src/src/expand.c

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