"Fossies" - the Fresh Open Source Software Archive

Member "haproxy-2.0.9/include/common/standard.h" (15 Nov 2019, 49074 Bytes) of package /linux/misc/haproxy-2.0.9.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "standard.h" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 2.0.5_vs_2.0.6.

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