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