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