src/src/expand.c

   1 /* $Cambridge: exim/src/src/expand.c,v 1.18 2005/03/22 16:52:06 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 #ifdef WITH_OLD_DEMIME
 337   { "demime_errorlevel",   vtype_int,         &demime_errorlevel },
 338   { "demime_reason",       vtype_stringptr,   &demime_reason },
 339 #endif
 340 #ifdef EXPERIMENTAL_DOMAINKEYS
 341   { "dk_domain",           vtype_stringptr,   &dk_signing_domain },
 342   { "dk_is_signed",        vtype_dk_verify,   NULL },
 343   { "dk_result",           vtype_dk_verify,   NULL },
 344   { "dk_selector",         vtype_stringptr,   &dk_signing_selector },
 345   { "dk_sender",           vtype_dk_verify,   NULL },
 346   { "dk_sender_domain",    vtype_dk_verify,   NULL },
 347   { "dk_sender_local_part",vtype_dk_verify,   NULL },
 348   { "dk_sender_source",    vtype_dk_verify,   NULL },
 349   { "dk_signsall",         vtype_dk_verify,   NULL },
 350   { "dk_status",           vtype_dk_verify,   NULL },
 351   { "dk_testing",          vtype_dk_verify,   NULL },
 352 #endif
 353   { "dnslist_domain",      vtype_stringptr,   &dnslist_domain },
 354   { "dnslist_text",        vtype_stringptr,   &dnslist_text },
 355   { "dnslist_value",       vtype_stringptr,   &dnslist_value },
 356   { "domain",              vtype_stringptr,   &deliver_domain },
 357   { "domain_data",         vtype_stringptr,   &deliver_domain_data },
 358   { "exim_gid",            vtype_gid,         &exim_gid },
 359   { "exim_path",           vtype_stringptr,   &exim_path },
 360   { "exim_uid",            vtype_uid,         &exim_uid },
 361 #ifdef WITH_OLD_DEMIME
 362   { "found_extension",     vtype_stringptr,   &found_extension },
 363 #endif
 364   { "home",                vtype_stringptr,   &deliver_home },
 365   { "host",                vtype_stringptr,   &deliver_host },
 366   { "host_address",        vtype_stringptr,   &deliver_host_address },
 367   { "host_data",           vtype_stringptr,   &host_data },
 368   { "host_lookup_deferred",vtype_int,         &host_lookup_deferred },
 369   { "host_lookup_failed",  vtype_int,         &host_lookup_failed },
 370   { "inode",               vtype_ino,         &deliver_inode },
 371   { "interface_address",   vtype_stringptr,   &interface_address },
 372   { "interface_port",      vtype_int,         &interface_port },
 373   #ifdef LOOKUP_LDAP
 374   { "ldap_dn",             vtype_stringptr,   &eldap_dn },
 375   #endif
 376   { "load_average",        vtype_load_avg,    NULL },
 377   { "local_part",          vtype_stringptr,   &deliver_localpart },
 378   { "local_part_data",     vtype_stringptr,   &deliver_localpart_data },
 379   { "local_part_prefix",   vtype_stringptr,   &deliver_localpart_prefix },
 380   { "local_part_suffix",   vtype_stringptr,   &deliver_localpart_suffix },
 381   { "local_scan_data",     vtype_stringptr,   &local_scan_data },
 382   { "local_user_gid",      vtype_gid,         &local_user_gid },
 383   { "local_user_uid",      vtype_uid,         &local_user_uid },
 384   { "localhost_number",    vtype_int,         &host_number },
 385   { "log_inodes",          vtype_pinodes,     (void *)FALSE },
 386   { "log_space",           vtype_pspace,      (void *)FALSE },
 387   { "mailstore_basename",  vtype_stringptr,   &mailstore_basename },
 388 #ifdef WITH_CONTENT_SCAN
 389   { "malware_name",        vtype_stringptr,   &malware_name },
 390 #endif
 391   { "message_age",         vtype_int,         &message_age },
 392   { "message_body",        vtype_msgbody,     &message_body },
 393   { "message_body_end",    vtype_msgbody_end, &message_body_end },
 394   { "message_body_size",   vtype_int,         &message_body_size },
 395   { "message_headers",     vtype_msgheaders,  NULL },
 396   { "message_id",          vtype_stringptr,   &message_id },
 397   { "message_size",        vtype_int,         &message_size },
 398 #ifdef WITH_CONTENT_SCAN
 399   { "mime_anomaly_level",  vtype_int,         &mime_anomaly_level },
 400   { "mime_anomaly_text",   vtype_stringptr,   &mime_anomaly_text },
 401   { "mime_boundary",       vtype_stringptr,   &mime_boundary },
 402   { "mime_charset",        vtype_stringptr,   &mime_charset },
 403   { "mime_content_description", vtype_stringptr, &mime_content_description },
 404   { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
 405   { "mime_content_id",     vtype_stringptr,   &mime_content_id },
 406   { "mime_content_size",   vtype_int,         &mime_content_size },
 407   { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
 408   { "mime_content_type",   vtype_stringptr,   &mime_content_type },
 409   { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
 410   { "mime_filename",       vtype_stringptr,   &mime_filename },
 411   { "mime_is_coverletter", vtype_int,         &mime_is_coverletter },
 412   { "mime_is_multipart",   vtype_int,         &mime_is_multipart },
 413   { "mime_is_rfc822",      vtype_int,         &mime_is_rfc822 },
 414   { "mime_part_count",     vtype_int,         &mime_part_count },
 415 #endif
 416   { "n0",                  vtype_filter_int,  &filter_n[0] },
 417   { "n1",                  vtype_filter_int,  &filter_n[1] },
 418   { "n2",                  vtype_filter_int,  &filter_n[2] },
 419   { "n3",                  vtype_filter_int,  &filter_n[3] },
 420   { "n4",                  vtype_filter_int,  &filter_n[4] },
 421   { "n5",                  vtype_filter_int,  &filter_n[5] },
 422   { "n6",                  vtype_filter_int,  &filter_n[6] },
 423   { "n7",                  vtype_filter_int,  &filter_n[7] },
 424   { "n8",                  vtype_filter_int,  &filter_n[8] },
 425   { "n9",                  vtype_filter_int,  &filter_n[9] },
 426   { "original_domain",     vtype_stringptr,   &deliver_domain_orig },
 427   { "original_local_part", vtype_stringptr,   &deliver_localpart_orig },
 428   { "originator_gid",      vtype_gid,         &originator_gid },
 429   { "originator_uid",      vtype_uid,         &originator_uid },
 430   { "parent_domain",       vtype_stringptr,   &deliver_domain_parent },
 431   { "parent_local_part",   vtype_stringptr,   &deliver_localpart_parent },
 432   { "pid",                 vtype_pid,         NULL },
 433   { "primary_hostname",    vtype_stringptr,   &primary_hostname },
 434   { "qualify_domain",      vtype_stringptr,   &qualify_domain_sender },
 435   { "qualify_recipient",   vtype_stringptr,   &qualify_domain_recipient },
 436   { "rcpt_count",          vtype_int,         &rcpt_count },
 437   { "rcpt_defer_count",    vtype_int,         &rcpt_defer_count },
 438   { "rcpt_fail_count",     vtype_int,         &rcpt_fail_count },
 439   { "received_count",      vtype_int,         &received_count },
 440   { "received_for",        vtype_stringptr,   &received_for },
 441   { "received_protocol",   vtype_stringptr,   &received_protocol },
 442   { "received_time",       vtype_int,         &received_time },
 443   { "recipient_data",      vtype_stringptr,   &recipient_data },
 444   { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
 445   { "recipients",          vtype_recipients,  NULL },
 446   { "recipients_count",    vtype_int,         &recipients_count },
 447 #ifdef WITH_CONTENT_SCAN
 448   { "regex_match_string",  vtype_stringptr,   &regex_match_string },
 449 #endif
 450   { "reply_address",       vtype_reply,       NULL },
 451   { "return_path",         vtype_stringptr,   &return_path },
 452   { "return_size_limit",   vtype_int,         &bounce_return_size_limit },
 453   { "runrc",               vtype_int,         &runrc },
 454   { "self_hostname",       vtype_stringptr,   &self_hostname },
 455   { "sender_address",      vtype_stringptr,   &sender_address },
 456   { "sender_address_data", vtype_stringptr,   &sender_address_data },
 457   { "sender_address_domain", vtype_domain,    &sender_address },
 458   { "sender_address_local_part", vtype_localpart, &sender_address },
 459   { "sender_data",         vtype_stringptr,   &sender_data },
 460   { "sender_fullhost",     vtype_stringptr,   &sender_fullhost },
 461   { "sender_helo_name",    vtype_stringptr,   &sender_helo_name },
 462   { "sender_host_address", vtype_stringptr,   &sender_host_address },
 463   { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
 464   { "sender_host_name",    vtype_host_lookup, NULL },
 465   { "sender_host_port",    vtype_int,         &sender_host_port },
 466   { "sender_ident",        vtype_stringptr,   &sender_ident },
 467   { "sender_rcvhost",      vtype_stringptr,   &sender_rcvhost },
 468   { "sender_verify_failure",vtype_stringptr,  &sender_verify_failure },
 469   { "smtp_active_hostname", vtype_stringptr,  &smtp_active_hostname },
 470   { "smtp_command_argument", vtype_stringptr, &smtp_command_argument },
 471   { "sn0",                 vtype_filter_int,  &filter_sn[0] },
 472   { "sn1",                 vtype_filter_int,  &filter_sn[1] },
 473   { "sn2",                 vtype_filter_int,  &filter_sn[2] },
 474   { "sn3",                 vtype_filter_int,  &filter_sn[3] },
 475   { "sn4",                 vtype_filter_int,  &filter_sn[4] },
 476   { "sn5",                 vtype_filter_int,  &filter_sn[5] },
 477   { "sn6",                 vtype_filter_int,  &filter_sn[6] },
 478   { "sn7",                 vtype_filter_int,  &filter_sn[7] },
 479   { "sn8",                 vtype_filter_int,  &filter_sn[8] },
 480   { "sn9",                 vtype_filter_int,  &filter_sn[9] },
 481 #ifdef WITH_CONTENT_SCAN
 482   { "spam_bar",            vtype_stringptr,   &spam_bar },
 483   { "spam_report",         vtype_stringptr,   &spam_report },
 484   { "spam_score",          vtype_stringptr,   &spam_score },
 485   { "spam_score_int",      vtype_stringptr,   &spam_score_int },
 486 #endif
 487 #ifdef EXPERIMENTAL_SPF
 488   { "spf_header_comment",  vtype_stringptr,   &spf_header_comment },
 489   { "spf_received",        vtype_stringptr,   &spf_received },
 490   { "spf_result",          vtype_stringptr,   &spf_result },
 491   { "spf_smtp_comment",    vtype_stringptr,   &spf_smtp_comment },
 492 #endif
 493   { "spool_directory",     vtype_stringptr,   &spool_directory },
 494   { "spool_inodes",        vtype_pinodes,     (void *)TRUE },
 495   { "spool_space",         vtype_pspace,      (void *)TRUE },
 496 #ifdef EXPERIMENTAL_SRS
 497   { "srs_db_address",      vtype_stringptr,   &srs_db_address },
 498   { "srs_db_key",          vtype_stringptr,   &srs_db_key },
 499   { "srs_orig_recipient",  vtype_stringptr,   &srs_orig_recipient },
 500   { "srs_orig_sender",     vtype_stringptr,   &srs_orig_sender },
 501   { "srs_recipient",       vtype_stringptr,   &srs_recipient },
 502   { "srs_status",          vtype_stringptr,   &srs_status },
 503 #endif
 504   { "thisaddress",         vtype_stringptr,   &filter_thisaddress },
 505   { "tls_certificate_verified", vtype_int,    &tls_certificate_verified },
 506   { "tls_cipher",          vtype_stringptr,   &tls_cipher },
 507   { "tls_peerdn",          vtype_stringptr,   &tls_peerdn },
 508   { "tod_bsdinbox",        vtype_todbsdin,    NULL },
 509   { "tod_epoch",           vtype_tode,        NULL },
 510   { "tod_full",            vtype_todf,        NULL },
 511   { "tod_log",             vtype_todl,        NULL },
 512   { "tod_logfile",         vtype_todlf,       NULL },
 513   { "tod_zone",            vtype_todzone,     NULL },
 514   { "tod_zulu",            vtype_todzulu,     NULL },
 515   { "value",               vtype_stringptr,   &lookup_value },
 516   { "version_number",      vtype_stringptr,   &version_string },
 517   { "warn_message_delay",  vtype_stringptr,   &warnmsg_delay },
 518   { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
 519   { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
 520   { "warnmsg_delay",       vtype_stringptr,   &warnmsg_delay },
 521   { "warnmsg_recipient",   vtype_stringptr,   &warnmsg_recipients },
 522   { "warnmsg_recipients",  vtype_stringptr,   &warnmsg_recipients }
 523 };
 524
 525 static int var_table_size = sizeof(var_table)/sizeof(var_entry);
 526 static uschar var_buffer[256];
 527 static BOOL malformed_header;
 528
 529 /* For textual hashes */
 530
 531 static char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
 532                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 533                          "0123456789";
 534
 535 enum { HMAC_MD5, HMAC_SHA1 };
 536
 537 /* For numeric hashes */
 538
 539 static unsigned int prime[] = {
 540   2,   3,   5,   7,  11,  13,  17,  19,  23,  29,
 541  31,  37,  41,  43,  47,  53,  59,  61,  67,  71,
 542  73,  79,  83,  89,  97, 101, 103, 107, 109, 113};
 543
 544 /* For printing modes in symbolic form */
 545
 546 static uschar *mtable_normal[] =
 547   { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
 548
 549 static uschar *mtable_setid[] =
 550   { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
 551
 552 static uschar *mtable_sticky[] =
 553   { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
 554
 555
 556
 557 /*************************************************
 558 *           Tables for UTF-8 support             *
 559 *************************************************/
 560
 561 /* Table of the number of extra characters, indexed by the first character
 562 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
 563 0x3d. */
 564
 565 static uschar utf8_table1[] = {
 566   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 567   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 568   2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 569   3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
 570
 571 /* These are the masks for the data bits in the first byte of a character,
 572 indexed by the number of additional bytes. */
 573
 574 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
 575
 576 /* Get the next UTF-8 character, advancing the pointer. */
 577
 578 #define GETUTF8INC(c, ptr) \
 579   c = *ptr++; \
 580   if ((c & 0xc0) == 0xc0) \
 581     { \
 582     int a = utf8_table1[c & 0x3f];  /* Number of additional bytes */ \
 583     int s = 6*a; \
 584     c = (c & utf8_table2[a]) << s; \
 585     while (a-- > 0) \
 586       { \
 587       s -= 6; \
 588       c |= (*ptr++ & 0x3f) << s; \
 589       } \
 590     }
 591
 592
 593 /*************************************************
 594 *           Binary chop search on a table        *
 595 *************************************************/
 596
 597 /* This is used for matching expansion items and operators.
 598
 599 Arguments:
 600   name        the name that is being sought
 601   table       the table to search
 602   table_size  the number of items in the table
 603
 604 Returns:      the offset in the table, or -1
 605 */
 606
 607 static int
 608 chop_match(uschar *name, uschar **table, int table_size)
 609 {
 610 uschar **bot = table;
 611 uschar **top = table + table_size;
 612
 613 while (top > bot)
 614   {
 615   uschar **mid = bot + (top - bot)/2;
 616   int c = Ustrcmp(name, *mid);
 617   if (c == 0) return mid - table;
 618   if (c > 0) bot = mid + 1; else top = mid;
 619   }
 620
 621 return -1;
 622 }
 623
 624
 625
 626 /*************************************************
 627 *          Check a condition string              *
 628 *************************************************/
 629
 630 /* This function is called to expand a string, and test the result for a "true"
 631 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
 632 forced fail or lookup defer. All store used by the function can be released on
 633 exit.
 634
 635 Arguments:
 636   condition     the condition string
 637   m1            text to be incorporated in panic error
 638   m2            ditto
 639
 640 Returns:        TRUE if condition is met, FALSE if not
 641 */
 642
 643 BOOL
 644 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
 645 {
 646 int rc;
 647 void *reset_point = store_get(0);
 648 uschar *ss = expand_string(condition);
 649 if (ss == NULL)
 650   {
 651   if (!expand_string_forcedfail && !search_find_defer)
 652     log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
 653       "for %s %s: %s", condition, m1, m2, expand_string_message);
 654   return FALSE;
 655   }
 656 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
 657   strcmpic(ss, US"false") != 0;
 658 store_reset(reset_point);
 659 return rc;
 660 }
 661
 662
 663
 664 /*************************************************
 665 *             Pick out a name from a string      *
 666 *************************************************/
 667
 668 /* If the name is too long, it is silently truncated.
 669
 670 Arguments:
 671   name      points to a buffer into which to put the name
 672   max       is the length of the buffer
 673   s         points to the first alphabetic character of the name
 674   extras    chars other than alphanumerics to permit
 675
 676 Returns:    pointer to the first character after the name
 677
 678 Note: The test for *s != 0 in the while loop is necessary because
 679 Ustrchr() yields non-NULL if the character is zero (which is not something
 680 I expected). */
 681
 682 static uschar *
 683 read_name(uschar *name, int max, uschar *s, uschar *extras)
 684 {
 685 int ptr = 0;
 686 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
 687   {
 688   if (ptr < max-1) name[ptr++] = *s;
 689   s++;
 690   }
 691 name[ptr] = 0;
 692 return s;
 693 }
 694
 695
 696
 697 /*************************************************
 698 *     Pick out the rest of a header name         *
 699 *************************************************/
 700
 701 /* A variable name starting $header_ (or just $h_ for those who like
 702 abbreviations) might not be the complete header name because headers can
 703 contain any printing characters in their names, except ':'. This function is
 704 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
 705 on the end, if the name was terminated by white space.
 706
 707 Arguments:
 708   name      points to a buffer in which the name read so far exists
 709   max       is the length of the buffer
 710   s         points to the first character after the name so far, i.e. the
 711             first non-alphameric character after $header_xxxxx
 712
 713 Returns:    a pointer to the first character after the header name
 714 */
 715
 716 static uschar *
 717 read_header_name(uschar *name, int max, uschar *s)
 718 {
 719 int prelen = Ustrchr(name, '_') - name + 1;
 720 int ptr = Ustrlen(name) - prelen;
 721 if (ptr > 0) memmove(name, name+prelen, ptr);
 722 while (mac_isgraph(*s) && *s != ':')
 723   {
 724   if (ptr < max-1) name[ptr++] = *s;
 725   s++;
 726   }
 727 if (*s == ':') s++;
 728 name[ptr++] = ':';
 729 name[ptr] = 0;
 730 return s;
 731 }
 732
 733
 734
 735 /*************************************************
 736 *           Pick out a number from a string      *
 737 *************************************************/
 738
 739 /* Arguments:
 740   n     points to an integer into which to put the number
 741   s     points to the first digit of the number
 742
 743 Returns:  a pointer to the character after the last digit
 744 */
 745
 746 static uschar *
 747 read_number(int *n, uschar *s)
 748 {
 749 *n = 0;
 750 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
 751 return s;
 752 }
 753
 754
 755
 756 /*************************************************
 757 *        Extract keyed subfield from a string    *
 758 *************************************************/
 759
 760 /* The yield is in dynamic store; NULL means that the key was not found.
 761
 762 Arguments:
 763   key       points to the name of the key
 764   s         points to the string from which to extract the subfield
 765
 766 Returns:    NULL if the subfield was not found, or
 767             a pointer to the subfield's data
 768 */
 769
 770 static uschar *
 771 expand_getkeyed(uschar *key, uschar *s)
 772 {
 773 int length = Ustrlen(key);
 774 while (isspace(*s)) s++;
 775
 776 /* Loop to search for the key */
 777
 778 while (*s != 0)
 779   {
 780   int dkeylength;
 781   uschar *data;
 782   uschar *dkey = s;
 783
 784   while (*s != 0 && *s != '=' && !isspace(*s)) s++;
 785   dkeylength = s - dkey;
 786   while (isspace(*s)) s++;
 787   if (*s == '=') while (isspace((*(++s))));
 788
 789   data = string_dequote(&s);
 790   if (length == dkeylength && strncmpic(key, dkey, length) == 0)
 791     return data;
 792
 793   while (isspace(*s)) s++;
 794   }
 795
 796 return NULL;
 797 }
 798
 799
 800
 801
 802 /*************************************************
 803 *   Extract numbered subfield from string        *
 804 *************************************************/
 805
 806 /* Extracts a numbered field from a string that is divided by tokens - for
 807 example a line from /etc/passwd is divided by colon characters.  First field is
 808 numbered one.  Negative arguments count from the right. Zero returns the whole
 809 string. Returns NULL if there are insufficient tokens in the string
 810
 811 ***WARNING***
 812 Modifies final argument - this is a dynamically generated string, so that's OK.
 813
 814 Arguments:
 815   field       number of field to be extracted,
 816                 first field = 1, whole string = 0, last field = -1
 817   separators  characters that are used to break string into tokens
 818   s           points to the string from which to extract the subfield
 819
 820 Returns:      NULL if the field was not found,
 821               a pointer to the field's data inside s (modified to add 0)
 822 */
 823
 824 static uschar *
 825 expand_gettokened (int field, uschar *separators, uschar *s)
 826 {
 827 int sep = 1;
 828 int count;
 829 uschar *ss = s;
 830 uschar *fieldtext = NULL;
 831
 832 if (field == 0) return s;
 833
 834 /* Break the line up into fields in place; for field > 0 we stop when we have
 835 done the number of fields we want. For field < 0 we continue till the end of
 836 the string, counting the number of fields. */
 837
 838 count = (field > 0)? field : INT_MAX;
 839
 840 while (count-- > 0)
 841   {
 842   size_t len;
 843
 844   /* Previous field was the last one in the string. For a positive field
 845   number, this means there are not enough fields. For a negative field number,
 846   check that there are enough, and scan back to find the one that is wanted. */
 847
 848   if (sep == 0)
 849     {
 850     if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
 851     if ((-field) == (INT_MAX - count - 1)) return s;
 852     while (field++ < 0)
 853       {
 854       ss--;
 855       while (ss[-1] != 0) ss--;
 856       }
 857     fieldtext = ss;
 858     break;
 859     }
 860
 861   /* Previous field was not last in the string; save its start and put a
 862   zero at its end. */
 863
 864   fieldtext = ss;
 865   len = Ustrcspn(ss, separators);
 866   sep = ss[len];
 867   ss[len] = 0;
 868   ss += len + 1;
 869   }
 870
 871 return fieldtext;
 872 }
 873
 874
 875
 876 /*************************************************
 877 *        Extract a substring from a string       *
 878 *************************************************/
 879
 880 /* Perform the ${substr or ${length expansion operations.
 881
 882 Arguments:
 883   subject     the input string
 884   value1      the offset from the start of the input string to the start of
 885                 the output string; if negative, count from the right.
 886   value2      the length of the output string, or negative (-1) for unset
 887                 if value1 is positive, unset means "all after"
 888                 if value1 is negative, unset means "all before"
 889   len         set to the length of the returned string
 890
 891 Returns:      pointer to the output string, or NULL if there is an error
 892 */
 893
 894 static uschar *
 895 extract_substr(uschar *subject, int value1, int value2, int *len)
 896 {
 897 int sublen = Ustrlen(subject);
 898
 899 if (value1 < 0)    /* count from right */
 900   {
 901   value1 += sublen;
 902
 903   /* If the position is before the start, skip to the start, and adjust the
 904   length. If the length ends up negative, the substring is null because nothing
 905   can precede. This falls out naturally when the length is unset, meaning "all
 906   to the left". */
 907
 908   if (value1 < 0)
 909     {
 910     value2 += value1;
 911     if (value2 < 0) value2 = 0;
 912     value1 = 0;
 913     }
 914
 915   /* Otherwise an unset length => characters before value1 */
 916
 917   else if (value2 < 0)
 918     {
 919     value2 = value1;
 920     value1 = 0;
 921     }
 922   }
 923
 924 /* For a non-negative offset, if the starting position is past the end of the
 925 string, the result will be the null string. Otherwise, an unset length means
 926 "rest"; just set it to the maximum - it will be cut down below if necessary. */
 927
 928 else
 929   {
 930   if (value1 > sublen)
 931     {
 932     value1 = sublen;
 933     value2 = 0;
 934     }
 935   else if (value2 < 0) value2 = sublen;
 936   }
 937
 938 /* Cut the length down to the maximum possible for the offset value, and get
 939 the required characters. */
 940
 941 if (value1 + value2 > sublen) value2 = sublen - value1;
 942 *len = value2;
 943 return subject + value1;
 944 }
 945
 946
 947
 948
 949 /*************************************************
 950 *            Old-style hash of a string          *
 951 *************************************************/
 952
 953 /* Perform the ${hash expansion operation.
 954
 955 Arguments:
 956   subject     the input string (an expanded substring)
 957   value1      the length of the output string; if greater or equal to the
 958                 length of the input string, the input string is returned
 959   value2      the number of hash characters to use, or 26 if negative
 960   len         set to the length of the returned string
 961
 962 Returns:      pointer to the output string, or NULL if there is an error
 963 */
 964
 965 static uschar *
 966 compute_hash(uschar *subject, int value1, int value2, int *len)
 967 {
 968 int sublen = Ustrlen(subject);
 969
 970 if (value2 < 0) value2 = 26;
 971 else if (value2 > Ustrlen(hashcodes))
 972   {
 973   expand_string_message =
 974     string_sprintf("hash count \"%d\" too big", value2);
 975   return NULL;
 976   }
 977
 978 /* Calculate the hash text. We know it is shorter than the original string, so
 979 can safely place it in subject[] (we know that subject is always itself an
 980 expanded substring). */
 981
 982 if (value1 < sublen)
 983   {
 984   int c;
 985   int i = 0;
 986   int j = value1;
 987   while ((c = (subject[j])) != 0)
 988     {
 989     int shift = (c + j++) & 7;
 990     subject[i] ^= (c << shift) | (c >> (8-shift));
 991     if (++i >= value1) i = 0;
 992     }
 993   for (i = 0; i < value1; i++)
 994     subject[i] = hashcodes[(subject[i]) % value2];
 995   }
 996 else value1 = sublen;
 997
 998 *len = value1;
 999 return subject;
1000 }
1001
1002
1003
1004
1005 /*************************************************
1006 *             Numeric hash of a string           *
1007 *************************************************/
1008
1009 /* Perform the ${nhash expansion operation. The first characters of the
1010 string are treated as most important, and get the highest prime numbers.
1011
1012 Arguments:
1013   subject     the input string
1014   value1      the maximum value of the first part of the result
1015   value2      the maximum value of the second part of the result,
1016                 or negative to produce only a one-part result
1017   len         set to the length of the returned string
1018
1019 Returns:  pointer to the output string, or NULL if there is an error.
1020 */
1021
1022 static uschar *
1023 compute_nhash (uschar *subject, int value1, int value2, int *len)
1024 {
1025 uschar *s = subject;
1026 int i = 0;
1027 unsigned long int total = 0; /* no overflow */
1028
1029 while (*s != 0)
1030   {
1031   if (i == 0) i = sizeof(prime)/sizeof(int) - 1;
1032   total += prime[i--] * (unsigned int)(*s++);
1033   }
1034
1035 /* If value2 is unset, just compute one number */
1036
1037 if (value2 < 0)
1038   {
1039   s = string_sprintf("%d", total % value1);
1040   }
1041
1042 /* Otherwise do a div/mod hash */
1043
1044 else
1045   {
1046   total = total % (value1 * value2);
1047   s = string_sprintf("%d/%d", total/value2, total % value2);
1048   }
1049
1050 *len = Ustrlen(s);
1051 return s;
1052 }
1053
1054
1055
1056
1057
1058 /*************************************************
1059 *     Find the value of a header or headers      *
1060 *************************************************/
1061
1062 /* Multiple instances of the same header get concatenated, and this function
1063 can also return a concatenation of all the header lines. When concatenating
1064 specific headers that contain lists of addresses, a comma is inserted between
1065 them. Otherwise we use a straight concatenation. Because some messages can have
1066 pathologically large number of lines, there is a limit on the length that is
1067 returned. Also, to avoid massive store use which would result from using
1068 string_cat() as it copies and extends strings, we do a preliminary pass to find
1069 out exactly how much store will be needed. On "normal" messages this will be
1070 pretty trivial.
1071
1072 Arguments:
1073   name          the name of the header, without the leading $header_ or $h_,
1074                 or NULL if a concatenation of all headers is required
1075   exists_only   TRUE if called from a def: test; don't need to build a string;
1076                 just return a string that is not "" and not "0" if the header
1077                 exists
1078   newsize       return the size of memory block that was obtained; may be NULL
1079                 if exists_only is TRUE
1080   want_raw      TRUE if called for $rh_ or $rheader_ variables; no processing,
1081                 other than concatenating, will be done on the header
1082   charset       name of charset to translate MIME words to; used only if
1083                 want_raw is false; if NULL, no translation is done (this is
1084                 used for $bh_ and $bheader_)
1085
1086 Returns:        NULL if the header does not exist, else a pointer to a new
1087                 store block
1088 */
1089
1090 static uschar *
1091 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1092   uschar *charset)
1093 {
1094 BOOL found = name == NULL;
1095 int comma = 0;
1096 int len = found? 0 : Ustrlen(name);
1097 int i;
1098 uschar *yield = NULL;
1099 uschar *ptr = NULL;
1100
1101 /* Loop for two passes - saves code repetition */
1102
1103 for (i = 0; i < 2; i++)
1104   {
1105   int size = 0;
1106   header_line *h;
1107
1108   for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1109     {
1110     if (h->type != htype_old && h->text != NULL)  /* NULL => Received: placeholder */
1111       {
1112       if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1113         {
1114         int ilen;
1115         uschar *t;
1116
1117         if (exists_only) return US"1";      /* don't need actual string */
1118         found = TRUE;
1119         t = h->text + len;                  /* text to insert */
1120         if (!want_raw)                      /* unless wanted raw, */
1121           while (isspace(*t)) t++;          /* remove leading white space */
1122         ilen = h->slen - (t - h->text);     /* length to insert */
1123
1124         /* Set comma = 1 if handling a single header and it's one of those
1125         that contains an address list, except when asked for raw headers. Only
1126         need to do this once. */
1127
1128         if (!want_raw && name != NULL && comma == 0 &&
1129             Ustrchr("BCFRST", h->type) != NULL)
1130           comma = 1;
1131
1132         /* First pass - compute total store needed; second pass - compute
1133         total store used, including this header. */
1134
1135         size += ilen + comma;
1136
1137         /* Second pass - concatentate the data, up to a maximum. Note that
1138         the loop stops when size hits the limit. */
1139
1140         if (i != 0)
1141           {
1142           if (size > header_insert_maxlen)
1143             {
1144             ilen -= size - header_insert_maxlen;
1145             comma = 0;
1146             }
1147           Ustrncpy(ptr, t, ilen);
1148           ptr += ilen;
1149           if (comma != 0 && ilen > 0)
1150             {
1151             ptr[-1] = ',';
1152             *ptr++ = '\n';
1153             }
1154           }
1155         }
1156       }
1157     }
1158
1159   /* At end of first pass, truncate size if necessary, and get the buffer
1160   to hold the data, returning the buffer size. */
1161
1162   if (i == 0)
1163     {
1164     if (!found) return NULL;
1165     if (size > header_insert_maxlen) size = header_insert_maxlen;
1166     *newsize = size + 1;
1167     ptr = yield = store_get(*newsize);
1168     }
1169   }
1170
1171 /* Remove a redundant added comma if present */
1172
1173 if (comma != 0 && ptr > yield) ptr -= 2;
1174
1175 /* That's all we do for raw header expansion. */
1176
1177 if (want_raw)
1178   {
1179   *ptr = 0;
1180   }
1181
1182 /* Otherwise, we remove trailing whitespace, including newlines. Then we do RFC
1183 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1184 function can return an error with decoded data if the charset translation
1185 fails. If decoding fails, it returns NULL. */
1186
1187 else
1188   {
1189   uschar *decoded, *error;
1190   while (ptr > yield && isspace(ptr[-1])) ptr--;
1191   *ptr = 0;
1192   decoded = rfc2047_decode2(yield, TRUE, charset, '?', NULL, newsize, &error);
1193   if (error != NULL)
1194     {
1195     DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1196       "    input was: %s\n", error, yield);
1197     }
1198   if (decoded != NULL) yield = decoded;
1199   }
1200
1201 return yield;
1202 }
1203
1204
1205
1206
1207 /*************************************************
1208 *               Find value of a variable         *
1209 *************************************************/
1210
1211 /* The table of variables is kept in alphabetic order, so we can search it
1212 using a binary chop. The "choplen" variable is nothing to do with the binary
1213 chop.
1214
1215 Arguments:
1216   name          the name of the variable being sought
1217   exists_only   TRUE if this is a def: test; passed on to find_header()
1218   skipping      TRUE => skip any processing evaluation; this is not the same as
1219                   exists_only because def: may test for values that are first
1220                   evaluated here
1221   newsize       pointer to an int which is initially zero; if the answer is in
1222                 a new memory buffer, *newsize is set to its size
1223
1224 Returns:        NULL if the variable does not exist, or
1225                 a pointer to the variable's contents, or
1226                 something non-NULL if exists_only is TRUE
1227 */
1228
1229 static uschar *
1230 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1231 {
1232 int first = 0;
1233 int last = var_table_size;
1234
1235 while (last > first)
1236   {
1237   uschar *s, *domain;
1238   uschar **ss;
1239   int middle = (first + last)/2;
1240   int c = Ustrcmp(name, var_table[middle].name);
1241
1242   if (c > 0) { first = middle + 1; continue; }
1243   if (c < 0) { last = middle; continue; }
1244
1245   /* Found an existing variable. If in skipping state, the value isn't needed,
1246   and we want to avoid processing (such as looking up up the host name). */
1247
1248   if (skipping) return US"";
1249
1250   switch (var_table[middle].type)
1251     {
1252     case vtype_filter_int:
1253     if (!filter_running) return NULL;
1254     /* Fall through */
1255
1256 #ifdef EXPERIMENTAL_DOMAINKEYS
1257
1258     case vtype_dk_verify:
1259     if (dk_verify_block == NULL) return US"";
1260     s = NULL;
1261     if (Ustrcmp(var_table[middle].name, "dk_result") == 0)
1262       s = dk_verify_block->result_string;
1263     if (Ustrcmp(var_table[middle].name, "dk_sender") == 0)
1264       s = dk_verify_block->address;
1265     if (Ustrcmp(var_table[middle].name, "dk_sender_domain") == 0)
1266       s = dk_verify_block->domain;
1267     if (Ustrcmp(var_table[middle].name, "dk_sender_local_part") == 0)
1268       s = dk_verify_block->local_part;
1269
1270     if (Ustrcmp(var_table[middle].name, "dk_sender_source") == 0)
1271       switch(dk_verify_block->address_source) {
1272         case DK_EXIM_ADDRESS_NONE: s = "0"; break;
1273         case DK_EXIM_ADDRESS_FROM_FROM: s = "from"; break;
1274         case DK_EXIM_ADDRESS_FROM_SENDER: s = "sender"; break;
1275       }
1276
1277     if (Ustrcmp(var_table[middle].name, "dk_status") == 0)
1278       switch(dk_verify_block->result) {
1279         case DK_EXIM_RESULT_ERR: s = "error"; break;
1280         case DK_EXIM_RESULT_BAD_FORMAT: s = "bad format"; break;
1281         case DK_EXIM_RESULT_NO_KEY: s = "no key"; break;
1282         case DK_EXIM_RESULT_NO_SIGNATURE: s = "no signature"; break;
1283         case DK_EXIM_RESULT_REVOKED: s = "revoked"; break;
1284         case DK_EXIM_RESULT_NON_PARTICIPANT: s = "non-participant"; break;
1285         case DK_EXIM_RESULT_GOOD: s = "good"; break;
1286         case DK_EXIM_RESULT_BAD: s = "bad"; break;
1287       }
1288
1289     if (Ustrcmp(var_table[middle].name, "dk_signsall") == 0)
1290       s = (dk_verify_block->signsall)? "1" : "0";
1291
1292     if (Ustrcmp(var_table[middle].name, "dk_testing") == 0)
1293       s = (dk_verify_block->testing)? "1" : "0";
1294
1295     if (Ustrcmp(var_table[middle].name, "dk_is_signed") == 0)
1296       s = (dk_verify_block->is_signed)? "1" : "0";
1297
1298     return (s == NULL)? US"" : s;
1299 #endif
1300
1301     case vtype_int:
1302     sprintf(CS var_buffer, "%d", *(int *)(var_table[middle].value)); /* Integer */
1303     return var_buffer;
1304
1305     case vtype_ino:
1306     sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(var_table[middle].value))); /* Inode */
1307     return var_buffer;
1308
1309     case vtype_gid:
1310     sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(var_table[middle].value))); /* gid */
1311     return var_buffer;
1312
1313     case vtype_uid:
1314     sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(var_table[middle].value))); /* uid */
1315     return var_buffer;
1316
1317     case vtype_stringptr:                      /* Pointer to string */
1318     s = *((uschar **)(var_table[middle].value));
1319     return (s == NULL)? US"" : s;
1320
1321     case vtype_pid:
1322     sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1323     return var_buffer;
1324
1325     case vtype_load_avg:
1326     sprintf(CS var_buffer, "%d", os_getloadavg()); /* load_average */
1327     return var_buffer;
1328
1329     case vtype_host_lookup:                    /* Lookup if not done so */
1330     if (sender_host_name == NULL && sender_host_address != NULL &&
1331         !host_lookup_failed && host_name_lookup() == OK)
1332       host_build_sender_fullhost();
1333     return (sender_host_name == NULL)? US"" : sender_host_name;
1334
1335     case vtype_localpart:                      /* Get local part from address */
1336     s = *((uschar **)(var_table[middle].value));
1337     if (s == NULL) return US"";
1338     domain = Ustrrchr(s, '@');
1339     if (domain == NULL) return s;
1340     if (domain - s > sizeof(var_buffer) - 1)
1341       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than %d in "
1342         "string expansion", sizeof(var_buffer));
1343     Ustrncpy(var_buffer, s, domain - s);
1344     var_buffer[domain - s] = 0;
1345     return var_buffer;
1346
1347     case vtype_domain:                         /* Get domain from address */
1348     s = *((uschar **)(var_table[middle].value));
1349     if (s == NULL) return US"";
1350     domain = Ustrrchr(s, '@');
1351     return (domain == NULL)? US"" : domain + 1;
1352
1353     case vtype_msgheaders:
1354     return find_header(NULL, exists_only, newsize, FALSE, NULL);
1355
1356     case vtype_msgbody:                        /* Pointer to msgbody string */
1357     case vtype_msgbody_end:                    /* Ditto, the end of the msg */
1358     ss = (uschar **)(var_table[middle].value);
1359     if (*ss == NULL && deliver_datafile >= 0)  /* Read body when needed */
1360       {
1361       uschar *body;
1362       int start_offset = SPOOL_DATA_START_OFFSET;
1363       int len = message_body_visible;
1364       if (len > message_size) len = message_size;
1365       *ss = body = store_malloc(len+1);
1366       body[0] = 0;
1367       if (var_table[middle].type == vtype_msgbody_end)
1368         {
1369         struct stat statbuf;
1370         if (fstat(deliver_datafile, &statbuf) == 0)
1371           {
1372           start_offset = statbuf.st_size - len;
1373           if (start_offset < SPOOL_DATA_START_OFFSET)
1374             start_offset = SPOOL_DATA_START_OFFSET;
1375           }
1376         }
1377       lseek(deliver_datafile, start_offset, SEEK_SET);
1378       len = read(deliver_datafile, body, len);
1379       if (len > 0)
1380         {
1381         body[len] = 0;
1382         while (len > 0)
1383           {
1384           if (body[--len] == '\n' || body[len] == 0) body[len] = ' ';
1385           }
1386         }
1387       }
1388     return (*ss == NULL)? US"" : *ss;
1389
1390     case vtype_todbsdin:                       /* BSD inbox time of day */
1391     return tod_stamp(tod_bsdin);
1392
1393     case vtype_tode:                           /* Unix epoch time of day */
1394     return tod_stamp(tod_epoch);
1395
1396     case vtype_todf:                           /* Full time of day */
1397     return tod_stamp(tod_full);
1398
1399     case vtype_todl:                           /* Log format time of day */
1400     return tod_stamp(tod_log_bare);            /* (without timezone) */
1401
1402     case vtype_todzone:                        /* Time zone offset only */
1403     return tod_stamp(tod_zone);
1404
1405     case vtype_todzulu:                        /* Zulu time */
1406     return tod_stamp(tod_zulu);
1407
1408     case vtype_todlf:                          /* Log file datestamp tod */
1409     return tod_stamp(tod_log_datestamp);
1410
1411     case vtype_reply:                          /* Get reply address */
1412     s = find_header(US"reply-to:", exists_only, newsize, FALSE,
1413       headers_charset);
1414     if (s == NULL || *s == 0)
1415       s = find_header(US"from:", exists_only, newsize, FALSE, headers_charset);
1416     return (s == NULL)? US"" : s;
1417
1418     /* A recipients list is available only during system message filtering,
1419     during ACL processing after DATA, and while expanding pipe commands
1420     generated from a system filter, but not elsewhere. */
1421
1422     case vtype_recipients:
1423     if (!enable_dollar_recipients) return NULL; else
1424       {
1425       int size = 128;
1426       int ptr = 0;
1427       int i;
1428       s = store_get(size);
1429       for (i = 0; i < recipients_count; i++)
1430         {
1431         if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1432         s = string_cat(s, &size, &ptr, recipients_list[i].address,
1433           Ustrlen(recipients_list[i].address));
1434         }
1435       s[ptr] = 0;     /* string_cat() leaves room */
1436       }
1437     return s;
1438
1439     case vtype_pspace:
1440       {
1441       int inodes;
1442       sprintf(CS var_buffer, "%d",
1443         receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes));
1444       }
1445     return var_buffer;
1446
1447     case vtype_pinodes:
1448       {
1449       int inodes;
1450       (void) receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes);
1451       sprintf(CS var_buffer, "%d", inodes);
1452       }
1453     return var_buffer;
1454     }
1455   }
1456
1457 return NULL;          /* Unknown variable name */
1458 }
1459
1460
1461
1462
1463 /*************************************************
1464 *           Read and expand substrings           *
1465 *************************************************/
1466
1467 /* This function is called to read and expand argument substrings for various
1468 expansion items. Some have a minimum requirement that is less than the maximum;
1469 in these cases, the first non-present one is set to NULL.
1470
1471 Arguments:
1472   sub        points to vector of pointers to set
1473   n          maximum number of substrings
1474   m          minimum required
1475   sptr       points to current string pointer
1476   skipping   the skipping flag
1477   check_end  if TRUE, check for final '}'
1478   name       name of item, for error message
1479
1480 Returns:     0 OK; string pointer updated
1481              1 curly bracketing error (too few arguments)
1482              2 too many arguments (only if check_end is set); message set
1483              3 other error (expansion failure)
1484 */
1485
1486 static int
1487 read_subs(uschar **sub, int n, int m, uschar **sptr, BOOL skipping,
1488   BOOL check_end, uschar *name)
1489 {
1490 int i;
1491 uschar *s = *sptr;
1492
1493 while (isspace(*s)) s++;
1494 for (i = 0; i < n; i++)
1495   {
1496   if (*s != '{')
1497     {
1498     if (i < m) return 1;
1499     sub[i] = NULL;
1500     break;
1501     }
1502   sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
1503   if (sub[i] == NULL) return 3;
1504   if (*s++ != '}') return 1;
1505   while (isspace(*s)) s++;
1506   }
1507 if (check_end && *s++ != '}')
1508   {
1509   if (s[-1] == '{')
1510     {
1511     expand_string_message = string_sprintf("Too many arguments for \"%s\" "
1512       "(max is %d)", name, n);
1513     return 2;
1514     }
1515   return 1;
1516   }
1517
1518 *sptr = s;
1519 return 0;
1520 }
1521
1522
1523
1524
1525 /*************************************************
1526 *        Read and evaluate a condition           *
1527 *************************************************/
1528
1529 /*
1530 Arguments:
1531   s        points to the start of the condition text
1532   yield    points to a BOOL to hold the result of the condition test;
1533            if NULL, we are just reading through a condition that is
1534            part of an "or" combination to check syntax, or in a state
1535            where the answer isn't required
1536
1537 Returns:   a pointer to the first character after the condition, or
1538            NULL after an error
1539 */
1540
1541 static uschar *
1542 eval_condition(uschar *s, BOOL *yield)
1543 {
1544 BOOL testfor = TRUE;
1545 BOOL tempcond, combined_cond;
1546 BOOL *subcondptr;
1547 int i, rc, cond_type, roffset;
1548 int num[2];
1549 struct stat statbuf;
1550 uschar name[256];
1551 uschar *sub[4];
1552
1553 const pcre *re;
1554 const uschar *rerror;
1555
1556 for (;;)
1557   {
1558   while (isspace(*s)) s++;
1559   if (*s == '!') { testfor = !testfor; s++; } else break;
1560   }
1561
1562 /* Numeric comparisons are symbolic */
1563
1564 if (*s == '=' || *s == '>' || *s == '<')
1565   {
1566   int p = 0;
1567   name[p++] = *s++;
1568   if (*s == '=')
1569     {
1570     name[p++] = '=';
1571     s++;
1572     }
1573   name[p] = 0;
1574   }
1575
1576 /* All other conditions are named */
1577
1578 else s = read_name(name, 256, s, US"_");
1579
1580 /* If we haven't read a name, it means some non-alpha character is first. */
1581
1582 if (name[0] == 0)
1583   {
1584   expand_string_message = string_sprintf("condition name expected, "
1585     "but found \"%.16s\"", s);
1586   return NULL;
1587   }
1588
1589 /* Find which condition we are dealing with, and switch on it */
1590
1591 cond_type = chop_match(name, cond_table, sizeof(cond_table)/sizeof(uschar *));
1592 switch(cond_type)
1593   {
1594   /* def: tests for a non-zero or non-NULL variable, or for an existing
1595   header */
1596
1597   case ECOND_DEF:
1598   if (*s != ':')
1599     {
1600     expand_string_message = US"\":\" expected after \"def\"";
1601     return NULL;
1602     }
1603
1604   s = read_name(name, 256, s+1, US"_");
1605
1606   /* Test for a header's existence */
1607
1608   if (Ustrncmp(name, "h_", 2) == 0 ||
1609       Ustrncmp(name, "rh_", 3) == 0 ||
1610       Ustrncmp(name, "bh_", 3) == 0 ||
1611       Ustrncmp(name, "header_", 7) == 0 ||
1612       Ustrncmp(name, "rheader_", 8) == 0 ||
1613       Ustrncmp(name, "bheader_", 8) == 0)
1614     {
1615     s = read_header_name(name, 256, s);
1616     if (yield != NULL) *yield =
1617       (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
1618     }
1619
1620   /* Test for a variable's having a non-empty value. If yield == NULL we
1621   are in a skipping state, and don't care about the answer. */
1622
1623   else
1624     {
1625     uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
1626     if (value == NULL)
1627       {
1628       expand_string_message = (name[0] == 0)?
1629         string_sprintf("variable name omitted after \"def:\"") :
1630         string_sprintf("unknown variable \"%s\" after \"def:\"", name);
1631       return NULL;
1632       }
1633     if (yield != NULL)
1634       *yield = (value[0] != 0 && Ustrcmp(value, "0") != 0) == testfor;
1635     }
1636
1637   return s;
1638
1639
1640   /* first_delivery tests for first delivery attempt */
1641
1642   case ECOND_FIRST_DELIVERY:
1643   if (yield != NULL) *yield = deliver_firsttime == testfor;
1644   return s;
1645
1646
1647   /* queue_running tests for any process started by a queue runner */
1648
1649   case ECOND_QUEUE_RUNNING:
1650   if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
1651   return s;
1652
1653
1654   /* exists:  tests for file existence
1655        isip:  tests for any IP address
1656       isip4:  tests for an IPv4 address
1657       isip6:  tests for an IPv6 address
1658         pam:  does PAM authentication
1659      radius:  does RADIUS authentication
1660    ldapauth:  does LDAP authentication
1661     pwcheck:  does Cyrus SASL pwcheck authentication
1662   */
1663
1664   case ECOND_EXISTS:
1665   case ECOND_ISIP:
1666   case ECOND_ISIP4:
1667   case ECOND_ISIP6:
1668   case ECOND_PAM:
1669   case ECOND_RADIUS:
1670   case ECOND_LDAPAUTH:
1671   case ECOND_PWCHECK:
1672
1673   while (isspace(*s)) s++;
1674   if (*s != '{') goto COND_FAILED_CURLY_START;
1675
1676   sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1677   if (sub[0] == NULL) return NULL;
1678   if (*s++ != '}') goto COND_FAILED_CURLY_END;
1679
1680   if (yield == NULL) return s;   /* No need to run the test if skipping */
1681
1682   switch(cond_type)
1683     {
1684     case ECOND_EXISTS:
1685     if ((expand_forbid & RDO_EXISTS) != 0)
1686       {
1687       expand_string_message = US"File existence tests are not permitted";
1688       return NULL;
1689       }
1690     *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
1691     break;
1692
1693     case ECOND_ISIP:
1694     case ECOND_ISIP4:
1695     case ECOND_ISIP6:
1696     rc = string_is_ip_address(sub[0], NULL);
1697     *yield = ((cond_type == ECOND_ISIP)? (rc > 0) :
1698              (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
1699     break;
1700
1701     /* Various authentication tests - all optionally compiled */
1702
1703     case ECOND_PAM:
1704     #ifdef SUPPORT_PAM
1705     rc = auth_call_pam(sub[0], &expand_string_message);
1706     goto END_AUTH;
1707     #else
1708     goto COND_FAILED_NOT_COMPILED;
1709     #endif  /* SUPPORT_PAM */
1710
1711     case ECOND_RADIUS:
1712     #ifdef RADIUS_CONFIG_FILE
1713     rc = auth_call_radius(sub[0], &expand_string_message);
1714     goto END_AUTH;
1715     #else
1716     goto COND_FAILED_NOT_COMPILED;
1717     #endif  /* RADIUS_CONFIG_FILE */
1718
1719     case ECOND_LDAPAUTH:
1720     #ifdef LOOKUP_LDAP
1721       {
1722       /* Just to keep the interface the same */
1723       BOOL do_cache;
1724       int old_pool = store_pool;
1725       store_pool = POOL_SEARCH;
1726       rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
1727         &expand_string_message, &do_cache);
1728       store_pool = old_pool;
1729       }
1730     goto END_AUTH;
1731     #else
1732     goto COND_FAILED_NOT_COMPILED;
1733     #endif  /* LOOKUP_LDAP */
1734
1735     case ECOND_PWCHECK:
1736     #ifdef CYRUS_PWCHECK_SOCKET
1737     rc = auth_call_pwcheck(sub[0], &expand_string_message);
1738     goto END_AUTH;
1739     #else
1740     goto COND_FAILED_NOT_COMPILED;
1741     #endif  /* CYRUS_PWCHECK_SOCKET */
1742
1743     #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
1744         defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
1745     END_AUTH:
1746     if (rc == ERROR || rc == DEFER) return NULL;
1747     *yield = (rc == OK) == testfor;
1748     #endif
1749     }
1750   return s;
1751
1752
1753   /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
1754
1755      ${if saslauthd {{username}{password}{service}{realm}}  {yes}[no}}
1756
1757   However, the last two are optional. That is why the whole set is enclosed
1758   in their own set or braces. */
1759
1760   case ECOND_SASLAUTHD:
1761   #ifndef CYRUS_SASLAUTHD_SOCKET
1762   goto COND_FAILED_NOT_COMPILED;
1763   #else
1764   while (isspace(*s)) s++;
1765   if (*s++ != '{') goto COND_FAILED_CURLY_START;
1766   switch(read_subs(sub, 4, 2, &s, yield == NULL, TRUE, US"saslauthd"))
1767     {
1768     case 1: expand_string_message = US"too few arguments or bracketing "
1769       "error for saslauthd";
1770     case 2:
1771     case 3: return NULL;
1772     }
1773   if (sub[2] == NULL) sub[3] = NULL;  /* realm if no service */
1774   if (yield != NULL)
1775     {
1776     int rc;
1777     rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
1778       &expand_string_message);
1779     if (rc == ERROR || rc == DEFER) return NULL;
1780     *yield = (rc == OK) == testfor;
1781     }
1782   return s;
1783   #endif /* CYRUS_SASLAUTHD_SOCKET */
1784
1785
1786   /* symbolic operators for numeric and string comparison, and a number of
1787   other operators, all requiring two arguments.
1788
1789   match:             does a regular expression match and sets up the numerical
1790                        variables if it succeeds
1791   match_address:     matches in an address list
1792   match_domain:      matches in a domain list
1793   match_local_part:  matches in a local part list
1794   crypteq:           encrypts plaintext and compares against an encrypted text,
1795                        using crypt(), crypt16(), MD5 or SHA-1
1796   */
1797
1798   case ECOND_MATCH:
1799   case ECOND_MATCH_ADDRESS:
1800   case ECOND_MATCH_DOMAIN:
1801   case ECOND_MATCH_LOCAL_PART:
1802   case ECOND_CRYPTEQ:
1803
1804   case ECOND_NUM_L:     /* Numerical comparisons */
1805   case ECOND_NUM_LE:
1806   case ECOND_NUM_E:
1807   case ECOND_NUM_EE:
1808   case ECOND_NUM_G:
1809   case ECOND_NUM_GE:
1810
1811   case ECOND_STR_LT:    /* String comparisons */
1812   case ECOND_STR_LTI:
1813   case ECOND_STR_LE:
1814   case ECOND_STR_LEI:
1815   case ECOND_STR_EQ:
1816   case ECOND_STR_EQI:
1817   case ECOND_STR_GT:
1818   case ECOND_STR_GTI:
1819   case ECOND_STR_GE:
1820   case ECOND_STR_GEI:
1821
1822   for (i = 0; i < 2; i++)
1823     {
1824     while (isspace(*s)) s++;
1825     if (*s != '{')
1826       {
1827       if (i == 0) goto COND_FAILED_CURLY_START;
1828       expand_string_message = string_sprintf("missing 2nd string in {} "
1829         "after \"%s\"", name);
1830       return NULL;
1831       }
1832     sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1833     if (sub[i] == NULL) return NULL;
1834     if (*s++ != '}') goto COND_FAILED_CURLY_END;
1835
1836     /* Convert to numerical if required; we know that the names of all the
1837     conditions that compare numbers do not start with a letter. This just saves
1838     checking for them individually. */
1839
1840     if (!isalpha(name[0]))
1841       {
1842       uschar *endptr;
1843       num[i] = (int)Ustrtol((const uschar *)sub[i], &endptr, 10);
1844       if (tolower(*endptr) == 'k')
1845         {
1846         num[i] *= 1024;
1847         endptr++;
1848         }
1849       else if (tolower(*endptr) == 'm')
1850         {
1851         num[i] *= 1024*1024;
1852         endptr++;
1853         }
1854       while (isspace(*endptr)) endptr++;
1855       if (*endptr != 0)
1856         {
1857         expand_string_message = string_sprintf("\"%s\" is not a number",
1858           sub[i]);
1859         return NULL;
1860         }
1861       }
1862     }
1863
1864   /* Result not required */
1865
1866   if (yield == NULL) return s;
1867
1868   /* Do an appropriate comparison */
1869
1870   switch(cond_type)
1871     {
1872     case ECOND_NUM_E:
1873     case ECOND_NUM_EE:
1874     *yield = (num[0] == num[1]) == testfor;
1875     break;
1876
1877     case ECOND_NUM_G:
1878     *yield = (num[0] > num[1]) == testfor;
1879     break;
1880
1881     case ECOND_NUM_GE:
1882     *yield = (num[0] >= num[1]) == testfor;
1883     break;
1884
1885     case ECOND_NUM_L:
1886     *yield = (num[0] < num[1]) == testfor;
1887     break;
1888
1889     case ECOND_NUM_LE:
1890     *yield = (num[0] <= num[1]) == testfor;
1891     break;
1892
1893     case ECOND_STR_LT:
1894     *yield = (Ustrcmp(sub[0], sub[1]) < 0) == testfor;
1895     break;
1896
1897     case ECOND_STR_LTI:
1898     *yield = (strcmpic(sub[0], sub[1]) < 0) == testfor;
1899     break;
1900
1901     case ECOND_STR_LE:
1902     *yield = (Ustrcmp(sub[0], sub[1]) <= 0) == testfor;
1903     break;
1904
1905     case ECOND_STR_LEI:
1906     *yield = (strcmpic(sub[0], sub[1]) <= 0) == testfor;
1907     break;
1908
1909     case ECOND_STR_EQ:
1910     *yield = (Ustrcmp(sub[0], sub[1]) == 0) == testfor;
1911     break;
1912
1913     case ECOND_STR_EQI:
1914     *yield = (strcmpic(sub[0], sub[1]) == 0) == testfor;
1915     break;
1916
1917     case ECOND_STR_GT:
1918     *yield = (Ustrcmp(sub[0], sub[1]) > 0) == testfor;
1919     break;
1920
1921     case ECOND_STR_GTI:
1922     *yield = (strcmpic(sub[0], sub[1]) > 0) == testfor;
1923     break;
1924
1925     case ECOND_STR_GE:
1926     *yield = (Ustrcmp(sub[0], sub[1]) >= 0) == testfor;
1927     break;
1928
1929     case ECOND_STR_GEI:
1930     *yield = (strcmpic(sub[0], sub[1]) >= 0) == testfor;
1931     break;
1932
1933     case ECOND_MATCH:   /* Regular expression match */
1934     re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
1935       NULL);
1936     if (re == NULL)
1937       {
1938       expand_string_message = string_sprintf("regular expression error in "
1939         "\"%s\": %s at offset %d", sub[1], rerror, roffset);
1940       return NULL;
1941       }
1942     *yield = regex_match_and_setup(re, sub[0], 0, -1) == testfor;
1943     break;
1944
1945     case ECOND_MATCH_ADDRESS:  /* Match in an address list */
1946     rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
1947     goto MATCHED_SOMETHING;
1948
1949     case ECOND_MATCH_DOMAIN:   /* Match in a domain list */
1950     rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
1951       MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
1952     goto MATCHED_SOMETHING;
1953
1954     case ECOND_MATCH_LOCAL_PART:
1955     rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
1956       MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
1957     /* Fall through */
1958
1959     MATCHED_SOMETHING:
1960     switch(rc)
1961       {
1962       case OK:
1963       *yield = testfor;
1964       break;
1965
1966       case FAIL:
1967       *yield = !testfor;
1968       break;
1969
1970       case DEFER:
1971       expand_string_message = string_sprintf("unable to complete match "
1972         "against \"%s\": %s", sub[1], search_error_message);
1973       return NULL;
1974       }
1975
1976     break;
1977
1978     /* Various "encrypted" comparisons. If the second string starts with
1979     "{" then an encryption type is given. Default to crypt() or crypt16()
1980     (build-time choice). */
1981
1982     case ECOND_CRYPTEQ:
1983     #ifndef SUPPORT_CRYPTEQ
1984     goto COND_FAILED_NOT_COMPILED;
1985     #else
1986     if (strncmpic(sub[1], US"{md5}", 5) == 0)
1987       {
1988       int sublen = Ustrlen(sub[1]+5);
1989       md5 base;
1990       uschar digest[16];
1991
1992       md5_start(&base);
1993       md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
1994
1995       /* If the length that we are comparing against is 24, the MD5 digest
1996       is expressed as a base64 string. This is the way LDAP does it. However,
1997       some other software uses a straightforward hex representation. We assume
1998       this if the length is 32. Other lengths fail. */
1999
2000       if (sublen == 24)
2001         {
2002         uschar *coded = auth_b64encode((uschar *)digest, 16);
2003         DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2004           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2005         *yield = (Ustrcmp(coded, sub[1]+5) == 0) == testfor;
2006         }
2007       else if (sublen == 32)
2008         {
2009         int i;
2010         uschar coded[36];
2011         for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2012         coded[32] = 0;
2013         DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2014           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2015         *yield = (strcmpic(coded, sub[1]+5) == 0) == testfor;
2016         }
2017       else
2018         {
2019         DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2020           "fail\n  crypted=%s\n", sub[1]+5);
2021         *yield = !testfor;
2022         }
2023       }
2024
2025     else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2026       {
2027       int sublen = Ustrlen(sub[1]+6);
2028       sha1 base;
2029       uschar digest[20];
2030
2031       sha1_start(&base);
2032       sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2033
2034       /* If the length that we are comparing against is 28, assume the SHA1
2035       digest is expressed as a base64 string. If the length is 40, assume a
2036       straightforward hex representation. Other lengths fail. */
2037
2038       if (sublen == 28)
2039         {
2040         uschar *coded = auth_b64encode((uschar *)digest, 20);
2041         DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2042           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2043         *yield = (Ustrcmp(coded, sub[1]+6) == 0) == testfor;
2044         }
2045       else if (sublen == 40)
2046         {
2047         int i;
2048         uschar coded[44];
2049         for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2050         coded[40] = 0;
2051         DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2052           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2053         *yield = (strcmpic(coded, sub[1]+6) == 0) == testfor;
2054         }
2055       else
2056         {
2057         DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2058           "fail\n  crypted=%s\n", sub[1]+6);
2059         *yield = !testfor;
2060         }
2061       }
2062
2063     else   /* {crypt} or {crypt16} and non-{ at start */
2064       {
2065       int which = 0;
2066       uschar *coded;
2067
2068       if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2069         {
2070         sub[1] += 7;
2071         which = 1;
2072         }
2073       else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2074         {
2075         sub[1] += 9;
2076         which = 2;
2077         }
2078       else if (sub[1][0] == '{')
2079         {
2080         expand_string_message = string_sprintf("unknown encryption mechanism "
2081           "in \"%s\"", sub[1]);
2082         return NULL;
2083         }
2084
2085       switch(which)
2086         {
2087         case 0:  coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2088         case 1:  coded = US crypt(CS sub[0], CS sub[1]); break;
2089         default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2090         }
2091
2092       #define STR(s) # s
2093       #define XSTR(s) STR(s)
2094       DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2095         "  subject=%s\n  crypted=%s\n",
2096         (which == 0)? XSTR(DEFAULT_CRYPT) : (which == 1)? "crypt" : "crypt16",
2097         coded, sub[1]);
2098       #undef STR
2099       #undef XSTR
2100
2101       /* If the encrypted string contains fewer than two characters (for the
2102       salt), force failure. Otherwise we get false positives: with an empty
2103       string the yield of crypt() is an empty string! */
2104
2105       *yield = (Ustrlen(sub[1]) < 2)? !testfor :
2106         (Ustrcmp(coded, sub[1]) == 0) == testfor;
2107       }
2108     break;
2109     #endif  /* SUPPORT_CRYPTEQ */
2110     }   /* Switch for comparison conditions */
2111
2112   return s;    /* End of comparison conditions */
2113
2114
2115   /* and/or: computes logical and/or of several conditions */
2116
2117   case ECOND_AND:
2118   case ECOND_OR:
2119   subcondptr = (yield == NULL)? NULL : &tempcond;
2120   combined_cond = (cond_type == ECOND_AND);
2121
2122   while (isspace(*s)) s++;
2123   if (*s++ != '{') goto COND_FAILED_CURLY_START;
2124
2125   for (;;)
2126     {
2127     while (isspace(*s)) s++;
2128     if (*s == '}') break;
2129     if (*s != '{')
2130       {
2131       expand_string_message = string_sprintf("each subcondition "
2132         "inside an \"%s{...}\" condition must be in its own {}", name);
2133       return NULL;
2134       }
2135
2136     s = eval_condition(s+1, subcondptr);
2137     if (s == NULL)
2138       {
2139       expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2140         expand_string_message, name);
2141       return NULL;
2142       }
2143     while (isspace(*s)) s++;
2144
2145     if (*s++ != '}')
2146       {
2147       expand_string_message = string_sprintf("missing } at end of condition "
2148         "inside \"%s\" group", name);
2149       return NULL;
2150       }
2151
2152     if (yield != NULL)
2153       {
2154       if (cond_type == ECOND_AND)
2155         {
2156         combined_cond &= tempcond;
2157         if (!combined_cond) subcondptr = NULL;  /* once false, don't */
2158         }                                       /* evaluate any more */
2159       else
2160         {
2161         combined_cond |= tempcond;
2162         if (combined_cond) subcondptr = NULL;   /* once true, don't */
2163         }                                       /* evaluate any more */
2164       }
2165     }
2166
2167   if (yield != NULL) *yield = (combined_cond == testfor);
2168   return ++s;
2169
2170
2171   /* Unknown condition */
2172
2173   default:
2174   expand_string_message = string_sprintf("unknown condition \"%s\"", name);
2175   return NULL;
2176   }   /* End switch on condition type */
2177
2178 /* Missing braces at start and end of data */
2179
2180 COND_FAILED_CURLY_START:
2181 expand_string_message = string_sprintf("missing { after \"%s\"", name);
2182 return NULL;
2183
2184 COND_FAILED_CURLY_END:
2185 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2186   name);
2187 return NULL;
2188
2189 /* A condition requires code that is not compiled */
2190
2191 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
2192     !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
2193     !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
2194 COND_FAILED_NOT_COMPILED:
2195 expand_string_message = string_sprintf("support for \"%s\" not compiled",
2196   name);
2197 return NULL;
2198 #endif
2199 }
2200
2201
2202
2203
2204 /*************************************************
2205 *          Save numerical variables              *
2206 *************************************************/
2207
2208 /* This function is called from items such as "if" that want to preserve and
2209 restore the numbered variables.
2210
2211 Arguments:
2212   save_expand_string    points to an array of pointers to set
2213   save_expand_nlength   points to an array of ints for the lengths
2214
2215 Returns:                the value of expand max to save
2216 */
2217
2218 static int
2219 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2220 {
2221 int i;
2222 for (i = 0; i <= expand_nmax; i++)
2223   {
2224   save_expand_nstring[i] = expand_nstring[i];
2225   save_expand_nlength[i] = expand_nlength[i];
2226   }
2227 return expand_nmax;
2228 }
2229
2230
2231
2232 /*************************************************
2233 *           Restore numerical variables          *
2234 *************************************************/
2235
2236 /* This function restored saved values of numerical strings.
2237
2238 Arguments:
2239   save_expand_nmax      the number of strings to restore
2240   save_expand_string    points to an array of pointers
2241   save_expand_nlength   points to an array of ints
2242
2243 Returns:                nothing
2244 */
2245
2246 static void
2247 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2248   int *save_expand_nlength)
2249 {
2250 int i;
2251 expand_nmax = save_expand_nmax;
2252 for (i = 0; i <= expand_nmax; i++)
2253   {
2254   expand_nstring[i] = save_expand_nstring[i];
2255   expand_nlength[i] = save_expand_nlength[i];
2256   }
2257 }
2258
2259
2260
2261
2262
2263 /*************************************************
2264 *            Handle yes/no substrings            *
2265 *************************************************/
2266
2267 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
2268 alternative substrings that depend on whether or not the condition was true,
2269 or the lookup or extraction succeeded. The substrings always have to be
2270 expanded, to check their syntax, but "skipping" is set when the result is not
2271 needed - this avoids unnecessary nested lookups.
2272
2273 Arguments:
2274   skipping       TRUE if we were skipping when this item was reached
2275   yes            TRUE if the first string is to be used, else use the second
2276   save_lookup    a value to put back into lookup_value before the 2nd expansion
2277   sptr           points to the input string pointer
2278   yieldptr       points to the output string pointer
2279   sizeptr        points to the output string size
2280   ptrptr         points to the output string pointer
2281   type           "lookup" or "if" or "extract" or "run", for error message
2282
2283 Returns:         0 OK; lookup_value has been reset to save_lookup
2284                  1 expansion failed
2285                  2 expansion failed because of bracketing error
2286 */
2287
2288 static int
2289 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2290   uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type)
2291 {
2292 int rc = 0;
2293 uschar *s = *sptr;    /* Local value */
2294 uschar *sub1, *sub2;
2295
2296 /* If there are no following strings, we substitute the contents of $value for
2297 lookups and for extractions in the success case. For the ${if item, the string
2298 "true" is substituted. In the fail case, nothing is substituted for all three
2299 items. */
2300
2301 while (isspace(*s)) s++;
2302 if (*s == '}')
2303   {
2304   if (type[0] == 'i')
2305     {
2306     if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
2307     }
2308   else
2309     {
2310     if (yes && lookup_value != NULL)
2311       *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
2312         Ustrlen(lookup_value));
2313     lookup_value = save_lookup;
2314     }
2315   s++;
2316   goto RETURN;
2317   }
2318
2319 /* Expand the first substring. Forced failures are noticed only if we actually
2320 want this string. Set skipping in the call in the fail case (this will always
2321 be the case if we were already skipping). */
2322
2323 sub1 = expand_string_internal(s+1, TRUE, &s, !yes);
2324 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
2325 expand_string_forcedfail = FALSE;
2326 if (*s++ != '}') goto FAILED_CURLY;
2327
2328 /* If we want the first string, add it to the output */
2329
2330 if (yes)
2331   *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
2332
2333 /* If this is called from a lookup or an extract, we want to restore $value to
2334 what it was at the start of the item, so that it has this value during the
2335 second string expansion. For the call from "if" to this function, save_lookup
2336 is set to lookup_value, so that this statement does nothing. */
2337
2338 lookup_value = save_lookup;
2339
2340 /* There now follows either another substring, or "fail", or nothing. This
2341 time, forced failures are noticed only if we want the second string. We must
2342 set skipping in the nested call if we don't want this string, or if we were
2343 already skipping. */
2344
2345 while (isspace(*s)) s++;
2346 if (*s == '{')
2347   {
2348   sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping);
2349   if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
2350   expand_string_forcedfail = FALSE;
2351   if (*s++ != '}') goto FAILED_CURLY;
2352
2353   /* If we want the second string, add it to the output */
2354
2355   if (!yes)
2356     *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
2357   }
2358
2359 /* If there is no second string, but the word "fail" is present when the use of
2360 the second string is wanted, set a flag indicating it was a forced failure
2361 rather than a syntactic error. Swallow the terminating } in case this is nested
2362 inside another lookup or if or extract. */
2363
2364 else if (*s != '}')
2365   {
2366   uschar name[256];
2367   s = read_name(name, sizeof(name), s, US"_");
2368   if (Ustrcmp(name, "fail") == 0)
2369     {
2370     if (!yes && !skipping)
2371       {
2372       while (isspace(*s)) s++;
2373       if (*s++ != '}') goto FAILED_CURLY;
2374       expand_string_message =
2375         string_sprintf("\"%s\" failed and \"fail\" requested", type);
2376       expand_string_forcedfail = TRUE;
2377       goto FAILED;
2378       }
2379     }
2380   else
2381     {
2382     expand_string_message =
2383       string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
2384     goto FAILED;
2385     }
2386   }
2387
2388 /* All we have to do now is to check on the final closing brace. */
2389
2390 while (isspace(*s)) s++;
2391 if (*s++ == '}') goto RETURN;
2392
2393 /* Get here if there is a bracketing failure */
2394
2395 FAILED_CURLY:
2396 rc++;
2397
2398 /* Get here for other failures */
2399
2400 FAILED:
2401 rc++;
2402
2403 /* Update the input pointer value before returning */
2404
2405 RETURN:
2406 *sptr = s;
2407 return rc;
2408 }
2409
2410
2411
2412
2413
2414
2415 /*************************************************
2416 *    Handle MD5 or SHA-1 computation for HMAC    *
2417 *************************************************/
2418
2419 /* These are some wrapping functions that enable the HMAC code to be a bit
2420 cleaner. A good compiler will spot the tail recursion.
2421
2422 Arguments:
2423   type         HMAC_MD5 or HMAC_SHA1
2424   remaining    are as for the cryptographic hash functions
2425
2426 Returns:       nothing
2427 */
2428
2429 static void
2430 chash_start(int type, void *base)
2431 {
2432 if (type == HMAC_MD5)
2433   md5_start((md5 *)base);
2434 else
2435   sha1_start((sha1 *)base);
2436 }
2437
2438 static void
2439 chash_mid(int type, void *base, uschar *string)
2440 {
2441 if (type == HMAC_MD5)
2442   md5_mid((md5 *)base, string);
2443 else
2444   sha1_mid((sha1 *)base, string);
2445 }
2446
2447 static void
2448 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
2449 {
2450 if (type == HMAC_MD5)
2451   md5_end((md5 *)base, string, length, digest);
2452 else
2453   sha1_end((sha1 *)base, string, length, digest);
2454 }
2455
2456
2457
2458
2459
2460 /*************************************************
2461 *        Join a file onto the output string      *
2462 *************************************************/
2463
2464 /* This is used for readfile and after a run expansion. It joins the contents
2465 of a file onto the output string, globally replacing newlines with a given
2466 string (optionally). The file is closed at the end.
2467
2468 Arguments:
2469   f            the FILE
2470   yield        pointer to the expandable string
2471   sizep        pointer to the current size
2472   ptrp         pointer to the current position
2473   eol          newline replacement string, or NULL
2474
2475 Returns:       new value of string pointer
2476 */
2477
2478 static uschar *
2479 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
2480 {
2481 int eollen;
2482 uschar buffer[1024];
2483
2484 eollen = (eol == NULL)? 0 : Ustrlen(eol);
2485
2486 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
2487   {
2488   int len = Ustrlen(buffer);
2489   if (eol != NULL && buffer[len-1] == '\n') len--;
2490   yield = string_cat(yield, sizep, ptrp, buffer, len);
2491   if (buffer[len] != 0)
2492     yield = string_cat(yield, sizep, ptrp, eol, eollen);
2493   }
2494
2495 if (yield != NULL) yield[*ptrp] = 0;
2496
2497 return yield;
2498 }
2499
2500
2501
2502
2503 /*************************************************
2504 *          Evaluate numeric expression           *
2505 *************************************************/
2506
2507 /* This is a set of mutually recursive functions that evaluate a simple
2508 arithmetic expression involving only + - * / and parentheses. The only one that
2509 is called from elsewhere is eval_expr, whose interface is:
2510
2511 Arguments:
2512   sptr          pointer to the pointer to the string - gets updated
2513   decimal       TRUE if numbers are to be assumed decimal
2514   error         pointer to where to put an error message - must be NULL on input
2515   endket        TRUE if ')' must terminate - FALSE for external call
2516
2517
2518 Returns:        on success: the value of the expression, with *error still NULL
2519                 on failure: an undefined value, with *error = a message
2520 */
2521
2522 static int eval_sumterm(uschar **, BOOL, uschar **);
2523
2524 static int
2525 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
2526 {
2527 uschar *s = *sptr;
2528 int x = eval_sumterm(&s, decimal, error);
2529 if (*error == NULL)
2530   {
2531   while (*s == '+' || *s == '-')
2532     {
2533     int op = *s++;
2534     int y = eval_sumterm(&s, decimal, error);
2535     if (*error != NULL) break;
2536     if (op == '+') x += y; else x -= y;
2537     }
2538   if (*error == NULL)
2539     {
2540     if (endket)
2541       {
2542       if (*s != ')')
2543         *error = US"expecting closing parenthesis";
2544       else
2545         while (isspace(*(++s)));
2546       }
2547     else if (*s != 0) *error = US"expecting + or -";
2548     }
2549   }
2550
2551 *sptr = s;
2552 return x;
2553 }
2554
2555 static int
2556 eval_term(uschar **sptr, BOOL decimal, uschar **error)
2557 {
2558 register int c;
2559 int n;
2560 uschar *s = *sptr;
2561 while (isspace(*s)) s++;
2562 c = *s;
2563 if (isdigit(c) || ((c == '-' || c == '+') && isdigit(s[1])))
2564   {
2565   int count;
2566   (void)sscanf(CS s, (decimal? "%d%n" : "%i%n"), &n, &count);
2567   s += count;
2568   if (tolower(*s) == 'k') { n *= 1024; s++; }
2569     else if (tolower(*s) == 'm') { n *= 1024*1024; s++; }
2570   while (isspace (*s)) s++;
2571   }
2572 else if (c == '(')
2573   {
2574   s++;
2575   n = eval_expr(&s, decimal, error, 1);
2576   }
2577 else
2578   {
2579   *error = US"expecting number or opening parenthesis";
2580   n = 0;
2581   }
2582 *sptr = s;
2583 return n;
2584 }
2585
2586 static int eval_sumterm(uschar **sptr, BOOL decimal, uschar **error)
2587 {
2588 uschar *s = *sptr;
2589 int x = eval_term(&s, decimal, error);
2590 if (*error == NULL)
2591   {
2592   while (*s == '*' || *s == '/')
2593     {
2594     int op = *s++;
2595     int y = eval_term(&s, decimal, error);
2596     if (*error != NULL) break;
2597     if (op == '*') x *= y; else x /= y;
2598     }
2599   }
2600 *sptr = s;
2601 return x;
2602 }
2603
2604
2605
2606
2607 /*************************************************
2608 *                 Expand string                  *
2609 *************************************************/
2610
2611 /* Returns either an unchanged string, or the expanded string in stacking pool
2612 store. Interpreted sequences are:
2613
2614    \...                    normal escaping rules
2615    $name                   substitutes the variable
2616    ${name}                 ditto
2617    ${op:string}            operates on the expanded string value
2618    ${item{arg1}{arg2}...}  expands the args and then does the business
2619                              some literal args are not enclosed in {}
2620
2621 There are now far too many operators and item types to make it worth listing
2622 them here in detail any more.
2623
2624 We use an internal routine recursively to handle embedded substrings. The
2625 external function follows. The yield is NULL if the expansion failed, and there
2626 are two cases: if something collapsed syntactically, or if "fail" was given
2627 as the action on a lookup failure. These can be distinguised by looking at the
2628 variable expand_string_forcedfail, which is TRUE in the latter case.
2629
2630 The skipping flag is set true when expanding a substring that isn't actually
2631 going to be used (after "if" or "lookup") and it prevents lookups from
2632 happening lower down.
2633
2634 Store usage: At start, a store block of the length of the input plus 64
2635 is obtained. This is expanded as necessary by string_cat(), which might have to
2636 get a new block, or might be able to expand the original. At the end of the
2637 function we can release any store above that portion of the yield block that
2638 was actually used. In many cases this will be optimal.
2639
2640 However: if the first item in the expansion is a variable name or header name,
2641 we reset the store before processing it; if the result is in fresh store, we
2642 use that without copying. This is helpful for expanding strings like
2643 $message_headers which can get very long.
2644
2645 Arguments:
2646   string         the string to be expanded
2647   ket_ends       true if expansion is to stop at }
2648   left           if not NULL, a pointer to the first character after the
2649                  expansion is placed here (typically used with ket_ends)
2650   skipping       TRUE for recursive calls when the value isn't actually going
2651                  to be used (to allow for optimisation)
2652
2653 Returns:         NULL if expansion fails:
2654                    expand_string_forcedfail is set TRUE if failure was forced
2655                    expand_string_message contains a textual error message
2656                  a pointer to the expanded string on success
2657 */
2658
2659 static uschar *
2660 expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
2661   BOOL skipping)
2662 {
2663 int ptr = 0;
2664 int size = Ustrlen(string)+ 64;
2665 int item_type;
2666 uschar *yield = store_get(size);
2667 uschar *s = string;
2668 uschar *save_expand_nstring[EXPAND_MAXN+1];
2669 int save_expand_nlength[EXPAND_MAXN+1];
2670
2671 expand_string_forcedfail = FALSE;
2672 expand_string_message = US"";
2673
2674 while (*s != 0)
2675   {
2676   uschar *value;
2677   uschar name[256];
2678
2679   /* \ escapes the next character, which must exist, or else
2680   the expansion fails. There's a special escape, \N, which causes
2681   copying of the subject verbatim up to the next \N. Otherwise,
2682   the escapes are the standard set. */
2683
2684   if (*s == '\\')
2685     {
2686     if (s[1] == 0)
2687       {
2688       expand_string_message = US"\\ at end of string";
2689       goto EXPAND_FAILED;
2690       }
2691
2692     if (s[1] == 'N')
2693       {
2694       uschar *t = s + 2;
2695       for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
2696       yield = string_cat(yield, &size, &ptr, t, s - t);
2697       if (*s != 0) s += 2;
2698       }
2699
2700     else
2701       {
2702       uschar ch[1];
2703       ch[0] = string_interpret_escape(&s);
2704       s++;
2705       yield = string_cat(yield, &size, &ptr, ch, 1);
2706       }
2707
2708     continue;
2709     }
2710
2711   /* Anything other than $ is just copied verbatim, unless we are
2712   looking for a terminating } character. */
2713
2714   if (ket_ends && *s == '}') break;
2715
2716   if (*s != '$')
2717     {
2718     yield = string_cat(yield, &size, &ptr, s++, 1);
2719     continue;
2720     }
2721
2722   /* No { after the $ - must be a plain name or a number for string
2723   match variable. There has to be a fudge for variables that are the
2724   names of header fields preceded by "$header_" because header field
2725   names can contain any printing characters except space and colon.
2726   For those that don't like typing this much, "$h_" is a synonym for
2727   "$header_". A non-existent header yields a NULL value; nothing is
2728   inserted. */
2729
2730   if (isalpha((*(++s))))
2731     {
2732     int len;
2733     int newsize = 0;
2734
2735     s = read_name(name, sizeof(name), s, US"_");
2736
2737     /* If this is the first thing to be expanded, release the pre-allocated
2738     buffer. */
2739
2740     if (ptr == 0 && yield != NULL)
2741       {
2742       store_reset(yield);
2743       yield = NULL;
2744       size = 0;
2745       }
2746
2747     /* Header */
2748
2749     if (Ustrncmp(name, "h_", 2) == 0 ||
2750         Ustrncmp(name, "rh_", 3) == 0 ||
2751         Ustrncmp(name, "bh_", 3) == 0 ||
2752         Ustrncmp(name, "header_", 7) == 0 ||
2753         Ustrncmp(name, "rheader_", 8) == 0 ||
2754         Ustrncmp(name, "bheader_", 8) == 0)
2755       {
2756       BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
2757       uschar *charset = (name[0] == 'b')? NULL : headers_charset;
2758       s = read_header_name(name, sizeof(name), s);
2759       value = find_header(name, FALSE, &newsize, want_raw, charset);
2760
2761       /* If we didn't find the header, and the header contains a closing brace
2762       characters, this may be a user error where the terminating colon
2763       has been omitted. Set a flag to adjust the error message in this case.
2764       But there is no error here - nothing gets inserted. */
2765
2766       if (value == NULL)
2767         {
2768         if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2769         continue;
2770         }
2771       }
2772
2773     /* Variable */
2774
2775     else
2776       {
2777       value = find_variable(name, FALSE, skipping, &newsize);
2778       if (value == NULL)
2779         {
2780         expand_string_message =
2781           string_sprintf("unknown variable name \"%s\"", name);
2782         goto EXPAND_FAILED;
2783         }
2784       }
2785
2786     /* If the data is known to be in a new buffer, newsize will be set to the
2787     size of that buffer. If this is the first thing in an expansion string,
2788     yield will be NULL; just point it at the new store instead of copying. Many
2789     expansion strings contain just one reference, so this is a useful
2790     optimization, especially for humungous headers. */
2791
2792     len = Ustrlen(value);
2793     if (yield == NULL && newsize != 0)
2794       {
2795       yield = value;
2796       size = newsize;
2797       ptr = len;
2798       }
2799     else yield = string_cat(yield, &size, &ptr, value, len);
2800
2801     continue;
2802     }
2803
2804   if (isdigit(*s))
2805     {
2806     int n;
2807     s = read_number(&n, s);
2808     if (n >= 0 && n <= expand_nmax)
2809       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
2810         expand_nlength[n]);
2811     continue;
2812     }
2813
2814   /* Otherwise, if there's no '{' after $ it's an error. */
2815
2816   if (*s != '{')
2817     {
2818     expand_string_message = US"$ not followed by letter, digit, or {";
2819     goto EXPAND_FAILED;
2820     }
2821
2822   /* After { there can be various things, but they all start with
2823   an initial word, except for a number for a string match variable. */
2824
2825   if (isdigit((*(++s))))
2826     {
2827     int n;
2828     s = read_number(&n, s);
2829     if (*s++ != '}')
2830       {
2831       expand_string_message = US"} expected after number";
2832       goto EXPAND_FAILED;
2833       }
2834     if (n >= 0 && n <= expand_nmax)
2835       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
2836         expand_nlength[n]);
2837     continue;
2838     }
2839
2840   if (!isalpha(*s))
2841     {
2842     expand_string_message = US"letter or digit expected after ${";
2843     goto EXPAND_FAILED;
2844     }
2845
2846   /* Allow "-" in names to cater for substrings with negative
2847   arguments. Since we are checking for known names after { this is
2848   OK. */
2849
2850   s = read_name(name, sizeof(name), s, US"_-");
2851   item_type = chop_match(name, item_table, sizeof(item_table)/sizeof(uschar *));
2852
2853   switch(item_type)
2854     {
2855     /* Handle conditionals - preserve the values of the numerical expansion
2856     variables in case they get changed by a regular expression match in the
2857     condition. If not, they retain their external settings. At the end
2858     of this "if" section, they get restored to their previous values. */
2859
2860     case EITEM_IF:
2861       {
2862       BOOL cond = FALSE;
2863       uschar *next_s;
2864       int save_expand_nmax =
2865         save_expand_strings(save_expand_nstring, save_expand_nlength);
2866
2867       while (isspace(*s)) s++;
2868       next_s = eval_condition(s, skipping? NULL : &cond);
2869       if (next_s == NULL) goto EXPAND_FAILED;  /* message already set */
2870
2871       DEBUG(D_expand)
2872         debug_printf("condition: %.*s\n   result: %s\n", (int)(next_s - s), s,
2873           cond? "true" : "false");
2874
2875       s = next_s;
2876
2877       /* The handling of "yes" and "no" result strings is now in a separate
2878       function that is also used by ${lookup} and ${extract} and ${run}. */
2879
2880       switch(process_yesno(
2881                skipping,                     /* were previously skipping */
2882                cond,                         /* success/failure indicator */
2883                lookup_value,                 /* value to reset for string2 */
2884                &s,                           /* input pointer */
2885                &yield,                       /* output pointer */
2886                &size,                        /* output size */
2887                &ptr,                         /* output current point */
2888                US"if"))                      /* condition type */
2889         {
2890         case 1: goto EXPAND_FAILED;          /* when all is well, the */
2891         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
2892         }
2893
2894       /* Restore external setting of expansion variables for continuation
2895       at this level. */
2896
2897       restore_expand_strings(save_expand_nmax, save_expand_nstring,
2898         save_expand_nlength);
2899       continue;
2900       }
2901
2902     /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
2903     expanding an internal string that isn't actually going to be used. All we
2904     need to do is check the syntax, so don't do a lookup at all. Preserve the
2905     values of the numerical expansion variables in case they get changed by a
2906     partial lookup. If not, they retain their external settings. At the end
2907     of this "lookup" section, they get restored to their previous values. */
2908
2909     case EITEM_LOOKUP:
2910       {
2911       int stype, partial, affixlen, starflags;
2912       int expand_setup = 0;
2913       int nameptr = 0;
2914       uschar *key, *filename, *affix;
2915       uschar *save_lookup_value = lookup_value;
2916       int save_expand_nmax =
2917         save_expand_strings(save_expand_nstring, save_expand_nlength);
2918
2919       if ((expand_forbid & RDO_LOOKUP) != 0)
2920         {
2921         expand_string_message = US"lookup expansions are not permitted";
2922         goto EXPAND_FAILED;
2923         }
2924
2925       /* Get the key we are to look up for single-key+file style lookups.
2926       Otherwise set the key NULL pro-tem. */
2927
2928       while (isspace(*s)) s++;
2929       if (*s == '{')
2930         {
2931         key = expand_string_internal(s+1, TRUE, &s, skipping);
2932         if (key == NULL) goto EXPAND_FAILED;
2933         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
2934         while (isspace(*s)) s++;
2935         }
2936       else key = NULL;
2937
2938       /* Find out the type of database */
2939
2940       if (!isalpha(*s))
2941         {
2942         expand_string_message = US"missing lookup type";
2943         goto EXPAND_FAILED;
2944         }
2945
2946       /* The type is a string that may contain special characters of various
2947       kinds. Allow everything except space or { to appear; the actual content
2948       is checked by search_findtype_partial. */
2949
2950       while (*s != 0 && *s != '{' && !isspace(*s))
2951         {
2952         if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
2953         s++;
2954         }
2955       name[nameptr] = 0;
2956       while (isspace(*s)) s++;
2957
2958       /* Now check for the individual search type and any partial or default
2959       options. Only those types that are actually in the binary are valid. */
2960
2961       stype = search_findtype_partial(name, &partial, &affix, &affixlen,
2962         &starflags);
2963       if (stype < 0)
2964         {
2965         expand_string_message = search_error_message;
2966         goto EXPAND_FAILED;
2967         }
2968
2969       /* Check that a key was provided for those lookup types that need it,
2970       and was not supplied for those that use the query style. */
2971
2972       if (!mac_islookup(stype, lookup_querystyle))
2973         {
2974         if (key == NULL)
2975           {
2976           expand_string_message = string_sprintf("missing {key} for single-"
2977             "key \"%s\" lookup", name);
2978           goto EXPAND_FAILED;
2979           }
2980         }
2981       else
2982         {
2983         if (key != NULL)
2984           {
2985           expand_string_message = string_sprintf("a single key was given for "
2986             "lookup type \"%s\", which is not a single-key lookup type", name);
2987           goto EXPAND_FAILED;
2988           }
2989         }
2990
2991       /* Get the next string in brackets and expand it. It is the file name for
2992       single-key+file lookups, and the whole query otherwise. */
2993
2994       if (*s != '{') goto EXPAND_FAILED_CURLY;
2995       filename = expand_string_internal(s+1, TRUE, &s, skipping);
2996       if (filename == NULL) goto EXPAND_FAILED;
2997       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
2998       while (isspace(*s)) s++;
2999
3000       /* If this isn't a single-key+file lookup, re-arrange the variables
3001       to be appropriate for the search_ functions. */
3002
3003       if (key == NULL)
3004         {
3005         key = filename;
3006         filename = NULL;
3007         }
3008
3009       /* If skipping, don't do the next bit - just lookup_value == NULL, as if
3010       the entry was not found. Note that there is no search_close() function.
3011       Files are left open in case of re-use. At suitable places in higher logic,
3012       search_tidyup() is called to tidy all open files. This can save opening
3013       the same file several times. However, files may also get closed when
3014       others are opened, if too many are open at once. The rule is that a
3015       handle should not be used after a second search_open().
3016
3017       Request that a partial search sets up $1 and maybe $2 by passing
3018       expand_setup containing zero. If its value changes, reset expand_nmax,
3019       since new variables will have been set. Note that at the end of this
3020       "lookup" section, the old numeric variables are restored. */
3021
3022       if (skipping)
3023         lookup_value = NULL;
3024       else
3025         {
3026         void *handle = search_open(filename, stype, 0, NULL, NULL);
3027         if (handle == NULL)
3028           {
3029           expand_string_message = search_error_message;
3030           goto EXPAND_FAILED;
3031           }
3032         lookup_value = search_find(handle, filename, key, partial, affix,
3033           affixlen, starflags, &expand_setup);
3034         if (search_find_defer)
3035           {
3036           expand_string_message =
3037             string_sprintf("lookup of \"%s\" gave DEFER: %s", key,
3038               search_error_message);
3039           goto EXPAND_FAILED;
3040           }
3041         if (expand_setup > 0) expand_nmax = expand_setup;
3042         }
3043
3044       /* The handling of "yes" and "no" result strings is now in a separate
3045       function that is also used by ${if} and ${extract}. */
3046
3047       switch(process_yesno(
3048                skipping,                     /* were previously skipping */
3049                lookup_value != NULL,         /* success/failure indicator */
3050                save_lookup_value,            /* value to reset for string2 */
3051                &s,                           /* input pointer */
3052                &yield,                       /* output pointer */
3053                &size,                        /* output size */
3054                &ptr,                         /* output current point */
3055                US"lookup"))                  /* condition type */
3056         {
3057         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3058         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3059         }
3060
3061       /* Restore external setting of expansion variables for carrying on
3062       at this level, and continue. */
3063
3064       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3065         save_expand_nlength);
3066       continue;
3067       }
3068
3069     /* If Perl support is configured, handle calling embedded perl subroutines,
3070     unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
3071     or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
3072     arguments (defined below). */
3073
3074     #define EXIM_PERL_MAX_ARGS 8
3075
3076     case EITEM_PERL:
3077     #ifndef EXIM_PERL
3078     expand_string_message = US"\"${perl\" encountered, but this facility "
3079       "is not included in this binary";
3080     goto EXPAND_FAILED;
3081
3082     #else   /* EXIM_PERL */
3083       {
3084       uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
3085       uschar *new_yield;
3086
3087       if ((expand_forbid & RDO_PERL) != 0)
3088         {
3089         expand_string_message = US"Perl calls are not permitted";
3090         goto EXPAND_FAILED;
3091         }
3092
3093       switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
3094            US"perl"))
3095         {
3096         case 1: goto EXPAND_FAILED_CURLY;
3097         case 2:
3098         case 3: goto EXPAND_FAILED;
3099         }
3100
3101       /* If skipping, we don't actually do anything */
3102
3103       if (skipping) continue;
3104
3105       /* Start the interpreter if necessary */
3106
3107       if (!opt_perl_started)
3108         {
3109         uschar *initerror;
3110         if (opt_perl_startup == NULL)
3111           {
3112           expand_string_message = US"A setting of perl_startup is needed when "
3113             "using the Perl interpreter";
3114           goto EXPAND_FAILED;
3115           }
3116         DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
3117         initerror = init_perl(opt_perl_startup);
3118         if (initerror != NULL)
3119           {
3120           expand_string_message =
3121             string_sprintf("error in perl_startup code: %s\n", initerror);
3122           goto EXPAND_FAILED;
3123           }
3124         opt_perl_started = TRUE;
3125         }
3126
3127       /* Call the function */
3128
3129       sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
3130       new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
3131         sub_arg[0], sub_arg + 1);
3132
3133       /* NULL yield indicates failure; if the message pointer has been set to
3134       NULL, the yield was undef, indicating a forced failure. Otherwise the
3135       message will indicate some kind of Perl error. */
3136
3137       if (new_yield == NULL)
3138         {
3139         if (expand_string_message == NULL)
3140           {
3141           expand_string_message =
3142             string_sprintf("Perl subroutine \"%s\" returned undef to force "
3143               "failure", sub_arg[0]);
3144           expand_string_forcedfail = TRUE;
3145           }
3146         goto EXPAND_FAILED;
3147         }
3148
3149       /* Yield succeeded. Ensure forcedfail is unset, just in case it got
3150       set during a callback from Perl. */
3151
3152       expand_string_forcedfail = FALSE;
3153       yield = new_yield;
3154       continue;
3155       }
3156     #endif /* EXIM_PERL */
3157
3158     /* Handle "readfile" to insert an entire file */
3159
3160     case EITEM_READFILE:
3161       {
3162       FILE *f;
3163       uschar *sub_arg[2];
3164
3165       if ((expand_forbid & RDO_READFILE) != 0)
3166         {
3167         expand_string_message = US"file insertions are not permitted";
3168         goto EXPAND_FAILED;
3169         }
3170
3171       switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile"))
3172         {
3173         case 1: goto EXPAND_FAILED_CURLY;
3174         case 2:
3175         case 3: goto EXPAND_FAILED;
3176         }
3177
3178       /* If skipping, we don't actually do anything */
3179
3180       if (skipping) continue;
3181
3182       /* Open the file and read it */
3183
3184       f = Ufopen(sub_arg[0], "rb");
3185       if (f == NULL)
3186         {
3187         expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
3188         goto EXPAND_FAILED;
3189         }
3190
3191       yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
3192       fclose(f);
3193       continue;
3194       }
3195
3196     /* Handle "readsocket" to insert data from a Unix domain socket */
3197
3198     case EITEM_READSOCK:
3199       {
3200       int fd;
3201       int timeout = 5;
3202       int save_ptr = ptr;
3203       FILE *f;
3204       struct sockaddr_un sockun;         /* don't call this "sun" ! */
3205       uschar *arg;
3206       uschar *sub_arg[4];
3207
3208       if ((expand_forbid & RDO_READSOCK) != 0)
3209         {
3210         expand_string_message = US"socket insertions are not permitted";
3211         goto EXPAND_FAILED;
3212         }
3213
3214       /* Read up to 4 arguments, but don't do the end of item check afterwards,
3215       because there may be a string for expansion on failure. */
3216
3217       switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket"))
3218         {
3219         case 1: goto EXPAND_FAILED_CURLY;
3220         case 2:                             /* Won't occur: no end check */
3221         case 3: goto EXPAND_FAILED;
3222         }
3223
3224       /* Sort out timeout, if given */
3225
3226       if (sub_arg[2] != NULL)
3227         {
3228         timeout = readconf_readtime(sub_arg[2], 0, FALSE);
3229         if (timeout < 0)
3230           {
3231           expand_string_message = string_sprintf("bad time value %s",
3232             sub_arg[2]);
3233           goto EXPAND_FAILED;
3234           }
3235         }
3236       else sub_arg[3] = NULL;                     /* No eol if no timeout */
3237
3238       /* If skipping, we don't actually do anything */
3239
3240       if (!skipping)
3241         {
3242         /* Make a connection to the socket */
3243
3244         if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
3245           {
3246           expand_string_message = string_sprintf("failed to create socket: %s",
3247             strerror(errno));
3248           goto SOCK_FAIL;
3249           }
3250
3251         sockun.sun_family = AF_UNIX;
3252         sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
3253           sub_arg[0]);
3254         if(connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
3255           {
3256           expand_string_message = string_sprintf("failed to connect to socket "
3257             "%s: %s", sub_arg[0], strerror(errno));
3258           goto SOCK_FAIL;
3259           }
3260         DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
3261
3262         /* Write the request string, if not empty */
3263
3264         if (sub_arg[1][0] != 0)
3265           {
3266           int len = Ustrlen(sub_arg[1]);
3267           DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
3268             sub_arg[1]);
3269           if (write(fd, sub_arg[1], len) != len)
3270             {
3271             expand_string_message = string_sprintf("request write to socket "
3272               "failed: %s", strerror(errno));
3273             goto SOCK_FAIL;
3274             }
3275           }
3276
3277         /* Now we need to read from the socket, under a timeout. The function
3278         that reads a file can be used. */
3279
3280         f = fdopen(fd, "rb");
3281         sigalrm_seen = FALSE;
3282         alarm(timeout);
3283         yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
3284         alarm(0);
3285         fclose(f);
3286
3287         /* After a timeout, we restore the pointer in the result, that is,
3288         make sure we add nothing from the socket. */
3289
3290         if (sigalrm_seen)
3291           {
3292           ptr = save_ptr;
3293           expand_string_message = US"socket read timed out";
3294           goto SOCK_FAIL;
3295           }
3296         }
3297
3298       /* The whole thing has worked (or we were skipping). If there is a
3299       failure string following, we need to skip it. */
3300
3301       if (*s == '{')
3302         {
3303         if (expand_string_internal(s+1, TRUE, &s, TRUE) == NULL)
3304           goto EXPAND_FAILED;
3305         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3306         while (isspace(*s)) s++;
3307         }
3308       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3309       continue;
3310
3311       /* Come here on failure to create socket, connect socket, write to the
3312       socket, or timeout on reading. If another substring follows, expand and
3313       use it. Otherwise, those conditions give expand errors. */
3314
3315       SOCK_FAIL:
3316       if (*s != '{') goto EXPAND_FAILED;
3317       DEBUG(D_any) debug_printf("%s\n", expand_string_message);
3318       arg = expand_string_internal(s+1, TRUE, &s, FALSE);
3319       if (arg == NULL) goto EXPAND_FAILED;
3320       yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
3321       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3322       while (isspace(*s)) s++;
3323       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3324       continue;
3325       }
3326
3327     /* Handle "run" to execute a program. */
3328
3329     case EITEM_RUN:
3330       {
3331       FILE *f;
3332       uschar *old_lookup_value = NULL;
3333       uschar *arg;
3334       uschar **argv;
3335       pid_t pid;
3336       int fd_in, fd_out;
3337       int lsize = 0;
3338       int lptr = 0;
3339
3340       if ((expand_forbid & RDO_RUN) != 0)
3341         {
3342         expand_string_message = US"running a command is not permitted";
3343         goto EXPAND_FAILED;
3344         }
3345
3346       while (isspace(*s)) s++;
3347       if (*s != '{') goto EXPAND_FAILED_CURLY;
3348       arg = expand_string_internal(s+1, TRUE, &s, skipping);
3349       if (arg == NULL) goto EXPAND_FAILED;
3350       while (isspace(*s)) s++;
3351       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3352
3353       if (skipping)   /* Just pretend it worked when we're skipping */
3354         {
3355         runrc = 0;
3356         }
3357       else
3358         {
3359         if (!transport_set_up_command(&argv,    /* anchor for arg list */
3360             arg,                                /* raw command */
3361             FALSE,                              /* don't expand the arguments */
3362             0,                                  /* not relevant when... */
3363             NULL,                               /* no transporting address */
3364             US"${run} expansion",               /* for error messages */
3365             &expand_string_message))            /* where to put error message */
3366           {
3367           goto EXPAND_FAILED;
3368           }
3369
3370         /* Create the child process, making it a group leader. */
3371
3372         pid = child_open(argv, NULL, 0077, &fd_in, &fd_out, TRUE);
3373
3374         if (pid < 0)
3375           {
3376           expand_string_message =
3377             string_sprintf("couldn't create child process: %s", strerror(errno));
3378           goto EXPAND_FAILED;
3379           }
3380
3381         /* Nothing is written to the standard input. */
3382
3383         close(fd_in);
3384
3385         /* Wait for the process to finish, applying the timeout, and inspect its
3386         return code for serious disasters. Simple non-zero returns are passed on.
3387         */
3388
3389         if ((runrc = child_close(pid, 60)) < 0)
3390           {
3391           if (runrc == -256)
3392             {
3393             expand_string_message = string_sprintf("command timed out");
3394             killpg(pid, SIGKILL);       /* Kill the whole process group */
3395             }
3396
3397           else if (runrc == -257)
3398             expand_string_message = string_sprintf("wait() failed: %s",
3399               strerror(errno));
3400
3401           else
3402             expand_string_message = string_sprintf("command killed by signal %d",
3403               -runrc);
3404
3405           goto EXPAND_FAILED;
3406           }
3407
3408         /* Read the pipe to get the command's output into $value (which is kept
3409         in lookup_value). */
3410
3411         f = fdopen(fd_out, "rb");
3412         old_lookup_value = lookup_value;
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 */
3419
3420       switch(process_yesno(
3421                skipping,                     /* were previously skipping */
3422                runrc == 0,                   /* success/failure indicator */
3423                old_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 */