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