src/src/expand.c

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