src/src/expand.c

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