1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Miscellaneous string-handling functions. Some are not required for
9 utilities and tests, and are cut out by the COMPILE_UTILITY macro. */
15 #ifndef COMPILE_UTILITY
16 /*************************************************
17 * Test for IP address *
18 *************************************************/
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.
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
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
37 string_is_ip_address(const uschar *s, int *maskptr)
42 /* If an optional mask is permitted, check for it. If found, pass back the
47 const uschar *ss = s + Ustrlen(s);
49 if (s != ss && isdigit(*(--ss)))
51 while (ss > s && isdigit(ss[-1])) ss--;
52 if (ss > s && *(--ss) == '/') *maskptr = ss - s;
56 /* A colon anywhere in the string => IPv6 address */
58 if (Ustrchr(s, ':') != NULL)
60 BOOL had_double_colon = FALSE;
66 /* An IPv6 address must start with hex digit or double colon. A single
69 if (*s == ':' && *(++s) != ':') return 0;
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. */
75 for (count = 0; count < 8; count++)
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. */
82 if (*s == 0 || *s == '%' || *s == '/') return had_double_colon ? yield : 0;
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. */
90 if (had_double_colon) return 0;
91 had_double_colon = TRUE;
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. */
102 if (Ustrchr(s, ':') == NULL && Ustrchr(s, '.') != NULL)
104 if ((!had_double_colon && count != 6) ||
105 (had_double_colon && count > 6)) return 0;
111 /* Check for at least one and not more than 4 hex digits for this
114 if (!isxdigit(*s++)) return 0;
115 if (isxdigit(*s) && isxdigit(*(++s)) && isxdigit(*(++s))) s++;
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
121 if (*s == ':' && *(++s) == 0) return 0;
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
130 return (*s == 0 || *s == '%' ||
131 (*s == '/' && maskptr != NULL && *maskptr != 0))? yield : 0;
134 /* Test for IPv4 address, which may be the tail-end of an IPv6 address. */
136 for (i = 0; i < 4; i++)
141 if (i != 0 && *s++ != '.') return 0;
142 n = strtol(CCS s, CSS &end, 10);
143 if (n > 255 || n < 0 || end <= s || end > s+3) return 0;
147 return !*s || (*s == '/' && maskptr && *maskptr != 0) ? yield : 0;
149 #endif /* COMPILE_UTILITY */
152 /*************************************************
153 * Format message size *
154 *************************************************/
156 /* Convert a message size in bytes to printing form, rounding
157 according to the magnitude of the number. A value of zero causes
158 a string of spaces to be returned.
161 size the message size in bytes
162 buffer where to put the answer
164 Returns: pointer to the buffer
165 a string of exactly 5 characters is normally returned
169 string_format_size(int size, uschar *buffer)
171 if (size == 0) Ustrcpy(buffer, " ");
172 else if (size < 1024) sprintf(CS buffer, "%5d", size);
173 else if (size < 10*1024)
174 sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);
175 else if (size < 1024*1024)
176 sprintf(CS buffer, "%4dK", (size + 512)/1024);
177 else if (size < 10*1024*1024)
178 sprintf(CS buffer, "%4.1fM", (double)size / (1024.0 * 1024.0));
180 sprintf(CS buffer, "%4dM", (size + 512 * 1024)/(1024*1024));
186 #ifndef COMPILE_UTILITY
187 /*************************************************
188 * Convert a number to base 62 format *
189 *************************************************/
191 /* Convert a long integer into an ASCII base 62 string. For Cygwin the value of
192 BASE_62 is actually 36. Always return exactly 6 characters plus zero, in a
195 Argument: a long integer
196 Returns: pointer to base 62 string
200 string_base62(unsigned long int value)
202 static uschar yield[7];
203 uschar *p = yield + sizeof(yield) - 1;
207 *(--p) = base62_chars[value % BASE_62];
212 #endif /* 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(const uschar **pp)
232 #ifdef COMPILE_UTILITY
233 const uschar *hex_digits= CUS"0123456789abcdef";
236 const uschar *p = *pp;
238 if (isdigit(ch) && ch != '8' && ch != '9')
241 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
243 ch = ch * 8 + *(++p) - '0';
244 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
245 ch = ch * 8 + *(++p) - '0';
250 case 'b': ch = '\b'; break;
251 case 'f': ch = '\f'; break;
252 case 'n': ch = '\n'; break;
253 case 'r': ch = '\r'; break;
254 case 't': ch = '\t'; break;
255 case 'v': ch = '\v'; break;
261 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
262 if (isxdigit(p[1])) ch = ch * 16 +
263 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
273 #ifndef COMPILE_UTILITY
274 /*************************************************
275 * Ensure string is printable *
276 *************************************************/
278 /* This function is called for critical strings. It checks for any
279 non-printing characters, and if any are found, it makes a new copy
280 of the string with suitable escape sequences. It is most often called by the
281 macro string_printing(), which sets allow_tab TRUE.
285 allow_tab TRUE to allow tab as a printing character
287 Returns: string with non-printers encoded as printing sequences
291 string_printing2(const uschar *s, BOOL allow_tab)
293 int nonprintcount = 0;
301 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
305 if (nonprintcount == 0) return s;
307 /* Get a new block of store guaranteed big enough to hold the
310 ss = store_get(length + nonprintcount * 3 + 1);
312 /* Copy everything, escaping non printers. */
320 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
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;
339 #endif /* COMPILE_UTILITY */
341 /*************************************************
342 * Undo printing escapes in string *
343 *************************************************/
345 /* This function is the reverse of string_printing2. It searches for
346 backslash characters and if any are found, it makes a new copy of the
347 string with escape sequences parsed. Otherwise it returns the original
353 Returns: string with printing escapes parsed back
357 string_unprinting(uschar *s)
359 uschar *p, *q, *r, *ss;
362 p = Ustrchr(s, '\\');
365 len = Ustrlen(s) + 1;
380 *q++ = string_interpret_escape((const uschar **)&p);
385 r = Ustrchr(p, '\\');
411 /*************************************************
412 * Copy and save string *
413 *************************************************/
415 /* This function assumes that memcpy() is faster than strcpy().
417 Argument: string to copy
418 Returns: copy of string in new store
422 string_copy(const uschar *s)
424 int len = Ustrlen(s) + 1;
425 uschar *ss = store_get(len);
432 /*************************************************
433 * Copy and save string in malloc'd store *
434 *************************************************/
436 /* This function assumes that memcpy() is faster than strcpy().
438 Argument: string to copy
439 Returns: copy of string in new store
443 string_copy_malloc(const uschar *s)
445 int len = Ustrlen(s) + 1;
446 uschar *ss = store_malloc(len);
453 /*************************************************
454 * Copy, lowercase and save string *
455 *************************************************/
458 Argument: string to copy
459 Returns: copy of string in new store, with letters lowercased
463 string_copylc(const uschar *s)
465 uschar *ss = store_get(Ustrlen(s) + 1);
467 while (*s != 0) *p++ = tolower(*s++);
474 /*************************************************
475 * Copy and save string, given length *
476 *************************************************/
478 /* It is assumed the data contains no zeros. A zero is added
483 n number of characters
485 Returns: copy of string in new store
489 string_copyn(const uschar *s, int n)
491 uschar *ss = store_get(n + 1);
498 /*************************************************
499 * Copy, lowercase, and save string, given length *
500 *************************************************/
502 /* It is assumed the data contains no zeros. A zero is added
507 n number of characters
509 Returns: copy of string in new store, with letters lowercased
513 string_copynlc(uschar *s, int n)
515 uschar *ss = store_get(n + 1);
517 while (n-- > 0) *p++ = tolower(*s++);
524 /*************************************************
525 * Copy string if long, inserting newlines *
526 *************************************************/
528 /* If the given string is longer than 75 characters, it is copied, and within
529 the copy, certain space characters are converted into newlines.
531 Argument: pointer to the string
532 Returns: pointer to the possibly altered string
536 string_split_message(uschar *msg)
540 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
541 s = ss = msg = string_copy(msg);
546 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
558 if (t[-1] == ':') { tt = t; break; }
559 if (tt == NULL) tt = t;
563 if (tt == NULL) /* Can't split behind - try ahead */
568 if (*t == ' ' || *t == '\n')
574 if (tt == NULL) break; /* Can't find anywhere to split */
585 /*************************************************
586 * Copy returned DNS domain name, de-escaping *
587 *************************************************/
589 /* If a domain name contains top-bit characters, some resolvers return
590 the fully qualified name with those characters turned into escapes. The
591 convention is a backslash followed by _decimal_ digits. We convert these
592 back into the original binary values. This will be relevant when
593 allow_utf8_domains is set true and UTF-8 characters are used in domain
594 names. Backslash can also be used to escape other characters, though we
595 shouldn't come across them in domain names.
597 Argument: the domain name string
598 Returns: copy of string in new store, de-escaped
602 string_copy_dnsdomain(uschar *s)
605 uschar *ss = yield = store_get(Ustrlen(s) + 1);
613 else if (isdigit(s[1]))
615 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
618 else if (*(++s) != 0)
629 #ifndef COMPILE_UTILITY
630 /*************************************************
631 * Copy space-terminated or quoted string *
632 *************************************************/
634 /* This function copies from a string until its end, or until whitespace is
635 encountered, unless the string begins with a double quote, in which case the
636 terminating quote is sought, and escaping within the string is done. The length
637 of a de-quoted string can be no longer than the original, since escaping always
638 turns n characters into 1 character.
640 Argument: pointer to the pointer to the first character, which gets updated
641 Returns: the new string
645 string_dequote(const uschar **sptr)
647 const uschar *s = *sptr;
650 /* First find the end of the string */
654 while (*s != 0 && !isspace(*s)) s++;
659 while (*s != 0 && *s != '\"')
661 if (*s == '\\') (void)string_interpret_escape(&s);
667 /* Get enough store to copy into */
669 t = yield = store_get(s - *sptr + 1);
676 while (*s != 0 && !isspace(*s)) *t++ = *s++;
681 while (*s != 0 && *s != '\"')
683 if (*s == '\\') *t++ = string_interpret_escape(&s);
690 /* Update the pointer and return the terminated copy */
696 #endif /* COMPILE_UTILITY */
700 /*************************************************
701 * Format a string and save it *
702 *************************************************/
704 /* The formatting is done by string_format, which checks the length of
708 format a printf() format - deliberately char * rather than uschar *
709 because it will most usually be a literal string
710 ... arguments for format
712 Returns: pointer to fresh piece of store containing sprintf'ed string
716 string_sprintf(const char *format, ...)
719 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
720 va_start(ap, format);
721 if (!string_vformat(buffer, sizeof(buffer), format, ap))
722 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
723 "string_sprintf expansion was longer than " SIZE_T_FMT
724 "; format string was (%s)\nexpansion started '%.32s'",
725 sizeof(buffer), format, buffer);
727 return string_copy(buffer);
732 /*************************************************
733 * Case-independent strncmp() function *
734 *************************************************/
740 n number of characters to compare
742 Returns: < 0, = 0, or > 0, according to the comparison
746 strncmpic(const uschar *s, const uschar *t, int n)
750 int c = tolower(*s++) - tolower(*t++);
757 /*************************************************
758 * Case-independent strcmp() function *
759 *************************************************/
766 Returns: < 0, = 0, or > 0, according to the comparison
770 strcmpic(const uschar *s, const uschar *t)
774 int c = tolower(*s++) - tolower(*t++);
775 if (c != 0) return c;
781 /*************************************************
782 * Case-independent strstr() function *
783 *************************************************/
785 /* The third argument specifies whether whitespace is required
786 to follow the matched string.
790 t substring to search for
791 space_follows if TRUE, match only if whitespace follows
793 Returns: pointer to substring in string, or NULL if not found
797 strstric(uschar *s, uschar *t, BOOL space_follows)
800 uschar *yield = NULL;
801 int cl = tolower(*p);
802 int cu = toupper(*p);
806 if (*s == cl || *s == cu)
808 if (yield == NULL) yield = s;
811 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
819 else if (yield != NULL)
833 #ifndef COMPILE_UTILITY
834 /*************************************************
835 * Get next string from separated list *
836 *************************************************/
838 /* Leading and trailing space is removed from each item. The separator in the
839 list is controlled by the int pointed to by the separator argument as follows:
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
845 (If the value is actually > UCHAR_MAX there is only one item in the list.
846 This is used for some cases when called via functions that sometimes
847 plough through lists, and sometimes are given single items.)
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
853 (a) if separator == 0, ':' is used
854 (b) if separator <0, -separator is used
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.
859 A literal ispunct() separator can be represented in an item by doubling, but
860 there is no way to include an iscntrl() separator as part of the data.
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
870 Returns: pointer to buffer, containing the next substring,
871 or NULL if no more substrings
875 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
877 int sep = *separator;
878 const uschar *s = *listptr;
881 if (s == NULL) return NULL;
883 /* This allows for a fixed specified separator to be an iscntrl() character,
884 but at the time of implementation, this is never the case. However, it's best
885 to be conservative. */
887 while (isspace(*s) && *s != sep) s++;
889 /* A change of separator is permitted, so look for a leading '<' followed by an
890 allowed character. */
894 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
898 while (isspace(*s) && *s != sep) s++;
902 sep = (sep == 0)? ':' : -sep;
907 /* An empty string has no list elements */
909 if (*s == 0) return NULL;
911 /* Note whether whether or not the separator is an iscntrl() character. */
913 sep_is_special = iscntrl(sep);
915 /* Handle the case when a buffer is provided. */
922 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
923 if (p < buflen - 1) buffer[p++] = *s;
925 while (p > 0 && isspace(buffer[p-1])) p--;
929 /* Handle the case when a buffer is not provided. */
936 /* We know that *s != 0 at this point. However, it might be pointing to a
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. */
944 if (*s != sep || sep_is_special)
947 return string_copy(US"");
951 /* Not an empty string; the first character is guaranteed to be a data
956 for (ss = s + 1; *ss != 0 && *ss != sep; ss++) ;
957 g = string_catn(g, s, ss-s);
959 if (*s == 0 || *(++s) != sep || sep_is_special) break;
961 while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
962 buffer = string_from_gstring(g);
963 gstring_reset_unused(g);
966 /* Update the current pointer and return the new string */
973 static const uschar *
974 Ustrnchr(const uschar * s, int c, unsigned * len)
979 if (!*s) return NULL;
992 /************************************************
993 * Add element to separated list *
994 ************************************************/
995 /* This function is used to build a list, returning an allocated null-terminated
996 growable string. The given element has any embedded separator characters
999 Despite having the same growable-string interface as string_cat() the list is
1000 always returned null-terminated.
1003 list expanding-string for the list that is being built, or NULL
1004 if this is a new list that has no contents yet
1005 sep list separator character
1006 ele new element to be appended to the list
1008 Returns: pointer to the start of the list, changed if copied for expansion.
1012 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1016 if (list && list->ptr)
1017 list = string_catn(list, &sep, 1);
1019 while((sp = Ustrchr(ele, sep)))
1021 list = string_catn(list, ele, sp-ele+1);
1022 list = string_catn(list, &sep, 1);
1025 list = string_cat(list, ele);
1026 (void) string_from_gstring(list);
1032 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1037 if (list && list->ptr)
1038 list = string_catn(list, &sep, 1);
1040 while((sp = Ustrnchr(ele, sep, &len)))
1042 list = string_catn(list, ele, sp-ele+1);
1043 list = string_catn(list, &sep, 1);
1047 list = string_catn(list, ele, len);
1048 (void) string_from_gstring(list);
1054 /* A slightly-bogus listmaker utility; the separator is a string so
1055 can be multiple chars - there is no checking for the element content
1056 containing any of the separator. */
1059 string_append2_listele_n(gstring * list, const uschar * sepstr,
1060 const uschar * ele, unsigned len)
1064 if (list && list->ptr)
1065 list = string_cat(list, sepstr);
1067 list = string_catn(list, ele, len);
1068 (void) string_from_gstring(list);
1074 /************************************************/
1075 /* Create a growable-string with some preassigned space */
1078 string_get(unsigned size)
1080 gstring * g = store_get(sizeof(gstring) + size);
1087 /* NUL-terminate the C string in the growable-string, and return it. */
1090 string_from_gstring(gstring * g)
1092 if (!g) return NULL;
1093 g->s[g->ptr] = '\0';
1098 gstring_reset_unused(gstring * g)
1100 store_reset(g->s + (g->size = g->ptr + 1));
1103 /*************************************************
1104 * Add chars to string *
1105 *************************************************/
1108 g the grawable-string
1109 p current end of data
1110 count amount to grow by
1114 gstring_grow(gstring * g, int p, int count)
1116 int oldsize = g->size;
1118 /* Mostly, string_cat() is used to build small strings of a few hundred
1119 characters at most. There are times, however, when the strings are very much
1120 longer (for example, a lookup that returns a vast number of alias addresses).
1121 To try to keep things reasonable, we use increments whose size depends on the
1122 existing length of the string. */
1124 unsigned inc = oldsize < 4096 ? 127 : 1023;
1125 g->size = ((p + count + inc) & ~inc) + 1;
1127 /* Try to extend an existing allocation. If the result of calling
1128 store_extend() is false, either there isn't room in the current memory block,
1129 or this string is not the top item on the dynamic store stack. We then have
1130 to get a new chunk of store and copy the old string. When building large
1131 strings, it is helpful to call store_release() on the old string, to release
1132 memory blocks that have become empty. (The block will be freed if the string
1133 is at its start.) However, we can do this only if we know that the old string
1134 was the last item on the dynamic memory stack. This is the case if it matches
1137 if (!store_extend(g->s, oldsize, g->size))
1138 g->s = store_newblock(g->s, g->size, p);
1143 /* This function is used when building up strings of unknown length. Room is
1144 always left for a terminating zero to be added to the string that is being
1145 built. This function does not require the string that is being added to be NUL
1146 terminated, because the number of characters to add is given explicitly. It is
1147 sometimes called to extract parts of other strings.
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
1152 s points to characters to add
1153 count count of characters to add; must not exceed the length of s, if s
1156 Returns: 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.
1162 /* coverity[+alloc] */
1165 string_catn(gstring * g, const uschar *s, int count)
1171 unsigned inc = count < 4096 ? 127 : 1023;
1172 unsigned size = ((count + inc) & ~inc) + 1;
1173 g = string_get(size);
1177 if (p + count >= g->size)
1178 gstring_grow(g, p, count);
1180 /* Because we always specify the exact number of characters to copy, we can
1181 use memcpy(), which is likely to be more efficient than strncopy() because the
1182 latter has to check for zero bytes. */
1184 memcpy(g->s + p, s, count);
1191 string_cat(gstring *string, const uschar *s)
1193 return string_catn(string, s, Ustrlen(s));
1198 /*************************************************
1199 * Append strings to another string *
1200 *************************************************/
1202 /* This function can be used to build a string from many other strings.
1203 It calls string_cat() to do the dirty work.
1206 string expanding-string that is being built, or NULL
1207 if this is a new string that has no contents yet
1208 count the number of strings to append
1209 ... "count" uschar* arguments, which must be valid zero-terminated
1212 Returns: pointer to the start of the string, changed if copied for expansion.
1213 The string is not zero-terminated - see string_cat() above.
1216 __inline__ gstring *
1217 string_append(gstring *string, int count, ...)
1221 va_start(ap, count);
1224 uschar *t = va_arg(ap, uschar *);
1225 string = string_cat(string, t);
1235 /*************************************************
1236 * Format a string with length checks *
1237 *************************************************/
1239 /* This function is used to format a string with checking of the length of the
1240 output for all conversions. It protects Exim from absent-mindedness when
1241 calling functions like debug_printf and string_sprintf, and elsewhere. There
1242 are two different entry points to what is actually the same function, depending
1243 on whether the variable length list of data arguments are given explicitly or
1246 The formats are the usual printf() ones, with some omissions (never used) and
1247 three additions for strings: %S forces lower case, %T forces upper case, and
1248 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1249 (useful in debugging). There is also the addition of %D and %M, which insert
1250 the date in the form used for datestamped log files.
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
1258 Returns: TRUE if the result fitted in the buffer
1262 string_format(uschar *buffer, int buflen, const char *format, ...)
1266 va_start(ap, format);
1267 yield = string_vformat(buffer, buflen, format, ap);
1274 string_vformat(uschar *buffer, int buflen, const char *format, va_list ap)
1276 /* We assume numbered ascending order, C does not guarantee that */
1277 enum { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1280 int width, precision;
1281 const char *fp = format; /* Deliberately not unsigned */
1283 uschar *last = buffer + buflen - 1;
1285 string_datestamp_offset = -1; /* Datestamp not inserted */
1286 string_datestamp_length = 0; /* Datestamp not inserted */
1287 string_datestamp_type = 0; /* Datestamp not inserted */
1289 /* Scan the format and handle the insertions */
1293 int length = L_NORMAL;
1296 const char *null = "NULL"; /* ) These variables */
1297 const char *item_start, *s; /* ) are deliberately */
1298 char newformat[16]; /* ) not unsigned */
1300 /* Non-% characters just get copied verbatim */
1304 if (p >= last) { yield = FALSE; break; }
1305 *p++ = (uschar)*fp++;
1309 /* Deal with % characters. Pick off the width and precision, for checking
1310 strings, skipping over the flag and modifier characters. */
1313 width = precision = -1;
1315 if (strchr("-+ #0", *(++fp)) != NULL)
1317 if (*fp == '#') null = "";
1321 if (isdigit((uschar)*fp))
1323 width = *fp++ - '0';
1324 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1326 else if (*fp == '*')
1328 width = va_arg(ap, int);
1336 precision = va_arg(ap, int);
1342 while (isdigit((uschar)*fp))
1343 precision = precision*10 + *fp++ - '0';
1347 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1350 { fp++; length = L_SHORT; }
1351 else if (*fp == 'L')
1352 { fp++; length = L_LONGDOUBLE; }
1353 else if (*fp == 'l')
1358 length = L_LONGLONG;
1366 else if (*fp == 'z')
1367 { fp++; length = L_SIZE; }
1369 /* Handle each specific format type. */
1374 nptr = va_arg(ap, int *);
1383 if (p >= last - ((length > L_LONG)? 24 : 12))
1384 { yield = FALSE; goto END_FORMAT; }
1385 strncpy(newformat, item_start, fp - item_start);
1386 newformat[fp - item_start] = 0;
1388 /* Short int is promoted to int when passing through ..., so we must use
1389 int for va_arg(). */
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;
1404 if (p >= last - 24) { yield = FALSE; goto END_FORMAT; }
1405 /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1406 Handle it explicitly. */
1407 if ((ptr = va_arg(ap, void *)))
1409 strncpy(newformat, item_start, fp - item_start);
1410 newformat[fp - item_start] = 0;
1411 p += sprintf(CS p, newformat, ptr);
1414 p += sprintf(CS p, "(nil)");
1418 /* %f format is inherently insecure if the numbers that it may be
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. */
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;
1434 if (length == L_LONGDOUBLE)
1435 p += sprintf(CS p, newformat, va_arg(ap, long double));
1437 p += sprintf(CS p, newformat, va_arg(ap, double));
1443 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1448 if (p >= last) { yield = FALSE; goto END_FORMAT; }
1449 *p++ = va_arg(ap, int);
1452 case 'D': /* Insert daily datestamp for log file names */
1453 s = CS tod_stamp(tod_log_datestamp_daily);
1454 string_datestamp_offset = p - buffer; /* Passed back via global */
1455 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1456 string_datestamp_type = tod_log_datestamp_daily;
1457 slen = string_datestamp_length;
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;
1469 case 'S': /* Forces *lower* case */
1470 case 'T': /* Forces *upper* case */
1471 s = va_arg(ap, char *);
1473 if (s == NULL) s = null;
1476 INSERT_STRING: /* Come to from %D or %M above */
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
1484 if (precision < 0) precision = width;
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. */
1490 else if (precision >= 0)
1492 width = (precision < slen)? precision : slen;
1495 /* If neither are specified, set them both to the string length. */
1497 else width = precision = slen;
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). */
1508 if (p >= last - width)
1511 width = precision = last - p - 1;
1512 if (width < 0) width = 0;
1513 if (precision < 0) precision = 0;
1515 sprintf(CS p, "%*.*s", width, precision, s);
1517 while (*p) { *p = tolower(*p); p++; }
1518 else if (fp[-1] == 'T')
1519 while (*p) { *p = toupper(*p); p++; }
1522 if (!yield) goto END_FORMAT;
1525 /* Some things are never used in Exim; also catches junk. */
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);
1536 /* Ensure string is complete; return TRUE if got to the end of the format */
1546 #ifndef COMPILE_UTILITY
1547 /*************************************************
1548 * Generate an "open failed" message *
1549 *************************************************/
1551 /* This function creates a message after failure to open a file. It includes a
1552 string supplied as data, adds the strerror() text, and if the failure was
1553 "Permission denied", reads and includes the euid and egid.
1556 eno the value of errno after the failure
1557 format a text format string - deliberately not uschar *
1558 ... arguments for the format string
1560 Returns: a message, in dynamic store
1564 string_open_failed(int eno, const char *format, ...)
1567 uschar buffer[1024];
1569 Ustrcpy(buffer, "failed to open ");
1570 va_start(ap, format);
1572 /* Use the checked formatting routine to ensure that the buffer
1573 does not overflow. It should not, since this is called only for internally
1574 specified messages. If it does, the message just gets truncated, and there
1575 doesn't seem much we can do about that. */
1577 (void)string_vformat(buffer+15, sizeof(buffer) - 15, format, ap);
1580 return (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));
1585 #endif /* COMPILE_UTILITY */
1591 #ifndef COMPILE_UTILITY
1592 /* qsort(3), currently used to sort the environment variables
1593 for -bP environment output, needs a function to compare two pointers to string
1594 pointers. Here it is. */
1597 string_compare_by_pointer(const void *a, const void *b)
1599 return Ustrcmp(* CUSS a, * CUSS b);
1601 #endif /* COMPILE_UTILITY */
1605 /*************************************************
1606 **************************************************
1607 * Stand-alone test program *
1608 **************************************************
1609 *************************************************/
1616 printf("Testing is_ip_address\n");
1618 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
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);
1626 printf("Testing string_nextinlist\n");
1628 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1630 uschar *list = buffer;
1638 sep1 = sep2 = list[1];
1645 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1646 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1648 if (item1 == NULL && item2 == NULL) break;
1649 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1651 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1652 (item1 == NULL)? "NULL" : CS item1,
1653 (item2 == NULL)? "NULL" : CS item2);
1656 else printf(" \"%s\"\n", CS item1);
1660 /* This is a horrible lash-up, but it serves its purpose. */
1662 printf("Testing string_format\n");
1664 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1667 long long llargs[3];
1677 buffer[Ustrlen(buffer) - 1] = 0;
1679 s = Ustrchr(buffer, ',');
1680 if (s == NULL) s = buffer + Ustrlen(buffer);
1682 Ustrncpy(format, buffer, s - buffer);
1683 format[s-buffer] = 0;
1690 s = Ustrchr(ss, ',');
1691 if (s == NULL) s = ss + Ustrlen(ss);
1695 Ustrncpy(outbuf, ss, s-ss);
1696 if (Ustrchr(outbuf, '.') != NULL)
1699 dargs[n++] = Ustrtod(outbuf, NULL);
1701 else if (Ustrstr(outbuf, "ll") != NULL)
1704 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1708 args[n++] = (void *)Uatoi(outbuf);
1712 else if (Ustrcmp(ss, "*") == 0)
1714 args[n++] = (void *)(&count);
1720 uschar *sss = malloc(s - ss + 1);
1721 Ustrncpy(sss, ss, s-ss);
1728 if (!dflag && !llflag)
1729 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1730 args[0], args[1], args[2])? "True" : "False");
1733 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1734 dargs[0], dargs[1], dargs[2])? "True" : "False");
1736 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1737 llargs[0], llargs[1], llargs[2])? "True" : "False");
1739 printf("%s\n", CS outbuf);
1740 if (countset) printf("count=%d\n", count);
1747 /* End of string.c */