blob: 74903efdaeead27c8c45ef7fd535eb6091794d28 [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.comc4e52322021-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 Carlierbd2cced2021-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
David Carlier43a56852022-03-04 15:50:48 +000046#if defined(__linux__) && 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>
Christopher Faulet6b0a0fb2022-04-04 11:29:28 +020054#include <haproxy/applet.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020055#include <haproxy/chunk.h>
Willy Tarreau7c18b542020-06-11 09:23:02 +020056#include <haproxy/dgram.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020057#include <haproxy/global.h>
Willy Tarreau86416052020-06-04 09:20:54 +020058#include <haproxy/hlua.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020059#include <haproxy/listener.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +020060#include <haproxy/namespace.h>
Christopher Faulet9553de72021-02-26 09:12:50 +010061#include <haproxy/net_helper.h>
Willy Tarreau5fc93282020-09-16 18:25:03 +020062#include <haproxy/protocol.h>
Emeric Brunc9437992021-02-12 19:42:55 +010063#include <haproxy/resolvers.h>
Willy Tarreau5edca2f2022-05-27 09:25:10 +020064#include <haproxy/sc_strm.h>
Willy Tarreau586f71b2020-12-11 15:54:36 +010065#include <haproxy/sock.h>
Willy Tarreau209108d2020-06-04 20:30:20 +020066#include <haproxy/ssl_sock.h>
William Lallemand3aeb3f92021-08-21 23:59:56 +020067#include <haproxy/ssl_utils.h>
Willy Tarreaucb086c62022-05-27 09:47:12 +020068#include <haproxy/stconn.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020069#include <haproxy/task.h>
Willy Tarreau48fbcae2020-06-03 18:09:46 +020070#include <haproxy/tools.h>
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +010071
Thierry Fournier93127942016-01-20 18:49:45 +010072/* This macro returns false if the test __x is false. Many
73 * of the following parsing function must be abort the processing
74 * if it returns 0, so this macro is useful for writing light code.
75 */
76#define RET0_UNLESS(__x) do { if (!(__x)) return 0; } while (0)
77
Willy Tarreau56adcf22012-12-23 18:00:29 +010078/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020079 * 2^64-1 = 18446744073709551615 or
80 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020081 *
82 * The HTML version needs room for adding the 25 characters
83 * '<span class="rls"></span>' around digits at positions 3N+1 in order
84 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020085 */
Christopher Faulet99bca652017-11-14 16:47:26 +010086THREAD_LOCAL char itoa_str[NB_ITOA_STR][171];
87THREAD_LOCAL int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020088
Willy Tarreau588297f2014-06-16 15:16:40 +020089/* sometimes we'll need to quote strings (eg: in stats), and we don't expect
90 * to quote strings larger than a max configuration line.
91 */
Christopher Faulet99bca652017-11-14 16:47:26 +010092THREAD_LOCAL char quoted_str[NB_QSTR][QSTR_SIZE + 1];
93THREAD_LOCAL int quoted_idx = 0;
Willy Tarreau588297f2014-06-16 15:16:40 +020094
Willy Tarreau06e69b52021-03-02 14:01:35 +010095/* thread-local PRNG state. It's modified to start from a different sequence
96 * on all threads upon startup. It must not be used or anything beyond getting
97 * statistical values as it's 100% predictable.
98 */
99THREAD_LOCAL unsigned int statistical_prng_state = 2463534242U;
100
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101/*
William Lallemande7340ec2012-01-24 11:15:39 +0100102 * unsigned long long ASCII representation
103 *
104 * return the last char '\0' or NULL if no enough
105 * space in dst
106 */
107char *ulltoa(unsigned long long n, char *dst, size_t size)
108{
109 int i = 0;
110 char *res;
111
112 switch(n) {
113 case 1ULL ... 9ULL:
114 i = 0;
115 break;
116
117 case 10ULL ... 99ULL:
118 i = 1;
119 break;
120
121 case 100ULL ... 999ULL:
122 i = 2;
123 break;
124
125 case 1000ULL ... 9999ULL:
126 i = 3;
127 break;
128
129 case 10000ULL ... 99999ULL:
130 i = 4;
131 break;
132
133 case 100000ULL ... 999999ULL:
134 i = 5;
135 break;
136
137 case 1000000ULL ... 9999999ULL:
138 i = 6;
139 break;
140
141 case 10000000ULL ... 99999999ULL:
142 i = 7;
143 break;
144
145 case 100000000ULL ... 999999999ULL:
146 i = 8;
147 break;
148
149 case 1000000000ULL ... 9999999999ULL:
150 i = 9;
151 break;
152
153 case 10000000000ULL ... 99999999999ULL:
154 i = 10;
155 break;
156
157 case 100000000000ULL ... 999999999999ULL:
158 i = 11;
159 break;
160
161 case 1000000000000ULL ... 9999999999999ULL:
162 i = 12;
163 break;
164
165 case 10000000000000ULL ... 99999999999999ULL:
166 i = 13;
167 break;
168
169 case 100000000000000ULL ... 999999999999999ULL:
170 i = 14;
171 break;
172
173 case 1000000000000000ULL ... 9999999999999999ULL:
174 i = 15;
175 break;
176
177 case 10000000000000000ULL ... 99999999999999999ULL:
178 i = 16;
179 break;
180
181 case 100000000000000000ULL ... 999999999999999999ULL:
182 i = 17;
183 break;
184
185 case 1000000000000000000ULL ... 9999999999999999999ULL:
186 i = 18;
187 break;
188
189 case 10000000000000000000ULL ... ULLONG_MAX:
190 i = 19;
191 break;
192 }
193 if (i + 2 > size) // (i + 1) + '\0'
194 return NULL; // too long
195 res = dst + i + 1;
196 *res = '\0';
197 for (; i >= 0; i--) {
198 dst[i] = n % 10ULL + '0';
199 n /= 10ULL;
200 }
201 return res;
202}
203
204/*
205 * unsigned long ASCII representation
206 *
207 * return the last char '\0' or NULL if no enough
208 * space in dst
209 */
210char *ultoa_o(unsigned long n, char *dst, size_t size)
211{
212 int i = 0;
213 char *res;
214
215 switch (n) {
216 case 0U ... 9UL:
217 i = 0;
218 break;
219
220 case 10U ... 99UL:
221 i = 1;
222 break;
223
224 case 100U ... 999UL:
225 i = 2;
226 break;
227
228 case 1000U ... 9999UL:
229 i = 3;
230 break;
231
232 case 10000U ... 99999UL:
233 i = 4;
234 break;
235
236 case 100000U ... 999999UL:
237 i = 5;
238 break;
239
240 case 1000000U ... 9999999UL:
241 i = 6;
242 break;
243
244 case 10000000U ... 99999999UL:
245 i = 7;
246 break;
247
248 case 100000000U ... 999999999UL:
249 i = 8;
250 break;
251#if __WORDSIZE == 32
252
253 case 1000000000ULL ... ULONG_MAX:
254 i = 9;
255 break;
256
257#elif __WORDSIZE == 64
258
259 case 1000000000ULL ... 9999999999UL:
260 i = 9;
261 break;
262
263 case 10000000000ULL ... 99999999999UL:
264 i = 10;
265 break;
266
267 case 100000000000ULL ... 999999999999UL:
268 i = 11;
269 break;
270
271 case 1000000000000ULL ... 9999999999999UL:
272 i = 12;
273 break;
274
275 case 10000000000000ULL ... 99999999999999UL:
276 i = 13;
277 break;
278
279 case 100000000000000ULL ... 999999999999999UL:
280 i = 14;
281 break;
282
283 case 1000000000000000ULL ... 9999999999999999UL:
284 i = 15;
285 break;
286
287 case 10000000000000000ULL ... 99999999999999999UL:
288 i = 16;
289 break;
290
291 case 100000000000000000ULL ... 999999999999999999UL:
292 i = 17;
293 break;
294
295 case 1000000000000000000ULL ... 9999999999999999999UL:
296 i = 18;
297 break;
298
299 case 10000000000000000000ULL ... ULONG_MAX:
300 i = 19;
301 break;
302
303#endif
304 }
305 if (i + 2 > size) // (i + 1) + '\0'
306 return NULL; // too long
307 res = dst + i + 1;
308 *res = '\0';
309 for (; i >= 0; i--) {
310 dst[i] = n % 10U + '0';
311 n /= 10U;
312 }
313 return res;
314}
315
316/*
317 * signed long ASCII representation
318 *
319 * return the last char '\0' or NULL if no enough
320 * space in dst
321 */
322char *ltoa_o(long int n, char *dst, size_t size)
323{
324 char *pos = dst;
325
326 if (n < 0) {
327 if (size < 3)
328 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
329 *pos = '-';
330 pos++;
331 dst = ultoa_o(-n, pos, size - 1);
332 } else {
333 dst = ultoa_o(n, dst, size);
334 }
335 return dst;
336}
337
338/*
339 * signed long long ASCII representation
340 *
341 * return the last char '\0' or NULL if no enough
342 * space in dst
343 */
344char *lltoa(long long n, char *dst, size_t size)
345{
346 char *pos = dst;
347
348 if (n < 0) {
349 if (size < 3)
350 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
351 *pos = '-';
352 pos++;
353 dst = ulltoa(-n, pos, size - 1);
354 } else {
355 dst = ulltoa(n, dst, size);
356 }
357 return dst;
358}
359
360/*
361 * write a ascii representation of a unsigned into dst,
362 * return a pointer to the last character
363 * Pad the ascii representation with '0', using size.
364 */
365char *utoa_pad(unsigned int n, char *dst, size_t size)
366{
367 int i = 0;
368 char *ret;
369
370 switch(n) {
371 case 0U ... 9U:
372 i = 0;
373 break;
374
375 case 10U ... 99U:
376 i = 1;
377 break;
378
379 case 100U ... 999U:
380 i = 2;
381 break;
382
383 case 1000U ... 9999U:
384 i = 3;
385 break;
386
387 case 10000U ... 99999U:
388 i = 4;
389 break;
390
391 case 100000U ... 999999U:
392 i = 5;
393 break;
394
395 case 1000000U ... 9999999U:
396 i = 6;
397 break;
398
399 case 10000000U ... 99999999U:
400 i = 7;
401 break;
402
403 case 100000000U ... 999999999U:
404 i = 8;
405 break;
406
407 case 1000000000U ... 4294967295U:
408 i = 9;
409 break;
410 }
411 if (i + 2 > size) // (i + 1) + '\0'
412 return NULL; // too long
413 if (i < size)
414 i = size - 2; // padding - '\0'
415
416 ret = dst + i + 1;
417 *ret = '\0';
418 for (; i >= 0; i--) {
419 dst[i] = n % 10U + '0';
420 n /= 10U;
421 }
422 return ret;
423}
424
425/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200426 * copies at most <size-1> chars from <src> to <dst>. Last char is always
427 * set to 0, unless <size> is 0. The number of chars copied is returned
428 * (excluding the terminating zero).
429 * This code has been optimized for size and speed : on x86, it's 45 bytes
430 * long, uses only registers, and consumes only 4 cycles per char.
431 */
432int strlcpy2(char *dst, const char *src, int size)
433{
434 char *orig = dst;
435 if (size) {
436 while (--size && (*dst = *src)) {
437 src++; dst++;
438 }
439 *dst = 0;
440 }
441 return dst - orig;
442}
443
444/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200445 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200446 * the ascii representation for number 'n' in decimal.
447 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100448char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200449{
450 char *pos;
451
Willy Tarreau72d759c2007-10-25 12:14:10 +0200452 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453 *pos-- = '\0';
454
455 do {
456 *pos-- = '0' + n % 10;
457 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200458 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200459 return pos + 1;
460}
461
Willy Tarreau91092e52007-10-25 16:58:42 +0200462/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200463 * This function simply returns a locally allocated string containing
Thierry FOURNIER763a5d82015-07-06 23:09:52 +0200464 * the ascii representation for number 'n' in decimal.
465 */
466char *lltoa_r(long long int in, char *buffer, int size)
467{
468 char *pos;
469 int neg = 0;
470 unsigned long long int n;
471
472 pos = buffer + size - 1;
473 *pos-- = '\0';
474
475 if (in < 0) {
476 neg = 1;
477 n = -in;
478 }
479 else
480 n = in;
481
482 do {
483 *pos-- = '0' + n % 10;
484 n /= 10;
485 } while (n && pos >= buffer);
486 if (neg && pos > buffer)
487 *pos-- = '-';
488 return pos + 1;
489}
490
491/*
492 * This function simply returns a locally allocated string containing
Thierry FOURNIER1480bd82015-06-06 19:14:59 +0200493 * the ascii representation for signed number 'n' in decimal.
494 */
495char *sltoa_r(long n, char *buffer, int size)
496{
497 char *pos;
498
499 if (n >= 0)
500 return ultoa_r(n, buffer, size);
501
502 pos = ultoa_r(-n, buffer + 1, size - 1) - 1;
503 *pos = '-';
504 return pos;
505}
506
507/*
508 * This function simply returns a locally allocated string containing
Willy Tarreaue7239b52009-03-29 13:41:58 +0200509 * the ascii representation for number 'n' in decimal, formatted for
510 * HTML output with tags to create visual grouping by 3 digits. The
511 * output needs to support at least 171 characters.
512 */
513const char *ulltoh_r(unsigned long long n, char *buffer, int size)
514{
515 char *start;
516 int digit = 0;
517
518 start = buffer + size;
519 *--start = '\0';
520
521 do {
522 if (digit == 3 && start >= buffer + 7)
523 memcpy(start -= 7, "</span>", 7);
524
525 if (start >= buffer + 1) {
526 *--start = '0' + n % 10;
527 n /= 10;
528 }
529
530 if (digit == 3 && start >= buffer + 18)
531 memcpy(start -= 18, "<span class=\"rls\">", 18);
532
533 if (digit++ == 3)
534 digit = 1;
535 } while (n && start > buffer);
536 return start;
537}
538
539/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200540 * This function simply returns a locally allocated string containing the ascii
541 * representation for number 'n' in decimal, unless n is 0 in which case it
542 * returns the alternate string (or an empty string if the alternate string is
543 * NULL). It use is intended for limits reported in reports, where it's
544 * desirable not to display anything if there is no limit. Warning! it shares
545 * the same vector as ultoa_r().
546 */
547const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
548{
549 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
550}
551
Willy Tarreau56d1d8d2021-05-08 10:28:53 +0200552/* Trims the first "%f" float in a string to its minimum number of digits after
553 * the decimal point by trimming trailing zeroes, even dropping the decimal
554 * point if not needed. The string is in <buffer> of length <len>, and the
555 * number is expected to start at or after position <num_start> (the first
556 * point appearing there is considered). A NUL character is always placed at
557 * the end if some trimming occurs. The new buffer length is returned.
558 */
559size_t flt_trim(char *buffer, size_t num_start, size_t len)
560{
561 char *end = buffer + len;
562 char *p = buffer + num_start;
563 char *trim;
564
565 do {
566 if (p >= end)
567 return len;
568 trim = p++;
569 } while (*trim != '.');
570
571 /* For now <trim> is on the decimal point. Let's look for any other
572 * meaningful digit after it.
573 */
574 while (p < end) {
575 if (*p++ != '0')
576 trim = p;
577 }
578
579 if (trim < end)
580 *trim = 0;
581
582 return trim - buffer;
583}
584
Willy Tarreauae03d262021-05-08 07:35:00 +0200585/*
586 * This function simply returns a locally allocated string containing
587 * the ascii representation for number 'n' in decimal with useless trailing
588 * zeroes trimmed.
589 */
590char *ftoa_r(double n, char *buffer, int size)
591{
592 flt_trim(buffer, 0, snprintf(buffer, size, "%f", n));
593 return buffer;
594}
595
Willy Tarreau588297f2014-06-16 15:16:40 +0200596/* returns a locally allocated string containing the quoted encoding of the
597 * input string. The output may be truncated to QSTR_SIZE chars, but it is
598 * guaranteed that the string will always be properly terminated. Quotes are
599 * encoded by doubling them as is commonly done in CSV files. QSTR_SIZE must
600 * always be at least 4 chars.
601 */
602const char *qstr(const char *str)
603{
604 char *ret = quoted_str[quoted_idx];
605 char *p, *end;
606
607 if (++quoted_idx >= NB_QSTR)
608 quoted_idx = 0;
609
610 p = ret;
611 end = ret + QSTR_SIZE;
612
613 *p++ = '"';
614
615 /* always keep 3 chars to support passing "" and the ending " */
616 while (*str && p < end - 3) {
617 if (*str == '"') {
618 *p++ = '"';
619 *p++ = '"';
620 }
621 else
622 *p++ = *str;
623 str++;
624 }
625 *p++ = '"';
626 return ret;
627}
628
Robert Tsai81ae1952007-12-05 10:47:29 +0100629/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200630 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
631 *
632 * It looks like this one would be a good candidate for inlining, but this is
633 * not interesting because it around 35 bytes long and often called multiple
634 * times within the same function.
635 */
636int ishex(char s)
637{
638 s -= '0';
639 if ((unsigned char)s <= 9)
640 return 1;
641 s -= 'A' - '0';
642 if ((unsigned char)s <= 5)
643 return 1;
644 s -= 'a' - 'A';
645 if ((unsigned char)s <= 5)
646 return 1;
647 return 0;
648}
649
Willy Tarreau3ca1a882015-01-15 18:43:49 +0100650/* rounds <i> down to the closest value having max 2 digits */
651unsigned int round_2dig(unsigned int i)
652{
653 unsigned int mul = 1;
654
655 while (i >= 100) {
656 i /= 10;
657 mul *= 10;
658 }
659 return i * mul;
660}
661
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100662/*
663 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
664 * invalid character is found, a pointer to it is returned. If everything is
665 * fine, NULL is returned.
666 */
667const char *invalid_char(const char *name)
668{
669 if (!*name)
670 return name;
671
672 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100673 if (!isalnum((unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100674 *name != '_' && *name != '-')
675 return name;
676 name++;
677 }
678 return NULL;
679}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200680
681/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200682 * Checks <name> for invalid characters. Valid chars are [_.-] and those
683 * accepted by <f> function.
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200684 * If an invalid character is found, a pointer to it is returned.
685 * If everything is fine, NULL is returned.
686 */
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200687static inline const char *__invalid_char(const char *name, int (*f)(int)) {
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200688
689 if (!*name)
690 return name;
691
692 while (*name) {
Willy Tarreau90807112020-02-25 08:16:33 +0100693 if (!f((unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200694 *name != '_' && *name != '-')
695 return name;
696
697 name++;
698 }
699
700 return NULL;
701}
702
703/*
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200704 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_.-].
705 * If an invalid character is found, a pointer to it is returned.
706 * If everything is fine, NULL is returned.
707 */
708const char *invalid_domainchar(const char *name) {
709 return __invalid_char(name, isalnum);
710}
711
712/*
713 * Checks <name> for invalid characters. Valid chars are [A-Za-z_.-].
714 * If an invalid character is found, a pointer to it is returned.
715 * If everything is fine, NULL is returned.
716 */
717const char *invalid_prefix_char(const char *name) {
Thierry Fournierf7b7c3e2018-03-26 11:54:39 +0200718 return __invalid_char(name, isalnum);
Frédéric Lécailleb82f7422017-04-13 18:24:23 +0200719}
720
721/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100722 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100723 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
724 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
725 * the function tries to guess the address family from the syntax. If the
726 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100727 * string is assumed to contain only an address, no port. The address can be a
728 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
729 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
730 * The return address will only have the address family and the address set,
731 * all other fields remain zero. The string is not supposed to be modified.
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100732 * The IPv6 '::' address is IN6ADDR_ANY. If <resolve> is non-zero, the hostname
733 * is resolved, otherwise only IP addresses are resolved, and anything else
Willy Tarreauecde7df2016-11-02 22:37:03 +0100734 * returns NULL. If the address contains a port, this one is preserved.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200735 */
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100736struct sockaddr_storage *str2ip2(const char *str, struct sockaddr_storage *sa, int resolve)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200737{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100738 struct hostent *he;
mildisff5d5102015-10-26 18:50:08 +0100739 /* max IPv6 length, including brackets and terminating NULL */
740 char tmpip[48];
Willy Tarreauecde7df2016-11-02 22:37:03 +0100741 int port = get_host_port(sa);
mildisff5d5102015-10-26 18:50:08 +0100742
743 /* check IPv6 with square brackets */
744 if (str[0] == '[') {
745 size_t iplength = strlen(str);
746
747 if (iplength < 4) {
748 /* minimal size is 4 when using brackets "[::]" */
749 goto fail;
750 }
751 else if (iplength >= sizeof(tmpip)) {
752 /* IPv6 literal can not be larger than tmpip */
753 goto fail;
754 }
755 else {
756 if (str[iplength - 1] != ']') {
757 /* if address started with bracket, it should end with bracket */
758 goto fail;
759 }
760 else {
761 memcpy(tmpip, str + 1, iplength - 2);
762 tmpip[iplength - 2] = '\0';
763 str = tmpip;
764 }
765 }
766 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100767
Willy Tarreaufab5a432011-03-04 15:31:53 +0100768 /* Any IPv6 address */
769 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100770 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
771 sa->ss_family = AF_INET6;
772 else if (sa->ss_family != AF_INET6)
773 goto fail;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100774 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100775 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100776 }
777
Willy Tarreau24709282013-03-10 21:32:12 +0100778 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100779 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100780 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
781 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100782 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100783 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100784 }
785
786 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100787 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
788 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100789 sa->ss_family = AF_INET6;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100790 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100791 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100792 }
793
794 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100795 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
796 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100797 sa->ss_family = AF_INET;
Willy Tarreauecde7df2016-11-02 22:37:03 +0100798 set_host_port(sa, port);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100799 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100800 }
801
Thierry FOURNIER58639a02014-11-25 12:02:25 +0100802 if (!resolve)
803 return NULL;
804
Emeric Brund30e9a12020-12-23 18:49:16 +0100805 if (!resolv_hostname_validation(str, NULL))
Baptiste Assmanna68ca962015-04-14 01:15:08 +0200806 return NULL;
807
David du Colombierd5f43282011-03-17 10:40:16 +0100808#ifdef USE_GETADDRINFO
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200809 if (global.tune.options & GTUNE_USE_GAI) {
David du Colombierd5f43282011-03-17 10:40:16 +0100810 struct addrinfo hints, *result;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100811 int success = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100812
813 memset(&result, 0, sizeof(result));
814 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100815 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100816 hints.ai_socktype = SOCK_DGRAM;
Dmitry Sivachenkoeab7f392015-10-02 01:01:58 +0200817 hints.ai_flags = 0;
David du Colombierd5f43282011-03-17 10:40:16 +0100818 hints.ai_protocol = 0;
819
820 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100821 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
822 sa->ss_family = result->ai_family;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100823 else if (sa->ss_family != result->ai_family) {
824 freeaddrinfo(result);
Willy Tarreau24709282013-03-10 21:32:12 +0100825 goto fail;
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100826 }
Willy Tarreau24709282013-03-10 21:32:12 +0100827
David du Colombierd5f43282011-03-17 10:40:16 +0100828 switch (result->ai_family) {
829 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100830 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100831 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100832 success = 1;
833 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100834 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100835 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100836 set_host_port(sa, port);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100837 success = 1;
838 break;
David du Colombierd5f43282011-03-17 10:40:16 +0100839 }
840 }
841
Sean Carey58ea0392013-02-15 23:39:18 +0100842 if (result)
843 freeaddrinfo(result);
Tim Duesterhus7d58b4d2018-01-21 22:11:17 +0100844
845 if (success)
846 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100847 }
David du Colombierd5f43282011-03-17 10:40:16 +0100848#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200849 /* try to resolve an IPv4/IPv6 hostname */
850 he = gethostbyname(str);
851 if (he) {
852 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
853 sa->ss_family = he->h_addrtype;
854 else if (sa->ss_family != he->h_addrtype)
855 goto fail;
856
857 switch (sa->ss_family) {
858 case AF_INET:
859 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100860 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200861 return sa;
862 case AF_INET6:
863 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
Willy Tarreauecde7df2016-11-02 22:37:03 +0100864 set_host_port(sa, port);
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200865 return sa;
866 }
867 }
868
David du Colombierd5f43282011-03-17 10:40:16 +0100869 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100870 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100871 return NULL;
872}
873
874/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100875 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
876 * range or offset consisting in two integers that the caller will have to
877 * check to find the relevant input format. The following format are supported :
878 *
879 * String format | address | port | low | high
880 * addr | <addr> | 0 | 0 | 0
881 * addr: | <addr> | 0 | 0 | 0
882 * addr:port | <addr> | <port> | <port> | <port>
883 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
884 * addr:+port | <addr> | <port> | 0 | <port>
885 * addr:-port | <addr> |-<port> | <port> | 0
886 *
887 * The detection of a port range or increment by the caller is made by
888 * comparing <low> and <high>. If both are equal, then port 0 means no port
889 * was specified. The caller may pass NULL for <low> and <high> if it is not
890 * interested in retrieving port ranges.
891 *
892 * Note that <addr> above may also be :
893 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
894 * - "*" => family will be AF_INET and address will be INADDR_ANY
895 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
896 * - a host name => family and address will depend on host name resolving.
897 *
Willy Tarreau24709282013-03-10 21:32:12 +0100898 * A prefix may be passed in before the address above to force the family :
899 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
900 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
901 * - "unix@" => force address to be a path to a UNIX socket even if the
902 * path does not start with a '/'
Willy Tarreauccfccef2014-05-10 01:49:15 +0200903 * - 'abns@' -> force address to belong to the abstract namespace (Linux
904 * only). These sockets are just like Unix sockets but without
905 * the need for an underlying file system. The address is a
906 * string. Technically it's like a Unix socket with a zero in
907 * the first byte of the address.
Willy Tarreau40aa0702013-03-10 23:51:38 +0100908 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100909 *
mildisff5d5102015-10-26 18:50:08 +0100910 * IPv6 addresses can be declared with or without square brackets. When using
911 * square brackets for IPv6 addresses, the port separator (colon) is optional.
912 * If not using square brackets, and in order to avoid any ambiguity with
913 * IPv6 addresses, the last colon ':' is mandatory even when no port is specified.
914 * NULL is returned if the address cannot be parsed. The <low> and <high> ports
915 * are always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100916 *
917 * If <pfx> is non-null, it is used as a string prefix before any path-based
918 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100919 *
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200920 * if <fqdn> is non-null, it will be filled with :
921 * - a pointer to the FQDN of the server name to resolve if there's one, and
922 * that the caller will have to free(),
923 * - NULL if there was an explicit address that doesn't require resolution.
924 *
Willy Tarreaucd3a55912020-09-04 15:30:46 +0200925 * Hostnames are only resolved if <opts> has PA_O_RESOLVE. Otherwise <fqdn> is
926 * still honored so it is possible for the caller to know whether a resolution
927 * failed by clearing this flag and checking if <fqdn> was filled, indicating
928 * the need for a resolution.
Thierry FOURNIER7fe3be72015-09-26 20:03:36 +0200929 *
Willy Tarreau40aa0702013-03-10 23:51:38 +0100930 * When a file descriptor is passed, its value is put into the s_addr part of
Willy Tarreaua5b325f2020-09-04 16:44:20 +0200931 * the address when cast to sockaddr_in and the address family is
932 * AF_CUST_EXISTING_FD.
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200933 *
Willy Tarreau5fc93282020-09-16 18:25:03 +0200934 * The matching protocol will be set into <proto> if non-null.
935 *
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200936 * Any known file descriptor is also assigned to <fd> if non-null, otherwise it
937 * is forced to -1.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100938 */
Willy Tarreau5fc93282020-09-16 18:25:03 +0200939struct sockaddr_storage *str2sa_range(const char *str, int *port, int *low, int *high, int *fd,
940 struct protocol **proto, char **err,
941 const char *pfx, char **fqdn, unsigned int opts)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100942{
Christopher Faulet1bc04c72017-10-29 20:14:08 +0100943 static THREAD_LOCAL struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100944 struct sockaddr_storage *ret = NULL;
Willy Tarreau5fc93282020-09-16 18:25:03 +0200945 struct protocol *new_proto = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100946 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100947 char *port1, *port2;
948 int portl, porth, porta;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200949 int abstract = 0;
Willy Tarreaua93e5c72020-09-15 14:01:16 +0200950 int new_fd = -1;
Willy Tarreaue3b45182021-10-27 17:28:55 +0200951 enum proto_type proto_type;
952 int ctrl_type;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100953
954 portl = porth = porta = 0;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +0200955 if (fqdn)
956 *fqdn = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200957
Willy Tarreaudad36a32013-03-11 01:20:04 +0100958 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100959 if (str2 == NULL) {
960 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100961 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100962 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200963
Willy Tarreau9f69f462015-09-08 16:01:25 +0200964 if (!*str2) {
965 memprintf(err, "'%s' resolves to an empty address (environment variable missing?)\n", str);
966 goto out;
967 }
968
Willy Tarreau24709282013-03-10 21:32:12 +0100969 memset(&ss, 0, sizeof(ss));
970
Willy Tarreaue835bd82020-09-16 11:35:47 +0200971 /* prepare the default socket types */
Willy Tarreauf23b1bc2021-03-23 18:36:37 +0100972 if ((opts & (PA_O_STREAM|PA_O_DGRAM)) == PA_O_DGRAM ||
Willy Tarreaue3b45182021-10-27 17:28:55 +0200973 ((opts & (PA_O_STREAM|PA_O_DGRAM)) == (PA_O_DGRAM|PA_O_STREAM) && (opts & PA_O_DEFAULT_DGRAM))) {
974 proto_type = PROTO_TYPE_DGRAM;
975 ctrl_type = SOCK_DGRAM;
976 } else {
977 proto_type = PROTO_TYPE_STREAM;
978 ctrl_type = SOCK_STREAM;
979 }
Willy Tarreaue835bd82020-09-16 11:35:47 +0200980
981 if (strncmp(str2, "stream+", 7) == 0) {
982 str2 += 7;
Willy Tarreaue3b45182021-10-27 17:28:55 +0200983 proto_type = PROTO_TYPE_STREAM;
984 ctrl_type = SOCK_STREAM;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200985 }
986 else if (strncmp(str2, "dgram+", 6) == 0) {
987 str2 += 6;
Willy Tarreaue3b45182021-10-27 17:28:55 +0200988 proto_type = PROTO_TYPE_DGRAM;
989 ctrl_type = SOCK_DGRAM;
Willy Tarreaue835bd82020-09-16 11:35:47 +0200990 }
991
Willy Tarreau24709282013-03-10 21:32:12 +0100992 if (strncmp(str2, "unix@", 5) == 0) {
993 str2 += 5;
Willy Tarreauccfccef2014-05-10 01:49:15 +0200994 abstract = 0;
Willy Tarreau24709282013-03-10 21:32:12 +0100995 ss.ss_family = AF_UNIX;
996 }
Emeric Brunce325c42021-04-02 17:05:09 +0200997 else if (strncmp(str2, "uxdg@", 5) == 0) {
998 str2 += 5;
999 abstract = 0;
1000 ss.ss_family = AF_UNIX;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001001 proto_type = PROTO_TYPE_DGRAM;
1002 ctrl_type = SOCK_DGRAM;
Emeric Brunce325c42021-04-02 17:05:09 +02001003 }
1004 else if (strncmp(str2, "uxst@", 5) == 0) {
1005 str2 += 5;
1006 abstract = 0;
1007 ss.ss_family = AF_UNIX;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001008 proto_type = PROTO_TYPE_STREAM;
1009 ctrl_type = SOCK_STREAM;
Emeric Brunce325c42021-04-02 17:05:09 +02001010 }
Willy Tarreauccfccef2014-05-10 01:49:15 +02001011 else if (strncmp(str2, "abns@", 5) == 0) {
1012 str2 += 5;
1013 abstract = 1;
1014 ss.ss_family = AF_UNIX;
1015 }
Emeric Brunce325c42021-04-02 17:05:09 +02001016 else if (strncmp(str2, "ip@", 3) == 0) {
1017 str2 += 3;
1018 ss.ss_family = AF_UNSPEC;
1019 }
Willy Tarreau24709282013-03-10 21:32:12 +01001020 else if (strncmp(str2, "ipv4@", 5) == 0) {
1021 str2 += 5;
1022 ss.ss_family = AF_INET;
1023 }
1024 else if (strncmp(str2, "ipv6@", 5) == 0) {
1025 str2 += 5;
1026 ss.ss_family = AF_INET6;
1027 }
Emeric Brunce325c42021-04-02 17:05:09 +02001028 else if (strncmp(str2, "tcp4@", 5) == 0) {
1029 str2 += 5;
1030 ss.ss_family = AF_INET;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001031 proto_type = PROTO_TYPE_STREAM;
1032 ctrl_type = SOCK_STREAM;
Emeric Brunce325c42021-04-02 17:05:09 +02001033 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001034 else if (strncmp(str2, "udp4@", 5) == 0) {
1035 str2 += 5;
1036 ss.ss_family = AF_INET;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001037 proto_type = PROTO_TYPE_DGRAM;
1038 ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001039 }
Emeric Brunce325c42021-04-02 17:05:09 +02001040 else if (strncmp(str2, "tcp6@", 5) == 0) {
1041 str2 += 5;
1042 ss.ss_family = AF_INET6;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001043 proto_type = PROTO_TYPE_STREAM;
1044 ctrl_type = SOCK_STREAM;
Emeric Brunce325c42021-04-02 17:05:09 +02001045 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001046 else if (strncmp(str2, "udp6@", 5) == 0) {
1047 str2 += 5;
1048 ss.ss_family = AF_INET6;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001049 proto_type = PROTO_TYPE_DGRAM;
1050 ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001051 }
Emeric Brunce325c42021-04-02 17:05:09 +02001052 else if (strncmp(str2, "tcp@", 4) == 0) {
1053 str2 += 4;
1054 ss.ss_family = AF_UNSPEC;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001055 proto_type = PROTO_TYPE_STREAM;
1056 ctrl_type = SOCK_STREAM;
Emeric Brunce325c42021-04-02 17:05:09 +02001057 }
Emeric Brun3835c0d2020-07-07 09:46:09 +02001058 else if (strncmp(str2, "udp@", 4) == 0) {
1059 str2 += 4;
1060 ss.ss_family = AF_UNSPEC;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001061 proto_type = PROTO_TYPE_DGRAM;
1062 ctrl_type = SOCK_DGRAM;
Emeric Brun3835c0d2020-07-07 09:46:09 +02001063 }
Frédéric Lécaille10caf652020-11-23 11:36:57 +01001064 else if (strncmp(str2, "quic4@", 6) == 0) {
1065 str2 += 6;
1066 ss.ss_family = AF_INET;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001067 proto_type = PROTO_TYPE_DGRAM;
Frédéric Lécaille10caf652020-11-23 11:36:57 +01001068 ctrl_type = SOCK_STREAM;
1069 }
1070 else if (strncmp(str2, "quic6@", 6) == 0) {
1071 str2 += 6;
1072 ss.ss_family = AF_INET6;
Willy Tarreaue3b45182021-10-27 17:28:55 +02001073 proto_type = PROTO_TYPE_DGRAM;
Frédéric Lécaille10caf652020-11-23 11:36:57 +01001074 ctrl_type = SOCK_STREAM;
1075 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001076 else if (strncmp(str2, "fd@", 3) == 0) {
1077 str2 += 3;
1078 ss.ss_family = AF_CUST_EXISTING_FD;
1079 }
1080 else if (strncmp(str2, "sockpair@", 9) == 0) {
1081 str2 += 9;
1082 ss.ss_family = AF_CUST_SOCKPAIR;
1083 }
Willy Tarreau24709282013-03-10 21:32:12 +01001084 else if (*str2 == '/') {
1085 ss.ss_family = AF_UNIX;
1086 }
1087 else
1088 ss.ss_family = AF_UNSPEC;
1089
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001090 if (ss.ss_family == AF_CUST_SOCKPAIR) {
Willy Tarreaua215be22020-09-16 10:14:16 +02001091 struct sockaddr_storage ss2;
1092 socklen_t addr_len;
William Lallemand2fe7dd02018-09-11 16:51:29 +02001093 char *endptr;
1094
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001095 new_fd = strtol(str2, &endptr, 10);
1096 if (!*str2 || new_fd < 0 || *endptr) {
William Lallemand2fe7dd02018-09-11 16:51:29 +02001097 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
1098 goto out;
1099 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001100
Willy Tarreaua215be22020-09-16 10:14:16 +02001101 /* just verify that it's a socket */
1102 addr_len = sizeof(ss2);
1103 if (getsockname(new_fd, (struct sockaddr *)&ss2, &addr_len) == -1) {
1104 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1105 goto out;
1106 }
1107
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001108 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1109 ((struct sockaddr_in *)&ss)->sin_port = 0;
William Lallemand2fe7dd02018-09-11 16:51:29 +02001110 }
Willy Tarreau5a7beed2020-09-04 16:54:05 +02001111 else if (ss.ss_family == AF_CUST_EXISTING_FD) {
Willy Tarreau40aa0702013-03-10 23:51:38 +01001112 char *endptr;
1113
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001114 new_fd = strtol(str2, &endptr, 10);
1115 if (!*str2 || new_fd < 0 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +01001116 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +01001117 goto out;
1118 }
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001119
Willy Tarreau6edc7222020-09-15 17:41:56 +02001120 if (opts & PA_O_SOCKET_FD) {
1121 socklen_t addr_len;
1122 int type;
1123
1124 addr_len = sizeof(ss);
1125 if (getsockname(new_fd, (struct sockaddr *)&ss, &addr_len) == -1) {
1126 memprintf(err, "cannot use file descriptor '%d' : %s.\n", new_fd, strerror(errno));
1127 goto out;
1128 }
1129
1130 addr_len = sizeof(type);
1131 if (getsockopt(new_fd, SOL_SOCKET, SO_TYPE, &type, &addr_len) != 0 ||
Willy Tarreaue3b45182021-10-27 17:28:55 +02001132 (type == SOCK_STREAM) != (proto_type == PROTO_TYPE_STREAM)) {
Willy Tarreau6edc7222020-09-15 17:41:56 +02001133 memprintf(err, "socket on file descriptor '%d' is of the wrong type.\n", new_fd);
1134 goto out;
1135 }
1136
1137 porta = portl = porth = get_host_port(&ss);
1138 } else if (opts & PA_O_RAW_FD) {
1139 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = new_fd;
1140 ((struct sockaddr_in *)&ss)->sin_port = 0;
1141 } else {
1142 memprintf(err, "a file descriptor is not acceptable here in '%s'\n", str);
1143 goto out;
1144 }
Willy Tarreau40aa0702013-03-10 23:51:38 +01001145 }
1146 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau8daa9202019-06-16 18:16:33 +02001147 struct sockaddr_un *un = (struct sockaddr_un *)&ss;
Willy Tarreau15586382013-03-04 19:48:14 +01001148 int prefix_path_len;
1149 int max_path_len;
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001150 int adr_len;
Willy Tarreau15586382013-03-04 19:48:14 +01001151
1152 /* complete unix socket path name during startup or soft-restart is
1153 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
1154 */
Willy Tarreauccfccef2014-05-10 01:49:15 +02001155 prefix_path_len = (pfx && !abstract) ? strlen(pfx) : 0;
Willy Tarreau8daa9202019-06-16 18:16:33 +02001156 max_path_len = (sizeof(un->sun_path) - 1) -
Willy Tarreau327ea5a2020-02-11 06:43:37 +01001157 (abstract ? 0 : prefix_path_len + 1 + 5 + 1 + 3);
Willy Tarreau15586382013-03-04 19:48:14 +01001158
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001159 adr_len = strlen(str2);
1160 if (adr_len > max_path_len) {
Willy Tarreau15586382013-03-04 19:48:14 +01001161 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
1162 goto out;
1163 }
1164
Willy Tarreauccfccef2014-05-10 01:49:15 +02001165 /* when abstract==1, we skip the first zero and copy all bytes except the trailing zero */
Willy Tarreau8daa9202019-06-16 18:16:33 +02001166 memset(un->sun_path, 0, sizeof(un->sun_path));
Willy Tarreau94ef3f32014-04-14 14:49:00 +02001167 if (prefix_path_len)
Willy Tarreau8daa9202019-06-16 18:16:33 +02001168 memcpy(un->sun_path, pfx, prefix_path_len);
1169 memcpy(un->sun_path + prefix_path_len + abstract, str2, adr_len + 1 - abstract);
Willy Tarreau15586382013-03-04 19:48:14 +01001170 }
Willy Tarreau24709282013-03-10 21:32:12 +01001171 else { /* IPv4 and IPv6 */
mildisff5d5102015-10-26 18:50:08 +01001172 char *end = str2 + strlen(str2);
1173 char *chr;
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001174
mildisff5d5102015-10-26 18:50:08 +01001175 /* search for : or ] whatever comes first */
1176 for (chr = end-1; chr > str2; chr--) {
1177 if (*chr == ']' || *chr == ':')
1178 break;
1179 }
1180
1181 if (*chr == ':') {
1182 /* Found a colon before a closing-bracket, must be a port separator.
1183 * This guarantee backward compatibility.
1184 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001185 if (!(opts & PA_O_PORT_OK)) {
1186 memprintf(err, "port specification not permitted here in '%s'", str);
1187 goto out;
1188 }
mildisff5d5102015-10-26 18:50:08 +01001189 *chr++ = '\0';
1190 port1 = chr;
1191 }
1192 else {
1193 /* Either no colon and no closing-bracket
1194 * or directly ending with a closing-bracket.
1195 * However, no port.
1196 */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001197 if (opts & PA_O_PORT_MAND) {
1198 memprintf(err, "missing port specification in '%s'", str);
1199 goto out;
1200 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001201 port1 = "";
mildisff5d5102015-10-26 18:50:08 +01001202 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001203
Willy Tarreau90807112020-02-25 08:16:33 +01001204 if (isdigit((unsigned char)*port1)) { /* single port or range */
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001205 port2 = strchr(port1, '-');
Willy Tarreau7f96a842020-09-15 11:12:44 +02001206 if (port2) {
1207 if (!(opts & PA_O_PORT_RANGE)) {
1208 memprintf(err, "port range not permitted here in '%s'", str);
1209 goto out;
1210 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001211 *port2++ = '\0';
Willy Tarreau7f96a842020-09-15 11:12:44 +02001212 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001213 else
1214 port2 = port1;
1215 portl = atoi(port1);
1216 porth = atoi(port2);
Willy Tarreau7f96a842020-09-15 11:12:44 +02001217
1218 if (portl < !!(opts & PA_O_PORT_MAND) || portl > 65535) {
1219 memprintf(err, "invalid port '%s'", port1);
1220 goto out;
1221 }
1222
1223 if (porth < !!(opts & PA_O_PORT_MAND) || porth > 65535) {
1224 memprintf(err, "invalid port '%s'", port2);
1225 goto out;
1226 }
1227
1228 if (portl > porth) {
1229 memprintf(err, "invalid port range '%d-%d'", portl, porth);
1230 goto out;
1231 }
1232
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001233 porta = portl;
1234 }
1235 else if (*port1 == '-') { /* negative offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001236 if (!(opts & PA_O_PORT_OFS)) {
1237 memprintf(err, "port offset not permitted here in '%s'", str);
1238 goto out;
1239 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001240 portl = atoi(port1 + 1);
1241 porta = -portl;
1242 }
1243 else if (*port1 == '+') { /* positive offset */
Willy Tarreau7f96a842020-09-15 11:12:44 +02001244 if (!(opts & PA_O_PORT_OFS)) {
1245 memprintf(err, "port offset not permitted here in '%s'", str);
1246 goto out;
1247 }
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001248 porth = atoi(port1 + 1);
1249 porta = porth;
1250 }
1251 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +01001252 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001253 goto out;
1254 }
Willy Tarreau7f96a842020-09-15 11:12:44 +02001255 else if (opts & PA_O_PORT_MAND) {
1256 memprintf(err, "missing port specification in '%s'", str);
1257 goto out;
1258 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001259
1260 /* first try to parse the IP without resolving. If it fails, it
1261 * tells us we need to keep a copy of the FQDN to resolve later
1262 * and to enable DNS. In this case we can proceed if <fqdn> is
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001263 * set or if PA_O_RESOLVE is set, otherwise it's an error.
Willy Tarreauceccdd72016-11-02 22:27:10 +01001264 */
1265 if (str2ip2(str2, &ss, 0) == NULL) {
Willy Tarreaucd3a55912020-09-04 15:30:46 +02001266 if ((!(opts & PA_O_RESOLVE) && !fqdn) ||
1267 ((opts & PA_O_RESOLVE) && str2ip2(str2, &ss, 1) == NULL)) {
Willy Tarreauceccdd72016-11-02 22:27:10 +01001268 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
1269 goto out;
1270 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001271
Willy Tarreauceccdd72016-11-02 22:27:10 +01001272 if (fqdn) {
1273 if (str2 != back)
1274 memmove(back, str2, strlen(str2) + 1);
1275 *fqdn = back;
1276 back = NULL;
1277 }
Willy Tarreau72b8c1f2015-09-08 15:50:19 +02001278 }
Willy Tarreauceccdd72016-11-02 22:27:10 +01001279 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +01001280 }
Willy Tarreaufab5a432011-03-04 15:31:53 +01001281
Willy Tarreaue835bd82020-09-16 11:35:47 +02001282 if (ctrl_type == SOCK_STREAM && !(opts & PA_O_STREAM)) {
Willy Tarreau8d31ab02022-05-09 16:18:26 +02001283 memprintf(err, "stream-type address not acceptable in '%s'\n", str);
Willy Tarreaue835bd82020-09-16 11:35:47 +02001284 goto out;
1285 }
1286 else if (ctrl_type == SOCK_DGRAM && !(opts & PA_O_DGRAM)) {
Willy Tarreau8d31ab02022-05-09 16:18:26 +02001287 memprintf(err, "dgram-type address not acceptable in '%s'\n", str);
Willy Tarreaue835bd82020-09-16 11:35:47 +02001288 goto out;
1289 }
1290
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001291 if (proto || (opts & PA_O_CONNECT)) {
Willy Tarreau5fc93282020-09-16 18:25:03 +02001292 /* Note: if the caller asks for a proto, we must find one,
Emeric Brun26754902021-04-07 14:26:44 +02001293 * except if we inherit from a raw FD (family == AF_CUST_EXISTING_FD)
1294 * orif we return with an fqdn that will resolve later,
Willy Tarreau5fc93282020-09-16 18:25:03 +02001295 * in which case the address is not known yet (this is only
1296 * for servers actually).
1297 */
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001298 new_proto = protocol_lookup(ss.ss_family,
Willy Tarreaue3b45182021-10-27 17:28:55 +02001299 proto_type,
Willy Tarreauaf9609b2020-09-16 22:04:46 +02001300 ctrl_type == SOCK_DGRAM);
Willy Tarreaub2ffc992020-09-16 21:37:31 +02001301
Emeric Brun26754902021-04-07 14:26:44 +02001302 if (!new_proto && (!fqdn || !*fqdn) && (ss.ss_family != AF_CUST_EXISTING_FD)) {
Willy Tarreau3d7b4682022-05-20 17:32:35 +02001303 memprintf(err, "unsupported %s protocol for %s family %d address '%s'%s",
Willy Tarreau2b049b82022-05-20 17:28:30 +02001304 (ctrl_type == SOCK_DGRAM) ? "datagram" : "stream",
1305 (proto_type == PROTO_TYPE_DGRAM) ? "datagram" : "stream",
1306 ss.ss_family,
Willy Tarreau3d7b4682022-05-20 17:32:35 +02001307 str,
Willy Tarreau3d7b4682022-05-20 17:32:35 +02001308#ifndef USE_QUIC
Tim Duesterhus147eeb22022-05-22 12:40:58 +02001309 (ctrl_type == SOCK_STREAM && proto_type == PROTO_TYPE_DGRAM)
1310 ? "; QUIC is not compiled in if this is what you were looking for."
1311 : ""
Willy Tarreau3d7b4682022-05-20 17:32:35 +02001312#else
1313 ""
1314#endif
Tim Duesterhus147eeb22022-05-22 12:40:58 +02001315 );
Willy Tarreau5fc93282020-09-16 18:25:03 +02001316 goto out;
1317 }
Willy Tarreau65ec4e32020-09-16 19:17:08 +02001318
1319 if ((opts & PA_O_CONNECT) && new_proto && !new_proto->connect) {
1320 memprintf(err, "connect() not supported for this protocol family %d used by address '%s'", ss.ss_family, str);
1321 goto out;
1322 }
Willy Tarreau5fc93282020-09-16 18:25:03 +02001323 }
1324
Willy Tarreauc120c8d2013-03-10 19:27:44 +01001325 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +01001326 out:
Willy Tarreau48ef4c92017-01-06 18:32:38 +01001327 if (port)
1328 *port = porta;
Willy Tarreaud4448bc2013-02-20 15:55:15 +01001329 if (low)
1330 *low = portl;
1331 if (high)
1332 *high = porth;
Willy Tarreaua93e5c72020-09-15 14:01:16 +02001333 if (fd)
1334 *fd = new_fd;
Willy Tarreau5fc93282020-09-16 18:25:03 +02001335 if (proto)
1336 *proto = new_proto;
Willy Tarreau24709282013-03-10 21:32:12 +01001337 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +01001338 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001339}
1340
Thayne McCombs92149f92020-11-20 01:28:26 -07001341/* converts <addr> and <port> into a string representation of the address and port. This is sort
1342 * of an inverse of str2sa_range, with some restrictions. The supported families are AF_INET,
1343 * AF_INET6, AF_UNIX, and AF_CUST_SOCKPAIR. If the family is unsopported NULL is returned.
1344 * If map_ports is true, then the sign of the port is included in the output, to indicate it is
1345 * relative to the incoming port. AF_INET and AF_INET6 will be in the form "<addr>:<port>".
1346 * AF_UNIX will either be just the path (if using a pathname) or "abns@<path>" if it is abstract.
1347 * AF_CUST_SOCKPAIR will be of the form "sockpair@<fd>".
1348 *
1349 * The returned char* is allocated, and it is the responsibility of the caller to free it.
1350 */
1351char * sa2str(const struct sockaddr_storage *addr, int port, int map_ports)
1352{
1353 char buffer[INET6_ADDRSTRLEN];
1354 char *out = NULL;
1355 const void *ptr;
1356 const char *path;
1357
1358 switch (addr->ss_family) {
1359 case AF_INET:
1360 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1361 break;
1362 case AF_INET6:
1363 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1364 break;
1365 case AF_UNIX:
1366 path = ((struct sockaddr_un *)addr)->sun_path;
1367 if (path[0] == '\0') {
1368 const int max_length = sizeof(struct sockaddr_un) - offsetof(struct sockaddr_un, sun_path) - 1;
1369 return memprintf(&out, "abns@%.*s", max_length, path+1);
1370 } else {
1371 return strdup(path);
1372 }
1373 case AF_CUST_SOCKPAIR:
1374 return memprintf(&out, "sockpair@%d", ((struct sockaddr_in *)addr)->sin_addr.s_addr);
1375 default:
1376 return NULL;
1377 }
Tim Duesterhus22535a52022-05-23 09:30:49 +02001378 if (inet_ntop(addr->ss_family, ptr, buffer, sizeof(buffer)) == NULL) {
1379 BUG_ON(errno == ENOSPC);
1380 return NULL;
1381 }
Thayne McCombs92149f92020-11-20 01:28:26 -07001382 if (map_ports)
1383 return memprintf(&out, "%s:%+d", buffer, port);
1384 else
1385 return memprintf(&out, "%s:%d", buffer, port);
1386}
1387
1388
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001389/* converts <str> to a struct in_addr containing a network mask. It can be
1390 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
Jarno Huuskonen577d5ac2017-05-21 17:32:21 +03001391 * if the conversion succeeds otherwise zero.
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001392 */
1393int str2mask(const char *str, struct in_addr *mask)
1394{
1395 if (strchr(str, '.') != NULL) { /* dotted notation */
1396 if (!inet_pton(AF_INET, str, mask))
1397 return 0;
1398 }
1399 else { /* mask length */
1400 char *err;
1401 unsigned long len = strtol(str, &err, 10);
1402
1403 if (!*str || (err && *err) || (unsigned)len > 32)
1404 return 0;
Tim Duesterhus8575f722018-01-25 16:24:48 +01001405
1406 len2mask4(len, mask);
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001407 }
1408 return 1;
1409}
1410
Tim Duesterhus47185172018-01-25 16:24:49 +01001411/* converts <str> to a struct in6_addr containing a network mask. It can be
Tim Duesterhus5e642862018-02-20 17:02:18 +01001412 * passed in quadruplet form (ffff:ffff::) or in CIDR form (64). It returns 1
Tim Duesterhus47185172018-01-25 16:24:49 +01001413 * if the conversion succeeds otherwise zero.
1414 */
1415int str2mask6(const char *str, struct in6_addr *mask)
1416{
1417 if (strchr(str, ':') != NULL) { /* quadruplet notation */
1418 if (!inet_pton(AF_INET6, str, mask))
1419 return 0;
1420 }
1421 else { /* mask length */
1422 char *err;
1423 unsigned long len = strtol(str, &err, 10);
1424
1425 if (!*str || (err && *err) || (unsigned)len > 128)
1426 return 0;
1427
1428 len2mask6(len, mask);
1429 }
1430 return 1;
1431}
1432
Thierry FOURNIERb0504632013-12-14 15:39:02 +01001433/* convert <cidr> to struct in_addr <mask>. It returns 1 if the conversion
1434 * succeeds otherwise zero.
1435 */
1436int cidr2dotted(int cidr, struct in_addr *mask) {
1437
1438 if (cidr < 0 || cidr > 32)
1439 return 0;
1440
1441 mask->s_addr = cidr ? htonl(~0UL << (32 - cidr)) : 0;
1442 return 1;
1443}
1444
Thierry Fournier70473a52016-02-17 17:12:14 +01001445/* Convert mask from bit length form to in_addr form.
1446 * This function never fails.
1447 */
1448void len2mask4(int len, struct in_addr *addr)
1449{
1450 if (len >= 32) {
1451 addr->s_addr = 0xffffffff;
1452 return;
1453 }
1454 if (len <= 0) {
1455 addr->s_addr = 0x00000000;
1456 return;
1457 }
1458 addr->s_addr = 0xffffffff << (32 - len);
1459 addr->s_addr = htonl(addr->s_addr);
1460}
1461
1462/* Convert mask from bit length form to in6_addr form.
1463 * This function never fails.
1464 */
1465void len2mask6(int len, struct in6_addr *addr)
1466{
1467 len2mask4(len, (struct in_addr *)&addr->s6_addr[0]); /* msb */
1468 len -= 32;
1469 len2mask4(len, (struct in_addr *)&addr->s6_addr[4]);
1470 len -= 32;
1471 len2mask4(len, (struct in_addr *)&addr->s6_addr[8]);
1472 len -= 32;
1473 len2mask4(len, (struct in_addr *)&addr->s6_addr[12]); /* lsb */
1474}
1475
Willy Tarreauc6f4ce82009-06-10 11:09:37 +02001476/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +02001477 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001478 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001479 * is optional and either in the dotted or CIDR notation.
Willy Tarreaubaaee002006-06-26 02:48:02 +02001480 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
1481 */
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001482int str2net(const char *str, int resolve, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001483{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001484 __label__ out_free, out_err;
1485 char *c, *s;
1486 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001487
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001488 s = strdup(str);
1489 if (!s)
1490 return 0;
1491
Willy Tarreaubaaee002006-06-26 02:48:02 +02001492 memset(mask, 0, sizeof(*mask));
1493 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001494
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001495 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001496 *c++ = '\0';
1497 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +01001498 if (!str2mask(c, mask))
1499 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001500 }
1501 else {
Willy Tarreauebd61602006-12-30 11:54:15 +01001502 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001503 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001504 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02001505 struct hostent *he;
1506
Thierry FOURNIERfc7ac7b2014-02-11 15:23:04 +01001507 if (!resolve)
1508 goto out_err;
1509
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001510 if ((he = gethostbyname(s)) == NULL) {
1511 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001512 }
1513 else
1514 *addr = *(struct in_addr *) *(he->h_addr_list);
1515 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +02001516
1517 ret_val = 1;
1518 out_free:
1519 free(s);
1520 return ret_val;
1521 out_err:
1522 ret_val = 0;
1523 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001524}
1525
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001526
1527/*
Willy Tarreau6d20e282012-04-27 22:49:47 +02001528 * converts <str> to two struct in6_addr* which must be pre-allocated.
1529 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001530 * is an optional number of bits (128 being the default).
Willy Tarreau6d20e282012-04-27 22:49:47 +02001531 * Returns 1 if OK, 0 if error.
1532 */
1533int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
1534{
1535 char *c, *s;
1536 int ret_val = 0;
1537 char *err;
1538 unsigned long len = 128;
1539
1540 s = strdup(str);
1541 if (!s)
1542 return 0;
1543
1544 memset(mask, 0, sizeof(*mask));
1545 memset(addr, 0, sizeof(*addr));
1546
1547 if ((c = strrchr(s, '/')) != NULL) {
1548 *c++ = '\0'; /* c points to the mask */
1549 if (!*c)
1550 goto out_free;
1551
1552 len = strtoul(c, &err, 10);
1553 if ((err && *err) || (unsigned)len > 128)
1554 goto out_free;
1555 }
1556 *mask = len; /* OK we have a valid mask in <len> */
1557
1558 if (!inet_pton(AF_INET6, s, addr))
1559 goto out_free;
1560
1561 ret_val = 1;
1562 out_free:
1563 free(s);
1564 return ret_val;
1565}
1566
1567
1568/*
Willy Tarreau12e10272021-03-25 11:34:40 +01001569 * Parse IPv4 address found in url. Return the number of bytes parsed. It
1570 * expects exactly 4 numbers between 0 and 255 delimited by dots, and returns
1571 * zero in case of mismatch.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001572 */
David du Colombier6f5ccb12011-03-10 22:26:24 +01001573int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001574{
1575 int saw_digit, octets, ch;
1576 u_char tmp[4], *tp;
1577 const char *cp = addr;
1578
1579 saw_digit = 0;
1580 octets = 0;
1581 *(tp = tmp) = 0;
1582
1583 while (*addr) {
Willy Tarreau12e10272021-03-25 11:34:40 +01001584 unsigned char digit = (ch = *addr) - '0';
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001585 if (digit > 9 && ch != '.')
1586 break;
Willy Tarreau12e10272021-03-25 11:34:40 +01001587 addr++;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001588 if (digit <= 9) {
1589 u_int new = *tp * 10 + digit;
1590 if (new > 255)
1591 return 0;
1592 *tp = new;
1593 if (!saw_digit) {
1594 if (++octets > 4)
1595 return 0;
1596 saw_digit = 1;
1597 }
1598 } else if (ch == '.' && saw_digit) {
1599 if (octets == 4)
1600 return 0;
1601 *++tp = 0;
1602 saw_digit = 0;
1603 } else
1604 return 0;
1605 }
1606
1607 if (octets < 4)
1608 return 0;
1609
1610 memcpy(&dst->s_addr, tmp, 4);
Willy Tarreau12e10272021-03-25 11:34:40 +01001611 return addr - cp;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001612}
1613
1614/*
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001615 * Resolve destination server from URL. Convert <str> to a sockaddr_storage.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05001616 * <out> contain the code of the detected scheme, the start and length of
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001617 * the hostname. Actually only http and https are supported. <out> can be NULL.
1618 * This function returns the consumed length. It is useful if you parse complete
1619 * url like http://host:port/path, because the consumed length corresponds to
1620 * the first character of the path. If the conversion fails, it returns -1.
1621 *
1622 * This function tries to resolve the DNS name if haproxy is in starting mode.
1623 * So, this function may be used during the configuration parsing.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001624 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001625int url2sa(const char *url, int ulen, struct sockaddr_storage *addr, struct split_url *out)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001626{
1627 const char *curr = url, *cp = url;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001628 const char *end;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001629 int ret, url_code = 0;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001630 unsigned long long int http_code = 0;
1631 int default_port;
1632 struct hostent *he;
1633 char *p;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001634
1635 /* Firstly, try to find :// pattern */
1636 while (curr < url+ulen && url_code != 0x3a2f2f) {
1637 url_code = ((url_code & 0xffff) << 8);
1638 url_code += (unsigned char)*curr++;
1639 }
1640
1641 /* Secondly, if :// pattern is found, verify parsed stuff
1642 * before pattern is matching our http pattern.
1643 * If so parse ip address and port in uri.
1644 *
1645 * WARNING: Current code doesn't support dynamic async dns resolver.
1646 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001647 if (url_code != 0x3a2f2f)
1648 return -1;
1649
1650 /* Copy scheme, and utrn to lower case. */
1651 while (cp < curr - 3)
1652 http_code = (http_code << 8) + *cp++;
1653 http_code |= 0x2020202020202020ULL; /* Turn everything to lower case */
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001654
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001655 /* HTTP or HTTPS url matching */
1656 if (http_code == 0x2020202068747470ULL) {
1657 default_port = 80;
1658 if (out)
1659 out->scheme = SCH_HTTP;
1660 }
1661 else if (http_code == 0x2020206874747073ULL) {
1662 default_port = 443;
1663 if (out)
1664 out->scheme = SCH_HTTPS;
1665 }
1666 else
1667 return -1;
1668
1669 /* If the next char is '[', the host address is IPv6. */
1670 if (*curr == '[') {
1671 curr++;
1672
1673 /* Check trash size */
1674 if (trash.size < ulen)
1675 return -1;
1676
1677 /* Look for ']' and copy the address in a trash buffer. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001678 p = trash.area;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001679 for (end = curr;
1680 end < url + ulen && *end != ']';
1681 end++, p++)
1682 *p = *end;
1683 if (*end != ']')
1684 return -1;
1685 *p = '\0';
1686
1687 /* Update out. */
1688 if (out) {
1689 out->host = curr;
1690 out->host_len = end - curr;
1691 }
1692
1693 /* Try IPv6 decoding. */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001694 if (!inet_pton(AF_INET6, trash.area, &((struct sockaddr_in6 *)addr)->sin6_addr))
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001695 return -1;
1696 end++;
1697
1698 /* Decode port. */
William Lallemand3d7a9182022-03-25 17:37:51 +01001699 if (end < url + ulen && *end == ':') {
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001700 end++;
1701 default_port = read_uint(&end, url + ulen);
1702 }
1703 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1704 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1705 return end - url;
1706 }
1707 else {
William Lallemand8a913742022-02-18 16:13:12 +01001708 /* we need to copy the string into the trash because url2ipv4
1709 * needs a \0 at the end of the string */
1710 if (trash.size < ulen)
1711 return -1;
1712
1713 memcpy(trash.area, curr, ulen - (curr - url));
1714 trash.area[ulen - (curr - url)] = '\0';
1715
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001716 /* We are looking for IP address. If you want to parse and
1717 * resolve hostname found in url, you can use str2sa_range(), but
1718 * be warned this can slow down global daemon performances
1719 * while handling lagging dns responses.
1720 */
William Lallemand8a913742022-02-18 16:13:12 +01001721 ret = url2ipv4(trash.area, &((struct sockaddr_in *)addr)->sin_addr);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001722 if (ret) {
1723 /* Update out. */
1724 if (out) {
1725 out->host = curr;
1726 out->host_len = ret;
1727 }
1728
William Lallemandb938b772022-03-24 21:59:03 +01001729 curr += ret;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001730
1731 /* Decode port. */
William Lallemand3d7a9182022-03-25 17:37:51 +01001732 if (curr < url + ulen && *curr == ':') {
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001733 curr++;
1734 default_port = read_uint(&curr, url + ulen);
1735 }
1736 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1737
1738 /* Set family. */
1739 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1740 return curr - url;
1741 }
1742 else if (global.mode & MODE_STARTING) {
1743 /* The IPv4 and IPv6 decoding fails, maybe the url contain name. Try to execute
1744 * synchronous DNS request only if HAProxy is in the start state.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001745 */
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001746
1747 /* look for : or / or end */
1748 for (end = curr;
1749 end < url + ulen && *end != '/' && *end != ':';
1750 end++);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001751 memcpy(trash.area, curr, end - curr);
1752 trash.area[end - curr] = '\0';
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001753
1754 /* try to resolve an IPv4/IPv6 hostname */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001755 he = gethostbyname(trash.area);
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001756 if (!he)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001757 return -1;
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001758
1759 /* Update out. */
1760 if (out) {
1761 out->host = curr;
1762 out->host_len = end - curr;
1763 }
1764
1765 /* Decode port. */
William Lallemand3d7a9182022-03-25 17:37:51 +01001766 if (end < url + ulen && *end == ':') {
Thierry FOURNIER9f95e402014-03-21 14:51:46 +01001767 end++;
1768 default_port = read_uint(&end, url + ulen);
1769 }
1770
1771 /* Copy IP address, set port and family. */
1772 switch (he->h_addrtype) {
1773 case AF_INET:
1774 ((struct sockaddr_in *)addr)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
1775 ((struct sockaddr_in *)addr)->sin_port = htons(default_port);
1776 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
1777 return end - url;
1778
1779 case AF_INET6:
1780 ((struct sockaddr_in6 *)addr)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
1781 ((struct sockaddr_in6 *)addr)->sin6_port = htons(default_port);
1782 ((struct sockaddr_in6 *)addr)->sin6_family = AF_INET6;
1783 return end - url;
1784 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001785 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001786 }
Alexandre Cassen5eb1a902007-11-29 15:43:32 +01001787 return -1;
1788}
1789
Willy Tarreau631f01c2011-09-05 00:36:48 +02001790/* Tries to convert a sockaddr_storage address to text form. Upon success, the
1791 * address family is returned so that it's easy for the caller to adapt to the
1792 * output format. Zero is returned if the address family is not supported. -1
1793 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1794 * supported.
1795 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001796int addr_to_str(const struct sockaddr_storage *addr, char *str, int size)
Willy Tarreau631f01c2011-09-05 00:36:48 +02001797{
1798
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001799 const void *ptr;
Willy Tarreau631f01c2011-09-05 00:36:48 +02001800
1801 if (size < 5)
1802 return 0;
1803 *str = '\0';
1804
1805 switch (addr->ss_family) {
1806 case AF_INET:
1807 ptr = &((struct sockaddr_in *)addr)->sin_addr;
1808 break;
1809 case AF_INET6:
1810 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
1811 break;
1812 case AF_UNIX:
1813 memcpy(str, "unix", 5);
1814 return addr->ss_family;
1815 default:
1816 return 0;
1817 }
1818
1819 if (inet_ntop(addr->ss_family, ptr, str, size))
1820 return addr->ss_family;
1821
1822 /* failed */
1823 return -1;
1824}
1825
Simon Horman75ab8bd2014-06-16 09:39:41 +09001826/* Tries to convert a sockaddr_storage port to text form. Upon success, the
1827 * address family is returned so that it's easy for the caller to adapt to the
1828 * output format. Zero is returned if the address family is not supported. -1
1829 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
1830 * supported.
1831 */
Willy Tarreaud5ec4bf2019-04-25 17:48:16 +02001832int port_to_str(const struct sockaddr_storage *addr, char *str, int size)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001833{
1834
1835 uint16_t port;
1836
1837
Willy Tarreaud7dad1b2017-01-06 16:46:22 +01001838 if (size < 6)
Simon Horman75ab8bd2014-06-16 09:39:41 +09001839 return 0;
1840 *str = '\0';
1841
1842 switch (addr->ss_family) {
1843 case AF_INET:
1844 port = ((struct sockaddr_in *)addr)->sin_port;
1845 break;
1846 case AF_INET6:
1847 port = ((struct sockaddr_in6 *)addr)->sin6_port;
1848 break;
1849 case AF_UNIX:
1850 memcpy(str, "unix", 5);
1851 return addr->ss_family;
1852 default:
1853 return 0;
1854 }
1855
1856 snprintf(str, size, "%u", ntohs(port));
1857 return addr->ss_family;
1858}
1859
Willy Tarreau16e01562016-08-09 16:46:18 +02001860/* check if the given address is local to the system or not. It will return
1861 * -1 when it's not possible to know, 0 when the address is not local, 1 when
1862 * it is. We don't want to iterate over all interfaces for this (and it is not
1863 * portable). So instead we try to bind in UDP to this address on a free non
1864 * privileged port and to connect to the same address, port 0 (connect doesn't
1865 * care). If it succeeds, we own the address. Note that non-inet addresses are
1866 * considered local since they're most likely AF_UNIX.
1867 */
1868int addr_is_local(const struct netns_entry *ns,
1869 const struct sockaddr_storage *orig)
1870{
1871 struct sockaddr_storage addr;
1872 int result;
1873 int fd;
1874
1875 if (!is_inet_addr(orig))
1876 return 1;
1877
1878 memcpy(&addr, orig, sizeof(addr));
1879 set_host_port(&addr, 0);
1880
1881 fd = my_socketat(ns, addr.ss_family, SOCK_DGRAM, IPPROTO_UDP);
1882 if (fd < 0)
1883 return -1;
1884
1885 result = -1;
1886 if (bind(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == 0) {
1887 if (connect(fd, (struct sockaddr *)&addr, get_addr_len(&addr)) == -1)
1888 result = 0; // fail, non-local address
1889 else
1890 result = 1; // success, local address
1891 }
1892 else {
1893 if (errno == EADDRNOTAVAIL)
1894 result = 0; // definitely not local :-)
1895 }
1896 close(fd);
1897
1898 return result;
1899}
1900
Willy Tarreaubaaee002006-06-26 02:48:02 +02001901/* will try to encode the string <string> replacing all characters tagged in
1902 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1903 * prefixed by <escape>, and will store the result between <start> (included)
1904 * and <stop> (excluded), and will always terminate the string with a '\0'
1905 * before <stop>. The position of the '\0' is returned if the conversion
1906 * completes. If bytes are missing between <start> and <stop>, then the
1907 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1908 * cannot even be stored so we return <start> without writing the 0.
1909 * The input string must also be zero-terminated.
1910 */
1911const char hextab[16] = "0123456789ABCDEF";
1912char *encode_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001913 const char escape, const long *map,
Willy Tarreaubaaee002006-06-26 02:48:02 +02001914 const char *string)
1915{
1916 if (start < stop) {
1917 stop--; /* reserve one byte for the final '\0' */
1918 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001919 if (!ha_bit_test((unsigned char)(*string), map))
Willy Tarreaubaaee002006-06-26 02:48:02 +02001920 *start++ = *string;
1921 else {
1922 if (start + 3 >= stop)
1923 break;
1924 *start++ = escape;
1925 *start++ = hextab[(*string >> 4) & 15];
1926 *start++ = hextab[*string & 15];
1927 }
1928 string++;
1929 }
1930 *start = '\0';
1931 }
1932 return start;
1933}
1934
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001935/*
1936 * Same behavior as encode_string() above, except that it encodes chunk
1937 * <chunk> instead of a string.
1938 */
1939char *encode_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001940 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02001941 const struct buffer *chunk)
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001942{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001943 char *str = chunk->area;
1944 char *end = chunk->area + chunk->data;
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001945
1946 if (start < stop) {
1947 stop--; /* reserve one byte for the final '\0' */
1948 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001949 if (!ha_bit_test((unsigned char)(*str), map))
Thierry FOURNIERe059ec92014-03-17 12:01:13 +01001950 *start++ = *str;
1951 else {
1952 if (start + 3 >= stop)
1953 break;
1954 *start++ = escape;
1955 *start++ = hextab[(*str >> 4) & 15];
1956 *start++ = hextab[*str & 15];
1957 }
1958 str++;
1959 }
1960 *start = '\0';
1961 }
1962 return start;
1963}
1964
Dragan Dosen0edd1092016-02-12 13:23:02 +01001965/*
1966 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001967 * character. The input <string> must be zero-terminated. The result will
1968 * be stored between <start> (included) and <stop> (excluded). This
1969 * function will always try to terminate the resulting string with a '\0'
1970 * before <stop>, and will return its position if the conversion
1971 * completes.
1972 */
1973char *escape_string(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001974 const char escape, const long *map,
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001975 const char *string)
1976{
1977 if (start < stop) {
1978 stop--; /* reserve one byte for the final '\0' */
1979 while (start < stop && *string != '\0') {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02001980 if (!ha_bit_test((unsigned char)(*string), map))
Dragan Dosen1a5d0602016-07-22 16:00:31 +02001981 *start++ = *string;
1982 else {
1983 if (start + 2 >= stop)
1984 break;
1985 *start++ = escape;
1986 *start++ = *string;
1987 }
1988 string++;
1989 }
1990 *start = '\0';
1991 }
1992 return start;
1993}
1994
1995/*
1996 * Tries to prefix characters tagged in the <map> with the <escape>
Dragan Dosen0edd1092016-02-12 13:23:02 +01001997 * character. <chunk> contains the input to be escaped. The result will be
1998 * stored between <start> (included) and <stop> (excluded). The function
1999 * will always try to terminate the resulting string with a '\0' before
2000 * <stop>, and will return its position if the conversion completes.
2001 */
2002char *escape_chunk(char *start, char *stop,
Willy Tarreau1bfd6022019-06-07 11:10:07 +02002003 const char escape, const long *map,
Willy Tarreau83061a82018-07-13 11:56:34 +02002004 const struct buffer *chunk)
Dragan Dosen0edd1092016-02-12 13:23:02 +01002005{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002006 char *str = chunk->area;
2007 char *end = chunk->area + chunk->data;
Dragan Dosen0edd1092016-02-12 13:23:02 +01002008
2009 if (start < stop) {
2010 stop--; /* reserve one byte for the final '\0' */
2011 while (start < stop && str < end) {
Willy Tarreau1bfd6022019-06-07 11:10:07 +02002012 if (!ha_bit_test((unsigned char)(*str), map))
Dragan Dosen0edd1092016-02-12 13:23:02 +01002013 *start++ = *str;
2014 else {
2015 if (start + 2 >= stop)
2016 break;
2017 *start++ = escape;
2018 *start++ = *str;
2019 }
2020 str++;
2021 }
2022 *start = '\0';
2023 }
2024 return start;
2025}
2026
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002027/* Check a string for using it in a CSV output format. If the string contains
2028 * one of the following four char <">, <,>, CR or LF, the string is
2029 * encapsulated between <"> and the <"> are escaped by a <""> sequence.
2030 * <str> is the input string to be escaped. The function assumes that
2031 * the input string is null-terminated.
2032 *
2033 * If <quote> is 0, the result is returned escaped but without double quote.
Willy Tarreau898529b2016-01-06 18:07:04 +01002034 * It is useful if the escaped string is used between double quotes in the
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002035 * format.
2036 *
Willy Tarreau898529b2016-01-06 18:07:04 +01002037 * printf("..., \"%s\", ...\r\n", csv_enc(str, 0, &trash));
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002038 *
Willy Tarreaub631c292016-01-08 10:04:08 +01002039 * If <quote> is 1, the converter puts the quotes only if any reserved character
2040 * is present. If <quote> is 2, the converter always puts the quotes.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002041 *
Willy Tarreau83061a82018-07-13 11:56:34 +02002042 * <output> is a struct buffer used for storing the output string.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002043 *
Willy Tarreau898529b2016-01-06 18:07:04 +01002044 * The function returns the converted string on its output. If an error
2045 * occurs, the function returns an empty string. This type of output is useful
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002046 * for using the function directly as printf() argument.
2047 *
2048 * If the output buffer is too short to contain the input string, the result
2049 * is truncated.
Willy Tarreau898529b2016-01-06 18:07:04 +01002050 *
Willy Tarreaub631c292016-01-08 10:04:08 +01002051 * This function appends the encoding to the existing output chunk, and it
2052 * guarantees that it starts immediately at the first available character of
2053 * the chunk. Please use csv_enc() instead if you want to replace the output
2054 * chunk.
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002055 */
Willy Tarreau83061a82018-07-13 11:56:34 +02002056const char *csv_enc_append(const char *str, int quote, struct buffer *output)
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002057{
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002058 char *end = output->area + output->size;
2059 char *out = output->area + output->data;
Willy Tarreau898529b2016-01-06 18:07:04 +01002060 char *ptr = out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002061
Willy Tarreaub631c292016-01-08 10:04:08 +01002062 if (quote == 1) {
2063 /* automatic quoting: first verify if we'll have to quote the string */
2064 if (!strpbrk(str, "\n\r,\""))
2065 quote = 0;
2066 }
2067
2068 if (quote)
2069 *ptr++ = '"';
2070
Willy Tarreau898529b2016-01-06 18:07:04 +01002071 while (*str && ptr < end - 2) { /* -2 for reserving space for <"> and \0. */
2072 *ptr = *str;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002073 if (*str == '"') {
Willy Tarreau898529b2016-01-06 18:07:04 +01002074 ptr++;
2075 if (ptr >= end - 2) {
2076 ptr--;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002077 break;
2078 }
Willy Tarreau898529b2016-01-06 18:07:04 +01002079 *ptr = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002080 }
Willy Tarreau898529b2016-01-06 18:07:04 +01002081 ptr++;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002082 str++;
2083 }
2084
Willy Tarreaub631c292016-01-08 10:04:08 +01002085 if (quote)
2086 *ptr++ = '"';
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002087
Willy Tarreau898529b2016-01-06 18:07:04 +01002088 *ptr = '\0';
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002089 output->data = ptr - output->area;
Willy Tarreau898529b2016-01-06 18:07:04 +01002090 return out;
Thierry FOURNIERddea6262015-05-28 16:00:28 +02002091}
2092
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002093/* Decode an URL-encoded string in-place. The resulting string might
2094 * be shorter. If some forbidden characters are found, the conversion is
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002095 * aborted, the string is truncated before the issue and a negative value is
2096 * returned, otherwise the operation returns the length of the decoded string.
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002097 * If the 'in_form' argument is non-nul the string is assumed to be part of
2098 * an "application/x-www-form-urlencoded" encoded string, and the '+' will be
2099 * turned to a space. If it's zero, this will only be done after a question
2100 * mark ('?').
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002101 */
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002102int url_decode(char *string, int in_form)
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002103{
2104 char *in, *out;
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002105 int ret = -1;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002106
2107 in = string;
2108 out = string;
2109 while (*in) {
2110 switch (*in) {
2111 case '+' :
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002112 *out++ = in_form ? ' ' : *in;
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002113 break;
2114 case '%' :
2115 if (!ishex(in[1]) || !ishex(in[2]))
2116 goto end;
2117 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
2118 in += 2;
2119 break;
Willy Tarreau62ba9ba2020-04-23 17:54:47 +02002120 case '?':
2121 in_form = 1;
2122 /* fall through */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002123 default:
2124 *out++ = *in;
2125 break;
2126 }
2127 in++;
2128 }
Thierry FOURNIER5068d962013-10-04 16:27:27 +02002129 ret = out - string; /* success */
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02002130 end:
2131 *out = 0;
2132 return ret;
2133}
Willy Tarreaubaaee002006-06-26 02:48:02 +02002134
Willy Tarreau6911fa42007-03-04 18:06:08 +01002135unsigned int str2ui(const char *s)
2136{
2137 return __str2ui(s);
2138}
2139
2140unsigned int str2uic(const char *s)
2141{
2142 return __str2uic(s);
2143}
2144
2145unsigned int strl2ui(const char *s, int len)
2146{
2147 return __strl2ui(s, len);
2148}
2149
2150unsigned int strl2uic(const char *s, int len)
2151{
2152 return __strl2uic(s, len);
2153}
2154
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02002155unsigned int read_uint(const char **s, const char *end)
2156{
2157 return __read_uint(s, end);
2158}
2159
Thierry FOURNIER763a5d82015-07-06 23:09:52 +02002160/* This function reads an unsigned integer from the string pointed to by <s> and
2161 * returns it. The <s> pointer is adjusted to point to the first unread char. The
2162 * function automatically stops at <end>. If the number overflows, the 2^64-1
2163 * value is returned.
2164 */
2165unsigned long long int read_uint64(const char **s, const char *end)
2166{
2167 const char *ptr = *s;
2168 unsigned long long int i = 0, tmp;
2169 unsigned int j;
2170
2171 while (ptr < end) {
2172
2173 /* read next char */
2174 j = *ptr - '0';
2175 if (j > 9)
2176 goto read_uint64_end;
2177
2178 /* add char to the number and check overflow. */
2179 tmp = i * 10;
2180 if (tmp / 10 != i) {
2181 i = ULLONG_MAX;
2182 goto read_uint64_eat;
2183 }
2184 if (ULLONG_MAX - tmp < j) {
2185 i = ULLONG_MAX;
2186 goto read_uint64_eat;
2187 }
2188 i = tmp + j;
2189 ptr++;
2190 }
2191read_uint64_eat:
2192 /* eat each numeric char */
2193 while (ptr < end) {
2194 if ((unsigned int)(*ptr - '0') > 9)
2195 break;
2196 ptr++;
2197 }
2198read_uint64_end:
2199 *s = ptr;
2200 return i;
2201}
2202
2203/* This function reads an integer from the string pointed to by <s> and returns
2204 * it. The <s> pointer is adjusted to point to the first unread char. The function
2205 * automatically stops at <end>. Il the number is bigger than 2^63-2, the 2^63-1
2206 * value is returned. If the number is lowest than -2^63-1, the -2^63 value is
2207 * returned.
2208 */
2209long long int read_int64(const char **s, const char *end)
2210{
2211 unsigned long long int i = 0;
2212 int neg = 0;
2213
2214 /* Look for minus char. */
2215 if (**s == '-') {
2216 neg = 1;
2217 (*s)++;
2218 }
2219 else if (**s == '+')
2220 (*s)++;
2221
2222 /* convert as positive number. */
2223 i = read_uint64(s, end);
2224
2225 if (neg) {
2226 if (i > 0x8000000000000000ULL)
2227 return LLONG_MIN;
2228 return -i;
2229 }
2230 if (i > 0x7fffffffffffffffULL)
2231 return LLONG_MAX;
2232 return i;
2233}
2234
Willy Tarreau6911fa42007-03-04 18:06:08 +01002235/* This one is 7 times faster than strtol() on athlon with checks.
2236 * It returns the value of the number composed of all valid digits read,
2237 * and can process negative numbers too.
2238 */
2239int strl2ic(const char *s, int len)
2240{
2241 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002242 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002243
2244 if (len > 0) {
2245 if (*s != '-') {
2246 /* positive number */
2247 while (len-- > 0) {
2248 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002249 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002250 if (j > 9)
2251 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002252 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002253 }
2254 } else {
2255 /* negative number */
2256 s++;
2257 while (--len > 0) {
2258 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002259 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002260 if (j > 9)
2261 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02002262 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01002263 }
2264 }
2265 }
2266 return i;
2267}
2268
2269
2270/* This function reads exactly <len> chars from <s> and converts them to a
2271 * signed integer which it stores into <ret>. It accurately detects any error
2272 * (truncated string, invalid chars, overflows). It is meant to be used in
2273 * applications designed for hostile environments. It returns zero when the
2274 * number has successfully been converted, non-zero otherwise. When an error
2275 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
2276 * faster than strtol().
2277 */
2278int strl2irc(const char *s, int len, int *ret)
2279{
2280 int i = 0;
2281 int j;
2282
2283 if (!len)
2284 return 1;
2285
2286 if (*s != '-') {
2287 /* positive number */
2288 while (len-- > 0) {
2289 j = (*s++) - '0';
2290 if (j > 9) return 1; /* invalid char */
2291 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
2292 i = i * 10;
2293 if (i + j < i) return 1; /* check for addition overflow */
2294 i = i + j;
2295 }
2296 } else {
2297 /* negative number */
2298 s++;
2299 while (--len > 0) {
2300 j = (*s++) - '0';
2301 if (j > 9) return 1; /* invalid char */
2302 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
2303 i = i * 10;
2304 if (i - j > i) return 1; /* check for subtract overflow */
2305 i = i - j;
2306 }
2307 }
2308 *ret = i;
2309 return 0;
2310}
2311
2312
2313/* This function reads exactly <len> chars from <s> and converts them to a
2314 * signed integer which it stores into <ret>. It accurately detects any error
2315 * (truncated string, invalid chars, overflows). It is meant to be used in
2316 * applications designed for hostile environments. It returns zero when the
2317 * number has successfully been converted, non-zero otherwise. When an error
2318 * is returned, the <ret> value is left untouched. It is about 3 times slower
William Dauchy060ffc82021-02-06 20:47:51 +01002319 * than strl2irc().
Willy Tarreau6911fa42007-03-04 18:06:08 +01002320 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01002321
2322int strl2llrc(const char *s, int len, long long *ret)
2323{
2324 long long i = 0;
2325 int j;
2326
2327 if (!len)
2328 return 1;
2329
2330 if (*s != '-') {
2331 /* positive number */
2332 while (len-- > 0) {
2333 j = (*s++) - '0';
2334 if (j > 9) return 1; /* invalid char */
2335 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
2336 i = i * 10LL;
2337 if (i + j < i) return 1; /* check for addition overflow */
2338 i = i + j;
2339 }
2340 } else {
2341 /* negative number */
2342 s++;
2343 while (--len > 0) {
2344 j = (*s++) - '0';
2345 if (j > 9) return 1; /* invalid char */
2346 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
2347 i = i * 10LL;
2348 if (i - j > i) return 1; /* check for subtract overflow */
2349 i = i - j;
2350 }
2351 }
2352 *ret = i;
2353 return 0;
2354}
2355
Thierry FOURNIER511e9472014-01-23 17:40:34 +01002356/* This function is used with pat_parse_dotted_ver(). It converts a string
2357 * composed by two number separated by a dot. Each part must contain in 16 bits
2358 * because internally they will be represented as a 32-bit quantity stored in
2359 * a 64-bit integer. It returns zero when the number has successfully been
2360 * converted, non-zero otherwise. When an error is returned, the <ret> value
2361 * is left untouched.
2362 *
2363 * "1.3" -> 0x0000000000010003
2364 * "65535.65535" -> 0x00000000ffffffff
2365 */
2366int strl2llrc_dotted(const char *text, int len, long long *ret)
2367{
2368 const char *end = &text[len];
2369 const char *p;
2370 long long major, minor;
2371
2372 /* Look for dot. */
2373 for (p = text; p < end; p++)
2374 if (*p == '.')
2375 break;
2376
2377 /* Convert major. */
2378 if (strl2llrc(text, p - text, &major) != 0)
2379 return 1;
2380
2381 /* Check major. */
2382 if (major >= 65536)
2383 return 1;
2384
2385 /* Convert minor. */
2386 minor = 0;
2387 if (p < end)
2388 if (strl2llrc(p + 1, end - (p + 1), &minor) != 0)
2389 return 1;
2390
2391 /* Check minor. */
2392 if (minor >= 65536)
2393 return 1;
2394
2395 /* Compose value. */
2396 *ret = (major << 16) | (minor & 0xffff);
2397 return 0;
2398}
2399
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002400/* This function parses a time value optionally followed by a unit suffix among
2401 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
2402 * expected by the caller. The computation does its best to avoid overflows.
2403 * The value is returned in <ret> if everything is fine, and a NULL is returned
2404 * by the function. In case of error, a pointer to the error is returned and
2405 * <ret> is left untouched. Values are automatically rounded up when needed.
Willy Tarreau9faebe32019-06-07 19:00:37 +02002406 * Values resulting in values larger than or equal to 2^31 after conversion are
2407 * reported as an overflow as value PARSE_TIME_OVER. Non-null values resulting
2408 * in an underflow are reported as an underflow as value PARSE_TIME_UNDER.
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002409 */
2410const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
2411{
Willy Tarreau9faebe32019-06-07 19:00:37 +02002412 unsigned long long imult, idiv;
2413 unsigned long long omult, odiv;
2414 unsigned long long value, result;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002415 const char *str = text;
2416
2417 if (!isdigit((unsigned char)*text))
2418 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002419
2420 omult = odiv = 1;
2421
2422 switch (unit_flags & TIME_UNIT_MASK) {
2423 case TIME_UNIT_US: omult = 1000000; break;
2424 case TIME_UNIT_MS: omult = 1000; break;
2425 case TIME_UNIT_S: break;
2426 case TIME_UNIT_MIN: odiv = 60; break;
2427 case TIME_UNIT_HOUR: odiv = 3600; break;
2428 case TIME_UNIT_DAY: odiv = 86400; break;
2429 default: break;
2430 }
2431
2432 value = 0;
2433
2434 while (1) {
2435 unsigned int j;
2436
2437 j = *text - '0';
2438 if (j > 9)
2439 break;
2440 text++;
2441 value *= 10;
2442 value += j;
2443 }
2444
2445 imult = idiv = 1;
2446 switch (*text) {
2447 case '\0': /* no unit = default unit */
2448 imult = omult = idiv = odiv = 1;
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002449 goto end;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002450 case 's': /* second = unscaled unit */
2451 break;
2452 case 'u': /* microsecond : "us" */
2453 if (text[1] == 's') {
2454 idiv = 1000000;
2455 text++;
Thayne McCombsa6838052021-04-02 14:12:43 -06002456 break;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002457 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002458 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002459 case 'm': /* millisecond : "ms" or minute: "m" */
2460 if (text[1] == 's') {
2461 idiv = 1000;
2462 text++;
2463 } else
2464 imult = 60;
2465 break;
2466 case 'h': /* hour : "h" */
2467 imult = 3600;
2468 break;
2469 case 'd': /* day : "d" */
2470 imult = 86400;
2471 break;
2472 default:
2473 return text;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002474 }
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002475 if (*(++text) != '\0') {
2476 ha_warning("unexpected character '%c' after the timer value '%s', only "
2477 "(us=microseconds,ms=milliseconds,s=seconds,m=minutes,h=hours,d=days) are supported."
2478 " This will be reported as an error in next versions.\n", *text, str);
2479 }
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002480
Christopher Fauletc20ad0d2020-12-11 09:23:07 +01002481 end:
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002482 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
2483 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
2484 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
2485 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
2486
Willy Tarreau9faebe32019-06-07 19:00:37 +02002487 result = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
2488 if (result >= 0x80000000)
2489 return PARSE_TIME_OVER;
2490 if (!result && value)
2491 return PARSE_TIME_UNDER;
2492 *ret = result;
Willy Tarreaua0d37b62007-12-02 22:00:35 +01002493 return NULL;
2494}
Willy Tarreau6911fa42007-03-04 18:06:08 +01002495
Emeric Brun39132b22010-01-04 14:57:24 +01002496/* this function converts the string starting at <text> to an unsigned int
2497 * stored in <ret>. If an error is detected, the pointer to the unexpected
Joseph Herlant32b83272018-11-15 11:58:28 -08002498 * character is returned. If the conversion is successful, NULL is returned.
Emeric Brun39132b22010-01-04 14:57:24 +01002499 */
2500const char *parse_size_err(const char *text, unsigned *ret) {
2501 unsigned value = 0;
2502
Christopher Faulet82635a02020-12-11 09:30:45 +01002503 if (!isdigit((unsigned char)*text))
2504 return text;
2505
Emeric Brun39132b22010-01-04 14:57:24 +01002506 while (1) {
2507 unsigned int j;
2508
2509 j = *text - '0';
2510 if (j > 9)
2511 break;
2512 if (value > ~0U / 10)
2513 return text;
2514 value *= 10;
2515 if (value > (value + j))
2516 return text;
2517 value += j;
2518 text++;
2519 }
2520
2521 switch (*text) {
2522 case '\0':
2523 break;
2524 case 'K':
2525 case 'k':
2526 if (value > ~0U >> 10)
2527 return text;
2528 value = value << 10;
2529 break;
2530 case 'M':
2531 case 'm':
2532 if (value > ~0U >> 20)
2533 return text;
2534 value = value << 20;
2535 break;
2536 case 'G':
2537 case 'g':
2538 if (value > ~0U >> 30)
2539 return text;
2540 value = value << 30;
2541 break;
2542 default:
2543 return text;
2544 }
2545
Godbach58048a22015-01-28 17:36:16 +08002546 if (*text != '\0' && *++text != '\0')
2547 return text;
2548
Emeric Brun39132b22010-01-04 14:57:24 +01002549 *ret = value;
2550 return NULL;
2551}
2552
Willy Tarreau126d4062013-12-03 17:50:47 +01002553/*
2554 * Parse binary string written in hexadecimal (source) and store the decoded
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002555 * result into binstr and set binstrlen to the length of binstr. Memory for
Willy Tarreau126d4062013-12-03 17:50:47 +01002556 * binstr is allocated by the function. In case of error, returns 0 with an
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002557 * error message in err. In success case, it returns the consumed length.
Willy Tarreau126d4062013-12-03 17:50:47 +01002558 */
2559int parse_binary(const char *source, char **binstr, int *binstrlen, char **err)
2560{
2561 int len;
2562 const char *p = source;
2563 int i,j;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002564 int alloc;
Willy Tarreau126d4062013-12-03 17:50:47 +01002565
2566 len = strlen(source);
2567 if (len % 2) {
2568 memprintf(err, "an even number of hex digit is expected");
2569 return 0;
2570 }
2571
2572 len = len >> 1;
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002573
Willy Tarreau126d4062013-12-03 17:50:47 +01002574 if (!*binstr) {
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02002575 *binstr = calloc(len, sizeof(**binstr));
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002576 if (!*binstr) {
2577 memprintf(err, "out of memory while loading string pattern");
2578 return 0;
2579 }
2580 alloc = 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002581 }
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002582 else {
2583 if (*binstrlen < len) {
Joseph Herlant76dbe782018-11-15 12:01:22 -08002584 memprintf(err, "no space available in the buffer. expect %d, provides %d",
Thierry FOURNIER9645d422013-12-06 19:59:28 +01002585 len, *binstrlen);
2586 return 0;
2587 }
2588 alloc = 0;
2589 }
2590 *binstrlen = len;
Willy Tarreau126d4062013-12-03 17:50:47 +01002591
2592 i = j = 0;
2593 while (j < len) {
2594 if (!ishex(p[i++]))
2595 goto bad_input;
2596 if (!ishex(p[i++]))
2597 goto bad_input;
2598 (*binstr)[j++] = (hex2i(p[i-2]) << 4) + hex2i(p[i-1]);
2599 }
Thierry FOURNIERee330af2014-01-21 11:36:14 +01002600 return len << 1;
Willy Tarreau126d4062013-12-03 17:50:47 +01002601
2602bad_input:
2603 memprintf(err, "an hex digit is expected (found '%c')", p[i-1]);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002604 if (alloc)
2605 ha_free(binstr);
Willy Tarreau126d4062013-12-03 17:50:47 +01002606 return 0;
2607}
2608
Willy Tarreau946ba592009-05-10 15:41:18 +02002609/* copies at most <n> characters from <src> and always terminates with '\0' */
2610char *my_strndup(const char *src, int n)
2611{
2612 int len = 0;
2613 char *ret;
2614
2615 while (len < n && src[len])
2616 len++;
2617
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02002618 ret = malloc(len + 1);
Willy Tarreau946ba592009-05-10 15:41:18 +02002619 if (!ret)
2620 return ret;
2621 memcpy(ret, src, len);
2622 ret[len] = '\0';
2623 return ret;
2624}
2625
Baptiste Assmannbb77c8e2013-10-06 23:24:13 +02002626/*
2627 * search needle in haystack
2628 * returns the pointer if found, returns NULL otherwise
2629 */
2630const void *my_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen)
2631{
2632 const void *c = NULL;
2633 unsigned char f;
2634
2635 if ((haystack == NULL) || (needle == NULL) || (haystacklen < needlelen))
2636 return NULL;
2637
2638 f = *(char *)needle;
2639 c = haystack;
2640 while ((c = memchr(c, f, haystacklen - (c - haystack))) != NULL) {
2641 if ((haystacklen - (c - haystack)) < needlelen)
2642 return NULL;
2643
2644 if (memcmp(c, needle, needlelen) == 0)
2645 return c;
2646 ++c;
2647 }
2648 return NULL;
2649}
2650
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002651/* get length of the initial segment consisting entirely of bytes in <accept> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002652size_t my_memspn(const void *str, size_t len, const void *accept, size_t acceptlen)
2653{
2654 size_t ret = 0;
2655
2656 while (ret < len && memchr(accept, *((int *)str), acceptlen)) {
2657 str++;
2658 ret++;
2659 }
2660 return ret;
2661}
2662
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +05002663/* get length of the initial segment consisting entirely of bytes not in <rejcet> */
Christopher Faulet5eb96cb2020-04-15 10:23:01 +02002664size_t my_memcspn(const void *str, size_t len, const void *reject, size_t rejectlen)
2665{
2666 size_t ret = 0;
2667
2668 while (ret < len) {
2669 if(memchr(reject, *((int *)str), rejectlen))
2670 return ret;
2671 str++;
2672 ret++;
2673 }
2674 return ret;
2675}
2676
Willy Tarreau482b00d2009-10-04 22:48:42 +02002677/* This function returns the first unused key greater than or equal to <key> in
2678 * ID tree <root>. Zero is returned if no place is found.
2679 */
2680unsigned int get_next_id(struct eb_root *root, unsigned int key)
2681{
2682 struct eb32_node *used;
2683
2684 do {
2685 used = eb32_lookup_ge(root, key);
2686 if (!used || used->key > key)
2687 return key; /* key is available */
2688 key++;
2689 } while (key);
2690 return key;
2691}
2692
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002693/* dump the full tree to <file> in DOT format for debugging purposes. Will
2694 * optionally highlight node <subj> if found, depending on operation <op> :
2695 * 0 : nothing
2696 * >0 : insertion, node/leaf are surrounded in red
2697 * <0 : removal, node/leaf are dashed with no background
2698 * Will optionally add "desc" as a label on the graph if set and non-null.
2699 */
2700void 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 +01002701{
2702 struct eb32sc_node *node;
2703 unsigned long scope = -1;
2704
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002705 fprintf(file, "digraph ebtree {\n");
2706
2707 if (desc && *desc) {
2708 fprintf(file,
2709 " fontname=\"fixed\";\n"
2710 " fontsize=8;\n"
2711 " label=\"%s\";\n", desc);
2712 }
2713
Willy Tarreaued3cda02017-11-15 15:04:05 +01002714 fprintf(file,
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002715 " node [fontname=\"fixed\" fontsize=8 shape=\"box\" style=\"filled\" color=\"black\" fillcolor=\"white\"];\n"
2716 " edge [fontname=\"fixed\" fontsize=8 style=\"solid\" color=\"magenta\" dir=\"forward\"];\n"
Willy Tarreaued3cda02017-11-15 15:04:05 +01002717 " \"%lx_n\" [label=\"root\\n%lx\"]\n", (long)eb_root_to_node(root), (long)root
2718 );
2719
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002720 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002721 (long)eb_root_to_node(root),
2722 (long)eb_root_to_node(eb_clrtag(root->b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002723 eb_gettag(root->b[0]) == EB_LEAF ? 'l' : 'n');
2724
2725 node = eb32sc_first(root, scope);
2726 while (node) {
2727 if (node->node.node_p) {
2728 /* node part is used */
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002729 fprintf(file, " \"%lx_n\" [label=\"%lx\\nkey=%u\\nscope=%lx\\nbit=%d\" fillcolor=\"lightskyblue1\" %s];\n",
2730 (long)node, (long)node, node->key, node->node_s, node->node.bit,
2731 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002732
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002733 fprintf(file, " \"%lx_n\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002734 (long)node,
2735 (long)eb_root_to_node(eb_clrtag(node->node.node_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002736 eb_gettag(node->node.node_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002737
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002738 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"L\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002739 (long)node,
2740 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[0])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002741 eb_gettag(node->node.branches.b[0]) == EB_LEAF ? 'l' : 'n');
2742
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002743 fprintf(file, " \"%lx_n\" -> \"%lx_%c\" [taillabel=\"R\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002744 (long)node,
2745 (long)eb_root_to_node(eb_clrtag(node->node.branches.b[1])),
Willy Tarreaued3cda02017-11-15 15:04:05 +01002746 eb_gettag(node->node.branches.b[1]) == EB_LEAF ? 'l' : 'n');
2747 }
2748
Willy Tarreau9c1e15d2017-11-15 18:51:29 +01002749 fprintf(file, " \"%lx_l\" [label=\"%lx\\nkey=%u\\nscope=%lx\\npfx=%u\" fillcolor=\"yellow\" %s];\n",
2750 (long)node, (long)node, node->key, node->leaf_s, node->node.pfx,
2751 (node == subj) ? (op < 0 ? "color=\"red\" style=\"dashed\"" : op > 0 ? "color=\"red\"" : "") : "");
Willy Tarreaued3cda02017-11-15 15:04:05 +01002752
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002753 fprintf(file, " \"%lx_l\" -> \"%lx_n\" [taillabel=\"%c\"];\n",
Willy Tarreaued3cda02017-11-15 15:04:05 +01002754 (long)node,
2755 (long)eb_root_to_node(eb_clrtag(node->node.leaf_p)),
Willy Tarreau6c7f4de2017-11-15 17:49:54 +01002756 eb_gettag(node->node.leaf_p) ? 'R' : 'L');
Willy Tarreaued3cda02017-11-15 15:04:05 +01002757 node = eb32sc_next(node, scope);
2758 }
2759 fprintf(file, "}\n");
2760}
2761
Willy Tarreau348238b2010-01-18 15:05:57 +01002762/* This function compares a sample word possibly followed by blanks to another
2763 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
2764 * otherwise zero. This intends to be used when checking HTTP headers for some
2765 * values. Note that it validates a word followed only by blanks but does not
2766 * validate a word followed by blanks then other chars.
2767 */
2768int word_match(const char *sample, int slen, const char *word, int wlen)
2769{
2770 if (slen < wlen)
2771 return 0;
2772
2773 while (wlen) {
2774 char c = *sample ^ *word;
2775 if (c && c != ('A' ^ 'a'))
2776 return 0;
2777 sample++;
2778 word++;
2779 slen--;
2780 wlen--;
2781 }
2782
2783 while (slen) {
2784 if (*sample != ' ' && *sample != '\t')
2785 return 0;
2786 sample++;
2787 slen--;
2788 }
2789 return 1;
2790}
Willy Tarreau482b00d2009-10-04 22:48:42 +02002791
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002792/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
2793 * is particularly fast because it avoids expensive operations such as
2794 * multiplies, which are optimized away at the end. It requires a properly
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05002795 * formatted address though (3 points).
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002796 */
2797unsigned int inetaddr_host(const char *text)
2798{
2799 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2800 register unsigned int dig100, dig10, dig1;
2801 int s;
2802 const char *p, *d;
2803
2804 dig1 = dig10 = dig100 = ascii_zero;
2805 s = 24;
2806
2807 p = text;
2808 while (1) {
2809 if (((unsigned)(*p - '0')) <= 9) {
2810 p++;
2811 continue;
2812 }
2813
2814 /* here, we have a complete byte between <text> and <p> (exclusive) */
2815 if (p == text)
2816 goto end;
2817
2818 d = p - 1;
2819 dig1 |= (unsigned int)(*d << s);
2820 if (d == text)
2821 goto end;
2822
2823 d--;
2824 dig10 |= (unsigned int)(*d << s);
2825 if (d == text)
2826 goto end;
2827
2828 d--;
2829 dig100 |= (unsigned int)(*d << s);
2830 end:
2831 if (!s || *p != '.')
2832 break;
2833
2834 s -= 8;
2835 text = ++p;
2836 }
2837
2838 dig100 -= ascii_zero;
2839 dig10 -= ascii_zero;
2840 dig1 -= ascii_zero;
2841 return ((dig100 * 10) + dig10) * 10 + dig1;
2842}
2843
2844/*
2845 * Idem except the first unparsed character has to be passed in <stop>.
2846 */
2847unsigned int inetaddr_host_lim(const char *text, const char *stop)
2848{
2849 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2850 register unsigned int dig100, dig10, dig1;
2851 int s;
2852 const char *p, *d;
2853
2854 dig1 = dig10 = dig100 = ascii_zero;
2855 s = 24;
2856
2857 p = text;
2858 while (1) {
2859 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2860 p++;
2861 continue;
2862 }
2863
2864 /* here, we have a complete byte between <text> and <p> (exclusive) */
2865 if (p == text)
2866 goto end;
2867
2868 d = p - 1;
2869 dig1 |= (unsigned int)(*d << s);
2870 if (d == text)
2871 goto end;
2872
2873 d--;
2874 dig10 |= (unsigned int)(*d << s);
2875 if (d == text)
2876 goto end;
2877
2878 d--;
2879 dig100 |= (unsigned int)(*d << s);
2880 end:
2881 if (!s || p == stop || *p != '.')
2882 break;
2883
2884 s -= 8;
2885 text = ++p;
2886 }
2887
2888 dig100 -= ascii_zero;
2889 dig10 -= ascii_zero;
2890 dig1 -= ascii_zero;
2891 return ((dig100 * 10) + dig10) * 10 + dig1;
2892}
2893
2894/*
2895 * Idem except the pointer to first unparsed byte is returned into <ret> which
2896 * must not be NULL.
2897 */
Willy Tarreau74172752010-10-15 23:21:42 +02002898unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002899{
2900 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
2901 register unsigned int dig100, dig10, dig1;
2902 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02002903 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02002904
2905 dig1 = dig10 = dig100 = ascii_zero;
2906 s = 24;
2907
2908 p = text;
2909 while (1) {
2910 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
2911 p++;
2912 continue;
2913 }
2914
2915 /* here, we have a complete byte between <text> and <p> (exclusive) */
2916 if (p == text)
2917 goto end;
2918
2919 d = p - 1;
2920 dig1 |= (unsigned int)(*d << s);
2921 if (d == text)
2922 goto end;
2923
2924 d--;
2925 dig10 |= (unsigned int)(*d << s);
2926 if (d == text)
2927 goto end;
2928
2929 d--;
2930 dig100 |= (unsigned int)(*d << s);
2931 end:
2932 if (!s || p == stop || *p != '.')
2933 break;
2934
2935 s -= 8;
2936 text = ++p;
2937 }
2938
2939 *ret = p;
2940 dig100 -= ascii_zero;
2941 dig10 -= ascii_zero;
2942 dig1 -= ascii_zero;
2943 return ((dig100 * 10) + dig10) * 10 + dig1;
2944}
2945
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002946/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
2947 * or the number of chars read in case of success. Maybe this could be replaced
2948 * by one of the functions above. Also, apparently this function does not support
2949 * hosts above 255 and requires exactly 4 octets.
Willy Tarreau075415a2013-12-12 11:29:39 +01002950 * The destination is only modified on success.
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02002951 */
2952int buf2ip(const char *buf, size_t len, struct in_addr *dst)
2953{
2954 const char *addr;
2955 int saw_digit, octets, ch;
2956 u_char tmp[4], *tp;
2957 const char *cp = buf;
2958
2959 saw_digit = 0;
2960 octets = 0;
2961 *(tp = tmp) = 0;
2962
2963 for (addr = buf; addr - buf < len; addr++) {
2964 unsigned char digit = (ch = *addr) - '0';
2965
2966 if (digit > 9 && ch != '.')
2967 break;
2968
2969 if (digit <= 9) {
2970 u_int new = *tp * 10 + digit;
2971
2972 if (new > 255)
2973 return 0;
2974
2975 *tp = new;
2976
2977 if (!saw_digit) {
2978 if (++octets > 4)
2979 return 0;
2980 saw_digit = 1;
2981 }
2982 } else if (ch == '.' && saw_digit) {
2983 if (octets == 4)
2984 return 0;
2985
2986 *++tp = 0;
2987 saw_digit = 0;
2988 } else
2989 return 0;
2990 }
2991
2992 if (octets < 4)
2993 return 0;
2994
2995 memcpy(&dst->s_addr, tmp, 4);
2996 return addr - cp;
2997}
2998
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01002999/* This function converts the string in <buf> of the len <len> to
3000 * struct in6_addr <dst> which must be allocated by the caller.
3001 * This function returns 1 in success case, otherwise zero.
Willy Tarreau075415a2013-12-12 11:29:39 +01003002 * The destination is only modified on success.
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003003 */
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003004int buf2ip6(const char *buf, size_t len, struct in6_addr *dst)
3005{
Thierry FOURNIERcd659912013-12-11 12:33:54 +01003006 char null_term_ip6[INET6_ADDRSTRLEN + 1];
Willy Tarreau075415a2013-12-12 11:29:39 +01003007 struct in6_addr out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003008
Thierry FOURNIERcd659912013-12-11 12:33:54 +01003009 if (len > INET6_ADDRSTRLEN)
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003010 return 0;
3011
3012 memcpy(null_term_ip6, buf, len);
3013 null_term_ip6[len] = '\0';
3014
Willy Tarreau075415a2013-12-12 11:29:39 +01003015 if (!inet_pton(AF_INET6, null_term_ip6, &out))
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003016 return 0;
3017
Willy Tarreau075415a2013-12-12 11:29:39 +01003018 *dst = out;
Thierry FOURNIERd559dd82013-11-22 16:16:59 +01003019 return 1;
3020}
3021
Willy Tarreauacf95772010-06-14 19:09:21 +02003022/* To be used to quote config arg positions. Returns the short string at <ptr>
3023 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
3024 * if ptr is NULL or empty. The string is locally allocated.
3025 */
3026const char *quote_arg(const char *ptr)
3027{
Christopher Faulet1bc04c72017-10-29 20:14:08 +01003028 static THREAD_LOCAL char val[32];
Willy Tarreauacf95772010-06-14 19:09:21 +02003029 int i;
3030
3031 if (!ptr || !*ptr)
3032 return "end of line";
3033 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01003034 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02003035 val[i] = *ptr++;
3036 val[i++] = '\'';
3037 val[i] = '\0';
3038 return val;
3039}
3040
Willy Tarreau5b180202010-07-18 10:40:48 +02003041/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
3042int get_std_op(const char *str)
3043{
3044 int ret = -1;
3045
3046 if (*str == 'e' && str[1] == 'q')
3047 ret = STD_OP_EQ;
3048 else if (*str == 'n' && str[1] == 'e')
3049 ret = STD_OP_NE;
3050 else if (*str == 'l') {
3051 if (str[1] == 'e') ret = STD_OP_LE;
3052 else if (str[1] == 't') ret = STD_OP_LT;
3053 }
3054 else if (*str == 'g') {
3055 if (str[1] == 'e') ret = STD_OP_GE;
3056 else if (str[1] == 't') ret = STD_OP_GT;
3057 }
3058
3059 if (ret == -1 || str[2] != '\0')
3060 return -1;
3061 return ret;
3062}
3063
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01003064/* hash a 32-bit integer to another 32-bit integer */
3065unsigned int full_hash(unsigned int a)
3066{
3067 return __full_hash(a);
3068}
3069
Willy Tarreauf3241112019-02-26 09:56:22 +01003070/* Return the bit position in mask <m> of the nth bit set of rank <r>, between
3071 * 0 and LONGBITS-1 included, starting from the left. For example ranks 0,1,2,3
3072 * for mask 0x55 will be 6, 4, 2 and 0 respectively. This algorithm is based on
3073 * a popcount variant and is described here :
3074 * https://graphics.stanford.edu/~seander/bithacks.html
3075 */
3076unsigned int mask_find_rank_bit(unsigned int r, unsigned long m)
3077{
3078 unsigned long a, b, c, d;
3079 unsigned int s;
3080 unsigned int t;
3081
3082 a = m - ((m >> 1) & ~0UL/3);
3083 b = (a & ~0UL/5) + ((a >> 2) & ~0UL/5);
3084 c = (b + (b >> 4)) & ~0UL/0x11;
3085 d = (c + (c >> 8)) & ~0UL/0x101;
3086
3087 r++; // make r be 1..64
3088
3089 t = 0;
3090 s = LONGBITS;
3091 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01003092 unsigned long d2 = (d >> 16) >> 16;
3093 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01003094 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
3095 }
3096
3097 t = (d >> (s - 16)) & 0xff;
3098 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
3099 t = (c >> (s - 8)) & 0xf;
3100 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
3101 t = (b >> (s - 4)) & 0x7;
3102 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
3103 t = (a >> (s - 2)) & 0x3;
3104 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
3105 t = (m >> (s - 1)) & 0x1;
3106 s -= ((t - r) & 256) >> 8;
3107
3108 return s - 1;
3109}
3110
3111/* Same as mask_find_rank_bit() above but makes use of pre-computed bitmaps
3112 * based on <m>, in <a..d>. These ones must be updated whenever <m> changes
3113 * using mask_prep_rank_map() below.
3114 */
3115unsigned int mask_find_rank_bit_fast(unsigned int r, unsigned long m,
3116 unsigned long a, unsigned long b,
3117 unsigned long c, unsigned long d)
3118{
3119 unsigned int s;
3120 unsigned int t;
3121
3122 r++; // make r be 1..64
3123
3124 t = 0;
3125 s = LONGBITS;
3126 if (s > 32) {
Willy Tarreau9b6be3b2019-03-18 16:31:18 +01003127 unsigned long d2 = (d >> 16) >> 16;
3128 t = d2 + (d2 >> 16);
Willy Tarreauf3241112019-02-26 09:56:22 +01003129 s -= ((t - r) & 256) >> 3; r -= (t & ((t - r) >> 8));
3130 }
3131
3132 t = (d >> (s - 16)) & 0xff;
3133 s -= ((t - r) & 256) >> 4; r -= (t & ((t - r) >> 8));
3134 t = (c >> (s - 8)) & 0xf;
3135 s -= ((t - r) & 256) >> 5; r -= (t & ((t - r) >> 8));
3136 t = (b >> (s - 4)) & 0x7;
3137 s -= ((t - r) & 256) >> 6; r -= (t & ((t - r) >> 8));
3138 t = (a >> (s - 2)) & 0x3;
3139 s -= ((t - r) & 256) >> 7; r -= (t & ((t - r) >> 8));
3140 t = (m >> (s - 1)) & 0x1;
3141 s -= ((t - r) & 256) >> 8;
3142
3143 return s - 1;
3144}
3145
3146/* Prepare the bitmaps used by the fast implementation of the find_rank_bit()
3147 * above.
3148 */
3149void mask_prep_rank_map(unsigned long m,
3150 unsigned long *a, unsigned long *b,
3151 unsigned long *c, unsigned long *d)
3152{
3153 *a = m - ((m >> 1) & ~0UL/3);
3154 *b = (*a & ~0UL/5) + ((*a >> 2) & ~0UL/5);
3155 *c = (*b + (*b >> 4)) & ~0UL/0x11;
3156 *d = (*c + (*c >> 8)) & ~0UL/0x101;
3157}
3158
David du Colombier4f92d322011-03-24 11:09:31 +01003159/* Return non-zero if IPv4 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003160 * otherwise zero. Note that <addr> may not necessarily be aligned
3161 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003162 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003163int in_net_ipv4(const void *addr, const struct in_addr *mask, const struct in_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003164{
Willy Tarreaueec1d382016-07-13 11:59:39 +02003165 struct in_addr addr_copy;
3166
3167 memcpy(&addr_copy, addr, sizeof(addr_copy));
3168 return((addr_copy.s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
David du Colombier4f92d322011-03-24 11:09:31 +01003169}
3170
3171/* Return non-zero if IPv6 address is part of the network,
Willy Tarreaueec1d382016-07-13 11:59:39 +02003172 * otherwise zero. Note that <addr> may not necessarily be aligned
3173 * while the two other ones must.
David du Colombier4f92d322011-03-24 11:09:31 +01003174 */
Willy Tarreaueec1d382016-07-13 11:59:39 +02003175int in_net_ipv6(const void *addr, const struct in6_addr *mask, const struct in6_addr *net)
David du Colombier4f92d322011-03-24 11:09:31 +01003176{
3177 int i;
Willy Tarreaueec1d382016-07-13 11:59:39 +02003178 struct in6_addr addr_copy;
David du Colombier4f92d322011-03-24 11:09:31 +01003179
Willy Tarreaueec1d382016-07-13 11:59:39 +02003180 memcpy(&addr_copy, addr, sizeof(addr_copy));
David du Colombier4f92d322011-03-24 11:09:31 +01003181 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
Willy Tarreaueec1d382016-07-13 11:59:39 +02003182 if (((((int *)&addr_copy)[i] & ((int *)mask)[i])) !=
David du Colombier4f92d322011-03-24 11:09:31 +01003183 (((int *)net)[i] & ((int *)mask)[i]))
3184 return 0;
3185 return 1;
3186}
3187
3188/* RFC 4291 prefix */
3189const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
3190 0x00, 0x00, 0x00, 0x00,
3191 0x00, 0x00, 0xFF, 0xFF };
3192
Joseph Herlant32b83272018-11-15 11:58:28 -08003193/* Map IPv4 address on IPv6 address, as specified in RFC 3513.
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003194 * Input and output may overlap.
3195 */
David du Colombier4f92d322011-03-24 11:09:31 +01003196void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
3197{
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003198 struct in_addr tmp_addr;
3199
3200 tmp_addr.s_addr = sin_addr->s_addr;
David du Colombier4f92d322011-03-24 11:09:31 +01003201 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
Thierry FOURNIER4a04dc32013-11-28 16:33:15 +01003202 memcpy(sin6_addr->s6_addr+12, &tmp_addr.s_addr, 4);
David du Colombier4f92d322011-03-24 11:09:31 +01003203}
3204
Joseph Herlant32b83272018-11-15 11:58:28 -08003205/* Map IPv6 address on IPv4 address, as specified in RFC 3513.
David du Colombier4f92d322011-03-24 11:09:31 +01003206 * Return true if conversion is possible and false otherwise.
3207 */
3208int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
3209{
3210 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
3211 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
3212 sizeof(struct in_addr));
3213 return 1;
3214 }
3215
3216 return 0;
3217}
3218
Baptiste Assmann08b24cf2016-01-23 23:39:12 +01003219/* compare two struct sockaddr_storage and return:
3220 * 0 (true) if the addr is the same in both
3221 * 1 (false) if the addr is not the same in both
3222 * -1 (unable) if one of the addr is not AF_INET*
3223 */
3224int ipcmp(struct sockaddr_storage *ss1, struct sockaddr_storage *ss2)
3225{
3226 if ((ss1->ss_family != AF_INET) && (ss1->ss_family != AF_INET6))
3227 return -1;
3228
3229 if ((ss2->ss_family != AF_INET) && (ss2->ss_family != AF_INET6))
3230 return -1;
3231
3232 if (ss1->ss_family != ss2->ss_family)
3233 return 1;
3234
3235 switch (ss1->ss_family) {
3236 case AF_INET:
3237 return memcmp(&((struct sockaddr_in *)ss1)->sin_addr,
3238 &((struct sockaddr_in *)ss2)->sin_addr,
3239 sizeof(struct in_addr)) != 0;
3240 case AF_INET6:
3241 return memcmp(&((struct sockaddr_in6 *)ss1)->sin6_addr,
3242 &((struct sockaddr_in6 *)ss2)->sin6_addr,
3243 sizeof(struct in6_addr)) != 0;
3244 }
3245
3246 return 1;
3247}
3248
Christopher Faulet9553de72021-02-26 09:12:50 +01003249/* compare a struct sockaddr_storage to a struct net_addr and return :
3250 * 0 (true) if <addr> is matching <net>
3251 * 1 (false) if <addr> is not matching <net>
3252 * -1 (unable) if <addr> or <net> is not AF_INET*
3253 */
3254int ipcmp2net(const struct sockaddr_storage *addr, const struct net_addr *net)
3255{
3256 if ((addr->ss_family != AF_INET) && (addr->ss_family != AF_INET6))
3257 return -1;
3258
3259 if ((net->family != AF_INET) && (net->family != AF_INET6))
3260 return -1;
3261
3262 if (addr->ss_family != net->family)
3263 return 1;
3264
3265 if (addr->ss_family == AF_INET &&
3266 (((struct sockaddr_in *)addr)->sin_addr.s_addr & net->addr.v4.mask.s_addr) == net->addr.v4.ip.s_addr)
3267 return 0;
3268 else {
3269 const struct in6_addr *addr6 = &(((const struct sockaddr_in6*)addr)->sin6_addr);
3270 const struct in6_addr *nip6 = &net->addr.v6.ip;
3271 const struct in6_addr *nmask6 = &net->addr.v6.mask;
3272
3273 if ((read_u32(&addr6->s6_addr[0]) & read_u32(&nmask6->s6_addr[0])) == read_u32(&nip6->s6_addr[0]) &&
3274 (read_u32(&addr6->s6_addr[4]) & read_u32(&nmask6->s6_addr[4])) == read_u32(&nip6->s6_addr[4]) &&
3275 (read_u32(&addr6->s6_addr[8]) & read_u32(&nmask6->s6_addr[8])) == read_u32(&nip6->s6_addr[8]) &&
3276 (read_u32(&addr6->s6_addr[12]) & read_u32(&nmask6->s6_addr[12])) == read_u32(&nip6->s6_addr[12]))
3277 return 0;
3278 }
3279
3280 return 1;
3281}
3282
Baptiste Assmann08396c82016-01-31 00:27:17 +01003283/* copy IP address from <source> into <dest>
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003284 * The caller must allocate and clear <dest> before calling.
3285 * The source must be in either AF_INET or AF_INET6 family, or the destination
3286 * address will be undefined. If the destination address used to hold a port,
3287 * it is preserved, so that this function can be used to switch to another
3288 * address family with no risk. Returns a pointer to the destination.
Baptiste Assmann08396c82016-01-31 00:27:17 +01003289 */
3290struct sockaddr_storage *ipcpy(struct sockaddr_storage *source, struct sockaddr_storage *dest)
3291{
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003292 int prev_port;
3293
3294 prev_port = get_net_port(dest);
3295 memset(dest, 0, sizeof(*dest));
Baptiste Assmann08396c82016-01-31 00:27:17 +01003296 dest->ss_family = source->ss_family;
3297
3298 /* copy new addr and apply it */
3299 switch (source->ss_family) {
3300 case AF_INET:
3301 ((struct sockaddr_in *)dest)->sin_addr.s_addr = ((struct sockaddr_in *)source)->sin_addr.s_addr;
Willy Tarreaudc3a9e82016-11-04 18:47:01 +01003302 ((struct sockaddr_in *)dest)->sin_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003303 break;
3304 case AF_INET6:
3305 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 +01003306 ((struct sockaddr_in6 *)dest)->sin6_port = prev_port;
Baptiste Assmann08396c82016-01-31 00:27:17 +01003307 break;
3308 }
3309
3310 return dest;
3311}
3312
William Lallemand421f5b52012-02-06 18:15:57 +01003313char *human_time(int t, short hz_div) {
3314 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
3315 char *p = rv;
Willy Tarreau761b3d52014-04-14 14:53:06 +02003316 char *end = rv + sizeof(rv);
William Lallemand421f5b52012-02-06 18:15:57 +01003317 int cnt=2; // print two numbers
3318
3319 if (unlikely(t < 0 || hz_div <= 0)) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003320 snprintf(p, end - p, "?");
William Lallemand421f5b52012-02-06 18:15:57 +01003321 return rv;
3322 }
3323
3324 if (unlikely(hz_div > 1))
3325 t /= hz_div;
3326
3327 if (t >= DAY) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003328 p += snprintf(p, end - p, "%dd", t / DAY);
William Lallemand421f5b52012-02-06 18:15:57 +01003329 cnt--;
3330 }
3331
3332 if (cnt && t % DAY / HOUR) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003333 p += snprintf(p, end - p, "%dh", t % DAY / HOUR);
William Lallemand421f5b52012-02-06 18:15:57 +01003334 cnt--;
3335 }
3336
3337 if (cnt && t % HOUR / MINUTE) {
Willy Tarreau761b3d52014-04-14 14:53:06 +02003338 p += snprintf(p, end - p, "%dm", t % HOUR / MINUTE);
William Lallemand421f5b52012-02-06 18:15:57 +01003339 cnt--;
3340 }
3341
3342 if ((cnt && t % MINUTE) || !t) // also display '0s'
Willy Tarreau761b3d52014-04-14 14:53:06 +02003343 p += snprintf(p, end - p, "%ds", t % MINUTE / SEC);
William Lallemand421f5b52012-02-06 18:15:57 +01003344
3345 return rv;
3346}
3347
3348const char *monthname[12] = {
3349 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
3350 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
3351};
3352
3353/* date2str_log: write a date in the format :
3354 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
3355 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
3356 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
3357 *
3358 * without using sprintf. return a pointer to the last char written (\0) or
3359 * NULL if there isn't enough space.
3360 */
Willy Tarreauf16cb412018-09-04 19:08:48 +02003361char *date2str_log(char *dst, const struct tm *tm, const struct timeval *date, size_t size)
William Lallemand421f5b52012-02-06 18:15:57 +01003362{
3363
3364 if (size < 25) /* the size is fixed: 24 chars + \0 */
3365 return NULL;
3366
3367 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003368 if (!dst)
3369 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003370 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003371
William Lallemand421f5b52012-02-06 18:15:57 +01003372 memcpy(dst, monthname[tm->tm_mon], 3); // month
3373 dst += 3;
3374 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003375
William Lallemand421f5b52012-02-06 18:15:57 +01003376 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003377 if (!dst)
3378 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003379 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003380
William Lallemand421f5b52012-02-06 18:15:57 +01003381 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003382 if (!dst)
3383 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003384 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003385
William Lallemand421f5b52012-02-06 18:15:57 +01003386 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003387 if (!dst)
3388 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003389 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003390
William Lallemand421f5b52012-02-06 18:15:57 +01003391 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003392 if (!dst)
3393 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003394 *dst++ = '.';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003395
Willy Tarreau7d9421d2020-02-29 09:08:02 +01003396 dst = utoa_pad((unsigned int)(date->tv_usec/1000)%1000, dst, 4); // milliseconds
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003397 if (!dst)
3398 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003399 *dst = '\0';
3400
3401 return dst;
3402}
3403
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003404/* Base year used to compute leap years */
3405#define TM_YEAR_BASE 1900
3406
3407/* Return the difference in seconds between two times (leap seconds are ignored).
3408 * Retrieved from glibc 2.18 source code.
3409 */
3410static int my_tm_diff(const struct tm *a, const struct tm *b)
3411{
3412 /* Compute intervening leap days correctly even if year is negative.
3413 * Take care to avoid int overflow in leap day calculations,
3414 * but it's OK to assume that A and B are close to each other.
3415 */
3416 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
3417 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
3418 int a100 = a4 / 25 - (a4 % 25 < 0);
3419 int b100 = b4 / 25 - (b4 % 25 < 0);
3420 int a400 = a100 >> 2;
3421 int b400 = b100 >> 2;
3422 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
3423 int years = a->tm_year - b->tm_year;
3424 int days = (365 * years + intervening_leap_days
3425 + (a->tm_yday - b->tm_yday));
3426 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
3427 + (a->tm_min - b->tm_min))
3428 + (a->tm_sec - b->tm_sec));
3429}
3430
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003431/* Return the GMT offset for a specific local time.
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003432 * Both t and tm must represent the same time.
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003433 * The string returned has the same format as returned by strftime(... "%z", tm).
3434 * Offsets are kept in an internal cache for better performances.
3435 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003436const char *get_gmt_offset(time_t t, struct tm *tm)
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003437{
3438 /* Cache offsets from GMT (depending on whether DST is active or not) */
Christopher Faulet1bc04c72017-10-29 20:14:08 +01003439 static THREAD_LOCAL char gmt_offsets[2][5+1] = { "", "" };
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003440
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003441 char *gmt_offset;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003442 struct tm tm_gmt;
3443 int diff;
3444 int isdst = tm->tm_isdst;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003445
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003446 /* Pretend DST not active if its status is unknown */
3447 if (isdst < 0)
3448 isdst = 0;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003449
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003450 /* Fetch the offset and initialize it if needed */
3451 gmt_offset = gmt_offsets[isdst & 0x01];
3452 if (unlikely(!*gmt_offset)) {
3453 get_gmtime(t, &tm_gmt);
3454 diff = my_tm_diff(tm, &tm_gmt);
3455 if (diff < 0) {
3456 diff = -diff;
3457 *gmt_offset = '-';
3458 } else {
3459 *gmt_offset = '+';
3460 }
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003461 diff %= 86400U;
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003462 diff /= 60; /* Convert to minutes */
3463 snprintf(gmt_offset+1, 4+1, "%02d%02d", diff/60, diff%60);
3464 }
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003465
Willy Tarreaue112c8a2019-10-29 10:16:11 +01003466 return gmt_offset;
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003467}
3468
William Lallemand421f5b52012-02-06 18:15:57 +01003469/* gmt2str_log: write a date in the format :
3470 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
3471 * return a pointer to the last char written (\0) or
3472 * NULL if there isn't enough space.
3473 */
3474char *gmt2str_log(char *dst, struct tm *tm, size_t size)
3475{
Yuxans Yao4e25b012012-10-19 10:36:09 +08003476 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01003477 return NULL;
3478
3479 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003480 if (!dst)
3481 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003482 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003483
William Lallemand421f5b52012-02-06 18:15:57 +01003484 memcpy(dst, monthname[tm->tm_mon], 3); // month
3485 dst += 3;
3486 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003487
William Lallemand421f5b52012-02-06 18:15:57 +01003488 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003489 if (!dst)
3490 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003491 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003492
William Lallemand421f5b52012-02-06 18:15:57 +01003493 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003494 if (!dst)
3495 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003496 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003497
William Lallemand421f5b52012-02-06 18:15:57 +01003498 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003499 if (!dst)
3500 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003501 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003502
William Lallemand421f5b52012-02-06 18:15:57 +01003503 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003504 if (!dst)
3505 return NULL;
William Lallemand421f5b52012-02-06 18:15:57 +01003506 *dst++ = ' ';
3507 *dst++ = '+';
3508 *dst++ = '0';
3509 *dst++ = '0';
3510 *dst++ = '0';
3511 *dst++ = '0';
3512 *dst = '\0';
3513
3514 return dst;
3515}
3516
Yuxans Yao4e25b012012-10-19 10:36:09 +08003517/* localdate2str_log: write a date in the format :
3518 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003519 * Both t and tm must represent the same time.
3520 * return a pointer to the last char written (\0) or
3521 * NULL if there isn't enough space.
Yuxans Yao4e25b012012-10-19 10:36:09 +08003522 */
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003523char *localdate2str_log(char *dst, time_t t, struct tm *tm, size_t size)
Yuxans Yao4e25b012012-10-19 10:36:09 +08003524{
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003525 const char *gmt_offset;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003526 if (size < 27) /* the size is fixed: 26 chars + \0 */
3527 return NULL;
3528
Benoit GARNIERe2e5bde2016-03-27 03:04:16 +02003529 gmt_offset = get_gmt_offset(t, tm);
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003530
Yuxans Yao4e25b012012-10-19 10:36:09 +08003531 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003532 if (!dst)
3533 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003534 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003535
Yuxans Yao4e25b012012-10-19 10:36:09 +08003536 memcpy(dst, monthname[tm->tm_mon], 3); // month
3537 dst += 3;
3538 *dst++ = '/';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003539
Yuxans Yao4e25b012012-10-19 10:36:09 +08003540 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003541 if (!dst)
3542 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003543 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003544
Yuxans Yao4e25b012012-10-19 10:36:09 +08003545 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003546 if (!dst)
3547 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003548 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003549
Yuxans Yao4e25b012012-10-19 10:36:09 +08003550 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003551 if (!dst)
3552 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003553 *dst++ = ':';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003554
Yuxans Yao4e25b012012-10-19 10:36:09 +08003555 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003556 if (!dst)
3557 return NULL;
Yuxans Yao4e25b012012-10-19 10:36:09 +08003558 *dst++ = ' ';
Willy Tarreau4eee38a2019-02-12 11:26:29 +01003559
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02003560 memcpy(dst, gmt_offset, 5); // Offset from local time to GMT
Yuxans Yao4e25b012012-10-19 10:36:09 +08003561 dst += 5;
3562 *dst = '\0';
3563
3564 return dst;
3565}
3566
Willy Tarreaucb1949b2017-07-19 19:05:29 +02003567/* Returns the number of seconds since 01/01/1970 0:0:0 GMT for GMT date <tm>.
3568 * It is meant as a portable replacement for timegm() for use with valid inputs.
3569 * Returns undefined results for invalid dates (eg: months out of range 0..11).
3570 */
3571time_t my_timegm(const struct tm *tm)
3572{
3573 /* Each month has 28, 29, 30 or 31 days, or 28+N. The date in the year
3574 * is thus (current month - 1)*28 + cumulated_N[month] to count the
3575 * sum of the extra N days for elapsed months. The sum of all these N
3576 * days doesn't exceed 30 for a complete year (366-12*28) so it fits
3577 * in a 5-bit word. This means that with 60 bits we can represent a
3578 * matrix of all these values at once, which is fast and efficient to
3579 * access. The extra February day for leap years is not counted here.
3580 *
3581 * Jan : none = 0 (0)
3582 * Feb : Jan = 3 (3)
3583 * Mar : Jan..Feb = 3 (3 + 0)
3584 * Apr : Jan..Mar = 6 (3 + 0 + 3)
3585 * May : Jan..Apr = 8 (3 + 0 + 3 + 2)
3586 * Jun : Jan..May = 11 (3 + 0 + 3 + 2 + 3)
3587 * Jul : Jan..Jun = 13 (3 + 0 + 3 + 2 + 3 + 2)
3588 * Aug : Jan..Jul = 16 (3 + 0 + 3 + 2 + 3 + 2 + 3)
3589 * Sep : Jan..Aug = 19 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3)
3590 * Oct : Jan..Sep = 21 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2)
3591 * Nov : Jan..Oct = 24 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3)
3592 * Dec : Jan..Nov = 26 (3 + 0 + 3 + 2 + 3 + 2 + 3 + 3 + 2 + 3 + 2)
3593 */
3594 uint64_t extra =
3595 ( 0ULL << 0*5) + ( 3ULL << 1*5) + ( 3ULL << 2*5) + /* Jan, Feb, Mar, */
3596 ( 6ULL << 3*5) + ( 8ULL << 4*5) + (11ULL << 5*5) + /* Apr, May, Jun, */
3597 (13ULL << 6*5) + (16ULL << 7*5) + (19ULL << 8*5) + /* Jul, Aug, Sep, */
3598 (21ULL << 9*5) + (24ULL << 10*5) + (26ULL << 11*5); /* Oct, Nov, Dec, */
3599
3600 unsigned int y = tm->tm_year + 1900;
3601 unsigned int m = tm->tm_mon;
3602 unsigned long days = 0;
3603
3604 /* days since 1/1/1970 for full years */
3605 days += days_since_zero(y) - days_since_zero(1970);
3606
3607 /* days for full months in the current year */
3608 days += 28 * m + ((extra >> (m * 5)) & 0x1f);
3609
3610 /* count + 1 after March for leap years. A leap year is a year multiple
3611 * of 4, unless it's multiple of 100 without being multiple of 400. 2000
3612 * is leap, 1900 isn't, 1904 is.
3613 */
3614 if ((m > 1) && !(y & 3) && ((y % 100) || !(y % 400)))
3615 days++;
3616
3617 days += tm->tm_mday - 1;
3618 return days * 86400ULL + tm->tm_hour * 3600 + tm->tm_min * 60 + tm->tm_sec;
3619}
3620
Thierry Fournier93127942016-01-20 18:49:45 +01003621/* This function check a char. It returns true and updates
3622 * <date> and <len> pointer to the new position if the
3623 * character is found.
3624 */
3625static inline int parse_expect_char(const char **date, int *len, char c)
3626{
3627 if (*len < 1 || **date != c)
3628 return 0;
3629 (*len)--;
3630 (*date)++;
3631 return 1;
3632}
3633
3634/* This function expects a string <str> of len <l>. It return true and updates.
3635 * <date> and <len> if the string matches, otherwise, it returns false.
3636 */
3637static inline int parse_strcmp(const char **date, int *len, char *str, int l)
3638{
3639 if (*len < l || strncmp(*date, str, l) != 0)
3640 return 0;
3641 (*len) -= l;
3642 (*date) += l;
3643 return 1;
3644}
3645
3646/* This macro converts 3 chars name in integer. */
3647#define STR2I3(__a, __b, __c) ((__a) * 65536 + (__b) * 256 + (__c))
3648
3649/* day-name = %x4D.6F.6E ; "Mon", case-sensitive
3650 * / %x54.75.65 ; "Tue", case-sensitive
3651 * / %x57.65.64 ; "Wed", case-sensitive
3652 * / %x54.68.75 ; "Thu", case-sensitive
3653 * / %x46.72.69 ; "Fri", case-sensitive
3654 * / %x53.61.74 ; "Sat", case-sensitive
3655 * / %x53.75.6E ; "Sun", case-sensitive
3656 *
3657 * This array must be alphabetically sorted
3658 */
3659static inline int parse_http_dayname(const char **date, int *len, struct tm *tm)
3660{
3661 if (*len < 3)
3662 return 0;
3663 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3664 case STR2I3('M','o','n'): tm->tm_wday = 1; break;
3665 case STR2I3('T','u','e'): tm->tm_wday = 2; break;
3666 case STR2I3('W','e','d'): tm->tm_wday = 3; break;
3667 case STR2I3('T','h','u'): tm->tm_wday = 4; break;
3668 case STR2I3('F','r','i'): tm->tm_wday = 5; break;
3669 case STR2I3('S','a','t'): tm->tm_wday = 6; break;
3670 case STR2I3('S','u','n'): tm->tm_wday = 7; break;
3671 default: return 0;
3672 }
3673 *len -= 3;
3674 *date += 3;
3675 return 1;
3676}
3677
3678/* month = %x4A.61.6E ; "Jan", case-sensitive
3679 * / %x46.65.62 ; "Feb", case-sensitive
3680 * / %x4D.61.72 ; "Mar", case-sensitive
3681 * / %x41.70.72 ; "Apr", case-sensitive
3682 * / %x4D.61.79 ; "May", case-sensitive
3683 * / %x4A.75.6E ; "Jun", case-sensitive
3684 * / %x4A.75.6C ; "Jul", case-sensitive
3685 * / %x41.75.67 ; "Aug", case-sensitive
3686 * / %x53.65.70 ; "Sep", case-sensitive
3687 * / %x4F.63.74 ; "Oct", case-sensitive
3688 * / %x4E.6F.76 ; "Nov", case-sensitive
3689 * / %x44.65.63 ; "Dec", case-sensitive
3690 *
3691 * This array must be alphabetically sorted
3692 */
3693static inline int parse_http_monthname(const char **date, int *len, struct tm *tm)
3694{
3695 if (*len < 3)
3696 return 0;
3697 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3698 case STR2I3('J','a','n'): tm->tm_mon = 0; break;
3699 case STR2I3('F','e','b'): tm->tm_mon = 1; break;
3700 case STR2I3('M','a','r'): tm->tm_mon = 2; break;
3701 case STR2I3('A','p','r'): tm->tm_mon = 3; break;
3702 case STR2I3('M','a','y'): tm->tm_mon = 4; break;
3703 case STR2I3('J','u','n'): tm->tm_mon = 5; break;
3704 case STR2I3('J','u','l'): tm->tm_mon = 6; break;
3705 case STR2I3('A','u','g'): tm->tm_mon = 7; break;
3706 case STR2I3('S','e','p'): tm->tm_mon = 8; break;
3707 case STR2I3('O','c','t'): tm->tm_mon = 9; break;
3708 case STR2I3('N','o','v'): tm->tm_mon = 10; break;
3709 case STR2I3('D','e','c'): tm->tm_mon = 11; break;
3710 default: return 0;
3711 }
3712 *len -= 3;
3713 *date += 3;
3714 return 1;
3715}
3716
3717/* day-name-l = %x4D.6F.6E.64.61.79 ; "Monday", case-sensitive
3718 * / %x54.75.65.73.64.61.79 ; "Tuesday", case-sensitive
3719 * / %x57.65.64.6E.65.73.64.61.79 ; "Wednesday", case-sensitive
3720 * / %x54.68.75.72.73.64.61.79 ; "Thursday", case-sensitive
3721 * / %x46.72.69.64.61.79 ; "Friday", case-sensitive
3722 * / %x53.61.74.75.72.64.61.79 ; "Saturday", case-sensitive
3723 * / %x53.75.6E.64.61.79 ; "Sunday", case-sensitive
3724 *
3725 * This array must be alphabetically sorted
3726 */
3727static inline int parse_http_ldayname(const char **date, int *len, struct tm *tm)
3728{
3729 if (*len < 6) /* Minimum length. */
3730 return 0;
3731 switch (STR2I3((*date)[0], (*date)[1], (*date)[2])) {
3732 case STR2I3('M','o','n'):
3733 RET0_UNLESS(parse_strcmp(date, len, "Monday", 6));
3734 tm->tm_wday = 1;
3735 return 1;
3736 case STR2I3('T','u','e'):
3737 RET0_UNLESS(parse_strcmp(date, len, "Tuesday", 7));
3738 tm->tm_wday = 2;
3739 return 1;
3740 case STR2I3('W','e','d'):
3741 RET0_UNLESS(parse_strcmp(date, len, "Wednesday", 9));
3742 tm->tm_wday = 3;
3743 return 1;
3744 case STR2I3('T','h','u'):
3745 RET0_UNLESS(parse_strcmp(date, len, "Thursday", 8));
3746 tm->tm_wday = 4;
3747 return 1;
3748 case STR2I3('F','r','i'):
3749 RET0_UNLESS(parse_strcmp(date, len, "Friday", 6));
3750 tm->tm_wday = 5;
3751 return 1;
3752 case STR2I3('S','a','t'):
3753 RET0_UNLESS(parse_strcmp(date, len, "Saturday", 8));
3754 tm->tm_wday = 6;
3755 return 1;
3756 case STR2I3('S','u','n'):
3757 RET0_UNLESS(parse_strcmp(date, len, "Sunday", 6));
3758 tm->tm_wday = 7;
3759 return 1;
3760 }
3761 return 0;
3762}
3763
3764/* This function parses exactly 1 digit and returns the numeric value in "digit". */
3765static inline int parse_digit(const char **date, int *len, int *digit)
3766{
3767 if (*len < 1 || **date < '0' || **date > '9')
3768 return 0;
3769 *digit = (**date - '0');
3770 (*date)++;
3771 (*len)--;
3772 return 1;
3773}
3774
3775/* This function parses exactly 2 digits and returns the numeric value in "digit". */
3776static inline int parse_2digit(const char **date, int *len, int *digit)
3777{
3778 int value;
3779
3780 RET0_UNLESS(parse_digit(date, len, &value));
3781 (*digit) = value * 10;
3782 RET0_UNLESS(parse_digit(date, len, &value));
3783 (*digit) += value;
3784
3785 return 1;
3786}
3787
3788/* This function parses exactly 4 digits and returns the numeric value in "digit". */
3789static inline int parse_4digit(const char **date, int *len, int *digit)
3790{
3791 int value;
3792
3793 RET0_UNLESS(parse_digit(date, len, &value));
3794 (*digit) = value * 1000;
3795
3796 RET0_UNLESS(parse_digit(date, len, &value));
3797 (*digit) += value * 100;
3798
3799 RET0_UNLESS(parse_digit(date, len, &value));
3800 (*digit) += value * 10;
3801
3802 RET0_UNLESS(parse_digit(date, len, &value));
3803 (*digit) += value;
3804
3805 return 1;
3806}
3807
3808/* time-of-day = hour ":" minute ":" second
3809 * ; 00:00:00 - 23:59:60 (leap second)
3810 *
3811 * hour = 2DIGIT
3812 * minute = 2DIGIT
3813 * second = 2DIGIT
3814 */
3815static inline int parse_http_time(const char **date, int *len, struct tm *tm)
3816{
3817 RET0_UNLESS(parse_2digit(date, len, &tm->tm_hour)); /* hour 2DIGIT */
3818 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3819 RET0_UNLESS(parse_2digit(date, len, &tm->tm_min)); /* min 2DIGIT */
3820 RET0_UNLESS(parse_expect_char(date, len, ':')); /* expect ":" */
3821 RET0_UNLESS(parse_2digit(date, len, &tm->tm_sec)); /* sec 2DIGIT */
3822 return 1;
3823}
3824
3825/* From RFC7231
3826 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3827 *
3828 * IMF-fixdate = day-name "," SP date1 SP time-of-day SP GMT
3829 * ; fixed length/zone/capitalization subset of the format
3830 * ; see Section 3.3 of [RFC5322]
3831 *
3832 *
3833 * date1 = day SP month SP year
3834 * ; e.g., 02 Jun 1982
3835 *
3836 * day = 2DIGIT
3837 * year = 4DIGIT
3838 *
3839 * GMT = %x47.4D.54 ; "GMT", case-sensitive
3840 *
3841 * time-of-day = hour ":" minute ":" second
3842 * ; 00:00:00 - 23:59:60 (leap second)
3843 *
3844 * hour = 2DIGIT
3845 * minute = 2DIGIT
3846 * second = 2DIGIT
3847 *
3848 * DIGIT = decimal 0-9
3849 */
3850int parse_imf_date(const char *date, int len, struct tm *tm)
3851{
David Carlier327298c2016-11-20 10:42:38 +00003852 /* tm_gmtoff, if present, ought to be zero'ed */
3853 memset(tm, 0, sizeof(*tm));
3854
Thierry Fournier93127942016-01-20 18:49:45 +01003855 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3856 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3857 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3858 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3859 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3860 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3861 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3862 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3863 tm->tm_year -= 1900;
3864 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3865 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3866 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3867 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3868 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003869 return 1;
3870}
3871
3872/* From RFC7231
3873 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3874 *
3875 * rfc850-date = day-name-l "," SP date2 SP time-of-day SP GMT
3876 * date2 = day "-" month "-" 2DIGIT
3877 * ; e.g., 02-Jun-82
3878 *
3879 * day = 2DIGIT
3880 */
3881int parse_rfc850_date(const char *date, int len, struct tm *tm)
3882{
3883 int year;
3884
David Carlier327298c2016-11-20 10:42:38 +00003885 /* tm_gmtoff, if present, ought to be zero'ed */
3886 memset(tm, 0, sizeof(*tm));
3887
Thierry Fournier93127942016-01-20 18:49:45 +01003888 RET0_UNLESS(parse_http_ldayname(&date, &len, tm)); /* Read the day name */
3889 RET0_UNLESS(parse_expect_char(&date, &len, ',')); /* expect "," */
3890 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3891 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday)); /* day 2DIGIT */
3892 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3893 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* Month */
3894 RET0_UNLESS(parse_expect_char(&date, &len, '-')); /* expect "-" */
3895
3896 /* year = 2DIGIT
3897 *
3898 * Recipients of a timestamp value in rfc850-(*date) format, which uses a
3899 * two-digit year, MUST interpret a timestamp that appears to be more
3900 * than 50 years in the future as representing the most recent year in
3901 * the past that had the same last two digits.
3902 */
3903 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_year));
3904
3905 /* expect SP */
3906 if (!parse_expect_char(&date, &len, ' ')) {
3907 /* Maybe we have the date with 4 digits. */
3908 RET0_UNLESS(parse_2digit(&date, &len, &year));
3909 tm->tm_year = (tm->tm_year * 100 + year) - 1900;
3910 /* expect SP */
3911 RET0_UNLESS(parse_expect_char(&date, &len, ' '));
3912 } else {
3913 /* I fix 60 as pivot: >60: +1900, <60: +2000. Note that the
3914 * tm_year is the number of year since 1900, so for +1900, we
3915 * do nothing, and for +2000, we add 100.
3916 */
3917 if (tm->tm_year <= 60)
3918 tm->tm_year += 100;
3919 }
3920
3921 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3922 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3923 RET0_UNLESS(parse_strcmp(&date, &len, "GMT", 3)); /* GMT = %x47.4D.54 ; "GMT", case-sensitive */
3924 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003925
3926 return 1;
3927}
3928
3929/* From RFC7231
3930 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3931 *
3932 * asctime-date = day-name SP date3 SP time-of-day SP year
3933 * date3 = month SP ( 2DIGIT / ( SP 1DIGIT ))
3934 * ; e.g., Jun 2
3935 *
3936 * HTTP-date is case sensitive. A sender MUST NOT generate additional
3937 * whitespace in an HTTP-date beyond that specifically included as SP in
3938 * the grammar.
3939 */
3940int parse_asctime_date(const char *date, int len, struct tm *tm)
3941{
David Carlier327298c2016-11-20 10:42:38 +00003942 /* tm_gmtoff, if present, ought to be zero'ed */
3943 memset(tm, 0, sizeof(*tm));
3944
Thierry Fournier93127942016-01-20 18:49:45 +01003945 RET0_UNLESS(parse_http_dayname(&date, &len, tm)); /* day-name */
3946 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3947 RET0_UNLESS(parse_http_monthname(&date, &len, tm)); /* expect month */
3948 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3949
3950 /* expect SP and 1DIGIT or 2DIGIT */
3951 if (parse_expect_char(&date, &len, ' '))
3952 RET0_UNLESS(parse_digit(&date, &len, &tm->tm_mday));
3953 else
3954 RET0_UNLESS(parse_2digit(&date, &len, &tm->tm_mday));
3955
3956 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3957 RET0_UNLESS(parse_http_time(&date, &len, tm)); /* Parse time. */
3958 RET0_UNLESS(parse_expect_char(&date, &len, ' ')); /* expect SP */
3959 RET0_UNLESS(parse_4digit(&date, &len, &tm->tm_year)); /* year = 4DIGIT */
3960 tm->tm_year -= 1900;
3961 tm->tm_isdst = -1;
Thierry Fournier93127942016-01-20 18:49:45 +01003962 return 1;
3963}
3964
3965/* From RFC7231
3966 * https://tools.ietf.org/html/rfc7231#section-7.1.1.1
3967 *
3968 * HTTP-date = IMF-fixdate / obs-date
3969 * obs-date = rfc850-date / asctime-date
3970 *
3971 * parses an HTTP date in the RFC format and is accepted
3972 * alternatives. <date> is the strinf containing the date,
3973 * len is the len of the string. <tm> is filled with the
3974 * parsed time. We must considers this time as GMT.
3975 */
3976int parse_http_date(const char *date, int len, struct tm *tm)
3977{
3978 if (parse_imf_date(date, len, tm))
3979 return 1;
3980
3981 if (parse_rfc850_date(date, len, tm))
3982 return 1;
3983
3984 if (parse_asctime_date(date, len, tm))
3985 return 1;
3986
3987 return 0;
3988}
3989
Willy Tarreau4deeb102021-01-29 10:47:52 +01003990/* print the time <ns> in a short form (exactly 7 chars) at the end of buffer
3991 * <out>. "-" is printed if the value is zero, "inf" if larger than 1000 years.
3992 * It returns the new buffer length, or 0 if it doesn't fit. The value will be
3993 * surrounded by <pfx> and <sfx> respectively if not NULL.
3994 */
3995int print_time_short(struct buffer *out, const char *pfx, uint64_t ns, const char *sfx)
3996{
3997 double val = ns; // 52 bits of mantissa keep ns accuracy over 52 days
3998 const char *unit;
3999
4000 if (!pfx)
4001 pfx = "";
4002 if (!sfx)
4003 sfx = "";
4004
4005 do {
4006 unit = " - "; if (val <= 0.0) break;
4007 unit = "ns"; if (val < 1000.0) break;
4008 unit = "us"; val /= 1000.0; if (val < 1000.0) break;
4009 unit = "ms"; val /= 1000.0; if (val < 1000.0) break;
4010 unit = "s "; val /= 1000.0; if (val < 60.0) break;
4011 unit = "m "; val /= 60.0; if (val < 60.0) break;
4012 unit = "h "; val /= 60.0; if (val < 24.0) break;
4013 unit = "d "; val /= 24.0; if (val < 365.0) break;
4014 unit = "yr"; val /= 365.0; if (val < 1000.0) break;
4015 unit = " inf "; val = 0.0; break;
4016 } while (0);
4017
4018 if (val <= 0.0)
4019 return chunk_appendf(out, "%s%7s%s", pfx, unit, sfx);
4020 else if (val < 10.0)
4021 return chunk_appendf(out, "%s%1.3f%s%s", pfx, val, unit, sfx);
4022 else if (val < 100.0)
4023 return chunk_appendf(out, "%s%2.2f%s%s", pfx, val, unit, sfx);
4024 else
4025 return chunk_appendf(out, "%s%3.1f%s%s", pfx, val, unit, sfx);
4026}
4027
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004028/* Dynamically allocates a string of the proper length to hold the formatted
4029 * output. NULL is returned on error. The caller is responsible for freeing the
4030 * memory area using free(). The resulting string is returned in <out> if the
4031 * pointer is not NULL. A previous version of <out> might be used to build the
4032 * new string, and it will be freed before returning if it is not NULL, which
4033 * makes it possible to build complex strings from iterative calls without
4034 * having to care about freeing intermediate values, as in the example below :
4035 *
4036 * memprintf(&err, "invalid argument: '%s'", arg);
4037 * ...
4038 * memprintf(&err, "parser said : <%s>\n", *err);
4039 * ...
4040 * free(*err);
4041 *
4042 * This means that <err> must be initialized to NULL before first invocation.
4043 * The return value also holds the allocated string, which eases error checking
4044 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02004045 * passed instead and it will be ignored. The returned message will then also
4046 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004047 *
4048 * It is also convenient to use it without any free except the last one :
4049 * err = NULL;
4050 * if (!fct1(err)) report(*err);
4051 * if (!fct2(err)) report(*err);
4052 * if (!fct3(err)) report(*err);
4053 * free(*err);
Christopher Faulet93a518f2017-10-24 11:25:33 +02004054 *
4055 * memprintf relies on memvprintf. This last version can be called from any
4056 * function with variadic arguments.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004057 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02004058char *memvprintf(char **out, const char *format, va_list orig_args)
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004059{
4060 va_list args;
4061 char *ret = NULL;
4062 int allocated = 0;
4063 int needed = 0;
4064
Willy Tarreaueb6cead2012-09-20 19:43:14 +02004065 if (!out)
4066 return NULL;
4067
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004068 do {
Willy Tarreaue0609f52019-03-29 19:13:23 +01004069 char buf1;
4070
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004071 /* vsnprintf() will return the required length even when the
4072 * target buffer is NULL. We do this in a loop just in case
4073 * intermediate evaluations get wrong.
4074 */
Christopher Faulet93a518f2017-10-24 11:25:33 +02004075 va_copy(args, orig_args);
Willy Tarreaue0609f52019-03-29 19:13:23 +01004076 needed = vsnprintf(ret ? ret : &buf1, allocated, format, args);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004077 va_end(args);
Willy Tarreau1b2fed62013-04-01 22:48:54 +02004078 if (needed < allocated) {
4079 /* Note: on Solaris 8, the first iteration always
4080 * returns -1 if allocated is zero, so we force a
4081 * retry.
4082 */
4083 if (!allocated)
4084 needed = 0;
4085 else
4086 break;
4087 }
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004088
Willy Tarreau1b2fed62013-04-01 22:48:54 +02004089 allocated = needed + 1;
Hubert Verstraete831962e2016-06-28 22:44:26 +02004090 ret = my_realloc2(ret, allocated);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004091 } while (ret);
4092
4093 if (needed < 0) {
4094 /* an error was encountered */
Willy Tarreau61cfdf42021-02-20 10:46:51 +01004095 ha_free(&ret);
Willy Tarreau9a7bea52012-04-27 11:16:50 +02004096 }
4097
4098 if (out) {
4099 free(*out);
4100 *out = ret;
4101 }
4102
4103 return ret;
4104}
William Lallemand421f5b52012-02-06 18:15:57 +01004105
Christopher Faulet93a518f2017-10-24 11:25:33 +02004106char *memprintf(char **out, const char *format, ...)
4107{
4108 va_list args;
4109 char *ret = NULL;
4110
4111 va_start(args, format);
4112 ret = memvprintf(out, format, args);
4113 va_end(args);
4114
4115 return ret;
4116}
4117
Willy Tarreau21c705b2012-09-14 11:40:36 +02004118/* Used to add <level> spaces before each line of <out>, unless there is only one line.
4119 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02004120 * freed by the caller. It also supports being passed a NULL which results in the same
4121 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02004122 * Example of use :
4123 * parse(cmd, &err); (callee: memprintf(&err, ...))
4124 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
4125 * free(err);
4126 */
4127char *indent_msg(char **out, int level)
4128{
4129 char *ret, *in, *p;
4130 int needed = 0;
4131 int lf = 0;
4132 int lastlf = 0;
4133 int len;
4134
Willy Tarreau70eec382012-10-10 08:56:47 +02004135 if (!out || !*out)
4136 return NULL;
4137
Willy Tarreau21c705b2012-09-14 11:40:36 +02004138 in = *out - 1;
4139 while ((in = strchr(in + 1, '\n')) != NULL) {
4140 lastlf = in - *out;
4141 lf++;
4142 }
4143
4144 if (!lf) /* single line, no LF, return it as-is */
4145 return *out;
4146
4147 len = strlen(*out);
4148
4149 if (lf == 1 && lastlf == len - 1) {
4150 /* single line, LF at end, strip it and return as-is */
4151 (*out)[lastlf] = 0;
4152 return *out;
4153 }
4154
4155 /* OK now we have at least one LF, we need to process the whole string
4156 * as a multi-line string. What we'll do :
4157 * - prefix with an LF if there is none
4158 * - add <level> spaces before each line
4159 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
4160 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
4161 */
4162
4163 needed = 1 + level * (lf + 1) + len + 1;
4164 p = ret = malloc(needed);
4165 in = *out;
4166
4167 /* skip initial LFs */
4168 while (*in == '\n')
4169 in++;
4170
4171 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
4172 while (*in) {
4173 *p++ = '\n';
4174 memset(p, ' ', level);
4175 p += level;
4176 do {
4177 *p++ = *in++;
4178 } while (*in && *in != '\n');
4179 if (*in)
4180 in++;
4181 }
4182 *p = 0;
4183
4184 free(*out);
4185 *out = ret;
4186
4187 return ret;
4188}
4189
Willy Tarreaua2c99112019-08-21 13:17:37 +02004190/* makes a copy of message <in> into <out>, with each line prefixed with <pfx>
4191 * and end of lines replaced with <eol> if not 0. The first line to indent has
4192 * to be indicated in <first> (starts at zero), so that it is possible to skip
4193 * indenting the first line if it has to be appended after an existing message.
4194 * Empty strings are never indented, and NULL strings are considered empty both
4195 * for <in> and <pfx>. It returns non-zero if an EOL was appended as the last
4196 * character, non-zero otherwise.
4197 */
4198int append_prefixed_str(struct buffer *out, const char *in, const char *pfx, char eol, int first)
4199{
4200 int bol, lf;
4201 int pfxlen = pfx ? strlen(pfx) : 0;
4202
4203 if (!in)
4204 return 0;
4205
4206 bol = 1;
4207 lf = 0;
4208 while (*in) {
4209 if (bol && pfxlen) {
4210 if (first > 0)
4211 first--;
4212 else
4213 b_putblk(out, pfx, pfxlen);
4214 bol = 0;
4215 }
4216
4217 lf = (*in == '\n');
4218 bol |= lf;
4219 b_putchr(out, (lf && eol) ? eol : *in);
4220 in++;
4221 }
4222 return lf;
4223}
4224
Willy Tarreau9d22e562019-03-29 18:49:09 +01004225/* removes environment variable <name> from the environment as found in
4226 * environ. This is only provided as an alternative for systems without
4227 * unsetenv() (old Solaris and AIX versions). THIS IS NOT THREAD SAFE.
Ilya Shipitsin856aabc2020-04-16 23:51:34 +05004228 * The principle is to scan environ for each occurrence of variable name
Willy Tarreau9d22e562019-03-29 18:49:09 +01004229 * <name> and to replace the matching pointers with the last pointer of
4230 * the array (since variables are not ordered).
4231 * It always returns 0 (success).
4232 */
4233int my_unsetenv(const char *name)
4234{
4235 extern char **environ;
4236 char **p = environ;
4237 int vars;
4238 int next;
4239 int len;
4240
4241 len = strlen(name);
4242 for (vars = 0; p[vars]; vars++)
4243 ;
4244 next = 0;
4245 while (next < vars) {
4246 if (strncmp(p[next], name, len) != 0 || p[next][len] != '=') {
4247 next++;
4248 continue;
4249 }
4250 if (next < vars - 1)
4251 p[next] = p[vars - 1];
4252 p[--vars] = NULL;
4253 }
4254 return 0;
4255}
4256
Willy Tarreaudad36a32013-03-11 01:20:04 +01004257/* Convert occurrences of environment variables in the input string to their
4258 * corresponding value. A variable is identified as a series of alphanumeric
4259 * characters or underscores following a '$' sign. The <in> string must be
4260 * free()able. NULL returns NULL. The resulting string might be reallocated if
4261 * some expansion is made. Variable names may also be enclosed into braces if
4262 * needed (eg: to concatenate alphanum characters).
4263 */
4264char *env_expand(char *in)
4265{
4266 char *txt_beg;
4267 char *out;
4268 char *txt_end;
4269 char *var_beg;
4270 char *var_end;
4271 char *value;
4272 char *next;
4273 int out_len;
4274 int val_len;
4275
4276 if (!in)
4277 return in;
4278
4279 value = out = NULL;
4280 out_len = 0;
4281
4282 txt_beg = in;
4283 do {
4284 /* look for next '$' sign in <in> */
4285 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
4286
4287 if (!*txt_end && !out) /* end and no expansion performed */
4288 return in;
4289
4290 val_len = 0;
4291 next = txt_end;
4292 if (*txt_end == '$') {
4293 char save;
4294
4295 var_beg = txt_end + 1;
4296 if (*var_beg == '{')
4297 var_beg++;
4298
4299 var_end = var_beg;
Willy Tarreau90807112020-02-25 08:16:33 +01004300 while (isalnum((unsigned char)*var_end) || *var_end == '_') {
Willy Tarreaudad36a32013-03-11 01:20:04 +01004301 var_end++;
4302 }
4303
4304 next = var_end;
4305 if (*var_end == '}' && (var_beg > txt_end + 1))
4306 next++;
4307
4308 /* get value of the variable name at this location */
4309 save = *var_end;
4310 *var_end = '\0';
4311 value = getenv(var_beg);
4312 *var_end = save;
4313 val_len = value ? strlen(value) : 0;
4314 }
4315
Hubert Verstraete831962e2016-06-28 22:44:26 +02004316 out = my_realloc2(out, out_len + (txt_end - txt_beg) + val_len + 1);
Willy Tarreaudad36a32013-03-11 01:20:04 +01004317 if (txt_end > txt_beg) {
4318 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
4319 out_len += txt_end - txt_beg;
4320 }
4321 if (val_len) {
4322 memcpy(out + out_len, value, val_len);
4323 out_len += val_len;
4324 }
4325 out[out_len] = 0;
4326 txt_beg = next;
4327 } while (*txt_beg);
4328
4329 /* here we know that <out> was allocated and that we don't need <in> anymore */
4330 free(in);
4331 return out;
4332}
4333
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004334
4335/* same as strstr() but case-insensitive and with limit length */
4336const char *strnistr(const char *str1, int len_str1, const char *str2, int len_str2)
4337{
4338 char *pptr, *sptr, *start;
Willy Tarreauc8746532014-05-28 23:05:07 +02004339 unsigned int slen, plen;
4340 unsigned int tmp1, tmp2;
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004341
4342 if (str1 == NULL || len_str1 == 0) // search pattern into an empty string => search is not found
4343 return NULL;
4344
4345 if (str2 == NULL || len_str2 == 0) // pattern is empty => every str1 match
4346 return str1;
4347
4348 if (len_str1 < len_str2) // pattern is longer than string => search is not found
4349 return NULL;
4350
4351 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 +02004352 while (toupper((unsigned char)*start) != toupper((unsigned char)*str2)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004353 start++;
4354 slen--;
4355 tmp1++;
4356
4357 if (tmp1 >= len_str1)
4358 return NULL;
4359
4360 /* if pattern longer than string */
4361 if (slen < plen)
4362 return NULL;
4363 }
4364
4365 sptr = start;
4366 pptr = (char *)str2;
4367
4368 tmp2 = 0;
Willy Tarreauf278eec2020-07-05 21:46:32 +02004369 while (toupper((unsigned char)*sptr) == toupper((unsigned char)*pptr)) {
de Lafond Guillaume88c278f2013-04-15 19:27:10 +02004370 sptr++;
4371 pptr++;
4372 tmp2++;
4373
4374 if (*pptr == '\0' || tmp2 == len_str2) /* end of pattern found */
4375 return start;
4376 if (*sptr == '\0' || tmp2 == len_str1) /* end of string found and the pattern is not fully found */
4377 return NULL;
4378 }
4379 }
4380 return NULL;
4381}
4382
Willy Tarreau3ff476e2022-03-30 10:02:56 +02004383/* Returns true if s1 < s2 < s3 otherwise zero. Both s1 and s3 may be NULL and
4384 * in this case only non-null strings are compared. This allows to pass initial
4385 * values in iterators and in sort functions.
4386 */
4387int strordered(const char *s1, const char *s2, const char *s3)
4388{
4389 return (!s1 || strcmp(s1, s2) < 0) && (!s3 || strcmp(s2, s3) < 0);
4390}
4391
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004392/* This function read the next valid utf8 char.
4393 * <s> is the byte srray to be decode, <len> is its length.
4394 * The function returns decoded char encoded like this:
4395 * The 4 msb are the return code (UTF8_CODE_*), the 4 lsb
4396 * are the length read. The decoded character is stored in <c>.
4397 */
4398unsigned char utf8_next(const char *s, int len, unsigned int *c)
4399{
4400 const unsigned char *p = (unsigned char *)s;
4401 int dec;
4402 unsigned char code = UTF8_CODE_OK;
4403
4404 if (len < 1)
4405 return UTF8_CODE_OK;
4406
4407 /* Check the type of UTF8 sequence
4408 *
4409 * 0... .... 0x00 <= x <= 0x7f : 1 byte: ascii char
4410 * 10.. .... 0x80 <= x <= 0xbf : invalid sequence
4411 * 110. .... 0xc0 <= x <= 0xdf : 2 bytes
4412 * 1110 .... 0xe0 <= x <= 0xef : 3 bytes
4413 * 1111 0... 0xf0 <= x <= 0xf7 : 4 bytes
4414 * 1111 10.. 0xf8 <= x <= 0xfb : 5 bytes
4415 * 1111 110. 0xfc <= x <= 0xfd : 6 bytes
4416 * 1111 111. 0xfe <= x <= 0xff : invalid sequence
4417 */
4418 switch (*p) {
4419 case 0x00 ... 0x7f:
4420 *c = *p;
4421 return UTF8_CODE_OK | 1;
4422
4423 case 0x80 ... 0xbf:
4424 *c = *p;
4425 return UTF8_CODE_BADSEQ | 1;
4426
4427 case 0xc0 ... 0xdf:
4428 if (len < 2) {
4429 *c = *p;
4430 return UTF8_CODE_BADSEQ | 1;
4431 }
4432 *c = *p & 0x1f;
4433 dec = 1;
4434 break;
4435
4436 case 0xe0 ... 0xef:
4437 if (len < 3) {
4438 *c = *p;
4439 return UTF8_CODE_BADSEQ | 1;
4440 }
4441 *c = *p & 0x0f;
4442 dec = 2;
4443 break;
4444
4445 case 0xf0 ... 0xf7:
4446 if (len < 4) {
4447 *c = *p;
4448 return UTF8_CODE_BADSEQ | 1;
4449 }
4450 *c = *p & 0x07;
4451 dec = 3;
4452 break;
4453
4454 case 0xf8 ... 0xfb:
4455 if (len < 5) {
4456 *c = *p;
4457 return UTF8_CODE_BADSEQ | 1;
4458 }
4459 *c = *p & 0x03;
4460 dec = 4;
4461 break;
4462
4463 case 0xfc ... 0xfd:
4464 if (len < 6) {
4465 *c = *p;
4466 return UTF8_CODE_BADSEQ | 1;
4467 }
4468 *c = *p & 0x01;
4469 dec = 5;
4470 break;
4471
4472 case 0xfe ... 0xff:
4473 default:
4474 *c = *p;
4475 return UTF8_CODE_BADSEQ | 1;
4476 }
4477
4478 p++;
4479
4480 while (dec > 0) {
4481
4482 /* need 0x10 for the 2 first bits */
4483 if ( ( *p & 0xc0 ) != 0x80 )
4484 return UTF8_CODE_BADSEQ | ((p-(unsigned char *)s)&0xffff);
4485
4486 /* add data at char */
4487 *c = ( *c << 6 ) | ( *p & 0x3f );
4488
4489 dec--;
4490 p++;
4491 }
4492
4493 /* Check ovelong encoding.
4494 * 1 byte : 5 + 6 : 11 : 0x80 ... 0x7ff
4495 * 2 bytes : 4 + 6 + 6 : 16 : 0x800 ... 0xffff
4496 * 3 bytes : 3 + 6 + 6 + 6 : 21 : 0x10000 ... 0x1fffff
4497 */
Thierry FOURNIER9e7ec082015-03-12 19:32:38 +01004498 if (( *c <= 0x7f && (p-(unsigned char *)s) > 1) ||
Thierry FOURNIER317e1c42014-08-12 10:20:47 +02004499 (*c >= 0x80 && *c <= 0x7ff && (p-(unsigned char *)s) > 2) ||
4500 (*c >= 0x800 && *c <= 0xffff && (p-(unsigned char *)s) > 3) ||
4501 (*c >= 0x10000 && *c <= 0x1fffff && (p-(unsigned char *)s) > 4))
4502 code |= UTF8_CODE_OVERLONG;
4503
4504 /* Check invalid UTF8 range. */
4505 if ((*c >= 0xd800 && *c <= 0xdfff) ||
4506 (*c >= 0xfffe && *c <= 0xffff))
4507 code |= UTF8_CODE_INVRANGE;
4508
4509 return code | ((p-(unsigned char *)s)&0x0f);
4510}
4511
Maxime de Roucydc887852016-05-13 23:52:54 +02004512/* append a copy of string <str> (in a wordlist) at the end of the list <li>
4513 * On failure : return 0 and <err> filled with an error message.
4514 * The caller is responsible for freeing the <err> and <str> copy
4515 * memory area using free()
4516 */
4517int list_append_word(struct list *li, const char *str, char **err)
4518{
4519 struct wordlist *wl;
4520
4521 wl = calloc(1, sizeof(*wl));
4522 if (!wl) {
4523 memprintf(err, "out of memory");
4524 goto fail_wl;
4525 }
4526
4527 wl->s = strdup(str);
4528 if (!wl->s) {
4529 memprintf(err, "out of memory");
4530 goto fail_wl_s;
4531 }
4532
Willy Tarreau2b718102021-04-21 07:32:39 +02004533 LIST_APPEND(li, &wl->list);
Maxime de Roucydc887852016-05-13 23:52:54 +02004534
4535 return 1;
4536
4537fail_wl_s:
4538 free(wl->s);
4539fail_wl:
4540 free(wl);
4541 return 0;
4542}
4543
Willy Tarreau37101052019-05-20 16:48:20 +02004544/* indicates if a memory location may safely be read or not. The trick consists
4545 * in performing a harmless syscall using this location as an input and letting
4546 * the operating system report whether it's OK or not. For this we have the
4547 * stat() syscall, which will return EFAULT when the memory location supposed
4548 * to contain the file name is not readable. If it is readable it will then
4549 * either return 0 if the area contains an existing file name, or -1 with
4550 * another code. This must not be abused, and some audit systems might detect
4551 * this as abnormal activity. It's used only for unsafe dumps.
4552 */
4553int may_access(const void *ptr)
4554{
4555 struct stat buf;
4556
4557 if (stat(ptr, &buf) == 0)
4558 return 1;
4559 if (errno == EFAULT)
4560 return 0;
4561 return 1;
4562}
4563
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004564/* print a string of text buffer to <out>. The format is :
4565 * Non-printable chars \t, \n, \r and \e are * encoded in C format.
4566 * Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
4567 * Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
4568 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004569int dump_text(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004570{
4571 unsigned char c;
Tim Duesterhus18795d42021-08-29 00:58:22 +02004572 size_t ptr = 0;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004573
Tim Duesterhus18795d42021-08-29 00:58:22 +02004574 while (ptr < bsize && buf[ptr]) {
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004575 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004576 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\' && c != ' ' && c != '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004577 if (out->data > out->size - 1)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004578 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004579 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004580 }
4581 else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\' || c == ' ' || c == '=') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004582 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004583 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004584 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004585 switch (c) {
4586 case ' ': c = ' '; break;
4587 case '\t': c = 't'; break;
4588 case '\n': c = 'n'; break;
4589 case '\r': c = 'r'; break;
4590 case '\e': c = 'e'; break;
4591 case '\\': c = '\\'; break;
4592 case '=': c = '='; break;
4593 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004594 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004595 }
4596 else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004597 if (out->data > out->size - 4)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004598 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004599 out->area[out->data++] = '\\';
4600 out->area[out->data++] = 'x';
4601 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4602 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004603 }
4604 ptr++;
4605 }
4606
4607 return ptr;
4608}
4609
4610/* print a buffer in hexa.
4611 * Print stopped if <bsize> is reached, or if no more place in the chunk.
4612 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004613int dump_binary(struct buffer *out, const char *buf, int bsize)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004614{
4615 unsigned char c;
4616 int ptr = 0;
4617
4618 while (ptr < bsize) {
4619 c = buf[ptr];
4620
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004621 if (out->data > out->size - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004622 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004623 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4624 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004625
4626 ptr++;
4627 }
4628 return ptr;
4629}
4630
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004631/* Appends into buffer <out> a hex dump of memory area <buf> for <len> bytes,
4632 * prepending each line with prefix <pfx>. The output is *not* initialized.
4633 * The output will not wrap pas the buffer's end so it is more optimal if the
4634 * caller makes sure the buffer is aligned first. A trailing zero will always
4635 * be appended (and not counted) if there is room for it. The caller must make
Willy Tarreau37101052019-05-20 16:48:20 +02004636 * sure that the area is dumpable first. If <unsafe> is non-null, the memory
4637 * locations are checked first for being readable.
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004638 */
Willy Tarreau37101052019-05-20 16:48:20 +02004639void dump_hex(struct buffer *out, const char *pfx, const void *buf, int len, int unsafe)
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004640{
4641 const unsigned char *d = buf;
4642 int i, j, start;
4643
4644 d = (const unsigned char *)(((unsigned long)buf) & -16);
4645 start = ((unsigned long)buf) & 15;
4646
4647 for (i = 0; i < start + len; i += 16) {
4648 chunk_appendf(out, (sizeof(void *) == 4) ? "%s%8p: " : "%s%16p: ", pfx, d + i);
4649
Willy Tarreau37101052019-05-20 16:48:20 +02004650 // 0: unchecked, 1: checked safe, 2: danger
4651 unsafe = !!unsafe;
4652 if (unsafe && !may_access(d + i))
4653 unsafe = 2;
4654
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004655 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004656 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004657 chunk_strcat(out, "'' ");
Willy Tarreau37101052019-05-20 16:48:20 +02004658 else if (unsafe > 1)
4659 chunk_strcat(out, "** ");
4660 else
4661 chunk_appendf(out, "%02x ", d[i + j]);
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004662
4663 if (j == 7)
4664 chunk_strcat(out, "- ");
4665 }
4666 chunk_strcat(out, " ");
4667 for (j = 0; j < 16; j++) {
Willy Tarreau37101052019-05-20 16:48:20 +02004668 if ((i + j < start) || (i + j >= start + len))
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004669 chunk_strcat(out, "'");
Willy Tarreau37101052019-05-20 16:48:20 +02004670 else if (unsafe > 1)
4671 chunk_strcat(out, "*");
Willy Tarreau90807112020-02-25 08:16:33 +01004672 else if (isprint((unsigned char)d[i + j]))
Willy Tarreau37101052019-05-20 16:48:20 +02004673 chunk_appendf(out, "%c", d[i + j]);
4674 else
4675 chunk_strcat(out, ".");
Willy Tarreau9fc5dcb2019-05-20 16:13:40 +02004676 }
4677 chunk_strcat(out, "\n");
4678 }
4679}
4680
Willy Tarreau762fb3e2020-03-03 15:57:10 +01004681/* dumps <pfx> followed by <n> bytes from <addr> in hex form into buffer <buf>
4682 * enclosed in brackets after the address itself, formatted on 14 chars
4683 * including the "0x" prefix. This is meant to be used as a prefix for code
4684 * areas. For example:
4685 * "0x7f10b6557690 [48 c7 c0 0f 00 00 00 0f]"
4686 * It relies on may_access() to know if the bytes are dumpable, otherwise "--"
4687 * is emitted. A NULL <pfx> will be considered empty.
4688 */
4689void dump_addr_and_bytes(struct buffer *buf, const char *pfx, const void *addr, int n)
4690{
4691 int ok = 0;
4692 int i;
4693
4694 chunk_appendf(buf, "%s%#14lx [", pfx ? pfx : "", (long)addr);
4695
4696 for (i = 0; i < n; i++) {
4697 if (i == 0 || (((long)(addr + i) ^ (long)(addr)) & 4096))
4698 ok = may_access(addr + i);
4699 if (ok)
4700 chunk_appendf(buf, "%02x%s", ((uint8_t*)addr)[i], (i<n-1) ? " " : "]");
4701 else
4702 chunk_appendf(buf, "--%s", (i<n-1) ? " " : "]");
4703 }
4704}
4705
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004706/* print a line of text buffer (limited to 70 bytes) to <out>. The format is :
4707 * <2 spaces> <offset=5 digits> <space or plus> <space> <70 chars max> <\n>
4708 * which is 60 chars per line. Non-printable chars \t, \n, \r and \e are
4709 * encoded in C format. Other non-printable chars are encoded "\xHH". Original
4710 * lines are respected within the limit of 70 output chars. Lines that are
4711 * continuation of a previous truncated line begin with "+" instead of " "
4712 * after the offset. The new pointer is returned.
4713 */
Willy Tarreau83061a82018-07-13 11:56:34 +02004714int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004715 int *line, int ptr)
4716{
4717 int end;
4718 unsigned char c;
4719
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004720 end = out->data + 80;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004721 if (end > out->size)
4722 return ptr;
4723
4724 chunk_appendf(out, " %05d%c ", ptr, (ptr == *line) ? ' ' : '+');
4725
4726 while (ptr < len && ptr < bsize) {
4727 c = buf[ptr];
Willy Tarreau90807112020-02-25 08:16:33 +01004728 if (isprint((unsigned char)c) && isascii((unsigned char)c) && c != '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004729 if (out->data > end - 2)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004730 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004731 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004732 } else if (c == '\t' || c == '\n' || c == '\r' || c == '\e' || c == '\\') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004733 if (out->data > end - 3)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004734 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004735 out->area[out->data++] = '\\';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004736 switch (c) {
4737 case '\t': c = 't'; break;
4738 case '\n': c = 'n'; break;
4739 case '\r': c = 'r'; break;
4740 case '\e': c = 'e'; break;
4741 case '\\': c = '\\'; break;
4742 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004743 out->area[out->data++] = c;
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004744 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004745 if (out->data > end - 5)
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004746 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004747 out->area[out->data++] = '\\';
4748 out->area[out->data++] = 'x';
4749 out->area[out->data++] = hextab[(c >> 4) & 0xF];
4750 out->area[out->data++] = hextab[c & 0xF];
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004751 }
4752 if (buf[ptr++] == '\n') {
4753 /* we had a line break, let's return now */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004754 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004755 *line = ptr;
4756 return ptr;
4757 }
4758 }
4759 /* we have an incomplete line, we return it as-is */
Willy Tarreau843b7cb2018-07-13 10:54:26 +02004760 out->area[out->data++] = '\n';
Willy Tarreau97c2ae12016-11-22 18:00:20 +01004761 return ptr;
4762}
4763
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004764/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
Willy Tarreaued936c52017-04-27 18:03:20 +02004765 * has address <baseaddr>. String <pfx> may be placed as a prefix in front of
4766 * each line. It may be NULL if unused. The output is emitted to file <out>.
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004767 */
Willy Tarreaued936c52017-04-27 18:03:20 +02004768void debug_hexdump(FILE *out, const char *pfx, const char *buf,
4769 unsigned int baseaddr, int len)
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004770{
Willy Tarreau73459792017-04-11 07:58:08 +02004771 unsigned int i;
4772 int b, j;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004773
4774 for (i = 0; i < (len + (baseaddr & 15)); i += 16) {
4775 b = i - (baseaddr & 15);
Willy Tarreaued936c52017-04-27 18:03:20 +02004776 fprintf(out, "%s%08x: ", pfx ? pfx : "", i + (baseaddr & ~15));
Willy Tarreau0ebb5112016-12-05 00:10:57 +01004777 for (j = 0; j < 8; j++) {
4778 if (b + j >= 0 && b + j < len)
4779 fprintf(out, "%02x ", (unsigned char)buf[b + j]);
4780 else
4781 fprintf(out, " ");
4782 }
4783
4784 if (b + j >= 0 && b + j < len)
4785 fputc('-', out);
4786 else
4787 fputc(' ', out);
4788
4789 for (j = 8; j < 16; j++) {
4790 if (b + j >= 0 && b + j < len)
4791 fprintf(out, " %02x", (unsigned char)buf[b + j]);
4792 else
4793 fprintf(out, " ");
4794 }
4795
4796 fprintf(out, " ");
4797 for (j = 0; j < 16; j++) {
4798 if (b + j >= 0 && b + j < len) {
4799 if (isprint((unsigned char)buf[b + j]))
4800 fputc((unsigned char)buf[b + j], out);
4801 else
4802 fputc('.', out);
4803 }
4804 else
4805 fputc(' ', out);
4806 }
4807 fputc('\n', out);
4808 }
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004809}
4810
Willy Tarreaubb869862020-04-16 10:52:41 +02004811/* Tries to report the executable path name on platforms supporting this. If
4812 * not found or not possible, returns NULL.
4813 */
4814const char *get_exec_path()
4815{
4816 const char *ret = NULL;
4817
David Carlier43a56852022-03-04 15:50:48 +00004818#if defined(__linux__) && defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
Willy Tarreaubb869862020-04-16 10:52:41 +02004819 long execfn = getauxval(AT_EXECFN);
4820
4821 if (execfn && execfn != ENOENT)
4822 ret = (const char *)execfn;
devnexen@gmail.comc4e52322021-08-17 12:55:49 +01004823#elif defined(__FreeBSD__)
4824 Elf_Auxinfo *auxv;
4825 for (auxv = __elf_aux_vector; auxv->a_type != AT_NULL; ++auxv) {
4826 if (auxv->a_type == AT_EXECPATH) {
4827 ret = (const char *)auxv->a_un.a_ptr;
4828 break;
4829 }
4830 }
David Carlierbd2cced2021-08-17 08:44:25 +01004831#elif defined(__NetBSD__)
4832 AuxInfo *auxv;
4833 for (auxv = _dlauxinfo(); auxv->a_type != AT_NULL; ++auxv) {
4834 if (auxv->a_type == AT_SUN_EXECNAME) {
4835 ret = (const char *)auxv->a_v;
4836 break;
4837 }
4838 }
David Carlier7198c702022-05-14 17:15:49 +01004839#elif defined(__sun)
4840 ret = getexecname();
Willy Tarreaubb869862020-04-16 10:52:41 +02004841#endif
4842 return ret;
4843}
4844
Baruch Siache1651b22020-07-24 07:52:20 +03004845#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreau9133e482020-03-04 10:19:36 +01004846/* calls dladdr() or dladdr1() on <addr> and <dli>. If dladdr1 is available,
4847 * also returns the symbol size in <size>, otherwise returns 0 there.
4848 */
4849static int dladdr_and_size(const void *addr, Dl_info *dli, size_t *size)
4850{
4851 int ret;
Willy Tarreau7b2108c2021-08-30 10:15:35 +02004852#if defined(__GLIBC__) && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) // most detailed one
Willy Tarreauf3d5c4b2022-01-28 09:42:29 +01004853 const ElfW(Sym) *sym __attribute__((may_alias));
Willy Tarreau9133e482020-03-04 10:19:36 +01004854
4855 ret = dladdr1(addr, dli, (void **)&sym, RTLD_DL_SYMENT);
4856 if (ret)
4857 *size = sym ? sym->st_size : 0;
4858#else
David Carlierae5c42f2021-12-31 08:15:29 +00004859#if defined(__sun)
4860 ret = dladdr((void *)addr, dli);
4861#else
Willy Tarreau9133e482020-03-04 10:19:36 +01004862 ret = dladdr(addr, dli);
David Carlierae5c42f2021-12-31 08:15:29 +00004863#endif
Willy Tarreau9133e482020-03-04 10:19:36 +01004864 *size = 0;
4865#endif
4866 return ret;
4867}
Willy Tarreau64192392021-05-05 09:06:21 +02004868
4869/* Tries to retrieve the address of the first occurrence symbol <name>.
4870 * Note that NULL in return is not always an error as a symbol may have that
4871 * address in special situations.
4872 */
4873void *get_sym_curr_addr(const char *name)
4874{
4875 void *ptr = NULL;
4876
4877#ifdef RTLD_DEFAULT
4878 ptr = dlsym(RTLD_DEFAULT, name);
4879#endif
4880 return ptr;
4881}
4882
4883
4884/* Tries to retrieve the address of the next occurrence of symbol <name>
4885 * Note that NULL in return is not always an error as a symbol may have that
4886 * address in special situations.
4887 */
4888void *get_sym_next_addr(const char *name)
4889{
4890 void *ptr = NULL;
4891
4892#ifdef RTLD_NEXT
4893 ptr = dlsym(RTLD_NEXT, name);
Willy Tarreau9133e482020-03-04 10:19:36 +01004894#endif
Willy Tarreau64192392021-05-05 09:06:21 +02004895 return ptr;
4896}
4897
4898#else /* elf & linux & dl */
4899
4900/* no possible resolving on other platforms at the moment */
4901void *get_sym_curr_addr(const char *name)
4902{
4903 return NULL;
4904}
4905
4906void *get_sym_next_addr(const char *name)
4907{
4908 return NULL;
4909}
4910
4911#endif /* elf & linux & dl */
Willy Tarreau9133e482020-03-04 10:19:36 +01004912
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004913/* Tries to append to buffer <buf> some indications about the symbol at address
4914 * <addr> using the following form:
4915 * lib:+0xoffset (unresolvable address from lib's base)
4916 * main+0xoffset (unresolvable address from main (+/-))
4917 * lib:main+0xoffset (unresolvable lib address from main (+/-))
4918 * name (resolved exact exec address)
4919 * lib:name (resolved exact lib address)
4920 * name+0xoffset/0xsize (resolved address within exec symbol)
4921 * lib:name+0xoffset/0xsize (resolved address within lib symbol)
4922 *
4923 * The file name (lib or executable) is limited to what lies between the last
4924 * '/' and the first following '.'. An optional prefix <pfx> is prepended before
4925 * 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 +03004926 * that contains the "main" symbol, or when __ELF__ && USE_DL are not set.
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004927 *
4928 * The symbol's base address is returned, or NULL when unresolved, in order to
4929 * allow the caller to match it against known ones.
4930 */
Willy Tarreau45fd1032021-01-20 14:37:59 +01004931const void *resolve_sym_name(struct buffer *buf, const char *pfx, const void *addr)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004932{
4933 const struct {
4934 const void *func;
4935 const char *name;
4936 } fcts[] = {
4937 { .func = process_stream, .name = "process_stream" },
4938 { .func = task_run_applet, .name = "task_run_applet" },
Willy Tarreau462b9892022-05-18 18:06:53 +02004939 { .func = sc_conn_io_cb, .name = "sc_conn_io_cb" },
Willy Tarreau586f71b2020-12-11 15:54:36 +01004940 { .func = sock_conn_iocb, .name = "sock_conn_iocb" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004941 { .func = dgram_fd_handler, .name = "dgram_fd_handler" },
4942 { .func = listener_accept, .name = "listener_accept" },
Willy Tarreaud597ec22021-01-29 14:29:06 +01004943 { .func = manage_global_listener_queue, .name = "manage_global_listener_queue" },
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004944 { .func = poller_pipe_io_handler, .name = "poller_pipe_io_handler" },
4945 { .func = mworker_accept_wrapper, .name = "mworker_accept_wrapper" },
Willy Tarreau02922e12021-01-29 12:27:57 +01004946 { .func = session_expire_embryonic, .name = "session_expire_embryonic" },
Willy Tarreaufb5401f2021-01-29 12:25:23 +01004947#ifdef USE_THREAD
4948 { .func = accept_queue_process, .name = "accept_queue_process" },
4949#endif
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004950#ifdef USE_LUA
4951 { .func = hlua_process_task, .name = "hlua_process_task" },
4952#endif
Ilya Shipitsinbdec3ba2020-11-14 01:56:34 +05004953#ifdef SSL_MODE_ASYNC
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004954 { .func = ssl_async_fd_free, .name = "ssl_async_fd_free" },
4955 { .func = ssl_async_fd_handler, .name = "ssl_async_fd_handler" },
4956#endif
4957 };
4958
Baruch Siache1651b22020-07-24 07:52:20 +03004959#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004960 Dl_info dli, dli_main;
Willy Tarreau9133e482020-03-04 10:19:36 +01004961 size_t size;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004962 const char *fname, *p;
4963#endif
4964 int i;
4965
4966 if (pfx)
4967 chunk_appendf(buf, "%s", pfx);
4968
4969 for (i = 0; i < sizeof(fcts) / sizeof(fcts[0]); i++) {
4970 if (addr == fcts[i].func) {
4971 chunk_appendf(buf, "%s", fcts[i].name);
4972 return addr;
4973 }
4974 }
4975
Baruch Siache1651b22020-07-24 07:52:20 +03004976#if (defined(__ELF__) && !defined(__linux__)) || defined(USE_DL)
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004977 /* Now let's try to be smarter */
Willy Tarreau9133e482020-03-04 10:19:36 +01004978 if (!dladdr_and_size(addr, &dli, &size))
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004979 goto unknown;
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01004980
4981 /* 1. prefix the library name if it's not the same object as the one
4982 * that contains the main function. The name is picked between last '/'
4983 * and first following '.'.
4984 */
4985 if (!dladdr(main, &dli_main))
4986 dli_main.dli_fbase = NULL;
4987
4988 if (dli_main.dli_fbase != dli.dli_fbase) {
4989 fname = dli.dli_fname;
4990 p = strrchr(fname, '/');
4991 if (p++)
4992 fname = p;
4993 p = strchr(fname, '.');
4994 if (!p)
4995 p = fname + strlen(fname);
4996
4997 chunk_appendf(buf, "%.*s:", (int)(long)(p - fname), fname);
4998 }
4999
5000 /* 2. symbol name */
5001 if (dli.dli_sname) {
5002 /* known, dump it and return symbol's address (exact or relative) */
5003 chunk_appendf(buf, "%s", dli.dli_sname);
5004 if (addr != dli.dli_saddr) {
5005 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_saddr));
Willy Tarreau9133e482020-03-04 10:19:36 +01005006 if (size)
5007 chunk_appendf(buf, "/%#lx", (long)size);
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01005008 }
5009 return dli.dli_saddr;
5010 }
5011 else if (dli_main.dli_fbase != dli.dli_fbase) {
5012 /* unresolved symbol from a known library, report relative offset */
5013 chunk_appendf(buf, "+%#lx", (long)(addr - dli.dli_fbase));
5014 return NULL;
5015 }
Baruch Siache1651b22020-07-24 07:52:20 +03005016#endif /* __ELF__ && !__linux__ || USE_DL */
Willy Tarreaueb8b1ca2020-03-03 17:09:08 +01005017 unknown:
5018 /* unresolved symbol from the main file, report relative offset to main */
5019 if ((void*)addr < (void*)main)
5020 chunk_appendf(buf, "main-%#lx", (long)((void*)main - addr));
5021 else
5022 chunk_appendf(buf, "main+%#lx", (long)(addr - (void*)main));
5023 return NULL;
Willy Tarreau0ebb5112016-12-05 00:10:57 +01005024}
5025
Willy Tarreau6ab7b212021-12-28 09:57:10 +01005026/* On systems where this is supported, let's provide a possibility to enumerate
5027 * the list of object files. The output is appended to a buffer initialized by
5028 * the caller, with one name per line. A trailing zero is always emitted if data
5029 * are written. Only real objects are dumped (executable and .so libs). The
5030 * function returns non-zero if it dumps anything. These functions do not make
5031 * use of the trash so that it is possible for the caller to call them with the
5032 * trash on input. The output format may be platform-specific but at least one
5033 * version must emit raw object file names when argument is zero.
5034 */
5035#if defined(HA_HAVE_DUMP_LIBS)
5036# if defined(HA_HAVE_DL_ITERATE_PHDR)
5037/* the private <data> we pass below is a dump context initialized like this */
5038struct dl_dump_ctx {
5039 struct buffer *buf;
5040 int with_addr;
5041};
5042
5043static int dl_dump_libs_cb(struct dl_phdr_info *info, size_t size, void *data)
5044{
5045 struct dl_dump_ctx *ctx = data;
5046 const char *fname;
5047 size_t p1, p2, beg, end;
5048 int idx;
5049
5050 if (!info || !info->dlpi_name)
5051 goto leave;
5052
5053 if (!*info->dlpi_name)
5054 fname = get_exec_path();
5055 else if (strchr(info->dlpi_name, '/'))
5056 fname = info->dlpi_name;
5057 else
5058 /* else it's a VDSO or similar and we're not interested */
5059 goto leave;
5060
5061 if (!ctx->with_addr)
5062 goto dump_name;
5063
5064 /* virtual addresses are relative to the load address and are per
5065 * pseudo-header, so we have to scan them all to find the furthest
5066 * one from the beginning. In this case we only dump entries if
5067 * they have at least one section.
5068 */
5069 beg = ~0; end = 0;
5070 for (idx = 0; idx < info->dlpi_phnum; idx++) {
5071 if (!info->dlpi_phdr[idx].p_memsz)
5072 continue;
5073 p1 = info->dlpi_phdr[idx].p_vaddr;
5074 if (p1 < beg)
5075 beg = p1;
5076 p2 = p1 + info->dlpi_phdr[idx].p_memsz - 1;
5077 if (p2 > end)
5078 end = p2;
5079 }
5080
5081 if (!idx)
5082 goto leave;
5083
5084 chunk_appendf(ctx->buf, "0x%012llx-0x%012llx (0x%07llx) ",
5085 (ullong)info->dlpi_addr + beg,
5086 (ullong)info->dlpi_addr + end,
5087 (ullong)(end - beg + 1));
5088 dump_name:
5089 chunk_appendf(ctx->buf, "%s\n", fname);
5090 leave:
5091 return 0;
5092}
5093
5094/* dumps lib names and optionally address ranges */
5095int dump_libs(struct buffer *output, int with_addr)
5096{
5097 struct dl_dump_ctx ctx = { .buf = output, .with_addr = with_addr };
5098 size_t old_data = output->data;
5099
5100 dl_iterate_phdr(dl_dump_libs_cb, &ctx);
5101 return output->data != old_data;
5102}
5103# else // no DL_ITERATE_PHDR
5104# error "No dump_libs() function for this platform"
5105# endif
5106#else // no HA_HAVE_DUMP_LIBS
5107
5108/* unsupported platform: do not dump anything */
5109int dump_libs(struct buffer *output, int with_addr)
5110{
5111 return 0;
5112}
5113
5114#endif // HA_HAVE_DUMP_LIBS
5115
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005116/*
5117 * Allocate an array of unsigned int with <nums> as address from <str> string
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05005118 * made of integer separated by dot characters.
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005119 *
5120 * First, initializes the value with <sz> as address to 0 and initializes the
5121 * array with <nums> as address to NULL. Then allocates the array with <nums> as
5122 * address updating <sz> pointed value to the size of this array.
5123 *
5124 * Returns 1 if succeeded, 0 if not.
5125 */
5126int parse_dotted_uints(const char *str, unsigned int **nums, size_t *sz)
5127{
5128 unsigned int *n;
5129 const char *s, *end;
5130
5131 s = str;
5132 *sz = 0;
5133 end = str + strlen(str);
5134 *nums = n = NULL;
5135
5136 while (1) {
5137 unsigned int r;
5138
5139 if (s >= end)
5140 break;
5141
5142 r = read_uint(&s, end);
5143 /* Expected characters after having read an uint: '\0' or '.',
5144 * if '.', must not be terminal.
5145 */
Christopher Faulet4b524122021-02-11 10:42:41 +01005146 if (*s != '\0'&& (*s++ != '.' || s == end)) {
5147 free(n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005148 return 0;
Christopher Faulet4b524122021-02-11 10:42:41 +01005149 }
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005150
Frédéric Lécaille12a71842019-02-26 18:19:48 +01005151 n = my_realloc2(n, (*sz + 1) * sizeof *n);
Frédéric Lécaille3b717162019-02-25 15:04:22 +01005152 if (!n)
5153 return 0;
5154
5155 n[(*sz)++] = r;
5156 }
5157 *nums = n;
5158
5159 return 1;
5160}
5161
Willy Tarreau4d589e72019-08-23 19:02:26 +02005162
5163/* returns the number of bytes needed to encode <v> as a varint. An inline
5164 * version exists for use with constants (__varint_bytes()).
5165 */
5166int varint_bytes(uint64_t v)
5167{
5168 int len = 1;
5169
5170 if (v >= 240) {
5171 v = (v - 240) >> 4;
5172 while (1) {
5173 len++;
5174 if (v < 128)
5175 break;
5176 v = (v - 128) >> 7;
5177 }
5178 }
5179 return len;
5180}
5181
Willy Tarreau52bf8392020-03-08 00:42:37 +01005182
5183/* Random number generator state, see below */
Willy Tarreau1544c142020-03-12 00:31:18 +01005184static uint64_t ha_random_state[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01005185
5186/* This is a thread-safe implementation of xoroshiro128** described below:
5187 * http://prng.di.unimi.it/
5188 * It features a 2^128 long sequence, returns 64 high-quality bits on each call,
5189 * supports fast jumps and passes all common quality tests. It is thread-safe,
5190 * uses a double-cas on 64-bit architectures supporting it, and falls back to a
5191 * local lock on other ones.
5192 */
5193uint64_t ha_random64()
5194{
Willy Tarreau1544c142020-03-12 00:31:18 +01005195 uint64_t old[2] ALIGNED(2*sizeof(uint64_t));
5196 uint64_t new[2] ALIGNED(2*sizeof(uint64_t));
Willy Tarreau52bf8392020-03-08 00:42:37 +01005197
5198#if defined(USE_THREAD) && (!defined(HA_CAS_IS_8B) || !defined(HA_HAVE_CAS_DW))
5199 static HA_SPINLOCK_T rand_lock;
5200
5201 HA_SPIN_LOCK(OTHER_LOCK, &rand_lock);
5202#endif
5203
5204 old[0] = ha_random_state[0];
5205 old[1] = ha_random_state[1];
5206
5207#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
5208 do {
5209#endif
Willy Tarreau52bf8392020-03-08 00:42:37 +01005210 new[1] = old[0] ^ old[1];
5211 new[0] = rotl64(old[0], 24) ^ new[1] ^ (new[1] << 16); // a, b
5212 new[1] = rotl64(new[1], 37); // c
5213
5214#if defined(USE_THREAD) && defined(HA_CAS_IS_8B) && defined(HA_HAVE_CAS_DW)
5215 } while (unlikely(!_HA_ATOMIC_DWCAS(ha_random_state, old, new)));
5216#else
5217 ha_random_state[0] = new[0];
5218 ha_random_state[1] = new[1];
5219#if defined(USE_THREAD)
5220 HA_SPIN_UNLOCK(OTHER_LOCK, &rand_lock);
5221#endif
5222#endif
Willy Tarreaub2475a12021-05-09 10:26:14 +02005223 return rotl64(old[0] * 5, 7) * 9;
Willy Tarreau52bf8392020-03-08 00:42:37 +01005224}
5225
5226/* seeds the random state using up to <len> bytes from <seed>, starting with
5227 * the first non-zero byte.
5228 */
5229void ha_random_seed(const unsigned char *seed, size_t len)
5230{
5231 size_t pos;
5232
5233 /* the seed must not be all zeroes, so we pre-fill it with alternating
5234 * bits and overwrite part of them with the block starting at the first
5235 * non-zero byte from the seed.
5236 */
5237 memset(ha_random_state, 0x55, sizeof(ha_random_state));
5238
5239 for (pos = 0; pos < len; pos++)
5240 if (seed[pos] != 0)
5241 break;
5242
5243 if (pos == len)
5244 return;
5245
5246 seed += pos;
5247 len -= pos;
5248
5249 if (len > sizeof(ha_random_state))
5250 len = sizeof(ha_random_state);
5251
5252 memcpy(ha_random_state, seed, len);
5253}
5254
5255/* This causes a jump to (dist * 2^96) places in the pseudo-random sequence,
5256 * and is equivalent to calling ha_random64() as many times. It is used to
5257 * provide non-overlapping sequences of 2^96 numbers (~7*10^28) to up to 2^32
5258 * different generators (i.e. different processes after a fork). The <dist>
5259 * argument is the distance to jump to and is used in a loop so it rather not
5260 * be too large if the processing time is a concern.
5261 *
5262 * BEWARE: this function is NOT thread-safe and must not be called during
5263 * concurrent accesses to ha_random64().
5264 */
5265void ha_random_jump96(uint32_t dist)
5266{
5267 while (dist--) {
5268 uint64_t s0 = 0;
5269 uint64_t s1 = 0;
5270 int b;
5271
5272 for (b = 0; b < 64; b++) {
5273 if ((0xd2a98b26625eee7bULL >> b) & 1) {
5274 s0 ^= ha_random_state[0];
5275 s1 ^= ha_random_state[1];
5276 }
5277 ha_random64();
5278 }
5279
5280 for (b = 0; b < 64; b++) {
5281 if ((0xdddf9b1090aa7ac1ULL >> b) & 1) {
5282 s0 ^= ha_random_state[0];
5283 s1 ^= ha_random_state[1];
5284 }
5285 ha_random64();
5286 }
5287 ha_random_state[0] = s0;
5288 ha_random_state[1] = s1;
5289 }
5290}
5291
Willy Tarreauee3bcdd2020-03-08 17:48:17 +01005292/* Generates an RFC4122 UUID into chunk <output> which must be at least 37
5293 * bytes large.
5294 */
5295void ha_generate_uuid(struct buffer *output)
5296{
5297 uint32_t rnd[4];
5298 uint64_t last;
5299
5300 last = ha_random64();
5301 rnd[0] = last;
5302 rnd[1] = last >> 32;
5303
5304 last = ha_random64();
5305 rnd[2] = last;
5306 rnd[3] = last >> 32;
5307
5308 chunk_printf(output, "%8.8x-%4.4x-%4.4x-%4.4x-%12.12llx",
5309 rnd[0],
5310 rnd[1] & 0xFFFF,
5311 ((rnd[1] >> 16u) & 0xFFF) | 0x4000, // highest 4 bits indicate the uuid version
5312 (rnd[2] & 0x3FFF) | 0x8000, // the highest 2 bits indicate the UUID variant (10),
5313 (long long)((rnd[2] >> 14u) | ((uint64_t) rnd[3] << 18u)) & 0xFFFFFFFFFFFFull);
5314}
5315
5316
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005317/* only used by parse_line() below. It supports writing in place provided that
5318 * <in> is updated to the next location before calling it. In that case, the
5319 * char at <in> may be overwritten.
5320 */
5321#define EMIT_CHAR(x) \
5322 do { \
5323 char __c = (char)(x); \
5324 if ((opts & PARSE_OPT_INPLACE) && out+outpos > in) \
5325 err |= PARSE_ERR_OVERLAP; \
5326 if (outpos >= outmax) \
5327 err |= PARSE_ERR_TOOLARGE; \
5328 if (!err) \
5329 out[outpos] = __c; \
5330 outpos++; \
5331 } while (0)
5332
Ilya Shipitsin46a030c2020-07-05 16:36:08 +05005333/* Parse <in>, copy it into <out> split into isolated words whose pointers
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005334 * are put in <args>. If more than <outlen> bytes have to be emitted, the
5335 * extraneous ones are not emitted but <outlen> is updated so that the caller
5336 * knows how much to realloc. Similarly, <args> are not updated beyond <nbargs>
5337 * but the returned <nbargs> indicates how many were found. All trailing args
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005338 * up to <nbargs> point to the trailing zero, and as long as <nbargs> is > 0,
5339 * it is guaranteed that at least one arg will point to the zero. It is safe
5340 * to call it with a NULL <args> if <nbargs> is 0.
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005341 *
5342 * <out> may overlap with <in> provided that it never goes further, in which
5343 * case the parser will accept to perform in-place parsing and unquoting/
5344 * unescaping but only if environment variables do not lead to expansion that
5345 * causes overlapping, otherwise the input string being destroyed, the error
5346 * will not be recoverable. Note that even during out-of-place <in> will
5347 * experience temporary modifications in-place for variable resolution and must
5348 * be writable, and will also receive zeroes to delimit words when using
5349 * in-place copy. Parsing options <opts> taken from PARSE_OPT_*. Return value
5350 * is zero on success otherwise a bitwise-or of PARSE_ERR_*. Upon error, the
5351 * starting point of the first invalid character sequence or unmatched
5352 * quote/brace is reported in <errptr> if not NULL. When using in-place parsing
5353 * error reporting might be difficult since zeroes will have been inserted into
5354 * the string. One solution for the caller may consist in replacing all args
5355 * delimiters with spaces in this case.
5356 */
Maximilian Mader29c6cd72021-06-06 00:50:21 +02005357uint32_t parse_line(char *in, char *out, size_t *outlen, char **args, int *nbargs, uint32_t opts, const char **errptr)
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005358{
5359 char *quote = NULL;
5360 char *brace = NULL;
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005361 char *word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005362 unsigned char hex1, hex2;
5363 size_t outmax = *outlen;
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005364 int argsmax = *nbargs - 1;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005365 size_t outpos = 0;
5366 int squote = 0;
5367 int dquote = 0;
5368 int arg = 0;
5369 uint32_t err = 0;
5370
5371 *nbargs = 0;
5372 *outlen = 0;
5373
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005374 /* argsmax may be -1 here, protecting args[] from any write */
5375 if (arg < argsmax)
5376 args[arg] = out;
5377
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005378 while (1) {
5379 if (*in >= '-' && *in != '\\') {
5380 /* speedup: directly send all regular chars starting
5381 * with '-', '.', '/', alnum etc...
5382 */
5383 EMIT_CHAR(*in++);
5384 continue;
5385 }
5386 else if (*in == '\0' || *in == '\n' || *in == '\r') {
5387 /* end of line */
5388 break;
5389 }
5390 else if (*in == '#' && (opts & PARSE_OPT_SHARP) && !squote && !dquote) {
5391 /* comment */
5392 break;
5393 }
5394 else if (*in == '"' && !squote && (opts & PARSE_OPT_DQUOTE)) { /* double quote outside single quotes */
5395 if (dquote) {
5396 dquote = 0;
5397 quote = NULL;
5398 }
5399 else {
5400 dquote = 1;
5401 quote = in;
5402 }
5403 in++;
5404 continue;
5405 }
5406 else if (*in == '\'' && !dquote && (opts & PARSE_OPT_SQUOTE)) { /* single quote outside double quotes */
5407 if (squote) {
5408 squote = 0;
5409 quote = NULL;
5410 }
5411 else {
5412 squote = 1;
5413 quote = in;
5414 }
5415 in++;
5416 continue;
5417 }
5418 else if (*in == '\\' && !squote && (opts & PARSE_OPT_BKSLASH)) {
5419 /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
5420 * C equivalent value but only when they have a special meaning and within
5421 * double quotes for some of them. Other combinations left unchanged (eg: \1).
5422 */
5423 char tosend = *in;
5424
5425 switch (in[1]) {
5426 case ' ':
5427 case '\\':
5428 tosend = in[1];
5429 in++;
5430 break;
5431
5432 case 't':
5433 tosend = '\t';
5434 in++;
5435 break;
5436
5437 case 'n':
5438 tosend = '\n';
5439 in++;
5440 break;
5441
5442 case 'r':
5443 tosend = '\r';
5444 in++;
5445 break;
5446
5447 case '#':
5448 /* escaping of "#" only if comments are supported */
5449 if (opts & PARSE_OPT_SHARP)
5450 in++;
5451 tosend = *in;
5452 break;
5453
5454 case '\'':
5455 /* escaping of "'" only outside single quotes and only if single quotes are supported */
5456 if (opts & PARSE_OPT_SQUOTE && !squote)
5457 in++;
5458 tosend = *in;
5459 break;
5460
5461 case '"':
5462 /* escaping of '"' only outside single quotes and only if double quotes are supported */
5463 if (opts & PARSE_OPT_DQUOTE && !squote)
5464 in++;
5465 tosend = *in;
5466 break;
5467
5468 case '$':
5469 /* escaping of '$' only inside double quotes and only if env supported */
5470 if (opts & PARSE_OPT_ENV && dquote)
5471 in++;
5472 tosend = *in;
5473 break;
5474
5475 case 'x':
5476 if (!ishex(in[2]) || !ishex(in[3])) {
5477 /* invalid or incomplete hex sequence */
5478 err |= PARSE_ERR_HEX;
5479 if (errptr)
5480 *errptr = in;
5481 goto leave;
5482 }
Willy Tarreauf278eec2020-07-05 21:46:32 +02005483 hex1 = toupper((unsigned char)in[2]) - '0';
5484 hex2 = toupper((unsigned char)in[3]) - '0';
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005485 if (hex1 > 9) hex1 -= 'A' - '9' - 1;
5486 if (hex2 > 9) hex2 -= 'A' - '9' - 1;
5487 tosend = (hex1 << 4) + hex2;
5488 in += 3;
5489 break;
5490
5491 default:
5492 /* other combinations are not escape sequences */
5493 break;
5494 }
5495
5496 in++;
5497 EMIT_CHAR(tosend);
5498 }
5499 else if (isspace((unsigned char)*in) && !squote && !dquote) {
5500 /* a non-escaped space is an argument separator */
5501 while (isspace((unsigned char)*in))
5502 in++;
5503 EMIT_CHAR(0);
5504 arg++;
5505 if (arg < argsmax)
5506 args[arg] = out + outpos;
5507 else
5508 err |= PARSE_ERR_TOOMANY;
5509 }
5510 else if (*in == '$' && (opts & PARSE_OPT_ENV) && (dquote || !(opts & PARSE_OPT_DQUOTE))) {
5511 /* environment variables are evaluated anywhere, or only
5512 * inside double quotes if they are supported.
5513 */
5514 char *var_name;
5515 char save_char;
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005516 const char *value;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005517
5518 in++;
5519
5520 if (*in == '{')
5521 brace = in++;
5522
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005523 if (!isalpha((unsigned char)*in) && *in != '_' && *in != '.') {
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005524 /* unacceptable character in variable name */
5525 err |= PARSE_ERR_VARNAME;
5526 if (errptr)
5527 *errptr = in;
5528 goto leave;
5529 }
5530
5531 var_name = in;
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005532 if (*in == '.')
5533 in++;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005534 while (isalnum((unsigned char)*in) || *in == '_')
5535 in++;
5536
5537 save_char = *in;
5538 *in = '\0';
Willy Tarreaua46f1af2021-05-06 10:25:11 +02005539 if (unlikely(*var_name == '.')) {
5540 /* internal pseudo-variables */
5541 if (strcmp(var_name, ".LINE") == 0)
5542 value = ultoa(global.cfg_curr_line);
5543 else if (strcmp(var_name, ".FILE") == 0)
5544 value = global.cfg_curr_file;
5545 else if (strcmp(var_name, ".SECTION") == 0)
5546 value = global.cfg_curr_section;
5547 else {
5548 /* unsupported internal variable name */
5549 err |= PARSE_ERR_VARNAME;
5550 if (errptr)
5551 *errptr = var_name;
5552 goto leave;
5553 }
5554 } else {
5555 value = getenv(var_name);
5556 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005557 *in = save_char;
5558
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005559 /* support for '[*]' sequence to force word expansion,
5560 * only available inside braces */
5561 if (*in == '[' && brace && (opts & PARSE_OPT_WORD_EXPAND)) {
5562 word_expand = in++;
5563
5564 if (*in++ != '*' || *in++ != ']') {
5565 err |= PARSE_ERR_WRONG_EXPAND;
5566 if (errptr)
5567 *errptr = word_expand;
5568 goto leave;
5569 }
5570 }
5571
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005572 if (brace) {
Willy Tarreauec347b12021-11-18 17:42:50 +01005573 if (*in == '-') {
5574 /* default value starts just after the '-' */
5575 if (!value)
5576 value = in + 1;
5577
5578 while (*in && *in != '}')
5579 in++;
5580 if (!*in)
5581 goto no_brace;
5582 *in = 0; // terminate the default value
5583 }
5584 else if (*in != '}') {
5585 no_brace:
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005586 /* unmatched brace */
5587 err |= PARSE_ERR_BRACE;
5588 if (errptr)
5589 *errptr = brace;
5590 goto leave;
5591 }
Willy Tarreauec347b12021-11-18 17:42:50 +01005592
5593 /* brace found, skip it */
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005594 in++;
5595 brace = NULL;
5596 }
5597
5598 if (value) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005599 while (*value) {
5600 /* expand as individual parameters on a space character */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005601 if (word_expand && isspace((unsigned char)*value)) {
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005602 EMIT_CHAR(0);
5603 ++arg;
5604 if (arg < argsmax)
5605 args[arg] = out + outpos;
5606 else
5607 err |= PARSE_ERR_TOOMANY;
5608
5609 /* skip consecutive spaces */
Willy Tarreaufe2cc412020-10-01 18:04:40 +02005610 while (isspace((unsigned char)*++value))
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005611 ;
5612 } else {
5613 EMIT_CHAR(*value++);
5614 }
5615 }
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005616 }
Amaury Denoyellefa41cb62020-10-01 14:32:35 +02005617 word_expand = NULL;
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005618 }
5619 else {
5620 /* any other regular char */
5621 EMIT_CHAR(*in++);
5622 }
5623 }
5624
5625 /* end of output string */
5626 EMIT_CHAR(0);
5627 arg++;
5628
5629 if (quote) {
5630 /* unmatched quote */
5631 err |= PARSE_ERR_QUOTE;
5632 if (errptr)
5633 *errptr = quote;
5634 goto leave;
5635 }
5636 leave:
5637 *nbargs = arg;
5638 *outlen = outpos;
5639
Willy Tarreau61dd44b2020-06-25 07:35:42 +02005640 /* empty all trailing args by making them point to the trailing zero,
5641 * at least the last one in any case.
5642 */
5643 if (arg > argsmax)
5644 arg = argsmax;
5645
5646 while (arg >= 0 && arg <= argsmax)
Willy Tarreauc8d167b2020-06-16 16:27:26 +02005647 args[arg++] = out + outpos - 1;
5648
5649 return err;
5650}
5651#undef EMIT_CHAR
5652
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005653/* This is used to sanitize an input line that's about to be used for error reporting.
5654 * It will adjust <line> to print approximately <width> chars around <pos>, trying to
5655 * preserve the beginning, with leading or trailing "..." when the line is truncated.
5656 * If non-printable chars are present in the output. It returns the new offset <pos>
5657 * in the modified line. Non-printable characters are replaced with '?'. <width> must
5658 * be at least 6 to support two "..." otherwise the result is undefined. The line
5659 * itself must have at least 7 chars allocated for the same reason.
5660 */
5661size_t sanitize_for_printing(char *line, size_t pos, size_t width)
5662{
5663 size_t shift = 0;
5664 char *out = line;
5665 char *in = line;
5666 char *end = line + width;
5667
5668 if (pos >= width) {
5669 /* if we have to shift, we'll be out of context, so let's
5670 * try to put <pos> at the center of width.
5671 */
5672 shift = pos - width / 2;
5673 in += shift + 3;
5674 end = out + width - 3;
5675 out[0] = out[1] = out[2] = '.';
5676 out += 3;
5677 }
5678
5679 while (out < end && *in) {
5680 if (isspace((unsigned char)*in))
5681 *out++ = ' ';
5682 else if (isprint((unsigned char)*in))
5683 *out++ = *in;
5684 else
5685 *out++ = '?';
5686 in++;
5687 }
5688
5689 if (end < line + width) {
5690 out[0] = out[1] = out[2] = '.';
5691 out += 3;
5692 }
5693
5694 *out++ = 0;
5695 return pos - shift;
5696}
Willy Tarreau06e69b52021-03-02 14:01:35 +01005697
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005698/* Update array <fp> with the fingerprint of word <word> by counting the
Willy Tarreauba2c4452021-03-12 09:01:52 +01005699 * transitions between characters. <fp> is a 1024-entries array indexed as
5700 * 32*from+to. Positions for 'from' and 'to' are:
Willy Tarreau9294e882021-03-15 09:34:27 +01005701 * 1..26=letter, 27=digit, 28=other/begin/end.
5702 * Row "from=0" is used to mark the character's presence. Others unused.
Willy Tarreauba2c4452021-03-12 09:01:52 +01005703 */
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005704void update_word_fingerprint(uint8_t *fp, const char *word)
Willy Tarreauba2c4452021-03-12 09:01:52 +01005705{
5706 const char *p;
5707 int from, to;
5708 int c;
5709
Willy Tarreauba2c4452021-03-12 09:01:52 +01005710 from = 28; // begin
5711 for (p = word; *p; p++) {
5712 c = tolower(*p);
5713 switch(c) {
Willy Tarreau9294e882021-03-15 09:34:27 +01005714 case 'a'...'z': to = c - 'a' + 1; break;
5715 case 'A'...'Z': to = tolower(c) - 'a' + 1; break;
5716 case '0'...'9': to = 27; break;
5717 default: to = 28; break;
Willy Tarreauba2c4452021-03-12 09:01:52 +01005718 }
Willy Tarreau9294e882021-03-15 09:34:27 +01005719 fp[to] = 1;
Willy Tarreauba2c4452021-03-12 09:01:52 +01005720 fp[32 * from + to]++;
5721 from = to;
5722 }
5723 to = 28; // end
5724 fp[32 * from + to]++;
5725}
5726
Willy Tarreaue33c4b32021-03-12 18:59:31 +01005727/* Initialize array <fp> with the fingerprint of word <word> by counting the
5728 * transitions between characters. <fp> is a 1024-entries array indexed as
5729 * 32*from+to. Positions for 'from' and 'to' are:
5730 * 0..25=letter, 26=digit, 27=other, 28=begin, 29=end, others unused.
5731 */
5732void make_word_fingerprint(uint8_t *fp, const char *word)
5733{
5734 memset(fp, 0, 1024);
5735 update_word_fingerprint(fp, word);
5736}
5737
Willy Tarreauba2c4452021-03-12 09:01:52 +01005738/* Return the distance between two word fingerprints created by function
5739 * make_word_fingerprint(). It's a positive integer calculated as the sum of
Willy Tarreau714c4c12021-03-15 09:44:53 +01005740 * the differences between each location.
Willy Tarreauba2c4452021-03-12 09:01:52 +01005741 */
5742int word_fingerprint_distance(const uint8_t *fp1, const uint8_t *fp2)
5743{
5744 int i, k, dist = 0;
5745
5746 for (i = 0; i < 1024; i++) {
5747 k = (int)fp1[i] - (int)fp2[i];
Willy Tarreau714c4c12021-03-15 09:44:53 +01005748 dist += abs(k);
Willy Tarreauba2c4452021-03-12 09:01:52 +01005749 }
5750 return dist;
5751}
5752
William Lallemand3aeb3f92021-08-21 23:59:56 +02005753/*
5754 * This function compares the loaded openssl version with a string <version>
5755 * This function use the same return code as compare_current_version:
5756 *
5757 * -1 : the version in argument is older than the current openssl version
5758 * 0 : the version in argument is the same as the current openssl version
5759 * 1 : the version in argument is newer than the current openssl version
5760 *
5761 * Or some errors:
5762 * -2 : openssl is not available on this process
5763 * -3 : the version in argument is not parsable
5764 */
5765int openssl_compare_current_version(const char *version)
5766{
5767#ifdef USE_OPENSSL
5768 int numversion;
5769
5770 numversion = openssl_version_parser(version);
5771 if (numversion == 0)
5772 return -3;
5773
5774 if (numversion < OPENSSL_VERSION_NUMBER)
5775 return -1;
5776 else if (numversion > OPENSSL_VERSION_NUMBER)
5777 return 1;
5778 else
5779 return 0;
5780#else
5781 return -2;
5782#endif
5783}
5784
Remi Tricot-Le Bretonb01179a2021-10-11 15:34:12 +02005785/*
5786 * This function compares the loaded openssl name with a string <name>
5787 * This function returns 0 if the OpenSSL name starts like the passed parameter,
5788 * 1 otherwise.
5789 */
5790int openssl_compare_current_name(const char *name)
5791{
5792#ifdef USE_OPENSSL
5793 int name_len = 0;
5794 const char *openssl_version = OpenSSL_version(OPENSSL_VERSION);
5795
5796 if (name) {
5797 name_len = strlen(name);
5798 if (strlen(name) <= strlen(openssl_version))
5799 return strncmp(openssl_version, name, name_len);
5800 }
5801#endif
5802 return 1;
5803}
5804
Willy Tarreau06e69b52021-03-02 14:01:35 +01005805static int init_tools_per_thread()
5806{
5807 /* Let's make each thread start from a different position */
5808 statistical_prng_state += tid * MAX_THREADS;
5809 if (!statistical_prng_state)
5810 statistical_prng_state++;
5811 return 1;
5812}
5813REGISTER_PER_THREAD_INIT(init_tools_per_thread);
Willy Tarreauc54e5ad2020-06-25 09:15:40 +02005814
Willy Tarreaubaaee002006-06-26 02:48:02 +02005815/*
5816 * Local variables:
5817 * c-indent-level: 8
5818 * c-basic-offset: 8
5819 * End:
5820 */