src/src/expand.c

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