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