a5161bb31e057d3592294a7a9bd0ad57e4b101f4
[exim.git] / src / src / string.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2022 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
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, 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, 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, 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, const void * proto_mem)
441 {
442 return string_copy_taint(s, proto_mem);
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, GET_TAINTED);   /* 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, *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 /*XXX need to also deal with qouted-requirements mismatch */
915
916 if (buffer)
917   {
918   int p = 0;
919   if (is_tainted(s) && !is_tainted(buffer))
920     die_tainted(US"string_nextinlist", func, line);
921   for (; *s; s++)
922     {
923     if (*s == sep && (*(++s) != sep || sep_is_special)) break;
924     if (p < buflen - 1) buffer[p++] = *s;
925     }
926   while (p > 0 && isspace(buffer[p-1])) p--;
927   buffer[p] = '\0';
928   }
929
930 /* Handle the case when a buffer is not provided. */
931
932 else
933   {
934   gstring * g = NULL;
935
936   /* We know that *s != 0 at this point. However, it might be pointing to a
937   separator, which could indicate an empty string, or (if an ispunct()
938   character) could be doubled to indicate a separator character as data at the
939   start of a string. Avoid getting working memory for an empty item. */
940
941   if (*s == sep)
942     if (*++s != sep || sep_is_special)
943       {
944       *listptr = s;
945       return string_copy(US"");
946       }
947
948   /* Not an empty string; the first character is guaranteed to be a data
949   character. */
950
951   for (;;)
952     {
953     const uschar * ss;
954     for (ss = s + 1; *ss && *ss != sep; ) ss++;
955     g = string_catn(g, s, ss-s);
956     s = ss;
957     if (!*s || *++s != sep || sep_is_special) break;
958     }
959
960   /* Trim trailing spaces from the returned string */
961
962   /* while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--; */
963   while (  g->ptr > 0 && isspace(g->s[g->ptr-1])
964         && (g->ptr == 1 || g->s[g->ptr-2] != '\\') )
965     g->ptr--;
966   buffer = string_from_gstring(g);
967   gstring_release_unused_trc(g, CCS func, line);
968   }
969
970 /* Update the current pointer and return the new string */
971
972 *listptr = s;
973 return buffer;
974 }
975
976
977 static const uschar *
978 Ustrnchr(const uschar * s, int c, unsigned * len)
979 {
980 unsigned siz = *len;
981 while (siz)
982   {
983   if (!*s) return NULL;
984   if (*s == c)
985     {
986     *len = siz;
987     return s;
988     }
989   s++;
990   siz--;
991   }
992 return NULL;
993 }
994
995
996 /************************************************
997 *       Add element to separated list           *
998 ************************************************/
999 /* This function is used to build a list, returning an allocated null-terminated
1000 growable string. The given element has any embedded separator characters
1001 doubled.
1002
1003 Despite having the same growable-string interface as string_cat() the list is
1004 always returned null-terminated.
1005
1006 Arguments:
1007   list  expanding-string for the list that is being built, or NULL
1008         if this is a new list that has no contents yet
1009   sep   list separator character
1010   ele   new element to be appended to the list
1011
1012 Returns:  pointer to the start of the list, changed if copied for expansion.
1013 */
1014
1015 gstring *
1016 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1017 {
1018 uschar * sp;
1019
1020 if (list && list->ptr)
1021   list = string_catn(list, &sep, 1);
1022
1023 while((sp = Ustrchr(ele, sep)))
1024   {
1025   list = string_catn(list, ele, sp-ele+1);
1026   list = string_catn(list, &sep, 1);
1027   ele = sp+1;
1028   }
1029 list = string_cat(list, ele);
1030 (void) string_from_gstring(list);
1031 return list;
1032 }
1033
1034
1035 gstring *
1036 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1037  unsigned len)
1038 {
1039 const uschar * sp;
1040
1041 if (list && list->ptr)
1042   list = string_catn(list, &sep, 1);
1043
1044 while((sp = Ustrnchr(ele, sep, &len)))
1045   {
1046   list = string_catn(list, ele, sp-ele+1);
1047   list = string_catn(list, &sep, 1);
1048   ele = sp+1;
1049   len--;
1050   }
1051 list = string_catn(list, ele, len);
1052 (void) string_from_gstring(list);
1053 return list;
1054 }
1055
1056
1057
1058 /* A slightly-bogus listmaker utility; the separator is a string so
1059 can be multiple chars - there is no checking for the element content
1060 containing any of the separator. */
1061
1062 gstring *
1063 string_append2_listele_n(gstring * list, const uschar * sepstr,
1064  const uschar * ele, unsigned len)
1065 {
1066 if (list && list->ptr)
1067   list = string_cat(list, sepstr);
1068
1069 list = string_catn(list, ele, len);
1070 (void) string_from_gstring(list);
1071 return list;
1072 }
1073
1074
1075
1076 /************************************************/
1077 /* Add more space to a growable-string.  The caller should check
1078 first if growth is required.  The gstring struct is modified on
1079 return; specifically, the string-base-pointer may have been changed.
1080
1081 Arguments:
1082   g             the growable-string
1083   count         amount needed for g->ptr to increase by
1084 */
1085
1086 static void
1087 gstring_grow(gstring * g, int count)
1088 {
1089 int p = g->ptr;
1090 int oldsize = g->size;
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, oldsize, g->size))
1123   g->s = store_newblock(g->s, 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
1157 if (count < 0)
1158   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1159     "internal error in string_catn (count %d)", count);
1160 if (count == 0) return g;
1161
1162 /*debug_printf("string_catn '%.*s'\n", count, s);*/
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, s);
1168   }
1169 else if (!g->s)                 /* should not happen */
1170   {
1171   g->s = string_copyn(s, count);
1172   g->ptr = count;
1173   g->size = count;      /*XXX suboptimal*/
1174   return g;
1175   }
1176 else if (is_incompatible(g->s, s))
1177   {
1178 /* debug_printf("rebuf A\n"); */
1179   gstring_rebuffer(g, s);
1180   }
1181
1182 if (g->ptr < 0 || g->ptr > g->size)
1183   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1184     "internal error in string_catn (ptr %d size %d)", g->ptr, g->size);
1185
1186 p = g->ptr;
1187 if (count >= g->size - p)
1188   gstring_grow(g, count);
1189
1190 /* Because we always specify the exact number of characters to copy, we can
1191 use memcpy(), which is likely to be more efficient than strncopy() because the
1192 latter has to check for zero bytes. */
1193
1194 memcpy(g->s + p, s, count);
1195 g->ptr = p + count;
1196 return g;
1197 }
1198
1199
1200 gstring *
1201 string_cat(gstring * g, const uschar * s)
1202 {
1203 return string_catn(g, s, Ustrlen(s));
1204 }
1205
1206
1207
1208 /*************************************************
1209 *        Append strings to another string        *
1210 *************************************************/
1211
1212 /* This function can be used to build a string from many other strings.
1213 It calls string_cat() to do the dirty work.
1214
1215 Arguments:
1216   g        growable-string that is being built, or NULL if not yet assigned
1217   count    the number of strings to append
1218   ...      "count" uschar* arguments, which must be valid zero-terminated
1219              C strings
1220
1221 Returns:   growable string, changed if copied for expansion.
1222            The string is not zero-terminated - see string_cat() above.
1223 */
1224
1225 __inline__ gstring *
1226 string_append(gstring * g, int count, ...)
1227 {
1228 va_list ap;
1229
1230 va_start(ap, count);
1231 while (count-- > 0)
1232   {
1233   uschar * t = va_arg(ap, uschar *);
1234   g = string_cat(g, t);
1235   }
1236 va_end(ap);
1237
1238 return g;
1239 }
1240 #endif
1241
1242
1243
1244 /*************************************************
1245 *        Format a string with length checks      *
1246 *************************************************/
1247
1248 /* This function is used to format a string with checking of the length of the
1249 output for all conversions. It protects Exim from absent-mindedness when
1250 calling functions like debug_printf and string_sprintf, and elsewhere. There
1251 are two different entry points to what is actually the same function, depending
1252 on whether the variable length list of data arguments are given explicitly or
1253 as a va_list item.
1254
1255 The formats are the usual printf() ones, with some omissions (never used) and
1256 three additions for strings: %S forces lower case, %T forces upper case, and
1257 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1258 (useful in debugging). There is also the addition of %D and %M, which insert
1259 the date in the form used for datestamped log files.
1260
1261 Arguments:
1262   buffer       a buffer in which to put the formatted string
1263   buflen       the length of the buffer
1264   format       the format string - deliberately char * and not uschar *
1265   ... or ap    variable list of supplementary arguments
1266
1267 Returns:       TRUE if the result fitted in the buffer
1268 */
1269
1270 BOOL
1271 string_format_trc(uschar * buffer, int buflen,
1272   const uschar * func, unsigned line, const char * format, ...)
1273 {
1274 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, * gp;
1275 va_list ap;
1276 va_start(ap, format);
1277 gp = string_vformat_trc(&g, func, line, STRING_SPRINTF_BUFFER_SIZE,
1278         0, format, ap);
1279 va_end(ap);
1280 g.s[g.ptr] = '\0';
1281 return !!gp;
1282 }
1283
1284
1285
1286
1287 /* Build or append to a growing-string, sprintf-style.
1288
1289 Arguments:
1290         g       a growable-string
1291         func    called-from function name, for debug
1292         line    called-from file line number, for debug
1293         limit   maximum string size
1294         flags   see below
1295         format  printf-like format string
1296         ap      variable-args pointer
1297
1298 Flags:
1299         SVFMT_EXTEND            buffer can be created or exteded as needed
1300         SVFMT_REBUFFER          buffer can be recopied to tainted mem as needed
1301         SVFMT_TAINT_NOCHK       do not check inputs for taint
1302
1303 If the "extend" flag is true, the string passed in can be NULL,
1304 empty, or non-empty.  Growing is subject to an overall limit given
1305 by the limit argument.
1306
1307 If the "extend" flag is false, the string passed in may not be NULL,
1308 will not be grown, and is usable in the original place after return.
1309 The return value can be NULL to signify overflow.
1310
1311 Returns the possibly-new (if copy for growth or taint-handling was needed)
1312 string, not nul-terminated.
1313 */
1314
1315 gstring *
1316 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
1317   unsigned size_limit, unsigned flags, const char * format, va_list ap)
1318 {
1319 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1320
1321 int width, precision, off, lim, need;
1322 const char * fp = format;       /* Deliberately not unsigned */
1323
1324 string_datestamp_offset = -1;   /* Datestamp not inserted */
1325 string_datestamp_length = 0;    /* Datestamp not inserted */
1326 string_datestamp_type = 0;      /* Datestamp not inserted */
1327
1328 #ifdef COMPILE_UTILITY
1329 assert(!(flags & SVFMT_EXTEND));
1330 assert(g);
1331 #else
1332
1333 /* Ensure we have a string, to save on checking later */
1334 if (!g) g = string_get(16);
1335
1336 if (!(flags & SVFMT_TAINT_NOCHK) && is_incompatible(g->s, format))
1337   {
1338 #ifndef MACRO_PREDEF
1339   if (!(flags & SVFMT_REBUFFER))
1340     die_tainted(US"string_vformat", func, line);
1341 #endif
1342 /* debug_printf("rebuf B\n"); */
1343   gstring_rebuffer(g, format);
1344   }
1345 #endif  /*!COMPILE_UTILITY*/
1346
1347 lim = g->size - 1;      /* leave one for a nul */
1348 off = g->ptr;           /* remember initial offset in gstring */
1349
1350 /* Scan the format and handle the insertions */
1351
1352 while (*fp)
1353   {
1354   int length = L_NORMAL;
1355   int * nptr;
1356   int slen;
1357   const char *null = "NULL";            /* ) These variables */
1358   const char *item_start, *s;           /* ) are deliberately */
1359   char newformat[16];                   /* ) not unsigned */
1360   char * gp = CS g->s + g->ptr;         /* ) */
1361
1362   /* Non-% characters just get copied verbatim */
1363
1364   if (*fp != '%')
1365     {
1366     /* Avoid string_copyn() due to COMPILE_UTILITY */
1367     if ((need = g->ptr + 1) > lim)
1368       {
1369       if (!(flags & SVFMT_EXTEND) || need > size_limit) return NULL;
1370       gstring_grow(g, 1);
1371       lim = g->size - 1;
1372       }
1373     g->s[g->ptr++] = (uschar) *fp++;
1374     continue;
1375     }
1376
1377   /* Deal with % characters. Pick off the width and precision, for checking
1378   strings, skipping over the flag and modifier characters. */
1379
1380   item_start = fp;
1381   width = precision = -1;
1382
1383   if (strchr("-+ #0", *(++fp)) != NULL)
1384     {
1385     if (*fp == '#') null = "";
1386     fp++;
1387     }
1388
1389   if (isdigit((uschar)*fp))
1390     {
1391     width = *fp++ - '0';
1392     while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1393     }
1394   else if (*fp == '*')
1395     {
1396     width = va_arg(ap, int);
1397     fp++;
1398     }
1399
1400   if (*fp == '.')
1401     if (*(++fp) == '*')
1402       {
1403       precision = va_arg(ap, int);
1404       fp++;
1405       }
1406     else
1407       for (precision = 0; isdigit((uschar)*fp); fp++)
1408         precision = precision*10 + *fp - '0';
1409
1410   /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1411
1412   if (*fp == 'h')
1413     { fp++; length = L_SHORT; }
1414   else if (*fp == 'L')
1415     { fp++; length = L_LONGDOUBLE; }
1416   else if (*fp == 'l')
1417     if (fp[1] == 'l')
1418       { fp += 2; length = L_LONGLONG; }
1419     else
1420       { fp++; length = L_LONG; }
1421   else if (*fp == 'z')
1422     { fp++; length = L_SIZE; }
1423
1424   /* Handle each specific format type. */
1425
1426   switch (*fp++)
1427     {
1428     case 'n':
1429       nptr = va_arg(ap, int *);
1430       *nptr = g->ptr - off;
1431       break;
1432
1433     case 'd':
1434     case 'o':
1435     case 'u':
1436     case 'x':
1437     case 'X':
1438       width = length > L_LONG ? 24 : 12;
1439       if ((need = g->ptr + width) > lim)
1440         {
1441         if (!(flags & SVFMT_EXTEND) || need >= size_limit) return NULL;
1442         gstring_grow(g, width);
1443         lim = g->size - 1;
1444         gp = CS g->s + g->ptr;
1445         }
1446       strncpy(newformat, item_start, fp - item_start);
1447       newformat[fp - item_start] = 0;
1448
1449       /* Short int is promoted to int when passing through ..., so we must use
1450       int for va_arg(). */
1451
1452       switch(length)
1453         {
1454         case L_SHORT:
1455         case L_NORMAL:
1456           g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1457         case L_LONG:
1458           g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1459         case L_LONGLONG:
1460           g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1461         case L_SIZE:
1462           g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1463         }
1464       break;
1465
1466     case 'p':
1467       {
1468       void * ptr;
1469       if ((need = g->ptr + 24) > lim)
1470         {
1471         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1472         gstring_grow(g, 24);
1473         lim = g->size - 1;
1474         gp = CS g->s + g->ptr;
1475         }
1476       /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1477       Handle it explicitly. */
1478       if ((ptr = va_arg(ap, void *)))
1479         {
1480         strncpy(newformat, item_start, fp - item_start);
1481         newformat[fp - item_start] = 0;
1482         g->ptr += sprintf(gp, newformat, ptr);
1483         }
1484       else
1485         g->ptr += sprintf(gp, "(nil)");
1486       }
1487     break;
1488
1489     /* %f format is inherently insecure if the numbers that it may be
1490     handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1491     printing load averages, and these are actually stored as integers
1492     (load average * 1000) so the size of the numbers is constrained.
1493     It is also used for formatting sending rates, where the simplicity
1494     of the format prevents overflow. */
1495
1496     case 'f':
1497     case 'e':
1498     case 'E':
1499     case 'g':
1500     case 'G':
1501       if (precision < 0) precision = 6;
1502       if ((need = g->ptr + precision + 8) > lim)
1503         {
1504         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1505         gstring_grow(g, precision+8);
1506         lim = g->size - 1;
1507         gp = CS g->s + g->ptr;
1508         }
1509       strncpy(newformat, item_start, fp - item_start);
1510       newformat[fp-item_start] = 0;
1511       if (length == L_LONGDOUBLE)
1512         g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1513       else
1514         g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1515       break;
1516
1517     /* String types */
1518
1519     case '%':
1520       if ((need = g->ptr + 1) > lim)
1521         {
1522         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1523         gstring_grow(g, 1);
1524         lim = g->size - 1;
1525         }
1526       g->s[g->ptr++] = (uschar) '%';
1527       break;
1528
1529     case 'c':
1530       if ((need = g->ptr + 1) > lim)
1531         {
1532         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1533         gstring_grow(g, 1);
1534         lim = g->size - 1;
1535         }
1536       g->s[g->ptr++] = (uschar) va_arg(ap, int);
1537       break;
1538
1539     case 'D':                   /* Insert daily datestamp for log file names */
1540       s = CS tod_stamp(tod_log_datestamp_daily);
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_daily;
1544       slen = string_datestamp_length;
1545       goto INSERT_STRING;
1546
1547     case 'M':                   /* Insert monthly datestamp for log file names */
1548       s = CS tod_stamp(tod_log_datestamp_monthly);
1549       string_datestamp_offset = g->ptr;         /* Passed back via global */
1550       string_datestamp_length = Ustrlen(s);     /* Passed back via global */
1551       string_datestamp_type = tod_log_datestamp_monthly;
1552       slen = string_datestamp_length;
1553       goto INSERT_STRING;
1554
1555     case 's':
1556     case 'S':                   /* Forces *lower* case */
1557     case 'T':                   /* Forces *upper* case */
1558       s = va_arg(ap, char *);
1559
1560       if (!s) s = null;
1561       slen = Ustrlen(s);
1562
1563       if (!(flags & SVFMT_TAINT_NOCHK) && is_incompatible(g->s, s))
1564         if (flags & SVFMT_REBUFFER)
1565           {
1566 /* debug_printf("%s %d: untainted workarea, tainted %%s :- rebuffer\n", __FUNCTION__, __LINE__); */
1567           gstring_rebuffer(g, s);
1568           gp = CS g->s + g->ptr;
1569           }
1570 #ifndef MACRO_PREDEF
1571         else
1572           die_tainted(US"string_vformat", func, line);
1573 #endif
1574
1575     INSERT_STRING:              /* Come to from %D or %M above */
1576
1577       {
1578       BOOL truncated = FALSE;
1579
1580       /* If the width is specified, check that there is a precision
1581       set; if not, set it to the width to prevent overruns of long
1582       strings. */
1583
1584       if (width >= 0)
1585         {
1586         if (precision < 0) precision = width;
1587         }
1588
1589       /* If a width is not specified and the precision is specified, set
1590       the width to the precision, or the string length if shorted. */
1591
1592       else if (precision >= 0)
1593         width = precision < slen ? precision : slen;
1594
1595       /* If neither are specified, set them both to the string length. */
1596
1597       else
1598         width = precision = slen;
1599
1600       if ((need = g->ptr + width) >= size_limit || !(flags & SVFMT_EXTEND))
1601         {
1602         if (g->ptr == lim) return NULL;
1603         if (need > lim)
1604           {
1605           truncated = TRUE;
1606           width = precision = lim - g->ptr - 1;
1607           if (width < 0) width = 0;
1608           if (precision < 0) precision = 0;
1609           }
1610         }
1611       else if (need > lim)
1612         {
1613         gstring_grow(g, width);
1614         lim = g->size - 1;
1615         gp = CS g->s + g->ptr;
1616         }
1617
1618       g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1619       if (fp[-1] == 'S')
1620         while (*gp) { *gp = tolower(*gp); gp++; }
1621       else if (fp[-1] == 'T')
1622         while (*gp) { *gp = toupper(*gp); gp++; }
1623
1624       if (truncated) return NULL;
1625       break;
1626       }
1627
1628     /* Some things are never used in Exim; also catches junk. */
1629
1630     default:
1631       strncpy(newformat, item_start, fp - item_start);
1632       newformat[fp-item_start] = 0;
1633       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1634         "in \"%s\" in \"%s\"", newformat, format);
1635       break;
1636     }
1637   }
1638
1639 if (g->ptr > g->size)
1640   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1641     "string_format internal error: caller %s %d", func, line);
1642 return g;
1643 }
1644
1645
1646
1647 #ifndef COMPILE_UTILITY
1648 /*************************************************
1649 *       Generate an "open failed" message        *
1650 *************************************************/
1651
1652 /* This function creates a message after failure to open a file. It includes a
1653 string supplied as data, adds the strerror() text, and if the failure was
1654 "Permission denied", reads and includes the euid and egid.
1655
1656 Arguments:
1657   format        a text format string - deliberately not uschar *
1658   func          caller, for debug
1659   line          caller, for debug
1660   ...           arguments for the format string
1661
1662 Returns:        a message, in dynamic store
1663 */
1664
1665 uschar *
1666 string_open_failed_trc(const uschar * func, unsigned line,
1667   const char * format, ...)
1668 {
1669 va_list ap;
1670 gstring * g = string_get(1024);
1671
1672 g = string_catn(g, US"failed to open ", 15);
1673
1674 /* Use the checked formatting routine to ensure that the buffer
1675 does not overflow. It should not, since this is called only for internally
1676 specified messages. If it does, the message just gets truncated, and there
1677 doesn't seem much we can do about that. */
1678
1679 va_start(ap, format);
1680 (void) string_vformat_trc(g, func, line, STRING_SPRINTF_BUFFER_SIZE,
1681         SVFMT_REBUFFER, format, ap);
1682 va_end(ap);
1683
1684 g = string_catn(g, US": ", 2);
1685 g = string_cat(g, US strerror(errno));
1686
1687 if (errno == EACCES)
1688   {
1689   int save_errno = errno;
1690   g = string_fmt_append(g, " (euid=%ld egid=%ld)",
1691     (long int)geteuid(), (long int)getegid());
1692   errno = save_errno;
1693   }
1694 gstring_release_unused(g);
1695 return string_from_gstring(g);
1696 }
1697
1698
1699
1700
1701
1702 /* qsort(3), currently used to sort the environment variables
1703 for -bP environment output, needs a function to compare two pointers to string
1704 pointers. Here it is. */
1705
1706 int
1707 string_compare_by_pointer(const void *a, const void *b)
1708 {
1709 return Ustrcmp(* CUSS a, * CUSS b);
1710 }
1711 #endif /* COMPILE_UTILITY */
1712
1713
1714
1715
1716 /*************************************************
1717 **************************************************
1718 *             Stand-alone test program           *
1719 **************************************************
1720 *************************************************/
1721
1722 #ifdef STAND_ALONE
1723 int main(void)
1724 {
1725 uschar buffer[256];
1726
1727 printf("Testing is_ip_address\n");
1728 store_init();
1729
1730 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1731   {
1732   int offset;
1733   buffer[Ustrlen(buffer) - 1] = 0;
1734   printf("%d\n", string_is_ip_address(buffer, NULL));
1735   printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1736   }
1737
1738 printf("Testing string_nextinlist\n");
1739
1740 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1741   {
1742   uschar *list = buffer;
1743   uschar *lp1, *lp2;
1744   uschar item[256];
1745   int sep1 = 0;
1746   int sep2 = 0;
1747
1748   if (*list == '<')
1749     {
1750     sep1 = sep2 = list[1];
1751     list += 2;
1752     }
1753
1754   lp1 = lp2 = list;
1755   for (;;)
1756     {
1757     uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1758     uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1759
1760     if (item1 == NULL && item2 == NULL) break;
1761     if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1762       {
1763       printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1764         (item1 == NULL)? "NULL" : CS item1,
1765         (item2 == NULL)? "NULL" : CS item2);
1766       break;
1767       }
1768     else printf("  \"%s\"\n", CS item1);
1769     }
1770   }
1771
1772 /* This is a horrible lash-up, but it serves its purpose. */
1773
1774 printf("Testing string_format\n");
1775
1776 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1777   {
1778   void *args[3];
1779   long long llargs[3];
1780   double dargs[3];
1781   int dflag = 0;
1782   int llflag = 0;
1783   int n = 0;
1784   int count;
1785   int countset = 0;
1786   uschar format[256];
1787   uschar outbuf[256];
1788   uschar *s;
1789   buffer[Ustrlen(buffer) - 1] = 0;
1790
1791   s = Ustrchr(buffer, ',');
1792   if (s == NULL) s = buffer + Ustrlen(buffer);
1793
1794   Ustrncpy(format, buffer, s - buffer);
1795   format[s-buffer] = 0;
1796
1797   if (*s == ',') s++;
1798
1799   while (*s != 0)
1800     {
1801     uschar *ss = s;
1802     s = Ustrchr(ss, ',');
1803     if (s == NULL) s = ss + Ustrlen(ss);
1804
1805     if (isdigit(*ss))
1806       {
1807       Ustrncpy(outbuf, ss, s-ss);
1808       if (Ustrchr(outbuf, '.') != NULL)
1809         {
1810         dflag = 1;
1811         dargs[n++] = Ustrtod(outbuf, NULL);
1812         }
1813       else if (Ustrstr(outbuf, "ll") != NULL)
1814         {
1815         llflag = 1;
1816         llargs[n++] = strtoull(CS outbuf, NULL, 10);
1817         }
1818       else
1819         {
1820         args[n++] = (void *)Uatoi(outbuf);
1821         }
1822       }
1823
1824     else if (Ustrcmp(ss, "*") == 0)
1825       {
1826       args[n++] = (void *)(&count);
1827       countset = 1;
1828       }
1829
1830     else
1831       {
1832       uschar *sss = malloc(s - ss + 1);
1833       Ustrncpy(sss, ss, s-ss);
1834       args[n++] = sss;
1835       }
1836
1837     if (*s == ',') s++;
1838     }
1839
1840   if (!dflag && !llflag)
1841     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1842       args[0], args[1], args[2])? "True" : "False");
1843
1844   else if (dflag)
1845     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1846       dargs[0], dargs[1], dargs[2])? "True" : "False");
1847
1848   else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1849     llargs[0], llargs[1], llargs[2])? "True" : "False");
1850
1851   printf("%s\n", CS outbuf);
1852   if (countset) printf("count=%d\n", count);
1853   }
1854
1855 return 0;
1856 }
1857 #endif
1858
1859 /* End of string.c */