src/src/expand.c

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