1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
9 /* Functions for handling string expansion. */
14 /* Recursively called function */
16 static uschar *expand_string_internal(const uschar *, BOOL, const uschar **, BOOL, BOOL, BOOL *);
17 static int_eximarith_t expanded_string_integer(const uschar *, BOOL);
20 #ifndef SUPPORT_CRYPTEQ
21 #define SUPPORT_CRYPTEQ
26 #include "lookups/ldap.h"
29 #ifdef SUPPORT_CRYPTEQ
34 extern char* crypt16(char*, char*);
38 /* The handling of crypt16() is a mess. I will record below the analysis of the
39 mess that was sent to me. We decided, however, to make changing this very low
40 priority, because in practice people are moving away from the crypt()
41 algorithms nowadays, so it doesn't seem worth it.
44 There is an algorithm named "crypt16" in Ultrix and Tru64. It crypts
45 the first 8 characters of the password using a 20-round version of crypt
46 (standard crypt does 25 rounds). It then crypts the next 8 characters,
47 or an empty block if the password is less than 9 characters, using a
48 20-round version of crypt and the same salt as was used for the first
49 block. Charaters after the first 16 are ignored. It always generates
50 a 16-byte hash, which is expressed together with the salt as a string
51 of 24 base 64 digits. Here are some links to peruse:
53 http://cvs.pld.org.pl/pam/pamcrypt/crypt16.c?rev=1.2
54 http://seclists.org/bugtraq/1999/Mar/0076.html
56 There's a different algorithm named "bigcrypt" in HP-UX, Digital Unix,
57 and OSF/1. This is the same as the standard crypt if given a password
58 of 8 characters or less. If given more, it first does the same as crypt
59 using the first 8 characters, then crypts the next 8 (the 9th to 16th)
60 using as salt the first two base 64 digits from the first hash block.
61 If the password is more than 16 characters then it crypts the 17th to 24th
62 characters using as salt the first two base 64 digits from the second hash
63 block. And so on: I've seen references to it cutting off the password at
64 40 characters (5 blocks), 80 (10 blocks), or 128 (16 blocks). Some links:
66 http://cvs.pld.org.pl/pam/pamcrypt/bigcrypt.c?rev=1.2
67 http://seclists.org/bugtraq/1999/Mar/0109.html
68 http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/HTML/AA-Q0R2D-
69 TET1_html/sec.c222.html#no_id_208
71 Exim has something it calls "crypt16". It will either use a native
72 crypt16 or its own implementation. A native crypt16 will presumably
73 be the one that I called "crypt16" above. The internal "crypt16"
74 function, however, is a two-block-maximum implementation of what I called
75 "bigcrypt". The documentation matches the internal code.
77 I suspect that whoever did the "crypt16" stuff for Exim didn't realise
78 that crypt16 and bigcrypt were different things.
80 Exim uses the LDAP-style scheme identifier "{crypt16}" to refer
81 to whatever it is using under that name. This unfortunately sets a
82 precedent for using "{crypt16}" to identify two incompatible algorithms
83 whose output can't be distinguished. With "{crypt16}" thus rendered
84 ambiguous, I suggest you deprecate it and invent two new identifiers
85 for the two algorithms.
87 Both crypt16 and bigcrypt are very poor algorithms, btw. Hashing parts
88 of the password separately means they can be cracked separately, so
89 the double-length hash only doubles the cracking effort instead of
90 squaring it. I recommend salted SHA-1 ({SSHA}), or the Blowfish-based
97 /*************************************************
98 * Local statics and tables *
99 *************************************************/
101 /* Table of item names, and corresponding switch numbers. The names must be in
102 alphabetical order. */
104 static uschar *item_table[] = {
164 /* Tables of operator names, and corresponding switch numbers. The names must be
165 in alphabetical order. There are two tables, because underscore is used in some
166 cases to introduce arguments, whereas for other it is part of the name. This is
167 an historical mis-design. */
169 static uschar *op_table_underscore[] = {
172 US"quote_local_part",
177 ,US"utf8_domain_from_alabel",
178 US"utf8_domain_to_alabel",
179 US"utf8_localpart_from_alabel",
180 US"utf8_localpart_to_alabel"
187 EOP_QUOTE_LOCAL_PART,
192 ,EOP_UTF8_DOMAIN_FROM_ALABEL,
193 EOP_UTF8_DOMAIN_TO_ALABEL,
194 EOP_UTF8_LOCALPART_FROM_ALABEL,
195 EOP_UTF8_LOCALPART_TO_ALABEL
199 static uschar *op_table_main[] = {
242 EOP_ADDRESS = nelem(op_table_underscore),
284 /* Table of condition names, and corresponding switch numbers. The names must
285 be in alphabetical order. */
287 static uschar *cond_table[] = {
291 US"==", /* Backward compatibility */
324 US"match_local_part",
349 ECOND_FIRST_DELIVERY,
370 ECOND_MATCH_LOCAL_PART,
380 /* Types of table entry */
383 vtype_int, /* value is address of int */
384 vtype_filter_int, /* ditto, but recognized only when filtering */
385 vtype_ino, /* value is address of ino_t (not always an int) */
386 vtype_uid, /* value is address of uid_t (not always an int) */
387 vtype_gid, /* value is address of gid_t (not always an int) */
388 vtype_bool, /* value is address of bool */
389 vtype_stringptr, /* value is address of pointer to string */
390 vtype_msgbody, /* as stringptr, but read when first required */
391 vtype_msgbody_end, /* ditto, the end of the message */
392 vtype_msgheaders, /* the message's headers, processed */
393 vtype_msgheaders_raw, /* the message's headers, unprocessed */
394 vtype_localpart, /* extract local part from string */
395 vtype_domain, /* extract domain from string */
396 vtype_string_func, /* value is string returned by given function */
397 vtype_todbsdin, /* value not used; generate BSD inbox tod */
398 vtype_tode, /* value not used; generate tod in epoch format */
399 vtype_todel, /* value not used; generate tod in epoch/usec format */
400 vtype_todf, /* value not used; generate full tod */
401 vtype_todl, /* value not used; generate log tod */
402 vtype_todlf, /* value not used; generate log file datestamp tod */
403 vtype_todzone, /* value not used; generate time zone only */
404 vtype_todzulu, /* value not used; generate zulu tod */
405 vtype_reply, /* value not used; get reply from headers */
406 vtype_pid, /* value not used; result is pid */
407 vtype_host_lookup, /* value not used; get host name */
408 vtype_load_avg, /* value not used; result is int from os_getloadavg */
409 vtype_pspace, /* partition space; value is T/F for spool/log */
410 vtype_pinodes, /* partition inodes; value is T/F for spool/log */
411 vtype_cert /* SSL certificate */
413 ,vtype_dkim /* Lookup of value in DKIM signature */
417 /* Type for main variable table */
425 /* Type for entries pointing to address/length pairs. Not currently
433 static uschar * fn_recipients(void);
435 /* This table must be kept in alphabetical order. */
437 static var_entry var_table[] = {
438 /* WARNING: Do not invent variables whose names start acl_c or acl_m because
439 they will be confused with user-creatable ACL variables. */
440 { "acl_arg1", vtype_stringptr, &acl_arg[0] },
441 { "acl_arg2", vtype_stringptr, &acl_arg[1] },
442 { "acl_arg3", vtype_stringptr, &acl_arg[2] },
443 { "acl_arg4", vtype_stringptr, &acl_arg[3] },
444 { "acl_arg5", vtype_stringptr, &acl_arg[4] },
445 { "acl_arg6", vtype_stringptr, &acl_arg[5] },
446 { "acl_arg7", vtype_stringptr, &acl_arg[6] },
447 { "acl_arg8", vtype_stringptr, &acl_arg[7] },
448 { "acl_arg9", vtype_stringptr, &acl_arg[8] },
449 { "acl_narg", vtype_int, &acl_narg },
450 { "acl_verify_message", vtype_stringptr, &acl_verify_message },
451 { "address_data", vtype_stringptr, &deliver_address_data },
452 { "address_file", vtype_stringptr, &address_file },
453 { "address_pipe", vtype_stringptr, &address_pipe },
454 { "authenticated_fail_id",vtype_stringptr, &authenticated_fail_id },
455 { "authenticated_id", vtype_stringptr, &authenticated_id },
456 { "authenticated_sender",vtype_stringptr, &authenticated_sender },
457 { "authentication_failed",vtype_int, &authentication_failed },
458 #ifdef WITH_CONTENT_SCAN
459 { "av_failed", vtype_int, &av_failed },
461 #ifdef EXPERIMENTAL_BRIGHTMAIL
462 { "bmi_alt_location", vtype_stringptr, &bmi_alt_location },
463 { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
464 { "bmi_base64_verdict", vtype_stringptr, &bmi_base64_verdict },
465 { "bmi_deliver", vtype_int, &bmi_deliver },
467 { "body_linecount", vtype_int, &body_linecount },
468 { "body_zerocount", vtype_int, &body_zerocount },
469 { "bounce_recipient", vtype_stringptr, &bounce_recipient },
470 { "bounce_return_size_limit", vtype_int, &bounce_return_size_limit },
471 { "caller_gid", vtype_gid, &real_gid },
472 { "caller_uid", vtype_uid, &real_uid },
473 { "callout_address", vtype_stringptr, &callout_address },
474 { "compile_date", vtype_stringptr, &version_date },
475 { "compile_number", vtype_stringptr, &version_cnumber },
476 { "config_dir", vtype_stringptr, &config_main_directory },
477 { "config_file", vtype_stringptr, &config_main_filename },
478 { "csa_status", vtype_stringptr, &csa_status },
479 #ifdef EXPERIMENTAL_DCC
480 { "dcc_header", vtype_stringptr, &dcc_header },
481 { "dcc_result", vtype_stringptr, &dcc_result },
483 #ifdef WITH_OLD_DEMIME
484 { "demime_errorlevel", vtype_int, &demime_errorlevel },
485 { "demime_reason", vtype_stringptr, &demime_reason },
488 { "dkim_algo", vtype_dkim, (void *)DKIM_ALGO },
489 { "dkim_bodylength", vtype_dkim, (void *)DKIM_BODYLENGTH },
490 { "dkim_canon_body", vtype_dkim, (void *)DKIM_CANON_BODY },
491 { "dkim_canon_headers", vtype_dkim, (void *)DKIM_CANON_HEADERS },
492 { "dkim_copiedheaders", vtype_dkim, (void *)DKIM_COPIEDHEADERS },
493 { "dkim_created", vtype_dkim, (void *)DKIM_CREATED },
494 { "dkim_cur_signer", vtype_stringptr, &dkim_cur_signer },
495 { "dkim_domain", vtype_stringptr, &dkim_signing_domain },
496 { "dkim_expires", vtype_dkim, (void *)DKIM_EXPIRES },
497 { "dkim_headernames", vtype_dkim, (void *)DKIM_HEADERNAMES },
498 { "dkim_identity", vtype_dkim, (void *)DKIM_IDENTITY },
499 { "dkim_key_granularity",vtype_dkim, (void *)DKIM_KEY_GRANULARITY },
500 { "dkim_key_length", vtype_int, &dkim_key_length },
501 { "dkim_key_nosubdomains",vtype_dkim, (void *)DKIM_NOSUBDOMAINS },
502 { "dkim_key_notes", vtype_dkim, (void *)DKIM_KEY_NOTES },
503 { "dkim_key_srvtype", vtype_dkim, (void *)DKIM_KEY_SRVTYPE },
504 { "dkim_key_testing", vtype_dkim, (void *)DKIM_KEY_TESTING },
505 { "dkim_selector", vtype_stringptr, &dkim_signing_selector },
506 { "dkim_signers", vtype_stringptr, &dkim_signers },
507 { "dkim_verify_reason", vtype_dkim, (void *)DKIM_VERIFY_REASON },
508 { "dkim_verify_status", vtype_dkim, (void *)DKIM_VERIFY_STATUS},
510 #ifdef EXPERIMENTAL_DMARC
511 { "dmarc_ar_header", vtype_stringptr, &dmarc_ar_header },
512 { "dmarc_domain_policy", vtype_stringptr, &dmarc_domain_policy },
513 { "dmarc_status", vtype_stringptr, &dmarc_status },
514 { "dmarc_status_text", vtype_stringptr, &dmarc_status_text },
515 { "dmarc_used_domain", vtype_stringptr, &dmarc_used_domain },
517 { "dnslist_domain", vtype_stringptr, &dnslist_domain },
518 { "dnslist_matched", vtype_stringptr, &dnslist_matched },
519 { "dnslist_text", vtype_stringptr, &dnslist_text },
520 { "dnslist_value", vtype_stringptr, &dnslist_value },
521 { "domain", vtype_stringptr, &deliver_domain },
522 { "domain_data", vtype_stringptr, &deliver_domain_data },
523 #ifndef DISABLE_EVENT
524 { "event_data", vtype_stringptr, &event_data },
526 /*XXX want to use generic vars for as many of these as possible*/
527 { "event_defer_errno", vtype_int, &event_defer_errno },
529 { "event_name", vtype_stringptr, &event_name },
531 { "exim_gid", vtype_gid, &exim_gid },
532 { "exim_path", vtype_stringptr, &exim_path },
533 { "exim_uid", vtype_uid, &exim_uid },
534 { "exim_version", vtype_stringptr, &version_string },
535 #ifdef WITH_OLD_DEMIME
536 { "found_extension", vtype_stringptr, &found_extension },
538 { "headers_added", vtype_string_func, &fn_hdrs_added },
539 { "home", vtype_stringptr, &deliver_home },
540 { "host", vtype_stringptr, &deliver_host },
541 { "host_address", vtype_stringptr, &deliver_host_address },
542 { "host_data", vtype_stringptr, &host_data },
543 { "host_lookup_deferred",vtype_int, &host_lookup_deferred },
544 { "host_lookup_failed", vtype_int, &host_lookup_failed },
545 { "host_port", vtype_int, &deliver_host_port },
546 { "inode", vtype_ino, &deliver_inode },
547 { "interface_address", vtype_stringptr, &interface_address },
548 { "interface_port", vtype_int, &interface_port },
549 { "item", vtype_stringptr, &iterate_item },
551 { "ldap_dn", vtype_stringptr, &eldap_dn },
553 { "load_average", vtype_load_avg, NULL },
554 { "local_part", vtype_stringptr, &deliver_localpart },
555 { "local_part_data", vtype_stringptr, &deliver_localpart_data },
556 { "local_part_prefix", vtype_stringptr, &deliver_localpart_prefix },
557 { "local_part_suffix", vtype_stringptr, &deliver_localpart_suffix },
558 { "local_scan_data", vtype_stringptr, &local_scan_data },
559 { "local_user_gid", vtype_gid, &local_user_gid },
560 { "local_user_uid", vtype_uid, &local_user_uid },
561 { "localhost_number", vtype_int, &host_number },
562 { "log_inodes", vtype_pinodes, (void *)FALSE },
563 { "log_space", vtype_pspace, (void *)FALSE },
564 { "lookup_dnssec_authenticated",vtype_stringptr,&lookup_dnssec_authenticated},
565 { "mailstore_basename", vtype_stringptr, &mailstore_basename },
566 #ifdef WITH_CONTENT_SCAN
567 { "malware_name", vtype_stringptr, &malware_name },
569 { "max_received_linelength", vtype_int, &max_received_linelength },
570 { "message_age", vtype_int, &message_age },
571 { "message_body", vtype_msgbody, &message_body },
572 { "message_body_end", vtype_msgbody_end, &message_body_end },
573 { "message_body_size", vtype_int, &message_body_size },
574 { "message_exim_id", vtype_stringptr, &message_id },
575 { "message_headers", vtype_msgheaders, NULL },
576 { "message_headers_raw", vtype_msgheaders_raw, NULL },
577 { "message_id", vtype_stringptr, &message_id },
578 { "message_linecount", vtype_int, &message_linecount },
579 { "message_size", vtype_int, &message_size },
581 { "message_smtputf8", vtype_bool, &message_smtputf8 },
583 #ifdef WITH_CONTENT_SCAN
584 { "mime_anomaly_level", vtype_int, &mime_anomaly_level },
585 { "mime_anomaly_text", vtype_stringptr, &mime_anomaly_text },
586 { "mime_boundary", vtype_stringptr, &mime_boundary },
587 { "mime_charset", vtype_stringptr, &mime_charset },
588 { "mime_content_description", vtype_stringptr, &mime_content_description },
589 { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
590 { "mime_content_id", vtype_stringptr, &mime_content_id },
591 { "mime_content_size", vtype_int, &mime_content_size },
592 { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
593 { "mime_content_type", vtype_stringptr, &mime_content_type },
594 { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
595 { "mime_filename", vtype_stringptr, &mime_filename },
596 { "mime_is_coverletter", vtype_int, &mime_is_coverletter },
597 { "mime_is_multipart", vtype_int, &mime_is_multipart },
598 { "mime_is_rfc822", vtype_int, &mime_is_rfc822 },
599 { "mime_part_count", vtype_int, &mime_part_count },
601 { "n0", vtype_filter_int, &filter_n[0] },
602 { "n1", vtype_filter_int, &filter_n[1] },
603 { "n2", vtype_filter_int, &filter_n[2] },
604 { "n3", vtype_filter_int, &filter_n[3] },
605 { "n4", vtype_filter_int, &filter_n[4] },
606 { "n5", vtype_filter_int, &filter_n[5] },
607 { "n6", vtype_filter_int, &filter_n[6] },
608 { "n7", vtype_filter_int, &filter_n[7] },
609 { "n8", vtype_filter_int, &filter_n[8] },
610 { "n9", vtype_filter_int, &filter_n[9] },
611 { "original_domain", vtype_stringptr, &deliver_domain_orig },
612 { "original_local_part", vtype_stringptr, &deliver_localpart_orig },
613 { "originator_gid", vtype_gid, &originator_gid },
614 { "originator_uid", vtype_uid, &originator_uid },
615 { "parent_domain", vtype_stringptr, &deliver_domain_parent },
616 { "parent_local_part", vtype_stringptr, &deliver_localpart_parent },
617 { "pid", vtype_pid, NULL },
619 { "prdr_requested", vtype_bool, &prdr_requested },
621 { "primary_hostname", vtype_stringptr, &primary_hostname },
622 #if defined(SUPPORT_PROXY) || defined(SUPPORT_SOCKS)
623 { "proxy_external_address",vtype_stringptr, &proxy_external_address },
624 { "proxy_external_port", vtype_int, &proxy_external_port },
625 { "proxy_local_address", vtype_stringptr, &proxy_local_address },
626 { "proxy_local_port", vtype_int, &proxy_local_port },
627 { "proxy_session", vtype_bool, &proxy_session },
629 { "prvscheck_address", vtype_stringptr, &prvscheck_address },
630 { "prvscheck_keynum", vtype_stringptr, &prvscheck_keynum },
631 { "prvscheck_result", vtype_stringptr, &prvscheck_result },
632 { "qualify_domain", vtype_stringptr, &qualify_domain_sender },
633 { "qualify_recipient", vtype_stringptr, &qualify_domain_recipient },
634 { "rcpt_count", vtype_int, &rcpt_count },
635 { "rcpt_defer_count", vtype_int, &rcpt_defer_count },
636 { "rcpt_fail_count", vtype_int, &rcpt_fail_count },
637 { "received_count", vtype_int, &received_count },
638 { "received_for", vtype_stringptr, &received_for },
639 { "received_ip_address", vtype_stringptr, &interface_address },
640 { "received_port", vtype_int, &interface_port },
641 { "received_protocol", vtype_stringptr, &received_protocol },
642 { "received_time", vtype_int, &received_time },
643 { "recipient_data", vtype_stringptr, &recipient_data },
644 { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
645 { "recipients", vtype_string_func, &fn_recipients },
646 { "recipients_count", vtype_int, &recipients_count },
647 #ifdef WITH_CONTENT_SCAN
648 { "regex_match_string", vtype_stringptr, ®ex_match_string },
650 { "reply_address", vtype_reply, NULL },
651 { "return_path", vtype_stringptr, &return_path },
652 { "return_size_limit", vtype_int, &bounce_return_size_limit },
653 { "router_name", vtype_stringptr, &router_name },
654 { "runrc", vtype_int, &runrc },
655 { "self_hostname", vtype_stringptr, &self_hostname },
656 { "sender_address", vtype_stringptr, &sender_address },
657 { "sender_address_data", vtype_stringptr, &sender_address_data },
658 { "sender_address_domain", vtype_domain, &sender_address },
659 { "sender_address_local_part", vtype_localpart, &sender_address },
660 { "sender_data", vtype_stringptr, &sender_data },
661 { "sender_fullhost", vtype_stringptr, &sender_fullhost },
662 { "sender_helo_dnssec", vtype_bool, &sender_helo_dnssec },
663 { "sender_helo_name", vtype_stringptr, &sender_helo_name },
664 { "sender_host_address", vtype_stringptr, &sender_host_address },
665 { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
666 { "sender_host_dnssec", vtype_bool, &sender_host_dnssec },
667 { "sender_host_name", vtype_host_lookup, NULL },
668 { "sender_host_port", vtype_int, &sender_host_port },
669 { "sender_ident", vtype_stringptr, &sender_ident },
670 { "sender_rate", vtype_stringptr, &sender_rate },
671 { "sender_rate_limit", vtype_stringptr, &sender_rate_limit },
672 { "sender_rate_period", vtype_stringptr, &sender_rate_period },
673 { "sender_rcvhost", vtype_stringptr, &sender_rcvhost },
674 { "sender_verify_failure",vtype_stringptr, &sender_verify_failure },
675 { "sending_ip_address", vtype_stringptr, &sending_ip_address },
676 { "sending_port", vtype_int, &sending_port },
677 { "smtp_active_hostname", vtype_stringptr, &smtp_active_hostname },
678 { "smtp_command", vtype_stringptr, &smtp_cmd_buffer },
679 { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
680 { "smtp_count_at_connection_start", vtype_int, &smtp_accept_count },
681 { "smtp_notquit_reason", vtype_stringptr, &smtp_notquit_reason },
682 { "sn0", vtype_filter_int, &filter_sn[0] },
683 { "sn1", vtype_filter_int, &filter_sn[1] },
684 { "sn2", vtype_filter_int, &filter_sn[2] },
685 { "sn3", vtype_filter_int, &filter_sn[3] },
686 { "sn4", vtype_filter_int, &filter_sn[4] },
687 { "sn5", vtype_filter_int, &filter_sn[5] },
688 { "sn6", vtype_filter_int, &filter_sn[6] },
689 { "sn7", vtype_filter_int, &filter_sn[7] },
690 { "sn8", vtype_filter_int, &filter_sn[8] },
691 { "sn9", vtype_filter_int, &filter_sn[9] },
692 #ifdef WITH_CONTENT_SCAN
693 { "spam_action", vtype_stringptr, &spam_action },
694 { "spam_bar", vtype_stringptr, &spam_bar },
695 { "spam_report", vtype_stringptr, &spam_report },
696 { "spam_score", vtype_stringptr, &spam_score },
697 { "spam_score_int", vtype_stringptr, &spam_score_int },
699 #ifdef EXPERIMENTAL_SPF
700 { "spf_guess", vtype_stringptr, &spf_guess },
701 { "spf_header_comment", vtype_stringptr, &spf_header_comment },
702 { "spf_received", vtype_stringptr, &spf_received },
703 { "spf_result", vtype_stringptr, &spf_result },
704 { "spf_smtp_comment", vtype_stringptr, &spf_smtp_comment },
706 { "spool_directory", vtype_stringptr, &spool_directory },
707 { "spool_inodes", vtype_pinodes, (void *)TRUE },
708 { "spool_space", vtype_pspace, (void *)TRUE },
709 #ifdef EXPERIMENTAL_SRS
710 { "srs_db_address", vtype_stringptr, &srs_db_address },
711 { "srs_db_key", vtype_stringptr, &srs_db_key },
712 { "srs_orig_recipient", vtype_stringptr, &srs_orig_recipient },
713 { "srs_orig_sender", vtype_stringptr, &srs_orig_sender },
714 { "srs_recipient", vtype_stringptr, &srs_recipient },
715 { "srs_status", vtype_stringptr, &srs_status },
717 { "thisaddress", vtype_stringptr, &filter_thisaddress },
719 /* The non-(in,out) variables are now deprecated */
720 { "tls_bits", vtype_int, &tls_in.bits },
721 { "tls_certificate_verified", vtype_int, &tls_in.certificate_verified },
722 { "tls_cipher", vtype_stringptr, &tls_in.cipher },
724 { "tls_in_bits", vtype_int, &tls_in.bits },
725 { "tls_in_certificate_verified", vtype_int, &tls_in.certificate_verified },
726 { "tls_in_cipher", vtype_stringptr, &tls_in.cipher },
727 { "tls_in_ocsp", vtype_int, &tls_in.ocsp },
728 { "tls_in_ourcert", vtype_cert, &tls_in.ourcert },
729 { "tls_in_peercert", vtype_cert, &tls_in.peercert },
730 { "tls_in_peerdn", vtype_stringptr, &tls_in.peerdn },
731 #if defined(SUPPORT_TLS)
732 { "tls_in_sni", vtype_stringptr, &tls_in.sni },
734 { "tls_out_bits", vtype_int, &tls_out.bits },
735 { "tls_out_certificate_verified", vtype_int,&tls_out.certificate_verified },
736 { "tls_out_cipher", vtype_stringptr, &tls_out.cipher },
737 #ifdef EXPERIMENTAL_DANE
738 { "tls_out_dane", vtype_bool, &tls_out.dane_verified },
740 { "tls_out_ocsp", vtype_int, &tls_out.ocsp },
741 { "tls_out_ourcert", vtype_cert, &tls_out.ourcert },
742 { "tls_out_peercert", vtype_cert, &tls_out.peercert },
743 { "tls_out_peerdn", vtype_stringptr, &tls_out.peerdn },
744 #if defined(SUPPORT_TLS)
745 { "tls_out_sni", vtype_stringptr, &tls_out.sni },
747 #ifdef EXPERIMENTAL_DANE
748 { "tls_out_tlsa_usage", vtype_int, &tls_out.tlsa_usage },
751 { "tls_peerdn", vtype_stringptr, &tls_in.peerdn }, /* mind the alphabetical order! */
752 #if defined(SUPPORT_TLS)
753 { "tls_sni", vtype_stringptr, &tls_in.sni }, /* mind the alphabetical order! */
756 { "tod_bsdinbox", vtype_todbsdin, NULL },
757 { "tod_epoch", vtype_tode, NULL },
758 { "tod_epoch_l", vtype_todel, NULL },
759 { "tod_full", vtype_todf, NULL },
760 { "tod_log", vtype_todl, NULL },
761 { "tod_logfile", vtype_todlf, NULL },
762 { "tod_zone", vtype_todzone, NULL },
763 { "tod_zulu", vtype_todzulu, NULL },
764 { "transport_name", vtype_stringptr, &transport_name },
765 { "value", vtype_stringptr, &lookup_value },
766 { "verify_mode", vtype_stringptr, &verify_mode },
767 { "version_number", vtype_stringptr, &version_string },
768 { "warn_message_delay", vtype_stringptr, &warnmsg_delay },
769 { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
770 { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
771 { "warnmsg_delay", vtype_stringptr, &warnmsg_delay },
772 { "warnmsg_recipient", vtype_stringptr, &warnmsg_recipients },
773 { "warnmsg_recipients", vtype_stringptr, &warnmsg_recipients }
776 static int var_table_size = nelem(var_table);
777 static uschar var_buffer[256];
778 static BOOL malformed_header;
780 /* For textual hashes */
782 static const char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
783 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
786 enum { HMAC_MD5, HMAC_SHA1 };
788 /* For numeric hashes */
790 static unsigned int prime[] = {
791 2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
792 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
793 73, 79, 83, 89, 97, 101, 103, 107, 109, 113};
795 /* For printing modes in symbolic form */
797 static uschar *mtable_normal[] =
798 { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
800 static uschar *mtable_setid[] =
801 { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
803 static uschar *mtable_sticky[] =
804 { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
808 /*************************************************
809 * Tables for UTF-8 support *
810 *************************************************/
812 /* Table of the number of extra characters, indexed by the first character
813 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
816 static uschar utf8_table1[] = {
817 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
818 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
819 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
820 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
822 /* These are the masks for the data bits in the first byte of a character,
823 indexed by the number of additional bytes. */
825 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
827 /* Get the next UTF-8 character, advancing the pointer. */
829 #define GETUTF8INC(c, ptr) \
831 if ((c & 0xc0) == 0xc0) \
833 int a = utf8_table1[c & 0x3f]; /* Number of additional bytes */ \
835 c = (c & utf8_table2[a]) << s; \
839 c |= (*ptr++ & 0x3f) << s; \
844 /*************************************************
845 * Binary chop search on a table *
846 *************************************************/
848 /* This is used for matching expansion items and operators.
851 name the name that is being sought
852 table the table to search
853 table_size the number of items in the table
855 Returns: the offset in the table, or -1
859 chop_match(uschar *name, uschar **table, int table_size)
861 uschar **bot = table;
862 uschar **top = table + table_size;
866 uschar **mid = bot + (top - bot)/2;
867 int c = Ustrcmp(name, *mid);
868 if (c == 0) return mid - table;
869 if (c > 0) bot = mid + 1; else top = mid;
877 /*************************************************
878 * Check a condition string *
879 *************************************************/
881 /* This function is called to expand a string, and test the result for a "true"
882 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
883 forced fail or lookup defer.
885 We used to release all store used, but this is not not safe due
886 to ${dlfunc } and ${acl }. In any case expand_string_internal()
887 is reasonably careful to release what it can.
889 The actual false-value tests should be replicated for ECOND_BOOL_LAX.
892 condition the condition string
893 m1 text to be incorporated in panic error
896 Returns: TRUE if condition is met, FALSE if not
900 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
903 uschar *ss = expand_string(condition);
906 if (!expand_string_forcedfail && !search_find_defer)
907 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
908 "for %s %s: %s", condition, m1, m2, expand_string_message);
911 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
912 strcmpic(ss, US"false") != 0;
919 /*************************************************
920 * Pseudo-random number generation *
921 *************************************************/
923 /* Pseudo-random number generation. The result is not "expected" to be
924 cryptographically strong but not so weak that someone will shoot themselves
925 in the foot using it as a nonce in some email header scheme or whatever
926 weirdness they'll twist this into. The result should ideally handle fork().
928 However, if we're stuck unable to provide this, then we'll fall back to
929 appallingly bad randomness.
931 If SUPPORT_TLS is defined then this will not be used except as an emergency
936 Returns a random number in range [0, max-1]
940 # define vaguely_random_number vaguely_random_number_fallback
943 vaguely_random_number(int max)
946 # undef vaguely_random_number
948 static pid_t pid = 0;
950 #if defined(HAVE_SRANDOM) && !defined(HAVE_SRANDOMDEV)
960 #ifdef HAVE_ARC4RANDOM
961 /* cryptographically strong randomness, common on *BSD platforms, not
962 so much elsewhere. Alas. */
963 #ifndef NOT_HAVE_ARC4RANDOM_STIR
966 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
967 #ifdef HAVE_SRANDOMDEV
968 /* uses random(4) for seeding */
971 gettimeofday(&tv, NULL);
972 srandom(tv.tv_sec | tv.tv_usec | getpid());
975 /* Poor randomness and no seeding here */
982 #ifdef HAVE_ARC4RANDOM
983 return arc4random() % max;
984 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
985 return random() % max;
987 /* This one returns a 16-bit number, definitely not crypto-strong */
988 return random_number(max);
995 /*************************************************
996 * Pick out a name from a string *
997 *************************************************/
999 /* If the name is too long, it is silently truncated.
1002 name points to a buffer into which to put the name
1003 max is the length of the buffer
1004 s points to the first alphabetic character of the name
1005 extras chars other than alphanumerics to permit
1007 Returns: pointer to the first character after the name
1009 Note: The test for *s != 0 in the while loop is necessary because
1010 Ustrchr() yields non-NULL if the character is zero (which is not something
1013 static const uschar *
1014 read_name(uschar *name, int max, const uschar *s, uschar *extras)
1017 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
1019 if (ptr < max-1) name[ptr++] = *s;
1028 /*************************************************
1029 * Pick out the rest of a header name *
1030 *************************************************/
1032 /* A variable name starting $header_ (or just $h_ for those who like
1033 abbreviations) might not be the complete header name because headers can
1034 contain any printing characters in their names, except ':'. This function is
1035 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
1036 on the end, if the name was terminated by white space.
1039 name points to a buffer in which the name read so far exists
1040 max is the length of the buffer
1041 s points to the first character after the name so far, i.e. the
1042 first non-alphameric character after $header_xxxxx
1044 Returns: a pointer to the first character after the header name
1047 static const uschar *
1048 read_header_name(uschar *name, int max, const uschar *s)
1050 int prelen = Ustrchr(name, '_') - name + 1;
1051 int ptr = Ustrlen(name) - prelen;
1052 if (ptr > 0) memmove(name, name+prelen, ptr);
1053 while (mac_isgraph(*s) && *s != ':')
1055 if (ptr < max-1) name[ptr++] = *s;
1066 /*************************************************
1067 * Pick out a number from a string *
1068 *************************************************/
1071 n points to an integer into which to put the number
1072 s points to the first digit of the number
1074 Returns: a pointer to the character after the last digit
1078 read_number(int *n, uschar *s)
1081 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1085 static const uschar *
1086 read_cnumber(int *n, const uschar *s)
1089 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1095 /*************************************************
1096 * Extract keyed subfield from a string *
1097 *************************************************/
1099 /* The yield is in dynamic store; NULL means that the key was not found.
1102 key points to the name of the key
1103 s points to the string from which to extract the subfield
1105 Returns: NULL if the subfield was not found, or
1106 a pointer to the subfield's data
1110 expand_getkeyed(uschar *key, const uschar *s)
1112 int length = Ustrlen(key);
1113 while (isspace(*s)) s++;
1115 /* Loop to search for the key */
1121 const uschar *dkey = s;
1123 while (*s != 0 && *s != '=' && !isspace(*s)) s++;
1124 dkeylength = s - dkey;
1125 while (isspace(*s)) s++;
1126 if (*s == '=') while (isspace((*(++s))));
1128 data = string_dequote(&s);
1129 if (length == dkeylength && strncmpic(key, dkey, length) == 0)
1132 while (isspace(*s)) s++;
1141 find_var_ent(uschar * name)
1144 int last = var_table_size;
1146 while (last > first)
1148 int middle = (first + last)/2;
1149 int c = Ustrcmp(name, var_table[middle].name);
1151 if (c > 0) { first = middle + 1; continue; }
1152 if (c < 0) { last = middle; continue; }
1153 return &var_table[middle];
1158 /*************************************************
1159 * Extract numbered subfield from string *
1160 *************************************************/
1162 /* Extracts a numbered field from a string that is divided by tokens - for
1163 example a line from /etc/passwd is divided by colon characters. First field is
1164 numbered one. Negative arguments count from the right. Zero returns the whole
1165 string. Returns NULL if there are insufficient tokens in the string
1168 Modifies final argument - this is a dynamically generated string, so that's OK.
1171 field number of field to be extracted,
1172 first field = 1, whole string = 0, last field = -1
1173 separators characters that are used to break string into tokens
1174 s points to the string from which to extract the subfield
1176 Returns: NULL if the field was not found,
1177 a pointer to the field's data inside s (modified to add 0)
1181 expand_gettokened (int field, uschar *separators, uschar *s)
1186 uschar *fieldtext = NULL;
1188 if (field == 0) return s;
1190 /* Break the line up into fields in place; for field > 0 we stop when we have
1191 done the number of fields we want. For field < 0 we continue till the end of
1192 the string, counting the number of fields. */
1194 count = (field > 0)? field : INT_MAX;
1200 /* Previous field was the last one in the string. For a positive field
1201 number, this means there are not enough fields. For a negative field number,
1202 check that there are enough, and scan back to find the one that is wanted. */
1206 if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
1207 if ((-field) == (INT_MAX - count - 1)) return s;
1211 while (ss[-1] != 0) ss--;
1217 /* Previous field was not last in the string; save its start and put a
1221 len = Ustrcspn(ss, separators);
1232 expand_getlistele(int field, const uschar * list)
1234 const uschar * tlist= list;
1240 for(field++; string_nextinlist(&tlist, &sep, &dummy, 1); ) field++;
1243 if(field==0) return NULL;
1244 while(--field>0 && (string_nextinlist(&list, &sep, &dummy, 1))) ;
1245 return string_nextinlist(&list, &sep, NULL, 0);
1249 /* Certificate fields, by name. Worry about by-OID later */
1250 /* Names are chosen to not have common prefixes */
1257 uschar * (*getfn)(void * cert, uschar * mod);
1259 static certfield certfields[] =
1260 { /* linear search; no special order */
1261 { US"version", 7, &tls_cert_version },
1262 { US"serial_number", 13, &tls_cert_serial_number },
1263 { US"subject", 7, &tls_cert_subject },
1264 { US"notbefore", 9, &tls_cert_not_before },
1265 { US"notafter", 8, &tls_cert_not_after },
1266 { US"issuer", 6, &tls_cert_issuer },
1267 { US"signature", 9, &tls_cert_signature },
1268 { US"sig_algorithm", 13, &tls_cert_signature_algorithm },
1269 { US"subj_altname", 12, &tls_cert_subject_altname },
1270 { US"ocsp_uri", 8, &tls_cert_ocsp_uri },
1271 { US"crl_uri", 7, &tls_cert_crl_uri },
1275 expand_getcertele(uschar * field, uschar * certvar)
1280 if (!(vp = find_var_ent(certvar)))
1282 expand_string_message =
1283 string_sprintf("no variable named \"%s\"", certvar);
1284 return NULL; /* Unknown variable name */
1286 /* NB this stops us passing certs around in variable. Might
1287 want to do that in future */
1288 if (vp->type != vtype_cert)
1290 expand_string_message =
1291 string_sprintf("\"%s\" is not a certificate", certvar);
1292 return NULL; /* Unknown variable name */
1294 if (!*(void **)vp->value)
1297 if (*field >= '0' && *field <= '9')
1298 return tls_cert_ext_by_oid(*(void **)vp->value, field, 0);
1300 for(cp = certfields;
1301 cp < certfields + nelem(certfields);
1303 if (Ustrncmp(cp->name, field, cp->namelen) == 0)
1305 uschar * modifier = *(field += cp->namelen) == ','
1307 return (*cp->getfn)( *(void **)vp->value, modifier );
1310 expand_string_message =
1311 string_sprintf("bad field selector \"%s\" for certextract", field);
1314 #endif /*SUPPORT_TLS*/
1316 /*************************************************
1317 * Extract a substring from a string *
1318 *************************************************/
1320 /* Perform the ${substr or ${length expansion operations.
1323 subject the input string
1324 value1 the offset from the start of the input string to the start of
1325 the output string; if negative, count from the right.
1326 value2 the length of the output string, or negative (-1) for unset
1327 if value1 is positive, unset means "all after"
1328 if value1 is negative, unset means "all before"
1329 len set to the length of the returned string
1331 Returns: pointer to the output string, or NULL if there is an error
1335 extract_substr(uschar *subject, int value1, int value2, int *len)
1337 int sublen = Ustrlen(subject);
1339 if (value1 < 0) /* count from right */
1343 /* If the position is before the start, skip to the start, and adjust the
1344 length. If the length ends up negative, the substring is null because nothing
1345 can precede. This falls out naturally when the length is unset, meaning "all
1351 if (value2 < 0) value2 = 0;
1355 /* Otherwise an unset length => characters before value1 */
1357 else if (value2 < 0)
1364 /* For a non-negative offset, if the starting position is past the end of the
1365 string, the result will be the null string. Otherwise, an unset length means
1366 "rest"; just set it to the maximum - it will be cut down below if necessary. */
1370 if (value1 > sublen)
1375 else if (value2 < 0) value2 = sublen;
1378 /* Cut the length down to the maximum possible for the offset value, and get
1379 the required characters. */
1381 if (value1 + value2 > sublen) value2 = sublen - value1;
1383 return subject + value1;
1389 /*************************************************
1390 * Old-style hash of a string *
1391 *************************************************/
1393 /* Perform the ${hash expansion operation.
1396 subject the input string (an expanded substring)
1397 value1 the length of the output string; if greater or equal to the
1398 length of the input string, the input string is returned
1399 value2 the number of hash characters to use, or 26 if negative
1400 len set to the length of the returned string
1402 Returns: pointer to the output string, or NULL if there is an error
1406 compute_hash(uschar *subject, int value1, int value2, int *len)
1408 int sublen = Ustrlen(subject);
1410 if (value2 < 0) value2 = 26;
1411 else if (value2 > Ustrlen(hashcodes))
1413 expand_string_message =
1414 string_sprintf("hash count \"%d\" too big", value2);
1418 /* Calculate the hash text. We know it is shorter than the original string, so
1419 can safely place it in subject[] (we know that subject is always itself an
1420 expanded substring). */
1422 if (value1 < sublen)
1427 while ((c = (subject[j])) != 0)
1429 int shift = (c + j++) & 7;
1430 subject[i] ^= (c << shift) | (c >> (8-shift));
1431 if (++i >= value1) i = 0;
1433 for (i = 0; i < value1; i++)
1434 subject[i] = hashcodes[(subject[i]) % value2];
1436 else value1 = sublen;
1445 /*************************************************
1446 * Numeric hash of a string *
1447 *************************************************/
1449 /* Perform the ${nhash expansion operation. The first characters of the
1450 string are treated as most important, and get the highest prime numbers.
1453 subject the input string
1454 value1 the maximum value of the first part of the result
1455 value2 the maximum value of the second part of the result,
1456 or negative to produce only a one-part result
1457 len set to the length of the returned string
1459 Returns: pointer to the output string, or NULL if there is an error.
1463 compute_nhash (uschar *subject, int value1, int value2, int *len)
1465 uschar *s = subject;
1467 unsigned long int total = 0; /* no overflow */
1471 if (i == 0) i = nelem(prime) - 1;
1472 total += prime[i--] * (unsigned int)(*s++);
1475 /* If value2 is unset, just compute one number */
1479 s = string_sprintf("%d", total % value1);
1482 /* Otherwise do a div/mod hash */
1486 total = total % (value1 * value2);
1487 s = string_sprintf("%d/%d", total/value2, total % value2);
1498 /*************************************************
1499 * Find the value of a header or headers *
1500 *************************************************/
1502 /* Multiple instances of the same header get concatenated, and this function
1503 can also return a concatenation of all the header lines. When concatenating
1504 specific headers that contain lists of addresses, a comma is inserted between
1505 them. Otherwise we use a straight concatenation. Because some messages can have
1506 pathologically large number of lines, there is a limit on the length that is
1507 returned. Also, to avoid massive store use which would result from using
1508 string_cat() as it copies and extends strings, we do a preliminary pass to find
1509 out exactly how much store will be needed. On "normal" messages this will be
1513 name the name of the header, without the leading $header_ or $h_,
1514 or NULL if a concatenation of all headers is required
1515 exists_only TRUE if called from a def: test; don't need to build a string;
1516 just return a string that is not "" and not "0" if the header
1518 newsize return the size of memory block that was obtained; may be NULL
1519 if exists_only is TRUE
1520 want_raw TRUE if called for $rh_ or $rheader_ variables; no processing,
1521 other than concatenating, will be done on the header. Also used
1522 for $message_headers_raw.
1523 charset name of charset to translate MIME words to; used only if
1524 want_raw is false; if NULL, no translation is done (this is
1525 used for $bh_ and $bheader_)
1527 Returns: NULL if the header does not exist, else a pointer to a new
1532 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1535 BOOL found = name == NULL;
1537 int len = found? 0 : Ustrlen(name);
1539 uschar *yield = NULL;
1542 /* Loop for two passes - saves code repetition */
1544 for (i = 0; i < 2; i++)
1549 for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1551 if (h->type != htype_old && h->text != NULL) /* NULL => Received: placeholder */
1553 if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1558 if (exists_only) return US"1"; /* don't need actual string */
1560 t = h->text + len; /* text to insert */
1561 if (!want_raw) /* unless wanted raw, */
1562 while (isspace(*t)) t++; /* remove leading white space */
1563 ilen = h->slen - (t - h->text); /* length to insert */
1565 /* Unless wanted raw, remove trailing whitespace, including the
1569 while (ilen > 0 && isspace(t[ilen-1])) ilen--;
1571 /* Set comma = 1 if handling a single header and it's one of those
1572 that contains an address list, except when asked for raw headers. Only
1573 need to do this once. */
1575 if (!want_raw && name != NULL && comma == 0 &&
1576 Ustrchr("BCFRST", h->type) != NULL)
1579 /* First pass - compute total store needed; second pass - compute
1580 total store used, including this header. */
1582 size += ilen + comma + 1; /* +1 for the newline */
1584 /* Second pass - concatentate the data, up to a maximum. Note that
1585 the loop stops when size hits the limit. */
1589 if (size > header_insert_maxlen)
1591 ilen -= size - header_insert_maxlen - 1;
1594 Ustrncpy(ptr, t, ilen);
1597 /* For a non-raw header, put in the comma if needed, then add
1598 back the newline we removed above, provided there was some text in
1601 if (!want_raw && ilen > 0)
1603 if (comma != 0) *ptr++ = ',';
1611 /* At end of first pass, return NULL if no header found. Then truncate size
1612 if necessary, and get the buffer to hold the data, returning the buffer size.
1617 if (!found) return NULL;
1618 if (size > header_insert_maxlen) size = header_insert_maxlen;
1619 *newsize = size + 1;
1620 ptr = yield = store_get(*newsize);
1624 /* That's all we do for raw header expansion. */
1631 /* Otherwise, remove a final newline and a redundant added comma. Then we do
1632 RFC 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1633 function can return an error with decoded data if the charset translation
1634 fails. If decoding fails, it returns NULL. */
1638 uschar *decoded, *error;
1639 if (ptr > yield && ptr[-1] == '\n') ptr--;
1640 if (ptr > yield && comma != 0 && ptr[-1] == ',') ptr--;
1642 decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1646 DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1647 " input was: %s\n", error, yield);
1649 if (decoded != NULL) yield = decoded;
1658 /*************************************************
1659 * Return list of recipients *
1660 *************************************************/
1661 /* A recipients list is available only during system message filtering,
1662 during ACL processing after DATA, and while expanding pipe commands
1663 generated from a system filter, but not elsewhere. */
1668 if (!enable_dollar_recipients) return NULL; else
1673 uschar * s = store_get(size);
1674 for (i = 0; i < recipients_count; i++)
1676 if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1677 s = string_cat(s, &size, &ptr, recipients_list[i].address,
1678 Ustrlen(recipients_list[i].address));
1680 s[ptr] = 0; /* string_cat() leaves room */
1686 /*************************************************
1687 * Find value of a variable *
1688 *************************************************/
1690 /* The table of variables is kept in alphabetic order, so we can search it
1691 using a binary chop. The "choplen" variable is nothing to do with the binary
1695 name the name of the variable being sought
1696 exists_only TRUE if this is a def: test; passed on to find_header()
1697 skipping TRUE => skip any processing evaluation; this is not the same as
1698 exists_only because def: may test for values that are first
1700 newsize pointer to an int which is initially zero; if the answer is in
1701 a new memory buffer, *newsize is set to its size
1703 Returns: NULL if the variable does not exist, or
1704 a pointer to the variable's contents, or
1705 something non-NULL if exists_only is TRUE
1709 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1716 /* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1717 Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1718 release 4.64 onwards arbitrary names are permitted, as long as the first 5
1719 characters are acl_c or acl_m and the sixth is either a digit or an underscore
1720 (this gave backwards compatibility at the changeover). There may be built-in
1721 variables whose names start acl_ but they should never start in this way. This
1722 slightly messy specification is a consequence of the history, needless to say.
1724 If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1725 set, in which case give an error. */
1727 if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1731 tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
1732 return (node == NULL)? (strict_acl_vars? NULL : US"") : node->data.ptr;
1735 /* Handle $auth<n> variables. */
1737 if (Ustrncmp(name, "auth", 4) == 0)
1740 int n = Ustrtoul(name + 4, &endptr, 10);
1741 if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
1742 return !auth_vars[n-1] ? US"" : auth_vars[n-1];
1744 else if (Ustrncmp(name, "regex", 5) == 0)
1747 int n = Ustrtoul(name + 5, &endptr, 10);
1748 if (*endptr == 0 && n != 0 && n <= REGEX_VARS)
1749 return !regex_vars[n-1] ? US"" : regex_vars[n-1];
1752 /* For all other variables, search the table */
1754 if (!(vp = find_var_ent(name)))
1755 return NULL; /* Unknown variable name */
1757 /* Found an existing variable. If in skipping state, the value isn't needed,
1758 and we want to avoid processing (such as looking up the host name). */
1766 case vtype_filter_int:
1767 if (!filter_running) return NULL;
1771 sprintf(CS var_buffer, "%d", *(int *)(val)); /* Integer */
1775 sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(val))); /* Inode */
1779 sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(val))); /* gid */
1783 sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(val))); /* uid */
1787 sprintf(CS var_buffer, "%s", *(BOOL *)(val) ? "yes" : "no"); /* bool */
1790 case vtype_stringptr: /* Pointer to string */
1791 s = *((uschar **)(val));
1792 return (s == NULL)? US"" : s;
1795 sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1798 case vtype_load_avg:
1799 sprintf(CS var_buffer, "%d", OS_GETLOADAVG()); /* load_average */
1802 case vtype_host_lookup: /* Lookup if not done so */
1803 if (sender_host_name == NULL && sender_host_address != NULL &&
1804 !host_lookup_failed && host_name_lookup() == OK)
1805 host_build_sender_fullhost();
1806 return (sender_host_name == NULL)? US"" : sender_host_name;
1808 case vtype_localpart: /* Get local part from address */
1809 s = *((uschar **)(val));
1810 if (s == NULL) return US"";
1811 domain = Ustrrchr(s, '@');
1812 if (domain == NULL) return s;
1813 if (domain - s > sizeof(var_buffer) - 1)
1814 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than " SIZE_T_FMT
1815 " in string expansion", sizeof(var_buffer));
1816 Ustrncpy(var_buffer, s, domain - s);
1817 var_buffer[domain - s] = 0;
1820 case vtype_domain: /* Get domain from address */
1821 s = *((uschar **)(val));
1822 if (s == NULL) return US"";
1823 domain = Ustrrchr(s, '@');
1824 return (domain == NULL)? US"" : domain + 1;
1826 case vtype_msgheaders:
1827 return find_header(NULL, exists_only, newsize, FALSE, NULL);
1829 case vtype_msgheaders_raw:
1830 return find_header(NULL, exists_only, newsize, TRUE, NULL);
1832 case vtype_msgbody: /* Pointer to msgbody string */
1833 case vtype_msgbody_end: /* Ditto, the end of the msg */
1834 ss = (uschar **)(val);
1835 if (*ss == NULL && deliver_datafile >= 0) /* Read body when needed */
1838 off_t start_offset = SPOOL_DATA_START_OFFSET;
1839 int len = message_body_visible;
1840 if (len > message_size) len = message_size;
1841 *ss = body = store_malloc(len+1);
1843 if (vp->type == vtype_msgbody_end)
1845 struct stat statbuf;
1846 if (fstat(deliver_datafile, &statbuf) == 0)
1848 start_offset = statbuf.st_size - len;
1849 if (start_offset < SPOOL_DATA_START_OFFSET)
1850 start_offset = SPOOL_DATA_START_OFFSET;
1853 lseek(deliver_datafile, start_offset, SEEK_SET);
1854 len = read(deliver_datafile, body, len);
1858 if (message_body_newlines) /* Separate loops for efficiency */
1861 { if (body[--len] == 0) body[len] = ' '; }
1866 { if (body[--len] == '\n' || body[len] == 0) body[len] = ' '; }
1870 return (*ss == NULL)? US"" : *ss;
1872 case vtype_todbsdin: /* BSD inbox time of day */
1873 return tod_stamp(tod_bsdin);
1875 case vtype_tode: /* Unix epoch time of day */
1876 return tod_stamp(tod_epoch);
1878 case vtype_todel: /* Unix epoch/usec time of day */
1879 return tod_stamp(tod_epoch_l);
1881 case vtype_todf: /* Full time of day */
1882 return tod_stamp(tod_full);
1884 case vtype_todl: /* Log format time of day */
1885 return tod_stamp(tod_log_bare); /* (without timezone) */
1887 case vtype_todzone: /* Time zone offset only */
1888 return tod_stamp(tod_zone);
1890 case vtype_todzulu: /* Zulu time */
1891 return tod_stamp(tod_zulu);
1893 case vtype_todlf: /* Log file datestamp tod */
1894 return tod_stamp(tod_log_datestamp_daily);
1896 case vtype_reply: /* Get reply address */
1897 s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1899 if (s != NULL) while (isspace(*s)) s++;
1900 if (s == NULL || *s == 0)
1902 *newsize = 0; /* For the *s==0 case */
1903 s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1908 while (isspace(*s)) s++;
1909 for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1910 while (t > s && isspace(t[-1])) t--;
1913 return (s == NULL)? US"" : s;
1915 case vtype_string_func:
1917 uschar * (*fn)() = val;
1924 sprintf(CS var_buffer, "%d",
1925 receive_statvfs(val == (void *)TRUE, &inodes));
1932 (void) receive_statvfs(val == (void *)TRUE, &inodes);
1933 sprintf(CS var_buffer, "%d", inodes);
1938 return *(void **)val ? US"<cert>" : US"";
1940 #ifndef DISABLE_DKIM
1942 return dkim_exim_expand_query((int)(long)val);
1947 return NULL; /* Unknown variable. Silences static checkers. */
1954 modify_variable(uschar *name, void * value)
1957 if ((vp = find_var_ent(name))) vp->value = value;
1958 return; /* Unknown variable name, fail silently */
1965 /*************************************************
1966 * Read and expand substrings *
1967 *************************************************/
1969 /* This function is called to read and expand argument substrings for various
1970 expansion items. Some have a minimum requirement that is less than the maximum;
1971 in these cases, the first non-present one is set to NULL.
1974 sub points to vector of pointers to set
1975 n maximum number of substrings
1977 sptr points to current string pointer
1978 skipping the skipping flag
1979 check_end if TRUE, check for final '}'
1980 name name of item, for error message
1981 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
1984 Returns: 0 OK; string pointer updated
1985 1 curly bracketing error (too few arguments)
1986 2 too many arguments (only if check_end is set); message set
1987 3 other error (expansion failure)
1991 read_subs(uschar **sub, int n, int m, const uschar **sptr, BOOL skipping,
1992 BOOL check_end, uschar *name, BOOL *resetok)
1995 const uschar *s = *sptr;
1997 while (isspace(*s)) s++;
1998 for (i = 0; i < n; i++)
2002 if (i < m) return 1;
2006 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, resetok);
2007 if (sub[i] == NULL) return 3;
2008 if (*s++ != '}') return 1;
2009 while (isspace(*s)) s++;
2011 if (check_end && *s++ != '}')
2015 expand_string_message = string_sprintf("Too many arguments for \"%s\" "
2016 "(max is %d)", name, n);
2029 /*************************************************
2030 * Elaborate message for bad variable *
2031 *************************************************/
2033 /* For the "unknown variable" message, take a look at the variable's name, and
2034 give additional information about possible ACL variables. The extra information
2035 is added on to expand_string_message.
2037 Argument: the name of the variable
2042 check_variable_error_message(uschar *name)
2044 if (Ustrncmp(name, "acl_", 4) == 0)
2045 expand_string_message = string_sprintf("%s (%s)", expand_string_message,
2046 (name[4] == 'c' || name[4] == 'm')?
2048 US"6th character of a user-defined ACL variable must be a digit or underscore" :
2049 US"strict_acl_vars is set" /* Syntax is OK, it has to be this */
2051 US"user-defined ACL variables must start acl_c or acl_m");
2057 Load args from sub array to globals, and call acl_check().
2058 Sub array will be corrupted on return.
2060 Returns: OK access is granted by an ACCEPT verb
2061 DISCARD access is granted by a DISCARD verb
2062 FAIL access is denied
2063 FAIL_DROP access is denied; drop the connection
2064 DEFER can't tell at the moment
2068 eval_acl(uschar ** sub, int nsub, uschar ** user_msgp)
2071 int sav_narg = acl_narg;
2073 uschar * dummy_logmsg;
2074 extern int acl_where;
2076 if(--nsub > nelem(acl_arg)) nsub = nelem(acl_arg);
2077 for (i = 0; i < nsub && sub[i+1]; i++)
2079 uschar * tmp = acl_arg[i];
2080 acl_arg[i] = sub[i+1]; /* place callers args in the globals */
2081 sub[i+1] = tmp; /* stash the old args using our caller's storage */
2086 sub[i+1] = acl_arg[i];
2087 acl_arg[i++] = NULL;
2091 debug_printf("expanding: acl: %s arg: %s%s\n",
2093 acl_narg>0 ? acl_arg[0] : US"<none>",
2094 acl_narg>1 ? " +more" : "");
2096 ret = acl_eval(acl_where, sub[0], user_msgp, &dummy_logmsg);
2098 for (i = 0; i < nsub; i++)
2099 acl_arg[i] = sub[i+1]; /* restore old args */
2100 acl_narg = sav_narg;
2108 /*************************************************
2109 * Read and evaluate a condition *
2110 *************************************************/
2114 s points to the start of the condition text
2115 resetok points to a BOOL which is written false if it is unsafe to
2116 free memory. Certain condition types (acl) may have side-effect
2117 allocation which must be preserved.
2118 yield points to a BOOL to hold the result of the condition test;
2119 if NULL, we are just reading through a condition that is
2120 part of an "or" combination to check syntax, or in a state
2121 where the answer isn't required
2123 Returns: a pointer to the first character after the condition, or
2127 static const uschar *
2128 eval_condition(const uschar *s, BOOL *resetok, BOOL *yield)
2130 BOOL testfor = TRUE;
2131 BOOL tempcond, combined_cond;
2133 BOOL sub2_honour_dollar = TRUE;
2134 int i, rc, cond_type, roffset;
2135 int_eximarith_t num[2];
2136 struct stat statbuf;
2138 const uschar *sub[10];
2141 const uschar *rerror;
2145 while (isspace(*s)) s++;
2146 if (*s == '!') { testfor = !testfor; s++; } else break;
2149 /* Numeric comparisons are symbolic */
2151 if (*s == '=' || *s == '>' || *s == '<')
2163 /* All other conditions are named */
2165 else s = read_name(name, 256, s, US"_");
2167 /* If we haven't read a name, it means some non-alpha character is first. */
2171 expand_string_message = string_sprintf("condition name expected, "
2172 "but found \"%.16s\"", s);
2176 /* Find which condition we are dealing with, and switch on it */
2178 cond_type = chop_match(name, cond_table, nelem(cond_table));
2181 /* def: tests for a non-empty variable, or for the existence of a header. If
2182 yield == NULL we are in a skipping state, and don't care about the answer. */
2187 expand_string_message = US"\":\" expected after \"def\"";
2191 s = read_name(name, 256, s+1, US"_");
2193 /* Test for a header's existence. If the name contains a closing brace
2194 character, this may be a user error where the terminating colon has been
2195 omitted. Set a flag to adjust a subsequent error message in this case. */
2197 if (Ustrncmp(name, "h_", 2) == 0 ||
2198 Ustrncmp(name, "rh_", 3) == 0 ||
2199 Ustrncmp(name, "bh_", 3) == 0 ||
2200 Ustrncmp(name, "header_", 7) == 0 ||
2201 Ustrncmp(name, "rheader_", 8) == 0 ||
2202 Ustrncmp(name, "bheader_", 8) == 0)
2204 s = read_header_name(name, 256, s);
2205 /* {-for-text-editors */
2206 if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2207 if (yield != NULL) *yield =
2208 (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
2211 /* Test for a variable's having a non-empty value. A non-existent variable
2212 causes an expansion failure. */
2216 uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
2219 expand_string_message = (name[0] == 0)?
2220 string_sprintf("variable name omitted after \"def:\"") :
2221 string_sprintf("unknown variable \"%s\" after \"def:\"", name);
2222 check_variable_error_message(name);
2225 if (yield != NULL) *yield = (value[0] != 0) == testfor;
2231 /* first_delivery tests for first delivery attempt */
2233 case ECOND_FIRST_DELIVERY:
2234 if (yield != NULL) *yield = deliver_firsttime == testfor;
2238 /* queue_running tests for any process started by a queue runner */
2240 case ECOND_QUEUE_RUNNING:
2241 if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
2245 /* exists: tests for file existence
2246 isip: tests for any IP address
2247 isip4: tests for an IPv4 address
2248 isip6: tests for an IPv6 address
2249 pam: does PAM authentication
2250 radius: does RADIUS authentication
2251 ldapauth: does LDAP authentication
2252 pwcheck: does Cyrus SASL pwcheck authentication
2261 case ECOND_LDAPAUTH:
2264 while (isspace(*s)) s++;
2265 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2267 sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL, TRUE, resetok);
2268 if (sub[0] == NULL) return NULL;
2269 /* {-for-text-editors */
2270 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2272 if (yield == NULL) return s; /* No need to run the test if skipping */
2277 if ((expand_forbid & RDO_EXISTS) != 0)
2279 expand_string_message = US"File existence tests are not permitted";
2282 *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
2288 rc = string_is_ip_address(sub[0], NULL);
2289 *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
2290 (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
2293 /* Various authentication tests - all optionally compiled */
2297 rc = auth_call_pam(sub[0], &expand_string_message);
2300 goto COND_FAILED_NOT_COMPILED;
2301 #endif /* SUPPORT_PAM */
2304 #ifdef RADIUS_CONFIG_FILE
2305 rc = auth_call_radius(sub[0], &expand_string_message);
2308 goto COND_FAILED_NOT_COMPILED;
2309 #endif /* RADIUS_CONFIG_FILE */
2311 case ECOND_LDAPAUTH:
2314 /* Just to keep the interface the same */
2316 int old_pool = store_pool;
2317 store_pool = POOL_SEARCH;
2318 rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
2319 &expand_string_message, &do_cache);
2320 store_pool = old_pool;
2324 goto COND_FAILED_NOT_COMPILED;
2325 #endif /* LOOKUP_LDAP */
2328 #ifdef CYRUS_PWCHECK_SOCKET
2329 rc = auth_call_pwcheck(sub[0], &expand_string_message);
2332 goto COND_FAILED_NOT_COMPILED;
2333 #endif /* CYRUS_PWCHECK_SOCKET */
2335 #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
2336 defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
2338 if (rc == ERROR || rc == DEFER) return NULL;
2339 *yield = (rc == OK) == testfor;
2345 /* call ACL (in a conditional context). Accept true, deny false.
2346 Defer is a forced-fail. Anything set by message= goes to $value.
2347 Up to ten parameters are used; we use the braces round the name+args
2348 like the saslauthd condition does, to permit a variable number of args.
2349 See also the expansion-item version EITEM_ACL and the traditional
2350 acl modifier ACLC_ACL.
2351 Since the ACL may allocate new global variables, tell our caller to not
2356 /* ${if acl {{name}{arg1}{arg2}...} {yes}{no}} */
2364 while (isspace(*s)) s++;
2365 if (*s++ != '{') goto COND_FAILED_CURLY_START; /*}*/
2367 switch(read_subs(sub, nelem(sub), 1,
2368 &s, yield == NULL, TRUE, US"acl", resetok))
2370 case 1: expand_string_message = US"too few arguments or bracketing "
2373 case 3: return NULL;
2377 if (yield != NULL) switch(eval_acl(sub, nelem(sub), &user_msg))
2382 lookup_value = NULL;
2385 lookup_value = string_cat(NULL, &size, &ptr, user_msg, Ustrlen(user_msg));
2386 lookup_value[ptr] = '\0';
2388 *yield = cond == testfor;
2392 expand_string_forcedfail = TRUE;
2394 expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
2401 /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
2403 ${if saslauthd {{username}{password}{service}{realm}} {yes}{no}}
2405 However, the last two are optional. That is why the whole set is enclosed
2406 in their own set of braces. */
2408 case ECOND_SASLAUTHD:
2409 #ifndef CYRUS_SASLAUTHD_SOCKET
2410 goto COND_FAILED_NOT_COMPILED;
2414 while (isspace(*s)) s++;
2415 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2416 switch(read_subs(sub, nelem(sub), 2, &s, yield == NULL, TRUE, US"saslauthd",
2419 case 1: expand_string_message = US"too few arguments or bracketing "
2420 "error for saslauthd";
2422 case 3: return NULL;
2424 if (sub[2] == NULL) sub[3] = NULL; /* realm if no service */
2427 int rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
2428 &expand_string_message);
2429 if (rc == ERROR || rc == DEFER) return NULL;
2430 *yield = (rc == OK) == testfor;
2434 #endif /* CYRUS_SASLAUTHD_SOCKET */
2437 /* symbolic operators for numeric and string comparison, and a number of
2438 other operators, all requiring two arguments.
2440 crypteq: encrypts plaintext and compares against an encrypted text,
2441 using crypt(), crypt16(), MD5 or SHA-1
2442 inlist/inlisti: checks if first argument is in the list of the second
2443 match: does a regular expression match and sets up the numerical
2444 variables if it succeeds
2445 match_address: matches in an address list
2446 match_domain: matches in a domain list
2447 match_ip: matches a host list that is restricted to IP addresses
2448 match_local_part: matches in a local part list
2451 case ECOND_MATCH_ADDRESS:
2452 case ECOND_MATCH_DOMAIN:
2453 case ECOND_MATCH_IP:
2454 case ECOND_MATCH_LOCAL_PART:
2455 #ifndef EXPAND_LISTMATCH_RHS
2456 sub2_honour_dollar = FALSE;
2465 case ECOND_NUM_L: /* Numerical comparisons */
2472 case ECOND_STR_LT: /* String comparisons */
2483 for (i = 0; i < 2; i++)
2485 /* Sometimes, we don't expand substrings; too many insecure configurations
2486 created using match_address{}{} and friends, where the second param
2487 includes information from untrustworthy sources. */
2488 BOOL honour_dollar = TRUE;
2489 if ((i > 0) && !sub2_honour_dollar)
2490 honour_dollar = FALSE;
2492 while (isspace(*s)) s++;
2495 if (i == 0) goto COND_FAILED_CURLY_START;
2496 expand_string_message = string_sprintf("missing 2nd string in {} "
2497 "after \"%s\"", name);
2500 sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL,
2501 honour_dollar, resetok);
2502 if (sub[i] == NULL) return NULL;
2503 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2505 /* Convert to numerical if required; we know that the names of all the
2506 conditions that compare numbers do not start with a letter. This just saves
2507 checking for them individually. */
2509 if (!isalpha(name[0]) && yield != NULL)
2515 debug_printf("empty string cast to zero for numerical comparison\n");
2519 num[i] = expanded_string_integer(sub[i], FALSE);
2520 if (expand_string_message != NULL) return NULL;
2525 /* Result not required */
2527 if (yield == NULL) return s;
2529 /* Do an appropriate comparison */
2535 tempcond = (num[0] == num[1]);
2539 tempcond = (num[0] > num[1]);
2543 tempcond = (num[0] >= num[1]);
2547 tempcond = (num[0] < num[1]);
2551 tempcond = (num[0] <= num[1]);
2555 tempcond = (Ustrcmp(sub[0], sub[1]) < 0);
2559 tempcond = (strcmpic(sub[0], sub[1]) < 0);
2563 tempcond = (Ustrcmp(sub[0], sub[1]) <= 0);
2567 tempcond = (strcmpic(sub[0], sub[1]) <= 0);
2571 tempcond = (Ustrcmp(sub[0], sub[1]) == 0);
2575 tempcond = (strcmpic(sub[0], sub[1]) == 0);
2579 tempcond = (Ustrcmp(sub[0], sub[1]) > 0);
2583 tempcond = (strcmpic(sub[0], sub[1]) > 0);
2587 tempcond = (Ustrcmp(sub[0], sub[1]) >= 0);
2591 tempcond = (strcmpic(sub[0], sub[1]) >= 0);
2594 case ECOND_MATCH: /* Regular expression match */
2595 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
2599 expand_string_message = string_sprintf("regular expression error in "
2600 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
2603 tempcond = regex_match_and_setup(re, sub[0], 0, -1);
2606 case ECOND_MATCH_ADDRESS: /* Match in an address list */
2607 rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
2608 goto MATCHED_SOMETHING;
2610 case ECOND_MATCH_DOMAIN: /* Match in a domain list */
2611 rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
2612 MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
2613 goto MATCHED_SOMETHING;
2615 case ECOND_MATCH_IP: /* Match IP address in a host list */
2616 if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
2618 expand_string_message = string_sprintf("\"%s\" is not an IP address",
2624 unsigned int *nullcache = NULL;
2625 check_host_block cb;
2627 cb.host_name = US"";
2628 cb.host_address = sub[0];
2630 /* If the host address starts off ::ffff: it is an IPv6 address in
2631 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2634 cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2635 cb.host_address + 7 : cb.host_address;
2637 rc = match_check_list(
2638 &sub[1], /* the list */
2639 0, /* separator character */
2640 &hostlist_anchor, /* anchor pointer */
2641 &nullcache, /* cache pointer */
2642 check_host, /* function for testing */
2643 &cb, /* argument for function */
2644 MCL_HOST, /* type of check */
2645 sub[0], /* text for debugging */
2646 NULL); /* where to pass back data */
2648 goto MATCHED_SOMETHING;
2650 case ECOND_MATCH_LOCAL_PART:
2651 rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
2652 MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
2667 expand_string_message = string_sprintf("unable to complete match "
2668 "against \"%s\": %s", sub[1], search_error_message);
2674 /* Various "encrypted" comparisons. If the second string starts with
2675 "{" then an encryption type is given. Default to crypt() or crypt16()
2676 (build-time choice). */
2677 /* }-for-text-editors */
2680 #ifndef SUPPORT_CRYPTEQ
2681 goto COND_FAILED_NOT_COMPILED;
2683 if (strncmpic(sub[1], US"{md5}", 5) == 0)
2685 int sublen = Ustrlen(sub[1]+5);
2690 md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2692 /* If the length that we are comparing against is 24, the MD5 digest
2693 is expressed as a base64 string. This is the way LDAP does it. However,
2694 some other software uses a straightforward hex representation. We assume
2695 this if the length is 32. Other lengths fail. */
2699 uschar *coded = b64encode((uschar *)digest, 16);
2700 DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2701 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2702 tempcond = (Ustrcmp(coded, sub[1]+5) == 0);
2704 else if (sublen == 32)
2708 for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2710 DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2711 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2712 tempcond = (strcmpic(coded, sub[1]+5) == 0);
2716 DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2717 "fail\n crypted=%s\n", sub[1]+5);
2722 else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2724 int sublen = Ustrlen(sub[1]+6);
2729 sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2731 /* If the length that we are comparing against is 28, assume the SHA1
2732 digest is expressed as a base64 string. If the length is 40, assume a
2733 straightforward hex representation. Other lengths fail. */
2737 uschar *coded = b64encode((uschar *)digest, 20);
2738 DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2739 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2740 tempcond = (Ustrcmp(coded, sub[1]+6) == 0);
2742 else if (sublen == 40)
2746 for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2748 DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2749 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2750 tempcond = (strcmpic(coded, sub[1]+6) == 0);
2754 DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2755 "fail\n crypted=%s\n", sub[1]+6);
2760 else /* {crypt} or {crypt16} and non-{ at start */
2761 /* }-for-text-editors */
2766 if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2771 else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2776 else if (sub[1][0] == '{') /* }-for-text-editors */
2778 expand_string_message = string_sprintf("unknown encryption mechanism "
2779 "in \"%s\"", sub[1]);
2785 case 0: coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2786 case 1: coded = US crypt(CS sub[0], CS sub[1]); break;
2787 default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2791 #define XSTR(s) STR(s)
2792 DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2793 " subject=%s\n crypted=%s\n",
2794 which == 0 ? XSTR(DEFAULT_CRYPT) : which == 1 ? "crypt" : "crypt16",
2799 /* If the encrypted string contains fewer than two characters (for the
2800 salt), force failure. Otherwise we get false positives: with an empty
2801 string the yield of crypt() is an empty string! */
2804 tempcond = Ustrlen(sub[1]) < 2 ? FALSE : Ustrcmp(coded, sub[1]) == 0;
2805 else if (errno == EINVAL)
2809 expand_string_message = string_sprintf("crypt error: %s\n",
2810 US strerror(errno));
2815 #endif /* SUPPORT_CRYPTEQ */
2820 const uschar * list = sub[1];
2822 uschar *save_iterate_item = iterate_item;
2823 int (*compare)(const uschar *, const uschar *);
2825 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2828 compare = cond_type == ECOND_INLISTI
2829 ? strcmpic : (int (*)(const uschar *, const uschar *)) strcmp;
2831 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
2832 if (compare(sub[0], iterate_item) == 0)
2837 iterate_item = save_iterate_item;
2840 } /* Switch for comparison conditions */
2842 *yield = tempcond == testfor;
2843 return s; /* End of comparison conditions */
2846 /* and/or: computes logical and/or of several conditions */
2850 subcondptr = (yield == NULL)? NULL : &tempcond;
2851 combined_cond = (cond_type == ECOND_AND);
2853 while (isspace(*s)) s++;
2854 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2858 while (isspace(*s)) s++;
2859 /* {-for-text-editors */
2860 if (*s == '}') break;
2861 if (*s != '{') /* }-for-text-editors */
2863 expand_string_message = string_sprintf("each subcondition "
2864 "inside an \"%s{...}\" condition must be in its own {}", name);
2868 if (!(s = eval_condition(s+1, resetok, subcondptr)))
2870 expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2871 expand_string_message, name);
2874 while (isspace(*s)) s++;
2876 /* {-for-text-editors */
2879 /* {-for-text-editors */
2880 expand_string_message = string_sprintf("missing } at end of condition "
2881 "inside \"%s\" group", name);
2887 if (cond_type == ECOND_AND)
2889 combined_cond &= tempcond;
2890 if (!combined_cond) subcondptr = NULL; /* once false, don't */
2891 } /* evaluate any more */
2894 combined_cond |= tempcond;
2895 if (combined_cond) subcondptr = NULL; /* once true, don't */
2896 } /* evaluate any more */
2900 if (yield != NULL) *yield = (combined_cond == testfor);
2904 /* forall/forany: iterates a condition with different values */
2909 const uschar * list;
2911 uschar *save_iterate_item = iterate_item;
2913 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2915 while (isspace(*s)) s++;
2916 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2917 sub[0] = expand_string_internal(s, TRUE, &s, (yield == NULL), TRUE, resetok);
2918 if (sub[0] == NULL) return NULL;
2919 /* {-for-text-editors */
2920 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2922 while (isspace(*s)) s++;
2923 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2927 /* Call eval_condition once, with result discarded (as if scanning a
2928 "false" part). This allows us to find the end of the condition, because if
2929 the list it empty, we won't actually evaluate the condition for real. */
2931 if (!(s = eval_condition(sub[1], resetok, NULL)))
2933 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2934 expand_string_message, name);
2937 while (isspace(*s)) s++;
2939 /* {-for-text-editors */
2942 /* {-for-text-editors */
2943 expand_string_message = string_sprintf("missing } at end of condition "
2944 "inside \"%s\"", name);
2948 if (yield != NULL) *yield = !testfor;
2950 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
2952 DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
2953 if (!eval_condition(sub[1], resetok, &tempcond))
2955 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2956 expand_string_message, name);
2957 iterate_item = save_iterate_item;
2960 DEBUG(D_expand) debug_printf("%s: condition evaluated to %s\n", name,
2961 tempcond? "true":"false");
2963 if (yield != NULL) *yield = (tempcond == testfor);
2964 if (tempcond == (cond_type == ECOND_FORANY)) break;
2967 iterate_item = save_iterate_item;
2972 /* The bool{} expansion condition maps a string to boolean.
2973 The values supported should match those supported by the ACL condition
2974 (acl.c, ACLC_CONDITION) so that we keep to a minimum the different ideas
2975 of true/false. Note that Router "condition" rules have a different
2976 interpretation, where general data can be used and only a few values
2978 Note that readconf.c boolean matching, for boolean configuration options,
2979 only matches true/yes/false/no.
2980 The bool_lax{} condition matches the Router logic, which is much more
2983 case ECOND_BOOL_LAX:
2989 BOOL boolvalue = FALSE;
2990 while (isspace(*s)) s++;
2991 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2992 ourname = cond_type == ECOND_BOOL_LAX ? US"bool_lax" : US"bool";
2993 switch(read_subs(sub_arg, 1, 1, &s, yield == NULL, FALSE, ourname, resetok))
2995 case 1: expand_string_message = string_sprintf(
2996 "too few arguments or bracketing error for %s",
3000 case 3: return NULL;
3003 while (isspace(*t)) t++;
3007 /* trailing whitespace: seems like a good idea to ignore it too */
3009 while (isspace(*t2)) t2--;
3010 if (t2 != (t + len))
3017 debug_printf("considering %s: %s\n", ourname, len ? t : US"<empty>");
3018 /* logic for the lax case from expand_check_condition(), which also does
3019 expands, and the logic is both short and stable enough that there should
3020 be no maintenance burden from replicating it. */
3024 ? Ustrspn(t+1, "0123456789") == len-1
3025 : Ustrspn(t, "0123456789") == len)
3027 boolvalue = (Uatoi(t) == 0) ? FALSE : TRUE;
3028 /* expand_check_condition only does a literal string "0" check */
3029 if ((cond_type == ECOND_BOOL_LAX) && (len > 1))
3032 else if (strcmpic(t, US"true") == 0 || strcmpic(t, US"yes") == 0)
3034 else if (strcmpic(t, US"false") == 0 || strcmpic(t, US"no") == 0)
3036 else if (cond_type == ECOND_BOOL_LAX)
3040 expand_string_message = string_sprintf("unrecognised boolean "
3044 if (yield != NULL) *yield = (boolvalue == testfor);
3048 /* Unknown condition */
3051 expand_string_message = string_sprintf("unknown condition \"%s\"", name);
3053 } /* End switch on condition type */
3055 /* Missing braces at start and end of data */
3057 COND_FAILED_CURLY_START:
3058 expand_string_message = string_sprintf("missing { after \"%s\"", name);
3061 COND_FAILED_CURLY_END:
3062 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
3066 /* A condition requires code that is not compiled */
3068 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
3069 !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
3070 !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
3071 COND_FAILED_NOT_COMPILED:
3072 expand_string_message = string_sprintf("support for \"%s\" not compiled",
3081 /*************************************************
3082 * Save numerical variables *
3083 *************************************************/
3085 /* This function is called from items such as "if" that want to preserve and
3086 restore the numbered variables.
3089 save_expand_string points to an array of pointers to set
3090 save_expand_nlength points to an array of ints for the lengths
3092 Returns: the value of expand max to save
3096 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
3099 for (i = 0; i <= expand_nmax; i++)
3101 save_expand_nstring[i] = expand_nstring[i];
3102 save_expand_nlength[i] = expand_nlength[i];
3109 /*************************************************
3110 * Restore numerical variables *
3111 *************************************************/
3113 /* This function restored saved values of numerical strings.
3116 save_expand_nmax the number of strings to restore
3117 save_expand_string points to an array of pointers
3118 save_expand_nlength points to an array of ints
3124 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
3125 int *save_expand_nlength)
3128 expand_nmax = save_expand_nmax;
3129 for (i = 0; i <= expand_nmax; i++)
3131 expand_nstring[i] = save_expand_nstring[i];
3132 expand_nlength[i] = save_expand_nlength[i];
3140 /*************************************************
3141 * Handle yes/no substrings *
3142 *************************************************/
3144 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
3145 alternative substrings that depend on whether or not the condition was true,
3146 or the lookup or extraction succeeded. The substrings always have to be
3147 expanded, to check their syntax, but "skipping" is set when the result is not
3148 needed - this avoids unnecessary nested lookups.
3151 skipping TRUE if we were skipping when this item was reached
3152 yes TRUE if the first string is to be used, else use the second
3153 save_lookup a value to put back into lookup_value before the 2nd expansion
3154 sptr points to the input string pointer
3155 yieldptr points to the output string pointer
3156 sizeptr points to the output string size
3157 ptrptr points to the output string pointer
3158 type "lookup" or "if" or "extract" or "run", for error message
3159 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
3162 Returns: 0 OK; lookup_value has been reset to save_lookup
3164 2 expansion failed because of bracketing error
3168 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, const uschar **sptr,
3169 uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type, BOOL *resetok)
3172 const uschar *s = *sptr; /* Local value */
3173 uschar *sub1, *sub2;
3175 /* If there are no following strings, we substitute the contents of $value for
3176 lookups and for extractions in the success case. For the ${if item, the string
3177 "true" is substituted. In the fail case, nothing is substituted for all three
3180 while (isspace(*s)) s++;
3185 if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
3189 if (yes && lookup_value != NULL)
3190 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
3191 Ustrlen(lookup_value));
3192 lookup_value = save_lookup;
3198 /* The first following string must be braced. */
3200 if (*s++ != '{') goto FAILED_CURLY;
3202 /* Expand the first substring. Forced failures are noticed only if we actually
3203 want this string. Set skipping in the call in the fail case (this will always
3204 be the case if we were already skipping). */
3206 sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
3207 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
3208 expand_string_forcedfail = FALSE;
3209 if (*s++ != '}') goto FAILED_CURLY;
3211 /* If we want the first string, add it to the output */
3214 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
3216 /* If this is called from a lookup or an extract, we want to restore $value to
3217 what it was at the start of the item, so that it has this value during the
3218 second string expansion. For the call from "if" or "run" to this function,
3219 save_lookup is set to lookup_value, so that this statement does nothing. */
3221 lookup_value = save_lookup;
3223 /* There now follows either another substring, or "fail", or nothing. This
3224 time, forced failures are noticed only if we want the second string. We must
3225 set skipping in the nested call if we don't want this string, or if we were
3226 already skipping. */
3228 while (isspace(*s)) s++;
3231 sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
3232 if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
3233 expand_string_forcedfail = FALSE;
3234 if (*s++ != '}') goto FAILED_CURLY;
3236 /* If we want the second string, add it to the output */
3239 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
3242 /* If there is no second string, but the word "fail" is present when the use of
3243 the second string is wanted, set a flag indicating it was a forced failure
3244 rather than a syntactic error. Swallow the terminating } in case this is nested
3245 inside another lookup or if or extract. */
3250 /* deconst cast ok here as source is s anyway */
3251 s = US read_name(name, sizeof(name), s, US"_");
3252 if (Ustrcmp(name, "fail") == 0)
3254 if (!yes && !skipping)
3256 while (isspace(*s)) s++;
3257 if (*s++ != '}') goto FAILED_CURLY;
3258 expand_string_message =
3259 string_sprintf("\"%s\" failed and \"fail\" requested", type);
3260 expand_string_forcedfail = TRUE;
3266 expand_string_message =
3267 string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
3272 /* All we have to do now is to check on the final closing brace. */
3274 while (isspace(*s)) s++;
3275 if (*s++ == '}') goto RETURN;
3277 /* Get here if there is a bracketing failure */
3282 /* Get here for other failures */
3287 /* Update the input pointer value before returning */
3297 /*************************************************
3298 * Handle MD5 or SHA-1 computation for HMAC *
3299 *************************************************/
3301 /* These are some wrapping functions that enable the HMAC code to be a bit
3302 cleaner. A good compiler will spot the tail recursion.
3305 type HMAC_MD5 or HMAC_SHA1
3306 remaining are as for the cryptographic hash functions
3312 chash_start(int type, void *base)
3314 if (type == HMAC_MD5)
3315 md5_start((md5 *)base);
3317 sha1_start((sha1 *)base);
3321 chash_mid(int type, void *base, uschar *string)
3323 if (type == HMAC_MD5)
3324 md5_mid((md5 *)base, string);
3326 sha1_mid((sha1 *)base, string);
3330 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
3332 if (type == HMAC_MD5)
3333 md5_end((md5 *)base, string, length, digest);
3335 sha1_end((sha1 *)base, string, length, digest);
3342 /********************************************************
3343 * prvs: Get last three digits of days since Jan 1, 1970 *
3344 ********************************************************/
3346 /* This is needed to implement the "prvs" BATV reverse
3349 Argument: integer "days" offset to add or substract to
3350 or from the current number of days.
3352 Returns: pointer to string containing the last three
3353 digits of the number of days since Jan 1, 1970,
3354 modified by the offset argument, NULL if there
3355 was an error in the conversion.
3360 prvs_daystamp(int day_offset)
3362 uschar *days = store_get(32); /* Need at least 24 for cases */
3363 (void)string_format(days, 32, TIME_T_FMT, /* where TIME_T_FMT is %lld */
3364 (time(NULL) + day_offset*86400)/86400);
3365 return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
3370 /********************************************************
3371 * prvs: perform HMAC-SHA1 computation of prvs bits *
3372 ********************************************************/
3374 /* This is needed to implement the "prvs" BATV reverse
3378 address RFC2821 Address to use
3379 key The key to use (must be less than 64 characters
3381 key_num Single-digit key number to use. Defaults to
3384 Returns: pointer to string containing the first three
3385 bytes of the final hash in hex format, NULL if
3386 there was an error in the process.
3390 prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
3392 uschar *hash_source, *p;
3393 int size = 0,offset = 0,i;
3395 void *use_base = &sha1_base;
3396 uschar innerhash[20];
3397 uschar finalhash[20];
3398 uschar innerkey[64];
3399 uschar outerkey[64];
3400 uschar *finalhash_hex = store_get(40);
3402 if (key_num == NULL)
3405 if (Ustrlen(key) > 64)
3408 hash_source = string_cat(NULL,&size,&offset,key_num,1);
3409 string_cat(hash_source,&size,&offset,daystamp,3);
3410 string_cat(hash_source,&size,&offset,address,Ustrlen(address));
3411 hash_source[offset] = '\0';
3413 DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
3415 memset(innerkey, 0x36, 64);
3416 memset(outerkey, 0x5c, 64);
3418 for (i = 0; i < Ustrlen(key); i++)
3420 innerkey[i] ^= key[i];
3421 outerkey[i] ^= key[i];
3424 chash_start(HMAC_SHA1, use_base);
3425 chash_mid(HMAC_SHA1, use_base, innerkey);
3426 chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
3428 chash_start(HMAC_SHA1, use_base);
3429 chash_mid(HMAC_SHA1, use_base, outerkey);
3430 chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
3433 for (i = 0; i < 3; i++)
3435 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
3436 *p++ = hex_digits[finalhash[i] & 0x0f];
3440 return finalhash_hex;
3446 /*************************************************
3447 * Join a file onto the output string *
3448 *************************************************/
3450 /* This is used for readfile and after a run expansion. It joins the contents
3451 of a file onto the output string, globally replacing newlines with a given
3452 string (optionally). The file is closed at the end.
3456 yield pointer to the expandable string
3457 sizep pointer to the current size
3458 ptrp pointer to the current position
3459 eol newline replacement string, or NULL
3461 Returns: new value of string pointer
3465 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
3468 uschar buffer[1024];
3470 eollen = (eol == NULL)? 0 : Ustrlen(eol);
3472 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
3474 int len = Ustrlen(buffer);
3475 if (eol != NULL && buffer[len-1] == '\n') len--;
3476 yield = string_cat(yield, sizep, ptrp, buffer, len);
3477 if (buffer[len] != 0)
3478 yield = string_cat(yield, sizep, ptrp, eol, eollen);
3481 if (yield != NULL) yield[*ptrp] = 0;
3489 /*************************************************
3490 * Evaluate numeric expression *
3491 *************************************************/
3493 /* This is a set of mutually recursive functions that evaluate an arithmetic
3494 expression involving + - * / % & | ^ ~ << >> and parentheses. The only one of
3495 these functions that is called from elsewhere is eval_expr, whose interface is:
3498 sptr pointer to the pointer to the string - gets updated
3499 decimal TRUE if numbers are to be assumed decimal
3500 error pointer to where to put an error message - must be NULL on input
3501 endket TRUE if ')' must terminate - FALSE for external call
3503 Returns: on success: the value of the expression, with *error still NULL
3504 on failure: an undefined value, with *error = a message
3507 static int_eximarith_t eval_op_or(uschar **, BOOL, uschar **);
3510 static int_eximarith_t
3511 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
3514 int_eximarith_t x = eval_op_or(&s, decimal, error);
3520 *error = US"expecting closing parenthesis";
3522 while (isspace(*(++s)));
3524 else if (*s != 0) *error = US"expecting operator";
3531 static int_eximarith_t
3532 eval_number(uschar **sptr, BOOL decimal, uschar **error)
3537 while (isspace(*s)) s++;
3542 (void)sscanf(CS s, (decimal? SC_EXIM_DEC "%n" : SC_EXIM_ARITH "%n"), &n, &count);
3544 switch (tolower(*s))
3547 case 'k': n *= 1024; s++; break;
3548 case 'm': n *= 1024*1024; s++; break;
3549 case 'g': n *= 1024*1024*1024; s++; break;
3551 while (isspace (*s)) s++;
3556 n = eval_expr(&s, decimal, error, 1);
3560 *error = US"expecting number or opening parenthesis";
3568 static int_eximarith_t
3569 eval_op_unary(uschar **sptr, BOOL decimal, uschar **error)
3573 while (isspace(*s)) s++;
3574 if (*s == '+' || *s == '-' || *s == '~')
3577 x = eval_op_unary(&s, decimal, error);
3578 if (op == '-') x = -x;
3579 else if (op == '~') x = ~x;
3583 x = eval_number(&s, decimal, error);
3590 static int_eximarith_t
3591 eval_op_mult(uschar **sptr, BOOL decimal, uschar **error)
3594 int_eximarith_t x = eval_op_unary(&s, decimal, error);
3597 while (*s == '*' || *s == '/' || *s == '%')
3600 int_eximarith_t y = eval_op_unary(&s, decimal, error);
3601 if (*error != NULL) break;
3602 /* SIGFPE both on div/mod by zero and on INT_MIN / -1, which would give
3603 * a value of INT_MAX+1. Note that INT_MIN * -1 gives INT_MIN for me, which
3604 * is a bug somewhere in [gcc 4.2.1, FreeBSD, amd64]. In fact, -N*-M where
3605 * -N*M is INT_MIN will yielf INT_MIN.
3606 * Since we don't support floating point, this is somewhat simpler.
3607 * Ideally, we'd return an error, but since we overflow for all other
3608 * arithmetic, consistency suggests otherwise, but what's the correct value
3609 * to use? There is none.
3610 * The C standard guarantees overflow for unsigned arithmetic but signed
3611 * overflow invokes undefined behaviour; in practice, this is overflow
3612 * except for converting INT_MIN to INT_MAX+1. We also can't guarantee
3613 * that long/longlong larger than int are available, or we could just work
3614 * with larger types. We should consider whether to guarantee 32bit eval
3615 * and 64-bit working variables, with errors returned. For now ...
3616 * So, the only SIGFPEs occur with a non-shrinking div/mod, thus -1; we
3617 * can just let the other invalid results occur otherwise, as they have
3618 * until now. For this one case, we can coerce.
3620 if (y == -1 && x == EXIM_ARITH_MIN && op != '*')
3623 debug_printf("Integer exception dodging: " PR_EXIM_ARITH "%c-1 coerced to " PR_EXIM_ARITH "\n",
3624 EXIM_ARITH_MIN, op, EXIM_ARITH_MAX);
3634 *error = (op == '/') ? US"divide by zero" : US"modulo by zero";
3650 static int_eximarith_t
3651 eval_op_sum(uschar **sptr, BOOL decimal, uschar **error)
3654 int_eximarith_t x = eval_op_mult(&s, decimal, error);
3657 while (*s == '+' || *s == '-')
3660 int_eximarith_t y = eval_op_mult(&s, decimal, error);
3661 if (*error != NULL) break;
3662 if (op == '+') x += y; else x -= y;
3670 static int_eximarith_t
3671 eval_op_shift(uschar **sptr, BOOL decimal, uschar **error)
3674 int_eximarith_t x = eval_op_sum(&s, decimal, error);
3677 while ((*s == '<' || *s == '>') && s[1] == s[0])
3682 y = eval_op_sum(&s, decimal, error);
3683 if (*error != NULL) break;
3684 if (op == '<') x <<= y; else x >>= y;
3692 static int_eximarith_t
3693 eval_op_and(uschar **sptr, BOOL decimal, uschar **error)
3696 int_eximarith_t x = eval_op_shift(&s, decimal, error);
3703 y = eval_op_shift(&s, decimal, error);
3704 if (*error != NULL) break;
3713 static int_eximarith_t
3714 eval_op_xor(uschar **sptr, BOOL decimal, uschar **error)
3717 int_eximarith_t x = eval_op_and(&s, decimal, error);
3724 y = eval_op_and(&s, decimal, error);
3725 if (*error != NULL) break;
3734 static int_eximarith_t
3735 eval_op_or(uschar **sptr, BOOL decimal, uschar **error)
3738 int_eximarith_t x = eval_op_xor(&s, decimal, error);
3745 y = eval_op_xor(&s, decimal, error);
3746 if (*error != NULL) break;
3756 /*************************************************
3758 *************************************************/
3760 /* Returns either an unchanged string, or the expanded string in stacking pool
3761 store. Interpreted sequences are:
3763 \... normal escaping rules
3764 $name substitutes the variable
3766 ${op:string} operates on the expanded string value
3767 ${item{arg1}{arg2}...} expands the args and then does the business
3768 some literal args are not enclosed in {}
3770 There are now far too many operators and item types to make it worth listing
3771 them here in detail any more.
3773 We use an internal routine recursively to handle embedded substrings. The
3774 external function follows. The yield is NULL if the expansion failed, and there
3775 are two cases: if something collapsed syntactically, or if "fail" was given
3776 as the action on a lookup failure. These can be distinguised by looking at the
3777 variable expand_string_forcedfail, which is TRUE in the latter case.
3779 The skipping flag is set true when expanding a substring that isn't actually
3780 going to be used (after "if" or "lookup") and it prevents lookups from
3781 happening lower down.
3783 Store usage: At start, a store block of the length of the input plus 64
3784 is obtained. This is expanded as necessary by string_cat(), which might have to
3785 get a new block, or might be able to expand the original. At the end of the
3786 function we can release any store above that portion of the yield block that
3787 was actually used. In many cases this will be optimal.
3789 However: if the first item in the expansion is a variable name or header name,
3790 we reset the store before processing it; if the result is in fresh store, we
3791 use that without copying. This is helpful for expanding strings like
3792 $message_headers which can get very long.
3794 There's a problem if a ${dlfunc item has side-effects that cause allocation,
3795 since resetting the store at the end of the expansion will free store that was
3796 allocated by the plugin code as well as the slop after the expanded string. So
3797 we skip any resets if ${dlfunc } has been used. The same applies for ${acl }
3798 and, given the acl condition, ${if }. This is an unfortunate consequence of
3799 string expansion becoming too powerful.
3802 string the string to be expanded
3803 ket_ends true if expansion is to stop at }
3804 left if not NULL, a pointer to the first character after the
3805 expansion is placed here (typically used with ket_ends)
3806 skipping TRUE for recursive calls when the value isn't actually going
3807 to be used (to allow for optimisation)
3808 honour_dollar TRUE if $ is to be expanded,
3809 FALSE if it's just another character
3810 resetok_p if not NULL, pointer to flag - write FALSE if unsafe to reset
3813 Returns: NULL if expansion fails:
3814 expand_string_forcedfail is set TRUE if failure was forced
3815 expand_string_message contains a textual error message
3816 a pointer to the expanded string on success
3820 expand_string_internal(const uschar *string, BOOL ket_ends, const uschar **left,
3821 BOOL skipping, BOOL honour_dollar, BOOL *resetok_p)
3824 int size = Ustrlen(string)+ 64;
3826 uschar *yield = store_get(size);
3827 const uschar *s = string;
3828 uschar *save_expand_nstring[EXPAND_MAXN+1];
3829 int save_expand_nlength[EXPAND_MAXN+1];
3830 BOOL resetok = TRUE;
3832 expand_string_forcedfail = FALSE;
3833 expand_string_message = US"";
3840 /* \ escapes the next character, which must exist, or else
3841 the expansion fails. There's a special escape, \N, which causes
3842 copying of the subject verbatim up to the next \N. Otherwise,
3843 the escapes are the standard set. */
3849 expand_string_message = US"\\ at end of string";
3855 const uschar * t = s + 2;
3856 for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
3857 yield = string_cat(yield, &size, &ptr, t, s - t);
3858 if (*s != 0) s += 2;
3864 ch[0] = string_interpret_escape(&s);
3866 yield = string_cat(yield, &size, &ptr, ch, 1);
3873 /* Anything other than $ is just copied verbatim, unless we are
3874 looking for a terminating } character. */
3877 if (ket_ends && *s == '}') break;
3879 if (*s != '$' || !honour_dollar)
3881 yield = string_cat(yield, &size, &ptr, s++, 1);
3885 /* No { after the $ - must be a plain name or a number for string
3886 match variable. There has to be a fudge for variables that are the
3887 names of header fields preceded by "$header_" because header field
3888 names can contain any printing characters except space and colon.
3889 For those that don't like typing this much, "$h_" is a synonym for
3890 "$header_". A non-existent header yields a NULL value; nothing is
3893 if (isalpha((*(++s))))
3898 s = read_name(name, sizeof(name), s, US"_");
3900 /* If this is the first thing to be expanded, release the pre-allocated
3903 if (ptr == 0 && yield != NULL)
3905 if (resetok) store_reset(yield);
3912 if (Ustrncmp(name, "h_", 2) == 0 ||
3913 Ustrncmp(name, "rh_", 3) == 0 ||
3914 Ustrncmp(name, "bh_", 3) == 0 ||
3915 Ustrncmp(name, "header_", 7) == 0 ||
3916 Ustrncmp(name, "rheader_", 8) == 0 ||
3917 Ustrncmp(name, "bheader_", 8) == 0)
3919 BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
3920 uschar *charset = (name[0] == 'b')? NULL : headers_charset;
3921 s = read_header_name(name, sizeof(name), s);
3922 value = find_header(name, FALSE, &newsize, want_raw, charset);
3924 /* If we didn't find the header, and the header contains a closing brace
3925 character, this may be a user error where the terminating colon
3926 has been omitted. Set a flag to adjust the error message in this case.
3927 But there is no error here - nothing gets inserted. */
3931 if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
3940 value = find_variable(name, FALSE, skipping, &newsize);
3943 expand_string_message =
3944 string_sprintf("unknown variable name \"%s\"", name);
3945 check_variable_error_message(name);
3950 /* If the data is known to be in a new buffer, newsize will be set to the
3951 size of that buffer. If this is the first thing in an expansion string,
3952 yield will be NULL; just point it at the new store instead of copying. Many
3953 expansion strings contain just one reference, so this is a useful
3954 optimization, especially for humungous headers. */
3956 len = Ustrlen(value);
3957 if (yield == NULL && newsize != 0)
3963 else yield = string_cat(yield, &size, &ptr, value, len);
3971 s = read_cnumber(&n, s);
3972 if (n >= 0 && n <= expand_nmax)
3973 yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3978 /* Otherwise, if there's no '{' after $ it's an error. */ /*}*/
3980 if (*s != '{') /*}*/
3982 expand_string_message = US"$ not followed by letter, digit, or {"; /*}*/
3986 /* After { there can be various things, but they all start with
3987 an initial word, except for a number for a string match variable. */
3989 if (isdigit((*(++s))))
3992 s = read_cnumber(&n, s); /*{*/
3995 expand_string_message = US"} expected after number";
3998 if (n >= 0 && n <= expand_nmax)
3999 yield = string_cat(yield, &size, &ptr, expand_nstring[n],
4006 expand_string_message = US"letter or digit expected after ${"; /*}*/
4010 /* Allow "-" in names to cater for substrings with negative
4011 arguments. Since we are checking for known names after { this is
4014 s = read_name(name, sizeof(name), s, US"_-");
4015 item_type = chop_match(name, item_table, nelem(item_table));
4019 /* Call an ACL from an expansion. We feed data in via $acl_arg1 - $acl_arg9.
4020 If the ACL returns accept or reject we return content set by "message ="
4021 There is currently no limit on recursion; this would have us call
4022 acl_check_internal() directly and get a current level from somewhere.
4023 See also the acl expansion condition ECOND_ACL and the traditional
4024 acl modifier ACLC_ACL.
4025 Assume that the function has side-effects on the store that must be preserved.
4029 /* ${acl {name} {arg1}{arg2}...} */
4031 uschar *sub[10]; /* name + arg1-arg9 (which must match number of acl_arg[]) */
4034 switch(read_subs(sub, nelem(sub), 1, &s, skipping, TRUE, US"acl",
4037 case 1: goto EXPAND_FAILED_CURLY;
4039 case 3: goto EXPAND_FAILED;
4041 if (skipping) continue;
4044 switch(eval_acl(sub, nelem(sub), &user_msg))
4049 debug_printf("acl expansion yield: %s\n", user_msg);
4051 yield = string_cat(yield, &size, &ptr, user_msg, Ustrlen(user_msg));
4055 expand_string_forcedfail = TRUE;
4057 expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
4062 /* Handle conditionals - preserve the values of the numerical expansion
4063 variables in case they get changed by a regular expression match in the
4064 condition. If not, they retain their external settings. At the end
4065 of this "if" section, they get restored to their previous values. */
4070 const uschar *next_s;
4071 int save_expand_nmax =
4072 save_expand_strings(save_expand_nstring, save_expand_nlength);
4074 while (isspace(*s)) s++;
4075 next_s = eval_condition(s, &resetok, skipping? NULL : &cond);
4076 if (next_s == NULL) goto EXPAND_FAILED; /* message already set */
4079 debug_printf("condition: %.*s\n result: %s\n", (int)(next_s - s), s,
4080 cond? "true" : "false");
4084 /* The handling of "yes" and "no" result strings is now in a separate
4085 function that is also used by ${lookup} and ${extract} and ${run}. */
4087 switch(process_yesno(
4088 skipping, /* were previously skipping */
4089 cond, /* success/failure indicator */
4090 lookup_value, /* value to reset for string2 */
4091 &s, /* input pointer */
4092 &yield, /* output pointer */
4093 &size, /* output size */
4094 &ptr, /* output current point */
4095 US"if", /* condition type */
4098 case 1: goto EXPAND_FAILED; /* when all is well, the */
4099 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
4102 /* Restore external setting of expansion variables for continuation
4105 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4106 save_expand_nlength);
4111 case EITEM_IMAPFOLDER:
4112 { /* ${imapfolder {name}{sep]{specials}} */
4116 switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, skipping, TRUE, name,
4119 case 1: goto EXPAND_FAILED_CURLY;
4121 case 3: goto EXPAND_FAILED;
4124 if (sub_arg[1] == NULL) /* One argument */
4126 sub_arg[1] = US"/"; /* default separator */
4129 else if (Ustrlen(sub_arg[1]) != 1)
4131 expand_string_message =
4133 "IMAP folder separator must be one character, found \"%s\"",
4138 if (!(encoded = imap_utf7_encode(sub_arg[0], headers_charset,
4139 sub_arg[1][0], sub_arg[2], &expand_string_message)))
4142 yield = string_cat(yield, &size, &ptr, encoded, Ustrlen(encoded));
4147 /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
4148 expanding an internal string that isn't actually going to be used. All we
4149 need to do is check the syntax, so don't do a lookup at all. Preserve the
4150 values of the numerical expansion variables in case they get changed by a
4151 partial lookup. If not, they retain their external settings. At the end
4152 of this "lookup" section, they get restored to their previous values. */
4156 int stype, partial, affixlen, starflags;
4157 int expand_setup = 0;
4159 uschar *key, *filename;
4160 const uschar *affix;
4161 uschar *save_lookup_value = lookup_value;
4162 int save_expand_nmax =
4163 save_expand_strings(save_expand_nstring, save_expand_nlength);
4165 if ((expand_forbid & RDO_LOOKUP) != 0)
4167 expand_string_message = US"lookup expansions are not permitted";
4171 /* Get the key we are to look up for single-key+file style lookups.
4172 Otherwise set the key NULL pro-tem. */
4174 while (isspace(*s)) s++;
4175 if (*s == '{') /*}*/
4177 key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4178 if (key == NULL) goto EXPAND_FAILED; /*{*/
4179 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4180 while (isspace(*s)) s++;
4184 /* Find out the type of database */
4188 expand_string_message = US"missing lookup type";
4192 /* The type is a string that may contain special characters of various
4193 kinds. Allow everything except space or { to appear; the actual content
4194 is checked by search_findtype_partial. */ /*}*/
4196 while (*s != 0 && *s != '{' && !isspace(*s)) /*}*/
4198 if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
4202 while (isspace(*s)) s++;
4204 /* Now check for the individual search type and any partial or default
4205 options. Only those types that are actually in the binary are valid. */
4207 stype = search_findtype_partial(name, &partial, &affix, &affixlen,
4211 expand_string_message = search_error_message;
4215 /* Check that a key was provided for those lookup types that need it,
4216 and was not supplied for those that use the query style. */
4218 if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
4222 expand_string_message = string_sprintf("missing {key} for single-"
4223 "key \"%s\" lookup", name);
4231 expand_string_message = string_sprintf("a single key was given for "
4232 "lookup type \"%s\", which is not a single-key lookup type", name);
4237 /* Get the next string in brackets and expand it. It is the file name for
4238 single-key+file lookups, and the whole query otherwise. In the case of
4239 queries that also require a file name (e.g. sqlite), the file name comes
4242 if (*s != '{') goto EXPAND_FAILED_CURLY;
4243 filename = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4244 if (filename == NULL) goto EXPAND_FAILED;
4245 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4246 while (isspace(*s)) s++;
4248 /* If this isn't a single-key+file lookup, re-arrange the variables
4249 to be appropriate for the search_ functions. For query-style lookups,
4250 there is just a "key", and no file name. For the special query-style +
4251 file types, the query (i.e. "key") starts with a file name. */
4255 while (isspace(*filename)) filename++;
4258 if (mac_islookup(stype, lookup_querystyle))
4264 if (*filename != '/')
4266 expand_string_message = string_sprintf(
4267 "absolute file name expected for \"%s\" lookup", name);
4270 while (*key != 0 && !isspace(*key)) key++;
4271 if (*key != 0) *key++ = 0;
4275 /* If skipping, don't do the next bit - just lookup_value == NULL, as if
4276 the entry was not found. Note that there is no search_close() function.
4277 Files are left open in case of re-use. At suitable places in higher logic,
4278 search_tidyup() is called to tidy all open files. This can save opening
4279 the same file several times. However, files may also get closed when
4280 others are opened, if too many are open at once. The rule is that a
4281 handle should not be used after a second search_open().
4283 Request that a partial search sets up $1 and maybe $2 by passing
4284 expand_setup containing zero. If its value changes, reset expand_nmax,
4285 since new variables will have been set. Note that at the end of this
4286 "lookup" section, the old numeric variables are restored. */
4289 lookup_value = NULL;
4292 void *handle = search_open(filename, stype, 0, NULL, NULL);
4295 expand_string_message = search_error_message;
4298 lookup_value = search_find(handle, filename, key, partial, affix,
4299 affixlen, starflags, &expand_setup);
4300 if (search_find_defer)
4302 expand_string_message =
4303 string_sprintf("lookup of \"%s\" gave DEFER: %s",
4304 string_printing2(key, FALSE), search_error_message);
4307 if (expand_setup > 0) expand_nmax = expand_setup;
4310 /* The handling of "yes" and "no" result strings is now in a separate
4311 function that is also used by ${if} and ${extract}. */
4313 switch(process_yesno(
4314 skipping, /* were previously skipping */
4315 lookup_value != NULL, /* success/failure indicator */
4316 save_lookup_value, /* value to reset for string2 */
4317 &s, /* input pointer */
4318 &yield, /* output pointer */
4319 &size, /* output size */
4320 &ptr, /* output current point */
4321 US"lookup", /* condition type */
4324 case 1: goto EXPAND_FAILED; /* when all is well, the */
4325 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
4328 /* Restore external setting of expansion variables for carrying on
4329 at this level, and continue. */
4331 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4332 save_expand_nlength);
4336 /* If Perl support is configured, handle calling embedded perl subroutines,
4337 unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
4338 or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
4339 arguments (defined below). */
4341 #define EXIM_PERL_MAX_ARGS 8
4345 expand_string_message = US"\"${perl\" encountered, but this facility " /*}*/
4346 "is not included in this binary";
4349 #else /* EXIM_PERL */
4351 uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
4354 if ((expand_forbid & RDO_PERL) != 0)
4356 expand_string_message = US"Perl calls are not permitted";
4360 switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
4361 US"perl", &resetok))
4363 case 1: goto EXPAND_FAILED_CURLY;
4365 case 3: goto EXPAND_FAILED;
4368 /* If skipping, we don't actually do anything */
4370 if (skipping) continue;
4372 /* Start the interpreter if necessary */
4374 if (!opt_perl_started)
4377 if (opt_perl_startup == NULL)
4379 expand_string_message = US"A setting of perl_startup is needed when "
4380 "using the Perl interpreter";
4383 DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
4384 initerror = init_perl(opt_perl_startup);
4385 if (initerror != NULL)
4387 expand_string_message =
4388 string_sprintf("error in perl_startup code: %s\n", initerror);
4391 opt_perl_started = TRUE;
4394 /* Call the function */
4396 sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
4397 new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
4398 sub_arg[0], sub_arg + 1);
4400 /* NULL yield indicates failure; if the message pointer has been set to
4401 NULL, the yield was undef, indicating a forced failure. Otherwise the
4402 message will indicate some kind of Perl error. */
4404 if (new_yield == NULL)
4406 if (expand_string_message == NULL)
4408 expand_string_message =
4409 string_sprintf("Perl subroutine \"%s\" returned undef to force "
4410 "failure", sub_arg[0]);
4411 expand_string_forcedfail = TRUE;
4416 /* Yield succeeded. Ensure forcedfail is unset, just in case it got
4417 set during a callback from Perl. */
4419 expand_string_forcedfail = FALSE;
4423 #endif /* EXIM_PERL */
4425 /* Transform email address to "prvs" scheme to use
4426 as BATV-signed return path */
4433 switch(read_subs(sub_arg, 3, 2, &s, skipping, TRUE, US"prvs", &resetok))
4435 case 1: goto EXPAND_FAILED_CURLY;
4437 case 3: goto EXPAND_FAILED;
4440 /* If skipping, we don't actually do anything */
4441 if (skipping) continue;
4443 /* sub_arg[0] is the address */
4444 domain = Ustrrchr(sub_arg[0],'@');
4445 if ( (domain == NULL) || (domain == sub_arg[0]) || (Ustrlen(domain) == 1) )
4447 expand_string_message = US"prvs first argument must be a qualified email address";
4451 /* Calculate the hash. The second argument must be a single-digit
4452 key number, or unset. */
4454 if (sub_arg[2] != NULL &&
4455 (!isdigit(sub_arg[2][0]) || sub_arg[2][1] != 0))
4457 expand_string_message = US"prvs second argument must be a single digit";
4461 p = prvs_hmac_sha1(sub_arg[0],sub_arg[1],sub_arg[2],prvs_daystamp(7));
4464 expand_string_message = US"prvs hmac-sha1 conversion failed";
4468 /* Now separate the domain from the local part */
4471 yield = string_cat(yield,&size,&ptr,US"prvs=",5);
4472 string_cat(yield,&size,&ptr,(sub_arg[2] != NULL) ? sub_arg[2] : US"0", 1);
4473 string_cat(yield,&size,&ptr,prvs_daystamp(7),3);
4474 string_cat(yield,&size,&ptr,p,6);
4475 string_cat(yield,&size,&ptr,US"=",1);
4476 string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
4477 string_cat(yield,&size,&ptr,US"@",1);
4478 string_cat(yield,&size,&ptr,domain,Ustrlen(domain));
4483 /* Check a prvs-encoded address for validity */
4485 case EITEM_PRVSCHECK:
4488 int mysize = 0, myptr = 0;
4492 /* TF: Ugliness: We want to expand parameter 1 first, then set
4493 up expansion variables that are used in the expansion of
4494 parameter 2. So we clone the string for the first
4495 expansion, where we only expand parameter 1.
4497 PH: Actually, that isn't necessary. The read_subs() function is
4498 designed to work this way for the ${if and ${lookup expansions. I've
4502 /* Reset expansion variables */
4503 prvscheck_result = NULL;
4504 prvscheck_address = NULL;
4505 prvscheck_keynum = NULL;
4507 switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4509 case 1: goto EXPAND_FAILED_CURLY;
4511 case 3: goto EXPAND_FAILED;
4514 re = regex_must_compile(US"^prvs\\=([0-9])([0-9]{3})([A-F0-9]{6})\\=(.+)\\@(.+)$",
4517 if (regex_match_and_setup(re,sub_arg[0],0,-1))
4519 uschar *local_part = string_copyn(expand_nstring[4],expand_nlength[4]);
4520 uschar *key_num = string_copyn(expand_nstring[1],expand_nlength[1]);
4521 uschar *daystamp = string_copyn(expand_nstring[2],expand_nlength[2]);
4522 uschar *hash = string_copyn(expand_nstring[3],expand_nlength[3]);
4523 uschar *domain = string_copyn(expand_nstring[5],expand_nlength[5]);
4525 DEBUG(D_expand) debug_printf("prvscheck localpart: %s\n", local_part);
4526 DEBUG(D_expand) debug_printf("prvscheck key number: %s\n", key_num);
4527 DEBUG(D_expand) debug_printf("prvscheck daystamp: %s\n", daystamp);
4528 DEBUG(D_expand) debug_printf("prvscheck hash: %s\n", hash);
4529 DEBUG(D_expand) debug_printf("prvscheck domain: %s\n", domain);
4531 /* Set up expansion variables */
4532 prvscheck_address = string_cat(NULL, &mysize, &myptr, local_part, Ustrlen(local_part));
4533 string_cat(prvscheck_address,&mysize,&myptr,US"@",1);
4534 string_cat(prvscheck_address,&mysize,&myptr,domain,Ustrlen(domain));
4535 prvscheck_address[myptr] = '\0';
4536 prvscheck_keynum = string_copy(key_num);
4538 /* Now expand the second argument */
4539 switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs", &resetok))
4541 case 1: goto EXPAND_FAILED_CURLY;
4543 case 3: goto EXPAND_FAILED;
4546 /* Now we have the key and can check the address. */
4548 p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
4553 expand_string_message = US"hmac-sha1 conversion failed";
4557 DEBUG(D_expand) debug_printf("prvscheck: received hash is %s\n", hash);
4558 DEBUG(D_expand) debug_printf("prvscheck: own hash is %s\n", p);
4560 if (Ustrcmp(p,hash) == 0)
4562 /* Success, valid BATV address. Now check the expiry date. */
4563 uschar *now = prvs_daystamp(0);
4564 unsigned int inow = 0,iexpire = 1;
4566 (void)sscanf(CS now,"%u",&inow);
4567 (void)sscanf(CS daystamp,"%u",&iexpire);
4569 /* When "iexpire" is < 7, a "flip" has occured.
4570 Adjust "inow" accordingly. */
4571 if ( (iexpire < 7) && (inow >= 993) ) inow = 0;
4573 if (iexpire >= inow)
4575 prvscheck_result = US"1";
4576 DEBUG(D_expand) debug_printf("prvscheck: success, $pvrs_result set to 1\n");
4580 prvscheck_result = NULL;
4581 DEBUG(D_expand) debug_printf("prvscheck: signature expired, $pvrs_result unset\n");
4586 prvscheck_result = NULL;
4587 DEBUG(D_expand) debug_printf("prvscheck: hash failure, $pvrs_result unset\n");
4590 /* Now expand the final argument. We leave this till now so that
4591 it can include $prvscheck_result. */
4593 switch(read_subs(sub_arg, 1, 0, &s, skipping, TRUE, US"prvs", &resetok))
4595 case 1: goto EXPAND_FAILED_CURLY;
4597 case 3: goto EXPAND_FAILED;
4600 if (sub_arg[0] == NULL || *sub_arg[0] == '\0')
4601 yield = string_cat(yield,&size,&ptr,prvscheck_address,Ustrlen(prvscheck_address));
4603 yield = string_cat(yield,&size,&ptr,sub_arg[0],Ustrlen(sub_arg[0]));
4605 /* Reset the "internal" variables afterwards, because they are in
4606 dynamic store that will be reclaimed if the expansion succeeded. */
4608 prvscheck_address = NULL;
4609 prvscheck_keynum = NULL;
4613 /* Does not look like a prvs encoded address, return the empty string.
4614 We need to make sure all subs are expanded first, so as to skip over
4617 switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"prvs", &resetok))
4619 case 1: goto EXPAND_FAILED_CURLY;
4621 case 3: goto EXPAND_FAILED;
4628 /* Handle "readfile" to insert an entire file */
4630 case EITEM_READFILE:
4635 if ((expand_forbid & RDO_READFILE) != 0)
4637 expand_string_message = US"file insertions are not permitted";
4641 switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"readfile", &resetok))
4643 case 1: goto EXPAND_FAILED_CURLY;
4645 case 3: goto EXPAND_FAILED;
4648 /* If skipping, we don't actually do anything */
4650 if (skipping) continue;
4652 /* Open the file and read it */
4654 f = Ufopen(sub_arg[0], "rb");
4657 expand_string_message = string_open_failed(errno, "%s", sub_arg[0]);
4661 yield = cat_file(f, yield, &size, &ptr, sub_arg[1]);
4666 /* Handle "readsocket" to insert data from a Unix domain socket */
4668 case EITEM_READSOCK:
4674 struct sockaddr_un sockun; /* don't call this "sun" ! */
4678 if ((expand_forbid & RDO_READSOCK) != 0)
4680 expand_string_message = US"socket insertions are not permitted";
4684 /* Read up to 4 arguments, but don't do the end of item check afterwards,
4685 because there may be a string for expansion on failure. */
4687 switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, US"readsocket", &resetok))
4689 case 1: goto EXPAND_FAILED_CURLY;
4690 case 2: /* Won't occur: no end check */
4691 case 3: goto EXPAND_FAILED;
4694 /* Sort out timeout, if given */
4696 if (sub_arg[2] != NULL)
4698 timeout = readconf_readtime(sub_arg[2], 0, FALSE);
4701 expand_string_message = string_sprintf("bad time value %s",
4706 else sub_arg[3] = NULL; /* No eol if no timeout */
4708 /* If skipping, we don't actually do anything. Otherwise, arrange to
4709 connect to either an IP or a Unix socket. */
4713 /* Handle an IP (internet) domain */
4715 if (Ustrncmp(sub_arg[0], "inet:", 5) == 0)
4718 uschar *server_name = sub_arg[0] + 5;
4719 uschar *port_name = Ustrrchr(server_name, ':');
4721 /* Sort out the port */
4723 if (port_name == NULL)
4725 expand_string_message =
4726 string_sprintf("missing port for readsocket %s", sub_arg[0]);
4729 *port_name++ = 0; /* Terminate server name */
4731 if (isdigit(*port_name))
4734 port = Ustrtol(port_name, &end, 0);
4735 if (end != port_name + Ustrlen(port_name))
4737 expand_string_message =
4738 string_sprintf("invalid port number %s", port_name);
4744 struct servent *service_info = getservbyname(CS port_name, "tcp");
4745 if (service_info == NULL)
4747 expand_string_message = string_sprintf("unknown port \"%s\"",
4751 port = ntohs(service_info->s_port);
4754 if ((fd = ip_connectedsocket(SOCK_STREAM, server_name, port, port,
4755 timeout, NULL, &expand_string_message)) < 0)
4759 /* Handle a Unix domain socket */
4764 if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
4766 expand_string_message = string_sprintf("failed to create socket: %s",
4771 sockun.sun_family = AF_UNIX;
4772 sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
4775 sigalrm_seen = FALSE;
4777 rc = connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun));
4781 expand_string_message = US "socket connect timed out";
4786 expand_string_message = string_sprintf("failed to connect to socket "
4787 "%s: %s", sub_arg[0], strerror(errno));
4792 DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
4794 /* Allow sequencing of test actions */
4795 if (running_in_test_harness) millisleep(100);
4797 /* Write the request string, if not empty */
4799 if (sub_arg[1][0] != 0)
4801 int len = Ustrlen(sub_arg[1]);
4802 DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
4804 if (write(fd, sub_arg[1], len) != len)
4806 expand_string_message = string_sprintf("request write to socket "
4807 "failed: %s", strerror(errno));
4812 /* Shut down the sending side of the socket. This helps some servers to
4813 recognise that it is their turn to do some work. Just in case some
4814 system doesn't have this function, make it conditional. */
4817 shutdown(fd, SHUT_WR);
4820 if (running_in_test_harness) millisleep(100);
4822 /* Now we need to read from the socket, under a timeout. The function
4823 that reads a file can be used. */
4825 f = fdopen(fd, "rb");
4826 sigalrm_seen = FALSE;
4828 yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
4832 /* After a timeout, we restore the pointer in the result, that is,
4833 make sure we add nothing from the socket. */
4838 expand_string_message = US "socket read timed out";
4843 /* The whole thing has worked (or we were skipping). If there is a
4844 failure string following, we need to skip it. */
4848 if (expand_string_internal(s+1, TRUE, &s, TRUE, TRUE, &resetok) == NULL)
4850 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4851 while (isspace(*s)) s++;
4853 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4856 /* Come here on failure to create socket, connect socket, write to the
4857 socket, or timeout on reading. If another substring follows, expand and
4858 use it. Otherwise, those conditions give expand errors. */
4861 if (*s != '{') goto EXPAND_FAILED;
4862 DEBUG(D_any) debug_printf("%s\n", expand_string_message);
4863 arg = expand_string_internal(s+1, TRUE, &s, FALSE, TRUE, &resetok);
4864 if (arg == NULL) goto EXPAND_FAILED;
4865 yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
4866 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4867 while (isspace(*s)) s++;
4868 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4872 /* Handle "run" to execute a program. */
4878 const uschar **argv;
4884 if ((expand_forbid & RDO_RUN) != 0)
4886 expand_string_message = US"running a command is not permitted";
4890 while (isspace(*s)) s++;
4891 if (*s != '{') goto EXPAND_FAILED_CURLY;
4892 arg = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
4893 if (arg == NULL) goto EXPAND_FAILED;
4894 while (isspace(*s)) s++;
4895 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4897 if (skipping) /* Just pretend it worked when we're skipping */
4903 if (!transport_set_up_command(&argv, /* anchor for arg list */
4904 arg, /* raw command */
4905 FALSE, /* don't expand the arguments */
4906 0, /* not relevant when... */
4907 NULL, /* no transporting address */
4908 US"${run} expansion", /* for error messages */
4909 &expand_string_message)) /* where to put error message */
4914 /* Create the child process, making it a group leader. */
4916 pid = child_open(USS argv, NULL, 0077, &fd_in, &fd_out, TRUE);
4920 expand_string_message =
4921 string_sprintf("couldn't create child process: %s", strerror(errno));
4925 /* Nothing is written to the standard input. */
4929 /* Read the pipe to get the command's output into $value (which is kept
4930 in lookup_value). Read during execution, so that if the output exceeds
4931 the OS pipe buffer limit, we don't block forever. */
4933 f = fdopen(fd_out, "rb");
4934 sigalrm_seen = FALSE;
4936 lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
4940 /* Wait for the process to finish, applying the timeout, and inspect its
4941 return code for serious disasters. Simple non-zero returns are passed on.
4944 if (sigalrm_seen == TRUE || (runrc = child_close(pid, 30)) < 0)
4946 if (sigalrm_seen == TRUE || runrc == -256)
4948 expand_string_message = string_sprintf("command timed out");
4949 killpg(pid, SIGKILL); /* Kill the whole process group */
4952 else if (runrc == -257)
4953 expand_string_message = string_sprintf("wait() failed: %s",
4957 expand_string_message = string_sprintf("command killed by signal %d",
4964 /* Process the yes/no strings; $value may be useful in both cases */
4966 switch(process_yesno(
4967 skipping, /* were previously skipping */
4968 runrc == 0, /* success/failure indicator */
4969 lookup_value, /* value to reset for string2 */
4970 &s, /* input pointer */
4971 &yield, /* output pointer */
4972 &size, /* output size */
4973 &ptr, /* output current point */
4974 US"run", /* condition type */
4977 case 1: goto EXPAND_FAILED; /* when all is well, the */
4978 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
4984 /* Handle character translation for "tr" */
4992 switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr", &resetok))
4994 case 1: goto EXPAND_FAILED_CURLY;
4996 case 3: goto EXPAND_FAILED;
4999 yield = string_cat(yield, &size, &ptr, sub[0], Ustrlen(sub[0]));
5000 o2m = Ustrlen(sub[2]) - 1;
5002 if (o2m >= 0) for (; oldptr < ptr; oldptr++)
5004 uschar *m = Ustrrchr(sub[1], yield[oldptr]);
5008 yield[oldptr] = sub[2][(o < o2m)? o : o2m];
5015 /* Handle "hash", "length", "nhash", and "substr" when they are given with
5016 expanded arguments. */
5026 int val[2] = { 0, -1 };
5029 /* "length" takes only 2 arguments whereas the others take 2 or 3.
5030 Ensure that sub[2] is set in the ${length } case. */
5033 switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
5034 TRUE, name, &resetok))
5036 case 1: goto EXPAND_FAILED_CURLY;
5038 case 3: goto EXPAND_FAILED;
5041 /* Juggle the arguments if there are only two of them: always move the
5042 string to the last position and make ${length{n}{str}} equivalent to
5043 ${substr{0}{n}{str}}. See the defaults for val[] above. */
5049 if (item_type == EITEM_LENGTH)
5056 for (i = 0; i < 2; i++)
5058 if (sub[i] == NULL) continue;
5059 val[i] = (int)Ustrtol(sub[i], &ret, 10);
5060 if (*ret != 0 || (i != 0 && val[i] < 0))
5062 expand_string_message = string_sprintf("\"%s\" is not a%s number "
5063 "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
5069 (item_type == EITEM_HASH)?
5070 compute_hash(sub[2], val[0], val[1], &len) :
5071 (item_type == EITEM_NHASH)?
5072 compute_nhash(sub[2], val[0], val[1], &len) :
5073 extract_substr(sub[2], val[0], val[1], &len);
5075 if (ret == NULL) goto EXPAND_FAILED;
5076 yield = string_cat(yield, &size, &ptr, ret, len);
5080 /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
5081 This code originally contributed by Steve Haslam. It currently supports
5082 the use of MD5 and SHA-1 hashes.
5084 We need some workspace that is large enough to handle all the supported
5085 hash types. Use macros to set the sizes rather than be too elaborate. */
5087 #define MAX_HASHLEN 20
5088 #define MAX_HASHBLOCKLEN 64
5097 int hashlen; /* Number of octets for the hash algorithm's output */
5098 int hashblocklen; /* Number of octets the hash algorithm processes */
5100 unsigned int keylen;
5102 uschar keyhash[MAX_HASHLEN];
5103 uschar innerhash[MAX_HASHLEN];
5104 uschar finalhash[MAX_HASHLEN];
5105 uschar finalhash_hex[2*MAX_HASHLEN];
5106 uschar innerkey[MAX_HASHBLOCKLEN];
5107 uschar outerkey[MAX_HASHBLOCKLEN];
5109 switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
5111 case 1: goto EXPAND_FAILED_CURLY;
5113 case 3: goto EXPAND_FAILED;
5116 if (Ustrcmp(sub[0], "md5") == 0)
5119 use_base = &md5_base;
5123 else if (Ustrcmp(sub[0], "sha1") == 0)
5126 use_base = &sha1_base;
5132 expand_string_message =
5133 string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
5138 keylen = Ustrlen(keyptr);
5140 /* If the key is longer than the hash block length, then hash the key
5143 if (keylen > hashblocklen)
5145 chash_start(type, use_base);
5146 chash_end(type, use_base, keyptr, keylen, keyhash);
5151 /* Now make the inner and outer key values */
5153 memset(innerkey, 0x36, hashblocklen);
5154 memset(outerkey, 0x5c, hashblocklen);
5156 for (i = 0; i < keylen; i++)
5158 innerkey[i] ^= keyptr[i];
5159 outerkey[i] ^= keyptr[i];
5162 /* Now do the hashes */
5164 chash_start(type, use_base);
5165 chash_mid(type, use_base, innerkey);
5166 chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
5168 chash_start(type, use_base);
5169 chash_mid(type, use_base, outerkey);
5170 chash_end(type, use_base, innerhash, hashlen, finalhash);
5172 /* Encode the final hash as a hex string */
5175 for (i = 0; i < hashlen; i++)
5177 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
5178 *p++ = hex_digits[finalhash[i] & 0x0f];
5181 DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
5182 (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
5184 yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
5189 /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
5190 We have to save the numerical variables and restore them afterwards. */
5195 int moffset, moffsetextra, slen;
5198 const uschar *rerror;
5201 int save_expand_nmax =
5202 save_expand_strings(save_expand_nstring, save_expand_nlength);
5204 switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg", &resetok))
5206 case 1: goto EXPAND_FAILED_CURLY;
5208 case 3: goto EXPAND_FAILED;
5211 /* Compile the regular expression */
5213 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
5218 expand_string_message = string_sprintf("regular expression error in "
5219 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
5223 /* Now run a loop to do the substitutions as often as necessary. It ends
5224 when there are no more matches. Take care over matches of the null string;
5225 do the same thing as Perl does. */
5228 slen = Ustrlen(sub[0]);
5229 moffset = moffsetextra = 0;
5234 int ovector[3*(EXPAND_MAXN+1)];
5235 int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
5236 PCRE_EOPT | emptyopt, ovector, nelem(ovector));
5240 /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
5241 is not necessarily the end. We want to repeat the match from one
5242 character further along, but leaving the basic offset the same (for
5243 copying below). We can't be at the end of the string - that was checked
5244 before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
5245 finished; copy the remaining string and end the loop. */
5255 yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
5259 /* Match - set up for expanding the replacement. */
5261 if (n == 0) n = EXPAND_MAXN + 1;
5263 for (nn = 0; nn < n*2; nn += 2)
5265 expand_nstring[expand_nmax] = subject + ovector[nn];
5266 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5270 /* Copy the characters before the match, plus the expanded insertion. */
5272 yield = string_cat(yield, &size, &ptr, subject + moffset,
5273 ovector[0] - moffset);
5274 insert = expand_string(sub[2]);
5275 if (insert == NULL) goto EXPAND_FAILED;
5276 yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
5278 moffset = ovector[1];
5282 /* If we have matched an empty string, first check to see if we are at
5283 the end of the subject. If so, the loop is over. Otherwise, mimic
5284 what Perl's /g options does. This turns out to be rather cunning. First
5285 we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
5286 string at the same point. If this fails (picked up above) we advance to
5287 the next character. */
5289 if (ovector[0] == ovector[1])
5291 if (ovector[0] == slen) break;
5292 emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
5296 /* All done - restore numerical variables. */
5298 restore_expand_strings(save_expand_nmax, save_expand_nstring,
5299 save_expand_nlength);
5303 /* Handle keyed and numbered substring extraction. If the first argument
5304 consists entirely of digits, then a numerical extraction is assumed. */
5310 int field_number = 1;
5311 BOOL field_number_set = FALSE;
5312 uschar *save_lookup_value = lookup_value;
5314 int save_expand_nmax =
5315 save_expand_strings(save_expand_nstring, save_expand_nlength);
5317 /* Read the arguments */
5319 for (i = 0; i < j; i++)
5321 while (isspace(*s)) s++;
5322 if (*s == '{') /*}*/
5324 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5325 if (sub[i] == NULL) goto EXPAND_FAILED; /*{*/
5326 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5328 /* After removal of leading and trailing white space, the first
5329 argument must not be empty; if it consists entirely of digits
5330 (optionally preceded by a minus sign), this is a numerical
5331 extraction, and we expect 3 arguments. */
5339 while (isspace(*p)) p++;
5343 while (len > 0 && isspace(p[len-1])) len--;
5350 expand_string_message = US"first argument of \"extract\" must "
5360 while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
5364 j = 3; /* Need 3 args */
5365 field_number_set = TRUE;
5370 else goto EXPAND_FAILED_CURLY;
5373 /* Extract either the numbered or the keyed substring into $value. If
5374 skipping, just pretend the extraction failed. */
5376 lookup_value = skipping? NULL : field_number_set?
5377 expand_gettokened(field_number, sub[1], sub[2]) :
5378 expand_getkeyed(sub[0], sub[1]);
5380 /* If no string follows, $value gets substituted; otherwise there can
5381 be yes/no strings, as for lookup or if. */
5383 switch(process_yesno(
5384 skipping, /* were previously skipping */
5385 lookup_value != NULL, /* success/failure indicator */
5386 save_lookup_value, /* value to reset for string2 */
5387 &s, /* input pointer */
5388 &yield, /* output pointer */
5389 &size, /* output size */
5390 &ptr, /* output current point */
5391 US"extract", /* condition type */
5394 case 1: goto EXPAND_FAILED; /* when all is well, the */
5395 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
5398 /* All done - restore numerical variables. */
5400 restore_expand_strings(save_expand_nmax, save_expand_nstring,
5401 save_expand_nlength);
5406 /* return the Nth item from a list */
5408 case EITEM_LISTEXTRACT:
5411 int field_number = 1;
5412 uschar *save_lookup_value = lookup_value;
5414 int save_expand_nmax =
5415 save_expand_strings(save_expand_nstring, save_expand_nlength);
5417 /* Read the field & list arguments */
5419 for (i = 0; i < 2; i++)
5421 while (isspace(*s)) s++;
5422 if (*s != '{') /*}*/
5423 goto EXPAND_FAILED_CURLY;
5425 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5426 if (!sub[i]) goto EXPAND_FAILED; /*{*/
5427 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5429 /* After removal of leading and trailing white space, the first
5430 argument must be numeric and nonempty. */
5438 while (isspace(*p)) p++;
5442 while (len > 0 && isspace(p[len-1])) len--;
5445 if (!*p && !skipping)
5447 expand_string_message = US"first argument of \"listextract\" must "
5457 while (*p && isdigit(*p)) x = x * 10 + *p++ - '0';
5460 expand_string_message = US"first argument of \"listextract\" must "
5468 /* Extract the numbered element into $value. If
5469 skipping, just pretend the extraction failed. */
5471 lookup_value = skipping? NULL : expand_getlistele(field_number, sub[1]);
5473 /* If no string follows, $value gets substituted; otherwise there can
5474 be yes/no strings, as for lookup or if. */
5476 switch(process_yesno(
5477 skipping, /* were previously skipping */
5478 lookup_value != NULL, /* success/failure indicator */
5479 save_lookup_value, /* value to reset for string2 */
5480 &s, /* input pointer */
5481 &yield, /* output pointer */
5482 &size, /* output size */
5483 &ptr, /* output current point */
5484 US"extract", /* condition type */
5487 case 1: goto EXPAND_FAILED; /* when all is well, the */
5488 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
5491 /* All done - restore numerical variables. */
5493 restore_expand_strings(save_expand_nmax, save_expand_nstring,
5494 save_expand_nlength);
5500 case EITEM_CERTEXTRACT:
5502 uschar *save_lookup_value = lookup_value;
5504 int save_expand_nmax =
5505 save_expand_strings(save_expand_nstring, save_expand_nlength);
5507 /* Read the field argument */
5508 while (isspace(*s)) s++;
5509 if (*s != '{') /*}*/
5510 goto EXPAND_FAILED_CURLY;
5511 sub[0] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5512 if (!sub[0]) goto EXPAND_FAILED; /*{*/
5513 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5514 /* strip spaces fore & aft */
5519 while (isspace(*p)) p++;
5523 while (len > 0 && isspace(p[len-1])) len--;
5527 /* inspect the cert argument */
5528 while (isspace(*s)) s++;
5529 if (*s != '{') /*}*/
5530 goto EXPAND_FAILED_CURLY;
5533 expand_string_message = US"second argument of \"certextract\" must "
5534 "be a certificate variable";
5537 sub[1] = expand_string_internal(s+1, TRUE, &s, skipping, FALSE, &resetok);
5538 if (!sub[1]) goto EXPAND_FAILED; /*{*/
5539 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5542 lookup_value = NULL;
5545 lookup_value = expand_getcertele(sub[0], sub[1]);
5546 if (*expand_string_message) goto EXPAND_FAILED;
5548 switch(process_yesno(
5549 skipping, /* were previously skipping */
5550 lookup_value != NULL, /* success/failure indicator */
5551 save_lookup_value, /* value to reset for string2 */
5552 &s, /* input pointer */
5553 &yield, /* output pointer */
5554 &size, /* output size */
5555 &ptr, /* output current point */
5556 US"extract", /* condition type */
5559 case 1: goto EXPAND_FAILED; /* when all is well, the */
5560 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
5563 restore_expand_strings(save_expand_nmax, save_expand_nstring,
5564 save_expand_nlength);
5567 #endif /*SUPPORT_TLS*/
5569 /* Handle list operations */
5577 uschar outsep[2] = { '\0', '\0' };
5578 const uschar *list, *expr, *temp;
5579 uschar *save_iterate_item = iterate_item;
5580 uschar *save_lookup_value = lookup_value;
5582 while (isspace(*s)) s++;
5583 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5585 list = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5586 if (list == NULL) goto EXPAND_FAILED;
5587 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5589 if (item_type == EITEM_REDUCE)
5592 while (isspace(*s)) s++;
5593 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5594 t = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5595 if (!t) goto EXPAND_FAILED;
5597 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5600 while (isspace(*s)) s++;
5601 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5605 /* For EITEM_FILTER, call eval_condition once, with result discarded (as
5606 if scanning a "false" part). This allows us to find the end of the
5607 condition, because if the list is empty, we won't actually evaluate the
5608 condition for real. For EITEM_MAP and EITEM_REDUCE, do the same, using
5609 the normal internal expansion function. */
5611 if (item_type == EITEM_FILTER)
5613 temp = eval_condition(expr, &resetok, NULL);
5614 if (temp != NULL) s = temp;
5617 temp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
5621 expand_string_message = string_sprintf("%s inside \"%s\" item",
5622 expand_string_message, name);
5626 while (isspace(*s)) s++;
5629 expand_string_message = string_sprintf("missing } at end of condition "
5630 "or expression inside \"%s\"", name);
5634 while (isspace(*s)) s++; /*{*/
5637 expand_string_message = string_sprintf("missing } at end of \"%s\"",
5642 /* If we are skipping, we can now just move on to the next item. When
5643 processing for real, we perform the iteration. */
5645 if (skipping) continue;
5646 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
5648 *outsep = (uschar)sep; /* Separator as a string */
5650 DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
5652 if (item_type == EITEM_FILTER)
5655 if (eval_condition(expr, &resetok, &condresult) == NULL)
5657 iterate_item = save_iterate_item;
5658 lookup_value = save_lookup_value;
5659 expand_string_message = string_sprintf("%s inside \"%s\" condition",
5660 expand_string_message, name);
5663 DEBUG(D_expand) debug_printf("%s: condition is %s\n", name,
5664 condresult? "true":"false");
5666 temp = iterate_item; /* TRUE => include this item */
5668 continue; /* FALSE => skip this item */
5671 /* EITEM_MAP and EITEM_REDUCE */
5675 uschar * t = expand_string_internal(expr, TRUE, NULL, skipping, TRUE, &resetok);
5679 iterate_item = save_iterate_item;
5680 expand_string_message = string_sprintf("%s inside \"%s\" item",
5681 expand_string_message, name);
5684 if (item_type == EITEM_REDUCE)
5686 lookup_value = t; /* Update the value of $value */
5687 continue; /* and continue the iteration */
5691 /* We reach here for FILTER if the condition is true, always for MAP,
5692 and never for REDUCE. The value in "temp" is to be added to the output
5693 list that is being created, ensuring that any occurrences of the
5694 separator character are doubled. Unless we are dealing with the first
5695 item of the output list, add in a space if the new item begins with the
5696 separator character, or is an empty string. */
5698 if (ptr != save_ptr && (temp[0] == *outsep || temp[0] == 0))
5699 yield = string_cat(yield, &size, &ptr, US" ", 1);
5701 /* Add the string in "temp" to the output list that we are building,
5702 This is done in chunks by searching for the separator character. */
5706 size_t seglen = Ustrcspn(temp, outsep);
5707 yield = string_cat(yield, &size, &ptr, temp, seglen + 1);
5709 /* If we got to the end of the string we output one character
5710 too many; backup and end the loop. Otherwise arrange to double the
5713 if (temp[seglen] == '\0') { ptr--; break; }
5714 yield = string_cat(yield, &size, &ptr, outsep, 1);
5718 /* Output a separator after the string: we will remove the redundant
5719 final one at the end. */
5721 yield = string_cat(yield, &size, &ptr, outsep, 1);
5722 } /* End of iteration over the list loop */
5724 /* REDUCE has generated no output above: output the final value of
5727 if (item_type == EITEM_REDUCE)
5729 yield = string_cat(yield, &size, &ptr, lookup_value,
5730 Ustrlen(lookup_value));
5731 lookup_value = save_lookup_value; /* Restore $value */
5734 /* FILTER and MAP generate lists: if they have generated anything, remove
5735 the redundant final separator. Even though an empty item at the end of a
5736 list does not count, this is tidier. */
5738 else if (ptr != save_ptr) ptr--;
5740 /* Restore preserved $item */
5742 iterate_item = save_iterate_item;
5749 const uschar *srclist, *cmp, *xtract;
5751 const uschar *dstlist = NULL, *dstkeylist = NULL;
5753 uschar *save_iterate_item = iterate_item;
5755 while (isspace(*s)) s++;
5756 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5758 srclist = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
5759 if (!srclist) goto EXPAND_FAILED;
5760 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5762 while (isspace(*s)) s++;
5763 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5765 cmp = expand_string_internal(s, TRUE, &s, skipping, FALSE, &resetok);
5766 if (!cmp) goto EXPAND_FAILED;
5767 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5769 while (isspace(*s)) s++;
5770 if (*s++ != '{') goto EXPAND_FAILED_CURLY;
5773 tmp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
5774 if (!tmp) goto EXPAND_FAILED;
5775 xtract = string_copyn(xtract, s - xtract);
5777 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5781 expand_string_message = US"missing } at end of \"sort\"";
5785 if (skipping) continue;
5787 while ((srcitem = string_nextinlist(&srclist, &sep, NULL, 0)))
5790 uschar * newlist = NULL;
5791 uschar * newkeylist = NULL;
5794 DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, srcitem);
5796 /* extract field for comparisons */
5797 iterate_item = srcitem;
5798 if ( !(srcfield = expand_string_internal(xtract, FALSE, NULL, FALSE,
5802 expand_string_message = string_sprintf(
5803 "field-extract in sort: \"%s\"", xtract);
5807 /* Insertion sort */
5809 /* copy output list until new-item < list-item */
5810 while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
5816 /* field for comparison */
5817 if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
5820 /* build and run condition string */
5821 expr = string_sprintf("%s{%s}{%s}", cmp, srcfield, dstfield);
5823 DEBUG(D_expand) debug_printf("%s: cond = \"%s\"\n", name, expr);
5824 if (!eval_condition(expr, &resetok, &before))
5826 expand_string_message = string_sprintf("comparison in sort: %s",
5833 /* New-item sorts before this dst-item. Append new-item,
5834 then dst-item, then remainder of dst list. */
5836 newlist = string_append_listele(newlist, sep, srcitem);
5837 newkeylist = string_append_listele(newkeylist, sep, srcfield);
5840 newlist = string_append_listele(newlist, sep, dstitem);
5841 newkeylist = string_append_listele(newkeylist, sep, dstfield);
5843 while ((dstitem = string_nextinlist(&dstlist, &sep, NULL, 0)))
5845 if (!(dstfield = string_nextinlist(&dstkeylist, &sep, NULL, 0)))
5847 newlist = string_append_listele(newlist, sep, dstitem);
5848 newkeylist = string_append_listele(newkeylist, sep, dstfield);
5854 newlist = string_append_listele(newlist, sep, dstitem);
5855 newkeylist = string_append_listele(newkeylist, sep, dstfield);
5858 /* If we ran out of dstlist without consuming srcitem, append it */
5861 newlist = string_append_listele(newlist, sep, srcitem);
5862 newkeylist = string_append_listele(newkeylist, sep, srcfield);
5866 dstkeylist = newkeylist;
5868 DEBUG(D_expand) debug_printf("%s: dstlist = \"%s\"\n", name, dstlist);
5869 DEBUG(D_expand) debug_printf("%s: dstkeylist = \"%s\"\n", name, dstkeylist);
5873 yield = string_cat(yield, &size, &ptr, dstlist, Ustrlen(dstlist));
5875 /* Restore preserved $item */
5876 iterate_item = save_iterate_item;
5880 expand_string_message = US"Internal error in sort (list mismatch)";
5885 /* If ${dlfunc } support is configured, handle calling dynamically-loaded
5886 functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
5887 or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
5888 a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
5890 #define EXPAND_DLFUNC_MAX_ARGS 8
5893 #ifndef EXPAND_DLFUNC
5894 expand_string_message = US"\"${dlfunc\" encountered, but this facility " /*}*/
5895 "is not included in this binary";
5898 #else /* EXPAND_DLFUNC */
5901 exim_dlfunc_t *func;
5904 uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
5906 if ((expand_forbid & RDO_DLFUNC) != 0)
5908 expand_string_message =
5909 US"dynamically-loaded functions are not permitted";
5913 switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
5914 TRUE, US"dlfunc", &resetok))
5916 case 1: goto EXPAND_FAILED_CURLY;
5918 case 3: goto EXPAND_FAILED;
5921 /* If skipping, we don't actually do anything */
5923 if (skipping) continue;
5925 /* Look up the dynamically loaded object handle in the tree. If it isn't
5926 found, dlopen() the file and put the handle in the tree for next time. */
5928 t = tree_search(dlobj_anchor, argv[0]);
5931 void *handle = dlopen(CS argv[0], RTLD_LAZY);
5934 expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
5935 argv[0], dlerror());
5936 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
5939 t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
5940 Ustrcpy(t->name, argv[0]);
5941 t->data.ptr = handle;
5942 (void)tree_insertnode(&dlobj_anchor, t);
5945 /* Having obtained the dynamically loaded object handle, look up the
5946 function pointer. */
5948 func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
5951 expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
5952 "%s", argv[1], argv[0], dlerror());
5953 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
5957 /* Call the function and work out what to do with the result. If it
5958 returns OK, we have a replacement string; if it returns DEFER then
5959 expansion has failed in a non-forced manner; if it returns FAIL then
5960 failure was forced; if it returns ERROR or any other value there's a
5961 problem, so panic slightly. In any case, assume that the function has
5962 side-effects on the store that must be preserved. */
5966 for (argc = 0; argv[argc] != NULL; argc++);
5967 status = func(&result, argc - 2, &argv[2]);
5970 if (result == NULL) result = US"";
5971 yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
5976 expand_string_message = result == NULL ? US"(no message)" : result;
5977 if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
5978 else if(status != FAIL)
5979 log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
5980 argv[0], argv[1], status, expand_string_message);
5984 #endif /* EXPAND_DLFUNC */
5986 case EITEM_ENV: /* ${env {name} {val_if_found} {val_if_unfound}} */
5989 uschar *save_lookup_value = lookup_value;
5991 while (isspace(*s)) s++;
5992 if (*s != '{') /*}*/
5995 key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
5996 if (!key) goto EXPAND_FAILED; /*{*/
5997 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
5999 lookup_value = US getenv(CS key);
6001 switch(process_yesno(
6002 skipping, /* were previously skipping */
6003 lookup_value != NULL, /* success/failure indicator */
6004 save_lookup_value, /* value to reset for string2 */
6005 &s, /* input pointer */
6006 &yield, /* output pointer */
6007 &size, /* output size */
6008 &ptr, /* output current point */
6009 US"env", /* condition type */
6012 case 1: goto EXPAND_FAILED; /* when all is well, the */
6013 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
6017 } /* EITEM_* switch */
6019 /* Control reaches here if the name is not recognized as one of the more
6020 complicated expansion items. Check for the "operator" syntax (name terminated
6021 by a colon). Some of the operators have arguments, separated by _ from the
6029 var_entry *vp = NULL;
6031 /* Owing to an historical mis-design, an underscore may be part of the
6032 operator name, or it may introduce arguments. We therefore first scan the
6033 table of names that contain underscores. If there is no match, we cut off
6034 the arguments and then scan the main table. */
6036 if ((c = chop_match(name, op_table_underscore,
6037 nelem(op_table_underscore))) < 0)
6039 arg = Ustrchr(name, '_');
6040 if (arg != NULL) *arg = 0;
6041 c = chop_match(name, op_table_main, nelem(op_table_main));
6042 if (c >= 0) c += nelem(op_table_underscore);
6043 if (arg != NULL) *arg++ = '_'; /* Put back for error messages */
6046 /* Deal specially with operators that might take a certificate variable
6047 as we do not want to do the usual expansion. For most, expand the string.*/
6057 const uschar * s1 = s;
6058 sub = expand_string_internal(s+2, TRUE, &s1, skipping,
6060 if (!sub) goto EXPAND_FAILED; /*{*/
6061 if (*s1 != '}') goto EXPAND_FAILED_CURLY;
6062 if ((vp = find_var_ent(sub)) && vp->type == vtype_cert)
6072 sub = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
6073 if (!sub) goto EXPAND_FAILED;
6078 /* If we are skipping, we don't need to perform the operation at all.
6079 This matters for operations like "mask", because the data may not be
6080 in the correct format when skipping. For example, the expression may test
6081 for the existence of $sender_host_address before trying to mask it. For
6082 other operations, doing them may not fail, but it is a waste of time. */
6084 if (skipping && c >= 0) continue;
6086 /* Otherwise, switch on the operator type */
6093 unsigned long int n = Ustrtoul(sub, &t, 10);
6096 expand_string_message = string_sprintf("argument for base62 "
6097 "operator is \"%s\", which is not a decimal number", sub);
6100 t = string_base62(n);
6101 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
6105 /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
6111 unsigned long int n = 0;
6114 uschar *t = Ustrchr(base62_chars, *tt++);
6117 expand_string_message = string_sprintf("argument for base62d "
6118 "operator is \"%s\", which is not a base %d number", sub,
6122 n = n * BASE_62 + (t - base62_chars);
6124 (void)sprintf(CS buf, "%ld", n);
6125 yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
6131 uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping, TRUE, &resetok);
6132 if (expanded == NULL)
6134 expand_string_message =
6135 string_sprintf("internal expansion of \"%s\" failed: %s", sub,
6136 expand_string_message);
6139 yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
6146 uschar *t = sub - 1;
6147 while (*(++t) != 0) { *t = tolower(*t); count++; }
6148 yield = string_cat(yield, &size, &ptr, sub, count);
6155 uschar *t = sub - 1;
6156 while (*(++t) != 0) { *t = toupper(*t); count++; }
6157 yield = string_cat(yield, &size, &ptr, sub, count);
6163 if (vp && *(void **)vp->value)
6165 uschar * cp = tls_cert_fprt_md5(*(void **)vp->value);
6166 yield = string_cat(yield, &size, &ptr, cp, Ustrlen(cp));
6176 md5_end(&base, sub, Ustrlen(sub), digest);
6177 for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
6178 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
6184 if (vp && *(void **)vp->value)
6186 uschar * cp = tls_cert_fprt_sha1(*(void **)vp->value);
6187 yield = string_cat(yield, &size, &ptr, cp, Ustrlen(cp));
6197 sha1_end(&base, sub, Ustrlen(sub), digest);
6198 for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
6199 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
6205 if (vp && *(void **)vp->value)
6207 uschar * cp = tls_cert_fprt_sha256(*(void **)vp->value);
6208 yield = string_cat(yield, &size, &ptr, cp, (int)Ustrlen(cp));
6212 expand_string_message = US"sha256 only supported for certificates";
6215 /* Convert hex encoding to base64 encoding */
6225 for (enc = sub; *enc != 0; enc++)
6227 if (!isxdigit(*enc))
6229 expand_string_message = string_sprintf("\"%s\" is not a hex "
6238 expand_string_message = string_sprintf("\"%s\" contains an odd "
6239 "number of characters", sub);
6243 while ((c = *in++) != 0)
6245 if (isdigit(c)) c -= '0';
6246 else c = toupper(c) - 'A' + 10;
6258 enc = b64encode(sub, out - sub);
6259 yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
6263 /* Convert octets outside 0x21..0x7E to \xXX form */
6267 uschar *t = sub - 1;
6270 if (*t < 0x21 || 0x7E < *t)
6271 yield = string_cat(yield, &size, &ptr,
6272 string_sprintf("\\x%02x", *t), 4);
6274 yield = string_cat(yield, &size, &ptr, t, 1);
6279 /* count the number of list elements */
6288 while (string_nextinlist(CUSS &sub, &sep, buffer, sizeof(buffer)) != NULL) cnt++;
6289 cp = string_sprintf("%d", cnt);
6290 yield = string_cat(yield, &size, &ptr, cp, Ustrlen(cp));
6294 /* expand a named list given the name */
6295 /* handles nested named lists; requotes as colon-sep list */
6299 tree_node *t = NULL;
6300 const uschar * list;
6303 uschar * suffix = US"";
6304 BOOL needsep = FALSE;
6307 if (*sub == '+') sub++;
6308 if (arg == NULL) /* no-argument version */
6310 if (!(t = tree_search(addresslist_anchor, sub)) &&
6311 !(t = tree_search(domainlist_anchor, sub)) &&
6312 !(t = tree_search(hostlist_anchor, sub)))
6313 t = tree_search(localpartlist_anchor, sub);
6315 else switch(*arg) /* specific list-type version */
6317 case 'a': t = tree_search(addresslist_anchor, sub); suffix = US"_a"; break;
6318 case 'd': t = tree_search(domainlist_anchor, sub); suffix = US"_d"; break;
6319 case 'h': t = tree_search(hostlist_anchor, sub); suffix = US"_h"; break;
6320 case 'l': t = tree_search(localpartlist_anchor, sub); suffix = US"_l"; break;
6322 expand_string_message = string_sprintf("bad suffix on \"list\" operator");
6328 expand_string_message = string_sprintf("\"%s\" is not a %snamed list",
6330 : *arg=='a'?"address "
6331 : *arg=='d'?"domain "
6333 : *arg=='l'?"localpart "
6338 list = ((namedlist_block *)(t->data.ptr))->string;
6340 while ((item = string_nextinlist(&list, &sep, buffer, sizeof(buffer))) != NULL)
6342 uschar * buf = US" : ";
6344 yield = string_cat(yield, &size, &ptr, buf, 3);
6348 if (*item == '+') /* list item is itself a named list */
6350 uschar * sub = string_sprintf("${listnamed%s:%s}", suffix, item);
6351 item = expand_string_internal(sub, FALSE, NULL, FALSE, TRUE, &resetok);
6353 else if (sep != ':') /* item from non-colon-sep list, re-quote for colon list-separator */
6357 tok[0] = sep; tok[1] = ':'; tok[2] = 0;
6358 while ((cp= strpbrk((const char *)item, tok)))
6360 yield = string_cat(yield, &size, &ptr, item, cp-(char *)item);
6361 if (*cp++ == ':') /* colon in a non-colon-sep list item, needs doubling */
6363 yield = string_cat(yield, &size, &ptr, US"::", 2);
6364 item = (uschar *)cp;
6366 else /* sep in item; should already be doubled; emit once */
6368 yield = string_cat(yield, &size, &ptr, (uschar *)tok, 1);
6369 if (*cp == sep) cp++;
6370 item = (uschar *)cp;
6374 yield = string_cat(yield, &size, &ptr, item, Ustrlen(item));
6379 /* mask applies a mask to an IP address; for example the result of
6380 ${mask:131.111.10.206/28} is 131.111.10.192/28. */
6387 int mask, maskoffset;
6388 int type = string_is_ip_address(sub, &maskoffset);
6393 expand_string_message = string_sprintf("\"%s\" is not an IP address",
6398 if (maskoffset == 0)
6400 expand_string_message = string_sprintf("missing mask value in \"%s\"",
6405 mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
6407 if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
6409 expand_string_message = string_sprintf("mask value too big in \"%s\"",
6414 /* Convert the address to binary integer(s) and apply the mask */
6416 sub[maskoffset] = 0;
6417 count = host_aton(sub, binary);
6418 host_mask(count, binary, mask);
6420 /* Convert to masked textual format and add to output. */
6422 yield = string_cat(yield, &size, &ptr, buffer,
6423 host_nmtoa(count, binary, mask, buffer, '.'));
6428 case EOP_IPV6DENORM:
6430 int type = string_is_ip_address(sub, NULL);
6437 (void) host_aton(sub, binary);
6440 case 4: /* convert to IPv4-mapped IPv6 */
6441 binary[0] = binary[1] = 0;
6442 binary[2] = 0x0000ffff;
6443 (void) host_aton(sub, binary+3);
6447 expand_string_message =
6448 string_sprintf("\"%s\" is not an IP address", sub);
6452 yield = string_cat(yield, &size, &ptr, buffer,
6454 ? ipv6_nmtoa(binary, buffer)
6455 : host_nmtoa(4, binary, -1, buffer, ':')
6461 case EOP_LOCAL_PART:
6465 int start, end, domain;
6466 uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
6470 if (c != EOP_DOMAIN)
6472 if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
6473 yield = string_cat(yield, &size, &ptr, sub+start, end-start);
6475 else if (domain != 0)
6478 yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
6486 uschar outsep[2] = { ':', '\0' };
6487 uschar *address, *error;
6489 int start, end, domain; /* Not really used */
6491 while (isspace(*sub)) sub++;
6492 if (*sub == '>') { *outsep = *++sub; ++sub; }
6493 parse_allow_group = TRUE;
6497 uschar *p = parse_find_address_end(sub, FALSE);
6498 uschar saveend = *p;
6500 address = parse_extract_address(sub, &error, &start, &end, &domain,
6504 /* Add the address to the output list that we are building. This is
6505 done in chunks by searching for the separator character. At the
6506 start, unless we are dealing with the first address of the output
6507 list, add in a space if the new address begins with the separator
6508 character, or is an empty string. */
6510 if (address != NULL)
6512 if (ptr != save_ptr && address[0] == *outsep)
6513 yield = string_cat(yield, &size, &ptr, US" ", 1);
6517 size_t seglen = Ustrcspn(address, outsep);
6518 yield = string_cat(yield, &size, &ptr, address, seglen + 1);
6520 /* If we got to the end of the string we output one character
6523 if (address[seglen] == '\0') { ptr--; break; }
6524 yield = string_cat(yield, &size, &ptr, outsep, 1);
6525 address += seglen + 1;
6528 /* Output a separator after the string: we will remove the
6529 redundant final one at the end. */
6531 yield = string_cat(yield, &size, &ptr, outsep, 1);
6534 if (saveend == '\0') break;
6538 /* If we have generated anything, remove the redundant final
6541 if (ptr != save_ptr) ptr--;
6542 parse_allow_group = FALSE;
6547 /* quote puts a string in quotes if it is empty or contains anything
6548 other than alphamerics, underscore, dot, or hyphen.
6550 quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
6551 be quoted in order to be a valid local part.
6553 In both cases, newlines and carriage returns are converted into \n and \r
6557 case EOP_QUOTE_LOCAL_PART:
6560 BOOL needs_quote = (*sub == 0); /* TRUE for empty string */
6561 uschar *t = sub - 1;
6565 while (!needs_quote && *(++t) != 0)
6566 needs_quote = !isalnum(*t) && !strchr("_-.", *t);
6568 else /* EOP_QUOTE_LOCAL_PART */
6570 while (!needs_quote && *(++t) != 0)
6571 needs_quote = !isalnum(*t) &&
6572 strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
6573 (*t != '.' || t == sub || t[1] == 0);
6578 yield = string_cat(yield, &size, &ptr, US"\"", 1);
6583 yield = string_cat(yield, &size, &ptr, US"\\n", 2);
6584 else if (*t == '\r')
6585 yield = string_cat(yield, &size, &ptr, US"\\r", 2);
6588 if (*t == '\\' || *t == '"')
6589 yield = string_cat(yield, &size, &ptr, US"\\", 1);
6590 yield = string_cat(yield, &size, &ptr, t, 1);
6593 yield = string_cat(yield, &size, &ptr, US"\"", 1);
6595 else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
6599 /* quote_lookuptype does lookup-specific quoting */
6604 uschar *opt = Ustrchr(arg, '_');
6606 if (opt != NULL) *opt++ = 0;
6608 n = search_findtype(arg, Ustrlen(arg));
6611 expand_string_message = search_error_message;
6615 if (lookup_list[n]->quote != NULL)
6616 sub = (lookup_list[n]->quote)(sub, opt);
6617 else if (opt != NULL) sub = NULL;
6621 expand_string_message = string_sprintf(
6622 "\"%s\" unrecognized after \"${quote_%s\"",
6627 yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
6631 /* rx quote sticks in \ before any non-alphameric character so that
6632 the insertion works in a regular expression. */
6636 uschar *t = sub - 1;
6640 yield = string_cat(yield, &size, &ptr, US"\\", 1);
6641 yield = string_cat(yield, &size, &ptr, t, 1);
6646 /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
6647 prescribed by the RFC, if there are characters that need to be encoded */
6651 uschar buffer[2048];
6652 const uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
6653 buffer, sizeof(buffer), FALSE);
6654 yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
6658 /* RFC 2047 decode */
6664 uschar *decoded = rfc2047_decode(sub, check_rfc2047_length,
6665 headers_charset, '?', &len, &error);
6668 expand_string_message = error;
6671 yield = string_cat(yield, &size, &ptr, decoded, len);
6675 /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
6685 if (c > 255) c = '_';
6687 yield = string_cat(yield, &size, &ptr, buff, 1);
6692 /* replace illegal UTF-8 sequences by replacement character */
6694 #define UTF8_REPLACEMENT_CHAR US"?"
6698 int seq_len = 0, index = 0;
6700 long codepoint = -1;
6701 uschar seq_buff[4]; /* accumulate utf-8 here */
6710 if ((c & 0xc0) != 0x80)
6711 /* wrong continuation byte; invalidate all bytes */
6712 complete = 1; /* error */
6715 codepoint = (codepoint << 6) | (c & 0x3f);
6716 seq_buff[index++] = c;
6717 if (--bytes_left == 0) /* codepoint complete */
6718 if(codepoint > 0x10FFFF) /* is it too large? */
6719 complete = -1; /* error (RFC3629 limit) */
6721 { /* finished; output utf-8 sequence */
6722 yield = string_cat(yield, &size, &ptr, seq_buff, seq_len);
6727 else /* no bytes left: new sequence */
6729 if((c & 0x80) == 0) /* 1-byte sequence, US-ASCII, keep it */
6731 yield = string_cat(yield, &size, &ptr, &c, 1);
6734 if((c & 0xe0) == 0xc0) /* 2-byte sequence */
6736 if(c == 0xc0 || c == 0xc1) /* 0xc0 and 0xc1 are illegal */
6741 codepoint = c & 0x1f;
6744 else if((c & 0xf0) == 0xe0) /* 3-byte sequence */
6747 codepoint = c & 0x0f;
6749 else if((c & 0xf8) == 0xf0) /* 4-byte sequence */
6752 codepoint = c & 0x07;
6754 else /* invalid or too long (RFC3629 allows only 4 bytes) */
6757 seq_buff[index++] = c;
6758 seq_len = bytes_left + 1;
6759 } /* if(bytes_left) */
6763 bytes_left = index = 0;
6764 yield = string_cat(yield, &size, &ptr, UTF8_REPLACEMENT_CHAR, 1);
6766 if ((complete == 1) && ((c & 0x80) == 0))
6767 /* ASCII character follows incomplete sequence */
6768 yield = string_cat(yield, &size, &ptr, &c, 1);
6774 case EOP_UTF8_DOMAIN_TO_ALABEL:
6776 uschar * error = NULL;
6777 uschar * s = string_domain_utf8_to_alabel(sub, &error);
6780 expand_string_message = string_sprintf(
6781 "error converting utf8 (%s) to alabel: %s",
6782 string_printing(sub), error);
6785 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6789 case EOP_UTF8_DOMAIN_FROM_ALABEL:
6791 uschar * error = NULL;
6792 uschar * s = string_domain_alabel_to_utf8(sub, &error);
6795 expand_string_message = string_sprintf(
6796 "error converting alabel (%s) to utf8: %s",
6797 string_printing(sub), error);
6800 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6804 case EOP_UTF8_LOCALPART_TO_ALABEL:
6806 uschar * error = NULL;
6807 uschar * s = string_localpart_utf8_to_alabel(sub, &error);
6810 expand_string_message = string_sprintf(
6811 "error converting utf8 (%s) to alabel: %s",
6812 string_printing(sub), error);
6815 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6816 DEBUG(D_expand) debug_printf("yield: '%s'\n", yield);
6820 case EOP_UTF8_LOCALPART_FROM_ALABEL:
6822 uschar * error = NULL;
6823 uschar * s = string_localpart_alabel_to_utf8(sub, &error);
6826 expand_string_message = string_sprintf(
6827 "error converting alabel (%s) to utf8: %s",
6828 string_printing(sub), error);
6831 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6834 #endif /* EXPERIMENTAL_INTERNATIONAL */
6836 /* escape turns all non-printing characters into escape sequences. */
6840 const uschar *t = string_printing(sub);
6841 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
6845 /* Handle numeric expression evaluation */
6850 uschar *save_sub = sub;
6851 uschar *error = NULL;
6852 int_eximarith_t n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
6855 expand_string_message = string_sprintf("error in expression "
6856 "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
6860 sprintf(CS var_buffer, PR_EXIM_ARITH, n);
6861 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
6865 /* Handle time period formating */
6869 int n = readconf_readtime(sub, 0, FALSE);
6872 expand_string_message = string_sprintf("string \"%s\" is not an "
6873 "Exim time interval in \"%s\" operator", sub, name);
6876 sprintf(CS var_buffer, "%d", n);
6877 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
6881 case EOP_TIME_INTERVAL:
6884 uschar *t = read_number(&n, sub);
6885 if (*t != 0) /* Not A Number*/
6887 expand_string_message = string_sprintf("string \"%s\" is not a "
6888 "positive number in \"%s\" operator", sub, name);
6891 t = readconf_printtime(n);
6892 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
6896 /* Convert string to base64 encoding */
6902 uschar * s = vp && *(void **)vp->value
6903 ? tls_cert_der_b64(*(void **)vp->value)
6904 : b64encode(sub, Ustrlen(sub));
6906 uschar * s = b64encode(sub, Ustrlen(sub));
6908 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6915 int len = b64decode(sub, &s);
6918 expand_string_message = string_sprintf("string \"%s\" is not "
6919 "well-formed for \"%s\" operator", sub, name);
6922 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
6926 /* strlen returns the length of the string */
6931 (void)sprintf(CS buff, "%d", Ustrlen(sub));
6932 yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
6936 /* length_n or l_n takes just the first n characters or the whole string,
6937 whichever is the shorter;
6939 substr_m_n, and s_m_n take n characters from offset m; negative m take
6940 from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
6941 takes the rest, either to the right or to the left.
6943 hash_n or h_n makes a hash of length n from the string, yielding n
6944 characters from the set a-z; hash_n_m makes a hash of length n, but
6945 uses m characters from the set a-zA-Z0-9.
6947 nhash_n returns a single number between 0 and n-1 (in text form), while
6948 nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
6949 between 0 and n-1 and the second between 0 and m-1. */
6969 expand_string_message = string_sprintf("missing values after %s",
6974 /* "length" has only one argument, effectively being synonymous with
6977 if (c == EOP_LENGTH || c == EOP_L)
6983 /* The others have one or two arguments; for "substr" the first may be
6984 negative. The second being negative means "not supplied". */
6989 if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
6992 /* Read up to two numbers, separated by underscores */
6997 if (arg != ret && *arg == '_' && pn == &value1)
7001 if (arg[1] != 0) arg++;
7003 else if (!isdigit(*arg))
7005 expand_string_message =
7006 string_sprintf("non-digit after underscore in \"%s\"", name);
7009 else *pn = (*pn)*10 + *arg++ - '0';
7013 /* Perform the required operation */
7016 (c == EOP_HASH || c == EOP_H)?
7017 compute_hash(sub, value1, value2, &len) :
7018 (c == EOP_NHASH || c == EOP_NH)?
7019 compute_nhash(sub, value1, value2, &len) :
7020 extract_substr(sub, value1, value2, &len);
7022 if (ret == NULL) goto EXPAND_FAILED;
7023 yield = string_cat(yield, &size, &ptr, ret, len);
7033 uschar **modetable[3];
7038 if ((expand_forbid & RDO_EXISTS) != 0)
7040 expand_string_message = US"Use of the stat() expansion is not permitted";
7044 if (stat(CS sub, &st) < 0)
7046 expand_string_message = string_sprintf("stat(%s) failed: %s",
7047 sub, strerror(errno));
7051 switch (mode & S_IFMT)
7053 case S_IFIFO: smode[0] = 'p'; break;
7054 case S_IFCHR: smode[0] = 'c'; break;
7055 case S_IFDIR: smode[0] = 'd'; break;
7056 case S_IFBLK: smode[0] = 'b'; break;
7057 case S_IFREG: smode[0] = '-'; break;
7058 default: smode[0] = '?'; break;
7061 modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
7062 modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
7063 modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
7065 for (i = 0; i < 3; i++)
7067 memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
7072 s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
7073 "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
7074 (long)(st.st_mode & 077777), smode, (long)st.st_ino,
7075 (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
7076 (long)st.st_gid, st.st_size, (long)st.st_atime,
7077 (long)st.st_mtime, (long)st.st_ctime);
7078 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
7082 /* vaguely random number less than N */
7086 int_eximarith_t max;
7089 max = expanded_string_integer(sub, TRUE);
7090 if (expand_string_message != NULL)
7092 s = string_sprintf("%d", vaguely_random_number((int)max));
7093 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
7097 /* Reverse IP, including IPv6 to dotted-nibble */
7099 case EOP_REVERSE_IP:
7101 int family, maskptr;
7102 uschar reversed[128];
7104 family = string_is_ip_address(sub, &maskptr);
7107 expand_string_message = string_sprintf(
7108 "reverse_ip() not given an IP address [%s]", sub);
7111 invert_address(reversed, sub);
7112 yield = string_cat(yield, &size, &ptr, reversed, Ustrlen(reversed));
7116 /* Unknown operator */
7119 expand_string_message =
7120 string_sprintf("unknown expansion operator \"%s\"", name);
7125 /* Handle a plain name. If this is the first thing in the expansion, release
7126 the pre-allocated buffer. If the result data is known to be in a new buffer,
7127 newsize will be set to the size of that buffer, and we can just point at that
7128 store instead of copying. Many expansion strings contain just one reference,
7129 so this is a useful optimization, especially for humungous headers
7130 ($message_headers). */
7138 if (resetok) store_reset(yield);
7142 value = find_variable(name, FALSE, skipping, &newsize);
7145 expand_string_message =
7146 string_sprintf("unknown variable in \"${%s}\"", name);
7147 check_variable_error_message(name);
7150 len = Ustrlen(value);
7151 if (yield == NULL && newsize != 0)
7157 else yield = string_cat(yield, &size, &ptr, value, len);
7161 /* Else there's something wrong */
7163 expand_string_message =
7164 string_sprintf("\"${%s\" is not a known operator (or a } is missing "
7165 "in a variable reference)", name);
7169 /* If we hit the end of the string when ket_ends is set, there is a missing
7170 terminating brace. */
7172 if (ket_ends && *s == 0)
7174 expand_string_message = malformed_header?
7175 US"missing } at end of string - could be header name not terminated by colon"
7177 US"missing } at end of string";
7181 /* Expansion succeeded; yield may still be NULL here if nothing was actually
7182 added to the string. If so, set up an empty string. Add a terminating zero. If
7183 left != NULL, return a pointer to the terminator. */
7185 if (yield == NULL) yield = store_get(1);
7187 if (left != NULL) *left = s;
7189 /* Any stacking store that was used above the final string is no longer needed.
7190 In many cases the final string will be the first one that was got and so there
7191 will be optimal store usage. */
7193 if (resetok) store_reset(yield + ptr + 1);
7194 else if (resetok_p) *resetok_p = FALSE;
7198 debug_printf("expanding: %.*s\n result: %s\n", (int)(s - string), string,
7200 if (skipping) debug_printf("skipping: result is not used\n");
7204 /* This is the failure exit: easiest to program with a goto. We still need
7205 to update the pointer to the terminator, for cases of nested calls with "fail".
7208 EXPAND_FAILED_CURLY:
7209 expand_string_message = malformed_header?
7210 US"missing or misplaced { or } - could be header name not terminated by colon"
7212 US"missing or misplaced { or }";
7214 /* At one point, Exim reset the store to yield (if yield was not NULL), but
7215 that is a bad idea, because expand_string_message is in dynamic store. */
7218 if (left != NULL) *left = s;
7221 debug_printf("failed to expand: %s\n", string);
7222 debug_printf(" error message: %s\n", expand_string_message);
7223 if (expand_string_forcedfail) debug_printf("failure was forced\n");
7225 if (resetok_p) *resetok_p = resetok;
7230 /* This is the external function call. Do a quick check for any expansion
7231 metacharacters, and if there are none, just return the input string.
7233 Argument: the string to be expanded
7234 Returns: the expanded string, or NULL if expansion failed; if failure was
7235 due to a lookup deferring, search_find_defer will be TRUE
7239 expand_string(uschar *string)
7241 search_find_defer = FALSE;
7242 malformed_header = FALSE;
7243 return (Ustrpbrk(string, "$\\") == NULL)? string :
7244 expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
7250 expand_cstring(const uschar *string)
7252 search_find_defer = FALSE;
7253 malformed_header = FALSE;
7254 return (Ustrpbrk(string, "$\\") == NULL)? string :
7255 expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
7260 /*************************************************
7262 *************************************************/
7264 /* Now and again we want to expand a string and be sure that the result is in a
7265 new bit of store. This function does that.
7266 Since we know it has been copied, the de-const cast is safe.
7268 Argument: the string to be expanded
7269 Returns: the expanded string, always in a new bit of store, or NULL
7273 expand_string_copy(const uschar *string)
7275 const uschar *yield = expand_cstring(string);
7276 if (yield == string) yield = string_copy(string);
7282 /*************************************************
7283 * Expand and interpret as an integer *
7284 *************************************************/
7286 /* Expand a string, and convert the result into an integer.
7289 string the string to be expanded
7290 isplus TRUE if a non-negative number is expected
7292 Returns: the integer value, or
7293 -1 for an expansion error ) in both cases, message in
7294 -2 for an integer interpretation error ) expand_string_message
7295 expand_string_message is set NULL for an OK integer
7299 expand_string_integer(uschar *string, BOOL isplus)
7301 return expanded_string_integer(expand_string(string), isplus);
7305 /*************************************************
7306 * Interpret string as an integer *
7307 *************************************************/
7309 /* Convert a string (that has already been expanded) into an integer.
7311 This function is used inside the expansion code.
7314 s the string to be expanded
7315 isplus TRUE if a non-negative number is expected
7317 Returns: the integer value, or
7318 -1 if string is NULL (which implies an expansion error)
7319 -2 for an integer interpretation error
7320 expand_string_message is set NULL for an OK integer
7323 static int_eximarith_t
7324 expanded_string_integer(const uschar *s, BOOL isplus)
7326 int_eximarith_t value;
7327 uschar *msg = US"invalid integer \"%s\"";
7330 /* If expansion failed, expand_string_message will be set. */
7332 if (s == NULL) return -1;
7334 /* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
7335 to ERANGE. When there isn't an overflow, errno is not changed, at least on some
7336 systems, so we set it zero ourselves. */
7339 expand_string_message = NULL; /* Indicates no error */
7341 /* Before Exim 4.64, strings consisting entirely of whitespace compared
7342 equal to 0. Unfortunately, people actually relied upon that, so preserve
7343 the behaviour explicitly. Stripping leading whitespace is a harmless
7344 noop change since strtol skips it anyway (provided that there is a number
7348 while (isspace(*s)) ++s;
7352 debug_printf("treating blank string as number 0\n");
7357 value = strtoll(CS s, CSS &endptr, 10);
7361 msg = US"integer expected but \"%s\" found";
7363 else if (value < 0 && isplus)
7365 msg = US"non-negative integer expected but \"%s\" found";
7369 switch (tolower(*endptr))
7374 if (value > EXIM_ARITH_MAX/1024 || value < EXIM_ARITH_MIN/1024) errno = ERANGE;
7379 if (value > EXIM_ARITH_MAX/(1024*1024) || value < EXIM_ARITH_MIN/(1024*1024)) errno = ERANGE;
7380 else value *= 1024*1024;
7384 if (value > EXIM_ARITH_MAX/(1024*1024*1024) || value < EXIM_ARITH_MIN/(1024*1024*1024)) errno = ERANGE;
7385 else value *= 1024*1024*1024;
7389 if (errno == ERANGE)
7390 msg = US"absolute value of integer \"%s\" is too large (overflow)";
7393 while (isspace(*endptr)) endptr++;
7394 if (*endptr == 0) return value;
7398 expand_string_message = string_sprintf(CS msg, s);
7403 /* These values are usually fixed boolean values, but they are permitted to be
7407 addr address being routed
7408 mtype the module type
7409 mname the module name
7410 dbg_opt debug selectors
7411 oname the option name
7412 bvalue the router's boolean value
7413 svalue the router's string value
7414 rvalue where to put the returned value
7416 Returns: OK value placed in rvalue
7417 DEFER expansion failed
7421 exp_bool(address_item *addr,
7422 uschar *mtype, uschar *mname, unsigned dbg_opt,
7423 uschar *oname, BOOL bvalue,
7424 uschar *svalue, BOOL *rvalue)
7427 if (svalue == NULL) { *rvalue = bvalue; return OK; }
7429 expanded = expand_string(svalue);
7430 if (expanded == NULL)
7432 if (expand_string_forcedfail)
7434 DEBUG(dbg_opt) debug_printf("expansion of \"%s\" forced failure\n", oname);
7438 addr->message = string_sprintf("failed to expand \"%s\" in %s %s: %s",
7439 oname, mname, mtype, expand_string_message);
7440 DEBUG(dbg_opt) debug_printf("%s\n", addr->message);
7444 DEBUG(dbg_opt) debug_printf("expansion of \"%s\" yields \"%s\"\n", oname,
7447 if (strcmpic(expanded, US"true") == 0 || strcmpic(expanded, US"yes") == 0)
7449 else if (strcmpic(expanded, US"false") == 0 || strcmpic(expanded, US"no") == 0)
7453 addr->message = string_sprintf("\"%s\" is not a valid value for the "
7454 "\"%s\" option in the %s %s", expanded, oname, mname, mtype);
7464 /*************************************************
7465 **************************************************
7466 * Stand-alone test program *
7467 **************************************************
7468 *************************************************/
7474 regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
7476 int ovector[3*(EXPAND_MAXN+1)];
7477 int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
7478 ovector, nelem(ovector));
7479 BOOL yield = n >= 0;
7480 if (n == 0) n = EXPAND_MAXN + 1;
7484 expand_nmax = (setup < 0)? 0 : setup + 1;
7485 for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
7487 expand_nstring[expand_nmax] = subject + ovector[nn];
7488 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
7496 int main(int argc, uschar **argv)
7499 uschar buffer[1024];
7501 debug_selector = D_v;
7502 debug_file = stderr;
7503 debug_fd = fileno(debug_file);
7504 big_buffer = malloc(big_buffer_size);
7506 for (i = 1; i < argc; i++)
7508 if (argv[i][0] == '+')
7510 debug_trace_memory = 2;
7513 if (isdigit(argv[i][0]))
7514 debug_selector = Ustrtol(argv[i], NULL, 0);
7516 if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
7520 eldap_default_servers = argv[i];
7523 mysql_servers = argv[i];
7526 pgsql_servers = argv[i];
7529 redis_servers = argv[i];
7533 else opt_perl_startup = argv[i];
7537 printf("Testing string expansion: debug_level = %d\n\n", debug_level);
7539 expand_nstring[1] = US"string 1....";
7540 expand_nlength[1] = 8;
7544 if (opt_perl_startup != NULL)
7547 printf("Starting Perl interpreter\n");
7548 errstr = init_perl(opt_perl_startup);
7551 printf("** error in perl_startup code: %s\n", errstr);
7552 return EXIT_FAILURE;
7555 #endif /* EXIM_PERL */
7557 while (fgets(buffer, sizeof(buffer), stdin) != NULL)
7559 void *reset_point = store_get(0);
7560 uschar *yield = expand_string(buffer);
7563 printf("%s\n", yield);
7564 store_reset(reset_point);
7568 if (search_find_defer) printf("search_find deferred\n");
7569 printf("Failed: %s\n", expand_string_message);
7570 if (expand_string_forcedfail) printf("Forced failure\n");
7584 /* End of expand.c */