Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | cc05fba | 2009-10-27 21:40:18 +0100 | [diff] [blame] | 2 | * include/common/standard.h |
| 3 | * This files contains some general purpose functions and macros. |
| 4 | * |
Willy Tarreau | 348238b | 2010-01-18 15:05:57 +0100 | [diff] [blame] | 5 | * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu |
Willy Tarreau | cc05fba | 2009-10-27 21:40:18 +0100 | [diff] [blame] | 6 | * |
| 7 | * This library is free software; you can redistribute it and/or |
| 8 | * modify it under the terms of the GNU Lesser General Public |
| 9 | * License as published by the Free Software Foundation, version 2.1 |
| 10 | * exclusively. |
| 11 | * |
| 12 | * This library is distributed in the hope that it will be useful, |
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * Lesser General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU Lesser General Public |
| 18 | * License along with this library; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 21 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 22 | #ifndef _COMMON_STANDARD_H |
| 23 | #define _COMMON_STANDARD_H |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 24 | |
Willy Tarreau | 13faf16 | 2020-03-04 07:44:06 +0100 | [diff] [blame] | 25 | #ifdef USE_BACKTRACE |
| 26 | #define _GNU_SOURCE |
| 27 | #include <execinfo.h> |
| 28 | #endif |
| 29 | |
Willy Tarreau | 050737f | 2010-01-14 11:40:12 +0100 | [diff] [blame] | 30 | #include <string.h> |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 31 | #include <stdio.h> |
Willy Tarreau | fe94460 | 2007-10-25 10:34:16 +0200 | [diff] [blame] | 32 | #include <time.h> |
David Carlier | 5222d8e | 2017-11-03 12:00:26 +0000 | [diff] [blame] | 33 | #include <stdarg.h> |
Willy Tarreau | e6e49cf | 2015-04-29 17:13:35 +0200 | [diff] [blame] | 34 | #include <sys/time.h> |
Willy Tarreau | 938b303 | 2007-05-10 06:39:03 +0200 | [diff] [blame] | 35 | #include <sys/types.h> |
Willy Tarreau | d50265a | 2012-09-04 14:18:33 +0200 | [diff] [blame] | 36 | #include <sys/socket.h> |
Willy Tarreau | dd2f85e | 2012-09-02 22:34:23 +0200 | [diff] [blame] | 37 | #include <sys/un.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 38 | #include <netinet/in.h> |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 39 | #include <arpa/inet.h> |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 40 | #include <haproxy/api.h> |
Willy Tarreau | aea4635 | 2020-06-01 11:48:35 +0200 | [diff] [blame] | 41 | #include <haproxy/intops.h> |
Willy Tarreau | c13ed53 | 2020-06-02 10:22:45 +0200 | [diff] [blame^] | 42 | #include <haproxy/chunk.h> |
Willy Tarreau | 16e0156 | 2016-08-09 16:46:18 +0200 | [diff] [blame] | 43 | #include <common/namespace.h> |
Willy Tarreau | 8d2b777 | 2020-05-27 10:58:19 +0200 | [diff] [blame] | 44 | #include <import/eb32tree.h> |
| 45 | #include <import/eb32sctree.h> |
William Lallemand | 2fe7dd0 | 2018-09-11 16:51:29 +0200 | [diff] [blame] | 46 | #include <types/protocol.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 47 | |
Thierry FOURNIER | 511e947 | 2014-01-23 17:40:34 +0100 | [diff] [blame] | 48 | /* size used for max length of decimal representation of long long int. */ |
| 49 | #define NB_LLMAX_STR (sizeof("-9223372036854775807")-1) |
| 50 | |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 51 | /* number of itoa_str entries */ |
Willy Tarreau | 59caa3b | 2018-12-14 13:59:42 +0100 | [diff] [blame] | 52 | #define NB_ITOA_STR 16 |
William Lallemand | e7340ec | 2012-01-24 11:15:39 +0100 | [diff] [blame] | 53 | |
Willy Tarreau | 588297f | 2014-06-16 15:16:40 +0200 | [diff] [blame] | 54 | /* maximum quoted string length (truncated above) */ |
| 55 | #define QSTR_SIZE 200 |
| 56 | #define NB_QSTR 10 |
| 57 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 58 | /****** string-specific macros and functions ******/ |
| 59 | /* if a > max, then bound <a> to <max>. The macro returns the new <a> */ |
| 60 | #define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); }) |
| 61 | |
| 62 | /* if a < min, then bound <a> to <min>. The macro returns the new <a> */ |
| 63 | #define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); }) |
| 64 | |
| 65 | /* returns 1 only if only zero or one bit is set in X, which means that X is a |
| 66 | * power of 2, and 0 otherwise */ |
| 67 | #define POWEROF2(x) (((x) & ((x)-1)) == 0) |
| 68 | |
Willy Tarreau | 4d653a6 | 2020-06-03 17:49:00 +0200 | [diff] [blame] | 69 | #define SWAP(a, b) do { typeof(a) t; t = a; a = b; b = t; } while(0) |
| 70 | |
| 71 | /* return an integer of type <ret> with only the highest bit set. <ret> may be |
| 72 | * both a variable or a type. |
| 73 | */ |
| 74 | #define MID_RANGE(ret) ((typeof(ret))1 << (8*sizeof(ret) - 1)) |
| 75 | |
| 76 | /* return the largest possible integer of type <ret>, with all bits set */ |
| 77 | #define MAX_RANGE(ret) (~(typeof(ret))0) |
| 78 | |
Willy Tarreau | 32c2455 | 2019-08-19 17:39:33 +0200 | [diff] [blame] | 79 | /* DEFNULL() returns either the argument as-is, or NULL if absent. This is for |
| 80 | * use in macros arguments. |
| 81 | */ |
| 82 | #define DEFNULL(...) _FIRST_ARG(NULL, ##__VA_ARGS__, NULL) |
| 83 | #define _FIRST_ARG(a, b, ...) b |
| 84 | |
Willy Tarreau | 5b18020 | 2010-07-18 10:40:48 +0200 | [diff] [blame] | 85 | /* operators to compare values. They're ordered that way so that the lowest bit |
| 86 | * serves as a negation for the test and contains all tests that are not equal. |
| 87 | */ |
| 88 | enum { |
| 89 | STD_OP_LE = 0, STD_OP_GT = 1, |
| 90 | STD_OP_EQ = 2, STD_OP_NE = 3, |
| 91 | STD_OP_GE = 4, STD_OP_LT = 5, |
| 92 | }; |
| 93 | |
Thierry FOURNIER | 9f95e40 | 2014-03-21 14:51:46 +0100 | [diff] [blame] | 94 | enum http_scheme { |
| 95 | SCH_HTTP, |
| 96 | SCH_HTTPS, |
| 97 | }; |
| 98 | |
| 99 | struct split_url { |
| 100 | enum http_scheme scheme; |
| 101 | const char *host; |
| 102 | int host_len; |
| 103 | }; |
| 104 | |
Willy Tarreau | fb4ba91 | 2019-08-29 09:32:21 +0200 | [diff] [blame] | 105 | /* generic structure associating a name and a value, for use in arrays */ |
| 106 | struct name_desc { |
| 107 | const char *name; |
| 108 | const char *desc; |
| 109 | }; |
| 110 | |
Christopher Faulet | 99bca65 | 2017-11-14 16:47:26 +0100 | [diff] [blame] | 111 | extern THREAD_LOCAL int itoa_idx; /* index of next itoa_str to use */ |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 112 | |
Willy Tarreau | 7d58a63 | 2007-01-13 23:06:06 +0100 | [diff] [blame] | 113 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 114 | * copies at most <size-1> chars from <src> to <dst>. Last char is always |
| 115 | * set to 0, unless <size> is 0. The number of chars copied is returned |
| 116 | * (excluding the terminating zero). |
| 117 | * This code has been optimized for size and speed : on x86, it's 45 bytes |
| 118 | * long, uses only registers, and consumes only 4 cycles per char. |
| 119 | */ |
| 120 | extern int strlcpy2(char *dst, const char *src, int size); |
| 121 | |
| 122 | /* |
Willy Tarreau | 72d759c | 2007-10-25 12:14:10 +0200 | [diff] [blame] | 123 | * This function simply returns a locally allocated string containing |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 124 | * the ascii representation for number 'n' in decimal. |
| 125 | */ |
Christopher Faulet | 99bca65 | 2017-11-14 16:47:26 +0100 | [diff] [blame] | 126 | extern THREAD_LOCAL char itoa_str[][171]; |
Emeric Brun | 3a7fce5 | 2010-01-04 14:54:38 +0100 | [diff] [blame] | 127 | extern char *ultoa_r(unsigned long n, char *buffer, int size); |
Thierry FOURNIER | 763a5d8 | 2015-07-06 23:09:52 +0200 | [diff] [blame] | 128 | extern char *lltoa_r(long long int n, char *buffer, int size); |
Thierry FOURNIER | 1480bd8 | 2015-06-06 19:14:59 +0200 | [diff] [blame] | 129 | extern char *sltoa_r(long n, char *buffer, int size); |
Willy Tarreau | e7239b5 | 2009-03-29 13:41:58 +0200 | [diff] [blame] | 130 | extern const char *ulltoh_r(unsigned long long n, char *buffer, int size); |
Willy Tarreau | 72d759c | 2007-10-25 12:14:10 +0200 | [diff] [blame] | 131 | static inline const char *ultoa(unsigned long n) |
| 132 | { |
| 133 | return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0])); |
| 134 | } |
| 135 | |
William Lallemand | e7340ec | 2012-01-24 11:15:39 +0100 | [diff] [blame] | 136 | /* |
| 137 | * unsigned long long ASCII representation |
| 138 | * |
| 139 | * return the last char '\0' or NULL if no enough |
| 140 | * space in dst |
| 141 | */ |
| 142 | char *ulltoa(unsigned long long n, char *dst, size_t size); |
| 143 | |
| 144 | |
| 145 | /* |
| 146 | * unsigned long ASCII representation |
| 147 | * |
| 148 | * return the last char '\0' or NULL if no enough |
| 149 | * space in dst |
| 150 | */ |
| 151 | char *ultoa_o(unsigned long n, char *dst, size_t size); |
| 152 | |
| 153 | /* |
| 154 | * signed long ASCII representation |
| 155 | * |
| 156 | * return the last char '\0' or NULL if no enough |
| 157 | * space in dst |
| 158 | */ |
| 159 | char *ltoa_o(long int n, char *dst, size_t size); |
| 160 | |
| 161 | /* |
| 162 | * signed long long ASCII representation |
| 163 | * |
| 164 | * return the last char '\0' or NULL if no enough |
| 165 | * space in dst |
| 166 | */ |
| 167 | char *lltoa(long long n, char *dst, size_t size); |
| 168 | |
| 169 | /* |
| 170 | * write a ascii representation of a unsigned into dst, |
| 171 | * return a pointer to the last character |
| 172 | * Pad the ascii representation with '0', using size. |
| 173 | */ |
| 174 | char *utoa_pad(unsigned int n, char *dst, size_t size); |
| 175 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 176 | /* |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 177 | * This function simply returns a locally allocated string containing the ascii |
| 178 | * representation for number 'n' in decimal, unless n is 0 in which case it |
| 179 | * returns the alternate string (or an empty string if the alternate string is |
| 180 | * NULL). It use is intended for limits reported in reports, where it's |
| 181 | * desirable not to display anything if there is no limit. Warning! it shares |
| 182 | * the same vector as ultoa_r(). |
| 183 | */ |
| 184 | extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt); |
| 185 | |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 186 | /* returns a locally allocated string containing the ASCII representation of |
| 187 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 188 | * function call (eg: printf), shared with the other similar functions making |
| 189 | * use of itoa_str[]. |
| 190 | */ |
| 191 | static inline const char *U2A(unsigned long n) |
| 192 | { |
| 193 | const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0])); |
| 194 | if (++itoa_idx >= NB_ITOA_STR) |
| 195 | itoa_idx = 0; |
| 196 | return ret; |
| 197 | } |
| 198 | |
| 199 | /* returns a locally allocated string containing the HTML representation of |
| 200 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 201 | * function call (eg: printf), shared with the other similar functions making |
| 202 | * use of itoa_str[]. |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 203 | */ |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 204 | static inline const char *U2H(unsigned long long n) |
| 205 | { |
| 206 | const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0])); |
| 207 | if (++itoa_idx >= NB_ITOA_STR) |
| 208 | itoa_idx = 0; |
| 209 | return ret; |
| 210 | } |
| 211 | |
Ioannis Cherouvim | 1ff7633 | 2018-10-24 10:05:19 +0300 | [diff] [blame] | 212 | /* returns a locally allocated string containing the ASCII representation of |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 213 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 214 | * function call (eg: printf), shared with the other similar functions making |
| 215 | * use of itoa_str[]. |
| 216 | */ |
| 217 | static inline const char *LIM2A(unsigned long n, const char *alt) |
| 218 | { |
| 219 | const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt); |
| 220 | if (++itoa_idx >= NB_ITOA_STR) |
| 221 | itoa_idx = 0; |
| 222 | return ret; |
| 223 | } |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 224 | |
Willy Tarreau | 588297f | 2014-06-16 15:16:40 +0200 | [diff] [blame] | 225 | /* returns a locally allocated string containing the quoted encoding of the |
| 226 | * input string. The output may be truncated to QSTR_SIZE chars, but it is |
| 227 | * guaranteed that the string will always be properly terminated. Quotes are |
| 228 | * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must |
| 229 | * always be at least 4 chars. |
| 230 | */ |
| 231 | const char *qstr(const char *str); |
| 232 | |
| 233 | /* returns <str> or its quote-encoded equivalent if it contains at least one |
| 234 | * quote or a comma. This is aimed at build CSV-compatible strings. |
| 235 | */ |
| 236 | static inline const char *cstr(const char *str) |
| 237 | { |
| 238 | const char *p = str; |
| 239 | |
| 240 | while (*p) { |
| 241 | if (*p == ',' || *p == '"') |
| 242 | return qstr(str); |
| 243 | p++; |
| 244 | } |
| 245 | return str; |
| 246 | } |
| 247 | |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 248 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 249 | * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero. |
| 250 | */ |
| 251 | extern int ishex(char s); |
| 252 | |
| 253 | /* |
Willy Tarreau | 2e74c3f | 2007-12-02 18:45:09 +0100 | [diff] [blame] | 254 | * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an |
| 255 | * invalid character is found, a pointer to it is returned. If everything is |
| 256 | * fine, NULL is returned. |
| 257 | */ |
| 258 | extern const char *invalid_char(const char *name); |
| 259 | |
| 260 | /* |
Frédéric Lécaille | b82f742 | 2017-04-13 18:24:23 +0200 | [diff] [blame] | 261 | * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-]. |
Krzysztof Piotr Oledzki | efe3b6f | 2008-05-23 23:49:32 +0200 | [diff] [blame] | 262 | * If an invalid character is found, a pointer to it is returned. |
| 263 | * If everything is fine, NULL is returned. |
| 264 | */ |
| 265 | extern const char *invalid_domainchar(const char *name); |
| 266 | |
| 267 | /* |
Frédéric Lécaille | b82f742 | 2017-04-13 18:24:23 +0200 | [diff] [blame] | 268 | * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-]. |
| 269 | * If an invalid character is found, a pointer to it is returned. |
| 270 | * If everything is fine, NULL is returned. |
| 271 | */ |
| 272 | extern const char *invalid_prefix_char(const char *name); |
| 273 | |
Willy Tarreau | 36f586b | 2020-02-14 18:25:17 +0100 | [diff] [blame] | 274 | /* returns true if <c> is an identifier character, that is, a digit, a letter, |
Willy Tarreau | a71667c | 2020-02-17 06:34:11 +0100 | [diff] [blame] | 275 | * or '-', '+', '_', ':' or '.'. This is usable for proxy names, server names, |
| 276 | * ACL names, sample fetch names, and converter names. |
Willy Tarreau | 36f586b | 2020-02-14 18:25:17 +0100 | [diff] [blame] | 277 | */ |
| 278 | static inline int is_idchar(char c) |
| 279 | { |
Willy Tarreau | 9080711 | 2020-02-25 08:16:33 +0100 | [diff] [blame] | 280 | return isalnum((unsigned char)c) || |
Willy Tarreau | a71667c | 2020-02-17 06:34:11 +0100 | [diff] [blame] | 281 | c == '.' || c == '_' || c == '-' || c == '+' || c == ':'; |
Willy Tarreau | 36f586b | 2020-02-14 18:25:17 +0100 | [diff] [blame] | 282 | } |
| 283 | |
Frédéric Lécaille | b82f742 | 2017-04-13 18:24:23 +0200 | [diff] [blame] | 284 | /* |
Willy Tarreau | fab5a43 | 2011-03-04 15:31:53 +0100 | [diff] [blame] | 285 | * converts <str> to a locally allocated struct sockaddr_storage *, and a |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 286 | * port range consisting in two integers. The low and high end are always set |
| 287 | * even if the port is unspecified, in which case (0,0) is returned. The low |
Willy Tarreau | fab5a43 | 2011-03-04 15:31:53 +0100 | [diff] [blame] | 288 | * port is set in the sockaddr. Thus, it is enough to check the size of the |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 289 | * returned range to know if an array must be allocated or not. The format is |
Willy Tarreau | fab5a43 | 2011-03-04 15:31:53 +0100 | [diff] [blame] | 290 | * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6 |
| 291 | * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6 |
| 292 | * address wants to ignore port, it must be terminated by a trailing colon (':'). |
| 293 | * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on |
| 294 | * IPv6, use ":::port". NULL is returned if the host part cannot be resolved. |
Willy Tarreau | d393a62 | 2013-03-04 18:22:00 +0100 | [diff] [blame] | 295 | * If <pfx> is non-null, it is used as a string prefix before any path-based |
Thierry FOURNIER | 7fe3be7 | 2015-09-26 20:03:36 +0200 | [diff] [blame] | 296 | * address (typically the path to a unix socket). If use_dns is not true, |
Joseph Herlant | 32b8327 | 2018-11-15 11:58:28 -0800 | [diff] [blame] | 297 | * the function cannot accept the DNS resolution. |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 298 | */ |
Willy Tarreau | 48ef4c9 | 2017-01-06 18:32:38 +0100 | [diff] [blame] | 299 | struct sockaddr_storage *str2sa_range(const char *str, |
| 300 | int *port, int *low, int *high, |
| 301 | char **err, const char *pfx, |
| 302 | char **fqdn, int resolve); |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 303 | |
Willy Tarreau | 2937c0d | 2010-01-26 17:36:17 +0100 | [diff] [blame] | 304 | /* converts <str> to a struct in_addr containing a network mask. It can be |
| 305 | * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1 |
Jarno Huuskonen | 577d5ac | 2017-05-21 17:32:21 +0300 | [diff] [blame] | 306 | * if the conversion succeeds otherwise zero. |
Willy Tarreau | 2937c0d | 2010-01-26 17:36:17 +0100 | [diff] [blame] | 307 | */ |
| 308 | int str2mask(const char *str, struct in_addr *mask); |
| 309 | |
Tim Duesterhus | 4718517 | 2018-01-25 16:24:49 +0100 | [diff] [blame] | 310 | /* converts <str> to a struct in6_addr containing a network mask. It can be |
Tim Duesterhus | 5e64286 | 2018-02-20 17:02:18 +0100 | [diff] [blame] | 311 | * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1 |
Tim Duesterhus | 4718517 | 2018-01-25 16:24:49 +0100 | [diff] [blame] | 312 | * if the conversion succeeds otherwise zero. |
| 313 | */ |
| 314 | int str2mask6(const char *str, struct in6_addr *mask); |
| 315 | |
Thierry FOURNIER | b050463 | 2013-12-14 15:39:02 +0100 | [diff] [blame] | 316 | /* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion |
| 317 | * succeeds otherwise non-zero. |
| 318 | */ |
| 319 | int cidr2dotted(int cidr, struct in_addr *mask); |
| 320 | |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 321 | /* |
Willy Tarreau | d077a8e | 2007-05-08 18:28:09 +0200 | [diff] [blame] | 322 | * converts <str> to two struct in_addr* which must be pre-allocated. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 323 | * The format is "addr[/mask]", where "addr" cannot be empty, and mask |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 324 | * is optional and either in the dotted or CIDR notation. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 325 | * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error. |
| 326 | */ |
Thierry FOURNIER | fc7ac7b | 2014-02-11 15:23:04 +0100 | [diff] [blame] | 327 | int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 328 | |
Thierry FOURNIER | 58639a0 | 2014-11-25 12:02:25 +0100 | [diff] [blame] | 329 | /* str2ip and str2ip2: |
| 330 | * |
| 331 | * converts <str> to a struct sockaddr_storage* provided by the caller. The |
| 332 | * caller must have zeroed <sa> first, and may have set sa->ss_family to force |
| 333 | * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then |
| 334 | * the function tries to guess the address family from the syntax. If the |
| 335 | * family is forced and the format doesn't match, an error is returned. The |
| 336 | * string is assumed to contain only an address, no port. The address can be a |
| 337 | * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to |
| 338 | * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved. |
| 339 | * The return address will only have the address family and the address set, |
| 340 | * all other fields remain zero. The string is not supposed to be modified. |
| 341 | * The IPv6 '::' address is IN6ADDR_ANY. |
| 342 | * |
| 343 | * str2ip2: |
| 344 | * |
| 345 | * If <resolve> is set, this function try to resolve DNS, otherwise, it returns |
| 346 | * NULL result. |
| 347 | */ |
| 348 | struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve); |
| 349 | static inline struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa) |
| 350 | { |
| 351 | return str2ip2(str, sa, 1); |
| 352 | } |
| 353 | |
Alexandre Cassen | 5eb1a90 | 2007-11-29 15:43:32 +0100 | [diff] [blame] | 354 | /* |
Willy Tarreau | 6d20e28 | 2012-04-27 22:49:47 +0200 | [diff] [blame] | 355 | * converts <str> to two struct in6_addr* which must be pre-allocated. |
| 356 | * The format is "addr[/mask]", where "addr" cannot be empty, and mask |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 357 | * is an optional number of bits (128 being the default). |
Willy Tarreau | 6d20e28 | 2012-04-27 22:49:47 +0200 | [diff] [blame] | 358 | * Returns 1 if OK, 0 if error. |
| 359 | */ |
| 360 | int str62net(const char *str, struct in6_addr *addr, unsigned char *mask); |
| 361 | |
| 362 | /* |
Willy Tarreau | 106f979 | 2009-09-19 07:54:16 +0200 | [diff] [blame] | 363 | * Parse IP address found in url. |
| 364 | */ |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 365 | int url2ipv4(const char *addr, struct in_addr *dst); |
Willy Tarreau | 106f979 | 2009-09-19 07:54:16 +0200 | [diff] [blame] | 366 | |
| 367 | /* |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 368 | * Resolve destination server from URL. Convert <str> to a sockaddr_storage*. |
Alexandre Cassen | 5eb1a90 | 2007-11-29 15:43:32 +0100 | [diff] [blame] | 369 | */ |
Thierry FOURNIER | 9f95e40 | 2014-03-21 14:51:46 +0100 | [diff] [blame] | 370 | int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out); |
Alexandre Cassen | 5eb1a90 | 2007-11-29 15:43:32 +0100 | [diff] [blame] | 371 | |
Willy Tarreau | 631f01c | 2011-09-05 00:36:48 +0200 | [diff] [blame] | 372 | /* Tries to convert a sockaddr_storage address to text form. Upon success, the |
| 373 | * address family is returned so that it's easy for the caller to adapt to the |
| 374 | * output format. Zero is returned if the address family is not supported. -1 |
| 375 | * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are |
| 376 | * supported. |
| 377 | */ |
Willy Tarreau | d5ec4bf | 2019-04-25 17:48:16 +0200 | [diff] [blame] | 378 | int addr_to_str(const struct sockaddr_storage *addr, char *str, int size); |
Willy Tarreau | 631f01c | 2011-09-05 00:36:48 +0200 | [diff] [blame] | 379 | |
Simon Horman | 75ab8bd | 2014-06-16 09:39:41 +0900 | [diff] [blame] | 380 | /* Tries to convert a sockaddr_storage port to text form. Upon success, the |
| 381 | * address family is returned so that it's easy for the caller to adapt to the |
| 382 | * output format. Zero is returned if the address family is not supported. -1 |
| 383 | * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are |
| 384 | * supported. |
| 385 | */ |
Willy Tarreau | d5ec4bf | 2019-04-25 17:48:16 +0200 | [diff] [blame] | 386 | int port_to_str(const struct sockaddr_storage *addr, char *str, int size); |
Simon Horman | 75ab8bd | 2014-06-16 09:39:41 +0900 | [diff] [blame] | 387 | |
Willy Tarreau | 16e0156 | 2016-08-09 16:46:18 +0200 | [diff] [blame] | 388 | /* check if the given address is local to the system or not. It will return |
| 389 | * -1 when it's not possible to know, 0 when the address is not local, 1 when |
| 390 | * it is. We don't want to iterate over all interfaces for this (and it is not |
| 391 | * portable). So instead we try to bind in UDP to this address on a free non |
| 392 | * privileged port and to connect to the same address, port 0 (connect doesn't |
| 393 | * care). If it succeeds, we own the address. Note that non-inet addresses are |
| 394 | * considered local since they're most likely AF_UNIX. |
| 395 | */ |
| 396 | int addr_is_local(const struct netns_entry *ns, |
| 397 | const struct sockaddr_storage *orig); |
| 398 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 399 | /* will try to encode the string <string> replacing all characters tagged in |
| 400 | * <map> with the hexadecimal representation of their ASCII-code (2 digits) |
| 401 | * prefixed by <escape>, and will store the result between <start> (included) |
| 402 | * and <stop> (excluded), and will always terminate the string with a '\0' |
| 403 | * before <stop>. The position of the '\0' is returned if the conversion |
| 404 | * completes. If bytes are missing between <start> and <stop>, then the |
| 405 | * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0' |
| 406 | * cannot even be stored so we return <start> without writing the 0. |
| 407 | * The input string must also be zero-terminated. |
| 408 | */ |
| 409 | extern const char hextab[]; |
| 410 | char *encode_string(char *start, char *stop, |
Willy Tarreau | 1bfd602 | 2019-06-07 11:10:07 +0200 | [diff] [blame] | 411 | const char escape, const long *map, |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 412 | const char *string); |
| 413 | |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 414 | /* |
| 415 | * Same behavior, except that it encodes chunk <chunk> instead of a string. |
| 416 | */ |
| 417 | char *encode_chunk(char *start, char *stop, |
Willy Tarreau | 1bfd602 | 2019-06-07 11:10:07 +0200 | [diff] [blame] | 418 | const char escape, const long *map, |
Willy Tarreau | 83061a8 | 2018-07-13 11:56:34 +0200 | [diff] [blame] | 419 | const struct buffer *chunk); |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 420 | |
Dragan Dosen | 0edd109 | 2016-02-12 13:23:02 +0100 | [diff] [blame] | 421 | /* |
| 422 | * Tries to prefix characters tagged in the <map> with the <escape> |
Dragan Dosen | 1a5d060 | 2016-07-22 16:00:31 +0200 | [diff] [blame] | 423 | * character. The input <string> must be zero-terminated. The result will |
| 424 | * be stored between <start> (included) and <stop> (excluded). This |
| 425 | * function will always try to terminate the resulting string with a '\0' |
| 426 | * before <stop>, and will return its position if the conversion |
| 427 | * completes. |
| 428 | */ |
| 429 | char *escape_string(char *start, char *stop, |
Willy Tarreau | 1bfd602 | 2019-06-07 11:10:07 +0200 | [diff] [blame] | 430 | const char escape, const long *map, |
Dragan Dosen | 1a5d060 | 2016-07-22 16:00:31 +0200 | [diff] [blame] | 431 | const char *string); |
| 432 | |
| 433 | /* |
| 434 | * Tries to prefix characters tagged in the <map> with the <escape> |
Dragan Dosen | 0edd109 | 2016-02-12 13:23:02 +0100 | [diff] [blame] | 435 | * character. <chunk> contains the input to be escaped. The result will be |
| 436 | * stored between <start> (included) and <stop> (excluded). The function |
| 437 | * will always try to terminate the resulting string with a '\0' before |
| 438 | * <stop>, and will return its position if the conversion completes. |
| 439 | */ |
| 440 | char *escape_chunk(char *start, char *stop, |
Willy Tarreau | 1bfd602 | 2019-06-07 11:10:07 +0200 | [diff] [blame] | 441 | const char escape, const long *map, |
Willy Tarreau | 83061a8 | 2018-07-13 11:56:34 +0200 | [diff] [blame] | 442 | const struct buffer *chunk); |
Dragan Dosen | 0edd109 | 2016-02-12 13:23:02 +0100 | [diff] [blame] | 443 | |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 444 | |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 445 | /* Check a string for using it in a CSV output format. If the string contains |
| 446 | * one of the following four char <">, <,>, CR or LF, the string is |
| 447 | * encapsulated between <"> and the <"> are escaped by a <""> sequence. |
| 448 | * <str> is the input string to be escaped. The function assumes that |
| 449 | * the input string is null-terminated. |
| 450 | * |
| 451 | * If <quote> is 0, the result is returned escaped but without double quote. |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 452 | * It is useful if the escaped string is used between double quotes in the |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 453 | * format. |
| 454 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 455 | * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash)); |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 456 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 457 | * If <quote> is 1, the converter puts the quotes only if any character is |
| 458 | * escaped. If <quote> is 2, the converter always puts the quotes. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 459 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 460 | * <output> is a struct chunk used for storing the output string. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 461 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 462 | * The function returns the converted string on its output. If an error |
| 463 | * occurs, the function returns an empty string. This type of output is useful |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 464 | * for using the function directly as printf() argument. |
| 465 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 466 | * If the output buffer is too short to contain the input string, the result |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 467 | * is truncated. |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 468 | * |
| 469 | * This function appends the encoding to the existing output chunk. Please |
| 470 | * use csv_enc() instead if you want to replace the output chunk. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 471 | */ |
Willy Tarreau | 83061a8 | 2018-07-13 11:56:34 +0200 | [diff] [blame] | 472 | const char *csv_enc_append(const char *str, int quote, struct buffer *output); |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 473 | |
| 474 | /* same as above but the output chunk is reset first */ |
Willy Tarreau | 83061a8 | 2018-07-13 11:56:34 +0200 | [diff] [blame] | 475 | static inline const char *csv_enc(const char *str, int quote, |
| 476 | struct buffer *output) |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 477 | { |
| 478 | chunk_reset(output); |
| 479 | return csv_enc_append(str, quote, output); |
| 480 | } |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 481 | |
Willy Tarreau | bf9c2fc | 2011-05-31 18:06:18 +0200 | [diff] [blame] | 482 | /* Decode an URL-encoded string in-place. The resulting string might |
| 483 | * be shorter. If some forbidden characters are found, the conversion is |
| 484 | * aborted, the string is truncated before the issue and non-zero is returned, |
| 485 | * otherwise the operation returns non-zero indicating success. |
Willy Tarreau | 62ba9ba | 2020-04-23 17:54:47 +0200 | [diff] [blame] | 486 | * If the 'in_form' argument is non-nul the string is assumed to be part of |
| 487 | * an "application/x-www-form-urlencoded" encoded string, and the '+' will be |
| 488 | * turned to a space. If it's zero, this will only be done after a question |
| 489 | * mark ('?'). |
Willy Tarreau | bf9c2fc | 2011-05-31 18:06:18 +0200 | [diff] [blame] | 490 | */ |
Willy Tarreau | 62ba9ba | 2020-04-23 17:54:47 +0200 | [diff] [blame] | 491 | int url_decode(char *string, int in_form); |
Willy Tarreau | bf9c2fc | 2011-05-31 18:06:18 +0200 | [diff] [blame] | 492 | |
Willy Tarreau | d54bbdc | 2009-09-07 11:00:31 +0200 | [diff] [blame] | 493 | unsigned int inetaddr_host(const char *text); |
| 494 | unsigned int inetaddr_host_lim(const char *text, const char *stop); |
Willy Tarreau | 7417275 | 2010-10-15 23:21:42 +0200 | [diff] [blame] | 495 | unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret); |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 496 | |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 497 | static inline char *cut_crlf(char *s) { |
| 498 | |
Simon Horman | 5269cfb | 2013-02-13 17:48:00 +0900 | [diff] [blame] | 499 | while (*s != '\r' && *s != '\n') { |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 500 | char *p = s++; |
| 501 | |
| 502 | if (!*p) |
| 503 | return p; |
| 504 | } |
| 505 | |
Simon Horman | 5269cfb | 2013-02-13 17:48:00 +0900 | [diff] [blame] | 506 | *s++ = '\0'; |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 507 | |
| 508 | return s; |
| 509 | } |
| 510 | |
| 511 | static inline char *ltrim(char *s, char c) { |
| 512 | |
| 513 | if (c) |
| 514 | while (*s == c) |
| 515 | s++; |
| 516 | |
| 517 | return s; |
| 518 | } |
| 519 | |
| 520 | static inline char *rtrim(char *s, char c) { |
| 521 | |
| 522 | char *p = s + strlen(s); |
| 523 | |
| 524 | while (p-- > s) |
| 525 | if (*p == c) |
| 526 | *p = '\0'; |
| 527 | else |
| 528 | break; |
| 529 | |
| 530 | return s; |
| 531 | } |
| 532 | |
| 533 | static inline char *alltrim(char *s, char c) { |
| 534 | |
| 535 | rtrim(s, c); |
| 536 | |
| 537 | return ltrim(s, c); |
| 538 | } |
| 539 | |
Willy Tarreau | fe94460 | 2007-10-25 10:34:16 +0200 | [diff] [blame] | 540 | /* This function converts the time_t value <now> into a broken out struct tm |
| 541 | * which must be allocated by the caller. It is highly recommended to use this |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 542 | * function instead of localtime() because that one requires a time_t* which |
Willy Tarreau | fe94460 | 2007-10-25 10:34:16 +0200 | [diff] [blame] | 543 | * is not always compatible with tv_sec depending on OS/hardware combinations. |
| 544 | */ |
| 545 | static inline void get_localtime(const time_t now, struct tm *tm) |
| 546 | { |
| 547 | localtime_r(&now, tm); |
| 548 | } |
| 549 | |
Emeric Brun | 3a058f3 | 2009-06-30 18:26:00 +0200 | [diff] [blame] | 550 | /* This function converts the time_t value <now> into a broken out struct tm |
| 551 | * which must be allocated by the caller. It is highly recommended to use this |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 552 | * function instead of gmtime() because that one requires a time_t* which |
Emeric Brun | 3a058f3 | 2009-06-30 18:26:00 +0200 | [diff] [blame] | 553 | * is not always compatible with tv_sec depending on OS/hardware combinations. |
| 554 | */ |
| 555 | static inline void get_gmtime(const time_t now, struct tm *tm) |
| 556 | { |
| 557 | gmtime_r(&now, tm); |
| 558 | } |
| 559 | |
Willy Tarreau | cb1949b | 2017-07-19 19:05:29 +0200 | [diff] [blame] | 560 | /* Counts a number of elapsed days since 01/01/0000 based solely on elapsed |
| 561 | * years and assuming the regular rule for leap years applies. It's fake but |
| 562 | * serves as a temporary origin. It's worth remembering that it's the first |
| 563 | * year of each period that is leap and not the last one, so for instance year |
| 564 | * 1 sees 366 days since year 0 was leap. For this reason we have to apply |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 565 | * modular arithmetic which is why we offset the year by 399 before |
Willy Tarreau | cb1949b | 2017-07-19 19:05:29 +0200 | [diff] [blame] | 566 | * subtracting the excess at the end. No overflow here before ~11.7 million |
| 567 | * years. |
| 568 | */ |
| 569 | static inline unsigned int days_since_zero(unsigned int y) |
| 570 | { |
| 571 | return y * 365 + (y + 399) / 4 - (y + 399) / 100 + (y + 399) / 400 |
| 572 | - 399 / 4 + 399 / 100; |
| 573 | } |
| 574 | |
| 575 | /* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>. |
| 576 | * It is meant as a portable replacement for timegm() for use with valid inputs. |
| 577 | * Returns undefined results for invalid dates (eg: months out of range 0..11). |
| 578 | */ |
| 579 | extern time_t my_timegm(const struct tm *tm); |
| 580 | |
Willy Tarreau | a0d37b6 | 2007-12-02 22:00:35 +0100 | [diff] [blame] | 581 | /* This function parses a time value optionally followed by a unit suffix among |
| 582 | * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit |
| 583 | * expected by the caller. The computation does its best to avoid overflows. |
| 584 | * The value is returned in <ret> if everything is fine, and a NULL is returned |
| 585 | * by the function. In case of error, a pointer to the error is returned and |
| 586 | * <ret> is left untouched. |
| 587 | */ |
| 588 | extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags); |
Emeric Brun | 39132b2 | 2010-01-04 14:57:24 +0100 | [diff] [blame] | 589 | extern const char *parse_size_err(const char *text, unsigned *ret); |
Willy Tarreau | a0d37b6 | 2007-12-02 22:00:35 +0100 | [diff] [blame] | 590 | |
Willy Tarreau | 9faebe3 | 2019-06-07 19:00:37 +0200 | [diff] [blame] | 591 | /* special return values for the time parser */ |
| 592 | #define PARSE_TIME_UNDER ((char *)1) |
| 593 | #define PARSE_TIME_OVER ((char *)2) |
| 594 | |
Willy Tarreau | a0d37b6 | 2007-12-02 22:00:35 +0100 | [diff] [blame] | 595 | /* unit flags to pass to parse_time_err */ |
| 596 | #define TIME_UNIT_US 0x0000 |
| 597 | #define TIME_UNIT_MS 0x0001 |
| 598 | #define TIME_UNIT_S 0x0002 |
| 599 | #define TIME_UNIT_MIN 0x0003 |
| 600 | #define TIME_UNIT_HOUR 0x0004 |
| 601 | #define TIME_UNIT_DAY 0x0005 |
| 602 | #define TIME_UNIT_MASK 0x0007 |
| 603 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 604 | #define SEC 1 |
| 605 | #define MINUTE (60 * SEC) |
| 606 | #define HOUR (60 * MINUTE) |
| 607 | #define DAY (24 * HOUR) |
| 608 | |
Willy Tarreau | 126d406 | 2013-12-03 17:50:47 +0100 | [diff] [blame] | 609 | /* |
| 610 | * Parse binary string written in hexadecimal (source) and store the decoded |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 611 | * result into binstr and set binstrlen to the length of binstr. Memory for |
Willy Tarreau | 126d406 | 2013-12-03 17:50:47 +0100 | [diff] [blame] | 612 | * binstr is allocated by the function. In case of error, returns 0 with an |
| 613 | * error message in err. |
| 614 | */ |
| 615 | int parse_binary(const char *source, char **binstr, int *binstrlen, char **err); |
| 616 | |
Willy Tarreau | 946ba59 | 2009-05-10 15:41:18 +0200 | [diff] [blame] | 617 | /* copies at most <n> characters from <src> and always terminates with '\0' */ |
| 618 | char *my_strndup(const char *src, int n); |
| 619 | |
Baptiste Assmann | bb77c8e | 2013-10-06 23:24:13 +0200 | [diff] [blame] | 620 | /* |
| 621 | * search needle in haystack |
| 622 | * returns the pointer if found, returns NULL otherwise |
| 623 | */ |
| 624 | const void *my_memmem(const void *, size_t, const void *, size_t); |
| 625 | |
Christopher Faulet | 5eb96cb | 2020-04-15 10:23:01 +0200 | [diff] [blame] | 626 | /* get length of the initial segment consiting entirely of bytes within a given |
| 627 | * mask |
| 628 | */ |
| 629 | size_t my_memspn(const void *, size_t, const void *, size_t); |
| 630 | |
| 631 | /* get length of the initial segment consiting entirely of bytes not within a |
| 632 | * given mask |
| 633 | */ |
| 634 | size_t my_memcspn(const void *, size_t, const void *, size_t); |
| 635 | |
Willy Tarreau | 482b00d | 2009-10-04 22:48:42 +0200 | [diff] [blame] | 636 | /* This function returns the first unused key greater than or equal to <key> in |
| 637 | * ID tree <root>. Zero is returned if no place is found. |
| 638 | */ |
| 639 | unsigned int get_next_id(struct eb_root *root, unsigned int key); |
| 640 | |
Willy Tarreau | 9c1e15d | 2017-11-15 18:51:29 +0100 | [diff] [blame] | 641 | /* dump the full tree to <file> in DOT format for debugging purposes. Will |
| 642 | * optionally highlight node <subj> if found, depending on operation <op> : |
| 643 | * 0 : nothing |
| 644 | * >0 : insertion, node/leaf are surrounded in red |
| 645 | * <0 : removal, node/leaf are dashed with no background |
| 646 | * Will optionally add "desc" as a label on the graph if set and non-null. |
| 647 | */ |
| 648 | void eb32sc_to_file(FILE *file, struct eb_root *root, const struct eb32sc_node *subj, |
| 649 | int op, const char *desc); |
Willy Tarreau | ed3cda0 | 2017-11-15 15:04:05 +0100 | [diff] [blame] | 650 | |
Willy Tarreau | 348238b | 2010-01-18 15:05:57 +0100 | [diff] [blame] | 651 | /* This function compares a sample word possibly followed by blanks to another |
| 652 | * clean word. The compare is case-insensitive. 1 is returned if both are equal, |
| 653 | * otherwise zero. This intends to be used when checking HTTP headers for some |
| 654 | * values. |
| 655 | */ |
| 656 | int word_match(const char *sample, int slen, const char *word, int wlen); |
| 657 | |
Willy Tarreau | f0b38bf | 2010-06-06 13:22:23 +0200 | [diff] [blame] | 658 | /* Convert a fixed-length string to an IP address. Returns 0 in case of error, |
| 659 | * or the number of chars read in case of success. |
| 660 | */ |
| 661 | int buf2ip(const char *buf, size_t len, struct in_addr *dst); |
Thierry FOURNIER | d559dd8 | 2013-11-22 16:16:59 +0100 | [diff] [blame] | 662 | int buf2ip6(const char *buf, size_t len, struct in6_addr *dst); |
Willy Tarreau | f0b38bf | 2010-06-06 13:22:23 +0200 | [diff] [blame] | 663 | |
Willy Tarreau | acf9577 | 2010-06-14 19:09:21 +0200 | [diff] [blame] | 664 | /* To be used to quote config arg positions. Returns the string at <ptr> |
| 665 | * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line" |
| 666 | * if ptr is NULL or empty. The string is locally allocated. |
| 667 | */ |
| 668 | const char *quote_arg(const char *ptr); |
| 669 | |
Willy Tarreau | 5b18020 | 2010-07-18 10:40:48 +0200 | [diff] [blame] | 670 | /* returns an operator among STD_OP_* for string <str> or < 0 if unknown */ |
| 671 | int get_std_op(const char *str); |
| 672 | |
Willy Tarreau | 422a0a5 | 2012-10-26 19:47:23 +0200 | [diff] [blame] | 673 | /* sets the address family to AF_UNSPEC so that is_addr() does not match */ |
| 674 | static inline void clear_addr(struct sockaddr_storage *addr) |
| 675 | { |
| 676 | addr->ss_family = AF_UNSPEC; |
| 677 | } |
| 678 | |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 679 | /* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address, |
| 680 | * otherwise zero. |
| 681 | */ |
Willy Tarreau | 18ca2d4 | 2014-05-09 22:40:55 +0200 | [diff] [blame] | 682 | static inline int is_inet_addr(const struct sockaddr_storage *addr) |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 683 | { |
| 684 | int i; |
| 685 | |
| 686 | switch (addr->ss_family) { |
| 687 | case AF_INET: |
David du Colombier | 64e9c90 | 2011-03-22 11:39:41 +0100 | [diff] [blame] | 688 | return *(int *)&((struct sockaddr_in *)addr)->sin_addr; |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 689 | case AF_INET6: |
| 690 | for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++) |
| 691 | if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0) |
| 692 | return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i]; |
| 693 | } |
| 694 | return 0; |
| 695 | } |
| 696 | |
Willy Tarreau | 18ca2d4 | 2014-05-09 22:40:55 +0200 | [diff] [blame] | 697 | /* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address, |
| 698 | * or is a unix address, otherwise returns zero. |
| 699 | */ |
| 700 | static inline int is_addr(const struct sockaddr_storage *addr) |
| 701 | { |
William Lallemand | 2fe7dd0 | 2018-09-11 16:51:29 +0200 | [diff] [blame] | 702 | if (addr->ss_family == AF_UNIX || addr->ss_family == AF_CUST_SOCKPAIR) |
Willy Tarreau | 18ca2d4 | 2014-05-09 22:40:55 +0200 | [diff] [blame] | 703 | return 1; |
| 704 | else |
| 705 | return is_inet_addr(addr); |
| 706 | } |
| 707 | |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 708 | /* returns port in network byte order */ |
| 709 | static inline int get_net_port(struct sockaddr_storage *addr) |
| 710 | { |
| 711 | switch (addr->ss_family) { |
| 712 | case AF_INET: |
| 713 | return ((struct sockaddr_in *)addr)->sin_port; |
| 714 | case AF_INET6: |
| 715 | return ((struct sockaddr_in6 *)addr)->sin6_port; |
| 716 | } |
| 717 | return 0; |
| 718 | } |
| 719 | |
| 720 | /* returns port in host byte order */ |
| 721 | static inline int get_host_port(struct sockaddr_storage *addr) |
| 722 | { |
| 723 | switch (addr->ss_family) { |
| 724 | case AF_INET: |
| 725 | return ntohs(((struct sockaddr_in *)addr)->sin_port); |
| 726 | case AF_INET6: |
| 727 | return ntohs(((struct sockaddr_in6 *)addr)->sin6_port); |
| 728 | } |
| 729 | return 0; |
| 730 | } |
| 731 | |
Willy Tarreau | 1b4b7ce | 2011-04-05 16:56:50 +0200 | [diff] [blame] | 732 | /* returns address len for <addr>'s family, 0 for unknown families */ |
| 733 | static inline int get_addr_len(const struct sockaddr_storage *addr) |
| 734 | { |
| 735 | switch (addr->ss_family) { |
| 736 | case AF_INET: |
| 737 | return sizeof(struct sockaddr_in); |
| 738 | case AF_INET6: |
| 739 | return sizeof(struct sockaddr_in6); |
| 740 | case AF_UNIX: |
| 741 | return sizeof(struct sockaddr_un); |
| 742 | } |
| 743 | return 0; |
| 744 | } |
| 745 | |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 746 | /* set port in host byte order */ |
| 747 | static inline int set_net_port(struct sockaddr_storage *addr, int port) |
| 748 | { |
| 749 | switch (addr->ss_family) { |
| 750 | case AF_INET: |
| 751 | ((struct sockaddr_in *)addr)->sin_port = port; |
Willy Tarreau | 4c0fcc2 | 2018-09-20 10:48:35 +0200 | [diff] [blame] | 752 | break; |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 753 | case AF_INET6: |
| 754 | ((struct sockaddr_in6 *)addr)->sin6_port = port; |
Willy Tarreau | 4c0fcc2 | 2018-09-20 10:48:35 +0200 | [diff] [blame] | 755 | break; |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 756 | } |
| 757 | return 0; |
| 758 | } |
| 759 | |
| 760 | /* set port in network byte order */ |
| 761 | static inline int set_host_port(struct sockaddr_storage *addr, int port) |
| 762 | { |
| 763 | switch (addr->ss_family) { |
| 764 | case AF_INET: |
| 765 | ((struct sockaddr_in *)addr)->sin_port = htons(port); |
Willy Tarreau | 4c0fcc2 | 2018-09-20 10:48:35 +0200 | [diff] [blame] | 766 | break; |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 767 | case AF_INET6: |
| 768 | ((struct sockaddr_in6 *)addr)->sin6_port = htons(port); |
Willy Tarreau | 4c0fcc2 | 2018-09-20 10:48:35 +0200 | [diff] [blame] | 769 | break; |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 770 | } |
| 771 | return 0; |
| 772 | } |
| 773 | |
Thierry Fournier | 70473a5 | 2016-02-17 17:12:14 +0100 | [diff] [blame] | 774 | /* Convert mask from bit length form to in_addr form. |
| 775 | * This function never fails. |
| 776 | */ |
| 777 | void len2mask4(int len, struct in_addr *addr); |
| 778 | |
| 779 | /* Convert mask from bit length form to in6_addr form. |
| 780 | * This function never fails. |
| 781 | */ |
| 782 | void len2mask6(int len, struct in6_addr *addr); |
| 783 | |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 784 | /* Return true if IPv4 address is part of the network */ |
Willy Tarreau | eec1d38 | 2016-07-13 11:59:39 +0200 | [diff] [blame] | 785 | extern int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net); |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 786 | |
| 787 | /* Return true if IPv6 address is part of the network */ |
Willy Tarreau | eec1d38 | 2016-07-13 11:59:39 +0200 | [diff] [blame] | 788 | extern int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net); |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 789 | |
Joseph Herlant | 32b8327 | 2018-11-15 11:58:28 -0800 | [diff] [blame] | 790 | /* Map IPv4 address on IPv6 address, as specified in RFC 3513. */ |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 791 | extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr); |
| 792 | |
Joseph Herlant | 32b8327 | 2018-11-15 11:58:28 -0800 | [diff] [blame] | 793 | /* Map IPv6 address on IPv4 address, as specified in RFC 3513. |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 794 | * Return true if conversion is possible and false otherwise. |
| 795 | */ |
| 796 | extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr); |
| 797 | |
Baptiste Assmann | 08b24cf | 2016-01-23 23:39:12 +0100 | [diff] [blame] | 798 | /* compare two struct sockaddr_storage and return: |
| 799 | * 0 (true) if the addr is the same in both |
| 800 | * 1 (false) if the addr is not the same in both |
| 801 | */ |
| 802 | int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2); |
| 803 | |
Baptiste Assmann | 08396c8 | 2016-01-31 00:27:17 +0100 | [diff] [blame] | 804 | /* copy ip from <source> into <dest> |
| 805 | * the caller must clear <dest> before calling. |
| 806 | * Returns a pointer to the destination |
| 807 | */ |
| 808 | struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest); |
| 809 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 810 | char *human_time(int t, short hz_div); |
| 811 | |
| 812 | extern const char *monthname[]; |
| 813 | |
| 814 | /* date2str_log: write a date in the format : |
| 815 | * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d", |
| 816 | * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900, |
| 817 | * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000); |
| 818 | * |
| 819 | * without using sprintf. return a pointer to the last char written (\0) or |
| 820 | * NULL if there isn't enough space. |
| 821 | */ |
Willy Tarreau | f16cb41 | 2018-09-04 19:08:48 +0200 | [diff] [blame] | 822 | char *date2str_log(char *dest, const struct tm *tm, const struct timeval *date, size_t size); |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 823 | |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 824 | /* Return the GMT offset for a specific local time. |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 825 | * Both t and tm must represent the same time. |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 826 | * The string returned has the same format as returned by strftime(... "%z", tm). |
| 827 | * Offsets are kept in an internal cache for better performances. |
| 828 | */ |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 829 | const char *get_gmt_offset(time_t t, struct tm *tm); |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 830 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 831 | /* gmt2str_log: write a date in the format : |
| 832 | * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf |
| 833 | * return a pointer to the last char written (\0) or |
| 834 | * NULL if there isn't enough space. |
| 835 | */ |
| 836 | char *gmt2str_log(char *dst, struct tm *tm, size_t size); |
| 837 | |
Yuxans Yao | 4e25b01 | 2012-10-19 10:36:09 +0800 | [diff] [blame] | 838 | /* localdate2str_log: write a date in the format : |
| 839 | * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 840 | * Both t and tm must represent the same time. |
Yuxans Yao | 4e25b01 | 2012-10-19 10:36:09 +0800 | [diff] [blame] | 841 | * return a pointer to the last char written (\0) or |
| 842 | * NULL if there isn't enough space. |
| 843 | */ |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 844 | char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size); |
Yuxans Yao | 4e25b01 | 2012-10-19 10:36:09 +0800 | [diff] [blame] | 845 | |
Thierry Fournier | 9312794 | 2016-01-20 18:49:45 +0100 | [diff] [blame] | 846 | /* These 3 functions parses date string and fills the |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 847 | * corresponding broken-down time in <tm>. In success case, |
Thierry Fournier | 9312794 | 2016-01-20 18:49:45 +0100 | [diff] [blame] | 848 | * it returns 1, otherwise, it returns 0. |
| 849 | */ |
| 850 | int parse_http_date(const char *date, int len, struct tm *tm); |
| 851 | int parse_imf_date(const char *date, int len, struct tm *tm); |
| 852 | int parse_rfc850_date(const char *date, int len, struct tm *tm); |
| 853 | int parse_asctime_date(const char *date, int len, struct tm *tm); |
| 854 | |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 855 | /* Dynamically allocates a string of the proper length to hold the formatted |
| 856 | * output. NULL is returned on error. The caller is responsible for freeing the |
| 857 | * memory area using free(). The resulting string is returned in <out> if the |
| 858 | * pointer is not NULL. A previous version of <out> might be used to build the |
| 859 | * new string, and it will be freed before returning if it is not NULL, which |
| 860 | * makes it possible to build complex strings from iterative calls without |
| 861 | * having to care about freeing intermediate values, as in the example below : |
| 862 | * |
| 863 | * memprintf(&err, "invalid argument: '%s'", arg); |
| 864 | * ... |
| 865 | * memprintf(&err, "parser said : <%s>\n", *err); |
| 866 | * ... |
| 867 | * free(*err); |
| 868 | * |
| 869 | * This means that <err> must be initialized to NULL before first invocation. |
| 870 | * The return value also holds the allocated string, which eases error checking |
| 871 | * and immediate consumption. If the output pointer is not used, NULL must be |
Willy Tarreau | eb6cead | 2012-09-20 19:43:14 +0200 | [diff] [blame] | 872 | * passed instead and it will be ignored. The returned message will then also |
| 873 | * be NULL so that the caller does not have to bother with freeing anything. |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 874 | * |
| 875 | * It is also convenient to use it without any free except the last one : |
| 876 | * err = NULL; |
| 877 | * if (!fct1(err)) report(*err); |
| 878 | * if (!fct2(err)) report(*err); |
| 879 | * if (!fct3(err)) report(*err); |
| 880 | * free(*err); |
Christopher Faulet | 93a518f | 2017-10-24 11:25:33 +0200 | [diff] [blame] | 881 | * |
| 882 | * memprintf relies on memvprintf. This last version can be called from any |
| 883 | * function with variadic arguments. |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 884 | */ |
Christopher Faulet | 93a518f | 2017-10-24 11:25:33 +0200 | [diff] [blame] | 885 | char *memvprintf(char **out, const char *format, va_list args) |
| 886 | __attribute__ ((format(printf, 2, 0))); |
| 887 | |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 888 | char *memprintf(char **out, const char *format, ...) |
| 889 | __attribute__ ((format(printf, 2, 3))); |
| 890 | |
Willy Tarreau | 21c705b | 2012-09-14 11:40:36 +0200 | [diff] [blame] | 891 | /* Used to add <level> spaces before each line of <out>, unless there is only one line. |
| 892 | * The input argument is automatically freed and reassigned. The result will have to be |
| 893 | * freed by the caller. |
| 894 | * Example of use : |
| 895 | * parse(cmd, &err); (callee: memprintf(&err, ...)) |
| 896 | * fprintf(stderr, "Parser said: %s\n", indent_error(&err)); |
| 897 | * free(err); |
| 898 | */ |
| 899 | char *indent_msg(char **out, int level); |
Willy Tarreau | a2c9911 | 2019-08-21 13:17:37 +0200 | [diff] [blame] | 900 | int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first); |
Willy Tarreau | 3d2f16f | 2012-05-13 00:21:17 +0200 | [diff] [blame] | 901 | |
Willy Tarreau | 9d22e56 | 2019-03-29 18:49:09 +0100 | [diff] [blame] | 902 | /* removes environment variable <name> from the environment as found in |
| 903 | * environ. This is only provided as an alternative for systems without |
| 904 | * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE. |
Ilya Shipitsin | 77e3b4a | 2020-03-10 12:06:11 +0500 | [diff] [blame] | 905 | * The principle is to scan environ for each occurrence of variable name |
Willy Tarreau | 9d22e56 | 2019-03-29 18:49:09 +0100 | [diff] [blame] | 906 | * <name> and to replace the matching pointers with the last pointer of |
| 907 | * the array (since variables are not ordered). |
| 908 | * It always returns 0 (success). |
| 909 | */ |
| 910 | int my_unsetenv(const char *name); |
| 911 | |
Willy Tarreau | dad36a3 | 2013-03-11 01:20:04 +0100 | [diff] [blame] | 912 | /* Convert occurrences of environment variables in the input string to their |
| 913 | * corresponding value. A variable is identified as a series of alphanumeric |
| 914 | * characters or underscores following a '$' sign. The <in> string must be |
| 915 | * free()able. NULL returns NULL. The resulting string might be reallocated if |
| 916 | * some expansion is made. |
| 917 | */ |
| 918 | char *env_expand(char *in); |
| 919 | |
Willy Tarreau | 3d2f16f | 2012-05-13 00:21:17 +0200 | [diff] [blame] | 920 | /* debugging macro to emit messages using write() on fd #-1 so that strace sees |
| 921 | * them. |
| 922 | */ |
| 923 | #define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0) |
| 924 | |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 925 | /* displays a <len> long memory block at <buf>, assuming first byte of <buf> |
Willy Tarreau | ed936c5 | 2017-04-27 18:03:20 +0200 | [diff] [blame] | 926 | * has address <baseaddr>. String <pfx> may be placed as a prefix in front of |
| 927 | * each line. It may be NULL if unused. The output is emitted to file <out>. |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 928 | */ |
Willy Tarreau | ed936c5 | 2017-04-27 18:03:20 +0200 | [diff] [blame] | 929 | void debug_hexdump(FILE *out, const char *pfx, const char *buf, unsigned int baseaddr, int len); |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 930 | |
Willy Tarreau | 9eebd8a | 2019-08-08 16:53:40 +0200 | [diff] [blame] | 931 | /* this is used to emit call traces when building with TRACE=1 */ |
Willy Tarreau | 1296382 | 2017-10-24 10:54:08 +0200 | [diff] [blame] | 932 | __attribute__((format(printf, 1, 2))) |
Willy Tarreau | 9eebd8a | 2019-08-08 16:53:40 +0200 | [diff] [blame] | 933 | void calltrace(char *fmt, ...); |
Willy Tarreau | 1296382 | 2017-10-24 10:54:08 +0200 | [diff] [blame] | 934 | |
de Lafond Guillaume | 88c278f | 2013-04-15 19:27:10 +0200 | [diff] [blame] | 935 | /* same as strstr() but case-insensitive */ |
| 936 | const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2); |
| 937 | |
Willy Tarreau | ab813a4 | 2018-09-10 18:41:28 +0200 | [diff] [blame] | 938 | /* after increasing a pointer value, it can exceed the first buffer |
| 939 | * size. This function transform the value of <ptr> according with |
| 940 | * the expected position. <chunks> is an array of the one or two |
Joseph Herlant | 32b8327 | 2018-11-15 11:58:28 -0800 | [diff] [blame] | 941 | * available chunks. The first value is the start of the first chunk, |
Willy Tarreau | ab813a4 | 2018-09-10 18:41:28 +0200 | [diff] [blame] | 942 | * the second value if the end+1 of the first chunks. The third value |
| 943 | * is NULL or the start of the second chunk and the fourth value is |
| 944 | * the end+1 of the second chunk. The function returns 1 if does a |
| 945 | * wrap, else returns 0. |
| 946 | */ |
| 947 | static inline int fix_pointer_if_wrap(const char **chunks, const char **ptr) |
| 948 | { |
| 949 | if (*ptr < chunks[1]) |
| 950 | return 0; |
| 951 | if (!chunks[2]) |
| 952 | return 0; |
| 953 | *ptr = chunks[2] + ( *ptr - chunks[1] ); |
| 954 | return 1; |
| 955 | } |
Willy Tarreau | bb519c7 | 2014-01-28 23:04:39 +0100 | [diff] [blame] | 956 | |
| 957 | /************************* Composite address manipulation ********************* |
| 958 | * Composite addresses are simply unsigned long data in which the higher bits |
| 959 | * represent a pointer, and the two lower bits are flags. There are several |
| 960 | * places where we just want to associate one or two flags to a pointer (eg, |
| 961 | * to type it), and these functions permit this. The pointer is necessarily a |
| 962 | * 32-bit aligned pointer, as its two lower bits will be cleared and replaced |
| 963 | * with the flags. |
| 964 | *****************************************************************************/ |
| 965 | |
| 966 | /* Masks the two lower bits of a composite address and converts it to a |
| 967 | * pointer. This is used to mix some bits with some aligned pointers to |
| 968 | * structs and to retrieve the original (32-bit aligned) pointer. |
| 969 | */ |
| 970 | static inline void *caddr_to_ptr(unsigned long caddr) |
| 971 | { |
| 972 | return (void *)(caddr & ~3UL); |
| 973 | } |
| 974 | |
| 975 | /* Only retrieves the two lower bits of a composite address. This is used to mix |
| 976 | * some bits with some aligned pointers to structs and to retrieve the original |
| 977 | * data (2 bits). |
| 978 | */ |
| 979 | static inline unsigned int caddr_to_data(unsigned long caddr) |
| 980 | { |
| 981 | return (caddr & 3UL); |
| 982 | } |
| 983 | |
| 984 | /* Combines the aligned pointer whose 2 lower bits will be masked with the bits |
| 985 | * from <data> to form a composite address. This is used to mix some bits with |
| 986 | * some aligned pointers to structs and to retrieve the original (32-bit aligned) |
| 987 | * pointer. |
| 988 | */ |
| 989 | static inline unsigned long caddr_from_ptr(void *ptr, unsigned int data) |
| 990 | { |
| 991 | return (((unsigned long)ptr) & ~3UL) + (data & 3); |
| 992 | } |
| 993 | |
| 994 | /* sets the 2 bits of <data> in the <caddr> composite address */ |
| 995 | static inline unsigned long caddr_set_flags(unsigned long caddr, unsigned int data) |
| 996 | { |
| 997 | return caddr | (data & 3); |
| 998 | } |
| 999 | |
| 1000 | /* clears the 2 bits of <data> in the <caddr> composite address */ |
| 1001 | static inline unsigned long caddr_clr_flags(unsigned long caddr, unsigned int data) |
| 1002 | { |
| 1003 | return caddr & ~(unsigned long)(data & 3); |
| 1004 | } |
| 1005 | |
Thierry FOURNIER | 317e1c4 | 2014-08-12 10:20:47 +0200 | [diff] [blame] | 1006 | /* UTF-8 decoder status */ |
| 1007 | #define UTF8_CODE_OK 0x00 |
| 1008 | #define UTF8_CODE_OVERLONG 0x10 |
| 1009 | #define UTF8_CODE_INVRANGE 0x20 |
| 1010 | #define UTF8_CODE_BADSEQ 0x40 |
| 1011 | |
| 1012 | unsigned char utf8_next(const char *s, int len, unsigned int *c); |
| 1013 | |
| 1014 | static inline unsigned char utf8_return_code(unsigned int code) |
| 1015 | { |
| 1016 | return code & 0xf0; |
| 1017 | } |
| 1018 | |
| 1019 | static inline unsigned char utf8_return_length(unsigned char code) |
| 1020 | { |
| 1021 | return code & 0x0f; |
| 1022 | } |
| 1023 | |
Willy Tarreau | e6e49cf | 2015-04-29 17:13:35 +0200 | [diff] [blame] | 1024 | /* returns a 64-bit a timestamp with the finest resolution available. The |
| 1025 | * unit is intentionally not specified. It's mostly used to compare dates. |
| 1026 | */ |
| 1027 | #if defined(__i386__) || defined(__x86_64__) |
| 1028 | static inline unsigned long long rdtsc() |
| 1029 | { |
| 1030 | unsigned int a, d; |
| 1031 | asm volatile("rdtsc" : "=a" (a), "=d" (d)); |
| 1032 | return a + ((unsigned long long)d << 32); |
| 1033 | } |
| 1034 | #else |
| 1035 | static inline unsigned long long rdtsc() |
| 1036 | { |
| 1037 | struct timeval tv; |
| 1038 | gettimeofday(&tv, NULL); |
| 1039 | return tv.tv_sec * 1000000 + tv.tv_usec; |
| 1040 | } |
| 1041 | #endif |
| 1042 | |
Maxime de Roucy | dc88785 | 2016-05-13 23:52:54 +0200 | [diff] [blame] | 1043 | /* append a copy of string <str> (in a wordlist) at the end of the list <li> |
| 1044 | * On failure : return 0 and <err> filled with an error message. |
| 1045 | * The caller is responsible for freeing the <err> and <str> copy |
| 1046 | * memory area using free() |
| 1047 | */ |
| 1048 | struct list; |
| 1049 | int list_append_word(struct list *li, const char *str, char **err); |
| 1050 | |
Willy Tarreau | 83061a8 | 2018-07-13 11:56:34 +0200 | [diff] [blame] | 1051 | int dump_text(struct buffer *out, const char *buf, int bsize); |
| 1052 | int dump_binary(struct buffer *out, const char *buf, int bsize); |
| 1053 | int dump_text_line(struct buffer *out, const char *buf, int bsize, int len, |
Willy Tarreau | 97c2ae1 | 2016-11-22 18:00:20 +0100 | [diff] [blame] | 1054 | int *line, int ptr); |
Willy Tarreau | 762fb3e | 2020-03-03 15:57:10 +0100 | [diff] [blame] | 1055 | void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n); |
Willy Tarreau | 3710105 | 2019-05-20 16:48:20 +0200 | [diff] [blame] | 1056 | void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe); |
| 1057 | int may_access(const void *ptr); |
Willy Tarreau | eb8b1ca | 2020-03-03 17:09:08 +0100 | [diff] [blame] | 1058 | void *resolve_sym_name(struct buffer *buf, const char *pfx, void *addr); |
Willy Tarreau | bb86986 | 2020-04-16 10:52:41 +0200 | [diff] [blame] | 1059 | const char *get_exec_path(); |
Willy Tarreau | 97c2ae1 | 2016-11-22 18:00:20 +0100 | [diff] [blame] | 1060 | |
Willy Tarreau | 13faf16 | 2020-03-04 07:44:06 +0100 | [diff] [blame] | 1061 | #if defined(USE_BACKTRACE) |
| 1062 | /* Note that this may result in opening libgcc() on first call, so it may need |
| 1063 | * to have been called once before chrooting. |
| 1064 | */ |
| 1065 | static forceinline int my_backtrace(void **buffer, int max) |
| 1066 | { |
| 1067 | #ifdef HA_HAVE_WORKING_BACKTRACE |
| 1068 | return backtrace(buffer, max); |
| 1069 | #else |
| 1070 | const struct frame { |
| 1071 | const struct frame *next; |
| 1072 | void *ra; |
| 1073 | } *frame; |
| 1074 | int count; |
| 1075 | |
| 1076 | frame = __builtin_frame_address(0); |
| 1077 | for (count = 0; count < max && may_access(frame) && may_access(frame->ra);) { |
| 1078 | buffer[count++] = frame->ra; |
| 1079 | frame = frame->next; |
| 1080 | } |
| 1081 | return count; |
| 1082 | #endif |
| 1083 | } |
| 1084 | #endif |
| 1085 | |
Hubert Verstraete | 2eae3a0 | 2016-06-28 22:41:00 +0200 | [diff] [blame] | 1086 | /* same as realloc() except that ptr is also freed upon failure */ |
| 1087 | static inline void *my_realloc2(void *ptr, size_t size) |
| 1088 | { |
| 1089 | void *ret; |
| 1090 | |
| 1091 | ret = realloc(ptr, size); |
| 1092 | if (!ret && size) |
| 1093 | free(ptr); |
| 1094 | return ret; |
| 1095 | } |
| 1096 | |
Frédéric Lécaille | 3b71716 | 2019-02-25 15:04:22 +0100 | [diff] [blame] | 1097 | int parse_dotted_uints(const char *s, unsigned int **nums, size_t *sz); |
| 1098 | |
Willy Tarreau | 52bf839 | 2020-03-08 00:42:37 +0100 | [diff] [blame] | 1099 | /* PRNG */ |
Willy Tarreau | ee3bcdd | 2020-03-08 17:48:17 +0100 | [diff] [blame] | 1100 | void ha_generate_uuid(struct buffer *output); |
Willy Tarreau | 52bf839 | 2020-03-08 00:42:37 +0100 | [diff] [blame] | 1101 | void ha_random_seed(const unsigned char *seed, size_t len); |
| 1102 | void ha_random_jump96(uint32_t dist); |
| 1103 | uint64_t ha_random64(); |
| 1104 | |
| 1105 | static inline uint32_t ha_random32() |
| 1106 | { |
| 1107 | return ha_random64() >> 32; |
| 1108 | } |
| 1109 | |
| 1110 | static inline int32_t ha_random() |
| 1111 | { |
| 1112 | return ha_random32() >> 1; |
| 1113 | } |
| 1114 | |
Lukas Tribus | dcbc5c5 | 2016-09-12 21:42:07 +0000 | [diff] [blame] | 1115 | /* HAP_STRING() makes a string from a literal while HAP_XSTRING() first |
| 1116 | * evaluates the argument and is suited to pass macros. |
| 1117 | * |
| 1118 | * They allow macros like PCRE_MAJOR to be defined without quotes, which |
| 1119 | * is convenient for applications that want to test its value. |
| 1120 | */ |
| 1121 | #define HAP_STRING(...) #__VA_ARGS__ |
| 1122 | #define HAP_XSTRING(...) HAP_STRING(__VA_ARGS__) |
| 1123 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 1124 | #endif /* _COMMON_STANDARD_H */ |