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