Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1 | /* |
Willy Tarreau | cd3b094 | 2012-04-27 21:52:18 +0200 | [diff] [blame] | 2 | * Sample management functions. |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 3 | * |
| 4 | * Copyright 2009-2010 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr> |
Willy Tarreau | cd3b094 | 2012-04-27 21:52:18 +0200 | [diff] [blame] | 5 | * Copyright (C) 2012 Willy Tarreau <w@1wt.eu> |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 6 | * |
| 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 | |
| 14 | #include <string.h> |
| 15 | #include <arpa/inet.h> |
Willy Tarreau | dd2f85e | 2012-09-02 22:34:23 +0200 | [diff] [blame] | 16 | #include <stdio.h> |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 17 | |
Willy Tarreau | 7e2c647 | 2012-10-29 20:44:36 +0100 | [diff] [blame] | 18 | #include <types/global.h> |
| 19 | |
Willy Tarreau | c7e4238 | 2012-08-24 19:22:53 +0200 | [diff] [blame] | 20 | #include <common/chunk.h> |
Willy Tarreau | cd3b094 | 2012-04-27 21:52:18 +0200 | [diff] [blame] | 21 | #include <common/standard.h> |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 22 | #include <common/uri_auth.h> |
Emeric Brun | 53d1a98 | 2014-04-30 18:21:37 +0200 | [diff] [blame] | 23 | #include <common/base64.h> |
Willy Tarreau | cd3b094 | 2012-04-27 21:52:18 +0200 | [diff] [blame] | 24 | |
Willy Tarreau | 9fcb984 | 2012-04-20 14:45:49 +0200 | [diff] [blame] | 25 | #include <proto/arg.h> |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 26 | #include <proto/auth.h> |
| 27 | #include <proto/log.h> |
Thierry FOURNIER | d437314 | 2013-12-17 01:10:10 +0100 | [diff] [blame] | 28 | #include <proto/proto_http.h> |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 29 | #include <proto/proxy.h> |
Willy Tarreau | cd3b094 | 2012-04-27 21:52:18 +0200 | [diff] [blame] | 30 | #include <proto/sample.h> |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 31 | #include <proto/stick_table.h> |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 32 | |
Willy Tarreau | 1cf8f08 | 2014-02-07 12:14:54 +0100 | [diff] [blame] | 33 | /* sample type names */ |
| 34 | const char *smp_to_type[SMP_TYPES] = { |
| 35 | [SMP_T_BOOL] = "bool", |
| 36 | [SMP_T_UINT] = "uint", |
| 37 | [SMP_T_SINT] = "sint", |
| 38 | [SMP_T_ADDR] = "addr", |
| 39 | [SMP_T_IPV4] = "ipv4", |
| 40 | [SMP_T_IPV6] = "ipv6", |
| 41 | [SMP_T_STR] = "str", |
| 42 | [SMP_T_BIN] = "bin", |
Willy Tarreau | 1cf8f08 | 2014-02-07 12:14:54 +0100 | [diff] [blame] | 43 | }; |
| 44 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 45 | /* static sample used in sample_process() when <p> is NULL */ |
Willy Tarreau | b4a88f0 | 2012-04-23 21:35:11 +0200 | [diff] [blame] | 46 | static struct sample temp_smp; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 47 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 48 | /* list head of all known sample fetch keywords */ |
| 49 | static struct sample_fetch_kw_list sample_fetches = { |
| 50 | .list = LIST_HEAD_INIT(sample_fetches.list) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 51 | }; |
| 52 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 53 | /* list head of all known sample format conversion keywords */ |
| 54 | static struct sample_conv_kw_list sample_convs = { |
| 55 | .list = LIST_HEAD_INIT(sample_convs.list) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 56 | }; |
| 57 | |
Willy Tarreau | 80aca90 | 2013-01-07 15:42:20 +0100 | [diff] [blame] | 58 | const unsigned int fetch_cap[SMP_SRC_ENTRIES] = { |
| 59 | [SMP_SRC_INTRN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 60 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 61 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 62 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 63 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 64 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 65 | SMP_VAL_FE_LOG_END), |
| 66 | |
| 67 | [SMP_SRC_LISTN] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 68 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 69 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 70 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 71 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 72 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 73 | SMP_VAL_FE_LOG_END), |
| 74 | |
| 75 | [SMP_SRC_FTEND] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 76 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 77 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 78 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 79 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 80 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 81 | SMP_VAL_FE_LOG_END), |
| 82 | |
| 83 | [SMP_SRC_L4CLI] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 84 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 85 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 86 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 87 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 88 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 89 | SMP_VAL_FE_LOG_END), |
| 90 | |
| 91 | [SMP_SRC_L5CLI] = (SMP_VAL___________ | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 92 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 93 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 94 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 95 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 96 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 97 | SMP_VAL_FE_LOG_END), |
| 98 | |
| 99 | [SMP_SRC_TRACK] = (SMP_VAL_FE_CON_ACC | SMP_VAL_FE_SES_ACC | SMP_VAL_FE_REQ_CNT | |
| 100 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 101 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 102 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 103 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 104 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 105 | SMP_VAL_FE_LOG_END), |
| 106 | |
| 107 | [SMP_SRC_L6REQ] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT | |
| 108 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 109 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 110 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ | |
| 111 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 112 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 113 | SMP_VAL___________), |
| 114 | |
| 115 | [SMP_SRC_HRQHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT | |
| 116 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 117 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 118 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ | |
| 119 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 120 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 121 | SMP_VAL___________), |
| 122 | |
| 123 | [SMP_SRC_HRQHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_FE_REQ_CNT | |
| 124 | SMP_VAL_FE_HRQ_HDR | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 125 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 126 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 127 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 128 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 129 | SMP_VAL_FE_LOG_END), |
| 130 | |
| 131 | [SMP_SRC_HRQBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 132 | SMP_VAL___________ | SMP_VAL_FE_HRQ_BDY | SMP_VAL_FE_SET_BCK | |
| 133 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 134 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL___________ | |
| 135 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 136 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 137 | SMP_VAL___________), |
| 138 | |
| 139 | [SMP_SRC_BKEND] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 140 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 141 | SMP_VAL_BE_REQ_CNT | SMP_VAL_BE_HRQ_HDR | SMP_VAL_BE_HRQ_BDY | |
| 142 | SMP_VAL_BE_SET_SRV | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 143 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 144 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 145 | SMP_VAL_FE_LOG_END), |
| 146 | |
| 147 | [SMP_SRC_SERVR] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 148 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 149 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 150 | SMP_VAL___________ | SMP_VAL_BE_SRV_CON | SMP_VAL_BE_RES_CNT | |
| 151 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 152 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 153 | SMP_VAL_FE_LOG_END), |
| 154 | |
| 155 | [SMP_SRC_L4SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 156 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 157 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 158 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT | |
| 159 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 160 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 161 | SMP_VAL_FE_LOG_END), |
| 162 | |
| 163 | [SMP_SRC_L5SRV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 164 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 165 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 166 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT | |
| 167 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 168 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 169 | SMP_VAL_FE_LOG_END), |
| 170 | |
| 171 | [SMP_SRC_L6RES] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 172 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 173 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 174 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT | |
| 175 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 176 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 177 | SMP_VAL___________), |
| 178 | |
| 179 | [SMP_SRC_HRSHV] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 180 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 181 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 182 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT | |
| 183 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 184 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 185 | SMP_VAL___________), |
| 186 | |
| 187 | [SMP_SRC_HRSHP] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 188 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 189 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 190 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL_BE_RES_CNT | |
| 191 | SMP_VAL_BE_HRS_HDR | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 192 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 193 | SMP_VAL_FE_LOG_END), |
| 194 | |
| 195 | [SMP_SRC_HRSBO] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 196 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 197 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 198 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 199 | SMP_VAL___________ | SMP_VAL_BE_HRS_BDY | SMP_VAL_BE_STO_RUL | |
| 200 | SMP_VAL_FE_RES_CNT | SMP_VAL_FE_HRS_HDR | SMP_VAL_FE_HRS_BDY | |
| 201 | SMP_VAL___________), |
| 202 | |
| 203 | [SMP_SRC_RQFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 204 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 205 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 206 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 207 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 208 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 209 | SMP_VAL_FE_LOG_END), |
| 210 | |
| 211 | [SMP_SRC_RSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 212 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 213 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 214 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 215 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 216 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 217 | SMP_VAL_FE_LOG_END), |
| 218 | |
| 219 | [SMP_SRC_TXFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 220 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 221 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 222 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 223 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 224 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 225 | SMP_VAL_FE_LOG_END), |
| 226 | |
| 227 | [SMP_SRC_SSFIN] = (SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 228 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 229 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 230 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 231 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 232 | SMP_VAL___________ | SMP_VAL___________ | SMP_VAL___________ | |
| 233 | SMP_VAL_FE_LOG_END), |
| 234 | }; |
| 235 | |
| 236 | static const char *fetch_src_names[SMP_SRC_ENTRIES] = { |
| 237 | [SMP_SRC_INTRN] = "internal state", |
| 238 | [SMP_SRC_LISTN] = "listener", |
| 239 | [SMP_SRC_FTEND] = "frontend", |
| 240 | [SMP_SRC_L4CLI] = "client address", |
| 241 | [SMP_SRC_L5CLI] = "client-side connection", |
| 242 | [SMP_SRC_TRACK] = "track counters", |
| 243 | [SMP_SRC_L6REQ] = "request buffer", |
| 244 | [SMP_SRC_HRQHV] = "HTTP request headers", |
| 245 | [SMP_SRC_HRQHP] = "HTTP request", |
| 246 | [SMP_SRC_HRQBO] = "HTTP request body", |
| 247 | [SMP_SRC_BKEND] = "backend", |
| 248 | [SMP_SRC_SERVR] = "server", |
| 249 | [SMP_SRC_L4SRV] = "server address", |
| 250 | [SMP_SRC_L5SRV] = "server-side connection", |
| 251 | [SMP_SRC_L6RES] = "response buffer", |
| 252 | [SMP_SRC_HRSHV] = "HTTP response headers", |
| 253 | [SMP_SRC_HRSHP] = "HTTP response", |
| 254 | [SMP_SRC_HRSBO] = "HTTP response body", |
| 255 | [SMP_SRC_RQFIN] = "request buffer statistics", |
| 256 | [SMP_SRC_RSFIN] = "response buffer statistics", |
| 257 | [SMP_SRC_TXFIN] = "transaction statistics", |
| 258 | [SMP_SRC_SSFIN] = "session statistics", |
| 259 | }; |
| 260 | |
Willy Tarreau | bf8e251 | 2013-03-25 14:52:41 +0100 | [diff] [blame] | 261 | static const char *fetch_ckp_names[SMP_CKP_ENTRIES] = { |
| 262 | [SMP_CKP_FE_CON_ACC] = "frontend tcp-request connection rule", |
| 263 | [SMP_CKP_FE_SES_ACC] = "frontend tcp-request session rule", |
| 264 | [SMP_CKP_FE_REQ_CNT] = "frontend tcp-request content rule", |
| 265 | [SMP_CKP_FE_HRQ_HDR] = "frontend http-request header rule", |
| 266 | [SMP_CKP_FE_HRQ_BDY] = "frontend http-request body rule", |
| 267 | [SMP_CKP_FE_SET_BCK] = "frontend use-backend rule", |
| 268 | [SMP_CKP_BE_REQ_CNT] = "backend tcp-request content rule", |
| 269 | [SMP_CKP_BE_HRQ_HDR] = "backend http-request header rule", |
| 270 | [SMP_CKP_BE_HRQ_BDY] = "backend http-request body rule", |
| 271 | [SMP_CKP_BE_SET_SRV] = "backend use-server, balance or stick-match rule", |
| 272 | [SMP_CKP_BE_SRV_CON] = "server source selection", |
| 273 | [SMP_CKP_BE_RES_CNT] = "backend tcp-response content rule", |
| 274 | [SMP_CKP_BE_HRS_HDR] = "backend http-response header rule", |
| 275 | [SMP_CKP_BE_HRS_BDY] = "backend http-response body rule", |
| 276 | [SMP_CKP_BE_STO_RUL] = "backend stick-store rule", |
| 277 | [SMP_CKP_FE_RES_CNT] = "frontend tcp-response content rule", |
| 278 | [SMP_CKP_FE_HRS_HDR] = "frontend http-response header rule", |
| 279 | [SMP_CKP_FE_HRS_BDY] = "frontend http-response body rule", |
| 280 | [SMP_CKP_FE_LOG_END] = "logs", |
| 281 | }; |
| 282 | |
Thierry FOURNIER | 348971e | 2013-11-21 10:50:10 +0100 | [diff] [blame] | 283 | /* This function returns the type of the data returned by the sample_expr. |
| 284 | * It assumes that the <expr> and all of its converters are properly |
| 285 | * initialized. |
| 286 | */ |
| 287 | inline |
| 288 | int smp_expr_output_type(struct sample_expr *expr) |
| 289 | { |
| 290 | struct sample_conv_expr *smp_expr; |
| 291 | |
| 292 | if (!LIST_ISEMPTY(&expr->conv_exprs)) { |
| 293 | smp_expr = LIST_PREV(&expr->conv_exprs, struct sample_conv_expr *, list); |
| 294 | return smp_expr->conv->out_type; |
| 295 | } |
| 296 | return expr->fetch->out_type; |
| 297 | } |
| 298 | |
| 299 | |
Willy Tarreau | 80aca90 | 2013-01-07 15:42:20 +0100 | [diff] [blame] | 300 | /* fill the trash with a comma-delimited list of source names for the <use> bit |
| 301 | * field which must be composed of a non-null set of SMP_USE_* flags. The return |
| 302 | * value is the pointer to the string in the trash buffer. |
| 303 | */ |
| 304 | const char *sample_src_names(unsigned int use) |
| 305 | { |
| 306 | int bit; |
| 307 | |
| 308 | trash.len = 0; |
| 309 | trash.str[0] = '\0'; |
| 310 | for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) { |
| 311 | if (!(use & ~((1 << bit) - 1))) |
| 312 | break; /* no more bits */ |
| 313 | |
| 314 | if (!(use & (1 << bit))) |
| 315 | continue; /* bit not set */ |
| 316 | |
| 317 | trash.len += snprintf(trash.str + trash.len, trash.size - trash.len, "%s%s", |
| 318 | (use & ((1 << bit) - 1)) ? "," : "", |
| 319 | fetch_src_names[bit]); |
| 320 | } |
| 321 | return trash.str; |
| 322 | } |
| 323 | |
Willy Tarreau | bf8e251 | 2013-03-25 14:52:41 +0100 | [diff] [blame] | 324 | /* return a pointer to the correct sample checkpoint name, or "unknown" when |
| 325 | * the flags are invalid. Only the lowest bit is used, higher bits are ignored |
| 326 | * if set. |
| 327 | */ |
| 328 | const char *sample_ckp_names(unsigned int use) |
| 329 | { |
| 330 | int bit; |
| 331 | |
| 332 | for (bit = 0; bit < SMP_CKP_ENTRIES; bit++) |
| 333 | if (use & (1 << bit)) |
| 334 | return fetch_ckp_names[bit]; |
| 335 | return "unknown sample check place, please report this bug"; |
| 336 | } |
| 337 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 338 | /* |
Willy Tarreau | 80aca90 | 2013-01-07 15:42:20 +0100 | [diff] [blame] | 339 | * Registers the sample fetch keyword list <kwl> as a list of valid keywords |
| 340 | * for next parsing sessions. The fetch keywords capabilities are also computed |
| 341 | * from their ->use field. |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 342 | */ |
Willy Tarreau | 80aca90 | 2013-01-07 15:42:20 +0100 | [diff] [blame] | 343 | void sample_register_fetches(struct sample_fetch_kw_list *kwl) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 344 | { |
Willy Tarreau | 80aca90 | 2013-01-07 15:42:20 +0100 | [diff] [blame] | 345 | struct sample_fetch *sf; |
| 346 | int bit; |
| 347 | |
| 348 | for (sf = kwl->kw; sf->kw != NULL; sf++) { |
| 349 | for (bit = 0; bit < SMP_SRC_ENTRIES; bit++) |
| 350 | if (sf->use & (1 << bit)) |
| 351 | sf->val |= fetch_cap[bit]; |
| 352 | } |
| 353 | LIST_ADDQ(&sample_fetches.list, &kwl->list); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 354 | } |
| 355 | |
| 356 | /* |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 357 | * Registers the sample format coverstion keyword list <pckl> as a list of valid keywords for next |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 358 | * parsing sessions. |
| 359 | */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 360 | void sample_register_convs(struct sample_conv_kw_list *pckl) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 361 | { |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 362 | LIST_ADDQ(&sample_convs.list, &pckl->list); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | /* |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 366 | * Returns the pointer on sample fetch keyword structure identified by |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 367 | * string of <len> in buffer <kw>. |
| 368 | * |
| 369 | */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 370 | struct sample_fetch *find_sample_fetch(const char *kw, int len) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 371 | { |
| 372 | int index; |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 373 | struct sample_fetch_kw_list *kwl; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 374 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 375 | list_for_each_entry(kwl, &sample_fetches.list, list) { |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 376 | for (index = 0; kwl->kw[index].kw != NULL; index++) { |
| 377 | if (strncmp(kwl->kw[index].kw, kw, len) == 0 && |
| 378 | kwl->kw[index].kw[len] == '\0') |
| 379 | return &kwl->kw[index]; |
| 380 | } |
| 381 | } |
| 382 | return NULL; |
| 383 | } |
| 384 | |
| 385 | /* |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 386 | * Returns the pointer on sample format conversion keyword structure identified by |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 387 | * string of <len> in buffer <kw>. |
| 388 | * |
| 389 | */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 390 | struct sample_conv *find_sample_conv(const char *kw, int len) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 391 | { |
| 392 | int index; |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 393 | struct sample_conv_kw_list *kwl; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 394 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 395 | list_for_each_entry(kwl, &sample_convs.list, list) { |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 396 | for (index = 0; kwl->kw[index].kw != NULL; index++) { |
| 397 | if (strncmp(kwl->kw[index].kw, kw, len) == 0 && |
| 398 | kwl->kw[index].kw[len] == '\0') |
| 399 | return &kwl->kw[index]; |
| 400 | } |
| 401 | } |
| 402 | return NULL; |
| 403 | } |
| 404 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 405 | /******************************************************************/ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 406 | /* Sample casts functions */ |
Willy Tarreau | b8c8f1f | 2012-04-23 22:38:26 +0200 | [diff] [blame] | 407 | /* Note: these functions do *NOT* set the output type on the */ |
| 408 | /* sample, the caller is responsible for doing this on return. */ |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 409 | /******************************************************************/ |
| 410 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 411 | static int c_ip2int(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 412 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 413 | smp->data.uint = ntohl(smp->data.ipv4.s_addr); |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 414 | smp->type = SMP_T_UINT; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 415 | return 1; |
| 416 | } |
| 417 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 418 | static int c_ip2str(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 419 | { |
Willy Tarreau | 47ca545 | 2012-12-23 20:22:19 +0100 | [diff] [blame] | 420 | struct chunk *trash = get_trash_chunk(); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 421 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 422 | if (!inet_ntop(AF_INET, (void *)&smp->data.ipv4, trash->str, trash->size)) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 423 | return 0; |
| 424 | |
| 425 | trash->len = strlen(trash->str); |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 426 | smp->data.str = *trash; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 427 | smp->type = SMP_T_STR; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 428 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 429 | |
| 430 | return 1; |
| 431 | } |
| 432 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 433 | static int c_ip2ipv6(struct sample *smp) |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 434 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 435 | v4tov6(&smp->data.ipv6, &smp->data.ipv4); |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 436 | smp->type = SMP_T_IPV6; |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 437 | return 1; |
| 438 | } |
| 439 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 440 | static int c_ipv62str(struct sample *smp) |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 441 | { |
Willy Tarreau | 47ca545 | 2012-12-23 20:22:19 +0100 | [diff] [blame] | 442 | struct chunk *trash = get_trash_chunk(); |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 443 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 444 | if (!inet_ntop(AF_INET6, (void *)&smp->data.ipv6, trash->str, trash->size)) |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 445 | return 0; |
| 446 | |
| 447 | trash->len = strlen(trash->str); |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 448 | smp->data.str = *trash; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 449 | smp->type = SMP_T_STR; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 450 | smp->flags &= ~SMP_F_CONST; |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 451 | return 1; |
| 452 | } |
| 453 | |
| 454 | /* |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 455 | static int c_ipv62ip(struct sample *smp) |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 456 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 457 | return v6tov4(&smp->data.ipv4, &smp->data.ipv6); |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 458 | } |
| 459 | */ |
| 460 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 461 | static int c_int2ip(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 462 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 463 | smp->data.ipv4.s_addr = htonl(smp->data.uint); |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 464 | smp->type = SMP_T_IPV4; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 465 | return 1; |
| 466 | } |
| 467 | |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 468 | static int c_str2addr(struct sample *smp) |
| 469 | { |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 470 | if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) { |
Thierry FOURNIER | fd13990 | 2013-12-11 12:38:57 +0100 | [diff] [blame] | 471 | if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6)) |
| 472 | return 0; |
| 473 | smp->type = SMP_T_IPV6; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 474 | smp->flags &= ~SMP_F_CONST; |
Thierry FOURNIER | fd13990 | 2013-12-11 12:38:57 +0100 | [diff] [blame] | 475 | return 1; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 476 | } |
| 477 | smp->type = SMP_T_IPV4; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 478 | smp->flags &= ~SMP_F_CONST; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 479 | return 1; |
| 480 | } |
| 481 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 482 | static int c_str2ip(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 483 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 484 | if (!buf2ip(smp->data.str.str, smp->data.str.len, &smp->data.ipv4)) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 485 | return 0; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 486 | smp->type = SMP_T_IPV4; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 487 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 488 | return 1; |
| 489 | } |
| 490 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 491 | static int c_str2ipv6(struct sample *smp) |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 492 | { |
Thierry FOURNIER | fd13990 | 2013-12-11 12:38:57 +0100 | [diff] [blame] | 493 | if (!buf2ip6(smp->data.str.str, smp->data.str.len, &smp->data.ipv6)) |
| 494 | return 0; |
| 495 | smp->type = SMP_T_IPV6; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 496 | smp->flags &= ~SMP_F_CONST; |
Thierry FOURNIER | fd13990 | 2013-12-11 12:38:57 +0100 | [diff] [blame] | 497 | return 1; |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 498 | } |
| 499 | |
Thierry FOURNIER | e87cac1 | 2014-03-12 15:07:59 +0100 | [diff] [blame] | 500 | /* The sample is always copied into a new one so that smp->size is always |
| 501 | * valid. The NULL char always enforces the end of string if it is met. |
| 502 | */ |
Emeric Brun | 8ac33d9 | 2012-10-17 13:36:06 +0200 | [diff] [blame] | 503 | static int c_bin2str(struct sample *smp) |
| 504 | { |
Willy Tarreau | 47ca545 | 2012-12-23 20:22:19 +0100 | [diff] [blame] | 505 | struct chunk *trash = get_trash_chunk(); |
Emeric Brun | 8ac33d9 | 2012-10-17 13:36:06 +0200 | [diff] [blame] | 506 | unsigned char c; |
| 507 | int ptr = 0; |
| 508 | |
Thierry FOURNIER | e87cac1 | 2014-03-12 15:07:59 +0100 | [diff] [blame] | 509 | while (ptr < smp->data.str.len) { |
| 510 | c = smp->data.str.str[ptr]; |
| 511 | if (!c) |
| 512 | break; |
| 513 | trash->str[ptr] = c; |
| 514 | ptr++; |
Emeric Brun | 8ac33d9 | 2012-10-17 13:36:06 +0200 | [diff] [blame] | 515 | } |
Thierry FOURNIER | e87cac1 | 2014-03-12 15:07:59 +0100 | [diff] [blame] | 516 | trash->len = ptr; |
| 517 | trash->str[ptr] = 0; |
Emeric Brun | 8ac33d9 | 2012-10-17 13:36:06 +0200 | [diff] [blame] | 518 | smp->data.str = *trash; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 519 | smp->type = SMP_T_STR; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 520 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 8ac33d9 | 2012-10-17 13:36:06 +0200 | [diff] [blame] | 521 | return 1; |
| 522 | } |
| 523 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 524 | static int c_int2str(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 525 | { |
Willy Tarreau | 47ca545 | 2012-12-23 20:22:19 +0100 | [diff] [blame] | 526 | struct chunk *trash = get_trash_chunk(); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 527 | char *pos; |
| 528 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 529 | pos = ultoa_r(smp->data.uint, trash->str, trash->size); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 530 | |
| 531 | if (!pos) |
| 532 | return 0; |
| 533 | |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 534 | trash->size = trash->size - (pos - trash->str); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 535 | trash->str = pos; |
| 536 | trash->len = strlen(pos); |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 537 | smp->data.str = *trash; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 538 | smp->type = SMP_T_STR; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 539 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 540 | return 1; |
| 541 | } |
| 542 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 543 | /* This function duplicates data and removes the flag "const". */ |
| 544 | int smp_dup(struct sample *smp) |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 545 | { |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 546 | struct chunk *trash; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 547 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 548 | /* If the const flag is not set, we don't need to duplicate the |
| 549 | * pattern as it can be modified in place. |
| 550 | */ |
| 551 | if (!(smp->flags & SMP_F_CONST)) |
| 552 | return 1; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 553 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 554 | switch (smp->type) { |
| 555 | case SMP_T_BOOL: |
| 556 | case SMP_T_UINT: |
| 557 | case SMP_T_SINT: |
| 558 | case SMP_T_ADDR: |
| 559 | case SMP_T_IPV4: |
| 560 | case SMP_T_IPV6: |
| 561 | /* These type are not const. */ |
| 562 | break; |
| 563 | case SMP_T_STR: |
| 564 | case SMP_T_BIN: |
| 565 | /* Duplicate data. */ |
| 566 | trash = get_trash_chunk(); |
| 567 | trash->len = smp->data.str.len < trash->size ? smp->data.str.len : trash->size; |
| 568 | memcpy(trash->str, smp->data.str.str, trash->len); |
| 569 | smp->data.str = *trash; |
| 570 | break; |
| 571 | default: |
| 572 | /* Other cases are unexpected. */ |
| 573 | return 0; |
| 574 | } |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 575 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 576 | /* remove const flag */ |
| 577 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 578 | return 1; |
| 579 | } |
| 580 | |
Thierry FOURNIER | 0e9af55 | 2013-12-14 14:55:04 +0100 | [diff] [blame] | 581 | int c_none(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 582 | { |
| 583 | return 1; |
| 584 | } |
| 585 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 586 | static int c_str2int(struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 587 | { |
| 588 | int i; |
| 589 | uint32_t ret = 0; |
| 590 | |
Thierry FOURNIER | 60bb020 | 2014-01-27 18:20:48 +0100 | [diff] [blame] | 591 | if (smp->data.str.len == 0) |
| 592 | return 0; |
| 593 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 594 | for (i = 0; i < smp->data.str.len; i++) { |
| 595 | uint32_t val = smp->data.str.str[i] - '0'; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 596 | |
Thierry FOURNIER | 60bb020 | 2014-01-27 18:20:48 +0100 | [diff] [blame] | 597 | if (val > 9) { |
| 598 | if (i == 0) |
| 599 | return 0; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 600 | break; |
Thierry FOURNIER | 60bb020 | 2014-01-27 18:20:48 +0100 | [diff] [blame] | 601 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 602 | |
| 603 | ret = ret * 10 + val; |
| 604 | } |
| 605 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 606 | smp->data.uint = ret; |
Thierry FOURNIER | b805f71 | 2013-11-26 20:47:54 +0100 | [diff] [blame] | 607 | smp->type = SMP_T_UINT; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 608 | smp->flags &= ~SMP_F_CONST; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 609 | return 1; |
| 610 | } |
| 611 | |
Thierry FOURNIER | d437314 | 2013-12-17 01:10:10 +0100 | [diff] [blame] | 612 | static int c_str2meth(struct sample *smp) |
| 613 | { |
| 614 | enum http_meth_t meth; |
| 615 | int len; |
| 616 | |
| 617 | meth = find_http_meth(smp->data.str.str, smp->data.str.len); |
| 618 | if (meth == HTTP_METH_OTHER) { |
| 619 | len = smp->data.str.len; |
| 620 | smp->data.meth.str.str = smp->data.str.str; |
| 621 | smp->data.meth.str.len = len; |
| 622 | } |
| 623 | else |
| 624 | smp->flags &= ~SMP_F_CONST; |
| 625 | smp->data.meth.meth = meth; |
| 626 | smp->type = SMP_T_METH; |
| 627 | return 1; |
| 628 | } |
| 629 | |
| 630 | static int c_meth2str(struct sample *smp) |
| 631 | { |
| 632 | int len; |
| 633 | enum http_meth_t meth; |
| 634 | |
| 635 | if (smp->data.meth.meth == HTTP_METH_OTHER) { |
| 636 | /* The method is unknown. Copy the original pointer. */ |
| 637 | len = smp->data.meth.str.len; |
| 638 | smp->data.str.str = smp->data.meth.str.str; |
| 639 | smp->data.str.len = len; |
| 640 | smp->type = SMP_T_STR; |
| 641 | } |
| 642 | else if (smp->data.meth.meth < HTTP_METH_OTHER) { |
| 643 | /* The method is known, copy the pointer containing the string. */ |
| 644 | meth = smp->data.meth.meth; |
| 645 | smp->data.str.str = http_known_methods[meth].name; |
| 646 | smp->data.str.len = http_known_methods[meth].len; |
| 647 | smp->flags |= SMP_F_CONST; |
| 648 | smp->type = SMP_T_STR; |
| 649 | } |
| 650 | else { |
| 651 | /* Unknown method */ |
| 652 | return 0; |
| 653 | } |
| 654 | return 1; |
| 655 | } |
| 656 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 657 | /*****************************************************************/ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 658 | /* Sample casts matrix: */ |
| 659 | /* sample_casts[from type][to type] */ |
| 660 | /* NULL pointer used for impossible sample casts */ |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 661 | /*****************************************************************/ |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 662 | |
Thierry FOURNIER | 8af6ff1 | 2013-11-21 10:53:12 +0100 | [diff] [blame] | 663 | sample_cast_fct sample_casts[SMP_TYPES][SMP_TYPES] = { |
Thierry FOURNIER | d437314 | 2013-12-17 01:10:10 +0100 | [diff] [blame] | 664 | /* to: BOOL UINT SINT ADDR IPV4 IPV6 STR BIN METH */ |
| 665 | /* from: BOOL */ { c_none, c_none, c_none, NULL, NULL, NULL, c_int2str, NULL, NULL, }, |
| 666 | /* UINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, }, |
| 667 | /* SINT */ { c_none, c_none, c_none, c_int2ip, c_int2ip, NULL, c_int2str, NULL, NULL, }, |
| 668 | /* ADDR */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, |
| 669 | /* IPV4 */ { NULL, c_ip2int, c_ip2int, c_none, c_none, c_ip2ipv6, c_ip2str, NULL, NULL, }, |
| 670 | /* IPV6 */ { NULL, NULL, NULL, c_none, NULL, c_none, c_ipv62str, NULL, NULL, }, |
| 671 | /* STR */ { c_str2int, c_str2int, c_str2int, c_str2addr, c_str2ip, c_str2ipv6, c_none, c_none, c_str2meth, }, |
| 672 | /* BIN */ { NULL, NULL, NULL, NULL, NULL, NULL, c_bin2str, c_none, c_str2meth, }, |
| 673 | /* METH */ { NULL, NULL, NULL, NULL, NULL, NULL, c_meth2str, c_meth2str, c_none, }, |
Willy Tarreau | f0b38bf | 2010-06-06 13:22:23 +0200 | [diff] [blame] | 674 | }; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 675 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 676 | /* |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 677 | * Parse a sample expression configuration: |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 678 | * fetch keyword followed by format conversion keywords. |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 679 | * Returns a pointer on allocated sample expression structure. |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 680 | * The caller must have set al->ctx. |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 681 | */ |
Thierry FOURNIER | eeaa951 | 2014-02-11 14:00:19 +0100 | [diff] [blame] | 682 | struct sample_expr *sample_parse_expr(char **str, int *idx, const char *file, int line, char **err_msg, struct arg_list *al) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 683 | { |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 684 | const char *begw; /* beginning of word */ |
| 685 | const char *endw; /* end of word */ |
| 686 | const char *endt; /* end of term */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 687 | struct sample_expr *expr; |
| 688 | struct sample_fetch *fetch; |
| 689 | struct sample_conv *conv; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 690 | unsigned long prev_type; |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 691 | char *fkw = NULL; |
| 692 | char *ckw = NULL; |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 693 | int err_arg; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 694 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 695 | begw = str[*idx]; |
| 696 | for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++); |
| 697 | |
| 698 | if (endw == begw) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 699 | memprintf(err_msg, "missing fetch method"); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 700 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 701 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 702 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 703 | /* keep a copy of the current fetch keyword for error reporting */ |
| 704 | fkw = my_strndup(begw, endw - begw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 705 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 706 | fetch = find_sample_fetch(begw, endw - begw); |
| 707 | if (!fetch) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 708 | memprintf(err_msg, "unknown fetch method '%s'", fkw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 709 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 710 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 711 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 712 | endt = endw; |
| 713 | if (*endt == '(') { |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 714 | /* look for the end of this term and skip the opening parenthesis */ |
| 715 | endt = ++endw; |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 716 | while (*endt && *endt != ')') |
| 717 | endt++; |
| 718 | if (*endt != ')') { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 719 | memprintf(err_msg, "missing closing ')' after arguments to fetch keyword '%s'", fkw); |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 720 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 721 | } |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 722 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 723 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 724 | /* At this point, we have : |
| 725 | * - begw : beginning of the keyword |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 726 | * - endw : end of the keyword, first character not part of keyword |
| 727 | * nor the opening parenthesis (so first character of args |
| 728 | * if present). |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 729 | * - endt : end of the term (=endw or last parenthesis if args are present) |
| 730 | */ |
| 731 | |
| 732 | if (fetch->out_type >= SMP_TYPES) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 733 | memprintf(err_msg, "returns type of fetch method '%s' is unknown", fkw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 734 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 735 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 736 | prev_type = fetch->out_type; |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 737 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 738 | expr = calloc(1, sizeof(struct sample_expr)); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 739 | if (!expr) |
| 740 | goto out_error; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 741 | |
| 742 | LIST_INIT(&(expr->conv_exprs)); |
| 743 | expr->fetch = fetch; |
Willy Tarreau | 2e845be | 2012-10-19 19:49:09 +0200 | [diff] [blame] | 744 | expr->arg_p = empty_arg_list; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 745 | |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 746 | /* Note that we call the argument parser even with an empty string, |
| 747 | * this allows it to automatically create entries for mandatory |
| 748 | * implicit arguments (eg: local proxy name). |
| 749 | */ |
| 750 | al->kw = expr->fetch->kw; |
| 751 | al->conv = NULL; |
| 752 | if (make_arg_list(endw, endt - endw, fetch->arg_mask, &expr->arg_p, err_msg, NULL, &err_arg, al) < 0) { |
| 753 | memprintf(err_msg, "fetch method '%s' : %s", fkw, *err_msg); |
| 754 | goto out_error; |
| 755 | } |
Willy Tarreau | 2e845be | 2012-10-19 19:49:09 +0200 | [diff] [blame] | 756 | |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 757 | if (!expr->arg_p) { |
| 758 | expr->arg_p = empty_arg_list; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 759 | } |
Willy Tarreau | 689a1df | 2013-12-13 00:40:11 +0100 | [diff] [blame] | 760 | else if (fetch->val_args && !fetch->val_args(expr->arg_p, err_msg)) { |
| 761 | memprintf(err_msg, "invalid args in fetch method '%s' : %s", fkw, *err_msg); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 762 | goto out_error; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 763 | } |
| 764 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 765 | /* Now process the converters if any. We have two supported syntaxes |
| 766 | * for the converters, which can be combined : |
| 767 | * - comma-delimited list of converters just after the keyword and args ; |
| 768 | * - one converter per keyword |
| 769 | * The combination allows to have each keyword being a comma-delimited |
| 770 | * series of converters. |
| 771 | * |
| 772 | * We want to process the former first, then the latter. For this we start |
| 773 | * from the beginning of the supposed place in the exiting conv chain, which |
| 774 | * starts at the last comma (endt). |
| 775 | */ |
| 776 | |
| 777 | while (1) { |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 778 | struct sample_conv_expr *conv_expr; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 779 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 780 | if (*endt == ')') /* skip last closing parenthesis */ |
| 781 | endt++; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 782 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 783 | if (*endt && *endt != ',') { |
| 784 | if (ckw) |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 785 | memprintf(err_msg, "missing comma after conv keyword '%s'", ckw); |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 786 | else |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 787 | memprintf(err_msg, "missing comma after fetch keyword '%s'", fkw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 788 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 789 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 790 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 791 | while (*endt == ',') /* then trailing commas */ |
| 792 | endt++; |
| 793 | |
| 794 | begw = endt; /* start of conv keyword */ |
| 795 | |
| 796 | if (!*begw) { |
| 797 | /* none ? skip to next string */ |
| 798 | (*idx)++; |
| 799 | begw = str[*idx]; |
| 800 | if (!begw || !*begw) |
| 801 | break; |
| 802 | } |
| 803 | |
| 804 | for (endw = begw; *endw && *endw != '(' && *endw != ','; endw++); |
| 805 | |
| 806 | free(ckw); |
| 807 | ckw = my_strndup(begw, endw - begw); |
| 808 | |
| 809 | conv = find_sample_conv(begw, endw - begw); |
| 810 | if (!conv) { |
| 811 | /* we found an isolated keyword that we don't know, it's not ours */ |
| 812 | if (begw == str[*idx]) |
| 813 | break; |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 814 | memprintf(err_msg, "unknown conv method '%s'", ckw); |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 815 | goto out_error; |
| 816 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 817 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 818 | endt = endw; |
| 819 | if (*endt == '(') { |
| 820 | /* look for the end of this term */ |
| 821 | while (*endt && *endt != ')') |
| 822 | endt++; |
| 823 | if (*endt != ')') { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 824 | memprintf(err_msg, "syntax error: missing ')' after conv keyword '%s'", ckw); |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 825 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 826 | } |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 827 | } |
| 828 | |
| 829 | if (conv->in_type >= SMP_TYPES || conv->out_type >= SMP_TYPES) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 830 | memprintf(err_msg, "returns type of conv method '%s' is unknown", ckw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 831 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 832 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 833 | |
| 834 | /* If impossible type conversion */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 835 | if (!sample_casts[prev_type][conv->in_type]) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 836 | memprintf(err_msg, "conv method '%s' cannot be applied", ckw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 837 | goto out_error; |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 838 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 839 | |
| 840 | prev_type = conv->out_type; |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 841 | conv_expr = calloc(1, sizeof(struct sample_conv_expr)); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 842 | if (!conv_expr) |
| 843 | goto out_error; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 844 | |
| 845 | LIST_ADDQ(&(expr->conv_exprs), &(conv_expr->list)); |
| 846 | conv_expr->conv = conv; |
| 847 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 848 | if (endt != endw) { |
Willy Tarreau | b27c0d3 | 2012-04-20 16:04:47 +0200 | [diff] [blame] | 849 | int err_arg; |
Willy Tarreau | 21d68a6 | 2012-04-20 15:52:36 +0200 | [diff] [blame] | 850 | |
Willy Tarreau | 9fcb984 | 2012-04-20 14:45:49 +0200 | [diff] [blame] | 851 | if (!conv->arg_mask) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 852 | memprintf(err_msg, "conv method '%s' does not support any args", ckw); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 853 | goto out_error; |
| 854 | } |
Willy Tarreau | 9e92d32 | 2010-01-26 17:58:06 +0100 | [diff] [blame] | 855 | |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 856 | al->kw = expr->fetch->kw; |
| 857 | al->conv = conv_expr->conv->kw; |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 858 | if (make_arg_list(endw + 1, endt - endw - 1, conv->arg_mask, &conv_expr->arg_p, err_msg, NULL, &err_arg, al) < 0) { |
| 859 | memprintf(err_msg, "invalid arg %d in conv method '%s' : %s", err_arg+1, ckw, *err_msg); |
Willy Tarreau | 21d68a6 | 2012-04-20 15:52:36 +0200 | [diff] [blame] | 860 | goto out_error; |
| 861 | } |
| 862 | |
Willy Tarreau | 2e845be | 2012-10-19 19:49:09 +0200 | [diff] [blame] | 863 | if (!conv_expr->arg_p) |
| 864 | conv_expr->arg_p = empty_arg_list; |
| 865 | |
Thierry FOURNIER | eeaa951 | 2014-02-11 14:00:19 +0100 | [diff] [blame] | 866 | if (conv->val_args && !conv->val_args(conv_expr->arg_p, conv, file, line, err_msg)) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 867 | memprintf(err_msg, "invalid args in conv method '%s' : %s", ckw, *err_msg); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 868 | goto out_error; |
| 869 | } |
| 870 | } |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 871 | else if (ARGM(conv->arg_mask)) { |
Willy Tarreau | 975c178 | 2013-12-12 23:16:54 +0100 | [diff] [blame] | 872 | memprintf(err_msg, "missing args for conv method '%s'", ckw); |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 873 | goto out_error; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 874 | } |
| 875 | } |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 876 | |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 877 | out: |
| 878 | free(fkw); |
| 879 | free(ckw); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 880 | return expr; |
| 881 | |
| 882 | out_error: |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 883 | /* TODO: prune_sample_expr(expr); */ |
Willy Tarreau | 833cc79 | 2013-07-24 15:34:19 +0200 | [diff] [blame] | 884 | expr = NULL; |
| 885 | goto out; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 886 | } |
| 887 | |
| 888 | /* |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 889 | * Process a fetch + format conversion of defined by the sample expression <expr> |
Willy Tarreau | 32a6f2e | 2012-04-25 10:13:36 +0200 | [diff] [blame] | 890 | * on request or response considering the <opt> parameter. |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 891 | * Returns a pointer on a typed sample structure containing the result or NULL if |
| 892 | * sample is not found or when format conversion failed. |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 893 | * If <p> is not null, function returns results in structure pointed by <p>. |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 894 | * If <p> is null, functions returns a pointer on a static sample structure. |
Willy Tarreau | b8c8f1f | 2012-04-23 22:38:26 +0200 | [diff] [blame] | 895 | * |
| 896 | * Note: the fetch functions are required to properly set the return type. The |
| 897 | * conversion functions must do so too. However the cast functions do not need |
| 898 | * to since they're made to cast mutiple types according to what is required. |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 899 | */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 900 | struct sample *sample_process(struct proxy *px, struct session *l4, void *l7, |
| 901 | unsigned int opt, |
| 902 | struct sample_expr *expr, struct sample *p) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 903 | { |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 904 | struct sample_conv_expr *conv_expr; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 905 | |
Willy Tarreau | 18387e2 | 2013-07-25 12:02:38 +0200 | [diff] [blame] | 906 | if (p == NULL) { |
Willy Tarreau | b4a88f0 | 2012-04-23 21:35:11 +0200 | [diff] [blame] | 907 | p = &temp_smp; |
Willy Tarreau | 18387e2 | 2013-07-25 12:02:38 +0200 | [diff] [blame] | 908 | p->flags = 0; |
| 909 | } |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 910 | |
Willy Tarreau | ef38c39 | 2013-07-22 16:29:32 +0200 | [diff] [blame] | 911 | if (!expr->fetch->process(px, l4, l7, opt, expr->arg_p, p, expr->fetch->kw)) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 912 | return NULL; |
| 913 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 914 | list_for_each_entry(conv_expr, &expr->conv_exprs, list) { |
Willy Tarreau | 12e5011 | 2012-04-25 17:21:49 +0200 | [diff] [blame] | 915 | /* we want to ensure that p->type can be casted into |
| 916 | * conv_expr->conv->in_type. We have 3 possibilities : |
| 917 | * - NULL => not castable. |
| 918 | * - c_none => nothing to do (let's optimize it) |
| 919 | * - other => apply cast and prepare to fail |
| 920 | */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 921 | if (!sample_casts[p->type][conv_expr->conv->in_type]) |
Willy Tarreau | 12e5011 | 2012-04-25 17:21:49 +0200 | [diff] [blame] | 922 | return NULL; |
| 923 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 924 | if (sample_casts[p->type][conv_expr->conv->in_type] != c_none && |
| 925 | !sample_casts[p->type][conv_expr->conv->in_type](p)) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 926 | return NULL; |
| 927 | |
Willy Tarreau | 12e5011 | 2012-04-25 17:21:49 +0200 | [diff] [blame] | 928 | /* OK cast succeeded */ |
| 929 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 930 | if (!conv_expr->conv->process(conv_expr->arg_p, p)) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 931 | return NULL; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 932 | } |
| 933 | return p; |
| 934 | } |
| 935 | |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 936 | /* |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 937 | * Resolve all remaining arguments in proxy <p>. Returns the number of |
| 938 | * errors or 0 if everything is fine. |
| 939 | */ |
| 940 | int smp_resolve_args(struct proxy *p) |
| 941 | { |
| 942 | struct arg_list *cur, *bak; |
| 943 | const char *ctx, *where; |
| 944 | const char *conv_ctx, *conv_pre, *conv_pos; |
| 945 | struct userlist *ul; |
| 946 | struct arg *arg; |
| 947 | int cfgerr = 0; |
| 948 | |
| 949 | list_for_each_entry_safe(cur, bak, &p->conf.args.list, list) { |
| 950 | struct proxy *px; |
| 951 | struct server *srv; |
| 952 | char *pname, *sname; |
| 953 | |
| 954 | arg = cur->arg; |
| 955 | |
| 956 | /* prepare output messages */ |
| 957 | conv_pre = conv_pos = conv_ctx = ""; |
| 958 | if (cur->conv) { |
| 959 | conv_ctx = cur->conv; |
| 960 | conv_pre = "conversion keyword '"; |
| 961 | conv_pos = "' for "; |
| 962 | } |
| 963 | |
| 964 | where = "in"; |
| 965 | ctx = "sample fetch keyword"; |
| 966 | switch (cur->ctx) { |
| 967 | case ARGC_STK:where = "in stick rule in"; break; |
| 968 | case ARGC_TRK: where = "in tracking rule in"; break; |
| 969 | case ARGC_LOG: where = "in log-format string in"; break; |
Thierry FOURNIER | 1c0054f | 2013-11-20 15:09:52 +0100 | [diff] [blame] | 970 | case ARGC_HRQ: where = "in http-request header format string in"; break; |
| 971 | case ARGC_HRS: where = "in http-response header format string in"; break; |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 972 | case ARGC_UIF: where = "in unique-id-format string in"; break; |
Thierry FOURNIER | d18cd0f | 2013-11-29 12:15:45 +0100 | [diff] [blame] | 973 | case ARGC_RDR: where = "in redirect format string in"; break; |
Willy Tarreau | 3a4ac42 | 2014-06-13 16:17:14 +0200 | [diff] [blame^] | 974 | case ARGC_CAP: where = "in capture rule in"; break; |
Willy Tarreau | a4312fa | 2013-04-02 16:34:32 +0200 | [diff] [blame] | 975 | case ARGC_ACL: ctx = "ACL keyword"; break; |
| 976 | } |
| 977 | |
| 978 | /* set a few default settings */ |
| 979 | px = p; |
| 980 | pname = p->id; |
| 981 | |
| 982 | switch (arg->type) { |
| 983 | case ARGT_SRV: |
| 984 | if (!arg->data.str.len) { |
| 985 | Alert("parsing [%s:%d] : missing server name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 986 | cur->file, cur->line, |
| 987 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 988 | cfgerr++; |
| 989 | continue; |
| 990 | } |
| 991 | |
| 992 | /* we support two formats : "bck/srv" and "srv" */ |
| 993 | sname = strrchr(arg->data.str.str, '/'); |
| 994 | |
| 995 | if (sname) { |
| 996 | *sname++ = '\0'; |
| 997 | pname = arg->data.str.str; |
| 998 | |
| 999 | px = findproxy(pname, PR_CAP_BE); |
| 1000 | if (!px) { |
| 1001 | Alert("parsing [%s:%d] : unable to find proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1002 | cur->file, cur->line, pname, |
| 1003 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1004 | cfgerr++; |
| 1005 | break; |
| 1006 | } |
| 1007 | } |
| 1008 | else |
| 1009 | sname = arg->data.str.str; |
| 1010 | |
| 1011 | srv = findserver(px, sname); |
| 1012 | if (!srv) { |
| 1013 | 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", |
| 1014 | cur->file, cur->line, sname, pname, |
| 1015 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1016 | cfgerr++; |
| 1017 | break; |
| 1018 | } |
| 1019 | |
| 1020 | free(arg->data.str.str); |
| 1021 | arg->data.str.str = NULL; |
| 1022 | arg->unresolved = 0; |
| 1023 | arg->data.srv = srv; |
| 1024 | break; |
| 1025 | |
| 1026 | case ARGT_FE: |
| 1027 | if (arg->data.str.len) { |
| 1028 | pname = arg->data.str.str; |
| 1029 | px = findproxy(pname, PR_CAP_FE); |
| 1030 | } |
| 1031 | |
| 1032 | if (!px) { |
| 1033 | Alert("parsing [%s:%d] : unable to find frontend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1034 | cur->file, cur->line, pname, |
| 1035 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1036 | cfgerr++; |
| 1037 | break; |
| 1038 | } |
| 1039 | |
| 1040 | if (!(px->cap & PR_CAP_FE)) { |
| 1041 | Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not frontend capability.\n", |
| 1042 | cur->file, cur->line, pname, |
| 1043 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1044 | cfgerr++; |
| 1045 | break; |
| 1046 | } |
| 1047 | |
| 1048 | free(arg->data.str.str); |
| 1049 | arg->data.str.str = NULL; |
| 1050 | arg->unresolved = 0; |
| 1051 | arg->data.prx = px; |
| 1052 | break; |
| 1053 | |
| 1054 | case ARGT_BE: |
| 1055 | if (arg->data.str.len) { |
| 1056 | pname = arg->data.str.str; |
| 1057 | px = findproxy(pname, PR_CAP_BE); |
| 1058 | } |
| 1059 | |
| 1060 | if (!px) { |
| 1061 | Alert("parsing [%s:%d] : unable to find backend '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1062 | cur->file, cur->line, pname, |
| 1063 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1064 | cfgerr++; |
| 1065 | break; |
| 1066 | } |
| 1067 | |
| 1068 | if (!(px->cap & PR_CAP_BE)) { |
| 1069 | Alert("parsing [%s:%d] : proxy '%s', referenced in arg %d of %s%s%s%s '%s' %s proxy '%s', has not backend capability.\n", |
| 1070 | cur->file, cur->line, pname, |
| 1071 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1072 | cfgerr++; |
| 1073 | break; |
| 1074 | } |
| 1075 | |
| 1076 | free(arg->data.str.str); |
| 1077 | arg->data.str.str = NULL; |
| 1078 | arg->unresolved = 0; |
| 1079 | arg->data.prx = px; |
| 1080 | break; |
| 1081 | |
| 1082 | case ARGT_TAB: |
| 1083 | if (arg->data.str.len) { |
| 1084 | pname = arg->data.str.str; |
| 1085 | px = find_stktable(pname); |
| 1086 | } |
| 1087 | |
| 1088 | if (!px) { |
| 1089 | Alert("parsing [%s:%d] : unable to find table '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1090 | cur->file, cur->line, pname, |
| 1091 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1092 | cfgerr++; |
| 1093 | break; |
| 1094 | } |
| 1095 | |
| 1096 | if (!px->table.size) { |
| 1097 | Alert("parsing [%s:%d] : no table in proxy '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1098 | cur->file, cur->line, pname, |
| 1099 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1100 | cfgerr++; |
| 1101 | break; |
| 1102 | } |
| 1103 | |
| 1104 | free(arg->data.str.str); |
| 1105 | arg->data.str.str = NULL; |
| 1106 | arg->unresolved = 0; |
| 1107 | arg->data.prx = px; |
| 1108 | break; |
| 1109 | |
| 1110 | case ARGT_USR: |
| 1111 | if (!arg->data.str.len) { |
| 1112 | Alert("parsing [%s:%d] : missing userlist name in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1113 | cur->file, cur->line, |
| 1114 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1115 | cfgerr++; |
| 1116 | break; |
| 1117 | } |
| 1118 | |
| 1119 | if (p->uri_auth && p->uri_auth->userlist && |
| 1120 | !strcmp(p->uri_auth->userlist->name, arg->data.str.str)) |
| 1121 | ul = p->uri_auth->userlist; |
| 1122 | else |
| 1123 | ul = auth_find_userlist(arg->data.str.str); |
| 1124 | |
| 1125 | if (!ul) { |
| 1126 | Alert("parsing [%s:%d] : unable to find userlist '%s' referenced in arg %d of %s%s%s%s '%s' %s proxy '%s'.\n", |
| 1127 | cur->file, cur->line, arg->data.str.str, |
| 1128 | cur->arg_pos + 1, conv_pre, conv_ctx, conv_pos, ctx, cur->kw, where, p->id); |
| 1129 | cfgerr++; |
| 1130 | break; |
| 1131 | } |
| 1132 | |
| 1133 | free(arg->data.str.str); |
| 1134 | arg->data.str.str = NULL; |
| 1135 | arg->unresolved = 0; |
| 1136 | arg->data.usr = ul; |
| 1137 | break; |
| 1138 | } |
| 1139 | |
| 1140 | LIST_DEL(&cur->list); |
| 1141 | free(cur); |
| 1142 | } /* end of args processing */ |
| 1143 | |
| 1144 | return cfgerr; |
| 1145 | } |
| 1146 | |
| 1147 | /* |
Willy Tarreau | 5b4bf70 | 2014-06-13 16:04:35 +0200 | [diff] [blame] | 1148 | * Process a fetch + format conversion as defined by the sample expression |
| 1149 | * <expr> on request or response considering the <opt> parameter. The output is |
| 1150 | * always of type string. If a stable sample can be fetched, or an unstable one |
| 1151 | * when <opt> contains SMP_OPT_FINAL, the sample is converted to a string and |
| 1152 | * returned without the SMP_F_MAY_CHANGE flag. If an unstable sample is found |
| 1153 | * and <opt> does not contain SMP_OPT_FINAL, then the sample is returned as-is |
| 1154 | * with its SMP_F_MAY_CHANGE flag so that the caller can check it and decide to |
| 1155 | * take actions (eg: wait longer). If a sample could not be found or could not |
| 1156 | * be converted, NULL is returned. |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1157 | */ |
| 1158 | struct sample *sample_fetch_string(struct proxy *px, struct session *l4, void *l7, |
| 1159 | unsigned int opt, struct sample_expr *expr) |
| 1160 | { |
Willy Tarreau | 5b4bf70 | 2014-06-13 16:04:35 +0200 | [diff] [blame] | 1161 | struct sample *smp = &temp_smp; |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1162 | |
Willy Tarreau | 5b4bf70 | 2014-06-13 16:04:35 +0200 | [diff] [blame] | 1163 | smp->flags = 0; |
| 1164 | if (!sample_process(px, l4, l7, opt, expr, smp)) { |
| 1165 | if ((smp->flags & SMP_F_MAY_CHANGE) && !(opt & SMP_OPT_FINAL)) |
| 1166 | return smp; |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1167 | return NULL; |
Willy Tarreau | 5b4bf70 | 2014-06-13 16:04:35 +0200 | [diff] [blame] | 1168 | } |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1169 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1170 | if (!sample_casts[smp->type][SMP_T_STR]) |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1171 | return NULL; |
| 1172 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1173 | if (!sample_casts[smp->type][SMP_T_STR](smp)) |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1174 | return NULL; |
| 1175 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1176 | smp->type = SMP_T_STR; |
Willy Tarreau | 5b4bf70 | 2014-06-13 16:04:35 +0200 | [diff] [blame] | 1177 | smp->flags &= ~SMP_F_MAY_CHANGE; |
Willy Tarreau | e7ad4bb | 2012-12-21 00:02:32 +0100 | [diff] [blame] | 1178 | return smp; |
| 1179 | } |
| 1180 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1181 | /*****************************************************************/ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1182 | /* Sample format convert functions */ |
Willy Tarreau | b8c8f1f | 2012-04-23 22:38:26 +0200 | [diff] [blame] | 1183 | /* These functions set the data type on return. */ |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1184 | /*****************************************************************/ |
| 1185 | |
Emeric Brun | 53d1a98 | 2014-04-30 18:21:37 +0200 | [diff] [blame] | 1186 | static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp) |
| 1187 | { |
| 1188 | struct chunk *trash = get_trash_chunk(); |
| 1189 | int b64_len; |
| 1190 | |
| 1191 | trash->len = 0; |
| 1192 | b64_len = a2base64(smp->data.str.str, smp->data.str.len, trash->str, trash->size); |
| 1193 | if (b64_len < 0) |
| 1194 | return 0; |
| 1195 | |
| 1196 | trash->len = b64_len; |
| 1197 | smp->data.str = *trash; |
| 1198 | smp->type = SMP_T_STR; |
| 1199 | smp->flags &= ~SMP_F_CONST; |
| 1200 | return 1; |
| 1201 | } |
| 1202 | |
Thierry FOURNIER | 2f49d6d | 2014-03-12 15:01:52 +0100 | [diff] [blame] | 1203 | static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp) |
| 1204 | { |
| 1205 | struct chunk *trash = get_trash_chunk(); |
| 1206 | unsigned char c; |
| 1207 | int ptr = 0; |
| 1208 | |
| 1209 | trash->len = 0; |
| 1210 | while (ptr < smp->data.str.len && trash->len <= trash->size - 2) { |
| 1211 | c = smp->data.str.str[ptr++]; |
| 1212 | trash->str[trash->len++] = hextab[(c >> 4) & 0xF]; |
| 1213 | trash->str[trash->len++] = hextab[c & 0xF]; |
| 1214 | } |
| 1215 | smp->data.str = *trash; |
| 1216 | smp->type = SMP_T_STR; |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1217 | smp->flags &= ~SMP_F_CONST; |
Thierry FOURNIER | 2f49d6d | 2014-03-12 15:01:52 +0100 | [diff] [blame] | 1218 | return 1; |
| 1219 | } |
| 1220 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1221 | static int sample_conv_str2lower(const struct arg *arg_p, struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1222 | { |
| 1223 | int i; |
| 1224 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1225 | if (!smp_dup(smp)) |
| 1226 | return 0; |
| 1227 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 1228 | if (!smp->data.str.size) |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 1229 | return 0; |
| 1230 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 1231 | for (i = 0; i < smp->data.str.len; i++) { |
| 1232 | if ((smp->data.str.str[i] >= 'A') && (smp->data.str.str[i] <= 'Z')) |
| 1233 | smp->data.str.str[i] += 'a' - 'A'; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1234 | } |
| 1235 | return 1; |
| 1236 | } |
| 1237 | |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1238 | static int sample_conv_str2upper(const struct arg *arg_p, struct sample *smp) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1239 | { |
| 1240 | int i; |
| 1241 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1242 | if (!smp_dup(smp)) |
| 1243 | return 0; |
| 1244 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 1245 | if (!smp->data.str.size) |
Emeric Brun | 485479d | 2010-09-23 18:02:19 +0200 | [diff] [blame] | 1246 | return 0; |
| 1247 | |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 1248 | for (i = 0; i < smp->data.str.len; i++) { |
| 1249 | if ((smp->data.str.str[i] >= 'a') && (smp->data.str.str[i] <= 'z')) |
| 1250 | smp->data.str.str[i] += 'A' - 'a'; |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1251 | } |
| 1252 | return 1; |
| 1253 | } |
| 1254 | |
Willy Tarreau | f995410 | 2012-04-20 14:03:29 +0200 | [diff] [blame] | 1255 | /* takes the netmask in arg_p */ |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1256 | static int sample_conv_ipmask(const struct arg *arg_p, struct sample *smp) |
Willy Tarreau | d31d6eb | 2010-01-26 18:01:41 +0100 | [diff] [blame] | 1257 | { |
Willy Tarreau | 342acb4 | 2012-04-23 22:03:39 +0200 | [diff] [blame] | 1258 | smp->data.ipv4.s_addr &= arg_p->data.ipv4.s_addr; |
Willy Tarreau | b8c8f1f | 2012-04-23 22:38:26 +0200 | [diff] [blame] | 1259 | smp->type = SMP_T_IPV4; |
Willy Tarreau | d31d6eb | 2010-01-26 18:01:41 +0100 | [diff] [blame] | 1260 | return 1; |
| 1261 | } |
| 1262 | |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1263 | /************************************************************************/ |
| 1264 | /* All supported sample fetch functions must be declared here */ |
| 1265 | /************************************************************************/ |
| 1266 | |
| 1267 | /* force TRUE to be returned at the fetch level */ |
| 1268 | static int |
| 1269 | smp_fetch_true(struct proxy *px, struct session *s, void *l7, unsigned int opt, |
Willy Tarreau | ef38c39 | 2013-07-22 16:29:32 +0200 | [diff] [blame] | 1270 | const struct arg *args, struct sample *smp, const char *kw) |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1271 | { |
| 1272 | smp->type = SMP_T_BOOL; |
| 1273 | smp->data.uint = 1; |
| 1274 | return 1; |
| 1275 | } |
| 1276 | |
| 1277 | /* force FALSE to be returned at the fetch level */ |
| 1278 | static int |
| 1279 | smp_fetch_false(struct proxy *px, struct session *s, void *l7, unsigned int opt, |
Willy Tarreau | ef38c39 | 2013-07-22 16:29:32 +0200 | [diff] [blame] | 1280 | const struct arg *args, struct sample *smp, const char *kw) |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1281 | { |
| 1282 | smp->type = SMP_T_BOOL; |
| 1283 | smp->data.uint = 0; |
| 1284 | return 1; |
| 1285 | } |
| 1286 | |
| 1287 | /* retrieve environment variable $1 as a string */ |
| 1288 | static int |
| 1289 | smp_fetch_env(struct proxy *px, struct session *s, void *l7, unsigned int opt, |
Willy Tarreau | ef38c39 | 2013-07-22 16:29:32 +0200 | [diff] [blame] | 1290 | const struct arg *args, struct sample *smp, const char *kw) |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1291 | { |
| 1292 | char *env; |
| 1293 | |
| 1294 | if (!args || args[0].type != ARGT_STR) |
| 1295 | return 0; |
| 1296 | |
| 1297 | env = getenv(args[0].data.str.str); |
| 1298 | if (!env) |
| 1299 | return 0; |
| 1300 | |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1301 | smp->type = SMP_T_STR; |
| 1302 | smp->flags = SMP_F_CONST; |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1303 | smp->data.str.str = env; |
| 1304 | smp->data.str.len = strlen(env); |
| 1305 | return 1; |
| 1306 | } |
| 1307 | |
Willy Tarreau | 6236d3a | 2013-07-25 14:28:25 +0200 | [diff] [blame] | 1308 | /* retrieve the current local date in epoch time, and applies an optional offset |
| 1309 | * of args[0] seconds. |
| 1310 | */ |
| 1311 | static int |
| 1312 | smp_fetch_date(struct proxy *px, struct session *s, void *l7, unsigned int opt, |
Willy Tarreau | ef38c39 | 2013-07-22 16:29:32 +0200 | [diff] [blame] | 1313 | const struct arg *args, struct sample *smp, const char *kw) |
Willy Tarreau | 6236d3a | 2013-07-25 14:28:25 +0200 | [diff] [blame] | 1314 | { |
| 1315 | smp->data.uint = date.tv_sec; |
| 1316 | |
| 1317 | /* add offset */ |
| 1318 | if (args && (args[0].type == ARGT_SINT || args[0].type == ARGT_UINT)) |
| 1319 | smp->data.uint += args[0].data.sint; |
| 1320 | |
| 1321 | smp->type = SMP_T_UINT; |
| 1322 | smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE; |
| 1323 | return 1; |
| 1324 | } |
| 1325 | |
Willy Tarreau | 84310e2 | 2014-02-14 11:59:04 +0100 | [diff] [blame] | 1326 | /* generate a random 32-bit integer for whatever purpose, with an optional |
| 1327 | * range specified in argument. |
| 1328 | */ |
| 1329 | static int |
| 1330 | smp_fetch_rand(struct proxy *px, struct session *s, void *l7, unsigned int opt, |
| 1331 | const struct arg *args, struct sample *smp, const char *kw) |
| 1332 | { |
| 1333 | smp->data.uint = random(); |
| 1334 | |
| 1335 | /* reduce if needed. Don't do a modulo, use all bits! */ |
| 1336 | if (args && args[0].type == ARGT_UINT) |
| 1337 | smp->data.uint = ((uint64_t)smp->data.uint * args[0].data.uint) >> 32; |
| 1338 | |
| 1339 | smp->type = SMP_T_UINT; |
| 1340 | smp->flags |= SMP_F_VOL_TEST | SMP_F_MAY_CHANGE; |
| 1341 | return 1; |
| 1342 | } |
| 1343 | |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1344 | /* Note: must not be declared <const> as its list will be overwritten. |
| 1345 | * Note: fetches that may return multiple types must be declared as the lowest |
| 1346 | * common denominator, the type that can be casted into all other ones. For |
| 1347 | * instance IPv4/IPv6 must be declared IPv4. |
| 1348 | */ |
| 1349 | static struct sample_fetch_kw_list smp_kws = {ILH, { |
| 1350 | { "always_false", smp_fetch_false, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN }, |
| 1351 | { "always_true", smp_fetch_true, 0, NULL, SMP_T_BOOL, SMP_USE_INTRN }, |
Thierry FOURNIER | 7654c9f | 2013-12-17 00:20:33 +0100 | [diff] [blame] | 1352 | { "env", smp_fetch_env, ARG1(1,STR), NULL, SMP_T_STR, SMP_USE_INTRN }, |
Willy Tarreau | 6236d3a | 2013-07-25 14:28:25 +0200 | [diff] [blame] | 1353 | { "date", smp_fetch_date, ARG1(0,SINT), NULL, SMP_T_UINT, SMP_USE_INTRN }, |
Willy Tarreau | 84310e2 | 2014-02-14 11:59:04 +0100 | [diff] [blame] | 1354 | { "rand", smp_fetch_rand, ARG1(0,UINT), NULL, SMP_T_UINT, SMP_USE_INTRN }, |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1355 | { /* END */ }, |
| 1356 | }}; |
| 1357 | |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1358 | /* Note: must not be declared <const> as its list will be overwritten */ |
Willy Tarreau | dc13c11 | 2013-06-21 23:16:39 +0200 | [diff] [blame] | 1359 | static struct sample_conv_kw_list sample_conv_kws = {ILH, { |
Emeric Brun | 53d1a98 | 2014-04-30 18:21:37 +0200 | [diff] [blame] | 1360 | { "base64", sample_conv_bin2base64,0, NULL, SMP_T_BIN, SMP_T_STR }, |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1361 | { "upper", sample_conv_str2upper, 0, NULL, SMP_T_STR, SMP_T_STR }, |
| 1362 | { "lower", sample_conv_str2lower, 0, NULL, SMP_T_STR, SMP_T_STR }, |
Thierry FOURNIER | 2f49d6d | 2014-03-12 15:01:52 +0100 | [diff] [blame] | 1363 | { "hex", sample_conv_bin2hex, 0, NULL, SMP_T_BIN, SMP_T_STR }, |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1364 | { "ipmask", sample_conv_ipmask, ARG1(1,MSK4), NULL, SMP_T_IPV4, SMP_T_IPV4 }, |
Willy Tarreau | 9fcb984 | 2012-04-20 14:45:49 +0200 | [diff] [blame] | 1365 | { NULL, NULL, 0, 0, 0 }, |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1366 | }}; |
| 1367 | |
| 1368 | __attribute__((constructor)) |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1369 | static void __sample_init(void) |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1370 | { |
Willy Tarreau | 5b8ad22 | 2013-07-25 12:17:57 +0200 | [diff] [blame] | 1371 | /* register sample fetch and format conversion keywords */ |
| 1372 | sample_register_fetches(&smp_kws); |
Willy Tarreau | 1278578 | 2012-04-27 21:37:17 +0200 | [diff] [blame] | 1373 | sample_register_convs(&sample_conv_kws); |
Emeric Brun | 107ca30 | 2010-01-04 16:16:05 +0100 | [diff] [blame] | 1374 | } |