src/src/expand.c

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