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