blob: 7a6ca1129e4d42e22ba5902234f41b04fa896e7d [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * General purpose functions.
3 *
Willy Tarreau348238b2010-01-18 15:05:57 +01004 * Copyright 2000-2010 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau2e74c3f2007-12-02 18:45:09 +010013#include <ctype.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020014#include <netdb.h>
Willy Tarreau9a7bea52012-04-27 11:16:50 +020015#include <stdarg.h>
Willy Tarreaudd2f85e2012-09-02 22:34:23 +020016#include <stdio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020017#include <stdlib.h>
18#include <string.h>
Willy Tarreau127f9662007-12-06 00:53:51 +010019#include <sys/socket.h>
20#include <sys/un.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020021#include <netinet/in.h>
22#include <arpa/inet.h>
23
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020024#include <common/config.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020025#include <common/standard.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010026#include <eb32tree.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020027
Willy Tarreau56adcf22012-12-23 18:00:29 +010028/* enough to store NB_ITOA_STR integers of :
Willy Tarreau72d759c2007-10-25 12:14:10 +020029 * 2^64-1 = 18446744073709551615 or
30 * -2^63 = -9223372036854775808
Willy Tarreaue7239b52009-03-29 13:41:58 +020031 *
32 * The HTML version needs room for adding the 25 characters
33 * '<span class="rls"></span>' around digits at positions 3N+1 in order
34 * to add spacing at up to 6 positions : 18 446 744 073 709 551 615
Willy Tarreau72d759c2007-10-25 12:14:10 +020035 */
Willy Tarreau56adcf22012-12-23 18:00:29 +010036char itoa_str[NB_ITOA_STR][171];
37int itoa_idx = 0; /* index of next itoa_str to use */
Willy Tarreaubaaee002006-06-26 02:48:02 +020038
39/*
William Lallemande7340ec2012-01-24 11:15:39 +010040 * unsigned long long ASCII representation
41 *
42 * return the last char '\0' or NULL if no enough
43 * space in dst
44 */
45char *ulltoa(unsigned long long n, char *dst, size_t size)
46{
47 int i = 0;
48 char *res;
49
50 switch(n) {
51 case 1ULL ... 9ULL:
52 i = 0;
53 break;
54
55 case 10ULL ... 99ULL:
56 i = 1;
57 break;
58
59 case 100ULL ... 999ULL:
60 i = 2;
61 break;
62
63 case 1000ULL ... 9999ULL:
64 i = 3;
65 break;
66
67 case 10000ULL ... 99999ULL:
68 i = 4;
69 break;
70
71 case 100000ULL ... 999999ULL:
72 i = 5;
73 break;
74
75 case 1000000ULL ... 9999999ULL:
76 i = 6;
77 break;
78
79 case 10000000ULL ... 99999999ULL:
80 i = 7;
81 break;
82
83 case 100000000ULL ... 999999999ULL:
84 i = 8;
85 break;
86
87 case 1000000000ULL ... 9999999999ULL:
88 i = 9;
89 break;
90
91 case 10000000000ULL ... 99999999999ULL:
92 i = 10;
93 break;
94
95 case 100000000000ULL ... 999999999999ULL:
96 i = 11;
97 break;
98
99 case 1000000000000ULL ... 9999999999999ULL:
100 i = 12;
101 break;
102
103 case 10000000000000ULL ... 99999999999999ULL:
104 i = 13;
105 break;
106
107 case 100000000000000ULL ... 999999999999999ULL:
108 i = 14;
109 break;
110
111 case 1000000000000000ULL ... 9999999999999999ULL:
112 i = 15;
113 break;
114
115 case 10000000000000000ULL ... 99999999999999999ULL:
116 i = 16;
117 break;
118
119 case 100000000000000000ULL ... 999999999999999999ULL:
120 i = 17;
121 break;
122
123 case 1000000000000000000ULL ... 9999999999999999999ULL:
124 i = 18;
125 break;
126
127 case 10000000000000000000ULL ... ULLONG_MAX:
128 i = 19;
129 break;
130 }
131 if (i + 2 > size) // (i + 1) + '\0'
132 return NULL; // too long
133 res = dst + i + 1;
134 *res = '\0';
135 for (; i >= 0; i--) {
136 dst[i] = n % 10ULL + '0';
137 n /= 10ULL;
138 }
139 return res;
140}
141
142/*
143 * unsigned long ASCII representation
144 *
145 * return the last char '\0' or NULL if no enough
146 * space in dst
147 */
148char *ultoa_o(unsigned long n, char *dst, size_t size)
149{
150 int i = 0;
151 char *res;
152
153 switch (n) {
154 case 0U ... 9UL:
155 i = 0;
156 break;
157
158 case 10U ... 99UL:
159 i = 1;
160 break;
161
162 case 100U ... 999UL:
163 i = 2;
164 break;
165
166 case 1000U ... 9999UL:
167 i = 3;
168 break;
169
170 case 10000U ... 99999UL:
171 i = 4;
172 break;
173
174 case 100000U ... 999999UL:
175 i = 5;
176 break;
177
178 case 1000000U ... 9999999UL:
179 i = 6;
180 break;
181
182 case 10000000U ... 99999999UL:
183 i = 7;
184 break;
185
186 case 100000000U ... 999999999UL:
187 i = 8;
188 break;
189#if __WORDSIZE == 32
190
191 case 1000000000ULL ... ULONG_MAX:
192 i = 9;
193 break;
194
195#elif __WORDSIZE == 64
196
197 case 1000000000ULL ... 9999999999UL:
198 i = 9;
199 break;
200
201 case 10000000000ULL ... 99999999999UL:
202 i = 10;
203 break;
204
205 case 100000000000ULL ... 999999999999UL:
206 i = 11;
207 break;
208
209 case 1000000000000ULL ... 9999999999999UL:
210 i = 12;
211 break;
212
213 case 10000000000000ULL ... 99999999999999UL:
214 i = 13;
215 break;
216
217 case 100000000000000ULL ... 999999999999999UL:
218 i = 14;
219 break;
220
221 case 1000000000000000ULL ... 9999999999999999UL:
222 i = 15;
223 break;
224
225 case 10000000000000000ULL ... 99999999999999999UL:
226 i = 16;
227 break;
228
229 case 100000000000000000ULL ... 999999999999999999UL:
230 i = 17;
231 break;
232
233 case 1000000000000000000ULL ... 9999999999999999999UL:
234 i = 18;
235 break;
236
237 case 10000000000000000000ULL ... ULONG_MAX:
238 i = 19;
239 break;
240
241#endif
242 }
243 if (i + 2 > size) // (i + 1) + '\0'
244 return NULL; // too long
245 res = dst + i + 1;
246 *res = '\0';
247 for (; i >= 0; i--) {
248 dst[i] = n % 10U + '0';
249 n /= 10U;
250 }
251 return res;
252}
253
254/*
255 * signed long ASCII representation
256 *
257 * return the last char '\0' or NULL if no enough
258 * space in dst
259 */
260char *ltoa_o(long int n, char *dst, size_t size)
261{
262 char *pos = dst;
263
264 if (n < 0) {
265 if (size < 3)
266 return NULL; // min size is '-' + digit + '\0' but another test in ultoa
267 *pos = '-';
268 pos++;
269 dst = ultoa_o(-n, pos, size - 1);
270 } else {
271 dst = ultoa_o(n, dst, size);
272 }
273 return dst;
274}
275
276/*
277 * signed long long ASCII representation
278 *
279 * return the last char '\0' or NULL if no enough
280 * space in dst
281 */
282char *lltoa(long long n, char *dst, size_t size)
283{
284 char *pos = dst;
285
286 if (n < 0) {
287 if (size < 3)
288 return NULL; // min size is '-' + digit + '\0' but another test in ulltoa
289 *pos = '-';
290 pos++;
291 dst = ulltoa(-n, pos, size - 1);
292 } else {
293 dst = ulltoa(n, dst, size);
294 }
295 return dst;
296}
297
298/*
299 * write a ascii representation of a unsigned into dst,
300 * return a pointer to the last character
301 * Pad the ascii representation with '0', using size.
302 */
303char *utoa_pad(unsigned int n, char *dst, size_t size)
304{
305 int i = 0;
306 char *ret;
307
308 switch(n) {
309 case 0U ... 9U:
310 i = 0;
311 break;
312
313 case 10U ... 99U:
314 i = 1;
315 break;
316
317 case 100U ... 999U:
318 i = 2;
319 break;
320
321 case 1000U ... 9999U:
322 i = 3;
323 break;
324
325 case 10000U ... 99999U:
326 i = 4;
327 break;
328
329 case 100000U ... 999999U:
330 i = 5;
331 break;
332
333 case 1000000U ... 9999999U:
334 i = 6;
335 break;
336
337 case 10000000U ... 99999999U:
338 i = 7;
339 break;
340
341 case 100000000U ... 999999999U:
342 i = 8;
343 break;
344
345 case 1000000000U ... 4294967295U:
346 i = 9;
347 break;
348 }
349 if (i + 2 > size) // (i + 1) + '\0'
350 return NULL; // too long
351 if (i < size)
352 i = size - 2; // padding - '\0'
353
354 ret = dst + i + 1;
355 *ret = '\0';
356 for (; i >= 0; i--) {
357 dst[i] = n % 10U + '0';
358 n /= 10U;
359 }
360 return ret;
361}
362
363/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200364 * copies at most <size-1> chars from <src> to <dst>. Last char is always
365 * set to 0, unless <size> is 0. The number of chars copied is returned
366 * (excluding the terminating zero).
367 * This code has been optimized for size and speed : on x86, it's 45 bytes
368 * long, uses only registers, and consumes only 4 cycles per char.
369 */
370int strlcpy2(char *dst, const char *src, int size)
371{
372 char *orig = dst;
373 if (size) {
374 while (--size && (*dst = *src)) {
375 src++; dst++;
376 }
377 *dst = 0;
378 }
379 return dst - orig;
380}
381
382/*
Willy Tarreau72d759c2007-10-25 12:14:10 +0200383 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +0200384 * the ascii representation for number 'n' in decimal.
385 */
Emeric Brun3a7fce52010-01-04 14:54:38 +0100386char *ultoa_r(unsigned long n, char *buffer, int size)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200387{
388 char *pos;
389
Willy Tarreau72d759c2007-10-25 12:14:10 +0200390 pos = buffer + size - 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200391 *pos-- = '\0';
392
393 do {
394 *pos-- = '0' + n % 10;
395 n /= 10;
Willy Tarreau72d759c2007-10-25 12:14:10 +0200396 } while (n && pos >= buffer);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200397 return pos + 1;
398}
399
Willy Tarreau91092e52007-10-25 16:58:42 +0200400/*
Willy Tarreaue7239b52009-03-29 13:41:58 +0200401 * This function simply returns a locally allocated string containing
402 * the ascii representation for number 'n' in decimal, formatted for
403 * HTML output with tags to create visual grouping by 3 digits. The
404 * output needs to support at least 171 characters.
405 */
406const char *ulltoh_r(unsigned long long n, char *buffer, int size)
407{
408 char *start;
409 int digit = 0;
410
411 start = buffer + size;
412 *--start = '\0';
413
414 do {
415 if (digit == 3 && start >= buffer + 7)
416 memcpy(start -= 7, "</span>", 7);
417
418 if (start >= buffer + 1) {
419 *--start = '0' + n % 10;
420 n /= 10;
421 }
422
423 if (digit == 3 && start >= buffer + 18)
424 memcpy(start -= 18, "<span class=\"rls\">", 18);
425
426 if (digit++ == 3)
427 digit = 1;
428 } while (n && start > buffer);
429 return start;
430}
431
432/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200433 * This function simply returns a locally allocated string containing the ascii
434 * representation for number 'n' in decimal, unless n is 0 in which case it
435 * returns the alternate string (or an empty string if the alternate string is
436 * NULL). It use is intended for limits reported in reports, where it's
437 * desirable not to display anything if there is no limit. Warning! it shares
438 * the same vector as ultoa_r().
439 */
440const char *limit_r(unsigned long n, char *buffer, int size, const char *alt)
441{
442 return (n) ? ultoa_r(n, buffer, size) : (alt ? alt : "");
443}
444
Robert Tsai81ae1952007-12-05 10:47:29 +0100445/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200446 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
447 *
448 * It looks like this one would be a good candidate for inlining, but this is
449 * not interesting because it around 35 bytes long and often called multiple
450 * times within the same function.
451 */
452int ishex(char s)
453{
454 s -= '0';
455 if ((unsigned char)s <= 9)
456 return 1;
457 s -= 'A' - '0';
458 if ((unsigned char)s <= 5)
459 return 1;
460 s -= 'a' - 'A';
461 if ((unsigned char)s <= 5)
462 return 1;
463 return 0;
464}
465
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100466/*
467 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
468 * invalid character is found, a pointer to it is returned. If everything is
469 * fine, NULL is returned.
470 */
471const char *invalid_char(const char *name)
472{
473 if (!*name)
474 return name;
475
476 while (*name) {
Willy Tarreau88e05812010-03-03 00:16:00 +0100477 if (!isalnum((int)(unsigned char)*name) && *name != '.' && *name != ':' &&
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100478 *name != '_' && *name != '-')
479 return name;
480 name++;
481 }
482 return NULL;
483}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200484
485/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200486 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
487 * If an invalid character is found, a pointer to it is returned.
488 * If everything is fine, NULL is returned.
489 */
490const char *invalid_domainchar(const char *name) {
491
492 if (!*name)
493 return name;
494
495 while (*name) {
Willy Tarreau88e05812010-03-03 00:16:00 +0100496 if (!isalnum((int)(unsigned char)*name) && *name != '.' &&
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200497 *name != '_' && *name != '-')
498 return name;
499
500 name++;
501 }
502
503 return NULL;
504}
505
506/*
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100507 * converts <str> to a struct sockaddr_storage* provided by the caller. The
Willy Tarreau24709282013-03-10 21:32:12 +0100508 * caller must have zeroed <sa> first, and may have set sa->ss_family to force
509 * parse a specific address format. If the ss_family is 0 or AF_UNSPEC, then
510 * the function tries to guess the address family from the syntax. If the
511 * family is forced and the format doesn't match, an error is returned. The
Willy Tarreaufab5a432011-03-04 15:31:53 +0100512 * string is assumed to contain only an address, no port. The address can be a
513 * dotted IPv4 address, an IPv6 address, a host name, or empty or "*" to
514 * indicate INADDR_ANY. NULL is returned if the host part cannot be resolved.
515 * The return address will only have the address family and the address set,
516 * all other fields remain zero. The string is not supposed to be modified.
517 * The IPv6 '::' address is IN6ADDR_ANY.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200518 */
Willy Tarreau24709282013-03-10 21:32:12 +0100519static struct sockaddr_storage *str2ip(const char *str, struct sockaddr_storage *sa)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200520{
Willy Tarreaufab5a432011-03-04 15:31:53 +0100521 struct hostent *he;
522
Willy Tarreaufab5a432011-03-04 15:31:53 +0100523 /* Any IPv6 address */
524 if (str[0] == ':' && str[1] == ':' && !str[2]) {
Willy Tarreau24709282013-03-10 21:32:12 +0100525 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
526 sa->ss_family = AF_INET6;
527 else if (sa->ss_family != AF_INET6)
528 goto fail;
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100529 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100530 }
531
Willy Tarreau24709282013-03-10 21:32:12 +0100532 /* Any address for the family, defaults to IPv4 */
Willy Tarreaufab5a432011-03-04 15:31:53 +0100533 if (!str[0] || (str[0] == '*' && !str[1])) {
Willy Tarreau24709282013-03-10 21:32:12 +0100534 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
535 sa->ss_family = AF_INET;
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100536 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100537 }
538
539 /* check for IPv6 first */
Willy Tarreau24709282013-03-10 21:32:12 +0100540 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET6) &&
541 inet_pton(AF_INET6, str, &((struct sockaddr_in6 *)sa)->sin6_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100542 sa->ss_family = AF_INET6;
543 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100544 }
545
546 /* then check for IPv4 */
Willy Tarreau24709282013-03-10 21:32:12 +0100547 if ((!sa->ss_family || sa->ss_family == AF_UNSPEC || sa->ss_family == AF_INET) &&
548 inet_pton(AF_INET, str, &((struct sockaddr_in *)sa)->sin_addr)) {
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100549 sa->ss_family = AF_INET;
550 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100551 }
552
553 /* try to resolve an IPv4/IPv6 hostname */
554 he = gethostbyname(str);
555 if (he) {
Willy Tarreau24709282013-03-10 21:32:12 +0100556 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
557 sa->ss_family = he->h_addrtype;
558 else if (sa->ss_family != he->h_addrtype)
559 goto fail;
560
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100561 switch (sa->ss_family) {
Willy Tarreaufab5a432011-03-04 15:31:53 +0100562 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100563 ((struct sockaddr_in *)sa)->sin_addr = *(struct in_addr *) *(he->h_addr_list);
564 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100565 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100566 ((struct sockaddr_in6 *)sa)->sin6_addr = *(struct in6_addr *) *(he->h_addr_list);
567 return sa;
Willy Tarreaufab5a432011-03-04 15:31:53 +0100568 }
David du Colombierd5f43282011-03-17 10:40:16 +0100569 }
570#ifdef USE_GETADDRINFO
571 else {
572 struct addrinfo hints, *result;
573
574 memset(&result, 0, sizeof(result));
575 memset(&hints, 0, sizeof(hints));
Willy Tarreau24709282013-03-10 21:32:12 +0100576 hints.ai_family = sa->ss_family ? sa->ss_family : AF_UNSPEC;
David du Colombierd5f43282011-03-17 10:40:16 +0100577 hints.ai_socktype = SOCK_DGRAM;
578 hints.ai_flags = AI_PASSIVE;
579 hints.ai_protocol = 0;
580
581 if (getaddrinfo(str, NULL, &hints, &result) == 0) {
Willy Tarreau24709282013-03-10 21:32:12 +0100582 if (!sa->ss_family || sa->ss_family == AF_UNSPEC)
583 sa->ss_family = result->ai_family;
584 else if (sa->ss_family != result->ai_family)
585 goto fail;
586
David du Colombierd5f43282011-03-17 10:40:16 +0100587 switch (result->ai_family) {
588 case AF_INET:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100589 memcpy((struct sockaddr_in *)sa, result->ai_addr, result->ai_addrlen);
590 return sa;
David du Colombierd5f43282011-03-17 10:40:16 +0100591 case AF_INET6:
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100592 memcpy((struct sockaddr_in6 *)sa, result->ai_addr, result->ai_addrlen);
593 return sa;
David du Colombierd5f43282011-03-17 10:40:16 +0100594 }
595 }
596
Sean Carey58ea0392013-02-15 23:39:18 +0100597 if (result)
598 freeaddrinfo(result);
Willy Tarreaufab5a432011-03-04 15:31:53 +0100599 }
David du Colombierd5f43282011-03-17 10:40:16 +0100600#endif
601 /* unsupported address family */
Willy Tarreau24709282013-03-10 21:32:12 +0100602 fail:
Willy Tarreaufab5a432011-03-04 15:31:53 +0100603 return NULL;
604}
605
606/*
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100607 * Converts <str> to a locally allocated struct sockaddr_storage *, and a port
608 * range or offset consisting in two integers that the caller will have to
609 * check to find the relevant input format. The following format are supported :
610 *
611 * String format | address | port | low | high
612 * addr | <addr> | 0 | 0 | 0
613 * addr: | <addr> | 0 | 0 | 0
614 * addr:port | <addr> | <port> | <port> | <port>
615 * addr:pl-ph | <addr> | <pl> | <pl> | <ph>
616 * addr:+port | <addr> | <port> | 0 | <port>
617 * addr:-port | <addr> |-<port> | <port> | 0
618 *
619 * The detection of a port range or increment by the caller is made by
620 * comparing <low> and <high>. If both are equal, then port 0 means no port
621 * was specified. The caller may pass NULL for <low> and <high> if it is not
622 * interested in retrieving port ranges.
623 *
624 * Note that <addr> above may also be :
625 * - empty ("") => family will be AF_INET and address will be INADDR_ANY
626 * - "*" => family will be AF_INET and address will be INADDR_ANY
627 * - "::" => family will be AF_INET6 and address will be IN6ADDR_ANY
628 * - a host name => family and address will depend on host name resolving.
629 *
Willy Tarreau24709282013-03-10 21:32:12 +0100630 * A prefix may be passed in before the address above to force the family :
631 * - "ipv4@" => force address to resolve as IPv4 and fail if not possible.
632 * - "ipv6@" => force address to resolve as IPv6 and fail if not possible.
633 * - "unix@" => force address to be a path to a UNIX socket even if the
634 * path does not start with a '/'
Willy Tarreau40aa0702013-03-10 23:51:38 +0100635 * - "fd@" => an integer must follow, and is a file descriptor number.
Willy Tarreau24709282013-03-10 21:32:12 +0100636 *
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100637 * Also note that in order to avoid any ambiguity with IPv6 addresses, the ':'
638 * is mandatory after the IP address even when no port is specified. NULL is
639 * returned if the address cannot be parsed. The <low> and <high> ports are
Willy Tarreau24709282013-03-10 21:32:12 +0100640 * always initialized if non-null, even for non-IP families.
Willy Tarreaud393a622013-03-04 18:22:00 +0100641 *
642 * If <pfx> is non-null, it is used as a string prefix before any path-based
643 * address (typically the path to a unix socket).
Willy Tarreau40aa0702013-03-10 23:51:38 +0100644 *
645 * When a file descriptor is passed, its value is put into the s_addr part of
646 * the address when cast to sockaddr_in and the address family is AF_UNSPEC.
Willy Tarreaufab5a432011-03-04 15:31:53 +0100647 */
Willy Tarreaud393a622013-03-04 18:22:00 +0100648struct sockaddr_storage *str2sa_range(const char *str, int *low, int *high, char **err, const char *pfx)
Willy Tarreaufab5a432011-03-04 15:31:53 +0100649{
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100650 static struct sockaddr_storage ss;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100651 struct sockaddr_storage *ret = NULL;
Willy Tarreau24709282013-03-10 21:32:12 +0100652 char *back, *str2;
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100653 char *port1, *port2;
654 int portl, porth, porta;
655
656 portl = porth = porta = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200657
Willy Tarreaudad36a32013-03-11 01:20:04 +0100658 str2 = back = env_expand(strdup(str));
Willy Tarreaudf350f12013-03-01 20:22:54 +0100659 if (str2 == NULL) {
660 memprintf(err, "out of memory in '%s'\n", __FUNCTION__);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100661 goto out;
Willy Tarreaudf350f12013-03-01 20:22:54 +0100662 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200663
Willy Tarreau24709282013-03-10 21:32:12 +0100664 memset(&ss, 0, sizeof(ss));
665
666 if (strncmp(str2, "unix@", 5) == 0) {
667 str2 += 5;
668 ss.ss_family = AF_UNIX;
669 }
670 else if (strncmp(str2, "ipv4@", 5) == 0) {
671 str2 += 5;
672 ss.ss_family = AF_INET;
673 }
674 else if (strncmp(str2, "ipv6@", 5) == 0) {
675 str2 += 5;
676 ss.ss_family = AF_INET6;
677 }
678 else if (*str2 == '/') {
679 ss.ss_family = AF_UNIX;
680 }
681 else
682 ss.ss_family = AF_UNSPEC;
683
Willy Tarreau40aa0702013-03-10 23:51:38 +0100684 if (ss.ss_family == AF_UNSPEC && strncmp(str2, "fd@", 3) == 0) {
685 char *endptr;
686
687 str2 += 3;
688 ((struct sockaddr_in *)&ss)->sin_addr.s_addr = strtol(str2, &endptr, 10);
689
690 if (!*str2 || *endptr) {
Willy Tarreaudad36a32013-03-11 01:20:04 +0100691 memprintf(err, "file descriptor '%s' is not a valid integer in '%s'\n", str2, str);
Willy Tarreau40aa0702013-03-10 23:51:38 +0100692 goto out;
693 }
694
695 /* we return AF_UNSPEC if we use a file descriptor number */
696 ss.ss_family = AF_UNSPEC;
697 }
698 else if (ss.ss_family == AF_UNIX) {
Willy Tarreau15586382013-03-04 19:48:14 +0100699 int prefix_path_len;
700 int max_path_len;
701
702 /* complete unix socket path name during startup or soft-restart is
703 * <unix_bind_prefix><path>.<pid>.<bak|tmp>
704 */
705 prefix_path_len = pfx ? strlen(pfx) : 0;
706 max_path_len = (sizeof(((struct sockaddr_un *)&ss)->sun_path) - 1) -
707 (prefix_path_len ? prefix_path_len + 1 + 5 + 1 + 3 : 0);
708
709 if (strlen(str2) > max_path_len) {
710 memprintf(err, "socket path '%s' too long (max %d)\n", str, max_path_len);
711 goto out;
712 }
713
Willy Tarreau15586382013-03-04 19:48:14 +0100714 if (pfx) {
715 memcpy(((struct sockaddr_un *)&ss)->sun_path, pfx, prefix_path_len);
716 strcpy(((struct sockaddr_un *)&ss)->sun_path + prefix_path_len, str2);
717 }
718 else {
719 strcpy(((struct sockaddr_un *)&ss)->sun_path, str2);
720 }
Willy Tarreau15586382013-03-04 19:48:14 +0100721 }
Willy Tarreau24709282013-03-10 21:32:12 +0100722 else { /* IPv4 and IPv6 */
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100723 port1 = strrchr(str2, ':');
724 if (port1)
725 *port1++ = '\0';
726 else
727 port1 = "";
Willy Tarreaubaaee002006-06-26 02:48:02 +0200728
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100729 if (str2ip(str2, &ss) == NULL) {
730 memprintf(err, "invalid address: '%s' in '%s'\n", str2, str);
731 goto out;
732 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100733
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100734 if (isdigit(*port1)) { /* single port or range */
735 port2 = strchr(port1, '-');
736 if (port2)
737 *port2++ = '\0';
738 else
739 port2 = port1;
740 portl = atoi(port1);
741 porth = atoi(port2);
742 porta = portl;
743 }
744 else if (*port1 == '-') { /* negative offset */
745 portl = atoi(port1 + 1);
746 porta = -portl;
747 }
748 else if (*port1 == '+') { /* positive offset */
749 porth = atoi(port1 + 1);
750 porta = porth;
751 }
752 else if (*port1) { /* other any unexpected char */
Willy Tarreaudad36a32013-03-11 01:20:04 +0100753 memprintf(err, "invalid character '%c' in port number '%s' in '%s'\n", *port1, port1, str);
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100754 goto out;
755 }
756 set_host_port(&ss, porta);
Willy Tarreaue4c58c82013-03-06 15:28:17 +0100757 }
Willy Tarreaufab5a432011-03-04 15:31:53 +0100758
Willy Tarreauc120c8d2013-03-10 19:27:44 +0100759 ret = &ss;
Willy Tarreaud5191e72010-02-09 20:50:45 +0100760 out:
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100761 if (low)
762 *low = portl;
763 if (high)
764 *high = porth;
Willy Tarreau24709282013-03-10 21:32:12 +0100765 free(back);
Willy Tarreaud5191e72010-02-09 20:50:45 +0100766 return ret;
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200767}
768
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100769/* converts <str> to a struct in_addr containing a network mask. It can be
770 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
771 * if the conversion succeeds otherwise non-zero.
772 */
773int str2mask(const char *str, struct in_addr *mask)
774{
775 if (strchr(str, '.') != NULL) { /* dotted notation */
776 if (!inet_pton(AF_INET, str, mask))
777 return 0;
778 }
779 else { /* mask length */
780 char *err;
781 unsigned long len = strtol(str, &err, 10);
782
783 if (!*str || (err && *err) || (unsigned)len > 32)
784 return 0;
785 if (len)
786 mask->s_addr = htonl(~0UL << (32 - len));
787 else
788 mask->s_addr = 0;
789 }
790 return 1;
791}
792
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200793/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200794 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200795 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
796 * is optionnal and either in the dotted or CIDR notation.
797 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
798 */
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200799int str2net(const char *str, struct in_addr *addr, struct in_addr *mask)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200800{
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200801 __label__ out_free, out_err;
802 char *c, *s;
803 int ret_val;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200804
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200805 s = strdup(str);
806 if (!s)
807 return 0;
808
Willy Tarreaubaaee002006-06-26 02:48:02 +0200809 memset(mask, 0, sizeof(*mask));
810 memset(addr, 0, sizeof(*addr));
Willy Tarreaubaaee002006-06-26 02:48:02 +0200811
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200812 if ((c = strrchr(s, '/')) != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200813 *c++ = '\0';
814 /* c points to the mask */
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100815 if (!str2mask(c, mask))
816 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200817 }
818 else {
Willy Tarreauebd61602006-12-30 11:54:15 +0100819 mask->s_addr = ~0U;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200820 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200821 if (!inet_pton(AF_INET, s, addr)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200822 struct hostent *he;
823
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200824 if ((he = gethostbyname(s)) == NULL) {
825 goto out_err;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200826 }
827 else
828 *addr = *(struct in_addr *) *(he->h_addr_list);
829 }
Willy Tarreau8aeae4a2007-06-17 11:42:08 +0200830
831 ret_val = 1;
832 out_free:
833 free(s);
834 return ret_val;
835 out_err:
836 ret_val = 0;
837 goto out_free;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200838}
839
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100840
841/*
Willy Tarreau6d20e282012-04-27 22:49:47 +0200842 * converts <str> to two struct in6_addr* which must be pre-allocated.
843 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
844 * is an optionnal number of bits (128 being the default).
845 * Returns 1 if OK, 0 if error.
846 */
847int str62net(const char *str, struct in6_addr *addr, unsigned char *mask)
848{
849 char *c, *s;
850 int ret_val = 0;
851 char *err;
852 unsigned long len = 128;
853
854 s = strdup(str);
855 if (!s)
856 return 0;
857
858 memset(mask, 0, sizeof(*mask));
859 memset(addr, 0, sizeof(*addr));
860
861 if ((c = strrchr(s, '/')) != NULL) {
862 *c++ = '\0'; /* c points to the mask */
863 if (!*c)
864 goto out_free;
865
866 len = strtoul(c, &err, 10);
867 if ((err && *err) || (unsigned)len > 128)
868 goto out_free;
869 }
870 *mask = len; /* OK we have a valid mask in <len> */
871
872 if (!inet_pton(AF_INET6, s, addr))
873 goto out_free;
874
875 ret_val = 1;
876 out_free:
877 free(s);
878 return ret_val;
879}
880
881
882/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100883 * Parse IPv4 address found in url.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100884 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100885int url2ipv4(const char *addr, struct in_addr *dst)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100886{
887 int saw_digit, octets, ch;
888 u_char tmp[4], *tp;
889 const char *cp = addr;
890
891 saw_digit = 0;
892 octets = 0;
893 *(tp = tmp) = 0;
894
895 while (*addr) {
896 unsigned char digit = (ch = *addr++) - '0';
897 if (digit > 9 && ch != '.')
898 break;
899 if (digit <= 9) {
900 u_int new = *tp * 10 + digit;
901 if (new > 255)
902 return 0;
903 *tp = new;
904 if (!saw_digit) {
905 if (++octets > 4)
906 return 0;
907 saw_digit = 1;
908 }
909 } else if (ch == '.' && saw_digit) {
910 if (octets == 4)
911 return 0;
912 *++tp = 0;
913 saw_digit = 0;
914 } else
915 return 0;
916 }
917
918 if (octets < 4)
919 return 0;
920
921 memcpy(&dst->s_addr, tmp, 4);
922 return addr-cp-1;
923}
924
925/*
David du Colombier6f5ccb12011-03-10 22:26:24 +0100926 * Resolve destination server from URL. Convert <str> to a sockaddr_storage*.
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100927 */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100928int url2sa(const char *url, int ulen, struct sockaddr_storage *addr)
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100929{
930 const char *curr = url, *cp = url;
931 int ret, url_code = 0;
932 unsigned int http_code = 0;
933
934 /* Cleanup the room */
David du Colombier6f5ccb12011-03-10 22:26:24 +0100935
936 /* FIXME: assume IPv4 only for now */
937 ((struct sockaddr_in *)addr)->sin_family = AF_INET;
938 ((struct sockaddr_in *)addr)->sin_addr.s_addr = 0;
939 ((struct sockaddr_in *)addr)->sin_port = 0;
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100940
941 /* Firstly, try to find :// pattern */
942 while (curr < url+ulen && url_code != 0x3a2f2f) {
943 url_code = ((url_code & 0xffff) << 8);
944 url_code += (unsigned char)*curr++;
945 }
946
947 /* Secondly, if :// pattern is found, verify parsed stuff
948 * before pattern is matching our http pattern.
949 * If so parse ip address and port in uri.
950 *
951 * WARNING: Current code doesn't support dynamic async dns resolver.
952 */
953 if (url_code == 0x3a2f2f) {
954 while (cp < curr - 3)
955 http_code = (http_code << 8) + *cp++;
956 http_code |= 0x20202020; /* Turn everything to lower case */
957
958 /* HTTP url matching */
959 if (http_code == 0x68747470) {
960 /* We are looking for IP address. If you want to parse and
Willy Tarreaud4448bc2013-02-20 15:55:15 +0100961 * resolve hostname found in url, you can use str2sa_range(), but
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100962 * be warned this can slow down global daemon performances
963 * while handling lagging dns responses.
964 */
Cyril Bonté9ccf6612012-10-24 23:47:47 +0200965 ret = url2ipv4(curr, &((struct sockaddr_in *)addr)->sin_addr);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100966 if (!ret)
967 return -1;
968 curr += ret;
David du Colombier6f5ccb12011-03-10 22:26:24 +0100969 ((struct sockaddr_in *)addr)->sin_port = (*curr == ':') ? str2uic(++curr) : 80;
Cyril Bonté9ccf6612012-10-24 23:47:47 +0200970 ((struct sockaddr_in *)addr)->sin_port = htons(((struct sockaddr_in *)addr)->sin_port);
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100971 }
972 return 0;
973 }
974
975 return -1;
976}
977
Willy Tarreau631f01c2011-09-05 00:36:48 +0200978/* Tries to convert a sockaddr_storage address to text form. Upon success, the
979 * address family is returned so that it's easy for the caller to adapt to the
980 * output format. Zero is returned if the address family is not supported. -1
981 * is returned upon error, with errno set. AF_INET, AF_INET6 and AF_UNIX are
982 * supported.
983 */
984int addr_to_str(struct sockaddr_storage *addr, char *str, int size)
985{
986
987 void *ptr;
988
989 if (size < 5)
990 return 0;
991 *str = '\0';
992
993 switch (addr->ss_family) {
994 case AF_INET:
995 ptr = &((struct sockaddr_in *)addr)->sin_addr;
996 break;
997 case AF_INET6:
998 ptr = &((struct sockaddr_in6 *)addr)->sin6_addr;
999 break;
1000 case AF_UNIX:
1001 memcpy(str, "unix", 5);
1002 return addr->ss_family;
1003 default:
1004 return 0;
1005 }
1006
1007 if (inet_ntop(addr->ss_family, ptr, str, size))
1008 return addr->ss_family;
1009
1010 /* failed */
1011 return -1;
1012}
1013
Willy Tarreaubaaee002006-06-26 02:48:02 +02001014/* will try to encode the string <string> replacing all characters tagged in
1015 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
1016 * prefixed by <escape>, and will store the result between <start> (included)
1017 * and <stop> (excluded), and will always terminate the string with a '\0'
1018 * before <stop>. The position of the '\0' is returned if the conversion
1019 * completes. If bytes are missing between <start> and <stop>, then the
1020 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
1021 * cannot even be stored so we return <start> without writing the 0.
1022 * The input string must also be zero-terminated.
1023 */
1024const char hextab[16] = "0123456789ABCDEF";
1025char *encode_string(char *start, char *stop,
1026 const char escape, const fd_set *map,
1027 const char *string)
1028{
1029 if (start < stop) {
1030 stop--; /* reserve one byte for the final '\0' */
1031 while (start < stop && *string != '\0') {
1032 if (!FD_ISSET((unsigned char)(*string), map))
1033 *start++ = *string;
1034 else {
1035 if (start + 3 >= stop)
1036 break;
1037 *start++ = escape;
1038 *start++ = hextab[(*string >> 4) & 15];
1039 *start++ = hextab[*string & 15];
1040 }
1041 string++;
1042 }
1043 *start = '\0';
1044 }
1045 return start;
1046}
1047
Willy Tarreaubf9c2fc2011-05-31 18:06:18 +02001048/* Decode an URL-encoded string in-place. The resulting string might
1049 * be shorter. If some forbidden characters are found, the conversion is
1050 * aborted, the string is truncated before the issue and non-zero is returned,
1051 * otherwise the operation returns non-zero indicating success.
1052 */
1053int url_decode(char *string)
1054{
1055 char *in, *out;
1056 int ret = 0;
1057
1058 in = string;
1059 out = string;
1060 while (*in) {
1061 switch (*in) {
1062 case '+' :
1063 *out++ = ' ';
1064 break;
1065 case '%' :
1066 if (!ishex(in[1]) || !ishex(in[2]))
1067 goto end;
1068 *out++ = (hex2i(in[1]) << 4) + hex2i(in[2]);
1069 in += 2;
1070 break;
1071 default:
1072 *out++ = *in;
1073 break;
1074 }
1075 in++;
1076 }
1077 ret = 1; /* success */
1078 end:
1079 *out = 0;
1080 return ret;
1081}
Willy Tarreaubaaee002006-06-26 02:48:02 +02001082
Willy Tarreau6911fa42007-03-04 18:06:08 +01001083unsigned int str2ui(const char *s)
1084{
1085 return __str2ui(s);
1086}
1087
1088unsigned int str2uic(const char *s)
1089{
1090 return __str2uic(s);
1091}
1092
1093unsigned int strl2ui(const char *s, int len)
1094{
1095 return __strl2ui(s, len);
1096}
1097
1098unsigned int strl2uic(const char *s, int len)
1099{
1100 return __strl2uic(s, len);
1101}
1102
Willy Tarreau4ec83cd2010-10-15 23:19:55 +02001103unsigned int read_uint(const char **s, const char *end)
1104{
1105 return __read_uint(s, end);
1106}
1107
Willy Tarreau6911fa42007-03-04 18:06:08 +01001108/* This one is 7 times faster than strtol() on athlon with checks.
1109 * It returns the value of the number composed of all valid digits read,
1110 * and can process negative numbers too.
1111 */
1112int strl2ic(const char *s, int len)
1113{
1114 int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001115 int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001116
1117 if (len > 0) {
1118 if (*s != '-') {
1119 /* positive number */
1120 while (len-- > 0) {
1121 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001122 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001123 if (j > 9)
1124 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001125 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001126 }
1127 } else {
1128 /* negative number */
1129 s++;
1130 while (--len > 0) {
1131 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001132 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001133 if (j > 9)
1134 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +02001135 i = k - j;
Willy Tarreau6911fa42007-03-04 18:06:08 +01001136 }
1137 }
1138 }
1139 return i;
1140}
1141
1142
1143/* This function reads exactly <len> chars from <s> and converts them to a
1144 * signed integer which it stores into <ret>. It accurately detects any error
1145 * (truncated string, invalid chars, overflows). It is meant to be used in
1146 * applications designed for hostile environments. It returns zero when the
1147 * number has successfully been converted, non-zero otherwise. When an error
1148 * is returned, the <ret> value is left untouched. It is yet 5 to 40 times
1149 * faster than strtol().
1150 */
1151int strl2irc(const char *s, int len, int *ret)
1152{
1153 int i = 0;
1154 int j;
1155
1156 if (!len)
1157 return 1;
1158
1159 if (*s != '-') {
1160 /* positive number */
1161 while (len-- > 0) {
1162 j = (*s++) - '0';
1163 if (j > 9) return 1; /* invalid char */
1164 if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
1165 i = i * 10;
1166 if (i + j < i) return 1; /* check for addition overflow */
1167 i = i + j;
1168 }
1169 } else {
1170 /* negative number */
1171 s++;
1172 while (--len > 0) {
1173 j = (*s++) - '0';
1174 if (j > 9) return 1; /* invalid char */
1175 if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
1176 i = i * 10;
1177 if (i - j > i) return 1; /* check for subtract overflow */
1178 i = i - j;
1179 }
1180 }
1181 *ret = i;
1182 return 0;
1183}
1184
1185
1186/* This function reads exactly <len> chars from <s> and converts them to a
1187 * signed integer which it stores into <ret>. It accurately detects any error
1188 * (truncated string, invalid chars, overflows). It is meant to be used in
1189 * applications designed for hostile environments. It returns zero when the
1190 * number has successfully been converted, non-zero otherwise. When an error
1191 * is returned, the <ret> value is left untouched. It is about 3 times slower
1192 * than str2irc().
1193 */
Willy Tarreau6911fa42007-03-04 18:06:08 +01001194
1195int strl2llrc(const char *s, int len, long long *ret)
1196{
1197 long long i = 0;
1198 int j;
1199
1200 if (!len)
1201 return 1;
1202
1203 if (*s != '-') {
1204 /* positive number */
1205 while (len-- > 0) {
1206 j = (*s++) - '0';
1207 if (j > 9) return 1; /* invalid char */
1208 if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
1209 i = i * 10LL;
1210 if (i + j < i) return 1; /* check for addition overflow */
1211 i = i + j;
1212 }
1213 } else {
1214 /* negative number */
1215 s++;
1216 while (--len > 0) {
1217 j = (*s++) - '0';
1218 if (j > 9) return 1; /* invalid char */
1219 if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
1220 i = i * 10LL;
1221 if (i - j > i) return 1; /* check for subtract overflow */
1222 i = i - j;
1223 }
1224 }
1225 *ret = i;
1226 return 0;
1227}
1228
Willy Tarreaua0d37b62007-12-02 22:00:35 +01001229/* This function parses a time value optionally followed by a unit suffix among
1230 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
1231 * expected by the caller. The computation does its best to avoid overflows.
1232 * The value is returned in <ret> if everything is fine, and a NULL is returned
1233 * by the function. In case of error, a pointer to the error is returned and
1234 * <ret> is left untouched. Values are automatically rounded up when needed.
1235 */
1236const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags)
1237{
1238 unsigned imult, idiv;
1239 unsigned omult, odiv;
1240 unsigned value;
1241
1242 omult = odiv = 1;
1243
1244 switch (unit_flags & TIME_UNIT_MASK) {
1245 case TIME_UNIT_US: omult = 1000000; break;
1246 case TIME_UNIT_MS: omult = 1000; break;
1247 case TIME_UNIT_S: break;
1248 case TIME_UNIT_MIN: odiv = 60; break;
1249 case TIME_UNIT_HOUR: odiv = 3600; break;
1250 case TIME_UNIT_DAY: odiv = 86400; break;
1251 default: break;
1252 }
1253
1254 value = 0;
1255
1256 while (1) {
1257 unsigned int j;
1258
1259 j = *text - '0';
1260 if (j > 9)
1261 break;
1262 text++;
1263 value *= 10;
1264 value += j;
1265 }
1266
1267 imult = idiv = 1;
1268 switch (*text) {
1269 case '\0': /* no unit = default unit */
1270 imult = omult = idiv = odiv = 1;
1271 break;
1272 case 's': /* second = unscaled unit */
1273 break;
1274 case 'u': /* microsecond : "us" */
1275 if (text[1] == 's') {
1276 idiv = 1000000;
1277 text++;
1278 }
1279 break;
1280 case 'm': /* millisecond : "ms" or minute: "m" */
1281 if (text[1] == 's') {
1282 idiv = 1000;
1283 text++;
1284 } else
1285 imult = 60;
1286 break;
1287 case 'h': /* hour : "h" */
1288 imult = 3600;
1289 break;
1290 case 'd': /* day : "d" */
1291 imult = 86400;
1292 break;
1293 default:
1294 return text;
1295 break;
1296 }
1297
1298 if (omult % idiv == 0) { omult /= idiv; idiv = 1; }
1299 if (idiv % omult == 0) { idiv /= omult; omult = 1; }
1300 if (imult % odiv == 0) { imult /= odiv; odiv = 1; }
1301 if (odiv % imult == 0) { odiv /= imult; imult = 1; }
1302
1303 value = (value * (imult * omult) + (idiv * odiv - 1)) / (idiv * odiv);
1304 *ret = value;
1305 return NULL;
1306}
Willy Tarreau6911fa42007-03-04 18:06:08 +01001307
Emeric Brun39132b22010-01-04 14:57:24 +01001308/* this function converts the string starting at <text> to an unsigned int
1309 * stored in <ret>. If an error is detected, the pointer to the unexpected
1310 * character is returned. If the conversio is succesful, NULL is returned.
1311 */
1312const char *parse_size_err(const char *text, unsigned *ret) {
1313 unsigned value = 0;
1314
1315 while (1) {
1316 unsigned int j;
1317
1318 j = *text - '0';
1319 if (j > 9)
1320 break;
1321 if (value > ~0U / 10)
1322 return text;
1323 value *= 10;
1324 if (value > (value + j))
1325 return text;
1326 value += j;
1327 text++;
1328 }
1329
1330 switch (*text) {
1331 case '\0':
1332 break;
1333 case 'K':
1334 case 'k':
1335 if (value > ~0U >> 10)
1336 return text;
1337 value = value << 10;
1338 break;
1339 case 'M':
1340 case 'm':
1341 if (value > ~0U >> 20)
1342 return text;
1343 value = value << 20;
1344 break;
1345 case 'G':
1346 case 'g':
1347 if (value > ~0U >> 30)
1348 return text;
1349 value = value << 30;
1350 break;
1351 default:
1352 return text;
1353 }
1354
1355 *ret = value;
1356 return NULL;
1357}
1358
Willy Tarreau946ba592009-05-10 15:41:18 +02001359/* copies at most <n> characters from <src> and always terminates with '\0' */
1360char *my_strndup(const char *src, int n)
1361{
1362 int len = 0;
1363 char *ret;
1364
1365 while (len < n && src[len])
1366 len++;
1367
1368 ret = (char *)malloc(len + 1);
1369 if (!ret)
1370 return ret;
1371 memcpy(ret, src, len);
1372 ret[len] = '\0';
1373 return ret;
1374}
1375
Willy Tarreau482b00d2009-10-04 22:48:42 +02001376/* This function returns the first unused key greater than or equal to <key> in
1377 * ID tree <root>. Zero is returned if no place is found.
1378 */
1379unsigned int get_next_id(struct eb_root *root, unsigned int key)
1380{
1381 struct eb32_node *used;
1382
1383 do {
1384 used = eb32_lookup_ge(root, key);
1385 if (!used || used->key > key)
1386 return key; /* key is available */
1387 key++;
1388 } while (key);
1389 return key;
1390}
1391
Willy Tarreau348238b2010-01-18 15:05:57 +01001392/* This function compares a sample word possibly followed by blanks to another
1393 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
1394 * otherwise zero. This intends to be used when checking HTTP headers for some
1395 * values. Note that it validates a word followed only by blanks but does not
1396 * validate a word followed by blanks then other chars.
1397 */
1398int word_match(const char *sample, int slen, const char *word, int wlen)
1399{
1400 if (slen < wlen)
1401 return 0;
1402
1403 while (wlen) {
1404 char c = *sample ^ *word;
1405 if (c && c != ('A' ^ 'a'))
1406 return 0;
1407 sample++;
1408 word++;
1409 slen--;
1410 wlen--;
1411 }
1412
1413 while (slen) {
1414 if (*sample != ' ' && *sample != '\t')
1415 return 0;
1416 sample++;
1417 slen--;
1418 }
1419 return 1;
1420}
Willy Tarreau482b00d2009-10-04 22:48:42 +02001421
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02001422/* Converts any text-formatted IPv4 address to a host-order IPv4 address. It
1423 * is particularly fast because it avoids expensive operations such as
1424 * multiplies, which are optimized away at the end. It requires a properly
1425 * formated address though (3 points).
1426 */
1427unsigned int inetaddr_host(const char *text)
1428{
1429 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
1430 register unsigned int dig100, dig10, dig1;
1431 int s;
1432 const char *p, *d;
1433
1434 dig1 = dig10 = dig100 = ascii_zero;
1435 s = 24;
1436
1437 p = text;
1438 while (1) {
1439 if (((unsigned)(*p - '0')) <= 9) {
1440 p++;
1441 continue;
1442 }
1443
1444 /* here, we have a complete byte between <text> and <p> (exclusive) */
1445 if (p == text)
1446 goto end;
1447
1448 d = p - 1;
1449 dig1 |= (unsigned int)(*d << s);
1450 if (d == text)
1451 goto end;
1452
1453 d--;
1454 dig10 |= (unsigned int)(*d << s);
1455 if (d == text)
1456 goto end;
1457
1458 d--;
1459 dig100 |= (unsigned int)(*d << s);
1460 end:
1461 if (!s || *p != '.')
1462 break;
1463
1464 s -= 8;
1465 text = ++p;
1466 }
1467
1468 dig100 -= ascii_zero;
1469 dig10 -= ascii_zero;
1470 dig1 -= ascii_zero;
1471 return ((dig100 * 10) + dig10) * 10 + dig1;
1472}
1473
1474/*
1475 * Idem except the first unparsed character has to be passed in <stop>.
1476 */
1477unsigned int inetaddr_host_lim(const char *text, const char *stop)
1478{
1479 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
1480 register unsigned int dig100, dig10, dig1;
1481 int s;
1482 const char *p, *d;
1483
1484 dig1 = dig10 = dig100 = ascii_zero;
1485 s = 24;
1486
1487 p = text;
1488 while (1) {
1489 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
1490 p++;
1491 continue;
1492 }
1493
1494 /* here, we have a complete byte between <text> and <p> (exclusive) */
1495 if (p == text)
1496 goto end;
1497
1498 d = p - 1;
1499 dig1 |= (unsigned int)(*d << s);
1500 if (d == text)
1501 goto end;
1502
1503 d--;
1504 dig10 |= (unsigned int)(*d << s);
1505 if (d == text)
1506 goto end;
1507
1508 d--;
1509 dig100 |= (unsigned int)(*d << s);
1510 end:
1511 if (!s || p == stop || *p != '.')
1512 break;
1513
1514 s -= 8;
1515 text = ++p;
1516 }
1517
1518 dig100 -= ascii_zero;
1519 dig10 -= ascii_zero;
1520 dig1 -= ascii_zero;
1521 return ((dig100 * 10) + dig10) * 10 + dig1;
1522}
1523
1524/*
1525 * Idem except the pointer to first unparsed byte is returned into <ret> which
1526 * must not be NULL.
1527 */
Willy Tarreau74172752010-10-15 23:21:42 +02001528unsigned int inetaddr_host_lim_ret(char *text, char *stop, char **ret)
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02001529{
1530 const unsigned int ascii_zero = ('0' << 24) | ('0' << 16) | ('0' << 8) | '0';
1531 register unsigned int dig100, dig10, dig1;
1532 int s;
Willy Tarreau74172752010-10-15 23:21:42 +02001533 char *p, *d;
Willy Tarreaud54bbdc2009-09-07 11:00:31 +02001534
1535 dig1 = dig10 = dig100 = ascii_zero;
1536 s = 24;
1537
1538 p = text;
1539 while (1) {
1540 if (((unsigned)(*p - '0')) <= 9 && p < stop) {
1541 p++;
1542 continue;
1543 }
1544
1545 /* here, we have a complete byte between <text> and <p> (exclusive) */
1546 if (p == text)
1547 goto end;
1548
1549 d = p - 1;
1550 dig1 |= (unsigned int)(*d << s);
1551 if (d == text)
1552 goto end;
1553
1554 d--;
1555 dig10 |= (unsigned int)(*d << s);
1556 if (d == text)
1557 goto end;
1558
1559 d--;
1560 dig100 |= (unsigned int)(*d << s);
1561 end:
1562 if (!s || p == stop || *p != '.')
1563 break;
1564
1565 s -= 8;
1566 text = ++p;
1567 }
1568
1569 *ret = p;
1570 dig100 -= ascii_zero;
1571 dig10 -= ascii_zero;
1572 dig1 -= ascii_zero;
1573 return ((dig100 * 10) + dig10) * 10 + dig1;
1574}
1575
Willy Tarreauf0b38bf2010-06-06 13:22:23 +02001576/* Convert a fixed-length string to an IP address. Returns 0 in case of error,
1577 * or the number of chars read in case of success. Maybe this could be replaced
1578 * by one of the functions above. Also, apparently this function does not support
1579 * hosts above 255 and requires exactly 4 octets.
1580 */
1581int buf2ip(const char *buf, size_t len, struct in_addr *dst)
1582{
1583 const char *addr;
1584 int saw_digit, octets, ch;
1585 u_char tmp[4], *tp;
1586 const char *cp = buf;
1587
1588 saw_digit = 0;
1589 octets = 0;
1590 *(tp = tmp) = 0;
1591
1592 for (addr = buf; addr - buf < len; addr++) {
1593 unsigned char digit = (ch = *addr) - '0';
1594
1595 if (digit > 9 && ch != '.')
1596 break;
1597
1598 if (digit <= 9) {
1599 u_int new = *tp * 10 + digit;
1600
1601 if (new > 255)
1602 return 0;
1603
1604 *tp = new;
1605
1606 if (!saw_digit) {
1607 if (++octets > 4)
1608 return 0;
1609 saw_digit = 1;
1610 }
1611 } else if (ch == '.' && saw_digit) {
1612 if (octets == 4)
1613 return 0;
1614
1615 *++tp = 0;
1616 saw_digit = 0;
1617 } else
1618 return 0;
1619 }
1620
1621 if (octets < 4)
1622 return 0;
1623
1624 memcpy(&dst->s_addr, tmp, 4);
1625 return addr - cp;
1626}
1627
Willy Tarreauacf95772010-06-14 19:09:21 +02001628/* To be used to quote config arg positions. Returns the short string at <ptr>
1629 * surrounded by simple quotes if <ptr> is valid and non-empty, or "end of line"
1630 * if ptr is NULL or empty. The string is locally allocated.
1631 */
1632const char *quote_arg(const char *ptr)
1633{
1634 static char val[32];
1635 int i;
1636
1637 if (!ptr || !*ptr)
1638 return "end of line";
1639 val[0] = '\'';
Willy Tarreaude2dd6b2013-01-24 02:14:42 +01001640 for (i = 1; i < sizeof(val) - 2 && *ptr; i++)
Willy Tarreauacf95772010-06-14 19:09:21 +02001641 val[i] = *ptr++;
1642 val[i++] = '\'';
1643 val[i] = '\0';
1644 return val;
1645}
1646
Willy Tarreau5b180202010-07-18 10:40:48 +02001647/* returns an operator among STD_OP_* for string <str> or < 0 if unknown */
1648int get_std_op(const char *str)
1649{
1650 int ret = -1;
1651
1652 if (*str == 'e' && str[1] == 'q')
1653 ret = STD_OP_EQ;
1654 else if (*str == 'n' && str[1] == 'e')
1655 ret = STD_OP_NE;
1656 else if (*str == 'l') {
1657 if (str[1] == 'e') ret = STD_OP_LE;
1658 else if (str[1] == 't') ret = STD_OP_LT;
1659 }
1660 else if (*str == 'g') {
1661 if (str[1] == 'e') ret = STD_OP_GE;
1662 else if (str[1] == 't') ret = STD_OP_GT;
1663 }
1664
1665 if (ret == -1 || str[2] != '\0')
1666 return -1;
1667 return ret;
1668}
1669
Willy Tarreau4c14eaa2010-11-24 14:01:45 +01001670/* hash a 32-bit integer to another 32-bit integer */
1671unsigned int full_hash(unsigned int a)
1672{
1673 return __full_hash(a);
1674}
1675
David du Colombier4f92d322011-03-24 11:09:31 +01001676/* Return non-zero if IPv4 address is part of the network,
1677 * otherwise zero.
1678 */
1679int in_net_ipv4(struct in_addr *addr, struct in_addr *mask, struct in_addr *net)
1680{
1681 return((addr->s_addr & mask->s_addr) == (net->s_addr & mask->s_addr));
1682}
1683
1684/* Return non-zero if IPv6 address is part of the network,
1685 * otherwise zero.
1686 */
1687int in_net_ipv6(struct in6_addr *addr, struct in6_addr *mask, struct in6_addr *net)
1688{
1689 int i;
1690
1691 for (i = 0; i < sizeof(struct in6_addr) / sizeof(int); i++)
1692 if (((((int *)addr)[i] & ((int *)mask)[i])) !=
1693 (((int *)net)[i] & ((int *)mask)[i]))
1694 return 0;
1695 return 1;
1696}
1697
1698/* RFC 4291 prefix */
1699const char rfc4291_pfx[] = { 0x00, 0x00, 0x00, 0x00,
1700 0x00, 0x00, 0x00, 0x00,
1701 0x00, 0x00, 0xFF, 0xFF };
1702
1703/* Map IPv4 adress on IPv6 address, as specified in RFC 3513. */
1704void v4tov6(struct in6_addr *sin6_addr, struct in_addr *sin_addr)
1705{
1706 memcpy(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx));
1707 memcpy(sin6_addr->s6_addr+12, &sin_addr->s_addr, 4);
1708}
1709
1710/* Map IPv6 adress on IPv4 address, as specified in RFC 3513.
1711 * Return true if conversion is possible and false otherwise.
1712 */
1713int v6tov4(struct in_addr *sin_addr, struct in6_addr *sin6_addr)
1714{
1715 if (memcmp(sin6_addr->s6_addr, rfc4291_pfx, sizeof(rfc4291_pfx)) == 0) {
1716 memcpy(&(sin_addr->s_addr), &(sin6_addr->s6_addr[12]),
1717 sizeof(struct in_addr));
1718 return 1;
1719 }
1720
1721 return 0;
1722}
1723
William Lallemand421f5b52012-02-06 18:15:57 +01001724char *human_time(int t, short hz_div) {
1725 static char rv[sizeof("24855d23h")+1]; // longest of "23h59m" and "59m59s"
1726 char *p = rv;
1727 int cnt=2; // print two numbers
1728
1729 if (unlikely(t < 0 || hz_div <= 0)) {
1730 sprintf(p, "?");
1731 return rv;
1732 }
1733
1734 if (unlikely(hz_div > 1))
1735 t /= hz_div;
1736
1737 if (t >= DAY) {
1738 p += sprintf(p, "%dd", t / DAY);
1739 cnt--;
1740 }
1741
1742 if (cnt && t % DAY / HOUR) {
1743 p += sprintf(p, "%dh", t % DAY / HOUR);
1744 cnt--;
1745 }
1746
1747 if (cnt && t % HOUR / MINUTE) {
1748 p += sprintf(p, "%dm", t % HOUR / MINUTE);
1749 cnt--;
1750 }
1751
1752 if ((cnt && t % MINUTE) || !t) // also display '0s'
1753 p += sprintf(p, "%ds", t % MINUTE / SEC);
1754
1755 return rv;
1756}
1757
1758const char *monthname[12] = {
1759 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1760 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1761};
1762
1763/* date2str_log: write a date in the format :
1764 * sprintf(str, "%02d/%s/%04d:%02d:%02d:%02d.%03d",
1765 * tm.tm_mday, monthname[tm.tm_mon], tm.tm_year+1900,
1766 * tm.tm_hour, tm.tm_min, tm.tm_sec, (int)date.tv_usec/1000);
1767 *
1768 * without using sprintf. return a pointer to the last char written (\0) or
1769 * NULL if there isn't enough space.
1770 */
1771char *date2str_log(char *dst, struct tm *tm, struct timeval *date, size_t size)
1772{
1773
1774 if (size < 25) /* the size is fixed: 24 chars + \0 */
1775 return NULL;
1776
1777 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
1778 *dst++ = '/';
1779 memcpy(dst, monthname[tm->tm_mon], 3); // month
1780 dst += 3;
1781 *dst++ = '/';
1782 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
1783 *dst++ = ':';
1784 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
1785 *dst++ = ':';
1786 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
1787 *dst++ = ':';
1788 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
1789 *dst++ = '.';
1790 utoa_pad((unsigned int)(date->tv_usec/1000), dst, 4); // millisecondes
1791 dst += 3; // only the 3 first digits
1792 *dst = '\0';
1793
1794 return dst;
1795}
1796
1797/* gmt2str_log: write a date in the format :
1798 * "%02d/%s/%04d:%02d:%02d:%02d +0000" without using snprintf
1799 * return a pointer to the last char written (\0) or
1800 * NULL if there isn't enough space.
1801 */
1802char *gmt2str_log(char *dst, struct tm *tm, size_t size)
1803{
Yuxans Yao4e25b012012-10-19 10:36:09 +08001804 if (size < 27) /* the size is fixed: 26 chars + \0 */
William Lallemand421f5b52012-02-06 18:15:57 +01001805 return NULL;
1806
1807 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
1808 *dst++ = '/';
1809 memcpy(dst, monthname[tm->tm_mon], 3); // month
1810 dst += 3;
1811 *dst++ = '/';
1812 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
1813 *dst++ = ':';
1814 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
1815 *dst++ = ':';
1816 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
1817 *dst++ = ':';
1818 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
1819 *dst++ = ' ';
1820 *dst++ = '+';
1821 *dst++ = '0';
1822 *dst++ = '0';
1823 *dst++ = '0';
1824 *dst++ = '0';
1825 *dst = '\0';
1826
1827 return dst;
1828}
1829
Yuxans Yao4e25b012012-10-19 10:36:09 +08001830/* localdate2str_log: write a date in the format :
1831 * "%02d/%s/%04d:%02d:%02d:%02d +0000(local timezone)" without using snprintf
1832 * * return a pointer to the last char written (\0) or
1833 * * NULL if there isn't enough space.
1834 */
1835char *localdate2str_log(char *dst, struct tm *tm, size_t size)
1836{
1837 if (size < 27) /* the size is fixed: 26 chars + \0 */
1838 return NULL;
1839
1840 dst = utoa_pad((unsigned int)tm->tm_mday, dst, 3); // day
1841 *dst++ = '/';
1842 memcpy(dst, monthname[tm->tm_mon], 3); // month
1843 dst += 3;
1844 *dst++ = '/';
1845 dst = utoa_pad((unsigned int)tm->tm_year+1900, dst, 5); // year
1846 *dst++ = ':';
1847 dst = utoa_pad((unsigned int)tm->tm_hour, dst, 3); // hour
1848 *dst++ = ':';
1849 dst = utoa_pad((unsigned int)tm->tm_min, dst, 3); // minutes
1850 *dst++ = ':';
1851 dst = utoa_pad((unsigned int)tm->tm_sec, dst, 3); // secondes
1852 *dst++ = ' ';
1853 memcpy(dst, localtimezone, 5); // timezone
1854 dst += 5;
1855 *dst = '\0';
1856
1857 return dst;
1858}
1859
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001860/* Dynamically allocates a string of the proper length to hold the formatted
1861 * output. NULL is returned on error. The caller is responsible for freeing the
1862 * memory area using free(). The resulting string is returned in <out> if the
1863 * pointer is not NULL. A previous version of <out> might be used to build the
1864 * new string, and it will be freed before returning if it is not NULL, which
1865 * makes it possible to build complex strings from iterative calls without
1866 * having to care about freeing intermediate values, as in the example below :
1867 *
1868 * memprintf(&err, "invalid argument: '%s'", arg);
1869 * ...
1870 * memprintf(&err, "parser said : <%s>\n", *err);
1871 * ...
1872 * free(*err);
1873 *
1874 * This means that <err> must be initialized to NULL before first invocation.
1875 * The return value also holds the allocated string, which eases error checking
1876 * and immediate consumption. If the output pointer is not used, NULL must be
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001877 * passed instead and it will be ignored. The returned message will then also
1878 * be NULL so that the caller does not have to bother with freeing anything.
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001879 *
1880 * It is also convenient to use it without any free except the last one :
1881 * err = NULL;
1882 * if (!fct1(err)) report(*err);
1883 * if (!fct2(err)) report(*err);
1884 * if (!fct3(err)) report(*err);
1885 * free(*err);
1886 */
1887char *memprintf(char **out, const char *format, ...)
1888{
1889 va_list args;
1890 char *ret = NULL;
1891 int allocated = 0;
1892 int needed = 0;
1893
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001894 if (!out)
1895 return NULL;
1896
Willy Tarreau9a7bea52012-04-27 11:16:50 +02001897 do {
1898 /* vsnprintf() will return the required length even when the
1899 * target buffer is NULL. We do this in a loop just in case
1900 * intermediate evaluations get wrong.
1901 */
1902 va_start(args, format);
1903 needed = vsnprintf(ret, allocated, format, args) + 1;
1904 va_end(args);
1905
1906 if (needed <= allocated)
1907 break;
1908
1909 allocated = needed;
1910 ret = realloc(ret, allocated);
1911 } while (ret);
1912
1913 if (needed < 0) {
1914 /* an error was encountered */
1915 free(ret);
1916 ret = NULL;
1917 }
1918
1919 if (out) {
1920 free(*out);
1921 *out = ret;
1922 }
1923
1924 return ret;
1925}
William Lallemand421f5b52012-02-06 18:15:57 +01001926
Willy Tarreau21c705b2012-09-14 11:40:36 +02001927/* Used to add <level> spaces before each line of <out>, unless there is only one line.
1928 * The input argument is automatically freed and reassigned. The result will have to be
Willy Tarreau70eec382012-10-10 08:56:47 +02001929 * freed by the caller. It also supports being passed a NULL which results in the same
1930 * output.
Willy Tarreau21c705b2012-09-14 11:40:36 +02001931 * Example of use :
1932 * parse(cmd, &err); (callee: memprintf(&err, ...))
1933 * fprintf(stderr, "Parser said: %s\n", indent_error(&err));
1934 * free(err);
1935 */
1936char *indent_msg(char **out, int level)
1937{
1938 char *ret, *in, *p;
1939 int needed = 0;
1940 int lf = 0;
1941 int lastlf = 0;
1942 int len;
1943
Willy Tarreau70eec382012-10-10 08:56:47 +02001944 if (!out || !*out)
1945 return NULL;
1946
Willy Tarreau21c705b2012-09-14 11:40:36 +02001947 in = *out - 1;
1948 while ((in = strchr(in + 1, '\n')) != NULL) {
1949 lastlf = in - *out;
1950 lf++;
1951 }
1952
1953 if (!lf) /* single line, no LF, return it as-is */
1954 return *out;
1955
1956 len = strlen(*out);
1957
1958 if (lf == 1 && lastlf == len - 1) {
1959 /* single line, LF at end, strip it and return as-is */
1960 (*out)[lastlf] = 0;
1961 return *out;
1962 }
1963
1964 /* OK now we have at least one LF, we need to process the whole string
1965 * as a multi-line string. What we'll do :
1966 * - prefix with an LF if there is none
1967 * - add <level> spaces before each line
1968 * This means at most ( 1 + level + (len-lf) + lf*<1+level) ) =
1969 * 1 + level + len + lf * level = 1 + level * (lf + 1) + len.
1970 */
1971
1972 needed = 1 + level * (lf + 1) + len + 1;
1973 p = ret = malloc(needed);
1974 in = *out;
1975
1976 /* skip initial LFs */
1977 while (*in == '\n')
1978 in++;
1979
1980 /* copy each line, prefixed with LF and <level> spaces, and without the trailing LF */
1981 while (*in) {
1982 *p++ = '\n';
1983 memset(p, ' ', level);
1984 p += level;
1985 do {
1986 *p++ = *in++;
1987 } while (*in && *in != '\n');
1988 if (*in)
1989 in++;
1990 }
1991 *p = 0;
1992
1993 free(*out);
1994 *out = ret;
1995
1996 return ret;
1997}
1998
Willy Tarreaudad36a32013-03-11 01:20:04 +01001999/* Convert occurrences of environment variables in the input string to their
2000 * corresponding value. A variable is identified as a series of alphanumeric
2001 * characters or underscores following a '$' sign. The <in> string must be
2002 * free()able. NULL returns NULL. The resulting string might be reallocated if
2003 * some expansion is made. Variable names may also be enclosed into braces if
2004 * needed (eg: to concatenate alphanum characters).
2005 */
2006char *env_expand(char *in)
2007{
2008 char *txt_beg;
2009 char *out;
2010 char *txt_end;
2011 char *var_beg;
2012 char *var_end;
2013 char *value;
2014 char *next;
2015 int out_len;
2016 int val_len;
2017
2018 if (!in)
2019 return in;
2020
2021 value = out = NULL;
2022 out_len = 0;
2023
2024 txt_beg = in;
2025 do {
2026 /* look for next '$' sign in <in> */
2027 for (txt_end = txt_beg; *txt_end && *txt_end != '$'; txt_end++);
2028
2029 if (!*txt_end && !out) /* end and no expansion performed */
2030 return in;
2031
2032 val_len = 0;
2033 next = txt_end;
2034 if (*txt_end == '$') {
2035 char save;
2036
2037 var_beg = txt_end + 1;
2038 if (*var_beg == '{')
2039 var_beg++;
2040
2041 var_end = var_beg;
2042 while (isalnum((int)(unsigned char)*var_end) || *var_end == '_') {
2043 var_end++;
2044 }
2045
2046 next = var_end;
2047 if (*var_end == '}' && (var_beg > txt_end + 1))
2048 next++;
2049
2050 /* get value of the variable name at this location */
2051 save = *var_end;
2052 *var_end = '\0';
2053 value = getenv(var_beg);
2054 *var_end = save;
2055 val_len = value ? strlen(value) : 0;
2056 }
2057
2058 out = realloc(out, out_len + (txt_end - txt_beg) + val_len + 1);
2059 if (txt_end > txt_beg) {
2060 memcpy(out + out_len, txt_beg, txt_end - txt_beg);
2061 out_len += txt_end - txt_beg;
2062 }
2063 if (val_len) {
2064 memcpy(out + out_len, value, val_len);
2065 out_len += val_len;
2066 }
2067 out[out_len] = 0;
2068 txt_beg = next;
2069 } while (*txt_beg);
2070
2071 /* here we know that <out> was allocated and that we don't need <in> anymore */
2072 free(in);
2073 return out;
2074}
2075
Willy Tarreaubaaee002006-06-26 02:48:02 +02002076/*
2077 * Local variables:
2078 * c-indent-level: 8
2079 * c-basic-offset: 8
2080 * End:
2081 */