src/src/expand.c

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