The following items are recognized in expanded strings. White space may be used between sub-items that are keywords or substrings enclosed in braces inside an outer set of braces, to improve readability.
"$<variable name> or ${<variable name>}"
Substitute the contents of the named variable, for example
$local_part
${domain}
The second form can be used to separate the name from subsequent alphanumeric characters. This form (using curly brackets) is available only for variables; it does not apply to message headers. The names of the variables are given in section "Expansion variables" below. If the name of a non-existent variable is given, the expansion fails.
"$header_<header name>: or $h_<header name>:"
Substitute the contents of the named message header, for example
$header_reply-to:
This particular expansion is intended mainly for use in filter files. The header names follow the syntax of RFC 822, which states that they may contain any printing characters except space and colon. Consequently, curly brackets do not terminate header names, and should not be used to enclose them as if they were variables. Attempting to do so causes a syntax error.
Upper-case and lower-case letters are synonymous in header names. If the following character is white space, the terminating colon may be omitted. The white space is included in the expanded string. If the message does not contain the given header, the expansion item is replaced by an empty string. (See the `def' condition in section "Expansion conditions" for a means of testing for the existence of a header.) If there is more than one header with the same name, they are all concatenated to form the substitution string, with a newline character between each of them. However, if the length of this string exceeds 64K, any further headers of the same name are ignored.
"${<op>:<string>}"
The string is first itself expanded, and then the operation specified by <op> is applied to it. For example,
${lc:$local_part}
A list of operators is given in section "Expansion operators" below. The string starts with the first character after the colon, which may be leading white space.
"${if <condition> {<string1>}{<string2>}}"
If <condition> is true, <string1> is expanded and replaces the whole item; otherwise <string2> is used. For example,
${if eq {$local_part}{postmaster} {yes}{no} }
The second string need not be present; if it is not and the condition is not true, the item is replaced with nothing. Alternatively, the word `fail' may be present instead of the second string (without any curly brackets). In this case, the expansion fails if the condition is not true. The available conditions are described in section "Expansion conditions" below.
"${lookup{<key>} <search type> {<file>} {<string1>} {<string2>}}"
"${lookup <search type> {<query>} {<string1>} {<string2>}}"
These items specify data lookups in files and databases, as discussed in chapter "". The first form is used for single-key lookups, and the second is used for query-style lookups. The <key>, <file>, and <query> strings are expanded before use.
If there is any white space in a lookup item which is part of a filter command, the lookup item must be enclosed in double quotes. The use of data lookups in users' filter files may be locked out by the system administrator.
If the lookup succeeds, then <string1> is expanded and replaces the entire item. During its expansion, a variable called `$value' is available, containing the data returned by the file lookup. If the lookup fails, <string2> is expanded and replaces the entire item. It may be omitted, in which case the replacement is null. Alternatively, <string2> can itself be another lookup, thus providing a mechanism for looking up a default value when the original lookup fails.
For single-key lookups, the string `partial-' is permitted to precede the search type in order to do partial matching, and * or *@ may follow a search type to request default lookups if the key does not match (see sections "" and "").
If a partial search is used, the variables `$1' and `$2' contain the wild and non-wild parts of the key during the expansion of the replacement text. They return to their previous values at the end of the lookup item.
Instead of {<string2>} the word `fail' can appear, and in this case, if the lookup fails, the entire expansion fails. This causes processing of the filter file to fail, which either delays delivery of the message, or causes the filter file to be ignored, depending on how the administrator has configured Exim.
This example looks up the postmaster alias in the conventional alias file.
"${lookup {postmaster} lsearch {/etc/aliases} {$value}}"
This example uses NIS+ to look up the full name of the user corresponding to the local part of an address, failing the expansion if it is not found.
"${lookup nisplus {[name=$local_part],passwd.org_dir:gcos} \
{$value}fail}"
"${lookup{<key:subkey>} <search type> {<file>} {<string1>} {<string2>}}"
This searches for <key> in the file as described above for single-key lookups; if it succeeds, it extracts from the data a subfield which is identified by the <subkey>. The data related to the main key must be of the form:
<subkey1> = <value1> <subkey2> = <value2> ...
where the equals signs are optional. If any of the values contain white space, they must be enclosed in double quotes, and any values that are enclosed in double quotes are subject to escape processing as described in section "Format of filter files". For example, if a line in a linearly searched file contains
alice: uid=1984 gid=2001
then expanding the string
${lookup{alice:uid}lsearch{<file name>}{$value}}
yields the string `1984'. If the subkey is not found in <string1>, then <string2>, if present, is expanded and replaces the entire item. Otherwise the replacement is null.
"${extract{<key>} {<string>}}"
The key and the string are first expanded. Then the subfield identified by the key is extracted from the string, exactly as just described for `lookup' items with subkeys. If the key is not found in the string, the item is replaced by nothing.
"${extract{<number>} {<separators>} {<string>}}"
This is distinguished from the above form of `extract' by having three rather than two arguments. It extracts from the string the field whose number is given as the first argument. The first field is numbered one. If the number is negative or greater than the number of fields in the string, the result is empty; if it is zero the entire string is returned. The fields in the string are separated by any one of the characters in the separator string. For example:
${extract{3}{:}{exim:x:42:99:& Mailer::/bin/bash}}
yields `42'. Two successive separators mean that the field between them is empty (for example, the sixth field above). If the first argument is not numeric, the expansion fails.
Go to the first, previous, next, last section, table of contents.