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