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 | 167d8b5 | 2007-04-09 22:16:12 +0200 | [diff] [blame] | 25 | #include <limits.h> |
Willy Tarreau | 050737f | 2010-01-14 11:40:12 +0100 | [diff] [blame] | 26 | #include <string.h> |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 27 | #include <stdio.h> |
Willy Tarreau | fe94460 | 2007-10-25 10:34:16 +0200 | [diff] [blame] | 28 | #include <time.h> |
David Carlier | 5222d8e | 2017-11-03 12:00:26 +0000 | [diff] [blame^] | 29 | #include <stdarg.h> |
Willy Tarreau | e6e49cf | 2015-04-29 17:13:35 +0200 | [diff] [blame] | 30 | #include <sys/time.h> |
Willy Tarreau | 938b303 | 2007-05-10 06:39:03 +0200 | [diff] [blame] | 31 | #include <sys/types.h> |
Willy Tarreau | d50265a | 2012-09-04 14:18:33 +0200 | [diff] [blame] | 32 | #include <sys/socket.h> |
Willy Tarreau | dd2f85e | 2012-09-02 22:34:23 +0200 | [diff] [blame] | 33 | #include <sys/un.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 34 | #include <netinet/in.h> |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 35 | #include <arpa/inet.h> |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 36 | #include <common/chunk.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 37 | #include <common/config.h> |
Willy Tarreau | 16e0156 | 2016-08-09 16:46:18 +0200 | [diff] [blame] | 38 | #include <common/namespace.h> |
Willy Tarreau | 45cb4fb | 2009-10-26 21:10:04 +0100 | [diff] [blame] | 39 | #include <eb32tree.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 40 | |
William Lallemand | e7340ec | 2012-01-24 11:15:39 +0100 | [diff] [blame] | 41 | #ifndef LLONG_MAX |
| 42 | # define LLONG_MAX 9223372036854775807LL |
| 43 | # define LLONG_MIN (-LLONG_MAX - 1LL) |
| 44 | #endif |
| 45 | |
| 46 | #ifndef ULLONG_MAX |
| 47 | # define ULLONG_MAX (LLONG_MAX * 2ULL + 1) |
| 48 | #endif |
| 49 | |
Willy Tarreau | a9db57e | 2013-01-18 11:29:29 +0100 | [diff] [blame] | 50 | #ifndef LONGBITS |
| 51 | #define LONGBITS ((unsigned int)sizeof(long) * 8) |
| 52 | #endif |
| 53 | |
Thierry FOURNIER | 511e947 | 2014-01-23 17:40:34 +0100 | [diff] [blame] | 54 | /* size used for max length of decimal representation of long long int. */ |
| 55 | #define NB_LLMAX_STR (sizeof("-9223372036854775807")-1) |
| 56 | |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 57 | /* number of itoa_str entries */ |
| 58 | #define NB_ITOA_STR 10 |
William Lallemand | e7340ec | 2012-01-24 11:15:39 +0100 | [diff] [blame] | 59 | |
Willy Tarreau | 588297f | 2014-06-16 15:16:40 +0200 | [diff] [blame] | 60 | /* maximum quoted string length (truncated above) */ |
| 61 | #define QSTR_SIZE 200 |
| 62 | #define NB_QSTR 10 |
| 63 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 64 | /****** string-specific macros and functions ******/ |
| 65 | /* if a > max, then bound <a> to <max>. The macro returns the new <a> */ |
| 66 | #define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); }) |
| 67 | |
| 68 | /* if a < min, then bound <a> to <min>. The macro returns the new <a> */ |
| 69 | #define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); }) |
| 70 | |
| 71 | /* returns 1 only if only zero or one bit is set in X, which means that X is a |
| 72 | * power of 2, and 0 otherwise */ |
| 73 | #define POWEROF2(x) (((x) & ((x)-1)) == 0) |
| 74 | |
Willy Tarreau | 5b18020 | 2010-07-18 10:40:48 +0200 | [diff] [blame] | 75 | /* operators to compare values. They're ordered that way so that the lowest bit |
| 76 | * serves as a negation for the test and contains all tests that are not equal. |
| 77 | */ |
| 78 | enum { |
| 79 | STD_OP_LE = 0, STD_OP_GT = 1, |
| 80 | STD_OP_EQ = 2, STD_OP_NE = 3, |
| 81 | STD_OP_GE = 4, STD_OP_LT = 5, |
| 82 | }; |
| 83 | |
Thierry FOURNIER | 9f95e40 | 2014-03-21 14:51:46 +0100 | [diff] [blame] | 84 | enum http_scheme { |
| 85 | SCH_HTTP, |
| 86 | SCH_HTTPS, |
| 87 | }; |
| 88 | |
| 89 | struct split_url { |
| 90 | enum http_scheme scheme; |
| 91 | const char *host; |
| 92 | int host_len; |
| 93 | }; |
| 94 | |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 95 | extern int itoa_idx; /* index of next itoa_str to use */ |
| 96 | |
Willy Tarreau | 7d58a63 | 2007-01-13 23:06:06 +0100 | [diff] [blame] | 97 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 98 | * copies at most <size-1> chars from <src> to <dst>. Last char is always |
| 99 | * set to 0, unless <size> is 0. The number of chars copied is returned |
| 100 | * (excluding the terminating zero). |
| 101 | * This code has been optimized for size and speed : on x86, it's 45 bytes |
| 102 | * long, uses only registers, and consumes only 4 cycles per char. |
| 103 | */ |
| 104 | extern int strlcpy2(char *dst, const char *src, int size); |
| 105 | |
| 106 | /* |
Willy Tarreau | 72d759c | 2007-10-25 12:14:10 +0200 | [diff] [blame] | 107 | * This function simply returns a locally allocated string containing |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 108 | * the ascii representation for number 'n' in decimal. |
| 109 | */ |
Willy Tarreau | e7239b5 | 2009-03-29 13:41:58 +0200 | [diff] [blame] | 110 | extern char itoa_str[][171]; |
Emeric Brun | 3a7fce5 | 2010-01-04 14:54:38 +0100 | [diff] [blame] | 111 | extern char *ultoa_r(unsigned long n, char *buffer, int size); |
Thierry FOURNIER | 763a5d8 | 2015-07-06 23:09:52 +0200 | [diff] [blame] | 112 | extern char *lltoa_r(long long int n, char *buffer, int size); |
Thierry FOURNIER | 1480bd8 | 2015-06-06 19:14:59 +0200 | [diff] [blame] | 113 | extern char *sltoa_r(long n, char *buffer, int size); |
Willy Tarreau | e7239b5 | 2009-03-29 13:41:58 +0200 | [diff] [blame] | 114 | 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] | 115 | static inline const char *ultoa(unsigned long n) |
| 116 | { |
| 117 | return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0])); |
| 118 | } |
| 119 | |
William Lallemand | e7340ec | 2012-01-24 11:15:39 +0100 | [diff] [blame] | 120 | /* |
| 121 | * unsigned long long ASCII representation |
| 122 | * |
| 123 | * return the last char '\0' or NULL if no enough |
| 124 | * space in dst |
| 125 | */ |
| 126 | char *ulltoa(unsigned long long n, char *dst, size_t size); |
| 127 | |
| 128 | |
| 129 | /* |
| 130 | * unsigned long ASCII representation |
| 131 | * |
| 132 | * return the last char '\0' or NULL if no enough |
| 133 | * space in dst |
| 134 | */ |
| 135 | char *ultoa_o(unsigned long n, char *dst, size_t size); |
| 136 | |
| 137 | /* |
| 138 | * signed long ASCII representation |
| 139 | * |
| 140 | * return the last char '\0' or NULL if no enough |
| 141 | * space in dst |
| 142 | */ |
| 143 | char *ltoa_o(long int n, char *dst, size_t size); |
| 144 | |
| 145 | /* |
| 146 | * signed long long ASCII representation |
| 147 | * |
| 148 | * return the last char '\0' or NULL if no enough |
| 149 | * space in dst |
| 150 | */ |
| 151 | char *lltoa(long long n, char *dst, size_t size); |
| 152 | |
| 153 | /* |
| 154 | * write a ascii representation of a unsigned into dst, |
| 155 | * return a pointer to the last character |
| 156 | * Pad the ascii representation with '0', using size. |
| 157 | */ |
| 158 | char *utoa_pad(unsigned int n, char *dst, size_t size); |
| 159 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 160 | /* |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 161 | * This function simply returns a locally allocated string containing the ascii |
| 162 | * representation for number 'n' in decimal, unless n is 0 in which case it |
| 163 | * returns the alternate string (or an empty string if the alternate string is |
| 164 | * NULL). It use is intended for limits reported in reports, where it's |
| 165 | * desirable not to display anything if there is no limit. Warning! it shares |
| 166 | * the same vector as ultoa_r(). |
| 167 | */ |
| 168 | extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt); |
| 169 | |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 170 | /* returns a locally allocated string containing the ASCII representation of |
| 171 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 172 | * function call (eg: printf), shared with the other similar functions making |
| 173 | * use of itoa_str[]. |
| 174 | */ |
| 175 | static inline const char *U2A(unsigned long n) |
| 176 | { |
| 177 | const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0])); |
| 178 | if (++itoa_idx >= NB_ITOA_STR) |
| 179 | itoa_idx = 0; |
| 180 | return ret; |
| 181 | } |
| 182 | |
| 183 | /* returns a locally allocated string containing the HTML representation of |
| 184 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 185 | * function call (eg: printf), shared with the other similar functions making |
| 186 | * use of itoa_str[]. |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 187 | */ |
Willy Tarreau | 56adcf2 | 2012-12-23 18:00:29 +0100 | [diff] [blame] | 188 | static inline const char *U2H(unsigned long long n) |
| 189 | { |
| 190 | const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0])); |
| 191 | if (++itoa_idx >= NB_ITOA_STR) |
| 192 | itoa_idx = 0; |
| 193 | return ret; |
| 194 | } |
| 195 | |
| 196 | /* returns a locally allocated string containing the HTML representation of |
| 197 | * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same |
| 198 | * function call (eg: printf), shared with the other similar functions making |
| 199 | * use of itoa_str[]. |
| 200 | */ |
| 201 | static inline const char *LIM2A(unsigned long n, const char *alt) |
| 202 | { |
| 203 | const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt); |
| 204 | if (++itoa_idx >= NB_ITOA_STR) |
| 205 | itoa_idx = 0; |
| 206 | return ret; |
| 207 | } |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 208 | |
Thierry FOURNIER | 6ab2bae | 2017-04-19 11:49:44 +0200 | [diff] [blame] | 209 | /* Encode the integer <i> into a varint (variable-length integer). The encoded |
| 210 | * value is copied in <*buf>. Here is the encoding format: |
| 211 | * |
| 212 | * 0 <= X < 240 : 1 byte (7.875 bits) [ XXXX XXXX ] |
| 213 | * 240 <= X < 2288 : 2 bytes (11 bits) [ 1111 XXXX ] [ 0XXX XXXX ] |
| 214 | * 2288 <= X < 264432 : 3 bytes (18 bits) [ 1111 XXXX ] [ 1XXX XXXX ] [ 0XXX XXXX ] |
| 215 | * 264432 <= X < 33818864 : 4 bytes (25 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*2 [ 0XXX XXXX ] |
| 216 | * 33818864 <= X < 4328786160 : 5 bytes (32 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*3 [ 0XXX XXXX ] |
| 217 | * ... |
| 218 | * |
| 219 | * On success, it returns the number of written bytes and <*buf> is moved after |
| 220 | * the encoded value. Otherwise, it returns -1. */ |
| 221 | static inline int |
| 222 | encode_varint(uint64_t i, char **buf, char *end) |
| 223 | { |
| 224 | unsigned char *p = (unsigned char *)*buf; |
| 225 | int r; |
| 226 | |
| 227 | if (p >= (unsigned char *)end) |
| 228 | return -1; |
| 229 | |
| 230 | if (i < 240) { |
| 231 | *p++ = i; |
| 232 | *buf = (char *)p; |
| 233 | return 1; |
| 234 | } |
| 235 | |
| 236 | *p++ = (unsigned char)i | 240; |
| 237 | i = (i - 240) >> 4; |
| 238 | while (i >= 128) { |
| 239 | if (p >= (unsigned char *)end) |
| 240 | return -1; |
| 241 | *p++ = (unsigned char)i | 128; |
| 242 | i = (i - 128) >> 7; |
| 243 | } |
| 244 | |
| 245 | if (p >= (unsigned char *)end) |
| 246 | return -1; |
| 247 | *p++ = (unsigned char)i; |
| 248 | |
| 249 | r = ((char *)p - *buf); |
| 250 | *buf = (char *)p; |
| 251 | return r; |
| 252 | } |
| 253 | |
| 254 | /* Decode a varint from <*buf> and save the decoded value in <*i>. See |
| 255 | * 'spoe_encode_varint' for details about varint. |
| 256 | * On success, it returns the number of read bytes and <*buf> is moved after the |
| 257 | * varint. Otherwise, it returns -1. */ |
| 258 | static inline int |
| 259 | decode_varint(char **buf, char *end, uint64_t *i) |
| 260 | { |
| 261 | unsigned char *p = (unsigned char *)*buf; |
| 262 | int r; |
| 263 | |
| 264 | if (p >= (unsigned char *)end) |
| 265 | return -1; |
| 266 | |
| 267 | *i = *p++; |
| 268 | if (*i < 240) { |
| 269 | *buf = (char *)p; |
| 270 | return 1; |
| 271 | } |
| 272 | |
| 273 | r = 4; |
| 274 | do { |
| 275 | if (p >= (unsigned char *)end) |
| 276 | return -1; |
| 277 | *i += (uint64_t)*p << r; |
| 278 | r += 7; |
| 279 | } while (*p++ >= 128); |
| 280 | |
| 281 | r = ((char *)p - *buf); |
| 282 | *buf = (char *)p; |
| 283 | return r; |
| 284 | } |
| 285 | |
Willy Tarreau | 588297f | 2014-06-16 15:16:40 +0200 | [diff] [blame] | 286 | /* returns a locally allocated string containing the quoted encoding of the |
| 287 | * input string. The output may be truncated to QSTR_SIZE chars, but it is |
| 288 | * guaranteed that the string will always be properly terminated. Quotes are |
| 289 | * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must |
| 290 | * always be at least 4 chars. |
| 291 | */ |
| 292 | const char *qstr(const char *str); |
| 293 | |
| 294 | /* returns <str> or its quote-encoded equivalent if it contains at least one |
| 295 | * quote or a comma. This is aimed at build CSV-compatible strings. |
| 296 | */ |
| 297 | static inline const char *cstr(const char *str) |
| 298 | { |
| 299 | const char *p = str; |
| 300 | |
| 301 | while (*p) { |
| 302 | if (*p == ',' || *p == '"') |
| 303 | return qstr(str); |
| 304 | p++; |
| 305 | } |
| 306 | return str; |
| 307 | } |
| 308 | |
Willy Tarreau | 91092e5 | 2007-10-25 16:58:42 +0200 | [diff] [blame] | 309 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 310 | * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero. |
| 311 | */ |
| 312 | extern int ishex(char s); |
| 313 | |
| 314 | /* |
Willy Tarreau | da3b7c3 | 2009-11-02 20:12:52 +0100 | [diff] [blame] | 315 | * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F), |
Willy Tarreau | 3dd0c4e | 2012-10-26 00:58:22 +0200 | [diff] [blame] | 316 | * otherwise -1. This compact form helps gcc produce efficient code. |
Willy Tarreau | da3b7c3 | 2009-11-02 20:12:52 +0100 | [diff] [blame] | 317 | */ |
Willy Tarreau | 3dd0c4e | 2012-10-26 00:58:22 +0200 | [diff] [blame] | 318 | static inline int hex2i(int c) |
| 319 | { |
Willy Tarreau | 0161d62 | 2013-04-02 01:26:55 +0200 | [diff] [blame] | 320 | if (unlikely((unsigned char)(c -= '0') > 9)) { |
| 321 | if (likely((unsigned char)(c -= 'A' - '0') > 5 && |
| 322 | (unsigned char)(c -= 'a' - 'A') > 5)) |
Willy Tarreau | 3dd0c4e | 2012-10-26 00:58:22 +0200 | [diff] [blame] | 323 | c = -11; |
| 324 | c += 10; |
| 325 | } |
| 326 | return c; |
| 327 | } |
| 328 | |
Willy Tarreau | 3ca1a88 | 2015-01-15 18:43:49 +0100 | [diff] [blame] | 329 | /* rounds <i> down to the closest value having max 2 digits */ |
| 330 | unsigned int round_2dig(unsigned int i); |
Willy Tarreau | da3b7c3 | 2009-11-02 20:12:52 +0100 | [diff] [blame] | 331 | |
| 332 | /* |
Willy Tarreau | 2e74c3f | 2007-12-02 18:45:09 +0100 | [diff] [blame] | 333 | * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an |
| 334 | * invalid character is found, a pointer to it is returned. If everything is |
| 335 | * fine, NULL is returned. |
| 336 | */ |
| 337 | extern const char *invalid_char(const char *name); |
| 338 | |
| 339 | /* |
Frédéric Lécaille | b82f742 | 2017-04-13 18:24:23 +0200 | [diff] [blame] | 340 | * 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] | 341 | * If an invalid character is found, a pointer to it is returned. |
| 342 | * If everything is fine, NULL is returned. |
| 343 | */ |
| 344 | extern const char *invalid_domainchar(const char *name); |
| 345 | |
| 346 | /* |
Frédéric Lécaille | b82f742 | 2017-04-13 18:24:23 +0200 | [diff] [blame] | 347 | * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-]. |
| 348 | * If an invalid character is found, a pointer to it is returned. |
| 349 | * If everything is fine, NULL is returned. |
| 350 | */ |
| 351 | extern const char *invalid_prefix_char(const char *name); |
| 352 | |
| 353 | /* |
Willy Tarreau | fab5a43 | 2011-03-04 15:31:53 +0100 | [diff] [blame] | 354 | * converts <str> to a locally allocated struct sockaddr_storage *, and a |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 355 | * port range consisting in two integers. The low and high end are always set |
| 356 | * 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] | 357 | * 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] | 358 | * 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] | 359 | * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6 |
| 360 | * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6 |
| 361 | * address wants to ignore port, it must be terminated by a trailing colon (':'). |
| 362 | * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on |
| 363 | * 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] | 364 | * 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] | 365 | * address (typically the path to a unix socket). If use_dns is not true, |
| 366 | * the funtion cannot accept the DNS resolution. |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 367 | */ |
Willy Tarreau | 48ef4c9 | 2017-01-06 18:32:38 +0100 | [diff] [blame] | 368 | struct sockaddr_storage *str2sa_range(const char *str, |
| 369 | int *port, int *low, int *high, |
| 370 | char **err, const char *pfx, |
| 371 | char **fqdn, int resolve); |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 372 | |
Willy Tarreau | 2937c0d | 2010-01-26 17:36:17 +0100 | [diff] [blame] | 373 | /* converts <str> to a struct in_addr containing a network mask. It can be |
| 374 | * 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] | 375 | * if the conversion succeeds otherwise zero. |
Willy Tarreau | 2937c0d | 2010-01-26 17:36:17 +0100 | [diff] [blame] | 376 | */ |
| 377 | int str2mask(const char *str, struct in_addr *mask); |
| 378 | |
Thierry FOURNIER | b050463 | 2013-12-14 15:39:02 +0100 | [diff] [blame] | 379 | /* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion |
| 380 | * succeeds otherwise non-zero. |
| 381 | */ |
| 382 | int cidr2dotted(int cidr, struct in_addr *mask); |
| 383 | |
Willy Tarreau | c6f4ce8 | 2009-06-10 11:09:37 +0200 | [diff] [blame] | 384 | /* |
Willy Tarreau | d077a8e | 2007-05-08 18:28:09 +0200 | [diff] [blame] | 385 | * converts <str> to two struct in_addr* which must be pre-allocated. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 386 | * The format is "addr[/mask]", where "addr" cannot be empty, and mask |
| 387 | * is optionnal and either in the dotted or CIDR notation. |
| 388 | * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error. |
| 389 | */ |
Thierry FOURNIER | fc7ac7b | 2014-02-11 15:23:04 +0100 | [diff] [blame] | 390 | 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] | 391 | |
Thierry FOURNIER | 58639a0 | 2014-11-25 12:02:25 +0100 | [diff] [blame] | 392 | /* str2ip and str2ip2: |
| 393 | * |
| 394 | * converts <str> to a struct sockaddr_storage* provided by the caller. The |
| 395 | * caller must have zeroed <sa> first, and may have set sa->ss_family to force |
| 396 | * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then |
| 397 | * the function tries to guess the address family from the syntax. If the |
| 398 | * family is forced and the format doesn't match, an error is returned. The |
| 399 | * string is assumed to contain only an address, no port. The address can be a |
| 400 | * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to |
| 401 | * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved. |
| 402 | * The return address will only have the address family and the address set, |
| 403 | * all other fields remain zero. The string is not supposed to be modified. |
| 404 | * The IPv6 '::' address is IN6ADDR_ANY. |
| 405 | * |
| 406 | * str2ip2: |
| 407 | * |
| 408 | * If <resolve> is set, this function try to resolve DNS, otherwise, it returns |
| 409 | * NULL result. |
| 410 | */ |
| 411 | struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve); |
| 412 | static inline struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa) |
| 413 | { |
| 414 | return str2ip2(str, sa, 1); |
| 415 | } |
| 416 | |
Alexandre Cassen | 5eb1a90 | 2007-11-29 15:43:32 +0100 | [diff] [blame] | 417 | /* |
Willy Tarreau | 6d20e28 | 2012-04-27 22:49:47 +0200 | [diff] [blame] | 418 | * converts <str> to two struct in6_addr* which must be pre-allocated. |
| 419 | * The format is "addr[/mask]", where "addr" cannot be empty, and mask |
| 420 | * is an optionnal number of bits (128 being the default). |
| 421 | * Returns 1 if OK, 0 if error. |
| 422 | */ |
| 423 | int str62net(const char *str, struct in6_addr *addr, unsigned char *mask); |
| 424 | |
| 425 | /* |
Willy Tarreau | 106f979 | 2009-09-19 07:54:16 +0200 | [diff] [blame] | 426 | * Parse IP address found in url. |
| 427 | */ |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 428 | int url2ipv4(const char *addr, struct in_addr *dst); |
Willy Tarreau | 106f979 | 2009-09-19 07:54:16 +0200 | [diff] [blame] | 429 | |
| 430 | /* |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 431 | * Resolve destination server from URL. Convert <str> to a sockaddr_storage*. |
Alexandre Cassen | 5eb1a90 | 2007-11-29 15:43:32 +0100 | [diff] [blame] | 432 | */ |
Thierry FOURNIER | 9f95e40 | 2014-03-21 14:51:46 +0100 | [diff] [blame] | 433 | 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] | 434 | |
Willy Tarreau | 631f01c | 2011-09-05 00:36:48 +0200 | [diff] [blame] | 435 | /* Tries to convert a sockaddr_storage address to text form. Upon success, the |
| 436 | * address family is returned so that it's easy for the caller to adapt to the |
| 437 | * output format. Zero is returned if the address family is not supported. -1 |
| 438 | * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are |
| 439 | * supported. |
| 440 | */ |
| 441 | int addr_to_str(struct sockaddr_storage *addr, char *str, int size); |
| 442 | |
Simon Horman | 75ab8bd | 2014-06-16 09:39:41 +0900 | [diff] [blame] | 443 | /* Tries to convert a sockaddr_storage port to text form. Upon success, the |
| 444 | * address family is returned so that it's easy for the caller to adapt to the |
| 445 | * output format. Zero is returned if the address family is not supported. -1 |
| 446 | * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are |
| 447 | * supported. |
| 448 | */ |
| 449 | int port_to_str(struct sockaddr_storage *addr, char *str, int size); |
| 450 | |
Willy Tarreau | 16e0156 | 2016-08-09 16:46:18 +0200 | [diff] [blame] | 451 | /* check if the given address is local to the system or not. It will return |
| 452 | * -1 when it's not possible to know, 0 when the address is not local, 1 when |
| 453 | * it is. We don't want to iterate over all interfaces for this (and it is not |
| 454 | * portable). So instead we try to bind in UDP to this address on a free non |
| 455 | * privileged port and to connect to the same address, port 0 (connect doesn't |
| 456 | * care). If it succeeds, we own the address. Note that non-inet addresses are |
| 457 | * considered local since they're most likely AF_UNIX. |
| 458 | */ |
| 459 | int addr_is_local(const struct netns_entry *ns, |
| 460 | const struct sockaddr_storage *orig); |
| 461 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 462 | /* will try to encode the string <string> replacing all characters tagged in |
| 463 | * <map> with the hexadecimal representation of their ASCII-code (2 digits) |
| 464 | * prefixed by <escape>, and will store the result between <start> (included) |
| 465 | * and <stop> (excluded), and will always terminate the string with a '\0' |
| 466 | * before <stop>. The position of the '\0' is returned if the conversion |
| 467 | * completes. If bytes are missing between <start> and <stop>, then the |
| 468 | * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0' |
| 469 | * cannot even be stored so we return <start> without writing the 0. |
| 470 | * The input string must also be zero-terminated. |
| 471 | */ |
| 472 | extern const char hextab[]; |
| 473 | char *encode_string(char *start, char *stop, |
| 474 | const char escape, const fd_set *map, |
| 475 | const char *string); |
| 476 | |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 477 | /* |
| 478 | * Same behavior, except that it encodes chunk <chunk> instead of a string. |
| 479 | */ |
| 480 | char *encode_chunk(char *start, char *stop, |
| 481 | const char escape, const fd_set *map, |
| 482 | const struct chunk *chunk); |
| 483 | |
Dragan Dosen | 0edd109 | 2016-02-12 13:23:02 +0100 | [diff] [blame] | 484 | /* |
| 485 | * Tries to prefix characters tagged in the <map> with the <escape> |
Dragan Dosen | 1a5d060 | 2016-07-22 16:00:31 +0200 | [diff] [blame] | 486 | * character. The input <string> must be zero-terminated. The result will |
| 487 | * be stored between <start> (included) and <stop> (excluded). This |
| 488 | * function will always try to terminate the resulting string with a '\0' |
| 489 | * before <stop>, and will return its position if the conversion |
| 490 | * completes. |
| 491 | */ |
| 492 | char *escape_string(char *start, char *stop, |
| 493 | const char escape, const fd_set *map, |
| 494 | const char *string); |
| 495 | |
| 496 | /* |
| 497 | * Tries to prefix characters tagged in the <map> with the <escape> |
Dragan Dosen | 0edd109 | 2016-02-12 13:23:02 +0100 | [diff] [blame] | 498 | * character. <chunk> contains the input to be escaped. The result will be |
| 499 | * stored between <start> (included) and <stop> (excluded). The function |
| 500 | * will always try to terminate the resulting string with a '\0' before |
| 501 | * <stop>, and will return its position if the conversion completes. |
| 502 | */ |
| 503 | char *escape_chunk(char *start, char *stop, |
| 504 | const char escape, const fd_set *map, |
| 505 | const struct chunk *chunk); |
| 506 | |
Thierry FOURNIER | e059ec9 | 2014-03-17 12:01:13 +0100 | [diff] [blame] | 507 | |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 508 | /* Check a string for using it in a CSV output format. If the string contains |
| 509 | * one of the following four char <">, <,>, CR or LF, the string is |
| 510 | * encapsulated between <"> and the <"> are escaped by a <""> sequence. |
| 511 | * <str> is the input string to be escaped. The function assumes that |
| 512 | * the input string is null-terminated. |
| 513 | * |
| 514 | * 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] | 515 | * 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] | 516 | * format. |
| 517 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 518 | * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash)); |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 519 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 520 | * If <quote> is 1, the converter puts the quotes only if any character is |
| 521 | * escaped. If <quote> is 2, the converter always puts the quotes. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 522 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 523 | * <output> is a struct chunk used for storing the output string. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 524 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 525 | * The function returns the converted string on its output. If an error |
| 526 | * 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] | 527 | * for using the function directly as printf() argument. |
| 528 | * |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 529 | * 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] | 530 | * is truncated. |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 531 | * |
| 532 | * This function appends the encoding to the existing output chunk. Please |
| 533 | * use csv_enc() instead if you want to replace the output chunk. |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 534 | */ |
Willy Tarreau | 898529b | 2016-01-06 18:07:04 +0100 | [diff] [blame] | 535 | const char *csv_enc_append(const char *str, int quote, struct chunk *output); |
| 536 | |
| 537 | /* same as above but the output chunk is reset first */ |
| 538 | static inline const char *csv_enc(const char *str, int quote, struct chunk *output) |
| 539 | { |
| 540 | chunk_reset(output); |
| 541 | return csv_enc_append(str, quote, output); |
| 542 | } |
Thierry FOURNIER | ddea626 | 2015-05-28 16:00:28 +0200 | [diff] [blame] | 543 | |
Willy Tarreau | bf9c2fc | 2011-05-31 18:06:18 +0200 | [diff] [blame] | 544 | /* Decode an URL-encoded string in-place. The resulting string might |
| 545 | * be shorter. If some forbidden characters are found, the conversion is |
| 546 | * aborted, the string is truncated before the issue and non-zero is returned, |
| 547 | * otherwise the operation returns non-zero indicating success. |
| 548 | */ |
| 549 | int url_decode(char *string); |
| 550 | |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 551 | /* This one is 6 times faster than strtoul() on athlon, but does |
| 552 | * no check at all. |
| 553 | */ |
| 554 | static inline unsigned int __str2ui(const char *s) |
| 555 | { |
| 556 | unsigned int i = 0; |
| 557 | while (*s) { |
| 558 | i = i * 10 - '0'; |
| 559 | i += (unsigned char)*s++; |
| 560 | } |
| 561 | return i; |
| 562 | } |
| 563 | |
| 564 | /* This one is 5 times faster than strtoul() on athlon with checks. |
| 565 | * It returns the value of the number composed of all valid digits read. |
| 566 | */ |
| 567 | static inline unsigned int __str2uic(const char *s) |
| 568 | { |
| 569 | unsigned int i = 0; |
| 570 | unsigned int j; |
| 571 | while (1) { |
| 572 | j = (*s++) - '0'; |
| 573 | if (j > 9) |
| 574 | break; |
| 575 | i *= 10; |
| 576 | i += j; |
| 577 | } |
| 578 | return i; |
| 579 | } |
| 580 | |
| 581 | /* This one is 28 times faster than strtoul() on athlon, but does |
| 582 | * no check at all! |
| 583 | */ |
| 584 | static inline unsigned int __strl2ui(const char *s, int len) |
| 585 | { |
| 586 | unsigned int i = 0; |
| 587 | while (len-- > 0) { |
| 588 | i = i * 10 - '0'; |
| 589 | i += (unsigned char)*s++; |
| 590 | } |
| 591 | return i; |
| 592 | } |
| 593 | |
| 594 | /* This one is 7 times faster than strtoul() on athlon with checks. |
| 595 | * It returns the value of the number composed of all valid digits read. |
| 596 | */ |
| 597 | static inline unsigned int __strl2uic(const char *s, int len) |
| 598 | { |
| 599 | unsigned int i = 0; |
Willy Tarreau | 3f0c976 | 2007-10-25 09:42:24 +0200 | [diff] [blame] | 600 | unsigned int j, k; |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 601 | |
| 602 | while (len-- > 0) { |
| 603 | j = (*s++) - '0'; |
Willy Tarreau | 3f0c976 | 2007-10-25 09:42:24 +0200 | [diff] [blame] | 604 | k = i * 10; |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 605 | if (j > 9) |
| 606 | break; |
Willy Tarreau | 3f0c976 | 2007-10-25 09:42:24 +0200 | [diff] [blame] | 607 | i = k + j; |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 608 | } |
| 609 | return i; |
| 610 | } |
| 611 | |
Willy Tarreau | 4ec83cd | 2010-10-15 23:19:55 +0200 | [diff] [blame] | 612 | /* This function reads an unsigned integer from the string pointed to by <s> |
| 613 | * and returns it. The <s> pointer is adjusted to point to the first unread |
| 614 | * char. The function automatically stops at <end>. |
| 615 | */ |
| 616 | static inline unsigned int __read_uint(const char **s, const char *end) |
| 617 | { |
| 618 | const char *ptr = *s; |
| 619 | unsigned int i = 0; |
| 620 | unsigned int j, k; |
| 621 | |
| 622 | while (ptr < end) { |
| 623 | j = *ptr - '0'; |
| 624 | k = i * 10; |
| 625 | if (j > 9) |
| 626 | break; |
| 627 | i = k + j; |
| 628 | ptr++; |
| 629 | } |
| 630 | *s = ptr; |
| 631 | return i; |
| 632 | } |
| 633 | |
Thierry FOURNIER | 763a5d8 | 2015-07-06 23:09:52 +0200 | [diff] [blame] | 634 | unsigned long long int read_uint64(const char **s, const char *end); |
| 635 | long long int read_int64(const char **s, const char *end); |
| 636 | |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 637 | extern unsigned int str2ui(const char *s); |
| 638 | extern unsigned int str2uic(const char *s); |
| 639 | extern unsigned int strl2ui(const char *s, int len); |
| 640 | extern unsigned int strl2uic(const char *s, int len); |
| 641 | extern int strl2ic(const char *s, int len); |
| 642 | extern int strl2irc(const char *s, int len, int *ret); |
| 643 | extern int strl2llrc(const char *s, int len, long long *ret); |
Thierry FOURNIER | 511e947 | 2014-01-23 17:40:34 +0100 | [diff] [blame] | 644 | extern int strl2llrc_dotted(const char *text, int len, long long *ret); |
Willy Tarreau | 4ec83cd | 2010-10-15 23:19:55 +0200 | [diff] [blame] | 645 | extern unsigned int read_uint(const char **s, const char *end); |
Willy Tarreau | d54bbdc | 2009-09-07 11:00:31 +0200 | [diff] [blame] | 646 | unsigned int inetaddr_host(const char *text); |
| 647 | unsigned int inetaddr_host_lim(const char *text, const char *stop); |
Willy Tarreau | 7417275 | 2010-10-15 23:21:42 +0200 | [diff] [blame] | 648 | unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret); |
Willy Tarreau | 6911fa4 | 2007-03-04 18:06:08 +0100 | [diff] [blame] | 649 | |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 650 | static inline char *cut_crlf(char *s) { |
| 651 | |
Simon Horman | 5269cfb | 2013-02-13 17:48:00 +0900 | [diff] [blame] | 652 | while (*s != '\r' && *s != '\n') { |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 653 | char *p = s++; |
| 654 | |
| 655 | if (!*p) |
| 656 | return p; |
| 657 | } |
| 658 | |
Simon Horman | 5269cfb | 2013-02-13 17:48:00 +0900 | [diff] [blame] | 659 | *s++ = '\0'; |
Krzysztof Piotr Oledzki | 3d5562b | 2009-10-10 20:11:17 +0200 | [diff] [blame] | 660 | |
| 661 | return s; |
| 662 | } |
| 663 | |
| 664 | static inline char *ltrim(char *s, char c) { |
| 665 | |
| 666 | if (c) |
| 667 | while (*s == c) |
| 668 | s++; |
| 669 | |
| 670 | return s; |
| 671 | } |
| 672 | |
| 673 | static inline char *rtrim(char *s, char c) { |
| 674 | |
| 675 | char *p = s + strlen(s); |
| 676 | |
| 677 | while (p-- > s) |
| 678 | if (*p == c) |
| 679 | *p = '\0'; |
| 680 | else |
| 681 | break; |
| 682 | |
| 683 | return s; |
| 684 | } |
| 685 | |
| 686 | static inline char *alltrim(char *s, char c) { |
| 687 | |
| 688 | rtrim(s, c); |
| 689 | |
| 690 | return ltrim(s, c); |
| 691 | } |
| 692 | |
Willy Tarreau | fe94460 | 2007-10-25 10:34:16 +0200 | [diff] [blame] | 693 | /* This function converts the time_t value <now> into a broken out struct tm |
| 694 | * which must be allocated by the caller. It is highly recommended to use this |
| 695 | * function intead of localtime() because that one requires a time_t* which |
| 696 | * is not always compatible with tv_sec depending on OS/hardware combinations. |
| 697 | */ |
| 698 | static inline void get_localtime(const time_t now, struct tm *tm) |
| 699 | { |
| 700 | localtime_r(&now, tm); |
| 701 | } |
| 702 | |
Emeric Brun | 3a058f3 | 2009-06-30 18:26:00 +0200 | [diff] [blame] | 703 | /* This function converts the time_t value <now> into a broken out struct tm |
| 704 | * which must be allocated by the caller. It is highly recommended to use this |
| 705 | * function intead of gmtime() because that one requires a time_t* which |
| 706 | * is not always compatible with tv_sec depending on OS/hardware combinations. |
| 707 | */ |
| 708 | static inline void get_gmtime(const time_t now, struct tm *tm) |
| 709 | { |
| 710 | gmtime_r(&now, tm); |
| 711 | } |
| 712 | |
Willy Tarreau | cb1949b | 2017-07-19 19:05:29 +0200 | [diff] [blame] | 713 | /* Counts a number of elapsed days since 01/01/0000 based solely on elapsed |
| 714 | * years and assuming the regular rule for leap years applies. It's fake but |
| 715 | * serves as a temporary origin. It's worth remembering that it's the first |
| 716 | * year of each period that is leap and not the last one, so for instance year |
| 717 | * 1 sees 366 days since year 0 was leap. For this reason we have to apply |
| 718 | * modular arithmetics which is why we offset the year by 399 before |
| 719 | * subtracting the excess at the end. No overflow here before ~11.7 million |
| 720 | * years. |
| 721 | */ |
| 722 | static inline unsigned int days_since_zero(unsigned int y) |
| 723 | { |
| 724 | return y * 365 + (y + 399) / 4 - (y + 399) / 100 + (y + 399) / 400 |
| 725 | - 399 / 4 + 399 / 100; |
| 726 | } |
| 727 | |
| 728 | /* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>. |
| 729 | * It is meant as a portable replacement for timegm() for use with valid inputs. |
| 730 | * Returns undefined results for invalid dates (eg: months out of range 0..11). |
| 731 | */ |
| 732 | extern time_t my_timegm(const struct tm *tm); |
| 733 | |
Willy Tarreau | a0d37b6 | 2007-12-02 22:00:35 +0100 | [diff] [blame] | 734 | /* This function parses a time value optionally followed by a unit suffix among |
| 735 | * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit |
| 736 | * expected by the caller. The computation does its best to avoid overflows. |
| 737 | * The value is returned in <ret> if everything is fine, and a NULL is returned |
| 738 | * by the function. In case of error, a pointer to the error is returned and |
| 739 | * <ret> is left untouched. |
| 740 | */ |
| 741 | 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] | 742 | extern const char *parse_size_err(const char *text, unsigned *ret); |
Willy Tarreau | a0d37b6 | 2007-12-02 22:00:35 +0100 | [diff] [blame] | 743 | |
| 744 | /* unit flags to pass to parse_time_err */ |
| 745 | #define TIME_UNIT_US 0x0000 |
| 746 | #define TIME_UNIT_MS 0x0001 |
| 747 | #define TIME_UNIT_S 0x0002 |
| 748 | #define TIME_UNIT_MIN 0x0003 |
| 749 | #define TIME_UNIT_HOUR 0x0004 |
| 750 | #define TIME_UNIT_DAY 0x0005 |
| 751 | #define TIME_UNIT_MASK 0x0007 |
| 752 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 753 | #define SEC 1 |
| 754 | #define MINUTE (60 * SEC) |
| 755 | #define HOUR (60 * MINUTE) |
| 756 | #define DAY (24 * HOUR) |
| 757 | |
Willy Tarreau | 7f062c4 | 2009-03-05 18:43:00 +0100 | [diff] [blame] | 758 | /* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits. |
| 759 | * This is used to compute fixed ratios by setting one of the operands to |
| 760 | * (2^32*ratio). |
| 761 | */ |
| 762 | static inline unsigned int mul32hi(unsigned int a, unsigned int b) |
| 763 | { |
| 764 | return ((unsigned long long)a * b) >> 32; |
| 765 | } |
| 766 | |
Willy Tarreau | f0d9eec | 2010-06-20 07:12:37 +0200 | [diff] [blame] | 767 | /* gcc does not know when it can safely divide 64 bits by 32 bits. Use this |
| 768 | * function when you know for sure that the result fits in 32 bits, because |
| 769 | * it is optimal on x86 and on 64bit processors. |
| 770 | */ |
| 771 | static inline unsigned int div64_32(unsigned long long o1, unsigned int o2) |
| 772 | { |
| 773 | unsigned int result; |
| 774 | #ifdef __i386__ |
| 775 | asm("divl %2" |
| 776 | : "=a" (result) |
| 777 | : "A"(o1), "rm"(o2)); |
| 778 | #else |
| 779 | result = o1 / o2; |
| 780 | #endif |
| 781 | return result; |
| 782 | } |
| 783 | |
David Carlier | e6c3941 | 2015-07-02 07:00:17 +0000 | [diff] [blame] | 784 | /* Simple popcountl implementation. It returns the number of ones in a word */ |
| 785 | static inline unsigned int my_popcountl(unsigned long a) |
Willy Tarreau | 37994f0 | 2012-11-19 12:11:07 +0100 | [diff] [blame] | 786 | { |
| 787 | unsigned int cnt; |
| 788 | for (cnt = 0; a; a >>= 1) { |
| 789 | if (a & 1) |
| 790 | cnt++; |
| 791 | } |
| 792 | return cnt; |
| 793 | } |
| 794 | |
David Carlier | e6c3941 | 2015-07-02 07:00:17 +0000 | [diff] [blame] | 795 | /* Build a word with the <bits> lower bits set (reverse of my_popcountl) */ |
Willy Tarreau | a9db57e | 2013-01-18 11:29:29 +0100 | [diff] [blame] | 796 | static inline unsigned long nbits(int bits) |
| 797 | { |
| 798 | if (--bits < 0) |
| 799 | return 0; |
| 800 | else |
| 801 | return (2UL << bits) - 1; |
| 802 | } |
| 803 | |
Willy Tarreau | 126d406 | 2013-12-03 17:50:47 +0100 | [diff] [blame] | 804 | /* |
| 805 | * Parse binary string written in hexadecimal (source) and store the decoded |
| 806 | * result into binstr and set binstrlen to the lengh of binstr. Memory for |
| 807 | * binstr is allocated by the function. In case of error, returns 0 with an |
| 808 | * error message in err. |
| 809 | */ |
| 810 | int parse_binary(const char *source, char **binstr, int *binstrlen, char **err); |
| 811 | |
Willy Tarreau | 946ba59 | 2009-05-10 15:41:18 +0200 | [diff] [blame] | 812 | /* copies at most <n> characters from <src> and always terminates with '\0' */ |
| 813 | char *my_strndup(const char *src, int n); |
| 814 | |
Baptiste Assmann | bb77c8e | 2013-10-06 23:24:13 +0200 | [diff] [blame] | 815 | /* |
| 816 | * search needle in haystack |
| 817 | * returns the pointer if found, returns NULL otherwise |
| 818 | */ |
| 819 | const void *my_memmem(const void *, size_t, const void *, size_t); |
| 820 | |
Willy Tarreau | 482b00d | 2009-10-04 22:48:42 +0200 | [diff] [blame] | 821 | /* This function returns the first unused key greater than or equal to <key> in |
| 822 | * ID tree <root>. Zero is returned if no place is found. |
| 823 | */ |
| 824 | unsigned int get_next_id(struct eb_root *root, unsigned int key); |
| 825 | |
Willy Tarreau | 348238b | 2010-01-18 15:05:57 +0100 | [diff] [blame] | 826 | /* This function compares a sample word possibly followed by blanks to another |
| 827 | * clean word. The compare is case-insensitive. 1 is returned if both are equal, |
| 828 | * otherwise zero. This intends to be used when checking HTTP headers for some |
| 829 | * values. |
| 830 | */ |
| 831 | int word_match(const char *sample, int slen, const char *word, int wlen); |
| 832 | |
Willy Tarreau | f0b38bf | 2010-06-06 13:22:23 +0200 | [diff] [blame] | 833 | /* Convert a fixed-length string to an IP address. Returns 0 in case of error, |
| 834 | * or the number of chars read in case of success. |
| 835 | */ |
| 836 | int buf2ip(const char *buf, size_t len, struct in_addr *dst); |
Thierry FOURNIER | d559dd8 | 2013-11-22 16:16:59 +0100 | [diff] [blame] | 837 | int buf2ip6(const char *buf, size_t len, struct in6_addr *dst); |
Willy Tarreau | f0b38bf | 2010-06-06 13:22:23 +0200 | [diff] [blame] | 838 | |
Willy Tarreau | acf9577 | 2010-06-14 19:09:21 +0200 | [diff] [blame] | 839 | /* To be used to quote config arg positions. Returns the string at <ptr> |
| 840 | * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line" |
| 841 | * if ptr is NULL or empty. The string is locally allocated. |
| 842 | */ |
| 843 | const char *quote_arg(const char *ptr); |
| 844 | |
Willy Tarreau | 5b18020 | 2010-07-18 10:40:48 +0200 | [diff] [blame] | 845 | /* returns an operator among STD_OP_* for string <str> or < 0 if unknown */ |
| 846 | int get_std_op(const char *str); |
| 847 | |
Willy Tarreau | 4c14eaa | 2010-11-24 14:01:45 +0100 | [diff] [blame] | 848 | /* hash a 32-bit integer to another 32-bit integer */ |
| 849 | extern unsigned int full_hash(unsigned int a); |
| 850 | static inline unsigned int __full_hash(unsigned int a) |
| 851 | { |
| 852 | /* This function is one of Bob Jenkins' full avalanche hashing |
| 853 | * functions, which when provides quite a good distribution for little |
| 854 | * input variations. The result is quite suited to fit over a 32-bit |
| 855 | * space with enough variations so that a randomly picked number falls |
| 856 | * equally before any server position. |
| 857 | * Check http://burtleburtle.net/bob/hash/integer.html for more info. |
| 858 | */ |
| 859 | a = (a+0x7ed55d16) + (a<<12); |
| 860 | a = (a^0xc761c23c) ^ (a>>19); |
| 861 | a = (a+0x165667b1) + (a<<5); |
| 862 | a = (a+0xd3a2646c) ^ (a<<9); |
| 863 | a = (a+0xfd7046c5) + (a<<3); |
| 864 | a = (a^0xb55a4f09) ^ (a>>16); |
| 865 | |
| 866 | /* ensure values are better spread all around the tree by multiplying |
| 867 | * by a large prime close to 3/4 of the tree. |
| 868 | */ |
| 869 | return a * 3221225473U; |
| 870 | } |
| 871 | |
Willy Tarreau | 422a0a5 | 2012-10-26 19:47:23 +0200 | [diff] [blame] | 872 | /* sets the address family to AF_UNSPEC so that is_addr() does not match */ |
| 873 | static inline void clear_addr(struct sockaddr_storage *addr) |
| 874 | { |
| 875 | addr->ss_family = AF_UNSPEC; |
| 876 | } |
| 877 | |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 878 | /* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address, |
| 879 | * otherwise zero. |
| 880 | */ |
Willy Tarreau | 18ca2d4 | 2014-05-09 22:40:55 +0200 | [diff] [blame] | 881 | static inline int is_inet_addr(const struct sockaddr_storage *addr) |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 882 | { |
| 883 | int i; |
| 884 | |
| 885 | switch (addr->ss_family) { |
| 886 | case AF_INET: |
David du Colombier | 64e9c90 | 2011-03-22 11:39:41 +0100 | [diff] [blame] | 887 | return *(int *)&((struct sockaddr_in *)addr)->sin_addr; |
David du Colombier | 6f5ccb1 | 2011-03-10 22:26:24 +0100 | [diff] [blame] | 888 | case AF_INET6: |
| 889 | for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++) |
| 890 | if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0) |
| 891 | return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i]; |
| 892 | } |
| 893 | return 0; |
| 894 | } |
| 895 | |
Willy Tarreau | 18ca2d4 | 2014-05-09 22:40:55 +0200 | [diff] [blame] | 896 | /* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address, |
| 897 | * or is a unix address, otherwise returns zero. |
| 898 | */ |
| 899 | static inline int is_addr(const struct sockaddr_storage *addr) |
| 900 | { |
| 901 | if (addr->ss_family == AF_UNIX) |
| 902 | return 1; |
| 903 | else |
| 904 | return is_inet_addr(addr); |
| 905 | } |
| 906 | |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 907 | /* returns port in network byte order */ |
| 908 | static inline int get_net_port(struct sockaddr_storage *addr) |
| 909 | { |
| 910 | switch (addr->ss_family) { |
| 911 | case AF_INET: |
| 912 | return ((struct sockaddr_in *)addr)->sin_port; |
| 913 | case AF_INET6: |
| 914 | return ((struct sockaddr_in6 *)addr)->sin6_port; |
| 915 | } |
| 916 | return 0; |
| 917 | } |
| 918 | |
| 919 | /* returns port in host byte order */ |
| 920 | static inline int get_host_port(struct sockaddr_storage *addr) |
| 921 | { |
| 922 | switch (addr->ss_family) { |
| 923 | case AF_INET: |
| 924 | return ntohs(((struct sockaddr_in *)addr)->sin_port); |
| 925 | case AF_INET6: |
| 926 | return ntohs(((struct sockaddr_in6 *)addr)->sin6_port); |
| 927 | } |
| 928 | return 0; |
| 929 | } |
| 930 | |
Willy Tarreau | 1b4b7ce | 2011-04-05 16:56:50 +0200 | [diff] [blame] | 931 | /* returns address len for <addr>'s family, 0 for unknown families */ |
| 932 | static inline int get_addr_len(const struct sockaddr_storage *addr) |
| 933 | { |
| 934 | switch (addr->ss_family) { |
| 935 | case AF_INET: |
| 936 | return sizeof(struct sockaddr_in); |
| 937 | case AF_INET6: |
| 938 | return sizeof(struct sockaddr_in6); |
| 939 | case AF_UNIX: |
| 940 | return sizeof(struct sockaddr_un); |
| 941 | } |
| 942 | return 0; |
| 943 | } |
| 944 | |
David du Colombier | 11bcb6c | 2011-03-24 12:23:00 +0100 | [diff] [blame] | 945 | /* set port in host byte order */ |
| 946 | static inline int set_net_port(struct sockaddr_storage *addr, int port) |
| 947 | { |
| 948 | switch (addr->ss_family) { |
| 949 | case AF_INET: |
| 950 | ((struct sockaddr_in *)addr)->sin_port = port; |
| 951 | case AF_INET6: |
| 952 | ((struct sockaddr_in6 *)addr)->sin6_port = port; |
| 953 | } |
| 954 | return 0; |
| 955 | } |
| 956 | |
| 957 | /* set port in network byte order */ |
| 958 | static inline int set_host_port(struct sockaddr_storage *addr, int port) |
| 959 | { |
| 960 | switch (addr->ss_family) { |
| 961 | case AF_INET: |
| 962 | ((struct sockaddr_in *)addr)->sin_port = htons(port); |
| 963 | case AF_INET6: |
| 964 | ((struct sockaddr_in6 *)addr)->sin6_port = htons(port); |
| 965 | } |
| 966 | return 0; |
| 967 | } |
| 968 | |
Thierry Fournier | 70473a5 | 2016-02-17 17:12:14 +0100 | [diff] [blame] | 969 | /* Convert mask from bit length form to in_addr form. |
| 970 | * This function never fails. |
| 971 | */ |
| 972 | void len2mask4(int len, struct in_addr *addr); |
| 973 | |
| 974 | /* Convert mask from bit length form to in6_addr form. |
| 975 | * This function never fails. |
| 976 | */ |
| 977 | void len2mask6(int len, struct in6_addr *addr); |
| 978 | |
David du Colombier | 4f92d32 | 2011-03-24 11:09:31 +0100 | [diff] [blame] | 979 | /* Return true if IPv4 address is part of the network */ |
Willy Tarreau | eec1d38 | 2016-07-13 11:59:39 +0200 | [diff] [blame] | 980 | 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] | 981 | |
| 982 | /* Return true if IPv6 address is part of the network */ |
Willy Tarreau | eec1d38 | 2016-07-13 11:59:39 +0200 | [diff] [blame] | 983 | 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] | 984 | |
| 985 | /* Map IPv4 adress on IPv6 address, as specified in RFC 3513. */ |
| 986 | extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr); |
| 987 | |
| 988 | /* Map IPv6 adress on IPv4 address, as specified in RFC 3513. |
| 989 | * Return true if conversion is possible and false otherwise. |
| 990 | */ |
| 991 | extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr); |
| 992 | |
Baptiste Assmann | 08b24cf | 2016-01-23 23:39:12 +0100 | [diff] [blame] | 993 | /* compare two struct sockaddr_storage and return: |
| 994 | * 0 (true) if the addr is the same in both |
| 995 | * 1 (false) if the addr is not the same in both |
| 996 | */ |
| 997 | int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2); |
| 998 | |
Baptiste Assmann | 08396c8 | 2016-01-31 00:27:17 +0100 | [diff] [blame] | 999 | /* copy ip from <source> into <dest> |
| 1000 | * the caller must clear <dest> before calling. |
| 1001 | * Returns a pointer to the destination |
| 1002 | */ |
| 1003 | struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest); |
| 1004 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 1005 | char *human_time(int t, short hz_div); |
| 1006 | |
| 1007 | extern const char *monthname[]; |
| 1008 | |
| 1009 | /* date2str_log: write a date in the format : |
| 1010 | * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d", |
| 1011 | * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900, |
| 1012 | * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000); |
| 1013 | * |
| 1014 | * without using sprintf. return a pointer to the last char written (\0) or |
| 1015 | * NULL if there isn't enough space. |
| 1016 | */ |
| 1017 | char *date2str_log(char *dest, struct tm *tm, struct timeval *date, size_t size); |
| 1018 | |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 1019 | /* Return the GMT offset for a specific local time. |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 1020 | * Both t and tm must represent the same time. |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 1021 | * The string returned has the same format as returned by strftime(... "%z", tm). |
| 1022 | * Offsets are kept in an internal cache for better performances. |
| 1023 | */ |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 1024 | const char *get_gmt_offset(time_t t, struct tm *tm); |
Benoit GARNIER | b413c2a | 2016-03-27 11:08:03 +0200 | [diff] [blame] | 1025 | |
William Lallemand | 421f5b5 | 2012-02-06 18:15:57 +0100 | [diff] [blame] | 1026 | /* gmt2str_log: write a date in the format : |
| 1027 | * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf |
| 1028 | * return a pointer to the last char written (\0) or |
| 1029 | * NULL if there isn't enough space. |
| 1030 | */ |
| 1031 | char *gmt2str_log(char *dst, struct tm *tm, size_t size); |
| 1032 | |
Yuxans Yao | 4e25b01 | 2012-10-19 10:36:09 +0800 | [diff] [blame] | 1033 | /* localdate2str_log: write a date in the format : |
| 1034 | * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 1035 | * Both t and tm must represent the same time. |
Yuxans Yao | 4e25b01 | 2012-10-19 10:36:09 +0800 | [diff] [blame] | 1036 | * return a pointer to the last char written (\0) or |
| 1037 | * NULL if there isn't enough space. |
| 1038 | */ |
Benoit GARNIER | e2e5bde | 2016-03-27 03:04:16 +0200 | [diff] [blame] | 1039 | 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] | 1040 | |
Thierry Fournier | 9312794 | 2016-01-20 18:49:45 +0100 | [diff] [blame] | 1041 | /* These 3 functions parses date string and fills the |
| 1042 | * corresponding broken-down time in <tm>. In succes case, |
| 1043 | * it returns 1, otherwise, it returns 0. |
| 1044 | */ |
| 1045 | int parse_http_date(const char *date, int len, struct tm *tm); |
| 1046 | int parse_imf_date(const char *date, int len, struct tm *tm); |
| 1047 | int parse_rfc850_date(const char *date, int len, struct tm *tm); |
| 1048 | int parse_asctime_date(const char *date, int len, struct tm *tm); |
| 1049 | |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 1050 | /* Dynamically allocates a string of the proper length to hold the formatted |
| 1051 | * output. NULL is returned on error. The caller is responsible for freeing the |
| 1052 | * memory area using free(). The resulting string is returned in <out> if the |
| 1053 | * pointer is not NULL. A previous version of <out> might be used to build the |
| 1054 | * new string, and it will be freed before returning if it is not NULL, which |
| 1055 | * makes it possible to build complex strings from iterative calls without |
| 1056 | * having to care about freeing intermediate values, as in the example below : |
| 1057 | * |
| 1058 | * memprintf(&err, "invalid argument: '%s'", arg); |
| 1059 | * ... |
| 1060 | * memprintf(&err, "parser said : <%s>\n", *err); |
| 1061 | * ... |
| 1062 | * free(*err); |
| 1063 | * |
| 1064 | * This means that <err> must be initialized to NULL before first invocation. |
| 1065 | * The return value also holds the allocated string, which eases error checking |
| 1066 | * 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] | 1067 | * passed instead and it will be ignored. The returned message will then also |
| 1068 | * 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] | 1069 | * |
| 1070 | * It is also convenient to use it without any free except the last one : |
| 1071 | * err = NULL; |
| 1072 | * if (!fct1(err)) report(*err); |
| 1073 | * if (!fct2(err)) report(*err); |
| 1074 | * if (!fct3(err)) report(*err); |
| 1075 | * free(*err); |
Christopher Faulet | 93a518f | 2017-10-24 11:25:33 +0200 | [diff] [blame] | 1076 | * |
| 1077 | * memprintf relies on memvprintf. This last version can be called from any |
| 1078 | * function with variadic arguments. |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 1079 | */ |
Christopher Faulet | 93a518f | 2017-10-24 11:25:33 +0200 | [diff] [blame] | 1080 | char *memvprintf(char **out, const char *format, va_list args) |
| 1081 | __attribute__ ((format(printf, 2, 0))); |
| 1082 | |
Willy Tarreau | 9a7bea5 | 2012-04-27 11:16:50 +0200 | [diff] [blame] | 1083 | char *memprintf(char **out, const char *format, ...) |
| 1084 | __attribute__ ((format(printf, 2, 3))); |
| 1085 | |
Willy Tarreau | 21c705b | 2012-09-14 11:40:36 +0200 | [diff] [blame] | 1086 | /* Used to add <level> spaces before each line of <out>, unless there is only one line. |
| 1087 | * The input argument is automatically freed and reassigned. The result will have to be |
| 1088 | * freed by the caller. |
| 1089 | * Example of use : |
| 1090 | * parse(cmd, &err); (callee: memprintf(&err, ...)) |
| 1091 | * fprintf(stderr, "Parser said: %s\n", indent_error(&err)); |
| 1092 | * free(err); |
| 1093 | */ |
| 1094 | char *indent_msg(char **out, int level); |
Willy Tarreau | 3d2f16f | 2012-05-13 00:21:17 +0200 | [diff] [blame] | 1095 | |
Willy Tarreau | dad36a3 | 2013-03-11 01:20:04 +0100 | [diff] [blame] | 1096 | /* Convert occurrences of environment variables in the input string to their |
| 1097 | * corresponding value. A variable is identified as a series of alphanumeric |
| 1098 | * characters or underscores following a '$' sign. The <in> string must be |
| 1099 | * free()able. NULL returns NULL. The resulting string might be reallocated if |
| 1100 | * some expansion is made. |
| 1101 | */ |
| 1102 | char *env_expand(char *in); |
| 1103 | |
Willy Tarreau | 3d2f16f | 2012-05-13 00:21:17 +0200 | [diff] [blame] | 1104 | /* debugging macro to emit messages using write() on fd #-1 so that strace sees |
| 1105 | * them. |
| 1106 | */ |
| 1107 | #define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0) |
| 1108 | |
Willy Tarreau | 0ebb511 | 2016-12-05 00:10:57 +0100 | [diff] [blame] | 1109 | /* 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] | 1110 | * has address <baseaddr>. String <pfx> may be placed as a prefix in front of |
| 1111 | * 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] | 1112 | */ |
Willy Tarreau | ed936c5 | 2017-04-27 18:03:20 +0200 | [diff] [blame] | 1113 | 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] | 1114 | |
Willy Tarreau | 1296382 | 2017-10-24 10:54:08 +0200 | [diff] [blame] | 1115 | /* this is used to emit traces when building with TRACE=1 */ |
| 1116 | __attribute__((format(printf, 1, 2))) |
| 1117 | void trace(char *fmt, ...); |
| 1118 | |
Willy Tarreau | 89efaed | 2013-12-13 15:14:55 +0100 | [diff] [blame] | 1119 | /* used from everywhere just to drain results we don't want to read and which |
| 1120 | * recent versions of gcc increasingly and annoyingly complain about. |
| 1121 | */ |
| 1122 | extern int shut_your_big_mouth_gcc_int; |
| 1123 | |
| 1124 | /* used from everywhere just to drain results we don't want to read and which |
| 1125 | * recent versions of gcc increasingly and annoyingly complain about. |
| 1126 | */ |
| 1127 | static inline void shut_your_big_mouth_gcc(int r) |
| 1128 | { |
| 1129 | shut_your_big_mouth_gcc_int = r; |
| 1130 | } |
| 1131 | |
de Lafond Guillaume | 88c278f | 2013-04-15 19:27:10 +0200 | [diff] [blame] | 1132 | /* same as strstr() but case-insensitive */ |
| 1133 | const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2); |
| 1134 | |
Willy Tarreau | bb519c7 | 2014-01-28 23:04:39 +0100 | [diff] [blame] | 1135 | |
| 1136 | /************************* Composite address manipulation ********************* |
| 1137 | * Composite addresses are simply unsigned long data in which the higher bits |
| 1138 | * represent a pointer, and the two lower bits are flags. There are several |
| 1139 | * places where we just want to associate one or two flags to a pointer (eg, |
| 1140 | * to type it), and these functions permit this. The pointer is necessarily a |
| 1141 | * 32-bit aligned pointer, as its two lower bits will be cleared and replaced |
| 1142 | * with the flags. |
| 1143 | *****************************************************************************/ |
| 1144 | |
| 1145 | /* Masks the two lower bits of a composite address and converts it to a |
| 1146 | * pointer. This is used to mix some bits with some aligned pointers to |
| 1147 | * structs and to retrieve the original (32-bit aligned) pointer. |
| 1148 | */ |
| 1149 | static inline void *caddr_to_ptr(unsigned long caddr) |
| 1150 | { |
| 1151 | return (void *)(caddr & ~3UL); |
| 1152 | } |
| 1153 | |
| 1154 | /* Only retrieves the two lower bits of a composite address. This is used to mix |
| 1155 | * some bits with some aligned pointers to structs and to retrieve the original |
| 1156 | * data (2 bits). |
| 1157 | */ |
| 1158 | static inline unsigned int caddr_to_data(unsigned long caddr) |
| 1159 | { |
| 1160 | return (caddr & 3UL); |
| 1161 | } |
| 1162 | |
| 1163 | /* Combines the aligned pointer whose 2 lower bits will be masked with the bits |
| 1164 | * from <data> to form a composite address. This is used to mix some bits with |
| 1165 | * some aligned pointers to structs and to retrieve the original (32-bit aligned) |
| 1166 | * pointer. |
| 1167 | */ |
| 1168 | static inline unsigned long caddr_from_ptr(void *ptr, unsigned int data) |
| 1169 | { |
| 1170 | return (((unsigned long)ptr) & ~3UL) + (data & 3); |
| 1171 | } |
| 1172 | |
| 1173 | /* sets the 2 bits of <data> in the <caddr> composite address */ |
| 1174 | static inline unsigned long caddr_set_flags(unsigned long caddr, unsigned int data) |
| 1175 | { |
| 1176 | return caddr | (data & 3); |
| 1177 | } |
| 1178 | |
| 1179 | /* clears the 2 bits of <data> in the <caddr> composite address */ |
| 1180 | static inline unsigned long caddr_clr_flags(unsigned long caddr, unsigned int data) |
| 1181 | { |
| 1182 | return caddr & ~(unsigned long)(data & 3); |
| 1183 | } |
| 1184 | |
Thierry FOURNIER | 317e1c4 | 2014-08-12 10:20:47 +0200 | [diff] [blame] | 1185 | /* UTF-8 decoder status */ |
| 1186 | #define UTF8_CODE_OK 0x00 |
| 1187 | #define UTF8_CODE_OVERLONG 0x10 |
| 1188 | #define UTF8_CODE_INVRANGE 0x20 |
| 1189 | #define UTF8_CODE_BADSEQ 0x40 |
| 1190 | |
| 1191 | unsigned char utf8_next(const char *s, int len, unsigned int *c); |
| 1192 | |
| 1193 | static inline unsigned char utf8_return_code(unsigned int code) |
| 1194 | { |
| 1195 | return code & 0xf0; |
| 1196 | } |
| 1197 | |
| 1198 | static inline unsigned char utf8_return_length(unsigned char code) |
| 1199 | { |
| 1200 | return code & 0x0f; |
| 1201 | } |
| 1202 | |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1203 | /* Turns 64-bit value <a> from host byte order to network byte order. |
| 1204 | * The principle consists in letting the compiler detect we're playing |
| 1205 | * with a union and simplify most or all operations. The asm-optimized |
| 1206 | * htonl() version involving bswap (x86) / rev (arm) / other is a single |
| 1207 | * operation on little endian, or a NOP on big-endian. In both cases, |
| 1208 | * this lets the compiler "see" that we're rebuilding a 64-bit word from |
| 1209 | * two 32-bit quantities that fit into a 32-bit register. In big endian, |
| 1210 | * the whole code is optimized out. In little endian, with a decent compiler, |
| 1211 | * a few bswap and 2 shifts are left, which is the minimum acceptable. |
| 1212 | */ |
Willy Tarreau | 5f6e905 | 2016-05-20 06:29:59 +0200 | [diff] [blame] | 1213 | static inline unsigned long long my_htonll(unsigned long long a) |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1214 | { |
Willy Tarreau | 36eb3a3 | 2017-09-20 08:18:49 +0200 | [diff] [blame] | 1215 | #if defined(__x86_64__) |
Willy Tarreau | dea7c5c | 2017-10-18 11:39:33 +0200 | [diff] [blame] | 1216 | __asm__ volatile("bswap %0" : "=r"(a) : "0"(a)); |
Willy Tarreau | 36eb3a3 | 2017-09-20 08:18:49 +0200 | [diff] [blame] | 1217 | return a; |
| 1218 | #else |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1219 | union { |
| 1220 | struct { |
| 1221 | unsigned int w1; |
| 1222 | unsigned int w2; |
| 1223 | } by32; |
| 1224 | unsigned long long by64; |
| 1225 | } w = { .by64 = a }; |
| 1226 | return ((unsigned long long)htonl(w.by32.w1) << 32) | htonl(w.by32.w2); |
Willy Tarreau | 36eb3a3 | 2017-09-20 08:18:49 +0200 | [diff] [blame] | 1227 | #endif |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1228 | } |
| 1229 | |
| 1230 | /* Turns 64-bit value <a> from network byte order to host byte order. */ |
Willy Tarreau | 5f6e905 | 2016-05-20 06:29:59 +0200 | [diff] [blame] | 1231 | static inline unsigned long long my_ntohll(unsigned long long a) |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1232 | { |
Willy Tarreau | 5f6e905 | 2016-05-20 06:29:59 +0200 | [diff] [blame] | 1233 | return my_htonll(a); |
Willy Tarreau | 5b4dd68 | 2015-07-21 23:47:18 +0200 | [diff] [blame] | 1234 | } |
| 1235 | |
Willy Tarreau | e6e49cf | 2015-04-29 17:13:35 +0200 | [diff] [blame] | 1236 | /* returns a 64-bit a timestamp with the finest resolution available. The |
| 1237 | * unit is intentionally not specified. It's mostly used to compare dates. |
| 1238 | */ |
| 1239 | #if defined(__i386__) || defined(__x86_64__) |
| 1240 | static inline unsigned long long rdtsc() |
| 1241 | { |
| 1242 | unsigned int a, d; |
| 1243 | asm volatile("rdtsc" : "=a" (a), "=d" (d)); |
| 1244 | return a + ((unsigned long long)d << 32); |
| 1245 | } |
| 1246 | #else |
| 1247 | static inline unsigned long long rdtsc() |
| 1248 | { |
| 1249 | struct timeval tv; |
| 1250 | gettimeofday(&tv, NULL); |
| 1251 | return tv.tv_sec * 1000000 + tv.tv_usec; |
| 1252 | } |
| 1253 | #endif |
| 1254 | |
Maxime de Roucy | dc88785 | 2016-05-13 23:52:54 +0200 | [diff] [blame] | 1255 | /* append a copy of string <str> (in a wordlist) at the end of the list <li> |
| 1256 | * On failure : return 0 and <err> filled with an error message. |
| 1257 | * The caller is responsible for freeing the <err> and <str> copy |
| 1258 | * memory area using free() |
| 1259 | */ |
| 1260 | struct list; |
| 1261 | int list_append_word(struct list *li, const char *str, char **err); |
| 1262 | |
Willy Tarreau | 97c2ae1 | 2016-11-22 18:00:20 +0100 | [diff] [blame] | 1263 | int dump_text(struct chunk *out, const char *buf, int bsize); |
| 1264 | int dump_binary(struct chunk *out, const char *buf, int bsize); |
| 1265 | int dump_text_line(struct chunk *out, const char *buf, int bsize, int len, |
| 1266 | int *line, int ptr); |
| 1267 | |
Hubert Verstraete | 2eae3a0 | 2016-06-28 22:41:00 +0200 | [diff] [blame] | 1268 | /* same as realloc() except that ptr is also freed upon failure */ |
| 1269 | static inline void *my_realloc2(void *ptr, size_t size) |
| 1270 | { |
| 1271 | void *ret; |
| 1272 | |
| 1273 | ret = realloc(ptr, size); |
| 1274 | if (!ret && size) |
| 1275 | free(ptr); |
| 1276 | return ret; |
| 1277 | } |
| 1278 | |
Lukas Tribus | dcbc5c5 | 2016-09-12 21:42:07 +0000 | [diff] [blame] | 1279 | /* HAP_STRING() makes a string from a literal while HAP_XSTRING() first |
| 1280 | * evaluates the argument and is suited to pass macros. |
| 1281 | * |
| 1282 | * They allow macros like PCRE_MAJOR to be defined without quotes, which |
| 1283 | * is convenient for applications that want to test its value. |
| 1284 | */ |
| 1285 | #define HAP_STRING(...) #__VA_ARGS__ |
| 1286 | #define HAP_XSTRING(...) HAP_STRING(__VA_ARGS__) |
| 1287 | |
Willy Tarreau | 2dd0d47 | 2006-06-29 17:53:05 +0200 | [diff] [blame] | 1288 | #endif /* _COMMON_STANDARD_H */ |