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