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)
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;
65 /* An IPv6 address must start with hex digit or double colon. A single
68 if (*s == ':' && *(++s) != ':') return 0;
70 /* Now read up to 8 components consisting of up to 4 hex digits each. There
71 may be one and only one appearance of double colon, which implies any number
72 of binary zero bits. The number of preceding components is held in count. */
74 for (int count = 0; count < 8; count++)
76 /* If the end of the string is reached before reading 8 components, the
77 address is valid provided a double colon has been read. This also applies
78 if we hit the / that introduces a mask or the % that introduces the
79 interface specifier (scope id) of a link-local address. */
81 if (*s == 0 || *s == '%' || *s == '/') return had_double_colon ? yield : 0;
83 /* If a component starts with an additional colon, we have hit a double
84 colon. This is permitted to appear once only, and counts as at least
85 one component. The final component may be of this form. */
89 if (had_double_colon) return 0;
90 had_double_colon = TRUE;
95 /* If the remainder of the string contains a dot but no colons, we
96 can expect a trailing IPv4 address. This is valid if either there has
97 been no double-colon and this is the 7th component (with the IPv4 address
98 being the 7th & 8th components), OR if there has been a double-colon
99 and fewer than 6 components. */
101 if (Ustrchr(s, ':') == NULL && Ustrchr(s, '.') != NULL)
103 if ((!had_double_colon && count != 6) ||
104 (had_double_colon && count > 6)) return 0;
110 /* Check for at least one and not more than 4 hex digits for this
113 if (!isxdigit(*s++)) return 0;
114 if (isxdigit(*s) && isxdigit(*(++s)) && isxdigit(*(++s))) s++;
116 /* If the component is terminated by colon and there is more to
117 follow, skip over the colon. If there is no more to follow the address is
120 if (*s == ':' && *(++s) == 0) return 0;
123 /* If about to handle a trailing IPv4 address, drop through. Otherwise
124 all is well if we are at the end of the string or at the mask or at a percent
125 sign, which introduces the interface specifier (scope id) of a link local
129 return (*s == 0 || *s == '%' ||
130 (*s == '/' && maskptr != NULL && *maskptr != 0))? yield : 0;
133 /* Test for IPv4 address, which may be the tail-end of an IPv6 address. */
135 for (int i = 0; i < 4; i++)
140 if (i != 0 && *s++ != '.') return 0;
141 n = strtol(CCS s, CSS &end, 10);
142 if (n > 255 || n < 0 || end <= s || end > s+3) return 0;
146 return !*s || (*s == '/' && maskptr && *maskptr != 0) ? yield : 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(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 /*************************************************
216 * Interpret escape sequence *
217 *************************************************/
219 /* This function is called from several places where escape sequences are to be
220 interpreted in strings.
223 pp points a pointer to the initiating "\" in the string;
224 the pointer gets updated to point to the final character
225 Returns: the value of the character escape
229 string_interpret_escape(const uschar **pp)
231 #ifdef COMPILE_UTILITY
232 const uschar *hex_digits= CUS"0123456789abcdef";
235 const uschar *p = *pp;
237 if (isdigit(ch) && ch != '8' && ch != '9')
240 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
242 ch = ch * 8 + *(++p) - '0';
243 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
244 ch = ch * 8 + *(++p) - '0';
249 case 'b': ch = '\b'; break;
250 case 'f': ch = '\f'; break;
251 case 'n': ch = '\n'; break;
252 case 'r': ch = '\r'; break;
253 case 't': ch = '\t'; break;
254 case 'v': ch = '\v'; break;
260 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
261 if (isxdigit(p[1])) ch = ch * 16 +
262 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
272 #ifndef COMPILE_UTILITY
273 /*************************************************
274 * Ensure string is printable *
275 *************************************************/
277 /* This function is called for critical strings. It checks for any
278 non-printing characters, and if any are found, it makes a new copy
279 of the string with suitable escape sequences. It is most often called by the
280 macro string_printing(), which sets allow_tab TRUE.
284 allow_tab TRUE to allow tab as a printing character
286 Returns: string with non-printers encoded as printing sequences
290 string_printing2(const uschar *s, BOOL allow_tab)
292 int nonprintcount = 0;
300 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
304 if (nonprintcount == 0) return s;
306 /* Get a new block of store guaranteed big enough to hold the
309 ss = store_get(length + nonprintcount * 3 + 1);
311 /* Copy everything, escaping non printers. */
319 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
324 case '\n': *tt++ = 'n'; break;
325 case '\r': *tt++ = 'r'; break;
326 case '\b': *tt++ = 'b'; break;
327 case '\v': *tt++ = 'v'; break;
328 case '\f': *tt++ = 'f'; break;
329 case '\t': *tt++ = 't'; break;
330 default: sprintf(CS tt, "%03o", *t); tt += 3; break;
338 #endif /* COMPILE_UTILITY */
340 /*************************************************
341 * Undo printing escapes in string *
342 *************************************************/
344 /* This function is the reverse of string_printing2. It searches for
345 backslash characters and if any are found, it makes a new copy of the
346 string with escape sequences parsed. Otherwise it returns the original
352 Returns: string with printing escapes parsed back
356 string_unprinting(uschar *s)
358 uschar *p, *q, *r, *ss;
361 p = Ustrchr(s, '\\');
364 len = Ustrlen(s) + 1;
379 *q++ = string_interpret_escape((const uschar **)&p);
384 r = Ustrchr(p, '\\');
410 #ifdef HAVE_LOCAL_SCAN
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_function(const uschar *s)
424 int len = Ustrlen(s) + 1;
425 uschar *ss = store_get(len);
431 /*************************************************
432 * Copy and save string, given length *
433 *************************************************/
435 /* It is assumed the data contains no zeros. A zero is added
440 n number of characters
442 Returns: copy of string in new store
446 string_copyn_function(const uschar *s, int n)
448 uschar *ss = store_get(n + 1);
456 /*************************************************
457 * Copy and save string in malloc'd store *
458 *************************************************/
460 /* This function assumes that memcpy() is faster than strcpy().
462 Argument: string to copy
463 Returns: copy of string in new store
467 string_copy_malloc(const uschar *s)
469 int len = Ustrlen(s) + 1;
470 uschar *ss = store_malloc(len);
477 /*************************************************
478 * Copy string if long, inserting newlines *
479 *************************************************/
481 /* If the given string is longer than 75 characters, it is copied, and within
482 the copy, certain space characters are converted into newlines.
484 Argument: pointer to the string
485 Returns: pointer to the possibly altered string
489 string_split_message(uschar *msg)
493 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
494 s = ss = msg = string_copy(msg);
499 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
511 if (t[-1] == ':') { tt = t; break; }
512 if (tt == NULL) tt = t;
516 if (tt == NULL) /* Can't split behind - try ahead */
521 if (*t == ' ' || *t == '\n')
527 if (tt == NULL) break; /* Can't find anywhere to split */
538 /*************************************************
539 * Copy returned DNS domain name, de-escaping *
540 *************************************************/
542 /* If a domain name contains top-bit characters, some resolvers return
543 the fully qualified name with those characters turned into escapes. The
544 convention is a backslash followed by _decimal_ digits. We convert these
545 back into the original binary values. This will be relevant when
546 allow_utf8_domains is set true and UTF-8 characters are used in domain
547 names. Backslash can also be used to escape other characters, though we
548 shouldn't come across them in domain names.
550 Argument: the domain name string
551 Returns: copy of string in new store, de-escaped
555 string_copy_dnsdomain(uschar *s)
558 uschar *ss = yield = store_get(Ustrlen(s) + 1);
566 else if (isdigit(s[1]))
568 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
571 else if (*(++s) != 0)
582 #ifndef COMPILE_UTILITY
583 /*************************************************
584 * Copy space-terminated or quoted string *
585 *************************************************/
587 /* This function copies from a string until its end, or until whitespace is
588 encountered, unless the string begins with a double quote, in which case the
589 terminating quote is sought, and escaping within the string is done. The length
590 of a de-quoted string can be no longer than the original, since escaping always
591 turns n characters into 1 character.
593 Argument: pointer to the pointer to the first character, which gets updated
594 Returns: the new string
598 string_dequote(const uschar **sptr)
600 const uschar *s = *sptr;
603 /* First find the end of the string */
606 while (*s != 0 && !isspace(*s)) s++;
610 while (*s && *s != '\"')
612 if (*s == '\\') (void)string_interpret_escape(&s);
618 /* Get enough store to copy into */
620 t = yield = store_get(s - *sptr + 1);
627 while (*s != 0 && !isspace(*s)) *t++ = *s++;
632 while (*s != 0 && *s != '\"')
634 if (*s == '\\') *t++ = string_interpret_escape(&s);
641 /* Update the pointer and return the terminated copy */
647 #endif /* COMPILE_UTILITY */
651 /*************************************************
652 * Format a string and save it *
653 *************************************************/
655 /* The formatting is done by string_vformat, which checks the length of
659 format a printf() format - deliberately char * rather than uschar *
660 because it will most usually be a literal string
661 ... arguments for format
663 Returns: pointer to fresh piece of store containing sprintf'ed string
667 string_sprintf(const char *format, ...)
669 #ifdef COMPILE_UTILITY
670 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
671 gstring g = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
674 gstring * gp = string_get(STRING_SPRINTF_BUFFER_SIZE);
679 va_start(ap, format);
680 gp2 = string_vformat(gp, FALSE, format, ap);
681 gp->s[gp->ptr] = '\0';
685 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
686 "string_sprintf expansion was longer than %d; format string was (%s)\n"
687 "expansion started '%.32s'",
688 gp->size, format, gp->s);
690 #ifdef COMPILE_UTILITY
691 return string_copy(gp->s);
693 gstring_release_unused(gp);
700 /*************************************************
701 * Case-independent strncmp() function *
702 *************************************************/
708 n number of characters to compare
710 Returns: < 0, = 0, or > 0, according to the comparison
714 strncmpic(const uschar *s, const uschar *t, int n)
718 int c = tolower(*s++) - tolower(*t++);
725 /*************************************************
726 * Case-independent strcmp() function *
727 *************************************************/
734 Returns: < 0, = 0, or > 0, according to the comparison
738 strcmpic(const uschar *s, const uschar *t)
742 int c = tolower(*s++) - tolower(*t++);
743 if (c != 0) return c;
749 /*************************************************
750 * Case-independent strstr() function *
751 *************************************************/
753 /* The third argument specifies whether whitespace is required
754 to follow the matched string.
758 t substring to search for
759 space_follows if TRUE, match only if whitespace follows
761 Returns: pointer to substring in string, or NULL if not found
765 strstric(uschar *s, uschar *t, BOOL space_follows)
768 uschar *yield = NULL;
769 int cl = tolower(*p);
770 int cu = toupper(*p);
774 if (*s == cl || *s == cu)
776 if (yield == NULL) yield = s;
779 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
787 else if (yield != NULL)
801 #ifdef COMPILE_UTILITY
802 /* Dummy version for this function; it should never be called */
804 gstring_grow(gstring * g, int p, int count)
812 #ifndef COMPILE_UTILITY
813 /*************************************************
814 * Get next string from separated list *
815 *************************************************/
817 /* Leading and trailing space is removed from each item. The separator in the
818 list is controlled by the int pointed to by the separator argument as follows:
820 If the value is > 0 it is used as the separator. This is typically used for
821 sublists such as slash-separated options. The value is always a printing
824 (If the value is actually > UCHAR_MAX there is only one item in the list.
825 This is used for some cases when called via functions that sometimes
826 plough through lists, and sometimes are given single items.)
828 If the value is <= 0, the string is inspected for a leading <x, where x is an
829 ispunct() or an iscntrl() character. If found, x is used as the separator. If
832 (a) if separator == 0, ':' is used
833 (b) if separator <0, -separator is used
835 In all cases the value of the separator that is used is written back to the
836 int so that it is used on subsequent calls as we progress through the list.
838 A literal ispunct() separator can be represented in an item by doubling, but
839 there is no way to include an iscntrl() separator as part of the data.
842 listptr points to a pointer to the current start of the list; the
843 pointer gets updated to point after the end of the next item
844 separator a pointer to the separator character in an int (see above)
845 buffer where to put a copy of the next string in the list; or
846 NULL if the next string is returned in new memory
847 buflen when buffer is not NULL, the size of buffer; otherwise ignored
849 Returns: pointer to buffer, containing the next substring,
850 or NULL if no more substrings
854 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
856 int sep = *separator;
857 const uschar *s = *listptr;
862 /* This allows for a fixed specified separator to be an iscntrl() character,
863 but at the time of implementation, this is never the case. However, it's best
864 to be conservative. */
866 while (isspace(*s) && *s != sep) s++;
868 /* A change of separator is permitted, so look for a leading '<' followed by an
869 allowed character. */
873 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
877 while (isspace(*s) && *s != sep) s++;
880 sep = sep ? -sep : ':';
884 /* An empty string has no list elements */
886 if (!*s) return NULL;
888 /* Note whether whether or not the separator is an iscntrl() character. */
890 sep_is_special = iscntrl(sep);
892 /* Handle the case when a buffer is provided. */
899 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
900 if (p < buflen - 1) buffer[p++] = *s;
902 while (p > 0 && isspace(buffer[p-1])) p--;
906 /* Handle the case when a buffer is not provided. */
912 /* We know that *s != 0 at this point. However, it might be pointing to a
913 separator, which could indicate an empty string, or (if an ispunct()
914 character) could be doubled to indicate a separator character as data at the
915 start of a string. Avoid getting working memory for an empty item. */
920 if (*s != sep || sep_is_special)
923 return string_copy(US"");
927 /* Not an empty string; the first character is guaranteed to be a data
933 for (ss = s + 1; *ss && *ss != sep; ) ss++;
934 g = string_catn(g, s, ss-s);
936 if (!*s || *++s != sep || sep_is_special) break;
938 while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
939 buffer = string_from_gstring(g);
940 gstring_release_unused(g);
943 /* Update the current pointer and return the new string */
950 static const uschar *
951 Ustrnchr(const uschar * s, int c, unsigned * len)
956 if (!*s) return NULL;
969 /************************************************
970 * Add element to separated list *
971 ************************************************/
972 /* This function is used to build a list, returning an allocated null-terminated
973 growable string. The given element has any embedded separator characters
976 Despite having the same growable-string interface as string_cat() the list is
977 always returned null-terminated.
980 list expanding-string for the list that is being built, or NULL
981 if this is a new list that has no contents yet
982 sep list separator character
983 ele new element to be appended to the list
985 Returns: pointer to the start of the list, changed if copied for expansion.
989 string_append_listele(gstring * list, uschar sep, const uschar * ele)
993 if (list && list->ptr)
994 list = string_catn(list, &sep, 1);
996 while((sp = Ustrchr(ele, sep)))
998 list = string_catn(list, ele, sp-ele+1);
999 list = string_catn(list, &sep, 1);
1002 list = string_cat(list, ele);
1003 (void) string_from_gstring(list);
1009 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1014 if (list && list->ptr)
1015 list = string_catn(list, &sep, 1);
1017 while((sp = Ustrnchr(ele, sep, &len)))
1019 list = string_catn(list, ele, sp-ele+1);
1020 list = string_catn(list, &sep, 1);
1024 list = string_catn(list, ele, len);
1025 (void) string_from_gstring(list);
1031 /* A slightly-bogus listmaker utility; the separator is a string so
1032 can be multiple chars - there is no checking for the element content
1033 containing any of the separator. */
1036 string_append2_listele_n(gstring * list, const uschar * sepstr,
1037 const uschar * ele, unsigned len)
1039 if (list && list->ptr)
1040 list = string_cat(list, sepstr);
1042 list = string_catn(list, ele, len);
1043 (void) string_from_gstring(list);
1049 /************************************************/
1050 /* Add more space to a growable-string.
1053 g the growable-string
1054 p current end of data
1055 count amount to grow by
1059 gstring_grow(gstring * g, int p, int count)
1061 int oldsize = g->size;
1063 /* Mostly, string_cat() is used to build small strings of a few hundred
1064 characters at most. There are times, however, when the strings are very much
1065 longer (for example, a lookup that returns a vast number of alias addresses).
1066 To try to keep things reasonable, we use increments whose size depends on the
1067 existing length of the string. */
1069 unsigned inc = oldsize < 4096 ? 127 : 1023;
1070 g->size = ((p + count + inc) & ~inc) + 1;
1072 /* Try to extend an existing allocation. If the result of calling
1073 store_extend() is false, either there isn't room in the current memory block,
1074 or this string is not the top item on the dynamic store stack. We then have
1075 to get a new chunk of store and copy the old string. When building large
1076 strings, it is helpful to call store_release() on the old string, to release
1077 memory blocks that have become empty. (The block will be freed if the string
1078 is at its start.) However, we can do this only if we know that the old string
1079 was the last item on the dynamic memory stack. This is the case if it matches
1082 if (!store_extend(g->s, oldsize, g->size))
1083 g->s = store_newblock(g->s, g->size, p);
1088 /*************************************************
1089 * Add chars to string *
1090 *************************************************/
1091 /* This function is used when building up strings of unknown length. Room is
1092 always left for a terminating zero to be added to the string that is being
1093 built. This function does not require the string that is being added to be NUL
1094 terminated, because the number of characters to add is given explicitly. It is
1095 sometimes called to extract parts of other strings.
1098 string points to the start of the string that is being built, or NULL
1099 if this is a new string that has no contents yet
1100 s points to characters to add
1101 count count of characters to add; must not exceed the length of s, if s
1104 Returns: pointer to the start of the string, changed if copied for expansion.
1105 Note that a NUL is not added, though space is left for one. This is
1106 because string_cat() is often called multiple times to build up a
1107 string - there's no point adding the NUL till the end.
1110 /* coverity[+alloc] */
1113 string_catn(gstring * g, const uschar *s, int count)
1119 unsigned inc = count < 4096 ? 127 : 1023;
1120 unsigned size = ((count + inc) & ~inc) + 1;
1121 g = string_get(size);
1125 if (p + count >= g->size)
1126 gstring_grow(g, p, count);
1128 /* Because we always specify the exact number of characters to copy, we can
1129 use memcpy(), which is likely to be more efficient than strncopy() because the
1130 latter has to check for zero bytes. */
1132 memcpy(g->s + p, s, count);
1139 string_cat(gstring *string, const uschar *s)
1141 return string_catn(string, s, Ustrlen(s));
1146 /*************************************************
1147 * Append strings to another string *
1148 *************************************************/
1150 /* This function can be used to build a string from many other strings.
1151 It calls string_cat() to do the dirty work.
1154 string expanding-string that is being built, or NULL
1155 if this is a new string that has no contents yet
1156 count the number of strings to append
1157 ... "count" uschar* arguments, which must be valid zero-terminated
1160 Returns: pointer to the start of the string, changed if copied for expansion.
1161 The string is not zero-terminated - see string_cat() above.
1164 __inline__ gstring *
1165 string_append(gstring *string, int count, ...)
1169 va_start(ap, count);
1172 uschar *t = va_arg(ap, uschar *);
1173 string = string_cat(string, t);
1183 /*************************************************
1184 * Format a string with length checks *
1185 *************************************************/
1187 /* This function is used to format a string with checking of the length of the
1188 output for all conversions. It protects Exim from absent-mindedness when
1189 calling functions like debug_printf and string_sprintf, and elsewhere. There
1190 are two different entry points to what is actually the same function, depending
1191 on whether the variable length list of data arguments are given explicitly or
1194 The formats are the usual printf() ones, with some omissions (never used) and
1195 three additions for strings: %S forces lower case, %T forces upper case, and
1196 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1197 (useful in debugging). There is also the addition of %D and %M, which insert
1198 the date in the form used for datestamped log files.
1201 buffer a buffer in which to put the formatted string
1202 buflen the length of the buffer
1203 format the format string - deliberately char * and not uschar *
1204 ... or ap variable list of supplementary arguments
1206 Returns: TRUE if the result fitted in the buffer
1210 string_format(uschar * buffer, int buflen, const char * format, ...)
1212 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1214 va_start(ap, format);
1215 gp = string_vformat(&g, FALSE, format, ap);
1225 /* Bulid or append to a growing-string, sprintf-style.
1227 If the "extend" argument is true, the string passed in can be NULL,
1228 empty, or non-empty.
1230 If the "extend" argument is false, the string passed in may not be NULL,
1231 will not be grown, and is usable in the original place after return.
1232 The return value can be NULL to signify overflow.
1234 Returns the possibly-new (if copy for growth was needed) string,
1239 string_vformat(gstring * g, BOOL extend, const char *format, va_list ap)
1241 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1243 int width, precision, off, lim;
1244 const char * fp = format; /* Deliberately not unsigned */
1246 string_datestamp_offset = -1; /* Datestamp not inserted */
1247 string_datestamp_length = 0; /* Datestamp not inserted */
1248 string_datestamp_type = 0; /* Datestamp not inserted */
1250 #ifdef COMPILE_UTILITY
1255 /* Ensure we have a string, to save on checking later */
1256 if (!g) g = string_get(16);
1257 #endif /*!COMPILE_UTILITY*/
1259 lim = g->size - 1; /* leave one for a nul */
1260 off = g->ptr; /* remember initial offset in gstring */
1262 /* Scan the format and handle the insertions */
1266 int length = L_NORMAL;
1269 const char *null = "NULL"; /* ) These variables */
1270 const char *item_start, *s; /* ) are deliberately */
1271 char newformat[16]; /* ) not unsigned */
1272 char * gp = CS g->s + g->ptr; /* ) */
1274 /* Non-% characters just get copied verbatim */
1278 /* Avoid string_copyn() due to COMPILE_UTILITY */
1279 if (g->ptr >= lim - 1)
1281 if (!extend) return NULL;
1282 gstring_grow(g, g->ptr, 1);
1285 g->s[g->ptr++] = (uschar) *fp++;
1289 /* Deal with % characters. Pick off the width and precision, for checking
1290 strings, skipping over the flag and modifier characters. */
1293 width = precision = -1;
1295 if (strchr("-+ #0", *(++fp)) != NULL)
1297 if (*fp == '#') null = "";
1301 if (isdigit((uschar)*fp))
1303 width = *fp++ - '0';
1304 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1306 else if (*fp == '*')
1308 width = va_arg(ap, int);
1315 precision = va_arg(ap, int);
1319 for (precision = 0; isdigit((uschar)*fp); fp++)
1320 precision = precision*10 + *fp - '0';
1322 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1325 { fp++; length = L_SHORT; }
1326 else if (*fp == 'L')
1327 { fp++; length = L_LONGDOUBLE; }
1328 else if (*fp == 'l')
1330 { fp += 2; length = L_LONGLONG; }
1332 { fp++; length = L_LONG; }
1333 else if (*fp == 'z')
1334 { fp++; length = L_SIZE; }
1336 /* Handle each specific format type. */
1341 nptr = va_arg(ap, int *);
1342 *nptr = g->ptr - off;
1350 width = length > L_LONG ? 24 : 12;
1351 if (g->ptr >= lim - width)
1353 if (!extend) return NULL;
1354 gstring_grow(g, g->ptr, width);
1356 gp = CS g->s + g->ptr;
1358 strncpy(newformat, item_start, fp - item_start);
1359 newformat[fp - item_start] = 0;
1361 /* Short int is promoted to int when passing through ..., so we must use
1362 int for va_arg(). */
1368 g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1370 g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1372 g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1374 g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1381 if (g->ptr >= lim - 24)
1383 if (!extend) return NULL;
1384 gstring_grow(g, g->ptr, 24);
1386 gp = CS g->s + g->ptr;
1388 /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1389 Handle it explicitly. */
1390 if ((ptr = va_arg(ap, void *)))
1392 strncpy(newformat, item_start, fp - item_start);
1393 newformat[fp - item_start] = 0;
1394 g->ptr += sprintf(gp, newformat, ptr);
1397 g->ptr += sprintf(gp, "(nil)");
1401 /* %f format is inherently insecure if the numbers that it may be
1402 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1403 printing load averages, and these are actually stored as integers
1404 (load average * 1000) so the size of the numbers is constrained.
1405 It is also used for formatting sending rates, where the simplicity
1406 of the format prevents overflow. */
1413 if (precision < 0) precision = 6;
1414 if (g->ptr >= lim - precision - 8)
1416 if (!extend) return NULL;
1417 gstring_grow(g, g->ptr, precision+8);
1419 gp = CS g->s + g->ptr;
1421 strncpy(newformat, item_start, fp - item_start);
1422 newformat[fp-item_start] = 0;
1423 if (length == L_LONGDOUBLE)
1424 g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1426 g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1432 if (g->ptr >= lim - 1)
1434 if (!extend) return NULL;
1435 gstring_grow(g, g->ptr, 1);
1438 g->s[g->ptr++] = (uschar) '%';
1442 if (g->ptr >= lim - 1)
1444 if (!extend) return NULL;
1445 gstring_grow(g, g->ptr, 1);
1448 g->s[g->ptr++] = (uschar) va_arg(ap, int);
1451 case 'D': /* Insert daily datestamp for log file names */
1452 s = CS tod_stamp(tod_log_datestamp_daily);
1453 string_datestamp_offset = g->ptr; /* Passed back via global */
1454 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1455 string_datestamp_type = tod_log_datestamp_daily;
1456 slen = string_datestamp_length;
1459 case 'M': /* Insert monthly datestamp for log file names */
1460 s = CS tod_stamp(tod_log_datestamp_monthly);
1461 string_datestamp_offset = g->ptr; /* Passed back via global */
1462 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1463 string_datestamp_type = tod_log_datestamp_monthly;
1464 slen = string_datestamp_length;
1468 case 'S': /* Forces *lower* case */
1469 case 'T': /* Forces *upper* case */
1470 s = va_arg(ap, char *);
1475 INSERT_STRING: /* Come to from %D or %M above */
1478 BOOL truncated = FALSE;
1480 /* If the width is specified, check that there is a precision
1481 set; if not, set it to the width to prevent overruns of long
1486 if (precision < 0) precision = width;
1489 /* If a width is not specified and the precision is specified, set
1490 the width to the precision, or the string length if shorted. */
1492 else if (precision >= 0)
1493 width = precision < slen ? precision : slen;
1495 /* If neither are specified, set them both to the string length. */
1498 width = precision = slen;
1502 if (g->ptr == lim) return NULL;
1503 if (g->ptr >= lim - width)
1506 width = precision = lim - g->ptr - 1;
1507 if (width < 0) width = 0;
1508 if (precision < 0) precision = 0;
1511 else if (g->ptr >= lim - width)
1513 gstring_grow(g, g->ptr, width - (lim - g->ptr));
1515 gp = CS g->s + g->ptr;
1518 g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1520 while (*gp) { *gp = tolower(*gp); gp++; }
1521 else if (fp[-1] == 'T')
1522 while (*gp) { *gp = toupper(*gp); gp++; }
1524 if (truncated) return NULL;
1528 /* Some things are never used in Exim; also catches junk. */
1531 strncpy(newformat, item_start, fp - item_start);
1532 newformat[fp-item_start] = 0;
1533 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1534 "in \"%s\" in \"%s\"", newformat, format);
1544 #ifndef COMPILE_UTILITY
1547 string_fmt_append(gstring * g, const char *format, ...)
1550 va_start(ap, format);
1551 g = string_vformat(g, TRUE, format, ap);
1558 /*************************************************
1559 * Generate an "open failed" message *
1560 *************************************************/
1562 /* This function creates a message after failure to open a file. It includes a
1563 string supplied as data, adds the strerror() text, and if the failure was
1564 "Permission denied", reads and includes the euid and egid.
1567 eno the value of errno after the failure
1568 format a text format string - deliberately not uschar *
1569 ... arguments for the format string
1571 Returns: a message, in dynamic store
1575 string_open_failed(int eno, const char *format, ...)
1578 gstring * g = string_get(1024);
1580 g = string_catn(g, US"failed to open ", 15);
1582 /* Use the checked formatting routine to ensure that the buffer
1583 does not overflow. It should not, since this is called only for internally
1584 specified messages. If it does, the message just gets truncated, and there
1585 doesn't seem much we can do about that. */
1587 va_start(ap, format);
1588 (void) string_vformat(g, FALSE, format, ap);
1589 string_from_gstring(g);
1590 gstring_release_unused(g);
1593 return eno == EACCES
1594 ? string_sprintf("%s: %s (euid=%ld egid=%ld)", g->s, strerror(eno),
1595 (long int)geteuid(), (long int)getegid())
1596 : string_sprintf("%s: %s", g->s, strerror(eno));
1598 #endif /* COMPILE_UTILITY */
1604 #ifndef COMPILE_UTILITY
1605 /* qsort(3), currently used to sort the environment variables
1606 for -bP environment output, needs a function to compare two pointers to string
1607 pointers. Here it is. */
1610 string_compare_by_pointer(const void *a, const void *b)
1612 return Ustrcmp(* CUSS a, * CUSS b);
1614 #endif /* COMPILE_UTILITY */
1619 /*************************************************
1620 **************************************************
1621 * Stand-alone test program *
1622 **************************************************
1623 *************************************************/
1630 printf("Testing is_ip_address\n");
1632 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1635 buffer[Ustrlen(buffer) - 1] = 0;
1636 printf("%d\n", string_is_ip_address(buffer, NULL));
1637 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1640 printf("Testing string_nextinlist\n");
1642 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1644 uschar *list = buffer;
1652 sep1 = sep2 = list[1];
1659 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1660 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1662 if (item1 == NULL && item2 == NULL) break;
1663 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1665 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1666 (item1 == NULL)? "NULL" : CS item1,
1667 (item2 == NULL)? "NULL" : CS item2);
1670 else printf(" \"%s\"\n", CS item1);
1674 /* This is a horrible lash-up, but it serves its purpose. */
1676 printf("Testing string_format\n");
1678 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1681 long long llargs[3];
1691 buffer[Ustrlen(buffer) - 1] = 0;
1693 s = Ustrchr(buffer, ',');
1694 if (s == NULL) s = buffer + Ustrlen(buffer);
1696 Ustrncpy(format, buffer, s - buffer);
1697 format[s-buffer] = 0;
1704 s = Ustrchr(ss, ',');
1705 if (s == NULL) s = ss + Ustrlen(ss);
1709 Ustrncpy(outbuf, ss, s-ss);
1710 if (Ustrchr(outbuf, '.') != NULL)
1713 dargs[n++] = Ustrtod(outbuf, NULL);
1715 else if (Ustrstr(outbuf, "ll") != NULL)
1718 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1722 args[n++] = (void *)Uatoi(outbuf);
1726 else if (Ustrcmp(ss, "*") == 0)
1728 args[n++] = (void *)(&count);
1734 uschar *sss = malloc(s - ss + 1);
1735 Ustrncpy(sss, ss, s-ss);
1742 if (!dflag && !llflag)
1743 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1744 args[0], args[1], args[2])? "True" : "False");
1747 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1748 dargs[0], dargs[1], dargs[2])? "True" : "False");
1750 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1751 llargs[0], llargs[1], llargs[2])? "True" : "False");
1753 printf("%s\n", CS outbuf);
1754 if (countset) printf("count=%d\n", count);
1761 /* End of string.c */