X-Git-Url: https://git.exim.org/exim.git/blobdiff_plain/9b810c775c6e9dd1f8a87a743b943b465a1ca5a1..HEAD:/src/src/expand.c

diff --git a/src/src/expand.c b/src/src/expand.c
index b4a76b3e7..e7d089909 100644
--- a/src/src/expand.c
+++ b/src/src/expand.c
@@ -2,7 +2,7 @@
 *     Exim - an Internet mail transport agent    *
 *************************************************/
 
-/* Copyright (c) The Exim Maintainers 2020 - 2023 */
+/* Copyright (c) The Exim Maintainers 2020 - 2024 */
 /* Copyright (c) University of Cambridge 1995 - 2018 */
 /* See the file NOTICE for conditions of use and distribution. */
 /* SPDX-License-Identifier: GPL-2.0-or-later */
@@ -259,7 +259,9 @@ static uschar *op_table_main[] = {
   US"strlen",
   US"substr",
   US"uc",
-  US"utf8clean" };
+  US"utf8clean",
+  US"xtextd",
+  };
 
 enum {
   EOP_ADDRESS =  nelem(op_table_underscore),
@@ -307,7 +309,9 @@ enum {
   EOP_STRLEN,
   EOP_SUBSTR,
   EOP_UC,
-  EOP_UTF8CLEAN };
+  EOP_UTF8CLEAN,
+  EOP_XTEXTD,
+  };
 
 
 /* Table of condition names, and corresponding switch numbers. The names must
@@ -1262,7 +1266,8 @@ while (*s)
 
   while (*s && *s != '=' && !isspace(*s)) s++;
   dkeylength = s - dkey;
-  if (Uskip_whitespace(&s) == '=') while (isspace(*++s));
+  if (Uskip_whitespace(&s) == '=')
+    while (isspace(*++s)) ;
 
   data = string_dequote(&s);
   if (length == dkeylength && strncmpic(key, dkey, length) == 0)
@@ -1804,20 +1809,19 @@ return g;
 /* A recipients list is available only during system message filtering,
 during ACL processing after DATA, and while expanding pipe commands
 generated from a system filter, but not elsewhere.  Note that this does
-not check for comman in the elements, and uses comma-space as seperator -
+not check for commas in the elements, and uses comma-space as seperator -
 so cannot be used as an exim list as-is. */
 
 static uschar *
 fn_recipients(void)
 {
-uschar * s;
 gstring * g = NULL;
 
 if (!f.enable_dollar_recipients) return NULL;
 
 for (int i = 0; i < recipients_count; i++)
   {
-  s = recipients_list[i].address;
+  const uschar * s = recipients_list[i].address;
   g = string_append2_listele_n(g, US", ", s, Ustrlen(s));
   }
 gstring_release_unused(g);
@@ -2763,9 +2767,17 @@ switch(cond_type = identify_operator(&s, &opname))
     case ECOND_ISIP:
     case ECOND_ISIP4:
     case ECOND_ISIP6:
-    rc = string_is_ip_address(sub[0], NULL);
-    *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
-             (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
+    {
+      const uschar *errp;
+      const uschar **errpp;
+      DEBUG(D_expand) errpp = &errp; else errpp = 0;
+      if (0 == (rc = string_is_ip_addressX(sub[0], NULL, errpp)))
+        DEBUG(D_expand) debug_printf("failed: %s\n", errp);
+
+      *yield = ( cond_type == ECOND_ISIP  ? rc != 0 :
+                 cond_type == ECOND_ISIP4 ? rc == 4 : rc == 6) == testfor;
+    }
+
     break;
 
     /* Various authentication tests - all optionally compiled */
@@ -3583,53 +3595,50 @@ switch(cond_type = identify_operator(&s, &opname))
     /* If a zero-length secret was given, we're done.  Otherwise carry on
     and validate the given SRS local_part againt our secret. */
 
-    if (!*sub[1])
+    if (*sub[1])
       {
-      boolvalue = TRUE;
-      goto srs_result;
-      }
+      /* check the timestamp */
+	{
+	struct timeval now;
+	uschar * ss = sub[0] + ovec[4];	/* substring 2, the timestamp */
+	long d;
+	int n;
 
-    /* check the timestamp */
-      {
-      struct timeval now;
-      uschar * ss = sub[0] + ovec[4];	/* substring 2, the timestamp */
-      long d;
-      int n;
+	gettimeofday(&now, NULL);
+	now.tv_sec /= 86400;			/* days since epoch */
 
-      gettimeofday(&now, NULL);
-      now.tv_sec /= 86400;		/* days since epoch */
+	/* Decode substring 2 from base32 to a number */
 
-      /* Decode substring 2 from base32 to a number */
+	for (d = 0, n = ovec[5]-ovec[4]; n; n--)
+	  {
+	  uschar * t = Ustrchr(base32_chars, *ss++);
+	  d = d * 32 + (t - base32_chars);
+	  }
 
-      for (d = 0, n = ovec[5]-ovec[4]; n; n--)
-	{
-	uschar * t = Ustrchr(base32_chars, *ss++);
-	d = d * 32 + (t - base32_chars);
+	if (((now.tv_sec - d) & 0x3ff) > 10)	/* days since SRS generated */
+	  {
+	  DEBUG(D_expand) debug_printf("SRS too old\n");
+	  goto srs_result;
+	  }
 	}
 
-      if (((now.tv_sec - d) & 0x3ff) > 10)	/* days since SRS generated */
+      /* check length of substring 1, the offered checksum */
+
+      if (ovec[3]-ovec[2] != 4)
 	{
-	DEBUG(D_expand) debug_printf("SRS too old\n");
+	DEBUG(D_expand) debug_printf("SRS checksum wrong size\n");
 	goto srs_result;
 	}
-      }
-
-    /* check length of substring 1, the offered checksum */
-
-    if (ovec[3]-ovec[2] != 4)
-      {
-      DEBUG(D_expand) debug_printf("SRS checksum wrong size\n");
-      goto srs_result;
-      }
 
-    /* Hash the address with our secret, and compare that computed checksum
-    with the one extracted from the arg */
+      /* Hash the address with our secret, and compare that computed checksum
+      with the one extracted from the arg */
 
-    hmac_md5(sub[1], srs_recipient, cksum, sizeof(cksum));
-    if (Ustrncmp(cksum, sub[0] + ovec[2], 4) != 0)
-      {
-      DEBUG(D_expand) debug_printf("SRS checksum mismatch\n");
-      goto srs_result;
+      hmac_md5(sub[1], srs_recipient, cksum, sizeof(cksum));
+      if (Ustrncmp(cksum, sub[0] + ovec[2], 4) != 0)
+	{
+	DEBUG(D_expand) debug_printf("SRS checksum mismatch\n");
+	goto srs_result;
+	}
       }
     boolvalue = TRUE;
 
@@ -4110,7 +4119,7 @@ if (!*error)
     if (*s != ')')
       *error = US"expecting closing parenthesis";
     else
-      while (isspace(*++s));
+      while (isspace(*++s)) ;
   else if (*s)
     *error = US"expecting operator";
 *sptr = s;
@@ -4492,30 +4501,17 @@ return yield;
 /************************************************/
 static void
 debug_expansion_interim(const uschar * what, const uschar * value, int nchar,
-  BOOL skipping)
+  esi_flags flags)
 {
-DEBUG(D_noutf8)
-  debug_printf_indent("|");
-else
-  debug_printf_indent(UTF8_VERT_RIGHT);
+debug_printf_indent("%V", "K");
 
 for (int fill = 11 - Ustrlen(what); fill > 0; fill--)
-  DEBUG(D_noutf8)
-    debug_printf("-");
-  else
-    debug_printf(UTF8_HORIZ);
+  debug_printf("%V", "-");
 
-debug_printf("%s: %.*s\n", what, nchar, value);
+debug_printf("%s: %.*W\n", what, nchar, value);
 if (is_tainted(value))
-  {
-  DEBUG(D_noutf8)
-    debug_printf_indent("%s     \\__", skipping ? "|     " : "      ");
-  else
-    debug_printf_indent("%s",
-      skipping
-      ? UTF8_VERT "             " : "           " UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ);
-  debug_printf("(tainted)\n");
-  }
+  debug_printf_indent("%V          %V(tainted)\n",
+    flags & ESI_SKIPPING ? "|" : " ", "\\__");
 }
 
 
@@ -4614,17 +4610,10 @@ while (*s)
 
   DEBUG(D_expand)
     {
-    DEBUG(D_noutf8)
-      debug_printf_indent("%c%s: %s\n",
-	first ? '/' : '|',
-	flags & ESI_SKIPPING ? "---scanning" : "considering", s);
-    else
-      debug_printf_indent("%s%s: %s\n",
-	first ? UTF8_DOWN_RIGHT : UTF8_VERT_RIGHT,
-	flags & ESI_SKIPPING
-	? UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ "scanning"
-	: "considering",
-	s);
+    debug_printf_indent("%V%V%s: %W\n",
+      first ? "/" : "K",
+      flags & ESI_SKIPPING ? "---" : "",
+      flags & ESI_SKIPPING ? "scanning" : "considering", s);
     first = FALSE;
     }
 
@@ -4647,21 +4636,20 @@ while (*s)
       for (s = t; *s ; s++) if (*s == '\\' && s[1] == 'N') break;
 
       DEBUG(D_expand)
-	debug_expansion_interim(US"protected", t, (int)(s - t), !!(flags & ESI_SKIPPING));
-      yield = string_catn(yield, t, s - t);
+	debug_expansion_interim(US"protected", t, (int)(s - t), flags);
+      if (!(flags & ESI_SKIPPING))
+	yield = string_catn(yield, t, s - t);
       if (*s) s += 2;
       }
     else
       {
       uschar ch[1];
       DEBUG(D_expand)
-	DEBUG(D_noutf8)
-	  debug_printf_indent("|backslashed: '\\%c'\n", s[1]);
-	else
-	  debug_printf_indent(UTF8_VERT_RIGHT "backslashed: '\\%c'\n", s[1]);
+	debug_printf_indent("%Vbackslashed: '\\%c'\n", "K", s[1]);
       ch[0] = string_interpret_escape(&s);
+      if (!(flags & ESI_SKIPPING))
+	yield = string_catn(yield, ch, 1);
       s++;
-      yield = string_catn(yield, ch, 1);
       }
     continue;
     }
@@ -4678,9 +4666,10 @@ while (*s)
     for (const uschar * t = s+1;
 	*t && *t != '$' && *t != '}' && *t != '\\'; t++) i++;
 
-    DEBUG(D_expand) debug_expansion_interim(US"text", s, i, !!(flags & ESI_SKIPPING));
+    DEBUG(D_expand) debug_expansion_interim(US"text", s, i, flags);
 
-    yield = string_catn(yield, s, i);
+    if (!(flags & ESI_SKIPPING))
+      yield = string_catn(yield, s, i);
     s += i;
     continue;
     }
@@ -4706,15 +4695,16 @@ while (*s)
     /* If this is the first thing to be expanded, release the pre-allocated
     buffer. */
 
-    if (!yield)
-      g = store_get(sizeof(gstring), GET_UNTAINTED);
-    else if (yield->ptr == 0)
-      {
-      if (resetok) reset_point = store_reset(reset_point);
-      yield = NULL;
-      reset_point = store_mark();
-      g = store_get(sizeof(gstring), GET_UNTAINTED);	/* alloc _before_ calling find_variable() */
-      }
+    if (!(flags & ESI_SKIPPING))
+      if (!yield)
+	g = store_get(sizeof(gstring), GET_UNTAINTED);
+      else if (yield->ptr == 0)
+	{
+	if (resetok) reset_point = store_reset(reset_point);
+	yield = NULL;
+	reset_point = store_mark();
+	g = store_get(sizeof(gstring), GET_UNTAINTED);	/* alloc _before_ calling find_variable() */
+	}
 
     /* Header */
 
@@ -4763,16 +4753,17 @@ while (*s)
     reset in the middle of the buffer will make it inaccessible. */
 
     len = Ustrlen(value);
-    DEBUG(D_expand) debug_expansion_interim(US"value", value, len, !!(flags & ESI_SKIPPING));
-    if (!yield && newsize != 0)
-      {
-      yield = g;
-      yield->size = newsize;
-      yield->ptr = len;
-      yield->s = US value; /* known to be in new store i.e. a copy, so deconst safe */
-      }
-    else
-      yield = string_catn(yield, value, len);
+    DEBUG(D_expand) debug_expansion_interim(US"value", value, len, flags);
+    if (!(flags & ESI_SKIPPING))
+      if (!yield && newsize != 0)
+	{
+	yield = g;
+	yield->size = newsize;
+	yield->ptr = len;
+	yield->s = US value; /* known to be in new store i.e. a copy, so deconst safe */
+	}
+      else
+	yield = string_catn(yield, value, len);
 
     continue;
     }
@@ -4783,8 +4774,9 @@ while (*s)
     s = read_cnumber(&n, s);
     if (n >= 0 && n <= expand_nmax)
       {
-      DEBUG(D_expand) debug_expansion_interim(US"value", expand_nstring[n], expand_nlength[n], !!(flags & ESI_SKIPPING));
-      yield = string_catn(yield, expand_nstring[n], expand_nlength[n]);
+      DEBUG(D_expand) debug_expansion_interim(US"value", expand_nstring[n], expand_nlength[n], flags);
+      if (!(flags & ESI_SKIPPING))
+	yield = string_catn(yield, expand_nstring[n], expand_nlength[n]);
       }
     continue;
     }
@@ -4811,8 +4803,9 @@ while (*s)
       }
     if (n >= 0 && n <= expand_nmax)
       {
-      DEBUG(D_expand) debug_expansion_interim(US"value", expand_nstring[n], expand_nlength[n], !!(flags & ESI_SKIPPING));
-      yield = string_catn(yield, expand_nstring[n], expand_nlength[n]);
+      DEBUG(D_expand) debug_expansion_interim(US"value", expand_nstring[n], expand_nlength[n], flags);
+      if (!(flags & ESI_SKIPPING))
+	yield = string_catn(yield, expand_nstring[n], expand_nlength[n]);
       }
     continue;
     }
@@ -4937,9 +4930,9 @@ while (*s)
 
       DEBUG(D_expand)
 	{
-	debug_expansion_interim(US"condition", s, (int)(next_s - s), !!(flags & ESI_SKIPPING));
+	debug_expansion_interim(US"condition", s, (int)(next_s - s), flags);
 	debug_expansion_interim(US"result",
-	  cond ? US"true" : US"false", cond ? 4 : 5, !!(flags & ESI_SKIPPING));
+	  cond ? US"true" : US"false", cond ? 4 : 5, flags);
 	}
 
       s = next_s;
@@ -5807,16 +5800,15 @@ while (*s)
         case 3: goto EXPAND_FAILED;
         }
 
-      yield = string_cat(yield, sub[0]);
-      o2m = Ustrlen(sub[2]) - 1;
-
-      if (o2m >= 0) for (; oldptr < yield->ptr; oldptr++)
+      if (  (yield = string_cat(yield, sub[0]))
+         && (o2m = Ustrlen(sub[2]) - 1) >= 0)
+	  for (; oldptr < yield->ptr; oldptr++)
         {
         uschar * m = Ustrrchr(sub[1], yield->s[oldptr]);
         if (m)
           {
           int o = m - sub[1];
-          yield->s[oldptr] = sub[2][(o < o2m)? o : o2m];
+          yield->s[oldptr] = sub[2][o < o2m ? o : o2m];
           }
         }
 
@@ -6568,6 +6560,7 @@ while (*s)
 	goto EXPAND_FAILED_CURLY;					/*}*/
 	}
 
+      DEBUG(D_expand) debug_printf_indent("%s: evaluate input list list\n", name);
       if (!(list = expand_string_internal(s,
 	      ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL)))
 	goto EXPAND_FAILED;						/*{{*/
@@ -6587,6 +6580,7 @@ while (*s)
 	  expand_string_message = US"missing '{' for second arg of reduce";
 	  goto EXPAND_FAILED_CURLY;					/*}*/
 	  }
+	DEBUG(D_expand) debug_printf_indent("reduce: initial result list\n");
         t = expand_string_internal(s,
 	      ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
         if (!t) goto EXPAND_FAILED;
@@ -6614,6 +6608,7 @@ while (*s)
       condition for real. For EITEM_MAP and EITEM_REDUCE, do the same, using
       the normal internal expansion function. */
 
+      DEBUG(D_expand) debug_printf_indent("%s: find end of conditionn\n", name);
       if (item_type != EITEM_FILTER)
         temp = expand_string_internal(s,
 	  ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | ESI_SKIPPING, &s, &resetok, NULL);
@@ -7126,7 +7121,7 @@ while (*s)
 	    gstring_release_unused(h);
 	    s = string_from_gstring(h);
 	    }
-	  g = string_cat(g, s);
+	  if (s) g = string_cat(g, s);
 	  }
 
 	/* Assume that if the original local_part had quotes
@@ -7156,7 +7151,7 @@ while (*s)
     if (yield && (expansion_start > 0 || *s))
       debug_expansion_interim(US"item-res",
 	  yield->s + expansion_start, yield->ptr - expansion_start,
-	  !!(flags & ESI_SKIPPING));
+	  flags);
   continue;
 
 NOT_ITEM: ;
@@ -7335,19 +7330,20 @@ NOT_ITEM: ;
 
       case EOP_LC:
 	{
-	int count = 0;
-	uschar *t = sub - 1;
-	while (*(++t) != 0) { *t = tolower(*t); count++; }
-	yield = string_catn(yield, sub, count);
+	uschar * t = sub - 1;
+	while (*++t) *t = tolower(*t);
+	yield = string_catn(yield, sub, t-sub);
 	break;
 	}
+	{
+	uschar * s = sub;
+	}
 
       case EOP_UC:
 	{
-	int count = 0;
-	uschar *t = sub - 1;
-	while (*(++t) != 0) { *t = toupper(*t); count++; }
-	yield = string_catn(yield, sub, count);
+	uschar * t = sub - 1;
+	while (*++t) *t = toupper(*t);
+	yield = string_catn(yield, sub, t-sub);
 	break;
 	}
 
@@ -7783,7 +7779,6 @@ NOT_ITEM: ;
 	    }
 	  else
 	    yield = string_cat(yield, sub);
-	  break;
 	  }
 
 	/* quote_lookuptype does lookup-specific quoting */
@@ -7815,553 +7810,546 @@ NOT_ITEM: ;
 	    }
 
 	  yield = string_cat(yield, sub);
-	  break;
 	  }
+	break;
 
-	/* rx quote sticks in \ before any non-alphameric character so that
-	the insertion works in a regular expression. */
+      /* rx quote sticks in \ before any non-alphameric character so that
+      the insertion works in a regular expression. */
 
-	case EOP_RXQUOTE:
+      case EOP_RXQUOTE:
+	{
+	uschar *t = sub - 1;
+	while (*(++t) != 0)
 	  {
-	  uschar *t = sub - 1;
-	  while (*(++t) != 0)
-	    {
-	    if (!isalnum(*t))
-	      yield = string_catn(yield, US"\\", 1);
-	    yield = string_catn(yield, t, 1);
-	    }
-	  break;
+	  if (!isalnum(*t))
+	    yield = string_catn(yield, US"\\", 1);
+	  yield = string_catn(yield, t, 1);
 	  }
+	break;
+	}
 
-	/* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
-	prescribed by the RFC, if there are characters that need to be encoded */
+      /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
+      prescribed by the RFC, if there are characters that need to be encoded */
 
-	case EOP_RFC2047:
-	  yield = string_cat(yield,
-			      parse_quote_2047(sub, Ustrlen(sub), headers_charset,
-				FALSE));
-	  break;
+      case EOP_RFC2047:
+	yield = string_cat(yield,
+			    parse_quote_2047(sub, Ustrlen(sub), headers_charset,
+			      FALSE));
+	break;
 
-	/* RFC 2047 decode */
+      /* RFC 2047 decode */
 
-	case EOP_RFC2047D:
+      case EOP_RFC2047D:
+	{
+	int len;
+	uschar *error;
+	uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
+	  headers_charset, '?', &len, &error);
+	if (error)
 	  {
-	  int len;
-	  uschar *error;
-	  uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
-	    headers_charset, '?', &len, &error);
-	  if (error)
-	    {
-	    expand_string_message = error;
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_catn(yield, decoded, len);
-	  break;
+	  expand_string_message = error;
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_catn(yield, decoded, len);
+	break;
+	}
 
-	/* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
-	underscores */
+      /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
+      underscores */
 
-	case EOP_FROM_UTF8:
+      case EOP_FROM_UTF8:
+	{
+	uschar * buff = store_get(4, sub);
+	while (*sub)
 	  {
-	  uschar * buff = store_get(4, sub);
-	  while (*sub)
-	    {
-	    int c;
-	    GETUTF8INC(c, sub);
-	    if (c > 255) c = '_';
-	    buff[0] = c;
-	    yield = string_catn(yield, buff, 1);
-	    }
-	  break;
+	  int c;
+	  GETUTF8INC(c, sub);
+	  if (c > 255) c = '_';
+	  buff[0] = c;
+	  yield = string_catn(yield, buff, 1);
 	  }
+	break;
+	}
+
+      /* replace illegal UTF-8 sequences by replacement character  */
 
-	/* replace illegal UTF-8 sequences by replacement character  */
+      #define UTF8_REPLACEMENT_CHAR US"?"
+
+      case EOP_UTF8CLEAN:
+	{
+	int seq_len = 0, index = 0, bytes_left = 0, complete;
+	u_long codepoint = (u_long)-1;
+	uschar seq_buff[4];			/* accumulate utf-8 here */
 
-	#define UTF8_REPLACEMENT_CHAR US"?"
+	/* Manually track tainting, as we deal in individual chars below */
 
-	case EOP_UTF8CLEAN:
+	if (!yield)
+	  yield = string_get_tainted(Ustrlen(sub), sub);
+	else if (!yield->s || !yield->ptr)
 	  {
-	  int seq_len = 0, index = 0, bytes_left = 0, complete;
-	  u_long codepoint = (u_long)-1;
-	  uschar seq_buff[4];			/* accumulate utf-8 here */
+	  yield->s = store_get(yield->size = Ustrlen(sub), sub);
+	  gstring_reset(yield);
+	  }
+	else if (is_incompatible(yield->s, sub))
+	  gstring_rebuffer(yield, sub);
+
+	/* Check the UTF-8, byte-by-byte */
 
-	  /* Manually track tainting, as we deal in individual chars below */
+	while (*sub)
+	  {
+	  complete = 0;
+	  uschar c = *sub++;
 
-	  if (!yield)
-	    yield = string_get_tainted(Ustrlen(sub), sub);
-	  else if (!yield->s || !yield->ptr)
+	  if (bytes_left)
 	    {
-	    yield->s = store_get(yield->size = Ustrlen(sub), sub);
-	    gstring_reset(yield);
+	    if ((c & 0xc0) != 0x80)
+		    /* wrong continuation byte; invalidate all bytes */
+	      complete = 1; /* error */
+	    else
+	      {
+	      codepoint = (codepoint << 6) | (c & 0x3f);
+	      seq_buff[index++] = c;
+	      if (--bytes_left == 0)		/* codepoint complete */
+		if(codepoint > 0x10FFFF)	/* is it too large? */
+		  complete = -1;	/* error (RFC3629 limit) */
+		else if ( (codepoint & 0x1FF800 ) == 0xD800 ) /* surrogate */
+		  /* A UTF-16 surrogate (which should be one of a pair that
+		  encode a Unicode codepoint that is outside the Basic
+		  Multilingual Plane).  Error, not UTF8.
+		  RFC2279.2 is slightly unclear on this, but 
+		  https://unicodebook.readthedocs.io/issues.html#strict-utf8-decoder
+		  says "Surrogates characters are also invalid in UTF-8:
+		  characters in U+D800—U+DFFF have to be rejected." */
+		  complete = -1;
+		else
+		  {		/* finished; output utf-8 sequence */
+		  yield = string_catn(yield, seq_buff, seq_len);
+		  index = 0;
+		  }
+	      }
 	    }
-	  else if (is_incompatible(yield->s, sub))
-	    gstring_rebuffer(yield, sub);
-
-	  /* Check the UTF-8, byte-by-byte */
-
-	  while (*sub)
+	  else	/* no bytes left: new sequence */
 	    {
-	    complete = 0;
-	    uschar c = *sub++;
-
-	    if (bytes_left)
+	    if (!(c & 0x80))	/* 1-byte sequence, US-ASCII, keep it */
 	      {
-	      if ((c & 0xc0) != 0x80)
-		      /* wrong continuation byte; invalidate all bytes */
-		complete = 1; /* error */
+	      yield = string_catn(yield, &c, 1);
+	      continue;
+	      }
+	    if ((c & 0xe0) == 0xc0)		/* 2-byte sequence */
+	      if (c == 0xc0 || c == 0xc1)	/* 0xc0 and 0xc1 are illegal */
+		complete = -1;
 	      else
 		{
-		codepoint = (codepoint << 6) | (c & 0x3f);
-		seq_buff[index++] = c;
-		if (--bytes_left == 0)		/* codepoint complete */
-		  if(codepoint > 0x10FFFF)	/* is it too large? */
-		    complete = -1;	/* error (RFC3629 limit) */
-		  else if ( (codepoint & 0x1FF800 ) == 0xD800 ) /* surrogate */
-		    /* A UTF-16 surrogate (which should be one of a pair that
-		    encode a Unicode codepoint that is outside the Basic
-		    Multilingual Plane).  Error, not UTF8.
-		    RFC2279.2 is slightly unclear on this, but 
-		    https://unicodebook.readthedocs.io/issues.html#strict-utf8-decoder
-		    says "Surrogates characters are also invalid in UTF-8:
-		    characters in U+D800—U+DFFF have to be rejected." */
-		    complete = -1;
-		  else
-		    {		/* finished; output utf-8 sequence */
-		    yield = string_catn(yield, seq_buff, seq_len);
-		    index = 0;
-		    }
+		bytes_left = 1;
+		codepoint = c & 0x1f;
 		}
+	    else if ((c & 0xf0) == 0xe0)		/* 3-byte sequence */
+	      {
+	      bytes_left = 2;
+	      codepoint = c & 0x0f;
 	      }
-	    else	/* no bytes left: new sequence */
+	    else if ((c & 0xf8) == 0xf0)		/* 4-byte sequence */
 	      {
-	      if (!(c & 0x80))	/* 1-byte sequence, US-ASCII, keep it */
-		{
-		yield = string_catn(yield, &c, 1);
-		continue;
-		}
-	      if ((c & 0xe0) == 0xc0)		/* 2-byte sequence */
-		if (c == 0xc0 || c == 0xc1)	/* 0xc0 and 0xc1 are illegal */
-		  complete = -1;
-		else
-		  {
-		  bytes_left = 1;
-		  codepoint = c & 0x1f;
-		  }
-	      else if ((c & 0xf0) == 0xe0)		/* 3-byte sequence */
-		{
-		bytes_left = 2;
-		codepoint = c & 0x0f;
-		}
-	      else if ((c & 0xf8) == 0xf0)		/* 4-byte sequence */
-		{
-		bytes_left = 3;
-		codepoint = c & 0x07;
-		}
-	      else	/* invalid or too long (RFC3629 allows only 4 bytes) */
-		complete = -1;
+	      bytes_left = 3;
+	      codepoint = c & 0x07;
+	      }
+	    else	/* invalid or too long (RFC3629 allows only 4 bytes) */
+	      complete = -1;
 
-	      seq_buff[index++] = c;
-	      seq_len = bytes_left + 1;
-	      }		/* if(bytes_left) */
+	    seq_buff[index++] = c;
+	    seq_len = bytes_left + 1;
+	    }		/* if(bytes_left) */
 
-	    if (complete != 0)
-	      {
-	      bytes_left = index = 0;
-	      yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
-	      }
-	    if ((complete == 1) && ((c & 0x80) == 0))
-			  /* ASCII character follows incomplete sequence */
-		yield = string_catn(yield, &c, 1);
+	  if (complete != 0)
+	    {
+	    bytes_left = index = 0;
+	    yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
 	    }
-	  /* If given a sequence truncated mid-character, we also want to report ?
-	  Eg, ${length_1:フィル} is one byte, not one character, so we expect
-	  ${utf8clean:${length_1:フィル}} to yield '?' */
+	  if ((complete == 1) && ((c & 0x80) == 0))
+			/* ASCII character follows incomplete sequence */
+	      yield = string_catn(yield, &c, 1);
+	  }
+	/* If given a sequence truncated mid-character, we also want to report ?
+	Eg, ${length_1:フィル} is one byte, not one character, so we expect
+	${utf8clean:${length_1:フィル}} to yield '?' */
 
-	  if (bytes_left != 0)
-	    yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
+	if (bytes_left != 0)
+	  yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
 
-	  break;
-	  }
+	break;
+	}
 
 #ifdef SUPPORT_I18N
-	case EOP_UTF8_DOMAIN_TO_ALABEL:
+      case EOP_UTF8_DOMAIN_TO_ALABEL:
+	{
+	uschar * error = NULL;
+	uschar * s = string_domain_utf8_to_alabel(sub, &error);
+	if (error)
 	  {
-	  uschar * error = NULL;
-	  uschar * s = string_domain_utf8_to_alabel(sub, &error);
-	  if (error)
-	    {
-	    expand_string_message = string_sprintf(
-	      "error converting utf8 (%s) to alabel: %s",
-	      string_printing(sub), error);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_cat(yield, s);
-	  break;
+	  expand_string_message = string_sprintf(
+	    "error converting utf8 (%s) to alabel: %s",
+	    string_printing(sub), error);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_cat(yield, s);
+	break;
+	}
 
-	case EOP_UTF8_DOMAIN_FROM_ALABEL:
+      case EOP_UTF8_DOMAIN_FROM_ALABEL:
+	{
+	uschar * error = NULL;
+	uschar * s = string_domain_alabel_to_utf8(sub, &error);
+	if (error)
 	  {
-	  uschar * error = NULL;
-	  uschar * s = string_domain_alabel_to_utf8(sub, &error);
-	  if (error)
-	    {
-	    expand_string_message = string_sprintf(
-	      "error converting alabel (%s) to utf8: %s",
-	      string_printing(sub), error);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_cat(yield, s);
-	  break;
+	  expand_string_message = string_sprintf(
+	    "error converting alabel (%s) to utf8: %s",
+	    string_printing(sub), error);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_cat(yield, s);
+	break;
+	}
 
-	case EOP_UTF8_LOCALPART_TO_ALABEL:
+      case EOP_UTF8_LOCALPART_TO_ALABEL:
+	{
+	uschar * error = NULL;
+	uschar * s = string_localpart_utf8_to_alabel(sub, &error);
+	if (error)
 	  {
-	  uschar * error = NULL;
-	  uschar * s = string_localpart_utf8_to_alabel(sub, &error);
-	  if (error)
-	    {
-	    expand_string_message = string_sprintf(
-	      "error converting utf8 (%s) to alabel: %s",
-	      string_printing(sub), error);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_cat(yield, s);
-	  DEBUG(D_expand) debug_printf_indent("yield: '%Y'\n", yield);
-	  break;
+	  expand_string_message = string_sprintf(
+	    "error converting utf8 (%s) to alabel: %s",
+	    string_printing(sub), error);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_cat(yield, s);
+	DEBUG(D_expand) debug_printf_indent("yield: '%Y'\n", yield);
+	break;
+	}
 
-	case EOP_UTF8_LOCALPART_FROM_ALABEL:
+      case EOP_UTF8_LOCALPART_FROM_ALABEL:
+	{
+	uschar * error = NULL;
+	uschar * s = string_localpart_alabel_to_utf8(sub, &error);
+	if (error)
 	  {
-	  uschar * error = NULL;
-	  uschar * s = string_localpart_alabel_to_utf8(sub, &error);
-	  if (error)
-	    {
-	    expand_string_message = string_sprintf(
-	      "error converting alabel (%s) to utf8: %s",
-	      string_printing(sub), error);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_cat(yield, s);
-	  break;
+	  expand_string_message = string_sprintf(
+	    "error converting alabel (%s) to utf8: %s",
+	    string_printing(sub), error);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_cat(yield, s);
+	break;
+	}
 #endif	/* EXPERIMENTAL_INTERNATIONAL */
 
-	/* escape turns all non-printing characters into escape sequences. */
+      /* escape turns all non-printing characters into escape sequences. */
 
-	case EOP_ESCAPE:
-	  {
-	  const uschar * t = string_printing(sub);
-	  yield = string_cat(yield, t);
-	  break;
-	  }
+      case EOP_ESCAPE:
+	{
+	const uschar * t = string_printing(sub);
+	yield = string_cat(yield, t);
+	break;
+	}
 
-	case EOP_ESCAPE8BIT:
-	  {
-	  uschar c;
+      case EOP_ESCAPE8BIT:
+	{
+	uschar c;
 
-	  for (const uschar * s = sub; (c = *s); s++)
-	    yield = c < 127 && c != '\\'
-	      ? string_catn(yield, s, 1)
-	      : string_fmt_append(yield, "\\%03o", c);
-	  break;
-	  }
+	for (const uschar * s = sub; (c = *s); s++)
+	  yield = c < 127 && c != '\\'
+	    ? string_catn(yield, s, 1)
+	    : string_fmt_append(yield, "\\%03o", c);
+	break;
+	}
 
-	/* Handle numeric expression evaluation */
+      /* Handle numeric expression evaluation */
 
-	case EOP_EVAL:
-	case EOP_EVAL10:
+      case EOP_EVAL:
+      case EOP_EVAL10:
+	{
+	uschar *save_sub = sub;
+	uschar *error = NULL;
+	int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
+	if (error)
 	  {
-	  uschar *save_sub = sub;
-	  uschar *error = NULL;
-	  int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
-	  if (error)
-	    {
-	    expand_string_message = string_sprintf("error in expression "
-	      "evaluation: %s (after processing \"%.*s\")", error,
-	      (int)(sub-save_sub), save_sub);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_fmt_append(yield, PR_EXIM_ARITH, n);
-	  break;
+	  expand_string_message = string_sprintf("error in expression "
+	    "evaluation: %s (after processing \"%.*s\")", error,
+	    (int)(sub-save_sub), save_sub);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_fmt_append(yield, PR_EXIM_ARITH, n);
+	break;
+	}
 
-	/* Handle time period formatting */
+      /* Handle time period formatting */
 
-	case EOP_TIME_EVAL:
+      case EOP_TIME_EVAL:
+	{
+	int n = readconf_readtime(sub, 0, FALSE);
+	if (n < 0)
 	  {
-	  int n = readconf_readtime(sub, 0, FALSE);
-	  if (n < 0)
-	    {
-	    expand_string_message = string_sprintf("string \"%s\" is not an "
-	      "Exim time interval in \"%s\" operator", sub, name);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_fmt_append(yield, "%d", n);
-	  break;
+	  expand_string_message = string_sprintf("string \"%s\" is not an "
+	    "Exim time interval in \"%s\" operator", sub, name);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_fmt_append(yield, "%d", n);
+	break;
+	}
 
-	case EOP_TIME_INTERVAL:
+      case EOP_TIME_INTERVAL:
+	{
+	int n;
+	uschar *t = read_number(&n, sub);
+	if (*t != 0) /* Not A Number*/
 	  {
-	  int n;
-	  uschar *t = read_number(&n, sub);
-	  if (*t != 0) /* Not A Number*/
-	    {
-	    expand_string_message = string_sprintf("string \"%s\" is not a "
-	      "positive number in \"%s\" operator", sub, name);
-	    goto EXPAND_FAILED;
-	    }
-	  t = readconf_printtime(n);
-	  yield = string_cat(yield, t);
-	  break;
+	  expand_string_message = string_sprintf("string \"%s\" is not a "
+	    "positive number in \"%s\" operator", sub, name);
+	  goto EXPAND_FAILED;
 	  }
+	t = readconf_printtime(n);
+	yield = string_cat(yield, t);
+	break;
+	}
 
-	/* Convert string to base64 encoding */
+      /* Convert string to base64 encoding */
 
-	case EOP_STR2B64:
-	case EOP_BASE64:
-	  {
+      case EOP_STR2B64:
+      case EOP_BASE64:
+	{
 #ifndef DISABLE_TLS
-	  uschar * s = vp && *(void **)vp->value
-	    ? tls_cert_der_b64(*(void **)vp->value)
-	    : b64encode(CUS sub, Ustrlen(sub));
+	uschar * s = vp && *(void **)vp->value
+	  ? tls_cert_der_b64(*(void **)vp->value)
+	  : b64encode(CUS sub, Ustrlen(sub));
 #else
-	  uschar * s = b64encode(CUS sub, Ustrlen(sub));
+	uschar * s = b64encode(CUS sub, Ustrlen(sub));
 #endif
-	  yield = string_cat(yield, s);
-	  break;
-	  }
+	yield = string_cat(yield, s);
+	break;
+	}
 
-	case EOP_BASE64D:
+      case EOP_BASE64D:
+	{
+	uschar * s;
+	int len = b64decode(sub, &s, sub);
+	if (len < 0)
 	  {
-	  uschar * s;
-	  int len = b64decode(sub, &s, sub);
-	  if (len < 0)
-	    {
-	    expand_string_message = string_sprintf("string \"%s\" is not "
-	      "well-formed for \"%s\" operator", sub, name);
-	    goto EXPAND_FAILED;
-	    }
-	  yield = string_cat(yield, s);
-	  break;
+	  expand_string_message = string_sprintf("string \"%s\" is not "
+	    "well-formed for \"%s\" operator", sub, name);
+	  goto EXPAND_FAILED;
 	  }
+	yield = string_cat(yield, s);
+	break;
+	}
 
-	/* strlen returns the length of the string */
+      /* strlen returns the length of the string */
 
-	case EOP_STRLEN:
-	  yield = string_fmt_append(yield, "%d", Ustrlen(sub));
-	  break;
+      case EOP_STRLEN:
+	yield = string_fmt_append(yield, "%d", Ustrlen(sub));
+	break;
+
+      /* length_n or l_n takes just the first n characters or the whole string,
+      whichever is the shorter;
+
+      substr_m_n, and s_m_n take n characters from offset m; negative m take
+      from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
+      takes the rest, either to the right or to the left.
+
+      hash_n or h_n makes a hash of length n from the string, yielding n
+      characters from the set a-z; hash_n_m makes a hash of length n, but
+      uses m characters from the set a-zA-Z0-9.
+
+      nhash_n returns a single number between 0 and n-1 (in text form), while
+      nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
+      between 0 and n-1 and the second between 0 and m-1. */
+
+      case EOP_LENGTH:
+      case EOP_L:
+      case EOP_SUBSTR:
+      case EOP_S:
+      case EOP_HASH:
+      case EOP_H:
+      case EOP_NHASH:
+      case EOP_NH:
+	{
+	int sign = 1;
+	int value1 = 0;
+	int value2 = -1;
+	int *pn;
+	int len;
+	uschar *ret;
+
+	if (!arg)
+	  {
+	  expand_string_message = string_sprintf("missing values after %s",
+	    name);
+	  goto EXPAND_FAILED;
+	  }
+
+	/* "length" has only one argument, effectively being synonymous with
+	substr_0_n. */
 
-	/* length_n or l_n takes just the first n characters or the whole string,
-	whichever is the shorter;
-
-	substr_m_n, and s_m_n take n characters from offset m; negative m take
-	from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
-	takes the rest, either to the right or to the left.
-
-	hash_n or h_n makes a hash of length n from the string, yielding n
-	characters from the set a-z; hash_n_m makes a hash of length n, but
-	uses m characters from the set a-zA-Z0-9.
-
-	nhash_n returns a single number between 0 and n-1 (in text form), while
-	nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
-	between 0 and n-1 and the second between 0 and m-1. */
-
-	case EOP_LENGTH:
-	case EOP_L:
-	case EOP_SUBSTR:
-	case EOP_S:
-	case EOP_HASH:
-	case EOP_H:
-	case EOP_NHASH:
-	case EOP_NH:
+	if (c == EOP_LENGTH || c == EOP_L)
 	  {
-	  int sign = 1;
-	  int value1 = 0;
-	  int value2 = -1;
-	  int *pn;
-	  int len;
-	  uschar *ret;
+	  pn = &value2;
+	  value2 = 0;
+	  }
 
-	  if (!arg)
-	    {
-	    expand_string_message = string_sprintf("missing values after %s",
-	      name);
-	    goto EXPAND_FAILED;
-	    }
+	/* The others have one or two arguments; for "substr" the first may be
+	negative. The second being negative means "not supplied". */
+
+	else
+	  {
+	  pn = &value1;
+	  if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
+	  }
 
-	  /* "length" has only one argument, effectively being synonymous with
-	  substr_0_n. */
+	/* Read up to two numbers, separated by underscores */
 
-	  if (c == EOP_LENGTH || c == EOP_L)
+	ret = arg;
+	while (*arg != 0)
+	  {
+	  if (arg != ret && *arg == '_' && pn == &value1)
 	    {
 	    pn = &value2;
 	    value2 = 0;
+	    if (arg[1] != 0) arg++;
 	    }
-
-	  /* The others have one or two arguments; for "substr" the first may be
-	  negative. The second being negative means "not supplied". */
-
-	  else
+	  else if (!isdigit(*arg))
 	    {
-	    pn = &value1;
-	    if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
+	    expand_string_message =
+	      string_sprintf("non-digit after underscore in \"%s\"", name);
+	    goto EXPAND_FAILED;
 	    }
+	  else *pn = (*pn)*10 + *arg++ - '0';
+	  }
+	value1 *= sign;
 
-	  /* Read up to two numbers, separated by underscores */
+	/* Perform the required operation */
 
-	  ret = arg;
-	  while (*arg != 0)
-	    {
-	    if (arg != ret && *arg == '_' && pn == &value1)
-	      {
-	      pn = &value2;
-	      value2 = 0;
-	      if (arg[1] != 0) arg++;
-	      }
-	    else if (!isdigit(*arg))
-	      {
-	      expand_string_message =
-		string_sprintf("non-digit after underscore in \"%s\"", name);
-	      goto EXPAND_FAILED;
-	      }
-	    else *pn = (*pn)*10 + *arg++ - '0';
-	    }
-	  value1 *= sign;
+	ret = c == EOP_HASH || c == EOP_H
+	  ? compute_hash(sub, value1, value2, &len)
+	  : c == EOP_NHASH || c == EOP_NH
+	  ? compute_nhash(sub, value1, value2, &len)
+	  : extract_substr(sub, value1, value2, &len);
+	if (!ret) goto EXPAND_FAILED;
 
-	  /* Perform the required operation */
-
-	  ret = c == EOP_HASH || c == EOP_H
-	    ? compute_hash(sub, value1, value2, &len)
-	    : c == EOP_NHASH || c == EOP_NH
-	    ? compute_nhash(sub, value1, value2, &len)
-	    : extract_substr(sub, value1, value2, &len);
-	  if (!ret) goto EXPAND_FAILED;
+	yield = string_catn(yield, ret, len);
+	break;
+	}
 
-	  yield = string_catn(yield, ret, len);
-	  break;
-	  }
+      /* Stat a path */
 
-	/* Stat a path */
+      case EOP_STAT:
+	{
+	uschar smode[12];
+	uschar **modetable[3];
+	mode_t mode;
+	struct stat st;
 
-	case EOP_STAT:
+	if (expand_forbid & RDO_EXISTS)
 	  {
-	  uschar smode[12];
-	  uschar **modetable[3];
-	  mode_t mode;
-	  struct stat st;
+	  expand_string_message = US"Use of the stat() expansion is not permitted";
+	  goto EXPAND_FAILED;
+	  }
 
-	  if (expand_forbid & RDO_EXISTS)
-	    {
-	    expand_string_message = US"Use of the stat() expansion is not permitted";
-	    goto EXPAND_FAILED;
-	    }
+	if (stat(CS sub, &st) < 0)
+	  {
+	  expand_string_message = string_sprintf("stat(%s) failed: %s",
+	    sub, strerror(errno));
+	  goto EXPAND_FAILED;
+	  }
+	mode = st.st_mode;
+	switch (mode & S_IFMT)
+	  {
+	  case S_IFIFO: smode[0] = 'p'; break;
+	  case S_IFCHR: smode[0] = 'c'; break;
+	  case S_IFDIR: smode[0] = 'd'; break;
+	  case S_IFBLK: smode[0] = 'b'; break;
+	  case S_IFREG: smode[0] = '-'; break;
+	  default: smode[0] = '?'; break;
+	  }
 
-	  if (stat(CS sub, &st) < 0)
-	    {
-	    expand_string_message = string_sprintf("stat(%s) failed: %s",
-	      sub, strerror(errno));
-	    goto EXPAND_FAILED;
-	    }
-	  mode = st.st_mode;
-	  switch (mode & S_IFMT)
-	    {
-	    case S_IFIFO: smode[0] = 'p'; break;
-	    case S_IFCHR: smode[0] = 'c'; break;
-	    case S_IFDIR: smode[0] = 'd'; break;
-	    case S_IFBLK: smode[0] = 'b'; break;
-	    case S_IFREG: smode[0] = '-'; break;
-	    default: smode[0] = '?'; break;
-	    }
+	modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
+	modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
+	modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
 
-	  modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
-	  modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
-	  modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
+	for (int i = 0; i < 3; i++)
+	  {
+	  memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
+	  mode >>= 3;
+	  }
 
-	  for (int i = 0; i < 3; i++)
-	    {
-	    memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
-	    mode >>= 3;
-	    }
+	smode[10] = 0;
+	yield = string_fmt_append(yield,
+	  "mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
+	  "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
+	  (long)(st.st_mode & 077777), smode, (long)st.st_ino,
+	  (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
+	  (long)st.st_gid, st.st_size, (long)st.st_atime,
+	  (long)st.st_mtime, (long)st.st_ctime);
+	break;
+	}
 
-	  smode[10] = 0;
-	  yield = string_fmt_append(yield,
-	    "mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
-	    "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
-	    (long)(st.st_mode & 077777), smode, (long)st.st_ino,
-	    (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
-	    (long)st.st_gid, st.st_size, (long)st.st_atime,
-	    (long)st.st_mtime, (long)st.st_ctime);
-	  break;
-	  }
+      /* vaguely random number less than N */
 
-	/* vaguely random number less than N */
+      case EOP_RANDINT:
+	{
+	int_eximarith_t max = expanded_string_integer(sub, TRUE);
 
-	case EOP_RANDINT:
-	  {
-	  int_eximarith_t max = expanded_string_integer(sub, TRUE);
+	if (expand_string_message)
+	  goto EXPAND_FAILED;
+	yield = string_fmt_append(yield, "%d", vaguely_random_number((int)max));
+	break;
+	}
 
-	  if (expand_string_message)
-	    goto EXPAND_FAILED;
-	  yield = string_fmt_append(yield, "%d", vaguely_random_number((int)max));
-	  break;
-	  }
+      /* Reverse IP, including IPv6 to dotted-nibble */
 
-	/* Reverse IP, including IPv6 to dotted-nibble */
+      case EOP_REVERSE_IP:
+	{
+	int family, maskptr;
+	uschar reversed[128];
 
-	case EOP_REVERSE_IP:
+	family = string_is_ip_address(sub, &maskptr);
+	if (family == 0)
 	  {
-	  int family, maskptr;
-	  uschar reversed[128];
-
-	  family = string_is_ip_address(sub, &maskptr);
-	  if (family == 0)
-	    {
-	    expand_string_message = string_sprintf(
-		"reverse_ip() not given an IP address [%s]", sub);
-	    goto EXPAND_FAILED;
-	    }
-	  invert_address(reversed, sub);
-	  yield = string_cat(yield, reversed);
-	  break;
+	  expand_string_message = string_sprintf(
+	      "reverse_ip() not given an IP address [%s]", sub);
+	  goto EXPAND_FAILED;
 	  }
+	invert_address(reversed, sub);
+	yield = string_cat(yield, reversed);
+	break;
+	}
 
-	/* Unknown operator */
+      case EOP_XTEXTD:
+	{
+	uschar * s;
+	int len = auth_xtextdecode(sub, &s);
+	yield = string_catn(yield, s, len);
+	break;
+	}
 
-	default:
-	  expand_string_message =
-	    string_sprintf("unknown expansion operator \"%s\"", name);
-	  goto EXPAND_FAILED;
-	}	/* EOP_* switch */
+      /* Unknown operator */
+      default:
+	expand_string_message =
+	  string_sprintf("unknown expansion operator \"%s\"", name);
+	goto EXPAND_FAILED;
+      }	/* EOP_* switch */
 
-       DEBUG(D_expand)
+      DEBUG(D_expand)
 	{
 	const uschar * res = string_from_gstring(yield);
 	const uschar * s = res + expansion_start;
 	int i = gstring_length(yield) - expansion_start;
 	BOOL tainted = is_tainted(s);
 
-	DEBUG(D_noutf8)
+	debug_printf_indent("%Vop-res: %.*s\n", "K-----", i, s);
+	if (tainted)
 	  {
-	  debug_printf_indent("|-----op-res: %.*s\n", i, s);
-	  if (tainted)
-	    {
-	    debug_printf_indent("%s     \\__", flags & ESI_SKIPPING ? "|     " : "      ");
-	    debug_print_taint(res);
-	    }
-	  }
-	else
-	  {
-	  debug_printf_indent(UTF8_VERT_RIGHT
-	    UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
-	    "op-res: %.*s\n", i, s);
-	  if (tainted)
-	    {
-	    debug_printf_indent("%s",
-	      flags & ESI_SKIPPING
-	      ? UTF8_VERT "             " : "           " UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ);
-	    debug_print_taint(res);
-	    }
+	  debug_printf_indent("%V          %V",
+	    flags & ESI_SKIPPING ? "|" : " ",
+	    "\\__");
+	  debug_print_taint(res);
 	  }
 	}
        continue;
@@ -8453,39 +8441,25 @@ left != NULL, return a pointer to the terminator. */
   DEBUG(D_expand)
     {
     BOOL tainted = is_tainted(res);
-    DEBUG(D_noutf8)
-      {
-      debug_printf_indent("|--expanding: %.*s\n", (int)(s - string), string);
-      debug_printf_indent("%sresult: %s\n",
-	flags & ESI_SKIPPING ? "|-----" : "\\_____", res);
-      if (tainted)
-	{
-	debug_printf_indent("%s     \\__", flags & ESI_SKIPPING ? "|     " : "      ");
-	debug_print_taint(res);
-	}
-      if (flags & ESI_SKIPPING)
-	debug_printf_indent("\\___skipping: result is not used\n");
-      }
+    debug_printf_indent("%Vexpanded: %.*W\n",
+      "K---",
+      (int)(s - string), string);
+    debug_printf_indent("%Vresult: ",
+      flags & ESI_SKIPPING ? "K-----" : "\\_____");
+    if (*res || !(flags & ESI_SKIPPING))
+      debug_printf("%W\n", res);
     else
+      debug_printf(" %Vskipped%V\n", "<", ">");
+    if (tainted)
       {
-      debug_printf_indent(UTF8_VERT_RIGHT UTF8_HORIZ UTF8_HORIZ
-	"expanding: %.*s\n",
-	(int)(s - string), string);
-      debug_printf_indent("%s" UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
-	"result: %s\n",
-	flags & ESI_SKIPPING ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
-	res);
-      if (tainted)
-	{
-	debug_printf_indent("%s",
-	  flags & ESI_SKIPPING
-	  ? UTF8_VERT "             " : "           " UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ);
-	debug_print_taint(res);
-	}
-      if (flags & ESI_SKIPPING)
-	debug_printf_indent(UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
-	  "skipping: result is not used\n");
+      debug_printf_indent("%V          %V",
+	flags & ESI_SKIPPING ? "|" : " ",
+	"\\__"
+	);
+      debug_print_taint(res);
       }
+    if (flags & ESI_SKIPPING)
+      debug_printf_indent("%Vskipping: result is not used\n", "\\___");
     }
   if (textonly_p) *textonly_p = textonly;
   expand_level--;
@@ -8511,25 +8485,11 @@ EXPAND_FAILED:
 if (left) *left = s;
 DEBUG(D_expand)
   {
-  DEBUG(D_noutf8)
-    {
-    debug_printf_indent("|failed to expand: %s\n", string);
-    debug_printf_indent("%serror message: %s\n",
-      f.expand_string_forcedfail ? "|---" : "\\___", expand_string_message);
-    if (f.expand_string_forcedfail)
-      debug_printf_indent("\\failure was forced\n");
-    }
-  else
-    {
-    debug_printf_indent(UTF8_VERT_RIGHT "failed to expand: %s\n",
-      string);
-    debug_printf_indent("%s" UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
-      "error message: %s\n",
-      f.expand_string_forcedfail ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
-      expand_string_message);
-    if (f.expand_string_forcedfail)
-      debug_printf_indent(UTF8_UP_RIGHT "failure was forced\n");
-    }
+  debug_printf_indent("%Vfailed to expand: %s\n", "K", string);
+  debug_printf_indent("%Verror message: %s\n",
+    f.expand_string_forcedfail ? "K---" : "\\___", expand_string_message);
+  if (f.expand_string_forcedfail)
+    debug_printf_indent("%Vfailure was forced\n", "\\");
   }
 if (resetok_p && !resetok) *resetok_p = FALSE;
 expand_level--;
@@ -8552,13 +8512,12 @@ Returns:  the expanded string, or NULL if expansion failed; if failure was
 const uschar *
 expand_string_2(const uschar * string, BOOL * textonly_p)
 {
+f.expand_string_forcedfail = f.search_find_defer = malformed_header = FALSE;
 if (Ustrpbrk(string, "$\\") != NULL)
   {
   int old_pool = store_pool;
   uschar * s;
 
-  f.search_find_defer = FALSE;
-  malformed_header = FALSE;
   store_pool = POOL_MAIN;
     s = expand_string_internal(string, ESI_HONOR_DOLLAR, NULL, NULL, textonly_p);
   store_pool = old_pool;
@@ -8732,12 +8691,14 @@ Returns:     OK     value placed in rvalue
 */
 
 int
-exp_bool(address_item *addr,
-  uschar *mtype, uschar *mname, unsigned dbg_opt,
-  uschar *oname, BOOL bvalue,
-  uschar *svalue, BOOL *rvalue)
+exp_bool(address_item * addr,
+  uschar * mtype, uschar * mname, unsigned dbg_opt,
+  uschar * oname, BOOL bvalue,
+  uschar * svalue, BOOL * rvalue)
 {
-uschar *expanded;
+uschar * expanded;
+
+DEBUG(D_expand) debug_printf("try option %s\n", oname);
 if (!svalue) { *rvalue = bvalue; return OK; }
 
 if (!(expanded = expand_string(svalue)))