blob: 7af9c25ceb44bb8b462e244001c63055a86535ab [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 Tarreau167d8b52007-04-09 22:16:12 +020025#include <limits.h>
Willy Tarreau050737f2010-01-14 11:40:12 +010026#include <string.h>
Willy Tarreau0ebb5112016-12-05 00:10:57 +010027#include <stdio.h>
Willy Tarreaufe944602007-10-25 10:34:16 +020028#include <time.h>
David Carlier5222d8e2017-11-03 12:00:26 +000029#include <stdarg.h>
Willy Tarreaue6e49cf2015-04-29 17:13:35 +020030#include <sys/time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020031#include <sys/types.h>
Willy Tarreaud50265a2012-09-04 14:18:33 +020032#include <sys/socket.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020033#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <netinet/in.h>
Willy Tarreau5b4dd682015-07-21 23:47:18 +020035#include <arpa/inet.h>
Thierry FOURNIERe059ec92014-03-17 12:01:13 +010036#include <common/chunk.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020037#include <common/config.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020038#include <common/namespace.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010039#include <eb32tree.h>
Willy Tarreau9c1e15d2017-11-15 18:51:29 +010040#include <eb32sctree.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020041
William Lallemande7340ec2012-01-24 11:15:39 +010042#ifndef LLONG_MAX
43# define LLONG_MAX 9223372036854775807LL
44# define LLONG_MIN (-LLONG_MAX - 1LL)
45#endif
46
47#ifndef ULLONG_MAX
48# define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
49#endif
50
Willy Tarreaua9db57e2013-01-18 11:29:29 +010051#ifndef LONGBITS
52#define LONGBITS ((unsigned int)sizeof(long) * 8)
53#endif
54
Thierry FOURNIER511e9472014-01-23 17:40:34 +010055/* size used for max length of decimal representation of long long int. */
56#define NB_LLMAX_STR (sizeof("-9223372036854775807")-1)
57
Willy Tarreau56adcf22012-12-23 18:00:29 +010058/* number of itoa_str entries */
59#define NB_ITOA_STR 10
William Lallemande7340ec2012-01-24 11:15:39 +010060
Willy Tarreau588297f2014-06-16 15:16:40 +020061/* maximum quoted string length (truncated above) */
62#define QSTR_SIZE 200
63#define NB_QSTR 10
64
Willy Tarreaubaaee002006-06-26 02:48:02 +020065/****** string-specific macros and functions ******/
66/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
67#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
68
69/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
70#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
71
72/* returns 1 only if only zero or one bit is set in X, which means that X is a
73 * power of 2, and 0 otherwise */
74#define POWEROF2(x) (((x) & ((x)-1)) == 0)
75
Willy Tarreau5b180202010-07-18 10:40:48 +020076/* operators to compare values. They're ordered that way so that the lowest bit
77 * serves as a negation for the test and contains all tests that are not equal.
78 */
79enum {
80 STD_OP_LE = 0, STD_OP_GT = 1,
81 STD_OP_EQ = 2, STD_OP_NE = 3,
82 STD_OP_GE = 4, STD_OP_LT = 5,
83};
84
Thierry FOURNIER9f95e402014-03-21 14:51:46 +010085enum http_scheme {
86 SCH_HTTP,
87 SCH_HTTPS,
88};
89
90struct split_url {
91 enum http_scheme scheme;
92 const char *host;
93 int host_len;
94};
95
Christopher Faulet99bca652017-11-14 16:47:26 +010096extern THREAD_LOCAL int itoa_idx; /* index of next itoa_str to use */
Willy Tarreau56adcf22012-12-23 18:00:29 +010097
Willy Tarreau7d58a632007-01-13 23:06:06 +010098/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020099 * copies at most <size-1> chars from <src> to <dst>. Last char is always
100 * set to 0, unless <size> is 0. The number of chars copied is returned
101 * (excluding the terminating zero).
102 * This code has been optimized for size and speed : on x86, it's 45 bytes
103 * long, uses only registers, and consumes only 4 cycles per char.
104 */
105extern int strlcpy2(char *dst, const char *src, int size);
106
107/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200108 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200109 * the ascii representation for number 'n' in decimal.
110 */
Christopher Faulet99bca652017-11-14 16:47:26 +0100111extern THREAD_LOCAL char itoa_str[][171];
Emeric Brun3a7fce52010-01-04 14:54:38 +0100112extern char *ultoa_r(unsigned long n, char *buffer, int size);
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200113extern char *lltoa_r(long long int n, char *buffer, int size);
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200114extern char *sltoa_r(long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +0200115extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +0200116static inline const char *ultoa(unsigned long n)
117{
118 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
119}
120
William Lallemande7340ec2012-01-24 11:15:39 +0100121/*
122 * unsigned long long ASCII representation
123 *
124 * return the last char '\0' or NULL if no enough
125 * space in dst
126 */
127char *ulltoa(unsigned long long n, char *dst, size_t size);
128
129
130/*
131 * unsigned long ASCII representation
132 *
133 * return the last char '\0' or NULL if no enough
134 * space in dst
135 */
136char *ultoa_o(unsigned long n, char *dst, size_t size);
137
138/*
139 * signed long ASCII representation
140 *
141 * return the last char '\0' or NULL if no enough
142 * space in dst
143 */
144char *ltoa_o(long int n, char *dst, size_t size);
145
146/*
147 * signed long long ASCII representation
148 *
149 * return the last char '\0' or NULL if no enough
150 * space in dst
151 */
152char *lltoa(long long n, char *dst, size_t size);
153
154/*
155 * write a ascii representation of a unsigned into dst,
156 * return a pointer to the last character
157 * Pad the ascii representation with '0', using size.
158 */
159char *utoa_pad(unsigned int n, char *dst, size_t size);
160
Willy Tarreaubaaee002006-06-26 02:48:02 +0200161/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200162 * This function simply returns a locally allocated string containing the ascii
163 * representation for number 'n' in decimal, unless n is 0 in which case it
164 * returns the alternate string (or an empty string if the alternate string is
165 * NULL). It use is intended for limits reported in reports, where it's
166 * desirable not to display anything if there is no limit. Warning! it shares
167 * the same vector as ultoa_r().
168 */
169extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
170
Willy Tarreau56adcf22012-12-23 18:00:29 +0100171/* returns a locally allocated string containing the ASCII representation of
172 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
173 * function call (eg: printf), shared with the other similar functions making
174 * use of itoa_str[].
175 */
176static inline const char *U2A(unsigned long n)
177{
178 const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
179 if (++itoa_idx >= NB_ITOA_STR)
180 itoa_idx = 0;
181 return ret;
182}
183
184/* returns a locally allocated string containing the HTML representation of
185 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
186 * function call (eg: printf), shared with the other similar functions making
187 * use of itoa_str[].
Willy Tarreau91092e52007-10-25 16:58:42 +0200188 */
Willy Tarreau56adcf22012-12-23 18:00:29 +0100189static inline const char *U2H(unsigned long long n)
190{
191 const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
192 if (++itoa_idx >= NB_ITOA_STR)
193 itoa_idx = 0;
194 return ret;
195}
196
197/* returns a locally allocated string containing the HTML representation of
198 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
199 * function call (eg: printf), shared with the other similar functions making
200 * use of itoa_str[].
201 */
202static inline const char *LIM2A(unsigned long n, const char *alt)
203{
204 const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt);
205 if (++itoa_idx >= NB_ITOA_STR)
206 itoa_idx = 0;
207 return ret;
208}
Willy Tarreau91092e52007-10-25 16:58:42 +0200209
Thierry FOURNIER6ab2bae2017-04-19 11:49:44 +0200210/* Encode the integer <i> into a varint (variable-length integer). The encoded
211 * value is copied in <*buf>. Here is the encoding format:
212 *
213 * 0 <= X < 240 : 1 byte (7.875 bits) [ XXXX XXXX ]
214 * 240 <= X < 2288 : 2 bytes (11 bits) [ 1111 XXXX ] [ 0XXX XXXX ]
215 * 2288 <= X < 264432 : 3 bytes (18 bits) [ 1111 XXXX ] [ 1XXX XXXX ] [ 0XXX XXXX ]
216 * 264432 <= X < 33818864 : 4 bytes (25 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*2 [ 0XXX XXXX ]
217 * 33818864 <= X < 4328786160 : 5 bytes (32 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*3 [ 0XXX XXXX ]
218 * ...
219 *
220 * On success, it returns the number of written bytes and <*buf> is moved after
221 * the encoded value. Otherwise, it returns -1. */
222static inline int
223encode_varint(uint64_t i, char **buf, char *end)
224{
225 unsigned char *p = (unsigned char *)*buf;
226 int r;
227
228 if (p >= (unsigned char *)end)
229 return -1;
230
231 if (i < 240) {
232 *p++ = i;
233 *buf = (char *)p;
234 return 1;
235 }
236
237 *p++ = (unsigned char)i | 240;
238 i = (i - 240) >> 4;
239 while (i >= 128) {
240 if (p >= (unsigned char *)end)
241 return -1;
242 *p++ = (unsigned char)i | 128;
243 i = (i - 128) >> 7;
244 }
245
246 if (p >= (unsigned char *)end)
247 return -1;
248 *p++ = (unsigned char)i;
249
250 r = ((char *)p - *buf);
251 *buf = (char *)p;
252 return r;
253}
254
255/* Decode a varint from <*buf> and save the decoded value in <*i>. See
256 * 'spoe_encode_varint' for details about varint.
257 * On success, it returns the number of read bytes and <*buf> is moved after the
258 * varint. Otherwise, it returns -1. */
259static inline int
260decode_varint(char **buf, char *end, uint64_t *i)
261{
262 unsigned char *p = (unsigned char *)*buf;
263 int r;
264
265 if (p >= (unsigned char *)end)
266 return -1;
267
268 *i = *p++;
269 if (*i < 240) {
270 *buf = (char *)p;
271 return 1;
272 }
273
274 r = 4;
275 do {
276 if (p >= (unsigned char *)end)
277 return -1;
278 *i += (uint64_t)*p << r;
279 r += 7;
280 } while (*p++ >= 128);
281
282 r = ((char *)p - *buf);
283 *buf = (char *)p;
284 return r;
285}
286
Willy Tarreau588297f2014-06-16 15:16:40 +0200287/* returns a locally allocated string containing the quoted encoding of the
288 * input string. The output may be truncated to QSTR_SIZE chars, but it is
289 * guaranteed that the string will always be properly terminated. Quotes are
290 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
291 * always be at least 4 chars.
292 */
293const char *qstr(const char *str);
294
295/* returns <str> or its quote-encoded equivalent if it contains at least one
296 * quote or a comma. This is aimed at build CSV-compatible strings.
297 */
298static inline const char *cstr(const char *str)
299{
300 const char *p = str;
301
302 while (*p) {
303 if (*p == ',' || *p == '"')
304 return qstr(str);
305 p++;
306 }
307 return str;
308}
309
Willy Tarreau91092e52007-10-25 16:58:42 +0200310/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200311 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
312 */
313extern int ishex(char s);
314
315/*
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100316 * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F),
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200317 * otherwise -1. This compact form helps gcc produce efficient code.
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100318 */
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200319static inline int hex2i(int c)
320{
Willy Tarreauaa398602017-11-10 11:19:54 +0100321 if ((unsigned char)(c -= '0') > 9) {
322 if ((unsigned char)(c -= 'A' - '0') > 5 &&
323 (unsigned char)(c -= 'a' - 'A') > 5)
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200324 c = -11;
325 c += 10;
326 }
327 return c;
328}
329
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100330/* rounds <i> down to the closest value having max 2 digits */
331unsigned int round_2dig(unsigned int i);
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100332
333/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100334 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
335 * invalid character is found, a pointer to it is returned. If everything is
336 * fine, NULL is returned.
337 */
338extern const char *invalid_char(const char *name);
339
340/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200341 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200342 * If an invalid character is found, a pointer to it is returned.
343 * If everything is fine, NULL is returned.
344 */
345extern const char *invalid_domainchar(const char *name);
346
347/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200348 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
349 * If an invalid character is found, a pointer to it is returned.
350 * If everything is fine, NULL is returned.
351 */
352extern const char *invalid_prefix_char(const char *name);
353
354/*
Willy Tarreaufab5a432011-03-04 15:31:53 +0100355 * converts <str> to a locally allocated struct sockaddr_storage *, and a
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200356 * port range consisting in two integers. The low and high end are always set
357 * even if the port is unspecified, in which case (0,0) is returned. The low
Willy Tarreaufab5a432011-03-04 15:31:53 +0100358 * port is set in the sockaddr. Thus, it is enough to check the size of the
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200359 * returned range to know if an array must be allocated or not. The format is
Willy Tarreaufab5a432011-03-04 15:31:53 +0100360 * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6
361 * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6
362 * address wants to ignore port, it must be terminated by a trailing colon (':').
363 * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on
364 * IPv6, use ":::port". NULL is returned if the host part cannot be resolved.
Willy Tarreaud393a622013-03-04 18:22:00 +0100365 * If <pfx> is non-null, it is used as a string prefix before any path-based
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200366 * address (typically the path to a unix socket). If use_dns is not true,
367 * the funtion cannot accept the DNS resolution.
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200368 */
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100369struct sockaddr_storage *str2sa_range(const char *str,
370 int *port, int *low, int *high,
371 char **err, const char *pfx,
372 char **fqdn, int resolve);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200373
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100374/* converts <str> to a struct in_addr containing a network mask. It can be
375 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +0300376 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100377 */
378int str2mask(const char *str, struct in_addr *mask);
379
Tim Duesterhus47185172018-01-25 16:24:49 +0100380/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +0100381 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +0100382 * if the conversion succeeds otherwise zero.
383 */
384int str2mask6(const char *str, struct in6_addr *mask);
385
Thierry FOURNIERb0504632013-12-14 15:39:02 +0100386/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
387 * succeeds otherwise non-zero.
388 */
389int cidr2dotted(int cidr, struct in_addr *mask);
390
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200391/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200392 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200393 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
394 * is optionnal and either in the dotted or CIDR notation.
395 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
396 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +0100397int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200398
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100399/* str2ip and str2ip2:
400 *
401 * converts <str> to a struct sockaddr_storage* provided by the caller. The
402 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
403 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
404 * the function tries to guess the address family from the syntax. If the
405 * family is forced and the format doesn't match, an error is returned. The
406 * string is assumed to contain only an address, no port. The address can be a
407 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
408 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
409 * The return address will only have the address family and the address set,
410 * all other fields remain zero. The string is not supposed to be modified.
411 * The IPv6 '::' address is IN6ADDR_ANY.
412 *
413 * str2ip2:
414 *
415 * If <resolve> is set, this function try to resolve DNS, otherwise, it returns
416 * NULL result.
417 */
418struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve);
419static inline struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa)
420{
421 return str2ip2(str, sa, 1);
422}
423
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100424/*
Willy Tarreau6d20e282012-04-27 22:49:47 +0200425 * converts <str> to two struct in6_addr* which must be pre-allocated.
426 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
427 * is an optionnal number of bits (128 being the default).
428 * Returns 1 if OK, 0 if error.
429 */
430int str62net(const char *str, struct in6_addr *addr, unsigned char *mask);
431
432/*
Willy Tarreau106f9792009-09-19 07:54:16 +0200433 * Parse IP address found in url.
434 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100435int url2ipv4(const char *addr, struct in_addr *dst);
Willy Tarreau106f9792009-09-19 07:54:16 +0200436
437/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100438 * Resolve destination server from URL. Convert <str> to a sockaddr_storage*.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100439 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +0100440int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100441
Willy Tarreau631f01c2011-09-05 00:36:48 +0200442/* Tries to convert a sockaddr_storage address to text form. Upon success, the
443 * address family is returned so that it's easy for the caller to adapt to the
444 * output format. Zero is returned if the address family is not supported. -1
445 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
446 * supported.
447 */
448int addr_to_str(struct sockaddr_storage *addr, char *str, int size);
449
Simon Horman75ab8bd2014-06-16 09:39:41 +0900450/* Tries to convert a sockaddr_storage port to text form. Upon success, the
451 * address family is returned so that it's easy for the caller to adapt to the
452 * output format. Zero is returned if the address family is not supported. -1
453 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
454 * supported.
455 */
456int port_to_str(struct sockaddr_storage *addr, char *str, int size);
457
Willy Tarreau16e01562016-08-09 16:46:18 +0200458/* check if the given address is local to the system or not. It will return
459 * -1 when it's not possible to know, 0 when the address is not local, 1 when
460 * it is. We don't want to iterate over all interfaces for this (and it is not
461 * portable). So instead we try to bind in UDP to this address on a free non
462 * privileged port and to connect to the same address, port 0 (connect doesn't
463 * care). If it succeeds, we own the address. Note that non-inet addresses are
464 * considered local since they're most likely AF_UNIX.
465 */
466int addr_is_local(const struct netns_entry *ns,
467 const struct sockaddr_storage *orig);
468
Willy Tarreaubaaee002006-06-26 02:48:02 +0200469/* will try to encode the string <string> replacing all characters tagged in
470 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
471 * prefixed by <escape>, and will store the result between <start> (included)
472 * and <stop> (excluded), and will always terminate the string with a '\0'
473 * before <stop>. The position of the '\0' is returned if the conversion
474 * completes. If bytes are missing between <start> and <stop>, then the
475 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
476 * cannot even be stored so we return <start> without writing the 0.
477 * The input string must also be zero-terminated.
478 */
479extern const char hextab[];
480char *encode_string(char *start, char *stop,
481 const char escape, const fd_set *map,
482 const char *string);
483
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100484/*
485 * Same behavior, except that it encodes chunk <chunk> instead of a string.
486 */
487char *encode_chunk(char *start, char *stop,
488 const char escape, const fd_set *map,
Willy Tarreau83061a82018-07-13 11:56:34 +0200489 const struct buffer *chunk);
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100490
Dragan Dosen0edd1092016-02-12 13:23:02 +0100491/*
492 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +0200493 * character. The input <string> must be zero-terminated. The result will
494 * be stored between <start> (included) and <stop> (excluded). This
495 * function will always try to terminate the resulting string with a '\0'
496 * before <stop>, and will return its position if the conversion
497 * completes.
498 */
499char *escape_string(char *start, char *stop,
500 const char escape, const fd_set *map,
501 const char *string);
502
503/*
504 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +0100505 * character. <chunk> contains the input to be escaped. The result will be
506 * stored between <start> (included) and <stop> (excluded). The function
507 * will always try to terminate the resulting string with a '\0' before
508 * <stop>, and will return its position if the conversion completes.
509 */
510char *escape_chunk(char *start, char *stop,
511 const char escape, const fd_set *map,
Willy Tarreau83061a82018-07-13 11:56:34 +0200512 const struct buffer *chunk);
Dragan Dosen0edd1092016-02-12 13:23:02 +0100513
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100514
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200515/* Check a string for using it in a CSV output format. If the string contains
516 * one of the following four char <">, <,>, CR or LF, the string is
517 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
518 * <str> is the input string to be escaped. The function assumes that
519 * the input string is null-terminated.
520 *
521 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +0100522 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200523 * format.
524 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100525 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200526 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100527 * If <quote> is 1, the converter puts the quotes only if any character is
528 * escaped. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200529 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100530 * <output> is a struct chunk used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200531 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100532 * The function returns the converted string on its output. If an error
533 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200534 * for using the function directly as printf() argument.
535 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100536 * If the output buffer is too short to contain the input string, the result
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200537 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +0100538 *
539 * This function appends the encoding to the existing output chunk. Please
540 * use csv_enc() instead if you want to replace the output chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200541 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200542const char *csv_enc_append(const char *str, int quote, struct buffer *output);
Willy Tarreau898529b2016-01-06 18:07:04 +0100543
544/* same as above but the output chunk is reset first */
Willy Tarreau83061a82018-07-13 11:56:34 +0200545static inline const char *csv_enc(const char *str, int quote,
546 struct buffer *output)
Willy Tarreau898529b2016-01-06 18:07:04 +0100547{
548 chunk_reset(output);
549 return csv_enc_append(str, quote, output);
550}
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200551
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200552/* Decode an URL-encoded string in-place. The resulting string might
553 * be shorter. If some forbidden characters are found, the conversion is
554 * aborted, the string is truncated before the issue and non-zero is returned,
555 * otherwise the operation returns non-zero indicating success.
556 */
557int url_decode(char *string);
558
Willy Tarreau6911fa42007-03-04 18:06:08 +0100559/* This one is 6 times faster than strtoul() on athlon, but does
560 * no check at all.
561 */
562static inline unsigned int __str2ui(const char *s)
563{
564 unsigned int i = 0;
565 while (*s) {
566 i = i * 10 - '0';
567 i += (unsigned char)*s++;
568 }
569 return i;
570}
571
572/* This one is 5 times faster than strtoul() on athlon with checks.
573 * It returns the value of the number composed of all valid digits read.
574 */
575static inline unsigned int __str2uic(const char *s)
576{
577 unsigned int i = 0;
578 unsigned int j;
579 while (1) {
580 j = (*s++) - '0';
581 if (j > 9)
582 break;
583 i *= 10;
584 i += j;
585 }
586 return i;
587}
588
589/* This one is 28 times faster than strtoul() on athlon, but does
590 * no check at all!
591 */
592static inline unsigned int __strl2ui(const char *s, int len)
593{
594 unsigned int i = 0;
595 while (len-- > 0) {
596 i = i * 10 - '0';
597 i += (unsigned char)*s++;
598 }
599 return i;
600}
601
602/* This one is 7 times faster than strtoul() on athlon with checks.
603 * It returns the value of the number composed of all valid digits read.
604 */
605static inline unsigned int __strl2uic(const char *s, int len)
606{
607 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200608 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100609
610 while (len-- > 0) {
611 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200612 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100613 if (j > 9)
614 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200615 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100616 }
617 return i;
618}
619
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200620/* This function reads an unsigned integer from the string pointed to by <s>
621 * and returns it. The <s> pointer is adjusted to point to the first unread
622 * char. The function automatically stops at <end>.
623 */
624static inline unsigned int __read_uint(const char **s, const char *end)
625{
626 const char *ptr = *s;
627 unsigned int i = 0;
628 unsigned int j, k;
629
630 while (ptr < end) {
631 j = *ptr - '0';
632 k = i * 10;
633 if (j > 9)
634 break;
635 i = k + j;
636 ptr++;
637 }
638 *s = ptr;
639 return i;
640}
641
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200642unsigned long long int read_uint64(const char **s, const char *end);
643long long int read_int64(const char **s, const char *end);
644
Willy Tarreau6911fa42007-03-04 18:06:08 +0100645extern unsigned int str2ui(const char *s);
646extern unsigned int str2uic(const char *s);
647extern unsigned int strl2ui(const char *s, int len);
648extern unsigned int strl2uic(const char *s, int len);
649extern int strl2ic(const char *s, int len);
650extern int strl2irc(const char *s, int len, int *ret);
651extern int strl2llrc(const char *s, int len, long long *ret);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100652extern int strl2llrc_dotted(const char *text, int len, long long *ret);
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200653extern unsigned int read_uint(const char **s, const char *end);
Willy Tarreaud54bbdc2009-09-07 11:00:31 +0200654unsigned int inetaddr_host(const char *text);
655unsigned int inetaddr_host_lim(const char *text, const char *stop);
Willy Tarreau74172752010-10-15 23:21:42 +0200656unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret);
Willy Tarreau6911fa42007-03-04 18:06:08 +0100657
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200658static inline char *cut_crlf(char *s) {
659
Simon Horman5269cfb2013-02-13 17:48:00 +0900660 while (*s != '\r' && *s != '\n') {
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200661 char *p = s++;
662
663 if (!*p)
664 return p;
665 }
666
Simon Horman5269cfb2013-02-13 17:48:00 +0900667 *s++ = '\0';
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200668
669 return s;
670}
671
672static inline char *ltrim(char *s, char c) {
673
674 if (c)
675 while (*s == c)
676 s++;
677
678 return s;
679}
680
681static inline char *rtrim(char *s, char c) {
682
683 char *p = s + strlen(s);
684
685 while (p-- > s)
686 if (*p == c)
687 *p = '\0';
688 else
689 break;
690
691 return s;
692}
693
694static inline char *alltrim(char *s, char c) {
695
696 rtrim(s, c);
697
698 return ltrim(s, c);
699}
700
Willy Tarreaufe944602007-10-25 10:34:16 +0200701/* This function converts the time_t value <now> into a broken out struct tm
702 * which must be allocated by the caller. It is highly recommended to use this
703 * function intead of localtime() because that one requires a time_t* which
704 * is not always compatible with tv_sec depending on OS/hardware combinations.
705 */
706static inline void get_localtime(const time_t now, struct tm *tm)
707{
708 localtime_r(&now, tm);
709}
710
Emeric Brun3a058f32009-06-30 18:26:00 +0200711/* This function converts the time_t value <now> into a broken out struct tm
712 * which must be allocated by the caller. It is highly recommended to use this
713 * function intead of gmtime() because that one requires a time_t* which
714 * is not always compatible with tv_sec depending on OS/hardware combinations.
715 */
716static inline void get_gmtime(const time_t now, struct tm *tm)
717{
718 gmtime_r(&now, tm);
719}
720
Willy Tarreaucb1949b2017-07-19 19:05:29 +0200721/* Counts a number of elapsed days since 01/01/0000 based solely on elapsed
722 * years and assuming the regular rule for leap years applies. It's fake but
723 * serves as a temporary origin. It's worth remembering that it's the first
724 * year of each period that is leap and not the last one, so for instance year
725 * 1 sees 366 days since year 0 was leap. For this reason we have to apply
726 * modular arithmetics which is why we offset the year by 399 before
727 * subtracting the excess at the end. No overflow here before ~11.7 million
728 * years.
729 */
730static inline unsigned int days_since_zero(unsigned int y)
731{
732 return y * 365 + (y + 399) / 4 - (y + 399) / 100 + (y + 399) / 400
733 - 399 / 4 + 399 / 100;
734}
735
736/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
737 * It is meant as a portable replacement for timegm() for use with valid inputs.
738 * Returns undefined results for invalid dates (eg: months out of range 0..11).
739 */
740extern time_t my_timegm(const struct tm *tm);
741
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100742/* This function parses a time value optionally followed by a unit suffix among
743 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
744 * expected by the caller. The computation does its best to avoid overflows.
745 * The value is returned in <ret> if everything is fine, and a NULL is returned
746 * by the function. In case of error, a pointer to the error is returned and
747 * <ret> is left untouched.
748 */
749extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
Emeric Brun39132b22010-01-04 14:57:24 +0100750extern const char *parse_size_err(const char *text, unsigned *ret);
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100751
752/* unit flags to pass to parse_time_err */
753#define TIME_UNIT_US 0x0000
754#define TIME_UNIT_MS 0x0001
755#define TIME_UNIT_S 0x0002
756#define TIME_UNIT_MIN 0x0003
757#define TIME_UNIT_HOUR 0x0004
758#define TIME_UNIT_DAY 0x0005
759#define TIME_UNIT_MASK 0x0007
760
William Lallemand421f5b52012-02-06 18:15:57 +0100761#define SEC 1
762#define MINUTE (60 * SEC)
763#define HOUR (60 * MINUTE)
764#define DAY (24 * HOUR)
765
Willy Tarreau7f062c42009-03-05 18:43:00 +0100766/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
767 * This is used to compute fixed ratios by setting one of the operands to
768 * (2^32*ratio).
769 */
770static inline unsigned int mul32hi(unsigned int a, unsigned int b)
771{
772 return ((unsigned long long)a * b) >> 32;
773}
774
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200775/* gcc does not know when it can safely divide 64 bits by 32 bits. Use this
776 * function when you know for sure that the result fits in 32 bits, because
777 * it is optimal on x86 and on 64bit processors.
778 */
779static inline unsigned int div64_32(unsigned long long o1, unsigned int o2)
780{
781 unsigned int result;
782#ifdef __i386__
783 asm("divl %2"
784 : "=a" (result)
785 : "A"(o1), "rm"(o2));
786#else
787 result = o1 / o2;
788#endif
789 return result;
790}
791
David Carliere6c39412015-07-02 07:00:17 +0000792/* Simple popcountl implementation. It returns the number of ones in a word */
793static inline unsigned int my_popcountl(unsigned long a)
Willy Tarreau37994f02012-11-19 12:11:07 +0100794{
795 unsigned int cnt;
796 for (cnt = 0; a; a >>= 1) {
797 if (a & 1)
798 cnt++;
799 }
800 return cnt;
801}
802
Christopher Fauletff813182017-11-22 15:00:13 +0100803/* Simple ffs implementation. It returns the position of the lowest bit set to
804 * one. */
805static inline unsigned int my_ffsl(unsigned long a)
806{
807 unsigned int cnt;
808
809 if (!a)
810 return 0;
811
812 cnt = 1;
813#if LONG_MAX > 0x7FFFFFFFL /* 64bits */
814 if (!(a & 0xFFFFFFFFUL)) {
815 a >>= 32;
816 cnt += 32;
817 }
818#endif
819 if (!(a & 0XFFFFU)) {
820 a >>= 16;
821 cnt += 16;
822 }
823 if (!(a & 0XFF)) {
824 a >>= 8;
825 cnt += 8;
826 }
827 if (!(a & 0xf)) {
828 a >>= 4;
829 cnt += 4;
830 }
831 if (!(a & 0x3)) {
832 a >>= 2;
833 cnt += 2;
834 }
835 if (!(a & 0x1)) {
836 a >>= 1;
837 cnt += 1;
838 }
839
840 return cnt;
841}
842
David Carliere6c39412015-07-02 07:00:17 +0000843/* Build a word with the <bits> lower bits set (reverse of my_popcountl) */
Willy Tarreaua9db57e2013-01-18 11:29:29 +0100844static inline unsigned long nbits(int bits)
845{
846 if (--bits < 0)
847 return 0;
848 else
849 return (2UL << bits) - 1;
850}
851
Willy Tarreau126d4062013-12-03 17:50:47 +0100852/*
853 * Parse binary string written in hexadecimal (source) and store the decoded
854 * result into binstr and set binstrlen to the lengh of binstr. Memory for
855 * binstr is allocated by the function. In case of error, returns 0 with an
856 * error message in err.
857 */
858int parse_binary(const char *source, char **binstr, int *binstrlen, char **err);
859
Willy Tarreau946ba592009-05-10 15:41:18 +0200860/* copies at most <n> characters from <src> and always terminates with '\0' */
861char *my_strndup(const char *src, int n);
862
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +0200863/*
864 * search needle in haystack
865 * returns the pointer if found, returns NULL otherwise
866 */
867const void *my_memmem(const void *, size_t, const void *, size_t);
868
Willy Tarreau482b00d2009-10-04 22:48:42 +0200869/* This function returns the first unused key greater than or equal to <key> in
870 * ID tree <root>. Zero is returned if no place is found.
871 */
872unsigned int get_next_id(struct eb_root *root, unsigned int key);
873
Willy Tarreau9c1e15d2017-11-15 18:51:29 +0100874/* dump the full tree to <file> in DOT format for debugging purposes. Will
875 * optionally highlight node <subj> if found, depending on operation <op> :
876 * 0 : nothing
877 * >0 : insertion, node/leaf are surrounded in red
878 * <0 : removal, node/leaf are dashed with no background
879 * Will optionally add "desc" as a label on the graph if set and non-null.
880 */
881void eb32sc_to_file(FILE *file, struct eb_root *root, const struct eb32sc_node *subj,
882 int op, const char *desc);
Willy Tarreaued3cda02017-11-15 15:04:05 +0100883
Willy Tarreau348238b2010-01-18 15:05:57 +0100884/* This function compares a sample word possibly followed by blanks to another
885 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
886 * otherwise zero. This intends to be used when checking HTTP headers for some
887 * values.
888 */
889int word_match(const char *sample, int slen, const char *word, int wlen);
890
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200891/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
892 * or the number of chars read in case of success.
893 */
894int buf2ip(const char *buf, size_t len, struct in_addr *dst);
Thierry FOURNIERd559dd82013-11-22 16:16:59 +0100895int buf2ip6(const char *buf, size_t len, struct in6_addr *dst);
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200896
Willy Tarreauacf95772010-06-14 19:09:21 +0200897/* To be used to quote config arg positions. Returns the string at <ptr>
898 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
899 * if ptr is NULL or empty. The string is locally allocated.
900 */
901const char *quote_arg(const char *ptr);
902
Willy Tarreau5b180202010-07-18 10:40:48 +0200903/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
904int get_std_op(const char *str);
905
Willy Tarreau4c14eaa2010-11-24 14:01:45 +0100906/* hash a 32-bit integer to another 32-bit integer */
907extern unsigned int full_hash(unsigned int a);
908static inline unsigned int __full_hash(unsigned int a)
909{
910 /* This function is one of Bob Jenkins' full avalanche hashing
911 * functions, which when provides quite a good distribution for little
912 * input variations. The result is quite suited to fit over a 32-bit
913 * space with enough variations so that a randomly picked number falls
914 * equally before any server position.
915 * Check http://burtleburtle.net/bob/hash/integer.html for more info.
916 */
917 a = (a+0x7ed55d16) + (a<<12);
918 a = (a^0xc761c23c) ^ (a>>19);
919 a = (a+0x165667b1) + (a<<5);
920 a = (a+0xd3a2646c) ^ (a<<9);
921 a = (a+0xfd7046c5) + (a<<3);
922 a = (a^0xb55a4f09) ^ (a>>16);
923
924 /* ensure values are better spread all around the tree by multiplying
925 * by a large prime close to 3/4 of the tree.
926 */
927 return a * 3221225473U;
928}
929
Willy Tarreau422a0a52012-10-26 19:47:23 +0200930/* sets the address family to AF_UNSPEC so that is_addr() does not match */
931static inline void clear_addr(struct sockaddr_storage *addr)
932{
933 addr->ss_family = AF_UNSPEC;
934}
935
David du Colombier6f5ccb12011-03-10 22:26:24 +0100936/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
937 * otherwise zero.
938 */
Willy Tarreau18ca2d42014-05-09 22:40:55 +0200939static inline int is_inet_addr(const struct sockaddr_storage *addr)
David du Colombier6f5ccb12011-03-10 22:26:24 +0100940{
941 int i;
942
943 switch (addr->ss_family) {
944 case AF_INET:
David du Colombier64e9c902011-03-22 11:39:41 +0100945 return *(int *)&((struct sockaddr_in *)addr)->sin_addr;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100946 case AF_INET6:
947 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
948 if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0)
949 return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i];
950 }
951 return 0;
952}
953
Willy Tarreau18ca2d42014-05-09 22:40:55 +0200954/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
955 * or is a unix address, otherwise returns zero.
956 */
957static inline int is_addr(const struct sockaddr_storage *addr)
958{
959 if (addr->ss_family == AF_UNIX)
960 return 1;
961 else
962 return is_inet_addr(addr);
963}
964
David du Colombier11bcb6c2011-03-24 12:23:00 +0100965/* returns port in network byte order */
966static inline int get_net_port(struct sockaddr_storage *addr)
967{
968 switch (addr->ss_family) {
969 case AF_INET:
970 return ((struct sockaddr_in *)addr)->sin_port;
971 case AF_INET6:
972 return ((struct sockaddr_in6 *)addr)->sin6_port;
973 }
974 return 0;
975}
976
977/* returns port in host byte order */
978static inline int get_host_port(struct sockaddr_storage *addr)
979{
980 switch (addr->ss_family) {
981 case AF_INET:
982 return ntohs(((struct sockaddr_in *)addr)->sin_port);
983 case AF_INET6:
984 return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
985 }
986 return 0;
987}
988
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +0200989/* returns address len for <addr>'s family, 0 for unknown families */
990static inline int get_addr_len(const struct sockaddr_storage *addr)
991{
992 switch (addr->ss_family) {
993 case AF_INET:
994 return sizeof(struct sockaddr_in);
995 case AF_INET6:
996 return sizeof(struct sockaddr_in6);
997 case AF_UNIX:
998 return sizeof(struct sockaddr_un);
999 }
1000 return 0;
1001}
1002
David du Colombier11bcb6c2011-03-24 12:23:00 +01001003/* set port in host byte order */
1004static inline int set_net_port(struct sockaddr_storage *addr, int port)
1005{
1006 switch (addr->ss_family) {
1007 case AF_INET:
1008 ((struct sockaddr_in *)addr)->sin_port = port;
1009 case AF_INET6:
1010 ((struct sockaddr_in6 *)addr)->sin6_port = port;
1011 }
1012 return 0;
1013}
1014
1015/* set port in network byte order */
1016static inline int set_host_port(struct sockaddr_storage *addr, int port)
1017{
1018 switch (addr->ss_family) {
1019 case AF_INET:
1020 ((struct sockaddr_in *)addr)->sin_port = htons(port);
1021 case AF_INET6:
1022 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
1023 }
1024 return 0;
1025}
1026
Thierry Fournier70473a52016-02-17 17:12:14 +01001027/* Convert mask from bit length form to in_addr form.
1028 * This function never fails.
1029 */
1030void len2mask4(int len, struct in_addr *addr);
1031
1032/* Convert mask from bit length form to in6_addr form.
1033 * This function never fails.
1034 */
1035void len2mask6(int len, struct in6_addr *addr);
1036
David du Colombier4f92d322011-03-24 11:09:31 +01001037/* Return true if IPv4 address is part of the network */
Willy Tarreaueec1d382016-07-13 11:59:39 +02001038extern 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 +01001039
1040/* Return true if IPv6 address is part of the network */
Willy Tarreaueec1d382016-07-13 11:59:39 +02001041extern 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 +01001042
1043/* Map IPv4 adress on IPv6 address, as specified in RFC 3513. */
1044extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr);
1045
1046/* Map IPv6 adress on IPv4 address, as specified in RFC 3513.
1047 * Return true if conversion is possible and false otherwise.
1048 */
1049extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr);
1050
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01001051/* compare two struct sockaddr_storage and return:
1052 * 0 (true) if the addr is the same in both
1053 * 1 (false) if the addr is not the same in both
1054 */
1055int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2);
1056
Baptiste Assmann08396c82016-01-31 00:27:17 +01001057/* copy ip from <source> into <dest>
1058 * the caller must clear <dest> before calling.
1059 * Returns a pointer to the destination
1060 */
1061struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest);
1062
William Lallemand421f5b52012-02-06 18:15:57 +01001063char *human_time(int t, short hz_div);
1064
1065extern const char *monthname[];
1066
1067/* date2str_log: write a date in the format :
1068 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
1069 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
1070 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
1071 *
1072 * without using sprintf. return a pointer to the last char written (\0) or
1073 * NULL if there isn't enough space.
1074 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02001075char *date2str_log(char *dest, const struct tm *tm, const struct timeval *date, size_t size);
William Lallemand421f5b52012-02-06 18:15:57 +01001076
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001077/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001078 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001079 * The string returned has the same format as returned by strftime(... "%z", tm).
1080 * Offsets are kept in an internal cache for better performances.
1081 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001082const char *get_gmt_offset(time_t t, struct tm *tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001083
William Lallemand421f5b52012-02-06 18:15:57 +01001084/* gmt2str_log: write a date in the format :
1085 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
1086 * return a pointer to the last char written (\0) or
1087 * NULL if there isn't enough space.
1088 */
1089char *gmt2str_log(char *dst, struct tm *tm, size_t size);
1090
Yuxans Yao4e25b012012-10-19 10:36:09 +08001091/* localdate2str_log: write a date in the format :
1092 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001093 * Both t and tm must represent the same time.
Yuxans Yao4e25b012012-10-19 10:36:09 +08001094 * return a pointer to the last char written (\0) or
1095 * NULL if there isn't enough space.
1096 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02001097char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size);
Yuxans Yao4e25b012012-10-19 10:36:09 +08001098
Thierry Fournier93127942016-01-20 18:49:45 +01001099/* These 3 functions parses date string and fills the
1100 * corresponding broken-down time in <tm>. In succes case,
1101 * it returns 1, otherwise, it returns 0.
1102 */
1103int parse_http_date(const char *date, int len, struct tm *tm);
1104int parse_imf_date(const char *date, int len, struct tm *tm);
1105int parse_rfc850_date(const char *date, int len, struct tm *tm);
1106int parse_asctime_date(const char *date, int len, struct tm *tm);
1107
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001108/* Dynamically allocates a string of the proper length to hold the formatted
1109 * output. NULL is returned on error. The caller is responsible for freeing the
1110 * memory area using free(). The resulting string is returned in <out> if the
1111 * pointer is not NULL. A previous version of <out> might be used to build the
1112 * new string, and it will be freed before returning if it is not NULL, which
1113 * makes it possible to build complex strings from iterative calls without
1114 * having to care about freeing intermediate values, as in the example below :
1115 *
1116 * memprintf(&err, "invalid argument: '%s'", arg);
1117 * ...
1118 * memprintf(&err, "parser said : <%s>\n", *err);
1119 * ...
1120 * free(*err);
1121 *
1122 * This means that <err> must be initialized to NULL before first invocation.
1123 * The return value also holds the allocated string, which eases error checking
1124 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001125 * passed instead and it will be ignored. The returned message will then also
1126 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001127 *
1128 * It is also convenient to use it without any free except the last one :
1129 * err = NULL;
1130 * if (!fct1(err)) report(*err);
1131 * if (!fct2(err)) report(*err);
1132 * if (!fct3(err)) report(*err);
1133 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02001134 *
1135 * memprintf relies on memvprintf. This last version can be called from any
1136 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001137 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02001138char *memvprintf(char **out, const char *format, va_list args)
1139 __attribute__ ((format(printf, 2, 0)));
1140
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001141char *memprintf(char **out, const char *format, ...)
1142 __attribute__ ((format(printf, 2, 3)));
1143
Willy Tarreau21c705b2012-09-14 11:40:36 +02001144/* Used to add <level> spaces before each line of <out>, unless there is only one line.
1145 * The input argument is automatically freed and reassigned. The result will have to be
1146 * freed by the caller.
1147 * Example of use :
1148 * parse(cmd, &err); (callee: memprintf(&err, ...))
1149 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
1150 * free(err);
1151 */
1152char *indent_msg(char **out, int level);
Willy Tarreau3d2f16f2012-05-13 00:21:17 +02001153
Willy Tarreaudad36a32013-03-11 01:20:04 +01001154/* Convert occurrences of environment variables in the input string to their
1155 * corresponding value. A variable is identified as a series of alphanumeric
1156 * characters or underscores following a '$' sign. The <in> string must be
1157 * free()able. NULL returns NULL. The resulting string might be reallocated if
1158 * some expansion is made.
1159 */
1160char *env_expand(char *in);
1161
Willy Tarreau3d2f16f2012-05-13 00:21:17 +02001162/* debugging macro to emit messages using write() on fd #-1 so that strace sees
1163 * them.
1164 */
1165#define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0)
1166
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001167/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02001168 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
1169 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001170 */
Willy Tarreaued936c52017-04-27 18:03:20 +02001171void debug_hexdump(FILE *out, const char *pfx, const char *buf, unsigned int baseaddr, int len);
Willy Tarreau0ebb5112016-12-05 00:10:57 +01001172
Willy Tarreau12963822017-10-24 10:54:08 +02001173/* this is used to emit traces when building with TRACE=1 */
1174__attribute__((format(printf, 1, 2)))
1175void trace(char *fmt, ...);
1176
Willy Tarreau89efaed2013-12-13 15:14:55 +01001177/* used from everywhere just to drain results we don't want to read and which
1178 * recent versions of gcc increasingly and annoyingly complain about.
1179 */
1180extern int shut_your_big_mouth_gcc_int;
1181
1182/* used from everywhere just to drain results we don't want to read and which
1183 * recent versions of gcc increasingly and annoyingly complain about.
1184 */
1185static inline void shut_your_big_mouth_gcc(int r)
1186{
1187 shut_your_big_mouth_gcc_int = r;
1188}
1189
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02001190/* same as strstr() but case-insensitive */
1191const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2);
1192
Willy Tarreaubb519c72014-01-28 23:04:39 +01001193
1194/************************* Composite address manipulation *********************
1195 * Composite addresses are simply unsigned long data in which the higher bits
1196 * represent a pointer, and the two lower bits are flags. There are several
1197 * places where we just want to associate one or two flags to a pointer (eg,
1198 * to type it), and these functions permit this. The pointer is necessarily a
1199 * 32-bit aligned pointer, as its two lower bits will be cleared and replaced
1200 * with the flags.
1201 *****************************************************************************/
1202
1203/* Masks the two lower bits of a composite address and converts it to a
1204 * pointer. This is used to mix some bits with some aligned pointers to
1205 * structs and to retrieve the original (32-bit aligned) pointer.
1206 */
1207static inline void *caddr_to_ptr(unsigned long caddr)
1208{
1209 return (void *)(caddr & ~3UL);
1210}
1211
1212/* Only retrieves the two lower bits of a composite address. This is used to mix
1213 * some bits with some aligned pointers to structs and to retrieve the original
1214 * data (2 bits).
1215 */
1216static inline unsigned int caddr_to_data(unsigned long caddr)
1217{
1218 return (caddr & 3UL);
1219}
1220
1221/* Combines the aligned pointer whose 2 lower bits will be masked with the bits
1222 * from <data> to form a composite address. This is used to mix some bits with
1223 * some aligned pointers to structs and to retrieve the original (32-bit aligned)
1224 * pointer.
1225 */
1226static inline unsigned long caddr_from_ptr(void *ptr, unsigned int data)
1227{
1228 return (((unsigned long)ptr) & ~3UL) + (data & 3);
1229}
1230
1231/* sets the 2 bits of <data> in the <caddr> composite address */
1232static inline unsigned long caddr_set_flags(unsigned long caddr, unsigned int data)
1233{
1234 return caddr | (data & 3);
1235}
1236
1237/* clears the 2 bits of <data> in the <caddr> composite address */
1238static inline unsigned long caddr_clr_flags(unsigned long caddr, unsigned int data)
1239{
1240 return caddr & ~(unsigned long)(data & 3);
1241}
1242
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001243/* UTF-8 decoder status */
1244#define UTF8_CODE_OK 0x00
1245#define UTF8_CODE_OVERLONG 0x10
1246#define UTF8_CODE_INVRANGE 0x20
1247#define UTF8_CODE_BADSEQ 0x40
1248
1249unsigned char utf8_next(const char *s, int len, unsigned int *c);
1250
1251static inline unsigned char utf8_return_code(unsigned int code)
1252{
1253 return code & 0xf0;
1254}
1255
1256static inline unsigned char utf8_return_length(unsigned char code)
1257{
1258 return code & 0x0f;
1259}
1260
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001261/* Turns 64-bit value <a> from host byte order to network byte order.
1262 * The principle consists in letting the compiler detect we're playing
1263 * with a union and simplify most or all operations. The asm-optimized
1264 * htonl() version involving bswap (x86) / rev (arm) / other is a single
1265 * operation on little endian, or a NOP on big-endian. In both cases,
1266 * this lets the compiler "see" that we're rebuilding a 64-bit word from
1267 * two 32-bit quantities that fit into a 32-bit register. In big endian,
1268 * the whole code is optimized out. In little endian, with a decent compiler,
1269 * a few bswap and 2 shifts are left, which is the minimum acceptable.
1270 */
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001271static inline unsigned long long my_htonll(unsigned long long a)
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001272{
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001273#if defined(__x86_64__)
Willy Tarreaudea7c5c2017-10-18 11:39:33 +02001274 __asm__ volatile("bswap %0" : "=r"(a) : "0"(a));
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001275 return a;
1276#else
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001277 union {
1278 struct {
1279 unsigned int w1;
1280 unsigned int w2;
1281 } by32;
1282 unsigned long long by64;
1283 } w = { .by64 = a };
1284 return ((unsigned long long)htonl(w.by32.w1) << 32) | htonl(w.by32.w2);
Willy Tarreau36eb3a32017-09-20 08:18:49 +02001285#endif
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001286}
1287
1288/* Turns 64-bit value <a> from network byte order to host byte order. */
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001289static inline unsigned long long my_ntohll(unsigned long long a)
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001290{
Willy Tarreau5f6e9052016-05-20 06:29:59 +02001291 return my_htonll(a);
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001292}
1293
Willy Tarreaue6e49cf2015-04-29 17:13:35 +02001294/* returns a 64-bit a timestamp with the finest resolution available. The
1295 * unit is intentionally not specified. It's mostly used to compare dates.
1296 */
1297#if defined(__i386__) || defined(__x86_64__)
1298static inline unsigned long long rdtsc()
1299{
1300 unsigned int a, d;
1301 asm volatile("rdtsc" : "=a" (a), "=d" (d));
1302 return a + ((unsigned long long)d << 32);
1303}
1304#else
1305static inline unsigned long long rdtsc()
1306{
1307 struct timeval tv;
1308 gettimeofday(&tv, NULL);
1309 return tv.tv_sec * 1000000 + tv.tv_usec;
1310}
1311#endif
1312
Maxime de Roucydc887852016-05-13 23:52:54 +02001313/* append a copy of string <str> (in a wordlist) at the end of the list <li>
1314 * On failure : return 0 and <err> filled with an error message.
1315 * The caller is responsible for freeing the <err> and <str> copy
1316 * memory area using free()
1317 */
1318struct list;
1319int list_append_word(struct list *li, const char *str, char **err);
1320
Willy Tarreau83061a82018-07-13 11:56:34 +02001321int dump_text(struct buffer *out, const char *buf, int bsize);
1322int dump_binary(struct buffer *out, const char *buf, int bsize);
1323int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01001324 int *line, int ptr);
1325
Hubert Verstraete2eae3a02016-06-28 22:41:00 +02001326/* same as realloc() except that ptr is also freed upon failure */
1327static inline void *my_realloc2(void *ptr, size_t size)
1328{
1329 void *ret;
1330
1331 ret = realloc(ptr, size);
1332 if (!ret && size)
1333 free(ptr);
1334 return ret;
1335}
1336
Lukas Tribusdcbc5c52016-09-12 21:42:07 +00001337/* HAP_STRING() makes a string from a literal while HAP_XSTRING() first
1338 * evaluates the argument and is suited to pass macros.
1339 *
1340 * They allow macros like PCRE_MAJOR to be defined without quotes, which
1341 * is convenient for applications that want to test its value.
1342 */
1343#define HAP_STRING(...) #__VA_ARGS__
1344#define HAP_XSTRING(...) HAP_STRING(__VA_ARGS__)
1345
Willy Tarreau2dd0d472006-06-29 17:53:05 +02001346#endif /* _COMMON_STANDARD_H */