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             if ((lookup_value = s = item))
5865               {
5866               while (*s) s++;
5867               while (--s >= lookup_value && isspace(*s)) *s = '\0';
5868               }
5869             }
5870           else
5871             {
5872             lookup_value = NULL;
5873             while ((item = json_nextinlist(&list)))
5874               {
5875               /* Item is:  string name-sep value.  string is quoted.
5876               Dequote the string and compare with the search key. */
5877
5878               if (!(item = dewrap(item, US"\"\"")))
5879                 {
5880                 expand_string_message =
5881                   string_sprintf("%s wrapping string key for extract json",
5882                     expand_string_message);
5883                 goto EXPAND_FAILED_CURLY;
5884                 }
5885               if (Ustrcmp(item, sub[0]) == 0)   /*XXX should be a UTF8-compare */
5886                 {
5887                 s = item + Ustrlen(item) + 1;
5888                 while (isspace(*s)) s++;
5889                 if (*s != ':')
5890                   {
5891                   expand_string_message = string_sprintf(
5892                     "missing object value-separator for extract json");
5893                   goto EXPAND_FAILED_CURLY;
5894                   }
5895                 s++;
5896                 while (isspace(*s)) s++;
5897                 lookup_value = s;
5898                 break;
5899                 }
5900               }
5901             }
5902           }
5903         }
5904
5905       /* If no string follows, $value gets substituted; otherwise there can
5906       be yes/no strings, as for lookup or if. */
5907
5908       switch(process_yesno(
5909                skipping,                     /* were previously skipping */
5910                lookup_value != NULL,         /* success/failure indicator */
5911                save_lookup_value,            /* value to reset for string2 */
5912                &s,                           /* input pointer */
5913                &yield,                       /* output pointer */
5914                US"extract",                  /* condition type */
5915                &resetok))
5916         {
5917         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5918         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5919         }
5920
5921       /* All done - restore numerical variables. */
5922
5923       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5924         save_expand_nlength);
5925
5926       continue;
5927       }
5928
5929     /* return the Nth item from a list */
5930
5931     case EITEM_LISTEXTRACT:
5932       {
5933       int i;
5934       int field_number = 1;
5935       uschar *save_lookup_value = lookup_value;
5936       uschar *sub[2];
5937       int save_expand_nmax =
5938         save_expand_strings(save_expand_nstring, save_expand_nlength);
5939
5940       /* Read the field & list arguments */
5941
5942       for (i = 0; i < 2; i++)
5943         {
5944         while (isspace(*s)) s++;
5945         if (*s != '{')                                  /*}*/
5946           {
5947           expand_string_message = string_sprintf(
5948             "missing '{' for arg %d of listextract", i+1);
5949           goto EXPAND_FAILED_CURLY;
5950           }
5951
5952         sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5953         if (!sub[i])     goto EXPAND_FAILED;            /*{*/
5954         if (*s++ != '}')
5955           {
5956           expand_string_message = string_sprintf(
5957             "missing '}' closing arg %d of listextract", i+1);
5958           goto EXPAND_FAILED_CURLY;
5959           }
5960
5961         /* After removal of leading and trailing white space, the first
5962         argument must be numeric and nonempty. */
5963
5964         if (i == 0)
5965           {
5966           int len;
5967           int x = 0;
5968           uschar *p = sub[0];
5969
5970           while (isspace(*p)) p++;
5971           sub[0] = p;
5972
5973           len = Ustrlen(p);
5974           while (len > 0 && isspace(p[len-1])) len--;
5975           p[len] = 0;
5976
5977           if (!*p && !skipping)
5978             {
5979             expand_string_message = US"first argument of \"listextract\" must "
5980               "not be empty";
5981             goto EXPAND_FAILED;
5982             }
5983
5984           if (*p == '-')
5985             {
5986             field_number = -1;
5987             p++;
5988             }
5989           while (*p && isdigit(*p)) x = x * 10 + *p++ - '0';
5990           if (*p)
5991             {
5992             expand_string_message = US"first argument of \"listextract\" must "
5993               "be numeric";
5994             goto EXPAND_FAILED;
5995             }
5996           field_number *= x;
5997           }
5998         }
5999
6000       /* Extract the numbered element into $value. If
6001       skipping, just pretend the extraction failed. */
6002
6003       lookup_value = skipping ? NULL : expand_getlistele(field_number, sub[1]);
6004
6005       /* If no string follows, $value gets substituted; otherwise there can
6006       be yes/no strings, as for lookup or if. */
6007
6008       switch(process_yesno(
6009                skipping,                     /* were previously skipping */
6010                lookup_value != NULL,         /* success/failure indicator */
6011                save_lookup_value,            /* value to reset for string2 */
6012                &s,                           /* input pointer */
6013                &yield,                       /* output pointer */
6014                US"listextract",              /* condition type */
6015                &resetok))
6016         {
6017         case 1: goto EXPAND_FAILED;          /* when all is well, the */
6018         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
6019         }
6020
6021       /* All done - restore numerical variables. */
6022
6023       restore_expand_strings(save_expand_nmax, save_expand_nstring,
6024         save_expand_nlength);
6025
6026       continue;
6027       }
6028
6029 #ifdef SUPPORT_TLS
6030     case EITEM_CERTEXTRACT:
6031       {
6032       uschar *save_lookup_value = lookup_value;
6033       uschar *sub[2];
6034       int save_expand_nmax =
6035         save_expand_strings(save_expand_nstring, save_expand_nlength);
6036
6037       /* Read the field argument */
6038       while (isspace(*s)) s++;
6039       if (*s != '{')                                    /*}*/
6040         {
6041         expand_string_message = US"missing '{' for field arg of certextract";
6042         goto EXPAND_FAILED_CURLY;
6043         }
6044       sub[0] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6045       if (!sub[0])     goto EXPAND_FAILED;              /*{*/
6046       if (*s++ != '}')
6047         {
6048         expand_string_message = US"missing '}' closing field arg of certextract";
6049         goto EXPAND_FAILED_CURLY;
6050         }
6051       /* strip spaces fore & aft */
6052       {
6053       int len;
6054       uschar *p = sub[0];
6055
6056       while (isspace(*p)) p++;
6057       sub[0] = p;
6058
6059       len = Ustrlen(p);
6060       while (len > 0 && isspace(p[len-1])) len--;
6061       p[len] = 0;
6062       }
6063
6064       /* inspect the cert argument */
6065       while (isspace(*s)) s++;
6066       if (*s != '{')                                    /*}*/
6067         {
6068         expand_string_message = US"missing '{' for cert variable arg of certextract";
6069         goto EXPAND_FAILED_CURLY;
6070         }
6071       if (*++s != '$')
6072         {
6073         expand_string_message = US"second argument of \"certextract\" must "
6074           "be a certificate variable";
6075         goto EXPAND_FAILED;
6076         }
6077       sub[1] = expand_string_internal(s+1, TRUE, &s, skipping, FALSE, &resetok);
6078       if (!sub[1])     goto EXPAND_FAILED;              /*{*/
6079       if (*s++ != '}')
6080         {
6081         expand_string_message = US"missing '}' closing cert variable arg of certextract";
6082         goto EXPAND_FAILED_CURLY;
6083         }
6084
6085       if (skipping)
6086         lookup_value = NULL;
6087       else
6088         {
6089         lookup_value = expand_getcertele(sub[0], sub[1]);
6090         if (*expand_string_message) goto EXPAND_FAILED;
6091         }
6092       switch(process_yesno(
6093                skipping,                     /* were previously skipping */
6094                lookup_value != NULL,         /* success/failure indicator */
6095                save_lookup_value,            /* value to reset for string2 */
6096                &s,                           /* input pointer */
6097                &yield,                       /* output pointer */
6098                US"certextract",              /* condition type */
6099                &resetok))
6100         {
6101         case 1: goto EXPAND_FAILED;          /* when all is well, the */
6102         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
6103         }
6104
6105       restore_expand_strings(save_expand_nmax, save_expand_nstring,
6106         save_expand_nlength);
6107       continue;
6108       }
6109 #endif  /*SUPPORT_TLS*/
6110
6111     /* Handle list operations */
6112
6113     case EITEM_FILTER:
6114     case EITEM_MAP:
6115     case EITEM_REDUCE:
6116       {
6117       int sep = 0;
6118       int save_ptr = yield->ptr;
6119       uschar outsep[2] = { '\0', '\0' };
6120       const uschar *list, *expr, *temp;
6121       uschar *save_iterate_item = iterate_item;
6122       uschar *save_lookup_value = lookup_value;
6123
6124       while (isspace(*s)) s++;
6125       if (*s++ != '{')
6126         {
6127         expand_string_message =
6128           string_sprintf("missing '{' for first arg of %s", name);
6129         goto EXPAND_FAILED_CURLY;
6130         }
6131
6132       list = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
6133       if (list == NULL) goto EXPAND_FAILED;
6134       if (*s++ != '}')
6135         {
6136         expand_string_message =
6137           string_sprintf("missing '}' closing first arg of %s", name);
6138         goto EXPAND_FAILED_CURLY;
6139         }
6140
6141       if (item_type == EITEM_REDUCE)
6142         {
6143         uschar * t;
6144         while (isspace(*s)) s++;
6145         if (*s++ != '{')
6146           {
6147           expand_string_message = US"missing '{' for second arg of reduce";
6148           goto EXPAND_FAILED_CURLY;
6149           }
6150         t = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
6151         if (!t) goto EXPAND_FAILED;
6152         lookup_value = t;
6153         if (*s++ != '}')
6154           {
6155           expand_string_message = US"missing '}' closing second arg of reduce";
6156           goto EXPAND_FAILED_CURLY;
6157           }
6158         }
6159
6160       while (isspace(*s)) s++;
6161       if (*s++ != '{')
6162         {
6163         expand_string_message =
6164           string_sprintf("missing '{' for last arg of %s", name);
6165         goto EXPAND_FAILED_CURLY;
6166         }
6167
6168       expr = s;
6169
6170       /* For EITEM_FILTER, call eval_condition once, with result discarded (as
6171       if scanning a "false" part). This allows us to find the end of the
6172       condition, because if the list is empty, we won't actually evaluate the
6173       condition for real. For EITEM_MAP and EITEM_REDUCE, do the same, using
6174       the normal internal expansion function. */
6175
6176       if (item_type == EITEM_FILTER)
6177         {
6178         temp = eval_condition(expr, &resetok, NULL);
6179         if (temp != NULL) s = temp;
6180         }
6181       else
6182         temp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
6183
6184       if (temp == NULL)
6185         {
6186         expand_string_message = string_sprintf("%s inside \"%s\" item",
6187           expand_string_message, name);
6188         goto EXPAND_FAILED;
6189         }
6190
6191       while (isspace(*s)) s++;
6192       if (*s++ != '}')
6193         {                                               /*{*/
6194         expand_string_message = string_sprintf("missing } at end of condition "
6195           "or expression inside \"%s\"; could be an unquoted } in the content",
6196           name);
6197         goto EXPAND_FAILED;
6198         }
6199
6200       while (isspace(*s)) s++;                          /*{*/
6201       if (*s++ != '}')
6202         {                                               /*{*/
6203         expand_string_message = string_sprintf("missing } at end of \"%s\"",
6204           name);
6205         goto EXPAND_FAILED;
6206         }
6207
6208       /* If we are skipping, we can now just move on to the next item. When
6209       processing for real, we perform the iteration. */
6210
6211       if (skipping) continue;
6212       while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
6213         {
6214         *outsep = (uschar)sep;      /* Separator as a string */
6215
6216         DEBUG(D_expand) debug_printf_indent("%s: $item = '%s'  $value = '%s'\n",
6217                           name, iterate_item, lookup_value);
6218
6219         if (item_type == EITEM_FILTER)
6220           {
6221           BOOL condresult;
6222           if (eval_condition(expr, &resetok, &condresult) == NULL)
6223             {
6224             iterate_item = save_iterate_item;
6225             lookup_value = save_lookup_value;
6226             expand_string_message = string_sprintf("%s inside \"%s\" condition",
6227               expand_string_message, name);
6228             goto EXPAND_FAILED;
6229             }
6230           DEBUG(D_expand) debug_printf_indent("%s: condition is %s\n", name,
6231             condresult? "true":"false");
6232           if (condresult)
6233             temp = iterate_item;    /* TRUE => include this item */
6234           else
6235             continue;               /* FALSE => skip this item */
6236           }
6237
6238         /* EITEM_MAP and EITEM_REDUCE */
6239
6240         else
6241           {
6242           uschar * t = expand_string_internal(expr, TRUE, NULL, skipping, TRUE, &resetok);
6243           temp = t;
6244           if (temp == NULL)
6245             {
6246             iterate_item = save_iterate_item;
6247             expand_string_message = string_sprintf("%s inside \"%s\" item",
6248               expand_string_message, name);
6249             goto EXPAND_FAILED;
6250             }
6251           if (item_type == EITEM_REDUCE)
6252             {
6253             lookup_value = t;         /* Update the value of $value */
6254             continue;                 /* and continue the iteration */
6255             }
6256           }
6257
6258         /* We reach here for FILTER if the condition is true, always for MAP,
6259         and never for REDUCE. The value in "temp" is to be added to the output
6260         list that is being created, ensuring that any occurrences of the
6261         separator character are doubled. Unless we are dealing with the first
6262         item of the output list, add in a space if the new item begins with the
6263         separator character, or is an empty string. */
6264
6265         if (yield->ptr != save_ptr && (temp[0] == *outsep || temp[0] == 0))
6266           yield = string_catn(yield, US" ", 1);
6267
6268         /* Add the string in "temp" to the output list that we are building,
6269         This is done in chunks by searching for the separator character. */
6270
6271         for (;;)
6272           {
6273           size_t seglen = Ustrcspn(temp, outsep);
6274
6275           yield = string_catn(yield, temp, seglen + 1);
6276
6277           /* If we got to the end of the string we output one character
6278           too many; backup and end the loop. Otherwise arrange to double the
6279           separator. */
6280
6281           if (temp[seglen] == '\0') { yield->ptr--; break; }
6282           yield = string_catn(yield, outsep, 1);
6283           temp += seglen + 1;
6284           }
6285
6286         /* Output a separator after the string: we will remove the redundant
6287         final one at the end. */
6288
6289         yield = string_catn(yield, outsep, 1);
6290         }   /* End of iteration over the list loop */
6291
6292       /* REDUCE has generated no output above: output the final value of
6293       $value. */
6294
6295       if (item_type == EITEM_REDUCE)
6296         {
6297         yield = string_cat(yield, lookup_value);
6298         lookup_value = save_lookup_value;  /* Restore $value */
6299         }
6300
6301       /* FILTER and MAP generate lists: if they have generated anything, remove
6302       the redundant final separator. Even though an empty item at the end of a
6303       list does not count, this is tidier. */
6304
6305       else if (yield->ptr != save_ptr) yield->ptr--;
6306
6307       /* Restore preserved $item */
6308
6309       iterate_item = save_iterate_item;
6310       continue;
6311       }
6312
6313     case EITEM_SORT:
6314       {
6315       int cond_type;
6316       int sep = 0;
6317       const uschar *srclist, *cmp, *xtract;
6318       uschar * opname, * srcitem;
6319       const uschar *dstlist = NULL, *dstkeylist = NULL;
6320       uschar * tmp;
6321       uschar *save_iterate_item = iterate_item;
6322
6323       while (isspace(*s)) s++;
6324       if (*s++ != '{')
6325         {
6326         expand_string_message = US"missing '{' for list arg of sort";
6327         goto EXPAND_FAILED_CURLY;
6328         }
6329
6330       srclist = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
6331       if (!srclist) goto EXPAND_FAILED;
6332       if (*s++ != '}')
6333         {
6334         expand_string_message = US"missing '}' closing list arg of sort";
6335         goto EXPAND_FAILED_CURLY;
6336         }
6337
6338       while (isspace(*s)) s++;
6339       if (*s++ != '{')
6340         {
6341         expand_string_message = US"missing '{' for comparator arg of sort";
6342         goto EXPAND_FAILED_CURLY;
6343         }
6344
6345       cmp = expand_string_internal(s, TRUE, &s, skipping, FALSE, &resetok);
6346       if (!cmp) goto EXPAND_FAILED;
6347       if (*s++ != '}')
6348         {
6349         expand_string_message = US"missing '}' closing comparator arg of sort";
6350         goto EXPAND_FAILED_CURLY;
6351         }
6352
6353       if ((cond_type = identify_operator(&cmp, &opname)) == -1)
6354         {
6355         if (!expand_string_message)
6356           expand_string_message = string_sprintf("unknown condition \"%s\"", s);
6357         goto EXPAND_FAILED;
6358         }
6359       switch(cond_type)
6360         {
6361         case ECOND_NUM_L: case ECOND_NUM_LE:
6362         case ECOND_NUM_G: case ECOND_NUM_GE:
6363         case ECOND_STR_GE: case ECOND_STR_GEI: case ECOND_STR_GT: case ECOND_STR_GTI:
6364         case ECOND_STR_LE: case ECOND_STR_LEI: case ECOND_STR_LT: case ECOND_STR_LTI:
6365           break;
6366
6367         default:
6368           expand_string_message = US"comparator not handled for sort";
6369           goto EXPAND_FAILED;
6370         }
6371
6372       while (isspace(*s)) s++;
6373       if (*s++ != '{')
6374         {
6375         expand_string_message = US"missing '{' for extractor arg of sort";
6376         goto EXPAND_FAILED_CURLY;
6377         }
6378
6379       xtract = s;
6380       tmp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
6381       if (!tmp) goto EXPAND_FAILED;
6382       xtract = string_copyn(xtract, s - xtract);
6383
6384       if (*s++ != '}')
6385         {
6386         expand_string_message = US"missing '}' closing extractor arg of sort";
6387         goto EXPAND_FAILED_CURLY;
6388         }
6389                                                         /*{*/
6390       if (*s++ != '}')
6391         {                                               /*{*/
6392         expand_string_message = US"missing } at end of \"sort\"";
6393         goto EXPAND_FAILED;
6394         }
6395
6396       if (skipping) continue;
6397
6398       while ((srcitem = string_nextinlist(&srclist, &sep, NULL, 0)))
6399         {
6400         uschar * srcfield, * dstitem;
6401         gstring * newlist = NULL;
6402         gstring * newkeylist = NULL;
6403
6404         DEBUG(D_expand) debug_printf_indent("%s: $item = \"%s\"\n", name, srcitem);
6405
6406         /* extract field for comparisons */
6407         iterate_item = srcitem;
6408         if (  !(srcfield = expand_string_internal(xtract, FALSE, NULL, FALSE,
6409                                           TRUE, &resetok))
6410            || !*srcfield)
6411           {
6412           expand_string_message = string_sprintf(
6413               "field-extract in sort: \"%s\"", xtract);
6414           goto EXPAND_FAILED;
6415           }
6416
6417         /* Insertion sort */
6418
6419         /* copy output list until new-item < list-item */
6420         while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
6421           {
6422           uschar * dstfield;
6423
6424           /* field for comparison */
6425           if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
6426             goto sort_mismatch;
6427
6428           /* String-comparator names start with a letter; numeric names do not */
6429
6430           if (sortsbefore(cond_type, isalpha(opname[0]),
6431               srcfield, dstfield))
6432             {
6433             /* New-item sorts before this dst-item.  Append new-item,
6434             then dst-item, then remainder of dst list. */
6435
6436             newlist = string_append_listele(newlist, sep, srcitem);
6437             newkeylist = string_append_listele(newkeylist, sep, srcfield);
6438             srcitem = NULL;
6439
6440             newlist = string_append_listele(newlist, sep, dstitem);
6441             newkeylist = string_append_listele(newkeylist, sep, dstfield);
6442
6443             while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
6444               {
6445               if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
6446                 goto sort_mismatch;
6447               newlist = string_append_listele(newlist, sep, dstitem);
6448               newkeylist = string_append_listele(newkeylist, sep, dstfield);
6449               }
6450
6451             break;
6452             }
6453
6454           newlist = string_append_listele(newlist, sep, dstitem);
6455           newkeylist = string_append_listele(newkeylist, sep, dstfield);
6456           }
6457
6458         /* If we ran out of dstlist without consuming srcitem, append it */
6459         if (srcitem)
6460           {
6461           newlist = string_append_listele(newlist, sep, srcitem);
6462           newkeylist = string_append_listele(newkeylist, sep, srcfield);
6463           }
6464
6465         dstlist = newlist->s;
6466         dstkeylist = newkeylist->s;
6467
6468         DEBUG(D_expand) debug_printf_indent("%s: dstlist = \"%s\"\n", name, dstlist);
6469         DEBUG(D_expand) debug_printf_indent("%s: dstkeylist = \"%s\"\n", name, dstkeylist);
6470         }
6471
6472       if (dstlist)
6473         yield = string_cat(yield, dstlist);
6474
6475       /* Restore preserved $item */
6476       iterate_item = save_iterate_item;
6477       continue;
6478
6479       sort_mismatch:
6480         expand_string_message = US"Internal error in sort (list mismatch)";
6481         goto EXPAND_FAILED;
6482       }
6483
6484
6485     /* If ${dlfunc } support is configured, handle calling dynamically-loaded
6486     functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
6487     or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
6488     a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
6489
6490     #define EXPAND_DLFUNC_MAX_ARGS 8
6491
6492     case EITEM_DLFUNC:
6493 #ifndef EXPAND_DLFUNC
6494       expand_string_message = US"\"${dlfunc\" encountered, but this facility "  /*}*/
6495         "is not included in this binary";
6496       goto EXPAND_FAILED;
6497
6498 #else   /* EXPAND_DLFUNC */
6499       {
6500       tree_node *t;
6501       exim_dlfunc_t *func;
6502       uschar *result;
6503       int status, argc;
6504       uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
6505
6506       if ((expand_forbid & RDO_DLFUNC) != 0)
6507         {
6508         expand_string_message =
6509           US"dynamically-loaded functions are not permitted";
6510         goto EXPAND_FAILED;
6511         }
6512
6513       switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
6514            TRUE, US"dlfunc", &resetok))
6515         {
6516         case 1: goto EXPAND_FAILED_CURLY;
6517         case 2:
6518         case 3: goto EXPAND_FAILED;
6519         }
6520
6521       /* If skipping, we don't actually do anything */
6522
6523       if (skipping) continue;
6524
6525       /* Look up the dynamically loaded object handle in the tree. If it isn't
6526       found, dlopen() the file and put the handle in the tree for next time. */
6527
6528       t = tree_search(dlobj_anchor, argv[0]);
6529       if (t == NULL)
6530         {
6531         void *handle = dlopen(CS argv[0], RTLD_LAZY);
6532         if (handle == NULL)
6533           {
6534           expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
6535             argv[0], dlerror());
6536           log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
6537           goto EXPAND_FAILED;
6538           }
6539         t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
6540         Ustrcpy(t->name, argv[0]);
6541         t->data.ptr = handle;
6542         (void)tree_insertnode(&dlobj_anchor, t);
6543         }
6544
6545       /* Having obtained the dynamically loaded object handle, look up the
6546       function pointer. */
6547
6548       func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
6549       if (func == NULL)
6550         {
6551         expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
6552           "%s", argv[1], argv[0], dlerror());
6553         log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
6554         goto EXPAND_FAILED;
6555         }
6556
6557       /* Call the function and work out what to do with the result. If it
6558       returns OK, we have a replacement string; if it returns DEFER then
6559       expansion has failed in a non-forced manner; if it returns FAIL then
6560       failure was forced; if it returns ERROR or any other value there's a
6561       problem, so panic slightly. In any case, assume that the function has
6562       side-effects on the store that must be preserved. */
6563
6564       resetok = FALSE;
6565       result = NULL;
6566       for (argc = 0; argv[argc] != NULL; argc++);
6567       status = func(&result, argc - 2, &argv[2]);
6568       if(status == OK)
6569         {
6570         if (result == NULL) result = US"";
6571         yield = string_cat(yield, result);
6572         continue;
6573         }
6574       else
6575         {
6576         expand_string_message = result == NULL ? US"(no message)" : result;
6577         if(status == FAIL_FORCED) f.expand_string_forcedfail = TRUE;
6578           else if(status != FAIL)
6579             log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
6580               argv[0], argv[1], status, expand_string_message);
6581         goto EXPAND_FAILED;
6582         }
6583       }
6584 #endif /* EXPAND_DLFUNC */
6585
6586     case EITEM_ENV:     /* ${env {name} {val_if_found} {val_if_unfound}} */
6587       {
6588       uschar * key;
6589       uschar *save_lookup_value = lookup_value;
6590
6591       while (isspace(*s)) s++;
6592       if (*s != '{')                                    /*}*/
6593         goto EXPAND_FAILED;
6594
6595       key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6596       if (!key) goto EXPAND_FAILED;                     /*{*/
6597       if (*s++ != '}')
6598         {
6599         expand_string_message = US"missing '{' for name arg of env";
6600         goto EXPAND_FAILED_CURLY;
6601         }
6602
6603       lookup_value = US getenv(CS key);
6604
6605       switch(process_yesno(
6606                skipping,                     /* were previously skipping */
6607                lookup_value != NULL,         /* success/failure indicator */
6608                save_lookup_value,            /* value to reset for string2 */
6609                &s,                           /* input pointer */
6610                &yield,                       /* output pointer */
6611                US"env",                      /* condition type */
6612                &resetok))
6613         {
6614         case 1: goto EXPAND_FAILED;          /* when all is well, the */
6615         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
6616         }
6617       continue;
6618       }
6619     }   /* EITEM_* switch */
6620
6621   /* Control reaches here if the name is not recognized as one of the more
6622   complicated expansion items. Check for the "operator" syntax (name terminated
6623   by a colon). Some of the operators have arguments, separated by _ from the
6624   name. */
6625
6626   if (*s == ':')
6627     {
6628     int c;
6629     uschar *arg = NULL;
6630     uschar *sub;
6631 #ifdef SUPPORT_TLS
6632     var_entry *vp = NULL;
6633 #endif
6634
6635     /* Owing to an historical mis-design, an underscore may be part of the
6636     operator name, or it may introduce arguments.  We therefore first scan the
6637     table of names that contain underscores. If there is no match, we cut off
6638     the arguments and then scan the main table. */
6639
6640     if ((c = chop_match(name, op_table_underscore,
6641                         nelem(op_table_underscore))) < 0)
6642       {
6643       arg = Ustrchr(name, '_');
6644       if (arg != NULL) *arg = 0;
6645       c = chop_match(name, op_table_main, nelem(op_table_main));
6646       if (c >= 0) c += nelem(op_table_underscore);
6647       if (arg != NULL) *arg++ = '_';   /* Put back for error messages */
6648       }
6649
6650     /* Deal specially with operators that might take a certificate variable
6651     as we do not want to do the usual expansion. For most, expand the string.*/
6652     switch(c)
6653       {
6654 #ifdef SUPPORT_TLS
6655       case EOP_MD5:
6656       case EOP_SHA1:
6657       case EOP_SHA256:
6658       case EOP_BASE64:
6659         if (s[1] == '$')
6660           {
6661           const uschar * s1 = s;
6662           sub = expand_string_internal(s+2, TRUE, &s1, skipping,
6663                   FALSE, &resetok);
6664           if (!sub)       goto EXPAND_FAILED;           /*{*/
6665           if (*s1 != '}')
6666             {
6667             expand_string_message =
6668               string_sprintf("missing '}' closing cert arg of %s", name);
6669             goto EXPAND_FAILED_CURLY;
6670             }
6671           if ((vp = find_var_ent(sub)) && vp->type == vtype_cert)
6672             {
6673             s = s1+1;
6674             break;
6675             }
6676           vp = NULL;
6677           }
6678         /*FALLTHROUGH*/
6679 #endif
6680       default:
6681         sub = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6682         if (!sub) goto EXPAND_FAILED;
6683         s++;
6684         break;
6685       }
6686
6687     /* If we are skipping, we don't need to perform the operation at all.
6688     This matters for operations like "mask", because the data may not be
6689     in the correct format when skipping. For example, the expression may test
6690     for the existence of $sender_host_address before trying to mask it. For
6691     other operations, doing them may not fail, but it is a waste of time. */
6692
6693     if (skipping && c >= 0) continue;
6694
6695     /* Otherwise, switch on the operator type */
6696
6697     switch(c)
6698       {
6699       case EOP_BASE32:
6700         {
6701         uschar *t;
6702         unsigned long int n = Ustrtoul(sub, &t, 10);
6703         gstring * g = NULL;
6704
6705         if (*t != 0)
6706           {
6707           expand_string_message = string_sprintf("argument for base32 "
6708             "operator is \"%s\", which is not a decimal number", sub);
6709           goto EXPAND_FAILED;
6710           }
6711         for ( ; n; n >>= 5)
6712           g = string_catn(g, &base32_chars[n & 0x1f], 1);
6713
6714         if (g) while (g->ptr > 0) yield = string_catn(yield, &g->s[--g->ptr], 1);
6715         continue;
6716         }
6717
6718       case EOP_BASE32D:
6719         {
6720         uschar *tt = sub;
6721         unsigned long int n = 0;
6722         uschar * s;
6723         while (*tt)
6724           {
6725           uschar * t = Ustrchr(base32_chars, *tt++);
6726           if (t == NULL)
6727             {
6728             expand_string_message = string_sprintf("argument for base32d "
6729               "operator is \"%s\", which is not a base 32 number", sub);
6730             goto EXPAND_FAILED;
6731             }
6732           n = n * 32 + (t - base32_chars);
6733           }
6734         s = string_sprintf("%ld", n);
6735         yield = string_cat(yield, s);
6736         continue;
6737         }
6738
6739       case EOP_BASE62:
6740         {
6741         uschar *t;
6742         unsigned long int n = Ustrtoul(sub, &t, 10);
6743         if (*t != 0)
6744           {
6745           expand_string_message = string_sprintf("argument for base62 "
6746             "operator is \"%s\", which is not a decimal number", sub);
6747           goto EXPAND_FAILED;
6748           }
6749         t = string_base62(n);
6750         yield = string_cat(yield, t);
6751         continue;
6752         }
6753
6754       /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
6755
6756       case EOP_BASE62D:
6757         {
6758         uschar *tt = sub;
6759         unsigned long int n = 0;
6760         while (*tt != 0)
6761           {
6762           uschar *t = Ustrchr(base62_chars, *tt++);
6763           if (t == NULL)
6764             {
6765             expand_string_message = string_sprintf("argument for base62d "
6766               "operator is \"%s\", which is not a base %d number", sub,
6767               BASE_62);
6768             goto EXPAND_FAILED;
6769             }
6770           n = n * BASE_62 + (t - base62_chars);
6771           }
6772         yield = string_fmt_append(yield, "%ld", n);
6773         continue;
6774         }
6775
6776       case EOP_EXPAND:
6777         {
6778         uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping, TRUE, &resetok);
6779         if (expanded == NULL)
6780           {
6781           expand_string_message =
6782             string_sprintf("internal expansion of \"%s\" failed: %s", sub,
6783               expand_string_message);
6784           goto EXPAND_FAILED;
6785           }
6786         yield = string_cat(yield, expanded);
6787         continue;
6788         }
6789
6790       case EOP_LC:
6791         {
6792         int count = 0;
6793         uschar *t = sub - 1;
6794         while (*(++t) != 0) { *t = tolower(*t); count++; }
6795         yield = string_catn(yield, sub, count);
6796         continue;
6797         }
6798
6799       case EOP_UC:
6800         {
6801         int count = 0;
6802         uschar *t = sub - 1;
6803         while (*(++t) != 0) { *t = toupper(*t); count++; }
6804         yield = string_catn(yield, sub, count);
6805         continue;
6806         }
6807
6808       case EOP_MD5:
6809 #ifdef SUPPORT_TLS
6810         if (vp && *(void **)vp->value)
6811           {
6812           uschar * cp = tls_cert_fprt_md5(*(void **)vp->value);
6813           yield = string_cat(yield, cp);
6814           }
6815         else
6816 #endif
6817           {
6818           md5 base;
6819           uschar digest[16];
6820           int j;
6821           md5_start(&base);
6822           md5_end(&base, sub, Ustrlen(sub), digest);
6823           for (j = 0; j < 16; j++)
6824             yield = string_fmt_append(yield, "%02x", digest[j]);
6825           }
6826         continue;
6827
6828       case EOP_SHA1:
6829 #ifdef SUPPORT_TLS
6830         if (vp && *(void **)vp->value)
6831           {
6832           uschar * cp = tls_cert_fprt_sha1(*(void **)vp->value);
6833           yield = string_cat(yield, cp);
6834           }
6835         else
6836 #endif
6837           {
6838           hctx h;
6839           uschar digest[20];
6840           int j;
6841           sha1_start(&h);
6842           sha1_end(&h, sub, Ustrlen(sub), digest);
6843           for (j = 0; j < 20; j++)
6844             yield = string_fmt_append(yield, "%02X", digest[j]);
6845           }
6846         continue;
6847
6848       case EOP_SHA256:
6849 #ifdef EXIM_HAVE_SHA2
6850         if (vp && *(void **)vp->value)
6851           {
6852           uschar * cp = tls_cert_fprt_sha256(*(void **)vp->value);
6853           yield = string_cat(yield, cp);
6854           }
6855         else
6856           {
6857           hctx h;
6858           blob b;
6859
6860           if (!exim_sha_init(&h, HASH_SHA2_256))
6861             {
6862             expand_string_message = US"unrecognised sha256 variant";
6863             goto EXPAND_FAILED;
6864             }
6865           exim_sha_update(&h, sub, Ustrlen(sub));
6866           exim_sha_finish(&h, &b);
6867           while (b.len-- > 0)
6868             yield = string_fmt_append(yield, "%02X", *b.data++);
6869           }
6870 #else
6871           expand_string_message = US"sha256 only supported with TLS";
6872 #endif
6873         continue;
6874
6875       case EOP_SHA3:
6876 #ifdef EXIM_HAVE_SHA3
6877         {
6878         hctx h;
6879         blob b;
6880         hashmethod m = !arg ? HASH_SHA3_256
6881           : Ustrcmp(arg, "224") == 0 ? HASH_SHA3_224
6882           : Ustrcmp(arg, "256") == 0 ? HASH_SHA3_256
6883           : Ustrcmp(arg, "384") == 0 ? HASH_SHA3_384
6884           : Ustrcmp(arg, "512") == 0 ? HASH_SHA3_512
6885           : HASH_BADTYPE;
6886
6887         if (m == HASH_BADTYPE || !exim_sha_init(&h, m))
6888           {
6889           expand_string_message = US"unrecognised sha3 variant";
6890           goto EXPAND_FAILED;
6891           }
6892
6893         exim_sha_update(&h, sub, Ustrlen(sub));
6894         exim_sha_finish(&h, &b);
6895         while (b.len-- > 0)
6896           yield = string_fmt_append(yield, "%02X", *b.data++);
6897         }
6898         continue;
6899 #else
6900         expand_string_message = US"sha3 only supported with GnuTLS 3.5.0 + or OpenSSL 1.1.1 +";
6901         goto EXPAND_FAILED;
6902 #endif
6903
6904       /* Convert hex encoding to base64 encoding */
6905
6906       case EOP_HEX2B64:
6907         {
6908         int c = 0;
6909         int b = -1;
6910         uschar *in = sub;
6911         uschar *out = sub;
6912         uschar *enc;
6913
6914         for (enc = sub; *enc != 0; enc++)
6915           {
6916           if (!isxdigit(*enc))
6917             {
6918             expand_string_message = string_sprintf("\"%s\" is not a hex "
6919               "string", sub);
6920             goto EXPAND_FAILED;
6921             }
6922           c++;
6923           }
6924
6925         if ((c & 1) != 0)
6926           {
6927           expand_string_message = string_sprintf("\"%s\" contains an odd "
6928             "number of characters", sub);
6929           goto EXPAND_FAILED;
6930           }
6931
6932         while ((c = *in++) != 0)
6933           {
6934           if (isdigit(c)) c -= '0';
6935           else c = toupper(c) - 'A' + 10;
6936           if (b == -1)
6937             {
6938             b = c << 4;
6939             }
6940           else
6941             {
6942             *out++ = b | c;
6943             b = -1;
6944             }
6945           }
6946
6947         enc = b64encode(sub, out - sub);
6948         yield = string_cat(yield, enc);
6949         continue;
6950         }
6951
6952       /* Convert octets outside 0x21..0x7E to \xXX form */
6953
6954       case EOP_HEXQUOTE:
6955         {
6956         uschar *t = sub - 1;
6957         while (*(++t) != 0)
6958           {
6959           if (*t < 0x21 || 0x7E < *t)
6960             yield = string_fmt_append(yield, "\\x%02x", *t);
6961           else
6962             yield = string_catn(yield, t, 1);
6963           }
6964         continue;
6965         }
6966
6967       /* count the number of list elements */
6968
6969       case EOP_LISTCOUNT:
6970         {
6971         int cnt = 0;
6972         int sep = 0;
6973         uschar buffer[256];
6974
6975         while (string_nextinlist(CUSS &sub, &sep, buffer, sizeof(buffer)) != NULL) cnt++;
6976         yield = string_fmt_append(yield, "%d", cnt);
6977         continue;
6978         }
6979
6980       /* expand a named list given the name */
6981       /* handles nested named lists; requotes as colon-sep list */
6982
6983       case EOP_LISTNAMED:
6984         {
6985         tree_node *t = NULL;
6986         const uschar * list;
6987         int sep = 0;
6988         uschar * item;
6989         uschar * suffix = US"";
6990         BOOL needsep = FALSE;
6991         uschar buffer[256];
6992
6993         if (*sub == '+') sub++;
6994         if (arg == NULL)        /* no-argument version */
6995           {
6996           if (!(t = tree_search(addresslist_anchor, sub)) &&
6997               !(t = tree_search(domainlist_anchor,  sub)) &&
6998               !(t = tree_search(hostlist_anchor,    sub)))
6999             t = tree_search(localpartlist_anchor, sub);
7000           }
7001         else switch(*arg)       /* specific list-type version */
7002           {
7003           case 'a': t = tree_search(addresslist_anchor,   sub); suffix = US"_a"; break;
7004           case 'd': t = tree_search(domainlist_anchor,    sub); suffix = US"_d"; break;
7005           case 'h': t = tree_search(hostlist_anchor,      sub); suffix = US"_h"; break;
7006           case 'l': t = tree_search(localpartlist_anchor, sub); suffix = US"_l"; break;
7007           default:
7008             expand_string_message = string_sprintf("bad suffix on \"list\" operator");
7009             goto EXPAND_FAILED;
7010           }
7011
7012         if(!t)
7013           {
7014           expand_string_message = string_sprintf("\"%s\" is not a %snamed list",
7015             sub, !arg?""
7016               : *arg=='a'?"address "
7017               : *arg=='d'?"domain "
7018               : *arg=='h'?"host "
7019               : *arg=='l'?"localpart "
7020               : 0);
7021           goto EXPAND_FAILED;
7022           }
7023
7024         list = ((namedlist_block *)(t->data.ptr))->string;
7025
7026         while ((item = string_nextinlist(&list, &sep, buffer, sizeof(buffer))))
7027           {
7028           uschar * buf = US" : ";
7029           if (needsep)
7030             yield = string_catn(yield, buf, 3);
7031           else
7032             needsep = TRUE;
7033
7034           if (*item == '+')     /* list item is itself a named list */
7035             {
7036             uschar * sub = string_sprintf("${listnamed%s:%s}", suffix, item);
7037             item = expand_string_internal(sub, FALSE, NULL, FALSE, TRUE, &resetok);
7038             }
7039           else if (sep != ':')  /* item from non-colon-sep list, re-quote for colon list-separator */
7040             {
7041             char * cp;
7042             char tok[3];
7043             tok[0] = sep; tok[1] = ':'; tok[2] = 0;
7044             while ((cp= strpbrk(CCS item, tok)))
7045               {
7046               yield = string_catn(yield, item, cp - CS item);
7047               if (*cp++ == ':') /* colon in a non-colon-sep list item, needs doubling */
7048                 {
7049                 yield = string_catn(yield, US"::", 2);
7050                 item = US cp;
7051                 }
7052               else              /* sep in item; should already be doubled; emit once */
7053                 {
7054                 yield = string_catn(yield, US tok, 1);
7055                 if (*cp == sep) cp++;
7056                 item = US cp;
7057                 }
7058               }
7059             }
7060           yield = string_cat(yield, item);
7061           }
7062         continue;
7063         }
7064
7065       /* mask applies a mask to an IP address; for example the result of
7066       ${mask:131.111.10.206/28} is 131.111.10.192/28. */
7067
7068       case EOP_MASK:
7069         {
7070         int count;
7071         uschar *endptr;
7072         int binary[4];
7073         int mask, maskoffset;
7074         int type = string_is_ip_address(sub, &maskoffset);
7075         uschar buffer[64];
7076
7077         if (type == 0)
7078           {
7079           expand_string_message = string_sprintf("\"%s\" is not an IP address",
7080            sub);
7081           goto EXPAND_FAILED;
7082           }
7083
7084         if (maskoffset == 0)
7085           {
7086           expand_string_message = string_sprintf("missing mask value in \"%s\"",
7087             sub);
7088           goto EXPAND_FAILED;
7089           }
7090
7091         mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
7092
7093         if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
7094           {
7095           expand_string_message = string_sprintf("mask value too big in \"%s\"",
7096             sub);
7097           goto EXPAND_FAILED;
7098           }
7099
7100         /* Convert the address to binary integer(s) and apply the mask */
7101
7102         sub[maskoffset] = 0;
7103         count = host_aton(sub, binary);
7104         host_mask(count, binary, mask);
7105
7106         /* Convert to masked textual format and add to output. */
7107
7108         yield = string_catn(yield, buffer,
7109           host_nmtoa(count, binary, mask, buffer, '.'));
7110         continue;
7111         }
7112
7113       case EOP_IPV6NORM:
7114       case EOP_IPV6DENORM:
7115         {
7116         int type = string_is_ip_address(sub, NULL);
7117         int binary[4];
7118         uschar buffer[44];
7119
7120         switch (type)
7121           {
7122           case 6:
7123             (void) host_aton(sub, binary);
7124             break;
7125
7126           case 4:       /* convert to IPv4-mapped IPv6 */
7127             binary[0] = binary[1] = 0;
7128             binary[2] = 0x0000ffff;
7129             (void) host_aton(sub, binary+3);
7130             break;
7131
7132           case 0:
7133             expand_string_message =
7134               string_sprintf("\"%s\" is not an IP address", sub);
7135             goto EXPAND_FAILED;
7136           }
7137
7138         yield = string_catn(yield, buffer, c == EOP_IPV6NORM
7139                     ? ipv6_nmtoa(binary, buffer)
7140                     : host_nmtoa(4, binary, -1, buffer, ':')
7141                   );
7142         continue;
7143         }
7144
7145       case EOP_ADDRESS:
7146       case EOP_LOCAL_PART:
7147       case EOP_DOMAIN:
7148         {
7149         uschar * error;
7150         int start, end, domain;
7151         uschar * t = parse_extract_address(sub, &error, &start, &end, &domain,
7152           FALSE);
7153         if (t)
7154           if (c != EOP_DOMAIN)
7155             {
7156             if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
7157             yield = string_catn(yield, sub+start, end-start);
7158             }
7159           else if (domain != 0)
7160             {
7161             domain += start;
7162             yield = string_catn(yield, sub+domain, end-domain);
7163             }
7164         continue;
7165         }
7166
7167       case EOP_ADDRESSES:
7168         {
7169         uschar outsep[2] = { ':', '\0' };
7170         uschar *address, *error;
7171         int save_ptr = yield->ptr;
7172         int start, end, domain;  /* Not really used */
7173
7174         while (isspace(*sub)) sub++;
7175         if (*sub == '>')
7176           if (*outsep = *++sub) ++sub;
7177           else
7178             {
7179             expand_string_message = string_sprintf("output separator "
7180               "missing in expanding ${addresses:%s}", --sub);
7181             goto EXPAND_FAILED;
7182             }
7183         f.parse_allow_group = TRUE;
7184
7185         for (;;)
7186           {
7187           uschar *p = parse_find_address_end(sub, FALSE);
7188           uschar saveend = *p;
7189           *p = '\0';
7190           address = parse_extract_address(sub, &error, &start, &end, &domain,
7191             FALSE);
7192           *p = saveend;
7193
7194           /* Add the address to the output list that we are building. This is
7195           done in chunks by searching for the separator character. At the
7196           start, unless we are dealing with the first address of the output
7197           list, add in a space if the new address begins with the separator
7198           character, or is an empty string. */
7199
7200           if (address != NULL)
7201             {
7202             if (yield->ptr != save_ptr && address[0] == *outsep)
7203               yield = string_catn(yield, US" ", 1);
7204
7205             for (;;)
7206               {
7207               size_t seglen = Ustrcspn(address, outsep);
7208               yield = string_catn(yield, address, seglen + 1);
7209
7210               /* If we got to the end of the string we output one character
7211               too many. */
7212
7213               if (address[seglen] == '\0') { yield->ptr--; break; }
7214               yield = string_catn(yield, outsep, 1);
7215               address += seglen + 1;
7216               }
7217
7218             /* Output a separator after the string: we will remove the
7219             redundant final one at the end. */
7220
7221             yield = string_catn(yield, outsep, 1);
7222             }
7223
7224           if (saveend == '\0') break;
7225           sub = p + 1;
7226           }
7227
7228         /* If we have generated anything, remove the redundant final
7229         separator. */
7230
7231         if (yield->ptr != save_ptr) yield->ptr--;
7232         f.parse_allow_group = FALSE;
7233         continue;
7234         }
7235
7236
7237       /* quote puts a string in quotes if it is empty or contains anything
7238       other than alphamerics, underscore, dot, or hyphen.
7239
7240       quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
7241       be quoted in order to be a valid local part.
7242
7243       In both cases, newlines and carriage returns are converted into \n and \r
7244       respectively */
7245
7246       case EOP_QUOTE:
7247       case EOP_QUOTE_LOCAL_PART:
7248       if (arg == NULL)
7249         {
7250         BOOL needs_quote = (*sub == 0);      /* TRUE for empty string */
7251         uschar *t = sub - 1;
7252
7253         if (c == EOP_QUOTE)
7254           {
7255           while (!needs_quote && *(++t) != 0)
7256             needs_quote = !isalnum(*t) && !strchr("_-.", *t);
7257           }
7258         else  /* EOP_QUOTE_LOCAL_PART */
7259           {
7260           while (!needs_quote && *(++t) != 0)
7261             needs_quote = !isalnum(*t) &&
7262               strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
7263               (*t != '.' || t == sub || t[1] == 0);
7264           }
7265
7266         if (needs_quote)
7267           {
7268           yield = string_catn(yield, US"\"", 1);
7269           t = sub - 1;
7270           while (*(++t) != 0)
7271             {
7272             if (*t == '\n')
7273               yield = string_catn(yield, US"\\n", 2);
7274             else if (*t == '\r')
7275               yield = string_catn(yield, US"\\r", 2);
7276             else
7277               {
7278               if (*t == '\\' || *t == '"')
7279                 yield = string_catn(yield, US"\\", 1);
7280               yield = string_catn(yield, t, 1);
7281               }
7282             }
7283           yield = string_catn(yield, US"\"", 1);
7284           }
7285         else yield = string_cat(yield, sub);
7286         continue;
7287         }
7288
7289       /* quote_lookuptype does lookup-specific quoting */
7290
7291       else
7292         {
7293         int n;
7294         uschar *opt = Ustrchr(arg, '_');
7295
7296         if (opt != NULL) *opt++ = 0;
7297
7298         n = search_findtype(arg, Ustrlen(arg));
7299         if (n < 0)
7300           {
7301           expand_string_message = search_error_message;
7302           goto EXPAND_FAILED;
7303           }
7304
7305         if (lookup_list[n]->quote != NULL)
7306           sub = (lookup_list[n]->quote)(sub, opt);
7307         else if (opt != NULL) sub = NULL;
7308
7309         if (sub == NULL)
7310           {
7311           expand_string_message = string_sprintf(
7312             "\"%s\" unrecognized after \"${quote_%s\"",
7313             opt, arg);
7314           goto EXPAND_FAILED;
7315           }
7316
7317         yield = string_cat(yield, sub);
7318         continue;
7319         }
7320
7321       /* rx quote sticks in \ before any non-alphameric character so that
7322       the insertion works in a regular expression. */
7323
7324       case EOP_RXQUOTE:
7325         {
7326         uschar *t = sub - 1;
7327         while (*(++t) != 0)
7328           {
7329           if (!isalnum(*t))
7330             yield = string_catn(yield, US"\\", 1);
7331           yield = string_catn(yield, t, 1);
7332           }
7333         continue;
7334         }
7335
7336       /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
7337       prescribed by the RFC, if there are characters that need to be encoded */
7338
7339       case EOP_RFC2047:
7340         {
7341         uschar buffer[2048];
7342         yield = string_cat(yield,
7343                             parse_quote_2047(sub, Ustrlen(sub), headers_charset,
7344                               buffer, sizeof(buffer), FALSE));
7345         continue;
7346         }
7347
7348       /* RFC 2047 decode */
7349
7350       case EOP_RFC2047D:
7351         {
7352         int len;
7353         uschar *error;
7354         uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
7355           headers_charset, '?', &len, &error);
7356         if (error != NULL)
7357           {
7358           expand_string_message = error;
7359           goto EXPAND_FAILED;
7360           }
7361         yield = string_catn(yield, decoded, len);
7362         continue;
7363         }
7364
7365       /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
7366       underscores */
7367
7368       case EOP_FROM_UTF8:
7369         {
7370         while (*sub != 0)
7371           {
7372           int c;
7373           uschar buff[4];
7374           GETUTF8INC(c, sub);
7375           if (c > 255) c = '_';
7376           buff[0] = c;
7377           yield = string_catn(yield, buff, 1);
7378           }
7379         continue;
7380         }
7381
7382           /* replace illegal UTF-8 sequences by replacement character  */
7383
7384       #define UTF8_REPLACEMENT_CHAR US"?"
7385
7386       case EOP_UTF8CLEAN:
7387         {
7388         int seq_len = 0, index = 0;
7389         int bytes_left = 0;
7390         long codepoint = -1;
7391         int complete;
7392         uschar seq_buff[4];                     /* accumulate utf-8 here */
7393
7394         while (*sub != 0)
7395           {
7396           complete = 0;
7397           uschar c = *sub++;
7398
7399           if (bytes_left)
7400             {
7401             if ((c & 0xc0) != 0x80)
7402                     /* wrong continuation byte; invalidate all bytes */
7403               complete = 1; /* error */
7404             else
7405               {
7406               codepoint = (codepoint << 6) | (c & 0x3f);
7407               seq_buff[index++] = c;
7408               if (--bytes_left == 0)            /* codepoint complete */
7409                 if(codepoint > 0x10FFFF)        /* is it too large? */
7410                   complete = -1;        /* error (RFC3629 limit) */
7411                 else
7412                   {             /* finished; output utf-8 sequence */
7413                   yield = string_catn(yield, seq_buff, seq_len);
7414                   index = 0;
7415                   }
7416               }
7417             }
7418           else  /* no bytes left: new sequence */
7419             {
7420             if((c & 0x80) == 0) /* 1-byte sequence, US-ASCII, keep it */
7421               {
7422               yield = string_catn(yield, &c, 1);
7423               continue;
7424               }
7425             if((c & 0xe0) == 0xc0)              /* 2-byte sequence */
7426               {
7427               if(c == 0xc0 || c == 0xc1)        /* 0xc0 and 0xc1 are illegal */
7428                 complete = -1;
7429               else
7430                 {
7431                   bytes_left = 1;
7432                   codepoint = c & 0x1f;
7433                 }
7434               }
7435             else if((c & 0xf0) == 0xe0)         /* 3-byte sequence */
7436               {
7437               bytes_left = 2;
7438               codepoint = c & 0x0f;
7439               }
7440             else if((c & 0xf8) == 0xf0)         /* 4-byte sequence */
7441               {
7442               bytes_left = 3;
7443               codepoint = c & 0x07;
7444               }
7445             else        /* invalid or too long (RFC3629 allows only 4 bytes) */
7446               complete = -1;
7447
7448             seq_buff[index++] = c;
7449             seq_len = bytes_left + 1;
7450             }           /* if(bytes_left) */
7451
7452           if (complete != 0)
7453             {
7454             bytes_left = index = 0;
7455             yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
7456             }
7457           if ((complete == 1) && ((c & 0x80) == 0))
7458                         /* ASCII character follows incomplete sequence */
7459               yield = string_catn(yield, &c, 1);
7460           }
7461         /* If given a sequence truncated mid-character, we also want to report ?
7462         * Eg, ${length_1:フィル} is one byte, not one character, so we expect
7463         * ${utf8clean:${length_1:フィル}} to yield '?' */
7464         if (bytes_left != 0)
7465           {
7466           yield = string_catn(yield, UTF8_REPLACEMENT_CHAR, 1);
7467           }
7468         continue;
7469         }
7470
7471 #ifdef SUPPORT_I18N
7472       case EOP_UTF8_DOMAIN_TO_ALABEL:
7473         {
7474         uschar * error = NULL;
7475         uschar * s = string_domain_utf8_to_alabel(sub, &error);
7476         if (error)
7477           {
7478           expand_string_message = string_sprintf(
7479             "error converting utf8 (%s) to alabel: %s",
7480             string_printing(sub), error);
7481           goto EXPAND_FAILED;
7482           }
7483         yield = string_cat(yield, s);
7484         continue;
7485         }
7486
7487       case EOP_UTF8_DOMAIN_FROM_ALABEL:
7488         {
7489         uschar * error = NULL;
7490         uschar * s = string_domain_alabel_to_utf8(sub, &error);
7491         if (error)
7492           {
7493           expand_string_message = string_sprintf(
7494             "error converting alabel (%s) to utf8: %s",
7495             string_printing(sub), error);
7496           goto EXPAND_FAILED;
7497           }
7498         yield = string_cat(yield, s);
7499         continue;
7500         }
7501
7502       case EOP_UTF8_LOCALPART_TO_ALABEL:
7503         {
7504         uschar * error = NULL;
7505         uschar * s = string_localpart_utf8_to_alabel(sub, &error);
7506         if (error)
7507           {
7508           expand_string_message = string_sprintf(
7509             "error converting utf8 (%s) to alabel: %s",
7510             string_printing(sub), error);
7511           goto EXPAND_FAILED;
7512           }
7513         yield = string_cat(yield, s);
7514         DEBUG(D_expand) debug_printf_indent("yield: '%s'\n", yield->s);
7515         continue;
7516         }
7517
7518       case EOP_UTF8_LOCALPART_FROM_ALABEL:
7519         {
7520         uschar * error = NULL;
7521         uschar * s = string_localpart_alabel_to_utf8(sub, &error);
7522         if (error)
7523           {
7524           expand_string_message = string_sprintf(
7525             "error converting alabel (%s) to utf8: %s",
7526             string_printing(sub), error);
7527           goto EXPAND_FAILED;
7528           }
7529         yield = string_cat(yield, s);
7530         continue;
7531         }
7532 #endif  /* EXPERIMENTAL_INTERNATIONAL */
7533
7534       /* escape turns all non-printing characters into escape sequences. */
7535
7536       case EOP_ESCAPE:
7537         {
7538         const uschar * t = string_printing(sub);
7539         yield = string_cat(yield, t);
7540         continue;
7541         }
7542
7543       case EOP_ESCAPE8BIT:
7544         {
7545         const uschar * s = sub;
7546         uschar c;
7547
7548         for (s = sub; (c = *s); s++)
7549           yield = c < 127 && c != '\\'
7550             ? string_catn(yield, s, 1)
7551             : string_fmt_append(yield, "\\%03o", c);
7552         continue;
7553         }
7554
7555       /* Handle numeric expression evaluation */
7556
7557       case EOP_EVAL:
7558       case EOP_EVAL10:
7559         {
7560         uschar *save_sub = sub;
7561         uschar *error = NULL;
7562         int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
7563         if (error)
7564           {
7565           expand_string_message = string_sprintf("error in expression "
7566             "evaluation: %s (after processing \"%.*s\")", error,
7567             (int)(sub-save_sub), save_sub);
7568           goto EXPAND_FAILED;
7569           }
7570         yield = string_fmt_append(yield, PR_EXIM_ARITH, n);
7571         continue;
7572         }
7573
7574       /* Handle time period formatting */
7575
7576       case EOP_TIME_EVAL:
7577         {
7578         int n = readconf_readtime(sub, 0, FALSE);
7579         if (n < 0)
7580           {
7581           expand_string_message = string_sprintf("string \"%s\" is not an "
7582             "Exim time interval in \"%s\" operator", sub, name);
7583           goto EXPAND_FAILED;
7584           }
7585         yield = string_fmt_append(yield, "%d", n);
7586         continue;
7587         }
7588
7589       case EOP_TIME_INTERVAL:
7590         {
7591         int n;
7592         uschar *t = read_number(&n, sub);
7593         if (*t != 0) /* Not A Number*/
7594           {
7595           expand_string_message = string_sprintf("string \"%s\" is not a "
7596             "positive number in \"%s\" operator", sub, name);
7597           goto EXPAND_FAILED;
7598           }
7599         t = readconf_printtime(n);
7600         yield = string_cat(yield, t);
7601         continue;
7602         }
7603
7604       /* Convert string to base64 encoding */
7605
7606       case EOP_STR2B64:
7607       case EOP_BASE64:
7608         {
7609 #ifdef SUPPORT_TLS
7610         uschar * s = vp && *(void **)vp->value
7611           ? tls_cert_der_b64(*(void **)vp->value)
7612           : b64encode(sub, Ustrlen(sub));
7613 #else
7614         uschar * s = b64encode(sub, Ustrlen(sub));
7615 #endif
7616         yield = string_cat(yield, s);
7617         continue;
7618         }
7619
7620       case EOP_BASE64D:
7621         {
7622         uschar * s;
7623         int len = b64decode(sub, &s);
7624         if (len < 0)
7625           {
7626           expand_string_message = string_sprintf("string \"%s\" is not "
7627             "well-formed for \"%s\" operator", sub, name);
7628           goto EXPAND_FAILED;
7629           }
7630         yield = string_cat(yield, s);
7631         continue;
7632         }
7633
7634       /* strlen returns the length of the string */
7635
7636       case EOP_STRLEN:
7637         yield = string_fmt_append(yield, "%d", Ustrlen(sub));
7638         continue;
7639
7640       /* length_n or l_n takes just the first n characters or the whole string,
7641       whichever is the shorter;
7642
7643       substr_m_n, and s_m_n take n characters from offset m; negative m take
7644       from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
7645       takes the rest, either to the right or to the left.
7646
7647       hash_n or h_n makes a hash of length n from the string, yielding n
7648       characters from the set a-z; hash_n_m makes a hash of length n, but
7649       uses m characters from the set a-zA-Z0-9.
7650
7651       nhash_n returns a single number between 0 and n-1 (in text form), while
7652       nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
7653       between 0 and n-1 and the second between 0 and m-1. */
7654
7655       case EOP_LENGTH:
7656       case EOP_L:
7657       case EOP_SUBSTR:
7658       case EOP_S:
7659       case EOP_HASH:
7660       case EOP_H:
7661       case EOP_NHASH:
7662       case EOP_NH:
7663         {
7664         int sign = 1;
7665         int value1 = 0;
7666         int value2 = -1;
7667         int *pn;
7668         int len;
7669         uschar *ret;
7670
7671         if (!arg)
7672           {
7673           expand_string_message = string_sprintf("missing values after %s",
7674             name);
7675           goto EXPAND_FAILED;
7676           }
7677
7678         /* "length" has only one argument, effectively being synonymous with
7679         substr_0_n. */
7680
7681         if (c == EOP_LENGTH || c == EOP_L)
7682           {
7683           pn = &value2;
7684           value2 = 0;
7685           }
7686
7687         /* The others have one or two arguments; for "substr" the first may be
7688         negative. The second being negative means "not supplied". */
7689
7690         else
7691           {
7692           pn = &value1;
7693           if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
7694           }
7695
7696         /* Read up to two numbers, separated by underscores */
7697
7698         ret = arg;
7699         while (*arg != 0)
7700           {
7701           if (arg != ret && *arg == '_' && pn == &value1)
7702             {
7703             pn = &value2;
7704             value2 = 0;
7705             if (arg[1] != 0) arg++;
7706             }
7707           else if (!isdigit(*arg))
7708             {
7709             expand_string_message =
7710               string_sprintf("non-digit after underscore in \"%s\"", name);
7711             goto EXPAND_FAILED;
7712             }
7713           else *pn = (*pn)*10 + *arg++ - '0';
7714           }
7715         value1 *= sign;
7716
7717         /* Perform the required operation */
7718
7719         ret =
7720           (c == EOP_HASH || c == EOP_H)?
7721              compute_hash(sub, value1, value2, &len) :
7722           (c == EOP_NHASH || c == EOP_NH)?
7723              compute_nhash(sub, value1, value2, &len) :
7724              extract_substr(sub, value1, value2, &len);
7725
7726         if (ret == NULL) goto EXPAND_FAILED;
7727         yield = string_catn(yield, ret, len);
7728         continue;
7729         }
7730
7731       /* Stat a path */
7732
7733       case EOP_STAT:
7734         {
7735         uschar smode[12];
7736         uschar **modetable[3];
7737         int i;
7738         mode_t mode;
7739         struct stat st;
7740
7741         if (expand_forbid & RDO_EXISTS)
7742           {
7743           expand_string_message = US"Use of the stat() expansion is not permitted";
7744           goto EXPAND_FAILED;
7745           }
7746
7747         if (stat(CS sub, &st) < 0)
7748           {
7749           expand_string_message = string_sprintf("stat(%s) failed: %s",
7750             sub, strerror(errno));
7751           goto EXPAND_FAILED;
7752           }
7753         mode = st.st_mode;
7754         switch (mode & S_IFMT)
7755           {
7756           case S_IFIFO: smode[0] = 'p'; break;
7757           case S_IFCHR: smode[0] = 'c'; break;
7758           case S_IFDIR: smode[0] = 'd'; break;
7759           case S_IFBLK: smode[0] = 'b'; break;
7760           case S_IFREG: smode[0] = '-'; break;
7761           default: smode[0] = '?'; break;
7762           }
7763
7764         modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
7765         modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
7766         modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
7767
7768         for (i = 0; i < 3; i++)
7769           {
7770           memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
7771           mode >>= 3;
7772           }
7773
7774         smode[10] = 0;
7775         yield = string_fmt_append(yield,
7776           "mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
7777           "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
7778           (long)(st.st_mode & 077777), smode, (long)st.st_ino,
7779           (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
7780           (long)st.st_gid, st.st_size, (long)st.st_atime,
7781           (long)st.st_mtime, (long)st.st_ctime);
7782         continue;
7783         }
7784
7785       /* vaguely random number less than N */
7786
7787       case EOP_RANDINT:
7788         {
7789         int_eximarith_t max = expanded_string_integer(sub, TRUE);
7790
7791         if (expand_string_message)
7792           goto EXPAND_FAILED;
7793         yield = string_fmt_append(yield, "%d", vaguely_random_number((int)max));
7794         continue;
7795         }
7796
7797       /* Reverse IP, including IPv6 to dotted-nibble */
7798
7799       case EOP_REVERSE_IP:
7800         {
7801         int family, maskptr;
7802         uschar reversed[128];
7803
7804         family = string_is_ip_address(sub, &maskptr);
7805         if (family == 0)
7806           {
7807           expand_string_message = string_sprintf(
7808               "reverse_ip() not given an IP address [%s]", sub);
7809           goto EXPAND_FAILED;
7810           }
7811         invert_address(reversed, sub);
7812         yield = string_cat(yield, reversed);
7813         continue;
7814         }
7815
7816       /* Unknown operator */
7817
7818       default:
7819         expand_string_message =
7820           string_sprintf("unknown expansion operator \"%s\"", name);
7821         goto EXPAND_FAILED;
7822       }
7823     }
7824
7825   /* Handle a plain name. If this is the first thing in the expansion, release
7826   the pre-allocated buffer. If the result data is known to be in a new buffer,
7827   newsize will be set to the size of that buffer, and we can just point at that
7828   store instead of copying. Many expansion strings contain just one reference,
7829   so this is a useful optimization, especially for humungous headers
7830   ($message_headers). */
7831                                                 /*{*/
7832   if (*s++ == '}')
7833     {
7834     int len;
7835     int newsize = 0;
7836     gstring * g = NULL;
7837
7838     if (!yield)
7839       g = store_get(sizeof(gstring));
7840     else if (yield->ptr == 0)
7841       {
7842       if (resetok) store_reset(yield);
7843       yield = NULL;
7844       g = store_get(sizeof(gstring));   /* alloc _before_ calling find_variable() */
7845       }
7846     if (!(value = find_variable(name, FALSE, skipping, &newsize)))
7847       {
7848       expand_string_message =
7849         string_sprintf("unknown variable in \"${%s}\"", name);
7850       check_variable_error_message(name);
7851       goto EXPAND_FAILED;
7852       }
7853     len = Ustrlen(value);
7854     if (!yield && newsize)
7855       {
7856       yield = g;
7857       yield->size = newsize;
7858       yield->ptr = len;
7859       yield->s = value;
7860       }
7861     else
7862       yield = string_catn(yield, value, len);
7863     continue;
7864     }
7865
7866   /* Else there's something wrong */
7867
7868   expand_string_message =
7869     string_sprintf("\"${%s\" is not a known operator (or a } is missing "
7870     "in a variable reference)", name);
7871   goto EXPAND_FAILED;
7872   }
7873
7874 /* If we hit the end of the string when ket_ends is set, there is a missing
7875 terminating brace. */
7876
7877 if (ket_ends && *s == 0)
7878   {
7879   expand_string_message = malformed_header
7880     ? US"missing } at end of string - could be header name not terminated by colon"
7881     : US"missing } at end of string";
7882   goto EXPAND_FAILED;
7883   }
7884
7885 /* Expansion succeeded; yield may still be NULL here if nothing was actually
7886 added to the string. If so, set up an empty string. Add a terminating zero. If
7887 left != NULL, return a pointer to the terminator. */
7888
7889 if (!yield)
7890   yield = string_get(1);
7891 (void) string_from_gstring(yield);
7892 if (left) *left = s;
7893
7894 /* Any stacking store that was used above the final string is no longer needed.
7895 In many cases the final string will be the first one that was got and so there
7896 will be optimal store usage. */
7897
7898 if (resetok) store_reset(yield->s + (yield->size = yield->ptr + 1));
7899 else if (resetok_p) *resetok_p = FALSE;
7900
7901 DEBUG(D_expand)
7902   DEBUG(D_noutf8)
7903     {
7904     debug_printf_indent("|--expanding: %.*s\n", (int)(s - string), string);
7905     debug_printf_indent("%sresult: %s\n",
7906       skipping ? "|-----" : "\\_____", yield->s);
7907     if (skipping)
7908       debug_printf_indent("\\___skipping: result is not used\n");
7909     }
7910   else
7911     {
7912     debug_printf_indent(UTF8_VERT_RIGHT UTF8_HORIZ UTF8_HORIZ
7913       "expanding: %.*s\n",
7914       (int)(s - string), string);
7915     debug_printf_indent("%s"
7916       UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
7917       "result: %s\n",
7918       skipping ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
7919       yield->s);
7920     if (skipping)
7921       debug_printf_indent(UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
7922         "skipping: result is not used\n");
7923     }
7924 expand_level--;
7925 return yield->s;
7926
7927 /* This is the failure exit: easiest to program with a goto. We still need
7928 to update the pointer to the terminator, for cases of nested calls with "fail".
7929 */
7930
7931 EXPAND_FAILED_CURLY:
7932 if (malformed_header)
7933   expand_string_message =
7934     US"missing or misplaced { or } - could be header name not terminated by colon";
7935
7936 else if (!expand_string_message || !*expand_string_message)
7937   expand_string_message = US"missing or misplaced { or }";
7938
7939 /* At one point, Exim reset the store to yield (if yield was not NULL), but
7940 that is a bad idea, because expand_string_message is in dynamic store. */
7941
7942 EXPAND_FAILED:
7943 if (left) *left = s;
7944 DEBUG(D_expand)
7945   DEBUG(D_noutf8)
7946     {
7947     debug_printf_indent("|failed to expand: %s\n", string);
7948     debug_printf_indent("%serror message: %s\n",
7949       f.expand_string_forcedfail ? "|---" : "\\___", expand_string_message);
7950     if (f.expand_string_forcedfail)
7951       debug_printf_indent("\\failure was forced\n");
7952     }
7953   else
7954     {
7955     debug_printf_indent(UTF8_VERT_RIGHT "failed to expand: %s\n",
7956       string);
7957     debug_printf_indent("%s" UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
7958       "error message: %s\n",
7959       f.expand_string_forcedfail ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
7960       expand_string_message);
7961     if (f.expand_string_forcedfail)
7962       debug_printf_indent(UTF8_UP_RIGHT "failure was forced\n");
7963     }
7964 if (resetok_p && !resetok) *resetok_p = FALSE;
7965 expand_level--;
7966 return NULL;
7967 }
7968
7969
7970 /* This is the external function call. Do a quick check for any expansion
7971 metacharacters, and if there are none, just return the input string.
7972
7973 Argument: the string to be expanded
7974 Returns:  the expanded string, or NULL if expansion failed; if failure was
7975           due to a lookup deferring, search_find_defer will be TRUE
7976 */
7977
7978 const uschar *
7979 expand_cstring(const uschar * string)
7980 {
7981 if (Ustrpbrk(string, "$\\") != NULL)
7982   {
7983   int old_pool = store_pool;
7984   uschar * s;
7985
7986   f.search_find_defer = FALSE;
7987   malformed_header = FALSE;
7988   store_pool = POOL_MAIN;
7989     s = expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
7990   store_pool = old_pool;
7991   return s;
7992   }
7993 return string;
7994 }
7995
7996
7997 uschar *
7998 expand_string(uschar * string)
7999 {
8000 return US expand_cstring(CUS string);
8001 }
8002
8003
8004
8005
8006
8007 /*************************************************
8008 *              Expand and copy                   *
8009 *************************************************/
8010
8011 /* Now and again we want to expand a string and be sure that the result is in a
8012 new bit of store. This function does that.
8013 Since we know it has been copied, the de-const cast is safe.
8014
8015 Argument: the string to be expanded
8016 Returns:  the expanded string, always in a new bit of store, or NULL
8017 */
8018
8019 uschar *
8020 expand_string_copy(const uschar *string)
8021 {
8022 const uschar *yield = expand_cstring(string);
8023 if (yield == string) yield = string_copy(string);
8024 return US yield;
8025 }
8026
8027
8028
8029 /*************************************************
8030 *        Expand and interpret as an integer      *
8031 *************************************************/
8032
8033 /* Expand a string, and convert the result into an integer.
8034
8035 Arguments:
8036   string  the string to be expanded
8037   isplus  TRUE if a non-negative number is expected
8038
8039 Returns:  the integer value, or
8040           -1 for an expansion error               ) in both cases, message in
8041           -2 for an integer interpretation error  ) expand_string_message
8042           expand_string_message is set NULL for an OK integer
8043 */
8044
8045 int_eximarith_t
8046 expand_string_integer(uschar *string, BOOL isplus)
8047 {
8048 return expanded_string_integer(expand_string(string), isplus);
8049 }
8050
8051
8052 /*************************************************
8053  *         Interpret string as an integer        *
8054  *************************************************/
8055
8056 /* Convert a string (that has already been expanded) into an integer.
8057
8058 This function is used inside the expansion code.
8059
8060 Arguments:
8061   s       the string to be expanded
8062   isplus  TRUE if a non-negative number is expected
8063
8064 Returns:  the integer value, or
8065           -1 if string is NULL (which implies an expansion error)
8066           -2 for an integer interpretation error
8067           expand_string_message is set NULL for an OK integer
8068 */
8069
8070 static int_eximarith_t
8071 expanded_string_integer(const uschar *s, BOOL isplus)
8072 {
8073 int_eximarith_t value;
8074 uschar *msg = US"invalid integer \"%s\"";
8075 uschar *endptr;
8076
8077 /* If expansion failed, expand_string_message will be set. */
8078
8079 if (s == NULL) return -1;
8080
8081 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
8082 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
8083 systems, so we set it zero ourselves. */
8084
8085 errno = 0;
8086 expand_string_message = NULL;               /* Indicates no error */
8087
8088 /* Before Exim 4.64, strings consisting entirely of whitespace compared
8089 equal to 0.  Unfortunately, people actually relied upon that, so preserve
8090 the behaviour explicitly.  Stripping leading whitespace is a harmless
8091 noop change since strtol skips it anyway (provided that there is a number
8092 to find at all). */
8093 if (isspace(*s))
8094   {
8095   while (isspace(*s)) ++s;
8096   if (*s == '\0')
8097     {
8098       DEBUG(D_expand)
8099        debug_printf_indent("treating blank string as number 0\n");
8100       return 0;
8101     }
8102   }
8103
8104 value = strtoll(CS s, CSS &endptr, 10);
8105
8106 if (endptr == s)
8107   {
8108   msg = US"integer expected but \"%s\" found";
8109   }
8110 else if (value < 0 && isplus)
8111   {
8112   msg = US"non-negative integer expected but \"%s\" found";
8113   }
8114 else
8115   {
8116   switch (tolower(*endptr))
8117     {
8118     default:
8119       break;
8120     case 'k':
8121       if (value > EXIM_ARITH_MAX/1024 || value < EXIM_ARITH_MIN/1024) errno = ERANGE;
8122       else value *= 1024;
8123       endptr++;
8124       break;
8125     case 'm':
8126       if (value > EXIM_ARITH_MAX/(1024*1024) || value < EXIM_ARITH_MIN/(1024*1024)) errno = ERANGE;
8127       else value *= 1024*1024;
8128       endptr++;
8129       break;
8130     case 'g':
8131       if (value > EXIM_ARITH_MAX/(1024*1024*1024) || value < EXIM_ARITH_MIN/(1024*1024*1024)) errno = ERANGE;
8132       else value *= 1024*1024*1024;
8133       endptr++;
8134       break;
8135     }
8136   if (errno == ERANGE)
8137     msg = US"absolute value of integer \"%s\" is too large (overflow)";
8138   else
8139     {
8140     while (isspace(*endptr)) endptr++;
8141     if (*endptr == 0) return value;
8142     }
8143   }
8144
8145 expand_string_message = string_sprintf(CS msg, s);
8146 return -2;
8147 }
8148
8149
8150 /* These values are usually fixed boolean values, but they are permitted to be
8151 expanded strings.
8152
8153 Arguments:
8154   addr       address being routed
8155   mtype      the module type
8156   mname      the module name
8157   dbg_opt    debug selectors
8158   oname      the option name
8159   bvalue     the router's boolean value
8160   svalue     the router's string value
8161   rvalue     where to put the returned value
8162
8163 Returns:     OK     value placed in rvalue
8164              DEFER  expansion failed
8165 */
8166
8167 int
8168 exp_bool(address_item *addr,
8169   uschar *mtype, uschar *mname, unsigned dbg_opt,
8170   uschar *oname, BOOL bvalue,
8171   uschar *svalue, BOOL *rvalue)
8172 {
8173 uschar *expanded;
8174 if (svalue == NULL) { *rvalue = bvalue; return OK; }
8175
8176 expanded = expand_string(svalue);
8177 if (expanded == NULL)
8178   {
8179   if (f.expand_string_forcedfail)
8180     {
8181     DEBUG(dbg_opt) debug_printf("expansion of \"%s\" forced failure\n", oname);
8182     *rvalue = bvalue;
8183     return OK;
8184     }
8185   addr->message = string_sprintf("failed to expand \"%s\" in %s %s: %s",
8186       oname, mname, mtype, expand_string_message);
8187   DEBUG(dbg_opt) debug_printf("%s\n", addr->message);
8188   return DEFER;
8189   }
8190
8191 DEBUG(dbg_opt) debug_printf("expansion of \"%s\" yields \"%s\"\n", oname,
8192   expanded);
8193
8194 if (strcmpic(expanded, US"true") == 0 || strcmpic(expanded, US"yes") == 0)
8195   *rvalue = TRUE;
8196 else if (strcmpic(expanded, US"false") == 0 || strcmpic(expanded, US"no") == 0)
8197   *rvalue = FALSE;
8198 else
8199   {
8200   addr->message = string_sprintf("\"%s\" is not a valid value for the "
8201     "\"%s\" option in the %s %s", expanded, oname, mname, mtype);
8202   return DEFER;
8203   }
8204
8205 return OK;
8206 }
8207
8208
8209
8210 /* Avoid potentially exposing a password in a string about to be logged */
8211
8212 uschar *
8213 expand_hide_passwords(uschar * s)
8214 {
8215 return (  (  Ustrstr(s, "failed to expand") != NULL
8216           || Ustrstr(s, "expansion of ")    != NULL
8217           )
8218        && (  Ustrstr(s, "mysql")   != NULL
8219           || Ustrstr(s, "pgsql")   != NULL
8220           || Ustrstr(s, "redis")   != NULL
8221           || Ustrstr(s, "sqlite")  != NULL
8222           || Ustrstr(s, "ldap:")   != NULL
8223           || Ustrstr(s, "ldaps:")  != NULL
8224           || Ustrstr(s, "ldapi:")  != NULL
8225           || Ustrstr(s, "ldapdn:") != NULL
8226           || Ustrstr(s, "ldapm:")  != NULL
8227        )  )
8228   ? US"Temporary internal error" : s;
8229 }
8230
8231
8232 /* Read given named file into big_buffer.  Use for keying material etc.
8233 The content will have an ascii NUL appended.
8234
8235 Arguments:
8236  filename       as it says
8237
8238 Return:  pointer to buffer, or NULL on error.
8239 */
8240
8241 uschar *
8242 expand_file_big_buffer(const uschar * filename)
8243 {
8244 int fd, off = 0, len;
8245
8246 if ((fd = open(CS filename, O_RDONLY)) < 0)
8247   {
8248   log_write(0, LOG_MAIN | LOG_PANIC, "unable to open file for reading: %s",
8249              filename);
8250   return NULL;
8251   }
8252
8253 do
8254   {
8255   if ((len = read(fd, big_buffer + off, big_buffer_size - 2 - off)) < 0)
8256     {
8257     (void) close(fd);
8258     log_write(0, LOG_MAIN|LOG_PANIC, "unable to read file: %s", filename);
8259     return NULL;
8260     }
8261   off += len;
8262   }
8263 while (len > 0);
8264
8265 (void) close(fd);
8266 big_buffer[off] = '\0';
8267 return big_buffer;
8268 }
8269
8270
8271
8272 /*************************************************
8273 * Error-checking for testsuite                   *
8274 *************************************************/
8275 typedef struct {
8276   uschar *      region_start;
8277   uschar *      region_end;
8278   const uschar *var_name;
8279   const uschar *var_data;
8280 } err_ctx;
8281
8282 static void
8283 assert_variable_notin(uschar * var_name, uschar * var_data, void * ctx)
8284 {
8285 err_ctx * e = ctx;
8286 if (var_data >= e->region_start  &&  var_data < e->region_end)
8287   {
8288   e->var_name = CUS var_name;
8289   e->var_data = CUS var_data;
8290   }
8291 }
8292
8293 void
8294 assert_no_variables(void * ptr, int len, const char * filename, int linenumber)
8295 {
8296 err_ctx e = { .region_start = ptr, .region_end = US ptr + len,
8297               .var_name = NULL, .var_data = NULL };
8298 int i;
8299 var_entry * v;
8300
8301 /* check acl_ variables */
8302 tree_walk(acl_var_c, assert_variable_notin, &e);
8303 tree_walk(acl_var_m, assert_variable_notin, &e);
8304
8305 /* check auth<n> variables */
8306 for (i = 0; i < AUTH_VARS; i++) if (auth_vars[i])
8307   assert_variable_notin(US"auth<n>", auth_vars[i], &e);
8308
8309 /* check regex<n> variables */
8310 for (i = 0; i < REGEX_VARS; i++) if (regex_vars[i])
8311   assert_variable_notin(US"regex<n>", regex_vars[i], &e);
8312
8313 /* check known-name variables */
8314 for (v = var_table; v < var_table + var_table_size; v++)
8315   if (v->type == vtype_stringptr)
8316     assert_variable_notin(US v->name, *(USS v->value), &e);
8317
8318 /* check dns and address trees */
8319 tree_walk(tree_dns_fails,     assert_variable_notin, &e);
8320 tree_walk(tree_duplicates,    assert_variable_notin, &e);
8321 tree_walk(tree_nonrecipients, assert_variable_notin, &e);
8322 tree_walk(tree_unusable,      assert_variable_notin, &e);
8323
8324 if (e.var_name)
8325   log_write(0, LOG_MAIN|LOG_PANIC_DIE,
8326     "live variable '%s' destroyed by reset_store at %s:%d\n- value '%.64s'",
8327     e.var_name, filename, linenumber, e.var_data);
8328 }
8329
8330
8331
8332 /*************************************************
8333 **************************************************
8334 *             Stand-alone test program           *
8335 **************************************************
8336 *************************************************/
8337
8338 #ifdef STAND_ALONE
8339
8340
8341 BOOL
8342 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
8343 {
8344 int ovector[3*(EXPAND_MAXN+1)];
8345 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
8346   ovector, nelem(ovector));
8347 BOOL yield = n >= 0;
8348 if (n == 0) n = EXPAND_MAXN + 1;
8349 if (yield)
8350   {
8351   int nn;
8352   expand_nmax = (setup < 0)? 0 : setup + 1;
8353   for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
8354     {
8355     expand_nstring[expand_nmax] = subject + ovector[nn];
8356     expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
8357     }
8358   expand_nmax--;
8359   }
8360 return yield;
8361 }
8362
8363
8364 int main(int argc, uschar **argv)
8365 {
8366 int i;
8367 uschar buffer[1024];
8368
8369 debug_selector = D_v;
8370 debug_file = stderr;
8371 debug_fd = fileno(debug_file);
8372 big_buffer = malloc(big_buffer_size);
8373
8374 for (i = 1; i < argc; i++)
8375   {
8376   if (argv[i][0] == '+')
8377     {
8378     debug_trace_memory = 2;
8379     argv[i]++;
8380     }
8381   if (isdigit(argv[i][0]))
8382     debug_selector = Ustrtol(argv[i], NULL, 0);
8383   else
8384     if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
8385         Ustrlen(argv[i]))
8386       {
8387 #ifdef LOOKUP_LDAP
8388       eldap_default_servers = argv[i];
8389 #endif
8390 #ifdef LOOKUP_MYSQL
8391       mysql_servers = argv[i];
8392 #endif
8393 #ifdef LOOKUP_PGSQL
8394       pgsql_servers = argv[i];
8395 #endif
8396 #ifdef LOOKUP_REDIS
8397       redis_servers = argv[i];
8398 #endif
8399       }
8400 #ifdef EXIM_PERL
8401   else opt_perl_startup = argv[i];
8402 #endif
8403   }
8404
8405 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
8406
8407 expand_nstring[1] = US"string 1....";
8408 expand_nlength[1] = 8;
8409 expand_nmax = 1;
8410
8411 #ifdef EXIM_PERL
8412 if (opt_perl_startup != NULL)
8413   {
8414   uschar *errstr;
8415   printf("Starting Perl interpreter\n");
8416   errstr = init_perl(opt_perl_startup);
8417   if (errstr != NULL)
8418     {
8419     printf("** error in perl_startup code: %s\n", errstr);
8420     return EXIT_FAILURE;
8421     }
8422   }
8423 #endif /* EXIM_PERL */
8424
8425 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
8426   {
8427   void *reset_point = store_get(0);
8428   uschar *yield = expand_string(buffer);
8429   if (yield != NULL)
8430     {
8431     printf("%s\n", yield);
8432     store_reset(reset_point);
8433     }
8434   else
8435     {
8436     if (f.search_find_defer) printf("search_find deferred\n");
8437     printf("Failed: %s\n", expand_string_message);
8438     if (f.expand_string_forcedfail) printf("Forced failure\n");
8439     printf("\n");
8440     }
8441   }
8442
8443 search_tidyup();
8444
8445 return 0;
8446 }
8447
8448 #endif
8449
8450 /* vi: aw ai sw=2
8451 */
8452 /* End of expand.c */