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