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