src/src/expand.c

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