projects / exim.git / blob
? search:


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