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