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