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