src/src/expand.c

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