914030775ba660a06ef00c842498a96d8835fc23
[exim.git] / src / src / string.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Miscellaneous string-handling functions. Some are not required for
9 utilities and tests, and are cut out by the COMPILE_UTILITY macro. */
10
11
12 #include "exim.h"
13 #include <assert.h>
14
15
16 #ifndef COMPILE_UTILITY
17 /*************************************************
18 * Test for IP address *
19 *************************************************/
20
21 /* This used just to be a regular expression, but with IPv6 things are a bit
22 more complicated. If the address contains a colon, it is assumed to be a v6
23 address (assuming HAVE_IPV6 is set). If a mask is permitted and one is present,
24 and maskptr is not NULL, its offset is placed there.
25
26 Arguments:
27 s a string
28 maskptr NULL if no mask is permitted to follow
29 otherwise, points to an int where the offset of '/' is placed
30 if there is no / followed by trailing digits, *maskptr is set 0
31
32 Returns: 0 if the string is not a textual representation of an IP address
33 4 if it is an IPv4 address
34 6 if it is an IPv6 address
35 */
36
37 int
38 string_is_ip_address(const uschar *s, int *maskptr)
39 {
40 int i;
41 int yield = 4;
42
43 /* If an optional mask is permitted, check for it. If found, pass back the
44 offset. */
45
46 if (maskptr)
47 {
48 const uschar *ss = s + Ustrlen(s);
49 *maskptr = 0;
50 if (s != ss && isdigit(*(--ss)))
51 {
52 while (ss > s && isdigit(ss[-1])) ss--;
53 if (ss > s && *(--ss) == '/') *maskptr = ss - s;
54 }
55 }
56
57 /* A colon anywhere in the string => IPv6 address */
58
59 if (Ustrchr(s, ':') != NULL)
60 {
61 BOOL had_double_colon = FALSE;
62 BOOL v4end = FALSE;
63 int count = 0;
64
65 yield = 6;
66
67 /* An IPv6 address must start with hex digit or double colon. A single
68 colon is invalid. */
69
70 if (*s == ':' && *(++s) != ':') return 0;
71
72 /* Now read up to 8 components consisting of up to 4 hex digits each. There
73 may be one and only one appearance of double colon, which implies any number
74 of binary zero bits. The number of preceding components is held in count. */
75
76 for (count = 0; count < 8; count++)
77 {
78 /* If the end of the string is reached before reading 8 components, the
79 address is valid provided a double colon has been read. This also applies
80 if we hit the / that introduces a mask or the % that introduces the
81 interface specifier (scope id) of a link-local address. */
82
83 if (*s == 0 || *s == '%' || *s == '/') return had_double_colon ? yield : 0;
84
85 /* If a component starts with an additional colon, we have hit a double
86 colon. This is permitted to appear once only, and counts as at least
87 one component. The final component may be of this form. */
88
89 if (*s == ':')
90 {
91 if (had_double_colon) return 0;
92 had_double_colon = TRUE;
93 s++;
94 continue;
95 }
96
97 /* If the remainder of the string contains a dot but no colons, we
98 can expect a trailing IPv4 address. This is valid if either there has
99 been no double-colon and this is the 7th component (with the IPv4 address
100 being the 7th & 8th components), OR if there has been a double-colon
101 and fewer than 6 components. */
102
103 if (Ustrchr(s, ':') == NULL && Ustrchr(s, '.') != NULL)
104 {
105 if ((!had_double_colon && count != 6) ||
106 (had_double_colon && count > 6)) return 0;
107 v4end = TRUE;
108 yield = 6;
109 break;
110 }
111
112 /* Check for at least one and not more than 4 hex digits for this
113 component. */
114
115 if (!isxdigit(*s++)) return 0;
116 if (isxdigit(*s) && isxdigit(*(++s)) && isxdigit(*(++s))) s++;
117
118 /* If the component is terminated by colon and there is more to
119 follow, skip over the colon. If there is no more to follow the address is
120 invalid. */
121
122 if (*s == ':' && *(++s) == 0) return 0;
123 }
124
125 /* If about to handle a trailing IPv4 address, drop through. Otherwise
126 all is well if we are at the end of the string or at the mask or at a percent
127 sign, which introduces the interface specifier (scope id) of a link local
128 address. */
129
130 if (!v4end)
131 return (*s == 0 || *s == '%' ||
132 (*s == '/' && maskptr != NULL && *maskptr != 0))? yield : 0;
133 }
134
135 /* Test for IPv4 address, which may be the tail-end of an IPv6 address. */
136
137 for (i = 0; i < 4; i++)
138 {
139 long n;
140 uschar * end;
141
142 if (i != 0 && *s++ != '.') return 0;
143 n = strtol(CCS s, CSS &end, 10);
144 if (n > 255 || n < 0 || end <= s || end > s+3) return 0;
145 s = end;
146 }
147
148 return !*s || (*s == '/' && maskptr && *maskptr != 0) ? yield : 0;
149 }
150 #endif /* COMPILE_UTILITY */
151
152
153 /*************************************************
154 * Format message size *
155 *************************************************/
156
157 /* Convert a message size in bytes to printing form, rounding
158 according to the magnitude of the number. A value of zero causes
159 a string of spaces to be returned.
160
161 Arguments:
162 size the message size in bytes
163 buffer where to put the answer
164
165 Returns: pointer to the buffer
166 a string of exactly 5 characters is normally returned
167 */
168
169 uschar *
170 string_format_size(int size, uschar *buffer)
171 {
172 if (size == 0) Ustrcpy(buffer, " ");
173 else if (size < 1024) sprintf(CS buffer, "%5d", size);
174 else if (size < 10*1024)
175 sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);
176 else if (size < 1024*1024)
177 sprintf(CS buffer, "%4dK", (size + 512)/1024);
178 else if (size < 10*1024*1024)
179 sprintf(CS buffer, "%4.1fM", (double)size / (1024.0 * 1024.0));
180 else
181 sprintf(CS buffer, "%4dM", (size + 512 * 1024)/(1024*1024));
182 return buffer;
183 }
184
185
186
187 #ifndef COMPILE_UTILITY
188 /*************************************************
189 * Convert a number to base 62 format *
190 *************************************************/
191
192 /* Convert a long integer into an ASCII base 62 string. For Cygwin the value of
193 BASE_62 is actually 36. Always return exactly 6 characters plus zero, in a
194 static area.
195
196 Argument: a long integer
197 Returns: pointer to base 62 string
198 */
199
200 uschar *
201 string_base62(unsigned long int value)
202 {
203 static uschar yield[7];
204 uschar *p = yield + sizeof(yield) - 1;
205 *p = 0;
206 while (p > yield)
207 {
208 *(--p) = base62_chars[value % BASE_62];
209 value /= BASE_62;
210 }
211 return yield;
212 }
213 #endif /* COMPILE_UTILITY */
214
215
216
217 /*************************************************
218 * Interpret escape sequence *
219 *************************************************/
220
221 /* This function is called from several places where escape sequences are to be
222 interpreted in strings.
223
224 Arguments:
225 pp points a pointer to the initiating "\" in the string;
226 the pointer gets updated to point to the final character
227 Returns: the value of the character escape
228 */
229
230 int
231 string_interpret_escape(const uschar **pp)
232 {
233 #ifdef COMPILE_UTILITY
234 const uschar *hex_digits= CUS"0123456789abcdef";
235 #endif
236 int ch;
237 const uschar *p = *pp;
238 ch = *(++p);
239 if (isdigit(ch) && ch != '8' && ch != '9')
240 {
241 ch -= '0';
242 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
243 {
244 ch = ch * 8 + *(++p) - '0';
245 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
246 ch = ch * 8 + *(++p) - '0';
247 }
248 }
249 else switch(ch)
250 {
251 case 'b': ch = '\b'; break;
252 case 'f': ch = '\f'; break;
253 case 'n': ch = '\n'; break;
254 case 'r': ch = '\r'; break;
255 case 't': ch = '\t'; break;
256 case 'v': ch = '\v'; break;
257 case 'x':
258 ch = 0;
259 if (isxdigit(p[1]))
260 {
261 ch = ch * 16 +
262 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
263 if (isxdigit(p[1])) ch = ch * 16 +
264 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
265 }
266 break;
267 }
268 *pp = p;
269 return ch;
270 }
271
272
273
274 #ifndef COMPILE_UTILITY
275 /*************************************************
276 * Ensure string is printable *
277 *************************************************/
278
279 /* This function is called for critical strings. It checks for any
280 non-printing characters, and if any are found, it makes a new copy
281 of the string with suitable escape sequences. It is most often called by the
282 macro string_printing(), which sets allow_tab TRUE.
283
284 Arguments:
285 s the input string
286 allow_tab TRUE to allow tab as a printing character
287
288 Returns: string with non-printers encoded as printing sequences
289 */
290
291 const uschar *
292 string_printing2(const uschar *s, BOOL allow_tab)
293 {
294 int nonprintcount = 0;
295 int length = 0;
296 const uschar *t = s;
297 uschar *ss, *tt;
298
299 while (*t != 0)
300 {
301 int c = *t++;
302 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
303 length++;
304 }
305
306 if (nonprintcount == 0) return s;
307
308 /* Get a new block of store guaranteed big enough to hold the
309 expanded string. */
310
311 ss = store_get(length + nonprintcount * 3 + 1);
312
313 /* Copy everything, escaping non printers. */
314
315 t = s;
316 tt = ss;
317
318 while (*t != 0)
319 {
320 int c = *t;
321 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
322 {
323 *tt++ = '\\';
324 switch (*t)
325 {
326 case '\n': *tt++ = 'n'; break;
327 case '\r': *tt++ = 'r'; break;
328 case '\b': *tt++ = 'b'; break;
329 case '\v': *tt++ = 'v'; break;
330 case '\f': *tt++ = 'f'; break;
331 case '\t': *tt++ = 't'; break;
332 default: sprintf(CS tt, "%03o", *t); tt += 3; break;
333 }
334 t++;
335 }
336 }
337 *tt = 0;
338 return ss;
339 }
340 #endif /* COMPILE_UTILITY */
341
342 /*************************************************
343 * Undo printing escapes in string *
344 *************************************************/
345
346 /* This function is the reverse of string_printing2. It searches for
347 backslash characters and if any are found, it makes a new copy of the
348 string with escape sequences parsed. Otherwise it returns the original
349 string.
350
351 Arguments:
352 s the input string
353
354 Returns: string with printing escapes parsed back
355 */
356
357 uschar *
358 string_unprinting(uschar *s)
359 {
360 uschar *p, *q, *r, *ss;
361 int len, off;
362
363 p = Ustrchr(s, '\\');
364 if (!p) return s;
365
366 len = Ustrlen(s) + 1;
367 ss = store_get(len);
368
369 q = ss;
370 off = p - s;
371 if (off)
372 {
373 memcpy(q, s, off);
374 q += off;
375 }
376
377 while (*p)
378 {
379 if (*p == '\\')
380 {
381 *q++ = string_interpret_escape((const uschar **)&p);
382 p++;
383 }
384 else
385 {
386 r = Ustrchr(p, '\\');
387 if (!r)
388 {
389 off = Ustrlen(p);
390 memcpy(q, p, off);
391 p += off;
392 q += off;
393 break;
394 }
395 else
396 {
397 off = r - p;
398 memcpy(q, p, off);
399 q += off;
400 p = r;
401 }
402 }
403 }
404 *q = '\0';
405
406 return ss;
407 }
408
409
410
411
412 /*************************************************
413 * Copy and save string *
414 *************************************************/
415
416 /* This function assumes that memcpy() is faster than strcpy().
417
418 Argument: string to copy
419 Returns: copy of string in new store
420 */
421
422 uschar *
423 string_copy(const uschar *s)
424 {
425 int len = Ustrlen(s) + 1;
426 uschar *ss = store_get(len);
427 memcpy(ss, s, len);
428 return ss;
429 }
430
431
432
433 /*************************************************
434 * Copy and save string in malloc'd store *
435 *************************************************/
436
437 /* This function assumes that memcpy() is faster than strcpy().
438
439 Argument: string to copy
440 Returns: copy of string in new store
441 */
442
443 uschar *
444 string_copy_malloc(const uschar *s)
445 {
446 int len = Ustrlen(s) + 1;
447 uschar *ss = store_malloc(len);
448 memcpy(ss, s, len);
449 return ss;
450 }
451
452
453
454 /*************************************************
455 * Copy, lowercase and save string *
456 *************************************************/
457
458 /*
459 Argument: string to copy
460 Returns: copy of string in new store, with letters lowercased
461 */
462
463 uschar *
464 string_copylc(const uschar *s)
465 {
466 uschar *ss = store_get(Ustrlen(s) + 1);
467 uschar *p = ss;
468 while (*s != 0) *p++ = tolower(*s++);
469 *p = 0;
470 return ss;
471 }
472
473
474
475 /*************************************************
476 * Copy and save string, given length *
477 *************************************************/
478
479 /* It is assumed the data contains no zeros. A zero is added
480 onto the end.
481
482 Arguments:
483 s string to copy
484 n number of characters
485
486 Returns: copy of string in new store
487 */
488
489 uschar *
490 string_copyn(const uschar *s, int n)
491 {
492 uschar *ss = store_get(n + 1);
493 Ustrncpy(ss, s, n);
494 ss[n] = 0;
495 return ss;
496 }
497
498
499 /*************************************************
500 * Copy, lowercase, and save string, given length *
501 *************************************************/
502
503 /* It is assumed the data contains no zeros. A zero is added
504 onto the end.
505
506 Arguments:
507 s string to copy
508 n number of characters
509
510 Returns: copy of string in new store, with letters lowercased
511 */
512
513 uschar *
514 string_copynlc(uschar *s, int n)
515 {
516 uschar *ss = store_get(n + 1);
517 uschar *p = ss;
518 while (n-- > 0) *p++ = tolower(*s++);
519 *p = 0;
520 return ss;
521 }
522
523
524
525 /*************************************************
526 * Copy string if long, inserting newlines *
527 *************************************************/
528
529 /* If the given string is longer than 75 characters, it is copied, and within
530 the copy, certain space characters are converted into newlines.
531
532 Argument: pointer to the string
533 Returns: pointer to the possibly altered string
534 */
535
536 uschar *
537 string_split_message(uschar *msg)
538 {
539 uschar *s, *ss;
540
541 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
542 s = ss = msg = string_copy(msg);
543
544 for (;;)
545 {
546 int i = 0;
547 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
548 if (*ss == 0) break;
549 if (*ss == '\n')
550 s = ++ss;
551 else
552 {
553 uschar *t = ss + 1;
554 uschar *tt = NULL;
555 while (--t > s + 35)
556 {
557 if (*t == ' ')
558 {
559 if (t[-1] == ':') { tt = t; break; }
560 if (tt == NULL) tt = t;
561 }
562 }
563
564 if (tt == NULL) /* Can't split behind - try ahead */
565 {
566 t = ss + 1;
567 while (*t != 0)
568 {
569 if (*t == ' ' || *t == '\n')
570 { tt = t; break; }
571 t++;
572 }
573 }
574
575 if (tt == NULL) break; /* Can't find anywhere to split */
576 *tt = '\n';
577 s = ss = tt+1;
578 }
579 }
580
581 return msg;
582 }
583
584
585
586 /*************************************************
587 * Copy returned DNS domain name, de-escaping *
588 *************************************************/
589
590 /* If a domain name contains top-bit characters, some resolvers return
591 the fully qualified name with those characters turned into escapes. The
592 convention is a backslash followed by _decimal_ digits. We convert these
593 back into the original binary values. This will be relevant when
594 allow_utf8_domains is set true and UTF-8 characters are used in domain
595 names. Backslash can also be used to escape other characters, though we
596 shouldn't come across them in domain names.
597
598 Argument: the domain name string
599 Returns: copy of string in new store, de-escaped
600 */
601
602 uschar *
603 string_copy_dnsdomain(uschar *s)
604 {
605 uschar *yield;
606 uschar *ss = yield = store_get(Ustrlen(s) + 1);
607
608 while (*s != 0)
609 {
610 if (*s != '\\')
611 {
612 *ss++ = *s++;
613 }
614 else if (isdigit(s[1]))
615 {
616 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
617 s += 4;
618 }
619 else if (*(++s) != 0)
620 {
621 *ss++ = *s++;
622 }
623 }
624
625 *ss = 0;
626 return yield;
627 }
628
629
630 #ifndef COMPILE_UTILITY
631 /*************************************************
632 * Copy space-terminated or quoted string *
633 *************************************************/
634
635 /* This function copies from a string until its end, or until whitespace is
636 encountered, unless the string begins with a double quote, in which case the
637 terminating quote is sought, and escaping within the string is done. The length
638 of a de-quoted string can be no longer than the original, since escaping always
639 turns n characters into 1 character.
640
641 Argument: pointer to the pointer to the first character, which gets updated
642 Returns: the new string
643 */
644
645 uschar *
646 string_dequote(const uschar **sptr)
647 {
648 const uschar *s = *sptr;
649 uschar *t, *yield;
650
651 /* First find the end of the string */
652
653 if (*s != '\"')
654 {
655 while (*s != 0 && !isspace(*s)) s++;
656 }
657 else
658 {
659 s++;
660 while (*s != 0 && *s != '\"')
661 {
662 if (*s == '\\') (void)string_interpret_escape(&s);
663 s++;
664 }
665 if (*s != 0) s++;
666 }
667
668 /* Get enough store to copy into */
669
670 t = yield = store_get(s - *sptr + 1);
671 s = *sptr;
672
673 /* Do the copy */
674
675 if (*s != '\"')
676 {
677 while (*s != 0 && !isspace(*s)) *t++ = *s++;
678 }
679 else
680 {
681 s++;
682 while (*s != 0 && *s != '\"')
683 {
684 if (*s == '\\') *t++ = string_interpret_escape(&s);
685 else *t++ = *s;
686 s++;
687 }
688 if (*s != 0) s++;
689 }
690
691 /* Update the pointer and return the terminated copy */
692
693 *sptr = s;
694 *t = 0;
695 return yield;
696 }
697 #endif /* COMPILE_UTILITY */
698
699
700
701 /*************************************************
702 * Format a string and save it *
703 *************************************************/
704
705 /* The formatting is done by string_vformat, which checks the length of
706 everything.
707
708 Arguments:
709 format a printf() format - deliberately char * rather than uschar *
710 because it will most usually be a literal string
711 ... arguments for format
712
713 Returns: pointer to fresh piece of store containing sprintf'ed string
714 */
715
716 uschar *
717 string_sprintf(const char *format, ...)
718 {
719 #ifdef COMPILE_UTILITY
720 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
721 gstring g = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
722 gstring * gp = &g;
723 #else
724 gstring * gp = string_get(STRING_SPRINTF_BUFFER_SIZE);
725 #endif
726 gstring * gp2;
727 va_list ap;
728
729 va_start(ap, format);
730 gp2 = string_vformat(gp, FALSE, format, ap);
731 gp->s[gp->ptr] = '\0';
732 va_end(ap);
733
734 if (!gp2)
735 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
736 "string_sprintf expansion was longer than %d; format string was (%s)\n"
737 "expansion started '%.32s'",
738 gp->size, format, gp->s);
739
740 #ifdef COMPILE_UTILITY
741 return string_copy(gp->s);
742 #else
743 gstring_reset_unused(gp);
744 return gp->s;
745 #endif
746 }
747
748
749
750 /*************************************************
751 * Case-independent strncmp() function *
752 *************************************************/
753
754 /*
755 Arguments:
756 s first string
757 t second string
758 n number of characters to compare
759
760 Returns: < 0, = 0, or > 0, according to the comparison
761 */
762
763 int
764 strncmpic(const uschar *s, const uschar *t, int n)
765 {
766 while (n--)
767 {
768 int c = tolower(*s++) - tolower(*t++);
769 if (c) return c;
770 }
771 return 0;
772 }
773
774
775 /*************************************************
776 * Case-independent strcmp() function *
777 *************************************************/
778
779 /*
780 Arguments:
781 s first string
782 t second string
783
784 Returns: < 0, = 0, or > 0, according to the comparison
785 */
786
787 int
788 strcmpic(const uschar *s, const uschar *t)
789 {
790 while (*s != 0)
791 {
792 int c = tolower(*s++) - tolower(*t++);
793 if (c != 0) return c;
794 }
795 return *t;
796 }
797
798
799 /*************************************************
800 * Case-independent strstr() function *
801 *************************************************/
802
803 /* The third argument specifies whether whitespace is required
804 to follow the matched string.
805
806 Arguments:
807 s string to search
808 t substring to search for
809 space_follows if TRUE, match only if whitespace follows
810
811 Returns: pointer to substring in string, or NULL if not found
812 */
813
814 uschar *
815 strstric(uschar *s, uschar *t, BOOL space_follows)
816 {
817 uschar *p = t;
818 uschar *yield = NULL;
819 int cl = tolower(*p);
820 int cu = toupper(*p);
821
822 while (*s)
823 {
824 if (*s == cl || *s == cu)
825 {
826 if (yield == NULL) yield = s;
827 if (*(++p) == 0)
828 {
829 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
830 yield = NULL;
831 p = t;
832 }
833 cl = tolower(*p);
834 cu = toupper(*p);
835 s++;
836 }
837 else if (yield != NULL)
838 {
839 yield = NULL;
840 p = t;
841 cl = tolower(*p);
842 cu = toupper(*p);
843 }
844 else s++;
845 }
846 return NULL;
847 }
848
849
850
851 #ifdef COMPILE_UTILITY
852 /* Dummy version for this function; it should never be called */
853 static void
854 gstring_grow(gstring * g, int p, int count)
855 {
856 assert(FALSE);
857 }
858 #endif
859
860
861
862 #ifndef COMPILE_UTILITY
863 /*************************************************
864 * Get next string from separated list *
865 *************************************************/
866
867 /* Leading and trailing space is removed from each item. The separator in the
868 list is controlled by the int pointed to by the separator argument as follows:
869
870 If the value is > 0 it is used as the separator. This is typically used for
871 sublists such as slash-separated options. The value is always a printing
872 character.
873
874 (If the value is actually > UCHAR_MAX there is only one item in the list.
875 This is used for some cases when called via functions that sometimes
876 plough through lists, and sometimes are given single items.)
877
878 If the value is <= 0, the string is inspected for a leading <x, where x is an
879 ispunct() or an iscntrl() character. If found, x is used as the separator. If
880 not found:
881
882 (a) if separator == 0, ':' is used
883 (b) if separator <0, -separator is used
884
885 In all cases the value of the separator that is used is written back to the
886 int so that it is used on subsequent calls as we progress through the list.
887
888 A literal ispunct() separator can be represented in an item by doubling, but
889 there is no way to include an iscntrl() separator as part of the data.
890
891 Arguments:
892 listptr points to a pointer to the current start of the list; the
893 pointer gets updated to point after the end of the next item
894 separator a pointer to the separator character in an int (see above)
895 buffer where to put a copy of the next string in the list; or
896 NULL if the next string is returned in new memory
897 buflen when buffer is not NULL, the size of buffer; otherwise ignored
898
899 Returns: pointer to buffer, containing the next substring,
900 or NULL if no more substrings
901 */
902
903 uschar *
904 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
905 {
906 int sep = *separator;
907 const uschar *s = *listptr;
908 BOOL sep_is_special;
909
910 if (s == NULL) return NULL;
911
912 /* This allows for a fixed specified separator to be an iscntrl() character,
913 but at the time of implementation, this is never the case. However, it's best
914 to be conservative. */
915
916 while (isspace(*s) && *s != sep) s++;
917
918 /* A change of separator is permitted, so look for a leading '<' followed by an
919 allowed character. */
920
921 if (sep <= 0)
922 {
923 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
924 {
925 sep = s[1];
926 s += 2;
927 while (isspace(*s) && *s != sep) s++;
928 }
929 else
930 {
931 sep = (sep == 0)? ':' : -sep;
932 }
933 *separator = sep;
934 }
935
936 /* An empty string has no list elements */
937
938 if (*s == 0) return NULL;
939
940 /* Note whether whether or not the separator is an iscntrl() character. */
941
942 sep_is_special = iscntrl(sep);
943
944 /* Handle the case when a buffer is provided. */
945
946 if (buffer)
947 {
948 int p = 0;
949 for (; *s != 0; s++)
950 {
951 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
952 if (p < buflen - 1) buffer[p++] = *s;
953 }
954 while (p > 0 && isspace(buffer[p-1])) p--;
955 buffer[p] = 0;
956 }
957
958 /* Handle the case when a buffer is not provided. */
959
960 else
961 {
962 const uschar *ss;
963 gstring * g = NULL;
964
965 /* We know that *s != 0 at this point. However, it might be pointing to a
966 separator, which could indicate an empty string, or (if an ispunct()
967 character) could be doubled to indicate a separator character as data at the
968 start of a string. Avoid getting working memory for an empty item. */
969
970 if (*s == sep)
971 {
972 s++;
973 if (*s != sep || sep_is_special)
974 {
975 *listptr = s;
976 return string_copy(US"");
977 }
978 }
979
980 /* Not an empty string; the first character is guaranteed to be a data
981 character. */
982
983 for (;;)
984 {
985 for (ss = s + 1; *ss != 0 && *ss != sep; ss++) ;
986 g = string_catn(g, s, ss-s);
987 s = ss;
988 if (*s == 0 || *(++s) != sep || sep_is_special) break;
989 }
990 while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
991 buffer = string_from_gstring(g);
992 gstring_reset_unused(g);
993 }
994
995 /* Update the current pointer and return the new string */
996
997 *listptr = s;
998 return buffer;
999 }
1000
1001
1002 static const uschar *
1003 Ustrnchr(const uschar * s, int c, unsigned * len)
1004 {
1005 unsigned siz = *len;
1006 while (siz)
1007 {
1008 if (!*s) return NULL;
1009 if (*s == c)
1010 {
1011 *len = siz;
1012 return s;
1013 }
1014 s++;
1015 siz--;
1016 }
1017 return NULL;
1018 }
1019
1020
1021 /************************************************
1022 * Add element to separated list *
1023 ************************************************/
1024 /* This function is used to build a list, returning an allocated null-terminated
1025 growable string. The given element has any embedded separator characters
1026 doubled.
1027
1028 Despite having the same growable-string interface as string_cat() the list is
1029 always returned null-terminated.
1030
1031 Arguments:
1032 list expanding-string for the list that is being built, or NULL
1033 if this is a new list that has no contents yet
1034 sep list separator character
1035 ele new element to be appended to the list
1036
1037 Returns: pointer to the start of the list, changed if copied for expansion.
1038 */
1039
1040 gstring *
1041 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1042 {
1043 uschar * sp;
1044
1045 if (list && list->ptr)
1046 list = string_catn(list, &sep, 1);
1047
1048 while((sp = Ustrchr(ele, sep)))
1049 {
1050 list = string_catn(list, ele, sp-ele+1);
1051 list = string_catn(list, &sep, 1);
1052 ele = sp+1;
1053 }
1054 list = string_cat(list, ele);
1055 (void) string_from_gstring(list);
1056 return list;
1057 }
1058
1059
1060 gstring *
1061 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1062 unsigned len)
1063 {
1064 const uschar * sp;
1065
1066 if (list && list->ptr)
1067 list = string_catn(list, &sep, 1);
1068
1069 while((sp = Ustrnchr(ele, sep, &len)))
1070 {
1071 list = string_catn(list, ele, sp-ele+1);
1072 list = string_catn(list, &sep, 1);
1073 ele = sp+1;
1074 len--;
1075 }
1076 list = string_catn(list, ele, len);
1077 (void) string_from_gstring(list);
1078 return list;
1079 }
1080
1081
1082
1083 /* A slightly-bogus listmaker utility; the separator is a string so
1084 can be multiple chars - there is no checking for the element content
1085 containing any of the separator. */
1086
1087 gstring *
1088 string_append2_listele_n(gstring * list, const uschar * sepstr,
1089 const uschar * ele, unsigned len)
1090 {
1091 if (list && list->ptr)
1092 list = string_cat(list, sepstr);
1093
1094 list = string_catn(list, ele, len);
1095 (void) string_from_gstring(list);
1096 return list;
1097 }
1098
1099
1100
1101 /************************************************/
1102 /* Create a growable-string with some preassigned space */
1103
1104 gstring *
1105 string_get(unsigned size)
1106 {
1107 gstring * g = store_get(sizeof(gstring) + size);
1108 g->size = size;
1109 g->ptr = 0;
1110 g->s = US(g + 1);
1111 return g;
1112 }
1113
1114 /* NUL-terminate the C string in the growable-string, and return it. */
1115
1116 uschar *
1117 string_from_gstring(gstring * g)
1118 {
1119 if (!g) return NULL;
1120 g->s[g->ptr] = '\0';
1121 return g->s;
1122 }
1123
1124 void
1125 gstring_reset_unused(gstring * g)
1126 {
1127 store_reset(g->s + (g->size = g->ptr + 1));
1128 }
1129
1130
1131 /* Add more space to a growable-string.
1132
1133 Arguments:
1134 g the growable-string
1135 p current end of data
1136 count amount to grow by
1137 */
1138
1139 static void
1140 gstring_grow(gstring * g, int p, int count)
1141 {
1142 int oldsize = g->size;
1143
1144 /* Mostly, string_cat() is used to build small strings of a few hundred
1145 characters at most. There are times, however, when the strings are very much
1146 longer (for example, a lookup that returns a vast number of alias addresses).
1147 To try to keep things reasonable, we use increments whose size depends on the
1148 existing length of the string. */
1149
1150 unsigned inc = oldsize < 4096 ? 127 : 1023;
1151 g->size = ((p + count + inc) & ~inc) + 1;
1152
1153 /* Try to extend an existing allocation. If the result of calling
1154 store_extend() is false, either there isn't room in the current memory block,
1155 or this string is not the top item on the dynamic store stack. We then have
1156 to get a new chunk of store and copy the old string. When building large
1157 strings, it is helpful to call store_release() on the old string, to release
1158 memory blocks that have become empty. (The block will be freed if the string
1159 is at its start.) However, we can do this only if we know that the old string
1160 was the last item on the dynamic memory stack. This is the case if it matches
1161 store_last_get. */
1162
1163 if (!store_extend(g->s, oldsize, g->size))
1164 g->s = store_newblock(g->s, g->size, p);
1165 }
1166
1167
1168
1169 /*************************************************
1170 * Add chars to string *
1171 *************************************************/
1172 /* This function is used when building up strings of unknown length. Room is
1173 always left for a terminating zero to be added to the string that is being
1174 built. This function does not require the string that is being added to be NUL
1175 terminated, because the number of characters to add is given explicitly. It is
1176 sometimes called to extract parts of other strings.
1177
1178 Arguments:
1179 string points to the start of the string that is being built, or NULL
1180 if this is a new string that has no contents yet
1181 s points to characters to add
1182 count count of characters to add; must not exceed the length of s, if s
1183 is a C string.
1184
1185 Returns: pointer to the start of the string, changed if copied for expansion.
1186 Note that a NUL is not added, though space is left for one. This is
1187 because string_cat() is often called multiple times to build up a
1188 string - there's no point adding the NUL till the end.
1189
1190 */
1191 /* coverity[+alloc] */
1192
1193 gstring *
1194 string_catn(gstring * g, const uschar *s, int count)
1195 {
1196 int p;
1197
1198 if (!g)
1199 {
1200 unsigned inc = count < 4096 ? 127 : 1023;
1201 unsigned size = ((count + inc) & ~inc) + 1;
1202 g = string_get(size);
1203 }
1204
1205 p = g->ptr;
1206 if (p + count >= g->size)
1207 gstring_grow(g, p, count);
1208
1209 /* Because we always specify the exact number of characters to copy, we can
1210 use memcpy(), which is likely to be more efficient than strncopy() because the
1211 latter has to check for zero bytes. */
1212
1213 memcpy(g->s + p, s, count);
1214 g->ptr = p + count;
1215 return g;
1216 }
1217
1218
1219 gstring *
1220 string_cat(gstring *string, const uschar *s)
1221 {
1222 return string_catn(string, s, Ustrlen(s));
1223 }
1224
1225
1226
1227 /*************************************************
1228 * Append strings to another string *
1229 *************************************************/
1230
1231 /* This function can be used to build a string from many other strings.
1232 It calls string_cat() to do the dirty work.
1233
1234 Arguments:
1235 string expanding-string that is being built, or NULL
1236 if this is a new string that has no contents yet
1237 count the number of strings to append
1238 ... "count" uschar* arguments, which must be valid zero-terminated
1239 C strings
1240
1241 Returns: pointer to the start of the string, changed if copied for expansion.
1242 The string is not zero-terminated - see string_cat() above.
1243 */
1244
1245 __inline__ gstring *
1246 string_append(gstring *string, int count, ...)
1247 {
1248 va_list ap;
1249
1250 va_start(ap, count);
1251 while (count-- > 0)
1252 {
1253 uschar *t = va_arg(ap, uschar *);
1254 string = string_cat(string, t);
1255 }
1256 va_end(ap);
1257
1258 return string;
1259 }
1260 #endif
1261
1262
1263
1264 /*************************************************
1265 * Format a string with length checks *
1266 *************************************************/
1267
1268 /* This function is used to format a string with checking of the length of the
1269 output for all conversions. It protects Exim from absent-mindedness when
1270 calling functions like debug_printf and string_sprintf, and elsewhere. There
1271 are two different entry points to what is actually the same function, depending
1272 on whether the variable length list of data arguments are given explicitly or
1273 as a va_list item.
1274
1275 The formats are the usual printf() ones, with some omissions (never used) and
1276 three additions for strings: %S forces lower case, %T forces upper case, and
1277 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1278 (useful in debugging). There is also the addition of %D and %M, which insert
1279 the date in the form used for datestamped log files.
1280
1281 Arguments:
1282 buffer a buffer in which to put the formatted string
1283 buflen the length of the buffer
1284 format the format string - deliberately char * and not uschar *
1285 ... or ap variable list of supplementary arguments
1286
1287 Returns: TRUE if the result fitted in the buffer
1288 */
1289
1290 BOOL
1291 string_format(uschar * buffer, int buflen, const char * format, ...)
1292 {
1293 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1294 va_list ap;
1295 va_start(ap, format);
1296 gp = string_vformat(&g, FALSE, format, ap);
1297 va_end(ap);
1298 g.s[g.ptr] = '\0';
1299 return !!gp;
1300 }
1301
1302
1303
1304
1305
1306 /* Bulid or append to a growing-string, sprintf-style.
1307
1308 If the "extend" argument is true, the string passed in can be NULL,
1309 empty, or non-empty.
1310
1311 If the "extend" argument is false, the string passed in may not be NULL,
1312 will not be grown, and is usable in the original place after return.
1313 The return value can be NULL to signify overflow.
1314
1315 Returns the possibly-new (if copy for growth was needed) string,
1316 not nul-terminated.
1317 */
1318
1319 gstring *
1320 string_vformat(gstring * g, BOOL extend, const char *format, va_list ap)
1321 {
1322 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1323
1324 int width, precision, off, lim;
1325 const char * fp = format; /* Deliberately not unsigned */
1326
1327 string_datestamp_offset = -1; /* Datestamp not inserted */
1328 string_datestamp_length = 0; /* Datestamp not inserted */
1329 string_datestamp_type = 0; /* Datestamp not inserted */
1330
1331 #ifdef COMPILE_UTILITY
1332 assert(!extend);
1333 assert(g);
1334 #else
1335
1336 /* Ensure we have a string, to save on checking later */
1337 if (!g) g = string_get(16);
1338 #endif /*!COMPILE_UTILITY*/
1339
1340 lim = g->size - 1; /* leave one for a nul */
1341 off = g->ptr; /* remember initial offset in gstring */
1342
1343 /* Scan the format and handle the insertions */
1344
1345 while (*fp)
1346 {
1347 int length = L_NORMAL;
1348 int *nptr;
1349 int slen;
1350 const char *null = "NULL"; /* ) These variables */
1351 const char *item_start, *s; /* ) are deliberately */
1352 char newformat[16]; /* ) not unsigned */
1353 char * gp = CS g->s + g->ptr; /* ) */
1354
1355 /* Non-% characters just get copied verbatim */
1356
1357 if (*fp != '%')
1358 {
1359 /* Avoid string_copyn() due to COMPILE_UTILITY */
1360 if (g->ptr >= lim - 1)
1361 {
1362 if (!extend) return NULL;
1363 gstring_grow(g, g->ptr, 1);
1364 lim = g->size - 1;
1365 }
1366 g->s[g->ptr++] = (uschar) *fp++;
1367 continue;
1368 }
1369
1370 /* Deal with % characters. Pick off the width and precision, for checking
1371 strings, skipping over the flag and modifier characters. */
1372
1373 item_start = fp;
1374 width = precision = -1;
1375
1376 if (strchr("-+ #0", *(++fp)) != NULL)
1377 {
1378 if (*fp == '#') null = "";
1379 fp++;
1380 }
1381
1382 if (isdigit((uschar)*fp))
1383 {
1384 width = *fp++ - '0';
1385 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1386 }
1387 else if (*fp == '*')
1388 {
1389 width = va_arg(ap, int);
1390 fp++;
1391 }
1392
1393 if (*fp == '.')
1394 if (*(++fp) == '*')
1395 {
1396 precision = va_arg(ap, int);
1397 fp++;
1398 }
1399 else
1400 for (precision = 0; isdigit((uschar)*fp); fp++)
1401 precision = precision*10 + *fp - '0';
1402
1403 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1404
1405 if (*fp == 'h')
1406 { fp++; length = L_SHORT; }
1407 else if (*fp == 'L')
1408 { fp++; length = L_LONGDOUBLE; }
1409 else if (*fp == 'l')
1410 if (fp[1] == 'l')
1411 { fp += 2; length = L_LONGLONG; }
1412 else
1413 { fp++; length = L_LONG; }
1414 else if (*fp == 'z')
1415 { fp++; length = L_SIZE; }
1416
1417 /* Handle each specific format type. */
1418
1419 switch (*fp++)
1420 {
1421 case 'n':
1422 nptr = va_arg(ap, int *);
1423 *nptr = g->ptr - off;
1424 break;
1425
1426 case 'd':
1427 case 'o':
1428 case 'u':
1429 case 'x':
1430 case 'X':
1431 width = length > L_LONG ? 24 : 12;
1432 if (g->ptr >= lim - width)
1433 {
1434 if (!extend) return NULL;
1435 gstring_grow(g, g->ptr, width);
1436 lim = g->size - 1;
1437 gp = CS g->s + g->ptr;
1438 }
1439 strncpy(newformat, item_start, fp - item_start);
1440 newformat[fp - item_start] = 0;
1441
1442 /* Short int is promoted to int when passing through ..., so we must use
1443 int for va_arg(). */
1444
1445 switch(length)
1446 {
1447 case L_SHORT:
1448 case L_NORMAL:
1449 g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1450 case L_LONG:
1451 g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1452 case L_LONGLONG:
1453 g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1454 case L_SIZE:
1455 g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1456 }
1457 break;
1458
1459 case 'p':
1460 {
1461 void * ptr;
1462 if (g->ptr >= lim - 24)
1463 {
1464 if (!extend) return NULL;
1465 gstring_grow(g, g->ptr, 24);
1466 lim = g->size - 1;
1467 gp = CS g->s + g->ptr;
1468 }
1469 /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1470 Handle it explicitly. */
1471 if ((ptr = va_arg(ap, void *)))
1472 {
1473 strncpy(newformat, item_start, fp - item_start);
1474 newformat[fp - item_start] = 0;
1475 g->ptr += sprintf(gp, newformat, ptr);
1476 }
1477 else
1478 g->ptr += sprintf(gp, "(nil)");
1479 }
1480 break;
1481
1482 /* %f format is inherently insecure if the numbers that it may be
1483 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1484 printing load averages, and these are actually stored as integers
1485 (load average * 1000) so the size of the numbers is constrained.
1486 It is also used for formatting sending rates, where the simplicity
1487 of the format prevents overflow. */
1488
1489 case 'f':
1490 case 'e':
1491 case 'E':
1492 case 'g':
1493 case 'G':
1494 if (precision < 0) precision = 6;
1495 if (g->ptr >= lim - precision - 8)
1496 {
1497 if (!extend) return NULL;
1498 gstring_grow(g, g->ptr, precision+8);
1499 lim = g->size - 1;
1500 gp = CS g->s + g->ptr;
1501 }
1502 strncpy(newformat, item_start, fp - item_start);
1503 newformat[fp-item_start] = 0;
1504 if (length == L_LONGDOUBLE)
1505 g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1506 else
1507 g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1508 break;
1509
1510 /* String types */
1511
1512 case '%':
1513 if (g->ptr >= lim - 1)
1514 {
1515 if (!extend) return NULL;
1516 gstring_grow(g, g->ptr, 1);
1517 lim = g->size - 1;
1518 }
1519 g->s[g->ptr++] = (uschar) '%';
1520 break;
1521
1522 case 'c':
1523 if (g->ptr >= lim - 1)
1524 {
1525 if (!extend) return NULL;
1526 gstring_grow(g, g->ptr, 1);
1527 lim = g->size - 1;
1528 }
1529 g->s[g->ptr++] = (uschar) va_arg(ap, int);
1530 break;
1531
1532 case 'D': /* Insert daily datestamp for log file names */
1533 s = CS tod_stamp(tod_log_datestamp_daily);
1534 string_datestamp_offset = g->ptr; /* Passed back via global */
1535 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1536 string_datestamp_type = tod_log_datestamp_daily;
1537 slen = string_datestamp_length;
1538 goto INSERT_STRING;
1539
1540 case 'M': /* Insert monthly datestamp for log file names */
1541 s = CS tod_stamp(tod_log_datestamp_monthly);
1542 string_datestamp_offset = g->ptr; /* Passed back via global */
1543 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1544 string_datestamp_type = tod_log_datestamp_monthly;
1545 slen = string_datestamp_length;
1546 goto INSERT_STRING;
1547
1548 case 's':
1549 case 'S': /* Forces *lower* case */
1550 case 'T': /* Forces *upper* case */
1551 s = va_arg(ap, char *);
1552
1553 if (!s) s = null;
1554 slen = Ustrlen(s);
1555
1556 INSERT_STRING: /* Come to from %D or %M above */
1557
1558 {
1559 BOOL truncated = FALSE;
1560
1561 /* If the width is specified, check that there is a precision
1562 set; if not, set it to the width to prevent overruns of long
1563 strings. */
1564
1565 if (width >= 0)
1566 {
1567 if (precision < 0) precision = width;
1568 }
1569
1570 /* If a width is not specified and the precision is specified, set
1571 the width to the precision, or the string length if shorted. */
1572
1573 else if (precision >= 0)
1574 width = precision < slen ? precision : slen;
1575
1576 /* If neither are specified, set them both to the string length. */
1577
1578 else
1579 width = precision = slen;
1580
1581 if (!extend)
1582 {
1583 if (g->ptr == lim) return NULL;
1584 if (g->ptr >= lim - width)
1585 {
1586 truncated = TRUE;
1587 width = precision = lim - g->ptr - 1;
1588 if (width < 0) width = 0;
1589 if (precision < 0) precision = 0;
1590 }
1591 }
1592 else if (g->ptr >= lim - width)
1593 {
1594 gstring_grow(g, g->ptr, width - (lim - g->ptr));
1595 lim = g->size - 1;
1596 gp = CS g->s + g->ptr;
1597 }
1598
1599 g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1600 if (fp[-1] == 'S')
1601 while (*gp) { *gp = tolower(*gp); gp++; }
1602 else if (fp[-1] == 'T')
1603 while (*gp) { *gp = toupper(*gp); gp++; }
1604
1605 if (truncated) return NULL;
1606 break;
1607 }
1608
1609 /* Some things are never used in Exim; also catches junk. */
1610
1611 default:
1612 strncpy(newformat, item_start, fp - item_start);
1613 newformat[fp-item_start] = 0;
1614 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1615 "in \"%s\" in \"%s\"", newformat, format);
1616 break;
1617 }
1618 }
1619
1620 return g;
1621 }
1622
1623
1624
1625 #ifndef COMPILE_UTILITY
1626
1627 gstring *
1628 string_fmt_append(gstring * g, const char *format, ...)
1629 {
1630 va_list ap;
1631 va_start(ap, format);
1632 g = string_vformat(g, TRUE, format, ap);
1633 va_end(ap);
1634 return g;
1635 }
1636
1637
1638
1639 /*************************************************
1640 * Generate an "open failed" message *
1641 *************************************************/
1642
1643 /* This function creates a message after failure to open a file. It includes a
1644 string supplied as data, adds the strerror() text, and if the failure was
1645 "Permission denied", reads and includes the euid and egid.
1646
1647 Arguments:
1648 eno the value of errno after the failure
1649 format a text format string - deliberately not uschar *
1650 ... arguments for the format string
1651
1652 Returns: a message, in dynamic store
1653 */
1654
1655 uschar *
1656 string_open_failed(int eno, const char *format, ...)
1657 {
1658 va_list ap;
1659 gstring * g = string_get(1024);
1660
1661 g = string_catn(g, US"failed to open ", 15);
1662
1663 /* Use the checked formatting routine to ensure that the buffer
1664 does not overflow. It should not, since this is called only for internally
1665 specified messages. If it does, the message just gets truncated, and there
1666 doesn't seem much we can do about that. */
1667
1668 va_start(ap, format);
1669 (void) string_vformat(g, FALSE, format, ap);
1670 string_from_gstring(g);
1671 gstring_reset_unused(g);
1672 va_end(ap);
1673
1674 return eno == EACCES
1675 ? string_sprintf("%s: %s (euid=%ld egid=%ld)", g->s, strerror(eno),
1676 (long int)geteuid(), (long int)getegid())
1677 : string_sprintf("%s: %s", g->s, strerror(eno));
1678 }
1679 #endif /* COMPILE_UTILITY */
1680
1681
1682
1683
1684
1685 #ifndef COMPILE_UTILITY
1686 /* qsort(3), currently used to sort the environment variables
1687 for -bP environment output, needs a function to compare two pointers to string
1688 pointers. Here it is. */
1689
1690 int
1691 string_compare_by_pointer(const void *a, const void *b)
1692 {
1693 return Ustrcmp(* CUSS a, * CUSS b);
1694 }
1695 #endif /* COMPILE_UTILITY */
1696
1697
1698
1699
1700 /*************************************************
1701 **************************************************
1702 * Stand-alone test program *
1703 **************************************************
1704 *************************************************/
1705
1706 #ifdef STAND_ALONE
1707 int main(void)
1708 {
1709 uschar buffer[256];
1710
1711 printf("Testing is_ip_address\n");
1712
1713 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1714 {
1715 int offset;
1716 buffer[Ustrlen(buffer) - 1] = 0;
1717 printf("%d\n", string_is_ip_address(buffer, NULL));
1718 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1719 }
1720
1721 printf("Testing string_nextinlist\n");
1722
1723 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1724 {
1725 uschar *list = buffer;
1726 uschar *lp1, *lp2;
1727 uschar item[256];
1728 int sep1 = 0;
1729 int sep2 = 0;
1730
1731 if (*list == '<')
1732 {
1733 sep1 = sep2 = list[1];
1734 list += 2;
1735 }
1736
1737 lp1 = lp2 = list;
1738 for (;;)
1739 {
1740 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1741 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1742
1743 if (item1 == NULL && item2 == NULL) break;
1744 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1745 {
1746 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1747 (item1 == NULL)? "NULL" : CS item1,
1748 (item2 == NULL)? "NULL" : CS item2);
1749 break;
1750 }
1751 else printf(" \"%s\"\n", CS item1);
1752 }
1753 }
1754
1755 /* This is a horrible lash-up, but it serves its purpose. */
1756
1757 printf("Testing string_format\n");
1758
1759 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1760 {
1761 void *args[3];
1762 long long llargs[3];
1763 double dargs[3];
1764 int dflag = 0;
1765 int llflag = 0;
1766 int n = 0;
1767 int count;
1768 int countset = 0;
1769 uschar format[256];
1770 uschar outbuf[256];
1771 uschar *s;
1772 buffer[Ustrlen(buffer) - 1] = 0;
1773
1774 s = Ustrchr(buffer, ',');
1775 if (s == NULL) s = buffer + Ustrlen(buffer);
1776
1777 Ustrncpy(format, buffer, s - buffer);
1778 format[s-buffer] = 0;
1779
1780 if (*s == ',') s++;
1781
1782 while (*s != 0)
1783 {
1784 uschar *ss = s;
1785 s = Ustrchr(ss, ',');
1786 if (s == NULL) s = ss + Ustrlen(ss);
1787
1788 if (isdigit(*ss))
1789 {
1790 Ustrncpy(outbuf, ss, s-ss);
1791 if (Ustrchr(outbuf, '.') != NULL)
1792 {
1793 dflag = 1;
1794 dargs[n++] = Ustrtod(outbuf, NULL);
1795 }
1796 else if (Ustrstr(outbuf, "ll") != NULL)
1797 {
1798 llflag = 1;
1799 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1800 }
1801 else
1802 {
1803 args[n++] = (void *)Uatoi(outbuf);
1804 }
1805 }
1806
1807 else if (Ustrcmp(ss, "*") == 0)
1808 {
1809 args[n++] = (void *)(&count);
1810 countset = 1;
1811 }
1812
1813 else
1814 {
1815 uschar *sss = malloc(s - ss + 1);
1816 Ustrncpy(sss, ss, s-ss);
1817 args[n++] = sss;
1818 }
1819
1820 if (*s == ',') s++;
1821 }
1822
1823 if (!dflag && !llflag)
1824 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1825 args[0], args[1], args[2])? "True" : "False");
1826
1827 else if (dflag)
1828 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1829 dargs[0], dargs[1], dargs[2])? "True" : "False");
1830
1831 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1832 llargs[0], llargs[1], llargs[2])? "True" : "False");
1833
1834 printf("%s\n", CS outbuf);
1835 if (countset) printf("count=%d\n", count);
1836 }
1837
1838 return 0;
1839 }
1840 #endif
1841
1842 /* End of string.c */