Tweak the ACL variable name code to require either a digit or an
[exim.git] / src / src / expand.c
1 /* $Cambridge: exim/src/src/expand.c,v 1.62 2006/09/19 14:31:07 ph10 Exp $ */
2
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10
11 /* Functions for handling string expansion. */
12
13
14 #include "exim.h"
15
16 #ifdef STAND_ALONE
17 #ifndef SUPPORT_CRYPTEQ
18 #define SUPPORT_CRYPTEQ
19 #endif
20 #endif
21
22 #ifdef SUPPORT_CRYPTEQ
23 #ifdef CRYPT_H
24 #include <crypt.h>
25 #endif
26 #ifndef HAVE_CRYPT16
27 extern char* crypt16(char*, char*);
28 #endif
29 #endif
30
31 #ifdef LOOKUP_LDAP
32 #include "lookups/ldap.h"
33 #endif
34
35
36
37 /* Recursively called function */
38
39 static uschar *expand_string_internal(uschar *, BOOL, uschar **, BOOL);
40
41
42
43 /*************************************************
44 * Local statics and tables *
45 *************************************************/
46
47 /* Table of item names, and corresponding switch numbers. The names must be in
48 alphabetical order. */
49
50 static uschar *item_table[] = {
51 US"dlfunc",
52 US"extract",
53 US"hash",
54 US"hmac",
55 US"if",
56 US"length",
57 US"lookup",
58 US"nhash",
59 US"perl",
60 US"prvs",
61 US"prvscheck",
62 US"readfile",
63 US"readsocket",
64 US"run",
65 US"sg",
66 US"substr",
67 US"tr" };
68
69 enum {
70 EITEM_DLFUNC,
71 EITEM_EXTRACT,
72 EITEM_HASH,
73 EITEM_HMAC,
74 EITEM_IF,
75 EITEM_LENGTH,
76 EITEM_LOOKUP,
77 EITEM_NHASH,
78 EITEM_PERL,
79 EITEM_PRVS,
80 EITEM_PRVSCHECK,
81 EITEM_READFILE,
82 EITEM_READSOCK,
83 EITEM_RUN,
84 EITEM_SG,
85 EITEM_SUBSTR,
86 EITEM_TR };
87
88 /* Tables of operator names, and corresponding switch numbers. The names must be
89 in alphabetical order. There are two tables, because underscore is used in some
90 cases to introduce arguments, whereas for other it is part of the name. This is
91 an historical mis-design. */
92
93 static uschar *op_table_underscore[] = {
94 US"from_utf8",
95 US"local_part",
96 US"quote_local_part",
97 US"time_eval",
98 US"time_interval"};
99
100 enum {
101 EOP_FROM_UTF8,
102 EOP_LOCAL_PART,
103 EOP_QUOTE_LOCAL_PART,
104 EOP_TIME_EVAL,
105 EOP_TIME_INTERVAL };
106
107 static uschar *op_table_main[] = {
108 US"address",
109 US"base62",
110 US"base62d",
111 US"domain",
112 US"escape",
113 US"eval",
114 US"eval10",
115 US"expand",
116 US"h",
117 US"hash",
118 US"hex2b64",
119 US"l",
120 US"lc",
121 US"length",
122 US"mask",
123 US"md5",
124 US"nh",
125 US"nhash",
126 US"quote",
127 US"rfc2047",
128 US"rxquote",
129 US"s",
130 US"sha1",
131 US"stat",
132 US"str2b64",
133 US"strlen",
134 US"substr",
135 US"uc" };
136
137 enum {
138 EOP_ADDRESS = sizeof(op_table_underscore)/sizeof(uschar *),
139 EOP_BASE62,
140 EOP_BASE62D,
141 EOP_DOMAIN,
142 EOP_ESCAPE,
143 EOP_EVAL,
144 EOP_EVAL10,
145 EOP_EXPAND,
146 EOP_H,
147 EOP_HASH,
148 EOP_HEX2B64,
149 EOP_L,
150 EOP_LC,
151 EOP_LENGTH,
152 EOP_MASK,
153 EOP_MD5,
154 EOP_NH,
155 EOP_NHASH,
156 EOP_QUOTE,
157 EOP_RFC2047,
158 EOP_RXQUOTE,
159 EOP_S,
160 EOP_SHA1,
161 EOP_STAT,
162 EOP_STR2B64,
163 EOP_STRLEN,
164 EOP_SUBSTR,
165 EOP_UC };
166
167
168 /* Table of condition names, and corresponding switch numbers. The names must
169 be in alphabetical order. */
170
171 static uschar *cond_table[] = {
172 US"<",
173 US"<=",
174 US"=",
175 US"==", /* Backward compatibility */
176 US">",
177 US">=",
178 US"and",
179 US"crypteq",
180 US"def",
181 US"eq",
182 US"eqi",
183 US"exists",
184 US"first_delivery",
185 US"ge",
186 US"gei",
187 US"gt",
188 US"gti",
189 US"isip",
190 US"isip4",
191 US"isip6",
192 US"ldapauth",
193 US"le",
194 US"lei",
195 US"lt",
196 US"lti",
197 US"match",
198 US"match_address",
199 US"match_domain",
200 US"match_ip",
201 US"match_local_part",
202 US"or",
203 US"pam",
204 US"pwcheck",
205 US"queue_running",
206 US"radius",
207 US"saslauthd"
208 };
209
210 enum {
211 ECOND_NUM_L,
212 ECOND_NUM_LE,
213 ECOND_NUM_E,
214 ECOND_NUM_EE,
215 ECOND_NUM_G,
216 ECOND_NUM_GE,
217 ECOND_AND,
218 ECOND_CRYPTEQ,
219 ECOND_DEF,
220 ECOND_STR_EQ,
221 ECOND_STR_EQI,
222 ECOND_EXISTS,
223 ECOND_FIRST_DELIVERY,
224 ECOND_STR_GE,
225 ECOND_STR_GEI,
226 ECOND_STR_GT,
227 ECOND_STR_GTI,
228 ECOND_ISIP,
229 ECOND_ISIP4,
230 ECOND_ISIP6,
231 ECOND_LDAPAUTH,
232 ECOND_STR_LE,
233 ECOND_STR_LEI,
234 ECOND_STR_LT,
235 ECOND_STR_LTI,
236 ECOND_MATCH,
237 ECOND_MATCH_ADDRESS,
238 ECOND_MATCH_DOMAIN,
239 ECOND_MATCH_IP,
240 ECOND_MATCH_LOCAL_PART,
241 ECOND_OR,
242 ECOND_PAM,
243 ECOND_PWCHECK,
244 ECOND_QUEUE_RUNNING,
245 ECOND_RADIUS,
246 ECOND_SASLAUTHD
247 };
248
249
250 /* Type for main variable table */
251
252 typedef struct {
253 char *name;
254 int type;
255 void *value;
256 } var_entry;
257
258 /* Type for entries pointing to address/length pairs. Not currently
259 in use. */
260
261 typedef struct {
262 uschar **address;
263 int *length;
264 } alblock;
265
266 /* Types of table entry */
267
268 enum {
269 vtype_int, /* value is address of int */
270 vtype_filter_int, /* ditto, but recognized only when filtering */
271 vtype_ino, /* value is address of ino_t (not always an int) */
272 vtype_uid, /* value is address of uid_t (not always an int) */
273 vtype_gid, /* value is address of gid_t (not always an int) */
274 vtype_stringptr, /* value is address of pointer to string */
275 vtype_msgbody, /* as stringptr, but read when first required */
276 vtype_msgbody_end, /* ditto, the end of the message */
277 vtype_msgheaders, /* the message's headers */
278 vtype_localpart, /* extract local part from string */
279 vtype_domain, /* extract domain from string */
280 vtype_recipients, /* extract recipients from recipients list */
281 /* (enabled only during system filtering */
282 vtype_todbsdin, /* value not used; generate BSD inbox tod */
283 vtype_tode, /* value not used; generate tod in epoch format */
284 vtype_todf, /* value not used; generate full tod */
285 vtype_todl, /* value not used; generate log tod */
286 vtype_todlf, /* value not used; generate log file datestamp tod */
287 vtype_todzone, /* value not used; generate time zone only */
288 vtype_todzulu, /* value not used; generate zulu tod */
289 vtype_reply, /* value not used; get reply from headers */
290 vtype_pid, /* value not used; result is pid */
291 vtype_host_lookup, /* value not used; get host name */
292 vtype_load_avg, /* value not used; result is int from os_getloadavg */
293 vtype_pspace, /* partition space; value is T/F for spool/log */
294 vtype_pinodes /* partition inodes; value is T/F for spool/log */
295 #ifdef EXPERIMENTAL_DOMAINKEYS
296 ,vtype_dk_verify /* Serve request out of DomainKeys verification structure */
297 #endif
298 };
299
300 /* This table must be kept in alphabetical order. */
301
302 static var_entry var_table[] = {
303 /* WARNING: Do not invent variables whose names start acl_c or acl_m because
304 they will be confused with user-creatable ACL variables. */
305 { "acl_verify_message", vtype_stringptr, &acl_verify_message },
306 { "address_data", vtype_stringptr, &deliver_address_data },
307 { "address_file", vtype_stringptr, &address_file },
308 { "address_pipe", vtype_stringptr, &address_pipe },
309 { "authenticated_id", vtype_stringptr, &authenticated_id },
310 { "authenticated_sender",vtype_stringptr, &authenticated_sender },
311 { "authentication_failed",vtype_int, &authentication_failed },
312 #ifdef EXPERIMENTAL_BRIGHTMAIL
313 { "bmi_alt_location", vtype_stringptr, &bmi_alt_location },
314 { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
315 { "bmi_base64_verdict", vtype_stringptr, &bmi_base64_verdict },
316 { "bmi_deliver", vtype_int, &bmi_deliver },
317 #endif
318 { "body_linecount", vtype_int, &body_linecount },
319 { "body_zerocount", vtype_int, &body_zerocount },
320 { "bounce_recipient", vtype_stringptr, &bounce_recipient },
321 { "bounce_return_size_limit", vtype_int, &bounce_return_size_limit },
322 { "caller_gid", vtype_gid, &real_gid },
323 { "caller_uid", vtype_uid, &real_uid },
324 { "compile_date", vtype_stringptr, &version_date },
325 { "compile_number", vtype_stringptr, &version_cnumber },
326 { "csa_status", vtype_stringptr, &csa_status },
327 #ifdef WITH_OLD_DEMIME
328 { "demime_errorlevel", vtype_int, &demime_errorlevel },
329 { "demime_reason", vtype_stringptr, &demime_reason },
330 #endif
331 #ifdef EXPERIMENTAL_DOMAINKEYS
332 { "dk_domain", vtype_stringptr, &dk_signing_domain },
333 { "dk_is_signed", vtype_dk_verify, NULL },
334 { "dk_result", vtype_dk_verify, NULL },
335 { "dk_selector", vtype_stringptr, &dk_signing_selector },
336 { "dk_sender", vtype_dk_verify, NULL },
337 { "dk_sender_domain", vtype_dk_verify, NULL },
338 { "dk_sender_local_part",vtype_dk_verify, NULL },
339 { "dk_sender_source", vtype_dk_verify, NULL },
340 { "dk_signsall", vtype_dk_verify, NULL },
341 { "dk_status", vtype_dk_verify, NULL },
342 { "dk_testing", vtype_dk_verify, NULL },
343 #endif
344 { "dnslist_domain", vtype_stringptr, &dnslist_domain },
345 { "dnslist_text", vtype_stringptr, &dnslist_text },
346 { "dnslist_value", vtype_stringptr, &dnslist_value },
347 { "domain", vtype_stringptr, &deliver_domain },
348 { "domain_data", vtype_stringptr, &deliver_domain_data },
349 { "exim_gid", vtype_gid, &exim_gid },
350 { "exim_path", vtype_stringptr, &exim_path },
351 { "exim_uid", vtype_uid, &exim_uid },
352 #ifdef WITH_OLD_DEMIME
353 { "found_extension", vtype_stringptr, &found_extension },
354 #endif
355 { "home", vtype_stringptr, &deliver_home },
356 { "host", vtype_stringptr, &deliver_host },
357 { "host_address", vtype_stringptr, &deliver_host_address },
358 { "host_data", vtype_stringptr, &host_data },
359 { "host_lookup_deferred",vtype_int, &host_lookup_deferred },
360 { "host_lookup_failed", vtype_int, &host_lookup_failed },
361 { "inode", vtype_ino, &deliver_inode },
362 { "interface_address", vtype_stringptr, &interface_address },
363 { "interface_port", vtype_int, &interface_port },
364 #ifdef LOOKUP_LDAP
365 { "ldap_dn", vtype_stringptr, &eldap_dn },
366 #endif
367 { "load_average", vtype_load_avg, NULL },
368 { "local_part", vtype_stringptr, &deliver_localpart },
369 { "local_part_data", vtype_stringptr, &deliver_localpart_data },
370 { "local_part_prefix", vtype_stringptr, &deliver_localpart_prefix },
371 { "local_part_suffix", vtype_stringptr, &deliver_localpart_suffix },
372 { "local_scan_data", vtype_stringptr, &local_scan_data },
373 { "local_user_gid", vtype_gid, &local_user_gid },
374 { "local_user_uid", vtype_uid, &local_user_uid },
375 { "localhost_number", vtype_int, &host_number },
376 { "log_inodes", vtype_pinodes, (void *)FALSE },
377 { "log_space", vtype_pspace, (void *)FALSE },
378 { "mailstore_basename", vtype_stringptr, &mailstore_basename },
379 #ifdef WITH_CONTENT_SCAN
380 { "malware_name", vtype_stringptr, &malware_name },
381 #endif
382 { "message_age", vtype_int, &message_age },
383 { "message_body", vtype_msgbody, &message_body },
384 { "message_body_end", vtype_msgbody_end, &message_body_end },
385 { "message_body_size", vtype_int, &message_body_size },
386 { "message_exim_id", vtype_stringptr, &message_id },
387 { "message_headers", vtype_msgheaders, NULL },
388 { "message_id", vtype_stringptr, &message_id },
389 { "message_linecount", vtype_int, &message_linecount },
390 { "message_size", vtype_int, &message_size },
391 #ifdef WITH_CONTENT_SCAN
392 { "mime_anomaly_level", vtype_int, &mime_anomaly_level },
393 { "mime_anomaly_text", vtype_stringptr, &mime_anomaly_text },
394 { "mime_boundary", vtype_stringptr, &mime_boundary },
395 { "mime_charset", vtype_stringptr, &mime_charset },
396 { "mime_content_description", vtype_stringptr, &mime_content_description },
397 { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
398 { "mime_content_id", vtype_stringptr, &mime_content_id },
399 { "mime_content_size", vtype_int, &mime_content_size },
400 { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
401 { "mime_content_type", vtype_stringptr, &mime_content_type },
402 { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
403 { "mime_filename", vtype_stringptr, &mime_filename },
404 { "mime_is_coverletter", vtype_int, &mime_is_coverletter },
405 { "mime_is_multipart", vtype_int, &mime_is_multipart },
406 { "mime_is_rfc822", vtype_int, &mime_is_rfc822 },
407 { "mime_part_count", vtype_int, &mime_part_count },
408 #endif
409 { "n0", vtype_filter_int, &filter_n[0] },
410 { "n1", vtype_filter_int, &filter_n[1] },
411 { "n2", vtype_filter_int, &filter_n[2] },
412 { "n3", vtype_filter_int, &filter_n[3] },
413 { "n4", vtype_filter_int, &filter_n[4] },
414 { "n5", vtype_filter_int, &filter_n[5] },
415 { "n6", vtype_filter_int, &filter_n[6] },
416 { "n7", vtype_filter_int, &filter_n[7] },
417 { "n8", vtype_filter_int, &filter_n[8] },
418 { "n9", vtype_filter_int, &filter_n[9] },
419 { "original_domain", vtype_stringptr, &deliver_domain_orig },
420 { "original_local_part", vtype_stringptr, &deliver_localpart_orig },
421 { "originator_gid", vtype_gid, &originator_gid },
422 { "originator_uid", vtype_uid, &originator_uid },
423 { "parent_domain", vtype_stringptr, &deliver_domain_parent },
424 { "parent_local_part", vtype_stringptr, &deliver_localpart_parent },
425 { "pid", vtype_pid, NULL },
426 { "primary_hostname", vtype_stringptr, &primary_hostname },
427 { "prvscheck_address", vtype_stringptr, &prvscheck_address },
428 { "prvscheck_keynum", vtype_stringptr, &prvscheck_keynum },
429 { "prvscheck_result", vtype_stringptr, &prvscheck_result },
430 { "qualify_domain", vtype_stringptr, &qualify_domain_sender },
431 { "qualify_recipient", vtype_stringptr, &qualify_domain_recipient },
432 { "rcpt_count", vtype_int, &rcpt_count },
433 { "rcpt_defer_count", vtype_int, &rcpt_defer_count },
434 { "rcpt_fail_count", vtype_int, &rcpt_fail_count },
435 { "received_count", vtype_int, &received_count },
436 { "received_for", vtype_stringptr, &received_for },
437 { "received_protocol", vtype_stringptr, &received_protocol },
438 { "received_time", vtype_int, &received_time },
439 { "recipient_data", vtype_stringptr, &recipient_data },
440 { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
441 { "recipients", vtype_recipients, NULL },
442 { "recipients_count", vtype_int, &recipients_count },
443 #ifdef WITH_CONTENT_SCAN
444 { "regex_match_string", vtype_stringptr, &regex_match_string },
445 #endif
446 { "reply_address", vtype_reply, NULL },
447 { "return_path", vtype_stringptr, &return_path },
448 { "return_size_limit", vtype_int, &bounce_return_size_limit },
449 { "runrc", vtype_int, &runrc },
450 { "self_hostname", vtype_stringptr, &self_hostname },
451 { "sender_address", vtype_stringptr, &sender_address },
452 { "sender_address_data", vtype_stringptr, &sender_address_data },
453 { "sender_address_domain", vtype_domain, &sender_address },
454 { "sender_address_local_part", vtype_localpart, &sender_address },
455 { "sender_data", vtype_stringptr, &sender_data },
456 { "sender_fullhost", vtype_stringptr, &sender_fullhost },
457 { "sender_helo_name", vtype_stringptr, &sender_helo_name },
458 { "sender_host_address", vtype_stringptr, &sender_host_address },
459 { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
460 { "sender_host_name", vtype_host_lookup, NULL },
461 { "sender_host_port", vtype_int, &sender_host_port },
462 { "sender_ident", vtype_stringptr, &sender_ident },
463 { "sender_rate", vtype_stringptr, &sender_rate },
464 { "sender_rate_limit", vtype_stringptr, &sender_rate_limit },
465 { "sender_rate_period", vtype_stringptr, &sender_rate_period },
466 { "sender_rcvhost", vtype_stringptr, &sender_rcvhost },
467 { "sender_verify_failure",vtype_stringptr, &sender_verify_failure },
468 { "smtp_active_hostname", vtype_stringptr, &smtp_active_hostname },
469 { "smtp_command", vtype_stringptr, &smtp_cmd_buffer },
470 { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
471 { "sn0", vtype_filter_int, &filter_sn[0] },
472 { "sn1", vtype_filter_int, &filter_sn[1] },
473 { "sn2", vtype_filter_int, &filter_sn[2] },
474 { "sn3", vtype_filter_int, &filter_sn[3] },
475 { "sn4", vtype_filter_int, &filter_sn[4] },
476 { "sn5", vtype_filter_int, &filter_sn[5] },
477 { "sn6", vtype_filter_int, &filter_sn[6] },
478 { "sn7", vtype_filter_int, &filter_sn[7] },
479 { "sn8", vtype_filter_int, &filter_sn[8] },
480 { "sn9", vtype_filter_int, &filter_sn[9] },
481 #ifdef WITH_CONTENT_SCAN
482 { "spam_bar", vtype_stringptr, &spam_bar },
483 { "spam_report", vtype_stringptr, &spam_report },
484 { "spam_score", vtype_stringptr, &spam_score },
485 { "spam_score_int", vtype_stringptr, &spam_score_int },
486 #endif
487 #ifdef EXPERIMENTAL_SPF
488 { "spf_header_comment", vtype_stringptr, &spf_header_comment },
489 { "spf_received", vtype_stringptr, &spf_received },
490 { "spf_result", vtype_stringptr, &spf_result },
491 { "spf_smtp_comment", vtype_stringptr, &spf_smtp_comment },
492 #endif
493 { "spool_directory", vtype_stringptr, &spool_directory },
494 { "spool_inodes", vtype_pinodes, (void *)TRUE },
495 { "spool_space", vtype_pspace, (void *)TRUE },
496 #ifdef EXPERIMENTAL_SRS
497 { "srs_db_address", vtype_stringptr, &srs_db_address },
498 { "srs_db_key", vtype_stringptr, &srs_db_key },
499 { "srs_orig_recipient", vtype_stringptr, &srs_orig_recipient },
500 { "srs_orig_sender", vtype_stringptr, &srs_orig_sender },
501 { "srs_recipient", vtype_stringptr, &srs_recipient },
502 { "srs_status", vtype_stringptr, &srs_status },
503 #endif
504 { "thisaddress", vtype_stringptr, &filter_thisaddress },
505 { "tls_certificate_verified", vtype_int, &tls_certificate_verified },
506 { "tls_cipher", vtype_stringptr, &tls_cipher },
507 { "tls_peerdn", vtype_stringptr, &tls_peerdn },
508 { "tod_bsdinbox", vtype_todbsdin, NULL },
509 { "tod_epoch", vtype_tode, NULL },
510 { "tod_full", vtype_todf, NULL },
511 { "tod_log", vtype_todl, NULL },
512 { "tod_logfile", vtype_todlf, NULL },
513 { "tod_zone", vtype_todzone, NULL },
514 { "tod_zulu", vtype_todzulu, NULL },
515 { "value", vtype_stringptr, &lookup_value },
516 { "version_number", vtype_stringptr, &version_string },
517 { "warn_message_delay", vtype_stringptr, &warnmsg_delay },
518 { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
519 { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
520 { "warnmsg_delay", vtype_stringptr, &warnmsg_delay },
521 { "warnmsg_recipient", vtype_stringptr, &warnmsg_recipients },
522 { "warnmsg_recipients", vtype_stringptr, &warnmsg_recipients }
523 };
524
525 static int var_table_size = sizeof(var_table)/sizeof(var_entry);
526 static uschar var_buffer[256];
527 static BOOL malformed_header;
528
529 /* For textual hashes */
530
531 static char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
532 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
533 "0123456789";
534
535 enum { HMAC_MD5, HMAC_SHA1 };
536
537 /* For numeric hashes */
538
539 static unsigned int prime[] = {
540 2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
541 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
542 73, 79, 83, 89, 97, 101, 103, 107, 109, 113};
543
544 /* For printing modes in symbolic form */
545
546 static uschar *mtable_normal[] =
547 { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
548
549 static uschar *mtable_setid[] =
550 { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
551
552 static uschar *mtable_sticky[] =
553 { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
554
555
556
557 /*************************************************
558 * Tables for UTF-8 support *
559 *************************************************/
560
561 /* Table of the number of extra characters, indexed by the first character
562 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
563 0x3d. */
564
565 static uschar utf8_table1[] = {
566 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
567 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
568 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
569 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
570
571 /* These are the masks for the data bits in the first byte of a character,
572 indexed by the number of additional bytes. */
573
574 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
575
576 /* Get the next UTF-8 character, advancing the pointer. */
577
578 #define GETUTF8INC(c, ptr) \
579 c = *ptr++; \
580 if ((c & 0xc0) == 0xc0) \
581 { \
582 int a = utf8_table1[c & 0x3f]; /* Number of additional bytes */ \
583 int s = 6*a; \
584 c = (c & utf8_table2[a]) << s; \
585 while (a-- > 0) \
586 { \
587 s -= 6; \
588 c |= (*ptr++ & 0x3f) << s; \
589 } \
590 }
591
592
593 /*************************************************
594 * Binary chop search on a table *
595 *************************************************/
596
597 /* This is used for matching expansion items and operators.
598
599 Arguments:
600 name the name that is being sought
601 table the table to search
602 table_size the number of items in the table
603
604 Returns: the offset in the table, or -1
605 */
606
607 static int
608 chop_match(uschar *name, uschar **table, int table_size)
609 {
610 uschar **bot = table;
611 uschar **top = table + table_size;
612
613 while (top > bot)
614 {
615 uschar **mid = bot + (top - bot)/2;
616 int c = Ustrcmp(name, *mid);
617 if (c == 0) return mid - table;
618 if (c > 0) bot = mid + 1; else top = mid;
619 }
620
621 return -1;
622 }
623
624
625
626 /*************************************************
627 * Check a condition string *
628 *************************************************/
629
630 /* This function is called to expand a string, and test the result for a "true"
631 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
632 forced fail or lookup defer. All store used by the function can be released on
633 exit.
634
635 Arguments:
636 condition the condition string
637 m1 text to be incorporated in panic error
638 m2 ditto
639
640 Returns: TRUE if condition is met, FALSE if not
641 */
642
643 BOOL
644 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
645 {
646 int rc;
647 void *reset_point = store_get(0);
648 uschar *ss = expand_string(condition);
649 if (ss == NULL)
650 {
651 if (!expand_string_forcedfail && !search_find_defer)
652 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
653 "for %s %s: %s", condition, m1, m2, expand_string_message);
654 return FALSE;
655 }
656 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
657 strcmpic(ss, US"false") != 0;
658 store_reset(reset_point);
659 return rc;
660 }
661
662
663
664 /*************************************************
665 * Pick out a name from a string *
666 *************************************************/
667
668 /* If the name is too long, it is silently truncated.
669
670 Arguments:
671 name points to a buffer into which to put the name
672 max is the length of the buffer
673 s points to the first alphabetic character of the name
674 extras chars other than alphanumerics to permit
675
676 Returns: pointer to the first character after the name
677
678 Note: The test for *s != 0 in the while loop is necessary because
679 Ustrchr() yields non-NULL if the character is zero (which is not something
680 I expected). */
681
682 static uschar *
683 read_name(uschar *name, int max, uschar *s, uschar *extras)
684 {
685 int ptr = 0;
686 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
687 {
688 if (ptr < max-1) name[ptr++] = *s;
689 s++;
690 }
691 name[ptr] = 0;
692 return s;
693 }
694
695
696
697 /*************************************************
698 * Pick out the rest of a header name *
699 *************************************************/
700
701 /* A variable name starting $header_ (or just $h_ for those who like
702 abbreviations) might not be the complete header name because headers can
703 contain any printing characters in their names, except ':'. This function is
704 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
705 on the end, if the name was terminated by white space.
706
707 Arguments:
708 name points to a buffer in which the name read so far exists
709 max is the length of the buffer
710 s points to the first character after the name so far, i.e. the
711 first non-alphameric character after $header_xxxxx
712
713 Returns: a pointer to the first character after the header name
714 */
715
716 static uschar *
717 read_header_name(uschar *name, int max, uschar *s)
718 {
719 int prelen = Ustrchr(name, '_') - name + 1;
720 int ptr = Ustrlen(name) - prelen;
721 if (ptr > 0) memmove(name, name+prelen, ptr);
722 while (mac_isgraph(*s) && *s != ':')
723 {
724 if (ptr < max-1) name[ptr++] = *s;
725 s++;
726 }
727 if (*s == ':') s++;
728 name[ptr++] = ':';
729 name[ptr] = 0;
730 return s;
731 }
732
733
734
735 /*************************************************
736 * Pick out a number from a string *
737 *************************************************/
738
739 /* Arguments:
740 n points to an integer into which to put the number
741 s points to the first digit of the number
742
743 Returns: a pointer to the character after the last digit
744 */
745
746 static uschar *
747 read_number(int *n, uschar *s)
748 {
749 *n = 0;
750 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
751 return s;
752 }
753
754
755
756 /*************************************************
757 * Extract keyed subfield from a string *
758 *************************************************/
759
760 /* The yield is in dynamic store; NULL means that the key was not found.
761
762 Arguments:
763 key points to the name of the key
764 s points to the string from which to extract the subfield
765
766 Returns: NULL if the subfield was not found, or
767 a pointer to the subfield's data
768 */
769
770 static uschar *
771 expand_getkeyed(uschar *key, uschar *s)
772 {
773 int length = Ustrlen(key);
774 while (isspace(*s)) s++;
775
776 /* Loop to search for the key */
777
778 while (*s != 0)
779 {
780 int dkeylength;
781 uschar *data;
782 uschar *dkey = s;
783
784 while (*s != 0 && *s != '=' && !isspace(*s)) s++;
785 dkeylength = s - dkey;
786 while (isspace(*s)) s++;
787 if (*s == '=') while (isspace((*(++s))));
788
789 data = string_dequote(&s);
790 if (length == dkeylength && strncmpic(key, dkey, length) == 0)
791 return data;
792
793 while (isspace(*s)) s++;
794 }
795
796 return NULL;
797 }
798
799
800
801
802 /*************************************************
803 * Extract numbered subfield from string *
804 *************************************************/
805
806 /* Extracts a numbered field from a string that is divided by tokens - for
807 example a line from /etc/passwd is divided by colon characters. First field is
808 numbered one. Negative arguments count from the right. Zero returns the whole
809 string. Returns NULL if there are insufficient tokens in the string
810
811 ***WARNING***
812 Modifies final argument - this is a dynamically generated string, so that's OK.
813
814 Arguments:
815 field number of field to be extracted,
816 first field = 1, whole string = 0, last field = -1
817 separators characters that are used to break string into tokens
818 s points to the string from which to extract the subfield
819
820 Returns: NULL if the field was not found,
821 a pointer to the field's data inside s (modified to add 0)
822 */
823
824 static uschar *
825 expand_gettokened (int field, uschar *separators, uschar *s)
826 {
827 int sep = 1;
828 int count;
829 uschar *ss = s;
830 uschar *fieldtext = NULL;
831
832 if (field == 0) return s;
833
834 /* Break the line up into fields in place; for field > 0 we stop when we have
835 done the number of fields we want. For field < 0 we continue till the end of
836 the string, counting the number of fields. */
837
838 count = (field > 0)? field : INT_MAX;
839
840 while (count-- > 0)
841 {
842 size_t len;
843
844 /* Previous field was the last one in the string. For a positive field
845 number, this means there are not enough fields. For a negative field number,
846 check that there are enough, and scan back to find the one that is wanted. */
847
848 if (sep == 0)
849 {
850 if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
851 if ((-field) == (INT_MAX - count - 1)) return s;
852 while (field++ < 0)
853 {
854 ss--;
855 while (ss[-1] != 0) ss--;
856 }
857 fieldtext = ss;
858 break;
859 }
860
861 /* Previous field was not last in the string; save its start and put a
862 zero at its end. */
863
864 fieldtext = ss;
865 len = Ustrcspn(ss, separators);
866 sep = ss[len];
867 ss[len] = 0;
868 ss += len + 1;
869 }
870
871 return fieldtext;
872 }
873
874
875
876 /*************************************************
877 * Extract a substring from a string *
878 *************************************************/
879
880 /* Perform the ${substr or ${length expansion operations.
881
882 Arguments:
883 subject the input string
884 value1 the offset from the start of the input string to the start of
885 the output string; if negative, count from the right.
886 value2 the length of the output string, or negative (-1) for unset
887 if value1 is positive, unset means "all after"
888 if value1 is negative, unset means "all before"
889 len set to the length of the returned string
890
891 Returns: pointer to the output string, or NULL if there is an error
892 */
893
894 static uschar *
895 extract_substr(uschar *subject, int value1, int value2, int *len)
896 {
897 int sublen = Ustrlen(subject);
898
899 if (value1 < 0) /* count from right */
900 {
901 value1 += sublen;
902
903 /* If the position is before the start, skip to the start, and adjust the
904 length. If the length ends up negative, the substring is null because nothing
905 can precede. This falls out naturally when the length is unset, meaning "all
906 to the left". */
907
908 if (value1 < 0)
909 {
910 value2 += value1;
911 if (value2 < 0) value2 = 0;
912 value1 = 0;
913 }
914
915 /* Otherwise an unset length => characters before value1 */
916
917 else if (value2 < 0)
918 {
919 value2 = value1;
920 value1 = 0;
921 }
922 }
923
924 /* For a non-negative offset, if the starting position is past the end of the
925 string, the result will be the null string. Otherwise, an unset length means
926 "rest"; just set it to the maximum - it will be cut down below if necessary. */
927
928 else
929 {
930 if (value1 > sublen)
931 {
932 value1 = sublen;
933 value2 = 0;
934 }
935 else if (value2 < 0) value2 = sublen;
936 }
937
938 /* Cut the length down to the maximum possible for the offset value, and get
939 the required characters. */
940
941 if (value1 + value2 > sublen) value2 = sublen - value1;
942 *len = value2;
943 return subject + value1;
944 }
945
946
947
948
949 /*************************************************
950 * Old-style hash of a string *
951 *************************************************/
952
953 /* Perform the ${hash expansion operation.
954
955 Arguments:
956 subject the input string (an expanded substring)
957 value1 the length of the output string; if greater or equal to the
958 length of the input string, the input string is returned
959 value2 the number of hash characters to use, or 26 if negative
960 len set to the length of the returned string
961
962 Returns: pointer to the output string, or NULL if there is an error
963 */
964
965 static uschar *
966 compute_hash(uschar *subject, int value1, int value2, int *len)
967 {
968 int sublen = Ustrlen(subject);
969
970 if (value2 < 0) value2 = 26;
971 else if (value2 > Ustrlen(hashcodes))
972 {
973 expand_string_message =
974 string_sprintf("hash count \"%d\" too big", value2);
975 return NULL;
976 }
977
978 /* Calculate the hash text. We know it is shorter than the original string, so
979 can safely place it in subject[] (we know that subject is always itself an
980 expanded substring). */
981
982 if (value1 < sublen)
983 {
984 int c;
985 int i = 0;
986 int j = value1;
987 while ((c = (subject[j])) != 0)
988 {
989 int shift = (c + j++) & 7;
990 subject[i] ^= (c << shift) | (c >> (8-shift));
991 if (++i >= value1) i = 0;
992 }
993 for (i = 0; i < value1; i++)
994 subject[i] = hashcodes[(subject[i]) % value2];
995 }
996 else value1 = sublen;
997
998 *len = value1;
999 return subject;
1000 }
1001
1002
1003
1004
1005 /*************************************************
1006 * Numeric hash of a string *
1007 *************************************************/
1008
1009 /* Perform the ${nhash expansion operation. The first characters of the
1010 string are treated as most important, and get the highest prime numbers.
1011
1012 Arguments:
1013 subject the input string
1014 value1 the maximum value of the first part of the result
1015 value2 the maximum value of the second part of the result,
1016 or negative to produce only a one-part result
1017 len set to the length of the returned string
1018
1019 Returns: pointer to the output string, or NULL if there is an error.
1020 */
1021
1022 static uschar *
1023 compute_nhash (uschar *subject, int value1, int value2, int *len)
1024 {
1025 uschar *s = subject;
1026 int i = 0;
1027 unsigned long int total = 0; /* no overflow */
1028
1029 while (*s != 0)
1030 {
1031 if (i == 0) i = sizeof(prime)/sizeof(int) - 1;
1032 total += prime[i--] * (unsigned int)(*s++);
1033 }
1034
1035 /* If value2 is unset, just compute one number */
1036
1037 if (value2 < 0)
1038 {
1039 s = string_sprintf("%d", total % value1);
1040 }
1041
1042 /* Otherwise do a div/mod hash */
1043
1044 else
1045 {
1046 total = total % (value1 * value2);
1047 s = string_sprintf("%d/%d", total/value2, total % value2);
1048 }
1049
1050 *len = Ustrlen(s);
1051 return s;
1052 }
1053
1054
1055
1056
1057
1058 /*************************************************
1059 * Find the value of a header or headers *
1060 *************************************************/
1061
1062 /* Multiple instances of the same header get concatenated, and this function
1063 can also return a concatenation of all the header lines. When concatenating
1064 specific headers that contain lists of addresses, a comma is inserted between
1065 them. Otherwise we use a straight concatenation. Because some messages can have
1066 pathologically large number of lines, there is a limit on the length that is
1067 returned. Also, to avoid massive store use which would result from using
1068 string_cat() as it copies and extends strings, we do a preliminary pass to find
1069 out exactly how much store will be needed. On "normal" messages this will be
1070 pretty trivial.
1071
1072 Arguments:
1073 name the name of the header, without the leading $header_ or $h_,
1074 or NULL if a concatenation of all headers is required
1075 exists_only TRUE if called from a def: test; don't need to build a string;
1076 just return a string that is not "" and not "0" if the header
1077 exists
1078 newsize return the size of memory block that was obtained; may be NULL
1079 if exists_only is TRUE
1080 want_raw TRUE if called for $rh_ or $rheader_ variables; no processing,
1081 other than concatenating, will be done on the header
1082 charset name of charset to translate MIME words to; used only if
1083 want_raw is false; if NULL, no translation is done (this is
1084 used for $bh_ and $bheader_)
1085
1086 Returns: NULL if the header does not exist, else a pointer to a new
1087 store block
1088 */
1089
1090 static uschar *
1091 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1092 uschar *charset)
1093 {
1094 BOOL found = name == NULL;
1095 int comma = 0;
1096 int len = found? 0 : Ustrlen(name);
1097 int i;
1098 uschar *yield = NULL;
1099 uschar *ptr = NULL;
1100
1101 /* Loop for two passes - saves code repetition */
1102
1103 for (i = 0; i < 2; i++)
1104 {
1105 int size = 0;
1106 header_line *h;
1107
1108 for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1109 {
1110 if (h->type != htype_old && h->text != NULL) /* NULL => Received: placeholder */
1111 {
1112 if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1113 {
1114 int ilen;
1115 uschar *t;
1116
1117 if (exists_only) return US"1"; /* don't need actual string */
1118 found = TRUE;
1119 t = h->text + len; /* text to insert */
1120 if (!want_raw) /* unless wanted raw, */
1121 while (isspace(*t)) t++; /* remove leading white space */
1122 ilen = h->slen - (t - h->text); /* length to insert */
1123
1124 /* Set comma = 1 if handling a single header and it's one of those
1125 that contains an address list, except when asked for raw headers. Only
1126 need to do this once. */
1127
1128 if (!want_raw && name != NULL && comma == 0 &&
1129 Ustrchr("BCFRST", h->type) != NULL)
1130 comma = 1;
1131
1132 /* First pass - compute total store needed; second pass - compute
1133 total store used, including this header. */
1134
1135 size += ilen + comma;
1136
1137 /* Second pass - concatentate the data, up to a maximum. Note that
1138 the loop stops when size hits the limit. */
1139
1140 if (i != 0)
1141 {
1142 if (size > header_insert_maxlen)
1143 {
1144 ilen -= size - header_insert_maxlen;
1145 comma = 0;
1146 }
1147 Ustrncpy(ptr, t, ilen);
1148 ptr += ilen;
1149 if (comma != 0 && ilen > 0)
1150 {
1151 ptr[-1] = ',';
1152 *ptr++ = '\n';
1153 }
1154 }
1155 }
1156 }
1157 }
1158
1159 /* At end of first pass, truncate size if necessary, and get the buffer
1160 to hold the data, returning the buffer size. */
1161
1162 if (i == 0)
1163 {
1164 if (!found) return NULL;
1165 if (size > header_insert_maxlen) size = header_insert_maxlen;
1166 *newsize = size + 1;
1167 ptr = yield = store_get(*newsize);
1168 }
1169 }
1170
1171 /* Remove a redundant added comma if present */
1172
1173 if (comma != 0 && ptr > yield) ptr -= 2;
1174
1175 /* That's all we do for raw header expansion. */
1176
1177 if (want_raw)
1178 {
1179 *ptr = 0;
1180 }
1181
1182 /* Otherwise, we remove trailing whitespace, including newlines. Then we do RFC
1183 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1184 function can return an error with decoded data if the charset translation
1185 fails. If decoding fails, it returns NULL. */
1186
1187 else
1188 {
1189 uschar *decoded, *error;
1190 while (ptr > yield && isspace(ptr[-1])) ptr--;
1191 *ptr = 0;
1192 decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1193 newsize, &error);
1194 if (error != NULL)
1195 {
1196 DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1197 " input was: %s\n", error, yield);
1198 }
1199 if (decoded != NULL) yield = decoded;
1200 }
1201
1202 return yield;
1203 }
1204
1205
1206
1207
1208 /*************************************************
1209 * Find value of a variable *
1210 *************************************************/
1211
1212 /* The table of variables is kept in alphabetic order, so we can search it
1213 using a binary chop. The "choplen" variable is nothing to do with the binary
1214 chop.
1215
1216 Arguments:
1217 name the name of the variable being sought
1218 exists_only TRUE if this is a def: test; passed on to find_header()
1219 skipping TRUE => skip any processing evaluation; this is not the same as
1220 exists_only because def: may test for values that are first
1221 evaluated here
1222 newsize pointer to an int which is initially zero; if the answer is in
1223 a new memory buffer, *newsize is set to its size
1224
1225 Returns: NULL if the variable does not exist, or
1226 a pointer to the variable's contents, or
1227 something non-NULL if exists_only is TRUE
1228 */
1229
1230 static uschar *
1231 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1232 {
1233 int first = 0;
1234 int last = var_table_size;
1235
1236 /* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1237 Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1238 release 4.64 onwards arbitrary names are permitted, as long as the first 5
1239 characters are acl_c or acl_m and the sixth is either a digit or an underscore
1240 (this gave backwards compatibility at the changeover). There may be built-in
1241 variables whose names start acl_ but they should never start in this way. This
1242 slightly messy specification is a consequence of the history, needless to say.
1243
1244 If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1245 set, in which case give an error. */
1246
1247 if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1248 !isalpha(name[5]))
1249 {
1250 tree_node *node =
1251 tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
1252 return (node == NULL)? (strict_acl_vars? NULL : US"") : node->data.ptr;
1253 }
1254
1255 /* Handle $auth<n> variables. */
1256
1257 if (Ustrncmp(name, "auth", 4) == 0)
1258 {
1259 uschar *endptr;
1260 int n = Ustrtoul(name + 4, &endptr, 10);
1261 if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
1262 return (auth_vars[n-1] == NULL)? US"" : auth_vars[n-1];
1263 }
1264
1265 /* For all other variables, search the table */
1266
1267 while (last > first)
1268 {
1269 uschar *s, *domain;
1270 uschar **ss;
1271 int middle = (first + last)/2;
1272 int c = Ustrcmp(name, var_table[middle].name);
1273
1274 if (c > 0) { first = middle + 1; continue; }
1275 if (c < 0) { last = middle; continue; }
1276
1277 /* Found an existing variable. If in skipping state, the value isn't needed,
1278 and we want to avoid processing (such as looking up the host name). */
1279
1280 if (skipping) return US"";
1281
1282 switch (var_table[middle].type)
1283 {
1284 #ifdef EXPERIMENTAL_DOMAINKEYS
1285
1286 case vtype_dk_verify:
1287 if (dk_verify_block == NULL) return US"";
1288 s = NULL;
1289 if (Ustrcmp(var_table[middle].name, "dk_result") == 0)
1290 s = dk_verify_block->result_string;
1291 if (Ustrcmp(var_table[middle].name, "dk_sender") == 0)
1292 s = dk_verify_block->address;
1293 if (Ustrcmp(var_table[middle].name, "dk_sender_domain") == 0)
1294 s = dk_verify_block->domain;
1295 if (Ustrcmp(var_table[middle].name, "dk_sender_local_part") == 0)
1296 s = dk_verify_block->local_part;
1297
1298 if (Ustrcmp(var_table[middle].name, "dk_sender_source") == 0)
1299 switch(dk_verify_block->address_source) {
1300 case DK_EXIM_ADDRESS_NONE: s = US"0"; break;
1301 case DK_EXIM_ADDRESS_FROM_FROM: s = US"from"; break;
1302 case DK_EXIM_ADDRESS_FROM_SENDER: s = US"sender"; break;
1303 }
1304
1305 if (Ustrcmp(var_table[middle].name, "dk_status") == 0)
1306 switch(dk_verify_block->result) {
1307 case DK_EXIM_RESULT_ERR: s = US"error"; break;
1308 case DK_EXIM_RESULT_BAD_FORMAT: s = US"bad format"; break;
1309 case DK_EXIM_RESULT_NO_KEY: s = US"no key"; break;
1310 case DK_EXIM_RESULT_NO_SIGNATURE: s = US"no signature"; break;
1311 case DK_EXIM_RESULT_REVOKED: s = US"revoked"; break;
1312 case DK_EXIM_RESULT_NON_PARTICIPANT: s = US"non-participant"; break;
1313 case DK_EXIM_RESULT_GOOD: s = US"good"; break;
1314 case DK_EXIM_RESULT_BAD: s = US"bad"; break;
1315 }
1316
1317 if (Ustrcmp(var_table[middle].name, "dk_signsall") == 0)
1318 s = (dk_verify_block->signsall)? US"1" : US"0";
1319
1320 if (Ustrcmp(var_table[middle].name, "dk_testing") == 0)
1321 s = (dk_verify_block->testing)? US"1" : US"0";
1322
1323 if (Ustrcmp(var_table[middle].name, "dk_is_signed") == 0)
1324 s = (dk_verify_block->is_signed)? US"1" : US"0";
1325
1326 return (s == NULL)? US"" : s;
1327 #endif
1328
1329 case vtype_filter_int:
1330 if (!filter_running) return NULL;
1331 /* Fall through */
1332 /* VVVVVVVVVVVV */
1333 case vtype_int:
1334 sprintf(CS var_buffer, "%d", *(int *)(var_table[middle].value)); /* Integer */
1335 return var_buffer;
1336
1337 case vtype_ino:
1338 sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(var_table[middle].value))); /* Inode */
1339 return var_buffer;
1340
1341 case vtype_gid:
1342 sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(var_table[middle].value))); /* gid */
1343 return var_buffer;
1344
1345 case vtype_uid:
1346 sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(var_table[middle].value))); /* uid */
1347 return var_buffer;
1348
1349 case vtype_stringptr: /* Pointer to string */
1350 s = *((uschar **)(var_table[middle].value));
1351 return (s == NULL)? US"" : s;
1352
1353 case vtype_pid:
1354 sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1355 return var_buffer;
1356
1357 case vtype_load_avg:
1358 sprintf(CS var_buffer, "%d", os_getloadavg()); /* load_average */
1359 return var_buffer;
1360
1361 case vtype_host_lookup: /* Lookup if not done so */
1362 if (sender_host_name == NULL && sender_host_address != NULL &&
1363 !host_lookup_failed && host_name_lookup() == OK)
1364 host_build_sender_fullhost();
1365 return (sender_host_name == NULL)? US"" : sender_host_name;
1366
1367 case vtype_localpart: /* Get local part from address */
1368 s = *((uschar **)(var_table[middle].value));
1369 if (s == NULL) return US"";
1370 domain = Ustrrchr(s, '@');
1371 if (domain == NULL) return s;
1372 if (domain - s > sizeof(var_buffer) - 1)
1373 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than %d in "
1374 "string expansion", sizeof(var_buffer));
1375 Ustrncpy(var_buffer, s, domain - s);
1376 var_buffer[domain - s] = 0;
1377 return var_buffer;
1378
1379 case vtype_domain: /* Get domain from address */
1380 s = *((uschar **)(var_table[middle].value));
1381 if (s == NULL) return US"";
1382 domain = Ustrrchr(s, '@');
1383 return (domain == NULL)? US"" : domain + 1;
1384
1385 case vtype_msgheaders:
1386 return find_header(NULL, exists_only, newsize, FALSE, NULL);
1387
1388 case vtype_msgbody: /* Pointer to msgbody string */
1389 case vtype_msgbody_end: /* Ditto, the end of the msg */
1390 ss = (uschar **)(var_table[middle].value);
1391 if (*ss == NULL && deliver_datafile >= 0) /* Read body when needed */
1392 {
1393 uschar *body;
1394 off_t start_offset = SPOOL_DATA_START_OFFSET;
1395 int len = message_body_visible;
1396 if (len > message_size) len = message_size;
1397 *ss = body = store_malloc(len+1);
1398 body[0] = 0;
1399 if (var_table[middle].type == vtype_msgbody_end)
1400 {
1401 struct stat statbuf;
1402 if (fstat(deliver_datafile, &statbuf) == 0)
1403 {
1404 start_offset = statbuf.st_size - len;
1405 if (start_offset < SPOOL_DATA_START_OFFSET)
1406 start_offset = SPOOL_DATA_START_OFFSET;
1407 }
1408 }
1409 lseek(deliver_datafile, start_offset, SEEK_SET);
1410 len = read(deliver_datafile, body, len);
1411 if (len > 0)
1412 {
1413 body[len] = 0;
1414 while (len > 0)
1415 {
1416 if (body[--len] == '\n' || body[len] == 0) body[len] = ' ';
1417 }
1418 }
1419 }
1420 return (*ss == NULL)? US"" : *ss;
1421
1422 case vtype_todbsdin: /* BSD inbox time of day */
1423 return tod_stamp(tod_bsdin);
1424
1425 case vtype_tode: /* Unix epoch time of day */
1426 return tod_stamp(tod_epoch);
1427
1428 case vtype_todf: /* Full time of day */
1429 return tod_stamp(tod_full);
1430
1431 case vtype_todl: /* Log format time of day */
1432 return tod_stamp(tod_log_bare); /* (without timezone) */
1433
1434 case vtype_todzone: /* Time zone offset only */
1435 return tod_stamp(tod_zone);
1436
1437 case vtype_todzulu: /* Zulu time */
1438 return tod_stamp(tod_zulu);
1439
1440 case vtype_todlf: /* Log file datestamp tod */
1441 return tod_stamp(tod_log_datestamp);
1442
1443 case vtype_reply: /* Get reply address */
1444 s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1445 headers_charset);
1446 if (s != NULL) while (isspace(*s)) s++;
1447 if (s == NULL || *s == 0)
1448 {
1449 *newsize = 0; /* For the *s==0 case */
1450 s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1451 }
1452 if (s != NULL)
1453 {
1454 uschar *t;
1455 while (isspace(*s)) s++;
1456 for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1457 while (t > s && isspace(t[-1])) t--;
1458 *t = 0;
1459 }
1460 return (s == NULL)? US"" : s;
1461
1462 /* A recipients list is available only during system message filtering,
1463 during ACL processing after DATA, and while expanding pipe commands
1464 generated from a system filter, but not elsewhere. */
1465
1466 case vtype_recipients:
1467 if (!enable_dollar_recipients) return NULL; else
1468 {
1469 int size = 128;
1470 int ptr = 0;
1471 int i;
1472 s = store_get(size);
1473 for (i = 0; i < recipients_count; i++)
1474 {
1475 if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1476 s = string_cat(s, &size, &ptr, recipients_list[i].address,
1477 Ustrlen(recipients_list[i].address));
1478 }
1479 s[ptr] = 0; /* string_cat() leaves room */
1480 }
1481 return s;
1482
1483 case vtype_pspace:
1484 {
1485 int inodes;
1486 sprintf(CS var_buffer, "%d",
1487 receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes));
1488 }
1489 return var_buffer;
1490
1491 case vtype_pinodes:
1492 {
1493 int inodes;
1494 (void) receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes);
1495 sprintf(CS var_buffer, "%d", inodes);
1496 }
1497 return var_buffer;
1498 }
1499 }
1500
1501 return NULL; /* Unknown variable name */
1502 }
1503
1504
1505
1506
1507 /*************************************************
1508 * Read and expand substrings *
1509 *************************************************/
1510
1511 /* This function is called to read and expand argument substrings for various
1512 expansion items. Some have a minimum requirement that is less than the maximum;
1513 in these cases, the first non-present one is set to NULL.
1514
1515 Arguments:
1516 sub points to vector of pointers to set
1517 n maximum number of substrings
1518 m minimum required
1519 sptr points to current string pointer
1520 skipping the skipping flag
1521 check_end if TRUE, check for final '}'
1522 name name of item, for error message
1523
1524 Returns: 0 OK; string pointer updated
1525 1 curly bracketing error (too few arguments)
1526 2 too many arguments (only if check_end is set); message set
1527 3 other error (expansion failure)
1528 */
1529
1530 static int
1531 read_subs(uschar **sub, int n, int m, uschar **sptr, BOOL skipping,
1532 BOOL check_end, uschar *name)
1533 {
1534 int i;
1535 uschar *s = *sptr;
1536
1537 while (isspace(*s)) s++;
1538 for (i = 0; i < n; i++)
1539 {
1540 if (*s != '{')
1541 {
1542 if (i < m) return 1;
1543 sub[i] = NULL;
1544 break;
1545 }
1546 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
1547 if (sub[i] == NULL) return 3;
1548 if (*s++ != '}') return 1;
1549 while (isspace(*s)) s++;
1550 }
1551 if (check_end && *s++ != '}')
1552 {
1553 if (s[-1] == '{')
1554 {
1555 expand_string_message = string_sprintf("Too many arguments for \"%s\" "
1556 "(max is %d)", name, n);
1557 return 2;
1558 }
1559 return 1;
1560 }
1561
1562 *sptr = s;
1563 return 0;
1564 }
1565
1566
1567
1568
1569 /*************************************************
1570 * Elaborate message for bad variable *
1571 *************************************************/
1572
1573 /* For the "unknown variable" message, take a look at the variable's name, and
1574 give additional information about possible ACL variables. The extra information
1575 is added on to expand_string_message.
1576
1577 Argument: the name of the variable
1578 Returns: nothing
1579 */
1580
1581 static void
1582 check_variable_error_message(uschar *name)
1583 {
1584 if (Ustrncmp(name, "acl_", 4) == 0)
1585 expand_string_message = string_sprintf("%s (%s)", expand_string_message,
1586 (name[4] == 'c' || name[4] == 'm')?
1587 (isalpha(name[5])?
1588 US"6th character of a user-defined ACL variable must be a digit or underscore" :
1589 US"strict_acl_vars is set" /* Syntax is OK, it has to be this */
1590 ) :
1591 US"user-defined ACL variables must start acl_c or acl_m");
1592 }
1593
1594
1595
1596 /*************************************************
1597 * Read and evaluate a condition *
1598 *************************************************/
1599
1600 /*
1601 Arguments:
1602 s points to the start of the condition text
1603 yield points to a BOOL to hold the result of the condition test;
1604 if NULL, we are just reading through a condition that is
1605 part of an "or" combination to check syntax, or in a state
1606 where the answer isn't required
1607
1608 Returns: a pointer to the first character after the condition, or
1609 NULL after an error
1610 */
1611
1612 static uschar *
1613 eval_condition(uschar *s, BOOL *yield)
1614 {
1615 BOOL testfor = TRUE;
1616 BOOL tempcond, combined_cond;
1617 BOOL *subcondptr;
1618 int i, rc, cond_type, roffset;
1619 int num[2];
1620 struct stat statbuf;
1621 uschar name[256];
1622 uschar *sub[4];
1623
1624 const pcre *re;
1625 const uschar *rerror;
1626
1627 for (;;)
1628 {
1629 while (isspace(*s)) s++;
1630 if (*s == '!') { testfor = !testfor; s++; } else break;
1631 }
1632
1633 /* Numeric comparisons are symbolic */
1634
1635 if (*s == '=' || *s == '>' || *s == '<')
1636 {
1637 int p = 0;
1638 name[p++] = *s++;
1639 if (*s == '=')
1640 {
1641 name[p++] = '=';
1642 s++;
1643 }
1644 name[p] = 0;
1645 }
1646
1647 /* All other conditions are named */
1648
1649 else s = read_name(name, 256, s, US"_");
1650
1651 /* If we haven't read a name, it means some non-alpha character is first. */
1652
1653 if (name[0] == 0)
1654 {
1655 expand_string_message = string_sprintf("condition name expected, "
1656 "but found \"%.16s\"", s);
1657 return NULL;
1658 }
1659
1660 /* Find which condition we are dealing with, and switch on it */
1661
1662 cond_type = chop_match(name, cond_table, sizeof(cond_table)/sizeof(uschar *));
1663 switch(cond_type)
1664 {
1665 /* def: tests for a non-empty variable, or for the existence of a header. If
1666 yield == NULL we are in a skipping state, and don't care about the answer. */
1667
1668 case ECOND_DEF:
1669 if (*s != ':')
1670 {
1671 expand_string_message = US"\":\" expected after \"def\"";
1672 return NULL;
1673 }
1674
1675 s = read_name(name, 256, s+1, US"_");
1676
1677 /* Test for a header's existence */
1678
1679 if (Ustrncmp(name, "h_", 2) == 0 ||
1680 Ustrncmp(name, "rh_", 3) == 0 ||
1681 Ustrncmp(name, "bh_", 3) == 0 ||
1682 Ustrncmp(name, "header_", 7) == 0 ||
1683 Ustrncmp(name, "rheader_", 8) == 0 ||
1684 Ustrncmp(name, "bheader_", 8) == 0)
1685 {
1686 s = read_header_name(name, 256, s);
1687 if (yield != NULL) *yield =
1688 (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
1689 }
1690
1691 /* Test for a variable's having a non-empty value. A non-existent variable
1692 causes an expansion failure. */
1693
1694 else
1695 {
1696 uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
1697 if (value == NULL)
1698 {
1699 expand_string_message = (name[0] == 0)?
1700 string_sprintf("variable name omitted after \"def:\"") :
1701 string_sprintf("unknown variable \"%s\" after \"def:\"", name);
1702 check_variable_error_message(name);
1703 return NULL;
1704 }
1705 if (yield != NULL) *yield = (value[0] != 0) == testfor;
1706 }
1707
1708 return s;
1709
1710
1711 /* first_delivery tests for first delivery attempt */
1712
1713 case ECOND_FIRST_DELIVERY:
1714 if (yield != NULL) *yield = deliver_firsttime == testfor;
1715 return s;
1716
1717
1718 /* queue_running tests for any process started by a queue runner */
1719
1720 case ECOND_QUEUE_RUNNING:
1721 if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
1722 return s;
1723
1724
1725 /* exists: tests for file existence
1726 isip: tests for any IP address
1727 isip4: tests for an IPv4 address
1728 isip6: tests for an IPv6 address
1729 pam: does PAM authentication
1730 radius: does RADIUS authentication
1731 ldapauth: does LDAP authentication
1732 pwcheck: does Cyrus SASL pwcheck authentication
1733 */
1734
1735 case ECOND_EXISTS:
1736 case ECOND_ISIP:
1737 case ECOND_ISIP4:
1738 case ECOND_ISIP6:
1739 case ECOND_PAM:
1740 case ECOND_RADIUS:
1741 case ECOND_LDAPAUTH:
1742 case ECOND_PWCHECK:
1743
1744 while (isspace(*s)) s++;
1745 if (*s != '{') goto COND_FAILED_CURLY_START;
1746
1747 sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1748 if (sub[0] == NULL) return NULL;
1749 if (*s++ != '}') goto COND_FAILED_CURLY_END;
1750
1751 if (yield == NULL) return s; /* No need to run the test if skipping */
1752
1753 switch(cond_type)
1754 {
1755 case ECOND_EXISTS:
1756 if ((expand_forbid & RDO_EXISTS) != 0)
1757 {
1758 expand_string_message = US"File existence tests are not permitted";
1759 return NULL;
1760 }
1761 *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
1762 break;
1763
1764 case ECOND_ISIP:
1765 case ECOND_ISIP4:
1766 case ECOND_ISIP6:
1767 rc = string_is_ip_address(sub[0], NULL);
1768 *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
1769 (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
1770 break;
1771
1772 /* Various authentication tests - all optionally compiled */
1773
1774 case ECOND_PAM:
1775 #ifdef SUPPORT_PAM
1776 rc = auth_call_pam(sub[0], &expand_string_message);
1777 goto END_AUTH;
1778 #else
1779 goto COND_FAILED_NOT_COMPILED;
1780 #endif /* SUPPORT_PAM */
1781
1782 case ECOND_RADIUS:
1783 #ifdef RADIUS_CONFIG_FILE
1784 rc = auth_call_radius(sub[0], &expand_string_message);
1785 goto END_AUTH;
1786 #else
1787 goto COND_FAILED_NOT_COMPILED;
1788 #endif /* RADIUS_CONFIG_FILE */
1789
1790 case ECOND_LDAPAUTH:
1791 #ifdef LOOKUP_LDAP
1792 {
1793 /* Just to keep the interface the same */
1794 BOOL do_cache;
1795 int old_pool = store_pool;
1796 store_pool = POOL_SEARCH;
1797 rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
1798 &expand_string_message, &do_cache);
1799 store_pool = old_pool;
1800 }
1801 goto END_AUTH;
1802 #else
1803 goto COND_FAILED_NOT_COMPILED;
1804 #endif /* LOOKUP_LDAP */
1805
1806 case ECOND_PWCHECK:
1807 #ifdef CYRUS_PWCHECK_SOCKET
1808 rc = auth_call_pwcheck(sub[0], &expand_string_message);
1809 goto END_AUTH;
1810 #else
1811 goto COND_FAILED_NOT_COMPILED;
1812 #endif /* CYRUS_PWCHECK_SOCKET */
1813
1814 #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
1815 defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
1816 END_AUTH:
1817 if (rc == ERROR || rc == DEFER) return NULL;
1818 *yield = (rc == OK) == testfor;
1819 #endif
1820 }
1821 return s;
1822
1823
1824 /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
1825
1826 ${if saslauthd {{username}{password}{service}{realm}} {yes}[no}}
1827
1828 However, the last two are optional. That is why the whole set is enclosed
1829 in their own set or braces. */
1830
1831 case ECOND_SASLAUTHD:
1832 #ifndef CYRUS_SASLAUTHD_SOCKET
1833 goto COND_FAILED_NOT_COMPILED;
1834 #else
1835 while (isspace(*s)) s++;
1836 if (*s++ != '{') goto COND_FAILED_CURLY_START;
1837 switch(read_subs(sub, 4, 2, &s, yield == NULL, TRUE, US"saslauthd"))
1838 {
1839 case 1: expand_string_message = US"too few arguments or bracketing "
1840 "error for saslauthd";
1841 case 2:
1842 case 3: return NULL;
1843 }
1844 if (sub[2] == NULL) sub[3] = NULL; /* realm if no service */
1845 if (yield != NULL)
1846 {
1847 int rc;
1848 rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
1849 &expand_string_message);
1850 if (rc == ERROR || rc == DEFER) return NULL;
1851 *yield = (rc == OK) == testfor;
1852 }
1853 return s;
1854 #endif /* CYRUS_SASLAUTHD_SOCKET */
1855
1856
1857 /* symbolic operators for numeric and string comparison, and a number of
1858 other operators, all requiring two arguments.
1859
1860 match: does a regular expression match and sets up the numerical
1861 variables if it succeeds
1862 match_address: matches in an address list
1863 match_domain: matches in a domain list
1864 match_ip: matches a host list that is restricted to IP addresses
1865 match_local_part: matches in a local part list
1866 crypteq: encrypts plaintext and compares against an encrypted text,
1867 using crypt(), crypt16(), MD5 or SHA-1
1868 */
1869
1870 case ECOND_MATCH:
1871 case ECOND_MATCH_ADDRESS:
1872 case ECOND_MATCH_DOMAIN:
1873 case ECOND_MATCH_IP:
1874 case ECOND_MATCH_LOCAL_PART:
1875 case ECOND_CRYPTEQ:
1876
1877 case ECOND_NUM_L: /* Numerical comparisons */
1878 case ECOND_NUM_LE:
1879 case ECOND_NUM_E:
1880 case ECOND_NUM_EE:
1881 case ECOND_NUM_G:
1882 case ECOND_NUM_GE:
1883
1884 case ECOND_STR_LT: /* String comparisons */
1885 case ECOND_STR_LTI:
1886 case ECOND_STR_LE:
1887 case ECOND_STR_LEI:
1888 case ECOND_STR_EQ:
1889 case ECOND_STR_EQI:
1890 case ECOND_STR_GT:
1891 case ECOND_STR_GTI:
1892 case ECOND_STR_GE:
1893 case ECOND_STR_GEI:
1894
1895 for (i = 0; i < 2; i++)
1896 {
1897 while (isspace(*s)) s++;
1898 if (*s != '{')
1899 {
1900 if (i == 0) goto COND_FAILED_CURLY_START;
1901 expand_string_message = string_sprintf("missing 2nd string in {} "
1902 "after \"%s\"", name);
1903 return NULL;
1904 }
1905 sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL);
1906 if (sub[i] == NULL) return NULL;
1907 if (*s++ != '}') goto COND_FAILED_CURLY_END;
1908
1909 /* Convert to numerical if required; we know that the names of all the
1910 conditions that compare numbers do not start with a letter. This just saves
1911 checking for them individually. */
1912
1913 if (!isalpha(name[0]))
1914 {
1915 num[i] = expand_string_integer(sub[i], FALSE);
1916 if (expand_string_message != NULL) return NULL;
1917 }
1918 }
1919
1920 /* Result not required */
1921
1922 if (yield == NULL) return s;
1923
1924 /* Do an appropriate comparison */
1925
1926 switch(cond_type)
1927 {
1928 case ECOND_NUM_E:
1929 case ECOND_NUM_EE:
1930 *yield = (num[0] == num[1]) == testfor;
1931 break;
1932
1933 case ECOND_NUM_G:
1934 *yield = (num[0] > num[1]) == testfor;
1935 break;
1936
1937 case ECOND_NUM_GE:
1938 *yield = (num[0] >= num[1]) == testfor;
1939 break;
1940
1941 case ECOND_NUM_L:
1942 *yield = (num[0] < num[1]) == testfor;
1943 break;
1944
1945 case ECOND_NUM_LE:
1946 *yield = (num[0] <= num[1]) == testfor;
1947 break;
1948
1949 case ECOND_STR_LT:
1950 *yield = (Ustrcmp(sub[0], sub[1]) < 0) == testfor;
1951 break;
1952
1953 case ECOND_STR_LTI:
1954 *yield = (strcmpic(sub[0], sub[1]) < 0) == testfor;
1955 break;
1956
1957 case ECOND_STR_LE:
1958 *yield = (Ustrcmp(sub[0], sub[1]) <= 0) == testfor;
1959 break;
1960
1961 case ECOND_STR_LEI:
1962 *yield = (strcmpic(sub[0], sub[1]) <= 0) == testfor;
1963 break;
1964
1965 case ECOND_STR_EQ:
1966 *yield = (Ustrcmp(sub[0], sub[1]) == 0) == testfor;
1967 break;
1968
1969 case ECOND_STR_EQI:
1970 *yield = (strcmpic(sub[0], sub[1]) == 0) == testfor;
1971 break;
1972
1973 case ECOND_STR_GT:
1974 *yield = (Ustrcmp(sub[0], sub[1]) > 0) == testfor;
1975 break;
1976
1977 case ECOND_STR_GTI:
1978 *yield = (strcmpic(sub[0], sub[1]) > 0) == testfor;
1979 break;
1980
1981 case ECOND_STR_GE:
1982 *yield = (Ustrcmp(sub[0], sub[1]) >= 0) == testfor;
1983 break;
1984
1985 case ECOND_STR_GEI:
1986 *yield = (strcmpic(sub[0], sub[1]) >= 0) == testfor;
1987 break;
1988
1989 case ECOND_MATCH: /* Regular expression match */
1990 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
1991 NULL);
1992 if (re == NULL)
1993 {
1994 expand_string_message = string_sprintf("regular expression error in "
1995 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
1996 return NULL;
1997 }
1998 *yield = regex_match_and_setup(re, sub[0], 0, -1) == testfor;
1999 break;
2000
2001 case ECOND_MATCH_ADDRESS: /* Match in an address list */
2002 rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
2003 goto MATCHED_SOMETHING;
2004
2005 case ECOND_MATCH_DOMAIN: /* Match in a domain list */
2006 rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
2007 MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
2008 goto MATCHED_SOMETHING;
2009
2010 case ECOND_MATCH_IP: /* Match IP address in a host list */
2011 if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
2012 {
2013 expand_string_message = string_sprintf("\"%s\" is not an IP address",
2014 sub[0]);
2015 return NULL;
2016 }
2017 else
2018 {
2019 unsigned int *nullcache = NULL;
2020 check_host_block cb;
2021
2022 cb.host_name = US"";
2023 cb.host_address = sub[0];
2024
2025 /* If the host address starts off ::ffff: it is an IPv6 address in
2026 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2027 addresses. */
2028
2029 cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2030 cb.host_address + 7 : cb.host_address;
2031
2032 rc = match_check_list(
2033 &sub[1], /* the list */
2034 0, /* separator character */
2035 &hostlist_anchor, /* anchor pointer */
2036 &nullcache, /* cache pointer */
2037 check_host, /* function for testing */
2038 &cb, /* argument for function */
2039 MCL_HOST, /* type of check */
2040 sub[0], /* text for debugging */
2041 NULL); /* where to pass back data */
2042 }
2043 goto MATCHED_SOMETHING;
2044
2045 case ECOND_MATCH_LOCAL_PART:
2046 rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
2047 MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
2048 /* Fall through */
2049 /* VVVVVVVVVVVV */
2050 MATCHED_SOMETHING:
2051 switch(rc)
2052 {
2053 case OK:
2054 *yield = testfor;
2055 break;
2056
2057 case FAIL:
2058 *yield = !testfor;
2059 break;
2060
2061 case DEFER:
2062 expand_string_message = string_sprintf("unable to complete match "
2063 "against \"%s\": %s", sub[1], search_error_message);
2064 return NULL;
2065 }
2066
2067 break;
2068
2069 /* Various "encrypted" comparisons. If the second string starts with
2070 "{" then an encryption type is given. Default to crypt() or crypt16()
2071 (build-time choice). */
2072
2073 case ECOND_CRYPTEQ:
2074 #ifndef SUPPORT_CRYPTEQ
2075 goto COND_FAILED_NOT_COMPILED;
2076 #else
2077 if (strncmpic(sub[1], US"{md5}", 5) == 0)
2078 {
2079 int sublen = Ustrlen(sub[1]+5);
2080 md5 base;
2081 uschar digest[16];
2082
2083 md5_start(&base);
2084 md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2085
2086 /* If the length that we are comparing against is 24, the MD5 digest
2087 is expressed as a base64 string. This is the way LDAP does it. However,
2088 some other software uses a straightforward hex representation. We assume
2089 this if the length is 32. Other lengths fail. */
2090
2091 if (sublen == 24)
2092 {
2093 uschar *coded = auth_b64encode((uschar *)digest, 16);
2094 DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2095 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2096 *yield = (Ustrcmp(coded, sub[1]+5) == 0) == testfor;
2097 }
2098 else if (sublen == 32)
2099 {
2100 int i;
2101 uschar coded[36];
2102 for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2103 coded[32] = 0;
2104 DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2105 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2106 *yield = (strcmpic(coded, sub[1]+5) == 0) == testfor;
2107 }
2108 else
2109 {
2110 DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2111 "fail\n crypted=%s\n", sub[1]+5);
2112 *yield = !testfor;
2113 }
2114 }
2115
2116 else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2117 {
2118 int sublen = Ustrlen(sub[1]+6);
2119 sha1 base;
2120 uschar digest[20];
2121
2122 sha1_start(&base);
2123 sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2124
2125 /* If the length that we are comparing against is 28, assume the SHA1
2126 digest is expressed as a base64 string. If the length is 40, assume a
2127 straightforward hex representation. Other lengths fail. */
2128
2129 if (sublen == 28)
2130 {
2131 uschar *coded = auth_b64encode((uschar *)digest, 20);
2132 DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2133 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2134 *yield = (Ustrcmp(coded, sub[1]+6) == 0) == testfor;
2135 }
2136 else if (sublen == 40)
2137 {
2138 int i;
2139 uschar coded[44];
2140 for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2141 coded[40] = 0;
2142 DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2143 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2144 *yield = (strcmpic(coded, sub[1]+6) == 0) == testfor;
2145 }
2146 else
2147 {
2148 DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2149 "fail\n crypted=%s\n", sub[1]+6);
2150 *yield = !testfor;
2151 }
2152 }
2153
2154 else /* {crypt} or {crypt16} and non-{ at start */
2155 {
2156 int which = 0;
2157 uschar *coded;
2158
2159 if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2160 {
2161 sub[1] += 7;
2162 which = 1;
2163 }
2164 else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2165 {
2166 sub[1] += 9;
2167 which = 2;
2168 }
2169 else if (sub[1][0] == '{')
2170 {
2171 expand_string_message = string_sprintf("unknown encryption mechanism "
2172 "in \"%s\"", sub[1]);
2173 return NULL;
2174 }
2175
2176 switch(which)
2177 {
2178 case 0: coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2179 case 1: coded = US crypt(CS sub[0], CS sub[1]); break;
2180 default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2181 }
2182
2183 #define STR(s) # s
2184 #define XSTR(s) STR(s)
2185 DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2186 " subject=%s\n crypted=%s\n",
2187 (which == 0)? XSTR(DEFAULT_CRYPT) : (which == 1)? "crypt" : "crypt16",
2188 coded, sub[1]);
2189 #undef STR
2190 #undef XSTR
2191
2192 /* If the encrypted string contains fewer than two characters (for the
2193 salt), force failure. Otherwise we get false positives: with an empty
2194 string the yield of crypt() is an empty string! */
2195
2196 *yield = (Ustrlen(sub[1]) < 2)? !testfor :
2197 (Ustrcmp(coded, sub[1]) == 0) == testfor;
2198 }
2199 break;
2200 #endif /* SUPPORT_CRYPTEQ */
2201 } /* Switch for comparison conditions */
2202
2203 return s; /* End of comparison conditions */
2204
2205
2206 /* and/or: computes logical and/or of several conditions */
2207
2208 case ECOND_AND:
2209 case ECOND_OR:
2210 subcondptr = (yield == NULL)? NULL : &tempcond;
2211 combined_cond = (cond_type == ECOND_AND);
2212
2213 while (isspace(*s)) s++;
2214 if (*s++ != '{') goto COND_FAILED_CURLY_START;
2215
2216 for (;;)
2217 {
2218 while (isspace(*s)) s++;
2219 if (*s == '}') break;
2220 if (*s != '{')
2221 {
2222 expand_string_message = string_sprintf("each subcondition "
2223 "inside an \"%s{...}\" condition must be in its own {}", name);
2224 return NULL;
2225 }
2226
2227 s = eval_condition(s+1, subcondptr);
2228 if (s == NULL)
2229 {
2230 expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2231 expand_string_message, name);
2232 return NULL;
2233 }
2234 while (isspace(*s)) s++;
2235
2236 if (*s++ != '}')
2237 {
2238 expand_string_message = string_sprintf("missing } at end of condition "
2239 "inside \"%s\" group", name);
2240 return NULL;
2241 }
2242
2243 if (yield != NULL)
2244 {
2245 if (cond_type == ECOND_AND)
2246 {
2247 combined_cond &= tempcond;
2248 if (!combined_cond) subcondptr = NULL; /* once false, don't */
2249 } /* evaluate any more */
2250 else
2251 {
2252 combined_cond |= tempcond;
2253 if (combined_cond) subcondptr = NULL; /* once true, don't */
2254 } /* evaluate any more */
2255 }
2256 }
2257
2258 if (yield != NULL) *yield = (combined_cond == testfor);
2259 return ++s;
2260
2261
2262 /* Unknown condition */
2263
2264 default:
2265 expand_string_message = string_sprintf("unknown condition \"%s\"", name);
2266 return NULL;
2267 } /* End switch on condition type */
2268
2269 /* Missing braces at start and end of data */
2270
2271 COND_FAILED_CURLY_START:
2272 expand_string_message = string_sprintf("missing { after \"%s\"", name);
2273 return NULL;
2274
2275 COND_FAILED_CURLY_END:
2276 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2277 name);
2278 return NULL;
2279
2280 /* A condition requires code that is not compiled */
2281
2282 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
2283 !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
2284 !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
2285 COND_FAILED_NOT_COMPILED:
2286 expand_string_message = string_sprintf("support for \"%s\" not compiled",
2287 name);
2288 return NULL;
2289 #endif
2290 }
2291
2292
2293
2294
2295 /*************************************************
2296 * Save numerical variables *
2297 *************************************************/
2298
2299 /* This function is called from items such as "if" that want to preserve and
2300 restore the numbered variables.
2301
2302 Arguments:
2303 save_expand_string points to an array of pointers to set
2304 save_expand_nlength points to an array of ints for the lengths
2305
2306 Returns: the value of expand max to save
2307 */
2308
2309 static int
2310 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2311 {
2312 int i;
2313 for (i = 0; i <= expand_nmax; i++)
2314 {
2315 save_expand_nstring[i] = expand_nstring[i];
2316 save_expand_nlength[i] = expand_nlength[i];
2317 }
2318 return expand_nmax;
2319 }
2320
2321
2322
2323 /*************************************************
2324 * Restore numerical variables *
2325 *************************************************/
2326
2327 /* This function restored saved values of numerical strings.
2328
2329 Arguments:
2330 save_expand_nmax the number of strings to restore
2331 save_expand_string points to an array of pointers
2332 save_expand_nlength points to an array of ints
2333
2334 Returns: nothing
2335 */
2336
2337 static void
2338 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2339 int *save_expand_nlength)
2340 {
2341 int i;
2342 expand_nmax = save_expand_nmax;
2343 for (i = 0; i <= expand_nmax; i++)
2344 {
2345 expand_nstring[i] = save_expand_nstring[i];
2346 expand_nlength[i] = save_expand_nlength[i];
2347 }
2348 }
2349
2350
2351
2352
2353
2354 /*************************************************
2355 * Handle yes/no substrings *
2356 *************************************************/
2357
2358 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
2359 alternative substrings that depend on whether or not the condition was true,
2360 or the lookup or extraction succeeded. The substrings always have to be
2361 expanded, to check their syntax, but "skipping" is set when the result is not
2362 needed - this avoids unnecessary nested lookups.
2363
2364 Arguments:
2365 skipping TRUE if we were skipping when this item was reached
2366 yes TRUE if the first string is to be used, else use the second
2367 save_lookup a value to put back into lookup_value before the 2nd expansion
2368 sptr points to the input string pointer
2369 yieldptr points to the output string pointer
2370 sizeptr points to the output string size
2371 ptrptr points to the output string pointer
2372 type "lookup" or "if" or "extract" or "run", for error message
2373
2374 Returns: 0 OK; lookup_value has been reset to save_lookup
2375 1 expansion failed
2376 2 expansion failed because of bracketing error
2377 */
2378
2379 static int
2380 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2381 uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type)
2382 {
2383 int rc = 0;
2384 uschar *s = *sptr; /* Local value */
2385 uschar *sub1, *sub2;
2386
2387 /* If there are no following strings, we substitute the contents of $value for
2388 lookups and for extractions in the success case. For the ${if item, the string
2389 "true" is substituted. In the fail case, nothing is substituted for all three
2390 items. */
2391
2392 while (isspace(*s)) s++;
2393 if (*s == '}')
2394 {
2395 if (type[0] == 'i')
2396 {
2397 if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
2398 }
2399 else
2400 {
2401 if (yes && lookup_value != NULL)
2402 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
2403 Ustrlen(lookup_value));
2404 lookup_value = save_lookup;
2405 }
2406 s++;
2407 goto RETURN;
2408 }
2409
2410 /* The first following string must be braced. */
2411
2412 if (*s++ != '{') goto FAILED_CURLY;
2413
2414 /* Expand the first substring. Forced failures are noticed only if we actually
2415 want this string. Set skipping in the call in the fail case (this will always
2416 be the case if we were already skipping). */
2417
2418 sub1 = expand_string_internal(s, TRUE, &s, !yes);
2419 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
2420 expand_string_forcedfail = FALSE;
2421 if (*s++ != '}') goto FAILED_CURLY;
2422
2423 /* If we want the first string, add it to the output */
2424
2425 if (yes)
2426 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
2427
2428 /* If this is called from a lookup or an extract, we want to restore $value to
2429 what it was at the start of the item, so that it has this value during the
2430 second string expansion. For the call from "if" or "run" to this function,
2431 save_lookup is set to lookup_value, so that this statement does nothing. */
2432
2433 lookup_value = save_lookup;
2434
2435 /* There now follows either another substring, or "fail", or nothing. This
2436 time, forced failures are noticed only if we want the second string. We must
2437 set skipping in the nested call if we don't want this string, or if we were
2438 already skipping. */
2439
2440 while (isspace(*s)) s++;
2441 if (*s == '{')
2442 {
2443 sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping);
2444 if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
2445 expand_string_forcedfail = FALSE;
2446 if (*s++ != '}') goto FAILED_CURLY;
2447
2448 /* If we want the second string, add it to the output */
2449
2450 if (!yes)
2451 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
2452 }
2453
2454 /* If there is no second string, but the word "fail" is present when the use of
2455 the second string is wanted, set a flag indicating it was a forced failure
2456 rather than a syntactic error. Swallow the terminating } in case this is nested
2457 inside another lookup or if or extract. */
2458
2459 else if (*s != '}')
2460 {
2461 uschar name[256];
2462 s = read_name(name, sizeof(name), s, US"_");
2463 if (Ustrcmp(name, "fail") == 0)
2464 {
2465 if (!yes && !skipping)
2466 {
2467 while (isspace(*s)) s++;
2468 if (*s++ != '}') goto FAILED_CURLY;
2469 expand_string_message =
2470 string_sprintf("\"%s\" failed and \"fail\" requested", type);
2471 expand_string_forcedfail = TRUE;
2472 goto FAILED;
2473 }
2474 }
2475 else
2476 {
2477 expand_string_message =
2478 string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
2479 goto FAILED;
2480 }
2481 }
2482
2483 /* All we have to do now is to check on the final closing brace. */
2484
2485 while (isspace(*s)) s++;
2486 if (*s++ == '}') goto RETURN;
2487
2488 /* Get here if there is a bracketing failure */
2489
2490 FAILED_CURLY:
2491 rc++;
2492
2493 /* Get here for other failures */
2494
2495 FAILED:
2496 rc++;
2497
2498 /* Update the input pointer value before returning */
2499
2500 RETURN:
2501 *sptr = s;
2502 return rc;
2503 }
2504
2505
2506
2507
2508 /*************************************************
2509 * Handle MD5 or SHA-1 computation for HMAC *
2510 *************************************************/
2511
2512 /* These are some wrapping functions that enable the HMAC code to be a bit
2513 cleaner. A good compiler will spot the tail recursion.
2514
2515 Arguments:
2516 type HMAC_MD5 or HMAC_SHA1
2517 remaining are as for the cryptographic hash functions
2518
2519 Returns: nothing
2520 */
2521
2522 static void
2523 chash_start(int type, void *base)
2524 {
2525 if (type == HMAC_MD5)
2526 md5_start((md5 *)base);
2527 else
2528 sha1_start((sha1 *)base);
2529 }
2530
2531 static void
2532 chash_mid(int type, void *base, uschar *string)
2533 {
2534 if (type == HMAC_MD5)
2535 md5_mid((md5 *)base, string);
2536 else
2537 sha1_mid((sha1 *)base, string);
2538 }
2539
2540 static void
2541 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
2542 {
2543 if (type == HMAC_MD5)
2544 md5_end((md5 *)base, string, length, digest);
2545 else
2546 sha1_end((sha1 *)base, string, length, digest);
2547 }
2548
2549
2550
2551
2552
2553 /********************************************************
2554 * prvs: Get last three digits of days since Jan 1, 1970 *
2555 ********************************************************/
2556
2557 /* This is needed to implement the "prvs" BATV reverse
2558 path signing scheme
2559
2560 Argument: integer "days" offset to add or substract to
2561 or from the current number of days.
2562
2563 Returns: pointer to string containing the last three
2564 digits of the number of days since Jan 1, 1970,
2565 modified by the offset argument, NULL if there
2566 was an error in the conversion.
2567
2568 */
2569
2570 static uschar *
2571 prvs_daystamp(int day_offset)
2572 {
2573 uschar *days = store_get(32); /* Need at least 24 for cases */
2574 (void)string_format(days, 32, TIME_T_FMT, /* where TIME_T_FMT is %lld */
2575 (time(NULL) + day_offset*86400)/86400);
2576 return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
2577 }
2578
2579
2580
2581 /********************************************************
2582 * prvs: perform HMAC-SHA1 computation of prvs bits *
2583 ********************************************************/
2584
2585 /* This is needed to implement the "prvs" BATV reverse
2586 path signing scheme
2587
2588 Arguments:
2589 address RFC2821 Address to use
2590 key The key to use (must be less than 64 characters
2591 in size)
2592 key_num Single-digit key number to use. Defaults to
2593 '0' when NULL.
2594
2595 Returns: pointer to string containing the first three
2596 bytes of the final hash in hex format, NULL if
2597 there was an error in the process.
2598 */
2599
2600 static uschar *
2601 prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
2602 {
2603 uschar *hash_source, *p;
2604 int size = 0,offset = 0,i;
2605 sha1 sha1_base;
2606 void *use_base = &sha1_base;
2607 uschar innerhash[20];
2608 uschar finalhash[20];
2609 uschar innerkey[64];
2610 uschar outerkey[64];
2611 uschar *finalhash_hex = store_get(40);
2612
2613 if (key_num == NULL)
2614 key_num = US"0";
2615
2616 if (Ustrlen(key) > 64)
2617 return NULL;
2618
2619 hash_source = string_cat(NULL,&size,&offset,key_num,1);
2620 string_cat(hash_source,&size,&offset,daystamp,3);
2621 string_cat(hash_source,&size,&offset,address,Ustrlen(address));
2622 hash_source[offset] = '\0';
2623
2624 DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
2625
2626 memset(innerkey, 0x36, 64);
2627 memset(outerkey, 0x5c, 64);
2628
2629 for (i = 0; i < Ustrlen(key); i++)
2630 {
2631 innerkey[i] ^= key[i];
2632 outerkey[i] ^= key[i];
2633 }
2634
2635 chash_start(HMAC_SHA1, use_base);
2636 chash_mid(HMAC_SHA1, use_base, innerkey);
2637 chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
2638
2639 chash_start(HMAC_SHA1, use_base);
2640 chash_mid(HMAC_SHA1, use_base, outerkey);
2641 chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
2642
2643 p = finalhash_hex;
2644 for (i = 0; i < 3; i++)
2645 {
2646 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
2647 *p++ = hex_digits[finalhash[i] & 0x0f];
2648 }
2649 *p = '\0';
2650
2651 return finalhash_hex;
2652 }
2653
2654
2655
2656
2657 /*************************************************
2658 * Join a file onto the output string *
2659 *************************************************/
2660
2661 /* This is used for readfile and after a run expansion. It joins the contents
2662 of a file onto the output string, globally replacing newlines with a given
2663 string (optionally). The file is closed at the end.
2664
2665 Arguments:
2666 f the FILE
2667 yield pointer to the expandable string
2668 sizep pointer to the current size
2669 ptrp pointer to the current position
2670 eol newline replacement string, or NULL
2671
2672 Returns: new value of string pointer
2673 */
2674
2675 static uschar *
2676 cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
2677 {
2678 int eollen;
2679 uschar buffer[1024];
2680
2681 eollen = (eol == NULL)? 0 : Ustrlen(eol);
2682
2683 while (Ufgets(buffer, sizeof(buffer), f) != NULL)
2684 {
2685 int len = Ustrlen(buffer);
2686 if (eol != NULL && buffer[len-1] == '\n') len--;
2687 yield = string_cat(yield, sizep, ptrp, buffer, len);
2688 if (buffer[len] != 0)
2689 yield = string_cat(yield, sizep, ptrp, eol, eollen);
2690 }
2691
2692 if (yield != NULL) yield[*ptrp] = 0;
2693
2694 return yield;
2695 }
2696
2697
2698
2699
2700 /*************************************************
2701 * Evaluate numeric expression *
2702 *************************************************/
2703
2704 /* This is a set of mutually recursive functions that evaluate a simple
2705 arithmetic expression involving only + - * / and parentheses. The only one that
2706 is called from elsewhere is eval_expr, whose interface is:
2707
2708 Arguments:
2709 sptr pointer to the pointer to the string - gets updated
2710 decimal TRUE if numbers are to be assumed decimal
2711 error pointer to where to put an error message - must be NULL on input
2712 endket TRUE if ')' must terminate - FALSE for external call
2713
2714
2715 Returns: on success: the value of the expression, with *error still NULL
2716 on failure: an undefined value, with *error = a message
2717 */
2718
2719 static int eval_sumterm(uschar **, BOOL, uschar **);
2720
2721 static int
2722 eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
2723 {
2724 uschar *s = *sptr;
2725 int x = eval_sumterm(&s, decimal, error);
2726 if (*error == NULL)
2727 {
2728 while (*s == '+' || *s == '-')
2729 {
2730 int op = *s++;
2731 int y = eval_sumterm(&s, decimal, error);
2732 if (*error != NULL) break;
2733 if (op == '+') x += y; else x -= y;
2734 }
2735 if (*error == NULL)
2736 {
2737 if (endket)
2738 {
2739 if (*s != ')')
2740 *error = US"expecting closing parenthesis";
2741 else
2742 while (isspace(*(++s)));
2743 }
2744 else if (*s != 0) *error = US"expecting + or -";
2745 }
2746 }
2747
2748 *sptr = s;
2749 return x;
2750 }
2751
2752 static int
2753 eval_term(uschar **sptr, BOOL decimal, uschar **error)
2754 {
2755 register int c;
2756 int n;
2757 uschar *s = *sptr;
2758 while (isspace(*s)) s++;
2759 c = *s;
2760 if (isdigit(c) || ((c == '-' || c == '+') && isdigit(s[1])))
2761 {
2762 int count;
2763 (void)sscanf(CS s, (decimal? "%d%n" : "%i%n"), &n, &count);
2764 s += count;
2765 if (tolower(*s) == 'k') { n *= 1024; s++; }
2766 else if (tolower(*s) == 'm') { n *= 1024*1024; s++; }
2767 while (isspace (*s)) s++;
2768 }
2769 else if (c == '(')
2770 {
2771 s++;
2772 n = eval_expr(&s, decimal, error, 1);
2773 }
2774 else
2775 {
2776 *error = US"expecting number or opening parenthesis";
2777 n = 0;
2778 }
2779 *sptr = s;
2780 return n;
2781 }
2782
2783 static int eval_sumterm(uschar **sptr, BOOL decimal, uschar **error)
2784 {
2785 uschar *s = *sptr;
2786 int x = eval_term(&s, decimal, error);
2787 if (*error == NULL)
2788 {
2789 while (*s == '*' || *s == '/' || *s == '%')
2790 {
2791 int op = *s++;
2792 int y = eval_term(&s, decimal, error);
2793 if (*error != NULL) break;
2794 if (op == '*') x *= y;
2795 else if (op == '/') x /= y;
2796 else x %= y;
2797 }
2798 }
2799 *sptr = s;
2800 return x;
2801 }
2802
2803
2804
2805
2806 /*************************************************
2807 * Expand string *
2808 *************************************************/
2809
2810 /* Returns either an unchanged string, or the expanded string in stacking pool
2811 store. Interpreted sequences are:
2812
2813 \... normal escaping rules
2814 $name substitutes the variable
2815 ${name} ditto
2816 ${op:string} operates on the expanded string value
2817 ${item{arg1}{arg2}...} expands the args and then does the business
2818 some literal args are not enclosed in {}
2819
2820 There are now far too many operators and item types to make it worth listing
2821 them here in detail any more.
2822
2823 We use an internal routine recursively to handle embedded substrings. The
2824 external function follows. The yield is NULL if the expansion failed, and there
2825 are two cases: if something collapsed syntactically, or if "fail" was given
2826 as the action on a lookup failure. These can be distinguised by looking at the
2827 variable expand_string_forcedfail, which is TRUE in the latter case.
2828
2829 The skipping flag is set true when expanding a substring that isn't actually
2830 going to be used (after "if" or "lookup") and it prevents lookups from
2831 happening lower down.
2832
2833 Store usage: At start, a store block of the length of the input plus 64
2834 is obtained. This is expanded as necessary by string_cat(), which might have to
2835 get a new block, or might be able to expand the original. At the end of the
2836 function we can release any store above that portion of the yield block that
2837 was actually used. In many cases this will be optimal.
2838
2839 However: if the first item in the expansion is a variable name or header name,
2840 we reset the store before processing it; if the result is in fresh store, we
2841 use that without copying. This is helpful for expanding strings like
2842 $message_headers which can get very long.
2843
2844 Arguments:
2845 string the string to be expanded
2846 ket_ends true if expansion is to stop at }
2847 left if not NULL, a pointer to the first character after the
2848 expansion is placed here (typically used with ket_ends)
2849 skipping TRUE for recursive calls when the value isn't actually going
2850 to be used (to allow for optimisation)
2851
2852 Returns: NULL if expansion fails:
2853 expand_string_forcedfail is set TRUE if failure was forced
2854 expand_string_message contains a textual error message
2855 a pointer to the expanded string on success
2856 */
2857
2858 static uschar *
2859 expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
2860 BOOL skipping)
2861 {
2862 int ptr = 0;
2863 int size = Ustrlen(string)+ 64;
2864 int item_type;
2865 uschar *yield = store_get(size);
2866 uschar *s = string;
2867 uschar *save_expand_nstring[EXPAND_MAXN+1];
2868 int save_expand_nlength[EXPAND_MAXN+1];
2869
2870 expand_string_forcedfail = FALSE;
2871 expand_string_message = US"";
2872
2873 while (*s != 0)
2874 {
2875 uschar *value;
2876 uschar name[256];
2877
2878 /* \ escapes the next character, which must exist, or else
2879 the expansion fails. There's a special escape, \N, which causes
2880 copying of the subject verbatim up to the next \N. Otherwise,
2881 the escapes are the standard set. */
2882
2883 if (*s == '\\')
2884 {
2885 if (s[1] == 0)
2886 {
2887 expand_string_message = US"\\ at end of string";
2888 goto EXPAND_FAILED;
2889 }
2890
2891 if (s[1] == 'N')
2892 {
2893 uschar *t = s + 2;
2894 for (s = t; *s != 0; s++) if (*s == '\\' && s[1] == 'N') break;
2895 yield = string_cat(yield, &size, &ptr, t, s - t);
2896 if (*s != 0) s += 2;
2897 }
2898
2899 else
2900 {
2901 uschar ch[1];
2902 ch[0] = string_interpret_escape(&s);
2903 s++;
2904 yield = string_cat(yield, &size, &ptr, ch, 1);
2905 }
2906
2907 continue;
2908 }
2909
2910 /* Anything other than $ is just copied verbatim, unless we are
2911 looking for a terminating } character. */
2912
2913 if (ket_ends && *s == '}') break;
2914
2915 if (*s != '$')
2916 {
2917 yield = string_cat(yield, &size, &ptr, s++, 1);
2918 continue;
2919 }
2920
2921 /* No { after the $ - must be a plain name or a number for string
2922 match variable. There has to be a fudge for variables that are the
2923 names of header fields preceded by "$header_" because header field
2924 names can contain any printing characters except space and colon.
2925 For those that don't like typing this much, "$h_" is a synonym for
2926 "$header_". A non-existent header yields a NULL value; nothing is
2927 inserted. */
2928
2929 if (isalpha((*(++s))))
2930 {
2931 int len;
2932 int newsize = 0;
2933
2934 s = read_name(name, sizeof(name), s, US"_");
2935
2936 /* If this is the first thing to be expanded, release the pre-allocated
2937 buffer. */
2938
2939 if (ptr == 0 && yield != NULL)
2940 {
2941 store_reset(yield);
2942 yield = NULL;
2943 size = 0;
2944 }
2945
2946 /* Header */
2947
2948 if (Ustrncmp(name, "h_", 2) == 0 ||
2949 Ustrncmp(name, "rh_", 3) == 0 ||
2950 Ustrncmp(name, "bh_", 3) == 0 ||
2951 Ustrncmp(name, "header_", 7) == 0 ||
2952 Ustrncmp(name, "rheader_", 8) == 0 ||
2953 Ustrncmp(name, "bheader_", 8) == 0)
2954 {
2955 BOOL want_raw = (name[0] == 'r')? TRUE : FALSE;
2956 uschar *charset = (name[0] == 'b')? NULL : headers_charset;
2957 s = read_header_name(name, sizeof(name), s);
2958 value = find_header(name, FALSE, &newsize, want_raw, charset);
2959
2960 /* If we didn't find the header, and the header contains a closing brace
2961 characters, this may be a user error where the terminating colon
2962 has been omitted. Set a flag to adjust the error message in this case.
2963 But there is no error here - nothing gets inserted. */
2964
2965 if (value == NULL)
2966 {
2967 if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2968 continue;
2969 }
2970 }
2971
2972 /* Variable */
2973
2974 else
2975 {
2976 value = find_variable(name, FALSE, skipping, &newsize);
2977 if (value == NULL)
2978 {
2979 expand_string_message =
2980 string_sprintf("unknown variable name \"%s\"", name);
2981 check_variable_error_message(name);
2982 goto EXPAND_FAILED;
2983 }
2984 }
2985
2986 /* If the data is known to be in a new buffer, newsize will be set to the
2987 size of that buffer. If this is the first thing in an expansion string,
2988 yield will be NULL; just point it at the new store instead of copying. Many
2989 expansion strings contain just one reference, so this is a useful
2990 optimization, especially for humungous headers. */
2991
2992 len = Ustrlen(value);
2993 if (yield == NULL && newsize != 0)
2994 {
2995 yield = value;
2996 size = newsize;
2997 ptr = len;
2998 }
2999 else yield = string_cat(yield, &size, &ptr, value, len);
3000
3001 continue;
3002 }
3003
3004 if (isdigit(*s))
3005 {
3006 int n;
3007 s = read_number(&n, s);
3008 if (n >= 0 && n <= expand_nmax)
3009 yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3010 expand_nlength[n]);
3011 continue;
3012 }
3013
3014 /* Otherwise, if there's no '{' after $ it's an error. */
3015
3016 if (*s != '{')
3017 {
3018 expand_string_message = US"$ not followed by letter, digit, or {";
3019 goto EXPAND_FAILED;
3020 }
3021
3022 /* After { there can be various things, but they all start with
3023 an initial word, except for a number for a string match variable. */
3024
3025 if (isdigit((*(++s))))
3026 {
3027 int n;
3028 s = read_number(&n, s);
3029 if (*s++ != '}')
3030 {
3031 expand_string_message = US"} expected after number";
3032 goto EXPAND_FAILED;
3033 }
3034 if (n >= 0 && n <= expand_nmax)
3035 yield = string_cat(yield, &size, &ptr, expand_nstring[n],
3036 expand_nlength[n]);
3037 continue;
3038 }
3039
3040 if (!isalpha(*s))
3041 {
3042 expand_string_message = US"letter or digit expected after ${";
3043 goto EXPAND_FAILED;
3044 }
3045
3046 /* Allow "-" in names to cater for substrings with negative
3047 arguments. Since we are checking for known names after { this is
3048 OK. */
3049
3050 s = read_name(name, sizeof(name), s, US"_-");
3051 item_type = chop_match(name, item_table, sizeof(item_table)/sizeof(uschar *));
3052
3053 switch(item_type)
3054 {
3055 /* Handle conditionals - preserve the values of the numerical expansion
3056 variables in case they get changed by a regular expression match in the
3057 condition. If not, they retain their external settings. At the end
3058 of this "if" section, they get restored to their previous values. */
3059
3060 case EITEM_IF:
3061 {
3062 BOOL cond = FALSE;
3063 uschar *next_s;
3064 int save_expand_nmax =
3065 save_expand_strings(save_expand_nstring, save_expand_nlength);
3066
3067 while (isspace(*s)) s++;
3068 next_s = eval_condition(s, skipping? NULL : &cond);
3069 if (next_s == NULL) goto EXPAND_FAILED; /* message already set */
3070
3071 DEBUG(D_expand)
3072 debug_printf("condition: %.*s\n result: %s\n", (int)(next_s - s), s,
3073 cond? "true" : "false");
3074
3075 s = next_s;
3076
3077 /* The handling of "yes" and "no" result strings is now in a separate
3078 function that is also used by ${lookup} and ${extract} and ${run}. */
3079
3080 switch(process_yesno(
3081 skipping, /* were previously skipping */
3082 cond, /* success/failure indicator */
3083 lookup_value, /* value to reset for string2 */
3084 &s, /* input pointer */
3085 &yield, /* output pointer */
3086 &size, /* output size */
3087 &ptr, /* output current point */
3088 US"if")) /* condition type */
3089 {
3090 case 1: goto EXPAND_FAILED; /* when all is well, the */
3091 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
3092 }
3093
3094 /* Restore external setting of expansion variables for continuation
3095 at this level. */
3096
3097 restore_expand_strings(save_expand_nmax, save_expand_nstring,
3098 save_expand_nlength);
3099 continue;
3100 }
3101
3102 /* Handle database lookups unless locked out. If "skipping" is TRUE, we are
3103 expanding an internal string that isn't actually going to be used. All we
3104 need to do is check the syntax, so don't do a lookup at all. Preserve the
3105 values of the numerical expansion variables in case they get changed by a
3106 partial lookup. If not, they retain their external settings. At the end
3107 of this "lookup" section, they get restored to their previous values. */
3108
3109 case EITEM_LOOKUP:
3110 {
3111 int stype, partial, affixlen, starflags;
3112 int expand_setup = 0;
3113 int nameptr = 0;
3114 uschar *key, *filename, *affix;
3115 uschar *save_lookup_value = lookup_value;
3116 int save_expand_nmax =
3117 save_expand_strings(save_expand_nstring, save_expand_nlength);
3118
3119 if ((expand_forbid & RDO_LOOKUP) != 0)
3120 {
3121 expand_string_message = US"lookup expansions are not permitted";
3122 goto EXPAND_FAILED;
3123 }
3124
3125 /* Get the key we are to look up for single-key+file style lookups.
3126 Otherwise set the key NULL pro-tem. */
3127
3128 while (isspace(*s)) s++;
3129 if (*s == '{')
3130 {
3131 key = expand_string_internal(s+1, TRUE, &s, skipping);
3132 if (key == NULL) goto EXPAND_FAILED;
3133 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3134 while (isspace(*s)) s++;
3135 }
3136 else key = NULL;
3137
3138 /* Find out the type of database */
3139
3140 if (!isalpha(*s))
3141 {
3142 expand_string_message = US"missing lookup type";
3143 goto EXPAND_FAILED;
3144 }
3145
3146 /* The type is a string that may contain special characters of various
3147 kinds. Allow everything except space or { to appear; the actual content
3148 is checked by search_findtype_partial. */
3149
3150 while (*s != 0 && *s != '{' && !isspace(*s))
3151 {
3152 if (nameptr < sizeof(name) - 1) name[nameptr++] = *s;
3153 s++;
3154 }
3155 name[nameptr] = 0;
3156 while (isspace(*s)) s++;
3157
3158 /* Now check for the individual search type and any partial or default
3159 options. Only those types that are actually in the binary are valid. */
3160
3161 stype = search_findtype_partial(name, &partial, &affix, &affixlen,
3162 &starflags);
3163 if (stype < 0)
3164 {
3165 expand_string_message = search_error_message;
3166 goto EXPAND_FAILED;
3167 }
3168
3169 /* Check that a key was provided for those lookup types that need it,
3170 and was not supplied for those that use the query style. */
3171
3172 if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
3173 {
3174 if (key == NULL)
3175 {
3176 expand_string_message = string_sprintf("missing {key} for single-"
3177 "key \"%s\" lookup", name);
3178 goto EXPAND_FAILED;
3179 }
3180 }
3181 else
3182 {
3183 if (key != NULL)
3184 {
3185 expand_string_message = string_sprintf("a single key was given for "
3186 "lookup type \"%s\", which is not a single-key lookup type", name);
3187 goto EXPAND_FAILED;
3188 }
3189 }
3190
3191 /* Get the next string in brackets and expand it. It is the file name for
3192 single-key+file lookups, and the whole query otherwise. In the case of
3193 queries that also require a file name (e.g. sqlite), the file name comes
3194 first. */
3195
3196 if (*s != '{') goto EXPAND_FAILED_CURLY;
3197 filename = expand_string_internal(s+1, TRUE, &s, skipping);
3198 if (filename == NULL) goto EXPAND_FAILED;
3199 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3200 while (isspace(*s)) s++;
3201
3202 /* If this isn't a single-key+file lookup, re-arrange the variables
3203 to be appropriate for the search_ functions. For query-style lookups,
3204 there is just a "key", and no file name. For the special query-style +
3205 file types, the query (i.e. "key") starts with a file name. */
3206
3207 if (key == NULL)
3208 {
3209 while (isspace(*filename)) filename++;
3210 key = filename;
3211
3212 if (mac_islookup(stype, lookup_querystyle))
3213 {
3214 filename = NULL;
3215 }
3216 else
3217 {
3218 if (*filename != '/')
3219 {
3220 expand_string_message = string_sprintf(
3221 "absolute file name expected for \"%s\" lookup", name);
3222 goto EXPAND_FAILED;
3223 }
3224 while (*key != 0 && !isspace(*key)) key++;
3225 if (*key != 0) *key++ = 0;
3226 }
3227 }
3228
3229 /* If skipping, don't do the next bit - just lookup_value == NULL, as if
3230 the entry was not found. Note that there is no search_close() function.
3231 Files are left open in case of re-use. At suitable places in higher logic,
3232 search_tidyup() is called to tidy all open files. This can save opening
3233 the same file several times. However, files may also get closed when
3234 others are opened, if too many are open at once. The rule is that a
3235 handle should not be used after a second search_open().
3236
3237 Request that a partial search sets up $1 and maybe $2 by passing
3238 expand_setup containing zero. If its value changes, reset expand_nmax,
3239 since new variables will have been set. Note that at the end of this
3240 "lookup" section, the old numeric variables are restored. */
3241
3242 if (skipping)
3243 lookup_value = NULL;
3244 else
3245 {
3246 void *handle = search_open(filename, stype, 0, NULL, NULL);
3247 if (handle == NULL)
3248 {
3249 expand_string_message = search_error_message;
3250 goto EXPAND_FAILED;
3251 }
3252 lookup_value = search_find(handle, filename, key, partial, affix,
3253 affixlen, starflags, &expand_setup);
3254 if (search_find_defer)
3255 {
3256 expand_string_message =
3257 string_sprintf("lookup of \"%s\" gave DEFER: %s", key,
3258 search_error_message);
3259 goto EXPAND_FAILED;
3260 }
3261 if (expand_setup > 0) expand_nmax = expand_setup;
3262 }
3263
3264 /* The handling of "yes" and "no" result strings is now in a separate
3265 function that is also used by ${if} and ${extract}. */
3266
3267 switch(process_yesno(
3268 skipping, /* were previously skipping */
3269 lookup_value != NULL, /* success/failure indicator */
3270 save_lookup_value, /* value to reset for string2 */
3271 &s, /* input pointer */
3272 &yield, /* output pointer */
3273 &size, /* output size */
3274 &ptr, /* output current point */
3275 US"lookup")) /* condition type */
3276 {
3277 case 1: goto EXPAND_FAILED; /* when all is well, the */
3278 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
3279 }
3280
3281 /* Restore external setting of expansion variables for carrying on
3282 at this level, and continue. */
3283
3284 restore_expand_strings(save_expand_nmax, save_expand_nstring,
3285 save_expand_nlength);
3286 continue;
3287 }
3288
3289 /* If Perl support is configured, handle calling embedded perl subroutines,
3290 unless locked out at this time. Syntax is ${perl{sub}} or ${perl{sub}{arg}}
3291 or ${perl{sub}{arg1}{arg2}} or up to a maximum of EXIM_PERL_MAX_ARGS
3292 arguments (defined below). */
3293
3294 #define EXIM_PERL_MAX_ARGS 8
3295
3296 case EITEM_PERL:
3297 #ifndef EXIM_PERL
3298 expand_string_message = US"\"${perl\" encountered, but this facility "
3299 "is not included in this binary";
3300 goto EXPAND_FAILED;
3301
3302 #else /* EXIM_PERL */
3303 {
3304 uschar *sub_arg[EXIM_PERL_MAX_ARGS + 2];
3305 uschar *new_yield;
3306
3307 if ((expand_forbid & RDO_PERL) != 0)
3308 {
3309 expand_string_message = US"Perl calls are not permitted";
3310 goto EXPAND_FAILED;
3311 }
3312
3313 switch(read_subs(sub_arg, EXIM_PERL_MAX_ARGS + 1, 1, &s, skipping, TRUE,
3314 US"perl"))
3315 {
3316 case 1: goto EXPAND_FAILED_CURLY;
3317 case 2:
3318 case 3: goto EXPAND_FAILED;
3319 }
3320
3321 /* If skipping, we don't actually do anything */
3322
3323 if (skipping) continue;
3324
3325 /* Start the interpreter if necessary */
3326
3327 if (!opt_perl_started)
3328 {
3329 uschar *initerror;
3330 if (opt_perl_startup == NULL)
3331 {
3332 expand_string_message = US"A setting of perl_startup is needed when "
3333 "using the Perl interpreter";
3334 goto EXPAND_FAILED;
3335 }
3336 DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
3337 initerror = init_perl(opt_perl_startup);
3338 if (initerror != NULL)
3339 {
3340 expand_string_message =
3341 string_sprintf("error in perl_startup code: %s\n", initerror);
3342 goto EXPAND_FAILED;
3343 }
3344 opt_perl_started = TRUE;
3345 }
3346
3347 /* Call the function */
3348
3349 sub_arg[EXIM_PERL_MAX_ARGS + 1] = NULL;
3350 new_yield = call_perl_cat(yield, &size, &ptr, &expand_string_message,
3351 sub_arg[0], sub_arg + 1);
3352
3353 /* NULL yield indicates failure; if the message pointer has been set to
3354 NULL, the yield was undef, indicating a forced failure. Otherwise the
3355 message will indicate some kind of Perl error. */
3356
3357 if (new_yield == NULL)
3358 {
3359 if (expand_string_message == NULL)
3360 {
3361 expand_string_message =
3362 string_sprintf("Perl subroutine \"%s\" returned undef to force "
3363 "failure", sub_arg[0]);
3364 expand_string_forcedfail = TRUE;
3365 }
3366 goto EXPAND_FAILED;
3367 }
3368
3369 /* Yield succeeded. Ensure forcedfail is unset, just in case it got
3370 set during a callback from Perl. */
3371
3372 expand_string_forcedfail = FALSE;
3373 yield = new_yield;
3374 continue;
3375 }
3376 #endif /* EXIM_PERL */
3377