src/src/expand.c

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