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