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 Returns: the value of the character escape
231 string_interpret_escape(const uschar **pp)
233 #ifdef COMPILE_UTILITY
234 const uschar *hex_digits= CUS"0123456789abcdef";
237 const uschar *p = *pp;
239 if (isdigit(ch) && ch != '8' && ch != '9')
242 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
244 ch = ch * 8 + *(++p) - '0';
245 if (isdigit(p[1]) && p[1] != '8' && p[1] != '9')
246 ch = ch * 8 + *(++p) - '0';
251 case 'b': ch = '\b'; break;
252 case 'f': ch = '\f'; break;
253 case 'n': ch = '\n'; break;
254 case 'r': ch = '\r'; break;
255 case 't': ch = '\t'; break;
256 case 'v': ch = '\v'; break;
262 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
263 if (isxdigit(p[1])) ch = ch * 16 +
264 Ustrchr(hex_digits, tolower(*(++p))) - hex_digits;
274 #ifndef COMPILE_UTILITY
275 /*************************************************
276 * Ensure string is printable *
277 *************************************************/
279 /* This function is called for critical strings. It checks for any
280 non-printing characters, and if any are found, it makes a new copy
281 of the string with suitable escape sequences. It is most often called by the
282 macro string_printing(), which sets allow_tab TRUE.
286 allow_tab TRUE to allow tab as a printing character
288 Returns: string with non-printers encoded as printing sequences
292 string_printing2(const uschar *s, BOOL allow_tab)
294 int nonprintcount = 0;
302 if (!mac_isprint(c) || (!allow_tab && c == '\t')) nonprintcount++;
306 if (nonprintcount == 0) return s;
308 /* Get a new block of store guaranteed big enough to hold the
311 ss = store_get(length + nonprintcount * 3 + 1);
313 /* Copy everything, escaping non printers. */
321 if (mac_isprint(c) && (allow_tab || c != '\t')) *tt++ = *t++; else
326 case '\n': *tt++ = 'n'; break;
327 case '\r': *tt++ = 'r'; break;
328 case '\b': *tt++ = 'b'; break;
329 case '\v': *tt++ = 'v'; break;
330 case '\f': *tt++ = 'f'; break;
331 case '\t': *tt++ = 't'; break;
332 default: sprintf(CS tt, "%03o", *t); tt += 3; break;
340 #endif /* COMPILE_UTILITY */
342 /*************************************************
343 * Undo printing escapes in string *
344 *************************************************/
346 /* This function is the reverse of string_printing2. It searches for
347 backslash characters and if any are found, it makes a new copy of the
348 string with escape sequences parsed. Otherwise it returns the original
354 Returns: string with printing escapes parsed back
358 string_unprinting(uschar *s)
360 uschar *p, *q, *r, *ss;
363 p = Ustrchr(s, '\\');
366 len = Ustrlen(s) + 1;
381 *q++ = string_interpret_escape((const uschar **)&p);
386 r = Ustrchr(p, '\\');
412 /*************************************************
413 * Copy and save string *
414 *************************************************/
416 /* This function assumes that memcpy() is faster than strcpy().
418 Argument: string to copy
419 Returns: copy of string in new store
423 string_copy(const uschar *s)
425 int len = Ustrlen(s) + 1;
426 uschar *ss = store_get(len);
433 /*************************************************
434 * Copy and save string in malloc'd store *
435 *************************************************/
437 /* This function assumes that memcpy() is faster than strcpy().
439 Argument: string to copy
440 Returns: copy of string in new store
444 string_copy_malloc(const uschar *s)
446 int len = Ustrlen(s) + 1;
447 uschar *ss = store_malloc(len);
454 /*************************************************
455 * Copy, lowercase and save string *
456 *************************************************/
459 Argument: string to copy
460 Returns: copy of string in new store, with letters lowercased
464 string_copylc(const uschar *s)
466 uschar *ss = store_get(Ustrlen(s) + 1);
468 while (*s != 0) *p++ = tolower(*s++);
475 /*************************************************
476 * Copy and save string, given length *
477 *************************************************/
479 /* It is assumed the data contains no zeros. A zero is added
484 n number of characters
486 Returns: copy of string in new store
490 string_copyn(const uschar *s, int n)
492 uschar *ss = store_get(n + 1);
499 /*************************************************
500 * Copy, lowercase, and save string, given length *
501 *************************************************/
503 /* It is assumed the data contains no zeros. A zero is added
508 n number of characters
510 Returns: copy of string in new store, with letters lowercased
514 string_copynlc(uschar *s, int n)
516 uschar *ss = store_get(n + 1);
518 while (n-- > 0) *p++ = tolower(*s++);
525 /*************************************************
526 * Copy string if long, inserting newlines *
527 *************************************************/
529 /* If the given string is longer than 75 characters, it is copied, and within
530 the copy, certain space characters are converted into newlines.
532 Argument: pointer to the string
533 Returns: pointer to the possibly altered string
537 string_split_message(uschar *msg)
541 if (msg == NULL || Ustrlen(msg) <= 75) return msg;
542 s = ss = msg = string_copy(msg);
547 while (i < 75 && *ss != 0 && *ss != '\n') ss++, i++;
559 if (t[-1] == ':') { tt = t; break; }
560 if (tt == NULL) tt = t;
564 if (tt == NULL) /* Can't split behind - try ahead */
569 if (*t == ' ' || *t == '\n')
575 if (tt == NULL) break; /* Can't find anywhere to split */
586 /*************************************************
587 * Copy returned DNS domain name, de-escaping *
588 *************************************************/
590 /* If a domain name contains top-bit characters, some resolvers return
591 the fully qualified name with those characters turned into escapes. The
592 convention is a backslash followed by _decimal_ digits. We convert these
593 back into the original binary values. This will be relevant when
594 allow_utf8_domains is set true and UTF-8 characters are used in domain
595 names. Backslash can also be used to escape other characters, though we
596 shouldn't come across them in domain names.
598 Argument: the domain name string
599 Returns: copy of string in new store, de-escaped
603 string_copy_dnsdomain(uschar *s)
606 uschar *ss = yield = store_get(Ustrlen(s) + 1);
614 else if (isdigit(s[1]))
616 *ss++ = (s[1] - '0')*100 + (s[2] - '0')*10 + s[3] - '0';
619 else if (*(++s) != 0)
630 #ifndef COMPILE_UTILITY
631 /*************************************************
632 * Copy space-terminated or quoted string *
633 *************************************************/
635 /* This function copies from a string until its end, or until whitespace is
636 encountered, unless the string begins with a double quote, in which case the
637 terminating quote is sought, and escaping within the string is done. The length
638 of a de-quoted string can be no longer than the original, since escaping always
639 turns n characters into 1 character.
641 Argument: pointer to the pointer to the first character, which gets updated
642 Returns: the new string
646 string_dequote(const uschar **sptr)
648 const uschar *s = *sptr;
651 /* First find the end of the string */
654 while (*s != 0 && !isspace(*s)) s++;
658 while (*s && *s != '\"')
660 if (*s == '\\') (void)string_interpret_escape(&s);
666 /* Get enough store to copy into */
668 t = yield = store_get(s - *sptr + 1);
675 while (*s != 0 && !isspace(*s)) *t++ = *s++;
680 while (*s != 0 && *s != '\"')
682 if (*s == '\\') *t++ = string_interpret_escape(&s);
689 /* Update the pointer and return the terminated copy */
695 #endif /* COMPILE_UTILITY */
699 /*************************************************
700 * Format a string and save it *
701 *************************************************/
703 /* The formatting is done by string_vformat, which checks the length of
707 format a printf() format - deliberately char * rather than uschar *
708 because it will most usually be a literal string
709 ... arguments for format
711 Returns: pointer to fresh piece of store containing sprintf'ed string
715 string_sprintf(const char *format, ...)
717 #ifdef COMPILE_UTILITY
718 uschar buffer[STRING_SPRINTF_BUFFER_SIZE];
719 gstring g = { .size = STRING_SPRINTF_BUFFER_SIZE, .ptr = 0, .s = buffer };
722 gstring * gp = string_get(STRING_SPRINTF_BUFFER_SIZE);
727 va_start(ap, format);
728 gp2 = string_vformat(gp, FALSE, format, ap);
729 gp->s[gp->ptr] = '\0';
733 log_write(0, LOG_MAIN|LOG_PANIC_DIE,
734 "string_sprintf expansion was longer than %d; format string was (%s)\n"
735 "expansion started '%.32s'",
736 gp->size, format, gp->s);
738 #ifdef COMPILE_UTILITY
739 return string_copy(gp->s);
741 gstring_reset_unused(gp);
748 /*************************************************
749 * Case-independent strncmp() function *
750 *************************************************/
756 n number of characters to compare
758 Returns: < 0, = 0, or > 0, according to the comparison
762 strncmpic(const uschar *s, const uschar *t, int n)
766 int c = tolower(*s++) - tolower(*t++);
773 /*************************************************
774 * Case-independent strcmp() function *
775 *************************************************/
782 Returns: < 0, = 0, or > 0, according to the comparison
786 strcmpic(const uschar *s, const uschar *t)
790 int c = tolower(*s++) - tolower(*t++);
791 if (c != 0) return c;
797 /*************************************************
798 * Case-independent strstr() function *
799 *************************************************/
801 /* The third argument specifies whether whitespace is required
802 to follow the matched string.
806 t substring to search for
807 space_follows if TRUE, match only if whitespace follows
809 Returns: pointer to substring in string, or NULL if not found
813 strstric(uschar *s, uschar *t, BOOL space_follows)
816 uschar *yield = NULL;
817 int cl = tolower(*p);
818 int cu = toupper(*p);
822 if (*s == cl || *s == cu)
824 if (yield == NULL) yield = s;
827 if (!space_follows || s[1] == ' ' || s[1] == '\n' ) return yield;
835 else if (yield != NULL)
849 #ifdef COMPILE_UTILITY
850 /* Dummy version for this function; it should never be called */
852 gstring_grow(gstring * g, int p, int count)
860 #ifndef COMPILE_UTILITY
861 /*************************************************
862 * Get next string from separated list *
863 *************************************************/
865 /* Leading and trailing space is removed from each item. The separator in the
866 list is controlled by the int pointed to by the separator argument as follows:
868 If the value is > 0 it is used as the separator. This is typically used for
869 sublists such as slash-separated options. The value is always a printing
872 (If the value is actually > UCHAR_MAX there is only one item in the list.
873 This is used for some cases when called via functions that sometimes
874 plough through lists, and sometimes are given single items.)
876 If the value is <= 0, the string is inspected for a leading <x, where x is an
877 ispunct() or an iscntrl() character. If found, x is used as the separator. If
880 (a) if separator == 0, ':' is used
881 (b) if separator <0, -separator is used
883 In all cases the value of the separator that is used is written back to the
884 int so that it is used on subsequent calls as we progress through the list.
886 A literal ispunct() separator can be represented in an item by doubling, but
887 there is no way to include an iscntrl() separator as part of the data.
890 listptr points to a pointer to the current start of the list; the
891 pointer gets updated to point after the end of the next item
892 separator a pointer to the separator character in an int (see above)
893 buffer where to put a copy of the next string in the list; or
894 NULL if the next string is returned in new memory
895 buflen when buffer is not NULL, the size of buffer; otherwise ignored
897 Returns: pointer to buffer, containing the next substring,
898 or NULL if no more substrings
902 string_nextinlist(const uschar **listptr, int *separator, uschar *buffer, int buflen)
904 int sep = *separator;
905 const uschar *s = *listptr;
910 /* This allows for a fixed specified separator to be an iscntrl() character,
911 but at the time of implementation, this is never the case. However, it's best
912 to be conservative. */
914 while (isspace(*s) && *s != sep) s++;
916 /* A change of separator is permitted, so look for a leading '<' followed by an
917 allowed character. */
921 if (*s == '<' && (ispunct(s[1]) || iscntrl(s[1])))
925 while (isspace(*s) && *s != sep) s++;
928 sep = sep ? -sep : ':';
932 /* An empty string has no list elements */
934 if (!*s) return NULL;
936 /* Note whether whether or not the separator is an iscntrl() character. */
938 sep_is_special = iscntrl(sep);
940 /* Handle the case when a buffer is provided. */
947 if (*s == sep && (*(++s) != sep || sep_is_special)) break;
948 if (p < buflen - 1) buffer[p++] = *s;
950 while (p > 0 && isspace(buffer[p-1])) p--;
954 /* Handle the case when a buffer is not provided. */
961 /* We know that *s != 0 at this point. However, it might be pointing to a
962 separator, which could indicate an empty string, or (if an ispunct()
963 character) could be doubled to indicate a separator character as data at the
964 start of a string. Avoid getting working memory for an empty item. */
969 if (*s != sep || sep_is_special)
972 return string_copy(US"");
976 /* Not an empty string; the first character is guaranteed to be a data
981 for (ss = s + 1; *ss && *ss != sep; ss++) ;
982 g = string_catn(g, s, ss-s);
984 if (!*s || *++s != sep || sep_is_special) break;
986 while (g->ptr > 0 && isspace(g->s[g->ptr-1])) g->ptr--;
987 buffer = string_from_gstring(g);
988 gstring_reset_unused(g);
991 /* Update the current pointer and return the new string */
998 static const uschar *
999 Ustrnchr(const uschar * s, int c, unsigned * len)
1001 unsigned siz = *len;
1004 if (!*s) return NULL;
1017 /************************************************
1018 * Add element to separated list *
1019 ************************************************/
1020 /* This function is used to build a list, returning an allocated null-terminated
1021 growable string. The given element has any embedded separator characters
1024 Despite having the same growable-string interface as string_cat() the list is
1025 always returned null-terminated.
1028 list expanding-string for the list that is being built, or NULL
1029 if this is a new list that has no contents yet
1030 sep list separator character
1031 ele new element to be appended to the list
1033 Returns: pointer to the start of the list, changed if copied for expansion.
1037 string_append_listele(gstring * list, uschar sep, const uschar * ele)
1041 if (list && list->ptr)
1042 list = string_catn(list, &sep, 1);
1044 while((sp = Ustrchr(ele, sep)))
1046 list = string_catn(list, ele, sp-ele+1);
1047 list = string_catn(list, &sep, 1);
1050 list = string_cat(list, ele);
1051 (void) string_from_gstring(list);
1057 string_append_listele_n(gstring * list, uschar sep, const uschar * ele,
1062 if (list && list->ptr)
1063 list = string_catn(list, &sep, 1);
1065 while((sp = Ustrnchr(ele, sep, &len)))
1067 list = string_catn(list, ele, sp-ele+1);
1068 list = string_catn(list, &sep, 1);
1072 list = string_catn(list, ele, len);
1073 (void) string_from_gstring(list);
1079 /* A slightly-bogus listmaker utility; the separator is a string so
1080 can be multiple chars - there is no checking for the element content
1081 containing any of the separator. */
1084 string_append2_listele_n(gstring * list, const uschar * sepstr,
1085 const uschar * ele, unsigned len)
1087 if (list && list->ptr)
1088 list = string_cat(list, sepstr);
1090 list = string_catn(list, ele, len);
1091 (void) string_from_gstring(list);
1097 /************************************************/
1098 /* Create a growable-string with some preassigned space */
1101 string_get(unsigned size)
1103 gstring * g = store_get(sizeof(gstring) + size);
1110 /* NUL-terminate the C string in the growable-string, and return it. */
1113 string_from_gstring(gstring * g)
1115 if (!g) return NULL;
1116 g->s[g->ptr] = '\0';
1121 gstring_reset_unused(gstring * g)
1123 store_reset(g->s + (g->size = g->ptr + 1));
1127 /* Add more space to a growable-string.
1130 g the growable-string
1131 p current end of data
1132 count amount to grow by
1136 gstring_grow(gstring * g, int p, int count)
1138 int oldsize = g->size;
1140 /* Mostly, string_cat() is used to build small strings of a few hundred
1141 characters at most. There are times, however, when the strings are very much
1142 longer (for example, a lookup that returns a vast number of alias addresses).
1143 To try to keep things reasonable, we use increments whose size depends on the
1144 existing length of the string. */
1146 unsigned inc = oldsize < 4096 ? 127 : 1023;
1147 g->size = ((p + count + inc) & ~inc) + 1;
1149 /* Try to extend an existing allocation. If the result of calling
1150 store_extend() is false, either there isn't room in the current memory block,
1151 or this string is not the top item on the dynamic store stack. We then have
1152 to get a new chunk of store and copy the old string. When building large
1153 strings, it is helpful to call store_release() on the old string, to release
1154 memory blocks that have become empty. (The block will be freed if the string
1155 is at its start.) However, we can do this only if we know that the old string
1156 was the last item on the dynamic memory stack. This is the case if it matches
1159 if (!store_extend(g->s, oldsize, g->size))
1160 g->s = store_newblock(g->s, g->size, p);
1165 /*************************************************
1166 * Add chars to string *
1167 *************************************************/
1168 /* This function is used when building up strings of unknown length. Room is
1169 always left for a terminating zero to be added to the string that is being
1170 built. This function does not require the string that is being added to be NUL
1171 terminated, because the number of characters to add is given explicitly. It is
1172 sometimes called to extract parts of other strings.
1175 string points to the start of the string that is being built, or NULL
1176 if this is a new string that has no contents yet
1177 s points to characters to add
1178 count count of characters to add; must not exceed the length of s, if s
1181 Returns: pointer to the start of the string, changed if copied for expansion.
1182 Note that a NUL is not added, though space is left for one. This is
1183 because string_cat() is often called multiple times to build up a
1184 string - there's no point adding the NUL till the end.
1187 /* coverity[+alloc] */
1190 string_catn(gstring * g, const uschar *s, int count)
1196 unsigned inc = count < 4096 ? 127 : 1023;
1197 unsigned size = ((count + inc) & ~inc) + 1;
1198 g = string_get(size);
1202 if (p + count >= g->size)
1203 gstring_grow(g, p, count);
1205 /* Because we always specify the exact number of characters to copy, we can
1206 use memcpy(), which is likely to be more efficient than strncopy() because the
1207 latter has to check for zero bytes. */
1209 memcpy(g->s + p, s, count);
1216 string_cat(gstring *string, const uschar *s)
1218 return string_catn(string, s, Ustrlen(s));
1223 /*************************************************
1224 * Append strings to another string *
1225 *************************************************/
1227 /* This function can be used to build a string from many other strings.
1228 It calls string_cat() to do the dirty work.
1231 string expanding-string that is being built, or NULL
1232 if this is a new string that has no contents yet
1233 count the number of strings to append
1234 ... "count" uschar* arguments, which must be valid zero-terminated
1237 Returns: pointer to the start of the string, changed if copied for expansion.
1238 The string is not zero-terminated - see string_cat() above.
1241 __inline__ gstring *
1242 string_append(gstring *string, int count, ...)
1246 va_start(ap, count);
1249 uschar *t = va_arg(ap, uschar *);
1250 string = string_cat(string, t);
1260 /*************************************************
1261 * Format a string with length checks *
1262 *************************************************/
1264 /* This function is used to format a string with checking of the length of the
1265 output for all conversions. It protects Exim from absent-mindedness when
1266 calling functions like debug_printf and string_sprintf, and elsewhere. There
1267 are two different entry points to what is actually the same function, depending
1268 on whether the variable length list of data arguments are given explicitly or
1271 The formats are the usual printf() ones, with some omissions (never used) and
1272 three additions for strings: %S forces lower case, %T forces upper case, and
1273 %#s or %#S prints nothing for a NULL string. Without the # "NULL" is printed
1274 (useful in debugging). There is also the addition of %D and %M, which insert
1275 the date in the form used for datestamped log files.
1278 buffer a buffer in which to put the formatted string
1279 buflen the length of the buffer
1280 format the format string - deliberately char * and not uschar *
1281 ... or ap variable list of supplementary arguments
1283 Returns: TRUE if the result fitted in the buffer
1287 string_format(uschar * buffer, int buflen, const char * format, ...)
1289 gstring g = { .size = buflen, .ptr = 0, .s = buffer }, *gp;
1291 va_start(ap, format);
1292 gp = string_vformat(&g, FALSE, format, ap);
1302 /* Bulid or append to a growing-string, sprintf-style.
1304 If the "extend" argument is true, the string passed in can be NULL,
1305 empty, or non-empty.
1307 If the "extend" argument is false, the string passed in may not be NULL,
1308 will not be grown, and is usable in the original place after return.
1309 The return value can be NULL to signify overflow.
1311 Returns the possibly-new (if copy for growth was needed) string,
1316 string_vformat(gstring * g, BOOL extend, const char *format, va_list ap)
1318 enum ltypes { L_NORMAL=1, L_SHORT=2, L_LONG=3, L_LONGLONG=4, L_LONGDOUBLE=5, L_SIZE=6 };
1320 int width, precision, off, lim;
1321 const char * fp = format; /* Deliberately not unsigned */
1323 string_datestamp_offset = -1; /* Datestamp not inserted */
1324 string_datestamp_length = 0; /* Datestamp not inserted */
1325 string_datestamp_type = 0; /* Datestamp not inserted */
1327 #ifdef COMPILE_UTILITY
1332 /* Ensure we have a string, to save on checking later */
1333 if (!g) g = string_get(16);
1334 #endif /*!COMPILE_UTILITY*/
1336 lim = g->size - 1; /* leave one for a nul */
1337 off = g->ptr; /* remember initial offset in gstring */
1339 /* Scan the format and handle the insertions */
1343 int length = L_NORMAL;
1346 const char *null = "NULL"; /* ) These variables */
1347 const char *item_start, *s; /* ) are deliberately */
1348 char newformat[16]; /* ) not unsigned */
1349 char * gp = CS g->s + g->ptr; /* ) */
1351 /* Non-% characters just get copied verbatim */
1355 /* Avoid string_copyn() due to COMPILE_UTILITY */
1356 if (g->ptr >= lim - 1)
1358 if (!extend) return NULL;
1359 gstring_grow(g, g->ptr, 1);
1362 g->s[g->ptr++] = (uschar) *fp++;
1366 /* Deal with % characters. Pick off the width and precision, for checking
1367 strings, skipping over the flag and modifier characters. */
1370 width = precision = -1;
1372 if (strchr("-+ #0", *(++fp)) != NULL)
1374 if (*fp == '#') null = "";
1378 if (isdigit((uschar)*fp))
1380 width = *fp++ - '0';
1381 while (isdigit((uschar)*fp)) width = width * 10 + *fp++ - '0';
1383 else if (*fp == '*')
1385 width = va_arg(ap, int);
1392 precision = va_arg(ap, int);
1396 for (precision = 0; isdigit((uschar)*fp); fp++)
1397 precision = precision*10 + *fp - '0';
1399 /* Skip over 'h', 'L', 'l', 'll' and 'z', remembering the item length */
1402 { fp++; length = L_SHORT; }
1403 else if (*fp == 'L')
1404 { fp++; length = L_LONGDOUBLE; }
1405 else if (*fp == 'l')
1407 { fp += 2; length = L_LONGLONG; }
1409 { fp++; length = L_LONG; }
1410 else if (*fp == 'z')
1411 { fp++; length = L_SIZE; }
1413 /* Handle each specific format type. */
1418 nptr = va_arg(ap, int *);
1419 *nptr = g->ptr - off;
1427 width = length > L_LONG ? 24 : 12;
1428 if (g->ptr >= lim - width)
1430 if (!extend) return NULL;
1431 gstring_grow(g, g->ptr, width);
1433 gp = CS g->s + g->ptr;
1435 strncpy(newformat, item_start, fp - item_start);
1436 newformat[fp - item_start] = 0;
1438 /* Short int is promoted to int when passing through ..., so we must use
1439 int for va_arg(). */
1445 g->ptr += sprintf(gp, newformat, va_arg(ap, int)); break;
1447 g->ptr += sprintf(gp, newformat, va_arg(ap, long int)); break;
1449 g->ptr += sprintf(gp, newformat, va_arg(ap, LONGLONG_T)); break;
1451 g->ptr += sprintf(gp, newformat, va_arg(ap, size_t)); break;
1458 if (g->ptr >= lim - 24)
1460 if (!extend) return NULL;
1461 gstring_grow(g, g->ptr, 24);
1463 gp = CS g->s + g->ptr;
1465 /* sprintf() saying "(nil)" for a null pointer seems unreliable.
1466 Handle it explicitly. */
1467 if ((ptr = va_arg(ap, void *)))
1469 strncpy(newformat, item_start, fp - item_start);
1470 newformat[fp - item_start] = 0;
1471 g->ptr += sprintf(gp, newformat, ptr);
1474 g->ptr += sprintf(gp, "(nil)");
1478 /* %f format is inherently insecure if the numbers that it may be
1479 handed are unknown (e.g. 1e300). However, in Exim, %f is used for
1480 printing load averages, and these are actually stored as integers
1481 (load average * 1000) so the size of the numbers is constrained.
1482 It is also used for formatting sending rates, where the simplicity
1483 of the format prevents overflow. */
1490 if (precision < 0) precision = 6;
1491 if (g->ptr >= lim - precision - 8)
1493 if (!extend) return NULL;
1494 gstring_grow(g, g->ptr, precision+8);
1496 gp = CS g->s + g->ptr;
1498 strncpy(newformat, item_start, fp - item_start);
1499 newformat[fp-item_start] = 0;
1500 if (length == L_LONGDOUBLE)
1501 g->ptr += sprintf(gp, newformat, va_arg(ap, long double));
1503 g->ptr += sprintf(gp, newformat, va_arg(ap, double));
1509 if (g->ptr >= lim - 1)
1511 if (!extend) return NULL;
1512 gstring_grow(g, g->ptr, 1);
1515 g->s[g->ptr++] = (uschar) '%';
1519 if (g->ptr >= lim - 1)
1521 if (!extend) return NULL;
1522 gstring_grow(g, g->ptr, 1);
1525 g->s[g->ptr++] = (uschar) va_arg(ap, int);
1528 case 'D': /* Insert daily datestamp for log file names */
1529 s = CS tod_stamp(tod_log_datestamp_daily);
1530 string_datestamp_offset = g->ptr; /* Passed back via global */
1531 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1532 string_datestamp_type = tod_log_datestamp_daily;
1533 slen = string_datestamp_length;
1536 case 'M': /* Insert monthly datestamp for log file names */
1537 s = CS tod_stamp(tod_log_datestamp_monthly);
1538 string_datestamp_offset = g->ptr; /* Passed back via global */
1539 string_datestamp_length = Ustrlen(s); /* Passed back via global */
1540 string_datestamp_type = tod_log_datestamp_monthly;
1541 slen = string_datestamp_length;
1545 case 'S': /* Forces *lower* case */
1546 case 'T': /* Forces *upper* case */
1547 s = va_arg(ap, char *);
1552 INSERT_STRING: /* Come to from %D or %M above */
1555 BOOL truncated = FALSE;
1557 /* If the width is specified, check that there is a precision
1558 set; if not, set it to the width to prevent overruns of long
1563 if (precision < 0) precision = width;
1566 /* If a width is not specified and the precision is specified, set
1567 the width to the precision, or the string length if shorted. */
1569 else if (precision >= 0)
1570 width = precision < slen ? precision : slen;
1572 /* If neither are specified, set them both to the string length. */
1575 width = precision = slen;
1579 if (g->ptr == lim) return NULL;
1580 if (g->ptr >= lim - width)
1583 width = precision = lim - g->ptr - 1;
1584 if (width < 0) width = 0;
1585 if (precision < 0) precision = 0;
1588 else if (g->ptr >= lim - width)
1590 gstring_grow(g, g->ptr, width - (lim - g->ptr));
1592 gp = CS g->s + g->ptr;
1595 g->ptr += sprintf(gp, "%*.*s", width, precision, s);
1597 while (*gp) { *gp = tolower(*gp); gp++; }
1598 else if (fp[-1] == 'T')
1599 while (*gp) { *gp = toupper(*gp); gp++; }
1601 if (truncated) return NULL;
1605 /* Some things are never used in Exim; also catches junk. */
1608 strncpy(newformat, item_start, fp - item_start);
1609 newformat[fp-item_start] = 0;
1610 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string_format: unsupported type "
1611 "in \"%s\" in \"%s\"", newformat, format);
1621 #ifndef COMPILE_UTILITY
1624 string_fmt_append(gstring * g, const char *format, ...)
1627 va_start(ap, format);
1628 g = string_vformat(g, TRUE, format, ap);
1635 /*************************************************
1636 * Generate an "open failed" message *
1637 *************************************************/
1639 /* This function creates a message after failure to open a file. It includes a
1640 string supplied as data, adds the strerror() text, and if the failure was
1641 "Permission denied", reads and includes the euid and egid.
1644 eno the value of errno after the failure
1645 format a text format string - deliberately not uschar *
1646 ... arguments for the format string
1648 Returns: a message, in dynamic store
1652 string_open_failed(int eno, const char *format, ...)
1655 gstring * g = string_get(1024);
1657 g = string_catn(g, US"failed to open ", 15);
1659 /* Use the checked formatting routine to ensure that the buffer
1660 does not overflow. It should not, since this is called only for internally
1661 specified messages. If it does, the message just gets truncated, and there
1662 doesn't seem much we can do about that. */
1664 va_start(ap, format);
1665 (void) string_vformat(g, FALSE, format, ap);
1666 string_from_gstring(g);
1667 gstring_reset_unused(g);
1670 return eno == EACCES
1671 ? string_sprintf("%s: %s (euid=%ld egid=%ld)", g->s, strerror(eno),
1672 (long int)geteuid(), (long int)getegid())
1673 : string_sprintf("%s: %s", g->s, strerror(eno));
1675 #endif /* COMPILE_UTILITY */
1681 #ifndef COMPILE_UTILITY
1682 /* qsort(3), currently used to sort the environment variables
1683 for -bP environment output, needs a function to compare two pointers to string
1684 pointers. Here it is. */
1687 string_compare_by_pointer(const void *a, const void *b)
1689 return Ustrcmp(* CUSS a, * CUSS b);
1691 #endif /* COMPILE_UTILITY */
1696 /*************************************************
1697 **************************************************
1698 * Stand-alone test program *
1699 **************************************************
1700 *************************************************/
1707 printf("Testing is_ip_address\n");
1709 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1712 buffer[Ustrlen(buffer) - 1] = 0;
1713 printf("%d\n", string_is_ip_address(buffer, NULL));
1714 printf("%d %d %s\n", string_is_ip_address(buffer, &offset), offset, buffer);
1717 printf("Testing string_nextinlist\n");
1719 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1721 uschar *list = buffer;
1729 sep1 = sep2 = list[1];
1736 uschar *item1 = string_nextinlist(&lp1, &sep1, item, sizeof(item));
1737 uschar *item2 = string_nextinlist(&lp2, &sep2, NULL, 0);
1739 if (item1 == NULL && item2 == NULL) break;
1740 if (item == NULL || item2 == NULL || Ustrcmp(item1, item2) != 0)
1742 printf("***ERROR\nitem1=\"%s\"\nitem2=\"%s\"\n",
1743 (item1 == NULL)? "NULL" : CS item1,
1744 (item2 == NULL)? "NULL" : CS item2);
1747 else printf(" \"%s\"\n", CS item1);
1751 /* This is a horrible lash-up, but it serves its purpose. */
1753 printf("Testing string_format\n");
1755 while (fgets(CS buffer, sizeof(buffer), stdin) != NULL)
1758 long long llargs[3];
1768 buffer[Ustrlen(buffer) - 1] = 0;
1770 s = Ustrchr(buffer, ',');
1771 if (s == NULL) s = buffer + Ustrlen(buffer);
1773 Ustrncpy(format, buffer, s - buffer);
1774 format[s-buffer] = 0;
1781 s = Ustrchr(ss, ',');
1782 if (s == NULL) s = ss + Ustrlen(ss);
1786 Ustrncpy(outbuf, ss, s-ss);
1787 if (Ustrchr(outbuf, '.') != NULL)
1790 dargs[n++] = Ustrtod(outbuf, NULL);
1792 else if (Ustrstr(outbuf, "ll") != NULL)
1795 llargs[n++] = strtoull(CS outbuf, NULL, 10);
1799 args[n++] = (void *)Uatoi(outbuf);
1803 else if (Ustrcmp(ss, "*") == 0)
1805 args[n++] = (void *)(&count);
1811 uschar *sss = malloc(s - ss + 1);
1812 Ustrncpy(sss, ss, s-ss);
1819 if (!dflag && !llflag)
1820 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1821 args[0], args[1], args[2])? "True" : "False");
1824 printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1825 dargs[0], dargs[1], dargs[2])? "True" : "False");
1827 else printf("%s\n", string_format(outbuf, sizeof(outbuf), CS format,
1828 llargs[0], llargs[1], llargs[2])? "True" : "False");
1830 printf("%s\n", CS outbuf);
1831 if (countset) printf("count=%d\n", count);
1838 /* End of string.c */