src/src/expand.c

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