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