src/src/expand.c

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