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 (Ustrspn(t, "0123456789") == len)
2853       {
2854       boolvalue = (Uatoi(t) == 0) ? FALSE : TRUE;
2855       /* expand_check_condition only does a literal string "0" check */
2856       if ((cond_type == ECOND_BOOL_LAX) && (len > 1))
2857         boolvalue = TRUE;
2858       }
2859     else if (strcmpic(t, US"true") == 0 || strcmpic(t, US"yes") == 0)
2860       boolvalue = TRUE;
2861     else if (strcmpic(t, US"false") == 0 || strcmpic(t, US"no") == 0)
2862       boolvalue = FALSE;
2863     else if (cond_type == ECOND_BOOL_LAX)
2864       boolvalue = TRUE;
2865     else
2866       {
2867       expand_string_message = string_sprintf("unrecognised boolean "
2868        "value \"%s\"", t);
2869       return NULL;
2870       }
2871     if (yield != NULL) *yield = (boolvalue == testfor);
2872     return s;
2873     }
2874
2875   /* Unknown condition */
2876
2877   default:
2878   expand_string_message = string_sprintf("unknown condition \"%s\"", name);
2879   return NULL;
2880   }   /* End switch on condition type */
2881
2882 /* Missing braces at start and end of data */
2883
2884 COND_FAILED_CURLY_START:
2885 expand_string_message = string_sprintf("missing { after \"%s\"", name);
2886 return NULL;
2887
2888 COND_FAILED_CURLY_END:
2889 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2890   name);
2891 return NULL;
2892
2893 /* A condition requires code that is not compiled */
2894
2895 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
2896     !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
2897     !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
2898 COND_FAILED_NOT_COMPILED:
2899 expand_string_message = string_sprintf("support for \"%s\" not compiled",
2900   name);
2901 return NULL;
2902 #endif
2903 }
2904
2905
2906
2907
2908 /*************************************************
2909 *          Save numerical variables              *
2910 *************************************************/
2911
2912 /* This function is called from items such as "if" that want to preserve and
2913 restore the numbered variables.
2914
2915 Arguments:
2916   save_expand_string    points to an array of pointers to set
2917   save_expand_nlength   points to an array of ints for the lengths
2918
2919 Returns:                the value of expand max to save
2920 */
2921
2922 static int
2923 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2924 {
2925 int i;
2926 for (i = 0; i <= expand_nmax; i++)
2927   {
2928   save_expand_nstring[i] = expand_nstring[i];
2929   save_expand_nlength[i] = expand_nlength[i];
2930   }
2931 return expand_nmax;
2932 }
2933
2934
2935
2936 /*************************************************
2937 *           Restore numerical variables          *
2938 *************************************************/
2939
2940 /* This function restored saved values of numerical strings.
2941
2942 Arguments:
2943   save_expand_nmax      the number of strings to restore
2944   save_expand_string    points to an array of pointers
2945   save_expand_nlength   points to an array of ints
2946
2947 Returns:                nothing
2948 */
2949
2950 static void
2951 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2952   int *save_expand_nlength)
2953 {
2954 int i;
2955 expand_nmax = save_expand_nmax;
2956 for (i = 0; i <= expand_nmax; i++)
2957   {
2958   expand_nstring[i] = save_expand_nstring[i];
2959   expand_nlength[i] = save_expand_nlength[i];
2960   }
2961 }
2962
2963
2964
2965
2966
2967 /*************************************************
2968 *            Handle yes/no substrings            *
2969 *************************************************/
2970
2971 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
2972 alternative substrings that depend on whether or not the condition was true,
2973 or the lookup or extraction succeeded. The substrings always have to be
2974 expanded, to check their syntax, but "skipping" is set when the result is not
2975 needed - this avoids unnecessary nested lookups.
2976
2977 Arguments:
2978   skipping       TRUE if we were skipping when this item was reached
2979   yes            TRUE if the first string is to be used, else use the second
2980   save_lookup    a value to put back into lookup_value before the 2nd expansion
2981   sptr           points to the input string pointer
2982   yieldptr       points to the output string pointer
2983   sizeptr        points to the output string size
2984   ptrptr         points to the output string pointer
2985   type           "lookup" or "if" or "extract" or "run", for error message
2986   resetok        if not NULL, pointer to flag - write FALSE if unsafe to reset
2987                 the store.
2988
2989 Returns:         0 OK; lookup_value has been reset to save_lookup
2990                  1 expansion failed
2991                  2 expansion failed because of bracketing error
2992 */
2993
2994 static int
2995 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2996   uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type, BOOL *resetok)
2997 {
2998 int rc = 0;
2999 uschar *s = *sptr;    /* Local value */
3000 uschar *sub1, *sub2;
3001
3002 /* If there are no following strings, we substitute the contents of $value for
3003 lookups and for extractions in the success case. For the ${if item, the string
3004 "true" is substituted. In the fail case, nothing is substituted for all three
3005 items. */
3006
3007 while (isspace(*s)) s++;
3008 if (*s == '}')
3009   {
3010   if (type[0] == 'i')
3011     {
3012     if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
3013     }
3014   else
3015     {
3016     if (yes && lookup_value != NULL)
3017       *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
3018         Ustrlen(lookup_value));
3019     lookup_value = save_lookup;
3020     }
3021   s++;
3022   goto RETURN;
3023   }
3024
3025 /* The first following string must be braced. */
3026
3027 if (*s++ != '{') goto FAILED_CURLY;
3028
3029 /* Expand the first substring. Forced failures are noticed only if we actually
3030 want this string. Set skipping in the call in the fail case (this will always
3031 be the case if we were already skipping). */
3032
3033 sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
3034 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
3035 expand_string_forcedfail = FALSE;
3036 if (*s++ != '}') goto FAILED_CURLY;
3037
3038 /* If we want the first string, add it to the output */
3039
3040 if (yes)
3041   *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
3042
3043 /* If this is called from a lookup or an extract, we want to restore $value to
3044 what it was at the start of the item, so that it has this value during the
3045 second string expansion. For the call from "if" or "run" to this function,
3046 save_lookup is set to lookup_value, so that this statement does nothing. */
3047
3048 lookup_value = save_lookup;
3049
3050 /* There now follows either another substring, or "fail", or nothing. This
3051 time, forced failures are noticed only if we want the second string. We must
3052 set skipping in the nested call if we don't want this string, or if we were
3053 already skipping. */
3054
3055 while (isspace(*s)) s++;
3056 if (*s == '{')
3057   {
3058   sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
3059   if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
3060   expand_string_forcedfail = FALSE;
3061   if (*s++ != '}') goto FAILED_CURLY;
3062
3063   /* If we want the second string, add it to the output */
3064
3065   if (!yes)
3066     *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
3067   }
3068
3069 /* If there is no second string, but the word "fail" is present when the use of
3070 the second string is wanted, set a flag indicating it was a forced failure
3071 rather than a syntactic error. Swallow the terminating } in case this is nested
3072 inside another lookup or if or extract. */
3073
3074 else if (*s != '}')
3075   {
3076   uschar name[256];
3077   s = read_name(name, sizeof(name), s, US"_");
3078   if (Ustrcmp(name, "fail") == 0)
3079     {
3080     if (!yes && !skipping)
3081       {
3082       while (isspace(*s)) s++;
3083       if (*s++ != '}') goto FAILED_CURLY;
3084       expand_string_message =
3085         string_sprintf("\"%s\" failed and \"fail\" requested", type);
3086       expand_string_forcedfail = TRUE;
3087       goto FAILED;
3088       }
3089     }
3090   else
3091     {
3092     expand_string_message =
3093       string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
3094     goto FAILED;
3095     }
3096   }
3097
3098 /* All we have to do now is to check on the final closing brace. */
3099
3100 while (isspace(*s)) s++;
3101 if (*s++ == '}') goto RETURN;
3102
3103 /* Get here if there is a bracketing failure */
3104
3105 FAILED_CURLY:
3106 rc++;
3107
3108 /* Get here for other failures */
3109
3110 FAILED:
3111 rc++;
3112
3113 /* Update the input pointer value before returning */
3114
3115 RETURN:
3116 *sptr = s;
3117 return rc;
3118 }
3119
3120
3121
3122
3123 /*************************************************
3124 *    Handle MD5 or SHA-1 computation for HMAC    *
3125 *************************************************/
3126
3127 /* These are some wrapping functions that enable the HMAC code to be a bit
3128 cleaner. A good compiler will spot the tail recursion.
3129
3130 Arguments:
3131   type         HMAC_MD5 or HMAC_SHA1
3132   remaining    are as for the cryptographic hash functions
3133
3134 Returns:       nothing
3135 */
3136
3137 static void
3138 chash_start(int type, void *base)
3139 {
3140 if (type == HMAC_MD5)
3141   md5_start((md5 *)base);
3142 else
3143   sha1_start((sha1 *)base);
3144 }
3145
3146 static void
3147 chash_mid(int type, void *base, uschar *string)
3148 {
3149 if (type == HMAC_MD5)
3150   md5_mid((md5 *)base, string);
3151 else
3152   sha1_mid((sha1 *)base, string);
3153 }
3154
3155 static void
3156 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
3157 {
3158 if (type == HMAC_MD5)
3159   md5_end((md5 *)base, string, length, digest);
3160 else
3161   sha1_end((sha1 *)base, string, length, digest);
3162 }
3163
3164
3165
3166
3167
3168 /********************************************************
3169 * prvs: Get last three digits of days since Jan 1, 1970 *
3170 ********************************************************/
3171
3172 /* This is needed to implement the "prvs" BATV reverse
3173    path signing scheme
3174
3175 Argument: integer "days" offset to add or substract to
3176           or from the current number of days.
3177
3178 Returns:  pointer to string containing the last three
3179           digits of the number of days since Jan 1, 1970,
3180           modified by the offset argument, NULL if there
3181           was an error in the conversion.
3182
3183 */
3184
3185 static uschar *
3186 prvs_daystamp(int day_offset)
3187 {
3188 uschar *days = store_get(32);                /* Need at least 24 for cases */
3189 (void)string_format(days, 32, TIME_T_FMT,    /* where TIME_T_FMT is %lld */
3190   (time(NULL) + day_offset*86400)/86400);
3191 return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
3192 }
3193
3194
3195
3196 /********************************************************
3197 *   prvs: perform HMAC-SHA1 computation of prvs bits    *
3198 ********************************************************/
3199
3200 /* This is needed to implement the "prvs" BATV reverse
3201    path signing scheme
3202
3203 Arguments:
3204   address RFC2821 Address to use
3205       key The key to use (must be less than 64 characters
3206           in size)
3207   key_num Single-digit key number to use. Defaults to
3208           '0' when NULL.
3209
3210 Returns:  pointer to string containing the first three
3211           bytes of the final hash in hex format, NULL if
3212           there was an error in the process.
3213 */
3214
3215 static uschar *
3216 prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
3217 {
3218 uschar *hash_source, *p;
3219 int size = 0,offset = 0,i;
3220 sha1 sha1_base;
3221 void *use_base = &sha1_base;
3222 uschar innerhash[20];
3223 uschar finalhash[20];
3224 uschar innerkey[64];
3225 uschar outerkey[64];
3226 uschar *finalhash_hex = store_get(40);
3227
3228 if (key_num == NULL)
3229   key_num = US"0";
3230
3231 if (Ustrlen(key) > 64)
3232   return NULL;
3233
3234 hash_source = string_cat(NULL,&size,&offset,key_num,1);
3235 string_cat(hash_source,&size,&offset,daystamp,3);
3236 string_cat(hash_source,&size,&offset,address,Ustrlen(address));
3237 hash_source[offset] = '\0';
3238
3239 DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
3240
3241 memset(innerkey, 0x36, 64);
3242 memset(outerkey, 0x5c, 64);
3243
3244 for (i = 0; i < Ustrlen(key); i++)
3245   {
3246   innerkey[i] ^= key[i];
3247   outerkey[i] ^= key[i];
3248   }
3249
3250 chash_start(HMAC_SHA1, use_base);
3251 chash_mid(HMAC_SHA1, use_base, innerkey);
3252 chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
3253
3254 chash_start(HMAC_SHA1, use_base);
3255 chash_mid(HMAC_SHA1, use_base, outerkey);
3256 chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
3257
3258 p = finalhash_hex;
3259 for (i = 0; i < 3; i++)
3260   {
3261   *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
3262   *p++ = hex_digits[finalhash[i] & 0x0f];
3263   }
3264 *p = '\0';
3265
3266 return finalhash_hex;
3267 }
3268
3269
3270
3271
3272 /*************************************************
3273 *        Join a file onto the output string      *
3274 *************************************************/
3275
3276 /* This is used for readfile and after a run expansion. It joins the contents
3277 of a file onto the output string, globally replacing newlines with a given
3278 string (optionally). The file is closed at the end.
3279
3280 Arguments:
3281   f            the FILE
3282   yield        pointer to the expandable string
3283   sizep        pointer to the current size
3284   ptrp         pointer to the current position
3285   eol          newline replacement string, or NULL
3286
3287 Returns:       new value of string pointer
3288 */
3289
3290 static uschar *
3291 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
3292 {
3293 int eollen;
3294 uschar buffer[1024];
3295
3296 eollen = (eol == NULL)? 0 : Ustrlen(eol);
3297
3298 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
3299   {
3300   int len = Ustrlen(buffer);
3301   if (eol != NULL && buffer[len-1] == '\n') len--;
3302   yield = string_cat(yield, sizep, ptrp, buffer, len);
3303   if (buffer[len] != 0)
3304     yield = string_cat(yield, sizep, ptrp, eol, eollen);
3305   }
3306
3307 if (yield != NULL) yield[*ptrp] = 0;
3308
3309 return yield;
3310 }
3311
3312
3313
3314
3315 /*************************************************
3316 *          Evaluate numeric expression           *
3317 *************************************************/
3318
3319 /* This is a set of mutually recursive functions that evaluate an arithmetic
3320 expression involving + - * / % & | ^ ~ << >> and parentheses. The only one of
3321 these functions that is called from elsewhere is eval_expr, whose interface is:
3322
3323 Arguments:
3324   sptr        pointer to the pointer to the string - gets updated
3325   decimal     TRUE if numbers are to be assumed decimal
3326   error       pointer to where to put an error message - must be NULL on input
3327   endket      TRUE if ')' must terminate - FALSE for external call
3328
3329 Returns:      on success: the value of the expression, with *error still NULL
3330               on failure: an undefined value, with *error = a message
3331 */
3332
3333 static int_eximarith_t eval_op_or(uschar **, BOOL, uschar **);
3334
3335
3336 static int_eximarith_t
3337 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
3338 {
3339 uschar *s = *sptr;
3340 int_eximarith_t x = eval_op_or(&s, decimal, error);
3341 if (*error == NULL)
3342   {
3343   if (endket)
3344     {
3345     if (*s != ')')
3346       *error = US"expecting closing parenthesis";
3347     else
3348       while (isspace(*(++s)));
3349     }
3350   else if (*s != 0) *error = US"expecting operator";
3351   }
3352 *sptr = s;
3353 return x;
3354 }
3355
3356
3357 static int_eximarith_t
3358 eval_number(uschar **sptr, BOOL decimal, uschar **error)
3359 {
3360 register int c;
3361 int_eximarith_t n;
3362 uschar *s = *sptr;
3363 while (isspace(*s)) s++;
3364 c = *s;
3365 if (isdigit(c))
3366   {
3367   int count;
3368   (void)sscanf(CS s, (decimal? SC_EXIM_DEC "%n" : SC_EXIM_ARITH "%n"), &n, &count);
3369   s += count;
3370   switch (tolower(*s))
3371     {
3372     default: break;
3373     case 'k': n *= 1024; s++; break;
3374     case 'm': n *= 1024*1024; s++; break;
3375     case 'g': n *= 1024*1024*1024; s++; break;
3376     }
3377   while (isspace (*s)) s++;
3378   }
3379 else if (c == '(')
3380   {
3381   s++;
3382   n = eval_expr(&s, decimal, error, 1);
3383   }
3384 else
3385   {
3386   *error = US"expecting number or opening parenthesis";
3387   n = 0;
3388   }
3389 *sptr = s;
3390 return n;
3391 }
3392
3393
3394 static int_eximarith_t
3395 eval_op_unary(uschar **sptr, BOOL decimal, uschar **error)
3396 {
3397 uschar *s = *sptr;
3398 int_eximarith_t x;
3399 while (isspace(*s)) s++;
3400 if (*s == '+' || *s == '-' || *s == '~')
3401   {
3402   int op = *s++;
3403   x = eval_op_unary(&s, decimal, error);
3404   if (op == '-') x = -x;
3405     else if (op == '~') x = ~x;
3406   }
3407 else
3408   {
3409   x = eval_number(&s, decimal, error);
3410   }
3411 *sptr = s;
3412 return x;
3413 }
3414
3415
3416 static int_eximarith_t
3417 eval_op_mult(uschar **sptr, BOOL decimal, uschar **error)
3418 {
3419 uschar *s = *sptr;
3420 int_eximarith_t x = eval_op_unary(&s, decimal, error);
3421 if (*error == NULL)
3422   {
3423   while (*s == '*' || *s == '/' || *s == '%')
3424     {
3425     int op = *s++;
3426     int_eximarith_t y = eval_op_unary(&s, decimal, error);
3427     if (*error != NULL) break;
3428     /* SIGFPE both on div/mod by zero and on INT_MIN / -1, which would give
3429      * a value of INT_MAX+1. Note that INT_MIN * -1 gives INT_MIN for me, which
3430      * is a bug somewhere in [gcc 4.2.1, FreeBSD, amd64].  In fact, -N*-M where
3431      * -N*M is INT_MIN will yielf INT_MIN.
3432      * Since we don't support floating point, this is somewhat simpler.
3433      * Ideally, we'd return an error, but since we overflow for all other
3434      * arithmetic, consistency suggests otherwise, but what's the correct value
3435      * to use?  There is none.
3436      * The C standard guarantees overflow for unsigned arithmetic but signed
3437      * overflow invokes undefined behaviour; in practice, this is overflow
3438      * except for converting INT_MIN to INT_MAX+1.  We also can't guarantee
3439      * that long/longlong larger than int are available, or we could just work
3440      * with larger types.  We should consider whether to guarantee 32bit eval
3441      * and 64-bit working variables, with errors returned.  For now ...
3442      * So, the only SIGFPEs occur with a non-shrinking div/mod, thus -1; we
3443      * can just let the other invalid results occur otherwise, as they have
3444      * until now.  For this one case, we can coerce.
3445      */
3446     if (y == -1 && x == EXIM_ARITH_MIN && op != '*')
3447       {
3448       DEBUG(D_expand)
3449         debug_printf("Integer exception dodging: " PR_EXIM_ARITH "%c-1 coerced to " PR_EXIM_ARITH "\n",
3450             EXIM_ARITH_MIN, op, EXIM_ARITH_MAX);
3451       x = EXIM_ARITH_MAX;
3452       continue;
3453       }
3454     if (op == '*')
3455       x *= y;
3456     else
3457       {
3458       if (y == 0)
3459         {
3460         *error = (op == '/') ? US"divide by zero" : US"modulo by zero";
3461         x = 0;
3462         break;
3463         }
3464       if (op == '/')
3465         x /= y;
3466       else
3467         x %= y;
3468       }
3469     }
3470   }
3471 *sptr = s;
3472 return x;
3473 }
3474
3475
3476 static int_eximarith_t
3477 eval_op_sum(uschar **sptr, BOOL decimal, uschar **error)
3478 {
3479 uschar *s = *sptr;
3480 int_eximarith_t x = eval_op_mult(&s, decimal, error);
3481 if (*error == NULL)
3482   {
3483   while (*s == '+' || *s == '-')
3484     {
3485     int op = *s++;
3486     int_eximarith_t y = eval_op_mult(&s, decimal, error);
3487     if (*error != NULL) break;
3488     if (op == '+') x += y; else x -= y;
3489     }
3490   }
3491 *sptr = s;
3492 return x;
3493 }
3494
3495
3496 static int_eximarith_t
3497 eval_op_shift(uschar **sptr, BOOL decimal, uschar **error)
3498 {
3499 uschar *s = *sptr;
3500 int_eximarith_t x = eval_op_sum(&s, decimal, error);
3501 if (*error == NULL)
3502   {
3503   while ((*s == '<' || *s == '>') && s[1] == s[0])
3504     {
3505     int_eximarith_t y;
3506     int op = *s++;
3507     s++;
3508     y = eval_op_sum(&s, decimal, error);
3509     if (*error != NULL) break;
3510     if (op == '<') x <<= y; else x >>= y;
3511     }
3512   }
3513 *sptr = s;
3514 return x;
3515 }
3516
3517
3518 static int_eximarith_t
3519 eval_op_and(uschar **sptr, BOOL decimal, uschar **error)
3520 {
3521 uschar *s = *sptr;
3522 int_eximarith_t x = eval_op_shift(&s, decimal, error);
3523 if (*error == NULL)
3524   {
3525   while (*s == '&')
3526     {
3527     int_eximarith_t y;
3528     s++;
3529     y = eval_op_shift(&s, decimal, error);
3530     if (*error != NULL) break;
3531     x &= y;
3532     }
3533   }
3534 *sptr = s;
3535 return x;
3536 }
3537
3538
3539 static int_eximarith_t
3540 eval_op_xor(uschar **sptr, BOOL decimal, uschar **error)
3541 {
3542 uschar *s = *sptr;
3543 int_eximarith_t x = eval_op_and(&s, decimal, error);
3544 if (*error == NULL)
3545   {
3546   while (*s == '^')
3547     {
3548     int_eximarith_t y;
3549     s++;
3550     y = eval_op_and(&s, decimal, error);
3551     if (*error != NULL) break;
3552     x ^= y;
3553     }
3554   }
3555 *sptr = s;
3556 return x;
3557 }
3558
3559
3560 static int_eximarith_t
3561 eval_op_or(uschar **sptr, BOOL decimal, uschar **error)
3562 {
3563 uschar *s = *sptr;
3564 int_eximarith_t x = eval_op_xor(&s, decimal, error);
3565 if (*error == NULL)
3566   {
3567   while (*s == '|')
3568     {
3569     int_eximarith_t y;
3570     s++;
3571     y = eval_op_xor(&s, decimal, error);
3572     if (*error != NULL) break;
3573     x |= y;
3574     }
3575   }
3576 *sptr = s;
3577 return x;
3578 }
3579
3580
3581
3582 /*************************************************
3583 *                 Expand string                  *
3584 *************************************************/
3585
3586 /* Returns either an unchanged string, or the expanded string in stacking pool
3587 store. Interpreted sequences are:
3588
3589    \...                    normal escaping rules
3590    $name                   substitutes the variable
3591    ${name}                 ditto
3592    ${op:string}            operates on the expanded string value
3593    ${item{arg1}{arg2}...}  expands the args and then does the business
3594                              some literal args are not enclosed in {}
3595
3596 There are now far too many operators and item types to make it worth listing
3597 them here in detail any more.
3598
3599 We use an internal routine recursively to handle embedded substrings. The
3600 external function follows. The yield is NULL if the expansion failed, and there
3601 are two cases: if something collapsed syntactically, or if "fail" was given
3602 as the action on a lookup failure. These can be distinguised by looking at the
3603 variable expand_string_forcedfail, which is TRUE in the latter case.
3604
3605 The skipping flag is set true when expanding a substring that isn't actually
3606 going to be used (after "if" or "lookup") and it prevents lookups from
3607 happening lower down.
3608
3609 Store usage: At start, a store block of the length of the input plus 64
3610 is obtained. This is expanded as necessary by string_cat(), which might have to
3611 get a new block, or might be able to expand the original. At the end of the
3612 function we can release any store above that portion of the yield block that
3613 was actually used. In many cases this will be optimal.
3614
3615 However: if the first item in the expansion is a variable name or header name,
3616 we reset the store before processing it; if the result is in fresh store, we
3617 use that without copying. This is helpful for expanding strings like
3618 $message_headers which can get very long.
3619
3620 There's a problem if a ${dlfunc item has side-effects that cause allocation,
3621 since resetting the store at the end of the expansion will free store that was
3622 allocated by the plugin code as well as the slop after the expanded string. So
3623 we skip any resets if ${dlfunc } has been used. The same applies for ${acl }
3624 and, given the acl condition, ${if }. This is an unfortunate consequence of
3625 string expansion becoming too powerful.
3626
3627 Arguments:
3628   string         the string to be expanded
3629   ket_ends       true if expansion is to stop at }
3630   left           if not NULL, a pointer to the first character after the
3631                  expansion is placed here (typically used with ket_ends)
3632   skipping       TRUE for recursive calls when the value isn't actually going
3633                  to be used (to allow for optimisation)
3634   honour_dollar  TRUE if $ is to be expanded,
3635                  FALSE if it's just another character
3636   resetok_p      if not NULL, pointer to flag - write FALSE if unsafe to reset
3637                  the store.
3638
3639 Returns:         NULL if expansion fails:
3640                    expand_string_forcedfail is set TRUE if failure was forced
3641                    expand_string_message contains a textual error message
3642                  a pointer to the expanded string on success
3643 */
3644
3645 static uschar *
3646 expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
3647   BOOL skipping, BOOL honour_dollar, BOOL *resetok_p)
3648 {
3649 int ptr = 0;
3650 int size = Ustrlen(string)+ 64;
3651 int item_type;
3652 uschar *yield = store_get(size);
3653 uschar *s = string;
3654 uschar *save_expand_nstring[EXPAND_MAXN+1];
3655 int save_expand_nlength[EXPAND_MAXN+1];
3656 BOOL resetok = TRUE;
3657
3658 expand_string_forcedfail = FALSE;
3659 expand_string_message = US"";
3660
3661 while (*s != 0)
3662   {
3663   uschar *value;
3664   uschar name[256];
3665
3666   /* \ escapes the next character, which must exist, or else
3667   the expansion fails. There's a special escape, \N, which causes
3668   copying of the subject verbatim up to the next \N. Otherwise,
3669   the escapes are the standard set. */
3670
3671   if (*s == '\\')
3672     {
3673     if (s[1] == 0)
3674       {
3675       expand_string_message = US"\\ at end of string";
3676       goto EXPAND_FAILED;
3677       }
3678
3679     if (s[1] == 'N')
3680       {
3681       uschar *t = s + 2;
3682       for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
3683       yield = string_cat(yield, &size, &ptr, t, s - t);
3684       if (*s != 0) s += 2;
3685       }
3686
3687     else
3688       {
3689       uschar ch[1];
3690       ch[0] = string_interpret_escape(&s);
3691       s++;
3692       yield = string_cat(yield, &size, &ptr, ch, 1);
3693       }
3694
3695     continue;
3696     }
3697
3698   /*{*/
3699   /* Anything other than $ is just copied verbatim, unless we are
3700   looking for a terminating } character. */
3701
3702   /*{*/
3703   if (ket_ends && *s == '}') break;
3704
3705   if (*s != '$' || !honour_dollar)
3706     {
3707     yield = string_cat(yield, &size, &ptr, s++, 1);
3708     continue;
3709     }
3710
3711   /* No { after the $ - must be a plain name or a number for string
3712   match variable. There has to be a fudge for variables that are the
3713   names of header fields preceded by "$header_" because header field
3714   names can contain any printing characters except space and colon.
3715   For those that don't like typing this much, "$h_" is a synonym for
3716   "$header_". A non-existent header yields a NULL value; nothing is
3717   inserted. */  /*}*/
3718
3719   if (isalpha((*(++s))))
3720     {
3721     int len;
3722     int newsize = 0;
3723
3724     s = read_name(name, sizeof(name), s, US"_");
3725
3726     /* If this is the first thing to be expanded, release the pre-allocated
3727     buffer. */
3728
3729     if (ptr == 0 && yield != NULL)
3730       {
3731       if (resetok) store_reset(yield);
3732       yield = NULL;
3733       size = 0;
3734       }
3735
3736     /* Header */
3737
3738     if (Ustrncmp(name, "h_", 2) == 0 ||
3739         Ustrncmp(name, "rh_", 3) == 0 ||
3740         Ustrncmp(name, "bh_", 3) == 0 ||
3741         Ustrncmp(name, "header_", 7) == 0 ||
3742         Ustrncmp(name, "rheader_", 8) == 0 ||
3743         Ustrncmp(name, "bheader_", 8) == 0)
3744       {
3745       BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
3746       uschar *charset = (name[0] == 'b')? NULL : headers_charset;
3747       s = read_header_name(name, sizeof(name), s);
3748       value = find_header(name, FALSE, &newsize, want_raw, charset);
3749
3750       /* If we didn't find the header, and the header contains a closing brace
3751       character, this may be a user error where the terminating colon
3752       has been omitted. Set a flag to adjust the error message in this case.
3753       But there is no error here - nothing gets inserted. */
3754
3755       if (value == NULL)
3756         {
3757         if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
3758         continue;
3759         }
3760       }
3761
3762     /* Variable */
3763
3764     else
3765       {
3766       value = find_variable(name, FALSE, skipping, &newsize);
3767       if (value == NULL)
3768         {
3769         expand_string_message =
3770           string_sprintf("unknown variable name \"%s\"", name);
3771           check_variable_error_message(name);
3772         goto EXPAND_FAILED;
3773         }
3774       }
3775
3776     /* If the data is known to be in a new buffer, newsize will be set to the
3777     size of that buffer. If this is the first thing in an expansion string,
3778     yield will be NULL; just point it at the new store instead of copying. Many
3779     expansion strings contain just one reference, so this is a useful
3780     optimization, especially for humungous headers. */
3781
3782     len = Ustrlen(value);
3783     if (yield == NULL && newsize != 0)
3784       {
3785       yield = value;
3786       size = newsize;
3787       ptr = len;
3788       }
3789     else yield = string_cat(yield, &size, &ptr, value, len);
3790
3791     continue;
3792     }
3793
3794   if (isdigit(*s))
3795     {
3796     int n;
3797     s = read_number(&n, s);
3798     if (n >= 0 && n <= expand_nmax)
3799       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3800         expand_nlength[n]);
3801     continue;
3802     }
3803
3804   /* Otherwise, if there's no '{' after $ it's an error. */             /*}*/
3805
3806   if (*s != '{')                                                        /*}*/
3807     {
3808     expand_string_message = US"$ not followed by letter, digit, or {";  /*}*/
3809     goto EXPAND_FAILED;
3810     }
3811
3812   /* After { there can be various things, but they all start with
3813   an initial word, except for a number for a string match variable. */
3814
3815   if (isdigit((*(++s))))
3816     {
3817     int n;
3818     s = read_number(&n, s);             /*{*/
3819     if (*s++ != '}')
3820       {                                 /*{*/
3821       expand_string_message = US"} expected after number";
3822       goto EXPAND_FAILED;
3823       }
3824     if (n >= 0 && n <= expand_nmax)
3825       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3826         expand_nlength[n]);
3827     continue;
3828     }
3829
3830   if (!isalpha(*s))
3831     {
3832     expand_string_message = US"letter or digit expected after ${";      /*}*/
3833     goto EXPAND_FAILED;
3834     }
3835
3836   /* Allow "-" in names to cater for substrings with negative
3837   arguments. Since we are checking for known names after { this is
3838   OK. */
3839
3840   s = read_name(name, sizeof(name), s, US"_-");
3841   item_type = chop_match(name, item_table, sizeof(item_table)/sizeof(uschar *));
3842
3843   switch(item_type)
3844     {
3845     /* Call an ACL from an expansion.  We feed data in via $acl_arg1 - $acl_arg9.
3846     If the ACL returns accept or reject we return content set by "message ="
3847     There is currently no limit on recursion; this would have us call
3848     acl_check_internal() directly and get a current level from somewhere.
3849     See also the acl expansion condition ECOND_ACL and the traditional
3850     acl modifier ACLC_ACL.
3851     Assume that the function has side-effects on the store that must be preserved.
3852     */
3853
3854     case EITEM_ACL:
3855       /* ${acl {name} {arg1}{arg2}...} */
3856       {
3857       uschar *sub[10];  /* name + arg1-arg9 (which must match number of acl_arg[]) */
3858       uschar *user_msg;
3859
3860       switch(read_subs(sub, 10, 1, &s, skipping, TRUE, US"acl", &resetok))
3861         {
3862         case 1: goto EXPAND_FAILED_CURLY;
3863         case 2:
3864         case 3: goto EXPAND_FAILED;
3865         }
3866       if (skipping) continue;
3867
3868       resetok = FALSE;
3869       switch(eval_acl(sub, sizeof(sub)/sizeof(*sub), &user_msg))
3870         {
3871         case OK:
3872         case FAIL:
3873           if (user_msg)
3874             yield = string_cat(yield, &size, &ptr, user_msg, Ustrlen(user_msg));
3875           continue;
3876
3877         case DEFER:
3878           expand_string_forcedfail = TRUE;
3879         default:
3880           expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
3881           goto EXPAND_FAILED;
3882         }
3883       }
3884
3885     /* Handle conditionals - preserve the values of the numerical expansion
3886     variables in case they get changed by a regular expression match in the
3887     condition. If not, they retain their external settings. At the end
3888     of this "if" section, they get restored to their previous values. */
3889
3890     case EITEM_IF:
3891       {
3892       BOOL cond = FALSE;
3893       uschar *next_s;
3894       int save_expand_nmax =
3895         save_expand_strings(save_expand_nstring, save_expand_nlength);
3896
3897       while (isspace(*s)) s++;
3898       next_s = eval_condition(s, &resetok, skipping? NULL : &cond);
3899       if (next_s == NULL) goto EXPAND_FAILED;  /* message already set */
3900
3901       DEBUG(D_expand)
3902         debug_printf("condition: %.*s\n   result: %s\n", (int)(next_s - s), s,
3903           cond? "true" : "false");
3904
3905       s = next_s;
3906
3907       /* The handling of "yes" and "no" result strings is now in a separate
3908       function that is also used by ${lookup} and ${extract} and ${run}. */
3909
3910       switch(process_yesno(
3911                skipping,                     /* were previously skipping */
3912                cond,                         /* success/failure indicator */
3913                lookup_value,                 /* value to reset for string2 */
3914                &s,                           /* input pointer */
3915                &yield,                       /* output pointer */
3916                &size,                        /* output size */
3917                &ptr,                         /* output current point */
3918                US"if",                       /* condition type */
3919                &resetok))
3920         {
3921         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3922         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3923         }
3924
3925       /* Restore external setting of expansion variables for continuation
3926       at this level. */
3927
3928       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3929         save_expand_nlength);
3930       continue;
3931       }
3932
3933     /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
3934     expanding an internal string that isn't actually going to be used. All we
3935     need to do is check the syntax, so don't do a lookup at all. Preserve the
3936     values of the numerical expansion variables in case they get changed by a
3937     partial lookup. If not, they retain their external settings. At the end
3938     of this "lookup" section, they get restored to their previous values. */
3939
3940     case EITEM_LOOKUP:
3941       {
3942       int stype, partial, affixlen, starflags;
3943       int expand_setup = 0;
3944       int nameptr = 0;
3945       uschar *key, *filename, *affix;
3946       uschar *save_lookup_value = lookup_value;
3947       int save_expand_nmax =
3948         save_expand_strings(save_expand_nstring, save_expand_nlength);
3949
3950       if ((expand_forbid & RDO_LOOKUP) != 0)
3951         {
3952         expand_string_message = US"lookup expansions are not permitted";
3953         goto EXPAND_FAILED;
3954         }
3955
3956       /* Get the key we are to look up for single-key+file style lookups.
3957       Otherwise set the key NULL pro-tem. */
3958
3959       while (isspace(*s)) s++;
3960       if (*s == '{')                                    /*}*/
3961         {
3962         key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
3963         if (key == NULL) goto EXPAND_FAILED;            /*{*/
3964         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3965         while (isspace(*s)) s++;
3966         }
3967       else key = NULL;
3968
3969       /* Find out the type of database */
3970
3971       if (!isalpha(*s))
3972         {
3973         expand_string_message = US"missing lookup type";
3974         goto EXPAND_FAILED;
3975         }
3976
3977       /* The type is a string that may contain special characters of various
3978       kinds. Allow everything except space or { to appear; the actual content
3979       is checked by search_findtype_partial. */         /*}*/
3980
3981       while (*s != 0 && *s != '{' && !isspace(*s))      /*}*/
3982         {
3983         if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
3984         s++;
3985         }
3986       name[nameptr] = 0;
3987       while (isspace(*s)) s++;
3988
3989       /* Now check for the individual search type and any partial or default
3990       options. Only those types that are actually in the binary are valid. */
3991
3992       stype = search_findtype_partial(name, &partial, &affix, &affixlen,
3993         &starflags);
3994       if (stype < 0)
3995         {
3996         expand_string_message = search_error_message;
3997         goto EXPAND_FAILED;
3998         }
3999
4000       /* Check that a key was provided for those lookup types that need it,
4001       and was not supplied for those that use the query style. */
4002
4003       if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
4004         {
4005         if (key == NULL)
4006           {
4007           expand_string_message = string_sprintf("missing {key} for single-"
4008             "key \"%s\" lookup", name);
4009           goto EXPAND_FAILED;
4010           }
4011         }
4012       else
4013         {
4014         if (key != NULL)
4015           {
4016           expand_string_message = string_sprintf("a single key was given for "
4017             "lookup type \"%s\", which is not a single-key lookup type", name);
4018           goto EXPAND_FAILED;
4019           }
4020         }
4021
4022       /* Get the next string in brackets and expand it. It is the file name for
4023       single-key+file lookups, and the whole query otherwise. In the case of
4024       queries that also require a file name (e.g. sqlite), the file name comes
4025       first. */
4026
4027       if (*s != '{') goto EXPAND_FAILED_CURLY;
4028       filename = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4029       if (filename == NULL) goto EXPAND_FAILED;
4030       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4031       while (isspace(*s)) s++;
4032
4033       /* If this isn't a single-key+file lookup, re-arrange the variables
4034       to be appropriate for the search_ functions. For query-style lookups,
4035       there is just a "key", and no file name. For the special query-style +
4036       file types, the query (i.e. "key") starts with a file name. */
4037
4038       if (key == NULL)
4039         {
4040         while (isspace(*filename)) filename++;
4041         key = filename;
4042
4043         if (mac_islookup(stype, lookup_querystyle))
4044           {
4045           filename = NULL;
4046           }
4047         else
4048           {
4049           if (*filename != '/')
4050             {
4051             expand_string_message = string_sprintf(
4052               "absolute file name expected for \"%s\" lookup", name);
4053             goto EXPAND_FAILED;
4054             }
4055           while (*key != 0 && !isspace(*key)) key++;
4056           if (*key != 0) *key++ = 0;
4057           }
4058         }
4059
4060       /* If skipping, don't do the next bit - just lookup_value == NULL, as if
4061       the entry was not found. Note that there is no search_close() function.
4062       Files are left open in case of re-use. At suitable places in higher logic,
4063       search_tidyup() is called to tidy all open files. This can save opening
4064       the same file several times. However, files may also get closed when
4065       others are opened, if too many are open at once. The rule is that a
4066       handle should not be used after a second search_open().
4067
4068       Request that a partial search sets up $1 and maybe $2 by passing
4069       expand_setup containing zero. If its value changes, reset expand_nmax,
4070       since new variables will have been set. Note that at the end of this
4071       "lookup" section, the old numeric variables are restored. */
4072
4073       if (skipping)
4074         lookup_value = NULL;
4075       else
4076         {
4077         void *handle = search_open(filename, stype, 0, NULL, NULL);
4078         if (handle == NULL)
4079           {
4080           expand_string_message = search_error_message;
4081           goto EXPAND_FAILED;
4082           }
4083         lookup_value = search_find(handle, filename, key, partial, affix,
4084           affixlen, starflags, &expand_setup);
4085         if (search_find_defer)
4086           {
4087           expand_string_message =
4088             string_sprintf("lookup of \"%s\" gave DEFER: %s",
4089               string_printing2(key, FALSE), search_error_message);
4090           goto EXPAND_FAILED;
4091           }
4092         if (expand_setup > 0) expand_nmax = expand_setup;
4093         }
4094
4095       /* The handling of "yes" and "no" result strings is now in a separate
4096       function that is also used by ${if} and ${extract}. */
4097
4098       switch(process_yesno(
4099                skipping,                     /* were previously skipping */
4100                lookup_value != NULL,         /* success/failure indicator */
4101                save_lookup_value,            /* value to reset for string2 */
4102                &s,                           /* input pointer */
4103                &yield,                       /* output pointer */
4104                &size,                        /* output size */
4105                &ptr,                         /* output current point */
4106                US"lookup",                   /* condition type */
4107                &resetok))
4108         {
4109         case 1: goto EXPAND_FAILED;          /* when all is well, the */
4110         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
4111         }
4112
4113       /* Restore external setting of expansion variables for carrying on
4114       at this level, and continue. */
4115
4116       restore_expand_strings(save_expand_nmax, save_expand_nstring,
4117         save_expand_nlength);
4118       continue;
4119       }
4120
4121     /* If Perl support is configured, handle calling embedded perl subroutines,
4122     unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
4123     or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
4124     arguments (defined below). */
4125
4126     #define EXIM_PERL_MAX_ARGS 8
4127
4128     case EITEM_PERL:
4129     #ifndef EXIM_PERL
4130     expand_string_message = US"\"${perl\" encountered, but this facility "      /*}*/
4131       "is not included in this binary";
4132     goto EXPAND_FAILED;
4133
4134     #else   /* EXIM_PERL */
4135       {
4136       uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
4137       uschar *new_yield;
4138
4139       if ((expand_forbid & RDO_PERL) != 0)
4140         {
4141         expand_string_message = US"Perl calls are not permitted";
4142         goto EXPAND_FAILED;
4143         }
4144
4145       switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
4146            US"perl", &resetok))
4147         {
4148         case 1: goto EXPAND_FAILED_CURLY;
4149         case 2:
4150         case 3: goto EXPAND_FAILED;
4151         }
4152
4153       /* If skipping, we don't actually do anything */
4154
4155       if (skipping) continue;
4156
4157       /* Start the interpreter if necessary */
4158
4159       if (!opt_perl_started)
4160         {
4161         uschar *initerror;
4162         if (opt_perl_startup == NULL)
4163           {
4164           expand_string_message = US"A setting of perl_startup is needed when "
4165             "using the Perl interpreter";
4166           goto EXPAND_FAILED;
4167           }
4168         DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
4169         initerror = init_perl(opt_perl_startup);
4170         if (initerror != NULL)
4171           {
4172           expand_string_message =
4173             string_sprintf("error in perl_startup code: %s\n", initerror);
4174           goto EXPAND_FAILED;
4175           }
4176         opt_perl_started = TRUE;
4177         }
4178
4179       /* Call the function */
4180
4181       sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
4182       new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
4183         sub_arg[0], sub_arg + 1);
4184
4185       /* NULL yield indicates failure; if the message pointer has been set to
4186       NULL, the yield was undef, indicating a forced failure. Otherwise the
4187       message will indicate some kind of Perl error. */
4188
4189       if (new_yield == NULL)
4190         {
4191         if (expand_string_message == NULL)
4192           {
4193           expand_string_message =
4194             string_sprintf("Perl subroutine \"%s\" returned undef to force "
4195               "failure", sub_arg[0]);
4196           expand_string_forcedfail = TRUE;
4197           }
4198         goto EXPAND_FAILED;
4199         }
4200
4201       /* Yield succeeded. Ensure forcedfail is unset, just in case it got
4202       set during a callback from Perl. */
4203
4204       expand_string_forcedfail = FALSE;
4205       yield = new_yield;
4206       continue;
4207       }
4208     #endif /* EXIM_PERL */
4209
4210     /* Transform email address to "prvs" scheme to use
4211        as BATV-signed return path */
4212
4213     case EITEM_PRVS:
4214       {
4215       uschar *sub_arg[3];
4216       uschar *p,*domain;
4217
4218       switch(read_subs(sub_arg, 3, 2, &s, skipping, TRUE, US"prvs", &resetok))
4219         {
4220         case 1: goto EXPAND_FAILED_CURLY;
4221         case 2:
4222         case 3: goto EXPAND_FAILED;
4223         }
4224
4225       /* If skipping, we don't actually do anything */
4226       if (skipping) continue;
4227
4228       /* sub_arg[0] is the address */
4229       domain = Ustrrchr(sub_arg[0],'@');
4230       if ( (domain == NULL) || (domain == sub_arg[0]) || (Ustrlen(domain) == 1) )
4231         {
4232         expand_string_message = US"prvs first argument must be a qualified email address";
4233         goto EXPAND_FAILED;
4234         }
4235
4236       /* Calculate the hash. The second argument must be a single-digit
4237       key number, or unset. */
4238
4239       if (sub_arg[2] != NULL &&
4240           (!isdigit(sub_arg[2][0]) || sub_arg[2][1] != 0))
4241         {
4242         expand_string_message = US"prvs second argument must be a single digit";
4243         goto EXPAND_FAILED;
4244         }
4245
4246       p = prvs_hmac_sha1(sub_arg[0],sub_arg[1],sub_arg[2],prvs_daystamp(7));
4247       if (p == NULL)
4248         {
4249         expand_string_message = US"prvs hmac-sha1 conversion failed";
4250         goto EXPAND_FAILED;
4251         }
4252
4253       /* Now separate the domain from the local part */
4254       *domain++ = '\0';
4255
4256       yield = string_cat(yield,&size,&ptr,US"prvs=",5);
4257       string_cat(yield,&size,&ptr,(sub_arg[2] != NULL) ? sub_arg[2] : US"0", 1);
4258       string_cat(yield,&size,&ptr,prvs_daystamp(7),3);
4259       string_cat(yield,&size,&ptr,p,6);
4260       string_cat(yield,&size,&ptr,US"=",1);
4261       string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
4262       string_cat(yield,&size,&ptr,US"@",1);
4263       string_cat(yield,&size,&ptr,domain,Ustrlen(domain));
4264
4265       continue;
4266       }
4267
4268     /* Check a prvs-encoded address for validity */
4269
4270     case EITEM_PRVSCHECK:
4271       {
4272       uschar *sub_arg[3];
4273       int mysize = 0, myptr = 0;
4274       const pcre *re;
4275       uschar *p;
4276
4277       /* TF: Ugliness: We want to expand parameter 1 first, then set
4278          up expansion variables that are used in the expansion of
4279          parameter 2. So we clone the string for the first
4280          expansion, where we only expand parameter 1.
4281
4282          PH: Actually, that isn't necessary. The read_subs() function is
4283          designed to work this way for the ${if and ${lookup expansions. I've
4284          tidied the code.
4285       */
4286
4287       /* Reset expansion variables */
4288       prvscheck_result = NULL;
4289       prvscheck_address = NULL;
4290       prvscheck_keynum = NULL;
4291
4292       switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4293         {
4294         case 1: goto EXPAND_FAILED_CURLY;
4295         case 2:
4296         case 3: goto EXPAND_FAILED;
4297         }
4298
4299       re = regex_must_compile(US"^prvs\\=([0-9])([0-9]{3})([A-F0-9]{6})\\=(.+)\\@(.+)$",
4300                               TRUE,FALSE);
4301
4302       if (regex_match_and_setup(re,sub_arg[0],0,-1))
4303         {
4304         uschar *local_part = string_copyn(expand_nstring[4],expand_nlength[4]);
4305         uschar *key_num = string_copyn(expand_nstring[1],expand_nlength[1]);
4306         uschar *daystamp = string_copyn(expand_nstring[2],expand_nlength[2]);
4307         uschar *hash = string_copyn(expand_nstring[3],expand_nlength[3]);
4308         uschar *domain = string_copyn(expand_nstring[5],expand_nlength[5]);
4309
4310         DEBUG(D_expand) debug_printf("prvscheck localpart: %s\n", local_part);
4311         DEBUG(D_expand) debug_printf("prvscheck key number: %s\n", key_num);
4312         DEBUG(D_expand) debug_printf("prvscheck daystamp: %s\n", daystamp);
4313         DEBUG(D_expand) debug_printf("prvscheck hash: %s\n", hash);
4314         DEBUG(D_expand) debug_printf("prvscheck domain: %s\n", domain);
4315
4316         /* Set up expansion variables */
4317         prvscheck_address = string_cat(NULL, &mysize, &myptr, local_part, Ustrlen(local_part));
4318         string_cat(prvscheck_address,&mysize,&myptr,US"@",1);
4319         string_cat(prvscheck_address,&mysize,&myptr,domain,Ustrlen(domain));
4320         prvscheck_address[myptr] = '\0';
4321         prvscheck_keynum = string_copy(key_num);
4322
4323         /* Now expand the second argument */
4324         switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4325           {
4326           case 1: goto EXPAND_FAILED_CURLY;
4327           case 2:
4328           case 3: goto EXPAND_FAILED;
4329           }
4330
4331         /* Now we have the key and can check the address. */
4332
4333         p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
4334           daystamp);
4335
4336         if (p == NULL)
4337           {
4338           expand_string_message = US"hmac-sha1 conversion failed";
4339           goto EXPAND_FAILED;
4340           }
4341
4342         DEBUG(D_expand) debug_printf("prvscheck: received hash is %s\n", hash);
4343         DEBUG(D_expand) debug_printf("prvscheck:      own hash is %s\n", p);
4344
4345         if (Ustrcmp(p,hash) == 0)
4346           {
4347           /* Success, valid BATV address. Now check the expiry date. */
4348           uschar *now = prvs_daystamp(0);
4349           unsigned int inow = 0,iexpire = 1;
4350
4351           (void)sscanf(CS now,"%u",&inow);
4352           (void)sscanf(CS daystamp,"%u",&iexpire);
4353
4354           /* When "iexpire" is < 7, a "flip" has occured.
4355              Adjust "inow" accordingly. */
4356           if ( (iexpire < 7) && (inow >= 993) ) inow = 0;
4357
4358           if (iexpire >= inow)
4359             {
4360             prvscheck_result = US"1";
4361             DEBUG(D_expand) debug_printf("prvscheck: success, $pvrs_result set to 1\n");
4362             }
4363             else
4364             {
4365             prvscheck_result = NULL;
4366             DEBUG(D_expand) debug_printf("prvscheck: signature expired, $pvrs_result unset\n");
4367             }
4368           }
4369         else
4370           {
4371           prvscheck_result = NULL;
4372           DEBUG(D_expand) debug_printf("prvscheck: hash failure, $pvrs_result unset\n");
4373           }
4374
4375         /* Now expand the final argument. We leave this till now so that
4376         it can include $prvscheck_result. */
4377
4378         switch(read_subs(sub_arg, 1, 0, &s, skipping, TRUE, US"prvs", &resetok))
4379           {
4380           case 1: goto EXPAND_FAILED_CURLY;
4381           case 2:
4382           case 3: goto EXPAND_FAILED;
4383           }
4384
4385         if (sub_arg[0] == NULL || *sub_arg[0] == '\0')
4386           yield = string_cat(yield,&size,&ptr,prvscheck_address,Ustrlen(prvscheck_address));
4387         else
4388           yield = string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
4389
4390         /* Reset the "internal" variables afterwards, because they are in
4391         dynamic store that will be reclaimed if the expansion succeeded. */
4392
4393         prvscheck_address = NULL;
4394         prvscheck_keynum = NULL;
4395         }
4396       else
4397         {
4398         /* Does not look like a prvs encoded address, return the empty string.
4399            We need to make sure all subs are expanded first, so as to skip over
4400            the entire item. */
4401
4402         switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"prvs", &resetok))
4403           {
4404           case 1: goto EXPAND_FAILED_CURLY;
4405           case 2:
4406           case 3: goto EXPAND_FAILED;
4407           }
4408         }
4409
4410       continue;
4411       }
4412
4413     /* Handle "readfile" to insert an entire file */
4414
4415     case EITEM_READFILE:
4416       {
4417       FILE *f;
4418       uschar *sub_arg[2];
4419
4420       if ((expand_forbid & RDO_READFILE) != 0)
4421         {
4422         expand_string_message = US"file insertions are not permitted";
4423         goto EXPAND_FAILED;
4424         }
4425
4426       switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile", &resetok))
4427         {
4428         case 1: goto EXPAND_FAILED_CURLY;
4429         case 2:
4430         case 3: goto EXPAND_FAILED;
4431         }
4432
4433       /* If skipping, we don't actually do anything */
4434
4435       if (skipping) continue;
4436
4437       /* Open the file and read it */
4438
4439       f = Ufopen(sub_arg[0], "rb");
4440       if (f == NULL)
4441         {
4442         expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
4443         goto EXPAND_FAILED;
4444         }
4445
4446       yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
4447       (void)fclose(f);
4448       continue;
4449       }
4450
4451     /* Handle "readsocket" to insert data from a Unix domain socket */
4452
4453     case EITEM_READSOCK:
4454       {
4455       int fd;
4456       int timeout = 5;
4457       int save_ptr = ptr;
4458       FILE *f;
4459       struct sockaddr_un sockun;         /* don't call this "sun" ! */
4460       uschar *arg;
4461       uschar *sub_arg[4];
4462
4463       if ((expand_forbid & RDO_READSOCK) != 0)
4464         {
4465         expand_string_message = US"socket insertions are not permitted";
4466         goto EXPAND_FAILED;
4467         }
4468
4469       /* Read up to 4 arguments, but don't do the end of item check afterwards,
4470       because there may be a string for expansion on failure. */
4471
4472       switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket", &resetok))
4473         {
4474         case 1: goto EXPAND_FAILED_CURLY;
4475         case 2:                             /* Won't occur: no end check */
4476         case 3: goto EXPAND_FAILED;
4477         }
4478
4479       /* Sort out timeout, if given */
4480
4481       if (sub_arg[2] != NULL)
4482         {
4483         timeout = readconf_readtime(sub_arg[2], 0, FALSE);
4484         if (timeout < 0)
4485           {
4486           expand_string_message = string_sprintf("bad time value %s",
4487             sub_arg[2]);
4488           goto EXPAND_FAILED;
4489           }
4490         }
4491       else sub_arg[3] = NULL;                     /* No eol if no timeout */
4492
4493       /* If skipping, we don't actually do anything. Otherwise, arrange to
4494       connect to either an IP or a Unix socket. */
4495
4496       if (!skipping)
4497         {
4498         /* Handle an IP (internet) domain */
4499
4500         if (Ustrncmp(sub_arg[0], "inet:", 5) == 0)
4501           {
4502           int port;
4503           uschar *server_name = sub_arg[0] + 5;
4504           uschar *port_name = Ustrrchr(server_name, ':');
4505
4506           /* Sort out the port */
4507
4508           if (port_name == NULL)
4509             {
4510             expand_string_message =
4511               string_sprintf("missing port for readsocket %s", sub_arg[0]);
4512             goto EXPAND_FAILED;
4513             }
4514           *port_name++ = 0;           /* Terminate server name */
4515
4516           if (isdigit(*port_name))
4517             {
4518             uschar *end;
4519             port = Ustrtol(port_name, &end, 0);
4520             if (end != port_name + Ustrlen(port_name))
4521               {
4522               expand_string_message =
4523                 string_sprintf("invalid port number %s", port_name);
4524               goto EXPAND_FAILED;
4525               }
4526             }
4527           else
4528             {
4529             struct servent *service_info = getservbyname(CS port_name, "tcp");
4530             if (service_info == NULL)
4531               {
4532               expand_string_message = string_sprintf("unknown port \"%s\"",
4533                 port_name);
4534               goto EXPAND_FAILED;
4535               }
4536             port = ntohs(service_info->s_port);
4537             }
4538
4539           if ((fd = ip_connectedsocket(SOCK_STREAM, server_name, port, port,
4540                   timeout, NULL, &expand_string_message)) < 0)
4541               goto SOCK_FAIL;
4542           }
4543
4544         /* Handle a Unix domain socket */
4545
4546         else
4547           {
4548           int rc;
4549           if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
4550             {
4551             expand_string_message = string_sprintf("failed to create socket: %s",
4552               strerror(errno));
4553             goto SOCK_FAIL;
4554             }
4555
4556           sockun.sun_family = AF_UNIX;
4557           sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
4558             sub_arg[0]);
4559
4560           sigalrm_seen = FALSE;
4561           alarm(timeout);
4562           rc = connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun));
4563           alarm(0);
4564           if (sigalrm_seen)
4565             {
4566             expand_string_message = US "socket connect timed out";
4567             goto SOCK_FAIL;
4568             }
4569           if (rc < 0)
4570             {
4571             expand_string_message = string_sprintf("failed to connect to socket "
4572               "%s: %s", sub_arg[0], strerror(errno));
4573             goto SOCK_FAIL;
4574             }
4575           }
4576
4577         DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
4578
4579         /* Write the request string, if not empty */
4580
4581         if (sub_arg[1][0] != 0)
4582           {
4583           int len = Ustrlen(sub_arg[1]);
4584           DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
4585             sub_arg[1]);
4586           if (write(fd, sub_arg[1], len) != len)
4587             {
4588             expand_string_message = string_sprintf("request write to socket "
4589               "failed: %s", strerror(errno));
4590             goto SOCK_FAIL;
4591             }
4592           }
4593
4594         /* Shut down the sending side of the socket. This helps some servers to
4595         recognise that it is their turn to do some work. Just in case some
4596         system doesn't have this function, make it conditional. */
4597
4598         #ifdef SHUT_WR
4599         shutdown(fd, SHUT_WR);
4600         #endif
4601
4602         /* Now we need to read from the socket, under a timeout. The function
4603         that reads a file can be used. */
4604
4605         f = fdopen(fd, "rb");
4606         sigalrm_seen = FALSE;
4607         alarm(timeout);
4608         yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
4609         alarm(0);
4610         (void)fclose(f);
4611
4612         /* After a timeout, we restore the pointer in the result, that is,
4613         make sure we add nothing from the socket. */
4614
4615         if (sigalrm_seen)
4616           {
4617           ptr = save_ptr;
4618           expand_string_message = US "socket read timed out";
4619           goto SOCK_FAIL;
4620           }
4621         }
4622
4623       /* The whole thing has worked (or we were skipping). If there is a
4624       failure string following, we need to skip it. */
4625
4626       if (*s == '{')
4627         {
4628         if (expand_string_internal(s+1, TRUE, &s, TRUE, TRUE, &resetok) == NULL)
4629           goto EXPAND_FAILED;
4630         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4631         while (isspace(*s)) s++;
4632         }
4633       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4634       continue;
4635
4636       /* Come here on failure to create socket, connect socket, write to the
4637       socket, or timeout on reading. If another substring follows, expand and
4638       use it. Otherwise, those conditions give expand errors. */
4639
4640       SOCK_FAIL:
4641       if (*s != '{') goto EXPAND_FAILED;
4642       DEBUG(D_any) debug_printf("%s\n", expand_string_message);
4643       arg = expand_string_internal(s+1, TRUE, &s, FALSE, TRUE, &resetok);
4644       if (arg == NULL) goto EXPAND_FAILED;
4645       yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
4646       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4647       while (isspace(*s)) s++;
4648       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4649       continue;
4650       }
4651
4652     /* Handle "run" to execute a program. */
4653
4654     case EITEM_RUN:
4655       {
4656       FILE *f;
4657       uschar *arg;
4658       uschar **argv;
4659       pid_t pid;
4660       int fd_in, fd_out;
4661       int lsize = 0;
4662       int lptr = 0;
4663
4664       if ((expand_forbid & RDO_RUN) != 0)
4665         {
4666         expand_string_message = US"running a command is not permitted";
4667         goto EXPAND_FAILED;
4668         }
4669
4670       while (isspace(*s)) s++;
4671       if (*s != '{') goto EXPAND_FAILED_CURLY;
4672       arg = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4673       if (arg == NULL) goto EXPAND_FAILED;
4674       while (isspace(*s)) s++;
4675       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4676
4677       if (skipping)   /* Just pretend it worked when we're skipping */
4678         {
4679         runrc = 0;
4680         }
4681       else
4682         {
4683         if (!transport_set_up_command(&argv,    /* anchor for arg list */
4684             arg,                                /* raw command */
4685             FALSE,                              /* don't expand the arguments */
4686             0,                                  /* not relevant when... */
4687             NULL,                               /* no transporting address */
4688             US"${run} expansion",               /* for error messages */
4689             &expand_string_message))            /* where to put error message */
4690           {
4691           goto EXPAND_FAILED;
4692           }
4693
4694         /* Create the child process, making it a group leader. */
4695
4696         pid = child_open(argv, NULL, 0077, &fd_in, &fd_out, TRUE);
4697
4698         if (pid < 0)
4699           {
4700           expand_string_message =
4701             string_sprintf("couldn't create child process: %s", strerror(errno));
4702           goto EXPAND_FAILED;
4703           }
4704
4705         /* Nothing is written to the standard input. */
4706
4707         (void)close(fd_in);
4708
4709         /* Read the pipe to get the command's output into $value (which is kept
4710         in lookup_value). Read during execution, so that if the output exceeds
4711         the OS pipe buffer limit, we don't block forever. */
4712
4713         f = fdopen(fd_out, "rb");
4714         sigalrm_seen = FALSE;
4715         alarm(60);
4716         lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
4717         alarm(0);
4718         (void)fclose(f);
4719
4720         /* Wait for the process to finish, applying the timeout, and inspect its
4721         return code for serious disasters. Simple non-zero returns are passed on.
4722         */
4723
4724         if (sigalrm_seen == TRUE || (runrc = child_close(pid, 30)) < 0)
4725           {
4726           if (sigalrm_seen == TRUE || runrc == -256)
4727             {
4728             expand_string_message = string_sprintf("command timed out");
4729             killpg(pid, SIGKILL);       /* Kill the whole process group */
4730             }
4731
4732           else if (runrc == -257)
4733             expand_string_message = string_sprintf("wait() failed: %s",
4734               strerror(errno));
4735
4736           else
4737             expand_string_message = string_sprintf("command killed by signal %d",
4738               -runrc);
4739
4740           goto EXPAND_FAILED;
4741           }
4742         }
4743
4744       /* Process the yes/no strings; $value may be useful in both cases */
4745
4746       switch(process_yesno(
4747                skipping,                     /* were previously skipping */
4748                runrc == 0,                   /* success/failure indicator */
4749                lookup_value,                 /* value to reset for string2 */
4750                &s,                           /* input pointer */
4751                &yield,                       /* output pointer */
4752                &size,                        /* output size */
4753                &ptr,                         /* output current point */
4754                US"run",                      /* condition type */
4755                &resetok))
4756         {
4757         case 1: goto EXPAND_FAILED;          /* when all is well, the */
4758         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
4759         }
4760
4761       continue;
4762       }
4763
4764     /* Handle character translation for "tr" */
4765
4766     case EITEM_TR:
4767       {
4768       int oldptr = ptr;
4769       int o2m;
4770       uschar *sub[3];
4771
4772       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr", &resetok))
4773         {
4774         case 1: goto EXPAND_FAILED_CURLY;
4775         case 2:
4776         case 3: goto EXPAND_FAILED;
4777         }
4778
4779       yield = string_cat(yield, &size, &ptr, sub[0], Ustrlen(sub[0]));
4780       o2m = Ustrlen(sub[2]) - 1;
4781
4782       if (o2m >= 0) for (; oldptr < ptr; oldptr++)
4783         {
4784         uschar *m = Ustrrchr(sub[1], yield[oldptr]);
4785         if (m != NULL)
4786           {
4787           int o = m - sub[1];
4788           yield[oldptr] = sub[2][(o < o2m)? o : o2m];
4789           }
4790         }
4791
4792       continue;
4793       }
4794
4795     /* Handle "hash", "length", "nhash", and "substr" when they are given with
4796     expanded arguments. */
4797
4798     case EITEM_HASH:
4799     case EITEM_LENGTH:
4800     case EITEM_NHASH:
4801     case EITEM_SUBSTR:
4802       {
4803       int i;
4804       int len;
4805       uschar *ret;
4806       int val[2] = { 0, -1 };
4807       uschar *sub[3];
4808
4809       /* "length" takes only 2 arguments whereas the others take 2 or 3.
4810       Ensure that sub[2] is set in the ${length } case. */
4811
4812       sub[2] = NULL;
4813       switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
4814              TRUE, name, &resetok))
4815         {
4816         case 1: goto EXPAND_FAILED_CURLY;
4817         case 2:
4818         case 3: goto EXPAND_FAILED;
4819         }
4820
4821       /* Juggle the arguments if there are only two of them: always move the
4822       string to the last position and make ${length{n}{str}} equivalent to
4823       ${substr{0}{n}{str}}. See the defaults for val[] above. */
4824
4825       if (sub[2] == NULL)
4826         {
4827         sub[2] = sub[1];
4828         sub[1] = NULL;
4829         if (item_type == EITEM_LENGTH)
4830           {
4831           sub[1] = sub[0];
4832           sub[0] = NULL;
4833           }
4834         }
4835
4836       for (i = 0; i < 2; i++)
4837         {
4838         if (sub[i] == NULL) continue;
4839         val[i] = (int)Ustrtol(sub[i], &ret, 10);
4840         if (*ret != 0 || (i != 0 && val[i] < 0))
4841           {
4842           expand_string_message = string_sprintf("\"%s\" is not a%s number "
4843             "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
4844           goto EXPAND_FAILED;
4845           }
4846         }
4847
4848       ret =
4849         (item_type == EITEM_HASH)?
4850           compute_hash(sub[2], val[0], val[1], &len) :
4851         (item_type == EITEM_NHASH)?
4852           compute_nhash(sub[2], val[0], val[1], &len) :
4853           extract_substr(sub[2], val[0], val[1], &len);
4854
4855       if (ret == NULL) goto EXPAND_FAILED;
4856       yield = string_cat(yield, &size, &ptr, ret, len);
4857       continue;
4858       }
4859
4860     /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
4861     This code originally contributed by Steve Haslam. It currently supports
4862     the use of MD5 and SHA-1 hashes.
4863
4864     We need some workspace that is large enough to handle all the supported
4865     hash types. Use macros to set the sizes rather than be too elaborate. */
4866
4867     #define MAX_HASHLEN      20
4868     #define MAX_HASHBLOCKLEN 64
4869
4870     case EITEM_HMAC:
4871       {
4872       uschar *sub[3];
4873       md5 md5_base;
4874       sha1 sha1_base;
4875       void *use_base;
4876       int type, i;
4877       int hashlen;      /* Number of octets for the hash algorithm's output */
4878       int hashblocklen; /* Number of octets the hash algorithm processes */
4879       uschar *keyptr, *p;
4880       unsigned int keylen;
4881
4882       uschar keyhash[MAX_HASHLEN];
4883       uschar innerhash[MAX_HASHLEN];
4884       uschar finalhash[MAX_HASHLEN];
4885       uschar finalhash_hex[2*MAX_HASHLEN];
4886       uschar innerkey[MAX_HASHBLOCKLEN];
4887       uschar outerkey[MAX_HASHBLOCKLEN];
4888
4889       switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
4890         {
4891         case 1: goto EXPAND_FAILED_CURLY;
4892         case 2:
4893         case 3: goto EXPAND_FAILED;
4894         }
4895
4896       if (Ustrcmp(sub[0], "md5") == 0)
4897         {
4898         type = HMAC_MD5;
4899         use_base = &md5_base;
4900         hashlen = 16;
4901         hashblocklen = 64;
4902         }
4903       else if (Ustrcmp(sub[0], "sha1") == 0)
4904         {
4905         type = HMAC_SHA1;
4906         use_base = &sha1_base;
4907         hashlen = 20;
4908         hashblocklen = 64;
4909         }
4910       else
4911         {
4912         expand_string_message =
4913           string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
4914         goto EXPAND_FAILED;
4915         }
4916
4917       keyptr = sub[1];
4918       keylen = Ustrlen(keyptr);
4919
4920       /* If the key is longer than the hash block length, then hash the key
4921       first */
4922
4923       if (keylen > hashblocklen)
4924         {
4925         chash_start(type, use_base);
4926         chash_end(type, use_base, keyptr, keylen, keyhash);
4927         keyptr = keyhash;
4928         keylen = hashlen;
4929         }
4930
4931       /* Now make the inner and outer key values */
4932
4933       memset(innerkey, 0x36, hashblocklen);
4934       memset(outerkey, 0x5c, hashblocklen);
4935
4936       for (i = 0; i < keylen; i++)
4937         {
4938         innerkey[i] ^= keyptr[i];
4939         outerkey[i] ^= keyptr[i];
4940         }
4941
4942       /* Now do the hashes */
4943
4944       chash_start(type, use_base);
4945       chash_mid(type, use_base, innerkey);
4946       chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
4947
4948       chash_start(type, use_base);
4949       chash_mid(type, use_base, outerkey);
4950       chash_end(type, use_base, innerhash, hashlen, finalhash);
4951
4952       /* Encode the final hash as a hex string */
4953
4954       p = finalhash_hex;
4955       for (i = 0; i < hashlen; i++)
4956         {
4957         *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
4958         *p++ = hex_digits[finalhash[i] & 0x0f];
4959         }
4960
4961       DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
4962         (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
4963
4964       yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
4965       }
4966
4967     continue;
4968
4969     /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
4970     We have to save the numerical variables and restore them afterwards. */
4971
4972     case EITEM_SG:
4973       {
4974       const pcre *re;
4975       int moffset, moffsetextra, slen;
4976       int roffset;
4977       int emptyopt;
4978       const uschar *rerror;
4979       uschar *subject;
4980       uschar *sub[3];
4981       int save_expand_nmax =
4982         save_expand_strings(save_expand_nstring, save_expand_nlength);
4983
4984       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg", &resetok))
4985         {
4986         case 1: goto EXPAND_FAILED_CURLY;
4987         case 2:
4988         case 3: goto EXPAND_FAILED;
4989         }
4990
4991       /* Compile the regular expression */
4992
4993       re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
4994         NULL);
4995
4996       if (re == NULL)
4997         {
4998         expand_string_message = string_sprintf("regular expression error in "
4999           "\"%s\": %s at offset %d", sub[1], rerror, roffset);
5000         goto EXPAND_FAILED;
5001         }
5002
5003       /* Now run a loop to do the substitutions as often as necessary. It ends
5004       when there are no more matches. Take care over matches of the null string;
5005       do the same thing as Perl does. */
5006
5007       subject = sub[0];
5008       slen = Ustrlen(sub[0]);
5009       moffset = moffsetextra = 0;
5010       emptyopt = 0;
5011
5012       for (;;)
5013         {
5014         int ovector[3*(EXPAND_MAXN+1)];
5015         int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
5016           PCRE_EOPT | emptyopt, ovector, sizeof(ovector)/sizeof(int));
5017         int nn;
5018         uschar *insert;
5019
5020         /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
5021         is not necessarily the end. We want to repeat the match from one
5022         character further along, but leaving the basic offset the same (for
5023         copying below). We can't be at the end of the string - that was checked
5024         before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
5025         finished; copy the remaining string and end the loop. */
5026
5027         if (n < 0)
5028           {
5029           if (emptyopt != 0)
5030             {
5031             moffsetextra = 1;
5032             emptyopt = 0;
5033             continue;
5034             }
5035           yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
5036           break;
5037           }
5038
5039         /* Match - set up for expanding the replacement. */
5040
5041         if (n == 0) n = EXPAND_MAXN + 1;
5042         expand_nmax = 0;
5043         for (nn = 0; nn < n*2; nn += 2)
5044           {
5045           expand_nstring[expand_nmax] = subject + ovector[nn];
5046           expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5047           }
5048         expand_nmax--;
5049
5050         /* Copy the characters before the match, plus the expanded insertion. */
5051
5052         yield = string_cat(yield, &size, &ptr, subject + moffset,
5053           ovector[0] - moffset);
5054         insert = expand_string(sub[2]);
5055         if (insert == NULL) goto EXPAND_FAILED;
5056         yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
5057
5058         moffset = ovector[1];
5059         moffsetextra = 0;
5060         emptyopt = 0;
5061
5062         /* If we have matched an empty string, first check to see if we are at
5063         the end of the subject. If so, the loop is over. Otherwise, mimic
5064         what Perl's /g options does. This turns out to be rather cunning. First
5065         we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
5066         string at the same point. If this fails (picked up above) we advance to
5067         the next character. */
5068
5069         if (ovector[0] == ovector[1])
5070           {
5071           if (ovector[0] == slen) break;
5072           emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
5073           }
5074         }
5075
5076       /* All done - restore numerical variables. */
5077
5078       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5079         save_expand_nlength);
5080       continue;
5081       }
5082
5083     /* Handle keyed and numbered substring extraction. If the first argument
5084     consists entirely of digits, then a numerical extraction is assumed. */
5085
5086     case EITEM_EXTRACT:
5087       {
5088       int i;
5089       int j = 2;
5090       int field_number = 1;
5091       BOOL field_number_set = FALSE;
5092       uschar *save_lookup_value = lookup_value;
5093       uschar *sub[3];
5094       int save_expand_nmax =
5095         save_expand_strings(save_expand_nstring, save_expand_nlength);
5096
5097       /* Read the arguments */
5098
5099       for (i = 0; i < j; i++)
5100         {
5101         while (isspace(*s)) s++;
5102         if (*s == '{')                                          /*}*/
5103           {
5104           sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5105           if (sub[i] == NULL) goto EXPAND_FAILED;               /*{*/
5106           if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5107
5108           /* After removal of leading and trailing white space, the first
5109           argument must not be empty; if it consists entirely of digits
5110           (optionally preceded by a minus sign), this is a numerical
5111           extraction, and we expect 3 arguments. */
5112
5113           if (i == 0)
5114             {
5115             int len;
5116             int x = 0;
5117             uschar *p = sub[0];
5118
5119             while (isspace(*p)) p++;
5120             sub[0] = p;
5121
5122             len = Ustrlen(p);
5123             while (len > 0 && isspace(p[len-1])) len--;
5124             p[len] = 0;
5125
5126             if (*p == 0 && !skipping)
5127               {
5128               expand_string_message = US"first argument of \"extract\" must "
5129                 "not be empty";
5130               goto EXPAND_FAILED;
5131               }
5132
5133             if (*p == '-')
5134               {
5135               field_number = -1;
5136               p++;
5137               }
5138             while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
5139             if (*p == 0)
5140               {
5141               field_number *= x;
5142               j = 3;               /* Need 3 args */
5143               field_number_set = TRUE;
5144               }
5145             }
5146           }
5147         else goto EXPAND_FAILED_CURLY;
5148         }
5149
5150       /* Extract either the numbered or the keyed substring into $value. If
5151       skipping, just pretend the extraction failed. */
5152
5153       lookup_value = skipping? NULL : field_number_set?
5154         expand_gettokened(field_number, sub[1], sub[2]) :
5155         expand_getkeyed(sub[0], sub[1]);
5156
5157       /* If no string follows, $value gets substituted; otherwise there can
5158       be yes/no strings, as for lookup or if. */
5159
5160       switch(process_yesno(
5161                skipping,                     /* were previously skipping */
5162                lookup_value != NULL,         /* success/failure indicator */
5163                save_lookup_value,            /* value to reset for string2 */
5164                &s,                           /* input pointer */
5165                &yield,                       /* output pointer */
5166                &size,                        /* output size */
5167                &ptr,                         /* output current point */
5168                US"extract",                  /* condition type */
5169                &resetok))
5170         {
5171         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5172         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5173         }
5174
5175       /* All done - restore numerical variables. */
5176
5177       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5178         save_expand_nlength);
5179
5180       continue;
5181       }
5182
5183     /* return the Nth item from a list */
5184
5185     case EITEM_LISTEXTRACT:
5186       {
5187       int i;
5188       int field_number = 1;
5189       uschar *save_lookup_value = lookup_value;
5190       uschar *sub[2];
5191       int save_expand_nmax =
5192         save_expand_strings(save_expand_nstring, save_expand_nlength);
5193
5194       /* Read the field & list arguments */
5195
5196       for (i = 0; i < 2; i++)
5197         {
5198         while (isspace(*s)) s++;
5199         if (*s != '{')                                  /*}*/
5200           goto EXPAND_FAILED_CURLY;
5201
5202         sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5203         if (!sub[i])     goto EXPAND_FAILED;            /*{*/
5204         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5205
5206         /* After removal of leading and trailing white space, the first
5207         argument must be numeric and nonempty. */
5208
5209         if (i == 0)
5210           {
5211           int len;
5212           int x = 0;
5213           uschar *p = sub[0];
5214
5215           while (isspace(*p)) p++;
5216           sub[0] = p;
5217
5218           len = Ustrlen(p);
5219           while (len > 0 && isspace(p[len-1])) len--;
5220           p[len] = 0;
5221
5222           if (!*p && !skipping)
5223             {
5224             expand_string_message = US"first argument of \"listextract\" must "
5225               "not be empty";
5226             goto EXPAND_FAILED;
5227             }
5228
5229           if (*p == '-')
5230             {
5231             field_number = -1;
5232             p++;
5233             }
5234           while (*p && isdigit(*p)) x = x * 10 + *p++ - '0';
5235           if (*p)
5236             {
5237             expand_string_message = US"first argument of \"listextract\" must "
5238               "be numeric";
5239             goto EXPAND_FAILED;
5240             }
5241           field_number *= x;
5242           }
5243         }
5244
5245       /* Extract the numbered element into $value. If
5246       skipping, just pretend the extraction failed. */
5247
5248       lookup_value = skipping? NULL : expand_getlistele(field_number, sub[1]);
5249
5250       /* If no string follows, $value gets substituted; otherwise there can
5251       be yes/no strings, as for lookup or if. */
5252
5253       switch(process_yesno(
5254                skipping,                     /* were previously skipping */
5255                lookup_value != NULL,         /* success/failure indicator */
5256                save_lookup_value,            /* value to reset for string2 */
5257                &s,                           /* input pointer */
5258                &yield,                       /* output pointer */
5259                &size,                        /* output size */
5260                &ptr,                         /* output current point */
5261                US"extract",                  /* condition type */
5262                &resetok))
5263         {
5264         case 1: goto EXPAND_FAILED;          /* when all is well, the */
5265         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
5266         }
5267
5268       /* All done - restore numerical variables. */
5269
5270       restore_expand_strings(save_expand_nmax, save_expand_nstring,
5271         save_expand_nlength);
5272
5273       continue;
5274       }
5275
5276     /* Handle list operations */
5277
5278     case EITEM_FILTER:
5279     case EITEM_MAP:
5280     case EITEM_REDUCE:
5281       {
5282       int sep = 0;
5283       int save_ptr = ptr;
5284       uschar outsep[2] = { '\0', '\0' };
5285       uschar *list, *expr, *temp;
5286       uschar *save_iterate_item = iterate_item;
5287       uschar *save_lookup_value = lookup_value;
5288
5289       while (isspace(*s)) s++;
5290       if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5291
5292       list = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5293       if (list == NULL) goto EXPAND_FAILED;
5294       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5295
5296       if (item_type == EITEM_REDUCE)
5297         {
5298         while (isspace(*s)) s++;
5299         if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5300         temp = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5301         if (temp == NULL) goto EXPAND_FAILED;
5302         lookup_value = temp;
5303         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5304         }
5305
5306       while (isspace(*s)) s++;
5307       if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5308
5309       expr = s;
5310
5311       /* For EITEM_FILTER, call eval_condition once, with result discarded (as
5312       if scanning a "false" part). This allows us to find the end of the
5313       condition, because if the list is empty, we won't actually evaluate the
5314       condition for real. For EITEM_MAP and EITEM_REDUCE, do the same, using
5315       the normal internal expansion function. */
5316
5317       if (item_type == EITEM_FILTER)
5318         {
5319         temp = eval_condition(expr, &resetok, NULL);
5320         if (temp != NULL) s = temp;
5321         }
5322       else
5323         {
5324         temp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
5325         }
5326
5327       if (temp == NULL)
5328         {
5329         expand_string_message = string_sprintf("%s inside \"%s\" item",
5330           expand_string_message, name);
5331         goto EXPAND_FAILED;
5332         }
5333
5334       while (isspace(*s)) s++;
5335       if (*s++ != '}')
5336         {                                               /*{*/
5337         expand_string_message = string_sprintf("missing } at end of condition "
5338           "or expression inside \"%s\"", name);
5339         goto EXPAND_FAILED;
5340         }
5341
5342       while (isspace(*s)) s++;                          /*{*/
5343       if (*s++ != '}')
5344         {                                               /*{*/
5345         expand_string_message = string_sprintf("missing } at end of \"%s\"",
5346           name);
5347         goto EXPAND_FAILED;
5348         }
5349
5350       /* If we are skipping, we can now just move on to the next item. When
5351       processing for real, we perform the iteration. */
5352
5353       if (skipping) continue;
5354       while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
5355         {
5356         *outsep = (uschar)sep;      /* Separator as a string */
5357
5358         DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
5359
5360         if (item_type == EITEM_FILTER)
5361           {
5362           BOOL condresult;
5363           if (eval_condition(expr, &resetok, &condresult) == NULL)
5364             {
5365             iterate_item = save_iterate_item;
5366             lookup_value = save_lookup_value;
5367             expand_string_message = string_sprintf("%s inside \"%s\" condition",
5368               expand_string_message, name);
5369             goto EXPAND_FAILED;
5370             }
5371           DEBUG(D_expand) debug_printf("%s: condition is %s\n", name,
5372             condresult? "true":"false");
5373           if (condresult)
5374             temp = iterate_item;    /* TRUE => include this item */
5375           else
5376             continue;               /* FALSE => skip this item */
5377           }
5378
5379         /* EITEM_MAP and EITEM_REDUCE */
5380
5381         else
5382           {
5383           temp = expand_string_internal(expr, TRUE, NULL, skipping, TRUE, &resetok);
5384           if (temp == NULL)
5385             {
5386             iterate_item = save_iterate_item;
5387             expand_string_message = string_sprintf("%s inside \"%s\" item",
5388               expand_string_message, name);
5389             goto EXPAND_FAILED;
5390             }
5391           if (item_type == EITEM_REDUCE)
5392             {
5393             lookup_value = temp;      /* Update the value of $value */
5394             continue;                 /* and continue the iteration */
5395             }
5396           }
5397
5398         /* We reach here for FILTER if the condition is true, always for MAP,
5399         and never for REDUCE. The value in "temp" is to be added to the output
5400         list that is being created, ensuring that any occurrences of the
5401         separator character are doubled. Unless we are dealing with the first
5402         item of the output list, add in a space if the new item begins with the
5403         separator character, or is an empty string. */
5404
5405         if (ptr != save_ptr && (temp[0] == *outsep || temp[0] == 0))
5406           yield = string_cat(yield, &size, &ptr, US" ", 1);
5407
5408         /* Add the string in "temp" to the output list that we are building,
5409         This is done in chunks by searching for the separator character. */
5410
5411         for (;;)
5412           {
5413           size_t seglen = Ustrcspn(temp, outsep);
5414             yield = string_cat(yield, &size, &ptr, temp, seglen + 1);
5415
5416           /* If we got to the end of the string we output one character
5417           too many; backup and end the loop. Otherwise arrange to double the
5418           separator. */
5419
5420           if (temp[seglen] == '\0') { ptr--; break; }
5421           yield = string_cat(yield, &size, &ptr, outsep, 1);
5422           temp += seglen + 1;
5423           }
5424
5425         /* Output a separator after the string: we will remove the redundant
5426         final one at the end. */
5427
5428         yield = string_cat(yield, &size, &ptr, outsep, 1);
5429         }   /* End of iteration over the list loop */
5430
5431       /* REDUCE has generated no output above: output the final value of
5432       $value. */
5433
5434       if (item_type == EITEM_REDUCE)
5435         {
5436         yield = string_cat(yield, &size, &ptr, lookup_value,
5437           Ustrlen(lookup_value));
5438         lookup_value = save_lookup_value;  /* Restore $value */
5439         }
5440
5441       /* FILTER and MAP generate lists: if they have generated anything, remove
5442       the redundant final separator. Even though an empty item at the end of a
5443       list does not count, this is tidier. */
5444
5445       else if (ptr != save_ptr) ptr--;
5446
5447       /* Restore preserved $item */
5448
5449       iterate_item = save_iterate_item;
5450       continue;
5451       }
5452
5453
5454     /* If ${dlfunc } support is configured, handle calling dynamically-loaded
5455     functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
5456     or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
5457     a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
5458
5459     #define EXPAND_DLFUNC_MAX_ARGS 8
5460
5461     case EITEM_DLFUNC:
5462     #ifndef EXPAND_DLFUNC
5463     expand_string_message = US"\"${dlfunc\" encountered, but this facility "    /*}*/
5464       "is not included in this binary";
5465     goto EXPAND_FAILED;
5466
5467     #else   /* EXPAND_DLFUNC */
5468       {
5469       tree_node *t;
5470       exim_dlfunc_t *func;
5471       uschar *result;
5472       int status, argc;
5473       uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
5474
5475       if ((expand_forbid & RDO_DLFUNC) != 0)
5476         {
5477         expand_string_message =
5478           US"dynamically-loaded functions are not permitted";
5479         goto EXPAND_FAILED;
5480         }
5481
5482       switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
5483            TRUE, US"dlfunc", &resetok))
5484         {
5485         case 1: goto EXPAND_FAILED_CURLY;
5486         case 2:
5487         case 3: goto EXPAND_FAILED;
5488         }
5489
5490       /* If skipping, we don't actually do anything */
5491
5492       if (skipping) continue;
5493
5494       /* Look up the dynamically loaded object handle in the tree. If it isn't
5495       found, dlopen() the file and put the handle in the tree for next time. */
5496
5497       t = tree_search(dlobj_anchor, argv[0]);
5498       if (t == NULL)
5499         {
5500         void *handle = dlopen(CS argv[0], RTLD_LAZY);
5501         if (handle == NULL)
5502           {
5503           expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
5504             argv[0], dlerror());
5505           log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
5506           goto EXPAND_FAILED;
5507           }
5508         t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
5509         Ustrcpy(t->name, argv[0]);
5510         t->data.ptr = handle;
5511         (void)tree_insertnode(&dlobj_anchor, t);
5512         }
5513
5514       /* Having obtained the dynamically loaded object handle, look up the
5515       function pointer. */
5516
5517       func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
5518       if (func == NULL)
5519         {
5520         expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
5521           "%s", argv[1], argv[0], dlerror());
5522         log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
5523         goto EXPAND_FAILED;
5524         }
5525
5526       /* Call the function and work out what to do with the result. If it
5527       returns OK, we have a replacement string; if it returns DEFER then
5528       expansion has failed in a non-forced manner; if it returns FAIL then
5529       failure was forced; if it returns ERROR or any other value there's a
5530       problem, so panic slightly. In any case, assume that the function has
5531       side-effects on the store that must be preserved. */
5532
5533       resetok = FALSE;
5534       result = NULL;
5535       for (argc = 0; argv[argc] != NULL; argc++);
5536       status = func(&result, argc - 2, &argv[2]);
5537       if(status == OK)
5538         {
5539         if (result == NULL) result = US"";
5540         yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
5541         continue;
5542         }
5543       else
5544         {
5545         expand_string_message = result == NULL ? US"(no message)" : result;
5546         if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
5547           else if(status != FAIL)
5548             log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
5549               argv[0], argv[1], status, expand_string_message);
5550         goto EXPAND_FAILED;
5551         }
5552       }
5553     #endif /* EXPAND_DLFUNC */
5554     }   /* EITEM_* switch */
5555
5556   /* Control reaches here if the name is not recognized as one of the more
5557   complicated expansion items. Check for the "operator" syntax (name terminated
5558   by a colon). Some of the operators have arguments, separated by _ from the
5559   name. */
5560
5561   if (*s == ':')
5562     {
5563     int c;
5564     uschar *arg = NULL;
5565     uschar *sub = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5566     if (sub == NULL) goto EXPAND_FAILED;
5567     s++;
5568
5569     /* Owing to an historical mis-design, an underscore may be part of the
5570     operator name, or it may introduce arguments.  We therefore first scan the
5571     table of names that contain underscores. If there is no match, we cut off
5572     the arguments and then scan the main table. */
5573
5574     c = chop_match(name, op_table_underscore,
5575       sizeof(op_table_underscore)/sizeof(uschar *));
5576
5577     if (c < 0)
5578       {
5579       arg = Ustrchr(name, '_');
5580       if (arg != NULL) *arg = 0;
5581       c = chop_match(name, op_table_main,
5582         sizeof(op_table_main)/sizeof(uschar *));
5583       if (c >= 0) c += sizeof(op_table_underscore)/sizeof(uschar *);
5584       if (arg != NULL) *arg++ = '_';   /* Put back for error messages */
5585       }
5586
5587     /* If we are skipping, we don't need to perform the operation at all.
5588     This matters for operations like "mask", because the data may not be
5589     in the correct format when skipping. For example, the expression may test
5590     for the existence of $sender_host_address before trying to mask it. For
5591     other operations, doing them may not fail, but it is a waste of time. */
5592
5593     if (skipping && c >= 0) continue;
5594
5595     /* Otherwise, switch on the operator type */
5596
5597     switch(c)
5598       {
5599       case EOP_BASE62:
5600         {
5601         uschar *t;
5602         unsigned long int n = Ustrtoul(sub, &t, 10);
5603         if (*t != 0)
5604           {
5605           expand_string_message = string_sprintf("argument for base62 "
5606             "operator is \"%s\", which is not a decimal number", sub);
5607           goto EXPAND_FAILED;
5608           }
5609         t = string_base62(n);
5610         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
5611         continue;
5612         }
5613
5614       /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
5615
5616       case EOP_BASE62D:
5617         {
5618         uschar buf[16];
5619         uschar *tt = sub;
5620         unsigned long int n = 0;
5621         while (*tt != 0)
5622           {
5623           uschar *t = Ustrchr(base62_chars, *tt++);
5624           if (t == NULL)
5625             {
5626             expand_string_message = string_sprintf("argument for base62d "
5627               "operator is \"%s\", which is not a base %d number", sub,
5628               BASE_62);
5629             goto EXPAND_FAILED;
5630             }
5631           n = n * BASE_62 + (t - base62_chars);
5632           }
5633         (void)sprintf(CS buf, "%ld", n);
5634         yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
5635         continue;
5636         }
5637
5638       case EOP_EXPAND:
5639         {
5640         uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping, TRUE, &resetok);
5641         if (expanded == NULL)
5642           {
5643           expand_string_message =
5644             string_sprintf("internal expansion of \"%s\" failed: %s", sub,
5645               expand_string_message);
5646           goto EXPAND_FAILED;
5647           }
5648         yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
5649         continue;
5650         }
5651
5652       case EOP_LC:
5653         {
5654         int count = 0;
5655         uschar *t = sub - 1;
5656         while (*(++t) != 0) { *t = tolower(*t); count++; }
5657         yield = string_cat(yield, &size, &ptr, sub, count);
5658         continue;
5659         }
5660
5661       case EOP_UC:
5662         {
5663         int count = 0;
5664         uschar *t = sub - 1;
5665         while (*(++t) != 0) { *t = toupper(*t); count++; }
5666         yield = string_cat(yield, &size, &ptr, sub, count);
5667         continue;
5668         }
5669
5670       case EOP_MD5:
5671         {
5672         md5 base;
5673         uschar digest[16];
5674         int j;
5675         char st[33];
5676         md5_start(&base);
5677         md5_end(&base, sub, Ustrlen(sub), digest);
5678         for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
5679         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
5680         continue;
5681         }
5682
5683       case EOP_SHA1:
5684         {
5685         sha1 base;
5686         uschar digest[20];
5687         int j;
5688         char st[41];
5689         sha1_start(&base);
5690         sha1_end(&base, sub, Ustrlen(sub), digest);
5691         for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
5692         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
5693         continue;
5694         }
5695
5696       /* Convert hex encoding to base64 encoding */
5697
5698       case EOP_HEX2B64:
5699         {
5700         int c = 0;
5701         int b = -1;
5702         uschar *in = sub;
5703         uschar *out = sub;
5704         uschar *enc;
5705
5706         for (enc = sub; *enc != 0; enc++)
5707           {
5708           if (!isxdigit(*enc))
5709             {
5710             expand_string_message = string_sprintf("\"%s\" is not a hex "
5711               "string", sub);
5712             goto EXPAND_FAILED;
5713             }
5714           c++;
5715           }
5716
5717         if ((c & 1) != 0)
5718           {
5719           expand_string_message = string_sprintf("\"%s\" contains an odd "
5720             "number of characters", sub);
5721           goto EXPAND_FAILED;
5722           }
5723
5724         while ((c = *in++) != 0)
5725           {
5726           if (isdigit(c)) c -= '0';
5727           else c = toupper(c) - 'A' + 10;
5728           if (b == -1)
5729             {
5730             b = c << 4;
5731             }
5732           else
5733             {
5734             *out++ = b | c;
5735             b = -1;
5736             }
5737           }
5738
5739         enc = auth_b64encode(sub, out - sub);
5740         yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
5741         continue;
5742         }
5743
5744       /* Convert octets outside 0x21..0x7E to \xXX form */
5745
5746       case EOP_HEXQUOTE:
5747         {
5748         uschar *t = sub - 1;
5749         while (*(++t) != 0)
5750           {
5751           if (*t < 0x21 || 0x7E < *t)
5752             yield = string_cat(yield, &size, &ptr,
5753               string_sprintf("\\x%02x", *t), 4);
5754           else
5755             yield = string_cat(yield, &size, &ptr, t, 1);
5756           }
5757         continue;
5758         }
5759
5760       /* count the number of list elements */
5761
5762       case EOP_LISTCOUNT:
5763         {
5764         int cnt = 0;
5765         int sep = 0;
5766         uschar * cp;
5767         uschar buffer[256];
5768
5769         while (string_nextinlist(&sub, &sep, buffer, sizeof(buffer)) != NULL) cnt++;
5770         cp = string_sprintf("%d", cnt);
5771         yield = string_cat(yield, &size, &ptr, cp, Ustrlen(cp));
5772         continue;
5773         }
5774
5775       /* expand a named list given the name */
5776       /* handles nested named lists; requotes as colon-sep list */
5777
5778       case EOP_LISTNAMED:
5779         {
5780         tree_node *t = NULL;
5781         uschar * list;
5782         int sep = 0;
5783         uschar * item;
5784         uschar * suffix = US"";
5785         BOOL needsep = FALSE;
5786         uschar buffer[256];
5787
5788         if (*sub == '+') sub++;
5789         if (arg == NULL)        /* no-argument version */
5790           {
5791           if (!(t = tree_search(addresslist_anchor, sub)) &&
5792               !(t = tree_search(domainlist_anchor,  sub)) &&
5793               !(t = tree_search(hostlist_anchor,    sub)))
5794             t = tree_search(localpartlist_anchor, sub);
5795           }
5796         else switch(*arg)       /* specific list-type version */
5797           {
5798           case 'a': t = tree_search(addresslist_anchor,   sub); suffix = US"_a"; break;
5799           case 'd': t = tree_search(domainlist_anchor,    sub); suffix = US"_d"; break;
5800           case 'h': t = tree_search(hostlist_anchor,      sub); suffix = US"_h"; break;
5801           case 'l': t = tree_search(localpartlist_anchor, sub); suffix = US"_l"; break;
5802           default:
5803             expand_string_message = string_sprintf("bad suffix on \"list\" operator");
5804             goto EXPAND_FAILED;
5805           }
5806
5807         if(!t)
5808           {
5809           expand_string_message = string_sprintf("\"%s\" is not a %snamed list",
5810             sub, !arg?""
5811               : *arg=='a'?"address "
5812               : *arg=='d'?"domain "
5813               : *arg=='h'?"host "
5814               : *arg=='l'?"localpart "
5815               : 0);
5816           goto EXPAND_FAILED;
5817           }
5818
5819         list = ((namedlist_block *)(t->data.ptr))->string;
5820
5821         while ((item = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
5822           {
5823           uschar * buf = US" : ";
5824           if (needsep)
5825             yield = string_cat(yield, &size, &ptr, buf, 3);
5826           else
5827             needsep = TRUE;
5828
5829           if (*item == '+')     /* list item is itself a named list */
5830             {
5831             uschar * sub = string_sprintf("${listnamed%s:%s}", suffix, item);
5832             item = expand_string_internal(sub, FALSE, NULL, FALSE, TRUE, &resetok);
5833             }
5834           else if (sep != ':')  /* item from non-colon-sep list, re-quote for colon list-separator */
5835             {
5836             char * cp;
5837             char tok[3];
5838             tok[0] = sep; tok[1] = ':'; tok[2] = 0;
5839             while ((cp= strpbrk((const char *)item, tok)))
5840               {
5841               yield = string_cat(yield, &size, &ptr, item, cp-(char *)item);
5842               if (*cp++ == ':') /* colon in a non-colon-sep list item, needs doubling */
5843                 {
5844                 yield = string_cat(yield, &size, &ptr, US"::", 2);
5845                 item = (uschar *)cp;
5846                 }
5847               else              /* sep in item; should already be doubled; emit once */
5848                 {
5849                 yield = string_cat(yield, &size, &ptr, (uschar *)tok, 1);
5850                 if (*cp == sep) cp++;
5851                 item = (uschar *)cp;
5852                 }
5853               }
5854             }
5855           yield = string_cat(yield, &size, &ptr, item, Ustrlen(item));
5856           }
5857         continue;
5858         }
5859
5860       /* mask applies a mask to an IP address; for example the result of
5861       ${mask:131.111.10.206/28} is 131.111.10.192/28. */
5862
5863       case EOP_MASK:
5864         {
5865         int count;
5866         uschar *endptr;
5867         int binary[4];
5868         int mask, maskoffset;
5869         int type = string_is_ip_address(sub, &maskoffset);
5870         uschar buffer[64];
5871
5872         if (type == 0)
5873           {
5874           expand_string_message = string_sprintf("\"%s\" is not an IP address",
5875            sub);
5876           goto EXPAND_FAILED;
5877           }
5878
5879         if (maskoffset == 0)
5880           {
5881           expand_string_message = string_sprintf("missing mask value in \"%s\"",
5882             sub);
5883           goto EXPAND_FAILED;
5884           }
5885
5886         mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
5887
5888         if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
5889           {
5890           expand_string_message = string_sprintf("mask value too big in \"%s\"",
5891             sub);
5892           goto EXPAND_FAILED;
5893           }
5894
5895         /* Convert the address to binary integer(s) and apply the mask */
5896
5897         sub[maskoffset] = 0;
5898         count = host_aton(sub, binary);
5899         host_mask(count, binary, mask);
5900
5901         /* Convert to masked textual format and add to output. */
5902
5903         yield = string_cat(yield, &size, &ptr, buffer,
5904           host_nmtoa(count, binary, mask, buffer, '.'));
5905         continue;
5906         }
5907
5908       case EOP_ADDRESS:
5909       case EOP_LOCAL_PART:
5910       case EOP_DOMAIN:
5911         {
5912         uschar *error;
5913         int start, end, domain;
5914         uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
5915           FALSE);
5916         if (t != NULL)
5917           {
5918           if (c != EOP_DOMAIN)
5919             {
5920             if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
5921             yield = string_cat(yield, &size, &ptr, sub+start, end-start);
5922             }
5923           else if (domain != 0)
5924             {
5925             domain += start;
5926             yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
5927             }
5928           }
5929         continue;
5930         }
5931
5932       case EOP_ADDRESSES:
5933         {
5934         uschar outsep[2] = { ':', '\0' };
5935         uschar *address, *error;
5936         int save_ptr = ptr;
5937         int start, end, domain;  /* Not really used */
5938
5939         while (isspace(*sub)) sub++;
5940         if (*sub == '>') { *outsep = *++sub; ++sub; }
5941         parse_allow_group = TRUE;
5942
5943         for (;;)
5944           {
5945           uschar *p = parse_find_address_end(sub, FALSE);
5946           uschar saveend = *p;
5947           *p = '\0';
5948           address = parse_extract_address(sub, &error, &start, &end, &domain,
5949             FALSE);
5950           *p = saveend;
5951
5952           /* Add the address to the output list that we are building. This is
5953           done in chunks by searching for the separator character. At the
5954           start, unless we are dealing with the first address of the output
5955           list, add in a space if the new address begins with the separator
5956           character, or is an empty string. */
5957
5958           if (address != NULL)
5959             {
5960             if (ptr != save_ptr && address[0] == *outsep)
5961               yield = string_cat(yield, &size, &ptr, US" ", 1);
5962
5963             for (;;)
5964               {
5965               size_t seglen = Ustrcspn(address, outsep);
5966               yield = string_cat(yield, &size, &ptr, address, seglen + 1);
5967
5968               /* If we got to the end of the string we output one character
5969               too many. */
5970
5971               if (address[seglen] == '\0') { ptr--; break; }
5972               yield = string_cat(yield, &size, &ptr, outsep, 1);
5973               address += seglen + 1;
5974               }
5975
5976             /* Output a separator after the string: we will remove the
5977             redundant final one at the end. */
5978
5979             yield = string_cat(yield, &size, &ptr, outsep, 1);
5980             }
5981
5982           if (saveend == '\0') break;
5983           sub = p + 1;
5984           }
5985
5986         /* If we have generated anything, remove the redundant final
5987         separator. */
5988
5989         if (ptr != save_ptr) ptr--;
5990         parse_allow_group = FALSE;
5991         continue;
5992         }
5993
5994
5995       /* quote puts a string in quotes if it is empty or contains anything
5996       other than alphamerics, underscore, dot, or hyphen.
5997
5998       quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
5999       be quoted in order to be a valid local part.
6000
6001       In both cases, newlines and carriage returns are converted into \n and \r
6002       respectively */
6003
6004       case EOP_QUOTE:
6005       case EOP_QUOTE_LOCAL_PART:
6006       if (arg == NULL)
6007         {
6008         BOOL needs_quote = (*sub == 0);      /* TRUE for empty string */
6009         uschar *t = sub - 1;
6010
6011         if (c == EOP_QUOTE)
6012           {
6013           while (!needs_quote && *(++t) != 0)
6014             needs_quote = !isalnum(*t) && !strchr("_-.", *t);
6015           }
6016         else  /* EOP_QUOTE_LOCAL_PART */
6017           {
6018           while (!needs_quote && *(++t) != 0)
6019             needs_quote = !isalnum(*t) &&
6020               strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
6021               (*t != '.' || t == sub || t[1] == 0);
6022           }
6023
6024         if (needs_quote)
6025           {
6026           yield = string_cat(yield, &size, &ptr, US"\"", 1);
6027           t = sub - 1;
6028           while (*(++t) != 0)
6029             {
6030             if (*t == '\n')
6031               yield = string_cat(yield, &size, &ptr, US"\\n", 2);
6032             else if (*t == '\r')
6033               yield = string_cat(yield, &size, &ptr, US"\\r", 2);
6034             else
6035               {
6036               if (*t == '\\' || *t == '"')
6037                 yield = string_cat(yield, &size, &ptr, US"\\", 1);
6038               yield = string_cat(yield, &size, &ptr, t, 1);
6039               }
6040             }
6041           yield = string_cat(yield, &size, &ptr, US"\"", 1);
6042           }
6043         else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
6044         continue;
6045         }
6046
6047       /* quote_lookuptype does lookup-specific quoting */
6048
6049       else
6050         {
6051         int n;
6052         uschar *opt = Ustrchr(arg, '_');
6053
6054         if (opt != NULL) *opt++ = 0;
6055
6056         n = search_findtype(arg, Ustrlen(arg));
6057         if (n < 0)
6058           {
6059           expand_string_message = search_error_message;
6060           goto EXPAND_FAILED;
6061           }
6062
6063         if (lookup_list[n]->quote != NULL)
6064           sub = (lookup_list[n]->quote)(sub, opt);
6065         else if (opt != NULL) sub = NULL;
6066
6067         if (sub == NULL)
6068           {
6069           expand_string_message = string_sprintf(
6070             "\"%s\" unrecognized after \"${quote_%s\"",
6071             opt, arg);
6072           goto EXPAND_FAILED;
6073           }
6074
6075         yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
6076         continue;
6077         }
6078
6079       /* rx quote sticks in \ before any non-alphameric character so that
6080       the insertion works in a regular expression. */
6081
6082       case EOP_RXQUOTE:
6083         {
6084         uschar *t = sub - 1;
6085         while (*(++t) != 0)
6086           {
6087           if (!isalnum(*t))
6088             yield = string_cat(yield, &size, &ptr, US"\\", 1);
6089           yield = string_cat(yield, &size, &ptr, t, 1);
6090           }
6091         continue;
6092         }
6093
6094       /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
6095       prescribed by the RFC, if there are characters that need to be encoded */
6096
6097       case EOP_RFC2047:
6098         {
6099         uschar buffer[2048];
6100         uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
6101           buffer, sizeof(buffer), FALSE);
6102         yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
6103         continue;
6104         }
6105
6106       /* RFC 2047 decode */
6107
6108       case EOP_RFC2047D:
6109         {
6110         int len;
6111         uschar *error;
6112         uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
6113           headers_charset, '?', &len, &error);
6114         if (error != NULL)
6115           {
6116           expand_string_message = error;
6117           goto EXPAND_FAILED;
6118           }
6119         yield = string_cat(yield, &size, &ptr, decoded, len);
6120         continue;
6121         }
6122
6123       /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
6124       underscores */
6125
6126       case EOP_FROM_UTF8:
6127         {
6128         while (*sub != 0)
6129           {
6130           int c;
6131           uschar buff[4];
6132           GETUTF8INC(c, sub);
6133           if (c > 255) c = '_';
6134           buff[0] = c;
6135           yield = string_cat(yield, &size, &ptr, buff, 1);
6136           }
6137         continue;
6138         }
6139
6140           /* replace illegal UTF-8 sequences by replacement character  */
6141
6142       #define UTF8_REPLACEMENT_CHAR US"?"
6143
6144       case EOP_UTF8CLEAN:
6145         {
6146         int seq_len, index = 0;
6147         int bytes_left  = 0;
6148         uschar seq_buff[4];                     /* accumulate utf-8 here */
6149
6150         while (*sub != 0)
6151           {
6152           int complete;
6153           long codepoint;
6154           uschar c;
6155
6156           complete = 0;
6157           c = *sub++;
6158           if(bytes_left)
6159             {
6160             if ((c & 0xc0) != 0x80)
6161               {
6162                     /* wrong continuation byte; invalidate all bytes */
6163               complete = 1; /* error */
6164               }
6165             else
6166               {
6167               codepoint = (codepoint << 6) | (c & 0x3f);
6168               seq_buff[index++] = c;
6169               if (--bytes_left == 0)            /* codepoint complete */
6170                 {
6171                 if(codepoint > 0x10FFFF)        /* is it too large? */
6172                   complete = -1;        /* error */
6173                 else
6174                   {             /* finished; output utf-8 sequence */
6175                   yield = string_cat(yield, &size, &ptr, seq_buff, seq_len);
6176                   index = 0;
6177                   }
6178                 }
6179               }
6180             }
6181           else  /* no bytes left: new sequence */
6182             {
6183             if((c & 0x80) == 0) /* 1-byte sequence, US-ASCII, keep it */
6184               {
6185               yield = string_cat(yield, &size, &ptr, &c, 1);
6186               continue;
6187               }
6188             if((c & 0xe0) == 0xc0)              /* 2-byte sequence */
6189               {
6190               bytes_left = 1;
6191               codepoint = c & 0x1f;
6192               }
6193             else if((c & 0xf0) == 0xe0)         /* 3-byte sequence */
6194               {
6195               bytes_left = 2;
6196               codepoint = c & 0x0f;
6197               }
6198             else if((c & 0xf8) == 0xf0)         /* 4-byte sequence */
6199               {
6200               bytes_left = 3;
6201               codepoint = c & 0x07;
6202               }
6203             else        /* invalid or too long (RFC3629 allows only 4 bytes) */
6204               complete = -1;
6205
6206             seq_buff[index++] = c;
6207             seq_len = bytes_left + 1;
6208             }           /* if(bytes_left) */
6209
6210           if (complete != 0)
6211             {
6212             bytes_left = index = 0;
6213             yield = string_cat(yield, &size, &ptr, UTF8_REPLACEMENT_CHAR, 1);
6214             }
6215           if ((complete == 1) && ((c & 0x80) == 0))
6216             { /* ASCII character follows incomplete sequence */
6217               yield = string_cat(yield, &size, &ptr, &c, 1);
6218             }
6219           }
6220         continue;
6221         }
6222
6223       /* escape turns all non-printing characters into escape sequences. */
6224
6225       case EOP_ESCAPE:
6226         {
6227         uschar *t = string_printing(sub);
6228         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
6229         continue;
6230         }
6231
6232       /* Handle numeric expression evaluation */
6233
6234       case EOP_EVAL:
6235       case EOP_EVAL10:
6236         {
6237         uschar *save_sub = sub;
6238         uschar *error = NULL;
6239         int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
6240         if (error != NULL)
6241           {
6242           expand_string_message = string_sprintf("error in expression "
6243             "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
6244               save_sub);
6245           goto EXPAND_FAILED;
6246           }
6247         sprintf(CS var_buffer, PR_EXIM_ARITH, n);
6248         yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
6249         continue;
6250         }
6251
6252       /* Handle time period formating */
6253
6254       case EOP_TIME_EVAL:
6255         {
6256         int n = readconf_readtime(sub, 0, FALSE);
6257         if (n < 0)
6258           {
6259           expand_string_message = string_sprintf("string \"%s\" is not an "
6260             "Exim time interval in \"%s\" operator", sub, name);
6261           goto EXPAND_FAILED;
6262           }
6263         sprintf(CS var_buffer, "%d", n);
6264         yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
6265         continue;
6266         }
6267
6268       case EOP_TIME_INTERVAL:
6269         {
6270         int n;
6271         uschar *t = read_number(&n, sub);
6272         if (*t != 0) /* Not A Number*/
6273           {
6274           expand_string_message = string_sprintf("string \"%s\" is not a "
6275             "positive number in \"%s\" operator", sub, name);
6276           goto EXPAND_FAILED;
6277           }
6278         t = readconf_printtime(n);
6279         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
6280         continue;
6281         }
6282
6283       /* Convert string to base64 encoding */
6284
6285       case EOP_STR2B64:
6286         {
6287         uschar *encstr = auth_b64encode(sub, Ustrlen(sub));
6288         yield = string_cat(yield, &size, &ptr, encstr, Ustrlen(encstr));
6289         continue;
6290         }
6291
6292       /* strlen returns the length of the string */
6293
6294       case EOP_STRLEN:
6295         {
6296         uschar buff[24];
6297         (void)sprintf(CS buff, "%d", Ustrlen(sub));
6298         yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
6299         continue;
6300         }
6301
6302       /* length_n or l_n takes just the first n characters or the whole string,
6303       whichever is the shorter;
6304
6305       substr_m_n, and s_m_n take n characters from offset m; negative m take
6306       from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
6307       takes the rest, either to the right or to the left.
6308
6309       hash_n or h_n makes a hash of length n from the string, yielding n
6310       characters from the set a-z; hash_n_m makes a hash of length n, but
6311       uses m characters from the set a-zA-Z0-9.
6312
6313       nhash_n returns a single number between 0 and n-1 (in text form), while
6314       nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
6315       between 0 and n-1 and the second between 0 and m-1. */
6316
6317       case EOP_LENGTH:
6318       case EOP_L:
6319       case EOP_SUBSTR:
6320       case EOP_S:
6321       case EOP_HASH:
6322       case EOP_H:
6323       case EOP_NHASH:
6324       case EOP_NH:
6325         {
6326         int sign = 1;
6327         int value1 = 0;
6328         int value2 = -1;
6329         int *pn;
6330         int len;
6331         uschar *ret;
6332
6333         if (arg == NULL)
6334           {
6335           expand_string_message = string_sprintf("missing values after %s",
6336             name);
6337           goto EXPAND_FAILED;
6338           }
6339
6340         /* "length" has only one argument, effectively being synonymous with
6341         substr_0_n. */
6342
6343         if (c == EOP_LENGTH || c == EOP_L)
6344           {
6345           pn = &value2;
6346           value2 = 0;
6347           }
6348
6349         /* The others have one or two arguments; for "substr" the first may be
6350         negative. The second being negative means "not supplied". */
6351
6352         else
6353           {
6354           pn = &value1;
6355           if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
6356           }
6357
6358         /* Read up to two numbers, separated by underscores */
6359
6360         ret = arg;
6361         while (*arg != 0)
6362           {
6363           if (arg != ret && *arg == '_' && pn == &value1)
6364             {
6365             pn = &value2;
6366             value2 = 0;
6367             if (arg[1] != 0) arg++;
6368             }
6369           else if (!isdigit(*arg))
6370             {
6371             expand_string_message =
6372               string_sprintf("non-digit after underscore in \"%s\"", name);
6373             goto EXPAND_FAILED;
6374             }
6375           else *pn = (*pn)*10 + *arg++ - '0';
6376           }
6377         value1 *= sign;
6378
6379         /* Perform the required operation */
6380
6381         ret =
6382           (c == EOP_HASH || c == EOP_H)?
6383              compute_hash(sub, value1, value2, &len) :
6384           (c == EOP_NHASH || c == EOP_NH)?
6385              compute_nhash(sub, value1, value2, &len) :
6386              extract_substr(sub, value1, value2, &len);
6387
6388         if (ret == NULL) goto EXPAND_FAILED;
6389         yield = string_cat(yield, &size, &ptr, ret, len);
6390         continue;
6391         }
6392
6393       /* Stat a path */
6394
6395       case EOP_STAT:
6396         {
6397         uschar *s;
6398         uschar smode[12];
6399         uschar **modetable[3];
6400         int i;
6401         mode_t mode;
6402         struct stat st;
6403
6404         if ((expand_forbid & RDO_EXISTS) != 0)
6405           {
6406           expand_string_message = US"Use of the stat() expansion is not permitted";
6407           goto EXPAND_FAILED;
6408           }
6409
6410         if (stat(CS sub, &st) < 0)
6411           {
6412           expand_string_message = string_sprintf("stat(%s) failed: %s",
6413             sub, strerror(errno));
6414           goto EXPAND_FAILED;
6415           }
6416         mode = st.st_mode;
6417         switch (mode & S_IFMT)
6418           {
6419           case S_IFIFO: smode[0] = 'p'; break;
6420           case S_IFCHR: smode[0] = 'c'; break;
6421           case S_IFDIR: smode[0] = 'd'; break;
6422           case S_IFBLK: smode[0] = 'b'; break;
6423           case S_IFREG: smode[0] = '-'; break;
6424           default: smode[0] = '?'; break;
6425           }
6426
6427         modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
6428         modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
6429         modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
6430
6431         for (i = 0; i < 3; i++)
6432           {
6433           memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
6434           mode >>= 3;
6435           }
6436
6437         smode[10] = 0;
6438         s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
6439           "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
6440           (long)(st.st_mode & 077777), smode, (long)st.st_ino,
6441           (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
6442           (long)st.st_gid, st.st_size, (long)st.st_atime,
6443           (long)st.st_mtime, (long)st.st_ctime);
6444         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6445         continue;
6446         }
6447
6448       /* vaguely random number less than N */
6449
6450       case EOP_RANDINT:
6451         {
6452         int_eximarith_t max;
6453         uschar *s;
6454
6455         max = expand_string_integer(sub, TRUE);
6456         if (expand_string_message != NULL)
6457           goto EXPAND_FAILED;
6458         s = string_sprintf("%d", vaguely_random_number((int)max));
6459         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6460         continue;
6461         }
6462
6463       /* Reverse IP, including IPv6 to dotted-nibble */
6464
6465       case EOP_REVERSE_IP:
6466         {
6467         int family, maskptr;
6468         uschar reversed[128];
6469
6470         family = string_is_ip_address(sub, &maskptr);
6471         if (family == 0)
6472           {
6473           expand_string_message = string_sprintf(
6474               "reverse_ip() not given an IP address [%s]", sub);
6475           goto EXPAND_FAILED;
6476           }
6477         invert_address(reversed, sub);
6478         yield = string_cat(yield, &size, &ptr, reversed, Ustrlen(reversed));
6479         continue;
6480         }
6481
6482       /* Unknown operator */
6483
6484       default:
6485       expand_string_message =
6486         string_sprintf("unknown expansion operator \"%s\"", name);
6487       goto EXPAND_FAILED;
6488       }
6489     }
6490
6491   /* Handle a plain name. If this is the first thing in the expansion, release
6492   the pre-allocated buffer. If the result data is known to be in a new buffer,
6493   newsize will be set to the size of that buffer, and we can just point at that
6494   store instead of copying. Many expansion strings contain just one reference,
6495   so this is a useful optimization, especially for humungous headers
6496   ($message_headers). */
6497                                                 /*{*/
6498   if (*s++ == '}')
6499     {
6500     int len;
6501     int newsize = 0;
6502     if (ptr == 0)
6503       {
6504       if (resetok) store_reset(yield);
6505       yield = NULL;
6506       size = 0;
6507       }
6508     value = find_variable(name, FALSE, skipping, &newsize);
6509     if (value == NULL)
6510       {
6511       expand_string_message =
6512         string_sprintf("unknown variable in \"${%s}\"", name);
6513       check_variable_error_message(name);
6514       goto EXPAND_FAILED;
6515       }
6516     len = Ustrlen(value);
6517     if (yield == NULL && newsize != 0)
6518       {
6519       yield = value;
6520       size = newsize;
6521       ptr = len;
6522       }
6523     else yield = string_cat(yield, &size, &ptr, value, len);
6524     continue;
6525     }
6526
6527   /* Else there's something wrong */
6528
6529   expand_string_message =
6530     string_sprintf("\"${%s\" is not a known operator (or a } is missing "
6531     "in a variable reference)", name);
6532   goto EXPAND_FAILED;
6533   }
6534
6535 /* If we hit the end of the string when ket_ends is set, there is a missing
6536 terminating brace. */
6537
6538 if (ket_ends && *s == 0)
6539   {
6540   expand_string_message = malformed_header?
6541     US"missing } at end of string - could be header name not terminated by colon"
6542     :
6543     US"missing } at end of string";
6544   goto EXPAND_FAILED;
6545   }
6546
6547 /* Expansion succeeded; yield may still be NULL here if nothing was actually
6548 added to the string. If so, set up an empty string. Add a terminating zero. If
6549 left != NULL, return a pointer to the terminator. */
6550
6551 if (yield == NULL) yield = store_get(1);
6552 yield[ptr] = 0;
6553 if (left != NULL) *left = s;
6554
6555 /* Any stacking store that was used above the final string is no longer needed.
6556 In many cases the final string will be the first one that was got and so there
6557 will be optimal store usage. */
6558
6559 if (resetok) store_reset(yield + ptr + 1);
6560 else if (resetok_p) *resetok_p = FALSE;
6561
6562 DEBUG(D_expand)
6563   {
6564   debug_printf("expanding: %.*s\n   result: %s\n", (int)(s - string), string,
6565     yield);
6566   if (skipping) debug_printf("skipping: result is not used\n");
6567   }
6568 return yield;
6569
6570 /* This is the failure exit: easiest to program with a goto. We still need
6571 to update the pointer to the terminator, for cases of nested calls with "fail".
6572 */
6573
6574 EXPAND_FAILED_CURLY:
6575 expand_string_message = malformed_header?
6576   US"missing or misplaced { or } - could be header name not terminated by colon"
6577   :
6578   US"missing or misplaced { or }";
6579
6580 /* At one point, Exim reset the store to yield (if yield was not NULL), but
6581 that is a bad idea, because expand_string_message is in dynamic store. */
6582
6583 EXPAND_FAILED:
6584 if (left != NULL) *left = s;
6585 DEBUG(D_expand)
6586   {
6587   debug_printf("failed to expand: %s\n", string);
6588   debug_printf("   error message: %s\n", expand_string_message);
6589   if (expand_string_forcedfail) debug_printf("failure was forced\n");
6590   }
6591 if (resetok_p) *resetok_p = resetok;
6592 return NULL;
6593 }
6594
6595
6596 /* This is the external function call. Do a quick check for any expansion
6597 metacharacters, and if there are none, just return the input string.
6598
6599 Argument: the string to be expanded
6600 Returns:  the expanded string, or NULL if expansion failed; if failure was
6601           due to a lookup deferring, search_find_defer will be TRUE
6602 */
6603
6604 uschar *
6605 expand_string(uschar *string)
6606 {
6607 search_find_defer = FALSE;
6608 malformed_header = FALSE;
6609 return (Ustrpbrk(string, "$\\") == NULL)? string :
6610   expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
6611 }
6612
6613
6614
6615 /*************************************************
6616 *              Expand and copy                   *
6617 *************************************************/
6618
6619 /* Now and again we want to expand a string and be sure that the result is in a
6620 new bit of store. This function does that.
6621
6622 Argument: the string to be expanded
6623 Returns:  the expanded string, always in a new bit of store, or NULL
6624 */
6625
6626 uschar *
6627 expand_string_copy(uschar *string)
6628 {
6629 uschar *yield = expand_string(string);
6630 if (yield == string) yield = string_copy(string);
6631 return yield;
6632 }
6633
6634
6635
6636 /*************************************************
6637 *        Expand and interpret as an integer      *
6638 *************************************************/
6639
6640 /* Expand a string, and convert the result into an integer.
6641
6642 Arguments:
6643   string  the string to be expanded
6644   isplus  TRUE if a non-negative number is expected
6645
6646 Returns:  the integer value, or
6647           -1 for an expansion error               ) in both cases, message in
6648           -2 for an integer interpretation error  ) expand_string_message
6649           expand_string_message is set NULL for an OK integer
6650 */
6651
6652 int_eximarith_t
6653 expand_string_integer(uschar *string, BOOL isplus)
6654 {
6655 int_eximarith_t value;
6656 uschar *s = expand_string(string);
6657 uschar *msg = US"invalid integer \"%s\"";
6658 uschar *endptr;
6659
6660 /* If expansion failed, expand_string_message will be set. */
6661
6662 if (s == NULL) return -1;
6663
6664 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
6665 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
6666 systems, so we set it zero ourselves. */
6667
6668 errno = 0;
6669 expand_string_message = NULL;               /* Indicates no error */
6670
6671 /* Before Exim 4.64, strings consisting entirely of whitespace compared
6672 equal to 0.  Unfortunately, people actually relied upon that, so preserve
6673 the behaviour explicitly.  Stripping leading whitespace is a harmless
6674 noop change since strtol skips it anyway (provided that there is a number
6675 to find at all). */
6676 if (isspace(*s))
6677   {
6678   while (isspace(*s)) ++s;
6679   if (*s == '\0')
6680     {
6681       DEBUG(D_expand)
6682        debug_printf("treating blank string as number 0\n");
6683       return 0;
6684     }
6685   }
6686
6687 value = strtoll(CS s, CSS &endptr, 10);
6688
6689 if (endptr == s)
6690   {
6691   msg = US"integer expected but \"%s\" found";
6692   }
6693 else if (value < 0 && isplus)
6694   {
6695   msg = US"non-negative integer expected but \"%s\" found";
6696   }
6697 else
6698   {
6699   switch (tolower(*endptr))
6700     {
6701     default:
6702       break;
6703     case 'k':
6704       if (value > EXIM_ARITH_MAX/1024 || value < EXIM_ARITH_MIN/1024) errno = ERANGE;
6705       else value *= 1024;
6706       endptr++;
6707       break;
6708     case 'm':
6709       if (value > EXIM_ARITH_MAX/(1024*1024) || value < EXIM_ARITH_MIN/(1024*1024)) errno = ERANGE;
6710       else value *= 1024*1024;
6711       endptr++;
6712       break;
6713     case 'g':
6714       if (value > EXIM_ARITH_MAX/(1024*1024*1024) || value < EXIM_ARITH_MIN/(1024*1024*1024)) errno = ERANGE;
6715       else value *= 1024*1024*1024;
6716       endptr++;
6717       break;
6718     }
6719   if (errno == ERANGE)
6720     msg = US"absolute value of integer \"%s\" is too large (overflow)";
6721   else
6722     {
6723     while (isspace(*endptr)) endptr++;
6724     if (*endptr == 0) return value;
6725     }
6726   }
6727
6728 expand_string_message = string_sprintf(CS msg, s);
6729 return -2;
6730 }
6731
6732
6733 /*************************************************
6734 **************************************************
6735 *             Stand-alone test program           *
6736 **************************************************
6737 *************************************************/
6738
6739 #ifdef STAND_ALONE
6740
6741
6742 BOOL
6743 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
6744 {
6745 int ovector[3*(EXPAND_MAXN+1)];
6746 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
6747   ovector, sizeof(ovector)/sizeof(int));
6748 BOOL yield = n >= 0;
6749 if (n == 0) n = EXPAND_MAXN + 1;
6750 if (yield)
6751   {
6752   int nn;
6753   expand_nmax = (setup < 0)? 0 : setup + 1;
6754   for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
6755     {
6756     expand_nstring[expand_nmax] = subject + ovector[nn];
6757     expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
6758     }
6759   expand_nmax--;
6760   }
6761 return yield;
6762 }
6763
6764
6765 int main(int argc, uschar **argv)
6766 {
6767 int i;
6768 uschar buffer[1024];
6769
6770 debug_selector = D_v;
6771 debug_file = stderr;
6772 debug_fd = fileno(debug_file);
6773 big_buffer = malloc(big_buffer_size);
6774
6775 for (i = 1; i < argc; i++)
6776   {
6777   if (argv[i][0] == '+')
6778     {
6779     debug_trace_memory = 2;
6780     argv[i]++;
6781     }
6782   if (isdigit(argv[i][0]))
6783     debug_selector = Ustrtol(argv[i], NULL, 0);
6784   else
6785     if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
6786         Ustrlen(argv[i]))
6787       {
6788       #ifdef LOOKUP_LDAP
6789       eldap_default_servers = argv[i];
6790       #endif
6791       #ifdef LOOKUP_MYSQL
6792       mysql_servers = argv[i];
6793       #endif
6794       #ifdef LOOKUP_PGSQL
6795       pgsql_servers = argv[i];
6796       #endif
6797       #ifdef EXPERIMENTAL_REDIS
6798       redis_servers = argv[i];
6799       #endif
6800       }
6801   #ifdef EXIM_PERL
6802   else opt_perl_startup = argv[i];
6803   #endif
6804   }
6805
6806 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
6807
6808 expand_nstring[1] = US"string 1....";
6809 expand_nlength[1] = 8;
6810 expand_nmax = 1;
6811
6812 #ifdef EXIM_PERL
6813 if (opt_perl_startup != NULL)
6814   {
6815   uschar *errstr;
6816   printf("Starting Perl interpreter\n");
6817   errstr = init_perl(opt_perl_startup);
6818   if (errstr != NULL)
6819     {
6820     printf("** error in perl_startup code: %s\n", errstr);
6821     return EXIT_FAILURE;
6822     }
6823   }
6824 #endif /* EXIM_PERL */
6825
6826 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
6827   {
6828   void *reset_point = store_get(0);
6829   uschar *yield = expand_string(buffer);
6830   if (yield != NULL)
6831     {
6832     printf("%s\n", yield);
6833     store_reset(reset_point);
6834     }
6835   else
6836     {
6837     if (search_find_defer) printf("search_find deferred\n");
6838     printf("Failed: %s\n", expand_string_message);
6839     if (expand_string_forcedfail) printf("Forced failure\n");
6840     printf("\n");
6841     }
6842   }
6843
6844 search_tidyup();
6845
6846 return 0;
6847 }
6848
6849 #endif
6850
6851 /*
6852  vi: aw ai sw=2
6853 */
6854 /* End of expand.c */