src/src/expand.c

   1 /* $Cambridge: exim/src/src/expand.c,v 1.62 2006/09/19 14:31:07 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2006 */
   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"prvs",
  61   US"prvscheck",
  62   US"readfile",
  63   US"readsocket",
  64   US"run",
  65   US"sg",
  66   US"substr",
  67   US"tr" };
  68
  69 enum {
  70   EITEM_DLFUNC,
  71   EITEM_EXTRACT,
  72   EITEM_HASH,
  73   EITEM_HMAC,
  74   EITEM_IF,
  75   EITEM_LENGTH,
  76   EITEM_LOOKUP,
  77   EITEM_NHASH,
  78   EITEM_PERL,
  79   EITEM_PRVS,
  80   EITEM_PRVSCHECK,
  81   EITEM_READFILE,
  82   EITEM_READSOCK,
  83   EITEM_RUN,
  84   EITEM_SG,
  85   EITEM_SUBSTR,
  86   EITEM_TR };
  87
  88 /* Tables of operator names, and corresponding switch numbers. The names must be
  89 in alphabetical order. There are two tables, because underscore is used in some
  90 cases to introduce arguments, whereas for other it is part of the name. This is
  91 an historical mis-design. */
  92
  93 static uschar *op_table_underscore[] = {
  94   US"from_utf8",
  95   US"local_part",
  96   US"quote_local_part",
  97   US"time_eval",
  98   US"time_interval"};
  99
 100 enum {
 101   EOP_FROM_UTF8,
 102   EOP_LOCAL_PART,
 103   EOP_QUOTE_LOCAL_PART,
 104   EOP_TIME_EVAL,
 105   EOP_TIME_INTERVAL };
 106
 107 static uschar *op_table_main[] = {
 108   US"address",
 109   US"base62",
 110   US"base62d",
 111   US"domain",
 112   US"escape",
 113   US"eval",
 114   US"eval10",
 115   US"expand",
 116   US"h",
 117   US"hash",
 118   US"hex2b64",
 119   US"l",
 120   US"lc",
 121   US"length",
 122   US"mask",
 123   US"md5",
 124   US"nh",
 125   US"nhash",
 126   US"quote",
 127   US"rfc2047",
 128   US"rxquote",
 129   US"s",
 130   US"sha1",
 131   US"stat",
 132   US"str2b64",
 133   US"strlen",
 134   US"substr",
 135   US"uc" };
 136
 137 enum {
 138   EOP_ADDRESS =  sizeof(op_table_underscore)/sizeof(uschar *),
 139   EOP_BASE62,
 140   EOP_BASE62D,
 141   EOP_DOMAIN,
 142   EOP_ESCAPE,
 143   EOP_EVAL,
 144   EOP_EVAL10,
 145   EOP_EXPAND,
 146   EOP_H,
 147   EOP_HASH,
 148   EOP_HEX2B64,
 149   EOP_L,
 150   EOP_LC,
 151   EOP_LENGTH,
 152   EOP_MASK,
 153   EOP_MD5,
 154   EOP_NH,
 155   EOP_NHASH,
 156   EOP_QUOTE,
 157   EOP_RFC2047,
 158   EOP_RXQUOTE,
 159   EOP_S,
 160   EOP_SHA1,
 161   EOP_STAT,
 162   EOP_STR2B64,
 163   EOP_STRLEN,
 164   EOP_SUBSTR,
 165   EOP_UC };
 166
 167
 168 /* Table of condition names, and corresponding switch numbers. The names must
 169 be in alphabetical order. */
 170
 171 static uschar *cond_table[] = {
 172   US"<",
 173   US"<=",
 174   US"=",
 175   US"==",     /* Backward compatibility */
 176   US">",
 177   US">=",
 178   US"and",
 179   US"crypteq",
 180   US"def",
 181   US"eq",
 182   US"eqi",
 183   US"exists",
 184   US"first_delivery",
 185   US"ge",
 186   US"gei",
 187   US"gt",
 188   US"gti",
 189   US"isip",
 190   US"isip4",
 191   US"isip6",
 192   US"ldapauth",
 193   US"le",
 194   US"lei",
 195   US"lt",
 196   US"lti",
 197   US"match",
 198   US"match_address",
 199   US"match_domain",
 200   US"match_ip",
 201   US"match_local_part",
 202   US"or",
 203   US"pam",
 204   US"pwcheck",
 205   US"queue_running",
 206   US"radius",
 207   US"saslauthd"
 208 };
 209
 210 enum {
 211   ECOND_NUM_L,
 212   ECOND_NUM_LE,
 213   ECOND_NUM_E,
 214   ECOND_NUM_EE,
 215   ECOND_NUM_G,
 216   ECOND_NUM_GE,
 217   ECOND_AND,
 218   ECOND_CRYPTEQ,
 219   ECOND_DEF,
 220   ECOND_STR_EQ,
 221   ECOND_STR_EQI,
 222   ECOND_EXISTS,
 223   ECOND_FIRST_DELIVERY,
 224   ECOND_STR_GE,
 225   ECOND_STR_GEI,
 226   ECOND_STR_GT,
 227   ECOND_STR_GTI,
 228   ECOND_ISIP,
 229   ECOND_ISIP4,
 230   ECOND_ISIP6,
 231   ECOND_LDAPAUTH,
 232   ECOND_STR_LE,
 233   ECOND_STR_LEI,
 234   ECOND_STR_LT,
 235   ECOND_STR_LTI,
 236   ECOND_MATCH,
 237   ECOND_MATCH_ADDRESS,
 238   ECOND_MATCH_DOMAIN,
 239   ECOND_MATCH_IP,
 240   ECOND_MATCH_LOCAL_PART,
 241   ECOND_OR,
 242   ECOND_PAM,
 243   ECOND_PWCHECK,
 244   ECOND_QUEUE_RUNNING,
 245   ECOND_RADIUS,
 246   ECOND_SASLAUTHD
 247 };
 248
 249
 250 /* Type for main variable table */
 251
 252 typedef struct {
 253   char *name;
 254   int   type;
 255   void *value;
 256 } var_entry;
 257
 258 /* Type for entries pointing to address/length pairs. Not currently
 259 in use. */
 260
 261 typedef struct {
 262   uschar **address;
 263   int  *length;
 264 } alblock;
 265
 266 /* Types of table entry */
 267
 268 enum {
 269   vtype_int,            /* value is address of int */
 270   vtype_filter_int,     /* ditto, but recognized only when filtering */
 271   vtype_ino,            /* value is address of ino_t (not always an int) */
 272   vtype_uid,            /* value is address of uid_t (not always an int) */
 273   vtype_gid,            /* value is address of gid_t (not always an int) */
 274   vtype_stringptr,      /* value is address of pointer to string */
 275   vtype_msgbody,        /* as stringptr, but read when first required */
 276   vtype_msgbody_end,    /* ditto, the end of the message */
 277   vtype_msgheaders,     /* the message's headers */
 278   vtype_localpart,      /* extract local part from string */
 279   vtype_domain,         /* extract domain from string */
 280   vtype_recipients,     /* extract recipients from recipients list */
 281                         /* (enabled only during system filtering */
 282   vtype_todbsdin,       /* value not used; generate BSD inbox tod */
 283   vtype_tode,           /* value not used; generate tod in epoch format */
 284   vtype_todf,           /* value not used; generate full tod */
 285   vtype_todl,           /* value not used; generate log tod */
 286   vtype_todlf,          /* value not used; generate log file datestamp tod */
 287   vtype_todzone,        /* value not used; generate time zone only */
 288   vtype_todzulu,        /* value not used; generate zulu tod */
 289   vtype_reply,          /* value not used; get reply from headers */
 290   vtype_pid,            /* value not used; result is pid */
 291   vtype_host_lookup,    /* value not used; get host name */
 292   vtype_load_avg,       /* value not used; result is int from os_getloadavg */
 293   vtype_pspace,         /* partition space; value is T/F for spool/log */
 294   vtype_pinodes         /* partition inodes; value is T/F for spool/log */
 295 #ifdef EXPERIMENTAL_DOMAINKEYS
 296  ,vtype_dk_verify       /* Serve request out of DomainKeys verification structure */
 297 #endif
 298   };
 299
 300 /* This table must be kept in alphabetical order. */
 301
 302 static var_entry var_table[] = {
 303   /* WARNING: Do not invent variables whose names start acl_c or acl_m because
 304      they will be confused with user-creatable ACL variables. */
 305   { "acl_verify_message",  vtype_stringptr,   &acl_verify_message },
 306   { "address_data",        vtype_stringptr,   &deliver_address_data },
 307   { "address_file",        vtype_stringptr,   &address_file },
 308   { "address_pipe",        vtype_stringptr,   &address_pipe },
 309   { "authenticated_id",    vtype_stringptr,   &authenticated_id },
 310   { "authenticated_sender",vtype_stringptr,   &authenticated_sender },
 311   { "authentication_failed",vtype_int,        &authentication_failed },
 312 #ifdef EXPERIMENTAL_BRIGHTMAIL
 313   { "bmi_alt_location",    vtype_stringptr,   &bmi_alt_location },
 314   { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
 315   { "bmi_base64_verdict",  vtype_stringptr,   &bmi_base64_verdict },
 316   { "bmi_deliver",         vtype_int,         &bmi_deliver },
 317 #endif
 318   { "body_linecount",      vtype_int,         &body_linecount },
 319   { "body_zerocount",      vtype_int,         &body_zerocount },
 320   { "bounce_recipient",    vtype_stringptr,   &bounce_recipient },
 321   { "bounce_return_size_limit", vtype_int,    &bounce_return_size_limit },
 322   { "caller_gid",          vtype_gid,         &real_gid },
 323   { "caller_uid",          vtype_uid,         &real_uid },
 324   { "compile_date",        vtype_stringptr,   &version_date },
 325   { "compile_number",      vtype_stringptr,   &version_cnumber },
 326   { "csa_status",          vtype_stringptr,   &csa_status },
 327 #ifdef WITH_OLD_DEMIME
 328   { "demime_errorlevel",   vtype_int,         &demime_errorlevel },
 329   { "demime_reason",       vtype_stringptr,   &demime_reason },
 330 #endif
 331 #ifdef EXPERIMENTAL_DOMAINKEYS
 332   { "dk_domain",           vtype_stringptr,   &dk_signing_domain },
 333   { "dk_is_signed",        vtype_dk_verify,   NULL },
 334   { "dk_result",           vtype_dk_verify,   NULL },
 335   { "dk_selector",         vtype_stringptr,   &dk_signing_selector },
 336   { "dk_sender",           vtype_dk_verify,   NULL },
 337   { "dk_sender_domain",    vtype_dk_verify,   NULL },
 338   { "dk_sender_local_part",vtype_dk_verify,   NULL },
 339   { "dk_sender_source",    vtype_dk_verify,   NULL },
 340   { "dk_signsall",         vtype_dk_verify,   NULL },
 341   { "dk_status",           vtype_dk_verify,   NULL },
 342   { "dk_testing",          vtype_dk_verify,   NULL },
 343 #endif
 344   { "dnslist_domain",      vtype_stringptr,   &dnslist_domain },
 345   { "dnslist_text",        vtype_stringptr,   &dnslist_text },
 346   { "dnslist_value",       vtype_stringptr,   &dnslist_value },
 347   { "domain",              vtype_stringptr,   &deliver_domain },
 348   { "domain_data",         vtype_stringptr,   &deliver_domain_data },
 349   { "exim_gid",            vtype_gid,         &exim_gid },
 350   { "exim_path",           vtype_stringptr,   &exim_path },
 351   { "exim_uid",            vtype_uid,         &exim_uid },
 352 #ifdef WITH_OLD_DEMIME
 353   { "found_extension",     vtype_stringptr,   &found_extension },
 354 #endif
 355   { "home",                vtype_stringptr,   &deliver_home },
 356   { "host",                vtype_stringptr,   &deliver_host },
 357   { "host_address",        vtype_stringptr,   &deliver_host_address },
 358   { "host_data",           vtype_stringptr,   &host_data },
 359   { "host_lookup_deferred",vtype_int,         &host_lookup_deferred },
 360   { "host_lookup_failed",  vtype_int,         &host_lookup_failed },
 361   { "inode",               vtype_ino,         &deliver_inode },
 362   { "interface_address",   vtype_stringptr,   &interface_address },
 363   { "interface_port",      vtype_int,         &interface_port },
 364   #ifdef LOOKUP_LDAP
 365   { "ldap_dn",             vtype_stringptr,   &eldap_dn },
 366   #endif
 367   { "load_average",        vtype_load_avg,    NULL },
 368   { "local_part",          vtype_stringptr,   &deliver_localpart },
 369   { "local_part_data",     vtype_stringptr,   &deliver_localpart_data },
 370   { "local_part_prefix",   vtype_stringptr,   &deliver_localpart_prefix },
 371   { "local_part_suffix",   vtype_stringptr,   &deliver_localpart_suffix },
 372   { "local_scan_data",     vtype_stringptr,   &local_scan_data },
 373   { "local_user_gid",      vtype_gid,         &local_user_gid },
 374   { "local_user_uid",      vtype_uid,         &local_user_uid },
 375   { "localhost_number",    vtype_int,         &host_number },
 376   { "log_inodes",          vtype_pinodes,     (void *)FALSE },
 377   { "log_space",           vtype_pspace,      (void *)FALSE },
 378   { "mailstore_basename",  vtype_stringptr,   &mailstore_basename },
 379 #ifdef WITH_CONTENT_SCAN
 380   { "malware_name",        vtype_stringptr,   &malware_name },
 381 #endif
 382   { "message_age",         vtype_int,         &message_age },
 383   { "message_body",        vtype_msgbody,     &message_body },
 384   { "message_body_end",    vtype_msgbody_end, &message_body_end },
 385   { "message_body_size",   vtype_int,         &message_body_size },
 386   { "message_exim_id",     vtype_stringptr,   &message_id },
 387   { "message_headers",     vtype_msgheaders,  NULL },
 388   { "message_id",          vtype_stringptr,   &message_id },
 389   { "message_linecount",   vtype_int,         &message_linecount },
 390   { "message_size",        vtype_int,         &message_size },
 391 #ifdef WITH_CONTENT_SCAN
 392   { "mime_anomaly_level",  vtype_int,         &mime_anomaly_level },
 393   { "mime_anomaly_text",   vtype_stringptr,   &mime_anomaly_text },
 394   { "mime_boundary",       vtype_stringptr,   &mime_boundary },
 395   { "mime_charset",        vtype_stringptr,   &mime_charset },
 396   { "mime_content_description", vtype_stringptr, &mime_content_description },
 397   { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
 398   { "mime_content_id",     vtype_stringptr,   &mime_content_id },
 399   { "mime_content_size",   vtype_int,         &mime_content_size },
 400   { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
 401   { "mime_content_type",   vtype_stringptr,   &mime_content_type },
 402   { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
 403   { "mime_filename",       vtype_stringptr,   &mime_filename },
 404   { "mime_is_coverletter", vtype_int,         &mime_is_coverletter },
 405   { "mime_is_multipart",   vtype_int,         &mime_is_multipart },
 406   { "mime_is_rfc822",      vtype_int,         &mime_is_rfc822 },
 407   { "mime_part_count",     vtype_int,         &mime_part_count },
 408 #endif
 409   { "n0",                  vtype_filter_int,  &filter_n[0] },
 410   { "n1",                  vtype_filter_int,  &filter_n[1] },
 411   { "n2",                  vtype_filter_int,  &filter_n[2] },
 412   { "n3",                  vtype_filter_int,  &filter_n[3] },
 413   { "n4",                  vtype_filter_int,  &filter_n[4] },
 414   { "n5",                  vtype_filter_int,  &filter_n[5] },
 415   { "n6",                  vtype_filter_int,  &filter_n[6] },
 416   { "n7",                  vtype_filter_int,  &filter_n[7] },
 417   { "n8",                  vtype_filter_int,  &filter_n[8] },
 418   { "n9",                  vtype_filter_int,  &filter_n[9] },
 419   { "original_domain",     vtype_stringptr,   &deliver_domain_orig },
 420   { "original_local_part", vtype_stringptr,   &deliver_localpart_orig },
 421   { "originator_gid",      vtype_gid,         &originator_gid },
 422   { "originator_uid",      vtype_uid,         &originator_uid },
 423   { "parent_domain",       vtype_stringptr,   &deliver_domain_parent },
 424   { "parent_local_part",   vtype_stringptr,   &deliver_localpart_parent },
 425   { "pid",                 vtype_pid,         NULL },
 426   { "primary_hostname",    vtype_stringptr,   &primary_hostname },
 427   { "prvscheck_address",   vtype_stringptr,   &prvscheck_address },
 428   { "prvscheck_keynum",    vtype_stringptr,   &prvscheck_keynum },
 429   { "prvscheck_result",    vtype_stringptr,   &prvscheck_result },
 430   { "qualify_domain",      vtype_stringptr,   &qualify_domain_sender },
 431   { "qualify_recipient",   vtype_stringptr,   &qualify_domain_recipient },
 432   { "rcpt_count",          vtype_int,         &rcpt_count },
 433   { "rcpt_defer_count",    vtype_int,         &rcpt_defer_count },
 434   { "rcpt_fail_count",     vtype_int,         &rcpt_fail_count },
 435   { "received_count",      vtype_int,         &received_count },
 436   { "received_for",        vtype_stringptr,   &received_for },
 437   { "received_protocol",   vtype_stringptr,   &received_protocol },
 438   { "received_time",       vtype_int,         &received_time },
 439   { "recipient_data",      vtype_stringptr,   &recipient_data },
 440   { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
 441   { "recipients",          vtype_recipients,  NULL },
 442   { "recipients_count",    vtype_int,         &recipients_count },
 443 #ifdef WITH_CONTENT_SCAN
 444   { "regex_match_string",  vtype_stringptr,   &regex_match_string },
 445 #endif
 446   { "reply_address",       vtype_reply,       NULL },
 447   { "return_path",         vtype_stringptr,   &return_path },
 448   { "return_size_limit",   vtype_int,         &bounce_return_size_limit },
 449   { "runrc",               vtype_int,         &runrc },
 450   { "self_hostname",       vtype_stringptr,   &self_hostname },
 451   { "sender_address",      vtype_stringptr,   &sender_address },
 452   { "sender_address_data", vtype_stringptr,   &sender_address_data },
 453   { "sender_address_domain", vtype_domain,    &sender_address },
 454   { "sender_address_local_part", vtype_localpart, &sender_address },
 455   { "sender_data",         vtype_stringptr,   &sender_data },
 456   { "sender_fullhost",     vtype_stringptr,   &sender_fullhost },
 457   { "sender_helo_name",    vtype_stringptr,   &sender_helo_name },
 458   { "sender_host_address", vtype_stringptr,   &sender_host_address },
 459   { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
 460   { "sender_host_name",    vtype_host_lookup, NULL },
 461   { "sender_host_port",    vtype_int,         &sender_host_port },
 462   { "sender_ident",        vtype_stringptr,   &sender_ident },
 463   { "sender_rate",         vtype_stringptr,   &sender_rate },
 464   { "sender_rate_limit",   vtype_stringptr,   &sender_rate_limit },
 465   { "sender_rate_period",  vtype_stringptr,   &sender_rate_period },
 466   { "sender_rcvhost",      vtype_stringptr,   &sender_rcvhost },
 467   { "sender_verify_failure",vtype_stringptr,  &sender_verify_failure },
 468   { "smtp_active_hostname", vtype_stringptr,  &smtp_active_hostname },
 469   { "smtp_command",        vtype_stringptr,   &smtp_cmd_buffer },
 470   { "smtp_command_argument", vtype_stringptr, &smtp_cmd_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, check_rfc2047_length, charset, '?', NULL,
1193     newsize, &error);
1194   if (error != NULL)
1195     {
1196     DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1197       "    input was: %s\n", error, yield);
1198     }
1199   if (decoded != NULL) yield = decoded;
1200   }
1201
1202 return yield;
1203 }
1204
1205
1206
1207
1208 /*************************************************
1209 *               Find value of a variable         *
1210 *************************************************/
1211
1212 /* The table of variables is kept in alphabetic order, so we can search it
1213 using a binary chop. The "choplen" variable is nothing to do with the binary
1214 chop.
1215
1216 Arguments:
1217   name          the name of the variable being sought
1218   exists_only   TRUE if this is a def: test; passed on to find_header()
1219   skipping      TRUE => skip any processing evaluation; this is not the same as
1220                   exists_only because def: may test for values that are first
1221                   evaluated here
1222   newsize       pointer to an int which is initially zero; if the answer is in
1223                 a new memory buffer, *newsize is set to its size
1224
1225 Returns:        NULL if the variable does not exist, or
1226                 a pointer to the variable's contents, or
1227                 something non-NULL if exists_only is TRUE
1228 */
1229
1230 static uschar *
1231 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1232 {
1233 int first = 0;
1234 int last = var_table_size;
1235
1236 /* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1237 Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1238 release 4.64 onwards arbitrary names are permitted, as long as the first 5
1239 characters are acl_c or acl_m and the sixth is either a digit or an underscore
1240 (this gave backwards compatibility at the changeover). There may be built-in
1241 variables whose names start acl_ but they should never start in this way. This
1242 slightly messy specification is a consequence of the history, needless to say.
1243
1244 If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1245 set, in which case give an error. */
1246
1247 if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1248      !isalpha(name[5]))
1249   {
1250   tree_node *node =
1251     tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
1252   return (node == NULL)? (strict_acl_vars? NULL : US"") : node->data.ptr;
1253   }
1254
1255 /* Handle $auth<n> variables. */
1256
1257 if (Ustrncmp(name, "auth", 4) == 0)
1258   {
1259   uschar *endptr;
1260   int n = Ustrtoul(name + 4, &endptr, 10);
1261   if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
1262     return (auth_vars[n-1] == NULL)? US"" : auth_vars[n-1];
1263   }
1264
1265 /* For all other variables, search the table */
1266
1267 while (last > first)
1268   {
1269   uschar *s, *domain;
1270   uschar **ss;
1271   int middle = (first + last)/2;
1272   int c = Ustrcmp(name, var_table[middle].name);
1273
1274   if (c > 0) { first = middle + 1; continue; }
1275   if (c < 0) { last = middle; continue; }
1276
1277   /* Found an existing variable. If in skipping state, the value isn't needed,
1278   and we want to avoid processing (such as looking up the host name). */
1279
1280   if (skipping) return US"";
1281
1282   switch (var_table[middle].type)
1283     {
1284 #ifdef EXPERIMENTAL_DOMAINKEYS
1285
1286     case vtype_dk_verify:
1287     if (dk_verify_block == NULL) return US"";
1288     s = NULL;
1289     if (Ustrcmp(var_table[middle].name, "dk_result") == 0)
1290       s = dk_verify_block->result_string;
1291     if (Ustrcmp(var_table[middle].name, "dk_sender") == 0)
1292       s = dk_verify_block->address;
1293     if (Ustrcmp(var_table[middle].name, "dk_sender_domain") == 0)
1294       s = dk_verify_block->domain;
1295     if (Ustrcmp(var_table[middle].name, "dk_sender_local_part") == 0)
1296       s = dk_verify_block->local_part;
1297
1298     if (Ustrcmp(var_table[middle].name, "dk_sender_source") == 0)
1299       switch(dk_verify_block->address_source) {
1300         case DK_EXIM_ADDRESS_NONE: s = US"0"; break;
1301         case DK_EXIM_ADDRESS_FROM_FROM: s = US"from"; break;
1302         case DK_EXIM_ADDRESS_FROM_SENDER: s = US"sender"; break;
1303       }
1304
1305     if (Ustrcmp(var_table[middle].name, "dk_status") == 0)
1306       switch(dk_verify_block->result) {
1307         case DK_EXIM_RESULT_ERR: s = US"error"; break;
1308         case DK_EXIM_RESULT_BAD_FORMAT: s = US"bad format"; break;
1309         case DK_EXIM_RESULT_NO_KEY: s = US"no key"; break;
1310         case DK_EXIM_RESULT_NO_SIGNATURE: s = US"no signature"; break;
1311         case DK_EXIM_RESULT_REVOKED: s = US"revoked"; break;
1312         case DK_EXIM_RESULT_NON_PARTICIPANT: s = US"non-participant"; break;
1313         case DK_EXIM_RESULT_GOOD: s = US"good"; break;
1314         case DK_EXIM_RESULT_BAD: s = US"bad"; break;
1315       }
1316
1317     if (Ustrcmp(var_table[middle].name, "dk_signsall") == 0)
1318       s = (dk_verify_block->signsall)? US"1" : US"0";
1319
1320     if (Ustrcmp(var_table[middle].name, "dk_testing") == 0)
1321       s = (dk_verify_block->testing)? US"1" : US"0";
1322
1323     if (Ustrcmp(var_table[middle].name, "dk_is_signed") == 0)
1324       s = (dk_verify_block->is_signed)? US"1" : US"0";
1325
1326     return (s == NULL)? US"" : s;
1327 #endif
1328
1329     case vtype_filter_int:
1330     if (!filter_running) return NULL;
1331     /* Fall through */
1332     /* VVVVVVVVVVVV */
1333     case vtype_int:
1334     sprintf(CS var_buffer, "%d", *(int *)(var_table[middle].value)); /* Integer */
1335     return var_buffer;
1336
1337     case vtype_ino:
1338     sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(var_table[middle].value))); /* Inode */
1339     return var_buffer;
1340
1341     case vtype_gid:
1342     sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(var_table[middle].value))); /* gid */
1343     return var_buffer;
1344
1345     case vtype_uid:
1346     sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(var_table[middle].value))); /* uid */
1347     return var_buffer;
1348
1349     case vtype_stringptr:                      /* Pointer to string */
1350     s = *((uschar **)(var_table[middle].value));
1351     return (s == NULL)? US"" : s;
1352
1353     case vtype_pid:
1354     sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1355     return var_buffer;
1356
1357     case vtype_load_avg:
1358     sprintf(CS var_buffer, "%d", os_getloadavg()); /* load_average */
1359     return var_buffer;
1360
1361     case vtype_host_lookup:                    /* Lookup if not done so */
1362     if (sender_host_name == NULL && sender_host_address != NULL &&
1363         !host_lookup_failed && host_name_lookup() == OK)
1364       host_build_sender_fullhost();
1365     return (sender_host_name == NULL)? US"" : sender_host_name;
1366
1367     case vtype_localpart:                      /* Get local part from address */
1368     s = *((uschar **)(var_table[middle].value));
1369     if (s == NULL) return US"";
1370     domain = Ustrrchr(s, '@');
1371     if (domain == NULL) return s;
1372     if (domain - s > sizeof(var_buffer) - 1)
1373       log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than %d in "
1374         "string expansion", sizeof(var_buffer));
1375     Ustrncpy(var_buffer, s, domain - s);
1376     var_buffer[domain - s] = 0;
1377     return var_buffer;
1378
1379     case vtype_domain:                         /* Get domain from address */
1380     s = *((uschar **)(var_table[middle].value));
1381     if (s == NULL) return US"";
1382     domain = Ustrrchr(s, '@');
1383     return (domain == NULL)? US"" : domain + 1;
1384
1385     case vtype_msgheaders:
1386     return find_header(NULL, exists_only, newsize, FALSE, NULL);
1387
1388     case vtype_msgbody:                        /* Pointer to msgbody string */
1389     case vtype_msgbody_end:                    /* Ditto, the end of the msg */
1390     ss = (uschar **)(var_table[middle].value);
1391     if (*ss == NULL && deliver_datafile >= 0)  /* Read body when needed */
1392       {
1393       uschar *body;
1394       off_t start_offset = SPOOL_DATA_START_OFFSET;
1395       int len = message_body_visible;
1396       if (len > message_size) len = message_size;
1397       *ss = body = store_malloc(len+1);
1398       body[0] = 0;
1399       if (var_table[middle].type == vtype_msgbody_end)
1400         {
1401         struct stat statbuf;
1402         if (fstat(deliver_datafile, &statbuf) == 0)
1403           {
1404           start_offset = statbuf.st_size - len;
1405           if (start_offset < SPOOL_DATA_START_OFFSET)
1406             start_offset = SPOOL_DATA_START_OFFSET;
1407           }
1408         }
1409       lseek(deliver_datafile, start_offset, SEEK_SET);
1410       len = read(deliver_datafile, body, len);
1411       if (len > 0)
1412         {
1413         body[len] = 0;
1414         while (len > 0)
1415           {
1416           if (body[--len] == '\n' || body[len] == 0) body[len] = ' ';
1417           }
1418         }
1419       }
1420     return (*ss == NULL)? US"" : *ss;
1421
1422     case vtype_todbsdin:                       /* BSD inbox time of day */
1423     return tod_stamp(tod_bsdin);
1424
1425     case vtype_tode:                           /* Unix epoch time of day */
1426     return tod_stamp(tod_epoch);
1427
1428     case vtype_todf:                           /* Full time of day */
1429     return tod_stamp(tod_full);
1430
1431     case vtype_todl:                           /* Log format time of day */
1432     return tod_stamp(tod_log_bare);            /* (without timezone) */
1433
1434     case vtype_todzone:                        /* Time zone offset only */
1435     return tod_stamp(tod_zone);
1436
1437     case vtype_todzulu:                        /* Zulu time */
1438     return tod_stamp(tod_zulu);
1439
1440     case vtype_todlf:                          /* Log file datestamp tod */
1441     return tod_stamp(tod_log_datestamp);
1442
1443     case vtype_reply:                          /* Get reply address */
1444     s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1445       headers_charset);
1446     if (s != NULL) while (isspace(*s)) s++;
1447     if (s == NULL || *s == 0)
1448       {
1449       *newsize = 0;                            /* For the *s==0 case */
1450       s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1451       }
1452     if (s != NULL)
1453       {
1454       uschar *t;
1455       while (isspace(*s)) s++;
1456       for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1457       while (t > s && isspace(t[-1])) t--;
1458       *t = 0;
1459       }
1460     return (s == NULL)? US"" : s;
1461
1462     /* A recipients list is available only during system message filtering,
1463     during ACL processing after DATA, and while expanding pipe commands
1464     generated from a system filter, but not elsewhere. */
1465
1466     case vtype_recipients:
1467     if (!enable_dollar_recipients) return NULL; else
1468       {
1469       int size = 128;
1470       int ptr = 0;
1471       int i;
1472       s = store_get(size);
1473       for (i = 0; i < recipients_count; i++)
1474         {
1475         if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1476         s = string_cat(s, &size, &ptr, recipients_list[i].address,
1477           Ustrlen(recipients_list[i].address));
1478         }
1479       s[ptr] = 0;     /* string_cat() leaves room */
1480       }
1481     return s;
1482
1483     case vtype_pspace:
1484       {
1485       int inodes;
1486       sprintf(CS var_buffer, "%d",
1487         receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes));
1488       }
1489     return var_buffer;
1490
1491     case vtype_pinodes:
1492       {
1493       int inodes;
1494       (void) receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes);
1495       sprintf(CS var_buffer, "%d", inodes);
1496       }
1497     return var_buffer;
1498     }
1499   }
1500
1501 return NULL;          /* Unknown variable name */
1502 }
1503
1504
1505
1506
1507 /*************************************************
1508 *           Read and expand substrings           *
1509 *************************************************/
1510
1511 /* This function is called to read and expand argument substrings for various
1512 expansion items. Some have a minimum requirement that is less than the maximum;
1513 in these cases, the first non-present one is set to NULL.
1514
1515 Arguments:
1516   sub        points to vector of pointers to set
1517   n          maximum number of substrings
1518   m          minimum required
1519   sptr       points to current string pointer
1520   skipping   the skipping flag
1521   check_end  if TRUE, check for final '}'
1522   name       name of item, for error message
1523
1524 Returns:     0 OK; string pointer updated
1525              1 curly bracketing error (too few arguments)
1526              2 too many arguments (only if check_end is set); message set
1527              3 other error (expansion failure)
1528 */
1529
1530 static int
1531 read_subs(uschar **sub, int n, int m, uschar **sptr, BOOL skipping,
1532   BOOL check_end, uschar *name)
1533 {
1534 int i;
1535 uschar *s = *sptr;
1536
1537 while (isspace(*s)) s++;
1538 for (i = 0; i < n; i++)
1539   {
1540   if (*s != '{')
1541     {
1542     if (i < m) return 1;
1543     sub[i] = NULL;
1544     break;
1545     }
1546   sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
1547   if (sub[i] == NULL) return 3;
1548   if (*s++ != '}') return 1;
1549   while (isspace(*s)) s++;
1550   }
1551 if (check_end && *s++ != '}')
1552   {
1553   if (s[-1] == '{')
1554     {
1555     expand_string_message = string_sprintf("Too many arguments for \"%s\" "
1556       "(max is %d)", name, n);
1557     return 2;
1558     }
1559   return 1;
1560   }
1561
1562 *sptr = s;
1563 return 0;
1564 }
1565
1566
1567
1568
1569 /*************************************************
1570 *     Elaborate message for bad variable         *
1571 *************************************************/
1572
1573 /* For the "unknown variable" message, take a look at the variable's name, and
1574 give additional information about possible ACL variables. The extra information
1575 is added on to expand_string_message.
1576
1577 Argument:   the name of the variable
1578 Returns:    nothing
1579 */
1580
1581 static void
1582 check_variable_error_message(uschar *name)
1583 {
1584 if (Ustrncmp(name, "acl_", 4) == 0)
1585   expand_string_message = string_sprintf("%s (%s)", expand_string_message,
1586     (name[4] == 'c' || name[4] == 'm')?
1587       (isalpha(name[5])?
1588         US"6th character of a user-defined ACL variable must be a digit or underscore" :
1589         US"strict_acl_vars is set"    /* Syntax is OK, it has to be this */
1590       ) :
1591       US"user-defined ACL variables must start acl_c or acl_m");
1592 }
1593
1594
1595
1596 /*************************************************
1597 *        Read and evaluate a condition           *
1598 *************************************************/
1599
1600 /*
1601 Arguments:
1602   s        points to the start of the condition text
1603   yield    points to a BOOL to hold the result of the condition test;
1604            if NULL, we are just reading through a condition that is
1605            part of an "or" combination to check syntax, or in a state
1606            where the answer isn't required
1607
1608 Returns:   a pointer to the first character after the condition, or
1609            NULL after an error
1610 */
1611
1612 static uschar *
1613 eval_condition(uschar *s, BOOL *yield)
1614 {
1615 BOOL testfor = TRUE;
1616 BOOL tempcond, combined_cond;
1617 BOOL *subcondptr;
1618 int i, rc, cond_type, roffset;
1619 int num[2];
1620 struct stat statbuf;
1621 uschar name[256];
1622 uschar *sub[4];
1623
1624 const pcre *re;
1625 const uschar *rerror;
1626
1627 for (;;)
1628   {
1629   while (isspace(*s)) s++;
1630   if (*s == '!') { testfor = !testfor; s++; } else break;
1631   }
1632
1633 /* Numeric comparisons are symbolic */
1634
1635 if (*s == '=' || *s == '>' || *s == '<')
1636   {
1637   int p = 0;
1638   name[p++] = *s++;
1639   if (*s == '=')
1640     {
1641     name[p++] = '=';
1642     s++;
1643     }
1644   name[p] = 0;
1645   }
1646
1647 /* All other conditions are named */
1648
1649 else s = read_name(name, 256, s, US"_");
1650
1651 /* If we haven't read a name, it means some non-alpha character is first. */
1652
1653 if (name[0] == 0)
1654   {
1655   expand_string_message = string_sprintf("condition name expected, "
1656     "but found \"%.16s\"", s);
1657   return NULL;
1658   }
1659
1660 /* Find which condition we are dealing with, and switch on it */
1661
1662 cond_type = chop_match(name, cond_table, sizeof(cond_table)/sizeof(uschar *));
1663 switch(cond_type)
1664   {
1665   /* def: tests for a non-empty variable, or for the existence of a header. If
1666   yield == NULL we are in a skipping state, and don't care about the answer. */
1667
1668   case ECOND_DEF:
1669   if (*s != ':')
1670     {
1671     expand_string_message = US"\":\" expected after \"def\"";
1672     return NULL;
1673     }
1674
1675   s = read_name(name, 256, s+1, US"_");
1676
1677   /* Test for a header's existence */
1678
1679   if (Ustrncmp(name, "h_", 2) == 0 ||
1680       Ustrncmp(name, "rh_", 3) == 0 ||
1681       Ustrncmp(name, "bh_", 3) == 0 ||
1682       Ustrncmp(name, "header_", 7) == 0 ||
1683       Ustrncmp(name, "rheader_", 8) == 0 ||
1684       Ustrncmp(name, "bheader_", 8) == 0)
1685     {
1686     s = read_header_name(name, 256, s);
1687     if (yield != NULL) *yield =
1688       (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
1689     }
1690
1691   /* Test for a variable's having a non-empty value. A non-existent variable
1692   causes an expansion failure. */
1693
1694   else
1695     {
1696     uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
1697     if (value == NULL)
1698       {
1699       expand_string_message = (name[0] == 0)?
1700         string_sprintf("variable name omitted after \"def:\"") :
1701         string_sprintf("unknown variable \"%s\" after \"def:\"", name);
1702       check_variable_error_message(name);
1703       return NULL;
1704       }
1705     if (yield != NULL) *yield = (value[0] != 0) == testfor;
1706     }
1707
1708   return s;
1709
1710
1711   /* first_delivery tests for first delivery attempt */
1712
1713   case ECOND_FIRST_DELIVERY:
1714   if (yield != NULL) *yield = deliver_firsttime == testfor;
1715   return s;
1716
1717
1718   /* queue_running tests for any process started by a queue runner */
1719
1720   case ECOND_QUEUE_RUNNING:
1721   if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
1722   return s;
1723
1724
1725   /* exists:  tests for file existence
1726        isip:  tests for any IP address
1727       isip4:  tests for an IPv4 address
1728       isip6:  tests for an IPv6 address
1729         pam:  does PAM authentication
1730      radius:  does RADIUS authentication
1731    ldapauth:  does LDAP authentication
1732     pwcheck:  does Cyrus SASL pwcheck authentication
1733   */
1734
1735   case ECOND_EXISTS:
1736   case ECOND_ISIP:
1737   case ECOND_ISIP4:
1738   case ECOND_ISIP6:
1739   case ECOND_PAM:
1740   case ECOND_RADIUS:
1741   case ECOND_LDAPAUTH:
1742   case ECOND_PWCHECK:
1743
1744   while (isspace(*s)) s++;
1745   if (*s != '{') goto COND_FAILED_CURLY_START;
1746
1747   sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1748   if (sub[0] == NULL) return NULL;
1749   if (*s++ != '}') goto COND_FAILED_CURLY_END;
1750
1751   if (yield == NULL) return s;   /* No need to run the test if skipping */
1752
1753   switch(cond_type)
1754     {
1755     case ECOND_EXISTS:
1756     if ((expand_forbid & RDO_EXISTS) != 0)
1757       {
1758       expand_string_message = US"File existence tests are not permitted";
1759       return NULL;
1760       }
1761     *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
1762     break;
1763
1764     case ECOND_ISIP:
1765     case ECOND_ISIP4:
1766     case ECOND_ISIP6:
1767     rc = string_is_ip_address(sub[0], NULL);
1768     *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
1769              (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
1770     break;
1771
1772     /* Various authentication tests - all optionally compiled */
1773
1774     case ECOND_PAM:
1775     #ifdef SUPPORT_PAM
1776     rc = auth_call_pam(sub[0], &expand_string_message);
1777     goto END_AUTH;
1778     #else
1779     goto COND_FAILED_NOT_COMPILED;
1780     #endif  /* SUPPORT_PAM */
1781
1782     case ECOND_RADIUS:
1783     #ifdef RADIUS_CONFIG_FILE
1784     rc = auth_call_radius(sub[0], &expand_string_message);
1785     goto END_AUTH;
1786     #else
1787     goto COND_FAILED_NOT_COMPILED;
1788     #endif  /* RADIUS_CONFIG_FILE */
1789
1790     case ECOND_LDAPAUTH:
1791     #ifdef LOOKUP_LDAP
1792       {
1793       /* Just to keep the interface the same */
1794       BOOL do_cache;
1795       int old_pool = store_pool;
1796       store_pool = POOL_SEARCH;
1797       rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
1798         &expand_string_message, &do_cache);
1799       store_pool = old_pool;
1800       }
1801     goto END_AUTH;
1802     #else
1803     goto COND_FAILED_NOT_COMPILED;
1804     #endif  /* LOOKUP_LDAP */
1805
1806     case ECOND_PWCHECK:
1807     #ifdef CYRUS_PWCHECK_SOCKET
1808     rc = auth_call_pwcheck(sub[0], &expand_string_message);
1809     goto END_AUTH;
1810     #else
1811     goto COND_FAILED_NOT_COMPILED;
1812     #endif  /* CYRUS_PWCHECK_SOCKET */
1813
1814     #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
1815         defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
1816     END_AUTH:
1817     if (rc == ERROR || rc == DEFER) return NULL;
1818     *yield = (rc == OK) == testfor;
1819     #endif
1820     }
1821   return s;
1822
1823
1824   /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
1825
1826      ${if saslauthd {{username}{password}{service}{realm}}  {yes}[no}}
1827
1828   However, the last two are optional. That is why the whole set is enclosed
1829   in their own set or braces. */
1830
1831   case ECOND_SASLAUTHD:
1832   #ifndef CYRUS_SASLAUTHD_SOCKET
1833   goto COND_FAILED_NOT_COMPILED;
1834   #else
1835   while (isspace(*s)) s++;
1836   if (*s++ != '{') goto COND_FAILED_CURLY_START;
1837   switch(read_subs(sub, 4, 2, &s, yield == NULL, TRUE, US"saslauthd"))
1838     {
1839     case 1: expand_string_message = US"too few arguments or bracketing "
1840       "error for saslauthd";
1841     case 2:
1842     case 3: return NULL;
1843     }
1844   if (sub[2] == NULL) sub[3] = NULL;  /* realm if no service */
1845   if (yield != NULL)
1846     {
1847     int rc;
1848     rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
1849       &expand_string_message);
1850     if (rc == ERROR || rc == DEFER) return NULL;
1851     *yield = (rc == OK) == testfor;
1852     }
1853   return s;
1854   #endif /* CYRUS_SASLAUTHD_SOCKET */
1855
1856
1857   /* symbolic operators for numeric and string comparison, and a number of
1858   other operators, all requiring two arguments.
1859
1860   match:             does a regular expression match and sets up the numerical
1861                        variables if it succeeds
1862   match_address:     matches in an address list
1863   match_domain:      matches in a domain list
1864   match_ip:          matches a host list that is restricted to IP addresses
1865   match_local_part:  matches in a local part list
1866   crypteq:           encrypts plaintext and compares against an encrypted text,
1867                        using crypt(), crypt16(), MD5 or SHA-1
1868   */
1869
1870   case ECOND_MATCH:
1871   case ECOND_MATCH_ADDRESS:
1872   case ECOND_MATCH_DOMAIN:
1873   case ECOND_MATCH_IP:
1874   case ECOND_MATCH_LOCAL_PART:
1875   case ECOND_CRYPTEQ:
1876
1877   case ECOND_NUM_L:     /* Numerical comparisons */
1878   case ECOND_NUM_LE:
1879   case ECOND_NUM_E:
1880   case ECOND_NUM_EE:
1881   case ECOND_NUM_G:
1882   case ECOND_NUM_GE:
1883
1884   case ECOND_STR_LT:    /* String comparisons */
1885   case ECOND_STR_LTI:
1886   case ECOND_STR_LE:
1887   case ECOND_STR_LEI:
1888   case ECOND_STR_EQ:
1889   case ECOND_STR_EQI:
1890   case ECOND_STR_GT:
1891   case ECOND_STR_GTI:
1892   case ECOND_STR_GE:
1893   case ECOND_STR_GEI:
1894
1895   for (i = 0; i < 2; i++)
1896     {
1897     while (isspace(*s)) s++;
1898     if (*s != '{')
1899       {
1900       if (i == 0) goto COND_FAILED_CURLY_START;
1901       expand_string_message = string_sprintf("missing 2nd string in {} "
1902         "after \"%s\"", name);
1903       return NULL;
1904       }
1905     sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1906     if (sub[i] == NULL) return NULL;
1907     if (*s++ != '}') goto COND_FAILED_CURLY_END;
1908
1909     /* Convert to numerical if required; we know that the names of all the
1910     conditions that compare numbers do not start with a letter. This just saves
1911     checking for them individually. */
1912
1913     if (!isalpha(name[0]))
1914       {
1915       num[i] = expand_string_integer(sub[i], FALSE);
1916       if (expand_string_message != NULL) return NULL;
1917       }
1918     }
1919
1920   /* Result not required */
1921
1922   if (yield == NULL) return s;
1923
1924   /* Do an appropriate comparison */
1925
1926   switch(cond_type)
1927     {
1928     case ECOND_NUM_E:
1929     case ECOND_NUM_EE:
1930     *yield = (num[0] == num[1]) == testfor;
1931     break;
1932
1933     case ECOND_NUM_G:
1934     *yield = (num[0] > num[1]) == testfor;
1935     break;
1936
1937     case ECOND_NUM_GE:
1938     *yield = (num[0] >= num[1]) == testfor;
1939     break;
1940
1941     case ECOND_NUM_L:
1942     *yield = (num[0] < num[1]) == testfor;
1943     break;
1944
1945     case ECOND_NUM_LE:
1946     *yield = (num[0] <= num[1]) == testfor;
1947     break;
1948
1949     case ECOND_STR_LT:
1950     *yield = (Ustrcmp(sub[0], sub[1]) < 0) == testfor;
1951     break;
1952
1953     case ECOND_STR_LTI:
1954     *yield = (strcmpic(sub[0], sub[1]) < 0) == testfor;
1955     break;
1956
1957     case ECOND_STR_LE:
1958     *yield = (Ustrcmp(sub[0], sub[1]) <= 0) == testfor;
1959     break;
1960
1961     case ECOND_STR_LEI:
1962     *yield = (strcmpic(sub[0], sub[1]) <= 0) == testfor;
1963     break;
1964
1965     case ECOND_STR_EQ:
1966     *yield = (Ustrcmp(sub[0], sub[1]) == 0) == testfor;
1967     break;
1968
1969     case ECOND_STR_EQI:
1970     *yield = (strcmpic(sub[0], sub[1]) == 0) == testfor;
1971     break;
1972
1973     case ECOND_STR_GT:
1974     *yield = (Ustrcmp(sub[0], sub[1]) > 0) == testfor;
1975     break;
1976
1977     case ECOND_STR_GTI:
1978     *yield = (strcmpic(sub[0], sub[1]) > 0) == testfor;
1979     break;
1980
1981     case ECOND_STR_GE:
1982     *yield = (Ustrcmp(sub[0], sub[1]) >= 0) == testfor;
1983     break;
1984
1985     case ECOND_STR_GEI:
1986     *yield = (strcmpic(sub[0], sub[1]) >= 0) == testfor;
1987     break;
1988
1989     case ECOND_MATCH:   /* Regular expression match */
1990     re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
1991       NULL);
1992     if (re == NULL)
1993       {
1994       expand_string_message = string_sprintf("regular expression error in "
1995         "\"%s\": %s at offset %d", sub[1], rerror, roffset);
1996       return NULL;
1997       }
1998     *yield = regex_match_and_setup(re, sub[0], 0, -1) == testfor;
1999     break;
2000
2001     case ECOND_MATCH_ADDRESS:  /* Match in an address list */
2002     rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
2003     goto MATCHED_SOMETHING;
2004
2005     case ECOND_MATCH_DOMAIN:   /* Match in a domain list */
2006     rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
2007       MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
2008     goto MATCHED_SOMETHING;
2009
2010     case ECOND_MATCH_IP:       /* Match IP address in a host list */
2011     if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
2012       {
2013       expand_string_message = string_sprintf("\"%s\" is not an IP address",
2014         sub[0]);
2015       return NULL;
2016       }
2017     else
2018       {
2019       unsigned int *nullcache = NULL;
2020       check_host_block cb;
2021
2022       cb.host_name = US"";
2023       cb.host_address = sub[0];
2024
2025       /* If the host address starts off ::ffff: it is an IPv6 address in
2026       IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2027       addresses. */
2028
2029       cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2030         cb.host_address + 7 : cb.host_address;
2031
2032       rc = match_check_list(
2033              &sub[1],                   /* the list */
2034              0,                         /* separator character */
2035              &hostlist_anchor,          /* anchor pointer */
2036              &nullcache,                /* cache pointer */
2037              check_host,                /* function for testing */
2038              &cb,                       /* argument for function */
2039              MCL_HOST,                  /* type of check */
2040              sub[0],                    /* text for debugging */
2041              NULL);                     /* where to pass back data */
2042       }
2043     goto MATCHED_SOMETHING;
2044
2045     case ECOND_MATCH_LOCAL_PART:
2046     rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
2047       MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
2048     /* Fall through */
2049     /* VVVVVVVVVVVV */
2050     MATCHED_SOMETHING:
2051     switch(rc)
2052       {
2053       case OK:
2054       *yield = testfor;
2055       break;
2056
2057       case FAIL:
2058       *yield = !testfor;
2059       break;
2060
2061       case DEFER:
2062       expand_string_message = string_sprintf("unable to complete match "
2063         "against \"%s\": %s", sub[1], search_error_message);
2064       return NULL;
2065       }
2066
2067     break;
2068
2069     /* Various "encrypted" comparisons. If the second string starts with
2070     "{" then an encryption type is given. Default to crypt() or crypt16()
2071     (build-time choice). */
2072
2073     case ECOND_CRYPTEQ:
2074     #ifndef SUPPORT_CRYPTEQ
2075     goto COND_FAILED_NOT_COMPILED;
2076     #else
2077     if (strncmpic(sub[1], US"{md5}", 5) == 0)
2078       {
2079       int sublen = Ustrlen(sub[1]+5);
2080       md5 base;
2081       uschar digest[16];
2082
2083       md5_start(&base);
2084       md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2085
2086       /* If the length that we are comparing against is 24, the MD5 digest
2087       is expressed as a base64 string. This is the way LDAP does it. However,
2088       some other software uses a straightforward hex representation. We assume
2089       this if the length is 32. Other lengths fail. */
2090
2091       if (sublen == 24)
2092         {
2093         uschar *coded = auth_b64encode((uschar *)digest, 16);
2094         DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2095           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2096         *yield = (Ustrcmp(coded, sub[1]+5) == 0) == testfor;
2097         }
2098       else if (sublen == 32)
2099         {
2100         int i;
2101         uschar coded[36];
2102         for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2103         coded[32] = 0;
2104         DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2105           "  subject=%s\n  crypted=%s\n", coded, sub[1]+5);
2106         *yield = (strcmpic(coded, sub[1]+5) == 0) == testfor;
2107         }
2108       else
2109         {
2110         DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2111           "fail\n  crypted=%s\n", sub[1]+5);
2112         *yield = !testfor;
2113         }
2114       }
2115
2116     else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2117       {
2118       int sublen = Ustrlen(sub[1]+6);
2119       sha1 base;
2120       uschar digest[20];
2121
2122       sha1_start(&base);
2123       sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2124
2125       /* If the length that we are comparing against is 28, assume the SHA1
2126       digest is expressed as a base64 string. If the length is 40, assume a
2127       straightforward hex representation. Other lengths fail. */
2128
2129       if (sublen == 28)
2130         {
2131         uschar *coded = auth_b64encode((uschar *)digest, 20);
2132         DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2133           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2134         *yield = (Ustrcmp(coded, sub[1]+6) == 0) == testfor;
2135         }
2136       else if (sublen == 40)
2137         {
2138         int i;
2139         uschar coded[44];
2140         for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2141         coded[40] = 0;
2142         DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2143           "  subject=%s\n  crypted=%s\n", coded, sub[1]+6);
2144         *yield = (strcmpic(coded, sub[1]+6) == 0) == testfor;
2145         }
2146       else
2147         {
2148         DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2149           "fail\n  crypted=%s\n", sub[1]+6);
2150         *yield = !testfor;
2151         }
2152       }
2153
2154     else   /* {crypt} or {crypt16} and non-{ at start */
2155       {
2156       int which = 0;
2157       uschar *coded;
2158
2159       if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2160         {
2161         sub[1] += 7;
2162         which = 1;
2163         }
2164       else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2165         {
2166         sub[1] += 9;
2167         which = 2;
2168         }
2169       else if (sub[1][0] == '{')
2170         {
2171         expand_string_message = string_sprintf("unknown encryption mechanism "
2172           "in \"%s\"", sub[1]);
2173         return NULL;
2174         }
2175
2176       switch(which)
2177         {
2178         case 0:  coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2179         case 1:  coded = US crypt(CS sub[0], CS sub[1]); break;
2180         default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2181         }
2182
2183       #define STR(s) # s
2184       #define XSTR(s) STR(s)
2185       DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2186         "  subject=%s\n  crypted=%s\n",
2187         (which == 0)? XSTR(DEFAULT_CRYPT) : (which == 1)? "crypt" : "crypt16",
2188         coded, sub[1]);
2189       #undef STR
2190       #undef XSTR
2191
2192       /* If the encrypted string contains fewer than two characters (for the
2193       salt), force failure. Otherwise we get false positives: with an empty
2194       string the yield of crypt() is an empty string! */
2195
2196       *yield = (Ustrlen(sub[1]) < 2)? !testfor :
2197         (Ustrcmp(coded, sub[1]) == 0) == testfor;
2198       }
2199     break;
2200     #endif  /* SUPPORT_CRYPTEQ */
2201     }   /* Switch for comparison conditions */
2202
2203   return s;    /* End of comparison conditions */
2204
2205
2206   /* and/or: computes logical and/or of several conditions */
2207
2208   case ECOND_AND:
2209   case ECOND_OR:
2210   subcondptr = (yield == NULL)? NULL : &tempcond;
2211   combined_cond = (cond_type == ECOND_AND);
2212
2213   while (isspace(*s)) s++;
2214   if (*s++ != '{') goto COND_FAILED_CURLY_START;
2215
2216   for (;;)
2217     {
2218     while (isspace(*s)) s++;
2219     if (*s == '}') break;
2220     if (*s != '{')
2221       {
2222       expand_string_message = string_sprintf("each subcondition "
2223         "inside an \"%s{...}\" condition must be in its own {}", name);
2224       return NULL;
2225       }
2226
2227     s = eval_condition(s+1, subcondptr);
2228     if (s == NULL)
2229       {
2230       expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2231         expand_string_message, name);
2232       return NULL;
2233       }
2234     while (isspace(*s)) s++;
2235
2236     if (*s++ != '}')
2237       {
2238       expand_string_message = string_sprintf("missing } at end of condition "
2239         "inside \"%s\" group", name);
2240       return NULL;
2241       }
2242
2243     if (yield != NULL)
2244       {
2245       if (cond_type == ECOND_AND)
2246         {
2247         combined_cond &= tempcond;
2248         if (!combined_cond) subcondptr = NULL;  /* once false, don't */
2249         }                                       /* evaluate any more */
2250       else
2251         {
2252         combined_cond |= tempcond;
2253         if (combined_cond) subcondptr = NULL;   /* once true, don't */
2254         }                                       /* evaluate any more */
2255       }
2256     }
2257
2258   if (yield != NULL) *yield = (combined_cond == testfor);
2259   return ++s;
2260
2261
2262   /* Unknown condition */
2263
2264   default:
2265   expand_string_message = string_sprintf("unknown condition \"%s\"", name);
2266   return NULL;
2267   }   /* End switch on condition type */
2268
2269 /* Missing braces at start and end of data */
2270
2271 COND_FAILED_CURLY_START:
2272 expand_string_message = string_sprintf("missing { after \"%s\"", name);
2273 return NULL;
2274
2275 COND_FAILED_CURLY_END:
2276 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2277   name);
2278 return NULL;
2279
2280 /* A condition requires code that is not compiled */
2281
2282 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
2283     !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
2284     !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
2285 COND_FAILED_NOT_COMPILED:
2286 expand_string_message = string_sprintf("support for \"%s\" not compiled",
2287   name);
2288 return NULL;
2289 #endif
2290 }
2291
2292
2293
2294
2295 /*************************************************
2296 *          Save numerical variables              *
2297 *************************************************/
2298
2299 /* This function is called from items such as "if" that want to preserve and
2300 restore the numbered variables.
2301
2302 Arguments:
2303   save_expand_string    points to an array of pointers to set
2304   save_expand_nlength   points to an array of ints for the lengths
2305
2306 Returns:                the value of expand max to save
2307 */
2308
2309 static int
2310 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2311 {
2312 int i;
2313 for (i = 0; i <= expand_nmax; i++)
2314   {
2315   save_expand_nstring[i] = expand_nstring[i];
2316   save_expand_nlength[i] = expand_nlength[i];
2317   }
2318 return expand_nmax;
2319 }
2320
2321
2322
2323 /*************************************************
2324 *           Restore numerical variables          *
2325 *************************************************/
2326
2327 /* This function restored saved values of numerical strings.
2328
2329 Arguments:
2330   save_expand_nmax      the number of strings to restore
2331   save_expand_string    points to an array of pointers
2332   save_expand_nlength   points to an array of ints
2333
2334 Returns:                nothing
2335 */
2336
2337 static void
2338 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2339   int *save_expand_nlength)
2340 {
2341 int i;
2342 expand_nmax = save_expand_nmax;
2343 for (i = 0; i <= expand_nmax; i++)
2344   {
2345   expand_nstring[i] = save_expand_nstring[i];
2346   expand_nlength[i] = save_expand_nlength[i];
2347   }
2348 }
2349
2350
2351
2352
2353
2354 /*************************************************
2355 *            Handle yes/no substrings            *
2356 *************************************************/
2357
2358 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
2359 alternative substrings that depend on whether or not the condition was true,
2360 or the lookup or extraction succeeded. The substrings always have to be
2361 expanded, to check their syntax, but "skipping" is set when the result is not
2362 needed - this avoids unnecessary nested lookups.
2363
2364 Arguments:
2365   skipping       TRUE if we were skipping when this item was reached
2366   yes            TRUE if the first string is to be used, else use the second
2367   save_lookup    a value to put back into lookup_value before the 2nd expansion
2368   sptr           points to the input string pointer
2369   yieldptr       points to the output string pointer
2370   sizeptr        points to the output string size
2371   ptrptr         points to the output string pointer
2372   type           "lookup" or "if" or "extract" or "run", for error message
2373
2374 Returns:         0 OK; lookup_value has been reset to save_lookup
2375                  1 expansion failed
2376                  2 expansion failed because of bracketing error
2377 */
2378
2379 static int
2380 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2381   uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type)
2382 {
2383 int rc = 0;
2384 uschar *s = *sptr;    /* Local value */
2385 uschar *sub1, *sub2;
2386
2387 /* If there are no following strings, we substitute the contents of $value for
2388 lookups and for extractions in the success case. For the ${if item, the string
2389 "true" is substituted. In the fail case, nothing is substituted for all three
2390 items. */
2391
2392 while (isspace(*s)) s++;
2393 if (*s == '}')
2394   {
2395   if (type[0] == 'i')
2396     {
2397     if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
2398     }
2399   else
2400     {
2401     if (yes && lookup_value != NULL)
2402       *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
2403         Ustrlen(lookup_value));
2404     lookup_value = save_lookup;
2405     }
2406   s++;
2407   goto RETURN;
2408   }
2409
2410 /* The first following string must be braced. */
2411
2412 if (*s++ != '{') goto FAILED_CURLY;
2413
2414 /* Expand the first substring. Forced failures are noticed only if we actually
2415 want this string. Set skipping in the call in the fail case (this will always
2416 be the case if we were already skipping). */
2417
2418 sub1 = expand_string_internal(s, TRUE, &s, !yes);
2419 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
2420 expand_string_forcedfail = FALSE;
2421 if (*s++ != '}') goto FAILED_CURLY;
2422
2423 /* If we want the first string, add it to the output */
2424
2425 if (yes)
2426   *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
2427
2428 /* If this is called from a lookup or an extract, we want to restore $value to
2429 what it was at the start of the item, so that it has this value during the
2430 second string expansion. For the call from "if" or "run" to this function,
2431 save_lookup is set to lookup_value, so that this statement does nothing. */
2432
2433 lookup_value = save_lookup;
2434
2435 /* There now follows either another substring, or "fail", or nothing. This
2436 time, forced failures are noticed only if we want the second string. We must
2437 set skipping in the nested call if we don't want this string, or if we were
2438 already skipping. */
2439
2440 while (isspace(*s)) s++;
2441 if (*s == '{')
2442   {
2443   sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping);
2444   if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
2445   expand_string_forcedfail = FALSE;
2446   if (*s++ != '}') goto FAILED_CURLY;
2447
2448   /* If we want the second string, add it to the output */
2449
2450   if (!yes)
2451     *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
2452   }
2453
2454 /* If there is no second string, but the word "fail" is present when the use of
2455 the second string is wanted, set a flag indicating it was a forced failure
2456 rather than a syntactic error. Swallow the terminating } in case this is nested
2457 inside another lookup or if or extract. */
2458
2459 else if (*s != '}')
2460   {
2461   uschar name[256];
2462   s = read_name(name, sizeof(name), s, US"_");
2463   if (Ustrcmp(name, "fail") == 0)
2464     {
2465     if (!yes && !skipping)
2466       {
2467       while (isspace(*s)) s++;
2468       if (*s++ != '}') goto FAILED_CURLY;
2469       expand_string_message =
2470         string_sprintf("\"%s\" failed and \"fail\" requested", type);
2471       expand_string_forcedfail = TRUE;
2472       goto FAILED;
2473       }
2474     }
2475   else
2476     {
2477     expand_string_message =
2478       string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
2479     goto FAILED;
2480     }
2481   }
2482
2483 /* All we have to do now is to check on the final closing brace. */
2484
2485 while (isspace(*s)) s++;
2486 if (*s++ == '}') goto RETURN;
2487
2488 /* Get here if there is a bracketing failure */
2489
2490 FAILED_CURLY:
2491 rc++;
2492
2493 /* Get here for other failures */
2494
2495 FAILED:
2496 rc++;
2497
2498 /* Update the input pointer value before returning */
2499
2500 RETURN:
2501 *sptr = s;
2502 return rc;
2503 }
2504
2505
2506
2507
2508 /*************************************************
2509 *    Handle MD5 or SHA-1 computation for HMAC    *
2510 *************************************************/
2511
2512 /* These are some wrapping functions that enable the HMAC code to be a bit
2513 cleaner. A good compiler will spot the tail recursion.
2514
2515 Arguments:
2516   type         HMAC_MD5 or HMAC_SHA1
2517   remaining    are as for the cryptographic hash functions
2518
2519 Returns:       nothing
2520 */
2521
2522 static void
2523 chash_start(int type, void *base)
2524 {
2525 if (type == HMAC_MD5)
2526   md5_start((md5 *)base);
2527 else
2528   sha1_start((sha1 *)base);
2529 }
2530
2531 static void
2532 chash_mid(int type, void *base, uschar *string)
2533 {
2534 if (type == HMAC_MD5)
2535   md5_mid((md5 *)base, string);
2536 else
2537   sha1_mid((sha1 *)base, string);
2538 }
2539
2540 static void
2541 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
2542 {
2543 if (type == HMAC_MD5)
2544   md5_end((md5 *)base, string, length, digest);
2545 else
2546   sha1_end((sha1 *)base, string, length, digest);
2547 }
2548
2549
2550
2551
2552
2553 /********************************************************
2554 * prvs: Get last three digits of days since Jan 1, 1970 *
2555 ********************************************************/
2556
2557 /* This is needed to implement the "prvs" BATV reverse
2558    path signing scheme
2559
2560 Argument: integer "days" offset to add or substract to
2561           or from the current number of days.
2562
2563 Returns:  pointer to string containing the last three
2564           digits of the number of days since Jan 1, 1970,
2565           modified by the offset argument, NULL if there
2566           was an error in the conversion.
2567
2568 */
2569
2570 static uschar *
2571 prvs_daystamp(int day_offset)
2572 {
2573 uschar *days = store_get(32);                /* Need at least 24 for cases */
2574 (void)string_format(days, 32, TIME_T_FMT,    /* where TIME_T_FMT is %lld */
2575   (time(NULL) + day_offset*86400)/86400);
2576 return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
2577 }
2578
2579
2580
2581 /********************************************************
2582 *   prvs: perform HMAC-SHA1 computation of prvs bits    *
2583 ********************************************************/
2584
2585 /* This is needed to implement the "prvs" BATV reverse
2586    path signing scheme
2587
2588 Arguments:
2589   address RFC2821 Address to use
2590       key The key to use (must be less than 64 characters
2591           in size)
2592   key_num Single-digit key number to use. Defaults to
2593           '0' when NULL.
2594
2595 Returns:  pointer to string containing the first three
2596           bytes of the final hash in hex format, NULL if
2597           there was an error in the process.
2598 */
2599
2600 static uschar *
2601 prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
2602 {
2603 uschar *hash_source, *p;
2604 int size = 0,offset = 0,i;
2605 sha1 sha1_base;
2606 void *use_base = &sha1_base;
2607 uschar innerhash[20];
2608 uschar finalhash[20];
2609 uschar innerkey[64];
2610 uschar outerkey[64];
2611 uschar *finalhash_hex = store_get(40);
2612
2613 if (key_num == NULL)
2614   key_num = US"0";
2615
2616 if (Ustrlen(key) > 64)
2617   return NULL;
2618
2619 hash_source = string_cat(NULL,&size,&offset,key_num,1);
2620 string_cat(hash_source,&size,&offset,daystamp,3);
2621 string_cat(hash_source,&size,&offset,address,Ustrlen(address));
2622 hash_source[offset] = '\0';
2623
2624 DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
2625
2626 memset(innerkey, 0x36, 64);
2627 memset(outerkey, 0x5c, 64);
2628
2629 for (i = 0; i < Ustrlen(key); i++)
2630   {
2631   innerkey[i] ^= key[i];
2632   outerkey[i] ^= key[i];
2633   }
2634
2635 chash_start(HMAC_SHA1, use_base);
2636 chash_mid(HMAC_SHA1, use_base, innerkey);
2637 chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
2638
2639 chash_start(HMAC_SHA1, use_base);
2640 chash_mid(HMAC_SHA1, use_base, outerkey);
2641 chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
2642
2643 p = finalhash_hex;
2644 for (i = 0; i < 3; i++)
2645   {
2646   *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
2647   *p++ = hex_digits[finalhash[i] & 0x0f];
2648   }
2649 *p = '\0';
2650
2651 return finalhash_hex;
2652 }
2653
2654
2655
2656
2657 /*************************************************
2658 *        Join a file onto the output string      *
2659 *************************************************/
2660
2661 /* This is used for readfile and after a run expansion. It joins the contents
2662 of a file onto the output string, globally replacing newlines with a given
2663 string (optionally). The file is closed at the end.
2664
2665 Arguments:
2666   f            the FILE
2667   yield        pointer to the expandable string
2668   sizep        pointer to the current size
2669   ptrp         pointer to the current position
2670   eol          newline replacement string, or NULL
2671
2672 Returns:       new value of string pointer
2673 */
2674
2675 static uschar *
2676 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
2677 {
2678 int eollen;
2679 uschar buffer[1024];
2680
2681 eollen = (eol == NULL)? 0 : Ustrlen(eol);
2682
2683 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
2684   {
2685   int len = Ustrlen(buffer);
2686   if (eol != NULL && buffer[len-1] == '\n') len--;
2687   yield = string_cat(yield, sizep, ptrp, buffer, len);
2688   if (buffer[len] != 0)
2689     yield = string_cat(yield, sizep, ptrp, eol, eollen);
2690   }
2691
2692 if (yield != NULL) yield[*ptrp] = 0;
2693
2694 return yield;
2695 }
2696
2697
2698
2699
2700 /*************************************************
2701 *          Evaluate numeric expression           *
2702 *************************************************/
2703
2704 /* This is a set of mutually recursive functions that evaluate a simple
2705 arithmetic expression involving only + - * / and parentheses. The only one that
2706 is called from elsewhere is eval_expr, whose interface is:
2707
2708 Arguments:
2709   sptr          pointer to the pointer to the string - gets updated
2710   decimal       TRUE if numbers are to be assumed decimal
2711   error         pointer to where to put an error message - must be NULL on input
2712   endket        TRUE if ')' must terminate - FALSE for external call
2713
2714
2715 Returns:        on success: the value of the expression, with *error still NULL
2716                 on failure: an undefined value, with *error = a message
2717 */
2718
2719 static int eval_sumterm(uschar **, BOOL, uschar **);
2720
2721 static int
2722 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
2723 {
2724 uschar *s = *sptr;
2725 int x = eval_sumterm(&s, decimal, error);
2726 if (*error == NULL)
2727   {
2728   while (*s == '+' || *s == '-')
2729     {
2730     int op = *s++;
2731     int y = eval_sumterm(&s, decimal, error);
2732     if (*error != NULL) break;
2733     if (op == '+') x += y; else x -= y;
2734     }
2735   if (*error == NULL)
2736     {
2737     if (endket)
2738       {
2739       if (*s != ')')
2740         *error = US"expecting closing parenthesis";
2741       else
2742         while (isspace(*(++s)));
2743       }
2744     else if (*s != 0) *error = US"expecting + or -";
2745     }
2746   }
2747
2748 *sptr = s;
2749 return x;
2750 }
2751
2752 static int
2753 eval_term(uschar **sptr, BOOL decimal, uschar **error)
2754 {
2755 register int c;
2756 int n;
2757 uschar *s = *sptr;
2758 while (isspace(*s)) s++;
2759 c = *s;
2760 if (isdigit(c) || ((c == '-' || c == '+') && isdigit(s[1])))
2761   {
2762   int count;
2763   (void)sscanf(CS s, (decimal? "%d%n" : "%i%n"), &n, &count);
2764   s += count;
2765   if (tolower(*s) == 'k') { n *= 1024; s++; }
2766     else if (tolower(*s) == 'm') { n *= 1024*1024; s++; }
2767   while (isspace (*s)) s++;
2768   }
2769 else if (c == '(')
2770   {
2771   s++;
2772   n = eval_expr(&s, decimal, error, 1);
2773   }
2774 else
2775   {
2776   *error = US"expecting number or opening parenthesis";
2777   n = 0;
2778   }
2779 *sptr = s;
2780 return n;
2781 }
2782
2783 static int eval_sumterm(uschar **sptr, BOOL decimal, uschar **error)
2784 {
2785 uschar *s = *sptr;
2786 int x = eval_term(&s, decimal, error);
2787 if (*error == NULL)
2788   {
2789   while (*s == '*' || *s == '/' || *s == '%')
2790     {
2791     int op = *s++;
2792     int y = eval_term(&s, decimal, error);
2793     if (*error != NULL) break;
2794     if (op == '*') x *= y;
2795       else if (op == '/') x /= y;
2796       else x %= y;
2797     }
2798   }
2799 *sptr = s;
2800 return x;
2801 }
2802
2803
2804
2805
2806 /*************************************************
2807 *                 Expand string                  *
2808 *************************************************/
2809
2810 /* Returns either an unchanged string, or the expanded string in stacking pool
2811 store. Interpreted sequences are:
2812
2813    \...                    normal escaping rules
2814    $name                   substitutes the variable
2815    ${name}                 ditto
2816    ${op:string}            operates on the expanded string value
2817    ${item{arg1}{arg2}...}  expands the args and then does the business
2818                              some literal args are not enclosed in {}
2819
2820 There are now far too many operators and item types to make it worth listing
2821 them here in detail any more.
2822
2823 We use an internal routine recursively to handle embedded substrings. The
2824 external function follows. The yield is NULL if the expansion failed, and there
2825 are two cases: if something collapsed syntactically, or if "fail" was given
2826 as the action on a lookup failure. These can be distinguised by looking at the
2827 variable expand_string_forcedfail, which is TRUE in the latter case.
2828
2829 The skipping flag is set true when expanding a substring that isn't actually
2830 going to be used (after "if" or "lookup") and it prevents lookups from
2831 happening lower down.
2832
2833 Store usage: At start, a store block of the length of the input plus 64
2834 is obtained. This is expanded as necessary by string_cat(), which might have to
2835 get a new block, or might be able to expand the original. At the end of the
2836 function we can release any store above that portion of the yield block that
2837 was actually used. In many cases this will be optimal.
2838
2839 However: if the first item in the expansion is a variable name or header name,
2840 we reset the store before processing it; if the result is in fresh store, we
2841 use that without copying. This is helpful for expanding strings like
2842 $message_headers which can get very long.
2843
2844 Arguments:
2845   string         the string to be expanded
2846   ket_ends       true if expansion is to stop at }
2847   left           if not NULL, a pointer to the first character after the
2848                  expansion is placed here (typically used with ket_ends)
2849   skipping       TRUE for recursive calls when the value isn't actually going
2850                  to be used (to allow for optimisation)
2851
2852 Returns:         NULL if expansion fails:
2853                    expand_string_forcedfail is set TRUE if failure was forced
2854                    expand_string_message contains a textual error message
2855                  a pointer to the expanded string on success
2856 */
2857
2858 static uschar *
2859 expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
2860   BOOL skipping)
2861 {
2862 int ptr = 0;
2863 int size = Ustrlen(string)+ 64;
2864 int item_type;
2865 uschar *yield = store_get(size);
2866 uschar *s = string;
2867 uschar *save_expand_nstring[EXPAND_MAXN+1];
2868 int save_expand_nlength[EXPAND_MAXN+1];
2869
2870 expand_string_forcedfail = FALSE;
2871 expand_string_message = US"";
2872
2873 while (*s != 0)
2874   {
2875   uschar *value;
2876   uschar name[256];
2877
2878   /* \ escapes the next character, which must exist, or else
2879   the expansion fails. There's a special escape, \N, which causes
2880   copying of the subject verbatim up to the next \N. Otherwise,
2881   the escapes are the standard set. */
2882
2883   if (*s == '\\')
2884     {
2885     if (s[1] == 0)
2886       {
2887       expand_string_message = US"\\ at end of string";
2888       goto EXPAND_FAILED;
2889       }
2890
2891     if (s[1] == 'N')
2892       {
2893       uschar *t = s + 2;
2894       for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
2895       yield = string_cat(yield, &size, &ptr, t, s - t);
2896       if (*s != 0) s += 2;
2897       }
2898
2899     else
2900       {
2901       uschar ch[1];
2902       ch[0] = string_interpret_escape(&s);
2903       s++;
2904       yield = string_cat(yield, &size, &ptr, ch, 1);
2905       }
2906
2907     continue;
2908     }
2909
2910   /* Anything other than $ is just copied verbatim, unless we are
2911   looking for a terminating } character. */
2912
2913   if (ket_ends && *s == '}') break;
2914
2915   if (*s != '$')
2916     {
2917     yield = string_cat(yield, &size, &ptr, s++, 1);
2918     continue;
2919     }
2920
2921   /* No { after the $ - must be a plain name or a number for string
2922   match variable. There has to be a fudge for variables that are the
2923   names of header fields preceded by "$header_" because header field
2924   names can contain any printing characters except space and colon.
2925   For those that don't like typing this much, "$h_" is a synonym for
2926   "$header_". A non-existent header yields a NULL value; nothing is
2927   inserted. */
2928
2929   if (isalpha((*(++s))))
2930     {
2931     int len;
2932     int newsize = 0;
2933
2934     s = read_name(name, sizeof(name), s, US"_");
2935
2936     /* If this is the first thing to be expanded, release the pre-allocated
2937     buffer. */
2938
2939     if (ptr == 0 && yield != NULL)
2940       {
2941       store_reset(yield);
2942       yield = NULL;
2943       size = 0;
2944       }
2945
2946     /* Header */
2947
2948     if (Ustrncmp(name, "h_", 2) == 0 ||
2949         Ustrncmp(name, "rh_", 3) == 0 ||
2950         Ustrncmp(name, "bh_", 3) == 0 ||
2951         Ustrncmp(name, "header_", 7) == 0 ||
2952         Ustrncmp(name, "rheader_", 8) == 0 ||
2953         Ustrncmp(name, "bheader_", 8) == 0)
2954       {
2955       BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
2956       uschar *charset = (name[0] == 'b')? NULL : headers_charset;
2957       s = read_header_name(name, sizeof(name), s);
2958       value = find_header(name, FALSE, &newsize, want_raw, charset);
2959
2960       /* If we didn't find the header, and the header contains a closing brace
2961       characters, this may be a user error where the terminating colon
2962       has been omitted. Set a flag to adjust the error message in this case.
2963       But there is no error here - nothing gets inserted. */
2964
2965       if (value == NULL)
2966         {
2967         if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2968         continue;
2969         }
2970       }
2971
2972     /* Variable */
2973
2974     else
2975       {
2976       value = find_variable(name, FALSE, skipping, &newsize);
2977       if (value == NULL)
2978         {
2979         expand_string_message =
2980           string_sprintf("unknown variable name \"%s\"", name);
2981           check_variable_error_message(name);
2982         goto EXPAND_FAILED;
2983         }
2984       }
2985
2986     /* If the data is known to be in a new buffer, newsize will be set to the
2987     size of that buffer. If this is the first thing in an expansion string,
2988     yield will be NULL; just point it at the new store instead of copying. Many
2989     expansion strings contain just one reference, so this is a useful
2990     optimization, especially for humungous headers. */
2991
2992     len = Ustrlen(value);
2993     if (yield == NULL && newsize != 0)
2994       {
2995       yield = value;
2996       size = newsize;
2997       ptr = len;
2998       }
2999     else yield = string_cat(yield, &size, &ptr, value, len);
3000
3001     continue;
3002     }
3003
3004   if (isdigit(*s))
3005     {
3006     int n;
3007     s = read_number(&n, s);
3008     if (n >= 0 && n <= expand_nmax)
3009       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3010         expand_nlength[n]);
3011     continue;
3012     }
3013
3014   /* Otherwise, if there's no '{' after $ it's an error. */
3015
3016   if (*s != '{')
3017     {
3018     expand_string_message = US"$ not followed by letter, digit, or {";
3019     goto EXPAND_FAILED;
3020     }
3021
3022   /* After { there can be various things, but they all start with
3023   an initial word, except for a number for a string match variable. */
3024
3025   if (isdigit((*(++s))))
3026     {
3027     int n;
3028     s = read_number(&n, s);
3029     if (*s++ != '}')
3030       {
3031       expand_string_message = US"} expected after number";
3032       goto EXPAND_FAILED;
3033       }
3034     if (n >= 0 && n <= expand_nmax)
3035       yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3036         expand_nlength[n]);
3037     continue;
3038     }
3039
3040   if (!isalpha(*s))
3041     {
3042     expand_string_message = US"letter or digit expected after ${";
3043     goto EXPAND_FAILED;
3044     }
3045
3046   /* Allow "-" in names to cater for substrings with negative
3047   arguments. Since we are checking for known names after { this is
3048   OK. */
3049
3050   s = read_name(name, sizeof(name), s, US"_-");
3051   item_type = chop_match(name, item_table, sizeof(item_table)/sizeof(uschar *));
3052
3053   switch(item_type)
3054     {
3055     /* Handle conditionals - preserve the values of the numerical expansion
3056     variables in case they get changed by a regular expression match in the
3057     condition. If not, they retain their external settings. At the end
3058     of this "if" section, they get restored to their previous values. */
3059
3060     case EITEM_IF:
3061       {
3062       BOOL cond = FALSE;
3063       uschar *next_s;
3064       int save_expand_nmax =
3065         save_expand_strings(save_expand_nstring, save_expand_nlength);
3066
3067       while (isspace(*s)) s++;
3068       next_s = eval_condition(s, skipping? NULL : &cond);
3069       if (next_s == NULL) goto EXPAND_FAILED;  /* message already set */
3070
3071       DEBUG(D_expand)
3072         debug_printf("condition: %.*s\n   result: %s\n", (int)(next_s - s), s,
3073           cond? "true" : "false");
3074
3075       s = next_s;
3076
3077       /* The handling of "yes" and "no" result strings is now in a separate
3078       function that is also used by ${lookup} and ${extract} and ${run}. */
3079
3080       switch(process_yesno(
3081                skipping,                     /* were previously skipping */
3082                cond,                         /* success/failure indicator */
3083                lookup_value,                 /* value to reset for string2 */
3084                &s,                           /* input pointer */
3085                &yield,                       /* output pointer */
3086                &size,                        /* output size */
3087                &ptr,                         /* output current point */
3088                US"if"))                      /* condition type */
3089         {
3090         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3091         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3092         }
3093
3094       /* Restore external setting of expansion variables for continuation
3095       at this level. */
3096
3097       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3098         save_expand_nlength);
3099       continue;
3100       }
3101
3102     /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
3103     expanding an internal string that isn't actually going to be used. All we
3104     need to do is check the syntax, so don't do a lookup at all. Preserve the
3105     values of the numerical expansion variables in case they get changed by a
3106     partial lookup. If not, they retain their external settings. At the end
3107     of this "lookup" section, they get restored to their previous values. */
3108
3109     case EITEM_LOOKUP:
3110       {
3111       int stype, partial, affixlen, starflags;
3112       int expand_setup = 0;
3113       int nameptr = 0;
3114       uschar *key, *filename, *affix;
3115       uschar *save_lookup_value = lookup_value;
3116       int save_expand_nmax =
3117         save_expand_strings(save_expand_nstring, save_expand_nlength);
3118
3119       if ((expand_forbid & RDO_LOOKUP) != 0)
3120         {
3121         expand_string_message = US"lookup expansions are not permitted";
3122         goto EXPAND_FAILED;
3123         }
3124
3125       /* Get the key we are to look up for single-key+file style lookups.
3126       Otherwise set the key NULL pro-tem. */
3127
3128       while (isspace(*s)) s++;
3129       if (*s == '{')
3130         {
3131         key = expand_string_internal(s+1, TRUE, &s, skipping);
3132         if (key == NULL) goto EXPAND_FAILED;
3133         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3134         while (isspace(*s)) s++;
3135         }
3136       else key = NULL;
3137
3138       /* Find out the type of database */
3139
3140       if (!isalpha(*s))
3141         {
3142         expand_string_message = US"missing lookup type";
3143         goto EXPAND_FAILED;
3144         }
3145
3146       /* The type is a string that may contain special characters of various
3147       kinds. Allow everything except space or { to appear; the actual content
3148       is checked by search_findtype_partial. */
3149
3150       while (*s != 0 && *s != '{' && !isspace(*s))
3151         {
3152         if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
3153         s++;
3154         }
3155       name[nameptr] = 0;
3156       while (isspace(*s)) s++;
3157
3158       /* Now check for the individual search type and any partial or default
3159       options. Only those types that are actually in the binary are valid. */
3160
3161       stype = search_findtype_partial(name, &partial, &affix, &affixlen,
3162         &starflags);
3163       if (stype < 0)
3164         {
3165         expand_string_message = search_error_message;
3166         goto EXPAND_FAILED;
3167         }
3168
3169       /* Check that a key was provided for those lookup types that need it,
3170       and was not supplied for those that use the query style. */
3171
3172       if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
3173         {
3174         if (key == NULL)
3175           {
3176           expand_string_message = string_sprintf("missing {key} for single-"
3177             "key \"%s\" lookup", name);
3178           goto EXPAND_FAILED;
3179           }
3180         }
3181       else
3182         {
3183         if (key != NULL)
3184           {
3185           expand_string_message = string_sprintf("a single key was given for "
3186             "lookup type \"%s\", which is not a single-key lookup type", name);
3187           goto EXPAND_FAILED;
3188           }
3189         }
3190
3191       /* Get the next string in brackets and expand it. It is the file name for
3192       single-key+file lookups, and the whole query otherwise. In the case of
3193       queries that also require a file name (e.g. sqlite), the file name comes
3194       first. */
3195
3196       if (*s != '{') goto EXPAND_FAILED_CURLY;
3197       filename = expand_string_internal(s+1, TRUE, &s, skipping);
3198       if (filename == NULL) goto EXPAND_FAILED;
3199       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3200       while (isspace(*s)) s++;
3201
3202       /* If this isn't a single-key+file lookup, re-arrange the variables
3203       to be appropriate for the search_ functions. For query-style lookups,
3204       there is just a "key", and no file name. For the special query-style +
3205       file types, the query (i.e. "key") starts with a file name. */
3206
3207       if (key == NULL)
3208         {
3209         while (isspace(*filename)) filename++;
3210         key = filename;
3211
3212         if (mac_islookup(stype, lookup_querystyle))
3213           {
3214           filename = NULL;
3215           }
3216         else
3217           {
3218           if (*filename != '/')
3219             {
3220             expand_string_message = string_sprintf(
3221               "absolute file name expected for \"%s\" lookup", name);
3222             goto EXPAND_FAILED;
3223             }
3224           while (*key != 0 && !isspace(*key)) key++;
3225           if (*key != 0) *key++ = 0;
3226           }
3227         }
3228
3229       /* If skipping, don't do the next bit - just lookup_value == NULL, as if
3230       the entry was not found. Note that there is no search_close() function.
3231       Files are left open in case of re-use. At suitable places in higher logic,
3232       search_tidyup() is called to tidy all open files. This can save opening
3233       the same file several times. However, files may also get closed when
3234       others are opened, if too many are open at once. The rule is that a
3235       handle should not be used after a second search_open().
3236
3237       Request that a partial search sets up $1 and maybe $2 by passing
3238       expand_setup containing zero. If its value changes, reset expand_nmax,
3239       since new variables will have been set. Note that at the end of this
3240       "lookup" section, the old numeric variables are restored. */
3241
3242       if (skipping)
3243         lookup_value = NULL;
3244       else
3245         {
3246         void *handle = search_open(filename, stype, 0, NULL, NULL);
3247         if (handle == NULL)
3248           {
3249           expand_string_message = search_error_message;
3250           goto EXPAND_FAILED;
3251           }
3252         lookup_value = search_find(handle, filename, key, partial, affix,
3253           affixlen, starflags, &expand_setup);
3254         if (search_find_defer)
3255           {
3256           expand_string_message =
3257             string_sprintf("lookup of \"%s\" gave DEFER: %s", key,
3258               search_error_message);
3259           goto EXPAND_FAILED;
3260           }
3261         if (expand_setup > 0) expand_nmax = expand_setup;
3262         }
3263
3264       /* The handling of "yes" and "no" result strings is now in a separate
3265       function that is also used by ${if} and ${extract}. */
3266
3267       switch(process_yesno(
3268                skipping,                     /* were previously skipping */
3269                lookup_value != NULL,         /* success/failure indicator */
3270                save_lookup_value,            /* value to reset for string2 */
3271                &s,                           /* input pointer */
3272                &yield,                       /* output pointer */
3273                &size,                        /* output size */
3274                &ptr,                         /* output current point */
3275                US"lookup"))                  /* condition type */
3276         {
3277         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3278         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3279         }
3280
3281       /* Restore external setting of expansion variables for carrying on
3282       at this level, and continue. */
3283
3284       restore_expand_strings(save_expand_nmax, save_expand_nstring,
3285         save_expand_nlength);
3286       continue;
3287       }
3288
3289     /* If Perl support is configured, handle calling embedded perl subroutines,
3290     unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
3291     or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
3292     arguments (defined below). */
3293
3294     #define EXIM_PERL_MAX_ARGS 8
3295
3296     case EITEM_PERL:
3297     #ifndef EXIM_PERL
3298     expand_string_message = US"\"${perl\" encountered, but this facility "
3299       "is not included in this binary";
3300     goto EXPAND_FAILED;
3301
3302     #else   /* EXIM_PERL */
3303       {
3304       uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
3305       uschar *new_yield;
3306
3307       if ((expand_forbid & RDO_PERL) != 0)
3308         {
3309         expand_string_message = US"Perl calls are not permitted";
3310         goto EXPAND_FAILED;
3311         }
3312
3313       switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
3314            US"perl"))
3315         {
3316         case 1: goto EXPAND_FAILED_CURLY;
3317         case 2:
3318         case 3: goto EXPAND_FAILED;
3319         }
3320
3321       /* If skipping, we don't actually do anything */
3322
3323       if (skipping) continue;
3324
3325       /* Start the interpreter if necessary */
3326
3327       if (!opt_perl_started)
3328         {
3329         uschar *initerror;
3330         if (opt_perl_startup == NULL)
3331           {
3332           expand_string_message = US"A setting of perl_startup is needed when "
3333             "using the Perl interpreter";
3334           goto EXPAND_FAILED;
3335           }
3336         DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
3337         initerror = init_perl(opt_perl_startup);
3338         if (initerror != NULL)
3339           {
3340           expand_string_message =
3341             string_sprintf("error in perl_startup code: %s\n", initerror);
3342           goto EXPAND_FAILED;
3343           }
3344         opt_perl_started = TRUE;
3345         }
3346
3347       /* Call the function */
3348
3349       sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
3350       new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
3351         sub_arg[0], sub_arg + 1);
3352
3353       /* NULL yield indicates failure; if the message pointer has been set to
3354       NULL, the yield was undef, indicating a forced failure. Otherwise the
3355       message will indicate some kind of Perl error. */
3356
3357       if (new_yield == NULL)
3358         {
3359         if (expand_string_message == NULL)
3360           {
3361           expand_string_message =
3362             string_sprintf("Perl subroutine \"%s\" returned undef to force "
3363               "failure", sub_arg[0]);
3364           expand_string_forcedfail = TRUE;
3365           }
3366         goto EXPAND_FAILED;
3367         }
3368
3369       /* Yield succeeded. Ensure forcedfail is unset, just in case it got
3370       set during a callback from Perl. */
3371
3372       expand_string_forcedfail = FALSE;
3373       yield = new_yield;
3374       continue;
3375       }
3376     #endif /* EXIM_PERL */
3377
3378     /* Transform email address to "prvs" scheme to use
3379        as BATV-signed return path */
3380
3381     case EITEM_PRVS:
3382       {
3383       uschar *sub_arg[3];
3384       uschar *p,*domain;
3385
3386       switch(read_subs(sub_arg, 3, 2, &s, skipping, TRUE, US"prvs"))
3387         {
3388         case 1: goto EXPAND_FAILED_CURLY;
3389         case 2:
3390         case 3: goto EXPAND_FAILED;
3391         }
3392
3393       /* If skipping, we don't actually do anything */
3394       if (skipping) continue;
3395
3396       /* sub_arg[0] is the address */
3397       domain = Ustrrchr(sub_arg[0],'@');
3398       if ( (domain == NULL) || (domain == sub_arg[0]) || (Ustrlen(domain) == 1) )
3399         {
3400         expand_string_message = US"prvs first argument must be a qualified email address";
3401         goto EXPAND_FAILED;
3402         }
3403
3404       /* Calculate the hash. The second argument must be a single-digit
3405       key number, or unset. */
3406
3407       if (sub_arg[2] != NULL &&
3408           (!isdigit(sub_arg[2][0]) || sub_arg[2][1] != 0))
3409         {
3410         expand_string_message = US"prvs second argument must be a single digit";
3411         goto EXPAND_FAILED;
3412         }
3413
3414       p = prvs_hmac_sha1(sub_arg[0],sub_arg[1],sub_arg[2],prvs_daystamp(7));
3415       if (p == NULL)
3416         {
3417         expand_string_message = US"prvs hmac-sha1 conversion failed";
3418         goto EXPAND_FAILED;
3419         }
3420
3421       /* Now separate the domain from the local part */
3422       *domain++ = '\0';
3423
3424       yield = string_cat(yield,&size,&ptr,US"prvs=",5);
3425       string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
3426       string_cat(yield,&size,&ptr,US"/",1);
3427       string_cat(yield,&size,&ptr,(sub_arg[2] != NULL) ? sub_arg[2] : US"0", 1);
3428       string_cat(yield,&size,&ptr,prvs_daystamp(7),3);
3429       string_cat(yield,&size,&ptr,p,6);
3430       string_cat(yield,&size,&ptr,US"@",1);
3431       string_cat(yield,&size,&ptr,domain,Ustrlen(domain));
3432
3433       continue;
3434       }
3435
3436     /* Check a prvs-encoded address for validity */
3437
3438     case EITEM_PRVSCHECK:
3439       {
3440       uschar *sub_arg[3];
3441       int mysize = 0, myptr = 0;
3442       const pcre *re;
3443       uschar *p;
3444
3445       /* TF: Ugliness: We want to expand parameter 1 first, then set
3446          up expansion variables that are used in the expansion of
3447          parameter 2. So we clone the string for the first
3448          expansion, where we only expand parameter 1.
3449
3450          PH: Actually, that isn't necessary. The read_subs() function is
3451          designed to work this way for the ${if and ${lookup expansions. I've
3452          tidied the code.
3453       */
3454
3455       /* Reset expansion variables */
3456       prvscheck_result = NULL;
3457       prvscheck_address = NULL;
3458       prvscheck_keynum = NULL;
3459
3460       switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs"))
3461         {
3462         case 1: goto EXPAND_FAILED_CURLY;
3463         case 2:
3464         case 3: goto EXPAND_FAILED;
3465         }
3466
3467       re = regex_must_compile(US"^prvs\\=(.+)\\/([0-9])([0-9]{3})([A-F0-9]{6})\\@(.+)$",
3468                               TRUE,FALSE);
3469
3470       if (regex_match_and_setup(re,sub_arg[0],0,-1))
3471         {
3472         uschar *local_part = string_copyn(expand_nstring[1],expand_nlength[1]);
3473         uschar *key_num = string_copyn(expand_nstring[2],expand_nlength[2]);
3474         uschar *daystamp = string_copyn(expand_nstring[3],expand_nlength[3]);
3475         uschar *hash = string_copyn(expand_nstring[4],expand_nlength[4]);
3476         uschar *domain = string_copyn(expand_nstring[5],expand_nlength[5]);
3477
3478         DEBUG(D_expand) debug_printf("prvscheck localpart: %s\n", local_part);
3479         DEBUG(D_expand) debug_printf("prvscheck key number: %s\n", key_num);
3480         DEBUG(D_expand) debug_printf("prvscheck daystamp: %s\n", daystamp);
3481         DEBUG(D_expand) debug_printf("prvscheck hash: %s\n", hash);
3482         DEBUG(D_expand) debug_printf("prvscheck domain: %s\n", domain);
3483
3484         /* Set up expansion variables */
3485         prvscheck_address = string_cat(NULL, &mysize, &myptr, local_part, Ustrlen(local_part));
3486         string_cat(prvscheck_address,&mysize,&myptr,US"@",1);
3487         string_cat(prvscheck_address,&mysize,&myptr,domain,Ustrlen(domain));
3488         prvscheck_address[myptr] = '\0';
3489         prvscheck_keynum = string_copy(key_num);
3490
3491         /* Now expand the second argument */
3492         switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs"))
3493           {
3494           case 1: goto EXPAND_FAILED_CURLY;
3495           case 2:
3496           case 3: goto EXPAND_FAILED;
3497           }
3498
3499         /* Now we have the key and can check the address. */
3500
3501         p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
3502           daystamp);
3503
3504         if (p == NULL)
3505           {
3506           expand_string_message = US"hmac-sha1 conversion failed";
3507           goto EXPAND_FAILED;
3508           }
3509
3510         DEBUG(D_expand) debug_printf("prvscheck: received hash is %s\n", hash);
3511         DEBUG(D_expand) debug_printf("prvscheck:      own hash is %s\n", p);
3512
3513         if (Ustrcmp(p,hash) == 0)
3514           {
3515           /* Success, valid BATV address. Now check the expiry date. */
3516           uschar *now = prvs_daystamp(0);
3517           unsigned int inow = 0,iexpire = 1;
3518
3519           (void)sscanf(CS now,"%u",&inow);
3520           (void)sscanf(CS daystamp,"%u",&iexpire);
3521
3522           /* When "iexpire" is < 7, a "flip" has occured.
3523              Adjust "inow" accordingly. */
3524           if ( (iexpire < 7) && (inow >= 993) ) inow = 0;
3525
3526           if (iexpire > inow)
3527             {
3528             prvscheck_result = US"1";
3529             DEBUG(D_expand) debug_printf("prvscheck: success, $pvrs_result set to 1\n");
3530             }
3531             else
3532             {
3533             prvscheck_result = NULL;
3534             DEBUG(D_expand) debug_printf("prvscheck: signature expired, $pvrs_result unset\n");
3535             }
3536           }
3537         else
3538           {
3539           prvscheck_result = NULL;
3540           DEBUG(D_expand) debug_printf("prvscheck: hash failure, $pvrs_result unset\n");
3541           }
3542
3543         /* Now expand the final argument. We leave this till now so that
3544         it can include $prvscheck_result. */
3545
3546         switch(read_subs(sub_arg, 1, 0, &s, skipping, TRUE, US"prvs"))
3547           {
3548           case 1: goto EXPAND_FAILED_CURLY;
3549           case 2:
3550           case 3: goto EXPAND_FAILED;
3551           }
3552
3553         if (sub_arg[0] == NULL || *sub_arg[0] == '\0')
3554           yield = string_cat(yield,&size,&ptr,prvscheck_address,Ustrlen(prvscheck_address));
3555         else
3556           yield = string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
3557
3558         /* Reset the "internal" variables afterwards, because they are in
3559         dynamic store that will be reclaimed if the expansion succeeded. */
3560
3561         prvscheck_address = NULL;
3562         prvscheck_keynum = NULL;
3563         }
3564       else
3565         {
3566         /* Does not look like a prvs encoded address, return the empty string.
3567            We need to make sure all subs are expanded first, so as to skip over
3568            the entire item. */
3569
3570         switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"prvs"))
3571           {
3572           case 1: goto EXPAND_FAILED_CURLY;
3573           case 2:
3574           case 3: goto EXPAND_FAILED;
3575           }
3576         }
3577
3578       continue;
3579       }
3580
3581     /* Handle "readfile" to insert an entire file */
3582
3583     case EITEM_READFILE:
3584       {
3585       FILE *f;
3586       uschar *sub_arg[2];
3587
3588       if ((expand_forbid & RDO_READFILE) != 0)
3589         {
3590         expand_string_message = US"file insertions are not permitted";
3591         goto EXPAND_FAILED;
3592         }
3593
3594       switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile"))
3595         {
3596         case 1: goto EXPAND_FAILED_CURLY;
3597         case 2:
3598         case 3: goto EXPAND_FAILED;
3599         }
3600
3601       /* If skipping, we don't actually do anything */
3602
3603       if (skipping) continue;
3604
3605       /* Open the file and read it */
3606
3607       f = Ufopen(sub_arg[0], "rb");
3608       if (f == NULL)
3609         {
3610         expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
3611         goto EXPAND_FAILED;
3612         }
3613
3614       yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
3615       (void)fclose(f);
3616       continue;
3617       }
3618
3619     /* Handle "readsocket" to insert data from a Unix domain socket */
3620
3621     case EITEM_READSOCK:
3622       {
3623       int fd;
3624       int timeout = 5;
3625       int save_ptr = ptr;
3626       FILE *f;
3627       struct sockaddr_un sockun;         /* don't call this "sun" ! */
3628       uschar *arg;
3629       uschar *sub_arg[4];
3630
3631       if ((expand_forbid & RDO_READSOCK) != 0)
3632         {
3633         expand_string_message = US"socket insertions are not permitted";
3634         goto EXPAND_FAILED;
3635         }
3636
3637       /* Read up to 4 arguments, but don't do the end of item check afterwards,
3638       because there may be a string for expansion on failure. */
3639
3640       switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket"))
3641         {
3642         case 1: goto EXPAND_FAILED_CURLY;
3643         case 2:                             /* Won't occur: no end check */
3644         case 3: goto EXPAND_FAILED;
3645         }
3646
3647       /* Sort out timeout, if given */
3648
3649       if (sub_arg[2] != NULL)
3650         {
3651         timeout = readconf_readtime(sub_arg[2], 0, FALSE);
3652         if (timeout < 0)
3653           {
3654           expand_string_message = string_sprintf("bad time value %s",
3655             sub_arg[2]);
3656           goto EXPAND_FAILED;
3657           }
3658         }
3659       else sub_arg[3] = NULL;                     /* No eol if no timeout */
3660
3661       /* If skipping, we don't actually do anything. Otherwise, arrange to
3662       connect to either an IP or a Unix socket. */
3663
3664       if (!skipping)
3665         {
3666         /* Handle an IP (internet) domain */
3667
3668         if (Ustrncmp(sub_arg[0], "inet:", 5) == 0)
3669           {
3670           BOOL connected = FALSE;
3671           int namelen, port;
3672           host_item shost;
3673           host_item *h;
3674           uschar *server_name = sub_arg[0] + 5;
3675           uschar *port_name = Ustrrchr(server_name, ':');
3676
3677           /* Sort out the port */
3678
3679           if (port_name == NULL)
3680             {
3681             expand_string_message =
3682               string_sprintf("missing port for readsocket %s", sub_arg[0]);
3683             goto EXPAND_FAILED;
3684             }
3685           *port_name++ = 0;           /* Terminate server name */
3686
3687           if (isdigit(*port_name))
3688             {
3689             uschar *end;
3690             port = Ustrtol(port_name, &end, 0);
3691             if (end != port_name + Ustrlen(port_name))
3692               {
3693               expand_string_message =
3694                 string_sprintf("invalid port number %s", port_name);
3695               goto EXPAND_FAILED;
3696               }
3697             }
3698           else
3699             {
3700             struct servent *service_info = getservbyname(CS port_name, "tcp");
3701             if (service_info == NULL)
3702               {
3703               expand_string_message = string_sprintf("unknown port \"%s\"",
3704                 port_name);
3705               goto EXPAND_FAILED;
3706               }
3707             port = ntohs(service_info->s_port);
3708             }
3709
3710           /* Sort out the server. */
3711
3712           shost.next = NULL;
3713           shost.address = NULL;
3714           shost.port = port;
3715           shost.mx = -1;
3716
3717           namelen = Ustrlen(server_name);
3718
3719           /* Anything enclosed in [] must be an IP address. */
3720
3721           if (server_name[0] == '[' &&
3722               server_name[namelen - 1] == ']')
3723             {
3724             server_name[namelen - 1] = 0;
3725             server_name++;
3726             if (string_is_ip_address(server_name, NULL) == 0)
3727               {
3728               expand_string_message =
3729                 string_sprintf("malformed IP address \"%s\"", server_name);
3730               goto EXPAND_FAILED;
3731               }
3732             shost.name = shost.address = server_name;
3733             }
3734
3735           /* Otherwise check for an unadorned IP address */
3736
3737           else if (string_is_ip_address(server_name, NULL) != 0)
3738             shost.name = shost.address = server_name;
3739
3740           /* Otherwise lookup IP address(es) from the name */
3741
3742           else
3743             {
3744             shost.name = server_name;
3745             if (host_find_byname(&shost, NULL, NULL, FALSE) != HOST_FOUND)
3746               {
3747               expand_string_message =
3748                 string_sprintf("no IP address found for host %s", shost.name);
3749               goto EXPAND_FAILED;
3750               }
3751             }
3752
3753           /* Try to connect to the server - test each IP till one works */
3754
3755           for (h = &shost; h != NULL; h = h->next)
3756             {
3757             int af = (Ustrchr(h->address, ':') != 0)? AF_INET6 : AF_INET;
3758             if ((fd = ip_socket(SOCK_STREAM, af)) == -1)
3759               {
3760               expand_string_message = string_sprintf("failed to create socket: "
3761                 "%s", strerror(errno));
3762               goto SOCK_FAIL;
3763               }
3764
3765             if (ip_connect(fd, af, h->address, port, timeout) == 0)
3766               {
3767               connected = TRUE;
3768               break;
3769               }
3770             }
3771
3772           if (!connected)
3773             {
3774             expand_string_message = string_sprintf("failed to connect to "
3775               "socket %s: couldn't connect to any host", sub_arg[0],
3776               strerror(errno));
3777             goto SOCK_FAIL;
3778             }
3779           }
3780
3781         /* Handle a Unix domain socket */
3782
3783         else
3784           {
3785           if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
3786             {
3787             expand_string_message = string_sprintf("failed to create socket: %s",
3788               strerror(errno));
3789             goto SOCK_FAIL;
3790             }
3791
3792           sockun.sun_family = AF_UNIX;
3793           sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
3794             sub_arg[0]);
3795           if(connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
3796             {
3797             expand_string_message = string_sprintf("failed to connect to socket "
3798               "%s: %s", sub_arg[0], strerror(errno));
3799             goto SOCK_FAIL;
3800             }
3801           }
3802
3803         DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
3804
3805         /* Write the request string, if not empty */
3806
3807         if (sub_arg[1][0] != 0)
3808           {
3809           int len = Ustrlen(sub_arg[1]);
3810           DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
3811             sub_arg[1]);
3812           if (write(fd, sub_arg[1], len) != len)
3813             {
3814             expand_string_message = string_sprintf("request write to socket "
3815               "failed: %s", strerror(errno));
3816             goto SOCK_FAIL;
3817             }
3818           }
3819
3820         /* Now we need to read from the socket, under a timeout. The function
3821         that reads a file can be used. */
3822
3823         f = fdopen(fd, "rb");
3824         sigalrm_seen = FALSE;
3825         alarm(timeout);
3826         yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
3827         alarm(0);
3828         (void)fclose(f);
3829
3830         /* After a timeout, we restore the pointer in the result, that is,
3831         make sure we add nothing from the socket. */
3832
3833         if (sigalrm_seen)
3834           {
3835           ptr = save_ptr;
3836           expand_string_message = US "socket read timed out";
3837           goto SOCK_FAIL;
3838           }
3839         }
3840
3841       /* The whole thing has worked (or we were skipping). If there is a
3842       failure string following, we need to skip it. */
3843
3844       if (*s == '{')
3845         {
3846         if (expand_string_internal(s+1, TRUE, &s, TRUE) == NULL)
3847           goto EXPAND_FAILED;
3848         if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3849         while (isspace(*s)) s++;
3850         }
3851       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3852       continue;
3853
3854       /* Come here on failure to create socket, connect socket, write to the
3855       socket, or timeout on reading. If another substring follows, expand and
3856       use it. Otherwise, those conditions give expand errors. */
3857
3858       SOCK_FAIL:
3859       if (*s != '{') goto EXPAND_FAILED;
3860       DEBUG(D_any) debug_printf("%s\n", expand_string_message);
3861       arg = expand_string_internal(s+1, TRUE, &s, FALSE);
3862       if (arg == NULL) goto EXPAND_FAILED;
3863       yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
3864       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3865       while (isspace(*s)) s++;
3866       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3867       continue;
3868       }
3869
3870     /* Handle "run" to execute a program. */
3871
3872     case EITEM_RUN:
3873       {
3874       FILE *f;
3875       uschar *arg;
3876       uschar **argv;
3877       pid_t pid;
3878       int fd_in, fd_out;
3879       int lsize = 0;
3880       int lptr = 0;
3881
3882       if ((expand_forbid & RDO_RUN) != 0)
3883         {
3884         expand_string_message = US"running a command is not permitted";
3885         goto EXPAND_FAILED;
3886         }
3887
3888       while (isspace(*s)) s++;
3889       if (*s != '{') goto EXPAND_FAILED_CURLY;
3890       arg = expand_string_internal(s+1, TRUE, &s, skipping);
3891       if (arg == NULL) goto EXPAND_FAILED;
3892       while (isspace(*s)) s++;
3893       if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3894
3895       if (skipping)   /* Just pretend it worked when we're skipping */
3896         {
3897         runrc = 0;
3898         }
3899       else
3900         {
3901         if (!transport_set_up_command(&argv,    /* anchor for arg list */
3902             arg,                                /* raw command */
3903             FALSE,                              /* don't expand the arguments */
3904             0,                                  /* not relevant when... */
3905             NULL,                               /* no transporting address */
3906             US"${run} expansion",               /* for error messages */
3907             &expand_string_message))            /* where to put error message */
3908           {
3909           goto EXPAND_FAILED;
3910           }
3911
3912         /* Create the child process, making it a group leader. */
3913
3914         pid = child_open(argv, NULL, 0077, &fd_in, &fd_out, TRUE);
3915
3916         if (pid < 0)
3917           {
3918           expand_string_message =
3919             string_sprintf("couldn't create child process: %s", strerror(errno));
3920           goto EXPAND_FAILED;
3921           }
3922
3923         /* Nothing is written to the standard input. */
3924
3925         (void)close(fd_in);
3926
3927         /* Wait for the process to finish, applying the timeout, and inspect its
3928         return code for serious disasters. Simple non-zero returns are passed on.
3929         */
3930
3931         if ((runrc = child_close(pid, 60)) < 0)
3932           {
3933           if (runrc == -256)
3934             {
3935             expand_string_message = string_sprintf("command timed out");
3936             killpg(pid, SIGKILL);       /* Kill the whole process group */
3937             }
3938
3939           else if (runrc == -257)
3940             expand_string_message = string_sprintf("wait() failed: %s",
3941               strerror(errno));
3942
3943           else
3944             expand_string_message = string_sprintf("command killed by signal %d",
3945               -runrc);
3946
3947           goto EXPAND_FAILED;
3948           }
3949
3950         /* Read the pipe to get the command's output into $value (which is kept
3951         in lookup_value). */
3952
3953         f = fdopen(fd_out, "rb");
3954         lookup_value = NULL;
3955         lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
3956         (void)fclose(f);
3957         }
3958
3959       /* Process the yes/no strings; $value may be useful in both cases */
3960
3961       switch(process_yesno(
3962                skipping,                     /* were previously skipping */
3963                runrc == 0,                   /* success/failure indicator */
3964                lookup_value,                 /* value to reset for string2 */
3965                &s,                           /* input pointer */
3966                &yield,                       /* output pointer */
3967                &size,                        /* output size */
3968                &ptr,                         /* output current point */
3969                US"run"))                     /* condition type */
3970         {
3971         case 1: goto EXPAND_FAILED;          /* when all is well, the */
3972         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
3973         }
3974
3975       continue;
3976       }
3977
3978     /* Handle character translation for "tr" */
3979
3980     case EITEM_TR:
3981       {
3982       int oldptr = ptr;
3983       int o2m;
3984       uschar *sub[3];
3985
3986       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr"))
3987         {
3988         case 1: goto EXPAND_FAILED_CURLY;
3989         case 2:
3990         case 3: goto EXPAND_FAILED;
3991         }
3992
3993       yield = string_cat(yield, &size, &ptr, sub[0], Ustrlen(sub[0]));
3994       o2m = Ustrlen(sub[2]) - 1;
3995
3996       if (o2m >= 0) for (; oldptr < ptr; oldptr++)
3997         {
3998         uschar *m = Ustrrchr(sub[1], yield[oldptr]);
3999         if (m != NULL)
4000           {
4001           int o = m - sub[1];
4002           yield[oldptr] = sub[2][(o < o2m)? o : o2m];
4003           }
4004         }
4005
4006       continue;
4007       }
4008
4009     /* Handle "hash", "length", "nhash", and "substr" when they are given with
4010     expanded arguments. */
4011
4012     case EITEM_HASH:
4013     case EITEM_LENGTH:
4014     case EITEM_NHASH:
4015     case EITEM_SUBSTR:
4016       {
4017       int i;
4018       int len;
4019       uschar *ret;
4020       int val[2] = { 0, -1 };
4021       uschar *sub[3];
4022
4023       /* "length" takes only 2 arguments whereas the others take 2 or 3.
4024       Ensure that sub[2] is set in the ${length case. */
4025
4026       sub[2] = NULL;
4027       switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
4028              TRUE, name))
4029         {
4030         case 1: goto EXPAND_FAILED_CURLY;
4031         case 2:
4032         case 3: goto EXPAND_FAILED;
4033         }
4034
4035       /* Juggle the arguments if there are only two of them: always move the
4036       string to the last position and make ${length{n}{str}} equivalent to
4037       ${substr{0}{n}{str}}. See the defaults for val[] above. */
4038
4039       if (sub[2] == NULL)
4040         {
4041         sub[2] = sub[1];
4042         sub[1] = NULL;
4043         if (item_type == EITEM_LENGTH)
4044           {
4045           sub[1] = sub[0];
4046           sub[0] = NULL;
4047           }
4048         }
4049
4050       for (i = 0; i < 2; i++)
4051         {
4052         if (sub[i] == NULL) continue;
4053         val[i] = (int)Ustrtol(sub[i], &ret, 10);
4054         if (*ret != 0 || (i != 0 && val[i] < 0))
4055           {
4056           expand_string_message = string_sprintf("\"%s\" is not a%s number "
4057             "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
4058           goto EXPAND_FAILED;
4059           }
4060         }
4061
4062       ret =
4063         (item_type == EITEM_HASH)?
4064           compute_hash(sub[2], val[0], val[1], &len) :
4065         (item_type == EITEM_NHASH)?
4066           compute_nhash(sub[2], val[0], val[1], &len) :
4067           extract_substr(sub[2], val[0], val[1], &len);
4068
4069       if (ret == NULL) goto EXPAND_FAILED;
4070       yield = string_cat(yield, &size, &ptr, ret, len);
4071       continue;
4072       }
4073
4074     /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
4075     This code originally contributed by Steve Haslam. It currently supports
4076     the use of MD5 and SHA-1 hashes.
4077
4078     We need some workspace that is large enough to handle all the supported
4079     hash types. Use macros to set the sizes rather than be too elaborate. */
4080
4081     #define MAX_HASHLEN      20
4082     #define MAX_HASHBLOCKLEN 64
4083
4084     case EITEM_HMAC:
4085       {
4086       uschar *sub[3];
4087       md5 md5_base;
4088       sha1 sha1_base;
4089       void *use_base;
4090       int type, i;
4091       int hashlen;      /* Number of octets for the hash algorithm's output */
4092       int hashblocklen; /* Number of octets the hash algorithm processes */
4093       uschar *keyptr, *p;
4094       unsigned int keylen;
4095
4096       uschar keyhash[MAX_HASHLEN];
4097       uschar innerhash[MAX_HASHLEN];
4098       uschar finalhash[MAX_HASHLEN];
4099       uschar finalhash_hex[2*MAX_HASHLEN];
4100       uschar innerkey[MAX_HASHBLOCKLEN];
4101       uschar outerkey[MAX_HASHBLOCKLEN];
4102
4103       switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name))
4104         {
4105         case 1: goto EXPAND_FAILED_CURLY;
4106         case 2:
4107         case 3: goto EXPAND_FAILED;
4108         }
4109
4110       if (Ustrcmp(sub[0], "md5") == 0)
4111         {
4112         type = HMAC_MD5;
4113         use_base = &md5_base;
4114         hashlen = 16;
4115         hashblocklen = 64;
4116         }
4117       else if (Ustrcmp(sub[0], "sha1") == 0)
4118         {
4119         type = HMAC_SHA1;
4120         use_base = &sha1_base;
4121         hashlen = 20;
4122         hashblocklen = 64;
4123         }
4124       else
4125         {
4126         expand_string_message =
4127           string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
4128         goto EXPAND_FAILED;
4129         }
4130
4131       keyptr = sub[1];
4132       keylen = Ustrlen(keyptr);
4133
4134       /* If the key is longer than the hash block length, then hash the key
4135       first */
4136
4137       if (keylen > hashblocklen)
4138         {
4139         chash_start(type, use_base);
4140         chash_end(type, use_base, keyptr, keylen, keyhash);
4141         keyptr = keyhash;
4142         keylen = hashlen;
4143         }
4144
4145       /* Now make the inner and outer key values */
4146
4147       memset(innerkey, 0x36, hashblocklen);
4148       memset(outerkey, 0x5c, hashblocklen);
4149
4150       for (i = 0; i < keylen; i++)
4151         {
4152         innerkey[i] ^= keyptr[i];
4153         outerkey[i] ^= keyptr[i];
4154         }
4155
4156       /* Now do the hashes */
4157
4158       chash_start(type, use_base);
4159       chash_mid(type, use_base, innerkey);
4160       chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
4161
4162       chash_start(type, use_base);
4163       chash_mid(type, use_base, outerkey);
4164       chash_end(type, use_base, innerhash, hashlen, finalhash);
4165
4166       /* Encode the final hash as a hex string */
4167
4168       p = finalhash_hex;
4169       for (i = 0; i < hashlen; i++)
4170         {
4171         *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
4172         *p++ = hex_digits[finalhash[i] & 0x0f];
4173         }
4174
4175       DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
4176         (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
4177
4178       yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
4179       }
4180
4181     continue;
4182
4183     /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
4184     We have to save the numerical variables and restore them afterwards. */
4185
4186     case EITEM_SG:
4187       {
4188       const pcre *re;
4189       int moffset, moffsetextra, slen;
4190       int roffset;
4191       int emptyopt;
4192       const uschar *rerror;
4193       uschar *subject;
4194       uschar *sub[3];
4195       int save_expand_nmax =
4196         save_expand_strings(save_expand_nstring, save_expand_nlength);
4197
4198       switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg"))
4199         {
4200         case 1: goto EXPAND_FAILED_CURLY;
4201         case 2:
4202         case 3: goto EXPAND_FAILED;
4203         }
4204
4205       /* Compile the regular expression */
4206
4207       re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
4208         NULL);
4209
4210       if (re == NULL)
4211         {
4212         expand_string_message = string_sprintf("regular expression error in "
4213           "\"%s\": %s at offset %d", sub[1], rerror, roffset);
4214         goto EXPAND_FAILED;
4215         }
4216
4217       /* Now run a loop to do the substitutions as often as necessary. It ends
4218       when there are no more matches. Take care over matches of the null string;
4219       do the same thing as Perl does. */
4220
4221       subject = sub[0];
4222       slen = Ustrlen(sub[0]);
4223       moffset = moffsetextra = 0;
4224       emptyopt = 0;
4225
4226       for (;;)
4227         {
4228         int ovector[3*(EXPAND_MAXN+1)];
4229         int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
4230           PCRE_EOPT | emptyopt, ovector, sizeof(ovector)/sizeof(int));
4231         int nn;
4232         uschar *insert;
4233
4234         /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
4235         is not necessarily the end. We want to repeat the match from one
4236         character further along, but leaving the basic offset the same (for
4237         copying below). We can't be at the end of the string - that was checked
4238         before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
4239         finished; copy the remaining string and end the loop. */
4240
4241         if (n < 0)
4242           {
4243           if (emptyopt != 0)
4244             {
4245             moffsetextra = 1;
4246             emptyopt = 0;
4247             continue;
4248             }
4249           yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
4250           break;
4251           }
4252
4253         /* Match - set up for expanding the replacement. */
4254
4255         if (n == 0) n = EXPAND_MAXN + 1;
4256         expand_nmax = 0;
4257         for (nn = 0; nn < n*2; nn += 2)
4258           {
4259           expand_nstring[expand_nmax] = subject + ovector[nn];
4260           expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
4261           }
4262         expand_nmax--;
4263
4264         /* Copy the characters before the match, plus the expanded insertion. */
4265
4266         yield = string_cat(yield, &size, &ptr, subject + moffset,
4267           ovector[0] - moffset);
4268         insert = expand_string(sub[2]);
4269         if (insert == NULL) goto EXPAND_FAILED;
4270         yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
4271
4272         moffset = ovector[1];
4273         moffsetextra = 0;
4274         emptyopt = 0;
4275
4276         /* If we have matched an empty string, first check to see if we are at
4277         the end of the subject. If so, the loop is over. Otherwise, mimic
4278         what Perl's /g options does. This turns out to be rather cunning. First
4279         we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
4280         string at the same point. If this fails (picked up above) we advance to
4281         the next character. */
4282
4283         if (ovector[0] == ovector[1])
4284           {
4285           if (ovector[0] == slen) break;
4286           emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
4287           }
4288         }
4289
4290       /* All done - restore numerical variables. */
4291
4292       restore_expand_strings(save_expand_nmax, save_expand_nstring,
4293         save_expand_nlength);
4294       continue;
4295       }
4296
4297     /* Handle keyed and numbered substring extraction. If the first argument
4298     consists entirely of digits, then a numerical extraction is assumed. */
4299
4300     case EITEM_EXTRACT:
4301       {
4302       int i;
4303       int j = 2;
4304       int field_number = 1;
4305       BOOL field_number_set = FALSE;
4306       uschar *save_lookup_value = lookup_value;
4307       uschar *sub[3];
4308       int save_expand_nmax =
4309         save_expand_strings(save_expand_nstring, save_expand_nlength);
4310
4311       /* Read the arguments */
4312
4313       for (i = 0; i < j; i++)
4314         {
4315         while (isspace(*s)) s++;
4316         if (*s == '{')
4317           {
4318           sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
4319           if (sub[i] == NULL) goto EXPAND_FAILED;
4320           if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4321
4322           /* After removal of leading and trailing white space, the first
4323           argument must not be empty; if it consists entirely of digits
4324           (optionally preceded by a minus sign), this is a numerical
4325           extraction, and we expect 3 arguments. */
4326
4327           if (i == 0)
4328             {
4329             int len;
4330             int x = 0;
4331             uschar *p = sub[0];
4332
4333             while (isspace(*p)) p++;
4334             sub[0] = p;
4335
4336             len = Ustrlen(p);
4337             while (len > 0 && isspace(p[len-1])) len--;
4338             p[len] = 0;
4339
4340             if (*p == 0)
4341               {
4342               expand_string_message = US"first argument of \"extract\" must "
4343                 "not be empty";
4344               goto EXPAND_FAILED;
4345               }
4346
4347             if (*p == '-')
4348               {
4349               field_number = -1;
4350               p++;
4351               }
4352             while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
4353             if (*p == 0)
4354               {
4355               field_number *= x;
4356               j = 3;               /* Need 3 args */
4357               field_number_set = TRUE;
4358               }
4359             }
4360           }
4361         else goto EXPAND_FAILED_CURLY;
4362         }
4363
4364       /* Extract either the numbered or the keyed substring into $value. If
4365       skipping, just pretend the extraction failed. */
4366
4367       lookup_value = skipping? NULL : field_number_set?
4368         expand_gettokened(field_number, sub[1], sub[2]) :
4369         expand_getkeyed(sub[0], sub[1]);
4370
4371       /* If no string follows, $value gets substituted; otherwise there can
4372       be yes/no strings, as for lookup or if. */
4373
4374       switch(process_yesno(
4375                skipping,                     /* were previously skipping */
4376                lookup_value != NULL,         /* success/failure indicator */
4377                save_lookup_value,            /* value to reset for string2 */
4378                &s,                           /* input pointer */
4379                &yield,                       /* output pointer */
4380                &size,                        /* output size */
4381                &ptr,                         /* output current point */
4382                US"extract"))                 /* condition type */
4383         {
4384         case 1: goto EXPAND_FAILED;          /* when all is well, the */
4385         case 2: goto EXPAND_FAILED_CURLY;    /* returned value is 0 */
4386         }
4387
4388       /* All done - restore numerical variables. */
4389
4390       restore_expand_strings(save_expand_nmax, save_expand_nstring,
4391         save_expand_nlength);
4392
4393       continue;
4394       }
4395
4396
4397     /* If ${dlfunc support is configured, handle calling dynamically-loaded
4398     functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
4399     or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
4400     a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
4401
4402     #define EXPAND_DLFUNC_MAX_ARGS 8
4403
4404     case EITEM_DLFUNC:
4405     #ifndef EXPAND_DLFUNC
4406     expand_string_message = US"\"${dlfunc\" encountered, but this facility "
4407       "is not included in this binary";
4408     goto EXPAND_FAILED;
4409
4410     #else   /* EXPAND_DLFUNC */
4411       {
4412       tree_node *t;
4413       exim_dlfunc_t *func;
4414       uschar *result;
4415       int status, argc;
4416       uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
4417
4418       if ((expand_forbid & RDO_DLFUNC) != 0)
4419         {
4420         expand_string_message =
4421           US"dynamically-loaded functions are not permitted";
4422         goto EXPAND_FAILED;
4423         }
4424
4425       switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
4426            TRUE, US"dlfunc"))
4427         {
4428         case 1: goto EXPAND_FAILED_CURLY;
4429         case 2:
4430         case 3: goto EXPAND_FAILED;
4431         }
4432
4433       /* If skipping, we don't actually do anything */
4434
4435       if (skipping) continue;
4436
4437       /* Look up the dynamically loaded object handle in the tree. If it isn't
4438       found, dlopen() the file and put the handle in the tree for next time. */
4439
4440       t = tree_search(dlobj_anchor, argv[0]);
4441       if (t == NULL)
4442         {
4443         void *handle = dlopen(CS argv[0], RTLD_LAZY);
4444         if (handle == NULL)
4445           {
4446           expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
4447             argv[0], dlerror());
4448           log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
4449           goto EXPAND_FAILED;
4450           }
4451         t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
4452         Ustrcpy(t->name, argv[0]);
4453         t->data.ptr = handle;
4454         (void)tree_insertnode(&dlobj_anchor, t);
4455         }
4456
4457       /* Having obtained the dynamically loaded object handle, look up the
4458       function pointer. */
4459
4460       func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
4461       if (func == NULL)
4462         {
4463         expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
4464           "%s", argv[1], argv[0], dlerror());
4465         log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
4466         goto EXPAND_FAILED;
4467         }
4468
4469       /* Call the function and work out what to do with the result. If it
4470       returns OK, we have a replacement string; if it returns DEFER then
4471       expansion has failed in a non-forced manner; if it returns FAIL then
4472       failure was forced; if it returns ERROR or any other value there's a
4473       problem, so panic slightly. */
4474
4475       result = NULL;
4476       for (argc = 0; argv[argc] != NULL; argc++);
4477       status = func(&result, argc - 2, &argv[2]);
4478       if(status == OK)
4479         {
4480         if (result == NULL) result = US"";
4481         yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
4482         continue;
4483         }
4484       else
4485         {
4486         expand_string_message = result == NULL ? US"(no message)" : result;
4487         if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
4488           else if(status != FAIL)
4489             log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
4490               argv[0], argv[1], status, expand_string_message);
4491         goto EXPAND_FAILED;
4492         }
4493       }
4494     #endif /* EXPAND_DLFUNC */
4495     }
4496
4497   /* Control reaches here if the name is not recognized as one of the more
4498   complicated expansion items. Check for the "operator" syntax (name terminated
4499   by a colon). Some of the operators have arguments, separated by _ from the
4500   name. */
4501
4502   if (*s == ':')
4503     {
4504     int c;
4505     uschar *arg = NULL;
4506     uschar *sub = expand_string_internal(s+1, TRUE, &s, skipping);
4507     if (sub == NULL) goto EXPAND_FAILED;
4508     s++;
4509
4510     /* Owing to an historical mis-design, an underscore may be part of the
4511     operator name, or it may introduce arguments.  We therefore first scan the
4512     table of names that contain underscores. If there is no match, we cut off
4513     the arguments and then scan the main table. */
4514
4515     c = chop_match(name, op_table_underscore,
4516       sizeof(op_table_underscore)/sizeof(uschar *));
4517
4518     if (c < 0)
4519       {
4520       arg = Ustrchr(name, '_');
4521       if (arg != NULL) *arg = 0;
4522       c = chop_match(name, op_table_main,
4523         sizeof(op_table_main)/sizeof(uschar *));
4524       if (c >= 0) c += sizeof(op_table_underscore)/sizeof(uschar *);
4525       if (arg != NULL) *arg++ = '_';   /* Put back for error messages */
4526       }
4527
4528     /* If we are skipping, we don't need to perform the operation at all.
4529     This matters for operations like "mask", because the data may not be
4530     in the correct format when skipping. For example, the expression may test
4531     for the existence of $sender_host_address before trying to mask it. For
4532     other operations, doing them may not fail, but it is a waste of time. */
4533
4534     if (skipping && c >= 0) continue;
4535
4536     /* Otherwise, switch on the operator type */
4537
4538     switch(c)
4539       {
4540       case EOP_BASE62:
4541         {
4542         uschar *t;
4543         unsigned long int n = Ustrtoul(sub, &t, 10);
4544         if (*t != 0)
4545           {
4546           expand_string_message = string_sprintf("argument for base62 "
4547             "operator is \"%s\", which is not a decimal number", sub);
4548           goto EXPAND_FAILED;
4549           }
4550         t = string_base62(n);
4551         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4552         continue;
4553         }
4554
4555       /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
4556
4557       case EOP_BASE62D:
4558         {
4559         uschar buf[16];
4560         uschar *tt = sub;
4561         unsigned long int n = 0;
4562         while (*tt != 0)
4563           {
4564           uschar *t = Ustrchr(base62_chars, *tt++);
4565           if (t == NULL)
4566             {
4567             expand_string_message = string_sprintf("argument for base62d "
4568               "operator is \"%s\", which is not a base %d number", sub,
4569               BASE_62);
4570             goto EXPAND_FAILED;
4571             }
4572           n = n * BASE_62 + (t - base62_chars);
4573           }
4574         (void)sprintf(CS buf, "%ld", n);
4575         yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
4576         continue;
4577         }
4578
4579       case EOP_EXPAND:
4580         {
4581         uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping);
4582         if (expanded == NULL)
4583           {
4584           expand_string_message =
4585             string_sprintf("internal expansion of \"%s\" failed: %s", sub,
4586               expand_string_message);
4587           goto EXPAND_FAILED;
4588           }
4589         yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
4590         continue;
4591         }
4592
4593       case EOP_LC:
4594         {
4595         int count = 0;
4596         uschar *t = sub - 1;
4597         while (*(++t) != 0) { *t = tolower(*t); count++; }
4598         yield = string_cat(yield, &size, &ptr, sub, count);
4599         continue;
4600         }
4601
4602       case EOP_UC:
4603         {
4604         int count = 0;
4605         uschar *t = sub - 1;
4606         while (*(++t) != 0) { *t = toupper(*t); count++; }
4607         yield = string_cat(yield, &size, &ptr, sub, count);
4608         continue;
4609         }
4610
4611       case EOP_MD5:
4612         {
4613         md5 base;
4614         uschar digest[16];
4615         int j;
4616         char st[33];
4617         md5_start(&base);
4618         md5_end(&base, sub, Ustrlen(sub), digest);
4619         for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
4620         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4621         continue;
4622         }
4623
4624       case EOP_SHA1:
4625         {
4626         sha1 base;
4627         uschar digest[20];
4628         int j;
4629         char st[41];
4630         sha1_start(&base);
4631         sha1_end(&base, sub, Ustrlen(sub), digest);
4632         for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
4633         yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4634         continue;
4635         }
4636
4637       /* Convert hex encoding to base64 encoding */
4638
4639       case EOP_HEX2B64:
4640         {
4641         int c = 0;
4642         int b = -1;
4643         uschar *in = sub;
4644         uschar *out = sub;
4645         uschar *enc;
4646
4647         for (enc = sub; *enc != 0; enc++)
4648           {
4649           if (!isxdigit(*enc))
4650             {
4651             expand_string_message = string_sprintf("\"%s\" is not a hex "
4652               "string", sub);
4653             goto EXPAND_FAILED;
4654             }
4655           c++;
4656           }
4657
4658         if ((c & 1) != 0)
4659           {
4660           expand_string_message = string_sprintf("\"%s\" contains an odd "
4661             "number of characters", sub);
4662           goto EXPAND_FAILED;
4663           }
4664
4665         while ((c = *in++) != 0)
4666           {
4667           if (isdigit(c)) c -= '0';
4668           else c = toupper(c) - 'A' + 10;
4669           if (b == -1)
4670             {
4671             b = c << 4;
4672             }
4673           else
4674             {
4675             *out++ = b | c;
4676             b = -1;
4677             }
4678           }
4679
4680         enc = auth_b64encode(sub, out - sub);
4681         yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
4682         continue;
4683         }
4684
4685       /* mask applies a mask to an IP address; for example the result of
4686       ${mask:131.111.10.206/28} is 131.111.10.192/28. */
4687
4688       case EOP_MASK:
4689         {
4690         int count;
4691         uschar *endptr;
4692         int binary[4];
4693         int mask, maskoffset;
4694         int type = string_is_ip_address(sub, &maskoffset);
4695         uschar buffer[64];
4696
4697         if (type == 0)
4698           {
4699           expand_string_message = string_sprintf("\"%s\" is not an IP address",
4700            sub);
4701           goto EXPAND_FAILED;
4702           }
4703
4704         if (maskoffset == 0)
4705           {
4706           expand_string_message = string_sprintf("missing mask value in \"%s\"",
4707             sub);
4708           goto EXPAND_FAILED;
4709           }
4710
4711         mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
4712
4713         if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
4714           {
4715           expand_string_message = string_sprintf("mask value too big in \"%s\"",
4716             sub);
4717           goto EXPAND_FAILED;
4718           }
4719
4720         /* Convert the address to binary integer(s) and apply the mask */
4721
4722         sub[maskoffset] = 0;
4723         count = host_aton(sub, binary);
4724         host_mask(count, binary, mask);
4725
4726         /* Convert to masked textual format and add to output. */
4727
4728         yield = string_cat(yield, &size, &ptr, buffer,
4729           host_nmtoa(count, binary, mask, buffer, '.'));
4730         continue;
4731         }
4732
4733       case EOP_ADDRESS:
4734       case EOP_LOCAL_PART:
4735       case EOP_DOMAIN:
4736         {
4737         uschar *error;
4738         int start, end, domain;
4739         uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
4740           FALSE);
4741         if (t != NULL)
4742           {
4743           if (c != EOP_DOMAIN)
4744             {
4745             if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
4746             yield = string_cat(yield, &size, &ptr, sub+start, end-start);
4747             }
4748           else if (domain != 0)
4749             {
4750             domain += start;
4751             yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
4752             }
4753           }
4754         continue;
4755         }
4756
4757       /* quote puts a string in quotes if it is empty or contains anything
4758       other than alphamerics, underscore, dot, or hyphen.
4759
4760       quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
4761       be quoted in order to be a valid local part.
4762
4763       In both cases, newlines and carriage returns are converted into \n and \r
4764       respectively */
4765
4766       case EOP_QUOTE:
4767       case EOP_QUOTE_LOCAL_PART:
4768       if (arg == NULL)
4769         {
4770         BOOL needs_quote = (*sub == 0);      /* TRUE for empty string */
4771         uschar *t = sub - 1;
4772
4773         if (c == EOP_QUOTE)
4774           {
4775           while (!needs_quote && *(++t) != 0)
4776             needs_quote = !isalnum(*t) && !strchr("_-.", *t);
4777           }
4778         else  /* EOP_QUOTE_LOCAL_PART */
4779           {
4780           while (!needs_quote && *(++t) != 0)
4781             needs_quote = !isalnum(*t) &&
4782               strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
4783               (*t != '.' || t == sub || t[1] == 0);
4784           }
4785
4786         if (needs_quote)
4787           {
4788           yield = string_cat(yield, &size, &ptr, US"\"", 1);
4789           t = sub - 1;
4790           while (*(++t) != 0)
4791             {
4792             if (*t == '\n')
4793               yield = string_cat(yield, &size, &ptr, US"\\n", 2);
4794             else if (*t == '\r')
4795               yield = string_cat(yield, &size, &ptr, US"\\r", 2);
4796             else
4797               {
4798               if (*t == '\\' || *t == '"')
4799                 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4800               yield = string_cat(yield, &size, &ptr, t, 1);
4801               }
4802             }
4803           yield = string_cat(yield, &size, &ptr, US"\"", 1);
4804           }
4805         else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4806         continue;
4807         }
4808
4809       /* quote_lookuptype does lookup-specific quoting */
4810
4811       else
4812         {
4813         int n;
4814         uschar *opt = Ustrchr(arg, '_');
4815
4816         if (opt != NULL) *opt++ = 0;
4817
4818         n = search_findtype(arg, Ustrlen(arg));
4819         if (n < 0)
4820           {
4821           expand_string_message = search_error_message;
4822           goto EXPAND_FAILED;
4823           }
4824
4825         if (lookup_list[n].quote != NULL)
4826           sub = (lookup_list[n].quote)(sub, opt);
4827         else if (opt != NULL) sub = NULL;
4828
4829         if (sub == NULL)
4830           {
4831           expand_string_message = string_sprintf(
4832             "\"%s\" unrecognized after \"${quote_%s\"",
4833             opt, arg);
4834           goto EXPAND_FAILED;
4835           }
4836
4837         yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4838         continue;
4839         }
4840
4841       /* rx quote sticks in \ before any non-alphameric character so that
4842       the insertion works in a regular expression. */
4843
4844       case EOP_RXQUOTE:
4845         {
4846         uschar *t = sub - 1;
4847         while (*(++t) != 0)
4848           {
4849           if (!isalnum(*t))
4850             yield = string_cat(yield, &size, &ptr, US"\\", 1);
4851           yield = string_cat(yield, &size, &ptr, t, 1);
4852           }
4853         continue;
4854         }
4855
4856       /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
4857       prescribed by the RFC, if there are characters that need to be encoded */
4858
4859       case EOP_RFC2047:
4860         {
4861         uschar buffer[2048];
4862         uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
4863           buffer, sizeof(buffer), FALSE);
4864         yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
4865         continue;
4866         }
4867
4868       /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
4869       underscores */
4870
4871       case EOP_FROM_UTF8:
4872         {
4873         while (*sub != 0)
4874           {
4875           int c;
4876           uschar buff[4];
4877           GETUTF8INC(c, sub);
4878           if (c > 255) c = '_';
4879           buff[0] = c;
4880           yield = string_cat(yield, &size, &ptr, buff, 1);
4881           }
4882         continue;
4883         }
4884
4885       /* escape turns all non-printing characters into escape sequences. */
4886
4887       case EOP_ESCAPE:
4888         {
4889         uschar *t = string_printing(sub);
4890         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4891         continue;
4892         }
4893
4894       /* Handle numeric expression evaluation */
4895
4896       case EOP_EVAL:
4897       case EOP_EVAL10:
4898         {
4899         uschar *save_sub = sub;
4900         uschar *error = NULL;
4901         int n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
4902         if (error != NULL)
4903           {
4904           expand_string_message = string_sprintf("error in expression "
4905             "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
4906               save_sub);
4907           goto EXPAND_FAILED;
4908           }
4909         sprintf(CS var_buffer, "%d", n);
4910         yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4911         continue;
4912         }
4913
4914       /* Handle time period formating */
4915
4916       case EOP_TIME_EVAL:
4917         {
4918         int n = readconf_readtime(sub, 0, FALSE);
4919         if (n < 0)
4920           {
4921           expand_string_message = string_sprintf("string \"%s\" is not an "
4922             "Exim time interval in \"%s\" operator", sub, name);
4923           goto EXPAND_FAILED;
4924           }
4925         sprintf(CS var_buffer, "%d", n);
4926         yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4927         continue;
4928         }
4929
4930       case EOP_TIME_INTERVAL:
4931         {
4932         int n;
4933         uschar *t = read_number(&n, sub);
4934         if (*t != 0) /* Not A Number*/
4935           {
4936           expand_string_message = string_sprintf("string \"%s\" is not a "
4937             "positive number in \"%s\" operator", sub, name);
4938           goto EXPAND_FAILED;
4939           }
4940         t = readconf_printtime(n);
4941         yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4942         continue;
4943         }
4944
4945       /* Convert string to base64 encoding */
4946
4947       case EOP_STR2B64:
4948         {
4949         uschar *encstr = auth_b64encode(sub, Ustrlen(sub));
4950         yield = string_cat(yield, &size, &ptr, encstr, Ustrlen(encstr));
4951         continue;
4952         }
4953
4954       /* strlen returns the length of the string */
4955
4956       case EOP_STRLEN:
4957         {
4958         uschar buff[24];
4959         (void)sprintf(CS buff, "%d", Ustrlen(sub));
4960         yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
4961         continue;
4962         }
4963
4964       /* length_n or l_n takes just the first n characters or the whole string,
4965       whichever is the shorter;
4966
4967       substr_m_n, and s_m_n take n characters from offset m; negative m take
4968       from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
4969       takes the rest, either to the right or to the left.
4970
4971       hash_n or h_n makes a hash of length n from the string, yielding n
4972       characters from the set a-z; hash_n_m makes a hash of length n, but
4973       uses m characters from the set a-zA-Z0-9.
4974
4975       nhash_n returns a single number between 0 and n-1 (in text form), while
4976       nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
4977       between 0 and n-1 and the second between 0 and m-1. */
4978
4979       case EOP_LENGTH:
4980       case EOP_L:
4981       case EOP_SUBSTR:
4982       case EOP_S:
4983       case EOP_HASH:
4984       case EOP_H:
4985       case EOP_NHASH:
4986       case EOP_NH:
4987         {
4988         int sign = 1;
4989         int value1 = 0;
4990         int value2 = -1;
4991         int *pn;
4992         int len;
4993         uschar *ret;
4994
4995         if (arg == NULL)
4996           {
4997           expand_string_message = string_sprintf("missing values after %s",
4998             name);
4999           goto EXPAND_FAILED;
5000           }
5001
5002         /* "length" has only one argument, effectively being synonymous with
5003         substr_0_n. */
5004
5005         if (c == EOP_LENGTH || c == EOP_L)
5006           {
5007           pn = &value2;
5008           value2 = 0;
5009           }
5010
5011         /* The others have one or two arguments; for "substr" the first may be
5012         negative. The second being negative means "not supplied". */
5013
5014         else
5015           {
5016           pn = &value1;
5017           if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
5018           }
5019
5020         /* Read up to two numbers, separated by underscores */
5021
5022         ret = arg;
5023         while (*arg != 0)
5024           {
5025           if (arg != ret && *arg == '_' && pn == &value1)
5026             {
5027             pn = &value2;
5028             value2 = 0;
5029             if (arg[1] != 0) arg++;
5030             }
5031           else if (!isdigit(*arg))
5032             {
5033             expand_string_message =
5034               string_sprintf("non-digit after underscore in \"%s\"", name);
5035             goto EXPAND_FAILED;
5036             }
5037           else *pn = (*pn)*10 + *arg++ - '0';
5038           }
5039         value1 *= sign;
5040
5041         /* Perform the required operation */
5042
5043         ret =
5044           (c == EOP_HASH || c == EOP_H)?
5045              compute_hash(sub, value1, value2, &len) :
5046           (c == EOP_NHASH || c == EOP_NH)?
5047              compute_nhash(sub, value1, value2, &len) :
5048              extract_substr(sub, value1, value2, &len);
5049
5050         if (ret == NULL) goto EXPAND_FAILED;
5051         yield = string_cat(yield, &size, &ptr, ret, len);
5052         continue;
5053         }
5054
5055       /* Stat a path */
5056
5057       case EOP_STAT:
5058         {
5059         uschar *s;
5060         uschar smode[12];
5061         uschar **modetable[3];
5062         int i;
5063         mode_t mode;
5064         struct stat st;
5065
5066         if ((expand_forbid & RDO_EXISTS) != 0)
5067           {
5068           expand_string_message = US"Use of the stat() expansion is not permitted";
5069           goto EXPAND_FAILED;
5070           }
5071
5072         if (stat(CS sub, &st) < 0)
5073           {
5074           expand_string_message = string_sprintf("stat(%s) failed: %s",
5075             sub, strerror(errno));
5076           goto EXPAND_FAILED;
5077           }
5078         mode = st.st_mode;
5079         switch (mode & S_IFMT)
5080           {
5081           case S_IFIFO: smode[0] = 'p'; break;
5082           case S_IFCHR: smode[0] = 'c'; break;
5083           case S_IFDIR: smode[0] = 'd'; break;
5084           case S_IFBLK: smode[0] = 'b'; break;
5085           case S_IFREG: smode[0] = '-'; break;
5086           default: smode[0] = '?'; break;
5087           }
5088
5089         modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
5090         modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
5091         modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
5092
5093         for (i = 0; i < 3; i++)
5094           {
5095           memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
5096           mode >>= 3;
5097           }
5098
5099         smode[10] = 0;
5100         s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
5101           "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
5102           (long)(st.st_mode & 077777), smode, (long)st.st_ino,
5103           (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
5104           (long)st.st_gid, st.st_size, (long)st.st_atime,
5105           (long)st.st_mtime, (long)st.st_ctime);
5106         yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
5107         continue;
5108         }
5109
5110       /* Unknown operator */
5111
5112       default:
5113       expand_string_message =
5114         string_sprintf("unknown expansion operator \"%s\"", name);
5115       goto EXPAND_FAILED;
5116       }
5117     }
5118
5119   /* Handle a plain name. If this is the first thing in the expansion, release
5120   the pre-allocated buffer. If the result data is known to be in a new buffer,
5121   newsize will be set to the size of that buffer, and we can just point at that
5122   store instead of copying. Many expansion strings contain just one reference,
5123   so this is a useful optimization, especially for humungous headers
5124   ($message_headers). */
5125
5126   if (*s++ == '}')
5127     {
5128     int len;
5129     int newsize = 0;
5130     if (ptr == 0)
5131       {
5132       store_reset(yield);
5133       yield = NULL;
5134       size = 0;
5135       }
5136     value = find_variable(name, FALSE, skipping, &newsize);
5137     if (value == NULL)
5138       {
5139       expand_string_message =
5140         string_sprintf("unknown variable in \"${%s}\"", name);
5141       check_variable_error_message(name);
5142       goto EXPAND_FAILED;
5143       }
5144     len = Ustrlen(value);
5145     if (yield == NULL && newsize != 0)
5146       {
5147       yield = value;
5148       size = newsize;
5149       ptr = len;
5150       }
5151     else yield = string_cat(yield, &size, &ptr, value, len);
5152     continue;
5153     }
5154
5155   /* Else there's something wrong */
5156
5157   expand_string_message =
5158     string_sprintf("\"${%s\" is not a known operator (or a } is missing "
5159     "in a variable reference)", name);
5160   goto EXPAND_FAILED;
5161   }
5162
5163 /* If we hit the end of the string when ket_ends is set, there is a missing
5164 terminating brace. */
5165
5166 if (ket_ends && *s == 0)
5167   {
5168   expand_string_message = malformed_header?
5169     US"missing } at end of string - could be header name not terminated by colon"
5170     :
5171     US"missing } at end of string";
5172   goto EXPAND_FAILED;
5173   }
5174
5175 /* Expansion succeeded; yield may still be NULL here if nothing was actually
5176 added to the string. If so, set up an empty string. Add a terminating zero. If
5177 left != NULL, return a pointer to the terminator. */
5178
5179 if (yield == NULL) yield = store_get(1);
5180 yield[ptr] = 0;
5181 if (left != NULL) *left = s;
5182
5183 /* Any stacking store that was used above the final string is no longer needed.
5184 In many cases the final string will be the first one that was got and so there
5185 will be optimal store usage. */
5186
5187 store_reset(yield + ptr + 1);
5188 DEBUG(D_expand)
5189   {
5190   debug_printf("expanding: %.*s\n   result: %s\n", (int)(s - string), string,
5191     yield);
5192   if (skipping) debug_printf("skipping: result is not used\n");
5193   }
5194 return yield;
5195
5196 /* This is the failure exit: easiest to program with a goto. We still need
5197 to update the pointer to the terminator, for cases of nested calls with "fail".
5198 */
5199
5200 EXPAND_FAILED_CURLY:
5201 expand_string_message = malformed_header?
5202   US"missing or misplaced { or } - could be header name not terminated by colon"
5203   :
5204   US"missing or misplaced { or }";
5205
5206 /* At one point, Exim reset the store to yield (if yield was not NULL), but
5207 that is a bad idea, because expand_string_message is in dynamic store. */
5208
5209 EXPAND_FAILED:
5210 if (left != NULL) *left = s;
5211 DEBUG(D_expand)
5212   {
5213   debug_printf("failed to expand: %s\n", string);
5214   debug_printf("   error message: %s\n", expand_string_message);
5215   if (expand_string_forcedfail) debug_printf("failure was forced\n");
5216   }
5217 return NULL;
5218 }
5219
5220
5221 /* This is the external function call. Do a quick check for any expansion
5222 metacharacters, and if there are none, just return the input string.
5223
5224 Argument: the string to be expanded
5225 Returns:  the expanded string, or NULL if expansion failed; if failure was
5226           due to a lookup deferring, search_find_defer will be TRUE
5227 */
5228
5229 uschar *
5230 expand_string(uschar *string)
5231 {
5232 search_find_defer = FALSE;
5233 malformed_header = FALSE;
5234 return (Ustrpbrk(string, "$\\") == NULL)? string :
5235   expand_string_internal(string, FALSE, NULL, FALSE);
5236 }
5237
5238
5239
5240 /*************************************************
5241 *              Expand and copy                   *
5242 *************************************************/
5243
5244 /* Now and again we want to expand a string and be sure that the result is in a
5245 new bit of store. This function does that.
5246
5247 Argument: the string to be expanded
5248 Returns:  the expanded string, always in a new bit of store, or NULL
5249 */
5250
5251 uschar *
5252 expand_string_copy(uschar *string)
5253 {
5254 uschar *yield = expand_string(string);
5255 if (yield == string) yield = string_copy(string);
5256 return yield;
5257 }
5258
5259
5260
5261 /*************************************************
5262 *        Expand and interpret as an integer      *
5263 *************************************************/
5264
5265 /* Expand a string, and convert the result into an integer.
5266
5267 Arguments:
5268   string  the string to be expanded
5269   isplus  TRUE if a non-negative number is expected
5270
5271 Returns:  the integer value, or
5272           -1 for an expansion error               ) in both cases, message in
5273           -2 for an integer interpretation error  ) expand_string_message
5274           expand_string_message is set NULL for an OK integer
5275 */
5276
5277 int
5278 expand_string_integer(uschar *string, BOOL isplus)
5279 {
5280 long int value;
5281 uschar *s = expand_string(string);
5282 uschar *msg = US"invalid integer \"%s\"";
5283 uschar *endptr;
5284
5285 /* If expansion failed, expand_string_message will be set. */
5286
5287 if (s == NULL) return -1;
5288
5289 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
5290 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
5291 systems, so we set it zero ourselves. */
5292
5293 errno = 0;
5294 expand_string_message = NULL;               /* Indicates no error */
5295 value = strtol(CS s, CSS &endptr, 0);
5296
5297 if (endptr == s)
5298   {
5299   msg = US"integer expected but \"%s\" found";
5300   }
5301 else if (value < 0 && isplus)
5302   {
5303   msg = US"non-negative integer expected but \"%s\" found";
5304   }
5305 else
5306   {
5307   /* Ensure we can cast this down to an int */
5308   if (value > INT_MAX  || value < INT_MIN) errno = ERANGE;
5309
5310   if (errno != ERANGE)
5311     {
5312     if (tolower(*endptr) == 'k')
5313       {
5314       if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
5315         else value *= 1024;
5316       endptr++;
5317       }
5318     else if (tolower(*endptr) == 'm')
5319       {
5320       if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
5321         errno = ERANGE;
5322       else value *= 1024*1024;
5323       endptr++;
5324       }
5325     }
5326   if (errno == ERANGE)
5327     msg = US"absolute value of integer \"%s\" is too large (overflow)";
5328   else
5329     {
5330     while (isspace(*endptr)) endptr++;
5331     if (*endptr == 0) return (int)value;
5332     }
5333   }
5334
5335 expand_string_message = string_sprintf(CS msg, s);
5336 return -2;
5337 }
5338
5339
5340 /*************************************************
5341 **************************************************
5342 *             Stand-alone test program           *
5343 **************************************************
5344 *************************************************/
5345
5346 #ifdef STAND_ALONE
5347
5348
5349 BOOL
5350 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
5351 {
5352 int ovector[3*(EXPAND_MAXN+1)];
5353 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
5354   ovector, sizeof(ovector)/sizeof(int));
5355 BOOL yield = n >= 0;
5356 if (n == 0) n = EXPAND_MAXN + 1;
5357 if (yield)
5358   {
5359   int nn;
5360   expand_nmax = (setup < 0)? 0 : setup + 1;
5361   for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
5362     {
5363     expand_nstring[expand_nmax] = subject + ovector[nn];
5364     expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5365     }
5366   expand_nmax--;
5367   }
5368 return yield;
5369 }
5370
5371
5372 int main(int argc, uschar **argv)
5373 {
5374 int i;
5375 uschar buffer[1024];
5376
5377 debug_selector = D_v;
5378 debug_file = stderr;
5379 debug_fd = fileno(debug_file);
5380 big_buffer = malloc(big_buffer_size);
5381
5382 for (i = 1; i < argc; i++)
5383   {
5384   if (argv[i][0] == '+')
5385     {
5386     debug_trace_memory = 2;
5387     argv[i]++;
5388     }
5389   if (isdigit(argv[i][0]))
5390     debug_selector = Ustrtol(argv[i], NULL, 0);
5391   else
5392     if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
5393         Ustrlen(argv[i]))
5394       {
5395       #ifdef LOOKUP_LDAP
5396       eldap_default_servers = argv[i];
5397       #endif
5398       #ifdef LOOKUP_MYSQL
5399       mysql_servers = argv[i];
5400       #endif
5401       #ifdef LOOKUP_PGSQL
5402       pgsql_servers = argv[i];
5403       #endif
5404       }
5405   #ifdef EXIM_PERL
5406   else opt_perl_startup = argv[i];
5407   #endif
5408   }
5409
5410 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
5411
5412 expand_nstring[1] = US"string 1....";
5413 expand_nlength[1] = 8;
5414 expand_nmax = 1;
5415
5416 #ifdef EXIM_PERL
5417 if (opt_perl_startup != NULL)
5418   {
5419   uschar *errstr;
5420   printf("Starting Perl interpreter\n");
5421   errstr = init_perl(opt_perl_startup);
5422   if (errstr != NULL)
5423     {
5424     printf("** error in perl_startup code: %s\n", errstr);
5425     return EXIT_FAILURE;
5426     }
5427   }
5428 #endif /* EXIM_PERL */
5429
5430 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
5431   {
5432   void *reset_point = store_get(0);
5433   uschar *yield = expand_string(buffer);
5434   if (yield != NULL)
5435     {
5436     printf("%s\n", yield);
5437     store_reset(reset_point);
5438     }
5439   else
5440     {
5441     if (search_find_defer) printf("search_find deferred\n");
5442     printf("Failed: %s\n", expand_string_message);
5443     if (expand_string_forcedfail) printf("Forced failure\n");
5444     printf("\n");
5445     }
5446   }
5447
5448 search_tidyup();
5449
5450 return 0;
5451 }
5452
5453 #endif
5454
5455 /* End of expand.c */