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