src/src/expand.c

   1 /* $Cambridge: exim/src/src/expand.c,v 1.26 2005/06/16 14:10:13 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2005 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10
  11 /* Functions for handling string expansion. */
  12
  13
  14 #include "exim.h"
  15
  16 #ifdef STAND_ALONE
  17 #ifndef SUPPORT_CRYPTEQ
  18 #define SUPPORT_CRYPTEQ
  19 #endif
  20 #endif
  21
  22 #ifdef SUPPORT_CRYPTEQ
  23 #ifdef CRYPT_H
  24 #include <crypt.h>
  25 #endif
  26 #ifndef HAVE_CRYPT16
  27 extern char* crypt16(char*, char*);
  28 #endif
  29 #endif
  30
  31 #ifdef LOOKUP_LDAP
  32 #include "lookups/ldap.h"
  33 #endif
  34
  35
  36
  37 /* Recursively called function */
  38
  39 static uschar *expand_string_internal(uschar *, BOOL, uschar **, BOOL);
  40
  41
  42
  43 /*************************************************
  44 *            Local statics and tables            *
  45 *************************************************/
  46
  47 /* Table of item names, and corresponding switch numbers. The names must be in
  48 alphabetical order. */
  49
  50 static uschar *item_table[] = {
  51   US"dlfunc",
  52   US"extract",
  53   US"hash",
  54   US"hmac",
  55   US"if",
  56   US"length",
  57   US"lookup",
  58   US"nhash",
  59   US"perl",
  60   US"readfile",
  61   US"readsocket",
  62   US"run",
  63   US"sg",
  64   US"substr",
  65   US"tr" };
  66
  67 enum {
  68   EITEM_DLFUNC,
  69   EITEM_EXTRACT,
  70   EITEM_HASH,
  71   EITEM_HMAC,
  72   EITEM_IF,
  73   EITEM_LENGTH,
  74   EITEM_LOOKUP,
  75   EITEM_NHASH,
  76   EITEM_PERL,
  77   EITEM_READFILE,
  78   EITEM_READSOCK,
  79   EITEM_RUN,
  80   EITEM_SG,
  81   EITEM_SUBSTR,
  82   EITEM_TR };
  83
  84 /* Tables of operator names, and corresponding switch numbers. The names must be
  85 in alphabetical order. There are two tables, because underscore is used in some
  86 cases to introduce arguments, whereas for other it is part of the name. This is
  87 an historical mis-design. */
  88
  89 static uschar *op_table_underscore[] = {
  90   US"from_utf8",
  91   US"local_part",
  92   US"quote_local_part",
  93   US"time_interval"};
  94
  95 enum {
  96   EOP_FROM_UTF8,
  97   EOP_LOCAL_PART,
  98   EOP_QUOTE_LOCAL_PART,
  99   EOP_TIME_INTERVAL };
 100
 101 static uschar *op_table_main[] = {
 102   US"address",
 103   US"base62",
 104   US"base62d",
 105   US"domain",
 106   US"escape",
 107   US"eval",
 108   US"eval10",
 109   US"expand",
 110   US"h",
 111   US"hash",
 112   US"hex2b64",
 113   US"l",
 114   US"lc",
 115   US"length",
 116   US"mask",
 117   US"md5",
 118   US"nh",
 119   US"nhash",
 120   US"quote",
 121   US"rfc2047",
 122   US"rxquote",
 123   US"s",
 124   US"sha1",
 125   US"stat",
 126   US"str2b64",
 127   US"strlen",
 128   US"substr",
 129   US"uc" };
 130
 131 enum {
 132   EOP_ADDRESS =  sizeof(op_table_underscore)/sizeof(uschar *),
 133   EOP_BASE62,
 134   EOP_BASE62D,
 135   EOP_DOMAIN,
 136   EOP_ESCAPE,
 137   EOP_EVAL,
 138   EOP_EVAL10,
 139   EOP_EXPAND,
 140   EOP_H,
 141   EOP_HASH,
 142   EOP_HEX2B64,
 143   EOP_L,
 144   EOP_LC,
 145   EOP_LENGTH,
 146   EOP_MASK,
 147   EOP_MD5,
 148   EOP_NH,
 149   EOP_NHASH,
 150   EOP_QUOTE,
 151   EOP_RFC2047,
 152   EOP_RXQUOTE,
 153   EOP_S,
 154   EOP_SHA1,
 155   EOP_STAT,
 156   EOP_STR2B64,
 157   EOP_STRLEN,
 158   EOP_SUBSTR,
 159   EOP_UC };
 160
 161
 162 /* Table of condition names, and corresponding switch numbers. The names must
 163 be in alphabetical order. */
 164
 165 static uschar *cond_table[] = {
 166   US"<",
 167   US"<=",
 168   US"=",
 169   US"==",     /* Backward compatibility */
 170   US">",
 171   US">=",
 172   US"and",
 173   US"crypteq",
 174   US"def",
 175   US"eq",
 176   US"eqi",
 177   US"exists",
 178   US"first_delivery",
 179   US"ge",
 180   US"gei",
 181   US"gt",
 182   US"gti",
 183   US"isip",
 184   US"isip4",
 185   US"isip6",
 186   US"ldapauth",
 187   US"le",
 188   US"lei",
 189   US"lt",
 190   US"lti",
 191   US"match",
 192   US"match_address",
 193   US"match_domain",
 194   US"match_local_part",
 195   US"or",
 196   US"pam",
 197   US"pwcheck",
 198   US"queue_running",
 199   US"radius",
 200   US"saslauthd"
 201 };
 202
 203 enum {
 204   ECOND_NUM_L,
 205   ECOND_NUM_LE,
 206   ECOND_NUM_E,
 207   ECOND_NUM_EE,
 208   ECOND_NUM_G,
 209   ECOND_NUM_GE,
 210   ECOND_AND,
 211   ECOND_CRYPTEQ,
 212   ECOND_DEF,
 213   ECOND_STR_EQ,
 214   ECOND_STR_EQI,
 215   ECOND_EXISTS,
 216   ECOND_FIRST_DELIVERY,
 217   ECOND_STR_GE,
 218   ECOND_STR_GEI,
 219   ECOND_STR_GT,
 220   ECOND_STR_GTI,
 221   ECOND_ISIP,
 222   ECOND_ISIP4,
 223   ECOND_ISIP6,
 224   ECOND_LDAPAUTH,
 225   ECOND_STR_LE,
 226   ECOND_STR_LEI,
 227   ECOND_STR_LT,
 228   ECOND_STR_LTI,
 229   ECOND_MATCH,
 230   ECOND_MATCH_ADDRESS,
 231   ECOND_MATCH_DOMAIN,
 232   ECOND_MATCH_LOCAL_PART,
 233   ECOND_OR,
 234   ECOND_PAM,
 235   ECOND_PWCHECK,
 236   ECOND_QUEUE_RUNNING,
 237   ECOND_RADIUS,
 238   ECOND_SASLAUTHD
 239 };
 240
 241
 242 /* Type for main variable table */
 243
 244 typedef struct {
 245   char *name;
 246   int   type;
 247   void *value;
 248 } var_entry;
 249
 250 /* Type for entries pointing to address/length pairs. Not currently
 251 in use. */
 252
 253 typedef struct {
 254   uschar **address;
 255   int  *length;
 256 } alblock;
 257
 258 /* Types of table entry */
 259
 260 enum {
 261   vtype_int,            /* value is address of int */
 262   vtype_filter_int,     /* ditto, but recognized only when filtering */
 263   vtype_ino,            /* value is address of ino_t (not always an int) */
 264   vtype_uid,            /* value is address of uid_t (not always an int) */
 265   vtype_gid,            /* value is address of gid_t (not always an int) */
 266   vtype_stringptr,      /* value is address of pointer to string */
 267   vtype_msgbody,        /* as stringptr, but read when first required */
 268   vtype_msgbody_end,    /* ditto, the end of the message */
 269   vtype_msgheaders,     /* the message's headers */
 270   vtype_localpart,      /* extract local part from string */
 271   vtype_domain,         /* extract domain from string */
 272   vtype_recipients,     /* extract recipients from recipients list */
 273                         /* (enabled only during system filtering */
 274   vtype_todbsdin,       /* value not used; generate BSD inbox tod */
 275   vtype_tode,           /* value not used; generate tod in epoch format */
 276   vtype_todf,           /* value not used; generate full tod */
 277   vtype_todl,           /* value not used; generate log tod */
 278   vtype_todlf,          /* value not used; generate log file datestamp tod */
 279   vtype_todzone,        /* value not used; generate time zone only */
 280   vtype_todzulu,        /* value not used; generate zulu tod */
 281   vtype_reply,          /* value not used; get reply from headers */
 282   vtype_pid,            /* value not used; result is pid */
 283   vtype_host_lookup,    /* value not used; get host name */
 284   vtype_load_avg,       /* value not used; result is int from os_getloadavg */
 285   vtype_pspace,         /* partition space; value is T/F for spool/log */
 286   vtype_pinodes         /* partition inodes; value is T/F for spool/log */
 287 #ifdef EXPERIMENTAL_DOMAINKEYS
 288  ,vtype_dk_verify       /* Serve request out of DomainKeys verification structure */
 289 #endif
 290   };
 291
 292 /* This table must be kept in alphabetical order. */
 293
 294 static var_entry var_table[] = {
 295   { "acl_c0",              vtype_stringptr,   &acl_var[0] },
 296   { "acl_c1",              vtype_stringptr,   &acl_var[1] },
 297   { "acl_c2",              vtype_stringptr,   &acl_var[2] },
 298   { "acl_c3",              vtype_stringptr,   &acl_var[3] },
 299   { "acl_c4",              vtype_stringptr,   &acl_var[4] },
 300   { "acl_c5",              vtype_stringptr,   &acl_var[5] },
 301   { "acl_c6",              vtype_stringptr,   &acl_var[6] },
 302   { "acl_c7",              vtype_stringptr,   &acl_var[7] },
 303   { "acl_c8",              vtype_stringptr,   &acl_var[8] },
 304   { "acl_c9",              vtype_stringptr,   &acl_var[9] },
 305   { "acl_m0",              vtype_stringptr,   &acl_var[10] },
 306   { "acl_m1",              vtype_stringptr,   &acl_var[11] },
 307   { "acl_m2",              vtype_stringptr,   &acl_var[12] },
 308   { "acl_m3",              vtype_stringptr,   &acl_var[13] },
 309   { "acl_m4",              vtype_stringptr,   &acl_var[14] },
 310   { "acl_m5",              vtype_stringptr,   &acl_var[15] },
 311   { "acl_m6",              vtype_stringptr,   &acl_var[16] },
 312   { "acl_m7",              vtype_stringptr,   &acl_var[17] },
 313   { "acl_m8",              vtype_stringptr,   &acl_var[18] },
 314   { "acl_m9",              vtype_stringptr,   &acl_var[19] },
 315   { "acl_verify_message",  vtype_stringptr,   &acl_verify_message },
 316   { "address_data",        vtype_stringptr,   &deliver_address_data },
 317   { "address_file",        vtype_stringptr,   &address_file },
 318   { "address_pipe",        vtype_stringptr,   &address_pipe },
 319   { "authenticated_id",    vtype_stringptr,   &authenticated_id },
 320   { "authenticated_sender",vtype_stringptr,   &authenticated_sender },
 321   { "authentication_failed",vtype_int,        &authentication_failed },
 322 #ifdef EXPERIMENTAL_BRIGHTMAIL
 323   { "bmi_alt_location",    vtype_stringptr,   &bmi_alt_location },
 324   { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
 325   { "bmi_base64_verdict",  vtype_stringptr,   &bmi_base64_verdict },
 326   { "bmi_deliver",         vtype_int,         &bmi_deliver },
 327 #endif
 328   { "body_linecount",      vtype_int,         &body_linecount },
 329   { "body_zerocount",      vtype_int,         &body_zerocount },
 330   { "bounce_recipient",    vtype_stringptr,   &bounce_recipient },
 331   { "bounce_return_size_limit", vtype_int,    &bounce_return_size_limit },
 332   { "caller_gid",          vtype_gid,         &real_gid },
 333   { "caller_uid",          vtype_uid,         &real_uid },
 334   { "compile_date",        vtype_stringptr,   &version_date },
 335   { "compile_number",      vtype_stringptr,   &version_cnumber },
 336   { "csa_status",          vtype_stringptr,   &csa_status },
 337 #ifdef WITH_OLD_DEMIME
 338   { "demime_errorlevel",   vtype_int,         &demime_errorlevel },
 339   { "demime_reason",       vtype_stringptr,   &demime_reason },
 340 #endif
 341 #ifdef EXPERIMENTAL_DOMAINKEYS
 342   { "dk_domain",           vtype_stringptr,   &dk_signing_domain },
 343   { "dk_is_signed",        vtype_dk_verify,   NULL },
 344   { "dk_result",           vtype_dk_verify,   NULL },
 345   { "dk_selector",         vtype_stringptr,   &dk_signing_selector },
 346   { "dk_sender",           vtype_dk_verify,   NULL },
 347   { "dk_sender_domain",    vtype_dk_verify,   NULL },
 348   { "dk_sender_local_part",vtype_dk_verify,   NULL },
 349   { "dk_sender_source",    vtype_dk_verify,   NULL },
 350   { "dk_signsall",         vtype_dk_verify,   NULL },
 351   { "dk_status",           vtype_dk_verify,   NULL },
 352   { "dk_testing",          vtype_dk_verify,   NULL },
 353 #endif
 354   { "dnslist_domain",      vtype_stringptr,   &dnslist_domain },
 355   { "dnslist_text",        vtype_stringptr,   &dnslist_text },
 356   { "dnslist_value",       vtype_stringptr,   &dnslist_value },
 357   { "domain",              vtype_stringptr,   &deliver_domain },
 358   { "domain_data",         vtype_stringptr,   &deliver_domain_data },
 359   { "exim_gid",            vtype_gid,         &exim_gid },
 360   { "exim_path",           vtype_stringptr,   &exim_path },
 361   { "exim_uid",            vtype_uid,         &exim_uid },
 362 #ifdef WITH_OLD_DEMIME
 363   { "found_extension",     vtype_stringptr,   &found_extension },
 364 #endif
 365   { "home",                vtype_stringptr,   &deliver_home },
 366   { "host",                vtype_stringptr,   &deliver_host },
 367   { "host_address",        vtype_stringptr,   &deliver_host_address },
 368   { "host_data",           vtype_stringptr,   &host_data },
 369   { "host_lookup_deferred",vtype_int,         &host_lookup_deferred },
 370   { "host_lookup_failed",  vtype_int,         &host_lookup_failed },
 371   { "inode",               vtype_ino,         &deliver_inode },
 372   { "interface_address",   vtype_stringptr,   &interface_address },
 373   { "interface_port",      vtype_int,         &interface_port },
 374   #ifdef LOOKUP_LDAP
 375   { "ldap_dn",             vtype_stringptr,   &eldap_dn },
 376   #endif
 377   { "load_average",        vtype_load_avg,    NULL },
 378   { "local_part",          vtype_stringptr,   &deliver_localpart },
 379   { "local_part_data",     vtype_stringptr,   &deliver_localpart_data },
 380   { "local_part_prefix",   vtype_stringptr,   &deliver_localpart_prefix },
 381   { "local_part_suffix",   vtype_stringptr,   &deliver_localpart_suffix },
 382   { "local_scan_data",     vtype_stringptr,   &local_scan_data },
 383   { "local_user_gid",      vtype_gid,         &local_user_gid },
 384   { "local_user_uid",      vtype_uid,         &local_user_uid },
 385   { "localhost_number",    vtype_int,         &host_number },
 386   { "log_inodes",          vtype_pinodes,     (void *)FALSE },
 387   { "log_space",           vtype_pspace,      (void *)FALSE },
 388   { "mailstore_basename",  vtype_stringptr,   &mailstore_basename },
 389 #ifdef WITH_CONTENT_SCAN
 390   { "malware_name",        vtype_stringptr,   &malware_name },
 391 #endif
 392   { "message_age",         vtype_int,         &message_age },
 393   { "message_body",        vtype_msgbody,     &message_body },
 394   { "message_body_end",    vtype_msgbody_end, &message_body_end },
 395   { "message_body_size",   vtype_int,         &message_body_size },
 396   { "message_headers",     vtype_msgheaders,  NULL },
 397   { "message_id",          vtype_stringptr,   &message_id },
 398   { "message_linecount",   vtype_int,         &message_linecount },
 399   { "message_size",        vtype_int,         &message_size },
 400 #ifdef WITH_CONTENT_SCAN
 401   { "mime_anomaly_level",  vtype_int,         &mime_anomaly_level },
 402   { "mime_anomaly_text",   vtype_stringptr,   &mime_anomaly_text },
 403   { "mime_boundary",       vtype_stringptr,   &mime_boundary },
 404   { "mime_charset",        vtype_stringptr,   &mime_charset },
 405   { "mime_content_description", vtype_stringptr, &mime_content_description },
 406   { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
 407   { "mime_content_id",     vtype_stringptr,   &mime_content_id },
 408   { "mime_content_size",   vtype_int,         &mime_content_size },
 409   { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
 410   { "mime_content_type",   vtype_stringptr,   &mime_content_type },
 411   { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
 412   { "mime_filename",       vtype_stringptr,   &mime_filename },
 413   { "mime_is_coverletter", vtype_int,         &mime_is_coverletter },
 414   { "mime_is_multipart",   vtype_int,         &mime_is_multipart },
 415   { "mime_is_rfc822",      vtype_int,         &mime_is_rfc822 },
 416   { "mime_part_count",     vtype_int,         &mime_part_count },
 417 #endif
 418   { "n0",                  vtype_filter_int,  &filter_n[0] },
 419   { "n1",                  vtype_filter_int,  &filter_n[1] },
 420   { "n2",                  vtype_filter_int,  &filter_n[2] },
 421   { "n3",                  vtype_filter_int,  &filter_n[3] },
 422   { "n4",                  vtype_filter_int,  &filter_n[4] },
 423   { "n5",                  vtype_filter_int,  &filter_n[5] },
 424   { "n6",                  vtype_filter_int,  &filter_n[6] },
 425   { "n7",                  vtype_filter_int,  &filter_n[7] },
 426   { "n8",                  vtype_filter_int,  &filter_n[8] },
 427   { "n9",                  vtype_filter_int,  &filter_n[9] },
 428   { "original_domain",     vtype_stringptr,   &deliver_domain_orig },
 429   { "original_local_part", vtype_stringptr,   &deliver_localpart_orig },
 430   { "originator_gid",      vtype_gid,         &originator_gid },
 431   { "originator_uid",      vtype_uid,         &originator_uid },
 432   { "parent_domain",       vtype_stringptr,   &deliver_domain_parent },
 433   { "parent_local_part",   vtype_stringptr,   &deliver_localpart_parent },
 434   { "pid",                 vtype_pid,         NULL },
 435   { "primary_hostname",    vtype_stringptr,   &primary_hostname },
 436   { "qualify_domain",      vtype_stringptr,   &qualify_domain_sender },
 437   { "qualify_recipient",   vtype_stringptr,   &qualify_domain_recipient },
 438   { "rcpt_count",          vtype_int,         &rcpt_count },
 439   { "rcpt_defer_count",    vtype_int,         &rcpt_defer_count },
 440   { "rcpt_fail_count",     vtype_int,         &rcpt_fail_count },
 441   { "received_count",      vtype_int,         &received_count },
 442   { "received_for",        vtype_stringptr,   &received_for },
 443   { "received_protocol",   vtype_stringptr,   &received_protocol },
 444   { "received_time",       vtype_int,         &received_time },
 445   { "recipient_data",      vtype_stringptr,   &recipient_data },
 446   { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
 447   { "recipients",          vtype_recipients,  NULL },
 448   { "recipients_count",    vtype_int,         &recipients_count },
 449 #ifdef WITH_CONTENT_SCAN
 450   { "regex_match_string",  vtype_stringptr,   &regex_match_string },
 451 #endif
 452   { "reply_address",       vtype_reply,       NULL },
 453   { "return_path",         vtype_stringptr,   &return_path },
 454   { "return_size_limit",   vtype_int,         &bounce_return_size_limit },
 455   { "runrc",               vtype_int,         &runrc },
 456   { "self_hostname",       vtype_stringptr,   &self_hostname },
 457   { "sender_address",      vtype_stringptr,   &sender_address },
 458   { "sender_address_data", vtype_stringptr,   &sender_address_data },
 459   { "sender_address_domain", vtype_domain,    &sender_address },
 460   { "sender_address_local_part", vtype_localpart, &sender_address },
 461   { "sender_data",         vtype_stringptr,   &sender_data },
 462   { "sender_fullhost",     vtype_stringptr,   &sender_fullhost },
 463   { "sender_helo_name",    vtype_stringptr,   &sender_helo_name },
 464   { "sender_host_address", vtype_stringptr,   &sender_host_address },
 465   { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
 466   { "sender_host_name",    vtype_host_lookup, NULL },
 467   { "sender_host_port",    vtype_int,         &sender_host_port },
 468   { "sender_ident",        vtype_stringptr,   &sender_ident },
 469   { "sender_rate",         vtype_stringptr,   &sender_rate },
 470   { "sender_rate_limit",   vtype_stringptr,   &sender_rate_limit },
 471   { "sender_rate_period",  vtype_stringptr,   &sender_rate_period },
 472   { "sender_rcvhost",      vtype_stringptr,   &sender_rcvhost },
 473   { "sender_verify_failure",vtype_stringptr,  &sender_verify_failure },
 474   { "smtp_active_hostname", vtype_stringptr,  &smtp_active_hostname },
 475   { "smtp_command_argument", vtype_stringptr, &smtp_command_argument },
 476   { "sn0",                 vtype_filter_int,  &filter_sn[0] },
 477   { "sn1",                 vtype_filter_int,  &filter_sn[1] },
 478   { "sn2",                 vtype_filter_int,  &filter_sn[2] },
 479   { "sn3",                 vtype_filter_int,  &filter_sn[3] },
 480   { "sn4",                 vtype_filter_int,  &filter_sn[4] },
 481   { "sn5",                 vtype_filter_int,  &filter_sn[5] },
 482   { "sn6",                 vtype_filter_int,  &filter_sn[6] },
 483   { "sn7",                 vtype_filter_int,  &filter_sn[7] },
 484   { "sn8",                 vtype_filter_int,  &filter_sn[8] },
 485   { "sn9",                 vtype_filter_int,  &filter_sn[9] },
 486 #ifdef WITH_CONTENT_SCAN
 487   { "spam_bar",            vtype_stringptr,   &spam_bar },
 488   { "spam_report",         vtype_stringptr,   &spam_report },
 489   { "spam_score",          vtype_stringptr,   &spam_score },
 490   { "spam_score_int",      vtype_stringptr,   &spam_score_int },
 491 #endif
 492 #ifdef EXPERIMENTAL_SPF
 493   { "spf_header_comment",  vtype_stringptr,   &spf_header_comment },
 494   { "spf_received",        vtype_stringptr,   &spf_received },
 495   { "spf_result",          vtype_stringptr,   &spf_result },
 496   { "spf_smtp_comment",    vtype_stringptr,   &spf_smtp_comment },
 497 #endif
 498   { "spool_directory",     vtype_stringptr,   &spool_directory },
 499   { "spool_inodes",        vtype_pinodes,     (void *)TRUE },
 500   { "spool_space",         vtype_pspace,      (void *)TRUE },
 501 #ifdef EXPERIMENTAL_SRS
 502   { "srs_db_address",      vtype_stringptr,   &srs_db_address },
 503   { "srs_db_key",          vtype_stringptr,   &srs_db_key },
 504   { "srs_orig_recipient",  vtype_stringptr,   &srs_orig_recipient },
 505   { "srs_orig_sender",     vtype_stringptr,   &srs_orig_sender },
 506   { "srs_recipient",       vtype_stringptr,   &srs_recipient },
 507   { "srs_status",          vtype_stringptr,   &srs_status },
 508 #endif
 509   { "thisaddress",         vtype_stringptr,   &filter_thisaddress },
 510   { "tls_certificate_verified", vtype_int,    &tls_certificate_verified },
 511   { "tls_cipher",          vtype_stringptr,   &tls_cipher },
 512   { "tls_peerdn",          vtype_stringptr,   &tls_peerdn },
 513   { "tod_bsdinbox",        vtype_todbsdin,    NULL },
 514   { "tod_epoch",           vtype_tode,        NULL },
 515   { "tod_full",            vtype_todf,        NULL },
 516   { "tod_log",             vtype_todl,        NULL },
 517   { "tod_logfile",         vtype_todlf,       NULL },
 518   { "tod_zone",            vtype_todzone,     NULL },
 519   { "tod_zulu",            vtype_todzulu,     NULL },
 520   { "value",               vtype_stringptr,   &lookup_value },
 521   { "version_number",      vtype_stringptr,   &version_string },
 522   { "warn_message_delay",  vtype_stringptr,   &warnmsg_delay },
 523   { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
 524   { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
 525   { "warnmsg_delay",       vtype_stringptr,   &warnmsg_delay },
 526   { "warnmsg_recipient",   vtype_stringptr,   &warnmsg_recipients },
 527   { "warnmsg_recipients",  vtype_stringptr,   &warnmsg_recipients }
 528 };
 529
 530 static int var_table_size = sizeof(var_table)/sizeof(var_entry);
 531 static uschar var_buffer[256];
 532 static BOOL malformed_header;
 533
 534 /* For textual hashes */
 535
 536 static char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
 537                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 538                          "0123456789";
 539
 540 enum { HMAC_MD5, HMAC_SHA1 };
 541
 542 /* For numeric hashes */
 543
 544 static unsigned int prime[] = {
 545   2,   3,   5,   7,  11,  13,  17,  19,  23,  29,
 546  31,  37,  41,  43,  47,  53,  59,  61,  67,  71,
 547  73,  79,  83,  89,  97, 101, 103, 107, 109, 113};
 548
 549 /* For printing modes in symbolic form */
 550
 551 static uschar *mtable_normal[] =
 552   { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
 553
 554 static uschar *mtable_setid[] =
 555   { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
 556
 557 static uschar *mtable_sticky[] =
 558   { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
 559
 560
 561
 562 /*************************************************
 563 *           Tables for UTF-8 support             *
 564 *************************************************/
 565
 566 /* Table of the number of extra characters, indexed by the first character
 567 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
 568 0x3d. */
 569
 570 static uschar utf8_table1[] = {
 571   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 572   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 573   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 574   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
 575
 576 /* These are the masks for the data bits in the first byte of a character,
 577 indexed by the number of additional bytes. */
 578
 579 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
 580
 581 /* Get the next UTF-8 character, advancing the pointer. */
 582
 583 #define GETUTF8INC(c, ptr) \
 584   c = *ptr++; \
 585   if ((c & 0xc0) == 0xc0) \
 586     { \
 587     int a = utf8_table1[c & 0x3f];  /* Number of additional bytes */ \
 588     int s = 6*a; \
 589     c = (c & utf8_table2[a]) << s; \
 590     while (a-- > 0) \
 591       { \
 592       s -= 6; \
 593       c |= (*ptr++ & 0x3f) << s; \
 594       } \
 595     }
 596
 597
 598 /*************************************************
 599 *           Binary chop search on a table        *
 600 *************************************************/
 601
 602 /* This is used for matching expansion items and operators.
 603
 604 Arguments:
 605   name        the name that is being sought
 606   table       the table to search
 607   table_size  the number of items in the table
 608
 609 Returns:      the offset in the table, or -1
 610 */
 611
 612 static int
 613 chop_match(uschar *name, uschar **table, int table_size)
 614 {
 615 uschar **bot = table;
 616 uschar **top = table + table_size;
 617
 618 while (top > bot)
 619   {
 620   uschar **mid = bot + (top - bot)/2;
 621   int c = Ustrcmp(name, *mid);
 622   if (c == 0) return mid - table;
 623   if (c > 0) bot = mid + 1; else top = mid;
 624   }
 625
 626 return -1;
 627 }
 628
 629
 630
 631 /*************************************************
 632 *          Check a condition string              *
 633 *************************************************/
 634
 635 /* This function is called to expand a string, and test the result for a "true"
 636 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
 637 forced fail or lookup defer. All store used by the function can be released on
 638 exit.
 639
 640 Arguments:
 641   condition     the condition string
 642   m1            text to be incorporated in panic error
 643   m2            ditto
 644
 645 Returns:        TRUE if condition is met, FALSE if not
 646 */
 647
 648 BOOL
 649 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
 650 {
 651 int rc;
 652 void *reset_point = store_get(0);
 653 uschar *ss = expand_string(condition);
 654 if (ss == NULL)
 655   {
 656   if (!expand_string_forcedfail && !search_find_defer)
 657     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
 658       "for %s %s: %s", condition, m1, m2, expand_string_message);
 659   return FALSE;
 660   }
 661 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
 662   strcmpic(ss, US"false") != 0;
 663 store_reset(reset_point);
 664 return rc;
 665 }
 666
 667
 668
 669 /*************************************************
 670 *             Pick out a name from a string      *
 671 *************************************************/
 672
 673 /* If the name is too long, it is silently truncated.
 674
 675 Arguments:
 676   name      points to a buffer into which to put the name
 677   max       is the length of the buffer
 678   s         points to the first alphabetic character of the name
 679   extras    chars other than alphanumerics to permit
 680
 681 Returns:    pointer to the first character after the name
 682
 683 Note: The test for *s != 0 in the while loop is necessary because
 684 Ustrchr() yields non-NULL if the character is zero (which is not something
 685 I expected). */
 686
 687 static uschar *
 688 read_name(uschar *name, int max, uschar *s, uschar *extras)
 689 {
 690 int ptr = 0;
 691 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
 692   {
 693   if (ptr < max-1) name[ptr++] = *s;
 694   s++;
 695   }
 696 name[ptr] = 0;
 697 return s;
 698 }
 699
 700
 701
 702 /*************************************************
 703 *     Pick out the rest of a header name         *
 704 *************************************************/
 705
 706 /* A variable name starting $header_ (or just $h_ for those who like
 707 abbreviations) might not be the complete header name because headers can
 708 contain any printing characters in their names, except ':'. This function is
 709 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
 710 on the end, if the name was terminated by white space.
 711
 712 Arguments:
 713   name      points to a buffer in which the name read so far exists
 714   max       is the length of the buffer
 715   s         points to the first character after the name so far, i.e. the
 716             first non-alphameric character after $header_xxxxx
 717
 718 Returns:    a pointer to the first character after the header name
 719 */
 720
 721 static uschar *
 722 read_header_name(uschar *name, int max, uschar *s)
 723 {
 724 int prelen = Ustrchr(name, '_') - name + 1;
 725 int ptr = Ustrlen(name) - prelen;
 726 if (ptr > 0) memmove(name, name+prelen, ptr);
 727 while (mac_isgraph(*s) && *s != ':')
 728   {
 729   if (ptr < max-1) name[ptr++] = *s;
 730   s++;
 731   }
 732 if (*s == ':') s++;
 733 name[ptr++] = ':';
 734 name[ptr] = 0;
 735 return s;
 736 }
 737
 738
 739
 740 /*************************************************
 741 *           Pick out a number from a string      *
 742 *************************************************/
 743
 744 /* Arguments:
 745   n     points to an integer into which to put the number
 746   s     points to the first digit of the number
 747
 748 Returns:  a pointer to the character after the last digit
 749 */
 750
 751 static uschar *
 752 read_number(int *n, uschar *s)
 753 {
 754 *n = 0;
 755 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
 756 return s;
 757 }
 758
 759
 760
 761 /*************************************************
 762 *        Extract keyed subfield from a string    *
 763 *************************************************/
 764
 765 /* The yield is in dynamic store; NULL means that the key was not found.
 766
 767 Arguments:
 768   key       points to the name of the key
 769   s         points to the string from which to extract the subfield
 770
 771 Returns:    NULL if the subfield was not found, or
 772             a pointer to the subfield's data
 773 */
 774
 775 static uschar *
 776 expand_getkeyed(uschar *key, uschar *s)
 777 {
 778 int length = Ustrlen(key);
 779 while (isspace(*s)) s++;
 780
 781 /* Loop to search for the key */
 782
 783 while (*s != 0)
 784   {
 785   int dkeylength;
 786   uschar *data;
 787   uschar *dkey = s;
 788
 789   while (*s != 0 && *s != '=' && !isspace(*s)) s++;
 790   dkeylength = s - dkey;
 791   while (isspace(*s)) s++;
 792   if (*s == '=') while (isspace((*(++s))));
 793
 794   data = string_dequote(&s);
 795   if (length == dkeylength && strncmpic(key, dkey, length) == 0)
 796     return data;
 797
 798   while (isspace(*s)) s++;
 799   }
 800
 801 return NULL;
 802 }
 803
 804
 805
 806
 807 /*************************************************
 808 *   Extract numbered subfield from string        *
 809 *************************************************/
 810
 811 /* Extracts a numbered field from a string that is divided by tokens - for
 812 example a line from /etc/passwd is divided by colon characters.  First field is
 813 numbered one.  Negative arguments count from the right. Zero returns the whole
 814 string. Returns NULL if there are insufficient tokens in the string
 815
 816 ***WARNING***
 817 Modifies final argument - this is a dynamically generated string, so that's OK.
 818
 819 Arguments:
 820   field       number of field to be extracted,
 821                 first field = 1, whole string = 0, last field = -1
 822   separators  characters that are used to break string into tokens
 823   s           points to the string from which to extract the subfield
 824
 825 Returns:      NULL if the field was not found,
 826               a pointer to the field's data inside s (modified to add 0)
 827 */
 828
 829 static uschar *
 830 expand_gettokened (int field, uschar *separators, uschar *s)
 831 {
 832 int sep = 1;
 833 int count;
 834 uschar *ss = s;
 835 uschar *fieldtext = NULL;
 836
 837 if (field == 0) return s;
 838
 839 /* Break the line up into fields in place; for field > 0 we stop when we have
 840 done the number of fields we want. For field < 0 we continue till the end of
 841 the string, counting the number of fields. */
 842
 843 count = (field > 0)? field : INT_MAX;
 844
 845 while (count-- > 0)
 846   {
 847   size_t len;
 848
 849   /* Previous field was the last one in the string. For a positive field
 850   number, this means there are not enough fields. For a negative field number,
 851   check that there are enough, and scan back to find the one that is wanted. */
 852
 853   if (sep == 0)
 854     {
 855     if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
 856     if ((-field) == (INT_MAX - count - 1)) return s;
 857     while (field++ < 0)
 858       {
 859       ss--;
 860       while (ss[-1] != 0) ss--;
 861       }
 862     fieldtext = ss;
 863     break;
 864     }
 865
 866   /* Previous field was not last in the string; save its start and put a
 867   zero at its end. */
 868
 869   fieldtext = ss;
 870   len = Ustrcspn(ss, separators);
 871   sep = ss[len];
 872   ss[len] = 0;
 873   ss += len + 1;
 874   }
 875
 876 return fieldtext;
 877 }
 878
 879
 880
 881 /*************************************************
 882 *        Extract a substring from a string       *
 883 *************************************************/
 884
 885 /* Perform the ${substr or ${length expansion operations.
 886
 887 Arguments:
 888   subject     the input string
 889   value1      the offset from the start of the input string to the start of
 890                 the output string; if negative, count from the right.
 891   value2      the length of the output string, or negative (-1) for unset
 892                 if value1 is positive, unset means "all after"
 893                 if value1 is negative, unset means "all before"
 894   len         set to the length of the returned string
 895
 896 Returns:      pointer to the output string, or NULL if there is an error
 897 */
 898
 899 static uschar *
 900 extract_substr(uschar *subject, int value1, int value2, int *len)
 901 {
 902 int sublen = Ustrlen(subject);
 903
 904 if (value1 < 0)    /* count from right */
 905   {
 906   value1 += sublen;
 907
 908   /* If the position is before the start, skip to the start, and adjust the
 909   length. If the length ends up negative, the substring is null because nothing
 910   can precede. This falls out naturally when the length is unset, meaning "all
 911   to the left". */
 912
 913   if (value1 < 0)
 914     {
 915     value2 += value1;
 916     if (value2 < 0) value2 = 0;
 917     value1 = 0;
 918     }
 919
 920   /* Otherwise an unset length => characters before value1 */
 921
 922   else if (value2 < 0)
 923     {
 924     value2 = value1;
 925     value1 = 0;
 926     }
 927   }
 928
 929 /* For a non-negative offset, if the starting position is past the end of the
 930 string, the result will be the null string. Otherwise, an unset length means
 931 "rest"; just set it to the maximum - it will be cut down below if necessary. */
 932
 933 else
 934   {
 935   if (value1 > sublen)
 936     {
 937     value1 = sublen;
 938     value2 = 0;
 939     }
 940   else if (value2 < 0) value2 = sublen;
 941   }
 942
 943 /* Cut the length down to the maximum possible for the offset value, and get
 944 the required characters. */
 945
 946 if (value1 + value2 > sublen) value2 = sublen - value1;
 947 *len = value2;
 948 return subject + value1;
 949 }
 950
 951
 952
 953
 954 /*************************************************
 955 *            Old-style hash of a string          *
 956 *************************************************/
 957
 958 /* Perform the ${hash expansion operation.
 959
 960 Arguments:
 961   subject     the input string (an expanded substring)
 962   value1      the length of the output string; if greater or equal to the
 963                 length of the input string, the input string is returned
 964   value2      the number of hash characters to use, or 26 if negative
 965   len         set to the length of the returned string
 966
 967 Returns:      pointer to the output string, or NULL if there is an error
 968 */
 969
 970 static uschar *
 971 compute_hash(uschar *subject, int value1, int value2, int *len)
 972 {
 973 int sublen = Ustrlen(subject);
 974
 975 if (value2 < 0) value2 = 26;
 976 else if (value2 > Ustrlen(hashcodes))
 977   {
 978   expand_string_message =
 979     string_sprintf("hash count \"%d\" too big", value2);
 980   return NULL;
 981   }
 982
 983 /* Calculate the hash text. We know it is shorter than the original string, so
 984 can safely place it in subject[] (we know that subject is always itself an
 985 expanded substring). */
 986
 987 if (value1 < sublen)
 988   {
 989   int c;
 990   int i = 0;
 991   int j = value1;
 992   while ((c = (subject[j])) != 0)
 993     {
 994     int shift = (c + j++) & 7;
 995     subject[i] ^= (c << shift) | (c >> (8-shift));
 996     if (++i >= value1) i = 0;
 997     }
 998   for (i = 0; i < value1; i++)
 999     subject[i] = hashcodes[(subject[i]) % value2];
1000   }
1001 else value1 = sublen;
1002
1003 *len = value1;
1004 return subject;
1005 }
1006
1007
1008
1009
1010 /*************************************************
1011 *             Numeric hash of a string           *
1012 *************************************************/
1013
1014 /* Perform the ${nhash expansion operation. The first characters of the
1015 string are treated as most important, and get the highest prime numbers.
1016
1017 Arguments:
1018   subject     the input string
1019   value1      the maximum value of the first part of the result
1020   value2      the maximum value of the second part of the result,
1021                 or negative to produce only a one-part result
1022   len         set to the length of the returned string
1023
1024 Returns:  pointer to the output string, or NULL if there is an error.
1025 */
1026
1027 static uschar *
1028 compute_nhash (uschar *subject, int value1, int value2, int *len)
1029 {
1030 uschar *s = subject;
1031 int i = 0;
1032 unsigned long int total = 0; /* no overflow */
1033
1034 while (*s != 0)
1035   {
1036   if (i == 0) i = sizeof(prime)/sizeof(int) - 1;
1037   total += prime[i--] * (unsigned int)(*s++);
1038   }
1039
1040 /* If value2 is unset, just compute one number */
1041
1042 if (value2 < 0)
1043   {
1044   s = string_sprintf("%d", total % value1);
1045   }
1046
1047 /* Otherwise do a div/mod hash */
1048
1049 else
1050   {
1051   total = total % (value1 * value2);
1052   s = string_sprintf("%d/%d", total/value2, total % value2);
1053   }
1054
1055 *len = Ustrlen(s);
1056 return s;
1057 }
1058
1059
1060
1061
1062
1063 /*************************************************
1064 *     Find the value of a header or headers      *
1065 *************************************************/
1066
1067 /* Multiple instances of the same header get concatenated, and this function
1068 can also return a concatenation of all the header lines. When concatenating
1069 specific headers that contain lists of addresses, a comma is inserted between
1070 them. Otherwise we use a straight concatenation. Because some messages can have
1071 pathologically large number of lines, there is a limit on the length that is
1072 returned. Also, to avoid massive store use which would result from using
1073 string_cat() as it copies and extends strings, we do a preliminary pass to find
1074 out exactly how much store will be needed. On "normal" messages this will be
1075 pretty trivial.
1076
1077 Arguments:
1078   name          the name of the header, without the leading $header_ or $h_,
1079                 or NULL if a concatenation of all headers is required
1080   exists_only   TRUE if called from a def: test; don't need to build a string;
1081                 just return a string that is not "" and not "0" if the header
1082                 exists
1083   newsize       return the size of memory block that was obtained; may be NULL
1084                 if exists_only is TRUE
1085   want_raw      TRUE if called for $rh_ or $rheader_ variables; no processing,
1086                 other than concatenating, will be done on the header
1087   charset       name of charset to translate MIME words to; used only if
1088                 want_raw is false; if NULL, no translation is done (this is
1089                 used for $bh_ and $bheader_)
1090
1091 Returns:        NULL if the header does not exist, else a pointer to a new
1092                 store block
1093 */
1094
1095 static uschar *
1096 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1097   uschar *charset)
1098 {
1099 BOOL found = name == NULL;
1100 int comma = 0;
1101 int len = found? 0 : Ustrlen(name);
1102 int i;
1103 uschar *yield = NULL;
1104 uschar *ptr = NULL;
1105
1106 /* Loop for two passes - saves code repetition */
1107
1108 for (i = 0; i < 2; i++)
1109   {
1110   int size = 0;
1111   header_line *h;
1112
1113   for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1114     {
1115     if (h->type != htype_old && h->text != NULL)  /* NULL => Received: placeholder */
1116       {
1117       if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1118         {
1119         int ilen;
1120         uschar *t;
1121
1122         if (exists_only) return US"1";      /* don't need actual string */
1123         found = TRUE;
1124         t = h->text + len;                  /* text to insert */
1125         if (!want_raw)                      /* unless wanted raw, */
1126           while (isspace(*t)) t++;          /* remove leading white space */
1127         ilen = h->slen - (t - h->text);     /* length to insert */
1128
1129         /* Set comma = 1 if handling a single header and it's one of those
1130         that contains an address list, except when asked for raw headers. Only
1131         need to do this once. */
1132
1133         if (!want_raw && name != NULL && comma == 0 &&
1134             Ustrchr("BCFRST", h->type) != NULL)
1135           comma = 1;
1136
1137         /* First pass - compute total store needed; second pass - compute
1138         total store used, including this header. */
1139
1140         size += ilen + comma;
1141
1142         /* Second pass - concatentate the data, up to a maximum. Note that
1143         the loop stops when size hits the limit. */
1144
1145         if (i != 0)
1146           {
1147           if (size > header_insert_maxlen)
1148             {
1149             ilen -= size - header_insert_maxlen;
1150             comma = 0;
1151             }
1152           Ustrncpy(ptr, t, ilen);
1153           ptr += ilen;
1154           if (comma != 0 && ilen > 0)
1155             {
1156             ptr[-1] = ',';
1157             *ptr++ = '\n';
1158             }
1159           }
1160         }
1161       }
1162     }
1163
1164   /* At end of first pass, truncate size if necessary, and get the buffer
1165   to hold the data, returning the buffer size. */
1166
1167   if (i == 0)
1168     {
1169     if (!found) return NULL;
1170     if (size > header_insert_maxlen) size = header_insert_maxlen;
1171     *newsize = size + 1;
1172     ptr = yield = store_get(*newsize);
1173     }
1174   }
1175
1176 /* Remove a redundant added comma if present */
1177
1178 if (comma != 0 && ptr > yield) ptr -= 2;
1179
1180 /* That's all we do for raw header expansion. */
1181
1182 if (want_raw)
1183   {
1184   *ptr = 0;
1185   }
1186
1187 /* Otherwise, we remove trailing whitespace, including newlines. Then we do RFC
1188 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1189 function can return an error with decoded data if the charset translation
1190 fails. If decoding fails, it returns NULL. */
1191
1192 else
1193   {
1194   uschar *decoded, *error;
1195   while (ptr > yield && isspace(ptr[-1])) ptr--;
1196   *ptr = 0;
1197   decoded = rfc2047_decode2(yield, TRUE, charset, '?', NULL, newsize, &error);
1198   if (error != NULL)
1199     {
1200     DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1201       "    input was: %s\n", error, yield);
1202     }
1203   if (decoded != NULL) yield = decoded;
1204   }
1205
1206 return yield;
1207 }
1208
1209
1210
1211
1212 /*************************************************
1213 *               Find value of a variable         *
1214 *************************************************/
1215
1216 /* The table of variables is kept in alphabetic order, so we can search it
1217 using a binary chop. The "choplen" variable is nothing to do with the binary
1218 chop.
1219
1220 Arguments:
1221   name          the name of the variable being sought
1222   exists_only   TRUE if this is a def: test; passed on to find_header()
1223   skipping      TRUE => skip any processing evaluation; this is not the same as
1224                   exists_only because def: may test for values that are first
1225                   evaluated here
1226   newsize       pointer to an int which is initially zero; if the answer is in
1227                 a new memory buffer, *newsize is set to its size
1228
1229 Returns:        NULL if the variable does not exist, or
1230                 a pointer to the variable's contents, or
1231                 something non-NULL if exists_only is TRUE
1232 */
1233
1234 static uschar *
1235 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1236 {
1237 int first = 0;
1238 int last = var_table_size;
1239
1240 while (last > first)
1241   {
1242   uschar *s, *domain;
1243   uschar **ss;
1244   int middle = (first + last)/2;
1245   int c = Ustrcmp(name, var_table[middle].name);
1246
1247   if (c > 0) { first = middle + 1; continue; }
1248   if (c < 0) { last = middle; continue; }
1249
1250   /* Found an existing variable. If in skipping state, the value isn't needed,
1251   and we want to avoid processing (such as looking up up the host name). */
1252
1253   if (skipping) return US"";
1254
1255   switch (var_table[middle].type)
1256     {
1257     case vtype_filter_int:
1258     if (!filter_running) return NULL;
1259     /* Fall through */
1260
1261 #ifdef EXPERIMENTAL_DOMAINKEYS
1262
1263     case vtype_dk_verify:
1264     if (dk_verify_block == NULL) return US"";
1265     s = NULL;
1266     if (Ustrcmp(var_table[middle].name, "dk_result") == 0)
1267       s = dk_verify_block->result_string;
1268     if (Ustrcmp(var_table[middle].name, "dk_sender") == 0)
1269       s = dk_verify_block->address;
1270     if (Ustrcmp(var_table[middle].name, "dk_sender_domain") == 0)
1271       s = dk_verify_block->domain;
1272     if (Ustrcmp(var_table[middle].name, "dk_sender_local_part") == 0)
1273       s = dk_verify_block->local_part;
1274
1275     if (Ustrcmp(var_table[middle].name, "dk_sender_source") == 0)
1276       switch(dk_verify_block->address_source) {
1277         case DK_EXIM_ADDRESS_NONE: s = "0"; break;
1278         case DK_EXIM_ADDRESS_FROM_FROM: s = "from"; break;
1279         case DK_EXIM_ADDRESS_FROM_SENDER: s = "sender"; break;
1280       }
1281
1282     if (Ustrcmp(var_table[middle].name, "dk_status") == 0)
1283       switch(dk_verify_block->result) {
1284         case DK_EXIM_RESULT_ERR: s = "error"; break;
1285         case DK_EXIM_RESULT_BAD_FORMAT: s = "bad format"; break;
1286         case DK_EXIM_RESULT_NO_KEY: s = "no key"; break;
1287         case DK_EXIM_RESULT_NO_SIGNATURE: s = "no signature"; break;
1288         case DK_EXIM_RESULT_REVOKED: s = "revoked"; break;
1289         case DK_EXIM_RESULT_NON_PARTICIPANT: s = "non-participant"; break;
1290         case DK_EXIM_RESULT_GOOD: s = "good"; break;
1291         case DK_EXIM_RESULT_BAD: s = "bad"; break;
1292       }
1293
1294     if (Ustrcmp(var_table[middle].name, "dk_signsall") == 0)
1295       s = (dk_verify_block->signsall)? "1" : "0";
1296
1297     if (Ustrcmp(var_table[middle].name, "dk_testing") == 0)
1298       s = (dk_verify_block->testing)? "1" : "0";
1299
1300     if (Ustrcmp(var_table[middle].name, "dk_is_signed") == 0)
1301       s = (dk_verify_block->is_signed)? "1" : "0";
1302
1303     return (s == NULL)? US"" : s;
1304 #endif
1305
1306     case vtype_int:
1307     sprintf(CS var_buffer, "%d", *(int *)(var_table[middle].value)); /* Integer */
1308     return var_buffer;
1309
1310     case vtype_ino:
1311     sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(var_table[middle].value))); /* Inode */
1312     return var_buffer;
1313
1314     case vtype_gid:
1315     sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(var_table[middle].value))); /* gid */
1316     return var_buffer;
1317
1318     case vtype_uid:
1319     sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(var_table[middle].value))); /* uid */
1320     return var_buffer;
1321
1322     case vtype_stringptr:                      /* Pointer to string */
1323     s = *((uschar **)(var_table[middle].value));
1324     return (s == NULL)? US"" : s;
1325
1326     case vtype_pid:
1327     sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1328     return var_buffer;
1329
1330     case vtype_load_avg:
1331     sprintf(CS var_buffer, "%d", os_getloadavg()); /* load_average */
1332     return var_buffer;
1333
1334     case vtype_host_lookup:                    /* Lookup if not done so */
1335     if (sender_host_name == NULL && sender_host_address != NULL &&
1336         !host_lookup_failed && host_name_lookup() == OK)
1337       host_build_sender_fullhost();
1338     return (sender_host_name == NULL)? US"" : sender_host_name;
1339
1340     case vtype_localpart:                      /* Get local part from address */
1341     s = *((uschar **)(var_table[middle].value));
1342     if (s == NULL) return US"";
1343     domain = Ustrrchr(s, '@');
1344     if (domain == NULL) return s;
1345     if (domain - s > sizeof(var_buffer) - 1)
1346       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than %d in "
1347         "string expansion", sizeof(var_buffer));
1348     Ustrncpy(var_buffer, s, domain - s);
1349     var_buffer[domain - s] = 0;
1350     return var_buffer;
1351
1352     case vtype_domain:                         /* Get domain from address */
1353     s = *((uschar **)(var_table[middle].value));
1354     if (s == NULL) return US"";
1355     domain = Ustrrchr(s, '@');
1356     return (domain == NULL)? US"" : domain + 1;
1357
1358     case vtype_msgheaders:
1359     return find_header(NULL, exists_only, newsize, FALSE, NULL);
1360
1361     case vtype_msgbody:                        /* Pointer to msgbody string */
1362     case vtype_msgbody_end:                    /* Ditto, the end of the msg */
1363     ss = (uschar **)(var_table[middle].value);
1364     if (*ss == NULL && deliver_datafile >= 0)  /* Read body when needed */
1365       {
1366       uschar *body;
1367       off_t start_offset = SPOOL_DATA_START_OFFSET;
1368       int len = message_body_visible;
1369       if (len > message_size) len = message_size;
1370       *ss = body = store_malloc(len+1);
1371       body[0] = 0;
1372       if (var_table[middle].type == vtype_msgbody_end)
1373         {
1374         struct stat statbuf;
1375         if (fstat(deliver_datafile, &statbuf) == 0)
1376           {
1377           start_offset = statbuf.st_size - len;
1378           if (start_offset < SPOOL_DATA_START_OFFSET)
1379             start_offset = SPOOL_DATA_START_OFFSET;
1380           }
1381         }
1382       lseek(deliver_datafile, start_offset, SEEK_SET);
1383       len = read(deliver_datafile, body, len);
1384       if (len > 0)
1385         {
1386         body[len] = 0;
1387         while (len > 0)
1388           {
1389           if (body[--len] == '\n' || body[len] == 0) body[len] = ' ';
1390           }
1391         }
1392       }
1393     return (*ss == NULL)? US"" : *ss;
1394
1395     case vtype_todbsdin:                       /* BSD inbox time of day */
1396     return tod_stamp(tod_bsdin);
1397
1398     case vtype_tode:                           /* Unix epoch time of day */
1399     return tod_stamp(tod_epoch);
1400
1401     case vtype_todf:                           /* Full time of day */
1402     return tod_stamp(tod_full);
1403
1404     case vtype_todl:                           /* Log format time of day */
1405     return tod_stamp(tod_log_bare);            /* (without timezone) */
1406
1407     case vtype_todzone:                        /* Time zone offset only */
1408     return tod_stamp(tod_zone);
1409
1410     case vtype_todzulu:                        /* Zulu time */
1411     return tod_stamp(tod_zulu);
1412
1413     case vtype_todlf:                          /* Log file datestamp tod */
1414     return tod_stamp(tod_log_datestamp);
1415
1416     case vtype_reply:                          /* Get reply address */
1417     s = find_header(US"reply-to:", exists_only, newsize, FALSE,
1418       headers_charset);
1419     if (s == NULL || *s == 0)
1420       s = find_header(US"from:", exists_only, newsize, FALSE, headers_charset);
1421     return (s == NULL)? US"" : s;
1422
1423     /* A recipients list is available only during system message filtering,
1424     during ACL processing after DATA, and while expanding pipe commands
1425     generated from a system filter, but not elsewhere. */
1426
1427     case vtype_recipients:
1428     if (!enable_dollar_recipients) return NULL; else
1429       {
1430       int size = 128;
1431       int ptr = 0;
1432       int i;
1433       s = store_get(size);
1434       for (i = 0; i < recipients_count; i++)
1435         {
1436         if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1437         s = string_cat(s, &size, &ptr, recipients_list[i].address,
1438           Ustrlen(recipients_list[i].address));
1439         }
1440       s[ptr] = 0;     /* string_cat() leaves room */
1441       }
1442     return s;
1443
1444     case vtype_pspace:
1445       {
1446       int inodes;
1447       sprintf(CS var_buffer, "%d",
1448         receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes));
1449       }
1450     return var_buffer;
1451
1452     case vtype_pinodes:
1453       {
1454       int inodes;
1455       (void) receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes);
1456       sprintf(CS var_buffer, "%d", inodes);
1457       }
1458     return var_buffer;
1459     }
1460   }
1461
1462 return NULL;          /* Unknown variable name */
1463 }
1464
1465
1466
1467
1468 /*************************************************
1469 *           Read and expand substrings           *
1470 *************************************************/
1471
1472 /* This function is called to read and expand argument substrings for various
1473 expansion items. Some have a minimum requirement that is less than the maximum;
1474 in these cases, the first non-present one is set to NULL.
1475
1476 Arguments:
1477   sub        points to vector of pointers to set
1478   n          maximum number of substrings
1479   m          minimum required
1480   sptr       points to current string pointer
1481   skipping   the skipping flag
1482   check_end  if TRUE, check for final '}'
1483   name       name of item, for error message
1484
1485 Returns:     0 OK; string pointer updated
1486              1 curly bracketing error (too few arguments)
1487              2 too many arguments (only if check_end is set); message set
1488              3 other error (expansion failure)
1489 */
1490
1491 static int
1492 read_subs(uschar **sub, int n, int m, uschar **sptr, BOOL skipping,
1493   BOOL check_end, uschar *name)
1494 {
1495 int i;
1496 uschar *s = *sptr;
1497
1498 while (isspace(*s)) s++;
1499 for (i = 0; i < n; i++)
1500   {
1501   if (*s != '{')
1502     {
1503     if (i < m) return 1;
1504     sub[i] = NULL;
1505     break;
1506     }
1507   sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
1508   if (sub[i] == NULL) return 3;
1509   if (*s++ != '}') return 1;
1510   while (isspace(*s)) s++;
1511   }
1512 if (check_end && *s++ != '}')
1513   {
1514   if (s[-1] == '{')
1515     {
1516     expand_string_message = string_sprintf("Too many arguments for \"%s\" "
1517       "(max is %d)", name, n);
1518     return 2;
1519     }
1520   return 1;
1521   }
1522
1523 *sptr = s;
1524 return 0;
1525 }
1526
1527
1528
1529
1530 /*************************************************
1531 *        Read and evaluate a condition           *
1532 *************************************************/
1533
1534 /*
1535 Arguments:
1536   s        points to the start of the condition text
1537   yield    points to a BOOL to hold the result of the condition test;
1538            if NULL, we are just reading through a condition that is
1539            part of an "or" combination to check syntax, or in a state
1540            where the answer isn't required
1541
1542 Returns:   a pointer to the first character after the condition, or
1543            NULL after an error
1544 */
1545
1546 static uschar *
1547 eval_condition(uschar *s, BOOL *yield)
1548 {
1549 BOOL testfor = TRUE;
1550 BOOL tempcond, combined_cond;
1551 BOOL *subcondptr;
1552 int i, rc, cond_type, roffset;
1553 int num[2];
1554 struct stat statbuf;
1555 uschar name[256];
1556 uschar *sub[4];
1557
1558 const pcre *re;
1559 const uschar *rerror;
1560
1561 for (;;)
1562   {
1563   while (isspace(*s)) s++;
1564   if (*s == '!') { testfor = !testfor; s++; } else break;
1565   }
1566
1567 /* Numeric comparisons are symbolic */
1568
1569 if (*s == '=' || *s == '>' || *s == '<')
1570   {
1571   int p = 0;
1572   name[p++] = *s++;
1573   if (*s == '=')
1574     {
1575     name[p++] = '=';
1576     s++;
1577     }
1578   name[p] = 0;
1579   }
1580
1581 /* All other conditions are named */
1582
1583 else s = read_name(name, 256, s, US"_");
1584
1585 /* If we haven't read a name, it means some non-alpha character is first. */
1586
1587 if (name[0] == 0)
1588   {
1589   expand_string_message = string_sprintf("condition name expected, "
1590     "but found \"%.16s\"", s);
1591   return NULL;
1592   }
1593
1594 /* Find which condition we are dealing with, and switch on it */
1595
1596 cond_type = chop_match(name, cond_table, sizeof(cond_table)/sizeof(uschar *));
1597 switch(cond_type)
1598   {
1599   /* def: tests for a non-empty variable, or for the existence of a header. If
1600   yield == NULL we are in a skipping state, and don't care about the answer. */
1601
1602   case ECOND_DEF:
1603   if (*s != ':')
1604     {
1605     expand_string_message = US"\":\" expected after \"def\"";
1606     return NULL;
1607     }
1608
1609   s = read_name(name, 256, s+1, US"_");
1610
1611   /* Test for a header's existence */
1612
1613   if (Ustrncmp(name, "h_", 2) == 0 ||
1614       Ustrncmp(name, "rh_", 3) == 0 ||
1615       Ustrncmp(name, "bh_", 3) == 0 ||
1616       Ustrncmp(name, "header_", 7) == 0 ||
1617       Ustrncmp(name, "rheader_", 8) == 0 ||
1618       Ustrncmp(name, "bheader_", 8) == 0)
1619     {
1620     s = read_header_name(name, 256, s);
1621     if (yield != NULL) *yield =
1622       (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
1623     }
1624
1625   /* Test for a variable's having a non-empty value. A non-existent variable
1626   causes an expansion failure. */
1627
1628   else
1629     {
1630     uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
1631     if (value == NULL)
1632       {
1633       expand_string_message = (name[0] == 0)?
1634         string_sprintf("variable name omitted after \"def:\"") :
1635         string_sprintf("unknown variable \"%s\" after \"def:\"", name);
1636       return NULL;
1637       }
1638     if (yield != NULL) *yield = (value[0] != 0) == testfor;
1639     }
1640
1641   return s;
1642
1643
1644   /* first_delivery tests for first delivery attempt */
1645
1646   case ECOND_FIRST_DELIVERY:
1647   if (yield != NULL) *yield = deliver_firsttime == testfor;
1648   return s;
1649
1650
1651   /* queue_running tests for any process started by a queue runner */
1652
1653   case ECOND_QUEUE_RUNNING:
1654   if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
1655   return s;
1656
1657
1658   /* exists:  tests for file existence
1659        isip:  tests for any IP address
1660       isip4:  tests for an IPv4 address
1661       isip6:  tests for an IPv6 address
1662         pam:  does PAM authentication
1663      radius:  does RADIUS authentication
1664    ldapauth:  does LDAP authentication
1665     pwcheck:  does Cyrus SASL pwcheck authentication
1666   */
1667
1668   case ECOND_EXISTS:
1669   case ECOND_ISIP:
1670   case ECOND_ISIP4:
1671   case ECOND_ISIP6:
1672   case ECOND_PAM:
1673   case ECOND_RADIUS:
1674   case ECOND_LDAPAUTH:
1675   case ECOND_PWCHECK:
1676
1677   while (isspace(*s)) s++;
1678   if (*s != '{') goto COND_FAILED_CURLY_START;
1679
1680   sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1681   if (sub[0] == NULL) return NULL;
1682   if (*s++ != '}') goto COND_FAILED_CURLY_END;
1683
1684   if (yield == NULL) return s;   /* No need to run the test if skipping */
1685
1686   switch(cond_type)
1687     {
1688     case ECOND_EXISTS:
1689     if ((expand_forbid & RDO_EXISTS) != 0)
1690       {
1691       expand_string_message = US"File existence tests are not permitted";
1692       return NULL;
1693       }
1694     *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
1695     break;
1696
1697     case ECOND_ISIP:
1698     case ECOND_ISIP4:
1699     case ECOND_ISIP6:
1700     rc = string_is_ip_address(sub[0], NULL);
1701     *yield = ((cond_type == ECOND_ISIP)? (rc > 0) :
1702              (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
1703     break;
1704
1705     /* Various authentication tests - all optionally compiled */
1706
1707     case ECOND_PAM:
1708     #ifdef SUPPORT_PAM
1709     rc = auth_call_pam(sub[0], &expand_string_message);
1710     goto END_AUTH;
1711     #else
1712     goto COND_FAILED_NOT_COMPILED;
1713     #endif  /* SUPPORT_PAM */
1714
1715     case ECOND_RADIUS:
1716     #ifdef RADIUS_CONFIG_FILE
1717     rc = auth_call_radius(sub[0], &expand_string_message);
1718     goto END_AUTH;
1719     #else
1720     goto COND_FAILED_NOT_COMPILED;
1721     #endif  /* RADIUS_CONFIG_FILE */
1722
1723     case ECOND_LDAPAUTH:
1724     #ifdef LOOKUP_LDAP
1725       {
1726       /* Just to keep the interface the same */
1727       BOOL do_cache;
1728       int old_pool = store_pool;
1729       store_pool = POOL_SEARCH;
1730       rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
1731         &expand_string_message, &do_cache);
1732       store_pool = old_pool;
1733       }
1734     goto END_AUTH;
1735     #else
1736     goto COND_FAILED_NOT_COMPILED;
1737     #endif  /* LOOKUP_LDAP */
1738
1739     case ECOND_PWCHECK:
1740     #ifdef CYRUS_PWCHECK_SOCKET
1741     rc = auth_call_pwcheck(sub[0], &expand_string_message);
1742     goto END_AUTH;
1743     #else
1744     goto COND_FAILED_NOT_COMPILED;
1745     #endif  /* CYRUS_PWCHECK_SOCKET */
1746
1747     #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
1748         defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
1749     END_AUTH:
1750     if (rc == ERROR || rc == DEFER) return NULL;
1751     *yield = (rc == OK) == testfor;
1752     #endif
1753     }
1754   return s;
1755
1756
1757   /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
1758
1759      ${if saslauthd {{username}{password}{service}{realm}}  {yes}[no}}
1760
1761   However, the last two are optional. That is why the whole set is enclosed
1762   in their own set or braces. */
1763
1764   case ECOND_SASLAUTHD:
1765   #ifndef CYRUS_SASLAUTHD_SOCKET
1766   goto COND_FAILED_NOT_COMPILED;
1767   #else
1768   while (isspace(*s)) s++;
1769   if (*s++ != '{') goto COND_FAILED_CURLY_START;
1770   switch(read_subs(sub, 4, 2, &s, yield == NULL, TRUE, US"saslauthd"))
1771     {
1772     case 1: expand_string_message = US"too few arguments or bracketing "
1773       "error for saslauthd";
1774     case 2:
1775     case 3: return NULL;
1776     }
1777   if (sub[2] == NULL) sub[3] = NULL;  /* realm if no service */
1778   if (yield != NULL)
1779     {
1780     int rc;
1781     rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
1782       &expand_string_message);
1783     if (rc == ERROR || rc == DEFER) return NULL;
1784     *yield = (rc == OK) == testfor;
1785     }
1786   return s;
1787   #endif /* CYRUS_SASLAUTHD_SOCKET */
1788
1789
1790   /* symbolic operators for numeric and string comparison, and a number of
1791   other operators, all requiring two arguments.
1792
1793   match:             does a regular expression match and sets up the numerical
1794                        variables if it succeeds
1795   match_address:     matches in an address list
1796   match_domain:      matches in a domain list
1797   match_local_part:  matches in a local part list
1798   crypteq:           encrypts plaintext and compares against an encrypted text,
1799                        using crypt(), crypt16(), MD5 or SHA-1
1800   */
1801
1802   case ECOND_MATCH:
1803   case ECOND_MATCH_ADDRESS:
1804   case ECOND_MATCH_DOMAIN:
1805   case ECOND_MATCH_LOCAL_PART:
1806   case ECOND_CRYPTEQ:
1807
1808   case ECOND_NUM_L:     /* Numerical comparisons */
1809   case ECOND_NUM_LE:
1810   case ECOND_NUM_E:
1811   case ECOND_NUM_EE:
1812   case ECOND_NUM_G:
1813   case ECOND_NUM_GE:
1814
1815   case ECOND_STR_LT:    /* String comparisons */
1816   case ECOND_STR_LTI:
1817   case ECOND_STR_LE:
1818   case ECOND_STR_LEI:
1819   case ECOND_STR_EQ:
1820   case ECOND_STR_EQI:
1821   case ECOND_STR_GT:
1822   case ECOND_STR_GTI:
1823   case ECOND_STR_GE:
1824   case ECOND_STR_GEI:
1825
1826   for (i = 0; i < 2; i++)
1827     {
1828     while (isspace(*s)) s++;
1829     if (*s != '{')
1830       {
1831       if (i == 0) goto COND_FAILED_CURLY_START;
1832       expand_string_message = string_sprintf("missing 2nd string in {} "
1833         "after \"%s\"", name);
1834       return NULL;
1835       }
1836     sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1837     if (sub[i] == NULL) return NULL;
1838     if (*s++ != '}') goto COND_FAILED_CURLY_END;
1839
1840     /* Convert to numerical if required; we know that the names of all the
1841     conditions that compare numbers do not start with a letter. This just saves
1842     checking for them individually. */
1843
1844     if (!isalpha(name[0]))
1845       {
1846       uschar *endptr;
1847       num[i] = (int)Ustrtol((const uschar *)sub[i], &endptr, 10);
1848       if (tolower(*endptr) == 'k')
1849         {
1850         num[i] *= 1024;
1851         endptr++;
1852         }
1853       else if (tolower(*endptr) == 'm')
1854         {
1855         num[i] *= 1024*1024;
1856         endptr++;
1857         }
1858       while (isspace(*endptr)) endptr++;
1859       if (*endptr != 0)
1860         {
1861         expand_string_message = string_sprintf("\"%s\" is not a number",
1862           sub[i]);
1863         return NULL;
1864         }
1865       }
1866     }
1867
1868   /* Result not required */
1869
1870   if (yield == NULL) return s;
1871
1872   /* Do an appropriate comparison */
1873
1874   switch(cond_type)
1875     {
1876     case ECOND_NUM_E:
1877     case ECOND_NUM_EE:
1878     *yield = (num[0] == num[1]) == testfor;
1879     break;
1880
1881     case ECOND_NUM_G:
1882     *yield = (num[0] > num[1]) == testfor;
1883     break;
1884
1885     case ECOND_NUM_GE:
1886     *yield = (num[0] >= num[1]) == testfor;
1887     break;
1888
1889     case ECOND_NUM_L:
1890     *yield = (num[0] < num[1]) == testfor;
1891     break;
1892
1893     case ECOND_NUM_LE:
1894     *yield = (num[0] <= num[1]) == testfor;
1895     break;
1896
1897     case ECOND_STR_LT:
1898     *yield = (Ustrcmp(sub[0], sub[1]) < 0) == testfor;
1899     break;
1900
1901     case ECOND_STR_LTI:
1902     *yield = (strcmpic(sub[0], sub[1]) < 0) == testfor;
1903     break;
1904
1905     case ECOND_STR_LE:
1906     *yield = (Ustrcmp(sub[0], sub[1]) <= 0) == testfor;
1907     break;
1908
1909     case ECOND_STR_LEI:
1910     *yield = (strcmpic(sub[0], sub[1]) <= 0) == testfor;
1911     break;
1912
1913     case ECOND_STR_EQ:
1914     *yield = (Ustrcmp(sub[0], sub[1]) == 0) == testfor;
1915     break;
1916
1917     case ECOND_STR_EQI:
1918     *yield = (strcmpic(sub[0], sub[1]) == 0) == testfor;
1919     break;
1920
1921     case ECOND_STR_GT:
1922     *yield = (Ustrcmp(sub[0], sub[1]) > 0) == testfor;
1923     break;
1924
1925     case ECOND_STR_GTI:
1926     *yield = (strcmpic(sub[0], sub[1]) > 0) == testfor;
1927     break;
1928
1929     case ECOND_STR_GE:
1930     *yield = (Ustrcmp(sub[0], sub[1]) >= 0) == testfor;
1931     break;
1932
1933     case ECOND_STR_GEI:
1934     *yield = (strcmpic(sub[0], sub[1]) >= 0) == testfor;
1935     break;
1936
1937     case ECOND_MATCH:   /* Regular expression match */
1938     re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
1939       NULL);
1940     if (re == NULL)
1941       {
1942       expand_string_message = string_sprintf("regular expression error in "
1943         "\"%s\": %s at offset %d", sub[1], rerror, roffset);
1944       return NULL;
1945       }
1946     *yield = regex_match_and_setup(re, sub[0], 0, -1) == testfor;
1947     break;
1948
1949     case ECOND_MATCH_ADDRESS:  /* Match in an address list */
1950     rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
1951     goto MATCHED_SOMETHING;
1952
1953     case ECOND_MATCH_DOMAIN:   /* Match in a domain list */
1954     rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
1955       MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
1956     goto MATCHED_SOMETHING;
1957
1958     case ECOND_MATCH_LOCAL_PART:
1959     rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
1960       MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
1961     /* Fall through */
1962
1963     MATCHED_SOMETHING:
1964     switch(rc)
1965       {
1966       case OK:
1967       *yield = testfor;
1968       break;
1969
1970       case FAIL:
1971       *yield = !testfor;
1972       break;
1973
1974       case DEFER:
1975       expand_string_message = string_sprintf("unable to complete match "
1976         "against \"%s\": %s", sub[1], search_error_message);
1977       return NULL;
1978       }
1979
1980     break;
1981
1982     /* Various "encrypted" comparisons. If the second string starts with
1983     "{" then an encryption type is given. Default to crypt() or crypt16()
1984     (build-time choice). */
1985
1986     case ECOND_CRYPTEQ:
1987     #ifndef SUPPORT_CRYPTEQ
1988     goto COND_FAILED_NOT_COMPILED;
1989     #else
1990     if (strncmpic(sub[1], US"{md5}", 5) == 0)
1991       {
1992       int sublen = Ustrlen(sub[1]+5);
1993       md5 base;
1994       uschar digest[16];
1995
1996       md5_start(&base);
1997       md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
1998
1999       /* If the length that we are comparing against is 24, the MD5 digest
2000       is expressed as a base64 string. This is the way LDAP does it. However,
2001       some other software uses a straightforward hex representation. We assume
2002       this if the length is 32. Other lengths fail. */
2003
2004       if (sublen == 24)
2005         {
2006         uschar *coded = auth_b64encode((uschar *)digest, 16);
2007         DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2008           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2009         *yield = (Ustrcmp(coded, sub[1]+5) == 0) == testfor;
2010         }
2011       else if (sublen == 32)
2012         {
2013         int i;
2014         uschar coded[36];
2015         for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2016         coded[32] = 0;
2017         DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2018           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2019         *yield = (strcmpic(coded, sub[1]+5) == 0) == testfor;
2020         }
2021       else
2022         {
2023         DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2024           "fail\n  crypted=%s\n", sub[1]+5);
2025         *yield = !testfor;
2026         }
2027       }
2028
2029     else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2030       {
2031       int sublen = Ustrlen(sub[1]+6);
2032       sha1 base;
2033       uschar digest[20];
2034
2035       sha1_start(&base);
2036       sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2037
2038       /* If the length that we are comparing against is 28, assume the SHA1
2039       digest is expressed as a base64 string. If the length is 40, assume a
2040       straightforward hex representation. Other lengths fail. */
2041
2042       if (sublen == 28)
2043         {
2044         uschar *coded = auth_b64encode((uschar *)digest, 20);
2045         DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2046           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2047         *yield = (Ustrcmp(coded, sub[1]+6) == 0) == testfor;
2048         }
2049       else if (sublen == 40)
2050         {
2051         int i;
2052         uschar coded[44];
2053         for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2054         coded[40] = 0;
2055         DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2056           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2057         *yield = (strcmpic(coded, sub[1]+6) == 0) == testfor;
2058         }
2059       else
2060         {
2061         DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2062           "fail\n  crypted=%s\n", sub[1]+6);
2063         *yield = !testfor;
2064         }
2065       }
2066
2067     else   /* {crypt} or {crypt16} and non-{ at start */
2068       {
2069       int which = 0;
2070       uschar *coded;
2071
2072       if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2073         {
2074         sub[1] += 7;
2075         which = 1;
2076         }
2077       else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2078         {
2079         sub[1] += 9;
2080         which = 2;
2081         }
2082       else if (sub[1][0] == '{')
2083         {
2084         expand_string_message = string_sprintf("unknown encryption mechanism "
2085           "in \"%s\"", sub[1]);
2086         return NULL;
2087         }
2088
2089       switch(which)
2090         {
2091         case 0:  coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2092         case 1:  coded = US crypt(CS sub[0], CS sub[1]); break;
2093         default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2094         }
2095
2096       #define STR(s) # s
2097       #define XSTR(s) STR(s)
2098       DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2099         "  subject=%s\n  crypted=%s\n",
2100         (which == 0)? XSTR(DEFAULT_CRYPT) : (which == 1)? "crypt" : "crypt16",
2101         coded, sub[1]);
2102       #undef STR
2103       #undef XSTR
2104
2105       /* If the encrypted string contains fewer than two characters (for the
2106       salt), force failure. Otherwise we get false positives: with an empty
2107       string the yield of crypt() is an empty string! */
2108
2109       *yield = (Ustrlen(sub[1]) < 2)? !testfor :
2110         (Ustrcmp(coded, sub[1]) == 0) == testfor;
2111       }
2112     break;
2113     #endif  /* SUPPORT_CRYPTEQ */
2114     }   /* Switch for comparison conditions */
2115
2116   return s;    /* End of comparison conditions */
2117
2118
2119   /* and/or: computes logical and/or of several conditions */
2120
2121   case ECOND_AND:
2122   case ECOND_OR:
2123   subcondptr = (yield == NULL)? NULL : &tempcond;
2124   combined_cond = (cond_type == ECOND_AND);
2125
2126   while (isspace(*s)) s++;
2127   if (*s++ != '{') goto COND_FAILED_CURLY_START;
2128
2129   for (;;)
2130     {
2131     while (isspace(*s)) s++;
2132     if (*s == '}') break;
2133     if (*s != '{')
2134       {
2135       expand_string_message = string_sprintf("each subcondition "
2136         "inside an \"%s{...}\" condition must be in its own {}", name);
2137       return NULL;
2138       }
2139
2140     s = eval_condition(s+1, subcondptr);
2141     if (s == NULL)
2142       {
2143       expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2144         expand_string_message, name);
2145       return NULL;
2146       }
2147     while (isspace(*s)) s++;
2148
2149     if (*s++ != '}')
2150       {
2151       expand_string_message = string_sprintf("missing } at end of condition "
2152         "inside \"%s\" group", name);
2153       return NULL;
2154       }
2155
2156     if (yield != NULL)
2157       {
2158       if (cond_type == ECOND_AND)
2159         {
2160         combined_cond &= tempcond;
2161         if (!combined_cond) subcondptr = NULL;  /* once false, don't */
2162         }                                       /* evaluate any more */
2163       else
2164         {
2165         combined_cond |= tempcond;
2166         if (combined_cond) subcondptr = NULL;   /* once true, don't */
2167         }                                       /* evaluate any more */
2168       }
2169     }
2170
2171   if (yield != NULL) *yield = (combined_cond == testfor);
2172   return ++s;
2173
2174
2175   /* Unknown condition */
2176
2177   default:
2178   expand_string_message = string_sprintf("unknown condition \"%s\"", name);
2179   return NULL;
2180   }   /* End switch on condition type */
2181
2182 /* Missing braces at start and end of data */
2183
2184 COND_FAILED_CURLY_START:
2185 expand_string_message = string_sprintf("missing { after \"%s\"", name);
2186 return NULL;
2187
2188 COND_FAILED_CURLY_END:
2189 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2190   name);
2191 return NULL;
2192
2193 /* A condition requires code that is not compiled */
2194
2195 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
2196     !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
2197     !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
2198 COND_FAILED_NOT_COMPILED:
2199 expand_string_message = string_sprintf("support for \"%s\" not compiled",
2200   name);
2201 return NULL;
2202 #endif
2203 }
2204
2205
2206
2207
2208 /*************************************************
2209 *          Save numerical variables              *
2210 *************************************************/
2211
2212 /* This function is called from items such as "if" that want to preserve and
2213 restore the numbered variables.
2214
2215 Arguments:
2216   save_expand_string    points to an array of pointers to set
2217   save_expand_nlength   points to an array of ints for the lengths
2218
2219 Returns:                the value of expand max to save
2220 */
2221
2222 static int
2223 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2224 {
2225 int i;
2226 for (i = 0; i <= expand_nmax; i++)
2227   {
2228   save_expand_nstring[i] = expand_nstring[i];
2229   save_expand_nlength[i] = expand_nlength[i];
2230   }
2231 return expand_nmax;
2232 }
2233
2234
2235
2236 /*************************************************
2237 *           Restore numerical variables          *
2238 *************************************************/
2239
2240 /* This function restored saved values of numerical strings.
2241
2242 Arguments:
2243   save_expand_nmax      the number of strings to restore
2244   save_expand_string    points to an array of pointers
2245   save_expand_nlength   points to an array of ints
2246
2247 Returns:                nothing
2248 */
2249
2250 static void
2251 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2252   int *save_expand_nlength)
2253 {
2254 int i;
2255 expand_nmax = save_expand_nmax;
2256 for (i = 0; i <= expand_nmax; i++)
2257   {
2258   expand_nstring[i] = save_expand_nstring[i];
2259   expand_nlength[i] = save_expand_nlength[i];
2260   }
2261 }
2262
2263
2264
2265
2266
2267 /*************************************************
2268 *            Handle yes/no substrings            *
2269 *************************************************/
2270
2271 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
2272 alternative substrings that depend on whether or not the condition was true,
2273 or the lookup or extraction succeeded. The substrings always have to be
2274 expanded, to check their syntax, but "skipping" is set when the result is not
2275 needed - this avoids unnecessary nested lookups.
2276
2277 Arguments:
2278   skipping       TRUE if we were skipping when this item was reached
2279   yes            TRUE if the first string is to be used, else use the second
2280   save_lookup    a value to put back into lookup_value before the 2nd expansion
2281   sptr           points to the input string pointer
2282   yieldptr       points to the output string pointer
2283   sizeptr        points to the output string size
2284   ptrptr         points to the output string pointer
2285   type           "lookup" or "if" or "extract" or "run", for error message
2286
2287 Returns:         0 OK; lookup_value has been reset to save_lookup
2288                  1 expansion failed
2289                  2 expansion failed because of bracketing error
2290 */
2291
2292 static int
2293 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2294   uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type)
2295 {
2296 int rc = 0;
2297 uschar *s = *sptr;    /* Local value */
2298 uschar *sub1, *sub2;
2299
2300 /* If there are no following strings, we substitute the contents of $value for
2301 lookups and for extractions in the success case. For the ${if item, the string
2302 "true" is substituted. In the fail case, nothing is substituted for all three
2303 items. */
2304
2305 while (isspace(*s)) s++;
2306 if (*s == '}')
2307   {
2308   if (type[0] == 'i')
2309     {
2310     if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
2311     }
2312   else
2313     {
2314     if (yes && lookup_value != NULL)
2315       *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
2316         Ustrlen(lookup_value));
2317     lookup_value = save_lookup;
2318     }
2319   s++;
2320   goto RETURN;
2321   }
2322
2323 /* The first following string must be braced. */
2324
2325 if (*s++ != '{') goto FAILED_CURLY;
2326
2327 /* Expand the first substring. Forced failures are noticed only if we actually
2328 want this string. Set skipping in the call in the fail case (this will always
2329 be the case if we were already skipping). */
2330
2331 sub1 = expand_string_internal(s, TRUE, &s, !yes);
2332 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
2333 expand_string_forcedfail = FALSE;
2334 if (*s++ != '}') goto FAILED_CURLY;
2335
2336 /* If we want the first string, add it to the output */
2337
2338 if (yes)
2339   *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
2340
2341 /* If this is called from a lookup or an extract, we want to restore $value to
2342 what it was at the start of the item, so that it has this value during the
2343 second string expansion. For the call from "if" or "run" to this function,
2344 save_lookup is set to lookup_value, so that this statement does nothing. */
2345
2346 lookup_value = save_lookup;
2347
2348 /* There now follows either another substring, or "fail", or nothing. This
2349 time, forced failures are noticed only if we want the second string. We must
2350 set skipping in the nested call if we don't want this string, or if we were
2351 already skipping. */
2352
2353 while (isspace(*s)) s++;
2354 if (*s == '{')
2355   {
2356   sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping);
2357   if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
2358   expand_string_forcedfail = FALSE;
2359   if (*s++ != '}') goto FAILED_CURLY;
2360
2361   /* If we want the second string, add it to the output */
2362
2363   if (!yes)
2364     *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
2365   }
2366
2367 /* If there is no second string, but the word "fail" is present when the use of
2368 the second string is wanted, set a flag indicating it was a forced failure
2369 rather than a syntactic error. Swallow the terminating } in case this is nested
2370 inside another lookup or if or extract. */
2371
2372 else if (*s != '}')
2373   {
2374   uschar name[256];
2375   s = read_name(name, sizeof(name), s, US"_");
2376   if (Ustrcmp(name, "fail") == 0)
2377     {
2378     if (!yes && !skipping)
2379       {
2380       while (isspace(*s)) s++;
2381       if (*s++ != '}') goto FAILED_CURLY;
2382       expand_string_message =
2383         string_sprintf("\"%s\" failed and \"fail\" requested", type);
2384       expand_string_forcedfail = TRUE;
2385       goto FAILED;
2386       }
2387     }
2388   else
2389     {
2390     expand_string_message =
2391       string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
2392     goto FAILED;
2393     }
2394   }
2395
2396 /* All we have to do now is to check on the final closing brace. */
2397
2398 while (isspace(*s)) s++;
2399 if (*s++ == '}') goto RETURN;
2400
2401 /* Get here if there is a bracketing failure */
2402
2403 FAILED_CURLY:
2404 rc++;
2405
2406 /* Get here for other failures */
2407
2408 FAILED:
2409 rc++;
2410
2411 /* Update the input pointer value before returning */
2412
2413 RETURN:
2414 *sptr = s;
2415 return rc;
2416 }
2417
2418
2419
2420
2421
2422
2423 /*************************************************
2424 *    Handle MD5 or SHA-1 computation for HMAC    *
2425 *************************************************/
2426
2427 /* These are some wrapping functions that enable the HMAC code to be a bit
2428 cleaner. A good compiler will spot the tail recursion.
2429
2430 Arguments:
2431   type         HMAC_MD5 or HMAC_SHA1
2432   remaining    are as for the cryptographic hash functions
2433
2434 Returns:       nothing
2435 */
2436
2437 static void
2438 chash_start(int type, void *base)
2439 {
2440 if (type == HMAC_MD5)
2441   md5_start((md5 *)base);
2442 else
2443   sha1_start((sha1 *)base);
2444 }
2445
2446 static void
2447 chash_mid(int type, void *base, uschar *string)
2448 {
2449 if (type == HMAC_MD5)
2450   md5_mid((md5 *)base, string);
2451 else
2452   sha1_mid((sha1 *)base, string);
2453 }
2454
2455 static void
2456 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
2457 {
2458 if (type == HMAC_MD5)
2459   md5_end((md5 *)base, string, length, digest);
2460 else
2461   sha1_end((sha1 *)base, string, length, digest);
2462 }
2463
2464
2465
2466
2467
2468 /*************************************************
2469 *        Join a file onto the output string      *
2470 *************************************************/
2471
2472 /* This is used for readfile and after a run expansion. It joins the contents
2473 of a file onto the output string, globally replacing newlines with a given
2474 string (optionally). The file is closed at the end.
2475
2476 Arguments:
2477   f            the FILE
2478   yield        pointer to the expandable string
2479   sizep        pointer to the current size
2480   ptrp         pointer to the current position
2481   eol          newline replacement string, or NULL
2482
2483 Returns:       new value of string pointer
2484 */
2485
2486 static uschar *
2487 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
2488 {
2489 int eollen;
2490 uschar buffer[1024];
2491
2492 eollen = (eol == NULL)? 0 : Ustrlen(eol);
2493
2494 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
2495   {
2496   int len = Ustrlen(buffer);
2497   if (eol != NULL && buffer[len-1] == '\n') len--;
2498   yield = string_cat(yield, sizep, ptrp, buffer, len);
2499   if (buffer[len] != 0)
2500     yield = string_cat(yield, sizep, ptrp, eol, eollen);
2501   }
2502
2503 if (yield != NULL) yield[*ptrp] = 0;
2504
2505 return yield;
2506 }
2507
2508
2509
2510
2511 /*************************************************
2512 *          Evaluate numeric expression           *
2513 *************************************************/
2514
2515 /* This is a set of mutually recursive functions that evaluate a simple
2516 arithmetic expression involving only + - * / and parentheses. The only one that
2517 is called from elsewhere is eval_expr, whose interface is:
2518
2519 Arguments:
2520   sptr          pointer to the pointer to the string - gets updated
2521   decimal       TRUE if numbers are to be assumed decimal
2522   error         pointer to where to put an error message - must be NULL on input
2523   endket        TRUE if ')' must terminate - FALSE for external call
2524
2525
2526 Returns:        on success: the value of the expression, with *error still NULL
2527                 on failure: an undefined value, with *error = a message
2528 */
2529
2530 static int eval_sumterm(uschar **, BOOL, uschar **);
2531
2532 static int
2533 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
2534 {
2535 uschar *s = *sptr;
2536 int x = eval_sumterm(&s, decimal, error);
2537 if (*error == NULL)
2538   {
2539   while (*s == '+' || *s == '-')
2540     {
2541     int op = *s++;
2542     int y = eval_sumterm(&s, decimal, error);
2543     if (*error != NULL) break;
2544     if (op == '+') x += y; else x -= y;
2545     }
2546   if (*error == NULL)
2547     {
2548     if (endket)
2549       {
2550       if (*s != ')')
2551         *error = US"expecting closing parenthesis";
2552       else
2553         while (isspace(*(++s)));
2554       }
2555     else if (*s != 0) *error = US"expecting + or -";
2556     }
2557   }
2558
2559 *sptr = s;
2560 return x;
2561 }
2562
2563 static int
2564 eval_term(uschar **sptr, BOOL decimal, uschar **error)
2565 {
2566 register int c;
2567 int n;
2568 uschar *s = *sptr;
2569 while (isspace(*s)) s++;
2570 c = *s;
2571 if (isdigit(c) || ((c == '-' || c == '+') && isdigit(s[1])))
2572   {
2573   int count;
2574   (void)sscanf(CS s, (decimal? "%d%n" : "%i%n"), &n, &count);
2575   s += count;
2576   if (tolower(*s) == 'k') { n *= 1024; s++; }
2577     else if (tolower(*s) == 'm') { n *= 1024*1024; s++; }
2578   while (isspace (*s)) s++;
2579   }
2580 else if (c == '(')
2581   {
2582   s++;
2583   n = eval_expr(&s, decimal, error, 1);
2584   }
2585 else
2586   {
2587   *error = US"expecting number or opening parenthesis";
2588   n = 0;
2589   }
2590 *sptr = s;
2591 return n;
2592 }
2593
2594 static int eval_sumterm(uschar **sptr, BOOL decimal, uschar **error)
2595 {
2596 uschar *s = *sptr;
2597 int x = eval_term(&s, decimal, error);
2598 if (*error == NULL)
2599   {
2600   while (*s == '*' || *s == '/')
2601     {
2602     int op = *s++;
2603     int y = eval_term(&s, decimal, error);
2604     if (*error != NULL) break;
2605     if (op == '*') x *= y; else x /= y;
2606     }
2607   }
2608 *sptr = s;
2609 return x;
2610 }
2611
2612
2613
2614
2615 /*************************************************
2616 *                 Expand string                  *
2617 *************************************************/
2618
2619 /* Returns either an unchanged string, or the expanded string in stacking pool
2620 store. Interpreted sequences are:
2621
2622    \...                    normal escaping rules
2623    $name                   substitutes the variable
2624    ${name}                 ditto
2625    ${op:string}            operates on the expanded string value
2626    ${item{arg1}{arg2}...}  expands the args and then does the business
2627                              some literal args are not enclosed in {}
2628
2629 There are now far too many operators and item types to make it worth listing
2630 them here in detail any more.
2631
2632 We use an internal routine recursively to handle embedded substrings. The
2633 external function follows. The yield is NULL if the expansion failed, and there
2634 are two cases: if something collapsed syntactically, or if "fail" was given
2635 as the action on a lookup failure. These can be distinguised by looking at the
2636 variable expand_string_forcedfail, which is TRUE in the latter case.
2637
2638 The skipping flag is set true when expanding a substring that isn't actually
2639 going to be used (after "if" or "lookup") and it prevents lookups from
2640 happening lower down.
2641
2642 Store usage: At start, a store block of the length of the input plus 64
2643 is obtained. This is expanded as necessary by string_cat(), which might have to
2644 get a new block, or might be able to expand the original. At the end of the
2645 function we can release any store above that portion of the yield block that
2646 was actually used. In many cases this will be optimal.
2647
2648 However: if the first item in the expansion is a variable name or header name,
2649 we reset the store before processing it; if the result is in fresh store, we
2650 use that without copying. This is helpful for expanding strings like
2651 $message_headers which can get very long.
2652
2653 Arguments:
2654   string         the string to be expanded
2655   ket_ends       true if expansion is to stop at }
2656   left           if not NULL, a pointer to the first character after the
2657                  expansion is placed here (typically used with ket_ends)
2658   skipping       TRUE for recursive calls when the value isn't actually going
2659                  to be used (to allow for optimisation)
2660
2661 Returns:         NULL if expansion fails:
2662                    expand_string_forcedfail is set TRUE if failure was forced
2663                    expand_string_message contains a textual error message
2664                  a pointer to the expanded string on success
2665 */
2666
2667 static uschar *
2668 expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
2669   BOOL skipping)
2670 {
2671 int ptr = 0;
2672 int size = Ustrlen(string)+ 64;
2673 int item_type;
2674 uschar *yield = store_get(size);
2675 uschar *s = string;
2676 uschar *save_expand_nstring[EXPAND_MAXN+1];
2677 int save_expand_nlength[EXPAND_MAXN+1];
2678
2679 expand_string_forcedfail = FALSE;
2680 expand_string_message = US"";
2681
2682 while (*s != 0)
2683   {
2684   uschar *value;
2685   uschar name[256];
2686
2687   /* \ escapes the next character, which must exist, or else
2688   the expansion fails. There's a special escape, \N, which causes
2689   copying of the subject verbatim up to the next \N. Otherwise,
2690   the escapes are the standard set. */
2691
2692   if (*s == '\\')
2693     {
2694     if (s[1] == 0)
2695       {
2696       expand_string_message = US"\\ at end of string";
2697       goto EXPAND_FAILED;
2698       }
2699
2700     if (s[1] == 'N')
2701       {
2702       uschar *t = s + 2;
2703       for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
2704       yield = string_cat(yield, &size, &ptr, t, s - t);
2705       if (*s != 0) s += 2;
2706       }
2707
2708     else
2709       {
2710       uschar ch[1];
2711       ch[0] = string_interpret_escape(&s);
2712       s++;
2713       yield = string_cat(yield, &size, &ptr, ch, 1);
2714       }
2715
2716     continue;
2717     }
2718
2719   /* Anything other than $ is just copied verbatim, unless we are
2720   looking for a terminating } character. */
2721
2722   if (ket_ends && *s == '}') break;
2723
2724   if (*s != '$')
2725     {
2726     yield = string_cat(yield, &size, &ptr, s++, 1);
2727     continue;
2728     }
2729
2730   /* No { after the $ - must be a plain name or a number for string
2731   match variable. There has to be a fudge for variables that are the
2732   names of header fields preceded by "$header_" because header field
2733   names can contain any printing characters except space and colon.
2734   For those that don't like typing this much, "$h_" is a synonym for
2735   "$header_". A non-existent header yields a NULL value; nothing is
2736   inserted. */
2737
2738   if (isalpha((*(++s))))
2739     {
2740     int len;
2741     int newsize = 0;
2742
2743     s = read_name(name, sizeof(name), s, US"_");
2744
2745     /* If this is the first thing to be expanded, release the pre-allocated
2746     buffer. */
2747
2748     if (ptr == 0 && yield != NULL)
2749       {
2750       store_reset(yield);
2751       yield = NULL;
2752       size = 0;
2753       }
2754
2755     /* Header */
2756
2757     if (Ustrncmp(name, "h_", 2) == 0 ||
2758         Ustrncmp(name, "rh_", 3) == 0 ||
2759         Ustrncmp(name, "bh_", 3) == 0 ||
2760         Ustrncmp(name, "header_", 7) == 0 ||
2761         Ustrncmp(name, "rheader_", 8) == 0 ||
2762         Ustrncmp(name, "bheader_", 8) == 0)
2763       {
2764       BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
2765       uschar *charset = (name[0] == 'b')? NULL : headers_charset;
2766       s = read_header_name(name, sizeof(name), s);
2767       value = find_header(name, FALSE, &newsize, want_raw, charset);
2768
2769       /* If we didn't find the header, and the header contains a closing brace
2770       characters, this may be a user error where the terminating colon
2771       has been omitted. Set a flag to adjust the error message in this case.
2772       But there is no error here - nothing gets inserted. */
2773
2774       if (value == NULL)
2775         {
2776         if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2777         continue;
2778         }
2779       }
2780
2781     /* Variable */
2782
2783     else
2784       {
2785       value = find_variable(name, FALSE, skipping, &newsize);
2786       if (value == NULL)
2787         {
2788         expand_string_message =
2789           string_sprintf("unknown variable name \"%s\"", name);
2790         goto EXPAND_FAILED;
2791         }
2792       }
2793
2794     /* If the data is known to be in a new buffer, newsize will be set to the
2795     size of that buffer. If this is the first thing in an expansion string,
2796     yield will be NULL; just point it at the new store instead of copying. Many
2797     expansion strings contain just one reference, so this is a useful
2798     optimization, especially for humungous headers. */
2799
2800     len = Ustrlen(value);
2801     if (yield == NULL && newsize != 0)
2802       {
2803       yield = value;
2804       size = newsize;
2805       ptr = len;
2806       }
2807     else yield = string_cat(yield, &size, &ptr, value, len);
2808
2809     continue;
2810     }
2811
2812   if (isdigit(*s))
2813     {
2814     int n;
2815     s = read_number(&n, s);
2816     if (n >= 0 && n <= expand_nmax)
2817       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
2818         expand_nlength[n]);
2819     continue;
2820     }
2821
2822   /* Otherwise, if there's no '{' after $ it's an error. */
2823
2824   if (*s != '{')
2825     {
2826     expand_string_message = US"$ not followed by letter, digit, or {";
2827     goto EXPAND_FAILED;
2828     }
2829
2830   /* After { there can be various things, but they all start with
2831   an initial word, except for a number for a string match variable. */
2832
2833   if (isdigit((*(++s))))
2834     {
2835     int n;
2836     s = read_number(&n, s);
2837     if (*s++ != '}')
2838       {
2839       expand_string_message = US"} expected after number";
2840       goto EXPAND_FAILED;
2841       }
2842     if (n >= 0 && n <= expand_nmax)
2843       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
2844         expand_nlength[n]);
2845     continue;
2846     }
2847
2848   if (!isalpha(*s))
2849     {
2850     expand_string_message = US"letter or digit expected after ${";
2851     goto EXPAND_FAILED;
2852     }
2853
2854   /* Allow "-" in names to cater for substrings with negative
2855   arguments. Since we are checking for known names after { this is
2856   OK. */
2857
2858   s = read_name(name, sizeof(name), s, US"_-");
2859   item_type = chop_match(name, item_table, sizeof(item_table)/sizeof(uschar *));
2860
2861   switch(item_type)
2862     {
2863     /* Handle conditionals - preserve the values of the numerical expansion
2864     variables in case they get changed by a regular expression match in the
2865     condition. If not, they retain their external settings. At the end
2866     of this "if" section, they get restored to their previous values. */
2867
2868     case EITEM_IF:
2869       {
2870       BOOL cond = FALSE;
2871       uschar *next_s;
2872       int save_expand_nmax =
2873         save_expand_strings(save_expand_nstring, save_expand_nlength);
2874
2875       while (isspace(*s)) s++;
2876       next_s = eval_condition(s, skipping? NULL : &cond);
2877       if (next_s == NULL) goto EXPAND_FAILED;  /* message already set */
2878
2879       DEBUG(D_expand)
2880         debug_printf("condition: %.*s\n   result: %s\n", (int)(next_s - s), s,
2881           cond? "true" : "false");
2882
2883       s = next_s;
2884
2885       /* The handling of "yes" and "no" result strings is now in a separate
2886       function that is also used by ${lookup} and ${extract} and ${run}. */
2887
2888       switch(process_yesno(
2889                skipping,                     /* were previously skipping */
2890                cond,                         /* success/failure indicator */
2891                lookup_value,                 /* value to reset for string2 */
2892                &s,                           /* input pointer */
2893                &yield,                       /* output pointer */
2894                &size,                        /* output size */
2895                &ptr,                         /* output current point */
2896                US"if"))                      /* condition type */
2897         {
2898         case 1: goto EXPAND_FAILED;          /* when all is well, the */
2899         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
2900         }
2901
2902       /* Restore external setting of expansion variables for continuation
2903       at this level. */
2904
2905       restore_expand_strings(save_expand_nmax, save_expand_nstring,
2906         save_expand_nlength);
2907       continue;
2908       }
2909
2910     /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
2911     expanding an internal string that isn't actually going to be used. All we
2912     need to do is check the syntax, so don't do a lookup at all. Preserve the
2913     values of the numerical expansion variables in case they get changed by a
2914     partial lookup. If not, they retain their external settings. At the end
2915     of this "lookup" section, they get restored to their previous values. */
2916
2917     case EITEM_LOOKUP:
2918       {
2919       int stype, partial, affixlen, starflags;
2920       int expand_setup = 0;
2921       int nameptr = 0;
2922       uschar *key, *filename, *affix;
2923       uschar *save_lookup_value = lookup_value;
2924       int save_expand_nmax =
2925         save_expand_strings(save_expand_nstring, save_expand_nlength);
2926
2927       if ((expand_forbid & RDO_LOOKUP) != 0)
2928         {
2929         expand_string_message = US"lookup expansions are not permitted";
2930         goto EXPAND_FAILED;
2931         }
2932
2933       /* Get the key we are to look up for single-key+file style lookups.
2934       Otherwise set the key NULL pro-tem. */
2935
2936       while (isspace(*s)) s++;
2937       if (*s == '{')
2938         {
2939         key = expand_string_internal(s+1, TRUE, &s, skipping);
2940         if (key == NULL) goto EXPAND_FAILED;
2941         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
2942         while (isspace(*s)) s++;
2943         }
2944       else key = NULL;
2945
2946       /* Find out the type of database */
2947
2948       if (!isalpha(*s))
2949         {
2950         expand_string_message = US"missing lookup type";
2951         goto EXPAND_FAILED;
2952         }
2953
2954       /* The type is a string that may contain special characters of various
2955       kinds. Allow everything except space or { to appear; the actual content
2956       is checked by search_findtype_partial. */
2957
2958       while (*s != 0 && *s != '{' && !isspace(*s))
2959         {
2960         if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
2961         s++;
2962         }
2963       name[nameptr] = 0;
2964       while (isspace(*s)) s++;
2965
2966       /* Now check for the individual search type and any partial or default
2967       options. Only those types that are actually in the binary are valid. */
2968
2969       stype = search_findtype_partial(name, &partial, &affix, &affixlen,
2970         &starflags);
2971       if (stype < 0)
2972         {
2973         expand_string_message = search_error_message;
2974         goto EXPAND_FAILED;
2975         }
2976
2977       /* Check that a key was provided for those lookup types that need it,
2978       and was not supplied for those that use the query style. */
2979
2980       if (!mac_islookup(stype, lookup_querystyle))
2981         {
2982         if (key == NULL)
2983           {
2984           expand_string_message = string_sprintf("missing {key} for single-"
2985             "key \"%s\" lookup", name);
2986           goto EXPAND_FAILED;
2987           }
2988         }
2989       else
2990         {
2991         if (key != NULL)
2992           {
2993           expand_string_message = string_sprintf("a single key was given for "
2994             "lookup type \"%s\", which is not a single-key lookup type", name);
2995           goto EXPAND_FAILED;
2996           }
2997         }
2998
2999       /* Get the next string in brackets and expand it. It is the file name for
3000       single-key+file lookups, and the whole query otherwise. */
3001
3002       if (*s != '{') goto EXPAND_FAILED_CURLY;
3003       filename = expand_string_internal(s+1, TRUE, &s, skipping);
3004       if (filename == NULL) goto EXPAND_FAILED;
3005       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3006       while (isspace(*s)) s++;
3007
3008       /* If this isn't a single-key+file lookup, re-arrange the variables
3009       to be appropriate for the search_ functions. */
3010
3011       if (key == NULL)
3012         {
3013         key = filename;
3014         filename = NULL;
3015         }
3016
3017       /* If skipping, don't do the next bit - just lookup_value == NULL, as if
3018       the entry was not found. Note that there is no search_close() function.
3019       Files are left open in case of re-use. At suitable places in higher logic,
3020       search_tidyup() is called to tidy all open files. This can save opening
3021       the same file several times. However, files may also get closed when
3022       others are opened, if too many are open at once. The rule is that a
3023       handle should not be used after a second search_open().
3024
3025       Request that a partial search sets up $1 and maybe $2 by passing
3026       expand_setup containing zero. If its value changes, reset expand_nmax,
3027       since new variables will have been set. Note that at the end of this
3028       "lookup" section, the old numeric variables are restored. */
3029
3030       if (skipping)
3031         lookup_value = NULL;
3032       else
3033         {
3034         void *handle = search_open(filename, stype, 0, NULL, NULL);
3035         if (handle == NULL)
3036           {
3037           expand_string_message = search_error_message;
3038           goto EXPAND_FAILED;
3039           }
3040         lookup_value = search_find(handle, filename, key, partial, affix,
3041           affixlen, starflags, &expand_setup);
3042         if (search_find_defer)
3043           {
3044           expand_string_message =
3045             string_sprintf("lookup of \"%s\" gave DEFER: %s", key,
3046               search_error_message);
3047           goto EXPAND_FAILED;
3048           }
3049         if (expand_setup > 0) expand_nmax = expand_setup;
3050         }
3051
3052       /* The handling of "yes" and "no" result strings is now in a separate
3053       function that is also used by ${if} and ${extract}. */
3054
3055       switch(process_yesno(
3056                skipping,                     /* were previously skipping */
3057                lookup_value != NULL,         /* success/failure indicator */
3058                save_lookup_value,            /* value to reset for string2 */
3059                &s,                           /* input pointer */
3060                &yield,                       /* output pointer */
3061                &size,                        /* output size */
3062                &ptr,                         /* output current point */
3063                US"lookup"))                  /* condition type */
3064         {
3065         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3066         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3067         }
3068
3069       /* Restore external setting of expansion variables for carrying on
3070       at this level, and continue. */
3071
3072       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3073         save_expand_nlength);
3074       continue;
3075       }
3076
3077     /* If Perl support is configured, handle calling embedded perl subroutines,
3078     unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
3079     or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
3080     arguments (defined below). */
3081
3082     #define EXIM_PERL_MAX_ARGS 8
3083
3084     case EITEM_PERL:
3085     #ifndef EXIM_PERL
3086     expand_string_message = US"\"${perl\" encountered, but this facility "
3087       "is not included in this binary";
3088     goto EXPAND_FAILED;
3089
3090     #else   /* EXIM_PERL */
3091       {
3092       uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
3093       uschar *new_yield;
3094
3095       if ((expand_forbid & RDO_PERL) != 0)
3096         {
3097         expand_string_message = US"Perl calls are not permitted";
3098         goto EXPAND_FAILED;
3099         }
3100
3101       switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
3102            US"perl"))
3103         {
3104         case 1: goto EXPAND_FAILED_CURLY;
3105         case 2:
3106         case 3: goto EXPAND_FAILED;
3107         }
3108
3109       /* If skipping, we don't actually do anything */
3110
3111       if (skipping) continue;
3112
3113       /* Start the interpreter if necessary */
3114
3115       if (!opt_perl_started)
3116         {
3117         uschar *initerror;
3118         if (opt_perl_startup == NULL)
3119           {
3120           expand_string_message = US"A setting of perl_startup is needed when "
3121             "using the Perl interpreter";
3122           goto EXPAND_FAILED;
3123           }
3124         DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
3125         initerror = init_perl(opt_perl_startup);
3126         if (initerror != NULL)
3127           {
3128           expand_string_message =
3129             string_sprintf("error in perl_startup code: %s\n", initerror);
3130           goto EXPAND_FAILED;
3131           }
3132         opt_perl_started = TRUE;
3133         }
3134
3135       /* Call the function */
3136
3137       sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
3138       new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
3139         sub_arg[0], sub_arg + 1);
3140
3141       /* NULL yield indicates failure; if the message pointer has been set to
3142       NULL, the yield was undef, indicating a forced failure. Otherwise the
3143       message will indicate some kind of Perl error. */
3144
3145       if (new_yield == NULL)
3146         {
3147         if (expand_string_message == NULL)
3148           {
3149           expand_string_message =
3150             string_sprintf("Perl subroutine \"%s\" returned undef to force "
3151               "failure", sub_arg[0]);
3152           expand_string_forcedfail = TRUE;
3153           }
3154         goto EXPAND_FAILED;
3155         }
3156
3157       /* Yield succeeded. Ensure forcedfail is unset, just in case it got
3158       set during a callback from Perl. */
3159
3160       expand_string_forcedfail = FALSE;
3161       yield = new_yield;
3162       continue;
3163       }
3164     #endif /* EXIM_PERL */
3165
3166     /* Handle "readfile" to insert an entire file */
3167
3168     case EITEM_READFILE:
3169       {
3170       FILE *f;
3171       uschar *sub_arg[2];
3172
3173       if ((expand_forbid & RDO_READFILE) != 0)
3174         {
3175         expand_string_message = US"file insertions are not permitted";
3176         goto EXPAND_FAILED;
3177         }
3178
3179       switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile"))
3180         {
3181         case 1: goto EXPAND_FAILED_CURLY;
3182         case 2:
3183         case 3: goto EXPAND_FAILED;
3184         }
3185
3186       /* If skipping, we don't actually do anything */
3187
3188       if (skipping) continue;
3189
3190       /* Open the file and read it */
3191
3192       f = Ufopen(sub_arg[0], "rb");
3193       if (f == NULL)
3194         {
3195         expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
3196         goto EXPAND_FAILED;
3197         }
3198
3199       yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
3200       fclose(f);
3201       continue;
3202       }
3203
3204     /* Handle "readsocket" to insert data from a Unix domain socket */
3205
3206     case EITEM_READSOCK:
3207       {
3208       int fd;
3209       int timeout = 5;
3210       int save_ptr = ptr;
3211       FILE *f;
3212       struct sockaddr_un sockun;         /* don't call this "sun" ! */
3213       uschar *arg;
3214       uschar *sub_arg[4];
3215
3216       if ((expand_forbid & RDO_READSOCK) != 0)
3217         {
3218         expand_string_message = US"socket insertions are not permitted";
3219         goto EXPAND_FAILED;
3220         }
3221
3222       /* Read up to 4 arguments, but don't do the end of item check afterwards,
3223       because there may be a string for expansion on failure. */
3224
3225       switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket"))
3226         {
3227         case 1: goto EXPAND_FAILED_CURLY;
3228         case 2:                             /* Won't occur: no end check */
3229         case 3: goto EXPAND_FAILED;
3230         }
3231
3232       /* Sort out timeout, if given */
3233
3234       if (sub_arg[2] != NULL)
3235         {
3236         timeout = readconf_readtime(sub_arg[2], 0, FALSE);
3237         if (timeout < 0)
3238           {
3239           expand_string_message = string_sprintf("bad time value %s",
3240             sub_arg[2]);
3241           goto EXPAND_FAILED;
3242           }
3243         }
3244       else sub_arg[3] = NULL;                     /* No eol if no timeout */
3245
3246       /* If skipping, we don't actually do anything */
3247
3248       if (!skipping)
3249         {
3250         /* Make a connection to the socket */
3251
3252         if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
3253           {
3254           expand_string_message = string_sprintf("failed to create socket: %s",
3255             strerror(errno));
3256           goto SOCK_FAIL;
3257           }
3258
3259         sockun.sun_family = AF_UNIX;
3260         sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
3261           sub_arg[0]);
3262         if(connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
3263           {
3264           expand_string_message = string_sprintf("failed to connect to socket "
3265             "%s: %s", sub_arg[0], strerror(errno));
3266           goto SOCK_FAIL;
3267           }
3268         DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
3269
3270         /* Write the request string, if not empty */
3271
3272         if (sub_arg[1][0] != 0)
3273           {
3274           int len = Ustrlen(sub_arg[1]);
3275           DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
3276             sub_arg[1]);
3277           if (write(fd, sub_arg[1], len) != len)
3278             {
3279             expand_string_message = string_sprintf("request write to socket "
3280               "failed: %s", strerror(errno));
3281             goto SOCK_FAIL;
3282             }
3283           }
3284
3285         /* Now we need to read from the socket, under a timeout. The function
3286         that reads a file can be used. */
3287
3288         f = fdopen(fd, "rb");
3289         sigalrm_seen = FALSE;
3290         alarm(timeout);
3291         yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
3292         alarm(0);
3293         fclose(f);
3294
3295         /* After a timeout, we restore the pointer in the result, that is,
3296         make sure we add nothing from the socket. */
3297
3298         if (sigalrm_seen)
3299           {
3300           ptr = save_ptr;
3301           expand_string_message = US"socket read timed out";
3302           goto SOCK_FAIL;
3303           }
3304         }
3305
3306       /* The whole thing has worked (or we were skipping). If there is a
3307       failure string following, we need to skip it. */
3308
3309       if (*s == '{')
3310         {
3311         if (expand_string_internal(s+1, TRUE, &s, TRUE) == NULL)
3312           goto EXPAND_FAILED;
3313         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3314         while (isspace(*s)) s++;
3315         }
3316       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3317       continue;
3318
3319       /* Come here on failure to create socket, connect socket, write to the
3320       socket, or timeout on reading. If another substring follows, expand and
3321       use it. Otherwise, those conditions give expand errors. */
3322
3323       SOCK_FAIL:
3324       if (*s != '{') goto EXPAND_FAILED;
3325       DEBUG(D_any) debug_printf("%s\n", expand_string_message);
3326       arg = expand_string_internal(s+1, TRUE, &s, FALSE);
3327       if (arg == NULL) goto EXPAND_FAILED;
3328       yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
3329       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3330       while (isspace(*s)) s++;
3331       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3332       continue;
3333       }
3334
3335     /* Handle "run" to execute a program. */
3336
3337     case EITEM_RUN:
3338       {
3339       FILE *f;
3340       uschar *arg;
3341       uschar **argv;
3342       pid_t pid;
3343       int fd_in, fd_out;
3344       int lsize = 0;
3345       int lptr = 0;
3346
3347       if ((expand_forbid & RDO_RUN) != 0)
3348         {
3349         expand_string_message = US"running a command is not permitted";
3350         goto EXPAND_FAILED;
3351         }
3352
3353       while (isspace(*s)) s++;
3354       if (*s != '{') goto EXPAND_FAILED_CURLY;
3355       arg = expand_string_internal(s+1, TRUE, &s, skipping);
3356       if (arg == NULL) goto EXPAND_FAILED;
3357       while (isspace(*s)) s++;
3358       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3359
3360       if (skipping)   /* Just pretend it worked when we're skipping */
3361         {
3362         runrc = 0;
3363         }
3364       else
3365         {
3366         if (!transport_set_up_command(&argv,    /* anchor for arg list */
3367             arg,                                /* raw command */
3368             FALSE,                              /* don't expand the arguments */
3369             0,                                  /* not relevant when... */
3370             NULL,                               /* no transporting address */
3371             US"${run} expansion",               /* for error messages */
3372             &expand_string_message))            /* where to put error message */
3373           {
3374           goto EXPAND_FAILED;
3375           }
3376
3377         /* Create the child process, making it a group leader. */
3378
3379         pid = child_open(argv, NULL, 0077, &fd_in, &fd_out, TRUE);
3380
3381         if (pid < 0)
3382           {
3383           expand_string_message =
3384             string_sprintf("couldn't create child process: %s", strerror(errno));
3385           goto EXPAND_FAILED;
3386           }
3387
3388         /* Nothing is written to the standard input. */
3389
3390         close(fd_in);
3391
3392         /* Wait for the process to finish, applying the timeout, and inspect its
3393         return code for serious disasters. Simple non-zero returns are passed on.
3394         */
3395
3396         if ((runrc = child_close(pid, 60)) < 0)
3397           {
3398           if (runrc == -256)
3399             {
3400             expand_string_message = string_sprintf("command timed out");
3401             killpg(pid, SIGKILL);       /* Kill the whole process group */
3402             }
3403
3404           else if (runrc == -257)
3405             expand_string_message = string_sprintf("wait() failed: %s",
3406               strerror(errno));
3407
3408           else
3409             expand_string_message = string_sprintf("command killed by signal %d",
3410               -runrc);
3411
3412           goto EXPAND_FAILED;
3413           }
3414
3415         /* Read the pipe to get the command's output into $value (which is kept
3416         in lookup_value). */
3417
3418         f = fdopen(fd_out, "rb");
3419         lookup_value = NULL;
3420         lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
3421         fclose(f);
3422         }
3423
3424       /* Process the yes/no strings; $value may be useful in both cases */
3425
3426       switch(process_yesno(
3427                skipping,                     /* were previously skipping */
3428                runrc == 0,                   /* success/failure indicator */
3429                lookup_value,                 /* value to reset for string2 */
3430                &s,                           /* input pointer */
3431                &yield,                       /* output pointer */
3432                &size,                        /* output size */
3433                &ptr,                         /* output current point */
3434                US"run"))                     /* condition type */
3435         {
3436         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3437         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3438         }
3439
3440       continue;
3441       }
3442
3443     /* Handle character translation for "tr" */
3444
3445     case EITEM_TR:
3446       {
3447       int oldptr = ptr;
3448       int o2m;
3449       uschar *sub[3];
3450
3451       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr"))
3452         {
3453         case 1: goto EXPAND_FAILED_CURLY;
3454         case 2:
3455         case 3: goto EXPAND_FAILED;
3456         }
3457
3458       yield = string_cat(yield, &size, &ptr, sub[0], Ustrlen(sub[0]));
3459       o2m = Ustrlen(sub[2]) - 1;
3460
3461       if (o2m >= 0) for (; oldptr < ptr; oldptr++)
3462         {
3463         uschar *m = Ustrrchr(sub[1], yield[oldptr]);
3464         if (m != NULL)
3465           {
3466           int o = m - sub[1];
3467           yield[oldptr] = sub[2][(o < o2m)? o : o2m];
3468           }
3469         }
3470
3471       continue;
3472       }
3473
3474     /* Handle "hash", "length", "nhash", and "substr" when they are given with
3475     expanded arguments. */
3476
3477     case EITEM_HASH:
3478     case EITEM_LENGTH:
3479     case EITEM_NHASH:
3480     case EITEM_SUBSTR:
3481       {
3482       int i;
3483       int len;
3484       uschar *ret;
3485       int val[2] = { 0, -1 };
3486       uschar *sub[3];
3487
3488       /* "length" takes only 2 arguments whereas the others take 2 or 3.
3489       Ensure that sub[2] is set in the ${length case. */
3490
3491       sub[2] = NULL;
3492       switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
3493              TRUE, name))
3494         {
3495         case 1: goto EXPAND_FAILED_CURLY;
3496         case 2:
3497         case 3: goto EXPAND_FAILED;
3498         }
3499
3500       /* Juggle the arguments if there are only two of them: always move the
3501       string to the last position and make ${length{n}{str}} equivalent to
3502       ${substr{0}{n}{str}}. See the defaults for val[] above. */
3503
3504       if (sub[2] == NULL)
3505         {
3506         sub[2] = sub[1];
3507         sub[1] = NULL;
3508         if (item_type == EITEM_LENGTH)
3509           {
3510           sub[1] = sub[0];
3511           sub[0] = NULL;
3512           }
3513         }
3514
3515       for (i = 0; i < 2; i++)
3516         {
3517         if (sub[i] == NULL) continue;
3518         val[i] = (int)Ustrtol(sub[i], &ret, 10);
3519         if (*ret != 0 || (i != 0 && val[i] < 0))
3520           {
3521           expand_string_message = string_sprintf("\"%s\" is not a%s number "
3522             "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
3523           goto EXPAND_FAILED;
3524           }
3525         }
3526
3527       ret =
3528         (item_type == EITEM_HASH)?
3529           compute_hash(sub[2], val[0], val[1], &len) :
3530         (item_type == EITEM_NHASH)?
3531           compute_nhash(sub[2], val[0], val[1], &len) :
3532           extract_substr(sub[2], val[0], val[1], &len);
3533
3534       if (ret == NULL) goto EXPAND_FAILED;
3535       yield = string_cat(yield, &size, &ptr, ret, len);
3536       continue;
3537       }
3538
3539     /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
3540     This code originally contributed by Steve Haslam. It currently supports
3541     the use of MD5 and SHA-1 hashes.
3542
3543     We need some workspace that is large enough to handle all the supported
3544     hash types. Use macros to set the sizes rather than be too elaborate. */
3545
3546     #define MAX_HASHLEN      20
3547     #define MAX_HASHBLOCKLEN 64
3548
3549     case EITEM_HMAC:
3550       {
3551       uschar *sub[3];
3552       md5 md5_base;
3553       sha1 sha1_base;
3554       void *use_base;
3555       int type, i;
3556       int hashlen;      /* Number of octets for the hash algorithm's output */
3557       int hashblocklen; /* Number of octets the hash algorithm processes */
3558       uschar *keyptr, *p;
3559       unsigned int keylen;
3560
3561       uschar keyhash[MAX_HASHLEN];
3562       uschar innerhash[MAX_HASHLEN];
3563       uschar finalhash[MAX_HASHLEN];
3564       uschar finalhash_hex[2*MAX_HASHLEN];
3565       uschar innerkey[MAX_HASHBLOCKLEN];
3566       uschar outerkey[MAX_HASHBLOCKLEN];
3567
3568       switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name))
3569         {
3570         case 1: goto EXPAND_FAILED_CURLY;
3571         case 2:
3572         case 3: goto EXPAND_FAILED;
3573         }
3574
3575       if (Ustrcmp(sub[0], "md5") == 0)
3576         {
3577         type = HMAC_MD5;
3578         use_base = &md5_base;
3579         hashlen = 16;
3580         hashblocklen = 64;
3581         }
3582       else if (Ustrcmp(sub[0], "sha1") == 0)
3583         {
3584         type = HMAC_SHA1;
3585         use_base = &sha1_base;
3586         hashlen = 20;
3587         hashblocklen = 64;
3588         }
3589       else
3590         {
3591         expand_string_message =
3592           string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
3593         goto EXPAND_FAILED;
3594         }
3595
3596       keyptr = sub[1];
3597       keylen = Ustrlen(keyptr);
3598
3599       /* If the key is longer than the hash block length, then hash the key
3600       first */
3601
3602       if (keylen > hashblocklen)
3603         {
3604         chash_start(type, use_base);
3605         chash_end(type, use_base, keyptr, keylen, keyhash);
3606         keyptr = keyhash;
3607         keylen = hashlen;
3608         }
3609
3610       /* Now make the inner and outer key values */
3611
3612       memset(innerkey, 0x36, hashblocklen);
3613       memset(outerkey, 0x5c, hashblocklen);
3614
3615       for (i = 0; i < keylen; i++)
3616         {
3617         innerkey[i] ^= keyptr[i];
3618         outerkey[i] ^= keyptr[i];
3619         }
3620
3621       /* Now do the hashes */
3622
3623       chash_start(type, use_base);
3624       chash_mid(type, use_base, innerkey);
3625       chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
3626
3627       chash_start(type, use_base);
3628       chash_mid(type, use_base, outerkey);
3629       chash_end(type, use_base, innerhash, hashlen, finalhash);
3630
3631       /* Encode the final hash as a hex string */
3632
3633       p = finalhash_hex;
3634       for (i = 0; i < hashlen; i++)
3635         {
3636         *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
3637         *p++ = hex_digits[finalhash[i] & 0x0f];
3638         }
3639
3640       DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
3641         (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
3642
3643       yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
3644       }
3645
3646     continue;
3647
3648     /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
3649     We have to save the numerical variables and restore them afterwards. */
3650
3651     case EITEM_SG:
3652       {
3653       const pcre *re;
3654       int moffset, moffsetextra, slen;
3655       int roffset;
3656       int emptyopt;
3657       const uschar *rerror;
3658       uschar *subject;
3659       uschar *sub[3];
3660       int save_expand_nmax =
3661         save_expand_strings(save_expand_nstring, save_expand_nlength);
3662
3663       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg"))
3664         {
3665         case 1: goto EXPAND_FAILED_CURLY;
3666         case 2:
3667         case 3: goto EXPAND_FAILED;
3668         }
3669
3670       /* Compile the regular expression */
3671
3672       re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
3673         NULL);
3674
3675       if (re == NULL)
3676         {
3677         expand_string_message = string_sprintf("regular expression error in "
3678           "\"%s\": %s at offset %d", sub[1], rerror, roffset);
3679         goto EXPAND_FAILED;
3680         }
3681
3682       /* Now run a loop to do the substitutions as often as necessary. It ends
3683       when there are no more matches. Take care over matches of the null string;
3684       do the same thing as Perl does. */
3685
3686       subject = sub[0];
3687       slen = Ustrlen(sub[0]);
3688       moffset = moffsetextra = 0;
3689       emptyopt = 0;
3690
3691       for (;;)
3692         {
3693         int ovector[3*(EXPAND_MAXN+1)];
3694         int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
3695           PCRE_EOPT | emptyopt, ovector, sizeof(ovector)/sizeof(int));
3696         int nn;
3697         uschar *insert;
3698
3699         /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
3700         is not necessarily the end. We want to repeat the match from one
3701         character further along, but leaving the basic offset the same (for
3702         copying below). We can't be at the end of the string - that was checked
3703         before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
3704         finished; copy the remaining string and end the loop. */
3705
3706         if (n < 0)
3707           {
3708           if (emptyopt != 0)
3709             {
3710             moffsetextra = 1;
3711             emptyopt = 0;
3712             continue;
3713             }
3714           yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
3715           break;
3716           }
3717
3718         /* Match - set up for expanding the replacement. */
3719
3720         if (n == 0) n = EXPAND_MAXN + 1;
3721         expand_nmax = 0;
3722         for (nn = 0; nn < n*2; nn += 2)
3723           {
3724           expand_nstring[expand_nmax] = subject + ovector[nn];
3725           expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
3726           }
3727         expand_nmax--;
3728
3729         /* Copy the characters before the match, plus the expanded insertion. */
3730
3731         yield = string_cat(yield, &size, &ptr, subject + moffset,
3732           ovector[0] - moffset);
3733         insert = expand_string(sub[2]);
3734         if (insert == NULL) goto EXPAND_FAILED;
3735         yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
3736
3737         moffset = ovector[1];
3738         moffsetextra = 0;
3739         emptyopt = 0;
3740
3741         /* If we have matched an empty string, first check to see if we are at
3742         the end of the subject. If so, the loop is over. Otherwise, mimic
3743         what Perl's /g options does. This turns out to be rather cunning. First
3744         we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
3745         string at the same point. If this fails (picked up above) we advance to
3746         the next character. */
3747
3748         if (ovector[0] == ovector[1])
3749           {
3750           if (ovector[0] == slen) break;
3751           emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
3752           }
3753         }
3754
3755       /* All done - restore numerical variables. */
3756
3757       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3758         save_expand_nlength);
3759       continue;
3760       }
3761
3762     /* Handle keyed and numbered substring extraction. If the first argument
3763     consists entirely of digits, then a numerical extraction is assumed. */
3764
3765     case EITEM_EXTRACT:
3766       {
3767       int i;
3768       int j = 2;
3769       int field_number = 1;
3770       BOOL field_number_set = FALSE;
3771       uschar *save_lookup_value = lookup_value;
3772       uschar *sub[3];
3773       int save_expand_nmax =
3774         save_expand_strings(save_expand_nstring, save_expand_nlength);
3775
3776       /* Read the arguments */
3777
3778       for (i = 0; i < j; i++)
3779         {
3780         while (isspace(*s)) s++;
3781         if (*s == '{')
3782           {
3783           sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
3784           if (sub[i] == NULL) goto EXPAND_FAILED;
3785           if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3786
3787           /* After removal of leading and trailing white space, the first
3788           argument must not be empty; if it consists entirely of digits
3789           (optionally preceded by a minus sign), this is a numerical
3790           extraction, and we expect 3 arguments. */
3791
3792           if (i == 0)
3793             {
3794             int len;
3795             int x = 0;
3796             uschar *p = sub[0];
3797
3798             while (isspace(*p)) p++;
3799             sub[0] = p;
3800
3801             len = Ustrlen(p);
3802             while (len > 0 && isspace(p[len-1])) len--;
3803             p[len] = 0;
3804
3805             if (*p == 0)
3806               {
3807               expand_string_message = US"first argument of \"extract\" must "
3808                 "not be empty";
3809               goto EXPAND_FAILED;
3810               }
3811
3812             if (*p == '-')
3813               {
3814               field_number = -1;
3815               p++;
3816               }
3817             while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
3818             if (*p == 0)
3819               {
3820               field_number *= x;
3821               j = 3;               /* Need 3 args */
3822               field_number_set = TRUE;
3823               }
3824             }
3825           }
3826         else goto EXPAND_FAILED_CURLY;
3827         }
3828
3829       /* Extract either the numbered or the keyed substring into $value. If
3830       skipping, just pretend the extraction failed. */
3831
3832       lookup_value = skipping? NULL : field_number_set?
3833         expand_gettokened(field_number, sub[1], sub[2]) :
3834         expand_getkeyed(sub[0], sub[1]);
3835
3836       /* If no string follows, $value gets substituted; otherwise there can
3837       be yes/no strings, as for lookup or if. */
3838
3839       switch(process_yesno(
3840                skipping,                     /* were previously skipping */
3841                lookup_value != NULL,         /* success/failure indicator */
3842                save_lookup_value,            /* value to reset for string2 */
3843                &s,                           /* input pointer */
3844                &yield,                       /* output pointer */
3845                &size,                        /* output size */
3846                &ptr,                         /* output current point */
3847                US"extract"))                 /* condition type */
3848         {
3849         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3850         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3851         }
3852
3853       /* All done - restore numerical variables. */
3854
3855       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3856         save_expand_nlength);
3857
3858       continue;
3859       }
3860
3861
3862     /* If ${dlfunc support is configured, handle calling dynamically-loaded
3863     functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
3864     or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
3865     a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
3866
3867     #define EXPAND_DLFUNC_MAX_ARGS 8
3868
3869     case EITEM_DLFUNC:
3870     #ifndef EXPAND_DLFUNC
3871     expand_string_message = US"\"${dlfunc\" encountered, but this facility "
3872       "is not included in this binary";
3873     goto EXPAND_FAILED;
3874
3875     #else   /* EXPAND_DLFUNC */
3876       {
3877       tree_node *t;
3878       exim_dlfunc_t *func;
3879       uschar *result;
3880       int status, argc;
3881       uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
3882
3883       if ((expand_forbid & RDO_DLFUNC) != 0)
3884         {
3885         expand_string_message =
3886           US"dynamically-loaded functions are not permitted";
3887         goto EXPAND_FAILED;
3888         }
3889
3890       switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
3891            TRUE, US"dlfunc"))
3892         {
3893         case 1: goto EXPAND_FAILED_CURLY;
3894         case 2:
3895         case 3: goto EXPAND_FAILED;
3896         }
3897
3898       /* If skipping, we don't actually do anything */
3899
3900       if (skipping) continue;
3901
3902       /* Look up the dynamically loaded object handle in the tree. If it isn't
3903       found, dlopen() the file and put the handle in the tree for next time. */
3904
3905       t = tree_search(dlobj_anchor, argv[0]);
3906       if (t == NULL)
3907         {
3908         void *handle = dlopen(CS argv[0], RTLD_LAZY);
3909         if (handle == NULL)
3910           {
3911           expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
3912             argv[0], dlerror());
3913           log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
3914           goto EXPAND_FAILED;
3915           }
3916         t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
3917         Ustrcpy(t->name, argv[0]);
3918         t->data.ptr = handle;
3919         (void)tree_insertnode(&dlobj_anchor, t);
3920         }
3921
3922       /* Having obtained the dynamically loaded object handle, look up the
3923       function pointer. */
3924
3925       func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
3926       if (func == NULL)
3927         {
3928         expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
3929           "%s", argv[1], argv[0], dlerror());
3930         log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
3931         goto EXPAND_FAILED;
3932         }
3933
3934       /* Call the function and work out what to do with the result. If it
3935       returns OK, we have a replacement string; if it returns DEFER then
3936       expansion has failed in a non-forced manner; if it returns FAIL then
3937       failure was forced; if it returns ERROR or any other value there's a
3938       problem, so panic slightly. */
3939
3940       result = NULL;
3941       for (argc = 0; argv[argc] != NULL; argc++);
3942       status = func(&result, argc - 2, &argv[2]);
3943       if(status == OK)
3944         {
3945         if (result == NULL) result = US"";
3946         yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
3947         continue;
3948         }
3949       else
3950         {
3951         expand_string_message = result == NULL ? US"(no message)" : result;
3952         if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
3953           else if(status != FAIL)
3954             log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
3955               argv[0], argv[1], status, expand_string_message);
3956         goto EXPAND_FAILED;
3957         }
3958       }
3959     #endif /* EXPAND_DLFUNC */
3960     }
3961
3962   /* Control reaches here if the name is not recognized as one of the more
3963   complicated expansion items. Check for the "operator" syntax (name terminated
3964   by a colon). Some of the operators have arguments, separated by _ from the
3965   name. */
3966
3967   if (*s == ':')
3968     {
3969     int c;
3970     uschar *arg = NULL;
3971     uschar *sub = expand_string_internal(s+1, TRUE, &s, skipping);
3972     if (sub == NULL) goto EXPAND_FAILED;
3973     s++;
3974
3975     /* Owing to an historical mis-design, an underscore may be part of the
3976     operator name, or it may introduce arguments.  We therefore first scan the
3977     table of names that contain underscores. If there is no match, we cut off
3978     the arguments and then scan the main table. */
3979
3980     c = chop_match(name, op_table_underscore,
3981       sizeof(op_table_underscore)/sizeof(uschar *));
3982
3983     if (c < 0)
3984       {
3985       arg = Ustrchr(name, '_');
3986       if (arg != NULL) *arg = 0;
3987       c = chop_match(name, op_table_main,
3988         sizeof(op_table_main)/sizeof(uschar *));
3989       if (c >= 0) c += sizeof(op_table_underscore)/sizeof(uschar *);
3990       if (arg != NULL) *arg++ = '_';   /* Put back for error messages */
3991       }
3992
3993     /* If we are skipping, we don't need to perform the operation at all.
3994     This matters for operations like "mask", because the data may not be
3995     in the correct format when skipping. For example, the expression may test
3996     for the existence of $sender_host_address before trying to mask it. For
3997     other operations, doing them may not fail, but it is a waste of time. */
3998
3999     if (skipping && c >= 0) continue;
4000
4001     /* Otherwise, switch on the operator type */
4002
4003     switch(c)
4004       {
4005       case EOP_BASE62:
4006         {
4007         uschar *t;
4008         unsigned long int n = Ustrtoul(sub, &t, 10);
4009         if (*t != 0)
4010           {
4011           expand_string_message = string_sprintf("argument for base62 "
4012             "operator is \"%s\", which is not a decimal number", sub);
4013           goto EXPAND_FAILED;
4014           }
4015         t = string_base62(n);
4016         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4017         continue;
4018         }
4019
4020       case EOP_BASE62D:
4021         {
4022         uschar buf[16];
4023         uschar *tt = sub;
4024         unsigned long int n = 0;
4025         while (*tt != 0)
4026           {
4027           uschar *t = Ustrchr(base62_chars, *tt++);
4028           if (t == NULL)
4029             {
4030             expand_string_message = string_sprintf("argument for base62d "
4031               "operator is \"%s\", which is not a base 62 number", sub);
4032             goto EXPAND_FAILED;
4033             }
4034           n = n * 62 + (t - base62_chars);
4035           }
4036         (void)sprintf(CS buf, "%ld", n);
4037         yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
4038         continue;
4039         }
4040
4041       case EOP_EXPAND:
4042         {
4043         uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping);
4044         if (expanded == NULL)
4045           {
4046           expand_string_message =
4047             string_sprintf("internal expansion of \"%s\" failed: %s", sub,
4048               expand_string_message);
4049           goto EXPAND_FAILED;
4050           }
4051         yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
4052         continue;
4053         }
4054
4055       case EOP_LC:
4056         {
4057         int count = 0;
4058         uschar *t = sub - 1;
4059         while (*(++t) != 0) { *t = tolower(*t); count++; }
4060         yield = string_cat(yield, &size, &ptr, sub, count);
4061         continue;
4062         }
4063
4064       case EOP_UC:
4065         {
4066         int count = 0;
4067         uschar *t = sub - 1;
4068         while (*(++t) != 0) { *t = toupper(*t); count++; }
4069         yield = string_cat(yield, &size, &ptr, sub, count);
4070         continue;
4071         }
4072
4073       case EOP_MD5:
4074         {
4075         md5 base;
4076         uschar digest[16];
4077         int j;
4078         char st[33];
4079         md5_start(&base);
4080         md5_end(&base, sub, Ustrlen(sub), digest);
4081         for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
4082         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4083         continue;
4084         }
4085
4086       case EOP_SHA1:
4087         {
4088         sha1 base;
4089         uschar digest[20];
4090         int j;
4091         char st[41];
4092         sha1_start(&base);
4093         sha1_end(&base, sub, Ustrlen(sub), digest);
4094         for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
4095         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4096         continue;
4097         }
4098
4099       /* Convert hex encoding to base64 encoding */
4100
4101       case EOP_HEX2B64:
4102         {
4103         int c = 0;
4104         int b = -1;
4105         uschar *in = sub;
4106         uschar *out = sub;
4107         uschar *enc;
4108
4109         for (enc = sub; *enc != 0; enc++)
4110           {
4111           if (!isxdigit(*enc))
4112             {
4113             expand_string_message = string_sprintf("\"%s\" is not a hex "
4114               "string", sub);
4115             goto EXPAND_FAILED;
4116             }
4117           c++;
4118           }
4119
4120         if ((c & 1) != 0)
4121           {
4122           expand_string_message = string_sprintf("\"%s\" contains an odd "
4123             "number of characters", sub);
4124           goto EXPAND_FAILED;
4125           }
4126
4127         while ((c = *in++) != 0)
4128           {
4129           if (isdigit(c)) c -= '0';
4130           else c = toupper(c) - 'A' + 10;
4131           if (b == -1)
4132             {
4133             b = c << 4;
4134             }
4135           else
4136             {
4137             *out++ = b | c;
4138             b = -1;
4139             }
4140           }
4141
4142         enc = auth_b64encode(sub, out - sub);
4143         yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
4144         continue;
4145         }
4146
4147       /* mask applies a mask to an IP address; for example the result of
4148       ${mask:131.111.10.206/28} is 131.111.10.192/28. */
4149
4150       case EOP_MASK:
4151         {
4152         int count;
4153         uschar *endptr;
4154         int binary[4];
4155         int mask, maskoffset;
4156         int type = string_is_ip_address(sub, &maskoffset);
4157         uschar buffer[64];
4158
4159         if (type == 0)
4160           {
4161           expand_string_message = string_sprintf("\"%s\" is not an IP address",
4162            sub);
4163           goto EXPAND_FAILED;
4164           }
4165
4166         if (maskoffset == 0)
4167           {
4168           expand_string_message = string_sprintf("missing mask value in \"%s\"",
4169             sub);
4170           goto EXPAND_FAILED;
4171           }
4172
4173         mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
4174
4175         if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
4176           {
4177           expand_string_message = string_sprintf("mask value too big in \"%s\"",
4178             sub);
4179           goto EXPAND_FAILED;
4180           }
4181
4182         /* Convert the address to binary integer(s) and apply the mask */
4183
4184         sub[maskoffset] = 0;
4185         count = host_aton(sub, binary);
4186         host_mask(count, binary, mask);
4187
4188         /* Convert to masked textual format and add to output. */
4189
4190         yield = string_cat(yield, &size, &ptr, buffer,
4191           host_nmtoa(count, binary, mask, buffer, '.'));
4192         continue;
4193         }
4194
4195       case EOP_ADDRESS:
4196       case EOP_LOCAL_PART:
4197       case EOP_DOMAIN:
4198         {
4199         uschar *error;
4200         int start, end, domain;
4201         uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
4202           FALSE);
4203         if (t != NULL)
4204           {
4205           if (c != EOP_DOMAIN)
4206             {
4207             if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
4208             yield = string_cat(yield, &size, &ptr, sub+start, end-start);
4209             }
4210           else if (domain != 0)
4211             {
4212             domain += start;
4213             yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
4214             }
4215           }
4216         continue;
4217         }
4218
4219       /* quote puts a string in quotes if it is empty or contains anything
4220       other than alphamerics, underscore, dot, or hyphen.
4221
4222       quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
4223       be quoted in order to be a valid local part.
4224
4225       In both cases, newlines and carriage returns are converted into \n and \r
4226       respectively */
4227
4228       case EOP_QUOTE:
4229       case EOP_QUOTE_LOCAL_PART:
4230       if (arg == NULL)
4231         {
4232         BOOL needs_quote = (*sub == 0);      /* TRUE for empty string */
4233         uschar *t = sub - 1;
4234
4235         if (c == EOP_QUOTE)
4236           {
4237           while (!needs_quote && *(++t) != 0)
4238             needs_quote = !isalnum(*t) && !strchr("_-.", *t);
4239           }
4240         else  /* EOP_QUOTE_LOCAL_PART */
4241           {
4242           while (!needs_quote && *(++t) != 0)
4243             needs_quote = !isalnum(*t) &&
4244               strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
4245               (*t != '.' || t == sub || t[1] == 0);
4246           }
4247
4248         if (needs_quote)
4249           {
4250           yield = string_cat(yield, &size, &ptr, US"\"", 1);
4251           t = sub - 1;
4252           while (*(++t) != 0)
4253             {
4254             if (*t == '\n')
4255               yield = string_cat(yield, &size, &ptr, US"\\n", 2);
4256             else if (*t == '\r')
4257               yield = string_cat(yield, &size, &ptr, US"\\r", 2);
4258             else
4259               {
4260               if (*t == '\\' || *t == '"')
4261                 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4262               yield = string_cat(yield, &size, &ptr, t, 1);
4263               }
4264             }
4265           yield = string_cat(yield, &size, &ptr, US"\"", 1);
4266           }
4267         else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4268         continue;
4269         }
4270
4271       /* quote_lookuptype does lookup-specific quoting */
4272
4273       else
4274         {
4275         int n;
4276         uschar *opt = Ustrchr(arg, '_');
4277
4278         if (opt != NULL) *opt++ = 0;
4279
4280         n = search_findtype(arg, Ustrlen(arg));
4281         if (n < 0)
4282           {
4283           expand_string_message = search_error_message;
4284           goto EXPAND_FAILED;
4285           }
4286
4287         if (lookup_list[n].quote != NULL)
4288           sub = (lookup_list[n].quote)(sub, opt);
4289         else if (opt != NULL) sub = NULL;
4290
4291         if (sub == NULL)
4292           {
4293           expand_string_message = string_sprintf(
4294             "\"%s\" unrecognized after \"${quote_%s\"",
4295             opt, arg);
4296           goto EXPAND_FAILED;
4297           }
4298
4299         yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4300         continue;
4301         }
4302
4303       /* rx quote sticks in \ before any non-alphameric character so that
4304       the insertion works in a regular expression. */
4305
4306       case EOP_RXQUOTE:
4307         {
4308         uschar *t = sub - 1;
4309         while (*(++t) != 0)
4310           {
4311           if (!isalnum(*t))
4312             yield = string_cat(yield, &size, &ptr, US"\\", 1);
4313           yield = string_cat(yield, &size, &ptr, t, 1);
4314           }
4315         continue;
4316         }
4317
4318       /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
4319       prescribed by the RFC, if there are characters that need to be encoded */
4320
4321       case EOP_RFC2047:
4322         {
4323         uschar buffer[2048];
4324         uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
4325           buffer, sizeof(buffer));
4326         yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
4327         continue;
4328         }
4329
4330       /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
4331       underscores */
4332
4333       case EOP_FROM_UTF8:
4334         {
4335         while (*sub != 0)
4336           {
4337           int c;
4338           uschar buff[4];
4339           GETUTF8INC(c, sub);
4340           if (c > 255) c = '_';
4341           buff[0] = c;
4342           yield = string_cat(yield, &size, &ptr, buff, 1);
4343           }
4344         continue;
4345         }
4346
4347       /* escape turns all non-printing characters into escape sequences. */
4348
4349       case EOP_ESCAPE:
4350         {
4351         uschar *t = string_printing(sub);
4352         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4353         continue;
4354         }
4355
4356       /* Handle numeric expression evaluation */
4357
4358       case EOP_EVAL:
4359       case EOP_EVAL10:
4360         {
4361         uschar *save_sub = sub;
4362         uschar *error = NULL;
4363         int n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
4364         if (error != NULL)
4365           {
4366           expand_string_message = string_sprintf("error in expression "
4367             "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
4368               save_sub);
4369           goto EXPAND_FAILED;
4370           }
4371         sprintf(CS var_buffer, "%d", n);
4372         yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4373         continue;
4374         }
4375
4376       /* Handle time period formating */
4377
4378       case EOP_TIME_INTERVAL:
4379         {
4380         int n;
4381         uschar *t = read_number(&n, sub);
4382         if (*t != 0) /* Not A Number*/
4383           {
4384           expand_string_message = string_sprintf("string \"%s\" is not a "
4385             "positive number in \"%s\" operator", sub, name);
4386           goto EXPAND_FAILED;
4387           }
4388         t = readconf_printtime(n);
4389         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4390         continue;
4391         }
4392
4393       /* Convert string to base64 encoding */
4394
4395       case EOP_STR2B64:
4396         {
4397         uschar *encstr = auth_b64encode(sub, Ustrlen(sub));
4398         yield = string_cat(yield, &size, &ptr, encstr, Ustrlen(encstr));
4399         continue;
4400         }
4401
4402       /* strlen returns the length of the string */
4403
4404       case EOP_STRLEN:
4405         {
4406         uschar buff[24];
4407         (void)sprintf(CS buff, "%d", Ustrlen(sub));
4408         yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
4409         continue;
4410         }
4411
4412       /* length_n or l_n takes just the first n characters or the whole string,
4413       whichever is the shorter;
4414
4415       substr_m_n, and s_m_n take n characters from offset m; negative m take
4416       from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
4417       takes the rest, either to the right or to the left.
4418
4419       hash_n or h_n makes a hash of length n from the string, yielding n
4420       characters from the set a-z; hash_n_m makes a hash of length n, but
4421       uses m characters from the set a-zA-Z0-9.
4422
4423       nhash_n returns a single number between 0 and n-1 (in text form), while
4424       nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
4425       between 0 and n-1 and the second between 0 and m-1. */
4426
4427       case EOP_LENGTH:
4428       case EOP_L:
4429       case EOP_SUBSTR:
4430       case EOP_S:
4431       case EOP_HASH:
4432       case EOP_H:
4433       case EOP_NHASH:
4434       case EOP_NH:
4435         {
4436         int sign = 1;
4437         int value1 = 0;
4438         int value2 = -1;
4439         int *pn;
4440         int len;
4441         uschar *ret;
4442
4443         if (arg == NULL)
4444           {
4445           expand_string_message = string_sprintf("missing values after %s",
4446             name);
4447           goto EXPAND_FAILED;
4448           }
4449
4450         /* "length" has only one argument, effectively being synonymous with
4451         substr_0_n. */
4452
4453         if (c == EOP_LENGTH || c == EOP_L)
4454           {
4455           pn = &value2;
4456           value2 = 0;
4457           }
4458
4459         /* The others have one or two arguments; for "substr" the first may be
4460         negative. The second being negative means "not supplied". */
4461
4462         else
4463           {
4464           pn = &value1;
4465           if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
4466           }
4467
4468         /* Read up to two numbers, separated by underscores */
4469
4470         ret = arg;
4471         while (*arg != 0)
4472           {
4473           if (arg != ret && *arg == '_' && pn == &value1)
4474             {
4475             pn = &value2;
4476             value2 = 0;
4477             if (arg[1] != 0) arg++;
4478             }
4479           else if (!isdigit(*arg))
4480             {
4481             expand_string_message =
4482               string_sprintf("non-digit after underscore in \"%s\"", name);
4483             goto EXPAND_FAILED;
4484             }
4485           else *pn = (*pn)*10 + *arg++ - '0';
4486           }
4487         value1 *= sign;
4488
4489         /* Perform the required operation */
4490
4491         ret =
4492           (c == EOP_HASH || c == EOP_H)?
4493              compute_hash(sub, value1, value2, &len) :
4494           (c == EOP_NHASH || c == EOP_NH)?
4495              compute_nhash(sub, value1, value2, &len) :
4496              extract_substr(sub, value1, value2, &len);
4497
4498         if (ret == NULL) goto EXPAND_FAILED;
4499         yield = string_cat(yield, &size, &ptr, ret, len);
4500         continue;
4501         }
4502
4503       /* Stat a path */
4504
4505       case EOP_STAT:
4506         {
4507         uschar *s;
4508         uschar smode[12];
4509         uschar **modetable[3];
4510         int i;
4511         mode_t mode;
4512         struct stat st;
4513
4514         if (stat(CS sub, &st) < 0)
4515           {
4516           expand_string_message = string_sprintf("stat(%s) failed: %s",
4517             sub, strerror(errno));
4518           goto EXPAND_FAILED;
4519           }
4520         mode = st.st_mode;
4521         switch (mode & S_IFMT)
4522           {
4523           case S_IFIFO: smode[0] = 'p'; break;
4524           case S_IFCHR: smode[0] = 'c'; break;
4525           case S_IFDIR: smode[0] = 'd'; break;
4526           case S_IFBLK: smode[0] = 'b'; break;
4527           case S_IFREG: smode[0] = '-'; break;
4528           default: smode[0] = '?'; break;
4529           }
4530
4531         modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
4532         modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
4533         modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
4534
4535         for (i = 0; i < 3; i++)
4536           {
4537           memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
4538           mode >>= 3;
4539           }
4540
4541         smode[10] = 0;
4542         s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
4543           "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
4544           (long)(st.st_mode & 077777), smode, (long)st.st_ino,
4545           (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
4546           (long)st.st_gid, st.st_size, (long)st.st_atime,
4547           (long)st.st_mtime, (long)st.st_ctime);
4548         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
4549         continue;
4550         }
4551
4552       /* Unknown operator */
4553
4554       default:
4555       expand_string_message =
4556         string_sprintf("unknown expansion operator \"%s\"", name);
4557       goto EXPAND_FAILED;
4558       }
4559     }
4560
4561   /* Handle a plain name. If this is the first thing in the expansion, release
4562   the pre-allocated buffer. If the result data is known to be in a new buffer,
4563   newsize will be set to the size of that buffer, and we can just point at that
4564   store instead of copying. Many expansion strings contain just one reference,
4565   so this is a useful optimization, especially for humungous headers
4566   ($message_headers). */
4567
4568   if (*s++ == '}')
4569     {
4570     int len;
4571     int newsize = 0;
4572     if (ptr == 0)
4573       {
4574       store_reset(yield);
4575       yield = NULL;
4576       size = 0;
4577       }
4578     value = find_variable(name, FALSE, skipping, &newsize);
4579     if (value == NULL)
4580       {
4581       expand_string_message =
4582         string_sprintf("unknown variable in \"${%s}\"", name);
4583       goto EXPAND_FAILED;
4584       }
4585     len = Ustrlen(value);
4586     if (yield == NULL && newsize != 0)
4587       {
4588       yield = value;
4589       size = newsize;
4590       ptr = len;
4591       }
4592     else yield = string_cat(yield, &size, &ptr, value, len);
4593     continue;
4594     }
4595
4596   /* Else there's something wrong */
4597
4598   expand_string_message =
4599     string_sprintf("\"${%s\" is not a known operator (or a } is missing "
4600     "in a variable reference)", name);
4601   goto EXPAND_FAILED;
4602   }
4603
4604 /* If we hit the end of the string when ket_ends is set, there is a missing
4605 terminating brace. */
4606
4607 if (ket_ends && *s == 0)
4608   {
4609   expand_string_message = malformed_header?
4610     US"missing } at end of string - could be header name not terminated by colon"
4611     :
4612     US"missing } at end of string";
4613   goto EXPAND_FAILED;
4614   }
4615
4616 /* Expansion succeeded; yield may still be NULL here if nothing was actually
4617 added to the string. If so, set up an empty string. Add a terminating zero. If
4618 left != NULL, return a pointer to the terminator. */
4619
4620 if (yield == NULL) yield = store_get(1);
4621 yield[ptr] = 0;
4622 if (left != NULL) *left = s;
4623
4624 /* Any stacking store that was used above the final string is no longer needed.
4625 In many cases the final string will be the first one that was got and so there
4626 will be optimal store usage. */
4627
4628 store_reset(yield + ptr + 1);
4629 DEBUG(D_expand)
4630   {
4631   debug_printf("expanding: %.*s\n   result: %s\n", (int)(s - string), string,
4632     yield);
4633   if (skipping) debug_printf("skipping: result is not used\n");
4634   }
4635 return yield;
4636
4637 /* This is the failure exit: easiest to program with a goto. We still need
4638 to update the pointer to the terminator, for cases of nested calls with "fail".
4639 */
4640
4641 EXPAND_FAILED_CURLY:
4642 expand_string_message = malformed_header?
4643   US"missing or misplaced { or } - could be header name not terminated by colon"
4644   :
4645   US"missing or misplaced { or }";
4646
4647 /* At one point, Exim reset the store to yield (if yield was not NULL), but
4648 that is a bad idea, because expand_string_message is in dynamic store. */
4649
4650 EXPAND_FAILED:
4651 if (left != NULL) *left = s;
4652 DEBUG(D_expand)
4653   {
4654   debug_printf("failed to expand: %s\n", string);
4655   debug_printf("   error message: %s\n", expand_string_message);
4656   if (expand_string_forcedfail) debug_printf("failure was forced\n");
4657   }
4658 return NULL;
4659 }
4660
4661
4662 /* This is the external function call. Do a quick check for any expansion
4663 metacharacters, and if there are none, just return the input string.
4664
4665 Argument: the string to be expanded
4666 Returns:  the expanded string, or NULL if expansion failed; if failure was
4667           due to a lookup deferring, search_find_defer will be TRUE
4668 */
4669
4670 uschar *
4671 expand_string(uschar *string)
4672 {
4673 search_find_defer = FALSE;
4674 malformed_header = FALSE;
4675 return (Ustrpbrk(string, "$\\") == NULL)? string :
4676   expand_string_internal(string, FALSE, NULL, FALSE);
4677 }
4678
4679
4680
4681 /*************************************************
4682 *              Expand and copy                   *
4683 *************************************************/
4684
4685 /* Now and again we want to expand a string and be sure that the result is in a
4686 new bit of store. This function does that.
4687
4688 Argument: the string to be expanded
4689 Returns:  the expanded string, always in a new bit of store, or NULL
4690 */
4691
4692 uschar *
4693 expand_string_copy(uschar *string)
4694 {
4695 uschar *yield = expand_string(string);
4696 if (yield == string) yield = string_copy(string);
4697 return yield;
4698 }
4699
4700
4701
4702 /*************************************************
4703 *        Expand and interpret as an integer      *
4704 *************************************************/
4705
4706 /* Expand a string, and convert the result into an integer.
4707
4708 Argument: the string to be expanded
4709
4710 Returns:  the integer value, or
4711           -1 for an expansion error               ) in both cases, message in
4712           -2 for an integer interpretation error  ) expand_string_message
4713
4714 */
4715
4716 int
4717 expand_string_integer(uschar *string)
4718 {
4719 long int value;
4720 uschar *s = expand_string(string);
4721 uschar *msg = US"invalid integer \"%s\"";
4722 uschar *endptr;
4723
4724 if (s == NULL) return -1;
4725
4726 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
4727 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
4728 systems, so we set it zero ourselves. */
4729
4730 errno = 0;
4731 value = strtol(CS s, CSS &endptr, 0);
4732
4733 if (endptr == s)
4734   {
4735   msg = US"integer expected but \"%s\" found";
4736   }
4737 else
4738   {
4739   /* Ensure we can cast this down to an int */
4740   if (value > INT_MAX  || value < INT_MIN) errno = ERANGE;
4741
4742   if (errno != ERANGE)
4743     {
4744     if (tolower(*endptr) == 'k')
4745       {
4746       if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
4747         else value *= 1024;
4748       endptr++;
4749       }
4750     else if (tolower(*endptr) == 'm')
4751       {
4752       if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
4753         errno = ERANGE;
4754       else value *= 1024*1024;
4755       endptr++;
4756       }
4757     }
4758   if (errno == ERANGE)
4759     msg = US"absolute value of integer \"%s\" is too large (overflow)";
4760   else
4761     {
4762     while (isspace(*endptr)) endptr++;
4763     if (*endptr == 0) return (int)value;
4764     }
4765   }
4766
4767 expand_string_message = string_sprintf(CS msg, s);
4768 return -2;
4769 }
4770
4771
4772
4773 /*************************************************
4774 **************************************************
4775 *             Stand-alone test program           *
4776 **************************************************
4777 *************************************************/
4778
4779 #ifdef STAND_ALONE
4780
4781
4782 BOOL
4783 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
4784 {
4785 int ovector[3*(EXPAND_MAXN+1)];
4786 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
4787   ovector, sizeof(ovector)/sizeof(int));
4788 BOOL yield = n >= 0;
4789 if (n == 0) n = EXPAND_MAXN + 1;
4790 if (yield)
4791   {
4792   int nn;
4793   expand_nmax = (setup < 0)? 0 : setup + 1;
4794   for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
4795     {
4796     expand_nstring[expand_nmax] = subject + ovector[nn];
4797     expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
4798     }
4799   expand_nmax--;
4800   }
4801 return yield;
4802 }
4803
4804
4805 int main(int argc, uschar **argv)
4806 {
4807 int i;
4808 uschar buffer[1024];
4809
4810 debug_selector = D_v;
4811 debug_file = stderr;
4812 debug_fd = fileno(debug_file);
4813 big_buffer = malloc(big_buffer_size);
4814
4815 for (i = 1; i < argc; i++)
4816   {
4817   if (argv[i][0] == '+')
4818     {
4819     debug_trace_memory = 2;
4820     argv[i]++;
4821     }
4822   if (isdigit(argv[i][0]))
4823     debug_selector = Ustrtol(argv[i], NULL, 0);
4824   else
4825     if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
4826         Ustrlen(argv[i]))
4827       {
4828       #ifdef LOOKUP_LDAP
4829       eldap_default_servers = argv[i];
4830       #endif
4831       #ifdef LOOKUP_MYSQL
4832       mysql_servers = argv[i];
4833       #endif
4834       #ifdef LOOKUP_PGSQL
4835       pgsql_servers = argv[i];
4836       #endif
4837       }
4838   #ifdef EXIM_PERL
4839   else opt_perl_startup = argv[i];
4840   #endif
4841   }
4842
4843 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
4844
4845 expand_nstring[1] = US"string 1....";
4846 expand_nlength[1] = 8;
4847 expand_nmax = 1;
4848
4849 #ifdef EXIM_PERL
4850 if (opt_perl_startup != NULL)
4851   {
4852   uschar *errstr;
4853   printf("Starting Perl interpreter\n");
4854   errstr = init_perl(opt_perl_startup);
4855   if (errstr != NULL)
4856     {
4857     printf("** error in perl_startup code: %s\n", errstr);
4858     return EXIT_FAILURE;
4859     }
4860   }
4861 #endif /* EXIM_PERL */
4862
4863 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
4864   {
4865   void *reset_point = store_get(0);
4866   uschar *yield = expand_string(buffer);
4867   if (yield != NULL)
4868     {
4869     printf("%s\n", yield);
4870     store_reset(reset_point);
4871     }
4872   else
4873     {
4874     if (search_find_defer) printf("search_find deferred\n");
4875     printf("Failed: %s\n", expand_string_message);
4876     if (expand_string_forcedfail) printf("Forced failure\n");
4877     printf("\n");
4878     }
4879   }
4880
4881 search_tidyup();
4882
4883 return 0;
4884 }
4885
4886 #endif
4887
4888 /* End of expand.c */