blob: a67948ba59c1d280e8ddc0ad7fd60bea75adcd23 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * General purpose functions.
3 *
Willy Tarreau348238b2010-01-18 15:05:57 +01004 * Copyright 2000-2010 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau2e74c3f2007-12-02 18:45:09 +010013#include <ctype.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020014#include <errno.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020015#include <netdb.h>
Willy Tarreau9a7bea52012-04-27 11:16:50 +020016#include <stdarg.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020017#include <stdio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020018#include <stdlib.h>
19#include <string.h>
Thierry Fournier93127942016-01-20 18:49:45 +010020#include <time.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020021#include <unistd.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010022#include <sys/socket.h>
Willy Tarreau37101052019-05-20 16:48:20 +020023#include <sys/stat.h>
24#include <sys/types.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010025#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020026#include <netinet/in.h>
27#include <arpa/inet.h>
28
Thierry FOURNIERe059ec92014-03-17 12:01:13 +010029#include <common/chunk.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020030#include <common/config.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020031#include <common/standard.h>
Thierry Fournier93127942016-01-20 18:49:45 +010032#include <common/tools.h>
Thierry FOURNIER9f95e402014-03-21 14:51:46 +010033#include <types/global.h>
Baptiste Assmanna68ca962015-04-14 01:15:08 +020034#include <proto/dns.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010035#include <eb32tree.h>
Willy Tarreaued3cda02017-11-15 15:04:05 +010036#include <eb32sctree.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020037
Thierry Fournier93127942016-01-20 18:49:45 +010038/* This macro returns false if the test __x is false. Many
39 * of the following parsing function must be abort the processing
40 * if it returns 0, so this macro is useful for writing light code.
41 */
42#define RET0_UNLESS(__x) do { if (!(__x)) return 0; } while (0)
43
Willy Tarreau56adcf22012-12-23 18:00:29 +010044/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020045 * 2^64-1 = 18446744073709551615 or
46 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020047 *
48 * The HTML version needs room for adding the 25 characters
49 * '<span class="rls"></span>' around digits at positions 3N+1 in order
50 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020051 */
Christopher Faulet99bca652017-11-14 16:47:26 +010052THREAD_LOCAL char itoa_str[NB_ITOA_STR][171];
53THREAD_LOCAL int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020054
Willy Tarreau588297f2014-06-16 15:16:40 +020055/* sometimes we'll need to quote strings (eg: in stats), and we don't expect
56 * to quote strings larger than a max configuration line.
57 */
Christopher Faulet99bca652017-11-14 16:47:26 +010058THREAD_LOCAL char quoted_str[NB_QSTR][QSTR_SIZE + 1];
59THREAD_LOCAL int quoted_idx = 0;
Willy Tarreau588297f2014-06-16 15:16:40 +020060
Willy Tarreaubaaee002006-06-26 02:48:02 +020061/*
William Lallemande7340ec2012-01-24 11:15:39 +010062 * unsigned long long ASCII representation
63 *
64 * return the last char '\0' or NULL if no enough
65 * space in dst
66 */
67char *ulltoa(unsigned long long n, char *dst, size_t size)
68{
69 int i = 0;
70 char *res;
71
72 switch(n) {
73 case 1ULL ... 9ULL:
74 i = 0;
75 break;
76
77 case 10ULL ... 99ULL:
78 i = 1;
79 break;
80
81 case 100ULL ... 999ULL:
82 i = 2;
83 break;
84
85 case 1000ULL ... 9999ULL:
86 i = 3;
87 break;
88
89 case 10000ULL ... 99999ULL:
90 i = 4;
91 break;
92
93 case 100000ULL ... 999999ULL:
94 i = 5;
95 break;
96
97 case 1000000ULL ... 9999999ULL:
98 i = 6;
99 break;
100
101 case 10000000ULL ... 99999999ULL:
102 i = 7;
103 break;
104
105 case 100000000ULL ... 999999999ULL:
106 i = 8;
107 break;
108
109 case 1000000000ULL ... 9999999999ULL:
110 i = 9;
111 break;
112
113 case 10000000000ULL ... 99999999999ULL:
114 i = 10;
115 break;
116
117 case 100000000000ULL ... 999999999999ULL:
118 i = 11;
119 break;
120
121 case 1000000000000ULL ... 9999999999999ULL:
122 i = 12;
123 break;
124
125 case 10000000000000ULL ... 99999999999999ULL:
126 i = 13;
127 break;
128
129 case 100000000000000ULL ... 999999999999999ULL:
130 i = 14;
131 break;
132
133 case 1000000000000000ULL ... 9999999999999999ULL:
134 i = 15;
135 break;
136
137 case 10000000000000000ULL ... 99999999999999999ULL:
138 i = 16;
139 break;
140
141 case 100000000000000000ULL ... 999999999999999999ULL:
142 i = 17;
143 break;
144
145 case 1000000000000000000ULL ... 9999999999999999999ULL:
146 i = 18;
147 break;
148
149 case 10000000000000000000ULL ... ULLONG_MAX:
150 i = 19;
151 break;
152 }
153 if (i + 2 > size) // (i + 1) + '\0'
154 return NULL; // too long
155 res = dst + i + 1;
156 *res = '\0';
157 for (; i >= 0; i--) {
158 dst[i] = n % 10ULL + '0';
159 n /= 10ULL;
160 }
161 return res;
162}
163
164/*
165 * unsigned long ASCII representation
166 *
167 * return the last char '\0' or NULL if no enough
168 * space in dst
169 */
170char *ultoa_o(unsigned long n, char *dst, size_t size)
171{
172 int i = 0;
173 char *res;
174
175 switch (n) {
176 case 0U ... 9UL:
177 i = 0;
178 break;
179
180 case 10U ... 99UL:
181 i = 1;
182 break;
183
184 case 100U ... 999UL:
185 i = 2;
186 break;
187
188 case 1000U ... 9999UL:
189 i = 3;
190 break;
191
192 case 10000U ... 99999UL:
193 i = 4;
194 break;
195
196 case 100000U ... 999999UL:
197 i = 5;
198 break;
199
200 case 1000000U ... 9999999UL:
201 i = 6;
202 break;
203
204 case 10000000U ... 99999999UL:
205 i = 7;
206 break;
207
208 case 100000000U ... 999999999UL:
209 i = 8;
210 break;
211#if __WORDSIZE == 32
212
213 case 1000000000ULL ... ULONG_MAX:
214 i = 9;
215 break;
216
217#elif __WORDSIZE == 64
218
219 case 1000000000ULL ... 9999999999UL:
220 i = 9;
221 break;
222
223 case 10000000000ULL ... 99999999999UL:
224 i = 10;
225 break;
226
227 case 100000000000ULL ... 999999999999UL:
228 i = 11;
229 break;
230
231 case 1000000000000ULL ... 9999999999999UL:
232 i = 12;
233 break;
234
235 case 10000000000000ULL ... 99999999999999UL:
236 i = 13;
237 break;
238
239 case 100000000000000ULL ... 999999999999999UL:
240 i = 14;
241 break;
242
243 case 1000000000000000ULL ... 9999999999999999UL:
244 i = 15;
245 break;
246
247 case 10000000000000000ULL ... 99999999999999999UL:
248 i = 16;
249 break;
250
251 case 100000000000000000ULL ... 999999999999999999UL:
252 i = 17;
253 break;
254
255 case 1000000000000000000ULL ... 9999999999999999999UL:
256 i = 18;
257 break;
258
259 case 10000000000000000000ULL ... ULONG_MAX:
260 i = 19;
261 break;
262
263#endif
264 }
265 if (i + 2 > size) // (i + 1) + '\0'
266 return NULL; // too long
267 res = dst + i + 1;
268 *res = '\0';
269 for (; i >= 0; i--) {
270 dst[i] = n % 10U + '0';
271 n /= 10U;
272 }
273 return res;
274}
275
276/*
277 * signed long ASCII representation
278 *
279 * return the last char '\0' or NULL if no enough
280 * space in dst
281 */
282char *ltoa_o(long int n, char *dst, size_t size)
283{
284 char *pos = dst;
285
286 if (n < 0) {
287 if (size < 3)
288 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
289 *pos = '-';
290 pos++;
291 dst = ultoa_o(-n, pos, size - 1);
292 } else {
293 dst = ultoa_o(n, dst, size);
294 }
295 return dst;
296}
297
298/*
299 * signed long long ASCII representation
300 *
301 * return the last char '\0' or NULL if no enough
302 * space in dst
303 */
304char *lltoa(long long n, char *dst, size_t size)
305{
306 char *pos = dst;
307
308 if (n < 0) {
309 if (size < 3)
310 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
311 *pos = '-';
312 pos++;
313 dst = ulltoa(-n, pos, size - 1);
314 } else {
315 dst = ulltoa(n, dst, size);
316 }
317 return dst;
318}
319
320/*
321 * write a ascii representation of a unsigned into dst,
322 * return a pointer to the last character
323 * Pad the ascii representation with '0', using size.
324 */
325char *utoa_pad(unsigned int n, char *dst, size_t size)
326{
327 int i = 0;
328 char *ret;
329
330 switch(n) {
331 case 0U ... 9U:
332 i = 0;
333 break;
334
335 case 10U ... 99U:
336 i = 1;
337 break;
338
339 case 100U ... 999U:
340 i = 2;
341 break;
342
343 case 1000U ... 9999U:
344 i = 3;
345 break;
346
347 case 10000U ... 99999U:
348 i = 4;
349 break;
350
351 case 100000U ... 999999U:
352 i = 5;
353 break;
354
355 case 1000000U ... 9999999U:
356 i = 6;
357 break;
358
359 case 10000000U ... 99999999U:
360 i = 7;
361 break;
362
363 case 100000000U ... 999999999U:
364 i = 8;
365 break;
366
367 case 1000000000U ... 4294967295U:
368 i = 9;
369 break;
370 }
371 if (i + 2 > size) // (i + 1) + '\0'
372 return NULL; // too long
373 if (i < size)
374 i = size - 2; // padding - '\0'
375
376 ret = dst + i + 1;
377 *ret = '\0';
378 for (; i >= 0; i--) {
379 dst[i] = n % 10U + '0';
380 n /= 10U;
381 }
382 return ret;
383}
384
385/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200386 * copies at most <size-1> chars from <src> to <dst>. Last char is always
387 * set to 0, unless <size> is 0. The number of chars copied is returned
388 * (excluding the terminating zero).
389 * This code has been optimized for size and speed : on x86, it's 45 bytes
390 * long, uses only registers, and consumes only 4 cycles per char.
391 */
392int strlcpy2(char *dst, const char *src, int size)
393{
394 char *orig = dst;
395 if (size) {
396 while (--size && (*dst = *src)) {
397 src++; dst++;
398 }
399 *dst = 0;
400 }
401 return dst - orig;
402}
403
404/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200405 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200406 * the ascii representation for number 'n' in decimal.
407 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100408char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200409{
410 char *pos;
411
Willy Tarreau72d759c2007-10-25 12:14:10 +0200412 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200413 *pos-- = '\0';
414
415 do {
416 *pos-- = '0' + n % 10;
417 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200418 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200419 return pos + 1;
420}
421
Willy Tarreau91092e52007-10-25 16:58:42 +0200422/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200423 * This function simply returns a locally allocated string containing
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200424 * the ascii representation for number 'n' in decimal.
425 */
426char *lltoa_r(long long int in, char *buffer, int size)
427{
428 char *pos;
429 int neg = 0;
430 unsigned long long int n;
431
432 pos = buffer + size - 1;
433 *pos-- = '\0';
434
435 if (in < 0) {
436 neg = 1;
437 n = -in;
438 }
439 else
440 n = in;
441
442 do {
443 *pos-- = '0' + n % 10;
444 n /= 10;
445 } while (n && pos >= buffer);
446 if (neg && pos > buffer)
447 *pos-- = '-';
448 return pos + 1;
449}
450
451/*
452 * This function simply returns a locally allocated string containing
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200453 * the ascii representation for signed number 'n' in decimal.
454 */
455char *sltoa_r(long n, char *buffer, int size)
456{
457 char *pos;
458
459 if (n >= 0)
460 return ultoa_r(n, buffer, size);
461
462 pos = ultoa_r(-n, buffer + 1, size - 1) - 1;
463 *pos = '-';
464 return pos;
465}
466
467/*
468 * This function simply returns a locally allocated string containing
Willy Tarreaue7239b52009-03-29 13:41:58 +0200469 * the ascii representation for number 'n' in decimal, formatted for
470 * HTML output with tags to create visual grouping by 3 digits. The
471 * output needs to support at least 171 characters.
472 */
473const char *ulltoh_r(unsigned long long n, char *buffer, int size)
474{
475 char *start;
476 int digit = 0;
477
478 start = buffer + size;
479 *--start = '\0';
480
481 do {
482 if (digit == 3 && start >= buffer + 7)
483 memcpy(start -= 7, "</span>", 7);
484
485 if (start >= buffer + 1) {
486 *--start = '0' + n % 10;
487 n /= 10;
488 }
489
490 if (digit == 3 && start >= buffer + 18)
491 memcpy(start -= 18, "<span class=\"rls\">", 18);
492
493 if (digit++ == 3)
494 digit = 1;
495 } while (n && start > buffer);
496 return start;
497}
498
499/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200500 * This function simply returns a locally allocated string containing the ascii
501 * representation for number 'n' in decimal, unless n is 0 in which case it
502 * returns the alternate string (or an empty string if the alternate string is
503 * NULL). It use is intended for limits reported in reports, where it's
504 * desirable not to display anything if there is no limit. Warning! it shares
505 * the same vector as ultoa_r().
506 */
507const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
508{
509 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
510}
511
Willy Tarreau588297f2014-06-16 15:16:40 +0200512/* returns a locally allocated string containing the quoted encoding of the
513 * input string. The output may be truncated to QSTR_SIZE chars, but it is
514 * guaranteed that the string will always be properly terminated. Quotes are
515 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
516 * always be at least 4 chars.
517 */
518const char *qstr(const char *str)
519{
520 char *ret = quoted_str[quoted_idx];
521 char *p, *end;
522
523 if (++quoted_idx >= NB_QSTR)
524 quoted_idx = 0;
525
526 p = ret;
527 end = ret + QSTR_SIZE;
528
529 *p++ = '"';
530
531 /* always keep 3 chars to support passing "" and the ending " */
532 while (*str && p < end - 3) {
533 if (*str == '"') {
534 *p++ = '"';
535 *p++ = '"';
536 }
537 else
538 *p++ = *str;
539 str++;
540 }
541 *p++ = '"';
542 return ret;
543}
544
Robert Tsai81ae1952007-12-05 10:47:29 +0100545/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200546 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
547 *
548 * It looks like this one would be a good candidate for inlining, but this is
549 * not interesting because it around 35 bytes long and often called multiple
550 * times within the same function.
551 */
552int ishex(char s)
553{
554 s -= '0';
555 if ((unsigned char)s <= 9)
556 return 1;
557 s -= 'A' - '0';
558 if ((unsigned char)s <= 5)
559 return 1;
560 s -= 'a' - 'A';
561 if ((unsigned char)s <= 5)
562 return 1;
563 return 0;
564}
565
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100566/* rounds <i> down to the closest value having max 2 digits */
567unsigned int round_2dig(unsigned int i)
568{
569 unsigned int mul = 1;
570
571 while (i >= 100) {
572 i /= 10;
573 mul *= 10;
574 }
575 return i * mul;
576}
577
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100578/*
579 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
580 * invalid character is found, a pointer to it is returned. If everything is
581 * fine, NULL is returned.
582 */
583const char *invalid_char(const char *name)
584{
585 if (!*name)
586 return name;
587
588 while (*name) {
Willy Tarreau88e05812010-03-03 00:16:00 +0100589 if (!isalnum((int)(unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100590 *name != '_' && *name != '-')
591 return name;
592 name++;
593 }
594 return NULL;
595}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200596
597/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200598 * Checks <name> for invalid characters. Valid chars are [_.-] and those
599 * accepted by <f> function.
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200600 * If an invalid character is found, a pointer to it is returned.
601 * If everything is fine, NULL is returned.
602 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200603static inline const char *__invalid_char(const char *name, int (*f)(int)) {
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200604
605 if (!*name)
606 return name;
607
608 while (*name) {
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200609 if (!f((int)(unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200610 *name != '_' && *name != '-')
611 return name;
612
613 name++;
614 }
615
616 return NULL;
617}
618
619/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200620 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
621 * If an invalid character is found, a pointer to it is returned.
622 * If everything is fine, NULL is returned.
623 */
624const char *invalid_domainchar(const char *name) {
625 return __invalid_char(name, isalnum);
626}
627
628/*
629 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
630 * If an invalid character is found, a pointer to it is returned.
631 * If everything is fine, NULL is returned.
632 */
633const char *invalid_prefix_char(const char *name) {
Thierry Fournierf7b7c3e2018-03-26 11:54:39 +0200634 return __invalid_char(name, isalnum);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200635}
636
637/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100638 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100639 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
640 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
641 * the function tries to guess the address family from the syntax. If the
642 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100643 * string is assumed to contain only an address, no port. The address can be a
644 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
645 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
646 * The return address will only have the address family and the address set,
647 * all other fields remain zero. The string is not supposed to be modified.
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100648 * The IPv6 '::' address is IN6ADDR_ANY. If <resolve> is non-zero, the hostname
649 * is resolved, otherwise only IP addresses are resolved, and anything else
Willy Tarreauecde7df2016-11-02 22:37:03 +0100650 * returns NULL. If the address contains a port, this one is preserved.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200651 */
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100652struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200653{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100654 struct hostent *he;
mildisff5d5102015-10-26 18:50:08 +0100655 /* max IPv6 length, including brackets and terminating NULL */
656 char tmpip[48];
Willy Tarreauecde7df2016-11-02 22:37:03 +0100657 int port = get_host_port(sa);
mildisff5d5102015-10-26 18:50:08 +0100658
659 /* check IPv6 with square brackets */
660 if (str[0] == '[') {
661 size_t iplength = strlen(str);
662
663 if (iplength < 4) {
664 /* minimal size is 4 when using brackets "[::]" */
665 goto fail;
666 }
667 else if (iplength >= sizeof(tmpip)) {
668 /* IPv6 literal can not be larger than tmpip */
669 goto fail;
670 }
671 else {
672 if (str[iplength - 1] != ']') {
673 /* if address started with bracket, it should end with bracket */
674 goto fail;
675 }
676 else {
677 memcpy(tmpip, str + 1, iplength - 2);
678 tmpip[iplength - 2] = '\0';
679 str = tmpip;
680 }
681 }
682 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100683
Willy Tarreaufab5a432011-03-04 15:31:53 +0100684 /* Any IPv6 address */
685 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100686 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
687 sa->ss_family = AF_INET6;
688 else if (sa->ss_family != AF_INET6)
689 goto fail;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100690 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100691 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100692 }
693
Willy Tarreau24709282013-03-10 21:32:12 +0100694 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100695 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100696 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
697 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100698 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100699 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100700 }
701
702 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100703 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
704 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100705 sa->ss_family = AF_INET6;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100706 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100707 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100708 }
709
710 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100711 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
712 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100713 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100714 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100715 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100716 }
717
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100718 if (!resolve)
719 return NULL;
720
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200721 if (!dns_hostname_validation(str, NULL))
722 return NULL;
723
David du Colombierd5f43282011-03-17 10:40:16 +0100724#ifdef USE_GETADDRINFO
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200725 if (global.tune.options & GTUNE_USE_GAI) {
David du Colombierd5f43282011-03-17 10:40:16 +0100726 struct addrinfo hints, *result;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100727 int success = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100728
729 memset(&result, 0, sizeof(result));
730 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100731 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100732 hints.ai_socktype = SOCK_DGRAM;
Dmitry Sivachenkoeab7f392015-10-02 01:01:58 +0200733 hints.ai_flags = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100734 hints.ai_protocol = 0;
735
736 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100737 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
738 sa->ss_family = result->ai_family;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100739 else if (sa->ss_family != result->ai_family) {
740 freeaddrinfo(result);
Willy Tarreau24709282013-03-10 21:32:12 +0100741 goto fail;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100742 }
Willy Tarreau24709282013-03-10 21:32:12 +0100743
David du Colombierd5f43282011-03-17 10:40:16 +0100744 switch (result->ai_family) {
745 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100746 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100747 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100748 success = 1;
749 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100750 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100751 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100752 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100753 success = 1;
754 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100755 }
756 }
757
Sean Carey58ea0392013-02-15 23:39:18 +0100758 if (result)
759 freeaddrinfo(result);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100760
761 if (success)
762 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100763 }
David du Colombierd5f43282011-03-17 10:40:16 +0100764#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200765 /* try to resolve an IPv4/IPv6 hostname */
766 he = gethostbyname(str);
767 if (he) {
768 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
769 sa->ss_family = he->h_addrtype;
770 else if (sa->ss_family != he->h_addrtype)
771 goto fail;
772
773 switch (sa->ss_family) {
774 case AF_INET:
775 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100776 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200777 return sa;
778 case AF_INET6:
779 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100780 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200781 return sa;
782 }
783 }
784
David du Colombierd5f43282011-03-17 10:40:16 +0100785 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100786 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100787 return NULL;
788}
789
790/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100791 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
792 * range or offset consisting in two integers that the caller will have to
793 * check to find the relevant input format. The following format are supported :
794 *
795 * String format | address | port | low | high
796 * addr | <addr> | 0 | 0 | 0
797 * addr: | <addr> | 0 | 0 | 0
798 * addr:port | <addr> | <port> | <port> | <port>
799 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
800 * addr:+port | <addr> | <port> | 0 | <port>
801 * addr:-port | <addr> |-<port> | <port> | 0
802 *
803 * The detection of a port range or increment by the caller is made by
804 * comparing <low> and <high>. If both are equal, then port 0 means no port
805 * was specified. The caller may pass NULL for <low> and <high> if it is not
806 * interested in retrieving port ranges.
807 *
808 * Note that <addr> above may also be :
809 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
810 * - "*" => family will be AF_INET and address will be INADDR_ANY
811 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
812 * - a host name => family and address will depend on host name resolving.
813 *
Willy Tarreau24709282013-03-10 21:32:12 +0100814 * A prefix may be passed in before the address above to force the family :
815 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
816 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
817 * - "unix@" => force address to be a path to a UNIX socket even if the
818 * path does not start with a '/'
Willy Tarreauccfccef2014-05-10 01:49:15 +0200819 * - 'abns@' -> force address to belong to the abstract namespace (Linux
820 * only). These sockets are just like Unix sockets but without
821 * the need for an underlying file system. The address is a
822 * string. Technically it's like a Unix socket with a zero in
823 * the first byte of the address.
Willy Tarreau40aa0702013-03-10 23:51:38 +0100824 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100825 *
mildisff5d5102015-10-26 18:50:08 +0100826 * IPv6 addresses can be declared with or without square brackets. When using
827 * square brackets for IPv6 addresses, the port separator (colon) is optional.
828 * If not using square brackets, and in order to avoid any ambiguity with
829 * IPv6 addresses, the last colon ':' is mandatory even when no port is specified.
830 * NULL is returned if the address cannot be parsed. The <low> and <high> ports
831 * are always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100832 *
833 * If <pfx> is non-null, it is used as a string prefix before any path-based
834 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100835 *
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200836 * if <fqdn> is non-null, it will be filled with :
837 * - a pointer to the FQDN of the server name to resolve if there's one, and
838 * that the caller will have to free(),
839 * - NULL if there was an explicit address that doesn't require resolution.
840 *
Willy Tarreauceccdd72016-11-02 22:27:10 +0100841 * Hostnames are only resolved if <resolve> is non-null. Note that if <resolve>
842 * is null, <fqdn> is still honnored so it is possible for the caller to know
843 * whether a resolution failed by setting <resolve> to null and checking if
844 * <fqdn> was filled, indicating the need for a resolution.
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200845 *
Willy Tarreau40aa0702013-03-10 23:51:38 +0100846 * When a file descriptor is passed, its value is put into the s_addr part of
847 * the address when cast to sockaddr_in and the address family is AF_UNSPEC.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100848 */
Willy Tarreau48ef4c92017-01-06 18:32:38 +0100849struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int *high, char **err, const char *pfx, char **fqdn, int resolve)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100850{
Christopher Faulet1bc04c72017-10-29 20:14:08 +0100851 static THREAD_LOCAL struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100852 struct sockaddr_storage *ret = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100853 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100854 char *port1, *port2;
855 int portl, porth, porta;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200856 int abstract = 0;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100857
858 portl = porth = porta = 0;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200859 if (fqdn)
860 *fqdn = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200861
Willy Tarreaudad36a32013-03-11 01:20:04 +0100862 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100863 if (str2 == NULL) {
864 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100865 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100866 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200867
Willy Tarreau9f69f462015-09-08 16:01:25 +0200868 if (!*str2) {
869 memprintf(err, "'%s' resolves to an empty address (environment variable missing?)\n", str);
870 goto out;
871 }
872
Willy Tarreau24709282013-03-10 21:32:12 +0100873 memset(&ss, 0, sizeof(ss));
874
875 if (strncmp(str2, "unix@", 5) == 0) {
876 str2 += 5;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200877 abstract = 0;
Willy Tarreau24709282013-03-10 21:32:12 +0100878 ss.ss_family = AF_UNIX;
879 }
Willy Tarreauccfccef2014-05-10 01:49:15 +0200880 else if (strncmp(str2, "abns@", 5) == 0) {
881 str2 += 5;
882 abstract = 1;
883 ss.ss_family = AF_UNIX;
884 }
Willy Tarreau24709282013-03-10 21:32:12 +0100885 else if (strncmp(str2, "ipv4@", 5) == 0) {
886 str2 += 5;
887 ss.ss_family = AF_INET;
888 }
889 else if (strncmp(str2, "ipv6@", 5) == 0) {
890 str2 += 5;
891 ss.ss_family = AF_INET6;
892 }
893 else if (*str2 == '/') {
894 ss.ss_family = AF_UNIX;
895 }
896 else
897 ss.ss_family = AF_UNSPEC;
898
William Lallemand2fe7dd02018-09-11 16:51:29 +0200899 if (ss.ss_family == AF_UNSPEC && strncmp(str2, "sockpair@", 9) == 0) {
900 char *endptr;
901
902 str2 += 9;
903
904 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = strtol(str2, &endptr, 10);
Willy Tarreau0205a4e2018-12-15 15:40:12 +0100905 ((struct sockaddr_in *)&ss)->sin_port = 0;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200906
907 if (!*str2 || *endptr) {
908 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
909 goto out;
910 }
911
912 ss.ss_family = AF_CUST_SOCKPAIR;
913
914 }
915 else if (ss.ss_family == AF_UNSPEC && strncmp(str2, "fd@", 3) == 0) {
Willy Tarreau40aa0702013-03-10 23:51:38 +0100916 char *endptr;
917
918 str2 += 3;
919 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = strtol(str2, &endptr, 10);
Willy Tarreau0205a4e2018-12-15 15:40:12 +0100920 ((struct sockaddr_in *)&ss)->sin_port = 0;
Willy Tarreau40aa0702013-03-10 23:51:38 +0100921
922 if (!*str2 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +0100923 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +0100924 goto out;
925 }
926
927 /* we return AF_UNSPEC if we use a file descriptor number */
928 ss.ss_family = AF_UNSPEC;
929 }
930 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau15586382013-03-04 19:48:14 +0100931 int prefix_path_len;
932 int max_path_len;
Willy Tarreau94ef3f32014-04-14 14:49:00 +0200933 int adr_len;
Willy Tarreau15586382013-03-04 19:48:14 +0100934
935 /* complete unix socket path name during startup or soft-restart is
936 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
937 */
Willy Tarreauccfccef2014-05-10 01:49:15 +0200938 prefix_path_len = (pfx && !abstract) ? strlen(pfx) : 0;
Willy Tarreau15586382013-03-04 19:48:14 +0100939 max_path_len = (sizeof(((struct sockaddr_un *)&ss)->sun_path) - 1) -
940 (prefix_path_len ? prefix_path_len + 1 + 5 + 1 + 3 : 0);
941
Willy Tarreau94ef3f32014-04-14 14:49:00 +0200942 adr_len = strlen(str2);
943 if (adr_len > max_path_len) {
Willy Tarreau15586382013-03-04 19:48:14 +0100944 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
945 goto out;
946 }
947
Willy Tarreauccfccef2014-05-10 01:49:15 +0200948 /* when abstract==1, we skip the first zero and copy all bytes except the trailing zero */
949 memset(((struct sockaddr_un *)&ss)->sun_path, 0, sizeof(((struct sockaddr_un *)&ss)->sun_path));
Willy Tarreau94ef3f32014-04-14 14:49:00 +0200950 if (prefix_path_len)
Willy Tarreau15586382013-03-04 19:48:14 +0100951 memcpy(((struct sockaddr_un *)&ss)->sun_path, pfx, prefix_path_len);
Willy Tarreauccfccef2014-05-10 01:49:15 +0200952 memcpy(((struct sockaddr_un *)&ss)->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
Willy Tarreau15586382013-03-04 19:48:14 +0100953 }
Willy Tarreau24709282013-03-10 21:32:12 +0100954 else { /* IPv4 and IPv6 */
mildisff5d5102015-10-26 18:50:08 +0100955 char *end = str2 + strlen(str2);
956 char *chr;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200957
mildisff5d5102015-10-26 18:50:08 +0100958 /* search for : or ] whatever comes first */
959 for (chr = end-1; chr > str2; chr--) {
960 if (*chr == ']' || *chr == ':')
961 break;
962 }
963
964 if (*chr == ':') {
965 /* Found a colon before a closing-bracket, must be a port separator.
966 * This guarantee backward compatibility.
967 */
968 *chr++ = '\0';
969 port1 = chr;
970 }
971 else {
972 /* Either no colon and no closing-bracket
973 * or directly ending with a closing-bracket.
974 * However, no port.
975 */
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100976 port1 = "";
mildisff5d5102015-10-26 18:50:08 +0100977 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200978
Willy Tarreaua39d1992013-04-01 20:37:42 +0200979 if (isdigit((int)(unsigned char)*port1)) { /* single port or range */
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100980 port2 = strchr(port1, '-');
981 if (port2)
982 *port2++ = '\0';
983 else
984 port2 = port1;
985 portl = atoi(port1);
986 porth = atoi(port2);
987 porta = portl;
988 }
989 else if (*port1 == '-') { /* negative offset */
990 portl = atoi(port1 + 1);
991 porta = -portl;
992 }
993 else if (*port1 == '+') { /* positive offset */
994 porth = atoi(port1 + 1);
995 porta = porth;
996 }
997 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +0100998 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100999 goto out;
1000 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001001
1002 /* first try to parse the IP without resolving. If it fails, it
1003 * tells us we need to keep a copy of the FQDN to resolve later
1004 * and to enable DNS. In this case we can proceed if <fqdn> is
1005 * set or if resolve is set, otherwise it's an error.
1006 */
1007 if (str2ip2(str2, &ss, 0) == NULL) {
Willy Tarreau7b760c92017-01-06 19:23:20 +01001008 if ((!resolve && !fqdn) ||
Willy Tarreauceccdd72016-11-02 22:27:10 +01001009 (resolve && str2ip2(str2, &ss, 1) == NULL)) {
1010 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
1011 goto out;
1012 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001013
Willy Tarreauceccdd72016-11-02 22:27:10 +01001014 if (fqdn) {
1015 if (str2 != back)
1016 memmove(back, str2, strlen(str2) + 1);
1017 *fqdn = back;
1018 back = NULL;
1019 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001020 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001021 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +01001022 }
Willy Tarreaufab5a432011-03-04 15:31:53 +01001023
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001024 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +01001025 out:
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001026 if (port)
1027 *port = porta;
Willy Tarreaud4448bc2013-02-20 15:55:15 +01001028 if (low)
1029 *low = portl;
1030 if (high)
1031 *high = porth;
Willy Tarreau24709282013-03-10 21:32:12 +01001032 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +01001033 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001034}
1035
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001036/* converts <str> to a struct in_addr containing a network mask. It can be
1037 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +03001038 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001039 */
1040int str2mask(const char *str, struct in_addr *mask)
1041{
1042 if (strchr(str, '.') != NULL) { /* dotted notation */
1043 if (!inet_pton(AF_INET, str, mask))
1044 return 0;
1045 }
1046 else { /* mask length */
1047 char *err;
1048 unsigned long len = strtol(str, &err, 10);
1049
1050 if (!*str || (err && *err) || (unsigned)len > 32)
1051 return 0;
Tim Duesterhus8575f722018-01-25 16:24:48 +01001052
1053 len2mask4(len, mask);
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001054 }
1055 return 1;
1056}
1057
Tim Duesterhus47185172018-01-25 16:24:49 +01001058/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +01001059 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +01001060 * if the conversion succeeds otherwise zero.
1061 */
1062int str2mask6(const char *str, struct in6_addr *mask)
1063{
1064 if (strchr(str, ':') != NULL) { /* quadruplet notation */
1065 if (!inet_pton(AF_INET6, str, mask))
1066 return 0;
1067 }
1068 else { /* mask length */
1069 char *err;
1070 unsigned long len = strtol(str, &err, 10);
1071
1072 if (!*str || (err && *err) || (unsigned)len > 128)
1073 return 0;
1074
1075 len2mask6(len, mask);
1076 }
1077 return 1;
1078}
1079
Thierry FOURNIERb0504632013-12-14 15:39:02 +01001080/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
1081 * succeeds otherwise zero.
1082 */
1083int cidr2dotted(int cidr, struct in_addr *mask) {
1084
1085 if (cidr < 0 || cidr > 32)
1086 return 0;
1087
1088 mask->s_addr = cidr ? htonl(~0UL << (32 - cidr)) : 0;
1089 return 1;
1090}
1091
Thierry Fournier70473a52016-02-17 17:12:14 +01001092/* Convert mask from bit length form to in_addr form.
1093 * This function never fails.
1094 */
1095void len2mask4(int len, struct in_addr *addr)
1096{
1097 if (len >= 32) {
1098 addr->s_addr = 0xffffffff;
1099 return;
1100 }
1101 if (len <= 0) {
1102 addr->s_addr = 0x00000000;
1103 return;
1104 }
1105 addr->s_addr = 0xffffffff << (32 - len);
1106 addr->s_addr = htonl(addr->s_addr);
1107}
1108
1109/* Convert mask from bit length form to in6_addr form.
1110 * This function never fails.
1111 */
1112void len2mask6(int len, struct in6_addr *addr)
1113{
1114 len2mask4(len, (struct in_addr *)&addr->s6_addr[0]); /* msb */
1115 len -= 32;
1116 len2mask4(len, (struct in_addr *)&addr->s6_addr[4]);
1117 len -= 32;
1118 len2mask4(len, (struct in_addr *)&addr->s6_addr[8]);
1119 len -= 32;
1120 len2mask4(len, (struct in_addr *)&addr->s6_addr[12]); /* lsb */
1121}
1122
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001123/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +02001124 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001125 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
1126 * is optionnal and either in the dotted or CIDR notation.
1127 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
1128 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001129int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001130{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001131 __label__ out_free, out_err;
1132 char *c, *s;
1133 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001134
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001135 s = strdup(str);
1136 if (!s)
1137 return 0;
1138
Willy Tarreaubaaee002006-06-26 02:48:02 +02001139 memset(mask, 0, sizeof(*mask));
1140 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001141
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001142 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001143 *c++ = '\0';
1144 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001145 if (!str2mask(c, mask))
1146 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001147 }
1148 else {
Willy Tarreauebd61602006-12-30 11:54:15 +01001149 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001150 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001151 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001152 struct hostent *he;
1153
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001154 if (!resolve)
1155 goto out_err;
1156
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001157 if ((he = gethostbyname(s)) == NULL) {
1158 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001159 }
1160 else
1161 *addr = *(struct in_addr *) *(he->h_addr_list);
1162 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001163
1164 ret_val = 1;
1165 out_free:
1166 free(s);
1167 return ret_val;
1168 out_err:
1169 ret_val = 0;
1170 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001171}
1172
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001173
1174/*
Willy Tarreau6d20e282012-04-27 22:49:47 +02001175 * converts <str> to two struct in6_addr* which must be pre-allocated.
1176 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
1177 * is an optionnal number of bits (128 being the default).
1178 * Returns 1 if OK, 0 if error.
1179 */
1180int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
1181{
1182 char *c, *s;
1183 int ret_val = 0;
1184 char *err;
1185 unsigned long len = 128;
1186
1187 s = strdup(str);
1188 if (!s)
1189 return 0;
1190
1191 memset(mask, 0, sizeof(*mask));
1192 memset(addr, 0, sizeof(*addr));
1193
1194 if ((c = strrchr(s, '/')) != NULL) {
1195 *c++ = '\0'; /* c points to the mask */
1196 if (!*c)
1197 goto out_free;
1198
1199 len = strtoul(c, &err, 10);
1200 if ((err && *err) || (unsigned)len > 128)
1201 goto out_free;
1202 }
1203 *mask = len; /* OK we have a valid mask in <len> */
1204
1205 if (!inet_pton(AF_INET6, s, addr))
1206 goto out_free;
1207
1208 ret_val = 1;
1209 out_free:
1210 free(s);
1211 return ret_val;
1212}
1213
1214
1215/*
David du Colombier6f5ccb12011-03-10 22:26:24 +01001216 * Parse IPv4 address found in url.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001217 */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001218int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001219{
1220 int saw_digit, octets, ch;
1221 u_char tmp[4], *tp;
1222 const char *cp = addr;
1223
1224 saw_digit = 0;
1225 octets = 0;
1226 *(tp = tmp) = 0;
1227
1228 while (*addr) {
1229 unsigned char digit = (ch = *addr++) - '0';
1230 if (digit > 9 && ch != '.')
1231 break;
1232 if (digit <= 9) {
1233 u_int new = *tp * 10 + digit;
1234 if (new > 255)
1235 return 0;
1236 *tp = new;
1237 if (!saw_digit) {
1238 if (++octets > 4)
1239 return 0;
1240 saw_digit = 1;
1241 }
1242 } else if (ch == '.' && saw_digit) {
1243 if (octets == 4)
1244 return 0;
1245 *++tp = 0;
1246 saw_digit = 0;
1247 } else
1248 return 0;
1249 }
1250
1251 if (octets < 4)
1252 return 0;
1253
1254 memcpy(&dst->s_addr, tmp, 4);
1255 return addr-cp-1;
1256}
1257
1258/*
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001259 * Resolve destination server from URL. Convert <str> to a sockaddr_storage.
1260 * <out> contain the code of the dectected scheme, the start and length of
1261 * the hostname. Actually only http and https are supported. <out> can be NULL.
1262 * This function returns the consumed length. It is useful if you parse complete
1263 * url like http://host:port/path, because the consumed length corresponds to
1264 * the first character of the path. If the conversion fails, it returns -1.
1265 *
1266 * This function tries to resolve the DNS name if haproxy is in starting mode.
1267 * So, this function may be used during the configuration parsing.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001268 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001269int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001270{
1271 const char *curr = url, *cp = url;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001272 const char *end;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001273 int ret, url_code = 0;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001274 unsigned long long int http_code = 0;
1275 int default_port;
1276 struct hostent *he;
1277 char *p;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001278
1279 /* Firstly, try to find :// pattern */
1280 while (curr < url+ulen && url_code != 0x3a2f2f) {
1281 url_code = ((url_code & 0xffff) << 8);
1282 url_code += (unsigned char)*curr++;
1283 }
1284
1285 /* Secondly, if :// pattern is found, verify parsed stuff
1286 * before pattern is matching our http pattern.
1287 * If so parse ip address and port in uri.
1288 *
1289 * WARNING: Current code doesn't support dynamic async dns resolver.
1290 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001291 if (url_code != 0x3a2f2f)
1292 return -1;
1293
1294 /* Copy scheme, and utrn to lower case. */
1295 while (cp < curr - 3)
1296 http_code = (http_code << 8) + *cp++;
1297 http_code |= 0x2020202020202020ULL; /* Turn everything to lower case */
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001298
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001299 /* HTTP or HTTPS url matching */
1300 if (http_code == 0x2020202068747470ULL) {
1301 default_port = 80;
1302 if (out)
1303 out->scheme = SCH_HTTP;
1304 }
1305 else if (http_code == 0x2020206874747073ULL) {
1306 default_port = 443;
1307 if (out)
1308 out->scheme = SCH_HTTPS;
1309 }
1310 else
1311 return -1;
1312
1313 /* If the next char is '[', the host address is IPv6. */
1314 if (*curr == '[') {
1315 curr++;
1316
1317 /* Check trash size */
1318 if (trash.size < ulen)
1319 return -1;
1320
1321 /* Look for ']' and copy the address in a trash buffer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001322 p = trash.area;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001323 for (end = curr;
1324 end < url + ulen && *end != ']';
1325 end++, p++)
1326 *p = *end;
1327 if (*end != ']')
1328 return -1;
1329 *p = '\0';
1330
1331 /* Update out. */
1332 if (out) {
1333 out->host = curr;
1334 out->host_len = end - curr;
1335 }
1336
1337 /* Try IPv6 decoding. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001338 if (!inet_pton(AF_INET6, trash.area, &((struct sockaddr_in6 *)addr)->sin6_addr))
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001339 return -1;
1340 end++;
1341
1342 /* Decode port. */
1343 if (*end == ':') {
1344 end++;
1345 default_port = read_uint(&end, url + ulen);
1346 }
1347 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1348 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1349 return end - url;
1350 }
1351 else {
1352 /* We are looking for IP address. If you want to parse and
1353 * resolve hostname found in url, you can use str2sa_range(), but
1354 * be warned this can slow down global daemon performances
1355 * while handling lagging dns responses.
1356 */
1357 ret = url2ipv4(curr, &((struct sockaddr_in *)addr)->sin_addr);
1358 if (ret) {
1359 /* Update out. */
1360 if (out) {
1361 out->host = curr;
1362 out->host_len = ret;
1363 }
1364
1365 curr += ret;
1366
1367 /* Decode port. */
1368 if (*curr == ':') {
1369 curr++;
1370 default_port = read_uint(&curr, url + ulen);
1371 }
1372 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1373
1374 /* Set family. */
1375 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1376 return curr - url;
1377 }
1378 else if (global.mode & MODE_STARTING) {
1379 /* The IPv4 and IPv6 decoding fails, maybe the url contain name. Try to execute
1380 * synchronous DNS request only if HAProxy is in the start state.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001381 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001382
1383 /* look for : or / or end */
1384 for (end = curr;
1385 end < url + ulen && *end != '/' && *end != ':';
1386 end++);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001387 memcpy(trash.area, curr, end - curr);
1388 trash.area[end - curr] = '\0';
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001389
1390 /* try to resolve an IPv4/IPv6 hostname */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001391 he = gethostbyname(trash.area);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001392 if (!he)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001393 return -1;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001394
1395 /* Update out. */
1396 if (out) {
1397 out->host = curr;
1398 out->host_len = end - curr;
1399 }
1400
1401 /* Decode port. */
1402 if (*end == ':') {
1403 end++;
1404 default_port = read_uint(&end, url + ulen);
1405 }
1406
1407 /* Copy IP address, set port and family. */
1408 switch (he->h_addrtype) {
1409 case AF_INET:
1410 ((struct sockaddr_in *)addr)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
1411 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1412 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1413 return end - url;
1414
1415 case AF_INET6:
1416 ((struct sockaddr_in6 *)addr)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
1417 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1418 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1419 return end - url;
1420 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001421 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001422 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001423 return -1;
1424}
1425
Willy Tarreau631f01c2011-09-05 00:36:48 +02001426/* Tries to convert a sockaddr_storage address to text form. Upon success, the
1427 * address family is returned so that it's easy for the caller to adapt to the
1428 * output format. Zero is returned if the address family is not supported. -1
1429 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1430 * supported.
1431 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001432int addr_to_str(const struct sockaddr_storage *addr, char *str, int size)
Willy Tarreau631f01c2011-09-05 00:36:48 +02001433{
1434
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001435 const void *ptr;
Willy Tarreau631f01c2011-09-05 00:36:48 +02001436
1437 if (size < 5)
1438 return 0;
1439 *str = '\0';
1440
1441 switch (addr->ss_family) {
1442 case AF_INET:
1443 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1444 break;
1445 case AF_INET6:
1446 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1447 break;
1448 case AF_UNIX:
1449 memcpy(str, "unix", 5);
1450 return addr->ss_family;
1451 default:
1452 return 0;
1453 }
1454
1455 if (inet_ntop(addr->ss_family, ptr, str, size))
1456 return addr->ss_family;
1457
1458 /* failed */
1459 return -1;
1460}
1461
Simon Horman75ab8bd2014-06-16 09:39:41 +09001462/* Tries to convert a sockaddr_storage port to text form. Upon success, the
1463 * address family is returned so that it's easy for the caller to adapt to the
1464 * output format. Zero is returned if the address family is not supported. -1
1465 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1466 * supported.
1467 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001468int port_to_str(const struct sockaddr_storage *addr, char *str, int size)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001469{
1470
1471 uint16_t port;
1472
1473
Willy Tarreaud7dad1b2017-01-06 16:46:22 +01001474 if (size < 6)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001475 return 0;
1476 *str = '\0';
1477
1478 switch (addr->ss_family) {
1479 case AF_INET:
1480 port = ((struct sockaddr_in *)addr)->sin_port;
1481 break;
1482 case AF_INET6:
1483 port = ((struct sockaddr_in6 *)addr)->sin6_port;
1484 break;
1485 case AF_UNIX:
1486 memcpy(str, "unix", 5);
1487 return addr->ss_family;
1488 default:
1489 return 0;
1490 }
1491
1492 snprintf(str, size, "%u", ntohs(port));
1493 return addr->ss_family;
1494}
1495
Willy Tarreau16e01562016-08-09 16:46:18 +02001496/* check if the given address is local to the system or not. It will return
1497 * -1 when it's not possible to know, 0 when the address is not local, 1 when
1498 * it is. We don't want to iterate over all interfaces for this (and it is not
1499 * portable). So instead we try to bind in UDP to this address on a free non
1500 * privileged port and to connect to the same address, port 0 (connect doesn't
1501 * care). If it succeeds, we own the address. Note that non-inet addresses are
1502 * considered local since they're most likely AF_UNIX.
1503 */
1504int addr_is_local(const struct netns_entry *ns,
1505 const struct sockaddr_storage *orig)
1506{
1507 struct sockaddr_storage addr;
1508 int result;
1509 int fd;
1510
1511 if (!is_inet_addr(orig))
1512 return 1;
1513
1514 memcpy(&addr, orig, sizeof(addr));
1515 set_host_port(&addr, 0);
1516
1517 fd = my_socketat(ns, addr.ss_family, SOCK_DGRAM, IPPROTO_UDP);
1518 if (fd < 0)
1519 return -1;
1520
1521 result = -1;
1522 if (bind(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == 0) {
1523 if (connect(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == -1)
1524 result = 0; // fail, non-local address
1525 else
1526 result = 1; // success, local address
1527 }
1528 else {
1529 if (errno == EADDRNOTAVAIL)
1530 result = 0; // definitely not local :-)
1531 }
1532 close(fd);
1533
1534 return result;
1535}
1536
Willy Tarreaubaaee002006-06-26 02:48:02 +02001537/* will try to encode the string <string> replacing all characters tagged in
1538 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1539 * prefixed by <escape>, and will store the result between <start> (included)
1540 * and <stop> (excluded), and will always terminate the string with a '\0'
1541 * before <stop>. The position of the '\0' is returned if the conversion
1542 * completes. If bytes are missing between <start> and <stop>, then the
1543 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1544 * cannot even be stored so we return <start> without writing the 0.
1545 * The input string must also be zero-terminated.
1546 */
1547const char hextab[16] = "0123456789ABCDEF";
1548char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001549 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +02001550 const char *string)
1551{
1552 if (start < stop) {
1553 stop--; /* reserve one byte for the final '\0' */
1554 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001555 if (!ha_bit_test((unsigned char)(*string), map))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001556 *start++ = *string;
1557 else {
1558 if (start + 3 >= stop)
1559 break;
1560 *start++ = escape;
1561 *start++ = hextab[(*string >> 4) & 15];
1562 *start++ = hextab[*string & 15];
1563 }
1564 string++;
1565 }
1566 *start = '\0';
1567 }
1568 return start;
1569}
1570
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001571/*
1572 * Same behavior as encode_string() above, except that it encodes chunk
1573 * <chunk> instead of a string.
1574 */
1575char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001576 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001577 const struct buffer *chunk)
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001578{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001579 char *str = chunk->area;
1580 char *end = chunk->area + chunk->data;
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001581
1582 if (start < stop) {
1583 stop--; /* reserve one byte for the final '\0' */
1584 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001585 if (!ha_bit_test((unsigned char)(*str), map))
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001586 *start++ = *str;
1587 else {
1588 if (start + 3 >= stop)
1589 break;
1590 *start++ = escape;
1591 *start++ = hextab[(*str >> 4) & 15];
1592 *start++ = hextab[*str & 15];
1593 }
1594 str++;
1595 }
1596 *start = '\0';
1597 }
1598 return start;
1599}
1600
Dragan Dosen0edd1092016-02-12 13:23:02 +01001601/*
1602 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001603 * character. The input <string> must be zero-terminated. The result will
1604 * be stored between <start> (included) and <stop> (excluded). This
1605 * function will always try to terminate the resulting string with a '\0'
1606 * before <stop>, and will return its position if the conversion
1607 * completes.
1608 */
1609char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001610 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001611 const char *string)
1612{
1613 if (start < stop) {
1614 stop--; /* reserve one byte for the final '\0' */
1615 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001616 if (!ha_bit_test((unsigned char)(*string), map))
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001617 *start++ = *string;
1618 else {
1619 if (start + 2 >= stop)
1620 break;
1621 *start++ = escape;
1622 *start++ = *string;
1623 }
1624 string++;
1625 }
1626 *start = '\0';
1627 }
1628 return start;
1629}
1630
1631/*
1632 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +01001633 * character. <chunk> contains the input to be escaped. The result will be
1634 * stored between <start> (included) and <stop> (excluded). The function
1635 * will always try to terminate the resulting string with a '\0' before
1636 * <stop>, and will return its position if the conversion completes.
1637 */
1638char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001639 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001640 const struct buffer *chunk)
Dragan Dosen0edd1092016-02-12 13:23:02 +01001641{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001642 char *str = chunk->area;
1643 char *end = chunk->area + chunk->data;
Dragan Dosen0edd1092016-02-12 13:23:02 +01001644
1645 if (start < stop) {
1646 stop--; /* reserve one byte for the final '\0' */
1647 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001648 if (!ha_bit_test((unsigned char)(*str), map))
Dragan Dosen0edd1092016-02-12 13:23:02 +01001649 *start++ = *str;
1650 else {
1651 if (start + 2 >= stop)
1652 break;
1653 *start++ = escape;
1654 *start++ = *str;
1655 }
1656 str++;
1657 }
1658 *start = '\0';
1659 }
1660 return start;
1661}
1662
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001663/* Check a string for using it in a CSV output format. If the string contains
1664 * one of the following four char <">, <,>, CR or LF, the string is
1665 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
1666 * <str> is the input string to be escaped. The function assumes that
1667 * the input string is null-terminated.
1668 *
1669 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +01001670 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001671 * format.
1672 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001673 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001674 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001675 * If <quote> is 1, the converter puts the quotes only if any reserved character
1676 * is present. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001677 *
Willy Tarreau83061a82018-07-13 11:56:34 +02001678 * <output> is a struct buffer used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001679 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001680 * The function returns the converted string on its output. If an error
1681 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001682 * for using the function directly as printf() argument.
1683 *
1684 * If the output buffer is too short to contain the input string, the result
1685 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +01001686 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001687 * This function appends the encoding to the existing output chunk, and it
1688 * guarantees that it starts immediately at the first available character of
1689 * the chunk. Please use csv_enc() instead if you want to replace the output
1690 * chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001691 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001692const char *csv_enc_append(const char *str, int quote, struct buffer *output)
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001693{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001694 char *end = output->area + output->size;
1695 char *out = output->area + output->data;
Willy Tarreau898529b2016-01-06 18:07:04 +01001696 char *ptr = out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001697
Willy Tarreaub631c292016-01-08 10:04:08 +01001698 if (quote == 1) {
1699 /* automatic quoting: first verify if we'll have to quote the string */
1700 if (!strpbrk(str, "\n\r,\""))
1701 quote = 0;
1702 }
1703
1704 if (quote)
1705 *ptr++ = '"';
1706
Willy Tarreau898529b2016-01-06 18:07:04 +01001707 while (*str && ptr < end - 2) { /* -2 for reserving space for <"> and \0. */
1708 *ptr = *str;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001709 if (*str == '"') {
Willy Tarreau898529b2016-01-06 18:07:04 +01001710 ptr++;
1711 if (ptr >= end - 2) {
1712 ptr--;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001713 break;
1714 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001715 *ptr = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001716 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001717 ptr++;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001718 str++;
1719 }
1720
Willy Tarreaub631c292016-01-08 10:04:08 +01001721 if (quote)
1722 *ptr++ = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001723
Willy Tarreau898529b2016-01-06 18:07:04 +01001724 *ptr = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001725 output->data = ptr - output->area;
Willy Tarreau898529b2016-01-06 18:07:04 +01001726 return out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001727}
1728
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001729/* Decode an URL-encoded string in-place. The resulting string might
1730 * be shorter. If some forbidden characters are found, the conversion is
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001731 * aborted, the string is truncated before the issue and a negative value is
1732 * returned, otherwise the operation returns the length of the decoded string.
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001733 */
1734int url_decode(char *string)
1735{
1736 char *in, *out;
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001737 int ret = -1;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001738
1739 in = string;
1740 out = string;
1741 while (*in) {
1742 switch (*in) {
1743 case '+' :
1744 *out++ = ' ';
1745 break;
1746 case '%' :
1747 if (!ishex(in[1]) || !ishex(in[2]))
1748 goto end;
1749 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
1750 in += 2;
1751 break;
1752 default:
1753 *out++ = *in;
1754 break;
1755 }
1756 in++;
1757 }
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001758 ret = out - string; /* success */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001759 end:
1760 *out = 0;
1761 return ret;
1762}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001763
Willy Tarreau6911fa42007-03-04 18:06:08 +01001764unsigned int str2ui(const char *s)
1765{
1766 return __str2ui(s);
1767}
1768
1769unsigned int str2uic(const char *s)
1770{
1771 return __str2uic(s);
1772}
1773
1774unsigned int strl2ui(const char *s, int len)
1775{
1776 return __strl2ui(s, len);
1777}
1778
1779unsigned int strl2uic(const char *s, int len)
1780{
1781 return __strl2uic(s, len);
1782}
1783
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02001784unsigned int read_uint(const char **s, const char *end)
1785{
1786 return __read_uint(s, end);
1787}
1788
Thierry FOURNIER763a5d82015-07-06 23:09:52 +02001789/* This function reads an unsigned integer from the string pointed to by <s> and
1790 * returns it. The <s> pointer is adjusted to point to the first unread char. The
1791 * function automatically stops at <end>. If the number overflows, the 2^64-1
1792 * value is returned.
1793 */
1794unsigned long long int read_uint64(const char **s, const char *end)
1795{
1796 const char *ptr = *s;
1797 unsigned long long int i = 0, tmp;
1798 unsigned int j;
1799
1800 while (ptr < end) {
1801
1802 /* read next char */
1803 j = *ptr - '0';
1804 if (j > 9)
1805 goto read_uint64_end;
1806
1807 /* add char to the number and check overflow. */
1808 tmp = i * 10;
1809 if (tmp / 10 != i) {
1810 i = ULLONG_MAX;
1811 goto read_uint64_eat;
1812 }
1813 if (ULLONG_MAX - tmp < j) {
1814 i = ULLONG_MAX;
1815 goto read_uint64_eat;
1816 }
1817 i = tmp + j;
1818 ptr++;
1819 }
1820read_uint64_eat:
1821 /* eat each numeric char */
1822 while (ptr < end) {
1823 if ((unsigned int)(*ptr - '0') > 9)
1824 break;
1825 ptr++;
1826 }
1827read_uint64_end:
1828 *s = ptr;
1829 return i;
1830}
1831
1832/* This function reads an integer from the string pointed to by <s> and returns
1833 * it. The <s> pointer is adjusted to point to the first unread char. The function
1834 * automatically stops at <end>. Il the number is bigger than 2^63-2, the 2^63-1
1835 * value is returned. If the number is lowest than -2^63-1, the -2^63 value is
1836 * returned.
1837 */
1838long long int read_int64(const char **s, const char *end)
1839{
1840 unsigned long long int i = 0;
1841 int neg = 0;
1842
1843 /* Look for minus char. */
1844 if (**s == '-') {
1845 neg = 1;
1846 (*s)++;
1847 }
1848 else if (**s == '+')
1849 (*s)++;
1850
1851 /* convert as positive number. */
1852 i = read_uint64(s, end);
1853
1854 if (neg) {
1855 if (i > 0x8000000000000000ULL)
1856 return LLONG_MIN;
1857 return -i;
1858 }
1859 if (i > 0x7fffffffffffffffULL)
1860 return LLONG_MAX;
1861 return i;
1862}
1863
Willy Tarreau6911fa42007-03-04 18:06:08 +01001864/* This one is 7 times faster than strtol() on athlon with checks.
1865 * It returns the value of the number composed of all valid digits read,
1866 * and can process negative numbers too.
1867 */
1868int strl2ic(const char *s, int len)
1869{
1870 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001871 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001872
1873 if (len > 0) {
1874 if (*s != '-') {
1875 /* positive number */
1876 while (len-- > 0) {
1877 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001878 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001879 if (j > 9)
1880 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001881 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001882 }
1883 } else {
1884 /* negative number */
1885 s++;
1886 while (--len > 0) {
1887 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001888 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001889 if (j > 9)
1890 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001891 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001892 }
1893 }
1894 }
1895 return i;
1896}
1897
1898
1899/* This function reads exactly <len> chars from <s> and converts them to a
1900 * signed integer which it stores into <ret>. It accurately detects any error
1901 * (truncated string, invalid chars, overflows). It is meant to be used in
1902 * applications designed for hostile environments. It returns zero when the
1903 * number has successfully been converted, non-zero otherwise. When an error
1904 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
1905 * faster than strtol().
1906 */
1907int strl2irc(const char *s, int len, int *ret)
1908{
1909 int i = 0;
1910 int j;
1911
1912 if (!len)
1913 return 1;
1914
1915 if (*s != '-') {
1916 /* positive number */
1917 while (len-- > 0) {
1918 j = (*s++) - '0';
1919 if (j > 9) return 1; /* invalid char */
1920 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
1921 i = i * 10;
1922 if (i + j < i) return 1; /* check for addition overflow */
1923 i = i + j;
1924 }
1925 } else {
1926 /* negative number */
1927 s++;
1928 while (--len > 0) {
1929 j = (*s++) - '0';
1930 if (j > 9) return 1; /* invalid char */
1931 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
1932 i = i * 10;
1933 if (i - j > i) return 1; /* check for subtract overflow */
1934 i = i - j;
1935 }
1936 }
1937 *ret = i;
1938 return 0;
1939}
1940
1941
1942/* This function reads exactly <len> chars from <s> and converts them to a
1943 * signed integer which it stores into <ret>. It accurately detects any error
1944 * (truncated string, invalid chars, overflows). It is meant to be used in
1945 * applications designed for hostile environments. It returns zero when the
1946 * number has successfully been converted, non-zero otherwise. When an error
1947 * is returned, the <ret> value is left untouched. It is about 3 times slower
1948 * than str2irc().
1949 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01001950
1951int strl2llrc(const char *s, int len, long long *ret)
1952{
1953 long long i = 0;
1954 int j;
1955
1956 if (!len)
1957 return 1;
1958
1959 if (*s != '-') {
1960 /* positive number */
1961 while (len-- > 0) {
1962 j = (*s++) - '0';
1963 if (j > 9) return 1; /* invalid char */
1964 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
1965 i = i * 10LL;
1966 if (i + j < i) return 1; /* check for addition overflow */
1967 i = i + j;
1968 }
1969 } else {
1970 /* negative number */
1971 s++;
1972 while (--len > 0) {
1973 j = (*s++) - '0';
1974 if (j > 9) return 1; /* invalid char */
1975 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
1976 i = i * 10LL;
1977 if (i - j > i) return 1; /* check for subtract overflow */
1978 i = i - j;
1979 }
1980 }
1981 *ret = i;
1982 return 0;
1983}
1984
Thierry FOURNIER511e9472014-01-23 17:40:34 +01001985/* This function is used with pat_parse_dotted_ver(). It converts a string
1986 * composed by two number separated by a dot. Each part must contain in 16 bits
1987 * because internally they will be represented as a 32-bit quantity stored in
1988 * a 64-bit integer. It returns zero when the number has successfully been
1989 * converted, non-zero otherwise. When an error is returned, the <ret> value
1990 * is left untouched.
1991 *
1992 * "1.3" -> 0x0000000000010003
1993 * "65535.65535" -> 0x00000000ffffffff
1994 */
1995int strl2llrc_dotted(const char *text, int len, long long *ret)
1996{
1997 const char *end = &text[len];
1998 const char *p;
1999 long long major, minor;
2000
2001 /* Look for dot. */
2002 for (p = text; p < end; p++)
2003 if (*p == '.')
2004 break;
2005
2006 /* Convert major. */
2007 if (strl2llrc(text, p - text, &major) != 0)
2008 return 1;
2009
2010 /* Check major. */
2011 if (major >= 65536)
2012 return 1;
2013
2014 /* Convert minor. */
2015 minor = 0;
2016 if (p < end)
2017 if (strl2llrc(p + 1, end - (p + 1), &minor) != 0)
2018 return 1;
2019
2020 /* Check minor. */
2021 if (minor >= 65536)
2022 return 1;
2023
2024 /* Compose value. */
2025 *ret = (major << 16) | (minor & 0xffff);
2026 return 0;
2027}
2028
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002029/* This function parses a time value optionally followed by a unit suffix among
2030 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
2031 * expected by the caller. The computation does its best to avoid overflows.
2032 * The value is returned in <ret> if everything is fine, and a NULL is returned
2033 * by the function. In case of error, a pointer to the error is returned and
2034 * <ret> is left untouched. Values are automatically rounded up when needed.
2035 */
2036const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
2037{
2038 unsigned imult, idiv;
2039 unsigned omult, odiv;
2040 unsigned value;
2041
2042 omult = odiv = 1;
2043
2044 switch (unit_flags & TIME_UNIT_MASK) {
2045 case TIME_UNIT_US: omult = 1000000; break;
2046 case TIME_UNIT_MS: omult = 1000; break;
2047 case TIME_UNIT_S: break;
2048 case TIME_UNIT_MIN: odiv = 60; break;
2049 case TIME_UNIT_HOUR: odiv = 3600; break;
2050 case TIME_UNIT_DAY: odiv = 86400; break;
2051 default: break;
2052 }
2053
2054 value = 0;
2055
2056 while (1) {
2057 unsigned int j;
2058
2059 j = *text - '0';
2060 if (j > 9)
2061 break;
2062 text++;
2063 value *= 10;
2064 value += j;
2065 }
2066
2067 imult = idiv = 1;
2068 switch (*text) {
2069 case '\0': /* no unit = default unit */
2070 imult = omult = idiv = odiv = 1;
2071 break;
2072 case 's': /* second = unscaled unit */
2073 break;
2074 case 'u': /* microsecond : "us" */
2075 if (text[1] == 's') {
2076 idiv = 1000000;
2077 text++;
2078 }
2079 break;
2080 case 'm': /* millisecond : "ms" or minute: "m" */
2081 if (text[1] == 's') {
2082 idiv = 1000;
2083 text++;
2084 } else
2085 imult = 60;
2086 break;
2087 case 'h': /* hour : "h" */
2088 imult = 3600;
2089 break;
2090 case 'd': /* day : "d" */
2091 imult = 86400;
2092 break;
2093 default:
2094 return text;
2095 break;
2096 }
2097
2098 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
2099 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
2100 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
2101 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
2102
2103 value = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
2104 *ret = value;
2105 return NULL;
2106}
Willy Tarreau6911fa42007-03-04 18:06:08 +01002107
Emeric Brun39132b22010-01-04 14:57:24 +01002108/* this function converts the string starting at <text> to an unsigned int
2109 * stored in <ret>. If an error is detected, the pointer to the unexpected
Joseph Herlant32b83272018-11-15 11:58:28 -08002110 * character is returned. If the conversion is successful, NULL is returned.
Emeric Brun39132b22010-01-04 14:57:24 +01002111 */
2112const char *parse_size_err(const char *text, unsigned *ret) {
2113 unsigned value = 0;
2114
2115 while (1) {
2116 unsigned int j;
2117
2118 j = *text - '0';
2119 if (j > 9)
2120 break;
2121 if (value > ~0U / 10)
2122 return text;
2123 value *= 10;
2124 if (value > (value + j))
2125 return text;
2126 value += j;
2127 text++;
2128 }
2129
2130 switch (*text) {
2131 case '\0':
2132 break;
2133 case 'K':
2134 case 'k':
2135 if (value > ~0U >> 10)
2136 return text;
2137 value = value << 10;
2138 break;
2139 case 'M':
2140 case 'm':
2141 if (value > ~0U >> 20)
2142 return text;
2143 value = value << 20;
2144 break;
2145 case 'G':
2146 case 'g':
2147 if (value > ~0U >> 30)
2148 return text;
2149 value = value << 30;
2150 break;
2151 default:
2152 return text;
2153 }
2154
Godbach58048a22015-01-28 17:36:16 +08002155 if (*text != '\0' && *++text != '\0')
2156 return text;
2157
Emeric Brun39132b22010-01-04 14:57:24 +01002158 *ret = value;
2159 return NULL;
2160}
2161
Willy Tarreau126d4062013-12-03 17:50:47 +01002162/*
2163 * Parse binary string written in hexadecimal (source) and store the decoded
2164 * result into binstr and set binstrlen to the lengh of binstr. Memory for
2165 * binstr is allocated by the function. In case of error, returns 0 with an
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002166 * error message in err. In succes case, it returns the consumed length.
Willy Tarreau126d4062013-12-03 17:50:47 +01002167 */
2168int parse_binary(const char *source, char **binstr, int *binstrlen, char **err)
2169{
2170 int len;
2171 const char *p = source;
2172 int i,j;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002173 int alloc;
Willy Tarreau126d4062013-12-03 17:50:47 +01002174
2175 len = strlen(source);
2176 if (len % 2) {
2177 memprintf(err, "an even number of hex digit is expected");
2178 return 0;
2179 }
2180
2181 len = len >> 1;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002182
Willy Tarreau126d4062013-12-03 17:50:47 +01002183 if (!*binstr) {
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002184 *binstr = calloc(len, sizeof(char));
2185 if (!*binstr) {
2186 memprintf(err, "out of memory while loading string pattern");
2187 return 0;
2188 }
2189 alloc = 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002190 }
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002191 else {
2192 if (*binstrlen < len) {
Joseph Herlant76dbe782018-11-15 12:01:22 -08002193 memprintf(err, "no space available in the buffer. expect %d, provides %d",
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002194 len, *binstrlen);
2195 return 0;
2196 }
2197 alloc = 0;
2198 }
2199 *binstrlen = len;
Willy Tarreau126d4062013-12-03 17:50:47 +01002200
2201 i = j = 0;
2202 while (j < len) {
2203 if (!ishex(p[i++]))
2204 goto bad_input;
2205 if (!ishex(p[i++]))
2206 goto bad_input;
2207 (*binstr)[j++] = (hex2i(p[i-2]) << 4) + hex2i(p[i-1]);
2208 }
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002209 return len << 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002210
2211bad_input:
2212 memprintf(err, "an hex digit is expected (found '%c')", p[i-1]);
Andreas Seltenreich93f91c32016-03-03 20:40:37 +01002213 if (alloc) {
2214 free(*binstr);
2215 *binstr = NULL;
2216 }
Willy Tarreau126d4062013-12-03 17:50:47 +01002217 return 0;
2218}
2219
Willy Tarreau946ba592009-05-10 15:41:18 +02002220/* copies at most <n> characters from <src> and always terminates with '\0' */
2221char *my_strndup(const char *src, int n)
2222{
2223 int len = 0;
2224 char *ret;
2225
2226 while (len < n && src[len])
2227 len++;
2228
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002229 ret = malloc(len + 1);
Willy Tarreau946ba592009-05-10 15:41:18 +02002230 if (!ret)
2231 return ret;
2232 memcpy(ret, src, len);
2233 ret[len] = '\0';
2234 return ret;
2235}
2236
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02002237/*
2238 * search needle in haystack
2239 * returns the pointer if found, returns NULL otherwise
2240 */
2241const void *my_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
2242{
2243 const void *c = NULL;
2244 unsigned char f;
2245
2246 if ((haystack == NULL) || (needle == NULL) || (haystacklen < needlelen))
2247 return NULL;
2248
2249 f = *(char *)needle;
2250 c = haystack;
2251 while ((c = memchr(c, f, haystacklen - (c - haystack))) != NULL) {
2252 if ((haystacklen - (c - haystack)) < needlelen)
2253 return NULL;
2254
2255 if (memcmp(c, needle, needlelen) == 0)
2256 return c;
2257 ++c;
2258 }
2259 return NULL;
2260}
2261
Willy Tarreau482b00d2009-10-04 22:48:42 +02002262/* This function returns the first unused key greater than or equal to <key> in
2263 * ID tree <root>. Zero is returned if no place is found.
2264 */
2265unsigned int get_next_id(struct eb_root *root, unsigned int key)
2266{
2267 struct eb32_node *used;
2268
2269 do {
2270 used = eb32_lookup_ge(root, key);
2271 if (!used || used->key > key)
2272 return key; /* key is available */
2273 key++;
2274 } while (key);
2275 return key;
2276}
2277
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002278/* dump the full tree to <file> in DOT format for debugging purposes. Will
2279 * optionally highlight node <subj> if found, depending on operation <op> :
2280 * 0 : nothing
2281 * >0 : insertion, node/leaf are surrounded in red
2282 * <0 : removal, node/leaf are dashed with no background
2283 * Will optionally add "desc" as a label on the graph if set and non-null.
2284 */
2285void eb32sc_to_file(FILE *file, struct eb_root *root, const struct eb32sc_node *subj, int op, const char *desc)
Willy Tarreaued3cda02017-11-15 15:04:05 +01002286{
2287 struct eb32sc_node *node;
2288 unsigned long scope = -1;
2289
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002290 fprintf(file, "digraph ebtree {\n");
2291
2292 if (desc && *desc) {
2293 fprintf(file,
2294 " fontname=\"fixed\";\n"
2295 " fontsize=8;\n"
2296 " label=\"%s\";\n", desc);
2297 }
2298
Willy Tarreaued3cda02017-11-15 15:04:05 +01002299 fprintf(file,
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002300 " node [fontname=\"fixed\" fontsize=8 shape=\"box\" style=\"filled\" color=\"black\" fillcolor=\"white\"];\n"
2301 " edge [fontname=\"fixed\" fontsize=8 style=\"solid\" color=\"magenta\" dir=\"forward\"];\n"
Willy Tarreaued3cda02017-11-15 15:04:05 +01002302 " \"%lx_n\" [label=\"root\\n%lx\"]\n", (long)eb_root_to_node(root), (long)root
2303 );
2304
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002305 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002306 (long)eb_root_to_node(root),
2307 (long)eb_root_to_node(eb_clrtag(root->b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002308 eb_gettag(root->b[0]) == EB_LEAF ? 'l' : 'n');
2309
2310 node = eb32sc_first(root, scope);
2311 while (node) {
2312 if (node->node.node_p) {
2313 /* node part is used */
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002314 fprintf(file, " \"%lx_n\" [label=\"%lx\\nkey=%u\\nscope=%lx\\nbit=%d\" fillcolor=\"lightskyblue1\" %s];\n",
2315 (long)node, (long)node, node->key, node->node_s, node->node.bit,
2316 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002317
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002318 fprintf(file, " \"%lx_n\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002319 (long)node,
2320 (long)eb_root_to_node(eb_clrtag(node->node.node_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002321 eb_gettag(node->node.node_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002322
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002323 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002324 (long)node,
2325 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002326 eb_gettag(node->node.branches.b[0]) == EB_LEAF ? 'l' : 'n');
2327
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002328 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"R\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002329 (long)node,
2330 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[1])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002331 eb_gettag(node->node.branches.b[1]) == EB_LEAF ? 'l' : 'n');
2332 }
2333
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002334 fprintf(file, " \"%lx_l\" [label=\"%lx\\nkey=%u\\nscope=%lx\\npfx=%u\" fillcolor=\"yellow\" %s];\n",
2335 (long)node, (long)node, node->key, node->leaf_s, node->node.pfx,
2336 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002337
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002338 fprintf(file, " \"%lx_l\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002339 (long)node,
2340 (long)eb_root_to_node(eb_clrtag(node->node.leaf_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002341 eb_gettag(node->node.leaf_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002342 node = eb32sc_next(node, scope);
2343 }
2344 fprintf(file, "}\n");
2345}
2346
Willy Tarreau348238b2010-01-18 15:05:57 +01002347/* This function compares a sample word possibly followed by blanks to another
2348 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
2349 * otherwise zero. This intends to be used when checking HTTP headers for some
2350 * values. Note that it validates a word followed only by blanks but does not
2351 * validate a word followed by blanks then other chars.
2352 */
2353int word_match(const char *sample, int slen, const char *word, int wlen)
2354{
2355 if (slen < wlen)
2356 return 0;
2357
2358 while (wlen) {
2359 char c = *sample ^ *word;
2360 if (c && c != ('A' ^ 'a'))
2361 return 0;
2362 sample++;
2363 word++;
2364 slen--;
2365 wlen--;
2366 }
2367
2368 while (slen) {
2369 if (*sample != ' ' && *sample != '\t')
2370 return 0;
2371 sample++;
2372 slen--;
2373 }
2374 return 1;
2375}
Willy Tarreau482b00d2009-10-04 22:48:42 +02002376
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002377/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
2378 * is particularly fast because it avoids expensive operations such as
2379 * multiplies, which are optimized away at the end. It requires a properly
2380 * formated address though (3 points).
2381 */
2382unsigned int inetaddr_host(const char *text)
2383{
2384 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2385 register unsigned int dig100, dig10, dig1;
2386 int s;
2387 const char *p, *d;
2388
2389 dig1 = dig10 = dig100 = ascii_zero;
2390 s = 24;
2391
2392 p = text;
2393 while (1) {
2394 if (((unsigned)(*p - '0')) <= 9) {
2395 p++;
2396 continue;
2397 }
2398
2399 /* here, we have a complete byte between <text> and <p> (exclusive) */
2400 if (p == text)
2401 goto end;
2402
2403 d = p - 1;
2404 dig1 |= (unsigned int)(*d << s);
2405 if (d == text)
2406 goto end;
2407
2408 d--;
2409 dig10 |= (unsigned int)(*d << s);
2410 if (d == text)
2411 goto end;
2412
2413 d--;
2414 dig100 |= (unsigned int)(*d << s);
2415 end:
2416 if (!s || *p != '.')
2417 break;
2418
2419 s -= 8;
2420 text = ++p;
2421 }
2422
2423 dig100 -= ascii_zero;
2424 dig10 -= ascii_zero;
2425 dig1 -= ascii_zero;
2426 return ((dig100 * 10) + dig10) * 10 + dig1;
2427}
2428
2429/*
2430 * Idem except the first unparsed character has to be passed in <stop>.
2431 */
2432unsigned int inetaddr_host_lim(const char *text, const char *stop)
2433{
2434 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2435 register unsigned int dig100, dig10, dig1;
2436 int s;
2437 const char *p, *d;
2438
2439 dig1 = dig10 = dig100 = ascii_zero;
2440 s = 24;
2441
2442 p = text;
2443 while (1) {
2444 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2445 p++;
2446 continue;
2447 }
2448
2449 /* here, we have a complete byte between <text> and <p> (exclusive) */
2450 if (p == text)
2451 goto end;
2452
2453 d = p - 1;
2454 dig1 |= (unsigned int)(*d << s);
2455 if (d == text)
2456 goto end;
2457
2458 d--;
2459 dig10 |= (unsigned int)(*d << s);
2460 if (d == text)
2461 goto end;
2462
2463 d--;
2464 dig100 |= (unsigned int)(*d << s);
2465 end:
2466 if (!s || p == stop || *p != '.')
2467 break;
2468
2469 s -= 8;
2470 text = ++p;
2471 }
2472
2473 dig100 -= ascii_zero;
2474 dig10 -= ascii_zero;
2475 dig1 -= ascii_zero;
2476 return ((dig100 * 10) + dig10) * 10 + dig1;
2477}
2478
2479/*
2480 * Idem except the pointer to first unparsed byte is returned into <ret> which
2481 * must not be NULL.
2482 */
Willy Tarreau74172752010-10-15 23:21:42 +02002483unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002484{
2485 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2486 register unsigned int dig100, dig10, dig1;
2487 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02002488 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002489
2490 dig1 = dig10 = dig100 = ascii_zero;
2491 s = 24;
2492
2493 p = text;
2494 while (1) {
2495 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2496 p++;
2497 continue;
2498 }
2499
2500 /* here, we have a complete byte between <text> and <p> (exclusive) */
2501 if (p == text)
2502 goto end;
2503
2504 d = p - 1;
2505 dig1 |= (unsigned int)(*d << s);
2506 if (d == text)
2507 goto end;
2508
2509 d--;
2510 dig10 |= (unsigned int)(*d << s);
2511 if (d == text)
2512 goto end;
2513
2514 d--;
2515 dig100 |= (unsigned int)(*d << s);
2516 end:
2517 if (!s || p == stop || *p != '.')
2518 break;
2519
2520 s -= 8;
2521 text = ++p;
2522 }
2523
2524 *ret = p;
2525 dig100 -= ascii_zero;
2526 dig10 -= ascii_zero;
2527 dig1 -= ascii_zero;
2528 return ((dig100 * 10) + dig10) * 10 + dig1;
2529}
2530
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002531/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
2532 * or the number of chars read in case of success. Maybe this could be replaced
2533 * by one of the functions above. Also, apparently this function does not support
2534 * hosts above 255 and requires exactly 4 octets.
Willy Tarreau075415a2013-12-12 11:29:39 +01002535 * The destination is only modified on success.
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002536 */
2537int buf2ip(const char *buf, size_t len, struct in_addr *dst)
2538{
2539 const char *addr;
2540 int saw_digit, octets, ch;
2541 u_char tmp[4], *tp;
2542 const char *cp = buf;
2543
2544 saw_digit = 0;
2545 octets = 0;
2546 *(tp = tmp) = 0;
2547
2548 for (addr = buf; addr - buf < len; addr++) {
2549 unsigned char digit = (ch = *addr) - '0';
2550
2551 if (digit > 9 && ch != '.')
2552 break;
2553
2554 if (digit <= 9) {
2555 u_int new = *tp * 10 + digit;
2556
2557 if (new > 255)
2558 return 0;
2559
2560 *tp = new;
2561
2562 if (!saw_digit) {
2563 if (++octets > 4)
2564 return 0;
2565 saw_digit = 1;
2566 }
2567 } else if (ch == '.' && saw_digit) {
2568 if (octets == 4)
2569 return 0;
2570
2571 *++tp = 0;
2572 saw_digit = 0;
2573 } else
2574 return 0;
2575 }
2576
2577 if (octets < 4)
2578 return 0;
2579
2580 memcpy(&dst->s_addr, tmp, 4);
2581 return addr - cp;
2582}
2583
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002584/* This function converts the string in <buf> of the len <len> to
2585 * struct in6_addr <dst> which must be allocated by the caller.
2586 * This function returns 1 in success case, otherwise zero.
Willy Tarreau075415a2013-12-12 11:29:39 +01002587 * The destination is only modified on success.
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002588 */
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002589int buf2ip6(const char *buf, size_t len, struct in6_addr *dst)
2590{
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002591 char null_term_ip6[INET6_ADDRSTRLEN + 1];
Willy Tarreau075415a2013-12-12 11:29:39 +01002592 struct in6_addr out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002593
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002594 if (len > INET6_ADDRSTRLEN)
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002595 return 0;
2596
2597 memcpy(null_term_ip6, buf, len);
2598 null_term_ip6[len] = '\0';
2599
Willy Tarreau075415a2013-12-12 11:29:39 +01002600 if (!inet_pton(AF_INET6, null_term_ip6, &out))
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002601 return 0;
2602
Willy Tarreau075415a2013-12-12 11:29:39 +01002603 *dst = out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002604 return 1;
2605}
2606
Willy Tarreauacf95772010-06-14 19:09:21 +02002607/* To be used to quote config arg positions. Returns the short string at <ptr>
2608 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
2609 * if ptr is NULL or empty. The string is locally allocated.
2610 */
2611const char *quote_arg(const char *ptr)
2612{
Christopher Faulet1bc04c72017-10-29 20:14:08 +01002613 static THREAD_LOCAL char val[32];
Willy Tarreauacf95772010-06-14 19:09:21 +02002614 int i;
2615
2616 if (!ptr || !*ptr)
2617 return "end of line";
2618 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01002619 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02002620 val[i] = *ptr++;
2621 val[i++] = '\'';
2622 val[i] = '\0';
2623 return val;
2624}
2625
Willy Tarreau5b180202010-07-18 10:40:48 +02002626/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
2627int get_std_op(const char *str)
2628{
2629 int ret = -1;
2630
2631 if (*str == 'e' && str[1] == 'q')
2632 ret = STD_OP_EQ;
2633 else if (*str == 'n' && str[1] == 'e')
2634 ret = STD_OP_NE;
2635 else if (*str == 'l') {
2636 if (str[1] == 'e') ret = STD_OP_LE;
2637 else if (str[1] == 't') ret = STD_OP_LT;
2638 }
2639 else if (*str == 'g') {
2640 if (str[1] == 'e') ret = STD_OP_GE;
2641 else if (str[1] == 't') ret = STD_OP_GT;
2642 }
2643
2644 if (ret == -1 || str[2] != '\0')
2645 return -1;
2646 return ret;
2647}
2648
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01002649/* hash a 32-bit integer to another 32-bit integer */
2650unsigned int full_hash(unsigned int a)
2651{
2652 return __full_hash(a);
2653}
2654
Willy Tarreauf3241112019-02-26 09:56:22 +01002655/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
2656 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
2657 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
2658 * a popcount variant and is described here :
2659 * https://graphics.stanford.edu/~seander/bithacks.html
2660 */
2661unsigned int mask_find_rank_bit(unsigned int r, unsigned long m)
2662{
2663 unsigned long a, b, c, d;
2664 unsigned int s;
2665 unsigned int t;
2666
2667 a = m - ((m >> 1) & ~0UL/3);
2668 b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
2669 c = (b + (b >> 4)) & ~0UL/0x11;
2670 d = (c + (c >> 8)) & ~0UL/0x101;
2671
2672 r++; // make r be 1..64
2673
2674 t = 0;
2675 s = LONGBITS;
2676 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002677 unsigned long d2 = (d >> 16) >> 16;
2678 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002679 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2680 }
2681
2682 t = (d >> (s - 16)) & 0xff;
2683 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2684 t = (c >> (s - 8)) & 0xf;
2685 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
2686 t = (b >> (s - 4)) & 0x7;
2687 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
2688 t = (a >> (s - 2)) & 0x3;
2689 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
2690 t = (m >> (s - 1)) & 0x1;
2691 s -= ((t - r) & 256) >> 8;
2692
2693 return s - 1;
2694}
2695
2696/* Same as mask_find_rank_bit() above but makes use of pre-computed bitmaps
2697 * based on <m>, in <a..d>. These ones must be updated whenever <m> changes
2698 * using mask_prep_rank_map() below.
2699 */
2700unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
2701 unsigned long a, unsigned long b,
2702 unsigned long c, unsigned long d)
2703{
2704 unsigned int s;
2705 unsigned int t;
2706
2707 r++; // make r be 1..64
2708
2709 t = 0;
2710 s = LONGBITS;
2711 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002712 unsigned long d2 = (d >> 16) >> 16;
2713 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002714 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2715 }
2716
2717 t = (d >> (s - 16)) & 0xff;
2718 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2719 t = (c >> (s - 8)) & 0xf;
2720 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
2721 t = (b >> (s - 4)) & 0x7;
2722 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
2723 t = (a >> (s - 2)) & 0x3;
2724 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
2725 t = (m >> (s - 1)) & 0x1;
2726 s -= ((t - r) & 256) >> 8;
2727
2728 return s - 1;
2729}
2730
2731/* Prepare the bitmaps used by the fast implementation of the find_rank_bit()
2732 * above.
2733 */
2734void mask_prep_rank_map(unsigned long m,
2735 unsigned long *a, unsigned long *b,
2736 unsigned long *c, unsigned long *d)
2737{
2738 *a = m - ((m >> 1) & ~0UL/3);
2739 *b = (*a & ~0UL/5) + ((*a >> 2) & ~0UL/5);
2740 *c = (*b + (*b >> 4)) & ~0UL/0x11;
2741 *d = (*c + (*c >> 8)) & ~0UL/0x101;
2742}
2743
David du Colombier4f92d322011-03-24 11:09:31 +01002744/* Return non-zero if IPv4 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02002745 * otherwise zero. Note that <addr> may not necessarily be aligned
2746 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01002747 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02002748int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01002749{
Willy Tarreaueec1d382016-07-13 11:59:39 +02002750 struct in_addr addr_copy;
2751
2752 memcpy(&addr_copy, addr, sizeof(addr_copy));
2753 return((addr_copy.s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
David du Colombier4f92d322011-03-24 11:09:31 +01002754}
2755
2756/* Return non-zero if IPv6 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02002757 * otherwise zero. Note that <addr> may not necessarily be aligned
2758 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01002759 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02002760int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01002761{
2762 int i;
Willy Tarreaueec1d382016-07-13 11:59:39 +02002763 struct in6_addr addr_copy;
David du Colombier4f92d322011-03-24 11:09:31 +01002764
Willy Tarreaueec1d382016-07-13 11:59:39 +02002765 memcpy(&addr_copy, addr, sizeof(addr_copy));
David du Colombier4f92d322011-03-24 11:09:31 +01002766 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
Willy Tarreaueec1d382016-07-13 11:59:39 +02002767 if (((((int *)&addr_copy)[i] & ((int *)mask)[i])) !=
David du Colombier4f92d322011-03-24 11:09:31 +01002768 (((int *)net)[i] & ((int *)mask)[i]))
2769 return 0;
2770 return 1;
2771}
2772
2773/* RFC 4291 prefix */
2774const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
2775 0x00, 0x00, 0x00, 0x00,
2776 0x00, 0x00, 0xFF, 0xFF };
2777
Joseph Herlant32b83272018-11-15 11:58:28 -08002778/* Map IPv4 address on IPv6 address, as specified in RFC 3513.
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01002779 * Input and output may overlap.
2780 */
David du Colombier4f92d322011-03-24 11:09:31 +01002781void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
2782{
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01002783 struct in_addr tmp_addr;
2784
2785 tmp_addr.s_addr = sin_addr->s_addr;
David du Colombier4f92d322011-03-24 11:09:31 +01002786 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01002787 memcpy(sin6_addr->s6_addr+12, &tmp_addr.s_addr, 4);
David du Colombier4f92d322011-03-24 11:09:31 +01002788}
2789
Joseph Herlant32b83272018-11-15 11:58:28 -08002790/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01002791 * Return true if conversion is possible and false otherwise.
2792 */
2793int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
2794{
2795 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
2796 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
2797 sizeof(struct in_addr));
2798 return 1;
2799 }
2800
2801 return 0;
2802}
2803
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01002804/* compare two struct sockaddr_storage and return:
2805 * 0 (true) if the addr is the same in both
2806 * 1 (false) if the addr is not the same in both
2807 * -1 (unable) if one of the addr is not AF_INET*
2808 */
2809int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2)
2810{
2811 if ((ss1->ss_family != AF_INET) && (ss1->ss_family != AF_INET6))
2812 return -1;
2813
2814 if ((ss2->ss_family != AF_INET) && (ss2->ss_family != AF_INET6))
2815 return -1;
2816
2817 if (ss1->ss_family != ss2->ss_family)
2818 return 1;
2819
2820 switch (ss1->ss_family) {
2821 case AF_INET:
2822 return memcmp(&((struct sockaddr_in *)ss1)->sin_addr,
2823 &((struct sockaddr_in *)ss2)->sin_addr,
2824 sizeof(struct in_addr)) != 0;
2825 case AF_INET6:
2826 return memcmp(&((struct sockaddr_in6 *)ss1)->sin6_addr,
2827 &((struct sockaddr_in6 *)ss2)->sin6_addr,
2828 sizeof(struct in6_addr)) != 0;
2829 }
2830
2831 return 1;
2832}
2833
Baptiste Assmann08396c82016-01-31 00:27:17 +01002834/* copy IP address from <source> into <dest>
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01002835 * The caller must allocate and clear <dest> before calling.
2836 * The source must be in either AF_INET or AF_INET6 family, or the destination
2837 * address will be undefined. If the destination address used to hold a port,
2838 * it is preserved, so that this function can be used to switch to another
2839 * address family with no risk. Returns a pointer to the destination.
Baptiste Assmann08396c82016-01-31 00:27:17 +01002840 */
2841struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest)
2842{
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01002843 int prev_port;
2844
2845 prev_port = get_net_port(dest);
2846 memset(dest, 0, sizeof(*dest));
Baptiste Assmann08396c82016-01-31 00:27:17 +01002847 dest->ss_family = source->ss_family;
2848
2849 /* copy new addr and apply it */
2850 switch (source->ss_family) {
2851 case AF_INET:
2852 ((struct sockaddr_in *)dest)->sin_addr.s_addr = ((struct sockaddr_in *)source)->sin_addr.s_addr;
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01002853 ((struct sockaddr_in *)dest)->sin_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01002854 break;
2855 case AF_INET6:
2856 memcpy(((struct sockaddr_in6 *)dest)->sin6_addr.s6_addr, ((struct sockaddr_in6 *)source)->sin6_addr.s6_addr, sizeof(struct in6_addr));
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01002857 ((struct sockaddr_in6 *)dest)->sin6_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01002858 break;
2859 }
2860
2861 return dest;
2862}
2863
William Lallemand421f5b52012-02-06 18:15:57 +01002864char *human_time(int t, short hz_div) {
2865 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
2866 char *p = rv;
Willy Tarreau761b3d52014-04-14 14:53:06 +02002867 char *end = rv + sizeof(rv);
William Lallemand421f5b52012-02-06 18:15:57 +01002868 int cnt=2; // print two numbers
2869
2870 if (unlikely(t < 0 || hz_div <= 0)) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02002871 snprintf(p, end - p, "?");
William Lallemand421f5b52012-02-06 18:15:57 +01002872 return rv;
2873 }
2874
2875 if (unlikely(hz_div > 1))
2876 t /= hz_div;
2877
2878 if (t >= DAY) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02002879 p += snprintf(p, end - p, "%dd", t / DAY);
William Lallemand421f5b52012-02-06 18:15:57 +01002880 cnt--;
2881 }
2882
2883 if (cnt && t % DAY / HOUR) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02002884 p += snprintf(p, end - p, "%dh", t % DAY / HOUR);
William Lallemand421f5b52012-02-06 18:15:57 +01002885 cnt--;
2886 }
2887
2888 if (cnt && t % HOUR / MINUTE) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02002889 p += snprintf(p, end - p, "%dm", t % HOUR / MINUTE);
William Lallemand421f5b52012-02-06 18:15:57 +01002890 cnt--;
2891 }
2892
2893 if ((cnt && t % MINUTE) || !t) // also display '0s'
Willy Tarreau761b3d52014-04-14 14:53:06 +02002894 p += snprintf(p, end - p, "%ds", t % MINUTE / SEC);
William Lallemand421f5b52012-02-06 18:15:57 +01002895
2896 return rv;
2897}
2898
2899const char *monthname[12] = {
2900 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
2901 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
2902};
2903
2904/* date2str_log: write a date in the format :
2905 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
2906 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
2907 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
2908 *
2909 * without using sprintf. return a pointer to the last char written (\0) or
2910 * NULL if there isn't enough space.
2911 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02002912char *date2str_log(char *dst, const struct tm *tm, const struct timeval *date, size_t size)
William Lallemand421f5b52012-02-06 18:15:57 +01002913{
2914
2915 if (size < 25) /* the size is fixed: 24 chars + \0 */
2916 return NULL;
2917
2918 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002919 if (!dst)
2920 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002921 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002922
William Lallemand421f5b52012-02-06 18:15:57 +01002923 memcpy(dst, monthname[tm->tm_mon], 3); // month
2924 dst += 3;
2925 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002926
William Lallemand421f5b52012-02-06 18:15:57 +01002927 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002928 if (!dst)
2929 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002930 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002931
William Lallemand421f5b52012-02-06 18:15:57 +01002932 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002933 if (!dst)
2934 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002935 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002936
William Lallemand421f5b52012-02-06 18:15:57 +01002937 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002938 if (!dst)
2939 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002940 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002941
William Lallemand421f5b52012-02-06 18:15:57 +01002942 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002943 if (!dst)
2944 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002945 *dst++ = '.';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002946
William Lallemand421f5b52012-02-06 18:15:57 +01002947 utoa_pad((unsigned int)(date->tv_usec/1000), dst, 4); // millisecondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01002948 if (!dst)
2949 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01002950 dst += 3; // only the 3 first digits
2951 *dst = '\0';
2952
2953 return dst;
2954}
2955
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02002956/* Base year used to compute leap years */
2957#define TM_YEAR_BASE 1900
2958
2959/* Return the difference in seconds between two times (leap seconds are ignored).
2960 * Retrieved from glibc 2.18 source code.
2961 */
2962static int my_tm_diff(const struct tm *a, const struct tm *b)
2963{
2964 /* Compute intervening leap days correctly even if year is negative.
2965 * Take care to avoid int overflow in leap day calculations,
2966 * but it's OK to assume that A and B are close to each other.
2967 */
2968 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
2969 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
2970 int a100 = a4 / 25 - (a4 % 25 < 0);
2971 int b100 = b4 / 25 - (b4 % 25 < 0);
2972 int a400 = a100 >> 2;
2973 int b400 = b100 >> 2;
2974 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
2975 int years = a->tm_year - b->tm_year;
2976 int days = (365 * years + intervening_leap_days
2977 + (a->tm_yday - b->tm_yday));
2978 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
2979 + (a->tm_min - b->tm_min))
2980 + (a->tm_sec - b->tm_sec));
2981}
2982
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002983/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02002984 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002985 * The string returned has the same format as returned by strftime(... "%z", tm).
2986 * Offsets are kept in an internal cache for better performances.
2987 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02002988const char *get_gmt_offset(time_t t, struct tm *tm)
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002989{
2990 /* Cache offsets from GMT (depending on whether DST is active or not) */
Christopher Faulet1bc04c72017-10-29 20:14:08 +01002991 static THREAD_LOCAL char gmt_offsets[2][5+1] = { "", "" };
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002992
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002993 char *gmt_offset;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02002994 struct tm tm_gmt;
2995 int diff;
2996 int isdst = tm->tm_isdst;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02002997
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02002998 /* Pretend DST not active if its status is unknown */
2999 if (isdst < 0)
3000 isdst = 0;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003001
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003002 /* Fetch the offset and initialize it if needed */
3003 gmt_offset = gmt_offsets[isdst & 0x01];
3004 if (unlikely(!*gmt_offset)) {
3005 get_gmtime(t, &tm_gmt);
3006 diff = my_tm_diff(tm, &tm_gmt);
3007 if (diff < 0) {
3008 diff = -diff;
3009 *gmt_offset = '-';
3010 } else {
3011 *gmt_offset = '+';
3012 }
3013 diff /= 60; /* Convert to minutes */
3014 snprintf(gmt_offset+1, 4+1, "%02d%02d", diff/60, diff%60);
3015 }
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003016
3017 return gmt_offset;
3018}
3019
William Lallemand421f5b52012-02-06 18:15:57 +01003020/* gmt2str_log: write a date in the format :
3021 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
3022 * return a pointer to the last char written (\0) or
3023 * NULL if there isn't enough space.
3024 */
3025char *gmt2str_log(char *dst, struct tm *tm, size_t size)
3026{
Yuxans Yao4e25b012012-10-19 10:36:09 +08003027 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01003028 return NULL;
3029
3030 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003031 if (!dst)
3032 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003033 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003034
William Lallemand421f5b52012-02-06 18:15:57 +01003035 memcpy(dst, monthname[tm->tm_mon], 3); // month
3036 dst += 3;
3037 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003038
William Lallemand421f5b52012-02-06 18:15:57 +01003039 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003040 if (!dst)
3041 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003042 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003043
William Lallemand421f5b52012-02-06 18:15:57 +01003044 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003045 if (!dst)
3046 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003047 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003048
William Lallemand421f5b52012-02-06 18:15:57 +01003049 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003050 if (!dst)
3051 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003052 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003053
William Lallemand421f5b52012-02-06 18:15:57 +01003054 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003055 if (!dst)
3056 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003057 *dst++ = ' ';
3058 *dst++ = '+';
3059 *dst++ = '0';
3060 *dst++ = '0';
3061 *dst++ = '0';
3062 *dst++ = '0';
3063 *dst = '\0';
3064
3065 return dst;
3066}
3067
Yuxans Yao4e25b012012-10-19 10:36:09 +08003068/* localdate2str_log: write a date in the format :
3069 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003070 * Both t and tm must represent the same time.
3071 * return a pointer to the last char written (\0) or
3072 * NULL if there isn't enough space.
Yuxans Yao4e25b012012-10-19 10:36:09 +08003073 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003074char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size)
Yuxans Yao4e25b012012-10-19 10:36:09 +08003075{
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003076 const char *gmt_offset;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003077 if (size < 27) /* the size is fixed: 26 chars + \0 */
3078 return NULL;
3079
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003080 gmt_offset = get_gmt_offset(t, tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003081
Yuxans Yao4e25b012012-10-19 10:36:09 +08003082 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003083 if (!dst)
3084 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003085 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003086
Yuxans Yao4e25b012012-10-19 10:36:09 +08003087 memcpy(dst, monthname[tm->tm_mon], 3); // month
3088 dst += 3;
3089 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003090
Yuxans Yao4e25b012012-10-19 10:36:09 +08003091 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003092 if (!dst)
3093 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003094 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003095
Yuxans Yao4e25b012012-10-19 10:36:09 +08003096 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003097 if (!dst)
3098 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003099 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003100
Yuxans Yao4e25b012012-10-19 10:36:09 +08003101 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003102 if (!dst)
3103 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003104 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003105
Yuxans Yao4e25b012012-10-19 10:36:09 +08003106 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003107 if (!dst)
3108 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003109 *dst++ = ' ';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003110
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003111 memcpy(dst, gmt_offset, 5); // Offset from local time to GMT
Yuxans Yao4e25b012012-10-19 10:36:09 +08003112 dst += 5;
3113 *dst = '\0';
3114
3115 return dst;
3116}
3117
Willy Tarreaucb1949b2017-07-19 19:05:29 +02003118/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
3119 * It is meant as a portable replacement for timegm() for use with valid inputs.
3120 * Returns undefined results for invalid dates (eg: months out of range 0..11).
3121 */
3122time_t my_timegm(const struct tm *tm)
3123{
3124 /* Each month has 28, 29, 30 or 31 days, or 28+N. The date in the year
3125 * is thus (current month - 1)*28 + cumulated_N[month] to count the
3126 * sum of the extra N days for elapsed months. The sum of all these N
3127 * days doesn't exceed 30 for a complete year (366-12*28) so it fits
3128 * in a 5-bit word. This means that with 60 bits we can represent a
3129 * matrix of all these values at once, which is fast and efficient to
3130 * access. The extra February day for leap years is not counted here.
3131 *
3132 * Jan : none = 0 (0)
3133 * Feb : Jan = 3 (3)
3134 * Mar : Jan..Feb = 3 (3 + 0)
3135 * Apr : Jan..Mar = 6 (3 + 0 + 3)
3136 * May : Jan..Apr = 8 (3 + 0 + 3 + 2)
3137 * Jun : Jan..May = 11 (3 + 0 + 3 + 2 + 3)
3138 * Jul : Jan..Jun = 13 (3 + 0 + 3 + 2 + 3 + 2)
3139 * Aug : Jan..Jul = 16 (3 + 0 + 3 + 2 + 3 + 2 + 3)
3140 * Sep : Jan..Aug = 19 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3)
3141 * Oct : Jan..Sep = 21 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2)
3142 * Nov : Jan..Oct = 24 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3)
3143 * Dec : Jan..Nov = 26 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3 + 2)
3144 */
3145 uint64_t extra =
3146 ( 0ULL << 0*5) + ( 3ULL << 1*5) + ( 3ULL << 2*5) + /* Jan, Feb, Mar, */
3147 ( 6ULL << 3*5) + ( 8ULL << 4*5) + (11ULL << 5*5) + /* Apr, May, Jun, */
3148 (13ULL << 6*5) + (16ULL << 7*5) + (19ULL << 8*5) + /* Jul, Aug, Sep, */
3149 (21ULL << 9*5) + (24ULL << 10*5) + (26ULL << 11*5); /* Oct, Nov, Dec, */
3150
3151 unsigned int y = tm->tm_year + 1900;
3152 unsigned int m = tm->tm_mon;
3153 unsigned long days = 0;
3154
3155 /* days since 1/1/1970 for full years */
3156 days += days_since_zero(y) - days_since_zero(1970);
3157
3158 /* days for full months in the current year */
3159 days += 28 * m + ((extra >> (m * 5)) & 0x1f);
3160
3161 /* count + 1 after March for leap years. A leap year is a year multiple
3162 * of 4, unless it's multiple of 100 without being multiple of 400. 2000
3163 * is leap, 1900 isn't, 1904 is.
3164 */
3165 if ((m > 1) && !(y & 3) && ((y % 100) || !(y % 400)))
3166 days++;
3167
3168 days += tm->tm_mday - 1;
3169 return days * 86400ULL + tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
3170}
3171
Thierry Fournier93127942016-01-20 18:49:45 +01003172/* This function check a char. It returns true and updates
3173 * <date> and <len> pointer to the new position if the
3174 * character is found.
3175 */
3176static inline int parse_expect_char(const char **date, int *len, char c)
3177{
3178 if (*len < 1 || **date != c)
3179 return 0;
3180 (*len)--;
3181 (*date)++;
3182 return 1;
3183}
3184
3185/* This function expects a string <str> of len <l>. It return true and updates.
3186 * <date> and <len> if the string matches, otherwise, it returns false.
3187 */
3188static inline int parse_strcmp(const char **date, int *len, char *str, int l)
3189{
3190 if (*len < l || strncmp(*date, str, l) != 0)
3191 return 0;
3192 (*len) -= l;
3193 (*date) += l;
3194 return 1;
3195}
3196
3197/* This macro converts 3 chars name in integer. */
3198#define STR2I3(__a, __b, __c) ((__a) * 65536 + (__b) * 256 + (__c))
3199
3200/* day-name = %x4D.6F.6E ; "Mon", case-sensitive
3201 * / %x54.75.65 ; "Tue", case-sensitive
3202 * / %x57.65.64 ; "Wed", case-sensitive
3203 * / %x54.68.75 ; "Thu", case-sensitive
3204 * / %x46.72.69 ; "Fri", case-sensitive
3205 * / %x53.61.74 ; "Sat", case-sensitive
3206 * / %x53.75.6E ; "Sun", case-sensitive
3207 *
3208 * This array must be alphabetically sorted
3209 */
3210static inline int parse_http_dayname(const char **date, int *len, struct tm *tm)
3211{
3212 if (*len < 3)
3213 return 0;
3214 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3215 case STR2I3('M','o','n'): tm->tm_wday = 1; break;
3216 case STR2I3('T','u','e'): tm->tm_wday = 2; break;
3217 case STR2I3('W','e','d'): tm->tm_wday = 3; break;
3218 case STR2I3('T','h','u'): tm->tm_wday = 4; break;
3219 case STR2I3('F','r','i'): tm->tm_wday = 5; break;
3220 case STR2I3('S','a','t'): tm->tm_wday = 6; break;
3221 case STR2I3('S','u','n'): tm->tm_wday = 7; break;
3222 default: return 0;
3223 }
3224 *len -= 3;
3225 *date += 3;
3226 return 1;
3227}
3228
3229/* month = %x4A.61.6E ; "Jan", case-sensitive
3230 * / %x46.65.62 ; "Feb", case-sensitive
3231 * / %x4D.61.72 ; "Mar", case-sensitive
3232 * / %x41.70.72 ; "Apr", case-sensitive
3233 * / %x4D.61.79 ; "May", case-sensitive
3234 * / %x4A.75.6E ; "Jun", case-sensitive
3235 * / %x4A.75.6C ; "Jul", case-sensitive
3236 * / %x41.75.67 ; "Aug", case-sensitive
3237 * / %x53.65.70 ; "Sep", case-sensitive
3238 * / %x4F.63.74 ; "Oct", case-sensitive
3239 * / %x4E.6F.76 ; "Nov", case-sensitive
3240 * / %x44.65.63 ; "Dec", case-sensitive
3241 *
3242 * This array must be alphabetically sorted
3243 */
3244static inline int parse_http_monthname(const char **date, int *len, struct tm *tm)
3245{
3246 if (*len < 3)
3247 return 0;
3248 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3249 case STR2I3('J','a','n'): tm->tm_mon = 0; break;
3250 case STR2I3('F','e','b'): tm->tm_mon = 1; break;
3251 case STR2I3('M','a','r'): tm->tm_mon = 2; break;
3252 case STR2I3('A','p','r'): tm->tm_mon = 3; break;
3253 case STR2I3('M','a','y'): tm->tm_mon = 4; break;
3254 case STR2I3('J','u','n'): tm->tm_mon = 5; break;
3255 case STR2I3('J','u','l'): tm->tm_mon = 6; break;
3256 case STR2I3('A','u','g'): tm->tm_mon = 7; break;
3257 case STR2I3('S','e','p'): tm->tm_mon = 8; break;
3258 case STR2I3('O','c','t'): tm->tm_mon = 9; break;
3259 case STR2I3('N','o','v'): tm->tm_mon = 10; break;
3260 case STR2I3('D','e','c'): tm->tm_mon = 11; break;
3261 default: return 0;
3262 }
3263 *len -= 3;
3264 *date += 3;
3265 return 1;
3266}
3267
3268/* day-name-l = %x4D.6F.6E.64.61.79 ; "Monday", case-sensitive
3269 * / %x54.75.65.73.64.61.79 ; "Tuesday", case-sensitive
3270 * / %x57.65.64.6E.65.73.64.61.79 ; "Wednesday", case-sensitive
3271 * / %x54.68.75.72.73.64.61.79 ; "Thursday", case-sensitive
3272 * / %x46.72.69.64.61.79 ; "Friday", case-sensitive
3273 * / %x53.61.74.75.72.64.61.79 ; "Saturday", case-sensitive
3274 * / %x53.75.6E.64.61.79 ; "Sunday", case-sensitive
3275 *
3276 * This array must be alphabetically sorted
3277 */
3278static inline int parse_http_ldayname(const char **date, int *len, struct tm *tm)
3279{
3280 if (*len < 6) /* Minimum length. */
3281 return 0;
3282 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3283 case STR2I3('M','o','n'):
3284 RET0_UNLESS(parse_strcmp(date, len, "Monday", 6));
3285 tm->tm_wday = 1;
3286 return 1;
3287 case STR2I3('T','u','e'):
3288 RET0_UNLESS(parse_strcmp(date, len, "Tuesday", 7));
3289 tm->tm_wday = 2;
3290 return 1;
3291 case STR2I3('W','e','d'):
3292 RET0_UNLESS(parse_strcmp(date, len, "Wednesday", 9));
3293 tm->tm_wday = 3;
3294 return 1;
3295 case STR2I3('T','h','u'):
3296 RET0_UNLESS(parse_strcmp(date, len, "Thursday", 8));
3297 tm->tm_wday = 4;
3298 return 1;
3299 case STR2I3('F','r','i'):
3300 RET0_UNLESS(parse_strcmp(date, len, "Friday", 6));
3301 tm->tm_wday = 5;
3302 return 1;
3303 case STR2I3('S','a','t'):
3304 RET0_UNLESS(parse_strcmp(date, len, "Saturday", 8));
3305 tm->tm_wday = 6;
3306 return 1;
3307 case STR2I3('S','u','n'):
3308 RET0_UNLESS(parse_strcmp(date, len, "Sunday", 6));
3309 tm->tm_wday = 7;
3310 return 1;
3311 }
3312 return 0;
3313}
3314
3315/* This function parses exactly 1 digit and returns the numeric value in "digit". */
3316static inline int parse_digit(const char **date, int *len, int *digit)
3317{
3318 if (*len < 1 || **date < '0' || **date > '9')
3319 return 0;
3320 *digit = (**date - '0');
3321 (*date)++;
3322 (*len)--;
3323 return 1;
3324}
3325
3326/* This function parses exactly 2 digits and returns the numeric value in "digit". */
3327static inline int parse_2digit(const char **date, int *len, int *digit)
3328{
3329 int value;
3330
3331 RET0_UNLESS(parse_digit(date, len, &value));
3332 (*digit) = value * 10;
3333 RET0_UNLESS(parse_digit(date, len, &value));
3334 (*digit) += value;
3335
3336 return 1;
3337}
3338
3339/* This function parses exactly 4 digits and returns the numeric value in "digit". */
3340static inline int parse_4digit(const char **date, int *len, int *digit)
3341{
3342 int value;
3343
3344 RET0_UNLESS(parse_digit(date, len, &value));
3345 (*digit) = value * 1000;
3346
3347 RET0_UNLESS(parse_digit(date, len, &value));
3348 (*digit) += value * 100;
3349
3350 RET0_UNLESS(parse_digit(date, len, &value));
3351 (*digit) += value * 10;
3352
3353 RET0_UNLESS(parse_digit(date, len, &value));
3354 (*digit) += value;
3355
3356 return 1;
3357}
3358
3359/* time-of-day = hour ":" minute ":" second
3360 * ; 00:00:00 - 23:59:60 (leap second)
3361 *
3362 * hour = 2DIGIT
3363 * minute = 2DIGIT
3364 * second = 2DIGIT
3365 */
3366static inline int parse_http_time(const char **date, int *len, struct tm *tm)
3367{
3368 RET0_UNLESS(parse_2digit(date, len, &tm->tm_hour)); /* hour 2DIGIT */
3369 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3370 RET0_UNLESS(parse_2digit(date, len, &tm->tm_min)); /* min 2DIGIT */
3371 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3372 RET0_UNLESS(parse_2digit(date, len, &tm->tm_sec)); /* sec 2DIGIT */
3373 return 1;
3374}
3375
3376/* From RFC7231
3377 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3378 *
3379 * IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
3380 * ; fixed length/zone/capitalization subset of the format
3381 * ; see Section 3.3 of [RFC5322]
3382 *
3383 *
3384 * date1 = day SP month SP year
3385 * ; e.g., 02 Jun 1982
3386 *
3387 * day = 2DIGIT
3388 * year = 4DIGIT
3389 *
3390 * GMT = %x47.4D.54 ; "GMT", case-sensitive
3391 *
3392 * time-of-day = hour ":" minute ":" second
3393 * ; 00:00:00 - 23:59:60 (leap second)
3394 *
3395 * hour = 2DIGIT
3396 * minute = 2DIGIT
3397 * second = 2DIGIT
3398 *
3399 * DIGIT = decimal 0-9
3400 */
3401int parse_imf_date(const char *date, int len, struct tm *tm)
3402{
David Carlier327298c2016-11-20 10:42:38 +00003403 /* tm_gmtoff, if present, ought to be zero'ed */
3404 memset(tm, 0, sizeof(*tm));
3405
Thierry Fournier93127942016-01-20 18:49:45 +01003406 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3407 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3408 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3409 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3410 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3411 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3412 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3413 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3414 tm->tm_year -= 1900;
3415 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3416 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3417 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3418 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3419 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003420 return 1;
3421}
3422
3423/* From RFC7231
3424 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3425 *
3426 * rfc850-date = day-name-l "," SP date2 SP time-of-day SP GMT
3427 * date2 = day "-" month "-" 2DIGIT
3428 * ; e.g., 02-Jun-82
3429 *
3430 * day = 2DIGIT
3431 */
3432int parse_rfc850_date(const char *date, int len, struct tm *tm)
3433{
3434 int year;
3435
David Carlier327298c2016-11-20 10:42:38 +00003436 /* tm_gmtoff, if present, ought to be zero'ed */
3437 memset(tm, 0, sizeof(*tm));
3438
Thierry Fournier93127942016-01-20 18:49:45 +01003439 RET0_UNLESS(parse_http_ldayname(&date, &len, tm)); /* Read the day name */
3440 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3441 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3442 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3443 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3444 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3445 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3446
3447 /* year = 2DIGIT
3448 *
3449 * Recipients of a timestamp value in rfc850-(*date) format, which uses a
3450 * two-digit year, MUST interpret a timestamp that appears to be more
3451 * than 50 years in the future as representing the most recent year in
3452 * the past that had the same last two digits.
3453 */
3454 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_year));
3455
3456 /* expect SP */
3457 if (!parse_expect_char(&date, &len, ' ')) {
3458 /* Maybe we have the date with 4 digits. */
3459 RET0_UNLESS(parse_2digit(&date, &len, &year));
3460 tm->tm_year = (tm->tm_year * 100 + year) - 1900;
3461 /* expect SP */
3462 RET0_UNLESS(parse_expect_char(&date, &len, ' '));
3463 } else {
3464 /* I fix 60 as pivot: >60: +1900, <60: +2000. Note that the
3465 * tm_year is the number of year since 1900, so for +1900, we
3466 * do nothing, and for +2000, we add 100.
3467 */
3468 if (tm->tm_year <= 60)
3469 tm->tm_year += 100;
3470 }
3471
3472 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3473 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3474 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3475 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003476
3477 return 1;
3478}
3479
3480/* From RFC7231
3481 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3482 *
3483 * asctime-date = day-name SP date3 SP time-of-day SP year
3484 * date3 = month SP ( 2DIGIT / ( SP 1DIGIT ))
3485 * ; e.g., Jun 2
3486 *
3487 * HTTP-date is case sensitive. A sender MUST NOT generate additional
3488 * whitespace in an HTTP-date beyond that specifically included as SP in
3489 * the grammar.
3490 */
3491int parse_asctime_date(const char *date, int len, struct tm *tm)
3492{
David Carlier327298c2016-11-20 10:42:38 +00003493 /* tm_gmtoff, if present, ought to be zero'ed */
3494 memset(tm, 0, sizeof(*tm));
3495
Thierry Fournier93127942016-01-20 18:49:45 +01003496 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3497 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3498 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* expect month */
3499 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3500
3501 /* expect SP and 1DIGIT or 2DIGIT */
3502 if (parse_expect_char(&date, &len, ' '))
3503 RET0_UNLESS(parse_digit(&date, &len, &tm->tm_mday));
3504 else
3505 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday));
3506
3507 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3508 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3509 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3510 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3511 tm->tm_year -= 1900;
3512 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003513 return 1;
3514}
3515
3516/* From RFC7231
3517 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3518 *
3519 * HTTP-date = IMF-fixdate / obs-date
3520 * obs-date = rfc850-date / asctime-date
3521 *
3522 * parses an HTTP date in the RFC format and is accepted
3523 * alternatives. <date> is the strinf containing the date,
3524 * len is the len of the string. <tm> is filled with the
3525 * parsed time. We must considers this time as GMT.
3526 */
3527int parse_http_date(const char *date, int len, struct tm *tm)
3528{
3529 if (parse_imf_date(date, len, tm))
3530 return 1;
3531
3532 if (parse_rfc850_date(date, len, tm))
3533 return 1;
3534
3535 if (parse_asctime_date(date, len, tm))
3536 return 1;
3537
3538 return 0;
3539}
3540
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003541/* Dynamically allocates a string of the proper length to hold the formatted
3542 * output. NULL is returned on error. The caller is responsible for freeing the
3543 * memory area using free(). The resulting string is returned in <out> if the
3544 * pointer is not NULL. A previous version of <out> might be used to build the
3545 * new string, and it will be freed before returning if it is not NULL, which
3546 * makes it possible to build complex strings from iterative calls without
3547 * having to care about freeing intermediate values, as in the example below :
3548 *
3549 * memprintf(&err, "invalid argument: '%s'", arg);
3550 * ...
3551 * memprintf(&err, "parser said : <%s>\n", *err);
3552 * ...
3553 * free(*err);
3554 *
3555 * This means that <err> must be initialized to NULL before first invocation.
3556 * The return value also holds the allocated string, which eases error checking
3557 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003558 * passed instead and it will be ignored. The returned message will then also
3559 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003560 *
3561 * It is also convenient to use it without any free except the last one :
3562 * err = NULL;
3563 * if (!fct1(err)) report(*err);
3564 * if (!fct2(err)) report(*err);
3565 * if (!fct3(err)) report(*err);
3566 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02003567 *
3568 * memprintf relies on memvprintf. This last version can be called from any
3569 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003570 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003571char *memvprintf(char **out, const char *format, va_list orig_args)
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003572{
3573 va_list args;
3574 char *ret = NULL;
3575 int allocated = 0;
3576 int needed = 0;
3577
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003578 if (!out)
3579 return NULL;
3580
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003581 do {
Willy Tarreaue0609f52019-03-29 19:13:23 +01003582 char buf1;
3583
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003584 /* vsnprintf() will return the required length even when the
3585 * target buffer is NULL. We do this in a loop just in case
3586 * intermediate evaluations get wrong.
3587 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003588 va_copy(args, orig_args);
Willy Tarreaue0609f52019-03-29 19:13:23 +01003589 needed = vsnprintf(ret ? ret : &buf1, allocated, format, args);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003590 va_end(args);
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003591 if (needed < allocated) {
3592 /* Note: on Solaris 8, the first iteration always
3593 * returns -1 if allocated is zero, so we force a
3594 * retry.
3595 */
3596 if (!allocated)
3597 needed = 0;
3598 else
3599 break;
3600 }
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003601
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003602 allocated = needed + 1;
Hubert Verstraete831962e2016-06-28 22:44:26 +02003603 ret = my_realloc2(ret, allocated);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003604 } while (ret);
3605
3606 if (needed < 0) {
3607 /* an error was encountered */
3608 free(ret);
3609 ret = NULL;
3610 }
3611
3612 if (out) {
3613 free(*out);
3614 *out = ret;
3615 }
3616
3617 return ret;
3618}
William Lallemand421f5b52012-02-06 18:15:57 +01003619
Christopher Faulet93a518f2017-10-24 11:25:33 +02003620char *memprintf(char **out, const char *format, ...)
3621{
3622 va_list args;
3623 char *ret = NULL;
3624
3625 va_start(args, format);
3626 ret = memvprintf(out, format, args);
3627 va_end(args);
3628
3629 return ret;
3630}
3631
Willy Tarreau21c705b2012-09-14 11:40:36 +02003632/* Used to add <level> spaces before each line of <out>, unless there is only one line.
3633 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02003634 * freed by the caller. It also supports being passed a NULL which results in the same
3635 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02003636 * Example of use :
3637 * parse(cmd, &err); (callee: memprintf(&err, ...))
3638 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
3639 * free(err);
3640 */
3641char *indent_msg(char **out, int level)
3642{
3643 char *ret, *in, *p;
3644 int needed = 0;
3645 int lf = 0;
3646 int lastlf = 0;
3647 int len;
3648
Willy Tarreau70eec382012-10-10 08:56:47 +02003649 if (!out || !*out)
3650 return NULL;
3651
Willy Tarreau21c705b2012-09-14 11:40:36 +02003652 in = *out - 1;
3653 while ((in = strchr(in + 1, '\n')) != NULL) {
3654 lastlf = in - *out;
3655 lf++;
3656 }
3657
3658 if (!lf) /* single line, no LF, return it as-is */
3659 return *out;
3660
3661 len = strlen(*out);
3662
3663 if (lf == 1 && lastlf == len - 1) {
3664 /* single line, LF at end, strip it and return as-is */
3665 (*out)[lastlf] = 0;
3666 return *out;
3667 }
3668
3669 /* OK now we have at least one LF, we need to process the whole string
3670 * as a multi-line string. What we'll do :
3671 * - prefix with an LF if there is none
3672 * - add <level> spaces before each line
3673 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
3674 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
3675 */
3676
3677 needed = 1 + level * (lf + 1) + len + 1;
3678 p = ret = malloc(needed);
3679 in = *out;
3680
3681 /* skip initial LFs */
3682 while (*in == '\n')
3683 in++;
3684
3685 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
3686 while (*in) {
3687 *p++ = '\n';
3688 memset(p, ' ', level);
3689 p += level;
3690 do {
3691 *p++ = *in++;
3692 } while (*in && *in != '\n');
3693 if (*in)
3694 in++;
3695 }
3696 *p = 0;
3697
3698 free(*out);
3699 *out = ret;
3700
3701 return ret;
3702}
3703
Willy Tarreau9d22e562019-03-29 18:49:09 +01003704/* removes environment variable <name> from the environment as found in
3705 * environ. This is only provided as an alternative for systems without
3706 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
3707 * The principle is to scan environ for each occurence of variable name
3708 * <name> and to replace the matching pointers with the last pointer of
3709 * the array (since variables are not ordered).
3710 * It always returns 0 (success).
3711 */
3712int my_unsetenv(const char *name)
3713{
3714 extern char **environ;
3715 char **p = environ;
3716 int vars;
3717 int next;
3718 int len;
3719
3720 len = strlen(name);
3721 for (vars = 0; p[vars]; vars++)
3722 ;
3723 next = 0;
3724 while (next < vars) {
3725 if (strncmp(p[next], name, len) != 0 || p[next][len] != '=') {
3726 next++;
3727 continue;
3728 }
3729 if (next < vars - 1)
3730 p[next] = p[vars - 1];
3731 p[--vars] = NULL;
3732 }
3733 return 0;
3734}
3735
Willy Tarreaudad36a32013-03-11 01:20:04 +01003736/* Convert occurrences of environment variables in the input string to their
3737 * corresponding value. A variable is identified as a series of alphanumeric
3738 * characters or underscores following a '$' sign. The <in> string must be
3739 * free()able. NULL returns NULL. The resulting string might be reallocated if
3740 * some expansion is made. Variable names may also be enclosed into braces if
3741 * needed (eg: to concatenate alphanum characters).
3742 */
3743char *env_expand(char *in)
3744{
3745 char *txt_beg;
3746 char *out;
3747 char *txt_end;
3748 char *var_beg;
3749 char *var_end;
3750 char *value;
3751 char *next;
3752 int out_len;
3753 int val_len;
3754
3755 if (!in)
3756 return in;
3757
3758 value = out = NULL;
3759 out_len = 0;
3760
3761 txt_beg = in;
3762 do {
3763 /* look for next '$' sign in <in> */
3764 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
3765
3766 if (!*txt_end && !out) /* end and no expansion performed */
3767 return in;
3768
3769 val_len = 0;
3770 next = txt_end;
3771 if (*txt_end == '$') {
3772 char save;
3773
3774 var_beg = txt_end + 1;
3775 if (*var_beg == '{')
3776 var_beg++;
3777
3778 var_end = var_beg;
3779 while (isalnum((int)(unsigned char)*var_end) || *var_end == '_') {
3780 var_end++;
3781 }
3782
3783 next = var_end;
3784 if (*var_end == '}' && (var_beg > txt_end + 1))
3785 next++;
3786
3787 /* get value of the variable name at this location */
3788 save = *var_end;
3789 *var_end = '\0';
3790 value = getenv(var_beg);
3791 *var_end = save;
3792 val_len = value ? strlen(value) : 0;
3793 }
3794
Hubert Verstraete831962e2016-06-28 22:44:26 +02003795 out = my_realloc2(out, out_len + (txt_end - txt_beg) + val_len + 1);
Willy Tarreaudad36a32013-03-11 01:20:04 +01003796 if (txt_end > txt_beg) {
3797 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
3798 out_len += txt_end - txt_beg;
3799 }
3800 if (val_len) {
3801 memcpy(out + out_len, value, val_len);
3802 out_len += val_len;
3803 }
3804 out[out_len] = 0;
3805 txt_beg = next;
3806 } while (*txt_beg);
3807
3808 /* here we know that <out> was allocated and that we don't need <in> anymore */
3809 free(in);
3810 return out;
3811}
3812
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02003813
3814/* same as strstr() but case-insensitive and with limit length */
3815const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2)
3816{
3817 char *pptr, *sptr, *start;
Willy Tarreauc8746532014-05-28 23:05:07 +02003818 unsigned int slen, plen;
3819 unsigned int tmp1, tmp2;
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02003820
3821 if (str1 == NULL || len_str1 == 0) // search pattern into an empty string => search is not found
3822 return NULL;
3823
3824 if (str2 == NULL || len_str2 == 0) // pattern is empty => every str1 match
3825 return str1;
3826
3827 if (len_str1 < len_str2) // pattern is longer than string => search is not found
3828 return NULL;
3829
3830 for (tmp1 = 0, start = (char *)str1, pptr = (char *)str2, slen = len_str1, plen = len_str2; slen >= plen; start++, slen--) {
3831 while (toupper(*start) != toupper(*str2)) {
3832 start++;
3833 slen--;
3834 tmp1++;
3835
3836 if (tmp1 >= len_str1)
3837 return NULL;
3838
3839 /* if pattern longer than string */
3840 if (slen < plen)
3841 return NULL;
3842 }
3843
3844 sptr = start;
3845 pptr = (char *)str2;
3846
3847 tmp2 = 0;
3848 while (toupper(*sptr) == toupper(*pptr)) {
3849 sptr++;
3850 pptr++;
3851 tmp2++;
3852
3853 if (*pptr == '\0' || tmp2 == len_str2) /* end of pattern found */
3854 return start;
3855 if (*sptr == '\0' || tmp2 == len_str1) /* end of string found and the pattern is not fully found */
3856 return NULL;
3857 }
3858 }
3859 return NULL;
3860}
3861
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003862/* This function read the next valid utf8 char.
3863 * <s> is the byte srray to be decode, <len> is its length.
3864 * The function returns decoded char encoded like this:
3865 * The 4 msb are the return code (UTF8_CODE_*), the 4 lsb
3866 * are the length read. The decoded character is stored in <c>.
3867 */
3868unsigned char utf8_next(const char *s, int len, unsigned int *c)
3869{
3870 const unsigned char *p = (unsigned char *)s;
3871 int dec;
3872 unsigned char code = UTF8_CODE_OK;
3873
3874 if (len < 1)
3875 return UTF8_CODE_OK;
3876
3877 /* Check the type of UTF8 sequence
3878 *
3879 * 0... .... 0x00 <= x <= 0x7f : 1 byte: ascii char
3880 * 10.. .... 0x80 <= x <= 0xbf : invalid sequence
3881 * 110. .... 0xc0 <= x <= 0xdf : 2 bytes
3882 * 1110 .... 0xe0 <= x <= 0xef : 3 bytes
3883 * 1111 0... 0xf0 <= x <= 0xf7 : 4 bytes
3884 * 1111 10.. 0xf8 <= x <= 0xfb : 5 bytes
3885 * 1111 110. 0xfc <= x <= 0xfd : 6 bytes
3886 * 1111 111. 0xfe <= x <= 0xff : invalid sequence
3887 */
3888 switch (*p) {
3889 case 0x00 ... 0x7f:
3890 *c = *p;
3891 return UTF8_CODE_OK | 1;
3892
3893 case 0x80 ... 0xbf:
3894 *c = *p;
3895 return UTF8_CODE_BADSEQ | 1;
3896
3897 case 0xc0 ... 0xdf:
3898 if (len < 2) {
3899 *c = *p;
3900 return UTF8_CODE_BADSEQ | 1;
3901 }
3902 *c = *p & 0x1f;
3903 dec = 1;
3904 break;
3905
3906 case 0xe0 ... 0xef:
3907 if (len < 3) {
3908 *c = *p;
3909 return UTF8_CODE_BADSEQ | 1;
3910 }
3911 *c = *p & 0x0f;
3912 dec = 2;
3913 break;
3914
3915 case 0xf0 ... 0xf7:
3916 if (len < 4) {
3917 *c = *p;
3918 return UTF8_CODE_BADSEQ | 1;
3919 }
3920 *c = *p & 0x07;
3921 dec = 3;
3922 break;
3923
3924 case 0xf8 ... 0xfb:
3925 if (len < 5) {
3926 *c = *p;
3927 return UTF8_CODE_BADSEQ | 1;
3928 }
3929 *c = *p & 0x03;
3930 dec = 4;
3931 break;
3932
3933 case 0xfc ... 0xfd:
3934 if (len < 6) {
3935 *c = *p;
3936 return UTF8_CODE_BADSEQ | 1;
3937 }
3938 *c = *p & 0x01;
3939 dec = 5;
3940 break;
3941
3942 case 0xfe ... 0xff:
3943 default:
3944 *c = *p;
3945 return UTF8_CODE_BADSEQ | 1;
3946 }
3947
3948 p++;
3949
3950 while (dec > 0) {
3951
3952 /* need 0x10 for the 2 first bits */
3953 if ( ( *p & 0xc0 ) != 0x80 )
3954 return UTF8_CODE_BADSEQ | ((p-(unsigned char *)s)&0xffff);
3955
3956 /* add data at char */
3957 *c = ( *c << 6 ) | ( *p & 0x3f );
3958
3959 dec--;
3960 p++;
3961 }
3962
3963 /* Check ovelong encoding.
3964 * 1 byte : 5 + 6 : 11 : 0x80 ... 0x7ff
3965 * 2 bytes : 4 + 6 + 6 : 16 : 0x800 ... 0xffff
3966 * 3 bytes : 3 + 6 + 6 + 6 : 21 : 0x10000 ... 0x1fffff
3967 */
Thierry FOURNIER9e7ec082015-03-12 19:32:38 +01003968 if (( *c <= 0x7f && (p-(unsigned char *)s) > 1) ||
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02003969 (*c >= 0x80 && *c <= 0x7ff && (p-(unsigned char *)s) > 2) ||
3970 (*c >= 0x800 && *c <= 0xffff && (p-(unsigned char *)s) > 3) ||
3971 (*c >= 0x10000 && *c <= 0x1fffff && (p-(unsigned char *)s) > 4))
3972 code |= UTF8_CODE_OVERLONG;
3973
3974 /* Check invalid UTF8 range. */
3975 if ((*c >= 0xd800 && *c <= 0xdfff) ||
3976 (*c >= 0xfffe && *c <= 0xffff))
3977 code |= UTF8_CODE_INVRANGE;
3978
3979 return code | ((p-(unsigned char *)s)&0x0f);
3980}
3981
Maxime de Roucydc887852016-05-13 23:52:54 +02003982/* append a copy of string <str> (in a wordlist) at the end of the list <li>
3983 * On failure : return 0 and <err> filled with an error message.
3984 * The caller is responsible for freeing the <err> and <str> copy
3985 * memory area using free()
3986 */
3987int list_append_word(struct list *li, const char *str, char **err)
3988{
3989 struct wordlist *wl;
3990
3991 wl = calloc(1, sizeof(*wl));
3992 if (!wl) {
3993 memprintf(err, "out of memory");
3994 goto fail_wl;
3995 }
3996
3997 wl->s = strdup(str);
3998 if (!wl->s) {
3999 memprintf(err, "out of memory");
4000 goto fail_wl_s;
4001 }
4002
4003 LIST_ADDQ(li, &wl->list);
4004
4005 return 1;
4006
4007fail_wl_s:
4008 free(wl->s);
4009fail_wl:
4010 free(wl);
4011 return 0;
4012}
4013
Willy Tarreau37101052019-05-20 16:48:20 +02004014/* indicates if a memory location may safely be read or not. The trick consists
4015 * in performing a harmless syscall using this location as an input and letting
4016 * the operating system report whether it's OK or not. For this we have the
4017 * stat() syscall, which will return EFAULT when the memory location supposed
4018 * to contain the file name is not readable. If it is readable it will then
4019 * either return 0 if the area contains an existing file name, or -1 with
4020 * another code. This must not be abused, and some audit systems might detect
4021 * this as abnormal activity. It's used only for unsafe dumps.
4022 */
4023int may_access(const void *ptr)
4024{
4025 struct stat buf;
4026
4027 if (stat(ptr, &buf) == 0)
4028 return 1;
4029 if (errno == EFAULT)
4030 return 0;
4031 return 1;
4032}
4033
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004034/* print a string of text buffer to <out>. The format is :
4035 * Non-printable chars \t, \n, \r and \e are * encoded in C format.
4036 * Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
4037 * Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
4038 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004039int dump_text(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004040{
4041 unsigned char c;
4042 int ptr = 0;
4043
4044 while (buf[ptr] && ptr < bsize) {
4045 c = buf[ptr];
4046 if (isprint(c) && isascii(c) && c != '\\' && c != ' ' && c != '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004047 if (out->data > out->size - 1)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004048 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004049 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004050 }
4051 else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\' || c == ' ' || c == '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004052 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004053 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004054 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004055 switch (c) {
4056 case ' ': c = ' '; break;
4057 case '\t': c = 't'; break;
4058 case '\n': c = 'n'; break;
4059 case '\r': c = 'r'; break;
4060 case '\e': c = 'e'; break;
4061 case '\\': c = '\\'; break;
4062 case '=': c = '='; break;
4063 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004064 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004065 }
4066 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004067 if (out->data > out->size - 4)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004068 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004069 out->area[out->data++] = '\\';
4070 out->area[out->data++] = 'x';
4071 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4072 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004073 }
4074 ptr++;
4075 }
4076
4077 return ptr;
4078}
4079
4080/* print a buffer in hexa.
4081 * Print stopped if <bsize> is reached, or if no more place in the chunk.
4082 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004083int dump_binary(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004084{
4085 unsigned char c;
4086 int ptr = 0;
4087
4088 while (ptr < bsize) {
4089 c = buf[ptr];
4090
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004091 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004092 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004093 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4094 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004095
4096 ptr++;
4097 }
4098 return ptr;
4099}
4100
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004101/* Appends into buffer <out> a hex dump of memory area <buf> for <len> bytes,
4102 * prepending each line with prefix <pfx>. The output is *not* initialized.
4103 * The output will not wrap pas the buffer's end so it is more optimal if the
4104 * caller makes sure the buffer is aligned first. A trailing zero will always
4105 * be appended (and not counted) if there is room for it. The caller must make
Willy Tarreau37101052019-05-20 16:48:20 +02004106 * sure that the area is dumpable first. If <unsafe> is non-null, the memory
4107 * locations are checked first for being readable.
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004108 */
Willy Tarreau37101052019-05-20 16:48:20 +02004109void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe)
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004110{
4111 const unsigned char *d = buf;
4112 int i, j, start;
4113
4114 d = (const unsigned char *)(((unsigned long)buf) & -16);
4115 start = ((unsigned long)buf) & 15;
4116
4117 for (i = 0; i < start + len; i += 16) {
4118 chunk_appendf(out, (sizeof(void *) == 4) ? "%s%8p: " : "%s%16p: ", pfx, d + i);
4119
Willy Tarreau37101052019-05-20 16:48:20 +02004120 // 0: unchecked, 1: checked safe, 2: danger
4121 unsafe = !!unsafe;
4122 if (unsafe && !may_access(d + i))
4123 unsafe = 2;
4124
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004125 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004126 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004127 chunk_strcat(out, "'' ");
Willy Tarreau37101052019-05-20 16:48:20 +02004128 else if (unsafe > 1)
4129 chunk_strcat(out, "** ");
4130 else
4131 chunk_appendf(out, "%02x ", d[i + j]);
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004132
4133 if (j == 7)
4134 chunk_strcat(out, "- ");
4135 }
4136 chunk_strcat(out, " ");
4137 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004138 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004139 chunk_strcat(out, "'");
Willy Tarreau37101052019-05-20 16:48:20 +02004140 else if (unsafe > 1)
4141 chunk_strcat(out, "*");
4142 else if (isprint(d[i + j]))
4143 chunk_appendf(out, "%c", d[i + j]);
4144 else
4145 chunk_strcat(out, ".");
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004146 }
4147 chunk_strcat(out, "\n");
4148 }
4149}
4150
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004151/* print a line of text buffer (limited to 70 bytes) to <out>. The format is :
4152 * <2 spaces> <offset=5 digits> <space or plus> <space> <70 chars max> <\n>
4153 * which is 60 chars per line. Non-printable chars \t, \n, \r and \e are
4154 * encoded in C format. Other non-printable chars are encoded "\xHH". Original
4155 * lines are respected within the limit of 70 output chars. Lines that are
4156 * continuation of a previous truncated line begin with "+" instead of " "
4157 * after the offset. The new pointer is returned.
4158 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004159int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004160 int *line, int ptr)
4161{
4162 int end;
4163 unsigned char c;
4164
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004165 end = out->data + 80;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004166 if (end > out->size)
4167 return ptr;
4168
4169 chunk_appendf(out, " %05d%c ", ptr, (ptr == *line) ? ' ' : '+');
4170
4171 while (ptr < len && ptr < bsize) {
4172 c = buf[ptr];
4173 if (isprint(c) && isascii(c) && c != '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004174 if (out->data > end - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004175 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004176 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004177 } else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004178 if (out->data > end - 3)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004179 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004180 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004181 switch (c) {
4182 case '\t': c = 't'; break;
4183 case '\n': c = 'n'; break;
4184 case '\r': c = 'r'; break;
4185 case '\e': c = 'e'; break;
4186 case '\\': c = '\\'; break;
4187 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004188 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004189 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004190 if (out->data > end - 5)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004191 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004192 out->area[out->data++] = '\\';
4193 out->area[out->data++] = 'x';
4194 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4195 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004196 }
4197 if (buf[ptr++] == '\n') {
4198 /* we had a line break, let's return now */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004199 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004200 *line = ptr;
4201 return ptr;
4202 }
4203 }
4204 /* we have an incomplete line, we return it as-is */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004205 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004206 return ptr;
4207}
4208
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004209/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02004210 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
4211 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004212 */
Willy Tarreaued936c52017-04-27 18:03:20 +02004213void debug_hexdump(FILE *out, const char *pfx, const char *buf,
4214 unsigned int baseaddr, int len)
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004215{
Willy Tarreau73459792017-04-11 07:58:08 +02004216 unsigned int i;
4217 int b, j;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004218
4219 for (i = 0; i < (len + (baseaddr & 15)); i += 16) {
4220 b = i - (baseaddr & 15);
Willy Tarreaued936c52017-04-27 18:03:20 +02004221 fprintf(out, "%s%08x: ", pfx ? pfx : "", i + (baseaddr & ~15));
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004222 for (j = 0; j < 8; j++) {
4223 if (b + j >= 0 && b + j < len)
4224 fprintf(out, "%02x ", (unsigned char)buf[b + j]);
4225 else
4226 fprintf(out, " ");
4227 }
4228
4229 if (b + j >= 0 && b + j < len)
4230 fputc('-', out);
4231 else
4232 fputc(' ', out);
4233
4234 for (j = 8; j < 16; j++) {
4235 if (b + j >= 0 && b + j < len)
4236 fprintf(out, " %02x", (unsigned char)buf[b + j]);
4237 else
4238 fprintf(out, " ");
4239 }
4240
4241 fprintf(out, " ");
4242 for (j = 0; j < 16; j++) {
4243 if (b + j >= 0 && b + j < len) {
4244 if (isprint((unsigned char)buf[b + j]))
4245 fputc((unsigned char)buf[b + j], out);
4246 else
4247 fputc('.', out);
4248 }
4249 else
4250 fputc(' ', out);
4251 }
4252 fputc('\n', out);
4253 }
4254}
4255
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004256/*
4257 * Allocate an array of unsigned int with <nums> as address from <str> string
4258 * made of integer sepereated by dot characters.
4259 *
4260 * First, initializes the value with <sz> as address to 0 and initializes the
4261 * array with <nums> as address to NULL. Then allocates the array with <nums> as
4262 * address updating <sz> pointed value to the size of this array.
4263 *
4264 * Returns 1 if succeeded, 0 if not.
4265 */
4266int parse_dotted_uints(const char *str, unsigned int **nums, size_t *sz)
4267{
4268 unsigned int *n;
4269 const char *s, *end;
4270
4271 s = str;
4272 *sz = 0;
4273 end = str + strlen(str);
4274 *nums = n = NULL;
4275
4276 while (1) {
4277 unsigned int r;
4278
4279 if (s >= end)
4280 break;
4281
4282 r = read_uint(&s, end);
4283 /* Expected characters after having read an uint: '\0' or '.',
4284 * if '.', must not be terminal.
4285 */
4286 if (*s != '\0'&& (*s++ != '.' || s == end))
4287 return 0;
4288
Frédéric Lécaille12a71842019-02-26 18:19:48 +01004289 n = my_realloc2(n, (*sz + 1) * sizeof *n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004290 if (!n)
4291 return 0;
4292
4293 n[(*sz)++] = r;
4294 }
4295 *nums = n;
4296
4297 return 1;
4298}
4299
Willy Tarreau12963822017-10-24 10:54:08 +02004300/* do nothing, just a placeholder for debugging calls, the real one is in trace.c */
Willy Tarreau42a66212019-06-04 16:02:26 +02004301#ifndef USE_OBSOLETE_LINKER
Willy Tarreau12963822017-10-24 10:54:08 +02004302__attribute__((weak,format(printf, 1, 2)))
Willy Tarreau42a66212019-06-04 16:02:26 +02004303#endif
Willy Tarreau12963822017-10-24 10:54:08 +02004304void trace(char *msg, ...)
4305{
4306}
4307
Willy Tarreaubaaee002006-06-26 02:48:02 +02004308/*
4309 * Local variables:
4310 * c-indent-level: 8
4311 * c-basic-offset: 8
4312 * End:
4313 */