blob: 8fef15b4dda4b3513cf7300ad29dc4060dfdaa7b [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 Tarreau586f71b2020-12-11 15:54:36 +010051#include <haproxy/sock.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020052#include <haproxy/ssl_sock.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020053#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020054#include <haproxy/task.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020055#include <haproxy/tools.h>
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +010056
Thierry Fournier93127942016-01-20 18:49:45 +010057/* This macro returns false if the test __x is false. Many
58 * of the following parsing function must be abort the processing
59 * if it returns 0, so this macro is useful for writing light code.
60 */
61#define RET0_UNLESS(__x) do { if (!(__x)) return 0; } while (0)
62
Willy Tarreau56adcf22012-12-23 18:00:29 +010063/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020064 * 2^64-1 = 18446744073709551615 or
65 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020066 *
67 * The HTML version needs room for adding the 25 characters
68 * '<span class="rls"></span>' around digits at positions 3N+1 in order
69 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020070 */
Christopher Faulet99bca652017-11-14 16:47:26 +010071THREAD_LOCAL char itoa_str[NB_ITOA_STR][171];
72THREAD_LOCAL int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020073
Willy Tarreau588297f2014-06-16 15:16:40 +020074/* sometimes we'll need to quote strings (eg: in stats), and we don't expect
75 * to quote strings larger than a max configuration line.
76 */
Christopher Faulet99bca652017-11-14 16:47:26 +010077THREAD_LOCAL char quoted_str[NB_QSTR][QSTR_SIZE + 1];
78THREAD_LOCAL int quoted_idx = 0;
Willy Tarreau588297f2014-06-16 15:16:40 +020079
Willy Tarreaubaaee002006-06-26 02:48:02 +020080/*
William Lallemande7340ec2012-01-24 11:15:39 +010081 * unsigned long long ASCII representation
82 *
83 * return the last char '\0' or NULL if no enough
84 * space in dst
85 */
86char *ulltoa(unsigned long long n, char *dst, size_t size)
87{
88 int i = 0;
89 char *res;
90
91 switch(n) {
92 case 1ULL ... 9ULL:
93 i = 0;
94 break;
95
96 case 10ULL ... 99ULL:
97 i = 1;
98 break;
99
100 case 100ULL ... 999ULL:
101 i = 2;
102 break;
103
104 case 1000ULL ... 9999ULL:
105 i = 3;
106 break;
107
108 case 10000ULL ... 99999ULL:
109 i = 4;
110 break;
111
112 case 100000ULL ... 999999ULL:
113 i = 5;
114 break;
115
116 case 1000000ULL ... 9999999ULL:
117 i = 6;
118 break;
119
120 case 10000000ULL ... 99999999ULL:
121 i = 7;
122 break;
123
124 case 100000000ULL ... 999999999ULL:
125 i = 8;
126 break;
127
128 case 1000000000ULL ... 9999999999ULL:
129 i = 9;
130 break;
131
132 case 10000000000ULL ... 99999999999ULL:
133 i = 10;
134 break;
135
136 case 100000000000ULL ... 999999999999ULL:
137 i = 11;
138 break;
139
140 case 1000000000000ULL ... 9999999999999ULL:
141 i = 12;
142 break;
143
144 case 10000000000000ULL ... 99999999999999ULL:
145 i = 13;
146 break;
147
148 case 100000000000000ULL ... 999999999999999ULL:
149 i = 14;
150 break;
151
152 case 1000000000000000ULL ... 9999999999999999ULL:
153 i = 15;
154 break;
155
156 case 10000000000000000ULL ... 99999999999999999ULL:
157 i = 16;
158 break;
159
160 case 100000000000000000ULL ... 999999999999999999ULL:
161 i = 17;
162 break;
163
164 case 1000000000000000000ULL ... 9999999999999999999ULL:
165 i = 18;
166 break;
167
168 case 10000000000000000000ULL ... ULLONG_MAX:
169 i = 19;
170 break;
171 }
172 if (i + 2 > size) // (i + 1) + '\0'
173 return NULL; // too long
174 res = dst + i + 1;
175 *res = '\0';
176 for (; i >= 0; i--) {
177 dst[i] = n % 10ULL + '0';
178 n /= 10ULL;
179 }
180 return res;
181}
182
183/*
184 * unsigned long ASCII representation
185 *
186 * return the last char '\0' or NULL if no enough
187 * space in dst
188 */
189char *ultoa_o(unsigned long n, char *dst, size_t size)
190{
191 int i = 0;
192 char *res;
193
194 switch (n) {
195 case 0U ... 9UL:
196 i = 0;
197 break;
198
199 case 10U ... 99UL:
200 i = 1;
201 break;
202
203 case 100U ... 999UL:
204 i = 2;
205 break;
206
207 case 1000U ... 9999UL:
208 i = 3;
209 break;
210
211 case 10000U ... 99999UL:
212 i = 4;
213 break;
214
215 case 100000U ... 999999UL:
216 i = 5;
217 break;
218
219 case 1000000U ... 9999999UL:
220 i = 6;
221 break;
222
223 case 10000000U ... 99999999UL:
224 i = 7;
225 break;
226
227 case 100000000U ... 999999999UL:
228 i = 8;
229 break;
230#if __WORDSIZE == 32
231
232 case 1000000000ULL ... ULONG_MAX:
233 i = 9;
234 break;
235
236#elif __WORDSIZE == 64
237
238 case 1000000000ULL ... 9999999999UL:
239 i = 9;
240 break;
241
242 case 10000000000ULL ... 99999999999UL:
243 i = 10;
244 break;
245
246 case 100000000000ULL ... 999999999999UL:
247 i = 11;
248 break;
249
250 case 1000000000000ULL ... 9999999999999UL:
251 i = 12;
252 break;
253
254 case 10000000000000ULL ... 99999999999999UL:
255 i = 13;
256 break;
257
258 case 100000000000000ULL ... 999999999999999UL:
259 i = 14;
260 break;
261
262 case 1000000000000000ULL ... 9999999999999999UL:
263 i = 15;
264 break;
265
266 case 10000000000000000ULL ... 99999999999999999UL:
267 i = 16;
268 break;
269
270 case 100000000000000000ULL ... 999999999999999999UL:
271 i = 17;
272 break;
273
274 case 1000000000000000000ULL ... 9999999999999999999UL:
275 i = 18;
276 break;
277
278 case 10000000000000000000ULL ... ULONG_MAX:
279 i = 19;
280 break;
281
282#endif
283 }
284 if (i + 2 > size) // (i + 1) + '\0'
285 return NULL; // too long
286 res = dst + i + 1;
287 *res = '\0';
288 for (; i >= 0; i--) {
289 dst[i] = n % 10U + '0';
290 n /= 10U;
291 }
292 return res;
293}
294
295/*
296 * signed long ASCII representation
297 *
298 * return the last char '\0' or NULL if no enough
299 * space in dst
300 */
301char *ltoa_o(long int n, char *dst, size_t size)
302{
303 char *pos = dst;
304
305 if (n < 0) {
306 if (size < 3)
307 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
308 *pos = '-';
309 pos++;
310 dst = ultoa_o(-n, pos, size - 1);
311 } else {
312 dst = ultoa_o(n, dst, size);
313 }
314 return dst;
315}
316
317/*
318 * signed long long ASCII representation
319 *
320 * return the last char '\0' or NULL if no enough
321 * space in dst
322 */
323char *lltoa(long long n, char *dst, size_t size)
324{
325 char *pos = dst;
326
327 if (n < 0) {
328 if (size < 3)
329 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
330 *pos = '-';
331 pos++;
332 dst = ulltoa(-n, pos, size - 1);
333 } else {
334 dst = ulltoa(n, dst, size);
335 }
336 return dst;
337}
338
339/*
340 * write a ascii representation of a unsigned into dst,
341 * return a pointer to the last character
342 * Pad the ascii representation with '0', using size.
343 */
344char *utoa_pad(unsigned int n, char *dst, size_t size)
345{
346 int i = 0;
347 char *ret;
348
349 switch(n) {
350 case 0U ... 9U:
351 i = 0;
352 break;
353
354 case 10U ... 99U:
355 i = 1;
356 break;
357
358 case 100U ... 999U:
359 i = 2;
360 break;
361
362 case 1000U ... 9999U:
363 i = 3;
364 break;
365
366 case 10000U ... 99999U:
367 i = 4;
368 break;
369
370 case 100000U ... 999999U:
371 i = 5;
372 break;
373
374 case 1000000U ... 9999999U:
375 i = 6;
376 break;
377
378 case 10000000U ... 99999999U:
379 i = 7;
380 break;
381
382 case 100000000U ... 999999999U:
383 i = 8;
384 break;
385
386 case 1000000000U ... 4294967295U:
387 i = 9;
388 break;
389 }
390 if (i + 2 > size) // (i + 1) + '\0'
391 return NULL; // too long
392 if (i < size)
393 i = size - 2; // padding - '\0'
394
395 ret = dst + i + 1;
396 *ret = '\0';
397 for (; i >= 0; i--) {
398 dst[i] = n % 10U + '0';
399 n /= 10U;
400 }
401 return ret;
402}
403
404/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200405 * copies at most <size-1> chars from <src> to <dst>. Last char is always
406 * set to 0, unless <size> is 0. The number of chars copied is returned
407 * (excluding the terminating zero).
408 * This code has been optimized for size and speed : on x86, it's 45 bytes
409 * long, uses only registers, and consumes only 4 cycles per char.
410 */
411int strlcpy2(char *dst, const char *src, int size)
412{
413 char *orig = dst;
414 if (size) {
415 while (--size && (*dst = *src)) {
416 src++; dst++;
417 }
418 *dst = 0;
419 }
420 return dst - orig;
421}
422
423/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200424 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200425 * the ascii representation for number 'n' in decimal.
426 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100427char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200428{
429 char *pos;
430
Willy Tarreau72d759c2007-10-25 12:14:10 +0200431 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200432 *pos-- = '\0';
433
434 do {
435 *pos-- = '0' + n % 10;
436 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200437 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200438 return pos + 1;
439}
440
Willy Tarreau91092e52007-10-25 16:58:42 +0200441/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200442 * This function simply returns a locally allocated string containing
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200443 * the ascii representation for number 'n' in decimal.
444 */
445char *lltoa_r(long long int in, char *buffer, int size)
446{
447 char *pos;
448 int neg = 0;
449 unsigned long long int n;
450
451 pos = buffer + size - 1;
452 *pos-- = '\0';
453
454 if (in < 0) {
455 neg = 1;
456 n = -in;
457 }
458 else
459 n = in;
460
461 do {
462 *pos-- = '0' + n % 10;
463 n /= 10;
464 } while (n && pos >= buffer);
465 if (neg && pos > buffer)
466 *pos-- = '-';
467 return pos + 1;
468}
469
470/*
471 * This function simply returns a locally allocated string containing
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200472 * the ascii representation for signed number 'n' in decimal.
473 */
474char *sltoa_r(long n, char *buffer, int size)
475{
476 char *pos;
477
478 if (n >= 0)
479 return ultoa_r(n, buffer, size);
480
481 pos = ultoa_r(-n, buffer + 1, size - 1) - 1;
482 *pos = '-';
483 return pos;
484}
485
486/*
487 * This function simply returns a locally allocated string containing
Willy Tarreaue7239b52009-03-29 13:41:58 +0200488 * the ascii representation for number 'n' in decimal, formatted for
489 * HTML output with tags to create visual grouping by 3 digits. The
490 * output needs to support at least 171 characters.
491 */
492const char *ulltoh_r(unsigned long long n, char *buffer, int size)
493{
494 char *start;
495 int digit = 0;
496
497 start = buffer + size;
498 *--start = '\0';
499
500 do {
501 if (digit == 3 && start >= buffer + 7)
502 memcpy(start -= 7, "</span>", 7);
503
504 if (start >= buffer + 1) {
505 *--start = '0' + n % 10;
506 n /= 10;
507 }
508
509 if (digit == 3 && start >= buffer + 18)
510 memcpy(start -= 18, "<span class=\"rls\">", 18);
511
512 if (digit++ == 3)
513 digit = 1;
514 } while (n && start > buffer);
515 return start;
516}
517
518/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200519 * This function simply returns a locally allocated string containing the ascii
520 * representation for number 'n' in decimal, unless n is 0 in which case it
521 * returns the alternate string (or an empty string if the alternate string is
522 * NULL). It use is intended for limits reported in reports, where it's
523 * desirable not to display anything if there is no limit. Warning! it shares
524 * the same vector as ultoa_r().
525 */
526const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
527{
528 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
529}
530
Willy Tarreau588297f2014-06-16 15:16:40 +0200531/* returns a locally allocated string containing the quoted encoding of the
532 * input string. The output may be truncated to QSTR_SIZE chars, but it is
533 * guaranteed that the string will always be properly terminated. Quotes are
534 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
535 * always be at least 4 chars.
536 */
537const char *qstr(const char *str)
538{
539 char *ret = quoted_str[quoted_idx];
540 char *p, *end;
541
542 if (++quoted_idx >= NB_QSTR)
543 quoted_idx = 0;
544
545 p = ret;
546 end = ret + QSTR_SIZE;
547
548 *p++ = '"';
549
550 /* always keep 3 chars to support passing "" and the ending " */
551 while (*str && p < end - 3) {
552 if (*str == '"') {
553 *p++ = '"';
554 *p++ = '"';
555 }
556 else
557 *p++ = *str;
558 str++;
559 }
560 *p++ = '"';
561 return ret;
562}
563
Robert Tsai81ae1952007-12-05 10:47:29 +0100564/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200565 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
566 *
567 * It looks like this one would be a good candidate for inlining, but this is
568 * not interesting because it around 35 bytes long and often called multiple
569 * times within the same function.
570 */
571int ishex(char s)
572{
573 s -= '0';
574 if ((unsigned char)s <= 9)
575 return 1;
576 s -= 'A' - '0';
577 if ((unsigned char)s <= 5)
578 return 1;
579 s -= 'a' - 'A';
580 if ((unsigned char)s <= 5)
581 return 1;
582 return 0;
583}
584
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100585/* rounds <i> down to the closest value having max 2 digits */
586unsigned int round_2dig(unsigned int i)
587{
588 unsigned int mul = 1;
589
590 while (i >= 100) {
591 i /= 10;
592 mul *= 10;
593 }
594 return i * mul;
595}
596
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100597/*
598 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
599 * invalid character is found, a pointer to it is returned. If everything is
600 * fine, NULL is returned.
601 */
602const char *invalid_char(const char *name)
603{
604 if (!*name)
605 return name;
606
607 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100608 if (!isalnum((unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100609 *name != '_' && *name != '-')
610 return name;
611 name++;
612 }
613 return NULL;
614}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200615
616/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200617 * Checks <name> for invalid characters. Valid chars are [_.-] and those
618 * accepted by <f> function.
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200619 * If an invalid character is found, a pointer to it is returned.
620 * If everything is fine, NULL is returned.
621 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200622static inline const char *__invalid_char(const char *name, int (*f)(int)) {
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200623
624 if (!*name)
625 return name;
626
627 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100628 if (!f((unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200629 *name != '_' && *name != '-')
630 return name;
631
632 name++;
633 }
634
635 return NULL;
636}
637
638/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200639 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
640 * If an invalid character is found, a pointer to it is returned.
641 * If everything is fine, NULL is returned.
642 */
643const char *invalid_domainchar(const char *name) {
644 return __invalid_char(name, isalnum);
645}
646
647/*
648 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
649 * If an invalid character is found, a pointer to it is returned.
650 * If everything is fine, NULL is returned.
651 */
652const char *invalid_prefix_char(const char *name) {
Thierry Fournierf7b7c3e2018-03-26 11:54:39 +0200653 return __invalid_char(name, isalnum);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200654}
655
656/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100657 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100658 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
659 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
660 * the function tries to guess the address family from the syntax. If the
661 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100662 * string is assumed to contain only an address, no port. The address can be a
663 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
664 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
665 * The return address will only have the address family and the address set,
666 * all other fields remain zero. The string is not supposed to be modified.
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100667 * The IPv6 '::' address is IN6ADDR_ANY. If <resolve> is non-zero, the hostname
668 * is resolved, otherwise only IP addresses are resolved, and anything else
Willy Tarreauecde7df2016-11-02 22:37:03 +0100669 * returns NULL. If the address contains a port, this one is preserved.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200670 */
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100671struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200672{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100673 struct hostent *he;
mildisff5d5102015-10-26 18:50:08 +0100674 /* max IPv6 length, including brackets and terminating NULL */
675 char tmpip[48];
Willy Tarreauecde7df2016-11-02 22:37:03 +0100676 int port = get_host_port(sa);
mildisff5d5102015-10-26 18:50:08 +0100677
678 /* check IPv6 with square brackets */
679 if (str[0] == '[') {
680 size_t iplength = strlen(str);
681
682 if (iplength < 4) {
683 /* minimal size is 4 when using brackets "[::]" */
684 goto fail;
685 }
686 else if (iplength >= sizeof(tmpip)) {
687 /* IPv6 literal can not be larger than tmpip */
688 goto fail;
689 }
690 else {
691 if (str[iplength - 1] != ']') {
692 /* if address started with bracket, it should end with bracket */
693 goto fail;
694 }
695 else {
696 memcpy(tmpip, str + 1, iplength - 2);
697 tmpip[iplength - 2] = '\0';
698 str = tmpip;
699 }
700 }
701 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100702
Willy Tarreaufab5a432011-03-04 15:31:53 +0100703 /* Any IPv6 address */
704 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100705 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
706 sa->ss_family = AF_INET6;
707 else if (sa->ss_family != AF_INET6)
708 goto fail;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100709 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100710 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100711 }
712
Willy Tarreau24709282013-03-10 21:32:12 +0100713 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100714 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100715 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
716 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100717 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100718 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100719 }
720
721 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100722 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
723 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100724 sa->ss_family = AF_INET6;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100725 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100726 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100727 }
728
729 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100730 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
731 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100732 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100733 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100734 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100735 }
736
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100737 if (!resolve)
738 return NULL;
739
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200740 if (!dns_hostname_validation(str, NULL))
741 return NULL;
742
David du Colombierd5f43282011-03-17 10:40:16 +0100743#ifdef USE_GETADDRINFO
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200744 if (global.tune.options & GTUNE_USE_GAI) {
David du Colombierd5f43282011-03-17 10:40:16 +0100745 struct addrinfo hints, *result;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100746 int success = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100747
748 memset(&result, 0, sizeof(result));
749 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100750 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100751 hints.ai_socktype = SOCK_DGRAM;
Dmitry Sivachenkoeab7f392015-10-02 01:01:58 +0200752 hints.ai_flags = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100753 hints.ai_protocol = 0;
754
755 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100756 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
757 sa->ss_family = result->ai_family;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100758 else if (sa->ss_family != result->ai_family) {
759 freeaddrinfo(result);
Willy Tarreau24709282013-03-10 21:32:12 +0100760 goto fail;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100761 }
Willy Tarreau24709282013-03-10 21:32:12 +0100762
David du Colombierd5f43282011-03-17 10:40:16 +0100763 switch (result->ai_family) {
764 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100765 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100766 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100767 success = 1;
768 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100769 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100770 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100771 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100772 success = 1;
773 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100774 }
775 }
776
Sean Carey58ea0392013-02-15 23:39:18 +0100777 if (result)
778 freeaddrinfo(result);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100779
780 if (success)
781 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100782 }
David du Colombierd5f43282011-03-17 10:40:16 +0100783#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200784 /* try to resolve an IPv4/IPv6 hostname */
785 he = gethostbyname(str);
786 if (he) {
787 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
788 sa->ss_family = he->h_addrtype;
789 else if (sa->ss_family != he->h_addrtype)
790 goto fail;
791
792 switch (sa->ss_family) {
793 case AF_INET:
794 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100795 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200796 return sa;
797 case AF_INET6:
798 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100799 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200800 return sa;
801 }
802 }
803
David du Colombierd5f43282011-03-17 10:40:16 +0100804 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100805 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100806 return NULL;
807}
808
809/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100810 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
811 * range or offset consisting in two integers that the caller will have to
812 * check to find the relevant input format. The following format are supported :
813 *
814 * String format | address | port | low | high
815 * addr | <addr> | 0 | 0 | 0
816 * addr: | <addr> | 0 | 0 | 0
817 * addr:port | <addr> | <port> | <port> | <port>
818 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
819 * addr:+port | <addr> | <port> | 0 | <port>
820 * addr:-port | <addr> |-<port> | <port> | 0
821 *
822 * The detection of a port range or increment by the caller is made by
823 * comparing <low> and <high>. If both are equal, then port 0 means no port
824 * was specified. The caller may pass NULL for <low> and <high> if it is not
825 * interested in retrieving port ranges.
826 *
827 * Note that <addr> above may also be :
828 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
829 * - "*" => family will be AF_INET and address will be INADDR_ANY
830 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
831 * - a host name => family and address will depend on host name resolving.
832 *
Willy Tarreau24709282013-03-10 21:32:12 +0100833 * A prefix may be passed in before the address above to force the family :
834 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
835 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
836 * - "unix@" => force address to be a path to a UNIX socket even if the
837 * path does not start with a '/'
Willy Tarreauccfccef2014-05-10 01:49:15 +0200838 * - 'abns@' -> force address to belong to the abstract namespace (Linux
839 * only). These sockets are just like Unix sockets but without
840 * the need for an underlying file system. The address is a
841 * string. Technically it's like a Unix socket with a zero in
842 * the first byte of the address.
Willy Tarreau40aa0702013-03-10 23:51:38 +0100843 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100844 *
mildisff5d5102015-10-26 18:50:08 +0100845 * IPv6 addresses can be declared with or without square brackets. When using
846 * square brackets for IPv6 addresses, the port separator (colon) is optional.
847 * If not using square brackets, and in order to avoid any ambiguity with
848 * IPv6 addresses, the last colon ':' is mandatory even when no port is specified.
849 * NULL is returned if the address cannot be parsed. The <low> and <high> ports
850 * are always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100851 *
852 * If <pfx> is non-null, it is used as a string prefix before any path-based
853 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100854 *
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200855 * if <fqdn> is non-null, it will be filled with :
856 * - a pointer to the FQDN of the server name to resolve if there's one, and
857 * that the caller will have to free(),
858 * - NULL if there was an explicit address that doesn't require resolution.
859 *
Willy Tarreaucd3a55912020-09-04 15:30:46 +0200860 * Hostnames are only resolved if <opts> has PA_O_RESOLVE. Otherwise <fqdn> is
861 * still honored so it is possible for the caller to know whether a resolution
862 * failed by clearing this flag and checking if <fqdn> was filled, indicating
863 * the need for a resolution.
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200864 *
Willy Tarreau40aa0702013-03-10 23:51:38 +0100865 * When a file descriptor is passed, its value is put into the s_addr part of
Willy Tarreaua5b325f2020-09-04 16:44:20 +0200866 * the address when cast to sockaddr_in and the address family is
867 * AF_CUST_EXISTING_FD.
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200868 *
Willy Tarreau5fc93282020-09-16 18:25:03 +0200869 * The matching protocol will be set into <proto> if non-null.
870 *
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200871 * Any known file descriptor is also assigned to <fd> if non-null, otherwise it
872 * is forced to -1.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100873 */
Willy Tarreau5fc93282020-09-16 18:25:03 +0200874struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int *high, int *fd,
875 struct protocol **proto, char **err,
876 const char *pfx, char **fqdn, unsigned int opts)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100877{
Christopher Faulet1bc04c72017-10-29 20:14:08 +0100878 static THREAD_LOCAL struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100879 struct sockaddr_storage *ret = NULL;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200880 struct protocol *new_proto = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100881 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100882 char *port1, *port2;
883 int portl, porth, porta;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200884 int abstract = 0;
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200885 int new_fd = -1;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200886 int sock_type, ctrl_type;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100887
888 portl = porth = porta = 0;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200889 if (fqdn)
890 *fqdn = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200891
Willy Tarreaudad36a32013-03-11 01:20:04 +0100892 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100893 if (str2 == NULL) {
894 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100895 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100896 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200897
Willy Tarreau9f69f462015-09-08 16:01:25 +0200898 if (!*str2) {
899 memprintf(err, "'%s' resolves to an empty address (environment variable missing?)\n", str);
900 goto out;
901 }
902
Willy Tarreau24709282013-03-10 21:32:12 +0100903 memset(&ss, 0, sizeof(ss));
904
Willy Tarreaue835bd82020-09-16 11:35:47 +0200905 /* prepare the default socket types */
906 if ((opts & (PA_O_STREAM|PA_O_DGRAM)) == PA_O_DGRAM)
907 sock_type = ctrl_type = SOCK_DGRAM;
908 else
909 sock_type = ctrl_type = SOCK_STREAM;
910
911 if (strncmp(str2, "stream+", 7) == 0) {
912 str2 += 7;
913 sock_type = ctrl_type = SOCK_STREAM;
914 }
915 else if (strncmp(str2, "dgram+", 6) == 0) {
916 str2 += 6;
917 sock_type = ctrl_type = SOCK_DGRAM;
918 }
919
Willy Tarreau24709282013-03-10 21:32:12 +0100920 if (strncmp(str2, "unix@", 5) == 0) {
921 str2 += 5;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200922 abstract = 0;
Willy Tarreau24709282013-03-10 21:32:12 +0100923 ss.ss_family = AF_UNIX;
924 }
Willy Tarreauccfccef2014-05-10 01:49:15 +0200925 else if (strncmp(str2, "abns@", 5) == 0) {
926 str2 += 5;
927 abstract = 1;
928 ss.ss_family = AF_UNIX;
929 }
Willy Tarreau24709282013-03-10 21:32:12 +0100930 else if (strncmp(str2, "ipv4@", 5) == 0) {
931 str2 += 5;
932 ss.ss_family = AF_INET;
933 }
934 else if (strncmp(str2, "ipv6@", 5) == 0) {
935 str2 += 5;
936 ss.ss_family = AF_INET6;
937 }
Emeric Brun3835c0d2020-07-07 09:46:09 +0200938 else if (strncmp(str2, "udp4@", 5) == 0) {
939 str2 += 5;
940 ss.ss_family = AF_INET;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200941 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200942 }
943 else if (strncmp(str2, "udp6@", 5) == 0) {
944 str2 += 5;
945 ss.ss_family = AF_INET6;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200946 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200947 }
948 else if (strncmp(str2, "udp@", 4) == 0) {
949 str2 += 4;
950 ss.ss_family = AF_UNSPEC;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200951 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +0200952 }
Frédéric Lécaille10caf652020-11-23 11:36:57 +0100953 else if (strncmp(str2, "quic4@", 6) == 0) {
954 str2 += 6;
955 ss.ss_family = AF_INET;
956 sock_type = SOCK_DGRAM;
957 ctrl_type = SOCK_STREAM;
958 }
959 else if (strncmp(str2, "quic6@", 6) == 0) {
960 str2 += 6;
961 ss.ss_family = AF_INET6;
962 sock_type = SOCK_DGRAM;
963 ctrl_type = SOCK_STREAM;
964 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +0200965 else if (strncmp(str2, "fd@", 3) == 0) {
966 str2 += 3;
967 ss.ss_family = AF_CUST_EXISTING_FD;
968 }
969 else if (strncmp(str2, "sockpair@", 9) == 0) {
970 str2 += 9;
971 ss.ss_family = AF_CUST_SOCKPAIR;
972 }
Willy Tarreau24709282013-03-10 21:32:12 +0100973 else if (*str2 == '/') {
974 ss.ss_family = AF_UNIX;
975 }
976 else
977 ss.ss_family = AF_UNSPEC;
978
Willy Tarreau5a7beed2020-09-04 16:54:05 +0200979 if (ss.ss_family == AF_CUST_SOCKPAIR) {
Willy Tarreaua215be22020-09-16 10:14:16 +0200980 struct sockaddr_storage ss2;
981 socklen_t addr_len;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200982 char *endptr;
983
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200984 new_fd = strtol(str2, &endptr, 10);
985 if (!*str2 || new_fd < 0 || *endptr) {
William Lallemand2fe7dd02018-09-11 16:51:29 +0200986 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
987 goto out;
988 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200989
Willy Tarreaua215be22020-09-16 10:14:16 +0200990 /* just verify that it's a socket */
991 addr_len = sizeof(ss2);
992 if (getsockname(new_fd, (struct sockaddr *)&ss2, &addr_len) == -1) {
993 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
994 goto out;
995 }
996
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200997 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
998 ((struct sockaddr_in *)&ss)->sin_port = 0;
William Lallemand2fe7dd02018-09-11 16:51:29 +0200999 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001000 else if (ss.ss_family == AF_CUST_EXISTING_FD) {
Willy Tarreau40aa0702013-03-10 23:51:38 +01001001 char *endptr;
1002
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001003 new_fd = strtol(str2, &endptr, 10);
1004 if (!*str2 || new_fd < 0 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +01001005 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +01001006 goto out;
1007 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001008
Willy Tarreau6edc7222020-09-15 17:41:56 +02001009 if (opts & PA_O_SOCKET_FD) {
1010 socklen_t addr_len;
1011 int type;
1012
1013 addr_len = sizeof(ss);
1014 if (getsockname(new_fd, (struct sockaddr *)&ss, &addr_len) == -1) {
1015 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1016 goto out;
1017 }
1018
1019 addr_len = sizeof(type);
1020 if (getsockopt(new_fd, SOL_SOCKET, SO_TYPE, &type, &addr_len) != 0 ||
Willy Tarreaue835bd82020-09-16 11:35:47 +02001021 (type == SOCK_STREAM) != (sock_type == SOCK_STREAM)) {
Willy Tarreau6edc7222020-09-15 17:41:56 +02001022 memprintf(err, "socket on file descriptor '%d' is of the wrong type.\n", new_fd);
1023 goto out;
1024 }
1025
1026 porta = portl = porth = get_host_port(&ss);
1027 } else if (opts & PA_O_RAW_FD) {
1028 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1029 ((struct sockaddr_in *)&ss)->sin_port = 0;
1030 } else {
1031 memprintf(err, "a file descriptor is not acceptable here in '%s'\n", str);
1032 goto out;
1033 }
Willy Tarreau40aa0702013-03-10 23:51:38 +01001034 }
1035 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau8daa9202019-06-16 18:16:33 +02001036 struct sockaddr_un *un = (struct sockaddr_un *)&ss;
Willy Tarreau15586382013-03-04 19:48:14 +01001037 int prefix_path_len;
1038 int max_path_len;
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001039 int adr_len;
Willy Tarreau15586382013-03-04 19:48:14 +01001040
1041 /* complete unix socket path name during startup or soft-restart is
1042 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
1043 */
Willy Tarreauccfccef2014-05-10 01:49:15 +02001044 prefix_path_len = (pfx && !abstract) ? strlen(pfx) : 0;
Willy Tarreau8daa9202019-06-16 18:16:33 +02001045 max_path_len = (sizeof(un->sun_path) - 1) -
Willy Tarreau327ea5a2020-02-11 06:43:37 +01001046 (abstract ? 0 : prefix_path_len + 1 + 5 + 1 + 3);
Willy Tarreau15586382013-03-04 19:48:14 +01001047
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001048 adr_len = strlen(str2);
1049 if (adr_len > max_path_len) {
Willy Tarreau15586382013-03-04 19:48:14 +01001050 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
1051 goto out;
1052 }
1053
Willy Tarreauccfccef2014-05-10 01:49:15 +02001054 /* when abstract==1, we skip the first zero and copy all bytes except the trailing zero */
Willy Tarreau8daa9202019-06-16 18:16:33 +02001055 memset(un->sun_path, 0, sizeof(un->sun_path));
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001056 if (prefix_path_len)
Willy Tarreau8daa9202019-06-16 18:16:33 +02001057 memcpy(un->sun_path, pfx, prefix_path_len);
1058 memcpy(un->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
Willy Tarreau15586382013-03-04 19:48:14 +01001059 }
Willy Tarreau24709282013-03-10 21:32:12 +01001060 else { /* IPv4 and IPv6 */
mildisff5d5102015-10-26 18:50:08 +01001061 char *end = str2 + strlen(str2);
1062 char *chr;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001063
mildisff5d5102015-10-26 18:50:08 +01001064 /* search for : or ] whatever comes first */
1065 for (chr = end-1; chr > str2; chr--) {
1066 if (*chr == ']' || *chr == ':')
1067 break;
1068 }
1069
1070 if (*chr == ':') {
1071 /* Found a colon before a closing-bracket, must be a port separator.
1072 * This guarantee backward compatibility.
1073 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001074 if (!(opts & PA_O_PORT_OK)) {
1075 memprintf(err, "port specification not permitted here in '%s'", str);
1076 goto out;
1077 }
mildisff5d5102015-10-26 18:50:08 +01001078 *chr++ = '\0';
1079 port1 = chr;
1080 }
1081 else {
1082 /* Either no colon and no closing-bracket
1083 * or directly ending with a closing-bracket.
1084 * However, no port.
1085 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001086 if (opts & PA_O_PORT_MAND) {
1087 memprintf(err, "missing port specification in '%s'", str);
1088 goto out;
1089 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001090 port1 = "";
mildisff5d5102015-10-26 18:50:08 +01001091 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001092
Willy Tarreau90807112020-02-25 08:16:33 +01001093 if (isdigit((unsigned char)*port1)) { /* single port or range */
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001094 port2 = strchr(port1, '-');
Willy Tarreau7f96a842020-09-15 11:12:44 +02001095 if (port2) {
1096 if (!(opts & PA_O_PORT_RANGE)) {
1097 memprintf(err, "port range not permitted here in '%s'", str);
1098 goto out;
1099 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001100 *port2++ = '\0';
Willy Tarreau7f96a842020-09-15 11:12:44 +02001101 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001102 else
1103 port2 = port1;
1104 portl = atoi(port1);
1105 porth = atoi(port2);
Willy Tarreau7f96a842020-09-15 11:12:44 +02001106
1107 if (portl < !!(opts & PA_O_PORT_MAND) || portl > 65535) {
1108 memprintf(err, "invalid port '%s'", port1);
1109 goto out;
1110 }
1111
1112 if (porth < !!(opts & PA_O_PORT_MAND) || porth > 65535) {
1113 memprintf(err, "invalid port '%s'", port2);
1114 goto out;
1115 }
1116
1117 if (portl > porth) {
1118 memprintf(err, "invalid port range '%d-%d'", portl, porth);
1119 goto out;
1120 }
1121
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001122 porta = portl;
1123 }
1124 else if (*port1 == '-') { /* negative offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001125 if (!(opts & PA_O_PORT_OFS)) {
1126 memprintf(err, "port offset not permitted here in '%s'", str);
1127 goto out;
1128 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001129 portl = atoi(port1 + 1);
1130 porta = -portl;
1131 }
1132 else if (*port1 == '+') { /* positive offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001133 if (!(opts & PA_O_PORT_OFS)) {
1134 memprintf(err, "port offset not permitted here in '%s'", str);
1135 goto out;
1136 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001137 porth = atoi(port1 + 1);
1138 porta = porth;
1139 }
1140 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +01001141 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001142 goto out;
1143 }
Willy Tarreau7f96a842020-09-15 11:12:44 +02001144 else if (opts & PA_O_PORT_MAND) {
1145 memprintf(err, "missing port specification in '%s'", str);
1146 goto out;
1147 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001148
1149 /* first try to parse the IP without resolving. If it fails, it
1150 * tells us we need to keep a copy of the FQDN to resolve later
1151 * and to enable DNS. In this case we can proceed if <fqdn> is
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001152 * set or if PA_O_RESOLVE is set, otherwise it's an error.
Willy Tarreauceccdd72016-11-02 22:27:10 +01001153 */
1154 if (str2ip2(str2, &ss, 0) == NULL) {
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001155 if ((!(opts & PA_O_RESOLVE) && !fqdn) ||
1156 ((opts & PA_O_RESOLVE) && str2ip2(str2, &ss, 1) == NULL)) {
Willy Tarreauceccdd72016-11-02 22:27:10 +01001157 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
1158 goto out;
1159 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001160
Willy Tarreauceccdd72016-11-02 22:27:10 +01001161 if (fqdn) {
1162 if (str2 != back)
1163 memmove(back, str2, strlen(str2) + 1);
1164 *fqdn = back;
1165 back = NULL;
1166 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001167 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001168 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +01001169 }
Willy Tarreaufab5a432011-03-04 15:31:53 +01001170
Willy Tarreaue835bd82020-09-16 11:35:47 +02001171 if (ctrl_type == SOCK_STREAM && !(opts & PA_O_STREAM)) {
1172 memprintf(err, "stream-type socket not acceptable in '%s'\n", str);
1173 goto out;
1174 }
1175 else if (ctrl_type == SOCK_DGRAM && !(opts & PA_O_DGRAM)) {
1176 memprintf(err, "dgram-type socket not acceptable in '%s'\n", str);
1177 goto out;
1178 }
1179
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001180 if (proto || (opts & PA_O_CONNECT)) {
Willy Tarreau5fc93282020-09-16 18:25:03 +02001181 /* Note: if the caller asks for a proto, we must find one,
1182 * except if we return with an fqdn that will resolve later,
1183 * in which case the address is not known yet (this is only
1184 * for servers actually).
1185 */
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001186 new_proto = protocol_lookup(ss.ss_family,
Willy Tarreauaf9609b2020-09-16 22:04:46 +02001187 sock_type == SOCK_DGRAM,
1188 ctrl_type == SOCK_DGRAM);
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001189
Willy Tarreau5fc93282020-09-16 18:25:03 +02001190 if (!new_proto && (!fqdn || !*fqdn)) {
1191 memprintf(err, "unsupported protocol family %d for address '%s'", ss.ss_family, str);
1192 goto out;
1193 }
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001194
1195 if ((opts & PA_O_CONNECT) && new_proto && !new_proto->connect) {
1196 memprintf(err, "connect() not supported for this protocol family %d used by address '%s'", ss.ss_family, str);
1197 goto out;
1198 }
Willy Tarreau5fc93282020-09-16 18:25:03 +02001199 }
1200
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001201 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +01001202 out:
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001203 if (port)
1204 *port = porta;
Willy Tarreaud4448bc2013-02-20 15:55:15 +01001205 if (low)
1206 *low = portl;
1207 if (high)
1208 *high = porth;
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001209 if (fd)
1210 *fd = new_fd;
Willy Tarreau5fc93282020-09-16 18:25:03 +02001211 if (proto)
1212 *proto = new_proto;
Willy Tarreau24709282013-03-10 21:32:12 +01001213 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +01001214 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001215}
1216
Thayne McCombs92149f92020-11-20 01:28:26 -07001217/* converts <addr> and <port> into a string representation of the address and port. This is sort
1218 * of an inverse of str2sa_range, with some restrictions. The supported families are AF_INET,
1219 * AF_INET6, AF_UNIX, and AF_CUST_SOCKPAIR. If the family is unsopported NULL is returned.
1220 * If map_ports is true, then the sign of the port is included in the output, to indicate it is
1221 * relative to the incoming port. AF_INET and AF_INET6 will be in the form "<addr>:<port>".
1222 * AF_UNIX will either be just the path (if using a pathname) or "abns@<path>" if it is abstract.
1223 * AF_CUST_SOCKPAIR will be of the form "sockpair@<fd>".
1224 *
1225 * The returned char* is allocated, and it is the responsibility of the caller to free it.
1226 */
1227char * sa2str(const struct sockaddr_storage *addr, int port, int map_ports)
1228{
1229 char buffer[INET6_ADDRSTRLEN];
1230 char *out = NULL;
1231 const void *ptr;
1232 const char *path;
1233
1234 switch (addr->ss_family) {
1235 case AF_INET:
1236 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1237 break;
1238 case AF_INET6:
1239 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1240 break;
1241 case AF_UNIX:
1242 path = ((struct sockaddr_un *)addr)->sun_path;
1243 if (path[0] == '\0') {
1244 const int max_length = sizeof(struct sockaddr_un) - offsetof(struct sockaddr_un, sun_path) - 1;
1245 return memprintf(&out, "abns@%.*s", max_length, path+1);
1246 } else {
1247 return strdup(path);
1248 }
1249 case AF_CUST_SOCKPAIR:
1250 return memprintf(&out, "sockpair@%d", ((struct sockaddr_in *)addr)->sin_addr.s_addr);
1251 default:
1252 return NULL;
1253 }
1254 inet_ntop(addr->ss_family, ptr, buffer, get_addr_len(addr));
1255 if (map_ports)
1256 return memprintf(&out, "%s:%+d", buffer, port);
1257 else
1258 return memprintf(&out, "%s:%d", buffer, port);
1259}
1260
1261
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001262/* converts <str> to a struct in_addr containing a network mask. It can be
1263 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +03001264 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001265 */
1266int str2mask(const char *str, struct in_addr *mask)
1267{
1268 if (strchr(str, '.') != NULL) { /* dotted notation */
1269 if (!inet_pton(AF_INET, str, mask))
1270 return 0;
1271 }
1272 else { /* mask length */
1273 char *err;
1274 unsigned long len = strtol(str, &err, 10);
1275
1276 if (!*str || (err && *err) || (unsigned)len > 32)
1277 return 0;
Tim Duesterhus8575f722018-01-25 16:24:48 +01001278
1279 len2mask4(len, mask);
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001280 }
1281 return 1;
1282}
1283
Tim Duesterhus47185172018-01-25 16:24:49 +01001284/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +01001285 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +01001286 * if the conversion succeeds otherwise zero.
1287 */
1288int str2mask6(const char *str, struct in6_addr *mask)
1289{
1290 if (strchr(str, ':') != NULL) { /* quadruplet notation */
1291 if (!inet_pton(AF_INET6, str, mask))
1292 return 0;
1293 }
1294 else { /* mask length */
1295 char *err;
1296 unsigned long len = strtol(str, &err, 10);
1297
1298 if (!*str || (err && *err) || (unsigned)len > 128)
1299 return 0;
1300
1301 len2mask6(len, mask);
1302 }
1303 return 1;
1304}
1305
Thierry FOURNIERb0504632013-12-14 15:39:02 +01001306/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
1307 * succeeds otherwise zero.
1308 */
1309int cidr2dotted(int cidr, struct in_addr *mask) {
1310
1311 if (cidr < 0 || cidr > 32)
1312 return 0;
1313
1314 mask->s_addr = cidr ? htonl(~0UL << (32 - cidr)) : 0;
1315 return 1;
1316}
1317
Thierry Fournier70473a52016-02-17 17:12:14 +01001318/* Convert mask from bit length form to in_addr form.
1319 * This function never fails.
1320 */
1321void len2mask4(int len, struct in_addr *addr)
1322{
1323 if (len >= 32) {
1324 addr->s_addr = 0xffffffff;
1325 return;
1326 }
1327 if (len <= 0) {
1328 addr->s_addr = 0x00000000;
1329 return;
1330 }
1331 addr->s_addr = 0xffffffff << (32 - len);
1332 addr->s_addr = htonl(addr->s_addr);
1333}
1334
1335/* Convert mask from bit length form to in6_addr form.
1336 * This function never fails.
1337 */
1338void len2mask6(int len, struct in6_addr *addr)
1339{
1340 len2mask4(len, (struct in_addr *)&addr->s6_addr[0]); /* msb */
1341 len -= 32;
1342 len2mask4(len, (struct in_addr *)&addr->s6_addr[4]);
1343 len -= 32;
1344 len2mask4(len, (struct in_addr *)&addr->s6_addr[8]);
1345 len -= 32;
1346 len2mask4(len, (struct in_addr *)&addr->s6_addr[12]); /* lsb */
1347}
1348
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001349/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +02001350 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001351 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001352 * is optional and either in the dotted or CIDR notation.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001353 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
1354 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001355int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001356{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001357 __label__ out_free, out_err;
1358 char *c, *s;
1359 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001360
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001361 s = strdup(str);
1362 if (!s)
1363 return 0;
1364
Willy Tarreaubaaee002006-06-26 02:48:02 +02001365 memset(mask, 0, sizeof(*mask));
1366 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001367
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001368 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001369 *c++ = '\0';
1370 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001371 if (!str2mask(c, mask))
1372 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001373 }
1374 else {
Willy Tarreauebd61602006-12-30 11:54:15 +01001375 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001376 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001377 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001378 struct hostent *he;
1379
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001380 if (!resolve)
1381 goto out_err;
1382
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001383 if ((he = gethostbyname(s)) == NULL) {
1384 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001385 }
1386 else
1387 *addr = *(struct in_addr *) *(he->h_addr_list);
1388 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001389
1390 ret_val = 1;
1391 out_free:
1392 free(s);
1393 return ret_val;
1394 out_err:
1395 ret_val = 0;
1396 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001397}
1398
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001399
1400/*
Willy Tarreau6d20e282012-04-27 22:49:47 +02001401 * converts <str> to two struct in6_addr* which must be pre-allocated.
1402 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001403 * is an optional number of bits (128 being the default).
Willy Tarreau6d20e282012-04-27 22:49:47 +02001404 * Returns 1 if OK, 0 if error.
1405 */
1406int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
1407{
1408 char *c, *s;
1409 int ret_val = 0;
1410 char *err;
1411 unsigned long len = 128;
1412
1413 s = strdup(str);
1414 if (!s)
1415 return 0;
1416
1417 memset(mask, 0, sizeof(*mask));
1418 memset(addr, 0, sizeof(*addr));
1419
1420 if ((c = strrchr(s, '/')) != NULL) {
1421 *c++ = '\0'; /* c points to the mask */
1422 if (!*c)
1423 goto out_free;
1424
1425 len = strtoul(c, &err, 10);
1426 if ((err && *err) || (unsigned)len > 128)
1427 goto out_free;
1428 }
1429 *mask = len; /* OK we have a valid mask in <len> */
1430
1431 if (!inet_pton(AF_INET6, s, addr))
1432 goto out_free;
1433
1434 ret_val = 1;
1435 out_free:
1436 free(s);
1437 return ret_val;
1438}
1439
1440
1441/*
David du Colombier6f5ccb12011-03-10 22:26:24 +01001442 * Parse IPv4 address found in url.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001443 */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001444int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001445{
1446 int saw_digit, octets, ch;
1447 u_char tmp[4], *tp;
1448 const char *cp = addr;
1449
1450 saw_digit = 0;
1451 octets = 0;
1452 *(tp = tmp) = 0;
1453
1454 while (*addr) {
1455 unsigned char digit = (ch = *addr++) - '0';
1456 if (digit > 9 && ch != '.')
1457 break;
1458 if (digit <= 9) {
1459 u_int new = *tp * 10 + digit;
1460 if (new > 255)
1461 return 0;
1462 *tp = new;
1463 if (!saw_digit) {
1464 if (++octets > 4)
1465 return 0;
1466 saw_digit = 1;
1467 }
1468 } else if (ch == '.' && saw_digit) {
1469 if (octets == 4)
1470 return 0;
1471 *++tp = 0;
1472 saw_digit = 0;
1473 } else
1474 return 0;
1475 }
1476
1477 if (octets < 4)
1478 return 0;
1479
1480 memcpy(&dst->s_addr, tmp, 4);
1481 return addr-cp-1;
1482}
1483
1484/*
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001485 * Resolve destination server from URL. Convert <str> to a sockaddr_storage.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001486 * <out> contain the code of the detected scheme, the start and length of
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001487 * the hostname. Actually only http and https are supported. <out> can be NULL.
1488 * This function returns the consumed length. It is useful if you parse complete
1489 * url like http://host:port/path, because the consumed length corresponds to
1490 * the first character of the path. If the conversion fails, it returns -1.
1491 *
1492 * This function tries to resolve the DNS name if haproxy is in starting mode.
1493 * So, this function may be used during the configuration parsing.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001494 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001495int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001496{
1497 const char *curr = url, *cp = url;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001498 const char *end;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001499 int ret, url_code = 0;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001500 unsigned long long int http_code = 0;
1501 int default_port;
1502 struct hostent *he;
1503 char *p;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001504
1505 /* Firstly, try to find :// pattern */
1506 while (curr < url+ulen && url_code != 0x3a2f2f) {
1507 url_code = ((url_code & 0xffff) << 8);
1508 url_code += (unsigned char)*curr++;
1509 }
1510
1511 /* Secondly, if :// pattern is found, verify parsed stuff
1512 * before pattern is matching our http pattern.
1513 * If so parse ip address and port in uri.
1514 *
1515 * WARNING: Current code doesn't support dynamic async dns resolver.
1516 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001517 if (url_code != 0x3a2f2f)
1518 return -1;
1519
1520 /* Copy scheme, and utrn to lower case. */
1521 while (cp < curr - 3)
1522 http_code = (http_code << 8) + *cp++;
1523 http_code |= 0x2020202020202020ULL; /* Turn everything to lower case */
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001524
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001525 /* HTTP or HTTPS url matching */
1526 if (http_code == 0x2020202068747470ULL) {
1527 default_port = 80;
1528 if (out)
1529 out->scheme = SCH_HTTP;
1530 }
1531 else if (http_code == 0x2020206874747073ULL) {
1532 default_port = 443;
1533 if (out)
1534 out->scheme = SCH_HTTPS;
1535 }
1536 else
1537 return -1;
1538
1539 /* If the next char is '[', the host address is IPv6. */
1540 if (*curr == '[') {
1541 curr++;
1542
1543 /* Check trash size */
1544 if (trash.size < ulen)
1545 return -1;
1546
1547 /* Look for ']' and copy the address in a trash buffer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001548 p = trash.area;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001549 for (end = curr;
1550 end < url + ulen && *end != ']';
1551 end++, p++)
1552 *p = *end;
1553 if (*end != ']')
1554 return -1;
1555 *p = '\0';
1556
1557 /* Update out. */
1558 if (out) {
1559 out->host = curr;
1560 out->host_len = end - curr;
1561 }
1562
1563 /* Try IPv6 decoding. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001564 if (!inet_pton(AF_INET6, trash.area, &((struct sockaddr_in6 *)addr)->sin6_addr))
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001565 return -1;
1566 end++;
1567
1568 /* Decode port. */
1569 if (*end == ':') {
1570 end++;
1571 default_port = read_uint(&end, url + ulen);
1572 }
1573 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1574 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1575 return end - url;
1576 }
1577 else {
1578 /* We are looking for IP address. If you want to parse and
1579 * resolve hostname found in url, you can use str2sa_range(), but
1580 * be warned this can slow down global daemon performances
1581 * while handling lagging dns responses.
1582 */
1583 ret = url2ipv4(curr, &((struct sockaddr_in *)addr)->sin_addr);
1584 if (ret) {
1585 /* Update out. */
1586 if (out) {
1587 out->host = curr;
1588 out->host_len = ret;
1589 }
1590
1591 curr += ret;
1592
1593 /* Decode port. */
1594 if (*curr == ':') {
1595 curr++;
1596 default_port = read_uint(&curr, url + ulen);
1597 }
1598 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1599
1600 /* Set family. */
1601 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1602 return curr - url;
1603 }
1604 else if (global.mode & MODE_STARTING) {
1605 /* The IPv4 and IPv6 decoding fails, maybe the url contain name. Try to execute
1606 * synchronous DNS request only if HAProxy is in the start state.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001607 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001608
1609 /* look for : or / or end */
1610 for (end = curr;
1611 end < url + ulen && *end != '/' && *end != ':';
1612 end++);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001613 memcpy(trash.area, curr, end - curr);
1614 trash.area[end - curr] = '\0';
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001615
1616 /* try to resolve an IPv4/IPv6 hostname */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001617 he = gethostbyname(trash.area);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001618 if (!he)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001619 return -1;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001620
1621 /* Update out. */
1622 if (out) {
1623 out->host = curr;
1624 out->host_len = end - curr;
1625 }
1626
1627 /* Decode port. */
1628 if (*end == ':') {
1629 end++;
1630 default_port = read_uint(&end, url + ulen);
1631 }
1632
1633 /* Copy IP address, set port and family. */
1634 switch (he->h_addrtype) {
1635 case AF_INET:
1636 ((struct sockaddr_in *)addr)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
1637 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1638 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1639 return end - url;
1640
1641 case AF_INET6:
1642 ((struct sockaddr_in6 *)addr)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
1643 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1644 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1645 return end - url;
1646 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001647 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001648 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001649 return -1;
1650}
1651
Willy Tarreau631f01c2011-09-05 00:36:48 +02001652/* Tries to convert a sockaddr_storage address to text form. Upon success, the
1653 * address family is returned so that it's easy for the caller to adapt to the
1654 * output format. Zero is returned if the address family is not supported. -1
1655 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1656 * supported.
1657 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001658int addr_to_str(const struct sockaddr_storage *addr, char *str, int size)
Willy Tarreau631f01c2011-09-05 00:36:48 +02001659{
1660
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001661 const void *ptr;
Willy Tarreau631f01c2011-09-05 00:36:48 +02001662
1663 if (size < 5)
1664 return 0;
1665 *str = '\0';
1666
1667 switch (addr->ss_family) {
1668 case AF_INET:
1669 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1670 break;
1671 case AF_INET6:
1672 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1673 break;
1674 case AF_UNIX:
1675 memcpy(str, "unix", 5);
1676 return addr->ss_family;
1677 default:
1678 return 0;
1679 }
1680
1681 if (inet_ntop(addr->ss_family, ptr, str, size))
1682 return addr->ss_family;
1683
1684 /* failed */
1685 return -1;
1686}
1687
Simon Horman75ab8bd2014-06-16 09:39:41 +09001688/* Tries to convert a sockaddr_storage port to text form. Upon success, the
1689 * address family is returned so that it's easy for the caller to adapt to the
1690 * output format. Zero is returned if the address family is not supported. -1
1691 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1692 * supported.
1693 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001694int port_to_str(const struct sockaddr_storage *addr, char *str, int size)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001695{
1696
1697 uint16_t port;
1698
1699
Willy Tarreaud7dad1b2017-01-06 16:46:22 +01001700 if (size < 6)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001701 return 0;
1702 *str = '\0';
1703
1704 switch (addr->ss_family) {
1705 case AF_INET:
1706 port = ((struct sockaddr_in *)addr)->sin_port;
1707 break;
1708 case AF_INET6:
1709 port = ((struct sockaddr_in6 *)addr)->sin6_port;
1710 break;
1711 case AF_UNIX:
1712 memcpy(str, "unix", 5);
1713 return addr->ss_family;
1714 default:
1715 return 0;
1716 }
1717
1718 snprintf(str, size, "%u", ntohs(port));
1719 return addr->ss_family;
1720}
1721
Willy Tarreau16e01562016-08-09 16:46:18 +02001722/* check if the given address is local to the system or not. It will return
1723 * -1 when it's not possible to know, 0 when the address is not local, 1 when
1724 * it is. We don't want to iterate over all interfaces for this (and it is not
1725 * portable). So instead we try to bind in UDP to this address on a free non
1726 * privileged port and to connect to the same address, port 0 (connect doesn't
1727 * care). If it succeeds, we own the address. Note that non-inet addresses are
1728 * considered local since they're most likely AF_UNIX.
1729 */
1730int addr_is_local(const struct netns_entry *ns,
1731 const struct sockaddr_storage *orig)
1732{
1733 struct sockaddr_storage addr;
1734 int result;
1735 int fd;
1736
1737 if (!is_inet_addr(orig))
1738 return 1;
1739
1740 memcpy(&addr, orig, sizeof(addr));
1741 set_host_port(&addr, 0);
1742
1743 fd = my_socketat(ns, addr.ss_family, SOCK_DGRAM, IPPROTO_UDP);
1744 if (fd < 0)
1745 return -1;
1746
1747 result = -1;
1748 if (bind(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == 0) {
1749 if (connect(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == -1)
1750 result = 0; // fail, non-local address
1751 else
1752 result = 1; // success, local address
1753 }
1754 else {
1755 if (errno == EADDRNOTAVAIL)
1756 result = 0; // definitely not local :-)
1757 }
1758 close(fd);
1759
1760 return result;
1761}
1762
Willy Tarreaubaaee002006-06-26 02:48:02 +02001763/* will try to encode the string <string> replacing all characters tagged in
1764 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1765 * prefixed by <escape>, and will store the result between <start> (included)
1766 * and <stop> (excluded), and will always terminate the string with a '\0'
1767 * before <stop>. The position of the '\0' is returned if the conversion
1768 * completes. If bytes are missing between <start> and <stop>, then the
1769 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1770 * cannot even be stored so we return <start> without writing the 0.
1771 * The input string must also be zero-terminated.
1772 */
1773const char hextab[16] = "0123456789ABCDEF";
1774char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001775 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +02001776 const char *string)
1777{
1778 if (start < stop) {
1779 stop--; /* reserve one byte for the final '\0' */
1780 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001781 if (!ha_bit_test((unsigned char)(*string), map))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001782 *start++ = *string;
1783 else {
1784 if (start + 3 >= stop)
1785 break;
1786 *start++ = escape;
1787 *start++ = hextab[(*string >> 4) & 15];
1788 *start++ = hextab[*string & 15];
1789 }
1790 string++;
1791 }
1792 *start = '\0';
1793 }
1794 return start;
1795}
1796
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001797/*
1798 * Same behavior as encode_string() above, except that it encodes chunk
1799 * <chunk> instead of a string.
1800 */
1801char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001802 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001803 const struct buffer *chunk)
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001804{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001805 char *str = chunk->area;
1806 char *end = chunk->area + chunk->data;
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001807
1808 if (start < stop) {
1809 stop--; /* reserve one byte for the final '\0' */
1810 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001811 if (!ha_bit_test((unsigned char)(*str), map))
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001812 *start++ = *str;
1813 else {
1814 if (start + 3 >= stop)
1815 break;
1816 *start++ = escape;
1817 *start++ = hextab[(*str >> 4) & 15];
1818 *start++ = hextab[*str & 15];
1819 }
1820 str++;
1821 }
1822 *start = '\0';
1823 }
1824 return start;
1825}
1826
Dragan Dosen0edd1092016-02-12 13:23:02 +01001827/*
1828 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001829 * character. The input <string> must be zero-terminated. The result will
1830 * be stored between <start> (included) and <stop> (excluded). This
1831 * function will always try to terminate the resulting string with a '\0'
1832 * before <stop>, and will return its position if the conversion
1833 * completes.
1834 */
1835char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001836 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001837 const char *string)
1838{
1839 if (start < stop) {
1840 stop--; /* reserve one byte for the final '\0' */
1841 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001842 if (!ha_bit_test((unsigned char)(*string), map))
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001843 *start++ = *string;
1844 else {
1845 if (start + 2 >= stop)
1846 break;
1847 *start++ = escape;
1848 *start++ = *string;
1849 }
1850 string++;
1851 }
1852 *start = '\0';
1853 }
1854 return start;
1855}
1856
1857/*
1858 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +01001859 * character. <chunk> contains the input to be escaped. The result will be
1860 * stored between <start> (included) and <stop> (excluded). The function
1861 * will always try to terminate the resulting string with a '\0' before
1862 * <stop>, and will return its position if the conversion completes.
1863 */
1864char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001865 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001866 const struct buffer *chunk)
Dragan Dosen0edd1092016-02-12 13:23:02 +01001867{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001868 char *str = chunk->area;
1869 char *end = chunk->area + chunk->data;
Dragan Dosen0edd1092016-02-12 13:23:02 +01001870
1871 if (start < stop) {
1872 stop--; /* reserve one byte for the final '\0' */
1873 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001874 if (!ha_bit_test((unsigned char)(*str), map))
Dragan Dosen0edd1092016-02-12 13:23:02 +01001875 *start++ = *str;
1876 else {
1877 if (start + 2 >= stop)
1878 break;
1879 *start++ = escape;
1880 *start++ = *str;
1881 }
1882 str++;
1883 }
1884 *start = '\0';
1885 }
1886 return start;
1887}
1888
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001889/* Check a string for using it in a CSV output format. If the string contains
1890 * one of the following four char <">, <,>, CR or LF, the string is
1891 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
1892 * <str> is the input string to be escaped. The function assumes that
1893 * the input string is null-terminated.
1894 *
1895 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +01001896 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001897 * format.
1898 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001899 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001900 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001901 * If <quote> is 1, the converter puts the quotes only if any reserved character
1902 * is present. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001903 *
Willy Tarreau83061a82018-07-13 11:56:34 +02001904 * <output> is a struct buffer used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001905 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001906 * The function returns the converted string on its output. If an error
1907 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001908 * for using the function directly as printf() argument.
1909 *
1910 * If the output buffer is too short to contain the input string, the result
1911 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +01001912 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001913 * This function appends the encoding to the existing output chunk, and it
1914 * guarantees that it starts immediately at the first available character of
1915 * the chunk. Please use csv_enc() instead if you want to replace the output
1916 * chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001917 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001918const char *csv_enc_append(const char *str, int quote, struct buffer *output)
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001919{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001920 char *end = output->area + output->size;
1921 char *out = output->area + output->data;
Willy Tarreau898529b2016-01-06 18:07:04 +01001922 char *ptr = out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001923
Willy Tarreaub631c292016-01-08 10:04:08 +01001924 if (quote == 1) {
1925 /* automatic quoting: first verify if we'll have to quote the string */
1926 if (!strpbrk(str, "\n\r,\""))
1927 quote = 0;
1928 }
1929
1930 if (quote)
1931 *ptr++ = '"';
1932
Willy Tarreau898529b2016-01-06 18:07:04 +01001933 while (*str && ptr < end - 2) { /* -2 for reserving space for <"> and \0. */
1934 *ptr = *str;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001935 if (*str == '"') {
Willy Tarreau898529b2016-01-06 18:07:04 +01001936 ptr++;
1937 if (ptr >= end - 2) {
1938 ptr--;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001939 break;
1940 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001941 *ptr = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001942 }
Willy Tarreau898529b2016-01-06 18:07:04 +01001943 ptr++;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001944 str++;
1945 }
1946
Willy Tarreaub631c292016-01-08 10:04:08 +01001947 if (quote)
1948 *ptr++ = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001949
Willy Tarreau898529b2016-01-06 18:07:04 +01001950 *ptr = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001951 output->data = ptr - output->area;
Willy Tarreau898529b2016-01-06 18:07:04 +01001952 return out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001953}
1954
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001955/* Decode an URL-encoded string in-place. The resulting string might
1956 * be shorter. If some forbidden characters are found, the conversion is
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001957 * aborted, the string is truncated before the issue and a negative value is
1958 * returned, otherwise the operation returns the length of the decoded string.
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001959 * If the 'in_form' argument is non-nul the string is assumed to be part of
1960 * an "application/x-www-form-urlencoded" encoded string, and the '+' will be
1961 * turned to a space. If it's zero, this will only be done after a question
1962 * mark ('?').
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001963 */
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001964int url_decode(char *string, int in_form)
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001965{
1966 char *in, *out;
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001967 int ret = -1;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001968
1969 in = string;
1970 out = string;
1971 while (*in) {
1972 switch (*in) {
1973 case '+' :
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001974 *out++ = in_form ? ' ' : *in;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001975 break;
1976 case '%' :
1977 if (!ishex(in[1]) || !ishex(in[2]))
1978 goto end;
1979 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
1980 in += 2;
1981 break;
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02001982 case '?':
1983 in_form = 1;
1984 /* fall through */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001985 default:
1986 *out++ = *in;
1987 break;
1988 }
1989 in++;
1990 }
Thierry FOURNIER5068d962013-10-04 16:27:27 +02001991 ret = out - string; /* success */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001992 end:
1993 *out = 0;
1994 return ret;
1995}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001996
Willy Tarreau6911fa42007-03-04 18:06:08 +01001997unsigned int str2ui(const char *s)
1998{
1999 return __str2ui(s);
2000}
2001
2002unsigned int str2uic(const char *s)
2003{
2004 return __str2uic(s);
2005}
2006
2007unsigned int strl2ui(const char *s, int len)
2008{
2009 return __strl2ui(s, len);
2010}
2011
2012unsigned int strl2uic(const char *s, int len)
2013{
2014 return __strl2uic(s, len);
2015}
2016
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02002017unsigned int read_uint(const char **s, const char *end)
2018{
2019 return __read_uint(s, end);
2020}
2021
Thierry FOURNIER763a5d82015-07-06 23:09:52 +02002022/* This function reads an unsigned integer from the string pointed to by <s> and
2023 * returns it. The <s> pointer is adjusted to point to the first unread char. The
2024 * function automatically stops at <end>. If the number overflows, the 2^64-1
2025 * value is returned.
2026 */
2027unsigned long long int read_uint64(const char **s, const char *end)
2028{
2029 const char *ptr = *s;
2030 unsigned long long int i = 0, tmp;
2031 unsigned int j;
2032
2033 while (ptr < end) {
2034
2035 /* read next char */
2036 j = *ptr - '0';
2037 if (j > 9)
2038 goto read_uint64_end;
2039
2040 /* add char to the number and check overflow. */
2041 tmp = i * 10;
2042 if (tmp / 10 != i) {
2043 i = ULLONG_MAX;
2044 goto read_uint64_eat;
2045 }
2046 if (ULLONG_MAX - tmp < j) {
2047 i = ULLONG_MAX;
2048 goto read_uint64_eat;
2049 }
2050 i = tmp + j;
2051 ptr++;
2052 }
2053read_uint64_eat:
2054 /* eat each numeric char */
2055 while (ptr < end) {
2056 if ((unsigned int)(*ptr - '0') > 9)
2057 break;
2058 ptr++;
2059 }
2060read_uint64_end:
2061 *s = ptr;
2062 return i;
2063}
2064
2065/* This function reads an integer from the string pointed to by <s> and returns
2066 * it. The <s> pointer is adjusted to point to the first unread char. The function
2067 * automatically stops at <end>. Il the number is bigger than 2^63-2, the 2^63-1
2068 * value is returned. If the number is lowest than -2^63-1, the -2^63 value is
2069 * returned.
2070 */
2071long long int read_int64(const char **s, const char *end)
2072{
2073 unsigned long long int i = 0;
2074 int neg = 0;
2075
2076 /* Look for minus char. */
2077 if (**s == '-') {
2078 neg = 1;
2079 (*s)++;
2080 }
2081 else if (**s == '+')
2082 (*s)++;
2083
2084 /* convert as positive number. */
2085 i = read_uint64(s, end);
2086
2087 if (neg) {
2088 if (i > 0x8000000000000000ULL)
2089 return LLONG_MIN;
2090 return -i;
2091 }
2092 if (i > 0x7fffffffffffffffULL)
2093 return LLONG_MAX;
2094 return i;
2095}
2096
Willy Tarreau6911fa42007-03-04 18:06:08 +01002097/* This one is 7 times faster than strtol() on athlon with checks.
2098 * It returns the value of the number composed of all valid digits read,
2099 * and can process negative numbers too.
2100 */
2101int strl2ic(const char *s, int len)
2102{
2103 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002104 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002105
2106 if (len > 0) {
2107 if (*s != '-') {
2108 /* positive number */
2109 while (len-- > 0) {
2110 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002111 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002112 if (j > 9)
2113 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002114 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002115 }
2116 } else {
2117 /* negative number */
2118 s++;
2119 while (--len > 0) {
2120 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002121 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002122 if (j > 9)
2123 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002124 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002125 }
2126 }
2127 }
2128 return i;
2129}
2130
2131
2132/* This function reads exactly <len> chars from <s> and converts them to a
2133 * signed integer which it stores into <ret>. It accurately detects any error
2134 * (truncated string, invalid chars, overflows). It is meant to be used in
2135 * applications designed for hostile environments. It returns zero when the
2136 * number has successfully been converted, non-zero otherwise. When an error
2137 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
2138 * faster than strtol().
2139 */
2140int strl2irc(const char *s, int len, int *ret)
2141{
2142 int i = 0;
2143 int j;
2144
2145 if (!len)
2146 return 1;
2147
2148 if (*s != '-') {
2149 /* positive number */
2150 while (len-- > 0) {
2151 j = (*s++) - '0';
2152 if (j > 9) return 1; /* invalid char */
2153 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
2154 i = i * 10;
2155 if (i + j < i) return 1; /* check for addition overflow */
2156 i = i + j;
2157 }
2158 } else {
2159 /* negative number */
2160 s++;
2161 while (--len > 0) {
2162 j = (*s++) - '0';
2163 if (j > 9) return 1; /* invalid char */
2164 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
2165 i = i * 10;
2166 if (i - j > i) return 1; /* check for subtract overflow */
2167 i = i - j;
2168 }
2169 }
2170 *ret = i;
2171 return 0;
2172}
2173
2174
2175/* This function reads exactly <len> chars from <s> and converts them to a
2176 * signed integer which it stores into <ret>. It accurately detects any error
2177 * (truncated string, invalid chars, overflows). It is meant to be used in
2178 * applications designed for hostile environments. It returns zero when the
2179 * number has successfully been converted, non-zero otherwise. When an error
2180 * is returned, the <ret> value is left untouched. It is about 3 times slower
2181 * than str2irc().
2182 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01002183
2184int strl2llrc(const char *s, int len, long long *ret)
2185{
2186 long long i = 0;
2187 int j;
2188
2189 if (!len)
2190 return 1;
2191
2192 if (*s != '-') {
2193 /* positive number */
2194 while (len-- > 0) {
2195 j = (*s++) - '0';
2196 if (j > 9) return 1; /* invalid char */
2197 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
2198 i = i * 10LL;
2199 if (i + j < i) return 1; /* check for addition overflow */
2200 i = i + j;
2201 }
2202 } else {
2203 /* negative number */
2204 s++;
2205 while (--len > 0) {
2206 j = (*s++) - '0';
2207 if (j > 9) return 1; /* invalid char */
2208 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
2209 i = i * 10LL;
2210 if (i - j > i) return 1; /* check for subtract overflow */
2211 i = i - j;
2212 }
2213 }
2214 *ret = i;
2215 return 0;
2216}
2217
Thierry FOURNIER511e9472014-01-23 17:40:34 +01002218/* This function is used with pat_parse_dotted_ver(). It converts a string
2219 * composed by two number separated by a dot. Each part must contain in 16 bits
2220 * because internally they will be represented as a 32-bit quantity stored in
2221 * a 64-bit integer. It returns zero when the number has successfully been
2222 * converted, non-zero otherwise. When an error is returned, the <ret> value
2223 * is left untouched.
2224 *
2225 * "1.3" -> 0x0000000000010003
2226 * "65535.65535" -> 0x00000000ffffffff
2227 */
2228int strl2llrc_dotted(const char *text, int len, long long *ret)
2229{
2230 const char *end = &text[len];
2231 const char *p;
2232 long long major, minor;
2233
2234 /* Look for dot. */
2235 for (p = text; p < end; p++)
2236 if (*p == '.')
2237 break;
2238
2239 /* Convert major. */
2240 if (strl2llrc(text, p - text, &major) != 0)
2241 return 1;
2242
2243 /* Check major. */
2244 if (major >= 65536)
2245 return 1;
2246
2247 /* Convert minor. */
2248 minor = 0;
2249 if (p < end)
2250 if (strl2llrc(p + 1, end - (p + 1), &minor) != 0)
2251 return 1;
2252
2253 /* Check minor. */
2254 if (minor >= 65536)
2255 return 1;
2256
2257 /* Compose value. */
2258 *ret = (major << 16) | (minor & 0xffff);
2259 return 0;
2260}
2261
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002262/* This function parses a time value optionally followed by a unit suffix among
2263 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
2264 * expected by the caller. The computation does its best to avoid overflows.
2265 * The value is returned in <ret> if everything is fine, and a NULL is returned
2266 * by the function. In case of error, a pointer to the error is returned and
2267 * <ret> is left untouched. Values are automatically rounded up when needed.
Willy Tarreau9faebe32019-06-07 19:00:37 +02002268 * Values resulting in values larger than or equal to 2^31 after conversion are
2269 * reported as an overflow as value PARSE_TIME_OVER. Non-null values resulting
2270 * in an underflow are reported as an underflow as value PARSE_TIME_UNDER.
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002271 */
2272const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
2273{
Willy Tarreau9faebe32019-06-07 19:00:37 +02002274 unsigned long long imult, idiv;
2275 unsigned long long omult, odiv;
2276 unsigned long long value, result;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002277 const char *str = text;
2278
2279 if (!isdigit((unsigned char)*text))
2280 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002281
2282 omult = odiv = 1;
2283
2284 switch (unit_flags & TIME_UNIT_MASK) {
2285 case TIME_UNIT_US: omult = 1000000; break;
2286 case TIME_UNIT_MS: omult = 1000; break;
2287 case TIME_UNIT_S: break;
2288 case TIME_UNIT_MIN: odiv = 60; break;
2289 case TIME_UNIT_HOUR: odiv = 3600; break;
2290 case TIME_UNIT_DAY: odiv = 86400; break;
2291 default: break;
2292 }
2293
2294 value = 0;
2295
2296 while (1) {
2297 unsigned int j;
2298
2299 j = *text - '0';
2300 if (j > 9)
2301 break;
2302 text++;
2303 value *= 10;
2304 value += j;
2305 }
2306
2307 imult = idiv = 1;
2308 switch (*text) {
2309 case '\0': /* no unit = default unit */
2310 imult = omult = idiv = odiv = 1;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002311 goto end;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002312 case 's': /* second = unscaled unit */
2313 break;
2314 case 'u': /* microsecond : "us" */
2315 if (text[1] == 's') {
2316 idiv = 1000000;
2317 text++;
2318 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002319 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002320 case 'm': /* millisecond : "ms" or minute: "m" */
2321 if (text[1] == 's') {
2322 idiv = 1000;
2323 text++;
2324 } else
2325 imult = 60;
2326 break;
2327 case 'h': /* hour : "h" */
2328 imult = 3600;
2329 break;
2330 case 'd': /* day : "d" */
2331 imult = 86400;
2332 break;
2333 default:
2334 return text;
2335 break;
2336 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002337 if (*(++text) != '\0') {
2338 ha_warning("unexpected character '%c' after the timer value '%s', only "
2339 "(us=microseconds,ms=milliseconds,s=seconds,m=minutes,h=hours,d=days) are supported."
2340 " This will be reported as an error in next versions.\n", *text, str);
2341 }
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002342
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002343 end:
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002344 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
2345 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
2346 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
2347 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
2348
Willy Tarreau9faebe32019-06-07 19:00:37 +02002349 result = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
2350 if (result >= 0x80000000)
2351 return PARSE_TIME_OVER;
2352 if (!result && value)
2353 return PARSE_TIME_UNDER;
2354 *ret = result;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002355 return NULL;
2356}
Willy Tarreau6911fa42007-03-04 18:06:08 +01002357
Emeric Brun39132b22010-01-04 14:57:24 +01002358/* this function converts the string starting at <text> to an unsigned int
2359 * stored in <ret>. If an error is detected, the pointer to the unexpected
Joseph Herlant32b83272018-11-15 11:58:28 -08002360 * character is returned. If the conversion is successful, NULL is returned.
Emeric Brun39132b22010-01-04 14:57:24 +01002361 */
2362const char *parse_size_err(const char *text, unsigned *ret) {
2363 unsigned value = 0;
2364
Christopher Faulet82635a02020-12-11 09:30:45 +01002365 if (!isdigit((unsigned char)*text))
2366 return text;
2367
Emeric Brun39132b22010-01-04 14:57:24 +01002368 while (1) {
2369 unsigned int j;
2370
2371 j = *text - '0';
2372 if (j > 9)
2373 break;
2374 if (value > ~0U / 10)
2375 return text;
2376 value *= 10;
2377 if (value > (value + j))
2378 return text;
2379 value += j;
2380 text++;
2381 }
2382
2383 switch (*text) {
2384 case '\0':
2385 break;
2386 case 'K':
2387 case 'k':
2388 if (value > ~0U >> 10)
2389 return text;
2390 value = value << 10;
2391 break;
2392 case 'M':
2393 case 'm':
2394 if (value > ~0U >> 20)
2395 return text;
2396 value = value << 20;
2397 break;
2398 case 'G':
2399 case 'g':
2400 if (value > ~0U >> 30)
2401 return text;
2402 value = value << 30;
2403 break;
2404 default:
2405 return text;
2406 }
2407
Godbach58048a22015-01-28 17:36:16 +08002408 if (*text != '\0' && *++text != '\0')
2409 return text;
2410
Emeric Brun39132b22010-01-04 14:57:24 +01002411 *ret = value;
2412 return NULL;
2413}
2414
Willy Tarreau126d4062013-12-03 17:50:47 +01002415/*
2416 * Parse binary string written in hexadecimal (source) and store the decoded
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002417 * result into binstr and set binstrlen to the length of binstr. Memory for
Willy Tarreau126d4062013-12-03 17:50:47 +01002418 * binstr is allocated by the function. In case of error, returns 0 with an
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002419 * error message in err. In success case, it returns the consumed length.
Willy Tarreau126d4062013-12-03 17:50:47 +01002420 */
2421int parse_binary(const char *source, char **binstr, int *binstrlen, char **err)
2422{
2423 int len;
2424 const char *p = source;
2425 int i,j;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002426 int alloc;
Willy Tarreau126d4062013-12-03 17:50:47 +01002427
2428 len = strlen(source);
2429 if (len % 2) {
2430 memprintf(err, "an even number of hex digit is expected");
2431 return 0;
2432 }
2433
2434 len = len >> 1;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002435
Willy Tarreau126d4062013-12-03 17:50:47 +01002436 if (!*binstr) {
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02002437 *binstr = calloc(len, sizeof(**binstr));
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002438 if (!*binstr) {
2439 memprintf(err, "out of memory while loading string pattern");
2440 return 0;
2441 }
2442 alloc = 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002443 }
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002444 else {
2445 if (*binstrlen < len) {
Joseph Herlant76dbe782018-11-15 12:01:22 -08002446 memprintf(err, "no space available in the buffer. expect %d, provides %d",
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002447 len, *binstrlen);
2448 return 0;
2449 }
2450 alloc = 0;
2451 }
2452 *binstrlen = len;
Willy Tarreau126d4062013-12-03 17:50:47 +01002453
2454 i = j = 0;
2455 while (j < len) {
2456 if (!ishex(p[i++]))
2457 goto bad_input;
2458 if (!ishex(p[i++]))
2459 goto bad_input;
2460 (*binstr)[j++] = (hex2i(p[i-2]) << 4) + hex2i(p[i-1]);
2461 }
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002462 return len << 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002463
2464bad_input:
2465 memprintf(err, "an hex digit is expected (found '%c')", p[i-1]);
Andreas Seltenreich93f91c32016-03-03 20:40:37 +01002466 if (alloc) {
2467 free(*binstr);
2468 *binstr = NULL;
2469 }
Willy Tarreau126d4062013-12-03 17:50:47 +01002470 return 0;
2471}
2472
Willy Tarreau946ba592009-05-10 15:41:18 +02002473/* copies at most <n> characters from <src> and always terminates with '\0' */
2474char *my_strndup(const char *src, int n)
2475{
2476 int len = 0;
2477 char *ret;
2478
2479 while (len < n && src[len])
2480 len++;
2481
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002482 ret = malloc(len + 1);
Willy Tarreau946ba592009-05-10 15:41:18 +02002483 if (!ret)
2484 return ret;
2485 memcpy(ret, src, len);
2486 ret[len] = '\0';
2487 return ret;
2488}
2489
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02002490/*
2491 * search needle in haystack
2492 * returns the pointer if found, returns NULL otherwise
2493 */
2494const void *my_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
2495{
2496 const void *c = NULL;
2497 unsigned char f;
2498
2499 if ((haystack == NULL) || (needle == NULL) || (haystacklen < needlelen))
2500 return NULL;
2501
2502 f = *(char *)needle;
2503 c = haystack;
2504 while ((c = memchr(c, f, haystacklen - (c - haystack))) != NULL) {
2505 if ((haystacklen - (c - haystack)) < needlelen)
2506 return NULL;
2507
2508 if (memcmp(c, needle, needlelen) == 0)
2509 return c;
2510 ++c;
2511 }
2512 return NULL;
2513}
2514
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002515/* get length of the initial segment consisting entirely of bytes in <accept> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002516size_t my_memspn(const void *str, size_t len, const void *accept, size_t acceptlen)
2517{
2518 size_t ret = 0;
2519
2520 while (ret < len && memchr(accept, *((int *)str), acceptlen)) {
2521 str++;
2522 ret++;
2523 }
2524 return ret;
2525}
2526
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002527/* get length of the initial segment consisting entirely of bytes not in <rejcet> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002528size_t my_memcspn(const void *str, size_t len, const void *reject, size_t rejectlen)
2529{
2530 size_t ret = 0;
2531
2532 while (ret < len) {
2533 if(memchr(reject, *((int *)str), rejectlen))
2534 return ret;
2535 str++;
2536 ret++;
2537 }
2538 return ret;
2539}
2540
Willy Tarreau482b00d2009-10-04 22:48:42 +02002541/* This function returns the first unused key greater than or equal to <key> in
2542 * ID tree <root>. Zero is returned if no place is found.
2543 */
2544unsigned int get_next_id(struct eb_root *root, unsigned int key)
2545{
2546 struct eb32_node *used;
2547
2548 do {
2549 used = eb32_lookup_ge(root, key);
2550 if (!used || used->key > key)
2551 return key; /* key is available */
2552 key++;
2553 } while (key);
2554 return key;
2555}
2556
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002557/* dump the full tree to <file> in DOT format for debugging purposes. Will
2558 * optionally highlight node <subj> if found, depending on operation <op> :
2559 * 0 : nothing
2560 * >0 : insertion, node/leaf are surrounded in red
2561 * <0 : removal, node/leaf are dashed with no background
2562 * Will optionally add "desc" as a label on the graph if set and non-null.
2563 */
2564void 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 +01002565{
2566 struct eb32sc_node *node;
2567 unsigned long scope = -1;
2568
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002569 fprintf(file, "digraph ebtree {\n");
2570
2571 if (desc && *desc) {
2572 fprintf(file,
2573 " fontname=\"fixed\";\n"
2574 " fontsize=8;\n"
2575 " label=\"%s\";\n", desc);
2576 }
2577
Willy Tarreaued3cda02017-11-15 15:04:05 +01002578 fprintf(file,
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002579 " node [fontname=\"fixed\" fontsize=8 shape=\"box\" style=\"filled\" color=\"black\" fillcolor=\"white\"];\n"
2580 " edge [fontname=\"fixed\" fontsize=8 style=\"solid\" color=\"magenta\" dir=\"forward\"];\n"
Willy Tarreaued3cda02017-11-15 15:04:05 +01002581 " \"%lx_n\" [label=\"root\\n%lx\"]\n", (long)eb_root_to_node(root), (long)root
2582 );
2583
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002584 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002585 (long)eb_root_to_node(root),
2586 (long)eb_root_to_node(eb_clrtag(root->b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002587 eb_gettag(root->b[0]) == EB_LEAF ? 'l' : 'n');
2588
2589 node = eb32sc_first(root, scope);
2590 while (node) {
2591 if (node->node.node_p) {
2592 /* node part is used */
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002593 fprintf(file, " \"%lx_n\" [label=\"%lx\\nkey=%u\\nscope=%lx\\nbit=%d\" fillcolor=\"lightskyblue1\" %s];\n",
2594 (long)node, (long)node, node->key, node->node_s, node->node.bit,
2595 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002596
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002597 fprintf(file, " \"%lx_n\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002598 (long)node,
2599 (long)eb_root_to_node(eb_clrtag(node->node.node_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002600 eb_gettag(node->node.node_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002601
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002602 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002603 (long)node,
2604 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002605 eb_gettag(node->node.branches.b[0]) == EB_LEAF ? 'l' : 'n');
2606
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002607 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"R\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002608 (long)node,
2609 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[1])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002610 eb_gettag(node->node.branches.b[1]) == EB_LEAF ? 'l' : 'n');
2611 }
2612
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002613 fprintf(file, " \"%lx_l\" [label=\"%lx\\nkey=%u\\nscope=%lx\\npfx=%u\" fillcolor=\"yellow\" %s];\n",
2614 (long)node, (long)node, node->key, node->leaf_s, node->node.pfx,
2615 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002616
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002617 fprintf(file, " \"%lx_l\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002618 (long)node,
2619 (long)eb_root_to_node(eb_clrtag(node->node.leaf_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002620 eb_gettag(node->node.leaf_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002621 node = eb32sc_next(node, scope);
2622 }
2623 fprintf(file, "}\n");
2624}
2625
Willy Tarreau348238b2010-01-18 15:05:57 +01002626/* This function compares a sample word possibly followed by blanks to another
2627 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
2628 * otherwise zero. This intends to be used when checking HTTP headers for some
2629 * values. Note that it validates a word followed only by blanks but does not
2630 * validate a word followed by blanks then other chars.
2631 */
2632int word_match(const char *sample, int slen, const char *word, int wlen)
2633{
2634 if (slen < wlen)
2635 return 0;
2636
2637 while (wlen) {
2638 char c = *sample ^ *word;
2639 if (c && c != ('A' ^ 'a'))
2640 return 0;
2641 sample++;
2642 word++;
2643 slen--;
2644 wlen--;
2645 }
2646
2647 while (slen) {
2648 if (*sample != ' ' && *sample != '\t')
2649 return 0;
2650 sample++;
2651 slen--;
2652 }
2653 return 1;
2654}
Willy Tarreau482b00d2009-10-04 22:48:42 +02002655
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002656/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
2657 * is particularly fast because it avoids expensive operations such as
2658 * multiplies, which are optimized away at the end. It requires a properly
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002659 * formatted address though (3 points).
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002660 */
2661unsigned int inetaddr_host(const char *text)
2662{
2663 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2664 register unsigned int dig100, dig10, dig1;
2665 int s;
2666 const char *p, *d;
2667
2668 dig1 = dig10 = dig100 = ascii_zero;
2669 s = 24;
2670
2671 p = text;
2672 while (1) {
2673 if (((unsigned)(*p - '0')) <= 9) {
2674 p++;
2675 continue;
2676 }
2677
2678 /* here, we have a complete byte between <text> and <p> (exclusive) */
2679 if (p == text)
2680 goto end;
2681
2682 d = p - 1;
2683 dig1 |= (unsigned int)(*d << s);
2684 if (d == text)
2685 goto end;
2686
2687 d--;
2688 dig10 |= (unsigned int)(*d << s);
2689 if (d == text)
2690 goto end;
2691
2692 d--;
2693 dig100 |= (unsigned int)(*d << s);
2694 end:
2695 if (!s || *p != '.')
2696 break;
2697
2698 s -= 8;
2699 text = ++p;
2700 }
2701
2702 dig100 -= ascii_zero;
2703 dig10 -= ascii_zero;
2704 dig1 -= ascii_zero;
2705 return ((dig100 * 10) + dig10) * 10 + dig1;
2706}
2707
2708/*
2709 * Idem except the first unparsed character has to be passed in <stop>.
2710 */
2711unsigned int inetaddr_host_lim(const char *text, const char *stop)
2712{
2713 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2714 register unsigned int dig100, dig10, dig1;
2715 int s;
2716 const char *p, *d;
2717
2718 dig1 = dig10 = dig100 = ascii_zero;
2719 s = 24;
2720
2721 p = text;
2722 while (1) {
2723 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2724 p++;
2725 continue;
2726 }
2727
2728 /* here, we have a complete byte between <text> and <p> (exclusive) */
2729 if (p == text)
2730 goto end;
2731
2732 d = p - 1;
2733 dig1 |= (unsigned int)(*d << s);
2734 if (d == text)
2735 goto end;
2736
2737 d--;
2738 dig10 |= (unsigned int)(*d << s);
2739 if (d == text)
2740 goto end;
2741
2742 d--;
2743 dig100 |= (unsigned int)(*d << s);
2744 end:
2745 if (!s || p == stop || *p != '.')
2746 break;
2747
2748 s -= 8;
2749 text = ++p;
2750 }
2751
2752 dig100 -= ascii_zero;
2753 dig10 -= ascii_zero;
2754 dig1 -= ascii_zero;
2755 return ((dig100 * 10) + dig10) * 10 + dig1;
2756}
2757
2758/*
2759 * Idem except the pointer to first unparsed byte is returned into <ret> which
2760 * must not be NULL.
2761 */
Willy Tarreau74172752010-10-15 23:21:42 +02002762unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002763{
2764 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2765 register unsigned int dig100, dig10, dig1;
2766 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02002767 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002768
2769 dig1 = dig10 = dig100 = ascii_zero;
2770 s = 24;
2771
2772 p = text;
2773 while (1) {
2774 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2775 p++;
2776 continue;
2777 }
2778
2779 /* here, we have a complete byte between <text> and <p> (exclusive) */
2780 if (p == text)
2781 goto end;
2782
2783 d = p - 1;
2784 dig1 |= (unsigned int)(*d << s);
2785 if (d == text)
2786 goto end;
2787
2788 d--;
2789 dig10 |= (unsigned int)(*d << s);
2790 if (d == text)
2791 goto end;
2792
2793 d--;
2794 dig100 |= (unsigned int)(*d << s);
2795 end:
2796 if (!s || p == stop || *p != '.')
2797 break;
2798
2799 s -= 8;
2800 text = ++p;
2801 }
2802
2803 *ret = p;
2804 dig100 -= ascii_zero;
2805 dig10 -= ascii_zero;
2806 dig1 -= ascii_zero;
2807 return ((dig100 * 10) + dig10) * 10 + dig1;
2808}
2809
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002810/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
2811 * or the number of chars read in case of success. Maybe this could be replaced
2812 * by one of the functions above. Also, apparently this function does not support
2813 * hosts above 255 and requires exactly 4 octets.
Willy Tarreau075415a2013-12-12 11:29:39 +01002814 * The destination is only modified on success.
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002815 */
2816int buf2ip(const char *buf, size_t len, struct in_addr *dst)
2817{
2818 const char *addr;
2819 int saw_digit, octets, ch;
2820 u_char tmp[4], *tp;
2821 const char *cp = buf;
2822
2823 saw_digit = 0;
2824 octets = 0;
2825 *(tp = tmp) = 0;
2826
2827 for (addr = buf; addr - buf < len; addr++) {
2828 unsigned char digit = (ch = *addr) - '0';
2829
2830 if (digit > 9 && ch != '.')
2831 break;
2832
2833 if (digit <= 9) {
2834 u_int new = *tp * 10 + digit;
2835
2836 if (new > 255)
2837 return 0;
2838
2839 *tp = new;
2840
2841 if (!saw_digit) {
2842 if (++octets > 4)
2843 return 0;
2844 saw_digit = 1;
2845 }
2846 } else if (ch == '.' && saw_digit) {
2847 if (octets == 4)
2848 return 0;
2849
2850 *++tp = 0;
2851 saw_digit = 0;
2852 } else
2853 return 0;
2854 }
2855
2856 if (octets < 4)
2857 return 0;
2858
2859 memcpy(&dst->s_addr, tmp, 4);
2860 return addr - cp;
2861}
2862
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002863/* This function converts the string in <buf> of the len <len> to
2864 * struct in6_addr <dst> which must be allocated by the caller.
2865 * This function returns 1 in success case, otherwise zero.
Willy Tarreau075415a2013-12-12 11:29:39 +01002866 * The destination is only modified on success.
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002867 */
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002868int buf2ip6(const char *buf, size_t len, struct in6_addr *dst)
2869{
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002870 char null_term_ip6[INET6_ADDRSTRLEN + 1];
Willy Tarreau075415a2013-12-12 11:29:39 +01002871 struct in6_addr out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002872
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002873 if (len > INET6_ADDRSTRLEN)
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002874 return 0;
2875
2876 memcpy(null_term_ip6, buf, len);
2877 null_term_ip6[len] = '\0';
2878
Willy Tarreau075415a2013-12-12 11:29:39 +01002879 if (!inet_pton(AF_INET6, null_term_ip6, &out))
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002880 return 0;
2881
Willy Tarreau075415a2013-12-12 11:29:39 +01002882 *dst = out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002883 return 1;
2884}
2885
Willy Tarreauacf95772010-06-14 19:09:21 +02002886/* To be used to quote config arg positions. Returns the short string at <ptr>
2887 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
2888 * if ptr is NULL or empty. The string is locally allocated.
2889 */
2890const char *quote_arg(const char *ptr)
2891{
Christopher Faulet1bc04c72017-10-29 20:14:08 +01002892 static THREAD_LOCAL char val[32];
Willy Tarreauacf95772010-06-14 19:09:21 +02002893 int i;
2894
2895 if (!ptr || !*ptr)
2896 return "end of line";
2897 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01002898 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02002899 val[i] = *ptr++;
2900 val[i++] = '\'';
2901 val[i] = '\0';
2902 return val;
2903}
2904
Willy Tarreau5b180202010-07-18 10:40:48 +02002905/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
2906int get_std_op(const char *str)
2907{
2908 int ret = -1;
2909
2910 if (*str == 'e' && str[1] == 'q')
2911 ret = STD_OP_EQ;
2912 else if (*str == 'n' && str[1] == 'e')
2913 ret = STD_OP_NE;
2914 else if (*str == 'l') {
2915 if (str[1] == 'e') ret = STD_OP_LE;
2916 else if (str[1] == 't') ret = STD_OP_LT;
2917 }
2918 else if (*str == 'g') {
2919 if (str[1] == 'e') ret = STD_OP_GE;
2920 else if (str[1] == 't') ret = STD_OP_GT;
2921 }
2922
2923 if (ret == -1 || str[2] != '\0')
2924 return -1;
2925 return ret;
2926}
2927
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01002928/* hash a 32-bit integer to another 32-bit integer */
2929unsigned int full_hash(unsigned int a)
2930{
2931 return __full_hash(a);
2932}
2933
Willy Tarreauf3241112019-02-26 09:56:22 +01002934/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
2935 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
2936 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
2937 * a popcount variant and is described here :
2938 * https://graphics.stanford.edu/~seander/bithacks.html
2939 */
2940unsigned int mask_find_rank_bit(unsigned int r, unsigned long m)
2941{
2942 unsigned long a, b, c, d;
2943 unsigned int s;
2944 unsigned int t;
2945
2946 a = m - ((m >> 1) & ~0UL/3);
2947 b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
2948 c = (b + (b >> 4)) & ~0UL/0x11;
2949 d = (c + (c >> 8)) & ~0UL/0x101;
2950
2951 r++; // make r be 1..64
2952
2953 t = 0;
2954 s = LONGBITS;
2955 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002956 unsigned long d2 = (d >> 16) >> 16;
2957 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002958 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2959 }
2960
2961 t = (d >> (s - 16)) & 0xff;
2962 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2963 t = (c >> (s - 8)) & 0xf;
2964 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
2965 t = (b >> (s - 4)) & 0x7;
2966 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
2967 t = (a >> (s - 2)) & 0x3;
2968 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
2969 t = (m >> (s - 1)) & 0x1;
2970 s -= ((t - r) & 256) >> 8;
2971
2972 return s - 1;
2973}
2974
2975/* Same as mask_find_rank_bit() above but makes use of pre-computed bitmaps
2976 * based on <m>, in <a..d>. These ones must be updated whenever <m> changes
2977 * using mask_prep_rank_map() below.
2978 */
2979unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
2980 unsigned long a, unsigned long b,
2981 unsigned long c, unsigned long d)
2982{
2983 unsigned int s;
2984 unsigned int t;
2985
2986 r++; // make r be 1..64
2987
2988 t = 0;
2989 s = LONGBITS;
2990 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01002991 unsigned long d2 = (d >> 16) >> 16;
2992 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01002993 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
2994 }
2995
2996 t = (d >> (s - 16)) & 0xff;
2997 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
2998 t = (c >> (s - 8)) & 0xf;
2999 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
3000 t = (b >> (s - 4)) & 0x7;
3001 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
3002 t = (a >> (s - 2)) & 0x3;
3003 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
3004 t = (m >> (s - 1)) & 0x1;
3005 s -= ((t - r) & 256) >> 8;
3006
3007 return s - 1;
3008}
3009
3010/* Prepare the bitmaps used by the fast implementation of the find_rank_bit()
3011 * above.
3012 */
3013void mask_prep_rank_map(unsigned long m,
3014 unsigned long *a, unsigned long *b,
3015 unsigned long *c, unsigned long *d)
3016{
3017 *a = m - ((m >> 1) & ~0UL/3);
3018 *b = (*a & ~0UL/5) + ((*a >> 2) & ~0UL/5);
3019 *c = (*b + (*b >> 4)) & ~0UL/0x11;
3020 *d = (*c + (*c >> 8)) & ~0UL/0x101;
3021}
3022
David du Colombier4f92d322011-03-24 11:09:31 +01003023/* Return non-zero if IPv4 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003024 * otherwise zero. Note that <addr> may not necessarily be aligned
3025 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003026 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003027int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003028{
Willy Tarreaueec1d382016-07-13 11:59:39 +02003029 struct in_addr addr_copy;
3030
3031 memcpy(&addr_copy, addr, sizeof(addr_copy));
3032 return((addr_copy.s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
David du Colombier4f92d322011-03-24 11:09:31 +01003033}
3034
3035/* Return non-zero if IPv6 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003036 * otherwise zero. Note that <addr> may not necessarily be aligned
3037 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003038 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003039int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003040{
3041 int i;
Willy Tarreaueec1d382016-07-13 11:59:39 +02003042 struct in6_addr addr_copy;
David du Colombier4f92d322011-03-24 11:09:31 +01003043
Willy Tarreaueec1d382016-07-13 11:59:39 +02003044 memcpy(&addr_copy, addr, sizeof(addr_copy));
David du Colombier4f92d322011-03-24 11:09:31 +01003045 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
Willy Tarreaueec1d382016-07-13 11:59:39 +02003046 if (((((int *)&addr_copy)[i] & ((int *)mask)[i])) !=
David du Colombier4f92d322011-03-24 11:09:31 +01003047 (((int *)net)[i] & ((int *)mask)[i]))
3048 return 0;
3049 return 1;
3050}
3051
3052/* RFC 4291 prefix */
3053const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
3054 0x00, 0x00, 0x00, 0x00,
3055 0x00, 0x00, 0xFF, 0xFF };
3056
Joseph Herlant32b83272018-11-15 11:58:28 -08003057/* Map IPv4 address on IPv6 address, as specified in RFC 3513.
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003058 * Input and output may overlap.
3059 */
David du Colombier4f92d322011-03-24 11:09:31 +01003060void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
3061{
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003062 struct in_addr tmp_addr;
3063
3064 tmp_addr.s_addr = sin_addr->s_addr;
David du Colombier4f92d322011-03-24 11:09:31 +01003065 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003066 memcpy(sin6_addr->s6_addr+12, &tmp_addr.s_addr, 4);
David du Colombier4f92d322011-03-24 11:09:31 +01003067}
3068
Joseph Herlant32b83272018-11-15 11:58:28 -08003069/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01003070 * Return true if conversion is possible and false otherwise.
3071 */
3072int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
3073{
3074 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
3075 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
3076 sizeof(struct in_addr));
3077 return 1;
3078 }
3079
3080 return 0;
3081}
3082
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01003083/* compare two struct sockaddr_storage and return:
3084 * 0 (true) if the addr is the same in both
3085 * 1 (false) if the addr is not the same in both
3086 * -1 (unable) if one of the addr is not AF_INET*
3087 */
3088int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2)
3089{
3090 if ((ss1->ss_family != AF_INET) && (ss1->ss_family != AF_INET6))
3091 return -1;
3092
3093 if ((ss2->ss_family != AF_INET) && (ss2->ss_family != AF_INET6))
3094 return -1;
3095
3096 if (ss1->ss_family != ss2->ss_family)
3097 return 1;
3098
3099 switch (ss1->ss_family) {
3100 case AF_INET:
3101 return memcmp(&((struct sockaddr_in *)ss1)->sin_addr,
3102 &((struct sockaddr_in *)ss2)->sin_addr,
3103 sizeof(struct in_addr)) != 0;
3104 case AF_INET6:
3105 return memcmp(&((struct sockaddr_in6 *)ss1)->sin6_addr,
3106 &((struct sockaddr_in6 *)ss2)->sin6_addr,
3107 sizeof(struct in6_addr)) != 0;
3108 }
3109
3110 return 1;
3111}
3112
Baptiste Assmann08396c82016-01-31 00:27:17 +01003113/* copy IP address from <source> into <dest>
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003114 * The caller must allocate and clear <dest> before calling.
3115 * The source must be in either AF_INET or AF_INET6 family, or the destination
3116 * address will be undefined. If the destination address used to hold a port,
3117 * it is preserved, so that this function can be used to switch to another
3118 * address family with no risk. Returns a pointer to the destination.
Baptiste Assmann08396c82016-01-31 00:27:17 +01003119 */
3120struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest)
3121{
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003122 int prev_port;
3123
3124 prev_port = get_net_port(dest);
3125 memset(dest, 0, sizeof(*dest));
Baptiste Assmann08396c82016-01-31 00:27:17 +01003126 dest->ss_family = source->ss_family;
3127
3128 /* copy new addr and apply it */
3129 switch (source->ss_family) {
3130 case AF_INET:
3131 ((struct sockaddr_in *)dest)->sin_addr.s_addr = ((struct sockaddr_in *)source)->sin_addr.s_addr;
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003132 ((struct sockaddr_in *)dest)->sin_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003133 break;
3134 case AF_INET6:
3135 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 +01003136 ((struct sockaddr_in6 *)dest)->sin6_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003137 break;
3138 }
3139
3140 return dest;
3141}
3142
William Lallemand421f5b52012-02-06 18:15:57 +01003143char *human_time(int t, short hz_div) {
3144 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
3145 char *p = rv;
Willy Tarreau761b3d52014-04-14 14:53:06 +02003146 char *end = rv + sizeof(rv);
William Lallemand421f5b52012-02-06 18:15:57 +01003147 int cnt=2; // print two numbers
3148
3149 if (unlikely(t < 0 || hz_div <= 0)) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003150 snprintf(p, end - p, "?");
William Lallemand421f5b52012-02-06 18:15:57 +01003151 return rv;
3152 }
3153
3154 if (unlikely(hz_div > 1))
3155 t /= hz_div;
3156
3157 if (t >= DAY) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003158 p += snprintf(p, end - p, "%dd", t / DAY);
William Lallemand421f5b52012-02-06 18:15:57 +01003159 cnt--;
3160 }
3161
3162 if (cnt && t % DAY / HOUR) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003163 p += snprintf(p, end - p, "%dh", t % DAY / HOUR);
William Lallemand421f5b52012-02-06 18:15:57 +01003164 cnt--;
3165 }
3166
3167 if (cnt && t % HOUR / MINUTE) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003168 p += snprintf(p, end - p, "%dm", t % HOUR / MINUTE);
William Lallemand421f5b52012-02-06 18:15:57 +01003169 cnt--;
3170 }
3171
3172 if ((cnt && t % MINUTE) || !t) // also display '0s'
Willy Tarreau761b3d52014-04-14 14:53:06 +02003173 p += snprintf(p, end - p, "%ds", t % MINUTE / SEC);
William Lallemand421f5b52012-02-06 18:15:57 +01003174
3175 return rv;
3176}
3177
3178const char *monthname[12] = {
3179 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3180 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
3181};
3182
3183/* date2str_log: write a date in the format :
3184 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
3185 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3186 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
3187 *
3188 * without using sprintf. return a pointer to the last char written (\0) or
3189 * NULL if there isn't enough space.
3190 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02003191char *date2str_log(char *dst, const struct tm *tm, const struct timeval *date, size_t size)
William Lallemand421f5b52012-02-06 18:15:57 +01003192{
3193
3194 if (size < 25) /* the size is fixed: 24 chars + \0 */
3195 return NULL;
3196
3197 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003198 if (!dst)
3199 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003200 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003201
William Lallemand421f5b52012-02-06 18:15:57 +01003202 memcpy(dst, monthname[tm->tm_mon], 3); // month
3203 dst += 3;
3204 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003205
William Lallemand421f5b52012-02-06 18:15:57 +01003206 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003207 if (!dst)
3208 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003209 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003210
William Lallemand421f5b52012-02-06 18:15:57 +01003211 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003212 if (!dst)
3213 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003214 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003215
William Lallemand421f5b52012-02-06 18:15:57 +01003216 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003217 if (!dst)
3218 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003219 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003220
William Lallemand421f5b52012-02-06 18:15:57 +01003221 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003222 if (!dst)
3223 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003224 *dst++ = '.';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003225
Willy Tarreau7d9421d2020-02-29 09:08:02 +01003226 dst = utoa_pad((unsigned int)(date->tv_usec/1000)%1000, dst, 4); // milliseconds
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003227 if (!dst)
3228 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003229 *dst = '\0';
3230
3231 return dst;
3232}
3233
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003234/* Base year used to compute leap years */
3235#define TM_YEAR_BASE 1900
3236
3237/* Return the difference in seconds between two times (leap seconds are ignored).
3238 * Retrieved from glibc 2.18 source code.
3239 */
3240static int my_tm_diff(const struct tm *a, const struct tm *b)
3241{
3242 /* Compute intervening leap days correctly even if year is negative.
3243 * Take care to avoid int overflow in leap day calculations,
3244 * but it's OK to assume that A and B are close to each other.
3245 */
3246 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
3247 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
3248 int a100 = a4 / 25 - (a4 % 25 < 0);
3249 int b100 = b4 / 25 - (b4 % 25 < 0);
3250 int a400 = a100 >> 2;
3251 int b400 = b100 >> 2;
3252 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
3253 int years = a->tm_year - b->tm_year;
3254 int days = (365 * years + intervening_leap_days
3255 + (a->tm_yday - b->tm_yday));
3256 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
3257 + (a->tm_min - b->tm_min))
3258 + (a->tm_sec - b->tm_sec));
3259}
3260
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003261/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003262 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003263 * The string returned has the same format as returned by strftime(... "%z", tm).
3264 * Offsets are kept in an internal cache for better performances.
3265 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003266const char *get_gmt_offset(time_t t, struct tm *tm)
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003267{
3268 /* Cache offsets from GMT (depending on whether DST is active or not) */
Christopher Faulet1bc04c72017-10-29 20:14:08 +01003269 static THREAD_LOCAL char gmt_offsets[2][5+1] = { "", "" };
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003270
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003271 char *gmt_offset;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003272 struct tm tm_gmt;
3273 int diff;
3274 int isdst = tm->tm_isdst;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003275
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003276 /* Pretend DST not active if its status is unknown */
3277 if (isdst < 0)
3278 isdst = 0;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003279
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003280 /* Fetch the offset and initialize it if needed */
3281 gmt_offset = gmt_offsets[isdst & 0x01];
3282 if (unlikely(!*gmt_offset)) {
3283 get_gmtime(t, &tm_gmt);
3284 diff = my_tm_diff(tm, &tm_gmt);
3285 if (diff < 0) {
3286 diff = -diff;
3287 *gmt_offset = '-';
3288 } else {
3289 *gmt_offset = '+';
3290 }
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003291 diff %= 86400U;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003292 diff /= 60; /* Convert to minutes */
3293 snprintf(gmt_offset+1, 4+1, "%02d%02d", diff/60, diff%60);
3294 }
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003295
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003296 return gmt_offset;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003297}
3298
William Lallemand421f5b52012-02-06 18:15:57 +01003299/* gmt2str_log: write a date in the format :
3300 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
3301 * return a pointer to the last char written (\0) or
3302 * NULL if there isn't enough space.
3303 */
3304char *gmt2str_log(char *dst, struct tm *tm, size_t size)
3305{
Yuxans Yao4e25b012012-10-19 10:36:09 +08003306 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01003307 return NULL;
3308
3309 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003310 if (!dst)
3311 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003312 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003313
William Lallemand421f5b52012-02-06 18:15:57 +01003314 memcpy(dst, monthname[tm->tm_mon], 3); // month
3315 dst += 3;
3316 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003317
William Lallemand421f5b52012-02-06 18:15:57 +01003318 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003319 if (!dst)
3320 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003321 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003322
William Lallemand421f5b52012-02-06 18:15:57 +01003323 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003324 if (!dst)
3325 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003326 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003327
William Lallemand421f5b52012-02-06 18:15:57 +01003328 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003329 if (!dst)
3330 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003331 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003332
William Lallemand421f5b52012-02-06 18:15:57 +01003333 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003334 if (!dst)
3335 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003336 *dst++ = ' ';
3337 *dst++ = '+';
3338 *dst++ = '0';
3339 *dst++ = '0';
3340 *dst++ = '0';
3341 *dst++ = '0';
3342 *dst = '\0';
3343
3344 return dst;
3345}
3346
Yuxans Yao4e25b012012-10-19 10:36:09 +08003347/* localdate2str_log: write a date in the format :
3348 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003349 * Both t and tm must represent the same time.
3350 * return a pointer to the last char written (\0) or
3351 * NULL if there isn't enough space.
Yuxans Yao4e25b012012-10-19 10:36:09 +08003352 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003353char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size)
Yuxans Yao4e25b012012-10-19 10:36:09 +08003354{
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003355 const char *gmt_offset;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003356 if (size < 27) /* the size is fixed: 26 chars + \0 */
3357 return NULL;
3358
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003359 gmt_offset = get_gmt_offset(t, tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003360
Yuxans Yao4e25b012012-10-19 10:36:09 +08003361 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003362 if (!dst)
3363 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003364 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003365
Yuxans Yao4e25b012012-10-19 10:36:09 +08003366 memcpy(dst, monthname[tm->tm_mon], 3); // month
3367 dst += 3;
3368 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003369
Yuxans Yao4e25b012012-10-19 10:36:09 +08003370 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003371 if (!dst)
3372 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003373 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003374
Yuxans Yao4e25b012012-10-19 10:36:09 +08003375 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003376 if (!dst)
3377 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003378 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003379
Yuxans Yao4e25b012012-10-19 10:36:09 +08003380 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003381 if (!dst)
3382 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003383 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003384
Yuxans Yao4e25b012012-10-19 10:36:09 +08003385 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003386 if (!dst)
3387 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003388 *dst++ = ' ';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003389
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003390 memcpy(dst, gmt_offset, 5); // Offset from local time to GMT
Yuxans Yao4e25b012012-10-19 10:36:09 +08003391 dst += 5;
3392 *dst = '\0';
3393
3394 return dst;
3395}
3396
Willy Tarreaucb1949b2017-07-19 19:05:29 +02003397/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
3398 * It is meant as a portable replacement for timegm() for use with valid inputs.
3399 * Returns undefined results for invalid dates (eg: months out of range 0..11).
3400 */
3401time_t my_timegm(const struct tm *tm)
3402{
3403 /* Each month has 28, 29, 30 or 31 days, or 28+N. The date in the year
3404 * is thus (current month - 1)*28 + cumulated_N[month] to count the
3405 * sum of the extra N days for elapsed months. The sum of all these N
3406 * days doesn't exceed 30 for a complete year (366-12*28) so it fits
3407 * in a 5-bit word. This means that with 60 bits we can represent a
3408 * matrix of all these values at once, which is fast and efficient to
3409 * access. The extra February day for leap years is not counted here.
3410 *
3411 * Jan : none = 0 (0)
3412 * Feb : Jan = 3 (3)
3413 * Mar : Jan..Feb = 3 (3 + 0)
3414 * Apr : Jan..Mar = 6 (3 + 0 + 3)
3415 * May : Jan..Apr = 8 (3 + 0 + 3 + 2)
3416 * Jun : Jan..May = 11 (3 + 0 + 3 + 2 + 3)
3417 * Jul : Jan..Jun = 13 (3 + 0 + 3 + 2 + 3 + 2)
3418 * Aug : Jan..Jul = 16 (3 + 0 + 3 + 2 + 3 + 2 + 3)
3419 * Sep : Jan..Aug = 19 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3)
3420 * Oct : Jan..Sep = 21 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2)
3421 * Nov : Jan..Oct = 24 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3)
3422 * Dec : Jan..Nov = 26 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3 + 2)
3423 */
3424 uint64_t extra =
3425 ( 0ULL << 0*5) + ( 3ULL << 1*5) + ( 3ULL << 2*5) + /* Jan, Feb, Mar, */
3426 ( 6ULL << 3*5) + ( 8ULL << 4*5) + (11ULL << 5*5) + /* Apr, May, Jun, */
3427 (13ULL << 6*5) + (16ULL << 7*5) + (19ULL << 8*5) + /* Jul, Aug, Sep, */
3428 (21ULL << 9*5) + (24ULL << 10*5) + (26ULL << 11*5); /* Oct, Nov, Dec, */
3429
3430 unsigned int y = tm->tm_year + 1900;
3431 unsigned int m = tm->tm_mon;
3432 unsigned long days = 0;
3433
3434 /* days since 1/1/1970 for full years */
3435 days += days_since_zero(y) - days_since_zero(1970);
3436
3437 /* days for full months in the current year */
3438 days += 28 * m + ((extra >> (m * 5)) & 0x1f);
3439
3440 /* count + 1 after March for leap years. A leap year is a year multiple
3441 * of 4, unless it's multiple of 100 without being multiple of 400. 2000
3442 * is leap, 1900 isn't, 1904 is.
3443 */
3444 if ((m > 1) && !(y & 3) && ((y % 100) || !(y % 400)))
3445 days++;
3446
3447 days += tm->tm_mday - 1;
3448 return days * 86400ULL + tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
3449}
3450
Thierry Fournier93127942016-01-20 18:49:45 +01003451/* This function check a char. It returns true and updates
3452 * <date> and <len> pointer to the new position if the
3453 * character is found.
3454 */
3455static inline int parse_expect_char(const char **date, int *len, char c)
3456{
3457 if (*len < 1 || **date != c)
3458 return 0;
3459 (*len)--;
3460 (*date)++;
3461 return 1;
3462}
3463
3464/* This function expects a string <str> of len <l>. It return true and updates.
3465 * <date> and <len> if the string matches, otherwise, it returns false.
3466 */
3467static inline int parse_strcmp(const char **date, int *len, char *str, int l)
3468{
3469 if (*len < l || strncmp(*date, str, l) != 0)
3470 return 0;
3471 (*len) -= l;
3472 (*date) += l;
3473 return 1;
3474}
3475
3476/* This macro converts 3 chars name in integer. */
3477#define STR2I3(__a, __b, __c) ((__a) * 65536 + (__b) * 256 + (__c))
3478
3479/* day-name = %x4D.6F.6E ; "Mon", case-sensitive
3480 * / %x54.75.65 ; "Tue", case-sensitive
3481 * / %x57.65.64 ; "Wed", case-sensitive
3482 * / %x54.68.75 ; "Thu", case-sensitive
3483 * / %x46.72.69 ; "Fri", case-sensitive
3484 * / %x53.61.74 ; "Sat", case-sensitive
3485 * / %x53.75.6E ; "Sun", case-sensitive
3486 *
3487 * This array must be alphabetically sorted
3488 */
3489static inline int parse_http_dayname(const char **date, int *len, struct tm *tm)
3490{
3491 if (*len < 3)
3492 return 0;
3493 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3494 case STR2I3('M','o','n'): tm->tm_wday = 1; break;
3495 case STR2I3('T','u','e'): tm->tm_wday = 2; break;
3496 case STR2I3('W','e','d'): tm->tm_wday = 3; break;
3497 case STR2I3('T','h','u'): tm->tm_wday = 4; break;
3498 case STR2I3('F','r','i'): tm->tm_wday = 5; break;
3499 case STR2I3('S','a','t'): tm->tm_wday = 6; break;
3500 case STR2I3('S','u','n'): tm->tm_wday = 7; break;
3501 default: return 0;
3502 }
3503 *len -= 3;
3504 *date += 3;
3505 return 1;
3506}
3507
3508/* month = %x4A.61.6E ; "Jan", case-sensitive
3509 * / %x46.65.62 ; "Feb", case-sensitive
3510 * / %x4D.61.72 ; "Mar", case-sensitive
3511 * / %x41.70.72 ; "Apr", case-sensitive
3512 * / %x4D.61.79 ; "May", case-sensitive
3513 * / %x4A.75.6E ; "Jun", case-sensitive
3514 * / %x4A.75.6C ; "Jul", case-sensitive
3515 * / %x41.75.67 ; "Aug", case-sensitive
3516 * / %x53.65.70 ; "Sep", case-sensitive
3517 * / %x4F.63.74 ; "Oct", case-sensitive
3518 * / %x4E.6F.76 ; "Nov", case-sensitive
3519 * / %x44.65.63 ; "Dec", case-sensitive
3520 *
3521 * This array must be alphabetically sorted
3522 */
3523static inline int parse_http_monthname(const char **date, int *len, struct tm *tm)
3524{
3525 if (*len < 3)
3526 return 0;
3527 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3528 case STR2I3('J','a','n'): tm->tm_mon = 0; break;
3529 case STR2I3('F','e','b'): tm->tm_mon = 1; break;
3530 case STR2I3('M','a','r'): tm->tm_mon = 2; break;
3531 case STR2I3('A','p','r'): tm->tm_mon = 3; break;
3532 case STR2I3('M','a','y'): tm->tm_mon = 4; break;
3533 case STR2I3('J','u','n'): tm->tm_mon = 5; break;
3534 case STR2I3('J','u','l'): tm->tm_mon = 6; break;
3535 case STR2I3('A','u','g'): tm->tm_mon = 7; break;
3536 case STR2I3('S','e','p'): tm->tm_mon = 8; break;
3537 case STR2I3('O','c','t'): tm->tm_mon = 9; break;
3538 case STR2I3('N','o','v'): tm->tm_mon = 10; break;
3539 case STR2I3('D','e','c'): tm->tm_mon = 11; break;
3540 default: return 0;
3541 }
3542 *len -= 3;
3543 *date += 3;
3544 return 1;
3545}
3546
3547/* day-name-l = %x4D.6F.6E.64.61.79 ; "Monday", case-sensitive
3548 * / %x54.75.65.73.64.61.79 ; "Tuesday", case-sensitive
3549 * / %x57.65.64.6E.65.73.64.61.79 ; "Wednesday", case-sensitive
3550 * / %x54.68.75.72.73.64.61.79 ; "Thursday", case-sensitive
3551 * / %x46.72.69.64.61.79 ; "Friday", case-sensitive
3552 * / %x53.61.74.75.72.64.61.79 ; "Saturday", case-sensitive
3553 * / %x53.75.6E.64.61.79 ; "Sunday", case-sensitive
3554 *
3555 * This array must be alphabetically sorted
3556 */
3557static inline int parse_http_ldayname(const char **date, int *len, struct tm *tm)
3558{
3559 if (*len < 6) /* Minimum length. */
3560 return 0;
3561 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3562 case STR2I3('M','o','n'):
3563 RET0_UNLESS(parse_strcmp(date, len, "Monday", 6));
3564 tm->tm_wday = 1;
3565 return 1;
3566 case STR2I3('T','u','e'):
3567 RET0_UNLESS(parse_strcmp(date, len, "Tuesday", 7));
3568 tm->tm_wday = 2;
3569 return 1;
3570 case STR2I3('W','e','d'):
3571 RET0_UNLESS(parse_strcmp(date, len, "Wednesday", 9));
3572 tm->tm_wday = 3;
3573 return 1;
3574 case STR2I3('T','h','u'):
3575 RET0_UNLESS(parse_strcmp(date, len, "Thursday", 8));
3576 tm->tm_wday = 4;
3577 return 1;
3578 case STR2I3('F','r','i'):
3579 RET0_UNLESS(parse_strcmp(date, len, "Friday", 6));
3580 tm->tm_wday = 5;
3581 return 1;
3582 case STR2I3('S','a','t'):
3583 RET0_UNLESS(parse_strcmp(date, len, "Saturday", 8));
3584 tm->tm_wday = 6;
3585 return 1;
3586 case STR2I3('S','u','n'):
3587 RET0_UNLESS(parse_strcmp(date, len, "Sunday", 6));
3588 tm->tm_wday = 7;
3589 return 1;
3590 }
3591 return 0;
3592}
3593
3594/* This function parses exactly 1 digit and returns the numeric value in "digit". */
3595static inline int parse_digit(const char **date, int *len, int *digit)
3596{
3597 if (*len < 1 || **date < '0' || **date > '9')
3598 return 0;
3599 *digit = (**date - '0');
3600 (*date)++;
3601 (*len)--;
3602 return 1;
3603}
3604
3605/* This function parses exactly 2 digits and returns the numeric value in "digit". */
3606static inline int parse_2digit(const char **date, int *len, int *digit)
3607{
3608 int value;
3609
3610 RET0_UNLESS(parse_digit(date, len, &value));
3611 (*digit) = value * 10;
3612 RET0_UNLESS(parse_digit(date, len, &value));
3613 (*digit) += value;
3614
3615 return 1;
3616}
3617
3618/* This function parses exactly 4 digits and returns the numeric value in "digit". */
3619static inline int parse_4digit(const char **date, int *len, int *digit)
3620{
3621 int value;
3622
3623 RET0_UNLESS(parse_digit(date, len, &value));
3624 (*digit) = value * 1000;
3625
3626 RET0_UNLESS(parse_digit(date, len, &value));
3627 (*digit) += value * 100;
3628
3629 RET0_UNLESS(parse_digit(date, len, &value));
3630 (*digit) += value * 10;
3631
3632 RET0_UNLESS(parse_digit(date, len, &value));
3633 (*digit) += value;
3634
3635 return 1;
3636}
3637
3638/* time-of-day = hour ":" minute ":" second
3639 * ; 00:00:00 - 23:59:60 (leap second)
3640 *
3641 * hour = 2DIGIT
3642 * minute = 2DIGIT
3643 * second = 2DIGIT
3644 */
3645static inline int parse_http_time(const char **date, int *len, struct tm *tm)
3646{
3647 RET0_UNLESS(parse_2digit(date, len, &tm->tm_hour)); /* hour 2DIGIT */
3648 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3649 RET0_UNLESS(parse_2digit(date, len, &tm->tm_min)); /* min 2DIGIT */
3650 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3651 RET0_UNLESS(parse_2digit(date, len, &tm->tm_sec)); /* sec 2DIGIT */
3652 return 1;
3653}
3654
3655/* From RFC7231
3656 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3657 *
3658 * IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
3659 * ; fixed length/zone/capitalization subset of the format
3660 * ; see Section 3.3 of [RFC5322]
3661 *
3662 *
3663 * date1 = day SP month SP year
3664 * ; e.g., 02 Jun 1982
3665 *
3666 * day = 2DIGIT
3667 * year = 4DIGIT
3668 *
3669 * GMT = %x47.4D.54 ; "GMT", case-sensitive
3670 *
3671 * time-of-day = hour ":" minute ":" second
3672 * ; 00:00:00 - 23:59:60 (leap second)
3673 *
3674 * hour = 2DIGIT
3675 * minute = 2DIGIT
3676 * second = 2DIGIT
3677 *
3678 * DIGIT = decimal 0-9
3679 */
3680int parse_imf_date(const char *date, int len, struct tm *tm)
3681{
David Carlier327298c2016-11-20 10:42:38 +00003682 /* tm_gmtoff, if present, ought to be zero'ed */
3683 memset(tm, 0, sizeof(*tm));
3684
Thierry Fournier93127942016-01-20 18:49:45 +01003685 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3686 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3687 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3688 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3689 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3690 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3691 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3692 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3693 tm->tm_year -= 1900;
3694 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3695 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3696 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3697 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3698 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003699 return 1;
3700}
3701
3702/* From RFC7231
3703 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3704 *
3705 * rfc850-date = day-name-l "," SP date2 SP time-of-day SP GMT
3706 * date2 = day "-" month "-" 2DIGIT
3707 * ; e.g., 02-Jun-82
3708 *
3709 * day = 2DIGIT
3710 */
3711int parse_rfc850_date(const char *date, int len, struct tm *tm)
3712{
3713 int year;
3714
David Carlier327298c2016-11-20 10:42:38 +00003715 /* tm_gmtoff, if present, ought to be zero'ed */
3716 memset(tm, 0, sizeof(*tm));
3717
Thierry Fournier93127942016-01-20 18:49:45 +01003718 RET0_UNLESS(parse_http_ldayname(&date, &len, tm)); /* Read the day name */
3719 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3720 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3721 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3722 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3723 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3724 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3725
3726 /* year = 2DIGIT
3727 *
3728 * Recipients of a timestamp value in rfc850-(*date) format, which uses a
3729 * two-digit year, MUST interpret a timestamp that appears to be more
3730 * than 50 years in the future as representing the most recent year in
3731 * the past that had the same last two digits.
3732 */
3733 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_year));
3734
3735 /* expect SP */
3736 if (!parse_expect_char(&date, &len, ' ')) {
3737 /* Maybe we have the date with 4 digits. */
3738 RET0_UNLESS(parse_2digit(&date, &len, &year));
3739 tm->tm_year = (tm->tm_year * 100 + year) - 1900;
3740 /* expect SP */
3741 RET0_UNLESS(parse_expect_char(&date, &len, ' '));
3742 } else {
3743 /* I fix 60 as pivot: >60: +1900, <60: +2000. Note that the
3744 * tm_year is the number of year since 1900, so for +1900, we
3745 * do nothing, and for +2000, we add 100.
3746 */
3747 if (tm->tm_year <= 60)
3748 tm->tm_year += 100;
3749 }
3750
3751 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3752 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3753 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3754 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003755
3756 return 1;
3757}
3758
3759/* From RFC7231
3760 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3761 *
3762 * asctime-date = day-name SP date3 SP time-of-day SP year
3763 * date3 = month SP ( 2DIGIT / ( SP 1DIGIT ))
3764 * ; e.g., Jun 2
3765 *
3766 * HTTP-date is case sensitive. A sender MUST NOT generate additional
3767 * whitespace in an HTTP-date beyond that specifically included as SP in
3768 * the grammar.
3769 */
3770int parse_asctime_date(const char *date, int len, struct tm *tm)
3771{
David Carlier327298c2016-11-20 10:42:38 +00003772 /* tm_gmtoff, if present, ought to be zero'ed */
3773 memset(tm, 0, sizeof(*tm));
3774
Thierry Fournier93127942016-01-20 18:49:45 +01003775 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3776 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3777 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* expect month */
3778 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3779
3780 /* expect SP and 1DIGIT or 2DIGIT */
3781 if (parse_expect_char(&date, &len, ' '))
3782 RET0_UNLESS(parse_digit(&date, &len, &tm->tm_mday));
3783 else
3784 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday));
3785
3786 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3787 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3788 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3789 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3790 tm->tm_year -= 1900;
3791 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003792 return 1;
3793}
3794
3795/* From RFC7231
3796 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3797 *
3798 * HTTP-date = IMF-fixdate / obs-date
3799 * obs-date = rfc850-date / asctime-date
3800 *
3801 * parses an HTTP date in the RFC format and is accepted
3802 * alternatives. <date> is the strinf containing the date,
3803 * len is the len of the string. <tm> is filled with the
3804 * parsed time. We must considers this time as GMT.
3805 */
3806int parse_http_date(const char *date, int len, struct tm *tm)
3807{
3808 if (parse_imf_date(date, len, tm))
3809 return 1;
3810
3811 if (parse_rfc850_date(date, len, tm))
3812 return 1;
3813
3814 if (parse_asctime_date(date, len, tm))
3815 return 1;
3816
3817 return 0;
3818}
3819
Willy Tarreau4deeb102021-01-29 10:47:52 +01003820/* print the time <ns> in a short form (exactly 7 chars) at the end of buffer
3821 * <out>. "-" is printed if the value is zero, "inf" if larger than 1000 years.
3822 * It returns the new buffer length, or 0 if it doesn't fit. The value will be
3823 * surrounded by <pfx> and <sfx> respectively if not NULL.
3824 */
3825int print_time_short(struct buffer *out, const char *pfx, uint64_t ns, const char *sfx)
3826{
3827 double val = ns; // 52 bits of mantissa keep ns accuracy over 52 days
3828 const char *unit;
3829
3830 if (!pfx)
3831 pfx = "";
3832 if (!sfx)
3833 sfx = "";
3834
3835 do {
3836 unit = " - "; if (val <= 0.0) break;
3837 unit = "ns"; if (val < 1000.0) break;
3838 unit = "us"; val /= 1000.0; if (val < 1000.0) break;
3839 unit = "ms"; val /= 1000.0; if (val < 1000.0) break;
3840 unit = "s "; val /= 1000.0; if (val < 60.0) break;
3841 unit = "m "; val /= 60.0; if (val < 60.0) break;
3842 unit = "h "; val /= 60.0; if (val < 24.0) break;
3843 unit = "d "; val /= 24.0; if (val < 365.0) break;
3844 unit = "yr"; val /= 365.0; if (val < 1000.0) break;
3845 unit = " inf "; val = 0.0; break;
3846 } while (0);
3847
3848 if (val <= 0.0)
3849 return chunk_appendf(out, "%s%7s%s", pfx, unit, sfx);
3850 else if (val < 10.0)
3851 return chunk_appendf(out, "%s%1.3f%s%s", pfx, val, unit, sfx);
3852 else if (val < 100.0)
3853 return chunk_appendf(out, "%s%2.2f%s%s", pfx, val, unit, sfx);
3854 else
3855 return chunk_appendf(out, "%s%3.1f%s%s", pfx, val, unit, sfx);
3856}
3857
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003858/* Dynamically allocates a string of the proper length to hold the formatted
3859 * output. NULL is returned on error. The caller is responsible for freeing the
3860 * memory area using free(). The resulting string is returned in <out> if the
3861 * pointer is not NULL. A previous version of <out> might be used to build the
3862 * new string, and it will be freed before returning if it is not NULL, which
3863 * makes it possible to build complex strings from iterative calls without
3864 * having to care about freeing intermediate values, as in the example below :
3865 *
3866 * memprintf(&err, "invalid argument: '%s'", arg);
3867 * ...
3868 * memprintf(&err, "parser said : <%s>\n", *err);
3869 * ...
3870 * free(*err);
3871 *
3872 * This means that <err> must be initialized to NULL before first invocation.
3873 * The return value also holds the allocated string, which eases error checking
3874 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003875 * passed instead and it will be ignored. The returned message will then also
3876 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003877 *
3878 * It is also convenient to use it without any free except the last one :
3879 * err = NULL;
3880 * if (!fct1(err)) report(*err);
3881 * if (!fct2(err)) report(*err);
3882 * if (!fct3(err)) report(*err);
3883 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02003884 *
3885 * memprintf relies on memvprintf. This last version can be called from any
3886 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003887 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003888char *memvprintf(char **out, const char *format, va_list orig_args)
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003889{
3890 va_list args;
3891 char *ret = NULL;
3892 int allocated = 0;
3893 int needed = 0;
3894
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003895 if (!out)
3896 return NULL;
3897
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003898 do {
Willy Tarreaue0609f52019-03-29 19:13:23 +01003899 char buf1;
3900
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003901 /* vsnprintf() will return the required length even when the
3902 * target buffer is NULL. We do this in a loop just in case
3903 * intermediate evaluations get wrong.
3904 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02003905 va_copy(args, orig_args);
Willy Tarreaue0609f52019-03-29 19:13:23 +01003906 needed = vsnprintf(ret ? ret : &buf1, allocated, format, args);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003907 va_end(args);
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003908 if (needed < allocated) {
3909 /* Note: on Solaris 8, the first iteration always
3910 * returns -1 if allocated is zero, so we force a
3911 * retry.
3912 */
3913 if (!allocated)
3914 needed = 0;
3915 else
3916 break;
3917 }
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003918
Willy Tarreau1b2fed62013-04-01 22:48:54 +02003919 allocated = needed + 1;
Hubert Verstraete831962e2016-06-28 22:44:26 +02003920 ret = my_realloc2(ret, allocated);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003921 } while (ret);
3922
3923 if (needed < 0) {
3924 /* an error was encountered */
3925 free(ret);
3926 ret = NULL;
3927 }
3928
3929 if (out) {
3930 free(*out);
3931 *out = ret;
3932 }
3933
3934 return ret;
3935}
William Lallemand421f5b52012-02-06 18:15:57 +01003936
Christopher Faulet93a518f2017-10-24 11:25:33 +02003937char *memprintf(char **out, const char *format, ...)
3938{
3939 va_list args;
3940 char *ret = NULL;
3941
3942 va_start(args, format);
3943 ret = memvprintf(out, format, args);
3944 va_end(args);
3945
3946 return ret;
3947}
3948
Willy Tarreau21c705b2012-09-14 11:40:36 +02003949/* Used to add <level> spaces before each line of <out>, unless there is only one line.
3950 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02003951 * freed by the caller. It also supports being passed a NULL which results in the same
3952 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02003953 * Example of use :
3954 * parse(cmd, &err); (callee: memprintf(&err, ...))
3955 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
3956 * free(err);
3957 */
3958char *indent_msg(char **out, int level)
3959{
3960 char *ret, *in, *p;
3961 int needed = 0;
3962 int lf = 0;
3963 int lastlf = 0;
3964 int len;
3965
Willy Tarreau70eec382012-10-10 08:56:47 +02003966 if (!out || !*out)
3967 return NULL;
3968
Willy Tarreau21c705b2012-09-14 11:40:36 +02003969 in = *out - 1;
3970 while ((in = strchr(in + 1, '\n')) != NULL) {
3971 lastlf = in - *out;
3972 lf++;
3973 }
3974
3975 if (!lf) /* single line, no LF, return it as-is */
3976 return *out;
3977
3978 len = strlen(*out);
3979
3980 if (lf == 1 && lastlf == len - 1) {
3981 /* single line, LF at end, strip it and return as-is */
3982 (*out)[lastlf] = 0;
3983 return *out;
3984 }
3985
3986 /* OK now we have at least one LF, we need to process the whole string
3987 * as a multi-line string. What we'll do :
3988 * - prefix with an LF if there is none
3989 * - add <level> spaces before each line
3990 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
3991 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
3992 */
3993
3994 needed = 1 + level * (lf + 1) + len + 1;
3995 p = ret = malloc(needed);
3996 in = *out;
3997
3998 /* skip initial LFs */
3999 while (*in == '\n')
4000 in++;
4001
4002 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
4003 while (*in) {
4004 *p++ = '\n';
4005 memset(p, ' ', level);
4006 p += level;
4007 do {
4008 *p++ = *in++;
4009 } while (*in && *in != '\n');
4010 if (*in)
4011 in++;
4012 }
4013 *p = 0;
4014
4015 free(*out);
4016 *out = ret;
4017
4018 return ret;
4019}
4020
Willy Tarreaua2c99112019-08-21 13:17:37 +02004021/* makes a copy of message <in> into <out>, with each line prefixed with <pfx>
4022 * and end of lines replaced with <eol> if not 0. The first line to indent has
4023 * to be indicated in <first> (starts at zero), so that it is possible to skip
4024 * indenting the first line if it has to be appended after an existing message.
4025 * Empty strings are never indented, and NULL strings are considered empty both
4026 * for <in> and <pfx>. It returns non-zero if an EOL was appended as the last
4027 * character, non-zero otherwise.
4028 */
4029int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first)
4030{
4031 int bol, lf;
4032 int pfxlen = pfx ? strlen(pfx) : 0;
4033
4034 if (!in)
4035 return 0;
4036
4037 bol = 1;
4038 lf = 0;
4039 while (*in) {
4040 if (bol && pfxlen) {
4041 if (first > 0)
4042 first--;
4043 else
4044 b_putblk(out, pfx, pfxlen);
4045 bol = 0;
4046 }
4047
4048 lf = (*in == '\n');
4049 bol |= lf;
4050 b_putchr(out, (lf && eol) ? eol : *in);
4051 in++;
4052 }
4053 return lf;
4054}
4055
Willy Tarreau9d22e562019-03-29 18:49:09 +01004056/* removes environment variable <name> from the environment as found in
4057 * environ. This is only provided as an alternative for systems without
4058 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004059 * The principle is to scan environ for each occurrence of variable name
Willy Tarreau9d22e562019-03-29 18:49:09 +01004060 * <name> and to replace the matching pointers with the last pointer of
4061 * the array (since variables are not ordered).
4062 * It always returns 0 (success).
4063 */
4064int my_unsetenv(const char *name)
4065{
4066 extern char **environ;
4067 char **p = environ;
4068 int vars;
4069 int next;
4070 int len;
4071
4072 len = strlen(name);
4073 for (vars = 0; p[vars]; vars++)
4074 ;
4075 next = 0;
4076 while (next < vars) {
4077 if (strncmp(p[next], name, len) != 0 || p[next][len] != '=') {
4078 next++;
4079 continue;
4080 }
4081 if (next < vars - 1)
4082 p[next] = p[vars - 1];
4083 p[--vars] = NULL;
4084 }
4085 return 0;
4086}
4087
Willy Tarreaudad36a32013-03-11 01:20:04 +01004088/* Convert occurrences of environment variables in the input string to their
4089 * corresponding value. A variable is identified as a series of alphanumeric
4090 * characters or underscores following a '$' sign. The <in> string must be
4091 * free()able. NULL returns NULL. The resulting string might be reallocated if
4092 * some expansion is made. Variable names may also be enclosed into braces if
4093 * needed (eg: to concatenate alphanum characters).
4094 */
4095char *env_expand(char *in)
4096{
4097 char *txt_beg;
4098 char *out;
4099 char *txt_end;
4100 char *var_beg;
4101 char *var_end;
4102 char *value;
4103 char *next;
4104 int out_len;
4105 int val_len;
4106
4107 if (!in)
4108 return in;
4109
4110 value = out = NULL;
4111 out_len = 0;
4112
4113 txt_beg = in;
4114 do {
4115 /* look for next '$' sign in <in> */
4116 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
4117
4118 if (!*txt_end && !out) /* end and no expansion performed */
4119 return in;
4120
4121 val_len = 0;
4122 next = txt_end;
4123 if (*txt_end == '$') {
4124 char save;
4125
4126 var_beg = txt_end + 1;
4127 if (*var_beg == '{')
4128 var_beg++;
4129
4130 var_end = var_beg;
Willy Tarreau90807112020-02-25 08:16:33 +01004131 while (isalnum((unsigned char)*var_end) || *var_end == '_') {
Willy Tarreaudad36a32013-03-11 01:20:04 +01004132 var_end++;
4133 }
4134
4135 next = var_end;
4136 if (*var_end == '}' && (var_beg > txt_end + 1))
4137 next++;
4138
4139 /* get value of the variable name at this location */
4140 save = *var_end;
4141 *var_end = '\0';
4142 value = getenv(var_beg);
4143 *var_end = save;
4144 val_len = value ? strlen(value) : 0;
4145 }
4146
Hubert Verstraete831962e2016-06-28 22:44:26 +02004147 out = my_realloc2(out, out_len + (txt_end - txt_beg) + val_len + 1);
Willy Tarreaudad36a32013-03-11 01:20:04 +01004148 if (txt_end > txt_beg) {
4149 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
4150 out_len += txt_end - txt_beg;
4151 }
4152 if (val_len) {
4153 memcpy(out + out_len, value, val_len);
4154 out_len += val_len;
4155 }
4156 out[out_len] = 0;
4157 txt_beg = next;
4158 } while (*txt_beg);
4159
4160 /* here we know that <out> was allocated and that we don't need <in> anymore */
4161 free(in);
4162 return out;
4163}
4164
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004165
4166/* same as strstr() but case-insensitive and with limit length */
4167const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2)
4168{
4169 char *pptr, *sptr, *start;
Willy Tarreauc8746532014-05-28 23:05:07 +02004170 unsigned int slen, plen;
4171 unsigned int tmp1, tmp2;
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004172
4173 if (str1 == NULL || len_str1 == 0) // search pattern into an empty string => search is not found
4174 return NULL;
4175
4176 if (str2 == NULL || len_str2 == 0) // pattern is empty => every str1 match
4177 return str1;
4178
4179 if (len_str1 < len_str2) // pattern is longer than string => search is not found
4180 return NULL;
4181
4182 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 +02004183 while (toupper((unsigned char)*start) != toupper((unsigned char)*str2)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004184 start++;
4185 slen--;
4186 tmp1++;
4187
4188 if (tmp1 >= len_str1)
4189 return NULL;
4190
4191 /* if pattern longer than string */
4192 if (slen < plen)
4193 return NULL;
4194 }
4195
4196 sptr = start;
4197 pptr = (char *)str2;
4198
4199 tmp2 = 0;
Willy Tarreauf278eec2020-07-05 21:46:32 +02004200 while (toupper((unsigned char)*sptr) == toupper((unsigned char)*pptr)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004201 sptr++;
4202 pptr++;
4203 tmp2++;
4204
4205 if (*pptr == '\0' || tmp2 == len_str2) /* end of pattern found */
4206 return start;
4207 if (*sptr == '\0' || tmp2 == len_str1) /* end of string found and the pattern is not fully found */
4208 return NULL;
4209 }
4210 }
4211 return NULL;
4212}
4213
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004214/* This function read the next valid utf8 char.
4215 * <s> is the byte srray to be decode, <len> is its length.
4216 * The function returns decoded char encoded like this:
4217 * The 4 msb are the return code (UTF8_CODE_*), the 4 lsb
4218 * are the length read. The decoded character is stored in <c>.
4219 */
4220unsigned char utf8_next(const char *s, int len, unsigned int *c)
4221{
4222 const unsigned char *p = (unsigned char *)s;
4223 int dec;
4224 unsigned char code = UTF8_CODE_OK;
4225
4226 if (len < 1)
4227 return UTF8_CODE_OK;
4228
4229 /* Check the type of UTF8 sequence
4230 *
4231 * 0... .... 0x00 <= x <= 0x7f : 1 byte: ascii char
4232 * 10.. .... 0x80 <= x <= 0xbf : invalid sequence
4233 * 110. .... 0xc0 <= x <= 0xdf : 2 bytes
4234 * 1110 .... 0xe0 <= x <= 0xef : 3 bytes
4235 * 1111 0... 0xf0 <= x <= 0xf7 : 4 bytes
4236 * 1111 10.. 0xf8 <= x <= 0xfb : 5 bytes
4237 * 1111 110. 0xfc <= x <= 0xfd : 6 bytes
4238 * 1111 111. 0xfe <= x <= 0xff : invalid sequence
4239 */
4240 switch (*p) {
4241 case 0x00 ... 0x7f:
4242 *c = *p;
4243 return UTF8_CODE_OK | 1;
4244
4245 case 0x80 ... 0xbf:
4246 *c = *p;
4247 return UTF8_CODE_BADSEQ | 1;
4248
4249 case 0xc0 ... 0xdf:
4250 if (len < 2) {
4251 *c = *p;
4252 return UTF8_CODE_BADSEQ | 1;
4253 }
4254 *c = *p & 0x1f;
4255 dec = 1;
4256 break;
4257
4258 case 0xe0 ... 0xef:
4259 if (len < 3) {
4260 *c = *p;
4261 return UTF8_CODE_BADSEQ | 1;
4262 }
4263 *c = *p & 0x0f;
4264 dec = 2;
4265 break;
4266
4267 case 0xf0 ... 0xf7:
4268 if (len < 4) {
4269 *c = *p;
4270 return UTF8_CODE_BADSEQ | 1;
4271 }
4272 *c = *p & 0x07;
4273 dec = 3;
4274 break;
4275
4276 case 0xf8 ... 0xfb:
4277 if (len < 5) {
4278 *c = *p;
4279 return UTF8_CODE_BADSEQ | 1;
4280 }
4281 *c = *p & 0x03;
4282 dec = 4;
4283 break;
4284
4285 case 0xfc ... 0xfd:
4286 if (len < 6) {
4287 *c = *p;
4288 return UTF8_CODE_BADSEQ | 1;
4289 }
4290 *c = *p & 0x01;
4291 dec = 5;
4292 break;
4293
4294 case 0xfe ... 0xff:
4295 default:
4296 *c = *p;
4297 return UTF8_CODE_BADSEQ | 1;
4298 }
4299
4300 p++;
4301
4302 while (dec > 0) {
4303
4304 /* need 0x10 for the 2 first bits */
4305 if ( ( *p & 0xc0 ) != 0x80 )
4306 return UTF8_CODE_BADSEQ | ((p-(unsigned char *)s)&0xffff);
4307
4308 /* add data at char */
4309 *c = ( *c << 6 ) | ( *p & 0x3f );
4310
4311 dec--;
4312 p++;
4313 }
4314
4315 /* Check ovelong encoding.
4316 * 1 byte : 5 + 6 : 11 : 0x80 ... 0x7ff
4317 * 2 bytes : 4 + 6 + 6 : 16 : 0x800 ... 0xffff
4318 * 3 bytes : 3 + 6 + 6 + 6 : 21 : 0x10000 ... 0x1fffff
4319 */
Thierry FOURNIER9e7ec082015-03-12 19:32:38 +01004320 if (( *c <= 0x7f && (p-(unsigned char *)s) > 1) ||
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004321 (*c >= 0x80 && *c <= 0x7ff && (p-(unsigned char *)s) > 2) ||
4322 (*c >= 0x800 && *c <= 0xffff && (p-(unsigned char *)s) > 3) ||
4323 (*c >= 0x10000 && *c <= 0x1fffff && (p-(unsigned char *)s) > 4))
4324 code |= UTF8_CODE_OVERLONG;
4325
4326 /* Check invalid UTF8 range. */
4327 if ((*c >= 0xd800 && *c <= 0xdfff) ||
4328 (*c >= 0xfffe && *c <= 0xffff))
4329 code |= UTF8_CODE_INVRANGE;
4330
4331 return code | ((p-(unsigned char *)s)&0x0f);
4332}
4333
Maxime de Roucydc887852016-05-13 23:52:54 +02004334/* append a copy of string <str> (in a wordlist) at the end of the list <li>
4335 * On failure : return 0 and <err> filled with an error message.
4336 * The caller is responsible for freeing the <err> and <str> copy
4337 * memory area using free()
4338 */
4339int list_append_word(struct list *li, const char *str, char **err)
4340{
4341 struct wordlist *wl;
4342
4343 wl = calloc(1, sizeof(*wl));
4344 if (!wl) {
4345 memprintf(err, "out of memory");
4346 goto fail_wl;
4347 }
4348
4349 wl->s = strdup(str);
4350 if (!wl->s) {
4351 memprintf(err, "out of memory");
4352 goto fail_wl_s;
4353 }
4354
4355 LIST_ADDQ(li, &wl->list);
4356
4357 return 1;
4358
4359fail_wl_s:
4360 free(wl->s);
4361fail_wl:
4362 free(wl);
4363 return 0;
4364}
4365
Willy Tarreau37101052019-05-20 16:48:20 +02004366/* indicates if a memory location may safely be read or not. The trick consists
4367 * in performing a harmless syscall using this location as an input and letting
4368 * the operating system report whether it's OK or not. For this we have the
4369 * stat() syscall, which will return EFAULT when the memory location supposed
4370 * to contain the file name is not readable. If it is readable it will then
4371 * either return 0 if the area contains an existing file name, or -1 with
4372 * another code. This must not be abused, and some audit systems might detect
4373 * this as abnormal activity. It's used only for unsafe dumps.
4374 */
4375int may_access(const void *ptr)
4376{
4377 struct stat buf;
4378
4379 if (stat(ptr, &buf) == 0)
4380 return 1;
4381 if (errno == EFAULT)
4382 return 0;
4383 return 1;
4384}
4385
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004386/* print a string of text buffer to <out>. The format is :
4387 * Non-printable chars \t, \n, \r and \e are * encoded in C format.
4388 * Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
4389 * Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
4390 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004391int dump_text(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004392{
4393 unsigned char c;
4394 int ptr = 0;
4395
4396 while (buf[ptr] && ptr < bsize) {
4397 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004398 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\' && c != ' ' && c != '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004399 if (out->data > out->size - 1)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004400 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004401 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004402 }
4403 else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\' || c == ' ' || c == '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004404 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004405 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004406 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004407 switch (c) {
4408 case ' ': c = ' '; break;
4409 case '\t': c = 't'; break;
4410 case '\n': c = 'n'; break;
4411 case '\r': c = 'r'; break;
4412 case '\e': c = 'e'; break;
4413 case '\\': c = '\\'; break;
4414 case '=': c = '='; break;
4415 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004416 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004417 }
4418 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004419 if (out->data > out->size - 4)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004420 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004421 out->area[out->data++] = '\\';
4422 out->area[out->data++] = 'x';
4423 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4424 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004425 }
4426 ptr++;
4427 }
4428
4429 return ptr;
4430}
4431
4432/* print a buffer in hexa.
4433 * Print stopped if <bsize> is reached, or if no more place in the chunk.
4434 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004435int dump_binary(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004436{
4437 unsigned char c;
4438 int ptr = 0;
4439
4440 while (ptr < bsize) {
4441 c = buf[ptr];
4442
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004443 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004444 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004445 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4446 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004447
4448 ptr++;
4449 }
4450 return ptr;
4451}
4452
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004453/* Appends into buffer <out> a hex dump of memory area <buf> for <len> bytes,
4454 * prepending each line with prefix <pfx>. The output is *not* initialized.
4455 * The output will not wrap pas the buffer's end so it is more optimal if the
4456 * caller makes sure the buffer is aligned first. A trailing zero will always
4457 * be appended (and not counted) if there is room for it. The caller must make
Willy Tarreau37101052019-05-20 16:48:20 +02004458 * sure that the area is dumpable first. If <unsafe> is non-null, the memory
4459 * locations are checked first for being readable.
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004460 */
Willy Tarreau37101052019-05-20 16:48:20 +02004461void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe)
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004462{
4463 const unsigned char *d = buf;
4464 int i, j, start;
4465
4466 d = (const unsigned char *)(((unsigned long)buf) & -16);
4467 start = ((unsigned long)buf) & 15;
4468
4469 for (i = 0; i < start + len; i += 16) {
4470 chunk_appendf(out, (sizeof(void *) == 4) ? "%s%8p: " : "%s%16p: ", pfx, d + i);
4471
Willy Tarreau37101052019-05-20 16:48:20 +02004472 // 0: unchecked, 1: checked safe, 2: danger
4473 unsafe = !!unsafe;
4474 if (unsafe && !may_access(d + i))
4475 unsafe = 2;
4476
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004477 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004478 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004479 chunk_strcat(out, "'' ");
Willy Tarreau37101052019-05-20 16:48:20 +02004480 else if (unsafe > 1)
4481 chunk_strcat(out, "** ");
4482 else
4483 chunk_appendf(out, "%02x ", d[i + j]);
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004484
4485 if (j == 7)
4486 chunk_strcat(out, "- ");
4487 }
4488 chunk_strcat(out, " ");
4489 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004490 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004491 chunk_strcat(out, "'");
Willy Tarreau37101052019-05-20 16:48:20 +02004492 else if (unsafe > 1)
4493 chunk_strcat(out, "*");
Willy Tarreau90807112020-02-25 08:16:33 +01004494 else if (isprint((unsigned char)d[i + j]))
Willy Tarreau37101052019-05-20 16:48:20 +02004495 chunk_appendf(out, "%c", d[i + j]);
4496 else
4497 chunk_strcat(out, ".");
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004498 }
4499 chunk_strcat(out, "\n");
4500 }
4501}
4502
Willy Tarreau762fb3e2020-03-03 15:57:10 +01004503/* dumps <pfx> followed by <n> bytes from <addr> in hex form into buffer <buf>
4504 * enclosed in brackets after the address itself, formatted on 14 chars
4505 * including the "0x" prefix. This is meant to be used as a prefix for code
4506 * areas. For example:
4507 * "0x7f10b6557690 [48 c7 c0 0f 00 00 00 0f]"
4508 * It relies on may_access() to know if the bytes are dumpable, otherwise "--"
4509 * is emitted. A NULL <pfx> will be considered empty.
4510 */
4511void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n)
4512{
4513 int ok = 0;
4514 int i;
4515
4516 chunk_appendf(buf, "%s%#14lx [", pfx ? pfx : "", (long)addr);
4517
4518 for (i = 0; i < n; i++) {
4519 if (i == 0 || (((long)(addr + i) ^ (long)(addr)) & 4096))
4520 ok = may_access(addr + i);
4521 if (ok)
4522 chunk_appendf(buf, "%02x%s", ((uint8_t*)addr)[i], (i<n-1) ? " " : "]");
4523 else
4524 chunk_appendf(buf, "--%s", (i<n-1) ? " " : "]");
4525 }
4526}
4527
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004528/* print a line of text buffer (limited to 70 bytes) to <out>. The format is :
4529 * <2 spaces> <offset=5 digits> <space or plus> <space> <70 chars max> <\n>
4530 * which is 60 chars per line. Non-printable chars \t, \n, \r and \e are
4531 * encoded in C format. Other non-printable chars are encoded "\xHH". Original
4532 * lines are respected within the limit of 70 output chars. Lines that are
4533 * continuation of a previous truncated line begin with "+" instead of " "
4534 * after the offset. The new pointer is returned.
4535 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004536int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004537 int *line, int ptr)
4538{
4539 int end;
4540 unsigned char c;
4541
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004542 end = out->data + 80;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004543 if (end > out->size)
4544 return ptr;
4545
4546 chunk_appendf(out, " %05d%c ", ptr, (ptr == *line) ? ' ' : '+');
4547
4548 while (ptr < len && ptr < bsize) {
4549 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004550 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004551 if (out->data > end - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004552 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004553 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004554 } else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004555 if (out->data > end - 3)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004556 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004557 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004558 switch (c) {
4559 case '\t': c = 't'; break;
4560 case '\n': c = 'n'; break;
4561 case '\r': c = 'r'; break;
4562 case '\e': c = 'e'; break;
4563 case '\\': c = '\\'; break;
4564 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004565 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004566 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004567 if (out->data > end - 5)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004568 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004569 out->area[out->data++] = '\\';
4570 out->area[out->data++] = 'x';
4571 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4572 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004573 }
4574 if (buf[ptr++] == '\n') {
4575 /* we had a line break, let's return now */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004576 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004577 *line = ptr;
4578 return ptr;
4579 }
4580 }
4581 /* we have an incomplete line, we return it as-is */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004582 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004583 return ptr;
4584}
4585
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004586/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02004587 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
4588 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004589 */
Willy Tarreaued936c52017-04-27 18:03:20 +02004590void debug_hexdump(FILE *out, const char *pfx, const char *buf,
4591 unsigned int baseaddr, int len)
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004592{
Willy Tarreau73459792017-04-11 07:58:08 +02004593 unsigned int i;
4594 int b, j;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004595
4596 for (i = 0; i < (len + (baseaddr & 15)); i += 16) {
4597 b = i - (baseaddr & 15);
Willy Tarreaued936c52017-04-27 18:03:20 +02004598 fprintf(out, "%s%08x: ", pfx ? pfx : "", i + (baseaddr & ~15));
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004599 for (j = 0; j < 8; j++) {
4600 if (b + j >= 0 && b + j < len)
4601 fprintf(out, "%02x ", (unsigned char)buf[b + j]);
4602 else
4603 fprintf(out, " ");
4604 }
4605
4606 if (b + j >= 0 && b + j < len)
4607 fputc('-', out);
4608 else
4609 fputc(' ', out);
4610
4611 for (j = 8; j < 16; j++) {
4612 if (b + j >= 0 && b + j < len)
4613 fprintf(out, " %02x", (unsigned char)buf[b + j]);
4614 else
4615 fprintf(out, " ");
4616 }
4617
4618 fprintf(out, " ");
4619 for (j = 0; j < 16; j++) {
4620 if (b + j >= 0 && b + j < len) {
4621 if (isprint((unsigned char)buf[b + j]))
4622 fputc((unsigned char)buf[b + j], out);
4623 else
4624 fputc('.', out);
4625 }
4626 else
4627 fputc(' ', out);
4628 }
4629 fputc('\n', out);
4630 }
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004631}
4632
Willy Tarreaubb869862020-04-16 10:52:41 +02004633/* Tries to report the executable path name on platforms supporting this. If
4634 * not found or not possible, returns NULL.
4635 */
4636const char *get_exec_path()
4637{
4638 const char *ret = NULL;
4639
4640#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
4641 long execfn = getauxval(AT_EXECFN);
4642
4643 if (execfn && execfn != ENOENT)
4644 ret = (const char *)execfn;
4645#endif
4646 return ret;
4647}
4648
Baruch Siache1651b22020-07-24 07:52:20 +03004649#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreau9133e482020-03-04 10:19:36 +01004650/* calls dladdr() or dladdr1() on <addr> and <dli>. If dladdr1 is available,
4651 * also returns the symbol size in <size>, otherwise returns 0 there.
4652 */
4653static int dladdr_and_size(const void *addr, Dl_info *dli, size_t *size)
4654{
4655 int ret;
Willy Tarreau62af9c82020-03-10 07:51:48 +01004656#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) // most detailed one
Willy Tarreau9133e482020-03-04 10:19:36 +01004657 const ElfW(Sym) *sym;
4658
4659 ret = dladdr1(addr, dli, (void **)&sym, RTLD_DL_SYMENT);
4660 if (ret)
4661 *size = sym ? sym->st_size : 0;
4662#else
4663 ret = dladdr(addr, dli);
4664 *size = 0;
4665#endif
4666 return ret;
4667}
4668#endif
4669
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004670/* Tries to append to buffer <buf> some indications about the symbol at address
4671 * <addr> using the following form:
4672 * lib:+0xoffset (unresolvable address from lib's base)
4673 * main+0xoffset (unresolvable address from main (+/-))
4674 * lib:main+0xoffset (unresolvable lib address from main (+/-))
4675 * name (resolved exact exec address)
4676 * lib:name (resolved exact lib address)
4677 * name+0xoffset/0xsize (resolved address within exec symbol)
4678 * lib:name+0xoffset/0xsize (resolved address within lib symbol)
4679 *
4680 * The file name (lib or executable) is limited to what lies between the last
4681 * '/' and the first following '.'. An optional prefix <pfx> is prepended before
4682 * 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 +03004683 * that contains the "main" symbol, or when __ELF__ && USE_DL are not set.
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004684 *
4685 * The symbol's base address is returned, or NULL when unresolved, in order to
4686 * allow the caller to match it against known ones.
4687 */
Willy Tarreau45fd1032021-01-20 14:37:59 +01004688const void *resolve_sym_name(struct buffer *buf, const char *pfx, const void *addr)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004689{
4690 const struct {
4691 const void *func;
4692 const char *name;
4693 } fcts[] = {
4694 { .func = process_stream, .name = "process_stream" },
4695 { .func = task_run_applet, .name = "task_run_applet" },
4696 { .func = si_cs_io_cb, .name = "si_cs_io_cb" },
Willy Tarreau586f71b2020-12-11 15:54:36 +01004697 { .func = sock_conn_iocb, .name = "sock_conn_iocb" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004698 { .func = dgram_fd_handler, .name = "dgram_fd_handler" },
4699 { .func = listener_accept, .name = "listener_accept" },
Willy Tarreaud597ec22021-01-29 14:29:06 +01004700 { .func = manage_global_listener_queue, .name = "manage_global_listener_queue" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004701 { .func = poller_pipe_io_handler, .name = "poller_pipe_io_handler" },
4702 { .func = mworker_accept_wrapper, .name = "mworker_accept_wrapper" },
Willy Tarreau02922e12021-01-29 12:27:57 +01004703 { .func = session_expire_embryonic, .name = "session_expire_embryonic" },
Willy Tarreaufb5401f2021-01-29 12:25:23 +01004704#ifdef USE_THREAD
4705 { .func = accept_queue_process, .name = "accept_queue_process" },
4706#endif
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004707#ifdef USE_LUA
4708 { .func = hlua_process_task, .name = "hlua_process_task" },
4709#endif
Ilya Shipitsinbdec3ba2020-11-14 01:56:34 +05004710#ifdef SSL_MODE_ASYNC
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004711 { .func = ssl_async_fd_free, .name = "ssl_async_fd_free" },
4712 { .func = ssl_async_fd_handler, .name = "ssl_async_fd_handler" },
4713#endif
4714 };
4715
Baruch Siache1651b22020-07-24 07:52:20 +03004716#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004717 Dl_info dli, dli_main;
Willy Tarreau9133e482020-03-04 10:19:36 +01004718 size_t size;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004719 const char *fname, *p;
4720#endif
4721 int i;
4722
4723 if (pfx)
4724 chunk_appendf(buf, "%s", pfx);
4725
4726 for (i = 0; i < sizeof(fcts) / sizeof(fcts[0]); i++) {
4727 if (addr == fcts[i].func) {
4728 chunk_appendf(buf, "%s", fcts[i].name);
4729 return addr;
4730 }
4731 }
4732
Baruch Siache1651b22020-07-24 07:52:20 +03004733#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004734 /* Now let's try to be smarter */
Willy Tarreau9133e482020-03-04 10:19:36 +01004735 if (!dladdr_and_size(addr, &dli, &size))
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004736 goto unknown;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004737
4738 /* 1. prefix the library name if it's not the same object as the one
4739 * that contains the main function. The name is picked between last '/'
4740 * and first following '.'.
4741 */
4742 if (!dladdr(main, &dli_main))
4743 dli_main.dli_fbase = NULL;
4744
4745 if (dli_main.dli_fbase != dli.dli_fbase) {
4746 fname = dli.dli_fname;
4747 p = strrchr(fname, '/');
4748 if (p++)
4749 fname = p;
4750 p = strchr(fname, '.');
4751 if (!p)
4752 p = fname + strlen(fname);
4753
4754 chunk_appendf(buf, "%.*s:", (int)(long)(p - fname), fname);
4755 }
4756
4757 /* 2. symbol name */
4758 if (dli.dli_sname) {
4759 /* known, dump it and return symbol's address (exact or relative) */
4760 chunk_appendf(buf, "%s", dli.dli_sname);
4761 if (addr != dli.dli_saddr) {
4762 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_saddr));
Willy Tarreau9133e482020-03-04 10:19:36 +01004763 if (size)
4764 chunk_appendf(buf, "/%#lx", (long)size);
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004765 }
4766 return dli.dli_saddr;
4767 }
4768 else if (dli_main.dli_fbase != dli.dli_fbase) {
4769 /* unresolved symbol from a known library, report relative offset */
4770 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_fbase));
4771 return NULL;
4772 }
Baruch Siache1651b22020-07-24 07:52:20 +03004773#endif /* __ELF__ && !__linux__ || USE_DL */
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004774 unknown:
4775 /* unresolved symbol from the main file, report relative offset to main */
4776 if ((void*)addr < (void*)main)
4777 chunk_appendf(buf, "main-%#lx", (long)((void*)main - addr));
4778 else
4779 chunk_appendf(buf, "main+%#lx", (long)(addr - (void*)main));
4780 return NULL;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004781}
4782
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004783/*
4784 * Allocate an array of unsigned int with <nums> as address from <str> string
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05004785 * made of integer separated by dot characters.
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004786 *
4787 * First, initializes the value with <sz> as address to 0 and initializes the
4788 * array with <nums> as address to NULL. Then allocates the array with <nums> as
4789 * address updating <sz> pointed value to the size of this array.
4790 *
4791 * Returns 1 if succeeded, 0 if not.
4792 */
4793int parse_dotted_uints(const char *str, unsigned int **nums, size_t *sz)
4794{
4795 unsigned int *n;
4796 const char *s, *end;
4797
4798 s = str;
4799 *sz = 0;
4800 end = str + strlen(str);
4801 *nums = n = NULL;
4802
4803 while (1) {
4804 unsigned int r;
4805
4806 if (s >= end)
4807 break;
4808
4809 r = read_uint(&s, end);
4810 /* Expected characters after having read an uint: '\0' or '.',
4811 * if '.', must not be terminal.
4812 */
4813 if (*s != '\0'&& (*s++ != '.' || s == end))
4814 return 0;
4815
Frédéric Lécaille12a71842019-02-26 18:19:48 +01004816 n = my_realloc2(n, (*sz + 1) * sizeof *n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004817 if (!n)
4818 return 0;
4819
4820 n[(*sz)++] = r;
4821 }
4822 *nums = n;
4823
4824 return 1;
4825}
4826
Willy Tarreau4d589e72019-08-23 19:02:26 +02004827
4828/* returns the number of bytes needed to encode <v> as a varint. An inline
4829 * version exists for use with constants (__varint_bytes()).
4830 */
4831int varint_bytes(uint64_t v)
4832{
4833 int len = 1;
4834
4835 if (v >= 240) {
4836 v = (v - 240) >> 4;
4837 while (1) {
4838 len++;
4839 if (v < 128)
4840 break;
4841 v = (v - 128) >> 7;
4842 }
4843 }
4844 return len;
4845}
4846
Willy Tarreau52bf8392020-03-08 00:42:37 +01004847
4848/* Random number generator state, see below */
Willy Tarreau1544c142020-03-12 00:31:18 +01004849static uint64_t ha_random_state[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01004850
4851/* This is a thread-safe implementation of xoroshiro128** described below:
4852 * http://prng.di.unimi.it/
4853 * It features a 2^128 long sequence, returns 64 high-quality bits on each call,
4854 * supports fast jumps and passes all common quality tests. It is thread-safe,
4855 * uses a double-cas on 64-bit architectures supporting it, and falls back to a
4856 * local lock on other ones.
4857 */
4858uint64_t ha_random64()
4859{
4860 uint64_t result;
Willy Tarreau1544c142020-03-12 00:31:18 +01004861 uint64_t old[2] ALIGNED(2*sizeof(uint64_t));
4862 uint64_t new[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01004863
4864#if defined(USE_THREAD) && (!defined(HA_CAS_IS_8B) || !defined(HA_HAVE_CAS_DW))
4865 static HA_SPINLOCK_T rand_lock;
4866
4867 HA_SPIN_LOCK(OTHER_LOCK, &rand_lock);
4868#endif
4869
4870 old[0] = ha_random_state[0];
4871 old[1] = ha_random_state[1];
4872
4873#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
4874 do {
4875#endif
4876 result = rotl64(old[0] * 5, 7) * 9;
4877 new[1] = old[0] ^ old[1];
4878 new[0] = rotl64(old[0], 24) ^ new[1] ^ (new[1] << 16); // a, b
4879 new[1] = rotl64(new[1], 37); // c
4880
4881#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
4882 } while (unlikely(!_HA_ATOMIC_DWCAS(ha_random_state, old, new)));
4883#else
4884 ha_random_state[0] = new[0];
4885 ha_random_state[1] = new[1];
4886#if defined(USE_THREAD)
4887 HA_SPIN_UNLOCK(OTHER_LOCK, &rand_lock);
4888#endif
4889#endif
4890 return result;
4891}
4892
4893/* seeds the random state using up to <len> bytes from <seed>, starting with
4894 * the first non-zero byte.
4895 */
4896void ha_random_seed(const unsigned char *seed, size_t len)
4897{
4898 size_t pos;
4899
4900 /* the seed must not be all zeroes, so we pre-fill it with alternating
4901 * bits and overwrite part of them with the block starting at the first
4902 * non-zero byte from the seed.
4903 */
4904 memset(ha_random_state, 0x55, sizeof(ha_random_state));
4905
4906 for (pos = 0; pos < len; pos++)
4907 if (seed[pos] != 0)
4908 break;
4909
4910 if (pos == len)
4911 return;
4912
4913 seed += pos;
4914 len -= pos;
4915
4916 if (len > sizeof(ha_random_state))
4917 len = sizeof(ha_random_state);
4918
4919 memcpy(ha_random_state, seed, len);
4920}
4921
4922/* This causes a jump to (dist * 2^96) places in the pseudo-random sequence,
4923 * and is equivalent to calling ha_random64() as many times. It is used to
4924 * provide non-overlapping sequences of 2^96 numbers (~7*10^28) to up to 2^32
4925 * different generators (i.e. different processes after a fork). The <dist>
4926 * argument is the distance to jump to and is used in a loop so it rather not
4927 * be too large if the processing time is a concern.
4928 *
4929 * BEWARE: this function is NOT thread-safe and must not be called during
4930 * concurrent accesses to ha_random64().
4931 */
4932void ha_random_jump96(uint32_t dist)
4933{
4934 while (dist--) {
4935 uint64_t s0 = 0;
4936 uint64_t s1 = 0;
4937 int b;
4938
4939 for (b = 0; b < 64; b++) {
4940 if ((0xd2a98b26625eee7bULL >> b) & 1) {
4941 s0 ^= ha_random_state[0];
4942 s1 ^= ha_random_state[1];
4943 }
4944 ha_random64();
4945 }
4946
4947 for (b = 0; b < 64; b++) {
4948 if ((0xdddf9b1090aa7ac1ULL >> b) & 1) {
4949 s0 ^= ha_random_state[0];
4950 s1 ^= ha_random_state[1];
4951 }
4952 ha_random64();
4953 }
4954 ha_random_state[0] = s0;
4955 ha_random_state[1] = s1;
4956 }
4957}
4958
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01004959/* Generates an RFC4122 UUID into chunk <output> which must be at least 37
4960 * bytes large.
4961 */
4962void ha_generate_uuid(struct buffer *output)
4963{
4964 uint32_t rnd[4];
4965 uint64_t last;
4966
4967 last = ha_random64();
4968 rnd[0] = last;
4969 rnd[1] = last >> 32;
4970
4971 last = ha_random64();
4972 rnd[2] = last;
4973 rnd[3] = last >> 32;
4974
4975 chunk_printf(output, "%8.8x-%4.4x-%4.4x-%4.4x-%12.12llx",
4976 rnd[0],
4977 rnd[1] & 0xFFFF,
4978 ((rnd[1] >> 16u) & 0xFFF) | 0x4000, // highest 4 bits indicate the uuid version
4979 (rnd[2] & 0x3FFF) | 0x8000, // the highest 2 bits indicate the UUID variant (10),
4980 (long long)((rnd[2] >> 14u) | ((uint64_t) rnd[3] << 18u)) & 0xFFFFFFFFFFFFull);
4981}
4982
4983
Willy Tarreauc8d167b2020-06-16 16:27:26 +02004984/* only used by parse_line() below. It supports writing in place provided that
4985 * <in> is updated to the next location before calling it. In that case, the
4986 * char at <in> may be overwritten.
4987 */
4988#define EMIT_CHAR(x) \
4989 do { \
4990 char __c = (char)(x); \
4991 if ((opts & PARSE_OPT_INPLACE) && out+outpos > in) \
4992 err |= PARSE_ERR_OVERLAP; \
4993 if (outpos >= outmax) \
4994 err |= PARSE_ERR_TOOLARGE; \
4995 if (!err) \
4996 out[outpos] = __c; \
4997 outpos++; \
4998 } while (0)
4999
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05005000/* Parse <in>, copy it into <out> split into isolated words whose pointers
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005001 * are put in <args>. If more than <outlen> bytes have to be emitted, the
5002 * extraneous ones are not emitted but <outlen> is updated so that the caller
5003 * knows how much to realloc. Similarly, <args> are not updated beyond <nbargs>
5004 * but the returned <nbargs> indicates how many were found. All trailing args
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005005 * up to <nbargs> point to the trailing zero, and as long as <nbargs> is > 0,
5006 * it is guaranteed that at least one arg will point to the zero. It is safe
5007 * to call it with a NULL <args> if <nbargs> is 0.
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005008 *
5009 * <out> may overlap with <in> provided that it never goes further, in which
5010 * case the parser will accept to perform in-place parsing and unquoting/
5011 * unescaping but only if environment variables do not lead to expansion that
5012 * causes overlapping, otherwise the input string being destroyed, the error
5013 * will not be recoverable. Note that even during out-of-place <in> will
5014 * experience temporary modifications in-place for variable resolution and must
5015 * be writable, and will also receive zeroes to delimit words when using
5016 * in-place copy. Parsing options <opts> taken from PARSE_OPT_*. Return value
5017 * is zero on success otherwise a bitwise-or of PARSE_ERR_*. Upon error, the
5018 * starting point of the first invalid character sequence or unmatched
5019 * quote/brace is reported in <errptr> if not NULL. When using in-place parsing
5020 * error reporting might be difficult since zeroes will have been inserted into
5021 * the string. One solution for the caller may consist in replacing all args
5022 * delimiters with spaces in this case.
5023 */
5024uint32_t parse_line(char *in, char *out, size_t *outlen, char **args, int *nbargs, uint32_t opts, char **errptr)
5025{
5026 char *quote = NULL;
5027 char *brace = NULL;
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005028 char *word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005029 unsigned char hex1, hex2;
5030 size_t outmax = *outlen;
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005031 int argsmax = *nbargs - 1;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005032 size_t outpos = 0;
5033 int squote = 0;
5034 int dquote = 0;
5035 int arg = 0;
5036 uint32_t err = 0;
5037
5038 *nbargs = 0;
5039 *outlen = 0;
5040
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005041 /* argsmax may be -1 here, protecting args[] from any write */
5042 if (arg < argsmax)
5043 args[arg] = out;
5044
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005045 while (1) {
5046 if (*in >= '-' && *in != '\\') {
5047 /* speedup: directly send all regular chars starting
5048 * with '-', '.', '/', alnum etc...
5049 */
5050 EMIT_CHAR(*in++);
5051 continue;
5052 }
5053 else if (*in == '\0' || *in == '\n' || *in == '\r') {
5054 /* end of line */
5055 break;
5056 }
5057 else if (*in == '#' && (opts & PARSE_OPT_SHARP) && !squote && !dquote) {
5058 /* comment */
5059 break;
5060 }
5061 else if (*in == '"' && !squote && (opts & PARSE_OPT_DQUOTE)) { /* double quote outside single quotes */
5062 if (dquote) {
5063 dquote = 0;
5064 quote = NULL;
5065 }
5066 else {
5067 dquote = 1;
5068 quote = in;
5069 }
5070 in++;
5071 continue;
5072 }
5073 else if (*in == '\'' && !dquote && (opts & PARSE_OPT_SQUOTE)) { /* single quote outside double quotes */
5074 if (squote) {
5075 squote = 0;
5076 quote = NULL;
5077 }
5078 else {
5079 squote = 1;
5080 quote = in;
5081 }
5082 in++;
5083 continue;
5084 }
5085 else if (*in == '\\' && !squote && (opts & PARSE_OPT_BKSLASH)) {
5086 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
5087 * C equivalent value but only when they have a special meaning and within
5088 * double quotes for some of them. Other combinations left unchanged (eg: \1).
5089 */
5090 char tosend = *in;
5091
5092 switch (in[1]) {
5093 case ' ':
5094 case '\\':
5095 tosend = in[1];
5096 in++;
5097 break;
5098
5099 case 't':
5100 tosend = '\t';
5101 in++;
5102 break;
5103
5104 case 'n':
5105 tosend = '\n';
5106 in++;
5107 break;
5108
5109 case 'r':
5110 tosend = '\r';
5111 in++;
5112 break;
5113
5114 case '#':
5115 /* escaping of "#" only if comments are supported */
5116 if (opts & PARSE_OPT_SHARP)
5117 in++;
5118 tosend = *in;
5119 break;
5120
5121 case '\'':
5122 /* escaping of "'" only outside single quotes and only if single quotes are supported */
5123 if (opts & PARSE_OPT_SQUOTE && !squote)
5124 in++;
5125 tosend = *in;
5126 break;
5127
5128 case '"':
5129 /* escaping of '"' only outside single quotes and only if double quotes are supported */
5130 if (opts & PARSE_OPT_DQUOTE && !squote)
5131 in++;
5132 tosend = *in;
5133 break;
5134
5135 case '$':
5136 /* escaping of '$' only inside double quotes and only if env supported */
5137 if (opts & PARSE_OPT_ENV && dquote)
5138 in++;
5139 tosend = *in;
5140 break;
5141
5142 case 'x':
5143 if (!ishex(in[2]) || !ishex(in[3])) {
5144 /* invalid or incomplete hex sequence */
5145 err |= PARSE_ERR_HEX;
5146 if (errptr)
5147 *errptr = in;
5148 goto leave;
5149 }
Willy Tarreauf278eec2020-07-05 21:46:32 +02005150 hex1 = toupper((unsigned char)in[2]) - '0';
5151 hex2 = toupper((unsigned char)in[3]) - '0';
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005152 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
5153 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
5154 tosend = (hex1 << 4) + hex2;
5155 in += 3;
5156 break;
5157
5158 default:
5159 /* other combinations are not escape sequences */
5160 break;
5161 }
5162
5163 in++;
5164 EMIT_CHAR(tosend);
5165 }
5166 else if (isspace((unsigned char)*in) && !squote && !dquote) {
5167 /* a non-escaped space is an argument separator */
5168 while (isspace((unsigned char)*in))
5169 in++;
5170 EMIT_CHAR(0);
5171 arg++;
5172 if (arg < argsmax)
5173 args[arg] = out + outpos;
5174 else
5175 err |= PARSE_ERR_TOOMANY;
5176 }
5177 else if (*in == '$' && (opts & PARSE_OPT_ENV) && (dquote || !(opts & PARSE_OPT_DQUOTE))) {
5178 /* environment variables are evaluated anywhere, or only
5179 * inside double quotes if they are supported.
5180 */
5181 char *var_name;
5182 char save_char;
5183 char *value;
5184
5185 in++;
5186
5187 if (*in == '{')
5188 brace = in++;
5189
5190 if (!isalpha((unsigned char)*in) && *in != '_') {
5191 /* unacceptable character in variable name */
5192 err |= PARSE_ERR_VARNAME;
5193 if (errptr)
5194 *errptr = in;
5195 goto leave;
5196 }
5197
5198 var_name = in;
5199 while (isalnum((unsigned char)*in) || *in == '_')
5200 in++;
5201
5202 save_char = *in;
5203 *in = '\0';
5204 value = getenv(var_name);
5205 *in = save_char;
5206
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005207 /* support for '[*]' sequence to force word expansion,
5208 * only available inside braces */
5209 if (*in == '[' && brace && (opts & PARSE_OPT_WORD_EXPAND)) {
5210 word_expand = in++;
5211
5212 if (*in++ != '*' || *in++ != ']') {
5213 err |= PARSE_ERR_WRONG_EXPAND;
5214 if (errptr)
5215 *errptr = word_expand;
5216 goto leave;
5217 }
5218 }
5219
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005220 if (brace) {
5221 if (*in != '}') {
5222 /* unmatched brace */
5223 err |= PARSE_ERR_BRACE;
5224 if (errptr)
5225 *errptr = brace;
5226 goto leave;
5227 }
5228 in++;
5229 brace = NULL;
5230 }
5231
5232 if (value) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005233 while (*value) {
5234 /* expand as individual parameters on a space character */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005235 if (word_expand && isspace((unsigned char)*value)) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005236 EMIT_CHAR(0);
5237 ++arg;
5238 if (arg < argsmax)
5239 args[arg] = out + outpos;
5240 else
5241 err |= PARSE_ERR_TOOMANY;
5242
5243 /* skip consecutive spaces */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005244 while (isspace((unsigned char)*++value))
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005245 ;
5246 } else {
5247 EMIT_CHAR(*value++);
5248 }
5249 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005250 }
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005251 word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005252 }
5253 else {
5254 /* any other regular char */
5255 EMIT_CHAR(*in++);
5256 }
5257 }
5258
5259 /* end of output string */
5260 EMIT_CHAR(0);
5261 arg++;
5262
5263 if (quote) {
5264 /* unmatched quote */
5265 err |= PARSE_ERR_QUOTE;
5266 if (errptr)
5267 *errptr = quote;
5268 goto leave;
5269 }
5270 leave:
5271 *nbargs = arg;
5272 *outlen = outpos;
5273
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005274 /* empty all trailing args by making them point to the trailing zero,
5275 * at least the last one in any case.
5276 */
5277 if (arg > argsmax)
5278 arg = argsmax;
5279
5280 while (arg >= 0 && arg <= argsmax)
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005281 args[arg++] = out + outpos - 1;
5282
5283 return err;
5284}
5285#undef EMIT_CHAR
5286
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005287/* This is used to sanitize an input line that's about to be used for error reporting.
5288 * It will adjust <line> to print approximately <width> chars around <pos>, trying to
5289 * preserve the beginning, with leading or trailing "..." when the line is truncated.
5290 * If non-printable chars are present in the output. It returns the new offset <pos>
5291 * in the modified line. Non-printable characters are replaced with '?'. <width> must
5292 * be at least 6 to support two "..." otherwise the result is undefined. The line
5293 * itself must have at least 7 chars allocated for the same reason.
5294 */
5295size_t sanitize_for_printing(char *line, size_t pos, size_t width)
5296{
5297 size_t shift = 0;
5298 char *out = line;
5299 char *in = line;
5300 char *end = line + width;
5301
5302 if (pos >= width) {
5303 /* if we have to shift, we'll be out of context, so let's
5304 * try to put <pos> at the center of width.
5305 */
5306 shift = pos - width / 2;
5307 in += shift + 3;
5308 end = out + width - 3;
5309 out[0] = out[1] = out[2] = '.';
5310 out += 3;
5311 }
5312
5313 while (out < end && *in) {
5314 if (isspace((unsigned char)*in))
5315 *out++ = ' ';
5316 else if (isprint((unsigned char)*in))
5317 *out++ = *in;
5318 else
5319 *out++ = '?';
5320 in++;
5321 }
5322
5323 if (end < line + width) {
5324 out[0] = out[1] = out[2] = '.';
5325 out += 3;
5326 }
5327
5328 *out++ = 0;
5329 return pos - shift;
5330}
5331
Willy Tarreaubaaee002006-06-26 02:48:02 +02005332/*
5333 * Local variables:
5334 * c-indent-level: 8
5335 * c-basic-offset: 8
5336 * End:
5337 */