blob: 959b9b8cc67db672dd46dfa1a65aae9f757f9c24 [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
devnexen@gmail.com49a32282021-08-17 12:55:49 +010019#if defined(__FreeBSD__)
20#include <elf.h>
21#include <dlfcn.h>
22extern void *__elf_aux_vector;
23#endif
24
David Carlier1b9d57d2021-08-17 08:44:25 +010025#if defined(__NetBSD__)
26#include <sys/exec_elf.h>
27#include <dlfcn.h>
28#endif
29
Willy Tarreau2e74c3f2007-12-02 18:45:09 +010030#include <ctype.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020031#include <errno.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020032#include <netdb.h>
Willy Tarreau9a7bea52012-04-27 11:16:50 +020033#include <stdarg.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020034#include <stdio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020035#include <stdlib.h>
36#include <string.h>
Thierry Fournier93127942016-01-20 18:49:45 +010037#include <time.h>
Willy Tarreau16e01562016-08-09 16:46:18 +020038#include <unistd.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010039#include <sys/socket.h>
Willy Tarreau37101052019-05-20 16:48:20 +020040#include <sys/stat.h>
41#include <sys/types.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010042#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020043#include <netinet/in.h>
44#include <arpa/inet.h>
45
Willy Tarreau1ee71dd2021-08-30 10:15:35 +020046#if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
Willy Tarreau30053062020-08-20 16:39:14 +020047#include <sys/auxv.h>
48#endif
49
Willy Tarreau48fbcae2020-06-03 18:09:46 +020050#include <import/eb32sctree.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020051#include <import/eb32tree.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020052
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020053#include <haproxy/api.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020054#include <haproxy/chunk.h>
Willy Tarreau7c18b542020-06-11 09:23:02 +020055#include <haproxy/dgram.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020056#include <haproxy/global.h>
Willy Tarreau86416052020-06-04 09:20:54 +020057#include <haproxy/hlua.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020058#include <haproxy/listener.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020059#include <haproxy/namespace.h>
Christopher Faulet9553de72021-02-26 09:12:50 +010060#include <haproxy/net_helper.h>
Willy Tarreau5fc93282020-09-16 18:25:03 +020061#include <haproxy/protocol.h>
Emeric Brunc9437992021-02-12 19:42:55 +010062#include <haproxy/resolvers.h>
Willy Tarreau586f71b2020-12-11 15:54:36 +010063#include <haproxy/sock.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020064#include <haproxy/ssl_sock.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020065#include <haproxy/stream_interface.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020066#include <haproxy/task.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020067#include <haproxy/tools.h>
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +010068
Thierry Fournier93127942016-01-20 18:49:45 +010069/* This macro returns false if the test __x is false. Many
70 * of the following parsing function must be abort the processing
71 * if it returns 0, so this macro is useful for writing light code.
72 */
73#define RET0_UNLESS(__x) do { if (!(__x)) return 0; } while (0)
74
Willy Tarreau56adcf22012-12-23 18:00:29 +010075/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020076 * 2^64-1 = 18446744073709551615 or
77 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020078 *
79 * The HTML version needs room for adding the 25 characters
80 * '<span class="rls"></span>' around digits at positions 3N+1 in order
81 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020082 */
Christopher Faulet99bca652017-11-14 16:47:26 +010083THREAD_LOCAL char itoa_str[NB_ITOA_STR][171];
84THREAD_LOCAL int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020085
Willy Tarreau588297f2014-06-16 15:16:40 +020086/* sometimes we'll need to quote strings (eg: in stats), and we don't expect
87 * to quote strings larger than a max configuration line.
88 */
Christopher Faulet99bca652017-11-14 16:47:26 +010089THREAD_LOCAL char quoted_str[NB_QSTR][QSTR_SIZE + 1];
90THREAD_LOCAL int quoted_idx = 0;
Willy Tarreau588297f2014-06-16 15:16:40 +020091
Willy Tarreau06e69b52021-03-02 14:01:35 +010092/* thread-local PRNG state. It's modified to start from a different sequence
93 * on all threads upon startup. It must not be used or anything beyond getting
94 * statistical values as it's 100% predictable.
95 */
96THREAD_LOCAL unsigned int statistical_prng_state = 2463534242U;
97
Willy Tarreaubaaee002006-06-26 02:48:02 +020098/*
William Lallemande7340ec2012-01-24 11:15:39 +010099 * unsigned long long ASCII representation
100 *
101 * return the last char '\0' or NULL if no enough
102 * space in dst
103 */
104char *ulltoa(unsigned long long n, char *dst, size_t size)
105{
106 int i = 0;
107 char *res;
108
109 switch(n) {
110 case 1ULL ... 9ULL:
111 i = 0;
112 break;
113
114 case 10ULL ... 99ULL:
115 i = 1;
116 break;
117
118 case 100ULL ... 999ULL:
119 i = 2;
120 break;
121
122 case 1000ULL ... 9999ULL:
123 i = 3;
124 break;
125
126 case 10000ULL ... 99999ULL:
127 i = 4;
128 break;
129
130 case 100000ULL ... 999999ULL:
131 i = 5;
132 break;
133
134 case 1000000ULL ... 9999999ULL:
135 i = 6;
136 break;
137
138 case 10000000ULL ... 99999999ULL:
139 i = 7;
140 break;
141
142 case 100000000ULL ... 999999999ULL:
143 i = 8;
144 break;
145
146 case 1000000000ULL ... 9999999999ULL:
147 i = 9;
148 break;
149
150 case 10000000000ULL ... 99999999999ULL:
151 i = 10;
152 break;
153
154 case 100000000000ULL ... 999999999999ULL:
155 i = 11;
156 break;
157
158 case 1000000000000ULL ... 9999999999999ULL:
159 i = 12;
160 break;
161
162 case 10000000000000ULL ... 99999999999999ULL:
163 i = 13;
164 break;
165
166 case 100000000000000ULL ... 999999999999999ULL:
167 i = 14;
168 break;
169
170 case 1000000000000000ULL ... 9999999999999999ULL:
171 i = 15;
172 break;
173
174 case 10000000000000000ULL ... 99999999999999999ULL:
175 i = 16;
176 break;
177
178 case 100000000000000000ULL ... 999999999999999999ULL:
179 i = 17;
180 break;
181
182 case 1000000000000000000ULL ... 9999999999999999999ULL:
183 i = 18;
184 break;
185
186 case 10000000000000000000ULL ... ULLONG_MAX:
187 i = 19;
188 break;
189 }
190 if (i + 2 > size) // (i + 1) + '\0'
191 return NULL; // too long
192 res = dst + i + 1;
193 *res = '\0';
194 for (; i >= 0; i--) {
195 dst[i] = n % 10ULL + '0';
196 n /= 10ULL;
197 }
198 return res;
199}
200
201/*
202 * unsigned long ASCII representation
203 *
204 * return the last char '\0' or NULL if no enough
205 * space in dst
206 */
207char *ultoa_o(unsigned long n, char *dst, size_t size)
208{
209 int i = 0;
210 char *res;
211
212 switch (n) {
213 case 0U ... 9UL:
214 i = 0;
215 break;
216
217 case 10U ... 99UL:
218 i = 1;
219 break;
220
221 case 100U ... 999UL:
222 i = 2;
223 break;
224
225 case 1000U ... 9999UL:
226 i = 3;
227 break;
228
229 case 10000U ... 99999UL:
230 i = 4;
231 break;
232
233 case 100000U ... 999999UL:
234 i = 5;
235 break;
236
237 case 1000000U ... 9999999UL:
238 i = 6;
239 break;
240
241 case 10000000U ... 99999999UL:
242 i = 7;
243 break;
244
245 case 100000000U ... 999999999UL:
246 i = 8;
247 break;
248#if __WORDSIZE == 32
249
250 case 1000000000ULL ... ULONG_MAX:
251 i = 9;
252 break;
253
254#elif __WORDSIZE == 64
255
256 case 1000000000ULL ... 9999999999UL:
257 i = 9;
258 break;
259
260 case 10000000000ULL ... 99999999999UL:
261 i = 10;
262 break;
263
264 case 100000000000ULL ... 999999999999UL:
265 i = 11;
266 break;
267
268 case 1000000000000ULL ... 9999999999999UL:
269 i = 12;
270 break;
271
272 case 10000000000000ULL ... 99999999999999UL:
273 i = 13;
274 break;
275
276 case 100000000000000ULL ... 999999999999999UL:
277 i = 14;
278 break;
279
280 case 1000000000000000ULL ... 9999999999999999UL:
281 i = 15;
282 break;
283
284 case 10000000000000000ULL ... 99999999999999999UL:
285 i = 16;
286 break;
287
288 case 100000000000000000ULL ... 999999999999999999UL:
289 i = 17;
290 break;
291
292 case 1000000000000000000ULL ... 9999999999999999999UL:
293 i = 18;
294 break;
295
296 case 10000000000000000000ULL ... ULONG_MAX:
297 i = 19;
298 break;
299
300#endif
301 }
302 if (i + 2 > size) // (i + 1) + '\0'
303 return NULL; // too long
304 res = dst + i + 1;
305 *res = '\0';
306 for (; i >= 0; i--) {
307 dst[i] = n % 10U + '0';
308 n /= 10U;
309 }
310 return res;
311}
312
313/*
314 * signed long ASCII representation
315 *
316 * return the last char '\0' or NULL if no enough
317 * space in dst
318 */
319char *ltoa_o(long int n, char *dst, size_t size)
320{
321 char *pos = dst;
322
323 if (n < 0) {
324 if (size < 3)
325 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
326 *pos = '-';
327 pos++;
328 dst = ultoa_o(-n, pos, size - 1);
329 } else {
330 dst = ultoa_o(n, dst, size);
331 }
332 return dst;
333}
334
335/*
336 * signed long long ASCII representation
337 *
338 * return the last char '\0' or NULL if no enough
339 * space in dst
340 */
341char *lltoa(long long n, char *dst, size_t size)
342{
343 char *pos = dst;
344
345 if (n < 0) {
346 if (size < 3)
347 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
348 *pos = '-';
349 pos++;
350 dst = ulltoa(-n, pos, size - 1);
351 } else {
352 dst = ulltoa(n, dst, size);
353 }
354 return dst;
355}
356
357/*
358 * write a ascii representation of a unsigned into dst,
359 * return a pointer to the last character
360 * Pad the ascii representation with '0', using size.
361 */
362char *utoa_pad(unsigned int n, char *dst, size_t size)
363{
364 int i = 0;
365 char *ret;
366
367 switch(n) {
368 case 0U ... 9U:
369 i = 0;
370 break;
371
372 case 10U ... 99U:
373 i = 1;
374 break;
375
376 case 100U ... 999U:
377 i = 2;
378 break;
379
380 case 1000U ... 9999U:
381 i = 3;
382 break;
383
384 case 10000U ... 99999U:
385 i = 4;
386 break;
387
388 case 100000U ... 999999U:
389 i = 5;
390 break;
391
392 case 1000000U ... 9999999U:
393 i = 6;
394 break;
395
396 case 10000000U ... 99999999U:
397 i = 7;
398 break;
399
400 case 100000000U ... 999999999U:
401 i = 8;
402 break;
403
404 case 1000000000U ... 4294967295U:
405 i = 9;
406 break;
407 }
408 if (i + 2 > size) // (i + 1) + '\0'
409 return NULL; // too long
410 if (i < size)
411 i = size - 2; // padding - '\0'
412
413 ret = dst + i + 1;
414 *ret = '\0';
415 for (; i >= 0; i--) {
416 dst[i] = n % 10U + '0';
417 n /= 10U;
418 }
419 return ret;
420}
421
422/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200423 * copies at most <size-1> chars from <src> to <dst>. Last char is always
424 * set to 0, unless <size> is 0. The number of chars copied is returned
425 * (excluding the terminating zero).
426 * This code has been optimized for size and speed : on x86, it's 45 bytes
427 * long, uses only registers, and consumes only 4 cycles per char.
428 */
429int strlcpy2(char *dst, const char *src, int size)
430{
431 char *orig = dst;
432 if (size) {
433 while (--size && (*dst = *src)) {
434 src++; dst++;
435 }
436 *dst = 0;
437 }
438 return dst - orig;
439}
440
441/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200442 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200443 * the ascii representation for number 'n' in decimal.
444 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100445char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200446{
447 char *pos;
448
Willy Tarreau72d759c2007-10-25 12:14:10 +0200449 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200450 *pos-- = '\0';
451
452 do {
453 *pos-- = '0' + n % 10;
454 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200455 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200456 return pos + 1;
457}
458
Willy Tarreau91092e52007-10-25 16:58:42 +0200459/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200460 * This function simply returns a locally allocated string containing
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200461 * the ascii representation for number 'n' in decimal.
462 */
463char *lltoa_r(long long int in, char *buffer, int size)
464{
465 char *pos;
466 int neg = 0;
467 unsigned long long int n;
468
469 pos = buffer + size - 1;
470 *pos-- = '\0';
471
472 if (in < 0) {
473 neg = 1;
474 n = -in;
475 }
476 else
477 n = in;
478
479 do {
480 *pos-- = '0' + n % 10;
481 n /= 10;
482 } while (n && pos >= buffer);
483 if (neg && pos > buffer)
484 *pos-- = '-';
485 return pos + 1;
486}
487
488/*
489 * This function simply returns a locally allocated string containing
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200490 * the ascii representation for signed number 'n' in decimal.
491 */
492char *sltoa_r(long n, char *buffer, int size)
493{
494 char *pos;
495
496 if (n >= 0)
497 return ultoa_r(n, buffer, size);
498
499 pos = ultoa_r(-n, buffer + 1, size - 1) - 1;
500 *pos = '-';
501 return pos;
502}
503
504/*
505 * This function simply returns a locally allocated string containing
Willy Tarreaue7239b52009-03-29 13:41:58 +0200506 * the ascii representation for number 'n' in decimal, formatted for
507 * HTML output with tags to create visual grouping by 3 digits. The
508 * output needs to support at least 171 characters.
509 */
510const char *ulltoh_r(unsigned long long n, char *buffer, int size)
511{
512 char *start;
513 int digit = 0;
514
515 start = buffer + size;
516 *--start = '\0';
517
518 do {
519 if (digit == 3 && start >= buffer + 7)
520 memcpy(start -= 7, "</span>", 7);
521
522 if (start >= buffer + 1) {
523 *--start = '0' + n % 10;
524 n /= 10;
525 }
526
527 if (digit == 3 && start >= buffer + 18)
528 memcpy(start -= 18, "<span class=\"rls\">", 18);
529
530 if (digit++ == 3)
531 digit = 1;
532 } while (n && start > buffer);
533 return start;
534}
535
536/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200537 * This function simply returns a locally allocated string containing the ascii
538 * representation for number 'n' in decimal, unless n is 0 in which case it
539 * returns the alternate string (or an empty string if the alternate string is
540 * NULL). It use is intended for limits reported in reports, where it's
541 * desirable not to display anything if there is no limit. Warning! it shares
542 * the same vector as ultoa_r().
543 */
544const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
545{
546 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
547}
548
Willy Tarreau56d1d8d2021-05-08 10:28:53 +0200549/* Trims the first "%f" float in a string to its minimum number of digits after
550 * the decimal point by trimming trailing zeroes, even dropping the decimal
551 * point if not needed. The string is in <buffer> of length <len>, and the
552 * number is expected to start at or after position <num_start> (the first
553 * point appearing there is considered). A NUL character is always placed at
554 * the end if some trimming occurs. The new buffer length is returned.
555 */
556size_t flt_trim(char *buffer, size_t num_start, size_t len)
557{
558 char *end = buffer + len;
559 char *p = buffer + num_start;
560 char *trim;
561
562 do {
563 if (p >= end)
564 return len;
565 trim = p++;
566 } while (*trim != '.');
567
568 /* For now <trim> is on the decimal point. Let's look for any other
569 * meaningful digit after it.
570 */
571 while (p < end) {
572 if (*p++ != '0')
573 trim = p;
574 }
575
576 if (trim < end)
577 *trim = 0;
578
579 return trim - buffer;
580}
581
Willy Tarreauae03d262021-05-08 07:35:00 +0200582/*
583 * This function simply returns a locally allocated string containing
584 * the ascii representation for number 'n' in decimal with useless trailing
585 * zeroes trimmed.
586 */
587char *ftoa_r(double n, char *buffer, int size)
588{
589 flt_trim(buffer, 0, snprintf(buffer, size, "%f", n));
590 return buffer;
591}
592
Willy Tarreau588297f2014-06-16 15:16:40 +0200593/* returns a locally allocated string containing the quoted encoding of the
594 * input string. The output may be truncated to QSTR_SIZE chars, but it is
595 * guaranteed that the string will always be properly terminated. Quotes are
596 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
597 * always be at least 4 chars.
598 */
599const char *qstr(const char *str)
600{
601 char *ret = quoted_str[quoted_idx];
602 char *p, *end;
603
604 if (++quoted_idx >= NB_QSTR)
605 quoted_idx = 0;
606
607 p = ret;
608 end = ret + QSTR_SIZE;
609
610 *p++ = '"';
611
612 /* always keep 3 chars to support passing "" and the ending " */
613 while (*str && p < end - 3) {
614 if (*str == '"') {
615 *p++ = '"';
616 *p++ = '"';
617 }
618 else
619 *p++ = *str;
620 str++;
621 }
622 *p++ = '"';
623 return ret;
624}
625
Robert Tsai81ae1952007-12-05 10:47:29 +0100626/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200627 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
628 *
629 * It looks like this one would be a good candidate for inlining, but this is
630 * not interesting because it around 35 bytes long and often called multiple
631 * times within the same function.
632 */
633int ishex(char s)
634{
635 s -= '0';
636 if ((unsigned char)s <= 9)
637 return 1;
638 s -= 'A' - '0';
639 if ((unsigned char)s <= 5)
640 return 1;
641 s -= 'a' - 'A';
642 if ((unsigned char)s <= 5)
643 return 1;
644 return 0;
645}
646
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100647/* rounds <i> down to the closest value having max 2 digits */
648unsigned int round_2dig(unsigned int i)
649{
650 unsigned int mul = 1;
651
652 while (i >= 100) {
653 i /= 10;
654 mul *= 10;
655 }
656 return i * mul;
657}
658
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100659/*
660 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
661 * invalid character is found, a pointer to it is returned. If everything is
662 * fine, NULL is returned.
663 */
664const char *invalid_char(const char *name)
665{
666 if (!*name)
667 return name;
668
669 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100670 if (!isalnum((unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100671 *name != '_' && *name != '-')
672 return name;
673 name++;
674 }
675 return NULL;
676}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200677
678/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200679 * Checks <name> for invalid characters. Valid chars are [_.-] and those
680 * accepted by <f> function.
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200681 * If an invalid character is found, a pointer to it is returned.
682 * If everything is fine, NULL is returned.
683 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200684static inline const char *__invalid_char(const char *name, int (*f)(int)) {
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200685
686 if (!*name)
687 return name;
688
689 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100690 if (!f((unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200691 *name != '_' && *name != '-')
692 return name;
693
694 name++;
695 }
696
697 return NULL;
698}
699
700/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200701 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
702 * If an invalid character is found, a pointer to it is returned.
703 * If everything is fine, NULL is returned.
704 */
705const char *invalid_domainchar(const char *name) {
706 return __invalid_char(name, isalnum);
707}
708
709/*
710 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
711 * If an invalid character is found, a pointer to it is returned.
712 * If everything is fine, NULL is returned.
713 */
714const char *invalid_prefix_char(const char *name) {
Thierry Fournierf7b7c3e2018-03-26 11:54:39 +0200715 return __invalid_char(name, isalnum);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200716}
717
718/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100719 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100720 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
721 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
722 * the function tries to guess the address family from the syntax. If the
723 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100724 * string is assumed to contain only an address, no port. The address can be a
725 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
726 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
727 * The return address will only have the address family and the address set,
728 * all other fields remain zero. The string is not supposed to be modified.
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100729 * The IPv6 '::' address is IN6ADDR_ANY. If <resolve> is non-zero, the hostname
730 * is resolved, otherwise only IP addresses are resolved, and anything else
Willy Tarreauecde7df2016-11-02 22:37:03 +0100731 * returns NULL. If the address contains a port, this one is preserved.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200732 */
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100733struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200734{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100735 struct hostent *he;
mildisff5d5102015-10-26 18:50:08 +0100736 /* max IPv6 length, including brackets and terminating NULL */
737 char tmpip[48];
Willy Tarreauecde7df2016-11-02 22:37:03 +0100738 int port = get_host_port(sa);
mildisff5d5102015-10-26 18:50:08 +0100739
740 /* check IPv6 with square brackets */
741 if (str[0] == '[') {
742 size_t iplength = strlen(str);
743
744 if (iplength < 4) {
745 /* minimal size is 4 when using brackets "[::]" */
746 goto fail;
747 }
748 else if (iplength >= sizeof(tmpip)) {
749 /* IPv6 literal can not be larger than tmpip */
750 goto fail;
751 }
752 else {
753 if (str[iplength - 1] != ']') {
754 /* if address started with bracket, it should end with bracket */
755 goto fail;
756 }
757 else {
758 memcpy(tmpip, str + 1, iplength - 2);
759 tmpip[iplength - 2] = '\0';
760 str = tmpip;
761 }
762 }
763 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100764
Willy Tarreaufab5a432011-03-04 15:31:53 +0100765 /* Any IPv6 address */
766 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100767 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
768 sa->ss_family = AF_INET6;
769 else if (sa->ss_family != AF_INET6)
770 goto fail;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100771 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100772 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100773 }
774
Willy Tarreau24709282013-03-10 21:32:12 +0100775 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100776 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100777 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
778 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100779 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100780 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100781 }
782
783 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100784 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
785 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100786 sa->ss_family = AF_INET6;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100787 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100788 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100789 }
790
791 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100792 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
793 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100794 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100795 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100796 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100797 }
798
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100799 if (!resolve)
800 return NULL;
801
Emeric Brund30e9a12020-12-23 18:49:16 +0100802 if (!resolv_hostname_validation(str, NULL))
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200803 return NULL;
804
David du Colombierd5f43282011-03-17 10:40:16 +0100805#ifdef USE_GETADDRINFO
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200806 if (global.tune.options & GTUNE_USE_GAI) {
David du Colombierd5f43282011-03-17 10:40:16 +0100807 struct addrinfo hints, *result;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100808 int success = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100809
810 memset(&result, 0, sizeof(result));
811 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100812 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100813 hints.ai_socktype = SOCK_DGRAM;
Dmitry Sivachenkoeab7f392015-10-02 01:01:58 +0200814 hints.ai_flags = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100815 hints.ai_protocol = 0;
816
817 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100818 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
819 sa->ss_family = result->ai_family;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100820 else if (sa->ss_family != result->ai_family) {
821 freeaddrinfo(result);
Willy Tarreau24709282013-03-10 21:32:12 +0100822 goto fail;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100823 }
Willy Tarreau24709282013-03-10 21:32:12 +0100824
David du Colombierd5f43282011-03-17 10:40:16 +0100825 switch (result->ai_family) {
826 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100827 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100828 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100829 success = 1;
830 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100831 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100832 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100833 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100834 success = 1;
835 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100836 }
837 }
838
Sean Carey58ea0392013-02-15 23:39:18 +0100839 if (result)
840 freeaddrinfo(result);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100841
842 if (success)
843 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100844 }
David du Colombierd5f43282011-03-17 10:40:16 +0100845#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200846 /* try to resolve an IPv4/IPv6 hostname */
847 he = gethostbyname(str);
848 if (he) {
849 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
850 sa->ss_family = he->h_addrtype;
851 else if (sa->ss_family != he->h_addrtype)
852 goto fail;
853
854 switch (sa->ss_family) {
855 case AF_INET:
856 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100857 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200858 return sa;
859 case AF_INET6:
860 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100861 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200862 return sa;
863 }
864 }
865
David du Colombierd5f43282011-03-17 10:40:16 +0100866 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100867 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100868 return NULL;
869}
870
871/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100872 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
873 * range or offset consisting in two integers that the caller will have to
874 * check to find the relevant input format. The following format are supported :
875 *
876 * String format | address | port | low | high
877 * addr | <addr> | 0 | 0 | 0
878 * addr: | <addr> | 0 | 0 | 0
879 * addr:port | <addr> | <port> | <port> | <port>
880 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
881 * addr:+port | <addr> | <port> | 0 | <port>
882 * addr:-port | <addr> |-<port> | <port> | 0
883 *
884 * The detection of a port range or increment by the caller is made by
885 * comparing <low> and <high>. If both are equal, then port 0 means no port
886 * was specified. The caller may pass NULL for <low> and <high> if it is not
887 * interested in retrieving port ranges.
888 *
889 * Note that <addr> above may also be :
890 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
891 * - "*" => family will be AF_INET and address will be INADDR_ANY
892 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
893 * - a host name => family and address will depend on host name resolving.
894 *
Willy Tarreau24709282013-03-10 21:32:12 +0100895 * A prefix may be passed in before the address above to force the family :
896 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
897 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
898 * - "unix@" => force address to be a path to a UNIX socket even if the
899 * path does not start with a '/'
Willy Tarreauccfccef2014-05-10 01:49:15 +0200900 * - 'abns@' -> force address to belong to the abstract namespace (Linux
901 * only). These sockets are just like Unix sockets but without
902 * the need for an underlying file system. The address is a
903 * string. Technically it's like a Unix socket with a zero in
904 * the first byte of the address.
Willy Tarreau40aa0702013-03-10 23:51:38 +0100905 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100906 *
mildisff5d5102015-10-26 18:50:08 +0100907 * IPv6 addresses can be declared with or without square brackets. When using
908 * square brackets for IPv6 addresses, the port separator (colon) is optional.
909 * If not using square brackets, and in order to avoid any ambiguity with
910 * IPv6 addresses, the last colon ':' is mandatory even when no port is specified.
911 * NULL is returned if the address cannot be parsed. The <low> and <high> ports
912 * are always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100913 *
914 * If <pfx> is non-null, it is used as a string prefix before any path-based
915 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100916 *
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200917 * if <fqdn> is non-null, it will be filled with :
918 * - a pointer to the FQDN of the server name to resolve if there's one, and
919 * that the caller will have to free(),
920 * - NULL if there was an explicit address that doesn't require resolution.
921 *
Willy Tarreaucd3a55912020-09-04 15:30:46 +0200922 * Hostnames are only resolved if <opts> has PA_O_RESOLVE. Otherwise <fqdn> is
923 * still honored so it is possible for the caller to know whether a resolution
924 * failed by clearing this flag and checking if <fqdn> was filled, indicating
925 * the need for a resolution.
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200926 *
Willy Tarreau40aa0702013-03-10 23:51:38 +0100927 * When a file descriptor is passed, its value is put into the s_addr part of
Willy Tarreaua5b325f2020-09-04 16:44:20 +0200928 * the address when cast to sockaddr_in and the address family is
929 * AF_CUST_EXISTING_FD.
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200930 *
Willy Tarreau5fc93282020-09-16 18:25:03 +0200931 * The matching protocol will be set into <proto> if non-null.
932 *
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200933 * Any known file descriptor is also assigned to <fd> if non-null, otherwise it
934 * is forced to -1.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100935 */
Willy Tarreau5fc93282020-09-16 18:25:03 +0200936struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int *high, int *fd,
937 struct protocol **proto, char **err,
938 const char *pfx, char **fqdn, unsigned int opts)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100939{
Christopher Faulet1bc04c72017-10-29 20:14:08 +0100940 static THREAD_LOCAL struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100941 struct sockaddr_storage *ret = NULL;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200942 struct protocol *new_proto = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100943 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100944 char *port1, *port2;
945 int portl, porth, porta;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200946 int abstract = 0;
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200947 int new_fd = -1;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200948 int sock_type, ctrl_type;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100949
950 portl = porth = porta = 0;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200951 if (fqdn)
952 *fqdn = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200953
Willy Tarreaudad36a32013-03-11 01:20:04 +0100954 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100955 if (str2 == NULL) {
956 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100957 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100958 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200959
Willy Tarreau9f69f462015-09-08 16:01:25 +0200960 if (!*str2) {
961 memprintf(err, "'%s' resolves to an empty address (environment variable missing?)\n", str);
962 goto out;
963 }
964
Willy Tarreau24709282013-03-10 21:32:12 +0100965 memset(&ss, 0, sizeof(ss));
966
Willy Tarreaue835bd82020-09-16 11:35:47 +0200967 /* prepare the default socket types */
Willy Tarreauf23b1bc2021-03-23 18:36:37 +0100968 if ((opts & (PA_O_STREAM|PA_O_DGRAM)) == PA_O_DGRAM ||
969 ((opts & (PA_O_STREAM|PA_O_DGRAM)) == (PA_O_DGRAM|PA_O_STREAM) && (opts & PA_O_DEFAULT_DGRAM)))
Willy Tarreaue835bd82020-09-16 11:35:47 +0200970 sock_type = ctrl_type = SOCK_DGRAM;
971 else
972 sock_type = ctrl_type = SOCK_STREAM;
973
974 if (strncmp(str2, "stream+", 7) == 0) {
975 str2 += 7;
976 sock_type = ctrl_type = SOCK_STREAM;
977 }
978 else if (strncmp(str2, "dgram+", 6) == 0) {
979 str2 += 6;
980 sock_type = ctrl_type = SOCK_DGRAM;
981 }
982
Willy Tarreau24709282013-03-10 21:32:12 +0100983 if (strncmp(str2, "unix@", 5) == 0) {
984 str2 += 5;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200985 abstract = 0;
Willy Tarreau24709282013-03-10 21:32:12 +0100986 ss.ss_family = AF_UNIX;
987 }
Emeric Brunce325c42021-04-02 17:05:09 +0200988 else if (strncmp(str2, "uxdg@", 5) == 0) {
989 str2 += 5;
990 abstract = 0;
991 ss.ss_family = AF_UNIX;
992 sock_type = ctrl_type = SOCK_DGRAM;
993 }
994 else if (strncmp(str2, "uxst@", 5) == 0) {
995 str2 += 5;
996 abstract = 0;
997 ss.ss_family = AF_UNIX;
998 sock_type = ctrl_type = SOCK_STREAM;
999 }
Willy Tarreauccfccef2014-05-10 01:49:15 +02001000 else if (strncmp(str2, "abns@", 5) == 0) {
1001 str2 += 5;
1002 abstract = 1;
1003 ss.ss_family = AF_UNIX;
1004 }
Emeric Brunce325c42021-04-02 17:05:09 +02001005 else if (strncmp(str2, "ip@", 3) == 0) {
1006 str2 += 3;
1007 ss.ss_family = AF_UNSPEC;
1008 }
Willy Tarreau24709282013-03-10 21:32:12 +01001009 else if (strncmp(str2, "ipv4@", 5) == 0) {
1010 str2 += 5;
1011 ss.ss_family = AF_INET;
1012 }
1013 else if (strncmp(str2, "ipv6@", 5) == 0) {
1014 str2 += 5;
1015 ss.ss_family = AF_INET6;
1016 }
Emeric Brunce325c42021-04-02 17:05:09 +02001017 else if (strncmp(str2, "tcp4@", 5) == 0) {
1018 str2 += 5;
1019 ss.ss_family = AF_INET;
1020 sock_type = ctrl_type = SOCK_STREAM;
1021 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001022 else if (strncmp(str2, "udp4@", 5) == 0) {
1023 str2 += 5;
1024 ss.ss_family = AF_INET;
Willy Tarreaue835bd82020-09-16 11:35:47 +02001025 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001026 }
Emeric Brunce325c42021-04-02 17:05:09 +02001027 else if (strncmp(str2, "tcp6@", 5) == 0) {
1028 str2 += 5;
1029 ss.ss_family = AF_INET6;
1030 sock_type = ctrl_type = SOCK_STREAM;
1031 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001032 else if (strncmp(str2, "udp6@", 5) == 0) {
1033 str2 += 5;
1034 ss.ss_family = AF_INET6;
Willy Tarreaue835bd82020-09-16 11:35:47 +02001035 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001036 }
Emeric Brunce325c42021-04-02 17:05:09 +02001037 else if (strncmp(str2, "tcp@", 4) == 0) {
1038 str2 += 4;
1039 ss.ss_family = AF_UNSPEC;
1040 sock_type = ctrl_type = SOCK_STREAM;
1041 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001042 else if (strncmp(str2, "udp@", 4) == 0) {
1043 str2 += 4;
1044 ss.ss_family = AF_UNSPEC;
Willy Tarreaue835bd82020-09-16 11:35:47 +02001045 sock_type = ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001046 }
Frédéric Lécaille10caf652020-11-23 11:36:57 +01001047 else if (strncmp(str2, "quic4@", 6) == 0) {
1048 str2 += 6;
1049 ss.ss_family = AF_INET;
1050 sock_type = SOCK_DGRAM;
1051 ctrl_type = SOCK_STREAM;
1052 }
1053 else if (strncmp(str2, "quic6@", 6) == 0) {
1054 str2 += 6;
1055 ss.ss_family = AF_INET6;
1056 sock_type = SOCK_DGRAM;
1057 ctrl_type = SOCK_STREAM;
1058 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001059 else if (strncmp(str2, "fd@", 3) == 0) {
1060 str2 += 3;
1061 ss.ss_family = AF_CUST_EXISTING_FD;
1062 }
1063 else if (strncmp(str2, "sockpair@", 9) == 0) {
1064 str2 += 9;
1065 ss.ss_family = AF_CUST_SOCKPAIR;
1066 }
Willy Tarreau24709282013-03-10 21:32:12 +01001067 else if (*str2 == '/') {
1068 ss.ss_family = AF_UNIX;
1069 }
1070 else
1071 ss.ss_family = AF_UNSPEC;
1072
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001073 if (ss.ss_family == AF_CUST_SOCKPAIR) {
Willy Tarreaua215be22020-09-16 10:14:16 +02001074 struct sockaddr_storage ss2;
1075 socklen_t addr_len;
William Lallemand2fe7dd02018-09-11 16:51:29 +02001076 char *endptr;
1077
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001078 new_fd = strtol(str2, &endptr, 10);
1079 if (!*str2 || new_fd < 0 || *endptr) {
William Lallemand2fe7dd02018-09-11 16:51:29 +02001080 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
1081 goto out;
1082 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001083
Willy Tarreaua215be22020-09-16 10:14:16 +02001084 /* just verify that it's a socket */
1085 addr_len = sizeof(ss2);
1086 if (getsockname(new_fd, (struct sockaddr *)&ss2, &addr_len) == -1) {
1087 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1088 goto out;
1089 }
1090
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001091 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1092 ((struct sockaddr_in *)&ss)->sin_port = 0;
William Lallemand2fe7dd02018-09-11 16:51:29 +02001093 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001094 else if (ss.ss_family == AF_CUST_EXISTING_FD) {
Willy Tarreau40aa0702013-03-10 23:51:38 +01001095 char *endptr;
1096
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001097 new_fd = strtol(str2, &endptr, 10);
1098 if (!*str2 || new_fd < 0 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +01001099 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +01001100 goto out;
1101 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001102
Willy Tarreau6edc7222020-09-15 17:41:56 +02001103 if (opts & PA_O_SOCKET_FD) {
1104 socklen_t addr_len;
1105 int type;
1106
1107 addr_len = sizeof(ss);
1108 if (getsockname(new_fd, (struct sockaddr *)&ss, &addr_len) == -1) {
1109 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1110 goto out;
1111 }
1112
1113 addr_len = sizeof(type);
1114 if (getsockopt(new_fd, SOL_SOCKET, SO_TYPE, &type, &addr_len) != 0 ||
Willy Tarreaue835bd82020-09-16 11:35:47 +02001115 (type == SOCK_STREAM) != (sock_type == SOCK_STREAM)) {
Willy Tarreau6edc7222020-09-15 17:41:56 +02001116 memprintf(err, "socket on file descriptor '%d' is of the wrong type.\n", new_fd);
1117 goto out;
1118 }
1119
1120 porta = portl = porth = get_host_port(&ss);
1121 } else if (opts & PA_O_RAW_FD) {
1122 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1123 ((struct sockaddr_in *)&ss)->sin_port = 0;
1124 } else {
1125 memprintf(err, "a file descriptor is not acceptable here in '%s'\n", str);
1126 goto out;
1127 }
Willy Tarreau40aa0702013-03-10 23:51:38 +01001128 }
1129 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau8daa9202019-06-16 18:16:33 +02001130 struct sockaddr_un *un = (struct sockaddr_un *)&ss;
Willy Tarreau15586382013-03-04 19:48:14 +01001131 int prefix_path_len;
1132 int max_path_len;
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001133 int adr_len;
Willy Tarreau15586382013-03-04 19:48:14 +01001134
1135 /* complete unix socket path name during startup or soft-restart is
1136 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
1137 */
Willy Tarreauccfccef2014-05-10 01:49:15 +02001138 prefix_path_len = (pfx && !abstract) ? strlen(pfx) : 0;
Willy Tarreau8daa9202019-06-16 18:16:33 +02001139 max_path_len = (sizeof(un->sun_path) - 1) -
Willy Tarreau327ea5a2020-02-11 06:43:37 +01001140 (abstract ? 0 : prefix_path_len + 1 + 5 + 1 + 3);
Willy Tarreau15586382013-03-04 19:48:14 +01001141
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001142 adr_len = strlen(str2);
1143 if (adr_len > max_path_len) {
Willy Tarreau15586382013-03-04 19:48:14 +01001144 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
1145 goto out;
1146 }
1147
Willy Tarreauccfccef2014-05-10 01:49:15 +02001148 /* when abstract==1, we skip the first zero and copy all bytes except the trailing zero */
Willy Tarreau8daa9202019-06-16 18:16:33 +02001149 memset(un->sun_path, 0, sizeof(un->sun_path));
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001150 if (prefix_path_len)
Willy Tarreau8daa9202019-06-16 18:16:33 +02001151 memcpy(un->sun_path, pfx, prefix_path_len);
1152 memcpy(un->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
Willy Tarreau15586382013-03-04 19:48:14 +01001153 }
Willy Tarreau24709282013-03-10 21:32:12 +01001154 else { /* IPv4 and IPv6 */
mildisff5d5102015-10-26 18:50:08 +01001155 char *end = str2 + strlen(str2);
1156 char *chr;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001157
mildisff5d5102015-10-26 18:50:08 +01001158 /* search for : or ] whatever comes first */
1159 for (chr = end-1; chr > str2; chr--) {
1160 if (*chr == ']' || *chr == ':')
1161 break;
1162 }
1163
1164 if (*chr == ':') {
1165 /* Found a colon before a closing-bracket, must be a port separator.
1166 * This guarantee backward compatibility.
1167 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001168 if (!(opts & PA_O_PORT_OK)) {
1169 memprintf(err, "port specification not permitted here in '%s'", str);
1170 goto out;
1171 }
mildisff5d5102015-10-26 18:50:08 +01001172 *chr++ = '\0';
1173 port1 = chr;
1174 }
1175 else {
1176 /* Either no colon and no closing-bracket
1177 * or directly ending with a closing-bracket.
1178 * However, no port.
1179 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001180 if (opts & PA_O_PORT_MAND) {
1181 memprintf(err, "missing port specification in '%s'", str);
1182 goto out;
1183 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001184 port1 = "";
mildisff5d5102015-10-26 18:50:08 +01001185 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001186
Willy Tarreau90807112020-02-25 08:16:33 +01001187 if (isdigit((unsigned char)*port1)) { /* single port or range */
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001188 port2 = strchr(port1, '-');
Willy Tarreau7f96a842020-09-15 11:12:44 +02001189 if (port2) {
1190 if (!(opts & PA_O_PORT_RANGE)) {
1191 memprintf(err, "port range not permitted here in '%s'", str);
1192 goto out;
1193 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001194 *port2++ = '\0';
Willy Tarreau7f96a842020-09-15 11:12:44 +02001195 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001196 else
1197 port2 = port1;
1198 portl = atoi(port1);
1199 porth = atoi(port2);
Willy Tarreau7f96a842020-09-15 11:12:44 +02001200
1201 if (portl < !!(opts & PA_O_PORT_MAND) || portl > 65535) {
1202 memprintf(err, "invalid port '%s'", port1);
1203 goto out;
1204 }
1205
1206 if (porth < !!(opts & PA_O_PORT_MAND) || porth > 65535) {
1207 memprintf(err, "invalid port '%s'", port2);
1208 goto out;
1209 }
1210
1211 if (portl > porth) {
1212 memprintf(err, "invalid port range '%d-%d'", portl, porth);
1213 goto out;
1214 }
1215
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001216 porta = portl;
1217 }
1218 else if (*port1 == '-') { /* negative offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001219 if (!(opts & PA_O_PORT_OFS)) {
1220 memprintf(err, "port offset not permitted here in '%s'", str);
1221 goto out;
1222 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001223 portl = atoi(port1 + 1);
1224 porta = -portl;
1225 }
1226 else if (*port1 == '+') { /* positive offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001227 if (!(opts & PA_O_PORT_OFS)) {
1228 memprintf(err, "port offset not permitted here in '%s'", str);
1229 goto out;
1230 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001231 porth = atoi(port1 + 1);
1232 porta = porth;
1233 }
1234 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +01001235 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001236 goto out;
1237 }
Willy Tarreau7f96a842020-09-15 11:12:44 +02001238 else if (opts & PA_O_PORT_MAND) {
1239 memprintf(err, "missing port specification in '%s'", str);
1240 goto out;
1241 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001242
1243 /* first try to parse the IP without resolving. If it fails, it
1244 * tells us we need to keep a copy of the FQDN to resolve later
1245 * and to enable DNS. In this case we can proceed if <fqdn> is
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001246 * set or if PA_O_RESOLVE is set, otherwise it's an error.
Willy Tarreauceccdd72016-11-02 22:27:10 +01001247 */
1248 if (str2ip2(str2, &ss, 0) == NULL) {
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001249 if ((!(opts & PA_O_RESOLVE) && !fqdn) ||
1250 ((opts & PA_O_RESOLVE) && str2ip2(str2, &ss, 1) == NULL)) {
Willy Tarreauceccdd72016-11-02 22:27:10 +01001251 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
1252 goto out;
1253 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001254
Willy Tarreauceccdd72016-11-02 22:27:10 +01001255 if (fqdn) {
1256 if (str2 != back)
1257 memmove(back, str2, strlen(str2) + 1);
1258 *fqdn = back;
1259 back = NULL;
1260 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001261 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001262 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +01001263 }
Willy Tarreaufab5a432011-03-04 15:31:53 +01001264
Willy Tarreaue835bd82020-09-16 11:35:47 +02001265 if (ctrl_type == SOCK_STREAM && !(opts & PA_O_STREAM)) {
1266 memprintf(err, "stream-type socket not acceptable in '%s'\n", str);
1267 goto out;
1268 }
1269 else if (ctrl_type == SOCK_DGRAM && !(opts & PA_O_DGRAM)) {
1270 memprintf(err, "dgram-type socket not acceptable in '%s'\n", str);
1271 goto out;
1272 }
1273
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001274 if (proto || (opts & PA_O_CONNECT)) {
Willy Tarreau5fc93282020-09-16 18:25:03 +02001275 /* Note: if the caller asks for a proto, we must find one,
Emeric Brun26754902021-04-07 14:26:44 +02001276 * except if we inherit from a raw FD (family == AF_CUST_EXISTING_FD)
1277 * orif we return with an fqdn that will resolve later,
Willy Tarreau5fc93282020-09-16 18:25:03 +02001278 * in which case the address is not known yet (this is only
1279 * for servers actually).
1280 */
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001281 new_proto = protocol_lookup(ss.ss_family,
Willy Tarreauaf9609b2020-09-16 22:04:46 +02001282 sock_type == SOCK_DGRAM,
1283 ctrl_type == SOCK_DGRAM);
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001284
Emeric Brun26754902021-04-07 14:26:44 +02001285 if (!new_proto && (!fqdn || !*fqdn) && (ss.ss_family != AF_CUST_EXISTING_FD)) {
Willy Tarreau5fc93282020-09-16 18:25:03 +02001286 memprintf(err, "unsupported protocol family %d for address '%s'", ss.ss_family, str);
1287 goto out;
1288 }
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001289
1290 if ((opts & PA_O_CONNECT) && new_proto && !new_proto->connect) {
1291 memprintf(err, "connect() not supported for this protocol family %d used by address '%s'", ss.ss_family, str);
1292 goto out;
1293 }
Willy Tarreau5fc93282020-09-16 18:25:03 +02001294 }
1295
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001296 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +01001297 out:
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001298 if (port)
1299 *port = porta;
Willy Tarreaud4448bc2013-02-20 15:55:15 +01001300 if (low)
1301 *low = portl;
1302 if (high)
1303 *high = porth;
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001304 if (fd)
1305 *fd = new_fd;
Willy Tarreau5fc93282020-09-16 18:25:03 +02001306 if (proto)
1307 *proto = new_proto;
Willy Tarreau24709282013-03-10 21:32:12 +01001308 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +01001309 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001310}
1311
Thayne McCombs92149f92020-11-20 01:28:26 -07001312/* converts <addr> and <port> into a string representation of the address and port. This is sort
1313 * of an inverse of str2sa_range, with some restrictions. The supported families are AF_INET,
1314 * AF_INET6, AF_UNIX, and AF_CUST_SOCKPAIR. If the family is unsopported NULL is returned.
1315 * If map_ports is true, then the sign of the port is included in the output, to indicate it is
1316 * relative to the incoming port. AF_INET and AF_INET6 will be in the form "<addr>:<port>".
1317 * AF_UNIX will either be just the path (if using a pathname) or "abns@<path>" if it is abstract.
1318 * AF_CUST_SOCKPAIR will be of the form "sockpair@<fd>".
1319 *
1320 * The returned char* is allocated, and it is the responsibility of the caller to free it.
1321 */
1322char * sa2str(const struct sockaddr_storage *addr, int port, int map_ports)
1323{
1324 char buffer[INET6_ADDRSTRLEN];
1325 char *out = NULL;
1326 const void *ptr;
1327 const char *path;
1328
1329 switch (addr->ss_family) {
1330 case AF_INET:
1331 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1332 break;
1333 case AF_INET6:
1334 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1335 break;
1336 case AF_UNIX:
1337 path = ((struct sockaddr_un *)addr)->sun_path;
1338 if (path[0] == '\0') {
1339 const int max_length = sizeof(struct sockaddr_un) - offsetof(struct sockaddr_un, sun_path) - 1;
1340 return memprintf(&out, "abns@%.*s", max_length, path+1);
1341 } else {
1342 return strdup(path);
1343 }
1344 case AF_CUST_SOCKPAIR:
1345 return memprintf(&out, "sockpair@%d", ((struct sockaddr_in *)addr)->sin_addr.s_addr);
1346 default:
1347 return NULL;
1348 }
1349 inet_ntop(addr->ss_family, ptr, buffer, get_addr_len(addr));
1350 if (map_ports)
1351 return memprintf(&out, "%s:%+d", buffer, port);
1352 else
1353 return memprintf(&out, "%s:%d", buffer, port);
1354}
1355
1356
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001357/* converts <str> to a struct in_addr containing a network mask. It can be
1358 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +03001359 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001360 */
1361int str2mask(const char *str, struct in_addr *mask)
1362{
1363 if (strchr(str, '.') != NULL) { /* dotted notation */
1364 if (!inet_pton(AF_INET, str, mask))
1365 return 0;
1366 }
1367 else { /* mask length */
1368 char *err;
1369 unsigned long len = strtol(str, &err, 10);
1370
1371 if (!*str || (err && *err) || (unsigned)len > 32)
1372 return 0;
Tim Duesterhus8575f722018-01-25 16:24:48 +01001373
1374 len2mask4(len, mask);
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001375 }
1376 return 1;
1377}
1378
Tim Duesterhus47185172018-01-25 16:24:49 +01001379/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +01001380 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +01001381 * if the conversion succeeds otherwise zero.
1382 */
1383int str2mask6(const char *str, struct in6_addr *mask)
1384{
1385 if (strchr(str, ':') != NULL) { /* quadruplet notation */
1386 if (!inet_pton(AF_INET6, str, mask))
1387 return 0;
1388 }
1389 else { /* mask length */
1390 char *err;
1391 unsigned long len = strtol(str, &err, 10);
1392
1393 if (!*str || (err && *err) || (unsigned)len > 128)
1394 return 0;
1395
1396 len2mask6(len, mask);
1397 }
1398 return 1;
1399}
1400
Thierry FOURNIERb0504632013-12-14 15:39:02 +01001401/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
1402 * succeeds otherwise zero.
1403 */
1404int cidr2dotted(int cidr, struct in_addr *mask) {
1405
1406 if (cidr < 0 || cidr > 32)
1407 return 0;
1408
1409 mask->s_addr = cidr ? htonl(~0UL << (32 - cidr)) : 0;
1410 return 1;
1411}
1412
Thierry Fournier70473a52016-02-17 17:12:14 +01001413/* Convert mask from bit length form to in_addr form.
1414 * This function never fails.
1415 */
1416void len2mask4(int len, struct in_addr *addr)
1417{
1418 if (len >= 32) {
1419 addr->s_addr = 0xffffffff;
1420 return;
1421 }
1422 if (len <= 0) {
1423 addr->s_addr = 0x00000000;
1424 return;
1425 }
1426 addr->s_addr = 0xffffffff << (32 - len);
1427 addr->s_addr = htonl(addr->s_addr);
1428}
1429
1430/* Convert mask from bit length form to in6_addr form.
1431 * This function never fails.
1432 */
1433void len2mask6(int len, struct in6_addr *addr)
1434{
1435 len2mask4(len, (struct in_addr *)&addr->s6_addr[0]); /* msb */
1436 len -= 32;
1437 len2mask4(len, (struct in_addr *)&addr->s6_addr[4]);
1438 len -= 32;
1439 len2mask4(len, (struct in_addr *)&addr->s6_addr[8]);
1440 len -= 32;
1441 len2mask4(len, (struct in_addr *)&addr->s6_addr[12]); /* lsb */
1442}
1443
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001444/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +02001445 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001446 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001447 * is optional and either in the dotted or CIDR notation.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001448 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
1449 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001450int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001451{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001452 __label__ out_free, out_err;
1453 char *c, *s;
1454 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001455
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001456 s = strdup(str);
1457 if (!s)
1458 return 0;
1459
Willy Tarreaubaaee002006-06-26 02:48:02 +02001460 memset(mask, 0, sizeof(*mask));
1461 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001462
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001463 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001464 *c++ = '\0';
1465 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001466 if (!str2mask(c, mask))
1467 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001468 }
1469 else {
Willy Tarreauebd61602006-12-30 11:54:15 +01001470 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001471 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001472 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001473 struct hostent *he;
1474
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001475 if (!resolve)
1476 goto out_err;
1477
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001478 if ((he = gethostbyname(s)) == NULL) {
1479 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001480 }
1481 else
1482 *addr = *(struct in_addr *) *(he->h_addr_list);
1483 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001484
1485 ret_val = 1;
1486 out_free:
1487 free(s);
1488 return ret_val;
1489 out_err:
1490 ret_val = 0;
1491 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001492}
1493
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001494
1495/*
Willy Tarreau6d20e282012-04-27 22:49:47 +02001496 * converts <str> to two struct in6_addr* which must be pre-allocated.
1497 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001498 * is an optional number of bits (128 being the default).
Willy Tarreau6d20e282012-04-27 22:49:47 +02001499 * Returns 1 if OK, 0 if error.
1500 */
1501int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
1502{
1503 char *c, *s;
1504 int ret_val = 0;
1505 char *err;
1506 unsigned long len = 128;
1507
1508 s = strdup(str);
1509 if (!s)
1510 return 0;
1511
1512 memset(mask, 0, sizeof(*mask));
1513 memset(addr, 0, sizeof(*addr));
1514
1515 if ((c = strrchr(s, '/')) != NULL) {
1516 *c++ = '\0'; /* c points to the mask */
1517 if (!*c)
1518 goto out_free;
1519
1520 len = strtoul(c, &err, 10);
1521 if ((err && *err) || (unsigned)len > 128)
1522 goto out_free;
1523 }
1524 *mask = len; /* OK we have a valid mask in <len> */
1525
1526 if (!inet_pton(AF_INET6, s, addr))
1527 goto out_free;
1528
1529 ret_val = 1;
1530 out_free:
1531 free(s);
1532 return ret_val;
1533}
1534
1535
1536/*
Willy Tarreau12e10272021-03-25 11:34:40 +01001537 * Parse IPv4 address found in url. Return the number of bytes parsed. It
1538 * expects exactly 4 numbers between 0 and 255 delimited by dots, and returns
1539 * zero in case of mismatch.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001540 */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001541int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001542{
1543 int saw_digit, octets, ch;
1544 u_char tmp[4], *tp;
1545 const char *cp = addr;
1546
1547 saw_digit = 0;
1548 octets = 0;
1549 *(tp = tmp) = 0;
1550
1551 while (*addr) {
Willy Tarreau12e10272021-03-25 11:34:40 +01001552 unsigned char digit = (ch = *addr) - '0';
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001553 if (digit > 9 && ch != '.')
1554 break;
Willy Tarreau12e10272021-03-25 11:34:40 +01001555 addr++;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001556 if (digit <= 9) {
1557 u_int new = *tp * 10 + digit;
1558 if (new > 255)
1559 return 0;
1560 *tp = new;
1561 if (!saw_digit) {
1562 if (++octets > 4)
1563 return 0;
1564 saw_digit = 1;
1565 }
1566 } else if (ch == '.' && saw_digit) {
1567 if (octets == 4)
1568 return 0;
1569 *++tp = 0;
1570 saw_digit = 0;
1571 } else
1572 return 0;
1573 }
1574
1575 if (octets < 4)
1576 return 0;
1577
1578 memcpy(&dst->s_addr, tmp, 4);
Willy Tarreau12e10272021-03-25 11:34:40 +01001579 return addr - cp;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001580}
1581
1582/*
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001583 * Resolve destination server from URL. Convert <str> to a sockaddr_storage.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001584 * <out> contain the code of the detected scheme, the start and length of
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001585 * the hostname. Actually only http and https are supported. <out> can be NULL.
1586 * This function returns the consumed length. It is useful if you parse complete
1587 * url like http://host:port/path, because the consumed length corresponds to
1588 * the first character of the path. If the conversion fails, it returns -1.
1589 *
1590 * This function tries to resolve the DNS name if haproxy is in starting mode.
1591 * So, this function may be used during the configuration parsing.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001592 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001593int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001594{
1595 const char *curr = url, *cp = url;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001596 const char *end;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001597 int ret, url_code = 0;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001598 unsigned long long int http_code = 0;
1599 int default_port;
1600 struct hostent *he;
1601 char *p;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001602
1603 /* Firstly, try to find :// pattern */
1604 while (curr < url+ulen && url_code != 0x3a2f2f) {
1605 url_code = ((url_code & 0xffff) << 8);
1606 url_code += (unsigned char)*curr++;
1607 }
1608
1609 /* Secondly, if :// pattern is found, verify parsed stuff
1610 * before pattern is matching our http pattern.
1611 * If so parse ip address and port in uri.
1612 *
1613 * WARNING: Current code doesn't support dynamic async dns resolver.
1614 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001615 if (url_code != 0x3a2f2f)
1616 return -1;
1617
1618 /* Copy scheme, and utrn to lower case. */
1619 while (cp < curr - 3)
1620 http_code = (http_code << 8) + *cp++;
1621 http_code |= 0x2020202020202020ULL; /* Turn everything to lower case */
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001622
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001623 /* HTTP or HTTPS url matching */
1624 if (http_code == 0x2020202068747470ULL) {
1625 default_port = 80;
1626 if (out)
1627 out->scheme = SCH_HTTP;
1628 }
1629 else if (http_code == 0x2020206874747073ULL) {
1630 default_port = 443;
1631 if (out)
1632 out->scheme = SCH_HTTPS;
1633 }
1634 else
1635 return -1;
1636
1637 /* If the next char is '[', the host address is IPv6. */
1638 if (*curr == '[') {
1639 curr++;
1640
1641 /* Check trash size */
1642 if (trash.size < ulen)
1643 return -1;
1644
1645 /* Look for ']' and copy the address in a trash buffer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001646 p = trash.area;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001647 for (end = curr;
1648 end < url + ulen && *end != ']';
1649 end++, p++)
1650 *p = *end;
1651 if (*end != ']')
1652 return -1;
1653 *p = '\0';
1654
1655 /* Update out. */
1656 if (out) {
1657 out->host = curr;
1658 out->host_len = end - curr;
1659 }
1660
1661 /* Try IPv6 decoding. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001662 if (!inet_pton(AF_INET6, trash.area, &((struct sockaddr_in6 *)addr)->sin6_addr))
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001663 return -1;
1664 end++;
1665
1666 /* Decode port. */
1667 if (*end == ':') {
1668 end++;
1669 default_port = read_uint(&end, url + ulen);
1670 }
1671 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1672 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1673 return end - url;
1674 }
1675 else {
1676 /* We are looking for IP address. If you want to parse and
1677 * resolve hostname found in url, you can use str2sa_range(), but
1678 * be warned this can slow down global daemon performances
1679 * while handling lagging dns responses.
1680 */
1681 ret = url2ipv4(curr, &((struct sockaddr_in *)addr)->sin_addr);
1682 if (ret) {
1683 /* Update out. */
1684 if (out) {
1685 out->host = curr;
1686 out->host_len = ret;
1687 }
1688
1689 curr += ret;
1690
1691 /* Decode port. */
1692 if (*curr == ':') {
1693 curr++;
1694 default_port = read_uint(&curr, url + ulen);
1695 }
1696 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1697
1698 /* Set family. */
1699 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1700 return curr - url;
1701 }
1702 else if (global.mode & MODE_STARTING) {
1703 /* The IPv4 and IPv6 decoding fails, maybe the url contain name. Try to execute
1704 * synchronous DNS request only if HAProxy is in the start state.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001705 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001706
1707 /* look for : or / or end */
1708 for (end = curr;
1709 end < url + ulen && *end != '/' && *end != ':';
1710 end++);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001711 memcpy(trash.area, curr, end - curr);
1712 trash.area[end - curr] = '\0';
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001713
1714 /* try to resolve an IPv4/IPv6 hostname */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001715 he = gethostbyname(trash.area);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001716 if (!he)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001717 return -1;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001718
1719 /* Update out. */
1720 if (out) {
1721 out->host = curr;
1722 out->host_len = end - curr;
1723 }
1724
1725 /* Decode port. */
1726 if (*end == ':') {
1727 end++;
1728 default_port = read_uint(&end, url + ulen);
1729 }
1730
1731 /* Copy IP address, set port and family. */
1732 switch (he->h_addrtype) {
1733 case AF_INET:
1734 ((struct sockaddr_in *)addr)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
1735 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1736 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1737 return end - url;
1738
1739 case AF_INET6:
1740 ((struct sockaddr_in6 *)addr)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
1741 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1742 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1743 return end - url;
1744 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001745 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001746 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001747 return -1;
1748}
1749
Willy Tarreau631f01c2011-09-05 00:36:48 +02001750/* Tries to convert a sockaddr_storage address to text form. Upon success, the
1751 * address family is returned so that it's easy for the caller to adapt to the
1752 * output format. Zero is returned if the address family is not supported. -1
1753 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1754 * supported.
1755 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001756int addr_to_str(const struct sockaddr_storage *addr, char *str, int size)
Willy Tarreau631f01c2011-09-05 00:36:48 +02001757{
1758
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001759 const void *ptr;
Willy Tarreau631f01c2011-09-05 00:36:48 +02001760
1761 if (size < 5)
1762 return 0;
1763 *str = '\0';
1764
1765 switch (addr->ss_family) {
1766 case AF_INET:
1767 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1768 break;
1769 case AF_INET6:
1770 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1771 break;
1772 case AF_UNIX:
1773 memcpy(str, "unix", 5);
1774 return addr->ss_family;
1775 default:
1776 return 0;
1777 }
1778
1779 if (inet_ntop(addr->ss_family, ptr, str, size))
1780 return addr->ss_family;
1781
1782 /* failed */
1783 return -1;
1784}
1785
Simon Horman75ab8bd2014-06-16 09:39:41 +09001786/* Tries to convert a sockaddr_storage port to text form. Upon success, the
1787 * address family is returned so that it's easy for the caller to adapt to the
1788 * output format. Zero is returned if the address family is not supported. -1
1789 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1790 * supported.
1791 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001792int port_to_str(const struct sockaddr_storage *addr, char *str, int size)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001793{
1794
1795 uint16_t port;
1796
1797
Willy Tarreaud7dad1b2017-01-06 16:46:22 +01001798 if (size < 6)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001799 return 0;
1800 *str = '\0';
1801
1802 switch (addr->ss_family) {
1803 case AF_INET:
1804 port = ((struct sockaddr_in *)addr)->sin_port;
1805 break;
1806 case AF_INET6:
1807 port = ((struct sockaddr_in6 *)addr)->sin6_port;
1808 break;
1809 case AF_UNIX:
1810 memcpy(str, "unix", 5);
1811 return addr->ss_family;
1812 default:
1813 return 0;
1814 }
1815
1816 snprintf(str, size, "%u", ntohs(port));
1817 return addr->ss_family;
1818}
1819
Willy Tarreau16e01562016-08-09 16:46:18 +02001820/* check if the given address is local to the system or not. It will return
1821 * -1 when it's not possible to know, 0 when the address is not local, 1 when
1822 * it is. We don't want to iterate over all interfaces for this (and it is not
1823 * portable). So instead we try to bind in UDP to this address on a free non
1824 * privileged port and to connect to the same address, port 0 (connect doesn't
1825 * care). If it succeeds, we own the address. Note that non-inet addresses are
1826 * considered local since they're most likely AF_UNIX.
1827 */
1828int addr_is_local(const struct netns_entry *ns,
1829 const struct sockaddr_storage *orig)
1830{
1831 struct sockaddr_storage addr;
1832 int result;
1833 int fd;
1834
1835 if (!is_inet_addr(orig))
1836 return 1;
1837
1838 memcpy(&addr, orig, sizeof(addr));
1839 set_host_port(&addr, 0);
1840
1841 fd = my_socketat(ns, addr.ss_family, SOCK_DGRAM, IPPROTO_UDP);
1842 if (fd < 0)
1843 return -1;
1844
1845 result = -1;
1846 if (bind(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == 0) {
1847 if (connect(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == -1)
1848 result = 0; // fail, non-local address
1849 else
1850 result = 1; // success, local address
1851 }
1852 else {
1853 if (errno == EADDRNOTAVAIL)
1854 result = 0; // definitely not local :-)
1855 }
1856 close(fd);
1857
1858 return result;
1859}
1860
Willy Tarreaubaaee002006-06-26 02:48:02 +02001861/* will try to encode the string <string> replacing all characters tagged in
1862 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1863 * prefixed by <escape>, and will store the result between <start> (included)
1864 * and <stop> (excluded), and will always terminate the string with a '\0'
1865 * before <stop>. The position of the '\0' is returned if the conversion
1866 * completes. If bytes are missing between <start> and <stop>, then the
1867 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1868 * cannot even be stored so we return <start> without writing the 0.
1869 * The input string must also be zero-terminated.
1870 */
1871const char hextab[16] = "0123456789ABCDEF";
1872char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001873 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +02001874 const char *string)
1875{
1876 if (start < stop) {
1877 stop--; /* reserve one byte for the final '\0' */
1878 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001879 if (!ha_bit_test((unsigned char)(*string), map))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001880 *start++ = *string;
1881 else {
1882 if (start + 3 >= stop)
1883 break;
1884 *start++ = escape;
1885 *start++ = hextab[(*string >> 4) & 15];
1886 *start++ = hextab[*string & 15];
1887 }
1888 string++;
1889 }
1890 *start = '\0';
1891 }
1892 return start;
1893}
1894
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001895/*
1896 * Same behavior as encode_string() above, except that it encodes chunk
1897 * <chunk> instead of a string.
1898 */
1899char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001900 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001901 const struct buffer *chunk)
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001902{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001903 char *str = chunk->area;
1904 char *end = chunk->area + chunk->data;
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001905
1906 if (start < stop) {
1907 stop--; /* reserve one byte for the final '\0' */
1908 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001909 if (!ha_bit_test((unsigned char)(*str), map))
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001910 *start++ = *str;
1911 else {
1912 if (start + 3 >= stop)
1913 break;
1914 *start++ = escape;
1915 *start++ = hextab[(*str >> 4) & 15];
1916 *start++ = hextab[*str & 15];
1917 }
1918 str++;
1919 }
1920 *start = '\0';
1921 }
1922 return start;
1923}
1924
Dragan Dosen0edd1092016-02-12 13:23:02 +01001925/*
1926 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001927 * character. The input <string> must be zero-terminated. The result will
1928 * be stored between <start> (included) and <stop> (excluded). This
1929 * function will always try to terminate the resulting string with a '\0'
1930 * before <stop>, and will return its position if the conversion
1931 * completes.
1932 */
1933char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001934 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001935 const char *string)
1936{
1937 if (start < stop) {
1938 stop--; /* reserve one byte for the final '\0' */
1939 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001940 if (!ha_bit_test((unsigned char)(*string), map))
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001941 *start++ = *string;
1942 else {
1943 if (start + 2 >= stop)
1944 break;
1945 *start++ = escape;
1946 *start++ = *string;
1947 }
1948 string++;
1949 }
1950 *start = '\0';
1951 }
1952 return start;
1953}
1954
1955/*
1956 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +01001957 * character. <chunk> contains the input to be escaped. The result will be
1958 * stored between <start> (included) and <stop> (excluded). The function
1959 * will always try to terminate the resulting string with a '\0' before
1960 * <stop>, and will return its position if the conversion completes.
1961 */
1962char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001963 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001964 const struct buffer *chunk)
Dragan Dosen0edd1092016-02-12 13:23:02 +01001965{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001966 char *str = chunk->area;
1967 char *end = chunk->area + chunk->data;
Dragan Dosen0edd1092016-02-12 13:23:02 +01001968
1969 if (start < stop) {
1970 stop--; /* reserve one byte for the final '\0' */
1971 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001972 if (!ha_bit_test((unsigned char)(*str), map))
Dragan Dosen0edd1092016-02-12 13:23:02 +01001973 *start++ = *str;
1974 else {
1975 if (start + 2 >= stop)
1976 break;
1977 *start++ = escape;
1978 *start++ = *str;
1979 }
1980 str++;
1981 }
1982 *start = '\0';
1983 }
1984 return start;
1985}
1986
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001987/* Check a string for using it in a CSV output format. If the string contains
1988 * one of the following four char <">, <,>, CR or LF, the string is
1989 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
1990 * <str> is the input string to be escaped. The function assumes that
1991 * the input string is null-terminated.
1992 *
1993 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +01001994 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001995 * format.
1996 *
Willy Tarreau898529b2016-01-06 18:07:04 +01001997 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +02001998 *
Willy Tarreaub631c292016-01-08 10:04:08 +01001999 * If <quote> is 1, the converter puts the quotes only if any reserved character
2000 * is present. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002001 *
Willy Tarreau83061a82018-07-13 11:56:34 +02002002 * <output> is a struct buffer used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002003 *
Willy Tarreau898529b2016-01-06 18:07:04 +01002004 * The function returns the converted string on its output. If an error
2005 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002006 * for using the function directly as printf() argument.
2007 *
2008 * If the output buffer is too short to contain the input string, the result
2009 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +01002010 *
Willy Tarreaub631c292016-01-08 10:04:08 +01002011 * This function appends the encoding to the existing output chunk, and it
2012 * guarantees that it starts immediately at the first available character of
2013 * the chunk. Please use csv_enc() instead if you want to replace the output
2014 * chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002015 */
Willy Tarreau83061a82018-07-13 11:56:34 +02002016const char *csv_enc_append(const char *str, int quote, struct buffer *output)
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002017{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002018 char *end = output->area + output->size;
2019 char *out = output->area + output->data;
Willy Tarreau898529b2016-01-06 18:07:04 +01002020 char *ptr = out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002021
Willy Tarreaub631c292016-01-08 10:04:08 +01002022 if (quote == 1) {
2023 /* automatic quoting: first verify if we'll have to quote the string */
2024 if (!strpbrk(str, "\n\r,\""))
2025 quote = 0;
2026 }
2027
2028 if (quote)
2029 *ptr++ = '"';
2030
Willy Tarreau898529b2016-01-06 18:07:04 +01002031 while (*str && ptr < end - 2) { /* -2 for reserving space for <"> and \0. */
2032 *ptr = *str;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002033 if (*str == '"') {
Willy Tarreau898529b2016-01-06 18:07:04 +01002034 ptr++;
2035 if (ptr >= end - 2) {
2036 ptr--;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002037 break;
2038 }
Willy Tarreau898529b2016-01-06 18:07:04 +01002039 *ptr = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002040 }
Willy Tarreau898529b2016-01-06 18:07:04 +01002041 ptr++;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002042 str++;
2043 }
2044
Willy Tarreaub631c292016-01-08 10:04:08 +01002045 if (quote)
2046 *ptr++ = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002047
Willy Tarreau898529b2016-01-06 18:07:04 +01002048 *ptr = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002049 output->data = ptr - output->area;
Willy Tarreau898529b2016-01-06 18:07:04 +01002050 return out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002051}
2052
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002053/* Decode an URL-encoded string in-place. The resulting string might
2054 * be shorter. If some forbidden characters are found, the conversion is
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002055 * aborted, the string is truncated before the issue and a negative value is
2056 * returned, otherwise the operation returns the length of the decoded string.
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002057 * If the 'in_form' argument is non-nul the string is assumed to be part of
2058 * an "application/x-www-form-urlencoded" encoded string, and the '+' will be
2059 * turned to a space. If it's zero, this will only be done after a question
2060 * mark ('?').
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002061 */
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002062int url_decode(char *string, int in_form)
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002063{
2064 char *in, *out;
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002065 int ret = -1;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002066
2067 in = string;
2068 out = string;
2069 while (*in) {
2070 switch (*in) {
2071 case '+' :
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002072 *out++ = in_form ? ' ' : *in;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002073 break;
2074 case '%' :
2075 if (!ishex(in[1]) || !ishex(in[2]))
2076 goto end;
2077 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
2078 in += 2;
2079 break;
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002080 case '?':
2081 in_form = 1;
2082 /* fall through */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002083 default:
2084 *out++ = *in;
2085 break;
2086 }
2087 in++;
2088 }
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002089 ret = out - string; /* success */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002090 end:
2091 *out = 0;
2092 return ret;
2093}
Willy Tarreaubaaee002006-06-26 02:48:02 +02002094
Willy Tarreau6911fa42007-03-04 18:06:08 +01002095unsigned int str2ui(const char *s)
2096{
2097 return __str2ui(s);
2098}
2099
2100unsigned int str2uic(const char *s)
2101{
2102 return __str2uic(s);
2103}
2104
2105unsigned int strl2ui(const char *s, int len)
2106{
2107 return __strl2ui(s, len);
2108}
2109
2110unsigned int strl2uic(const char *s, int len)
2111{
2112 return __strl2uic(s, len);
2113}
2114
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02002115unsigned int read_uint(const char **s, const char *end)
2116{
2117 return __read_uint(s, end);
2118}
2119
Thierry FOURNIER763a5d82015-07-06 23:09:52 +02002120/* This function reads an unsigned integer from the string pointed to by <s> and
2121 * returns it. The <s> pointer is adjusted to point to the first unread char. The
2122 * function automatically stops at <end>. If the number overflows, the 2^64-1
2123 * value is returned.
2124 */
2125unsigned long long int read_uint64(const char **s, const char *end)
2126{
2127 const char *ptr = *s;
2128 unsigned long long int i = 0, tmp;
2129 unsigned int j;
2130
2131 while (ptr < end) {
2132
2133 /* read next char */
2134 j = *ptr - '0';
2135 if (j > 9)
2136 goto read_uint64_end;
2137
2138 /* add char to the number and check overflow. */
2139 tmp = i * 10;
2140 if (tmp / 10 != i) {
2141 i = ULLONG_MAX;
2142 goto read_uint64_eat;
2143 }
2144 if (ULLONG_MAX - tmp < j) {
2145 i = ULLONG_MAX;
2146 goto read_uint64_eat;
2147 }
2148 i = tmp + j;
2149 ptr++;
2150 }
2151read_uint64_eat:
2152 /* eat each numeric char */
2153 while (ptr < end) {
2154 if ((unsigned int)(*ptr - '0') > 9)
2155 break;
2156 ptr++;
2157 }
2158read_uint64_end:
2159 *s = ptr;
2160 return i;
2161}
2162
2163/* This function reads an integer from the string pointed to by <s> and returns
2164 * it. The <s> pointer is adjusted to point to the first unread char. The function
2165 * automatically stops at <end>. Il the number is bigger than 2^63-2, the 2^63-1
2166 * value is returned. If the number is lowest than -2^63-1, the -2^63 value is
2167 * returned.
2168 */
2169long long int read_int64(const char **s, const char *end)
2170{
2171 unsigned long long int i = 0;
2172 int neg = 0;
2173
2174 /* Look for minus char. */
2175 if (**s == '-') {
2176 neg = 1;
2177 (*s)++;
2178 }
2179 else if (**s == '+')
2180 (*s)++;
2181
2182 /* convert as positive number. */
2183 i = read_uint64(s, end);
2184
2185 if (neg) {
2186 if (i > 0x8000000000000000ULL)
2187 return LLONG_MIN;
2188 return -i;
2189 }
2190 if (i > 0x7fffffffffffffffULL)
2191 return LLONG_MAX;
2192 return i;
2193}
2194
Willy Tarreau6911fa42007-03-04 18:06:08 +01002195/* This one is 7 times faster than strtol() on athlon with checks.
2196 * It returns the value of the number composed of all valid digits read,
2197 * and can process negative numbers too.
2198 */
2199int strl2ic(const char *s, int len)
2200{
2201 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002202 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002203
2204 if (len > 0) {
2205 if (*s != '-') {
2206 /* positive number */
2207 while (len-- > 0) {
2208 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002209 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002210 if (j > 9)
2211 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002212 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002213 }
2214 } else {
2215 /* negative number */
2216 s++;
2217 while (--len > 0) {
2218 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002219 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002220 if (j > 9)
2221 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002222 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002223 }
2224 }
2225 }
2226 return i;
2227}
2228
2229
2230/* This function reads exactly <len> chars from <s> and converts them to a
2231 * signed integer which it stores into <ret>. It accurately detects any error
2232 * (truncated string, invalid chars, overflows). It is meant to be used in
2233 * applications designed for hostile environments. It returns zero when the
2234 * number has successfully been converted, non-zero otherwise. When an error
2235 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
2236 * faster than strtol().
2237 */
2238int strl2irc(const char *s, int len, int *ret)
2239{
2240 int i = 0;
2241 int j;
2242
2243 if (!len)
2244 return 1;
2245
2246 if (*s != '-') {
2247 /* positive number */
2248 while (len-- > 0) {
2249 j = (*s++) - '0';
2250 if (j > 9) return 1; /* invalid char */
2251 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
2252 i = i * 10;
2253 if (i + j < i) return 1; /* check for addition overflow */
2254 i = i + j;
2255 }
2256 } else {
2257 /* negative number */
2258 s++;
2259 while (--len > 0) {
2260 j = (*s++) - '0';
2261 if (j > 9) return 1; /* invalid char */
2262 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
2263 i = i * 10;
2264 if (i - j > i) return 1; /* check for subtract overflow */
2265 i = i - j;
2266 }
2267 }
2268 *ret = i;
2269 return 0;
2270}
2271
2272
2273/* This function reads exactly <len> chars from <s> and converts them to a
2274 * signed integer which it stores into <ret>. It accurately detects any error
2275 * (truncated string, invalid chars, overflows). It is meant to be used in
2276 * applications designed for hostile environments. It returns zero when the
2277 * number has successfully been converted, non-zero otherwise. When an error
2278 * is returned, the <ret> value is left untouched. It is about 3 times slower
William Dauchy060ffc82021-02-06 20:47:51 +01002279 * than strl2irc().
Willy Tarreau6911fa42007-03-04 18:06:08 +01002280 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01002281
2282int strl2llrc(const char *s, int len, long long *ret)
2283{
2284 long long i = 0;
2285 int j;
2286
2287 if (!len)
2288 return 1;
2289
2290 if (*s != '-') {
2291 /* positive number */
2292 while (len-- > 0) {
2293 j = (*s++) - '0';
2294 if (j > 9) return 1; /* invalid char */
2295 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
2296 i = i * 10LL;
2297 if (i + j < i) return 1; /* check for addition overflow */
2298 i = i + j;
2299 }
2300 } else {
2301 /* negative number */
2302 s++;
2303 while (--len > 0) {
2304 j = (*s++) - '0';
2305 if (j > 9) return 1; /* invalid char */
2306 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
2307 i = i * 10LL;
2308 if (i - j > i) return 1; /* check for subtract overflow */
2309 i = i - j;
2310 }
2311 }
2312 *ret = i;
2313 return 0;
2314}
2315
Thierry FOURNIER511e9472014-01-23 17:40:34 +01002316/* This function is used with pat_parse_dotted_ver(). It converts a string
2317 * composed by two number separated by a dot. Each part must contain in 16 bits
2318 * because internally they will be represented as a 32-bit quantity stored in
2319 * a 64-bit integer. It returns zero when the number has successfully been
2320 * converted, non-zero otherwise. When an error is returned, the <ret> value
2321 * is left untouched.
2322 *
2323 * "1.3" -> 0x0000000000010003
2324 * "65535.65535" -> 0x00000000ffffffff
2325 */
2326int strl2llrc_dotted(const char *text, int len, long long *ret)
2327{
2328 const char *end = &text[len];
2329 const char *p;
2330 long long major, minor;
2331
2332 /* Look for dot. */
2333 for (p = text; p < end; p++)
2334 if (*p == '.')
2335 break;
2336
2337 /* Convert major. */
2338 if (strl2llrc(text, p - text, &major) != 0)
2339 return 1;
2340
2341 /* Check major. */
2342 if (major >= 65536)
2343 return 1;
2344
2345 /* Convert minor. */
2346 minor = 0;
2347 if (p < end)
2348 if (strl2llrc(p + 1, end - (p + 1), &minor) != 0)
2349 return 1;
2350
2351 /* Check minor. */
2352 if (minor >= 65536)
2353 return 1;
2354
2355 /* Compose value. */
2356 *ret = (major << 16) | (minor & 0xffff);
2357 return 0;
2358}
2359
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002360/* This function parses a time value optionally followed by a unit suffix among
2361 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
2362 * expected by the caller. The computation does its best to avoid overflows.
2363 * The value is returned in <ret> if everything is fine, and a NULL is returned
2364 * by the function. In case of error, a pointer to the error is returned and
2365 * <ret> is left untouched. Values are automatically rounded up when needed.
Willy Tarreau9faebe32019-06-07 19:00:37 +02002366 * Values resulting in values larger than or equal to 2^31 after conversion are
2367 * reported as an overflow as value PARSE_TIME_OVER. Non-null values resulting
2368 * in an underflow are reported as an underflow as value PARSE_TIME_UNDER.
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002369 */
2370const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
2371{
Willy Tarreau9faebe32019-06-07 19:00:37 +02002372 unsigned long long imult, idiv;
2373 unsigned long long omult, odiv;
2374 unsigned long long value, result;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002375 const char *str = text;
2376
2377 if (!isdigit((unsigned char)*text))
2378 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002379
2380 omult = odiv = 1;
2381
2382 switch (unit_flags & TIME_UNIT_MASK) {
2383 case TIME_UNIT_US: omult = 1000000; break;
2384 case TIME_UNIT_MS: omult = 1000; break;
2385 case TIME_UNIT_S: break;
2386 case TIME_UNIT_MIN: odiv = 60; break;
2387 case TIME_UNIT_HOUR: odiv = 3600; break;
2388 case TIME_UNIT_DAY: odiv = 86400; break;
2389 default: break;
2390 }
2391
2392 value = 0;
2393
2394 while (1) {
2395 unsigned int j;
2396
2397 j = *text - '0';
2398 if (j > 9)
2399 break;
2400 text++;
2401 value *= 10;
2402 value += j;
2403 }
2404
2405 imult = idiv = 1;
2406 switch (*text) {
2407 case '\0': /* no unit = default unit */
2408 imult = omult = idiv = odiv = 1;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002409 goto end;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002410 case 's': /* second = unscaled unit */
2411 break;
2412 case 'u': /* microsecond : "us" */
2413 if (text[1] == 's') {
2414 idiv = 1000000;
2415 text++;
Thayne McCombsa6838052021-04-02 14:12:43 -06002416 break;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002417 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002418 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002419 case 'm': /* millisecond : "ms" or minute: "m" */
2420 if (text[1] == 's') {
2421 idiv = 1000;
2422 text++;
2423 } else
2424 imult = 60;
2425 break;
2426 case 'h': /* hour : "h" */
2427 imult = 3600;
2428 break;
2429 case 'd': /* day : "d" */
2430 imult = 86400;
2431 break;
2432 default:
2433 return text;
2434 break;
2435 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002436 if (*(++text) != '\0') {
2437 ha_warning("unexpected character '%c' after the timer value '%s', only "
2438 "(us=microseconds,ms=milliseconds,s=seconds,m=minutes,h=hours,d=days) are supported."
2439 " This will be reported as an error in next versions.\n", *text, str);
2440 }
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002441
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002442 end:
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002443 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
2444 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
2445 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
2446 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
2447
Willy Tarreau9faebe32019-06-07 19:00:37 +02002448 result = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
2449 if (result >= 0x80000000)
2450 return PARSE_TIME_OVER;
2451 if (!result && value)
2452 return PARSE_TIME_UNDER;
2453 *ret = result;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002454 return NULL;
2455}
Willy Tarreau6911fa42007-03-04 18:06:08 +01002456
Emeric Brun39132b22010-01-04 14:57:24 +01002457/* this function converts the string starting at <text> to an unsigned int
2458 * stored in <ret>. If an error is detected, the pointer to the unexpected
Joseph Herlant32b83272018-11-15 11:58:28 -08002459 * character is returned. If the conversion is successful, NULL is returned.
Emeric Brun39132b22010-01-04 14:57:24 +01002460 */
2461const char *parse_size_err(const char *text, unsigned *ret) {
2462 unsigned value = 0;
2463
Christopher Faulet82635a02020-12-11 09:30:45 +01002464 if (!isdigit((unsigned char)*text))
2465 return text;
2466
Emeric Brun39132b22010-01-04 14:57:24 +01002467 while (1) {
2468 unsigned int j;
2469
2470 j = *text - '0';
2471 if (j > 9)
2472 break;
2473 if (value > ~0U / 10)
2474 return text;
2475 value *= 10;
2476 if (value > (value + j))
2477 return text;
2478 value += j;
2479 text++;
2480 }
2481
2482 switch (*text) {
2483 case '\0':
2484 break;
2485 case 'K':
2486 case 'k':
2487 if (value > ~0U >> 10)
2488 return text;
2489 value = value << 10;
2490 break;
2491 case 'M':
2492 case 'm':
2493 if (value > ~0U >> 20)
2494 return text;
2495 value = value << 20;
2496 break;
2497 case 'G':
2498 case 'g':
2499 if (value > ~0U >> 30)
2500 return text;
2501 value = value << 30;
2502 break;
2503 default:
2504 return text;
2505 }
2506
Godbach58048a22015-01-28 17:36:16 +08002507 if (*text != '\0' && *++text != '\0')
2508 return text;
2509
Emeric Brun39132b22010-01-04 14:57:24 +01002510 *ret = value;
2511 return NULL;
2512}
2513
Willy Tarreau126d4062013-12-03 17:50:47 +01002514/*
2515 * Parse binary string written in hexadecimal (source) and store the decoded
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002516 * result into binstr and set binstrlen to the length of binstr. Memory for
Willy Tarreau126d4062013-12-03 17:50:47 +01002517 * binstr is allocated by the function. In case of error, returns 0 with an
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002518 * error message in err. In success case, it returns the consumed length.
Willy Tarreau126d4062013-12-03 17:50:47 +01002519 */
2520int parse_binary(const char *source, char **binstr, int *binstrlen, char **err)
2521{
2522 int len;
2523 const char *p = source;
2524 int i,j;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002525 int alloc;
Willy Tarreau126d4062013-12-03 17:50:47 +01002526
2527 len = strlen(source);
2528 if (len % 2) {
2529 memprintf(err, "an even number of hex digit is expected");
2530 return 0;
2531 }
2532
2533 len = len >> 1;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002534
Willy Tarreau126d4062013-12-03 17:50:47 +01002535 if (!*binstr) {
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02002536 *binstr = calloc(len, sizeof(**binstr));
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002537 if (!*binstr) {
2538 memprintf(err, "out of memory while loading string pattern");
2539 return 0;
2540 }
2541 alloc = 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002542 }
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002543 else {
2544 if (*binstrlen < len) {
Joseph Herlant76dbe782018-11-15 12:01:22 -08002545 memprintf(err, "no space available in the buffer. expect %d, provides %d",
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002546 len, *binstrlen);
2547 return 0;
2548 }
2549 alloc = 0;
2550 }
2551 *binstrlen = len;
Willy Tarreau126d4062013-12-03 17:50:47 +01002552
2553 i = j = 0;
2554 while (j < len) {
2555 if (!ishex(p[i++]))
2556 goto bad_input;
2557 if (!ishex(p[i++]))
2558 goto bad_input;
2559 (*binstr)[j++] = (hex2i(p[i-2]) << 4) + hex2i(p[i-1]);
2560 }
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002561 return len << 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002562
2563bad_input:
2564 memprintf(err, "an hex digit is expected (found '%c')", p[i-1]);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002565 if (alloc)
2566 ha_free(binstr);
Willy Tarreau126d4062013-12-03 17:50:47 +01002567 return 0;
2568}
2569
Willy Tarreau946ba592009-05-10 15:41:18 +02002570/* copies at most <n> characters from <src> and always terminates with '\0' */
2571char *my_strndup(const char *src, int n)
2572{
2573 int len = 0;
2574 char *ret;
2575
2576 while (len < n && src[len])
2577 len++;
2578
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002579 ret = malloc(len + 1);
Willy Tarreau946ba592009-05-10 15:41:18 +02002580 if (!ret)
2581 return ret;
2582 memcpy(ret, src, len);
2583 ret[len] = '\0';
2584 return ret;
2585}
2586
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02002587/*
2588 * search needle in haystack
2589 * returns the pointer if found, returns NULL otherwise
2590 */
2591const void *my_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
2592{
2593 const void *c = NULL;
2594 unsigned char f;
2595
2596 if ((haystack == NULL) || (needle == NULL) || (haystacklen < needlelen))
2597 return NULL;
2598
2599 f = *(char *)needle;
2600 c = haystack;
2601 while ((c = memchr(c, f, haystacklen - (c - haystack))) != NULL) {
2602 if ((haystacklen - (c - haystack)) < needlelen)
2603 return NULL;
2604
2605 if (memcmp(c, needle, needlelen) == 0)
2606 return c;
2607 ++c;
2608 }
2609 return NULL;
2610}
2611
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002612/* get length of the initial segment consisting entirely of bytes in <accept> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002613size_t my_memspn(const void *str, size_t len, const void *accept, size_t acceptlen)
2614{
2615 size_t ret = 0;
2616
2617 while (ret < len && memchr(accept, *((int *)str), acceptlen)) {
2618 str++;
2619 ret++;
2620 }
2621 return ret;
2622}
2623
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002624/* get length of the initial segment consisting entirely of bytes not in <rejcet> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002625size_t my_memcspn(const void *str, size_t len, const void *reject, size_t rejectlen)
2626{
2627 size_t ret = 0;
2628
2629 while (ret < len) {
2630 if(memchr(reject, *((int *)str), rejectlen))
2631 return ret;
2632 str++;
2633 ret++;
2634 }
2635 return ret;
2636}
2637
Willy Tarreau482b00d2009-10-04 22:48:42 +02002638/* This function returns the first unused key greater than or equal to <key> in
2639 * ID tree <root>. Zero is returned if no place is found.
2640 */
2641unsigned int get_next_id(struct eb_root *root, unsigned int key)
2642{
2643 struct eb32_node *used;
2644
2645 do {
2646 used = eb32_lookup_ge(root, key);
2647 if (!used || used->key > key)
2648 return key; /* key is available */
2649 key++;
2650 } while (key);
2651 return key;
2652}
2653
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002654/* dump the full tree to <file> in DOT format for debugging purposes. Will
2655 * optionally highlight node <subj> if found, depending on operation <op> :
2656 * 0 : nothing
2657 * >0 : insertion, node/leaf are surrounded in red
2658 * <0 : removal, node/leaf are dashed with no background
2659 * Will optionally add "desc" as a label on the graph if set and non-null.
2660 */
2661void 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 +01002662{
2663 struct eb32sc_node *node;
2664 unsigned long scope = -1;
2665
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002666 fprintf(file, "digraph ebtree {\n");
2667
2668 if (desc && *desc) {
2669 fprintf(file,
2670 " fontname=\"fixed\";\n"
2671 " fontsize=8;\n"
2672 " label=\"%s\";\n", desc);
2673 }
2674
Willy Tarreaued3cda02017-11-15 15:04:05 +01002675 fprintf(file,
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002676 " node [fontname=\"fixed\" fontsize=8 shape=\"box\" style=\"filled\" color=\"black\" fillcolor=\"white\"];\n"
2677 " edge [fontname=\"fixed\" fontsize=8 style=\"solid\" color=\"magenta\" dir=\"forward\"];\n"
Willy Tarreaued3cda02017-11-15 15:04:05 +01002678 " \"%lx_n\" [label=\"root\\n%lx\"]\n", (long)eb_root_to_node(root), (long)root
2679 );
2680
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002681 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002682 (long)eb_root_to_node(root),
2683 (long)eb_root_to_node(eb_clrtag(root->b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002684 eb_gettag(root->b[0]) == EB_LEAF ? 'l' : 'n');
2685
2686 node = eb32sc_first(root, scope);
2687 while (node) {
2688 if (node->node.node_p) {
2689 /* node part is used */
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002690 fprintf(file, " \"%lx_n\" [label=\"%lx\\nkey=%u\\nscope=%lx\\nbit=%d\" fillcolor=\"lightskyblue1\" %s];\n",
2691 (long)node, (long)node, node->key, node->node_s, node->node.bit,
2692 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002693
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002694 fprintf(file, " \"%lx_n\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002695 (long)node,
2696 (long)eb_root_to_node(eb_clrtag(node->node.node_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002697 eb_gettag(node->node.node_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002698
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002699 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002700 (long)node,
2701 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002702 eb_gettag(node->node.branches.b[0]) == EB_LEAF ? 'l' : 'n');
2703
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002704 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"R\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002705 (long)node,
2706 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[1])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002707 eb_gettag(node->node.branches.b[1]) == EB_LEAF ? 'l' : 'n');
2708 }
2709
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002710 fprintf(file, " \"%lx_l\" [label=\"%lx\\nkey=%u\\nscope=%lx\\npfx=%u\" fillcolor=\"yellow\" %s];\n",
2711 (long)node, (long)node, node->key, node->leaf_s, node->node.pfx,
2712 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002713
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002714 fprintf(file, " \"%lx_l\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002715 (long)node,
2716 (long)eb_root_to_node(eb_clrtag(node->node.leaf_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002717 eb_gettag(node->node.leaf_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002718 node = eb32sc_next(node, scope);
2719 }
2720 fprintf(file, "}\n");
2721}
2722
Willy Tarreau348238b2010-01-18 15:05:57 +01002723/* This function compares a sample word possibly followed by blanks to another
2724 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
2725 * otherwise zero. This intends to be used when checking HTTP headers for some
2726 * values. Note that it validates a word followed only by blanks but does not
2727 * validate a word followed by blanks then other chars.
2728 */
2729int word_match(const char *sample, int slen, const char *word, int wlen)
2730{
2731 if (slen < wlen)
2732 return 0;
2733
2734 while (wlen) {
2735 char c = *sample ^ *word;
2736 if (c && c != ('A' ^ 'a'))
2737 return 0;
2738 sample++;
2739 word++;
2740 slen--;
2741 wlen--;
2742 }
2743
2744 while (slen) {
2745 if (*sample != ' ' && *sample != '\t')
2746 return 0;
2747 sample++;
2748 slen--;
2749 }
2750 return 1;
2751}
Willy Tarreau482b00d2009-10-04 22:48:42 +02002752
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002753/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
2754 * is particularly fast because it avoids expensive operations such as
2755 * multiplies, which are optimized away at the end. It requires a properly
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002756 * formatted address though (3 points).
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002757 */
2758unsigned int inetaddr_host(const char *text)
2759{
2760 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2761 register unsigned int dig100, dig10, dig1;
2762 int s;
2763 const char *p, *d;
2764
2765 dig1 = dig10 = dig100 = ascii_zero;
2766 s = 24;
2767
2768 p = text;
2769 while (1) {
2770 if (((unsigned)(*p - '0')) <= 9) {
2771 p++;
2772 continue;
2773 }
2774
2775 /* here, we have a complete byte between <text> and <p> (exclusive) */
2776 if (p == text)
2777 goto end;
2778
2779 d = p - 1;
2780 dig1 |= (unsigned int)(*d << s);
2781 if (d == text)
2782 goto end;
2783
2784 d--;
2785 dig10 |= (unsigned int)(*d << s);
2786 if (d == text)
2787 goto end;
2788
2789 d--;
2790 dig100 |= (unsigned int)(*d << s);
2791 end:
2792 if (!s || *p != '.')
2793 break;
2794
2795 s -= 8;
2796 text = ++p;
2797 }
2798
2799 dig100 -= ascii_zero;
2800 dig10 -= ascii_zero;
2801 dig1 -= ascii_zero;
2802 return ((dig100 * 10) + dig10) * 10 + dig1;
2803}
2804
2805/*
2806 * Idem except the first unparsed character has to be passed in <stop>.
2807 */
2808unsigned int inetaddr_host_lim(const char *text, const char *stop)
2809{
2810 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2811 register unsigned int dig100, dig10, dig1;
2812 int s;
2813 const char *p, *d;
2814
2815 dig1 = dig10 = dig100 = ascii_zero;
2816 s = 24;
2817
2818 p = text;
2819 while (1) {
2820 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2821 p++;
2822 continue;
2823 }
2824
2825 /* here, we have a complete byte between <text> and <p> (exclusive) */
2826 if (p == text)
2827 goto end;
2828
2829 d = p - 1;
2830 dig1 |= (unsigned int)(*d << s);
2831 if (d == text)
2832 goto end;
2833
2834 d--;
2835 dig10 |= (unsigned int)(*d << s);
2836 if (d == text)
2837 goto end;
2838
2839 d--;
2840 dig100 |= (unsigned int)(*d << s);
2841 end:
2842 if (!s || p == stop || *p != '.')
2843 break;
2844
2845 s -= 8;
2846 text = ++p;
2847 }
2848
2849 dig100 -= ascii_zero;
2850 dig10 -= ascii_zero;
2851 dig1 -= ascii_zero;
2852 return ((dig100 * 10) + dig10) * 10 + dig1;
2853}
2854
2855/*
2856 * Idem except the pointer to first unparsed byte is returned into <ret> which
2857 * must not be NULL.
2858 */
Willy Tarreau74172752010-10-15 23:21:42 +02002859unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002860{
2861 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2862 register unsigned int dig100, dig10, dig1;
2863 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02002864 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002865
2866 dig1 = dig10 = dig100 = ascii_zero;
2867 s = 24;
2868
2869 p = text;
2870 while (1) {
2871 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2872 p++;
2873 continue;
2874 }
2875
2876 /* here, we have a complete byte between <text> and <p> (exclusive) */
2877 if (p == text)
2878 goto end;
2879
2880 d = p - 1;
2881 dig1 |= (unsigned int)(*d << s);
2882 if (d == text)
2883 goto end;
2884
2885 d--;
2886 dig10 |= (unsigned int)(*d << s);
2887 if (d == text)
2888 goto end;
2889
2890 d--;
2891 dig100 |= (unsigned int)(*d << s);
2892 end:
2893 if (!s || p == stop || *p != '.')
2894 break;
2895
2896 s -= 8;
2897 text = ++p;
2898 }
2899
2900 *ret = p;
2901 dig100 -= ascii_zero;
2902 dig10 -= ascii_zero;
2903 dig1 -= ascii_zero;
2904 return ((dig100 * 10) + dig10) * 10 + dig1;
2905}
2906
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002907/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
2908 * or the number of chars read in case of success. Maybe this could be replaced
2909 * by one of the functions above. Also, apparently this function does not support
2910 * hosts above 255 and requires exactly 4 octets.
Willy Tarreau075415a2013-12-12 11:29:39 +01002911 * The destination is only modified on success.
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002912 */
2913int buf2ip(const char *buf, size_t len, struct in_addr *dst)
2914{
2915 const char *addr;
2916 int saw_digit, octets, ch;
2917 u_char tmp[4], *tp;
2918 const char *cp = buf;
2919
2920 saw_digit = 0;
2921 octets = 0;
2922 *(tp = tmp) = 0;
2923
2924 for (addr = buf; addr - buf < len; addr++) {
2925 unsigned char digit = (ch = *addr) - '0';
2926
2927 if (digit > 9 && ch != '.')
2928 break;
2929
2930 if (digit <= 9) {
2931 u_int new = *tp * 10 + digit;
2932
2933 if (new > 255)
2934 return 0;
2935
2936 *tp = new;
2937
2938 if (!saw_digit) {
2939 if (++octets > 4)
2940 return 0;
2941 saw_digit = 1;
2942 }
2943 } else if (ch == '.' && saw_digit) {
2944 if (octets == 4)
2945 return 0;
2946
2947 *++tp = 0;
2948 saw_digit = 0;
2949 } else
2950 return 0;
2951 }
2952
2953 if (octets < 4)
2954 return 0;
2955
2956 memcpy(&dst->s_addr, tmp, 4);
2957 return addr - cp;
2958}
2959
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002960/* This function converts the string in <buf> of the len <len> to
2961 * struct in6_addr <dst> which must be allocated by the caller.
2962 * This function returns 1 in success case, otherwise zero.
Willy Tarreau075415a2013-12-12 11:29:39 +01002963 * The destination is only modified on success.
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002964 */
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002965int buf2ip6(const char *buf, size_t len, struct in6_addr *dst)
2966{
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002967 char null_term_ip6[INET6_ADDRSTRLEN + 1];
Willy Tarreau075415a2013-12-12 11:29:39 +01002968 struct in6_addr out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002969
Thierry FOURNIERcd659912013-12-11 12:33:54 +01002970 if (len > INET6_ADDRSTRLEN)
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002971 return 0;
2972
2973 memcpy(null_term_ip6, buf, len);
2974 null_term_ip6[len] = '\0';
2975
Willy Tarreau075415a2013-12-12 11:29:39 +01002976 if (!inet_pton(AF_INET6, null_term_ip6, &out))
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002977 return 0;
2978
Willy Tarreau075415a2013-12-12 11:29:39 +01002979 *dst = out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002980 return 1;
2981}
2982
Willy Tarreauacf95772010-06-14 19:09:21 +02002983/* To be used to quote config arg positions. Returns the short string at <ptr>
2984 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
2985 * if ptr is NULL or empty. The string is locally allocated.
2986 */
2987const char *quote_arg(const char *ptr)
2988{
Christopher Faulet1bc04c72017-10-29 20:14:08 +01002989 static THREAD_LOCAL char val[32];
Willy Tarreauacf95772010-06-14 19:09:21 +02002990 int i;
2991
2992 if (!ptr || !*ptr)
2993 return "end of line";
2994 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01002995 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02002996 val[i] = *ptr++;
2997 val[i++] = '\'';
2998 val[i] = '\0';
2999 return val;
3000}
3001
Willy Tarreau5b180202010-07-18 10:40:48 +02003002/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
3003int get_std_op(const char *str)
3004{
3005 int ret = -1;
3006
3007 if (*str == 'e' && str[1] == 'q')
3008 ret = STD_OP_EQ;
3009 else if (*str == 'n' && str[1] == 'e')
3010 ret = STD_OP_NE;
3011 else if (*str == 'l') {
3012 if (str[1] == 'e') ret = STD_OP_LE;
3013 else if (str[1] == 't') ret = STD_OP_LT;
3014 }
3015 else if (*str == 'g') {
3016 if (str[1] == 'e') ret = STD_OP_GE;
3017 else if (str[1] == 't') ret = STD_OP_GT;
3018 }
3019
3020 if (ret == -1 || str[2] != '\0')
3021 return -1;
3022 return ret;
3023}
3024
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01003025/* hash a 32-bit integer to another 32-bit integer */
3026unsigned int full_hash(unsigned int a)
3027{
3028 return __full_hash(a);
3029}
3030
Willy Tarreauf3241112019-02-26 09:56:22 +01003031/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
3032 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
3033 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
3034 * a popcount variant and is described here :
3035 * https://graphics.stanford.edu/~seander/bithacks.html
3036 */
3037unsigned int mask_find_rank_bit(unsigned int r, unsigned long m)
3038{
3039 unsigned long a, b, c, d;
3040 unsigned int s;
3041 unsigned int t;
3042
3043 a = m - ((m >> 1) & ~0UL/3);
3044 b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
3045 c = (b + (b >> 4)) & ~0UL/0x11;
3046 d = (c + (c >> 8)) & ~0UL/0x101;
3047
3048 r++; // make r be 1..64
3049
3050 t = 0;
3051 s = LONGBITS;
3052 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01003053 unsigned long d2 = (d >> 16) >> 16;
3054 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01003055 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
3056 }
3057
3058 t = (d >> (s - 16)) & 0xff;
3059 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
3060 t = (c >> (s - 8)) & 0xf;
3061 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
3062 t = (b >> (s - 4)) & 0x7;
3063 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
3064 t = (a >> (s - 2)) & 0x3;
3065 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
3066 t = (m >> (s - 1)) & 0x1;
3067 s -= ((t - r) & 256) >> 8;
3068
3069 return s - 1;
3070}
3071
3072/* Same as mask_find_rank_bit() above but makes use of pre-computed bitmaps
3073 * based on <m>, in <a..d>. These ones must be updated whenever <m> changes
3074 * using mask_prep_rank_map() below.
3075 */
3076unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
3077 unsigned long a, unsigned long b,
3078 unsigned long c, unsigned long d)
3079{
3080 unsigned int s;
3081 unsigned int t;
3082
3083 r++; // make r be 1..64
3084
3085 t = 0;
3086 s = LONGBITS;
3087 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01003088 unsigned long d2 = (d >> 16) >> 16;
3089 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01003090 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
3091 }
3092
3093 t = (d >> (s - 16)) & 0xff;
3094 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
3095 t = (c >> (s - 8)) & 0xf;
3096 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
3097 t = (b >> (s - 4)) & 0x7;
3098 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
3099 t = (a >> (s - 2)) & 0x3;
3100 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
3101 t = (m >> (s - 1)) & 0x1;
3102 s -= ((t - r) & 256) >> 8;
3103
3104 return s - 1;
3105}
3106
3107/* Prepare the bitmaps used by the fast implementation of the find_rank_bit()
3108 * above.
3109 */
3110void mask_prep_rank_map(unsigned long m,
3111 unsigned long *a, unsigned long *b,
3112 unsigned long *c, unsigned long *d)
3113{
3114 *a = m - ((m >> 1) & ~0UL/3);
3115 *b = (*a & ~0UL/5) + ((*a >> 2) & ~0UL/5);
3116 *c = (*b + (*b >> 4)) & ~0UL/0x11;
3117 *d = (*c + (*c >> 8)) & ~0UL/0x101;
3118}
3119
David du Colombier4f92d322011-03-24 11:09:31 +01003120/* Return non-zero if IPv4 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003121 * otherwise zero. Note that <addr> may not necessarily be aligned
3122 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003123 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003124int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003125{
Willy Tarreaueec1d382016-07-13 11:59:39 +02003126 struct in_addr addr_copy;
3127
3128 memcpy(&addr_copy, addr, sizeof(addr_copy));
3129 return((addr_copy.s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
David du Colombier4f92d322011-03-24 11:09:31 +01003130}
3131
3132/* Return non-zero if IPv6 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003133 * otherwise zero. Note that <addr> may not necessarily be aligned
3134 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003135 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003136int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003137{
3138 int i;
Willy Tarreaueec1d382016-07-13 11:59:39 +02003139 struct in6_addr addr_copy;
David du Colombier4f92d322011-03-24 11:09:31 +01003140
Willy Tarreaueec1d382016-07-13 11:59:39 +02003141 memcpy(&addr_copy, addr, sizeof(addr_copy));
David du Colombier4f92d322011-03-24 11:09:31 +01003142 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
Willy Tarreaueec1d382016-07-13 11:59:39 +02003143 if (((((int *)&addr_copy)[i] & ((int *)mask)[i])) !=
David du Colombier4f92d322011-03-24 11:09:31 +01003144 (((int *)net)[i] & ((int *)mask)[i]))
3145 return 0;
3146 return 1;
3147}
3148
3149/* RFC 4291 prefix */
3150const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
3151 0x00, 0x00, 0x00, 0x00,
3152 0x00, 0x00, 0xFF, 0xFF };
3153
Joseph Herlant32b83272018-11-15 11:58:28 -08003154/* Map IPv4 address on IPv6 address, as specified in RFC 3513.
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003155 * Input and output may overlap.
3156 */
David du Colombier4f92d322011-03-24 11:09:31 +01003157void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
3158{
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003159 struct in_addr tmp_addr;
3160
3161 tmp_addr.s_addr = sin_addr->s_addr;
David du Colombier4f92d322011-03-24 11:09:31 +01003162 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003163 memcpy(sin6_addr->s6_addr+12, &tmp_addr.s_addr, 4);
David du Colombier4f92d322011-03-24 11:09:31 +01003164}
3165
Joseph Herlant32b83272018-11-15 11:58:28 -08003166/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01003167 * Return true if conversion is possible and false otherwise.
3168 */
3169int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
3170{
3171 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
3172 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
3173 sizeof(struct in_addr));
3174 return 1;
3175 }
3176
3177 return 0;
3178}
3179
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01003180/* compare two struct sockaddr_storage and return:
3181 * 0 (true) if the addr is the same in both
3182 * 1 (false) if the addr is not the same in both
3183 * -1 (unable) if one of the addr is not AF_INET*
3184 */
3185int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2)
3186{
3187 if ((ss1->ss_family != AF_INET) && (ss1->ss_family != AF_INET6))
3188 return -1;
3189
3190 if ((ss2->ss_family != AF_INET) && (ss2->ss_family != AF_INET6))
3191 return -1;
3192
3193 if (ss1->ss_family != ss2->ss_family)
3194 return 1;
3195
3196 switch (ss1->ss_family) {
3197 case AF_INET:
3198 return memcmp(&((struct sockaddr_in *)ss1)->sin_addr,
3199 &((struct sockaddr_in *)ss2)->sin_addr,
3200 sizeof(struct in_addr)) != 0;
3201 case AF_INET6:
3202 return memcmp(&((struct sockaddr_in6 *)ss1)->sin6_addr,
3203 &((struct sockaddr_in6 *)ss2)->sin6_addr,
3204 sizeof(struct in6_addr)) != 0;
3205 }
3206
3207 return 1;
3208}
3209
Christopher Faulet9553de72021-02-26 09:12:50 +01003210/* compare a struct sockaddr_storage to a struct net_addr and return :
3211 * 0 (true) if <addr> is matching <net>
3212 * 1 (false) if <addr> is not matching <net>
3213 * -1 (unable) if <addr> or <net> is not AF_INET*
3214 */
3215int ipcmp2net(const struct sockaddr_storage *addr, const struct net_addr *net)
3216{
3217 if ((addr->ss_family != AF_INET) && (addr->ss_family != AF_INET6))
3218 return -1;
3219
3220 if ((net->family != AF_INET) && (net->family != AF_INET6))
3221 return -1;
3222
3223 if (addr->ss_family != net->family)
3224 return 1;
3225
3226 if (addr->ss_family == AF_INET &&
3227 (((struct sockaddr_in *)addr)->sin_addr.s_addr & net->addr.v4.mask.s_addr) == net->addr.v4.ip.s_addr)
3228 return 0;
3229 else {
3230 const struct in6_addr *addr6 = &(((const struct sockaddr_in6*)addr)->sin6_addr);
3231 const struct in6_addr *nip6 = &net->addr.v6.ip;
3232 const struct in6_addr *nmask6 = &net->addr.v6.mask;
3233
3234 if ((read_u32(&addr6->s6_addr[0]) & read_u32(&nmask6->s6_addr[0])) == read_u32(&nip6->s6_addr[0]) &&
3235 (read_u32(&addr6->s6_addr[4]) & read_u32(&nmask6->s6_addr[4])) == read_u32(&nip6->s6_addr[4]) &&
3236 (read_u32(&addr6->s6_addr[8]) & read_u32(&nmask6->s6_addr[8])) == read_u32(&nip6->s6_addr[8]) &&
3237 (read_u32(&addr6->s6_addr[12]) & read_u32(&nmask6->s6_addr[12])) == read_u32(&nip6->s6_addr[12]))
3238 return 0;
3239 }
3240
3241 return 1;
3242}
3243
Baptiste Assmann08396c82016-01-31 00:27:17 +01003244/* copy IP address from <source> into <dest>
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003245 * The caller must allocate and clear <dest> before calling.
3246 * The source must be in either AF_INET or AF_INET6 family, or the destination
3247 * address will be undefined. If the destination address used to hold a port,
3248 * it is preserved, so that this function can be used to switch to another
3249 * address family with no risk. Returns a pointer to the destination.
Baptiste Assmann08396c82016-01-31 00:27:17 +01003250 */
3251struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest)
3252{
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003253 int prev_port;
3254
3255 prev_port = get_net_port(dest);
3256 memset(dest, 0, sizeof(*dest));
Baptiste Assmann08396c82016-01-31 00:27:17 +01003257 dest->ss_family = source->ss_family;
3258
3259 /* copy new addr and apply it */
3260 switch (source->ss_family) {
3261 case AF_INET:
3262 ((struct sockaddr_in *)dest)->sin_addr.s_addr = ((struct sockaddr_in *)source)->sin_addr.s_addr;
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003263 ((struct sockaddr_in *)dest)->sin_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003264 break;
3265 case AF_INET6:
3266 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 +01003267 ((struct sockaddr_in6 *)dest)->sin6_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003268 break;
3269 }
3270
3271 return dest;
3272}
3273
William Lallemand421f5b52012-02-06 18:15:57 +01003274char *human_time(int t, short hz_div) {
3275 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
3276 char *p = rv;
Willy Tarreau761b3d52014-04-14 14:53:06 +02003277 char *end = rv + sizeof(rv);
William Lallemand421f5b52012-02-06 18:15:57 +01003278 int cnt=2; // print two numbers
3279
3280 if (unlikely(t < 0 || hz_div <= 0)) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003281 snprintf(p, end - p, "?");
William Lallemand421f5b52012-02-06 18:15:57 +01003282 return rv;
3283 }
3284
3285 if (unlikely(hz_div > 1))
3286 t /= hz_div;
3287
3288 if (t >= DAY) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003289 p += snprintf(p, end - p, "%dd", t / DAY);
William Lallemand421f5b52012-02-06 18:15:57 +01003290 cnt--;
3291 }
3292
3293 if (cnt && t % DAY / HOUR) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003294 p += snprintf(p, end - p, "%dh", t % DAY / HOUR);
William Lallemand421f5b52012-02-06 18:15:57 +01003295 cnt--;
3296 }
3297
3298 if (cnt && t % HOUR / MINUTE) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003299 p += snprintf(p, end - p, "%dm", t % HOUR / MINUTE);
William Lallemand421f5b52012-02-06 18:15:57 +01003300 cnt--;
3301 }
3302
3303 if ((cnt && t % MINUTE) || !t) // also display '0s'
Willy Tarreau761b3d52014-04-14 14:53:06 +02003304 p += snprintf(p, end - p, "%ds", t % MINUTE / SEC);
William Lallemand421f5b52012-02-06 18:15:57 +01003305
3306 return rv;
3307}
3308
3309const char *monthname[12] = {
3310 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3311 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
3312};
3313
3314/* date2str_log: write a date in the format :
3315 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
3316 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3317 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
3318 *
3319 * without using sprintf. return a pointer to the last char written (\0) or
3320 * NULL if there isn't enough space.
3321 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02003322char *date2str_log(char *dst, const struct tm *tm, const struct timeval *date, size_t size)
William Lallemand421f5b52012-02-06 18:15:57 +01003323{
3324
3325 if (size < 25) /* the size is fixed: 24 chars + \0 */
3326 return NULL;
3327
3328 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
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 memcpy(dst, monthname[tm->tm_mon], 3); // month
3334 dst += 3;
3335 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003336
William Lallemand421f5b52012-02-06 18:15:57 +01003337 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003338 if (!dst)
3339 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003340 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003341
William Lallemand421f5b52012-02-06 18:15:57 +01003342 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003343 if (!dst)
3344 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003345 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003346
William Lallemand421f5b52012-02-06 18:15:57 +01003347 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003348 if (!dst)
3349 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003350 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003351
William Lallemand421f5b52012-02-06 18:15:57 +01003352 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003353 if (!dst)
3354 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003355 *dst++ = '.';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003356
Willy Tarreau7d9421d2020-02-29 09:08:02 +01003357 dst = utoa_pad((unsigned int)(date->tv_usec/1000)%1000, dst, 4); // milliseconds
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003358 if (!dst)
3359 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003360 *dst = '\0';
3361
3362 return dst;
3363}
3364
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003365/* Base year used to compute leap years */
3366#define TM_YEAR_BASE 1900
3367
3368/* Return the difference in seconds between two times (leap seconds are ignored).
3369 * Retrieved from glibc 2.18 source code.
3370 */
3371static int my_tm_diff(const struct tm *a, const struct tm *b)
3372{
3373 /* Compute intervening leap days correctly even if year is negative.
3374 * Take care to avoid int overflow in leap day calculations,
3375 * but it's OK to assume that A and B are close to each other.
3376 */
3377 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
3378 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
3379 int a100 = a4 / 25 - (a4 % 25 < 0);
3380 int b100 = b4 / 25 - (b4 % 25 < 0);
3381 int a400 = a100 >> 2;
3382 int b400 = b100 >> 2;
3383 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
3384 int years = a->tm_year - b->tm_year;
3385 int days = (365 * years + intervening_leap_days
3386 + (a->tm_yday - b->tm_yday));
3387 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
3388 + (a->tm_min - b->tm_min))
3389 + (a->tm_sec - b->tm_sec));
3390}
3391
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003392/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003393 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003394 * The string returned has the same format as returned by strftime(... "%z", tm).
3395 * Offsets are kept in an internal cache for better performances.
3396 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003397const char *get_gmt_offset(time_t t, struct tm *tm)
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003398{
3399 /* Cache offsets from GMT (depending on whether DST is active or not) */
Christopher Faulet1bc04c72017-10-29 20:14:08 +01003400 static THREAD_LOCAL char gmt_offsets[2][5+1] = { "", "" };
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003401
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003402 char *gmt_offset;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003403 struct tm tm_gmt;
3404 int diff;
3405 int isdst = tm->tm_isdst;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003406
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003407 /* Pretend DST not active if its status is unknown */
3408 if (isdst < 0)
3409 isdst = 0;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003410
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003411 /* Fetch the offset and initialize it if needed */
3412 gmt_offset = gmt_offsets[isdst & 0x01];
3413 if (unlikely(!*gmt_offset)) {
3414 get_gmtime(t, &tm_gmt);
3415 diff = my_tm_diff(tm, &tm_gmt);
3416 if (diff < 0) {
3417 diff = -diff;
3418 *gmt_offset = '-';
3419 } else {
3420 *gmt_offset = '+';
3421 }
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003422 diff %= 86400U;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003423 diff /= 60; /* Convert to minutes */
3424 snprintf(gmt_offset+1, 4+1, "%02d%02d", diff/60, diff%60);
3425 }
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003426
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003427 return gmt_offset;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003428}
3429
William Lallemand421f5b52012-02-06 18:15:57 +01003430/* gmt2str_log: write a date in the format :
3431 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
3432 * return a pointer to the last char written (\0) or
3433 * NULL if there isn't enough space.
3434 */
3435char *gmt2str_log(char *dst, struct tm *tm, size_t size)
3436{
Yuxans Yao4e25b012012-10-19 10:36:09 +08003437 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01003438 return NULL;
3439
3440 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003441 if (!dst)
3442 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003443 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003444
William Lallemand421f5b52012-02-06 18:15:57 +01003445 memcpy(dst, monthname[tm->tm_mon], 3); // month
3446 dst += 3;
3447 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003448
William Lallemand421f5b52012-02-06 18:15:57 +01003449 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003450 if (!dst)
3451 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003452 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003453
William Lallemand421f5b52012-02-06 18:15:57 +01003454 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003455 if (!dst)
3456 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003457 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003458
William Lallemand421f5b52012-02-06 18:15:57 +01003459 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003460 if (!dst)
3461 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003462 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003463
William Lallemand421f5b52012-02-06 18:15:57 +01003464 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003465 if (!dst)
3466 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003467 *dst++ = ' ';
3468 *dst++ = '+';
3469 *dst++ = '0';
3470 *dst++ = '0';
3471 *dst++ = '0';
3472 *dst++ = '0';
3473 *dst = '\0';
3474
3475 return dst;
3476}
3477
Yuxans Yao4e25b012012-10-19 10:36:09 +08003478/* localdate2str_log: write a date in the format :
3479 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003480 * Both t and tm must represent the same time.
3481 * return a pointer to the last char written (\0) or
3482 * NULL if there isn't enough space.
Yuxans Yao4e25b012012-10-19 10:36:09 +08003483 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003484char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size)
Yuxans Yao4e25b012012-10-19 10:36:09 +08003485{
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003486 const char *gmt_offset;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003487 if (size < 27) /* the size is fixed: 26 chars + \0 */
3488 return NULL;
3489
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003490 gmt_offset = get_gmt_offset(t, tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003491
Yuxans Yao4e25b012012-10-19 10:36:09 +08003492 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003493 if (!dst)
3494 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003495 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003496
Yuxans Yao4e25b012012-10-19 10:36:09 +08003497 memcpy(dst, monthname[tm->tm_mon], 3); // month
3498 dst += 3;
3499 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003500
Yuxans Yao4e25b012012-10-19 10:36:09 +08003501 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003502 if (!dst)
3503 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003504 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003505
Yuxans Yao4e25b012012-10-19 10:36:09 +08003506 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003507 if (!dst)
3508 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003509 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003510
Yuxans Yao4e25b012012-10-19 10:36:09 +08003511 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003512 if (!dst)
3513 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003514 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003515
Yuxans Yao4e25b012012-10-19 10:36:09 +08003516 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003517 if (!dst)
3518 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003519 *dst++ = ' ';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003520
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003521 memcpy(dst, gmt_offset, 5); // Offset from local time to GMT
Yuxans Yao4e25b012012-10-19 10:36:09 +08003522 dst += 5;
3523 *dst = '\0';
3524
3525 return dst;
3526}
3527
Willy Tarreaucb1949b2017-07-19 19:05:29 +02003528/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
3529 * It is meant as a portable replacement for timegm() for use with valid inputs.
3530 * Returns undefined results for invalid dates (eg: months out of range 0..11).
3531 */
3532time_t my_timegm(const struct tm *tm)
3533{
3534 /* Each month has 28, 29, 30 or 31 days, or 28+N. The date in the year
3535 * is thus (current month - 1)*28 + cumulated_N[month] to count the
3536 * sum of the extra N days for elapsed months. The sum of all these N
3537 * days doesn't exceed 30 for a complete year (366-12*28) so it fits
3538 * in a 5-bit word. This means that with 60 bits we can represent a
3539 * matrix of all these values at once, which is fast and efficient to
3540 * access. The extra February day for leap years is not counted here.
3541 *
3542 * Jan : none = 0 (0)
3543 * Feb : Jan = 3 (3)
3544 * Mar : Jan..Feb = 3 (3 + 0)
3545 * Apr : Jan..Mar = 6 (3 + 0 + 3)
3546 * May : Jan..Apr = 8 (3 + 0 + 3 + 2)
3547 * Jun : Jan..May = 11 (3 + 0 + 3 + 2 + 3)
3548 * Jul : Jan..Jun = 13 (3 + 0 + 3 + 2 + 3 + 2)
3549 * Aug : Jan..Jul = 16 (3 + 0 + 3 + 2 + 3 + 2 + 3)
3550 * Sep : Jan..Aug = 19 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3)
3551 * Oct : Jan..Sep = 21 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2)
3552 * Nov : Jan..Oct = 24 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3)
3553 * Dec : Jan..Nov = 26 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3 + 2)
3554 */
3555 uint64_t extra =
3556 ( 0ULL << 0*5) + ( 3ULL << 1*5) + ( 3ULL << 2*5) + /* Jan, Feb, Mar, */
3557 ( 6ULL << 3*5) + ( 8ULL << 4*5) + (11ULL << 5*5) + /* Apr, May, Jun, */
3558 (13ULL << 6*5) + (16ULL << 7*5) + (19ULL << 8*5) + /* Jul, Aug, Sep, */
3559 (21ULL << 9*5) + (24ULL << 10*5) + (26ULL << 11*5); /* Oct, Nov, Dec, */
3560
3561 unsigned int y = tm->tm_year + 1900;
3562 unsigned int m = tm->tm_mon;
3563 unsigned long days = 0;
3564
3565 /* days since 1/1/1970 for full years */
3566 days += days_since_zero(y) - days_since_zero(1970);
3567
3568 /* days for full months in the current year */
3569 days += 28 * m + ((extra >> (m * 5)) & 0x1f);
3570
3571 /* count + 1 after March for leap years. A leap year is a year multiple
3572 * of 4, unless it's multiple of 100 without being multiple of 400. 2000
3573 * is leap, 1900 isn't, 1904 is.
3574 */
3575 if ((m > 1) && !(y & 3) && ((y % 100) || !(y % 400)))
3576 days++;
3577
3578 days += tm->tm_mday - 1;
3579 return days * 86400ULL + tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
3580}
3581
Thierry Fournier93127942016-01-20 18:49:45 +01003582/* This function check a char. It returns true and updates
3583 * <date> and <len> pointer to the new position if the
3584 * character is found.
3585 */
3586static inline int parse_expect_char(const char **date, int *len, char c)
3587{
3588 if (*len < 1 || **date != c)
3589 return 0;
3590 (*len)--;
3591 (*date)++;
3592 return 1;
3593}
3594
3595/* This function expects a string <str> of len <l>. It return true and updates.
3596 * <date> and <len> if the string matches, otherwise, it returns false.
3597 */
3598static inline int parse_strcmp(const char **date, int *len, char *str, int l)
3599{
3600 if (*len < l || strncmp(*date, str, l) != 0)
3601 return 0;
3602 (*len) -= l;
3603 (*date) += l;
3604 return 1;
3605}
3606
3607/* This macro converts 3 chars name in integer. */
3608#define STR2I3(__a, __b, __c) ((__a) * 65536 + (__b) * 256 + (__c))
3609
3610/* day-name = %x4D.6F.6E ; "Mon", case-sensitive
3611 * / %x54.75.65 ; "Tue", case-sensitive
3612 * / %x57.65.64 ; "Wed", case-sensitive
3613 * / %x54.68.75 ; "Thu", case-sensitive
3614 * / %x46.72.69 ; "Fri", case-sensitive
3615 * / %x53.61.74 ; "Sat", case-sensitive
3616 * / %x53.75.6E ; "Sun", case-sensitive
3617 *
3618 * This array must be alphabetically sorted
3619 */
3620static inline int parse_http_dayname(const char **date, int *len, struct tm *tm)
3621{
3622 if (*len < 3)
3623 return 0;
3624 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3625 case STR2I3('M','o','n'): tm->tm_wday = 1; break;
3626 case STR2I3('T','u','e'): tm->tm_wday = 2; break;
3627 case STR2I3('W','e','d'): tm->tm_wday = 3; break;
3628 case STR2I3('T','h','u'): tm->tm_wday = 4; break;
3629 case STR2I3('F','r','i'): tm->tm_wday = 5; break;
3630 case STR2I3('S','a','t'): tm->tm_wday = 6; break;
3631 case STR2I3('S','u','n'): tm->tm_wday = 7; break;
3632 default: return 0;
3633 }
3634 *len -= 3;
3635 *date += 3;
3636 return 1;
3637}
3638
3639/* month = %x4A.61.6E ; "Jan", case-sensitive
3640 * / %x46.65.62 ; "Feb", case-sensitive
3641 * / %x4D.61.72 ; "Mar", case-sensitive
3642 * / %x41.70.72 ; "Apr", case-sensitive
3643 * / %x4D.61.79 ; "May", case-sensitive
3644 * / %x4A.75.6E ; "Jun", case-sensitive
3645 * / %x4A.75.6C ; "Jul", case-sensitive
3646 * / %x41.75.67 ; "Aug", case-sensitive
3647 * / %x53.65.70 ; "Sep", case-sensitive
3648 * / %x4F.63.74 ; "Oct", case-sensitive
3649 * / %x4E.6F.76 ; "Nov", case-sensitive
3650 * / %x44.65.63 ; "Dec", case-sensitive
3651 *
3652 * This array must be alphabetically sorted
3653 */
3654static inline int parse_http_monthname(const char **date, int *len, struct tm *tm)
3655{
3656 if (*len < 3)
3657 return 0;
3658 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3659 case STR2I3('J','a','n'): tm->tm_mon = 0; break;
3660 case STR2I3('F','e','b'): tm->tm_mon = 1; break;
3661 case STR2I3('M','a','r'): tm->tm_mon = 2; break;
3662 case STR2I3('A','p','r'): tm->tm_mon = 3; break;
3663 case STR2I3('M','a','y'): tm->tm_mon = 4; break;
3664 case STR2I3('J','u','n'): tm->tm_mon = 5; break;
3665 case STR2I3('J','u','l'): tm->tm_mon = 6; break;
3666 case STR2I3('A','u','g'): tm->tm_mon = 7; break;
3667 case STR2I3('S','e','p'): tm->tm_mon = 8; break;
3668 case STR2I3('O','c','t'): tm->tm_mon = 9; break;
3669 case STR2I3('N','o','v'): tm->tm_mon = 10; break;
3670 case STR2I3('D','e','c'): tm->tm_mon = 11; break;
3671 default: return 0;
3672 }
3673 *len -= 3;
3674 *date += 3;
3675 return 1;
3676}
3677
3678/* day-name-l = %x4D.6F.6E.64.61.79 ; "Monday", case-sensitive
3679 * / %x54.75.65.73.64.61.79 ; "Tuesday", case-sensitive
3680 * / %x57.65.64.6E.65.73.64.61.79 ; "Wednesday", case-sensitive
3681 * / %x54.68.75.72.73.64.61.79 ; "Thursday", case-sensitive
3682 * / %x46.72.69.64.61.79 ; "Friday", case-sensitive
3683 * / %x53.61.74.75.72.64.61.79 ; "Saturday", case-sensitive
3684 * / %x53.75.6E.64.61.79 ; "Sunday", case-sensitive
3685 *
3686 * This array must be alphabetically sorted
3687 */
3688static inline int parse_http_ldayname(const char **date, int *len, struct tm *tm)
3689{
3690 if (*len < 6) /* Minimum length. */
3691 return 0;
3692 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3693 case STR2I3('M','o','n'):
3694 RET0_UNLESS(parse_strcmp(date, len, "Monday", 6));
3695 tm->tm_wday = 1;
3696 return 1;
3697 case STR2I3('T','u','e'):
3698 RET0_UNLESS(parse_strcmp(date, len, "Tuesday", 7));
3699 tm->tm_wday = 2;
3700 return 1;
3701 case STR2I3('W','e','d'):
3702 RET0_UNLESS(parse_strcmp(date, len, "Wednesday", 9));
3703 tm->tm_wday = 3;
3704 return 1;
3705 case STR2I3('T','h','u'):
3706 RET0_UNLESS(parse_strcmp(date, len, "Thursday", 8));
3707 tm->tm_wday = 4;
3708 return 1;
3709 case STR2I3('F','r','i'):
3710 RET0_UNLESS(parse_strcmp(date, len, "Friday", 6));
3711 tm->tm_wday = 5;
3712 return 1;
3713 case STR2I3('S','a','t'):
3714 RET0_UNLESS(parse_strcmp(date, len, "Saturday", 8));
3715 tm->tm_wday = 6;
3716 return 1;
3717 case STR2I3('S','u','n'):
3718 RET0_UNLESS(parse_strcmp(date, len, "Sunday", 6));
3719 tm->tm_wday = 7;
3720 return 1;
3721 }
3722 return 0;
3723}
3724
3725/* This function parses exactly 1 digit and returns the numeric value in "digit". */
3726static inline int parse_digit(const char **date, int *len, int *digit)
3727{
3728 if (*len < 1 || **date < '0' || **date > '9')
3729 return 0;
3730 *digit = (**date - '0');
3731 (*date)++;
3732 (*len)--;
3733 return 1;
3734}
3735
3736/* This function parses exactly 2 digits and returns the numeric value in "digit". */
3737static inline int parse_2digit(const char **date, int *len, int *digit)
3738{
3739 int value;
3740
3741 RET0_UNLESS(parse_digit(date, len, &value));
3742 (*digit) = value * 10;
3743 RET0_UNLESS(parse_digit(date, len, &value));
3744 (*digit) += value;
3745
3746 return 1;
3747}
3748
3749/* This function parses exactly 4 digits and returns the numeric value in "digit". */
3750static inline int parse_4digit(const char **date, int *len, int *digit)
3751{
3752 int value;
3753
3754 RET0_UNLESS(parse_digit(date, len, &value));
3755 (*digit) = value * 1000;
3756
3757 RET0_UNLESS(parse_digit(date, len, &value));
3758 (*digit) += value * 100;
3759
3760 RET0_UNLESS(parse_digit(date, len, &value));
3761 (*digit) += value * 10;
3762
3763 RET0_UNLESS(parse_digit(date, len, &value));
3764 (*digit) += value;
3765
3766 return 1;
3767}
3768
3769/* time-of-day = hour ":" minute ":" second
3770 * ; 00:00:00 - 23:59:60 (leap second)
3771 *
3772 * hour = 2DIGIT
3773 * minute = 2DIGIT
3774 * second = 2DIGIT
3775 */
3776static inline int parse_http_time(const char **date, int *len, struct tm *tm)
3777{
3778 RET0_UNLESS(parse_2digit(date, len, &tm->tm_hour)); /* hour 2DIGIT */
3779 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3780 RET0_UNLESS(parse_2digit(date, len, &tm->tm_min)); /* min 2DIGIT */
3781 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3782 RET0_UNLESS(parse_2digit(date, len, &tm->tm_sec)); /* sec 2DIGIT */
3783 return 1;
3784}
3785
3786/* From RFC7231
3787 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3788 *
3789 * IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
3790 * ; fixed length/zone/capitalization subset of the format
3791 * ; see Section 3.3 of [RFC5322]
3792 *
3793 *
3794 * date1 = day SP month SP year
3795 * ; e.g., 02 Jun 1982
3796 *
3797 * day = 2DIGIT
3798 * year = 4DIGIT
3799 *
3800 * GMT = %x47.4D.54 ; "GMT", case-sensitive
3801 *
3802 * time-of-day = hour ":" minute ":" second
3803 * ; 00:00:00 - 23:59:60 (leap second)
3804 *
3805 * hour = 2DIGIT
3806 * minute = 2DIGIT
3807 * second = 2DIGIT
3808 *
3809 * DIGIT = decimal 0-9
3810 */
3811int parse_imf_date(const char *date, int len, struct tm *tm)
3812{
David Carlier327298c2016-11-20 10:42:38 +00003813 /* tm_gmtoff, if present, ought to be zero'ed */
3814 memset(tm, 0, sizeof(*tm));
3815
Thierry Fournier93127942016-01-20 18:49:45 +01003816 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3817 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3818 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3819 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3820 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3821 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3822 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3823 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3824 tm->tm_year -= 1900;
3825 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3826 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3827 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3828 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3829 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003830 return 1;
3831}
3832
3833/* From RFC7231
3834 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3835 *
3836 * rfc850-date = day-name-l "," SP date2 SP time-of-day SP GMT
3837 * date2 = day "-" month "-" 2DIGIT
3838 * ; e.g., 02-Jun-82
3839 *
3840 * day = 2DIGIT
3841 */
3842int parse_rfc850_date(const char *date, int len, struct tm *tm)
3843{
3844 int year;
3845
David Carlier327298c2016-11-20 10:42:38 +00003846 /* tm_gmtoff, if present, ought to be zero'ed */
3847 memset(tm, 0, sizeof(*tm));
3848
Thierry Fournier93127942016-01-20 18:49:45 +01003849 RET0_UNLESS(parse_http_ldayname(&date, &len, tm)); /* Read the day name */
3850 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3851 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3852 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3853 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3854 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3855 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3856
3857 /* year = 2DIGIT
3858 *
3859 * Recipients of a timestamp value in rfc850-(*date) format, which uses a
3860 * two-digit year, MUST interpret a timestamp that appears to be more
3861 * than 50 years in the future as representing the most recent year in
3862 * the past that had the same last two digits.
3863 */
3864 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_year));
3865
3866 /* expect SP */
3867 if (!parse_expect_char(&date, &len, ' ')) {
3868 /* Maybe we have the date with 4 digits. */
3869 RET0_UNLESS(parse_2digit(&date, &len, &year));
3870 tm->tm_year = (tm->tm_year * 100 + year) - 1900;
3871 /* expect SP */
3872 RET0_UNLESS(parse_expect_char(&date, &len, ' '));
3873 } else {
3874 /* I fix 60 as pivot: >60: +1900, <60: +2000. Note that the
3875 * tm_year is the number of year since 1900, so for +1900, we
3876 * do nothing, and for +2000, we add 100.
3877 */
3878 if (tm->tm_year <= 60)
3879 tm->tm_year += 100;
3880 }
3881
3882 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3883 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3884 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3885 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003886
3887 return 1;
3888}
3889
3890/* From RFC7231
3891 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3892 *
3893 * asctime-date = day-name SP date3 SP time-of-day SP year
3894 * date3 = month SP ( 2DIGIT / ( SP 1DIGIT ))
3895 * ; e.g., Jun 2
3896 *
3897 * HTTP-date is case sensitive. A sender MUST NOT generate additional
3898 * whitespace in an HTTP-date beyond that specifically included as SP in
3899 * the grammar.
3900 */
3901int parse_asctime_date(const char *date, int len, struct tm *tm)
3902{
David Carlier327298c2016-11-20 10:42:38 +00003903 /* tm_gmtoff, if present, ought to be zero'ed */
3904 memset(tm, 0, sizeof(*tm));
3905
Thierry Fournier93127942016-01-20 18:49:45 +01003906 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3907 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3908 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* expect month */
3909 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3910
3911 /* expect SP and 1DIGIT or 2DIGIT */
3912 if (parse_expect_char(&date, &len, ' '))
3913 RET0_UNLESS(parse_digit(&date, &len, &tm->tm_mday));
3914 else
3915 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday));
3916
3917 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3918 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3919 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3920 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3921 tm->tm_year -= 1900;
3922 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003923 return 1;
3924}
3925
3926/* From RFC7231
3927 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3928 *
3929 * HTTP-date = IMF-fixdate / obs-date
3930 * obs-date = rfc850-date / asctime-date
3931 *
3932 * parses an HTTP date in the RFC format and is accepted
3933 * alternatives. <date> is the strinf containing the date,
3934 * len is the len of the string. <tm> is filled with the
3935 * parsed time. We must considers this time as GMT.
3936 */
3937int parse_http_date(const char *date, int len, struct tm *tm)
3938{
3939 if (parse_imf_date(date, len, tm))
3940 return 1;
3941
3942 if (parse_rfc850_date(date, len, tm))
3943 return 1;
3944
3945 if (parse_asctime_date(date, len, tm))
3946 return 1;
3947
3948 return 0;
3949}
3950
Willy Tarreau4deeb102021-01-29 10:47:52 +01003951/* print the time <ns> in a short form (exactly 7 chars) at the end of buffer
3952 * <out>. "-" is printed if the value is zero, "inf" if larger than 1000 years.
3953 * It returns the new buffer length, or 0 if it doesn't fit. The value will be
3954 * surrounded by <pfx> and <sfx> respectively if not NULL.
3955 */
3956int print_time_short(struct buffer *out, const char *pfx, uint64_t ns, const char *sfx)
3957{
3958 double val = ns; // 52 bits of mantissa keep ns accuracy over 52 days
3959 const char *unit;
3960
3961 if (!pfx)
3962 pfx = "";
3963 if (!sfx)
3964 sfx = "";
3965
3966 do {
3967 unit = " - "; if (val <= 0.0) break;
3968 unit = "ns"; if (val < 1000.0) break;
3969 unit = "us"; val /= 1000.0; if (val < 1000.0) break;
3970 unit = "ms"; val /= 1000.0; if (val < 1000.0) break;
3971 unit = "s "; val /= 1000.0; if (val < 60.0) break;
3972 unit = "m "; val /= 60.0; if (val < 60.0) break;
3973 unit = "h "; val /= 60.0; if (val < 24.0) break;
3974 unit = "d "; val /= 24.0; if (val < 365.0) break;
3975 unit = "yr"; val /= 365.0; if (val < 1000.0) break;
3976 unit = " inf "; val = 0.0; break;
3977 } while (0);
3978
3979 if (val <= 0.0)
3980 return chunk_appendf(out, "%s%7s%s", pfx, unit, sfx);
3981 else if (val < 10.0)
3982 return chunk_appendf(out, "%s%1.3f%s%s", pfx, val, unit, sfx);
3983 else if (val < 100.0)
3984 return chunk_appendf(out, "%s%2.2f%s%s", pfx, val, unit, sfx);
3985 else
3986 return chunk_appendf(out, "%s%3.1f%s%s", pfx, val, unit, sfx);
3987}
3988
Willy Tarreau9a7bea52012-04-27 11:16:50 +02003989/* Dynamically allocates a string of the proper length to hold the formatted
3990 * output. NULL is returned on error. The caller is responsible for freeing the
3991 * memory area using free(). The resulting string is returned in <out> if the
3992 * pointer is not NULL. A previous version of <out> might be used to build the
3993 * new string, and it will be freed before returning if it is not NULL, which
3994 * makes it possible to build complex strings from iterative calls without
3995 * having to care about freeing intermediate values, as in the example below :
3996 *
3997 * memprintf(&err, "invalid argument: '%s'", arg);
3998 * ...
3999 * memprintf(&err, "parser said : <%s>\n", *err);
4000 * ...
4001 * free(*err);
4002 *
4003 * This means that <err> must be initialized to NULL before first invocation.
4004 * The return value also holds the allocated string, which eases error checking
4005 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02004006 * passed instead and it will be ignored. The returned message will then also
4007 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004008 *
4009 * It is also convenient to use it without any free except the last one :
4010 * err = NULL;
4011 * if (!fct1(err)) report(*err);
4012 * if (!fct2(err)) report(*err);
4013 * if (!fct3(err)) report(*err);
4014 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02004015 *
4016 * memprintf relies on memvprintf. This last version can be called from any
4017 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004018 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02004019char *memvprintf(char **out, const char *format, va_list orig_args)
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004020{
4021 va_list args;
4022 char *ret = NULL;
4023 int allocated = 0;
4024 int needed = 0;
4025
Willy Tarreaueb6cead2012-09-20 19:43:14 +02004026 if (!out)
4027 return NULL;
4028
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004029 do {
Willy Tarreaue0609f52019-03-29 19:13:23 +01004030 char buf1;
4031
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004032 /* vsnprintf() will return the required length even when the
4033 * target buffer is NULL. We do this in a loop just in case
4034 * intermediate evaluations get wrong.
4035 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02004036 va_copy(args, orig_args);
Willy Tarreaue0609f52019-03-29 19:13:23 +01004037 needed = vsnprintf(ret ? ret : &buf1, allocated, format, args);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004038 va_end(args);
Willy Tarreau1b2fed62013-04-01 22:48:54 +02004039 if (needed < allocated) {
4040 /* Note: on Solaris 8, the first iteration always
4041 * returns -1 if allocated is zero, so we force a
4042 * retry.
4043 */
4044 if (!allocated)
4045 needed = 0;
4046 else
4047 break;
4048 }
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004049
Willy Tarreau1b2fed62013-04-01 22:48:54 +02004050 allocated = needed + 1;
Hubert Verstraete831962e2016-06-28 22:44:26 +02004051 ret = my_realloc2(ret, allocated);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004052 } while (ret);
4053
4054 if (needed < 0) {
4055 /* an error was encountered */
Willy Tarreau61cfdf42021-02-20 10:46:51 +01004056 ha_free(&ret);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004057 }
4058
4059 if (out) {
4060 free(*out);
4061 *out = ret;
4062 }
4063
4064 return ret;
4065}
William Lallemand421f5b52012-02-06 18:15:57 +01004066
Christopher Faulet93a518f2017-10-24 11:25:33 +02004067char *memprintf(char **out, const char *format, ...)
4068{
4069 va_list args;
4070 char *ret = NULL;
4071
4072 va_start(args, format);
4073 ret = memvprintf(out, format, args);
4074 va_end(args);
4075
4076 return ret;
4077}
4078
Willy Tarreau21c705b2012-09-14 11:40:36 +02004079/* Used to add <level> spaces before each line of <out>, unless there is only one line.
4080 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02004081 * freed by the caller. It also supports being passed a NULL which results in the same
4082 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02004083 * Example of use :
4084 * parse(cmd, &err); (callee: memprintf(&err, ...))
4085 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
4086 * free(err);
4087 */
4088char *indent_msg(char **out, int level)
4089{
4090 char *ret, *in, *p;
4091 int needed = 0;
4092 int lf = 0;
4093 int lastlf = 0;
4094 int len;
4095
Willy Tarreau70eec382012-10-10 08:56:47 +02004096 if (!out || !*out)
4097 return NULL;
4098
Willy Tarreau21c705b2012-09-14 11:40:36 +02004099 in = *out - 1;
4100 while ((in = strchr(in + 1, '\n')) != NULL) {
4101 lastlf = in - *out;
4102 lf++;
4103 }
4104
4105 if (!lf) /* single line, no LF, return it as-is */
4106 return *out;
4107
4108 len = strlen(*out);
4109
4110 if (lf == 1 && lastlf == len - 1) {
4111 /* single line, LF at end, strip it and return as-is */
4112 (*out)[lastlf] = 0;
4113 return *out;
4114 }
4115
4116 /* OK now we have at least one LF, we need to process the whole string
4117 * as a multi-line string. What we'll do :
4118 * - prefix with an LF if there is none
4119 * - add <level> spaces before each line
4120 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
4121 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
4122 */
4123
4124 needed = 1 + level * (lf + 1) + len + 1;
4125 p = ret = malloc(needed);
4126 in = *out;
4127
4128 /* skip initial LFs */
4129 while (*in == '\n')
4130 in++;
4131
4132 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
4133 while (*in) {
4134 *p++ = '\n';
4135 memset(p, ' ', level);
4136 p += level;
4137 do {
4138 *p++ = *in++;
4139 } while (*in && *in != '\n');
4140 if (*in)
4141 in++;
4142 }
4143 *p = 0;
4144
4145 free(*out);
4146 *out = ret;
4147
4148 return ret;
4149}
4150
Willy Tarreaua2c99112019-08-21 13:17:37 +02004151/* makes a copy of message <in> into <out>, with each line prefixed with <pfx>
4152 * and end of lines replaced with <eol> if not 0. The first line to indent has
4153 * to be indicated in <first> (starts at zero), so that it is possible to skip
4154 * indenting the first line if it has to be appended after an existing message.
4155 * Empty strings are never indented, and NULL strings are considered empty both
4156 * for <in> and <pfx>. It returns non-zero if an EOL was appended as the last
4157 * character, non-zero otherwise.
4158 */
4159int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first)
4160{
4161 int bol, lf;
4162 int pfxlen = pfx ? strlen(pfx) : 0;
4163
4164 if (!in)
4165 return 0;
4166
4167 bol = 1;
4168 lf = 0;
4169 while (*in) {
4170 if (bol && pfxlen) {
4171 if (first > 0)
4172 first--;
4173 else
4174 b_putblk(out, pfx, pfxlen);
4175 bol = 0;
4176 }
4177
4178 lf = (*in == '\n');
4179 bol |= lf;
4180 b_putchr(out, (lf && eol) ? eol : *in);
4181 in++;
4182 }
4183 return lf;
4184}
4185
Willy Tarreau9d22e562019-03-29 18:49:09 +01004186/* removes environment variable <name> from the environment as found in
4187 * environ. This is only provided as an alternative for systems without
4188 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004189 * The principle is to scan environ for each occurrence of variable name
Willy Tarreau9d22e562019-03-29 18:49:09 +01004190 * <name> and to replace the matching pointers with the last pointer of
4191 * the array (since variables are not ordered).
4192 * It always returns 0 (success).
4193 */
4194int my_unsetenv(const char *name)
4195{
4196 extern char **environ;
4197 char **p = environ;
4198 int vars;
4199 int next;
4200 int len;
4201
4202 len = strlen(name);
4203 for (vars = 0; p[vars]; vars++)
4204 ;
4205 next = 0;
4206 while (next < vars) {
4207 if (strncmp(p[next], name, len) != 0 || p[next][len] != '=') {
4208 next++;
4209 continue;
4210 }
4211 if (next < vars - 1)
4212 p[next] = p[vars - 1];
4213 p[--vars] = NULL;
4214 }
4215 return 0;
4216}
4217
Willy Tarreaudad36a32013-03-11 01:20:04 +01004218/* Convert occurrences of environment variables in the input string to their
4219 * corresponding value. A variable is identified as a series of alphanumeric
4220 * characters or underscores following a '$' sign. The <in> string must be
4221 * free()able. NULL returns NULL. The resulting string might be reallocated if
4222 * some expansion is made. Variable names may also be enclosed into braces if
4223 * needed (eg: to concatenate alphanum characters).
4224 */
4225char *env_expand(char *in)
4226{
4227 char *txt_beg;
4228 char *out;
4229 char *txt_end;
4230 char *var_beg;
4231 char *var_end;
4232 char *value;
4233 char *next;
4234 int out_len;
4235 int val_len;
4236
4237 if (!in)
4238 return in;
4239
4240 value = out = NULL;
4241 out_len = 0;
4242
4243 txt_beg = in;
4244 do {
4245 /* look for next '$' sign in <in> */
4246 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
4247
4248 if (!*txt_end && !out) /* end and no expansion performed */
4249 return in;
4250
4251 val_len = 0;
4252 next = txt_end;
4253 if (*txt_end == '$') {
4254 char save;
4255
4256 var_beg = txt_end + 1;
4257 if (*var_beg == '{')
4258 var_beg++;
4259
4260 var_end = var_beg;
Willy Tarreau90807112020-02-25 08:16:33 +01004261 while (isalnum((unsigned char)*var_end) || *var_end == '_') {
Willy Tarreaudad36a32013-03-11 01:20:04 +01004262 var_end++;
4263 }
4264
4265 next = var_end;
4266 if (*var_end == '}' && (var_beg > txt_end + 1))
4267 next++;
4268
4269 /* get value of the variable name at this location */
4270 save = *var_end;
4271 *var_end = '\0';
4272 value = getenv(var_beg);
4273 *var_end = save;
4274 val_len = value ? strlen(value) : 0;
4275 }
4276
Hubert Verstraete831962e2016-06-28 22:44:26 +02004277 out = my_realloc2(out, out_len + (txt_end - txt_beg) + val_len + 1);
Willy Tarreaudad36a32013-03-11 01:20:04 +01004278 if (txt_end > txt_beg) {
4279 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
4280 out_len += txt_end - txt_beg;
4281 }
4282 if (val_len) {
4283 memcpy(out + out_len, value, val_len);
4284 out_len += val_len;
4285 }
4286 out[out_len] = 0;
4287 txt_beg = next;
4288 } while (*txt_beg);
4289
4290 /* here we know that <out> was allocated and that we don't need <in> anymore */
4291 free(in);
4292 return out;
4293}
4294
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004295
4296/* same as strstr() but case-insensitive and with limit length */
4297const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2)
4298{
4299 char *pptr, *sptr, *start;
Willy Tarreauc8746532014-05-28 23:05:07 +02004300 unsigned int slen, plen;
4301 unsigned int tmp1, tmp2;
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004302
4303 if (str1 == NULL || len_str1 == 0) // search pattern into an empty string => search is not found
4304 return NULL;
4305
4306 if (str2 == NULL || len_str2 == 0) // pattern is empty => every str1 match
4307 return str1;
4308
4309 if (len_str1 < len_str2) // pattern is longer than string => search is not found
4310 return NULL;
4311
4312 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 +02004313 while (toupper((unsigned char)*start) != toupper((unsigned char)*str2)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004314 start++;
4315 slen--;
4316 tmp1++;
4317
4318 if (tmp1 >= len_str1)
4319 return NULL;
4320
4321 /* if pattern longer than string */
4322 if (slen < plen)
4323 return NULL;
4324 }
4325
4326 sptr = start;
4327 pptr = (char *)str2;
4328
4329 tmp2 = 0;
Willy Tarreauf278eec2020-07-05 21:46:32 +02004330 while (toupper((unsigned char)*sptr) == toupper((unsigned char)*pptr)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004331 sptr++;
4332 pptr++;
4333 tmp2++;
4334
4335 if (*pptr == '\0' || tmp2 == len_str2) /* end of pattern found */
4336 return start;
4337 if (*sptr == '\0' || tmp2 == len_str1) /* end of string found and the pattern is not fully found */
4338 return NULL;
4339 }
4340 }
4341 return NULL;
4342}
4343
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004344/* This function read the next valid utf8 char.
4345 * <s> is the byte srray to be decode, <len> is its length.
4346 * The function returns decoded char encoded like this:
4347 * The 4 msb are the return code (UTF8_CODE_*), the 4 lsb
4348 * are the length read. The decoded character is stored in <c>.
4349 */
4350unsigned char utf8_next(const char *s, int len, unsigned int *c)
4351{
4352 const unsigned char *p = (unsigned char *)s;
4353 int dec;
4354 unsigned char code = UTF8_CODE_OK;
4355
4356 if (len < 1)
4357 return UTF8_CODE_OK;
4358
4359 /* Check the type of UTF8 sequence
4360 *
4361 * 0... .... 0x00 <= x <= 0x7f : 1 byte: ascii char
4362 * 10.. .... 0x80 <= x <= 0xbf : invalid sequence
4363 * 110. .... 0xc0 <= x <= 0xdf : 2 bytes
4364 * 1110 .... 0xe0 <= x <= 0xef : 3 bytes
4365 * 1111 0... 0xf0 <= x <= 0xf7 : 4 bytes
4366 * 1111 10.. 0xf8 <= x <= 0xfb : 5 bytes
4367 * 1111 110. 0xfc <= x <= 0xfd : 6 bytes
4368 * 1111 111. 0xfe <= x <= 0xff : invalid sequence
4369 */
4370 switch (*p) {
4371 case 0x00 ... 0x7f:
4372 *c = *p;
4373 return UTF8_CODE_OK | 1;
4374
4375 case 0x80 ... 0xbf:
4376 *c = *p;
4377 return UTF8_CODE_BADSEQ | 1;
4378
4379 case 0xc0 ... 0xdf:
4380 if (len < 2) {
4381 *c = *p;
4382 return UTF8_CODE_BADSEQ | 1;
4383 }
4384 *c = *p & 0x1f;
4385 dec = 1;
4386 break;
4387
4388 case 0xe0 ... 0xef:
4389 if (len < 3) {
4390 *c = *p;
4391 return UTF8_CODE_BADSEQ | 1;
4392 }
4393 *c = *p & 0x0f;
4394 dec = 2;
4395 break;
4396
4397 case 0xf0 ... 0xf7:
4398 if (len < 4) {
4399 *c = *p;
4400 return UTF8_CODE_BADSEQ | 1;
4401 }
4402 *c = *p & 0x07;
4403 dec = 3;
4404 break;
4405
4406 case 0xf8 ... 0xfb:
4407 if (len < 5) {
4408 *c = *p;
4409 return UTF8_CODE_BADSEQ | 1;
4410 }
4411 *c = *p & 0x03;
4412 dec = 4;
4413 break;
4414
4415 case 0xfc ... 0xfd:
4416 if (len < 6) {
4417 *c = *p;
4418 return UTF8_CODE_BADSEQ | 1;
4419 }
4420 *c = *p & 0x01;
4421 dec = 5;
4422 break;
4423
4424 case 0xfe ... 0xff:
4425 default:
4426 *c = *p;
4427 return UTF8_CODE_BADSEQ | 1;
4428 }
4429
4430 p++;
4431
4432 while (dec > 0) {
4433
4434 /* need 0x10 for the 2 first bits */
4435 if ( ( *p & 0xc0 ) != 0x80 )
4436 return UTF8_CODE_BADSEQ | ((p-(unsigned char *)s)&0xffff);
4437
4438 /* add data at char */
4439 *c = ( *c << 6 ) | ( *p & 0x3f );
4440
4441 dec--;
4442 p++;
4443 }
4444
4445 /* Check ovelong encoding.
4446 * 1 byte : 5 + 6 : 11 : 0x80 ... 0x7ff
4447 * 2 bytes : 4 + 6 + 6 : 16 : 0x800 ... 0xffff
4448 * 3 bytes : 3 + 6 + 6 + 6 : 21 : 0x10000 ... 0x1fffff
4449 */
Thierry FOURNIER9e7ec082015-03-12 19:32:38 +01004450 if (( *c <= 0x7f && (p-(unsigned char *)s) > 1) ||
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004451 (*c >= 0x80 && *c <= 0x7ff && (p-(unsigned char *)s) > 2) ||
4452 (*c >= 0x800 && *c <= 0xffff && (p-(unsigned char *)s) > 3) ||
4453 (*c >= 0x10000 && *c <= 0x1fffff && (p-(unsigned char *)s) > 4))
4454 code |= UTF8_CODE_OVERLONG;
4455
4456 /* Check invalid UTF8 range. */
4457 if ((*c >= 0xd800 && *c <= 0xdfff) ||
4458 (*c >= 0xfffe && *c <= 0xffff))
4459 code |= UTF8_CODE_INVRANGE;
4460
4461 return code | ((p-(unsigned char *)s)&0x0f);
4462}
4463
Maxime de Roucydc887852016-05-13 23:52:54 +02004464/* append a copy of string <str> (in a wordlist) at the end of the list <li>
4465 * On failure : return 0 and <err> filled with an error message.
4466 * The caller is responsible for freeing the <err> and <str> copy
4467 * memory area using free()
4468 */
4469int list_append_word(struct list *li, const char *str, char **err)
4470{
4471 struct wordlist *wl;
4472
4473 wl = calloc(1, sizeof(*wl));
4474 if (!wl) {
4475 memprintf(err, "out of memory");
4476 goto fail_wl;
4477 }
4478
4479 wl->s = strdup(str);
4480 if (!wl->s) {
4481 memprintf(err, "out of memory");
4482 goto fail_wl_s;
4483 }
4484
Willy Tarreau2b718102021-04-21 07:32:39 +02004485 LIST_APPEND(li, &wl->list);
Maxime de Roucydc887852016-05-13 23:52:54 +02004486
4487 return 1;
4488
4489fail_wl_s:
4490 free(wl->s);
4491fail_wl:
4492 free(wl);
4493 return 0;
4494}
4495
Willy Tarreau37101052019-05-20 16:48:20 +02004496/* indicates if a memory location may safely be read or not. The trick consists
4497 * in performing a harmless syscall using this location as an input and letting
4498 * the operating system report whether it's OK or not. For this we have the
4499 * stat() syscall, which will return EFAULT when the memory location supposed
4500 * to contain the file name is not readable. If it is readable it will then
4501 * either return 0 if the area contains an existing file name, or -1 with
4502 * another code. This must not be abused, and some audit systems might detect
4503 * this as abnormal activity. It's used only for unsafe dumps.
4504 */
4505int may_access(const void *ptr)
4506{
4507 struct stat buf;
4508
4509 if (stat(ptr, &buf) == 0)
4510 return 1;
4511 if (errno == EFAULT)
4512 return 0;
4513 return 1;
4514}
4515
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004516/* print a string of text buffer to <out>. The format is :
4517 * Non-printable chars \t, \n, \r and \e are * encoded in C format.
4518 * Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
4519 * Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
4520 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004521int dump_text(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004522{
4523 unsigned char c;
Tim Duesterhuscd5521e2021-08-29 00:58:22 +02004524 size_t ptr = 0;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004525
Tim Duesterhuscd5521e2021-08-29 00:58:22 +02004526 while (ptr < bsize && buf[ptr]) {
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004527 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004528 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\' && c != ' ' && c != '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004529 if (out->data > out->size - 1)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004530 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004531 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004532 }
4533 else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\' || c == ' ' || c == '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004534 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004535 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004536 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004537 switch (c) {
4538 case ' ': c = ' '; break;
4539 case '\t': c = 't'; break;
4540 case '\n': c = 'n'; break;
4541 case '\r': c = 'r'; break;
4542 case '\e': c = 'e'; break;
4543 case '\\': c = '\\'; break;
4544 case '=': c = '='; break;
4545 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004546 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004547 }
4548 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004549 if (out->data > out->size - 4)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004550 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004551 out->area[out->data++] = '\\';
4552 out->area[out->data++] = 'x';
4553 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4554 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004555 }
4556 ptr++;
4557 }
4558
4559 return ptr;
4560}
4561
4562/* print a buffer in hexa.
4563 * Print stopped if <bsize> is reached, or if no more place in the chunk.
4564 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004565int dump_binary(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004566{
4567 unsigned char c;
4568 int ptr = 0;
4569
4570 while (ptr < bsize) {
4571 c = buf[ptr];
4572
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004573 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004574 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004575 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4576 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004577
4578 ptr++;
4579 }
4580 return ptr;
4581}
4582
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004583/* Appends into buffer <out> a hex dump of memory area <buf> for <len> bytes,
4584 * prepending each line with prefix <pfx>. The output is *not* initialized.
4585 * The output will not wrap pas the buffer's end so it is more optimal if the
4586 * caller makes sure the buffer is aligned first. A trailing zero will always
4587 * be appended (and not counted) if there is room for it. The caller must make
Willy Tarreau37101052019-05-20 16:48:20 +02004588 * sure that the area is dumpable first. If <unsafe> is non-null, the memory
4589 * locations are checked first for being readable.
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004590 */
Willy Tarreau37101052019-05-20 16:48:20 +02004591void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe)
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004592{
4593 const unsigned char *d = buf;
4594 int i, j, start;
4595
4596 d = (const unsigned char *)(((unsigned long)buf) & -16);
4597 start = ((unsigned long)buf) & 15;
4598
4599 for (i = 0; i < start + len; i += 16) {
4600 chunk_appendf(out, (sizeof(void *) == 4) ? "%s%8p: " : "%s%16p: ", pfx, d + i);
4601
Willy Tarreau37101052019-05-20 16:48:20 +02004602 // 0: unchecked, 1: checked safe, 2: danger
4603 unsafe = !!unsafe;
4604 if (unsafe && !may_access(d + i))
4605 unsafe = 2;
4606
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004607 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004608 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004609 chunk_strcat(out, "'' ");
Willy Tarreau37101052019-05-20 16:48:20 +02004610 else if (unsafe > 1)
4611 chunk_strcat(out, "** ");
4612 else
4613 chunk_appendf(out, "%02x ", d[i + j]);
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004614
4615 if (j == 7)
4616 chunk_strcat(out, "- ");
4617 }
4618 chunk_strcat(out, " ");
4619 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004620 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004621 chunk_strcat(out, "'");
Willy Tarreau37101052019-05-20 16:48:20 +02004622 else if (unsafe > 1)
4623 chunk_strcat(out, "*");
Willy Tarreau90807112020-02-25 08:16:33 +01004624 else if (isprint((unsigned char)d[i + j]))
Willy Tarreau37101052019-05-20 16:48:20 +02004625 chunk_appendf(out, "%c", d[i + j]);
4626 else
4627 chunk_strcat(out, ".");
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004628 }
4629 chunk_strcat(out, "\n");
4630 }
4631}
4632
Willy Tarreau762fb3e2020-03-03 15:57:10 +01004633/* dumps <pfx> followed by <n> bytes from <addr> in hex form into buffer <buf>
4634 * enclosed in brackets after the address itself, formatted on 14 chars
4635 * including the "0x" prefix. This is meant to be used as a prefix for code
4636 * areas. For example:
4637 * "0x7f10b6557690 [48 c7 c0 0f 00 00 00 0f]"
4638 * It relies on may_access() to know if the bytes are dumpable, otherwise "--"
4639 * is emitted. A NULL <pfx> will be considered empty.
4640 */
4641void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n)
4642{
4643 int ok = 0;
4644 int i;
4645
4646 chunk_appendf(buf, "%s%#14lx [", pfx ? pfx : "", (long)addr);
4647
4648 for (i = 0; i < n; i++) {
4649 if (i == 0 || (((long)(addr + i) ^ (long)(addr)) & 4096))
4650 ok = may_access(addr + i);
4651 if (ok)
4652 chunk_appendf(buf, "%02x%s", ((uint8_t*)addr)[i], (i<n-1) ? " " : "]");
4653 else
4654 chunk_appendf(buf, "--%s", (i<n-1) ? " " : "]");
4655 }
4656}
4657
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004658/* print a line of text buffer (limited to 70 bytes) to <out>. The format is :
4659 * <2 spaces> <offset=5 digits> <space or plus> <space> <70 chars max> <\n>
4660 * which is 60 chars per line. Non-printable chars \t, \n, \r and \e are
4661 * encoded in C format. Other non-printable chars are encoded "\xHH". Original
4662 * lines are respected within the limit of 70 output chars. Lines that are
4663 * continuation of a previous truncated line begin with "+" instead of " "
4664 * after the offset. The new pointer is returned.
4665 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004666int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004667 int *line, int ptr)
4668{
4669 int end;
4670 unsigned char c;
4671
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004672 end = out->data + 80;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004673 if (end > out->size)
4674 return ptr;
4675
4676 chunk_appendf(out, " %05d%c ", ptr, (ptr == *line) ? ' ' : '+');
4677
4678 while (ptr < len && ptr < bsize) {
4679 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004680 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004681 if (out->data > end - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004682 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004683 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004684 } else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004685 if (out->data > end - 3)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004686 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004687 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004688 switch (c) {
4689 case '\t': c = 't'; break;
4690 case '\n': c = 'n'; break;
4691 case '\r': c = 'r'; break;
4692 case '\e': c = 'e'; break;
4693 case '\\': c = '\\'; break;
4694 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004695 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004696 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004697 if (out->data > end - 5)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004698 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004699 out->area[out->data++] = '\\';
4700 out->area[out->data++] = 'x';
4701 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4702 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004703 }
4704 if (buf[ptr++] == '\n') {
4705 /* we had a line break, let's return now */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004706 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004707 *line = ptr;
4708 return ptr;
4709 }
4710 }
4711 /* we have an incomplete line, we return it as-is */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004712 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004713 return ptr;
4714}
4715
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004716/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02004717 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
4718 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004719 */
Willy Tarreaued936c52017-04-27 18:03:20 +02004720void debug_hexdump(FILE *out, const char *pfx, const char *buf,
4721 unsigned int baseaddr, int len)
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004722{
Willy Tarreau73459792017-04-11 07:58:08 +02004723 unsigned int i;
4724 int b, j;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004725
4726 for (i = 0; i < (len + (baseaddr & 15)); i += 16) {
4727 b = i - (baseaddr & 15);
Willy Tarreaued936c52017-04-27 18:03:20 +02004728 fprintf(out, "%s%08x: ", pfx ? pfx : "", i + (baseaddr & ~15));
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004729 for (j = 0; j < 8; j++) {
4730 if (b + j >= 0 && b + j < len)
4731 fprintf(out, "%02x ", (unsigned char)buf[b + j]);
4732 else
4733 fprintf(out, " ");
4734 }
4735
4736 if (b + j >= 0 && b + j < len)
4737 fputc('-', out);
4738 else
4739 fputc(' ', out);
4740
4741 for (j = 8; j < 16; j++) {
4742 if (b + j >= 0 && b + j < len)
4743 fprintf(out, " %02x", (unsigned char)buf[b + j]);
4744 else
4745 fprintf(out, " ");
4746 }
4747
4748 fprintf(out, " ");
4749 for (j = 0; j < 16; j++) {
4750 if (b + j >= 0 && b + j < len) {
4751 if (isprint((unsigned char)buf[b + j]))
4752 fputc((unsigned char)buf[b + j], out);
4753 else
4754 fputc('.', out);
4755 }
4756 else
4757 fputc(' ', out);
4758 }
4759 fputc('\n', out);
4760 }
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004761}
4762
Willy Tarreaubb869862020-04-16 10:52:41 +02004763/* Tries to report the executable path name on platforms supporting this. If
4764 * not found or not possible, returns NULL.
4765 */
4766const char *get_exec_path()
4767{
4768 const char *ret = NULL;
4769
Willy Tarreau1ee71dd2021-08-30 10:15:35 +02004770#if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
Willy Tarreaubb869862020-04-16 10:52:41 +02004771 long execfn = getauxval(AT_EXECFN);
4772
4773 if (execfn && execfn != ENOENT)
4774 ret = (const char *)execfn;
devnexen@gmail.com49a32282021-08-17 12:55:49 +01004775#elif defined(__FreeBSD__)
4776 Elf_Auxinfo *auxv;
4777 for (auxv = __elf_aux_vector; auxv->a_type != AT_NULL; ++auxv) {
4778 if (auxv->a_type == AT_EXECPATH) {
4779 ret = (const char *)auxv->a_un.a_ptr;
4780 break;
4781 }
4782 }
David Carlier1b9d57d2021-08-17 08:44:25 +01004783#elif defined(__NetBSD__)
4784 AuxInfo *auxv;
4785 for (auxv = _dlauxinfo(); auxv->a_type != AT_NULL; ++auxv) {
4786 if (auxv->a_type == AT_SUN_EXECNAME) {
4787 ret = (const char *)auxv->a_v;
4788 break;
4789 }
4790 }
Willy Tarreaubb869862020-04-16 10:52:41 +02004791#endif
4792 return ret;
4793}
4794
Baruch Siache1651b22020-07-24 07:52:20 +03004795#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreau9133e482020-03-04 10:19:36 +01004796/* calls dladdr() or dladdr1() on <addr> and <dli>. If dladdr1 is available,
4797 * also returns the symbol size in <size>, otherwise returns 0 there.
4798 */
4799static int dladdr_and_size(const void *addr, Dl_info *dli, size_t *size)
4800{
4801 int ret;
Willy Tarreau1ee71dd2021-08-30 10:15:35 +02004802#if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) // most detailed one
Willy Tarreau9133e482020-03-04 10:19:36 +01004803 const ElfW(Sym) *sym;
4804
4805 ret = dladdr1(addr, dli, (void **)&sym, RTLD_DL_SYMENT);
4806 if (ret)
4807 *size = sym ? sym->st_size : 0;
4808#else
4809 ret = dladdr(addr, dli);
4810 *size = 0;
4811#endif
4812 return ret;
4813}
Willy Tarreau64192392021-05-05 09:06:21 +02004814
4815/* Tries to retrieve the address of the first occurrence symbol <name>.
4816 * Note that NULL in return is not always an error as a symbol may have that
4817 * address in special situations.
4818 */
4819void *get_sym_curr_addr(const char *name)
4820{
4821 void *ptr = NULL;
4822
4823#ifdef RTLD_DEFAULT
4824 ptr = dlsym(RTLD_DEFAULT, name);
4825#endif
4826 return ptr;
4827}
4828
4829
4830/* Tries to retrieve the address of the next occurrence of symbol <name>
4831 * Note that NULL in return is not always an error as a symbol may have that
4832 * address in special situations.
4833 */
4834void *get_sym_next_addr(const char *name)
4835{
4836 void *ptr = NULL;
4837
4838#ifdef RTLD_NEXT
4839 ptr = dlsym(RTLD_NEXT, name);
Willy Tarreau9133e482020-03-04 10:19:36 +01004840#endif
Willy Tarreau64192392021-05-05 09:06:21 +02004841 return ptr;
4842}
4843
4844#else /* elf & linux & dl */
4845
4846/* no possible resolving on other platforms at the moment */
4847void *get_sym_curr_addr(const char *name)
4848{
4849 return NULL;
4850}
4851
4852void *get_sym_next_addr(const char *name)
4853{
4854 return NULL;
4855}
4856
4857#endif /* elf & linux & dl */
Willy Tarreau9133e482020-03-04 10:19:36 +01004858
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004859/* Tries to append to buffer <buf> some indications about the symbol at address
4860 * <addr> using the following form:
4861 * lib:+0xoffset (unresolvable address from lib's base)
4862 * main+0xoffset (unresolvable address from main (+/-))
4863 * lib:main+0xoffset (unresolvable lib address from main (+/-))
4864 * name (resolved exact exec address)
4865 * lib:name (resolved exact lib address)
4866 * name+0xoffset/0xsize (resolved address within exec symbol)
4867 * lib:name+0xoffset/0xsize (resolved address within lib symbol)
4868 *
4869 * The file name (lib or executable) is limited to what lies between the last
4870 * '/' and the first following '.'. An optional prefix <pfx> is prepended before
4871 * 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 +03004872 * that contains the "main" symbol, or when __ELF__ && USE_DL are not set.
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004873 *
4874 * The symbol's base address is returned, or NULL when unresolved, in order to
4875 * allow the caller to match it against known ones.
4876 */
Willy Tarreau45fd1032021-01-20 14:37:59 +01004877const void *resolve_sym_name(struct buffer *buf, const char *pfx, const void *addr)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004878{
4879 const struct {
4880 const void *func;
4881 const char *name;
4882 } fcts[] = {
4883 { .func = process_stream, .name = "process_stream" },
4884 { .func = task_run_applet, .name = "task_run_applet" },
4885 { .func = si_cs_io_cb, .name = "si_cs_io_cb" },
Willy Tarreau586f71b2020-12-11 15:54:36 +01004886 { .func = sock_conn_iocb, .name = "sock_conn_iocb" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004887 { .func = dgram_fd_handler, .name = "dgram_fd_handler" },
4888 { .func = listener_accept, .name = "listener_accept" },
Willy Tarreaud597ec22021-01-29 14:29:06 +01004889 { .func = manage_global_listener_queue, .name = "manage_global_listener_queue" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004890 { .func = poller_pipe_io_handler, .name = "poller_pipe_io_handler" },
4891 { .func = mworker_accept_wrapper, .name = "mworker_accept_wrapper" },
Willy Tarreau02922e12021-01-29 12:27:57 +01004892 { .func = session_expire_embryonic, .name = "session_expire_embryonic" },
Willy Tarreaufb5401f2021-01-29 12:25:23 +01004893#ifdef USE_THREAD
4894 { .func = accept_queue_process, .name = "accept_queue_process" },
4895#endif
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004896#ifdef USE_LUA
4897 { .func = hlua_process_task, .name = "hlua_process_task" },
4898#endif
Ilya Shipitsinbdec3ba2020-11-14 01:56:34 +05004899#ifdef SSL_MODE_ASYNC
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004900 { .func = ssl_async_fd_free, .name = "ssl_async_fd_free" },
4901 { .func = ssl_async_fd_handler, .name = "ssl_async_fd_handler" },
4902#endif
4903 };
4904
Baruch Siache1651b22020-07-24 07:52:20 +03004905#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004906 Dl_info dli, dli_main;
Willy Tarreau9133e482020-03-04 10:19:36 +01004907 size_t size;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004908 const char *fname, *p;
4909#endif
4910 int i;
4911
4912 if (pfx)
4913 chunk_appendf(buf, "%s", pfx);
4914
4915 for (i = 0; i < sizeof(fcts) / sizeof(fcts[0]); i++) {
4916 if (addr == fcts[i].func) {
4917 chunk_appendf(buf, "%s", fcts[i].name);
4918 return addr;
4919 }
4920 }
4921
Baruch Siache1651b22020-07-24 07:52:20 +03004922#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004923 /* Now let's try to be smarter */
Willy Tarreau9133e482020-03-04 10:19:36 +01004924 if (!dladdr_and_size(addr, &dli, &size))
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004925 goto unknown;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004926
4927 /* 1. prefix the library name if it's not the same object as the one
4928 * that contains the main function. The name is picked between last '/'
4929 * and first following '.'.
4930 */
4931 if (!dladdr(main, &dli_main))
4932 dli_main.dli_fbase = NULL;
4933
4934 if (dli_main.dli_fbase != dli.dli_fbase) {
4935 fname = dli.dli_fname;
4936 p = strrchr(fname, '/');
4937 if (p++)
4938 fname = p;
4939 p = strchr(fname, '.');
4940 if (!p)
4941 p = fname + strlen(fname);
4942
4943 chunk_appendf(buf, "%.*s:", (int)(long)(p - fname), fname);
4944 }
4945
4946 /* 2. symbol name */
4947 if (dli.dli_sname) {
4948 /* known, dump it and return symbol's address (exact or relative) */
4949 chunk_appendf(buf, "%s", dli.dli_sname);
4950 if (addr != dli.dli_saddr) {
4951 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_saddr));
Willy Tarreau9133e482020-03-04 10:19:36 +01004952 if (size)
4953 chunk_appendf(buf, "/%#lx", (long)size);
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004954 }
4955 return dli.dli_saddr;
4956 }
4957 else if (dli_main.dli_fbase != dli.dli_fbase) {
4958 /* unresolved symbol from a known library, report relative offset */
4959 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_fbase));
4960 return NULL;
4961 }
Baruch Siache1651b22020-07-24 07:52:20 +03004962#endif /* __ELF__ && !__linux__ || USE_DL */
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004963 unknown:
4964 /* unresolved symbol from the main file, report relative offset to main */
4965 if ((void*)addr < (void*)main)
4966 chunk_appendf(buf, "main-%#lx", (long)((void*)main - addr));
4967 else
4968 chunk_appendf(buf, "main+%#lx", (long)(addr - (void*)main));
4969 return NULL;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004970}
4971
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004972/*
4973 * Allocate an array of unsigned int with <nums> as address from <str> string
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05004974 * made of integer separated by dot characters.
Frédéric Lécaille3b717162019-02-25 15:04:22 +01004975 *
4976 * First, initializes the value with <sz> as address to 0 and initializes the
4977 * array with <nums> as address to NULL. Then allocates the array with <nums> as
4978 * address updating <sz> pointed value to the size of this array.
4979 *
4980 * Returns 1 if succeeded, 0 if not.
4981 */
4982int parse_dotted_uints(const char *str, unsigned int **nums, size_t *sz)
4983{
4984 unsigned int *n;
4985 const char *s, *end;
4986
4987 s = str;
4988 *sz = 0;
4989 end = str + strlen(str);
4990 *nums = n = NULL;
4991
4992 while (1) {
4993 unsigned int r;
4994
4995 if (s >= end)
4996 break;
4997
4998 r = read_uint(&s, end);
4999 /* Expected characters after having read an uint: '\0' or '.',
5000 * if '.', must not be terminal.
5001 */
Christopher Faulet4b524122021-02-11 10:42:41 +01005002 if (*s != '\0'&& (*s++ != '.' || s == end)) {
5003 free(n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005004 return 0;
Christopher Faulet4b524122021-02-11 10:42:41 +01005005 }
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005006
Frédéric Lécaille12a71842019-02-26 18:19:48 +01005007 n = my_realloc2(n, (*sz + 1) * sizeof *n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005008 if (!n)
5009 return 0;
5010
5011 n[(*sz)++] = r;
5012 }
5013 *nums = n;
5014
5015 return 1;
5016}
5017
Willy Tarreau4d589e72019-08-23 19:02:26 +02005018
5019/* returns the number of bytes needed to encode <v> as a varint. An inline
5020 * version exists for use with constants (__varint_bytes()).
5021 */
5022int varint_bytes(uint64_t v)
5023{
5024 int len = 1;
5025
5026 if (v >= 240) {
5027 v = (v - 240) >> 4;
5028 while (1) {
5029 len++;
5030 if (v < 128)
5031 break;
5032 v = (v - 128) >> 7;
5033 }
5034 }
5035 return len;
5036}
5037
Willy Tarreau52bf8392020-03-08 00:42:37 +01005038
5039/* Random number generator state, see below */
Willy Tarreau1544c142020-03-12 00:31:18 +01005040static uint64_t ha_random_state[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01005041
5042/* This is a thread-safe implementation of xoroshiro128** described below:
5043 * http://prng.di.unimi.it/
5044 * It features a 2^128 long sequence, returns 64 high-quality bits on each call,
5045 * supports fast jumps and passes all common quality tests. It is thread-safe,
5046 * uses a double-cas on 64-bit architectures supporting it, and falls back to a
5047 * local lock on other ones.
5048 */
5049uint64_t ha_random64()
5050{
Willy Tarreau1544c142020-03-12 00:31:18 +01005051 uint64_t old[2] ALIGNED(2*sizeof(uint64_t));
5052 uint64_t new[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01005053
5054#if defined(USE_THREAD) && (!defined(HA_CAS_IS_8B) || !defined(HA_HAVE_CAS_DW))
5055 static HA_SPINLOCK_T rand_lock;
5056
5057 HA_SPIN_LOCK(OTHER_LOCK, &rand_lock);
5058#endif
5059
5060 old[0] = ha_random_state[0];
5061 old[1] = ha_random_state[1];
5062
5063#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
5064 do {
5065#endif
Willy Tarreau52bf8392020-03-08 00:42:37 +01005066 new[1] = old[0] ^ old[1];
5067 new[0] = rotl64(old[0], 24) ^ new[1] ^ (new[1] << 16); // a, b
5068 new[1] = rotl64(new[1], 37); // c
5069
5070#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
5071 } while (unlikely(!_HA_ATOMIC_DWCAS(ha_random_state, old, new)));
5072#else
5073 ha_random_state[0] = new[0];
5074 ha_random_state[1] = new[1];
5075#if defined(USE_THREAD)
5076 HA_SPIN_UNLOCK(OTHER_LOCK, &rand_lock);
5077#endif
5078#endif
Willy Tarreaub2475a12021-05-09 10:26:14 +02005079 return rotl64(old[0] * 5, 7) * 9;
Willy Tarreau52bf8392020-03-08 00:42:37 +01005080}
5081
5082/* seeds the random state using up to <len> bytes from <seed>, starting with
5083 * the first non-zero byte.
5084 */
5085void ha_random_seed(const unsigned char *seed, size_t len)
5086{
5087 size_t pos;
5088
5089 /* the seed must not be all zeroes, so we pre-fill it with alternating
5090 * bits and overwrite part of them with the block starting at the first
5091 * non-zero byte from the seed.
5092 */
5093 memset(ha_random_state, 0x55, sizeof(ha_random_state));
5094
5095 for (pos = 0; pos < len; pos++)
5096 if (seed[pos] != 0)
5097 break;
5098
5099 if (pos == len)
5100 return;
5101
5102 seed += pos;
5103 len -= pos;
5104
5105 if (len > sizeof(ha_random_state))
5106 len = sizeof(ha_random_state);
5107
5108 memcpy(ha_random_state, seed, len);
5109}
5110
5111/* This causes a jump to (dist * 2^96) places in the pseudo-random sequence,
5112 * and is equivalent to calling ha_random64() as many times. It is used to
5113 * provide non-overlapping sequences of 2^96 numbers (~7*10^28) to up to 2^32
5114 * different generators (i.e. different processes after a fork). The <dist>
5115 * argument is the distance to jump to and is used in a loop so it rather not
5116 * be too large if the processing time is a concern.
5117 *
5118 * BEWARE: this function is NOT thread-safe and must not be called during
5119 * concurrent accesses to ha_random64().
5120 */
5121void ha_random_jump96(uint32_t dist)
5122{
5123 while (dist--) {
5124 uint64_t s0 = 0;
5125 uint64_t s1 = 0;
5126 int b;
5127
5128 for (b = 0; b < 64; b++) {
5129 if ((0xd2a98b26625eee7bULL >> b) & 1) {
5130 s0 ^= ha_random_state[0];
5131 s1 ^= ha_random_state[1];
5132 }
5133 ha_random64();
5134 }
5135
5136 for (b = 0; b < 64; b++) {
5137 if ((0xdddf9b1090aa7ac1ULL >> b) & 1) {
5138 s0 ^= ha_random_state[0];
5139 s1 ^= ha_random_state[1];
5140 }
5141 ha_random64();
5142 }
5143 ha_random_state[0] = s0;
5144 ha_random_state[1] = s1;
5145 }
5146}
5147
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01005148/* Generates an RFC4122 UUID into chunk <output> which must be at least 37
5149 * bytes large.
5150 */
5151void ha_generate_uuid(struct buffer *output)
5152{
5153 uint32_t rnd[4];
5154 uint64_t last;
5155
5156 last = ha_random64();
5157 rnd[0] = last;
5158 rnd[1] = last >> 32;
5159
5160 last = ha_random64();
5161 rnd[2] = last;
5162 rnd[3] = last >> 32;
5163
5164 chunk_printf(output, "%8.8x-%4.4x-%4.4x-%4.4x-%12.12llx",
5165 rnd[0],
5166 rnd[1] & 0xFFFF,
5167 ((rnd[1] >> 16u) & 0xFFF) | 0x4000, // highest 4 bits indicate the uuid version
5168 (rnd[2] & 0x3FFF) | 0x8000, // the highest 2 bits indicate the UUID variant (10),
5169 (long long)((rnd[2] >> 14u) | ((uint64_t) rnd[3] << 18u)) & 0xFFFFFFFFFFFFull);
5170}
5171
5172
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005173/* only used by parse_line() below. It supports writing in place provided that
5174 * <in> is updated to the next location before calling it. In that case, the
5175 * char at <in> may be overwritten.
5176 */
5177#define EMIT_CHAR(x) \
5178 do { \
5179 char __c = (char)(x); \
5180 if ((opts & PARSE_OPT_INPLACE) && out+outpos > in) \
5181 err |= PARSE_ERR_OVERLAP; \
5182 if (outpos >= outmax) \
5183 err |= PARSE_ERR_TOOLARGE; \
5184 if (!err) \
5185 out[outpos] = __c; \
5186 outpos++; \
5187 } while (0)
5188
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05005189/* Parse <in>, copy it into <out> split into isolated words whose pointers
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005190 * are put in <args>. If more than <outlen> bytes have to be emitted, the
5191 * extraneous ones are not emitted but <outlen> is updated so that the caller
5192 * knows how much to realloc. Similarly, <args> are not updated beyond <nbargs>
5193 * but the returned <nbargs> indicates how many were found. All trailing args
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005194 * up to <nbargs> point to the trailing zero, and as long as <nbargs> is > 0,
5195 * it is guaranteed that at least one arg will point to the zero. It is safe
5196 * to call it with a NULL <args> if <nbargs> is 0.
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005197 *
5198 * <out> may overlap with <in> provided that it never goes further, in which
5199 * case the parser will accept to perform in-place parsing and unquoting/
5200 * unescaping but only if environment variables do not lead to expansion that
5201 * causes overlapping, otherwise the input string being destroyed, the error
5202 * will not be recoverable. Note that even during out-of-place <in> will
5203 * experience temporary modifications in-place for variable resolution and must
5204 * be writable, and will also receive zeroes to delimit words when using
5205 * in-place copy. Parsing options <opts> taken from PARSE_OPT_*. Return value
5206 * is zero on success otherwise a bitwise-or of PARSE_ERR_*. Upon error, the
5207 * starting point of the first invalid character sequence or unmatched
5208 * quote/brace is reported in <errptr> if not NULL. When using in-place parsing
5209 * error reporting might be difficult since zeroes will have been inserted into
5210 * the string. One solution for the caller may consist in replacing all args
5211 * delimiters with spaces in this case.
5212 */
5213uint32_t parse_line(char *in, char *out, size_t *outlen, char **args, int *nbargs, uint32_t opts, char **errptr)
5214{
5215 char *quote = NULL;
5216 char *brace = NULL;
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005217 char *word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005218 unsigned char hex1, hex2;
5219 size_t outmax = *outlen;
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005220 int argsmax = *nbargs - 1;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005221 size_t outpos = 0;
5222 int squote = 0;
5223 int dquote = 0;
5224 int arg = 0;
5225 uint32_t err = 0;
5226
5227 *nbargs = 0;
5228 *outlen = 0;
5229
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005230 /* argsmax may be -1 here, protecting args[] from any write */
5231 if (arg < argsmax)
5232 args[arg] = out;
5233
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005234 while (1) {
5235 if (*in >= '-' && *in != '\\') {
5236 /* speedup: directly send all regular chars starting
5237 * with '-', '.', '/', alnum etc...
5238 */
5239 EMIT_CHAR(*in++);
5240 continue;
5241 }
5242 else if (*in == '\0' || *in == '\n' || *in == '\r') {
5243 /* end of line */
5244 break;
5245 }
5246 else if (*in == '#' && (opts & PARSE_OPT_SHARP) && !squote && !dquote) {
5247 /* comment */
5248 break;
5249 }
5250 else if (*in == '"' && !squote && (opts & PARSE_OPT_DQUOTE)) { /* double quote outside single quotes */
5251 if (dquote) {
5252 dquote = 0;
5253 quote = NULL;
5254 }
5255 else {
5256 dquote = 1;
5257 quote = in;
5258 }
5259 in++;
5260 continue;
5261 }
5262 else if (*in == '\'' && !dquote && (opts & PARSE_OPT_SQUOTE)) { /* single quote outside double quotes */
5263 if (squote) {
5264 squote = 0;
5265 quote = NULL;
5266 }
5267 else {
5268 squote = 1;
5269 quote = in;
5270 }
5271 in++;
5272 continue;
5273 }
5274 else if (*in == '\\' && !squote && (opts & PARSE_OPT_BKSLASH)) {
5275 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
5276 * C equivalent value but only when they have a special meaning and within
5277 * double quotes for some of them. Other combinations left unchanged (eg: \1).
5278 */
5279 char tosend = *in;
5280
5281 switch (in[1]) {
5282 case ' ':
5283 case '\\':
5284 tosend = in[1];
5285 in++;
5286 break;
5287
5288 case 't':
5289 tosend = '\t';
5290 in++;
5291 break;
5292
5293 case 'n':
5294 tosend = '\n';
5295 in++;
5296 break;
5297
5298 case 'r':
5299 tosend = '\r';
5300 in++;
5301 break;
5302
5303 case '#':
5304 /* escaping of "#" only if comments are supported */
5305 if (opts & PARSE_OPT_SHARP)
5306 in++;
5307 tosend = *in;
5308 break;
5309
5310 case '\'':
5311 /* escaping of "'" only outside single quotes and only if single quotes are supported */
5312 if (opts & PARSE_OPT_SQUOTE && !squote)
5313 in++;
5314 tosend = *in;
5315 break;
5316
5317 case '"':
5318 /* escaping of '"' only outside single quotes and only if double quotes are supported */
5319 if (opts & PARSE_OPT_DQUOTE && !squote)
5320 in++;
5321 tosend = *in;
5322 break;
5323
5324 case '$':
5325 /* escaping of '$' only inside double quotes and only if env supported */
5326 if (opts & PARSE_OPT_ENV && dquote)
5327 in++;
5328 tosend = *in;
5329 break;
5330
5331 case 'x':
5332 if (!ishex(in[2]) || !ishex(in[3])) {
5333 /* invalid or incomplete hex sequence */
5334 err |= PARSE_ERR_HEX;
5335 if (errptr)
5336 *errptr = in;
5337 goto leave;
5338 }
Willy Tarreauf278eec2020-07-05 21:46:32 +02005339 hex1 = toupper((unsigned char)in[2]) - '0';
5340 hex2 = toupper((unsigned char)in[3]) - '0';
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005341 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
5342 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
5343 tosend = (hex1 << 4) + hex2;
5344 in += 3;
5345 break;
5346
5347 default:
5348 /* other combinations are not escape sequences */
5349 break;
5350 }
5351
5352 in++;
5353 EMIT_CHAR(tosend);
5354 }
5355 else if (isspace((unsigned char)*in) && !squote && !dquote) {
5356 /* a non-escaped space is an argument separator */
5357 while (isspace((unsigned char)*in))
5358 in++;
5359 EMIT_CHAR(0);
5360 arg++;
5361 if (arg < argsmax)
5362 args[arg] = out + outpos;
5363 else
5364 err |= PARSE_ERR_TOOMANY;
5365 }
5366 else if (*in == '$' && (opts & PARSE_OPT_ENV) && (dquote || !(opts & PARSE_OPT_DQUOTE))) {
5367 /* environment variables are evaluated anywhere, or only
5368 * inside double quotes if they are supported.
5369 */
5370 char *var_name;
5371 char save_char;
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005372 const char *value;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005373
5374 in++;
5375
5376 if (*in == '{')
5377 brace = in++;
5378
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005379 if (!isalpha((unsigned char)*in) && *in != '_' && *in != '.') {
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005380 /* unacceptable character in variable name */
5381 err |= PARSE_ERR_VARNAME;
5382 if (errptr)
5383 *errptr = in;
5384 goto leave;
5385 }
5386
5387 var_name = in;
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005388 if (*in == '.')
5389 in++;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005390 while (isalnum((unsigned char)*in) || *in == '_')
5391 in++;
5392
5393 save_char = *in;
5394 *in = '\0';
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005395 if (unlikely(*var_name == '.')) {
5396 /* internal pseudo-variables */
5397 if (strcmp(var_name, ".LINE") == 0)
5398 value = ultoa(global.cfg_curr_line);
5399 else if (strcmp(var_name, ".FILE") == 0)
5400 value = global.cfg_curr_file;
5401 else if (strcmp(var_name, ".SECTION") == 0)
5402 value = global.cfg_curr_section;
5403 else {
5404 /* unsupported internal variable name */
5405 err |= PARSE_ERR_VARNAME;
5406 if (errptr)
5407 *errptr = var_name;
5408 goto leave;
5409 }
5410 } else {
5411 value = getenv(var_name);
5412 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005413 *in = save_char;
5414
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005415 /* support for '[*]' sequence to force word expansion,
5416 * only available inside braces */
5417 if (*in == '[' && brace && (opts & PARSE_OPT_WORD_EXPAND)) {
5418 word_expand = in++;
5419
5420 if (*in++ != '*' || *in++ != ']') {
5421 err |= PARSE_ERR_WRONG_EXPAND;
5422 if (errptr)
5423 *errptr = word_expand;
5424 goto leave;
5425 }
5426 }
5427
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005428 if (brace) {
5429 if (*in != '}') {
5430 /* unmatched brace */
5431 err |= PARSE_ERR_BRACE;
5432 if (errptr)
5433 *errptr = brace;
5434 goto leave;
5435 }
5436 in++;
5437 brace = NULL;
5438 }
5439
5440 if (value) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005441 while (*value) {
5442 /* expand as individual parameters on a space character */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005443 if (word_expand && isspace((unsigned char)*value)) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005444 EMIT_CHAR(0);
5445 ++arg;
5446 if (arg < argsmax)
5447 args[arg] = out + outpos;
5448 else
5449 err |= PARSE_ERR_TOOMANY;
5450
5451 /* skip consecutive spaces */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005452 while (isspace((unsigned char)*++value))
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005453 ;
5454 } else {
5455 EMIT_CHAR(*value++);
5456 }
5457 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005458 }
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005459 word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005460 }
5461 else {
5462 /* any other regular char */
5463 EMIT_CHAR(*in++);
5464 }
5465 }
5466
5467 /* end of output string */
5468 EMIT_CHAR(0);
5469 arg++;
5470
5471 if (quote) {
5472 /* unmatched quote */
5473 err |= PARSE_ERR_QUOTE;
5474 if (errptr)
5475 *errptr = quote;
5476 goto leave;
5477 }
5478 leave:
5479 *nbargs = arg;
5480 *outlen = outpos;
5481
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005482 /* empty all trailing args by making them point to the trailing zero,
5483 * at least the last one in any case.
5484 */
5485 if (arg > argsmax)
5486 arg = argsmax;
5487
5488 while (arg >= 0 && arg <= argsmax)
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005489 args[arg++] = out + outpos - 1;
5490
5491 return err;
5492}
5493#undef EMIT_CHAR
5494
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005495/* This is used to sanitize an input line that's about to be used for error reporting.
5496 * It will adjust <line> to print approximately <width> chars around <pos>, trying to
5497 * preserve the beginning, with leading or trailing "..." when the line is truncated.
5498 * If non-printable chars are present in the output. It returns the new offset <pos>
5499 * in the modified line. Non-printable characters are replaced with '?'. <width> must
5500 * be at least 6 to support two "..." otherwise the result is undefined. The line
5501 * itself must have at least 7 chars allocated for the same reason.
5502 */
5503size_t sanitize_for_printing(char *line, size_t pos, size_t width)
5504{
5505 size_t shift = 0;
5506 char *out = line;
5507 char *in = line;
5508 char *end = line + width;
5509
5510 if (pos >= width) {
5511 /* if we have to shift, we'll be out of context, so let's
5512 * try to put <pos> at the center of width.
5513 */
5514 shift = pos - width / 2;
5515 in += shift + 3;
5516 end = out + width - 3;
5517 out[0] = out[1] = out[2] = '.';
5518 out += 3;
5519 }
5520
5521 while (out < end && *in) {
5522 if (isspace((unsigned char)*in))
5523 *out++ = ' ';
5524 else if (isprint((unsigned char)*in))
5525 *out++ = *in;
5526 else
5527 *out++ = '?';
5528 in++;
5529 }
5530
5531 if (end < line + width) {
5532 out[0] = out[1] = out[2] = '.';
5533 out += 3;
5534 }
5535
5536 *out++ = 0;
5537 return pos - shift;
5538}
Willy Tarreau06e69b52021-03-02 14:01:35 +01005539
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005540/* Update array <fp> with the fingerprint of word <word> by counting the
Willy Tarreauba2c4452021-03-12 09:01:52 +01005541 * transitions between characters. <fp> is a 1024-entries array indexed as
5542 * 32*from+to. Positions for 'from' and 'to' are:
Willy Tarreau9294e882021-03-15 09:34:27 +01005543 * 1..26=letter, 27=digit, 28=other/begin/end.
5544 * Row "from=0" is used to mark the character's presence. Others unused.
Willy Tarreauba2c4452021-03-12 09:01:52 +01005545 */
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005546void update_word_fingerprint(uint8_t *fp, const char *word)
Willy Tarreauba2c4452021-03-12 09:01:52 +01005547{
5548 const char *p;
5549 int from, to;
5550 int c;
5551
Willy Tarreauba2c4452021-03-12 09:01:52 +01005552 from = 28; // begin
5553 for (p = word; *p; p++) {
5554 c = tolower(*p);
5555 switch(c) {
Willy Tarreau9294e882021-03-15 09:34:27 +01005556 case 'a'...'z': to = c - 'a' + 1; break;
5557 case 'A'...'Z': to = tolower(c) - 'a' + 1; break;
5558 case '0'...'9': to = 27; break;
5559 default: to = 28; break;
Willy Tarreauba2c4452021-03-12 09:01:52 +01005560 }
Willy Tarreau9294e882021-03-15 09:34:27 +01005561 fp[to] = 1;
Willy Tarreauba2c4452021-03-12 09:01:52 +01005562 fp[32 * from + to]++;
5563 from = to;
5564 }
5565 to = 28; // end
5566 fp[32 * from + to]++;
5567}
5568
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005569/* Initialize array <fp> with the fingerprint of word <word> by counting the
5570 * transitions between characters. <fp> is a 1024-entries array indexed as
5571 * 32*from+to. Positions for 'from' and 'to' are:
5572 * 0..25=letter, 26=digit, 27=other, 28=begin, 29=end, others unused.
5573 */
5574void make_word_fingerprint(uint8_t *fp, const char *word)
5575{
5576 memset(fp, 0, 1024);
5577 update_word_fingerprint(fp, word);
5578}
5579
Willy Tarreauba2c4452021-03-12 09:01:52 +01005580/* Return the distance between two word fingerprints created by function
5581 * make_word_fingerprint(). It's a positive integer calculated as the sum of
Willy Tarreau714c4c12021-03-15 09:44:53 +01005582 * the differences between each location.
Willy Tarreauba2c4452021-03-12 09:01:52 +01005583 */
5584int word_fingerprint_distance(const uint8_t *fp1, const uint8_t *fp2)
5585{
5586 int i, k, dist = 0;
5587
5588 for (i = 0; i < 1024; i++) {
5589 k = (int)fp1[i] - (int)fp2[i];
Willy Tarreau714c4c12021-03-15 09:44:53 +01005590 dist += abs(k);
Willy Tarreauba2c4452021-03-12 09:01:52 +01005591 }
5592 return dist;
5593}
5594
Willy Tarreau06e69b52021-03-02 14:01:35 +01005595static int init_tools_per_thread()
5596{
5597 /* Let's make each thread start from a different position */
5598 statistical_prng_state += tid * MAX_THREADS;
5599 if (!statistical_prng_state)
5600 statistical_prng_state++;
5601 return 1;
5602}
5603REGISTER_PER_THREAD_INIT(init_tools_per_thread);
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005604
Willy Tarreaubaaee002006-06-26 02:48:02 +02005605/*
5606 * Local variables:
5607 * c-indent-level: 8
5608 * c-basic-offset: 8
5609 * End:
5610 */