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