afdb517a25e146bd4d64e114c3eb2117cb324ed9
[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 */
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 != 0)
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 /* This function assumes that memcpy() is faster than strcpy().
437 As above, but explicitly specifying the result taint status
438 */
439
440 uschar *
441 string_copy_taint_function(const uschar * s, BOOL tainted)
442 {
443 int len = Ustrlen(s) + 1;
444 uschar *ss = store_get(len, tainted);
445 memcpy(ss, s, len);
446 return ss;
447 }
448
449
450
451 /*************************************************
452 *       Copy and save string, given length       *
453 *************************************************/
454
455 /* It is assumed the data contains no zeros. A zero is added
456 onto the end.
457
458 Arguments:
459   s         string to copy
460   n         number of characters
461
462 Returns:    copy of string in new store
463 */
464
465 uschar *
466 string_copyn_function(const uschar *s, int n)
467 {
468 uschar *ss = store_get(n + 1, is_tainted(s));
469 Ustrncpy(ss, s, n);
470 ss[n] = 0;
471 return ss;
472 }
473 #endif
474
475
476 /*************************************************
477 *     Copy and save string in malloc'd store     *
478 *************************************************/
479
480 /* This function assumes that memcpy() is faster than strcpy().
481
482 Argument: string to copy
483 Returns:  copy of string in new store
484 */
485
486 uschar *
487 string_copy_malloc(const uschar *s)
488 {
489 int len = Ustrlen(s) + 1;
490 uschar *ss = store_malloc(len);
491 memcpy(ss, s, len);
492 return ss;
493 }
494
495
496
497 /*************************************************
498 *    Copy string if long, inserting newlines     *
499 *************************************************/
500
501 /* If the given string is longer than 75 characters, it is copied, and within
502 the copy, certain space characters are converted into newlines.
503
504 Argument:  pointer to the string
505 Returns:   pointer to the possibly altered string
506 */
507
508 uschar *
509 string_split_message(uschar *msg)
510 {
511 uschar *s, *ss;
512
513 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
514 s = ss = msg = string_copy(msg);
515
516 for (;;)
517   {
518   int i = 0;
519   while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
520   if (*ss == 0) break;
521   if (*ss == '\n')
522     s = ++ss;
523   else
524     {
525     uschar *t = ss + 1;
526     uschar *tt = NULL;
527     while (--t > s + 35)
528       {
529       if (*t == ' ')
530         {
531         if (t[-1] == ':') { tt = t; break; }
532         if (tt == NULL) tt = t;
533         }
534       }
535
536     if (tt == NULL)          /* Can't split behind - try ahead */
537       {
538       t = ss + 1;
539       while (*t != 0)
540         {
541         if (*t == ' ' || *t == '\n')
542           { tt = t; break; }
543         t++;
544         }
545       }
546
547     if (tt == NULL) break;   /* Can't find anywhere to split */
548     *tt = '\n';
549     s = ss = tt+1;
550     }
551   }
552
553 return msg;
554 }
555
556
557
558 /*************************************************
559 *   Copy returned DNS domain name, de-escaping   *
560 *************************************************/
561
562 /* If a domain name contains top-bit characters, some resolvers return
563 the fully qualified name with those characters turned into escapes. The
564 convention is a backslash followed by _decimal_ digits. We convert these
565 back into the original binary values. This will be relevant when
566 allow_utf8_domains is set true and UTF-8 characters are used in domain
567 names. Backslash can also be used to escape other characters, though we
568 shouldn't come across them in domain names.
569
570 Argument:   the domain name string
571 Returns:    copy of string in new store, de-escaped
572 */
573
574 uschar *
575 string_copy_dnsdomain(uschar *s)
576 {
577 uschar *yield;
578 uschar *ss = yield = store_get(Ustrlen(s) + 1, TRUE);   /* always treat as tainted */
579
580 while (*s != 0)
581   {
582   if (*s != '\\')
583     *ss++ = *s++;
584   else if (isdigit(s[1]))
585     {
586     *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
587     s += 4;
588     }
589   else if (*(++s) != 0)
590     *ss++ = *s++;
591   }
592
593 *ss = 0;
594 return yield;
595 }
596
597
598 #ifndef COMPILE_UTILITY
599 /*************************************************
600 *     Copy space-terminated or quoted string     *
601 *************************************************/
602
603 /* This function copies from a string until its end, or until whitespace is
604 encountered, unless the string begins with a double quote, in which case the
605 terminating quote is sought, and escaping within the string is done. The length
606 of a de-quoted string can be no longer than the original, since escaping always
607 turns n characters into 1 character.
608
609 Argument:  pointer to the pointer to the first character, which gets updated
610 Returns:   the new string
611 */
612
613 uschar *
614 string_dequote(const uschar **sptr)
615 {
616 const uschar *s = *sptr;
617 uschar *t, *yield;
618
619 /* First find the end of the string */
620
621 if (*s != '\"')
622   while (*s != 0 && !isspace(*s)) s++;
623 else
624   {
625   s++;
626   while (*s && *s != '\"')
627     {
628     if (*s == '\\') (void)string_interpret_escape(&s);
629     s++;
630     }
631   if (*s) s++;
632   }
633
634 /* Get enough store to copy into */
635
636 t = yield = store_get(s - *sptr + 1, is_tainted(*sptr));
637 s = *sptr;
638
639 /* Do the copy */
640
641 if (*s != '\"')
642   while (*s != 0 && !isspace(*s)) *t++ = *s++;
643 else
644   {
645   s++;
646   while (*s != 0 && *s != '\"')
647     {
648     *t++ = *s == '\\' ? string_interpret_escape(&s) : *s;
649     s++;
650     }
651   if (*s) s++;
652   }
653
654 /* Update the pointer and return the terminated copy */
655
656 *sptr = s;
657 *t = 0;
658 return yield;
659 }
660 #endif  /* COMPILE_UTILITY */
661
662
663
664 /*************************************************
665 *          Format a string and save it           *
666 *************************************************/
667
668 /* The formatting is done by string_vformat, which checks the length of
669 everything.  Taint is taken from the worst of the arguments.
670
671 Arguments:
672   format    a printf() format - deliberately char * rather than uschar *
673               because it will most usually be a literal string
674   ...       arguments for format
675
676 Returns:    pointer to fresh piece of store containing sprintf'ed string
677 */
678
679 uschar *
680 string_sprintf_trc(const char *format, const uschar * func, unsigned line, ...)
681 {
682 #ifdef COMPILE_UTILITY
683 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
684 gstring gs = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
685 gstring * g = &gs;
686 unsigned flags = 0;
687 #else
688 gstring * g = NULL;
689 unsigned flags = SVFMT_REBUFFER|SVFMT_EXTEND;
690 #endif
691
692 va_list ap;
693 va_start(ap, line);
694 g = string_vformat_trc(g, func, line, STRING_SPRINTF_BUFFER_SIZE,
695         flags, format, ap);
696 va_end(ap);
697
698 if (!g)
699   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
700     "string_sprintf expansion was longer than %d; format string was (%s)\n"
701     " called from %s %d\n",
702     STRING_SPRINTF_BUFFER_SIZE, format, func, line);
703
704 #ifdef COMPILE_UTILITY
705 return string_copyn(g->s, g->ptr);
706 #else
707 gstring_release_unused(g);
708 return string_from_gstring(g);
709 #endif
710 }
711
712
713
714 /*************************************************
715 *         Case-independent strncmp() function    *
716 *************************************************/
717
718 /*
719 Arguments:
720   s         first string
721   t         second string
722   n         number of characters to compare
723
724 Returns:    < 0, = 0, or > 0, according to the comparison
725 */
726
727 int
728 strncmpic(const uschar *s, const uschar *t, int n)
729 {
730 while (n--)
731   {
732   int c = tolower(*s++) - tolower(*t++);
733   if (c) return c;
734   }
735 return 0;
736 }
737
738
739 /*************************************************
740 *         Case-independent strcmp() function     *
741 *************************************************/
742
743 /*
744 Arguments:
745   s         first string
746   t         second string
747
748 Returns:    < 0, = 0, or > 0, according to the comparison
749 */
750
751 int
752 strcmpic(const uschar *s, const uschar *t)
753 {
754 while (*s != 0)
755   {
756   int c = tolower(*s++) - tolower(*t++);
757   if (c != 0) return c;
758   }
759 return *t;
760 }
761
762
763 /*************************************************
764 *         Case-independent strstr() function     *
765 *************************************************/
766
767 /* The third argument specifies whether whitespace is required
768 to follow the matched string.
769
770 Arguments:
771   s              string to search
772   t              substring to search for
773   space_follows  if TRUE, match only if whitespace follows
774
775 Returns:         pointer to substring in string, or NULL if not found
776 */
777
778 uschar *
779 strstric(uschar *s, uschar *t, BOOL space_follows)
780 {
781 uschar *p = t;
782 uschar *yield = NULL;
783 int cl = tolower(*p);
784 int cu = toupper(*p);
785
786 while (*s)
787   {
788   if (*s == cl || *s == cu)
789     {
790     if (yield == NULL) yield = s;
791     if (*(++p) == 0)
792       {
793       if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
794       yield = NULL;
795       p = t;
796       }
797     cl = tolower(*p);
798     cu = toupper(*p);
799     s++;
800     }
801   else if (yield != NULL)
802     {
803     yield = NULL;
804     p = t;
805     cl = tolower(*p);
806     cu = toupper(*p);
807     }
808   else s++;
809   }
810 return NULL;
811 }
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 Returns:     pointer to buffer, containing the next substring,
867              or NULL if no more substrings
868 */
869
870 uschar *
871 string_nextinlist_trc(const uschar **listptr, int *separator, uschar *buffer, int buflen,
872  const uschar * func, int line)
873 {
874 int sep = *separator;
875 const uschar *s = *listptr;
876 BOOL sep_is_special;
877
878 if (!s) return NULL;
879
880 /* This allows for a fixed specified separator to be an iscntrl() character,
881 but at the time of implementation, this is never the case. However, it's best
882 to be conservative. */
883
884 while (isspace(*s) && *s != sep) s++;
885
886 /* A change of separator is permitted, so look for a leading '<' followed by an
887 allowed character. */
888
889 if (sep <= 0)
890   {
891   if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
892     {
893     sep = s[1];
894     if (*++s) ++s;
895     while (isspace(*s) && *s != sep) s++;
896     }
897   else
898     sep = sep ? -sep : ':';
899   *separator = sep;
900   }
901
902 /* An empty string has no list elements */
903
904 if (!*s) return NULL;
905
906 /* Note whether whether or not the separator is an iscntrl() character. */
907
908 sep_is_special = iscntrl(sep);
909
910 /* Handle the case when a buffer is provided. */
911
912 if (buffer)
913   {
914   int p = 0;
915   if (is_tainted(s) && !is_tainted(buffer))
916     die_tainted(US"string_nextinlist", func, line);
917   for (; *s; s++)
918     {
919     if (*s == sep && (*(++s) != sep || sep_is_special)) break;
920     if (p < buflen - 1) buffer[p++] = *s;
921     }
922   while (p > 0 && isspace(buffer[p-1])) p--;
923   buffer[p] = '\0';
924   }
925
926 /* Handle the case when a buffer is not provided. */
927
928 else
929   {
930   gstring * g = NULL;
931
932   /* We know that *s != 0 at this point. However, it might be pointing to a
933   separator, which could indicate an empty string, or (if an ispunct()
934   character) could be doubled to indicate a separator character as data at the
935   start of a string. Avoid getting working memory for an empty item. */
936
937   if (*s == sep)
938     if (*++s != sep || sep_is_special)
939       {
940       *listptr = s;
941       return string_copy(US"");
942       }
943
944   /* Not an empty string; the first character is guaranteed to be a data
945   character. */
946
947   for (;;)
948     {
949     const uschar * ss;
950     for (ss = s + 1; *ss && *ss != sep; ) ss++;
951     g = string_catn(g, s, ss-s);
952     s = ss;
953     if (!*s || *++s != sep || sep_is_special) break;
954     }
955   /* while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--; */
956   while (  g->ptr > 0 && isspace(g->s[g->ptr-1])
957         && (g->ptr == 1 || g->s[g->ptr-2] != '\\') )
958     g->ptr--;
959   buffer = string_from_gstring(g);
960   gstring_release_unused(g);
961   }
962
963 /* Update the current pointer and return the new string */
964
965 *listptr = s;
966 return buffer;
967 }
968
969
970 static const uschar *
971 Ustrnchr(const uschar * s, int c, unsigned * len)
972 {
973 unsigned siz = *len;
974 while (siz)
975   {
976   if (!*s) return NULL;
977   if (*s == c)
978     {
979     *len = siz;
980     return s;
981     }
982   s++;
983   siz--;
984   }
985 return NULL;
986 }
987
988
989 /************************************************
990 *       Add element to separated list           *
991 ************************************************/
992 /* This function is used to build a list, returning an allocated null-terminated
993 growable string. The given element has any embedded separator characters
994 doubled.
995
996 Despite having the same growable-string interface as string_cat() the list is
997 always returned null-terminated.
998
999 Arguments:
1000   list  expanding-string for the list that is being built, or NULL
1001         if this is a new list that has no contents yet
1002   sep   list separator character
1003   ele   new element to be appended to the list
1004
1005 Returns:  pointer to the start of the list, changed if copied for expansion.
1006 */
1007
1008 gstring *
1009 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1010 {
1011 uschar * sp;
1012
1013 if (list && list->ptr)
1014   list = string_catn(list, &sep, 1);
1015
1016 while((sp = Ustrchr(ele, sep)))
1017   {
1018   list = string_catn(list, ele, sp-ele+1);
1019   list = string_catn(list, &sep, 1);
1020   ele = sp+1;
1021   }
1022 list = string_cat(list, ele);
1023 (void) string_from_gstring(list);
1024 return list;
1025 }
1026
1027
1028 gstring *
1029 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1030  unsigned len)
1031 {
1032 const uschar * sp;
1033
1034 if (list && list->ptr)
1035   list = string_catn(list, &sep, 1);
1036
1037 while((sp = Ustrnchr(ele, sep, &len)))
1038   {
1039   list = string_catn(list, ele, sp-ele+1);
1040   list = string_catn(list, &sep, 1);
1041   ele = sp+1;
1042   len--;
1043   }
1044 list = string_catn(list, ele, len);
1045 (void) string_from_gstring(list);
1046 return list;
1047 }
1048
1049
1050
1051 /* A slightly-bogus listmaker utility; the separator is a string so
1052 can be multiple chars - there is no checking for the element content
1053 containing any of the separator. */
1054
1055 gstring *
1056 string_append2_listele_n(gstring * list, const uschar * sepstr,
1057  const uschar * ele, unsigned len)
1058 {
1059 if (list && list->ptr)
1060   list = string_cat(list, sepstr);
1061
1062 list = string_catn(list, ele, len);
1063 (void) string_from_gstring(list);
1064 return list;
1065 }
1066
1067
1068
1069 /************************************************/
1070 /* Add more space to a growable-string.  The caller should check
1071 first if growth is required.  The gstring struct is modified on
1072 return; specifically, the string-base-pointer may have been changed.
1073
1074 Arguments:
1075   g             the growable-string
1076   count         amount needed for g->ptr to increase by
1077 */
1078
1079 static void
1080 gstring_grow(gstring * g, int count)
1081 {
1082 int p = g->ptr;
1083 int oldsize = g->size;
1084 BOOL tainted = is_tainted(g->s);
1085
1086 /* Mostly, string_cat() is used to build small strings of a few hundred
1087 characters at most. There are times, however, when the strings are very much
1088 longer (for example, a lookup that returns a vast number of alias addresses).
1089 To try to keep things reasonable, we use increments whose size depends on the
1090 existing length of the string. */
1091
1092 unsigned inc = oldsize < 4096 ? 127 : 1023;
1093
1094 if (count <= 0) return;
1095 g->size = (p + count + inc + 1) & ~inc;         /* one for a NUL */
1096
1097 /* Try to extend an existing allocation. If the result of calling
1098 store_extend() is false, either there isn't room in the current memory block,
1099 or this string is not the top item on the dynamic store stack. We then have
1100 to get a new chunk of store and copy the old string. When building large
1101 strings, it is helpful to call store_release() on the old string, to release
1102 memory blocks that have become empty. (The block will be freed if the string
1103 is at its start.) However, we can do this only if we know that the old string
1104 was the last item on the dynamic memory stack. This is the case if it matches
1105 store_last_get. */
1106
1107 if (!store_extend(g->s, tainted, oldsize, g->size))
1108   g->s = store_newblock(g->s, tainted, g->size, p);
1109 }
1110
1111
1112
1113 /*************************************************
1114 *             Add chars to string                *
1115 *************************************************/
1116 /* This function is used when building up strings of unknown length. Room is
1117 always left for a terminating zero to be added to the string that is being
1118 built. This function does not require the string that is being added to be NUL
1119 terminated, because the number of characters to add is given explicitly. It is
1120 sometimes called to extract parts of other strings.
1121
1122 Arguments:
1123   string   points to the start of the string that is being built, or NULL
1124              if this is a new string that has no contents yet
1125   s        points to characters to add
1126   count    count of characters to add; must not exceed the length of s, if s
1127              is a C string.
1128
1129 Returns:   pointer to the start of the string, changed if copied for expansion.
1130            Note that a NUL is not added, though space is left for one. This is
1131            because string_cat() is often called multiple times to build up a
1132            string - there's no point adding the NUL till the end.
1133
1134 */
1135 /* coverity[+alloc] */
1136
1137 gstring *
1138 string_catn(gstring * g, const uschar *s, int count)
1139 {
1140 int p;
1141 BOOL srctaint = is_tainted(s);
1142
1143 if (!g)
1144   {
1145   unsigned inc = count < 4096 ? 127 : 1023;
1146   unsigned size = ((count + inc) &  ~inc) + 1;
1147   g = string_get_tainted(size, srctaint);
1148   }
1149 else if (srctaint && !is_tainted(g->s))
1150   gstring_rebuffer(g);
1151
1152 p = g->ptr;
1153 if (p + count >= g->size)
1154   gstring_grow(g, count);
1155
1156 /* Because we always specify the exact number of characters to copy, we can
1157 use memcpy(), which is likely to be more efficient than strncopy() because the
1158 latter has to check for zero bytes. */
1159
1160 memcpy(g->s + p, s, count);
1161 g->ptr = p + count;
1162 return g;
1163 }
1164
1165
1166 gstring *
1167 string_cat(gstring *string, const uschar *s)
1168 {
1169 return string_catn(string, s, Ustrlen(s));
1170 }
1171
1172
1173
1174 /*************************************************
1175 *        Append strings to another string        *
1176 *************************************************/
1177
1178 /* This function can be used to build a string from many other strings.
1179 It calls string_cat() to do the dirty work.
1180
1181 Arguments:
1182   string   expanding-string that is being built, or NULL
1183              if this is a new string that has no contents yet
1184   count    the number of strings to append
1185   ...      "count" uschar* arguments, which must be valid zero-terminated
1186              C strings
1187
1188 Returns:   pointer to the start of the string, changed if copied for expansion.
1189            The string is not zero-terminated - see string_cat() above.
1190 */
1191
1192 __inline__ gstring *
1193 string_append(gstring *string, int count, ...)
1194 {
1195 va_list ap;
1196
1197 va_start(ap, count);
1198 while (count-- > 0)
1199   {
1200   uschar *t = va_arg(ap, uschar *);
1201   string = string_cat(string, t);
1202   }
1203 va_end(ap);
1204
1205 return string;
1206 }
1207 #endif
1208
1209
1210
1211 /*************************************************
1212 *        Format a string with length checks      *
1213 *************************************************/
1214
1215 /* This function is used to format a string with checking of the length of the
1216 output for all conversions. It protects Exim from absent-mindedness when
1217 calling functions like debug_printf and string_sprintf, and elsewhere. There
1218 are two different entry points to what is actually the same function, depending
1219 on whether the variable length list of data arguments are given explicitly or
1220 as a va_list item.
1221
1222 The formats are the usual printf() ones, with some omissions (never used) and
1223 three additions for strings: %S forces lower case, %T forces upper case, and
1224 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1225 (useful in debugging). There is also the addition of %D and %M, which insert
1226 the date in the form used for datestamped log files.
1227
1228 Arguments:
1229   buffer       a buffer in which to put the formatted string
1230   buflen       the length of the buffer
1231   format       the format string - deliberately char * and not uschar *
1232   ... or ap    variable list of supplementary arguments
1233
1234 Returns:       TRUE if the result fitted in the buffer
1235 */
1236
1237 BOOL
1238 string_format_trc(uschar * buffer, int buflen,
1239   const uschar * func, unsigned line, const char * format, ...)
1240 {
1241 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1242 va_list ap;
1243 va_start(ap, format);
1244 gp = string_vformat_trc(&g, func, line, STRING_SPRINTF_BUFFER_SIZE,
1245         0, format, ap);
1246 va_end(ap);
1247 g.s[g.ptr] = '\0';
1248 return !!gp;
1249 }
1250
1251
1252
1253
1254 /* Build or append to a growing-string, sprintf-style.
1255
1256 Arguments:
1257         g       a growable-string
1258         func    called-from function name, for debug
1259         line    called-from file line number, for debug
1260         limit   maximum string size
1261         flags   see below
1262         format  printf-like format string
1263         ap      variable-args pointer
1264
1265 Flags:
1266         SVFMT_EXTEND            buffer can be created or exteded as needed
1267         SVFMT_REBUFFER          buffer can be recopied to tainted mem as needed
1268         SVFMT_TAINT_NOCHK       do not check inputs for taint
1269
1270 If the "extend" flag is true, the string passed in can be NULL,
1271 empty, or non-empty.  Growing is subject to an overall limit given
1272 by the limit argument.
1273
1274 If the "extend" flag is false, the string passed in may not be NULL,
1275 will not be grown, and is usable in the original place after return.
1276 The return value can be NULL to signify overflow.
1277
1278 Returns the possibly-new (if copy for growth or taint-handling was needed)
1279 string, not nul-terminated.
1280 */
1281
1282 gstring *
1283 string_vformat_trc(gstring * g, const uschar * func, unsigned line,
1284   unsigned size_limit, unsigned flags, const char *format, va_list ap)
1285 {
1286 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1287
1288 int width, precision, off, lim, need;
1289 const char * fp = format;       /* Deliberately not unsigned */
1290 BOOL dest_tainted = FALSE;
1291
1292 string_datestamp_offset = -1;   /* Datestamp not inserted */
1293 string_datestamp_length = 0;    /* Datestamp not inserted */
1294 string_datestamp_type = 0;      /* Datestamp not inserted */
1295
1296 #ifdef COMPILE_UTILITY
1297 assert(!(flags & SVFMT_EXTEND));
1298 assert(g);
1299 #else
1300
1301 /* Ensure we have a string, to save on checking later */
1302 if (!g) g = string_get(16);
1303 else if (!(flags & SVFMT_TAINT_NOCHK)) dest_tainted = is_tainted(g->s);
1304
1305 if (!(flags & SVFMT_TAINT_NOCHK) && !dest_tainted && is_tainted(format))
1306   {
1307 #ifndef MACRO_PREDEF
1308   if (!(flags & SVFMT_REBUFFER))
1309     die_tainted(US"string_vformat", func, line);
1310 #endif
1311   gstring_rebuffer(g);
1312   dest_tainted = TRUE;
1313   }
1314 #endif  /*!COMPILE_UTILITY*/
1315
1316 lim = g->size - 1;      /* leave one for a nul */
1317 off = g->ptr;           /* remember initial offset in gstring */
1318
1319 /* Scan the format and handle the insertions */
1320
1321 while (*fp)
1322   {
1323   int length = L_NORMAL;
1324   int *nptr;
1325   int slen;
1326   const char *null = "NULL";            /* ) These variables */
1327   const char *item_start, *s;           /* ) are deliberately */
1328   char newformat[16];                   /* ) not unsigned */
1329   char * gp = CS g->s + g->ptr;         /* ) */
1330
1331   /* Non-% characters just get copied verbatim */
1332
1333   if (*fp != '%')
1334     {
1335     /* Avoid string_copyn() due to COMPILE_UTILITY */
1336     if ((need = g->ptr + 1) > lim)
1337       {
1338       if (!(flags & SVFMT_EXTEND) || need > size_limit) return NULL;
1339       gstring_grow(g, 1);
1340       lim = g->size - 1;
1341       }
1342     g->s[g->ptr++] = (uschar) *fp++;
1343     continue;
1344     }
1345
1346   /* Deal with % characters. Pick off the width and precision, for checking
1347   strings, skipping over the flag and modifier characters. */
1348
1349   item_start = fp;
1350   width = precision = -1;
1351
1352   if (strchr("-+ #0", *(++fp)) != NULL)
1353     {
1354     if (*fp == '#') null = "";
1355     fp++;
1356     }
1357
1358   if (isdigit((uschar)*fp))
1359     {
1360     width = *fp++ - '0';
1361     while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1362     }
1363   else if (*fp == '*')
1364     {
1365     width = va_arg(ap, int);
1366     fp++;
1367     }
1368
1369   if (*fp == '.')
1370     if (*(++fp) == '*')
1371       {
1372       precision = va_arg(ap, int);
1373       fp++;
1374       }
1375     else
1376       for (precision = 0; isdigit((uschar)*fp); fp++)
1377         precision = precision*10 + *fp - '0';
1378
1379   /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1380
1381   if (*fp == 'h')
1382     { fp++; length = L_SHORT; }
1383   else if (*fp == 'L')
1384     { fp++; length = L_LONGDOUBLE; }
1385   else if (*fp == 'l')
1386     if (fp[1] == 'l')
1387       { fp += 2; length = L_LONGLONG; }
1388     else
1389       { fp++; length = L_LONG; }
1390   else if (*fp == 'z')
1391     { fp++; length = L_SIZE; }
1392
1393   /* Handle each specific format type. */
1394
1395   switch (*fp++)
1396     {
1397     case 'n':
1398       nptr = va_arg(ap, int *);
1399       *nptr = g->ptr - off;
1400       break;
1401
1402     case 'd':
1403     case 'o':
1404     case 'u':
1405     case 'x':
1406     case 'X':
1407       width = length > L_LONG ? 24 : 12;
1408       if ((need = g->ptr + width) > lim)
1409         {
1410         if (!(flags & SVFMT_EXTEND) || need >= size_limit) return NULL;
1411         gstring_grow(g, width);
1412         lim = g->size - 1;
1413         gp = CS g->s + g->ptr;
1414         }
1415       strncpy(newformat, item_start, fp - item_start);
1416       newformat[fp - item_start] = 0;
1417
1418       /* Short int is promoted to int when passing through ..., so we must use
1419       int for va_arg(). */
1420
1421       switch(length)
1422         {
1423         case L_SHORT:
1424         case L_NORMAL:
1425           g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1426         case L_LONG:
1427           g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1428         case L_LONGLONG:
1429           g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1430         case L_SIZE:
1431           g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1432         }
1433       break;
1434
1435     case 'p':
1436       {
1437       void * ptr;
1438       if ((need = g->ptr + 24) > lim)
1439         {
1440         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1441         gstring_grow(g, 24);
1442         lim = g->size - 1;
1443         gp = CS g->s + g->ptr;
1444         }
1445       /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1446       Handle it explicitly. */
1447       if ((ptr = va_arg(ap, void *)))
1448         {
1449         strncpy(newformat, item_start, fp - item_start);
1450         newformat[fp - item_start] = 0;
1451         g->ptr += sprintf(gp, newformat, ptr);
1452         }
1453       else
1454         g->ptr += sprintf(gp, "(nil)");
1455       }
1456     break;
1457
1458     /* %f format is inherently insecure if the numbers that it may be
1459     handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1460     printing load averages, and these are actually stored as integers
1461     (load average * 1000) so the size of the numbers is constrained.
1462     It is also used for formatting sending rates, where the simplicity
1463     of the format prevents overflow. */
1464
1465     case 'f':
1466     case 'e':
1467     case 'E':
1468     case 'g':
1469     case 'G':
1470       if (precision < 0) precision = 6;
1471       if ((need = g->ptr + precision + 8) > lim)
1472         {
1473         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1474         gstring_grow(g, precision+8);
1475         lim = g->size - 1;
1476         gp = CS g->s + g->ptr;
1477         }
1478       strncpy(newformat, item_start, fp - item_start);
1479       newformat[fp-item_start] = 0;
1480       if (length == L_LONGDOUBLE)
1481         g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1482       else
1483         g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1484       break;
1485
1486     /* String types */
1487
1488     case '%':
1489       if ((need = g->ptr + 1) > lim)
1490         {
1491         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1492         gstring_grow(g, 1);
1493         lim = g->size - 1;
1494         }
1495       g->s[g->ptr++] = (uschar) '%';
1496       break;
1497
1498     case 'c':
1499       if ((need = g->ptr + 1) > lim)
1500         {
1501         if (!(flags & SVFMT_EXTEND || need >= size_limit)) return NULL;
1502         gstring_grow(g, 1);
1503         lim = g->size - 1;
1504         }
1505       g->s[g->ptr++] = (uschar) va_arg(ap, int);
1506       break;
1507
1508     case 'D':                   /* Insert daily datestamp for log file names */
1509       s = CS tod_stamp(tod_log_datestamp_daily);
1510       string_datestamp_offset = g->ptr;         /* Passed back via global */
1511       string_datestamp_length = Ustrlen(s);     /* Passed back via global */
1512       string_datestamp_type = tod_log_datestamp_daily;
1513       slen = string_datestamp_length;
1514       goto INSERT_STRING;
1515
1516     case 'M':                   /* Insert monthly datestamp for log file names */
1517       s = CS tod_stamp(tod_log_datestamp_monthly);
1518       string_datestamp_offset = g->ptr;         /* Passed back via global */
1519       string_datestamp_length = Ustrlen(s);     /* Passed back via global */
1520       string_datestamp_type = tod_log_datestamp_monthly;
1521       slen = string_datestamp_length;
1522       goto INSERT_STRING;
1523
1524     case 's':
1525     case 'S':                   /* Forces *lower* case */
1526     case 'T':                   /* Forces *upper* case */
1527       s = va_arg(ap, char *);
1528
1529       if (!s) s = null;
1530       slen = Ustrlen(s);
1531
1532       if (!(flags & SVFMT_TAINT_NOCHK) && !dest_tainted && is_tainted(s))
1533         if (flags & SVFMT_REBUFFER)
1534           {
1535           gstring_rebuffer(g);
1536           gp = CS g->s + g->ptr;
1537           dest_tainted = TRUE;
1538           }
1539 #ifndef MACRO_PREDEF
1540         else
1541           die_tainted(US"string_vformat", func, line);
1542 #endif
1543
1544     INSERT_STRING:              /* Come to from %D or %M above */
1545
1546       {
1547       BOOL truncated = FALSE;
1548
1549       /* If the width is specified, check that there is a precision
1550       set; if not, set it to the width to prevent overruns of long
1551       strings. */
1552
1553       if (width >= 0)
1554         {
1555         if (precision < 0) precision = width;
1556         }
1557
1558       /* If a width is not specified and the precision is specified, set
1559       the width to the precision, or the string length if shorted. */
1560
1561       else if (precision >= 0)
1562         width = precision < slen ? precision : slen;
1563
1564       /* If neither are specified, set them both to the string length. */
1565
1566       else
1567         width = precision = slen;
1568
1569       if ((need = g->ptr + width) >= size_limit || !(flags & SVFMT_EXTEND))
1570         {
1571         if (g->ptr == lim) return NULL;
1572         if (need > lim)
1573           {
1574           truncated = TRUE;
1575           width = precision = lim - g->ptr - 1;
1576           if (width < 0) width = 0;
1577           if (precision < 0) precision = 0;
1578           }
1579         }
1580       else if (need > lim)
1581         {
1582         gstring_grow(g, width);
1583         lim = g->size - 1;
1584         gp = CS g->s + g->ptr;
1585         }
1586
1587       g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1588       if (fp[-1] == 'S')
1589         while (*gp) { *gp = tolower(*gp); gp++; }
1590       else if (fp[-1] == 'T')
1591         while (*gp) { *gp = toupper(*gp); gp++; }
1592
1593       if (truncated) return NULL;
1594       break;
1595       }
1596
1597     /* Some things are never used in Exim; also catches junk. */
1598
1599     default:
1600       strncpy(newformat, item_start, fp - item_start);
1601       newformat[fp-item_start] = 0;
1602       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1603         "in \"%s\" in \"%s\"", newformat, format);
1604       break;
1605     }
1606   }
1607
1608 if (g->ptr > g->size)
1609   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
1610     "string_format internal error: caller %s %d", func, line);
1611 return g;
1612 }
1613
1614
1615
1616 #ifndef COMPILE_UTILITY
1617 /*************************************************
1618 *       Generate an "open failed" message        *
1619 *************************************************/
1620
1621 /* This function creates a message after failure to open a file. It includes a
1622 string supplied as data, adds the strerror() text, and if the failure was
1623 "Permission denied", reads and includes the euid and egid.
1624
1625 Arguments:
1626   format        a text format string - deliberately not uschar *
1627   ...           arguments for the format string
1628
1629 Returns:        a message, in dynamic store
1630 */
1631
1632 uschar *
1633 string_open_failed_trc(const uschar * func, unsigned line,
1634   const char *format, ...)
1635 {
1636 va_list ap;
1637 gstring * g = string_get(1024);
1638
1639 g = string_catn(g, US"failed to open ", 15);
1640
1641 /* Use the checked formatting routine to ensure that the buffer
1642 does not overflow. It should not, since this is called only for internally
1643 specified messages. If it does, the message just gets truncated, and there
1644 doesn't seem much we can do about that. */
1645
1646 va_start(ap, format);
1647 (void) string_vformat_trc(g, func, line, STRING_SPRINTF_BUFFER_SIZE,
1648         SVFMT_REBUFFER, format, ap);
1649 va_end(ap);
1650
1651 g = string_catn(g, US": ", 2);
1652 g = string_cat(g, US strerror(errno));
1653
1654 if (errno == EACCES)
1655   {
1656   int save_errno = errno;
1657   g = string_fmt_append(g, " (euid=%ld egid=%ld)",
1658     (long int)geteuid(), (long int)getegid());
1659   errno = save_errno;
1660   }
1661 gstring_release_unused(g);
1662 return string_from_gstring(g);
1663 }
1664
1665
1666
1667
1668
1669 /* qsort(3), currently used to sort the environment variables
1670 for -bP environment output, needs a function to compare two pointers to string
1671 pointers. Here it is. */
1672
1673 int
1674 string_compare_by_pointer(const void *a, const void *b)
1675 {
1676 return Ustrcmp(* CUSS a, * CUSS b);
1677 }
1678 #endif /* COMPILE_UTILITY */
1679
1680
1681
1682
1683 /*************************************************
1684 **************************************************
1685 *             Stand-alone test program           *
1686 **************************************************
1687 *************************************************/
1688
1689 #ifdef STAND_ALONE
1690 int main(void)
1691 {
1692 uschar buffer[256];
1693
1694 printf("Testing is_ip_address\n");
1695 store_init();
1696
1697 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1698   {
1699   int offset;
1700   buffer[Ustrlen(buffer) - 1] = 0;
1701   printf("%d\n", string_is_ip_address(buffer, NULL));
1702   printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1703   }
1704
1705 printf("Testing string_nextinlist\n");
1706
1707 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1708   {
1709   uschar *list = buffer;
1710   uschar *lp1, *lp2;
1711   uschar item[256];
1712   int sep1 = 0;
1713   int sep2 = 0;
1714
1715   if (*list == '<')
1716     {
1717     sep1 = sep2 = list[1];
1718     list += 2;
1719     }
1720
1721   lp1 = lp2 = list;
1722   for (;;)
1723     {
1724     uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1725     uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1726
1727     if (item1 == NULL && item2 == NULL) break;
1728     if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1729       {
1730       printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1731         (item1 == NULL)? "NULL" : CS item1,
1732         (item2 == NULL)? "NULL" : CS item2);
1733       break;
1734       }
1735     else printf("  \"%s\"\n", CS item1);
1736     }
1737   }
1738
1739 /* This is a horrible lash-up, but it serves its purpose. */
1740
1741 printf("Testing string_format\n");
1742
1743 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1744   {
1745   void *args[3];
1746   long long llargs[3];
1747   double dargs[3];
1748   int dflag = 0;
1749   int llflag = 0;
1750   int n = 0;
1751   int count;
1752   int countset = 0;
1753   uschar format[256];
1754   uschar outbuf[256];
1755   uschar *s;
1756   buffer[Ustrlen(buffer) - 1] = 0;
1757
1758   s = Ustrchr(buffer, ',');
1759   if (s == NULL) s = buffer + Ustrlen(buffer);
1760
1761   Ustrncpy(format, buffer, s - buffer);
1762   format[s-buffer] = 0;
1763
1764   if (*s == ',') s++;
1765
1766   while (*s != 0)
1767     {
1768     uschar *ss = s;
1769     s = Ustrchr(ss, ',');
1770     if (s == NULL) s = ss + Ustrlen(ss);
1771
1772     if (isdigit(*ss))
1773       {
1774       Ustrncpy(outbuf, ss, s-ss);
1775       if (Ustrchr(outbuf, '.') != NULL)
1776         {
1777         dflag = 1;
1778         dargs[n++] = Ustrtod(outbuf, NULL);
1779         }
1780       else if (Ustrstr(outbuf, "ll") != NULL)
1781         {
1782         llflag = 1;
1783         llargs[n++] = strtoull(CS outbuf, NULL, 10);
1784         }
1785       else
1786         {
1787         args[n++] = (void *)Uatoi(outbuf);
1788         }
1789       }
1790
1791     else if (Ustrcmp(ss, "*") == 0)
1792       {
1793       args[n++] = (void *)(&count);
1794       countset = 1;
1795       }
1796
1797     else
1798       {
1799       uschar *sss = malloc(s - ss + 1);
1800       Ustrncpy(sss, ss, s-ss);
1801       args[n++] = sss;
1802       }
1803
1804     if (*s == ',') s++;
1805     }
1806
1807   if (!dflag && !llflag)
1808     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1809       args[0], args[1], args[2])? "True" : "False");
1810
1811   else if (dflag)
1812     printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1813       dargs[0], dargs[1], dargs[2])? "True" : "False");
1814
1815   else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1816     llargs[0], llargs[1], llargs[2])? "True" : "False");
1817
1818   printf("%s\n", CS outbuf);
1819   if (countset) printf("count=%d\n", count);
1820   }
1821
1822 return 0;
1823 }
1824 #endif
1825
1826 /* End of string.c */