blob: 4ee44cf493799ca624fd3f9ba231627897119d02 [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 Tarreau4c7e4b72020-05-27 12:58:42 +020019#include <haproxy/api.h>
Willy Tarreau7e2c6472012-10-29 20:44:36 +010020
Willy Tarreauac13aea2020-06-04 10:36:03 +020021#include <haproxy/auth.h>
Willy Tarreau16f958c2020-06-03 08:44:35 +020022#include <haproxy/buf.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020023#include <haproxy/chunk.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020024#include <haproxy/errors.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020025#include <haproxy/global.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020026#include <haproxy/hash.h>
Willy Tarreaucd72d8c2020-06-02 19:11:26 +020027#include <haproxy/http.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +020028#include <haproxy/net_helper.h>
Willy Tarreaub23e5952020-06-04 16:06:59 +020029#include <haproxy/protobuf.h>
Willy Tarreaua264d962020-06-04 22:29:18 +020030#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +020031#include <haproxy/regex.h>
Willy Tarreaue6ce10b2020-06-04 15:33:47 +020032#include <haproxy/sample.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020033#include <haproxy/tools.h>
Willy Tarreau8c42b8a2020-06-04 19:27:34 +020034#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +020035#include <haproxy/vars.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020036#include <haproxy/base64.h>
Willy Tarreaucd3b0942012-04-27 21:52:18 +020037
Willy Tarreauaa74c4e2020-06-04 10:19:23 +020038#include <haproxy/arg.h>
Willy Tarreauba2f73d2020-06-03 20:02:28 +020039#include <haproxy/sink.h>
Willy Tarreau872f2ea2020-06-04 18:46:44 +020040#include <haproxy/stick_table.h>
Emeric Brun107ca302010-01-04 16:16:05 +010041
Dragan Dosen6e5a9ca2017-10-24 09:18:23 +020042#include <import/sha1.h>
Thierry FOURNIER01e09742016-12-26 11:46:11 +010043#include <import/xxhash.h>
44
Willy Tarreau1cf8f082014-02-07 12:14:54 +010045/* sample type names */
46const char *smp_to_type[SMP_TYPES] = {
Thierry FOURNIER9c627e82015-06-03 20:12:35 +020047 [SMP_T_ANY] = "any",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010048 [SMP_T_BOOL] = "bool",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010049 [SMP_T_SINT] = "sint",
50 [SMP_T_ADDR] = "addr",
51 [SMP_T_IPV4] = "ipv4",
52 [SMP_T_IPV6] = "ipv6",
53 [SMP_T_STR] = "str",
54 [SMP_T_BIN] = "bin",
Thierry FOURNIER4c2479e2015-06-03 20:12:04 +020055 [SMP_T_METH] = "meth",
Willy Tarreau1cf8f082014-02-07 12:14:54 +010056};
57
Willy Tarreau12785782012-04-27 21:37:17 +020058/* static sample used in sample_process() when <p> is NULL */
Emeric Brune5c918b2017-06-14 14:15:36 +020059static THREAD_LOCAL struct sample temp_smp;
Emeric Brun107ca302010-01-04 16:16:05 +010060
Willy Tarreau12785782012-04-27 21:37:17 +020061/* list head of all known sample fetch keywords */
62static struct sample_fetch_kw_list sample_fetches = {
63 .list = LIST_HEAD_INIT(sample_fetches.list)
Emeric Brun107ca302010-01-04 16:16:05 +010064};
65
Willy Tarreau12785782012-04-27 21:37:17 +020066/* list head of all known sample format conversion keywords */
67static struct sample_conv_kw_list sample_convs = {
68 .list = LIST_HEAD_INIT(sample_convs.list)
Emeric Brun107ca302010-01-04 16:16:05 +010069};
70
Willy Tarreau80aca902013-01-07 15:42:20 +010071const unsigned int fetch_cap[SMP_SRC_ENTRIES] = {
72 [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
73 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
74 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
75 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
76 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
77 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010078 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +010079
80 [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
81 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
82 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
83 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
84 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
85 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010086 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010087
88 [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
89 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
90 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
91 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
92 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
93 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +010094 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +010095
96 [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
97 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
98 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
99 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
100 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
101 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100102 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100103
104 [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
105 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
106 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
107 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
108 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
109 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100110 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100111
112 [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT |
113 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
114 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
115 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
116 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
117 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100118 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100119
120 [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
121 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
122 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
123 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
124 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
125 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100126 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100127
128 [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
129 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
130 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
131 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
132 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
133 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100134 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100135
136 [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT |
137 SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
138 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
139 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
140 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
141 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100142 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100143
144 [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
145 SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK |
146 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
147 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ |
148 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
149 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100150 SMP_VAL___________ | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100151
152 [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
153 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
154 SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY |
155 SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
156 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
157 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100158 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100159
160 [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
161 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
162 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
163 SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT |
164 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
165 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100166 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100167
168 [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
169 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
170 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
171 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
172 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
173 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100174 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100175
176 [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
177 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
178 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
179 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
180 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
181 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100182 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100183
184 [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
185 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
186 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
187 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
188 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
189 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200190 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100191
192 [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
193 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
194 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
195 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
196 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
197 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200198 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100199
200 [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
201 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
202 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
203 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT |
204 SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
205 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200206 SMP_VAL_FE_LOG_END | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100207
208 [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
209 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_BE_HRS_BDY | SMP_VAL_BE_STO_RUL |
213 SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY |
Christopher Faulete596d182020-05-05 17:46:34 +0200214 SMP_VAL___________ | SMP_VAL_BE_CHK_RUL),
Willy Tarreau80aca902013-01-07 15:42:20 +0100215
216 [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
217 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
218 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
219 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
220 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
221 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100222 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100223
224 [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
225 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
226 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
227 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
228 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
229 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100230 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100231
232 [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
233 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
234 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
235 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
236 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
237 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100238 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100239
240 [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
241 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
242 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
243 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
244 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
245 SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ |
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100246 SMP_VAL_FE_LOG_END | SMP_VAL___________),
Willy Tarreau80aca902013-01-07 15:42:20 +0100247};
248
249static const char *fetch_src_names[SMP_SRC_ENTRIES] = {
250 [SMP_SRC_INTRN] = "internal state",
251 [SMP_SRC_LISTN] = "listener",
252 [SMP_SRC_FTEND] = "frontend",
253 [SMP_SRC_L4CLI] = "client address",
254 [SMP_SRC_L5CLI] = "client-side connection",
255 [SMP_SRC_TRACK] = "track counters",
256 [SMP_SRC_L6REQ] = "request buffer",
257 [SMP_SRC_HRQHV] = "HTTP request headers",
258 [SMP_SRC_HRQHP] = "HTTP request",
259 [SMP_SRC_HRQBO] = "HTTP request body",
260 [SMP_SRC_BKEND] = "backend",
261 [SMP_SRC_SERVR] = "server",
262 [SMP_SRC_L4SRV] = "server address",
263 [SMP_SRC_L5SRV] = "server-side connection",
264 [SMP_SRC_L6RES] = "response buffer",
265 [SMP_SRC_HRSHV] = "HTTP response headers",
266 [SMP_SRC_HRSHP] = "HTTP response",
267 [SMP_SRC_HRSBO] = "HTTP response body",
268 [SMP_SRC_RQFIN] = "request buffer statistics",
269 [SMP_SRC_RSFIN] = "response buffer statistics",
270 [SMP_SRC_TXFIN] = "transaction statistics",
271 [SMP_SRC_SSFIN] = "session statistics",
272};
273
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100274static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = {
275 [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule",
276 [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule",
277 [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule",
278 [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule",
279 [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule",
280 [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule",
281 [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule",
282 [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule",
283 [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule",
284 [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule",
285 [SMP_CKP_BE_SRV_CON] = "server source selection",
286 [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule",
287 [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule",
288 [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule",
289 [SMP_CKP_BE_STO_RUL] = "backend stick-store rule",
290 [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule",
291 [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule",
292 [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule",
293 [SMP_CKP_FE_LOG_END] = "logs",
Gaetan Rivet707b52f2020-02-21 18:14:59 +0100294 [SMP_CKP_BE_CHK_RUL] = "backend tcp-check rule",
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100295};
296
Thierry FOURNIER348971e2013-11-21 10:50:10 +0100297/* This function returns the type of the data returned by the sample_expr.
298 * It assumes that the <expr> and all of its converters are properly
299 * initialized.
300 */
301inline
302int smp_expr_output_type(struct sample_expr *expr)
303{
304 struct sample_conv_expr *smp_expr;
305
306 if (!LIST_ISEMPTY(&expr->conv_exprs)) {
307 smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list);
308 return smp_expr->conv->out_type;
309 }
310 return expr->fetch->out_type;
311}
312
313
Willy Tarreau80aca902013-01-07 15:42:20 +0100314/* fill the trash with a comma-delimited list of source names for the <use> bit
315 * field which must be composed of a non-null set of SMP_USE_* flags. The return
316 * value is the pointer to the string in the trash buffer.
317 */
318const char *sample_src_names(unsigned int use)
319{
320 int bit;
321
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200322 trash.data = 0;
323 trash.area[0] = '\0';
Willy Tarreau80aca902013-01-07 15:42:20 +0100324 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) {
325 if (!(use & ~((1 << bit) - 1)))
326 break; /* no more bits */
327
328 if (!(use & (1 << bit)))
329 continue; /* bit not set */
330
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200331 trash.data += snprintf(trash.area + trash.data,
332 trash.size - trash.data, "%s%s",
333 (use & ((1 << bit) - 1)) ? "," : "",
334 fetch_src_names[bit]);
Willy Tarreau80aca902013-01-07 15:42:20 +0100335 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200336 return trash.area;
Willy Tarreau80aca902013-01-07 15:42:20 +0100337}
338
Willy Tarreaubf8e2512013-03-25 14:52:41 +0100339/* return a pointer to the correct sample checkpoint name, or "unknown" when
340 * the flags are invalid. Only the lowest bit is used, higher bits are ignored
341 * if set.
342 */
343const char *sample_ckp_names(unsigned int use)
344{
345 int bit;
346
347 for (bit = 0; bit < SMP_CKP_ENTRIES; bit++)
348 if (use & (1 << bit))
349 return fetch_ckp_names[bit];
350 return "unknown sample check place, please report this bug";
351}
352
Emeric Brun107ca302010-01-04 16:16:05 +0100353/*
Willy Tarreau80aca902013-01-07 15:42:20 +0100354 * Registers the sample fetch keyword list <kwl> as a list of valid keywords
355 * for next parsing sessions. The fetch keywords capabilities are also computed
356 * from their ->use field.
Emeric Brun107ca302010-01-04 16:16:05 +0100357 */
Willy Tarreau80aca902013-01-07 15:42:20 +0100358void sample_register_fetches(struct sample_fetch_kw_list *kwl)
Emeric Brun107ca302010-01-04 16:16:05 +0100359{
Willy Tarreau80aca902013-01-07 15:42:20 +0100360 struct sample_fetch *sf;
361 int bit;
362
363 for (sf = kwl->kw; sf->kw != NULL; sf++) {
364 for (bit = 0; bit < SMP_SRC_ENTRIES; bit++)
365 if (sf->use & (1 << bit))
366 sf->val |= fetch_cap[bit];
367 }
368 LIST_ADDQ(&sample_fetches.list, &kwl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100369}
370
371/*
Willy Tarreau12785782012-04-27 21:37:17 +0200372 * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next
Emeric Brun107ca302010-01-04 16:16:05 +0100373 * parsing sessions.
374 */
Willy Tarreau12785782012-04-27 21:37:17 +0200375void sample_register_convs(struct sample_conv_kw_list *pckl)
Emeric Brun107ca302010-01-04 16:16:05 +0100376{
Willy Tarreau12785782012-04-27 21:37:17 +0200377 LIST_ADDQ(&sample_convs.list, &pckl->list);
Emeric Brun107ca302010-01-04 16:16:05 +0100378}
379
380/*
Willy Tarreau12785782012-04-27 21:37:17 +0200381 * Returns the pointer on sample fetch keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100382 * string of <len> in buffer <kw>.
383 *
384 */
Willy Tarreau12785782012-04-27 21:37:17 +0200385struct sample_fetch *find_sample_fetch(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100386{
387 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200388 struct sample_fetch_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100389
Willy Tarreau12785782012-04-27 21:37:17 +0200390 list_for_each_entry(kwl, &sample_fetches.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100391 for (index = 0; kwl->kw[index].kw != NULL; index++) {
392 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
393 kwl->kw[index].kw[len] == '\0')
394 return &kwl->kw[index];
395 }
396 }
397 return NULL;
398}
399
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100400/* This function browses the list of available sample fetches. <current> is
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100401 * the last used sample fetch. If it is the first call, it must set to NULL.
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100402 * <idx> is the index of the next sample fetch entry. It is used as private
403 * value. It is useless to initiate it.
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100404 *
Tim Duesterhusc555ee02018-01-25 16:24:44 +0100405 * It returns always the new fetch_sample entry, and NULL when the end of
Thierry FOURNIER4d9a1d12014-12-08 14:49:19 +0100406 * the list is reached.
407 */
408struct sample_fetch *sample_fetch_getnext(struct sample_fetch *current, int *idx)
409{
410 struct sample_fetch_kw_list *kwl;
411 struct sample_fetch *base;
412
413 if (!current) {
414 /* Get first kwl entry. */
415 kwl = LIST_NEXT(&sample_fetches.list, struct sample_fetch_kw_list *, list);
416 (*idx) = 0;
417 } else {
418 /* Get kwl corresponding to the curret entry. */
419 base = current + 1 - (*idx);
420 kwl = container_of(base, struct sample_fetch_kw_list, kw);
421 }
422
423 while (1) {
424
425 /* Check if kwl is the last entry. */
426 if (&kwl->list == &sample_fetches.list)
427 return NULL;
428
429 /* idx contain the next keyword. If it is available, return it. */
430 if (kwl->kw[*idx].kw) {
431 (*idx)++;
432 return &kwl->kw[(*idx)-1];
433 }
434
435 /* get next entry in the main list, and return NULL if the end is reached. */
436 kwl = LIST_NEXT(&kwl->list, struct sample_fetch_kw_list *, list);
437
438 /* Set index to 0, ans do one other loop. */
439 (*idx) = 0;
440 }
441}
442
Thierry FOURNIER8fd13762015-03-10 23:56:48 +0100443/* This function browses the list of available converters. <current> is
444 * the last used converter. If it is the first call, it must set to NULL.
445 * <idx> is the index of the next converter entry. It is used as private
446 * value. It is useless to initiate it.
447 *
448 * It returns always the next sample_conv entry, and NULL when the end of
449 * the list is reached.
450 */
451struct sample_conv *sample_conv_getnext(struct sample_conv *current, int *idx)
452{
453 struct sample_conv_kw_list *kwl;
454 struct sample_conv *base;
455
456 if (!current) {
457 /* Get first kwl entry. */
458 kwl = LIST_NEXT(&sample_convs.list, struct sample_conv_kw_list *, list);
459 (*idx) = 0;
460 } else {
461 /* Get kwl corresponding to the curret entry. */
462 base = current + 1 - (*idx);
463 kwl = container_of(base, struct sample_conv_kw_list, kw);
464 }
465
466 while (1) {
467 /* Check if kwl is the last entry. */
468 if (&kwl->list == &sample_convs.list)
469 return NULL;
470
471 /* idx contain the next keyword. If it is available, return it. */
472 if (kwl->kw[*idx].kw) {
473 (*idx)++;
474 return &kwl->kw[(*idx)-1];
475 }
476
477 /* get next entry in the main list, and return NULL if the end is reached. */
478 kwl = LIST_NEXT(&kwl->list, struct sample_conv_kw_list *, list);
479
480 /* Set index to 0, ans do one other loop. */
481 (*idx) = 0;
482 }
483}
484
Emeric Brun107ca302010-01-04 16:16:05 +0100485/*
Willy Tarreau12785782012-04-27 21:37:17 +0200486 * Returns the pointer on sample format conversion keyword structure identified by
Emeric Brun107ca302010-01-04 16:16:05 +0100487 * string of <len> in buffer <kw>.
488 *
489 */
Willy Tarreau12785782012-04-27 21:37:17 +0200490struct sample_conv *find_sample_conv(const char *kw, int len)
Emeric Brun107ca302010-01-04 16:16:05 +0100491{
492 int index;
Willy Tarreau12785782012-04-27 21:37:17 +0200493 struct sample_conv_kw_list *kwl;
Emeric Brun107ca302010-01-04 16:16:05 +0100494
Willy Tarreau12785782012-04-27 21:37:17 +0200495 list_for_each_entry(kwl, &sample_convs.list, list) {
Emeric Brun107ca302010-01-04 16:16:05 +0100496 for (index = 0; kwl->kw[index].kw != NULL; index++) {
497 if (strncmp(kwl->kw[index].kw, kw, len) == 0 &&
498 kwl->kw[index].kw[len] == '\0')
499 return &kwl->kw[index];
500 }
501 }
502 return NULL;
503}
504
Emeric Brun107ca302010-01-04 16:16:05 +0100505/******************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200506/* Sample casts functions */
Emeric Brun107ca302010-01-04 16:16:05 +0100507/******************************************************************/
508
Willy Tarreau342acb42012-04-23 22:03:39 +0200509static int c_ip2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100510{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200511 smp->data.u.sint = ntohl(smp->data.u.ipv4.s_addr);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200512 smp->data.type = SMP_T_SINT;
Emeric Brun107ca302010-01-04 16:16:05 +0100513 return 1;
514}
515
Willy Tarreau342acb42012-04-23 22:03:39 +0200516static int c_ip2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100517{
Willy Tarreau83061a82018-07-13 11:56:34 +0200518 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100519
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200520 if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
Emeric Brun107ca302010-01-04 16:16:05 +0100521 return 0;
522
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200523 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200524 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200525 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100526 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100527
528 return 1;
529}
530
Willy Tarreau342acb42012-04-23 22:03:39 +0200531static int c_ip2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100532{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200533 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200534 smp->data.type = SMP_T_IPV6;
David du Colombier4f92d322011-03-24 11:09:31 +0100535 return 1;
536}
537
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200538static int c_ipv62ip(struct sample *smp)
539{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200540 if (!v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6))
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200541 return 0;
Tim Duesterhusbf5ce022018-01-25 16:24:46 +0100542 smp->data.type = SMP_T_IPV4;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200543 return 1;
544}
545
Willy Tarreau342acb42012-04-23 22:03:39 +0200546static int c_ipv62str(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100547{
Willy Tarreau83061a82018-07-13 11:56:34 +0200548 struct buffer *trash = get_trash_chunk();
David du Colombier4f92d322011-03-24 11:09:31 +0100549
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200550 if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
David du Colombier4f92d322011-03-24 11:09:31 +0100551 return 0;
552
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200553 trash->data = strlen(trash->area);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200554 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200555 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100556 smp->flags &= ~SMP_F_CONST;
David du Colombier4f92d322011-03-24 11:09:31 +0100557 return 1;
558}
559
560/*
Willy Tarreau342acb42012-04-23 22:03:39 +0200561static int c_ipv62ip(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100562{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200563 return v6tov4(&smp->data.u.ipv4, &smp->data.u.ipv6);
David du Colombier4f92d322011-03-24 11:09:31 +0100564}
565*/
566
Willy Tarreau342acb42012-04-23 22:03:39 +0200567static int c_int2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100568{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200569 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200570 smp->data.type = SMP_T_IPV4;
Emeric Brun107ca302010-01-04 16:16:05 +0100571 return 1;
572}
573
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200574static int c_int2ipv6(struct sample *smp)
575{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200576 smp->data.u.ipv4.s_addr = htonl((unsigned int)smp->data.u.sint);
577 v4tov6(&smp->data.u.ipv6, &smp->data.u.ipv4);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200578 smp->data.type = SMP_T_IPV6;
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200579 return 1;
580}
581
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100582static int c_str2addr(struct sample *smp)
583{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200584 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4)) {
585 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100586 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200587 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100588 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100589 return 1;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100590 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200591 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100592 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100593 return 1;
594}
595
Willy Tarreau342acb42012-04-23 22:03:39 +0200596static int c_str2ip(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100597{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200598 if (!buf2ip(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv4))
Emeric Brun107ca302010-01-04 16:16:05 +0100599 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200600 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100601 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100602 return 1;
603}
604
Willy Tarreau342acb42012-04-23 22:03:39 +0200605static int c_str2ipv6(struct sample *smp)
David du Colombier4f92d322011-03-24 11:09:31 +0100606{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200607 if (!buf2ip6(smp->data.u.str.area, smp->data.u.str.data, &smp->data.u.ipv6))
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100608 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200609 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100610 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIERfd139902013-12-11 12:38:57 +0100611 return 1;
David du Colombier4f92d322011-03-24 11:09:31 +0100612}
613
Emeric Brun4b9e8022014-11-03 18:17:10 +0100614/*
615 * The NULL char always enforces the end of string if it is met.
616 * Data is never changed, so we can ignore the CONST case
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100617 */
Emeric Brun8ac33d92012-10-17 13:36:06 +0200618static int c_bin2str(struct sample *smp)
619{
Emeric Brun4b9e8022014-11-03 18:17:10 +0100620 int i;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200621
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200622 for (i = 0; i < smp->data.u.str.data; i++) {
623 if (!smp->data.u.str.area[i]) {
624 smp->data.u.str.data = i;
Thierry FOURNIERe87cac12014-03-12 15:07:59 +0100625 break;
Emeric Brun4b9e8022014-11-03 18:17:10 +0100626 }
Emeric Brun8ac33d92012-10-17 13:36:06 +0200627 }
Christopher Faulet472ad512020-04-30 09:57:40 +0200628 smp->data.type = SMP_T_STR;
Emeric Brun8ac33d92012-10-17 13:36:06 +0200629 return 1;
630}
631
Willy Tarreau342acb42012-04-23 22:03:39 +0200632static int c_int2str(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100633{
Willy Tarreau83061a82018-07-13 11:56:34 +0200634 struct buffer *trash = get_trash_chunk();
Emeric Brun107ca302010-01-04 16:16:05 +0100635 char *pos;
636
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200637 pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
Emeric Brun107ca302010-01-04 16:16:05 +0100638 if (!pos)
639 return 0;
640
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200641 trash->size = trash->size - (pos - trash->area);
642 trash->area = pos;
643 trash->data = strlen(pos);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200644 smp->data.u.str = *trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200645 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100646 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100647 return 1;
648}
649
Joseph Herlant757f5ad2018-11-15 12:14:56 -0800650/* This function unconditionally duplicates data and removes the "const" flag.
Willy Tarreauad635822016-08-08 19:21:09 +0200651 * For strings and binary blocks, it also provides a known allocated size with
652 * a length that is capped to the size, and ensures a trailing zero is always
653 * appended for strings. This is necessary for some operations which may
654 * require to extend the length. It returns 0 if it fails, 1 on success.
655 */
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100656int smp_dup(struct sample *smp)
Emeric Brun485479d2010-09-23 18:02:19 +0200657{
Willy Tarreau83061a82018-07-13 11:56:34 +0200658 struct buffer *trash;
Emeric Brun485479d2010-09-23 18:02:19 +0200659
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200660 switch (smp->data.type) {
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100661 case SMP_T_BOOL:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100662 case SMP_T_SINT:
663 case SMP_T_ADDR:
664 case SMP_T_IPV4:
665 case SMP_T_IPV6:
666 /* These type are not const. */
667 break;
Willy Tarreauad635822016-08-08 19:21:09 +0200668
Christopher Fauletec100512017-07-24 15:38:41 +0200669 case SMP_T_METH:
670 if (smp->data.u.meth.meth != HTTP_METH_OTHER)
671 break;
672 /* Fall through */
673
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100674 case SMP_T_STR:
Willy Tarreauad635822016-08-08 19:21:09 +0200675 trash = get_trash_chunk();
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100676 trash->data = smp->data.type == SMP_T_STR ?
677 smp->data.u.str.data : smp->data.u.meth.str.data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200678 if (trash->data > trash->size - 1)
679 trash->data = trash->size - 1;
Willy Tarreauad635822016-08-08 19:21:09 +0200680
Olivier Houchard4468f1c2018-12-07 15:23:41 +0100681 memcpy(trash->area, smp->data.type == SMP_T_STR ?
682 smp->data.u.str.area : smp->data.u.meth.str.area,
683 trash->data);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200684 trash->area[trash->data] = 0;
Willy Tarreauad635822016-08-08 19:21:09 +0200685 smp->data.u.str = *trash;
686 break;
687
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100688 case SMP_T_BIN:
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100689 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200690 trash->data = smp->data.u.str.data;
691 if (trash->data > trash->size)
692 trash->data = trash->size;
Willy Tarreauad635822016-08-08 19:21:09 +0200693
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200694 memcpy(trash->area, smp->data.u.str.area, trash->data);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200695 smp->data.u.str = *trash;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100696 break;
Christopher Fauletec100512017-07-24 15:38:41 +0200697
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100698 default:
699 /* Other cases are unexpected. */
700 return 0;
701 }
Thierry FOURNIERb805f712013-11-26 20:47:54 +0100702
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100703 /* remove const flag */
704 smp->flags &= ~SMP_F_CONST;
Emeric Brun485479d2010-09-23 18:02:19 +0200705 return 1;
706}
707
Thierry FOURNIER0e9af552013-12-14 14:55:04 +0100708int c_none(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100709{
710 return 1;
711}
712
Willy Tarreau342acb42012-04-23 22:03:39 +0200713static int c_str2int(struct sample *smp)
Emeric Brun107ca302010-01-04 16:16:05 +0100714{
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200715 const char *str;
716 const char *end;
Emeric Brun107ca302010-01-04 16:16:05 +0100717
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200718 if (smp->data.u.str.data == 0)
Thierry FOURNIER60bb0202014-01-27 18:20:48 +0100719 return 0;
720
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200721 str = smp->data.u.str.area;
722 end = smp->data.u.str.area + smp->data.u.str.data;
Emeric Brun107ca302010-01-04 16:16:05 +0100723
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200724 smp->data.u.sint = read_int64(&str, end);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200725 smp->data.type = SMP_T_SINT;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +0100726 smp->flags &= ~SMP_F_CONST;
Emeric Brun107ca302010-01-04 16:16:05 +0100727 return 1;
728}
729
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100730static int c_str2meth(struct sample *smp)
731{
732 enum http_meth_t meth;
733 int len;
734
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200735 meth = find_http_meth(smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100736 if (meth == HTTP_METH_OTHER) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200737 len = smp->data.u.str.data;
738 smp->data.u.meth.str.area = smp->data.u.str.area;
739 smp->data.u.meth.str.data = len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100740 }
741 else
742 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200743 smp->data.u.meth.meth = meth;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200744 smp->data.type = SMP_T_METH;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100745 return 1;
746}
747
748static int c_meth2str(struct sample *smp)
749{
750 int len;
751 enum http_meth_t meth;
752
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200753 if (smp->data.u.meth.meth == HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100754 /* The method is unknown. Copy the original pointer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200755 len = smp->data.u.meth.str.data;
756 smp->data.u.str.area = smp->data.u.meth.str.area;
757 smp->data.u.str.data = len;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200758 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100759 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200760 else if (smp->data.u.meth.meth < HTTP_METH_OTHER) {
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100761 /* The method is known, copy the pointer containing the string. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200762 meth = smp->data.u.meth.meth;
Willy Tarreau35b51c62018-09-10 15:38:55 +0200763 smp->data.u.str.area = http_known_methods[meth].ptr;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200764 smp->data.u.str.data = http_known_methods[meth].len;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100765 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200766 smp->data.type = SMP_T_STR;
Thierry FOURNIERd4373142013-12-17 01:10:10 +0100767 }
768 else {
769 /* Unknown method */
770 return 0;
771 }
772 return 1;
773}
774
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200775static int c_addr2bin(struct sample *smp)
776{
Willy Tarreau83061a82018-07-13 11:56:34 +0200777 struct buffer *chk = get_trash_chunk();
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200778
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200779 if (smp->data.type == SMP_T_IPV4) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200780 chk->data = 4;
781 memcpy(chk->area, &smp->data.u.ipv4, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200782 }
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200783 else if (smp->data.type == SMP_T_IPV6) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200784 chk->data = 16;
785 memcpy(chk->area, &smp->data.u.ipv6, chk->data);
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200786 }
787 else
788 return 0;
789
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200790 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200791 smp->data.type = SMP_T_BIN;
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200792 return 1;
793}
794
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200795static int c_int2bin(struct sample *smp)
796{
Willy Tarreau83061a82018-07-13 11:56:34 +0200797 struct buffer *chk = get_trash_chunk();
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200798
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200799 *(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
800 chk->data = 8;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200801
Thierry FOURNIER136f9d32015-08-19 09:07:19 +0200802 smp->data.u.str = *chk;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +0200803 smp->data.type = SMP_T_BIN;
Willy Tarreaubbfd1a22014-07-15 21:19:08 +0200804 return 1;
805}
806
Willy Tarreau9700e5c2014-07-15 21:03:26 +0200807
Emeric Brun107ca302010-01-04 16:16:05 +0100808/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +0200809/* Sample casts matrix: */
810/* sample_casts[from type][to type] */
811/* NULL pointer used for impossible sample casts */
Emeric Brun107ca302010-01-04 16:16:05 +0100812/*****************************************************************/
Emeric Brun107ca302010-01-04 16:16:05 +0100813
Thierry FOURNIER8af6ff12013-11-21 10:53:12 +0100814sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200815/* to: ANY BOOL SINT ADDR IPV4 IPV6 STR BIN METH */
816/* from: ANY */ { c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, c_none, },
817/* BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200818/* 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 +0200819/* ADDR */ { c_none, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
820/* IPV4 */ { c_none, NULL, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, c_addr2bin, NULL, },
Thierry FOURNIERcc4d1712015-07-24 09:04:56 +0200821/* IPV6 */ { c_none, NULL, NULL, c_none, c_ipv62ip,c_none, c_ipv62str, c_addr2bin, NULL, },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +0200822/* STR */ { c_none, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, },
823/* BIN */ { c_none, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, },
824/* METH */ { c_none, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200825};
Emeric Brun107ca302010-01-04 16:16:05 +0100826
Emeric Brun107ca302010-01-04 16:16:05 +0100827/*
Willy Tarreau12785782012-04-27 21:37:17 +0200828 * Parse a sample expression configuration:
Emeric Brun107ca302010-01-04 16:16:05 +0100829 * fetch keyword followed by format conversion keywords.
Willy Tarreau12785782012-04-27 21:37:17 +0200830 * Returns a pointer on allocated sample expression structure.
Willy Tarreaua4312fa2013-04-02 16:34:32 +0200831 * The caller must have set al->ctx.
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100832 * If <endptr> is non-nul, it will be set to the first unparsed character
833 * (which may be the final '\0') on success. If it is nul, the expression
834 * must be properly terminated by a '\0' otherwise an error is reported.
Emeric Brun107ca302010-01-04 16:16:05 +0100835 */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100836struct 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 +0100837{
Willy Tarreau833cc792013-07-24 15:34:19 +0200838 const char *begw; /* beginning of word */
839 const char *endw; /* end of word */
840 const char *endt; /* end of term */
Willy Tarreau12785782012-04-27 21:37:17 +0200841 struct sample_expr *expr;
842 struct sample_fetch *fetch;
843 struct sample_conv *conv;
Emeric Brun107ca302010-01-04 16:16:05 +0100844 unsigned long prev_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200845 char *fkw = NULL;
846 char *ckw = NULL;
Willy Tarreau689a1df2013-12-13 00:40:11 +0100847 int err_arg;
Emeric Brun107ca302010-01-04 16:16:05 +0100848
Willy Tarreau833cc792013-07-24 15:34:19 +0200849 begw = str[*idx];
Willy Tarreaued2c6622020-02-14 18:27:10 +0100850 for (endw = begw; is_idchar(*endw); endw++)
851 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200852
853 if (endw == begw) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100854 memprintf(err_msg, "missing fetch method");
Emeric Brun107ca302010-01-04 16:16:05 +0100855 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200856 }
Emeric Brun107ca302010-01-04 16:16:05 +0100857
Willy Tarreau833cc792013-07-24 15:34:19 +0200858 /* keep a copy of the current fetch keyword for error reporting */
859 fkw = my_strndup(begw, endw - begw);
Emeric Brun107ca302010-01-04 16:16:05 +0100860
Willy Tarreau833cc792013-07-24 15:34:19 +0200861 fetch = find_sample_fetch(begw, endw - begw);
862 if (!fetch) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100863 memprintf(err_msg, "unknown fetch method '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100864 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200865 }
Emeric Brun107ca302010-01-04 16:16:05 +0100866
Willy Tarreau833cc792013-07-24 15:34:19 +0200867 /* At this point, we have :
868 * - begw : beginning of the keyword
Willy Tarreau689a1df2013-12-13 00:40:11 +0100869 * - endw : end of the keyword, first character not part of keyword
Willy Tarreau833cc792013-07-24 15:34:19 +0200870 */
871
872 if (fetch->out_type >= SMP_TYPES) {
Willy Tarreau975c1782013-12-12 23:16:54 +0100873 memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100874 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200875 }
Emeric Brun107ca302010-01-04 16:16:05 +0100876 prev_type = fetch->out_type;
Willy Tarreau833cc792013-07-24 15:34:19 +0200877
Vincent Bernat02779b62016-04-03 13:48:43 +0200878 expr = calloc(1, sizeof(*expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200879 if (!expr)
880 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100881
882 LIST_INIT(&(expr->conv_exprs));
883 expr->fetch = fetch;
Willy Tarreau2e845be2012-10-19 19:49:09 +0200884 expr->arg_p = empty_arg_list;
Emeric Brun107ca302010-01-04 16:16:05 +0100885
Willy Tarreau689a1df2013-12-13 00:40:11 +0100886 /* Note that we call the argument parser even with an empty string,
887 * this allows it to automatically create entries for mandatory
888 * implicit arguments (eg: local proxy name).
889 */
890 al->kw = expr->fetch->kw;
891 al->conv = NULL;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100892 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 +0100893 memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg);
894 goto out_error;
895 }
Willy Tarreau2e845be2012-10-19 19:49:09 +0200896
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100897 /* now endt is our first char not part of the arg list, typically the
898 * comma after the sample fetch name or after the closing parenthesis,
899 * or the NUL char.
900 */
901
Willy Tarreau689a1df2013-12-13 00:40:11 +0100902 if (!expr->arg_p) {
903 expr->arg_p = empty_arg_list;
Emeric Brun485479d2010-09-23 18:02:19 +0200904 }
Willy Tarreau689a1df2013-12-13 00:40:11 +0100905 else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) {
906 memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +0200907 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100908 }
909
Willy Tarreau833cc792013-07-24 15:34:19 +0200910 /* Now process the converters if any. We have two supported syntaxes
911 * for the converters, which can be combined :
912 * - comma-delimited list of converters just after the keyword and args ;
913 * - one converter per keyword
914 * The combination allows to have each keyword being a comma-delimited
915 * series of converters.
916 *
917 * We want to process the former first, then the latter. For this we start
918 * from the beginning of the supposed place in the exiting conv chain, which
919 * starts at the last comma (endt).
920 */
921
922 while (1) {
Willy Tarreau12785782012-04-27 21:37:17 +0200923 struct sample_conv_expr *conv_expr;
Willy Tarreau46dfd782019-12-17 10:25:29 +0100924 int err_arg;
925 int argcnt;
Emeric Brun107ca302010-01-04 16:16:05 +0100926
Willy Tarreau833cc792013-07-24 15:34:19 +0200927 if (*endt && *endt != ',') {
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100928 if (endptr) {
929 /* end found, let's stop here */
930 break;
931 }
Willy Tarreau833cc792013-07-24 15:34:19 +0200932 if (ckw)
Willy Tarreau97108e02016-11-25 07:33:24 +0100933 memprintf(err_msg, "missing comma after converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200934 else
Willy Tarreau975c1782013-12-12 23:16:54 +0100935 memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw);
Emeric Brun107ca302010-01-04 16:16:05 +0100936 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200937 }
Emeric Brun107ca302010-01-04 16:16:05 +0100938
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100939 /* FIXME: how long should we support such idiocies ? Maybe we
940 * should already warn ?
941 */
Willy Tarreau833cc792013-07-24 15:34:19 +0200942 while (*endt == ',') /* then trailing commas */
943 endt++;
944
Willy Tarreau97108e02016-11-25 07:33:24 +0100945 begw = endt; /* start of converter */
Willy Tarreau833cc792013-07-24 15:34:19 +0200946
947 if (!*begw) {
948 /* none ? skip to next string */
949 (*idx)++;
950 begw = str[*idx];
951 if (!begw || !*begw)
952 break;
953 }
954
Willy Tarreaued2c6622020-02-14 18:27:10 +0100955 for (endw = begw; is_idchar(*endw); endw++)
956 ;
Willy Tarreau833cc792013-07-24 15:34:19 +0200957
958 free(ckw);
959 ckw = my_strndup(begw, endw - begw);
960
961 conv = find_sample_conv(begw, endw - begw);
962 if (!conv) {
963 /* we found an isolated keyword that we don't know, it's not ours */
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100964 if (begw == str[*idx]) {
965 endt = begw;
Willy Tarreau833cc792013-07-24 15:34:19 +0200966 break;
Willy Tarreaue3b57bf2020-02-14 16:50:14 +0100967 }
Willy Tarreau97108e02016-11-25 07:33:24 +0100968 memprintf(err_msg, "unknown converter '%s'", ckw);
Willy Tarreau833cc792013-07-24 15:34:19 +0200969 goto out_error;
970 }
Emeric Brun107ca302010-01-04 16:16:05 +0100971
Willy Tarreau833cc792013-07-24 15:34:19 +0200972 if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100973 memprintf(err_msg, "returns type of converter '%s' is unknown", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100974 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200975 }
Emeric Brun107ca302010-01-04 16:16:05 +0100976
977 /* If impossible type conversion */
Willy Tarreau12785782012-04-27 21:37:17 +0200978 if (!sample_casts[prev_type][conv->in_type]) {
Willy Tarreau97108e02016-11-25 07:33:24 +0100979 memprintf(err_msg, "converter '%s' cannot be applied", ckw);
Emeric Brun107ca302010-01-04 16:16:05 +0100980 goto out_error;
Emeric Brun485479d2010-09-23 18:02:19 +0200981 }
Emeric Brun107ca302010-01-04 16:16:05 +0100982
983 prev_type = conv->out_type;
Vincent Bernat02779b62016-04-03 13:48:43 +0200984 conv_expr = calloc(1, sizeof(*conv_expr));
Emeric Brun485479d2010-09-23 18:02:19 +0200985 if (!conv_expr)
986 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +0100987
988 LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list));
989 conv_expr->conv = conv;
990
Willy Tarreau46dfd782019-12-17 10:25:29 +0100991 al->kw = expr->fetch->kw;
992 al->conv = conv_expr->conv->kw;
Willy Tarreau80b53ff2020-02-14 08:40:37 +0100993 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 +0100994 if (argcnt < 0) {
995 memprintf(err_msg, "invalid arg %d in converter '%s' : %s", err_arg+1, ckw, *err_msg);
996 goto out_error;
997 }
Willy Tarreau9e92d322010-01-26 17:58:06 +0100998
Willy Tarreau46dfd782019-12-17 10:25:29 +0100999 if (argcnt && !conv->arg_mask) {
1000 memprintf(err_msg, "converter '%s' does not support any args", ckw);
1001 goto out_error;
1002 }
Willy Tarreau21d68a62012-04-20 15:52:36 +02001003
Willy Tarreau46dfd782019-12-17 10:25:29 +01001004 if (!conv_expr->arg_p)
1005 conv_expr->arg_p = empty_arg_list;
Willy Tarreau2e845be2012-10-19 19:49:09 +02001006
Willy Tarreau46dfd782019-12-17 10:25:29 +01001007 if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) {
1008 memprintf(err_msg, "invalid args in converter '%s' : %s", ckw, *err_msg);
Emeric Brun485479d2010-09-23 18:02:19 +02001009 goto out_error;
Emeric Brun107ca302010-01-04 16:16:05 +01001010 }
1011 }
Emeric Brun485479d2010-09-23 18:02:19 +02001012
Willy Tarreaue3b57bf2020-02-14 16:50:14 +01001013 if (endptr) {
1014 /* end found, let's stop here */
1015 *endptr = (char *)endt;
1016 }
1017
Willy Tarreau833cc792013-07-24 15:34:19 +02001018 out:
1019 free(fkw);
1020 free(ckw);
Emeric Brun107ca302010-01-04 16:16:05 +01001021 return expr;
1022
1023out_error:
Willy Tarreau12785782012-04-27 21:37:17 +02001024 /* TODO: prune_sample_expr(expr); */
Willy Tarreau833cc792013-07-24 15:34:19 +02001025 expr = NULL;
1026 goto out;
Emeric Brun107ca302010-01-04 16:16:05 +01001027}
1028
1029/*
Willy Tarreau12785782012-04-27 21:37:17 +02001030 * Process a fetch + format conversion of defined by the sample expression <expr>
Willy Tarreau32a6f2e2012-04-25 10:13:36 +02001031 * on request or response considering the <opt> parameter.
Willy Tarreau12785782012-04-27 21:37:17 +02001032 * Returns a pointer on a typed sample structure containing the result or NULL if
1033 * sample is not found or when format conversion failed.
Emeric Brun107ca302010-01-04 16:16:05 +01001034 * If <p> is not null, function returns results in structure pointed by <p>.
Willy Tarreau12785782012-04-27 21:37:17 +02001035 * If <p> is null, functions returns a pointer on a static sample structure.
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001036 *
1037 * Note: the fetch functions are required to properly set the return type. The
1038 * conversion functions must do so too. However the cast functions do not need
1039 * to since they're made to cast mutiple types according to what is required.
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001040 *
1041 * The caller may indicate in <opt> if it considers the result final or not.
1042 * The caller needs to check the SMP_F_MAY_CHANGE flag in p->flags to verify
1043 * if the result is stable or not, according to the following table :
1044 *
1045 * return MAY_CHANGE FINAL Meaning for the sample
1046 * NULL 0 * Not present and will never be (eg: header)
1047 * NULL 1 0 Not present yet, could change (eg: POST param)
1048 * NULL 1 1 Not present yet, will not change anymore
1049 * smp 0 * Present and will not change (eg: header)
1050 * smp 1 0 Present, may change (eg: request length)
1051 * smp 1 1 Present, last known value (eg: request length)
Emeric Brun107ca302010-01-04 16:16:05 +01001052 */
Willy Tarreau192252e2015-04-04 01:47:55 +02001053struct sample *sample_process(struct proxy *px, struct session *sess,
1054 struct stream *strm, unsigned int opt,
Willy Tarreau12785782012-04-27 21:37:17 +02001055 struct sample_expr *expr, struct sample *p)
Emeric Brun107ca302010-01-04 16:16:05 +01001056{
Willy Tarreau12785782012-04-27 21:37:17 +02001057 struct sample_conv_expr *conv_expr;
Emeric Brun107ca302010-01-04 16:16:05 +01001058
Willy Tarreau18387e22013-07-25 12:02:38 +02001059 if (p == NULL) {
Willy Tarreaub4a88f02012-04-23 21:35:11 +02001060 p = &temp_smp;
Willy Tarreau6c616e02014-06-25 16:56:41 +02001061 memset(p, 0, sizeof(*p));
Willy Tarreau18387e22013-07-25 12:02:38 +02001062 }
Emeric Brun107ca302010-01-04 16:16:05 +01001063
Willy Tarreau1777ea62016-03-10 16:15:46 +01001064 smp_set_owner(p, px, sess, strm, opt);
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001065 if (!expr->fetch->process(expr->arg_p, p, expr->fetch->kw, expr->fetch->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001066 return NULL;
1067
Emeric Brun107ca302010-01-04 16:16:05 +01001068 list_for_each_entry(conv_expr, &expr->conv_exprs, list) {
Willy Tarreau12e50112012-04-25 17:21:49 +02001069 /* we want to ensure that p->type can be casted into
1070 * conv_expr->conv->in_type. We have 3 possibilities :
1071 * - NULL => not castable.
1072 * - c_none => nothing to do (let's optimize it)
1073 * - other => apply cast and prepare to fail
1074 */
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001075 if (!sample_casts[p->data.type][conv_expr->conv->in_type])
Willy Tarreau12e50112012-04-25 17:21:49 +02001076 return NULL;
1077
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001078 if (sample_casts[p->data.type][conv_expr->conv->in_type] != c_none &&
1079 !sample_casts[p->data.type][conv_expr->conv->in_type](p))
Emeric Brun107ca302010-01-04 16:16:05 +01001080 return NULL;
1081
Willy Tarreau12e50112012-04-25 17:21:49 +02001082 /* OK cast succeeded */
1083
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02001084 if (!conv_expr->conv->process(conv_expr->arg_p, p, conv_expr->conv->private))
Emeric Brun107ca302010-01-04 16:16:05 +01001085 return NULL;
Emeric Brun107ca302010-01-04 16:16:05 +01001086 }
1087 return p;
1088}
1089
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001090/*
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001091 * Resolve all remaining arguments in proxy <p>. Returns the number of
1092 * errors or 0 if everything is fine.
1093 */
1094int smp_resolve_args(struct proxy *p)
1095{
1096 struct arg_list *cur, *bak;
1097 const char *ctx, *where;
1098 const char *conv_ctx, *conv_pre, *conv_pos;
1099 struct userlist *ul;
Willy Tarreau46947782015-01-19 19:00:58 +01001100 struct my_regex *reg;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001101 struct arg *arg;
1102 int cfgerr = 0;
Willy Tarreau46947782015-01-19 19:00:58 +01001103 int rflags;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001104
1105 list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) {
1106 struct proxy *px;
1107 struct server *srv;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001108 struct stktable *t;
1109 char *pname, *sname, *stktname;
Willy Tarreau46947782015-01-19 19:00:58 +01001110 char *err;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001111
1112 arg = cur->arg;
1113
1114 /* prepare output messages */
1115 conv_pre = conv_pos = conv_ctx = "";
1116 if (cur->conv) {
1117 conv_ctx = cur->conv;
1118 conv_pre = "conversion keyword '";
1119 conv_pos = "' for ";
1120 }
1121
1122 where = "in";
1123 ctx = "sample fetch keyword";
1124 switch (cur->ctx) {
Dragan Dosen0b85ece2015-09-25 19:17:44 +02001125 case ARGC_STK: where = "in stick rule in"; break;
1126 case ARGC_TRK: where = "in tracking rule in"; break;
1127 case ARGC_LOG: where = "in log-format string in"; break;
1128 case ARGC_LOGSD: where = "in log-format-sd string in"; break;
1129 case ARGC_HRQ: where = "in http-request header format string in"; break;
1130 case ARGC_HRS: where = "in http-response header format string in"; break;
1131 case ARGC_UIF: where = "in unique-id-format string in"; break;
1132 case ARGC_RDR: where = "in redirect format string in"; break;
1133 case ARGC_CAP: where = "in capture rule in"; break;
1134 case ARGC_ACL: ctx = "ACL keyword"; break;
1135 case ARGC_SRV: where = "in server directive in"; break;
Christopher Fauletf7e4e7e2016-10-27 22:29:49 +02001136 case ARGC_SPOE: where = "in spoe-message directive in"; break;
Christopher Faulet3b967c12020-05-15 15:47:44 +02001137 case ARGC_HERR: where = "in http-error directive in"; break;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001138 }
1139
1140 /* set a few default settings */
1141 px = p;
1142 pname = p->id;
1143
1144 switch (arg->type) {
1145 case ARGT_SRV:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001146 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001147 ha_alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1148 cur->file, cur->line,
1149 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001150 cfgerr++;
1151 continue;
1152 }
1153
1154 /* we support two formats : "bck/srv" and "srv" */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001155 sname = strrchr(arg->data.str.area, '/');
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001156
1157 if (sname) {
1158 *sname++ = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001159 pname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001160
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001161 px = proxy_be_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001162 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001163 ha_alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1164 cur->file, cur->line, pname,
1165 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001166 cfgerr++;
1167 break;
1168 }
1169 }
1170 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001171 sname = arg->data.str.area;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001172
1173 srv = findserver(px, sname);
1174 if (!srv) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001175 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",
1176 cur->file, cur->line, sname, pname,
1177 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001178 cfgerr++;
1179 break;
1180 }
1181
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001182 free(arg->data.str.area);
1183 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001184 arg->unresolved = 0;
1185 arg->data.srv = srv;
1186 break;
1187
1188 case ARGT_FE:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001189 if (arg->data.str.data) {
1190 pname = arg->data.str.area;
Willy Tarreau9e0bb102015-05-26 11:24:42 +02001191 px = proxy_fe_by_name(pname);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001192 }
1193
1194 if (!px) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001195 ha_alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1196 cur->file, cur->line, pname,
1197 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001198 cfgerr++;
1199 break;
1200 }
1201
1202 if (!(px->cap & PR_CAP_FE)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001203 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",
1204 cur->file, cur->line, pname,
1205 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001206 cfgerr++;
1207 break;
1208 }
1209
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001210 free(arg->data.str.area);
1211 arg->data.str.area = NULL;
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
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001238 free(arg->data.str.area);
1239 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001240 arg->unresolved = 0;
1241 arg->data.prx = px;
1242 break;
1243
1244 case ARGT_TAB:
Frédéric Lécaille9417f452019-06-20 09:31:04 +02001245 if (arg->data.str.data)
1246 stktname = arg->data.str.area;
1247 else
1248 stktname = px->id;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001249
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001250 t = stktable_find_by_name(stktname);
1251 if (!t) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001252 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 +01001253 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001254 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001255 cfgerr++;
1256 break;
1257 }
1258
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001259 if (!t->size) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001260 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 +01001261 cur->file, cur->line, stktname,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001262 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001263 cfgerr++;
1264 break;
1265 }
1266
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001267 if (t->proxy && (p->bind_proc & ~t->proxy->bind_proc)) {
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001268 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 +01001269 cur->file, cur->line, t->proxy->id, p->id);
Willy Tarreau1a0fe3b2019-02-06 10:25:07 +01001270 cfgerr++;
1271 break;
Willy Tarreau151e1ca2019-02-05 11:38:38 +01001272 }
1273
Frédéric Lécaillebe367932019-08-07 09:28:39 +02001274 if (!in_proxies_list(t->proxies_list, p)) {
Frédéric Lécaille015e4d72019-03-19 14:55:01 +01001275 p->next_stkt_ref = t->proxies_list;
1276 t->proxies_list = p;
1277 }
1278
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001279 free(arg->data.str.area);
1280 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001281 arg->unresolved = 0;
Frédéric Lécaille1b8e68e2019-03-14 07:07:41 +01001282 arg->data.t = t;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001283 break;
1284
1285 case ARGT_USR:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001286 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001287 ha_alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1288 cur->file, cur->line,
1289 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001290 cfgerr++;
1291 break;
1292 }
1293
1294 if (p->uri_auth && p->uri_auth->userlist &&
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001295 !strcmp(p->uri_auth->userlist->name, arg->data.str.area))
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001296 ul = p->uri_auth->userlist;
1297 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001298 ul = auth_find_userlist(arg->data.str.area);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001299
1300 if (!ul) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001301 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 +02001302 cur->file, cur->line,
1303 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001304 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001305 cfgerr++;
1306 break;
1307 }
1308
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001309 free(arg->data.str.area);
1310 arg->data.str.area = NULL;
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001311 arg->unresolved = 0;
1312 arg->data.usr = ul;
1313 break;
Willy Tarreau46947782015-01-19 19:00:58 +01001314
1315 case ARGT_REG:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001316 if (!arg->data.str.data) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001317 ha_alert("parsing [%s:%d] : missing regex in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n",
1318 cur->file, cur->line,
1319 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id);
Willy Tarreau46947782015-01-19 19:00:58 +01001320 cfgerr++;
1321 continue;
1322 }
1323
Willy Tarreau46947782015-01-19 19:00:58 +01001324 rflags = 0;
1325 rflags |= (arg->type_flags & ARGF_REG_ICASE) ? REG_ICASE : 0;
1326 err = NULL;
1327
Dragan Dosen26743032019-04-30 15:54:36 +02001328 if (!(reg = regex_comp(arg->data.str.area, !(rflags & REG_ICASE), 1 /* capture substr */, &err))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001329 ha_alert("parsing [%s:%d] : error in regex '%s' in arg %d of %s%s%s%s '%s' %s proxy '%s' : %s.\n",
1330 cur->file, cur->line,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001331 arg->data.str.area,
Christopher Faulet767a84b2017-11-24 16:50:31 +01001332 cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id, err);
Willy Tarreau46947782015-01-19 19:00:58 +01001333 cfgerr++;
1334 continue;
1335 }
1336
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001337 free(arg->data.str.area);
1338 arg->data.str.area = NULL;
Willy Tarreau46947782015-01-19 19:00:58 +01001339 arg->unresolved = 0;
1340 arg->data.reg = reg;
1341 break;
1342
1343
Willy Tarreaua4312fa2013-04-02 16:34:32 +02001344 }
1345
1346 LIST_DEL(&cur->list);
1347 free(cur);
1348 } /* end of args processing */
1349
1350 return cfgerr;
1351}
1352
1353/*
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001354 * Process a fetch + format conversion as defined by the sample expression
1355 * <expr> on request or response considering the <opt> parameter. The output is
Adis Nezirovic79beb242015-07-06 15:41:02 +02001356 * not explicitly set to <smp_type>, but shall be compatible with it as
1357 * specified by 'sample_casts' table. If a stable sample can be fetched, or an
1358 * unstable one when <opt> contains SMP_OPT_FINAL, the sample is converted and
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001359 * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found
1360 * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is
1361 * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to
1362 * take actions (eg: wait longer). If a sample could not be found or could not
Willy Tarreau6bcb0a82014-07-30 08:56:35 +02001363 * be converted, NULL is returned. The caller MUST NOT use the sample if the
1364 * SMP_F_MAY_CHANGE flag is present, as it is used only as a hint that there is
1365 * still hope to get it after waiting longer, and is not converted to string.
1366 * The possible output combinations are the following :
1367 *
1368 * return MAY_CHANGE FINAL Meaning for the sample
1369 * NULL * * Not present and will never be (eg: header)
1370 * smp 0 * Final value converted (eg: header)
1371 * smp 1 0 Not present yet, may appear later (eg: header)
1372 * smp 1 1 never happens (either flag is cleared on output)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001373 */
Adis Nezirovic79beb242015-07-06 15:41:02 +02001374struct sample *sample_fetch_as_type(struct proxy *px, struct session *sess,
Willy Tarreau192252e2015-04-04 01:47:55 +02001375 struct stream *strm, unsigned int opt,
Adis Nezirovic79beb242015-07-06 15:41:02 +02001376 struct sample_expr *expr, int smp_type)
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001377{
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001378 struct sample *smp = &temp_smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001379
Willy Tarreau6c616e02014-06-25 16:56:41 +02001380 memset(smp, 0, sizeof(*smp));
1381
Willy Tarreau192252e2015-04-04 01:47:55 +02001382 if (!sample_process(px, sess, strm, opt, expr, smp)) {
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001383 if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL))
1384 return smp;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001385 return NULL;
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001386 }
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001387
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001388 if (!sample_casts[smp->data.type][smp_type])
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001389 return NULL;
1390
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001391 if (!sample_casts[smp->data.type][smp_type](smp))
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001392 return NULL;
1393
Willy Tarreau5b4bf702014-06-13 16:04:35 +02001394 smp->flags &= ~SMP_F_MAY_CHANGE;
Willy Tarreaue7ad4bb2012-12-21 00:02:32 +01001395 return smp;
1396}
1397
Christopher Faulet476e5d02016-10-26 11:34:47 +02001398static void release_sample_arg(struct arg *p)
1399{
1400 struct arg *p_back = p;
1401
1402 if (!p)
1403 return;
1404
1405 while (p->type != ARGT_STOP) {
1406 if (p->type == ARGT_STR || p->unresolved) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001407 free(p->data.str.area);
1408 p->data.str.area = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001409 p->unresolved = 0;
1410 }
1411 else if (p->type == ARGT_REG) {
Dragan Dosen26743032019-04-30 15:54:36 +02001412 regex_free(p->data.reg);
1413 p->data.reg = NULL;
Christopher Faulet476e5d02016-10-26 11:34:47 +02001414 }
1415 p++;
1416 }
1417
1418 if (p_back != empty_arg_list)
1419 free(p_back);
1420}
1421
1422void release_sample_expr(struct sample_expr *expr)
1423{
1424 struct sample_conv_expr *conv_expr, *conv_exprb;
1425
1426 if (!expr)
1427 return;
1428
1429 list_for_each_entry_safe(conv_expr, conv_exprb, &expr->conv_exprs, list)
1430 release_sample_arg(conv_expr->arg_p);
1431 release_sample_arg(expr->arg_p);
1432 free(expr);
1433}
1434
Emeric Brun107ca302010-01-04 16:16:05 +01001435/*****************************************************************/
Willy Tarreau12785782012-04-27 21:37:17 +02001436/* Sample format convert functions */
Willy Tarreaub8c8f1f2012-04-23 22:38:26 +02001437/* These functions set the data type on return. */
Emeric Brun107ca302010-01-04 16:16:05 +01001438/*****************************************************************/
1439
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001440static int sample_conv_debug(const struct arg *arg_p, struct sample *smp, void *private)
1441{
1442 int i;
1443 struct sample tmp;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001444 struct buffer *buf;
1445 struct sink *sink;
1446 struct ist line;
1447 char *pfx;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001448
Willy Tarreau0851fd52019-12-17 10:07:25 +01001449 buf = alloc_trash_chunk();
1450 if (!buf)
1451 goto end;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001452
Willy Tarreau0851fd52019-12-17 10:07:25 +01001453 sink = (struct sink *)arg_p[1].data.str.area;
1454 BUG_ON(!sink);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001455
Willy Tarreau0851fd52019-12-17 10:07:25 +01001456 pfx = arg_p[0].data.str.area;
1457 BUG_ON(!pfx);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001458
Willy Tarreau0851fd52019-12-17 10:07:25 +01001459 chunk_printf(buf, "[debug] %s: type=%s ", pfx, smp_to_type[smp->data.type]);
1460 if (!sample_casts[smp->data.type][SMP_T_STR])
1461 goto nocast;
1462
1463 /* Copy sample fetch. This puts the sample as const, the
1464 * cast will copy data if a transformation is required.
1465 */
1466 memcpy(&tmp, smp, sizeof(struct sample));
1467 tmp.flags = SMP_F_CONST;
1468
1469 if (!sample_casts[smp->data.type][SMP_T_STR](&tmp))
1470 goto nocast;
1471
1472 /* Display the displayable chars*. */
1473 b_putchr(buf, '<');
1474 for (i = 0; i < tmp.data.u.str.data; i++) {
Willy Tarreau90807112020-02-25 08:16:33 +01001475 if (isprint((unsigned char)tmp.data.u.str.area[i]))
Willy Tarreau0851fd52019-12-17 10:07:25 +01001476 b_putchr(buf, tmp.data.u.str.area[i]);
1477 else
1478 b_putchr(buf, '.');
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001479 }
Willy Tarreau0851fd52019-12-17 10:07:25 +01001480 b_putchr(buf, '>');
1481
1482 done:
1483 line = ist2(buf->area, buf->data);
Emeric Brunbd163812020-05-06 14:33:46 +02001484 sink_write(sink, &line, 1, 0, 0, NULL, NULL, NULL);
Willy Tarreau0851fd52019-12-17 10:07:25 +01001485 end:
1486 free_trash_chunk(buf);
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001487 return 1;
Willy Tarreau0851fd52019-12-17 10:07:25 +01001488 nocast:
1489 chunk_appendf(buf, "(undisplayable)");
1490 goto done;
Thierry FOURNIER9687c772015-05-07 15:46:29 +02001491}
Willy Tarreau0851fd52019-12-17 10:07:25 +01001492
1493// This function checks the "debug" converter's arguments.
1494static int smp_check_debug(struct arg *args, struct sample_conv *conv,
1495 const char *file, int line, char **err)
1496{
1497 const char *name = "buf0";
1498 struct sink *sink = NULL;
1499
1500 if (args[0].type != ARGT_STR) {
1501 /* optional prefix */
1502 args[0].data.str.area = "";
1503 args[0].data.str.data = 0;
1504 }
1505
1506 if (args[1].type == ARGT_STR)
1507 name = args[1].data.str.area;
1508
1509 sink = sink_find(name);
1510 if (!sink) {
1511 memprintf(err, "No such sink '%s'", name);
1512 return 0;
1513 }
1514
1515 args[1].data.str.area = (char *)sink;
1516 args[1].data.str.data = 0; // that's not a string anymore
1517 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
Willy Tarreau80599772015-01-20 19:35:24 +01002102/* hashes the binary input into a 32-bit unsigned int */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002103static int sample_conv_crc32(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau80599772015-01-20 19:35:24 +01002104{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002105 smp->data.u.sint = hash_crc32(smp->data.u.str.area,
2106 smp->data.u.str.data);
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002107 if (arg_p && arg_p->data.sint)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002108 smp->data.u.sint = full_hash(smp->data.u.sint);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002109 smp->data.type = SMP_T_SINT;
Willy Tarreau80599772015-01-20 19:35:24 +01002110 return 1;
2111}
2112
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002113/* hashes the binary input into crc32c (RFC4960, Appendix B [8].) */
2114static int sample_conv_crc32c(const struct arg *arg_p, struct sample *smp, void *private)
2115{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002116 smp->data.u.sint = hash_crc32c(smp->data.u.str.area,
2117 smp->data.u.str.data);
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01002118 if (arg_p && arg_p->data.sint)
2119 smp->data.u.sint = full_hash(smp->data.u.sint);
2120 smp->data.type = SMP_T_SINT;
2121 return 1;
2122}
2123
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002124/* This function escape special json characters. The returned string can be
2125 * safely set between two '"' and used as json string. The json string is
2126 * defined like this:
2127 *
2128 * any Unicode character except '"' or '\' or control character
2129 * \", \\, \/, \b, \f, \n, \r, \t, \u + four-hex-digits
2130 *
2131 * The enum input_type contain all the allowed mode for decoding the input
2132 * string.
2133 */
2134enum input_type {
2135 IT_ASCII = 0,
2136 IT_UTF8,
2137 IT_UTF8S,
2138 IT_UTF8P,
2139 IT_UTF8PS,
2140};
2141static int sample_conv_json_check(struct arg *arg, struct sample_conv *conv,
2142 const char *file, int line, char **err)
2143{
2144 if (!arg) {
2145 memprintf(err, "Unexpected empty arg list");
2146 return 0;
2147 }
2148
2149 if (arg->type != ARGT_STR) {
2150 memprintf(err, "Unexpected arg type");
2151 return 0;
2152 }
2153
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002154 if (strcmp(arg->data.str.area, "") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002155 arg->type = ARGT_SINT;
2156 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002157 return 1;
2158 }
2159
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002160 else if (strcmp(arg->data.str.area, "ascii") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002161 arg->type = ARGT_SINT;
2162 arg->data.sint = IT_ASCII;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002163 return 1;
2164 }
2165
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002166 else if (strcmp(arg->data.str.area, "utf8") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002167 arg->type = ARGT_SINT;
2168 arg->data.sint = IT_UTF8;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002169 return 1;
2170 }
2171
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002172 else if (strcmp(arg->data.str.area, "utf8s") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002173 arg->type = ARGT_SINT;
2174 arg->data.sint = IT_UTF8S;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002175 return 1;
2176 }
2177
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002178 else if (strcmp(arg->data.str.area, "utf8p") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002179 arg->type = ARGT_SINT;
2180 arg->data.sint = IT_UTF8P;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002181 return 1;
2182 }
2183
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002184 else if (strcmp(arg->data.str.area, "utf8ps") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002185 arg->type = ARGT_SINT;
2186 arg->data.sint = IT_UTF8PS;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002187 return 1;
2188 }
2189
Thierry FOURNIER / OZON.IOa69c9122016-11-23 01:13:57 +01002190 memprintf(err, "Unexpected input code type. "
2191 "Allowed value are 'ascii', 'utf8', 'utf8s', 'utf8p' and 'utf8ps'");
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002192 return 0;
2193}
2194
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002195static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002196{
Willy Tarreau83061a82018-07-13 11:56:34 +02002197 struct buffer *temp;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002198 char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
2199 const char *str;
2200 int len;
2201 enum input_type input_type = IT_ASCII;
2202 unsigned int c;
2203 unsigned int ret;
2204 char *p;
2205
2206 if (arg_p)
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002207 input_type = arg_p->data.sint;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002208
2209 temp = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002210 temp->data = 0;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002211
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002212 p = smp->data.u.str.area;
2213 while (p < smp->data.u.str.area + smp->data.u.str.data) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002214
2215 if (input_type == IT_ASCII) {
2216 /* Read input as ASCII. */
2217 c = *(unsigned char *)p;
2218 p++;
2219 }
2220 else {
2221 /* Read input as UTF8. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002222 ret = utf8_next(p,
2223 smp->data.u.str.data - ( p - smp->data.u.str.area),
2224 &c);
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002225 p += utf8_return_length(ret);
2226
2227 if (input_type == IT_UTF8 && utf8_return_code(ret) != UTF8_CODE_OK)
2228 return 0;
2229 if (input_type == IT_UTF8S && utf8_return_code(ret) != UTF8_CODE_OK)
2230 continue;
2231 if (input_type == IT_UTF8P && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2232 return 0;
2233 if (input_type == IT_UTF8PS && utf8_return_code(ret) & (UTF8_CODE_INVRANGE|UTF8_CODE_BADSEQ))
2234 continue;
2235
2236 /* Check too big values. */
2237 if ((unsigned int)c > 0xffff) {
2238 if (input_type == IT_UTF8 || input_type == IT_UTF8P)
2239 return 0;
2240 continue;
2241 }
2242 }
2243
2244 /* Convert character. */
2245 if (c == '"') {
2246 len = 2;
2247 str = "\\\"";
2248 }
2249 else if (c == '\\') {
2250 len = 2;
2251 str = "\\\\";
2252 }
2253 else if (c == '/') {
2254 len = 2;
2255 str = "\\/";
2256 }
2257 else if (c == '\b') {
2258 len = 2;
2259 str = "\\b";
2260 }
2261 else if (c == '\f') {
2262 len = 2;
2263 str = "\\f";
2264 }
2265 else if (c == '\r') {
2266 len = 2;
2267 str = "\\r";
2268 }
2269 else if (c == '\n') {
2270 len = 2;
2271 str = "\\n";
2272 }
2273 else if (c == '\t') {
2274 len = 2;
2275 str = "\\t";
2276 }
Willy Tarreau90807112020-02-25 08:16:33 +01002277 else if (c > 0xff || !isprint((unsigned char)c)) {
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002278 /* isprint generate a segfault if c is too big. The man says that
2279 * c must have the value of an unsigned char or EOF.
2280 */
2281 len = 6;
2282 _str[0] = '\\';
2283 _str[1] = 'u';
2284 snprintf(&_str[2], 5, "%04x", (unsigned short)c);
2285 str = _str;
2286 }
2287 else {
2288 len = 1;
Willy Tarreau5715da22020-02-25 08:37:37 +01002289 _str[0] = c;
2290 str = _str;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002291 }
2292
2293 /* Check length */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002294 if (temp->data + len > temp->size)
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002295 return 0;
2296
2297 /* Copy string. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002298 memcpy(temp->area + temp->data, str, len);
2299 temp->data += len;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002300 }
2301
2302 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002303 smp->data.u.str = *temp;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002304 smp->data.type = SMP_T_STR;
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02002305
2306 return 1;
2307}
2308
Emeric Brun54c4ac82014-11-03 15:32:43 +01002309/* This sample function is designed to extract some bytes from an input buffer.
2310 * First arg is the offset.
2311 * Optional second arg is the length to truncate */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002312static int sample_conv_bytes(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brun54c4ac82014-11-03 15:32:43 +01002313{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002314 if (smp->data.u.str.data <= arg_p[0].data.sint) {
2315 smp->data.u.str.data = 0;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002316 return 1;
2317 }
2318
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002319 if (smp->data.u.str.size)
2320 smp->data.u.str.size -= arg_p[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002321 smp->data.u.str.data -= arg_p[0].data.sint;
2322 smp->data.u.str.area += arg_p[0].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002323
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002324 if ((arg_p[1].type == ARGT_SINT) && (arg_p[1].data.sint < smp->data.u.str.data))
2325 smp->data.u.str.data = arg_p[1].data.sint;
Emeric Brun54c4ac82014-11-03 15:32:43 +01002326
2327 return 1;
2328}
2329
Emeric Brunf399b0d2014-11-03 17:07:03 +01002330static int sample_conv_field_check(struct arg *args, struct sample_conv *conv,
2331 const char *file, int line, char **err)
2332{
2333 struct arg *arg = args;
2334
2335 if (!arg) {
2336 memprintf(err, "Unexpected empty arg list");
2337 return 0;
2338 }
2339
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002340 if (arg->type != ARGT_SINT) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002341 memprintf(err, "Unexpected arg type");
2342 return 0;
2343 }
2344
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002345 if (!arg->data.sint) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002346 memprintf(err, "Unexpected value 0 for index");
2347 return 0;
2348 }
2349
2350 arg++;
2351
2352 if (arg->type != ARGT_STR) {
2353 memprintf(err, "Unexpected arg type");
2354 return 0;
2355 }
2356
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002357 if (!arg->data.str.data) {
Emeric Brunf399b0d2014-11-03 17:07:03 +01002358 memprintf(err, "Empty separators list");
2359 return 0;
2360 }
2361
2362 return 1;
2363}
2364
2365/* This sample function is designed to a return selected part of a string (field).
2366 * First arg is the index of the field (start at 1)
2367 * Second arg is a char list of separators (type string)
2368 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002369static int sample_conv_field(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002370{
Marcin Deranek9631a282018-04-16 14:30:46 +02002371 int field;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002372 char *start, *end;
2373 int i;
Marcin Deranek9631a282018-04-16 14:30:46 +02002374 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002375
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002376 if (!arg_p[0].data.sint)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002377 return 0;
2378
Marcin Deranek9631a282018-04-16 14:30:46 +02002379 if (arg_p[0].data.sint < 0) {
2380 field = -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002381 end = start = smp->data.u.str.area + smp->data.u.str.data;
2382 while (start > smp->data.u.str.area) {
2383 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2384 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002385 if (field == arg_p[0].data.sint) {
2386 if (count == 1)
2387 goto found;
2388 else if (count > 1)
2389 count--;
2390 } else {
2391 end = start-1;
2392 field--;
2393 }
2394 break;
2395 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002396 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002397 start--;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002398 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002399 } else {
2400 field = 1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002401 end = start = smp->data.u.str.area;
2402 while (end - smp->data.u.str.area < smp->data.u.str.data) {
2403 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2404 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002405 if (field == arg_p[0].data.sint) {
2406 if (count == 1)
2407 goto found;
2408 else if (count > 1)
2409 count--;
2410 } else {
2411 start = end+1;
2412 field++;
2413 }
2414 break;
2415 }
2416 }
2417 end++;
2418 }
Emeric Brunf399b0d2014-11-03 17:07:03 +01002419 }
2420
2421 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002422 if (field != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002423 smp->data.u.str.data = 0;
Tim Duesterhus4381d262019-10-16 15:11:15 +02002424 return 0;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002425 }
2426found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002427 smp->data.u.str.data = end - start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002428 /* If ret string is len 0, no need to
2429 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002430 if (!smp->data.u.str.data)
Emeric Brunf399b0d2014-11-03 17:07:03 +01002431 return 1;
2432
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002433 smp->data.u.str.area = start;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002434
2435 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002436 Note: smp->data.u.str.size cannot be set to 0 */
2437 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002438 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunf399b0d2014-11-03 17:07:03 +01002439
2440 return 1;
2441}
2442
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002443/* This sample function is designed to return a word from a string.
2444 * First arg is the index of the word (start at 1)
2445 * Second arg is a char list of words separators (type string)
2446 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002447static int sample_conv_word(const struct arg *arg_p, struct sample *smp, void *private)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002448{
Marcin Deranek9631a282018-04-16 14:30:46 +02002449 int word;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002450 char *start, *end;
2451 int i, issep, inword;
Marcin Deranek9631a282018-04-16 14:30:46 +02002452 int count = (arg_p[2].type == ARGT_SINT) ? arg_p[2].data.sint : 1;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002453
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002454 if (!arg_p[0].data.sint)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002455 return 0;
2456
2457 word = 0;
2458 inword = 0;
Marcin Deranek9631a282018-04-16 14:30:46 +02002459 if (arg_p[0].data.sint < 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002460 end = start = smp->data.u.str.area + smp->data.u.str.data;
2461 while (start > smp->data.u.str.area) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002462 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002463 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2464 if (*(start-1) == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002465 issep = 1;
2466 break;
2467 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002468 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002469 if (!inword) {
2470 if (!issep) {
2471 if (word != arg_p[0].data.sint) {
2472 word--;
2473 end = start;
2474 }
2475 inword = 1;
2476 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002477 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002478 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002479 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002480 if (count == 1)
2481 goto found;
2482 else if (count > 1)
2483 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002484 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002485 inword = 0;
2486 }
2487 start--;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002488 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002489 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002490 end = start = smp->data.u.str.area;
2491 while (end - smp->data.u.str.area < smp->data.u.str.data) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002492 issep = 0;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002493 for (i = 0 ; i < arg_p[1].data.str.data; i++) {
2494 if (*end == arg_p[1].data.str.area[i]) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002495 issep = 1;
2496 break;
2497 }
2498 }
2499 if (!inword) {
2500 if (!issep) {
2501 if (word != arg_p[0].data.sint) {
2502 word++;
2503 start = end;
2504 }
2505 inword = 1;
2506 }
2507 }
2508 else if (issep) {
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002509 if (word == arg_p[0].data.sint) {
Marcin Deranek9631a282018-04-16 14:30:46 +02002510 if (count == 1)
2511 goto found;
2512 else if (count > 1)
2513 count--;
Willy Tarreau9eb2a4a2018-04-19 10:33:28 +02002514 }
Marcin Deranek9631a282018-04-16 14:30:46 +02002515 inword = 0;
2516 }
2517 end++;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002518 }
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002519 }
2520
2521 /* Field not found */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02002522 if (word != arg_p[0].data.sint) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002523 smp->data.u.str.data = 0;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002524 return 1;
2525 }
2526found:
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002527 smp->data.u.str.data = end - start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002528 /* If ret string is len 0, no need to
2529 change pointers or to update size */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002530 if (!smp->data.u.str.data)
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002531 return 1;
2532
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002533 smp->data.u.str.area = start;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002534
2535 /* Compute remaining size if needed
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002536 Note: smp->data.u.str.size cannot be set to 0 */
2537 if (smp->data.u.str.size)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002538 smp->data.u.str.size -= start - smp->data.u.str.area;
Emeric Brunc9a0f6d2014-11-25 14:09:01 +01002539
2540 return 1;
2541}
2542
Willy Tarreau7eda8492015-01-20 19:47:06 +01002543static int sample_conv_regsub_check(struct arg *args, struct sample_conv *conv,
2544 const char *file, int line, char **err)
2545{
2546 struct arg *arg = args;
2547 char *p;
2548 int len;
2549
2550 /* arg0 is a regex, it uses type_flag for ICASE and global match */
2551 arg[0].type_flags = 0;
2552
2553 if (arg[2].type != ARGT_STR)
2554 return 1;
2555
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002556 p = arg[2].data.str.area;
2557 len = arg[2].data.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002558 while (len) {
2559 if (*p == 'i') {
2560 arg[0].type_flags |= ARGF_REG_ICASE;
2561 }
2562 else if (*p == 'g') {
2563 arg[0].type_flags |= ARGF_REG_GLOB;
2564 }
2565 else {
2566 memprintf(err, "invalid regex flag '%c', only 'i' and 'g' are supported", *p);
2567 return 0;
2568 }
2569 p++;
2570 len--;
2571 }
2572 return 1;
2573}
2574
2575/* This sample function is designed to do the equivalent of s/match/replace/ on
2576 * the input string. It applies a regex and restarts from the last matched
2577 * location until nothing matches anymore. First arg is the regex to apply to
2578 * the input string, second arg is the replacement expression.
2579 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002580static int sample_conv_regsub(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau7eda8492015-01-20 19:47:06 +01002581{
2582 char *start, *end;
2583 struct my_regex *reg = arg_p[0].data.reg;
2584 regmatch_t pmatch[MAX_MATCH];
Willy Tarreau83061a82018-07-13 11:56:34 +02002585 struct buffer *trash = get_trash_chunk();
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002586 struct buffer *output;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002587 int flag, max;
2588 int found;
2589
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002590 start = smp->data.u.str.area;
2591 end = start + smp->data.u.str.data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002592
2593 flag = 0;
2594 while (1) {
2595 /* check for last round which is used to copy remaining parts
2596 * when not running in global replacement mode.
2597 */
2598 found = 0;
2599 if ((arg_p[0].type_flags & ARGF_REG_GLOB) || !(flag & REG_NOTBOL)) {
2600 /* Note: we can have start == end on empty strings or at the end */
2601 found = regex_exec_match2(reg, start, end - start, MAX_MATCH, pmatch, flag);
2602 }
2603
2604 if (!found)
2605 pmatch[0].rm_so = end - start;
2606
2607 /* copy the heading non-matching part (which may also be the tail if nothing matches) */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002608 max = trash->size - trash->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002609 if (max && pmatch[0].rm_so > 0) {
2610 if (max > pmatch[0].rm_so)
2611 max = pmatch[0].rm_so;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002612 memcpy(trash->area + trash->data, start, max);
2613 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002614 }
2615
2616 if (!found)
2617 break;
2618
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002619 output = alloc_trash_chunk();
Willy Tarreau23997da2020-02-18 14:27:44 +01002620 if (!output)
2621 break;
2622
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002623 output->data = exp_replace(output->area, output->size, start, arg_p[1].data.str.area, pmatch);
2624
Willy Tarreau7eda8492015-01-20 19:47:06 +01002625 /* replace the matching part */
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002626 max = output->size - output->data;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002627 if (max) {
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002628 if (max > output->data)
2629 max = output->data;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002630 memcpy(trash->area + trash->data,
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002631 output->area, max);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002632 trash->data += max;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002633 }
2634
Jerome Magnin07e1e3c2020-02-16 19:20:19 +01002635 free_trash_chunk(output);
2636
Willy Tarreau7eda8492015-01-20 19:47:06 +01002637 /* stop here if we're done with this string */
2638 if (start >= end)
2639 break;
2640
2641 /* We have a special case for matches of length 0 (eg: "x*y*").
2642 * These ones are considered to match in front of a character,
2643 * so we have to copy that character and skip to the next one.
2644 */
2645 if (!pmatch[0].rm_eo) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002646 if (trash->data < trash->size)
2647 trash->area[trash->data++] = start[pmatch[0].rm_eo];
Willy Tarreau7eda8492015-01-20 19:47:06 +01002648 pmatch[0].rm_eo++;
2649 }
2650
2651 start += pmatch[0].rm_eo;
2652 flag |= REG_NOTBOL;
2653 }
2654
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002655 smp->data.u.str = *trash;
Willy Tarreau7eda8492015-01-20 19:47:06 +01002656 return 1;
2657}
2658
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002659/* This function check an operator entry. It expects a string.
2660 * The string can be an integer or a variable name.
2661 */
2662static int check_operator(struct arg *args, struct sample_conv *conv,
2663 const char *file, int line, char **err)
2664{
2665 const char *str;
2666 const char *end;
2667
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);
2675 args[0].data.sint = read_int64(&str, end);
2676 if (*str != '\0') {
2677 memprintf(err, "expects an integer or a variable name");
2678 return 0;
2679 }
2680 args[0].type = ARGT_SINT;
2681 return 1;
2682}
2683
Willy Tarreau6204cd92016-03-10 16:33:04 +01002684/* This function returns a sample struct filled with an arg content.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002685 * If the arg contain an integer, the integer is returned in the
2686 * sample. If the arg contains a variable descriptor, it returns the
2687 * variable value.
2688 *
2689 * This function returns 0 if an error occurs, otherwise it returns 1.
2690 */
Willy Tarreau6204cd92016-03-10 16:33:04 +01002691static inline int sample_conv_var2smp(const struct arg *arg, struct sample *smp)
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002692{
2693 switch (arg->type) {
2694 case ARGT_SINT:
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002695 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002696 smp->data.u.sint = arg->data.sint;
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002697 return 1;
2698 case ARGT_VAR:
Willy Tarreau6204cd92016-03-10 16:33:04 +01002699 if (!vars_get_by_desc(&arg->data.var, smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002700 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002701 if (!sample_casts[smp->data.type][SMP_T_SINT])
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002702 return 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002703 if (!sample_casts[smp->data.type][SMP_T_SINT](smp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002704 return 0;
2705 return 1;
2706 default:
2707 return 0;
2708 }
2709}
2710
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002711/* Takes a SINT on input, applies a binary twos complement and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002712 * result.
2713 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002714static int sample_conv_binary_cpl(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002715{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002716 smp->data.u.sint = ~smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002717 return 1;
2718}
2719
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002720/* Takes a SINT on input, applies a binary "and" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002721 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002722 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002723static int sample_conv_binary_and(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002724{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002725 struct sample tmp;
2726
Willy Tarreau7560dd42016-03-10 16:28:58 +01002727 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002728 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002729 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002730 smp->data.u.sint &= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002731 return 1;
2732}
2733
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002734/* Takes a SINT on input, applies a binary "or" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002735 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002736 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002737static int sample_conv_binary_or(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002738{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002739 struct sample tmp;
2740
Willy Tarreau7560dd42016-03-10 16:28:58 +01002741 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002742 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002743 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002744 smp->data.u.sint |= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002745 return 1;
2746}
2747
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002748/* Takes a SINT on input, applies a binary "xor" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002749 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002750 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002751static int sample_conv_binary_xor(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002752{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002753 struct sample tmp;
2754
Willy Tarreau7560dd42016-03-10 16:28:58 +01002755 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002756 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002757 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002758 smp->data.u.sint ^= tmp.data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002759 return 1;
2760}
2761
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002762static inline long long int arith_add(long long int a, long long int b)
2763{
2764 /* Prevent overflow and makes capped calculus.
2765 * We must ensure that the check calculus doesn't
2766 * exceed the signed 64 bits limits.
2767 *
2768 * +----------+----------+
2769 * | a<0 | a>=0 |
2770 * +------+----------+----------+
2771 * | b<0 | MIN-a>b | no check |
2772 * +------+----------+----------+
2773 * | b>=0 | no check | MAX-a<b |
2774 * +------+----------+----------+
2775 */
2776 if ((a ^ b) >= 0) {
2777 /* signs are differents. */
2778 if (a < 0) {
2779 if (LLONG_MIN - a > b)
2780 return LLONG_MIN;
2781 }
2782 if (LLONG_MAX - a < b)
2783 return LLONG_MAX;
2784 }
2785 return a + b;
2786}
2787
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002788/* Takes a SINT on input, applies an arithmetic "add" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002789 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002790 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002791static int sample_conv_arith_add(const struct arg *arg_p, struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002792{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002793 struct sample tmp;
2794
Willy Tarreau7560dd42016-03-10 16:28:58 +01002795 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002796 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002797 return 0;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002798 smp->data.u.sint = arith_add(smp->data.u.sint, tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002799 return 1;
2800}
2801
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002802/* Takes a SINT on input, applies an arithmetic "sub" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002803 * arg_p or in the variable described in arg_p, and returns the SINT result.
Willy Tarreau97707872015-01-27 15:12:13 +01002804 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002805static int sample_conv_arith_sub(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002806 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002807{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002808 struct sample tmp;
2809
Willy Tarreau7560dd42016-03-10 16:28:58 +01002810 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002811 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002812 return 0;
2813
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002814 /* We cannot represent -LLONG_MIN because abs(LLONG_MIN) is greater
2815 * than abs(LLONG_MAX). So, the following code use LLONG_MAX in place
2816 * of -LLONG_MIN and correct the result.
2817 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002818 if (tmp.data.u.sint == LLONG_MIN) {
2819 smp->data.u.sint = arith_add(smp->data.u.sint, LLONG_MAX);
2820 if (smp->data.u.sint < LLONG_MAX)
2821 smp->data.u.sint++;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002822 return 1;
2823 }
2824
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002825 /* standard subtraction: we use the "add" function and negate
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002826 * the second operand.
2827 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002828 smp->data.u.sint = arith_add(smp->data.u.sint, -tmp.data.u.sint);
Willy Tarreau97707872015-01-27 15:12:13 +01002829 return 1;
2830}
2831
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002832/* Takes a SINT on input, applies an arithmetic "mul" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002833 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002834 * If the result makes an overflow, then the largest possible quantity is
2835 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002836 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002837static int sample_conv_arith_mul(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002838 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002839{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002840 struct sample tmp;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002841 long long int c;
2842
Willy Tarreau7560dd42016-03-10 16:28:58 +01002843 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002844 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002845 return 0;
2846
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002847 /* prevent divide by 0 during the check */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002848 if (!smp->data.u.sint || !tmp.data.u.sint) {
2849 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002850 return 1;
2851 }
2852
2853 /* The multiply between LLONG_MIN and -1 returns a
2854 * "floting point exception".
2855 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002856 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2857 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002858 return 1;
2859 }
2860
2861 /* execute standard multiplication. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002862 c = smp->data.u.sint * tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002863
2864 /* check for overflow and makes capped multiply. */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002865 if (smp->data.u.sint != c / tmp.data.u.sint) {
2866 if ((smp->data.u.sint < 0) == (tmp.data.u.sint < 0)) {
2867 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002868 return 1;
2869 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002870 smp->data.u.sint = LLONG_MIN;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002871 return 1;
2872 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002873 smp->data.u.sint = c;
Willy Tarreau97707872015-01-27 15:12:13 +01002874 return 1;
2875}
2876
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002877/* Takes a SINT on input, applies an arithmetic "div" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002878 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002879 * If arg_p makes the result overflow, then the largest possible quantity is
2880 * returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002881 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002882static int sample_conv_arith_div(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002883 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002884{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002885 struct sample tmp;
2886
Willy Tarreau7560dd42016-03-10 16:28:58 +01002887 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002888 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002889 return 0;
2890
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002891 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002892 /* The divide between LLONG_MIN and -1 returns a
2893 * "floting point exception".
2894 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002895 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2896 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002897 return 1;
2898 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002899 smp->data.u.sint /= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002900 return 1;
2901 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002902 smp->data.u.sint = LLONG_MAX;
Willy Tarreau97707872015-01-27 15:12:13 +01002903 return 1;
2904}
2905
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002906/* Takes a SINT on input, applies an arithmetic "mod" with the SINT directly in
Joseph Herlant757f5ad2018-11-15 12:14:56 -08002907 * arg_p or in the variable described in arg_p, and returns the SINT result.
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002908 * If arg_p makes the result overflow, then 0 is returned.
Willy Tarreau97707872015-01-27 15:12:13 +01002909 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002910static int sample_conv_arith_mod(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002911 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002912{
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002913 struct sample tmp;
2914
Willy Tarreau7560dd42016-03-10 16:28:58 +01002915 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
Willy Tarreau6204cd92016-03-10 16:33:04 +01002916 if (!sample_conv_var2smp(arg_p, &tmp))
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02002917 return 0;
2918
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002919 if (tmp.data.u.sint) {
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002920 /* The divide between LLONG_MIN and -1 returns a
2921 * "floting point exception".
2922 */
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002923 if (smp->data.u.sint == LLONG_MIN && tmp.data.u.sint == -1) {
2924 smp->data.u.sint = 0;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002925 return 1;
2926 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002927 smp->data.u.sint %= tmp.data.u.sint;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002928 return 1;
2929 }
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002930 smp->data.u.sint = 0;
Willy Tarreau97707872015-01-27 15:12:13 +01002931 return 1;
2932}
2933
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002934/* Takes an SINT on input, applies an arithmetic "neg" and returns the SINT
Willy Tarreau97707872015-01-27 15:12:13 +01002935 * result.
2936 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002937static int sample_conv_arith_neg(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002938 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002939{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002940 if (smp->data.u.sint == LLONG_MIN)
2941 smp->data.u.sint = LLONG_MAX;
Thierry FOURNIER00c005c2015-07-08 01:10:21 +02002942 else
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002943 smp->data.u.sint = -smp->data.u.sint;
Willy Tarreau97707872015-01-27 15:12:13 +01002944 return 1;
2945}
2946
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002947/* Takes a SINT on input, returns true is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002948 * false. The output is a BOOL.
2949 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002950static int sample_conv_arith_bool(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002951 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002952{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002953 smp->data.u.sint = !!smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002954 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002955 return 1;
2956}
2957
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002958/* Takes a SINT on input, returns false is the value is non-null, otherwise
Willy Tarreau97707872015-01-27 15:12:13 +01002959 * truee. The output is a BOOL.
2960 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002961static int sample_conv_arith_not(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002962 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002963{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002964 smp->data.u.sint = !smp->data.u.sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002965 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002966 return 1;
2967}
2968
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002969/* Takes a SINT on input, returns true is the value is odd, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002970 * The output is a BOOL.
2971 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002972static int sample_conv_arith_odd(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002973 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002974{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002975 smp->data.u.sint = smp->data.u.sint & 1;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002976 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002977 return 1;
2978}
2979
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02002980/* Takes a SINT on input, returns true is the value is even, otherwise false.
Willy Tarreau97707872015-01-27 15:12:13 +01002981 * The output is a BOOL.
2982 */
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02002983static int sample_conv_arith_even(const struct arg *arg_p,
Thierry FOURNIER68a556e2015-02-23 15:11:11 +01002984 struct sample *smp, void *private)
Willy Tarreau97707872015-01-27 15:12:13 +01002985{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02002986 smp->data.u.sint = !(smp->data.u.sint & 1);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02002987 smp->data.type = SMP_T_BOOL;
Willy Tarreau97707872015-01-27 15:12:13 +01002988 return 1;
2989}
2990
Willy Tarreau280f42b2018-02-19 15:34:12 +01002991/* appends an optional const string, an optional variable contents and another
2992 * optional const string to an existing string.
2993 */
2994static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
2995{
Willy Tarreau83061a82018-07-13 11:56:34 +02002996 struct buffer *trash;
Willy Tarreau280f42b2018-02-19 15:34:12 +01002997 struct sample tmp;
2998 int max;
2999
3000 trash = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003001 trash->data = smp->data.u.str.data;
3002 if (trash->data > trash->size - 1)
3003 trash->data = trash->size - 1;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003004
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003005 memcpy(trash->area, smp->data.u.str.area, trash->data);
3006 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003007
3008 /* append first string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003009 max = arg_p[0].data.str.data;
3010 if (max > trash->size - 1 - trash->data)
3011 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003012
3013 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003014 memcpy(trash->area + trash->data, arg_p[0].data.str.area, max);
3015 trash->data += max;
3016 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003017 }
3018
3019 /* append second string (variable) if it's found and we can turn it
3020 * into a string.
3021 */
3022 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3023 if (arg_p[1].type == ARGT_VAR && vars_get_by_desc(&arg_p[1].data.var, &tmp) &&
3024 (sample_casts[tmp.data.type][SMP_T_STR] == c_none ||
3025 sample_casts[tmp.data.type][SMP_T_STR](&tmp))) {
3026
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003027 max = tmp.data.u.str.data;
3028 if (max > trash->size - 1 - trash->data)
3029 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003030
3031 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003032 memcpy(trash->area + trash->data, tmp.data.u.str.area,
3033 max);
3034 trash->data += max;
3035 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003036 }
3037 }
3038
3039 /* append third string */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003040 max = arg_p[2].data.str.data;
3041 if (max > trash->size - 1 - trash->data)
3042 max = trash->size - 1 - trash->data;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003043
3044 if (max) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003045 memcpy(trash->area + trash->data, arg_p[2].data.str.area, max);
3046 trash->data += max;
3047 trash->area[trash->data] = 0;
Willy Tarreau280f42b2018-02-19 15:34:12 +01003048 }
3049
3050 smp->data.u.str = *trash;
3051 smp->data.type = SMP_T_STR;
3052 return 1;
3053}
3054
3055/* This function checks the "concat" converter's arguments and extracts the
3056 * variable name and its scope.
3057 */
3058static int smp_check_concat(struct arg *args, struct sample_conv *conv,
3059 const char *file, int line, char **err)
3060{
3061 /* Try to decode a variable. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003062 if (args[1].data.str.data > 0 && !vars_check_arg(&args[1], NULL)) {
3063 memprintf(err, "failed to register variable name '%s'",
3064 args[1].data.str.area);
Willy Tarreau280f42b2018-02-19 15:34:12 +01003065 return 0;
3066 }
3067 return 1;
3068}
3069
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003070/* Compares string with a variable containing a string. Return value
Tim Duesterhusca097c12018-04-27 21:18:45 +02003071 * is compatible with strcmp(3)'s return value.
3072 */
3073static int sample_conv_strcmp(const struct arg *arg_p, struct sample *smp, void *private)
3074{
3075 struct sample tmp;
3076 int max, result;
3077
3078 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3079 if (arg_p[0].type != ARGT_VAR)
3080 return 0;
3081 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3082 return 0;
3083 if (!sample_casts[tmp.data.type][SMP_T_STR](&tmp))
3084 return 0;
3085
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003086 max = MIN(smp->data.u.str.data, tmp.data.u.str.data);
3087 result = strncmp(smp->data.u.str.area, tmp.data.u.str.area, max);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003088 if (result == 0) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003089 if (smp->data.u.str.data != tmp.data.u.str.data) {
3090 if (smp->data.u.str.data < tmp.data.u.str.data) {
Tim Duesterhusca097c12018-04-27 21:18:45 +02003091 result = -1;
3092 }
3093 else {
3094 result = 1;
3095 }
3096 }
3097 }
3098
3099 smp->data.u.sint = result;
3100 smp->data.type = SMP_T_SINT;
3101 return 1;
3102}
3103
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003104#ifdef USE_OPENSSL
3105/* Compares bytestring with a variable containing a bytestring. Return value
3106 * is `true` if both bytestrings are bytewise identical and `false` otherwise.
3107 *
3108 * Comparison will be performed in constant time if both bytestrings are of
3109 * the same length. If the lengths differ execution time will not be constant.
3110 */
3111static int sample_conv_secure_memcmp(const struct arg *arg_p, struct sample *smp, void *private)
3112{
3113 struct sample tmp;
3114 int result;
3115
3116 smp_set_owner(&tmp, smp->px, smp->sess, smp->strm, smp->opt);
3117 if (arg_p[0].type != ARGT_VAR)
3118 return 0;
3119 if (!vars_get_by_desc(&arg_p[0].data.var, &tmp))
3120 return 0;
3121 if (!sample_casts[tmp.data.type][SMP_T_BIN](&tmp))
3122 return 0;
3123
3124 if (smp->data.u.str.data != tmp.data.u.str.data) {
3125 smp->data.u.sint = 0;
3126 smp->data.type = SMP_T_BOOL;
3127 return 1;
3128 }
3129
3130 /* The following comparison is performed in constant time. */
3131 result = CRYPTO_memcmp(smp->data.u.str.area, tmp.data.u.str.area, smp->data.u.str.data);
3132
3133 smp->data.u.sint = result == 0;
3134 smp->data.type = SMP_T_BOOL;
3135 return 1;
3136}
3137#endif
3138
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003139#define GRPC_MSG_COMPRESS_FLAG_SZ 1 /* 1 byte */
3140#define GRPC_MSG_LENGTH_SZ 4 /* 4 bytes */
3141#define GRPC_MSG_HEADER_SZ (GRPC_MSG_COMPRESS_FLAG_SZ + GRPC_MSG_LENGTH_SZ)
3142
3143/*
3144 * Extract the field value of an input binary sample. Takes a mandatory argument:
3145 * the protocol buffers field identifier (dotted notation) internally represented
3146 * as an array of unsigned integers and its size.
3147 * Return 1 if the field was found, 0 if not.
3148 */
3149static int sample_conv_ungrpc(const struct arg *arg_p, struct sample *smp, void *private)
3150{
3151 unsigned char *pos;
3152 size_t grpc_left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003153
3154 pos = (unsigned char *)smp->data.u.str.area;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003155 grpc_left = smp->data.u.str.data;
3156
Frédéric Lécaille7c93e882019-03-04 07:33:41 +01003157 while (grpc_left > GRPC_MSG_HEADER_SZ) {
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003158 size_t grpc_msg_len, left;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003159
3160 grpc_msg_len = left = ntohl(*(uint32_t *)(pos + GRPC_MSG_COMPRESS_FLAG_SZ));
3161
3162 pos += GRPC_MSG_HEADER_SZ;
3163 grpc_left -= GRPC_MSG_HEADER_SZ;
3164
3165 if (grpc_left < left)
3166 return 0;
3167
Frédéric Lécaille5f33f852019-03-06 08:03:44 +01003168 if (protobuf_field_lookup(arg_p, smp, &pos, &left))
3169 return 1;
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003170
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003171 grpc_left -= grpc_msg_len;
3172 }
3173
3174 return 0;
3175}
3176
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003177static int sample_conv_protobuf(const struct arg *arg_p, struct sample *smp, void *private)
3178{
3179 unsigned char *pos;
3180 size_t left;
3181
3182 pos = (unsigned char *)smp->data.u.str.area;
3183 left = smp->data.u.str.data;
3184
3185 return protobuf_field_lookup(arg_p, smp, &pos, &left);
3186}
3187
3188static int sample_conv_protobuf_check(struct arg *args, struct sample_conv *conv,
3189 const char *file, int line, char **err)
Frédéric Lécaille756d97f2019-03-04 19:03:48 +01003190{
3191 if (!args[1].type) {
3192 args[1].type = ARGT_SINT;
3193 args[1].data.sint = PBUF_T_BINARY;
3194 }
3195 else {
3196 int pbuf_type;
3197
3198 pbuf_type = protobuf_type(args[1].data.str.area);
3199 if (pbuf_type == -1) {
3200 memprintf(err, "Wrong protocol buffer type '%s'", args[1].data.str.area);
3201 return 0;
3202 }
3203
3204 args[1].type = ARGT_SINT;
3205 args[1].data.sint = pbuf_type;
3206 }
3207
3208 return 1;
3209}
3210
Tim Duesterhusca097c12018-04-27 21:18:45 +02003211/* This function checks the "strcmp" converter's arguments and extracts the
3212 * variable name and its scope.
3213 */
3214static int smp_check_strcmp(struct arg *args, struct sample_conv *conv,
3215 const char *file, int line, char **err)
3216{
3217 /* Try to decode a variable. */
3218 if (vars_check_arg(&args[0], NULL))
3219 return 1;
3220
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003221 memprintf(err, "failed to register variable name '%s'",
3222 args[0].data.str.area);
Tim Duesterhusca097c12018-04-27 21:18:45 +02003223 return 0;
3224}
3225
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003226#ifdef USE_OPENSSL
3227/* This function checks the "secure_memcmp" converter's arguments and extracts the
3228 * variable name and its scope.
3229 */
3230static int smp_check_secure_memcmp(struct arg *args, struct sample_conv *conv,
3231 const char *file, int line, char **err)
3232{
3233 /* Try to decode a variable. */
3234 if (vars_check_arg(&args[0], NULL))
3235 return 1;
3236
3237 memprintf(err, "failed to register variable name '%s'",
3238 args[0].data.str.area);
3239 return 0;
3240}
3241#endif
3242
Christopher Faulet4ccc12f2020-04-01 09:08:32 +02003243/**/
3244static int sample_conv_htonl(const struct arg *arg_p, struct sample *smp, void *private)
3245{
3246 struct buffer *tmp;
3247 uint32_t n;
3248
3249 n = htonl((uint32_t)smp->data.u.sint);
3250 tmp = get_trash_chunk();
3251
3252 memcpy(b_head(tmp), &n, 4);
3253 b_add(tmp, 4);
3254
3255 smp->data.u.str = *tmp;
3256 smp->data.type = SMP_T_BIN;
3257 return 1;
3258}
3259
Christopher Fauletea159d62020-04-01 16:21:44 +02003260/**/
3261static int sample_conv_cut_crlf(const struct arg *arg_p, struct sample *smp, void *private)
3262{
3263 char *p;
3264 size_t l;
3265
3266 p = smp->data.u.str.area;
3267 for (l = 0; l < smp->data.u.str.data; l++) {
3268 if (*(p+l) == '\r' || *(p+l) == '\n')
3269 break;
3270 }
3271 smp->data.u.str.data = l;
3272 return 1;
3273}
3274
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003275/**/
3276static int sample_conv_ltrim(const struct arg *arg_p, struct sample *smp, void *private)
3277{
3278 char *delimiters, *p;
3279 size_t dlen, l;
3280
3281 delimiters = arg_p[0].data.str.area;
3282 dlen = arg_p[0].data.str.data;
3283
3284 l = smp->data.u.str.data;
3285 p = smp->data.u.str.area;
3286 while (l && memchr(delimiters, *p, dlen) != NULL) {
3287 p++;
3288 l--;
3289 }
3290
3291 smp->data.u.str.area = p;
3292 smp->data.u.str.data = l;
3293 return 1;
3294}
3295
Christopher Faulet568415a2020-04-01 17:24:47 +02003296/**/
3297static int sample_conv_rtrim(const struct arg *arg_p, struct sample *smp, void *private)
3298{
3299 char *delimiters, *p;
3300 size_t dlen, l;
3301
3302 delimiters = arg_p[0].data.str.area;
3303 dlen = arg_p[0].data.str.data;
3304
3305 l = smp->data.u.str.data;
3306 p = smp->data.u.str.area + l - 1;
3307 while (l && memchr(delimiters, *p, dlen) != NULL) {
3308 p--;
3309 l--;
3310 }
3311
3312 smp->data.u.str.data = l;
3313 return 1;
3314}
3315
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003316/************************************************************************/
3317/* All supported sample fetch functions must be declared here */
3318/************************************************************************/
3319
3320/* force TRUE to be returned at the fetch level */
3321static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003322smp_fetch_true(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003323{
Willy Tarreau280f42b2018-02-19 15:34:12 +01003324 if (!smp_make_rw(smp))
3325 return 0;
3326
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003327 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003328 smp->data.u.sint = 1;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003329 return 1;
3330}
3331
3332/* force FALSE to be returned at the fetch level */
3333static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003334smp_fetch_false(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003335{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003336 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003337 smp->data.u.sint = 0;
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003338 return 1;
3339}
3340
3341/* retrieve environment variable $1 as a string */
3342static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003343smp_fetch_env(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003344{
3345 char *env;
3346
3347 if (!args || args[0].type != ARGT_STR)
3348 return 0;
3349
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003350 env = getenv(args[0].data.str.area);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003351 if (!env)
3352 return 0;
3353
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003354 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003355 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003356 smp->data.u.str.area = env;
3357 smp->data.u.str.data = strlen(env);
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003358 return 1;
3359}
3360
Damien Claisseae6f1252019-10-30 15:57:28 +00003361/* Validates the data unit argument passed to "date" fetch. Argument 1 support an
3362 * optional string representing the unit of the result: "s" for seconds, "ms" for
3363 * milliseconds and "us" for microseconds.
3364 * Returns 0 on error and non-zero if OK.
3365 */
3366int smp_check_date_unit(struct arg *args, char **err)
3367{
3368 if (args[1].type == ARGT_STR) {
3369 if (strcmp(args[1].data.str.area, "s") == 0) {
3370 args[1].data.sint = TIME_UNIT_S;
3371 }
3372 else if (strcmp(args[1].data.str.area, "ms") == 0) {
3373 args[1].data.sint = TIME_UNIT_MS;
3374 }
3375 else if (strcmp(args[1].data.str.area, "us") == 0) {
3376 args[1].data.sint = TIME_UNIT_US;
3377 }
3378 else {
3379 memprintf(err, "expects 's', 'ms' or 'us', got '%s'",
3380 args[1].data.str.area);
3381 return 0;
3382 }
3383 free(args[1].data.str.area);
3384 args[1].data.str.area = NULL;
3385 args[1].type = ARGT_SINT;
3386 }
3387 else if (args[1].type != ARGT_STOP) {
3388 memprintf(err, "Unexpected arg type");
3389 return 0;
3390 }
3391
3392 return 1;
3393}
3394
3395/* retrieve the current local date in epoch time, converts it to milliseconds
3396 * or microseconds if asked to in optional args[1] unit param, and applies an
3397 * optional args[0] offset.
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003398 */
3399static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003400smp_fetch_date(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003401{
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003402 smp->data.u.sint = date.tv_sec;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003403
Damien Claisseae6f1252019-10-30 15:57:28 +00003404 /* report in milliseconds */
3405 if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_MS) {
3406 smp->data.u.sint *= 1000;
3407 smp->data.u.sint += date.tv_usec / 1000;
3408 }
3409 /* report in microseconds */
3410 else if (args && args[1].type == ARGT_SINT && args[1].data.sint == TIME_UNIT_US) {
3411 smp->data.u.sint *= 1000000;
3412 smp->data.u.sint += date.tv_usec;
3413 }
3414
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003415 /* add offset */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003416 if (args && args[0].type == ARGT_SINT)
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003417 smp->data.u.sint += args[0].data.sint;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003418
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003419 smp->data.type = SMP_T_SINT;
Willy Tarreau6236d3a2013-07-25 14:28:25 +02003420 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3421 return 1;
3422}
3423
Etienne Carrierea792a0a2018-01-17 13:43:24 +01003424/* retrieve the current microsecond part of the date */
3425static int
3426smp_fetch_date_us(const struct arg *args, struct sample *smp, const char *kw, void *private)
3427{
3428 smp->data.u.sint = date.tv_usec;
3429 smp->data.type = SMP_T_SINT;
3430 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3431 return 1;
3432}
3433
3434
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003435/* returns the hostname */
3436static int
3437smp_fetch_hostname(const struct arg *args, struct sample *smp, const char *kw, void *private)
3438{
3439 smp->data.type = SMP_T_STR;
3440 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003441 smp->data.u.str.area = hostname;
3442 smp->data.u.str.data = strlen(hostname);
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003443 return 1;
3444}
3445
Willy Tarreau0f30d262014-11-24 16:02:05 +01003446/* returns the number of processes */
3447static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003448smp_fetch_nbproc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003449{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003450 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003451 smp->data.u.sint = global.nbproc;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003452 return 1;
3453}
3454
3455/* returns the number of the current process (between 1 and nbproc */
3456static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003457smp_fetch_proc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003458{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003459 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003460 smp->data.u.sint = relative_pid;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003461 return 1;
3462}
3463
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003464/* returns the number of the current thread (between 1 and nbthread */
3465static int
3466smp_fetch_thread(const struct arg *args, struct sample *smp, const char *kw, void *private)
3467{
3468 smp->data.type = SMP_T_SINT;
3469 smp->data.u.sint = tid;
3470 return 1;
3471}
3472
Willy Tarreau84310e22014-02-14 11:59:04 +01003473/* generate a random 32-bit integer for whatever purpose, with an optional
3474 * range specified in argument.
3475 */
3476static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003477smp_fetch_rand(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau84310e22014-02-14 11:59:04 +01003478{
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003479 smp->data.u.sint = ha_random32();
Willy Tarreau84310e22014-02-14 11:59:04 +01003480
3481 /* reduce if needed. Don't do a modulo, use all bits! */
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003482 if (args && args[0].type == ARGT_SINT)
Willy Tarreauaa8bbc12020-03-08 18:01:10 +01003483 smp->data.u.sint = ((u64)smp->data.u.sint * (u64)args[0].data.sint) >> 32;
Willy Tarreau84310e22014-02-14 11:59:04 +01003484
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003485 smp->data.type = SMP_T_SINT;
Willy Tarreau84310e22014-02-14 11:59:04 +01003486 smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3487 return 1;
3488}
3489
Willy Tarreau0f30d262014-11-24 16:02:05 +01003490/* returns true if the current process is stopping */
3491static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02003492smp_fetch_stopping(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau0f30d262014-11-24 16:02:05 +01003493{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003494 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003495 smp->data.u.sint = stopping;
Willy Tarreau0f30d262014-11-24 16:02:05 +01003496 return 1;
3497}
3498
Willy Tarreau70fe9442018-11-22 16:07:39 +01003499/* returns the number of calls of the current stream's process_stream() */
3500static int
3501smp_fetch_cpu_calls(const struct arg *args, struct sample *smp, const char *kw, void *private)
3502{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003503 if (!smp->strm)
3504 return 0;
3505
Willy Tarreau70fe9442018-11-22 16:07:39 +01003506 smp->data.type = SMP_T_SINT;
3507 smp->data.u.sint = smp->strm->task->calls;
3508 return 1;
3509}
3510
3511/* returns the average number of nanoseconds spent processing the stream per call */
3512static int
3513smp_fetch_cpu_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3514{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003515 if (!smp->strm)
3516 return 0;
3517
Willy Tarreau70fe9442018-11-22 16:07:39 +01003518 smp->data.type = SMP_T_SINT;
3519 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->cpu_time / smp->strm->task->calls : 0;
3520 return 1;
3521}
3522
3523/* returns the total number of nanoseconds spent processing the stream */
3524static int
3525smp_fetch_cpu_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3526{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003527 if (!smp->strm)
3528 return 0;
3529
Willy Tarreau70fe9442018-11-22 16:07:39 +01003530 smp->data.type = SMP_T_SINT;
3531 smp->data.u.sint = smp->strm->task->cpu_time;
3532 return 1;
3533}
3534
3535/* returns the average number of nanoseconds per call spent waiting for other tasks to be processed */
3536static int
3537smp_fetch_lat_ns_avg(const struct arg *args, struct sample *smp, const char *kw, void *private)
3538{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003539 if (!smp->strm)
3540 return 0;
3541
Willy Tarreau70fe9442018-11-22 16:07:39 +01003542 smp->data.type = SMP_T_SINT;
3543 smp->data.u.sint = smp->strm->task->calls ? smp->strm->task->lat_time / smp->strm->task->calls : 0;
3544 return 1;
3545}
3546
3547/* returns the total number of nanoseconds per call spent waiting for other tasks to be processed */
3548static int
3549smp_fetch_lat_ns_tot(const struct arg *args, struct sample *smp, const char *kw, void *private)
3550{
Willy Tarreaue0dd2102020-04-29 11:59:02 +02003551 if (!smp->strm)
3552 return 0;
3553
Willy Tarreau70fe9442018-11-22 16:07:39 +01003554 smp->data.type = SMP_T_SINT;
3555 smp->data.u.sint = smp->strm->task->lat_time;
3556 return 1;
3557}
3558
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003559static int smp_fetch_const_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
3560{
3561 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003562 smp->data.type = SMP_T_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003563 smp->data.u.str.area = args[0].data.str.area;
3564 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003565 return 1;
3566}
3567
3568static int smp_check_const_bool(struct arg *args, char **err)
3569{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003570 if (strcasecmp(args[0].data.str.area, "true") == 0 ||
3571 strcasecmp(args[0].data.str.area, "1") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003572 args[0].type = ARGT_SINT;
3573 args[0].data.sint = 1;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003574 return 1;
3575 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003576 if (strcasecmp(args[0].data.str.area, "false") == 0 ||
3577 strcasecmp(args[0].data.str.area, "0") == 0) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003578 args[0].type = ARGT_SINT;
3579 args[0].data.sint = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003580 return 1;
3581 }
3582 memprintf(err, "Expects 'true', 'false', '0' or '1'");
3583 return 0;
3584}
3585
3586static int smp_fetch_const_bool(const struct arg *args, struct sample *smp, const char *kw, void *private)
3587{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003588 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003589 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003590 return 1;
3591}
3592
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003593static int smp_fetch_const_int(const struct arg *args, struct sample *smp, const char *kw, void *private)
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003594{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003595 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003596 smp->data.u.sint = args[0].data.sint;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003597 return 1;
3598}
3599
3600static int smp_fetch_const_ipv4(const struct arg *args, struct sample *smp, const char *kw, void *private)
3601{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003602 smp->data.type = SMP_T_IPV4;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003603 smp->data.u.ipv4 = args[0].data.ipv4;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003604 return 1;
3605}
3606
3607static int smp_fetch_const_ipv6(const struct arg *args, struct sample *smp, const char *kw, void *private)
3608{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003609 smp->data.type = SMP_T_IPV6;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003610 smp->data.u.ipv6 = args[0].data.ipv6;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003611 return 1;
3612}
3613
3614static int smp_check_const_bin(struct arg *args, char **err)
3615{
David Carlier64a16ab2016-04-08 10:37:02 +01003616 char *binstr = NULL;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003617 int binstrlen;
3618
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003619 if (!parse_binary(args[0].data.str.area, &binstr, &binstrlen, err))
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003620 return 0;
3621 args[0].type = ARGT_STR;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003622 args[0].data.str.area = binstr;
3623 args[0].data.str.data = binstrlen;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003624 return 1;
3625}
3626
3627static int smp_fetch_const_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
3628{
3629 smp->flags |= SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003630 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003631 smp->data.u.str.area = args[0].data.str.area;
3632 smp->data.u.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003633 return 1;
3634}
3635
3636static int smp_check_const_meth(struct arg *args, char **err)
3637{
3638 enum http_meth_t meth;
3639 int i;
3640
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003641 meth = find_http_meth(args[0].data.str.area, args[0].data.str.data);
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003642 if (meth != HTTP_METH_OTHER) {
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003643 args[0].type = ARGT_SINT;
3644 args[0].data.sint = meth;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003645 } else {
3646 /* Check method avalaibility. A methos is a token defined as :
3647 * tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
3648 * "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
3649 * token = 1*tchar
3650 */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003651 for (i = 0; i < args[0].data.str.data; i++) {
3652 if (!HTTP_IS_TOKEN(args[0].data.str.area[i])) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003653 memprintf(err, "expects valid method.");
3654 return 0;
3655 }
3656 }
3657 }
3658 return 1;
3659}
3660
3661static int smp_fetch_const_meth(const struct arg *args, struct sample *smp, const char *kw, void *private)
3662{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02003663 smp->data.type = SMP_T_METH;
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003664 if (args[0].type == ARGT_SINT) {
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003665 smp->flags &= ~SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003666 smp->data.u.meth.meth = args[0].data.sint;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003667 smp->data.u.meth.str.area = "";
3668 smp->data.u.meth.str.data = 0;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003669 } else {
3670 smp->flags |= SMP_F_CONST;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02003671 smp->data.u.meth.meth = HTTP_METH_OTHER;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003672 smp->data.u.meth.str.area = args[0].data.str.area;
3673 smp->data.u.meth.str.data = args[0].data.str.data;
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003674 }
3675 return 1;
3676}
3677
Luca Schimweg8a694b82019-09-10 15:42:52 +02003678// This function checks the "uuid" sample's arguments.
3679// Function won't get called when no parameter is specified (maybe a bug?)
3680static int smp_check_uuid(struct arg *args, char **err)
3681{
3682 if (!args[0].type) {
3683 args[0].type = ARGT_SINT;
3684 args[0].data.sint = 4;
3685 }
3686 else if (args[0].data.sint != 4) {
3687 memprintf(err, "Unsupported UUID version: '%lld'", args[0].data.sint);
3688 return 0;
3689 }
3690
3691 return 1;
3692}
3693
3694// Generate a RFC4122 UUID (default is v4 = fully random)
3695static int smp_fetch_uuid(const struct arg *args, struct sample *smp, const char *kw, void *private)
3696{
3697 if (args[0].data.sint == 4 || !args[0].type) {
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01003698 ha_generate_uuid(&trash);
Luca Schimweg8a694b82019-09-10 15:42:52 +02003699 smp->data.type = SMP_T_STR;
3700 smp->flags = SMP_F_VOL_TEST | SMP_F_MAY_CHANGE;
3701 smp->data.u.str = trash;
3702 return 1;
3703 }
3704
3705 // more implementations of other uuid formats possible here
3706 return 0;
3707}
3708
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003709/* Note: must not be declared <const> as its list will be overwritten.
3710 * Note: fetches that may return multiple types must be declared as the lowest
3711 * common denominator, the type that can be casted into all other ones. For
3712 * instance IPv4/IPv6 must be declared IPv4.
3713 */
3714static struct sample_fetch_kw_list smp_kws = {ILH, {
3715 { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
3716 { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01003717 { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN },
Damien Claisseae6f1252019-10-30 15:57:28 +00003718 { "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 +01003719 { "date_us", smp_fetch_date_us, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Nenad Merdanovic807a6e72017-03-12 22:00:00 +01003720 { "hostname", smp_fetch_hostname, 0, NULL, SMP_T_STR, SMP_USE_INTRN },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003721 { "nbproc", smp_fetch_nbproc,0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3722 { "proc", smp_fetch_proc, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Christopher Faulet34adb2a2017-11-21 21:45:38 +01003723 { "thread", smp_fetch_thread, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003724 { "rand", smp_fetch_rand, ARG1(0,SINT), NULL, SMP_T_SINT, SMP_USE_INTRN },
Willy Tarreau0f30d262014-11-24 16:02:05 +01003725 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003726 { "stopping", smp_fetch_stopping, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN },
Luca Schimweg8a694b82019-09-10 15:42:52 +02003727 { "uuid", smp_fetch_uuid, ARG1(0, SINT), smp_check_uuid, SMP_T_STR, SMP_USE_INTRN },
Willy Tarreau70fe9442018-11-22 16:07:39 +01003728
3729 { "cpu_calls", smp_fetch_cpu_calls, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3730 { "cpu_ns_avg", smp_fetch_cpu_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3731 { "cpu_ns_tot", smp_fetch_cpu_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3732 { "lat_ns_avg", smp_fetch_lat_ns_avg, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
3733 { "lat_ns_tot", smp_fetch_lat_ns_tot, 0, NULL, SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003734
3735 { "str", smp_fetch_const_str, ARG1(1,STR), NULL , SMP_T_STR, SMP_USE_INTRN },
3736 { "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 +02003737 { "int", smp_fetch_const_int, ARG1(1,SINT), NULL , SMP_T_SINT, SMP_USE_INTRN },
Thierry FOURNIERcc103292015-06-06 19:30:17 +02003738 { "ipv4", smp_fetch_const_ipv4, ARG1(1,IPV4), NULL , SMP_T_IPV4, SMP_USE_INTRN },
3739 { "ipv6", smp_fetch_const_ipv6, ARG1(1,IPV6), NULL , SMP_T_IPV6, SMP_USE_INTRN },
3740 { "bin", smp_fetch_const_bin, ARG1(1,STR), smp_check_const_bin , SMP_T_BIN, SMP_USE_INTRN },
3741 { "meth", smp_fetch_const_meth, ARG1(1,STR), smp_check_const_meth, SMP_T_METH, SMP_USE_INTRN },
3742
Willy Tarreau5b8ad222013-07-25 12:17:57 +02003743 { /* END */ },
3744}};
3745
Willy Tarreau0108d902018-11-25 19:14:37 +01003746INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
3747
Emeric Brun107ca302010-01-04 16:16:05 +01003748/* Note: must not be declared <const> as its list will be overwritten */
Willy Tarreaudc13c112013-06-21 23:16:39 +02003749static struct sample_conv_kw_list sample_conv_kws = {ILH, {
Willy Tarreau0851fd52019-12-17 10:07:25 +01003750 { "debug", sample_conv_debug, ARG2(0,STR,STR), smp_check_debug, SMP_T_ANY, SMP_T_ANY },
Holger Just1bfc24b2017-05-06 00:56:53 +02003751 { "b64dec", sample_conv_base642bin,0, NULL, SMP_T_STR, SMP_T_BIN },
Emeric Brun53d1a982014-04-30 18:21:37 +02003752 { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR },
Willy Tarreau12785782012-04-27 21:37:17 +02003753 { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR },
3754 { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau60a2ee72017-12-15 07:13:48 +01003755 { "length", sample_conv_length, 0, NULL, SMP_T_STR, SMP_T_SINT },
Thierry FOURNIER2f49d6d2014-03-12 15:01:52 +01003756 { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR },
Dragan Dosen3f957b22017-10-24 09:27:34 +02003757 { "hex2i", sample_conv_hex2int, 0, NULL, SMP_T_STR, SMP_T_SINT },
Tim Duesterhus1478aa72018-01-25 16:24:51 +01003758 { "ipmask", sample_conv_ipmask, ARG2(1,MSK4,MSK6), NULL, SMP_T_ADDR, SMP_T_IPV4 },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02003759 { "ltime", sample_conv_ltime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
3760 { "utime", sample_conv_utime, ARG2(1,STR,SINT), NULL, SMP_T_SINT, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003761 { "crc32", sample_conv_crc32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Emmanuel Hocdet50791a72018-03-21 11:19:01 +01003762 { "crc32c", sample_conv_crc32c, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003763 { "djb2", sample_conv_djb2, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3764 { "sdbm", sample_conv_sdbm, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3765 { "wt6", sample_conv_wt6, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER01e09742016-12-26 11:46:11 +01003766 { "xxh32", sample_conv_xxh32, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
3767 { "xxh64", sample_conv_xxh64, ARG1(0,SINT), NULL, SMP_T_BIN, SMP_T_SINT },
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003768 { "json", sample_conv_json, ARG1(1,STR), sample_conv_json_check, SMP_T_STR, SMP_T_STR },
Thierry FOURNIERbf65cd42015-07-20 17:45:02 +02003769 { "bytes", sample_conv_bytes, ARG2(1,SINT,SINT), NULL, SMP_T_BIN, SMP_T_BIN },
Marcin Deranek9631a282018-04-16 14:30:46 +02003770 { "field", sample_conv_field, ARG3(2,SINT,STR,SINT), sample_conv_field_check, SMP_T_STR, SMP_T_STR },
3771 { "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 +01003772 { "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 +02003773 { "sha1", sample_conv_sha1, 0, NULL, SMP_T_BIN, SMP_T_BIN },
Tim Duesterhusd4376302019-06-17 12:41:44 +02003774#ifdef USE_OPENSSL
Tim Duesterhuscd373242019-12-17 12:31:20 +01003775 { "sha2", sample_conv_sha2, ARG1(0, SINT), smp_check_sha2, SMP_T_BIN, SMP_T_BIN },
Patrick Ganstererb399bfb2018-06-17 11:21:11 +02003776#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
3777 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
3778#endif
Patrick Gansterer8e366512020-04-22 16:47:57 +02003779 { "digest", sample_conv_crypto_digest, ARG1(1,STR), check_crypto_digest, SMP_T_BIN, SMP_T_BIN },
3780 { "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 +02003781#endif
Willy Tarreau280f42b2018-02-19 15:34:12 +01003782 { "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 +02003783 { "strcmp", sample_conv_strcmp, ARG1(1,STR), smp_check_strcmp, SMP_T_STR, SMP_T_SINT },
Tim Duesterhusf38175c2020-06-09 11:48:42 +02003784#ifdef USE_OPENSSL
3785 { "secure_memcmp", sample_conv_secure_memcmp, ARG1(1,STR), smp_check_secure_memcmp, SMP_T_BIN, SMP_T_BOOL },
3786#endif
Frédéric Lécaille50290fb2019-02-27 14:34:51 +01003787
3788 /* gRPC converters. */
Frédéric Lécaillebfe61382019-03-06 14:34:36 +01003789 { "ungrpc", sample_conv_ungrpc, ARG2(1,PBUF_FNUM,STR), sample_conv_protobuf_check, SMP_T_BIN, SMP_T_BIN },
3790 { "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 +01003791
Thierry FOURNIER5d86fae2015-07-07 21:10:16 +02003792 { "and", sample_conv_binary_and, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3793 { "or", sample_conv_binary_or, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3794 { "xor", sample_conv_binary_xor, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3795 { "cpl", sample_conv_binary_cpl, 0, NULL, SMP_T_SINT, SMP_T_SINT },
3796 { "bool", sample_conv_arith_bool, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3797 { "not", sample_conv_arith_not, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3798 { "odd", sample_conv_arith_odd, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3799 { "even", sample_conv_arith_even, 0, NULL, SMP_T_SINT, SMP_T_BOOL },
3800 { "add", sample_conv_arith_add, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3801 { "sub", sample_conv_arith_sub, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3802 { "mul", sample_conv_arith_mul, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3803 { "div", sample_conv_arith_div, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3804 { "mod", sample_conv_arith_mod, ARG1(1,STR), check_operator, SMP_T_SINT, SMP_T_SINT },
3805 { "neg", sample_conv_arith_neg, 0, NULL, SMP_T_SINT, SMP_T_SINT },
Willy Tarreau97707872015-01-27 15:12:13 +01003806
Christopher Fauletea159d62020-04-01 16:21:44 +02003807 { "htonl", sample_conv_htonl, 0, NULL, SMP_T_SINT, SMP_T_BIN },
3808 { "cut_crlf", sample_conv_cut_crlf, 0, NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet51fc9d12020-04-01 17:24:41 +02003809 { "ltrim", sample_conv_ltrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Christopher Faulet568415a2020-04-01 17:24:47 +02003810 { "rtrim", sample_conv_rtrim, ARG1(1,STR), NULL, SMP_T_STR, SMP_T_STR },
Willy Tarreau9fcb9842012-04-20 14:45:49 +02003811 { NULL, NULL, 0, 0, 0 },
Emeric Brun107ca302010-01-04 16:16:05 +01003812}};
3813
Willy Tarreau0108d902018-11-25 19:14:37 +01003814INITCALL1(STG_REGISTER, sample_register_convs, &sample_conv_kws);