src/src/expand.c

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