projects / exim.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix typo in usage: seond -> second
[exim.git] / src / src / expand.c
CommitLineData
46218253 1/* $Cambridge: exim/src/src/expand.c,v 1.57 2006/03/08 11:13:07 ph10 Exp $ */
059ec3d9
PH		 2
3/*************************************************
4* Exim - an Internet mail transport agent *
5*************************************************/
6
d7d7b7b9 7/* Copyright (c) University of Cambridge 1995 - 2006 */
059ec3d9
PH		 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
27extern 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
39static 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
48alphabetical order. */
49
50static uschar *item_table[] = {
1a46a8c5 51 US"dlfunc",
059ec3d9
PH		 52 US"extract",
53 US"hash",
54 US"hmac",
55 US"if",
56 US"length",
57 US"lookup",
58 US"nhash",
1a46a8c5 59 US"perl",
fffda43a
TK		 60 US"prvs",
61 US"prvscheck",
059ec3d9
PH		 62 US"readfile",
63 US"readsocket",
64 US"run",
65 US"sg",
66 US"substr",
67 US"tr" };
68
69enum {
1a46a8c5 70 EITEM_DLFUNC,
059ec3d9
PH		 71 EITEM_EXTRACT,
72 EITEM_HASH,
73 EITEM_HMAC,
74 EITEM_IF,
75 EITEM_LENGTH,
76 EITEM_LOOKUP,
77 EITEM_NHASH,
1a46a8c5 78 EITEM_PERL,
fffda43a
TK		 79 EITEM_PRVS,
80 EITEM_PRVSCHECK,
059ec3d9
PH		 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
89in alphabetical order. There are two tables, because underscore is used in some
90cases to introduce arguments, whereas for other it is part of the name. This is
91an historical mis-design. */
92
93static uschar *op_table_underscore[] = {
94 US"from_utf8",
95 US"local_part",
96 US"quote_local_part",
f90d018c 97 US"time_eval",
059ec3d9
PH		 98 US"time_interval"};
99
100enum {
101 EOP_FROM_UTF8,
102 EOP_LOCAL_PART,
103 EOP_QUOTE_LOCAL_PART,
f90d018c 104 EOP_TIME_EVAL,
059ec3d9
PH		 105 EOP_TIME_INTERVAL };
106
107static 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
137enum {
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
169be in alphabetical order. */
170
171static 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",
32d668a5 200 US"match_ip",
059ec3d9
PH		 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
210enum {
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,
32d668a5 239 ECOND_MATCH_IP,
059ec3d9
PH		 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
252typedef 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
259in use. */
260
261typedef struct {
262 uschar **address;
263 int *length;
264} alblock;
265
266/* Types of table entry */
267
268enum {
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 */
5cb8cbc6
PH		 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 */
8e669ac1 294 vtype_pinodes /* partition inodes; value is T/F for spool/log */
fb2274d4
TK		 295#ifdef EXPERIMENTAL_DOMAINKEYS
296 ,vtype_dk_verify /* Serve request out of DomainKeys verification structure */
84330b7b 297#endif
059ec3d9
PH		 298 };
299
300/* This table must be kept in alphabetical order. */
301
302static var_entry var_table[] = {
059ec3d9
PH		 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 },
8523533c
TK		 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
059ec3d9
PH		 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 },
e5a9dba6 324 { "csa_status", vtype_stringptr, &csa_status },
8523533c
TK		 325#ifdef WITH_OLD_DEMIME
326 { "demime_errorlevel", vtype_int, &demime_errorlevel },
327 { "demime_reason", vtype_stringptr, &demime_reason },
fb2274d4
TK		 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 },
8523533c 341#endif
059ec3d9
PH		 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 },
8523533c
TK		 350#ifdef WITH_OLD_DEMIME
351 { "found_extension", vtype_stringptr, &found_extension },
8e669ac1 352#endif
059ec3d9
PH		 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 },
b08b24c8 357 { "host_lookup_deferred",vtype_int, &host_lookup_deferred },
059ec3d9
PH		 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 },
5cb8cbc6 374 { "log_inodes", vtype_pinodes, (void *)FALSE },
8e669ac1 375 { "log_space", vtype_pspace, (void *)FALSE },
059ec3d9 376 { "mailstore_basename", vtype_stringptr, &mailstore_basename },
8523533c
TK		 377#ifdef WITH_CONTENT_SCAN
378 { "malware_name", vtype_stringptr, &malware_name },
379#endif
059ec3d9
PH		 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 },
1ab52c69 384 { "message_exim_id", vtype_stringptr, &message_id },
059ec3d9
PH		 385 { "message_headers", vtype_msgheaders, NULL },
386 { "message_id", vtype_stringptr, &message_id },
2e0c1448 387 { "message_linecount", vtype_int, &message_linecount },
059ec3d9 388 { "message_size", vtype_int, &message_size },
8523533c
TK		 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
059ec3d9
PH		 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 },
fffda43a
TK		 425 { "prvscheck_address", vtype_stringptr, &prvscheck_address },
426 { "prvscheck_keynum", vtype_stringptr, &prvscheck_keynum },
427 { "prvscheck_result", vtype_stringptr, &prvscheck_result },
059ec3d9
PH		 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 },
7dbf77c9 436 { "received_time", vtype_int, &received_time },
059ec3d9 437 { "recipient_data", vtype_stringptr, &recipient_data },
8e669ac1 438 { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
059ec3d9
PH		 439 { "recipients", vtype_recipients, NULL },
440 { "recipients_count", vtype_int, &recipients_count },
8523533c
TK		 441#ifdef WITH_CONTENT_SCAN
442 { "regex_match_string", vtype_stringptr, &regex_match_string },
443#endif
059ec3d9
PH		 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 },
2a3eea10 450 { "sender_address_data", vtype_stringptr, &sender_address_data },
059ec3d9
PH		 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 },
870f6ba8
TF		 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 },
059ec3d9 464 { "sender_rcvhost", vtype_stringptr, &sender_rcvhost },
8e669ac1
PH		 465 { "sender_verify_failure",vtype_stringptr, &sender_verify_failure },
466 { "smtp_active_hostname", vtype_stringptr, &smtp_active_hostname },
3ee512ff
PH		 467 { "smtp_command", vtype_stringptr, &smtp_cmd_buffer },
468 { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
059ec3d9
PH		 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] },
8523533c
TK		 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
059ec3d9 491 { "spool_directory", vtype_stringptr, &spool_directory },
5cb8cbc6 492 { "spool_inodes", vtype_pinodes, (void *)TRUE },
8e669ac1 493 { "spool_space", vtype_pspace, (void *)TRUE },
8523533c
TK		 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
059ec3d9
PH		 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
523static int var_table_size = sizeof(var_table)/sizeof(var_entry);
524static uschar var_buffer[256];
525static BOOL malformed_header;
526
527/* For textual hashes */
528
529static char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
530 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
531 "0123456789";
532
533enum { HMAC_MD5, HMAC_SHA1 };
534
535/* For numeric hashes */
536
537static 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
544static uschar *mtable_normal[] =
545 { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
546
547static uschar *mtable_setid[] =
548 { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
549
550static 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
560masked with 0x3f. The highest number for a valid UTF-8 character is in fact
5610x3d. */
562
563static 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,
570indexed by the number of additional bytes. */
571
572static 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
597Arguments:
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
602Returns: the offset in the table, or -1
603*/
604
605static int
606chop_match(uschar *name, uschar **table, int table_size)
607{
608uschar **bot = table;
609uschar **top = table + table_size;
610
611while (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
619return -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"
629or "false" value. Failure of the expansion yields FALSE; logged unless it was a
630forced fail or lookup defer. All store used by the function can be released on
631exit.
632
633Arguments:
634 condition the condition string
635 m1 text to be incorporated in panic error
636 m2 ditto
637
638Returns: TRUE if condition is met, FALSE if not
639*/
640
641BOOL
642expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
643{
644int rc;
645void *reset_point = store_get(0);
646uschar *ss = expand_string(condition);
647if (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 }
654rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
655 strcmpic(ss, US"false") != 0;
656store_reset(reset_point);
657return 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
668Arguments:
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
674Returns: pointer to the first character after the name
675
676Note: The test for *s != 0 in the while loop is necessary because
677Ustrchr() yields non-NULL if the character is zero (which is not something
678I expected). */
679
680static uschar *
681read_name(uschar *name, int max, uschar *s, uschar *extras)
682{
683int ptr = 0;
684while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
685 {
686 if (ptr < max-1) name[ptr++] = *s;
687 s++;
688 }
689name[ptr] = 0;
690return 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
700abbreviations) might not be the complete header name because headers can
701contain any printing characters in their names, except ':'. This function is
702called to read the rest of the name, chop h[eader]_ off the front, and put ':'
703on the end, if the name was terminated by white space.
704
705Arguments:
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
711Returns: a pointer to the first character after the header name
712*/
713
714static uschar *
715read_header_name(uschar *name, int max, uschar *s)
716{
717int prelen = Ustrchr(name, '_') - name + 1;
718int ptr = Ustrlen(name) - prelen;
719if (ptr > 0) memmove(name, name+prelen, ptr);
720while (mac_isgraph(*s) && *s != ':')
721 {
722 if (ptr < max-1) name[ptr++] = *s;
723 s++;
724 }
725if (*s == ':') s++;
726name[ptr++] = ':';
727name[ptr] = 0;
728return 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
741Returns: a pointer to the character after the last digit
742*/
743
744static uschar *
745read_number(int *n, uschar *s)
746{
747*n = 0;
748while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
749return 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
760Arguments:
761 key points to the name of the key
762 s points to the string from which to extract the subfield
763
764Returns: NULL if the subfield was not found, or
765 a pointer to the subfield's data
766*/
767
768static uschar *
769expand_getkeyed(uschar *key, uschar *s)
770{
771int length = Ustrlen(key);
772while (isspace(*s)) s++;
773
774/* Loop to search for the key */
775
776while (*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
794return 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
805example a line from /etc/passwd is divided by colon characters. First field is
806numbered one. Negative arguments count from the right. Zero returns the whole
807string. Returns NULL if there are insufficient tokens in the string
808
809***WARNING***
810Modifies final argument - this is a dynamically generated string, so that's OK.
811
812Arguments:
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
818Returns: NULL if the field was not found,
819 a pointer to the field's data inside s (modified to add 0)
820*/
821
822static uschar *
823expand_gettokened (int field, uschar *separators, uschar *s)
824{
825int sep = 1;
826int count;
827uschar *ss = s;
828uschar *fieldtext = NULL;
829
830if (field == 0) return s;
831
832/* Break the line up into fields in place; for field > 0 we stop when we have
833done the number of fields we want. For field < 0 we continue till the end of
834the string, counting the number of fields. */
835
836count = (field > 0)? field : INT_MAX;
837
838while (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
869return fieldtext;
870}
871
872
873
874/*************************************************
875* Extract a substring from a string *
876*************************************************/
877
878/* Perform the ${substr or ${length expansion operations.
879
880Arguments:
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
889Returns: pointer to the output string, or NULL if there is an error
890*/
891
892static uschar *
893extract_substr(uschar *subject, int value1, int value2, int *len)
894{
895int sublen = Ustrlen(subject);
896
897if (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
923string, 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
926else
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
937the required characters. */
938
939if (value1 + value2 > sublen) value2 = sublen - value1;
940*len = value2;
941return subject + value1;
942}
943
944
945
946
947/*************************************************
948* Old-style hash of a string *
949*************************************************/
950
951/* Perform the ${hash expansion operation.
952
953Arguments:
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
960Returns: pointer to the output string, or NULL if there is an error
961*/
962
963static uschar *
964compute_hash(uschar *subject, int value1, int value2, int *len)
965{
966int sublen = Ustrlen(subject);
967
968if (value2 < 0) value2 = 26;
969else 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
977can safely place it in subject[] (we know that subject is always itself an
978expanded substring). */
979
980if (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 }
994else value1 = sublen;
995
996*len = value1;
997return 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
1008string are treated as most important, and get the highest prime numbers.
1009
1010Arguments:
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
1017Returns: pointer to the output string, or NULL if there is an error.
1018*/
1019
1020static uschar *
1021compute_nhash (uschar *subject, int value1, int value2, int *len)
1022{
1023uschar *s = subject;
1024int i = 0;
1025unsigned long int total = 0; /* no overflow */
1026
1027while (*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
1035if (value2 < 0)
1036 {
1037 s = string_sprintf("%d", total % value1);
1038 }
1039
1040/* Otherwise do a div/mod hash */
1041
1042else
1043 {
1044 total = total % (value1 * value2);
1045 s = string_sprintf("%d/%d", total/value2, total % value2);
1046 }
1047
1048*len = Ustrlen(s);
1049return 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
1061can also return a concatenation of all the header lines. When concatenating
1062specific headers that contain lists of addresses, a comma is inserted between
1063them. Otherwise we use a straight concatenation. Because some messages can have
1064pathologically large number of lines, there is a limit on the length that is
1065returned. Also, to avoid massive store use which would result from using
1066string_cat() as it copies and extends strings, we do a preliminary pass to find
1067out exactly how much store will be needed. On "normal" messages this will be
1068pretty trivial.
1069
1070Arguments:
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
1084Returns: NULL if the header does not exist, else a pointer to a new
1085 store block
1086*/
1087
1088static uschar *
1089find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1090 uschar *charset)
1091{
1092BOOL found = name == NULL;
1093int comma = 0;
1094int len = found? 0 : Ustrlen(name);
1095int i;
1096uschar *yield = NULL;
1097uschar *ptr = NULL;
1098
1099/* Loop for two passes - saves code repetition */
1100
1101for (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
1171if (comma != 0 && ptr > yield) ptr -= 2;
1172
1173/* That's all we do for raw header expansion. */
1174
1175if (want_raw)
1176 {
1177 *ptr = 0;
1178 }
1179
1180/* Otherwise, we remove trailing whitespace, including newlines. Then we do RFC
11812047 decoding, translating the charset if requested. The rfc2047_decode2()
1182function can return an error with decoded data if the charset translation
1183fails. If decoding fails, it returns NULL. */
1184
1185else
1186 {
1187 uschar *decoded, *error;
1188 while (ptr > yield && isspace(ptr[-1])) ptr--;
1189 *ptr = 0;
a0d6ba8a
PH		 1190 decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1191 newsize, &error);
059ec3d9
PH		 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
1200return 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
1211using a binary chop. The "choplen" variable is nothing to do with the binary
1212chop.
1213
1214Arguments:
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
1223Returns: 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
1228static uschar *
1229find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1230{
1231int first = 0;
1232int last = var_table_size;
1233
47ca6d6c 1234/* Handle ACL variables, which are not in the table because their number may
53b8f9ce
PH		 1235vary depending on a build-time setting. If the variable's name is not of the
1236form acl_mddd or acl_cddd, where the d's are digits, fall through to look for
1237other names that start with acl_. */
47ca6d6c
PH		 1238
1239if (Ustrncmp(name, "acl_", 4) == 0)
1240 {
47ca6d6c 1241 uschar *endptr;
53b8f9ce
PH		 1242 int offset = -1;
1243 int max = 0;
47ca6d6c
PH		 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 }
47ca6d6c 1255
53b8f9ce
PH		 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 }
47ca6d6c
PH		 1262 }
1263
f78eb7c6
PH		 1264/* Similarly for $auth<n> variables. */
1265
1266if (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
47ca6d6c
PH		 1274/* For all other variables, search the table */
1275
059ec3d9
PH		 1276while (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,
47ca6d6c 1287 and we want to avoid processing (such as looking up the host name). */
059ec3d9
PH		 1288
1289 if (skipping) return US"";
1290
1291 switch (var_table[middle].type)
1292 {
fb2274d4
TK		 1293#ifdef EXPERIMENTAL_DOMAINKEYS
1294
1295 case vtype_dk_verify:
cacfbf29 1296 if (dk_verify_block == NULL) return US"";
fb2274d4
TK		 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;
84330b7b 1306
fb2274d4
TK		 1307 if (Ustrcmp(var_table[middle].name, "dk_sender_source") == 0)
1308 switch(dk_verify_block->address_source) {
a8d97c8a
PH		 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;
fb2274d4
TK		 1312 }
1313
1314 if (Ustrcmp(var_table[middle].name, "dk_status") == 0)
1315 switch(dk_verify_block->result) {
a8d97c8a
PH		 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;
fb2274d4 1324 }
84330b7b 1325
fb2274d4 1326 if (Ustrcmp(var_table[middle].name, "dk_signsall") == 0)
a8d97c8a 1327 s = (dk_verify_block->signsall)? US"1" : US"0";
84330b7b 1328
fb2274d4 1329 if (Ustrcmp(var_table[middle].name, "dk_testing") == 0)
a8d97c8a 1330 s = (dk_verify_block->testing)? US"1" : US"0";
84330b7b 1331
fb2274d4 1332 if (Ustrcmp(var_table[middle].name, "dk_is_signed") == 0)
a8d97c8a 1333 s = (dk_verify_block->is_signed)? US"1" : US"0";
84330b7b 1334
fb2274d4
TK		 1335 return (s == NULL)? US"" : s;
1336#endif
1337
9a26b6b2
PH		 1338 case vtype_filter_int:
1339 if (!filter_running) return NULL;
1340 /* Fall through */
1341 /* VVVVVVVVVVVV */
059ec3d9
PH		 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;
0d7eb84a 1403 off_t start_offset = SPOOL_DATA_START_OFFSET;
059ec3d9
PH		 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 */
c8ea1597 1453 s = find_header(US"reply-to:", exists_only, newsize, TRUE,
059ec3d9 1454 headers_charset);
6979240a 1455 if (s != NULL) while (isspace(*s)) s++;
059ec3d9 1456 if (s == NULL || *s == 0)
41a13e0a
PH		 1457 {
1458 *newsize = 0; /* For the *s==0 case */
c8ea1597
PH		 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 = ' ';
6979240a
PH		 1466 while (t > s && isspace(t[-1])) t--;
1467 *t = 0;
41a13e0a 1468 }
059ec3d9
PH		 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;
8e669ac1 1491
5cb8cbc6
PH		 1492 case vtype_pspace:
1493 {
1494 int inodes;
8e669ac1
PH		 1495 sprintf(CS var_buffer, "%d",
1496 receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes));
5cb8cbc6
PH		 1497 }
1498 return var_buffer;
8e669ac1 1499
5cb8cbc6
PH		 1500 case vtype_pinodes:
1501 {
1502 int inodes;
8e669ac1 1503 (void) receive_statvfs(var_table[middle].value == (void *)TRUE, &inodes);
5cb8cbc6
PH		 1504 sprintf(CS var_buffer, "%d", inodes);
1505 }
1506 return var_buffer;
059ec3d9
PH		 1507 }
1508 }
1509
1510return 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
1521expansion items. Some have a minimum requirement that is less than the maximum;
1522in these cases, the first non-present one is set to NULL.
1523
1524Arguments:
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
1533Returns: 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
1539static int
1540read_subs(uschar **sub, int n, int m, uschar **sptr, BOOL skipping,
1541 BOOL check_end, uschar *name)
1542{
1543int i;
1544uschar *s = *sptr;
1545
1546while (isspace(*s)) s++;
1547for (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 }
1560if (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;
1572return 0;
1573}
1574
1575
1576
1577
1578/*************************************************
1579* Read and evaluate a condition *
1580*************************************************/
1581
1582/*
1583Arguments:
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
1590Returns: a pointer to the first character after the condition, or
1591 NULL after an error
1592*/
1593
1594static uschar *
1595eval_condition(uschar *s, BOOL *yield)
1596{
1597BOOL testfor = TRUE;
1598BOOL tempcond, combined_cond;
1599BOOL *subcondptr;
1600int i, rc, cond_type, roffset;
1601int num[2];
1602struct stat statbuf;
1603uschar name[256];
1604uschar *sub[4];
1605
1606const pcre *re;
1607const uschar *rerror;
1608
1609for (;;)
1610 {
1611 while (isspace(*s)) s++;
1612 if (*s == '!') { testfor = !testfor; s++; } else break;
1613 }
1614
1615/* Numeric comparisons are symbolic */
1616
1617if (*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
1631else 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
1635if (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
1644cond_type = chop_match(name, cond_table, sizeof(cond_table)/sizeof(uschar *));
1645switch(cond_type)
1646 {
9b4768fa
PH		 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. */
059ec3d9
PH		 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
9b4768fa
PH		 1673 /* Test for a variable's having a non-empty value. A non-existent variable
1674 causes an expansion failure. */
059ec3d9
PH		 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 }
9b4768fa 1686 if (yield != NULL) *yield = (value[0] != 0) == testfor;
059ec3d9
PH		 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);
7e66e54d 1749 *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
059ec3d9
PH		 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
32d668a5 1845 match_ip: matches a host list that is restricted to IP addresses
059ec3d9
PH		 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:
32d668a5 1854 case ECOND_MATCH_IP:
059ec3d9
PH		 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
32d668a5 2008 case ECOND_MATCH_IP: /* Match IP address in a host list */
7e66e54d 2009 if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
32d668a5
PH		 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
059ec3d9
PH		 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 */
9a26b6b2 2047 /* VVVVVVVVVVVV */
059ec3d9
PH		 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
2269COND_FAILED_CURLY_START:
2270expand_string_message = string_sprintf("missing { after \"%s\"", name);
2271return NULL;
2272
2273COND_FAILED_CURLY_END:
2274expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
2275 name);
2276return 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)
2283COND_FAILED_NOT_COMPILED:
2284expand_string_message = string_sprintf("support for \"%s\" not compiled",
2285 name);
2286return 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
2298restore the numbered variables.
2299
2300Arguments:
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
2304Returns: the value of expand max to save
2305*/
2306
2307static int
2308save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
2309{
2310int i;
2311for (i = 0; i <= expand_nmax; i++)
2312 {
2313 save_expand_nstring[i] = expand_nstring[i];
2314 save_expand_nlength[i] = expand_nlength[i];
2315 }
2316return expand_nmax;
2317}
2318
2319
2320
2321/*************************************************
2322* Restore numerical variables *
2323*************************************************/
2324
2325/* This function restored saved values of numerical strings.
2326
2327Arguments:
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
2332Returns: nothing
2333*/
2334
2335static void
2336restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
2337 int *save_expand_nlength)
2338{
2339int i;
2340expand_nmax = save_expand_nmax;
2341for (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
2357alternative substrings that depend on whether or not the condition was true,
2358or the lookup or extraction succeeded. The substrings always have to be
2359expanded, to check their syntax, but "skipping" is set when the result is not
2360needed - this avoids unnecessary nested lookups.
2361
2362Arguments:
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
2372Returns: 0 OK; lookup_value has been reset to save_lookup
2373 1 expansion failed
2374 2 expansion failed because of bracketing error
2375*/
2376
2377static int
2378process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, uschar **sptr,
2379 uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type)
2380{
2381int rc = 0;
2382uschar *s = *sptr; /* Local value */
2383uschar *sub1, *sub2;
2384
2385/* If there are no following strings, we substitute the contents of $value for
063b1e99 2386lookups and for extractions in the success case. For the ${if item, the string
8e669ac1 2387"true" is substituted. In the fail case, nothing is substituted for all three
063b1e99 2388items. */
059ec3d9
PH		 2389
2390while (isspace(*s)) s++;
2391if (*s == '}')
2392 {
063b1e99
PH		 2393 if (type[0] == 'i')
2394 {
8e669ac1 2395 if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
063b1e99
PH		 2396 }
2397 else
8e669ac1 2398 {
063b1e99
PH		 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 }
059ec3d9
PH		 2404 s++;
2405 goto RETURN;
2406 }
2407
9b4768fa
PH		 2408/* The first following string must be braced. */
2409
2410if (*s++ != '{') goto FAILED_CURLY;
2411
059ec3d9
PH		 2412/* Expand the first substring. Forced failures are noticed only if we actually
2413want this string. Set skipping in the call in the fail case (this will always
2414be the case if we were already skipping). */
2415
9b4768fa 2416sub1 = expand_string_internal(s, TRUE, &s, !yes);
059ec3d9
PH		 2417if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
2418expand_string_forcedfail = FALSE;
2419if (*s++ != '}') goto FAILED_CURLY;
2420
2421/* If we want the first string, add it to the output */
2422
2423if (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
2427what it was at the start of the item, so that it has this value during the
d20976dc
PH		 2428second string expansion. For the call from "if" or "run" to this function,
2429save_lookup is set to lookup_value, so that this statement does nothing. */
059ec3d9
PH		 2430
2431lookup_value = save_lookup;
2432
2433/* There now follows either another substring, or "fail", or nothing. This
2434time, forced failures are noticed only if we want the second string. We must
2435set skipping in the nested call if we don't want this string, or if we were
2436already skipping. */
2437
2438while (isspace(*s)) s++;
2439if (*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
2453the second string is wanted, set a flag indicating it was a forced failure
2454rather than a syntactic error. Swallow the terminating } in case this is nested
2455inside another lookup or if or extract. */
2456
2457else 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
2483while (isspace(*s)) s++;
2484if (*s++ == '}') goto RETURN;
2485
2486/* Get here if there is a bracketing failure */
2487
2488FAILED_CURLY:
2489rc++;
2490
2491/* Get here for other failures */
2492
2493FAILED:
2494rc++;
2495
2496/* Update the input pointer value before returning */
2497
2498RETURN:
2499*sptr = s;
2500return rc;
2501}
2502
2503
2504
2505
059ec3d9
PH		 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
2511cleaner. A good compiler will spot the tail recursion.
2512
2513Arguments:
2514 type HMAC_MD5 or HMAC_SHA1
2515 remaining are as for the cryptographic hash functions
2516
2517Returns: nothing
2518*/
2519
2520static void
2521chash_start(int type, void *base)
2522{
2523if (type == HMAC_MD5)
2524 md5_start((md5 *)base);
2525else
2526 sha1_start((sha1 *)base);
2527}
2528
2529static void
2530chash_mid(int type, void *base, uschar *string)
2531{
2532if (type == HMAC_MD5)
2533 md5_mid((md5 *)base, string);
2534else
2535 sha1_mid((sha1 *)base, string);
2536}
2537
2538static void
2539chash_end(int type, void *base, uschar *string, int length, uschar *digest)
2540{
2541if (type == HMAC_MD5)
2542 md5_end((md5 *)base, string, length, digest);
2543else
2544 sha1_end((sha1 *)base, string, length, digest);
2545}
2546
2547
2548
2549
2550
1549ea3b
PH		 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
2558Argument: integer "days" offset to add or substract to
2559 or from the current number of days.
2560
2561Returns: 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
2568static uschar *
2569prvs_daystamp(int day_offset)
2570{
a86229cf
PH		 2571uschar *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 */
1549ea3b 2573 (time(NULL) + day_offset*86400)/86400);
e169f567 2574return (Ustrlen(days) >= 3) ? &days[Ustrlen(days)-3] : US"100";
1549ea3b
PH		 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
2586Arguments:
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
2593Returns: 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
2598static uschar *
2599prvs_hmac_sha1(uschar *address, uschar *key, uschar *key_num, uschar *daystamp)
2600{
2601uschar *hash_source, *p;
2602int size = 0,offset = 0,i;
2603sha1 sha1_base;
2604void *use_base = &sha1_base;
2605uschar innerhash[20];
2606uschar finalhash[20];
2607uschar innerkey[64];
2608uschar outerkey[64];
2609uschar *finalhash_hex = store_get(40);
2610
2611if (key_num == NULL)
2612 key_num = US"0";
2613
2614if (Ustrlen(key) > 64)
2615 return NULL;
2616
2617hash_source = string_cat(NULL,&size,&offset,key_num,1);
2618string_cat(hash_source,&size,&offset,daystamp,3);
2619string_cat(hash_source,&size,&offset,address,Ustrlen(address));
2620hash_source[offset] = '\0';
2621
2622DEBUG(D_expand) debug_printf("prvs: hash source is '%s'\n", hash_source);
2623
2624memset(innerkey, 0x36, 64);
2625memset(outerkey, 0x5c, 64);
2626
2627for (i = 0; i < Ustrlen(key); i++)
2628 {
2629 innerkey[i] ^= key[i];
2630 outerkey[i] ^= key[i];
2631 }
2632
2633chash_start(HMAC_SHA1, use_base);
2634chash_mid(HMAC_SHA1, use_base, innerkey);
2635chash_end(HMAC_SHA1, use_base, hash_source, offset, innerhash);
2636
2637chash_start(HMAC_SHA1, use_base);
2638chash_mid(HMAC_SHA1, use_base, outerkey);
2639chash_end(HMAC_SHA1, use_base, innerhash, 20, finalhash);
2640
2641p = finalhash_hex;
2642for (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
2649return finalhash_hex;
2650}
2651
2652
2653
2654
059ec3d9
PH		 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
2660of a file onto the output string, globally replacing newlines with a given
2661string (optionally). The file is closed at the end.
2662
2663Arguments:
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
2670Returns: new value of string pointer
2671*/
2672
2673static uschar *
2674cat_file(FILE *f, uschar *yield, int *sizep, int *ptrp, uschar *eol)
2675{
2676int eollen;
2677uschar buffer[1024];
2678
2679eollen = (eol == NULL)? 0 : Ustrlen(eol);
2680
2681while (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
2690if (yield != NULL) yield[*ptrp] = 0;
2691
2692return 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
2703arithmetic expression involving only + - * / and parentheses. The only one that
2704is called from elsewhere is eval_expr, whose interface is:
2705
2706Arguments:
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
2713Returns: on success: the value of the expression, with *error still NULL
2714 on failure: an undefined value, with *error = a message
2715*/
2716
2717static int eval_sumterm(uschar **, BOOL, uschar **);
2718
2719static int
2720eval_expr(uschar **sptr, BOOL decimal, uschar **error, BOOL endket)
2721{
2722uschar *s = *sptr;
2723int x = eval_sumterm(&s, decimal, error);
2724if (*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;
2747return x;
2748}
2749
2750static int
2751eval_term(uschar **sptr, BOOL decimal, uschar **error)
2752{
2753register int c;
2754int n;
2755uschar *s = *sptr;
2756while (isspace(*s)) s++;
2757c = *s;
2758if (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 }
2767else if (c == '(')
2768 {
2769 s++;
2770 n = eval_expr(&s, decimal, error, 1);
2771 }
2772else
2773 {
2774 *error = US"expecting number or opening parenthesis";
2775 n = 0;
2776 }
2777*sptr = s;
2778return n;
2779}
2780
2781static int eval_sumterm(uschar **sptr, BOOL decimal, uschar **error)
2782{
2783uschar *s = *sptr;
2784int x = eval_term(&s, decimal, error);
2785if (*error == NULL)
2786 {
5591031b 2787 while (*s == '*' || *s == '/' || *s == '%')
059ec3d9
PH		 2788 {
2789 int op = *s++;
2790 int y = eval_term(&s, decimal, error);
2791 if (*error != NULL) break;
5591031b
PH		 2792 if (op == '*') x *= y;
2793 else if (op == '/') x /= y;
2794 else x %= y;
059ec3d9
PH		 2795 }
2796 }
2797*sptr = s;
2798return 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
2809store. 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
2818There are now far too many operators and item types to make it worth listing
2819them here in detail any more.
2820
2821We use an internal routine recursively to handle embedded substrings. The
2822external function follows. The yield is NULL if the expansion failed, and there
2823are two cases: if something collapsed syntactically, or if "fail" was given
2824as the action on a lookup failure. These can be distinguised by looking at the
2825variable expand_string_forcedfail, which is TRUE in the latter case.
2826
2827The skipping flag is set true when expanding a substring that isn't actually
2828going to be used (after "if" or "lookup") and it prevents lookups from
2829happening lower down.
2830
2831Store usage: At start, a store block of the length of the input plus 64
2832is obtained. This is expanded as necessary by string_cat(), which might have to
2833get a new block, or might be able to expand the original. At the end of the
2834function we can release any store above that portion of the yield block that
2835was actually used. In many cases this will be optimal.
2836
2837However: if the first item in the expansion is a variable name or header name,
2838we reset the store before processing it; if the result is in fresh store, we
2839use that without copying. This is helpful for expanding strings like
2840$message_headers which can get very long.
2841
2842Arguments:
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
2850Returns: 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
2856static uschar *
2857expand_string_internal(uschar *string, BOOL ket_ends, uschar **left,
2858 BOOL skipping)
2859{
2860int ptr = 0;
2861int size = Ustrlen(string)+ 64;
2862int item_type;
2863uschar *yield = store_get(size);
2864uschar *s = string;
2865uschar *save_expand_nstring[EXPAND_MAXN+1];
2866int save_expand_nlength[EXPAND_MAXN+1];
2867
2868expand_string_forcedfail = FALSE;
2869expand_string_message = US"";
2870
2871while (*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
13b685f9 3169 if (!mac_islookup(stype, lookup_querystyle|lookup_absfilequery))
059ec3d9
PH		 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
13b685f9
PH		 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. */
059ec3d9
PH		 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
13b685f9
PH		 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. */
059ec3d9
PH		 3203
3204 if (key == NULL)
3205 {
13b685f9 3206 while (isspace(*filename)) filename++;
059ec3d9 3207 key = filename;
13b685f9
PH		 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 }
059ec3d9
PH		 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
059ec3d9
PH		 3291 #define EXIM_PERL_MAX_ARGS 8
3292
3293 case EITEM_PERL:
1a46a8c5
PH		 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 */
059ec3d9
PH		 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
fffda43a
TK		 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 {
cb9328de
PH		 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";
fffda43a
TK		 3408 goto EXPAND_FAILED;
3409 }
3410
fffda43a
TK		 3411 p = prvs_hmac_sha1(sub_arg[0],sub_arg[1],sub_arg[2],prvs_daystamp(7));
3412 if (p == NULL)
3413 {
cb9328de 3414 expand_string_message = US"prvs hmac-sha1 conversion failed";
fffda43a
TK		 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;
72fdd6ae
PH		 3441
3442 /* TF: Ugliness: We want to expand parameter 1 first, then set
fffda43a
TK		 3443 up expansion variables that are used in the expansion of
3444 parameter 2. So we clone the string for the first
72fdd6ae
PH		 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 */
fffda43a
TK		 3451
3452 /* Reset expansion variables */
3453 prvscheck_result = NULL;
3454 prvscheck_address = NULL;
3455 prvscheck_keynum = NULL;
3456
72fdd6ae 3457 switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs"))
fffda43a
TK		 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
72fdd6ae
PH		 3467 if (regex_match_and_setup(re,sub_arg[0],0,-1))
3468 {
fffda43a
TK		 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));
2740a2ca 3483 string_cat(prvscheck_address,&mysize,&myptr,US"@",1);
fffda43a
TK		 3484 string_cat(prvscheck_address,&mysize,&myptr,domain,Ustrlen(domain));
3485 prvscheck_address[myptr] = '\0';
3486 prvscheck_keynum = string_copy(key_num);
3487
72fdd6ae
PH		 3488 /* Now expand the second argument */
3489 switch(read_subs(sub_arg, 1, 1, &s, skipping, FALSE, US"prvs"))
fffda43a
TK		 3490 {
3491 case 1: goto EXPAND_FAILED_CURLY;
3492 case 2:
3493 case 3: goto EXPAND_FAILED;
3494 }
3495
fffda43a 3496 /* Now we have the key and can check the address. */
72fdd6ae
PH		 3497
3498 p = prvs_hmac_sha1(prvscheck_address, sub_arg[0], prvscheck_keynum,
3499 daystamp);
3500
fffda43a
TK		 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);
72fdd6ae 3509
fffda43a
TK		 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
ff790e47
PH		 3516 (void)sscanf(CS now,"%u",&inow);
3517 (void)sscanf(CS daystamp,"%u",&iexpire);
fffda43a
TK		 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 }
72fdd6ae
PH		 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 }
fffda43a
TK		 3561 else
3562 {
3563 /* Does not look like a prvs encoded address, return the empty string.
72fdd6ae
PH		 3564 We need to make sure all subs are expanded first, so as to skip over
3565 the entire item. */
3566
5a03bd24 3567 switch(read_subs(sub_arg, 2, 1, &s, skipping, TRUE, US"prvs"))
fffda43a
TK		 3568 {
3569 case 1: goto EXPAND_FAILED_CURLY;
3570 case 2:
3571 case 3: goto EXPAND_FAILED;
3572 }
3573 }
3574
3575 continue;
3576 }
3577
059ec3d9
PH		 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]);
f1e894f3 3612 (void)fclose(f);
059ec3d9
PH		 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);
f1e894f3 3705 (void)fclose(f);
059ec3d9
PH		 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;
059ec3d9
PH		 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
f1e894f3 3802 (void)close(fd_in);
059ec3d9
PH		 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");
059ec3d9
PH		 3831 lookup_value = NULL;
3832 lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
f1e894f3 3833 (void)fclose(f);
059ec3d9
PH		 3834 }
3835
d20976dc 3836 /* Process the yes/no strings; $value may be useful in both cases */
059ec3d9
PH		 3837
3838 switch(process_yesno(
3839 skipping, /* were previously skipping */
3840 runrc == 0, /* success/failure indicator */
d20976dc 3841 lookup_value, /* value to reset for string2 */
059ec3d9
PH		 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. */
3915
3916 if (sub[2] == NULL)
3917 {
3918 sub[2] = sub[1];
3919 sub[1] = NULL;
3920 if (item_type == EITEM_LENGTH)
3921 {
3922 sub[1] = sub[0];
3923 sub[0] = NULL;
3924 }
3925 }
3926
3927 for (i = 0; i < 2; i++)
3928 {
3929 if (sub[i] == NULL) continue;
3930 val[i] = (int)Ustrtol(sub[i], &ret, 10);
3931 if (*ret != 0 || (i != 0 && val[i] < 0))
3932 {
3933 expand_string_message = string_sprintf("\"%s\" is not a%s number "
3934 "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
3935 goto EXPAND_FAILED;
3936 }
3937 }
3938
3939 ret =
3940 (item_type == EITEM_HASH)?
3941 compute_hash(sub[2], val[0], val[1], &len) :
3942 (item_type == EITEM_NHASH)?
3943 compute_nhash(sub[2], val[0], val[1], &len) :
3944 extract_substr(sub[2], val[0], val[1], &len);
3945
3946 if (ret == NULL) goto EXPAND_FAILED;
3947 yield = string_cat(yield, &size, &ptr, ret, len);
3948 continue;
3949 }
3950
3951 /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
3952 This code originally contributed by Steve Haslam. It currently supports
3953 the use of MD5 and SHA-1 hashes.
3954
3955 We need some workspace that is large enough to handle all the supported
3956 hash types. Use macros to set the sizes rather than be too elaborate. */
3957
3958 #define MAX_HASHLEN 20
3959 #define MAX_HASHBLOCKLEN 64
3960
3961 case EITEM_HMAC:
3962 {
3963 uschar *sub[3];
3964 md5 md5_base;
3965 sha1 sha1_base;
3966 void *use_base;
3967 int type, i;
3968 int hashlen; /* Number of octets for the hash algorithm's output */
3969 int hashblocklen; /* Number of octets the hash algorithm processes */
3970 uschar *keyptr, *p;
3971 unsigned int keylen;
3972
3973 uschar keyhash[MAX_HASHLEN];
3974 uschar innerhash[MAX_HASHLEN];
3975 uschar finalhash[MAX_HASHLEN];
3976 uschar finalhash_hex[2*MAX_HASHLEN];
3977 uschar innerkey[MAX_HASHBLOCKLEN];
3978 uschar outerkey[MAX_HASHBLOCKLEN];
3979
3980 switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name))
3981 {
3982 case 1: goto EXPAND_FAILED_CURLY;
3983 case 2:
3984 case 3: goto EXPAND_FAILED;
3985 }
3986
3987 if (Ustrcmp(sub[0], "md5") == 0)
3988 {
3989 type = HMAC_MD5;
3990 use_base = &md5_base;
3991 hashlen = 16;
3992 hashblocklen = 64;
3993 }
3994 else if (Ustrcmp(sub[0], "sha1") == 0)
3995 {
3996 type = HMAC_SHA1;
3997 use_base = &sha1_base;
3998 hashlen = 20;
3999 hashblocklen = 64;
4000 }
4001 else
4002 {
4003 expand_string_message =
4004 string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
4005 goto EXPAND_FAILED;
4006 }
4007
4008 keyptr = sub[1];
4009 keylen = Ustrlen(keyptr);
4010
4011 /* If the key is longer than the hash block length, then hash the key
4012 first */
4013
4014 if (keylen > hashblocklen)
4015 {
4016 chash_start(type, use_base);
4017 chash_end(type, use_base, keyptr, keylen, keyhash);
4018 keyptr = keyhash;
4019 keylen = hashlen;
4020 }
4021
4022 /* Now make the inner and outer key values */
4023
4024 memset(innerkey, 0x36, hashblocklen);
4025 memset(outerkey, 0x5c, hashblocklen);
4026
4027 for (i = 0; i < keylen; i++)
4028 {
4029 innerkey[i] ^= keyptr[i];
4030 outerkey[i] ^= keyptr[i];
4031 }
4032
4033 /* Now do the hashes */
4034
4035 chash_start(type, use_base);
4036 chash_mid(type, use_base, innerkey);
4037 chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
4038
4039 chash_start(type, use_base);
4040 chash_mid(type, use_base, outerkey);
4041 chash_end(type, use_base, innerhash, hashlen, finalhash);
4042
4043 /* Encode the final hash as a hex string */
4044
4045 p = finalhash_hex;
4046 for (i = 0; i < hashlen; i++)
4047 {
4048 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
4049 *p++ = hex_digits[finalhash[i] & 0x0f];
4050 }
4051
4052 DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
4053 (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
4054
4055 yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
4056 }
4057
4058 continue;
4059
4060 /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
4061 We have to save the numerical variables and restore them afterwards. */
4062
4063 case EITEM_SG:
4064 {
4065 const pcre *re;
4066 int moffset, moffsetextra, slen;
4067 int roffset;
4068 int emptyopt;
4069 const uschar *rerror;
4070 uschar *subject;
4071 uschar *sub[3];
4072 int save_expand_nmax =
4073 save_expand_strings(save_expand_nstring, save_expand_nlength);
4074
4075 switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg"))
4076 {
4077 case 1: goto EXPAND_FAILED_CURLY;
4078 case 2:
4079 case 3: goto EXPAND_FAILED;
4080 }
4081
4082 /* Compile the regular expression */
4083
4084 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
4085 NULL);
4086
4087 if (re == NULL)
4088 {
4089 expand_string_message = string_sprintf("regular expression error in "
4090 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
4091 goto EXPAND_FAILED;
4092 }
4093
4094 /* Now run a loop to do the substitutions as often as necessary. It ends
4095 when there are no more matches. Take care over matches of the null string;
4096 do the same thing as Perl does. */
4097
4098 subject = sub[0];
4099 slen = Ustrlen(sub[0]);
4100 moffset = moffsetextra = 0;
4101 emptyopt = 0;
4102
4103 for (;;)
4104 {
4105 int ovector[3*(EXPAND_MAXN+1)];
4106 int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
4107 PCRE_EOPT | emptyopt, ovector, sizeof(ovector)/sizeof(int));
4108 int nn;
4109 uschar *insert;
4110
4111 /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
4112 is not necessarily the end. We want to repeat the match from one
4113 character further along, but leaving the basic offset the same (for
4114 copying below). We can't be at the end of the string - that was checked
4115 before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
4116 finished; copy the remaining string and end the loop. */
4117
4118 if (n < 0)
4119 {
4120 if (emptyopt != 0)
4121 {
4122 moffsetextra = 1;
4123 emptyopt = 0;
4124 continue;
4125 }
4126 yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
4127 break;
4128 }
4129
4130 /* Match - set up for expanding the replacement. */
4131
4132 if (n == 0) n = EXPAND_MAXN + 1;
4133 expand_nmax = 0;
4134 for (nn = 0; nn < n*2; nn += 2)
4135 {
4136 expand_nstring[expand_nmax] = subject + ovector[nn];
4137 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
4138 }
4139 expand_nmax--;
4140
4141 /* Copy the characters before the match, plus the expanded insertion. */
4142
4143 yield = string_cat(yield, &size, &ptr, subject + moffset,
4144 ovector[0] - moffset);
4145 insert = expand_string(sub[2]);
4146 if (insert == NULL) goto EXPAND_FAILED;
4147 yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
4148
4149 moffset = ovector[1];
4150 moffsetextra = 0;
4151 emptyopt = 0;
4152
4153 /* If we have matched an empty string, first check to see if we are at
4154 the end of the subject. If so, the loop is over. Otherwise, mimic
4155 what Perl's /g options does. This turns out to be rather cunning. First
4156 we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
4157 string at the same point. If this fails (picked up above) we advance to
4158 the next character. */
4159
4160 if (ovector[0] == ovector[1])
4161 {
4162 if (ovector[0] == slen) break;
4163 emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
4164 }
4165 }
4166
4167 /* All done - restore numerical variables. */
4168
4169 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4170 save_expand_nlength);
4171 continue;
4172 }
4173
4174 /* Handle keyed and numbered substring extraction. If the first argument
4175 consists entirely of digits, then a numerical extraction is assumed. */
4176
4177 case EITEM_EXTRACT:
4178 {
4179 int i;
4180 int j = 2;
4181 int field_number = 1;
4182 BOOL field_number_set = FALSE;
4183 uschar *save_lookup_value = lookup_value;
4184 uschar *sub[3];
4185 int save_expand_nmax =
4186 save_expand_strings(save_expand_nstring, save_expand_nlength);
4187
4188 /* Read the arguments */
4189
4190 for (i = 0; i < j; i++)
4191 {
4192 while (isspace(*s)) s++;
4193 if (*s == '{')
4194 {
4195 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
4196 if (sub[i] == NULL) goto EXPAND_FAILED;
4197 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4198
4199 /* After removal of leading and trailing white space, the first
4200 argument must not be empty; if it consists entirely of digits
4201 (optionally preceded by a minus sign), this is a numerical
4202 extraction, and we expect 3 arguments. */
4203
4204 if (i == 0)
4205 {
4206 int len;
4207 int x = 0;
4208 uschar *p = sub[0];
4209
4210 while (isspace(*p)) p++;
4211 sub[0] = p;
4212
4213 len = Ustrlen(p);
4214 while (len > 0 && isspace(p[len-1])) len--;
4215 p[len] = 0;
4216
4217 if (*p == 0)
4218 {
554d2369
TF		 4219 expand_string_message = US"first argument of \"extract\" must "
4220 "not be empty";
059ec3d9
PH		 4221 goto EXPAND_FAILED;
4222 }
4223
4224 if (*p == '-')
4225 {
4226 field_number = -1;
4227 p++;
4228 }
4229 while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
4230 if (*p == 0)
4231 {
4232 field_number *= x;
4233 j = 3; /* Need 3 args */
4234 field_number_set = TRUE;
4235 }
4236 }
4237 }
4238 else goto EXPAND_FAILED_CURLY;
4239 }
4240
4241 /* Extract either the numbered or the keyed substring into $value. If
4242 skipping, just pretend the extraction failed. */
4243
4244 lookup_value = skipping? NULL : field_number_set?
4245 expand_gettokened(field_number, sub[1], sub[2]) :
4246 expand_getkeyed(sub[0], sub[1]);
4247
4248 /* If no string follows, $value gets substituted; otherwise there can
4249 be yes/no strings, as for lookup or if. */
4250
4251 switch(process_yesno(
4252 skipping, /* were previously skipping */
4253 lookup_value != NULL, /* success/failure indicator */
4254 save_lookup_value, /* value to reset for string2 */
4255 &s, /* input pointer */
4256 &yield, /* output pointer */
4257 &size, /* output size */
4258 &ptr, /* output current point */
4259 US"extract")) /* condition type */
4260 {
4261 case 1: goto EXPAND_FAILED; /* when all is well, the */
4262 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
4263 }
4264
4265 /* All done - restore numerical variables. */
4266
4267 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4268 save_expand_nlength);
4269
4270 continue;
4271 }
1a46a8c5
PH		 4272
4273
4274 /* If ${dlfunc support is configured, handle calling dynamically-loaded
4275 functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
4276 or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
4277 a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
4278
4279 #define EXPAND_DLFUNC_MAX_ARGS 8
4280
4281 case EITEM_DLFUNC:
4282 #ifndef EXPAND_DLFUNC
4283 expand_string_message = US"\"${dlfunc\" encountered, but this facility "
4284 "is not included in this binary";
4285 goto EXPAND_FAILED;
4286
4287 #else /* EXPAND_DLFUNC */
4288 {
4289 tree_node *t;
4290 exim_dlfunc_t *func;
4291 uschar *result;
4292 int status, argc;
4293 uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
4294
4295 if ((expand_forbid & RDO_DLFUNC) != 0)
4296 {
4297 expand_string_message =
4298 US"dynamically-loaded functions are not permitted";
4299 goto EXPAND_FAILED;
4300 }
4301
4302 switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
4303 TRUE, US"dlfunc"))
4304 {
4305 case 1: goto EXPAND_FAILED_CURLY;
4306 case 2:
4307 case 3: goto EXPAND_FAILED;
4308 }
4309
4310 /* If skipping, we don't actually do anything */
4311
4312 if (skipping) continue;
4313
4314 /* Look up the dynamically loaded object handle in the tree. If it isn't
4315 found, dlopen() the file and put the handle in the tree for next time. */
4316
4317 t = tree_search(dlobj_anchor, argv[0]);
4318 if (t == NULL)
4319 {
4320 void *handle = dlopen(CS argv[0], RTLD_LAZY);
4321 if (handle == NULL)
4322 {
4323 expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
4324 argv[0], dlerror());
4325 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
4326 goto EXPAND_FAILED;
4327 }
4328 t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
4329 Ustrcpy(t->name, argv[0]);
4330 t->data.ptr = handle;
4331 (void)tree_insertnode(&dlobj_anchor, t);
4332 }
4333
4334 /* Having obtained the dynamically loaded object handle, look up the
4335 function pointer. */
4336
4337 func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
4338 if (func == NULL)
4339 {
4340 expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
4341 "%s", argv[1], argv[0], dlerror());
7dbf77c9 4342 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
1a46a8c5
PH		 4343 goto EXPAND_FAILED;
4344 }
4345
4346 /* Call the function and work out what to do with the result. If it
4347 returns OK, we have a replacement string; if it returns DEFER then
4348 expansion has failed in a non-forced manner; if it returns FAIL then
4349 failure was forced; if it returns ERROR or any other value there's a
4350 problem, so panic slightly. */
4351
4352 result = NULL;
4353 for (argc = 0; argv[argc] != NULL; argc++);
4354 status = func(&result, argc - 2, &argv[2]);
4355 if(status == OK)
4356 {
4357 if (result == NULL) result = US"";
4358 yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
4359 continue;
4360 }
4361 else
4362 {
4363 expand_string_message = result == NULL ? US"(no message)" : result;
4364 if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
4365 else if(status != FAIL)
4366 log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
4367 argv[0], argv[1], status, expand_string_message);
4368 goto EXPAND_FAILED;
4369 }
4370 }
4371 #endif /* EXPAND_DLFUNC */
059ec3d9
PH		 4372 }
4373
4374 /* Control reaches here if the name is not recognized as one of the more
4375 complicated expansion items. Check for the "operator" syntax (name terminated
4376 by a colon). Some of the operators have arguments, separated by _ from the
4377 name. */
4378
4379 if (*s == ':')
4380 {
4381 int c;
4382 uschar *arg = NULL;
4383 uschar *sub = expand_string_internal(s+1, TRUE, &s, skipping);
4384 if (sub == NULL) goto EXPAND_FAILED;
4385 s++;
4386
4387 /* Owing to an historical mis-design, an underscore may be part of the
4388 operator name, or it may introduce arguments. We therefore first scan the
4389 table of names that contain underscores. If there is no match, we cut off
4390 the arguments and then scan the main table. */
4391
4392 c = chop_match(name, op_table_underscore,
4393 sizeof(op_table_underscore)/sizeof(uschar *));
4394
4395 if (c < 0)
4396 {
4397 arg = Ustrchr(name, '_');
4398 if (arg != NULL) *arg = 0;
4399 c = chop_match(name, op_table_main,
4400 sizeof(op_table_main)/sizeof(uschar *));
4401 if (c >= 0) c += sizeof(op_table_underscore)/sizeof(uschar *);
4402 if (arg != NULL) *arg++ = '_'; /* Put back for error messages */
4403 }
4404
4405 /* If we are skipping, we don't need to perform the operation at all.
4406 This matters for operations like "mask", because the data may not be
4407 in the correct format when skipping. For example, the expression may test
4408 for the existence of $sender_host_address before trying to mask it. For
4409 other operations, doing them may not fail, but it is a waste of time. */
4410
4411 if (skipping && c >= 0) continue;
4412
4413 /* Otherwise, switch on the operator type */
4414
4415 switch(c)
4416 {
4417 case EOP_BASE62:
4418 {
4419 uschar *t;
4420 unsigned long int n = Ustrtoul(sub, &t, 10);
4421 if (*t != 0)
4422 {
4423 expand_string_message = string_sprintf("argument for base62 "
4424 "operator is \"%s\", which is not a decimal number", sub);
4425 goto EXPAND_FAILED;
4426 }
4427 t = string_base62(n);
4428 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4429 continue;
4430 }
4431
9a799bc0
PH		 4432 /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
4433
059ec3d9
PH		 4434 case EOP_BASE62D:
4435 {
4436 uschar buf[16];
4437 uschar *tt = sub;
4438 unsigned long int n = 0;
4439 while (*tt != 0)
4440 {
4441 uschar *t = Ustrchr(base62_chars, *tt++);
4442 if (t == NULL)
4443 {
4444 expand_string_message = string_sprintf("argument for base62d "
9a799bc0
PH		 4445 "operator is \"%s\", which is not a base %d number", sub,
4446 BASE_62);
059ec3d9
PH		 4447 goto EXPAND_FAILED;
4448 }
9a799bc0 4449 n = n * BASE_62 + (t - base62_chars);
059ec3d9
PH		 4450 }
4451 (void)sprintf(CS buf, "%ld", n);
4452 yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
4453 continue;
4454 }
4455
4456 case EOP_EXPAND:
4457 {
4458 uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping);
4459 if (expanded == NULL)
4460 {
4461 expand_string_message =
4462 string_sprintf("internal expansion of \"%s\" failed: %s", sub,
4463 expand_string_message);
4464 goto EXPAND_FAILED;
4465 }
4466 yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
4467 continue;
4468 }
4469
4470 case EOP_LC:
4471 {
4472 int count = 0;
4473 uschar *t = sub - 1;
4474 while (*(++t) != 0) { *t = tolower(*t); count++; }
4475 yield = string_cat(yield, &size, &ptr, sub, count);
4476 continue;
4477 }
4478
4479 case EOP_UC:
4480 {
4481 int count = 0;
4482 uschar *t = sub - 1;
4483 while (*(++t) != 0) { *t = toupper(*t); count++; }
4484 yield = string_cat(yield, &size, &ptr, sub, count);
4485 continue;
4486 }
4487
4488 case EOP_MD5:
4489 {
4490 md5 base;
4491 uschar digest[16];
4492 int j;
4493 char st[33];
4494 md5_start(&base);
4495 md5_end(&base, sub, Ustrlen(sub), digest);
4496 for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
4497 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4498 continue;
4499 }
4500
4501 case EOP_SHA1:
4502 {
4503 sha1 base;
4504 uschar digest[20];
4505 int j;
4506 char st[41];
4507 sha1_start(&base);
4508 sha1_end(&base, sub, Ustrlen(sub), digest);
4509 for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
4510 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4511 continue;
4512 }
4513
4514 /* Convert hex encoding to base64 encoding */
4515
4516 case EOP_HEX2B64:
4517 {
4518 int c = 0;
4519 int b = -1;
4520 uschar *in = sub;
4521 uschar *out = sub;
4522 uschar *enc;
4523
4524 for (enc = sub; *enc != 0; enc++)
4525 {
4526 if (!isxdigit(*enc))
4527 {
4528 expand_string_message = string_sprintf("\"%s\" is not a hex "
4529 "string", sub);
4530 goto EXPAND_FAILED;
4531 }
4532 c++;
4533 }
4534
4535 if ((c & 1) != 0)
4536 {
4537 expand_string_message = string_sprintf("\"%s\" contains an odd "
4538 "number of characters", sub);
4539 goto EXPAND_FAILED;
4540 }
4541
4542 while ((c = *in++) != 0)
4543 {
4544 if (isdigit(c)) c -= '0';
4545 else c = toupper(c) - 'A' + 10;
4546 if (b == -1)
4547 {
4548 b = c << 4;
4549 }
4550 else
4551 {
4552 *out++ = b | c;
4553 b = -1;
4554 }
4555 }
4556
4557 enc = auth_b64encode(sub, out - sub);
4558 yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
4559 continue;
4560 }
4561
4562 /* mask applies a mask to an IP address; for example the result of
4563 ${mask:131.111.10.206/28} is 131.111.10.192/28. */
4564
4565 case EOP_MASK:
4566 {
4567 int count;
4568 uschar *endptr;
4569 int binary[4];
4570 int mask, maskoffset;
4571 int type = string_is_ip_address(sub, &maskoffset);
4572 uschar buffer[64];
4573
4574 if (type == 0)
4575 {
4576 expand_string_message = string_sprintf("\"%s\" is not an IP address",
4577 sub);
4578 goto EXPAND_FAILED;
4579 }
4580
4581 if (maskoffset == 0)
4582 {
4583 expand_string_message = string_sprintf("missing mask value in \"%s\"",
4584 sub);
4585 goto EXPAND_FAILED;
4586 }
4587
4588 mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
4589
4590 if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
4591 {
4592 expand_string_message = string_sprintf("mask value too big in \"%s\"",
4593 sub);
4594 goto EXPAND_FAILED;
4595 }
4596
4597 /* Convert the address to binary integer(s) and apply the mask */
4598
4599 sub[maskoffset] = 0;
4600 count = host_aton(sub, binary);
4601 host_mask(count, binary, mask);
4602
4603 /* Convert to masked textual format and add to output. */
4604
4605 yield = string_cat(yield, &size, &ptr, buffer,
6f0c9a4f 4606 host_nmtoa(count, binary, mask, buffer, '.'));
059ec3d9
PH		 4607 continue;
4608 }
4609
4610 case EOP_ADDRESS:
4611 case EOP_LOCAL_PART:
4612 case EOP_DOMAIN:
4613 {
4614 uschar *error;
4615 int start, end, domain;
4616 uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
4617 FALSE);
4618 if (t != NULL)
4619 {
4620 if (c != EOP_DOMAIN)
4621 {
4622 if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
4623 yield = string_cat(yield, &size, &ptr, sub+start, end-start);
4624 }
4625 else if (domain != 0)
4626 {
4627 domain += start;
4628 yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
4629 }
4630 }
4631 continue;
4632 }
4633
4634 /* quote puts a string in quotes if it is empty or contains anything
4635 other than alphamerics, underscore, dot, or hyphen.
4636
4637 quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
4638 be quoted in order to be a valid local part.
4639
4640 In both cases, newlines and carriage returns are converted into \n and \r
4641 respectively */
4642
4643 case EOP_QUOTE:
4644 case EOP_QUOTE_LOCAL_PART:
4645 if (arg == NULL)
4646 {
4647 BOOL needs_quote = (*sub == 0); /* TRUE for empty string */
4648 uschar *t = sub - 1;
4649
4650 if (c == EOP_QUOTE)
4651 {
4652 while (!needs_quote && *(++t) != 0)
4653 needs_quote = !isalnum(*t) && !strchr("_-.", *t);
4654 }
4655 else /* EOP_QUOTE_LOCAL_PART */
4656 {
4657 while (!needs_quote && *(++t) != 0)
4658 needs_quote = !isalnum(*t) &&
4659 strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
4660 (*t != '.' || t == sub || t[1] == 0);
4661 }
4662
4663 if (needs_quote)
4664 {
4665 yield = string_cat(yield, &size, &ptr, US"\"", 1);
4666 t = sub - 1;
4667 while (*(++t) != 0)
4668 {
4669 if (*t == '\n')
4670 yield = string_cat(yield, &size, &ptr, US"\\n", 2);
4671 else if (*t == '\r')
4672 yield = string_cat(yield, &size, &ptr, US"\\r", 2);
4673 else
4674 {
4675 if (*t == '\\' || *t == '"')
4676 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4677 yield = string_cat(yield, &size, &ptr, t, 1);
4678 }
4679 }
4680 yield = string_cat(yield, &size, &ptr, US"\"", 1);
4681 }
4682 else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4683 continue;
4684 }
4685
4686 /* quote_lookuptype does lookup-specific quoting */
4687
4688 else
4689 {
4690 int n;
4691 uschar *opt = Ustrchr(arg, '_');
4692
4693 if (opt != NULL) *opt++ = 0;
4694
4695 n = search_findtype(arg, Ustrlen(arg));
4696 if (n < 0)
4697 {
4698 expand_string_message = search_error_message;
4699 goto EXPAND_FAILED;
4700 }
4701
4702 if (lookup_list[n].quote != NULL)
4703 sub = (lookup_list[n].quote)(sub, opt);
4704 else if (opt != NULL) sub = NULL;
4705
4706 if (sub == NULL)
4707 {
4708 expand_string_message = string_sprintf(
4709 "\"%s\" unrecognized after \"${quote_%s\"",
4710 opt, arg);
4711 goto EXPAND_FAILED;
4712 }
4713
4714 yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4715 continue;
4716 }
4717
4718 /* rx quote sticks in \ before any non-alphameric character so that
4719 the insertion works in a regular expression. */
4720
4721 case EOP_RXQUOTE:
4722 {
4723 uschar *t = sub - 1;
4724 while (*(++t) != 0)
4725 {
4726 if (!isalnum(*t))
4727 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4728 yield = string_cat(yield, &size, &ptr, t, 1);
4729 }
4730 continue;
4731 }
4732
4733 /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
4734 prescribed by the RFC, if there are characters that need to be encoded */
4735
4736 case EOP_RFC2047:
4737 {
14702f5b 4738 uschar buffer[2048];
059ec3d9 4739 uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
46218253 4740 buffer, sizeof(buffer), FALSE);
059ec3d9
PH		 4741 yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
4742 continue;
4743 }
4744
4745 /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
4746 underscores */
4747
4748 case EOP_FROM_UTF8:
4749 {
4750 while (*sub != 0)
4751 {
4752 int c;
4753 uschar buff[4];
4754 GETUTF8INC(c, sub);
4755 if (c > 255) c = '_';
4756 buff[0] = c;
4757 yield = string_cat(yield, &size, &ptr, buff, 1);
4758 }
4759 continue;
4760 }
4761
4762 /* escape turns all non-printing characters into escape sequences. */
4763
4764 case EOP_ESCAPE:
4765 {
4766 uschar *t = string_printing(sub);
4767 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4768 continue;
4769 }
4770
4771 /* Handle numeric expression evaluation */
4772
4773 case EOP_EVAL:
4774 case EOP_EVAL10:
4775 {
4776 uschar *save_sub = sub;
4777 uschar *error = NULL;
4778 int n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
4779 if (error != NULL)
4780 {
4781 expand_string_message = string_sprintf("error in expression "
4782 "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
4783 save_sub);
4784 goto EXPAND_FAILED;
4785 }
4786 sprintf(CS var_buffer, "%d", n);
4787 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4788 continue;
4789 }
4790
4791 /* Handle time period formating */
4792
f90d018c
PH		 4793 case EOP_TIME_EVAL:
4794 {
4795 int n = readconf_readtime(sub, 0, FALSE);
4796 if (n < 0)
4797 {
4798 expand_string_message = string_sprintf("string \"%s\" is not an "
4799 "Exim time interval in \"%s\" operator", sub, name);
4800 goto EXPAND_FAILED;
4801 }
4802 sprintf(CS var_buffer, "%d", n);
4803 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4804 continue;
4805 }
4806
059ec3d9
PH		 4807 case EOP_TIME_INTERVAL:
4808 {
4809 int n;
4810 uschar *t = read_number(&n, sub);
4811 if (*t != 0) /* Not A Number*/
4812 {
4813 expand_string_message = string_sprintf("string \"%s\" is not a "
4814 "positive number in \"%s\" operator", sub, name);
4815 goto EXPAND_FAILED;
4816 }
4817 t = readconf_printtime(n);
4818 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4819 continue;
4820 }
4821
4822 /* Convert string to base64 encoding */
4823
4824 case EOP_STR2B64:
4825 {
4826 uschar *encstr = auth_b64encode(sub, Ustrlen(sub));
4827 yield = string_cat(yield, &size, &ptr, encstr, Ustrlen(encstr));
4828 continue;
4829 }
4830
4831 /* strlen returns the length of the string */
4832
4833 case EOP_STRLEN:
4834 {
4835 uschar buff[24];
4836 (void)sprintf(CS buff, "%d", Ustrlen(sub));
4837 yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
4838 continue;
4839 }
4840
4841 /* length_n or l_n takes just the first n characters or the whole string,
4842 whichever is the shorter;
4843
4844 substr_m_n, and s_m_n take n characters from offset m; negative m take
4845 from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
4846 takes the rest, either to the right or to the left.
4847
4848 hash_n or h_n makes a hash of length n from the string, yielding n
4849 characters from the set a-z; hash_n_m makes a hash of length n, but
4850 uses m characters from the set a-zA-Z0-9.
4851
4852 nhash_n returns a single number between 0 and n-1 (in text form), while
4853 nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
4854 between 0 and n-1 and the second between 0 and m-1. */
4855
4856 case EOP_LENGTH:
4857 case EOP_L:
4858 case EOP_SUBSTR:
4859 case EOP_S:
4860 case EOP_HASH:
4861 case EOP_H:
4862 case EOP_NHASH:
4863 case EOP_NH:
4864 {
4865 int sign = 1;
4866 int value1 = 0;
4867 int value2 = -1;
4868 int *pn;
4869 int len;
4870 uschar *ret;
4871
4872 if (arg == NULL)
4873 {
4874 expand_string_message = string_sprintf("missing values after %s",
4875 name);
4876 goto EXPAND_FAILED;
4877 }
4878
4879 /* "length" has only one argument, effectively being synonymous with
4880 substr_0_n. */
4881
4882 if (c == EOP_LENGTH || c == EOP_L)
4883 {
4884 pn = &value2;
4885 value2 = 0;
4886 }
4887
4888 /* The others have one or two arguments; for "substr" the first may be
4889 negative. The second being negative means "not supplied". */
4890
4891 else
4892 {
4893 pn = &value1;
4894 if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
4895 }
4896
4897 /* Read up to two numbers, separated by underscores */
4898
4899 ret = arg;
4900 while (*arg != 0)
4901 {
4902 if (arg != ret && *arg == '_' && pn == &value1)
4903 {
4904 pn = &value2;
4905 value2 = 0;
4906 if (arg[1] != 0) arg++;
4907 }
4908 else if (!isdigit(*arg))
4909 {
4910 expand_string_message =
4911 string_sprintf("non-digit after underscore in \"%s\"", name);
4912 goto EXPAND_FAILED;
4913 }
4914 else *pn = (*pn)*10 + *arg++ - '0';
4915 }
4916 value1 *= sign;
4917
4918 /* Perform the required operation */
4919
4920 ret =
4921 (c == EOP_HASH || c == EOP_H)?
4922 compute_hash(sub, value1, value2, &len) :
4923 (c == EOP_NHASH || c == EOP_NH)?
4924 compute_nhash(sub, value1, value2, &len) :
4925 extract_substr(sub, value1, value2, &len);
4926
4927 if (ret == NULL) goto EXPAND_FAILED;
4928 yield = string_cat(yield, &size, &ptr, ret, len);
4929 continue;
4930 }
4931
4932 /* Stat a path */
4933
4934 case EOP_STAT:
4935 {
4936 uschar *s;
4937 uschar smode[12];
4938 uschar **modetable[3];
4939 int i;
4940 mode_t mode;
4941 struct stat st;
4942
254e032f
PH		 4943 if ((expand_forbid & RDO_EXISTS) != 0)
4944 {
4945 expand_string_message = US"Use of the stat() expansion is not permitted";
4946 goto EXPAND_FAILED;
4947 }
4948
059ec3d9
PH		 4949 if (stat(CS sub, &st) < 0)
4950 {
4951 expand_string_message = string_sprintf("stat(%s) failed: %s",
4952 sub, strerror(errno));
4953 goto EXPAND_FAILED;
4954 }
4955 mode = st.st_mode;
4956 switch (mode & S_IFMT)
4957 {
4958 case S_IFIFO: smode[0] = 'p'; break;
4959 case S_IFCHR: smode[0] = 'c'; break;
4960 case S_IFDIR: smode[0] = 'd'; break;
4961 case S_IFBLK: smode[0] = 'b'; break;
4962 case S_IFREG: smode[0] = '-'; break;
4963 default: smode[0] = '?'; break;
4964 }
4965
4966 modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
4967 modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
4968 modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
4969
4970 for (i = 0; i < 3; i++)
4971 {
4972 memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
4973 mode >>= 3;
4974 }
4975
4976 smode[10] = 0;
4977 s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
b1c749bb 4978 "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
059ec3d9
PH		 4979 (long)(st.st_mode & 077777), smode, (long)st.st_ino,
4980 (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
b1c749bb 4981 (long)st.st_gid, st.st_size, (long)st.st_atime,
059ec3d9
PH		 4982 (long)st.st_mtime, (long)st.st_ctime);
4983 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
4984 continue;
4985 }
4986
4987 /* Unknown operator */
4988
4989 default:
4990 expand_string_message =
4991 string_sprintf("unknown expansion operator \"%s\"", name);
4992 goto EXPAND_FAILED;
4993 }
4994 }
4995
4996 /* Handle a plain name. If this is the first thing in the expansion, release
4997 the pre-allocated buffer. If the result data is known to be in a new buffer,
4998 newsize will be set to the size of that buffer, and we can just point at that
4999 store instead of copying. Many expansion strings contain just one reference,
5000 so this is a useful optimization, especially for humungous headers
5001 ($message_headers). */
5002
5003 if (*s++ == '}')
5004 {
5005 int len;
5006 int newsize = 0;
5007 if (ptr == 0)
5008 {
5009 store_reset(yield);
5010 yield = NULL;
5011 size = 0;
5012 }
5013 value = find_variable(name, FALSE, skipping, &newsize);
5014 if (value == NULL)
5015 {
5016 expand_string_message =
5017 string_sprintf("unknown variable in \"${%s}\"", name);
5018 goto EXPAND_FAILED;
5019 }
5020 len = Ustrlen(value);
5021 if (yield == NULL && newsize != 0)
5022 {
5023 yield = value;
5024 size = newsize;
5025 ptr = len;
5026 }
5027 else yield = string_cat(yield, &size, &ptr, value, len);
5028 continue;
5029 }
5030
5031 /* Else there's something wrong */
5032
5033 expand_string_message =
5034 string_sprintf("\"${%s\" is not a known operator (or a } is missing "
5035 "in a variable reference)", name);
5036 goto EXPAND_FAILED;
5037 }
5038
5039/* If we hit the end of the string when ket_ends is set, there is a missing
5040terminating brace. */
5041
5042if (ket_ends && *s == 0)
5043 {
5044 expand_string_message = malformed_header?
5045 US"missing } at end of string - could be header name not terminated by colon"
5046 :
5047 US"missing } at end of string";
5048 goto EXPAND_FAILED;
5049 }
5050
5051/* Expansion succeeded; yield may still be NULL here if nothing was actually
5052added to the string. If so, set up an empty string. Add a terminating zero. If
5053left != NULL, return a pointer to the terminator. */
5054
5055if (yield == NULL) yield = store_get(1);
5056yield[ptr] = 0;
5057if (left != NULL) *left = s;
5058
5059/* Any stacking store that was used above the final string is no longer needed.
5060In many cases the final string will be the first one that was got and so there
5061will be optimal store usage. */
5062
5063store_reset(yield + ptr + 1);
5064DEBUG(D_expand)
5065 {
5066 debug_printf("expanding: %.*s\n result: %s\n", (int)(s - string), string,
5067 yield);
5068 if (skipping) debug_printf("skipping: result is not used\n");
5069 }
5070return yield;
5071
5072/* This is the failure exit: easiest to program with a goto. We still need
5073to update the pointer to the terminator, for cases of nested calls with "fail".
5074*/
5075
5076EXPAND_FAILED_CURLY:
5077expand_string_message = malformed_header?
5078 US"missing or misplaced { or } - could be header name not terminated by colon"
5079 :
5080 US"missing or misplaced { or }";
5081
5082/* At one point, Exim reset the store to yield (if yield was not NULL), but
5083that is a bad idea, because expand_string_message is in dynamic store. */
5084
5085EXPAND_FAILED:
5086if (left != NULL) *left = s;
5087DEBUG(D_expand)
5088 {
5089 debug_printf("failed to expand: %s\n", string);
5090 debug_printf(" error message: %s\n", expand_string_message);
5091 if (expand_string_forcedfail) debug_printf("failure was forced\n");
5092 }
5093return NULL;
5094}
5095
5096
5097/* This is the external function call. Do a quick check for any expansion
5098metacharacters, and if there are none, just return the input string.
5099
5100Argument: the string to be expanded
5101Returns: the expanded string, or NULL if expansion failed; if failure was
5102 due to a lookup deferring, search_find_defer will be TRUE
5103*/
5104
5105uschar *
5106expand_string(uschar *string)
5107{
5108search_find_defer = FALSE;
5109malformed_header = FALSE;
5110return (Ustrpbrk(string, "$\\") == NULL)? string :
5111 expand_string_internal(string, FALSE, NULL, FALSE);
5112}
5113
5114
5115
5116/*************************************************
5117* Expand and copy *
5118*************************************************/
5119
5120/* Now and again we want to expand a string and be sure that the result is in a
5121new bit of store. This function does that.
5122
5123Argument: the string to be expanded
5124Returns: the expanded string, always in a new bit of store, or NULL
5125*/
5126
5127uschar *
5128expand_string_copy(uschar *string)
5129{
5130uschar *yield = expand_string(string);
5131if (yield == string) yield = string_copy(string);
5132return yield;
5133}
5134
5135
5136
5137/*************************************************
5138* Expand and interpret as an integer *
5139*************************************************/
5140
5141/* Expand a string, and convert the result into an integer.
5142
5143Argument: the string to be expanded
5144
5145Returns: the integer value, or
5146 -1 for an expansion error ) in both cases, message in
5147 -2 for an integer interpretation error ) expand_string_message
5148
5149*/
5150
5151int
5152expand_string_integer(uschar *string)
5153{
5154long int value;
5155uschar *s = expand_string(string);
5156uschar *msg = US"invalid integer \"%s\"";
5157uschar *endptr;
5158
5159if (s == NULL) return -1;
5160
5161/* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
5162to ERANGE. When there isn't an overflow, errno is not changed, at least on some
5163systems, so we set it zero ourselves. */
5164
5165errno = 0;
5166value = strtol(CS s, CSS &endptr, 0);
5167
5168if (endptr == s)
5169 {
5170 msg = US"integer expected but \"%s\" found";
5171 }
5172else
5173 {
5174 /* Ensure we can cast this down to an int */
5175 if (value > INT_MAX || value < INT_MIN) errno = ERANGE;
5176
5177 if (errno != ERANGE)
5178 {
5179 if (tolower(*endptr) == 'k')
5180 {
5181 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
5182 else value *= 1024;
5183 endptr++;
5184 }
5185 else if (tolower(*endptr) == 'm')
5186 {
5187 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
5188 errno = ERANGE;
5189 else value *= 1024*1024;
5190 endptr++;
5191 }
5192 }
5193 if (errno == ERANGE)
5194 msg = US"absolute value of integer \"%s\" is too large (overflow)";
5195 else
5196 {
5197 while (isspace(*endptr)) endptr++;
5198 if (*endptr == 0) return (int)value;
5199 }
5200 }
5201
5202expand_string_message = string_sprintf(CS msg, s);
5203return -2;
5204}
5205
059ec3d9
PH		 5206
5207/*************************************************
5208**************************************************
5209* Stand-alone test program *
5210**************************************************
5211*************************************************/
5212
5213#ifdef STAND_ALONE
5214
5215
5216BOOL
5217regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
5218{
5219int ovector[3*(EXPAND_MAXN+1)];
5220int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
5221 ovector, sizeof(ovector)/sizeof(int));
5222BOOL yield = n >= 0;
5223if (n == 0) n = EXPAND_MAXN + 1;
5224if (yield)
5225 {
5226 int nn;
5227 expand_nmax = (setup < 0)? 0 : setup + 1;
5228 for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
5229 {
5230 expand_nstring[expand_nmax] = subject + ovector[nn];
5231 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5232 }
5233 expand_nmax--;
5234 }
5235return yield;
5236}
5237
5238
5239int main(int argc, uschar **argv)
5240{
5241int i;
5242uschar buffer[1024];
5243
5244debug_selector = D_v;
5245debug_file = stderr;
5246debug_fd = fileno(debug_file);
5247big_buffer = malloc(big_buffer_size);
5248
5249for (i = 1; i < argc; i++)
5250 {
5251 if (argv[i][0] == '+')
5252 {
5253 debug_trace_memory = 2;
5254 argv[i]++;
5255 }
5256 if (isdigit(argv[i][0]))
5257 debug_selector = Ustrtol(argv[i], NULL, 0);
5258 else
5259 if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
5260 Ustrlen(argv[i]))
5261 {
5262 #ifdef LOOKUP_LDAP
5263 eldap_default_servers = argv[i];
5264 #endif
5265 #ifdef LOOKUP_MYSQL
5266 mysql_servers = argv[i];
5267 #endif
5268 #ifdef LOOKUP_PGSQL
5269 pgsql_servers = argv[i];
5270 #endif
5271 }
5272 #ifdef EXIM_PERL
5273 else opt_perl_startup = argv[i];
5274 #endif
5275 }
5276
5277printf("Testing string expansion: debug_level = %d\n\n", debug_level);
5278
5279expand_nstring[1] = US"string 1....";
5280expand_nlength[1] = 8;
5281expand_nmax = 1;
5282
5283#ifdef EXIM_PERL
5284if (opt_perl_startup != NULL)
5285 {
5286 uschar *errstr;
5287 printf("Starting Perl interpreter\n");
5288 errstr = init_perl(opt_perl_startup);
5289 if (errstr != NULL)
5290 {
5291 printf("** error in perl_startup code: %s\n", errstr);
5292 return EXIT_FAILURE;
5293 }
5294 }
5295#endif /* EXIM_PERL */
5296
5297while (fgets(buffer, sizeof(buffer), stdin) != NULL)
5298 {
5299 void *reset_point = store_get(0);
5300 uschar *yield = expand_string(buffer);
5301 if (yield != NULL)
5302 {
5303 printf("%s\n", yield);
5304 store_reset(reset_point);
5305 }
5306 else
5307 {
5308 if (search_find_defer) printf("search_find deferred\n");
5309 printf("Failed: %s\n", expand_string_message);
5310 if (expand_string_forcedfail) printf("Forced failure\n");
5311 printf("\n");
5312 }
5313 }
5314
5315search_tidyup();
5316
5317return 0;
5318}
5319
5320#endif
5321
5322/* End of expand.c */
Unnamed repository; edit this file 'description' to name the repository.