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