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