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