. Update the Copyright year (only) when changing content.
. /////////////////////////////////////////////////////////////////////////////
-.set previousversion "4.95"
+.set previousversion "4.96"
.include ./local_params
.set ACL "access control lists (ACLs)"
To complicate things further, there are several very different versions of the
Berkeley DB package. Version 1.85 was stable for a very long time, releases
2.&'x'& and 3.&'x'& were current for a while,
-.new
but the latest versions when Exim last revamped support were numbered 5.&'x'&.
Maintenance of some of the earlier releases has ceased,
and Exim no longer supports versions before 3.&'x'&.
-.wen
All versions of Berkeley DB could be obtained from
&url(http://www.sleepycat.com/), which is now a redirect to their new owner's
page with far newer versions listed.
.endd
Similarly, for gdbm you set USE_GDBM, and for tdb you set USE_TDB. An
error is diagnosed if you set more than one of these.
-.new
You can set USE_NDBM if needed to override an operating system default.
-.wen
At the lowest level, the build-time configuration sets none of these options,
thereby assuming an interface of type (1). However, some operating system
DBMLIB = -ltdb
DBMLIB = -lgdbm -lgdbm_compat
.endd
-.new
The last of those was for a Linux having GDBM provide emulated NDBM facilities.
-.wen
Settings like that will work if the DBM library is installed in the standard
place. Sometimes it is not, and the library's header file may also not be in
the default path. You may need to set INCLUDE to specify where the header
domains = lsearch;/some/file
.endd
The first uses a string expansion, the result of which must be a domain list.
-.new
The key for an expansion-style lookup must be given explicitly.
-.wen
No strings have been specified for a successful or a failing lookup; the
defaults in this case are the looked-up data and an empty string, respectively.
The expansion takes place before the string is processed as a list, and the
Any data that follows the keys is not relevant when checking that the domain
matches the list item.
-.new
The key for a list-style lookup is implicit, from the lookup context, if
the lookup is a single-key type (see below).
For query-style lookup types the key must be given explicitly.
-.wen
It is possible, though no doubt confusing, to use both kinds of lookup at once.
Consider a file containing lines like this:
key value is assumed by Exim for query-style lookups. You can use whichever
Exim variables you need to construct the database query.
.cindex "tainted data" "quoting for lookups"
-.new
If tainted data is used in the query then it should be quuted by
using the &*${quote_*&<&'lookup-type'&>&*:*&<&'string'&>&*}*& expansion operator
appropriate for the lookup.
-.wen
.endlist
The code for each lookup type is in a separate source file that is included in
.cindex "expansion" "running a command"
.cindex "&%run%& expansion item"
This item runs an external command, as a subprocess.
-.new
One option is supported after the word &'run'&, comma-separated.
If the option &'preexpand'& is not used,
a careful assessment for security vulnerabilities should be done.
If the option &'preexpand'& is used,
-.wen
the command and its arguments are first expanded as one string. The result is
split apart into individual arguments by spaces, and then the command is run
as above.
around the command arguments. A possible guard against this is to wrap the
variable in the &%sg%& operator to change any quote marks to some other
character.
-.new
Neither the command nor any argument may be tainted.
-.wen
The standard input for the command exists, but is empty. The standard output
and standard error are set to the same file descriptor.
Since this operation is expected to
be mostly used for looking up masked addresses in files, the
-.new
normal
-.wen
result for an IPv6
address uses dots to separate components instead of colons, because colon
terminates a key string in lsearch files. So, for example,
.code
3ffe.ffff.836f.0a00.000a.0800.2000.0000/99
.endd
-.new
If the optional form &*mask_n*& is used, IPv6 address result are instead
returned in normailsed form, using colons and with zero-compression.
-.wen
Letters in IPv6 addresses are always output in lower case.
${if forany{fOo:NeeDLE:bAr}{eqi{$item}{Needle}}}
.endd
-.new
The variable &$value$& will be set for a successful match and can be
used in the success clause of an &%if%& expansion item using the condition.
.cindex "tainted data" "de-tainting"
.endd
can be used for de-tainting.
Any previous &$value$& is restored after the if.
-.wen
.vitem &*isip&~{*&<&'string'&>&*}*& &&&
have their local parts matched casefully. Domains are always matched
caselessly.
-.new
The variable &$value$& will be set for a successful match and can be
used in the success clause of an &%if%& expansion item using the condition.
.cindex "tainted data" "de-tainting"
.endd
can be used for de-tainting.
Any previous &$value$& is restored after the if.
-.wen
Note that <&'string2'&> is not itself subject to string expansion, unless
Exim was built with the EXPAND_LISTMATCH_RHS option.
This section contains an alphabetical list of all the expansion variables. Some
of them are available only when Exim is compiled with specific options such as
support for TLS or the content scanning extension.
-.new
.cindex "tainted data"
Variables marked as &'tainted'& are likely to carry data supplied by
a potential attacker.
Such variables should not be further expanded,
used as filenames
or used as command-line arguments for external commands.
-.wen
.vlist
.vitem "&$0$&, &$1$&, etc"
precedes the expansion of the string. For example, the commands available in
Exim filter files include an &%if%& command with its own regular expression
matching condition.
-.new
If the subject string was tainted then any captured substring will also be.
-.wen
.vitem "&$acl_arg1$&, &$acl_arg2$&, etc"
Within an acl condition, expansion condition or expansion item
(described under &%transport_filter%& in chapter &<<CHAPtransportgeneric>>&).
It cannot be used in general expansion strings, and provokes an &"unknown
variable"& error if encountered.
-.new
&*Note*&: This value permits data supplied by a potential attacker to
be used in the command for a &(pipe)& transport.
Such configurations should be carefully assessed for security vulnerbilities.
-.wen
.vitem &$primary_hostname$&
.vindex "&$primary_hostname$&"
When a &%regex%& or &%mime_regex%& ACL condition succeeds,
these variables contain the
captured substrings identified by the regular expression.
-.new
If the subject string was tainted then so will any captured substring.
-.wen
.tvar &$reply_address$&
.row &%log_timezone%& "add timezone to log lines"
.row &%message_logs%& "create per-message logs"
.row &%preserve_message_logs%& "after message completion"
+ .row &%panic_coredump%& "request coredump on fatal errors"
.row &%process_log_path%& "for SIGUSR1 and &'exiwhat'&"
.row &%slow_lookup_log%& "control logging of slow DNS lookups"
.row &%syslog_duplication%& "controls duplicate log lines on syslog"
.code
hosts_connection_nolog = :
.endd
- If the &%smtp_connection%& log selector is not set, this option has no effect.
+ .new
+ The hosts affected by this option also do not log "no MAIL in SMTP connection"
+ lines, as may commonly be produced by a monitoring system.
+ .wen
.option hosts_require_alpn main "host list&!!" unset
The option is available only if Exim has been built with Oracle support.
+ .new
+ .option panic_coredump main boolean false
+ This option is rarely needed but can help for some debugging investigations.
+ If set, when an internal error is detected by Exim which is sufficient
+ to terminate the process
+ (all such are logged in the paniclog)
+ then a coredump is requested.
+
+ Note that most systems require additional administrative configuration
+ to permit write a core file for a setuid program, which is Exim's
+ common installed configuration.
+ .wen
+
.option percent_hack_domains main "domain list&!!" unset
.cindex "&""percent hack""&"
.cindex "source routing" "in email address"
next queue run. See also &%hold_domains%& and &%queue_smtp_domains%&.
- .option queue_fast_ramp main boolean false
+ .option queue_fast_ramp main boolean true
.cindex "queue runner" "two phase"
.cindex "queue" "double scanning"
If set to true, two-phase queue runs, initiated using &%-qq%& on the
for the remaining recipients at a later time.
- .option remote_max_parallel main integer 2
+ .option remote_max_parallel main integer 4
.cindex "delivery" "parallelism for remote"
This option controls parallel delivery of one message to a number of remote
hosts. If the value is less than 2, parallel delivery is disabled, and Exim
At this point, all of the "ike" values should be considered obsolete;
they are still in Exim to avoid breaking unusual configurations, but are
candidates for removal the next time we have backwards-incompatible changes.
-.new
Two of them in particular (&`ike1`& and &`ike22`&) are called out by RFC 8247
as MUST NOT use for IPSEC, and two more (&`ike23`& and &`ike24`&) as
SHOULD NOT.
are used, warnings will be logged in the paniclog, and if any are used then
warnings will be logged in the mainlog.
All four will be removed in a future Exim release.
-.wen
The TLS protocol does not negotiate an acceptable size for this; clients tend
to hard-drop connections if what is offered by the server is unacceptable,
the &%environment%& option can be used to add additional variables to this
environment. The environment for the &(pipe)& transport is not subject
to the &%add_environment%& and &%keep_environment%& main config options.
-.new
&*Note*&: Using enviroment variables loses track of tainted data.
Writers of &(pipe)& transport commands should be wary of data supplied
by potential attackers.
-.wen
.display
&`DOMAIN `& the domain of the address
&`HOME `& the home directory, if set
Exim, and each argument is separately expanded, as described in section
&<<SECThowcommandrun>>& above.
-.new
.cindex "tainted data"
No part of the resulting command may be tainted.
-.wen
.option environment pipe string&!! unset
The use of &%helo_data%& applies both to sending messages and when doing
callouts.
-.new
.option host_name_extract smtp "string list&!!" "see below"
.cindex "load balancer" "hosts behind"
.cindex TLS resumption
expression for this option.
The smtp:ehlo event and the &$tls_out_resumption$& variable
will be useful for such work.
-.wen
.option hosts smtp "string list&!!" unset
Hosts are associated with an address by a router such as &(dnslookup)&, which
See also the &%pipelining_connect_advertise_hosts%& main option.
Note:
-.new
When the facility is used, if the transport &%interface%& option is unset
the &%helo_data%& option
-.wen
will be expanded before the &$sending_ip_address$& variable
is filled in.
A check is made for the use of that variable, without the
only point of caution. The &$tls_out_sni$& variable will be set to this string
for the lifetime of the client connection (including during authentication).
-.new
If DANE validated the connection attempt then the value of the &%tls_sni%& option
is forced to the name of the destination host, after any MX- or CNAME-following.
-.wen
Except during SMTP client sessions, if &$tls_in_sni$& is set then it is a string
received from a client.
the message override the banner message that is otherwise specified by the
&%smtp_banner%& option.
-.new
For tls-on-connect connections, the ACL is run after the TLS connection
is accepted (however, &%host_reject_connection%& is tested before).
-.wen
.section "The EHLO/HELO ACL" "SECID192"
with &`-d`&, with the output going to a new logfile in the usual logs directory,
by default called &'debuglog'&.
-.new
Logging set up by the control will be maintained across spool residency.
Options are a slash-separated list.
If an option takes an argument, the option name and argument are separated by
an equals character.
Several options are supported:
-.wen
.display
tag=<&'suffix'&> The filename can be adjusted with thise option.
The argument, which may access any variables already defined,
non-SMTP ACLs. It causes the incoming message to be scanned for a match with
any of the regular expressions. For details, see chapter &<<CHAPexiscan>>&.
-.new
.vitem &*seen&~=&~*&<&'parameters'&>
.cindex "&%sseen%& ACL condition"
This condition can be used to test if a situation has been previously met,
for example for greylisting.
Details are given in section &<<SECTseen>>&.
-.wen
.vitem &*sender_domains&~=&~*&<&'domain&~list'&>
.cindex "&%sender_domains%& ACL condition"
.endd
-.new
.section "Previously seen user and hosts" "SECTseen"
.cindex "&%sseen%& ACL condition"
.cindex greylisting
Note that &"seen"& should be added to the list of hints databases
for maintenance if this ACL condition is used.
-.wen
.section "Rate limiting incoming messages" "SECTratelimiting"
clients when the SMTP PIPELINING extension is in use. The flushing can be
disabled by using a &%control%& modifier to set &%no_callout_flush%&.
-.new
.cindex "tainted data" "de-tainting"
.cindex "de-tainting" "using receipient verify"
A recipient callout which gets a 2&'xx'& code
will assign untainted values to the
&$domain_data$& and &$local_part_data$& variables,
corresponding to the domain and local parts of the recipient address.
-.wen
.vitem &*header_line&~*header_last*&
A pointer to the last of the header lines.
-.new
.vitem &*const&~uschar&~*headers_charset*&
The value of the &%headers_charset%& configuration option.
-.wen
.vitem &*BOOL&~host_checking*&
This variable is TRUE during a host checking session that is initiated by the
.endlist
There is one more option, &%-h%&, which outputs a list of options.
-.new
At least one selection option, or either the &*-c*& or &*-h*& option, must be given.
-.wen
.cindex "&'exim_dumpdb'&"
The entire contents of a database are written to the standard output by the
&'exim_dumpdb'& program,
-.new
taking as arguments the spool and database names.
An option &'-z'& may be given to request times in UTC;
otherwise times are in the local timezone.
An option &'-k'& may be given to dump only the record keys.
-.wen
For example, to dump the retry database:
.code
exim_dumpdb /var/spool/exim retry
sequence of digit pairs for year, month, day, hour, and minute. Colons can be
used as optional separators.
-.new
Both displayed and input times are in the local timezone by default.
If an option &'-z'& is used on the command line, displayed times
are in UTC.
-.wen
start of the epoch. The second number is a count of the number of messages
warning of delayed delivery that have been sent to the sender.
-.new
There follow a number of lines starting with a hyphen.
These contain variables, can appear in any
order, and are omitted when not relevant.
The following word specifies a variable,
and the remainder of the item depends on the variable.
-.wen
.vlist
.vitem "&%-acl%&&~<&'number'&>&~<&'length'&>"
After expansion, this can be a list.
Each element in turn,
lowercased,
+.vindex "&$dkim_domain$&"
is put into the &%$dkim_domain%& expansion variable
while expanding the remaining signing options.
If it is empty after expansion, DKIM signing is not done,
This sets the key selector string.
After expansion, which can use &$dkim_domain$&, this can be a list.
Each element in turn is put in the expansion
+.vindex "&$dkim_selector$&"
variable &%$dkim_selector%& which may be used in the &%dkim_private_key%&
option along with &%$dkim_domain%&.
If the option is empty after expansion, DKIM signing is not done for this domain,
encoded.
The second argument should be given as the envelope sender address before this
encoding operation.
+If this value is empty the the expansion result will be empty.
The third argument should be the recipient domain of the message when
it arrived at this system.
.endlist
The name is placed in the variable &$event_name$& and the event action
expansion must check this, as it will be called for every possible event type.
-.new
The current list of events is:
.itable all 0 0 4 1pt left 1pt center 1pt center 1pt left
.irow dane:fail after transport "per connection"
.irow smtp:connect after transport "per connection"
.irow smtp:ehlo after transport "per connection"
.endtable
-.wen
New event types may be added in future.
The event name is a colon-separated list, defining the type of
#include "exim.h"
+ typedef unsigned esi_flags;
+ #define ESI_NOFLAGS 0
+ #define ESI_BRACE_ENDS BIT(0) /* expansion should stop at } */
+ #define ESI_HONOR_DOLLAR BIT(1) /* $ is meaningfull */
+ #define ESI_SKIPPING BIT(2) /* value will not be needed */
+
/* Recursively called function */
- static uschar *expand_string_internal(const uschar *, BOOL, const uschar **, BOOL, BOOL, BOOL *);
+ static uschar *expand_string_internal(const uschar *, esi_flags, const uschar **, BOOL *, BOOL *);
static int_eximarith_t expanded_string_integer(const uschar *, BOOL);
#ifdef STAND_ALONE
{ "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
{ "recipients", vtype_string_func, (void *) &fn_recipients },
{ "recipients_count", vtype_int, &recipients_count },
+ { "regex_cachesize", vtype_int, ®ex_cachesize },/* undocumented; devel observability */
#ifdef WITH_CONTENT_SCAN
{ "regex_match_string", vtype_stringptr, ®ex_match_string },
#endif
int fd;
ssize_t len;
const uschar * where;
- #ifndef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
uschar * sname;
- #endif
if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
{
return NULL;
}
- #ifdef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
- sa_un.sun_path[0] = 0; /* Abstract local socket addr - Linux-specific? */
- len = offsetof(struct sockaddr_un, sun_path) + 1
- + snprintf(sa_un.sun_path+1, sizeof(sa_un.sun_path)-1, "exim_%d", getpid());
- #else
- sname = string_sprintf("%s/p_%d", spool_directory, getpid());
- len = offsetof(struct sockaddr_un, sun_path)
- + snprintf(sa_un.sun_path, sizeof(sa_un.sun_path), "%s", sname);
- #endif
+ len = daemon_client_sockname(&sa_un, &sname);
- if (bind(fd, (const struct sockaddr *)&sa_un, len) < 0)
+ if (bind(fd, (const struct sockaddr *)&sa_un, (socklen_t)len) < 0)
{ where = US"bind"; goto bad; }
#ifdef notdef
sa_un.sun_path + (*sa_un.sun_path ? 0 : 1));
#endif
- #ifdef EXIM_HAVE_ABSTRACT_UNIX_SOCKETS
- sa_un.sun_path[0] = 0; /* Abstract local socket addr - Linux-specific? */
- len = offsetof(struct sockaddr_un, sun_path) + 1
- + snprintf(sa_un.sun_path+1, sizeof(sa_un.sun_path)-1, "%s",
- expand_string(notifier_socket));
- #else
- len = offsetof(struct sockaddr_un, sun_path)
- + snprintf(sa_un.sun_path, sizeof(sa_un.sun_path), "%s",
- expand_string(notifier_socket));
- #endif
-
+ len = daemon_notifier_sockname(&sa_un);
if (connect(fd, (const struct sockaddr *)&sa_un, len) < 0)
{ where = US"connect"; goto bad2; }
n maximum number of substrings
m minimum required
sptr points to current string pointer
- skipping the skipping flag
+ flags
+ skipping the skipping flag
check_end if TRUE, check for final '}'
name name of item, for error message
resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
- the store.
+ the store
+ textonly_p if not NULL, pointer to bitmask of which subs were text-only
+ (did not change when expended)
- Returns: 0 OK; string pointer updated
+ Returns: -1 OK; string pointer updated, but in "skipping" mode
+ 0 OK; string pointer updated
1 curly bracketing error (too few arguments)
2 too many arguments (only if check_end is set); message set
3 other error (expansion failure)
*/
static int
- read_subs(uschar **sub, int n, int m, const uschar **sptr, BOOL skipping,
- BOOL check_end, uschar *name, BOOL *resetok)
+ read_subs(uschar ** sub, int n, int m, const uschar ** sptr, esi_flags flags,
+ BOOL check_end, uschar * name, BOOL * resetok, unsigned * textonly_p)
{
- const uschar *s = *sptr;
+ const uschar * s = *sptr;
+ unsigned textonly_l = 0;
Uskip_whitespace(&s);
for (int i = 0; i < n; i++)
{
+ BOOL textonly;
if (*s != '{')
{
if (i < m)
sub[i] = NULL;
break;
}
- if (!(sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, resetok)))
+ if (!(sub[i] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags & ESI_SKIPPING, &s, resetok,
+ textonly_p ? &textonly : NULL)))
return 3;
if (*s++ != '}') return 1;
+ if (textonly_p && textonly) textonly_l |= BIT(i);
Uskip_whitespace(&s);
- }
+ } /*{*/
if (check_end && *s++ != '}')
{
if (s[-1] == '{')
return 1;
}
+ if (textonly_p) *textonly_p = textonly_l;
*sptr = s;
- return 0;
+ return flags & ESI_SKIPPING ? -1 : 0;
}
*/
static const uschar *
- eval_condition(const uschar *s, BOOL *resetok, BOOL *yield)
+ eval_condition(const uschar * s, BOOL * resetok, BOOL * yield)
{
BOOL testfor = TRUE;
BOOL tempcond, combined_cond;
- BOOL *subcondptr;
+ BOOL * subcondptr;
BOOL sub2_honour_dollar = TRUE;
BOOL is_forany, is_json, is_jsons;
int rc, cond_type;
struct stat statbuf;
uschar * opname;
uschar name[256];
- const uschar *sub[10];
+ const uschar * sub[10];
+ unsigned sub_textonly = 0;
for (;;)
if (Uskip_whitespace(&s) == '!') { testfor = !testfor; s++; } else break;
if (Uskip_whitespace(&s) != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
- sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL, TRUE, resetok);
- if (!sub[0]) return NULL;
+ {
+ BOOL textonly;
+ sub[0] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | (yield ? ESI_NOFLAGS : ESI_SKIPPING),
+ &s, resetok, &textonly);
+ if (!sub[0]) return NULL;
+ if (textonly) sub_textonly |= BIT(0);
+ }
/* {-for-text-editors */
if (*s++ != '}') goto COND_FAILED_CURLY_END;
Uskip_whitespace(&s);
if (*s++ != '{') goto COND_FAILED_CURLY_START; /*}*/
- switch(read_subs(sub, nelem(sub), 1,
- &s, yield == NULL, TRUE, name, resetok))
+ switch(read_subs(sub, nelem(sub), 1, &s,
+ yield ? ESI_NOFLAGS : ESI_SKIPPING, TRUE, name, resetok, NULL))
{
case 1: expand_string_message = US"too few arguments or bracketing "
"error for acl";
uschar *sub[4];
Uskip_whitespace(&s);
if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
- switch(read_subs(sub, nelem(sub), 2, &s, yield == NULL, TRUE, name,
- resetok))
+ switch(read_subs(sub, nelem(sub), 2, &s,
+ yield ? ESI_NOFLAGS : ESI_SKIPPING, TRUE, name, resetok, NULL))
{
case 1: expand_string_message = US"too few arguments or bracketing "
"error for saslauthd";
for (int i = 0; i < 2; i++)
{
+ BOOL textonly;
/* Sometimes, we don't expand substrings; too many insecure configurations
created using match_address{}{} and friends, where the second param
includes information from untrustworthy sources. */
- BOOL honour_dollar = TRUE;
- if ((i > 0) && !sub2_honour_dollar)
- honour_dollar = FALSE;
+ /*XXX is this moot given taint-tracking? */
+
+ esi_flags flags = ESI_BRACE_ENDS;
+
+ if (!(i > 0 && !sub2_honour_dollar)) flags |= ESI_HONOR_DOLLAR;
+ if (!yield) flags |= ESI_SKIPPING;
if (Uskip_whitespace(&s) != '{')
{
"after \"%s\"", opname);
return NULL;
}
- if (!(sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL,
- honour_dollar, resetok)))
+ if (!(sub[i] = expand_string_internal(s+1, flags, &s, resetok, &textonly)))
return NULL;
+ if (textonly) sub_textonly |= BIT(i);
DEBUG(D_expand) if (i == 1 && !sub2_honour_dollar && Ustrchr(sub[1], '$'))
debug_printf_indent("WARNING: the second arg is NOT expanded,"
" for security reasons\n");
case ECOND_MATCH: /* Regular expression match */
{
- const pcre2_code * re;
- PCRE2_SIZE offset;
- int err;
-
- if (!(re = pcre2_compile((PCRE2_SPTR)sub[1], PCRE2_ZERO_TERMINATED,
- PCRE_COPT, &err, &offset, pcre_cmp_ctx)))
- {
- uschar errbuf[128];
- pcre2_get_error_message(err, errbuf, sizeof(errbuf));
- expand_string_message = string_sprintf("regular expression error in "
- "\"%s\": %s at offset %ld", sub[1], errbuf, (long)offset);
+ const pcre2_code * re = regex_compile(sub[1],
+ sub_textonly & BIT(1) ? MCS_CACHEABLE : MCS_NOFLAGS,
+ &expand_string_message, pcre_gen_cmp_ctx);
+ if (!re)
return NULL;
- }
tempcond = regex_match_and_setup(re, sub[0], 0, -1);
break;
Uskip_whitespace(&s);
if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
- if (!(sub[0] = expand_string_internal(s, TRUE, &s, yield == NULL, TRUE, resetok)))
+ if (!(sub[0] = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | (yield ? ESI_NOFLAGS : ESI_SKIPPING),
+ &s, resetok, NULL)))
return NULL;
/* {-for-text-editors */
if (*s++ != '}') goto COND_FAILED_CURLY_END;
if (Uskip_whitespace(&s) != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
ourname = cond_type == ECOND_BOOL_LAX ? US"bool_lax" : US"bool";
- switch(read_subs(sub_arg, 1, 1, &s, yield == NULL, FALSE, ourname, resetok))
+ switch(read_subs(sub_arg, 1, 1, &s,
+ yield ? ESI_NOFLAGS : ESI_SKIPPING, FALSE, ourname, resetok, NULL))
{
case 1: expand_string_message = string_sprintf(
"too few arguments or bracketing error for %s",
uschar cksum[4];
BOOL boolvalue = FALSE;
- switch(read_subs(sub, 2, 2, CUSS &s, yield == NULL, FALSE, name, resetok))
+ switch(read_subs(sub, 2, 2, CUSS &s,
+ yield ? ESI_NOFLAGS : ESI_SKIPPING, FALSE, name, resetok, NULL))
{
case 1: expand_string_message = US"too few arguments or bracketing "
"error for inbound_srs";
/* Match the given local_part against the SRS-encoded pattern */
re = regex_must_compile(US"^(?i)SRS0=([^=]+)=([A-Z2-7]+)=([^=]*)=(.*)$",
- TRUE, FALSE);
+ MCS_CASELESS | MCS_CACHEABLE, FALSE);
md = pcre2_match_data_create(4+1, pcre_gen_ctx);
if (pcre2_match(re, sub[0], PCRE2_ZERO_TERMINATED, 0, PCRE_EOPT,
- md, pcre_mtc_ctx) < 0)
+ md, pcre_gen_mtc_ctx) < 0)
{
DEBUG(D_expand) debug_printf("no match for SRS'd local-part pattern\n");
goto srs_result;
boolvalue = TRUE;
srs_result:
+ /* pcre2_match_data_free(md); gen ctx needs no free */
if (yield) *yield = (boolvalue == testfor);
return s;
}
needed - this avoids unnecessary nested lookups.
Arguments:
- skipping TRUE if we were skipping when this item was reached
+ flags
+ skipping TRUE if we were skipping when this item was reached
yes TRUE if the first string is to be used, else use the second
save_lookup a value to put back into lookup_value before the 2nd expansion
sptr points to the input string pointer
*/
static int
- process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, const uschar **sptr,
+ process_yesno(esi_flags flags, BOOL yes, uschar *save_lookup, const uschar **sptr,
gstring ** yieldptr, uschar *type, BOOL *resetok)
{
int rc = 0;
uschar *sub1, *sub2;
const uschar * errwhere;
+ flags &= ESI_SKIPPING; /* Ignore all buf the skipping flag */
+
/* If there are no following strings, we substitute the contents of $value for
lookups and for extractions in the success case. For the ${if item, the string
"true" is substituted. In the fail case, nothing is substituted for all three
{
if (type[0] == 'i')
{
- if (yes && !skipping)
+ if (yes && !(flags & ESI_SKIPPING))
*yieldptr = string_catn(*yieldptr, US"true", 4);
}
else
{
- if (yes && lookup_value && !skipping)
+ if (yes && lookup_value && !(flags & ESI_SKIPPING))
*yieldptr = string_cat(*yieldptr, lookup_value);
lookup_value = save_lookup;
}
if (*s++ != '{')
{
- errwhere = US"'yes' part did not start with '{'";
+ errwhere = US"'yes' part did not start with '{'"; /*}}*/
goto FAILED_CURLY;
}
want this string. Set skipping in the call in the fail case (this will always
be the case if we were already skipping). */
- sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
+ sub1 = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | (yes ? ESI_NOFLAGS : ESI_SKIPPING),
+ &s, resetok, NULL);
if (sub1 == NULL && (yes || !f.expand_string_forcedfail)) goto FAILED;
f.expand_string_forcedfail = FALSE;
+ /*{{*/
if (*s++ != '}')
{
errwhere = US"'yes' part did not end with '}'";
set skipping in the nested call if we don't want this string, or if we were
already skipping. */
- if (skip_whitespace(&s) == '{')
+ if (skip_whitespace(&s) == '{') /*}*/
{
- sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
- if (sub2 == NULL && (!yes || !f.expand_string_forcedfail)) goto FAILED;
- f.expand_string_forcedfail = FALSE;
+ esi_flags s_flags = ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags;
+ if (yes) s_flags |= ESI_SKIPPING;
+ sub2 = expand_string_internal(s+1, s_flags, &s, resetok, NULL);
+ if (!sub2 && (!yes || !f.expand_string_forcedfail)) goto FAILED;
+ f.expand_string_forcedfail = FALSE; /*{*/
if (*s++ != '}')
{
- errwhere = US"'no' part did not start with '{'";
+ errwhere = US"'no' part did not start with '{'"; /*}*/
goto FAILED_CURLY;
}
if (!yes)
*yieldptr = string_cat(*yieldptr, sub2);
}
-
+ /*{{*/
/* If there is no second string, but the word "fail" is present when the use of
the second string is wanted, set a flag indicating it was a forced failure
rather than a syntactic error. Swallow the terminating } in case this is nested
s = US read_name(name, sizeof(name), s, US"_");
if (Ustrcmp(name, "fail") == 0)
{
- if (!yes && !skipping)
+ if (!yes && !(flags & ESI_SKIPPING))
{
- Uskip_whitespace(&s);
+ Uskip_whitespace(&s); /*{{*/
if (*s++ != '}')
{
errwhere = US"did not close with '}' after forcedfail";
/* All we have to do now is to check on the final closing brace. */
- skip_whitespace(&s);
+ skip_whitespace(&s); /*{{*/
if (*s++ != '}')
{
errwhere = US"did not close with '}'";
Arguments:
string the string to be expanded
- ket_ends true if expansion is to stop at }
+ flags
+ brace_ends expansion is to stop at }
+ honour_dollar TRUE if $ is to be expanded,
+ FALSE if it's just another character
+ skipping TRUE for recursive calls when the value isn't actually going
+ to be used (to allow for optimisation)
left if not NULL, a pointer to the first character after the
- expansion is placed here (typically used with ket_ends)
- skipping TRUE for recursive calls when the value isn't actually going
- to be used (to allow for optimisation)
- honour_dollar TRUE if $ is to be expanded,
- FALSE if it's just another character
+ expansion is placed here (typically used with brace_ends)
resetok_p if not NULL, pointer to flag - write FALSE if unsafe to reset
the store.
+ textonly_p if not NULL, pointer to flag - write bool for only-met-text
Returns: NULL if expansion fails:
expand_string_forcedfail is set TRUE if failure was forced
*/
static uschar *
- expand_string_internal(const uschar *string, BOOL ket_ends, const uschar **left,
- BOOL skipping, BOOL honour_dollar, BOOL *resetok_p)
+ expand_string_internal(const uschar * string, esi_flags flags, const uschar ** left,
+ BOOL *resetok_p, BOOL * textonly_p)
{
rmark reset_point = store_mark();
gstring * yield = string_get(Ustrlen(string) + 64);
const uschar * s = string;
const uschar * save_expand_nstring[EXPAND_MAXN+1];
int save_expand_nlength[EXPAND_MAXN+1];
- BOOL resetok = TRUE, first = TRUE;
+ BOOL resetok = TRUE, first = TRUE, textonly = TRUE;
expand_level++;
f.expand_string_forcedfail = FALSE;
DEBUG(D_noutf8)
debug_printf_indent("%c%s: %s\n",
first ? '/' : '|',
- skipping ? "---scanning" : "considering", s);
+ flags & ESI_SKIPPING ? "---scanning" : "considering", s);
else
debug_printf_indent("%s%s: %s\n",
first ? UTF8_DOWN_RIGHT : UTF8_VERT_RIGHT,
- skipping
+ flags & ESI_SKIPPING
? UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ "scanning"
: "considering",
s);
for (s = t; *s ; s++) if (*s == '\\' && s[1] == 'N') break;
DEBUG(D_expand)
- debug_expansion_interim(US"protected", t, (int)(s - t), skipping);
+ debug_expansion_interim(US"protected", t, (int)(s - t), !!(flags & ESI_SKIPPING));
yield = string_catn(yield, t, s - t);
if (*s) s += 2;
}
/* Anything other than $ is just copied verbatim, unless we are
looking for a terminating } character. */
- if (ket_ends && *s == '}') break;
+ if (flags & ESI_BRACE_ENDS && *s == '}') break;
- if (*s != '$' || !honour_dollar)
+ if (*s != '$' || !(flags & ESI_HONOR_DOLLAR))
{
int i = 1; /*{*/
for (const uschar * t = s+1;
*t && *t != '$' && *t != '}' && *t != '\\'; t++) i++;
- DEBUG(D_expand) debug_expansion_interim(US"text", s, i, skipping);
+ DEBUG(D_expand) debug_expansion_interim(US"text", s, i, !!(flags & ESI_SKIPPING));
yield = string_catn(yield, s, i);
s += i;
continue;
}
+ textonly = FALSE;
/* No { after the $ - must be a plain name or a number for string
match variable. There has to be a fudge for variables that are the
/* Variable */
- else if (!(value = find_variable(name, FALSE, skipping, &newsize)))
+ else if (!(value = find_variable(name, FALSE, !!(flags & ESI_SKIPPING), &newsize)))
{
expand_string_message =
string_sprintf("unknown variable name \"%s\"", name);
uschar * user_msg;
int rc;
- switch(read_subs(sub, nelem(sub), 1, &s, skipping, TRUE, name,
- &resetok))
+ switch(read_subs(sub, nelem(sub), 1, &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- if (skipping) continue;
resetok = FALSE;
switch(rc = eval_acl(sub, nelem(sub), &user_msg))
{
uschar * sub_arg[1];
- switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, skipping, TRUE, name,
- &resetok))
+ switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, flags, TRUE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
+ /*XXX no skipping-optimisation? */
yield = string_append(yield, 3,
US"Authentication-Results: ", sub_arg[0], US"; none");
uschar * save_lookup_value = lookup_value;
Uskip_whitespace(&s);
- if (!(next_s = eval_condition(s, &resetok, skipping ? NULL : &cond)))
+ if (!(next_s = eval_condition(s, &resetok, flags & ESI_SKIPPING ? NULL : &cond)))
goto EXPAND_FAILED; /* message already set */
DEBUG(D_expand)
{
- debug_expansion_interim(US"condition", s, (int)(next_s - s), skipping);
+ debug_expansion_interim(US"condition", s, (int)(next_s - s), !!(flags & ESI_SKIPPING));
debug_expansion_interim(US"result",
- cond ? US"true" : US"false", cond ? 4 : 5, skipping);
+ cond ? US"true" : US"false", cond ? 4 : 5, !!(flags & ESI_SKIPPING));
}
s = next_s;
function that is also used by ${lookup} and ${extract} and ${run}. */
switch(process_yesno(
- skipping, /* were previously skipping */
- cond, /* success/failure indicator */
- lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"if", /* condition type */
+ flags, /* were previously skipping */
+ cond, /* success/failure indicator */
+ lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"if", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
uschar *sub_arg[3];
uschar *encoded;
- switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, skipping, TRUE, name,
- &resetok))
+ switch(read_subs(sub_arg, nelem(sub_arg), 1, &s, flags, TRUE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
+ /*XXX no skipping-optimisation? */
if (!sub_arg[1]) /* One argument */
{
goto EXPAND_FAILED;
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
if (!(encoded = imap_utf7_encode(sub_arg[0], headers_charset,
sub_arg[1][0], sub_arg[2], &expand_string_message)))
if (Uskip_whitespace(&s) == '{') /*}*/
{
- key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
+ key = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!key) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
expand_string_message = US"missing '{' for lookup file-or-query arg";
goto EXPAND_FAILED_CURLY; /*}}*/
}
- if (!(filename = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok)))
+ if (!(filename = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL)))
goto EXPAND_FAILED;
/*{{*/
if (*s++ != '}')
since new variables will have been set. Note that at the end of this
"lookup" section, the old numeric variables are restored. */
- if (skipping)
+ if (flags & ESI_SKIPPING)
lookup_value = NULL;
else
{
function that is also used by ${if} and ${extract}. */
switch(process_yesno(
- skipping, /* were previously skipping */
- lookup_value != NULL, /* success/failure indicator */
- save_lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"lookup", /* condition type */
+ flags, /* were previously skipping */
+ lookup_value != NULL, /* success/failure indicator */
+ save_lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"lookup", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
restore_expand_strings(save_expand_nmax, save_expand_nstring,
save_expand_nlength);
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
goto EXPAND_FAILED;
}
- switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
- name, &resetok))
+ switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, flags, TRUE,
+ name, &resetok, NULL))
{
+ case -1: continue; /* If skipping, we don't actually do anything */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- /* If skipping, we don't actually do anything */
-
- if (skipping) continue;
-
/* Start the interpreter if necessary */
if (!opt_perl_started)
{
uschar * sub_arg[3], * p, * domain;
- switch(read_subs(sub_arg, 3, 2, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub_arg, 3, 2, &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* If skipping, we don't actually do anything */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- /* If skipping, we don't actually do anything */
- if (skipping) continue;
-
/* sub_arg[0] is the address */
if ( !(domain = Ustrrchr(sub_arg[0],'@'))
|| domain == sub_arg[0] || Ustrlen(domain) == 1)
gstring * g;
const pcre2_code * re;
- /* TF: Ugliness: We want to expand parameter 1 first, then set
- up expansion variables that are used in the expansion of
- parameter 2. So we clone the string for the first
- expansion, where we only expand parameter 1.
-
- PH: Actually, that isn't necessary. The read_subs() function is
- designed to work this way for the ${if and ${lookup expansions. I've
- tidied the code.
- */ /*}}*/
-
/* Reset expansion variables */
prvscheck_result = NULL;
prvscheck_address = NULL;
prvscheck_keynum = NULL;
- switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, name, &resetok))
+ switch(read_subs(sub_arg, 1, 1, &s, flags, FALSE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- re = regex_must_compile(US"^prvs\\=([0-9])([0-9]{3})([A-F0-9]{6})\\=(.+)\\@(.+)$",
- TRUE,FALSE);
+ re = regex_must_compile(
+ US"^prvs\\=([0-9])([0-9]{3})([A-F0-9]{6})\\=(.+)\\@(.+)$",
+ MCS_CASELESS | MCS_CACHEABLE, FALSE);
if (regex_match_and_setup(re,sub_arg[0],0,-1))
{
uschar * hash = string_copyn(expand_nstring[3],expand_nlength[3]);
uschar * domain = string_copyn(expand_nstring[5],expand_nlength[5]);
- DEBUG(D_expand) debug_printf_indent("prvscheck localpart: %s\n", local_part);
- DEBUG(D_expand) debug_printf_indent("prvscheck key number: %s\n", key_num);
- DEBUG(D_expand) debug_printf_indent("prvscheck daystamp: %s\n", daystamp);
- DEBUG(D_expand) debug_printf_indent("prvscheck hash: %s\n", hash);
- DEBUG(D_expand) debug_printf_indent("prvscheck domain: %s\n", domain);
+ DEBUG(D_expand)
+ {
+ debug_printf_indent("prvscheck localpart: %s\n", local_part);
+ debug_printf_indent("prvscheck key number: %s\n", key_num);
+ debug_printf_indent("prvscheck daystamp: %s\n", daystamp);
+ debug_printf_indent("prvscheck hash: %s\n", hash);
+ debug_printf_indent("prvscheck domain: %s\n", domain);
+ }
/* Set up expansion variables */
g = string_cat (NULL, local_part);
prvscheck_keynum = string_copy(key_num);
/* Now expand the second argument */
- switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, name, &resetok))
+ switch(read_subs(sub_arg, 1, 1, &s, flags, FALSE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
daystamp);
-
if (!p)
{
expand_string_message = US"hmac-sha1 conversion failed";
/* Now expand the final argument. We leave this till now so that
it can include $prvscheck_result. */
- switch(read_subs(sub_arg, 1, 0, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub_arg, 1, 0, &s, flags, TRUE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
We need to make sure all subs are expanded first, so as to skip over
the entire item. */
- switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub_arg, 2, 1, &s, flags, TRUE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
goto EXPAND_FAILED;
}
- switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub_arg, 2, 1, &s, flags, TRUE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2:
/* If skipping, we don't actually do anything */
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
/* Open the file and read it */
/* Read up to 4 arguments, but don't do the end of item check afterwards,
because there may be a string for expansion on failure. */
- switch(read_subs(sub_arg, 4, 2, &s, skipping, FALSE, name, &resetok))
+ switch(read_subs(sub_arg, 4, 2, &s, flags, FALSE, name, &resetok, NULL))
{
case 1: goto EXPAND_FAILED_CURLY;
case 2: /* Won't occur: no end check */
/* If skipping, we don't actually do anything. Otherwise, arrange to
connect to either an IP or a Unix socket. */
- if (!skipping)
+ if (!(flags & ESI_SKIPPING))
{
int stype = search_findtype(US"readsock", 8);
gstring * g = NULL;
if (*s == '{') /*}*/
{
- if (!expand_string_internal(s+1, TRUE, &s, TRUE, TRUE, &resetok))
+ if (!expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | ESI_SKIPPING, &s, &resetok, NULL))
goto EXPAND_FAILED; /*{*/
if (*s++ != '}')
{ /*{*/
expand_string_message = US"missing '}' closing readsocket";
goto EXPAND_FAILED_CURLY;
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
/* Come here on failure to create socket, connect socket, write to the
SOCK_FAIL:
if (*s != '{') goto EXPAND_FAILED; /*}*/
DEBUG(D_any) debug_printf("%s\n", expand_string_message);
- if (!(arg = expand_string_internal(s+1, TRUE, &s, FALSE, TRUE, &resetok)))
+ if (!(arg = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR, &s, &resetok, NULL)))
goto EXPAND_FAILED;
yield = string_cat(yield, arg); /*{*/
if (*s++ != '}')
s++;
if (late_expand) /* this is the default case */
- {
+ { /*{*/
int n = Ustrcspn(s, "}");
- arg = skipping ? NULL : string_copyn(s, n);
+ arg = flags & ESI_SKIPPING ? NULL : string_copyn(s, n);
s += n;
}
else
{
- if (!(arg = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok)))
+ if (!(arg = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL)))
goto EXPAND_FAILED;
Uskip_whitespace(&s);
}
goto EXPAND_FAILED_CURLY;
}
- if (skipping) /* Just pretend it worked when we're skipping */
+ if (flags & ESI_SKIPPING) /* Just pretend it worked when we're skipping */
{
runrc = 0;
lookup_value = NULL;
/* Process the yes/no strings; $value may be useful in both cases */
switch(process_yesno(
- skipping, /* were previously skipping */
- runrc == 0, /* success/failure indicator */
- lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"run", /* condition type */
+ flags, /* were previously skipping */
+ runrc == 0, /* success/failure indicator */
+ lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"run", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
int o2m;
uschar * sub[3];
- switch(read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub, 3, 3, &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
}
- if (skipping) continue;
break;
}
Ensure that sub[2] is set in the ${length } case. */
sub[2] = NULL;
- switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
- TRUE, name, &resetok))
+ switch(read_subs(sub, item_type == EITEM_LENGTH ? 2:3, 2, &s, flags,
+ TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
if (!ret)
goto EXPAND_FAILED;
yield = string_catn(yield, ret, len);
- if (skipping) continue;
break;
}
uschar innerkey[MAX_HASHBLOCKLEN];
uschar outerkey[MAX_HASHBLOCKLEN];
- switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
+ switch (read_subs(sub, 3, 3, &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- if (skipping) continue;
-
if (Ustrcmp(sub[0], "md5") == 0)
{
type = HMAC_MD5;
{
const pcre2_code * re;
int moffset, moffsetextra, slen;
- PCRE2_SIZE roffset;
pcre2_match_data * md;
- int err, emptyopt;
+ int emptyopt;
uschar * subject, * sub[3];
int save_expand_nmax =
save_expand_strings(save_expand_nstring, save_expand_nlength);
+ unsigned sub_textonly = 0;
- switch(read_subs(sub, 3, 3, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub, 3, 3, &s, flags, TRUE, name, &resetok, &sub_textonly))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- /*XXX no handling of skipping? */
/* Compile the regular expression */
- if (!(re = pcre2_compile((PCRE2_SPTR)sub[1], PCRE2_ZERO_TERMINATED,
- PCRE_COPT, &err, &roffset, pcre_cmp_ctx)))
- {
- uschar errbuf[128];
- pcre2_get_error_message(err, errbuf, sizeof(errbuf));
- expand_string_message = string_sprintf("regular expression error in "
- "\"%s\": %s at offset %ld", sub[1], errbuf, (long)roffset);
+ re = regex_compile(sub[1],
+ sub_textonly & BIT(1) ? MCS_CACHEABLE : MCS_NOFLAGS,
+ &expand_string_message, pcre_gen_cmp_ctx);
+ if (!re)
goto EXPAND_FAILED;
- }
+
md = pcre2_match_data_create(EXPAND_MAXN + 1, pcre_gen_ctx);
/* Now run a loop to do the substitutions as often as necessary. It ends
{
PCRE2_SIZE * ovec = pcre2_get_ovector_pointer(md);
int n = pcre2_match(re, (PCRE2_SPTR)subject, slen, moffset + moffsetextra,
- PCRE_EOPT | emptyopt, md, pcre_mtc_ctx);
+ PCRE_EOPT | emptyopt, md, pcre_gen_mtc_ctx);
uschar * insert;
/* No match - if we previously set PCRE_NOTEMPTY after a null match, this
/* All done - restore numerical variables. */
+ /* pcre2_match_data_free(md); gen ctx needs no free */
restore_expand_strings(save_expand_nmax, save_expand_nstring,
save_expand_nlength);
- if (skipping) continue;
break;
}
available (eg. $item) hence cannot decide on numeric vs. keyed.
Read a maximum of 5 arguments (including the yes/no) */
- if (skipping)
+ if (flags & ESI_SKIPPING)
{
for (int j = 5; j > 0 && *s == '{'; j--) /*'}'*/
{
- if (!expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok))
+ if (!expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL))
goto EXPAND_FAILED; /*'{'*/
if (*s++ != '}')
{
{
if (Uskip_whitespace(&s) == '{') /*'}'*/
{
- if (!(sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok)))
+ if (!(sub[i] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL)))
goto EXPAND_FAILED; /*'{'*/
if (*s++ != '}')
{
/* Extract either the numbered or the keyed substring into $value. If
skipping, just pretend the extraction failed. */
- if (skipping)
+ if (flags & ESI_SKIPPING)
lookup_value = NULL;
else switch (fmt)
{
be yes/no strings, as for lookup or if. */
switch(process_yesno(
- skipping, /* were previously skipping */
- lookup_value != NULL, /* success/failure indicator */
- save_lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"extract", /* condition type */
+ flags, /* were previously skipping */
+ lookup_value != NULL, /* success/failure indicator */
+ save_lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"extract", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
restore_expand_strings(save_expand_nmax, save_expand_nstring,
save_expand_nlength);
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
goto EXPAND_FAILED_CURLY;
}
- sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
+ sub[i] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!sub[i]) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
while (len > 0 && isspace(p[len-1])) len--;
p[len] = 0;
- if (!*p && !skipping)
+ if (!*p && !(flags & ESI_SKIPPING))
{
expand_string_message = US"first argument of \"listextract\" must "
"not be empty";
/* Extract the numbered element into $value. If
skipping, just pretend the extraction failed. */
- lookup_value = skipping ? NULL : expand_getlistele(field_number, sub[1]);
+ lookup_value = flags & ESI_SKIPPING ? NULL : expand_getlistele(field_number, sub[1]);
/* If no string follows, $value gets substituted; otherwise there can
be yes/no strings, as for lookup or if. */
switch(process_yesno(
- skipping, /* were previously skipping */
- lookup_value != NULL, /* success/failure indicator */
- save_lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"listextract", /* condition type */
+ flags, /* were previously skipping */
+ lookup_value != NULL, /* success/failure indicator */
+ save_lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"listextract", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
restore_expand_strings(save_expand_nmax, save_expand_nstring,
save_expand_nlength);
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
case EITEM_LISTQUOTE:
{
uschar * sub[2];
- switch(read_subs(sub, 2, 2, &s, skipping, TRUE, name, &resetok))
+ switch(read_subs(sub, 2, 2, &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
yield = string_catn(yield, sub[1], 1);
}
else yield = string_catn(yield, US" ", 1);
- if (skipping) continue;
break;
}
expand_string_message = US"missing '{' for field arg of certextract";
goto EXPAND_FAILED_CURLY; /*}*/
}
- sub[0] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
+ sub[0] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!sub[0]) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
"be a certificate variable";
goto EXPAND_FAILED;
}
- sub[1] = expand_string_internal(s+1, TRUE, &s, skipping, FALSE, &resetok);
+ sub[1] = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | flags & ESI_SKIPPING, &s, &resetok, NULL);
if (!sub[1]) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
goto EXPAND_FAILED_CURLY;
}
- if (skipping)
+ if (flags & ESI_SKIPPING)
lookup_value = NULL;
else
{
if (*expand_string_message) goto EXPAND_FAILED;
}
switch(process_yesno(
- skipping, /* were previously skipping */
- lookup_value != NULL, /* success/failure indicator */
- save_lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"certextract", /* condition type */
+ flags, /* were previously skipping */
+ lookup_value != NULL, /* success/failure indicator */
+ save_lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"certextract", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
restore_expand_strings(save_expand_nmax, save_expand_nstring,
save_expand_nlength);
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
#endif /*DISABLE_TLS*/
goto EXPAND_FAILED_CURLY; /*}*/
}
- if (!(list = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok)))
+ if (!(list = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL)))
goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
expand_string_message = US"missing '{' for second arg of reduce";
goto EXPAND_FAILED_CURLY; /*}*/
}
- t = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
+ t = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!t) goto EXPAND_FAILED;
lookup_value = t; /*{{*/
if (*s++ != '}')
the normal internal expansion function. */
if (item_type != EITEM_FILTER)
- temp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok);
+ temp = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | ESI_SKIPPING, &s, &resetok, NULL);
else
if ((temp = eval_condition(expr, &resetok, NULL))) s = temp;
/* If we are skipping, we can now just move on to the next item. When
processing for real, we perform the iteration. */
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
{
*outsep = (uschar)sep; /* Separator as a string */
else
{
- uschar * t = expand_string_internal(expr, TRUE, NULL, skipping, TRUE, &resetok);
+ uschar * t = expand_string_internal(expr,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, NULL, &resetok, NULL);
temp = t;
if (!temp)
{
/* Restore preserved $item */
iterate_item = save_iterate_item;
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
goto EXPAND_FAILED_CURLY; /*}*/
}
- srclist = expand_string_internal(s, TRUE, &s, skipping, TRUE, &resetok);
+ srclist = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!srclist) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
goto EXPAND_FAILED_CURLY; /*}*/
}
- cmp = expand_string_internal(s, TRUE, &s, skipping, FALSE, &resetok);
+ cmp = expand_string_internal(s,
+ ESI_BRACE_ENDS | flags & ESI_SKIPPING, &s, &resetok, NULL);
if (!cmp) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
}
xtract = s;
- if (!(tmp = expand_string_internal(s, TRUE, &s, TRUE, TRUE, &resetok)))
+ if (!(tmp = expand_string_internal(s,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | ESI_SKIPPING, &s, &resetok, NULL)))
goto EXPAND_FAILED;
xtract = string_copyn(xtract, s - xtract);
/*{{*/
goto EXPAND_FAILED;
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
while ((srcitem = string_nextinlist(&srclist, &sep, NULL, 0)))
{
/* extract field for comparisons */
iterate_item = srcitem;
- if ( !(srcfield = expand_string_internal(xtract, FALSE, NULL, FALSE,
- TRUE, &resetok))
+ if ( !(srcfield = expand_string_internal(xtract,
+ ESI_HONOR_DOLLAR, NULL, &resetok, NULL))
|| !*srcfield)
{
expand_string_message = string_sprintf(
goto EXPAND_FAILED;
}
- switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
- TRUE, name, &resetok))
+ switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, flags,
+ TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- /* If skipping, we don't actually do anything */
-
- if (skipping) continue;
-
/* Look up the dynamically loaded object handle in the tree. If it isn't
found, dlopen() the file and put the handle in the tree for next time. */
if (Uskip_whitespace(&s) != '{') /*}*/
goto EXPAND_FAILED;
- key = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
+ key = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!key) goto EXPAND_FAILED; /*{{*/
if (*s++ != '}')
{
lookup_value = US getenv(CS key);
switch(process_yesno(
- skipping, /* were previously skipping */
- lookup_value != NULL, /* success/failure indicator */
- save_lookup_value, /* value to reset for string2 */
- &s, /* input pointer */
- &yield, /* output pointer */
- US"env", /* condition type */
+ flags, /* were previously skipping */
+ lookup_value != NULL, /* success/failure indicator */
+ save_lookup_value, /* value to reset for string2 */
+ &s, /* input pointer */
+ &yield, /* output pointer */
+ US"env", /* condition type */
&resetok))
{
case 1: goto EXPAND_FAILED; /* when all is well, the */
case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
}
- if (skipping) continue;
+ if (flags & ESI_SKIPPING) continue;
break;
}
gstring * g = NULL;
BOOL quoted = FALSE;
- switch (read_subs(sub, 3, 3, CUSS &s, skipping, TRUE, name, &resetok))
+ switch (read_subs(sub, 3, 3, CUSS &s, flags, TRUE, name, &resetok, NULL))
{
+ case -1: continue; /* skipping */
case 1: goto EXPAND_FAILED_CURLY;
case 2:
case 3: goto EXPAND_FAILED;
}
- if (skipping) continue;
- g = string_catn(g, US"SRS0=", 5);
-
- /* ${l_4:${hmac{md5}{SRS_SECRET}{${lc:$return_path}}}}= */
- hmac_md5(sub[0], string_copylc(sub[1]), cksum, sizeof(cksum));
- g = string_catn(g, cksum, sizeof(cksum));
- g = string_catn(g, US"=", 1);
-
- /* ${base32:${eval:$tod_epoch/86400&0x3ff}}= */
+ if (sub[1] && *(sub[1]))
{
- struct timeval now;
- unsigned long i;
- gstring * h = NULL;
-
- gettimeofday(&now, NULL);
- for (unsigned long i = (now.tv_sec / 86400) & 0x3ff; i; i >>= 5)
- h = string_catn(h, &base32_chars[i & 0x1f], 1);
- if (h) while (h->ptr > 0)
- g = string_catn(g, &h->s[--h->ptr], 1);
- }
- g = string_catn(g, US"=", 1);
+ g = string_catn(g, US"SRS0=", 5);
- /* ${domain:$return_path}=${local_part:$return_path} */
- {
- int start, end, domain;
- uschar * t = parse_extract_address(sub[1], &expand_string_message,
- &start, &end, &domain, FALSE);
- uschar * s;
+ /* ${l_4:${hmac{md5}{SRS_SECRET}{${lc:$return_path}}}}= */
+ hmac_md5(sub[0], string_copylc(sub[1]), cksum, sizeof(cksum));
+ g = string_catn(g, cksum, sizeof(cksum));
+ g = string_catn(g, US"=", 1);
- if (!t)
- goto EXPAND_FAILED;
+ /* ${base32:${eval:$tod_epoch/86400&0x3ff}}= */
+ {
+ struct timeval now;
+ unsigned long i;
+ gstring * h = NULL;
- if (domain > 0) g = string_cat(g, t + domain);
+ gettimeofday(&now, NULL);
+ for (unsigned long i = (now.tv_sec / 86400) & 0x3ff; i; i >>= 5)
+ h = string_catn(h, &base32_chars[i & 0x1f], 1);
+ if (h) while (h->ptr > 0)
+ g = string_catn(g, &h->s[--h->ptr], 1);
+ }
g = string_catn(g, US"=", 1);
- s = domain > 0 ? string_copyn(t, domain - 1) : t;
- if ((quoted = Ustrchr(s, '"') != NULL))
+ /* ${domain:$return_path}=${local_part:$return_path} */
{
- gstring * h = NULL;
- DEBUG(D_expand) debug_printf_indent("auto-quoting local part\n");
- while (*s) /* de-quote */
+ int start, end, domain;
+ uschar * t = parse_extract_address(sub[1], &expand_string_message,
+ &start, &end, &domain, FALSE);
+ uschar * s;
+
+ if (!t)
+ goto EXPAND_FAILED;
+
+ if (domain > 0) g = string_cat(g, t + domain);
+ g = string_catn(g, US"=", 1);
+
+ s = domain > 0 ? string_copyn(t, domain - 1) : t;
+ if ((quoted = Ustrchr(s, '"') != NULL))
{
- while (*s && *s != '"') h = string_catn(h, s++, 1);
- if (*s) s++;
- while (*s && *s != '"') h = string_catn(h, s++, 1);
- if (*s) s++;
+ gstring * h = NULL;
+ DEBUG(D_expand) debug_printf_indent("auto-quoting local part\n");
+ while (*s) /* de-quote */
+ {
+ while (*s && *s != '"') h = string_catn(h, s++, 1);
+ if (*s) s++;
+ while (*s && *s != '"') h = string_catn(h, s++, 1);
+ if (*s) s++;
+ }
+ gstring_release_unused(h);
+ s = string_from_gstring(h);
}
- gstring_release_unused(h);
- s = string_from_gstring(h);
+ g = string_cat(g, s);
}
- g = string_cat(g, s);
- }
- /* Assume that if the original local_part had quotes
- it was for good reason */
+ /* Assume that if the original local_part had quotes
+ it was for good reason */
- if (quoted) yield = string_catn(yield, US"\"", 1);
- yield = string_catn(yield, g->s, g->ptr);
- if (quoted) yield = string_catn(yield, US"\"", 1);
+ if (quoted) yield = string_catn(yield, US"\"", 1);
+ yield = string_catn(yield, g->s, g->ptr);
+ if (quoted) yield = string_catn(yield, US"\"", 1);
- /* @$original_domain */
- yield = string_catn(yield, US"@", 1);
- yield = string_cat(yield, sub[2]);
+ /* @$original_domain */
+ yield = string_catn(yield, US"@", 1);
+ yield = string_cat(yield, sub[2]);
+ }
+ else
+ DEBUG(D_expand) debug_printf_indent("null return_path for srs-encode\n");
break;
}
DEBUG(D_expand)
if (yield && (start > 0 || *s)) /* only if not the sole expansion of the line */
debug_expansion_interim(US"item-res",
- yield->s + start, yield->ptr - start, skipping);
+ yield->s + start, yield->ptr - start, !!(flags & ESI_SKIPPING));
continue;
NOT_ITEM: ;
if (s[1] == '$')
{
const uschar * s1 = s;
- sub = expand_string_internal(s+2, TRUE, &s1, skipping,
- FALSE, &resetok);
+ sub = expand_string_internal(s+2,
+ ESI_BRACE_ENDS | flags & ESI_SKIPPING, &s1, &resetok, NULL);
if (!sub) goto EXPAND_FAILED; /*{*/
if (*s1 != '}')
{ /*{*/
/*FALLTHROUGH*/
#endif
default:
- sub = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, &resetok);
+ sub = expand_string_internal(s+1,
+ ESI_BRACE_ENDS | ESI_HONOR_DOLLAR | flags, &s, &resetok, NULL);
if (!sub) goto EXPAND_FAILED;
s++;
break;
for the existence of $sender_host_address before trying to mask it. For
other operations, doing them may not fail, but it is a waste of time. */
- if (skipping && c >= 0) continue;
+ if (flags & ESI_SKIPPING && c >= 0) continue;
/* Otherwise, switch on the operator type. After handling go back
to the main loop top. */
case EOP_EXPAND:
{
- uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping, TRUE, &resetok);
+ uschar *expanded = expand_string_internal(sub,
+ ESI_HONOR_DOLLAR | flags & ESI_SKIPPING, NULL, &resetok, NULL);
if (!expanded)
{
expand_string_message =
debug_printf_indent("|-----op-res: %.*s\n", i, s);
if (tainted)
{
- debug_printf_indent("%s \\__", skipping ? "| " : " ");
+ debug_printf_indent("%s \\__", flags & ESI_SKIPPING ? "| " : " ");
debug_print_taint(yield->s);
}
}
if (tainted)
{
debug_printf_indent("%s",
- skipping
+ flags & ESI_SKIPPING
? UTF8_VERT " " : " " UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ);
debug_print_taint(yield->s);
}
reset_point = store_mark();
g = store_get(sizeof(gstring), GET_UNTAINTED); /* alloc _before_ calling find_variable() */
}
- if (!(value = find_variable(name, FALSE, skipping, &newsize)))
+ if (!(value = find_variable(name, FALSE, !!(flags & ESI_SKIPPING), &newsize)))
{
expand_string_message =
string_sprintf("unknown variable in \"${%s}\"", name);
goto EXPAND_FAILED;
}
- /* If we hit the end of the string when ket_ends is set, there is a missing
+ /* If we hit the end of the string when brace_ends is set, there is a missing
terminating brace. */
- if (ket_ends && !*s)
- {
+ if (flags & ESI_BRACE_ENDS && !*s)
+ { /*{{*/
expand_string_message = malformed_header
? US"missing } at end of string - could be header name not terminated by colon"
: US"missing } at end of string";
{
debug_printf_indent("|--expanding: %.*s\n", (int)(s - string), string);
debug_printf_indent("%sresult: %s\n",
- skipping ? "|-----" : "\\_____", yield->s);
+ flags & ESI_SKIPPING ? "|-----" : "\\_____", yield->s);
if (tainted)
{
- debug_printf_indent("%s \\__", skipping ? "| " : " ");
+ debug_printf_indent("%s \\__", flags & ESI_SKIPPING ? "| " : " ");
debug_print_taint(yield->s);
}
- if (skipping)
+ if (flags & ESI_SKIPPING)
debug_printf_indent("\\___skipping: result is not used\n");
}
else
(int)(s - string), string);
debug_printf_indent("%s" UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
"result: %s\n",
- skipping ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
+ flags & ESI_SKIPPING ? UTF8_VERT_RIGHT : UTF8_UP_RIGHT,
yield->s);
if (tainted)
{
debug_printf_indent("%s",
- skipping
+ flags & ESI_SKIPPING
? UTF8_VERT " " : " " UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ);
debug_print_taint(yield->s);
}
- if (skipping)
+ if (flags & ESI_SKIPPING)
debug_printf_indent(UTF8_UP_RIGHT UTF8_HORIZ UTF8_HORIZ UTF8_HORIZ
"skipping: result is not used\n");
}
}
+ if (textonly_p) *textonly_p = textonly;
expand_level--;
return yield->s;
}
+
/* This is the external function call. Do a quick check for any expansion
metacharacters, and if there are none, just return the input string.
- Argument: the string to be expanded
+ Arguments
+ the string to be expanded
+ optional pointer for return boolean indicating no-dynamic-expansions
+
Returns: the expanded string, or NULL if expansion failed; if failure was
due to a lookup deferring, search_find_defer will be TRUE
*/
const uschar *
- expand_cstring(const uschar * string)
+ expand_string_2(const uschar * string, BOOL * textonly_p)
{
if (Ustrpbrk(string, "$\\") != NULL)
{
f.search_find_defer = FALSE;
malformed_header = FALSE;
store_pool = POOL_MAIN;
- s = expand_string_internal(string, FALSE, NULL, FALSE, TRUE, NULL);
+ s = expand_string_internal(string, ESI_HONOR_DOLLAR, NULL, NULL, textonly_p);
store_pool = old_pool;
return s;
}
+ if (textonly_p) *textonly_p = TRUE;
return string;
}
+ const uschar *
+ expand_cstring(const uschar * string)
+ { return expand_string_2(string, NULL); }
uschar *
expand_string(uschar * string)
- {
- return US expand_cstring(CUS string);
- }
+ { return US expand_string_2(CUS string, NULL); }
+
git://git.exim.org / exim.git / commitdiff