src/src/expand.c

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