An update to gcc 4 threw up some new uninitialized variable and signed vs
[exim.git] / src / src / expand.c
CommitLineData
91ecef39 1/* $Cambridge: exim/src/src/expand.c,v 1.59 2006/09/05 14:05:43 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
1cce3af8
PH
3658 /* If skipping, we don't actually do anything. Otherwise, arrange to
3659 connect to either an IP or a Unix socket. */
059ec3d9
PH
3660
3661 if (!skipping)
3662 {
1cce3af8 3663 /* Handle an IP (internet) domain */
059ec3d9 3664
91ecef39 3665 if (Ustrncmp(sub_arg[0], "inet:", 5) == 0)
059ec3d9 3666 {
1cce3af8
PH
3667 BOOL connected = FALSE;
3668 int namelen, port;
3669 host_item shost;
3670 host_item *h;
3671 uschar *server_name = sub_arg[0] + 5;
3672 uschar *port_name = Ustrrchr(server_name, ':');
3673
3674 /* Sort out the port */
3675
3676 if (port_name == NULL)
3677 {
3678 expand_string_message =
3679 string_sprintf("missing port for readsocket %s", sub_arg[0]);
3680 goto EXPAND_FAILED;
3681 }
3682 *port_name++ = 0; /* Terminate server name */
3683
3684 if (isdigit(*port_name))
3685 {
3686 uschar *end;
3687 port = Ustrtol(port_name, &end, 0);
3688 if (end != port_name + Ustrlen(port_name))
3689 {
3690 expand_string_message =
3691 string_sprintf("invalid port number %s", port_name);
3692 goto EXPAND_FAILED;
3693 }
3694 }
3695 else
3696 {
3697 struct servent *service_info = getservbyname(CS port_name, "tcp");
3698 if (service_info == NULL)
3699 {
3700 expand_string_message = string_sprintf("unknown port \"%s\"",
3701 port_name);
3702 goto EXPAND_FAILED;
3703 }
3704 port = ntohs(service_info->s_port);
3705 }
3706
3707 /* Sort out the server. */
3708
3709 shost.next = NULL;
3710 shost.address = NULL;
3711 shost.port = port;
3712 shost.mx = -1;
3713
3714 namelen = Ustrlen(server_name);
3715
3716 /* Anything enclosed in [] must be an IP address. */
3717
3718 if (server_name[0] == '[' &&
3719 server_name[namelen - 1] == ']')
3720 {
3721 server_name[namelen - 1] = 0;
3722 server_name++;
3723 if (string_is_ip_address(server_name, NULL) == 0)
3724 {
3725 expand_string_message =
3726 string_sprintf("malformed IP address \"%s\"", server_name);
3727 goto EXPAND_FAILED;
3728 }
3729 shost.name = shost.address = server_name;
3730 }
3731
3732 /* Otherwise check for an unadorned IP address */
3733
3734 else if (string_is_ip_address(server_name, NULL) != 0)
3735 shost.name = shost.address = server_name;
3736
3737 /* Otherwise lookup IP address(es) from the name */
3738
3739 else
3740 {
3741 shost.name = server_name;
3742 if (host_find_byname(&shost, NULL, NULL, FALSE) != HOST_FOUND)
3743 {
3744 expand_string_message =
3745 string_sprintf("no IP address found for host %s", shost.name);
3746 goto EXPAND_FAILED;
3747 }
3748 }
3749
3750 /* Try to connect to the server - test each IP till one works */
3751
3752 for (h = &shost; h != NULL; h = h->next)
3753 {
3754 int af = (Ustrchr(h->address, ':') != 0)? AF_INET6 : AF_INET;
3755 if ((fd = ip_socket(SOCK_STREAM, af)) == -1)
3756 {
3757 expand_string_message = string_sprintf("failed to create socket: "
3758 "%s", strerror(errno));
3759 goto SOCK_FAIL;
3760 }
3761
3762 if (ip_connect(fd, af, h->address, port, timeout) == 0)
3763 {
3764 connected = TRUE;
3765 break;
3766 }
3767 }
3768
3769 if (!connected)
3770 {
3771 expand_string_message = string_sprintf("failed to connect to "
3772 "socket %s: couldn't connect to any host", sub_arg[0],
3773 strerror(errno));
3774 goto SOCK_FAIL;
3775 }
059ec3d9
PH
3776 }
3777
1cce3af8
PH
3778 /* Handle a Unix domain socket */
3779
3780 else
059ec3d9 3781 {
1cce3af8
PH
3782 if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
3783 {
3784 expand_string_message = string_sprintf("failed to create socket: %s",
3785 strerror(errno));
3786 goto SOCK_FAIL;
3787 }
3788
3789 sockun.sun_family = AF_UNIX;
3790 sprintf(sockun.sun_path, "%.*s", (int)(sizeof(sockun.sun_path)-1),
3791 sub_arg[0]);
3792 if(connect(fd, (struct sockaddr *)(&sockun), sizeof(sockun)) == -1)
3793 {
3794 expand_string_message = string_sprintf("failed to connect to socket "
3795 "%s: %s", sub_arg[0], strerror(errno));
3796 goto SOCK_FAIL;
3797 }
059ec3d9 3798 }
1cce3af8 3799
059ec3d9
PH
3800 DEBUG(D_expand) debug_printf("connected to socket %s\n", sub_arg[0]);
3801
3802 /* Write the request string, if not empty */
3803
3804 if (sub_arg[1][0] != 0)
3805 {
3806 int len = Ustrlen(sub_arg[1]);
3807 DEBUG(D_expand) debug_printf("writing \"%s\" to socket\n",
3808 sub_arg[1]);
3809 if (write(fd, sub_arg[1], len) != len)
3810 {
3811 expand_string_message = string_sprintf("request write to socket "
3812 "failed: %s", strerror(errno));
3813 goto SOCK_FAIL;
3814 }
3815 }
3816
3817 /* Now we need to read from the socket, under a timeout. The function
3818 that reads a file can be used. */
3819
3820 f = fdopen(fd, "rb");
3821 sigalrm_seen = FALSE;
3822 alarm(timeout);
3823 yield = cat_file(f, yield, &size, &ptr, sub_arg[3]);
3824 alarm(0);
f1e894f3 3825 (void)fclose(f);
059ec3d9
PH
3826
3827 /* After a timeout, we restore the pointer in the result, that is,
3828 make sure we add nothing from the socket. */
3829
3830 if (sigalrm_seen)
3831 {
3832 ptr = save_ptr;
1cce3af8 3833 expand_string_message = US "socket read timed out";
059ec3d9
PH
3834 goto SOCK_FAIL;
3835 }
3836 }
3837
3838 /* The whole thing has worked (or we were skipping). If there is a
3839 failure string following, we need to skip it. */
3840
3841 if (*s == '{')
3842 {
3843 if (expand_string_internal(s+1, TRUE, &s, TRUE) == NULL)
3844 goto EXPAND_FAILED;
3845 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3846 while (isspace(*s)) s++;
3847 }
3848 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3849 continue;
3850
3851 /* Come here on failure to create socket, connect socket, write to the
3852 socket, or timeout on reading. If another substring follows, expand and
3853 use it. Otherwise, those conditions give expand errors. */
3854
3855 SOCK_FAIL:
3856 if (*s != '{') goto EXPAND_FAILED;
3857 DEBUG(D_any) debug_printf("%s\n", expand_string_message);
3858 arg = expand_string_internal(s+1, TRUE, &s, FALSE);
3859 if (arg == NULL) goto EXPAND_FAILED;
3860 yield = string_cat(yield, &size, &ptr, arg, Ustrlen(arg));
3861 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3862 while (isspace(*s)) s++;
3863 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3864 continue;
3865 }
3866
3867 /* Handle "run" to execute a program. */
3868
3869 case EITEM_RUN:
3870 {
3871 FILE *f;
059ec3d9
PH
3872 uschar *arg;
3873 uschar **argv;
3874 pid_t pid;
3875 int fd_in, fd_out;
3876 int lsize = 0;
3877 int lptr = 0;
3878
3879 if ((expand_forbid & RDO_RUN) != 0)
3880 {
3881 expand_string_message = US"running a command is not permitted";
3882 goto EXPAND_FAILED;
3883 }
3884
3885 while (isspace(*s)) s++;
3886 if (*s != '{') goto EXPAND_FAILED_CURLY;
3887 arg = expand_string_internal(s+1, TRUE, &s, skipping);
3888 if (arg == NULL) goto EXPAND_FAILED;
3889 while (isspace(*s)) s++;
3890 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
3891
3892 if (skipping) /* Just pretend it worked when we're skipping */
3893 {
3894 runrc = 0;
3895 }
3896 else
3897 {
3898 if (!transport_set_up_command(&argv, /* anchor for arg list */
3899 arg, /* raw command */
3900 FALSE, /* don't expand the arguments */
3901 0, /* not relevant when... */
3902 NULL, /* no transporting address */
3903 US"${run} expansion", /* for error messages */
3904 &expand_string_message)) /* where to put error message */
3905 {
3906 goto EXPAND_FAILED;
3907 }
3908
3909 /* Create the child process, making it a group leader. */
3910
3911 pid = child_open(argv, NULL, 0077, &fd_in, &fd_out, TRUE);
3912
3913 if (pid < 0)
3914 {
3915 expand_string_message =
3916 string_sprintf("couldn't create child process: %s", strerror(errno));
3917 goto EXPAND_FAILED;
3918 }
3919
3920 /* Nothing is written to the standard input. */
3921
f1e894f3 3922 (void)close(fd_in);
059ec3d9
PH
3923
3924 /* Wait for the process to finish, applying the timeout, and inspect its
3925 return code for serious disasters. Simple non-zero returns are passed on.
3926 */
3927
3928 if ((runrc = child_close(pid, 60)) < 0)
3929 {
3930 if (runrc == -256)
3931 {
3932 expand_string_message = string_sprintf("command timed out");
3933 killpg(pid, SIGKILL); /* Kill the whole process group */
3934 }
3935
3936 else if (runrc == -257)
3937 expand_string_message = string_sprintf("wait() failed: %s",
3938 strerror(errno));
3939
3940 else
3941 expand_string_message = string_sprintf("command killed by signal %d",
3942 -runrc);
3943
3944 goto EXPAND_FAILED;
3945 }
3946
3947 /* Read the pipe to get the command's output into $value (which is kept
3948 in lookup_value). */
3949
3950 f = fdopen(fd_out, "rb");
059ec3d9
PH
3951 lookup_value = NULL;
3952 lookup_value = cat_file(f, lookup_value, &lsize, &lptr, NULL);
f1e894f3 3953 (void)fclose(f);
059ec3d9
PH
3954 }
3955
d20976dc 3956 /* Process the yes/no strings; $value may be useful in both cases */
059ec3d9
PH
3957
3958 switch(process_yesno(
3959 skipping, /* were previously skipping */
3960 runrc == 0, /* success/failure indicator */
d20976dc 3961 lookup_value, /* value to reset for string2 */
059ec3d9
PH
3962 &s, /* input pointer */
3963 &yield, /* output pointer */
3964 &size, /* output size */
3965 &ptr, /* output current point */
3966 US"run")) /* condition type */
3967 {
3968 case 1: goto EXPAND_FAILED; /* when all is well, the */
3969 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
3970 }
3971
3972 continue;
3973 }
3974
3975 /* Handle character translation for "tr" */
3976
3977 case EITEM_TR:
3978 {
3979 int oldptr = ptr;
3980 int o2m;
3981 uschar *sub[3];
3982
3983 switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"tr"))
3984 {
3985 case 1: goto EXPAND_FAILED_CURLY;
3986 case 2:
3987 case 3: goto EXPAND_FAILED;
3988 }
3989
3990 yield = string_cat(yield, &size, &ptr, sub[0], Ustrlen(sub[0]));
3991 o2m = Ustrlen(sub[2]) - 1;
3992
3993 if (o2m >= 0) for (; oldptr < ptr; oldptr++)
3994 {
3995 uschar *m = Ustrrchr(sub[1], yield[oldptr]);
3996 if (m != NULL)
3997 {
3998 int o = m - sub[1];
3999 yield[oldptr] = sub[2][(o < o2m)? o : o2m];
4000 }
4001 }
4002
4003 continue;
4004 }
4005
4006 /* Handle "hash", "length", "nhash", and "substr" when they are given with
4007 expanded arguments. */
4008
4009 case EITEM_HASH:
4010 case EITEM_LENGTH:
4011 case EITEM_NHASH:
4012 case EITEM_SUBSTR:
4013 {
4014 int i;
4015 int len;
4016 uschar *ret;
4017 int val[2] = { 0, -1 };
4018 uschar *sub[3];
4019
4020 /* "length" takes only 2 arguments whereas the others take 2 or 3.
4021 Ensure that sub[2] is set in the ${length case. */
4022
4023 sub[2] = NULL;
4024 switch(read_subs(sub, (item_type == EITEM_LENGTH)? 2:3, 2, &s, skipping,
4025 TRUE, name))
4026 {
4027 case 1: goto EXPAND_FAILED_CURLY;
4028 case 2:
4029 case 3: goto EXPAND_FAILED;
4030 }
4031
4032 /* Juggle the arguments if there are only two of them: always move the
4033 string to the last position and make ${length{n}{str}} equivalent to
4034 ${substr{0}{n}{str}}. See the defaults for val[] above. */
4035
4036 if (sub[2] == NULL)
4037 {
4038 sub[2] = sub[1];
4039 sub[1] = NULL;
4040 if (item_type == EITEM_LENGTH)
4041 {
4042 sub[1] = sub[0];
4043 sub[0] = NULL;
4044 }
4045 }
4046
4047 for (i = 0; i < 2; i++)
4048 {
4049 if (sub[i] == NULL) continue;
4050 val[i] = (int)Ustrtol(sub[i], &ret, 10);
4051 if (*ret != 0 || (i != 0 && val[i] < 0))
4052 {
4053 expand_string_message = string_sprintf("\"%s\" is not a%s number "
4054 "(in \"%s\" expansion)", sub[i], (i != 0)? " positive" : "", name);
4055 goto EXPAND_FAILED;
4056 }
4057 }
4058
4059 ret =
4060 (item_type == EITEM_HASH)?
4061 compute_hash(sub[2], val[0], val[1], &len) :
4062 (item_type == EITEM_NHASH)?
4063 compute_nhash(sub[2], val[0], val[1], &len) :
4064 extract_substr(sub[2], val[0], val[1], &len);
4065
4066 if (ret == NULL) goto EXPAND_FAILED;
4067 yield = string_cat(yield, &size, &ptr, ret, len);
4068 continue;
4069 }
4070
4071 /* Handle HMAC computation: ${hmac{<algorithm>}{<secret>}{<text>}}
4072 This code originally contributed by Steve Haslam. It currently supports
4073 the use of MD5 and SHA-1 hashes.
4074
4075 We need some workspace that is large enough to handle all the supported
4076 hash types. Use macros to set the sizes rather than be too elaborate. */
4077
4078 #define MAX_HASHLEN 20
4079 #define MAX_HASHBLOCKLEN 64
4080
4081 case EITEM_HMAC:
4082 {
4083 uschar *sub[3];
4084 md5 md5_base;
4085 sha1 sha1_base;
4086 void *use_base;
4087 int type, i;
4088 int hashlen; /* Number of octets for the hash algorithm's output */
4089 int hashblocklen; /* Number of octets the hash algorithm processes */
4090 uschar *keyptr, *p;
4091 unsigned int keylen;
4092
4093 uschar keyhash[MAX_HASHLEN];
4094 uschar innerhash[MAX_HASHLEN];
4095 uschar finalhash[MAX_HASHLEN];
4096 uschar finalhash_hex[2*MAX_HASHLEN];
4097 uschar innerkey[MAX_HASHBLOCKLEN];
4098 uschar outerkey[MAX_HASHBLOCKLEN];
4099
4100 switch (read_subs(sub, 3, 3, &s, skipping, TRUE, name))
4101 {
4102 case 1: goto EXPAND_FAILED_CURLY;
4103 case 2:
4104 case 3: goto EXPAND_FAILED;
4105 }
4106
4107 if (Ustrcmp(sub[0], "md5") == 0)
4108 {
4109 type = HMAC_MD5;
4110 use_base = &md5_base;
4111 hashlen = 16;
4112 hashblocklen = 64;
4113 }
4114 else if (Ustrcmp(sub[0], "sha1") == 0)
4115 {
4116 type = HMAC_SHA1;
4117 use_base = &sha1_base;
4118 hashlen = 20;
4119 hashblocklen = 64;
4120 }
4121 else
4122 {
4123 expand_string_message =
4124 string_sprintf("hmac algorithm \"%s\" is not recognised", sub[0]);
4125 goto EXPAND_FAILED;
4126 }
4127
4128 keyptr = sub[1];
4129 keylen = Ustrlen(keyptr);
4130
4131 /* If the key is longer than the hash block length, then hash the key
4132 first */
4133
4134 if (keylen > hashblocklen)
4135 {
4136 chash_start(type, use_base);
4137 chash_end(type, use_base, keyptr, keylen, keyhash);
4138 keyptr = keyhash;
4139 keylen = hashlen;
4140 }
4141
4142 /* Now make the inner and outer key values */
4143
4144 memset(innerkey, 0x36, hashblocklen);
4145 memset(outerkey, 0x5c, hashblocklen);
4146
4147 for (i = 0; i < keylen; i++)
4148 {
4149 innerkey[i] ^= keyptr[i];
4150 outerkey[i] ^= keyptr[i];
4151 }
4152
4153 /* Now do the hashes */
4154
4155 chash_start(type, use_base);
4156 chash_mid(type, use_base, innerkey);
4157 chash_end(type, use_base, sub[2], Ustrlen(sub[2]), innerhash);
4158
4159 chash_start(type, use_base);
4160 chash_mid(type, use_base, outerkey);
4161 chash_end(type, use_base, innerhash, hashlen, finalhash);
4162
4163 /* Encode the final hash as a hex string */
4164
4165 p = finalhash_hex;
4166 for (i = 0; i < hashlen; i++)
4167 {
4168 *p++ = hex_digits[(finalhash[i] & 0xf0) >> 4];
4169 *p++ = hex_digits[finalhash[i] & 0x0f];
4170 }
4171
4172 DEBUG(D_any) debug_printf("HMAC[%s](%.*s,%.*s)=%.*s\n", sub[0],
4173 (int)keylen, keyptr, Ustrlen(sub[2]), sub[2], hashlen*2, finalhash_hex);
4174
4175 yield = string_cat(yield, &size, &ptr, finalhash_hex, hashlen*2);
4176 }
4177
4178 continue;
4179
4180 /* Handle global substitution for "sg" - like Perl's s/xxx/yyy/g operator.
4181 We have to save the numerical variables and restore them afterwards. */
4182
4183 case EITEM_SG:
4184 {
4185 const pcre *re;
4186 int moffset, moffsetextra, slen;
4187 int roffset;
4188 int emptyopt;
4189 const uschar *rerror;
4190 uschar *subject;
4191 uschar *sub[3];
4192 int save_expand_nmax =
4193 save_expand_strings(save_expand_nstring, save_expand_nlength);
4194
4195 switch(read_subs(sub, 3, 3, &s, skipping, TRUE, US"sg"))
4196 {
4197 case 1: goto EXPAND_FAILED_CURLY;
4198 case 2:
4199 case 3: goto EXPAND_FAILED;
4200 }
4201
4202 /* Compile the regular expression */
4203
4204 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
4205 NULL);
4206
4207 if (re == NULL)
4208 {
4209 expand_string_message = string_sprintf("regular expression error in "
4210 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
4211 goto EXPAND_FAILED;
4212 }
4213
4214 /* Now run a loop to do the substitutions as often as necessary. It ends
4215 when there are no more matches. Take care over matches of the null string;
4216 do the same thing as Perl does. */
4217
4218 subject = sub[0];
4219 slen = Ustrlen(sub[0]);
4220 moffset = moffsetextra = 0;
4221 emptyopt = 0;
4222
4223 for (;;)
4224 {
4225 int ovector[3*(EXPAND_MAXN+1)];
4226 int n = pcre_exec(re, NULL, CS subject, slen, moffset + moffsetextra,
4227 PCRE_EOPT | emptyopt, ovector, sizeof(ovector)/sizeof(int));
4228 int nn;
4229 uschar *insert;
4230
4231 /* No match - if we previously set PCRE_NOTEMPTY after a null match, this
4232 is not necessarily the end. We want to repeat the match from one
4233 character further along, but leaving the basic offset the same (for
4234 copying below). We can't be at the end of the string - that was checked
4235 before setting PCRE_NOTEMPTY. If PCRE_NOTEMPTY is not set, we are
4236 finished; copy the remaining string and end the loop. */
4237
4238 if (n < 0)
4239 {
4240 if (emptyopt != 0)
4241 {
4242 moffsetextra = 1;
4243 emptyopt = 0;
4244 continue;
4245 }
4246 yield = string_cat(yield, &size, &ptr, subject+moffset, slen-moffset);
4247 break;
4248 }
4249
4250 /* Match - set up for expanding the replacement. */
4251
4252 if (n == 0) n = EXPAND_MAXN + 1;
4253 expand_nmax = 0;
4254 for (nn = 0; nn < n*2; nn += 2)
4255 {
4256 expand_nstring[expand_nmax] = subject + ovector[nn];
4257 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
4258 }
4259 expand_nmax--;
4260
4261 /* Copy the characters before the match, plus the expanded insertion. */
4262
4263 yield = string_cat(yield, &size, &ptr, subject + moffset,
4264 ovector[0] - moffset);
4265 insert = expand_string(sub[2]);
4266 if (insert == NULL) goto EXPAND_FAILED;
4267 yield = string_cat(yield, &size, &ptr, insert, Ustrlen(insert));
4268
4269 moffset = ovector[1];
4270 moffsetextra = 0;
4271 emptyopt = 0;
4272
4273 /* If we have matched an empty string, first check to see if we are at
4274 the end of the subject. If so, the loop is over. Otherwise, mimic
4275 what Perl's /g options does. This turns out to be rather cunning. First
4276 we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match a non-empty
4277 string at the same point. If this fails (picked up above) we advance to
4278 the next character. */
4279
4280 if (ovector[0] == ovector[1])
4281 {
4282 if (ovector[0] == slen) break;
4283 emptyopt = PCRE_NOTEMPTY | PCRE_ANCHORED;
4284 }
4285 }
4286
4287 /* All done - restore numerical variables. */
4288
4289 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4290 save_expand_nlength);
4291 continue;
4292 }
4293
4294 /* Handle keyed and numbered substring extraction. If the first argument
4295 consists entirely of digits, then a numerical extraction is assumed. */
4296
4297 case EITEM_EXTRACT:
4298 {
4299 int i;
4300 int j = 2;
4301 int field_number = 1;
4302 BOOL field_number_set = FALSE;
4303 uschar *save_lookup_value = lookup_value;
4304 uschar *sub[3];
4305 int save_expand_nmax =
4306 save_expand_strings(save_expand_nstring, save_expand_nlength);
4307
4308 /* Read the arguments */
4309
4310 for (i = 0; i < j; i++)
4311 {
4312 while (isspace(*s)) s++;
4313 if (*s == '{')
4314 {
4315 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping);
4316 if (sub[i] == NULL) goto EXPAND_FAILED;
4317 if (*s++ != '}') goto EXPAND_FAILED_CURLY;
4318
4319 /* After removal of leading and trailing white space, the first
4320 argument must not be empty; if it consists entirely of digits
4321 (optionally preceded by a minus sign), this is a numerical
4322 extraction, and we expect 3 arguments. */
4323
4324 if (i == 0)
4325 {
4326 int len;
4327 int x = 0;
4328 uschar *p = sub[0];
4329
4330 while (isspace(*p)) p++;
4331 sub[0] = p;
4332
4333 len = Ustrlen(p);
4334 while (len > 0 && isspace(p[len-1])) len--;
4335 p[len] = 0;
4336
4337 if (*p == 0)
4338 {
554d2369
TF
4339 expand_string_message = US"first argument of \"extract\" must "
4340 "not be empty";
059ec3d9
PH
4341 goto EXPAND_FAILED;
4342 }
4343
4344 if (*p == '-')
4345 {
4346 field_number = -1;
4347 p++;
4348 }
4349 while (*p != 0 && isdigit(*p)) x = x * 10 + *p++ - '0';
4350 if (*p == 0)
4351 {
4352 field_number *= x;
4353 j = 3; /* Need 3 args */
4354 field_number_set = TRUE;
4355 }
4356 }
4357 }
4358 else goto EXPAND_FAILED_CURLY;
4359 }
4360
4361 /* Extract either the numbered or the keyed substring into $value. If
4362 skipping, just pretend the extraction failed. */
4363
4364 lookup_value = skipping? NULL : field_number_set?
4365 expand_gettokened(field_number, sub[1], sub[2]) :
4366 expand_getkeyed(sub[0], sub[1]);
4367
4368 /* If no string follows, $value gets substituted; otherwise there can
4369 be yes/no strings, as for lookup or if. */
4370
4371 switch(process_yesno(
4372 skipping, /* were previously skipping */
4373 lookup_value != NULL, /* success/failure indicator */
4374 save_lookup_value, /* value to reset for string2 */
4375 &s, /* input pointer */
4376 &yield, /* output pointer */
4377 &size, /* output size */
4378 &ptr, /* output current point */
4379 US"extract")) /* condition type */
4380 {
4381 case 1: goto EXPAND_FAILED; /* when all is well, the */
4382 case 2: goto EXPAND_FAILED_CURLY; /* returned value is 0 */
4383 }
4384
4385 /* All done - restore numerical variables. */
4386
4387 restore_expand_strings(save_expand_nmax, save_expand_nstring,
4388 save_expand_nlength);
4389
4390 continue;
4391 }
1a46a8c5
PH
4392
4393
4394 /* If ${dlfunc support is configured, handle calling dynamically-loaded
4395 functions, unless locked out at this time. Syntax is ${dlfunc{file}{func}}
4396 or ${dlfunc{file}{func}{arg}} or ${dlfunc{file}{func}{arg1}{arg2}} or up to
4397 a maximum of EXPAND_DLFUNC_MAX_ARGS arguments (defined below). */
4398
4399 #define EXPAND_DLFUNC_MAX_ARGS 8
4400
4401 case EITEM_DLFUNC:
4402 #ifndef EXPAND_DLFUNC
4403 expand_string_message = US"\"${dlfunc\" encountered, but this facility "
4404 "is not included in this binary";
4405 goto EXPAND_FAILED;
4406
4407 #else /* EXPAND_DLFUNC */
4408 {
4409 tree_node *t;
4410 exim_dlfunc_t *func;
4411 uschar *result;
4412 int status, argc;
4413 uschar *argv[EXPAND_DLFUNC_MAX_ARGS + 3];
4414
4415 if ((expand_forbid & RDO_DLFUNC) != 0)
4416 {
4417 expand_string_message =
4418 US"dynamically-loaded functions are not permitted";
4419 goto EXPAND_FAILED;
4420 }
4421
4422 switch(read_subs(argv, EXPAND_DLFUNC_MAX_ARGS + 2, 2, &s, skipping,
4423 TRUE, US"dlfunc"))
4424 {
4425 case 1: goto EXPAND_FAILED_CURLY;
4426 case 2:
4427 case 3: goto EXPAND_FAILED;
4428 }
4429
4430 /* If skipping, we don't actually do anything */
4431
4432 if (skipping) continue;
4433
4434 /* Look up the dynamically loaded object handle in the tree. If it isn't
4435 found, dlopen() the file and put the handle in the tree for next time. */
4436
4437 t = tree_search(dlobj_anchor, argv[0]);
4438 if (t == NULL)
4439 {
4440 void *handle = dlopen(CS argv[0], RTLD_LAZY);
4441 if (handle == NULL)
4442 {
4443 expand_string_message = string_sprintf("dlopen \"%s\" failed: %s",
4444 argv[0], dlerror());
4445 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
4446 goto EXPAND_FAILED;
4447 }
4448 t = store_get_perm(sizeof(tree_node) + Ustrlen(argv[0]));
4449 Ustrcpy(t->name, argv[0]);
4450 t->data.ptr = handle;
4451 (void)tree_insertnode(&dlobj_anchor, t);
4452 }
4453
4454 /* Having obtained the dynamically loaded object handle, look up the
4455 function pointer. */
4456
4457 func = (exim_dlfunc_t *)dlsym(t->data.ptr, CS argv[1]);
4458 if (func == NULL)
4459 {
4460 expand_string_message = string_sprintf("dlsym \"%s\" in \"%s\" failed: "
4461 "%s", argv[1], argv[0], dlerror());
7dbf77c9 4462 log_write(0, LOG_MAIN|LOG_PANIC, "%s", expand_string_message);
1a46a8c5
PH
4463 goto EXPAND_FAILED;
4464 }
4465
4466 /* Call the function and work out what to do with the result. If it
4467 returns OK, we have a replacement string; if it returns DEFER then
4468 expansion has failed in a non-forced manner; if it returns FAIL then
4469 failure was forced; if it returns ERROR or any other value there's a
4470 problem, so panic slightly. */
4471
4472 result = NULL;
4473 for (argc = 0; argv[argc] != NULL; argc++);
4474 status = func(&result, argc - 2, &argv[2]);
4475 if(status == OK)
4476 {
4477 if (result == NULL) result = US"";
4478 yield = string_cat(yield, &size, &ptr, result, Ustrlen(result));
4479 continue;
4480 }
4481 else
4482 {
4483 expand_string_message = result == NULL ? US"(no message)" : result;
4484 if(status == FAIL_FORCED) expand_string_forcedfail = TRUE;
4485 else if(status != FAIL)
4486 log_write(0, LOG_MAIN|LOG_PANIC, "dlfunc{%s}{%s} failed (%d): %s",
4487 argv[0], argv[1], status, expand_string_message);
4488 goto EXPAND_FAILED;
4489 }
4490 }
4491 #endif /* EXPAND_DLFUNC */
059ec3d9
PH
4492 }
4493
4494 /* Control reaches here if the name is not recognized as one of the more
4495 complicated expansion items. Check for the "operator" syntax (name terminated
4496 by a colon). Some of the operators have arguments, separated by _ from the
4497 name. */
4498
4499 if (*s == ':')
4500 {
4501 int c;
4502 uschar *arg = NULL;
4503 uschar *sub = expand_string_internal(s+1, TRUE, &s, skipping);
4504 if (sub == NULL) goto EXPAND_FAILED;
4505 s++;
4506
4507 /* Owing to an historical mis-design, an underscore may be part of the
4508 operator name, or it may introduce arguments. We therefore first scan the
4509 table of names that contain underscores. If there is no match, we cut off
4510 the arguments and then scan the main table. */
4511
4512 c = chop_match(name, op_table_underscore,
4513 sizeof(op_table_underscore)/sizeof(uschar *));
4514
4515 if (c < 0)
4516 {
4517 arg = Ustrchr(name, '_');
4518 if (arg != NULL) *arg = 0;
4519 c = chop_match(name, op_table_main,
4520 sizeof(op_table_main)/sizeof(uschar *));
4521 if (c >= 0) c += sizeof(op_table_underscore)/sizeof(uschar *);
4522 if (arg != NULL) *arg++ = '_'; /* Put back for error messages */
4523 }
4524
4525 /* If we are skipping, we don't need to perform the operation at all.
4526 This matters for operations like "mask", because the data may not be
4527 in the correct format when skipping. For example, the expression may test
4528 for the existence of $sender_host_address before trying to mask it. For
4529 other operations, doing them may not fail, but it is a waste of time. */
4530
4531 if (skipping && c >= 0) continue;
4532
4533 /* Otherwise, switch on the operator type */
4534
4535 switch(c)
4536 {
4537 case EOP_BASE62:
4538 {
4539 uschar *t;
4540 unsigned long int n = Ustrtoul(sub, &t, 10);
4541 if (*t != 0)
4542 {
4543 expand_string_message = string_sprintf("argument for base62 "
4544 "operator is \"%s\", which is not a decimal number", sub);
4545 goto EXPAND_FAILED;
4546 }
4547 t = string_base62(n);
4548 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4549 continue;
4550 }
4551
9a799bc0
PH
4552 /* Note that for Darwin and Cygwin, BASE_62 actually has the value 36 */
4553
059ec3d9
PH
4554 case EOP_BASE62D:
4555 {
4556 uschar buf[16];
4557 uschar *tt = sub;
4558 unsigned long int n = 0;
4559 while (*tt != 0)
4560 {
4561 uschar *t = Ustrchr(base62_chars, *tt++);
4562 if (t == NULL)
4563 {
4564 expand_string_message = string_sprintf("argument for base62d "
9a799bc0
PH
4565 "operator is \"%s\", which is not a base %d number", sub,
4566 BASE_62);
059ec3d9
PH
4567 goto EXPAND_FAILED;
4568 }
9a799bc0 4569 n = n * BASE_62 + (t - base62_chars);
059ec3d9
PH
4570 }
4571 (void)sprintf(CS buf, "%ld", n);
4572 yield = string_cat(yield, &size, &ptr, buf, Ustrlen(buf));
4573 continue;
4574 }
4575
4576 case EOP_EXPAND:
4577 {
4578 uschar *expanded = expand_string_internal(sub, FALSE, NULL, skipping);
4579 if (expanded == NULL)
4580 {
4581 expand_string_message =
4582 string_sprintf("internal expansion of \"%s\" failed: %s", sub,
4583 expand_string_message);
4584 goto EXPAND_FAILED;
4585 }
4586 yield = string_cat(yield, &size, &ptr, expanded, Ustrlen(expanded));
4587 continue;
4588 }
4589
4590 case EOP_LC:
4591 {
4592 int count = 0;
4593 uschar *t = sub - 1;
4594 while (*(++t) != 0) { *t = tolower(*t); count++; }
4595 yield = string_cat(yield, &size, &ptr, sub, count);
4596 continue;
4597 }
4598
4599 case EOP_UC:
4600 {
4601 int count = 0;
4602 uschar *t = sub - 1;
4603 while (*(++t) != 0) { *t = toupper(*t); count++; }
4604 yield = string_cat(yield, &size, &ptr, sub, count);
4605 continue;
4606 }
4607
4608 case EOP_MD5:
4609 {
4610 md5 base;
4611 uschar digest[16];
4612 int j;
4613 char st[33];
4614 md5_start(&base);
4615 md5_end(&base, sub, Ustrlen(sub), digest);
4616 for(j = 0; j < 16; j++) sprintf(st+2*j, "%02x", digest[j]);
4617 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4618 continue;
4619 }
4620
4621 case EOP_SHA1:
4622 {
4623 sha1 base;
4624 uschar digest[20];
4625 int j;
4626 char st[41];
4627 sha1_start(&base);
4628 sha1_end(&base, sub, Ustrlen(sub), digest);
4629 for(j = 0; j < 20; j++) sprintf(st+2*j, "%02X", digest[j]);
4630 yield = string_cat(yield, &size, &ptr, US st, (int)strlen(st));
4631 continue;
4632 }
4633
4634 /* Convert hex encoding to base64 encoding */
4635
4636 case EOP_HEX2B64:
4637 {
4638 int c = 0;
4639 int b = -1;
4640 uschar *in = sub;
4641 uschar *out = sub;
4642 uschar *enc;
4643
4644 for (enc = sub; *enc != 0; enc++)
4645 {
4646 if (!isxdigit(*enc))
4647 {
4648 expand_string_message = string_sprintf("\"%s\" is not a hex "
4649 "string", sub);
4650 goto EXPAND_FAILED;
4651 }
4652 c++;
4653 }
4654
4655 if ((c & 1) != 0)
4656 {
4657 expand_string_message = string_sprintf("\"%s\" contains an odd "
4658 "number of characters", sub);
4659 goto EXPAND_FAILED;
4660 }
4661
4662 while ((c = *in++) != 0)
4663 {
4664 if (isdigit(c)) c -= '0';
4665 else c = toupper(c) - 'A' + 10;
4666 if (b == -1)
4667 {
4668 b = c << 4;
4669 }
4670 else
4671 {
4672 *out++ = b | c;
4673 b = -1;
4674 }
4675 }
4676
4677 enc = auth_b64encode(sub, out - sub);
4678 yield = string_cat(yield, &size, &ptr, enc, Ustrlen(enc));
4679 continue;
4680 }
4681
4682 /* mask applies a mask to an IP address; for example the result of
4683 ${mask:131.111.10.206/28} is 131.111.10.192/28. */
4684
4685 case EOP_MASK:
4686 {
4687 int count;
4688 uschar *endptr;
4689 int binary[4];
4690 int mask, maskoffset;
4691 int type = string_is_ip_address(sub, &maskoffset);
4692 uschar buffer[64];
4693
4694 if (type == 0)
4695 {
4696 expand_string_message = string_sprintf("\"%s\" is not an IP address",
4697 sub);
4698 goto EXPAND_FAILED;
4699 }
4700
4701 if (maskoffset == 0)
4702 {
4703 expand_string_message = string_sprintf("missing mask value in \"%s\"",
4704 sub);
4705 goto EXPAND_FAILED;
4706 }
4707
4708 mask = Ustrtol(sub + maskoffset + 1, &endptr, 10);
4709
4710 if (*endptr != 0 || mask < 0 || mask > ((type == 4)? 32 : 128))
4711 {
4712 expand_string_message = string_sprintf("mask value too big in \"%s\"",
4713 sub);
4714 goto EXPAND_FAILED;
4715 }
4716
4717 /* Convert the address to binary integer(s) and apply the mask */
4718
4719 sub[maskoffset] = 0;
4720 count = host_aton(sub, binary);
4721 host_mask(count, binary, mask);
4722
4723 /* Convert to masked textual format and add to output. */
4724
4725 yield = string_cat(yield, &size, &ptr, buffer,
6f0c9a4f 4726 host_nmtoa(count, binary, mask, buffer, '.'));
059ec3d9
PH
4727 continue;
4728 }
4729
4730 case EOP_ADDRESS:
4731 case EOP_LOCAL_PART:
4732 case EOP_DOMAIN:
4733 {
4734 uschar *error;
4735 int start, end, domain;
4736 uschar *t = parse_extract_address(sub, &error, &start, &end, &domain,
4737 FALSE);
4738 if (t != NULL)
4739 {
4740 if (c != EOP_DOMAIN)
4741 {
4742 if (c == EOP_LOCAL_PART && domain != 0) end = start + domain - 1;
4743 yield = string_cat(yield, &size, &ptr, sub+start, end-start);
4744 }
4745 else if (domain != 0)
4746 {
4747 domain += start;
4748 yield = string_cat(yield, &size, &ptr, sub+domain, end-domain);
4749 }
4750 }
4751 continue;
4752 }
4753
4754 /* quote puts a string in quotes if it is empty or contains anything
4755 other than alphamerics, underscore, dot, or hyphen.
4756
4757 quote_local_part puts a string in quotes if RFC 2821/2822 requires it to
4758 be quoted in order to be a valid local part.
4759
4760 In both cases, newlines and carriage returns are converted into \n and \r
4761 respectively */
4762
4763 case EOP_QUOTE:
4764 case EOP_QUOTE_LOCAL_PART:
4765 if (arg == NULL)
4766 {
4767 BOOL needs_quote = (*sub == 0); /* TRUE for empty string */
4768 uschar *t = sub - 1;
4769
4770 if (c == EOP_QUOTE)
4771 {
4772 while (!needs_quote && *(++t) != 0)
4773 needs_quote = !isalnum(*t) && !strchr("_-.", *t);
4774 }
4775 else /* EOP_QUOTE_LOCAL_PART */
4776 {
4777 while (!needs_quote && *(++t) != 0)
4778 needs_quote = !isalnum(*t) &&
4779 strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
4780 (*t != '.' || t == sub || t[1] == 0);
4781 }
4782
4783 if (needs_quote)
4784 {
4785 yield = string_cat(yield, &size, &ptr, US"\"", 1);
4786 t = sub - 1;
4787 while (*(++t) != 0)
4788 {
4789 if (*t == '\n')
4790 yield = string_cat(yield, &size, &ptr, US"\\n", 2);
4791 else if (*t == '\r')
4792 yield = string_cat(yield, &size, &ptr, US"\\r", 2);
4793 else
4794 {
4795 if (*t == '\\' || *t == '"')
4796 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4797 yield = string_cat(yield, &size, &ptr, t, 1);
4798 }
4799 }
4800 yield = string_cat(yield, &size, &ptr, US"\"", 1);
4801 }
4802 else yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4803 continue;
4804 }
4805
4806 /* quote_lookuptype does lookup-specific quoting */
4807
4808 else
4809 {
4810 int n;
4811 uschar *opt = Ustrchr(arg, '_');
4812
4813 if (opt != NULL) *opt++ = 0;
4814
4815 n = search_findtype(arg, Ustrlen(arg));
4816 if (n < 0)
4817 {
4818 expand_string_message = search_error_message;
4819 goto EXPAND_FAILED;
4820 }
4821
4822 if (lookup_list[n].quote != NULL)
4823 sub = (lookup_list[n].quote)(sub, opt);
4824 else if (opt != NULL) sub = NULL;
4825
4826 if (sub == NULL)
4827 {
4828 expand_string_message = string_sprintf(
4829 "\"%s\" unrecognized after \"${quote_%s\"",
4830 opt, arg);
4831 goto EXPAND_FAILED;
4832 }
4833
4834 yield = string_cat(yield, &size, &ptr, sub, Ustrlen(sub));
4835 continue;
4836 }
4837
4838 /* rx quote sticks in \ before any non-alphameric character so that
4839 the insertion works in a regular expression. */
4840
4841 case EOP_RXQUOTE:
4842 {
4843 uschar *t = sub - 1;
4844 while (*(++t) != 0)
4845 {
4846 if (!isalnum(*t))
4847 yield = string_cat(yield, &size, &ptr, US"\\", 1);
4848 yield = string_cat(yield, &size, &ptr, t, 1);
4849 }
4850 continue;
4851 }
4852
4853 /* RFC 2047 encodes, assuming headers_charset (default ISO 8859-1) as
4854 prescribed by the RFC, if there are characters that need to be encoded */
4855
4856 case EOP_RFC2047:
4857 {
14702f5b 4858 uschar buffer[2048];
059ec3d9 4859 uschar *string = parse_quote_2047(sub, Ustrlen(sub), headers_charset,
46218253 4860 buffer, sizeof(buffer), FALSE);
059ec3d9
PH
4861 yield = string_cat(yield, &size, &ptr, string, Ustrlen(string));
4862 continue;
4863 }
4864
4865 /* from_utf8 converts UTF-8 to 8859-1, turning non-existent chars into
4866 underscores */
4867
4868 case EOP_FROM_UTF8:
4869 {
4870 while (*sub != 0)
4871 {
4872 int c;
4873 uschar buff[4];
4874 GETUTF8INC(c, sub);
4875 if (c > 255) c = '_';
4876 buff[0] = c;
4877 yield = string_cat(yield, &size, &ptr, buff, 1);
4878 }
4879 continue;
4880 }
4881
4882 /* escape turns all non-printing characters into escape sequences. */
4883
4884 case EOP_ESCAPE:
4885 {
4886 uschar *t = string_printing(sub);
4887 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4888 continue;
4889 }
4890
4891 /* Handle numeric expression evaluation */
4892
4893 case EOP_EVAL:
4894 case EOP_EVAL10:
4895 {
4896 uschar *save_sub = sub;
4897 uschar *error = NULL;
4898 int n = eval_expr(&sub, (c == EOP_EVAL10), &error, FALSE);
4899 if (error != NULL)
4900 {
4901 expand_string_message = string_sprintf("error in expression "
4902 "evaluation: %s (after processing \"%.*s\")", error, sub-save_sub,
4903 save_sub);
4904 goto EXPAND_FAILED;
4905 }
4906 sprintf(CS var_buffer, "%d", n);
4907 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4908 continue;
4909 }
4910
4911 /* Handle time period formating */
4912
f90d018c
PH
4913 case EOP_TIME_EVAL:
4914 {
4915 int n = readconf_readtime(sub, 0, FALSE);
4916 if (n < 0)
4917 {
4918 expand_string_message = string_sprintf("string \"%s\" is not an "
4919 "Exim time interval in \"%s\" operator", sub, name);
4920 goto EXPAND_FAILED;
4921 }
4922 sprintf(CS var_buffer, "%d", n);
4923 yield = string_cat(yield, &size, &ptr, var_buffer, Ustrlen(var_buffer));
4924 continue;
4925 }
4926
059ec3d9
PH
4927 case EOP_TIME_INTERVAL:
4928 {
4929 int n;
4930 uschar *t = read_number(&n, sub);
4931 if (*t != 0) /* Not A Number*/
4932 {
4933 expand_string_message = string_sprintf("string \"%s\" is not a "
4934 "positive number in \"%s\" operator", sub, name);
4935 goto EXPAND_FAILED;
4936 }
4937 t = readconf_printtime(n);
4938 yield = string_cat(yield, &size, &ptr, t, Ustrlen(t));
4939 continue;
4940 }
4941
4942 /* Convert string to base64 encoding */
4943
4944 case EOP_STR2B64:
4945 {
4946 uschar *encstr = auth_b64encode(sub, Ustrlen(sub));
4947 yield = string_cat(yield, &size, &ptr, encstr, Ustrlen(encstr));
4948 continue;
4949 }
4950
4951 /* strlen returns the length of the string */
4952
4953 case EOP_STRLEN:
4954 {
4955 uschar buff[24];
4956 (void)sprintf(CS buff, "%d", Ustrlen(sub));
4957 yield = string_cat(yield, &size, &ptr, buff, Ustrlen(buff));
4958 continue;
4959 }
4960
4961 /* length_n or l_n takes just the first n characters or the whole string,
4962 whichever is the shorter;
4963
4964 substr_m_n, and s_m_n take n characters from offset m; negative m take
4965 from the end; l_n is synonymous with s_0_n. If n is omitted in substr it
4966 takes the rest, either to the right or to the left.
4967
4968 hash_n or h_n makes a hash of length n from the string, yielding n
4969 characters from the set a-z; hash_n_m makes a hash of length n, but
4970 uses m characters from the set a-zA-Z0-9.
4971
4972 nhash_n returns a single number between 0 and n-1 (in text form), while
4973 nhash_n_m returns a div/mod hash as two numbers "a/b". The first lies
4974 between 0 and n-1 and the second between 0 and m-1. */
4975
4976 case EOP_LENGTH:
4977 case EOP_L:
4978 case EOP_SUBSTR:
4979 case EOP_S:
4980 case EOP_HASH:
4981 case EOP_H:
4982 case EOP_NHASH:
4983 case EOP_NH:
4984 {
4985 int sign = 1;
4986 int value1 = 0;
4987 int value2 = -1;
4988 int *pn;
4989 int len;
4990 uschar *ret;
4991
4992 if (arg == NULL)
4993 {
4994 expand_string_message = string_sprintf("missing values after %s",
4995 name);
4996 goto EXPAND_FAILED;
4997 }
4998
4999 /* "length" has only one argument, effectively being synonymous with
5000 substr_0_n. */
5001
5002 if (c == EOP_LENGTH || c == EOP_L)
5003 {
5004 pn = &value2;
5005 value2 = 0;
5006 }
5007
5008 /* The others have one or two arguments; for "substr" the first may be
5009 negative. The second being negative means "not supplied". */
5010
5011 else
5012 {
5013 pn = &value1;
5014 if (name[0] == 's' && *arg == '-') { sign = -1; arg++; }
5015 }
5016
5017 /* Read up to two numbers, separated by underscores */
5018
5019 ret = arg;
5020 while (*arg != 0)
5021 {
5022 if (arg != ret && *arg == '_' && pn == &value1)
5023 {
5024 pn = &value2;
5025 value2 = 0;
5026 if (arg[1] != 0) arg++;
5027 }
5028 else if (!isdigit(*arg))
5029 {
5030 expand_string_message =
5031 string_sprintf("non-digit after underscore in \"%s\"", name);
5032 goto EXPAND_FAILED;
5033 }
5034 else *pn = (*pn)*10 + *arg++ - '0';
5035 }
5036 value1 *= sign;
5037
5038 /* Perform the required operation */
5039
5040 ret =
5041 (c == EOP_HASH || c == EOP_H)?
5042 compute_hash(sub, value1, value2, &len) :
5043 (c == EOP_NHASH || c == EOP_NH)?
5044 compute_nhash(sub, value1, value2, &len) :
5045 extract_substr(sub, value1, value2, &len);
5046
5047 if (ret == NULL) goto EXPAND_FAILED;
5048 yield = string_cat(yield, &size, &ptr, ret, len);
5049 continue;
5050 }
5051
5052 /* Stat a path */
5053
5054 case EOP_STAT:
5055 {
5056 uschar *s;
5057 uschar smode[12];
5058 uschar **modetable[3];
5059 int i;
5060 mode_t mode;
5061 struct stat st;
5062
254e032f
PH
5063 if ((expand_forbid & RDO_EXISTS) != 0)
5064 {
5065 expand_string_message = US"Use of the stat() expansion is not permitted";
5066 goto EXPAND_FAILED;
5067 }
5068
059ec3d9
PH
5069 if (stat(CS sub, &st) < 0)
5070 {
5071 expand_string_message = string_sprintf("stat(%s) failed: %s",
5072 sub, strerror(errno));
5073 goto EXPAND_FAILED;
5074 }
5075 mode = st.st_mode;
5076 switch (mode & S_IFMT)
5077 {
5078 case S_IFIFO: smode[0] = 'p'; break;
5079 case S_IFCHR: smode[0] = 'c'; break;
5080 case S_IFDIR: smode[0] = 'd'; break;
5081 case S_IFBLK: smode[0] = 'b'; break;
5082 case S_IFREG: smode[0] = '-'; break;
5083 default: smode[0] = '?'; break;
5084 }
5085
5086 modetable[0] = ((mode & 01000) == 0)? mtable_normal : mtable_sticky;
5087 modetable[1] = ((mode & 02000) == 0)? mtable_normal : mtable_setid;
5088 modetable[2] = ((mode & 04000) == 0)? mtable_normal : mtable_setid;
5089
5090 for (i = 0; i < 3; i++)
5091 {
5092 memcpy(CS(smode + 7 - i*3), CS(modetable[i][mode & 7]), 3);
5093 mode >>= 3;
5094 }
5095
5096 smode[10] = 0;
5097 s = string_sprintf("mode=%04lo smode=%s inode=%ld device=%ld links=%ld "
b1c749bb 5098 "uid=%ld gid=%ld size=" OFF_T_FMT " atime=%ld mtime=%ld ctime=%ld",
059ec3d9
PH
5099 (long)(st.st_mode & 077777), smode, (long)st.st_ino,
5100 (long)st.st_dev, (long)st.st_nlink, (long)st.st_uid,
b1c749bb 5101 (long)st.st_gid, st.st_size, (long)st.st_atime,
059ec3d9
PH
5102 (long)st.st_mtime, (long)st.st_ctime);
5103 yield = string_cat(yield, &size, &ptr, s, Ustrlen(s));
5104 continue;
5105 }
5106
5107 /* Unknown operator */
5108
5109 default:
5110 expand_string_message =
5111 string_sprintf("unknown expansion operator \"%s\"", name);
5112 goto EXPAND_FAILED;
5113 }
5114 }
5115
5116 /* Handle a plain name. If this is the first thing in the expansion, release
5117 the pre-allocated buffer. If the result data is known to be in a new buffer,
5118 newsize will be set to the size of that buffer, and we can just point at that
5119 store instead of copying. Many expansion strings contain just one reference,
5120 so this is a useful optimization, especially for humungous headers
5121 ($message_headers). */
5122
5123 if (*s++ == '}')
5124 {
5125 int len;
5126 int newsize = 0;
5127 if (ptr == 0)
5128 {
5129 store_reset(yield);
5130 yield = NULL;
5131 size = 0;
5132 }
5133 value = find_variable(name, FALSE, skipping, &newsize);
5134 if (value == NULL)
5135 {
5136 expand_string_message =
5137 string_sprintf("unknown variable in \"${%s}\"", name);
5138 goto EXPAND_FAILED;
5139 }
5140 len = Ustrlen(value);
5141 if (yield == NULL && newsize != 0)
5142 {
5143 yield = value;
5144 size = newsize;
5145 ptr = len;
5146 }
5147 else yield = string_cat(yield, &size, &ptr, value, len);
5148 continue;
5149 }
5150
5151 /* Else there's something wrong */
5152
5153 expand_string_message =
5154 string_sprintf("\"${%s\" is not a known operator (or a } is missing "
5155 "in a variable reference)", name);
5156 goto EXPAND_FAILED;
5157 }
5158
5159/* If we hit the end of the string when ket_ends is set, there is a missing
5160terminating brace. */
5161
5162if (ket_ends && *s == 0)
5163 {
5164 expand_string_message = malformed_header?
5165 US"missing } at end of string - could be header name not terminated by colon"
5166 :
5167 US"missing } at end of string";
5168 goto EXPAND_FAILED;
5169 }
5170
5171/* Expansion succeeded; yield may still be NULL here if nothing was actually
5172added to the string. If so, set up an empty string. Add a terminating zero. If
5173left != NULL, return a pointer to the terminator. */
5174
5175if (yield == NULL) yield = store_get(1);
5176yield[ptr] = 0;
5177if (left != NULL) *left = s;
5178
5179/* Any stacking store that was used above the final string is no longer needed.
5180In many cases the final string will be the first one that was got and so there
5181will be optimal store usage. */
5182
5183store_reset(yield + ptr + 1);
5184DEBUG(D_expand)
5185 {
5186 debug_printf("expanding: %.*s\n result: %s\n", (int)(s - string), string,
5187 yield);
5188 if (skipping) debug_printf("skipping: result is not used\n");
5189 }
5190return yield;
5191
5192/* This is the failure exit: easiest to program with a goto. We still need
5193to update the pointer to the terminator, for cases of nested calls with "fail".
5194*/
5195
5196EXPAND_FAILED_CURLY:
5197expand_string_message = malformed_header?
5198 US"missing or misplaced { or } - could be header name not terminated by colon"
5199 :
5200 US"missing or misplaced { or }";
5201
5202/* At one point, Exim reset the store to yield (if yield was not NULL), but
5203that is a bad idea, because expand_string_message is in dynamic store. */
5204
5205EXPAND_FAILED:
5206if (left != NULL) *left = s;
5207DEBUG(D_expand)
5208 {
5209 debug_printf("failed to expand: %s\n", string);
5210 debug_printf(" error message: %s\n", expand_string_message);
5211 if (expand_string_forcedfail) debug_printf("failure was forced\n");
5212 }
5213return NULL;
5214}
5215
5216
5217/* This is the external function call. Do a quick check for any expansion
5218metacharacters, and if there are none, just return the input string.
5219
5220Argument: the string to be expanded
5221Returns: the expanded string, or NULL if expansion failed; if failure was
5222 due to a lookup deferring, search_find_defer will be TRUE
5223*/
5224
5225uschar *
5226expand_string(uschar *string)
5227{
5228search_find_defer = FALSE;
5229malformed_header = FALSE;
5230return (Ustrpbrk(string, "$\\") == NULL)? string :
5231 expand_string_internal(string, FALSE, NULL, FALSE);
5232}
5233
5234
5235
5236/*************************************************
5237* Expand and copy *
5238*************************************************/
5239
5240/* Now and again we want to expand a string and be sure that the result is in a
5241new bit of store. This function does that.
5242
5243Argument: the string to be expanded
5244Returns: the expanded string, always in a new bit of store, or NULL
5245*/
5246
5247uschar *
5248expand_string_copy(uschar *string)
5249{
5250uschar *yield = expand_string(string);
5251if (yield == string) yield = string_copy(string);
5252return yield;
5253}
5254
5255
5256
5257/*************************************************
5258* Expand and interpret as an integer *
5259*************************************************/
5260
5261/* Expand a string, and convert the result into an integer.
5262
5263Argument: the string to be expanded
5264
5265Returns: the integer value, or
5266 -1 for an expansion error ) in both cases, message in
5267 -2 for an integer interpretation error ) expand_string_message
5268
5269*/
5270
5271int
5272expand_string_integer(uschar *string)
5273{
5274long int value;
5275uschar *s = expand_string(string);
5276uschar *msg = US"invalid integer \"%s\"";
5277uschar *endptr;
5278
5279if (s == NULL) return -1;
5280
5281/* On an overflow, strtol() returns LONG_MAX or LONG_MIN, and sets errno
5282to ERANGE. When there isn't an overflow, errno is not changed, at least on some
5283systems, so we set it zero ourselves. */
5284
5285errno = 0;
5286value = strtol(CS s, CSS &endptr, 0);
5287
5288if (endptr == s)
5289 {
5290 msg = US"integer expected but \"%s\" found";
5291 }
5292else
5293 {
5294 /* Ensure we can cast this down to an int */
5295 if (value > INT_MAX || value < INT_MIN) errno = ERANGE;
5296
5297 if (errno != ERANGE)
5298 {
5299 if (tolower(*endptr) == 'k')
5300 {
5301 if (value > INT_MAX/1024 || value < INT_MIN/1024) errno = ERANGE;
5302 else value *= 1024;
5303 endptr++;
5304 }
5305 else if (tolower(*endptr) == 'm')
5306 {
5307 if (value > INT_MAX/(1024*1024) || value < INT_MIN/(1024*1024))
5308 errno = ERANGE;
5309 else value *= 1024*1024;
5310 endptr++;
5311 }
5312 }
5313 if (errno == ERANGE)
5314 msg = US"absolute value of integer \"%s\" is too large (overflow)";
5315 else
5316 {
5317 while (isspace(*endptr)) endptr++;
5318 if (*endptr == 0) return (int)value;
5319 }
5320 }
5321
5322expand_string_message = string_sprintf(CS msg, s);
5323return -2;
5324}
5325
059ec3d9
PH
5326
5327/*************************************************
5328**************************************************
5329* Stand-alone test program *
5330**************************************************
5331*************************************************/
5332
5333#ifdef STAND_ALONE
5334
5335
5336BOOL
5337regex_match_and_setup(const pcre *re, uschar *subject, int options, int setup)
5338{
5339int ovector[3*(EXPAND_MAXN+1)];
5340int n = pcre_exec(re, NULL, subject, Ustrlen(subject), 0, PCRE_EOPT|options,
5341 ovector, sizeof(ovector)/sizeof(int));
5342BOOL yield = n >= 0;
5343if (n == 0) n = EXPAND_MAXN + 1;
5344if (yield)
5345 {
5346 int nn;
5347 expand_nmax = (setup < 0)? 0 : setup + 1;
5348 for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
5349 {
5350 expand_nstring[expand_nmax] = subject + ovector[nn];
5351 expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
5352 }
5353 expand_nmax--;
5354 }
5355return yield;
5356}
5357
5358
5359int main(int argc, uschar **argv)
5360{
5361int i;
5362uschar buffer[1024];
5363
5364debug_selector = D_v;
5365debug_file = stderr;
5366debug_fd = fileno(debug_file);
5367big_buffer = malloc(big_buffer_size);
5368
5369for (i = 1; i < argc; i++)
5370 {
5371 if (argv[i][0] == '+')
5372 {
5373 debug_trace_memory = 2;
5374 argv[i]++;
5375 }
5376 if (isdigit(argv[i][0]))
5377 debug_selector = Ustrtol(argv[i], NULL, 0);
5378 else
5379 if (Ustrspn(argv[i], "abcdefghijklmnopqrtsuvwxyz0123456789-.:/") ==
5380 Ustrlen(argv[i]))
5381 {
5382 #ifdef LOOKUP_LDAP
5383 eldap_default_servers = argv[i];
5384 #endif
5385 #ifdef LOOKUP_MYSQL
5386 mysql_servers = argv[i];
5387 #endif
5388 #ifdef LOOKUP_PGSQL
5389 pgsql_servers = argv[i];
5390 #endif
5391 }
5392 #ifdef EXIM_PERL
5393 else opt_perl_startup = argv[i];
5394 #endif
5395 }
5396
5397printf("Testing string expansion: debug_level = %d\n\n", debug_level);
5398
5399expand_nstring[1] = US"string 1....";
5400expand_nlength[1] = 8;
5401expand_nmax = 1;
5402
5403#ifdef EXIM_PERL
5404if (opt_perl_startup != NULL)
5405 {
5406 uschar *errstr;
5407 printf("Starting Perl interpreter\n");
5408 errstr = init_perl(opt_perl_startup);
5409 if (errstr != NULL)
5410 {
5411 printf("** error in perl_startup code: %s\n", errstr);
5412 return EXIT_FAILURE;
5413 }
5414 }
5415#endif /* EXIM_PERL */
5416
5417while (fgets(buffer, sizeof(buffer), stdin) != NULL)
5418 {
5419 void *reset_point = store_get(0);
5420 uschar *yield = expand_string(buffer);
5421 if (yield != NULL)
5422 {
5423 printf("%s\n", yield);
5424 store_reset(reset_point);
5425 }
5426 else
5427 {
5428 if (search_find_defer) printf("search_find deferred\n");
5429 printf("Failed: %s\n", expand_string_message);
5430 if (expand_string_forcedfail) printf("Forced failure\n");
5431 printf("\n");
5432 }
5433 }
5434
5435search_tidyup();
5436
5437return 0;
5438}
5439
5440#endif
5441
5442/* End of expand.c */