src/src/expand.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2016 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8
   9 /* Functions for handling string expansion. */
  10
  11
  12 #include "exim.h"
  13
  14 /* Recursively called function */
  15
  16 static uschar *expand_string_internal(const uschar *, BOOL, const uschar **, BOOL, BOOL, BOOL *);
  17 static int_eximarith_t expanded_string_integer(const uschar *, BOOL);
  18
  19 #ifdef STAND_ALONE
  20 #ifndef SUPPORT_CRYPTEQ
  21 #define SUPPORT_CRYPTEQ
  22 #endif
  23 #endif
  24
  25 #ifdef LOOKUP_LDAP
  26 #include "lookups/ldap.h"
  27 #endif
  28
  29 #ifdef SUPPORT_CRYPTEQ
  30 #ifdef CRYPT_H
  31 #include <crypt.h>
  32 #endif
  33 #ifndef HAVE_CRYPT16
  34 extern char* crypt16(char*, char*);
  35 #endif
  36 #endif
  37
  38 /* The handling of crypt16() is a mess. I will record below the analysis of the
  39 mess that was sent to me. We decided, however, to make changing this very low
  40 priority, because in practice people are moving away from the crypt()
  41 algorithms nowadays, so it doesn't seem worth it.
  42
  43 <quote>
  44 There is an algorithm named "crypt16" in Ultrix and Tru64.  It crypts
  45 the first 8 characters of the password using a 20-round version of crypt
  46 (standard crypt does 25 rounds).  It then crypts the next 8 characters,
  47 or an empty block if the password is less than 9 characters, using a
  48 20-round version of crypt and the same salt as was used for the first
  49 block.  Charaters after the first 16 are ignored.  It always generates
  50 a 16-byte hash, which is expressed together with the salt as a string
  51 of 24 base 64 digits.  Here are some links to peruse:
  52
  53         http://cvs.pld.org.pl/pam/pamcrypt/crypt16.c?rev=1.2
  54         http://seclists.org/bugtraq/1999/Mar/0076.html
  55
  56 There's a different algorithm named "bigcrypt" in HP-UX, Digital Unix,
  57 and OSF/1.  This is the same as the standard crypt if given a password
  58 of 8 characters or less.  If given more, it first does the same as crypt
  59 using the first 8 characters, then crypts the next 8 (the 9th to 16th)
  60 using as salt the first two base 64 digits from the first hash block.
  61 If the password is more than 16 characters then it crypts the 17th to 24th
  62 characters using as salt the first two base 64 digits from the second hash
  63 block.  And so on: I've seen references to it cutting off the password at
  64 40 characters (5 blocks), 80 (10 blocks), or 128 (16 blocks).  Some links:
  65
  66         http://cvs.pld.org.pl/pam/pamcrypt/bigcrypt.c?rev=1.2
  67         http://seclists.org/bugtraq/1999/Mar/0109.html
  68         http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/HTML/AA-Q0R2D-
  69              TET1_html/sec.c222.html#no_id_208
  70
  71 Exim has something it calls "crypt16".  It will either use a native
  72 crypt16 or its own implementation.  A native crypt16 will presumably
  73 be the one that I called "crypt16" above.  The internal "crypt16"
  74 function, however, is a two-block-maximum implementation of what I called
  75 "bigcrypt".  The documentation matches the internal code.
  76
  77 I suspect that whoever did the "crypt16" stuff for Exim didn't realise
  78 that crypt16 and bigcrypt were different things.
  79
  80 Exim uses the LDAP-style scheme identifier "{crypt16}" to refer
  81 to whatever it is using under that name.  This unfortunately sets a
  82 precedent for using "{crypt16}" to identify two incompatible algorithms
  83 whose output can't be distinguished.  With "{crypt16}" thus rendered
  84 ambiguous, I suggest you deprecate it and invent two new identifiers
  85 for the two algorithms.
  86
  87 Both crypt16 and bigcrypt are very poor algorithms, btw.  Hashing parts
  88 of the password separately means they can be cracked separately, so
  89 the double-length hash only doubles the cracking effort instead of
  90 squaring it.  I recommend salted SHA-1 ({SSHA}), or the Blowfish-based
  91 bcrypt ({CRYPT}$2a$).
  92 </quote>
  93 */
  94
  95
  96
  97 /*************************************************
  98 *            Local statics and tables            *
  99 *************************************************/
 100
 101 /* Table of item names, and corresponding switch numbers. The names must be in
 102 alphabetical order. */
 103
 104 static uschar *item_table[] = {
 105   US"acl",
 106   US"certextract",
 107   US"dlfunc",
 108   US"env",
 109   US"extract",
 110   US"filter",
 111   US"hash",
 112   US"hmac",
 113   US"if",
 114 #ifdef SUPPORT_I18N
 115   US"imapfolder",
 116 #endif
 117   US"length",
 118   US"listextract",
 119   US"lookup",
 120   US"map",
 121   US"nhash",
 122   US"perl",
 123   US"prvs",
 124   US"prvscheck",
 125   US"readfile",
 126   US"readsocket",
 127   US"reduce",
 128   US"run",
 129   US"sg",
 130   US"sort",
 131   US"substr",
 132   US"tr" };
 133
 134 enum {
 135   EITEM_ACL,
 136   EITEM_CERTEXTRACT,
 137   EITEM_DLFUNC,
 138   EITEM_ENV,
 139   EITEM_EXTRACT,
 140   EITEM_FILTER,
 141   EITEM_HASH,
 142   EITEM_HMAC,
 143   EITEM_IF,
 144 #ifdef SUPPORT_I18N
 145   EITEM_IMAPFOLDER,
 146 #endif
 147   EITEM_LENGTH,
 148   EITEM_LISTEXTRACT,
 149   EITEM_LOOKUP,
 150   EITEM_MAP,
 151   EITEM_NHASH,
 152   EITEM_PERL,
 153   EITEM_PRVS,
 154   EITEM_PRVSCHECK,
 155   EITEM_READFILE,
 156   EITEM_READSOCK,
 157   EITEM_REDUCE,
 158   EITEM_RUN,
 159   EITEM_SG,
 160   EITEM_SORT,
 161   EITEM_SUBSTR,
 162   EITEM_TR };
 163
 164 /* Tables of operator names, and corresponding switch numbers. The names must be
 165 in alphabetical order. There are two tables, because underscore is used in some
 166 cases to introduce arguments, whereas for other it is part of the name. This is
 167 an historical mis-design. */
 168
 169 static uschar *op_table_underscore[] = {
 170   US"from_utf8",
 171   US"local_part",
 172   US"quote_local_part",
 173   US"reverse_ip",
 174   US"time_eval",
 175   US"time_interval"
 176 #ifdef SUPPORT_I18N
 177  ,US"utf8_domain_from_alabel",
 178   US"utf8_domain_to_alabel",
 179   US"utf8_localpart_from_alabel",
 180   US"utf8_localpart_to_alabel"
 181 #endif
 182   };
 183
 184 enum {
 185   EOP_FROM_UTF8,
 186   EOP_LOCAL_PART,
 187   EOP_QUOTE_LOCAL_PART,
 188   EOP_REVERSE_IP,
 189   EOP_TIME_EVAL,
 190   EOP_TIME_INTERVAL
 191 #ifdef SUPPORT_I18N
 192  ,EOP_UTF8_DOMAIN_FROM_ALABEL,
 193   EOP_UTF8_DOMAIN_TO_ALABEL,
 194   EOP_UTF8_LOCALPART_FROM_ALABEL,
 195   EOP_UTF8_LOCALPART_TO_ALABEL
 196 #endif
 197   };
 198
 199 static uschar *op_table_main[] = {
 200   US"address",
 201   US"addresses",
 202   US"base62",
 203   US"base62d",
 204   US"base64",
 205   US"base64d",
 206   US"domain",
 207   US"escape",
 208   US"eval",
 209   US"eval10",
 210   US"expand",
 211   US"h",
 212   US"hash",
 213   US"hex2b64",
 214   US"hexquote",
 215   US"ipv6denorm",
 216   US"ipv6norm",
 217   US"l",
 218   US"lc",
 219   US"length",
 220   US"listcount",
 221   US"listnamed",
 222   US"mask",
 223   US"md5",
 224   US"nh",
 225   US"nhash",
 226   US"quote",
 227   US"randint",
 228   US"rfc2047",
 229   US"rfc2047d",
 230   US"rxquote",
 231   US"s",
 232   US"sha1",
 233   US"sha256",
 234   US"stat",
 235   US"str2b64",
 236   US"strlen",
 237   US"substr",
 238   US"uc",
 239   US"utf8clean" };
 240
 241 enum {
 242   EOP_ADDRESS =  nelem(op_table_underscore),
 243   EOP_ADDRESSES,
 244   EOP_BASE62,
 245   EOP_BASE62D,
 246   EOP_BASE64,
 247   EOP_BASE64D,
 248   EOP_DOMAIN,
 249   EOP_ESCAPE,
 250   EOP_EVAL,
 251   EOP_EVAL10,
 252   EOP_EXPAND,
 253   EOP_H,
 254   EOP_HASH,
 255   EOP_HEX2B64,
 256   EOP_HEXQUOTE,
 257   EOP_IPV6DENORM,
 258   EOP_IPV6NORM,
 259   EOP_L,
 260   EOP_LC,
 261   EOP_LENGTH,
 262   EOP_LISTCOUNT,
 263   EOP_LISTNAMED,
 264   EOP_MASK,
 265   EOP_MD5,
 266   EOP_NH,
 267   EOP_NHASH,
 268   EOP_QUOTE,
 269   EOP_RANDINT,
 270   EOP_RFC2047,
 271   EOP_RFC2047D,
 272   EOP_RXQUOTE,
 273   EOP_S,
 274   EOP_SHA1,
 275   EOP_SHA256,
 276   EOP_STAT,
 277   EOP_STR2B64,
 278   EOP_STRLEN,
 279   EOP_SUBSTR,
 280   EOP_UC,
 281   EOP_UTF8CLEAN };
 282
 283
 284 /* Table of condition names, and corresponding switch numbers. The names must
 285 be in alphabetical order. */
 286
 287 static uschar *cond_table[] = {
 288   US"<",
 289   US"<=",
 290   US"=",
 291   US"==",     /* Backward compatibility */
 292   US">",
 293   US">=",
 294   US"acl",
 295   US"and",
 296   US"bool",
 297   US"bool_lax",
 298   US"crypteq",
 299   US"def",
 300   US"eq",
 301   US"eqi",
 302   US"exists",
 303   US"first_delivery",
 304   US"forall",
 305   US"forany",
 306   US"ge",
 307   US"gei",
 308   US"gt",
 309   US"gti",
 310   US"inlist",
 311   US"inlisti",
 312   US"isip",
 313   US"isip4",
 314   US"isip6",
 315   US"ldapauth",
 316   US"le",
 317   US"lei",
 318   US"lt",
 319   US"lti",
 320   US"match",
 321   US"match_address",
 322   US"match_domain",
 323   US"match_ip",
 324   US"match_local_part",
 325   US"or",
 326   US"pam",
 327   US"pwcheck",
 328   US"queue_running",
 329   US"radius",
 330   US"saslauthd"
 331 };
 332
 333 enum {
 334   ECOND_NUM_L,
 335   ECOND_NUM_LE,
 336   ECOND_NUM_E,
 337   ECOND_NUM_EE,
 338   ECOND_NUM_G,
 339   ECOND_NUM_GE,
 340   ECOND_ACL,
 341   ECOND_AND,
 342   ECOND_BOOL,
 343   ECOND_BOOL_LAX,
 344   ECOND_CRYPTEQ,
 345   ECOND_DEF,
 346   ECOND_STR_EQ,
 347   ECOND_STR_EQI,
 348   ECOND_EXISTS,
 349   ECOND_FIRST_DELIVERY,
 350   ECOND_FORALL,
 351   ECOND_FORANY,
 352   ECOND_STR_GE,
 353   ECOND_STR_GEI,
 354   ECOND_STR_GT,
 355   ECOND_STR_GTI,
 356   ECOND_INLIST,
 357   ECOND_INLISTI,
 358   ECOND_ISIP,
 359   ECOND_ISIP4,
 360   ECOND_ISIP6,
 361   ECOND_LDAPAUTH,
 362   ECOND_STR_LE,
 363   ECOND_STR_LEI,
 364   ECOND_STR_LT,
 365   ECOND_STR_LTI,
 366   ECOND_MATCH,
 367   ECOND_MATCH_ADDRESS,
 368   ECOND_MATCH_DOMAIN,
 369   ECOND_MATCH_IP,
 370   ECOND_MATCH_LOCAL_PART,
 371   ECOND_OR,
 372   ECOND_PAM,
 373   ECOND_PWCHECK,
 374   ECOND_QUEUE_RUNNING,
 375   ECOND_RADIUS,
 376   ECOND_SASLAUTHD
 377 };
 378
 379
 380 /* Types of table entry */
 381
 382 enum vtypes {
 383   vtype_int,            /* value is address of int */
 384   vtype_filter_int,     /* ditto, but recognized only when filtering */
 385   vtype_ino,            /* value is address of ino_t (not always an int) */
 386   vtype_uid,            /* value is address of uid_t (not always an int) */
 387   vtype_gid,            /* value is address of gid_t (not always an int) */
 388   vtype_bool,           /* value is address of bool */
 389   vtype_stringptr,      /* value is address of pointer to string */
 390   vtype_msgbody,        /* as stringptr, but read when first required */
 391   vtype_msgbody_end,    /* ditto, the end of the message */
 392   vtype_msgheaders,     /* the message's headers, processed */
 393   vtype_msgheaders_raw, /* the message's headers, unprocessed */
 394   vtype_localpart,      /* extract local part from string */
 395   vtype_domain,         /* extract domain from string */
 396   vtype_string_func,    /* value is string returned by given function */
 397   vtype_todbsdin,       /* value not used; generate BSD inbox tod */
 398   vtype_tode,           /* value not used; generate tod in epoch format */
 399   vtype_todel,          /* value not used; generate tod in epoch/usec format */
 400   vtype_todf,           /* value not used; generate full tod */
 401   vtype_todl,           /* value not used; generate log tod */
 402   vtype_todlf,          /* value not used; generate log file datestamp tod */
 403   vtype_todzone,        /* value not used; generate time zone only */
 404   vtype_todzulu,        /* value not used; generate zulu tod */
 405   vtype_reply,          /* value not used; get reply from headers */
 406   vtype_pid,            /* value not used; result is pid */
 407   vtype_host_lookup,    /* value not used; get host name */
 408   vtype_load_avg,       /* value not used; result is int from os_getloadavg */
 409   vtype_pspace,         /* partition space; value is T/F for spool/log */
 410   vtype_pinodes,        /* partition inodes; value is T/F for spool/log */
 411   vtype_cert            /* SSL certificate */
 412   #ifndef DISABLE_DKIM
 413   ,vtype_dkim           /* Lookup of value in DKIM signature */
 414   #endif
 415 };
 416
 417 /* Type for main variable table */
 418
 419 typedef struct {
 420   const char *name;
 421   enum vtypes type;
 422   void       *value;
 423 } var_entry;
 424
 425 /* Type for entries pointing to address/length pairs. Not currently
 426 in use. */
 427
 428 typedef struct {
 429   uschar **address;
 430   int  *length;
 431 } alblock;
 432
 433 static uschar * fn_recipients(void);
 434
 435 /* This table must be kept in alphabetical order. */
 436
 437 static var_entry var_table[] = {
 438   /* WARNING: Do not invent variables whose names start acl_c or acl_m because
 439      they will be confused with user-creatable ACL variables. */
 440   { "acl_arg1",            vtype_stringptr,   &acl_arg[0] },
 441   { "acl_arg2",            vtype_stringptr,   &acl_arg[1] },
 442   { "acl_arg3",            vtype_stringptr,   &acl_arg[2] },
 443   { "acl_arg4",            vtype_stringptr,   &acl_arg[3] },
 444   { "acl_arg5",            vtype_stringptr,   &acl_arg[4] },
 445   { "acl_arg6",            vtype_stringptr,   &acl_arg[5] },
 446   { "acl_arg7",            vtype_stringptr,   &acl_arg[6] },
 447   { "acl_arg8",            vtype_stringptr,   &acl_arg[7] },
 448   { "acl_arg9",            vtype_stringptr,   &acl_arg[8] },
 449   { "acl_narg",            vtype_int,         &acl_narg },
 450   { "acl_verify_message",  vtype_stringptr,   &acl_verify_message },
 451   { "address_data",        vtype_stringptr,   &deliver_address_data },
 452   { "address_file",        vtype_stringptr,   &address_file },
 453   { "address_pipe",        vtype_stringptr,   &address_pipe },
 454   { "authenticated_fail_id",vtype_stringptr,  &authenticated_fail_id },
 455   { "authenticated_id",    vtype_stringptr,   &authenticated_id },
 456   { "authenticated_sender",vtype_stringptr,   &authenticated_sender },
 457   { "authentication_failed",vtype_int,        &authentication_failed },
 458 #ifdef WITH_CONTENT_SCAN
 459   { "av_failed",           vtype_int,         &av_failed },
 460 #endif
 461 #ifdef EXPERIMENTAL_BRIGHTMAIL
 462   { "bmi_alt_location",    vtype_stringptr,   &bmi_alt_location },
 463   { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
 464   { "bmi_base64_verdict",  vtype_stringptr,   &bmi_base64_verdict },
 465   { "bmi_deliver",         vtype_int,         &bmi_deliver },
 466 #endif
 467   { "body_linecount",      vtype_int,         &body_linecount },
 468   { "body_zerocount",      vtype_int,         &body_zerocount },
 469   { "bounce_recipient",    vtype_stringptr,   &bounce_recipient },
 470   { "bounce_return_size_limit", vtype_int,    &bounce_return_size_limit },
 471   { "caller_gid",          vtype_gid,         &real_gid },
 472   { "caller_uid",          vtype_uid,         &real_uid },
 473   { "callout_address",     vtype_stringptr,   &callout_address },
 474   { "compile_date",        vtype_stringptr,   &version_date },
 475   { "compile_number",      vtype_stringptr,   &version_cnumber },
 476   { "config_dir",          vtype_stringptr,   &config_main_directory },
 477   { "config_file",         vtype_stringptr,   &config_main_filename },
 478   { "csa_status",          vtype_stringptr,   &csa_status },
 479 #ifdef EXPERIMENTAL_DCC
 480   { "dcc_header",          vtype_stringptr,   &dcc_header },
 481   { "dcc_result",          vtype_stringptr,   &dcc_result },
 482 #endif
 483 #ifndef DISABLE_DKIM
 484   { "dkim_algo",           vtype_dkim,        (void *)DKIM_ALGO },
 485   { "dkim_bodylength",     vtype_dkim,        (void *)DKIM_BODYLENGTH },
 486   { "dkim_canon_body",     vtype_dkim,        (void *)DKIM_CANON_BODY },
 487   { "dkim_canon_headers",  vtype_dkim,        (void *)DKIM_CANON_HEADERS },
 488   { "dkim_copiedheaders",  vtype_dkim,        (void *)DKIM_COPIEDHEADERS },
 489   { "dkim_created",        vtype_dkim,        (void *)DKIM_CREATED },
 490   { "dkim_cur_signer",     vtype_stringptr,   &dkim_cur_signer },
 491   { "dkim_domain",         vtype_stringptr,   &dkim_signing_domain },
 492   { "dkim_expires",        vtype_dkim,        (void *)DKIM_EXPIRES },
 493   { "dkim_headernames",    vtype_dkim,        (void *)DKIM_HEADERNAMES },
 494   { "dkim_identity",       vtype_dkim,        (void *)DKIM_IDENTITY },
 495   { "dkim_key_granularity",vtype_dkim,        (void *)DKIM_KEY_GRANULARITY },
 496   { "dkim_key_length",     vtype_int,         &dkim_key_length },
 497   { "dkim_key_nosubdomains",vtype_dkim,       (void *)DKIM_NOSUBDOMAINS },
 498   { "dkim_key_notes",      vtype_dkim,        (void *)DKIM_KEY_NOTES },
 499   { "dkim_key_srvtype",    vtype_dkim,        (void *)DKIM_KEY_SRVTYPE },
 500   { "dkim_key_testing",    vtype_dkim,        (void *)DKIM_KEY_TESTING },
 501   { "dkim_selector",       vtype_stringptr,   &dkim_signing_selector },
 502   { "dkim_signers",        vtype_stringptr,   &dkim_signers },
 503   { "dkim_verify_reason",  vtype_dkim,        (void *)DKIM_VERIFY_REASON },
 504   { "dkim_verify_status",  vtype_dkim,        (void *)DKIM_VERIFY_STATUS},
 505 #endif
 506 #ifdef EXPERIMENTAL_DMARC
 507   { "dmarc_ar_header",     vtype_stringptr,   &dmarc_ar_header },
 508   { "dmarc_domain_policy", vtype_stringptr,   &dmarc_domain_policy },
 509   { "dmarc_status",        vtype_stringptr,   &dmarc_status },
 510   { "dmarc_status_text",   vtype_stringptr,   &dmarc_status_text },
 511   { "dmarc_used_domain",   vtype_stringptr,   &dmarc_used_domain },
 512 #endif
 513   { "dnslist_domain",      vtype_stringptr,   &dnslist_domain },
 514   { "dnslist_matched",     vtype_stringptr,   &dnslist_matched },
 515   { "dnslist_text",        vtype_stringptr,   &dnslist_text },
 516   { "dnslist_value",       vtype_stringptr,   &dnslist_value },
 517   { "domain",              vtype_stringptr,   &deliver_domain },
 518   { "domain_data",         vtype_stringptr,   &deliver_domain_data },
 519 #ifndef DISABLE_EVENT
 520   { "event_data",          vtype_stringptr,   &event_data },
 521
 522   /*XXX want to use generic vars for as many of these as possible*/
 523   { "event_defer_errno",   vtype_int,         &event_defer_errno },
 524
 525   { "event_name",          vtype_stringptr,   &event_name },
 526 #endif
 527   { "exim_gid",            vtype_gid,         &exim_gid },
 528   { "exim_path",           vtype_stringptr,   &exim_path },
 529   { "exim_uid",            vtype_uid,         &exim_uid },
 530   { "exim_version",        vtype_stringptr,   &version_string },
 531   { "headers_added",       vtype_string_func, &fn_hdrs_added },
 532   { "home",                vtype_stringptr,   &deliver_home },
 533   { "host",                vtype_stringptr,   &deliver_host },
 534   { "host_address",        vtype_stringptr,   &deliver_host_address },
 535   { "host_data",           vtype_stringptr,   &host_data },
 536   { "host_lookup_deferred",vtype_int,         &host_lookup_deferred },
 537   { "host_lookup_failed",  vtype_int,         &host_lookup_failed },
 538   { "host_port",           vtype_int,         &deliver_host_port },
 539   { "initial_cwd",         vtype_stringptr,   &initial_cwd },
 540   { "inode",               vtype_ino,         &deliver_inode },
 541   { "interface_address",   vtype_stringptr,   &interface_address },
 542   { "interface_port",      vtype_int,         &interface_port },
 543   { "item",                vtype_stringptr,   &iterate_item },
 544   #ifdef LOOKUP_LDAP
 545   { "ldap_dn",             vtype_stringptr,   &eldap_dn },
 546   #endif
 547   { "load_average",        vtype_load_avg,    NULL },
 548   { "local_part",          vtype_stringptr,   &deliver_localpart },
 549   { "local_part_data",     vtype_stringptr,   &deliver_localpart_data },
 550   { "local_part_prefix",   vtype_stringptr,   &deliver_localpart_prefix },
 551   { "local_part_suffix",   vtype_stringptr,   &deliver_localpart_suffix },
 552   { "local_scan_data",     vtype_stringptr,   &local_scan_data },
 553   { "local_user_gid",      vtype_gid,         &local_user_gid },
 554   { "local_user_uid",      vtype_uid,         &local_user_uid },
 555   { "localhost_number",    vtype_int,         &host_number },
 556   { "log_inodes",          vtype_pinodes,     (void *)FALSE },
 557   { "log_space",           vtype_pspace,      (void *)FALSE },
 558   { "lookup_dnssec_authenticated",vtype_stringptr,&lookup_dnssec_authenticated},
 559   { "mailstore_basename",  vtype_stringptr,   &mailstore_basename },
 560 #ifdef WITH_CONTENT_SCAN
 561   { "malware_name",        vtype_stringptr,   &malware_name },
 562 #endif
 563   { "max_received_linelength", vtype_int,     &max_received_linelength },
 564   { "message_age",         vtype_int,         &message_age },
 565   { "message_body",        vtype_msgbody,     &message_body },
 566   { "message_body_end",    vtype_msgbody_end, &message_body_end },
 567   { "message_body_size",   vtype_int,         &message_body_size },
 568   { "message_exim_id",     vtype_stringptr,   &message_id },
 569   { "message_headers",     vtype_msgheaders,  NULL },
 570   { "message_headers_raw", vtype_msgheaders_raw, NULL },
 571   { "message_id",          vtype_stringptr,   &message_id },
 572   { "message_linecount",   vtype_int,         &message_linecount },
 573   { "message_size",        vtype_int,         &message_size },
 574 #ifdef SUPPORT_I18N
 575   { "message_smtputf8",    vtype_bool,        &message_smtputf8 },
 576 #endif
 577 #ifdef WITH_CONTENT_SCAN
 578   { "mime_anomaly_level",  vtype_int,         &mime_anomaly_level },
 579   { "mime_anomaly_text",   vtype_stringptr,   &mime_anomaly_text },
 580   { "mime_boundary",       vtype_stringptr,   &mime_boundary },
 581   { "mime_charset",        vtype_stringptr,   &mime_charset },
 582   { "mime_content_description", vtype_stringptr, &mime_content_description },
 583   { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
 584   { "mime_content_id",     vtype_stringptr,   &mime_content_id },
 585   { "mime_content_size",   vtype_int,         &mime_content_size },
 586   { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
 587   { "mime_content_type",   vtype_stringptr,   &mime_content_type },
 588   { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
 589   { "mime_filename",       vtype_stringptr,   &mime_filename },
 590   { "mime_is_coverletter", vtype_int,         &mime_is_coverletter },
 591   { "mime_is_multipart",   vtype_int,         &mime_is_multipart },
 592   { "mime_is_rfc822",      vtype_int,         &mime_is_rfc822 },
 593   { "mime_part_count",     vtype_int,         &mime_part_count },
 594 #endif
 595   { "n0",                  vtype_filter_int,  &filter_n[0] },
 596   { "n1",                  vtype_filter_int,  &filter_n[1] },
 597   { "n2",                  vtype_filter_int,  &filter_n[2] },
 598   { "n3",                  vtype_filter_int,  &filter_n[3] },
 599   { "n4",                  vtype_filter_int,  &filter_n[4] },
 600   { "n5",                  vtype_filter_int,  &filter_n[5] },
 601   { "n6",                  vtype_filter_int,  &filter_n[6] },
 602   { "n7",                  vtype_filter_int,  &filter_n[7] },
 603   { "n8",                  vtype_filter_int,  &filter_n[8] },
 604   { "n9",                  vtype_filter_int,  &filter_n[9] },
 605   { "original_domain",     vtype_stringptr,   &deliver_domain_orig },
 606   { "original_local_part", vtype_stringptr,   &deliver_localpart_orig },
 607   { "originator_gid",      vtype_gid,         &originator_gid },
 608   { "originator_uid",      vtype_uid,         &originator_uid },
 609   { "parent_domain",       vtype_stringptr,   &deliver_domain_parent },
 610   { "parent_local_part",   vtype_stringptr,   &deliver_localpart_parent },
 611   { "pid",                 vtype_pid,         NULL },
 612 #ifndef DISABLE_PRDR
 613   { "prdr_requested",      vtype_bool,        &prdr_requested },
 614 #endif
 615   { "primary_hostname",    vtype_stringptr,   &primary_hostname },
 616 #if defined(SUPPORT_PROXY) || defined(SUPPORT_SOCKS)
 617   { "proxy_external_address",vtype_stringptr, &proxy_external_address },
 618   { "proxy_external_port", vtype_int,         &proxy_external_port },
 619   { "proxy_local_address", vtype_stringptr,   &proxy_local_address },
 620   { "proxy_local_port",    vtype_int,         &proxy_local_port },
 621   { "proxy_session",       vtype_bool,        &proxy_session },
 622 #endif
 623   { "prvscheck_address",   vtype_stringptr,   &prvscheck_address },
 624   { "prvscheck_keynum",    vtype_stringptr,   &prvscheck_keynum },
 625   { "prvscheck_result",    vtype_stringptr,   &prvscheck_result },
 626   { "qualify_domain",      vtype_stringptr,   &qualify_domain_sender },
 627   { "qualify_recipient",   vtype_stringptr,   &qualify_domain_recipient },
 628   { "rcpt_count",          vtype_int,         &rcpt_count },
 629   { "rcpt_defer_count",    vtype_int,         &rcpt_defer_count },
 630   { "rcpt_fail_count",     vtype_int,         &rcpt_fail_count },
 631   { "received_count",      vtype_int,         &received_count },
 632   { "received_for",        vtype_stringptr,   &received_for },
 633   { "received_ip_address", vtype_stringptr,   &interface_address },
 634   { "received_port",       vtype_int,         &interface_port },
 635   { "received_protocol",   vtype_stringptr,   &received_protocol },
 636   { "received_time",       vtype_int,         &received_time },
 637   { "recipient_data",      vtype_stringptr,   &recipient_data },
 638   { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
 639   { "recipients",          vtype_string_func, &fn_recipients },
 640   { "recipients_count",    vtype_int,         &recipients_count },
 641 #ifdef WITH_CONTENT_SCAN
 642   { "regex_match_string",  vtype_stringptr,   &regex_match_string },
 643 #endif
 644   { "reply_address",       vtype_reply,       NULL },
 645   { "return_path",         vtype_stringptr,   &return_path },
 646   { "return_size_limit",   vtype_int,         &bounce_return_size_limit },
 647   { "router_name",         vtype_stringptr,   &router_name },
 648   { "runrc",               vtype_int,         &runrc },
 649   { "self_hostname",       vtype_stringptr,   &self_hostname },
 650   { "sender_address",      vtype_stringptr,   &sender_address },
 651   { "sender_address_data", vtype_stringptr,   &sender_address_data },
 652   { "sender_address_domain", vtype_domain,    &sender_address },
 653   { "sender_address_local_part", vtype_localpart, &sender_address },
 654   { "sender_data",         vtype_stringptr,   &sender_data },
 655   { "sender_fullhost",     vtype_stringptr,   &sender_fullhost },
 656   { "sender_helo_dnssec",  vtype_bool,        &sender_helo_dnssec },
 657   { "sender_helo_name",    vtype_stringptr,   &sender_helo_name },
 658   { "sender_host_address", vtype_stringptr,   &sender_host_address },
 659   { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
 660   { "sender_host_dnssec",  vtype_bool,        &sender_host_dnssec },
 661   { "sender_host_name",    vtype_host_lookup, NULL },
 662   { "sender_host_port",    vtype_int,         &sender_host_port },
 663   { "sender_ident",        vtype_stringptr,   &sender_ident },
 664   { "sender_rate",         vtype_stringptr,   &sender_rate },
 665   { "sender_rate_limit",   vtype_stringptr,   &sender_rate_limit },
 666   { "sender_rate_period",  vtype_stringptr,   &sender_rate_period },
 667   { "sender_rcvhost",      vtype_stringptr,   &sender_rcvhost },
 668   { "sender_verify_failure",vtype_stringptr,  &sender_verify_failure },
 669   { "sending_ip_address",  vtype_stringptr,   &sending_ip_address },
 670   { "sending_port",        vtype_int,         &sending_port },
 671   { "smtp_active_hostname", vtype_stringptr,  &smtp_active_hostname },
 672   { "smtp_command",        vtype_stringptr,   &smtp_cmd_buffer },
 673   { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
 674   { "smtp_count_at_connection_start", vtype_int, &smtp_accept_count },
 675   { "smtp_notquit_reason", vtype_stringptr,   &smtp_notquit_reason },
 676   { "sn0",                 vtype_filter_int,  &filter_sn[0] },
 677   { "sn1",                 vtype_filter_int,  &filter_sn[1] },
 678   { "sn2",                 vtype_filter_int,  &filter_sn[2] },
 679   { "sn3",                 vtype_filter_int,  &filter_sn[3] },
 680   { "sn4",                 vtype_filter_int,  &filter_sn[4] },
 681   { "sn5",                 vtype_filter_int,  &filter_sn[5] },
 682   { "sn6",                 vtype_filter_int,  &filter_sn[6] },
 683   { "sn7",                 vtype_filter_int,  &filter_sn[7] },
 684   { "sn8",                 vtype_filter_int,  &filter_sn[8] },
 685   { "sn9",                 vtype_filter_int,  &filter_sn[9] },
 686 #ifdef WITH_CONTENT_SCAN
 687   { "spam_action",         vtype_stringptr,   &spam_action },
 688   { "spam_bar",            vtype_stringptr,   &spam_bar },
 689   { "spam_report",         vtype_stringptr,   &spam_report },
 690   { "spam_score",          vtype_stringptr,   &spam_score },
 691   { "spam_score_int",      vtype_stringptr,   &spam_score_int },
 692 #endif
 693 #ifdef EXPERIMENTAL_SPF
 694   { "spf_guess",           vtype_stringptr,   &spf_guess },
 695   { "spf_header_comment",  vtype_stringptr,   &spf_header_comment },
 696   { "spf_received",        vtype_stringptr,   &spf_received },
 697   { "spf_result",          vtype_stringptr,   &spf_result },
 698   { "spf_smtp_comment",    vtype_stringptr,   &spf_smtp_comment },
 699 #endif
 700   { "spool_directory",     vtype_stringptr,   &spool_directory },
 701   { "spool_inodes",        vtype_pinodes,     (void *)TRUE },
 702   { "spool_space",         vtype_pspace,      (void *)TRUE },
 703 #ifdef EXPERIMENTAL_SRS
 704   { "srs_db_address",      vtype_stringptr,   &srs_db_address },
 705   { "srs_db_key",          vtype_stringptr,   &srs_db_key },
 706   { "srs_orig_recipient",  vtype_stringptr,   &srs_orig_recipient },
 707   { "srs_orig_sender",     vtype_stringptr,   &srs_orig_sender },
 708   { "srs_recipient",       vtype_stringptr,   &srs_recipient },
 709   { "srs_status",          vtype_stringptr,   &srs_status },
 710 #endif
 711   { "thisaddress",         vtype_stringptr,   &filter_thisaddress },
 712
 713   /* The non-(in,out) variables are now deprecated */
 714   { "tls_bits",            vtype_int,         &tls_in.bits },
 715   { "tls_certificate_verified", vtype_int,    &tls_in.certificate_verified },
 716   { "tls_cipher",          vtype_stringptr,   &tls_in.cipher },
 717
 718   { "tls_in_bits",         vtype_int,         &tls_in.bits },
 719   { "tls_in_certificate_verified", vtype_int, &tls_in.certificate_verified },
 720   { "tls_in_cipher",       vtype_stringptr,   &tls_in.cipher },
 721   { "tls_in_ocsp",         vtype_int,         &tls_in.ocsp },
 722   { "tls_in_ourcert",      vtype_cert,        &tls_in.ourcert },
 723   { "tls_in_peercert",     vtype_cert,        &tls_in.peercert },
 724   { "tls_in_peerdn",       vtype_stringptr,   &tls_in.peerdn },
 725 #if defined(SUPPORT_TLS)
 726   { "tls_in_sni",          vtype_stringptr,   &tls_in.sni },
 727 #endif
 728   { "tls_out_bits",        vtype_int,         &tls_out.bits },
 729   { "tls_out_certificate_verified", vtype_int,&tls_out.certificate_verified },
 730   { "tls_out_cipher",      vtype_stringptr,   &tls_out.cipher },
 731 #ifdef EXPERIMENTAL_DANE
 732   { "tls_out_dane",        vtype_bool,        &tls_out.dane_verified },
 733 #endif
 734   { "tls_out_ocsp",        vtype_int,         &tls_out.ocsp },
 735   { "tls_out_ourcert",     vtype_cert,        &tls_out.ourcert },
 736   { "tls_out_peercert",    vtype_cert,        &tls_out.peercert },
 737   { "tls_out_peerdn",      vtype_stringptr,   &tls_out.peerdn },
 738 #if defined(SUPPORT_TLS)
 739   { "tls_out_sni",         vtype_stringptr,   &tls_out.sni },
 740 #endif
 741 #ifdef EXPERIMENTAL_DANE
 742   { "tls_out_tlsa_usage",  vtype_int,         &tls_out.tlsa_usage },
 743 #endif
 744
 745   { "tls_peerdn",          vtype_stringptr,   &tls_in.peerdn }, /* mind the alphabetical order! */
 746 #if defined(SUPPORT_TLS)
 747   { "tls_sni",             vtype_stringptr,   &tls_in.sni },    /* mind the alphabetical order! */
 748 #endif
 749
 750   { "tod_bsdinbox",        vtype_todbsdin,    NULL },
 751   { "tod_epoch",           vtype_tode,        NULL },
 752   { "tod_epoch_l",         vtype_todel,       NULL },
 753   { "tod_full",            vtype_todf,        NULL },
 754   { "tod_log",             vtype_todl,        NULL },
 755   { "tod_logfile",         vtype_todlf,       NULL },
 756   { "tod_zone",            vtype_todzone,     NULL },
 757   { "tod_zulu",            vtype_todzulu,     NULL },
 758   { "transport_name",      vtype_stringptr,   &transport_name },
 759   { "value",               vtype_stringptr,   &lookup_value },
 760   { "verify_mode",         vtype_stringptr,   &verify_mode },
 761   { "version_number",      vtype_stringptr,   &version_string },
 762   { "warn_message_delay",  vtype_stringptr,   &warnmsg_delay },
 763   { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
 764   { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
 765   { "warnmsg_delay",       vtype_stringptr,   &warnmsg_delay },
 766   { "warnmsg_recipient",   vtype_stringptr,   &warnmsg_recipients },
 767   { "warnmsg_recipients",  vtype_stringptr,   &warnmsg_recipients }
 768 };
 769
 770 static int var_table_size = nelem(var_table);
 771 static uschar var_buffer[256];
 772 static BOOL malformed_header;
 773
 774 /* For textual hashes */
 775
 776 static const char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
 777                                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 778                                "0123456789";
 779
 780 enum { HMAC_MD5, HMAC_SHA1 };
 781
 782 /* For numeric hashes */
 783
 784 static unsigned int prime[] = {
 785   2,   3,   5,   7,  11,  13,  17,  19,  23,  29,
 786  31,  37,  41,  43,  47,  53,  59,  61,  67,  71,
 787  73,  79,  83,  89,  97, 101, 103, 107, 109, 113};
 788
 789 /* For printing modes in symbolic form */
 790
 791 static uschar *mtable_normal[] =
 792   { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
 793
 794 static uschar *mtable_setid[] =
 795   { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
 796
 797 static uschar *mtable_sticky[] =
 798   { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
 799
 800
 801
 802 /*************************************************
 803 *           Tables for UTF-8 support             *
 804 *************************************************/
 805
 806 /* Table of the number of extra characters, indexed by the first character
 807 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
 808 0x3d. */
 809
 810 static uschar utf8_table1[] = {
 811   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 812   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 813   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 814   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
 815
 816 /* These are the masks for the data bits in the first byte of a character,
 817 indexed by the number of additional bytes. */
 818
 819 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
 820
 821 /* Get the next UTF-8 character, advancing the pointer. */
 822
 823 #define GETUTF8INC(c, ptr) \
 824   c = *ptr++; \
 825   if ((c & 0xc0) == 0xc0) \
 826     { \
 827     int a = utf8_table1[c & 0x3f];  /* Number of additional bytes */ \
 828     int s = 6*a; \
 829     c = (c & utf8_table2[a]) << s; \
 830     while (a-- > 0) \
 831       { \
 832       s -= 6; \
 833       c |= (*ptr++ & 0x3f) << s; \
 834       } \
 835     }
 836
 837
 838 /*************************************************
 839 *           Binary chop search on a table        *
 840 *************************************************/
 841
 842 /* This is used for matching expansion items and operators.
 843
 844 Arguments:
 845   name        the name that is being sought
 846   table       the table to search
 847   table_size  the number of items in the table
 848
 849 Returns:      the offset in the table, or -1
 850 */
 851
 852 static int
 853 chop_match(uschar *name, uschar **table, int table_size)
 854 {
 855 uschar **bot = table;
 856 uschar **top = table + table_size;
 857
 858 while (top > bot)
 859   {
 860   uschar **mid = bot + (top - bot)/2;
 861   int c = Ustrcmp(name, *mid);
 862   if (c == 0) return mid - table;
 863   if (c > 0) bot = mid + 1; else top = mid;
 864   }
 865
 866 return -1;
 867 }
 868
 869
 870
 871 /*************************************************
 872 *          Check a condition string              *
 873 *************************************************/
 874
 875 /* This function is called to expand a string, and test the result for a "true"
 876 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
 877 forced fail or lookup defer.
 878
 879 We used to release all store used, but this is not not safe due
 880 to ${dlfunc } and ${acl }.  In any case expand_string_internal()
 881 is reasonably careful to release what it can.
 882
 883 The actual false-value tests should be replicated for ECOND_BOOL_LAX.
 884
 885 Arguments:
 886   condition     the condition string
 887   m1            text to be incorporated in panic error
 888   m2            ditto
 889
 890 Returns:        TRUE if condition is met, FALSE if not
 891 */
 892
 893 BOOL
 894 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
 895 {
 896 int rc;
 897 uschar *ss = expand_string(condition);
 898 if (ss == NULL)
 899   {
 900   if (!expand_string_forcedfail && !search_find_defer)
 901     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
 902       "for %s %s: %s", condition, m1, m2, expand_string_message);
 903   return FALSE;
 904   }
 905 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
 906   strcmpic(ss, US"false") != 0;
 907 return rc;
 908 }
 909
 910
 911
 912
 913 /*************************************************
 914 *        Pseudo-random number generation         *
 915 *************************************************/
 916
 917 /* Pseudo-random number generation.  The result is not "expected" to be
 918 cryptographically strong but not so weak that someone will shoot themselves
 919 in the foot using it as a nonce in some email header scheme or whatever
 920 weirdness they'll twist this into.  The result should ideally handle fork().
 921
 922 However, if we're stuck unable to provide this, then we'll fall back to
 923 appallingly bad randomness.
 924
 925 If SUPPORT_TLS is defined then this will not be used except as an emergency
 926 fallback.
 927
 928 Arguments:
 929   max       range maximum
 930 Returns     a random number in range [0, max-1]
 931 */
 932
 933 #ifdef SUPPORT_TLS
 934 # define vaguely_random_number vaguely_random_number_fallback
 935 #endif
 936 int
 937 vaguely_random_number(int max)
 938 {
 939 #ifdef SUPPORT_TLS
 940 # undef vaguely_random_number
 941 #endif
 942   static pid_t pid = 0;
 943   pid_t p2;
 944 #if defined(HAVE_SRANDOM) && !defined(HAVE_SRANDOMDEV)
 945   struct timeval tv;
 946 #endif
 947
 948   p2 = getpid();
 949   if (p2 != pid)
 950     {
 951     if (pid != 0)
 952       {
 953
 954 #ifdef HAVE_ARC4RANDOM
 955       /* cryptographically strong randomness, common on *BSD platforms, not
 956       so much elsewhere.  Alas. */
 957 #ifndef NOT_HAVE_ARC4RANDOM_STIR
 958       arc4random_stir();
 959 #endif
 960 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
 961 #ifdef HAVE_SRANDOMDEV
 962       /* uses random(4) for seeding */
 963       srandomdev();
 964 #else
 965       gettimeofday(&tv, NULL);
 966       srandom(tv.tv_sec | tv.tv_usec | getpid());
 967 #endif
 968 #else
 969       /* Poor randomness and no seeding here */
 970 #endif
 971
 972       }
 973     pid = p2;
 974     }
 975
 976 #ifdef HAVE_ARC4RANDOM
 977   return arc4random() % max;
 978 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
 979   return random() % max;
 980 #else
 981   /* This one returns a 16-bit number, definitely not crypto-strong */
 982   return random_number(max);
 983 #endif
 984 }
 985
 986
 987
 988
 989 /*************************************************
 990 *             Pick out a name from a string      *
 991 *************************************************/
 992
 993 /* If the name is too long, it is silently truncated.
 994
 995 Arguments:
 996   name      points to a buffer into which to put the name
 997   max       is the length of the buffer
 998   s         points to the first alphabetic character of the name
 999   extras    chars other than alphanumerics to permit
1000
1001 Returns:    pointer to the first character after the name
1002
1003 Note: The test for *s != 0 in the while loop is necessary because
1004 Ustrchr() yields non-NULL if the character is zero (which is not something
1005 I expected). */
1006
1007 static const uschar *
1008 read_name(uschar *name, int max, const uschar *s, uschar *extras)
1009 {
1010 int ptr = 0;
1011 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
1012   {
1013   if (ptr < max-1) name[ptr++] = *s;
1014   s++;
1015   }
1016 name[ptr] = 0;
1017 return s;
1018 }
1019
1020
1021
1022 /*************************************************
1023 *     Pick out the rest of a header name         *
1024 *************************************************/
1025
1026 /* A variable name starting $header_ (or just $h_ for those who like
1027 abbreviations) might not be the complete header name because headers can
1028 contain any printing characters in their names, except ':'. This function is
1029 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
1030 on the end, if the name was terminated by white space.
1031
1032 Arguments:
1033   name      points to a buffer in which the name read so far exists
1034   max       is the length of the buffer
1035   s         points to the first character after the name so far, i.e. the
1036             first non-alphameric character after $header_xxxxx
1037
1038 Returns:    a pointer to the first character after the header name
1039 */
1040
1041 static const uschar *
1042 read_header_name(uschar *name, int max, const uschar *s)
1043 {
1044 int prelen = Ustrchr(name, '_') - name + 1;
1045 int ptr = Ustrlen(name) - prelen;
1046 if (ptr > 0) memmove(name, name+prelen, ptr);
1047 while (mac_isgraph(*s) && *s != ':')
1048   {
1049   if (ptr < max-1) name[ptr++] = *s;
1050   s++;
1051   }
1052 if (*s == ':') s++;
1053 name[ptr++] = ':';
1054 name[ptr] = 0;
1055 return s;
1056 }
1057
1058
1059
1060 /*************************************************
1061 *           Pick out a number from a string      *
1062 *************************************************/
1063
1064 /* Arguments:
1065   n     points to an integer into which to put the number
1066   s     points to the first digit of the number
1067
1068 Returns:  a pointer to the character after the last digit
1069 */
1070 /*XXX consider expanding to int_eximarith_t.  But the test for
1071 "overbig numbers" in 0002 still needs to overflow it. */
1072
1073 static uschar *
1074 read_number(int *n, uschar *s)
1075 {
1076 *n = 0;
1077 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1078 return s;
1079 }
1080
1081 static const uschar *
1082 read_cnumber(int *n, const uschar *s)
1083 {
1084 *n = 0;
1085 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1086 return s;
1087 }
1088
1089
1090
1091 /*************************************************
1092 *        Extract keyed subfield from a string    *
1093 *************************************************/
1094
1095 /* The yield is in dynamic store; NULL means that the key was not found.
1096
1097 Arguments:
1098   key       points to the name of the key
1099   s         points to the string from which to extract the subfield
1100
1101 Returns:    NULL if the subfield was not found, or
1102             a pointer to the subfield's data
1103 */
1104
1105 static uschar *
1106 expand_getkeyed(uschar *key, const uschar *s)
1107 {
1108 int length = Ustrlen(key);
1109 while (isspace(*s)) s++;
1110
1111 /* Loop to search for the key */
1112
1113 while (*s != 0)
1114   {
1115   int dkeylength;
1116   uschar *data;
1117   const uschar *dkey = s;
1118
1119   while (*s != 0 && *s != '=' && !isspace(*s)) s++;
1120   dkeylength = s - dkey;
1121   while (isspace(*s)) s++;
1122   if (*s == '=') while (isspace((*(++s))));
1123
1124   data = string_dequote(&s);
1125   if (length == dkeylength && strncmpic(key, dkey, length) == 0)
1126     return data;
1127
1128   while (isspace(*s)) s++;
1129   }
1130
1131 return NULL;
1132 }
1133
1134
1135
1136 static var_entry *
1137 find_var_ent(uschar * name)
1138 {
1139 int first = 0;
1140 int last = var_table_size;
1141
1142 while (last > first)
1143   {
1144   int middle = (first + last)/2;
1145   int c = Ustrcmp(name, var_table[middle].name);
1146
1147   if (c > 0) { first = middle + 1; continue; }
1148   if (c < 0) { last = middle; continue; }
1149   return &var_table[middle];
1150   }
1151 return NULL;
1152 }
1153
1154 /*************************************************
1155 *   Extract numbered subfield from string        *
1156 *************************************************/
1157
1158 /* Extracts a numbered field from a string that is divided by tokens - for
1159 example a line from /etc/passwd is divided by colon characters.  First field is
1160 numbered one.  Negative arguments count from the right. Zero returns the whole
1161 string. Returns NULL if there are insufficient tokens in the string
1162
1163 ***WARNING***
1164 Modifies final argument - this is a dynamically generated string, so that's OK.
1165
1166 Arguments:
1167   field       number of field to be extracted,
1168                 first field = 1, whole string = 0, last field = -1
1169   separators  characters that are used to break string into tokens
1170   s           points to the string from which to extract the subfield
1171
1172 Returns:      NULL if the field was not found,
1173               a pointer to the field's data inside s (modified to add 0)
1174 */
1175
1176 static uschar *
1177 expand_gettokened (int field, uschar *separators, uschar *s)
1178 {
1179 int sep = 1;
1180 int count;
1181 uschar *ss = s;
1182 uschar *fieldtext = NULL;
1183
1184 if (field == 0) return s;
1185
1186 /* Break the line up into fields in place; for field > 0 we stop when we have
1187 done the number of fields we want. For field < 0 we continue till the end of
1188 the string, counting the number of fields. */
1189
1190 count = (field > 0)? field : INT_MAX;
1191
1192 while (count-- > 0)
1193   {
1194   size_t len;
1195
1196   /* Previous field was the last one in the string. For a positive field
1197   number, this means there are not enough fields. For a negative field number,
1198   check that there are enough, and scan back to find the one that is wanted. */
1199
1200   if (sep == 0)
1201     {
1202     if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
1203     if ((-field) == (INT_MAX - count - 1)) return s;
1204     while (field++ < 0)
1205       {
1206       ss--;
1207       while (ss[-1] != 0) ss--;
1208       }
1209     fieldtext = ss;
1210     break;
1211     }
1212
1213   /* Previous field was not last in the string; save its start and put a
1214   zero at its end. */
1215
1216   fieldtext = ss;
1217   len = Ustrcspn(ss, separators);
1218   sep = ss[len];
1219   ss[len] = 0;
1220   ss += len + 1;
1221   }
1222
1223 return fieldtext;
1224 }
1225
1226
1227 static uschar *
1228 expand_getlistele(int field, const uschar * list)
1229 {
1230 const uschar * tlist= list;
1231 int sep= 0;
1232 uschar dummy;
1233
1234 if(field<0)
1235   {
1236   for(field++; string_nextinlist(&tlist, &sep, &dummy, 1); ) field++;
1237   sep= 0;
1238   }
1239 if(field==0) return NULL;
1240 while(--field>0 && (string_nextinlist(&list, &sep, &dummy, 1))) ;
1241 return string_nextinlist(&list, &sep, NULL, 0);
1242 }
1243
1244
1245 /* Certificate fields, by name.  Worry about by-OID later */
1246 /* Names are chosen to not have common prefixes */
1247
1248 #ifdef SUPPORT_TLS
1249 typedef struct
1250 {
1251 uschar * name;
1252 int      namelen;
1253 uschar * (*getfn)(void * cert, uschar * mod);
1254 } certfield;
1255 static certfield certfields[] =
1256 {                       /* linear search; no special order */
1257   { US"version",         7,  &tls_cert_version },
1258   { US"serial_number",   13, &tls_cert_serial_number },
1259   { US"subject",         7,  &tls_cert_subject },
1260   { US"notbefore",       9,  &tls_cert_not_before },
1261   { US"notafter",        8,  &tls_cert_not_after },
1262   { US"issuer",          6,  &tls_cert_issuer },
1263   { US"signature",       9,  &tls_cert_signature },
1264   { US"sig_algorithm",   13, &tls_cert_signature_algorithm },
1265   { US"subj_altname",    12, &tls_cert_subject_altname },
1266   { US"ocsp_uri",        8,  &tls_cert_ocsp_uri },
1267   { US"crl_uri",         7,  &tls_cert_crl_uri },
1268 };
1269
1270 static uschar *
1271 expand_getcertele(uschar * field, uschar * certvar)
1272 {
1273 var_entry * vp;
1274 certfield * cp;
1275
1276 if (!(vp = find_var_ent(certvar)))
1277   {
1278   expand_string_message =
1279     string_sprintf("no variable named \"%s\"", certvar);
1280   return NULL;          /* Unknown variable name */
1281   }
1282 /* NB this stops us passing certs around in variable.  Might
1283 want to do that in future */
1284 if (vp->type != vtype_cert)
1285   {
1286   expand_string_message =
1287     string_sprintf("\"%s\" is not a certificate", certvar);
1288   return NULL;          /* Unknown variable name */
1289   }
1290 if (!*(void **)vp->value)
1291   return NULL;
1292
1293 if (*field >= '0' && *field <= '9')
1294   return tls_cert_ext_by_oid(*(void **)vp->value, field, 0);
1295
1296 for(cp = certfields;
1297     cp < certfields + nelem(certfields);
1298     cp++)
1299   if (Ustrncmp(cp->name, field, cp->namelen) == 0)
1300     {
1301     uschar * modifier = *(field += cp->namelen) == ','
1302       ? ++field : NULL;
1303     return (*cp->getfn)( *(void **)vp->value, modifier );
1304     }
1305
1306 expand_string_message =
1307   string_sprintf("bad field selector \"%s\" for certextract", field);
1308 return NULL;
1309 }
1310 #endif  /*SUPPORT_TLS*/
1311
1312 /*************************************************
1313 *        Extract a substring from a string       *
1314 *************************************************/
1315
1316 /* Perform the ${substr or ${length expansion operations.
1317
1318 Arguments:
1319   subject     the input string
1320   value1      the offset from the start of the input string to the start of
1321                 the output string; if negative, count from the right.
1322   value2      the length of the output string, or negative (-1) for unset
1323                 if value1 is positive, unset means "all after"
1324                 if value1 is negative, unset means "all before"
1325   len         set to the length of the returned string
1326
1327 Returns:      pointer to the output string, or NULL if there is an error
1328 */
1329
1330 static uschar *
1331 extract_substr(uschar *subject, int value1, int value2, int *len)
1332 {
1333 int sublen = Ustrlen(subject);
1334
1335 if (value1 < 0)    /* count from right */
1336   {
1337   value1 += sublen;
1338
1339   /* If the position is before the start, skip to the start, and adjust the
1340   length. If the length ends up negative, the substring is null because nothing
1341   can precede. This falls out naturally when the length is unset, meaning "all
1342   to the left". */
1343
1344   if (value1 < 0)
1345     {
1346     value2 += value1;
1347     if (value2 < 0) value2 = 0;
1348     value1 = 0;
1349     }
1350
1351   /* Otherwise an unset length => characters before value1 */
1352
1353   else if (value2 < 0)
1354     {
1355     value2 = value1;
1356     value1 = 0;
1357     }
1358   }
1359
1360 /* For a non-negative offset, if the starting position is past the end of the
1361 string, the result will be the null string. Otherwise, an unset length means
1362 "rest"; just set it to the maximum - it will be cut down below if necessary. */
1363
1364 else
1365   {
1366   if (value1 > sublen)
1367     {
1368     value1 = sublen;
1369     value2 = 0;
1370     }
1371   else if (value2 < 0) value2 = sublen;
1372   }
1373
1374 /* Cut the length down to the maximum possible for the offset value, and get
1375 the required characters. */
1376
1377 if (value1 + value2 > sublen) value2 = sublen - value1;
1378 *len = value2;
1379 return subject + value1;
1380 }
1381
1382
1383
1384
1385 /*************************************************
1386 *            Old-style hash of a string          *
1387 *************************************************/
1388
1389 /* Perform the ${hash expansion operation.
1390
1391 Arguments:
1392   subject     the input string (an expanded substring)
1393   value1      the length of the output string; if greater or equal to the
1394                 length of the input string, the input string is returned
1395   value2      the number of hash characters to use, or 26 if negative
1396   len         set to the length of the returned string
1397
1398 Returns:      pointer to the output string, or NULL if there is an error
1399 */
1400
1401 static uschar *
1402 compute_hash(uschar *subject, int value1, int value2, int *len)
1403 {
1404 int sublen = Ustrlen(subject);
1405
1406 if (value2 < 0) value2 = 26;
1407 else if (value2 > Ustrlen(hashcodes))
1408   {
1409   expand_string_message =
1410     string_sprintf("hash count \"%d\" too big", value2);
1411   return NULL;
1412   }
1413
1414 /* Calculate the hash text. We know it is shorter than the original string, so
1415 can safely place it in subject[] (we know that subject is always itself an
1416 expanded substring). */
1417
1418 if (value1 < sublen)
1419   {
1420   int c;
1421   int i = 0;
1422   int j = value1;
1423   while ((c = (subject[j])) != 0)
1424     {
1425     int shift = (c + j++) & 7;
1426     subject[i] ^= (c << shift) | (c >> (8-shift));
1427     if (++i >= value1) i = 0;
1428     }
1429   for (i = 0; i < value1; i++)
1430     subject[i] = hashcodes[(subject[i]) % value2];
1431   }
1432 else value1 = sublen;
1433
1434 *len = value1;
1435 return subject;
1436 }
1437
1438
1439
1440
1441 /*************************************************
1442 *             Numeric hash of a string           *
1443 *************************************************/
1444
1445 /* Perform the ${nhash expansion operation. The first characters of the
1446 string are treated as most important, and get the highest prime numbers.
1447
1448 Arguments:
1449   subject     the input string
1450   value1      the maximum value of the first part of the result
1451   value2      the maximum value of the second part of the result,
1452                 or negative to produce only a one-part result
1453   len         set to the length of the returned string
1454
1455 Returns:  pointer to the output string, or NULL if there is an error.
1456 */
1457
1458 static uschar *
1459 compute_nhash (uschar *subject, int value1, int value2, int *len)
1460 {
1461 uschar *s = subject;
1462 int i = 0;
1463 unsigned long int total = 0; /* no overflow */
1464
1465 while (*s != 0)
1466   {
1467   if (i == 0) i = nelem(prime) - 1;
1468   total += prime[i--] * (unsigned int)(*s++);
1469   }
1470
1471 /* If value2 is unset, just compute one number */
1472
1473 if (value2 < 0)
1474   {
1475   s = string_sprintf("%d", total % value1);
1476   }
1477
1478 /* Otherwise do a div/mod hash */
1479
1480 else
1481   {
1482   total = total % (value1 * value2);
1483   s = string_sprintf("%d/%d", total/value2, total % value2);
1484   }
1485
1486 *len = Ustrlen(s);
1487 return s;
1488 }
1489
1490
1491
1492
1493
1494 /*************************************************
1495 *     Find the value of a header or headers      *
1496 *************************************************/
1497
1498 /* Multiple instances of the same header get concatenated, and this function
1499 can also return a concatenation of all the header lines. When concatenating
1500 specific headers that contain lists of addresses, a comma is inserted between
1501 them. Otherwise we use a straight concatenation. Because some messages can have
1502 pathologically large number of lines, there is a limit on the length that is
1503 returned. Also, to avoid massive store use which would result from using
1504 string_cat() as it copies and extends strings, we do a preliminary pass to find
1505 out exactly how much store will be needed. On "normal" messages this will be
1506 pretty trivial.
1507
1508 Arguments:
1509   name          the name of the header, without the leading $header_ or $h_,
1510                 or NULL if a concatenation of all headers is required
1511   exists_only   TRUE if called from a def: test; don't need to build a string;
1512                 just return a string that is not "" and not "0" if the header
1513                 exists
1514   newsize       return the size of memory block that was obtained; may be NULL
1515                 if exists_only is TRUE
1516   want_raw      TRUE if called for $rh_ or $rheader_ variables; no processing,
1517                 other than concatenating, will be done on the header. Also used
1518                 for $message_headers_raw.
1519   charset       name of charset to translate MIME words to; used only if
1520                 want_raw is false; if NULL, no translation is done (this is
1521                 used for $bh_ and $bheader_)
1522
1523 Returns:        NULL if the header does not exist, else a pointer to a new
1524                 store block
1525 */
1526
1527 static uschar *
1528 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1529   uschar *charset)
1530 {
1531 BOOL found = name == NULL;
1532 int comma = 0;
1533 int len = found? 0 : Ustrlen(name);
1534 int i;
1535 uschar *yield = NULL;
1536 uschar *ptr = NULL;
1537
1538 /* Loop for two passes - saves code repetition */
1539
1540 for (i = 0; i < 2; i++)
1541   {
1542   int size = 0;
1543   header_line *h;
1544
1545   for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1546     {
1547     if (h->type != htype_old && h->text != NULL)  /* NULL => Received: placeholder */
1548       {
1549       if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1550         {
1551         int ilen;
1552         uschar *t;
1553
1554         if (exists_only) return US"1";      /* don't need actual string */
1555         found = TRUE;
1556         t = h->text + len;                  /* text to insert */
1557         if (!want_raw)                      /* unless wanted raw, */
1558           while (isspace(*t)) t++;          /* remove leading white space */
1559         ilen = h->slen - (t - h->text);     /* length to insert */
1560
1561         /* Unless wanted raw, remove trailing whitespace, including the
1562         newline. */
1563
1564         if (!want_raw)
1565           while (ilen > 0 && isspace(t[ilen-1])) ilen--;
1566
1567         /* Set comma = 1 if handling a single header and it's one of those
1568         that contains an address list, except when asked for raw headers. Only
1569         need to do this once. */
1570
1571         if (!want_raw && name != NULL && comma == 0 &&
1572             Ustrchr("BCFRST", h->type) != NULL)
1573           comma = 1;
1574
1575         /* First pass - compute total store needed; second pass - compute
1576         total store used, including this header. */
1577
1578         size += ilen + comma + 1;  /* +1 for the newline */
1579
1580         /* Second pass - concatentate the data, up to a maximum. Note that
1581         the loop stops when size hits the limit. */
1582
1583         if (i != 0)
1584           {
1585           if (size > header_insert_maxlen)
1586             {
1587             ilen -= size - header_insert_maxlen - 1;
1588             comma = 0;
1589             }
1590           Ustrncpy(ptr, t, ilen);
1591           ptr += ilen;
1592
1593           /* For a non-raw header, put in the comma if needed, then add
1594           back the newline we removed above, provided there was some text in
1595           the header. */
1596
1597           if (!want_raw && ilen > 0)
1598             {
1599             if (comma != 0) *ptr++ = ',';
1600             *ptr++ = '\n';
1601             }
1602           }
1603         }
1604       }
1605     }
1606
1607   /* At end of first pass, return NULL if no header found. Then truncate size
1608   if necessary, and get the buffer to hold the data, returning the buffer size.
1609   */
1610
1611   if (i == 0)
1612     {
1613     if (!found) return NULL;
1614     if (size > header_insert_maxlen) size = header_insert_maxlen;
1615     *newsize = size + 1;
1616     ptr = yield = store_get(*newsize);
1617     }
1618   }
1619
1620 /* That's all we do for raw header expansion. */
1621
1622 if (want_raw)
1623   {
1624   *ptr = 0;
1625   }
1626
1627 /* Otherwise, remove a final newline and a redundant added comma. Then we do
1628 RFC 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1629 function can return an error with decoded data if the charset translation
1630 fails. If decoding fails, it returns NULL. */
1631
1632 else
1633   {
1634   uschar *decoded, *error;
1635   if (ptr > yield && ptr[-1] == '\n') ptr--;
1636   if (ptr > yield && comma != 0 && ptr[-1] == ',') ptr--;
1637   *ptr = 0;
1638   decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1639     newsize, &error);
1640   if (error != NULL)
1641     {
1642     DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1643       "    input was: %s\n", error, yield);
1644     }
1645   if (decoded != NULL) yield = decoded;
1646   }
1647
1648 return yield;
1649 }
1650
1651
1652
1653
1654 /*************************************************
1655 *               Return list of recipients        *
1656 *************************************************/
1657 /* A recipients list is available only during system message filtering,
1658 during ACL processing after DATA, and while expanding pipe commands
1659 generated from a system filter, but not elsewhere. */
1660
1661 static uschar *
1662 fn_recipients(void)
1663 {
1664 if (!enable_dollar_recipients) return NULL; else
1665   {
1666   int size = 128;
1667   int ptr = 0;
1668   int i;
1669   uschar * s = store_get(size);
1670   for (i = 0; i < recipients_count; i++)
1671     {
1672     if (i != 0) s = string_catn(s, &size, &ptr, US", ", 2);
1673     s = string_cat(s, &size, &ptr, recipients_list[i].address);
1674     }
1675   s[ptr] = 0;     /* string_cat() leaves room */
1676   return s;
1677   }
1678 }
1679
1680
1681 /*************************************************
1682 *               Find value of a variable         *
1683 *************************************************/
1684
1685 /* The table of variables is kept in alphabetic order, so we can search it
1686 using a binary chop. The "choplen" variable is nothing to do with the binary
1687 chop.
1688
1689 Arguments:
1690   name          the name of the variable being sought
1691   exists_only   TRUE if this is a def: test; passed on to find_header()
1692   skipping      TRUE => skip any processing evaluation; this is not the same as
1693                   exists_only because def: may test for values that are first
1694                   evaluated here
1695   newsize       pointer to an int which is initially zero; if the answer is in
1696                 a new memory buffer, *newsize is set to its size
1697
1698 Returns:        NULL if the variable does not exist, or
1699                 a pointer to the variable's contents, or
1700                 something non-NULL if exists_only is TRUE
1701 */
1702
1703 static uschar *
1704 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1705 {
1706 var_entry * vp;
1707 uschar *s, *domain;
1708 uschar **ss;
1709 void * val;
1710
1711 /* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1712 Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1713 release 4.64 onwards arbitrary names are permitted, as long as the first 5
1714 characters are acl_c or acl_m and the sixth is either a digit or an underscore
1715 (this gave backwards compatibility at the changeover). There may be built-in
1716 variables whose names start acl_ but they should never start in this way. This
1717 slightly messy specification is a consequence of the history, needless to say.
1718
1719 If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1720 set, in which case give an error. */
1721
1722 if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1723      !isalpha(name[5]))
1724   {
1725   tree_node *node =
1726     tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
1727   return node ? node->data.ptr : strict_acl_vars ? NULL : US"";
1728   }
1729
1730 /* Handle $auth<n> variables. */
1731
1732 if (Ustrncmp(name, "auth", 4) == 0)
1733   {
1734   uschar *endptr;
1735   int n = Ustrtoul(name + 4, &endptr, 10);
1736   if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
1737     return !auth_vars[n-1] ? US"" : auth_vars[n-1];
1738   }
1739 else if (Ustrncmp(name, "regex", 5) == 0)
1740   {
1741   uschar *endptr;
1742   int n = Ustrtoul(name + 5, &endptr, 10);
1743   if (*endptr == 0 && n != 0 && n <= REGEX_VARS)
1744     return !regex_vars[n-1] ? US"" : regex_vars[n-1];
1745   }
1746
1747 /* For all other variables, search the table */
1748
1749 if (!(vp = find_var_ent(name)))
1750   return NULL;          /* Unknown variable name */
1751
1752 /* Found an existing variable. If in skipping state, the value isn't needed,
1753 and we want to avoid processing (such as looking up the host name). */
1754
1755 if (skipping)
1756   return US"";
1757
1758 val = vp->value;
1759 switch (vp->type)
1760   {
1761   case vtype_filter_int:
1762     if (!filter_running) return NULL;
1763     /* Fall through */
1764     /* VVVVVVVVVVVV */
1765   case vtype_int:
1766     sprintf(CS var_buffer, "%d", *(int *)(val)); /* Integer */
1767     return var_buffer;
1768
1769   case vtype_ino:
1770     sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(val))); /* Inode */
1771     return var_buffer;
1772
1773   case vtype_gid:
1774     sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(val))); /* gid */
1775     return var_buffer;
1776
1777   case vtype_uid:
1778     sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(val))); /* uid */
1779     return var_buffer;
1780
1781   case vtype_bool:
1782     sprintf(CS var_buffer, "%s", *(BOOL *)(val) ? "yes" : "no"); /* bool */
1783     return var_buffer;
1784
1785   case vtype_stringptr:                      /* Pointer to string */
1786     return (s = *((uschar **)(val))) ? s : US"";
1787
1788   case vtype_pid:
1789     sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1790     return var_buffer;
1791
1792   case vtype_load_avg:
1793     sprintf(CS var_buffer, "%d", OS_GETLOADAVG()); /* load_average */
1794     return var_buffer;
1795
1796   case vtype_host_lookup:                    /* Lookup if not done so */
1797     if (sender_host_name == NULL && sender_host_address != NULL &&
1798         !host_lookup_failed && host_name_lookup() == OK)
1799       host_build_sender_fullhost();
1800     return (sender_host_name == NULL)? US"" : sender_host_name;
1801
1802   case vtype_localpart:                      /* Get local part from address */
1803     s = *((uschar **)(val));
1804     if (s == NULL) return US"";
1805     domain = Ustrrchr(s, '@');
1806     if (domain == NULL) return s;
1807     if (domain - s > sizeof(var_buffer) - 1)
1808       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than " SIZE_T_FMT
1809           " in string expansion", sizeof(var_buffer));
1810     Ustrncpy(var_buffer, s, domain - s);
1811     var_buffer[domain - s] = 0;
1812     return var_buffer;
1813
1814   case vtype_domain:                         /* Get domain from address */
1815     s = *((uschar **)(val));
1816     if (s == NULL) return US"";
1817     domain = Ustrrchr(s, '@');
1818     return (domain == NULL)? US"" : domain + 1;
1819
1820   case vtype_msgheaders:
1821     return find_header(NULL, exists_only, newsize, FALSE, NULL);
1822
1823   case vtype_msgheaders_raw:
1824     return find_header(NULL, exists_only, newsize, TRUE, NULL);
1825
1826   case vtype_msgbody:                        /* Pointer to msgbody string */
1827   case vtype_msgbody_end:                    /* Ditto, the end of the msg */
1828     ss = (uschar **)(val);
1829     if (*ss == NULL && deliver_datafile >= 0)  /* Read body when needed */
1830       {
1831       uschar *body;
1832       off_t start_offset = SPOOL_DATA_START_OFFSET;
1833       int len = message_body_visible;
1834       if (len > message_size) len = message_size;
1835       *ss = body = store_malloc(len+1);
1836       body[0] = 0;
1837       if (vp->type == vtype_msgbody_end)
1838         {
1839         struct stat statbuf;
1840         if (fstat(deliver_datafile, &statbuf) == 0)
1841           {
1842           start_offset = statbuf.st_size - len;
1843           if (start_offset < SPOOL_DATA_START_OFFSET)
1844             start_offset = SPOOL_DATA_START_OFFSET;
1845           }
1846         }
1847       if (lseek(deliver_datafile, start_offset, SEEK_SET) < 0)
1848         log_write(0, LOG_MAIN|LOG_PANIC_DIE, "deliver_datafile lseek: %s",
1849           strerror(errno));
1850       len = read(deliver_datafile, body, len);
1851       if (len > 0)
1852         {
1853         body[len] = 0;
1854         if (message_body_newlines)   /* Separate loops for efficiency */
1855           while (len > 0)
1856             { if (body[--len] == 0) body[len] = ' '; }
1857         else
1858           while (len > 0)
1859             { if (body[--len] == '\n' || body[len] == 0) body[len] = ' '; }
1860         }
1861       }
1862     return (*ss == NULL)? US"" : *ss;
1863
1864   case vtype_todbsdin:                       /* BSD inbox time of day */
1865     return tod_stamp(tod_bsdin);
1866
1867   case vtype_tode:                           /* Unix epoch time of day */
1868     return tod_stamp(tod_epoch);
1869
1870   case vtype_todel:                          /* Unix epoch/usec time of day */
1871     return tod_stamp(tod_epoch_l);
1872
1873   case vtype_todf:                           /* Full time of day */
1874     return tod_stamp(tod_full);
1875
1876   case vtype_todl:                           /* Log format time of day */
1877     return tod_stamp(tod_log_bare);            /* (without timezone) */
1878
1879   case vtype_todzone:                        /* Time zone offset only */
1880     return tod_stamp(tod_zone);
1881
1882   case vtype_todzulu:                        /* Zulu time */
1883     return tod_stamp(tod_zulu);
1884
1885   case vtype_todlf:                          /* Log file datestamp tod */
1886     return tod_stamp(tod_log_datestamp_daily);
1887
1888   case vtype_reply:                          /* Get reply address */
1889     s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1890       headers_charset);
1891     if (s != NULL) while (isspace(*s)) s++;
1892     if (s == NULL || *s == 0)
1893       {
1894       *newsize = 0;                            /* For the *s==0 case */
1895       s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1896       }
1897     if (s != NULL)
1898       {
1899       uschar *t;
1900       while (isspace(*s)) s++;
1901       for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1902       while (t > s && isspace(t[-1])) t--;
1903       *t = 0;
1904       }
1905     return (s == NULL)? US"" : s;
1906
1907   case vtype_string_func:
1908     {
1909     uschar * (*fn)() = val;
1910     return fn();
1911     }
1912
1913   case vtype_pspace:
1914     {
1915     int inodes;
1916     sprintf(CS var_buffer, "%d",
1917       receive_statvfs(val == (void *)TRUE, &inodes));
1918     }
1919   return var_buffer;
1920
1921   case vtype_pinodes:
1922     {
1923     int inodes;
1924     (void) receive_statvfs(val == (void *)TRUE, &inodes);
1925     sprintf(CS var_buffer, "%d", inodes);
1926     }
1927   return var_buffer;
1928
1929   case vtype_cert:
1930     return *(void **)val ? US"<cert>" : US"";
1931
1932 #ifndef DISABLE_DKIM
1933   case vtype_dkim:
1934     return dkim_exim_expand_query((int)(long)val);
1935 #endif
1936
1937   }
1938
1939 return NULL;  /* Unknown variable. Silences static checkers. */
1940 }
1941
1942
1943
1944
1945 void
1946 modify_variable(uschar *name, void * value)
1947 {
1948 var_entry * vp;
1949 if ((vp = find_var_ent(name))) vp->value = value;
1950 return;          /* Unknown variable name, fail silently */
1951 }
1952
1953
1954
1955
1956
1957 /*************************************************
1958 *           Read and expand substrings           *
1959 *************************************************/
1960
1961 /* This function is called to read and expand argument substrings for various
1962 expansion items. Some have a minimum requirement that is less than the maximum;
1963 in these cases, the first non-present one is set to NULL.
1964
1965 Arguments:
1966   sub        points to vector of pointers to set
1967   n          maximum number of substrings
1968   m          minimum required
1969   sptr       points to current string pointer
1970   skipping   the skipping flag
1971   check_end  if TRUE, check for final '}'
1972   name       name of item, for error message
1973   resetok    if not NULL, pointer to flag - write FALSE if unsafe to reset
1974              the store.
1975
1976 Returns:     0 OK; string pointer updated
1977              1 curly bracketing error (too few arguments)
1978              2 too many arguments (only if check_end is set); message set
1979              3 other error (expansion failure)
1980 */
1981
1982 static int
1983 read_subs(uschar **sub, int n, int m, const uschar **sptr, BOOL skipping,
1984   BOOL check_end, uschar *name, BOOL *resetok)
1985 {
1986 int i;
1987 const uschar *s = *sptr;
1988
1989 while (isspace(*s)) s++;
1990 for (i = 0; i < n; i++)
1991   {
1992   if (*s != '{')
1993     {
1994     if (i < m)
1995       {
1996       expand_string_message = string_sprintf("Not enough arguments for '%s' "
1997         "(min is %d)", name, m);
1998       return 1;
1999       }
2000     sub[i] = NULL;
2001     break;
2002     }
2003   if (!(sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, resetok)))
2004     return 3;
2005   if (*s++ != '}') return 1;
2006   while (isspace(*s)) s++;
2007   }
2008 if (check_end && *s++ != '}')
2009   {
2010   if (s[-1] == '{')
2011     {
2012     expand_string_message = string_sprintf("Too many arguments for '%s' "
2013       "(max is %d)", name, n);
2014     return 2;
2015     }
2016   expand_string_message = string_sprintf("missing '}' after '%s'", name);
2017   return 1;
2018   }
2019
2020 *sptr = s;
2021 return 0;
2022 }
2023
2024
2025
2026
2027 /*************************************************
2028 *     Elaborate message for bad variable         *
2029 *************************************************/
2030
2031 /* For the "unknown variable" message, take a look at the variable's name, and
2032 give additional information about possible ACL variables. The extra information
2033 is added on to expand_string_message.
2034
2035 Argument:   the name of the variable
2036 Returns:    nothing
2037 */
2038
2039 static void
2040 check_variable_error_message(uschar *name)
2041 {
2042 if (Ustrncmp(name, "acl_", 4) == 0)
2043   expand_string_message = string_sprintf("%s (%s)", expand_string_message,
2044     (name[4] == 'c' || name[4] == 'm')?
2045       (isalpha(name[5])?
2046         US"6th character of a user-defined ACL variable must be a digit or underscore" :
2047         US"strict_acl_vars is set"    /* Syntax is OK, it has to be this */
2048       ) :
2049       US"user-defined ACL variables must start acl_c or acl_m");
2050 }
2051
2052
2053
2054 /*
2055 Load args from sub array to globals, and call acl_check().
2056 Sub array will be corrupted on return.
2057
2058 Returns:       OK         access is granted by an ACCEPT verb
2059                DISCARD    access is (apparently) granted by a DISCARD verb
2060                FAIL       access is denied
2061                FAIL_DROP  access is denied; drop the connection
2062                DEFER      can't tell at the moment
2063                ERROR      disaster
2064 */
2065 static int
2066 eval_acl(uschar ** sub, int nsub, uschar ** user_msgp)
2067 {
2068 int i;
2069 int sav_narg = acl_narg;
2070 int ret;
2071 uschar * dummy_logmsg;
2072 extern int acl_where;
2073
2074 if(--nsub > nelem(acl_arg)) nsub = nelem(acl_arg);
2075 for (i = 0; i < nsub && sub[i+1]; i++)
2076   {
2077   uschar * tmp = acl_arg[i];
2078   acl_arg[i] = sub[i+1];        /* place callers args in the globals */
2079   sub[i+1] = tmp;               /* stash the old args using our caller's storage */
2080   }
2081 acl_narg = i;
2082 while (i < nsub)
2083   {
2084   sub[i+1] = acl_arg[i];
2085   acl_arg[i++] = NULL;
2086   }
2087
2088 DEBUG(D_expand)
2089   debug_printf("expanding: acl: %s  arg: %s%s\n",
2090     sub[0],
2091     acl_narg>0 ? acl_arg[0] : US"<none>",
2092     acl_narg>1 ? " +more"   : "");
2093
2094 ret = acl_eval(acl_where, sub[0], user_msgp, &dummy_logmsg);
2095
2096 for (i = 0; i < nsub; i++)
2097   acl_arg[i] = sub[i+1];        /* restore old args */
2098 acl_narg = sav_narg;
2099
2100 return ret;
2101 }
2102
2103
2104
2105
2106 /*************************************************
2107 *        Read and evaluate a condition           *
2108 *************************************************/
2109
2110 /*
2111 Arguments:
2112   s        points to the start of the condition text
2113   resetok  points to a BOOL which is written false if it is unsafe to
2114            free memory. Certain condition types (acl) may have side-effect
2115            allocation which must be preserved.
2116   yield    points to a BOOL to hold the result of the condition test;
2117            if NULL, we are just reading through a condition that is
2118            part of an "or" combination to check syntax, or in a state
2119            where the answer isn't required
2120
2121 Returns:   a pointer to the first character after the condition, or
2122            NULL after an error
2123 */
2124
2125 static const uschar *
2126 eval_condition(const uschar *s, BOOL *resetok, BOOL *yield)
2127 {
2128 BOOL testfor = TRUE;
2129 BOOL tempcond, combined_cond;
2130 BOOL *subcondptr;
2131 BOOL sub2_honour_dollar = TRUE;
2132 int i, rc, cond_type, roffset;
2133 int_eximarith_t num[2];
2134 struct stat statbuf;
2135 uschar name[256];
2136 const uschar *sub[10];
2137
2138 const pcre *re;
2139 const uschar *rerror;
2140
2141 for (;;)
2142   {
2143   while (isspace(*s)) s++;
2144   if (*s == '!') { testfor = !testfor; s++; } else break;
2145   }
2146
2147 /* Numeric comparisons are symbolic */
2148
2149 if (*s == '=' || *s == '>' || *s == '<')
2150   {
2151   int p = 0;
2152   name[p++] = *s++;
2153   if (*s == '=')
2154     {
2155     name[p++] = '=';
2156     s++;
2157     }
2158   name[p] = 0;
2159   }
2160
2161 /* All other conditions are named */
2162
2163 else s = read_name(name, 256, s, US"_");
2164
2165 /* If we haven't read a name, it means some non-alpha character is first. */
2166
2167 if (name[0] == 0)
2168   {
2169   expand_string_message = string_sprintf("condition name expected, "
2170     "but found \"%.16s\"", s);
2171   return NULL;
2172   }
2173
2174 /* Find which condition we are dealing with, and switch on it */
2175
2176 cond_type = chop_match(name, cond_table, nelem(cond_table));
2177 switch(cond_type)
2178   {
2179   /* def: tests for a non-empty variable, or for the existence of a header. If
2180   yield == NULL we are in a skipping state, and don't care about the answer. */
2181
2182   case ECOND_DEF:
2183   if (*s != ':')
2184     {
2185     expand_string_message = US"\":\" expected after \"def\"";
2186     return NULL;
2187     }
2188
2189   s = read_name(name, 256, s+1, US"_");
2190
2191   /* Test for a header's existence. If the name contains a closing brace
2192   character, this may be a user error where the terminating colon has been
2193   omitted. Set a flag to adjust a subsequent error message in this case. */
2194
2195   if (Ustrncmp(name, "h_", 2) == 0 ||
2196       Ustrncmp(name, "rh_", 3) == 0 ||
2197       Ustrncmp(name, "bh_", 3) == 0 ||
2198       Ustrncmp(name, "header_", 7) == 0 ||
2199       Ustrncmp(name, "rheader_", 8) == 0 ||
2200       Ustrncmp(name, "bheader_", 8) == 0)
2201     {
2202     s = read_header_name(name, 256, s);
2203     /* {-for-text-editors */
2204     if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2205     if (yield != NULL) *yield =
2206       (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
2207     }
2208
2209   /* Test for a variable's having a non-empty value. A non-existent variable
2210   causes an expansion failure. */
2211
2212   else
2213     {
2214     uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
2215     if (value == NULL)
2216       {
2217       expand_string_message = (name[0] == 0)?
2218         string_sprintf("variable name omitted after \"def:\"") :
2219         string_sprintf("unknown variable \"%s\" after \"def:\"", name);
2220       check_variable_error_message(name);
2221       return NULL;
2222       }
2223     if (yield != NULL) *yield = (value[0] != 0) == testfor;
2224     }
2225
2226   return s;
2227
2228
2229   /* first_delivery tests for first delivery attempt */
2230
2231   case ECOND_FIRST_DELIVERY:
2232   if (yield != NULL) *yield = deliver_firsttime == testfor;
2233   return s;
2234
2235
2236   /* queue_running tests for any process started by a queue runner */
2237
2238   case ECOND_QUEUE_RUNNING:
2239   if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
2240   return s;
2241
2242
2243   /* exists:  tests for file existence
2244        isip:  tests for any IP address
2245       isip4:  tests for an IPv4 address
2246       isip6:  tests for an IPv6 address
2247         pam:  does PAM authentication
2248      radius:  does RADIUS authentication
2249    ldapauth:  does LDAP authentication
2250     pwcheck:  does Cyrus SASL pwcheck authentication
2251   */
2252
2253   case ECOND_EXISTS:
2254   case ECOND_ISIP:
2255   case ECOND_ISIP4:
2256   case ECOND_ISIP6:
2257   case ECOND_PAM:
2258   case ECOND_RADIUS:
2259   case ECOND_LDAPAUTH:
2260   case ECOND_PWCHECK:
2261
2262   while (isspace(*s)) s++;
2263   if (*s != '{') goto COND_FAILED_CURLY_START;          /* }-for-text-editors */
2264
2265   sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL, TRUE, resetok);
2266   if (sub[0] == NULL) return NULL;
2267   /* {-for-text-editors */
2268   if (*s++ != '}') goto COND_FAILED_CURLY_END;
2269
2270   if (yield == NULL) return s;   /* No need to run the test if skipping */
2271
2272   switch(cond_type)
2273     {
2274     case ECOND_EXISTS:
2275     if ((expand_forbid & RDO_EXISTS) != 0)
2276       {
2277       expand_string_message = US"File existence tests are not permitted";
2278       return NULL;
2279       }
2280     *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
2281     break;
2282
2283     case ECOND_ISIP:
2284     case ECOND_ISIP4:
2285     case ECOND_ISIP6:
2286     rc = string_is_ip_address(sub[0], NULL);
2287     *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
2288              (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
2289     break;
2290
2291     /* Various authentication tests - all optionally compiled */
2292
2293     case ECOND_PAM:
2294     #ifdef SUPPORT_PAM
2295     rc = auth_call_pam(sub[0], &expand_string_message);
2296     goto END_AUTH;
2297     #else
2298     goto COND_FAILED_NOT_COMPILED;
2299     #endif  /* SUPPORT_PAM */
2300
2301     case ECOND_RADIUS:
2302     #ifdef RADIUS_CONFIG_FILE
2303     rc = auth_call_radius(sub[0], &expand_string_message);
2304     goto END_AUTH;
2305     #else
2306     goto COND_FAILED_NOT_COMPILED;
2307     #endif  /* RADIUS_CONFIG_FILE */
2308
2309     case ECOND_LDAPAUTH:
2310     #ifdef LOOKUP_LDAP
2311       {
2312       /* Just to keep the interface the same */
2313       BOOL do_cache;
2314       int old_pool = store_pool;
2315       store_pool = POOL_SEARCH;
2316       rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
2317         &expand_string_message, &do_cache);
2318       store_pool = old_pool;
2319       }
2320     goto END_AUTH;
2321     #else
2322     goto COND_FAILED_NOT_COMPILED;
2323     #endif  /* LOOKUP_LDAP */
2324
2325     case ECOND_PWCHECK:
2326     #ifdef CYRUS_PWCHECK_SOCKET
2327     rc = auth_call_pwcheck(sub[0], &expand_string_message);
2328     goto END_AUTH;
2329     #else
2330     goto COND_FAILED_NOT_COMPILED;
2331     #endif  /* CYRUS_PWCHECK_SOCKET */
2332
2333     #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
2334         defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
2335     END_AUTH:
2336     if (rc == ERROR || rc == DEFER) return NULL;
2337     *yield = (rc == OK) == testfor;
2338     #endif
2339     }
2340   return s;
2341
2342
2343   /* call ACL (in a conditional context).  Accept true, deny false.
2344   Defer is a forced-fail.  Anything set by message= goes to $value.
2345   Up to ten parameters are used; we use the braces round the name+args
2346   like the saslauthd condition does, to permit a variable number of args.
2347   See also the expansion-item version EITEM_ACL and the traditional
2348   acl modifier ACLC_ACL.
2349   Since the ACL may allocate new global variables, tell our caller to not
2350   reclaim memory.
2351   */
2352
2353   case ECOND_ACL:
2354     /* ${if acl {{name}{arg1}{arg2}...}  {yes}{no}} */
2355     {
2356     uschar *sub[10];
2357     uschar *user_msg;
2358     BOOL cond = FALSE;
2359     int size = 0;
2360     int ptr = 0;
2361
2362     while (isspace(*s)) s++;
2363     if (*s++ != '{') goto COND_FAILED_CURLY_START;      /*}*/
2364
2365     switch(read_subs(sub, nelem(sub), 1,
2366       &s, yield == NULL, TRUE, US"acl", resetok))
2367       {
2368       case 1: expand_string_message = US"too few arguments or bracketing "
2369         "error for acl";
2370       case 2:
2371       case 3: return NULL;
2372       }
2373
2374     *resetok = FALSE;   /* eval_acl() might allocate; do not reclaim */
2375     if (yield != NULL) switch(eval_acl(sub, nelem(sub), &user_msg))
2376         {
2377         case OK:
2378           cond = TRUE;
2379         case FAIL:
2380           lookup_value = NULL;
2381           if (user_msg)
2382             {
2383             lookup_value = string_cat(NULL, &size, &ptr, user_msg);
2384             lookup_value[ptr] = '\0';
2385             }
2386           *yield = cond == testfor;
2387           break;
2388
2389         case DEFER:
2390           expand_string_forcedfail = TRUE;
2391           /*FALLTHROUGH*/
2392         default:
2393           expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
2394           return NULL;
2395         }
2396     return s;
2397     }
2398
2399
2400   /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
2401
2402      ${if saslauthd {{username}{password}{service}{realm}}  {yes}{no}}
2403
2404   However, the last two are optional. That is why the whole set is enclosed
2405   in their own set of braces. */
2406
2407   case ECOND_SASLAUTHD:
2408 #ifndef CYRUS_SASLAUTHD_SOCKET
2409     goto COND_FAILED_NOT_COMPILED;
2410 #else
2411     {
2412     uschar *sub[4];
2413     while (isspace(*s)) s++;
2414     if (*s++ != '{') goto COND_FAILED_CURLY_START;      /* }-for-text-editors */
2415     switch(read_subs(sub, nelem(sub), 2, &s, yield == NULL, TRUE, US"saslauthd",
2416                     resetok))
2417       {
2418       case 1: expand_string_message = US"too few arguments or bracketing "
2419         "error for saslauthd";
2420       case 2:
2421       case 3: return NULL;
2422       }
2423     if (sub[2] == NULL) sub[3] = NULL;  /* realm if no service */
2424     if (yield != NULL)
2425       {
2426       int rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
2427         &expand_string_message);
2428       if (rc == ERROR || rc == DEFER) return NULL;
2429       *yield = (rc == OK) == testfor;
2430       }
2431     return s;
2432     }
2433 #endif /* CYRUS_SASLAUTHD_SOCKET */
2434
2435
2436   /* symbolic operators for numeric and string comparison, and a number of
2437   other operators, all requiring two arguments.
2438
2439   crypteq:           encrypts plaintext and compares against an encrypted text,
2440                        using crypt(), crypt16(), MD5 or SHA-1
2441   inlist/inlisti:    checks if first argument is in the list of the second
2442   match:             does a regular expression match and sets up the numerical
2443                        variables if it succeeds
2444   match_address:     matches in an address list
2445   match_domain:      matches in a domain list
2446   match_ip:          matches a host list that is restricted to IP addresses
2447   match_local_part:  matches in a local part list
2448   */
2449
2450   case ECOND_MATCH_ADDRESS:
2451   case ECOND_MATCH_DOMAIN:
2452   case ECOND_MATCH_IP:
2453   case ECOND_MATCH_LOCAL_PART:
2454 #ifndef EXPAND_LISTMATCH_RHS
2455     sub2_honour_dollar = FALSE;
2456 #endif
2457     /* FALLTHROUGH */
2458
2459   case ECOND_CRYPTEQ:
2460   case ECOND_INLIST:
2461   case ECOND_INLISTI:
2462   case ECOND_MATCH:
2463
2464   case ECOND_NUM_L:     /* Numerical comparisons */
2465   case ECOND_NUM_LE:
2466   case ECOND_NUM_E:
2467   case ECOND_NUM_EE:
2468   case ECOND_NUM_G:
2469   case ECOND_NUM_GE:
2470
2471   case ECOND_STR_LT:    /* String comparisons */
2472   case ECOND_STR_LTI:
2473   case ECOND_STR_LE:
2474   case ECOND_STR_LEI:
2475   case ECOND_STR_EQ:
2476   case ECOND_STR_EQI:
2477   case ECOND_STR_GT:
2478   case ECOND_STR_GTI:
2479   case ECOND_STR_GE:
2480   case ECOND_STR_GEI:
2481
2482   for (i = 0; i < 2; i++)
2483     {
2484     /* Sometimes, we don't expand substrings; too many insecure configurations
2485     created using match_address{}{} and friends, where the second param
2486     includes information from untrustworthy sources. */
2487     BOOL honour_dollar = TRUE;
2488     if ((i > 0) && !sub2_honour_dollar)
2489       honour_dollar = FALSE;
2490
2491     while (isspace(*s)) s++;
2492     if (*s != '{')
2493       {
2494       if (i == 0) goto COND_FAILED_CURLY_START;
2495       expand_string_message = string_sprintf("missing 2nd string in {} "
2496         "after \"%s\"", name);
2497       return NULL;
2498       }
2499     sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL,
2500         honour_dollar, resetok);
2501     if (sub[i] == NULL) return NULL;
2502     if (*s++ != '}') goto COND_FAILED_CURLY_END;
2503
2504     /* Convert to numerical if required; we know that the names of all the
2505     conditions that compare numbers do not start with a letter. This just saves
2506     checking for them individually. */
2507
2508     if (!isalpha(name[0]) && yield != NULL)
2509       if (sub[i][0] == 0)
2510         {
2511         num[i] = 0;
2512         DEBUG(D_expand)
2513           debug_printf("empty string cast to zero for numerical comparison\n");
2514         }
2515       else
2516         {
2517         num[i] = expanded_string_integer(sub[i], FALSE);
2518         if (expand_string_message != NULL) return NULL;
2519         }
2520     }
2521
2522   /* Result not required */
2523
2524   if (yield == NULL) return s;
2525
2526   /* Do an appropriate comparison */
2527
2528   switch(cond_type)
2529     {
2530     case ECOND_NUM_E:
2531     case ECOND_NUM_EE:
2532     tempcond = (num[0] == num[1]);
2533     break;
2534
2535     case ECOND_NUM_G:
2536     tempcond = (num[0] > num[1]);
2537     break;
2538
2539     case ECOND_NUM_GE:
2540     tempcond = (num[0] >= num[1]);
2541     break;
2542
2543     case ECOND_NUM_L:
2544     tempcond = (num[0] < num[1]);
2545     break;
2546
2547     case ECOND_NUM_LE:
2548     tempcond = (num[0] <= num[1]);
2549     break;
2550
2551     case ECOND_STR_LT:
2552     tempcond = (Ustrcmp(sub[0], sub[1]) < 0);
2553     break;
2554
2555     case ECOND_STR_LTI:
2556     tempcond = (strcmpic(sub[0], sub[1]) < 0);
2557     break;
2558
2559     case ECOND_STR_LE:
2560     tempcond = (Ustrcmp(sub[0], sub[1]) <= 0);
2561     break;
2562
2563     case ECOND_STR_LEI:
2564     tempcond = (strcmpic(sub[0], sub[1]) <= 0);
2565     break;
2566
2567     case ECOND_STR_EQ:
2568     tempcond = (Ustrcmp(sub[0], sub[1]) == 0);
2569     break;
2570
2571     case ECOND_STR_EQI:
2572     tempcond = (strcmpic(sub[0], sub[1]) == 0);
2573     break;
2574
2575     case ECOND_STR_GT:
2576     tempcond = (Ustrcmp(sub[0], sub[1]) > 0);
2577     break;
2578
2579     case ECOND_STR_GTI:
2580     tempcond = (strcmpic(sub[0], sub[1]) > 0);
2581     break;
2582
2583     case ECOND_STR_GE:
2584     tempcond = (Ustrcmp(sub[0], sub[1]) >= 0);
2585     break;
2586
2587     case ECOND_STR_GEI:
2588     tempcond = (strcmpic(sub[0], sub[1]) >= 0);
2589     break;
2590
2591     case ECOND_MATCH:   /* Regular expression match */
2592     re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
2593       NULL);
2594     if (re == NULL)
2595       {
2596       expand_string_message = string_sprintf("regular expression error in "
2597         "\"%s\": %s at offset %d", sub[1], rerror, roffset);
2598       return NULL;
2599       }
2600     tempcond = regex_match_and_setup(re, sub[0], 0, -1);
2601     break;
2602
2603     case ECOND_MATCH_ADDRESS:  /* Match in an address list */
2604     rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
2605     goto MATCHED_SOMETHING;
2606
2607     case ECOND_MATCH_DOMAIN:   /* Match in a domain list */
2608     rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
2609       MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
2610     goto MATCHED_SOMETHING;
2611
2612     case ECOND_MATCH_IP:       /* Match IP address in a host list */
2613     if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
2614       {
2615       expand_string_message = string_sprintf("\"%s\" is not an IP address",
2616         sub[0]);
2617       return NULL;
2618       }
2619     else
2620       {
2621       unsigned int *nullcache = NULL;
2622       check_host_block cb;
2623
2624       cb.host_name = US"";
2625       cb.host_address = sub[0];
2626
2627       /* If the host address starts off ::ffff: it is an IPv6 address in
2628       IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2629       addresses. */
2630
2631       cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2632         cb.host_address + 7 : cb.host_address;
2633
2634       rc = match_check_list(
2635              &sub[1],                   /* the list */
2636              0,                         /* separator character */
2637              &hostlist_anchor,          /* anchor pointer */
2638              &nullcache,                /* cache pointer */
2639              check_host,                /* function for testing */
2640              &cb,                       /* argument for function */
2641              MCL_HOST,                  /* type of check */
2642              sub[0],                    /* text for debugging */
2643              NULL);                     /* where to pass back data */
2644       }
2645     goto MATCHED_SOMETHING;
2646
2647     case ECOND_MATCH_LOCAL_PART:
2648     rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
2649       MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
2650     /* Fall through */
2651     /* VVVVVVVVVVVV */
2652     MATCHED_SOMETHING:
2653     switch(rc)
2654       {
2655       case OK:
2656       tempcond = TRUE;
2657       break;
2658
2659       case FAIL:
2660       tempcond = FALSE;
2661       break;
2662
2663       case DEFER:
2664       expand_string_message = string_sprintf("unable to complete match "
2665         "against \"%s\": %s", sub[1], search_error_message);
2666       return NULL;
2667       }
2668
2669     break;
2670
2671     /* Various "encrypted" comparisons. If the second string starts with
2672     "{" then an encryption type is given. Default to crypt() or crypt16()
2673     (build-time choice). */
2674     /* }-for-text-editors */
2675
2676     case ECOND_CRYPTEQ:
2677     #ifndef SUPPORT_CRYPTEQ
2678     goto COND_FAILED_NOT_COMPILED;
2679     #else
2680     if (strncmpic(sub[1], US"{md5}", 5) == 0)
2681       {
2682       int sublen = Ustrlen(sub[1]+5);
2683       md5 base;
2684       uschar digest[16];
2685
2686       md5_start(&base);
2687       md5_end(&base, sub[0], Ustrlen(sub[0]), digest);
2688
2689       /* If the length that we are comparing against is 24, the MD5 digest
2690       is expressed as a base64 string. This is the way LDAP does it. However,
2691       some other software uses a straightforward hex representation. We assume
2692       this if the length is 32. Other lengths fail. */
2693
2694       if (sublen == 24)
2695         {
2696         uschar *coded = b64encode(digest, 16);
2697         DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2698           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2699         tempcond = (Ustrcmp(coded, sub[1]+5) == 0);
2700         }
2701       else if (sublen == 32)
2702         {
2703         int i;
2704         uschar coded[36];
2705         for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2706         coded[32] = 0;
2707         DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2708           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2709         tempcond = (strcmpic(coded, sub[1]+5) == 0);
2710         }
2711       else
2712         {
2713         DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2714           "fail\n  crypted=%s\n", sub[1]+5);
2715         tempcond = FALSE;
2716         }
2717       }
2718
2719     else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2720       {
2721       int sublen = Ustrlen(sub[1]+6);
2722       hctx h;
2723       uschar digest[20];
2724
2725       sha1_start(&h);
2726       sha1_end(&h, sub[0], Ustrlen(sub[0]), digest);
2727
2728       /* If the length that we are comparing against is 28, assume the SHA1
2729       digest is expressed as a base64 string. If the length is 40, assume a
2730       straightforward hex representation. Other lengths fail. */
2731
2732       if (sublen == 28)
2733         {
2734         uschar *coded = b64encode(digest, 20);
2735         DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2736           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2737         tempcond = (Ustrcmp(coded, sub[1]+6) == 0);
2738         }
2739       else if (sublen == 40)
2740         {
2741         int i;
2742         uschar coded[44];
2743         for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2744         coded[40] = 0;
2745         DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2746           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2747         tempcond = (strcmpic(coded, sub[1]+6) == 0);
2748         }
2749       else
2750         {
2751         DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2752           "fail\n  crypted=%s\n", sub[1]+6);
2753         tempcond = FALSE;
2754         }
2755       }
2756
2757     else   /* {crypt} or {crypt16} and non-{ at start */
2758            /* }-for-text-editors */
2759       {
2760       int which = 0;
2761       uschar *coded;
2762
2763       if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2764         {
2765         sub[1] += 7;
2766         which = 1;
2767         }
2768       else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2769         {
2770         sub[1] += 9;
2771         which = 2;
2772         }
2773       else if (sub[1][0] == '{')                /* }-for-text-editors */
2774         {
2775         expand_string_message = string_sprintf("unknown encryption mechanism "
2776           "in \"%s\"", sub[1]);
2777         return NULL;
2778         }
2779
2780       switch(which)
2781         {
2782         case 0:  coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2783         case 1:  coded = US crypt(CS sub[0], CS sub[1]); break;
2784         default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2785         }
2786
2787       #define STR(s) # s
2788       #define XSTR(s) STR(s)
2789       DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2790         "  subject=%s\n  crypted=%s\n",
2791         which == 0 ? XSTR(DEFAULT_CRYPT) : which == 1 ? "crypt" : "crypt16",
2792         coded, sub[1]);
2793       #undef STR
2794       #undef XSTR
2795
2796       /* If the encrypted string contains fewer than two characters (for the
2797       salt), force failure. Otherwise we get false positives: with an empty
2798       string the yield of crypt() is an empty string! */
2799
2800       if (coded)
2801         tempcond = Ustrlen(sub[1]) < 2 ? FALSE : Ustrcmp(coded, sub[1]) == 0;
2802       else if (errno == EINVAL)
2803         tempcond = FALSE;
2804       else
2805         {
2806         expand_string_message = string_sprintf("crypt error: %s\n",
2807           US strerror(errno));
2808         return NULL;
2809         }
2810       }
2811     break;
2812     #endif  /* SUPPORT_CRYPTEQ */
2813
2814     case ECOND_INLIST:
2815     case ECOND_INLISTI:
2816       {
2817       const uschar * list = sub[1];
2818       int sep = 0;
2819       uschar *save_iterate_item = iterate_item;
2820       int (*compare)(const uschar *, const uschar *);
2821
2822       DEBUG(D_expand) debug_printf("condition: %s\n", name);
2823
2824       tempcond = FALSE;
2825       compare = cond_type == ECOND_INLISTI
2826         ? strcmpic : (int (*)(const uschar *, const uschar *)) strcmp;
2827
2828       while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
2829         if (compare(sub[0], iterate_item) == 0)
2830           {
2831           tempcond = TRUE;
2832           break;
2833           }
2834       iterate_item = save_iterate_item;
2835       }
2836
2837     }   /* Switch for comparison conditions */
2838
2839   *yield = tempcond == testfor;
2840   return s;    /* End of comparison conditions */
2841
2842
2843   /* and/or: computes logical and/or of several conditions */
2844
2845   case ECOND_AND:
2846   case ECOND_OR:
2847   subcondptr = (yield == NULL)? NULL : &tempcond;
2848   combined_cond = (cond_type == ECOND_AND);
2849
2850   while (isspace(*s)) s++;
2851   if (*s++ != '{') goto COND_FAILED_CURLY_START;        /* }-for-text-editors */
2852
2853   for (;;)
2854     {
2855     while (isspace(*s)) s++;
2856     /* {-for-text-editors */
2857     if (*s == '}') break;
2858     if (*s != '{')                                      /* }-for-text-editors */
2859       {
2860       expand_string_message = string_sprintf("each subcondition "
2861         "inside an \"%s{...}\" condition must be in its own {}", name);
2862       return NULL;
2863       }
2864
2865     if (!(s = eval_condition(s+1, resetok, subcondptr)))
2866       {
2867       expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2868         expand_string_message, name);
2869       return NULL;
2870       }
2871     while (isspace(*s)) s++;
2872
2873     /* {-for-text-editors */
2874     if (*s++ != '}')
2875       {
2876       /* {-for-text-editors */
2877       expand_string_message = string_sprintf("missing } at end of condition "
2878         "inside \"%s\" group", name);
2879       return NULL;
2880       }
2881
2882     if (yield != NULL)
2883       {
2884       if (cond_type == ECOND_AND)
2885         {
2886         combined_cond &= tempcond;
2887         if (!combined_cond) subcondptr = NULL;  /* once false, don't */
2888         }                                       /* evaluate any more */
2889       else
2890         {
2891         combined_cond |= tempcond;
2892         if (combined_cond) subcondptr = NULL;   /* once true, don't */
2893         }                                       /* evaluate any more */
2894       }
2895     }
2896
2897   if (yield != NULL) *yield = (combined_cond == testfor);
2898   return ++s;
2899
2900
2901   /* forall/forany: iterates a condition with different values */
2902
2903   case ECOND_FORALL:
2904   case ECOND_FORANY:
2905     {
2906     const uschar * list;
2907     int sep = 0;
2908     uschar *save_iterate_item = iterate_item;
2909
2910     DEBUG(D_expand) debug_printf("condition: %s\n", name);
2911
2912     while (isspace(*s)) s++;
2913     if (*s++ != '{') goto COND_FAILED_CURLY_START;      /* }-for-text-editors */
2914     sub[0] = expand_string_internal(s, TRUE, &s, (yield == NULL), TRUE, resetok);
2915     if (sub[0] == NULL) return NULL;
2916     /* {-for-text-editors */
2917     if (*s++ != '}') goto COND_FAILED_CURLY_END;
2918
2919     while (isspace(*s)) s++;
2920     if (*s++ != '{') goto COND_FAILED_CURLY_START;      /* }-for-text-editors */
2921
2922     sub[1] = s;
2923
2924     /* Call eval_condition once, with result discarded (as if scanning a
2925     "false" part). This allows us to find the end of the condition, because if
2926     the list it empty, we won't actually evaluate the condition for real. */
2927
2928     if (!(s = eval_condition(sub[1], resetok, NULL)))
2929       {
2930       expand_string_message = string_sprintf("%s inside \"%s\" condition",
2931         expand_string_message, name);
2932       return NULL;
2933       }
2934     while (isspace(*s)) s++;
2935
2936     /* {-for-text-editors */
2937     if (*s++ != '}')
2938       {
2939       /* {-for-text-editors */
2940       expand_string_message = string_sprintf("missing } at end of condition "
2941         "inside \"%s\"", name);
2942       return NULL;
2943       }
2944
2945     if (yield != NULL) *yield = !testfor;
2946     list = sub[0];
2947     while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
2948       {
2949       DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
2950       if (!eval_condition(sub[1], resetok, &tempcond))
2951         {
2952         expand_string_message = string_sprintf("%s inside \"%s\" condition",
2953           expand_string_message, name);
2954         iterate_item = save_iterate_item;
2955         return NULL;
2956         }
2957       DEBUG(D_expand) debug_printf("%s: condition evaluated to %s\n", name,
2958         tempcond? "true":"false");
2959
2960       if (yield != NULL) *yield = (tempcond == testfor);
2961       if (tempcond == (cond_type == ECOND_FORANY)) break;
2962       }
2963
2964     iterate_item = save_iterate_item;
2965     return s;
2966     }
2967
2968
2969   /* The bool{} expansion condition maps a string to boolean.
2970   The values supported should match those supported by the ACL condition
2971   (acl.c, ACLC_CONDITION) so that we keep to a minimum the different ideas
2972   of true/false.  Note that Router "condition" rules have a different
2973   interpretation, where general data can be used and only a few values
2974   map to FALSE.
2975   Note that readconf.c boolean matching, for boolean configuration options,
2976   only matches true/yes/false/no.
2977   The bool_lax{} condition matches the Router logic, which is much more
2978   liberal. */
2979   case ECOND_BOOL:
2980   case ECOND_BOOL_LAX:
2981     {
2982     uschar *sub_arg[1];
2983     uschar *t, *t2;
2984     uschar *ourname;
2985     size_t len;
2986     BOOL boolvalue = FALSE;
2987     while (isspace(*s)) s++;
2988     if (*s != '{') goto COND_FAILED_CURLY_START;        /* }-for-text-editors */
2989     ourname = cond_type == ECOND_BOOL_LAX ? US"bool_lax" : US"bool";
2990     switch(read_subs(sub_arg, 1, 1, &s, yield == NULL, FALSE, ourname, resetok))
2991       {
2992       case 1: expand_string_message = string_sprintf(
2993                   "too few arguments or bracketing error for %s",
2994                   ourname);
2995       /*FALLTHROUGH*/
2996       case 2:
2997       case 3: return NULL;
2998       }
2999     t = sub_arg[0];
3000     while (isspace(*t)) t++;
3001     len = Ustrlen(t);
3002     if (len)
3003       {
3004       /* trailing whitespace: seems like a good idea to ignore it too */
3005       t2 = t + len - 1;
3006       while (isspace(*t2)) t2--;
3007       if (t2 != (t + len))
3008         {
3009         *++t2 = '\0';
3010         len = t2 - t;
3011         }
3012       }
3013     DEBUG(D_expand)
3014       debug_printf("considering %s: %s\n", ourname, len ? t : US"<empty>");
3015     /* logic for the lax case from expand_check_condition(), which also does
3016     expands, and the logic is both short and stable enough that there should
3017     be no maintenance burden from replicating it. */
3018     if (len == 0)
3019       boolvalue = FALSE;
3020     else if (*t == '-'
3021              ? Ustrspn(t+1, "0123456789") == len-1
3022              : Ustrspn(t,   "0123456789") == len)
3023       {
3024       boolvalue = (Uatoi(t) == 0) ? FALSE : TRUE;
3025       /* expand_check_condition only does a literal string "0" check */
3026       if ((cond_type == ECOND_BOOL_LAX) && (len > 1))
3027         boolvalue = TRUE;
3028       }
3029     else if (strcmpic(t, US"true") == 0 || strcmpic(t, US"yes") == 0)
3030       boolvalue = TRUE;
3031     else if (strcmpic(t, US"false") == 0 || strcmpic(t, US"no") == 0)
3032       boolvalue = FALSE;
3033     else if (cond_type == ECOND_BOOL_LAX)
3034       boolvalue = TRUE;
3035     else
3036       {
3037       expand_string_message = string_sprintf("unrecognised boolean "
3038        "value \"%s\"", t);
3039       return NULL;
3040       }
3041     if (yield != NULL) *yield = (boolvalue == testfor);
3042     return s;
3043     }
3044
3045   /* Unknown condition */
3046
3047   default:
3048   expand_string_message = string_sprintf("unknown condition \"%s\"", name);
3049   return NULL;
3050   }   /* End switch on condition type */
3051
3052 /* Missing braces at start and end of data */
3053
3054 COND_FAILED_CURLY_START:
3055 expand_string_message = string_sprintf("missing { after \"%s\"", name);
3056 return NULL;
3057
3058 COND_FAILED_CURLY_END:
3059 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
3060   name);
3061 return NULL;
3062
3063 /* A condition requires code that is not compiled */
3064
3065 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
3066     !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
3067     !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
3068 COND_FAILED_NOT_COMPILED:
3069 expand_string_message = string_sprintf("support for \"%s\" not compiled",
3070   name);
3071 return NULL;
3072 #endif
3073 }
3074
3075
3076
3077
3078 /*************************************************
3079 *          Save numerical variables              *
3080 *************************************************/
3081
3082 /* This function is called from items such as "if" that want to preserve and
3083 restore the numbered variables.
3084
3085 Arguments:
3086   save_expand_string    points to an array of pointers to set
3087   save_expand_nlength   points to an array of ints for the lengths
3088
3089 Returns:                the value of expand max to save
3090 */
3091
3092 static int
3093 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
3094 {
3095 int i;
3096 for (i = 0; i <= expand_nmax; i++)
3097   {
3098   save_expand_nstring[i] = expand_nstring[i];
3099   save_expand_nlength[i] = expand_nlength[i];
3100   }
3101 return expand_nmax;
3102 }
3103
3104
3105
3106 /*************************************************
3107 *           Restore numerical variables          *
3108 *************************************************/
3109
3110 /* This function restored saved values of numerical strings.
3111
3112 Arguments:
3113   save_expand_nmax      the number of strings to restore
3114   save_expand_string    points to an array of pointers
3115   save_expand_nlength   points to an array of ints
3116
3117 Returns:                nothing
3118 */
3119
3120 static void
3121 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
3122   int *save_expand_nlength)
3123 {
3124 int i;
3125 expand_nmax = save_expand_nmax;
3126 for (i = 0; i <= expand_nmax; i++)
3127   {
3128   expand_nstring[i] = save_expand_nstring[i];
3129   expand_nlength[i] = save_expand_nlength[i];
3130   }
3131 }
3132
3133
3134
3135
3136
3137 /*************************************************
3138 *            Handle yes/no substrings            *
3139 *************************************************/
3140
3141 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
3142 alternative substrings that depend on whether or not the condition was true,
3143 or the lookup or extraction succeeded. The substrings always have to be
3144 expanded, to check their syntax, but "skipping" is set when the result is not
3145 needed - this avoids unnecessary nested lookups.
3146
3147 Arguments:
3148   skipping       TRUE if we were skipping when this item was reached
3149   yes            TRUE if the first string is to be used, else use the second
3150   save_lookup    a value to put back into lookup_value before the 2nd expansion
3151   sptr           points to the input string pointer
3152   yieldptr       points to the output string pointer
3153   sizeptr        points to the output string size
3154   ptrptr         points to the output string pointer
3155   type           "lookup", "if", "extract", "run", "env", "listextract" or
3156                  "certextract" for error message
3157   resetok        if not NULL, pointer to flag - write FALSE if unsafe to reset
3158                 the store.
3159
3160 Returns:         0 OK; lookup_value has been reset to save_lookup
3161                  1 expansion failed
3162                  2 expansion failed because of bracketing error
3163 */
3164
3165 static int
3166 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, const uschar **sptr,
3167   uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type, BOOL *resetok)
3168 {
3169 int rc = 0;
3170 const uschar *s = *sptr;    /* Local value */
3171 uschar *sub1, *sub2;
3172 const uschar * errwhere;
3173
3174 /* If there are no following strings, we substitute the contents of $value for
3175 lookups and for extractions in the success case. For the ${if item, the string
3176 "true" is substituted. In the fail case, nothing is substituted for all three
3177 items. */
3178
3179 while (isspace(*s)) s++;
3180 if (*s == '}')
3181   {
3182   if (type[0] == 'i')
3183     {
3184     if (yes) *yieldptr = string_catn(*yieldptr, sizeptr, ptrptr, US"true", 4);
3185     }
3186   else
3187     {
3188     if (yes && lookup_value)
3189       *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value);
3190     lookup_value = save_lookup;
3191     }
3192   s++;
3193   goto RETURN;
3194   }
3195
3196 /* The first following string must be braced. */
3197
3198 if (*s++ != '{')
3199   {
3200   errwhere = US"'yes' part did not start with '{'";
3201   goto FAILED_CURLY;
3202   }
3203
3204 /* Expand the first substring. Forced failures are noticed only if we actually
3205 want this string. Set skipping in the call in the fail case (this will always
3206 be the case if we were already skipping). */
3207
3208 sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
3209 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
3210 expand_string_forcedfail = FALSE;
3211 if (*s++ != '}')
3212   {
3213   errwhere = US"'yes' part did not end with '}'";
3214   goto FAILED_CURLY;
3215   }
3216
3217 /* If we want the first string, add it to the output */
3218
3219 if (yes)
3220   *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1);
3221
3222 /* If this is called from a lookup/env or a (cert)extract, we want to restore
3223 $value to what it was at the start of the item, so that it has this value
3224 during the second string expansion. For the call from "if" or "run" to this
3225 function, save_lookup is set to lookup_value, so that this statement does
3226 nothing. */
3227
3228 lookup_value = save_lookup;
3229
3230 /* There now follows either another substring, or "fail", or nothing. This
3231 time, forced failures are noticed only if we want the second string. We must
3232 set skipping in the nested call if we don't want this string, or if we were
3233 already skipping. */
3234
3235 while (isspace(*s)) s++;
3236 if (*s == '{')
3237   {
3238   sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
3239   if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
3240   expand_string_forcedfail = FALSE;
3241   if (*s++ != '}')
3242     {
3243     errwhere = US"'no' part did not start with '{'";
3244     goto FAILED_CURLY;
3245     }
3246
3247   /* If we want the second string, add it to the output */
3248
3249   if (!yes)
3250     *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2);
3251   }
3252
3253 /* If there is no second string, but the word "fail" is present when the use of
3254 the second string is wanted, set a flag indicating it was a forced failure
3255 rather than a syntactic error. Swallow the terminating } in case this is nested
3256 inside another lookup or if or extract. */
3257
3258 else if (*s != '}')
3259   {
3260   uschar name[256];
3261   /* deconst cast ok here as source is s anyway */
3262   s = US read_name(name, sizeof(name), s, US"_");
3263   if (Ustrcmp(name, "fail") == 0)
3264     {
3265     if (!yes && !skipping)
3266       {
3267       while (isspace(*s)) s++;
3268       if (*s++ != '}')
3269         {
3270         errwhere = US"did not close with '}' after forcedfail";
3271         goto FAILED_CURLY;
3272         }
3273       expand_string_message =
3274         string_sprintf("\"%s\" failed and \"fail\" requested", type);
3275       expand_string_forcedfail = TRUE;
3276       goto FAILED;
3277       }
3278     }
3279   else
3280     {
3281     expand_string_message =
3282       string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
3283     goto FAILED;
3284     }
3285   }
3286
3287 /* All we have to do now is to check on the final closing brace. */
3288
3289 while (isspace(*s)) s++;
3290 if (*s++ != '}')
3291   {
3292   errwhere = US"did not close with '}'";
3293   goto FAILED_CURLY;
3294   }
3295
3296
3297 RETURN:
3298 /* Update the input pointer value before returning */
3299 *sptr = s;
3300 return rc;
3301
3302 FAILED_CURLY:
3303   /* Get here if there is a bracketing failure */
3304   expand_string_message = string_sprintf(
3305     "curly-bracket problem in conditional yes/no parsing: %s\n"
3306     " remaining string is '%s'", errwhere, --s);
3307   rc = 2;
3308   goto RETURN;
3309
3310 FAILED:
3311   /* Get here for other failures */
3312   rc = 1;
3313   goto RETURN;
3314 }
3315
3316
3317
3318
3319 /*************************************************
3320 *    Handle MD5 or SHA-1 computation for HMAC    *
3321 *************************************************/
3322
3323 /* These are some wrapping functions that enable the HMAC code to be a bit
3324 cleaner. A good compiler will spot the tail recursion.
3325
3326 Arguments:
3327   type         HMAC_MD5 or HMAC_SHA1
3328   remaining    are as for the cryptographic hash functions
3329
3330 Returns:       nothing
3331 */
3332
3333 static void
3334 chash_start(int type, void *base)
3335 {
3336 if (type == HMAC_MD5)
3337   md5_start((md5 *)base);
3338 else
3339   sha1_start((hctx *)base);
3340 }
3341
3342 static void
3343 chash_mid(int type, void *base, uschar *string)
3344 {
3345 if (type == HMAC_MD5)
3346   md5_mid((md5 *)base, string);
3347 else
3348   sha1_mid((hctx *)base, string);
3349 }
3350
3351 static void
3352 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
3353 {
3354 if (type == HMAC_MD5)
3355   md5_end((md5 *)base, string, length, digest);
3356 else
3357   sha1_end((hctx *)base, string, length, digest);
3358 }
3359
3360
3361
3362
3363
3364 /********************************************************
3365 * prvs: Get last three digits of days since Jan 1, 1970 *
3366 ********************************************************/
3367
3368 /* This is needed to implement the "prvs" BATV reverse
3369    path signing scheme
3370
3371 Argument: integer "days" offset to add or substract to
3372           or from the current number of days.
3373
3374 Returns:  pointer to string containing the last three
3375           digits of the number of days since Jan 1, 1970,
3376           modified by the offset argument, NULL if there
3377           was an error in the conversion.
3378
3379 */
3380
3381 static uschar *
3382 prvs_daystamp(int day_offset)
3383 {
3384 uschar *days = store_get(32);                /* Need at least 24 for cases */
3385 (void)string_format(days, 32, TIME_T_FMT,    /* where TIME_T_FMT is %lld */
3386   (time(NULL) + day_offset*86400)/86400);
3387 return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
3388 }
3389
3390
3391
3392 /********************************************************
3393 *   prvs: perform HMAC-SHA1 computation of prvs bits    *
3394 ********************************************************/
3395
3396 /* This is needed to implement the "prvs" BATV reverse
3397    path signing scheme
3398
3399 Arguments:
3400   address RFC2821 Address to use
3401       key The key to use (must be less than 64 characters
3402           in size)
3403   key_num Single-digit key number to use. Defaults to
3404           '0' when NULL.
3405
3406 Returns:  pointer to string containing the first three
3407           bytes of the final hash in hex format, NULL if
3408           there was an error in the process.
3409 */
3410
3411 static uschar *
3412 prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
3413 {
3414 uschar *hash_source, *p;
3415 int size = 0,offset = 0,i;
3416 hctx h;
3417 uschar innerhash[20];
3418 uschar finalhash[20];
3419 uschar innerkey[64];
3420 uschar outerkey[64];
3421 uschar *finalhash_hex = store_get(40);
3422
3423 if (key_num == NULL)
3424   key_num = US"0";
3425
3426 if (Ustrlen(key) > 64)
3427   return NULL;
3428
3429 hash_source = string_catn(NULL, &size, &offset, key_num, 1);
3430 hash_source = string_catn(hash_source, &size, &offset, daystamp, 3);
3431 hash_source = string_cat(hash_source, &size, &offset, address);
3432 hash_source[offset] = '\0';
3433
3434 DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
3435
3436 memset(innerkey, 0x36, 64);
3437 memset(outerkey, 0x5c, 64);
3438
3439 for (i = 0; i < Ustrlen(key); i++)
3440   {
3441   innerkey[i] ^= key[i];
3442   outerkey[i] ^= key[i];
3443   }
3444
3445 chash_start(HMAC_SHA1, &h);
3446 chash_mid(HMAC_SHA1, &h, innerkey);
3447 chash_end(HMAC_SHA1, &h, hash_source, offset, innerhash);
3448
3449 chash_start(HMAC_SHA1, &h);
3450 chash_mid(HMAC_SHA1, &h, outerkey);
3451 chash_end(HMAC_SHA1, &h, innerhash, 20, finalhash);
3452
3453 p = finalhash_hex;
3454 for (i = 0; i < 3; i++)
3455   {
3456   *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
3457   *p++ = hex_digits[finalhash[i] & 0x0f];
3458   }
3459 *p = '\0';
3460
3461 return finalhash_hex;
3462 }
3463
3464
3465
3466
3467 /*************************************************
3468 *        Join a file onto the output string      *
3469 *************************************************/
3470
3471 /* This is used for readfile/readsock and after a run expansion.
3472 It joins the contents of a file onto the output string, globally replacing
3473 newlines with a given string (optionally).
3474
3475 Arguments:
3476   f            the FILE
3477   yield        pointer to the expandable string
3478   sizep        pointer to the current size
3479   ptrp         pointer to the current position
3480   eol          newline replacement string, or NULL
3481
3482 Returns:       new value of string pointer
3483 */
3484
3485 static uschar *
3486 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
3487 {
3488 int eollen = eol ? Ustrlen(eol) : 0;
3489 uschar buffer[1024];
3490
3491 while (Ufgets(buffer, sizeof(buffer), f))
3492   {
3493   int len = Ustrlen(buffer);
3494   if (eol && buffer[len-1] == '\n') len--;
3495   yield = string_catn(yield, sizep, ptrp, buffer, len);
3496   if (buffer[len] != 0)
3497     yield = string_catn(yield, sizep, ptrp, eol, eollen);
3498   }
3499
3500 if (yield) yield[*ptrp] = 0;
3501
3502 return yield;
3503 }
3504
3505
3506
3507
3508 /*************************************************
3509 *          Evaluate numeric expression           *
3510 *************************************************/
3511
3512 /* This is a set of mutually recursive functions that evaluate an arithmetic
3513 expression involving + - * / % & | ^ ~ << >> and parentheses. The only one of
3514 these functions that is called from elsewhere is eval_expr, whose interface is:
3515
3516 Arguments:
3517   sptr        pointer to the pointer to the string - gets updated
3518   decimal     TRUE if numbers are to be assumed decimal
3519   error       pointer to where to put an error message - must be NULL on input
3520   endket      TRUE if ')' must terminate - FALSE for external call
3521
3522 Returns:      on success: the value of the expression, with *error still NULL
3523               on failure: an undefined value, with *error = a message
3524 */
3525
3526 static int_eximarith_t eval_op_or(uschar **, BOOL, uschar **);
3527
3528
3529 static int_eximarith_t
3530 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
3531 {
3532 uschar *s = *sptr;
3533 int_eximarith_t x = eval_op_or(&s, decimal, error);
3534 if (*error == NULL)
3535   {
3536   if (endket)
3537     {
3538     if (*s != ')')
3539       *error = US"expecting closing parenthesis";
3540     else
3541       while (isspace(*(++s)));
3542     }
3543   else if (*s != 0) *error = US"expecting operator";
3544   }
3545 *sptr = s;
3546 return x;
3547 }
3548
3549
3550 static int_eximarith_t
3551 eval_number(uschar **sptr, BOOL decimal, uschar **error)
3552 {
3553 register int c;
3554 int_eximarith_t n;
3555 uschar *s = *sptr;
3556 while (isspace(*s)) s++;
3557 c = *s;
3558 if (isdigit(c))
3559   {
3560   int count;
3561   (void)sscanf(CS s, (decimal? SC_EXIM_DEC "%n" : SC_EXIM_ARITH "%n"), &n, &count);
3562   s += count;
3563   switch (tolower(*s))
3564     {
3565     default: break;
3566     case 'k': n *= 1024; s++; break;
3567     case 'm': n *= 1024*1024; s++; break;
3568     case 'g': n *= 1024*1024*1024; s++; break;
3569     }
3570   while (isspace (*s)) s++;
3571   }
3572 else if (c == '(')
3573   {
3574   s++;
3575   n = eval_expr(&s, decimal, error, 1);
3576   }
3577 else
3578   {
3579   *error = US"expecting number or opening parenthesis";
3580   n = 0;
3581   }
3582 *sptr = s;
3583 return n;
3584 }
3585
3586
3587 static int_eximarith_t
3588 eval_op_unary(uschar **sptr, BOOL decimal, uschar **error)
3589 {
3590 uschar *s = *sptr;
3591 int_eximarith_t x;
3592 while (isspace(*s)) s++;
3593 if (*s == '+' || *s == '-' || *s == '~')
3594   {
3595   int op = *s++;
3596   x = eval_op_unary(&s, decimal, error);
3597   if (op == '-') x = -x;
3598     else if (op == '~') x = ~x;
3599   }
3600 else
3601   {
3602   x = eval_number(&s, decimal, error);
3603   }
3604 *sptr = s;
3605 return x;
3606 }
3607
3608
3609 static int_eximarith_t
3610 eval_op_mult(uschar **sptr, BOOL decimal, uschar **error)
3611 {
3612 uschar *s = *sptr;
3613 int_eximarith_t x = eval_op_unary(&s, decimal, error);
3614 if (*error == NULL)
3615   {
3616   while (*s == '*' || *s == '/' || *s == '%')
3617     {
3618     int op = *s++;
3619     int_eximarith_t y = eval_op_unary(&s, decimal, error);
3620     if (*error != NULL) break;
3621     /* SIGFPE both on div/mod by zero and on INT_MIN / -1, which would give
3622      * a value of INT_MAX+1. Note that INT_MIN * -1 gives INT_MIN for me, which
3623      * is a bug somewhere in [gcc 4.2.1, FreeBSD, amd64].  In fact, -N*-M where
3624      * -N*M is INT_MIN will yielf INT_MIN.
3625      * Since we don't support floating point, this is somewhat simpler.
3626      * Ideally, we'd return an error, but since we overflow for all other
3627      * arithmetic, consistency suggests otherwise, but what's the correct value
3628      * to use?  There is none.
3629      * The C standard guarantees overflow for unsigned arithmetic but signed
3630      * overflow invokes undefined behaviour; in practice, this is overflow
3631      * except for converting INT_MIN to INT_MAX+1.  We also can't guarantee
3632      * that long/longlong larger than int are available, or we could just work
3633      * with larger types.  We should consider whether to guarantee 32bit eval
3634      * and 64-bit working variables, with errors returned.  For now ...
3635      * So, the only SIGFPEs occur with a non-shrinking div/mod, thus -1; we
3636      * can just let the other invalid results occur otherwise, as they have
3637      * until now.  For this one case, we can coerce.
3638      */
3639     if (y == -1 && x == EXIM_ARITH_MIN && op != '*')
3640       {
3641       DEBUG(D_expand)
3642         debug_printf("Integer exception dodging: " PR_EXIM_ARITH "%c-1 coerced to " PR_EXIM_ARITH "\n",
3643             EXIM_ARITH_MIN, op, EXIM_ARITH_MAX);
3644       x = EXIM_ARITH_MAX;
3645       continue;
3646       }
3647     if (op == '*')
3648       x *= y;
3649     else
3650       {
3651       if (y == 0)
3652         {
3653         *error = (op == '/') ? US"divide by zero" : US"modulo by zero";
3654         x = 0;
3655         break;
3656         }
3657       if (op == '/')
3658         x /= y;
3659       else
3660         x %= y;
3661       }
3662     }
3663   }
3664 *sptr = s;
3665 return x;
3666 }
3667
3668
3669 static int_eximarith_t
3670 eval_op_sum(uschar **sptr, BOOL decimal, uschar **error)
3671 {
3672 uschar *s = *sptr;
3673 int_eximarith_t x = eval_op_mult(&s, decimal, error);
3674 if (!*error)
3675   {
3676   while (*s == '+' || *s == '-')
3677     {
3678     int op = *s++;
3679     int_eximarith_t y = eval_op_mult(&s, decimal, error);
3680     if (*error) break;
3681     if (  (x >=   EXIM_ARITH_MAX/2  && x >=   EXIM_ARITH_MAX/2)
3682        || (x <= -(EXIM_ARITH_MAX/2) && y <= -(EXIM_ARITH_MAX/2)))
3683       {                 /* over-conservative check */
3684       *error = op == '+'
3685         ? US"overflow in sum" : US"overflow in difference";
3686       break;
3687       }
3688     if (op == '+') x += y; else x -= y;
3689     }
3690   }
3691 *sptr = s;
3692 return x;
3693 }
3694
3695
3696 static int_eximarith_t
3697 eval_op_shift(uschar **sptr, BOOL decimal, uschar **error)
3698 {
3699 uschar *s = *sptr;
3700 int_eximarith_t x = eval_op_sum(&s, decimal, error);
3701 if (*error == NULL)
3702   {
3703   while ((*s == '<' || *s == '>') && s[1] == s[0])
3704     {
3705     int_eximarith_t y;
3706     int op = *s++;
3707     s++;
3708     y = eval_op_sum(&s, decimal, error);
3709     if (*error != NULL) break;
3710     if (op == '<') x <<= y; else x >>= y;
3711     }
3712   }
3713 *sptr = s;
3714 return x;
3715 }
3716
3717
3718 static int_eximarith_t
3719 eval_op_and(uschar **sptr, BOOL decimal, uschar **error)
3720 {
3721 uschar *s = *sptr;
3722 int_eximarith_t x = eval_op_shift(&s, decimal, error);
3723 if (*error == NULL)
3724   {
3725   while (*s == '&')
3726     {
3727     int_eximarith_t y;
3728     s++;
3729     y = eval_op_shift(&s, decimal, error);
3730     if (*error != NULL) break;
3731     x &= y;
3732     }
3733   }
3734 *sptr = s;
3735 return x;
3736 }
3737
3738
3739 static int_eximarith_t
3740 eval_op_xor(uschar **sptr, BOOL decimal, uschar **error)
3741 {
3742 uschar *s = *sptr;
3743 int_eximarith_t x = eval_op_and(&s, decimal, error);
3744 if (*error == NULL)
3745   {
3746   while (*s == '^')
3747     {
3748     int_eximarith_t y;
3749     s++;
3750     y = eval_op_and(&s, decimal, error);
3751     if (*error != NULL) break;
3752     x ^= y;
3753     }
3754   }
3755 *sptr = s;
3756 return x;
3757 }
3758
3759
3760 static int_eximarith_t
3761 eval_op_or(uschar **sptr, BOOL decimal, uschar **error)
3762 {
3763 uschar *s = *sptr;
3764 int_eximarith_t x = eval_op_xor(&s, decimal, error);
3765 if (*error == NULL)
3766   {
3767   while (*s == '|')
3768     {
3769     int_eximarith_t y;
3770     s++;
3771     y = eval_op_xor(&s, decimal, error);
3772     if (*error != NULL) break;
3773     x |= y;
3774     }
3775   }
3776 *sptr = s;
3777 return x;
3778 }
3779
3780
3781
3782 /*************************************************
3783 *                 Expand string                  *
3784 *************************************************/
3785
3786 /* Returns either an unchanged string, or the expanded string in stacking pool
3787 store. Interpreted sequences are:
3788
3789    \...                    normal escaping rules
3790    $name                   substitutes the variable
3791    ${name}                 ditto
3792    ${op:string}            operates on the expanded string value
3793    ${item{arg1}{arg2}...}  expands the args and then does the business
3794                              some literal args are not enclosed in {}
3795
3796 There are now far too many operators and item types to make it worth listing
3797 them here in detail any more.
3798
3799 We use an internal routine recursively to handle embedded substrings. The
3800 external function follows. The yield is NULL if the expansion failed, and there
3801 are two cases: if something collapsed syntactically, or if "fail" was given
3802 as the action on a lookup failure. These can be distinguised by looking at the
3803 variable expand_string_forcedfail, which is TRUE in the latter case.
3804
3805 The skipping flag is set true when expanding a substring that isn't actually
3806 going to be used (after "if" or "lookup") and it prevents lookups from
3807 happening lower down.
3808
3809 Store usage: At start, a store block of the length of the input plus 64
3810 is obtained. This is expanded as necessary by string_cat(), which might have to
3811 get a new block, or might be able to expand the original. At the end of the
3812 function we can release any store above that portion of the yield block that
3813 was actually used. In many cases this will be optimal.
3814
3815 However: if the first item in the expansion is a variable name or header name,
3816 we reset the store before processing it; if the result is in fresh store, we
3817 use that without copying. This is helpful for expanding strings like
3818 $message_headers which can get very long.
3819
3820 There's a problem if a ${dlfunc item has side-effects that cause allocation,
3821 since resetting the store at the end of the expansion will free store that was
3822 allocated by the plugin code as well as the slop after the expanded string. So
3823 we skip any resets if ${dlfunc } has been used. The same applies for ${acl }
3824 and, given the acl condition, ${if }. This is an unfortunate consequence of
3825 string expansion becoming too powerful.
3826
3827 Arguments:
3828   string         the string to be expanded
3829   ket_ends       true if expansion is to stop at }
3830   left           if not NULL, a pointer to the first character after the
3831                  expansion is placed here (typically used with ket_ends)
3832   skipping       TRUE for recursive calls when the value isn't actually going
3833                  to be used (to allow for optimisation)
3834   honour_dollar  TRUE if $ is to be expanded,
3835                  FALSE if it's just another character
3836   resetok_p      if not NULL, pointer to flag - write FALSE if unsafe to reset
3837                  the store.
3838
3839 Returns:         NULL if expansion fails:
3840                    expand_string_forcedfail is set TRUE if failure was forced
3841                    expand_string_message contains a textual error message
3842                  a pointer to the expanded string on success
3843 */
3844
3845 static uschar *
3846 expand_string_internal(const uschar *string, BOOL ket_ends, const uschar **left,
3847   BOOL skipping, BOOL honour_dollar, BOOL *resetok_p)
3848 {
3849 int ptr = 0;
3850 int size = Ustrlen(string)+ 64;
3851 uschar *yield = store_get(size);
3852 int item_type;
3853 const uschar *s = string;
3854 uschar *save_expand_nstring[EXPAND_MAXN+1];
3855 int save_expand_nlength[EXPAND_MAXN+1];
3856 BOOL resetok = TRUE;
3857
3858 DEBUG(D_expand)
3859   debug_printf("%s: %s\n", skipping ? "   scanning" : "considering", string);
3860
3861 expand_string_forcedfail = FALSE;
3862 expand_string_message = US"";
3863
3864 while (*s != 0)
3865   {
3866   uschar *value;
3867   uschar name[256];
3868
3869   /* \ escapes the next character, which must exist, or else
3870   the expansion fails. There's a special escape, \N, which causes
3871   copying of the subject verbatim up to the next \N. Otherwise,
3872   the escapes are the standard set. */
3873
3874   if (*s == '\\')
3875     {
3876     if (s[1] == 0)
3877       {
3878       expand_string_message = US"\\ at end of string";
3879       goto EXPAND_FAILED;
3880       }
3881
3882     if (s[1] == 'N')
3883       {
3884       const uschar * t = s + 2;
3885       for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
3886       yield = string_catn(yield, &size, &ptr, t, s - t);
3887       if (*s != 0) s += 2;
3888       }
3889
3890     else
3891       {
3892       uschar ch[1];
3893       ch[0] = string_interpret_escape(&s);
3894       s++;
3895       yield = string_catn(yield, &size, &ptr, ch, 1);
3896       }
3897
3898     continue;
3899     }
3900
3901   /*{*/
3902   /* Anything other than $ is just copied verbatim, unless we are
3903   looking for a terminating } character. */
3904
3905   /*{*/
3906   if (ket_ends && *s == '}') break;
3907
3908   if (*s != '$' || !honour_dollar)
3909     {
3910     yield = string_catn(yield, &size, &ptr, s++, 1);
3911     continue;
3912     }
3913
3914   /* No { after the $ - must be a plain name or a number for string
3915   match variable. There has to be a fudge for variables that are the
3916   names of header fields preceded by "$header_" because header field
3917   names can contain any printing characters except space and colon.
3918   For those that don't like typing this much, "$h_" is a synonym for
3919   "$header_". A non-existent header yields a NULL value; nothing is
3920   inserted. */  /*}*/
3921
3922   if (isalpha((*(++s))))
3923     {
3924     int len;
3925     int newsize = 0;
3926
3927     s = read_name(name, sizeof(name), s, US"_");
3928
3929     /* If this is the first thing to be expanded, release the pre-allocated
3930     buffer. */
3931
3932     if (ptr == 0 && yield != NULL)
3933       {
3934       if (resetok) store_reset(yield);
3935       yield = NULL;
3936       size = 0;
3937       }
3938
3939     /* Header */
3940
3941     if (Ustrncmp(name, "h_", 2) == 0 ||
3942         Ustrncmp(name, "rh_", 3) == 0 ||
3943         Ustrncmp(name, "bh_", 3) == 0 ||
3944         Ustrncmp(name, "header_", 7) == 0 ||
3945         Ustrncmp(name, "rheader_", 8) == 0 ||
3946         Ustrncmp(name, "bheader_", 8) == 0)
3947       {
3948       BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
3949       uschar *charset = (name[0] == 'b')? NULL : headers_charset;
3950       s = read_header_name(name, sizeof(name), s);
3951       value = find_header(name, FALSE, &newsize, want_raw, charset);
3952
3953       /* If we didn't find the header, and the header contains a closing brace
3954       character, this may be a user error where the terminating colon
3955       has been omitted. Set a flag to adjust the error message in this case.
3956       But there is no error here - nothing gets inserted. */
3957
3958       if (value == NULL)
3959         {
3960         if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
3961         continue;
3962         }
3963       }
3964
3965     /* Variable */
3966
3967     else if (!(value = find_variable(name, FALSE, skipping, &newsize)))
3968       {
3969       expand_string_message =
3970         string_sprintf("unknown variable name \"%s\"", name);
3971         check_variable_error_message(name);
3972       goto EXPAND_FAILED;
3973       }
3974
3975     /* If the data is known to be in a new buffer, newsize will be set to the
3976     size of that buffer. If this is the first thing in an expansion string,
3977     yield will be NULL; just point it at the new store instead of copying. Many
3978     expansion strings contain just one reference, so this is a useful
3979     optimization, especially for humungous headers. */
3980
3981     len = Ustrlen(value);
3982     if (yield == NULL && newsize != 0)
3983       {
3984       yield = value;
3985       size = newsize;
3986       ptr = len;
3987       }
3988     else yield = string_catn(yield, &size, &ptr, value, len);
3989
3990     continue;
3991     }
3992
3993   if (isdigit(*s))
3994     {
3995     int n;
3996     s = read_cnumber(&n, s);
3997     if (n >= 0 && n <= expand_nmax)
3998       yield = string_catn(yield, &size, &ptr, expand_nstring[n],
3999         expand_nlength[n]);
4000     continue;
4001     }
4002
4003   /* Otherwise, if there's no '{' after $ it's an error. */             /*}*/
4004
4005   if (*s != '{')                                                        /*}*/
4006     {
4007     expand_string_message = US"$ not followed by letter, digit, or {";  /*}*/
4008     goto EXPAND_FAILED;
4009     }
4010
4011   /* After { there can be various things, but they all start with
4012   an initial word, except for a number for a string match variable. */
4013
4014   if (isdigit((*(++s))))
4015     {
4016     int n;
4017     s = read_cnumber(&n, s);            /*{*/
4018     if (*s++ != '}')
4019       {                                 /*{*/
4020       expand_string_message = US"} expected after number";
4021       goto EXPAND_FAILED;
4022       }
4023     if (n >= 0 && n <= expand_nmax)
4024       yield = string_catn(yield, &size, &ptr, expand_nstring[n],
4025         expand_nlength[n]);
4026     continue;
4027     }
4028
4029   if (!isalpha(*s))
4030     {
4031     expand_string_message = US"letter or digit expected after ${";      /*}*/
4032     goto EXPAND_FAILED;
4033     }
4034
4035   /* Allow "-" in names to cater for substrings with negative
4036   arguments. Since we are checking for known names after { this is
4037   OK. */
4038
4039   s = read_name(name, sizeof(name), s, US"_-");
4040   item_type = chop_match(name, item_table, nelem(item_table));
4041
4042   switch(item_type)
4043     {
4044     /* Call an ACL from an expansion.  We feed data in via $acl_arg1 - $acl_arg9.
4045     If the ACL returns accept or reject we return content set by "message ="
4046     There is currently no limit on recursion; this would have us call
4047     acl_check_internal() directly and get a current level from somewhere.
4048     See also the acl expansion condition ECOND_ACL and the traditional
4049     acl modifier ACLC_ACL.
4050     Assume that the function has side-effects on the store that must be preserved.
4051     */
4052
4053     case EITEM_ACL:
4054       /* ${acl {name} {arg1}{arg2}...} */
4055       {
4056       uschar *sub[10];  /* name + arg1-arg9 (which must match number of acl_arg[]) */
4057       uschar *user_msg;
4058
4059       switch(read_subs(sub, nelem(sub), 1, &s, skipping, TRUE, US"acl",
4060                       &resetok))
4061         {
4062         case 1: goto EXPAND_FAILED_CURLY;
4063         case 2:
4064         case 3: goto EXPAND_FAILED;
4065         }
4066       if (skipping) continue;
4067
4068       resetok = FALSE;
4069       switch(eval_acl(sub, nelem(sub), &user_msg))
4070         {
4071         case OK:
4072         case FAIL:
4073           DEBUG(D_expand)
4074             debug_printf("acl expansion yield: %s\n", user_msg);
4075           if (user_msg)
4076             yield = string_cat(yield, &size, &ptr, user_msg);
4077           continue;
4078
4079         case DEFER:
4080           expand_string_forcedfail = TRUE;
4081           /*FALLTHROUGH*/
4082         default:
4083           expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
4084           goto EXPAND_FAILED;
4085         }
4086       }
4087
4088     /* Handle conditionals - preserve the values of the numerical expansion
4089     variables in case they get changed by a regular expression match in the
4090     condition. If not, they retain their external settings. At the end
4091     of this "if" section, they get restored to their previous values. */
4092
4093     case EITEM_IF:
4094       {
4095       BOOL cond = FALSE;
4096       const uschar *next_s;
4097       int save_expand_nmax =
4098         save_expand_strings(save_expand_nstring, save_expand_nlength);
4099
4100       while (isspace(*s)) s++;
4101       next_s = eval_condition(s, &resetok, skipping? NULL : &cond);
4102       if (next_s == NULL) goto EXPAND_FAILED;  /* message already set */
4103
4104       DEBUG(D_expand)
4105         debug_printf("condition: %.*s\n   result: %s\n", (int)(next_s - s), s,
4106           cond? "true" : "false");
4107
4108       s = next_s;
4109
4110       /* The handling of "yes" and "no" result strings is now in a separate
4111       function that is also used by ${lookup} and ${extract} and ${run}. */
4112
4113       switch(process_yesno(
4114                skipping,                     /* were previously skipping */
4115                cond,                         /* success/failure indicator */
4116                lookup_value,                 /* value to reset for string2 */
4117                &s,                           /* input pointer */
4118                &yield,                       /* output pointer */
4119                &size,                        /* output size */
4120                &ptr,                         /* output current point */
4121                US"if",                       /* condition type */
4122                &resetok))
4123         {
4124         case 1: goto EXPAND_FAILED;          /* when all is well, the */
4125         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
4126         }
4127
4128       /* Restore external setting of expansion variables for continuation
4129       at this level. */
4130
4131       restore_expand_strings(save_expand_nmax, save_expand_nstring,
4132         save_expand_nlength);
4133       continue;
4134       }
4135
4136 #ifdef SUPPORT_I18N
4137     case EITEM_IMAPFOLDER:
4138       {                         /* ${imapfolder {name}{sep]{specials}} */
4139       uschar *sub_arg[3];
4140       uschar *encoded;
4141
4142       switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, skipping, TRUE, name,
4143                       &resetok))
4144         {
4145         case 1: goto EXPAND_FAILED_CURLY;
4146         case 2:
4147         case 3: goto EXPAND_FAILED;
4148         }
4149
4150       if (sub_arg[1] == NULL)           /* One argument */
4151         {
4152         sub_arg[1] = US"/";             /* default separator */
4153         sub_arg[2] = NULL;
4154         }
4155       else if (Ustrlen(sub_arg[1]) != 1)
4156         {
4157         expand_string_message =
4158           string_sprintf(
4159                 "IMAP folder separator must be one character, found \"%s\"",
4160                 sub_arg[1]);
4161         goto EXPAND_FAILED;
4162         }
4163
4164       if (!(encoded = imap_utf7_encode(sub_arg[0], headers_charset,
4165                           sub_arg[1][0], sub_arg[2], &expand_string_message)))
4166         goto EXPAND_FAILED;
4167       if (!skipping)
4168         yield = string_cat(yield, &size, &ptr, encoded);
4169       continue;
4170       }
4171 #endif
4172
4173     /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
4174     expanding an internal string that isn't actually going to be used. All we
4175     need to do is check the syntax, so don't do a lookup at all. Preserve the
4176     values of the numerical expansion variables in case they get changed by a
4177     partial lookup. If not, they retain their external settings. At the end
4178     of this "lookup" section, they get restored to their previous values. */
4179
4180     case EITEM_LOOKUP:
4181       {
4182       int stype, partial, affixlen, starflags;
4183       int expand_setup = 0;
4184       int nameptr = 0;
4185       uschar *key, *filename;
4186       const uschar *affix;
4187       uschar *save_lookup_value = lookup_value;
4188       int save_expand_nmax =
4189         save_expand_strings(save_expand_nstring, save_expand_nlength);
4190
4191       if ((expand_forbid & RDO_LOOKUP) != 0)
4192         {
4193         expand_string_message = US"lookup expansions are not permitted";
4194         goto EXPAND_FAILED;
4195         }
4196
4197       /* Get the key we are to look up for single-key+file style lookups.
4198       Otherwise set the key NULL pro-tem. */
4199
4200       while (isspace(*s)) s++;
4201       if (*s == '{')                                    /*}*/
4202         {
4203         key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4204         if (!key) goto EXPAND_FAILED;                   /*{{*/
4205         if (*s++ != '}')
4206           {
4207           expand_string_message = US"missing '}' after lookup key";
4208           goto EXPAND_FAILED_CURLY;
4209           }
4210         while (isspace(*s)) s++;
4211         }
4212       else key = NULL;
4213
4214       /* Find out the type of database */
4215
4216       if (!isalpha(*s))
4217         {
4218         expand_string_message = US"missing lookup type";
4219         goto EXPAND_FAILED;
4220         }
4221
4222       /* The type is a string that may contain special characters of various
4223       kinds. Allow everything except space or { to appear; the actual content
4224       is checked by search_findtype_partial. */         /*}*/
4225
4226       while (*s != 0 && *s != '{' && !isspace(*s))      /*}*/
4227         {
4228         if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
4229         s++;
4230         }
4231       name[nameptr] = 0;
4232       while (isspace(*s)) s++;
4233
4234       /* Now check for the individual search type and any partial or default
4235       options. Only those types that are actually in the binary are valid. */
4236
4237       stype = search_findtype_partial(name, &partial, &affix, &affixlen,
4238         &starflags);
4239       if (stype < 0)
4240         {
4241         expand_string_message = search_error_message;
4242         goto EXPAND_FAILED;
4243         }
4244
4245       /* Check that a key was provided for those lookup types that need it,
4246       and was not supplied for those that use the query style. */
4247
4248       if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
4249         {
4250         if (key == NULL)
4251           {
4252           expand_string_message = string_sprintf("missing {key} for single-"
4253             "key \"%s\" lookup", name);
4254           goto EXPAND_FAILED;
4255           }
4256         }
4257       else
4258         {
4259         if (key != NULL)
4260           {
4261           expand_string_message = string_sprintf("a single key was given for "
4262             "lookup type \"%s\", which is not a single-key lookup type", name);
4263           goto EXPAND_FAILED;
4264           }
4265         }
4266
4267       /* Get the next string in brackets and expand it. It is the file name for
4268       single-key+file lookups, and the whole query otherwise. In the case of
4269       queries that also require a file name (e.g. sqlite), the file name comes
4270       first. */
4271
4272       if (*s != '{')
4273         {
4274         expand_string_message = US"missing '{' for lookup file-or-query arg";
4275         goto EXPAND_FAILED_CURLY;
4276         }
4277       filename = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4278       if (filename == NULL) goto EXPAND_FAILED;
4279       if (*s++ != '}')
4280         {
4281         expand_string_message = US"missing '}' closing lookup file-or-query arg";
4282         goto EXPAND_FAILED_CURLY;
4283         }
4284       while (isspace(*s)) s++;
4285
4286       /* If this isn't a single-key+file lookup, re-arrange the variables
4287       to be appropriate for the search_ functions. For query-style lookups,
4288       there is just a "key", and no file name. For the special query-style +
4289       file types, the query (i.e. "key") starts with a file name. */
4290
4291       if (!key)
4292         {
4293         while (isspace(*filename)) filename++;
4294         key = filename;
4295
4296         if (mac_islookup(stype, lookup_querystyle))
4297           filename = NULL;
4298         else
4299           {
4300           if (*filename != '/')
4301             {
4302             expand_string_message = string_sprintf(
4303               "absolute file name expected for \"%s\" lookup", name);
4304             goto EXPAND_FAILED;
4305             }
4306           while (*key != 0 && !isspace(*key)) key++;
4307           if (*key != 0) *key++ = 0;
4308           }
4309         }
4310
4311       /* If skipping, don't do the next bit - just lookup_value == NULL, as if
4312       the entry was not found. Note that there is no search_close() function.
4313       Files are left open in case of re-use. At suitable places in higher logic,
4314       search_tidyup() is called to tidy all open files. This can save opening
4315       the same file several times. However, files may also get closed when
4316       others are opened, if too many are open at once. The rule is that a
4317       handle should not be used after a second search_open().
4318
4319       Request that a partial search sets up $1 and maybe $2 by passing
4320       expand_setup containing zero. If its value changes, reset expand_nmax,
4321       since new variables will have been set. Note that at the end of this
4322       "lookup" section, the old numeric variables are restored. */
4323
4324       if (skipping)
4325         lookup_value = NULL;
4326       else
4327         {
4328         void *handle = search_open(filename, stype, 0, NULL, NULL);
4329         if (handle == NULL)
4330           {
4331           expand_string_message = search_error_message;
4332           goto EXPAND_FAILED;
4333           }
4334         lookup_value = search_find(handle, filename, key, partial, affix,
4335           affixlen, starflags, &expand_setup);
4336         if (search_find_defer)
4337           {
4338           expand_string_message =
4339             string_sprintf("lookup of \"%s\" gave DEFER: %s",
4340               string_printing2(key, FALSE), search_error_message);
4341           goto EXPAND_FAILED;
4342           }
4343         if (expand_setup > 0) expand_nmax = expand_setup;
4344         }
4345
4346       /* The handling of "yes" and "no" result strings is now in a separate
4347       function that is also used by ${if} and ${extract}. */
4348
4349       switch(process_yesno(
4350                skipping,                     /* were previously skipping */
4351                lookup_value != NULL,         /* success/failure indicator */
4352                save_lookup_value,            /* value to reset for string2 */
4353                &s,                           /* input pointer */
4354                &yield,                       /* output pointer */
4355                &size,                        /* output size */
4356                &ptr,                         /* output current point */
4357                US"lookup",                   /* condition type */
4358                &resetok))
4359         {
4360         case 1: goto EXPAND_FAILED;          /* when all is well, the */
4361         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
4362         }
4363
4364       /* Restore external setting of expansion variables for carrying on
4365       at this level, and continue. */
4366
4367       restore_expand_strings(save_expand_nmax, save_expand_nstring,
4368         save_expand_nlength);
4369       continue;
4370       }
4371
4372     /* If Perl support is configured, handle calling embedded perl subroutines,
4373     unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
4374     or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
4375     arguments (defined below). */
4376
4377     #define EXIM_PERL_MAX_ARGS 8
4378
4379     case EITEM_PERL:
4380     #ifndef EXIM_PERL
4381     expand_string_message = US"\"${perl\" encountered, but this facility "      /*}*/
4382       "is not included in this binary";
4383     goto EXPAND_FAILED;
4384
4385     #else   /* EXIM_PERL */
4386       {
4387       uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
4388       uschar *new_yield;
4389
4390       if ((expand_forbid & RDO_PERL) != 0)
4391         {
4392         expand_string_message = US"Perl calls are not permitted";
4393         goto EXPAND_FAILED;
4394         }
4395
4396       switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
4397            US"perl", &resetok))
4398         {
4399         case 1: goto EXPAND_FAILED_CURLY;
4400         case 2:
4401         case 3: goto EXPAND_FAILED;
4402         }
4403
4404       /* If skipping, we don't actually do anything */
4405
4406       if (skipping) continue;
4407
4408       /* Start the interpreter if necessary */
4409
4410       if (!opt_perl_started)
4411         {
4412         uschar *initerror;
4413         if (opt_perl_startup == NULL)
4414           {
4415           expand_string_message = US"A setting of perl_startup is needed when "
4416             "using the Perl interpreter";
4417           goto EXPAND_FAILED;
4418           }
4419         DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
4420         initerror = init_perl(opt_perl_startup);
4421         if (initerror != NULL)
4422           {
4423           expand_string_message =
4424             string_sprintf("error in perl_startup code: %s\n", initerror);
4425           goto EXPAND_FAILED;
4426           }
4427         opt_perl_started = TRUE;
4428         }
4429
4430       /* Call the function */
4431
4432       sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
4433       new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
4434         sub_arg[0], sub_arg + 1);
4435
4436       /* NULL yield indicates failure; if the message pointer has been set to
4437       NULL, the yield was undef, indicating a forced failure. Otherwise the
4438       message will indicate some kind of Perl error. */
4439
4440       if (new_yield == NULL)
4441         {
4442         if (expand_string_message == NULL)
4443           {
4444           expand_string_message =
4445             string_sprintf("Perl subroutine \"%s\" returned undef to force "
4446               "failure", sub_arg[0]);
4447           expand_string_forcedfail = TRUE;
4448           }
4449         goto EXPAND_FAILED;
4450         }
4451
4452       /* Yield succeeded. Ensure forcedfail is unset, just in case it got
4453       set during a callback from Perl. */
4454
4455       expand_string_forcedfail = FALSE;
4456       yield = new_yield;
4457       continue;
4458       }
4459     #endif /* EXIM_PERL */
4460
4461     /* Transform email address to "prvs" scheme to use
4462        as BATV-signed return path */
4463
4464     case EITEM_PRVS:
4465       {
4466       uschar *sub_arg[3];
4467       uschar *p,*domain;
4468
4469       switch(read_subs(sub_arg, 3, 2, &s, skipping, TRUE, US"prvs", &resetok))
4470         {
4471         case 1: goto EXPAND_FAILED_CURLY;
4472         case 2:
4473         case 3: goto EXPAND_FAILED;
4474         }
4475
4476       /* If skipping, we don't actually do anything */
4477       if (skipping) continue;
4478
4479       /* sub_arg[0] is the address */
4480       domain = Ustrrchr(sub_arg[0],'@');
4481       if ( (domain == NULL) || (domain == sub_arg[0]) || (Ustrlen(domain) == 1) )
4482         {
4483         expand_string_message = US"prvs first argument must be a qualified email address";
4484         goto EXPAND_FAILED;
4485         }
4486
4487       /* Calculate the hash. The second argument must be a single-digit
4488       key number, or unset. */
4489
4490       if (sub_arg[2] != NULL &&
4491           (!isdigit(sub_arg[2][0]) || sub_arg[2][1] != 0))
4492         {
4493         expand_string_message = US"prvs second argument must be a single digit";
4494         goto EXPAND_FAILED;
4495         }
4496
4497       p = prvs_hmac_sha1(sub_arg[0],sub_arg[1],sub_arg[2],prvs_daystamp(7));
4498       if (p == NULL)
4499         {
4500         expand_string_message = US"prvs hmac-sha1 conversion failed";
4501         goto EXPAND_FAILED;
4502         }
4503
4504       /* Now separate the domain from the local part */
4505       *domain++ = '\0';
4506
4507       yield = string_catn(yield, &size, &ptr, US"prvs=", 5);
4508       yield = string_catn(yield, &size, &ptr, sub_arg[2] ? sub_arg[2] : US"0", 1);
4509       yield = string_catn(yield, &size, &ptr, prvs_daystamp(7), 3);
4510       yield = string_catn(yield, &size, &ptr, p, 6);
4511       yield = string_catn(yield, &size, &ptr, US"=", 1);
4512       yield = string_cat (yield, &size, &ptr, sub_arg[0]);
4513       yield = string_catn(yield, &size, &ptr, US"@", 1);
4514       yield = string_cat (yield, &size, &ptr, domain);
4515
4516       continue;
4517       }
4518
4519     /* Check a prvs-encoded address for validity */
4520
4521     case EITEM_PRVSCHECK:
4522       {
4523       uschar *sub_arg[3];
4524       int mysize = 0, myptr = 0;
4525       const pcre *re;
4526       uschar *p;
4527
4528       /* TF: Ugliness: We want to expand parameter 1 first, then set
4529          up expansion variables that are used in the expansion of
4530          parameter 2. So we clone the string for the first
4531          expansion, where we only expand parameter 1.
4532
4533          PH: Actually, that isn't necessary. The read_subs() function is
4534          designed to work this way for the ${if and ${lookup expansions. I've
4535          tidied the code.
4536       */
4537
4538       /* Reset expansion variables */
4539       prvscheck_result = NULL;
4540       prvscheck_address = NULL;
4541       prvscheck_keynum = NULL;
4542
4543       switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4544         {
4545         case 1: goto EXPAND_FAILED_CURLY;
4546         case 2:
4547         case 3: goto EXPAND_FAILED;
4548         }
4549
4550       re = regex_must_compile(US"^prvs\\=([0-9])([0-9]{3})([A-F0-9]{6})\\=(.+)\\@(.+)$",
4551                               TRUE,FALSE);
4552
4553       if (regex_match_and_setup(re,sub_arg[0],0,-1))
4554         {
4555         uschar *local_part = string_copyn(expand_nstring[4],expand_nlength[4]);
4556         uschar *key_num = string_copyn(expand_nstring[1],expand_nlength[1]);
4557         uschar *daystamp = string_copyn(expand_nstring[2],expand_nlength[2]);
4558         uschar *hash = string_copyn(expand_nstring[3],expand_nlength[3]);
4559         uschar *domain = string_copyn(expand_nstring[5],expand_nlength[5]);
4560
4561         DEBUG(D_expand) debug_printf("prvscheck localpart: %s\n", local_part);
4562         DEBUG(D_expand) debug_printf("prvscheck key number: %s\n", key_num);
4563         DEBUG(D_expand) debug_printf("prvscheck daystamp: %s\n", daystamp);
4564         DEBUG(D_expand) debug_printf("prvscheck hash: %s\n", hash);
4565         DEBUG(D_expand) debug_printf("prvscheck domain: %s\n", domain);
4566
4567         /* Set up expansion variables */
4568         prvscheck_address = string_cat (NULL, &mysize, &myptr, local_part);
4569         prvscheck_address = string_catn(prvscheck_address, &mysize, &myptr, US"@", 1);
4570         prvscheck_address = string_cat (prvscheck_address, &mysize, &myptr, domain);
4571         prvscheck_address[myptr] = '\0';
4572         prvscheck_keynum = string_copy(key_num);
4573
4574         /* Now expand the second argument */
4575         switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4576           {
4577           case 1: goto EXPAND_FAILED_CURLY;
4578           case 2:
4579           case 3: goto EXPAND_FAILED;
4580           }
4581
4582         /* Now we have the key and can check the address. */
4583
4584         p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
4585           daystamp);
4586
4587         if (p == NULL)
4588           {
4589           expand_string_message = US"hmac-sha1 conversion failed";
4590           goto EXPAND_FAILED;
4591           }
4592
4593         DEBUG(D_expand) debug_printf("prvscheck: received hash is %s\n", hash);
4594         DEBUG(D_expand) debug_printf("prvscheck:      own hash is %s\n", p);
4595
4596         if (Ustrcmp(p,hash) == 0)
4597           {
4598           /* Success, valid BATV address. Now check the expiry date. */
4599           uschar *now = prvs_daystamp(0);
4600           unsigned int inow = 0,iexpire = 1;
4601
4602           (void)sscanf(CS now,"%u",&inow);
4603           (void)sscanf(CS daystamp,"%u",&iexpire);
4604
4605           /* When "iexpire" is < 7, a "flip" has occured.
4606              Adjust "inow" accordingly. */
4607           if ( (iexpire < 7) && (inow >= 993) ) inow = 0;
4608
4609           if (iexpire >= inow)
4610             {
4611             prvscheck_result = US"1";
4612             DEBUG(D_expand) debug_printf("prvscheck: success, $pvrs_result set to 1\n");
4613             }
4614             else
4615             {
4616             prvscheck_result = NULL;
4617             DEBUG(D_expand) debug_printf("prvscheck: signature expired, $pvrs_result unset\n");
4618             }
4619           }
4620         else
4621           {
4622           prvscheck_result = NULL;
4623           DEBUG(D_expand) debug_printf("prvscheck: hash failure, $pvrs_result unset\n");
4624           }
4625
4626         /* Now expand the final argument. We leave this till now so that
4627         it can include $prvscheck_result. */
4628
4629         switch(read_subs(sub_arg, 1, 0, &s, skipping, TRUE, US"prvs", &resetok))
4630           {
4631           case 1: goto EXPAND_FAILED_CURLY;
4632           case 2:
4633           case 3: goto EXPAND_FAILED;
4634           }
4635
4636         yield = string_cat(yield, &size, &ptr,
4637           !sub_arg[0] || !*sub_arg[0] ? prvscheck_address : sub_arg[0]);
4638
4639         /* Reset the "internal" variables afterwards, because they are in
4640         dynamic store that will be reclaimed if the expansion succeeded. */
4641
4642         prvscheck_address = NULL;
4643         prvscheck_keynum = NULL;
4644         }
4645       else
4646         {
4647         /* Does not look like a prvs encoded address, return the empty string.
4648            We need to make sure all subs are expanded first, so as to skip over
4649            the entire item. */
4650
4651         switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"prvs", &resetok))
4652           {
4653           case 1: goto EXPAND_FAILED_CURLY;
4654           case 2:
4655           case 3: goto EXPAND_FAILED;
4656           }
4657         }
4658
4659       continue;
4660       }
4661
4662     /* Handle "readfile" to insert an entire file */
4663
4664     case EITEM_READFILE:
4665       {
4666       FILE *f;
4667       uschar *sub_arg[2];
4668
4669       if ((expand_forbid & RDO_READFILE) != 0)
4670         {
4671         expand_string_message = US"file insertions are not permitted";
4672         goto EXPAND_FAILED;
4673         }
4674
4675       switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile", &resetok))
4676         {
4677         case 1: goto EXPAND_FAILED_CURLY;
4678         case 2:
4679         case 3: goto EXPAND_FAILED;
4680         }
4681
4682       /* If skipping, we don't actually do anything */
4683
4684       if (skipping) continue;
4685
4686       /* Open the file and read it */
4687
4688       f = Ufopen(sub_arg[0], "rb");
4689       if (f == NULL)
4690         {
4691         expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
4692         goto EXPAND_FAILED;
4693         }
4694
4695       yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
4696       (void)fclose(f);
4697       continue;
4698       }
4699
4700     /* Handle "readsocket" to insert data from a Unix domain socket */
4701
4702     case EITEM_READSOCK:
4703       {
4704       int fd;
4705       int timeout = 5;
4706       int save_ptr = ptr;
4707       FILE *f;
4708       struct sockaddr_un sockun;         /* don't call this "sun" ! */
4709       uschar *arg;
4710       uschar *sub_arg[4];
4711
4712       if ((expand_forbid & RDO_READSOCK) != 0)
4713         {
4714         expand_string_message = US"socket insertions are not permitted";
4715         goto EXPAND_FAILED;
4716         }
4717
4718       /* Read up to 4 arguments, but don't do the end of item check afterwards,
4719       because there may be a string for expansion on failure. */
4720
4721       switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket", &resetok))
4722         {
4723         case 1: goto EXPAND_FAILED_CURLY;
4724         case 2:                             /* Won't occur: no end check */
4725         case 3: goto EXPAND_FAILED;
4726         }
4727
4728       /* Sort out timeout, if given */
4729
4730       if (sub_arg[2] != NULL)
4731         {
4732         timeout = readconf_readtime(sub_arg[2], 0, FALSE);
4733         if (timeout < 0)
4734           {
4735           expand_string_message = string_sprintf("bad time value %s",
4736             sub_arg[2]);
4737           goto EXPAND_FAILED;
4738           }
4739         }
4740       else sub_arg[3] = NULL;                     /* No eol if no timeout */
4741
4742       /* If skipping, we don't actually do anything. Otherwise, arrange to
4743       connect to either an IP or a Unix socket. */
4744
4745       if (!skipping)
4746         {
4747         /* Handle an IP (internet) domain */
4748
4749         if (Ustrncmp(sub_arg[0], "inet:", 5) == 0)
4750           {
4751           int port;
4752           uschar *server_name = sub_arg[0] + 5;
4753           uschar *port_name = Ustrrchr(server_name, ':');
4754
4755           /* Sort out the port */
4756
4757           if (port_name == NULL)
4758             {
4759             expand_string_message =
4760               string_sprintf("missing port for readsocket %s", sub_arg[0]);
4761             goto EXPAND_FAILED;
4762             }
4763           *port_name++ = 0;           /* Terminate server name */
4764
4765           if (isdigit(*port_name))
4766             {
4767             uschar *end;
4768             port = Ustrtol(port_name, &end, 0);
4769             if (end != port_name + Ustrlen(port_name))
4770               {
4771               expand_string_message =
4772                 string_sprintf("invalid port number %s", port_name);
4773               goto EXPAND_FAILED;
4774               }
4775             }
4776           else
4777             {
4778             struct servent *service_info = getservbyname(CS port_name, "tcp");
4779             if (service_info == NULL)
4780               {
4781               expand_string_message = string_sprintf("unknown port \"%s\"",
4782                 port_name);
4783               goto EXPAND_FAILED;
4784               }
4785             port = ntohs(service_info->s_port);
4786             }
4787
4788           if ((fd = ip_connectedsocket(SOCK_STREAM, server_name, port, port,
4789                   timeout, NULL, &expand_string_message)) < 0)
4790               goto SOCK_FAIL;
4791           }
4792
4793         /* Handle a Unix domain socket */
4794
4795         else
4796           {
4797           int rc;
4798           if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
4799             {
4800             expand_string_message = string_sprintf("failed to create socket: %s",
4801               strerror(errno));
4802             goto SOCK_FAIL;
4803             }
4804
4805           sockun.sun_family = AF_UNIX;
4806           sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
4807             sub_arg[0]);
4808
4809           sigalrm_seen = FALSE;
4810           alarm(timeout);
4811           rc = connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun));
4812           alarm(0);
4813           if (sigalrm_seen)
4814             {
4815             expand_string_message = US "socket connect timed out";
4816             goto SOCK_FAIL;
4817             }
4818           if (rc < 0)
4819             {
4820             expand_string_message = string_sprintf("failed to connect to socket "
4821               "%s: %s", sub_arg[0], strerror(errno));
4822             goto SOCK_FAIL;
4823             }
4824           }
4825
4826         DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
4827
4828         /* Allow sequencing of test actions */
4829         if (running_in_test_harness) millisleep(100);
4830
4831         /* Write the request string, if not empty */
4832
4833         if (sub_arg[1][0] != 0)
4834           {
4835           int len = Ustrlen(sub_arg[1]);
4836           DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
4837             sub_arg[1]);
4838           if (write(fd, sub_arg[1], len) != len)
4839             {
4840             expand_string_message = string_sprintf("request write to socket "
4841               "failed: %s", strerror(errno));
4842             goto SOCK_FAIL;
4843             }
4844           }
4845
4846         /* Shut down the sending side of the socket. This helps some servers to
4847         recognise that it is their turn to do some work. Just in case some
4848         system doesn't have this function, make it conditional. */
4849
4850         #ifdef SHUT_WR
4851         shutdown(fd, SHUT_WR);
4852         #endif
4853
4854         if (running_in_test_harness) millisleep(100);
4855
4856         /* Now we need to read from the socket, under a timeout. The function
4857         that reads a file can be used. */
4858
4859         f = fdopen(fd, "rb");
4860         sigalrm_seen = FALSE;
4861         alarm(timeout);
4862         yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
4863         alarm(0);
4864         (void)fclose(f);
4865
4866         /* After a timeout, we restore the pointer in the result, that is,
4867         make sure we add nothing from the socket. */
4868
4869         if (sigalrm_seen)
4870           {
4871           ptr = save_ptr;
4872           expand_string_message = US "socket read timed out";
4873           goto SOCK_FAIL;
4874           }
4875         }
4876
4877       /* The whole thing has worked (or we were skipping). If there is a
4878       failure string following, we need to skip it. */
4879
4880       if (*s == '{')
4881         {
4882         if (expand_string_internal(s+1, TRUE, &s, TRUE, TRUE, &resetok) == NULL)
4883           goto EXPAND_FAILED;
4884         if (*s++ != '}')
4885           {
4886           expand_string_message = US"missing '}' closing failstring for readsocket";
4887           goto EXPAND_FAILED_CURLY;
4888           }
4889         while (isspace(*s)) s++;
4890         }
4891
4892     readsock_done:
4893       if (*s++ != '}')
4894         {
4895         expand_string_message = US"missing '}' closing readsocket";
4896         goto EXPAND_FAILED_CURLY;
4897         }
4898       continue;
4899
4900       /* Come here on failure to create socket, connect socket, write to the
4901       socket, or timeout on reading. If another substring follows, expand and
4902       use it. Otherwise, those conditions give expand errors. */
4903
4904       SOCK_FAIL:
4905       if (*s != '{') goto EXPAND_FAILED;
4906       DEBUG(D_any) debug_printf("%s\n", expand_string_message);
4907       if (!(arg = expand_string_internal(s+1, TRUE, &s, FALSE, TRUE, &resetok)))
4908         goto EXPAND_FAILED;
4909       yield = string_cat(yield, &size, &ptr, arg);
4910       if (*s++ != '}')
4911         {
4912         expand_string_message = US"missing '}' closing failstring for readsocket";
4913         goto EXPAND_FAILED_CURLY;
4914         }
4915       while (isspace(*s)) s++;
4916       goto readsock_done;
4917       }
4918
4919     /* Handle "run" to execute a program. */
4920
4921     case EITEM_RUN:
4922       {
4923       FILE *f;
4924       uschar *arg;
4925       const uschar **argv;
4926       pid_t pid;
4927       int fd_in, fd_out;
4928       int lsize = 0, lptr = 0;
4929
4930       if ((expand_forbid & RDO_RUN) != 0)
4931         {
4932         expand_string_message = US"running a command is not permitted";
4933         goto EXPAND_FAILED;
4934         }
4935
4936       while (isspace(*s)) s++;
4937       if (*s != '{')
4938         {
4939         expand_string_message = US"missing '{' for command arg of run";
4940         goto EXPAND_FAILED_CURLY;
4941         }
4942       arg = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4943       if (arg == NULL) goto EXPAND_FAILED;
4944       while (isspace(*s)) s++;
4945       if (*s++ != '}')
4946         {
4947         expand_string_message = US"missing '}' closing command arg of run";
4948         goto EXPAND_FAILED_CURLY;
4949         }
4950
4951       if (skipping)   /* Just pretend it worked when we're skipping */
4952         runrc = 0;
4953       else
4954         {
4955         if (!transport_set_up_command(&argv,    /* anchor for arg list */
4956             arg,                                /* raw command */
4957             FALSE,                              /* don't expand the arguments */
4958             0,                                  /* not relevant when... */
4959             NULL,                               /* no transporting address */
4960             US"${run} expansion",               /* for error messages */
4961             &expand_string_message))            /* where to put error message */
4962           goto EXPAND_FAILED;
4963
4964         /* Create the child process, making it a group leader. */
4965
4966         if ((pid = child_open(USS argv, NULL, 0077, &fd_in, &fd_out, TRUE)) < 0)
4967           {
4968           expand_string_message =
4969             string_sprintf("couldn't create child process: %s", strerror(errno));
4970           goto EXPAND_FAILED;
4971           }
4972
4973         /* Nothing is written to the standard input. */
4974
4975         (void)close(fd_in);
4976
4977         /* Read the pipe to get the command's output into $value (which is kept
4978         in lookup_value). Read during execution, so that if the output exceeds
4979         the OS pipe buffer limit, we don't block forever. Remember to not release
4980         memory just allocated for $value. */
4981
4982         resetok = FALSE;
4983         f = fdopen(fd_out, "rb");
4984         sigalrm_seen = FALSE;
4985         alarm(60);
4986         lookup_value = cat_file(f, NULL, &lsize, &lptr, NULL);
4987         alarm(0);
4988         (void)fclose(f);
4989
4990         /* Wait for the process to finish, applying the timeout, and inspect its
4991         return code for serious disasters. Simple non-zero returns are passed on.
4992         */
4993
4994         if (sigalrm_seen == TRUE || (runrc = child_close(pid, 30)) < 0)
4995           {
4996           if (sigalrm_seen == TRUE || runrc == -256)
4997             {
4998             expand_string_message = string_sprintf("command timed out");
4999             killpg(pid, SIGKILL);       /* Kill the whole process group */
5000             }
5001
5002           else if (runrc == -257)
5003             expand_string_message = string_sprintf("wait() failed: %s",
5004               strerror(errno));
5005
5006           else
5007             expand_string_message = string_sprintf("command killed by signal %d",
5008               -runrc);
5009
5010           goto EXPAND_FAILED;
5011           }
5012         }
5013
5014       /* Process the yes/no strings; $value may be useful in both cases */
5015
5016       switch(process_yesno(
5017                skipping,                     /* were previously skipping */
5018                runrc == 0,                   /* success/failure indicator */
5019                lookup_value,                 /* value to reset for string2 */
5020                &s,                           /* input pointer */
5021                &yield,                       /* output pointer */
5022                &size,                        /* output size */
5023                &ptr,                         /* output current point */
5024                US"run",                      /* condition type */
5025                &resetok))
5026         {
5027         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5028         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5029         }
5030
5031       continue;
5032       }
5033
5034     /* Handle character translation for "tr" */
5035
5036     case EITEM_TR:
5037       {
5038       int oldptr = ptr;
5039       int o2m;
5040       uschar *sub[3];
5041
5042       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr", &resetok))
5043         {
5044         case 1: goto EXPAND_FAILED_CURLY;
5045         case 2:
5046         case 3: goto EXPAND_FAILED;
5047         }
5048
5049       yield = string_cat(yield, &size, &ptr, sub[0]);
5050       o2m = Ustrlen(sub[2]) - 1;
5051
5052       if (o2m >= 0) for (; oldptr < ptr; oldptr++)
5053         {
5054         uschar *m = Ustrrchr(sub[1], yield[oldptr]);
5055         if (m != NULL)
5056           {
5057           int o = m - sub[1];
5058           yield[oldptr] = sub[2][(o < o2m)? o : o2m];
5059           }
5060         }
5061
5062       continue;
5063       }
5064
5065     /* Handle "hash", "length", "nhash", and "substr" when they are given with
5066     expanded arguments. */
5067
5068     case EITEM_HASH:
5069     case EITEM_LENGTH:
5070     case EITEM_NHASH:
5071     case EITEM_SUBSTR:
5072       {
5073       int i;
5074       int len;
5075       uschar *ret;
5076       int val[2] = { 0, -1 };
5077       uschar *sub[3];
5078
5079       /* "length" takes only 2 arguments whereas the others take 2 or 3.
5080       Ensure that sub[2] is set in the ${length } case. */
5081
5082       sub[2] = NULL;
5083       switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
5084              TRUE, name, &resetok))
5085         {
5086         case 1: goto EXPAND_FAILED_CURLY;
5087         case 2:
5088         case 3: goto EXPAND_FAILED;
5089         }
5090
5091       /* Juggle the arguments if there are only two of them: always move the
5092       string to the last position and make ${length{n}{str}} equivalent to
5093       ${substr{0}{n}{str}}. See the defaults for val[] above. */
5094
5095       if (sub[2] == NULL)
5096         {
5097         sub[2] = sub[1];
5098         sub[1] = NULL;
5099         if (item_type == EITEM_LENGTH)
5100           {
5101           sub[1] = sub[0];
5102           sub[0] = NULL;
5103           }
5104         }
5105
5106       for (i = 0; i < 2; i++)
5107         {
5108         if (sub[i] == NULL) continue;
5109         val[i] = (int)Ustrtol(sub[i], &ret, 10);
5110         if (*ret != 0 || (i != 0 && val[i] < 0))
5111           {
5112           expand_string_message = string_sprintf("\"%s\" is not a%s number "
5113             "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
5114           goto EXPAND_FAILED;
5115           }
5116         }
5117
5118       ret =
5119         (item_type == EITEM_HASH)?
5120           compute_hash(sub[2], val[0], val[1], &len) :
5121         (item_type == EITEM_NHASH)?
5122           compute_nhash(sub[2], val[0], val[1], &len) :
5123           extract_substr(sub[2], val[0], val[1], &len);
5124
5125       if (ret == NULL) goto EXPAND_FAILED;
5126       yield = string_catn(yield, &size, &ptr, ret, len);
5127       continue;
5128       }
5129
5130     /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
5131     This code originally contributed by Steve Haslam. It currently supports
5132     the use of MD5 and SHA-1 hashes.
5133
5134     We need some workspace that is large enough to handle all the supported
5135     hash types. Use macros to set the sizes rather than be too elaborate. */
5136
5137     #define MAX_HASHLEN      20
5138     #define MAX_HASHBLOCKLEN 64
5139
5140     case EITEM_HMAC:
5141       {
5142       uschar *sub[3];
5143       md5 md5_base;
5144       hctx sha1_ctx;
5145       void *use_base;
5146       int type, i;
5147       int hashlen;      /* Number of octets for the hash algorithm's output */
5148       int hashblocklen; /* Number of octets the hash algorithm processes */
5149       uschar *keyptr, *p;
5150       unsigned int keylen;
5151
5152       uschar keyhash[MAX_HASHLEN];
5153       uschar innerhash[MAX_HASHLEN];
5154       uschar finalhash[MAX_HASHLEN];
5155       uschar finalhash_hex[2*MAX_HASHLEN];
5156       uschar innerkey[MAX_HASHBLOCKLEN];
5157       uschar outerkey[MAX_HASHBLOCKLEN];
5158
5159       switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
5160         {
5161         case 1: goto EXPAND_FAILED_CURLY;
5162         case 2:
5163         case 3: goto EXPAND_FAILED;
5164         }
5165
5166       if (Ustrcmp(sub[0], "md5") == 0)
5167         {
5168         type = HMAC_MD5;
5169         use_base = &md5_base;
5170         hashlen = 16;
5171         hashblocklen = 64;
5172         }
5173       else if (Ustrcmp(sub[0], "sha1") == 0)
5174         {
5175         type = HMAC_SHA1;
5176         use_base = &sha1_ctx;
5177         hashlen = 20;
5178         hashblocklen = 64;
5179         }
5180       else
5181         {
5182         expand_string_message =
5183           string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
5184         goto EXPAND_FAILED;
5185         }
5186
5187       keyptr = sub[1];
5188       keylen = Ustrlen(keyptr);
5189
5190       /* If the key is longer than the hash block length, then hash the key
5191       first */
5192
5193       if (keylen > hashblocklen)
5194         {
5195         chash_start(type, use_base);
5196         chash_end(type, use_base, keyptr, keylen, keyhash);
5197         keyptr = keyhash;
5198         keylen = hashlen;
5199         }
5200
5201       /* Now make the inner and outer key values */
5202
5203       memset(innerkey, 0x36, hashblocklen);
5204       memset(outerkey, 0x5c, hashblocklen);
5205
5206       for (i = 0; i < keylen; i++)
5207         {
5208         innerkey[i] ^= keyptr[i];
5209         outerkey[i] ^= keyptr[i];
5210         }
5211
5212       /* Now do the hashes */
5213
5214       chash_start(type, use_base);
5215       chash_mid(type, use_base, innerkey);
5216       chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
5217
5218       chash_start(type, use_base);
5219       chash_mid(type, use_base, outerkey);
5220       chash_end(type, use_base, innerhash, hashlen, finalhash);
5221
5222       /* Encode the final hash as a hex string */
5223
5224       p = finalhash_hex;
5225       for (i = 0; i < hashlen; i++)
5226         {
5227         *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
5228         *p++ = hex_digits[finalhash[i] & 0x0f];
5229         }
5230
5231       DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
5232         (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
5233
5234       yield = string_catn(yield, &size, &ptr, finalhash_hex, hashlen*2);
5235       }
5236
5237     continue;
5238
5239     /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
5240     We have to save the numerical variables and restore them afterwards. */
5241
5242     case EITEM_SG:
5243       {
5244       const pcre *re;
5245       int moffset, moffsetextra, slen;
5246       int roffset;
5247       int emptyopt;
5248       const uschar *rerror;
5249       uschar *subject;
5250       uschar *sub[3];
5251       int save_expand_nmax =
5252         save_expand_strings(save_expand_nstring, save_expand_nlength);
5253
5254       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg", &resetok))
5255         {
5256         case 1: goto EXPAND_FAILED_CURLY;
5257         case 2:
5258         case 3: goto EXPAND_FAILED;
5259         }
5260
5261       /* Compile the regular expression */
5262
5263       re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
5264         NULL);
5265
5266       if (re == NULL)
5267         {
5268         expand_string_message = string_sprintf("regular expression error in "
5269           "\"%s\": %s at offset %d", sub[1], rerror, roffset);
5270         goto EXPAND_FAILED;
5271         }
5272
5273       /* Now run a loop to do the substitutions as often as necessary. It ends
5274       when there are no more matches. Take care over matches of the null string;
5275       do the same thing as Perl does. */
5276
5277       subject = sub[0];
5278       slen = Ustrlen(sub[0]);
5279       moffset = moffsetextra = 0;
5280       emptyopt = 0;
5281
5282       for (;;)
5283         {
5284         int ovector[3*(EXPAND_MAXN+1)];
5285         int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
5286           PCRE_EOPT | emptyopt, ovector, nelem(ovector));
5287         int nn;
5288         uschar *insert;
5289
5290         /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
5291         is not necessarily the end. We want to repeat the match from one
5292         character further along, but leaving the basic offset the same (for
5293         copying below). We can't be at the end of the string - that was checked
5294         before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
5295         finished; copy the remaining string and end the loop. */
5296
5297         if (n < 0)
5298           {
5299           if (emptyopt != 0)
5300             {
5301             moffsetextra = 1;
5302             emptyopt = 0;
5303             continue;
5304             }
5305           yield = string_catn(yield, &size, &ptr, subject+moffset, slen-moffset);
5306           break;
5307           }
5308
5309         /* Match - set up for expanding the replacement. */
5310
5311         if (n == 0) n = EXPAND_MAXN + 1;
5312         expand_nmax = 0;
5313         for (nn = 0; nn < n*2; nn += 2)
5314           {
5315           expand_nstring[expand_nmax] = subject + ovector[nn];
5316           expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5317           }
5318         expand_nmax--;
5319
5320         /* Copy the characters before the match, plus the expanded insertion. */
5321
5322         yield = string_catn(yield, &size, &ptr, subject + moffset,
5323           ovector[0] - moffset);
5324         insert = expand_string(sub[2]);
5325         if (insert == NULL) goto EXPAND_FAILED;
5326         yield = string_cat(yield, &size, &ptr, insert);
5327
5328         moffset = ovector[1];
5329         moffsetextra = 0;
5330         emptyopt = 0;
5331
5332         /* If we have matched an empty string, first check to see if we are at
5333         the end of the subject. If so, the loop is over. Otherwise, mimic
5334         what Perl's /g options does. This turns out to be rather cunning. First
5335         we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
5336         string at the same point. If this fails (picked up above) we advance to
5337         the next character. */
5338
5339         if (ovector[0] == ovector[1])
5340           {
5341           if (ovector[0] == slen) break;
5342           emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
5343           }
5344         }
5345
5346       /* All done - restore numerical variables. */
5347
5348       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5349         save_expand_nlength);
5350       continue;
5351       }
5352
5353     /* Handle keyed and numbered substring extraction. If the first argument
5354     consists entirely of digits, then a numerical extraction is assumed. */
5355
5356     case EITEM_EXTRACT:
5357       {
5358       int i;
5359       int j;
5360       int field_number = 1;
5361       BOOL field_number_set = FALSE;
5362       uschar *save_lookup_value = lookup_value;
5363       uschar *sub[3];
5364       int save_expand_nmax =
5365         save_expand_strings(save_expand_nstring, save_expand_nlength);
5366
5367       /* While skipping we cannot rely on the data for expansions being
5368       available (eg. $item) hence cannot decide on numeric vs. keyed.
5369       Read a maximum of 5 arguments (inclding the yes/no) */
5370
5371       if (skipping)
5372         {
5373         while (isspace(*s)) s++;
5374         for (j = 5; j > 0 && *s == '{'; j--)
5375           {
5376           if (!expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok))
5377             goto EXPAND_FAILED;                                 /*{*/
5378           if (*s++ != '}')
5379             {
5380             expand_string_message = US"missing '{' for arg of extract";
5381             goto EXPAND_FAILED_CURLY;
5382             }
5383           while (isspace(*s)) s++;
5384           }
5385         if (  Ustrncmp(s, "fail", 4) == 0
5386            && (s[4] == '}' || s[4] == ' ' || s[4] == '\t' || !s[4])
5387            )
5388           {
5389           s += 4;
5390           while (isspace(*s)) s++;
5391           }
5392         if (*s != '}')
5393           {
5394           expand_string_message = US"missing '}' closing extract";
5395           goto EXPAND_FAILED_CURLY;
5396           }
5397         }
5398
5399       else for (i = 0, j = 2; i < j; i++) /* Read the proper number of arguments */
5400         {
5401         while (isspace(*s)) s++;
5402         if (*s == '{')                                          /*}*/
5403           {
5404           sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5405           if (sub[i] == NULL) goto EXPAND_FAILED;               /*{*/
5406           if (*s++ != '}')
5407             {
5408             expand_string_message = string_sprintf(
5409               "missing '}' closing arg %d of extract", i+1);
5410             goto EXPAND_FAILED_CURLY;
5411             }
5412
5413           /* After removal of leading and trailing white space, the first
5414           argument must not be empty; if it consists entirely of digits
5415           (optionally preceded by a minus sign), this is a numerical
5416           extraction, and we expect 3 arguments. */
5417
5418           if (i == 0)
5419             {
5420             int len;
5421             int x = 0;
5422             uschar *p = sub[0];
5423
5424             while (isspace(*p)) p++;
5425             sub[0] = p;
5426
5427             len = Ustrlen(p);
5428             while (len > 0 && isspace(p[len-1])) len--;
5429             p[len] = 0;
5430
5431             if (*p == 0)
5432               {
5433               expand_string_message = US"first argument of \"extract\" must "
5434                 "not be empty";
5435               goto EXPAND_FAILED;
5436               }
5437
5438             if (*p == '-')
5439               {
5440               field_number = -1;
5441               p++;
5442               }
5443             while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
5444             if (*p == 0)
5445               {
5446               field_number *= x;
5447               j = 3;               /* Need 3 args */
5448               field_number_set = TRUE;
5449               }
5450             }
5451           }
5452         else
5453           {
5454           expand_string_message = string_sprintf(
5455             "missing '{' for arg %d of extract", i+1);
5456           goto EXPAND_FAILED_CURLY;
5457           }
5458         }
5459
5460       /* Extract either the numbered or the keyed substring into $value. If
5461       skipping, just pretend the extraction failed. */
5462
5463       lookup_value = skipping? NULL : field_number_set?
5464         expand_gettokened(field_number, sub[1], sub[2]) :
5465         expand_getkeyed(sub[0], sub[1]);
5466
5467       /* If no string follows, $value gets substituted; otherwise there can
5468       be yes/no strings, as for lookup or if. */
5469
5470       switch(process_yesno(
5471                skipping,                     /* were previously skipping */
5472                lookup_value != NULL,         /* success/failure indicator */
5473                save_lookup_value,            /* value to reset for string2 */
5474                &s,                           /* input pointer */
5475                &yield,                       /* output pointer */
5476                &size,                        /* output size */
5477                &ptr,                         /* output current point */
5478                US"extract",                  /* condition type */
5479                &resetok))
5480         {
5481         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5482         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5483         }
5484
5485       /* All done - restore numerical variables. */
5486
5487       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5488         save_expand_nlength);
5489
5490       continue;
5491       }
5492
5493     /* return the Nth item from a list */
5494
5495     case EITEM_LISTEXTRACT:
5496       {
5497       int i;
5498       int field_number = 1;
5499       uschar *save_lookup_value = lookup_value;
5500       uschar *sub[2];
5501       int save_expand_nmax =
5502         save_expand_strings(save_expand_nstring, save_expand_nlength);
5503
5504       /* Read the field & list arguments */
5505
5506       for (i = 0; i < 2; i++)
5507         {
5508         while (isspace(*s)) s++;
5509         if (*s != '{')                                  /*}*/
5510           {
5511           expand_string_message = string_sprintf(
5512             "missing '{' for arg %d of listextract", i+1);
5513           goto EXPAND_FAILED_CURLY;
5514           }
5515
5516         sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5517         if (!sub[i])     goto EXPAND_FAILED;            /*{*/
5518         if (*s++ != '}')
5519           {
5520           expand_string_message = string_sprintf(
5521             "missing '}' closing arg %d of listextract", i+1);
5522           goto EXPAND_FAILED_CURLY;
5523           }
5524
5525         /* After removal of leading and trailing white space, the first
5526         argument must be numeric and nonempty. */
5527
5528         if (i == 0)
5529           {
5530           int len;
5531           int x = 0;
5532           uschar *p = sub[0];
5533
5534           while (isspace(*p)) p++;
5535           sub[0] = p;
5536
5537           len = Ustrlen(p);
5538           while (len > 0 && isspace(p[len-1])) len--;
5539           p[len] = 0;
5540
5541           if (!*p && !skipping)
5542             {
5543             expand_string_message = US"first argument of \"listextract\" must "
5544               "not be empty";
5545             goto EXPAND_FAILED;
5546             }
5547
5548           if (*p == '-')
5549             {
5550             field_number = -1;
5551             p++;
5552             }
5553           while (*p && isdigit(*p)) x = x * 10 + *p++ - '0';
5554           if (*p)
5555             {
5556             expand_string_message = US"first argument of \"listextract\" must "
5557               "be numeric";
5558             goto EXPAND_FAILED;
5559             }
5560           field_number *= x;
5561           }
5562         }
5563
5564       /* Extract the numbered element into $value. If
5565       skipping, just pretend the extraction failed. */
5566
5567       lookup_value = skipping? NULL : expand_getlistele(field_number, sub[1]);
5568
5569       /* If no string follows, $value gets substituted; otherwise there can
5570       be yes/no strings, as for lookup or if. */
5571
5572       switch(process_yesno(
5573                skipping,                     /* were previously skipping */
5574                lookup_value != NULL,         /* success/failure indicator */
5575                save_lookup_value,            /* value to reset for string2 */
5576                &s,                           /* input pointer */
5577                &yield,                       /* output pointer */
5578                &size,                        /* output size */
5579                &ptr,                         /* output current point */
5580                US"listextract",              /* condition type */
5581                &resetok))
5582         {
5583         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5584         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5585         }
5586
5587       /* All done - restore numerical variables. */
5588
5589       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5590         save_expand_nlength);
5591
5592       continue;
5593       }
5594
5595 #ifdef SUPPORT_TLS
5596     case EITEM_CERTEXTRACT:
5597       {
5598       uschar *save_lookup_value = lookup_value;
5599       uschar *sub[2];
5600       int save_expand_nmax =
5601         save_expand_strings(save_expand_nstring, save_expand_nlength);
5602
5603       /* Read the field argument */
5604       while (isspace(*s)) s++;
5605       if (*s != '{')                                    /*}*/
5606         {
5607         expand_string_message = US"missing '{' for field arg of certextract";
5608         goto EXPAND_FAILED_CURLY;
5609         }
5610       sub[0] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5611       if (!sub[0])     goto EXPAND_FAILED;              /*{*/
5612       if (*s++ != '}')
5613         {
5614         expand_string_message = US"missing '}' closing field arg of certextract";
5615         goto EXPAND_FAILED_CURLY;
5616         }
5617       /* strip spaces fore & aft */
5618       {
5619       int len;
5620       uschar *p = sub[0];
5621
5622       while (isspace(*p)) p++;
5623       sub[0] = p;
5624
5625       len = Ustrlen(p);
5626       while (len > 0 && isspace(p[len-1])) len--;
5627       p[len] = 0;
5628       }
5629
5630       /* inspect the cert argument */
5631       while (isspace(*s)) s++;
5632       if (*s != '{')                                    /*}*/
5633         {
5634         expand_string_message = US"missing '{' for cert variable arg of certextract";
5635         goto EXPAND_FAILED_CURLY;
5636         }
5637       if (*++s != '$')
5638         {
5639         expand_string_message = US"second argument of \"certextract\" must "
5640           "be a certificate variable";
5641         goto EXPAND_FAILED;
5642         }
5643       sub[1] = expand_string_internal(s+1, TRUE, &s, skipping, FALSE, &resetok);
5644       if (!sub[1])     goto EXPAND_FAILED;              /*{*/
5645       if (*s++ != '}')
5646         {
5647         expand_string_message = US"missing '}' closing cert variable arg of certextract";
5648         goto EXPAND_FAILED_CURLY;
5649         }
5650
5651       if (skipping)
5652         lookup_value = NULL;
5653       else
5654         {
5655         lookup_value = expand_getcertele(sub[0], sub[1]);
5656         if (*expand_string_message) goto EXPAND_FAILED;
5657         }
5658       switch(process_yesno(
5659                skipping,                     /* were previously skipping */
5660                lookup_value != NULL,         /* success/failure indicator */
5661                save_lookup_value,            /* value to reset for string2 */
5662                &s,                           /* input pointer */
5663                &yield,                       /* output pointer */
5664                &size,                        /* output size */
5665                &ptr,                         /* output current point */
5666                US"certextract",              /* condition type */
5667                &resetok))
5668         {
5669         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5670         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5671         }
5672
5673       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5674         save_expand_nlength);
5675       continue;
5676       }
5677 #endif  /*SUPPORT_TLS*/
5678
5679     /* Handle list operations */
5680
5681     case EITEM_FILTER:
5682     case EITEM_MAP:
5683     case EITEM_REDUCE:
5684       {
5685       int sep = 0;
5686       int save_ptr = ptr;
5687       uschar outsep[2] = { '\0', '\0' };
5688       const uschar *list, *expr, *temp;
5689       uschar *save_iterate_item = iterate_item;
5690       uschar *save_lookup_value = lookup_value;
5691
5692       while (isspace(*s)) s++;
5693       if (*s++ != '{')
5694         {
5695         expand_string_message =
5696           string_sprintf("missing '{' for first arg of %s", name);
5697         goto EXPAND_FAILED_CURLY;
5698         }
5699
5700       list = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5701       if (list == NULL) goto EXPAND_FAILED;
5702       if (*s++ != '}')
5703         {
5704         expand_string_message =
5705           string_sprintf("missing '}' closing first arg of %s", name);
5706         goto EXPAND_FAILED_CURLY;
5707         }
5708
5709       if (item_type == EITEM_REDUCE)
5710         {
5711         uschar * t;
5712         while (isspace(*s)) s++;
5713         if (*s++ != '{')
5714           {
5715           expand_string_message = US"missing '{' for second arg of reduce";
5716           goto EXPAND_FAILED_CURLY;
5717           }
5718         t = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5719         if (!t) goto EXPAND_FAILED;
5720         lookup_value = t;
5721         if (*s++ != '}')
5722           {
5723           expand_string_message = US"missing '}' closing second arg of reduce";
5724           goto EXPAND_FAILED_CURLY;
5725           }
5726         }
5727
5728       while (isspace(*s)) s++;
5729       if (*s++ != '{')
5730         {
5731         expand_string_message =
5732           string_sprintf("missing '{' for last arg of %s", name);
5733         goto EXPAND_FAILED_CURLY;
5734         }
5735
5736       expr = s;
5737
5738       /* For EITEM_FILTER, call eval_condition once, with result discarded (as
5739       if scanning a "false" part). This allows us to find the end of the
5740       condition, because if the list is empty, we won't actually evaluate the
5741       condition for real. For EITEM_MAP and EITEM_REDUCE, do the same, using
5742       the normal internal expansion function. */
5743
5744       if (item_type == EITEM_FILTER)
5745         {
5746         temp = eval_condition(expr, &resetok, NULL);
5747         if (temp != NULL) s = temp;
5748         }
5749       else
5750         temp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
5751
5752       if (temp == NULL)
5753         {
5754         expand_string_message = string_sprintf("%s inside \"%s\" item",
5755           expand_string_message, name);
5756         goto EXPAND_FAILED;
5757         }
5758
5759       while (isspace(*s)) s++;
5760       if (*s++ != '}')
5761         {                                               /*{*/
5762         expand_string_message = string_sprintf("missing } at end of condition "
5763           "or expression inside \"%s\"", name);
5764         goto EXPAND_FAILED;
5765         }
5766
5767       while (isspace(*s)) s++;                          /*{*/
5768       if (*s++ != '}')
5769         {                                               /*{*/
5770         expand_string_message = string_sprintf("missing } at end of \"%s\"",
5771           name);
5772         goto EXPAND_FAILED;
5773         }
5774
5775       /* If we are skipping, we can now just move on to the next item. When
5776       processing for real, we perform the iteration. */
5777
5778       if (skipping) continue;
5779       while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
5780         {
5781         *outsep = (uschar)sep;      /* Separator as a string */
5782
5783         DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
5784
5785         if (item_type == EITEM_FILTER)
5786           {
5787           BOOL condresult;
5788           if (eval_condition(expr, &resetok, &condresult) == NULL)
5789             {
5790             iterate_item = save_iterate_item;
5791             lookup_value = save_lookup_value;
5792             expand_string_message = string_sprintf("%s inside \"%s\" condition",
5793               expand_string_message, name);
5794             goto EXPAND_FAILED;
5795             }
5796           DEBUG(D_expand) debug_printf("%s: condition is %s\n", name,
5797             condresult? "true":"false");
5798           if (condresult)
5799             temp = iterate_item;    /* TRUE => include this item */
5800           else
5801             continue;               /* FALSE => skip this item */
5802           }
5803
5804         /* EITEM_MAP and EITEM_REDUCE */
5805
5806         else
5807           {
5808           uschar * t = expand_string_internal(expr, TRUE, NULL, skipping, TRUE, &resetok);
5809           temp = t;
5810           if (temp == NULL)
5811             {
5812             iterate_item = save_iterate_item;
5813             expand_string_message = string_sprintf("%s inside \"%s\" item",
5814               expand_string_message, name);
5815             goto EXPAND_FAILED;
5816             }
5817           if (item_type == EITEM_REDUCE)
5818             {
5819             lookup_value = t;         /* Update the value of $value */
5820             continue;                 /* and continue the iteration */
5821             }
5822           }
5823
5824         /* We reach here for FILTER if the condition is true, always for MAP,
5825         and never for REDUCE. The value in "temp" is to be added to the output
5826         list that is being created, ensuring that any occurrences of the
5827         separator character are doubled. Unless we are dealing with the first
5828         item of the output list, add in a space if the new item begins with the
5829         separator character, or is an empty string. */
5830
5831         if (ptr != save_ptr && (temp[0] == *outsep || temp[0] == 0))
5832           yield = string_catn(yield, &size, &ptr, US" ", 1);
5833
5834         /* Add the string in "temp" to the output list that we are building,
5835         This is done in chunks by searching for the separator character. */
5836
5837         for (;;)
5838           {
5839           size_t seglen = Ustrcspn(temp, outsep);
5840
5841           yield = string_catn(yield, &size, &ptr, temp, seglen + 1);
5842
5843           /* If we got to the end of the string we output one character
5844           too many; backup and end the loop. Otherwise arrange to double the
5845           separator. */
5846
5847           if (temp[seglen] == '\0') { ptr--; break; }
5848           yield = string_catn(yield, &size, &ptr, outsep, 1);
5849           temp += seglen + 1;
5850           }
5851
5852         /* Output a separator after the string: we will remove the redundant
5853         final one at the end. */
5854
5855         yield = string_catn(yield, &size, &ptr, outsep, 1);
5856         }   /* End of iteration over the list loop */
5857
5858       /* REDUCE has generated no output above: output the final value of
5859       $value. */
5860
5861       if (item_type == EITEM_REDUCE)
5862         {
5863         yield = string_cat(yield, &size, &ptr, lookup_value);
5864         lookup_value = save_lookup_value;  /* Restore $value */
5865         }
5866
5867       /* FILTER and MAP generate lists: if they have generated anything, remove
5868       the redundant final separator. Even though an empty item at the end of a
5869       list does not count, this is tidier. */
5870
5871       else if (ptr != save_ptr) ptr--;
5872
5873       /* Restore preserved $item */
5874
5875       iterate_item = save_iterate_item;
5876       continue;
5877       }
5878
5879     case EITEM_SORT:
5880       {
5881       int sep = 0;
5882       const uschar *srclist, *cmp, *xtract;
5883       uschar *srcitem;
5884       const uschar *dstlist = NULL, *dstkeylist = NULL;
5885       uschar * tmp;
5886       uschar *save_iterate_item = iterate_item;
5887
5888       while (isspace(*s)) s++;
5889       if (*s++ != '{')
5890         {
5891         expand_string_message = US"missing '{' for list arg of sort";
5892         goto EXPAND_FAILED_CURLY;
5893         }
5894
5895       srclist = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5896       if (!srclist) goto EXPAND_FAILED;
5897       if (*s++ != '}')
5898         {
5899         expand_string_message = US"missing '}' closing list arg of sort";
5900         goto EXPAND_FAILED_CURLY;
5901         }
5902
5903       while (isspace(*s)) s++;
5904       if (*s++ != '{')
5905         {
5906         expand_string_message = US"missing '{' for comparator arg of sort";
5907         goto EXPAND_FAILED_CURLY;
5908         }
5909
5910       cmp = expand_string_internal(s, TRUE, &s, skipping, FALSE, &resetok);
5911       if (!cmp) goto EXPAND_FAILED;
5912       if (*s++ != '}')
5913         {
5914         expand_string_message = US"missing '}' closing comparator arg of sort";
5915         goto EXPAND_FAILED_CURLY;
5916         }
5917
5918       while (isspace(*s)) s++;
5919       if (*s++ != '{')
5920         {
5921         expand_string_message = US"missing '{' for extractor arg of sort";
5922         goto EXPAND_FAILED_CURLY;
5923         }
5924
5925       xtract = s;
5926       tmp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
5927       if (!tmp) goto EXPAND_FAILED;
5928       xtract = string_copyn(xtract, s - xtract);
5929
5930       if (*s++ != '}')
5931         {
5932         expand_string_message = US"missing '}' closing extractor arg of sort";
5933         goto EXPAND_FAILED_CURLY;
5934         }
5935                                                         /*{*/
5936       if (*s++ != '}')
5937         {                                               /*{*/
5938         expand_string_message = US"missing } at end of \"sort\"";
5939         goto EXPAND_FAILED;
5940         }
5941
5942       if (skipping) continue;
5943
5944       while ((srcitem = string_nextinlist(&srclist, &sep, NULL, 0)))
5945         {
5946         uschar * dstitem;
5947         uschar * newlist = NULL;
5948         uschar * newkeylist = NULL;
5949         uschar * srcfield;
5950
5951         DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, srcitem);
5952
5953         /* extract field for comparisons */
5954         iterate_item = srcitem;
5955         if (  !(srcfield = expand_string_internal(xtract, FALSE, NULL, FALSE,
5956                                           TRUE, &resetok))
5957            || !*srcfield)
5958           {
5959           expand_string_message = string_sprintf(
5960               "field-extract in sort: \"%s\"", xtract);
5961           goto EXPAND_FAILED;
5962           }
5963
5964         /* Insertion sort */
5965
5966         /* copy output list until new-item < list-item */
5967         while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
5968           {
5969           uschar * dstfield;
5970           uschar * expr;
5971           BOOL before;
5972
5973           /* field for comparison */
5974           if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
5975             goto sort_mismatch;
5976
5977           /* build and run condition string */
5978           expr = string_sprintf("%s{%s}{%s}", cmp, srcfield, dstfield);
5979
5980           DEBUG(D_expand) debug_printf("%s: cond = \"%s\"\n", name, expr);
5981           if (!eval_condition(expr, &resetok, &before))
5982             {
5983             expand_string_message = string_sprintf("comparison in sort: %s",
5984                 expr);
5985             goto EXPAND_FAILED;
5986             }
5987
5988           if (before)
5989             {
5990             /* New-item sorts before this dst-item.  Append new-item,
5991             then dst-item, then remainder of dst list. */
5992
5993             newlist = string_append_listele(newlist, sep, srcitem);
5994             newkeylist = string_append_listele(newkeylist, sep, srcfield);
5995             srcitem = NULL;
5996
5997             newlist = string_append_listele(newlist, sep, dstitem);
5998             newkeylist = string_append_listele(newkeylist, sep, dstfield);
5999
6000             while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
6001               {
6002               if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
6003                 goto sort_mismatch;
6004               newlist = string_append_listele(newlist, sep, dstitem);
6005               newkeylist = string_append_listele(newkeylist, sep, dstfield);
6006               }
6007
6008             break;
6009             }
6010
6011           newlist = string_append_listele(newlist, sep, dstitem);
6012           newkeylist = string_append_listele(newkeylist, sep, dstfield);
6013           }
6014
6015         /* If we ran out of dstlist without consuming srcitem, append it */
6016         if (srcitem)
6017           {
6018           newlist = string_append_listele(newlist, sep, srcitem);
6019           newkeylist = string_append_listele(newkeylist, sep, srcfield);
6020           }
6021
6022         dstlist = newlist;
6023         dstkeylist = newkeylist;
6024
6025         DEBUG(D_expand) debug_printf("%s: dstlist = \"%s\"\n", name, dstlist);
6026         DEBUG(D_expand) debug_printf("%s: dstkeylist = \"%s\"\n", name, dstkeylist);
6027         }
6028
6029       if (dstlist)
6030         yield = string_cat(yield, &size, &ptr, dstlist);
6031
6032       /* Restore preserved $item */
6033       iterate_item = save_iterate_item;
6034       continue;
6035
6036       sort_mismatch:
6037         expand_string_message = US"Internal error in sort (list mismatch)";
6038         goto EXPAND_FAILED;
6039       }
6040
6041
6042     /* If ${dlfunc } support is configured, handle calling dynamically-loaded
6043     functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
6044     or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
6045     a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
6046
6047     #define EXPAND_DLFUNC_MAX_ARGS 8
6048
6049     case EITEM_DLFUNC:
6050 #ifndef EXPAND_DLFUNC
6051       expand_string_message = US"\"${dlfunc\" encountered, but this facility "  /*}*/
6052         "is not included in this binary";
6053       goto EXPAND_FAILED;
6054
6055 #else   /* EXPAND_DLFUNC */
6056       {
6057       tree_node *t;
6058       exim_dlfunc_t *func;
6059       uschar *result;
6060       int status, argc;
6061       uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
6062
6063       if ((expand_forbid & RDO_DLFUNC) != 0)
6064         {
6065         expand_string_message =
6066           US"dynamically-loaded functions are not permitted";
6067         goto EXPAND_FAILED;
6068         }
6069
6070       switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
6071            TRUE, US"dlfunc", &resetok))
6072         {
6073         case 1: goto EXPAND_FAILED_CURLY;
6074         case 2:
6075         case 3: goto EXPAND_FAILED;
6076         }
6077
6078       /* If skipping, we don't actually do anything */
6079
6080       if (skipping) continue;
6081
6082       /* Look up the dynamically loaded object handle in the tree. If it isn't
6083       found, dlopen() the file and put the handle in the tree for next time. */
6084
6085       t = tree_search(dlobj_anchor, argv[0]);
6086       if (t == NULL)
6087         {
6088         void *handle = dlopen(CS argv[0], RTLD_LAZY);
6089         if (handle == NULL)
6090           {
6091           expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
6092             argv[0], dlerror());
6093           log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
6094           goto EXPAND_FAILED;
6095           }
6096         t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
6097         Ustrcpy(t->name, argv[0]);
6098         t->data.ptr = handle;
6099         (void)tree_insertnode(&dlobj_anchor, t);
6100         }
6101
6102       /* Having obtained the dynamically loaded object handle, look up the
6103       function pointer. */
6104
6105       func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
6106       if (func == NULL)
6107         {
6108         expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
6109           "%s", argv[1], argv[0], dlerror());
6110         log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
6111         goto EXPAND_FAILED;
6112         }
6113
6114       /* Call the function and work out what to do with the result. If it
6115       returns OK, we have a replacement string; if it returns DEFER then
6116       expansion has failed in a non-forced manner; if it returns FAIL then
6117       failure was forced; if it returns ERROR or any other value there's a
6118       problem, so panic slightly. In any case, assume that the function has
6119       side-effects on the store that must be preserved. */
6120
6121       resetok = FALSE;
6122       result = NULL;
6123       for (argc = 0; argv[argc] != NULL; argc++);
6124       status = func(&result, argc - 2, &argv[2]);
6125       if(status == OK)
6126         {
6127         if (result == NULL) result = US"";
6128         yield = string_cat(yield, &size, &ptr, result);
6129         continue;
6130         }
6131       else
6132         {
6133         expand_string_message = result == NULL ? US"(no message)" : result;
6134         if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
6135           else if(status != FAIL)
6136             log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
6137               argv[0], argv[1], status, expand_string_message);
6138         goto EXPAND_FAILED;
6139         }
6140       }
6141 #endif /* EXPAND_DLFUNC */
6142
6143     case EITEM_ENV:     /* ${env {name} {val_if_found} {val_if_unfound}} */
6144       {
6145       uschar * key;
6146       uschar *save_lookup_value = lookup_value;
6147
6148       while (isspace(*s)) s++;
6149       if (*s != '{')                                    /*}*/
6150         goto EXPAND_FAILED;
6151
6152       key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6153       if (!key) goto EXPAND_FAILED;                     /*{*/
6154       if (*s++ != '}')
6155         {
6156         expand_string_message = US"missing '{' for name arg of env";
6157         goto EXPAND_FAILED_CURLY;
6158         }
6159
6160       lookup_value = US getenv(CS key);
6161
6162       switch(process_yesno(
6163                skipping,                     /* were previously skipping */
6164                lookup_value != NULL,         /* success/failure indicator */
6165                save_lookup_value,            /* value to reset for string2 */
6166                &s,                           /* input pointer */
6167                &yield,                       /* output pointer */
6168                &size,                        /* output size */
6169                &ptr,                         /* output current point */
6170                US"env",                      /* condition type */
6171                &resetok))
6172         {
6173         case 1: goto EXPAND_FAILED;          /* when all is well, the */
6174         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
6175         }
6176       continue;
6177       }
6178     }   /* EITEM_* switch */
6179
6180   /* Control reaches here if the name is not recognized as one of the more
6181   complicated expansion items. Check for the "operator" syntax (name terminated
6182   by a colon). Some of the operators have arguments, separated by _ from the
6183   name. */
6184
6185   if (*s == ':')
6186     {
6187     int c;
6188     uschar *arg = NULL;
6189     uschar *sub;
6190     var_entry *vp = NULL;
6191
6192     /* Owing to an historical mis-design, an underscore may be part of the
6193     operator name, or it may introduce arguments.  We therefore first scan the
6194     table of names that contain underscores. If there is no match, we cut off
6195     the arguments and then scan the main table. */
6196
6197     if ((c = chop_match(name, op_table_underscore,
6198                         nelem(op_table_underscore))) < 0)
6199       {
6200       arg = Ustrchr(name, '_');
6201       if (arg != NULL) *arg = 0;
6202       c = chop_match(name, op_table_main, nelem(op_table_main));
6203       if (c >= 0) c += nelem(op_table_underscore);
6204       if (arg != NULL) *arg++ = '_';   /* Put back for error messages */
6205       }
6206
6207     /* Deal specially with operators that might take a certificate variable
6208     as we do not want to do the usual expansion. For most, expand the string.*/
6209     switch(c)
6210       {
6211 #ifdef SUPPORT_TLS
6212       case EOP_MD5:
6213       case EOP_SHA1:
6214       case EOP_SHA256:
6215       case EOP_BASE64:
6216         if (s[1] == '$')
6217           {
6218           const uschar * s1 = s;
6219           sub = expand_string_internal(s+2, TRUE, &s1, skipping,
6220                   FALSE, &resetok);
6221           if (!sub)       goto EXPAND_FAILED;           /*{*/
6222           if (*s1 != '}')
6223             {
6224             expand_string_message =
6225               string_sprintf("missing '}' closing cert arg of %s", name);
6226             goto EXPAND_FAILED_CURLY;
6227             }
6228           if ((vp = find_var_ent(sub)) && vp->type == vtype_cert)
6229             {
6230             s = s1+1;
6231             break;
6232             }
6233           vp = NULL;
6234           }
6235         /*FALLTHROUGH*/
6236 #endif
6237       default:
6238         sub = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6239         if (!sub) goto EXPAND_FAILED;
6240         s++;
6241         break;
6242       }
6243
6244     /* If we are skipping, we don't need to perform the operation at all.
6245     This matters for operations like "mask", because the data may not be
6246     in the correct format when skipping. For example, the expression may test
6247     for the existence of $sender_host_address before trying to mask it. For
6248     other operations, doing them may not fail, but it is a waste of time. */
6249
6250     if (skipping && c >= 0) continue;
6251
6252     /* Otherwise, switch on the operator type */
6253
6254     switch(c)
6255       {
6256       case EOP_BASE62:
6257         {
6258         uschar *t;
6259         unsigned long int n = Ustrtoul(sub, &t, 10);
6260         if (*t != 0)
6261           {
6262           expand_string_message = string_sprintf("argument for base62 "
6263             "operator is \"%s\", which is not a decimal number", sub);
6264           goto EXPAND_FAILED;
6265           }
6266         t = string_base62(n);
6267         yield = string_cat(yield, &size, &ptr, t);
6268         continue;
6269         }
6270
6271       /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
6272
6273       case EOP_BASE62D:
6274         {
6275         uschar buf[16];
6276         uschar *tt = sub;
6277         unsigned long int n = 0;
6278         while (*tt != 0)
6279           {
6280           uschar *t = Ustrchr(base62_chars, *tt++);
6281           if (t == NULL)
6282             {
6283             expand_string_message = string_sprintf("argument for base62d "
6284               "operator is \"%s\", which is not a base %d number", sub,
6285               BASE_62);
6286             goto EXPAND_FAILED;
6287             }
6288           n = n * BASE_62 + (t - base62_chars);
6289           }
6290         (void)sprintf(CS buf, "%ld", n);
6291         yield = string_cat(yield, &size, &ptr, buf);
6292         continue;
6293         }
6294
6295       case EOP_EXPAND:
6296         {
6297         uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping, TRUE, &resetok);
6298         if (expanded == NULL)
6299           {
6300           expand_string_message =
6301             string_sprintf("internal expansion of \"%s\" failed: %s", sub,
6302               expand_string_message);
6303           goto EXPAND_FAILED;
6304           }
6305         yield = string_cat(yield, &size, &ptr, expanded);
6306         continue;
6307         }
6308
6309       case EOP_LC:
6310         {
6311         int count = 0;
6312         uschar *t = sub - 1;
6313         while (*(++t) != 0) { *t = tolower(*t); count++; }
6314         yield = string_catn(yield, &size, &ptr, sub, count);
6315         continue;
6316         }
6317
6318       case EOP_UC:
6319         {
6320         int count = 0;
6321         uschar *t = sub - 1;
6322         while (*(++t) != 0) { *t = toupper(*t); count++; }
6323         yield = string_catn(yield, &size, &ptr, sub, count);
6324         continue;
6325         }
6326
6327       case EOP_MD5:
6328 #ifdef SUPPORT_TLS
6329         if (vp && *(void **)vp->value)
6330           {
6331           uschar * cp = tls_cert_fprt_md5(*(void **)vp->value);
6332           yield = string_cat(yield, &size, &ptr, cp);
6333           }
6334         else
6335 #endif
6336           {
6337           md5 base;
6338           uschar digest[16];
6339           int j;
6340           char st[33];
6341           md5_start(&base);
6342           md5_end(&base, sub, Ustrlen(sub), digest);
6343           for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
6344           yield = string_cat(yield, &size, &ptr, US st);
6345           }
6346         continue;
6347
6348       case EOP_SHA1:
6349 #ifdef SUPPORT_TLS
6350         if (vp && *(void **)vp->value)
6351           {
6352           uschar * cp = tls_cert_fprt_sha1(*(void **)vp->value);
6353           yield = string_cat(yield, &size, &ptr, cp);
6354           }
6355         else
6356 #endif
6357           {
6358           hctx h;
6359           uschar digest[20];
6360           int j;
6361           char st[41];
6362           sha1_start(&h);
6363           sha1_end(&h, sub, Ustrlen(sub), digest);
6364           for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
6365           yield = string_catn(yield, &size, &ptr, US st, 40);
6366           }
6367         continue;
6368
6369       case EOP_SHA256:
6370 #ifdef SUPPORT_TLS
6371         if (vp && *(void **)vp->value)
6372           {
6373           uschar * cp = tls_cert_fprt_sha256(*(void **)vp->value);
6374           yield = string_cat(yield, &size, &ptr, cp);
6375           }
6376         else
6377           {
6378           hctx h;
6379           blob b;
6380           char st[3];
6381
6382           exim_sha_init(&h, HASH_SHA256);
6383           exim_sha_update(&h, sub, Ustrlen(sub));
6384           exim_sha_finish(&h, &b);
6385           while (b.len-- > 0)
6386             {
6387             sprintf(st, "%02X", *b.data++);
6388             yield = string_catn(yield, &size, &ptr, US st, 2);
6389             }
6390           }
6391 #else
6392           expand_string_message = US"sha256 only supported with TLS";
6393 #endif
6394         continue;
6395
6396       /* Convert hex encoding to base64 encoding */
6397
6398       case EOP_HEX2B64:
6399         {
6400         int c = 0;
6401         int b = -1;
6402         uschar *in = sub;
6403         uschar *out = sub;
6404         uschar *enc;
6405
6406         for (enc = sub; *enc != 0; enc++)
6407           {
6408           if (!isxdigit(*enc))
6409             {
6410             expand_string_message = string_sprintf("\"%s\" is not a hex "
6411               "string", sub);
6412             goto EXPAND_FAILED;
6413             }
6414           c++;
6415           }
6416
6417         if ((c & 1) != 0)
6418           {
6419           expand_string_message = string_sprintf("\"%s\" contains an odd "
6420             "number of characters", sub);
6421           goto EXPAND_FAILED;
6422           }
6423
6424         while ((c = *in++) != 0)
6425           {
6426           if (isdigit(c)) c -= '0';
6427           else c = toupper(c) - 'A' + 10;
6428           if (b == -1)
6429             {
6430             b = c << 4;
6431             }
6432           else
6433             {
6434             *out++ = b | c;
6435             b = -1;
6436             }
6437           }
6438
6439         enc = b64encode(sub, out - sub);
6440         yield = string_cat(yield, &size, &ptr, enc);
6441         continue;
6442         }
6443
6444       /* Convert octets outside 0x21..0x7E to \xXX form */
6445
6446       case EOP_HEXQUOTE:
6447         {
6448         uschar *t = sub - 1;
6449         while (*(++t) != 0)
6450           {
6451           if (*t < 0x21 || 0x7E < *t)
6452             yield = string_catn(yield, &size, &ptr,
6453               string_sprintf("\\x%02x", *t), 4);
6454           else
6455             yield = string_catn(yield, &size, &ptr, t, 1);
6456           }
6457         continue;
6458         }
6459
6460       /* count the number of list elements */
6461
6462       case EOP_LISTCOUNT:
6463         {
6464         int cnt = 0;
6465         int sep = 0;
6466         uschar * cp;
6467         uschar buffer[256];
6468
6469         while (string_nextinlist(CUSS &sub, &sep, buffer, sizeof(buffer)) != NULL) cnt++;
6470         cp = string_sprintf("%d", cnt);
6471         yield = string_cat(yield, &size, &ptr, cp);
6472         continue;
6473         }
6474
6475       /* expand a named list given the name */
6476       /* handles nested named lists; requotes as colon-sep list */
6477
6478       case EOP_LISTNAMED:
6479         {
6480         tree_node *t = NULL;
6481         const uschar * list;
6482         int sep = 0;
6483         uschar * item;
6484         uschar * suffix = US"";
6485         BOOL needsep = FALSE;
6486         uschar buffer[256];
6487
6488         if (*sub == '+') sub++;
6489         if (arg == NULL)        /* no-argument version */
6490           {
6491           if (!(t = tree_search(addresslist_anchor, sub)) &&
6492               !(t = tree_search(domainlist_anchor,  sub)) &&
6493               !(t = tree_search(hostlist_anchor,    sub)))
6494             t = tree_search(localpartlist_anchor, sub);
6495           }
6496         else switch(*arg)       /* specific list-type version */
6497           {
6498           case 'a': t = tree_search(addresslist_anchor,   sub); suffix = US"_a"; break;
6499           case 'd': t = tree_search(domainlist_anchor,    sub); suffix = US"_d"; break;
6500           case 'h': t = tree_search(hostlist_anchor,      sub); suffix = US"_h"; break;
6501           case 'l': t = tree_search(localpartlist_anchor, sub); suffix = US"_l"; break;
6502           default:
6503             expand_string_message = string_sprintf("bad suffix on \"list\" operator");
6504             goto EXPAND_FAILED;
6505           }
6506
6507         if(!t)
6508           {
6509           expand_string_message = string_sprintf("\"%s\" is not a %snamed list",
6510             sub, !arg?""
6511               : *arg=='a'?"address "
6512               : *arg=='d'?"domain "
6513               : *arg=='h'?"host "
6514               : *arg=='l'?"localpart "
6515               : 0);
6516           goto EXPAND_FAILED;
6517           }
6518
6519         list = ((namedlist_block *)(t->data.ptr))->string;
6520
6521         while ((item = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
6522           {
6523           uschar * buf = US" : ";
6524           if (needsep)
6525             yield = string_catn(yield, &size, &ptr, buf, 3);
6526           else
6527             needsep = TRUE;
6528
6529           if (*item == '+')     /* list item is itself a named list */
6530             {
6531             uschar * sub = string_sprintf("${listnamed%s:%s}", suffix, item);
6532             item = expand_string_internal(sub, FALSE, NULL, FALSE, TRUE, &resetok);
6533             }
6534           else if (sep != ':')  /* item from non-colon-sep list, re-quote for colon list-separator */
6535             {
6536             char * cp;
6537             char tok[3];
6538             tok[0] = sep; tok[1] = ':'; tok[2] = 0;
6539             while ((cp= strpbrk((const char *)item, tok)))
6540               {
6541               yield = string_catn(yield, &size, &ptr, item, cp-(char *)item);
6542               if (*cp++ == ':') /* colon in a non-colon-sep list item, needs doubling */
6543                 {
6544                 yield = string_catn(yield, &size, &ptr, US"::", 2);
6545                 item = (uschar *)cp;
6546                 }
6547               else              /* sep in item; should already be doubled; emit once */
6548                 {
6549                 yield = string_catn(yield, &size, &ptr, (uschar *)tok, 1);
6550                 if (*cp == sep) cp++;
6551                 item = (uschar *)cp;
6552                 }
6553               }
6554             }
6555           yield = string_cat(yield, &size, &ptr, item);
6556           }
6557         continue;
6558         }
6559
6560       /* mask applies a mask to an IP address; for example the result of
6561       ${mask:131.111.10.206/28} is 131.111.10.192/28. */
6562
6563       case EOP_MASK:
6564         {
6565         int count;
6566         uschar *endptr;
6567         int binary[4];
6568         int mask, maskoffset;
6569         int type = string_is_ip_address(sub, &maskoffset);
6570         uschar buffer[64];
6571
6572         if (type == 0)
6573           {
6574           expand_string_message = string_sprintf("\"%s\" is not an IP address",
6575            sub);
6576           goto EXPAND_FAILED;
6577           }
6578
6579         if (maskoffset == 0)
6580           {
6581           expand_string_message = string_sprintf("missing mask value in \"%s\"",
6582             sub);
6583           goto EXPAND_FAILED;
6584           }
6585
6586         mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
6587
6588         if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
6589           {
6590           expand_string_message = string_sprintf("mask value too big in \"%s\"",
6591             sub);
6592           goto EXPAND_FAILED;
6593           }
6594
6595         /* Convert the address to binary integer(s) and apply the mask */
6596
6597         sub[maskoffset] = 0;
6598         count = host_aton(sub, binary);
6599         host_mask(count, binary, mask);
6600
6601         /* Convert to masked textual format and add to output. */
6602
6603         yield = string_catn(yield, &size, &ptr, buffer,
6604           host_nmtoa(count, binary, mask, buffer, '.'));
6605         continue;
6606         }
6607
6608       case EOP_IPV6NORM:
6609       case EOP_IPV6DENORM:
6610         {
6611         int type = string_is_ip_address(sub, NULL);
6612         int binary[4];
6613         uschar buffer[44];
6614
6615         switch (type)
6616           {
6617           case 6:
6618             (void) host_aton(sub, binary);
6619             break;
6620
6621           case 4:       /* convert to IPv4-mapped IPv6 */
6622             binary[0] = binary[1] = 0;
6623             binary[2] = 0x0000ffff;
6624             (void) host_aton(sub, binary+3);
6625             break;
6626
6627           case 0:
6628             expand_string_message =
6629               string_sprintf("\"%s\" is not an IP address", sub);
6630             goto EXPAND_FAILED;
6631           }
6632
6633         yield = string_catn(yield, &size, &ptr, buffer,
6634                   c == EOP_IPV6NORM
6635                     ? ipv6_nmtoa(binary, buffer)
6636                     : host_nmtoa(4, binary, -1, buffer, ':')
6637                   );
6638         continue;
6639         }
6640
6641       case EOP_ADDRESS:
6642       case EOP_LOCAL_PART:
6643       case EOP_DOMAIN:
6644         {
6645         uschar *error;
6646         int start, end, domain;
6647         uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
6648           FALSE);
6649         if (t != NULL)
6650           {
6651           if (c != EOP_DOMAIN)
6652             {
6653             if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
6654             yield = string_catn(yield, &size, &ptr, sub+start, end-start);
6655             }
6656           else if (domain != 0)
6657             {
6658             domain += start;
6659             yield = string_catn(yield, &size, &ptr, sub+domain, end-domain);
6660             }
6661           }
6662         continue;
6663         }
6664
6665       case EOP_ADDRESSES:
6666         {
6667         uschar outsep[2] = { ':', '\0' };
6668         uschar *address, *error;
6669         int save_ptr = ptr;
6670         int start, end, domain;  /* Not really used */
6671
6672         while (isspace(*sub)) sub++;
6673         if (*sub == '>') { *outsep = *++sub; ++sub; }
6674         parse_allow_group = TRUE;
6675
6676         for (;;)
6677           {
6678           uschar *p = parse_find_address_end(sub, FALSE);
6679           uschar saveend = *p;
6680           *p = '\0';
6681           address = parse_extract_address(sub, &error, &start, &end, &domain,
6682             FALSE);
6683           *p = saveend;
6684
6685           /* Add the address to the output list that we are building. This is
6686           done in chunks by searching for the separator character. At the
6687           start, unless we are dealing with the first address of the output
6688           list, add in a space if the new address begins with the separator
6689           character, or is an empty string. */
6690
6691           if (address != NULL)
6692             {
6693             if (ptr != save_ptr && address[0] == *outsep)
6694               yield = string_catn(yield, &size, &ptr, US" ", 1);
6695
6696             for (;;)
6697               {
6698               size_t seglen = Ustrcspn(address, outsep);
6699               yield = string_catn(yield, &size, &ptr, address, seglen + 1);
6700
6701               /* If we got to the end of the string we output one character
6702               too many. */
6703
6704               if (address[seglen] == '\0') { ptr--; break; }
6705               yield = string_catn(yield, &size, &ptr, outsep, 1);
6706               address += seglen + 1;
6707               }
6708
6709             /* Output a separator after the string: we will remove the
6710             redundant final one at the end. */
6711
6712             yield = string_catn(yield, &size, &ptr, outsep, 1);
6713             }
6714
6715           if (saveend == '\0') break;
6716           sub = p + 1;
6717           }
6718
6719         /* If we have generated anything, remove the redundant final
6720         separator. */
6721
6722         if (ptr != save_ptr) ptr--;
6723         parse_allow_group = FALSE;
6724         continue;
6725         }
6726
6727
6728       /* quote puts a string in quotes if it is empty or contains anything
6729       other than alphamerics, underscore, dot, or hyphen.
6730
6731       quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
6732       be quoted in order to be a valid local part.
6733
6734       In both cases, newlines and carriage returns are converted into \n and \r
6735       respectively */
6736
6737       case EOP_QUOTE:
6738       case EOP_QUOTE_LOCAL_PART:
6739       if (arg == NULL)
6740         {
6741         BOOL needs_quote = (*sub == 0);      /* TRUE for empty string */
6742         uschar *t = sub - 1;
6743
6744         if (c == EOP_QUOTE)
6745           {
6746           while (!needs_quote && *(++t) != 0)
6747             needs_quote = !isalnum(*t) && !strchr("_-.", *t);
6748           }
6749         else  /* EOP_QUOTE_LOCAL_PART */
6750           {
6751           while (!needs_quote && *(++t) != 0)
6752             needs_quote = !isalnum(*t) &&
6753               strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
6754               (*t != '.' || t == sub || t[1] == 0);
6755           }
6756
6757         if (needs_quote)
6758           {
6759           yield = string_catn(yield, &size, &ptr, US"\"", 1);
6760           t = sub - 1;
6761           while (*(++t) != 0)
6762             {
6763             if (*t == '\n')
6764               yield = string_catn(yield, &size, &ptr, US"\\n", 2);
6765             else if (*t == '\r')
6766               yield = string_catn(yield, &size, &ptr, US"\\r", 2);
6767             else
6768               {
6769               if (*t == '\\' || *t == '"')
6770                 yield = string_catn(yield, &size, &ptr, US"\\", 1);
6771               yield = string_catn(yield, &size, &ptr, t, 1);
6772               }
6773             }
6774           yield = string_catn(yield, &size, &ptr, US"\"", 1);
6775           }
6776         else yield = string_cat(yield, &size, &ptr, sub);
6777         continue;
6778         }
6779
6780       /* quote_lookuptype does lookup-specific quoting */
6781
6782       else
6783         {
6784         int n;
6785         uschar *opt = Ustrchr(arg, '_');
6786
6787         if (opt != NULL) *opt++ = 0;
6788
6789         n = search_findtype(arg, Ustrlen(arg));
6790         if (n < 0)
6791           {
6792           expand_string_message = search_error_message;
6793           goto EXPAND_FAILED;
6794           }
6795
6796         if (lookup_list[n]->quote != NULL)
6797           sub = (lookup_list[n]->quote)(sub, opt);
6798         else if (opt != NULL) sub = NULL;
6799
6800         if (sub == NULL)
6801           {
6802           expand_string_message = string_sprintf(
6803             "\"%s\" unrecognized after \"${quote_%s\"",
6804             opt, arg);
6805           goto EXPAND_FAILED;
6806           }
6807
6808         yield = string_cat(yield, &size, &ptr, sub);
6809         continue;
6810         }
6811
6812       /* rx quote sticks in \ before any non-alphameric character so that
6813       the insertion works in a regular expression. */
6814
6815       case EOP_RXQUOTE:
6816         {
6817         uschar *t = sub - 1;
6818         while (*(++t) != 0)
6819           {
6820           if (!isalnum(*t))
6821             yield = string_catn(yield, &size, &ptr, US"\\", 1);
6822           yield = string_catn(yield, &size, &ptr, t, 1);
6823           }
6824         continue;
6825         }
6826
6827       /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
6828       prescribed by the RFC, if there are characters that need to be encoded */
6829
6830       case EOP_RFC2047:
6831         {
6832         uschar buffer[2048];
6833         const uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
6834           buffer, sizeof(buffer), FALSE);
6835         yield = string_cat(yield, &size, &ptr, string);
6836         continue;
6837         }
6838
6839       /* RFC 2047 decode */
6840
6841       case EOP_RFC2047D:
6842         {
6843         int len;
6844         uschar *error;
6845         uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
6846           headers_charset, '?', &len, &error);
6847         if (error != NULL)
6848           {
6849           expand_string_message = error;
6850           goto EXPAND_FAILED;
6851           }
6852         yield = string_catn(yield, &size, &ptr, decoded, len);
6853         continue;
6854         }
6855
6856       /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
6857       underscores */
6858
6859       case EOP_FROM_UTF8:
6860         {
6861         while (*sub != 0)
6862           {
6863           int c;
6864           uschar buff[4];
6865           GETUTF8INC(c, sub);
6866           if (c > 255) c = '_';
6867           buff[0] = c;
6868           yield = string_catn(yield, &size, &ptr, buff, 1);
6869           }
6870         continue;
6871         }
6872
6873           /* replace illegal UTF-8 sequences by replacement character  */
6874
6875       #define UTF8_REPLACEMENT_CHAR US"?"
6876
6877       case EOP_UTF8CLEAN:
6878         {
6879         int seq_len = 0, index = 0;
6880         int bytes_left = 0;
6881         long codepoint = -1;
6882         uschar seq_buff[4];                     /* accumulate utf-8 here */
6883
6884         while (*sub != 0)
6885           {
6886           int complete = 0;
6887           uschar c = *sub++;
6888
6889           if (bytes_left)
6890             {
6891             if ((c & 0xc0) != 0x80)
6892                     /* wrong continuation byte; invalidate all bytes */
6893               complete = 1; /* error */
6894             else
6895               {
6896               codepoint = (codepoint << 6) | (c & 0x3f);
6897               seq_buff[index++] = c;
6898               if (--bytes_left == 0)            /* codepoint complete */
6899                 if(codepoint > 0x10FFFF)        /* is it too large? */
6900                   complete = -1;        /* error (RFC3629 limit) */
6901                 else
6902                   {             /* finished; output utf-8 sequence */
6903                   yield = string_catn(yield, &size, &ptr, seq_buff, seq_len);
6904                   index = 0;
6905                   }
6906               }
6907             }
6908           else  /* no bytes left: new sequence */
6909             {
6910             if((c & 0x80) == 0) /* 1-byte sequence, US-ASCII, keep it */
6911               {
6912               yield = string_catn(yield, &size, &ptr, &c, 1);
6913               continue;
6914               }
6915             if((c & 0xe0) == 0xc0)              /* 2-byte sequence */
6916               {
6917               if(c == 0xc0 || c == 0xc1)        /* 0xc0 and 0xc1 are illegal */
6918                 complete = -1;
6919               else
6920                 {
6921                   bytes_left = 1;
6922                   codepoint = c & 0x1f;
6923                 }
6924               }
6925             else if((c & 0xf0) == 0xe0)         /* 3-byte sequence */
6926               {
6927               bytes_left = 2;
6928               codepoint = c & 0x0f;
6929               }
6930             else if((c & 0xf8) == 0xf0)         /* 4-byte sequence */
6931               {
6932               bytes_left = 3;
6933               codepoint = c & 0x07;
6934               }
6935             else        /* invalid or too long (RFC3629 allows only 4 bytes) */
6936               complete = -1;
6937
6938             seq_buff[index++] = c;
6939             seq_len = bytes_left + 1;
6940             }           /* if(bytes_left) */
6941
6942           if (complete != 0)
6943             {
6944             bytes_left = index = 0;
6945             yield = string_catn(yield, &size, &ptr, UTF8_REPLACEMENT_CHAR, 1);
6946             }
6947           if ((complete == 1) && ((c & 0x80) == 0))
6948                         /* ASCII character follows incomplete sequence */
6949               yield = string_catn(yield, &size, &ptr, &c, 1);
6950           }
6951         continue;
6952         }
6953
6954 #ifdef SUPPORT_I18N
6955       case EOP_UTF8_DOMAIN_TO_ALABEL:
6956         {
6957         uschar * error = NULL;
6958         uschar * s = string_domain_utf8_to_alabel(sub, &error);
6959         if (error)
6960           {
6961           expand_string_message = string_sprintf(
6962             "error converting utf8 (%s) to alabel: %s",
6963             string_printing(sub), error);
6964           goto EXPAND_FAILED;
6965           }
6966         yield = string_cat(yield, &size, &ptr, s);
6967         continue;
6968         }
6969
6970       case EOP_UTF8_DOMAIN_FROM_ALABEL:
6971         {
6972         uschar * error = NULL;
6973         uschar * s = string_domain_alabel_to_utf8(sub, &error);
6974         if (error)
6975           {
6976           expand_string_message = string_sprintf(
6977             "error converting alabel (%s) to utf8: %s",
6978             string_printing(sub), error);
6979           goto EXPAND_FAILED;
6980           }
6981         yield = string_cat(yield, &size, &ptr, s);
6982         continue;
6983         }
6984
6985       case EOP_UTF8_LOCALPART_TO_ALABEL:
6986         {
6987         uschar * error = NULL;
6988         uschar * s = string_localpart_utf8_to_alabel(sub, &error);
6989         if (error)
6990           {
6991           expand_string_message = string_sprintf(
6992             "error converting utf8 (%s) to alabel: %s",
6993             string_printing(sub), error);
6994           goto EXPAND_FAILED;
6995           }
6996         yield = string_cat(yield, &size, &ptr, s);
6997         DEBUG(D_expand) debug_printf("yield: '%s'\n", yield);
6998         continue;
6999         }
7000
7001       case EOP_UTF8_LOCALPART_FROM_ALABEL:
7002         {
7003         uschar * error = NULL;
7004         uschar * s = string_localpart_alabel_to_utf8(sub, &error);
7005         if (error)
7006           {
7007           expand_string_message = string_sprintf(
7008             "error converting alabel (%s) to utf8: %s",
7009             string_printing(sub), error);
7010           goto EXPAND_FAILED;
7011           }
7012         yield = string_cat(yield, &size, &ptr, s);
7013         continue;
7014         }
7015 #endif  /* EXPERIMENTAL_INTERNATIONAL */
7016
7017       /* escape turns all non-printing characters into escape sequences. */
7018
7019       case EOP_ESCAPE:
7020         {
7021         const uschar *t = string_printing(sub);
7022         yield = string_cat(yield, &size, &ptr, t);
7023         continue;
7024         }
7025
7026       /* Handle numeric expression evaluation */
7027
7028       case EOP_EVAL:
7029       case EOP_EVAL10:
7030         {
7031         uschar *save_sub = sub;
7032         uschar *error = NULL;
7033         int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
7034         if (error != NULL)
7035           {
7036           expand_string_message = string_sprintf("error in expression "
7037             "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
7038               save_sub);
7039           goto EXPAND_FAILED;
7040           }
7041         sprintf(CS var_buffer, PR_EXIM_ARITH, n);
7042         yield = string_cat(yield, &size, &ptr, var_buffer);
7043         continue;
7044         }
7045
7046       /* Handle time period formating */
7047
7048       case EOP_TIME_EVAL:
7049         {
7050         int n = readconf_readtime(sub, 0, FALSE);
7051         if (n < 0)
7052           {
7053           expand_string_message = string_sprintf("string \"%s\" is not an "
7054             "Exim time interval in \"%s\" operator", sub, name);
7055           goto EXPAND_FAILED;
7056           }
7057         sprintf(CS var_buffer, "%d", n);
7058         yield = string_cat(yield, &size, &ptr, var_buffer);
7059         continue;
7060         }
7061
7062       case EOP_TIME_INTERVAL:
7063         {
7064         int n;
7065         uschar *t = read_number(&n, sub);
7066         if (*t != 0) /* Not A Number*/
7067           {
7068           expand_string_message = string_sprintf("string \"%s\" is not a "
7069             "positive number in \"%s\" operator", sub, name);
7070           goto EXPAND_FAILED;
7071           }
7072         t = readconf_printtime(n);
7073         yield = string_cat(yield, &size, &ptr, t);
7074         continue;
7075         }
7076
7077       /* Convert string to base64 encoding */
7078
7079       case EOP_STR2B64:
7080       case EOP_BASE64:
7081         {
7082 #ifdef SUPPORT_TLS
7083         uschar * s = vp && *(void **)vp->value
7084           ? tls_cert_der_b64(*(void **)vp->value)
7085           : b64encode(sub, Ustrlen(sub));
7086 #else
7087         uschar * s = b64encode(sub, Ustrlen(sub));
7088 #endif
7089         yield = string_cat(yield, &size, &ptr, s);
7090         continue;
7091         }
7092
7093       case EOP_BASE64D:
7094         {
7095         uschar * s;
7096         int len = b64decode(sub, &s);
7097         if (len < 0)
7098           {
7099           expand_string_message = string_sprintf("string \"%s\" is not "
7100             "well-formed for \"%s\" operator", sub, name);
7101           goto EXPAND_FAILED;
7102           }
7103         yield = string_cat(yield, &size, &ptr, s);
7104         continue;
7105         }
7106
7107       /* strlen returns the length of the string */
7108
7109       case EOP_STRLEN:
7110         {
7111         uschar buff[24];
7112         (void)sprintf(CS buff, "%d", Ustrlen(sub));
7113         yield = string_cat(yield, &size, &ptr, buff);
7114         continue;
7115         }
7116
7117       /* length_n or l_n takes just the first n characters or the whole string,
7118       whichever is the shorter;
7119
7120       substr_m_n, and s_m_n take n characters from offset m; negative m take
7121       from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
7122       takes the rest, either to the right or to the left.
7123
7124       hash_n or h_n makes a hash of length n from the string, yielding n
7125       characters from the set a-z; hash_n_m makes a hash of length n, but
7126       uses m characters from the set a-zA-Z0-9.
7127
7128       nhash_n returns a single number between 0 and n-1 (in text form), while
7129       nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
7130       between 0 and n-1 and the second between 0 and m-1. */
7131
7132       case EOP_LENGTH:
7133       case EOP_L:
7134       case EOP_SUBSTR:
7135       case EOP_S:
7136       case EOP_HASH:
7137       case EOP_H:
7138       case EOP_NHASH:
7139       case EOP_NH:
7140         {
7141         int sign = 1;
7142         int value1 = 0;
7143         int value2 = -1;
7144         int *pn;
7145         int len;
7146         uschar *ret;
7147
7148         if (arg == NULL)
7149           {
7150           expand_string_message = string_sprintf("missing values after %s",
7151             name);
7152           goto EXPAND_FAILED;
7153           }
7154
7155         /* "length" has only one argument, effectively being synonymous with
7156         substr_0_n. */
7157
7158         if (c == EOP_LENGTH || c == EOP_L)
7159           {
7160           pn = &value2;
7161           value2 = 0;
7162           }
7163
7164         /* The others have one or two arguments; for "substr" the first may be
7165         negative. The second being negative means "not supplied". */
7166
7167         else
7168           {
7169           pn = &value1;
7170           if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
7171           }
7172
7173         /* Read up to two numbers, separated by underscores */
7174
7175         ret = arg;
7176         while (*arg != 0)
7177           {
7178           if (arg != ret && *arg == '_' && pn == &value1)
7179             {
7180             pn = &value2;
7181             value2 = 0;
7182             if (arg[1] != 0) arg++;
7183             }
7184           else if (!isdigit(*arg))
7185             {
7186             expand_string_message =
7187               string_sprintf("non-digit after underscore in \"%s\"", name);
7188             goto EXPAND_FAILED;
7189             }
7190           else *pn = (*pn)*10 + *arg++ - '0';
7191           }
7192         value1 *= sign;
7193
7194         /* Perform the required operation */
7195
7196         ret =
7197           (c == EOP_HASH || c == EOP_H)?
7198              compute_hash(sub, value1, value2, &len) :
7199           (c == EOP_NHASH || c == EOP_NH)?
7200              compute_nhash(sub, value1, value2, &len) :
7201              extract_substr(sub, value1, value2, &len);
7202
7203         if (ret == NULL) goto EXPAND_FAILED;
7204         yield = string_catn(yield, &size, &ptr, ret, len);
7205         continue;
7206         }
7207
7208       /* Stat a path */
7209
7210       case EOP_STAT:
7211         {
7212         uschar *s;
7213         uschar smode[12];
7214         uschar **modetable[3];
7215         int i;
7216         mode_t mode;
7217         struct stat st;
7218
7219         if ((expand_forbid & RDO_EXISTS) != 0)
7220           {
7221           expand_string_message = US"Use of the stat() expansion is not permitted";
7222           goto EXPAND_FAILED;
7223           }
7224
7225         if (stat(CS sub, &st) < 0)
7226           {
7227           expand_string_message = string_sprintf("stat(%s) failed: %s",
7228             sub, strerror(errno));
7229           goto EXPAND_FAILED;
7230           }
7231         mode = st.st_mode;
7232         switch (mode & S_IFMT)
7233           {
7234           case S_IFIFO: smode[0] = 'p'; break;
7235           case S_IFCHR: smode[0] = 'c'; break;
7236           case S_IFDIR: smode[0] = 'd'; break;
7237           case S_IFBLK: smode[0] = 'b'; break;
7238           case S_IFREG: smode[0] = '-'; break;
7239           default: smode[0] = '?'; break;
7240           }
7241
7242         modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
7243         modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
7244         modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
7245
7246         for (i = 0; i < 3; i++)
7247           {
7248           memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
7249           mode >>= 3;
7250           }
7251
7252         smode[10] = 0;
7253         s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
7254           "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
7255           (long)(st.st_mode & 077777), smode, (long)st.st_ino,
7256           (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
7257           (long)st.st_gid, st.st_size, (long)st.st_atime,
7258           (long)st.st_mtime, (long)st.st_ctime);
7259         yield = string_cat(yield, &size, &ptr, s);
7260         continue;
7261         }
7262
7263       /* vaguely random number less than N */
7264
7265       case EOP_RANDINT:
7266         {
7267         int_eximarith_t max;
7268         uschar *s;
7269
7270         max = expanded_string_integer(sub, TRUE);
7271         if (expand_string_message != NULL)
7272           goto EXPAND_FAILED;
7273         s = string_sprintf("%d", vaguely_random_number((int)max));
7274         yield = string_cat(yield, &size, &ptr, s);
7275         continue;
7276         }
7277
7278       /* Reverse IP, including IPv6 to dotted-nibble */
7279
7280       case EOP_REVERSE_IP:
7281         {
7282         int family, maskptr;
7283         uschar reversed[128];
7284
7285         family = string_is_ip_address(sub, &maskptr);
7286         if (family == 0)
7287           {
7288           expand_string_message = string_sprintf(
7289               "reverse_ip() not given an IP address [%s]", sub);
7290           goto EXPAND_FAILED;
7291           }
7292         invert_address(reversed, sub);
7293         yield = string_cat(yield, &size, &ptr, reversed);
7294         continue;
7295         }
7296
7297       /* Unknown operator */
7298
7299       default:
7300       expand_string_message =
7301         string_sprintf("unknown expansion operator \"%s\"", name);
7302       goto EXPAND_FAILED;
7303       }
7304     }
7305
7306   /* Handle a plain name. If this is the first thing in the expansion, release
7307   the pre-allocated buffer. If the result data is known to be in a new buffer,
7308   newsize will be set to the size of that buffer, and we can just point at that
7309   store instead of copying. Many expansion strings contain just one reference,
7310   so this is a useful optimization, especially for humungous headers
7311   ($message_headers). */
7312                                                 /*{*/
7313   if (*s++ == '}')
7314     {
7315     int len;
7316     int newsize = 0;
7317     if (ptr == 0)
7318       {
7319       if (resetok) store_reset(yield);
7320       yield = NULL;
7321       size = 0;
7322       }
7323     value = find_variable(name, FALSE, skipping, &newsize);
7324     if (value == NULL)
7325       {
7326       expand_string_message =
7327         string_sprintf("unknown variable in \"${%s}\"", name);
7328       check_variable_error_message(name);
7329       goto EXPAND_FAILED;
7330       }
7331     len = Ustrlen(value);
7332     if (yield == NULL && newsize != 0)
7333       {
7334       yield = value;
7335       size = newsize;
7336       ptr = len;
7337       }
7338     else yield = string_catn(yield, &size, &ptr, value, len);
7339     continue;
7340     }
7341
7342   /* Else there's something wrong */
7343
7344   expand_string_message =
7345     string_sprintf("\"${%s\" is not a known operator (or a } is missing "
7346     "in a variable reference)", name);
7347   goto EXPAND_FAILED;
7348   }
7349
7350 /* If we hit the end of the string when ket_ends is set, there is a missing
7351 terminating brace. */
7352
7353 if (ket_ends && *s == 0)
7354   {
7355   expand_string_message = malformed_header?
7356     US"missing } at end of string - could be header name not terminated by colon"
7357     :
7358     US"missing } at end of string";
7359   goto EXPAND_FAILED;
7360   }
7361
7362 /* Expansion succeeded; yield may still be NULL here if nothing was actually
7363 added to the string. If so, set up an empty string. Add a terminating zero. If
7364 left != NULL, return a pointer to the terminator. */
7365
7366 if (yield == NULL) yield = store_get(1);
7367 yield[ptr] = 0;
7368 if (left != NULL) *left = s;
7369
7370 /* Any stacking store that was used above the final string is no longer needed.
7371 In many cases the final string will be the first one that was got and so there
7372 will be optimal store usage. */
7373
7374 if (resetok) store_reset(yield + ptr + 1);
7375 else if (resetok_p) *resetok_p = FALSE;
7376
7377 DEBUG(D_expand)
7378   {
7379   debug_printf("  expanding: %.*s\n     result: %s\n", (int)(s - string), string,
7380     yield);
7381   if (skipping) debug_printf("   skipping: result is not used\n");
7382   }
7383 return yield;
7384
7385 /* This is the failure exit: easiest to program with a goto. We still need
7386 to update the pointer to the terminator, for cases of nested calls with "fail".
7387 */
7388
7389 EXPAND_FAILED_CURLY:
7390 if (malformed_header)
7391   expand_string_message =
7392     US"missing or misplaced { or } - could be header name not terminated by colon";
7393
7394 else if (!expand_string_message || !*expand_string_message)
7395   expand_string_message = US"missing or misplaced { or }";
7396
7397 /* At one point, Exim reset the store to yield (if yield was not NULL), but
7398 that is a bad idea, because expand_string_message is in dynamic store. */
7399
7400 EXPAND_FAILED:
7401 if (left != NULL) *left = s;
7402 DEBUG(D_expand)
7403   {
7404   debug_printf("failed to expand: %s\n", string);
7405   debug_printf("   error message: %s\n", expand_string_message);
7406   if (expand_string_forcedfail) debug_printf("failure was forced\n");
7407   }
7408 if (resetok_p) *resetok_p = resetok;
7409 return NULL;
7410 }
7411
7412
7413 /* This is the external function call. Do a quick check for any expansion
7414 metacharacters, and if there are none, just return the input string.
7415
7416 Argument: the string to be expanded
7417 Returns:  the expanded string, or NULL if expansion failed; if failure was
7418           due to a lookup deferring, search_find_defer will be TRUE
7419 */
7420
7421 uschar *
7422 expand_string(uschar *string)
7423 {
7424 search_find_defer = FALSE;
7425 malformed_header = FALSE;
7426 return (Ustrpbrk(string, "$\\") == NULL)? string :
7427   expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
7428 }
7429
7430
7431
7432 const uschar *
7433 expand_cstring(const uschar *string)
7434 {
7435 search_find_defer = FALSE;
7436 malformed_header = FALSE;
7437 return (Ustrpbrk(string, "$\\") == NULL)? string :
7438   expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
7439 }
7440
7441
7442
7443 /*************************************************
7444 *              Expand and copy                   *
7445 *************************************************/
7446
7447 /* Now and again we want to expand a string and be sure that the result is in a
7448 new bit of store. This function does that.
7449 Since we know it has been copied, the de-const cast is safe.
7450
7451 Argument: the string to be expanded
7452 Returns:  the expanded string, always in a new bit of store, or NULL
7453 */
7454
7455 uschar *
7456 expand_string_copy(const uschar *string)
7457 {
7458 const uschar *yield = expand_cstring(string);
7459 if (yield == string) yield = string_copy(string);
7460 return US yield;
7461 }
7462
7463
7464
7465 /*************************************************
7466 *        Expand and interpret as an integer      *
7467 *************************************************/
7468
7469 /* Expand a string, and convert the result into an integer.
7470
7471 Arguments:
7472   string  the string to be expanded
7473   isplus  TRUE if a non-negative number is expected
7474
7475 Returns:  the integer value, or
7476           -1 for an expansion error               ) in both cases, message in
7477           -2 for an integer interpretation error  ) expand_string_message
7478           expand_string_message is set NULL for an OK integer
7479 */
7480
7481 int_eximarith_t
7482 expand_string_integer(uschar *string, BOOL isplus)
7483 {
7484 return expanded_string_integer(expand_string(string), isplus);
7485 }
7486
7487
7488 /*************************************************
7489  *         Interpret string as an integer        *
7490  *************************************************/
7491
7492 /* Convert a string (that has already been expanded) into an integer.
7493
7494 This function is used inside the expansion code.
7495
7496 Arguments:
7497   s       the string to be expanded
7498   isplus  TRUE if a non-negative number is expected
7499
7500 Returns:  the integer value, or
7501           -1 if string is NULL (which implies an expansion error)
7502           -2 for an integer interpretation error
7503           expand_string_message is set NULL for an OK integer
7504 */
7505
7506 static int_eximarith_t
7507 expanded_string_integer(const uschar *s, BOOL isplus)
7508 {
7509 int_eximarith_t value;
7510 uschar *msg = US"invalid integer \"%s\"";
7511 uschar *endptr;
7512
7513 /* If expansion failed, expand_string_message will be set. */
7514
7515 if (s == NULL) return -1;
7516
7517 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
7518 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
7519 systems, so we set it zero ourselves. */
7520
7521 errno = 0;
7522 expand_string_message = NULL;               /* Indicates no error */
7523
7524 /* Before Exim 4.64, strings consisting entirely of whitespace compared
7525 equal to 0.  Unfortunately, people actually relied upon that, so preserve
7526 the behaviour explicitly.  Stripping leading whitespace is a harmless
7527 noop change since strtol skips it anyway (provided that there is a number
7528 to find at all). */
7529 if (isspace(*s))
7530   {
7531   while (isspace(*s)) ++s;
7532   if (*s == '\0')
7533     {
7534       DEBUG(D_expand)
7535        debug_printf("treating blank string as number 0\n");
7536       return 0;
7537     }
7538   }
7539
7540 value = strtoll(CS s, CSS &endptr, 10);
7541
7542 if (endptr == s)
7543   {
7544   msg = US"integer expected but \"%s\" found";
7545   }
7546 else if (value < 0 && isplus)
7547   {
7548   msg = US"non-negative integer expected but \"%s\" found";
7549   }
7550 else
7551   {
7552   switch (tolower(*endptr))
7553     {
7554     default:
7555       break;
7556     case 'k':
7557       if (value > EXIM_ARITH_MAX/1024 || value < EXIM_ARITH_MIN/1024) errno = ERANGE;
7558       else value *= 1024;
7559       endptr++;
7560       break;
7561     case 'm':
7562       if (value > EXIM_ARITH_MAX/(1024*1024) || value < EXIM_ARITH_MIN/(1024*1024)) errno = ERANGE;
7563       else value *= 1024*1024;
7564       endptr++;
7565       break;
7566     case 'g':
7567       if (value > EXIM_ARITH_MAX/(1024*1024*1024) || value < EXIM_ARITH_MIN/(1024*1024*1024)) errno = ERANGE;
7568       else value *= 1024*1024*1024;
7569       endptr++;
7570       break;
7571     }
7572   if (errno == ERANGE)
7573     msg = US"absolute value of integer \"%s\" is too large (overflow)";
7574   else
7575     {
7576     while (isspace(*endptr)) endptr++;
7577     if (*endptr == 0) return value;
7578     }
7579   }
7580
7581 expand_string_message = string_sprintf(CS msg, s);
7582 return -2;
7583 }
7584
7585
7586 /* These values are usually fixed boolean values, but they are permitted to be
7587 expanded strings.
7588
7589 Arguments:
7590   addr       address being routed
7591   mtype      the module type
7592   mname      the module name
7593   dbg_opt    debug selectors
7594   oname      the option name
7595   bvalue     the router's boolean value
7596   svalue     the router's string value
7597   rvalue     where to put the returned value
7598
7599 Returns:     OK     value placed in rvalue
7600              DEFER  expansion failed
7601 */
7602
7603 int
7604 exp_bool(address_item *addr,
7605   uschar *mtype, uschar *mname, unsigned dbg_opt,
7606   uschar *oname, BOOL bvalue,
7607   uschar *svalue, BOOL *rvalue)
7608 {
7609 uschar *expanded;
7610 if (svalue == NULL) { *rvalue = bvalue; return OK; }
7611
7612 expanded = expand_string(svalue);
7613 if (expanded == NULL)
7614   {
7615   if (expand_string_forcedfail)
7616     {
7617     DEBUG(dbg_opt) debug_printf("expansion of \"%s\" forced failure\n", oname);
7618     *rvalue = bvalue;
7619     return OK;
7620     }
7621   addr->message = string_sprintf("failed to expand \"%s\" in %s %s: %s",
7622       oname, mname, mtype, expand_string_message);
7623   DEBUG(dbg_opt) debug_printf("%s\n", addr->message);
7624   return DEFER;
7625   }
7626
7627 DEBUG(dbg_opt) debug_printf("expansion of \"%s\" yields \"%s\"\n", oname,
7628   expanded);
7629
7630 if (strcmpic(expanded, US"true") == 0 || strcmpic(expanded, US"yes") == 0)
7631   *rvalue = TRUE;
7632 else if (strcmpic(expanded, US"false") == 0 || strcmpic(expanded, US"no") == 0)
7633   *rvalue = FALSE;
7634 else
7635   {
7636   addr->message = string_sprintf("\"%s\" is not a valid value for the "
7637     "\"%s\" option in the %s %s", expanded, oname, mname, mtype);
7638   return DEFER;
7639   }
7640
7641 return OK;
7642 }
7643
7644
7645
7646 /* Avoid potentially exposing a password in a string about to be logged */
7647
7648 uschar *
7649 expand_hide_passwords(uschar * s)
7650 {
7651 return (  (  Ustrstr(s, "failed to expand") != NULL
7652           || Ustrstr(s, "expansion of ")    != NULL
7653           )
7654        && (  Ustrstr(s, "mysql")   != NULL
7655           || Ustrstr(s, "pgsql")   != NULL
7656           || Ustrstr(s, "redis")   != NULL
7657           || Ustrstr(s, "sqlite")  != NULL
7658           || Ustrstr(s, "ldap:")   != NULL
7659           || Ustrstr(s, "ldaps:")  != NULL
7660           || Ustrstr(s, "ldapi:")  != NULL
7661           || Ustrstr(s, "ldapdn:") != NULL
7662           || Ustrstr(s, "ldapm:")  != NULL
7663        )  )
7664   ? US"Temporary internal error" : s;
7665 }
7666
7667
7668
7669
7670 /*************************************************
7671 **************************************************
7672 *             Stand-alone test program           *
7673 **************************************************
7674 *************************************************/
7675
7676 #ifdef STAND_ALONE
7677
7678
7679 BOOL
7680 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
7681 {
7682 int ovector[3*(EXPAND_MAXN+1)];
7683 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
7684   ovector, nelem(ovector));
7685 BOOL yield = n >= 0;
7686 if (n == 0) n = EXPAND_MAXN + 1;
7687 if (yield)
7688   {
7689   int nn;
7690   expand_nmax = (setup < 0)? 0 : setup + 1;
7691   for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
7692     {
7693     expand_nstring[expand_nmax] = subject + ovector[nn];
7694     expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
7695     }
7696   expand_nmax--;
7697   }
7698 return yield;
7699 }
7700
7701
7702 int main(int argc, uschar **argv)
7703 {
7704 int i;
7705 uschar buffer[1024];
7706
7707 debug_selector = D_v;
7708 debug_file = stderr;
7709 debug_fd = fileno(debug_file);
7710 big_buffer = malloc(big_buffer_size);
7711
7712 for (i = 1; i < argc; i++)
7713   {
7714   if (argv[i][0] == '+')
7715     {
7716     debug_trace_memory = 2;
7717     argv[i]++;
7718     }
7719   if (isdigit(argv[i][0]))
7720     debug_selector = Ustrtol(argv[i], NULL, 0);
7721   else
7722     if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
7723         Ustrlen(argv[i]))
7724       {
7725 #ifdef LOOKUP_LDAP
7726       eldap_default_servers = argv[i];
7727 #endif
7728 #ifdef LOOKUP_MYSQL
7729       mysql_servers = argv[i];
7730 #endif
7731 #ifdef LOOKUP_PGSQL
7732       pgsql_servers = argv[i];
7733 #endif
7734 #ifdef LOOKUP_REDIS
7735       redis_servers = argv[i];
7736 #endif
7737       }
7738 #ifdef EXIM_PERL
7739   else opt_perl_startup = argv[i];
7740 #endif
7741   }
7742
7743 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
7744
7745 expand_nstring[1] = US"string 1....";
7746 expand_nlength[1] = 8;
7747 expand_nmax = 1;
7748
7749 #ifdef EXIM_PERL
7750 if (opt_perl_startup != NULL)
7751   {
7752   uschar *errstr;
7753   printf("Starting Perl interpreter\n");
7754   errstr = init_perl(opt_perl_startup);
7755   if (errstr != NULL)
7756     {
7757     printf("** error in perl_startup code: %s\n", errstr);
7758     return EXIT_FAILURE;
7759     }
7760   }
7761 #endif /* EXIM_PERL */
7762
7763 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
7764   {
7765   void *reset_point = store_get(0);
7766   uschar *yield = expand_string(buffer);
7767   if (yield != NULL)
7768     {
7769     printf("%s\n", yield);
7770     store_reset(reset_point);
7771     }
7772   else
7773     {
7774     if (search_find_defer) printf("search_find deferred\n");
7775     printf("Failed: %s\n", expand_string_message);
7776     if (expand_string_forcedfail) printf("Forced failure\n");
7777     printf("\n");
7778     }
7779   }
7780
7781 search_tidyup();
7782
7783 return 0;
7784 }
7785
7786 #endif
7787
7788 /* vi: aw ai sw=2
7789 */
7790 /* End of expand.c */