blob: 2f1dffe36c7d1da07910039761785c1bb6c7abce [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreaucc05fba2009-10-27 21:40:18 +01002 * include/common/standard.h
3 * This files contains some general purpose functions and macros.
4 *
Willy Tarreau348238b2010-01-18 15:05:57 +01005 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
Willy Tarreaucc05fba2009-10-27 21:40:18 +01006 *
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 Tarreaubaaee002006-06-26 02:48:02 +020021
Willy Tarreau2dd0d472006-06-29 17:53:05 +020022#ifndef _COMMON_STANDARD_H
23#define _COMMON_STANDARD_H
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreau13faf162020-03-04 07:44:06 +010025#ifdef USE_BACKTRACE
26#define _GNU_SOURCE
27#include <execinfo.h>
28#endif
29
Willy Tarreau050737f2010-01-14 11:40:12 +010030#include <string.h>
Willy Tarreau0ebb5112016-12-05 00:10:57 +010031#include <stdio.h>
Willy Tarreaufe944602007-10-25 10:34:16 +020032#include <time.h>
David Carlier5222d8e2017-11-03 12:00:26 +000033#include <stdarg.h>
Willy Tarreaue6e49cf2015-04-29 17:13:35 +020034#include <sys/time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020035#include <sys/types.h>
Willy Tarreaud50265a2012-09-04 14:18:33 +020036#include <sys/socket.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020037#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020038#include <netinet/in.h>
Willy Tarreau5b4dd682015-07-21 23:47:18 +020039#include <arpa/inet.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020040#include <haproxy/api.h>
Thierry FOURNIERe059ec92014-03-17 12:01:13 +010041#include <common/chunk.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020042#include <common/namespace.h>
Willy Tarreau8d2b7772020-05-27 10:58:19 +020043#include <import/eb32tree.h>
44#include <import/eb32sctree.h>
William Lallemand2fe7dd02018-09-11 16:51:29 +020045#include <types/protocol.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020046
Thierry FOURNIER511e9472014-01-23 17:40:34 +010047/* size used for max length of decimal representation of long long int. */
48#define NB_LLMAX_STR (sizeof("-9223372036854775807")-1)
49
Willy Tarreau56adcf22012-12-23 18:00:29 +010050/* number of itoa_str entries */
Willy Tarreau59caa3b2018-12-14 13:59:42 +010051#define NB_ITOA_STR 16
William Lallemande7340ec2012-01-24 11:15:39 +010052
Willy Tarreau588297f2014-06-16 15:16:40 +020053/* maximum quoted string length (truncated above) */
54#define QSTR_SIZE 200
55#define NB_QSTR 10
56
Willy Tarreaubaaee002006-06-26 02:48:02 +020057/****** string-specific macros and functions ******/
58/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
59#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
60
61/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
62#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
63
64/* returns 1 only if only zero or one bit is set in X, which means that X is a
65 * power of 2, and 0 otherwise */
66#define POWEROF2(x) (((x) & ((x)-1)) == 0)
67
Willy Tarreau4d653a62020-06-03 17:49:00 +020068#define SWAP(a, b) do { typeof(a) t; t = a; a = b; b = t; } while(0)
69
70/* return an integer of type <ret> with only the highest bit set. <ret> may be
71 * both a variable or a type.
72 */
73#define MID_RANGE(ret) ((typeof(ret))1 << (8*sizeof(ret) - 1))
74
75/* return the largest possible integer of type <ret>, with all bits set */
76#define MAX_RANGE(ret) (~(typeof(ret))0)
77
Willy Tarreau7a409092020-03-08 00:41:00 +010078/* rotate left a 64-bit integer by <bits:[0-5]> bits */
79static inline uint64_t rotl64(uint64_t v, uint8_t bits)
80{
81#if !defined(__ARM_ARCH_8A) && !defined(__x86_64__)
82 bits &= 63;
83#endif
84 v = (v << bits) | (v >> (-bits & 63));
85 return v;
86}
87
88/* rotate right a 64-bit integer by <bits:[0-5]> bits */
89static inline uint64_t rotr64(uint64_t v, uint8_t bits)
90{
91#if !defined(__ARM_ARCH_8A) && !defined(__x86_64__)
92 bits &= 63;
93#endif
94 v = (v >> bits) | (v << (-bits & 63));
95 return v;
96}
97
Willy Tarreau32c24552019-08-19 17:39:33 +020098/* DEFNULL() returns either the argument as-is, or NULL if absent. This is for
99 * use in macros arguments.
100 */
101#define DEFNULL(...) _FIRST_ARG(NULL, ##__VA_ARGS__, NULL)
102#define _FIRST_ARG(a, b, ...) b
103
Willy Tarreau5b180202010-07-18 10:40:48 +0200104/* operators to compare values. They're ordered that way so that the lowest bit
105 * serves as a negation for the test and contains all tests that are not equal.
106 */
107enum {
108 STD_OP_LE = 0, STD_OP_GT = 1,
109 STD_OP_EQ = 2, STD_OP_NE = 3,
110 STD_OP_GE = 4, STD_OP_LT = 5,
111};
112
Thierry FOURNIER9f95e402014-03-21 14:51:46 +0100113enum http_scheme {
114 SCH_HTTP,
115 SCH_HTTPS,
116};
117
118struct split_url {
119 enum http_scheme scheme;
120 const char *host;
121 int host_len;
122};
123
Willy Tarreaufb4ba912019-08-29 09:32:21 +0200124/* generic structure associating a name and a value, for use in arrays */
125struct name_desc {
126 const char *name;
127 const char *desc;
128};
129
Christopher Faulet99bca652017-11-14 16:47:26 +0100130extern THREAD_LOCAL int itoa_idx; /* index of next itoa_str to use */
Willy Tarreau56adcf22012-12-23 18:00:29 +0100131
Willy Tarreau7d58a632007-01-13 23:06:06 +0100132/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200133 * copies at most <size-1> chars from <src> to <dst>. Last char is always
134 * set to 0, unless <size> is 0. The number of chars copied is returned
135 * (excluding the terminating zero).
136 * This code has been optimized for size and speed : on x86, it's 45 bytes
137 * long, uses only registers, and consumes only 4 cycles per char.
138 */
139extern int strlcpy2(char *dst, const char *src, int size);
140
141/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200142 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200143 * the ascii representation for number 'n' in decimal.
144 */
Christopher Faulet99bca652017-11-14 16:47:26 +0100145extern THREAD_LOCAL char itoa_str[][171];
Emeric Brun3a7fce52010-01-04 14:54:38 +0100146extern char *ultoa_r(unsigned long n, char *buffer, int size);
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200147extern char *lltoa_r(long long int n, char *buffer, int size);
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200148extern char *sltoa_r(long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +0200149extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +0200150static inline const char *ultoa(unsigned long n)
151{
152 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
153}
154
William Lallemande7340ec2012-01-24 11:15:39 +0100155/*
156 * unsigned long long ASCII representation
157 *
158 * return the last char '\0' or NULL if no enough
159 * space in dst
160 */
161char *ulltoa(unsigned long long n, char *dst, size_t size);
162
163
164/*
165 * unsigned long ASCII representation
166 *
167 * return the last char '\0' or NULL if no enough
168 * space in dst
169 */
170char *ultoa_o(unsigned long n, char *dst, size_t size);
171
172/*
173 * signed long ASCII representation
174 *
175 * return the last char '\0' or NULL if no enough
176 * space in dst
177 */
178char *ltoa_o(long int n, char *dst, size_t size);
179
180/*
181 * signed long long ASCII representation
182 *
183 * return the last char '\0' or NULL if no enough
184 * space in dst
185 */
186char *lltoa(long long n, char *dst, size_t size);
187
188/*
189 * write a ascii representation of a unsigned into dst,
190 * return a pointer to the last character
191 * Pad the ascii representation with '0', using size.
192 */
193char *utoa_pad(unsigned int n, char *dst, size_t size);
194
Willy Tarreaubaaee002006-06-26 02:48:02 +0200195/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200196 * This function simply returns a locally allocated string containing the ascii
197 * representation for number 'n' in decimal, unless n is 0 in which case it
198 * returns the alternate string (or an empty string if the alternate string is
199 * NULL). It use is intended for limits reported in reports, where it's
200 * desirable not to display anything if there is no limit. Warning! it shares
201 * the same vector as ultoa_r().
202 */
203extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
204
Willy Tarreau56adcf22012-12-23 18:00:29 +0100205/* returns a locally allocated string containing the ASCII representation of
206 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
207 * function call (eg: printf), shared with the other similar functions making
208 * use of itoa_str[].
209 */
210static inline const char *U2A(unsigned long n)
211{
212 const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
213 if (++itoa_idx >= NB_ITOA_STR)
214 itoa_idx = 0;
215 return ret;
216}
217
218/* returns a locally allocated string containing the HTML representation of
219 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
220 * function call (eg: printf), shared with the other similar functions making
221 * use of itoa_str[].
Willy Tarreau91092e52007-10-25 16:58:42 +0200222 */
Willy Tarreau56adcf22012-12-23 18:00:29 +0100223static inline const char *U2H(unsigned long long n)
224{
225 const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
226 if (++itoa_idx >= NB_ITOA_STR)
227 itoa_idx = 0;
228 return ret;
229}
230
Ioannis Cherouvim1ff76332018-10-24 10:05:19 +0300231/* returns a locally allocated string containing the ASCII representation of
Willy Tarreau56adcf22012-12-23 18:00:29 +0100232 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
233 * function call (eg: printf), shared with the other similar functions making
234 * use of itoa_str[].
235 */
236static inline const char *LIM2A(unsigned long n, const char *alt)
237{
238 const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt);
239 if (++itoa_idx >= NB_ITOA_STR)
240 itoa_idx = 0;
241 return ret;
242}
Willy Tarreau91092e52007-10-25 16:58:42 +0200243
Willy Tarreau4d589e72019-08-23 19:02:26 +0200244/* returns the number of bytes needed to encode <v> as a varint. Be careful, use
245 * it only with constants as it generates a large code (typ. 180 bytes). Use the
246 * varint_bytes() version instead in case of doubt.
247 */
248int varint_bytes(uint64_t v);
249static inline int __varint_bytes(uint64_t v)
250{
251 switch (v) {
252 case 0x0000000000000000 ... 0x00000000000000ef: return 1;
253 case 0x00000000000000f0 ... 0x00000000000008ef: return 2;
254 case 0x00000000000008f0 ... 0x00000000000408ef: return 3;
255 case 0x00000000000408f0 ... 0x00000000020408ef: return 4;
256 case 0x00000000020408f0 ... 0x00000001020408ef: return 5;
257 case 0x00000001020408f0 ... 0x00000081020408ef: return 6;
258 case 0x00000081020408f0 ... 0x00004081020408ef: return 7;
259 case 0x00004081020408f0 ... 0x00204081020408ef: return 8;
260 case 0x00204081020408f0 ... 0x10204081020408ef: return 9;
261 default: return 10;
262 }
263}
264
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200265/* Encode the integer <i> into a varint (variable-length integer). The encoded
266 * value is copied in <*buf>. Here is the encoding format:
267 *
268 * 0 <= X < 240 : 1 byte (7.875 bits) [ XXXX XXXX ]
269 * 240 <= X < 2288 : 2 bytes (11 bits) [ 1111 XXXX ] [ 0XXX XXXX ]
270 * 2288 <= X < 264432 : 3 bytes (18 bits) [ 1111 XXXX ] [ 1XXX XXXX ] [ 0XXX XXXX ]
271 * 264432 <= X < 33818864 : 4 bytes (25 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*2 [ 0XXX XXXX ]
272 * 33818864 <= X < 4328786160 : 5 bytes (32 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*3 [ 0XXX XXXX ]
273 * ...
274 *
275 * On success, it returns the number of written bytes and <*buf> is moved after
276 * the encoded value. Otherwise, it returns -1. */
277static inline int
278encode_varint(uint64_t i, char **buf, char *end)
279{
280 unsigned char *p = (unsigned char *)*buf;
281 int r;
282
283 if (p >= (unsigned char *)end)
284 return -1;
285
286 if (i < 240) {
287 *p++ = i;
288 *buf = (char *)p;
289 return 1;
290 }
291
292 *p++ = (unsigned char)i | 240;
293 i = (i - 240) >> 4;
294 while (i >= 128) {
295 if (p >= (unsigned char *)end)
296 return -1;
297 *p++ = (unsigned char)i | 128;
298 i = (i - 128) >> 7;
299 }
300
301 if (p >= (unsigned char *)end)
302 return -1;
303 *p++ = (unsigned char)i;
304
305 r = ((char *)p - *buf);
306 *buf = (char *)p;
307 return r;
308}
309
310/* Decode a varint from <*buf> and save the decoded value in <*i>. See
311 * 'spoe_encode_varint' for details about varint.
312 * On success, it returns the number of read bytes and <*buf> is moved after the
313 * varint. Otherwise, it returns -1. */
314static inline int
315decode_varint(char **buf, char *end, uint64_t *i)
316{
317 unsigned char *p = (unsigned char *)*buf;
318 int r;
319
320 if (p >= (unsigned char *)end)
321 return -1;
322
323 *i = *p++;
324 if (*i < 240) {
325 *buf = (char *)p;
326 return 1;
327 }
328
329 r = 4;
330 do {
331 if (p >= (unsigned char *)end)
332 return -1;
333 *i += (uint64_t)*p << r;
334 r += 7;
335 } while (*p++ >= 128);
336
337 r = ((char *)p - *buf);
338 *buf = (char *)p;
339 return r;
340}
341
Willy Tarreau588297f2014-06-16 15:16:40 +0200342/* returns a locally allocated string containing the quoted encoding of the
343 * input string. The output may be truncated to QSTR_SIZE chars, but it is
344 * guaranteed that the string will always be properly terminated. Quotes are
345 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
346 * always be at least 4 chars.
347 */
348const char *qstr(const char *str);
349
350/* returns <str> or its quote-encoded equivalent if it contains at least one
351 * quote or a comma. This is aimed at build CSV-compatible strings.
352 */
353static inline const char *cstr(const char *str)
354{
355 const char *p = str;
356
357 while (*p) {
358 if (*p == ',' || *p == '"')
359 return qstr(str);
360 p++;
361 }
362 return str;
363}
364
Willy Tarreau91092e52007-10-25 16:58:42 +0200365/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200366 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
367 */
368extern int ishex(char s);
369
370/*
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100371 * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F),
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200372 * otherwise -1. This compact form helps gcc produce efficient code.
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100373 */
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200374static inline int hex2i(int c)
375{
Willy Tarreauaa398602017-11-10 11:19:54 +0100376 if ((unsigned char)(c -= '0') > 9) {
377 if ((unsigned char)(c -= 'A' - '0') > 5 &&
378 (unsigned char)(c -= 'a' - 'A') > 5)
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200379 c = -11;
380 c += 10;
381 }
382 return c;
383}
384
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100385/* rounds <i> down to the closest value having max 2 digits */
386unsigned int round_2dig(unsigned int i);
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100387
388/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100389 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
390 * invalid character is found, a pointer to it is returned. If everything is
391 * fine, NULL is returned.
392 */
393extern const char *invalid_char(const char *name);
394
395/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200396 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200397 * If an invalid character is found, a pointer to it is returned.
398 * If everything is fine, NULL is returned.
399 */
400extern const char *invalid_domainchar(const char *name);
401
402/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200403 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
404 * If an invalid character is found, a pointer to it is returned.
405 * If everything is fine, NULL is returned.
406 */
407extern const char *invalid_prefix_char(const char *name);
408
Willy Tarreau36f586b2020-02-14 18:25:17 +0100409/* returns true if <c> is an identifier character, that is, a digit, a letter,
Willy Tarreaua71667c2020-02-17 06:34:11 +0100410 * or '-', '+', '_', ':' or '.'. This is usable for proxy names, server names,
411 * ACL names, sample fetch names, and converter names.
Willy Tarreau36f586b2020-02-14 18:25:17 +0100412 */
413static inline int is_idchar(char c)
414{
Willy Tarreau90807112020-02-25 08:16:33 +0100415 return isalnum((unsigned char)c) ||
Willy Tarreaua71667c2020-02-17 06:34:11 +0100416 c == '.' || c == '_' || c == '-' || c == '+' || c == ':';
Willy Tarreau36f586b2020-02-14 18:25:17 +0100417}
418
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200419/*
Willy Tarreaufab5a432011-03-04 15:31:53 +0100420 * converts <str> to a locally allocated struct sockaddr_storage *, and a
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200421 * port range consisting in two integers. The low and high end are always set
422 * even if the port is unspecified, in which case (0,0) is returned. The low
Willy Tarreaufab5a432011-03-04 15:31:53 +0100423 * port is set in the sockaddr. Thus, it is enough to check the size of the
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200424 * returned range to know if an array must be allocated or not. The format is
Willy Tarreaufab5a432011-03-04 15:31:53 +0100425 * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6
426 * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6
427 * address wants to ignore port, it must be terminated by a trailing colon (':').
428 * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on
429 * IPv6, use ":::port". NULL is returned if the host part cannot be resolved.
Willy Tarreaud393a622013-03-04 18:22:00 +0100430 * If <pfx> is non-null, it is used as a string prefix before any path-based
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200431 * address (typically the path to a unix socket). If use_dns is not true,
Joseph Herlant32b83272018-11-15 11:58:28 -0800432 * the function cannot accept the DNS resolution.
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200433 */
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100434struct sockaddr_storage *str2sa_range(const char *str,
435 int *port, int *low, int *high,
436 char **err, const char *pfx,
437 char **fqdn, int resolve);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200438
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100439/* converts <str> to a struct in_addr containing a network mask. It can be
440 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +0300441 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100442 */
443int str2mask(const char *str, struct in_addr *mask);
444
Tim Duesterhus47185172018-01-25 16:24:49 +0100445/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +0100446 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +0100447 * if the conversion succeeds otherwise zero.
448 */
449int str2mask6(const char *str, struct in6_addr *mask);
450
Thierry FOURNIERb0504632013-12-14 15:39:02 +0100451/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
452 * succeeds otherwise non-zero.
453 */
454int cidr2dotted(int cidr, struct in_addr *mask);
455
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200456/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200457 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200458 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500459 * is optional and either in the dotted or CIDR notation.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200460 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
461 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +0100462int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200463
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100464/* str2ip and str2ip2:
465 *
466 * converts <str> to a struct sockaddr_storage* provided by the caller. The
467 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
468 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
469 * the function tries to guess the address family from the syntax. If the
470 * family is forced and the format doesn't match, an error is returned. The
471 * string is assumed to contain only an address, no port. The address can be a
472 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
473 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
474 * The return address will only have the address family and the address set,
475 * all other fields remain zero. The string is not supposed to be modified.
476 * The IPv6 '::' address is IN6ADDR_ANY.
477 *
478 * str2ip2:
479 *
480 * If <resolve> is set, this function try to resolve DNS, otherwise, it returns
481 * NULL result.
482 */
483struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve);
484static inline struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa)
485{
486 return str2ip2(str, sa, 1);
487}
488
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100489/*
Willy Tarreau6d20e282012-04-27 22:49:47 +0200490 * converts <str> to two struct in6_addr* which must be pre-allocated.
491 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500492 * is an optional number of bits (128 being the default).
Willy Tarreau6d20e282012-04-27 22:49:47 +0200493 * Returns 1 if OK, 0 if error.
494 */
495int str62net(const char *str, struct in6_addr *addr, unsigned char *mask);
496
497/*
Willy Tarreau106f9792009-09-19 07:54:16 +0200498 * Parse IP address found in url.
499 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100500int url2ipv4(const char *addr, struct in_addr *dst);
Willy Tarreau106f9792009-09-19 07:54:16 +0200501
502/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100503 * Resolve destination server from URL. Convert <str> to a sockaddr_storage*.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100504 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +0100505int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100506
Willy Tarreau631f01c2011-09-05 00:36:48 +0200507/* Tries to convert a sockaddr_storage address to text form. Upon success, the
508 * address family is returned so that it's easy for the caller to adapt to the
509 * output format. Zero is returned if the address family is not supported. -1
510 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
511 * supported.
512 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +0200513int addr_to_str(const struct sockaddr_storage *addr, char *str, int size);
Willy Tarreau631f01c2011-09-05 00:36:48 +0200514
Simon Horman75ab8bd2014-06-16 09:39:41 +0900515/* Tries to convert a sockaddr_storage port to text form. Upon success, the
516 * address family is returned so that it's easy for the caller to adapt to the
517 * output format. Zero is returned if the address family is not supported. -1
518 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
519 * supported.
520 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +0200521int port_to_str(const struct sockaddr_storage *addr, char *str, int size);
Simon Horman75ab8bd2014-06-16 09:39:41 +0900522
Willy Tarreau16e01562016-08-09 16:46:18 +0200523/* check if the given address is local to the system or not. It will return
524 * -1 when it's not possible to know, 0 when the address is not local, 1 when
525 * it is. We don't want to iterate over all interfaces for this (and it is not
526 * portable). So instead we try to bind in UDP to this address on a free non
527 * privileged port and to connect to the same address, port 0 (connect doesn't
528 * care). If it succeeds, we own the address. Note that non-inet addresses are
529 * considered local since they're most likely AF_UNIX.
530 */
531int addr_is_local(const struct netns_entry *ns,
532 const struct sockaddr_storage *orig);
533
Willy Tarreaubaaee002006-06-26 02:48:02 +0200534/* will try to encode the string <string> replacing all characters tagged in
535 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
536 * prefixed by <escape>, and will store the result between <start> (included)
537 * and <stop> (excluded), and will always terminate the string with a '\0'
538 * before <stop>. The position of the '\0' is returned if the conversion
539 * completes. If bytes are missing between <start> and <stop>, then the
540 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
541 * cannot even be stored so we return <start> without writing the 0.
542 * The input string must also be zero-terminated.
543 */
544extern const char hextab[];
545char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +0200546 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +0200547 const char *string);
548
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100549/*
550 * Same behavior, except that it encodes chunk <chunk> instead of a string.
551 */
552char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +0200553 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +0200554 const struct buffer *chunk);
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100555
Dragan Dosen0edd1092016-02-12 13:23:02 +0100556/*
557 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +0200558 * character. The input <string> must be zero-terminated. The result will
559 * be stored between <start> (included) and <stop> (excluded). This
560 * function will always try to terminate the resulting string with a '\0'
561 * before <stop>, and will return its position if the conversion
562 * completes.
563 */
564char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +0200565 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +0200566 const char *string);
567
568/*
569 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +0100570 * character. <chunk> contains the input to be escaped. The result will be
571 * stored between <start> (included) and <stop> (excluded). The function
572 * will always try to terminate the resulting string with a '\0' before
573 * <stop>, and will return its position if the conversion completes.
574 */
575char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +0200576 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +0200577 const struct buffer *chunk);
Dragan Dosen0edd1092016-02-12 13:23:02 +0100578
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100579
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200580/* Check a string for using it in a CSV output format. If the string contains
581 * one of the following four char <">, <,>, CR or LF, the string is
582 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
583 * <str> is the input string to be escaped. The function assumes that
584 * the input string is null-terminated.
585 *
586 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +0100587 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200588 * format.
589 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100590 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200591 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100592 * If <quote> is 1, the converter puts the quotes only if any character is
593 * escaped. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200594 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100595 * <output> is a struct chunk used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200596 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100597 * The function returns the converted string on its output. If an error
598 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200599 * for using the function directly as printf() argument.
600 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100601 * If the output buffer is too short to contain the input string, the result
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200602 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +0100603 *
604 * This function appends the encoding to the existing output chunk. Please
605 * use csv_enc() instead if you want to replace the output chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200606 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200607const char *csv_enc_append(const char *str, int quote, struct buffer *output);
Willy Tarreau898529b2016-01-06 18:07:04 +0100608
609/* same as above but the output chunk is reset first */
Willy Tarreau83061a82018-07-13 11:56:34 +0200610static inline const char *csv_enc(const char *str, int quote,
611 struct buffer *output)
Willy Tarreau898529b2016-01-06 18:07:04 +0100612{
613 chunk_reset(output);
614 return csv_enc_append(str, quote, output);
615}
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200616
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200617/* Decode an URL-encoded string in-place. The resulting string might
618 * be shorter. If some forbidden characters are found, the conversion is
619 * aborted, the string is truncated before the issue and non-zero is returned,
620 * otherwise the operation returns non-zero indicating success.
Willy Tarreau62ba9ba2020-04-23 17:54:47 +0200621 * If the 'in_form' argument is non-nul the string is assumed to be part of
622 * an "application/x-www-form-urlencoded" encoded string, and the '+' will be
623 * turned to a space. If it's zero, this will only be done after a question
624 * mark ('?').
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200625 */
Willy Tarreau62ba9ba2020-04-23 17:54:47 +0200626int url_decode(char *string, int in_form);
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200627
Willy Tarreau6911fa42007-03-04 18:06:08 +0100628/* This one is 6 times faster than strtoul() on athlon, but does
629 * no check at all.
630 */
631static inline unsigned int __str2ui(const char *s)
632{
633 unsigned int i = 0;
634 while (*s) {
635 i = i * 10 - '0';
636 i += (unsigned char)*s++;
637 }
638 return i;
639}
640
641/* This one is 5 times faster than strtoul() on athlon with checks.
642 * It returns the value of the number composed of all valid digits read.
643 */
644static inline unsigned int __str2uic(const char *s)
645{
646 unsigned int i = 0;
647 unsigned int j;
648 while (1) {
649 j = (*s++) - '0';
650 if (j > 9)
651 break;
652 i *= 10;
653 i += j;
654 }
655 return i;
656}
657
658/* This one is 28 times faster than strtoul() on athlon, but does
659 * no check at all!
660 */
661static inline unsigned int __strl2ui(const char *s, int len)
662{
663 unsigned int i = 0;
664 while (len-- > 0) {
665 i = i * 10 - '0';
666 i += (unsigned char)*s++;
667 }
668 return i;
669}
670
671/* This one is 7 times faster than strtoul() on athlon with checks.
672 * It returns the value of the number composed of all valid digits read.
673 */
674static inline unsigned int __strl2uic(const char *s, int len)
675{
676 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200677 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100678
679 while (len-- > 0) {
680 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200681 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100682 if (j > 9)
683 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200684 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100685 }
686 return i;
687}
688
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200689/* This function reads an unsigned integer from the string pointed to by <s>
690 * and returns it. The <s> pointer is adjusted to point to the first unread
691 * char. The function automatically stops at <end>.
692 */
693static inline unsigned int __read_uint(const char **s, const char *end)
694{
695 const char *ptr = *s;
696 unsigned int i = 0;
697 unsigned int j, k;
698
699 while (ptr < end) {
700 j = *ptr - '0';
701 k = i * 10;
702 if (j > 9)
703 break;
704 i = k + j;
705 ptr++;
706 }
707 *s = ptr;
708 return i;
709}
710
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200711unsigned long long int read_uint64(const char **s, const char *end);
712long long int read_int64(const char **s, const char *end);
713
Willy Tarreau6911fa42007-03-04 18:06:08 +0100714extern unsigned int str2ui(const char *s);
715extern unsigned int str2uic(const char *s);
716extern unsigned int strl2ui(const char *s, int len);
717extern unsigned int strl2uic(const char *s, int len);
718extern int strl2ic(const char *s, int len);
719extern int strl2irc(const char *s, int len, int *ret);
720extern int strl2llrc(const char *s, int len, long long *ret);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100721extern int strl2llrc_dotted(const char *text, int len, long long *ret);
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200722extern unsigned int read_uint(const char **s, const char *end);
Willy Tarreaud54bbdc2009-09-07 11:00:31 +0200723unsigned int inetaddr_host(const char *text);
724unsigned int inetaddr_host_lim(const char *text, const char *stop);
Willy Tarreau74172752010-10-15 23:21:42 +0200725unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret);
Willy Tarreau6911fa42007-03-04 18:06:08 +0100726
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200727static inline char *cut_crlf(char *s) {
728
Simon Horman5269cfb2013-02-13 17:48:00 +0900729 while (*s != '\r' && *s != '\n') {
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200730 char *p = s++;
731
732 if (!*p)
733 return p;
734 }
735
Simon Horman5269cfb2013-02-13 17:48:00 +0900736 *s++ = '\0';
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200737
738 return s;
739}
740
741static inline char *ltrim(char *s, char c) {
742
743 if (c)
744 while (*s == c)
745 s++;
746
747 return s;
748}
749
750static inline char *rtrim(char *s, char c) {
751
752 char *p = s + strlen(s);
753
754 while (p-- > s)
755 if (*p == c)
756 *p = '\0';
757 else
758 break;
759
760 return s;
761}
762
763static inline char *alltrim(char *s, char c) {
764
765 rtrim(s, c);
766
767 return ltrim(s, c);
768}
769
Willy Tarreaufe944602007-10-25 10:34:16 +0200770/* This function converts the time_t value <now> into a broken out struct tm
771 * which must be allocated by the caller. It is highly recommended to use this
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500772 * function instead of localtime() because that one requires a time_t* which
Willy Tarreaufe944602007-10-25 10:34:16 +0200773 * is not always compatible with tv_sec depending on OS/hardware combinations.
774 */
775static inline void get_localtime(const time_t now, struct tm *tm)
776{
777 localtime_r(&now, tm);
778}
779
Emeric Brun3a058f32009-06-30 18:26:00 +0200780/* This function converts the time_t value <now> into a broken out struct tm
781 * which must be allocated by the caller. It is highly recommended to use this
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500782 * function instead of gmtime() because that one requires a time_t* which
Emeric Brun3a058f32009-06-30 18:26:00 +0200783 * is not always compatible with tv_sec depending on OS/hardware combinations.
784 */
785static inline void get_gmtime(const time_t now, struct tm *tm)
786{
787 gmtime_r(&now, tm);
788}
789
Willy Tarreaucb1949b2017-07-19 19:05:29 +0200790/* Counts a number of elapsed days since 01/01/0000 based solely on elapsed
791 * years and assuming the regular rule for leap years applies. It's fake but
792 * serves as a temporary origin. It's worth remembering that it's the first
793 * year of each period that is leap and not the last one, so for instance year
794 * 1 sees 366 days since year 0 was leap. For this reason we have to apply
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500795 * modular arithmetic which is why we offset the year by 399 before
Willy Tarreaucb1949b2017-07-19 19:05:29 +0200796 * subtracting the excess at the end. No overflow here before ~11.7 million
797 * years.
798 */
799static inline unsigned int days_since_zero(unsigned int y)
800{
801 return y * 365 + (y + 399) / 4 - (y + 399) / 100 + (y + 399) / 400
802 - 399 / 4 + 399 / 100;
803}
804
805/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
806 * It is meant as a portable replacement for timegm() for use with valid inputs.
807 * Returns undefined results for invalid dates (eg: months out of range 0..11).
808 */
809extern time_t my_timegm(const struct tm *tm);
810
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100811/* This function parses a time value optionally followed by a unit suffix among
812 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
813 * expected by the caller. The computation does its best to avoid overflows.
814 * The value is returned in <ret> if everything is fine, and a NULL is returned
815 * by the function. In case of error, a pointer to the error is returned and
816 * <ret> is left untouched.
817 */
818extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
Emeric Brun39132b22010-01-04 14:57:24 +0100819extern const char *parse_size_err(const char *text, unsigned *ret);
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100820
Willy Tarreau9faebe32019-06-07 19:00:37 +0200821/* special return values for the time parser */
822#define PARSE_TIME_UNDER ((char *)1)
823#define PARSE_TIME_OVER ((char *)2)
824
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100825/* unit flags to pass to parse_time_err */
826#define TIME_UNIT_US 0x0000
827#define TIME_UNIT_MS 0x0001
828#define TIME_UNIT_S 0x0002
829#define TIME_UNIT_MIN 0x0003
830#define TIME_UNIT_HOUR 0x0004
831#define TIME_UNIT_DAY 0x0005
832#define TIME_UNIT_MASK 0x0007
833
William Lallemand421f5b52012-02-06 18:15:57 +0100834#define SEC 1
835#define MINUTE (60 * SEC)
836#define HOUR (60 * MINUTE)
837#define DAY (24 * HOUR)
838
Willy Tarreau7f062c42009-03-05 18:43:00 +0100839/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
840 * This is used to compute fixed ratios by setting one of the operands to
841 * (2^32*ratio).
842 */
843static inline unsigned int mul32hi(unsigned int a, unsigned int b)
844{
845 return ((unsigned long long)a * b) >> 32;
846}
847
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200848/* gcc does not know when it can safely divide 64 bits by 32 bits. Use this
849 * function when you know for sure that the result fits in 32 bits, because
850 * it is optimal on x86 and on 64bit processors.
851 */
852static inline unsigned int div64_32(unsigned long long o1, unsigned int o2)
853{
Willy Tarreau09568fd2020-04-23 17:08:02 +0200854 unsigned long long result;
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200855#ifdef __i386__
856 asm("divl %2"
Willy Tarreau09568fd2020-04-23 17:08:02 +0200857 : "=A" (result)
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200858 : "A"(o1), "rm"(o2));
859#else
860 result = o1 / o2;
861#endif
862 return result;
863}
864
Willy Tarreaucafa56e2019-02-02 20:17:31 +0100865/* Simple popcountl implementation. It returns the number of ones in a word.
866 * Described here : https://graphics.stanford.edu/~seander/bithacks.html
867 */
David Carliere6c39412015-07-02 07:00:17 +0000868static inline unsigned int my_popcountl(unsigned long a)
Willy Tarreau37994f02012-11-19 12:11:07 +0100869{
Willy Tarreaucafa56e2019-02-02 20:17:31 +0100870 a = a - ((a >> 1) & ~0UL/3);
871 a = (a & ~0UL/15*3) + ((a >> 2) & ~0UL/15*3);
872 a = (a + (a >> 4)) & ~0UL/255*15;
873 return (unsigned long)(a * (~0UL/255)) >> (sizeof(unsigned long) - 1) * 8;
Willy Tarreau37994f02012-11-19 12:11:07 +0100874}
875
Willy Tarreau98d334b2018-10-15 09:33:41 +0200876/* returns non-zero if <a> has at least 2 bits set */
877static inline unsigned long atleast2(unsigned long a)
878{
879 return a & (a - 1);
880}
881
Christopher Fauletff813182017-11-22 15:00:13 +0100882/* Simple ffs implementation. It returns the position of the lowest bit set to
Willy Tarreaud87a67f2019-03-05 12:04:55 +0100883 * one, starting at 1. It is illegal to call it with a==0 (undefined result).
Willy Tarreau27346b02018-10-10 19:05:56 +0200884 */
Christopher Fauletff813182017-11-22 15:00:13 +0100885static inline unsigned int my_ffsl(unsigned long a)
886{
Willy Tarreau27346b02018-10-10 19:05:56 +0200887 unsigned long cnt;
Christopher Fauletff813182017-11-22 15:00:13 +0100888
Willy Tarreau27346b02018-10-10 19:05:56 +0200889#if defined(__x86_64__)
Willy Tarreauce487aa2018-10-29 16:09:57 +0100890 __asm__("bsf %1,%0\n" : "=r" (cnt) : "rm" (a));
Willy Tarreau27346b02018-10-10 19:05:56 +0200891 cnt++;
892#else
Christopher Fauletff813182017-11-22 15:00:13 +0100893
894 cnt = 1;
895#if LONG_MAX > 0x7FFFFFFFL /* 64bits */
896 if (!(a & 0xFFFFFFFFUL)) {
897 a >>= 32;
898 cnt += 32;
899 }
900#endif
901 if (!(a & 0XFFFFU)) {
902 a >>= 16;
903 cnt += 16;
904 }
905 if (!(a & 0XFF)) {
906 a >>= 8;
907 cnt += 8;
908 }
909 if (!(a & 0xf)) {
910 a >>= 4;
911 cnt += 4;
912 }
913 if (!(a & 0x3)) {
914 a >>= 2;
915 cnt += 2;
916 }
917 if (!(a & 0x1)) {
Christopher Fauletff813182017-11-22 15:00:13 +0100918 cnt += 1;
919 }
Willy Tarreau27346b02018-10-10 19:05:56 +0200920#endif /* x86_64 */
Christopher Fauletff813182017-11-22 15:00:13 +0100921
922 return cnt;
923}
924
Willy Tarreaud87a67f2019-03-05 12:04:55 +0100925/* Simple fls implementation. It returns the position of the highest bit set to
926 * one, starting at 1. It is illegal to call it with a==0 (undefined result).
927 */
928static inline unsigned int my_flsl(unsigned long a)
929{
930 unsigned long cnt;
931
932#if defined(__x86_64__)
933 __asm__("bsr %1,%0\n" : "=r" (cnt) : "rm" (a));
934 cnt++;
935#else
936
937 cnt = 1;
938#if LONG_MAX > 0x7FFFFFFFUL /* 64bits */
939 if (a & 0xFFFFFFFF00000000UL) {
940 a >>= 32;
941 cnt += 32;
942 }
943#endif
944 if (a & 0XFFFF0000U) {
945 a >>= 16;
946 cnt += 16;
947 }
948 if (a & 0XFF00) {
949 a >>= 8;
950 cnt += 8;
951 }
952 if (a & 0xf0) {
953 a >>= 4;
954 cnt += 4;
955 }
956 if (a & 0xc) {
957 a >>= 2;
958 cnt += 2;
959 }
960 if (a & 0x2) {
Willy Tarreaud87a67f2019-03-05 12:04:55 +0100961 cnt += 1;
962 }
963#endif /* x86_64 */
964
965 return cnt;
966}
967
David Carliere6c39412015-07-02 07:00:17 +0000968/* Build a word with the <bits> lower bits set (reverse of my_popcountl) */
Willy Tarreaua9db57e2013-01-18 11:29:29 +0100969static inline unsigned long nbits(int bits)
970{
971 if (--bits < 0)
972 return 0;
973 else
974 return (2UL << bits) - 1;
975}
976
Willy Tarreau7355b042019-06-07 10:42:43 +0200977/* sets bit <bit> into map <map>, which must be long-aligned */
978static inline void ha_bit_set(unsigned long bit, long *map)
979{
980 map[bit / (8 * sizeof(*map))] |= 1UL << (bit & (8 * sizeof(*map) - 1));
981}
982
983/* clears bit <bit> from map <map>, which must be long-aligned */
984static inline void ha_bit_clr(unsigned long bit, long *map)
985{
986 map[bit / (8 * sizeof(*map))] &= ~(1UL << (bit & (8 * sizeof(*map) - 1)));
987}
988
989/* flips bit <bit> from map <map>, which must be long-aligned */
990static inline void ha_bit_flip(unsigned long bit, long *map)
991{
992 map[bit / (8 * sizeof(*map))] ^= 1UL << (bit & (8 * sizeof(*map) - 1));
993}
994
995/* returns non-zero if bit <bit> from map <map> is set, otherwise 0 */
996static inline int ha_bit_test(unsigned long bit, const long *map)
997{
998 return !!(map[bit / (8 * sizeof(*map))] & 1UL << (bit & (8 * sizeof(*map) - 1)));
999}
1000
Willy Tarreau126d4062013-12-03 17:50:47 +01001001/*
1002 * Parse binary string written in hexadecimal (source) and store the decoded
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001003 * result into binstr and set binstrlen to the length of binstr. Memory for
Willy Tarreau126d4062013-12-03 17:50:47 +01001004 * binstr is allocated by the function. In case of error, returns 0 with an
1005 * error message in err.
1006 */
1007int parse_binary(const char *source, char **binstr, int *binstrlen, char **err);
1008
Willy Tarreau946ba592009-05-10 15:41:18 +02001009/* copies at most <n> characters from <src> and always terminates with '\0' */
1010char *my_strndup(const char *src, int n);
1011
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02001012/*
1013 * search needle in haystack
1014 * returns the pointer if found, returns NULL otherwise
1015 */
1016const void *my_memmem(const void *, size_t, const void *, size_t);
1017
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02001018/* get length of the initial segment consiting entirely of bytes within a given
1019 * mask
1020 */
1021size_t my_memspn(const void *, size_t, const void *, size_t);
1022
1023/* get length of the initial segment consiting entirely of bytes not within a
1024 * given mask
1025 */
1026size_t my_memcspn(const void *, size_t, const void *, size_t);
1027
Willy Tarreau482b00d2009-10-04 22:48:42 +02001028/* This function returns the first unused key greater than or equal to <key> in
1029 * ID tree <root>. Zero is returned if no place is found.
1030 */
1031unsigned int get_next_id(struct eb_root *root, unsigned int key);
1032
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01001033/* dump the full tree to <file> in DOT format for debugging purposes. Will
1034 * optionally highlight node <subj> if found, depending on operation <op> :
1035 * 0 : nothing
1036 * >0 : insertion, node/leaf are surrounded in red
1037 * <0 : removal, node/leaf are dashed with no background
1038 * Will optionally add "desc" as a label on the graph if set and non-null.
1039 */
1040void eb32sc_to_file(FILE *file, struct eb_root *root, const struct eb32sc_node *subj,
1041 int op, const char *desc);
Willy Tarreaued3cda02017-11-15 15:04:05 +01001042
Willy Tarreau348238b2010-01-18 15:05:57 +01001043/* This function compares a sample word possibly followed by blanks to another
1044 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
1045 * otherwise zero. This intends to be used when checking HTTP headers for some
1046 * values.
1047 */
1048int word_match(const char *sample, int slen, const char *word, int wlen);
1049
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02001050/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
1051 * or the number of chars read in case of success.
1052 */
1053int buf2ip(const char *buf, size_t len, struct in_addr *dst);
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01001054int buf2ip6(const char *buf, size_t len, struct in6_addr *dst);
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02001055
Willy Tarreauacf95772010-06-14 19:09:21 +02001056/* To be used to quote config arg positions. Returns the string at <ptr>
1057 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
1058 * if ptr is NULL or empty. The string is locally allocated.
1059 */
1060const char *quote_arg(const char *ptr);
1061
Willy Tarreau5b180202010-07-18 10:40:48 +02001062/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
1063int get_std_op(const char *str);
1064
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01001065/* hash a 32-bit integer to another 32-bit integer */
1066extern unsigned int full_hash(unsigned int a);
1067static inline unsigned int __full_hash(unsigned int a)
1068{
1069 /* This function is one of Bob Jenkins' full avalanche hashing
1070 * functions, which when provides quite a good distribution for little
1071 * input variations. The result is quite suited to fit over a 32-bit
1072 * space with enough variations so that a randomly picked number falls
1073 * equally before any server position.
1074 * Check http://burtleburtle.net/bob/hash/integer.html for more info.
1075 */
1076 a = (a+0x7ed55d16) + (a<<12);
1077 a = (a^0xc761c23c) ^ (a>>19);
1078 a = (a+0x165667b1) + (a<<5);
1079 a = (a+0xd3a2646c) ^ (a<<9);
1080 a = (a+0xfd7046c5) + (a<<3);
1081 a = (a^0xb55a4f09) ^ (a>>16);
1082
1083 /* ensure values are better spread all around the tree by multiplying
1084 * by a large prime close to 3/4 of the tree.
1085 */
1086 return a * 3221225473U;
1087}
1088
Willy Tarreauf3241112019-02-26 09:56:22 +01001089/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
1090 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
1091 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
1092 * a popcount variant and is described here :
1093 * https://graphics.stanford.edu/~seander/bithacks.html
1094 */
1095unsigned int mask_find_rank_bit(unsigned int r, unsigned long m);
1096unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
1097 unsigned long a, unsigned long b,
1098 unsigned long c, unsigned long d);
1099void mask_prep_rank_map(unsigned long m,
1100 unsigned long *a, unsigned long *b,
1101 unsigned long *c, unsigned long *d);
1102
Willy Tarreau422a0a52012-10-26 19:47:23 +02001103/* sets the address family to AF_UNSPEC so that is_addr() does not match */
1104static inline void clear_addr(struct sockaddr_storage *addr)
1105{
1106 addr->ss_family = AF_UNSPEC;
1107}
1108
David du Colombier6f5ccb12011-03-10 22:26:24 +01001109/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
1110 * otherwise zero.
1111 */
Willy Tarreau18ca2d42014-05-09 22:40:55 +02001112static inline int is_inet_addr(const struct sockaddr_storage *addr)
David du Colombier6f5ccb12011-03-10 22:26:24 +01001113{
1114 int i;
1115
1116 switch (addr->ss_family) {
1117 case AF_INET:
David du Colombier64e9c902011-03-22 11:39:41 +01001118 return *(int *)&((struct sockaddr_in *)addr)->sin_addr;
David du Colombier6f5ccb12011-03-10 22:26:24 +01001119 case AF_INET6:
1120 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
1121 if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0)
1122 return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i];
1123 }
1124 return 0;
1125}
1126
Willy Tarreau18ca2d42014-05-09 22:40:55 +02001127/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
1128 * or is a unix address, otherwise returns zero.
1129 */
1130static inline int is_addr(const struct sockaddr_storage *addr)
1131{
William Lallemand2fe7dd02018-09-11 16:51:29 +02001132 if (addr->ss_family == AF_UNIX || addr->ss_family == AF_CUST_SOCKPAIR)
Willy Tarreau18ca2d42014-05-09 22:40:55 +02001133 return 1;
1134 else
1135 return is_inet_addr(addr);
1136}
1137
David du Colombier11bcb6c2011-03-24 12:23:00 +01001138/* returns port in network byte order */
1139static inline int get_net_port(struct sockaddr_storage *addr)
1140{
1141 switch (addr->ss_family) {
1142 case AF_INET:
1143 return ((struct sockaddr_in *)addr)->sin_port;
1144 case AF_INET6:
1145 return ((struct sockaddr_in6 *)addr)->sin6_port;
1146 }
1147 return 0;
1148}
1149
1150/* returns port in host byte order */
1151static inline int get_host_port(struct sockaddr_storage *addr)
1152{
1153 switch (addr->ss_family) {
1154 case AF_INET:
1155 return ntohs(((struct sockaddr_in *)addr)->sin_port);
1156 case AF_INET6:
1157 return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
1158 }
1159 return 0;
1160}
1161
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +02001162/* returns address len for <addr>'s family, 0 for unknown families */
1163static inline int get_addr_len(const struct sockaddr_storage *addr)
1164{
1165 switch (addr->ss_family) {
1166 case AF_INET:
1167 return sizeof(struct sockaddr_in);
1168 case AF_INET6:
1169 return sizeof(struct sockaddr_in6);
1170 case AF_UNIX:
1171 return sizeof(struct sockaddr_un);
1172 }
1173 return 0;
1174}
1175
David du Colombier11bcb6c2011-03-24 12:23:00 +01001176/* set port in host byte order */
1177static inline int set_net_port(struct sockaddr_storage *addr, int port)
1178{
1179 switch (addr->ss_family) {
1180 case AF_INET:
1181 ((struct sockaddr_in *)addr)->sin_port = port;
Willy Tarreau4c0fcc22018-09-20 10:48:35 +02001182 break;
David du Colombier11bcb6c2011-03-24 12:23:00 +01001183 case AF_INET6:
1184 ((struct sockaddr_in6 *)addr)->sin6_port = port;
Willy Tarreau4c0fcc22018-09-20 10:48:35 +02001185 break;
David du Colombier11bcb6c2011-03-24 12:23:00 +01001186 }
1187 return 0;
1188}
1189
1190/* set port in network byte order */
1191static inline int set_host_port(struct sockaddr_storage *addr, int port)
1192{
1193 switch (addr->ss_family) {
1194 case AF_INET:
1195 ((struct sockaddr_in *)addr)->sin_port = htons(port);
Willy Tarreau4c0fcc22018-09-20 10:48:35 +02001196 break;
David du Colombier11bcb6c2011-03-24 12:23:00 +01001197 case AF_INET6:
1198 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
Willy Tarreau4c0fcc22018-09-20 10:48:35 +02001199 break;
David du Colombier11bcb6c2011-03-24 12:23:00 +01001200 }
1201 return 0;
1202}
1203
Thierry Fournier70473a52016-02-17 17:12:14 +01001204/* Convert mask from bit length form to in_addr form.
1205 * This function never fails.
1206 */
1207void len2mask4(int len, struct in_addr *addr);
1208
1209/* Convert mask from bit length form to in6_addr form.
1210 * This function never fails.
1211 */
1212void len2mask6(int len, struct in6_addr *addr);
1213
David du Colombier4f92d322011-03-24 11:09:31 +01001214/* Return true if IPv4 address is part of the network */
Willy Tarreaueec1d382016-07-13 11:59:39 +02001215extern int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net);
David du Colombier4f92d322011-03-24 11:09:31 +01001216
1217/* Return true if IPv6 address is part of the network */
Willy Tarreaueec1d382016-07-13 11:59:39 +02001218extern int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net);
David du Colombier4f92d322011-03-24 11:09:31 +01001219
Joseph Herlant32b83272018-11-15 11:58:28 -08001220/* Map IPv4 address on IPv6 address, as specified in RFC 3513. */
David du Colombier4f92d322011-03-24 11:09:31 +01001221extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr);
1222
Joseph Herlant32b83272018-11-15 11:58:28 -08001223/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01001224 * Return true if conversion is possible and false otherwise.
1225 */
1226extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr);
1227
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01001228/* compare two struct sockaddr_storage and return:
1229 * 0 (true) if the addr is the same in both
1230 * 1 (false) if the addr is not the same in both
1231 */
1232int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2);
1233
Baptiste Assmann08396c82016-01-31 00:27:17 +01001234/* copy ip from <source> into <dest>
1235 * the caller must clear <dest> before calling.
1236 * Returns a pointer to the destination
1237 */
1238struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest);
1239
William Lallemand421f5b52012-02-06 18:15:57 +01001240char *human_time(int t, short hz_div);
1241
1242extern const char *monthname[];
1243
1244/* date2str_log: write a date in the format :
1245 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
1246 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
1247 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
1248 *
1249 * without using sprintf. return a pointer to the last char written (\0) or
1250 * NULL if there isn't enough space.
1251 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02001252char *date2str_log(char *dest, const struct tm *tm, const struct timeval *date, size_t size);
William Lallemand421f5b52012-02-06 18:15:57 +01001253
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001254/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001255 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001256 * The string returned has the same format as returned by strftime(... "%z", tm).
1257 * Offsets are kept in an internal cache for better performances.
1258 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001259const char *get_gmt_offset(time_t t, struct tm *tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001260
William Lallemand421f5b52012-02-06 18:15:57 +01001261/* gmt2str_log: write a date in the format :
1262 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
1263 * return a pointer to the last char written (\0) or
1264 * NULL if there isn't enough space.
1265 */
1266char *gmt2str_log(char *dst, struct tm *tm, size_t size);
1267
Yuxans Yao4e25b012012-10-19 10:36:09 +08001268/* localdate2str_log: write a date in the format :
1269 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001270 * Both t and tm must represent the same time.
Yuxans Yao4e25b012012-10-19 10:36:09 +08001271 * return a pointer to the last char written (\0) or
1272 * NULL if there isn't enough space.
1273 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001274char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size);
Yuxans Yao4e25b012012-10-19 10:36:09 +08001275
Thierry Fournier93127942016-01-20 18:49:45 +01001276/* These 3 functions parses date string and fills the
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001277 * corresponding broken-down time in <tm>. In success case,
Thierry Fournier93127942016-01-20 18:49:45 +01001278 * it returns 1, otherwise, it returns 0.
1279 */
1280int parse_http_date(const char *date, int len, struct tm *tm);
1281int parse_imf_date(const char *date, int len, struct tm *tm);
1282int parse_rfc850_date(const char *date, int len, struct tm *tm);
1283int parse_asctime_date(const char *date, int len, struct tm *tm);
1284
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001285/* Dynamically allocates a string of the proper length to hold the formatted
1286 * output. NULL is returned on error. The caller is responsible for freeing the
1287 * memory area using free(). The resulting string is returned in <out> if the
1288 * pointer is not NULL. A previous version of <out> might be used to build the
1289 * new string, and it will be freed before returning if it is not NULL, which
1290 * makes it possible to build complex strings from iterative calls without
1291 * having to care about freeing intermediate values, as in the example below :
1292 *
1293 * memprintf(&err, "invalid argument: '%s'", arg);
1294 * ...
1295 * memprintf(&err, "parser said : <%s>\n", *err);
1296 * ...
1297 * free(*err);
1298 *
1299 * This means that <err> must be initialized to NULL before first invocation.
1300 * The return value also holds the allocated string, which eases error checking
1301 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001302 * passed instead and it will be ignored. The returned message will then also
1303 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001304 *
1305 * It is also convenient to use it without any free except the last one :
1306 * err = NULL;
1307 * if (!fct1(err)) report(*err);
1308 * if (!fct2(err)) report(*err);
1309 * if (!fct3(err)) report(*err);
1310 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02001311 *
1312 * memprintf relies on memvprintf. This last version can be called from any
1313 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001314 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02001315char *memvprintf(char **out, const char *format, va_list args)
1316 __attribute__ ((format(printf, 2, 0)));
1317
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001318char *memprintf(char **out, const char *format, ...)
1319 __attribute__ ((format(printf, 2, 3)));
1320
Willy Tarreau21c705b2012-09-14 11:40:36 +02001321/* Used to add <level> spaces before each line of <out>, unless there is only one line.
1322 * The input argument is automatically freed and reassigned. The result will have to be
1323 * freed by the caller.
1324 * Example of use :
1325 * parse(cmd, &err); (callee: memprintf(&err, ...))
1326 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
1327 * free(err);
1328 */
1329char *indent_msg(char **out, int level);
Willy Tarreaua2c99112019-08-21 13:17:37 +02001330int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first);
Willy Tarreau3d2f16f2012-05-13 00:21:17 +02001331
Willy Tarreau9d22e562019-03-29 18:49:09 +01001332/* removes environment variable <name> from the environment as found in
1333 * environ. This is only provided as an alternative for systems without
1334 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001335 * The principle is to scan environ for each occurrence of variable name
Willy Tarreau9d22e562019-03-29 18:49:09 +01001336 * <name> and to replace the matching pointers with the last pointer of
1337 * the array (since variables are not ordered).
1338 * It always returns 0 (success).
1339 */
1340int my_unsetenv(const char *name);
1341
Willy Tarreaudad36a32013-03-11 01:20:04 +01001342/* Convert occurrences of environment variables in the input string to their
1343 * corresponding value. A variable is identified as a series of alphanumeric
1344 * characters or underscores following a '$' sign. The <in> string must be
1345 * free()able. NULL returns NULL. The resulting string might be reallocated if
1346 * some expansion is made.
1347 */
1348char *env_expand(char *in);
1349
Willy Tarreau3d2f16f2012-05-13 00:21:17 +02001350/* debugging macro to emit messages using write() on fd #-1 so that strace sees
1351 * them.
1352 */
1353#define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0)
1354
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001355/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02001356 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
1357 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001358 */
Willy Tarreaued936c52017-04-27 18:03:20 +02001359void debug_hexdump(FILE *out, const char *pfx, const char *buf, unsigned int baseaddr, int len);
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001360
Willy Tarreau9eebd8a2019-08-08 16:53:40 +02001361/* this is used to emit call traces when building with TRACE=1 */
Willy Tarreau12963822017-10-24 10:54:08 +02001362__attribute__((format(printf, 1, 2)))
Willy Tarreau9eebd8a2019-08-08 16:53:40 +02001363void calltrace(char *fmt, ...);
Willy Tarreau12963822017-10-24 10:54:08 +02001364
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02001365/* same as strstr() but case-insensitive */
1366const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2);
1367
Willy Tarreauab813a42018-09-10 18:41:28 +02001368/* after increasing a pointer value, it can exceed the first buffer
1369 * size. This function transform the value of <ptr> according with
1370 * the expected position. <chunks> is an array of the one or two
Joseph Herlant32b83272018-11-15 11:58:28 -08001371 * available chunks. The first value is the start of the first chunk,
Willy Tarreauab813a42018-09-10 18:41:28 +02001372 * the second value if the end+1 of the first chunks. The third value
1373 * is NULL or the start of the second chunk and the fourth value is
1374 * the end+1 of the second chunk. The function returns 1 if does a
1375 * wrap, else returns 0.
1376 */
1377static inline int fix_pointer_if_wrap(const char **chunks, const char **ptr)
1378{
1379 if (*ptr < chunks[1])
1380 return 0;
1381 if (!chunks[2])
1382 return 0;
1383 *ptr = chunks[2] + ( *ptr - chunks[1] );
1384 return 1;
1385}
Willy Tarreaubb519c72014-01-28 23:04:39 +01001386
1387/************************* Composite address manipulation *********************
1388 * Composite addresses are simply unsigned long data in which the higher bits
1389 * represent a pointer, and the two lower bits are flags. There are several
1390 * places where we just want to associate one or two flags to a pointer (eg,
1391 * to type it), and these functions permit this. The pointer is necessarily a
1392 * 32-bit aligned pointer, as its two lower bits will be cleared and replaced
1393 * with the flags.
1394 *****************************************************************************/
1395
1396/* Masks the two lower bits of a composite address and converts it to a
1397 * pointer. This is used to mix some bits with some aligned pointers to
1398 * structs and to retrieve the original (32-bit aligned) pointer.
1399 */
1400static inline void *caddr_to_ptr(unsigned long caddr)
1401{
1402 return (void *)(caddr & ~3UL);
1403}
1404
1405/* Only retrieves the two lower bits of a composite address. This is used to mix
1406 * some bits with some aligned pointers to structs and to retrieve the original
1407 * data (2 bits).
1408 */
1409static inline unsigned int caddr_to_data(unsigned long caddr)
1410{
1411 return (caddr & 3UL);
1412}
1413
1414/* Combines the aligned pointer whose 2 lower bits will be masked with the bits
1415 * from <data> to form a composite address. This is used to mix some bits with
1416 * some aligned pointers to structs and to retrieve the original (32-bit aligned)
1417 * pointer.
1418 */
1419static inline unsigned long caddr_from_ptr(void *ptr, unsigned int data)
1420{
1421 return (((unsigned long)ptr) & ~3UL) + (data & 3);
1422}
1423
1424/* sets the 2 bits of <data> in the <caddr> composite address */
1425static inline unsigned long caddr_set_flags(unsigned long caddr, unsigned int data)
1426{
1427 return caddr | (data & 3);
1428}
1429
1430/* clears the 2 bits of <data> in the <caddr> composite address */
1431static inline unsigned long caddr_clr_flags(unsigned long caddr, unsigned int data)
1432{
1433 return caddr & ~(unsigned long)(data & 3);
1434}
1435
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001436/* UTF-8 decoder status */
1437#define UTF8_CODE_OK 0x00
1438#define UTF8_CODE_OVERLONG 0x10
1439#define UTF8_CODE_INVRANGE 0x20
1440#define UTF8_CODE_BADSEQ 0x40
1441
1442unsigned char utf8_next(const char *s, int len, unsigned int *c);
1443
1444static inline unsigned char utf8_return_code(unsigned int code)
1445{
1446 return code & 0xf0;
1447}
1448
1449static inline unsigned char utf8_return_length(unsigned char code)
1450{
1451 return code & 0x0f;
1452}
1453
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001454/* Turns 64-bit value <a> from host byte order to network byte order.
1455 * The principle consists in letting the compiler detect we're playing
1456 * with a union and simplify most or all operations. The asm-optimized
1457 * htonl() version involving bswap (x86) / rev (arm) / other is a single
1458 * operation on little endian, or a NOP on big-endian. In both cases,
1459 * this lets the compiler "see" that we're rebuilding a 64-bit word from
1460 * two 32-bit quantities that fit into a 32-bit register. In big endian,
1461 * the whole code is optimized out. In little endian, with a decent compiler,
1462 * a few bswap and 2 shifts are left, which is the minimum acceptable.
1463 */
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001464static inline unsigned long long my_htonll(unsigned long long a)
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001465{
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001466#if defined(__x86_64__)
Willy Tarreaudea7c5c2017-10-18 11:39:33 +02001467 __asm__ volatile("bswap %0" : "=r"(a) : "0"(a));
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001468 return a;
1469#else
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001470 union {
1471 struct {
1472 unsigned int w1;
1473 unsigned int w2;
1474 } by32;
1475 unsigned long long by64;
1476 } w = { .by64 = a };
1477 return ((unsigned long long)htonl(w.by32.w1) << 32) | htonl(w.by32.w2);
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001478#endif
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001479}
1480
1481/* Turns 64-bit value <a> from network byte order to host byte order. */
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001482static inline unsigned long long my_ntohll(unsigned long long a)
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001483{
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001484 return my_htonll(a);
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001485}
1486
Willy Tarreaue6e49cf2015-04-29 17:13:35 +02001487/* returns a 64-bit a timestamp with the finest resolution available. The
1488 * unit is intentionally not specified. It's mostly used to compare dates.
1489 */
1490#if defined(__i386__) || defined(__x86_64__)
1491static inline unsigned long long rdtsc()
1492{
1493 unsigned int a, d;
1494 asm volatile("rdtsc" : "=a" (a), "=d" (d));
1495 return a + ((unsigned long long)d << 32);
1496}
1497#else
1498static inline unsigned long long rdtsc()
1499{
1500 struct timeval tv;
1501 gettimeofday(&tv, NULL);
1502 return tv.tv_sec * 1000000 + tv.tv_usec;
1503}
1504#endif
1505
Maxime de Roucydc887852016-05-13 23:52:54 +02001506/* append a copy of string <str> (in a wordlist) at the end of the list <li>
1507 * On failure : return 0 and <err> filled with an error message.
1508 * The caller is responsible for freeing the <err> and <str> copy
1509 * memory area using free()
1510 */
1511struct list;
1512int list_append_word(struct list *li, const char *str, char **err);
1513
Willy Tarreau83061a82018-07-13 11:56:34 +02001514int dump_text(struct buffer *out, const char *buf, int bsize);
1515int dump_binary(struct buffer *out, const char *buf, int bsize);
1516int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01001517 int *line, int ptr);
Willy Tarreau762fb3e2020-03-03 15:57:10 +01001518void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n);
Willy Tarreau37101052019-05-20 16:48:20 +02001519void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe);
1520int may_access(const void *ptr);
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01001521void *resolve_sym_name(struct buffer *buf, const char *pfx, void *addr);
Willy Tarreaubb869862020-04-16 10:52:41 +02001522const char *get_exec_path();
Willy Tarreau97c2ae12016-11-22 18:00:20 +01001523
Willy Tarreau13faf162020-03-04 07:44:06 +01001524#if defined(USE_BACKTRACE)
1525/* Note that this may result in opening libgcc() on first call, so it may need
1526 * to have been called once before chrooting.
1527 */
1528static forceinline int my_backtrace(void **buffer, int max)
1529{
1530#ifdef HA_HAVE_WORKING_BACKTRACE
1531 return backtrace(buffer, max);
1532#else
1533 const struct frame {
1534 const struct frame *next;
1535 void *ra;
1536 } *frame;
1537 int count;
1538
1539 frame = __builtin_frame_address(0);
1540 for (count = 0; count < max && may_access(frame) && may_access(frame->ra);) {
1541 buffer[count++] = frame->ra;
1542 frame = frame->next;
1543 }
1544 return count;
1545#endif
1546}
1547#endif
1548
Hubert Verstraete2eae3a02016-06-28 22:41:00 +02001549/* same as realloc() except that ptr is also freed upon failure */
1550static inline void *my_realloc2(void *ptr, size_t size)
1551{
1552 void *ret;
1553
1554 ret = realloc(ptr, size);
1555 if (!ret && size)
1556 free(ptr);
1557 return ret;
1558}
1559
Frédéric Lécaille3b717162019-02-25 15:04:22 +01001560int parse_dotted_uints(const char *s, unsigned int **nums, size_t *sz);
1561
Willy Tarreau52bf8392020-03-08 00:42:37 +01001562/* PRNG */
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01001563void ha_generate_uuid(struct buffer *output);
Willy Tarreau52bf8392020-03-08 00:42:37 +01001564void ha_random_seed(const unsigned char *seed, size_t len);
1565void ha_random_jump96(uint32_t dist);
1566uint64_t ha_random64();
1567
1568static inline uint32_t ha_random32()
1569{
1570 return ha_random64() >> 32;
1571}
1572
1573static inline int32_t ha_random()
1574{
1575 return ha_random32() >> 1;
1576}
1577
Lukas Tribusdcbc5c52016-09-12 21:42:07 +00001578/* HAP_STRING() makes a string from a literal while HAP_XSTRING() first
1579 * evaluates the argument and is suited to pass macros.
1580 *
1581 * They allow macros like PCRE_MAJOR to be defined without quotes, which
1582 * is convenient for applications that want to test its value.
1583 */
1584#define HAP_STRING(...) #__VA_ARGS__
1585#define HAP_XSTRING(...) HAP_STRING(__VA_ARGS__)
1586
Willy Tarreau2dd0d472006-06-29 17:53:05 +02001587#endif /* _COMMON_STANDARD_H */