String expansions: fix ${extract }, for the numeric/3-string case. Bug 1807
[exim.git] / src / src / expand.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
3386088d 5/* Copyright (c) University of Cambridge 1995 - 2015 */
059ec3d9
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
8
9/* Functions for handling string expansion. */
10
11
12#include "exim.h"
13
96c065cb
PH
14/* Recursively called function */
15
55414b25
JH
16static uschar *expand_string_internal(const uschar *, BOOL, const uschar **, BOOL, BOOL, BOOL *);
17static int_eximarith_t expanded_string_integer(const uschar *, BOOL);
96c065cb 18
059ec3d9
PH
19#ifdef STAND_ALONE
20#ifndef SUPPORT_CRYPTEQ
21#define SUPPORT_CRYPTEQ
22#endif
23#endif
24
96c065cb
PH
25#ifdef LOOKUP_LDAP
26#include "lookups/ldap.h"
27#endif
28
059ec3d9
PH
29#ifdef SUPPORT_CRYPTEQ
30#ifdef CRYPT_H
31#include <crypt.h>
32#endif
33#ifndef HAVE_CRYPT16
34extern char* crypt16(char*, char*);
35#endif
36#endif
37
96c065cb
PH
38/* The handling of crypt16() is a mess. I will record below the analysis of the
39mess that was sent to me. We decided, however, to make changing this very low
40priority, because in practice people are moving away from the crypt()
41algorithms nowadays, so it doesn't seem worth it.
42
43<quote>
44There is an algorithm named "crypt16" in Ultrix and Tru64. It crypts
45the 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,
47or an empty block if the password is less than 9 characters, using a
4820-round version of crypt and the same salt as was used for the first
49block. Charaters after the first 16 are ignored. It always generates
50a 16-byte hash, which is expressed together with the salt as a string
51of 24 base 64 digits. Here are some links to peruse:
52
53 http://cvs.pld.org.pl/pam/pamcrypt/crypt16.c?rev=1.2
54 http://seclists.org/bugtraq/1999/Mar/0076.html
55
56There's a different algorithm named "bigcrypt" in HP-UX, Digital Unix,
57and OSF/1. This is the same as the standard crypt if given a password
58of 8 characters or less. If given more, it first does the same as crypt
59using the first 8 characters, then crypts the next 8 (the 9th to 16th)
60using as salt the first two base 64 digits from the first hash block.
61If the password is more than 16 characters then it crypts the 17th to 24th
62characters using as salt the first two base 64 digits from the second hash
63block. And so on: I've seen references to it cutting off the password at
6440 characters (5 blocks), 80 (10 blocks), or 128 (16 blocks). Some links:
65
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
70
71Exim has something it calls "crypt16". It will either use a native
72crypt16 or its own implementation. A native crypt16 will presumably
73be the one that I called "crypt16" above. The internal "crypt16"
74function, however, is a two-block-maximum implementation of what I called
75"bigcrypt". The documentation matches the internal code.
76
77I suspect that whoever did the "crypt16" stuff for Exim didn't realise
78that crypt16 and bigcrypt were different things.
79
80Exim uses the LDAP-style scheme identifier "{crypt16}" to refer
81to whatever it is using under that name. This unfortunately sets a
82precedent for using "{crypt16}" to identify two incompatible algorithms
83whose output can't be distinguished. With "{crypt16}" thus rendered
84ambiguous, I suggest you deprecate it and invent two new identifiers
85for the two algorithms.
86
87Both crypt16 and bigcrypt are very poor algorithms, btw. Hashing parts
88of the password separately means they can be cracked separately, so
89the double-length hash only doubles the cracking effort instead of
90squaring it. I recommend salted SHA-1 ({SSHA}), or the Blowfish-based
91bcrypt ({CRYPT}$2a$).
92</quote>
93*/
059ec3d9
PH
94
95
059ec3d9 96
059ec3d9
PH
97/*************************************************
98* Local statics and tables *
99*************************************************/
100
101/* Table of item names, and corresponding switch numbers. The names must be in
102alphabetical order. */
103
104static uschar *item_table[] = {
723c72e6 105 US"acl",
9d1c15ef 106 US"certextract",
1a46a8c5 107 US"dlfunc",
089fc87a 108 US"env",
059ec3d9 109 US"extract",
29f89cad 110 US"filter",
059ec3d9
PH
111 US"hash",
112 US"hmac",
113 US"if",
8c5d388a 114#ifdef SUPPORT_I18N
ed0512a1
JH
115 US"imapfolder",
116#endif
059ec3d9 117 US"length",
aa26e137 118 US"listextract",
059ec3d9 119 US"lookup",
29f89cad 120 US"map",
059ec3d9 121 US"nhash",
1a46a8c5 122 US"perl",
fffda43a
TK
123 US"prvs",
124 US"prvscheck",
059ec3d9
PH
125 US"readfile",
126 US"readsocket",
29f89cad 127 US"reduce",
059ec3d9
PH
128 US"run",
129 US"sg",
ac4ef9bd 130 US"sort",
059ec3d9
PH
131 US"substr",
132 US"tr" };
133
134enum {
723c72e6 135 EITEM_ACL,
9d1c15ef 136 EITEM_CERTEXTRACT,
1a46a8c5 137 EITEM_DLFUNC,
089fc87a 138 EITEM_ENV,
059ec3d9 139 EITEM_EXTRACT,
29f89cad 140 EITEM_FILTER,
059ec3d9
PH
141 EITEM_HASH,
142 EITEM_HMAC,
143 EITEM_IF,
8c5d388a 144#ifdef SUPPORT_I18N
ed0512a1
JH
145 EITEM_IMAPFOLDER,
146#endif
059ec3d9 147 EITEM_LENGTH,
aa26e137 148 EITEM_LISTEXTRACT,
059ec3d9 149 EITEM_LOOKUP,
29f89cad 150 EITEM_MAP,
059ec3d9 151 EITEM_NHASH,
1a46a8c5 152 EITEM_PERL,
fffda43a
TK
153 EITEM_PRVS,
154 EITEM_PRVSCHECK,
059ec3d9
PH
155 EITEM_READFILE,
156 EITEM_READSOCK,
29f89cad 157 EITEM_REDUCE,
059ec3d9
PH
158 EITEM_RUN,
159 EITEM_SG,
ac4ef9bd 160 EITEM_SORT,
059ec3d9
PH
161 EITEM_SUBSTR,
162 EITEM_TR };
163
164/* Tables of operator names, and corresponding switch numbers. The names must be
165in alphabetical order. There are two tables, because underscore is used in some
166cases to introduce arguments, whereas for other it is part of the name. This is
167an historical mis-design. */
168
169static uschar *op_table_underscore[] = {
170 US"from_utf8",
171 US"local_part",
172 US"quote_local_part",
83e029d5 173 US"reverse_ip",
f90d018c 174 US"time_eval",
4e08fd50 175 US"time_interval"
8c5d388a 176#ifdef SUPPORT_I18N
4e08fd50
JH
177 ,US"utf8_domain_from_alabel",
178 US"utf8_domain_to_alabel",
179 US"utf8_localpart_from_alabel",
180 US"utf8_localpart_to_alabel"
181#endif
182 };
059ec3d9
PH
183
184enum {
185 EOP_FROM_UTF8,
186 EOP_LOCAL_PART,
187 EOP_QUOTE_LOCAL_PART,
83e029d5 188 EOP_REVERSE_IP,
f90d018c 189 EOP_TIME_EVAL,
4e08fd50 190 EOP_TIME_INTERVAL
8c5d388a 191#ifdef SUPPORT_I18N
4e08fd50
JH
192 ,EOP_UTF8_DOMAIN_FROM_ALABEL,
193 EOP_UTF8_DOMAIN_TO_ALABEL,
194 EOP_UTF8_LOCALPART_FROM_ALABEL,
195 EOP_UTF8_LOCALPART_TO_ALABEL
196#endif
197 };
059ec3d9
PH
198
199static uschar *op_table_main[] = {
200 US"address",
29f89cad 201 US"addresses",
059ec3d9
PH
202 US"base62",
203 US"base62d",
9aa35e9c
JH
204 US"base64",
205 US"base64d",
059ec3d9
PH
206 US"domain",
207 US"escape",
208 US"eval",
209 US"eval10",
210 US"expand",
211 US"h",
212 US"hash",
213 US"hex2b64",
c393f931 214 US"hexquote",
fc4a7f70
JH
215 US"ipv6denorm",
216 US"ipv6norm",
059ec3d9
PH
217 US"l",
218 US"lc",
219 US"length",
a64a3dfa
JH
220 US"listcount",
221 US"listnamed",
059ec3d9
PH
222 US"mask",
223 US"md5",
224 US"nh",
225 US"nhash",
226 US"quote",
9e3331ea 227 US"randint",
059ec3d9 228 US"rfc2047",
9c57cbc0 229 US"rfc2047d",
059ec3d9
PH
230 US"rxquote",
231 US"s",
232 US"sha1",
9ef9101c 233 US"sha256",
059ec3d9
PH
234 US"stat",
235 US"str2b64",
236 US"strlen",
237 US"substr",
b9c2e32f
AR
238 US"uc",
239 US"utf8clean" };
059ec3d9
PH
240
241enum {
0539a19d 242 EOP_ADDRESS = nelem(op_table_underscore),
29f89cad 243 EOP_ADDRESSES,
059ec3d9
PH
244 EOP_BASE62,
245 EOP_BASE62D,
9aa35e9c
JH
246 EOP_BASE64,
247 EOP_BASE64D,
059ec3d9
PH
248 EOP_DOMAIN,
249 EOP_ESCAPE,
250 EOP_EVAL,
251 EOP_EVAL10,
252 EOP_EXPAND,
253 EOP_H,
254 EOP_HASH,
255 EOP_HEX2B64,
c393f931 256 EOP_HEXQUOTE,
fc4a7f70
JH
257 EOP_IPV6DENORM,
258 EOP_IPV6NORM,
059ec3d9
PH
259 EOP_L,
260 EOP_LC,
261 EOP_LENGTH,
a64a3dfa
JH
262 EOP_LISTCOUNT,
263 EOP_LISTNAMED,
059ec3d9
PH
264 EOP_MASK,
265 EOP_MD5,
266 EOP_NH,
267 EOP_NHASH,
268 EOP_QUOTE,
9e3331ea 269 EOP_RANDINT,
059ec3d9 270 EOP_RFC2047,
9c57cbc0 271 EOP_RFC2047D,
059ec3d9
PH
272 EOP_RXQUOTE,
273 EOP_S,
274 EOP_SHA1,
9ef9101c 275 EOP_SHA256,
059ec3d9
PH
276 EOP_STAT,
277 EOP_STR2B64,
278 EOP_STRLEN,
279 EOP_SUBSTR,
b9c2e32f
AR
280 EOP_UC,
281 EOP_UTF8CLEAN };
059ec3d9
PH
282
283
284/* Table of condition names, and corresponding switch numbers. The names must
285be in alphabetical order. */
286
287static uschar *cond_table[] = {
288 US"<",
289 US"<=",
290 US"=",
291 US"==", /* Backward compatibility */
292 US">",
293 US">=",
333eea9c 294 US"acl",
059ec3d9 295 US"and",
f3766eb5 296 US"bool",
6a8de854 297 US"bool_lax",
059ec3d9
PH
298 US"crypteq",
299 US"def",
300 US"eq",
301 US"eqi",
302 US"exists",
303 US"first_delivery",
0ce9abe6
PH
304 US"forall",
305 US"forany",
059ec3d9
PH
306 US"ge",
307 US"gei",
308 US"gt",
309 US"gti",
76dca828
PP
310 US"inlist",
311 US"inlisti",
059ec3d9
PH
312 US"isip",
313 US"isip4",
314 US"isip6",
315 US"ldapauth",
316 US"le",
317 US"lei",
318 US"lt",
319 US"lti",
320 US"match",
321 US"match_address",
322 US"match_domain",
32d668a5 323 US"match_ip",
059ec3d9
PH
324 US"match_local_part",
325 US"or",
326 US"pam",
327 US"pwcheck",
328 US"queue_running",
329 US"radius",
330 US"saslauthd"
331};
332
333enum {
334 ECOND_NUM_L,
335 ECOND_NUM_LE,
336 ECOND_NUM_E,
337 ECOND_NUM_EE,
338 ECOND_NUM_G,
339 ECOND_NUM_GE,
333eea9c 340 ECOND_ACL,
059ec3d9 341 ECOND_AND,
f3766eb5 342 ECOND_BOOL,
6a8de854 343 ECOND_BOOL_LAX,
059ec3d9
PH
344 ECOND_CRYPTEQ,
345 ECOND_DEF,
346 ECOND_STR_EQ,
347 ECOND_STR_EQI,
348 ECOND_EXISTS,
349 ECOND_FIRST_DELIVERY,
0ce9abe6
PH
350 ECOND_FORALL,
351 ECOND_FORANY,
059ec3d9
PH
352 ECOND_STR_GE,
353 ECOND_STR_GEI,
354 ECOND_STR_GT,
355 ECOND_STR_GTI,
76dca828
PP
356 ECOND_INLIST,
357 ECOND_INLISTI,
059ec3d9
PH
358 ECOND_ISIP,
359 ECOND_ISIP4,
360 ECOND_ISIP6,
361 ECOND_LDAPAUTH,
362 ECOND_STR_LE,
363 ECOND_STR_LEI,
364 ECOND_STR_LT,
365 ECOND_STR_LTI,
366 ECOND_MATCH,
367 ECOND_MATCH_ADDRESS,
368 ECOND_MATCH_DOMAIN,
32d668a5 369 ECOND_MATCH_IP,
059ec3d9
PH
370 ECOND_MATCH_LOCAL_PART,
371 ECOND_OR,
372 ECOND_PAM,
373 ECOND_PWCHECK,
374 ECOND_QUEUE_RUNNING,
375 ECOND_RADIUS,
376 ECOND_SASLAUTHD
377};
378
379
059ec3d9
PH
380/* Types of table entry */
381
7e75538e 382enum vtypes {
059ec3d9
PH
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) */
11d7e4fa 388 vtype_bool, /* value is address of bool */
059ec3d9
PH
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 */
ff75a1f7
PH
392 vtype_msgheaders, /* the message's headers, processed */
393 vtype_msgheaders_raw, /* the message's headers, unprocessed */
059ec3d9
PH
394 vtype_localpart, /* extract local part from string */
395 vtype_domain, /* extract domain from string */
362145b5 396 vtype_string_func, /* value is string returned by given function */
059ec3d9
PH
397 vtype_todbsdin, /* value not used; generate BSD inbox tod */
398 vtype_tode, /* value not used; generate tod in epoch format */
f5787926 399 vtype_todel, /* value not used; generate tod in epoch/usec format */
059ec3d9
PH
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 */
5cb8cbc6
PH
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 */
9d1c15ef
JH
410 vtype_pinodes, /* partition inodes; value is T/F for spool/log */
411 vtype_cert /* SSL certificate */
80a47a2c
TK
412 #ifndef DISABLE_DKIM
413 ,vtype_dkim /* Lookup of value in DKIM signature */
414 #endif
7e75538e
JH
415};
416
417/* Type for main variable table */
418
419typedef struct {
420 const char *name;
421 enum vtypes type;
422 void *value;
423} var_entry;
424
425/* Type for entries pointing to address/length pairs. Not currently
426in use. */
427
428typedef struct {
429 uschar **address;
430 int *length;
431} alblock;
059ec3d9 432
362145b5
JH
433static uschar * fn_recipients(void);
434
059ec3d9
PH
435/* This table must be kept in alphabetical order. */
436
437static var_entry var_table[] = {
38a0a95f
PH
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. */
525239c1
JH
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 },
059ec3d9
PH
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 },
2d07a215 454 { "authenticated_fail_id",vtype_stringptr, &authenticated_fail_id },
059ec3d9
PH
455 { "authenticated_id", vtype_stringptr, &authenticated_id },
456 { "authenticated_sender",vtype_stringptr, &authenticated_sender },
457 { "authentication_failed",vtype_int, &authentication_failed },
9e949f00
PP
458#ifdef WITH_CONTENT_SCAN
459 { "av_failed", vtype_int, &av_failed },
460#endif
8523533c
TK
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 },
466#endif
059ec3d9
PH
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 },
055e2cb4 473 { "callout_address", vtype_stringptr, &callout_address },
059ec3d9
PH
474 { "compile_date", vtype_stringptr, &version_date },
475 { "compile_number", vtype_stringptr, &version_cnumber },
98b8312f
HSHR
476 { "config_dir", vtype_stringptr, &config_main_directory },
477 { "config_file", vtype_stringptr, &config_main_filename },
e5a9dba6 478 { "csa_status", vtype_stringptr, &csa_status },
6a8f9482
TK
479#ifdef EXPERIMENTAL_DCC
480 { "dcc_header", vtype_stringptr, &dcc_header },
481 { "dcc_result", vtype_stringptr, &dcc_result },
482#endif
8523533c
TK
483#ifdef WITH_OLD_DEMIME
484 { "demime_errorlevel", vtype_int, &demime_errorlevel },
485 { "demime_reason", vtype_stringptr, &demime_reason },
486#endif
80a47a2c
TK
487#ifndef DISABLE_DKIM
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 },
2df588c9 494 { "dkim_cur_signer", vtype_stringptr, &dkim_cur_signer },
e08d09e5 495 { "dkim_domain", vtype_stringptr, &dkim_signing_domain },
80a47a2c
TK
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 },
abe1010c 500 { "dkim_key_length", vtype_int, &dkim_key_length },
80a47a2c
TK
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 },
e08d09e5 505 { "dkim_selector", vtype_stringptr, &dkim_signing_selector },
9e5d6b55 506 { "dkim_signers", vtype_stringptr, &dkim_signers },
80a47a2c
TK
507 { "dkim_verify_reason", vtype_dkim, (void *)DKIM_VERIFY_REASON },
508 { "dkim_verify_status", vtype_dkim, (void *)DKIM_VERIFY_STATUS},
e08d09e5 509#endif
4840604e
TL
510#ifdef EXPERIMENTAL_DMARC
511 { "dmarc_ar_header", vtype_stringptr, &dmarc_ar_header },
8c8b8274 512 { "dmarc_domain_policy", vtype_stringptr, &dmarc_domain_policy },
4840604e
TL
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 },
516#endif
059ec3d9 517 { "dnslist_domain", vtype_stringptr, &dnslist_domain },
93655c46 518 { "dnslist_matched", vtype_stringptr, &dnslist_matched },
059ec3d9
PH
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 },
0cbf2b82 523#ifndef DISABLE_EVENT
774ef2d7
JH
524 { "event_data", vtype_stringptr, &event_data },
525
526 /*XXX want to use generic vars for as many of these as possible*/
527 { "event_defer_errno", vtype_int, &event_defer_errno },
528
529 { "event_name", vtype_stringptr, &event_name },
530#endif
059ec3d9
PH
531 { "exim_gid", vtype_gid, &exim_gid },
532 { "exim_path", vtype_stringptr, &exim_path },
533 { "exim_uid", vtype_uid, &exim_uid },
71224040 534 { "exim_version", vtype_stringptr, &version_string },
8523533c
TK
535#ifdef WITH_OLD_DEMIME
536 { "found_extension", vtype_stringptr, &found_extension },
8e669ac1 537#endif
362145b5 538 { "headers_added", vtype_string_func, &fn_hdrs_added },
059ec3d9
PH
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 },
b08b24c8 543 { "host_lookup_deferred",vtype_int, &host_lookup_deferred },
059ec3d9 544 { "host_lookup_failed", vtype_int, &host_lookup_failed },
a7538db1 545 { "host_port", vtype_int, &deliver_host_port },
3615fa9a 546 { "initial_cwd", vtype_stringptr, &initial_cwd },
059ec3d9
PH
547 { "inode", vtype_ino, &deliver_inode },
548 { "interface_address", vtype_stringptr, &interface_address },
549 { "interface_port", vtype_int, &interface_port },
0ce9abe6 550 { "item", vtype_stringptr, &iterate_item },
059ec3d9
PH
551 #ifdef LOOKUP_LDAP
552 { "ldap_dn", vtype_stringptr, &eldap_dn },
553 #endif
554 { "load_average", vtype_load_avg, NULL },
555 { "local_part", vtype_stringptr, &deliver_localpart },
556 { "local_part_data", vtype_stringptr, &deliver_localpart_data },
557 { "local_part_prefix", vtype_stringptr, &deliver_localpart_prefix },
558 { "local_part_suffix", vtype_stringptr, &deliver_localpart_suffix },
559 { "local_scan_data", vtype_stringptr, &local_scan_data },
560 { "local_user_gid", vtype_gid, &local_user_gid },
561 { "local_user_uid", vtype_uid, &local_user_uid },
562 { "localhost_number", vtype_int, &host_number },
5cb8cbc6 563 { "log_inodes", vtype_pinodes, (void *)FALSE },
8e669ac1 564 { "log_space", vtype_pspace, (void *)FALSE },
4e0983dc 565 { "lookup_dnssec_authenticated",vtype_stringptr,&lookup_dnssec_authenticated},
059ec3d9 566 { "mailstore_basename", vtype_stringptr, &mailstore_basename },
8523533c
TK
567#ifdef WITH_CONTENT_SCAN
568 { "malware_name", vtype_stringptr, &malware_name },
569#endif
d677b2f2 570 { "max_received_linelength", vtype_int, &max_received_linelength },
059ec3d9
PH
571 { "message_age", vtype_int, &message_age },
572 { "message_body", vtype_msgbody, &message_body },
573 { "message_body_end", vtype_msgbody_end, &message_body_end },
574 { "message_body_size", vtype_int, &message_body_size },
1ab52c69 575 { "message_exim_id", vtype_stringptr, &message_id },
059ec3d9 576 { "message_headers", vtype_msgheaders, NULL },
ff75a1f7 577 { "message_headers_raw", vtype_msgheaders_raw, NULL },
059ec3d9 578 { "message_id", vtype_stringptr, &message_id },
2e0c1448 579 { "message_linecount", vtype_int, &message_linecount },
059ec3d9 580 { "message_size", vtype_int, &message_size },
8c5d388a 581#ifdef SUPPORT_I18N
eb02f5df
JH
582 { "message_smtputf8", vtype_bool, &message_smtputf8 },
583#endif
8523533c
TK
584#ifdef WITH_CONTENT_SCAN
585 { "mime_anomaly_level", vtype_int, &mime_anomaly_level },
586 { "mime_anomaly_text", vtype_stringptr, &mime_anomaly_text },
587 { "mime_boundary", vtype_stringptr, &mime_boundary },
588 { "mime_charset", vtype_stringptr, &mime_charset },
589 { "mime_content_description", vtype_stringptr, &mime_content_description },
590 { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
591 { "mime_content_id", vtype_stringptr, &mime_content_id },
592 { "mime_content_size", vtype_int, &mime_content_size },
593 { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
594 { "mime_content_type", vtype_stringptr, &mime_content_type },
595 { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
596 { "mime_filename", vtype_stringptr, &mime_filename },
597 { "mime_is_coverletter", vtype_int, &mime_is_coverletter },
598 { "mime_is_multipart", vtype_int, &mime_is_multipart },
599 { "mime_is_rfc822", vtype_int, &mime_is_rfc822 },
600 { "mime_part_count", vtype_int, &mime_part_count },
601#endif
059ec3d9
PH
602 { "n0", vtype_filter_int, &filter_n[0] },
603 { "n1", vtype_filter_int, &filter_n[1] },
604 { "n2", vtype_filter_int, &filter_n[2] },
605 { "n3", vtype_filter_int, &filter_n[3] },
606 { "n4", vtype_filter_int, &filter_n[4] },
607 { "n5", vtype_filter_int, &filter_n[5] },
608 { "n6", vtype_filter_int, &filter_n[6] },
609 { "n7", vtype_filter_int, &filter_n[7] },
610 { "n8", vtype_filter_int, &filter_n[8] },
611 { "n9", vtype_filter_int, &filter_n[9] },
612 { "original_domain", vtype_stringptr, &deliver_domain_orig },
613 { "original_local_part", vtype_stringptr, &deliver_localpart_orig },
614 { "originator_gid", vtype_gid, &originator_gid },
615 { "originator_uid", vtype_uid, &originator_uid },
616 { "parent_domain", vtype_stringptr, &deliver_domain_parent },
617 { "parent_local_part", vtype_stringptr, &deliver_localpart_parent },
618 { "pid", vtype_pid, NULL },
858e91c2
JH
619#ifndef DISABLE_PRDR
620 { "prdr_requested", vtype_bool, &prdr_requested },
621#endif
059ec3d9 622 { "primary_hostname", vtype_stringptr, &primary_hostname },
e6d2a989
JH
623#if defined(SUPPORT_PROXY) || defined(SUPPORT_SOCKS)
624 { "proxy_external_address",vtype_stringptr, &proxy_external_address },
625 { "proxy_external_port", vtype_int, &proxy_external_port },
626 { "proxy_local_address", vtype_stringptr, &proxy_local_address },
627 { "proxy_local_port", vtype_int, &proxy_local_port },
a3c86431
TL
628 { "proxy_session", vtype_bool, &proxy_session },
629#endif
fffda43a
TK
630 { "prvscheck_address", vtype_stringptr, &prvscheck_address },
631 { "prvscheck_keynum", vtype_stringptr, &prvscheck_keynum },
632 { "prvscheck_result", vtype_stringptr, &prvscheck_result },
059ec3d9
PH
633 { "qualify_domain", vtype_stringptr, &qualify_domain_sender },
634 { "qualify_recipient", vtype_stringptr, &qualify_domain_recipient },
635 { "rcpt_count", vtype_int, &rcpt_count },
636 { "rcpt_defer_count", vtype_int, &rcpt_defer_count },
637 { "rcpt_fail_count", vtype_int, &rcpt_fail_count },
638 { "received_count", vtype_int, &received_count },
639 { "received_for", vtype_stringptr, &received_for },
194cc0e4
PH
640 { "received_ip_address", vtype_stringptr, &interface_address },
641 { "received_port", vtype_int, &interface_port },
059ec3d9 642 { "received_protocol", vtype_stringptr, &received_protocol },
7dbf77c9 643 { "received_time", vtype_int, &received_time },
059ec3d9 644 { "recipient_data", vtype_stringptr, &recipient_data },
8e669ac1 645 { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
362145b5 646 { "recipients", vtype_string_func, &fn_recipients },
059ec3d9 647 { "recipients_count", vtype_int, &recipients_count },
8523533c
TK
648#ifdef WITH_CONTENT_SCAN
649 { "regex_match_string", vtype_stringptr, &regex_match_string },
650#endif
059ec3d9
PH
651 { "reply_address", vtype_reply, NULL },
652 { "return_path", vtype_stringptr, &return_path },
653 { "return_size_limit", vtype_int, &bounce_return_size_limit },
181d9bf8 654 { "router_name", vtype_stringptr, &router_name },
059ec3d9
PH
655 { "runrc", vtype_int, &runrc },
656 { "self_hostname", vtype_stringptr, &self_hostname },
657 { "sender_address", vtype_stringptr, &sender_address },
2a3eea10 658 { "sender_address_data", vtype_stringptr, &sender_address_data },
059ec3d9
PH
659 { "sender_address_domain", vtype_domain, &sender_address },
660 { "sender_address_local_part", vtype_localpart, &sender_address },
661 { "sender_data", vtype_stringptr, &sender_data },
662 { "sender_fullhost", vtype_stringptr, &sender_fullhost },
1705dd20 663 { "sender_helo_dnssec", vtype_bool, &sender_helo_dnssec },
059ec3d9
PH
664 { "sender_helo_name", vtype_stringptr, &sender_helo_name },
665 { "sender_host_address", vtype_stringptr, &sender_host_address },
666 { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
11d7e4fa 667 { "sender_host_dnssec", vtype_bool, &sender_host_dnssec },
059ec3d9
PH
668 { "sender_host_name", vtype_host_lookup, NULL },
669 { "sender_host_port", vtype_int, &sender_host_port },
670 { "sender_ident", vtype_stringptr, &sender_ident },
870f6ba8
TF
671 { "sender_rate", vtype_stringptr, &sender_rate },
672 { "sender_rate_limit", vtype_stringptr, &sender_rate_limit },
673 { "sender_rate_period", vtype_stringptr, &sender_rate_period },
059ec3d9 674 { "sender_rcvhost", vtype_stringptr, &sender_rcvhost },
8e669ac1 675 { "sender_verify_failure",vtype_stringptr, &sender_verify_failure },
41c7c167
PH
676 { "sending_ip_address", vtype_stringptr, &sending_ip_address },
677 { "sending_port", vtype_int, &sending_port },
8e669ac1 678 { "smtp_active_hostname", vtype_stringptr, &smtp_active_hostname },
3ee512ff
PH
679 { "smtp_command", vtype_stringptr, &smtp_cmd_buffer },
680 { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
b01dd148 681 { "smtp_count_at_connection_start", vtype_int, &smtp_accept_count },
8f128379 682 { "smtp_notquit_reason", vtype_stringptr, &smtp_notquit_reason },
059ec3d9
PH
683 { "sn0", vtype_filter_int, &filter_sn[0] },
684 { "sn1", vtype_filter_int, &filter_sn[1] },
685 { "sn2", vtype_filter_int, &filter_sn[2] },
686 { "sn3", vtype_filter_int, &filter_sn[3] },
687 { "sn4", vtype_filter_int, &filter_sn[4] },
688 { "sn5", vtype_filter_int, &filter_sn[5] },
689 { "sn6", vtype_filter_int, &filter_sn[6] },
690 { "sn7", vtype_filter_int, &filter_sn[7] },
691 { "sn8", vtype_filter_int, &filter_sn[8] },
692 { "sn9", vtype_filter_int, &filter_sn[9] },
8523533c 693#ifdef WITH_CONTENT_SCAN
c5f280e2 694 { "spam_action", vtype_stringptr, &spam_action },
8523533c
TK
695 { "spam_bar", vtype_stringptr, &spam_bar },
696 { "spam_report", vtype_stringptr, &spam_report },
697 { "spam_score", vtype_stringptr, &spam_score },
698 { "spam_score_int", vtype_stringptr, &spam_score_int },
699#endif
700#ifdef EXPERIMENTAL_SPF
65a7d8c3 701 { "spf_guess", vtype_stringptr, &spf_guess },
8523533c
TK
702 { "spf_header_comment", vtype_stringptr, &spf_header_comment },
703 { "spf_received", vtype_stringptr, &spf_received },
704 { "spf_result", vtype_stringptr, &spf_result },
705 { "spf_smtp_comment", vtype_stringptr, &spf_smtp_comment },
706#endif
059ec3d9 707 { "spool_directory", vtype_stringptr, &spool_directory },
5cb8cbc6 708 { "spool_inodes", vtype_pinodes, (void *)TRUE },
8e669ac1 709 { "spool_space", vtype_pspace, (void *)TRUE },
8523533c
TK
710#ifdef EXPERIMENTAL_SRS
711 { "srs_db_address", vtype_stringptr, &srs_db_address },
712 { "srs_db_key", vtype_stringptr, &srs_db_key },
713 { "srs_orig_recipient", vtype_stringptr, &srs_orig_recipient },
714 { "srs_orig_sender", vtype_stringptr, &srs_orig_sender },
715 { "srs_recipient", vtype_stringptr, &srs_recipient },
716 { "srs_status", vtype_stringptr, &srs_status },
717#endif
059ec3d9 718 { "thisaddress", vtype_stringptr, &filter_thisaddress },
817d9f57 719
d9b2312b 720 /* The non-(in,out) variables are now deprecated */
817d9f57
JH
721 { "tls_bits", vtype_int, &tls_in.bits },
722 { "tls_certificate_verified", vtype_int, &tls_in.certificate_verified },
723 { "tls_cipher", vtype_stringptr, &tls_in.cipher },
d9b2312b
JH
724
725 { "tls_in_bits", vtype_int, &tls_in.bits },
726 { "tls_in_certificate_verified", vtype_int, &tls_in.certificate_verified },
727 { "tls_in_cipher", vtype_stringptr, &tls_in.cipher },
44662487 728 { "tls_in_ocsp", vtype_int, &tls_in.ocsp },
9d1c15ef
JH
729 { "tls_in_ourcert", vtype_cert, &tls_in.ourcert },
730 { "tls_in_peercert", vtype_cert, &tls_in.peercert },
d9b2312b 731 { "tls_in_peerdn", vtype_stringptr, &tls_in.peerdn },
4b57b15d 732#if defined(SUPPORT_TLS)
d9b2312b
JH
733 { "tls_in_sni", vtype_stringptr, &tls_in.sni },
734#endif
817d9f57 735 { "tls_out_bits", vtype_int, &tls_out.bits },
cb9d95ae 736 { "tls_out_certificate_verified", vtype_int,&tls_out.certificate_verified },
817d9f57 737 { "tls_out_cipher", vtype_stringptr, &tls_out.cipher },
594706ea
JH
738#ifdef EXPERIMENTAL_DANE
739 { "tls_out_dane", vtype_bool, &tls_out.dane_verified },
740#endif
44662487 741 { "tls_out_ocsp", vtype_int, &tls_out.ocsp },
9d1c15ef
JH
742 { "tls_out_ourcert", vtype_cert, &tls_out.ourcert },
743 { "tls_out_peercert", vtype_cert, &tls_out.peercert },
817d9f57 744 { "tls_out_peerdn", vtype_stringptr, &tls_out.peerdn },
4b57b15d 745#if defined(SUPPORT_TLS)
817d9f57 746 { "tls_out_sni", vtype_stringptr, &tls_out.sni },
7be682ca 747#endif
594706ea
JH
748#ifdef EXPERIMENTAL_DANE
749 { "tls_out_tlsa_usage", vtype_int, &tls_out.tlsa_usage },
750#endif
d9b2312b 751
613dd4ae 752 { "tls_peerdn", vtype_stringptr, &tls_in.peerdn }, /* mind the alphabetical order! */
4b57b15d 753#if defined(SUPPORT_TLS)
613dd4ae
JH
754 { "tls_sni", vtype_stringptr, &tls_in.sni }, /* mind the alphabetical order! */
755#endif
817d9f57 756
059ec3d9
PH
757 { "tod_bsdinbox", vtype_todbsdin, NULL },
758 { "tod_epoch", vtype_tode, NULL },
f5787926 759 { "tod_epoch_l", vtype_todel, NULL },
059ec3d9
PH
760 { "tod_full", vtype_todf, NULL },
761 { "tod_log", vtype_todl, NULL },
762 { "tod_logfile", vtype_todlf, NULL },
763 { "tod_zone", vtype_todzone, NULL },
764 { "tod_zulu", vtype_todzulu, NULL },
181d9bf8 765 { "transport_name", vtype_stringptr, &transport_name },
059ec3d9 766 { "value", vtype_stringptr, &lookup_value },
aec45841 767 { "verify_mode", vtype_stringptr, &verify_mode },
059ec3d9
PH
768 { "version_number", vtype_stringptr, &version_string },
769 { "warn_message_delay", vtype_stringptr, &warnmsg_delay },
770 { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
771 { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
772 { "warnmsg_delay", vtype_stringptr, &warnmsg_delay },
773 { "warnmsg_recipient", vtype_stringptr, &warnmsg_recipients },
774 { "warnmsg_recipients", vtype_stringptr, &warnmsg_recipients }
775};
776
0539a19d 777static int var_table_size = nelem(var_table);
059ec3d9
PH
778static uschar var_buffer[256];
779static BOOL malformed_header;
780
781/* For textual hashes */
782
1ba28e2b
PP
783static const char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
784 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
785 "0123456789";
059ec3d9
PH
786
787enum { HMAC_MD5, HMAC_SHA1 };
788
789/* For numeric hashes */
790
791static unsigned int prime[] = {
792 2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
793 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
794 73, 79, 83, 89, 97, 101, 103, 107, 109, 113};
795
796/* For printing modes in symbolic form */
797
798static uschar *mtable_normal[] =
799 { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
800
801static uschar *mtable_setid[] =
802 { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
803
804static uschar *mtable_sticky[] =
805 { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
806
807
808
809/*************************************************
810* Tables for UTF-8 support *
811*************************************************/
812
813/* Table of the number of extra characters, indexed by the first character
814masked with 0x3f. The highest number for a valid UTF-8 character is in fact
8150x3d. */
816
817static uschar utf8_table1[] = {
818 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
819 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
820 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
821 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
822
823/* These are the masks for the data bits in the first byte of a character,
824indexed by the number of additional bytes. */
825
826static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
827
828/* Get the next UTF-8 character, advancing the pointer. */
829
830#define GETUTF8INC(c, ptr) \
831 c = *ptr++; \
832 if ((c & 0xc0) == 0xc0) \
833 { \
834 int a = utf8_table1[c & 0x3f]; /* Number of additional bytes */ \
835 int s = 6*a; \
836 c = (c & utf8_table2[a]) << s; \
837 while (a-- > 0) \
838 { \
839 s -= 6; \
840 c |= (*ptr++ & 0x3f) << s; \
841 } \
842 }
843
844
845/*************************************************
846* Binary chop search on a table *
847*************************************************/
848
849/* This is used for matching expansion items and operators.
850
851Arguments:
852 name the name that is being sought
853 table the table to search
854 table_size the number of items in the table
855
856Returns: the offset in the table, or -1
857*/
858
859static int
860chop_match(uschar *name, uschar **table, int table_size)
861{
862uschar **bot = table;
863uschar **top = table + table_size;
864
865while (top > bot)
866 {
867 uschar **mid = bot + (top - bot)/2;
868 int c = Ustrcmp(name, *mid);
869 if (c == 0) return mid - table;
870 if (c > 0) bot = mid + 1; else top = mid;
871 }
872
873return -1;
874}
875
876
877
878/*************************************************
879* Check a condition string *
880*************************************************/
881
882/* This function is called to expand a string, and test the result for a "true"
883or "false" value. Failure of the expansion yields FALSE; logged unless it was a
be7a5781
JH
884forced fail or lookup defer.
885
886We used to release all store used, but this is not not safe due
887to ${dlfunc } and ${acl }. In any case expand_string_internal()
888is reasonably careful to release what it can.
059ec3d9 889
6a8de854
PP
890The actual false-value tests should be replicated for ECOND_BOOL_LAX.
891
059ec3d9
PH
892Arguments:
893 condition the condition string
894 m1 text to be incorporated in panic error
895 m2 ditto
896
897Returns: TRUE if condition is met, FALSE if not
898*/
899
900BOOL
901expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
902{
903int rc;
059ec3d9
PH
904uschar *ss = expand_string(condition);
905if (ss == NULL)
906 {
907 if (!expand_string_forcedfail && !search_find_defer)
908 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
909 "for %s %s: %s", condition, m1, m2, expand_string_message);
910 return FALSE;
911 }
912rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
913 strcmpic(ss, US"false") != 0;
059ec3d9
PH
914return rc;
915}
916
917
918
17c76198 919
059ec3d9 920/*************************************************
9e3331ea
TK
921* Pseudo-random number generation *
922*************************************************/
923
924/* Pseudo-random number generation. The result is not "expected" to be
925cryptographically strong but not so weak that someone will shoot themselves
926in the foot using it as a nonce in some email header scheme or whatever
927weirdness they'll twist this into. The result should ideally handle fork().
928
929However, if we're stuck unable to provide this, then we'll fall back to
930appallingly bad randomness.
931
17c76198
PP
932If SUPPORT_TLS is defined then this will not be used except as an emergency
933fallback.
9e3331ea
TK
934
935Arguments:
936 max range maximum
937Returns a random number in range [0, max-1]
938*/
939
17c76198
PP
940#ifdef SUPPORT_TLS
941# define vaguely_random_number vaguely_random_number_fallback
942#endif
9e3331ea 943int
17c76198 944vaguely_random_number(int max)
9e3331ea 945{
17c76198
PP
946#ifdef SUPPORT_TLS
947# undef vaguely_random_number
948#endif
9e3331ea
TK
949 static pid_t pid = 0;
950 pid_t p2;
951#if defined(HAVE_SRANDOM) && !defined(HAVE_SRANDOMDEV)
952 struct timeval tv;
953#endif
954
955 p2 = getpid();
956 if (p2 != pid)
957 {
958 if (pid != 0)
959 {
960
961#ifdef HAVE_ARC4RANDOM
962 /* cryptographically strong randomness, common on *BSD platforms, not
963 so much elsewhere. Alas. */
46ca7017 964#ifndef NOT_HAVE_ARC4RANDOM_STIR
9e3331ea 965 arc4random_stir();
46ca7017 966#endif
9e3331ea
TK
967#elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
968#ifdef HAVE_SRANDOMDEV
969 /* uses random(4) for seeding */
970 srandomdev();
971#else
972 gettimeofday(&tv, NULL);
973 srandom(tv.tv_sec | tv.tv_usec | getpid());
974#endif
975#else
976 /* Poor randomness and no seeding here */
977#endif
978
979 }
980 pid = p2;
981 }
982
983#ifdef HAVE_ARC4RANDOM
984 return arc4random() % max;
985#elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
986 return random() % max;
987#else
988 /* This one returns a 16-bit number, definitely not crypto-strong */
989 return random_number(max);
990#endif
991}
992
17c76198
PP
993
994
9e3331ea
TK
995
996/*************************************************
059ec3d9
PH
997* Pick out a name from a string *
998*************************************************/
999
1000/* If the name is too long, it is silently truncated.
1001
1002Arguments:
1003 name points to a buffer into which to put the name
1004 max is the length of the buffer
1005 s points to the first alphabetic character of the name
1006 extras chars other than alphanumerics to permit
1007
1008Returns: pointer to the first character after the name
1009
1010Note: The test for *s != 0 in the while loop is necessary because
1011Ustrchr() yields non-NULL if the character is zero (which is not something
1012I expected). */
1013
55414b25
JH
1014static const uschar *
1015read_name(uschar *name, int max, const uschar *s, uschar *extras)
059ec3d9
PH
1016{
1017int ptr = 0;
1018while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
1019 {
1020 if (ptr < max-1) name[ptr++] = *s;
1021 s++;
1022 }
1023name[ptr] = 0;
1024return s;
1025}
1026
1027
1028
1029/*************************************************
1030* Pick out the rest of a header name *
1031*************************************************/
1032
1033/* A variable name starting $header_ (or just $h_ for those who like
1034abbreviations) might not be the complete header name because headers can
1035contain any printing characters in their names, except ':'. This function is
1036called to read the rest of the name, chop h[eader]_ off the front, and put ':'
1037on the end, if the name was terminated by white space.
1038
1039Arguments:
1040 name points to a buffer in which the name read so far exists
1041 max is the length of the buffer
1042 s points to the first character after the name so far, i.e. the
1043 first non-alphameric character after $header_xxxxx
1044
1045Returns: a pointer to the first character after the header name
1046*/
1047
55414b25
JH
1048static const uschar *
1049read_header_name(uschar *name, int max, const uschar *s)
059ec3d9
PH
1050{
1051int prelen = Ustrchr(name, '_') - name + 1;
1052int ptr = Ustrlen(name) - prelen;
1053if (ptr > 0) memmove(name, name+prelen, ptr);
1054while (mac_isgraph(*s) && *s != ':')
1055 {
1056 if (ptr < max-1) name[ptr++] = *s;
1057 s++;
1058 }
1059if (*s == ':') s++;
1060name[ptr++] = ':';
1061name[ptr] = 0;
1062return s;
1063}
1064
1065
1066
1067/*************************************************
1068* Pick out a number from a string *
1069*************************************************/
1070
1071/* Arguments:
1072 n points to an integer into which to put the number
1073 s points to the first digit of the number
1074
1075Returns: a pointer to the character after the last digit
1076*/
13559da6
JH
1077/*XXX consider expanding to int_eximarith_t. But the test for
1078"overbig numbers" in 0002 still needs to overflow it. */
059ec3d9
PH
1079
1080static uschar *
1081read_number(int *n, uschar *s)
1082{
1083*n = 0;
1084while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1085return s;
1086}
1087
55414b25
JH
1088static const uschar *
1089read_cnumber(int *n, const uschar *s)
1090{
1091*n = 0;
1092while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1093return s;
1094}
1095
059ec3d9
PH
1096
1097
1098/*************************************************
1099* Extract keyed subfield from a string *
1100*************************************************/
1101
1102/* The yield is in dynamic store; NULL means that the key was not found.
1103
1104Arguments:
1105 key points to the name of the key
1106 s points to the string from which to extract the subfield
1107
1108Returns: NULL if the subfield was not found, or
1109 a pointer to the subfield's data
1110*/
1111
1112static uschar *
55414b25 1113expand_getkeyed(uschar *key, const uschar *s)
059ec3d9
PH
1114{
1115int length = Ustrlen(key);
1116while (isspace(*s)) s++;
1117
1118/* Loop to search for the key */
1119
1120while (*s != 0)
1121 {
1122 int dkeylength;
1123 uschar *data;
55414b25 1124 const uschar *dkey = s;
059ec3d9
PH
1125
1126 while (*s != 0 && *s != '=' && !isspace(*s)) s++;
1127 dkeylength = s - dkey;
1128 while (isspace(*s)) s++;
1129 if (*s == '=') while (isspace((*(++s))));
1130
1131 data = string_dequote(&s);
1132 if (length == dkeylength && strncmpic(key, dkey, length) == 0)
1133 return data;
1134
1135 while (isspace(*s)) s++;
1136 }
1137
1138return NULL;
1139}
1140
1141
1142
9d1c15ef
JH
1143static var_entry *
1144find_var_ent(uschar * name)
1145{
1146int first = 0;
1147int last = var_table_size;
1148
1149while (last > first)
1150 {
1151 int middle = (first + last)/2;
1152 int c = Ustrcmp(name, var_table[middle].name);
1153
1154 if (c > 0) { first = middle + 1; continue; }
1155 if (c < 0) { last = middle; continue; }
1156 return &var_table[middle];
1157 }
1158return NULL;
1159}
059ec3d9
PH
1160
1161/*************************************************
1162* Extract numbered subfield from string *
1163*************************************************/
1164
1165/* Extracts a numbered field from a string that is divided by tokens - for
1166example a line from /etc/passwd is divided by colon characters. First field is
1167numbered one. Negative arguments count from the right. Zero returns the whole
1168string. Returns NULL if there are insufficient tokens in the string
1169
1170***WARNING***
1171Modifies final argument - this is a dynamically generated string, so that's OK.
1172
1173Arguments:
1174 field number of field to be extracted,
1175 first field = 1, whole string = 0, last field = -1
1176 separators characters that are used to break string into tokens
1177 s points to the string from which to extract the subfield
1178
1179Returns: NULL if the field was not found,
1180 a pointer to the field's data inside s (modified to add 0)
1181*/
1182
1183static uschar *
1184expand_gettokened (int field, uschar *separators, uschar *s)
1185{
1186int sep = 1;
1187int count;
1188uschar *ss = s;
1189uschar *fieldtext = NULL;
1190
1191if (field == 0) return s;
1192
1193/* Break the line up into fields in place; for field > 0 we stop when we have
1194done the number of fields we want. For field < 0 we continue till the end of
1195the string, counting the number of fields. */
1196
1197count = (field > 0)? field : INT_MAX;
1198
1199while (count-- > 0)
1200 {
1201 size_t len;
1202
1203 /* Previous field was the last one in the string. For a positive field
1204 number, this means there are not enough fields. For a negative field number,
1205 check that there are enough, and scan back to find the one that is wanted. */
1206
1207 if (sep == 0)
1208 {
1209 if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
1210 if ((-field) == (INT_MAX - count - 1)) return s;
1211 while (field++ < 0)
1212 {
1213 ss--;
1214 while (ss[-1] != 0) ss--;
1215 }
1216 fieldtext = ss;
1217 break;
1218 }
1219
1220 /* Previous field was not last in the string; save its start and put a
1221 zero at its end. */
1222
1223 fieldtext = ss;
1224 len = Ustrcspn(ss, separators);
1225 sep = ss[len];
1226 ss[len] = 0;
1227 ss += len + 1;
1228 }
1229
1230return fieldtext;
1231}
1232
1233
aa26e137 1234static uschar *
55414b25 1235expand_getlistele(int field, const uschar * list)
aa26e137 1236{
55414b25 1237const uschar * tlist= list;
aa26e137
JH
1238int sep= 0;
1239uschar dummy;
1240
1241if(field<0)
0f0c8159 1242 {
aa26e137
JH
1243 for(field++; string_nextinlist(&tlist, &sep, &dummy, 1); ) field++;
1244 sep= 0;
0f0c8159 1245 }
aa26e137
JH
1246if(field==0) return NULL;
1247while(--field>0 && (string_nextinlist(&list, &sep, &dummy, 1))) ;
1248return string_nextinlist(&list, &sep, NULL, 0);
1249}
059ec3d9 1250
9d1c15ef
JH
1251
1252/* Certificate fields, by name. Worry about by-OID later */
9e4dddbd 1253/* Names are chosen to not have common prefixes */
9d1c15ef
JH
1254
1255#ifdef SUPPORT_TLS
1256typedef struct
1257{
1258uschar * name;
9e4dddbd
JH
1259int namelen;
1260uschar * (*getfn)(void * cert, uschar * mod);
9d1c15ef
JH
1261} certfield;
1262static certfield certfields[] =
1263{ /* linear search; no special order */
9e4dddbd
JH
1264 { US"version", 7, &tls_cert_version },
1265 { US"serial_number", 13, &tls_cert_serial_number },
1266 { US"subject", 7, &tls_cert_subject },
1267 { US"notbefore", 9, &tls_cert_not_before },
1268 { US"notafter", 8, &tls_cert_not_after },
1269 { US"issuer", 6, &tls_cert_issuer },
1270 { US"signature", 9, &tls_cert_signature },
1271 { US"sig_algorithm", 13, &tls_cert_signature_algorithm },
1272 { US"subj_altname", 12, &tls_cert_subject_altname },
1273 { US"ocsp_uri", 8, &tls_cert_ocsp_uri },
1274 { US"crl_uri", 7, &tls_cert_crl_uri },
9d1c15ef
JH
1275};
1276
1277static uschar *
1278expand_getcertele(uschar * field, uschar * certvar)
1279{
1280var_entry * vp;
1281certfield * cp;
1282
1283if (!(vp = find_var_ent(certvar)))
1284 {
94431adb 1285 expand_string_message =
9d1c15ef
JH
1286 string_sprintf("no variable named \"%s\"", certvar);
1287 return NULL; /* Unknown variable name */
1288 }
1289/* NB this stops us passing certs around in variable. Might
1290want to do that in future */
1291if (vp->type != vtype_cert)
1292 {
94431adb 1293 expand_string_message =
9d1c15ef
JH
1294 string_sprintf("\"%s\" is not a certificate", certvar);
1295 return NULL; /* Unknown variable name */
1296 }
1297if (!*(void **)vp->value)
1298 return NULL;
1299
1300if (*field >= '0' && *field <= '9')
1301 return tls_cert_ext_by_oid(*(void **)vp->value, field, 0);
1302
1303for(cp = certfields;
0539a19d 1304 cp < certfields + nelem(certfields);
9d1c15ef 1305 cp++)
9e4dddbd
JH
1306 if (Ustrncmp(cp->name, field, cp->namelen) == 0)
1307 {
1308 uschar * modifier = *(field += cp->namelen) == ','
1309 ? ++field : NULL;
1310 return (*cp->getfn)( *(void **)vp->value, modifier );
1311 }
9d1c15ef 1312
94431adb 1313expand_string_message =
9d1c15ef
JH
1314 string_sprintf("bad field selector \"%s\" for certextract", field);
1315return NULL;
1316}
1317#endif /*SUPPORT_TLS*/
1318
059ec3d9
PH
1319/*************************************************
1320* Extract a substring from a string *
1321*************************************************/
1322
1323/* Perform the ${substr or ${length expansion operations.
1324
1325Arguments:
1326 subject the input string
1327 value1 the offset from the start of the input string to the start of
1328 the output string; if negative, count from the right.
1329 value2 the length of the output string, or negative (-1) for unset
1330 if value1 is positive, unset means "all after"
1331 if value1 is negative, unset means "all before"
1332 len set to the length of the returned string
1333
1334Returns: pointer to the output string, or NULL if there is an error
1335*/
1336
1337static uschar *
1338extract_substr(uschar *subject, int value1, int value2, int *len)
1339{
1340int sublen = Ustrlen(subject);
1341
1342if (value1 < 0) /* count from right */
1343 {
1344 value1 += sublen;
1345
1346 /* If the position is before the start, skip to the start, and adjust the
1347 length. If the length ends up negative, the substring is null because nothing
1348 can precede. This falls out naturally when the length is unset, meaning "all
1349 to the left". */
1350
1351 if (value1 < 0)
1352 {
1353 value2 += value1;
1354 if (value2 < 0) value2 = 0;
1355 value1 = 0;
1356 }
1357
1358 /* Otherwise an unset length => characters before value1 */
1359
1360 else if (value2 < 0)
1361 {
1362 value2 = value1;
1363 value1 = 0;
1364 }
1365 }
1366
1367/* For a non-negative offset, if the starting position is past the end of the
1368string, the result will be the null string. Otherwise, an unset length means
1369"rest"; just set it to the maximum - it will be cut down below if necessary. */
1370
1371else
1372 {
1373 if (value1 > sublen)
1374 {
1375 value1 = sublen;
1376 value2 = 0;
1377 }
1378 else if (value2 < 0) value2 = sublen;
1379 }
1380
1381/* Cut the length down to the maximum possible for the offset value, and get
1382the required characters. */
1383
1384if (value1 + value2 > sublen) value2 = sublen - value1;
1385*len = value2;
1386return subject + value1;
1387}
1388
1389
1390
1391
1392/*************************************************
1393* Old-style hash of a string *
1394*************************************************/
1395
1396/* Perform the ${hash expansion operation.
1397
1398Arguments:
1399 subject the input string (an expanded substring)
1400 value1 the length of the output string; if greater or equal to the
1401 length of the input string, the input string is returned
1402 value2 the number of hash characters to use, or 26 if negative
1403 len set to the length of the returned string
1404
1405Returns: pointer to the output string, or NULL if there is an error
1406*/
1407
1408static uschar *
1409compute_hash(uschar *subject, int value1, int value2, int *len)
1410{
1411int sublen = Ustrlen(subject);
1412
1413if (value2 < 0) value2 = 26;
1414else if (value2 > Ustrlen(hashcodes))
1415 {
1416 expand_string_message =
1417 string_sprintf("hash count \"%d\" too big", value2);
1418 return NULL;
1419 }
1420
1421/* Calculate the hash text. We know it is shorter than the original string, so
1422can safely place it in subject[] (we know that subject is always itself an
1423expanded substring). */
1424
1425if (value1 < sublen)
1426 {
1427 int c;
1428 int i = 0;
1429 int j = value1;
1430 while ((c = (subject[j])) != 0)
1431 {
1432 int shift = (c + j++) & 7;
1433 subject[i] ^= (c << shift) | (c >> (8-shift));
1434 if (++i >= value1) i = 0;
1435 }
1436 for (i = 0; i < value1; i++)
1437 subject[i] = hashcodes[(subject[i]) % value2];
1438 }
1439else value1 = sublen;
1440
1441*len = value1;
1442return subject;
1443}
1444
1445
1446
1447
1448/*************************************************
1449* Numeric hash of a string *
1450*************************************************/
1451
1452/* Perform the ${nhash expansion operation. The first characters of the
1453string are treated as most important, and get the highest prime numbers.
1454
1455Arguments:
1456 subject the input string
1457 value1 the maximum value of the first part of the result
1458 value2 the maximum value of the second part of the result,
1459 or negative to produce only a one-part result
1460 len set to the length of the returned string
1461
1462Returns: pointer to the output string, or NULL if there is an error.
1463*/
1464
1465static uschar *
1466compute_nhash (uschar *subject, int value1, int value2, int *len)
1467{
1468uschar *s = subject;
1469int i = 0;
1470unsigned long int total = 0; /* no overflow */
1471
1472while (*s != 0)
1473 {
0539a19d 1474 if (i == 0) i = nelem(prime) - 1;
059ec3d9
PH
1475 total += prime[i--] * (unsigned int)(*s++);
1476 }
1477
1478/* If value2 is unset, just compute one number */
1479
1480if (value2 < 0)
1481 {
1482 s = string_sprintf("%d", total % value1);
1483 }
1484
1485/* Otherwise do a div/mod hash */
1486
1487else
1488 {
1489 total = total % (value1 * value2);
1490 s = string_sprintf("%d/%d", total/value2, total % value2);
1491 }
1492
1493*len = Ustrlen(s);
1494return s;
1495}
1496
1497
1498
1499
1500
1501/*************************************************
1502* Find the value of a header or headers *
1503*************************************************/
1504
1505/* Multiple instances of the same header get concatenated, and this function
1506can also return a concatenation of all the header lines. When concatenating
1507specific headers that contain lists of addresses, a comma is inserted between
1508them. Otherwise we use a straight concatenation. Because some messages can have
1509pathologically large number of lines, there is a limit on the length that is
1510returned. Also, to avoid massive store use which would result from using
1511string_cat() as it copies and extends strings, we do a preliminary pass to find
1512out exactly how much store will be needed. On "normal" messages this will be
1513pretty trivial.
1514
1515Arguments:
1516 name the name of the header, without the leading $header_ or $h_,
1517 or NULL if a concatenation of all headers is required
1518 exists_only TRUE if called from a def: test; don't need to build a string;
1519 just return a string that is not "" and not "0" if the header
1520 exists
1521 newsize return the size of memory block that was obtained; may be NULL
1522 if exists_only is TRUE
1523 want_raw TRUE if called for $rh_ or $rheader_ variables; no processing,
ff75a1f7
PH
1524 other than concatenating, will be done on the header. Also used
1525 for $message_headers_raw.
059ec3d9
PH
1526 charset name of charset to translate MIME words to; used only if
1527 want_raw is false; if NULL, no translation is done (this is
1528 used for $bh_ and $bheader_)
1529
1530Returns: NULL if the header does not exist, else a pointer to a new
1531 store block
1532*/
1533
1534static uschar *
1535find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1536 uschar *charset)
1537{
1538BOOL found = name == NULL;
1539int comma = 0;
1540int len = found? 0 : Ustrlen(name);
1541int i;
1542uschar *yield = NULL;
1543uschar *ptr = NULL;
1544
1545/* Loop for two passes - saves code repetition */
1546
1547for (i = 0; i < 2; i++)
1548 {
1549 int size = 0;
1550 header_line *h;
1551
1552 for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1553 {
1554 if (h->type != htype_old && h->text != NULL) /* NULL => Received: placeholder */
1555 {
1556 if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1557 {
1558 int ilen;
1559 uschar *t;
1560
1561 if (exists_only) return US"1"; /* don't need actual string */
1562 found = TRUE;
1563 t = h->text + len; /* text to insert */
1564 if (!want_raw) /* unless wanted raw, */
1565 while (isspace(*t)) t++; /* remove leading white space */
1566 ilen = h->slen - (t - h->text); /* length to insert */
1567
fd700877
PH
1568 /* Unless wanted raw, remove trailing whitespace, including the
1569 newline. */
1570
1571 if (!want_raw)
1572 while (ilen > 0 && isspace(t[ilen-1])) ilen--;
1573
059ec3d9
PH
1574 /* Set comma = 1 if handling a single header and it's one of those
1575 that contains an address list, except when asked for raw headers. Only
1576 need to do this once. */
1577
1578 if (!want_raw && name != NULL && comma == 0 &&
1579 Ustrchr("BCFRST", h->type) != NULL)
1580 comma = 1;
1581
1582 /* First pass - compute total store needed; second pass - compute
1583 total store used, including this header. */
1584
fd700877 1585 size += ilen + comma + 1; /* +1 for the newline */
059ec3d9
PH
1586
1587 /* Second pass - concatentate the data, up to a maximum. Note that
1588 the loop stops when size hits the limit. */
1589
1590 if (i != 0)
1591 {
1592 if (size > header_insert_maxlen)
1593 {
fd700877 1594 ilen -= size - header_insert_maxlen - 1;
059ec3d9
PH
1595 comma = 0;
1596 }
1597 Ustrncpy(ptr, t, ilen);
1598 ptr += ilen;
fd700877
PH
1599
1600 /* For a non-raw header, put in the comma if needed, then add
3168332a
PH
1601 back the newline we removed above, provided there was some text in
1602 the header. */
fd700877 1603
3168332a 1604 if (!want_raw && ilen > 0)
059ec3d9 1605 {
3168332a 1606 if (comma != 0) *ptr++ = ',';
059ec3d9
PH
1607 *ptr++ = '\n';
1608 }
1609 }
1610 }
1611 }
1612 }
1613
fd700877
PH
1614 /* At end of first pass, return NULL if no header found. Then truncate size
1615 if necessary, and get the buffer to hold the data, returning the buffer size.
1616 */
059ec3d9
PH
1617
1618 if (i == 0)
1619 {
1620 if (!found) return NULL;
1621 if (size > header_insert_maxlen) size = header_insert_maxlen;
1622 *newsize = size + 1;
1623 ptr = yield = store_get(*newsize);
1624 }
1625 }
1626
059ec3d9
PH
1627/* That's all we do for raw header expansion. */
1628
1629if (want_raw)
1630 {
1631 *ptr = 0;
1632 }
1633
fd700877
PH
1634/* Otherwise, remove a final newline and a redundant added comma. Then we do
1635RFC 2047 decoding, translating the charset if requested. The rfc2047_decode2()
059ec3d9
PH
1636function can return an error with decoded data if the charset translation
1637fails. If decoding fails, it returns NULL. */
1638
1639else
1640 {
1641 uschar *decoded, *error;
3168332a 1642 if (ptr > yield && ptr[-1] == '\n') ptr--;
fd700877 1643 if (ptr > yield && comma != 0 && ptr[-1] == ',') ptr--;
059ec3d9 1644 *ptr = 0;
a0d6ba8a
PH
1645 decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1646 newsize, &error);
059ec3d9
PH
1647 if (error != NULL)
1648 {
1649 DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1650 " input was: %s\n", error, yield);
1651 }
1652 if (decoded != NULL) yield = decoded;
1653 }
1654
1655return yield;
1656}
1657
1658
1659
1660
1661/*************************************************
362145b5
JH
1662* Return list of recipients *
1663*************************************************/
1664/* A recipients list is available only during system message filtering,
1665during ACL processing after DATA, and while expanding pipe commands
1666generated from a system filter, but not elsewhere. */
1667
1668static uschar *
1669fn_recipients(void)
1670{
1671if (!enable_dollar_recipients) return NULL; else
1672 {
1673 int size = 128;
1674 int ptr = 0;
1675 int i;
1676 uschar * s = store_get(size);
1677 for (i = 0; i < recipients_count; i++)
1678 {
1679 if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1680 s = string_cat(s, &size, &ptr, recipients_list[i].address,
1681 Ustrlen(recipients_list[i].address));
1682 }
1683 s[ptr] = 0; /* string_cat() leaves room */
1684 return s;
1685 }
1686}
1687
1688
1689/*************************************************
059ec3d9
PH
1690* Find value of a variable *
1691*************************************************/
1692
1693/* The table of variables is kept in alphabetic order, so we can search it
1694using a binary chop. The "choplen" variable is nothing to do with the binary
1695chop.
1696
1697Arguments:
1698 name the name of the variable being sought
1699 exists_only TRUE if this is a def: test; passed on to find_header()
1700 skipping TRUE => skip any processing evaluation; this is not the same as
1701 exists_only because def: may test for values that are first
1702 evaluated here
1703 newsize pointer to an int which is initially zero; if the answer is in
1704 a new memory buffer, *newsize is set to its size
1705
1706Returns: NULL if the variable does not exist, or
1707 a pointer to the variable's contents, or
1708 something non-NULL if exists_only is TRUE
1709*/
1710
1711static uschar *
1712find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1713{
9d1c15ef
JH
1714var_entry * vp;
1715uschar *s, *domain;
1716uschar **ss;
1717void * val;
059ec3d9 1718
38a0a95f
PH
1719/* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1720Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1721release 4.64 onwards arbitrary names are permitted, as long as the first 5
641cb756
PH
1722characters are acl_c or acl_m and the sixth is either a digit or an underscore
1723(this gave backwards compatibility at the changeover). There may be built-in
1724variables whose names start acl_ but they should never start in this way. This
1725slightly messy specification is a consequence of the history, needless to say.
47ca6d6c 1726
38a0a95f
PH
1727If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1728set, in which case give an error. */
47ca6d6c 1729
641cb756
PH
1730if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1731 !isalpha(name[5]))
38a0a95f
PH
1732 {
1733 tree_node *node =
1734 tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
63df3f26 1735 return node ? node->data.ptr : strict_acl_vars ? NULL : US"";
47ca6d6c
PH
1736 }
1737
38a0a95f 1738/* Handle $auth<n> variables. */
f78eb7c6
PH
1739
1740if (Ustrncmp(name, "auth", 4) == 0)
1741 {
1742 uschar *endptr;
1743 int n = Ustrtoul(name + 4, &endptr, 10);
1744 if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
f38917cc
JH
1745 return !auth_vars[n-1] ? US"" : auth_vars[n-1];
1746 }
1747else if (Ustrncmp(name, "regex", 5) == 0)
1748 {
1749 uschar *endptr;
1750 int n = Ustrtoul(name + 5, &endptr, 10);
1751 if (*endptr == 0 && n != 0 && n <= REGEX_VARS)
1752 return !regex_vars[n-1] ? US"" : regex_vars[n-1];
f78eb7c6
PH
1753 }
1754
47ca6d6c
PH
1755/* For all other variables, search the table */
1756
9d1c15ef
JH
1757if (!(vp = find_var_ent(name)))
1758 return NULL; /* Unknown variable name */
059ec3d9 1759
9d1c15ef
JH
1760/* Found an existing variable. If in skipping state, the value isn't needed,
1761and we want to avoid processing (such as looking up the host name). */
059ec3d9 1762
9d1c15ef
JH
1763if (skipping)
1764 return US"";
059ec3d9 1765
9d1c15ef
JH
1766val = vp->value;
1767switch (vp->type)
1768 {
1769 case vtype_filter_int:
63df3f26
JH
1770 if (!filter_running) return NULL;
1771 /* Fall through */
1772 /* VVVVVVVVVVVV */
9d1c15ef 1773 case vtype_int:
63df3f26
JH
1774 sprintf(CS var_buffer, "%d", *(int *)(val)); /* Integer */
1775 return var_buffer;
9d1c15ef
JH
1776
1777 case vtype_ino:
63df3f26
JH
1778 sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(val))); /* Inode */
1779 return var_buffer;
9d1c15ef
JH
1780
1781 case vtype_gid:
63df3f26
JH
1782 sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(val))); /* gid */
1783 return var_buffer;
9d1c15ef
JH
1784
1785 case vtype_uid:
63df3f26
JH
1786 sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(val))); /* uid */
1787 return var_buffer;
9d1c15ef
JH
1788
1789 case vtype_bool:
63df3f26
JH
1790 sprintf(CS var_buffer, "%s", *(BOOL *)(val) ? "yes" : "no"); /* bool */
1791 return var_buffer;
9d1c15ef
JH
1792
1793 case vtype_stringptr: /* Pointer to string */
63df3f26 1794 return (s = *((uschar **)(val))) ? s : US"";
9d1c15ef
JH
1795
1796 case vtype_pid:
63df3f26
JH
1797 sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1798 return var_buffer;
9d1c15ef
JH
1799
1800 case vtype_load_avg:
63df3f26
JH
1801 sprintf(CS var_buffer, "%d", OS_GETLOADAVG()); /* load_average */
1802 return var_buffer;
9d1c15ef
JH
1803
1804 case vtype_host_lookup: /* Lookup if not done so */
63df3f26
JH
1805 if (sender_host_name == NULL && sender_host_address != NULL &&
1806 !host_lookup_failed && host_name_lookup() == OK)
1807 host_build_sender_fullhost();
1808 return (sender_host_name == NULL)? US"" : sender_host_name;
9d1c15ef
JH
1809
1810 case vtype_localpart: /* Get local part from address */
63df3f26
JH
1811 s = *((uschar **)(val));
1812 if (s == NULL) return US"";
1813 domain = Ustrrchr(s, '@');
1814 if (domain == NULL) return s;
1815 if (domain - s > sizeof(var_buffer) - 1)
1816 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than " SIZE_T_FMT
1817 " in string expansion", sizeof(var_buffer));
1818 Ustrncpy(var_buffer, s, domain - s);
1819 var_buffer[domain - s] = 0;
1820 return var_buffer;
9d1c15ef
JH
1821
1822 case vtype_domain: /* Get domain from address */
63df3f26
JH
1823 s = *((uschar **)(val));
1824 if (s == NULL) return US"";
1825 domain = Ustrrchr(s, '@');
1826 return (domain == NULL)? US"" : domain + 1;
9d1c15ef
JH
1827
1828 case vtype_msgheaders:
63df3f26 1829 return find_header(NULL, exists_only, newsize, FALSE, NULL);
9d1c15ef
JH
1830
1831 case vtype_msgheaders_raw:
63df3f26 1832 return find_header(NULL, exists_only, newsize, TRUE, NULL);
9d1c15ef
JH
1833
1834 case vtype_msgbody: /* Pointer to msgbody string */
1835 case vtype_msgbody_end: /* Ditto, the end of the msg */
63df3f26
JH
1836 ss = (uschar **)(val);
1837 if (*ss == NULL && deliver_datafile >= 0) /* Read body when needed */
059ec3d9 1838 {
63df3f26
JH
1839 uschar *body;
1840 off_t start_offset = SPOOL_DATA_START_OFFSET;
1841 int len = message_body_visible;
1842 if (len > message_size) len = message_size;
1843 *ss = body = store_malloc(len+1);
1844 body[0] = 0;
1845 if (vp->type == vtype_msgbody_end)
9d1c15ef 1846 {
63df3f26
JH
1847 struct stat statbuf;
1848 if (fstat(deliver_datafile, &statbuf) == 0)
1849 {
1850 start_offset = statbuf.st_size - len;
1851 if (start_offset < SPOOL_DATA_START_OFFSET)
1852 start_offset = SPOOL_DATA_START_OFFSET;
1853 }
9d1c15ef 1854 }
d4ff61d1
JH
1855 if (lseek(deliver_datafile, start_offset, SEEK_SET) < 0)
1856 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "deliver_datafile lseek: %s",
1857 strerror(errno));
63df3f26
JH
1858 len = read(deliver_datafile, body, len);
1859 if (len > 0)
9d1c15ef 1860 {
63df3f26
JH
1861 body[len] = 0;
1862 if (message_body_newlines) /* Separate loops for efficiency */
1863 while (len > 0)
1864 { if (body[--len] == 0) body[len] = ' '; }
1865 else
1866 while (len > 0)
1867 { if (body[--len] == '\n' || body[len] == 0) body[len] = ' '; }
9d1c15ef 1868 }
059ec3d9 1869 }
63df3f26 1870 return (*ss == NULL)? US"" : *ss;
059ec3d9 1871
9d1c15ef 1872 case vtype_todbsdin: /* BSD inbox time of day */
63df3f26 1873 return tod_stamp(tod_bsdin);
059ec3d9 1874
9d1c15ef 1875 case vtype_tode: /* Unix epoch time of day */
63df3f26 1876 return tod_stamp(tod_epoch);
059ec3d9 1877
9d1c15ef 1878 case vtype_todel: /* Unix epoch/usec time of day */
63df3f26 1879 return tod_stamp(tod_epoch_l);
f5787926 1880
9d1c15ef 1881 case vtype_todf: /* Full time of day */
63df3f26 1882 return tod_stamp(tod_full);
059ec3d9 1883
9d1c15ef 1884 case vtype_todl: /* Log format time of day */
63df3f26 1885 return tod_stamp(tod_log_bare); /* (without timezone) */
059ec3d9 1886
9d1c15ef 1887 case vtype_todzone: /* Time zone offset only */
63df3f26 1888 return tod_stamp(tod_zone);
059ec3d9 1889
9d1c15ef 1890 case vtype_todzulu: /* Zulu time */
63df3f26 1891 return tod_stamp(tod_zulu);
059ec3d9 1892
9d1c15ef 1893 case vtype_todlf: /* Log file datestamp tod */
63df3f26 1894 return tod_stamp(tod_log_datestamp_daily);
059ec3d9 1895
9d1c15ef 1896 case vtype_reply: /* Get reply address */
63df3f26
JH
1897 s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1898 headers_charset);
1899 if (s != NULL) while (isspace(*s)) s++;
1900 if (s == NULL || *s == 0)
1901 {
1902 *newsize = 0; /* For the *s==0 case */
1903 s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1904 }
1905 if (s != NULL)
1906 {
1907 uschar *t;
1908 while (isspace(*s)) s++;
1909 for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1910 while (t > s && isspace(t[-1])) t--;
1911 *t = 0;
1912 }
1913 return (s == NULL)? US"" : s;
059ec3d9 1914
9d1c15ef
JH
1915 case vtype_string_func:
1916 {
1917 uschar * (*fn)() = val;
1918 return fn();
1919 }
8e669ac1 1920
9d1c15ef
JH
1921 case vtype_pspace:
1922 {
1923 int inodes;
1924 sprintf(CS var_buffer, "%d",
1925 receive_statvfs(val == (void *)TRUE, &inodes));
1926 }
1927 return var_buffer;
8e669ac1 1928
9d1c15ef
JH
1929 case vtype_pinodes:
1930 {
1931 int inodes;
1932 (void) receive_statvfs(val == (void *)TRUE, &inodes);
1933 sprintf(CS var_buffer, "%d", inodes);
1934 }
1935 return var_buffer;
80a47a2c 1936
9d1c15ef 1937 case vtype_cert:
63df3f26 1938 return *(void **)val ? US"<cert>" : US"";
80a47a2c 1939
63df3f26 1940#ifndef DISABLE_DKIM
9d1c15ef 1941 case vtype_dkim:
63df3f26
JH
1942 return dkim_exim_expand_query((int)(long)val);
1943#endif
059ec3d9 1944
9d1c15ef 1945 }
6c08476d
LM
1946
1947return NULL; /* Unknown variable. Silences static checkers. */
059ec3d9
PH
1948}
1949
1950
1951
1952
d9b2312b
JH
1953void
1954modify_variable(uschar *name, void * value)
1955{
9d1c15ef
JH
1956var_entry * vp;
1957if ((vp = find_var_ent(name))) vp->value = value;
d9b2312b
JH
1958return; /* Unknown variable name, fail silently */
1959}
1960
1961
1962
1963
1964
059ec3d9
PH
1965/*************************************************
1966* Read and expand substrings *
1967*************************************************/
1968
1969/* This function is called to read and expand argument substrings for various
1970expansion items. Some have a minimum requirement that is less than the maximum;
1971in these cases, the first non-present one is set to NULL.
1972
1973Arguments:
1974 sub points to vector of pointers to set
1975 n maximum number of substrings
1976 m minimum required
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
b0e85a8f
JH
1981 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
1982 the store.
059ec3d9
PH
1983
1984Returns: 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)
1988*/
1989
1990static int
55414b25 1991read_subs(uschar **sub, int n, int m, const uschar **sptr, BOOL skipping,
b0e85a8f 1992 BOOL check_end, uschar *name, BOOL *resetok)
059ec3d9
PH
1993{
1994int i;
55414b25 1995const uschar *s = *sptr;
059ec3d9
PH
1996
1997while (isspace(*s)) s++;
1998for (i = 0; i < n; i++)
1999 {
2000 if (*s != '{')
2001 {
2002 if (i < m) return 1;
2003 sub[i] = NULL;
2004 break;
2005 }
b0e85a8f 2006 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, resetok);
059ec3d9
PH
2007 if (sub[i] == NULL) return 3;
2008 if (*s++ != '}') return 1;
2009 while (isspace(*s)) s++;
2010 }
2011if (check_end && *s++ != '}')
2012 {
2013 if (s[-1] == '{')
2014 {
2015 expand_string_message = string_sprintf("Too many arguments for \"%s\" "
2016 "(max is %d)", name, n);
2017 return 2;
2018 }
2019 return 1;
2020 }
2021
2022*sptr = s;
2023return 0;
2024}
2025
2026
2027
2028
2029/*************************************************
641cb756
PH
2030* Elaborate message for bad variable *
2031*************************************************/
2032
2033/* For the "unknown variable" message, take a look at the variable's name, and
2034give additional information about possible ACL variables. The extra information
2035is added on to expand_string_message.
2036
2037Argument: the name of the variable
2038Returns: nothing
2039*/
2040
2041static void
2042check_variable_error_message(uschar *name)
2043{
2044if (Ustrncmp(name, "acl_", 4) == 0)
2045 expand_string_message = string_sprintf("%s (%s)", expand_string_message,
2046 (name[4] == 'c' || name[4] == 'm')?
2047 (isalpha(name[5])?
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 */
2050 ) :
2051 US"user-defined ACL variables must start acl_c or acl_m");
2052}
2053
2054
2055
f60d98e8
JH
2056/*
2057Load args from sub array to globals, and call acl_check().
ef21c07d 2058Sub array will be corrupted on return.
f60d98e8
JH
2059
2060Returns: 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
2065 ERROR disaster
2066*/
2067static int
2068eval_acl(uschar ** sub, int nsub, uschar ** user_msgp)
2069{
2070int i;
ef21c07d
JH
2071int sav_narg = acl_narg;
2072int ret;
93a6fce2 2073uschar * dummy_logmsg;
faa05a93 2074extern int acl_where;
f60d98e8 2075
0539a19d 2076if(--nsub > nelem(acl_arg)) nsub = nelem(acl_arg);
ef21c07d
JH
2077for (i = 0; i < nsub && sub[i+1]; i++)
2078 {
93a6fce2 2079 uschar * tmp = acl_arg[i];
ef21c07d
JH
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 */
2082 }
2083acl_narg = i;
bef3ea7f 2084while (i < nsub)
ef21c07d
JH
2085 {
2086 sub[i+1] = acl_arg[i];
2087 acl_arg[i++] = NULL;
2088 }
f60d98e8
JH
2089
2090DEBUG(D_expand)
2091 debug_printf("expanding: acl: %s arg: %s%s\n",
2092 sub[0],
60f8e1e8
JH
2093 acl_narg>0 ? acl_arg[0] : US"<none>",
2094 acl_narg>1 ? " +more" : "");
f60d98e8 2095
93a6fce2 2096ret = acl_eval(acl_where, sub[0], user_msgp, &dummy_logmsg);
ef21c07d
JH
2097
2098for (i = 0; i < nsub; i++)
2099 acl_arg[i] = sub[i+1]; /* restore old args */
2100acl_narg = sav_narg;
2101
2102return ret;
f60d98e8
JH
2103}
2104
2105
2106
2107
641cb756 2108/*************************************************
059ec3d9
PH
2109* Read and evaluate a condition *
2110*************************************************/
2111
2112/*
2113Arguments:
2114 s points to the start of the condition text
b0e85a8f
JH
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.
059ec3d9
PH
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
2122
2123Returns: a pointer to the first character after the condition, or
2124 NULL after an error
2125*/
2126
55414b25
JH
2127static const uschar *
2128eval_condition(const uschar *s, BOOL *resetok, BOOL *yield)
059ec3d9
PH
2129{
2130BOOL testfor = TRUE;
2131BOOL tempcond, combined_cond;
2132BOOL *subcondptr;
5cfd2e57 2133BOOL sub2_honour_dollar = TRUE;
059ec3d9 2134int i, rc, cond_type, roffset;
97d17305 2135int_eximarith_t num[2];
059ec3d9
PH
2136struct stat statbuf;
2137uschar name[256];
55414b25 2138const uschar *sub[10];
059ec3d9
PH
2139
2140const pcre *re;
2141const uschar *rerror;
2142
2143for (;;)
2144 {
2145 while (isspace(*s)) s++;
2146 if (*s == '!') { testfor = !testfor; s++; } else break;
2147 }
2148
2149/* Numeric comparisons are symbolic */
2150
2151if (*s == '=' || *s == '>' || *s == '<')
2152 {
2153 int p = 0;
2154 name[p++] = *s++;
2155 if (*s == '=')
2156 {
2157 name[p++] = '=';
2158 s++;
2159 }
2160 name[p] = 0;
2161 }
2162
2163/* All other conditions are named */
2164
2165else s = read_name(name, 256, s, US"_");
2166
2167/* If we haven't read a name, it means some non-alpha character is first. */
2168
2169if (name[0] == 0)
2170 {
2171 expand_string_message = string_sprintf("condition name expected, "
2172 "but found \"%.16s\"", s);
2173 return NULL;
2174 }
2175
2176/* Find which condition we are dealing with, and switch on it */
2177
0539a19d 2178cond_type = chop_match(name, cond_table, nelem(cond_table));
059ec3d9
PH
2179switch(cond_type)
2180 {
9b4768fa
PH
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. */
059ec3d9
PH
2183
2184 case ECOND_DEF:
2185 if (*s != ':')
2186 {
2187 expand_string_message = US"\":\" expected after \"def\"";
2188 return NULL;
2189 }
2190
2191 s = read_name(name, 256, s+1, US"_");
2192
0d85fa3f
PH
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. */
059ec3d9
PH
2196
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)
2203 {
2204 s = read_header_name(name, 256, s);
b5b871ac 2205 /* {-for-text-editors */
0d85fa3f 2206 if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
059ec3d9
PH
2207 if (yield != NULL) *yield =
2208 (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
2209 }
2210
9b4768fa
PH
2211 /* Test for a variable's having a non-empty value. A non-existent variable
2212 causes an expansion failure. */
059ec3d9
PH
2213
2214 else
2215 {
2216 uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
2217 if (value == NULL)
2218 {
2219 expand_string_message = (name[0] == 0)?
2220 string_sprintf("variable name omitted after \"def:\"") :
2221 string_sprintf("unknown variable \"%s\" after \"def:\"", name);
641cb756 2222 check_variable_error_message(name);
059ec3d9
PH
2223 return NULL;
2224 }
9b4768fa 2225 if (yield != NULL) *yield = (value[0] != 0) == testfor;
059ec3d9
PH
2226 }
2227
2228 return s;
2229
2230
2231 /* first_delivery tests for first delivery attempt */
2232
2233 case ECOND_FIRST_DELIVERY:
2234 if (yield != NULL) *yield = deliver_firsttime == testfor;
2235 return s;
2236
2237
2238 /* queue_running tests for any process started by a queue runner */
2239
2240 case ECOND_QUEUE_RUNNING:
2241 if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
2242 return s;
2243
2244
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
2253 */
2254
2255 case ECOND_EXISTS:
2256 case ECOND_ISIP:
2257 case ECOND_ISIP4:
2258 case ECOND_ISIP6:
2259 case ECOND_PAM:
2260 case ECOND_RADIUS:
2261 case ECOND_LDAPAUTH:
2262 case ECOND_PWCHECK:
2263
2264 while (isspace(*s)) s++;
b5b871ac 2265 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
059ec3d9 2266
b0e85a8f 2267 sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL, TRUE, resetok);
059ec3d9 2268 if (sub[0] == NULL) return NULL;
b5b871ac 2269 /* {-for-text-editors */
059ec3d9
PH
2270 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2271
2272 if (yield == NULL) return s; /* No need to run the test if skipping */
2273
2274 switch(cond_type)
2275 {
2276 case ECOND_EXISTS:
2277 if ((expand_forbid & RDO_EXISTS) != 0)
2278 {
2279 expand_string_message = US"File existence tests are not permitted";
2280 return NULL;
2281 }
2282 *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
2283 break;
2284
2285 case ECOND_ISIP:
2286 case ECOND_ISIP4:
2287 case ECOND_ISIP6:
2288 rc = string_is_ip_address(sub[0], NULL);
7e66e54d 2289 *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
059ec3d9
PH
2290 (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
2291 break;
2292
2293 /* Various authentication tests - all optionally compiled */
2294
2295 case ECOND_PAM:
2296 #ifdef SUPPORT_PAM
2297 rc = auth_call_pam(sub[0], &expand_string_message);
2298 goto END_AUTH;
2299 #else
2300 goto COND_FAILED_NOT_COMPILED;
2301 #endif /* SUPPORT_PAM */
2302
2303 case ECOND_RADIUS:
2304 #ifdef RADIUS_CONFIG_FILE
2305 rc = auth_call_radius(sub[0], &expand_string_message);
2306 goto END_AUTH;
2307 #else
2308 goto COND_FAILED_NOT_COMPILED;
2309 #endif /* RADIUS_CONFIG_FILE */
2310
2311 case ECOND_LDAPAUTH:
2312 #ifdef LOOKUP_LDAP
2313 {
2314 /* Just to keep the interface the same */
2315 BOOL do_cache;
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;
2321 }
2322 goto END_AUTH;
2323 #else
2324 goto COND_FAILED_NOT_COMPILED;
2325 #endif /* LOOKUP_LDAP */
2326
2327 case ECOND_PWCHECK:
2328 #ifdef CYRUS_PWCHECK_SOCKET
2329 rc = auth_call_pwcheck(sub[0], &expand_string_message);
2330 goto END_AUTH;
2331 #else
2332 goto COND_FAILED_NOT_COMPILED;
2333 #endif /* CYRUS_PWCHECK_SOCKET */
2334
2335 #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
2336 defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
2337 END_AUTH:
2338 if (rc == ERROR || rc == DEFER) return NULL;
2339 *yield = (rc == OK) == testfor;
2340 #endif
2341 }
2342 return s;
2343
2344
333eea9c
JH
2345 /* call ACL (in a conditional context). Accept true, deny false.
2346 Defer is a forced-fail. Anything set by message= goes to $value.
f60d98e8
JH
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.
fd5dad68
JH
2351 Since the ACL may allocate new global variables, tell our caller to not
2352 reclaim memory.
f60d98e8 2353 */
333eea9c
JH
2354
2355 case ECOND_ACL:
bef3ea7f 2356 /* ${if acl {{name}{arg1}{arg2}...} {yes}{no}} */
333eea9c 2357 {
55414b25 2358 uschar *sub[10];
333eea9c 2359 uschar *user_msg;
333eea9c 2360 BOOL cond = FALSE;
bef3ea7f
JH
2361 int size = 0;
2362 int ptr = 0;
333eea9c
JH
2363
2364 while (isspace(*s)) s++;
6d9cfc47 2365 if (*s++ != '{') goto COND_FAILED_CURLY_START; /*}*/
333eea9c 2366
0539a19d 2367 switch(read_subs(sub, nelem(sub), 1,
b0e85a8f 2368 &s, yield == NULL, TRUE, US"acl", resetok))
333eea9c 2369 {
f60d98e8
JH
2370 case 1: expand_string_message = US"too few arguments or bracketing "
2371 "error for acl";
2372 case 2:
2373 case 3: return NULL;
333eea9c 2374 }
f60d98e8 2375
b0e85a8f 2376 *resetok = FALSE;
0539a19d 2377 if (yield != NULL) switch(eval_acl(sub, nelem(sub), &user_msg))
f60d98e8
JH
2378 {
2379 case OK:
2380 cond = TRUE;
2381 case FAIL:
bef3ea7f 2382 lookup_value = NULL;
f60d98e8 2383 if (user_msg)
bef3ea7f 2384 {
f60d98e8 2385 lookup_value = string_cat(NULL, &size, &ptr, user_msg, Ustrlen(user_msg));
bef3ea7f
JH
2386 lookup_value[ptr] = '\0';
2387 }
b5b871ac 2388 *yield = cond == testfor;
f60d98e8
JH
2389 break;
2390
2391 case DEFER:
2392 expand_string_forcedfail = TRUE;
2393 default:
2394 expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
2395 return NULL;
2396 }
2397 return s;
333eea9c 2398 }
333eea9c
JH
2399
2400
059ec3d9
PH
2401 /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
2402
b0e85a8f 2403 ${if saslauthd {{username}{password}{service}{realm}} {yes}{no}}
059ec3d9
PH
2404
2405 However, the last two are optional. That is why the whole set is enclosed
333eea9c 2406 in their own set of braces. */
059ec3d9
PH
2407
2408 case ECOND_SASLAUTHD:
0539a19d
JH
2409#ifndef CYRUS_SASLAUTHD_SOCKET
2410 goto COND_FAILED_NOT_COMPILED;
2411#else
059ec3d9 2412 {
0539a19d
JH
2413 uschar *sub[4];
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",
2417 resetok))
2418 {
2419 case 1: expand_string_message = US"too few arguments or bracketing "
2420 "error for saslauthd";
2421 case 2:
2422 case 3: return NULL;
2423 }
2424 if (sub[2] == NULL) sub[3] = NULL; /* realm if no service */
2425 if (yield != NULL)
2426 {
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;
2431 }
2432 return s;
059ec3d9 2433 }
0539a19d 2434#endif /* CYRUS_SASLAUTHD_SOCKET */
059ec3d9
PH
2435
2436
2437 /* symbolic operators for numeric and string comparison, and a number of
2438 other operators, all requiring two arguments.
2439
76dca828
PP
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
059ec3d9
PH
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
32d668a5 2447 match_ip: matches a host list that is restricted to IP addresses
059ec3d9 2448 match_local_part: matches in a local part list
059ec3d9
PH
2449 */
2450
059ec3d9
PH
2451 case ECOND_MATCH_ADDRESS:
2452 case ECOND_MATCH_DOMAIN:
32d668a5 2453 case ECOND_MATCH_IP:
059ec3d9 2454 case ECOND_MATCH_LOCAL_PART:
da6dbe26
PP
2455#ifndef EXPAND_LISTMATCH_RHS
2456 sub2_honour_dollar = FALSE;
2457#endif
2458 /* FALLTHROUGH */
2459
2460 case ECOND_CRYPTEQ:
2461 case ECOND_INLIST:
2462 case ECOND_INLISTI:
2463 case ECOND_MATCH:
059ec3d9
PH
2464
2465 case ECOND_NUM_L: /* Numerical comparisons */
2466 case ECOND_NUM_LE:
2467 case ECOND_NUM_E:
2468 case ECOND_NUM_EE:
2469 case ECOND_NUM_G:
2470 case ECOND_NUM_GE:
2471
2472 case ECOND_STR_LT: /* String comparisons */
2473 case ECOND_STR_LTI:
2474 case ECOND_STR_LE:
2475 case ECOND_STR_LEI:
2476 case ECOND_STR_EQ:
2477 case ECOND_STR_EQI:
2478 case ECOND_STR_GT:
2479 case ECOND_STR_GTI:
2480 case ECOND_STR_GE:
2481 case ECOND_STR_GEI:
2482
2483 for (i = 0; i < 2; i++)
2484 {
da6dbe26
PP
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;
2491
059ec3d9
PH
2492 while (isspace(*s)) s++;
2493 if (*s != '{')
2494 {
2495 if (i == 0) goto COND_FAILED_CURLY_START;
2496 expand_string_message = string_sprintf("missing 2nd string in {} "
2497 "after \"%s\"", name);
2498 return NULL;
2499 }
da6dbe26 2500 sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL,
b0e85a8f 2501 honour_dollar, resetok);
059ec3d9
PH
2502 if (sub[i] == NULL) return NULL;
2503 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2504
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. */
2508
d6066548 2509 if (!isalpha(name[0]) && yield != NULL)
059ec3d9 2510 {
5dd1517f
PH
2511 if (sub[i][0] == 0)
2512 {
2513 num[i] = 0;
2514 DEBUG(D_expand)
2515 debug_printf("empty string cast to zero for numerical comparison\n");
2516 }
2517 else
2518 {
7685ce68 2519 num[i] = expanded_string_integer(sub[i], FALSE);
5dd1517f
PH
2520 if (expand_string_message != NULL) return NULL;
2521 }
059ec3d9
PH
2522 }
2523 }
2524
2525 /* Result not required */
2526
2527 if (yield == NULL) return s;
2528
2529 /* Do an appropriate comparison */
2530
2531 switch(cond_type)
2532 {
2533 case ECOND_NUM_E:
2534 case ECOND_NUM_EE:
b5b871ac 2535 tempcond = (num[0] == num[1]);
059ec3d9
PH
2536 break;
2537
2538 case ECOND_NUM_G:
b5b871ac 2539 tempcond = (num[0] > num[1]);
059ec3d9
PH
2540 break;
2541
2542 case ECOND_NUM_GE:
b5b871ac 2543 tempcond = (num[0] >= num[1]);
059ec3d9
PH
2544 break;
2545
2546 case ECOND_NUM_L:
b5b871ac 2547 tempcond = (num[0] < num[1]);
059ec3d9
PH
2548 break;
2549
2550 case ECOND_NUM_LE:
b5b871ac 2551 tempcond = (num[0] <= num[1]);
059ec3d9
PH
2552 break;
2553
2554 case ECOND_STR_LT:
b5b871ac 2555 tempcond = (Ustrcmp(sub[0], sub[1]) < 0);
059ec3d9
PH
2556 break;
2557
2558 case ECOND_STR_LTI:
b5b871ac 2559 tempcond = (strcmpic(sub[0], sub[1]) < 0);
059ec3d9
PH
2560 break;
2561
2562 case ECOND_STR_LE:
b5b871ac 2563 tempcond = (Ustrcmp(sub[0], sub[1]) <= 0);
059ec3d9
PH
2564 break;
2565
2566 case ECOND_STR_LEI:
b5b871ac 2567 tempcond = (strcmpic(sub[0], sub[1]) <= 0);
059ec3d9
PH
2568 break;
2569
2570 case ECOND_STR_EQ:
b5b871ac 2571 tempcond = (Ustrcmp(sub[0], sub[1]) == 0);
059ec3d9
PH
2572 break;
2573
2574 case ECOND_STR_EQI:
b5b871ac 2575 tempcond = (strcmpic(sub[0], sub[1]) == 0);
059ec3d9
PH
2576 break;
2577
2578 case ECOND_STR_GT:
b5b871ac 2579 tempcond = (Ustrcmp(sub[0], sub[1]) > 0);
059ec3d9
PH
2580 break;
2581
2582 case ECOND_STR_GTI:
b5b871ac 2583 tempcond = (strcmpic(sub[0], sub[1]) > 0);
059ec3d9
PH
2584 break;
2585
2586 case ECOND_STR_GE:
b5b871ac 2587 tempcond = (Ustrcmp(sub[0], sub[1]) >= 0);
059ec3d9
PH
2588 break;
2589
2590 case ECOND_STR_GEI:
b5b871ac 2591 tempcond = (strcmpic(sub[0], sub[1]) >= 0);
059ec3d9
PH
2592 break;
2593
2594 case ECOND_MATCH: /* Regular expression match */
2595 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
2596 NULL);
2597 if (re == NULL)
2598 {
2599 expand_string_message = string_sprintf("regular expression error in "
2600 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
2601 return NULL;
2602 }
b5b871ac 2603 tempcond = regex_match_and_setup(re, sub[0], 0, -1);
059ec3d9
PH
2604 break;
2605
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;
2609
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;
2614
32d668a5 2615 case ECOND_MATCH_IP: /* Match IP address in a host list */
7e66e54d 2616 if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
32d668a5
PH
2617 {
2618 expand_string_message = string_sprintf("\"%s\" is not an IP address",
2619 sub[0]);
2620 return NULL;
2621 }
2622 else
2623 {
2624 unsigned int *nullcache = NULL;
2625 check_host_block cb;
2626
2627 cb.host_name = US"";
2628 cb.host_address = sub[0];
2629
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
2632 addresses. */
2633
2634 cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2635 cb.host_address + 7 : cb.host_address;
2636
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 */
2647 }
2648 goto MATCHED_SOMETHING;
2649
059ec3d9
PH
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);
2653 /* Fall through */
9a26b6b2 2654 /* VVVVVVVVVVVV */
059ec3d9
PH
2655 MATCHED_SOMETHING:
2656 switch(rc)
2657 {
2658 case OK:
b5b871ac 2659 tempcond = TRUE;
059ec3d9
PH
2660 break;
2661
2662 case FAIL:
b5b871ac 2663 tempcond = FALSE;
059ec3d9
PH
2664 break;
2665
2666 case DEFER:
2667 expand_string_message = string_sprintf("unable to complete match "
2668 "against \"%s\": %s", sub[1], search_error_message);
2669 return NULL;
2670 }
2671
2672 break;
2673
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). */
b5b871ac 2677 /* }-for-text-editors */
059ec3d9
PH
2678
2679 case ECOND_CRYPTEQ:
2680 #ifndef SUPPORT_CRYPTEQ
2681 goto COND_FAILED_NOT_COMPILED;
2682 #else
2683 if (strncmpic(sub[1], US"{md5}", 5) == 0)
2684 {
2685 int sublen = Ustrlen(sub[1]+5);
2686 md5 base;
2687 uschar digest[16];
2688
2689 md5_start(&base);
2690 md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2691
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. */
2696
2697 if (sublen == 24)
2698 {
f4d091fb 2699 uschar *coded = b64encode((uschar *)digest, 16);
059ec3d9
PH
2700 DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2701 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
b5b871ac 2702 tempcond = (Ustrcmp(coded, sub[1]+5) == 0);
059ec3d9
PH
2703 }
2704 else if (sublen == 32)
2705 {
2706 int i;
2707 uschar coded[36];
2708 for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2709 coded[32] = 0;
2710 DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2711 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
b5b871ac 2712 tempcond = (strcmpic(coded, sub[1]+5) == 0);
059ec3d9
PH
2713 }
2714 else
2715 {
2716 DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2717 "fail\n crypted=%s\n", sub[1]+5);
b5b871ac 2718 tempcond = FALSE;
059ec3d9
PH
2719 }
2720 }
2721
2722 else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2723 {
2724 int sublen = Ustrlen(sub[1]+6);
2725 sha1 base;
2726 uschar digest[20];
2727
2728 sha1_start(&base);
2729 sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2730
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. */
2734
2735 if (sublen == 28)
2736 {
f4d091fb 2737 uschar *coded = b64encode((uschar *)digest, 20);
059ec3d9
PH
2738 DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2739 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
b5b871ac 2740 tempcond = (Ustrcmp(coded, sub[1]+6) == 0);
059ec3d9
PH
2741 }
2742 else if (sublen == 40)
2743 {
2744 int i;
2745 uschar coded[44];
2746 for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2747 coded[40] = 0;
2748 DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2749 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
b5b871ac 2750 tempcond = (strcmpic(coded, sub[1]+6) == 0);
059ec3d9
PH
2751 }
2752 else
2753 {
2754 DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2755 "fail\n crypted=%s\n", sub[1]+6);
b5b871ac 2756 tempcond = FALSE;
059ec3d9
PH
2757 }
2758 }
2759
2760 else /* {crypt} or {crypt16} and non-{ at start */
76dca828 2761 /* }-for-text-editors */
059ec3d9
PH
2762 {
2763 int which = 0;
2764 uschar *coded;
2765
2766 if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2767 {
2768 sub[1] += 7;
2769 which = 1;
2770 }
2771 else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2772 {
2773 sub[1] += 9;
2774 which = 2;
2775 }
b5b871ac 2776 else if (sub[1][0] == '{') /* }-for-text-editors */
059ec3d9
PH
2777 {
2778 expand_string_message = string_sprintf("unknown encryption mechanism "
2779 "in \"%s\"", sub[1]);
2780 return NULL;
2781 }
2782
2783 switch(which)
2784 {
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;
2788 }
2789
2790 #define STR(s) # s
2791 #define XSTR(s) STR(s)
2792 DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2793 " subject=%s\n crypted=%s\n",
9dc2b215 2794 which == 0 ? XSTR(DEFAULT_CRYPT) : which == 1 ? "crypt" : "crypt16",
059ec3d9
PH
2795 coded, sub[1]);
2796 #undef STR
2797 #undef XSTR
2798
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! */
2802
9dc2b215
JH
2803 if (coded)
2804 tempcond = Ustrlen(sub[1]) < 2 ? FALSE : Ustrcmp(coded, sub[1]) == 0;
2805 else if (errno == EINVAL)
2806 tempcond = FALSE;
2807 else
2808 {
2809 expand_string_message = string_sprintf("crypt error: %s\n",
2810 US strerror(errno));
2811 return NULL;
2812 }
059ec3d9
PH
2813 }
2814 break;
2815 #endif /* SUPPORT_CRYPTEQ */
76dca828
PP
2816
2817 case ECOND_INLIST:
2818 case ECOND_INLISTI:
2819 {
55414b25 2820 const uschar * list = sub[1];
76dca828 2821 int sep = 0;
76dca828
PP
2822 uschar *save_iterate_item = iterate_item;
2823 int (*compare)(const uschar *, const uschar *);
2824
82dbd376
JH
2825 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2826
b5b871ac 2827 tempcond = FALSE;
55414b25
JH
2828 compare = cond_type == ECOND_INLISTI
2829 ? strcmpic : (int (*)(const uschar *, const uschar *)) strcmp;
76dca828 2830
55414b25 2831 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
76dca828
PP
2832 if (compare(sub[0], iterate_item) == 0)
2833 {
b5b871ac 2834 tempcond = TRUE;
76dca828
PP
2835 break;
2836 }
2837 iterate_item = save_iterate_item;
76dca828
PP
2838 }
2839
059ec3d9
PH
2840 } /* Switch for comparison conditions */
2841
b5b871ac 2842 *yield = tempcond == testfor;
059ec3d9
PH
2843 return s; /* End of comparison conditions */
2844
2845
2846 /* and/or: computes logical and/or of several conditions */
2847
2848 case ECOND_AND:
2849 case ECOND_OR:
2850 subcondptr = (yield == NULL)? NULL : &tempcond;
2851 combined_cond = (cond_type == ECOND_AND);
2852
2853 while (isspace(*s)) s++;
b5b871ac 2854 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
059ec3d9
PH
2855
2856 for (;;)
2857 {
2858 while (isspace(*s)) s++;
b5b871ac 2859 /* {-for-text-editors */
059ec3d9 2860 if (*s == '}') break;
b5b871ac 2861 if (*s != '{') /* }-for-text-editors */
059ec3d9
PH
2862 {
2863 expand_string_message = string_sprintf("each subcondition "
2864 "inside an \"%s{...}\" condition must be in its own {}", name);
2865 return NULL;
2866 }
2867
b0e85a8f 2868 if (!(s = eval_condition(s+1, resetok, subcondptr)))
059ec3d9
PH
2869 {
2870 expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2871 expand_string_message, name);
2872 return NULL;
2873 }
2874 while (isspace(*s)) s++;
2875
b5b871ac 2876 /* {-for-text-editors */
059ec3d9
PH
2877 if (*s++ != '}')
2878 {
b5b871ac 2879 /* {-for-text-editors */
059ec3d9
PH
2880 expand_string_message = string_sprintf("missing } at end of condition "
2881 "inside \"%s\" group", name);
2882 return NULL;
2883 }
2884
2885 if (yield != NULL)
2886 {
2887 if (cond_type == ECOND_AND)
2888 {
2889 combined_cond &= tempcond;
2890 if (!combined_cond) subcondptr = NULL; /* once false, don't */
2891 } /* evaluate any more */
2892 else
2893 {
2894 combined_cond |= tempcond;
2895 if (combined_cond) subcondptr = NULL; /* once true, don't */
2896 } /* evaluate any more */
2897 }
2898 }
2899
2900 if (yield != NULL) *yield = (combined_cond == testfor);
2901 return ++s;
2902
2903
0ce9abe6
PH
2904 /* forall/forany: iterates a condition with different values */
2905
2906 case ECOND_FORALL:
2907 case ECOND_FORANY:
2908 {
55414b25 2909 const uschar * list;
0ce9abe6 2910 int sep = 0;
282b357d 2911 uschar *save_iterate_item = iterate_item;
0ce9abe6 2912
82dbd376
JH
2913 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2914
0ce9abe6 2915 while (isspace(*s)) s++;
b5b871ac 2916 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
b0e85a8f 2917 sub[0] = expand_string_internal(s, TRUE, &s, (yield == NULL), TRUE, resetok);
0ce9abe6 2918 if (sub[0] == NULL) return NULL;
b5b871ac 2919 /* {-for-text-editors */
0ce9abe6
PH
2920 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2921
2922 while (isspace(*s)) s++;
b5b871ac 2923 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
0ce9abe6
PH
2924
2925 sub[1] = s;
2926
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. */
2930
b0e85a8f 2931 if (!(s = eval_condition(sub[1], resetok, NULL)))
0ce9abe6
PH
2932 {
2933 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2934 expand_string_message, name);
2935 return NULL;
2936 }
2937 while (isspace(*s)) s++;
2938
b5b871ac 2939 /* {-for-text-editors */
0ce9abe6
PH
2940 if (*s++ != '}')
2941 {
b5b871ac 2942 /* {-for-text-editors */
0ce9abe6
PH
2943 expand_string_message = string_sprintf("missing } at end of condition "
2944 "inside \"%s\"", name);
2945 return NULL;
2946 }
2947
2948 if (yield != NULL) *yield = !testfor;
55414b25
JH
2949 list = sub[0];
2950 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
0ce9abe6
PH
2951 {
2952 DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
b0e85a8f 2953 if (!eval_condition(sub[1], resetok, &tempcond))
0ce9abe6
PH
2954 {
2955 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2956 expand_string_message, name);
e58c13cc 2957 iterate_item = save_iterate_item;
0ce9abe6
PH
2958 return NULL;
2959 }
2960 DEBUG(D_expand) debug_printf("%s: condition evaluated to %s\n", name,
2961 tempcond? "true":"false");
2962
2963 if (yield != NULL) *yield = (tempcond == testfor);
2964 if (tempcond == (cond_type == ECOND_FORANY)) break;
2965 }
2966
282b357d 2967 iterate_item = save_iterate_item;
0ce9abe6
PH
2968 return s;
2969 }
2970
2971
f3766eb5
NM
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
2977 map to FALSE.
2978 Note that readconf.c boolean matching, for boolean configuration options,
6a8de854
PP
2979 only matches true/yes/false/no.
2980 The bool_lax{} condition matches the Router logic, which is much more
2981 liberal. */
f3766eb5 2982 case ECOND_BOOL:
6a8de854 2983 case ECOND_BOOL_LAX:
f3766eb5
NM
2984 {
2985 uschar *sub_arg[1];
71265ae9 2986 uschar *t, *t2;
6a8de854 2987 uschar *ourname;
f3766eb5
NM
2988 size_t len;
2989 BOOL boolvalue = FALSE;
2990 while (isspace(*s)) s++;
b5b871ac 2991 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
6a8de854 2992 ourname = cond_type == ECOND_BOOL_LAX ? US"bool_lax" : US"bool";
b0e85a8f 2993 switch(read_subs(sub_arg, 1, 1, &s, yield == NULL, FALSE, ourname, resetok))
f3766eb5 2994 {
6a8de854
PP
2995 case 1: expand_string_message = string_sprintf(
2996 "too few arguments or bracketing error for %s",
2997 ourname);
f3766eb5
NM
2998 /*FALLTHROUGH*/
2999 case 2:
3000 case 3: return NULL;
3001 }
3002 t = sub_arg[0];
3003 while (isspace(*t)) t++;
3004 len = Ustrlen(t);
71265ae9
PP
3005 if (len)
3006 {
3007 /* trailing whitespace: seems like a good idea to ignore it too */
3008 t2 = t + len - 1;
3009 while (isspace(*t2)) t2--;
3010 if (t2 != (t + len))
3011 {
3012 *++t2 = '\0';
3013 len = t2 - t;
3014 }
3015 }
f3766eb5 3016 DEBUG(D_expand)
6a8de854
PP
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. */
f3766eb5
NM
3021 if (len == 0)
3022 boolvalue = FALSE;
51c7471d
JH
3023 else if (*t == '-'
3024 ? Ustrspn(t+1, "0123456789") == len-1
3025 : Ustrspn(t, "0123456789") == len)
6a8de854 3026 {
f3766eb5 3027 boolvalue = (Uatoi(t) == 0) ? FALSE : TRUE;
6a8de854
PP
3028 /* expand_check_condition only does a literal string "0" check */
3029 if ((cond_type == ECOND_BOOL_LAX) && (len > 1))
3030 boolvalue = TRUE;
3031 }
f3766eb5
NM
3032 else if (strcmpic(t, US"true") == 0 || strcmpic(t, US"yes") == 0)
3033 boolvalue = TRUE;
3034 else if (strcmpic(t, US"false") == 0 || strcmpic(t, US"no") == 0)
3035 boolvalue = FALSE;
6a8de854
PP
3036 else if (cond_type == ECOND_BOOL_LAX)
3037 boolvalue = TRUE;
f3766eb5
NM
3038 else
3039 {
3040 expand_string_message = string_sprintf("unrecognised boolean "
3041 "value \"%s\"", t);
3042 return NULL;
3043 }
5ee6f336 3044 if (yield != NULL) *yield = (boolvalue == testfor);
f3766eb5
NM
3045 return s;
3046 }
3047
059ec3d9
PH
3048 /* Unknown condition */
3049
3050 default:
3051 expand_string_message = string_sprintf("unknown condition \"%s\"", name);
3052 return NULL;
3053 } /* End switch on condition type */
3054
3055/* Missing braces at start and end of data */
3056
3057COND_FAILED_CURLY_START:
3058expand_string_message = string_sprintf("missing { after \"%s\"", name);
3059return NULL;
3060
3061COND_FAILED_CURLY_END:
3062expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
3063 name);
3064return NULL;
3065
3066/* A condition requires code that is not compiled */
3067
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)
3071COND_FAILED_NOT_COMPILED:
3072expand_string_message = string_sprintf("support for \"%s\" not compiled",
3073 name);
3074return NULL;
3075#endif
3076}
3077
3078
3079
3080
3081/*************************************************
3082* Save numerical variables *
3083*************************************************/
3084
3085/* This function is called from items such as "if" that want to preserve and
3086restore the numbered variables.
3087
3088Arguments:
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
3091
3092Returns: the value of expand max to save
3093*/
3094
3095static int
3096save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
3097{
3098int i;
3099for (i = 0; i <= expand_nmax; i++)
3100 {
3101 save_expand_nstring[i] = expand_nstring[i];
3102 save_expand_nlength[i] = expand_nlength[i];
3103 }
3104return expand_nmax;
3105}
3106
3107
3108
3109/*************************************************
3110* Restore numerical variables *
3111*************************************************/
3112
3113/* This function restored saved values of numerical strings.
3114
3115Arguments:
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
3119
3120Returns: nothing
3121*/
3122
3123static void
3124restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
3125 int *save_expand_nlength)
3126{
3127int i;
3128expand_nmax = save_expand_nmax;
3129for (i = 0; i <= expand_nmax; i++)
3130 {
3131 expand_nstring[i] = save_expand_nstring[i];
3132 expand_nlength[i] = save_expand_nlength[i];
3133 }
3134}
3135
3136
3137
3138
3139
3140/*************************************************
3141* Handle yes/no substrings *
3142*************************************************/
3143
3144/* This function is used by ${if}, ${lookup} and ${extract} to handle the
3145alternative substrings that depend on whether or not the condition was true,
3146or the lookup or extraction succeeded. The substrings always have to be
3147expanded, to check their syntax, but "skipping" is set when the result is not
3148needed - this avoids unnecessary nested lookups.
3149
3150Arguments:
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
f90d49f7
JH
3158 type "lookup", "if", "extract", "run", "env", "listextract" or
3159 "certextract" for error message
b0e85a8f
JH
3160 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
3161 the store.
059ec3d9
PH
3162
3163Returns: 0 OK; lookup_value has been reset to save_lookup
3164 1 expansion failed
3165 2 expansion failed because of bracketing error
3166*/
3167
3168static int
55414b25 3169process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, const uschar **sptr,
b0e85a8f 3170 uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type, BOOL *resetok)
059ec3d9
PH
3171{
3172int rc = 0;
55414b25 3173const uschar *s = *sptr; /* Local value */
059ec3d9
PH
3174uschar *sub1, *sub2;
3175
3176/* If there are no following strings, we substitute the contents of $value for
063b1e99 3177lookups and for extractions in the success case. For the ${if item, the string
8e669ac1 3178"true" is substituted. In the fail case, nothing is substituted for all three
063b1e99 3179items. */
059ec3d9
PH
3180
3181while (isspace(*s)) s++;
3182if (*s == '}')
3183 {
063b1e99
PH
3184 if (type[0] == 'i')
3185 {
8e669ac1 3186 if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
063b1e99
PH
3187 }
3188 else
8e669ac1 3189 {
1a08dbc4 3190 if (yes && lookup_value)
063b1e99
PH
3191 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
3192 Ustrlen(lookup_value));
3193 lookup_value = save_lookup;
3194 }
059ec3d9
PH
3195 s++;
3196 goto RETURN;
3197 }
3198
9b4768fa
PH
3199/* The first following string must be braced. */
3200
3201if (*s++ != '{') goto FAILED_CURLY;
3202
059ec3d9
PH
3203/* Expand the first substring. Forced failures are noticed only if we actually
3204want this string. Set skipping in the call in the fail case (this will always
3205be the case if we were already skipping). */
3206
b0e85a8f 3207sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
059ec3d9
PH
3208if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
3209expand_string_forcedfail = FALSE;
3210if (*s++ != '}') goto FAILED_CURLY;
3211
3212/* If we want the first string, add it to the output */
3213
3214if (yes)
3215 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
3216
fa01e4f8
JH
3217/* If this is called from a lookup/env or a (cert)extract, we want to restore
3218$value to what it was at the start of the item, so that it has this value
3219during the second string expansion. For the call from "if" or "run" to this
3220function, save_lookup is set to lookup_value, so that this statement does
3221nothing. */
059ec3d9
PH
3222
3223lookup_value = save_lookup;
3224
3225/* There now follows either another substring, or "fail", or nothing. This
3226time, forced failures are noticed only if we want the second string. We must
3227set skipping in the nested call if we don't want this string, or if we were
3228already skipping. */
3229
3230while (isspace(*s)) s++;
3231if (*s == '{')
3232 {
b0e85a8f 3233 sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
059ec3d9
PH
3234 if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
3235 expand_string_forcedfail = FALSE;
3236 if (*s++ != '}') goto FAILED_CURLY;
3237
3238 /* If we want the second string, add it to the output */
3239
3240 if (!yes)
3241 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
3242 }
3243
3244/* If there is no second string, but the word "fail" is present when the use of
3245the second string is wanted, set a flag indicating it was a forced failure
3246rather than a syntactic error. Swallow the terminating } in case this is nested
3247inside another lookup or if or extract. */
3248
3249else if (*s != '}')
3250 {
3251 uschar name[256];
55414b25
JH
3252 /* deconst cast ok here as source is s anyway */
3253 s = US read_name(name, sizeof(name), s, US"_");
059ec3d9
PH
3254 if (Ustrcmp(name, "fail") == 0)
3255 {
3256 if (!yes && !skipping)
3257 {
3258 while (isspace(*s)) s++;
3259 if (*s++ != '}') goto FAILED_CURLY;
3260 expand_string_message =
3261 string_sprintf("\"%s\" failed and \"fail\" requested", type);
3262 expand_string_forcedfail = TRUE;
3263 goto FAILED;
3264 }
3265 }
3266 else
3267 {
3268 expand_string_message =
3269 string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
3270 goto FAILED;
3271 }
3272 }
3273
3274/* All we have to do now is to check on the final closing brace. */
3275
3276while (isspace(*s)) s++;
3277if (*s++ == '}') goto RETURN;
3278
3279/* Get here if there is a bracketing failure */
3280
3281FAILED_CURLY:
3282rc++;
3283
3284/* Get here for other failures */
3285
3286FAILED:
3287rc++;
3288
3289/* Update the input pointer value before returning */
3290
3291RETURN:
3292*sptr = s;
3293return rc;
3294}
3295
3296
3297
3298
059ec3d9
PH
3299/*************************************************
3300* Handle MD5 or SHA-1 computation for HMAC *
3301*************************************************/
3302
3303/* These are some wrapping functions that enable the HMAC code to be a bit
3304cleaner. A good compiler will spot the tail recursion.
3305
3306Arguments:
3307 type HMAC_MD5 or HMAC_SHA1
3308 remaining are as for the cryptographic hash functions
3309
3310Returns: nothing
3311*/
3312
3313static void
3314chash_start(int type, void *base)
3315{
3316if (type == HMAC_MD5)
3317 md5_start((md5 *)base);
3318else
3319 sha1_start((sha1 *)base);
3320}
3321
3322static void
3323chash_mid(int type, void *base, uschar *string)
3324{
3325if (type == HMAC_MD5)
3326 md5_mid((md5 *)base, string);
3327else
3328 sha1_mid((sha1 *)base, string);
3329}
3330
3331static void
3332chash_end(int type, void *base, uschar *string, int length, uschar *digest)
3333{
3334if (type == HMAC_MD5)
3335 md5_end((md5 *)base, string, length, digest);
3336else
3337 sha1_end((sha1 *)base, string, length, digest);
3338}
3339
3340
3341
3342
3343
1549ea3b
PH
3344/********************************************************
3345* prvs: Get last three digits of days since Jan 1, 1970 *
3346********************************************************/
3347
3348/* This is needed to implement the "prvs" BATV reverse
3349 path signing scheme
3350
3351Argument: integer "days" offset to add or substract to
3352 or from the current number of days.
3353
3354Returns: pointer to string containing the last three
3355 digits of the number of days since Jan 1, 1970,
3356 modified by the offset argument, NULL if there
3357 was an error in the conversion.
3358
3359*/
3360
3361static uschar *
3362prvs_daystamp(int day_offset)
3363{
a86229cf
PH
3364uschar *days = store_get(32); /* Need at least 24 for cases */
3365(void)string_format(days, 32, TIME_T_FMT, /* where TIME_T_FMT is %lld */
1549ea3b 3366 (time(NULL) + day_offset*86400)/86400);
e169f567 3367return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
1549ea3b
PH
3368}
3369
3370
3371
3372/********************************************************
3373* prvs: perform HMAC-SHA1 computation of prvs bits *
3374********************************************************/
3375
3376/* This is needed to implement the "prvs" BATV reverse
3377 path signing scheme
3378
3379Arguments:
3380 address RFC2821 Address to use
3381 key The key to use (must be less than 64 characters
3382 in size)
3383 key_num Single-digit key number to use. Defaults to
3384 '0' when NULL.
3385
3386Returns: pointer to string containing the first three
3387 bytes of the final hash in hex format, NULL if
3388 there was an error in the process.
3389*/
3390
3391static uschar *
3392prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
3393{
3394uschar *hash_source, *p;
3395int size = 0,offset = 0,i;
3396sha1 sha1_base;
3397void *use_base = &sha1_base;
3398uschar innerhash[20];
3399uschar finalhash[20];
3400uschar innerkey[64];
3401uschar outerkey[64];
3402uschar *finalhash_hex = store_get(40);
3403
3404if (key_num == NULL)
3405 key_num = US"0";
3406
3407if (Ustrlen(key) > 64)
3408 return NULL;
3409
3410hash_source = string_cat(NULL,&size,&offset,key_num,1);
77560253
JH
3411hash_source = string_cat(hash_source,&size,&offset,daystamp,3);
3412hash_source = string_cat(hash_source,&size,&offset,address,Ustrlen(address));
1549ea3b
PH
3413hash_source[offset] = '\0';
3414
3415DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
3416
3417memset(innerkey, 0x36, 64);
3418memset(outerkey, 0x5c, 64);
3419
3420for (i = 0; i < Ustrlen(key); i++)
3421 {
3422 innerkey[i] ^= key[i];
3423 outerkey[i] ^= key[i];
3424 }
3425
3426chash_start(HMAC_SHA1, use_base);
3427chash_mid(HMAC_SHA1, use_base, innerkey);
3428chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
3429
3430chash_start(HMAC_SHA1, use_base);
3431chash_mid(HMAC_SHA1, use_base, outerkey);
3432chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
3433
3434p = finalhash_hex;
3435for (i = 0; i < 3; i++)
3436 {
3437 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
3438 *p++ = hex_digits[finalhash[i] & 0x0f];
3439 }
3440*p = '\0';
3441
3442return finalhash_hex;
3443}
3444
3445
3446
3447
059ec3d9
PH
3448/*************************************************
3449* Join a file onto the output string *
3450*************************************************/
3451
fa01e4f8
JH
3452/* This is used for readfile/readsock and after a run expansion.
3453It joins the contents of a file onto the output string, globally replacing
3454newlines with a given string (optionally).
059ec3d9
PH
3455
3456Arguments:
3457 f the FILE
3458 yield pointer to the expandable string
3459 sizep pointer to the current size
3460 ptrp pointer to the current position
3461 eol newline replacement string, or NULL
3462
3463Returns: new value of string pointer
3464*/
3465
3466static uschar *
3467cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
3468{
fa01e4f8 3469int eollen = eol ? Ustrlen(eol) : 0;
059ec3d9
PH
3470uschar buffer[1024];
3471
fa01e4f8 3472while (Ufgets(buffer, sizeof(buffer), f))
059ec3d9
PH
3473 {
3474 int len = Ustrlen(buffer);
fa01e4f8 3475 if (eol && buffer[len-1] == '\n') len--;
059ec3d9
PH
3476 yield = string_cat(yield, sizep, ptrp, buffer, len);
3477 if (buffer[len] != 0)
3478 yield = string_cat(yield, sizep, ptrp, eol, eollen);
3479 }
3480
fa01e4f8 3481if (yield) yield[*ptrp] = 0;
059ec3d9
PH
3482
3483return yield;
3484}
3485
3486
3487
3488
3489/*************************************************
3490* Evaluate numeric expression *
3491*************************************************/
3492
af561417
PH
3493/* This is a set of mutually recursive functions that evaluate an arithmetic
3494expression involving + - * / % & | ^ ~ << >> and parentheses. The only one of
3495these functions that is called from elsewhere is eval_expr, whose interface is:
059ec3d9
PH
3496
3497Arguments:
af561417
PH
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
059ec3d9 3502
af561417
PH
3503Returns: on success: the value of the expression, with *error still NULL
3504 on failure: an undefined value, with *error = a message
059ec3d9
PH
3505*/
3506
97d17305 3507static int_eximarith_t eval_op_or(uschar **, BOOL, uschar **);
af561417 3508
059ec3d9 3509
97d17305 3510static int_eximarith_t
059ec3d9
PH
3511eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
3512{
3513uschar *s = *sptr;
97d17305 3514int_eximarith_t x = eval_op_or(&s, decimal, error);
059ec3d9
PH
3515if (*error == NULL)
3516 {
af561417 3517 if (endket)
059ec3d9 3518 {
af561417
PH
3519 if (*s != ')')
3520 *error = US"expecting closing parenthesis";
3521 else
3522 while (isspace(*(++s)));
059ec3d9 3523 }
af561417 3524 else if (*s != 0) *error = US"expecting operator";
059ec3d9 3525 }
059ec3d9
PH
3526*sptr = s;
3527return x;
3528}
3529
af561417 3530
97d17305 3531static int_eximarith_t
af561417 3532eval_number(uschar **sptr, BOOL decimal, uschar **error)
059ec3d9
PH
3533{
3534register int c;
97d17305 3535int_eximarith_t n;
059ec3d9
PH
3536uschar *s = *sptr;
3537while (isspace(*s)) s++;
3538c = *s;
af561417 3539if (isdigit(c))
059ec3d9
PH
3540 {
3541 int count;
97d17305 3542 (void)sscanf(CS s, (decimal? SC_EXIM_DEC "%n" : SC_EXIM_ARITH "%n"), &n, &count);
059ec3d9 3543 s += count;
97d17305
JH
3544 switch (tolower(*s))
3545 {
3546 default: break;
3547 case 'k': n *= 1024; s++; break;
3548 case 'm': n *= 1024*1024; s++; break;
3549 case 'g': n *= 1024*1024*1024; s++; break;
3550 }
059ec3d9
PH
3551 while (isspace (*s)) s++;
3552 }
3553else if (c == '(')
3554 {
3555 s++;
3556 n = eval_expr(&s, decimal, error, 1);
3557 }
3558else
3559 {
3560 *error = US"expecting number or opening parenthesis";
3561 n = 0;
3562 }
3563*sptr = s;
3564return n;
3565}
3566
af561417 3567
97d17305 3568static int_eximarith_t
aa7c82b2 3569eval_op_unary(uschar **sptr, BOOL decimal, uschar **error)
af561417
PH
3570{
3571uschar *s = *sptr;
97d17305 3572int_eximarith_t x;
af561417
PH
3573while (isspace(*s)) s++;
3574if (*s == '+' || *s == '-' || *s == '~')
3575 {
3576 int op = *s++;
3577 x = eval_op_unary(&s, decimal, error);
3578 if (op == '-') x = -x;
3579 else if (op == '~') x = ~x;
3580 }
3581else
3582 {
3583 x = eval_number(&s, decimal, error);
3584 }
3585*sptr = s;
3586return x;
3587}
3588
3589
97d17305 3590static int_eximarith_t
aa7c82b2 3591eval_op_mult(uschar **sptr, BOOL decimal, uschar **error)
059ec3d9
PH
3592{
3593uschar *s = *sptr;
97d17305 3594int_eximarith_t x = eval_op_unary(&s, decimal, error);
059ec3d9
PH
3595if (*error == NULL)
3596 {
5591031b 3597 while (*s == '*' || *s == '/' || *s == '%')
059ec3d9
PH
3598 {
3599 int op = *s++;
97d17305 3600 int_eximarith_t y = eval_op_unary(&s, decimal, error);
059ec3d9 3601 if (*error != NULL) break;
053a9aa3
PP
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.
3619 */
4328fd3c 3620 if (y == -1 && x == EXIM_ARITH_MIN && op != '*')
053a9aa3
PP
3621 {
3622 DEBUG(D_expand)
97d17305 3623 debug_printf("Integer exception dodging: " PR_EXIM_ARITH "%c-1 coerced to " PR_EXIM_ARITH "\n",
4328fd3c
JH
3624 EXIM_ARITH_MIN, op, EXIM_ARITH_MAX);
3625 x = EXIM_ARITH_MAX;
053a9aa3
PP
3626 continue;
3627 }
a5b52695
PP
3628 if (op == '*')
3629 x *= y;
3630 else