2441f9b17a4c66df5783b166bf96f814556845c4
[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   while (*s != 0 && !isspace(*s)) s++;
655 else
656   {
657   s++;
658   while (*s && *s != '\"')
659     {
660     if (*s == '\\') (void)string_interpret_escape(&s);
661     s++;
662     }
663   if (*s) s++;
664   }
665
666 /* Get enough store to copy into */
667
668 t = yield = store_get(s - *sptr + 1);
669 s = *sptr;
670
671 /* Do the copy */
672
673 if (*s != '\"')
674   {
675   while (*s != 0 && !isspace(*s)) *t++ = *s++;
676   }
677 else
678   {
679   s++;
680   while (*s != 0 && *s != '\"')
681     {
682     if (*s == '\\') *t++ = string_interpret_escape(&s);
683       else *t++ = *s;
684     s++;
685     }
686   if (*s != 0) s++;
687   }
688
689 /* Update the pointer and return the terminated copy */
690
691 *sptr = s;
692 *t = 0;
693 return yield;
694 }
695 #endif  /* COMPILE_UTILITY */
696
697
698
699 /*************************************************
700 *          Format a string and save it           *
701 *************************************************/
702
703 /* The formatting is done by string_vformat, which checks the length of
704 everything.
705
706 Arguments:
707   format    a printf() format - deliberately char * rather than uschar *
708               because it will most usually be a literal string
709   ...       arguments for format
710
711 Returns:    pointer to fresh piece of store containing sprintf'ed string
712 */
713
714 uschar *
715 string_sprintf(const char *format, ...)
716 {
717 #ifdef COMPILE_UTILITY
718 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
719 gstring g = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
720 gstring * gp = &g;
721 #else
722 gstring * gp = string_get(STRING_SPRINTF_BUFFER_SIZE);
723 #endif
724 gstring * gp2;
725 va_list ap;
726
727 va_start(ap, format);
728 gp2 = string_vformat(gp, FALSE, format, ap);
729 gp->s[gp->ptr] = '\0';
730 va_end(ap);
731
732 if (!gp2)
733   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
734     "string_sprintf expansion was longer than %d; format string was (%s)\n"
735     "expansion started '%.32s'",
736     gp->size, format, gp->s);
737
738 #ifdef COMPILE_UTILITY
739 return string_copy(gp->s);
740 #else
741 gstring_reset_unused(gp);
742 return gp->s;
743 #endif
744 }
745
746
747
748 /*************************************************
749 *         Case-independent strncmp() function    *
750 *************************************************/
751
752 /*
753 Arguments:
754   s         first string
755   t         second string
756   n         number of characters to compare
757
758 Returns:    < 0, = 0, or > 0, according to the comparison
759 */
760
761 int
762 strncmpic(const uschar *s, const uschar *t, int n)
763 {
764 while (n--)
765   {
766   int c = tolower(*s++) - tolower(*t++);
767   if (c) return c;
768   }
769 return 0;
770 }
771
772
773 /*************************************************
774 *         Case-independent strcmp() function     *
775 *************************************************/
776
777 /*
778 Arguments:
779   s         first string
780   t         second string
781
782 Returns:    < 0, = 0, or > 0, according to the comparison
783 */
784
785 int
786 strcmpic(const uschar *s, const uschar *t)
787 {
788 while (*s != 0)
789   {
790   int c = tolower(*s++) - tolower(*t++);
791   if (c != 0) return c;
792   }
793 return *t;
794 }
795
796
797 /*************************************************
798 *         Case-independent strstr() function     *
799 *************************************************/
800
801 /* The third argument specifies whether whitespace is required
802 to follow the matched string.
803
804 Arguments:
805   s              string to search
806   t              substring to search for
807   space_follows  if TRUE, match only if whitespace follows
808
809 Returns:         pointer to substring in string, or NULL if not found
810 */
811
812 uschar *
813 strstric(uschar *s, uschar *t, BOOL space_follows)
814 {
815 uschar *p = t;
816 uschar *yield = NULL;
817 int cl = tolower(*p);
818 int cu = toupper(*p);
819
820 while (*s)
821   {
822   if (*s == cl || *s == cu)
823     {
824     if (yield == NULL) yield = s;
825     if (*(++p) == 0)
826       {
827       if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
828       yield = NULL;
829       p = t;
830       }
831     cl = tolower(*p);
832     cu = toupper(*p);
833     s++;
834     }
835   else if (yield != NULL)
836     {
837     yield = NULL;
838     p = t;
839     cl = tolower(*p);
840     cu = toupper(*p);
841     }
842   else s++;
843   }
844 return NULL;
845 }
846
847
848
849 #ifdef COMPILE_UTILITY
850 /* Dummy version for this function; it should never be called */
851 static void
852 gstring_grow(gstring * g, int p, int count)
853 {
854 assert(FALSE);
855 }
856 #endif
857
858
859
860 #ifndef COMPILE_UTILITY
861 /*************************************************
862 *       Get next string from separated list      *
863 *************************************************/
864
865 /* Leading and trailing space is removed from each item. The separator in the
866 list is controlled by the int pointed to by the separator argument as follows:
867
868   If the value is > 0 it is used as the separator. This is typically used for
869   sublists such as slash-separated options. The value is always a printing
870   character.
871
872     (If the value is actually > UCHAR_MAX there is only one item in the list.
873     This is used for some cases when called via functions that sometimes
874     plough through lists, and sometimes are given single items.)
875
876   If the value is <= 0, the string is inspected for a leading <x, where x is an
877   ispunct() or an iscntrl() character. If found, x is used as the separator. If
878   not found:
879
880       (a) if separator == 0, ':' is used
881       (b) if separator <0, -separator is used
882
883   In all cases the value of the separator that is used is written back to the
884   int so that it is used on subsequent calls as we progress through the list.
885
886 A literal ispunct() separator can be represented in an item by doubling, but
887 there is no way to include an iscntrl() separator as part of the data.
888
889 Arguments:
890   listptr    points to a pointer to the current start of the list; the
891              pointer gets updated to point after the end of the next item
892   separator  a pointer to the separator character in an int (see above)
893   buffer     where to put a copy of the next string in the list; or
894                NULL if the next string is returned in new memory
895   buflen     when buffer is not NULL, the size of buffer; otherwise ignored
896
897 Returns:     pointer to buffer, containing the next substring,
898              or NULL if no more substrings
899 */
900
901 uschar *
902 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
903 {
904 int sep = *separator;
905 const uschar *s = *listptr;
906 BOOL sep_is_special;
907
908 if (s == NULL) return NULL;
909
910 /* This allows for a fixed specified separator to be an iscntrl() character,
911 but at the time of implementation, this is never the case. However, it's best
912 to be conservative. */
913
914 while (isspace(*s) && *s != sep) s++;
915
916 /* A change of separator is permitted, so look for a leading '<' followed by an
917 allowed character. */
918
919 if (sep <= 0)
920   {
921   if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
922     {
923     sep = s[1];
924     if (*++s) ++s;
925     while (isspace(*s) && *s != sep) s++;
926     }
927   else
928     {
929     sep = (sep == 0)? ':' : -sep;
930     }
931   *separator = sep;
932   }
933
934 /* An empty string has no list elements */
935
936 if (*s == 0) return NULL;
937
938 /* Note whether whether or not the separator is an iscntrl() character. */
939
940 sep_is_special = iscntrl(sep);
941
942 /* Handle the case when a buffer is provided. */
943
944 if (buffer)
945   {
946   int p = 0;
947   for (; *s != 0; s++)
948     {
949     if (*s == sep && (*(++s) != sep || sep_is_special)) break;
950     if (p < buflen - 1) buffer[p++] = *s;
951     }
952   while (p > 0 && isspace(buffer[p-1])) p--;
953   buffer[p] = 0;
954   }
955
956 /* Handle the case when a buffer is not provided. */
957
958 else
959   {
960   const uschar *ss;
961   gstring * g = NULL;
962
963   /* We know that *s != 0 at this point. However, it might be pointing to a
964   separator, which could indicate an empty string, or (if an ispunct()
965   character) could be doubled to indicate a separator character as data at the
966   start of a string. Avoid getting working memory for an empty item. */
967
968   if (*s == sep)
969     {
970     s++;
971     if (*s != sep || sep_is_special)
972       {
973       *listptr = s;
974       return string_copy(US"");
975       }
976     }
977
978   /* Not an empty string; the first character is guaranteed to be a data
979   character. */
980
981   for (;;)
982     {
983     for (ss = s + 1; *ss != 0 && *ss != sep; ss++) ;
984     g = string_catn(g, s, ss-s);
985     s = ss;
986     if (*s == 0 || *(++s) != sep || sep_is_special) break;
987     }
988   while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
989   buffer = string_from_gstring(g);
990   gstring_reset_unused(g);
991   }
992
993 /* Update the current pointer and return the new string */
994
995 *listptr = s;
996 return buffer;
997 }
998
999
1000 static const uschar *
1001 Ustrnchr(const uschar * s, int c, unsigned * len)
1002 {
1003 unsigned siz = *len;
1004 while (siz)
1005   {
1006   if (!*s) return NULL;
1007   if (*s == c)
1008     {
1009     *len = siz;
1010     return s;
1011     }
1012   s++;
1013   siz--;
1014   }
1015 return NULL;
1016 }
1017
1018
1019 /************************************************
1020 *       Add element to separated list           *
1021 ************************************************/
1022 /* This function is used to build a list, returning an allocated null-terminated
1023 growable string. The given element has any embedded separator characters
1024 doubled.
1025
1026 Despite having the same growable-string interface as string_cat() the list is
1027 always returned null-terminated.
1028
1029 Arguments:
1030   list  expanding-string for the list that is being built, or NULL
1031         if this is a new list that has no contents yet
1032   sep   list separator character
1033   ele   new element to be appended to the list
1034
1035 Returns:  pointer to the start of the list, changed if copied for expansion.
1036 */
1037
1038 gstring *
1039 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1040 {
1041 uschar * sp;
1042
1043 if (list && list->ptr)
1044   list = string_catn(list, &sep, 1);
1045
1046 while((sp = Ustrchr(ele, sep)))
1047   {
1048   list = string_catn(list, ele, sp-ele+1);
1049   list = string_catn(list, &sep, 1);
1050   ele = sp+1;
1051   }
1052 list = string_cat(list, ele);
1053 (void) string_from_gstring(list);
1054 return list;
1055 }
1056
1057
1058 gstring *
1059 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1060  unsigned len)
1061 {
1062 const uschar * sp;
1063
1064 if (list && list->ptr)
1065   list = string_catn(list, &sep, 1);
1066
1067 while((sp = Ustrnchr(ele, sep, &len)))
1068   {
1069   list = string_catn(list, ele, sp-ele+1);
1070   list = string_catn(list, &sep, 1);
1071   ele = sp+1;
1072   len--;
1073   }
1074 list = string_catn(list, ele, len);
1075 (void) string_from_gstring(list);
1076 return list;
1077 }
1078
1079
1080
1081 /* A slightly-bogus listmaker utility; the separator is a string so
1082 can be multiple chars - there is no checking for the element content
1083 containing any of the separator. */
1084
1085 gstring *
1086 string_append2_listele_n(gstring * list, const uschar * sepstr,
1087  const uschar * ele, unsigned len)
1088 {
1089 if (list && list->ptr)
1090   list = string_cat(list, sepstr);
1091
1092 list = string_catn(list, ele, len);
1093 (void) string_from_gstring(list);
1094 return list;
1095 }
1096
1097
1098
1099 /************************************************/
1100 /* Create a growable-string with some preassigned space */
1101
1102 gstring *
1103 string_get(unsigned size)
1104 {
1105 gstring * g = store_get(sizeof(gstring) + size);
1106 g->size = size;
1107 g->ptr = 0;
1108 g->s = US(g + 1);
1109 return g;
1110 }
1111
1112 /* NUL-terminate the C string in the growable-string, and return it. */
1113
1114 uschar *
1115 string_from_gstring(gstring * g)
1116 {
1117 if (!g) return NULL;
1118 g->s[g->ptr] = '\0';
1119 return g->s;
1120 }
1121
1122 void
1123 gstring_reset_unused(gstring * g)
1124 {
1125 store_reset(g->s + (g->size = g->ptr + 1));
1126 }
1127
1128
1129 /* Add more space to a growable-string.
1130
1131 Arguments:
1132   g             the growable-string
1133   p             current end of data
1134   count         amount to grow by
1135 */
1136
1137 static void
1138 gstring_grow(gstring * g, int p, int count)
1139 {
1140 int oldsize = g->size;
1141
1142 /* Mostly, string_cat() is used to build small strings of a few hundred
1143 characters at most. There are times, however, when the strings are very much
1144 longer (for example, a lookup that returns a vast number of alias addresses).
1145 To try to keep things reasonable, we use increments whose size depends on the
1146 existing length of the string. */
1147
1148 unsigned inc = oldsize < 4096 ? 127 : 1023;
1149 g->size = ((p + count + inc) & ~inc) + 1;
1150
1151 /* Try to extend an existing allocation. If the result of calling
1152 store_extend() is false, either there isn't room in the current memory block,
1153 or this string is not the top item on the dynamic store stack. We then have
1154 to get a new chunk of store and copy the old string. When building large
1155 strings, it is helpful to call store_release() on the old string, to release
1156 memory blocks that have become empty. (The block will be freed if the string
1157 is at its start.) However, we can do this only if we know that the old string
1158 was the last item on the dynamic memory stack. This is the case if it matches
1159 store_last_get. */
1160
1161 if (!store_extend(g->s, oldsize, g->size))
1162   g->s = store_newblock(g->s, g->size, p);
1163 }
1164
1165
1166
1167 /*************************************************
1168 *             Add chars to string                *
1169 *************************************************/
1170 /* This function is used when building up strings of unknown length. Room is
1171 always left for a terminating zero to be added to the string that is being
1172 built. This function does not require the string that is being added to be NUL
1173 terminated, because the number of characters to add is given explicitly. It is
1174 sometimes called to extract parts of other strings.
1175
1176 Arguments:
1177   string   points to the start of the string that is being built, or NULL
1178              if this is a new string that has no contents yet
1179   s        points to characters to add
1180   count    count of characters to add; must not exceed the length of s, if s
1181              is a C string.
1182
1183 Returns:   pointer to the start of the string, changed if copied for expansion.
1184            Note that a NUL is not added, though space is left for one. This is
1185            because string_cat() is often called multiple times to build up a
1186            string - there's no point adding the NUL till the end.
1187
1188 */
1189 /* coverity[+alloc] */
1190
1191 gstring *
1192 string_catn(gstring * g, const uschar *s, int count)
1193 {
1194 int p;
1195
1196 if (!g)
1197   {
1198   unsigned inc = count < 4096 ? 127 : 1023;
1199   unsigned size = ((count + inc) &  ~inc) + 1;
1200   g = string_get(size);
1201   }
1202
1203 p = g->ptr;
1204 if (p + count >= g->size)
1205   gstring_grow(g, p, count);
1206
1207 /* Because we always specify the exact number of characters to copy, we can
1208 use memcpy(), which is likely to be more efficient than strncopy() because the
1209 latter has to check for zero bytes. */
1210
1211 memcpy(g->s + p, s, count);
1212 g->ptr = p + count;
1213 return g;
1214 }
1215  
1216  
1217 gstring *
1218 string_cat(gstring *string, const uschar *s)
1219 {
1220 return string_catn(string, s, Ustrlen(s));
1221 }
1222
1223
1224
1225 /*************************************************
1226 *        Append strings to another string        *
1227 *************************************************/
1228
1229 /* This function can be used to build a string from many other strings.
1230 It calls string_cat() to do the dirty work.
1231
1232 Arguments:
1233   string   expanding-string that is being built, or NULL
1234              if this is a new string that has no contents yet
1235   count    the number of strings to append
1236   ...      "count" uschar* arguments, which must be valid zero-terminated
1237              C strings
1238
1239 Returns:   pointer to the start of the string, changed if copied for expansion.
1240            The string is not zero-terminated - see string_cat() above.
1241 */
1242
1243 __inline__ gstring *
1244 string_append(gstring *string, int count, ...)
1245 {
1246 va_list ap;
1247
1248 va_start(ap, count);
1249 while (count-- > 0)
1250   {
1251   uschar *t = va_arg(ap, uschar *);
1252   string = string_cat(string, t);
1253   }
1254 va_end(ap);
1255
1256 return string;
1257 }
1258 #endif
1259
1260
1261
1262 /*************************************************
1263 *        Format a string with length checks      *
1264 *************************************************/
1265
1266 /* This function is used to format a string with checking of the length of the
1267 output for all conversions. It protects Exim from absent-mindedness when
1268 calling functions like debug_printf and string_sprintf, and elsewhere. There
1269 are two different entry points to what is actually the same function, depending
1270 on whether the variable length list of data arguments are given explicitly or
1271 as a va_list item.
1272
1273 The formats are the usual printf() ones, with some omissions (never used) and
1274 three additions for strings: %S forces lower case, %T forces upper case, and
1275 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1276 (useful in debugging). There is also the addition of %D and %M, which insert
1277 the date in the form used for datestamped log files.
1278
1279 Arguments:
1280   buffer       a buffer in which to put the formatted string
1281   buflen       the length of the buffer
1282   format       the format string - deliberately char * and not uschar *
1283   ... or ap    variable list of supplementary arguments
1284
1285 Returns:       TRUE if the result fitted in the buffer
1286 */
1287
1288 BOOL
1289 string_format(uschar * buffer, int buflen, const char * format, ...)
1290 {
1291 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1292 va_list ap;
1293 va_start(ap, format);
1294 gp = string_vformat(&g, FALSE, format, ap);
1295 va_end(ap);
1296 g.s[g.ptr] = '\0';
1297 return !!gp;
1298 }
1299
1300
1301
1302
1303
1304 /* Bulid or append to a growing-string, sprintf-style.
1305
1306 If the "extend" argument is true, the string passed in can be NULL,
1307 empty, or non-empty.
1308
1309 If the "extend" argument is false, the string passed in may not be NULL,
1310 will not be grown, and is usable in the original place after return.
1311 The return value can be NULL to signify overflow.
1312
1313 Returns the possibly-new (if copy for growth was needed) string,
1314 not nul-terminated.
1315 */
1316
1317 gstring *
1318 string_vformat(gstring * g, BOOL extend, const char *format, va_list ap)
1319 {
1320 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1321
1322 int width, precision, off, lim;
1323 const char * fp = format;       /* Deliberately not unsigned */
1324
1325 string_datestamp_offset = -1;   /* Datestamp not inserted */
1326 string_datestamp_length = 0;    /* Datestamp not inserted */
1327 string_datestamp_type = 0;      /* Datestamp not inserted */
1328
1329 #ifdef COMPILE_UTILITY
1330 assert(!extend);
1331 assert(g);
1332 #else
1333
1334 /* Ensure we have a string, to save on checking later */
1335 if (!g) g = string_get(16);
1336 #endif  /*!COMPILE_UTILITY*/
1337
1338 lim = g->size - 1;      /* leave one for a nul */
1339 off = g->ptr;           /* remember initial offset in gstring */
1340
1341 /* Scan the format and handle the insertions */
1342
1343 while (*fp)
1344   {
1345   int length = L_NORMAL;
1346   int *nptr;
1347   int slen;
1348   const char *null = "NULL";            /* ) These variables */
1349   const char *item_start, *s;           /* ) are deliberately */
1350   char newformat[16];                   /* ) not unsigned */
1351   char * gp = CS g->s + g->ptr;         /* ) */
1352
1353   /* Non-% characters just get copied verbatim */
1354
1355   if (*fp != '%')
1356     {
1357     /* Avoid string_copyn() due to COMPILE_UTILITY */
1358     if (g->ptr >= lim - 1)
1359       {
1360       if (!extend) return NULL;
1361       gstring_grow(g, g->ptr, 1);
1362       lim = g->size - 1;
1363       }
1364     g->s[g->ptr++] = (uschar) *fp++;
1365     continue;
1366     }
1367
1368   /* Deal with % characters. Pick off the width and precision, for checking
1369   strings, skipping over the flag and modifier characters. */
1370
1371   item_start = fp;
1372   width = precision = -1;
1373
1374   if (strchr("-+ #0", *(++fp)) != NULL)
1375     {
1376     if (*fp == '#') null = "";
1377     fp++;
1378     }
1379
1380   if (isdigit((uschar)*fp))
1381     {
1382     width = *fp++ - '0';
1383     while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1384     }
1385   else if (*fp == '*')
1386     {
1387     width = va_arg(ap, int);
1388     fp++;
1389     }
1390
1391   if (*fp == '.')
1392     if (*(++fp) == '*')
1393       {
1394       precision = va_arg(ap, int);
1395       fp++;
1396       }
1397     else
1398       for (precision = 0; isdigit((uschar)*fp); fp++)
1399         precision = precision*10 + *fp - '0';
1400
1401   /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1402
1403   if (*fp == 'h')
1404     { fp++; length = L_SHORT; }
1405   else if (*fp == 'L')
1406     { fp++; length = L_LONGDOUBLE; }
1407   else if (*fp == 'l')
1408     if (fp[1] == 'l')
1409       { fp += 2; length = L_LONGLONG; }
1410     else
1411       { fp++; length = L_LONG; }
1412   else if (*fp == 'z')
1413     { fp++; length = L_SIZE; }
1414
1415   /* Handle each specific format type. */
1416
1417   switch (*fp++)
1418     {
1419     case 'n':
1420       nptr = va_arg(ap, int *);
1421       *nptr = g->ptr - off;
1422       break;
1423
1424     case 'd':
1425     case 'o':
1426     case 'u':
1427     case 'x':
1428     case 'X':
1429       width = length > L_LONG ? 24 : 12;
1430       if (g->ptr >= lim - width)
1431         {
1432         if (!extend) return NULL;
1433         gstring_grow(g, g->ptr, width);
1434         lim = g->size - 1;
1435         gp = CS g->s + g->ptr;
1436         }
1437       strncpy(newformat, item_start, fp - item_start);
1438       newformat[fp - item_start] = 0;
1439
1440       /* Short int is promoted to int when passing through ..., so we must use
1441       int for va_arg(). */
1442
1443       switch(length)
1444         {
1445         case L_SHORT:
1446         case L_NORMAL:
1447           g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1448         case L_LONG:
1449           g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1450         case L_LONGLONG:
1451           g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1452         case L_SIZE:
1453           g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1454         }
1455       break;
1456
1457     case 'p':
1458       {
1459       void * ptr;
1460       if (g->ptr >= lim - 24)
1461         {
1462         if (!extend) return NULL;
1463         gstring_grow(g, g->ptr, 24);
1464         lim = g->size - 1;
1465         gp = CS g->s + g->ptr;
1466         }
1467       /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1468       Handle it explicitly. */
1469       if ((ptr = va_arg(ap, void *)))
1470         {
1471         strncpy(newformat, item_start, fp - item_start);
1472         newformat[fp - item_start] = 0;
1473         g->ptr += sprintf(gp, newformat, ptr);
1474         }
1475       else
1476         g->ptr += sprintf(gp, "(nil)");
1477       }
1478     break;
1479
1480     /* %f format is inherently insecure if the numbers that it may be
1481     handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1482     printing load averages, and these are actually stored as integers
1483     (load average * 1000) so the size of the numbers is constrained.
1484     It is also used for formatting sending rates, where the simplicity
1485     of the format prevents overflow. */
1486
1487     case 'f':
1488     case 'e':
1489     case 'E':
1490     case 'g':
1491     case 'G':
1492       if (precision < 0) precision = 6;
1493       if (g->ptr >= lim - precision - 8)
1494         {
1495         if (!extend) return NULL;
1496         gstring_grow(g, g->ptr, precision+8);
1497         lim = g->size - 1;
1498         gp = CS g->s + g->ptr;
1499         }
1500       strncpy(newformat, item_start, fp - item_start);
1501       newformat[fp-item_start] = 0;
1502       if (length == L_LONGDOUBLE)
1503         g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1504       else
1505         g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1506       break;
1507
1508     /* String types */
1509
1510     case '%':
1511       if (g->ptr >= lim - 1)
1512         {
1513         if (!extend) return NULL;
1514         gstring_grow(g, g->ptr, 1);
1515         lim = g->size - 1;
1516         }
1517       g->s[g->ptr++] = (uschar) '%';
1518       break;
1519
1520     case 'c':
1521       if (g->ptr >= lim - 1)
1522         {
1523         if (!extend) return NULL;
1524         gstring_grow(g, g->ptr, 1);
1525         lim = g->size - 1;
1526         }
1527       g->s[g->ptr++] = (uschar) va_arg(ap, int);
1528       break;
1529
1530     case 'D':                   /* Insert daily datestamp for log file names */
1531       s = CS tod_stamp(tod_log_datestamp_daily);
1532       string_datestamp_offset = g->ptr;         /* Passed back via global */
1533       string_datestamp_length = Ustrlen(s);     /* Passed back via global */
1534       string_datestamp_type = tod_log_datestamp_daily;
1535       slen = string_datestamp_length;
1536       goto INSERT_STRING;
1537
1538     case 'M':                   /* Insert monthly datestamp for log file names */
1539       s = CS tod_stamp(tod_log_datestamp_monthly);
1540       string_datestamp_offset = g->ptr;         /* Passed back via global */
1541       string_datestamp_length = Ustrlen(s);     /* Passed back via global */
1542       string_datestamp_type = tod_log_datestamp_monthly;
1543       slen = string_datestamp_length;
1544       goto INSERT_STRING;
1545
1546     case 's':
1547     case 'S':                   /* Forces *lower* case */
1548     case 'T':                   /* Forces *upper* case */
1549       s = va_arg(ap, char *);
1550
1551       if (!s) s = null;
1552       slen = Ustrlen(s);
1553
1554     INSERT_STRING:              /* Come to from %D or %M above */
1555
1556       {
1557       BOOL truncated = FALSE;
1558
1559       /* If the width is specified, check that there is a precision
1560       set; if not, set it to the width to prevent overruns of long
1561       strings. */
1562
1563       if (width >= 0)
1564         {
1565         if (precision < 0) precision = width;
1566         }
1567
1568       /* If a width is not specified and the precision is specified, set
1569       the width to the precision, or the string length if shorted. */
1570
1571       else if (precision >= 0)
1572         width = precision < slen ? precision : slen;
1573
1574       /* If neither are specified, set them both to the string length. */
1575
1576       else
1577         width = precision = slen;
1578
1579       if (!extend)
1580         {
1581         if (g->ptr == lim) return NULL;
1582         if (g->ptr >= lim - width)
1583           {
1584           truncated = TRUE;
1585           width = precision = lim - g->ptr - 1;
1586           if (width < 0) width = 0;
1587           if (precision < 0) precision = 0;
1588           }
1589         }
1590       else if (g->ptr >= lim - width)
1591         {
1592         gstring_grow(g, g->ptr, width - (lim - g->ptr));
1593         lim = g->size - 1;
1594         gp = CS g->s + g->ptr;
1595         }
1596
1597       g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1598       if (fp[-1] == 'S')
1599         while (*gp) { *gp = tolower(*gp); gp++; }
1600       else if (fp[-1] == 'T')
1601         while (*gp) { *gp = toupper(*gp); gp++; }
1602
1603       if (truncated) return NULL;
1604       break;
1605       }
1606
1607     /* Some things are never used in Exim; also catches junk. */
1608
1609     default:
1610       strncpy(newformat, item_start, fp - item_start);
1611       newformat[fp-item_start] = 0;
1612       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1613         "in \"%s\" in \"%s\"", newformat, format);
1614       break;
1615     }
1616   }
1617
1618 return g;
1619 }
1620
1621
1622
1623 #ifndef COMPILE_UTILITY
1624
1625 gstring *
1626 string_fmt_append(gstring * g, const char *format, ...)
1627 {
1628 va_list ap;
1629 va_start(ap, format);
1630 g = string_vformat(g, TRUE, format, ap);
1631 va_end(ap);
1632 return g;
1633 }
1634
1635
1636
1637 /*************************************************
1638 *       Generate an "open failed" message        *
1639 *************************************************/
1640
1641 /* This function creates a message after failure to open a file. It includes a
1642 string supplied as data, adds the strerror() text, and if the failure was
1643 "Permission denied", reads and includes the euid and egid.
1644
1645 Arguments:
1646   eno           the value of errno after the failure
1647   format        a text format string - deliberately not uschar *
1648   ...           arguments for the format string
1649
1650 Returns:        a message, in dynamic store
1651 */
1652
1653 uschar *
1654 string_open_failed(int eno, const char *format, ...)
1655 {
1656 va_list ap;
1657 gstring * g = string_get(1024);
1658
1659 g = string_catn(g, US"failed to open ", 15);
1660
1661 /* Use the checked formatting routine to ensure that the buffer
1662 does not overflow. It should not, since this is called only for internally
1663 specified messages. If it does, the message just gets truncated, and there
1664 doesn't seem much we can do about that. */
1665
1666 va_start(ap, format);
1667 (void) string_vformat(g, FALSE, format, ap);
1668 string_from_gstring(g);
1669 gstring_reset_unused(g);
1670 va_end(ap);
1671
1672 return eno == EACCES
1673   ? string_sprintf("%s: %s (euid=%ld egid=%ld)", g->s, strerror(eno),
1674     (long int)geteuid(), (long int)getegid())
1675   : string_sprintf("%s: %s", g->s, strerror(eno));
1676 }
1677 #endif  /* COMPILE_UTILITY */
1678
1679
1680
1681
1682
1683 #ifndef COMPILE_UTILITY
1684 /* qsort(3), currently used to sort the environment variables
1685 for -bP environment output, needs a function to compare two pointers to string
1686 pointers. Here it is. */
1687
1688 int
1689 string_compare_by_pointer(const void *a, const void *b)
1690 {
1691 return Ustrcmp(* CUSS a, * CUSS b);
1692 }
1693 #endif /* COMPILE_UTILITY */
1694
1695
1696
1697
1698 /*************************************************
1699 **************************************************
1700 *             Stand-alone test program           *
1701 **************************************************
1702 *************************************************/
1703
1704 #ifdef STAND_ALONE
1705 int main(void)
1706 {
1707 uschar buffer[256];
1708
1709 printf("Testing is_ip_address\n");
1710
1711 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1712   {
1713   int offset;
1714   buffer[Ustrlen(buffer) - 1] = 0;
1715   printf("%d\n", string_is_ip_address(buffer, NULL));
1716   printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1717   }
1718
1719 printf("Testing string_nextinlist\n");
1720
1721 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1722   {
1723   uschar *list = buffer;
1724   uschar *lp1, *lp2;
1725   uschar item[256];
1726   int sep1 = 0;
1727   int sep2 = 0;
1728
1729   if (*list == '<')
1730     {
1731     sep1 = sep2 = list[1];
1732     list += 2;
1733     }
1734
1735   lp1 = lp2 = list;
1736   for (;;)
1737     {
1738     uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1739     uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1740
1741     if (item1 == NULL && item2 == NULL) break;
1742     if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1743       {
1744       printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1745         (item1 == NULL)? "NULL" : CS item1,
1746         (item2 == NULL)? "NULL" : CS item2);
1747       break;
1748       }
1749     else printf("  \"%s\"\n", CS item1);
1750     }
1751   }
1752
1753 /* This is a horrible lash-up, but it serves its purpose. */
1754
1755 printf("Testing string_format\n");
1756
1757 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1758   {
1759   void *args[3];
1760   long long llargs[3];
1761   double dargs[3];
1762   int dflag = 0;
1763   int llflag = 0;
1764   int n = 0;
1765   int count;
1766   int countset = 0;
1767   uschar format[256];
1768   uschar outbuf[256];
1769   uschar *s;
1770   buffer[Ustrlen(buffer) - 1] = 0;
1771
1772   s = Ustrchr(buffer, ',');
1773   if (s == NULL) s = buffer + Ustrlen(buffer);
1774
1775   Ustrncpy(format, buffer, s - buffer);
1776   format[s-buffer] = 0;
1777
1778   if (*s == ',') s++;
1779
1780   while (*s != 0)
1781     {
1782     uschar *ss = s;
1783     s = Ustrchr(ss, ',');
1784     if (s == NULL) s = ss + Ustrlen(ss);
1785
1786     if (isdigit(*ss))
1787       {
1788       Ustrncpy(outbuf, ss, s-ss);
1789       if (Ustrchr(outbuf, '.') != NULL)
1790         {
1791         dflag = 1;
1792         dargs[n++] = Ustrtod(outbuf, NULL);
1793         }
1794       else if (Ustrstr(outbuf, "ll") != NULL)
1795         {
1796         llflag = 1;
1797         llargs[n++] = strtoull(CS outbuf, NULL, 10);
1798         }
1799       else
1800         {
1801         args[n++] = (void *)Uatoi(outbuf);
1802         }
1803       }
1804
1805     else if (Ustrcmp(ss, "*") == 0)
1806       {
1807       args[n++] = (void *)(&count);
1808       countset = 1;
1809       }
1810
1811     else
1812       {
1813       uschar *sss = malloc(s - ss + 1);
1814       Ustrncpy(sss, ss, s-ss);
1815       args[n++] = sss;
1816       }
1817
1818     if (*s == ',') s++;
1819     }
1820
1821   if (!dflag && !llflag)
1822     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1823       args[0], args[1], args[2])? "True" : "False");
1824
1825   else if (dflag)
1826     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1827       dargs[0], dargs[1], dargs[2])? "True" : "False");
1828
1829   else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1830     llargs[0], llargs[1], llargs[2])? "True" : "False");
1831
1832   printf("%s\n", CS outbuf);
1833   if (countset) printf("count=%d\n", count);
1834   }
1835
1836 return 0;
1837 }
1838 #endif
1839
1840 /* End of string.c */