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