src/src/expand.c

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