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