src/src/expand.c

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