src/src/expand.c

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