blob: f70797dae2e9cb02a0867678f34dd42b4f4fb9d8 [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 */
Willy Tarreau12785782012-04-27 21:37:17 +0200842 struct sample_expr *expr;
843 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:
Willy Tarreau12785782012-04-27 21:37:17 +02001025 /* TODO: prune_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 &&
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001293 !strcmp(p->uri_auth->userlist->name, arg->data.str.area))
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};
2155static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2156 const char *file, int line, char **err)
2157{
Christopher Faulet95917132020-08-05 23:07:07 +02002158 enum input_type type;
2159
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002160 if (!arg) {
2161 memprintf(err, "Unexpected empty arg list");
2162 return 0;
2163 }
2164
2165 if (arg->type != ARGT_STR) {
2166 memprintf(err, "Unexpected arg type");
2167 return 0;
2168 }
2169
Christopher Faulet95917132020-08-05 23:07:07 +02002170 if (strcmp(arg->data.str.area, "") == 0)
2171 type = IT_ASCII;
2172 else if (strcmp(arg->data.str.area, "ascii") == 0)
2173 type = IT_ASCII;
2174 else if (strcmp(arg->data.str.area, "utf8") == 0)
2175 type = IT_UTF8;
2176 else if (strcmp(arg->data.str.area, "utf8s") == 0)
2177 type = IT_UTF8S;
2178 else if (strcmp(arg->data.str.area, "utf8p") == 0)
2179 type = IT_UTF8P;
2180 else if (strcmp(arg->data.str.area, "utf8ps") == 0)
2181 type = IT_UTF8PS;
2182 else {
2183 memprintf(err, "Unexpected input code type. "
2184 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
2185 return 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002186 }
2187
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002188 chunk_destroy(&arg->data.str);
Christopher Faulet95917132020-08-05 23:07:07 +02002189 arg->type = ARGT_SINT;
2190 arg->data.sint = type;
2191 return 1;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002192}
2193
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002194static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002195{
Willy Tarreau83061a82018-07-13 11:56:34 +02002196 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002197 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2198 const char *str;
2199 int len;
2200 enum input_type input_type = IT_ASCII;
2201 unsigned int c;
2202 unsigned int ret;
2203 char *p;
2204
2205 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002206 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002207
2208 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002209 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002210
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002211 p = smp->data.u.str.area;
2212 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002213
2214 if (input_type == IT_ASCII) {
2215 /* Read input as ASCII. */
2216 c = *(unsigned char *)p;
2217 p++;
2218 }
2219 else {
2220 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002221 ret = utf8_next(p,
2222 smp->data.u.str.data - ( p - smp->data.u.str.area),
2223 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002224 p += utf8_return_length(ret);
2225
2226 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2227 return 0;
2228 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2229 continue;
2230 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2231 return 0;
2232 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2233 continue;
2234
2235 /* Check too big values. */
2236 if ((unsigned int)c > 0xffff) {
2237 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2238 return 0;
2239 continue;
2240 }
2241 }
2242
2243 /* Convert character. */
2244 if (c == '"') {
2245 len = 2;
2246 str = "\\\"";
2247 }
2248 else if (c == '\\') {
2249 len = 2;
2250 str = "\\\\";
2251 }
2252 else if (c == '/') {
2253 len = 2;
2254 str = "\\/";
2255 }
2256 else if (c == '\b') {
2257 len = 2;
2258 str = "\\b";
2259 }
2260 else if (c == '\f') {
2261 len = 2;
2262 str = "\\f";
2263 }
2264 else if (c == '\r') {
2265 len = 2;
2266 str = "\\r";
2267 }
2268 else if (c == '\n') {
2269 len = 2;
2270 str = "\\n";
2271 }
2272 else if (c == '\t') {
2273 len = 2;
2274 str = "\\t";
2275 }
Willy Tarreau90807112020-02-25 08:16:33 +01002276 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002277 /* isprint generate a segfault if c is too big. The man says that
2278 * c must have the value of an unsigned char or EOF.
2279 */
2280 len = 6;
2281 _str[0] = '\\';
2282 _str[1] = 'u';
2283 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2284 str = _str;
2285 }
2286 else {
2287 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002288 _str[0] = c;
2289 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002290 }
2291
2292 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002293 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002294 return 0;
2295
2296 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002297 memcpy(temp->area + temp->data, str, len);
2298 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002299 }
2300
2301 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002302 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002303 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002304
2305 return 1;
2306}
2307
Emeric Brun54c4ac82014-11-03 15:32:43 +01002308/* This sample function is designed to extract some bytes from an input buffer.
2309 * First arg is the offset.
2310 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002311static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002312{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002313 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2314 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002315 return 1;
2316 }
2317
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002318 if (smp->data.u.str.size)
2319 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002320 smp->data.u.str.data -= arg_p[0].data.sint;
2321 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002322
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002323 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2324 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002325
2326 return 1;
2327}
2328
Emeric Brunf399b0d2014-11-03 17:07:03 +01002329static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2330 const char *file, int line, char **err)
2331{
2332 struct arg *arg = args;
2333
2334 if (!arg) {
2335 memprintf(err, "Unexpected empty arg list");
2336 return 0;
2337 }
2338
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002339 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002340 memprintf(err, "Unexpected arg type");
2341 return 0;
2342 }
2343
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002344 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002345 memprintf(err, "Unexpected value 0 for index");
2346 return 0;
2347 }
2348
2349 arg++;
2350
2351 if (arg->type != ARGT_STR) {
2352 memprintf(err, "Unexpected arg type");
2353 return 0;
2354 }
2355
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002356 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002357 memprintf(err, "Empty separators list");
2358 return 0;
2359 }
2360
2361 return 1;
2362}
2363
2364/* This sample function is designed to a return selected part of a string (field).
2365 * First arg is the index of the field (start at 1)
2366 * Second arg is a char list of separators (type string)
2367 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002368static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002369{
Marcin Deranek9631a282018-04-16 14:30:46 +02002370 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002371 char *start, *end;
2372 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002373 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002374
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002375 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002376 return 0;
2377
Marcin Deranek9631a282018-04-16 14:30:46 +02002378 if (arg_p[0].data.sint < 0) {
2379 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002380 end = start = smp->data.u.str.area + smp->data.u.str.data;
2381 while (start > smp->data.u.str.area) {
2382 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2383 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002384 if (field == arg_p[0].data.sint) {
2385 if (count == 1)
2386 goto found;
2387 else if (count > 1)
2388 count--;
2389 } else {
2390 end = start-1;
2391 field--;
2392 }
2393 break;
2394 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002395 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002396 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002397 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002398 } else {
2399 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002400 end = start = smp->data.u.str.area;
2401 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2402 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2403 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002404 if (field == arg_p[0].data.sint) {
2405 if (count == 1)
2406 goto found;
2407 else if (count > 1)
2408 count--;
2409 } else {
2410 start = end+1;
2411 field++;
2412 }
2413 break;
2414 }
2415 }
2416 end++;
2417 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002418 }
2419
2420 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002421 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002422 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002423 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002424 }
2425found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002426 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002427 /* If ret string is len 0, no need to
2428 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002429 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002430 return 1;
2431
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002432 smp->data.u.str.area = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002433
2434 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002435 Note: smp->data.u.str.size cannot be set to 0 */
2436 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002437 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002438
2439 return 1;
2440}
2441
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002442/* This sample function is designed to return a word from a string.
2443 * First arg is the index of the word (start at 1)
2444 * Second arg is a char list of words separators (type string)
2445 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002446static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002447{
Marcin Deranek9631a282018-04-16 14:30:46 +02002448 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002449 char *start, *end;
2450 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002451 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002452
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002453 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002454 return 0;
2455
2456 word = 0;
2457 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002458 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002459 end = start = smp->data.u.str.area + smp->data.u.str.data;
2460 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002461 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002462 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2463 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002464 issep = 1;
2465 break;
2466 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002467 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002468 if (!inword) {
2469 if (!issep) {
2470 if (word != arg_p[0].data.sint) {
2471 word--;
2472 end = start;
2473 }
2474 inword = 1;
2475 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002476 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002477 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002478 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002479 if (count == 1)
2480 goto found;
2481 else if (count > 1)
2482 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002483 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002484 inword = 0;
2485 }
2486 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002487 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002488 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002489 end = start = smp->data.u.str.area;
2490 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002491 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002492 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2493 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002494 issep = 1;
2495 break;
2496 }
2497 }
2498 if (!inword) {
2499 if (!issep) {
2500 if (word != arg_p[0].data.sint) {
2501 word++;
2502 start = end;
2503 }
2504 inword = 1;
2505 }
2506 }
2507 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002508 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002509 if (count == 1)
2510 goto found;
2511 else if (count > 1)
2512 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002513 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002514 inword = 0;
2515 }
2516 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002517 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002518 }
2519
2520 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002521 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002522 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002523 return 1;
2524 }
2525found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002526 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002527 /* If ret string is len 0, no need to
2528 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002529 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002530 return 1;
2531
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002532 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002533
2534 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002535 Note: smp->data.u.str.size cannot be set to 0 */
2536 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002537 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002538
2539 return 1;
2540}
2541
Willy Tarreau7eda8492015-01-20 19:47:06 +01002542static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2543 const char *file, int line, char **err)
2544{
2545 struct arg *arg = args;
2546 char *p;
2547 int len;
2548
2549 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2550 arg[0].type_flags = 0;
2551
2552 if (arg[2].type != ARGT_STR)
2553 return 1;
2554
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002555 p = arg[2].data.str.area;
2556 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002557 while (len) {
2558 if (*p == 'i') {
2559 arg[0].type_flags |= ARGF_REG_ICASE;
2560 }
2561 else if (*p == 'g') {
2562 arg[0].type_flags |= ARGF_REG_GLOB;
2563 }
2564 else {
2565 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2566 return 0;
2567 }
2568 p++;
2569 len--;
2570 }
2571 return 1;
2572}
2573
2574/* This sample function is designed to do the equivalent of s/match/replace/ on
2575 * the input string. It applies a regex and restarts from the last matched
2576 * location until nothing matches anymore. First arg is the regex to apply to
2577 * the input string, second arg is the replacement expression.
2578 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002579static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002580{
2581 char *start, *end;
2582 struct my_regex *reg = arg_p[0].data.reg;
2583 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002584 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002585 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002586 int flag, max;
2587 int found;
2588
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002589 start = smp->data.u.str.area;
2590 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002591
2592 flag = 0;
2593 while (1) {
2594 /* check for last round which is used to copy remaining parts
2595 * when not running in global replacement mode.
2596 */
2597 found = 0;
2598 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2599 /* Note: we can have start == end on empty strings or at the end */
2600 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2601 }
2602
2603 if (!found)
2604 pmatch[0].rm_so = end - start;
2605
2606 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002607 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002608 if (max && pmatch[0].rm_so > 0) {
2609 if (max > pmatch[0].rm_so)
2610 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002611 memcpy(trash->area + trash->data, start, max);
2612 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002613 }
2614
2615 if (!found)
2616 break;
2617
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002618 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002619 if (!output)
2620 break;
2621
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002622 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2623
Willy Tarreau7eda8492015-01-20 19:47:06 +01002624 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002625 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002626 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002627 if (max > output->data)
2628 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002629 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002630 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002631 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002632 }
2633
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002634 free_trash_chunk(output);
2635
Willy Tarreau7eda8492015-01-20 19:47:06 +01002636 /* stop here if we're done with this string */
2637 if (start >= end)
2638 break;
2639
2640 /* We have a special case for matches of length 0 (eg: "x*y*").
2641 * These ones are considered to match in front of a character,
2642 * so we have to copy that character and skip to the next one.
2643 */
2644 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002645 if (trash->data < trash->size)
2646 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002647 pmatch[0].rm_eo++;
2648 }
2649
2650 start += pmatch[0].rm_eo;
2651 flag |= REG_NOTBOL;
2652 }
2653
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002654 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002655 return 1;
2656}
2657
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002658/* This function check an operator entry. It expects a string.
2659 * The string can be an integer or a variable name.
2660 */
2661static int check_operator(struct arg *args, struct sample_conv *conv,
2662 const char *file, int line, char **err)
2663{
2664 const char *str;
2665 const char *end;
Christopher Faulet95917132020-08-05 23:07:07 +02002666 long long int i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002667
2668 /* Try to decode a variable. */
2669 if (vars_check_arg(&args[0], NULL))
2670 return 1;
2671
2672 /* Try to convert an integer */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002673 str = args[0].data.str.area;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002674 end = str + strlen(str);
Christopher Faulet95917132020-08-05 23:07:07 +02002675 i = read_int64(&str, end);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002676 if (*str != '\0') {
2677 memprintf(err, "expects an integer or a variable name");
2678 return 0;
2679 }
Christopher Faulet95917132020-08-05 23:07:07 +02002680
Christopher Faulet6ad7df42020-08-07 11:45:18 +02002681 chunk_destroy(&args[0].data.str);
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002682 args[0].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02002683 args[0].data.sint = i;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002684 return 1;
2685}
2686
Willy Tarreau6204cd92016-03-10 16:33:04 +01002687/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002688 * If the arg contain an integer, the integer is returned in the
2689 * sample. If the arg contains a variable descriptor, it returns the
2690 * variable value.
2691 *
2692 * This function returns 0 if an error occurs, otherwise it returns 1.
2693 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002694static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002695{
2696 switch (arg->type) {
2697 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002698 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002699 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002700 return 1;
2701 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002702 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002703 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002704 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002705 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002706 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002707 return 0;
2708 return 1;
2709 default:
2710 return 0;
2711 }
2712}
2713
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002714/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002715 * result.
2716 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002717static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002718{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002719 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002720 return 1;
2721}
2722
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002723/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002724 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002725 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002726static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002727{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002728 struct sample tmp;
2729
Willy Tarreau7560dd42016-03-10 16:28:58 +01002730 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002731 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002732 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002733 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002734 return 1;
2735}
2736
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002737/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002738 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002739 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002740static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002741{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002742 struct sample tmp;
2743
Willy Tarreau7560dd42016-03-10 16:28:58 +01002744 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002745 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002746 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002747 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002748 return 1;
2749}
2750
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002751/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002752 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002753 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002754static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002755{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002756 struct sample tmp;
2757
Willy Tarreau7560dd42016-03-10 16:28:58 +01002758 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002759 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002760 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002761 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002762 return 1;
2763}
2764
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002765static inline long long int arith_add(long long int a, long long int b)
2766{
2767 /* Prevent overflow and makes capped calculus.
2768 * We must ensure that the check calculus doesn't
2769 * exceed the signed 64 bits limits.
2770 *
2771 * +----------+----------+
2772 * | a<0 | a>=0 |
2773 * +------+----------+----------+
2774 * | b<0 | MIN-a>b | no check |
2775 * +------+----------+----------+
2776 * | b>=0 | no check | MAX-a<b |
2777 * +------+----------+----------+
2778 */
2779 if ((a ^ b) >= 0) {
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002780 /* signs are different. */
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002781 if (a < 0) {
2782 if (LLONG_MIN - a > b)
2783 return LLONG_MIN;
2784 }
2785 if (LLONG_MAX - a < b)
2786 return LLONG_MAX;
2787 }
2788 return a + b;
2789}
2790
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002791/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002792 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002793 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002794static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002795{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002796 struct sample tmp;
2797
Willy Tarreau7560dd42016-03-10 16:28:58 +01002798 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002799 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002800 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002801 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002802 return 1;
2803}
2804
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002805/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002806 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002807 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002808static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002809 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002810{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002811 struct sample tmp;
2812
Willy Tarreau7560dd42016-03-10 16:28:58 +01002813 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002814 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002815 return 0;
2816
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002817 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2818 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2819 * of -LLONG_MIN and correct the result.
2820 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002821 if (tmp.data.u.sint == LLONG_MIN) {
2822 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2823 if (smp->data.u.sint < LLONG_MAX)
2824 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002825 return 1;
2826 }
2827
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002828 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002829 * the second operand.
2830 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002831 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002832 return 1;
2833}
2834
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002835/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002836 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002837 * If the result makes an overflow, then the largest possible quantity is
2838 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002839 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002840static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002841 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002842{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002843 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002844 long long int c;
2845
Willy Tarreau7560dd42016-03-10 16:28:58 +01002846 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002847 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002848 return 0;
2849
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002850 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002851 if (!smp->data.u.sint || !tmp.data.u.sint) {
2852 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002853 return 1;
2854 }
2855
2856 /* The multiply between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002857 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002858 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002859 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2860 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002861 return 1;
2862 }
2863
2864 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002865 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002866
2867 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002868 if (smp->data.u.sint != c / tmp.data.u.sint) {
2869 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2870 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002871 return 1;
2872 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002873 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002874 return 1;
2875 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002876 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002877 return 1;
2878}
2879
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002880/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002881 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002882 * If arg_p makes the result overflow, then the largest possible quantity is
2883 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002884 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002885static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002886 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002887{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002888 struct sample tmp;
2889
Willy Tarreau7560dd42016-03-10 16:28:58 +01002890 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002891 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002892 return 0;
2893
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002894 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002895 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002896 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002897 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002898 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2899 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002900 return 1;
2901 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002902 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002903 return 1;
2904 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002905 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002906 return 1;
2907}
2908
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002909/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002910 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002911 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002912 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002913static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002914 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002915{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002916 struct sample tmp;
2917
Willy Tarreau7560dd42016-03-10 16:28:58 +01002918 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002919 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002920 return 0;
2921
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002922 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002923 /* The divide between LLONG_MIN and -1 returns a
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05002924 * "floating point exception".
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002925 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002926 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2927 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002928 return 1;
2929 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002930 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002931 return 1;
2932 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002933 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002934 return 1;
2935}
2936
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002937/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002938 * result.
2939 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002940static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002941 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002942{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002943 if (smp->data.u.sint == LLONG_MIN)
2944 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002945 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002946 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002947 return 1;
2948}
2949
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002950/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002951 * false. The output is a BOOL.
2952 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002953static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002954 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002955{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002956 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002957 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002958 return 1;
2959}
2960
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002961/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002962 * truee. The output is a BOOL.
2963 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002964static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002965 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002966{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002967 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002968 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002969 return 1;
2970}
2971
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002972/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002973 * The output is a BOOL.
2974 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002975static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002976 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002977{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002978 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002979 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002980 return 1;
2981}
2982
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002983/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002984 * The output is a BOOL.
2985 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002986static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002987 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002988{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002989 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002990 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002991 return 1;
2992}
2993
Willy Tarreau280f42b2018-02-19 15:34:12 +01002994/* appends an optional const string, an optional variable contents and another
2995 * optional const string to an existing string.
2996 */
2997static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2998{
Willy Tarreau83061a82018-07-13 11:56:34 +02002999 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003000 struct sample tmp;
3001 int max;
3002
3003 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003004 trash->data = smp->data.u.str.data;
3005 if (trash->data > trash->size - 1)
3006 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003007
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003008 memcpy(trash->area, smp->data.u.str.area, trash->data);
3009 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003010
3011 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003012 max = arg_p[0].data.str.data;
3013 if (max > trash->size - 1 - trash->data)
3014 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003015
3016 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003017 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3018 trash->data += max;
3019 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003020 }
3021
3022 /* append second string (variable) if it's found and we can turn it
3023 * into a string.
3024 */
3025 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3026 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3027 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3028 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3029
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003030 max = tmp.data.u.str.data;
3031 if (max > trash->size - 1 - trash->data)
3032 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003033
3034 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003035 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3036 max);
3037 trash->data += max;
3038 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003039 }
3040 }
3041
3042 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003043 max = arg_p[2].data.str.data;
3044 if (max > trash->size - 1 - trash->data)
3045 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003046
3047 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003048 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3049 trash->data += max;
3050 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003051 }
3052
3053 smp->data.u.str = *trash;
3054 smp->data.type = SMP_T_STR;
3055 return 1;
3056}
3057
3058/* This function checks the "concat" converter's arguments and extracts the
3059 * variable name and its scope.
3060 */
3061static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3062 const char *file, int line, char **err)
3063{
3064 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003065 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3066 memprintf(err, "failed to register variable name '%s'",
3067 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003068 return 0;
3069 }
3070 return 1;
3071}
3072
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003073/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003074 * is compatible with strcmp(3)'s return value.
3075 */
3076static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3077{
3078 struct sample tmp;
3079 int max, result;
3080
3081 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3082 if (arg_p[0].type != ARGT_VAR)
3083 return 0;
3084 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3085 return 0;
3086 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3087 return 0;
3088
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003089 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3090 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003091 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003092 if (smp->data.u.str.data != tmp.data.u.str.data) {
3093 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003094 result = -1;
3095 }
3096 else {
3097 result = 1;
3098 }
3099 }
3100 }
3101
3102 smp->data.u.sint = result;
3103 smp->data.type = SMP_T_SINT;
3104 return 1;
3105}
3106
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003107#ifdef USE_OPENSSL
3108/* Compares bytestring with a variable containing a bytestring. Return value
3109 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3110 *
3111 * Comparison will be performed in constant time if both bytestrings are of
3112 * the same length. If the lengths differ execution time will not be constant.
3113 */
3114static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3115{
3116 struct sample tmp;
3117 int result;
3118
3119 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3120 if (arg_p[0].type != ARGT_VAR)
3121 return 0;
3122 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3123 return 0;
3124 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3125 return 0;
3126
3127 if (smp->data.u.str.data != tmp.data.u.str.data) {
3128 smp->data.u.sint = 0;
3129 smp->data.type = SMP_T_BOOL;
3130 return 1;
3131 }
3132
3133 /* The following comparison is performed in constant time. */
3134 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3135
3136 smp->data.u.sint = result == 0;
3137 smp->data.type = SMP_T_BOOL;
3138 return 1;
3139}
3140#endif
3141
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02003142/* Takes a boolean as input. Returns the first argument if that boolean is true and
3143 * the second argument otherwise.
3144 */
3145static int sample_conv_iif(const struct arg *arg_p, struct sample *smp, void *private)
3146{
3147 smp->data.type = SMP_T_STR;
3148 smp->flags |= SMP_F_CONST;
3149
3150 if (smp->data.u.sint) {
3151 smp->data.u.str.data = arg_p[0].data.str.data;
3152 smp->data.u.str.area = arg_p[0].data.str.area;
3153 }
3154 else {
3155 smp->data.u.str.data = arg_p[1].data.str.data;
3156 smp->data.u.str.area = arg_p[1].data.str.area;
3157 }
3158
3159 return 1;
3160}
3161
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003162#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3163#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3164#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3165
3166/*
3167 * Extract the field value of an input binary sample. Takes a mandatory argument:
3168 * the protocol buffers field identifier (dotted notation) internally represented
3169 * as an array of unsigned integers and its size.
3170 * Return 1 if the field was found, 0 if not.
3171 */
3172static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3173{
3174 unsigned char *pos;
3175 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003176
3177 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003178 grpc_left = smp->data.u.str.data;
3179
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003180 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003181 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003182
3183 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3184
3185 pos += GRPC_MSG_HEADER_SZ;
3186 grpc_left -= GRPC_MSG_HEADER_SZ;
3187
3188 if (grpc_left < left)
3189 return 0;
3190
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003191 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3192 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003193
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003194 grpc_left -= grpc_msg_len;
3195 }
3196
3197 return 0;
3198}
3199
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003200static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3201{
3202 unsigned char *pos;
3203 size_t left;
3204
3205 pos = (unsigned char *)smp->data.u.str.area;
3206 left = smp->data.u.str.data;
3207
3208 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3209}
3210
3211static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3212 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003213{
3214 if (!args[1].type) {
3215 args[1].type = ARGT_SINT;
3216 args[1].data.sint = PBUF_T_BINARY;
3217 }
3218 else {
3219 int pbuf_type;
3220
3221 pbuf_type = protobuf_type(args[1].data.str.area);
3222 if (pbuf_type == -1) {
3223 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3224 return 0;
3225 }
3226
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003227 chunk_destroy(&args[1].data.str);
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003228 args[1].type = ARGT_SINT;
3229 args[1].data.sint = pbuf_type;
3230 }
3231
3232 return 1;
3233}
3234
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003235/*
3236 * Extract the tag value of an input binary sample. Takes a mandatory argument:
3237 * the FIX protocol tag identifier.
3238 * Return 1 if the tag was found, 0 if not.
3239 */
3240static int sample_conv_fix_tag_value(const struct arg *arg_p, struct sample *smp, void *private)
3241{
3242 struct ist value;
3243
3244 smp->flags &= ~SMP_F_MAY_CHANGE;
3245 value = fix_tag_value(ist2(smp->data.u.str.area, smp->data.u.str.data),
3246 arg_p[0].data.sint);
3247 if (!istlen(value)) {
3248 if (!isttest(value)) {
3249 /* value != IST_NULL, need more data */
3250 smp->flags |= SMP_F_MAY_CHANGE;
3251 }
3252 return 0;
3253 }
3254
3255 smp->data.u.str = ist2buf(value);
3256 smp->flags |= SMP_F_CONST;
3257
3258 return 1;
3259}
3260
3261/* This function checks the "fix_tag_value" converter configuration.
3262 * It expects a "known" (by HAProxy) tag name or ID.
3263 * Tag string names are converted to their ID counterpart because this is the
3264 * format they are sent over the wire.
3265 */
3266static int sample_conv_fix_value_check(struct arg *args, struct sample_conv *conv,
3267 const char *file, int line, char **err)
3268{
3269 struct ist str;
3270 unsigned int tag;
3271
3272 str = ist2(args[0].data.str.area, args[0].data.str.data);
3273 tag = fix_tagid(str);
3274 if (!tag) {
3275 memprintf(err, "Unknown FIX tag name '%s'", args[0].data.str.area);
3276 return 0;
3277 }
3278
3279 chunk_destroy(&args[0].data.str);
3280 args[0].type = ARGT_SINT;
3281 args[0].data.sint = tag;
3282
3283 return 1;
3284}
3285
3286/*
3287 * Checks that a buffer contains a valid FIX message
3288 *
3289 * Return 1 if the check could be run, 0 if not.
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003290 * The result of the analyse itself is stored in <smp> as a boolean
Baptiste Assmanne138dda2020-10-22 15:39:03 +02003291 */
3292static int sample_conv_fix_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3293{
3294 struct ist msg;
3295
3296 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3297
3298 smp->flags &= ~SMP_F_MAY_CHANGE;
3299 switch (fix_validate_message(msg)) {
3300 case FIX_VALID_MESSAGE:
3301 smp->data.type = SMP_T_BOOL;
3302 smp->data.u.sint = 1;
3303 return 1;
3304 case FIX_NEED_MORE_DATA:
3305 smp->flags |= SMP_F_MAY_CHANGE;
3306 return 0;
3307 case FIX_INVALID_MESSAGE:
3308 smp->data.type = SMP_T_BOOL;
3309 smp->data.u.sint = 0;
3310 return 1;
3311 }
3312 return 0;
3313}
3314
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003315/*
3316 * Extract the field value of an input binary sample containing an MQTT packet.
3317 * Takes 2 mandatory arguments:
3318 * - packet type
3319 * - field name
3320 *
3321 * return 1 if the field was found, 0 if not.
3322 */
3323static int sample_conv_mqtt_field_value(const struct arg *arg_p, struct sample *smp, void *private)
3324{
3325 struct ist pkt, value;
3326 int type, fieldname_id;
3327
3328 pkt = ist2(smp->data.u.str.area, smp->data.u.str.data);
3329 type = arg_p[0].data.sint;
3330 fieldname_id = arg_p[1].data.sint;
3331
3332 smp->flags &= ~SMP_F_MAY_CHANGE;
3333 value = mqtt_field_value(pkt, type, fieldname_id);
3334 if (!istlen(value)) {
3335 if (isttest(value)) {
3336 /* value != IST_NULL, need more data */
3337 smp->flags |= SMP_F_MAY_CHANGE;
3338 }
3339 return 0;
3340 }
3341
3342 smp->data.u.str = ist2buf(value);
3343 smp->flags |= SMP_F_CONST;
3344 return 1;
3345}
3346
3347/*
3348 * this function checks the "mqtt_field_value" converter configuration.
3349 * It expects a known packet type name or ID and a field name, in this order
3350 *
Ilya Shipitsinf38a0182020-12-21 01:16:17 +05003351 * Args[0] will be turned into a MQTT_CPT_* value for direct matching when parsing
Baptiste Assmanne279ca62020-10-27 18:10:06 +01003352 * a packet.
3353 */
3354static int sample_conv_mqtt_field_value_check(struct arg *args, struct sample_conv *conv,
3355 const char *file, int line, char **err)
3356{
3357 int type, fieldname_id;
3358
3359 /* check the MQTT packet type is valid */
3360 type = mqtt_typeid(ist2(args[0].data.str.area, args[0].data.str.data));
3361 if (type == MQTT_CPT_INVALID) {
3362 memprintf(err, "Unknown MQTT type '%s'", args[0].data.str.area);
3363 return 0;
3364 }
3365
3366 /* check the field name belongs to the MQTT packet type */
3367 fieldname_id = mqtt_check_type_fieldname(type, ist2(args[1].data.str.area, args[1].data.str.data));
3368 if (fieldname_id == MQTT_FN_INVALID) {
3369 memprintf(err, "Unknown MQTT field name '%s' for packet type '%s'", args[1].data.str.area,
3370 args[0].data.str.area);
3371 return 0;
3372 }
3373
3374 /* save numeric counterparts of type and field name */
3375 chunk_destroy(&args[0].data.str);
3376 chunk_destroy(&args[1].data.str);
3377 args[0].type = ARGT_SINT;
3378 args[0].data.sint = type;
3379 args[1].type = ARGT_SINT;
3380 args[1].data.sint = fieldname_id;
3381
3382 return 1;
3383}
3384
3385/*
3386 * Checks that <smp> contains a valid MQTT message
3387 *
3388 * The function returns 1 if the check was run to its end, 0 otherwise.
3389 * The result of the analyse itself is stored in <smp> as a boolean.
3390 */
3391static int sample_conv_mqtt_is_valid(const struct arg *arg_p, struct sample *smp, void *private)
3392{
3393 struct ist msg;
3394
3395 msg = ist2(smp->data.u.str.area, smp->data.u.str.data);
3396
3397 smp->flags &= ~SMP_F_MAY_CHANGE;
3398 switch (mqtt_validate_message(msg, NULL)) {
3399 case FIX_VALID_MESSAGE:
3400 smp->data.type = SMP_T_BOOL;
3401 smp->data.u.sint = 1;
3402 return 1;
3403 case FIX_NEED_MORE_DATA:
3404 smp->flags |= SMP_F_MAY_CHANGE;
3405 return 0;
3406 case FIX_INVALID_MESSAGE:
3407 smp->data.type = SMP_T_BOOL;
3408 smp->data.u.sint = 0;
3409 return 1;
3410 }
3411 return 0;
3412}
3413
Tim Duesterhusca097c12018-04-27 21:18:45 +02003414/* This function checks the "strcmp" converter's arguments and extracts the
3415 * variable name and its scope.
3416 */
3417static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3418 const char *file, int line, char **err)
3419{
3420 /* Try to decode a variable. */
3421 if (vars_check_arg(&args[0], NULL))
3422 return 1;
3423
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003424 memprintf(err, "failed to register variable name '%s'",
3425 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003426 return 0;
3427}
3428
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003429#ifdef USE_OPENSSL
3430/* This function checks the "secure_memcmp" converter's arguments and extracts the
3431 * variable name and its scope.
3432 */
3433static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3434 const char *file, int line, char **err)
3435{
3436 /* Try to decode a variable. */
3437 if (vars_check_arg(&args[0], NULL))
3438 return 1;
3439
3440 memprintf(err, "failed to register variable name '%s'",
3441 args[0].data.str.area);
3442 return 0;
3443}
3444#endif
3445
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003446/**/
3447static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3448{
3449 struct buffer *tmp;
3450 uint32_t n;
3451
3452 n = htonl((uint32_t)smp->data.u.sint);
3453 tmp = get_trash_chunk();
3454
3455 memcpy(b_head(tmp), &n, 4);
3456 b_add(tmp, 4);
3457
3458 smp->data.u.str = *tmp;
3459 smp->data.type = SMP_T_BIN;
3460 return 1;
3461}
3462
Christopher Fauletea159d62020-04-01 16:21:44 +02003463/**/
3464static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3465{
3466 char *p;
3467 size_t l;
3468
3469 p = smp->data.u.str.area;
3470 for (l = 0; l < smp->data.u.str.data; l++) {
3471 if (*(p+l) == '\r' || *(p+l) == '\n')
3472 break;
3473 }
3474 smp->data.u.str.data = l;
3475 return 1;
3476}
3477
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003478/**/
3479static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3480{
3481 char *delimiters, *p;
3482 size_t dlen, l;
3483
3484 delimiters = arg_p[0].data.str.area;
3485 dlen = arg_p[0].data.str.data;
3486
3487 l = smp->data.u.str.data;
3488 p = smp->data.u.str.area;
3489 while (l && memchr(delimiters, *p, dlen) != NULL) {
3490 p++;
3491 l--;
3492 }
3493
3494 smp->data.u.str.area = p;
3495 smp->data.u.str.data = l;
3496 return 1;
3497}
3498
Christopher Faulet568415a2020-04-01 17:24:47 +02003499/**/
3500static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3501{
3502 char *delimiters, *p;
3503 size_t dlen, l;
3504
3505 delimiters = arg_p[0].data.str.area;
3506 dlen = arg_p[0].data.str.data;
3507
3508 l = smp->data.u.str.data;
3509 p = smp->data.u.str.area + l - 1;
3510 while (l && memchr(delimiters, *p, dlen) != NULL) {
3511 p--;
3512 l--;
3513 }
3514
3515 smp->data.u.str.data = l;
3516 return 1;
3517}
3518
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003519/************************************************************************/
3520/* All supported sample fetch functions must be declared here */
3521/************************************************************************/
3522
3523/* force TRUE to be returned at the fetch level */
3524static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003525smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003526{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003527 if (!smp_make_rw(smp))
3528 return 0;
3529
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003530 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003531 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003532 return 1;
3533}
3534
3535/* force FALSE to be returned at the fetch level */
3536static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003537smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003538{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003539 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003540 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003541 return 1;
3542}
3543
3544/* retrieve environment variable $1 as a string */
3545static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003546smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003547{
3548 char *env;
3549
3550 if (!args || args[0].type != ARGT_STR)
3551 return 0;
3552
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003553 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003554 if (!env)
3555 return 0;
3556
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003557 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003558 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003559 smp->data.u.str.area = env;
3560 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003561 return 1;
3562}
3563
Damien Claisseae6f1252019-10-30 15:57:28 +00003564/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3565 * optional string representing the unit of the result: "s" for seconds, "ms" for
3566 * milliseconds and "us" for microseconds.
3567 * Returns 0 on error and non-zero if OK.
3568 */
3569int smp_check_date_unit(struct arg *args, char **err)
3570{
3571 if (args[1].type == ARGT_STR) {
Christopher Faulet95917132020-08-05 23:07:07 +02003572 long long int unit;
3573
Damien Claisseae6f1252019-10-30 15:57:28 +00003574 if (strcmp(args[1].data.str.area, "s") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003575 unit = TIME_UNIT_S;
Damien Claisseae6f1252019-10-30 15:57:28 +00003576 }
3577 else if (strcmp(args[1].data.str.area, "ms") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003578 unit = TIME_UNIT_MS;
Damien Claisseae6f1252019-10-30 15:57:28 +00003579 }
3580 else if (strcmp(args[1].data.str.area, "us") == 0) {
Christopher Faulet95917132020-08-05 23:07:07 +02003581 unit = TIME_UNIT_US;
Damien Claisseae6f1252019-10-30 15:57:28 +00003582 }
3583 else {
3584 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3585 args[1].data.str.area);
3586 return 0;
3587 }
Christopher Faulet95917132020-08-05 23:07:07 +02003588
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003589 chunk_destroy(&args[1].data.str);
Damien Claisseae6f1252019-10-30 15:57:28 +00003590 args[1].type = ARGT_SINT;
Christopher Faulet95917132020-08-05 23:07:07 +02003591 args[1].data.sint = unit;
Damien Claisseae6f1252019-10-30 15:57:28 +00003592 }
3593 else if (args[1].type != ARGT_STOP) {
3594 memprintf(err, "Unexpected arg type");
3595 return 0;
3596 }
3597
3598 return 1;
3599}
3600
3601/* retrieve the current local date in epoch time, converts it to milliseconds
3602 * or microseconds if asked to in optional args[1] unit param, and applies an
3603 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003604 */
3605static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003606smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003607{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003608 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003609
Damien Claisseae6f1252019-10-30 15:57:28 +00003610 /* report in milliseconds */
3611 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3612 smp->data.u.sint *= 1000;
3613 smp->data.u.sint += date.tv_usec / 1000;
3614 }
3615 /* report in microseconds */
3616 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3617 smp->data.u.sint *= 1000000;
3618 smp->data.u.sint += date.tv_usec;
3619 }
3620
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003621 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003622 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003623 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003624
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003625 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003626 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3627 return 1;
3628}
3629
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003630/* retrieve the current microsecond part of the date */
3631static int
3632smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3633{
3634 smp->data.u.sint = date.tv_usec;
3635 smp->data.type = SMP_T_SINT;
3636 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3637 return 1;
3638}
3639
3640
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003641/* returns the hostname */
3642static int
3643smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3644{
3645 smp->data.type = SMP_T_STR;
3646 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003647 smp->data.u.str.area = hostname;
3648 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003649 return 1;
3650}
3651
Willy Tarreau0f30d262014-11-24 16:02:05 +01003652/* returns the number of processes */
3653static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003654smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003655{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003656 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003657 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003658 return 1;
3659}
3660
3661/* returns the number of the current process (between 1 and nbproc */
3662static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003663smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003664{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003665 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003666 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003667 return 1;
3668}
3669
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003670/* returns the number of the current thread (between 1 and nbthread */
3671static int
3672smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3673{
3674 smp->data.type = SMP_T_SINT;
3675 smp->data.u.sint = tid;
3676 return 1;
3677}
3678
Willy Tarreau84310e22014-02-14 11:59:04 +01003679/* generate a random 32-bit integer for whatever purpose, with an optional
3680 * range specified in argument.
3681 */
3682static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003683smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003684{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003685 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003686
3687 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003688 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003689 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003690
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003691 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003692 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3693 return 1;
3694}
3695
Willy Tarreau0f30d262014-11-24 16:02:05 +01003696/* returns true if the current process is stopping */
3697static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003698smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003699{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003700 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003701 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003702 return 1;
3703}
3704
Willy Tarreau70fe9442018-11-22 16:07:39 +01003705/* returns the number of calls of the current stream's process_stream() */
3706static int
3707smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3708{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003709 if (!smp->strm)
3710 return 0;
3711
Willy Tarreau70fe9442018-11-22 16:07:39 +01003712 smp->data.type = SMP_T_SINT;
3713 smp->data.u.sint = smp->strm->task->calls;
3714 return 1;
3715}
3716
3717/* returns the average number of nanoseconds spent processing the stream per call */
3718static int
3719smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3720{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003721 if (!smp->strm)
3722 return 0;
3723
Willy Tarreau70fe9442018-11-22 16:07:39 +01003724 smp->data.type = SMP_T_SINT;
3725 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3726 return 1;
3727}
3728
3729/* returns the total number of nanoseconds spent processing the stream */
3730static int
3731smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3732{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003733 if (!smp->strm)
3734 return 0;
3735
Willy Tarreau70fe9442018-11-22 16:07:39 +01003736 smp->data.type = SMP_T_SINT;
3737 smp->data.u.sint = smp->strm->task->cpu_time;
3738 return 1;
3739}
3740
3741/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3742static int
3743smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3744{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003745 if (!smp->strm)
3746 return 0;
3747
Willy Tarreau70fe9442018-11-22 16:07:39 +01003748 smp->data.type = SMP_T_SINT;
3749 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3750 return 1;
3751}
3752
3753/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3754static int
3755smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3756{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003757 if (!smp->strm)
3758 return 0;
3759
Willy Tarreau70fe9442018-11-22 16:07:39 +01003760 smp->data.type = SMP_T_SINT;
3761 smp->data.u.sint = smp->strm->task->lat_time;
3762 return 1;
3763}
3764
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003765static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3766{
3767 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003768 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003769 smp->data.u.str.area = args[0].data.str.area;
3770 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003771 return 1;
3772}
3773
3774static int smp_check_const_bool(struct arg *args, char **err)
3775{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003776 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3777 strcasecmp(args[0].data.str.area, "1") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003778 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003779 args[0].type = ARGT_SINT;
3780 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003781 return 1;
3782 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003783 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3784 strcasecmp(args[0].data.str.area, "0") == 0) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003785 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003786 args[0].type = ARGT_SINT;
3787 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003788 return 1;
3789 }
3790 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3791 return 0;
3792}
3793
3794static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3795{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003796 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003797 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003798 return 1;
3799}
3800
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003801static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003802{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003803 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003804 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003805 return 1;
3806}
3807
3808static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3809{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003810 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003811 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003812 return 1;
3813}
3814
3815static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
3816{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003817 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003818 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003819 return 1;
3820}
3821
3822static int smp_check_const_bin(struct arg *args, char **err)
3823{
David Carlier64a16ab2016-04-08 10:37:02 +01003824 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003825 int binstrlen;
3826
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003827 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003828 return 0;
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003829 chunk_destroy(&args[0].data.str);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003830 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003831 args[0].data.str.area = binstr;
3832 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003833 return 1;
3834}
3835
3836static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3837{
3838 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003839 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003840 smp->data.u.str.area = args[0].data.str.area;
3841 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003842 return 1;
3843}
3844
3845static int smp_check_const_meth(struct arg *args, char **err)
3846{
3847 enum http_meth_t meth;
3848 int i;
3849
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003850 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003851 if (meth != HTTP_METH_OTHER) {
Christopher Faulet6ad7df42020-08-07 11:45:18 +02003852 chunk_destroy(&args[0].data.str);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003853 args[0].type = ARGT_SINT;
3854 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003855 } else {
Ilya Shipitsin6b79f382020-07-23 00:32:55 +05003856 /* Check method avalaibility. A method is a token defined as :
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003857 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3858 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3859 * token = 1*tchar
3860 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003861 for (i = 0; i < args[0].data.str.data; i++) {
3862 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003863 memprintf(err, "expects valid method.");
3864 return 0;
3865 }
3866 }
3867 }
3868 return 1;
3869}
3870
3871static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3872{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003873 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003874 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003875 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003876 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003877 smp->data.u.meth.str.area = "";
3878 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003879 } else {
3880 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003881 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003882 smp->data.u.meth.str.area = args[0].data.str.area;
3883 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003884 }
3885 return 1;
3886}
3887
Luca Schimweg8a694b82019-09-10 15:42:52 +02003888// This function checks the "uuid" sample's arguments.
3889// Function won't get called when no parameter is specified (maybe a bug?)
3890static int smp_check_uuid(struct arg *args, char **err)
3891{
3892 if (!args[0].type) {
3893 args[0].type = ARGT_SINT;
3894 args[0].data.sint = 4;
3895 }
3896 else if (args[0].data.sint != 4) {
3897 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3898 return 0;
3899 }
3900
3901 return 1;
3902}
3903
3904// Generate a RFC4122 UUID (default is v4 = fully random)
3905static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3906{
3907 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003908 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003909 smp->data.type = SMP_T_STR;
3910 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3911 smp->data.u.str = trash;
3912 return 1;
3913 }
3914
3915 // more implementations of other uuid formats possible here
3916 return 0;
3917}
3918
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003919/* Note: must not be declared <const> as its list will be overwritten.
3920 * Note: fetches that may return multiple types must be declared as the lowest
3921 * common denominator, the type that can be casted into all other ones. For
3922 * instance IPv4/IPv6 must be declared IPv4.
3923 */
3924static struct sample_fetch_kw_list smp_kws = {ILH, {
3925 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3926 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003927 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003928 { "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 +01003929 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003930 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003931 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3932 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003933 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003934 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003935 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003936 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003937 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003938
3939 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3940 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3941 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3942 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3943 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003944
3945 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3946 { "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 +02003947 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003948 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3949 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3950 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3951 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3952
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003953 { /* END */ },
3954}};
3955
Willy Tarreau0108d902018-11-25 19:14:37 +01003956INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3957
Emeric Brun107ca302010-01-04 16:16:05 +01003958/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003959static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003960 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003961 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003962 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003963 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3964 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003965 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003966 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003967 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003968 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003969 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3970 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003971 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003972 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003973 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3974 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3975 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Dragan Dosen04bf0cc2020-12-22 21:44:33 +01003976 { "xxh3", sample_conv_xxh3, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003977 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3978 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003979 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003980 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003981 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3982 { "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 +01003983 { "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 +02003984 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003985#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003986 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003987#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3988 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3989#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003990 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3991 { "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 +02003992#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003993 { "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 +02003994 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003995#ifdef USE_OPENSSL
3996 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3997#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003998
3999 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01004000 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
4001 { "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 +01004002
Baptiste Assmanne138dda2020-10-22 15:39:03 +02004003 /* FIX converters */
4004 { "fix_is_valid", sample_conv_fix_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4005 { "fix_tag_value", sample_conv_fix_tag_value, ARG1(1,STR), sample_conv_fix_value_check, SMP_T_BIN, SMP_T_BIN },
4006
Baptiste Assmanne279ca62020-10-27 18:10:06 +01004007 /* MQTT converters */
4008 { "mqtt_is_valid", sample_conv_mqtt_is_valid, 0, NULL, SMP_T_BIN, SMP_T_BOOL },
4009 { "mqtt_field_value", sample_conv_mqtt_field_value, ARG2(2,STR,STR), sample_conv_mqtt_field_value_check, SMP_T_BIN, SMP_T_STR },
4010
Tim Duesterhus3943e4f2020-09-11 14:25:23 +02004011 { "iif", sample_conv_iif, ARG2(2, STR, STR), NULL, SMP_T_BOOL, SMP_T_STR },
4012
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02004013 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4014 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4015 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4016 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
4017 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4018 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4019 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4020 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
4021 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4022 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4023 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4024 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4025 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
4026 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01004027
Christopher Fauletea159d62020-04-01 16:21:44 +02004028 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
4029 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02004030 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02004031 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02004032 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01004033}};
4034
Willy Tarreau0108d902018-11-25 19:14:37 +01004035INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);