blob: 0869de406fe41e0daeaa5fb7897bf12f744099b4 [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
Baruch Siache1651b22020-07-24 07:52:20 +030013#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +010014#define _GNU_SOURCE
15#include <dlfcn.h>
16#include <link.h>
17#endif
18
Willy Tarreau2e74c3f2007-12-02 18:45:09 +010019#include <ctype.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020020#include <errno.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020021#include <netdb.h>
Willy Tarreau9a7bea52012-04-27 11:16:50 +020022#include <stdarg.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020023#include <stdio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020024#include <stdlib.h>
25#include <string.h>
Thierry Fournier93127942016-01-20 18:49:45 +010026#include <time.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020027#include <unistd.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010028#include <sys/socket.h>
Willy Tarreau37101052019-05-20 16:48:20 +020029#include <sys/stat.h>
30#include <sys/types.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010031#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032#include <netinet/in.h>
33#include <arpa/inet.h>
34
Willy Tarreau30053062020-08-20 16:39:14 +020035#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
36#include <sys/auxv.h>
37#endif
38
Willy Tarreau48fbcae2020-06-03 18:09:46 +020039#include <import/eb32sctree.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020040#include <import/eb32tree.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020041
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020042#include <haproxy/api.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020043#include <haproxy/chunk.h>
Willy Tarreau7c18b542020-06-11 09:23:02 +020044#include <haproxy/dgram.h>
Willy Tarreaueb92deb2020-06-04 10:53:16 +020045#include <haproxy/dns.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020046#include <haproxy/global.h>
Willy Tarreau86416052020-06-04 09:20:54 +020047#include <haproxy/hlua.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020048#include <haproxy/listener.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020049#include <haproxy/namespace.h>
Willy Tarreau5fc93282020-09-16 18:25:03 +020050#include <haproxy/protocol.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020051#include <haproxy/ssl_sock.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020052#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020053#include <haproxy/task.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020054#include <haproxy/tools.h>
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +010055
Thierry Fournier93127942016-01-20 18:49:45 +010056/* This macro returns false if the test __x is false. Many
57 * of the following parsing function must be abort the processing
58 * if it returns 0, so this macro is useful for writing light code.
59 */
60#define RET0_UNLESS(__x) do { if (!(__x)) return 0; } while (0)
61
Willy Tarreau56adcf22012-12-23 18:00:29 +010062/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020063 * 2^64-1 = 18446744073709551615 or
64 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020065 *
66 * The HTML version needs room for adding the 25 characters
67 * '<span class="rls"></span>' around digits at positions 3N+1 in order
68 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020069 */
Christopher Faulet99bca652017-11-14 16:47:26 +010070THREAD_LOCAL char itoa_str[NB_ITOA_STR][171];
71THREAD_LOCAL int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020072
Willy Tarreau588297f2014-06-16 15:16:40 +020073/* sometimes we'll need to quote strings (eg: in stats), and we don't expect
74 * to quote strings larger than a max configuration line.
75 */
Christopher Faulet99bca652017-11-14 16:47:26 +010076THREAD_LOCAL char quoted_str[NB_QSTR][QSTR_SIZE + 1];
77THREAD_LOCAL int quoted_idx = 0;
Willy Tarreau588297f2014-06-16 15:16:40 +020078
Willy Tarreaubaaee002006-06-26 02:48:02 +020079/*
William Lallemande7340ec2012-01-24 11:15:39 +010080 * unsigned long long ASCII representation
81 *
82 * return the last char '\0' or NULL if no enough
83 * space in dst
84 */
85char *ulltoa(unsigned long long n, char *dst, size_t size)
86{
87 int i = 0;
88 char *res;
89
90 switch(n) {
91 case 1ULL ... 9ULL:
92 i = 0;
93 break;
94
95 case 10ULL ... 99ULL:
96 i = 1;
97 break;
98
99 case 100ULL ... 999ULL:
100 i = 2;
101 break;
102
103 case 1000ULL ... 9999ULL:
104 i = 3;
105 break;
106
107 case 10000ULL ... 99999ULL:
108 i = 4;
109 break;
110
111 case 100000ULL ... 999999ULL:
112 i = 5;
113 break;
114
115 case 1000000ULL ... 9999999ULL:
116 i = 6;
117 break;
118
119 case 10000000ULL ... 99999999ULL:
120 i = 7;
121 break;
122
123 case 100000000ULL ... 999999999ULL:
124 i = 8;
125 break;
126
127 case 1000000000ULL ... 9999999999ULL:
128 i = 9;
129 break;
130
131 case 10000000000ULL ... 99999999999ULL:
132 i = 10;
133 break;
134
135 case 100000000000ULL ... 999999999999ULL:
136 i = 11;
137 break;
138
139 case 1000000000000ULL ... 9999999999999ULL:
140 i = 12;
141 break;
142
143 case 10000000000000ULL ... 99999999999999ULL:
144 i = 13;
145 break;
146
147 case 100000000000000ULL ... 999999999999999ULL:
148 i = 14;
149 break;
150
151 case 1000000000000000ULL ... 9999999999999999ULL:
152 i = 15;
153 break;
154
155 case 10000000000000000ULL ... 99999999999999999ULL:
156 i = 16;
157 break;
158
159 case 100000000000000000ULL ... 999999999999999999ULL:
160 i = 17;
161 break;
162
163 case 1000000000000000000ULL ... 9999999999999999999ULL:
164 i = 18;
165 break;
166
167 case 10000000000000000000ULL ... ULLONG_MAX:
168 i = 19;
169 break;
170 }
171 if (i + 2 > size) // (i + 1) + '\0'
172 return NULL; // too long
173 res = dst + i + 1;
174 *res = '\0';
175 for (; i >= 0; i--) {
176 dst[i] = n % 10ULL + '0';
177 n /= 10ULL;
178 }
179 return res;
180}
181
182/*
183 * unsigned long ASCII representation
184 *
185 * return the last char '\0' or NULL if no enough
186 * space in dst
187 */
188char *ultoa_o(unsigned long n, char *dst, size_t size)
189{
190 int i = 0;
191 char *res;
192
193 switch (n) {
194 case 0U ... 9UL:
195 i = 0;
196 break;
197
198 case 10U ... 99UL:
199 i = 1;
200 break;
201
202 case 100U ... 999UL:
203 i = 2;
204 break;
205
206 case 1000U ... 9999UL:
207 i = 3;
208 break;
209
210 case 10000U ... 99999UL:
211 i = 4;
212 break;
213
214 case 100000U ... 999999UL:
215 i = 5;
216 break;
217
218 case 1000000U ... 9999999UL:
219 i = 6;
220 break;
221
222 case 10000000U ... 99999999UL:
223 i = 7;
224 break;
225
226 case 100000000U ... 999999999UL:
227 i = 8;
228 break;
229#if __WORDSIZE == 32
230
231 case 1000000000ULL ... ULONG_MAX:
232 i = 9;
233 break;
234
235#elif __WORDSIZE == 64
236
237 case 1000000000ULL ... 9999999999UL:
238 i = 9;
239 break;
240
241 case 10000000000ULL ... 99999999999UL:
242 i = 10;
243 break;
244
245 case 100000000000ULL ... 999999999999UL:
246 i = 11;
247 break;
248
249 case 1000000000000ULL ... 9999999999999UL:
250 i = 12;
251 break;
252
253 case 10000000000000ULL ... 99999999999999UL:
254 i = 13;
255 break;
256
257 case 100000000000000ULL ... 999999999999999UL:
258 i = 14;
259 break;
260
261 case 1000000000000000ULL ... 9999999999999999UL:
262 i = 15;
263 break;
264
265 case 10000000000000000ULL ... 99999999999999999UL:
266 i = 16;
267 break;
268
269 case 100000000000000000ULL ... 999999999999999999UL:
270 i = 17;
271 break;
272
273 case 1000000000000000000ULL ... 9999999999999999999UL:
274 i = 18;
275 break;
276
277 case 10000000000000000000ULL ... ULONG_MAX:
278 i = 19;
279 break;
280
281#endif
282 }
283 if (i + 2 > size) // (i + 1) + '\0'
284 return NULL; // too long
285 res = dst + i + 1;
286 *res = '\0';
287 for (; i >= 0; i--) {
288 dst[i] = n % 10U + '0';
289 n /= 10U;
290 }
291 return res;
292}
293
294/*
295 * signed long ASCII representation
296 *
297 * return the last char '\0' or NULL if no enough
298 * space in dst
299 */
300char *ltoa_o(long int n, char *dst, size_t size)
301{
302 char *pos = dst;
303
304 if (n < 0) {
305 if (size < 3)
306 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
307 *pos = '-';
308 pos++;
309 dst = ultoa_o(-n, pos, size - 1);
310 } else {
311 dst = ultoa_o(n, dst, size);
312 }
313 return dst;
314}
315
316/*
317 * signed long long ASCII representation
318 *
319 * return the last char '\0' or NULL if no enough
320 * space in dst
321 */
322char *lltoa(long long n, char *dst, size_t size)
323{
324 char *pos = dst;
325
326 if (n < 0) {
327 if (size < 3)
328 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
329 *pos = '-';
330 pos++;
331 dst = ulltoa(-n, pos, size - 1);
332 } else {
333 dst = ulltoa(n, dst, size);
334 }
335 return dst;
336}
337
338/*
339 * write a ascii representation of a unsigned into dst,
340 * return a pointer to the last character
341 * Pad the ascii representation with '0', using size.
342 */
343char *utoa_pad(unsigned int n, char *dst, size_t size)
344{
345 int i = 0;
346 char *ret;
347
348 switch(n) {
349 case 0U ... 9U:
350 i = 0;
351 break;
352
353 case 10U ... 99U:
354 i = 1;
355 break;
356
357 case 100U ... 999U:
358 i = 2;
359 break;
360
361 case 1000U ... 9999U:
362 i = 3;
363 break;
364
365 case 10000U ... 99999U:
366 i = 4;
367 break;
368
369 case 100000U ... 999999U:
370 i = 5;
371 break;
372
373 case 1000000U ... 9999999U:
374 i = 6;
375 break;
376
377 case 10000000U ... 99999999U:
378 i = 7;
379 break;
380
381 case 100000000U ... 999999999U:
382 i = 8;
383 break;
384
385 case 1000000000U ... 4294967295U:
386 i = 9;
387 break;
388 }
389 if (i + 2 > size) // (i + 1) + '\0'
390 return NULL; // too long
391 if (i < size)
392 i = size - 2; // padding - '\0'
393
394 ret = dst + i + 1;
395 *ret = '\0';
396 for (; i >= 0; i--) {
397 dst[i] = n % 10U + '0';
398 n /= 10U;
399 }
400 return ret;
401}
402
403/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200404 * copies at most <size-1> chars from <src> to <dst>. Last char is always
405 * set to 0, unless <size> is 0. The number of chars copied is returned
406 * (excluding the terminating zero).
407 * This code has been optimized for size and speed : on x86, it's 45 bytes
408 * long, uses only registers, and consumes only 4 cycles per char.
409 */
410int strlcpy2(char *dst, const char *src, int size)
411{
412 char *orig = dst;
413 if (size) {
414 while (--size && (*dst = *src)) {
415 src++; dst++;
416 }
417 *dst = 0;
418 }
419 return dst - orig;
420}
421
422/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200423 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200424 * the ascii representation for number 'n' in decimal.
425 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100426char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200427{
428 char *pos;
429
Willy Tarreau72d759c2007-10-25 12:14:10 +0200430 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200431 *pos-- = '\0';
432
433 do {
434 *pos-- = '0' + n % 10;
435 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200436 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200437 return pos + 1;
438}
439
Willy Tarreau91092e52007-10-25 16:58:42 +0200440/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200441 * This function simply returns a locally allocated string containing
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200442 * the ascii representation for number 'n' in decimal.
443 */
444char *lltoa_r(long long int in, char *buffer, int size)
445{
446 char *pos;
447 int neg = 0;
448 unsigned long long int n;
449
450 pos = buffer + size - 1;
451 *pos-- = '\0';
452
453 if (in < 0) {
454 neg = 1;
455 n = -in;
456 }
457 else
458 n = in;
459
460 do {
461 *pos-- = '0' + n % 10;
462 n /= 10;
463 } while (n && pos >= buffer);
464 if (neg && pos > buffer)
465 *pos-- = '-';
466 return pos + 1;
467}
468
469/*
470 * This function simply returns a locally allocated string containing
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200471 * the ascii representation for signed number 'n' in decimal.
472 */
473char *sltoa_r(long n, char *buffer, int size)
474{
475 char *pos;
476
477 if (n >= 0)
478 return ultoa_r(n, buffer, size);
479
480 pos = ultoa_r(-n, buffer + 1, size - 1) - 1;
481 *pos = '-';
482 return pos;
483}
484
485/*
486 * This function simply returns a locally allocated string containing
Willy Tarreaue7239b52009-03-29 13:41:58 +0200487 * the ascii representation for number 'n' in decimal, formatted for
488 * HTML output with tags to create visual grouping by 3 digits. The
489 * output needs to support at least 171 characters.
490 */
491const char *ulltoh_r(unsigned long long n, char *buffer, int size)
492{
493 char *start;
494 int digit = 0;
495
496 start = buffer + size;
497 *--start = '\0';
498
499 do {
500 if (digit == 3 && start >= buffer + 7)
501 memcpy(start -= 7, "</span>", 7);
502
503 if (start >= buffer + 1) {
504 *--start = '0' + n % 10;
505 n /= 10;
506 }
507
508 if (digit == 3 && start >= buffer + 18)
509 memcpy(start -= 18, "<span class=\"rls\">", 18);
510
511 if (digit++ == 3)
512 digit = 1;
513 } while (n && start > buffer);
514 return start;
515}
516
517/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200518 * This function simply returns a locally allocated string containing the ascii
519 * representation for number 'n' in decimal, unless n is 0 in which case it
520 * returns the alternate string (or an empty string if the alternate string is
521 * NULL). It use is intended for limits reported in reports, where it's
522 * desirable not to display anything if there is no limit. Warning! it shares
523 * the same vector as ultoa_r().
524 */
525const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
526{
527 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
528}
529
Willy Tarreau588297f2014-06-16 15:16:40 +0200530/* returns a locally allocated string containing the quoted encoding of the
531 * input string. The output may be truncated to QSTR_SIZE chars, but it is
532 * guaranteed that the string will always be properly terminated. Quotes are
533 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
534 * always be at least 4 chars.
535 */
536const char *qstr(const char *str)
537{
538 char *ret = quoted_str[quoted_idx];
539 char *p, *end;
540
541 if (++quoted_idx >= NB_QSTR)
542 quoted_idx = 0;
543
544 p = ret;
545 end = ret + QSTR_SIZE;
546
547 *p++ = '"';
548
549 /* always keep 3 chars to support passing "" and the ending " */
550 while (*str && p < end - 3) {
551 if (*str == '"') {
552 *p++ = '"';
553 *p++ = '"';
554 }
555 else
556 *p++ = *str;
557 str++;
558 }
559 *p++ = '"';
560 return ret;
561}
562
Robert Tsai81ae1952007-12-05 10:47:29 +0100563/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200564 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
565 *
566 * It looks like this one would be a good candidate for inlining, but this is
567 * not interesting because it around 35 bytes long and often called multiple
568 * times within the same function.
569 */
570int ishex(char s)
571{
572 s -= '0';
573 if ((unsigned char)s <= 9)
574 return 1;
575 s -= 'A' - '0';
576 if ((unsigned char)s <= 5)
577 return 1;
578 s -= 'a' - 'A';
579 if ((unsigned char)s <= 5)
580 return 1;
581 return 0;
582}
583
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100584/* rounds <i> down to the closest value having max 2 digits */
585unsigned int round_2dig(unsigned int i)
586{
587 unsigned int mul = 1;
588
589 while (i >= 100) {
590 i /= 10;
591 mul *= 10;
592 }
593 return i * mul;
594}
595
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100596/*
597 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
598 * invalid character is found, a pointer to it is returned. If everything is
599 * fine, NULL is returned.
600 */
601const char *invalid_char(const char *name)
602{
603 if (!*name)
604 return name;
605
606 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100607 if (!isalnum((unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100608 *name != '_' && *name != '-')
609 return name;
610 name++;
611 }
612 return NULL;
613}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200614
615/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200616 * Checks <name> for invalid characters. Valid chars are [_.-] and those
617 * accepted by <f> function.
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200618 * If an invalid character is found, a pointer to it is returned.
619 * If everything is fine, NULL is returned.
620 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200621static inline const char *__invalid_char(const char *name, int (*f)(int)) {
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200622
623 if (!*name)
624 return name;
625
626 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100627 if (!f((unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200628 *name != '_' && *name != '-')
629 return name;
630
631 name++;
632 }
633
634 return NULL;
635}
636
637/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200638 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
639 * If an invalid character is found, a pointer to it is returned.
640 * If everything is fine, NULL is returned.
641 */
642const char *invalid_domainchar(const char *name) {
643 return __invalid_char(name, isalnum);
644}
645
646/*
647 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
648 * If an invalid character is found, a pointer to it is returned.
649 * If everything is fine, NULL is returned.
650 */
651const char *invalid_prefix_char(const char *name) {
Thierry Fournierf7b7c3e2018-03-26 11:54:39 +0200652 return __invalid_char(name, isalnum);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200653}
654
655/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100656 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100657 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
658 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
659 * the function tries to guess the address family from the syntax. If the
660 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100661 * string is assumed to contain only an address, no port. The address can be a
662 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
663 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
664 * The return address will only have the address family and the address set,
665 * all other fields remain zero. The string is not supposed to be modified.
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100666 * The IPv6 '::' address is IN6ADDR_ANY. If <resolve> is non-zero, the hostname
667 * is resolved, otherwise only IP addresses are resolved, and anything else
Willy Tarreauecde7df2016-11-02 22:37:03 +0100668 * returns NULL. If the address contains a port, this one is preserved.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200669 */
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100670struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200671{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100672 struct hostent *he;
mildisff5d5102015-10-26 18:50:08 +0100673 /* max IPv6 length, including brackets and terminating NULL */
674 char tmpip[48];
Willy Tarreauecde7df2016-11-02 22:37:03 +0100675 int port = get_host_port(sa);
mildisff5d5102015-10-26 18:50:08 +0100676
677 /* check IPv6 with square brackets */
678 if (str[0] == '[') {
679 size_t iplength = strlen(str);
680
681 if (iplength < 4) {
682 /* minimal size is 4 when using brackets "[::]" */
683 goto fail;
684 }
685 else if (iplength >= sizeof(tmpip)) {
686 /* IPv6 literal can not be larger than tmpip */
687 goto fail;
688 }
689 else {
690 if (str[iplength - 1] != ']') {
691 /* if address started with bracket, it should end with bracket */
692 goto fail;
693 }
694 else {
695 memcpy(tmpip, str + 1, iplength - 2);
696 tmpip[iplength - 2] = '\0';
697 str = tmpip;
698 }
699 }
700 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100701
Willy Tarreaufab5a432011-03-04 15:31:53 +0100702 /* Any IPv6 address */
703 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100704 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
705 sa->ss_family = AF_INET6;
706 else if (sa->ss_family != AF_INET6)
707 goto fail;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100708 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100709 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100710 }
711
Willy Tarreau24709282013-03-10 21:32:12 +0100712 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100713 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100714 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
715 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100716 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100717 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100718 }
719
720 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100721 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
722 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100723 sa->ss_family = AF_INET6;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100724 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100725 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100726 }
727
728 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100729 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
730 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100731 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100732 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100733 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100734 }
735
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100736 if (!resolve)
737 return NULL;
738
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200739 if (!dns_hostname_validation(str, NULL))
740 return NULL;
741
David du Colombierd5f43282011-03-17 10:40:16 +0100742#ifdef USE_GETADDRINFO
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200743 if (global.tune.options & GTUNE_USE_GAI) {
David du Colombierd5f43282011-03-17 10:40:16 +0100744 struct addrinfo hints, *result;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100745 int success = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100746
747 memset(&result, 0, sizeof(result));
748 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100749 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100750 hints.ai_socktype = SOCK_DGRAM;
Dmitry Sivachenkoeab7f392015-10-02 01:01:58 +0200751 hints.ai_flags = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100752 hints.ai_protocol = 0;
753
754 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100755 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
756 sa->ss_family = result->ai_family;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100757 else if (sa->ss_family != result->ai_family) {
758 freeaddrinfo(result);
Willy Tarreau24709282013-03-10 21:32:12 +0100759 goto fail;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100760 }
Willy Tarreau24709282013-03-10 21:32:12 +0100761
David du Colombierd5f43282011-03-17 10:40:16 +0100762 switch (result->ai_family) {
763 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100764 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100765 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100766 success = 1;
767 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100768 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100769 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100770 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100771 success = 1;
772 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100773 }
774 }
775
Sean Carey58ea0392013-02-15 23:39:18 +0100776 if (result)
777 freeaddrinfo(result);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100778
779 if (success)
780 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100781 }
David du Colombierd5f43282011-03-17 10:40:16 +0100782#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200783 /* try to resolve an IPv4/IPv6 hostname */
784 he = gethostbyname(str);
785 if (he) {
786 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
787 sa->ss_family = he->h_addrtype;
788 else if (sa->ss_family != he->h_addrtype)
789 goto fail;
790
791 switch (sa->ss_family) {
792 case AF_INET:
793 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100794 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200795 return sa;
796 case AF_INET6:
797 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100798 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200799 return sa;
800 }
801 }
802
David du Colombierd5f43282011-03-17 10:40:16 +0100803 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100804 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100805 return NULL;
806}
807
808/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100809 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
810 * range or offset consisting in two integers that the caller will have to
811 * check to find the relevant input format. The following format are supported :
812 *
813 * String format | address | port | low | high
814 * addr | <addr> | 0 | 0 | 0
815 * addr: | <addr> | 0 | 0 | 0
816 * addr:port | <addr> | <port> | <port> | <port>
817 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
818 * addr:+port | <addr> | <port> | 0 | <port>
819 * addr:-port | <addr> |-<port> | <port> | 0
820 *
821 * The detection of a port range or increment by the caller is made by
822 * comparing <low> and <high>. If both are equal, then port 0 means no port
823 * was specified. The caller may pass NULL for <low> and <high> if it is not
824 * interested in retrieving port ranges.
825 *
826 * Note that <addr> above may also be :
827 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
828 * - "*" => family will be AF_INET and address will be INADDR_ANY
829 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
830 * - a host name => family and address will depend on host name resolving.
831 *
Willy Tarreau24709282013-03-10 21:32:12 +0100832 * A prefix may be passed in before the address above to force the family :
833 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
834 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
835 * - "unix@" => force address to be a path to a UNIX socket even if the
836 * path does not start with a '/'
Willy Tarreauccfccef2014-05-10 01:49:15 +0200837 * - 'abns@' -> force address to belong to the abstract namespace (Linux
838 * only). These sockets are just like Unix sockets but without
839 * the need for an underlying file system. The address is a
840 * string. Technically it's like a Unix socket with a zero in
841 * the first byte of the address.
Willy Tarreau40aa0702013-03-10 23:51:38 +0100842 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100843 *
mildisff5d5102015-10-26 18:50:08 +0100844 * IPv6 addresses can be declared with or without square brackets. When using
845 * square brackets for IPv6 addresses, the port separator (colon) is optional.
846 * If not using square brackets, and in order to avoid any ambiguity with
847 * IPv6 addresses, the last colon ':' is mandatory even when no port is specified.
848 * NULL is returned if the address cannot be parsed. The <low> and <high> ports
849 * are always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100850 *
851 * If <pfx> is non-null, it is used as a string prefix before any path-based
852 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100853 *
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200854 * if <fqdn> is non-null, it will be filled with :
855 * - a pointer to the FQDN of the server name to resolve if there's one, and
856 * that the caller will have to free(),
857 * - NULL if there was an explicit address that doesn't require resolution.
858 *
Willy Tarreaucd3a55912020-09-04 15:30:46 +0200859 * Hostnames are only resolved if <opts> has PA_O_RESOLVE. Otherwise <fqdn> is
860 * still honored so it is possible for the caller to know whether a resolution
861 * failed by clearing this flag and checking if <fqdn> was filled, indicating
862 * the need for a resolution.
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200863 *
Willy Tarreau40aa0702013-03-10 23:51:38 +0100864 * When a file descriptor is passed, its value is put into the s_addr part of
Willy Tarreaua5b325f2020-09-04 16:44:20 +0200865 * the address when cast to sockaddr_in and the address family is
866 * AF_CUST_EXISTING_FD.
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200867 *
Willy Tarreau5fc93282020-09-16 18:25:03 +0200868 * The matching protocol will be set into <proto> if non-null.
869 *
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200870 * Any known file descriptor is also assigned to <fd> if non-null, otherwise it
871 * is forced to -1.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100872 */
Willy Tarreau5fc93282020-09-16 18:25:03 +0200873struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int *high, int *fd,
874 struct protocol **proto, char **err,
875 const char *pfx, char **fqdn, unsigned int opts)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100876{
Christopher Faulet1bc04c72017-10-29 20:14:08 +0100877 static THREAD_LOCAL struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100878 struct sockaddr_storage *ret = NULL;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200879 struct protocol *new_proto = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100880 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100881 char *port1, *port2;
882 int portl, porth, porta;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200883 int abstract = 0;
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200884 int new_fd = -1;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200885 int sock_type, ctrl_type;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100886
887 portl = porth = porta = 0;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200888 if (fqdn)
889 *fqdn = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200890
Willy Tarreaudad36a32013-03-11 01:20:04 +0100891 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100892 if (str2 == NULL) {
893 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100894 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100895 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200896
Willy Tarreau9f69f462015-09-08 16:01:25 +0200897 if (!*str2) {
898 memprintf(err, "'%s' resolves to an empty address (environment variable missing?)\n", str);
899 goto out;
900 }
901
Willy Tarreau24709282013-03-10 21:32:12 +0100902 memset(&ss, 0, sizeof(ss));
903
Willy Tarreaue835bd82020-09-16 11:35:47 +0200904 /* prepare the default socket types */
905 if ((opts & (PA_O_STREAM|PA_O_DGRAM)) == PA_O_DGRAM)
906 sock_type = ctrl_type = SOCK_DGRAM;
907 else
908 sock_type = ctrl_type = SOCK_STREAM;
909
910 if (strncmp(str2, "stream+", 7) == 0) {
911 str2 += 7;
912 sock_type = ctrl_type = SOCK_STREAM;
913 }
914 else if (strncmp(str2, "dgram+", 6) == 0) {
915 str2 += 6;
916 sock_type = ctrl_type = SOCK_DGRAM;
917 }
918
Willy Tarreau24709282013-03-10 21:32:12 +0100919 if (strncmp(str2, "unix@", 5) == 0) {
920 str2 += 5;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200921 abstract = 0;
Willy Tarreau24709282013-03-10 21:32:12 +0100922 ss.ss_family = AF_UNIX;
923 }
Willy Tarreauccfccef2014-05-10 01:49:15 +0200924 else if (strncmp(str2, "abns@", 5) == 0) {
925 str2 += 5;
926 abstract = 1;
927 ss.ss_family = AF_UNIX;
928 }
Willy Tarreau24709282013-03-10 21:32:12 +0100929 else if (strncmp(str2, "ipv4@", 5) == 0) {
930 str2 += 5;
931 ss.ss_family = AF_INET;
932 }
933 else if (strncmp(str2, "ipv6@", 5) == 0) {
934 str2 += 5;
935 ss.ss_family = AF_INET6;
936 }
Emeric Brun3835c0d2020-07-07 09:46:09 +0200937 else if (strncmp(str2, "udp4@", 5) == 0) {
938 str2 += 5;
939 ss.ss_family = AF_INET;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200940 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200941 }
942 else if (strncmp(str2, "udp6@", 5) == 0) {
943 str2 += 5;
944 ss.ss_family = AF_INET6;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200945 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200946 }
947 else if (strncmp(str2, "udp@", 4) == 0) {
948 str2 += 4;
949 ss.ss_family = AF_UNSPEC;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200950 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200951 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +0200952 else if (strncmp(str2, "fd@", 3) == 0) {
953 str2 += 3;
954 ss.ss_family = AF_CUST_EXISTING_FD;
955 }
956 else if (strncmp(str2, "sockpair@", 9) == 0) {
957 str2 += 9;
958 ss.ss_family = AF_CUST_SOCKPAIR;
959 }
Willy Tarreau24709282013-03-10 21:32:12 +0100960 else if (*str2 == '/') {
961 ss.ss_family = AF_UNIX;
962 }
963 else
964 ss.ss_family = AF_UNSPEC;
965
Willy Tarreau5a7beed2020-09-04 16:54:05 +0200966 if (ss.ss_family == AF_CUST_SOCKPAIR) {
Willy Tarreaua215be22020-09-16 10:14:16 +0200967 struct sockaddr_storage ss2;
968 socklen_t addr_len;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200969 char *endptr;
970
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200971 new_fd = strtol(str2, &endptr, 10);
972 if (!*str2 || new_fd < 0 || *endptr) {
William Lallemand2fe7dd02018-09-11 16:51:29 +0200973 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
974 goto out;
975 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200976
Willy Tarreaua215be22020-09-16 10:14:16 +0200977 /* just verify that it's a socket */
978 addr_len = sizeof(ss2);
979 if (getsockname(new_fd, (struct sockaddr *)&ss2, &addr_len) == -1) {
980 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
981 goto out;
982 }
983
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200984 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
985 ((struct sockaddr_in *)&ss)->sin_port = 0;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200986 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +0200987 else if (ss.ss_family == AF_CUST_EXISTING_FD) {
Willy Tarreau40aa0702013-03-10 23:51:38 +0100988 char *endptr;
989
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200990 new_fd = strtol(str2, &endptr, 10);
991 if (!*str2 || new_fd < 0 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +0100992 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +0100993 goto out;
994 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200995
Willy Tarreau6edc7222020-09-15 17:41:56 +0200996 if (opts & PA_O_SOCKET_FD) {
997 socklen_t addr_len;
998 int type;
999
1000 addr_len = sizeof(ss);
1001 if (getsockname(new_fd, (struct sockaddr *)&ss, &addr_len) == -1) {
1002 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1003 goto out;
1004 }
1005
1006 addr_len = sizeof(type);
1007 if (getsockopt(new_fd, SOL_SOCKET, SO_TYPE, &type, &addr_len) != 0 ||
Willy Tarreaue835bd82020-09-16 11:35:47 +02001008 (type == SOCK_STREAM) != (sock_type == SOCK_STREAM)) {
Willy Tarreau6edc7222020-09-15 17:41:56 +02001009 memprintf(err, "socket on file descriptor '%d' is of the wrong type.\n", new_fd);
1010 goto out;
1011 }
1012
1013 porta = portl = porth = get_host_port(&ss);
1014 } else if (opts & PA_O_RAW_FD) {
1015 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1016 ((struct sockaddr_in *)&ss)->sin_port = 0;
1017 } else {
1018 memprintf(err, "a file descriptor is not acceptable here in '%s'\n", str);
1019 goto out;
1020 }
Willy Tarreau40aa0702013-03-10 23:51:38 +01001021 }
1022 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau8daa9202019-06-16 18:16:33 +02001023 struct sockaddr_un *un = (struct sockaddr_un *)&ss;
Willy Tarreau15586382013-03-04 19:48:14 +01001024 int prefix_path_len;
1025 int max_path_len;
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001026 int adr_len;
Willy Tarreau15586382013-03-04 19:48:14 +01001027
1028 /* complete unix socket path name during startup or soft-restart is
1029 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
1030 */
Willy Tarreauccfccef2014-05-10 01:49:15 +02001031 prefix_path_len = (pfx && !abstract) ? strlen(pfx) : 0;
Willy Tarreau8daa9202019-06-16 18:16:33 +02001032 max_path_len = (sizeof(un->sun_path) - 1) -
Willy Tarreau327ea5a2020-02-11 06:43:37 +01001033 (abstract ? 0 : prefix_path_len + 1 + 5 + 1 + 3);
Willy Tarreau15586382013-03-04 19:48:14 +01001034
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001035 adr_len = strlen(str2);
1036 if (adr_len > max_path_len) {
Willy Tarreau15586382013-03-04 19:48:14 +01001037 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
1038 goto out;
1039 }
1040
Willy Tarreauccfccef2014-05-10 01:49:15 +02001041 /* when abstract==1, we skip the first zero and copy all bytes except the trailing zero */
Willy Tarreau8daa9202019-06-16 18:16:33 +02001042 memset(un->sun_path, 0, sizeof(un->sun_path));
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001043 if (prefix_path_len)
Willy Tarreau8daa9202019-06-16 18:16:33 +02001044 memcpy(un->sun_path, pfx, prefix_path_len);
1045 memcpy(un->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
Willy Tarreau15586382013-03-04 19:48:14 +01001046 }
Willy Tarreau24709282013-03-10 21:32:12 +01001047 else { /* IPv4 and IPv6 */
mildisff5d5102015-10-26 18:50:08 +01001048 char *end = str2 + strlen(str2);
1049 char *chr;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001050
mildisff5d5102015-10-26 18:50:08 +01001051 /* search for : or ] whatever comes first */
1052 for (chr = end-1; chr > str2; chr--) {
1053 if (*chr == ']' || *chr == ':')
1054 break;
1055 }
1056
1057 if (*chr == ':') {
1058 /* Found a colon before a closing-bracket, must be a port separator.
1059 * This guarantee backward compatibility.
1060 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001061 if (!(opts & PA_O_PORT_OK)) {
1062 memprintf(err, "port specification not permitted here in '%s'", str);
1063 goto out;
1064 }
mildisff5d5102015-10-26 18:50:08 +01001065 *chr++ = '\0';
1066 port1 = chr;
1067 }
1068 else {
1069 /* Either no colon and no closing-bracket
1070 * or directly ending with a closing-bracket.
1071 * However, no port.
1072 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001073 if (opts & PA_O_PORT_MAND) {
1074 memprintf(err, "missing port specification in '%s'", str);
1075 goto out;
1076 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001077 port1 = "";
mildisff5d5102015-10-26 18:50:08 +01001078 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001079
Willy Tarreau90807112020-02-25 08:16:33 +01001080 if (isdigit((unsigned char)*port1)) { /* single port or range */
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001081 port2 = strchr(port1, '-');
Willy Tarreau7f96a842020-09-15 11:12:44 +02001082 if (port2) {
1083 if (!(opts & PA_O_PORT_RANGE)) {
1084 memprintf(err, "port range not permitted here in '%s'", str);
1085 goto out;
1086 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001087 *port2++ = '\0';
Willy Tarreau7f96a842020-09-15 11:12:44 +02001088 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001089 else
1090 port2 = port1;
1091 portl = atoi(port1);
1092 porth = atoi(port2);
Willy Tarreau7f96a842020-09-15 11:12:44 +02001093
1094 if (portl < !!(opts & PA_O_PORT_MAND) || portl > 65535) {
1095 memprintf(err, "invalid port '%s'", port1);
1096 goto out;
1097 }
1098
1099 if (porth < !!(opts & PA_O_PORT_MAND) || porth > 65535) {
1100 memprintf(err, "invalid port '%s'", port2);
1101 goto out;
1102 }
1103
1104 if (portl > porth) {
1105 memprintf(err, "invalid port range '%d-%d'", portl, porth);
1106 goto out;
1107 }
1108
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001109 porta = portl;
1110 }
1111 else if (*port1 == '-') { /* negative offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001112 if (!(opts & PA_O_PORT_OFS)) {
1113 memprintf(err, "port offset not permitted here in '%s'", str);
1114 goto out;
1115 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001116 portl = atoi(port1 + 1);
1117 porta = -portl;
1118 }
1119 else if (*port1 == '+') { /* positive offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001120 if (!(opts & PA_O_PORT_OFS)) {
1121 memprintf(err, "port offset not permitted here in '%s'", str);
1122 goto out;
1123 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001124 porth = atoi(port1 + 1);
1125 porta = porth;
1126 }
1127 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +01001128 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001129 goto out;
1130 }
Willy Tarreau7f96a842020-09-15 11:12:44 +02001131 else if (opts & PA_O_PORT_MAND) {
1132 memprintf(err, "missing port specification in '%s'", str);
1133 goto out;
1134 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001135
1136 /* first try to parse the IP without resolving. If it fails, it
1137 * tells us we need to keep a copy of the FQDN to resolve later
1138 * and to enable DNS. In this case we can proceed if <fqdn> is
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001139 * set or if PA_O_RESOLVE is set, otherwise it's an error.
Willy Tarreauceccdd72016-11-02 22:27:10 +01001140 */
1141 if (str2ip2(str2, &ss, 0) == NULL) {
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001142 if ((!(opts & PA_O_RESOLVE) && !fqdn) ||
1143 ((opts & PA_O_RESOLVE) && str2ip2(str2, &ss, 1) == NULL)) {
Willy Tarreauceccdd72016-11-02 22:27:10 +01001144 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
1145 goto out;
1146 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001147
Willy Tarreauceccdd72016-11-02 22:27:10 +01001148 if (fqdn) {
1149 if (str2 != back)
1150 memmove(back, str2, strlen(str2) + 1);
1151 *fqdn = back;
1152 back = NULL;
1153 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001154 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001155 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +01001156 }
Willy Tarreaufab5a432011-03-04 15:31:53 +01001157
Willy Tarreaue835bd82020-09-16 11:35:47 +02001158 if (ctrl_type == SOCK_STREAM && !(opts & PA_O_STREAM)) {
1159 memprintf(err, "stream-type socket not acceptable in '%s'\n", str);
1160 goto out;
1161 }
1162 else if (ctrl_type == SOCK_DGRAM && !(opts & PA_O_DGRAM)) {
1163 memprintf(err, "dgram-type socket not acceptable in '%s'\n", str);
1164 goto out;
1165 }
1166
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001167 if (proto || (opts & PA_O_CONNECT)) {
Willy Tarreau5fc93282020-09-16 18:25:03 +02001168 /* Note: if the caller asks for a proto, we must find one,
1169 * except if we return with an fqdn that will resolve later,
1170 * in which case the address is not known yet (this is only
1171 * for servers actually).
1172 */
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001173 new_proto = protocol_lookup(ss.ss_family,
Willy Tarreauaf9609b2020-09-16 22:04:46 +02001174 sock_type == SOCK_DGRAM,
1175 ctrl_type == SOCK_DGRAM);
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001176
Willy Tarreau5fc93282020-09-16 18:25:03 +02001177 if (!new_proto && (!fqdn || !*fqdn)) {
1178 memprintf(err, "unsupported protocol family %d for address '%s'", ss.ss_family, str);
1179 goto out;
1180 }
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001181
1182 if ((opts & PA_O_CONNECT) && new_proto && !new_proto->connect) {
1183 memprintf(err, "connect() not supported for this protocol family %d used by address '%s'", ss.ss_family, str);
1184 goto out;
1185 }
Willy Tarreau5fc93282020-09-16 18:25:03 +02001186 }
1187
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001188 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +01001189 out:
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001190 if (port)
1191 *port = porta;
Willy Tarreaud4448bc2013-02-20 15:55:15 +01001192 if (low)
1193 *low = portl;
1194 if (high)
1195 *high = porth;
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001196 if (fd)
1197 *fd = new_fd;
Willy Tarreau5fc93282020-09-16 18:25:03 +02001198 if (proto)
1199 *proto = new_proto;
Willy Tarreau24709282013-03-10 21:32:12 +01001200 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +01001201 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001202}
1203
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001204/* converts <str> to a struct in_addr containing a network mask. It can be
1205 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +03001206 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001207 */
1208int str2mask(const char *str, struct in_addr *mask)
1209{
1210 if (strchr(str, '.') != NULL) { /* dotted notation */
1211 if (!inet_pton(AF_INET, str, mask))
1212 return 0;
1213 }
1214 else { /* mask length */
1215 char *err;
1216 unsigned long len = strtol(str, &err, 10);
1217
1218 if (!*str || (err && *err) || (unsigned)len > 32)
1219 return 0;
Tim Duesterhus8575f722018-01-25 16:24:48 +01001220
1221 len2mask4(len, mask);
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001222 }
1223 return 1;
1224}
1225
Tim Duesterhus47185172018-01-25 16:24:49 +01001226/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +01001227 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +01001228 * if the conversion succeeds otherwise zero.
1229 */
1230int str2mask6(const char *str, struct in6_addr *mask)
1231{
1232 if (strchr(str, ':') != NULL) { /* quadruplet notation */
1233 if (!inet_pton(AF_INET6, str, mask))
1234 return 0;
1235 }
1236 else { /* mask length */
1237 char *err;
1238 unsigned long len = strtol(str, &err, 10);
1239
1240 if (!*str || (err && *err) || (unsigned)len > 128)
1241 return 0;
1242
1243 len2mask6(len, mask);
1244 }
1245 return 1;
1246}
1247
Thierry FOURNIERb0504632013-12-14 15:39:02 +01001248/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
1249 * succeeds otherwise zero.
1250 */
1251int cidr2dotted(int cidr, struct in_addr *mask) {
1252
1253 if (cidr < 0 || cidr > 32)
1254 return 0;
1255
1256 mask->s_addr = cidr ? htonl(~0UL << (32 - cidr)) : 0;
1257 return 1;
1258}
1259
Thierry Fournier70473a52016-02-17 17:12:14 +01001260/* Convert mask from bit length form to in_addr form.
1261 * This function never fails.
1262 */
1263void len2mask4(int len, struct in_addr *addr)
1264{
1265 if (len >= 32) {
1266 addr->s_addr = 0xffffffff;
1267 return;
1268 }
1269 if (len <= 0) {
1270 addr->s_addr = 0x00000000;
1271 return;
1272 }
1273 addr->s_addr = 0xffffffff << (32 - len);
1274 addr->s_addr = htonl(addr->s_addr);
1275}
1276
1277/* Convert mask from bit length form to in6_addr form.
1278 * This function never fails.
1279 */
1280void len2mask6(int len, struct in6_addr *addr)
1281{
1282 len2mask4(len, (struct in_addr *)&addr->s6_addr[0]); /* msb */
1283 len -= 32;
1284 len2mask4(len, (struct in_addr *)&addr->s6_addr[4]);
1285 len -= 32;
1286 len2mask4(len, (struct in_addr *)&addr->s6_addr[8]);
1287 len -= 32;
1288 len2mask4(len, (struct in_addr *)&addr->s6_addr[12]); /* lsb */
1289}
1290
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001291/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +02001292 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001293 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001294 * is optional and either in the dotted or CIDR notation.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001295 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
1296 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001297int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001298{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001299 __label__ out_free, out_err;
1300 char *c, *s;
1301 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001302
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001303 s = strdup(str);
1304 if (!s)
1305 return 0;
1306
Willy Tarreaubaaee002006-06-26 02:48:02 +02001307 memset(mask, 0, sizeof(*mask));
1308 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001309
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001310 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001311 *c++ = '\0';
1312 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001313 if (!str2mask(c, mask))
1314 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001315 }
1316 else {
Willy Tarreauebd61602006-12-30 11:54:15 +01001317 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001318 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001319 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001320 struct hostent *he;
1321
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001322 if (!resolve)
1323 goto out_err;
1324
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001325 if ((he = gethostbyname(s)) == NULL) {
1326 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001327 }
1328 else
1329 *addr = *(struct in_addr *) *(he->h_addr_list);
1330 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001331
1332 ret_val = 1;
1333 out_free:
1334 free(s);
1335 return ret_val;
1336 out_err:
1337 ret_val = 0;
1338 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001339}
1340
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001341
1342/*
Willy Tarreau6d20e282012-04-27 22:49:47 +02001343 * converts <str> to two struct in6_addr* which must be pre-allocated.
1344 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001345 * is an optional number of bits (128 being the default).
Willy Tarreau6d20e282012-04-27 22:49:47 +02001346 * Returns 1 if OK, 0 if error.
1347 */
1348int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
1349{
1350 char *c, *s;
1351 int ret_val = 0;
1352 char *err;
1353 unsigned long len = 128;
1354
1355 s = strdup(str);
1356 if (!s)
1357 return 0;
1358
1359 memset(mask, 0, sizeof(*mask));
1360 memset(addr, 0, sizeof(*addr));
1361
1362 if ((c = strrchr(s, '/')) != NULL) {
1363 *c++ = '\0'; /* c points to the mask */
1364 if (!*c)
1365 goto out_free;
1366
1367 len = strtoul(c, &err, 10);
1368 if ((err && *err) || (unsigned)len > 128)
1369 goto out_free;
1370 }
1371 *mask = len; /* OK we have a valid mask in <len> */
1372
1373 if (!inet_pton(AF_INET6, s, addr))
1374 goto out_free;
1375
1376 ret_val = 1;
1377 out_free:
1378 free(s);
1379 return ret_val;
1380}
1381
1382
1383/*
David du Colombier6f5ccb12011-03-10 22:26:24 +01001384 * Parse IPv4 address found in url.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001385 */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001386int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001387{
1388 int saw_digit, octets, ch;
1389 u_char tmp[4], *tp;
1390 const char *cp = addr;
1391
1392 saw_digit = 0;
1393 octets = 0;
1394 *(tp = tmp) = 0;
1395
1396 while (*addr) {
1397 unsigned char digit = (ch = *addr++) - '0';
1398 if (digit > 9 && ch != '.')
1399 break;
1400 if (digit <= 9) {
1401 u_int new = *tp * 10 + digit;
1402 if (new > 255)
1403 return 0;
1404 *tp = new;
1405 if (!saw_digit) {
1406 if (++octets > 4)
1407 return 0;
1408 saw_digit = 1;
1409 }
1410 } else if (ch == '.' && saw_digit) {
1411 if (octets == 4)
1412 return 0;
1413 *++tp = 0;
1414 saw_digit = 0;
1415 } else
1416 return 0;
1417 }
1418
1419 if (octets < 4)
1420 return 0;
1421
1422 memcpy(&dst->s_addr, tmp, 4);
1423 return addr-cp-1;
1424}
1425
1426/*
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001427 * Resolve destination server from URL. Convert <str> to a sockaddr_storage.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001428 * <out> contain the code of the detected scheme, the start and length of
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001429 * the hostname. Actually only http and https are supported. <out> can be NULL.
1430 * This function returns the consumed length. It is useful if you parse complete
1431 * url like http://host:port/path, because the consumed length corresponds to
1432 * the first character of the path. If the conversion fails, it returns -1.
1433 *
1434 * This function tries to resolve the DNS name if haproxy is in starting mode.
1435 * So, this function may be used during the configuration parsing.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001436 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001437int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001438{
1439 const char *curr = url, *cp = url;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001440 const char *end;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001441 int ret, url_code = 0;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001442 unsigned long long int http_code = 0;
1443 int default_port;
1444 struct hostent *he;
1445 char *p;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001446
1447 /* Firstly, try to find :// pattern */
1448 while (curr < url+ulen && url_code != 0x3a2f2f) {
1449 url_code = ((url_code & 0xffff) << 8);
1450 url_code += (unsigned char)*curr++;
1451 }
1452
1453 /* Secondly, if :// pattern is found, verify parsed stuff
1454 * before pattern is matching our http pattern.
1455 * If so parse ip address and port in uri.
1456 *
1457 * WARNING: Current code doesn't support dynamic async dns resolver.
1458 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001459 if (url_code != 0x3a2f2f)
1460 return -1;
1461
1462 /* Copy scheme, and utrn to lower case. */
1463 while (cp < curr - 3)
1464 http_code = (http_code << 8) + *cp++;
1465 http_code |= 0x2020202020202020ULL; /* Turn everything to lower case */
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001466
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001467 /* HTTP or HTTPS url matching */
1468 if (http_code == 0x2020202068747470ULL) {
1469 default_port = 80;
1470 if (out)
1471 out->scheme = SCH_HTTP;
1472 }
1473 else if (http_code == 0x2020206874747073ULL) {
1474 default_port = 443;
1475 if (out)
1476 out->scheme = SCH_HTTPS;
1477 }
1478 else
1479 return -1;
1480
1481 /* If the next char is '[', the host address is IPv6. */
1482 if (*curr == '[') {
1483 curr++;
1484
1485 /* Check trash size */
1486 if (trash.size < ulen)
1487 return -1;
1488
1489 /* Look for ']' and copy the address in a trash buffer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001490 p = trash.area;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001491 for (end = curr;
1492 end < url + ulen && *end != ']';
1493 end++, p++)
1494 *p = *end;
1495 if (*end != ']')
1496 return -1;
1497 *p = '\0';
1498
1499 /* Update out. */
1500 if (out) {
1501 out->host = curr;
1502 out->host_len = end - curr;
1503 }
1504
1505 /* Try IPv6 decoding. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001506 if (!inet_pton(AF_INET6, trash.area, &((struct sockaddr_in6 *)addr)->sin6_addr))
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001507 return -1;
1508 end++;
1509
1510 /* Decode port. */
1511 if (*end == ':') {
1512 end++;
1513 default_port = read_uint(&end, url + ulen);
1514 }
1515 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1516 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1517 return end - url;
1518 }
1519 else {
1520 /* We are looking for IP address. If you want to parse and
1521 * resolve hostname found in url, you can use str2sa_range(), but
1522 * be warned this can slow down global daemon performances
1523 * while handling lagging dns responses.
1524 */
1525 ret = url2ipv4(curr, &((struct sockaddr_in *)addr)->sin_addr);
1526 if (ret) {
1527 /* Update out. */
1528 if (out) {
1529 out->host = curr;
1530 out->host_len = ret;
1531 }
1532
1533 curr += ret;
1534
1535 /* Decode port. */
1536 if (*curr == ':') {
1537 curr++;
1538 default_port = read_uint(&curr, url + ulen);
1539 }
1540 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1541
1542 /* Set family. */
1543 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1544 return curr - url;
1545 }
1546 else if (global.mode & MODE_STARTING) {
1547 /* The IPv4 and IPv6 decoding fails, maybe the url contain name. Try to execute
1548 * synchronous DNS request only if HAProxy is in the start state.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001549 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001550
1551 /* look for : or / or end */
1552 for (end = curr;
1553 end < url + ulen && *end != '/' && *end != ':';
1554 end++);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001555 memcpy(trash.area, curr, end - curr);
1556 trash.area[end - curr] = '\0';
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001557
1558 /* try to resolve an IPv4/IPv6 hostname */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001559 he = gethostbyname(trash.area);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001560 if (!he)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001561 return -1;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001562
1563 /* Update out. */
1564 if (out) {
1565 out->host = curr;
1566 out->host_len = end - curr;
1567 }
1568
1569 /* Decode port. */
1570 if (*end == ':') {
1571 end++;
1572 default_port = read_uint(&end, url + ulen);
1573 }
1574
1575 /* Copy IP address, set port and family. */
1576 switch (he->h_addrtype) {
1577 case AF_INET:
1578 ((struct sockaddr_in *)addr)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
1579 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1580 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1581 return end - url;
1582
1583 case AF_INET6:
1584 ((struct sockaddr_in6 *)addr)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
1585 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1586 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1587 return end - url;
1588 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001589 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001590 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001591 return -1;
1592}
1593
Willy Tarreau631f01c2011-09-05 00:36:48 +02001594/* Tries to convert a sockaddr_storage address to text form. Upon success, the
1595 * address family is returned so that it's easy for the caller to adapt to the
1596 * output format. Zero is returned if the address family is not supported. -1
1597 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1598 * supported.
1599 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001600int addr_to_str(const struct sockaddr_storage *addr, char *str, int size)
Willy Tarreau631f01c2011-09-05 00:36:48 +02001601{
1602
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001603 const void *ptr;
Willy Tarreau631f01c2011-09-05 00:36:48 +02001604
1605 if (size < 5)
1606 return 0;
1607 *str = '\0';
1608
1609 switch (addr->ss_family) {
1610 case AF_INET:
1611 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1612 break;
1613 case AF_INET6:
1614 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1615 break;
1616 case AF_UNIX:
1617 memcpy(str, "unix", 5);
1618 return addr->ss_family;
1619 default:
1620 return 0;
1621 }
1622
1623 if (inet_ntop(addr->ss_family, ptr, str, size))
1624 return addr->ss_family;
1625
1626 /* failed */
1627 return -1;
1628}
1629
Simon Horman75ab8bd2014-06-16 09:39:41 +09001630/* Tries to convert a sockaddr_storage port to text form. Upon success, the
1631 * address family is returned so that it's easy for the caller to adapt to the
1632 * output format. Zero is returned if the address family is not supported. -1
1633 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1634 * supported.
1635 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001636int port_to_str(const struct sockaddr_storage *addr, char *str, int size)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001637{
1638
1639 uint16_t port;
1640
1641
Willy Tarreaud7dad1b2017-01-06 16:46:22 +01001642 if (size < 6)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001643 return 0;
1644 *str = '\0';
1645
1646 switch (addr->ss_family) {
1647 case AF_INET:
1648 port = ((struct sockaddr_in *)addr)->sin_port;
1649 break;
1650 case AF_INET6:
1651 port = ((struct sockaddr_in6 *)addr)->sin6_port;
1652 break;
1653 case AF_UNIX:
1654 memcpy(str, "unix", 5);
1655 return addr->ss_family;
1656 default:
1657 return 0;
1658 }
1659
1660 snprintf(str, size, "%u", ntohs(port));
1661 return addr->ss_family;
1662}
1663
Willy Tarreau16e01562016-08-09 16:46:18 +02001664/* check if the given address is local to the system or not. It will return
1665 * -1 when it's not possible to know, 0 when the address is not local, 1 when
1666 * it is. We don't want to iterate over all interfaces for this (and it is not
1667 * portable). So instead we try to bind in UDP to this address on a free non
1668 * privileged port and to connect to the same address, port 0 (connect doesn't
1669 * care). If it succeeds, we own the address. Note that non-inet addresses are
1670 * considered local since they're most likely AF_UNIX.
1671 */
1672int addr_is_local(const struct netns_entry *ns,
1673 const struct sockaddr_storage *orig)
1674{
1675 struct sockaddr_storage addr;
1676 int result;
1677 int fd;
1678
1679 if (!is_inet_addr(orig))
1680 return 1;
1681
1682 memcpy(&addr, orig, sizeof(addr));
1683 set_host_port(&addr, 0);
1684
1685 fd = my_socketat(ns, addr.ss_family, SOCK_DGRAM, IPPROTO_UDP);
1686 if (fd < 0)
1687 return -1;
1688
1689 result = -1;
1690 if (bind(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == 0) {
1691 if (connect(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == -1)
1692 result = 0; // fail, non-local address
1693 else
1694 result = 1; // success, local address
1695 }
1696 else {
1697 if (errno == EADDRNOTAVAIL)
1698 result = 0; // definitely not local :-)
1699 }
1700 close(fd);
1701
1702 return result;
1703}
1704
Willy Tarreaubaaee002006-06-26 02:48:02 +02001705/* will try to encode the string <string> replacing all characters tagged in
1706 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1707 * prefixed by <escape>, and will store the result between <start> (included)
1708 * and <stop> (excluded), and will always terminate the string with a '\0'
1709 * before <stop>. The position of the '\0' is returned if the conversion
1710 * completes. If bytes are missing between <start> and <stop>, then the
1711 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1712 * cannot even be stored so we return <start> without writing the 0.
1713 * The input string must also be zero-terminated.
1714 */
1715const char hextab[16] = "0123456789ABCDEF";
1716char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001717 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +02001718 const char *string)
1719{
1720 if (start < stop) {
1721 stop--; /* reserve one byte for the final '\0' */
1722 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001723 if (!ha_bit_test((unsigned char)(*string), map))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001724 *start++ = *string;
1725 else {
1726 if (start + 3 >= stop)
1727 break;
1728 *start++ = escape;
1729 *start++ = hextab[(*string >> 4) & 15];
1730 *start++ = hextab[*string & 15];
1731 }
1732 string++;
1733 }
1734 *start = '\0';
1735 }
1736 return start;
1737}
1738
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001739/*
1740 * Same behavior as encode_string() above, except that it encodes chunk
1741 * <chunk> instead of a string.
1742 */
1743char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001744 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001745 const struct buffer *chunk)
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001746{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001747 char *str = chunk->area;
1748 char *end = chunk->area + chunk->data;
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001749
1750 if (start < stop) {
1751 stop--; /* reserve one byte for the final '\0' */
1752 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001753 if (!ha_bit_test((unsigned char)(*str), map))
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001754 *start++ = *str;
1755 else {
1756 if (start + 3 >= stop)
1757 break;
1758 *start++ = escape;
1759 *start++ = hextab[(*str >> 4) & 15];
1760 *start++ = hextab[*str & 15];
1761 }
1762 str++;
1763 }
1764 *start = '\0';
1765 }
1766 return start;
1767}
1768
Dragan Dosen0edd1092016-02-12 13:23:02 +01001769/*
1770 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001771 * character. The input <string> must be zero-terminated. The result will
1772 * be stored between <start> (included) and <stop> (excluded). This
1773 * function will always try to terminate the resulting string with a '\0'
1774 * before <stop>, and will return its position if the conversion
1775 * completes.
1776 */
1777char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001778 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001779 const char *string)
1780{
1781 if (start < stop) {
1782 stop--; /* reserve one byte for the final '\0' */
1783 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001784 if (!ha_bit_test((unsigned char)(*string), map))
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001785 *start++ = *string;
1786 else {
1787 if (start + 2 >= stop)
1788 break;
1789 *start++ = escape;
1790 *start++ = *string;
1791 }
1792 string++;
1793 }
1794 *start = '\0';
1795 }
1796 return start;
1797}
1798
1799/*
1800 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +01001801 * character. <chunk> contains the input to be escaped. The result will be
1802 * stored between <start> (included) and <stop> (excluded). The function
1803 * will always try to terminate the resulting string with a '\0' before
1804 * <stop>, and will return its position if the conversion completes.
1805 */
1806char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001807 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001808 const struct buffer *chunk)
Dragan Dosen0edd1092016-02-12 13:23:02 +01001809{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001810 char *str = chunk->area;
1811 char *end = chunk->area + chunk->data;
Dragan Dosen0edd1092016-02-12 13:23:02 +01001812
1813 if (start < stop) {
1814 stop--; /* reserve one byte for the final '\0' */
1815 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001816 if (!ha_bit_test((unsigned char)(*str), map))
Dragan Dosen0edd1092016-02-12 13:23:02 +01001817 *start++ = *str;
1818 else {
1819 if (start + 2 >= stop)
1820 break;
1821 *start++ = escape;
1822 *start++ = *str;
1823 }
1824 str++;
1825 }
1826 *start = '\0';
1827 }
1828 return start;
1829}
1830
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001831/* Check a string for using it in a CSV output format. If the string contains
1832 * one of the following four char <">, <,>, CR or LF, the string is
1833 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
1834 * <str> is the input string to be escaped. The function assumes that
1835 * the input string is null-terminated.
1836 *
1837 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +01001838 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001839 * format.
1840 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001841 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001842 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001843 * If <quote> is 1, the converter puts the quotes only if any reserved character
1844 * is present. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001845 *
Willy Tarreau83061a82018-07-13 11:56:34 +02001846 * <output> is a struct buffer used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001847 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001848 * The function returns the converted string on its output. If an error
1849 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001850 * for using the function directly as printf() argument.
1851 *
1852 * If the output buffer is too short to contain the input string, the result
1853 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +01001854 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001855 * This function appends the encoding to the existing output chunk, and it
1856 * guarantees that it starts immediately at the first available character of
1857 * the chunk. Please use csv_enc() instead if you want to replace the output
1858 * chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001859 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001860const char *csv_enc_append(const char *str, int quote, struct buffer *output)
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001861{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001862 char *end = output->area + output->size;
1863 char *out = output->area + output->data;
Willy Tarreau898529b2016-01-06 18:07:04 +01001864 char *ptr = out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001865
Willy Tarreaub631c292016-01-08 10:04:08 +01001866 if (quote == 1) {
1867 /* automatic quoting: first verify if we'll have to quote the string */
1868 if (!strpbrk(str, "\n\r,\""))
1869 quote = 0;
1870 }
1871
1872 if (quote)
1873 *ptr++ = '"';
1874
Willy Tarreau898529b2016-01-06 18:07:04 +01001875 while (*str && ptr < end - 2) { /* -2 for reserving space for <"> and \0. */
1876 *ptr = *str;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001877 if (*str == '"') {
Willy Tarreau898529b2016-01-06 18:07:04 +01001878 ptr++;
1879 if (ptr >= end - 2) {
1880 ptr--;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001881 break;
1882 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001883 *ptr = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001884 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001885 ptr++;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001886 str++;
1887 }
1888
Willy Tarreaub631c292016-01-08 10:04:08 +01001889 if (quote)
1890 *ptr++ = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001891
Willy Tarreau898529b2016-01-06 18:07:04 +01001892 *ptr = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001893 output->data = ptr - output->area;
Willy Tarreau898529b2016-01-06 18:07:04 +01001894 return out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001895}
1896
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001897/* Decode an URL-encoded string in-place. The resulting string might
1898 * be shorter. If some forbidden characters are found, the conversion is
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001899 * aborted, the string is truncated before the issue and a negative value is
1900 * returned, otherwise the operation returns the length of the decoded string.
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001901 * If the 'in_form' argument is non-nul the string is assumed to be part of
1902 * an "application/x-www-form-urlencoded" encoded string, and the '+' will be
1903 * turned to a space. If it's zero, this will only be done after a question
1904 * mark ('?').
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001905 */
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001906int url_decode(char *string, int in_form)
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001907{
1908 char *in, *out;
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001909 int ret = -1;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001910
1911 in = string;
1912 out = string;
1913 while (*in) {
1914 switch (*in) {
1915 case '+' :
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001916 *out++ = in_form ? ' ' : *in;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001917 break;
1918 case '%' :
1919 if (!ishex(in[1]) || !ishex(in[2]))
1920 goto end;
1921 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
1922 in += 2;
1923 break;
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001924 case '?':
1925 in_form = 1;
1926 /* fall through */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001927 default:
1928 *out++ = *in;
1929 break;
1930 }
1931 in++;
1932 }
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001933 ret = out - string; /* success */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001934 end:
1935 *out = 0;
1936 return ret;
1937}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001938
Willy Tarreau6911fa42007-03-04 18:06:08 +01001939unsigned int str2ui(const char *s)
1940{
1941 return __str2ui(s);
1942}
1943
1944unsigned int str2uic(const char *s)
1945{
1946 return __str2uic(s);
1947}
1948
1949unsigned int strl2ui(const char *s, int len)
1950{
1951 return __strl2ui(s, len);
1952}
1953
1954unsigned int strl2uic(const char *s, int len)
1955{
1956 return __strl2uic(s, len);
1957}
1958
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02001959unsigned int read_uint(const char **s, const char *end)
1960{
1961 return __read_uint(s, end);
1962}
1963
Thierry FOURNIER763a5d82015-07-06 23:09:52 +02001964/* This function reads an unsigned integer from the string pointed to by <s> and
1965 * returns it. The <s> pointer is adjusted to point to the first unread char. The
1966 * function automatically stops at <end>. If the number overflows, the 2^64-1
1967 * value is returned.
1968 */
1969unsigned long long int read_uint64(const char **s, const char *end)
1970{
1971 const char *ptr = *s;
1972 unsigned long long int i = 0, tmp;
1973 unsigned int j;
1974
1975 while (ptr < end) {
1976
1977 /* read next char */
1978 j = *ptr - '0';
1979 if (j > 9)
1980 goto read_uint64_end;
1981
1982 /* add char to the number and check overflow. */
1983 tmp = i * 10;
1984 if (tmp / 10 != i) {
1985 i = ULLONG_MAX;
1986 goto read_uint64_eat;
1987 }
1988 if (ULLONG_MAX - tmp < j) {
1989 i = ULLONG_MAX;
1990 goto read_uint64_eat;
1991 }
1992 i = tmp + j;
1993 ptr++;
1994 }
1995read_uint64_eat:
1996 /* eat each numeric char */
1997 while (ptr < end) {
1998 if ((unsigned int)(*ptr - '0') > 9)
1999 break;
2000 ptr++;
2001 }
2002read_uint64_end:
2003 *s = ptr;
2004 return i;
2005}
2006
2007/* This function reads an integer from the string pointed to by <s> and returns
2008 * it. The <s> pointer is adjusted to point to the first unread char. The function
2009 * automatically stops at <end>. Il the number is bigger than 2^63-2, the 2^63-1
2010 * value is returned. If the number is lowest than -2^63-1, the -2^63 value is
2011 * returned.
2012 */
2013long long int read_int64(const char **s, const char *end)
2014{
2015 unsigned long long int i = 0;
2016 int neg = 0;
2017
2018 /* Look for minus char. */
2019 if (**s == '-') {
2020 neg = 1;
2021 (*s)++;
2022 }
2023 else if (**s == '+')
2024 (*s)++;
2025
2026 /* convert as positive number. */
2027 i = read_uint64(s, end);
2028
2029 if (neg) {
2030 if (i > 0x8000000000000000ULL)
2031 return LLONG_MIN;
2032 return -i;
2033 }
2034 if (i > 0x7fffffffffffffffULL)
2035 return LLONG_MAX;
2036 return i;
2037}
2038
Willy Tarreau6911fa42007-03-04 18:06:08 +01002039/* This one is 7 times faster than strtol() on athlon with checks.
2040 * It returns the value of the number composed of all valid digits read,
2041 * and can process negative numbers too.
2042 */
2043int strl2ic(const char *s, int len)
2044{
2045 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002046 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002047
2048 if (len > 0) {
2049 if (*s != '-') {
2050 /* positive number */
2051 while (len-- > 0) {
2052 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002053 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002054 if (j > 9)
2055 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002056 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002057 }
2058 } else {
2059 /* negative number */
2060 s++;
2061 while (--len > 0) {
2062 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002063 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002064 if (j > 9)
2065 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002066 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002067 }
2068 }
2069 }
2070 return i;
2071}
2072
2073
2074/* This function reads exactly <len> chars from <s> and converts them to a
2075 * signed integer which it stores into <ret>. It accurately detects any error
2076 * (truncated string, invalid chars, overflows). It is meant to be used in
2077 * applications designed for hostile environments. It returns zero when the
2078 * number has successfully been converted, non-zero otherwise. When an error
2079 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
2080 * faster than strtol().
2081 */
2082int strl2irc(const char *s, int len, int *ret)
2083{
2084 int i = 0;
2085 int j;
2086
2087 if (!len)
2088 return 1;
2089
2090 if (*s != '-') {
2091 /* positive number */
2092 while (len-- > 0) {
2093 j = (*s++) - '0';
2094 if (j > 9) return 1; /* invalid char */
2095 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
2096 i = i * 10;
2097 if (i + j < i) return 1; /* check for addition overflow */
2098 i = i + j;
2099 }
2100 } else {
2101 /* negative number */
2102 s++;
2103 while (--len > 0) {
2104 j = (*s++) - '0';
2105 if (j > 9) return 1; /* invalid char */
2106 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
2107 i = i * 10;
2108 if (i - j > i) return 1; /* check for subtract overflow */
2109 i = i - j;
2110 }
2111 }
2112 *ret = i;
2113 return 0;
2114}
2115
2116
2117/* This function reads exactly <len> chars from <s> and converts them to a
2118 * signed integer which it stores into <ret>. It accurately detects any error
2119 * (truncated string, invalid chars, overflows). It is meant to be used in
2120 * applications designed for hostile environments. It returns zero when the
2121 * number has successfully been converted, non-zero otherwise. When an error
2122 * is returned, the <ret> value is left untouched. It is about 3 times slower
2123 * than str2irc().
2124 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01002125
2126int strl2llrc(const char *s, int len, long long *ret)
2127{
2128 long long i = 0;
2129 int j;
2130
2131 if (!len)
2132 return 1;
2133
2134 if (*s != '-') {
2135 /* positive number */
2136 while (len-- > 0) {
2137 j = (*s++) - '0';
2138 if (j > 9) return 1; /* invalid char */
2139 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
2140 i = i * 10LL;
2141 if (i + j < i) return 1; /* check for addition overflow */
2142 i = i + j;
2143 }
2144 } else {
2145 /* negative number */
2146 s++;
2147 while (--len > 0) {
2148 j = (*s++) - '0';
2149 if (j > 9) return 1; /* invalid char */
2150 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
2151 i = i * 10LL;
2152 if (i - j > i) return 1; /* check for subtract overflow */
2153 i = i - j;
2154 }
2155 }
2156 *ret = i;
2157 return 0;
2158}
2159
Thierry FOURNIER511e9472014-01-23 17:40:34 +01002160/* This function is used with pat_parse_dotted_ver(). It converts a string
2161 * composed by two number separated by a dot. Each part must contain in 16 bits
2162 * because internally they will be represented as a 32-bit quantity stored in
2163 * a 64-bit integer. It returns zero when the number has successfully been
2164 * converted, non-zero otherwise. When an error is returned, the <ret> value
2165 * is left untouched.
2166 *
2167 * "1.3" -> 0x0000000000010003
2168 * "65535.65535" -> 0x00000000ffffffff
2169 */
2170int strl2llrc_dotted(const char *text, int len, long long *ret)
2171{
2172 const char *end = &text[len];
2173 const char *p;
2174 long long major, minor;
2175
2176 /* Look for dot. */
2177 for (p = text; p < end; p++)
2178 if (*p == '.')
2179 break;
2180
2181 /* Convert major. */
2182 if (strl2llrc(text, p - text, &major) != 0)
2183 return 1;
2184
2185 /* Check major. */
2186 if (major >= 65536)
2187 return 1;
2188
2189 /* Convert minor. */
2190 minor = 0;
2191 if (p < end)
2192 if (strl2llrc(p + 1, end - (p + 1), &minor) != 0)
2193 return 1;
2194
2195 /* Check minor. */
2196 if (minor >= 65536)
2197 return 1;
2198
2199 /* Compose value. */
2200 *ret = (major << 16) | (minor & 0xffff);
2201 return 0;
2202}
2203
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002204/* This function parses a time value optionally followed by a unit suffix among
2205 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
2206 * expected by the caller. The computation does its best to avoid overflows.
2207 * The value is returned in <ret> if everything is fine, and a NULL is returned
2208 * by the function. In case of error, a pointer to the error is returned and
2209 * <ret> is left untouched. Values are automatically rounded up when needed.
Willy Tarreau9faebe32019-06-07 19:00:37 +02002210 * Values resulting in values larger than or equal to 2^31 after conversion are
2211 * reported as an overflow as value PARSE_TIME_OVER. Non-null values resulting
2212 * in an underflow are reported as an underflow as value PARSE_TIME_UNDER.
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002213 */
2214const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
2215{
Willy Tarreau9faebe32019-06-07 19:00:37 +02002216 unsigned long long imult, idiv;
2217 unsigned long long omult, odiv;
2218 unsigned long long value, result;
Christopher Faulet761d1fb2020-12-11 09:23:07 +01002219 const char *str = text;
2220
2221 if (!isdigit((unsigned char)*text))
2222 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002223
2224 omult = odiv = 1;
2225
2226 switch (unit_flags & TIME_UNIT_MASK) {
2227 case TIME_UNIT_US: omult = 1000000; break;
2228 case TIME_UNIT_MS: omult = 1000; break;
2229 case TIME_UNIT_S: break;
2230 case TIME_UNIT_MIN: odiv = 60; break;
2231 case TIME_UNIT_HOUR: odiv = 3600; break;
2232 case TIME_UNIT_DAY: odiv = 86400; break;
2233 default: break;
2234 }
2235
2236 value = 0;
2237
2238 while (1) {
2239 unsigned int j;
2240
2241 j = *text - '0';
2242 if (j > 9)
2243 break;
2244 text++;
2245 value *= 10;
2246 value += j;
2247 }
2248
2249 imult = idiv = 1;
2250 switch (*text) {
2251 case '\0': /* no unit = default unit */
2252 imult = omult = idiv = odiv = 1;
Christopher Faulet761d1fb2020-12-11 09:23:07 +01002253 goto end;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002254 case 's': /* second = unscaled unit */
2255 break;
2256 case 'u': /* microsecond : "us" */
2257 if (text[1] == 's') {
2258 idiv = 1000000;
2259 text++;
2260 }
Christopher Faulet761d1fb2020-12-11 09:23:07 +01002261 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002262 case 'm': /* millisecond : "ms" or minute: "m" */
2263 if (text[1] == 's') {
2264 idiv = 1000;
2265 text++;
2266 } else
2267 imult = 60;
2268 break;
2269 case 'h': /* hour : "h" */
2270 imult = 3600;
2271 break;
2272 case 'd': /* day : "d" */
2273 imult = 86400;
2274 break;
2275 default:
2276 return text;
2277 break;
2278 }
Christopher Faulet761d1fb2020-12-11 09:23:07 +01002279 if (*(++text) != '\0') {
2280 ha_warning("unexpected character '%c' after the timer value '%s', only "
2281 "(us=microseconds,ms=milliseconds,s=seconds,m=minutes,h=hours,d=days) are supported."
2282 " This will be reported as an error in next versions.\n", *text, str);
2283 }
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002284
Christopher Faulet761d1fb2020-12-11 09:23:07 +01002285 end:
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002286 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
2287 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
2288 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
2289 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
2290
Willy Tarreau9faebe32019-06-07 19:00:37 +02002291 result = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
2292 if (result >= 0x80000000)
2293 return PARSE_TIME_OVER;
2294 if (!result && value)
2295 return PARSE_TIME_UNDER;
2296 *ret = result;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002297 return NULL;
2298}
Willy Tarreau6911fa42007-03-04 18:06:08 +01002299
Emeric Brun39132b22010-01-04 14:57:24 +01002300/* this function converts the string starting at <text> to an unsigned int
2301 * stored in <ret>. If an error is detected, the pointer to the unexpected
Joseph Herlant32b83272018-11-15 11:58:28 -08002302 * character is returned. If the conversion is successful, NULL is returned.
Emeric Brun39132b22010-01-04 14:57:24 +01002303 */
2304const char *parse_size_err(const char *text, unsigned *ret) {
2305 unsigned value = 0;
2306
Christopher Faulet7f955e62020-12-11 09:30:45 +01002307 if (!isdigit((unsigned char)*text))
2308 return text;
2309
Emeric Brun39132b22010-01-04 14:57:24 +01002310 while (1) {
2311 unsigned int j;
2312
2313 j = *text - '0';
2314 if (j > 9)
2315 break;
2316 if (value > ~0U / 10)
2317 return text;
2318 value *= 10;
2319 if (value > (value + j))
2320 return text;
2321 value += j;
2322 text++;
2323 }
2324
2325 switch (*text) {
2326 case '\0':
2327 break;
2328 case 'K':
2329 case 'k':
2330 if (value > ~0U >> 10)
2331 return text;
2332 value = value << 10;
2333 break;
2334 case 'M':
2335 case 'm':
2336 if (value > ~0U >> 20)
2337 return text;
2338 value = value << 20;
2339 break;
2340 case 'G':
2341 case 'g':
2342 if (value > ~0U >> 30)
2343 return text;
2344 value = value << 30;
2345 break;
2346 default:
2347 return text;
2348 }
2349
Godbach58048a22015-01-28 17:36:16 +08002350 if (*text != '\0' && *++text != '\0')
2351 return text;
2352
Emeric Brun39132b22010-01-04 14:57:24 +01002353 *ret = value;
2354 return NULL;
2355}
2356
Willy Tarreau126d4062013-12-03 17:50:47 +01002357/*
2358 * Parse binary string written in hexadecimal (source) and store the decoded
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002359 * result into binstr and set binstrlen to the length of binstr. Memory for
Willy Tarreau126d4062013-12-03 17:50:47 +01002360 * binstr is allocated by the function. In case of error, returns 0 with an
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002361 * error message in err. In success case, it returns the consumed length.
Willy Tarreau126d4062013-12-03 17:50:47 +01002362 */
2363int parse_binary(const char *source, char **binstr, int *binstrlen, char **err)
2364{
2365 int len;
2366 const char *p = source;
2367 int i,j;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002368 int alloc;
Willy Tarreau126d4062013-12-03 17:50:47 +01002369
2370 len = strlen(source);
2371 if (len % 2) {
2372 memprintf(err, "an even number of hex digit is expected");
2373 return 0;
2374 }
2375
2376 len = len >> 1;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002377
Willy Tarreau126d4062013-12-03 17:50:47 +01002378 if (!*binstr) {
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02002379 *binstr = calloc(len, sizeof(**binstr));
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002380 if (!*binstr) {
2381 memprintf(err, "out of memory while loading string pattern");
2382 return 0;
2383 }
2384 alloc = 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002385 }
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002386 else {
2387 if (*binstrlen < len) {
Joseph Herlant76dbe782018-11-15 12:01:22 -08002388 memprintf(err, "no space available in the buffer. expect %d, provides %d",
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002389 len, *binstrlen);
2390 return 0;
2391 }
2392 alloc = 0;
2393 }
2394 *binstrlen = len;
Willy Tarreau126d4062013-12-03 17:50:47 +01002395
2396 i = j = 0;
2397 while (j < len) {
2398 if (!ishex(p[i++]))
2399 goto bad_input;
2400 if (!ishex(p[i++]))
2401 goto bad_input;
2402 (*binstr)[j++] = (hex2i(p[i-2]) << 4) + hex2i(p[i-1]);
2403 }
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002404 return len << 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002405
2406bad_input:
2407 memprintf(err, "an hex digit is expected (found '%c')", p[i-1]);
Andreas Seltenreich93f91c32016-03-03 20:40:37 +01002408 if (alloc) {
2409 free(*binstr);
2410 *binstr = NULL;
2411 }
Willy Tarreau126d4062013-12-03 17:50:47 +01002412 return 0;
2413}
2414
Willy Tarreau946ba592009-05-10 15:41:18 +02002415/* copies at most <n> characters from <src> and always terminates with '\0' */
2416char *my_strndup(const char *src, int n)
2417{
2418 int len = 0;
2419 char *ret;
2420
2421 while (len < n && src[len])
2422 len++;
2423
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002424 ret = malloc(len + 1);
Willy Tarreau946ba592009-05-10 15:41:18 +02002425 if (!ret)
2426 return ret;
2427 memcpy(ret, src, len);
2428 ret[len] = '\0';
2429 return ret;
2430}
2431
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02002432/*
2433 * search needle in haystack
2434 * returns the pointer if found, returns NULL otherwise
2435 */
2436const void *my_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
2437{
2438 const void *c = NULL;
2439 unsigned char f;
2440
2441 if ((haystack == NULL) || (needle == NULL) || (haystacklen < needlelen))
2442 return NULL;
2443
2444 f = *(char *)needle;
2445 c = haystack;
2446 while ((c = memchr(c, f, haystacklen - (c - haystack))) != NULL) {
2447 if ((haystacklen - (c - haystack)) < needlelen)
2448 return NULL;
2449
2450 if (memcmp(c, needle, needlelen) == 0)
2451 return c;
2452 ++c;
2453 }
2454 return NULL;
2455}
2456
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002457/* get length of the initial segment consisting entirely of bytes in <accept> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002458size_t my_memspn(const void *str, size_t len, const void *accept, size_t acceptlen)
2459{
2460 size_t ret = 0;
2461
2462 while (ret < len && memchr(accept, *((int *)str), acceptlen)) {
2463 str++;
2464 ret++;
2465 }
2466 return ret;
2467}
2468
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002469/* get length of the initial segment consisting entirely of bytes not in <rejcet> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002470size_t my_memcspn(const void *str, size_t len, const void *reject, size_t rejectlen)
2471{
2472 size_t ret = 0;
2473
2474 while (ret < len) {
2475 if(memchr(reject, *((int *)str), rejectlen))
2476 return ret;
2477 str++;
2478 ret++;
2479 }
2480 return ret;
2481}
2482
Willy Tarreau482b00d2009-10-04 22:48:42 +02002483/* This function returns the first unused key greater than or equal to <key> in
2484 * ID tree <root>. Zero is returned if no place is found.
2485 */
2486unsigned int get_next_id(struct eb_root *root, unsigned int key)
2487{
2488 struct eb32_node *used;
2489
2490 do {
2491 used = eb32_lookup_ge(root, key);
2492 if (!used || used->key > key)
2493 return key; /* key is available */
2494 key++;
2495 } while (key);
2496 return key;
2497}
2498
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002499/* dump the full tree to <file> in DOT format for debugging purposes. Will
2500 * optionally highlight node <subj> if found, depending on operation <op> :
2501 * 0 : nothing
2502 * >0 : insertion, node/leaf are surrounded in red
2503 * <0 : removal, node/leaf are dashed with no background
2504 * Will optionally add "desc" as a label on the graph if set and non-null.
2505 */
2506void 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 +01002507{
2508 struct eb32sc_node *node;
2509 unsigned long scope = -1;
2510
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002511 fprintf(file, "digraph ebtree {\n");
2512
2513 if (desc && *desc) {
2514 fprintf(file,
2515 " fontname=\"fixed\";\n"
2516 " fontsize=8;\n"
2517 " label=\"%s\";\n", desc);
2518 }
2519
Willy Tarreaued3cda02017-11-15 15:04:05 +01002520 fprintf(file,
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002521 " node [fontname=\"fixed\" fontsize=8 shape=\"box\" style=\"filled\" color=\"black\" fillcolor=\"white\"];\n"
2522 " edge [fontname=\"fixed\" fontsize=8 style=\"solid\" color=\"magenta\" dir=\"forward\"];\n"
Willy Tarreaued3cda02017-11-15 15:04:05 +01002523 " \"%lx_n\" [label=\"root\\n%lx\"]\n", (long)eb_root_to_node(root), (long)root
2524 );
2525
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002526 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002527 (long)eb_root_to_node(root),
2528 (long)eb_root_to_node(eb_clrtag(root->b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002529 eb_gettag(root->b[0]) == EB_LEAF ? 'l' : 'n');
2530
2531 node = eb32sc_first(root, scope);
2532 while (node) {
2533 if (node->node.node_p) {
2534 /* node part is used */
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002535 fprintf(file, " \"%lx_n\" [label=\"%lx\\nkey=%u\\nscope=%lx\\nbit=%d\" fillcolor=\"lightskyblue1\" %s];\n",
2536 (long)node, (long)node, node->key, node->node_s, node->node.bit,
2537 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002538
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002539 fprintf(file, " \"%lx_n\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002540 (long)node,
2541 (long)eb_root_to_node(eb_clrtag(node->node.node_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002542 eb_gettag(node->node.node_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002543
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002544 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002545 (long)node,
2546 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002547 eb_gettag(node->node.branches.b[0]) == EB_LEAF ? 'l' : 'n');
2548
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002549 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"R\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002550 (long)node,
2551 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[1])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002552 eb_gettag(node->node.branches.b[1]) == EB_LEAF ? 'l' : 'n');
2553 }
2554
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002555 fprintf(file, " \"%lx_l\" [label=\"%lx\\nkey=%u\\nscope=%lx\\npfx=%u\" fillcolor=\"yellow\" %s];\n",
2556 (long)node, (long)node, node->key, node->leaf_s, node->node.pfx,
2557 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002558
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002559 fprintf(file, " \"%lx_l\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002560 (long)node,
2561 (long)eb_root_to_node(eb_clrtag(node->node.leaf_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002562 eb_gettag(node->node.leaf_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002563 node = eb32sc_next(node, scope);
2564 }
2565 fprintf(file, "}\n");
2566}
2567
Willy Tarreau348238b2010-01-18 15:05:57 +01002568/* This function compares a sample word possibly followed by blanks to another
2569 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
2570 * otherwise zero. This intends to be used when checking HTTP headers for some
2571 * values. Note that it validates a word followed only by blanks but does not
2572 * validate a word followed by blanks then other chars.
2573 */
2574int word_match(const char *sample, int slen, const char *word, int wlen)
2575{
2576 if (slen < wlen)
2577 return 0;
2578
2579 while (wlen) {
2580 char c = *sample ^ *word;
2581 if (c && c != ('A' ^ 'a'))
2582 return 0;
2583 sample++;
2584 word++;
2585 slen--;
2586 wlen--;
2587 }
2588
2589 while (slen) {
2590 if (*sample != ' ' && *sample != '\t')
2591 return 0;
2592 sample++;
2593 slen--;
2594 }
2595 return 1;
2596}
Willy Tarreau482b00d2009-10-04 22:48:42 +02002597
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002598/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
2599 * is particularly fast because it avoids expensive operations such as
2600 * multiplies, which are optimized away at the end. It requires a properly
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002601 * formatted address though (3 points).
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002602 */
2603unsigned int inetaddr_host(const char *text)
2604{
2605 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2606 register unsigned int dig100, dig10, dig1;
2607 int s;
2608 const char *p, *d;
2609
2610 dig1 = dig10 = dig100 = ascii_zero;
2611 s = 24;
2612
2613 p = text;
2614 while (1) {
2615 if (((unsigned)(*p - '0')) <= 9) {
2616 p++;
2617 continue;
2618 }
2619
2620 /* here, we have a complete byte between <text> and <p> (exclusive) */
2621 if (p == text)
2622 goto end;
2623
2624 d = p - 1;
2625 dig1 |= (unsigned int)(*d << s);
2626 if (d == text)
2627 goto end;
2628
2629 d--;
2630 dig10 |= (unsigned int)(*d << s);
2631 if (d == text)
2632 goto end;
2633
2634 d--;
2635 dig100 |= (unsigned int)(*d << s);
2636 end:
2637 if (!s || *p != '.')
2638 break;
2639
2640 s -= 8;
2641 text = ++p;
2642 }
2643
2644 dig100 -= ascii_zero;
2645 dig10 -= ascii_zero;
2646 dig1 -= ascii_zero;
2647 return ((dig100 * 10) + dig10) * 10 + dig1;
2648}
2649
2650/*
2651 * Idem except the first unparsed character has to be passed in <stop>.
2652 */
2653unsigned int inetaddr_host_lim(const char *text, const char *stop)
2654{
2655 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2656 register unsigned int dig100, dig10, dig1;
2657 int s;
2658 const char *p, *d;
2659
2660 dig1 = dig10 = dig100 = ascii_zero;
2661 s = 24;
2662
2663 p = text;
2664 while (1) {
2665 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2666 p++;
2667 continue;
2668 }
2669
2670 /* here, we have a complete byte between <text> and <p> (exclusive) */
2671 if (p == text)
2672 goto end;
2673
2674 d = p - 1;
2675 dig1 |= (unsigned int)(*d << s);
2676 if (d == text)
2677 goto end;
2678
2679 d--;
2680 dig10 |= (unsigned int)(*d << s);
2681 if (d == text)
2682 goto end;
2683
2684 d--;
2685 dig100 |= (unsigned int)(*d << s);
2686 end:
2687 if (!s || p == stop || *p != '.')
2688 break;
2689
2690 s -= 8;
2691 text = ++p;
2692 }
2693
2694 dig100 -= ascii_zero;
2695 dig10 -= ascii_zero;
2696 dig1 -= ascii_zero;
2697 return ((dig100 * 10) + dig10) * 10 + dig1;
2698}
2699
2700/*
2701 * Idem except the pointer to first unparsed byte is returned into <ret> which
2702 * must not be NULL.
2703 */
Willy Tarreau74172752010-10-15 23:21:42 +02002704unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002705{
2706 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2707 register unsigned int dig100, dig10, dig1;
2708 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02002709 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002710
2711 dig1 = dig10 = dig100 = ascii_zero;
2712 s = 24;
2713
2714 p = text;
2715 while (1) {
2716 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2717 p++;
2718 continue;
2719 }
2720
2721 /* here, we have a complete byte between <text> and <p> (exclusive) */
2722 if (p == text)
2723 goto end;
2724
2725 d = p - 1;
2726 dig1 |= (unsigned int)(*d << s);
2727 if (d == text)
2728 goto end;
2729
2730 d--;
2731 dig10 |= (unsigned int)(*d << s);
2732 if (d == text)
2733 goto end;
2734
2735 d--;
2736 dig100 |= (unsigned int)(*d << s);
2737 end:
2738 if (!s || p == stop || *p != '.')
2739 break;
2740
2741 s -= 8;
2742 text = ++p;
2743 }
2744
2745 *ret = p;
2746 dig100 -= ascii_zero;
2747 dig10 -= ascii_zero;
2748 dig1 -= ascii_zero;
2749 return ((dig100 * 10) + dig10) * 10 + dig1;
2750}
2751
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002752/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
2753 * or the number of chars read in case of success. Maybe this could be replaced
2754 * by one of the functions above. Also, apparently this function does not support
2755 * hosts above 255 and requires exactly 4 octets.
Willy Tarreau075415a2013-12-12 11:29:39 +01002756 * The destination is only modified on success.
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002757 */
2758int buf2ip(const char *buf, size_t len, struct in_addr *dst)
2759{
2760 const char *addr;
2761 int saw_digit, octets, ch;
2762 u_char tmp[4], *tp;
2763 const char *cp = buf;
2764
2765 saw_digit = 0;
2766 octets = 0;
2767 *(tp = tmp) = 0;
2768
2769 for (addr = buf; addr - buf < len; addr++) {
2770 unsigned char digit = (ch = *addr) - '0';
2771
2772 if (digit > 9 && ch != '.')
2773 break;
2774
2775 if (digit <= 9) {
2776 u_int new = *tp * 10 + digit;
2777
2778 if (new > 255)
2779 return 0;
2780
2781 *tp = new;
2782
2783 if (!saw_digit) {
2784 if (++octets > 4)
2785 return 0;
2786 saw_digit = 1;
2787 }
2788 } else if (ch == '.' && saw_digit) {
2789 if (octets == 4)
2790 return 0;
2791
2792 *++tp = 0;
2793 saw_digit = 0;
2794 } else
2795 return 0;
2796 }
2797
2798 if (octets < 4)
2799 return 0;
2800
2801 memcpy(&dst->s_addr, tmp, 4);
2802 return addr - cp;
2803}
2804
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002805/* This function converts the string in <buf> of the len <len> to
2806 * struct in6_addr <dst> which must be allocated by the caller.
2807 * This function returns 1 in success case, otherwise zero.
Willy Tarreau075415a2013-12-12 11:29:39 +01002808 * The destination is only modified on success.
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002809 */
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002810int buf2ip6(const char *buf, size_t len, struct in6_addr *dst)
2811{
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002812 char null_term_ip6[INET6_ADDRSTRLEN + 1];
Willy Tarreau075415a2013-12-12 11:29:39 +01002813 struct in6_addr out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002814
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002815 if (len > INET6_ADDRSTRLEN)
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002816 return 0;
2817
2818 memcpy(null_term_ip6, buf, len);
2819 null_term_ip6[len] = '\0';
2820
Willy Tarreau075415a2013-12-12 11:29:39 +01002821 if (!inet_pton(AF_INET6, null_term_ip6, &out))
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002822 return 0;
2823
Willy Tarreau075415a2013-12-12 11:29:39 +01002824 *dst = out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002825 return 1;
2826}
2827
Willy Tarreauacf95772010-06-14 19:09:21 +02002828/* To be used to quote config arg positions. Returns the short string at <ptr>
2829 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
2830 * if ptr is NULL or empty. The string is locally allocated.
2831 */
2832const char *quote_arg(const char *ptr)
2833{
Christopher Faulet1bc04c72017-10-29 20:14:08 +01002834 static THREAD_LOCAL char val[32];
Willy Tarreauacf95772010-06-14 19:09:21 +02002835 int i;
2836
2837 if (!ptr || !*ptr)
2838 return "end of line";
2839 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01002840 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02002841 val[i] = *ptr++;
2842 val[i++] = '\'';
2843 val[i] = '\0';
2844 return val;
2845}
2846
Willy Tarreau5b180202010-07-18 10:40:48 +02002847/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
2848int get_std_op(const char *str)
2849{
2850 int ret = -1;
2851
2852 if (*str == 'e' && str[1] == 'q')
2853 ret = STD_OP_EQ;
2854 else if (*str == 'n' && str[1] == 'e')
2855 ret = STD_OP_NE;
2856 else if (*str == 'l') {
2857 if (str[1] == 'e') ret = STD_OP_LE;
2858 else if (str[1] == 't') ret = STD_OP_LT;
2859 }
2860 else if (*str == 'g') {
2861 if (str[1] == 'e') ret = STD_OP_GE;
2862 else if (str[1] == 't') ret = STD_OP_GT;
2863 }
2864
2865 if (ret == -1 || str[2] != '\0')
2866 return -1;
2867 return ret;
2868}
2869
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01002870/* hash a 32-bit integer to another 32-bit integer */
2871unsigned int full_hash(unsigned int a)
2872{
2873 return __full_hash(a);
2874}
2875
Willy Tarreauf3241112019-02-26 09:56:22 +01002876/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
2877 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
2878 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
2879 * a popcount variant and is described here :
2880 * https://graphics.stanford.edu/~seander/bithacks.html
2881 */
2882unsigned int mask_find_rank_bit(unsigned int r, unsigned long m)
2883{
2884 unsigned long a, b, c, d;
2885 unsigned int s;
2886 unsigned int t;
2887
2888 a = m - ((m >> 1) & ~0UL/3);
2889 b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
2890 c = (b + (b >> 4)) & ~0UL/0x11;
2891 d = (c + (c >> 8)) & ~0UL/0x101;
2892
2893 r++; // make r be 1..64
2894
2895 t = 0;
2896 s = LONGBITS;
2897 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002898 unsigned long d2 = (d >> 16) >> 16;
2899 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002900 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2901 }
2902
2903 t = (d >> (s - 16)) & 0xff;
2904 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2905 t = (c >> (s - 8)) & 0xf;
2906 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
2907 t = (b >> (s - 4)) & 0x7;
2908 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
2909 t = (a >> (s - 2)) & 0x3;
2910 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
2911 t = (m >> (s - 1)) & 0x1;
2912 s -= ((t - r) & 256) >> 8;
2913
2914 return s - 1;
2915}
2916
2917/* Same as mask_find_rank_bit() above but makes use of pre-computed bitmaps
2918 * based on <m>, in <a..d>. These ones must be updated whenever <m> changes
2919 * using mask_prep_rank_map() below.
2920 */
2921unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
2922 unsigned long a, unsigned long b,
2923 unsigned long c, unsigned long d)
2924{
2925 unsigned int s;
2926 unsigned int t;
2927
2928 r++; // make r be 1..64
2929
2930 t = 0;
2931 s = LONGBITS;
2932 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002933 unsigned long d2 = (d >> 16) >> 16;
2934 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002935 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2936 }
2937
2938 t = (d >> (s - 16)) & 0xff;
2939 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2940 t = (c >> (s - 8)) & 0xf;
2941 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
2942 t = (b >> (s - 4)) & 0x7;
2943 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
2944 t = (a >> (s - 2)) & 0x3;
2945 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
2946 t = (m >> (s - 1)) & 0x1;
2947 s -= ((t - r) & 256) >> 8;
2948
2949 return s - 1;
2950}
2951
2952/* Prepare the bitmaps used by the fast implementation of the find_rank_bit()
2953 * above.
2954 */
2955void mask_prep_rank_map(unsigned long m,
2956 unsigned long *a, unsigned long *b,
2957 unsigned long *c, unsigned long *d)
2958{
2959 *a = m - ((m >> 1) & ~0UL/3);
2960 *b = (*a & ~0UL/5) + ((*a >> 2) & ~0UL/5);
2961 *c = (*b + (*b >> 4)) & ~0UL/0x11;
2962 *d = (*c + (*c >> 8)) & ~0UL/0x101;
2963}
2964
David du Colombier4f92d322011-03-24 11:09:31 +01002965/* Return non-zero if IPv4 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02002966 * otherwise zero. Note that <addr> may not necessarily be aligned
2967 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01002968 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02002969int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01002970{
Willy Tarreaueec1d382016-07-13 11:59:39 +02002971 struct in_addr addr_copy;
2972
2973 memcpy(&addr_copy, addr, sizeof(addr_copy));
2974 return((addr_copy.s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
David du Colombier4f92d322011-03-24 11:09:31 +01002975}
2976
2977/* Return non-zero if IPv6 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02002978 * otherwise zero. Note that <addr> may not necessarily be aligned
2979 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01002980 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02002981int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01002982{
2983 int i;
Willy Tarreaueec1d382016-07-13 11:59:39 +02002984 struct in6_addr addr_copy;
David du Colombier4f92d322011-03-24 11:09:31 +01002985
Willy Tarreaueec1d382016-07-13 11:59:39 +02002986 memcpy(&addr_copy, addr, sizeof(addr_copy));
David du Colombier4f92d322011-03-24 11:09:31 +01002987 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
Willy Tarreaueec1d382016-07-13 11:59:39 +02002988 if (((((int *)&addr_copy)[i] & ((int *)mask)[i])) !=
David du Colombier4f92d322011-03-24 11:09:31 +01002989 (((int *)net)[i] & ((int *)mask)[i]))
2990 return 0;
2991 return 1;
2992}
2993
2994/* RFC 4291 prefix */
2995const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
2996 0x00, 0x00, 0x00, 0x00,
2997 0x00, 0x00, 0xFF, 0xFF };
2998
Joseph Herlant32b83272018-11-15 11:58:28 -08002999/* Map IPv4 address on IPv6 address, as specified in RFC 3513.
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003000 * Input and output may overlap.
3001 */
David du Colombier4f92d322011-03-24 11:09:31 +01003002void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
3003{
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003004 struct in_addr tmp_addr;
3005
3006 tmp_addr.s_addr = sin_addr->s_addr;
David du Colombier4f92d322011-03-24 11:09:31 +01003007 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003008 memcpy(sin6_addr->s6_addr+12, &tmp_addr.s_addr, 4);
David du Colombier4f92d322011-03-24 11:09:31 +01003009}
3010
Joseph Herlant32b83272018-11-15 11:58:28 -08003011/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01003012 * Return true if conversion is possible and false otherwise.
3013 */
3014int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
3015{
3016 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
3017 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
3018 sizeof(struct in_addr));
3019 return 1;
3020 }
3021
3022 return 0;
3023}
3024
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01003025/* compare two struct sockaddr_storage and return:
3026 * 0 (true) if the addr is the same in both
3027 * 1 (false) if the addr is not the same in both
3028 * -1 (unable) if one of the addr is not AF_INET*
3029 */
3030int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2)
3031{
3032 if ((ss1->ss_family != AF_INET) && (ss1->ss_family != AF_INET6))
3033 return -1;
3034
3035 if ((ss2->ss_family != AF_INET) && (ss2->ss_family != AF_INET6))
3036 return -1;
3037
3038 if (ss1->ss_family != ss2->ss_family)
3039 return 1;
3040
3041 switch (ss1->ss_family) {
3042 case AF_INET:
3043 return memcmp(&((struct sockaddr_in *)ss1)->sin_addr,
3044 &((struct sockaddr_in *)ss2)->sin_addr,
3045 sizeof(struct in_addr)) != 0;
3046 case AF_INET6:
3047 return memcmp(&((struct sockaddr_in6 *)ss1)->sin6_addr,
3048 &((struct sockaddr_in6 *)ss2)->sin6_addr,
3049 sizeof(struct in6_addr)) != 0;
3050 }
3051
3052 return 1;
3053}
3054
Baptiste Assmann08396c82016-01-31 00:27:17 +01003055/* copy IP address from <source> into <dest>
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003056 * The caller must allocate and clear <dest> before calling.
3057 * The source must be in either AF_INET or AF_INET6 family, or the destination
3058 * address will be undefined. If the destination address used to hold a port,
3059 * it is preserved, so that this function can be used to switch to another
3060 * address family with no risk. Returns a pointer to the destination.
Baptiste Assmann08396c82016-01-31 00:27:17 +01003061 */
3062struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest)
3063{
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003064 int prev_port;
3065
3066 prev_port = get_net_port(dest);
3067 memset(dest, 0, sizeof(*dest));
Baptiste Assmann08396c82016-01-31 00:27:17 +01003068 dest->ss_family = source->ss_family;
3069
3070 /* copy new addr and apply it */
3071 switch (source->ss_family) {
3072 case AF_INET:
3073 ((struct sockaddr_in *)dest)->sin_addr.s_addr = ((struct sockaddr_in *)source)->sin_addr.s_addr;
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003074 ((struct sockaddr_in *)dest)->sin_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003075 break;
3076 case AF_INET6:
3077 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 +01003078 ((struct sockaddr_in6 *)dest)->sin6_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003079 break;
3080 }
3081
3082 return dest;
3083}
3084
William Lallemand421f5b52012-02-06 18:15:57 +01003085char *human_time(int t, short hz_div) {
3086 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
3087 char *p = rv;
Willy Tarreau761b3d52014-04-14 14:53:06 +02003088 char *end = rv + sizeof(rv);
William Lallemand421f5b52012-02-06 18:15:57 +01003089 int cnt=2; // print two numbers
3090
3091 if (unlikely(t < 0 || hz_div <= 0)) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003092 snprintf(p, end - p, "?");
William Lallemand421f5b52012-02-06 18:15:57 +01003093 return rv;
3094 }
3095
3096 if (unlikely(hz_div > 1))
3097 t /= hz_div;
3098
3099 if (t >= DAY) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003100 p += snprintf(p, end - p, "%dd", t / DAY);
William Lallemand421f5b52012-02-06 18:15:57 +01003101 cnt--;
3102 }
3103
3104 if (cnt && t % DAY / HOUR) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003105 p += snprintf(p, end - p, "%dh", t % DAY / HOUR);
William Lallemand421f5b52012-02-06 18:15:57 +01003106 cnt--;
3107 }
3108
3109 if (cnt && t % HOUR / MINUTE) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003110 p += snprintf(p, end - p, "%dm", t % HOUR / MINUTE);
William Lallemand421f5b52012-02-06 18:15:57 +01003111 cnt--;
3112 }
3113
3114 if ((cnt && t % MINUTE) || !t) // also display '0s'
Willy Tarreau761b3d52014-04-14 14:53:06 +02003115 p += snprintf(p, end - p, "%ds", t % MINUTE / SEC);
William Lallemand421f5b52012-02-06 18:15:57 +01003116
3117 return rv;
3118}
3119
3120const char *monthname[12] = {
3121 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3122 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
3123};
3124
3125/* date2str_log: write a date in the format :
3126 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
3127 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3128 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
3129 *
3130 * without using sprintf. return a pointer to the last char written (\0) or
3131 * NULL if there isn't enough space.
3132 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02003133char *date2str_log(char *dst, const struct tm *tm, const struct timeval *date, size_t size)
William Lallemand421f5b52012-02-06 18:15:57 +01003134{
3135
3136 if (size < 25) /* the size is fixed: 24 chars + \0 */
3137 return NULL;
3138
3139 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003140 if (!dst)
3141 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003142 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003143
William Lallemand421f5b52012-02-06 18:15:57 +01003144 memcpy(dst, monthname[tm->tm_mon], 3); // month
3145 dst += 3;
3146 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003147
William Lallemand421f5b52012-02-06 18:15:57 +01003148 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003149 if (!dst)
3150 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003151 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003152
William Lallemand421f5b52012-02-06 18:15:57 +01003153 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003154 if (!dst)
3155 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003156 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003157
William Lallemand421f5b52012-02-06 18:15:57 +01003158 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003159 if (!dst)
3160 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003161 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003162
William Lallemand421f5b52012-02-06 18:15:57 +01003163 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003164 if (!dst)
3165 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003166 *dst++ = '.';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003167
Willy Tarreau7d9421d2020-02-29 09:08:02 +01003168 dst = utoa_pad((unsigned int)(date->tv_usec/1000)%1000, dst, 4); // milliseconds
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003169 if (!dst)
3170 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003171 *dst = '\0';
3172
3173 return dst;
3174}
3175
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003176/* Base year used to compute leap years */
3177#define TM_YEAR_BASE 1900
3178
3179/* Return the difference in seconds between two times (leap seconds are ignored).
3180 * Retrieved from glibc 2.18 source code.
3181 */
3182static int my_tm_diff(const struct tm *a, const struct tm *b)
3183{
3184 /* Compute intervening leap days correctly even if year is negative.
3185 * Take care to avoid int overflow in leap day calculations,
3186 * but it's OK to assume that A and B are close to each other.
3187 */
3188 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
3189 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
3190 int a100 = a4 / 25 - (a4 % 25 < 0);
3191 int b100 = b4 / 25 - (b4 % 25 < 0);
3192 int a400 = a100 >> 2;
3193 int b400 = b100 >> 2;
3194 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
3195 int years = a->tm_year - b->tm_year;
3196 int days = (365 * years + intervening_leap_days
3197 + (a->tm_yday - b->tm_yday));
3198 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
3199 + (a->tm_min - b->tm_min))
3200 + (a->tm_sec - b->tm_sec));
3201}
3202
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003203/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003204 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003205 * The string returned has the same format as returned by strftime(... "%z", tm).
3206 * Offsets are kept in an internal cache for better performances.
3207 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003208const char *get_gmt_offset(time_t t, struct tm *tm)
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003209{
3210 /* Cache offsets from GMT (depending on whether DST is active or not) */
Christopher Faulet1bc04c72017-10-29 20:14:08 +01003211 static THREAD_LOCAL char gmt_offsets[2][5+1] = { "", "" };
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003212
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003213 char *gmt_offset;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003214 struct tm tm_gmt;
3215 int diff;
3216 int isdst = tm->tm_isdst;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003217
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003218 /* Pretend DST not active if its status is unknown */
3219 if (isdst < 0)
3220 isdst = 0;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003221
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003222 /* Fetch the offset and initialize it if needed */
3223 gmt_offset = gmt_offsets[isdst & 0x01];
3224 if (unlikely(!*gmt_offset)) {
3225 get_gmtime(t, &tm_gmt);
3226 diff = my_tm_diff(tm, &tm_gmt);
3227 if (diff < 0) {
3228 diff = -diff;
3229 *gmt_offset = '-';
3230 } else {
3231 *gmt_offset = '+';
3232 }
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003233 diff %= 86400U;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003234 diff /= 60; /* Convert to minutes */
3235 snprintf(gmt_offset+1, 4+1, "%02d%02d", diff/60, diff%60);
3236 }
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003237
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003238 return gmt_offset;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003239}
3240
William Lallemand421f5b52012-02-06 18:15:57 +01003241/* gmt2str_log: write a date in the format :
3242 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
3243 * return a pointer to the last char written (\0) or
3244 * NULL if there isn't enough space.
3245 */
3246char *gmt2str_log(char *dst, struct tm *tm, size_t size)
3247{
Yuxans Yao4e25b012012-10-19 10:36:09 +08003248 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01003249 return NULL;
3250
3251 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003252 if (!dst)
3253 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003254 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003255
William Lallemand421f5b52012-02-06 18:15:57 +01003256 memcpy(dst, monthname[tm->tm_mon], 3); // month
3257 dst += 3;
3258 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003259
William Lallemand421f5b52012-02-06 18:15:57 +01003260 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003261 if (!dst)
3262 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003263 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003264
William Lallemand421f5b52012-02-06 18:15:57 +01003265 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003266 if (!dst)
3267 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003268 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003269
William Lallemand421f5b52012-02-06 18:15:57 +01003270 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003271 if (!dst)
3272 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003273 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003274
William Lallemand421f5b52012-02-06 18:15:57 +01003275 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003276 if (!dst)
3277 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003278 *dst++ = ' ';
3279 *dst++ = '+';
3280 *dst++ = '0';
3281 *dst++ = '0';
3282 *dst++ = '0';
3283 *dst++ = '0';
3284 *dst = '\0';
3285
3286 return dst;
3287}
3288
Yuxans Yao4e25b012012-10-19 10:36:09 +08003289/* localdate2str_log: write a date in the format :
3290 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003291 * Both t and tm must represent the same time.
3292 * return a pointer to the last char written (\0) or
3293 * NULL if there isn't enough space.
Yuxans Yao4e25b012012-10-19 10:36:09 +08003294 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003295char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size)
Yuxans Yao4e25b012012-10-19 10:36:09 +08003296{
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003297 const char *gmt_offset;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003298 if (size < 27) /* the size is fixed: 26 chars + \0 */
3299 return NULL;
3300
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003301 gmt_offset = get_gmt_offset(t, tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003302
Yuxans Yao4e25b012012-10-19 10:36:09 +08003303 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003304 if (!dst)
3305 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003306 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003307
Yuxans Yao4e25b012012-10-19 10:36:09 +08003308 memcpy(dst, monthname[tm->tm_mon], 3); // month
3309 dst += 3;
3310 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003311
Yuxans Yao4e25b012012-10-19 10:36:09 +08003312 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003313 if (!dst)
3314 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003315 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003316
Yuxans Yao4e25b012012-10-19 10:36:09 +08003317 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003318 if (!dst)
3319 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003320 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003321
Yuxans Yao4e25b012012-10-19 10:36:09 +08003322 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003323 if (!dst)
3324 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003325 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003326
Yuxans Yao4e25b012012-10-19 10:36:09 +08003327 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003328 if (!dst)
3329 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003330 *dst++ = ' ';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003331
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003332 memcpy(dst, gmt_offset, 5); // Offset from local time to GMT
Yuxans Yao4e25b012012-10-19 10:36:09 +08003333 dst += 5;
3334 *dst = '\0';
3335
3336 return dst;
3337}
3338
Willy Tarreaucb1949b2017-07-19 19:05:29 +02003339/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
3340 * It is meant as a portable replacement for timegm() for use with valid inputs.
3341 * Returns undefined results for invalid dates (eg: months out of range 0..11).
3342 */
3343time_t my_timegm(const struct tm *tm)
3344{
3345 /* Each month has 28, 29, 30 or 31 days, or 28+N. The date in the year
3346 * is thus (current month - 1)*28 + cumulated_N[month] to count the
3347 * sum of the extra N days for elapsed months. The sum of all these N
3348 * days doesn't exceed 30 for a complete year (366-12*28) so it fits
3349 * in a 5-bit word. This means that with 60 bits we can represent a
3350 * matrix of all these values at once, which is fast and efficient to
3351 * access. The extra February day for leap years is not counted here.
3352 *
3353 * Jan : none = 0 (0)
3354 * Feb : Jan = 3 (3)
3355 * Mar : Jan..Feb = 3 (3 + 0)
3356 * Apr : Jan..Mar = 6 (3 + 0 + 3)
3357 * May : Jan..Apr = 8 (3 + 0 + 3 + 2)
3358 * Jun : Jan..May = 11 (3 + 0 + 3 + 2 + 3)
3359 * Jul : Jan..Jun = 13 (3 + 0 + 3 + 2 + 3 + 2)
3360 * Aug : Jan..Jul = 16 (3 + 0 + 3 + 2 + 3 + 2 + 3)
3361 * Sep : Jan..Aug = 19 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3)
3362 * Oct : Jan..Sep = 21 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2)
3363 * Nov : Jan..Oct = 24 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3)
3364 * Dec : Jan..Nov = 26 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3 + 2)
3365 */
3366 uint64_t extra =
3367 ( 0ULL << 0*5) + ( 3ULL << 1*5) + ( 3ULL << 2*5) + /* Jan, Feb, Mar, */
3368 ( 6ULL << 3*5) + ( 8ULL << 4*5) + (11ULL << 5*5) + /* Apr, May, Jun, */
3369 (13ULL << 6*5) + (16ULL << 7*5) + (19ULL << 8*5) + /* Jul, Aug, Sep, */
3370 (21ULL << 9*5) + (24ULL << 10*5) + (26ULL << 11*5); /* Oct, Nov, Dec, */
3371
3372 unsigned int y = tm->tm_year + 1900;
3373 unsigned int m = tm->tm_mon;
3374 unsigned long days = 0;
3375
3376 /* days since 1/1/1970 for full years */
3377 days += days_since_zero(y) - days_since_zero(1970);
3378
3379 /* days for full months in the current year */
3380 days += 28 * m + ((extra >> (m * 5)) & 0x1f);
3381
3382 /* count + 1 after March for leap years. A leap year is a year multiple
3383 * of 4, unless it's multiple of 100 without being multiple of 400. 2000
3384 * is leap, 1900 isn't, 1904 is.
3385 */
3386 if ((m > 1) && !(y & 3) && ((y % 100) || !(y % 400)))
3387 days++;
3388
3389 days += tm->tm_mday - 1;
3390 return days * 86400ULL + tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
3391}
3392
Thierry Fournier93127942016-01-20 18:49:45 +01003393/* This function check a char. It returns true and updates
3394 * <date> and <len> pointer to the new position if the
3395 * character is found.
3396 */
3397static inline int parse_expect_char(const char **date, int *len, char c)
3398{
3399 if (*len < 1 || **date != c)
3400 return 0;
3401 (*len)--;
3402 (*date)++;
3403 return 1;
3404}
3405
3406/* This function expects a string <str> of len <l>. It return true and updates.
3407 * <date> and <len> if the string matches, otherwise, it returns false.
3408 */
3409static inline int parse_strcmp(const char **date, int *len, char *str, int l)
3410{
3411 if (*len < l || strncmp(*date, str, l) != 0)
3412 return 0;
3413 (*len) -= l;
3414 (*date) += l;
3415 return 1;
3416}
3417
3418/* This macro converts 3 chars name in integer. */
3419#define STR2I3(__a, __b, __c) ((__a) * 65536 + (__b) * 256 + (__c))
3420
3421/* day-name = %x4D.6F.6E ; "Mon", case-sensitive
3422 * / %x54.75.65 ; "Tue", case-sensitive
3423 * / %x57.65.64 ; "Wed", case-sensitive
3424 * / %x54.68.75 ; "Thu", case-sensitive
3425 * / %x46.72.69 ; "Fri", case-sensitive
3426 * / %x53.61.74 ; "Sat", case-sensitive
3427 * / %x53.75.6E ; "Sun", case-sensitive
3428 *
3429 * This array must be alphabetically sorted
3430 */
3431static inline int parse_http_dayname(const char **date, int *len, struct tm *tm)
3432{
3433 if (*len < 3)
3434 return 0;
3435 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3436 case STR2I3('M','o','n'): tm->tm_wday = 1; break;
3437 case STR2I3('T','u','e'): tm->tm_wday = 2; break;
3438 case STR2I3('W','e','d'): tm->tm_wday = 3; break;
3439 case STR2I3('T','h','u'): tm->tm_wday = 4; break;
3440 case STR2I3('F','r','i'): tm->tm_wday = 5; break;
3441 case STR2I3('S','a','t'): tm->tm_wday = 6; break;
3442 case STR2I3('S','u','n'): tm->tm_wday = 7; break;
3443 default: return 0;
3444 }
3445 *len -= 3;
3446 *date += 3;
3447 return 1;
3448}
3449
3450/* month = %x4A.61.6E ; "Jan", case-sensitive
3451 * / %x46.65.62 ; "Feb", case-sensitive
3452 * / %x4D.61.72 ; "Mar", case-sensitive
3453 * / %x41.70.72 ; "Apr", case-sensitive
3454 * / %x4D.61.79 ; "May", case-sensitive
3455 * / %x4A.75.6E ; "Jun", case-sensitive
3456 * / %x4A.75.6C ; "Jul", case-sensitive
3457 * / %x41.75.67 ; "Aug", case-sensitive
3458 * / %x53.65.70 ; "Sep", case-sensitive
3459 * / %x4F.63.74 ; "Oct", case-sensitive
3460 * / %x4E.6F.76 ; "Nov", case-sensitive
3461 * / %x44.65.63 ; "Dec", case-sensitive
3462 *
3463 * This array must be alphabetically sorted
3464 */
3465static inline int parse_http_monthname(const char **date, int *len, struct tm *tm)
3466{
3467 if (*len < 3)
3468 return 0;
3469 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3470 case STR2I3('J','a','n'): tm->tm_mon = 0; break;
3471 case STR2I3('F','e','b'): tm->tm_mon = 1; break;
3472 case STR2I3('M','a','r'): tm->tm_mon = 2; break;
3473 case STR2I3('A','p','r'): tm->tm_mon = 3; break;
3474 case STR2I3('M','a','y'): tm->tm_mon = 4; break;
3475 case STR2I3('J','u','n'): tm->tm_mon = 5; break;
3476 case STR2I3('J','u','l'): tm->tm_mon = 6; break;
3477 case STR2I3('A','u','g'): tm->tm_mon = 7; break;
3478 case STR2I3('S','e','p'): tm->tm_mon = 8; break;
3479 case STR2I3('O','c','t'): tm->tm_mon = 9; break;
3480 case STR2I3('N','o','v'): tm->tm_mon = 10; break;
3481 case STR2I3('D','e','c'): tm->tm_mon = 11; break;
3482 default: return 0;
3483 }
3484 *len -= 3;
3485 *date += 3;
3486 return 1;
3487}
3488
3489/* day-name-l = %x4D.6F.6E.64.61.79 ; "Monday", case-sensitive
3490 * / %x54.75.65.73.64.61.79 ; "Tuesday", case-sensitive
3491 * / %x57.65.64.6E.65.73.64.61.79 ; "Wednesday", case-sensitive
3492 * / %x54.68.75.72.73.64.61.79 ; "Thursday", case-sensitive
3493 * / %x46.72.69.64.61.79 ; "Friday", case-sensitive
3494 * / %x53.61.74.75.72.64.61.79 ; "Saturday", case-sensitive
3495 * / %x53.75.6E.64.61.79 ; "Sunday", case-sensitive
3496 *
3497 * This array must be alphabetically sorted
3498 */
3499static inline int parse_http_ldayname(const char **date, int *len, struct tm *tm)
3500{
3501 if (*len < 6) /* Minimum length. */
3502 return 0;
3503 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3504 case STR2I3('M','o','n'):
3505 RET0_UNLESS(parse_strcmp(date, len, "Monday", 6));
3506 tm->tm_wday = 1;
3507 return 1;
3508 case STR2I3('T','u','e'):
3509 RET0_UNLESS(parse_strcmp(date, len, "Tuesday", 7));
3510 tm->tm_wday = 2;
3511 return 1;
3512 case STR2I3('W','e','d'):
3513 RET0_UNLESS(parse_strcmp(date, len, "Wednesday", 9));
3514 tm->tm_wday = 3;
3515 return 1;
3516 case STR2I3('T','h','u'):
3517 RET0_UNLESS(parse_strcmp(date, len, "Thursday", 8));
3518 tm->tm_wday = 4;
3519 return 1;
3520 case STR2I3('F','r','i'):
3521 RET0_UNLESS(parse_strcmp(date, len, "Friday", 6));
3522 tm->tm_wday = 5;
3523 return 1;
3524 case STR2I3('S','a','t'):
3525 RET0_UNLESS(parse_strcmp(date, len, "Saturday", 8));
3526 tm->tm_wday = 6;
3527 return 1;
3528 case STR2I3('S','u','n'):
3529 RET0_UNLESS(parse_strcmp(date, len, "Sunday", 6));
3530 tm->tm_wday = 7;
3531 return 1;
3532 }
3533 return 0;
3534}
3535
3536/* This function parses exactly 1 digit and returns the numeric value in "digit". */
3537static inline int parse_digit(const char **date, int *len, int *digit)
3538{
3539 if (*len < 1 || **date < '0' || **date > '9')
3540 return 0;
3541 *digit = (**date - '0');
3542 (*date)++;
3543 (*len)--;
3544 return 1;
3545}
3546
3547/* This function parses exactly 2 digits and returns the numeric value in "digit". */
3548static inline int parse_2digit(const char **date, int *len, int *digit)
3549{
3550 int value;
3551
3552 RET0_UNLESS(parse_digit(date, len, &value));
3553 (*digit) = value * 10;
3554 RET0_UNLESS(parse_digit(date, len, &value));
3555 (*digit) += value;
3556
3557 return 1;
3558}
3559
3560/* This function parses exactly 4 digits and returns the numeric value in "digit". */
3561static inline int parse_4digit(const char **date, int *len, int *digit)
3562{
3563 int value;
3564
3565 RET0_UNLESS(parse_digit(date, len, &value));
3566 (*digit) = value * 1000;
3567
3568 RET0_UNLESS(parse_digit(date, len, &value));
3569 (*digit) += value * 100;
3570
3571 RET0_UNLESS(parse_digit(date, len, &value));
3572 (*digit) += value * 10;
3573
3574 RET0_UNLESS(parse_digit(date, len, &value));
3575 (*digit) += value;
3576
3577 return 1;
3578}
3579
3580/* time-of-day = hour ":" minute ":" second
3581 * ; 00:00:00 - 23:59:60 (leap second)
3582 *
3583 * hour = 2DIGIT
3584 * minute = 2DIGIT
3585 * second = 2DIGIT
3586 */
3587static inline int parse_http_time(const char **date, int *len, struct tm *tm)
3588{
3589 RET0_UNLESS(parse_2digit(date, len, &tm->tm_hour)); /* hour 2DIGIT */
3590 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3591 RET0_UNLESS(parse_2digit(date, len, &tm->tm_min)); /* min 2DIGIT */
3592 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3593 RET0_UNLESS(parse_2digit(date, len, &tm->tm_sec)); /* sec 2DIGIT */
3594 return 1;
3595}
3596
3597/* From RFC7231
3598 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3599 *
3600 * IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
3601 * ; fixed length/zone/capitalization subset of the format
3602 * ; see Section 3.3 of [RFC5322]
3603 *
3604 *
3605 * date1 = day SP month SP year
3606 * ; e.g., 02 Jun 1982
3607 *
3608 * day = 2DIGIT
3609 * year = 4DIGIT
3610 *
3611 * GMT = %x47.4D.54 ; "GMT", case-sensitive
3612 *
3613 * time-of-day = hour ":" minute ":" second
3614 * ; 00:00:00 - 23:59:60 (leap second)
3615 *
3616 * hour = 2DIGIT
3617 * minute = 2DIGIT
3618 * second = 2DIGIT
3619 *
3620 * DIGIT = decimal 0-9
3621 */
3622int parse_imf_date(const char *date, int len, struct tm *tm)
3623{
David Carlier327298c2016-11-20 10:42:38 +00003624 /* tm_gmtoff, if present, ought to be zero'ed */
3625 memset(tm, 0, sizeof(*tm));
3626
Thierry Fournier93127942016-01-20 18:49:45 +01003627 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3628 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3629 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3630 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3631 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3632 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3633 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3634 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3635 tm->tm_year -= 1900;
3636 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3637 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3638 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3639 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3640 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003641 return 1;
3642}
3643
3644/* From RFC7231
3645 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3646 *
3647 * rfc850-date = day-name-l "," SP date2 SP time-of-day SP GMT
3648 * date2 = day "-" month "-" 2DIGIT
3649 * ; e.g., 02-Jun-82
3650 *
3651 * day = 2DIGIT
3652 */
3653int parse_rfc850_date(const char *date, int len, struct tm *tm)
3654{
3655 int year;
3656
David Carlier327298c2016-11-20 10:42:38 +00003657 /* tm_gmtoff, if present, ought to be zero'ed */
3658 memset(tm, 0, sizeof(*tm));
3659
Thierry Fournier93127942016-01-20 18:49:45 +01003660 RET0_UNLESS(parse_http_ldayname(&date, &len, tm)); /* Read the day name */
3661 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3662 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3663 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3664 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3665 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3666 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3667
3668 /* year = 2DIGIT
3669 *
3670 * Recipients of a timestamp value in rfc850-(*date) format, which uses a
3671 * two-digit year, MUST interpret a timestamp that appears to be more
3672 * than 50 years in the future as representing the most recent year in
3673 * the past that had the same last two digits.
3674 */
3675 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_year));
3676
3677 /* expect SP */
3678 if (!parse_expect_char(&date, &len, ' ')) {
3679 /* Maybe we have the date with 4 digits. */
3680 RET0_UNLESS(parse_2digit(&date, &len, &year));
3681 tm->tm_year = (tm->tm_year * 100 + year) - 1900;
3682 /* expect SP */
3683 RET0_UNLESS(parse_expect_char(&date, &len, ' '));
3684 } else {
3685 /* I fix 60 as pivot: >60: +1900, <60: +2000. Note that the
3686 * tm_year is the number of year since 1900, so for +1900, we
3687 * do nothing, and for +2000, we add 100.
3688 */
3689 if (tm->tm_year <= 60)
3690 tm->tm_year += 100;
3691 }
3692
3693 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3694 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3695 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3696 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003697
3698 return 1;
3699}
3700
3701/* From RFC7231
3702 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3703 *
3704 * asctime-date = day-name SP date3 SP time-of-day SP year
3705 * date3 = month SP ( 2DIGIT / ( SP 1DIGIT ))
3706 * ; e.g., Jun 2
3707 *
3708 * HTTP-date is case sensitive. A sender MUST NOT generate additional
3709 * whitespace in an HTTP-date beyond that specifically included as SP in
3710 * the grammar.
3711 */
3712int parse_asctime_date(const char *date, int len, struct tm *tm)
3713{
David Carlier327298c2016-11-20 10:42:38 +00003714 /* tm_gmtoff, if present, ought to be zero'ed */
3715 memset(tm, 0, sizeof(*tm));
3716
Thierry Fournier93127942016-01-20 18:49:45 +01003717 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3718 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3719 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* expect month */
3720 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3721
3722 /* expect SP and 1DIGIT or 2DIGIT */
3723 if (parse_expect_char(&date, &len, ' '))
3724 RET0_UNLESS(parse_digit(&date, &len, &tm->tm_mday));
3725 else
3726 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday));
3727
3728 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3729 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3730 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3731 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3732 tm->tm_year -= 1900;
3733 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003734 return 1;
3735}
3736
3737/* From RFC7231
3738 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3739 *
3740 * HTTP-date = IMF-fixdate / obs-date
3741 * obs-date = rfc850-date / asctime-date
3742 *
3743 * parses an HTTP date in the RFC format and is accepted
3744 * alternatives. <date> is the strinf containing the date,
3745 * len is the len of the string. <tm> is filled with the
3746 * parsed time. We must considers this time as GMT.
3747 */
3748int parse_http_date(const char *date, int len, struct tm *tm)
3749{
3750 if (parse_imf_date(date, len, tm))
3751 return 1;
3752
3753 if (parse_rfc850_date(date, len, tm))
3754 return 1;
3755
3756 if (parse_asctime_date(date, len, tm))
3757 return 1;
3758
3759 return 0;
3760}
3761
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003762/* Dynamically allocates a string of the proper length to hold the formatted
3763 * output. NULL is returned on error. The caller is responsible for freeing the
3764 * memory area using free(). The resulting string is returned in <out> if the
3765 * pointer is not NULL. A previous version of <out> might be used to build the
3766 * new string, and it will be freed before returning if it is not NULL, which
3767 * makes it possible to build complex strings from iterative calls without
3768 * having to care about freeing intermediate values, as in the example below :
3769 *
3770 * memprintf(&err, "invalid argument: '%s'", arg);
3771 * ...
3772 * memprintf(&err, "parser said : <%s>\n", *err);
3773 * ...
3774 * free(*err);
3775 *
3776 * This means that <err> must be initialized to NULL before first invocation.
3777 * The return value also holds the allocated string, which eases error checking
3778 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003779 * passed instead and it will be ignored. The returned message will then also
3780 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003781 *
3782 * It is also convenient to use it without any free except the last one :
3783 * err = NULL;
3784 * if (!fct1(err)) report(*err);
3785 * if (!fct2(err)) report(*err);
3786 * if (!fct3(err)) report(*err);
3787 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02003788 *
3789 * memprintf relies on memvprintf. This last version can be called from any
3790 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003791 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003792char *memvprintf(char **out, const char *format, va_list orig_args)
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003793{
3794 va_list args;
3795 char *ret = NULL;
3796 int allocated = 0;
3797 int needed = 0;
3798
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003799 if (!out)
3800 return NULL;
3801
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003802 do {
Willy Tarreaue0609f52019-03-29 19:13:23 +01003803 char buf1;
3804
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003805 /* vsnprintf() will return the required length even when the
3806 * target buffer is NULL. We do this in a loop just in case
3807 * intermediate evaluations get wrong.
3808 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003809 va_copy(args, orig_args);
Willy Tarreaue0609f52019-03-29 19:13:23 +01003810 needed = vsnprintf(ret ? ret : &buf1, allocated, format, args);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003811 va_end(args);
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003812 if (needed < allocated) {
3813 /* Note: on Solaris 8, the first iteration always
3814 * returns -1 if allocated is zero, so we force a
3815 * retry.
3816 */
3817 if (!allocated)
3818 needed = 0;
3819 else
3820 break;
3821 }
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003822
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003823 allocated = needed + 1;
Hubert Verstraete831962e2016-06-28 22:44:26 +02003824 ret = my_realloc2(ret, allocated);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003825 } while (ret);
3826
3827 if (needed < 0) {
3828 /* an error was encountered */
3829 free(ret);
3830 ret = NULL;
3831 }
3832
3833 if (out) {
3834 free(*out);
3835 *out = ret;
3836 }
3837
3838 return ret;
3839}
William Lallemand421f5b52012-02-06 18:15:57 +01003840
Christopher Faulet93a518f2017-10-24 11:25:33 +02003841char *memprintf(char **out, const char *format, ...)
3842{
3843 va_list args;
3844 char *ret = NULL;
3845
3846 va_start(args, format);
3847 ret = memvprintf(out, format, args);
3848 va_end(args);
3849
3850 return ret;
3851}
3852
Willy Tarreau21c705b2012-09-14 11:40:36 +02003853/* Used to add <level> spaces before each line of <out>, unless there is only one line.
3854 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02003855 * freed by the caller. It also supports being passed a NULL which results in the same
3856 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02003857 * Example of use :
3858 * parse(cmd, &err); (callee: memprintf(&err, ...))
3859 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
3860 * free(err);
3861 */
3862char *indent_msg(char **out, int level)
3863{
3864 char *ret, *in, *p;
3865 int needed = 0;
3866 int lf = 0;
3867 int lastlf = 0;
3868 int len;
3869
Willy Tarreau70eec382012-10-10 08:56:47 +02003870 if (!out || !*out)
3871 return NULL;
3872
Willy Tarreau21c705b2012-09-14 11:40:36 +02003873 in = *out - 1;
3874 while ((in = strchr(in + 1, '\n')) != NULL) {
3875 lastlf = in - *out;
3876 lf++;
3877 }
3878
3879 if (!lf) /* single line, no LF, return it as-is */
3880 return *out;
3881
3882 len = strlen(*out);
3883
3884 if (lf == 1 && lastlf == len - 1) {
3885 /* single line, LF at end, strip it and return as-is */
3886 (*out)[lastlf] = 0;
3887 return *out;
3888 }
3889
3890 /* OK now we have at least one LF, we need to process the whole string
3891 * as a multi-line string. What we'll do :
3892 * - prefix with an LF if there is none
3893 * - add <level> spaces before each line
3894 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
3895 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
3896 */
3897
3898 needed = 1 + level * (lf + 1) + len + 1;
3899 p = ret = malloc(needed);
3900 in = *out;
3901
3902 /* skip initial LFs */
3903 while (*in == '\n')
3904 in++;
3905
3906 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
3907 while (*in) {
3908 *p++ = '\n';
3909 memset(p, ' ', level);
3910 p += level;
3911 do {
3912 *p++ = *in++;
3913 } while (*in && *in != '\n');
3914 if (*in)
3915 in++;
3916 }
3917 *p = 0;
3918
3919 free(*out);
3920 *out = ret;
3921
3922 return ret;
3923}
3924
Willy Tarreaua2c99112019-08-21 13:17:37 +02003925/* makes a copy of message <in> into <out>, with each line prefixed with <pfx>
3926 * and end of lines replaced with <eol> if not 0. The first line to indent has
3927 * to be indicated in <first> (starts at zero), so that it is possible to skip
3928 * indenting the first line if it has to be appended after an existing message.
3929 * Empty strings are never indented, and NULL strings are considered empty both
3930 * for <in> and <pfx>. It returns non-zero if an EOL was appended as the last
3931 * character, non-zero otherwise.
3932 */
3933int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first)
3934{
3935 int bol, lf;
3936 int pfxlen = pfx ? strlen(pfx) : 0;
3937
3938 if (!in)
3939 return 0;
3940
3941 bol = 1;
3942 lf = 0;
3943 while (*in) {
3944 if (bol && pfxlen) {
3945 if (first > 0)
3946 first--;
3947 else
3948 b_putblk(out, pfx, pfxlen);
3949 bol = 0;
3950 }
3951
3952 lf = (*in == '\n');
3953 bol |= lf;
3954 b_putchr(out, (lf && eol) ? eol : *in);
3955 in++;
3956 }
3957 return lf;
3958}
3959
Willy Tarreau9d22e562019-03-29 18:49:09 +01003960/* removes environment variable <name> from the environment as found in
3961 * environ. This is only provided as an alternative for systems without
3962 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05003963 * The principle is to scan environ for each occurrence of variable name
Willy Tarreau9d22e562019-03-29 18:49:09 +01003964 * <name> and to replace the matching pointers with the last pointer of
3965 * the array (since variables are not ordered).
3966 * It always returns 0 (success).
3967 */
3968int my_unsetenv(const char *name)
3969{
3970 extern char **environ;
3971 char **p = environ;
3972 int vars;
3973 int next;
3974 int len;
3975
3976 len = strlen(name);
3977 for (vars = 0; p[vars]; vars++)
3978 ;
3979 next = 0;
3980 while (next < vars) {
3981 if (strncmp(p[next], name, len) != 0 || p[next][len] != '=') {
3982 next++;
3983 continue;
3984 }
3985 if (next < vars - 1)
3986 p[next] = p[vars - 1];
3987 p[--vars] = NULL;
3988 }
3989 return 0;
3990}
3991
Willy Tarreaudad36a32013-03-11 01:20:04 +01003992/* Convert occurrences of environment variables in the input string to their
3993 * corresponding value. A variable is identified as a series of alphanumeric
3994 * characters or underscores following a '$' sign. The <in> string must be
3995 * free()able. NULL returns NULL. The resulting string might be reallocated if
3996 * some expansion is made. Variable names may also be enclosed into braces if
3997 * needed (eg: to concatenate alphanum characters).
3998 */
3999char *env_expand(char *in)
4000{
4001 char *txt_beg;
4002 char *out;
4003 char *txt_end;
4004 char *var_beg;
4005 char *var_end;
4006 char *value;
4007 char *next;
4008 int out_len;
4009 int val_len;
4010
4011 if (!in)
4012 return in;
4013
4014 value = out = NULL;
4015 out_len = 0;
4016
4017 txt_beg = in;
4018 do {
4019 /* look for next '$' sign in <in> */
4020 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
4021
4022 if (!*txt_end && !out) /* end and no expansion performed */
4023 return in;
4024
4025 val_len = 0;
4026 next = txt_end;
4027 if (*txt_end == '$') {
4028 char save;
4029
4030 var_beg = txt_end + 1;
4031 if (*var_beg == '{')
4032 var_beg++;
4033
4034 var_end = var_beg;
Willy Tarreau90807112020-02-25 08:16:33 +01004035 while (isalnum((unsigned char)*var_end) || *var_end == '_') {
Willy Tarreaudad36a32013-03-11 01:20:04 +01004036 var_end++;
4037 }
4038
4039 next = var_end;
4040 if (*var_end == '}' && (var_beg > txt_end + 1))
4041 next++;
4042
4043 /* get value of the variable name at this location */
4044 save = *var_end;
4045 *var_end = '\0';
4046 value = getenv(var_beg);
4047 *var_end = save;
4048 val_len = value ? strlen(value) : 0;
4049 }
4050
Hubert Verstraete831962e2016-06-28 22:44:26 +02004051 out = my_realloc2(out, out_len + (txt_end - txt_beg) + val_len + 1);
Willy Tarreaudad36a32013-03-11 01:20:04 +01004052 if (txt_end > txt_beg) {
4053 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
4054 out_len += txt_end - txt_beg;
4055 }
4056 if (val_len) {
4057 memcpy(out + out_len, value, val_len);
4058 out_len += val_len;
4059 }
4060 out[out_len] = 0;
4061 txt_beg = next;
4062 } while (*txt_beg);
4063
4064 /* here we know that <out> was allocated and that we don't need <in> anymore */
4065 free(in);
4066 return out;
4067}
4068
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004069
4070/* same as strstr() but case-insensitive and with limit length */
4071const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2)
4072{
4073 char *pptr, *sptr, *start;
Willy Tarreauc8746532014-05-28 23:05:07 +02004074 unsigned int slen, plen;
4075 unsigned int tmp1, tmp2;
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004076
4077 if (str1 == NULL || len_str1 == 0) // search pattern into an empty string => search is not found
4078 return NULL;
4079
4080 if (str2 == NULL || len_str2 == 0) // pattern is empty => every str1 match
4081 return str1;
4082
4083 if (len_str1 < len_str2) // pattern is longer than string => search is not found
4084 return NULL;
4085
4086 for (tmp1 = 0, start = (char *)str1, pptr = (char *)str2, slen = len_str1, plen = len_str2; slen >= plen; start++, slen--) {
Willy Tarreauf278eec2020-07-05 21:46:32 +02004087 while (toupper((unsigned char)*start) != toupper((unsigned char)*str2)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004088 start++;
4089 slen--;
4090 tmp1++;
4091
4092 if (tmp1 >= len_str1)
4093 return NULL;
4094
4095 /* if pattern longer than string */
4096 if (slen < plen)
4097 return NULL;
4098 }
4099
4100 sptr = start;
4101 pptr = (char *)str2;
4102
4103 tmp2 = 0;
Willy Tarreauf278eec2020-07-05 21:46:32 +02004104 while (toupper((unsigned char)*sptr) == toupper((unsigned char)*pptr)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004105 sptr++;
4106 pptr++;
4107 tmp2++;
4108
4109 if (*pptr == '\0' || tmp2 == len_str2) /* end of pattern found */
4110 return start;
4111 if (*sptr == '\0' || tmp2 == len_str1) /* end of string found and the pattern is not fully found */
4112 return NULL;
4113 }
4114 }
4115 return NULL;
4116}
4117
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004118/* This function read the next valid utf8 char.
4119 * <s> is the byte srray to be decode, <len> is its length.
4120 * The function returns decoded char encoded like this:
4121 * The 4 msb are the return code (UTF8_CODE_*), the 4 lsb
4122 * are the length read. The decoded character is stored in <c>.
4123 */
4124unsigned char utf8_next(const char *s, int len, unsigned int *c)
4125{
4126 const unsigned char *p = (unsigned char *)s;
4127 int dec;
4128 unsigned char code = UTF8_CODE_OK;
4129
4130 if (len < 1)
4131 return UTF8_CODE_OK;
4132
4133 /* Check the type of UTF8 sequence
4134 *
4135 * 0... .... 0x00 <= x <= 0x7f : 1 byte: ascii char
4136 * 10.. .... 0x80 <= x <= 0xbf : invalid sequence
4137 * 110. .... 0xc0 <= x <= 0xdf : 2 bytes
4138 * 1110 .... 0xe0 <= x <= 0xef : 3 bytes
4139 * 1111 0... 0xf0 <= x <= 0xf7 : 4 bytes
4140 * 1111 10.. 0xf8 <= x <= 0xfb : 5 bytes
4141 * 1111 110. 0xfc <= x <= 0xfd : 6 bytes
4142 * 1111 111. 0xfe <= x <= 0xff : invalid sequence
4143 */
4144 switch (*p) {
4145 case 0x00 ... 0x7f:
4146 *c = *p;
4147 return UTF8_CODE_OK | 1;
4148
4149 case 0x80 ... 0xbf:
4150 *c = *p;
4151 return UTF8_CODE_BADSEQ | 1;
4152
4153 case 0xc0 ... 0xdf:
4154 if (len < 2) {
4155 *c = *p;
4156 return UTF8_CODE_BADSEQ | 1;
4157 }
4158 *c = *p & 0x1f;
4159 dec = 1;
4160 break;
4161
4162 case 0xe0 ... 0xef:
4163 if (len < 3) {
4164 *c = *p;
4165 return UTF8_CODE_BADSEQ | 1;
4166 }
4167 *c = *p & 0x0f;
4168 dec = 2;
4169 break;
4170
4171 case 0xf0 ... 0xf7:
4172 if (len < 4) {
4173 *c = *p;
4174 return UTF8_CODE_BADSEQ | 1;
4175 }
4176 *c = *p & 0x07;
4177 dec = 3;
4178 break;
4179
4180 case 0xf8 ... 0xfb:
4181 if (len < 5) {
4182 *c = *p;
4183 return UTF8_CODE_BADSEQ | 1;
4184 }
4185 *c = *p & 0x03;
4186 dec = 4;
4187 break;
4188
4189 case 0xfc ... 0xfd:
4190 if (len < 6) {
4191 *c = *p;
4192 return UTF8_CODE_BADSEQ | 1;
4193 }
4194 *c = *p & 0x01;
4195 dec = 5;
4196 break;
4197
4198 case 0xfe ... 0xff:
4199 default:
4200 *c = *p;
4201 return UTF8_CODE_BADSEQ | 1;
4202 }
4203
4204 p++;
4205
4206 while (dec > 0) {
4207
4208 /* need 0x10 for the 2 first bits */
4209 if ( ( *p & 0xc0 ) != 0x80 )
4210 return UTF8_CODE_BADSEQ | ((p-(unsigned char *)s)&0xffff);
4211
4212 /* add data at char */
4213 *c = ( *c << 6 ) | ( *p & 0x3f );
4214
4215 dec--;
4216 p++;
4217 }
4218
4219 /* Check ovelong encoding.
4220 * 1 byte : 5 + 6 : 11 : 0x80 ... 0x7ff
4221 * 2 bytes : 4 + 6 + 6 : 16 : 0x800 ... 0xffff
4222 * 3 bytes : 3 + 6 + 6 + 6 : 21 : 0x10000 ... 0x1fffff
4223 */
Thierry FOURNIER9e7ec082015-03-12 19:32:38 +01004224 if (( *c <= 0x7f && (p-(unsigned char *)s) > 1) ||
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004225 (*c >= 0x80 && *c <= 0x7ff && (p-(unsigned char *)s) > 2) ||
4226 (*c >= 0x800 && *c <= 0xffff && (p-(unsigned char *)s) > 3) ||
4227 (*c >= 0x10000 && *c <= 0x1fffff && (p-(unsigned char *)s) > 4))
4228 code |= UTF8_CODE_OVERLONG;
4229
4230 /* Check invalid UTF8 range. */
4231 if ((*c >= 0xd800 && *c <= 0xdfff) ||
4232 (*c >= 0xfffe && *c <= 0xffff))
4233 code |= UTF8_CODE_INVRANGE;
4234
4235 return code | ((p-(unsigned char *)s)&0x0f);
4236}
4237
Maxime de Roucydc887852016-05-13 23:52:54 +02004238/* append a copy of string <str> (in a wordlist) at the end of the list <li>
4239 * On failure : return 0 and <err> filled with an error message.
4240 * The caller is responsible for freeing the <err> and <str> copy
4241 * memory area using free()
4242 */
4243int list_append_word(struct list *li, const char *str, char **err)
4244{
4245 struct wordlist *wl;
4246
4247 wl = calloc(1, sizeof(*wl));
4248 if (!wl) {
4249 memprintf(err, "out of memory");
4250 goto fail_wl;
4251 }
4252
4253 wl->s = strdup(str);
4254 if (!wl->s) {
4255 memprintf(err, "out of memory");
4256 goto fail_wl_s;
4257 }
4258
4259 LIST_ADDQ(li, &wl->list);
4260
4261 return 1;
4262
4263fail_wl_s:
4264 free(wl->s);
4265fail_wl:
4266 free(wl);
4267 return 0;
4268}
4269
Willy Tarreau37101052019-05-20 16:48:20 +02004270/* indicates if a memory location may safely be read or not. The trick consists
4271 * in performing a harmless syscall using this location as an input and letting
4272 * the operating system report whether it's OK or not. For this we have the
4273 * stat() syscall, which will return EFAULT when the memory location supposed
4274 * to contain the file name is not readable. If it is readable it will then
4275 * either return 0 if the area contains an existing file name, or -1 with
4276 * another code. This must not be abused, and some audit systems might detect
4277 * this as abnormal activity. It's used only for unsafe dumps.
4278 */
4279int may_access(const void *ptr)
4280{
4281 struct stat buf;
4282
4283 if (stat(ptr, &buf) == 0)
4284 return 1;
4285 if (errno == EFAULT)
4286 return 0;
4287 return 1;
4288}
4289
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004290/* print a string of text buffer to <out>. The format is :
4291 * Non-printable chars \t, \n, \r and \e are * encoded in C format.
4292 * Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
4293 * Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
4294 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004295int dump_text(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004296{
4297 unsigned char c;
4298 int ptr = 0;
4299
4300 while (buf[ptr] && ptr < bsize) {
4301 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004302 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\' && c != ' ' && c != '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004303 if (out->data > out->size - 1)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004304 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004305 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004306 }
4307 else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\' || c == ' ' || c == '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004308 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004309 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004310 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004311 switch (c) {
4312 case ' ': c = ' '; break;
4313 case '\t': c = 't'; break;
4314 case '\n': c = 'n'; break;
4315 case '\r': c = 'r'; break;
4316 case '\e': c = 'e'; break;
4317 case '\\': c = '\\'; break;
4318 case '=': c = '='; break;
4319 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004320 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004321 }
4322 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004323 if (out->data > out->size - 4)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004324 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004325 out->area[out->data++] = '\\';
4326 out->area[out->data++] = 'x';
4327 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4328 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004329 }
4330 ptr++;
4331 }
4332
4333 return ptr;
4334}
4335
4336/* print a buffer in hexa.
4337 * Print stopped if <bsize> is reached, or if no more place in the chunk.
4338 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004339int dump_binary(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004340{
4341 unsigned char c;
4342 int ptr = 0;
4343
4344 while (ptr < bsize) {
4345 c = buf[ptr];
4346
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004347 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004348 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004349 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4350 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004351
4352 ptr++;
4353 }
4354 return ptr;
4355}
4356
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004357/* Appends into buffer <out> a hex dump of memory area <buf> for <len> bytes,
4358 * prepending each line with prefix <pfx>. The output is *not* initialized.
4359 * The output will not wrap pas the buffer's end so it is more optimal if the
4360 * caller makes sure the buffer is aligned first. A trailing zero will always
4361 * be appended (and not counted) if there is room for it. The caller must make
Willy Tarreau37101052019-05-20 16:48:20 +02004362 * sure that the area is dumpable first. If <unsafe> is non-null, the memory
4363 * locations are checked first for being readable.
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004364 */
Willy Tarreau37101052019-05-20 16:48:20 +02004365void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe)
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004366{
4367 const unsigned char *d = buf;
4368 int i, j, start;
4369
4370 d = (const unsigned char *)(((unsigned long)buf) & -16);
4371 start = ((unsigned long)buf) & 15;
4372
4373 for (i = 0; i < start + len; i += 16) {
4374 chunk_appendf(out, (sizeof(void *) == 4) ? "%s%8p: " : "%s%16p: ", pfx, d + i);
4375
Willy Tarreau37101052019-05-20 16:48:20 +02004376 // 0: unchecked, 1: checked safe, 2: danger
4377 unsafe = !!unsafe;
4378 if (unsafe && !may_access(d + i))
4379 unsafe = 2;
4380
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004381 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004382 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004383 chunk_strcat(out, "'' ");
Willy Tarreau37101052019-05-20 16:48:20 +02004384 else if (unsafe > 1)
4385 chunk_strcat(out, "** ");
4386 else
4387 chunk_appendf(out, "%02x ", d[i + j]);
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004388
4389 if (j == 7)
4390 chunk_strcat(out, "- ");
4391 }
4392 chunk_strcat(out, " ");
4393 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004394 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004395 chunk_strcat(out, "'");
Willy Tarreau37101052019-05-20 16:48:20 +02004396 else if (unsafe > 1)
4397 chunk_strcat(out, "*");
Willy Tarreau90807112020-02-25 08:16:33 +01004398 else if (isprint((unsigned char)d[i + j]))
Willy Tarreau37101052019-05-20 16:48:20 +02004399 chunk_appendf(out, "%c", d[i + j]);
4400 else
4401 chunk_strcat(out, ".");
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004402 }
4403 chunk_strcat(out, "\n");
4404 }
4405}
4406
Willy Tarreau762fb3e2020-03-03 15:57:10 +01004407/* dumps <pfx> followed by <n> bytes from <addr> in hex form into buffer <buf>
4408 * enclosed in brackets after the address itself, formatted on 14 chars
4409 * including the "0x" prefix. This is meant to be used as a prefix for code
4410 * areas. For example:
4411 * "0x7f10b6557690 [48 c7 c0 0f 00 00 00 0f]"
4412 * It relies on may_access() to know if the bytes are dumpable, otherwise "--"
4413 * is emitted. A NULL <pfx> will be considered empty.
4414 */
4415void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n)
4416{
4417 int ok = 0;
4418 int i;
4419
4420 chunk_appendf(buf, "%s%#14lx [", pfx ? pfx : "", (long)addr);
4421
4422 for (i = 0; i < n; i++) {
4423 if (i == 0 || (((long)(addr + i) ^ (long)(addr)) & 4096))
4424 ok = may_access(addr + i);
4425 if (ok)
4426 chunk_appendf(buf, "%02x%s", ((uint8_t*)addr)[i], (i<n-1) ? " " : "]");
4427 else
4428 chunk_appendf(buf, "--%s", (i<n-1) ? " " : "]");
4429 }
4430}
4431
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004432/* print a line of text buffer (limited to 70 bytes) to <out>. The format is :
4433 * <2 spaces> <offset=5 digits> <space or plus> <space> <70 chars max> <\n>
4434 * which is 60 chars per line. Non-printable chars \t, \n, \r and \e are
4435 * encoded in C format. Other non-printable chars are encoded "\xHH". Original
4436 * lines are respected within the limit of 70 output chars. Lines that are
4437 * continuation of a previous truncated line begin with "+" instead of " "
4438 * after the offset. The new pointer is returned.
4439 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004440int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004441 int *line, int ptr)
4442{
4443 int end;
4444 unsigned char c;
4445
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004446 end = out->data + 80;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004447 if (end > out->size)
4448 return ptr;
4449
4450 chunk_appendf(out, " %05d%c ", ptr, (ptr == *line) ? ' ' : '+');
4451
4452 while (ptr < len && ptr < bsize) {
4453 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004454 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004455 if (out->data > end - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004456 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004457 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004458 } else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004459 if (out->data > end - 3)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004460 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004461 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004462 switch (c) {
4463 case '\t': c = 't'; break;
4464 case '\n': c = 'n'; break;
4465 case '\r': c = 'r'; break;
4466 case '\e': c = 'e'; break;
4467 case '\\': c = '\\'; break;
4468 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004469 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004470 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004471 if (out->data > end - 5)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004472 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004473 out->area[out->data++] = '\\';
4474 out->area[out->data++] = 'x';
4475 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4476 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004477 }
4478 if (buf[ptr++] == '\n') {
4479 /* we had a line break, let's return now */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004480 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004481 *line = ptr;
4482 return ptr;
4483 }
4484 }
4485 /* we have an incomplete line, we return it as-is */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004486 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004487 return ptr;
4488}
4489
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004490/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02004491 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
4492 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004493 */
Willy Tarreaued936c52017-04-27 18:03:20 +02004494void debug_hexdump(FILE *out, const char *pfx, const char *buf,
4495 unsigned int baseaddr, int len)
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004496{
Willy Tarreau73459792017-04-11 07:58:08 +02004497 unsigned int i;
4498 int b, j;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004499
4500 for (i = 0; i < (len + (baseaddr & 15)); i += 16) {
4501 b = i - (baseaddr & 15);
Willy Tarreaued936c52017-04-27 18:03:20 +02004502 fprintf(out, "%s%08x: ", pfx ? pfx : "", i + (baseaddr & ~15));
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004503 for (j = 0; j < 8; j++) {
4504 if (b + j >= 0 && b + j < len)
4505 fprintf(out, "%02x ", (unsigned char)buf[b + j]);
4506 else
4507 fprintf(out, " ");
4508 }
4509
4510 if (b + j >= 0 && b + j < len)
4511 fputc('-', out);
4512 else
4513 fputc(' ', out);
4514
4515 for (j = 8; j < 16; j++) {
4516 if (b + j >= 0 && b + j < len)
4517 fprintf(out, " %02x", (unsigned char)buf[b + j]);
4518 else
4519 fprintf(out, " ");
4520 }
4521
4522 fprintf(out, " ");
4523 for (j = 0; j < 16; j++) {
4524 if (b + j >= 0 && b + j < len) {
4525 if (isprint((unsigned char)buf[b + j]))
4526 fputc((unsigned char)buf[b + j], out);
4527 else
4528 fputc('.', out);
4529 }
4530 else
4531 fputc(' ', out);
4532 }
4533 fputc('\n', out);
4534 }
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004535}
4536
Willy Tarreaubb869862020-04-16 10:52:41 +02004537/* Tries to report the executable path name on platforms supporting this. If
4538 * not found or not possible, returns NULL.
4539 */
4540const char *get_exec_path()
4541{
4542 const char *ret = NULL;
4543
4544#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
4545 long execfn = getauxval(AT_EXECFN);
4546
4547 if (execfn && execfn != ENOENT)
4548 ret = (const char *)execfn;
4549#endif
4550 return ret;
4551}
4552
Baruch Siache1651b22020-07-24 07:52:20 +03004553#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreau9133e482020-03-04 10:19:36 +01004554/* calls dladdr() or dladdr1() on <addr> and <dli>. If dladdr1 is available,
4555 * also returns the symbol size in <size>, otherwise returns 0 there.
4556 */
4557static int dladdr_and_size(const void *addr, Dl_info *dli, size_t *size)
4558{
4559 int ret;
Willy Tarreau62af9c82020-03-10 07:51:48 +01004560#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) // most detailed one
Willy Tarreau9133e482020-03-04 10:19:36 +01004561 const ElfW(Sym) *sym;
4562
4563 ret = dladdr1(addr, dli, (void **)&sym, RTLD_DL_SYMENT);
4564 if (ret)
4565 *size = sym ? sym->st_size : 0;
4566#else
4567 ret = dladdr(addr, dli);
4568 *size = 0;
4569#endif
4570 return ret;
4571}
4572#endif
4573
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004574/* Tries to append to buffer <buf> some indications about the symbol at address
4575 * <addr> using the following form:
4576 * lib:+0xoffset (unresolvable address from lib's base)
4577 * main+0xoffset (unresolvable address from main (+/-))
4578 * lib:main+0xoffset (unresolvable lib address from main (+/-))
4579 * name (resolved exact exec address)
4580 * lib:name (resolved exact lib address)
4581 * name+0xoffset/0xsize (resolved address within exec symbol)
4582 * lib:name+0xoffset/0xsize (resolved address within lib symbol)
4583 *
4584 * The file name (lib or executable) is limited to what lies between the last
4585 * '/' and the first following '.'. An optional prefix <pfx> is prepended before
4586 * the output if not null. The file is not dumped when it's the same as the one
Baruch Siache1651b22020-07-24 07:52:20 +03004587 * that contains the "main" symbol, or when __ELF__ && USE_DL are not set.
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004588 *
4589 * The symbol's base address is returned, or NULL when unresolved, in order to
4590 * allow the caller to match it against known ones.
4591 */
Willy Tarreau0c439d82020-07-05 20:26:04 +02004592const void *resolve_sym_name(struct buffer *buf, const char *pfx, void *addr)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004593{
4594 const struct {
4595 const void *func;
4596 const char *name;
4597 } fcts[] = {
4598 { .func = process_stream, .name = "process_stream" },
4599 { .func = task_run_applet, .name = "task_run_applet" },
4600 { .func = si_cs_io_cb, .name = "si_cs_io_cb" },
4601 { .func = conn_fd_handler, .name = "conn_fd_handler" },
4602 { .func = dgram_fd_handler, .name = "dgram_fd_handler" },
4603 { .func = listener_accept, .name = "listener_accept" },
4604 { .func = poller_pipe_io_handler, .name = "poller_pipe_io_handler" },
4605 { .func = mworker_accept_wrapper, .name = "mworker_accept_wrapper" },
4606#ifdef USE_LUA
4607 { .func = hlua_process_task, .name = "hlua_process_task" },
4608#endif
4609#if defined(USE_OPENSSL) && (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
4610 { .func = ssl_async_fd_free, .name = "ssl_async_fd_free" },
4611 { .func = ssl_async_fd_handler, .name = "ssl_async_fd_handler" },
4612#endif
4613 };
4614
Baruch Siache1651b22020-07-24 07:52:20 +03004615#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004616 Dl_info dli, dli_main;
Willy Tarreau9133e482020-03-04 10:19:36 +01004617 size_t size;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004618 const char *fname, *p;
4619#endif
4620 int i;
4621
4622 if (pfx)
4623 chunk_appendf(buf, "%s", pfx);
4624
4625 for (i = 0; i < sizeof(fcts) / sizeof(fcts[0]); i++) {
4626 if (addr == fcts[i].func) {
4627 chunk_appendf(buf, "%s", fcts[i].name);
4628 return addr;
4629 }
4630 }
4631
Baruch Siache1651b22020-07-24 07:52:20 +03004632#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004633 /* Now let's try to be smarter */
Willy Tarreau9133e482020-03-04 10:19:36 +01004634 if (!dladdr_and_size(addr, &dli, &size))
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004635 goto unknown;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004636
4637 /* 1. prefix the library name if it's not the same object as the one
4638 * that contains the main function. The name is picked between last '/'
4639 * and first following '.'.
4640 */
4641 if (!dladdr(main, &dli_main))
4642 dli_main.dli_fbase = NULL;
4643
4644 if (dli_main.dli_fbase != dli.dli_fbase) {
4645 fname = dli.dli_fname;
4646 p = strrchr(fname, '/');
4647 if (p++)
4648 fname = p;
4649 p = strchr(fname, '.');
4650 if (!p)
4651 p = fname + strlen(fname);
4652
4653 chunk_appendf(buf, "%.*s:", (int)(long)(p - fname), fname);
4654 }
4655
4656 /* 2. symbol name */
4657 if (dli.dli_sname) {
4658 /* known, dump it and return symbol's address (exact or relative) */
4659 chunk_appendf(buf, "%s", dli.dli_sname);
4660 if (addr != dli.dli_saddr) {
4661 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_saddr));
Willy Tarreau9133e482020-03-04 10:19:36 +01004662 if (size)
4663 chunk_appendf(buf, "/%#lx", (long)size);
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004664 }
4665 return dli.dli_saddr;
4666 }
4667 else if (dli_main.dli_fbase != dli.dli_fbase) {
4668 /* unresolved symbol from a known library, report relative offset */
4669 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_fbase));
4670 return NULL;
4671 }
Baruch Siache1651b22020-07-24 07:52:20 +03004672#endif /* __ELF__ && !__linux__ || USE_DL */
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004673 unknown:
4674 /* unresolved symbol from the main file, report relative offset to main */
4675 if ((void*)addr < (void*)main)
4676 chunk_appendf(buf, "main-%#lx", (long)((void*)main - addr));
4677 else
4678 chunk_appendf(buf, "main+%#lx", (long)(addr - (void*)main));
4679 return NULL;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004680}
4681
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004682/*
4683 * Allocate an array of unsigned int with <nums> as address from <str> string
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05004684 * made of integer separated by dot characters.
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004685 *
4686 * First, initializes the value with <sz> as address to 0 and initializes the
4687 * array with <nums> as address to NULL. Then allocates the array with <nums> as
4688 * address updating <sz> pointed value to the size of this array.
4689 *
4690 * Returns 1 if succeeded, 0 if not.
4691 */
4692int parse_dotted_uints(const char *str, unsigned int **nums, size_t *sz)
4693{
4694 unsigned int *n;
4695 const char *s, *end;
4696
4697 s = str;
4698 *sz = 0;
4699 end = str + strlen(str);
4700 *nums = n = NULL;
4701
4702 while (1) {
4703 unsigned int r;
4704
4705 if (s >= end)
4706 break;
4707
4708 r = read_uint(&s, end);
4709 /* Expected characters after having read an uint: '\0' or '.',
4710 * if '.', must not be terminal.
4711 */
4712 if (*s != '\0'&& (*s++ != '.' || s == end))
4713 return 0;
4714
Frédéric Lécaille12a71842019-02-26 18:19:48 +01004715 n = my_realloc2(n, (*sz + 1) * sizeof *n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004716 if (!n)
4717 return 0;
4718
4719 n[(*sz)++] = r;
4720 }
4721 *nums = n;
4722
4723 return 1;
4724}
4725
Willy Tarreau4d589e72019-08-23 19:02:26 +02004726
4727/* returns the number of bytes needed to encode <v> as a varint. An inline
4728 * version exists for use with constants (__varint_bytes()).
4729 */
4730int varint_bytes(uint64_t v)
4731{
4732 int len = 1;
4733
4734 if (v >= 240) {
4735 v = (v - 240) >> 4;
4736 while (1) {
4737 len++;
4738 if (v < 128)
4739 break;
4740 v = (v - 128) >> 7;
4741 }
4742 }
4743 return len;
4744}
4745
Willy Tarreau52bf8392020-03-08 00:42:37 +01004746
4747/* Random number generator state, see below */
Willy Tarreau1544c142020-03-12 00:31:18 +01004748static uint64_t ha_random_state[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01004749
4750/* This is a thread-safe implementation of xoroshiro128** described below:
4751 * http://prng.di.unimi.it/
4752 * It features a 2^128 long sequence, returns 64 high-quality bits on each call,
4753 * supports fast jumps and passes all common quality tests. It is thread-safe,
4754 * uses a double-cas on 64-bit architectures supporting it, and falls back to a
4755 * local lock on other ones.
4756 */
4757uint64_t ha_random64()
4758{
4759 uint64_t result;
Willy Tarreau1544c142020-03-12 00:31:18 +01004760 uint64_t old[2] ALIGNED(2*sizeof(uint64_t));
4761 uint64_t new[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01004762
4763#if defined(USE_THREAD) && (!defined(HA_CAS_IS_8B) || !defined(HA_HAVE_CAS_DW))
4764 static HA_SPINLOCK_T rand_lock;
4765
4766 HA_SPIN_LOCK(OTHER_LOCK, &rand_lock);
4767#endif
4768
4769 old[0] = ha_random_state[0];
4770 old[1] = ha_random_state[1];
4771
4772#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
4773 do {
4774#endif
4775 result = rotl64(old[0] * 5, 7) * 9;
4776 new[1] = old[0] ^ old[1];
4777 new[0] = rotl64(old[0], 24) ^ new[1] ^ (new[1] << 16); // a, b
4778 new[1] = rotl64(new[1], 37); // c
4779
4780#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
4781 } while (unlikely(!_HA_ATOMIC_DWCAS(ha_random_state, old, new)));
4782#else
4783 ha_random_state[0] = new[0];
4784 ha_random_state[1] = new[1];
4785#if defined(USE_THREAD)
4786 HA_SPIN_UNLOCK(OTHER_LOCK, &rand_lock);
4787#endif
4788#endif
4789 return result;
4790}
4791
4792/* seeds the random state using up to <len> bytes from <seed>, starting with
4793 * the first non-zero byte.
4794 */
4795void ha_random_seed(const unsigned char *seed, size_t len)
4796{
4797 size_t pos;
4798
4799 /* the seed must not be all zeroes, so we pre-fill it with alternating
4800 * bits and overwrite part of them with the block starting at the first
4801 * non-zero byte from the seed.
4802 */
4803 memset(ha_random_state, 0x55, sizeof(ha_random_state));
4804
4805 for (pos = 0; pos < len; pos++)
4806 if (seed[pos] != 0)
4807 break;
4808
4809 if (pos == len)
4810 return;
4811
4812 seed += pos;
4813 len -= pos;
4814
4815 if (len > sizeof(ha_random_state))
4816 len = sizeof(ha_random_state);
4817
4818 memcpy(ha_random_state, seed, len);
4819}
4820
4821/* This causes a jump to (dist * 2^96) places in the pseudo-random sequence,
4822 * and is equivalent to calling ha_random64() as many times. It is used to
4823 * provide non-overlapping sequences of 2^96 numbers (~7*10^28) to up to 2^32
4824 * different generators (i.e. different processes after a fork). The <dist>
4825 * argument is the distance to jump to and is used in a loop so it rather not
4826 * be too large if the processing time is a concern.
4827 *
4828 * BEWARE: this function is NOT thread-safe and must not be called during
4829 * concurrent accesses to ha_random64().
4830 */
4831void ha_random_jump96(uint32_t dist)
4832{
4833 while (dist--) {
4834 uint64_t s0 = 0;
4835 uint64_t s1 = 0;
4836 int b;
4837
4838 for (b = 0; b < 64; b++) {
4839 if ((0xd2a98b26625eee7bULL >> b) & 1) {
4840 s0 ^= ha_random_state[0];
4841 s1 ^= ha_random_state[1];
4842 }
4843 ha_random64();
4844 }
4845
4846 for (b = 0; b < 64; b++) {
4847 if ((0xdddf9b1090aa7ac1ULL >> b) & 1) {
4848 s0 ^= ha_random_state[0];
4849 s1 ^= ha_random_state[1];
4850 }
4851 ha_random64();
4852 }
4853 ha_random_state[0] = s0;
4854 ha_random_state[1] = s1;
4855 }
4856}
4857
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01004858/* Generates an RFC4122 UUID into chunk <output> which must be at least 37
4859 * bytes large.
4860 */
4861void ha_generate_uuid(struct buffer *output)
4862{
4863 uint32_t rnd[4];
4864 uint64_t last;
4865
4866 last = ha_random64();
4867 rnd[0] = last;
4868 rnd[1] = last >> 32;
4869
4870 last = ha_random64();
4871 rnd[2] = last;
4872 rnd[3] = last >> 32;
4873
4874 chunk_printf(output, "%8.8x-%4.4x-%4.4x-%4.4x-%12.12llx",
4875 rnd[0],
4876 rnd[1] & 0xFFFF,
4877 ((rnd[1] >> 16u) & 0xFFF) | 0x4000, // highest 4 bits indicate the uuid version
4878 (rnd[2] & 0x3FFF) | 0x8000, // the highest 2 bits indicate the UUID variant (10),
4879 (long long)((rnd[2] >> 14u) | ((uint64_t) rnd[3] << 18u)) & 0xFFFFFFFFFFFFull);
4880}
4881
4882
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004883/* only used by parse_line() below. It supports writing in place provided that
4884 * <in> is updated to the next location before calling it. In that case, the
4885 * char at <in> may be overwritten.
4886 */
4887#define EMIT_CHAR(x) \
4888 do { \
4889 char __c = (char)(x); \
4890 if ((opts & PARSE_OPT_INPLACE) && out+outpos > in) \
4891 err |= PARSE_ERR_OVERLAP; \
4892 if (outpos >= outmax) \
4893 err |= PARSE_ERR_TOOLARGE; \
4894 if (!err) \
4895 out[outpos] = __c; \
4896 outpos++; \
4897 } while (0)
4898
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05004899/* Parse <in>, copy it into <out> split into isolated words whose pointers
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004900 * are put in <args>. If more than <outlen> bytes have to be emitted, the
4901 * extraneous ones are not emitted but <outlen> is updated so that the caller
4902 * knows how much to realloc. Similarly, <args> are not updated beyond <nbargs>
4903 * but the returned <nbargs> indicates how many were found. All trailing args
Willy Tarreau61dd44b2020-06-25 07:35:42 +02004904 * up to <nbargs> point to the trailing zero, and as long as <nbargs> is > 0,
4905 * it is guaranteed that at least one arg will point to the zero. It is safe
4906 * to call it with a NULL <args> if <nbargs> is 0.
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004907 *
4908 * <out> may overlap with <in> provided that it never goes further, in which
4909 * case the parser will accept to perform in-place parsing and unquoting/
4910 * unescaping but only if environment variables do not lead to expansion that
4911 * causes overlapping, otherwise the input string being destroyed, the error
4912 * will not be recoverable. Note that even during out-of-place <in> will
4913 * experience temporary modifications in-place for variable resolution and must
4914 * be writable, and will also receive zeroes to delimit words when using
4915 * in-place copy. Parsing options <opts> taken from PARSE_OPT_*. Return value
4916 * is zero on success otherwise a bitwise-or of PARSE_ERR_*. Upon error, the
4917 * starting point of the first invalid character sequence or unmatched
4918 * quote/brace is reported in <errptr> if not NULL. When using in-place parsing
4919 * error reporting might be difficult since zeroes will have been inserted into
4920 * the string. One solution for the caller may consist in replacing all args
4921 * delimiters with spaces in this case.
4922 */
4923uint32_t parse_line(char *in, char *out, size_t *outlen, char **args, int *nbargs, uint32_t opts, char **errptr)
4924{
4925 char *quote = NULL;
4926 char *brace = NULL;
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02004927 char *word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004928 unsigned char hex1, hex2;
4929 size_t outmax = *outlen;
Willy Tarreau61dd44b2020-06-25 07:35:42 +02004930 int argsmax = *nbargs - 1;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004931 size_t outpos = 0;
4932 int squote = 0;
4933 int dquote = 0;
4934 int arg = 0;
4935 uint32_t err = 0;
4936
4937 *nbargs = 0;
4938 *outlen = 0;
4939
Willy Tarreau61dd44b2020-06-25 07:35:42 +02004940 /* argsmax may be -1 here, protecting args[] from any write */
4941 if (arg < argsmax)
4942 args[arg] = out;
4943
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004944 while (1) {
4945 if (*in >= '-' && *in != '\\') {
4946 /* speedup: directly send all regular chars starting
4947 * with '-', '.', '/', alnum etc...
4948 */
4949 EMIT_CHAR(*in++);
4950 continue;
4951 }
4952 else if (*in == '\0' || *in == '\n' || *in == '\r') {
4953 /* end of line */
4954 break;
4955 }
4956 else if (*in == '#' && (opts & PARSE_OPT_SHARP) && !squote && !dquote) {
4957 /* comment */
4958 break;
4959 }
4960 else if (*in == '"' && !squote && (opts & PARSE_OPT_DQUOTE)) { /* double quote outside single quotes */
4961 if (dquote) {
4962 dquote = 0;
4963 quote = NULL;
4964 }
4965 else {
4966 dquote = 1;
4967 quote = in;
4968 }
4969 in++;
4970 continue;
4971 }
4972 else if (*in == '\'' && !dquote && (opts & PARSE_OPT_SQUOTE)) { /* single quote outside double quotes */
4973 if (squote) {
4974 squote = 0;
4975 quote = NULL;
4976 }
4977 else {
4978 squote = 1;
4979 quote = in;
4980 }
4981 in++;
4982 continue;
4983 }
4984 else if (*in == '\\' && !squote && (opts & PARSE_OPT_BKSLASH)) {
4985 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
4986 * C equivalent value but only when they have a special meaning and within
4987 * double quotes for some of them. Other combinations left unchanged (eg: \1).
4988 */
4989 char tosend = *in;
4990
4991 switch (in[1]) {
4992 case ' ':
4993 case '\\':
4994 tosend = in[1];
4995 in++;
4996 break;
4997
4998 case 't':
4999 tosend = '\t';
5000 in++;
5001 break;
5002
5003 case 'n':
5004 tosend = '\n';
5005 in++;
5006 break;
5007
5008 case 'r':
5009 tosend = '\r';
5010 in++;
5011 break;
5012
5013 case '#':
5014 /* escaping of "#" only if comments are supported */
5015 if (opts & PARSE_OPT_SHARP)
5016 in++;
5017 tosend = *in;
5018 break;
5019
5020 case '\'':
5021 /* escaping of "'" only outside single quotes and only if single quotes are supported */
5022 if (opts & PARSE_OPT_SQUOTE && !squote)
5023 in++;
5024 tosend = *in;
5025 break;
5026
5027 case '"':
5028 /* escaping of '"' only outside single quotes and only if double quotes are supported */
5029 if (opts & PARSE_OPT_DQUOTE && !squote)
5030 in++;
5031 tosend = *in;
5032 break;
5033
5034 case '$':
5035 /* escaping of '$' only inside double quotes and only if env supported */
5036 if (opts & PARSE_OPT_ENV && dquote)
5037 in++;
5038 tosend = *in;
5039 break;
5040
5041 case 'x':
5042 if (!ishex(in[2]) || !ishex(in[3])) {
5043 /* invalid or incomplete hex sequence */
5044 err |= PARSE_ERR_HEX;
5045 if (errptr)
5046 *errptr = in;
5047 goto leave;
5048 }
Willy Tarreauf278eec2020-07-05 21:46:32 +02005049 hex1 = toupper((unsigned char)in[2]) - '0';
5050 hex2 = toupper((unsigned char)in[3]) - '0';
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005051 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
5052 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
5053 tosend = (hex1 << 4) + hex2;
5054 in += 3;
5055 break;
5056
5057 default:
5058 /* other combinations are not escape sequences */
5059 break;
5060 }
5061
5062 in++;
5063 EMIT_CHAR(tosend);
5064 }
5065 else if (isspace((unsigned char)*in) && !squote && !dquote) {
5066 /* a non-escaped space is an argument separator */
5067 while (isspace((unsigned char)*in))
5068 in++;
5069 EMIT_CHAR(0);
5070 arg++;
5071 if (arg < argsmax)
5072 args[arg] = out + outpos;
5073 else
5074 err |= PARSE_ERR_TOOMANY;
5075 }
5076 else if (*in == '$' && (opts & PARSE_OPT_ENV) && (dquote || !(opts & PARSE_OPT_DQUOTE))) {
5077 /* environment variables are evaluated anywhere, or only
5078 * inside double quotes if they are supported.
5079 */
5080 char *var_name;
5081 char save_char;
5082 char *value;
5083
5084 in++;
5085
5086 if (*in == '{')
5087 brace = in++;
5088
5089 if (!isalpha((unsigned char)*in) && *in != '_') {
5090 /* unacceptable character in variable name */
5091 err |= PARSE_ERR_VARNAME;
5092 if (errptr)
5093 *errptr = in;
5094 goto leave;
5095 }
5096
5097 var_name = in;
5098 while (isalnum((unsigned char)*in) || *in == '_')
5099 in++;
5100
5101 save_char = *in;
5102 *in = '\0';
5103 value = getenv(var_name);
5104 *in = save_char;
5105
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005106 /* support for '[*]' sequence to force word expansion,
5107 * only available inside braces */
5108 if (*in == '[' && brace && (opts & PARSE_OPT_WORD_EXPAND)) {
5109 word_expand = in++;
5110
5111 if (*in++ != '*' || *in++ != ']') {
5112 err |= PARSE_ERR_WRONG_EXPAND;
5113 if (errptr)
5114 *errptr = word_expand;
5115 goto leave;
5116 }
5117 }
5118
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005119 if (brace) {
5120 if (*in != '}') {
5121 /* unmatched brace */
5122 err |= PARSE_ERR_BRACE;
5123 if (errptr)
5124 *errptr = brace;
5125 goto leave;
5126 }
5127 in++;
5128 brace = NULL;
5129 }
5130
5131 if (value) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005132 while (*value) {
5133 /* expand as individual parameters on a space character */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005134 if (word_expand && isspace((unsigned char)*value)) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005135 EMIT_CHAR(0);
5136 ++arg;
5137 if (arg < argsmax)
5138 args[arg] = out + outpos;
5139 else
5140 err |= PARSE_ERR_TOOMANY;
5141
5142 /* skip consecutive spaces */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005143 while (isspace((unsigned char)*++value))
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005144 ;
5145 } else {
5146 EMIT_CHAR(*value++);
5147 }
5148 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005149 }
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005150 word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005151 }
5152 else {
5153 /* any other regular char */
5154 EMIT_CHAR(*in++);
5155 }
5156 }
5157
5158 /* end of output string */
5159 EMIT_CHAR(0);
5160 arg++;
5161
5162 if (quote) {
5163 /* unmatched quote */
5164 err |= PARSE_ERR_QUOTE;
5165 if (errptr)
5166 *errptr = quote;
5167 goto leave;
5168 }
5169 leave:
5170 *nbargs = arg;
5171 *outlen = outpos;
5172
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005173 /* empty all trailing args by making them point to the trailing zero,
5174 * at least the last one in any case.
5175 */
5176 if (arg > argsmax)
5177 arg = argsmax;
5178
5179 while (arg >= 0 && arg <= argsmax)
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005180 args[arg++] = out + outpos - 1;
5181
5182 return err;
5183}
5184#undef EMIT_CHAR
5185
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005186/* This is used to sanitize an input line that's about to be used for error reporting.
5187 * It will adjust <line> to print approximately <width> chars around <pos>, trying to
5188 * preserve the beginning, with leading or trailing "..." when the line is truncated.
5189 * If non-printable chars are present in the output. It returns the new offset <pos>
5190 * in the modified line. Non-printable characters are replaced with '?'. <width> must
5191 * be at least 6 to support two "..." otherwise the result is undefined. The line
5192 * itself must have at least 7 chars allocated for the same reason.
5193 */
5194size_t sanitize_for_printing(char *line, size_t pos, size_t width)
5195{
5196 size_t shift = 0;
5197 char *out = line;
5198 char *in = line;
5199 char *end = line + width;
5200
5201 if (pos >= width) {
5202 /* if we have to shift, we'll be out of context, so let's
5203 * try to put <pos> at the center of width.
5204 */
5205 shift = pos - width / 2;
5206 in += shift + 3;
5207 end = out + width - 3;
5208 out[0] = out[1] = out[2] = '.';
5209 out += 3;
5210 }
5211
5212 while (out < end && *in) {
5213 if (isspace((unsigned char)*in))
5214 *out++ = ' ';
5215 else if (isprint((unsigned char)*in))
5216 *out++ = *in;
5217 else
5218 *out++ = '?';
5219 in++;
5220 }
5221
5222 if (end < line + width) {
5223 out[0] = out[1] = out[2] = '.';
5224 out += 3;
5225 }
5226
5227 *out++ = 0;
5228 return pos - shift;
5229}
5230
Willy Tarreaubaaee002006-06-26 02:48:02 +02005231/*
5232 * Local variables:
5233 * c-indent-level: 8
5234 * c-basic-offset: 8
5235 * End:
5236 */