src/src/expand.c

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