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