src/src/expand.c

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