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. */
16 #ifndef COMPILE_UTILITY
17 /*************************************************
18 * Test for IP address *
19 *************************************************/
21 /* This used just to be a regular expression, but with IPv6 things are a bit
22 more complicated. If the address contains a colon, it is assumed to be a v6
23 address (assuming HAVE_IPV6 is set). If a mask is permitted and one is present,
24 and maskptr is not NULL, its offset is placed there.
28 maskptr NULL if no mask is permitted to follow
29 otherwise, points to an int where the offset of '/' is placed
30 if there is no / followed by trailing digits, *maskptr is set 0
32 Returns: 0 if the string is not a textual representation of an IP address
33 4 if it is an IPv4 address
34 6 if it is an IPv6 address
38 string_is_ip_address(const uschar *s, int *maskptr)
43 /* If an optional mask is permitted, check for it. If found, pass back the
48 const uschar *ss = s + Ustrlen(s);
50 if (s != ss && isdigit(*(--ss)))
52 while (ss > s && isdigit(ss[-1])) ss--;
53 if (ss > s && *(--ss) == '/') *maskptr = ss - s;
57 /* A colon anywhere in the string => IPv6 address */
59 if (Ustrchr(s, ':') != NULL)
61 BOOL had_double_colon = FALSE;
67 /* An IPv6 address must start with hex digit or double colon. A single
70 if (*s == ':' && *(++s) != ':') return 0;
72 /* Now read up to 8 components consisting of up to 4 hex digits each. There
73 may be one and only one appearance of double colon, which implies any number
74 of binary zero bits. The number of preceding components is held in count. */
76 for (count = 0; count < 8; count++)
78 /* If the end of the string is reached before reading 8 components, the
79 address is valid provided a double colon has been read. This also applies
80 if we hit the / that introduces a mask or the % that introduces the
81 interface specifier (scope id) of a link-local address. */
83 if (*s == 0 || *s == '%' || *s == '/') return had_double_colon ? yield : 0;
85 /* If a component starts with an additional colon, we have hit a double
86 colon. This is permitted to appear once only, and counts as at least
87 one component. The final component may be of this form. */
91 if (had_double_colon) return 0;
92 had_double_colon = TRUE;
97 /* If the remainder of the string contains a dot but no colons, we
98 can expect a trailing IPv4 address. This is valid if either there has
99 been no double-colon and this is the 7th component (with the IPv4 address
100 being the 7th & 8th components), OR if there has been a double-colon
101 and fewer than 6 components. */
103 if (Ustrchr(s, ':') == NULL && Ustrchr(s, '.') != NULL)
105 if ((!had_double_colon && count != 6) ||
106 (had_double_colon && count > 6)) return 0;
112 /* Check for at least one and not more than 4 hex digits for this
115 if (!isxdigit(*s++)) return 0;
116 if (isxdigit(*s) && isxdigit(*(++s)) && isxdigit(*(++s))) s++;
118 /* If the component is terminated by colon and there is more to
119 follow, skip over the colon. If there is no more to follow the address is
122 if (*s == ':' && *(++s) == 0) return 0;
125 /* If about to handle a trailing IPv4 address, drop through. Otherwise
126 all is well if we are at the end of the string or at the mask or at a percent
127 sign, which introduces the interface specifier (scope id) of a link local
131 return (*s == 0 || *s == '%' ||
132 (*s == '/' && maskptr != NULL && *maskptr != 0))? yield : 0;
135 /* Test for IPv4 address, which may be the tail-end of an IPv6 address. */
137 for (i = 0; i < 4; i++)
142 if (i != 0 && *s++ != '.') return 0;
143 n = strtol(CCS s, CSS &end, 10);
144 if (n > 255 || n < 0 || end <= s || end > s+3) return 0;
148 return !*s || (*s == '/' && maskptr && *maskptr != 0) ? yield : 0;
150 #endif /* COMPILE_UTILITY */
153 /*************************************************
154 * Format message size *
155 *************************************************/
157 /* Convert a message size in bytes to printing form, rounding
158 according to the magnitude of the number. A value of zero causes
159 a string of spaces to be returned.
162 size the message size in bytes
163 buffer where to put the answer
165 Returns: pointer to the buffer
166 a string of exactly 5 characters is normally returned
170 string_format_size(int size, uschar *buffer)
172 if (size == 0) Ustrcpy(buffer, " ");
173 else if (size < 1024) sprintf(CS buffer, "%5d", size);
174 else if (size < 10*1024)
175 sprintf(CS buffer, "%4.1fK", (double)size / 1024.0);
176 else if (size < 1024*1024)
177 sprintf(CS buffer, "%4dK", (size + 512)/1024);
178 else if (size < 10*1024*1024)
179 sprintf(CS buffer, "%4.1fM", (double)size / (1024.0 * 1024.0));
181 sprintf(CS buffer, "%4dM", (size + 512 * 1024)/(1024*1024));
187 #ifndef COMPILE_UTILITY
188 /*************************************************
189 * Convert a number to base 62 format *
190 *************************************************/
192 /* Convert a long integer into an ASCII base 62 string. For Cygwin the value of
193 BASE_62 is actually 36. Always return exactly 6 characters plus zero, in a
196 Argument: a long integer
197 Returns: pointer to base 62 string
201 string_base62(unsigned long int value)
203 static uschar yield[7];
204 uschar *p = yield + sizeof(yield) - 1;
208 *(--p) = base62_chars[value % BASE_62];
213 #endif /* COMPILE_UTILITY */
217 /*************************************************
218 * Interpret escape sequence *
219 *************************************************/
221 /* This function is called from several places where escape sequences are to be
222 interpreted in strings.
225 pp points a pointer to the initiating "\" in the string;
226 the pointer gets updated to point to the final character
227 If the backslash is the last character in the string, it
229 Returns: the value of the character escape
233 string_interpret_escape(const uschar **pp)
235 #ifdef COMPILE_UTILITY
236 const uschar *hex_digits= CUS"0123456789abcdef";
239 const uschar *p = *pp;
241 if (ch == '\0') return **pp;
242 if (isdigit(ch) && ch != '8' && ch != '9')
245 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
247 ch = ch * 8 + *(++p) - '0';
248 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
249 ch = ch * 8 + *(++p) - '0';
254 case 'b': ch = '\b'; break;
255 case 'f': ch = '\f'; break;
256 case 'n': ch = '\n'; break;
257 case 'r': ch = '\r'; break;
258 case 't': ch = '\t'; break;
259 case 'v': ch = '\v'; break;
265 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
266 if (isxdigit(p[1])) ch = ch * 16 +
267 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
277 #ifndef COMPILE_UTILITY
278 /*************************************************
279 * Ensure string is printable *
280 *************************************************/
282 /* This function is called for critical strings. It checks for any
283 non-printing characters, and if any are found, it makes a new copy
284 of the string with suitable escape sequences. It is most often called by the
285 macro string_printing(), which sets allow_tab TRUE.
289 allow_tab TRUE to allow tab as a printing character
291 Returns: string with non-printers encoded as printing sequences
295 string_printing2(const uschar *s, BOOL allow_tab)
297 int nonprintcount = 0;
305 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
309 if (nonprintcount == 0) return s;
311 /* Get a new block of store guaranteed big enough to hold the
314 ss = store_get(length + nonprintcount * 3 + 1);
316 /* Copy everything, escaping non printers. */
324 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
329 case '\n': *tt++ = 'n'; break;
330 case '\r': *tt++ = 'r'; break;
331 case '\b': *tt++ = 'b'; break;
332 case '\v': *tt++ = 'v'; break;
333 case '\f': *tt++ = 'f'; break;
334 case '\t': *tt++ = 't'; break;
335 default: sprintf(CS tt, "%03o", *t); tt += 3; break;
343 #endif /* COMPILE_UTILITY */
345 /*************************************************
346 * Undo printing escapes in string *
347 *************************************************/
349 /* This function is the reverse of string_printing2. It searches for
350 backslash characters and if any are found, it makes a new copy of the
351 string with escape sequences parsed. Otherwise it returns the original
357 Returns: string with printing escapes parsed back
361 string_unprinting(uschar *s)
363 uschar *p, *q, *r, *ss;
366 p = Ustrchr(s, '\\');
369 len = Ustrlen(s) + 1;
384 *q++ = string_interpret_escape((const uschar **)&p);
389 r = Ustrchr(p, '\\');
415 /*************************************************
416 * Copy and save string *
417 *************************************************/
419 /* This function assumes that memcpy() is faster than strcpy().
421 Argument: string to copy
422 Returns: copy of string in new store
426 string_copy(const uschar *s)
428 int len = Ustrlen(s) + 1;
429 uschar *ss = store_get(len);
436 /*************************************************
437 * Copy and save string in malloc'd store *
438 *************************************************/
440 /* This function assumes that memcpy() is faster than strcpy().
442 Argument: string to copy
443 Returns: copy of string in new store
447 string_copy_malloc(const uschar *s)
449 int len = Ustrlen(s) + 1;
450 uschar *ss = store_malloc(len);
457 /*************************************************
458 * Copy, lowercase and save string *
459 *************************************************/
462 Argument: string to copy
463 Returns: copy of string in new store, with letters lowercased
467 string_copylc(const uschar *s)
469 uschar *ss = store_get(Ustrlen(s) + 1);
471 while (*s != 0) *p++ = tolower(*s++);
478 /*************************************************
479 * Copy and save string, given length *
480 *************************************************/
482 /* It is assumed the data contains no zeros. A zero is added
487 n number of characters
489 Returns: copy of string in new store
493 string_copyn(const uschar *s, int n)
495 uschar *ss = store_get(n + 1);
502 /*************************************************
503 * Copy, lowercase, and save string, given length *
504 *************************************************/
506 /* It is assumed the data contains no zeros. A zero is added
511 n number of characters
513 Returns: copy of string in new store, with letters lowercased
517 string_copynlc(uschar *s, int n)
519 uschar *ss = store_get(n + 1);
521 while (n-- > 0) *p++ = tolower(*s++);
528 /*************************************************
529 * Copy string if long, inserting newlines *
530 *************************************************/
532 /* If the given string is longer than 75 characters, it is copied, and within
533 the copy, certain space characters are converted into newlines.
535 Argument: pointer to the string
536 Returns: pointer to the possibly altered string
540 string_split_message(uschar *msg)
544 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
545 s = ss = msg = string_copy(msg);
550 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
562 if (t[-1] == ':') { tt = t; break; }
563 if (tt == NULL) tt = t;
567 if (tt == NULL) /* Can't split behind - try ahead */
572 if (*t == ' ' || *t == '\n')
578 if (tt == NULL) break; /* Can't find anywhere to split */
589 /*************************************************
590 * Copy returned DNS domain name, de-escaping *
591 *************************************************/
593 /* If a domain name contains top-bit characters, some resolvers return
594 the fully qualified name with those characters turned into escapes. The
595 convention is a backslash followed by _decimal_ digits. We convert these
596 back into the original binary values. This will be relevant when
597 allow_utf8_domains is set true and UTF-8 characters are used in domain
598 names. Backslash can also be used to escape other characters, though we
599 shouldn't come across them in domain names.
601 Argument: the domain name string
602 Returns: copy of string in new store, de-escaped
606 string_copy_dnsdomain(uschar *s)
609 uschar *ss = yield = store_get(Ustrlen(s) + 1);
617 else if (isdigit(s[1]))
619 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
622 else if (*(++s) != 0)
633 #ifndef COMPILE_UTILITY
634 /*************************************************
635 * Copy space-terminated or quoted string *
636 *************************************************/
638 /* This function copies from a string until its end, or until whitespace is
639 encountered, unless the string begins with a double quote, in which case the
640 terminating quote is sought, and escaping within the string is done. The length
641 of a de-quoted string can be no longer than the original, since escaping always
642 turns n characters into 1 character.
644 Argument: pointer to the pointer to the first character, which gets updated
645 Returns: the new string
649 string_dequote(const uschar **sptr)
651 const uschar *s = *sptr;
654 /* First find the end of the string */
657 while (*s != 0 && !isspace(*s)) s++;
661 while (*s && *s != '\"')
663 if (*s == '\\') (void)string_interpret_escape(&s);
669 /* Get enough store to copy into */
671 t = yield = store_get(s - *sptr + 1);
678 while (*s != 0 && !isspace(*s)) *t++ = *s++;
683 while (*s != 0 && *s != '\"')
685 if (*s == '\\') *t++ = string_interpret_escape(&s);
692 /* Update the pointer and return the terminated copy */
698 #endif /* COMPILE_UTILITY */
702 /*************************************************
703 * Format a string and save it *
704 *************************************************/
706 /* The formatting is done by string_vformat, which checks the length of
710 format a printf() format - deliberately char * rather than uschar *
711 because it will most usually be a literal string
712 ... arguments for format
714 Returns: pointer to fresh piece of store containing sprintf'ed string
718 string_sprintf(const char *format, ...)
720 #ifdef COMPILE_UTILITY
721 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
722 gstring g = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
725 gstring * gp = string_get(STRING_SPRINTF_BUFFER_SIZE);
730 va_start(ap, format);
731 gp2 = string_vformat(gp, FALSE, format, ap);
732 gp->s[gp->ptr] = '\0';
736 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
737 "string_sprintf expansion was longer than %d; format string was (%s)\n"
738 "expansion started '%.32s'",
739 gp->size, format, gp->s);
741 #ifdef COMPILE_UTILITY
742 return string_copy(gp->s);
744 gstring_reset_unused(gp);
751 /*************************************************
752 * Case-independent strncmp() function *
753 *************************************************/
759 n number of characters to compare
761 Returns: < 0, = 0, or > 0, according to the comparison
765 strncmpic(const uschar *s, const uschar *t, int n)
769 int c = tolower(*s++) - tolower(*t++);
776 /*************************************************
777 * Case-independent strcmp() function *
778 *************************************************/
785 Returns: < 0, = 0, or > 0, according to the comparison
789 strcmpic(const uschar *s, const uschar *t)
793 int c = tolower(*s++) - tolower(*t++);
794 if (c != 0) return c;
800 /*************************************************
801 * Case-independent strstr() function *
802 *************************************************/
804 /* The third argument specifies whether whitespace is required
805 to follow the matched string.
809 t substring to search for
810 space_follows if TRUE, match only if whitespace follows
812 Returns: pointer to substring in string, or NULL if not found
816 strstric(uschar *s, uschar *t, BOOL space_follows)
819 uschar *yield = NULL;
820 int cl = tolower(*p);
821 int cu = toupper(*p);
825 if (*s == cl || *s == cu)
827 if (yield == NULL) yield = s;
830 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
838 else if (yield != NULL)
852 #ifdef COMPILE_UTILITY
853 /* Dummy version for this function; it should never be called */
855 gstring_grow(gstring * g, int p, int count)
863 #ifndef COMPILE_UTILITY
864 /*************************************************
865 * Get next string from separated list *
866 *************************************************/
868 /* Leading and trailing space is removed from each item. The separator in the
869 list is controlled by the int pointed to by the separator argument as follows:
871 If the value is > 0 it is used as the separator. This is typically used for
872 sublists such as slash-separated options. The value is always a printing
875 (If the value is actually > UCHAR_MAX there is only one item in the list.
876 This is used for some cases when called via functions that sometimes
877 plough through lists, and sometimes are given single items.)
879 If the value is <= 0, the string is inspected for a leading <x, where x is an
880 ispunct() or an iscntrl() character. If found, x is used as the separator. If
883 (a) if separator == 0, ':' is used
884 (b) if separator <0, -separator is used
886 In all cases the value of the separator that is used is written back to the
887 int so that it is used on subsequent calls as we progress through the list.
889 A literal ispunct() separator can be represented in an item by doubling, but
890 there is no way to include an iscntrl() separator as part of the data.
893 listptr points to a pointer to the current start of the list; the
894 pointer gets updated to point after the end of the next item
895 separator a pointer to the separator character in an int (see above)
896 buffer where to put a copy of the next string in the list; or
897 NULL if the next string is returned in new memory
898 buflen when buffer is not NULL, the size of buffer; otherwise ignored
900 Returns: pointer to buffer, containing the next substring,
901 or NULL if no more substrings
905 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
907 int sep = *separator;
908 const uschar *s = *listptr;
913 /* This allows for a fixed specified separator to be an iscntrl() character,
914 but at the time of implementation, this is never the case. However, it's best
915 to be conservative. */
917 while (isspace(*s) && *s != sep) s++;
919 /* A change of separator is permitted, so look for a leading '<' followed by an
920 allowed character. */
924 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
928 while (isspace(*s) && *s != sep) s++;
931 sep = sep ? -sep : ':';
935 /* An empty string has no list elements */
937 if (!*s) return NULL;
939 /* Note whether whether or not the separator is an iscntrl() character. */
941 sep_is_special = iscntrl(sep);
943 /* Handle the case when a buffer is provided. */
950 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
951 if (p < buflen - 1) buffer[p++] = *s;
953 while (p > 0 && isspace(buffer[p-1])) p--;
957 /* Handle the case when a buffer is not provided. */
964 /* We know that *s != 0 at this point. However, it might be pointing to a
965 separator, which could indicate an empty string, or (if an ispunct()
966 character) could be doubled to indicate a separator character as data at the
967 start of a string. Avoid getting working memory for an empty item. */
972 if (*s != sep || sep_is_special)
975 return string_copy(US"");
979 /* Not an empty string; the first character is guaranteed to be a data
984 for (ss = s + 1; *ss && *ss != sep; ss++) ;
985 g = string_catn(g, s, ss-s);
987 if (!*s || *++s != sep || sep_is_special) break;
989 while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
990 buffer = string_from_gstring(g);
991 gstring_reset_unused(g);
994 /* Update the current pointer and return the new string */
1001 static const uschar *
1002 Ustrnchr(const uschar * s, int c, unsigned * len)
1004 unsigned siz = *len;
1007 if (!*s) return NULL;
1020 /************************************************
1021 * Add element to separated list *
1022 ************************************************/
1023 /* This function is used to build a list, returning an allocated null-terminated
1024 growable string. The given element has any embedded separator characters
1027 Despite having the same growable-string interface as string_cat() the list is
1028 always returned null-terminated.
1031 list expanding-string for the list that is being built, or NULL
1032 if this is a new list that has no contents yet
1033 sep list separator character
1034 ele new element to be appended to the list
1036 Returns: pointer to the start of the list, changed if copied for expansion.
1040 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1044 if (list && list->ptr)
1045 list = string_catn(list, &sep, 1);
1047 while((sp = Ustrchr(ele, sep)))
1049 list = string_catn(list, ele, sp-ele+1);
1050 list = string_catn(list, &sep, 1);
1053 list = string_cat(list, ele);
1054 (void) string_from_gstring(list);
1060 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1065 if (list && list->ptr)
1066 list = string_catn(list, &sep, 1);
1068 while((sp = Ustrnchr(ele, sep, &len)))
1070 list = string_catn(list, ele, sp-ele+1);
1071 list = string_catn(list, &sep, 1);
1075 list = string_catn(list, ele, len);
1076 (void) string_from_gstring(list);
1082 /* A slightly-bogus listmaker utility; the separator is a string so
1083 can be multiple chars - there is no checking for the element content
1084 containing any of the separator. */
1087 string_append2_listele_n(gstring * list, const uschar * sepstr,
1088 const uschar * ele, unsigned len)
1090 if (list && list->ptr)
1091 list = string_cat(list, sepstr);
1093 list = string_catn(list, ele, len);
1094 (void) string_from_gstring(list);
1100 /************************************************/
1101 /* Create a growable-string with some preassigned space */
1104 string_get(unsigned size)
1106 gstring * g = store_get(sizeof(gstring) + size);
1113 /* NUL-terminate the C string in the growable-string, and return it. */
1116 string_from_gstring(gstring * g)
1118 if (!g) return NULL;
1119 g->s[g->ptr] = '\0';
1124 gstring_reset_unused(gstring * g)
1126 store_reset(g->s + (g->size = g->ptr + 1));
1130 /* Add more space to a growable-string.
1133 g the growable-string
1134 p current end of data
1135 count amount to grow by
1139 gstring_grow(gstring * g, int p, int count)
1141 int oldsize = g->size;
1143 /* Mostly, string_cat() is used to build small strings of a few hundred
1144 characters at most. There are times, however, when the strings are very much
1145 longer (for example, a lookup that returns a vast number of alias addresses).
1146 To try to keep things reasonable, we use increments whose size depends on the
1147 existing length of the string. */
1149 unsigned inc = oldsize < 4096 ? 127 : 1023;
1150 g->size = ((p + count + inc) & ~inc) + 1;
1152 /* Try to extend an existing allocation. If the result of calling
1153 store_extend() is false, either there isn't room in the current memory block,
1154 or this string is not the top item on the dynamic store stack. We then have
1155 to get a new chunk of store and copy the old string. When building large
1156 strings, it is helpful to call store_release() on the old string, to release
1157 memory blocks that have become empty. (The block will be freed if the string
1158 is at its start.) However, we can do this only if we know that the old string
1159 was the last item on the dynamic memory stack. This is the case if it matches
1162 if (!store_extend(g->s, oldsize, g->size))
1163 g->s = store_newblock(g->s, g->size, p);
1168 /*************************************************
1169 * Add chars to string *
1170 *************************************************/
1171 /* This function is used when building up strings of unknown length. Room is
1172 always left for a terminating zero to be added to the string that is being
1173 built. This function does not require the string that is being added to be NUL
1174 terminated, because the number of characters to add is given explicitly. It is
1175 sometimes called to extract parts of other strings.
1178 string points to the start of the string that is being built, or NULL
1179 if this is a new string that has no contents yet
1180 s points to characters to add
1181 count count of characters to add; must not exceed the length of s, if s
1184 Returns: pointer to the start of the string, changed if copied for expansion.
1185 Note that a NUL is not added, though space is left for one. This is
1186 because string_cat() is often called multiple times to build up a
1187 string - there's no point adding the NUL till the end.
1190 /* coverity[+alloc] */
1193 string_catn(gstring * g, const uschar *s, int count)
1199 unsigned inc = count < 4096 ? 127 : 1023;
1200 unsigned size = ((count + inc) & ~inc) + 1;
1201 g = string_get(size);
1205 if (p + count >= g->size)
1206 gstring_grow(g, p, count);
1208 /* Because we always specify the exact number of characters to copy, we can
1209 use memcpy(), which is likely to be more efficient than strncopy() because the
1210 latter has to check for zero bytes. */
1212 memcpy(g->s + p, s, count);
1219 string_cat(gstring *string, const uschar *s)
1221 return string_catn(string, s, Ustrlen(s));
1226 /*************************************************
1227 * Append strings to another string *
1228 *************************************************/
1230 /* This function can be used to build a string from many other strings.
1231 It calls string_cat() to do the dirty work.
1234 string expanding-string that is being built, or NULL
1235 if this is a new string that has no contents yet
1236 count the number of strings to append
1237 ... "count" uschar* arguments, which must be valid zero-terminated
1240 Returns: pointer to the start of the string, changed if copied for expansion.
1241 The string is not zero-terminated - see string_cat() above.
1244 __inline__ gstring *
1245 string_append(gstring *string, int count, ...)
1249 va_start(ap, count);
1252 uschar *t = va_arg(ap, uschar *);
1253 string = string_cat(string, t);
1263 /*************************************************
1264 * Format a string with length checks *
1265 *************************************************/
1267 /* This function is used to format a string with checking of the length of the
1268 output for all conversions. It protects Exim from absent-mindedness when
1269 calling functions like debug_printf and string_sprintf, and elsewhere. There
1270 are two different entry points to what is actually the same function, depending
1271 on whether the variable length list of data arguments are given explicitly or
1274 The formats are the usual printf() ones, with some omissions (never used) and
1275 three additions for strings: %S forces lower case, %T forces upper case, and
1276 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1277 (useful in debugging). There is also the addition of %D and %M, which insert
1278 the date in the form used for datestamped log files.
1281 buffer a buffer in which to put the formatted string
1282 buflen the length of the buffer
1283 format the format string - deliberately char * and not uschar *
1284 ... or ap variable list of supplementary arguments
1286 Returns: TRUE if the result fitted in the buffer
1290 string_format(uschar * buffer, int buflen, const char * format, ...)
1292 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1294 va_start(ap, format);
1295 gp = string_vformat(&g, FALSE, format, ap);
1305 /* Bulid or append to a growing-string, sprintf-style.
1307 If the "extend" argument is true, the string passed in can be NULL,
1308 empty, or non-empty.
1310 If the "extend" argument is false, the string passed in may not be NULL,
1311 will not be grown, and is usable in the original place after return.
1312 The return value can be NULL to signify overflow.
1314 Returns the possibly-new (if copy for growth was needed) string,
1319 string_vformat(gstring * g, BOOL extend, const char *format, va_list ap)
1321 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1323 int width, precision, off, lim;
1324 const char * fp = format; /* Deliberately not unsigned */
1326 string_datestamp_offset = -1; /* Datestamp not inserted */
1327 string_datestamp_length = 0; /* Datestamp not inserted */
1328 string_datestamp_type = 0; /* Datestamp not inserted */
1330 #ifdef COMPILE_UTILITY
1335 /* Ensure we have a string, to save on checking later */
1336 if (!g) g = string_get(16);
1337 #endif /*!COMPILE_UTILITY*/
1339 lim = g->size - 1; /* leave one for a nul */
1340 off = g->ptr; /* remember initial offset in gstring */
1342 /* Scan the format and handle the insertions */
1346 int length = L_NORMAL;
1349 const char *null = "NULL"; /* ) These variables */
1350 const char *item_start, *s; /* ) are deliberately */
1351 char newformat[16]; /* ) not unsigned */
1352 char * gp = CS g->s + g->ptr; /* ) */
1354 /* Non-% characters just get copied verbatim */
1358 /* Avoid string_copyn() due to COMPILE_UTILITY */
1359 if (g->ptr >= lim - 1)
1361 if (!extend) return NULL;
1362 gstring_grow(g, g->ptr, 1);
1365 g->s[g->ptr++] = (uschar) *fp++;
1369 /* Deal with % characters. Pick off the width and precision, for checking
1370 strings, skipping over the flag and modifier characters. */
1373 width = precision = -1;
1375 if (strchr("-+ #0", *(++fp)) != NULL)
1377 if (*fp == '#') null = "";
1381 if (isdigit((uschar)*fp))
1383 width = *fp++ - '0';
1384 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1386 else if (*fp == '*')
1388 width = va_arg(ap, int);
1395 precision = va_arg(ap, int);
1399 for (precision = 0; isdigit((uschar)*fp); fp++)
1400 precision = precision*10 + *fp - '0';
1402 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1405 { fp++; length = L_SHORT; }
1406 else if (*fp == 'L')
1407 { fp++; length = L_LONGDOUBLE; }
1408 else if (*fp == 'l')
1410 { fp += 2; length = L_LONGLONG; }
1412 { fp++; length = L_LONG; }
1413 else if (*fp == 'z')
1414 { fp++; length = L_SIZE; }
1416 /* Handle each specific format type. */
1421 nptr = va_arg(ap, int *);
1422 *nptr = g->ptr - off;
1430 width = length > L_LONG ? 24 : 12;
1431 if (g->ptr >= lim - width)
1433 if (!extend) return NULL;
1434 gstring_grow(g, g->ptr, width);
1436 gp = CS g->s + g->ptr;
1438 strncpy(newformat, item_start, fp - item_start);
1439 newformat[fp - item_start] = 0;
1441 /* Short int is promoted to int when passing through ..., so we must use
1442 int for va_arg(). */
1448 g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1450 g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1452 g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1454 g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1461 if (g->ptr >= lim - 24)
1463 if (!extend) return NULL;
1464 gstring_grow(g, g->ptr, 24);
1466 gp = CS g->s + g->ptr;
1468 /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1469 Handle it explicitly. */
1470 if ((ptr = va_arg(ap, void *)))
1472 strncpy(newformat, item_start, fp - item_start);
1473 newformat[fp - item_start] = 0;
1474 g->ptr += sprintf(gp, newformat, ptr);
1477 g->ptr += sprintf(gp, "(nil)");
1481 /* %f format is inherently insecure if the numbers that it may be
1482 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1483 printing load averages, and these are actually stored as integers
1484 (load average * 1000) so the size of the numbers is constrained.
1485 It is also used for formatting sending rates, where the simplicity
1486 of the format prevents overflow. */
1493 if (precision < 0) precision = 6;
1494 if (g->ptr >= lim - precision - 8)
1496 if (!extend) return NULL;
1497 gstring_grow(g, g->ptr, precision+8);
1499 gp = CS g->s + g->ptr;
1501 strncpy(newformat, item_start, fp - item_start);
1502 newformat[fp-item_start] = 0;
1503 if (length == L_LONGDOUBLE)
1504 g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1506 g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1512 if (g->ptr >= lim - 1)
1514 if (!extend) return NULL;
1515 gstring_grow(g, g->ptr, 1);
1518 g->s[g->ptr++] = (uschar) '%';
1522 if (g->ptr >= lim - 1)
1524 if (!extend) return NULL;
1525 gstring_grow(g, g->ptr, 1);
1528 g->s[g->ptr++] = (uschar) va_arg(ap, int);
1531 case 'D': /* Insert daily datestamp for log file names */
1532 s = CS tod_stamp(tod_log_datestamp_daily);
1533 string_datestamp_offset = g->ptr; /* Passed back via global */
1534 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1535 string_datestamp_type = tod_log_datestamp_daily;
1536 slen = string_datestamp_length;
1539 case 'M': /* Insert monthly datestamp for log file names */
1540 s = CS tod_stamp(tod_log_datestamp_monthly);
1541 string_datestamp_offset = g->ptr; /* Passed back via global */
1542 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1543 string_datestamp_type = tod_log_datestamp_monthly;
1544 slen = string_datestamp_length;
1548 case 'S': /* Forces *lower* case */
1549 case 'T': /* Forces *upper* case */
1550 s = va_arg(ap, char *);
1555 INSERT_STRING: /* Come to from %D or %M above */
1558 BOOL truncated = FALSE;
1560 /* If the width is specified, check that there is a precision
1561 set; if not, set it to the width to prevent overruns of long
1566 if (precision < 0) precision = width;
1569 /* If a width is not specified and the precision is specified, set
1570 the width to the precision, or the string length if shorted. */
1572 else if (precision >= 0)
1573 width = precision < slen ? precision : slen;
1575 /* If neither are specified, set them both to the string length. */
1578 width = precision = slen;
1582 if (g->ptr == lim) return NULL;
1583 if (g->ptr >= lim - width)
1586 width = precision = lim - g->ptr - 1;
1587 if (width < 0) width = 0;
1588 if (precision < 0) precision = 0;
1591 else if (g->ptr >= lim - width)
1593 gstring_grow(g, g->ptr, width - (lim - g->ptr));
1595 gp = CS g->s + g->ptr;
1598 g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1600 while (*gp) { *gp = tolower(*gp); gp++; }
1601 else if (fp[-1] == 'T')
1602 while (*gp) { *gp = toupper(*gp); gp++; }
1604 if (truncated) return NULL;
1608 /* Some things are never used in Exim; also catches junk. */
1611 strncpy(newformat, item_start, fp - item_start);
1612 newformat[fp-item_start] = 0;
1613 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1614 "in \"%s\" in \"%s\"", newformat, format);
1624 #ifndef COMPILE_UTILITY
1627 string_fmt_append(gstring * g, const char *format, ...)
1630 va_start(ap, format);
1631 g = string_vformat(g, TRUE, format, ap);
1638 /*************************************************
1639 * Generate an "open failed" message *
1640 *************************************************/
1642 /* This function creates a message after failure to open a file. It includes a
1643 string supplied as data, adds the strerror() text, and if the failure was
1644 "Permission denied", reads and includes the euid and egid.
1647 eno the value of errno after the failure
1648 format a text format string - deliberately not uschar *
1649 ... arguments for the format string
1651 Returns: a message, in dynamic store
1655 string_open_failed(int eno, const char *format, ...)
1658 gstring * g = string_get(1024);
1660 g = string_catn(g, US"failed to open ", 15);
1662 /* Use the checked formatting routine to ensure that the buffer
1663 does not overflow. It should not, since this is called only for internally
1664 specified messages. If it does, the message just gets truncated, and there
1665 doesn't seem much we can do about that. */
1667 va_start(ap, format);
1668 (void) string_vformat(g, FALSE, format, ap);
1669 string_from_gstring(g);
1670 gstring_reset_unused(g);
1673 return eno == EACCES
1674 ? string_sprintf("%s: %s (euid=%ld egid=%ld)", g->s, strerror(eno),
1675 (long int)geteuid(), (long int)getegid())
1676 : string_sprintf("%s: %s", g->s, strerror(eno));
1678 #endif /* COMPILE_UTILITY */
1684 #ifndef COMPILE_UTILITY
1685 /* qsort(3), currently used to sort the environment variables
1686 for -bP environment output, needs a function to compare two pointers to string
1687 pointers. Here it is. */
1690 string_compare_by_pointer(const void *a, const void *b)
1692 return Ustrcmp(* CUSS a, * CUSS b);
1694 #endif /* COMPILE_UTILITY */
1699 /*************************************************
1700 **************************************************
1701 * Stand-alone test program *
1702 **************************************************
1703 *************************************************/
1710 printf("Testing is_ip_address\n");
1712 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1715 buffer[Ustrlen(buffer) - 1] = 0;
1716 printf("%d\n", string_is_ip_address(buffer, NULL));
1717 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1720 printf("Testing string_nextinlist\n");
1722 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1724 uschar *list = buffer;
1732 sep1 = sep2 = list[1];
1739 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1740 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1742 if (item1 == NULL && item2 == NULL) break;
1743 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1745 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1746 (item1 == NULL)? "NULL" : CS item1,
1747 (item2 == NULL)? "NULL" : CS item2);
1750 else printf(" \"%s\"\n", CS item1);
1754 /* This is a horrible lash-up, but it serves its purpose. */
1756 printf("Testing string_format\n");
1758 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1761 long long llargs[3];
1771 buffer[Ustrlen(buffer) - 1] = 0;
1773 s = Ustrchr(buffer, ',');
1774 if (s == NULL) s = buffer + Ustrlen(buffer);
1776 Ustrncpy(format, buffer, s - buffer);
1777 format[s-buffer] = 0;
1784 s = Ustrchr(ss, ',');
1785 if (s == NULL) s = ss + Ustrlen(ss);
1789 Ustrncpy(outbuf, ss, s-ss);
1790 if (Ustrchr(outbuf, '.') != NULL)
1793 dargs[n++] = Ustrtod(outbuf, NULL);
1795 else if (Ustrstr(outbuf, "ll") != NULL)
1798 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1802 args[n++] = (void *)Uatoi(outbuf);
1806 else if (Ustrcmp(ss, "*") == 0)
1808 args[n++] = (void *)(&count);
1814 uschar *sss = malloc(s - ss + 1);
1815 Ustrncpy(sss, ss, s-ss);
1822 if (!dflag && !llflag)
1823 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1824 args[0], args[1], args[2])? "True" : "False");
1827 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1828 dargs[0], dargs[1], dargs[2])? "True" : "False");
1830 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1831 llargs[0], llargs[1], llargs[2])? "True" : "False");
1833 printf("%s\n", CS outbuf);
1834 if (countset) printf("count=%d\n", count);
1841 /* End of string.c */