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