1 /* $Cambridge: exim/src/src/string.c,v 1.13 2007/02/26 14:07:04 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2007 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Miscellaneous string-handling functions. Some are not required for
11 utilities and tests, and are cut out by the COMPILE_UTILITY macro. */
17 #ifndef COMPILE_UTILITY
18 /*************************************************
19 * Test for IP address *
20 *************************************************/
22 /* This used just to be a regular expression, but with IPv6 things are a bit
23 more complicated. If the address contains a colon, it is assumed to be a v6
24 address (assuming HAVE_IPV6 is set). If a mask is permitted and one is present,
25 and maskptr is not NULL, its offset is placed there.
29 maskptr NULL if no mask is permitted to follow
30 otherwise, points to an int where the offset of '/' is placed
31 if there is no / followed by trailing digits, *maskptr is set 0
33 Returns: 0 if the string is not a textual representation of an IP address
34 4 if it is an IPv4 address
35 6 if it is an IPv6 address
39 string_is_ip_address(uschar *s, int *maskptr)
44 /* If an optional mask is permitted, check for it. If found, pass back the
49 uschar *ss = s + Ustrlen(s);
51 if (s != ss && isdigit(*(--ss)))
53 while (ss > s && isdigit(ss[-1])) ss--;
54 if (ss > s && *(--ss) == '/') *maskptr = ss - s;
58 /* A colon anywhere in the string => IPv6 address */
60 if (Ustrchr(s, ':') != NULL)
62 BOOL had_double_colon = FALSE;
68 /* An IPv6 address must start with hex digit or double colon. A single
71 if (*s == ':' && *(++s) != ':') return 0;
73 /* Now read up to 8 components consisting of up to 4 hex digits each. There
74 may be one and only one appearance of double colon, which implies any number
75 of binary zero bits. The number of preceding components is held in count. */
77 for (count = 0; count < 8; count++)
79 /* If the end of the string is reached before reading 8 components, the
80 address is valid provided a double colon has been read. This also applies
81 if we hit the / that introduces a mask or the % that introduces the
82 interface specifier (scope id) of a link-local address. */
84 if (*s == 0 || *s == '%' || *s == '/') return had_double_colon? yield : 0;
86 /* If a component starts with an additional colon, we have hit a double
87 colon. This is permitted to appear once only, and counts as at least
88 one component. The final component may be of this form. */
92 if (had_double_colon) return 0;
93 had_double_colon = TRUE;
98 /* If the remainder of the string contains a dot but no colons, we
99 can expect a trailing IPv4 address. This is valid if either there has
100 been no double-colon and this is the 7th component (with the IPv4 address
101 being the 7th & 8th components), OR if there has been a double-colon
102 and fewer than 6 components. */
104 if (Ustrchr(s, ':') == NULL && Ustrchr(s, '.') != NULL)
106 if ((!had_double_colon && count != 6) ||
107 (had_double_colon && count > 6)) return 0;
113 /* Check for at least one and not more than 4 hex digits for this
116 if (!isxdigit(*s++)) return 0;
117 if (isxdigit(*s) && isxdigit(*(++s)) && isxdigit(*(++s))) s++;
119 /* If the component is terminated by colon and there is more to
120 follow, skip over the colon. If there is no more to follow the address is
123 if (*s == ':' && *(++s) == 0) return 0;
126 /* If about to handle a trailing IPv4 address, drop through. Otherwise
127 all is well if we are at the end of the string or at the mask or at a percent
128 sign, which introduces the interface specifier (scope id) of a link local
132 return (*s == 0 || *s == '%' ||
133 (*s == '/' && maskptr != NULL && *maskptr != 0))? yield : 0;
136 /* Test for IPv4 address, which may be the tail-end of an IPv6 address. */
138 for (i = 0; i < 4; i++)
140 if (i != 0 && *s++ != '.') return 0;
141 if (!isdigit(*s++)) return 0;
142 if (isdigit(*s) && isdigit(*(++s))) s++;
145 return (*s == 0 || (*s == '/' && maskptr != NULL && *maskptr != 0))?
148 #endif /* COMPILE_UTILITY */
151 /*************************************************
152 * Format message size *
153 *************************************************/
155 /* Convert a message size in bytes to printing form, rounding
156 according to the magnitude of the number. A value of zero causes
157 a string of spaces to be returned.
160 size the message size in bytes
161 buffer where to put the answer
163 Returns: pointer to the buffer
164 a string of exactly 5 characters is normally returned
168 string_format_size(int size, uschar *buffer)
170 if (size == 0) Ustrcpy(CS buffer, " ");
171 else if (size < 1024) sprintf(CS buffer, "%5d", size);
172 else if (size < 10*1024)
173 sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);
174 else if (size < 1024*1024)
175 sprintf(CS buffer, "%4dK", (size + 512)/1024);
176 else if (size < 10*1024*1024)
177 sprintf(CS buffer, "%4.1fM", (double)size / (1024.0 * 1024.0));
179 sprintf(CS buffer, "%4dM", (size + 512 * 1024)/(1024*1024));
185 #ifndef COMPILE_UTILITY
186 /*************************************************
187 * Convert a number to base 62 format *
188 *************************************************/
190 /* Convert a long integer into an ASCII base 62 string. For Cygwin the value of
191 BASE_62 is actually 36. Always return exactly 6 characters plus zero, in a
194 Argument: a long integer
195 Returns: pointer to base 62 string
199 string_base62(unsigned long int value)
201 static uschar yield[7];
202 uschar *p = yield + sizeof(yield) - 1;
206 *(--p) = base62_chars[value % BASE_62];
211 #endif /* COMPILE_UTILITY */
215 #ifndef COMPILE_UTILITY
216 /*************************************************
217 * Interpret escape sequence *
218 *************************************************/
220 /* This function is called from several places where escape sequences are to be
221 interpreted in strings.
224 pp points a pointer to the initiating "\" in the string;
225 the pointer gets updated to point to the final character
226 Returns: the value of the character escape
230 string_interpret_escape(uschar **pp)
235 if (isdigit(ch) && ch != '8' && ch != '9')
238 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
240 ch = ch * 8 + *(++p) - '0';
241 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
242 ch = ch * 8 + *(++p) - '0';
247 case 'n': ch = '\n'; break;
248 case 'r': ch = '\r'; break;
249 case 't': ch = '\t'; break;
255 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
256 if (isxdigit(p[1])) ch = ch * 16 +
257 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
264 #endif /* COMPILE_UTILITY */
268 #ifndef COMPILE_UTILITY
269 /*************************************************
270 * Ensure string is printable *
271 *************************************************/
273 /* This function is called for critical strings. It checks for any
274 non-printing characters, and if any are found, it makes a new copy
275 of the string with suitable escape sequences. It is most often called by the
276 macro string_printing(), which sets allow_tab TRUE.
280 allow_tab TRUE to allow tab as a printing character
282 Returns: string with non-printers encoded as printing sequences
286 string_printing2(uschar *s, BOOL allow_tab)
288 int nonprintcount = 0;
296 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
300 if (nonprintcount == 0) return s;
302 /* Get a new block of store guaranteed big enough to hold the
305 ss = store_get(length + nonprintcount * 4 + 1);
307 /* Copy everying, escaping non printers. */
315 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
320 case '\n': *tt++ = 'n'; break;
321 case '\r': *tt++ = 'r'; break;
322 case '\b': *tt++ = 'b'; break;
323 case '\v': *tt++ = 'v'; break;
324 case '\f': *tt++ = 'f'; break;
325 case '\t': *tt++ = 't'; break;
326 default: sprintf(CS tt, "%03o", *t); tt += 3; break;
334 #endif /* COMPILE_UTILITY */
339 /*************************************************
340 * Copy and save string *
341 *************************************************/
343 /* This function assumes that memcpy() is faster than strcpy().
345 Argument: string to copy
346 Returns: copy of string in new store
350 string_copy(uschar *s)
352 int len = Ustrlen(s) + 1;
353 uschar *ss = store_get(len);
360 /*************************************************
361 * Copy and save string in malloc'd store *
362 *************************************************/
364 /* This function assumes that memcpy() is faster than strcpy().
366 Argument: string to copy
367 Returns: copy of string in new store
371 string_copy_malloc(uschar *s)
373 int len = Ustrlen(s) + 1;
374 uschar *ss = store_malloc(len);
381 /*************************************************
382 * Copy, lowercase and save string *
383 *************************************************/
386 Argument: string to copy
387 Returns: copy of string in new store, with letters lowercased
391 string_copylc(uschar *s)
393 uschar *ss = store_get(Ustrlen(s) + 1);
395 while (*s != 0) *p++ = tolower(*s++);
402 /*************************************************
403 * Copy and save string, given length *
404 *************************************************/
406 /* It is assumed the data contains no zeros. A zero is added
411 n number of characters
413 Returns: copy of string in new store
417 string_copyn(uschar *s, int n)
419 uschar *ss = store_get(n + 1);
426 /*************************************************
427 * Copy, lowercase, and save string, given length *
428 *************************************************/
430 /* It is assumed the data contains no zeros. A zero is added
435 n number of characters
437 Returns: copy of string in new store, with letters lowercased
441 string_copynlc(uschar *s, int n)
443 uschar *ss = store_get(n + 1);
445 while (n-- > 0) *p++ = tolower(*s++);
452 /*************************************************
453 * Copy string if long, inserting newlines *
454 *************************************************/
456 /* If the given string is longer than 75 characters, it is copied, and within
457 the copy, certain space characters are converted into newlines.
459 Argument: pointer to the string
460 Returns: pointer to the possibly altered string
464 string_split_message(uschar *msg)
468 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
469 s = ss = msg = string_copy(msg);
474 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
486 if (t[-1] == ':') { tt = t; break; }
487 if (tt == NULL) tt = t;
491 if (tt == NULL) /* Can't split behind - try ahead */
496 if (*t == ' ' || *t == '\n')
502 if (tt == NULL) break; /* Can't find anywhere to split */
513 /*************************************************
514 * Copy returned DNS domain name, de-escaping *
515 *************************************************/
517 /* If a domain name contains top-bit characters, some resolvers return
518 the fully qualified name with those characters turned into escapes. The
519 convention is a backslash followed by _decimal_ digits. We convert these
520 back into the original binary values. This will be relevant when
521 allow_utf8_domains is set true and UTF-8 characters are used in domain
522 names. Backslash can also be used to escape other characters, though we
523 shouldn't come across them in domain names.
525 Argument: the domain name string
526 Returns: copy of string in new store, de-escaped
530 string_copy_dnsdomain(uschar *s)
533 uschar *ss = yield = store_get(Ustrlen(s) + 1);
541 else if (isdigit(s[1]))
543 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
546 else if (*(++s) != 0)
557 #ifndef COMPILE_UTILITY
558 /*************************************************
559 * Copy space-terminated or quoted string *
560 *************************************************/
562 /* This function copies from a string until its end, or until whitespace is
563 encountered, unless the string begins with a double quote, in which case the
564 terminating quote is sought, and escaping within the string is done. The length
565 of a de-quoted string can be no longer than the original, since escaping always
566 turns n characters into 1 character.
568 Argument: pointer to the pointer to the first character, which gets updated
569 Returns: the new string
573 string_dequote(uschar **sptr)
578 /* First find the end of the string */
582 while (*s != 0 && !isspace(*s)) s++;
587 while (*s != 0 && *s != '\"')
589 if (*s == '\\') (void)string_interpret_escape(&s);
595 /* Get enough store to copy into */
597 t = yield = store_get(s - *sptr + 1);
604 while (*s != 0 && !isspace(*s)) *t++ = *s++;
609 while (*s != 0 && *s != '\"')
611 if (*s == '\\') *t++ = string_interpret_escape(&s);
618 /* Update the pointer and return the terminated copy */
624 #endif /* COMPILE_UTILITY */
628 /*************************************************
629 * Format a string and save it *
630 *************************************************/
632 /* The formatting is done by string_format, which checks the length of
636 format a printf() format - deliberately char * rather than uschar *
637 because it will most usually be a literal string
638 ... arguments for format
640 Returns: pointer to fresh piece of store containing sprintf'ed string
644 string_sprintf(char *format, ...)
647 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
648 va_start(ap, format);
649 if (!string_vformat(buffer, sizeof(buffer), format, ap))
650 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
651 "string_sprintf expansion was longer than %d", sizeof(buffer));
653 return string_copy(buffer);
658 /*************************************************
659 * Case-independent strncmp() function *
660 *************************************************/
666 n number of characters to compare
668 Returns: < 0, = 0, or > 0, according to the comparison
672 strncmpic(uschar *s, uschar *t, int n)
676 int c = tolower(*s++) - tolower(*t++);
683 /*************************************************
684 * Case-independent strcmp() function *
685 *************************************************/
692 Returns: < 0, = 0, or > 0, according to the comparison
696 strcmpic(uschar *s, uschar *t)
700 int c = tolower(*s++) - tolower(*t++);
701 if (c != 0) return c;
707 /*************************************************
708 * Case-independent strstr() function *
709 *************************************************/
711 /* The third argument specifies whether whitespace is required
712 to follow the matched string.
716 t substring to search for
717 space_follows if TRUE, match only if whitespace follows
719 Returns: pointer to substring in string, or NULL if not found
723 strstric(uschar *s, uschar *t, BOOL space_follows)
726 uschar *yield = NULL;
727 int cl = tolower(*p);
728 int cu = toupper(*p);
732 if (*s == cl || *s == cu)
734 if (yield == NULL) yield = s;
737 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
745 else if (yield != NULL)
759 #ifndef COMPILE_UTILITY
760 /*************************************************
761 * Get next string from separated list *
762 *************************************************/
764 /* Leading and trailing space is removed from each item. The separator in the
765 list is controlled by the int pointed to by the separator argument as follows:
767 If the value is > 0 it is used as the separator. This is typically used for
768 sublists such as slash-separated options. The value is always a printing
771 (If the value is actually > UCHAR_MAX there is only one item in the list.
772 This is used for some cases when called via functions that sometimes
773 plough through lists, and sometimes are given single items.)
775 If the value is <= 0, the string is inspected for a leading <x, where x is an
776 ispunct() or an iscntrl() character. If found, x is used as the separator. If
779 (a) if separator == 0, ':' is used
780 (b) if separator <0, -separator is used
782 In all cases the value of the separator that is used is written back to the
783 int so that it is used on subsequent calls as we progress through the list.
785 A literal ispunct() separator can be represented in an item by doubling, but
786 there is no way to include an iscntrl() separator as part of the data.
789 listptr points to a pointer to the current start of the list; the
790 pointer gets updated to point after the end of the next item
791 separator a pointer to the separator character in an int (see above)
792 buffer where to put a copy of the next string in the list; or
793 NULL if the next string is returned in new memory
794 buflen when buffer is not NULL, the size of buffer; otherwise ignored
796 Returns: pointer to buffer, containing the next substring,
797 or NULL if no more substrings
801 string_nextinlist(uschar **listptr, int *separator, uschar *buffer, int buflen)
803 register int sep = *separator;
804 register uschar *s = *listptr;
807 if (s == NULL) return NULL;
809 /* This allows for a fixed specified separator to be an iscntrl() character,
810 but at the time of implementation, this is never the case. However, it's best
811 to be conservative. */
813 while (isspace(*s) && *s != sep) s++;
815 /* A change of separator is permitted, so look for a leading '<' followed by an
816 allowed character. */
820 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
824 while (isspace(*s) && *s != sep) s++;
828 sep = (sep == 0)? ':' : -sep;
833 /* An empty string has no list elements */
835 if (*s == 0) return NULL;
837 /* Note whether whether or not the separator is an iscntrl() character. */
839 sep_is_special = iscntrl(sep);
841 /* Handle the case when a buffer is provided. */
848 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
849 if (p < buflen - 1) buffer[p++] = *s;
851 while (p > 0 && isspace(buffer[p-1])) p--;
855 /* Handle the case when a buffer is not provided. */
863 /* We know that *s != 0 at this point. However, it might be pointing to a
864 separator, which could indicate an empty string, or (if an ispunct()
865 character) could be doubled to indicate a separator character as data at the
866 start of a string. Avoid getting working memory for an empty item. */
871 if (*s != sep || sep_is_special)
874 return string_copy(US"");
878 /* Not an empty string; the first character is guaranteed to be a data
883 for (ss = s + 1; *ss != 0 && *ss != sep; ss++);
884 buffer = string_cat(buffer, &size, &ptr, s, ss-s);
886 if (*s == 0 || *(++s) != sep || sep_is_special) break;
888 while (ptr > 0 && isspace(buffer[ptr-1])) ptr--;
892 /* Update the current pointer and return the new string */
897 #endif /* COMPILE_UTILITY */
901 #ifndef COMPILE_UTILITY
902 /*************************************************
903 * Add chars to string *
904 *************************************************/
906 /* This function is used when building up strings of unknown length. Room is
907 always left for a terminating zero to be added to the string that is being
908 built. This function does not require the string that is being added to be NUL
909 terminated, because the number of characters to add is given explicitly. It is
910 sometimes called to extract parts of other strings.
913 string points to the start of the string that is being built, or NULL
914 if this is a new string that has no contents yet
915 size points to a variable that holds the current capacity of the memory
916 block (updated if changed)
917 ptr points to a variable that holds the offset at which to add
918 characters, updated to the new offset
919 s points to characters to add
920 count count of characters to add; must not exceed the length of s, if s
923 If string is given as NULL, *size and *ptr should both be zero.
925 Returns: pointer to the start of the string, changed if copied for expansion.
926 Note that a NUL is not added, though space is left for one. This is
927 because string_cat() is often called multiple times to build up a
928 string - there's no point adding the NUL till the end.
932 string_cat(uschar *string, int *size, int *ptr, const uschar *s, int count)
936 if (p + count >= *size)
940 /* Mostly, string_cat() is used to build small strings of a few hundred
941 characters at most. There are times, however, when the strings are very much
942 longer (for example, a lookup that returns a vast number of alias addresses).
943 To try to keep things reasonable, we use increments whose size depends on the
944 existing length of the string. */
946 int inc = (oldsize < 4096)? 100 : 1024;
947 while (*size <= p + count) *size += inc;
951 if (string == NULL) string = store_get(*size);
953 /* Try to extend an existing allocation. If the result of calling
954 store_extend() is false, either there isn't room in the current memory block,
955 or this string is not the top item on the dynamic store stack. We then have
956 to get a new chunk of store and copy the old string. When building large
957 strings, it is helpful to call store_release() on the old string, to release
958 memory blocks that have become empty. (The block will be freed if the string
959 is at its start.) However, we can do this only if we know that the old string
960 was the last item on the dynamic memory stack. This is the case if it matches
963 else if (!store_extend(string, oldsize, *size))
965 BOOL release_ok = store_last_get[store_pool] == string;
966 uschar *newstring = store_get(*size);
967 memcpy(newstring, string, p);
968 if (release_ok) store_release(string);
973 /* Because we always specify the exact number of characters to copy, we can
974 use memcpy(), which is likely to be more efficient than strncopy() because the
975 latter has to check for zero bytes. */
977 memcpy(string + p, s, count);
981 #endif /* COMPILE_UTILITY */
985 #ifndef COMPILE_UTILITY
986 /*************************************************
987 * Append strings to another string *
988 *************************************************/
990 /* This function can be used to build a string from many other strings.
991 It calls string_cat() to do the dirty work.
994 string points to the start of the string that is being built, or NULL
995 if this is a new string that has no contents yet
996 size points to a variable that holds the current capacity of the memory
997 block (updated if changed)
998 ptr points to a variable that holds the offset at which to add
999 characters, updated to the new offset
1000 count the number of strings to append
1001 ... "count" uschar* arguments, which must be valid zero-terminated
1004 Returns: pointer to the start of the string, changed if copied for expansion.
1005 The string is not zero-terminated - see string_cat() above.
1009 string_append(uschar *string, int *size, int *ptr, int count, ...)
1014 va_start(ap, count);
1015 for (i = 0; i < count; i++)
1017 uschar *t = va_arg(ap, uschar *);
1018 string = string_cat(string, size, ptr, t, Ustrlen(t));
1028 /*************************************************
1029 * Format a string with length checks *
1030 *************************************************/
1032 /* This function is used to format a string with checking of the length of the
1033 output for all conversions. It protects Exim from absent-mindedness when
1034 calling functions like debug_printf and string_sprintf, and elsewhere. There
1035 are two different entry points to what is actually the same function, depending
1036 on whether the variable length list of data arguments are given explicitly or
1039 The formats are the usual printf() ones, with some omissions (never used) and
1040 two additions for strings: %S forces lower case, and %#s or %#S prints nothing
1041 for a NULL string. Without the # "NULL" is printed (useful in debugging). There
1042 is also the addition of %D, which inserts the date in the form used for
1043 datestamped log files.
1046 buffer a buffer in which to put the formatted string
1047 buflen the length of the buffer
1048 format the format string - deliberately char * and not uschar *
1049 ... or ap variable list of supplementary arguments
1051 Returns: TRUE if the result fitted in the buffer
1055 string_format(uschar *buffer, int buflen, char *format, ...)
1059 va_start(ap, format);
1060 yield = string_vformat(buffer, buflen, format, ap);
1067 string_vformat(uschar *buffer, int buflen, char *format, va_list ap)
1069 enum { L_NORMAL, L_SHORT, L_LONG, L_LONGLONG, L_LONGDOUBLE };
1072 int width, precision;
1073 char *fp = format; /* Deliberately not unsigned */
1075 uschar *last = buffer + buflen - 1;
1077 string_datestamp_offset = -1; /* Datestamp not inserted */
1079 /* Scan the format and handle the insertions */
1083 int length = L_NORMAL;
1086 char *null = "NULL"; /* ) These variables */
1087 char *item_start, *s; /* ) are deliberately */
1088 char newformat[16]; /* ) not unsigned */
1090 /* Non-% characters just get copied verbatim */
1094 if (p >= last) { yield = FALSE; break; }
1095 *p++ = (uschar)*fp++;
1099 /* Deal with % characters. Pick off the width and precision, for checking
1100 strings, skipping over the flag and modifier characters. */
1103 width = precision = -1;
1105 if (strchr("-+ #0", *(++fp)) != NULL)
1107 if (*fp == '#') null = "";
1111 if (isdigit((uschar)*fp))
1113 width = *fp++ - '0';
1114 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1116 else if (*fp == '*')
1118 width = va_arg(ap, int);
1126 precision = va_arg(ap, int);
1132 while (isdigit((uschar)*fp))
1133 precision = precision*10 + *fp++ - '0';
1137 /* Skip over 'h', 'L', 'l', and 'll', remembering the item length */
1140 { fp++; length = L_SHORT; }
1141 else if (*fp == 'L')
1142 { fp++; length = L_LONGDOUBLE; }
1143 else if (*fp == 'l')
1148 length = L_LONGLONG;
1157 /* Handle each specific format type. */
1162 nptr = va_arg(ap, int *);
1171 if (p >= last - ((length > L_LONG)? 24 : 12))
1172 { yield = FALSE; goto END_FORMAT; }
1173 strncpy(newformat, item_start, fp - item_start);
1174 newformat[fp - item_start] = 0;
1176 /* Short int is promoted to int when passing through ..., so we must use
1177 int for va_arg(). */
1182 case L_NORMAL: sprintf(CS p, newformat, va_arg(ap, int)); break;
1183 case L_LONG: sprintf(CS p, newformat, va_arg(ap, long int)); break;
1184 case L_LONGLONG: sprintf(CS p, newformat, va_arg(ap, LONGLONG_T)); break;
1190 if (p >= last - 24) { yield = FALSE; goto END_FORMAT; }
1191 strncpy(newformat, item_start, fp - item_start);
1192 newformat[fp - item_start] = 0;
1193 sprintf(CS p, newformat, va_arg(ap, void *));
1197 /* %f format is inherently insecure if the numbers that it may be
1198 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1199 printing load averages, and these are actually stored as integers
1200 (load average * 1000) so the size of the numbers is constrained.
1201 It is also used for formatting sending rates, where the simplicity
1202 of the format prevents overflow. */
1209 if (precision < 0) precision = 6;
1210 if (p >= last - precision - 8) { yield = FALSE; goto END_FORMAT; }
1211 strncpy(newformat, item_start, fp - item_start);
1212 newformat[fp-item_start] = 0;
1213 if (length == L_LONGDOUBLE)
1214 sprintf(CS p, newformat, va_arg(ap, long double));
1216 sprintf(CS p, newformat, va_arg(ap, double));
1223 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1228 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1229 *p++ = va_arg(ap, int);
1232 case 'D': /* Insert datestamp for log file names */
1233 s = CS tod_stamp(tod_log_datestamp);
1234 string_datestamp_offset = p - buffer; /* Passed back via global */
1238 case 'S': /* Forces *lower* case */
1239 s = va_arg(ap, char *);
1241 INSERT_STRING: /* Come to from %D above */
1242 if (s == NULL) s = null;
1245 /* If the width is specified, check that there is a precision
1246 set; if not, set it to the width to prevent overruns of long
1251 if (precision < 0) precision = width;
1254 /* If a width is not specified and the precision is specified, set
1255 the width to the precision, or the string length if shorted. */
1257 else if (precision >= 0)
1259 width = (precision < slen)? precision : slen;
1262 /* If neither are specified, set them both to the string length. */
1264 else width = precision = slen;
1266 /* Check string space, and add the string to the buffer if ok. If
1267 not OK, add part of the string (debugging uses this to show as
1268 much as possible). */
1270 if (p >= last - width)
1273 width = precision = last - p - 1;
1275 sprintf(CS p, "%*.*s", width, precision, s);
1277 while (*p) { *p = tolower(*p); p++; }
1280 if (!yield) goto END_FORMAT;
1283 /* Some things are never used in Exim; also catches junk. */
1286 strncpy(newformat, item_start, fp - item_start);
1287 newformat[fp-item_start] = 0;
1288 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1289 "in \"%s\" in \"%s\"", newformat, format);
1294 /* Ensure string is complete; return TRUE if got to the end of the format */
1304 #ifndef COMPILE_UTILITY
1305 /*************************************************
1306 * Generate an "open failed" message *
1307 *************************************************/
1309 /* This function creates a message after failure to open a file. It includes a
1310 string supplied as data, adds the strerror() text, and if the failure was
1311 "Permission denied", reads and includes the euid and egid.
1314 eno the value of errno after the failure
1315 format a text format string - deliberately not uschar *
1316 ... arguments for the format string
1318 Returns: a message, in dynamic store
1322 string_open_failed(int eno, char *format, ...)
1325 uschar buffer[1024];
1327 Ustrcpy(buffer, "failed to open ");
1328 va_start(ap, format);
1330 /* Use the checked formatting routine to ensure that the buffer
1331 does not overflow. It should not, since this is called only for internally
1332 specified messages. If it does, the message just gets truncated, and there
1333 doesn't seem much we can do about that. */
1335 (void)string_vformat(buffer+15, sizeof(buffer) - 15, format, ap);
1337 return (eno == EACCES)?
1338 string_sprintf("%s: %s (euid=%ld egid=%ld)", buffer, strerror(eno),
1339 (long int)geteuid(), (long int)getegid()) :
1340 string_sprintf("%s: %s", buffer, strerror(eno));
1342 #endif /* COMPILE_UTILITY */
1346 #ifndef COMPILE_UTILITY
1347 /*************************************************
1348 * Generate local prt for logging *
1349 *************************************************/
1351 /* This function is a subroutine for use in string_log_address() below.
1354 addr the address being logged
1355 yield the current dynamic buffer pointer
1356 sizeptr points to current size
1357 ptrptr points to current insert pointer
1359 Returns: the new value of the buffer pointer
1363 string_get_localpart(address_item *addr, uschar *yield, int *sizeptr,
1366 if (testflag(addr, af_include_affixes) && addr->prefix != NULL)
1367 yield = string_cat(yield, sizeptr, ptrptr, addr->prefix,
1368 Ustrlen(addr->prefix));
1369 yield = string_cat(yield, sizeptr, ptrptr, addr->local_part,
1370 Ustrlen(addr->local_part));
1371 if (testflag(addr, af_include_affixes) && addr->suffix != NULL)
1372 yield = string_cat(yield, sizeptr, ptrptr, addr->suffix,
1373 Ustrlen(addr->suffix));
1378 /*************************************************
1379 * Generate log address list *
1380 *************************************************/
1382 /* This function generates a list consisting of an address and its parents, for
1383 use in logging lines. For saved onetime aliased addresses, the onetime parent
1384 field is used. If the address was delivered by a transport with rcpt_include_
1385 affixes set, the af_include_affixes bit will be set in the address. In that
1386 case, we include the affixes here too.
1389 addr bottom (ultimate) address
1390 all_parents if TRUE, include all parents
1391 success TRUE for successful delivery
1393 Returns: a string in dynamic store
1397 string_log_address(address_item *addr, BOOL all_parents, BOOL success)
1401 BOOL add_topaddr = TRUE;
1402 uschar *yield = store_get(size);
1403 address_item *topaddr;
1405 /* Find the ultimate parent */
1407 for (topaddr = addr; topaddr->parent != NULL; topaddr = topaddr->parent);
1409 /* We start with just the local part for pipe, file, and reply deliveries, and
1410 for successful local deliveries from routers that have the log_as_local flag
1411 set. File deliveries from filters can be specified as non-absolute paths in
1412 cases where the transport is goin to complete the path. If there is an error
1413 before this happens (expansion failure) the local part will not be updated, and
1414 so won't necessarily look like a path. Add extra text for this case. */
1416 if (testflag(addr, af_pfr) ||
1418 addr->router != NULL && addr->router->log_as_local &&
1419 addr->transport != NULL && addr->transport->info->local))
1421 if (testflag(addr, af_file) && addr->local_part[0] != '/')
1422 yield = string_cat(yield, &size, &ptr, CUS"save ", 5);
1423 yield = string_get_localpart(addr, yield, &size, &ptr);
1426 /* Other deliveries start with the full address. It we have split it into local
1427 part and domain, use those fields. Some early failures can happen before the
1428 splitting is done; in those cases use the original field. */
1432 if (addr->local_part != NULL)
1434 yield = string_get_localpart(addr, yield, &size, &ptr);
1435 yield = string_cat(yield, &size, &ptr, US"@", 1);
1436 yield = string_cat(yield, &size, &ptr, addr->domain,
1437 Ustrlen(addr->domain) );
1441 yield = string_cat(yield, &size, &ptr, addr->address, Ustrlen(addr->address));
1445 /* If the address we are going to print is the same as the top address,
1446 and all parents are not being included, don't add on the top address. First
1447 of all, do a caseless comparison; if this succeeds, do a caseful comparison
1448 on the local parts. */
1450 if (strcmpic(yield, topaddr->address) == 0 &&
1451 Ustrncmp(yield, topaddr->address, Ustrchr(yield, '@') - yield) == 0 &&
1452 addr->onetime_parent == NULL &&
1453 (!all_parents || addr->parent == NULL || addr->parent == topaddr))
1454 add_topaddr = FALSE;
1457 /* If all parents are requested, or this is a local pipe/file/reply, and
1458 there is at least one intermediate parent, show it in brackets, and continue
1459 with all of them if all are wanted. */
1461 if ((all_parents || testflag(addr, af_pfr)) &&
1462 addr->parent != NULL &&
1463 addr->parent != topaddr)
1466 address_item *addr2;
1467 for (addr2 = addr->parent; addr2 != topaddr; addr2 = addr2->parent)
1469 yield = string_cat(yield, &size, &ptr, s, 2);
1470 yield = string_cat(yield, &size, &ptr, addr2->address, Ustrlen(addr2->address));
1471 if (!all_parents) break;
1474 yield = string_cat(yield, &size, &ptr, US")", 1);
1477 /* Add the top address if it is required */
1481 yield = string_cat(yield, &size, &ptr, US" <", 2);
1483 if (addr->onetime_parent == NULL)
1484 yield = string_cat(yield, &size, &ptr, topaddr->address,
1485 Ustrlen(topaddr->address));
1487 yield = string_cat(yield, &size, &ptr, addr->onetime_parent,
1488 Ustrlen(addr->onetime_parent));
1490 yield = string_cat(yield, &size, &ptr, US">", 1);
1493 yield[ptr] = 0; /* string_cat() leaves space */
1496 #endif /* COMPILE_UTILITY */
1502 /*************************************************
1503 **************************************************
1504 * Stand-alone test program *
1505 **************************************************
1506 *************************************************/
1513 printf("Testing is_ip_address\n");
1515 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1518 buffer[Ustrlen(buffer) - 1] = 0;
1519 printf("%d\n", string_is_ip_address(buffer, NULL));
1520 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1523 printf("Testing string_nextinlist\n");
1525 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1527 uschar *list = buffer;
1535 sep1 = sep2 = list[1];
1542 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1543 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1545 if (item1 == NULL && item2 == NULL) break;
1546 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1548 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1549 (item1 == NULL)? "NULL" : CS item1,
1550 (item2 == NULL)? "NULL" : CS item2);
1553 else printf(" \"%s\"\n", CS item1);
1557 /* This is a horrible lash-up, but it serves its purpose. */
1559 printf("Testing string_format\n");
1561 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1564 long long llargs[3];
1574 buffer[Ustrlen(buffer) - 1] = 0;
1576 s = Ustrchr(buffer, ',');
1577 if (s == NULL) s = buffer + Ustrlen(buffer);
1579 Ustrncpy(format, buffer, s - buffer);
1580 format[s-buffer] = 0;
1587 s = Ustrchr(ss, ',');
1588 if (s == NULL) s = ss + Ustrlen(ss);
1592 Ustrncpy(outbuf, ss, s-ss);
1593 if (Ustrchr(outbuf, '.') != NULL)
1596 dargs[n++] = Ustrtod(outbuf, NULL);
1598 else if (Ustrstr(outbuf, "ll") != NULL)
1601 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1605 args[n++] = (void *)Uatoi(outbuf);
1609 else if (Ustrcmp(ss, "*") == 0)
1611 args[n++] = (void *)(&count);
1617 uschar *sss = malloc(s - ss + 1);
1618 Ustrncpy(sss, ss, s-ss);
1625 if (!dflag && !llflag)
1626 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1627 args[0], args[1], args[2])? "True" : "False");
1630 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1631 dargs[0], dargs[1], dargs[2])? "True" : "False");
1633 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1634 llargs[0], llargs[1], llargs[2])? "True" : "False");
1636 printf("%s\n", CS outbuf);
1637 if (countset) printf("count=%d\n", count);
1644 /* End of string.c */