tidying
[exim.git] / src / src / string.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
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(const uschar **pp)
228 {
229 #ifdef COMPILE_UTILITY
230 const uschar *hex_digits= CUS"0123456789abcdef";
231 #endif
232 int ch;
233 const 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 const uschar *
288 string_printing2(const uschar *s, BOOL allow_tab)
289 {
290 int nonprintcount = 0;
291 int length = 0;
292 const 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((const uschar **)&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(const 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(const 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(const 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(const uschar **sptr)
643 {
644 const 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
721 "; format string was (%s)\nexpansion started '%.32s'",
722 sizeof(buffer), format, buffer);
723 va_end(ap);
724 return string_copy(buffer);
725 }
726
727
728
729 /*************************************************
730 * Case-independent strncmp() function *
731 *************************************************/
732
733 /*
734 Arguments:
735 s first string
736 t second string
737 n number of characters to compare
738
739 Returns: < 0, = 0, or > 0, according to the comparison
740 */
741
742 int
743 strncmpic(const uschar *s, const uschar *t, int n)
744 {
745 while (n--)
746 {
747 int c = tolower(*s++) - tolower(*t++);
748 if (c) return c;
749 }
750 return 0;
751 }
752
753
754 /*************************************************
755 * Case-independent strcmp() function *
756 *************************************************/
757
758 /*
759 Arguments:
760 s first string
761 t second string
762
763 Returns: < 0, = 0, or > 0, according to the comparison
764 */
765
766 int
767 strcmpic(const uschar *s, const uschar *t)
768 {
769 while (*s != 0)
770 {
771 int c = tolower(*s++) - tolower(*t++);
772 if (c != 0) return c;
773 }
774 return *t;
775 }
776
777
778 /*************************************************
779 * Case-independent strstr() function *
780 *************************************************/
781
782 /* The third argument specifies whether whitespace is required
783 to follow the matched string.
784
785 Arguments:
786 s string to search
787 t substring to search for
788 space_follows if TRUE, match only if whitespace follows
789
790 Returns: pointer to substring in string, or NULL if not found
791 */
792
793 uschar *
794 strstric(uschar *s, uschar *t, BOOL space_follows)
795 {
796 uschar *p = t;
797 uschar *yield = NULL;
798 int cl = tolower(*p);
799 int cu = toupper(*p);
800
801 while (*s)
802 {
803 if (*s == cl || *s == cu)
804 {
805 if (yield == NULL) yield = s;
806 if (*(++p) == 0)
807 {
808 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
809 yield = NULL;
810 p = t;
811 }
812 cl = tolower(*p);
813 cu = toupper(*p);
814 s++;
815 }
816 else if (yield != NULL)
817 {
818 yield = NULL;
819 p = t;
820 cl = tolower(*p);
821 cu = toupper(*p);
822 }
823 else s++;
824 }
825 return NULL;
826 }
827
828
829
830 #ifndef COMPILE_UTILITY
831 /*************************************************
832 * Get next string from separated list *
833 *************************************************/
834
835 /* Leading and trailing space is removed from each item. The separator in the
836 list is controlled by the int pointed to by the separator argument as follows:
837
838 If the value is > 0 it is used as the separator. This is typically used for
839 sublists such as slash-separated options. The value is always a printing
840 character.
841
842 (If the value is actually > UCHAR_MAX there is only one item in the list.
843 This is used for some cases when called via functions that sometimes
844 plough through lists, and sometimes are given single items.)
845
846 If the value is <= 0, the string is inspected for a leading <x, where x is an
847 ispunct() or an iscntrl() character. If found, x is used as the separator. If
848 not found:
849
850 (a) if separator == 0, ':' is used
851 (b) if separator <0, -separator is used
852
853 In all cases the value of the separator that is used is written back to the
854 int so that it is used on subsequent calls as we progress through the list.
855
856 A literal ispunct() separator can be represented in an item by doubling, but
857 there is no way to include an iscntrl() separator as part of the data.
858
859 Arguments:
860 listptr points to a pointer to the current start of the list; the
861 pointer gets updated to point after the end of the next item
862 separator a pointer to the separator character in an int (see above)
863 buffer where to put a copy of the next string in the list; or
864 NULL if the next string is returned in new memory
865 buflen when buffer is not NULL, the size of buffer; otherwise ignored
866
867 Returns: pointer to buffer, containing the next substring,
868 or NULL if no more substrings
869 */
870
871 uschar *
872 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
873 {
874 int sep = *separator;
875 const uschar *s = *listptr;
876 BOOL sep_is_special;
877
878 if (s == NULL) return NULL;
879
880 /* This allows for a fixed specified separator to be an iscntrl() character,
881 but at the time of implementation, this is never the case. However, it's best
882 to be conservative. */
883
884 while (isspace(*s) && *s != sep) s++;
885
886 /* A change of separator is permitted, so look for a leading '<' followed by an
887 allowed character. */
888
889 if (sep <= 0)
890 {
891 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
892 {
893 sep = s[1];
894 s += 2;
895 while (isspace(*s) && *s != sep) s++;
896 }
897 else
898 {
899 sep = (sep == 0)? ':' : -sep;
900 }
901 *separator = sep;
902 }
903
904 /* An empty string has no list elements */
905
906 if (*s == 0) return NULL;
907
908 /* Note whether whether or not the separator is an iscntrl() character. */
909
910 sep_is_special = iscntrl(sep);
911
912 /* Handle the case when a buffer is provided. */
913
914 if (buffer != NULL)
915 {
916 int p = 0;
917 for (; *s != 0; s++)
918 {
919 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
920 if (p < buflen - 1) buffer[p++] = *s;
921 }
922 while (p > 0 && isspace(buffer[p-1])) p--;
923 buffer[p] = 0;
924 }
925
926 /* Handle the case when a buffer is not provided. */
927
928 else
929 {
930 int size = 0;
931 int ptr = 0;
932 const uschar *ss;
933
934 /* We know that *s != 0 at this point. However, it might be pointing to a
935 separator, which could indicate an empty string, or (if an ispunct()
936 character) could be doubled to indicate a separator character as data at the
937 start of a string. Avoid getting working memory for an empty item. */
938
939 if (*s == sep)
940 {
941 s++;
942 if (*s != sep || sep_is_special)
943 {
944 *listptr = s;
945 return string_copy(US"");
946 }
947 }
948
949 /* Not an empty string; the first character is guaranteed to be a data
950 character. */
951
952 for (;;)
953 {
954 for (ss = s + 1; *ss != 0 && *ss != sep; ss++);
955 buffer = string_catn(buffer, &size, &ptr, s, ss-s);
956 s = ss;
957 if (*s == 0 || *(++s) != sep || sep_is_special) break;
958 }
959 while (ptr > 0 && isspace(buffer[ptr-1])) ptr--;
960 buffer[ptr] = 0;
961 }
962
963 /* Update the current pointer and return the new string */
964
965 *listptr = s;
966 return buffer;
967 }
968 #endif /* COMPILE_UTILITY */
969
970
971 #ifndef COMPILE_UTILITY
972 /************************************************
973 * Add element to separated list *
974 ************************************************/
975 /* This function is used to build a list, returning
976 an allocated null-terminated growable string. The
977 given element has any embedded seperator characters
978 doubled.
979
980 Arguments:
981 list points to the start of the list that is being built, or NULL
982 if this is a new list that has no contents yet
983 sep list seperator charactoer
984 ele new lement to be appended to the list
985
986 Returns: pointer to the start of the list, changed if copied for expansion.
987 */
988
989 uschar *
990 string_append_listele(uschar * list, uschar sep, const uschar * ele)
991 {
992 uschar * new = NULL;
993 int sz = 0, off = 0;
994 uschar * sp;
995
996 if (list)
997 {
998 new = string_cat (new, &sz, &off, list);
999 new = string_catn(new, &sz, &off, &sep, 1);
1000 }
1001
1002 while((sp = Ustrchr(ele, sep)))
1003 {
1004 new = string_catn(new, &sz, &off, ele, sp-ele+1);
1005 new = string_catn(new, &sz, &off, &sep, 1);
1006 ele = sp+1;
1007 }
1008 new = string_cat(new, &sz, &off, ele);
1009 new[off] = '\0';
1010 return new;
1011 }
1012
1013
1014 static const uschar *
1015 Ustrnchr(const uschar * s, int c, unsigned * len)
1016 {
1017 unsigned siz = *len;
1018 while (siz)
1019 {
1020 if (!*s) return NULL;
1021 if (*s == c)
1022 {
1023 *len = siz;
1024 return s;
1025 }
1026 s++;
1027 siz--;
1028 }
1029 return NULL;
1030 }
1031
1032 uschar *
1033 string_append_listele_n(uschar * list, uschar sep, const uschar * ele,
1034 unsigned len)
1035 {
1036 uschar * new = NULL;
1037 int sz = 0, off = 0;
1038 const uschar * sp;
1039
1040 if (list)
1041 {
1042 new = string_cat (new, &sz, &off, list);
1043 new = string_catn(new, &sz, &off, &sep, 1);
1044 }
1045
1046 while((sp = Ustrnchr(ele, sep, &len)))
1047 {
1048 new = string_catn(new, &sz, &off, ele, sp-ele+1);
1049 new = string_catn(new, &sz, &off, &sep, 1);
1050 ele = sp+1;
1051 len--;
1052 }
1053 new = string_catn(new, &sz, &off, ele, len);
1054 new[off] = '\0';
1055 return new;
1056 }
1057 #endif /* COMPILE_UTILITY */
1058
1059
1060
1061 #ifndef COMPILE_UTILITY
1062 /*************************************************
1063 * Add chars to string *
1064 *************************************************/
1065
1066 /* This function is used when building up strings of unknown length. Room is
1067 always left for a terminating zero to be added to the string that is being
1068 built. This function does not require the string that is being added to be NUL
1069 terminated, because the number of characters to add is given explicitly. It is
1070 sometimes called to extract parts of other strings.
1071
1072 Arguments:
1073 string points to the start of the string that is being built, or NULL
1074 if this is a new string that has no contents yet
1075 size points to a variable that holds the current capacity of the memory
1076 block (updated if changed)
1077 ptr points to a variable that holds the offset at which to add
1078 characters, updated to the new offset
1079 s points to characters to add
1080 count count of characters to add; must not exceed the length of s, if s
1081 is a C string. If -1 given, strlen(s) is used.
1082
1083 If string is given as NULL, *size and *ptr should both be zero.
1084
1085 Returns: pointer to the start of the string, changed if copied for expansion.
1086 Note that a NUL is not added, though space is left for one. This is
1087 because string_cat() is often called multiple times to build up a
1088 string - there's no point adding the NUL till the end.
1089
1090 */
1091 /* coverity[+alloc] */
1092
1093 uschar *
1094 string_catn(uschar *string, int *size, int *ptr, const uschar *s, int count)
1095 {
1096 int p = *ptr;
1097
1098 if (p + count >= *size)
1099 {
1100 int oldsize = *size;
1101
1102 /* Mostly, string_cat() is used to build small strings of a few hundred
1103 characters at most. There are times, however, when the strings are very much
1104 longer (for example, a lookup that returns a vast number of alias addresses).
1105 To try to keep things reasonable, we use increments whose size depends on the
1106 existing length of the string. */
1107
1108 int inc = (oldsize < 4096)? 100 : 1024;
1109 while (*size <= p + count) *size += inc;
1110
1111 /* New string */
1112
1113 if (string == NULL) string = store_get(*size);
1114
1115 /* Try to extend an existing allocation. If the result of calling
1116 store_extend() is false, either there isn't room in the current memory block,
1117 or this string is not the top item on the dynamic store stack. We then have
1118 to get a new chunk of store and copy the old string. When building large
1119 strings, it is helpful to call store_release() on the old string, to release
1120 memory blocks that have become empty. (The block will be freed if the string
1121 is at its start.) However, we can do this only if we know that the old string
1122 was the last item on the dynamic memory stack. This is the case if it matches
1123 store_last_get. */
1124
1125 else if (!store_extend(string, oldsize, *size))
1126 {
1127 BOOL release_ok = store_last_get[store_pool] == string;
1128 uschar *newstring = store_get(*size);
1129 memcpy(newstring, string, p);
1130 if (release_ok) store_release(string);
1131 string = newstring;
1132 }
1133 }
1134
1135 /* Because we always specify the exact number of characters to copy, we can
1136 use memcpy(), which is likely to be more efficient than strncopy() because the
1137 latter has to check for zero bytes.
1138
1139 The Coverity annotation deals with the lack of correlated variable tracking;
1140 common use is a null string and zero size and pointer, on first use for a
1141 string being built. The "if" above then allocates, but Coverity assume that
1142 the "if" might not happen and whines for a null-deref done by the memcpy(). */
1143
1144 /* coverity[deref_parm_field_in_call] */
1145 memcpy(string + p, s, count);
1146 *ptr = p + count;
1147 return string;
1148 }
1149
1150
1151 uschar *
1152 string_cat(uschar *string, int *size, int *ptr, const uschar *s)
1153 {
1154 return string_catn(string, size, ptr, s, Ustrlen(s));
1155 }
1156 #endif /* COMPILE_UTILITY */
1157
1158
1159
1160 #ifndef COMPILE_UTILITY
1161 /*************************************************
1162 * Append strings to another string *
1163 *************************************************/
1164
1165 /* This function can be used to build a string from many other strings.
1166 It calls string_cat() to do the dirty work.
1167
1168 Arguments:
1169 string points to the start of the string that is being built, or NULL
1170 if this is a new string that has no contents yet
1171 size points to a variable that holds the current capacity of the memory
1172 block (updated if changed)
1173 ptr points to a variable that holds the offset at which to add
1174 characters, updated to the new offset
1175 count the number of strings to append
1176 ... "count" uschar* arguments, which must be valid zero-terminated
1177 C strings
1178
1179 Returns: pointer to the start of the string, changed if copied for expansion.
1180 The string is not zero-terminated - see string_cat() above.
1181 */
1182
1183 uschar *
1184 string_append(uschar *string, int *size, int *ptr, int count, ...)
1185 {
1186 va_list ap;
1187 int i;
1188
1189 va_start(ap, count);
1190 for (i = 0; i < count; i++)
1191 {
1192 uschar *t = va_arg(ap, uschar *);
1193 string = string_cat(string, size, ptr, t);
1194 }
1195 va_end(ap);
1196
1197 return string;
1198 }
1199 #endif
1200
1201
1202
1203 /*************************************************
1204 * Format a string with length checks *
1205 *************************************************/
1206
1207 /* This function is used to format a string with checking of the length of the
1208 output for all conversions. It protects Exim from absent-mindedness when
1209 calling functions like debug_printf and string_sprintf, and elsewhere. There
1210 are two different entry points to what is actually the same function, depending
1211 on whether the variable length list of data arguments are given explicitly or
1212 as a va_list item.
1213
1214 The formats are the usual printf() ones, with some omissions (never used) and
1215 two additions for strings: %S forces lower case, and %#s or %#S prints nothing
1216 for a NULL string. Without the # "NULL" is printed (useful in debugging). There
1217 is also the addition of %D and %M, which insert the date in the form used for
1218 datestamped log files.
1219
1220 Arguments:
1221 buffer a buffer in which to put the formatted string
1222 buflen the length of the buffer
1223 format the format string - deliberately char * and not uschar *
1224 ... or ap variable list of supplementary arguments
1225
1226 Returns: TRUE if the result fitted in the buffer
1227 */
1228
1229 BOOL
1230 string_format(uschar *buffer, int buflen, const char *format, ...)
1231 {
1232 BOOL yield;
1233 va_list ap;
1234 va_start(ap, format);
1235 yield = string_vformat(buffer, buflen, format, ap);
1236 va_end(ap);
1237 return yield;
1238 }
1239
1240
1241 BOOL
1242 string_vformat(uschar *buffer, int buflen, const char *format, va_list ap)
1243 {
1244 /* We assume numbered ascending order, C does not guarantee that */
1245 enum { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1246
1247 BOOL yield = TRUE;
1248 int width, precision;
1249 const char *fp = format; /* Deliberately not unsigned */
1250 uschar *p = buffer;
1251 uschar *last = buffer + buflen - 1;
1252
1253 string_datestamp_offset = -1; /* Datestamp not inserted */
1254 string_datestamp_length = 0; /* Datestamp not inserted */
1255 string_datestamp_type = 0; /* Datestamp not inserted */
1256
1257 /* Scan the format and handle the insertions */
1258
1259 while (*fp != 0)
1260 {
1261 int length = L_NORMAL;
1262 int *nptr;
1263 int slen;
1264 const char *null = "NULL"; /* ) These variables */
1265 const char *item_start, *s; /* ) are deliberately */
1266 char newformat[16]; /* ) not unsigned */
1267
1268 /* Non-% characters just get copied verbatim */
1269
1270 if (*fp != '%')
1271 {
1272 if (p >= last) { yield = FALSE; break; }
1273 *p++ = (uschar)*fp++;
1274 continue;
1275 }
1276
1277 /* Deal with % characters. Pick off the width and precision, for checking
1278 strings, skipping over the flag and modifier characters. */
1279
1280 item_start = fp;
1281 width = precision = -1;
1282
1283 if (strchr("-+ #0", *(++fp)) != NULL)
1284 {
1285 if (*fp == '#') null = "";
1286 fp++;
1287 }
1288
1289 if (isdigit((uschar)*fp))
1290 {
1291 width = *fp++ - '0';
1292 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1293 }
1294 else if (*fp == '*')
1295 {
1296 width = va_arg(ap, int);
1297 fp++;
1298 }
1299
1300 if (*fp == '.')
1301 {
1302 if (*(++fp) == '*')
1303 {
1304 precision = va_arg(ap, int);
1305 fp++;
1306 }
1307 else
1308 {
1309 precision = 0;
1310 while (isdigit((uschar)*fp))
1311 precision = precision*10 + *fp++ - '0';
1312 }
1313 }
1314
1315 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1316
1317 if (*fp == 'h')
1318 { fp++; length = L_SHORT; }
1319 else if (*fp == 'L')
1320 { fp++; length = L_LONGDOUBLE; }
1321 else if (*fp == 'l')
1322 {
1323 if (fp[1] == 'l')
1324 {
1325 fp += 2;
1326 length = L_LONGLONG;
1327 }
1328 else
1329 {
1330 fp++;
1331 length = L_LONG;
1332 }
1333 }
1334 else if (*fp == 'z')
1335 { fp++; length = L_SIZE; }
1336
1337 /* Handle each specific format type. */
1338
1339 switch (*fp++)
1340 {
1341 case 'n':
1342 nptr = va_arg(ap, int *);
1343 *nptr = p - buffer;
1344 break;
1345
1346 case 'd':
1347 case 'o':
1348 case 'u':
1349 case 'x':
1350 case 'X':
1351 if (p >= last - ((length > L_LONG)? 24 : 12))
1352 { yield = FALSE; goto END_FORMAT; }
1353 strncpy(newformat, item_start, fp - item_start);
1354 newformat[fp - item_start] = 0;
1355
1356 /* Short int is promoted to int when passing through ..., so we must use
1357 int for va_arg(). */
1358
1359 switch(length)
1360 {
1361 case L_SHORT:
1362 case L_NORMAL: sprintf(CS p, newformat, va_arg(ap, int)); break;
1363 case L_LONG: sprintf(CS p, newformat, va_arg(ap, long int)); break;
1364 case L_LONGLONG: sprintf(CS p, newformat, va_arg(ap, LONGLONG_T)); break;
1365 case L_SIZE: sprintf(CS p, newformat, va_arg(ap, size_t)); break;
1366 }
1367 while (*p) p++;
1368 break;
1369
1370 case 'p':
1371 if (p >= last - 24) { yield = FALSE; goto END_FORMAT; }
1372 strncpy(newformat, item_start, fp - item_start);
1373 newformat[fp - item_start] = 0;
1374 sprintf(CS p, newformat, va_arg(ap, void *));
1375 while (*p) p++;
1376 break;
1377
1378 /* %f format is inherently insecure if the numbers that it may be
1379 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1380 printing load averages, and these are actually stored as integers
1381 (load average * 1000) so the size of the numbers is constrained.
1382 It is also used for formatting sending rates, where the simplicity
1383 of the format prevents overflow. */
1384
1385 case 'f':
1386 case 'e':
1387 case 'E':
1388 case 'g':
1389 case 'G':
1390 if (precision < 0) precision = 6;
1391 if (p >= last - precision - 8) { yield = FALSE; goto END_FORMAT; }
1392 strncpy(newformat, item_start, fp - item_start);
1393 newformat[fp-item_start] = 0;
1394 if (length == L_LONGDOUBLE)
1395 sprintf(CS p, newformat, va_arg(ap, long double));
1396 else
1397 sprintf(CS p, newformat, va_arg(ap, double));
1398 while (*p) p++;
1399 break;
1400
1401 /* String types */
1402
1403 case '%':
1404 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1405 *p++ = '%';
1406 break;
1407
1408 case 'c':
1409 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1410 *p++ = va_arg(ap, int);
1411 break;
1412
1413 case 'D': /* Insert daily datestamp for log file names */
1414 s = CS tod_stamp(tod_log_datestamp_daily);
1415 string_datestamp_offset = p - buffer; /* Passed back via global */
1416 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1417 string_datestamp_type = tod_log_datestamp_daily;
1418 slen = string_datestamp_length;
1419 goto INSERT_STRING;
1420
1421 case 'M': /* Insert monthly datestamp for log file names */
1422 s = CS tod_stamp(tod_log_datestamp_monthly);
1423 string_datestamp_offset = p - buffer; /* Passed back via global */
1424 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1425 string_datestamp_type = tod_log_datestamp_monthly;
1426 slen = string_datestamp_length;
1427 goto INSERT_STRING;
1428
1429 case 's':
1430 case 'S': /* Forces *lower* case */
1431 s = va_arg(ap, char *);
1432
1433 if (s == NULL) s = null;
1434 slen = Ustrlen(s);
1435
1436 INSERT_STRING: /* Come to from %D or %M above */
1437
1438 /* If the width is specified, check that there is a precision
1439 set; if not, set it to the width to prevent overruns of long
1440 strings. */
1441
1442 if (width >= 0)
1443 {
1444 if (precision < 0) precision = width;
1445 }
1446
1447 /* If a width is not specified and the precision is specified, set
1448 the width to the precision, or the string length if shorted. */
1449
1450 else if (precision >= 0)
1451 {
1452 width = (precision < slen)? precision : slen;
1453 }
1454
1455 /* If neither are specified, set them both to the string length. */
1456
1457 else width = precision = slen;
1458
1459 /* Check string space, and add the string to the buffer if ok. If
1460 not OK, add part of the string (debugging uses this to show as
1461 much as possible). */
1462
1463 if (p == last)
1464 {
1465 yield = FALSE;
1466 goto END_FORMAT;
1467 }
1468 if (p >= last - width)
1469 {
1470 yield = FALSE;
1471 width = precision = last - p - 1;
1472 if (width < 0) width = 0;
1473 if (precision < 0) precision = 0;
1474 }
1475 sprintf(CS p, "%*.*s", width, precision, s);
1476 if (fp[-1] == 'S')
1477 while (*p) { *p = tolower(*p); p++; }
1478 else
1479 while (*p) p++;
1480 if (!yield) goto END_FORMAT;
1481 break;
1482
1483 /* Some things are never used in Exim; also catches junk. */
1484
1485 default:
1486 strncpy(newformat, item_start, fp - item_start);
1487 newformat[fp-item_start] = 0;
1488 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1489 "in \"%s\" in \"%s\"", newformat, format);
1490 break;
1491 }
1492 }
1493
1494 /* Ensure string is complete; return TRUE if got to the end of the format */
1495
1496 END_FORMAT:
1497
1498 *p = 0;
1499 return yield;
1500 }
1501
1502
1503
1504 #ifndef COMPILE_UTILITY
1505 /*************************************************
1506 * Generate an "open failed" message *
1507 *************************************************/
1508
1509 /* This function creates a message after failure to open a file. It includes a
1510 string supplied as data, adds the strerror() text, and if the failure was
1511 "Permission denied", reads and includes the euid and egid.
1512
1513 Arguments:
1514 eno the value of errno after the failure
1515 format a text format string - deliberately not uschar *
1516 ... arguments for the format string
1517
1518 Returns: a message, in dynamic store
1519 */
1520
1521 uschar *
1522 string_open_failed(int eno, const char *format, ...)
1523 {
1524 va_list ap;
1525 uschar buffer[1024];
1526
1527 Ustrcpy(buffer, "failed to open ");
1528 va_start(ap, format);
1529
1530 /* Use the checked formatting routine to ensure that the buffer
1531 does not overflow. It should not, since this is called only for internally
1532 specified messages. If it does, the message just gets truncated, and there
1533 doesn't seem much we can do about that. */
1534
1535 (void)string_vformat(buffer+15, sizeof(buffer) - 15, format, ap);
1536 va_end(ap);
1537
1538 return (eno == EACCES)?
1539 string_sprintf("%s: %s (euid=%ld egid=%ld)", buffer, strerror(eno),
1540 (long int)geteuid(), (long int)getegid()) :
1541 string_sprintf("%s: %s", buffer, strerror(eno));
1542 }
1543 #endif /* COMPILE_UTILITY */
1544
1545
1546
1547
1548
1549 #ifndef COMPILE_UTILITY
1550 /* qsort(3), currently used to sort the environment variables
1551 for -bP environment output, needs a function to compare two pointers to string
1552 pointers. Here it is. */
1553
1554 int
1555 string_compare_by_pointer(const void *a, const void *b)
1556 {
1557 return Ustrcmp(* CUSS a, * CUSS b);
1558 }
1559 #endif /* COMPILE_UTILITY */
1560
1561
1562
1563 /*************************************************
1564 **************************************************
1565 * Stand-alone test program *
1566 **************************************************
1567 *************************************************/
1568
1569 #ifdef STAND_ALONE
1570 int main(void)
1571 {
1572 uschar buffer[256];
1573
1574 printf("Testing is_ip_address\n");
1575
1576 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1577 {
1578 int offset;
1579 buffer[Ustrlen(buffer) - 1] = 0;
1580 printf("%d\n", string_is_ip_address(buffer, NULL));
1581 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1582 }
1583
1584 printf("Testing string_nextinlist\n");
1585
1586 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1587 {
1588 uschar *list = buffer;
1589 uschar *lp1, *lp2;
1590 uschar item[256];
1591 int sep1 = 0;
1592 int sep2 = 0;
1593
1594 if (*list == '<')
1595 {
1596 sep1 = sep2 = list[1];
1597 list += 2;
1598 }
1599
1600 lp1 = lp2 = list;
1601 for (;;)
1602 {
1603 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1604 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1605
1606 if (item1 == NULL && item2 == NULL) break;
1607 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1608 {
1609 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1610 (item1 == NULL)? "NULL" : CS item1,
1611 (item2 == NULL)? "NULL" : CS item2);
1612 break;
1613 }
1614 else printf(" \"%s\"\n", CS item1);
1615 }
1616 }
1617
1618 /* This is a horrible lash-up, but it serves its purpose. */
1619
1620 printf("Testing string_format\n");
1621
1622 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1623 {
1624 void *args[3];
1625 long long llargs[3];
1626 double dargs[3];
1627 int dflag = 0;
1628 int llflag = 0;
1629 int n = 0;
1630 int count;
1631 int countset = 0;
1632 uschar format[256];
1633 uschar outbuf[256];
1634 uschar *s;
1635 buffer[Ustrlen(buffer) - 1] = 0;
1636
1637 s = Ustrchr(buffer, ',');
1638 if (s == NULL) s = buffer + Ustrlen(buffer);
1639
1640 Ustrncpy(format, buffer, s - buffer);
1641 format[s-buffer] = 0;
1642
1643 if (*s == ',') s++;
1644
1645 while (*s != 0)
1646 {
1647 uschar *ss = s;
1648 s = Ustrchr(ss, ',');
1649 if (s == NULL) s = ss + Ustrlen(ss);
1650
1651 if (isdigit(*ss))
1652 {
1653 Ustrncpy(outbuf, ss, s-ss);
1654 if (Ustrchr(outbuf, '.') != NULL)
1655 {
1656 dflag = 1;
1657 dargs[n++] = Ustrtod(outbuf, NULL);
1658 }
1659 else if (Ustrstr(outbuf, "ll") != NULL)
1660 {
1661 llflag = 1;
1662 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1663 }
1664 else
1665 {
1666 args[n++] = (void *)Uatoi(outbuf);
1667 }
1668 }
1669
1670 else if (Ustrcmp(ss, "*") == 0)
1671 {
1672 args[n++] = (void *)(&count);
1673 countset = 1;
1674 }
1675
1676 else
1677 {
1678 uschar *sss = malloc(s - ss + 1);
1679 Ustrncpy(sss, ss, s-ss);
1680 args[n++] = sss;
1681 }
1682
1683 if (*s == ',') s++;
1684 }
1685
1686 if (!dflag && !llflag)
1687 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1688 args[0], args[1], args[2])? "True" : "False");
1689
1690 else if (dflag)
1691 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1692 dargs[0], dargs[1], dargs[2])? "True" : "False");
1693
1694 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1695 llargs[0], llargs[1], llargs[2])? "True" : "False");
1696
1697 printf("%s\n", CS outbuf);
1698 if (countset) printf("count=%d\n", count);
1699 }
1700
1701 return 0;
1702 }
1703 #endif
1704
1705 /* End of string.c */