src/src/expand.c

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