blob: be0762573d9c5575bc4256e4ba8ff0af3ef83280 [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 Tarreaufe944602007-10-25 10:34:16 +020027#include <time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020028#include <sys/types.h>
Willy Tarreaud50265a2012-09-04 14:18:33 +020029#include <sys/socket.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020030#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031#include <netinet/in.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020032#include <common/config.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010033#include <eb32tree.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020034
William Lallemande7340ec2012-01-24 11:15:39 +010035#ifndef LLONG_MAX
36# define LLONG_MAX 9223372036854775807LL
37# define LLONG_MIN (-LLONG_MAX - 1LL)
38#endif
39
40#ifndef ULLONG_MAX
41# define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
42#endif
43
Willy Tarreau56adcf22012-12-23 18:00:29 +010044/* number of itoa_str entries */
45#define NB_ITOA_STR 10
William Lallemande7340ec2012-01-24 11:15:39 +010046
Willy Tarreaubaaee002006-06-26 02:48:02 +020047/****** string-specific macros and functions ******/
48/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
49#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
50
51/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
52#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
53
54/* returns 1 only if only zero or one bit is set in X, which means that X is a
55 * power of 2, and 0 otherwise */
56#define POWEROF2(x) (((x) & ((x)-1)) == 0)
57
Willy Tarreau5b180202010-07-18 10:40:48 +020058/* operators to compare values. They're ordered that way so that the lowest bit
59 * serves as a negation for the test and contains all tests that are not equal.
60 */
61enum {
62 STD_OP_LE = 0, STD_OP_GT = 1,
63 STD_OP_EQ = 2, STD_OP_NE = 3,
64 STD_OP_GE = 4, STD_OP_LT = 5,
65};
66
Willy Tarreau56adcf22012-12-23 18:00:29 +010067extern int itoa_idx; /* index of next itoa_str to use */
68
Willy Tarreau7d58a632007-01-13 23:06:06 +010069/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020070 * copies at most <size-1> chars from <src> to <dst>. Last char is always
71 * set to 0, unless <size> is 0. The number of chars copied is returned
72 * (excluding the terminating zero).
73 * This code has been optimized for size and speed : on x86, it's 45 bytes
74 * long, uses only registers, and consumes only 4 cycles per char.
75 */
76extern int strlcpy2(char *dst, const char *src, int size);
77
78/*
Willy Tarreau72d759c2007-10-25 12:14:10 +020079 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +020080 * the ascii representation for number 'n' in decimal.
81 */
Willy Tarreaue7239b52009-03-29 13:41:58 +020082extern char itoa_str[][171];
Emeric Brun3a7fce52010-01-04 14:54:38 +010083extern char *ultoa_r(unsigned long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +020084extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +020085static inline const char *ultoa(unsigned long n)
86{
87 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
88}
89
William Lallemande7340ec2012-01-24 11:15:39 +010090/*
91 * unsigned long long ASCII representation
92 *
93 * return the last char '\0' or NULL if no enough
94 * space in dst
95 */
96char *ulltoa(unsigned long long n, char *dst, size_t size);
97
98
99/*
100 * unsigned long ASCII representation
101 *
102 * return the last char '\0' or NULL if no enough
103 * space in dst
104 */
105char *ultoa_o(unsigned long n, char *dst, size_t size);
106
107/*
108 * signed long ASCII representation
109 *
110 * return the last char '\0' or NULL if no enough
111 * space in dst
112 */
113char *ltoa_o(long int n, char *dst, size_t size);
114
115/*
116 * signed long long ASCII representation
117 *
118 * return the last char '\0' or NULL if no enough
119 * space in dst
120 */
121char *lltoa(long long n, char *dst, size_t size);
122
123/*
124 * write a ascii representation of a unsigned into dst,
125 * return a pointer to the last character
126 * Pad the ascii representation with '0', using size.
127 */
128char *utoa_pad(unsigned int n, char *dst, size_t size);
129
Willy Tarreaubaaee002006-06-26 02:48:02 +0200130/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200131 * This function simply returns a locally allocated string containing the ascii
132 * representation for number 'n' in decimal, unless n is 0 in which case it
133 * returns the alternate string (or an empty string if the alternate string is
134 * NULL). It use is intended for limits reported in reports, where it's
135 * desirable not to display anything if there is no limit. Warning! it shares
136 * the same vector as ultoa_r().
137 */
138extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
139
Willy Tarreau56adcf22012-12-23 18:00:29 +0100140/* returns a locally allocated string containing the ASCII representation of
141 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
142 * function call (eg: printf), shared with the other similar functions making
143 * use of itoa_str[].
144 */
145static inline const char *U2A(unsigned long n)
146{
147 const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
148 if (++itoa_idx >= NB_ITOA_STR)
149 itoa_idx = 0;
150 return ret;
151}
152
153/* returns a locally allocated string containing the HTML representation of
154 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
155 * function call (eg: printf), shared with the other similar functions making
156 * use of itoa_str[].
Willy Tarreau91092e52007-10-25 16:58:42 +0200157 */
Willy Tarreau56adcf22012-12-23 18:00:29 +0100158static inline const char *U2H(unsigned long long n)
159{
160 const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
161 if (++itoa_idx >= NB_ITOA_STR)
162 itoa_idx = 0;
163 return ret;
164}
165
166/* returns a locally allocated string containing the HTML representation of
167 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
168 * function call (eg: printf), shared with the other similar functions making
169 * use of itoa_str[].
170 */
171static inline const char *LIM2A(unsigned long n, const char *alt)
172{
173 const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt);
174 if (++itoa_idx >= NB_ITOA_STR)
175 itoa_idx = 0;
176 return ret;
177}
Willy Tarreau91092e52007-10-25 16:58:42 +0200178
179/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200180 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
181 */
182extern int ishex(char s);
183
184/*
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100185 * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F),
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200186 * otherwise -1. This compact form helps gcc produce efficient code.
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100187 */
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200188static inline int hex2i(int c)
189{
Willy Tarreau0161d622013-04-02 01:26:55 +0200190 if (unlikely((unsigned char)(c -= '0') > 9)) {
191 if (likely((unsigned char)(c -= 'A' - '0') > 5 &&
192 (unsigned char)(c -= 'a' - 'A') > 5))
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200193 c = -11;
194 c += 10;
195 }
196 return c;
197}
198
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100199
200/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100201 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
202 * invalid character is found, a pointer to it is returned. If everything is
203 * fine, NULL is returned.
204 */
205extern const char *invalid_char(const char *name);
206
207/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200208 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
209 * If an invalid character is found, a pointer to it is returned.
210 * If everything is fine, NULL is returned.
211 */
212extern const char *invalid_domainchar(const char *name);
213
214/*
Willy Tarreaufab5a432011-03-04 15:31:53 +0100215 * converts <str> to a locally allocated struct sockaddr_storage *, and a
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200216 * port range consisting in two integers. The low and high end are always set
217 * even if the port is unspecified, in which case (0,0) is returned. The low
Willy Tarreaufab5a432011-03-04 15:31:53 +0100218 * port is set in the sockaddr. Thus, it is enough to check the size of the
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200219 * returned range to know if an array must be allocated or not. The format is
Willy Tarreaufab5a432011-03-04 15:31:53 +0100220 * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6
221 * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6
222 * address wants to ignore port, it must be terminated by a trailing colon (':').
223 * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on
224 * IPv6, use ":::port". NULL is returned if the host part cannot be resolved.
Willy Tarreaud393a622013-03-04 18:22:00 +0100225 * If <pfx> is non-null, it is used as a string prefix before any path-based
226 * address (typically the path to a unix socket).
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200227 */
Willy Tarreaud393a622013-03-04 18:22:00 +0100228struct sockaddr_storage *str2sa_range(const char *str, int *low, int *high, char **err, const char *pfx);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200229
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100230/* converts <str> to a struct in_addr containing a network mask. It can be
231 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
232 * if the conversion succeeds otherwise non-zero.
233 */
234int str2mask(const char *str, struct in_addr *mask);
235
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200236/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200237 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200238 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
239 * is optionnal and either in the dotted or CIDR notation.
240 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
241 */
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200242int str2net(const char *str, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200243
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100244/*
Willy Tarreau6d20e282012-04-27 22:49:47 +0200245 * converts <str> to two struct in6_addr* which must be pre-allocated.
246 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
247 * is an optionnal number of bits (128 being the default).
248 * Returns 1 if OK, 0 if error.
249 */
250int str62net(const char *str, struct in6_addr *addr, unsigned char *mask);
251
252/*
Willy Tarreau106f9792009-09-19 07:54:16 +0200253 * Parse IP address found in url.
254 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100255int url2ipv4(const char *addr, struct in_addr *dst);
Willy Tarreau106f9792009-09-19 07:54:16 +0200256
257/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100258 * Resolve destination server from URL. Convert <str> to a sockaddr_storage*.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100259 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100260int url2sa(const char *url, int ulen, struct sockaddr_storage *addr);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100261
Willy Tarreau631f01c2011-09-05 00:36:48 +0200262/* Tries to convert a sockaddr_storage address to text form. Upon success, the
263 * address family is returned so that it's easy for the caller to adapt to the
264 * output format. Zero is returned if the address family is not supported. -1
265 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
266 * supported.
267 */
268int addr_to_str(struct sockaddr_storage *addr, char *str, int size);
269
Willy Tarreaubaaee002006-06-26 02:48:02 +0200270/* will try to encode the string <string> replacing all characters tagged in
271 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
272 * prefixed by <escape>, and will store the result between <start> (included)
273 * and <stop> (excluded), and will always terminate the string with a '\0'
274 * before <stop>. The position of the '\0' is returned if the conversion
275 * completes. If bytes are missing between <start> and <stop>, then the
276 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
277 * cannot even be stored so we return <start> without writing the 0.
278 * The input string must also be zero-terminated.
279 */
280extern const char hextab[];
281char *encode_string(char *start, char *stop,
282 const char escape, const fd_set *map,
283 const char *string);
284
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200285/* Decode an URL-encoded string in-place. The resulting string might
286 * be shorter. If some forbidden characters are found, the conversion is
287 * aborted, the string is truncated before the issue and non-zero is returned,
288 * otherwise the operation returns non-zero indicating success.
289 */
290int url_decode(char *string);
291
Willy Tarreau6911fa42007-03-04 18:06:08 +0100292/* This one is 6 times faster than strtoul() on athlon, but does
293 * no check at all.
294 */
295static inline unsigned int __str2ui(const char *s)
296{
297 unsigned int i = 0;
298 while (*s) {
299 i = i * 10 - '0';
300 i += (unsigned char)*s++;
301 }
302 return i;
303}
304
305/* This one is 5 times faster than strtoul() on athlon with checks.
306 * It returns the value of the number composed of all valid digits read.
307 */
308static inline unsigned int __str2uic(const char *s)
309{
310 unsigned int i = 0;
311 unsigned int j;
312 while (1) {
313 j = (*s++) - '0';
314 if (j > 9)
315 break;
316 i *= 10;
317 i += j;
318 }
319 return i;
320}
321
322/* This one is 28 times faster than strtoul() on athlon, but does
323 * no check at all!
324 */
325static inline unsigned int __strl2ui(const char *s, int len)
326{
327 unsigned int i = 0;
328 while (len-- > 0) {
329 i = i * 10 - '0';
330 i += (unsigned char)*s++;
331 }
332 return i;
333}
334
335/* This one is 7 times faster than strtoul() on athlon with checks.
336 * It returns the value of the number composed of all valid digits read.
337 */
338static inline unsigned int __strl2uic(const char *s, int len)
339{
340 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200341 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100342
343 while (len-- > 0) {
344 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200345 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100346 if (j > 9)
347 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200348 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100349 }
350 return i;
351}
352
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200353/* This function reads an unsigned integer from the string pointed to by <s>
354 * and returns it. The <s> pointer is adjusted to point to the first unread
355 * char. The function automatically stops at <end>.
356 */
357static inline unsigned int __read_uint(const char **s, const char *end)
358{
359 const char *ptr = *s;
360 unsigned int i = 0;
361 unsigned int j, k;
362
363 while (ptr < end) {
364 j = *ptr - '0';
365 k = i * 10;
366 if (j > 9)
367 break;
368 i = k + j;
369 ptr++;
370 }
371 *s = ptr;
372 return i;
373}
374
Willy Tarreau6911fa42007-03-04 18:06:08 +0100375extern unsigned int str2ui(const char *s);
376extern unsigned int str2uic(const char *s);
377extern unsigned int strl2ui(const char *s, int len);
378extern unsigned int strl2uic(const char *s, int len);
379extern int strl2ic(const char *s, int len);
380extern int strl2irc(const char *s, int len, int *ret);
381extern int strl2llrc(const char *s, int len, long long *ret);
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200382extern unsigned int read_uint(const char **s, const char *end);
Willy Tarreaud54bbdc2009-09-07 11:00:31 +0200383unsigned int inetaddr_host(const char *text);
384unsigned int inetaddr_host_lim(const char *text, const char *stop);
Willy Tarreau74172752010-10-15 23:21:42 +0200385unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret);
Willy Tarreau6911fa42007-03-04 18:06:08 +0100386
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200387static inline char *cut_crlf(char *s) {
388
Simon Horman5269cfb2013-02-13 17:48:00 +0900389 while (*s != '\r' && *s != '\n') {
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200390 char *p = s++;
391
392 if (!*p)
393 return p;
394 }
395
Simon Horman5269cfb2013-02-13 17:48:00 +0900396 *s++ = '\0';
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200397
398 return s;
399}
400
401static inline char *ltrim(char *s, char c) {
402
403 if (c)
404 while (*s == c)
405 s++;
406
407 return s;
408}
409
410static inline char *rtrim(char *s, char c) {
411
412 char *p = s + strlen(s);
413
414 while (p-- > s)
415 if (*p == c)
416 *p = '\0';
417 else
418 break;
419
420 return s;
421}
422
423static inline char *alltrim(char *s, char c) {
424
425 rtrim(s, c);
426
427 return ltrim(s, c);
428}
429
Willy Tarreaufe944602007-10-25 10:34:16 +0200430/* This function converts the time_t value <now> into a broken out struct tm
431 * which must be allocated by the caller. It is highly recommended to use this
432 * function intead of localtime() because that one requires a time_t* which
433 * is not always compatible with tv_sec depending on OS/hardware combinations.
434 */
435static inline void get_localtime(const time_t now, struct tm *tm)
436{
437 localtime_r(&now, tm);
438}
439
Emeric Brun3a058f32009-06-30 18:26:00 +0200440/* This function converts the time_t value <now> into a broken out struct tm
441 * which must be allocated by the caller. It is highly recommended to use this
442 * function intead of gmtime() because that one requires a time_t* which
443 * is not always compatible with tv_sec depending on OS/hardware combinations.
444 */
445static inline void get_gmtime(const time_t now, struct tm *tm)
446{
447 gmtime_r(&now, tm);
448}
449
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100450/* This function parses a time value optionally followed by a unit suffix among
451 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
452 * expected by the caller. The computation does its best to avoid overflows.
453 * The value is returned in <ret> if everything is fine, and a NULL is returned
454 * by the function. In case of error, a pointer to the error is returned and
455 * <ret> is left untouched.
456 */
457extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
Emeric Brun39132b22010-01-04 14:57:24 +0100458extern const char *parse_size_err(const char *text, unsigned *ret);
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100459
460/* unit flags to pass to parse_time_err */
461#define TIME_UNIT_US 0x0000
462#define TIME_UNIT_MS 0x0001
463#define TIME_UNIT_S 0x0002
464#define TIME_UNIT_MIN 0x0003
465#define TIME_UNIT_HOUR 0x0004
466#define TIME_UNIT_DAY 0x0005
467#define TIME_UNIT_MASK 0x0007
468
William Lallemand421f5b52012-02-06 18:15:57 +0100469#define SEC 1
470#define MINUTE (60 * SEC)
471#define HOUR (60 * MINUTE)
472#define DAY (24 * HOUR)
473
Willy Tarreau7f062c42009-03-05 18:43:00 +0100474/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
475 * This is used to compute fixed ratios by setting one of the operands to
476 * (2^32*ratio).
477 */
478static inline unsigned int mul32hi(unsigned int a, unsigned int b)
479{
480 return ((unsigned long long)a * b) >> 32;
481}
482
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200483/* gcc does not know when it can safely divide 64 bits by 32 bits. Use this
484 * function when you know for sure that the result fits in 32 bits, because
485 * it is optimal on x86 and on 64bit processors.
486 */
487static inline unsigned int div64_32(unsigned long long o1, unsigned int o2)
488{
489 unsigned int result;
490#ifdef __i386__
491 asm("divl %2"
492 : "=a" (result)
493 : "A"(o1), "rm"(o2));
494#else
495 result = o1 / o2;
496#endif
497 return result;
498}
499
Willy Tarreau37994f02012-11-19 12:11:07 +0100500/* Simple popcount implementation. It returns the number of ones in a word */
501static inline unsigned int popcount(unsigned int a)
502{
503 unsigned int cnt;
504 for (cnt = 0; a; a >>= 1) {
505 if (a & 1)
506 cnt++;
507 }
508 return cnt;
509}
510
Willy Tarreau126d4062013-12-03 17:50:47 +0100511/*
512 * Parse binary string written in hexadecimal (source) and store the decoded
513 * result into binstr and set binstrlen to the lengh of binstr. Memory for
514 * binstr is allocated by the function. In case of error, returns 0 with an
515 * error message in err.
516 */
517int parse_binary(const char *source, char **binstr, int *binstrlen, char **err);
518
Willy Tarreau946ba592009-05-10 15:41:18 +0200519/* copies at most <n> characters from <src> and always terminates with '\0' */
520char *my_strndup(const char *src, int n);
521
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +0200522/*
523 * search needle in haystack
524 * returns the pointer if found, returns NULL otherwise
525 */
526const void *my_memmem(const void *, size_t, const void *, size_t);
527
Willy Tarreau482b00d2009-10-04 22:48:42 +0200528/* This function returns the first unused key greater than or equal to <key> in
529 * ID tree <root>. Zero is returned if no place is found.
530 */
531unsigned int get_next_id(struct eb_root *root, unsigned int key);
532
Willy Tarreau348238b2010-01-18 15:05:57 +0100533/* This function compares a sample word possibly followed by blanks to another
534 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
535 * otherwise zero. This intends to be used when checking HTTP headers for some
536 * values.
537 */
538int word_match(const char *sample, int slen, const char *word, int wlen);
539
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200540/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
541 * or the number of chars read in case of success.
542 */
543int buf2ip(const char *buf, size_t len, struct in_addr *dst);
Thierry FOURNIERd559dd82013-11-22 16:16:59 +0100544int buf2ip6(const char *buf, size_t len, struct in6_addr *dst);
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200545
Willy Tarreauacf95772010-06-14 19:09:21 +0200546/* To be used to quote config arg positions. Returns the string at <ptr>
547 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
548 * if ptr is NULL or empty. The string is locally allocated.
549 */
550const char *quote_arg(const char *ptr);
551
Willy Tarreau5b180202010-07-18 10:40:48 +0200552/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
553int get_std_op(const char *str);
554
Willy Tarreau4c14eaa2010-11-24 14:01:45 +0100555/* hash a 32-bit integer to another 32-bit integer */
556extern unsigned int full_hash(unsigned int a);
557static inline unsigned int __full_hash(unsigned int a)
558{
559 /* This function is one of Bob Jenkins' full avalanche hashing
560 * functions, which when provides quite a good distribution for little
561 * input variations. The result is quite suited to fit over a 32-bit
562 * space with enough variations so that a randomly picked number falls
563 * equally before any server position.
564 * Check http://burtleburtle.net/bob/hash/integer.html for more info.
565 */
566 a = (a+0x7ed55d16) + (a<<12);
567 a = (a^0xc761c23c) ^ (a>>19);
568 a = (a+0x165667b1) + (a<<5);
569 a = (a+0xd3a2646c) ^ (a<<9);
570 a = (a+0xfd7046c5) + (a<<3);
571 a = (a^0xb55a4f09) ^ (a>>16);
572
573 /* ensure values are better spread all around the tree by multiplying
574 * by a large prime close to 3/4 of the tree.
575 */
576 return a * 3221225473U;
577}
578
Willy Tarreau422a0a52012-10-26 19:47:23 +0200579/* sets the address family to AF_UNSPEC so that is_addr() does not match */
580static inline void clear_addr(struct sockaddr_storage *addr)
581{
582 addr->ss_family = AF_UNSPEC;
583}
584
David du Colombier6f5ccb12011-03-10 22:26:24 +0100585/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
586 * otherwise zero.
587 */
588static inline int is_addr(struct sockaddr_storage *addr)
589{
590 int i;
591
592 switch (addr->ss_family) {
593 case AF_INET:
David du Colombier64e9c902011-03-22 11:39:41 +0100594 return *(int *)&((struct sockaddr_in *)addr)->sin_addr;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100595 case AF_INET6:
596 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
597 if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0)
598 return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i];
599 }
600 return 0;
601}
602
David du Colombier11bcb6c2011-03-24 12:23:00 +0100603/* returns port in network byte order */
604static inline int get_net_port(struct sockaddr_storage *addr)
605{
606 switch (addr->ss_family) {
607 case AF_INET:
608 return ((struct sockaddr_in *)addr)->sin_port;
609 case AF_INET6:
610 return ((struct sockaddr_in6 *)addr)->sin6_port;
611 }
612 return 0;
613}
614
615/* returns port in host byte order */
616static inline int get_host_port(struct sockaddr_storage *addr)
617{
618 switch (addr->ss_family) {
619 case AF_INET:
620 return ntohs(((struct sockaddr_in *)addr)->sin_port);
621 case AF_INET6:
622 return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
623 }
624 return 0;
625}
626
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +0200627/* returns address len for <addr>'s family, 0 for unknown families */
628static inline int get_addr_len(const struct sockaddr_storage *addr)
629{
630 switch (addr->ss_family) {
631 case AF_INET:
632 return sizeof(struct sockaddr_in);
633 case AF_INET6:
634 return sizeof(struct sockaddr_in6);
635 case AF_UNIX:
636 return sizeof(struct sockaddr_un);
637 }
638 return 0;
639}
640
David du Colombier11bcb6c2011-03-24 12:23:00 +0100641/* set port in host byte order */
642static inline int set_net_port(struct sockaddr_storage *addr, int port)
643{
644 switch (addr->ss_family) {
645 case AF_INET:
646 ((struct sockaddr_in *)addr)->sin_port = port;
647 case AF_INET6:
648 ((struct sockaddr_in6 *)addr)->sin6_port = port;
649 }
650 return 0;
651}
652
653/* set port in network byte order */
654static inline int set_host_port(struct sockaddr_storage *addr, int port)
655{
656 switch (addr->ss_family) {
657 case AF_INET:
658 ((struct sockaddr_in *)addr)->sin_port = htons(port);
659 case AF_INET6:
660 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
661 }
662 return 0;
663}
664
David du Colombier4f92d322011-03-24 11:09:31 +0100665/* Return true if IPv4 address is part of the network */
666extern int in_net_ipv4(struct in_addr *addr, struct in_addr *mask, struct in_addr *net);
667
668/* Return true if IPv6 address is part of the network */
669extern int in_net_ipv6(struct in6_addr *addr, struct in6_addr *mask, struct in6_addr *net);
670
671/* Map IPv4 adress on IPv6 address, as specified in RFC 3513. */
672extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr);
673
674/* Map IPv6 adress on IPv4 address, as specified in RFC 3513.
675 * Return true if conversion is possible and false otherwise.
676 */
677extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr);
678
William Lallemand421f5b52012-02-06 18:15:57 +0100679char *human_time(int t, short hz_div);
680
681extern const char *monthname[];
682
Yuxans Yao4e25b012012-10-19 10:36:09 +0800683/* numeric timezone (that is, the hour and minute offset from UTC) */
684char localtimezone[6];
685
William Lallemand421f5b52012-02-06 18:15:57 +0100686/* date2str_log: write a date in the format :
687 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
688 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
689 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
690 *
691 * without using sprintf. return a pointer to the last char written (\0) or
692 * NULL if there isn't enough space.
693 */
694char *date2str_log(char *dest, struct tm *tm, struct timeval *date, size_t size);
695
696/* gmt2str_log: write a date in the format :
697 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
698 * return a pointer to the last char written (\0) or
699 * NULL if there isn't enough space.
700 */
701char *gmt2str_log(char *dst, struct tm *tm, size_t size);
702
Yuxans Yao4e25b012012-10-19 10:36:09 +0800703/* localdate2str_log: write a date in the format :
704 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
705 * return a pointer to the last char written (\0) or
706 * NULL if there isn't enough space.
707 */
708char *localdate2str_log(char *dst, struct tm *tm, size_t size);
709
Willy Tarreau9a7bea52012-04-27 11:16:50 +0200710/* Dynamically allocates a string of the proper length to hold the formatted
711 * output. NULL is returned on error. The caller is responsible for freeing the
712 * memory area using free(). The resulting string is returned in <out> if the
713 * pointer is not NULL. A previous version of <out> might be used to build the
714 * new string, and it will be freed before returning if it is not NULL, which
715 * makes it possible to build complex strings from iterative calls without
716 * having to care about freeing intermediate values, as in the example below :
717 *
718 * memprintf(&err, "invalid argument: '%s'", arg);
719 * ...
720 * memprintf(&err, "parser said : <%s>\n", *err);
721 * ...
722 * free(*err);
723 *
724 * This means that <err> must be initialized to NULL before first invocation.
725 * The return value also holds the allocated string, which eases error checking
726 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200727 * passed instead and it will be ignored. The returned message will then also
728 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +0200729 *
730 * It is also convenient to use it without any free except the last one :
731 * err = NULL;
732 * if (!fct1(err)) report(*err);
733 * if (!fct2(err)) report(*err);
734 * if (!fct3(err)) report(*err);
735 * free(*err);
736 */
737char *memprintf(char **out, const char *format, ...)
738 __attribute__ ((format(printf, 2, 3)));
739
Willy Tarreau21c705b2012-09-14 11:40:36 +0200740/* Used to add <level> spaces before each line of <out>, unless there is only one line.
741 * The input argument is automatically freed and reassigned. The result will have to be
742 * freed by the caller.
743 * Example of use :
744 * parse(cmd, &err); (callee: memprintf(&err, ...))
745 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
746 * free(err);
747 */
748char *indent_msg(char **out, int level);
Willy Tarreau3d2f16f2012-05-13 00:21:17 +0200749
Willy Tarreaudad36a32013-03-11 01:20:04 +0100750/* Convert occurrences of environment variables in the input string to their
751 * corresponding value. A variable is identified as a series of alphanumeric
752 * characters or underscores following a '$' sign. The <in> string must be
753 * free()able. NULL returns NULL. The resulting string might be reallocated if
754 * some expansion is made.
755 */
756char *env_expand(char *in);
757
Willy Tarreau3d2f16f2012-05-13 00:21:17 +0200758/* debugging macro to emit messages using write() on fd #-1 so that strace sees
759 * them.
760 */
761#define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0)
762
de Lafond Guillaume88c278f2013-04-15 19:27:10 +0200763/* same as strstr() but case-insensitive */
764const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2);
765
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200766#endif /* _COMMON_STANDARD_H */