src/src/expand.c

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