src/src/expand.c

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