blob: cd2208ca1b0119b12b3f79a416833043b19e3e89 [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 Tarreaue6e49cf2015-04-29 17:13:35 +020028#include <sys/time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020029#include <sys/types.h>
Willy Tarreaud50265a2012-09-04 14:18:33 +020030#include <sys/socket.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020031#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032#include <netinet/in.h>
Willy Tarreau5b4dd682015-07-21 23:47:18 +020033#include <arpa/inet.h>
Thierry FOURNIERe059ec92014-03-17 12:01:13 +010034#include <common/chunk.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020035#include <common/config.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010036#include <eb32tree.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020037
William Lallemande7340ec2012-01-24 11:15:39 +010038#ifndef LLONG_MAX
39# define LLONG_MAX 9223372036854775807LL
40# define LLONG_MIN (-LLONG_MAX - 1LL)
41#endif
42
43#ifndef ULLONG_MAX
44# define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
45#endif
46
Willy Tarreaua9db57e2013-01-18 11:29:29 +010047#ifndef LONGBITS
48#define LONGBITS ((unsigned int)sizeof(long) * 8)
49#endif
50
Thierry FOURNIER511e9472014-01-23 17:40:34 +010051/* size used for max length of decimal representation of long long int. */
52#define NB_LLMAX_STR (sizeof("-9223372036854775807")-1)
53
Willy Tarreau56adcf22012-12-23 18:00:29 +010054/* number of itoa_str entries */
55#define NB_ITOA_STR 10
William Lallemande7340ec2012-01-24 11:15:39 +010056
Willy Tarreau588297f2014-06-16 15:16:40 +020057/* maximum quoted string length (truncated above) */
58#define QSTR_SIZE 200
59#define NB_QSTR 10
60
Willy Tarreaubaaee002006-06-26 02:48:02 +020061/****** string-specific macros and functions ******/
62/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
63#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
64
65/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
66#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
67
68/* returns 1 only if only zero or one bit is set in X, which means that X is a
69 * power of 2, and 0 otherwise */
70#define POWEROF2(x) (((x) & ((x)-1)) == 0)
71
Willy Tarreau5b180202010-07-18 10:40:48 +020072/* operators to compare values. They're ordered that way so that the lowest bit
73 * serves as a negation for the test and contains all tests that are not equal.
74 */
75enum {
76 STD_OP_LE = 0, STD_OP_GT = 1,
77 STD_OP_EQ = 2, STD_OP_NE = 3,
78 STD_OP_GE = 4, STD_OP_LT = 5,
79};
80
Thierry FOURNIER9f95e402014-03-21 14:51:46 +010081enum http_scheme {
82 SCH_HTTP,
83 SCH_HTTPS,
84};
85
86struct split_url {
87 enum http_scheme scheme;
88 const char *host;
89 int host_len;
90};
91
Willy Tarreau56adcf22012-12-23 18:00:29 +010092extern int itoa_idx; /* index of next itoa_str to use */
93
Willy Tarreau7d58a632007-01-13 23:06:06 +010094/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020095 * copies at most <size-1> chars from <src> to <dst>. Last char is always
96 * set to 0, unless <size> is 0. The number of chars copied is returned
97 * (excluding the terminating zero).
98 * This code has been optimized for size and speed : on x86, it's 45 bytes
99 * long, uses only registers, and consumes only 4 cycles per char.
100 */
101extern int strlcpy2(char *dst, const char *src, int size);
102
103/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200104 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200105 * the ascii representation for number 'n' in decimal.
106 */
Willy Tarreaue7239b52009-03-29 13:41:58 +0200107extern char itoa_str[][171];
Emeric Brun3a7fce52010-01-04 14:54:38 +0100108extern char *ultoa_r(unsigned long n, char *buffer, int size);
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200109extern char *lltoa_r(long long int n, char *buffer, int size);
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200110extern char *sltoa_r(long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +0200111extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +0200112static inline const char *ultoa(unsigned long n)
113{
114 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
115}
116
William Lallemande7340ec2012-01-24 11:15:39 +0100117/*
118 * unsigned long long ASCII representation
119 *
120 * return the last char '\0' or NULL if no enough
121 * space in dst
122 */
123char *ulltoa(unsigned long long n, char *dst, size_t size);
124
125
126/*
127 * unsigned long ASCII representation
128 *
129 * return the last char '\0' or NULL if no enough
130 * space in dst
131 */
132char *ultoa_o(unsigned long n, char *dst, size_t size);
133
134/*
135 * signed long ASCII representation
136 *
137 * return the last char '\0' or NULL if no enough
138 * space in dst
139 */
140char *ltoa_o(long int n, char *dst, size_t size);
141
142/*
143 * signed long long ASCII representation
144 *
145 * return the last char '\0' or NULL if no enough
146 * space in dst
147 */
148char *lltoa(long long n, char *dst, size_t size);
149
150/*
151 * write a ascii representation of a unsigned into dst,
152 * return a pointer to the last character
153 * Pad the ascii representation with '0', using size.
154 */
155char *utoa_pad(unsigned int n, char *dst, size_t size);
156
Willy Tarreaubaaee002006-06-26 02:48:02 +0200157/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200158 * This function simply returns a locally allocated string containing the ascii
159 * representation for number 'n' in decimal, unless n is 0 in which case it
160 * returns the alternate string (or an empty string if the alternate string is
161 * NULL). It use is intended for limits reported in reports, where it's
162 * desirable not to display anything if there is no limit. Warning! it shares
163 * the same vector as ultoa_r().
164 */
165extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
166
Willy Tarreau56adcf22012-12-23 18:00:29 +0100167/* returns a locally allocated string containing the ASCII representation of
168 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
169 * function call (eg: printf), shared with the other similar functions making
170 * use of itoa_str[].
171 */
172static inline const char *U2A(unsigned long n)
173{
174 const char *ret = ultoa_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
175 if (++itoa_idx >= NB_ITOA_STR)
176 itoa_idx = 0;
177 return ret;
178}
179
180/* returns a locally allocated string containing the HTML representation of
181 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
182 * function call (eg: printf), shared with the other similar functions making
183 * use of itoa_str[].
Willy Tarreau91092e52007-10-25 16:58:42 +0200184 */
Willy Tarreau56adcf22012-12-23 18:00:29 +0100185static inline const char *U2H(unsigned long long n)
186{
187 const char *ret = ulltoh_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]));
188 if (++itoa_idx >= NB_ITOA_STR)
189 itoa_idx = 0;
190 return ret;
191}
192
193/* returns a locally allocated string containing the HTML representation of
194 * the number 'n' in decimal. Up to NB_ITOA_STR calls may be used in the same
195 * function call (eg: printf), shared with the other similar functions making
196 * use of itoa_str[].
197 */
198static inline const char *LIM2A(unsigned long n, const char *alt)
199{
200 const char *ret = limit_r(n, itoa_str[itoa_idx], sizeof(itoa_str[0]), alt);
201 if (++itoa_idx >= NB_ITOA_STR)
202 itoa_idx = 0;
203 return ret;
204}
Willy Tarreau91092e52007-10-25 16:58:42 +0200205
Willy Tarreau588297f2014-06-16 15:16:40 +0200206/* returns a locally allocated string containing the quoted encoding of the
207 * input string. The output may be truncated to QSTR_SIZE chars, but it is
208 * guaranteed that the string will always be properly terminated. Quotes are
209 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
210 * always be at least 4 chars.
211 */
212const char *qstr(const char *str);
213
214/* returns <str> or its quote-encoded equivalent if it contains at least one
215 * quote or a comma. This is aimed at build CSV-compatible strings.
216 */
217static inline const char *cstr(const char *str)
218{
219 const char *p = str;
220
221 while (*p) {
222 if (*p == ',' || *p == '"')
223 return qstr(str);
224 p++;
225 }
226 return str;
227}
228
Willy Tarreau91092e52007-10-25 16:58:42 +0200229/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200230 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
231 */
232extern int ishex(char s);
233
234/*
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100235 * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F),
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200236 * otherwise -1. This compact form helps gcc produce efficient code.
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100237 */
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200238static inline int hex2i(int c)
239{
Willy Tarreau0161d622013-04-02 01:26:55 +0200240 if (unlikely((unsigned char)(c -= '0') > 9)) {
241 if (likely((unsigned char)(c -= 'A' - '0') > 5 &&
242 (unsigned char)(c -= 'a' - 'A') > 5))
Willy Tarreau3dd0c4e2012-10-26 00:58:22 +0200243 c = -11;
244 c += 10;
245 }
246 return c;
247}
248
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100249/* rounds <i> down to the closest value having max 2 digits */
250unsigned int round_2dig(unsigned int i);
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100251
252/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100253 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
254 * invalid character is found, a pointer to it is returned. If everything is
255 * fine, NULL is returned.
256 */
257extern const char *invalid_char(const char *name);
258
259/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200260 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
261 * If an invalid character is found, a pointer to it is returned.
262 * If everything is fine, NULL is returned.
263 */
264extern const char *invalid_domainchar(const char *name);
265
266/*
Willy Tarreaufab5a432011-03-04 15:31:53 +0100267 * converts <str> to a locally allocated struct sockaddr_storage *, and a
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200268 * port range consisting in two integers. The low and high end are always set
269 * even if the port is unspecified, in which case (0,0) is returned. The low
Willy Tarreaufab5a432011-03-04 15:31:53 +0100270 * port is set in the sockaddr. Thus, it is enough to check the size of the
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200271 * returned range to know if an array must be allocated or not. The format is
Willy Tarreaufab5a432011-03-04 15:31:53 +0100272 * "addr[:[port[-port]]]", where "addr" can be a dotted IPv4 address, an IPv6
273 * address, a host name, or empty or "*" to indicate INADDR_ANY. If an IPv6
274 * address wants to ignore port, it must be terminated by a trailing colon (':').
275 * The IPv6 '::' address is IN6ADDR_ANY, so in order to bind to a given port on
276 * IPv6, use ":::port". NULL is returned if the host part cannot be resolved.
Willy Tarreaud393a622013-03-04 18:22:00 +0100277 * If <pfx> is non-null, it is used as a string prefix before any path-based
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200278 * address (typically the path to a unix socket). If use_dns is not true,
279 * the funtion cannot accept the DNS resolution.
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200280 */
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200281struct sockaddr_storage *str2sa_range(const char *str, int *low, int *high, char **err, const char *pfx, char **fqdn, int use_dns);
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200282
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100283/* converts <str> to a struct in_addr containing a network mask. It can be
284 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
285 * if the conversion succeeds otherwise non-zero.
286 */
287int str2mask(const char *str, struct in_addr *mask);
288
Thierry FOURNIERb0504632013-12-14 15:39:02 +0100289/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
290 * succeeds otherwise non-zero.
291 */
292int cidr2dotted(int cidr, struct in_addr *mask);
293
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200294/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200295 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200296 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
297 * is optionnal and either in the dotted or CIDR notation.
298 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
299 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +0100300int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200301
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100302/* str2ip and str2ip2:
303 *
304 * converts <str> to a struct sockaddr_storage* provided by the caller. The
305 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
306 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
307 * the function tries to guess the address family from the syntax. If the
308 * family is forced and the format doesn't match, an error is returned. The
309 * string is assumed to contain only an address, no port. The address can be a
310 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
311 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
312 * The return address will only have the address family and the address set,
313 * all other fields remain zero. The string is not supposed to be modified.
314 * The IPv6 '::' address is IN6ADDR_ANY.
315 *
316 * str2ip2:
317 *
318 * If <resolve> is set, this function try to resolve DNS, otherwise, it returns
319 * NULL result.
320 */
321struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve);
322static inline struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa)
323{
324 return str2ip2(str, sa, 1);
325}
326
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100327/*
Willy Tarreau6d20e282012-04-27 22:49:47 +0200328 * converts <str> to two struct in6_addr* which must be pre-allocated.
329 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
330 * is an optionnal number of bits (128 being the default).
331 * Returns 1 if OK, 0 if error.
332 */
333int str62net(const char *str, struct in6_addr *addr, unsigned char *mask);
334
335/*
Willy Tarreau106f9792009-09-19 07:54:16 +0200336 * Parse IP address found in url.
337 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100338int url2ipv4(const char *addr, struct in_addr *dst);
Willy Tarreau106f9792009-09-19 07:54:16 +0200339
340/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100341 * Resolve destination server from URL. Convert <str> to a sockaddr_storage*.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100342 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +0100343int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100344
Willy Tarreau631f01c2011-09-05 00:36:48 +0200345/* Tries to convert a sockaddr_storage address to text form. Upon success, the
346 * address family is returned so that it's easy for the caller to adapt to the
347 * output format. Zero is returned if the address family is not supported. -1
348 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
349 * supported.
350 */
351int addr_to_str(struct sockaddr_storage *addr, char *str, int size);
352
Simon Horman75ab8bd2014-06-16 09:39:41 +0900353/* Tries to convert a sockaddr_storage port to text form. Upon success, the
354 * address family is returned so that it's easy for the caller to adapt to the
355 * output format. Zero is returned if the address family is not supported. -1
356 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
357 * supported.
358 */
359int port_to_str(struct sockaddr_storage *addr, char *str, int size);
360
Willy Tarreaubaaee002006-06-26 02:48:02 +0200361/* will try to encode the string <string> replacing all characters tagged in
362 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
363 * prefixed by <escape>, and will store the result between <start> (included)
364 * and <stop> (excluded), and will always terminate the string with a '\0'
365 * before <stop>. The position of the '\0' is returned if the conversion
366 * completes. If bytes are missing between <start> and <stop>, then the
367 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
368 * cannot even be stored so we return <start> without writing the 0.
369 * The input string must also be zero-terminated.
370 */
371extern const char hextab[];
372char *encode_string(char *start, char *stop,
373 const char escape, const fd_set *map,
374 const char *string);
375
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100376/*
377 * Same behavior, except that it encodes chunk <chunk> instead of a string.
378 */
379char *encode_chunk(char *start, char *stop,
380 const char escape, const fd_set *map,
381 const struct chunk *chunk);
382
Dragan Dosen0edd1092016-02-12 13:23:02 +0100383/*
384 * Tries to prefix characters tagged in the <map> with the <escape>
385 * character. <chunk> contains the input to be escaped. The result will be
386 * stored between <start> (included) and <stop> (excluded). The function
387 * will always try to terminate the resulting string with a '\0' before
388 * <stop>, and will return its position if the conversion completes.
389 */
390char *escape_chunk(char *start, char *stop,
391 const char escape, const fd_set *map,
392 const struct chunk *chunk);
393
Thierry FOURNIERe059ec92014-03-17 12:01:13 +0100394
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200395/* Check a string for using it in a CSV output format. If the string contains
396 * one of the following four char <">, <,>, CR or LF, the string is
397 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
398 * <str> is the input string to be escaped. The function assumes that
399 * the input string is null-terminated.
400 *
401 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +0100402 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200403 * format.
404 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100405 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200406 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100407 * If <quote> is 1, the converter puts the quotes only if any character is
408 * escaped. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200409 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100410 * <output> is a struct chunk used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200411 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100412 * The function returns the converted string on its output. If an error
413 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200414 * for using the function directly as printf() argument.
415 *
Willy Tarreau898529b2016-01-06 18:07:04 +0100416 * If the output buffer is too short to contain the input string, the result
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200417 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +0100418 *
419 * This function appends the encoding to the existing output chunk. Please
420 * use csv_enc() instead if you want to replace the output chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200421 */
Willy Tarreau898529b2016-01-06 18:07:04 +0100422const char *csv_enc_append(const char *str, int quote, struct chunk *output);
423
424/* same as above but the output chunk is reset first */
425static inline const char *csv_enc(const char *str, int quote, struct chunk *output)
426{
427 chunk_reset(output);
428 return csv_enc_append(str, quote, output);
429}
Thierry FOURNIERddea6262015-05-28 16:00:28 +0200430
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +0200431/* Decode an URL-encoded string in-place. The resulting string might
432 * be shorter. If some forbidden characters are found, the conversion is
433 * aborted, the string is truncated before the issue and non-zero is returned,
434 * otherwise the operation returns non-zero indicating success.
435 */
436int url_decode(char *string);
437
Willy Tarreau6911fa42007-03-04 18:06:08 +0100438/* This one is 6 times faster than strtoul() on athlon, but does
439 * no check at all.
440 */
441static inline unsigned int __str2ui(const char *s)
442{
443 unsigned int i = 0;
444 while (*s) {
445 i = i * 10 - '0';
446 i += (unsigned char)*s++;
447 }
448 return i;
449}
450
451/* This one is 5 times faster than strtoul() on athlon with checks.
452 * It returns the value of the number composed of all valid digits read.
453 */
454static inline unsigned int __str2uic(const char *s)
455{
456 unsigned int i = 0;
457 unsigned int j;
458 while (1) {
459 j = (*s++) - '0';
460 if (j > 9)
461 break;
462 i *= 10;
463 i += j;
464 }
465 return i;
466}
467
468/* This one is 28 times faster than strtoul() on athlon, but does
469 * no check at all!
470 */
471static inline unsigned int __strl2ui(const char *s, int len)
472{
473 unsigned int i = 0;
474 while (len-- > 0) {
475 i = i * 10 - '0';
476 i += (unsigned char)*s++;
477 }
478 return i;
479}
480
481/* This one is 7 times faster than strtoul() on athlon with checks.
482 * It returns the value of the number composed of all valid digits read.
483 */
484static inline unsigned int __strl2uic(const char *s, int len)
485{
486 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200487 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100488
489 while (len-- > 0) {
490 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200491 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100492 if (j > 9)
493 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200494 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100495 }
496 return i;
497}
498
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200499/* This function reads an unsigned integer from the string pointed to by <s>
500 * and returns it. The <s> pointer is adjusted to point to the first unread
501 * char. The function automatically stops at <end>.
502 */
503static inline unsigned int __read_uint(const char **s, const char *end)
504{
505 const char *ptr = *s;
506 unsigned int i = 0;
507 unsigned int j, k;
508
509 while (ptr < end) {
510 j = *ptr - '0';
511 k = i * 10;
512 if (j > 9)
513 break;
514 i = k + j;
515 ptr++;
516 }
517 *s = ptr;
518 return i;
519}
520
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200521unsigned long long int read_uint64(const char **s, const char *end);
522long long int read_int64(const char **s, const char *end);
523
Willy Tarreau6911fa42007-03-04 18:06:08 +0100524extern unsigned int str2ui(const char *s);
525extern unsigned int str2uic(const char *s);
526extern unsigned int strl2ui(const char *s, int len);
527extern unsigned int strl2uic(const char *s, int len);
528extern int strl2ic(const char *s, int len);
529extern int strl2irc(const char *s, int len, int *ret);
530extern int strl2llrc(const char *s, int len, long long *ret);
Thierry FOURNIER511e9472014-01-23 17:40:34 +0100531extern int strl2llrc_dotted(const char *text, int len, long long *ret);
Willy Tarreau4ec83cd2010-10-15 23:19:55 +0200532extern unsigned int read_uint(const char **s, const char *end);
Willy Tarreaud54bbdc2009-09-07 11:00:31 +0200533unsigned int inetaddr_host(const char *text);
534unsigned int inetaddr_host_lim(const char *text, const char *stop);
Willy Tarreau74172752010-10-15 23:21:42 +0200535unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret);
Willy Tarreau6911fa42007-03-04 18:06:08 +0100536
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200537static inline char *cut_crlf(char *s) {
538
Simon Horman5269cfb2013-02-13 17:48:00 +0900539 while (*s != '\r' && *s != '\n') {
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200540 char *p = s++;
541
542 if (!*p)
543 return p;
544 }
545
Simon Horman5269cfb2013-02-13 17:48:00 +0900546 *s++ = '\0';
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200547
548 return s;
549}
550
551static inline char *ltrim(char *s, char c) {
552
553 if (c)
554 while (*s == c)
555 s++;
556
557 return s;
558}
559
560static inline char *rtrim(char *s, char c) {
561
562 char *p = s + strlen(s);
563
564 while (p-- > s)
565 if (*p == c)
566 *p = '\0';
567 else
568 break;
569
570 return s;
571}
572
573static inline char *alltrim(char *s, char c) {
574
575 rtrim(s, c);
576
577 return ltrim(s, c);
578}
579
Willy Tarreaufe944602007-10-25 10:34:16 +0200580/* This function converts the time_t value <now> into a broken out struct tm
581 * which must be allocated by the caller. It is highly recommended to use this
582 * function intead of localtime() because that one requires a time_t* which
583 * is not always compatible with tv_sec depending on OS/hardware combinations.
584 */
585static inline void get_localtime(const time_t now, struct tm *tm)
586{
587 localtime_r(&now, tm);
588}
589
Emeric Brun3a058f32009-06-30 18:26:00 +0200590/* This function converts the time_t value <now> into a broken out struct tm
591 * which must be allocated by the caller. It is highly recommended to use this
592 * function intead of gmtime() because that one requires a time_t* which
593 * is not always compatible with tv_sec depending on OS/hardware combinations.
594 */
595static inline void get_gmtime(const time_t now, struct tm *tm)
596{
597 gmtime_r(&now, tm);
598}
599
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100600/* This function parses a time value optionally followed by a unit suffix among
601 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
602 * expected by the caller. The computation does its best to avoid overflows.
603 * The value is returned in <ret> if everything is fine, and a NULL is returned
604 * by the function. In case of error, a pointer to the error is returned and
605 * <ret> is left untouched.
606 */
607extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
Emeric Brun39132b22010-01-04 14:57:24 +0100608extern const char *parse_size_err(const char *text, unsigned *ret);
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100609
610/* unit flags to pass to parse_time_err */
611#define TIME_UNIT_US 0x0000
612#define TIME_UNIT_MS 0x0001
613#define TIME_UNIT_S 0x0002
614#define TIME_UNIT_MIN 0x0003
615#define TIME_UNIT_HOUR 0x0004
616#define TIME_UNIT_DAY 0x0005
617#define TIME_UNIT_MASK 0x0007
618
William Lallemand421f5b52012-02-06 18:15:57 +0100619#define SEC 1
620#define MINUTE (60 * SEC)
621#define HOUR (60 * MINUTE)
622#define DAY (24 * HOUR)
623
Willy Tarreau7f062c42009-03-05 18:43:00 +0100624/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
625 * This is used to compute fixed ratios by setting one of the operands to
626 * (2^32*ratio).
627 */
628static inline unsigned int mul32hi(unsigned int a, unsigned int b)
629{
630 return ((unsigned long long)a * b) >> 32;
631}
632
Willy Tarreauf0d9eec2010-06-20 07:12:37 +0200633/* gcc does not know when it can safely divide 64 bits by 32 bits. Use this
634 * function when you know for sure that the result fits in 32 bits, because
635 * it is optimal on x86 and on 64bit processors.
636 */
637static inline unsigned int div64_32(unsigned long long o1, unsigned int o2)
638{
639 unsigned int result;
640#ifdef __i386__
641 asm("divl %2"
642 : "=a" (result)
643 : "A"(o1), "rm"(o2));
644#else
645 result = o1 / o2;
646#endif
647 return result;
648}
649
David Carliere6c39412015-07-02 07:00:17 +0000650/* Simple popcountl implementation. It returns the number of ones in a word */
651static inline unsigned int my_popcountl(unsigned long a)
Willy Tarreau37994f02012-11-19 12:11:07 +0100652{
653 unsigned int cnt;
654 for (cnt = 0; a; a >>= 1) {
655 if (a & 1)
656 cnt++;
657 }
658 return cnt;
659}
660
David Carliere6c39412015-07-02 07:00:17 +0000661/* Build a word with the <bits> lower bits set (reverse of my_popcountl) */
Willy Tarreaua9db57e2013-01-18 11:29:29 +0100662static inline unsigned long nbits(int bits)
663{
664 if (--bits < 0)
665 return 0;
666 else
667 return (2UL << bits) - 1;
668}
669
Willy Tarreau126d4062013-12-03 17:50:47 +0100670/*
671 * Parse binary string written in hexadecimal (source) and store the decoded
672 * result into binstr and set binstrlen to the lengh of binstr. Memory for
673 * binstr is allocated by the function. In case of error, returns 0 with an
674 * error message in err.
675 */
676int parse_binary(const char *source, char **binstr, int *binstrlen, char **err);
677
Willy Tarreau946ba592009-05-10 15:41:18 +0200678/* copies at most <n> characters from <src> and always terminates with '\0' */
679char *my_strndup(const char *src, int n);
680
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +0200681/*
682 * search needle in haystack
683 * returns the pointer if found, returns NULL otherwise
684 */
685const void *my_memmem(const void *, size_t, const void *, size_t);
686
Willy Tarreau482b00d2009-10-04 22:48:42 +0200687/* This function returns the first unused key greater than or equal to <key> in
688 * ID tree <root>. Zero is returned if no place is found.
689 */
690unsigned int get_next_id(struct eb_root *root, unsigned int key);
691
Willy Tarreau348238b2010-01-18 15:05:57 +0100692/* This function compares a sample word possibly followed by blanks to another
693 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
694 * otherwise zero. This intends to be used when checking HTTP headers for some
695 * values.
696 */
697int word_match(const char *sample, int slen, const char *word, int wlen);
698
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200699/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
700 * or the number of chars read in case of success.
701 */
702int buf2ip(const char *buf, size_t len, struct in_addr *dst);
Thierry FOURNIERd559dd82013-11-22 16:16:59 +0100703int buf2ip6(const char *buf, size_t len, struct in6_addr *dst);
Willy Tarreauf0b38bf2010-06-06 13:22:23 +0200704
Willy Tarreauacf95772010-06-14 19:09:21 +0200705/* To be used to quote config arg positions. Returns the string at <ptr>
706 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
707 * if ptr is NULL or empty. The string is locally allocated.
708 */
709const char *quote_arg(const char *ptr);
710
Willy Tarreau5b180202010-07-18 10:40:48 +0200711/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
712int get_std_op(const char *str);
713
Willy Tarreau4c14eaa2010-11-24 14:01:45 +0100714/* hash a 32-bit integer to another 32-bit integer */
715extern unsigned int full_hash(unsigned int a);
716static inline unsigned int __full_hash(unsigned int a)
717{
718 /* This function is one of Bob Jenkins' full avalanche hashing
719 * functions, which when provides quite a good distribution for little
720 * input variations. The result is quite suited to fit over a 32-bit
721 * space with enough variations so that a randomly picked number falls
722 * equally before any server position.
723 * Check http://burtleburtle.net/bob/hash/integer.html for more info.
724 */
725 a = (a+0x7ed55d16) + (a<<12);
726 a = (a^0xc761c23c) ^ (a>>19);
727 a = (a+0x165667b1) + (a<<5);
728 a = (a+0xd3a2646c) ^ (a<<9);
729 a = (a+0xfd7046c5) + (a<<3);
730 a = (a^0xb55a4f09) ^ (a>>16);
731
732 /* ensure values are better spread all around the tree by multiplying
733 * by a large prime close to 3/4 of the tree.
734 */
735 return a * 3221225473U;
736}
737
Willy Tarreau422a0a52012-10-26 19:47:23 +0200738/* sets the address family to AF_UNSPEC so that is_addr() does not match */
739static inline void clear_addr(struct sockaddr_storage *addr)
740{
741 addr->ss_family = AF_UNSPEC;
742}
743
David du Colombier6f5ccb12011-03-10 22:26:24 +0100744/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
745 * otherwise zero.
746 */
Willy Tarreau18ca2d42014-05-09 22:40:55 +0200747static inline int is_inet_addr(const struct sockaddr_storage *addr)
David du Colombier6f5ccb12011-03-10 22:26:24 +0100748{
749 int i;
750
751 switch (addr->ss_family) {
752 case AF_INET:
David du Colombier64e9c902011-03-22 11:39:41 +0100753 return *(int *)&((struct sockaddr_in *)addr)->sin_addr;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100754 case AF_INET6:
755 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
756 if (((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i] != 0)
757 return ((int *)&((struct sockaddr_in6 *)addr)->sin6_addr)[i];
758 }
759 return 0;
760}
761
Willy Tarreau18ca2d42014-05-09 22:40:55 +0200762/* returns non-zero if addr has a valid and non-null IPv4 or IPv6 address,
763 * or is a unix address, otherwise returns zero.
764 */
765static inline int is_addr(const struct sockaddr_storage *addr)
766{
767 if (addr->ss_family == AF_UNIX)
768 return 1;
769 else
770 return is_inet_addr(addr);
771}
772
David du Colombier11bcb6c2011-03-24 12:23:00 +0100773/* returns port in network byte order */
774static inline int get_net_port(struct sockaddr_storage *addr)
775{
776 switch (addr->ss_family) {
777 case AF_INET:
778 return ((struct sockaddr_in *)addr)->sin_port;
779 case AF_INET6:
780 return ((struct sockaddr_in6 *)addr)->sin6_port;
781 }
782 return 0;
783}
784
785/* returns port in host byte order */
786static inline int get_host_port(struct sockaddr_storage *addr)
787{
788 switch (addr->ss_family) {
789 case AF_INET:
790 return ntohs(((struct sockaddr_in *)addr)->sin_port);
791 case AF_INET6:
792 return ntohs(((struct sockaddr_in6 *)addr)->sin6_port);
793 }
794 return 0;
795}
796
Willy Tarreau1b4b7ce2011-04-05 16:56:50 +0200797/* returns address len for <addr>'s family, 0 for unknown families */
798static inline int get_addr_len(const struct sockaddr_storage *addr)
799{
800 switch (addr->ss_family) {
801 case AF_INET:
802 return sizeof(struct sockaddr_in);
803 case AF_INET6:
804 return sizeof(struct sockaddr_in6);
805 case AF_UNIX:
806 return sizeof(struct sockaddr_un);
807 }
808 return 0;
809}
810
David du Colombier11bcb6c2011-03-24 12:23:00 +0100811/* set port in host byte order */
812static inline int set_net_port(struct sockaddr_storage *addr, int port)
813{
814 switch (addr->ss_family) {
815 case AF_INET:
816 ((struct sockaddr_in *)addr)->sin_port = port;
817 case AF_INET6:
818 ((struct sockaddr_in6 *)addr)->sin6_port = port;
819 }
820 return 0;
821}
822
823/* set port in network byte order */
824static inline int set_host_port(struct sockaddr_storage *addr, int port)
825{
826 switch (addr->ss_family) {
827 case AF_INET:
828 ((struct sockaddr_in *)addr)->sin_port = htons(port);
829 case AF_INET6:
830 ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
831 }
832 return 0;
833}
834
Thierry Fournier70473a52016-02-17 17:12:14 +0100835/* Convert mask from bit length form to in_addr form.
836 * This function never fails.
837 */
838void len2mask4(int len, struct in_addr *addr);
839
840/* Convert mask from bit length form to in6_addr form.
841 * This function never fails.
842 */
843void len2mask6(int len, struct in6_addr *addr);
844
David du Colombier4f92d322011-03-24 11:09:31 +0100845/* Return true if IPv4 address is part of the network */
846extern int in_net_ipv4(struct in_addr *addr, struct in_addr *mask, struct in_addr *net);
847
848/* Return true if IPv6 address is part of the network */
849extern int in_net_ipv6(struct in6_addr *addr, struct in6_addr *mask, struct in6_addr *net);
850
851/* Map IPv4 adress on IPv6 address, as specified in RFC 3513. */
852extern void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr);
853
854/* Map IPv6 adress on IPv4 address, as specified in RFC 3513.
855 * Return true if conversion is possible and false otherwise.
856 */
857extern int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr);
858
William Lallemand421f5b52012-02-06 18:15:57 +0100859char *human_time(int t, short hz_div);
860
861extern const char *monthname[];
862
863/* date2str_log: write a date in the format :
864 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
865 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
866 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
867 *
868 * without using sprintf. return a pointer to the last char written (\0) or
869 * NULL if there isn't enough space.
870 */
871char *date2str_log(char *dest, struct tm *tm, struct timeval *date, size_t size);
872
Benoit GARNIERb413c2a2016-03-27 11:08:03 +0200873/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +0200874 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +0200875 * The string returned has the same format as returned by strftime(... "%z", tm).
876 * Offsets are kept in an internal cache for better performances.
877 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +0200878const char *get_gmt_offset(time_t t, struct tm *tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +0200879
William Lallemand421f5b52012-02-06 18:15:57 +0100880/* gmt2str_log: write a date in the format :
881 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
882 * return a pointer to the last char written (\0) or
883 * NULL if there isn't enough space.
884 */
885char *gmt2str_log(char *dst, struct tm *tm, size_t size);
886
Yuxans Yao4e25b012012-10-19 10:36:09 +0800887/* localdate2str_log: write a date in the format :
888 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +0200889 * Both t and tm must represent the same time.
Yuxans Yao4e25b012012-10-19 10:36:09 +0800890 * return a pointer to the last char written (\0) or
891 * NULL if there isn't enough space.
892 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +0200893char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size);
Yuxans Yao4e25b012012-10-19 10:36:09 +0800894
Thierry Fournier93127942016-01-20 18:49:45 +0100895/* These 3 functions parses date string and fills the
896 * corresponding broken-down time in <tm>. In succes case,
897 * it returns 1, otherwise, it returns 0.
898 */
899int parse_http_date(const char *date, int len, struct tm *tm);
900int parse_imf_date(const char *date, int len, struct tm *tm);
901int parse_rfc850_date(const char *date, int len, struct tm *tm);
902int parse_asctime_date(const char *date, int len, struct tm *tm);
903
Willy Tarreau9a7bea52012-04-27 11:16:50 +0200904/* Dynamically allocates a string of the proper length to hold the formatted
905 * output. NULL is returned on error. The caller is responsible for freeing the
906 * memory area using free(). The resulting string is returned in <out> if the
907 * pointer is not NULL. A previous version of <out> might be used to build the
908 * new string, and it will be freed before returning if it is not NULL, which
909 * makes it possible to build complex strings from iterative calls without
910 * having to care about freeing intermediate values, as in the example below :
911 *
912 * memprintf(&err, "invalid argument: '%s'", arg);
913 * ...
914 * memprintf(&err, "parser said : <%s>\n", *err);
915 * ...
916 * free(*err);
917 *
918 * This means that <err> must be initialized to NULL before first invocation.
919 * The return value also holds the allocated string, which eases error checking
920 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +0200921 * passed instead and it will be ignored. The returned message will then also
922 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +0200923 *
924 * It is also convenient to use it without any free except the last one :
925 * err = NULL;
926 * if (!fct1(err)) report(*err);
927 * if (!fct2(err)) report(*err);
928 * if (!fct3(err)) report(*err);
929 * free(*err);
930 */
931char *memprintf(char **out, const char *format, ...)
932 __attribute__ ((format(printf, 2, 3)));
933
Willy Tarreau21c705b2012-09-14 11:40:36 +0200934/* Used to add <level> spaces before each line of <out>, unless there is only one line.
935 * The input argument is automatically freed and reassigned. The result will have to be
936 * freed by the caller.
937 * Example of use :
938 * parse(cmd, &err); (callee: memprintf(&err, ...))
939 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
940 * free(err);
941 */
942char *indent_msg(char **out, int level);
Willy Tarreau3d2f16f2012-05-13 00:21:17 +0200943
Willy Tarreaudad36a32013-03-11 01:20:04 +0100944/* Convert occurrences of environment variables in the input string to their
945 * corresponding value. A variable is identified as a series of alphanumeric
946 * characters or underscores following a '$' sign. The <in> string must be
947 * free()able. NULL returns NULL. The resulting string might be reallocated if
948 * some expansion is made.
949 */
950char *env_expand(char *in);
951
Willy Tarreau3d2f16f2012-05-13 00:21:17 +0200952/* debugging macro to emit messages using write() on fd #-1 so that strace sees
953 * them.
954 */
955#define fddebug(msg...) do { char *_m = NULL; memprintf(&_m, ##msg); if (_m) write(-1, _m, strlen(_m)); free(_m); } while (0)
956
Willy Tarreau89efaed2013-12-13 15:14:55 +0100957/* used from everywhere just to drain results we don't want to read and which
958 * recent versions of gcc increasingly and annoyingly complain about.
959 */
960extern int shut_your_big_mouth_gcc_int;
961
962/* used from everywhere just to drain results we don't want to read and which
963 * recent versions of gcc increasingly and annoyingly complain about.
964 */
965static inline void shut_your_big_mouth_gcc(int r)
966{
967 shut_your_big_mouth_gcc_int = r;
968}
969
de Lafond Guillaume88c278f2013-04-15 19:27:10 +0200970/* same as strstr() but case-insensitive */
971const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2);
972
Willy Tarreaubb519c72014-01-28 23:04:39 +0100973
974/************************* Composite address manipulation *********************
975 * Composite addresses are simply unsigned long data in which the higher bits
976 * represent a pointer, and the two lower bits are flags. There are several
977 * places where we just want to associate one or two flags to a pointer (eg,
978 * to type it), and these functions permit this. The pointer is necessarily a
979 * 32-bit aligned pointer, as its two lower bits will be cleared and replaced
980 * with the flags.
981 *****************************************************************************/
982
983/* Masks the two lower bits of a composite address and converts it to a
984 * pointer. This is used to mix some bits with some aligned pointers to
985 * structs and to retrieve the original (32-bit aligned) pointer.
986 */
987static inline void *caddr_to_ptr(unsigned long caddr)
988{
989 return (void *)(caddr & ~3UL);
990}
991
992/* Only retrieves the two lower bits of a composite address. This is used to mix
993 * some bits with some aligned pointers to structs and to retrieve the original
994 * data (2 bits).
995 */
996static inline unsigned int caddr_to_data(unsigned long caddr)
997{
998 return (caddr & 3UL);
999}
1000
1001/* Combines the aligned pointer whose 2 lower bits will be masked with the bits
1002 * from <data> to form a composite address. This is used to mix some bits with
1003 * some aligned pointers to structs and to retrieve the original (32-bit aligned)
1004 * pointer.
1005 */
1006static inline unsigned long caddr_from_ptr(void *ptr, unsigned int data)
1007{
1008 return (((unsigned long)ptr) & ~3UL) + (data & 3);
1009}
1010
1011/* sets the 2 bits of <data> in the <caddr> composite address */
1012static inline unsigned long caddr_set_flags(unsigned long caddr, unsigned int data)
1013{
1014 return caddr | (data & 3);
1015}
1016
1017/* clears the 2 bits of <data> in the <caddr> composite address */
1018static inline unsigned long caddr_clr_flags(unsigned long caddr, unsigned int data)
1019{
1020 return caddr & ~(unsigned long)(data & 3);
1021}
1022
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02001023/* UTF-8 decoder status */
1024#define UTF8_CODE_OK 0x00
1025#define UTF8_CODE_OVERLONG 0x10
1026#define UTF8_CODE_INVRANGE 0x20
1027#define UTF8_CODE_BADSEQ 0x40
1028
1029unsigned char utf8_next(const char *s, int len, unsigned int *c);
1030
1031static inline unsigned char utf8_return_code(unsigned int code)
1032{
1033 return code & 0xf0;
1034}
1035
1036static inline unsigned char utf8_return_length(unsigned char code)
1037{
1038 return code & 0x0f;
1039}
1040
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001041/* Turns 64-bit value <a> from host byte order to network byte order.
1042 * The principle consists in letting the compiler detect we're playing
1043 * with a union and simplify most or all operations. The asm-optimized
1044 * htonl() version involving bswap (x86) / rev (arm) / other is a single
1045 * operation on little endian, or a NOP on big-endian. In both cases,
1046 * this lets the compiler "see" that we're rebuilding a 64-bit word from
1047 * two 32-bit quantities that fit into a 32-bit register. In big endian,
1048 * the whole code is optimized out. In little endian, with a decent compiler,
1049 * a few bswap and 2 shifts are left, which is the minimum acceptable.
1050 */
Joseph Lynchffaf30b2015-10-06 19:43:18 -07001051#ifndef htonll
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001052static inline unsigned long long htonll(unsigned long long a)
1053{
1054 union {
1055 struct {
1056 unsigned int w1;
1057 unsigned int w2;
1058 } by32;
1059 unsigned long long by64;
1060 } w = { .by64 = a };
1061 return ((unsigned long long)htonl(w.by32.w1) << 32) | htonl(w.by32.w2);
1062}
Joseph Lynchffaf30b2015-10-06 19:43:18 -07001063#endif
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001064
1065/* Turns 64-bit value <a> from network byte order to host byte order. */
Joseph Lynchffaf30b2015-10-06 19:43:18 -07001066#ifndef ntohll
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001067static inline unsigned long long ntohll(unsigned long long a)
1068{
1069 return htonll(a);
1070}
Joseph Lynchffaf30b2015-10-06 19:43:18 -07001071#endif
Willy Tarreau5b4dd682015-07-21 23:47:18 +02001072
Willy Tarreaue6e49cf2015-04-29 17:13:35 +02001073/* returns a 64-bit a timestamp with the finest resolution available. The
1074 * unit is intentionally not specified. It's mostly used to compare dates.
1075 */
1076#if defined(__i386__) || defined(__x86_64__)
1077static inline unsigned long long rdtsc()
1078{
1079 unsigned int a, d;
1080 asm volatile("rdtsc" : "=a" (a), "=d" (d));
1081 return a + ((unsigned long long)d << 32);
1082}
1083#else
1084static inline unsigned long long rdtsc()
1085{
1086 struct timeval tv;
1087 gettimeofday(&tv, NULL);
1088 return tv.tv_sec * 1000000 + tv.tv_usec;
1089}
1090#endif
1091
Willy Tarreau2dd0d472006-06-29 17:53:05 +02001092#endif /* _COMMON_STANDARD_H */