Tidying: Issues detected by gcc --fsanitize=undefined
[exim.git] / src / src / expand.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8
9 /* Functions for handling string expansion. */
10
11
12 #include "exim.h"
13
14 /* Recursively called function */
15
16 static uschar *expand_string_internal(const uschar *, BOOL, const uschar **, BOOL, BOOL, BOOL *);
17 static int_eximarith_t expanded_string_integer(const uschar *, BOOL);
18
19 #ifdef STAND_ALONE
20 #ifndef SUPPORT_CRYPTEQ
21 #define SUPPORT_CRYPTEQ
22 #endif
23 #endif
24
25 #ifdef LOOKUP_LDAP
26 #include "lookups/ldap.h"
27 #endif
28
29 #ifdef SUPPORT_CRYPTEQ
30 #ifdef CRYPT_H
31 #include <crypt.h>
32 #endif
33 #ifndef HAVE_CRYPT16
34 extern char* crypt16(char*, char*);
35 #endif
36 #endif
37
38 /* The handling of crypt16() is a mess. I will record below the analysis of the
39 mess that was sent to me. We decided, however, to make changing this very low
40 priority, because in practice people are moving away from the crypt()
41 algorithms nowadays, so it doesn't seem worth it.
42
43 <quote>
44 There is an algorithm named "crypt16" in Ultrix and Tru64. It crypts
45 the first 8 characters of the password using a 20-round version of crypt
46 (standard crypt does 25 rounds). It then crypts the next 8 characters,
47 or an empty block if the password is less than 9 characters, using a
48 20-round version of crypt and the same salt as was used for the first
49 block. Charaters after the first 16 are ignored. It always generates
50 a 16-byte hash, which is expressed together with the salt as a string
51 of 24 base 64 digits. Here are some links to peruse:
52
53 http://cvs.pld.org.pl/pam/pamcrypt/crypt16.c?rev=1.2
54 http://seclists.org/bugtraq/1999/Mar/0076.html
55
56 There's a different algorithm named "bigcrypt" in HP-UX, Digital Unix,
57 and OSF/1. This is the same as the standard crypt if given a password
58 of 8 characters or less. If given more, it first does the same as crypt
59 using the first 8 characters, then crypts the next 8 (the 9th to 16th)
60 using as salt the first two base 64 digits from the first hash block.
61 If the password is more than 16 characters then it crypts the 17th to 24th
62 characters using as salt the first two base 64 digits from the second hash
63 block. And so on: I've seen references to it cutting off the password at
64 40 characters (5 blocks), 80 (10 blocks), or 128 (16 blocks). Some links:
65
66 http://cvs.pld.org.pl/pam/pamcrypt/bigcrypt.c?rev=1.2
67 http://seclists.org/bugtraq/1999/Mar/0109.html
68 http://h30097.www3.hp.com/docs/base_doc/DOCUMENTATION/HTML/AA-Q0R2D-
69 TET1_html/sec.c222.html#no_id_208
70
71 Exim has something it calls "crypt16". It will either use a native
72 crypt16 or its own implementation. A native crypt16 will presumably
73 be the one that I called "crypt16" above. The internal "crypt16"
74 function, however, is a two-block-maximum implementation of what I called
75 "bigcrypt". The documentation matches the internal code.
76
77 I suspect that whoever did the "crypt16" stuff for Exim didn't realise
78 that crypt16 and bigcrypt were different things.
79
80 Exim uses the LDAP-style scheme identifier "{crypt16}" to refer
81 to whatever it is using under that name. This unfortunately sets a
82 precedent for using "{crypt16}" to identify two incompatible algorithms
83 whose output can't be distinguished. With "{crypt16}" thus rendered
84 ambiguous, I suggest you deprecate it and invent two new identifiers
85 for the two algorithms.
86
87 Both crypt16 and bigcrypt are very poor algorithms, btw. Hashing parts
88 of the password separately means they can be cracked separately, so
89 the double-length hash only doubles the cracking effort instead of
90 squaring it. I recommend salted SHA-1 ({SSHA}), or the Blowfish-based
91 bcrypt ({CRYPT}$2a$).
92 </quote>
93 */
94
95
96
97 /*************************************************
98 * Local statics and tables *
99 *************************************************/
100
101 /* Table of item names, and corresponding switch numbers. The names must be in
102 alphabetical order. */
103
104 static uschar *item_table[] = {
105 US"acl",
106 US"certextract",
107 US"dlfunc",
108 US"env",
109 US"extract",
110 US"filter",
111 US"hash",
112 US"hmac",
113 US"if",
114 #ifdef SUPPORT_I18N
115 US"imapfolder",
116 #endif
117 US"length",
118 US"listextract",
119 US"lookup",
120 US"map",
121 US"nhash",
122 US"perl",
123 US"prvs",
124 US"prvscheck",
125 US"readfile",
126 US"readsocket",
127 US"reduce",
128 US"run",
129 US"sg",
130 US"sort",
131 US"substr",
132 US"tr" };
133
134 enum {
135 EITEM_ACL,
136 EITEM_CERTEXTRACT,
137 EITEM_DLFUNC,
138 EITEM_ENV,
139 EITEM_EXTRACT,
140 EITEM_FILTER,
141 EITEM_HASH,
142 EITEM_HMAC,
143 EITEM_IF,
144 #ifdef SUPPORT_I18N
145 EITEM_IMAPFOLDER,
146 #endif
147 EITEM_LENGTH,
148 EITEM_LISTEXTRACT,
149 EITEM_LOOKUP,
150 EITEM_MAP,
151 EITEM_NHASH,
152 EITEM_PERL,
153 EITEM_PRVS,
154 EITEM_PRVSCHECK,
155 EITEM_READFILE,
156 EITEM_READSOCK,
157 EITEM_REDUCE,
158 EITEM_RUN,
159 EITEM_SG,
160 EITEM_SORT,
161 EITEM_SUBSTR,
162 EITEM_TR };
163
164 /* Tables of operator names, and corresponding switch numbers. The names must be
165 in alphabetical order. There are two tables, because underscore is used in some
166 cases to introduce arguments, whereas for other it is part of the name. This is
167 an historical mis-design. */
168
169 static uschar *op_table_underscore[] = {
170 US"from_utf8",
171 US"local_part",
172 US"quote_local_part",
173 US"reverse_ip",
174 US"time_eval",
175 US"time_interval"
176 #ifdef SUPPORT_I18N
177 ,US"utf8_domain_from_alabel",
178 US"utf8_domain_to_alabel",
179 US"utf8_localpart_from_alabel",
180 US"utf8_localpart_to_alabel"
181 #endif
182 };
183
184 enum {
185 EOP_FROM_UTF8,
186 EOP_LOCAL_PART,
187 EOP_QUOTE_LOCAL_PART,
188 EOP_REVERSE_IP,
189 EOP_TIME_EVAL,
190 EOP_TIME_INTERVAL
191 #ifdef SUPPORT_I18N
192 ,EOP_UTF8_DOMAIN_FROM_ALABEL,
193 EOP_UTF8_DOMAIN_TO_ALABEL,
194 EOP_UTF8_LOCALPART_FROM_ALABEL,
195 EOP_UTF8_LOCALPART_TO_ALABEL
196 #endif
197 };
198
199 static uschar *op_table_main[] = {
200 US"address",
201 US"addresses",
202 US"base62",
203 US"base62d",
204 US"base64",
205 US"base64d",
206 US"domain",
207 US"escape",
208 US"eval",
209 US"eval10",
210 US"expand",
211 US"h",
212 US"hash",
213 US"hex2b64",
214 US"hexquote",
215 US"ipv6denorm",
216 US"ipv6norm",
217 US"l",
218 US"lc",
219 US"length",
220 US"listcount",
221 US"listnamed",
222 US"mask",
223 US"md5",
224 US"nh",
225 US"nhash",
226 US"quote",
227 US"randint",
228 US"rfc2047",
229 US"rfc2047d",
230 US"rxquote",
231 US"s",
232 US"sha1",
233 US"sha256",
234 US"stat",
235 US"str2b64",
236 US"strlen",
237 US"substr",
238 US"uc",
239 US"utf8clean" };
240
241 enum {
242 EOP_ADDRESS = nelem(op_table_underscore),
243 EOP_ADDRESSES,
244 EOP_BASE62,
245 EOP_BASE62D,
246 EOP_BASE64,
247 EOP_BASE64D,
248 EOP_DOMAIN,
249 EOP_ESCAPE,
250 EOP_EVAL,
251 EOP_EVAL10,
252 EOP_EXPAND,
253 EOP_H,
254 EOP_HASH,
255 EOP_HEX2B64,
256 EOP_HEXQUOTE,
257 EOP_IPV6DENORM,
258 EOP_IPV6NORM,
259 EOP_L,
260 EOP_LC,
261 EOP_LENGTH,
262 EOP_LISTCOUNT,
263 EOP_LISTNAMED,
264 EOP_MASK,
265 EOP_MD5,
266 EOP_NH,
267 EOP_NHASH,
268 EOP_QUOTE,
269 EOP_RANDINT,
270 EOP_RFC2047,
271 EOP_RFC2047D,
272 EOP_RXQUOTE,
273 EOP_S,
274 EOP_SHA1,
275 EOP_SHA256,
276 EOP_STAT,
277 EOP_STR2B64,
278 EOP_STRLEN,
279 EOP_SUBSTR,
280 EOP_UC,
281 EOP_UTF8CLEAN };
282
283
284 /* Table of condition names, and corresponding switch numbers. The names must
285 be in alphabetical order. */
286
287 static uschar *cond_table[] = {
288 US"<",
289 US"<=",
290 US"=",
291 US"==", /* Backward compatibility */
292 US">",
293 US">=",
294 US"acl",
295 US"and",
296 US"bool",
297 US"bool_lax",
298 US"crypteq",
299 US"def",
300 US"eq",
301 US"eqi",
302 US"exists",
303 US"first_delivery",
304 US"forall",
305 US"forany",
306 US"ge",
307 US"gei",
308 US"gt",
309 US"gti",
310 US"inlist",
311 US"inlisti",
312 US"isip",
313 US"isip4",
314 US"isip6",
315 US"ldapauth",
316 US"le",
317 US"lei",
318 US"lt",
319 US"lti",
320 US"match",
321 US"match_address",
322 US"match_domain",
323 US"match_ip",
324 US"match_local_part",
325 US"or",
326 US"pam",
327 US"pwcheck",
328 US"queue_running",
329 US"radius",
330 US"saslauthd"
331 };
332
333 enum {
334 ECOND_NUM_L,
335 ECOND_NUM_LE,
336 ECOND_NUM_E,
337 ECOND_NUM_EE,
338 ECOND_NUM_G,
339 ECOND_NUM_GE,
340 ECOND_ACL,
341 ECOND_AND,
342 ECOND_BOOL,
343 ECOND_BOOL_LAX,
344 ECOND_CRYPTEQ,
345 ECOND_DEF,
346 ECOND_STR_EQ,
347 ECOND_STR_EQI,
348 ECOND_EXISTS,
349 ECOND_FIRST_DELIVERY,
350 ECOND_FORALL,
351 ECOND_FORANY,
352 ECOND_STR_GE,
353 ECOND_STR_GEI,
354 ECOND_STR_GT,
355 ECOND_STR_GTI,
356 ECOND_INLIST,
357 ECOND_INLISTI,
358 ECOND_ISIP,
359 ECOND_ISIP4,
360 ECOND_ISIP6,
361 ECOND_LDAPAUTH,
362 ECOND_STR_LE,
363 ECOND_STR_LEI,
364 ECOND_STR_LT,
365 ECOND_STR_LTI,
366 ECOND_MATCH,
367 ECOND_MATCH_ADDRESS,
368 ECOND_MATCH_DOMAIN,
369 ECOND_MATCH_IP,
370 ECOND_MATCH_LOCAL_PART,
371 ECOND_OR,
372 ECOND_PAM,
373 ECOND_PWCHECK,
374 ECOND_QUEUE_RUNNING,
375 ECOND_RADIUS,
376 ECOND_SASLAUTHD
377 };
378
379
380 /* Types of table entry */
381
382 enum vtypes {
383 vtype_int, /* value is address of int */
384 vtype_filter_int, /* ditto, but recognized only when filtering */
385 vtype_ino, /* value is address of ino_t (not always an int) */
386 vtype_uid, /* value is address of uid_t (not always an int) */
387 vtype_gid, /* value is address of gid_t (not always an int) */
388 vtype_bool, /* value is address of bool */
389 vtype_stringptr, /* value is address of pointer to string */
390 vtype_msgbody, /* as stringptr, but read when first required */
391 vtype_msgbody_end, /* ditto, the end of the message */
392 vtype_msgheaders, /* the message's headers, processed */
393 vtype_msgheaders_raw, /* the message's headers, unprocessed */
394 vtype_localpart, /* extract local part from string */
395 vtype_domain, /* extract domain from string */
396 vtype_string_func, /* value is string returned by given function */
397 vtype_todbsdin, /* value not used; generate BSD inbox tod */
398 vtype_tode, /* value not used; generate tod in epoch format */
399 vtype_todel, /* value not used; generate tod in epoch/usec format */
400 vtype_todf, /* value not used; generate full tod */
401 vtype_todl, /* value not used; generate log tod */
402 vtype_todlf, /* value not used; generate log file datestamp tod */
403 vtype_todzone, /* value not used; generate time zone only */
404 vtype_todzulu, /* value not used; generate zulu tod */
405 vtype_reply, /* value not used; get reply from headers */
406 vtype_pid, /* value not used; result is pid */
407 vtype_host_lookup, /* value not used; get host name */
408 vtype_load_avg, /* value not used; result is int from os_getloadavg */
409 vtype_pspace, /* partition space; value is T/F for spool/log */
410 vtype_pinodes, /* partition inodes; value is T/F for spool/log */
411 vtype_cert /* SSL certificate */
412 #ifndef DISABLE_DKIM
413 ,vtype_dkim /* Lookup of value in DKIM signature */
414 #endif
415 };
416
417 /* Type for main variable table */
418
419 typedef struct {
420 const char *name;
421 enum vtypes type;
422 void *value;
423 } var_entry;
424
425 /* Type for entries pointing to address/length pairs. Not currently
426 in use. */
427
428 typedef struct {
429 uschar **address;
430 int *length;
431 } alblock;
432
433 static uschar * fn_recipients(void);
434
435 /* This table must be kept in alphabetical order. */
436
437 static var_entry var_table[] = {
438 /* WARNING: Do not invent variables whose names start acl_c or acl_m because
439 they will be confused with user-creatable ACL variables. */
440 { "acl_arg1", vtype_stringptr, &acl_arg[0] },
441 { "acl_arg2", vtype_stringptr, &acl_arg[1] },
442 { "acl_arg3", vtype_stringptr, &acl_arg[2] },
443 { "acl_arg4", vtype_stringptr, &acl_arg[3] },
444 { "acl_arg5", vtype_stringptr, &acl_arg[4] },
445 { "acl_arg6", vtype_stringptr, &acl_arg[5] },
446 { "acl_arg7", vtype_stringptr, &acl_arg[6] },
447 { "acl_arg8", vtype_stringptr, &acl_arg[7] },
448 { "acl_arg9", vtype_stringptr, &acl_arg[8] },
449 { "acl_narg", vtype_int, &acl_narg },
450 { "acl_verify_message", vtype_stringptr, &acl_verify_message },
451 { "address_data", vtype_stringptr, &deliver_address_data },
452 { "address_file", vtype_stringptr, &address_file },
453 { "address_pipe", vtype_stringptr, &address_pipe },
454 { "authenticated_fail_id",vtype_stringptr, &authenticated_fail_id },
455 { "authenticated_id", vtype_stringptr, &authenticated_id },
456 { "authenticated_sender",vtype_stringptr, &authenticated_sender },
457 { "authentication_failed",vtype_int, &authentication_failed },
458 #ifdef WITH_CONTENT_SCAN
459 { "av_failed", vtype_int, &av_failed },
460 #endif
461 #ifdef EXPERIMENTAL_BRIGHTMAIL
462 { "bmi_alt_location", vtype_stringptr, &bmi_alt_location },
463 { "bmi_base64_tracker_verdict", vtype_stringptr, &bmi_base64_tracker_verdict },
464 { "bmi_base64_verdict", vtype_stringptr, &bmi_base64_verdict },
465 { "bmi_deliver", vtype_int, &bmi_deliver },
466 #endif
467 { "body_linecount", vtype_int, &body_linecount },
468 { "body_zerocount", vtype_int, &body_zerocount },
469 { "bounce_recipient", vtype_stringptr, &bounce_recipient },
470 { "bounce_return_size_limit", vtype_int, &bounce_return_size_limit },
471 { "caller_gid", vtype_gid, &real_gid },
472 { "caller_uid", vtype_uid, &real_uid },
473 { "callout_address", vtype_stringptr, &callout_address },
474 { "compile_date", vtype_stringptr, &version_date },
475 { "compile_number", vtype_stringptr, &version_cnumber },
476 { "config_dir", vtype_stringptr, &config_main_directory },
477 { "config_file", vtype_stringptr, &config_main_filename },
478 { "csa_status", vtype_stringptr, &csa_status },
479 #ifdef EXPERIMENTAL_DCC
480 { "dcc_header", vtype_stringptr, &dcc_header },
481 { "dcc_result", vtype_stringptr, &dcc_result },
482 #endif
483 #ifdef WITH_OLD_DEMIME
484 { "demime_errorlevel", vtype_int, &demime_errorlevel },
485 { "demime_reason", vtype_stringptr, &demime_reason },
486 #endif
487 #ifndef DISABLE_DKIM
488 { "dkim_algo", vtype_dkim, (void *)DKIM_ALGO },
489 { "dkim_bodylength", vtype_dkim, (void *)DKIM_BODYLENGTH },
490 { "dkim_canon_body", vtype_dkim, (void *)DKIM_CANON_BODY },
491 { "dkim_canon_headers", vtype_dkim, (void *)DKIM_CANON_HEADERS },
492 { "dkim_copiedheaders", vtype_dkim, (void *)DKIM_COPIEDHEADERS },
493 { "dkim_created", vtype_dkim, (void *)DKIM_CREATED },
494 { "dkim_cur_signer", vtype_stringptr, &dkim_cur_signer },
495 { "dkim_domain", vtype_stringptr, &dkim_signing_domain },
496 { "dkim_expires", vtype_dkim, (void *)DKIM_EXPIRES },
497 { "dkim_headernames", vtype_dkim, (void *)DKIM_HEADERNAMES },
498 { "dkim_identity", vtype_dkim, (void *)DKIM_IDENTITY },
499 { "dkim_key_granularity",vtype_dkim, (void *)DKIM_KEY_GRANULARITY },
500 { "dkim_key_length", vtype_int, &dkim_key_length },
501 { "dkim_key_nosubdomains",vtype_dkim, (void *)DKIM_NOSUBDOMAINS },
502 { "dkim_key_notes", vtype_dkim, (void *)DKIM_KEY_NOTES },
503 { "dkim_key_srvtype", vtype_dkim, (void *)DKIM_KEY_SRVTYPE },
504 { "dkim_key_testing", vtype_dkim, (void *)DKIM_KEY_TESTING },
505 { "dkim_selector", vtype_stringptr, &dkim_signing_selector },
506 { "dkim_signers", vtype_stringptr, &dkim_signers },
507 { "dkim_verify_reason", vtype_dkim, (void *)DKIM_VERIFY_REASON },
508 { "dkim_verify_status", vtype_dkim, (void *)DKIM_VERIFY_STATUS},
509 #endif
510 #ifdef EXPERIMENTAL_DMARC
511 { "dmarc_ar_header", vtype_stringptr, &dmarc_ar_header },
512 { "dmarc_domain_policy", vtype_stringptr, &dmarc_domain_policy },
513 { "dmarc_status", vtype_stringptr, &dmarc_status },
514 { "dmarc_status_text", vtype_stringptr, &dmarc_status_text },
515 { "dmarc_used_domain", vtype_stringptr, &dmarc_used_domain },
516 #endif
517 { "dnslist_domain", vtype_stringptr, &dnslist_domain },
518 { "dnslist_matched", vtype_stringptr, &dnslist_matched },
519 { "dnslist_text", vtype_stringptr, &dnslist_text },
520 { "dnslist_value", vtype_stringptr, &dnslist_value },
521 { "domain", vtype_stringptr, &deliver_domain },
522 { "domain_data", vtype_stringptr, &deliver_domain_data },
523 #ifndef DISABLE_EVENT
524 { "event_data", vtype_stringptr, &event_data },
525
526 /*XXX want to use generic vars for as many of these as possible*/
527 { "event_defer_errno", vtype_int, &event_defer_errno },
528
529 { "event_name", vtype_stringptr, &event_name },
530 #endif
531 { "exim_gid", vtype_gid, &exim_gid },
532 { "exim_path", vtype_stringptr, &exim_path },
533 { "exim_uid", vtype_uid, &exim_uid },
534 { "exim_version", vtype_stringptr, &version_string },
535 #ifdef WITH_OLD_DEMIME
536 { "found_extension", vtype_stringptr, &found_extension },
537 #endif
538 { "headers_added", vtype_string_func, &fn_hdrs_added },
539 { "home", vtype_stringptr, &deliver_home },
540 { "host", vtype_stringptr, &deliver_host },
541 { "host_address", vtype_stringptr, &deliver_host_address },
542 { "host_data", vtype_stringptr, &host_data },
543 { "host_lookup_deferred",vtype_int, &host_lookup_deferred },
544 { "host_lookup_failed", vtype_int, &host_lookup_failed },
545 { "host_port", vtype_int, &deliver_host_port },
546 { "inode", vtype_ino, &deliver_inode },
547 { "interface_address", vtype_stringptr, &interface_address },
548 { "interface_port", vtype_int, &interface_port },
549 { "item", vtype_stringptr, &iterate_item },
550 #ifdef LOOKUP_LDAP
551 { "ldap_dn", vtype_stringptr, &eldap_dn },
552 #endif
553 { "load_average", vtype_load_avg, NULL },
554 { "local_part", vtype_stringptr, &deliver_localpart },
555 { "local_part_data", vtype_stringptr, &deliver_localpart_data },
556 { "local_part_prefix", vtype_stringptr, &deliver_localpart_prefix },
557 { "local_part_suffix", vtype_stringptr, &deliver_localpart_suffix },
558 { "local_scan_data", vtype_stringptr, &local_scan_data },
559 { "local_user_gid", vtype_gid, &local_user_gid },
560 { "local_user_uid", vtype_uid, &local_user_uid },
561 { "localhost_number", vtype_int, &host_number },
562 { "log_inodes", vtype_pinodes, (void *)FALSE },
563 { "log_space", vtype_pspace, (void *)FALSE },
564 { "lookup_dnssec_authenticated",vtype_stringptr,&lookup_dnssec_authenticated},
565 { "mailstore_basename", vtype_stringptr, &mailstore_basename },
566 #ifdef WITH_CONTENT_SCAN
567 { "malware_name", vtype_stringptr, &malware_name },
568 #endif
569 { "max_received_linelength", vtype_int, &max_received_linelength },
570 { "message_age", vtype_int, &message_age },
571 { "message_body", vtype_msgbody, &message_body },
572 { "message_body_end", vtype_msgbody_end, &message_body_end },
573 { "message_body_size", vtype_int, &message_body_size },
574 { "message_exim_id", vtype_stringptr, &message_id },
575 { "message_headers", vtype_msgheaders, NULL },
576 { "message_headers_raw", vtype_msgheaders_raw, NULL },
577 { "message_id", vtype_stringptr, &message_id },
578 { "message_linecount", vtype_int, &message_linecount },
579 { "message_size", vtype_int, &message_size },
580 #ifdef SUPPORT_I18N
581 { "message_smtputf8", vtype_bool, &message_smtputf8 },
582 #endif
583 #ifdef WITH_CONTENT_SCAN
584 { "mime_anomaly_level", vtype_int, &mime_anomaly_level },
585 { "mime_anomaly_text", vtype_stringptr, &mime_anomaly_text },
586 { "mime_boundary", vtype_stringptr, &mime_boundary },
587 { "mime_charset", vtype_stringptr, &mime_charset },
588 { "mime_content_description", vtype_stringptr, &mime_content_description },
589 { "mime_content_disposition", vtype_stringptr, &mime_content_disposition },
590 { "mime_content_id", vtype_stringptr, &mime_content_id },
591 { "mime_content_size", vtype_int, &mime_content_size },
592 { "mime_content_transfer_encoding",vtype_stringptr, &mime_content_transfer_encoding },
593 { "mime_content_type", vtype_stringptr, &mime_content_type },
594 { "mime_decoded_filename", vtype_stringptr, &mime_decoded_filename },
595 { "mime_filename", vtype_stringptr, &mime_filename },
596 { "mime_is_coverletter", vtype_int, &mime_is_coverletter },
597 { "mime_is_multipart", vtype_int, &mime_is_multipart },
598 { "mime_is_rfc822", vtype_int, &mime_is_rfc822 },
599 { "mime_part_count", vtype_int, &mime_part_count },
600 #endif
601 { "n0", vtype_filter_int, &filter_n[0] },
602 { "n1", vtype_filter_int, &filter_n[1] },
603 { "n2", vtype_filter_int, &filter_n[2] },
604 { "n3", vtype_filter_int, &filter_n[3] },
605 { "n4", vtype_filter_int, &filter_n[4] },
606 { "n5", vtype_filter_int, &filter_n[5] },
607 { "n6", vtype_filter_int, &filter_n[6] },
608 { "n7", vtype_filter_int, &filter_n[7] },
609 { "n8", vtype_filter_int, &filter_n[8] },
610 { "n9", vtype_filter_int, &filter_n[9] },
611 { "original_domain", vtype_stringptr, &deliver_domain_orig },
612 { "original_local_part", vtype_stringptr, &deliver_localpart_orig },
613 { "originator_gid", vtype_gid, &originator_gid },
614 { "originator_uid", vtype_uid, &originator_uid },
615 { "parent_domain", vtype_stringptr, &deliver_domain_parent },
616 { "parent_local_part", vtype_stringptr, &deliver_localpart_parent },
617 { "pid", vtype_pid, NULL },
618 #ifndef DISABLE_PRDR
619 { "prdr_requested", vtype_bool, &prdr_requested },
620 #endif
621 { "primary_hostname", vtype_stringptr, &primary_hostname },
622 #if defined(SUPPORT_PROXY) || defined(SUPPORT_SOCKS)
623 { "proxy_external_address",vtype_stringptr, &proxy_external_address },
624 { "proxy_external_port", vtype_int, &proxy_external_port },
625 { "proxy_local_address", vtype_stringptr, &proxy_local_address },
626 { "proxy_local_port", vtype_int, &proxy_local_port },
627 { "proxy_session", vtype_bool, &proxy_session },
628 #endif
629 { "prvscheck_address", vtype_stringptr, &prvscheck_address },
630 { "prvscheck_keynum", vtype_stringptr, &prvscheck_keynum },
631 { "prvscheck_result", vtype_stringptr, &prvscheck_result },
632 { "qualify_domain", vtype_stringptr, &qualify_domain_sender },
633 { "qualify_recipient", vtype_stringptr, &qualify_domain_recipient },
634 { "rcpt_count", vtype_int, &rcpt_count },
635 { "rcpt_defer_count", vtype_int, &rcpt_defer_count },
636 { "rcpt_fail_count", vtype_int, &rcpt_fail_count },
637 { "received_count", vtype_int, &received_count },
638 { "received_for", vtype_stringptr, &received_for },
639 { "received_ip_address", vtype_stringptr, &interface_address },
640 { "received_port", vtype_int, &interface_port },
641 { "received_protocol", vtype_stringptr, &received_protocol },
642 { "received_time", vtype_int, &received_time },
643 { "recipient_data", vtype_stringptr, &recipient_data },
644 { "recipient_verify_failure",vtype_stringptr,&recipient_verify_failure },
645 { "recipients", vtype_string_func, &fn_recipients },
646 { "recipients_count", vtype_int, &recipients_count },
647 #ifdef WITH_CONTENT_SCAN
648 { "regex_match_string", vtype_stringptr, &regex_match_string },
649 #endif
650 { "reply_address", vtype_reply, NULL },
651 { "return_path", vtype_stringptr, &return_path },
652 { "return_size_limit", vtype_int, &bounce_return_size_limit },
653 { "router_name", vtype_stringptr, &router_name },
654 { "runrc", vtype_int, &runrc },
655 { "self_hostname", vtype_stringptr, &self_hostname },
656 { "sender_address", vtype_stringptr, &sender_address },
657 { "sender_address_data", vtype_stringptr, &sender_address_data },
658 { "sender_address_domain", vtype_domain, &sender_address },
659 { "sender_address_local_part", vtype_localpart, &sender_address },
660 { "sender_data", vtype_stringptr, &sender_data },
661 { "sender_fullhost", vtype_stringptr, &sender_fullhost },
662 { "sender_helo_dnssec", vtype_bool, &sender_helo_dnssec },
663 { "sender_helo_name", vtype_stringptr, &sender_helo_name },
664 { "sender_host_address", vtype_stringptr, &sender_host_address },
665 { "sender_host_authenticated",vtype_stringptr, &sender_host_authenticated },
666 { "sender_host_dnssec", vtype_bool, &sender_host_dnssec },
667 { "sender_host_name", vtype_host_lookup, NULL },
668 { "sender_host_port", vtype_int, &sender_host_port },
669 { "sender_ident", vtype_stringptr, &sender_ident },
670 { "sender_rate", vtype_stringptr, &sender_rate },
671 { "sender_rate_limit", vtype_stringptr, &sender_rate_limit },
672 { "sender_rate_period", vtype_stringptr, &sender_rate_period },
673 { "sender_rcvhost", vtype_stringptr, &sender_rcvhost },
674 { "sender_verify_failure",vtype_stringptr, &sender_verify_failure },
675 { "sending_ip_address", vtype_stringptr, &sending_ip_address },
676 { "sending_port", vtype_int, &sending_port },
677 { "smtp_active_hostname", vtype_stringptr, &smtp_active_hostname },
678 { "smtp_command", vtype_stringptr, &smtp_cmd_buffer },
679 { "smtp_command_argument", vtype_stringptr, &smtp_cmd_argument },
680 { "smtp_count_at_connection_start", vtype_int, &smtp_accept_count },
681 { "smtp_notquit_reason", vtype_stringptr, &smtp_notquit_reason },
682 { "sn0", vtype_filter_int, &filter_sn[0] },
683 { "sn1", vtype_filter_int, &filter_sn[1] },
684 { "sn2", vtype_filter_int, &filter_sn[2] },
685 { "sn3", vtype_filter_int, &filter_sn[3] },
686 { "sn4", vtype_filter_int, &filter_sn[4] },
687 { "sn5", vtype_filter_int, &filter_sn[5] },
688 { "sn6", vtype_filter_int, &filter_sn[6] },
689 { "sn7", vtype_filter_int, &filter_sn[7] },
690 { "sn8", vtype_filter_int, &filter_sn[8] },
691 { "sn9", vtype_filter_int, &filter_sn[9] },
692 #ifdef WITH_CONTENT_SCAN
693 { "spam_action", vtype_stringptr, &spam_action },
694 { "spam_bar", vtype_stringptr, &spam_bar },
695 { "spam_report", vtype_stringptr, &spam_report },
696 { "spam_score", vtype_stringptr, &spam_score },
697 { "spam_score_int", vtype_stringptr, &spam_score_int },
698 #endif
699 #ifdef EXPERIMENTAL_SPF
700 { "spf_guess", vtype_stringptr, &spf_guess },
701 { "spf_header_comment", vtype_stringptr, &spf_header_comment },
702 { "spf_received", vtype_stringptr, &spf_received },
703 { "spf_result", vtype_stringptr, &spf_result },
704 { "spf_smtp_comment", vtype_stringptr, &spf_smtp_comment },
705 #endif
706 { "spool_directory", vtype_stringptr, &spool_directory },
707 { "spool_inodes", vtype_pinodes, (void *)TRUE },
708 { "spool_space", vtype_pspace, (void *)TRUE },
709 #ifdef EXPERIMENTAL_SRS
710 { "srs_db_address", vtype_stringptr, &srs_db_address },
711 { "srs_db_key", vtype_stringptr, &srs_db_key },
712 { "srs_orig_recipient", vtype_stringptr, &srs_orig_recipient },
713 { "srs_orig_sender", vtype_stringptr, &srs_orig_sender },
714 { "srs_recipient", vtype_stringptr, &srs_recipient },
715 { "srs_status", vtype_stringptr, &srs_status },
716 #endif
717 { "thisaddress", vtype_stringptr, &filter_thisaddress },
718
719 /* The non-(in,out) variables are now deprecated */
720 { "tls_bits", vtype_int, &tls_in.bits },
721 { "tls_certificate_verified", vtype_int, &tls_in.certificate_verified },
722 { "tls_cipher", vtype_stringptr, &tls_in.cipher },
723
724 { "tls_in_bits", vtype_int, &tls_in.bits },
725 { "tls_in_certificate_verified", vtype_int, &tls_in.certificate_verified },
726 { "tls_in_cipher", vtype_stringptr, &tls_in.cipher },
727 { "tls_in_ocsp", vtype_int, &tls_in.ocsp },
728 { "tls_in_ourcert", vtype_cert, &tls_in.ourcert },
729 { "tls_in_peercert", vtype_cert, &tls_in.peercert },
730 { "tls_in_peerdn", vtype_stringptr, &tls_in.peerdn },
731 #if defined(SUPPORT_TLS)
732 { "tls_in_sni", vtype_stringptr, &tls_in.sni },
733 #endif
734 { "tls_out_bits", vtype_int, &tls_out.bits },
735 { "tls_out_certificate_verified", vtype_int,&tls_out.certificate_verified },
736 { "tls_out_cipher", vtype_stringptr, &tls_out.cipher },
737 #ifdef EXPERIMENTAL_DANE
738 { "tls_out_dane", vtype_bool, &tls_out.dane_verified },
739 #endif
740 { "tls_out_ocsp", vtype_int, &tls_out.ocsp },
741 { "tls_out_ourcert", vtype_cert, &tls_out.ourcert },
742 { "tls_out_peercert", vtype_cert, &tls_out.peercert },
743 { "tls_out_peerdn", vtype_stringptr, &tls_out.peerdn },
744 #if defined(SUPPORT_TLS)
745 { "tls_out_sni", vtype_stringptr, &tls_out.sni },
746 #endif
747 #ifdef EXPERIMENTAL_DANE
748 { "tls_out_tlsa_usage", vtype_int, &tls_out.tlsa_usage },
749 #endif
750
751 { "tls_peerdn", vtype_stringptr, &tls_in.peerdn }, /* mind the alphabetical order! */
752 #if defined(SUPPORT_TLS)
753 { "tls_sni", vtype_stringptr, &tls_in.sni }, /* mind the alphabetical order! */
754 #endif
755
756 { "tod_bsdinbox", vtype_todbsdin, NULL },
757 { "tod_epoch", vtype_tode, NULL },
758 { "tod_epoch_l", vtype_todel, NULL },
759 { "tod_full", vtype_todf, NULL },
760 { "tod_log", vtype_todl, NULL },
761 { "tod_logfile", vtype_todlf, NULL },
762 { "tod_zone", vtype_todzone, NULL },
763 { "tod_zulu", vtype_todzulu, NULL },
764 { "transport_name", vtype_stringptr, &transport_name },
765 { "value", vtype_stringptr, &lookup_value },
766 { "verify_mode", vtype_stringptr, &verify_mode },
767 { "version_number", vtype_stringptr, &version_string },
768 { "warn_message_delay", vtype_stringptr, &warnmsg_delay },
769 { "warn_message_recipient",vtype_stringptr, &warnmsg_recipients },
770 { "warn_message_recipients",vtype_stringptr,&warnmsg_recipients },
771 { "warnmsg_delay", vtype_stringptr, &warnmsg_delay },
772 { "warnmsg_recipient", vtype_stringptr, &warnmsg_recipients },
773 { "warnmsg_recipients", vtype_stringptr, &warnmsg_recipients }
774 };
775
776 static int var_table_size = nelem(var_table);
777 static uschar var_buffer[256];
778 static BOOL malformed_header;
779
780 /* For textual hashes */
781
782 static const char *hashcodes = "abcdefghijklmnopqrtsuvwxyz"
783 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
784 "0123456789";
785
786 enum { HMAC_MD5, HMAC_SHA1 };
787
788 /* For numeric hashes */
789
790 static unsigned int prime[] = {
791 2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
792 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
793 73, 79, 83, 89, 97, 101, 103, 107, 109, 113};
794
795 /* For printing modes in symbolic form */
796
797 static uschar *mtable_normal[] =
798 { US"---", US"--x", US"-w-", US"-wx", US"r--", US"r-x", US"rw-", US"rwx" };
799
800 static uschar *mtable_setid[] =
801 { US"--S", US"--s", US"-wS", US"-ws", US"r-S", US"r-s", US"rwS", US"rws" };
802
803 static uschar *mtable_sticky[] =
804 { US"--T", US"--t", US"-wT", US"-wt", US"r-T", US"r-t", US"rwT", US"rwt" };
805
806
807
808 /*************************************************
809 * Tables for UTF-8 support *
810 *************************************************/
811
812 /* Table of the number of extra characters, indexed by the first character
813 masked with 0x3f. The highest number for a valid UTF-8 character is in fact
814 0x3d. */
815
816 static uschar utf8_table1[] = {
817 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
818 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
819 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
820 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
821
822 /* These are the masks for the data bits in the first byte of a character,
823 indexed by the number of additional bytes. */
824
825 static int utf8_table2[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
826
827 /* Get the next UTF-8 character, advancing the pointer. */
828
829 #define GETUTF8INC(c, ptr) \
830 c = *ptr++; \
831 if ((c & 0xc0) == 0xc0) \
832 { \
833 int a = utf8_table1[c & 0x3f]; /* Number of additional bytes */ \
834 int s = 6*a; \
835 c = (c & utf8_table2[a]) << s; \
836 while (a-- > 0) \
837 { \
838 s -= 6; \
839 c |= (*ptr++ & 0x3f) << s; \
840 } \
841 }
842
843
844 /*************************************************
845 * Binary chop search on a table *
846 *************************************************/
847
848 /* This is used for matching expansion items and operators.
849
850 Arguments:
851 name the name that is being sought
852 table the table to search
853 table_size the number of items in the table
854
855 Returns: the offset in the table, or -1
856 */
857
858 static int
859 chop_match(uschar *name, uschar **table, int table_size)
860 {
861 uschar **bot = table;
862 uschar **top = table + table_size;
863
864 while (top > bot)
865 {
866 uschar **mid = bot + (top - bot)/2;
867 int c = Ustrcmp(name, *mid);
868 if (c == 0) return mid - table;
869 if (c > 0) bot = mid + 1; else top = mid;
870 }
871
872 return -1;
873 }
874
875
876
877 /*************************************************
878 * Check a condition string *
879 *************************************************/
880
881 /* This function is called to expand a string, and test the result for a "true"
882 or "false" value. Failure of the expansion yields FALSE; logged unless it was a
883 forced fail or lookup defer.
884
885 We used to release all store used, but this is not not safe due
886 to ${dlfunc } and ${acl }. In any case expand_string_internal()
887 is reasonably careful to release what it can.
888
889 The actual false-value tests should be replicated for ECOND_BOOL_LAX.
890
891 Arguments:
892 condition the condition string
893 m1 text to be incorporated in panic error
894 m2 ditto
895
896 Returns: TRUE if condition is met, FALSE if not
897 */
898
899 BOOL
900 expand_check_condition(uschar *condition, uschar *m1, uschar *m2)
901 {
902 int rc;
903 uschar *ss = expand_string(condition);
904 if (ss == NULL)
905 {
906 if (!expand_string_forcedfail && !search_find_defer)
907 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand condition \"%s\" "
908 "for %s %s: %s", condition, m1, m2, expand_string_message);
909 return FALSE;
910 }
911 rc = ss[0] != 0 && Ustrcmp(ss, "0") != 0 && strcmpic(ss, US"no") != 0 &&
912 strcmpic(ss, US"false") != 0;
913 return rc;
914 }
915
916
917
918
919 /*************************************************
920 * Pseudo-random number generation *
921 *************************************************/
922
923 /* Pseudo-random number generation. The result is not "expected" to be
924 cryptographically strong but not so weak that someone will shoot themselves
925 in the foot using it as a nonce in some email header scheme or whatever
926 weirdness they'll twist this into. The result should ideally handle fork().
927
928 However, if we're stuck unable to provide this, then we'll fall back to
929 appallingly bad randomness.
930
931 If SUPPORT_TLS is defined then this will not be used except as an emergency
932 fallback.
933
934 Arguments:
935 max range maximum
936 Returns a random number in range [0, max-1]
937 */
938
939 #ifdef SUPPORT_TLS
940 # define vaguely_random_number vaguely_random_number_fallback
941 #endif
942 int
943 vaguely_random_number(int max)
944 {
945 #ifdef SUPPORT_TLS
946 # undef vaguely_random_number
947 #endif
948 static pid_t pid = 0;
949 pid_t p2;
950 #if defined(HAVE_SRANDOM) && !defined(HAVE_SRANDOMDEV)
951 struct timeval tv;
952 #endif
953
954 p2 = getpid();
955 if (p2 != pid)
956 {
957 if (pid != 0)
958 {
959
960 #ifdef HAVE_ARC4RANDOM
961 /* cryptographically strong randomness, common on *BSD platforms, not
962 so much elsewhere. Alas. */
963 #ifndef NOT_HAVE_ARC4RANDOM_STIR
964 arc4random_stir();
965 #endif
966 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
967 #ifdef HAVE_SRANDOMDEV
968 /* uses random(4) for seeding */
969 srandomdev();
970 #else
971 gettimeofday(&tv, NULL);
972 srandom(tv.tv_sec | tv.tv_usec | getpid());
973 #endif
974 #else
975 /* Poor randomness and no seeding here */
976 #endif
977
978 }
979 pid = p2;
980 }
981
982 #ifdef HAVE_ARC4RANDOM
983 return arc4random() % max;
984 #elif defined(HAVE_SRANDOM) || defined(HAVE_SRANDOMDEV)
985 return random() % max;
986 #else
987 /* This one returns a 16-bit number, definitely not crypto-strong */
988 return random_number(max);
989 #endif
990 }
991
992
993
994
995 /*************************************************
996 * Pick out a name from a string *
997 *************************************************/
998
999 /* If the name is too long, it is silently truncated.
1000
1001 Arguments:
1002 name points to a buffer into which to put the name
1003 max is the length of the buffer
1004 s points to the first alphabetic character of the name
1005 extras chars other than alphanumerics to permit
1006
1007 Returns: pointer to the first character after the name
1008
1009 Note: The test for *s != 0 in the while loop is necessary because
1010 Ustrchr() yields non-NULL if the character is zero (which is not something
1011 I expected). */
1012
1013 static const uschar *
1014 read_name(uschar *name, int max, const uschar *s, uschar *extras)
1015 {
1016 int ptr = 0;
1017 while (*s != 0 && (isalnum(*s) || Ustrchr(extras, *s) != NULL))
1018 {
1019 if (ptr < max-1) name[ptr++] = *s;
1020 s++;
1021 }
1022 name[ptr] = 0;
1023 return s;
1024 }
1025
1026
1027
1028 /*************************************************
1029 * Pick out the rest of a header name *
1030 *************************************************/
1031
1032 /* A variable name starting $header_ (or just $h_ for those who like
1033 abbreviations) might not be the complete header name because headers can
1034 contain any printing characters in their names, except ':'. This function is
1035 called to read the rest of the name, chop h[eader]_ off the front, and put ':'
1036 on the end, if the name was terminated by white space.
1037
1038 Arguments:
1039 name points to a buffer in which the name read so far exists
1040 max is the length of the buffer
1041 s points to the first character after the name so far, i.e. the
1042 first non-alphameric character after $header_xxxxx
1043
1044 Returns: a pointer to the first character after the header name
1045 */
1046
1047 static const uschar *
1048 read_header_name(uschar *name, int max, const uschar *s)
1049 {
1050 int prelen = Ustrchr(name, '_') - name + 1;
1051 int ptr = Ustrlen(name) - prelen;
1052 if (ptr > 0) memmove(name, name+prelen, ptr);
1053 while (mac_isgraph(*s) && *s != ':')
1054 {
1055 if (ptr < max-1) name[ptr++] = *s;
1056 s++;
1057 }
1058 if (*s == ':') s++;
1059 name[ptr++] = ':';
1060 name[ptr] = 0;
1061 return s;
1062 }
1063
1064
1065
1066 /*************************************************
1067 * Pick out a number from a string *
1068 *************************************************/
1069
1070 /* Arguments:
1071 n points to an integer into which to put the number
1072 s points to the first digit of the number
1073
1074 Returns: a pointer to the character after the last digit
1075 */
1076 /*XXX consider expanding to int_eximarith_t. But the test for
1077 "overbig numbers" in 0002 still needs to overflow it. */
1078
1079 static uschar *
1080 read_number(int *n, uschar *s)
1081 {
1082 *n = 0;
1083 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1084 return s;
1085 }
1086
1087 static const uschar *
1088 read_cnumber(int *n, const uschar *s)
1089 {
1090 *n = 0;
1091 while (isdigit(*s)) *n = *n * 10 + (*s++ - '0');
1092 return s;
1093 }
1094
1095
1096
1097 /*************************************************
1098 * Extract keyed subfield from a string *
1099 *************************************************/
1100
1101 /* The yield is in dynamic store; NULL means that the key was not found.
1102
1103 Arguments:
1104 key points to the name of the key
1105 s points to the string from which to extract the subfield
1106
1107 Returns: NULL if the subfield was not found, or
1108 a pointer to the subfield's data
1109 */
1110
1111 static uschar *
1112 expand_getkeyed(uschar *key, const uschar *s)
1113 {
1114 int length = Ustrlen(key);
1115 while (isspace(*s)) s++;
1116
1117 /* Loop to search for the key */
1118
1119 while (*s != 0)
1120 {
1121 int dkeylength;
1122 uschar *data;
1123 const uschar *dkey = s;
1124
1125 while (*s != 0 && *s != '=' && !isspace(*s)) s++;
1126 dkeylength = s - dkey;
1127 while (isspace(*s)) s++;
1128 if (*s == '=') while (isspace((*(++s))));
1129
1130 data = string_dequote(&s);
1131 if (length == dkeylength && strncmpic(key, dkey, length) == 0)
1132 return data;
1133
1134 while (isspace(*s)) s++;
1135 }
1136
1137 return NULL;
1138 }
1139
1140
1141
1142 static var_entry *
1143 find_var_ent(uschar * name)
1144 {
1145 int first = 0;
1146 int last = var_table_size;
1147
1148 while (last > first)
1149 {
1150 int middle = (first + last)/2;
1151 int c = Ustrcmp(name, var_table[middle].name);
1152
1153 if (c > 0) { first = middle + 1; continue; }
1154 if (c < 0) { last = middle; continue; }
1155 return &var_table[middle];
1156 }
1157 return NULL;
1158 }
1159
1160 /*************************************************
1161 * Extract numbered subfield from string *
1162 *************************************************/
1163
1164 /* Extracts a numbered field from a string that is divided by tokens - for
1165 example a line from /etc/passwd is divided by colon characters. First field is
1166 numbered one. Negative arguments count from the right. Zero returns the whole
1167 string. Returns NULL if there are insufficient tokens in the string
1168
1169 ***WARNING***
1170 Modifies final argument - this is a dynamically generated string, so that's OK.
1171
1172 Arguments:
1173 field number of field to be extracted,
1174 first field = 1, whole string = 0, last field = -1
1175 separators characters that are used to break string into tokens
1176 s points to the string from which to extract the subfield
1177
1178 Returns: NULL if the field was not found,
1179 a pointer to the field's data inside s (modified to add 0)
1180 */
1181
1182 static uschar *
1183 expand_gettokened (int field, uschar *separators, uschar *s)
1184 {
1185 int sep = 1;
1186 int count;
1187 uschar *ss = s;
1188 uschar *fieldtext = NULL;
1189
1190 if (field == 0) return s;
1191
1192 /* Break the line up into fields in place; for field > 0 we stop when we have
1193 done the number of fields we want. For field < 0 we continue till the end of
1194 the string, counting the number of fields. */
1195
1196 count = (field > 0)? field : INT_MAX;
1197
1198 while (count-- > 0)
1199 {
1200 size_t len;
1201
1202 /* Previous field was the last one in the string. For a positive field
1203 number, this means there are not enough fields. For a negative field number,
1204 check that there are enough, and scan back to find the one that is wanted. */
1205
1206 if (sep == 0)
1207 {
1208 if (field > 0 || (-field) > (INT_MAX - count - 1)) return NULL;
1209 if ((-field) == (INT_MAX - count - 1)) return s;
1210 while (field++ < 0)
1211 {
1212 ss--;
1213 while (ss[-1] != 0) ss--;
1214 }
1215 fieldtext = ss;
1216 break;
1217 }
1218
1219 /* Previous field was not last in the string; save its start and put a
1220 zero at its end. */
1221
1222 fieldtext = ss;
1223 len = Ustrcspn(ss, separators);
1224 sep = ss[len];
1225 ss[len] = 0;
1226 ss += len + 1;
1227 }
1228
1229 return fieldtext;
1230 }
1231
1232
1233 static uschar *
1234 expand_getlistele(int field, const uschar * list)
1235 {
1236 const uschar * tlist= list;
1237 int sep= 0;
1238 uschar dummy;
1239
1240 if(field<0)
1241 {
1242 for(field++; string_nextinlist(&tlist, &sep, &dummy, 1); ) field++;
1243 sep= 0;
1244 }
1245 if(field==0) return NULL;
1246 while(--field>0 && (string_nextinlist(&list, &sep, &dummy, 1))) ;
1247 return string_nextinlist(&list, &sep, NULL, 0);
1248 }
1249
1250
1251 /* Certificate fields, by name. Worry about by-OID later */
1252 /* Names are chosen to not have common prefixes */
1253
1254 #ifdef SUPPORT_TLS
1255 typedef struct
1256 {
1257 uschar * name;
1258 int namelen;
1259 uschar * (*getfn)(void * cert, uschar * mod);
1260 } certfield;
1261 static certfield certfields[] =
1262 { /* linear search; no special order */
1263 { US"version", 7, &tls_cert_version },
1264 { US"serial_number", 13, &tls_cert_serial_number },
1265 { US"subject", 7, &tls_cert_subject },
1266 { US"notbefore", 9, &tls_cert_not_before },
1267 { US"notafter", 8, &tls_cert_not_after },
1268 { US"issuer", 6, &tls_cert_issuer },
1269 { US"signature", 9, &tls_cert_signature },
1270 { US"sig_algorithm", 13, &tls_cert_signature_algorithm },
1271 { US"subj_altname", 12, &tls_cert_subject_altname },
1272 { US"ocsp_uri", 8, &tls_cert_ocsp_uri },
1273 { US"crl_uri", 7, &tls_cert_crl_uri },
1274 };
1275
1276 static uschar *
1277 expand_getcertele(uschar * field, uschar * certvar)
1278 {
1279 var_entry * vp;
1280 certfield * cp;
1281
1282 if (!(vp = find_var_ent(certvar)))
1283 {
1284 expand_string_message =
1285 string_sprintf("no variable named \"%s\"", certvar);
1286 return NULL; /* Unknown variable name */
1287 }
1288 /* NB this stops us passing certs around in variable. Might
1289 want to do that in future */
1290 if (vp->type != vtype_cert)
1291 {
1292 expand_string_message =
1293 string_sprintf("\"%s\" is not a certificate", certvar);
1294 return NULL; /* Unknown variable name */
1295 }
1296 if (!*(void **)vp->value)
1297 return NULL;
1298
1299 if (*field >= '0' && *field <= '9')
1300 return tls_cert_ext_by_oid(*(void **)vp->value, field, 0);
1301
1302 for(cp = certfields;
1303 cp < certfields + nelem(certfields);
1304 cp++)
1305 if (Ustrncmp(cp->name, field, cp->namelen) == 0)
1306 {
1307 uschar * modifier = *(field += cp->namelen) == ','
1308 ? ++field : NULL;
1309 return (*cp->getfn)( *(void **)vp->value, modifier );
1310 }
1311
1312 expand_string_message =
1313 string_sprintf("bad field selector \"%s\" for certextract", field);
1314 return NULL;
1315 }
1316 #endif /*SUPPORT_TLS*/
1317
1318 /*************************************************
1319 * Extract a substring from a string *
1320 *************************************************/
1321
1322 /* Perform the ${substr or ${length expansion operations.
1323
1324 Arguments:
1325 subject the input string
1326 value1 the offset from the start of the input string to the start of
1327 the output string; if negative, count from the right.
1328 value2 the length of the output string, or negative (-1) for unset
1329 if value1 is positive, unset means "all after"
1330 if value1 is negative, unset means "all before"
1331 len set to the length of the returned string
1332
1333 Returns: pointer to the output string, or NULL if there is an error
1334 */
1335
1336 static uschar *
1337 extract_substr(uschar *subject, int value1, int value2, int *len)
1338 {
1339 int sublen = Ustrlen(subject);
1340
1341 if (value1 < 0) /* count from right */
1342 {
1343 value1 += sublen;
1344
1345 /* If the position is before the start, skip to the start, and adjust the
1346 length. If the length ends up negative, the substring is null because nothing
1347 can precede. This falls out naturally when the length is unset, meaning "all
1348 to the left". */
1349
1350 if (value1 < 0)
1351 {
1352 value2 += value1;
1353 if (value2 < 0) value2 = 0;
1354 value1 = 0;
1355 }
1356
1357 /* Otherwise an unset length => characters before value1 */
1358
1359 else if (value2 < 0)
1360 {
1361 value2 = value1;
1362 value1 = 0;
1363 }
1364 }
1365
1366 /* For a non-negative offset, if the starting position is past the end of the
1367 string, the result will be the null string. Otherwise, an unset length means
1368 "rest"; just set it to the maximum - it will be cut down below if necessary. */
1369
1370 else
1371 {
1372 if (value1 > sublen)
1373 {
1374 value1 = sublen;
1375 value2 = 0;
1376 }
1377 else if (value2 < 0) value2 = sublen;
1378 }
1379
1380 /* Cut the length down to the maximum possible for the offset value, and get
1381 the required characters. */
1382
1383 if (value1 + value2 > sublen) value2 = sublen - value1;
1384 *len = value2;
1385 return subject + value1;
1386 }
1387
1388
1389
1390
1391 /*************************************************
1392 * Old-style hash of a string *
1393 *************************************************/
1394
1395 /* Perform the ${hash expansion operation.
1396
1397 Arguments:
1398 subject the input string (an expanded substring)
1399 value1 the length of the output string; if greater or equal to the
1400 length of the input string, the input string is returned
1401 value2 the number of hash characters to use, or 26 if negative
1402 len set to the length of the returned string
1403
1404 Returns: pointer to the output string, or NULL if there is an error
1405 */
1406
1407 static uschar *
1408 compute_hash(uschar *subject, int value1, int value2, int *len)
1409 {
1410 int sublen = Ustrlen(subject);
1411
1412 if (value2 < 0) value2 = 26;
1413 else if (value2 > Ustrlen(hashcodes))
1414 {
1415 expand_string_message =
1416 string_sprintf("hash count \"%d\" too big", value2);
1417 return NULL;
1418 }
1419
1420 /* Calculate the hash text. We know it is shorter than the original string, so
1421 can safely place it in subject[] (we know that subject is always itself an
1422 expanded substring). */
1423
1424 if (value1 < sublen)
1425 {
1426 int c;
1427 int i = 0;
1428 int j = value1;
1429 while ((c = (subject[j])) != 0)
1430 {
1431 int shift = (c + j++) & 7;
1432 subject[i] ^= (c << shift) | (c >> (8-shift));
1433 if (++i >= value1) i = 0;
1434 }
1435 for (i = 0; i < value1; i++)
1436 subject[i] = hashcodes[(subject[i]) % value2];
1437 }
1438 else value1 = sublen;
1439
1440 *len = value1;
1441 return subject;
1442 }
1443
1444
1445
1446
1447 /*************************************************
1448 * Numeric hash of a string *
1449 *************************************************/
1450
1451 /* Perform the ${nhash expansion operation. The first characters of the
1452 string are treated as most important, and get the highest prime numbers.
1453
1454 Arguments:
1455 subject the input string
1456 value1 the maximum value of the first part of the result
1457 value2 the maximum value of the second part of the result,
1458 or negative to produce only a one-part result
1459 len set to the length of the returned string
1460
1461 Returns: pointer to the output string, or NULL if there is an error.
1462 */
1463
1464 static uschar *
1465 compute_nhash (uschar *subject, int value1, int value2, int *len)
1466 {
1467 uschar *s = subject;
1468 int i = 0;
1469 unsigned long int total = 0; /* no overflow */
1470
1471 while (*s != 0)
1472 {
1473 if (i == 0) i = nelem(prime) - 1;
1474 total += prime[i--] * (unsigned int)(*s++);
1475 }
1476
1477 /* If value2 is unset, just compute one number */
1478
1479 if (value2 < 0)
1480 {
1481 s = string_sprintf("%d", total % value1);
1482 }
1483
1484 /* Otherwise do a div/mod hash */
1485
1486 else
1487 {
1488 total = total % (value1 * value2);
1489 s = string_sprintf("%d/%d", total/value2, total % value2);
1490 }
1491
1492 *len = Ustrlen(s);
1493 return s;
1494 }
1495
1496
1497
1498
1499
1500 /*************************************************
1501 * Find the value of a header or headers *
1502 *************************************************/
1503
1504 /* Multiple instances of the same header get concatenated, and this function
1505 can also return a concatenation of all the header lines. When concatenating
1506 specific headers that contain lists of addresses, a comma is inserted between
1507 them. Otherwise we use a straight concatenation. Because some messages can have
1508 pathologically large number of lines, there is a limit on the length that is
1509 returned. Also, to avoid massive store use which would result from using
1510 string_cat() as it copies and extends strings, we do a preliminary pass to find
1511 out exactly how much store will be needed. On "normal" messages this will be
1512 pretty trivial.
1513
1514 Arguments:
1515 name the name of the header, without the leading $header_ or $h_,
1516 or NULL if a concatenation of all headers is required
1517 exists_only TRUE if called from a def: test; don't need to build a string;
1518 just return a string that is not "" and not "0" if the header
1519 exists
1520 newsize return the size of memory block that was obtained; may be NULL
1521 if exists_only is TRUE
1522 want_raw TRUE if called for $rh_ or $rheader_ variables; no processing,
1523 other than concatenating, will be done on the header. Also used
1524 for $message_headers_raw.
1525 charset name of charset to translate MIME words to; used only if
1526 want_raw is false; if NULL, no translation is done (this is
1527 used for $bh_ and $bheader_)
1528
1529 Returns: NULL if the header does not exist, else a pointer to a new
1530 store block
1531 */
1532
1533 static uschar *
1534 find_header(uschar *name, BOOL exists_only, int *newsize, BOOL want_raw,
1535 uschar *charset)
1536 {
1537 BOOL found = name == NULL;
1538 int comma = 0;
1539 int len = found? 0 : Ustrlen(name);
1540 int i;
1541 uschar *yield = NULL;
1542 uschar *ptr = NULL;
1543
1544 /* Loop for two passes - saves code repetition */
1545
1546 for (i = 0; i < 2; i++)
1547 {
1548 int size = 0;
1549 header_line *h;
1550
1551 for (h = header_list; size < header_insert_maxlen && h != NULL; h = h->next)
1552 {
1553 if (h->type != htype_old && h->text != NULL) /* NULL => Received: placeholder */
1554 {
1555 if (name == NULL || (len <= h->slen && strncmpic(name, h->text, len) == 0))
1556 {
1557 int ilen;
1558 uschar *t;
1559
1560 if (exists_only) return US"1"; /* don't need actual string */
1561 found = TRUE;
1562 t = h->text + len; /* text to insert */
1563 if (!want_raw) /* unless wanted raw, */
1564 while (isspace(*t)) t++; /* remove leading white space */
1565 ilen = h->slen - (t - h->text); /* length to insert */
1566
1567 /* Unless wanted raw, remove trailing whitespace, including the
1568 newline. */
1569
1570 if (!want_raw)
1571 while (ilen > 0 && isspace(t[ilen-1])) ilen--;
1572
1573 /* Set comma = 1 if handling a single header and it's one of those
1574 that contains an address list, except when asked for raw headers. Only
1575 need to do this once. */
1576
1577 if (!want_raw && name != NULL && comma == 0 &&
1578 Ustrchr("BCFRST", h->type) != NULL)
1579 comma = 1;
1580
1581 /* First pass - compute total store needed; second pass - compute
1582 total store used, including this header. */
1583
1584 size += ilen + comma + 1; /* +1 for the newline */
1585
1586 /* Second pass - concatentate the data, up to a maximum. Note that
1587 the loop stops when size hits the limit. */
1588
1589 if (i != 0)
1590 {
1591 if (size > header_insert_maxlen)
1592 {
1593 ilen -= size - header_insert_maxlen - 1;
1594 comma = 0;
1595 }
1596 Ustrncpy(ptr, t, ilen);
1597 ptr += ilen;
1598
1599 /* For a non-raw header, put in the comma if needed, then add
1600 back the newline we removed above, provided there was some text in
1601 the header. */
1602
1603 if (!want_raw && ilen > 0)
1604 {
1605 if (comma != 0) *ptr++ = ',';
1606 *ptr++ = '\n';
1607 }
1608 }
1609 }
1610 }
1611 }
1612
1613 /* At end of first pass, return NULL if no header found. Then truncate size
1614 if necessary, and get the buffer to hold the data, returning the buffer size.
1615 */
1616
1617 if (i == 0)
1618 {
1619 if (!found) return NULL;
1620 if (size > header_insert_maxlen) size = header_insert_maxlen;
1621 *newsize = size + 1;
1622 ptr = yield = store_get(*newsize);
1623 }
1624 }
1625
1626 /* That's all we do for raw header expansion. */
1627
1628 if (want_raw)
1629 {
1630 *ptr = 0;
1631 }
1632
1633 /* Otherwise, remove a final newline and a redundant added comma. Then we do
1634 RFC 2047 decoding, translating the charset if requested. The rfc2047_decode2()
1635 function can return an error with decoded data if the charset translation
1636 fails. If decoding fails, it returns NULL. */
1637
1638 else
1639 {
1640 uschar *decoded, *error;
1641 if (ptr > yield && ptr[-1] == '\n') ptr--;
1642 if (ptr > yield && comma != 0 && ptr[-1] == ',') ptr--;
1643 *ptr = 0;
1644 decoded = rfc2047_decode2(yield, check_rfc2047_length, charset, '?', NULL,
1645 newsize, &error);
1646 if (error != NULL)
1647 {
1648 DEBUG(D_any) debug_printf("*** error in RFC 2047 decoding: %s\n"
1649 " input was: %s\n", error, yield);
1650 }
1651 if (decoded != NULL) yield = decoded;
1652 }
1653
1654 return yield;
1655 }
1656
1657
1658
1659
1660 /*************************************************
1661 * Return list of recipients *
1662 *************************************************/
1663 /* A recipients list is available only during system message filtering,
1664 during ACL processing after DATA, and while expanding pipe commands
1665 generated from a system filter, but not elsewhere. */
1666
1667 static uschar *
1668 fn_recipients(void)
1669 {
1670 if (!enable_dollar_recipients) return NULL; else
1671 {
1672 int size = 128;
1673 int ptr = 0;
1674 int i;
1675 uschar * s = store_get(size);
1676 for (i = 0; i < recipients_count; i++)
1677 {
1678 if (i != 0) s = string_cat(s, &size, &ptr, US", ", 2);
1679 s = string_cat(s, &size, &ptr, recipients_list[i].address,
1680 Ustrlen(recipients_list[i].address));
1681 }
1682 s[ptr] = 0; /* string_cat() leaves room */
1683 return s;
1684 }
1685 }
1686
1687
1688 /*************************************************
1689 * Find value of a variable *
1690 *************************************************/
1691
1692 /* The table of variables is kept in alphabetic order, so we can search it
1693 using a binary chop. The "choplen" variable is nothing to do with the binary
1694 chop.
1695
1696 Arguments:
1697 name the name of the variable being sought
1698 exists_only TRUE if this is a def: test; passed on to find_header()
1699 skipping TRUE => skip any processing evaluation; this is not the same as
1700 exists_only because def: may test for values that are first
1701 evaluated here
1702 newsize pointer to an int which is initially zero; if the answer is in
1703 a new memory buffer, *newsize is set to its size
1704
1705 Returns: NULL if the variable does not exist, or
1706 a pointer to the variable's contents, or
1707 something non-NULL if exists_only is TRUE
1708 */
1709
1710 static uschar *
1711 find_variable(uschar *name, BOOL exists_only, BOOL skipping, int *newsize)
1712 {
1713 var_entry * vp;
1714 uschar *s, *domain;
1715 uschar **ss;
1716 void * val;
1717
1718 /* Handle ACL variables, whose names are of the form acl_cxxx or acl_mxxx.
1719 Originally, xxx had to be a number in the range 0-9 (later 0-19), but from
1720 release 4.64 onwards arbitrary names are permitted, as long as the first 5
1721 characters are acl_c or acl_m and the sixth is either a digit or an underscore
1722 (this gave backwards compatibility at the changeover). There may be built-in
1723 variables whose names start acl_ but they should never start in this way. This
1724 slightly messy specification is a consequence of the history, needless to say.
1725
1726 If an ACL variable does not exist, treat it as empty, unless strict_acl_vars is
1727 set, in which case give an error. */
1728
1729 if ((Ustrncmp(name, "acl_c", 5) == 0 || Ustrncmp(name, "acl_m", 5) == 0) &&
1730 !isalpha(name[5]))
1731 {
1732 tree_node *node =
1733 tree_search((name[4] == 'c')? acl_var_c : acl_var_m, name + 4);
1734 return node ? node->data.ptr : strict_acl_vars ? NULL : US"";
1735 }
1736
1737 /* Handle $auth<n> variables. */
1738
1739 if (Ustrncmp(name, "auth", 4) == 0)
1740 {
1741 uschar *endptr;
1742 int n = Ustrtoul(name + 4, &endptr, 10);
1743 if (*endptr == 0 && n != 0 && n <= AUTH_VARS)
1744 return !auth_vars[n-1] ? US"" : auth_vars[n-1];
1745 }
1746 else if (Ustrncmp(name, "regex", 5) == 0)
1747 {
1748 uschar *endptr;
1749 int n = Ustrtoul(name + 5, &endptr, 10);
1750 if (*endptr == 0 && n != 0 && n <= REGEX_VARS)
1751 return !regex_vars[n-1] ? US"" : regex_vars[n-1];
1752 }
1753
1754 /* For all other variables, search the table */
1755
1756 if (!(vp = find_var_ent(name)))
1757 return NULL; /* Unknown variable name */
1758
1759 /* Found an existing variable. If in skipping state, the value isn't needed,
1760 and we want to avoid processing (such as looking up the host name). */
1761
1762 if (skipping)
1763 return US"";
1764
1765 val = vp->value;
1766 switch (vp->type)
1767 {
1768 case vtype_filter_int:
1769 if (!filter_running) return NULL;
1770 /* Fall through */
1771 /* VVVVVVVVVVVV */
1772 case vtype_int:
1773 sprintf(CS var_buffer, "%d", *(int *)(val)); /* Integer */
1774 return var_buffer;
1775
1776 case vtype_ino:
1777 sprintf(CS var_buffer, "%ld", (long int)(*(ino_t *)(val))); /* Inode */
1778 return var_buffer;
1779
1780 case vtype_gid:
1781 sprintf(CS var_buffer, "%ld", (long int)(*(gid_t *)(val))); /* gid */
1782 return var_buffer;
1783
1784 case vtype_uid:
1785 sprintf(CS var_buffer, "%ld", (long int)(*(uid_t *)(val))); /* uid */
1786 return var_buffer;
1787
1788 case vtype_bool:
1789 sprintf(CS var_buffer, "%s", *(BOOL *)(val) ? "yes" : "no"); /* bool */
1790 return var_buffer;
1791
1792 case vtype_stringptr: /* Pointer to string */
1793 return (s = *((uschar **)(val))) ? s : US"";
1794
1795 case vtype_pid:
1796 sprintf(CS var_buffer, "%d", (int)getpid()); /* pid */
1797 return var_buffer;
1798
1799 case vtype_load_avg:
1800 sprintf(CS var_buffer, "%d", OS_GETLOADAVG()); /* load_average */
1801 return var_buffer;
1802
1803 case vtype_host_lookup: /* Lookup if not done so */
1804 if (sender_host_name == NULL && sender_host_address != NULL &&
1805 !host_lookup_failed && host_name_lookup() == OK)
1806 host_build_sender_fullhost();
1807 return (sender_host_name == NULL)? US"" : sender_host_name;
1808
1809 case vtype_localpart: /* Get local part from address */
1810 s = *((uschar **)(val));
1811 if (s == NULL) return US"";
1812 domain = Ustrrchr(s, '@');
1813 if (domain == NULL) return s;
1814 if (domain - s > sizeof(var_buffer) - 1)
1815 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "local part longer than " SIZE_T_FMT
1816 " in string expansion", sizeof(var_buffer));
1817 Ustrncpy(var_buffer, s, domain - s);
1818 var_buffer[domain - s] = 0;
1819 return var_buffer;
1820
1821 case vtype_domain: /* Get domain from address */
1822 s = *((uschar **)(val));
1823 if (s == NULL) return US"";
1824 domain = Ustrrchr(s, '@');
1825 return (domain == NULL)? US"" : domain + 1;
1826
1827 case vtype_msgheaders:
1828 return find_header(NULL, exists_only, newsize, FALSE, NULL);
1829
1830 case vtype_msgheaders_raw:
1831 return find_header(NULL, exists_only, newsize, TRUE, NULL);
1832
1833 case vtype_msgbody: /* Pointer to msgbody string */
1834 case vtype_msgbody_end: /* Ditto, the end of the msg */
1835 ss = (uschar **)(val);
1836 if (*ss == NULL && deliver_datafile >= 0) /* Read body when needed */
1837 {
1838 uschar *body;
1839 off_t start_offset = SPOOL_DATA_START_OFFSET;
1840 int len = message_body_visible;
1841 if (len > message_size) len = message_size;
1842 *ss = body = store_malloc(len+1);
1843 body[0] = 0;
1844 if (vp->type == vtype_msgbody_end)
1845 {
1846 struct stat statbuf;
1847 if (fstat(deliver_datafile, &statbuf) == 0)
1848 {
1849 start_offset = statbuf.st_size - len;
1850 if (start_offset < SPOOL_DATA_START_OFFSET)
1851 start_offset = SPOOL_DATA_START_OFFSET;
1852 }
1853 }
1854 lseek(deliver_datafile, start_offset, SEEK_SET);
1855 len = read(deliver_datafile, body, len);
1856 if (len > 0)
1857 {
1858 body[len] = 0;
1859 if (message_body_newlines) /* Separate loops for efficiency */
1860 while (len > 0)
1861 { if (body[--len] == 0) body[len] = ' '; }
1862 else
1863 while (len > 0)
1864 { if (body[--len] == '\n' || body[len] == 0) body[len] = ' '; }
1865 }
1866 }
1867 return (*ss == NULL)? US"" : *ss;
1868
1869 case vtype_todbsdin: /* BSD inbox time of day */
1870 return tod_stamp(tod_bsdin);
1871
1872 case vtype_tode: /* Unix epoch time of day */
1873 return tod_stamp(tod_epoch);
1874
1875 case vtype_todel: /* Unix epoch/usec time of day */
1876 return tod_stamp(tod_epoch_l);
1877
1878 case vtype_todf: /* Full time of day */
1879 return tod_stamp(tod_full);
1880
1881 case vtype_todl: /* Log format time of day */
1882 return tod_stamp(tod_log_bare); /* (without timezone) */
1883
1884 case vtype_todzone: /* Time zone offset only */
1885 return tod_stamp(tod_zone);
1886
1887 case vtype_todzulu: /* Zulu time */
1888 return tod_stamp(tod_zulu);
1889
1890 case vtype_todlf: /* Log file datestamp tod */
1891 return tod_stamp(tod_log_datestamp_daily);
1892
1893 case vtype_reply: /* Get reply address */
1894 s = find_header(US"reply-to:", exists_only, newsize, TRUE,
1895 headers_charset);
1896 if (s != NULL) while (isspace(*s)) s++;
1897 if (s == NULL || *s == 0)
1898 {
1899 *newsize = 0; /* For the *s==0 case */
1900 s = find_header(US"from:", exists_only, newsize, TRUE, headers_charset);
1901 }
1902 if (s != NULL)
1903 {
1904 uschar *t;
1905 while (isspace(*s)) s++;
1906 for (t = s; *t != 0; t++) if (*t == '\n') *t = ' ';
1907 while (t > s && isspace(t[-1])) t--;
1908 *t = 0;
1909 }
1910 return (s == NULL)? US"" : s;
1911
1912 case vtype_string_func:
1913 {
1914 uschar * (*fn)() = val;
1915 return fn();
1916 }
1917
1918 case vtype_pspace:
1919 {
1920 int inodes;
1921 sprintf(CS var_buffer, "%d",
1922 receive_statvfs(val == (void *)TRUE, &inodes));
1923 }
1924 return var_buffer;
1925
1926 case vtype_pinodes:
1927 {
1928 int inodes;
1929 (void) receive_statvfs(val == (void *)TRUE, &inodes);
1930 sprintf(CS var_buffer, "%d", inodes);
1931 }
1932 return var_buffer;
1933
1934 case vtype_cert:
1935 return *(void **)val ? US"<cert>" : US"";
1936
1937 #ifndef DISABLE_DKIM
1938 case vtype_dkim:
1939 return dkim_exim_expand_query((int)(long)val);
1940 #endif
1941
1942 }
1943
1944 return NULL; /* Unknown variable. Silences static checkers. */
1945 }
1946
1947
1948
1949
1950 void
1951 modify_variable(uschar *name, void * value)
1952 {
1953 var_entry * vp;
1954 if ((vp = find_var_ent(name))) vp->value = value;
1955 return; /* Unknown variable name, fail silently */
1956 }
1957
1958
1959
1960
1961
1962 /*************************************************
1963 * Read and expand substrings *
1964 *************************************************/
1965
1966 /* This function is called to read and expand argument substrings for various
1967 expansion items. Some have a minimum requirement that is less than the maximum;
1968 in these cases, the first non-present one is set to NULL.
1969
1970 Arguments:
1971 sub points to vector of pointers to set
1972 n maximum number of substrings
1973 m minimum required
1974 sptr points to current string pointer
1975 skipping the skipping flag
1976 check_end if TRUE, check for final '}'
1977 name name of item, for error message
1978 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
1979 the store.
1980
1981 Returns: 0 OK; string pointer updated
1982 1 curly bracketing error (too few arguments)
1983 2 too many arguments (only if check_end is set); message set
1984 3 other error (expansion failure)
1985 */
1986
1987 static int
1988 read_subs(uschar **sub, int n, int m, const uschar **sptr, BOOL skipping,
1989 BOOL check_end, uschar *name, BOOL *resetok)
1990 {
1991 int i;
1992 const uschar *s = *sptr;
1993
1994 while (isspace(*s)) s++;
1995 for (i = 0; i < n; i++)
1996 {
1997 if (*s != '{')
1998 {
1999 if (i < m) return 1;
2000 sub[i] = NULL;
2001 break;
2002 }
2003 sub[i] = expand_string_internal(s+1, TRUE, &s, skipping, TRUE, resetok);
2004 if (sub[i] == NULL) return 3;
2005 if (*s++ != '}') return 1;
2006 while (isspace(*s)) s++;
2007 }
2008 if (check_end && *s++ != '}')
2009 {
2010 if (s[-1] == '{')
2011 {
2012 expand_string_message = string_sprintf("Too many arguments for \"%s\" "
2013 "(max is %d)", name, n);
2014 return 2;
2015 }
2016 return 1;
2017 }
2018
2019 *sptr = s;
2020 return 0;
2021 }
2022
2023
2024
2025
2026 /*************************************************
2027 * Elaborate message for bad variable *
2028 *************************************************/
2029
2030 /* For the "unknown variable" message, take a look at the variable's name, and
2031 give additional information about possible ACL variables. The extra information
2032 is added on to expand_string_message.
2033
2034 Argument: the name of the variable
2035 Returns: nothing
2036 */
2037
2038 static void
2039 check_variable_error_message(uschar *name)
2040 {
2041 if (Ustrncmp(name, "acl_", 4) == 0)
2042 expand_string_message = string_sprintf("%s (%s)", expand_string_message,
2043 (name[4] == 'c' || name[4] == 'm')?
2044 (isalpha(name[5])?
2045 US"6th character of a user-defined ACL variable must be a digit or underscore" :
2046 US"strict_acl_vars is set" /* Syntax is OK, it has to be this */
2047 ) :
2048 US"user-defined ACL variables must start acl_c or acl_m");
2049 }
2050
2051
2052
2053 /*
2054 Load args from sub array to globals, and call acl_check().
2055 Sub array will be corrupted on return.
2056
2057 Returns: OK access is granted by an ACCEPT verb
2058 DISCARD access is granted by a DISCARD verb
2059 FAIL access is denied
2060 FAIL_DROP access is denied; drop the connection
2061 DEFER can't tell at the moment
2062 ERROR disaster
2063 */
2064 static int
2065 eval_acl(uschar ** sub, int nsub, uschar ** user_msgp)
2066 {
2067 int i;
2068 int sav_narg = acl_narg;
2069 int ret;
2070 uschar * dummy_logmsg;
2071 extern int acl_where;
2072
2073 if(--nsub > nelem(acl_arg)) nsub = nelem(acl_arg);
2074 for (i = 0; i < nsub && sub[i+1]; i++)
2075 {
2076 uschar * tmp = acl_arg[i];
2077 acl_arg[i] = sub[i+1]; /* place callers args in the globals */
2078 sub[i+1] = tmp; /* stash the old args using our caller's storage */
2079 }
2080 acl_narg = i;
2081 while (i < nsub)
2082 {
2083 sub[i+1] = acl_arg[i];
2084 acl_arg[i++] = NULL;
2085 }
2086
2087 DEBUG(D_expand)
2088 debug_printf("expanding: acl: %s arg: %s%s\n",
2089 sub[0],
2090 acl_narg>0 ? acl_arg[0] : US"<none>",
2091 acl_narg>1 ? " +more" : "");
2092
2093 ret = acl_eval(acl_where, sub[0], user_msgp, &dummy_logmsg);
2094
2095 for (i = 0; i < nsub; i++)
2096 acl_arg[i] = sub[i+1]; /* restore old args */
2097 acl_narg = sav_narg;
2098
2099 return ret;
2100 }
2101
2102
2103
2104
2105 /*************************************************
2106 * Read and evaluate a condition *
2107 *************************************************/
2108
2109 /*
2110 Arguments:
2111 s points to the start of the condition text
2112 resetok points to a BOOL which is written false if it is unsafe to
2113 free memory. Certain condition types (acl) may have side-effect
2114 allocation which must be preserved.
2115 yield points to a BOOL to hold the result of the condition test;
2116 if NULL, we are just reading through a condition that is
2117 part of an "or" combination to check syntax, or in a state
2118 where the answer isn't required
2119
2120 Returns: a pointer to the first character after the condition, or
2121 NULL after an error
2122 */
2123
2124 static const uschar *
2125 eval_condition(const uschar *s, BOOL *resetok, BOOL *yield)
2126 {
2127 BOOL testfor = TRUE;
2128 BOOL tempcond, combined_cond;
2129 BOOL *subcondptr;
2130 BOOL sub2_honour_dollar = TRUE;
2131 int i, rc, cond_type, roffset;
2132 int_eximarith_t num[2];
2133 struct stat statbuf;
2134 uschar name[256];
2135 const uschar *sub[10];
2136
2137 const pcre *re;
2138 const uschar *rerror;
2139
2140 for (;;)
2141 {
2142 while (isspace(*s)) s++;
2143 if (*s == '!') { testfor = !testfor; s++; } else break;
2144 }
2145
2146 /* Numeric comparisons are symbolic */
2147
2148 if (*s == '=' || *s == '>' || *s == '<')
2149 {
2150 int p = 0;
2151 name[p++] = *s++;
2152 if (*s == '=')
2153 {
2154 name[p++] = '=';
2155 s++;
2156 }
2157 name[p] = 0;
2158 }
2159
2160 /* All other conditions are named */
2161
2162 else s = read_name(name, 256, s, US"_");
2163
2164 /* If we haven't read a name, it means some non-alpha character is first. */
2165
2166 if (name[0] == 0)
2167 {
2168 expand_string_message = string_sprintf("condition name expected, "
2169 "but found \"%.16s\"", s);
2170 return NULL;
2171 }
2172
2173 /* Find which condition we are dealing with, and switch on it */
2174
2175 cond_type = chop_match(name, cond_table, nelem(cond_table));
2176 switch(cond_type)
2177 {
2178 /* def: tests for a non-empty variable, or for the existence of a header. If
2179 yield == NULL we are in a skipping state, and don't care about the answer. */
2180
2181 case ECOND_DEF:
2182 if (*s != ':')
2183 {
2184 expand_string_message = US"\":\" expected after \"def\"";
2185 return NULL;
2186 }
2187
2188 s = read_name(name, 256, s+1, US"_");
2189
2190 /* Test for a header's existence. If the name contains a closing brace
2191 character, this may be a user error where the terminating colon has been
2192 omitted. Set a flag to adjust a subsequent error message in this case. */
2193
2194 if (Ustrncmp(name, "h_", 2) == 0 ||
2195 Ustrncmp(name, "rh_", 3) == 0 ||
2196 Ustrncmp(name, "bh_", 3) == 0 ||
2197 Ustrncmp(name, "header_", 7) == 0 ||
2198 Ustrncmp(name, "rheader_", 8) == 0 ||
2199 Ustrncmp(name, "bheader_", 8) == 0)
2200 {
2201 s = read_header_name(name, 256, s);
2202 /* {-for-text-editors */
2203 if (Ustrchr(name, '}') != NULL) malformed_header = TRUE;
2204 if (yield != NULL) *yield =
2205 (find_header(name, TRUE, NULL, FALSE, NULL) != NULL) == testfor;
2206 }
2207
2208 /* Test for a variable's having a non-empty value. A non-existent variable
2209 causes an expansion failure. */
2210
2211 else
2212 {
2213 uschar *value = find_variable(name, TRUE, yield == NULL, NULL);
2214 if (value == NULL)
2215 {
2216 expand_string_message = (name[0] == 0)?
2217 string_sprintf("variable name omitted after \"def:\"") :
2218 string_sprintf("unknown variable \"%s\" after \"def:\"", name);
2219 check_variable_error_message(name);
2220 return NULL;
2221 }
2222 if (yield != NULL) *yield = (value[0] != 0) == testfor;
2223 }
2224
2225 return s;
2226
2227
2228 /* first_delivery tests for first delivery attempt */
2229
2230 case ECOND_FIRST_DELIVERY:
2231 if (yield != NULL) *yield = deliver_firsttime == testfor;
2232 return s;
2233
2234
2235 /* queue_running tests for any process started by a queue runner */
2236
2237 case ECOND_QUEUE_RUNNING:
2238 if (yield != NULL) *yield = (queue_run_pid != (pid_t)0) == testfor;
2239 return s;
2240
2241
2242 /* exists: tests for file existence
2243 isip: tests for any IP address
2244 isip4: tests for an IPv4 address
2245 isip6: tests for an IPv6 address
2246 pam: does PAM authentication
2247 radius: does RADIUS authentication
2248 ldapauth: does LDAP authentication
2249 pwcheck: does Cyrus SASL pwcheck authentication
2250 */
2251
2252 case ECOND_EXISTS:
2253 case ECOND_ISIP:
2254 case ECOND_ISIP4:
2255 case ECOND_ISIP6:
2256 case ECOND_PAM:
2257 case ECOND_RADIUS:
2258 case ECOND_LDAPAUTH:
2259 case ECOND_PWCHECK:
2260
2261 while (isspace(*s)) s++;
2262 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2263
2264 sub[0] = expand_string_internal(s+1, TRUE, &s, yield == NULL, TRUE, resetok);
2265 if (sub[0] == NULL) return NULL;
2266 /* {-for-text-editors */
2267 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2268
2269 if (yield == NULL) return s; /* No need to run the test if skipping */
2270
2271 switch(cond_type)
2272 {
2273 case ECOND_EXISTS:
2274 if ((expand_forbid & RDO_EXISTS) != 0)
2275 {
2276 expand_string_message = US"File existence tests are not permitted";
2277 return NULL;
2278 }
2279 *yield = (Ustat(sub[0], &statbuf) == 0) == testfor;
2280 break;
2281
2282 case ECOND_ISIP:
2283 case ECOND_ISIP4:
2284 case ECOND_ISIP6:
2285 rc = string_is_ip_address(sub[0], NULL);
2286 *yield = ((cond_type == ECOND_ISIP)? (rc != 0) :
2287 (cond_type == ECOND_ISIP4)? (rc == 4) : (rc == 6)) == testfor;
2288 break;
2289
2290 /* Various authentication tests - all optionally compiled */
2291
2292 case ECOND_PAM:
2293 #ifdef SUPPORT_PAM
2294 rc = auth_call_pam(sub[0], &expand_string_message);
2295 goto END_AUTH;
2296 #else
2297 goto COND_FAILED_NOT_COMPILED;
2298 #endif /* SUPPORT_PAM */
2299
2300 case ECOND_RADIUS:
2301 #ifdef RADIUS_CONFIG_FILE
2302 rc = auth_call_radius(sub[0], &expand_string_message);
2303 goto END_AUTH;
2304 #else
2305 goto COND_FAILED_NOT_COMPILED;
2306 #endif /* RADIUS_CONFIG_FILE */
2307
2308 case ECOND_LDAPAUTH:
2309 #ifdef LOOKUP_LDAP
2310 {
2311 /* Just to keep the interface the same */
2312 BOOL do_cache;
2313 int old_pool = store_pool;
2314 store_pool = POOL_SEARCH;
2315 rc = eldapauth_find((void *)(-1), NULL, sub[0], Ustrlen(sub[0]), NULL,
2316 &expand_string_message, &do_cache);
2317 store_pool = old_pool;
2318 }
2319 goto END_AUTH;
2320 #else
2321 goto COND_FAILED_NOT_COMPILED;
2322 #endif /* LOOKUP_LDAP */
2323
2324 case ECOND_PWCHECK:
2325 #ifdef CYRUS_PWCHECK_SOCKET
2326 rc = auth_call_pwcheck(sub[0], &expand_string_message);
2327 goto END_AUTH;
2328 #else
2329 goto COND_FAILED_NOT_COMPILED;
2330 #endif /* CYRUS_PWCHECK_SOCKET */
2331
2332 #if defined(SUPPORT_PAM) || defined(RADIUS_CONFIG_FILE) || \
2333 defined(LOOKUP_LDAP) || defined(CYRUS_PWCHECK_SOCKET)
2334 END_AUTH:
2335 if (rc == ERROR || rc == DEFER) return NULL;
2336 *yield = (rc == OK) == testfor;
2337 #endif
2338 }
2339 return s;
2340
2341
2342 /* call ACL (in a conditional context). Accept true, deny false.
2343 Defer is a forced-fail. Anything set by message= goes to $value.
2344 Up to ten parameters are used; we use the braces round the name+args
2345 like the saslauthd condition does, to permit a variable number of args.
2346 See also the expansion-item version EITEM_ACL and the traditional
2347 acl modifier ACLC_ACL.
2348 Since the ACL may allocate new global variables, tell our caller to not
2349 reclaim memory.
2350 */
2351
2352 case ECOND_ACL:
2353 /* ${if acl {{name}{arg1}{arg2}...} {yes}{no}} */
2354 {
2355 uschar *sub[10];
2356 uschar *user_msg;
2357 BOOL cond = FALSE;
2358 int size = 0;
2359 int ptr = 0;
2360
2361 while (isspace(*s)) s++;
2362 if (*s++ != '{') goto COND_FAILED_CURLY_START; /*}*/
2363
2364 switch(read_subs(sub, nelem(sub), 1,
2365 &s, yield == NULL, TRUE, US"acl", resetok))
2366 {
2367 case 1: expand_string_message = US"too few arguments or bracketing "
2368 "error for acl";
2369 case 2:
2370 case 3: return NULL;
2371 }
2372
2373 *resetok = FALSE;
2374 if (yield != NULL) switch(eval_acl(sub, nelem(sub), &user_msg))
2375 {
2376 case OK:
2377 cond = TRUE;
2378 case FAIL:
2379 lookup_value = NULL;
2380 if (user_msg)
2381 {
2382 lookup_value = string_cat(NULL, &size, &ptr, user_msg, Ustrlen(user_msg));
2383 lookup_value[ptr] = '\0';
2384 }
2385 *yield = cond == testfor;
2386 break;
2387
2388 case DEFER:
2389 expand_string_forcedfail = TRUE;
2390 default:
2391 expand_string_message = string_sprintf("error from acl \"%s\"", sub[0]);
2392 return NULL;
2393 }
2394 return s;
2395 }
2396
2397
2398 /* saslauthd: does Cyrus saslauthd authentication. Four parameters are used:
2399
2400 ${if saslauthd {{username}{password}{service}{realm}} {yes}{no}}
2401
2402 However, the last two are optional. That is why the whole set is enclosed
2403 in their own set of braces. */
2404
2405 case ECOND_SASLAUTHD:
2406 #ifndef CYRUS_SASLAUTHD_SOCKET
2407 goto COND_FAILED_NOT_COMPILED;
2408 #else
2409 {
2410 uschar *sub[4];
2411 while (isspace(*s)) s++;
2412 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2413 switch(read_subs(sub, nelem(sub), 2, &s, yield == NULL, TRUE, US"saslauthd",
2414 resetok))
2415 {
2416 case 1: expand_string_message = US"too few arguments or bracketing "
2417 "error for saslauthd";
2418 case 2:
2419 case 3: return NULL;
2420 }
2421 if (sub[2] == NULL) sub[3] = NULL; /* realm if no service */
2422 if (yield != NULL)
2423 {
2424 int rc = auth_call_saslauthd(sub[0], sub[1], sub[2], sub[3],
2425 &expand_string_message);
2426 if (rc == ERROR || rc == DEFER) return NULL;
2427 *yield = (rc == OK) == testfor;
2428 }
2429 return s;
2430 }
2431 #endif /* CYRUS_SASLAUTHD_SOCKET */
2432
2433
2434 /* symbolic operators for numeric and string comparison, and a number of
2435 other operators, all requiring two arguments.
2436
2437 crypteq: encrypts plaintext and compares against an encrypted text,
2438 using crypt(), crypt16(), MD5 or SHA-1
2439 inlist/inlisti: checks if first argument is in the list of the second
2440 match: does a regular expression match and sets up the numerical
2441 variables if it succeeds
2442 match_address: matches in an address list
2443 match_domain: matches in a domain list
2444 match_ip: matches a host list that is restricted to IP addresses
2445 match_local_part: matches in a local part list
2446 */
2447
2448 case ECOND_MATCH_ADDRESS:
2449 case ECOND_MATCH_DOMAIN:
2450 case ECOND_MATCH_IP:
2451 case ECOND_MATCH_LOCAL_PART:
2452 #ifndef EXPAND_LISTMATCH_RHS
2453 sub2_honour_dollar = FALSE;
2454 #endif
2455 /* FALLTHROUGH */
2456
2457 case ECOND_CRYPTEQ:
2458 case ECOND_INLIST:
2459 case ECOND_INLISTI:
2460 case ECOND_MATCH:
2461
2462 case ECOND_NUM_L: /* Numerical comparisons */
2463 case ECOND_NUM_LE:
2464 case ECOND_NUM_E:
2465 case ECOND_NUM_EE:
2466 case ECOND_NUM_G:
2467 case ECOND_NUM_GE:
2468
2469 case ECOND_STR_LT: /* String comparisons */
2470 case ECOND_STR_LTI:
2471 case ECOND_STR_LE:
2472 case ECOND_STR_LEI:
2473 case ECOND_STR_EQ:
2474 case ECOND_STR_EQI:
2475 case ECOND_STR_GT:
2476 case ECOND_STR_GTI:
2477 case ECOND_STR_GE:
2478 case ECOND_STR_GEI:
2479
2480 for (i = 0; i < 2; i++)
2481 {
2482 /* Sometimes, we don't expand substrings; too many insecure configurations
2483 created using match_address{}{} and friends, where the second param
2484 includes information from untrustworthy sources. */
2485 BOOL honour_dollar = TRUE;
2486 if ((i > 0) && !sub2_honour_dollar)
2487 honour_dollar = FALSE;
2488
2489 while (isspace(*s)) s++;
2490 if (*s != '{')
2491 {
2492 if (i == 0) goto COND_FAILED_CURLY_START;
2493 expand_string_message = string_sprintf("missing 2nd string in {} "
2494 "after \"%s\"", name);
2495 return NULL;
2496 }
2497 sub[i] = expand_string_internal(s+1, TRUE, &s, yield == NULL,
2498 honour_dollar, resetok);
2499 if (sub[i] == NULL) return NULL;
2500 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2501
2502 /* Convert to numerical if required; we know that the names of all the
2503 conditions that compare numbers do not start with a letter. This just saves
2504 checking for them individually. */
2505
2506 if (!isalpha(name[0]) && yield != NULL)
2507 {
2508 if (sub[i][0] == 0)
2509 {
2510 num[i] = 0;
2511 DEBUG(D_expand)
2512 debug_printf("empty string cast to zero for numerical comparison\n");
2513 }
2514 else
2515 {
2516 num[i] = expanded_string_integer(sub[i], FALSE);
2517 if (expand_string_message != NULL) return NULL;
2518 }
2519 }
2520 }
2521
2522 /* Result not required */
2523
2524 if (yield == NULL) return s;
2525
2526 /* Do an appropriate comparison */
2527
2528 switch(cond_type)
2529 {
2530 case ECOND_NUM_E:
2531 case ECOND_NUM_EE:
2532 tempcond = (num[0] == num[1]);
2533 break;
2534
2535 case ECOND_NUM_G:
2536 tempcond = (num[0] > num[1]);
2537 break;
2538
2539 case ECOND_NUM_GE:
2540 tempcond = (num[0] >= num[1]);
2541 break;
2542
2543 case ECOND_NUM_L:
2544 tempcond = (num[0] < num[1]);
2545 break;
2546
2547 case ECOND_NUM_LE:
2548 tempcond = (num[0] <= num[1]);
2549 break;
2550
2551 case ECOND_STR_LT:
2552 tempcond = (Ustrcmp(sub[0], sub[1]) < 0);
2553 break;
2554
2555 case ECOND_STR_LTI:
2556 tempcond = (strcmpic(sub[0], sub[1]) < 0);
2557 break;
2558
2559 case ECOND_STR_LE:
2560 tempcond = (Ustrcmp(sub[0], sub[1]) <= 0);
2561 break;
2562
2563 case ECOND_STR_LEI:
2564 tempcond = (strcmpic(sub[0], sub[1]) <= 0);
2565 break;
2566
2567 case ECOND_STR_EQ:
2568 tempcond = (Ustrcmp(sub[0], sub[1]) == 0);
2569 break;
2570
2571 case ECOND_STR_EQI:
2572 tempcond = (strcmpic(sub[0], sub[1]) == 0);
2573 break;
2574
2575 case ECOND_STR_GT:
2576 tempcond = (Ustrcmp(sub[0], sub[1]) > 0);
2577 break;
2578
2579 case ECOND_STR_GTI:
2580 tempcond = (strcmpic(sub[0], sub[1]) > 0);
2581 break;
2582
2583 case ECOND_STR_GE:
2584 tempcond = (Ustrcmp(sub[0], sub[1]) >= 0);
2585 break;
2586
2587 case ECOND_STR_GEI:
2588 tempcond = (strcmpic(sub[0], sub[1]) >= 0);
2589 break;
2590
2591 case ECOND_MATCH: /* Regular expression match */
2592 re = pcre_compile(CS sub[1], PCRE_COPT, (const char **)&rerror, &roffset,
2593 NULL);
2594 if (re == NULL)
2595 {
2596 expand_string_message = string_sprintf("regular expression error in "
2597 "\"%s\": %s at offset %d", sub[1], rerror, roffset);
2598 return NULL;
2599 }
2600 tempcond = regex_match_and_setup(re, sub[0], 0, -1);
2601 break;
2602
2603 case ECOND_MATCH_ADDRESS: /* Match in an address list */
2604 rc = match_address_list(sub[0], TRUE, FALSE, &(sub[1]), NULL, -1, 0, NULL);
2605 goto MATCHED_SOMETHING;
2606
2607 case ECOND_MATCH_DOMAIN: /* Match in a domain list */
2608 rc = match_isinlist(sub[0], &(sub[1]), 0, &domainlist_anchor, NULL,
2609 MCL_DOMAIN + MCL_NOEXPAND, TRUE, NULL);
2610 goto MATCHED_SOMETHING;
2611
2612 case ECOND_MATCH_IP: /* Match IP address in a host list */
2613 if (sub[0][0] != 0 && string_is_ip_address(sub[0], NULL) == 0)
2614 {
2615 expand_string_message = string_sprintf("\"%s\" is not an IP address",
2616 sub[0]);
2617 return NULL;
2618 }
2619 else
2620 {
2621 unsigned int *nullcache = NULL;
2622 check_host_block cb;
2623
2624 cb.host_name = US"";
2625 cb.host_address = sub[0];
2626
2627 /* If the host address starts off ::ffff: it is an IPv6 address in
2628 IPv4-compatible mode. Find the IPv4 part for checking against IPv4
2629 addresses. */
2630
2631 cb.host_ipv4 = (Ustrncmp(cb.host_address, "::ffff:", 7) == 0)?
2632 cb.host_address + 7 : cb.host_address;
2633
2634 rc = match_check_list(
2635 &sub[1], /* the list */
2636 0, /* separator character */
2637 &hostlist_anchor, /* anchor pointer */
2638 &nullcache, /* cache pointer */
2639 check_host, /* function for testing */
2640 &cb, /* argument for function */
2641 MCL_HOST, /* type of check */
2642 sub[0], /* text for debugging */
2643 NULL); /* where to pass back data */
2644 }
2645 goto MATCHED_SOMETHING;
2646
2647 case ECOND_MATCH_LOCAL_PART:
2648 rc = match_isinlist(sub[0], &(sub[1]), 0, &localpartlist_anchor, NULL,
2649 MCL_LOCALPART + MCL_NOEXPAND, TRUE, NULL);
2650 /* Fall through */
2651 /* VVVVVVVVVVVV */
2652 MATCHED_SOMETHING:
2653 switch(rc)
2654 {
2655 case OK:
2656 tempcond = TRUE;
2657 break;
2658
2659 case FAIL:
2660 tempcond = FALSE;
2661 break;
2662
2663 case DEFER:
2664 expand_string_message = string_sprintf("unable to complete match "
2665 "against \"%s\": %s", sub[1], search_error_message);
2666 return NULL;
2667 }
2668
2669 break;
2670
2671 /* Various "encrypted" comparisons. If the second string starts with
2672 "{" then an encryption type is given. Default to crypt() or crypt16()
2673 (build-time choice). */
2674 /* }-for-text-editors */
2675
2676 case ECOND_CRYPTEQ:
2677 #ifndef SUPPORT_CRYPTEQ
2678 goto COND_FAILED_NOT_COMPILED;
2679 #else
2680 if (strncmpic(sub[1], US"{md5}", 5) == 0)
2681 {
2682 int sublen = Ustrlen(sub[1]+5);
2683 md5 base;
2684 uschar digest[16];
2685
2686 md5_start(&base);
2687 md5_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2688
2689 /* If the length that we are comparing against is 24, the MD5 digest
2690 is expressed as a base64 string. This is the way LDAP does it. However,
2691 some other software uses a straightforward hex representation. We assume
2692 this if the length is 32. Other lengths fail. */
2693
2694 if (sublen == 24)
2695 {
2696 uschar *coded = b64encode((uschar *)digest, 16);
2697 DEBUG(D_auth) debug_printf("crypteq: using MD5+B64 hashing\n"
2698 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2699 tempcond = (Ustrcmp(coded, sub[1]+5) == 0);
2700 }
2701 else if (sublen == 32)
2702 {
2703 int i;
2704 uschar coded[36];
2705 for (i = 0; i < 16; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2706 coded[32] = 0;
2707 DEBUG(D_auth) debug_printf("crypteq: using MD5+hex hashing\n"
2708 " subject=%s\n crypted=%s\n", coded, sub[1]+5);
2709 tempcond = (strcmpic(coded, sub[1]+5) == 0);
2710 }
2711 else
2712 {
2713 DEBUG(D_auth) debug_printf("crypteq: length for MD5 not 24 or 32: "
2714 "fail\n crypted=%s\n", sub[1]+5);
2715 tempcond = FALSE;
2716 }
2717 }
2718
2719 else if (strncmpic(sub[1], US"{sha1}", 6) == 0)
2720 {
2721 int sublen = Ustrlen(sub[1]+6);
2722 sha1 base;
2723 uschar digest[20];
2724
2725 sha1_start(&base);
2726 sha1_end(&base, (uschar *)sub[0], Ustrlen(sub[0]), digest);
2727
2728 /* If the length that we are comparing against is 28, assume the SHA1
2729 digest is expressed as a base64 string. If the length is 40, assume a
2730 straightforward hex representation. Other lengths fail. */
2731
2732 if (sublen == 28)
2733 {
2734 uschar *coded = b64encode((uschar *)digest, 20);
2735 DEBUG(D_auth) debug_printf("crypteq: using SHA1+B64 hashing\n"
2736 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2737 tempcond = (Ustrcmp(coded, sub[1]+6) == 0);
2738 }
2739 else if (sublen == 40)
2740 {
2741 int i;
2742 uschar coded[44];
2743 for (i = 0; i < 20; i++) sprintf(CS (coded+2*i), "%02X", digest[i]);
2744 coded[40] = 0;
2745 DEBUG(D_auth) debug_printf("crypteq: using SHA1+hex hashing\n"
2746 " subject=%s\n crypted=%s\n", coded, sub[1]+6);
2747 tempcond = (strcmpic(coded, sub[1]+6) == 0);
2748 }
2749 else
2750 {
2751 DEBUG(D_auth) debug_printf("crypteq: length for SHA-1 not 28 or 40: "
2752 "fail\n crypted=%s\n", sub[1]+6);
2753 tempcond = FALSE;
2754 }
2755 }
2756
2757 else /* {crypt} or {crypt16} and non-{ at start */
2758 /* }-for-text-editors */
2759 {
2760 int which = 0;
2761 uschar *coded;
2762
2763 if (strncmpic(sub[1], US"{crypt}", 7) == 0)
2764 {
2765 sub[1] += 7;
2766 which = 1;
2767 }
2768 else if (strncmpic(sub[1], US"{crypt16}", 9) == 0)
2769 {
2770 sub[1] += 9;
2771 which = 2;
2772 }
2773 else if (sub[1][0] == '{') /* }-for-text-editors */
2774 {
2775 expand_string_message = string_sprintf("unknown encryption mechanism "
2776 "in \"%s\"", sub[1]);
2777 return NULL;
2778 }
2779
2780 switch(which)
2781 {
2782 case 0: coded = US DEFAULT_CRYPT(CS sub[0], CS sub[1]); break;
2783 case 1: coded = US crypt(CS sub[0], CS sub[1]); break;
2784 default: coded = US crypt16(CS sub[0], CS sub[1]); break;
2785 }
2786
2787 #define STR(s) # s
2788 #define XSTR(s) STR(s)
2789 DEBUG(D_auth) debug_printf("crypteq: using %s()\n"
2790 " subject=%s\n crypted=%s\n",
2791 which == 0 ? XSTR(DEFAULT_CRYPT) : which == 1 ? "crypt" : "crypt16",
2792 coded, sub[1]);
2793 #undef STR
2794 #undef XSTR
2795
2796 /* If the encrypted string contains fewer than two characters (for the
2797 salt), force failure. Otherwise we get false positives: with an empty
2798 string the yield of crypt() is an empty string! */
2799
2800 if (coded)
2801 tempcond = Ustrlen(sub[1]) < 2 ? FALSE : Ustrcmp(coded, sub[1]) == 0;
2802 else if (errno == EINVAL)
2803 tempcond = FALSE;
2804 else
2805 {
2806 expand_string_message = string_sprintf("crypt error: %s\n",
2807 US strerror(errno));
2808 return NULL;
2809 }
2810 }
2811 break;
2812 #endif /* SUPPORT_CRYPTEQ */
2813
2814 case ECOND_INLIST:
2815 case ECOND_INLISTI:
2816 {
2817 const uschar * list = sub[1];
2818 int sep = 0;
2819 uschar *save_iterate_item = iterate_item;
2820 int (*compare)(const uschar *, const uschar *);
2821
2822 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2823
2824 tempcond = FALSE;
2825 compare = cond_type == ECOND_INLISTI
2826 ? strcmpic : (int (*)(const uschar *, const uschar *)) strcmp;
2827
2828 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)))
2829 if (compare(sub[0], iterate_item) == 0)
2830 {
2831 tempcond = TRUE;
2832 break;
2833 }
2834 iterate_item = save_iterate_item;
2835 }
2836
2837 } /* Switch for comparison conditions */
2838
2839 *yield = tempcond == testfor;
2840 return s; /* End of comparison conditions */
2841
2842
2843 /* and/or: computes logical and/or of several conditions */
2844
2845 case ECOND_AND:
2846 case ECOND_OR:
2847 subcondptr = (yield == NULL)? NULL : &tempcond;
2848 combined_cond = (cond_type == ECOND_AND);
2849
2850 while (isspace(*s)) s++;
2851 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2852
2853 for (;;)
2854 {
2855 while (isspace(*s)) s++;
2856 /* {-for-text-editors */
2857 if (*s == '}') break;
2858 if (*s != '{') /* }-for-text-editors */
2859 {
2860 expand_string_message = string_sprintf("each subcondition "
2861 "inside an \"%s{...}\" condition must be in its own {}", name);
2862 return NULL;
2863 }
2864
2865 if (!(s = eval_condition(s+1, resetok, subcondptr)))
2866 {
2867 expand_string_message = string_sprintf("%s inside \"%s{...}\" condition",
2868 expand_string_message, name);
2869 return NULL;
2870 }
2871 while (isspace(*s)) s++;
2872
2873 /* {-for-text-editors */
2874 if (*s++ != '}')
2875 {
2876 /* {-for-text-editors */
2877 expand_string_message = string_sprintf("missing } at end of condition "
2878 "inside \"%s\" group", name);
2879 return NULL;
2880 }
2881
2882 if (yield != NULL)
2883 {
2884 if (cond_type == ECOND_AND)
2885 {
2886 combined_cond &= tempcond;
2887 if (!combined_cond) subcondptr = NULL; /* once false, don't */
2888 } /* evaluate any more */
2889 else
2890 {
2891 combined_cond |= tempcond;
2892 if (combined_cond) subcondptr = NULL; /* once true, don't */
2893 } /* evaluate any more */
2894 }
2895 }
2896
2897 if (yield != NULL) *yield = (combined_cond == testfor);
2898 return ++s;
2899
2900
2901 /* forall/forany: iterates a condition with different values */
2902
2903 case ECOND_FORALL:
2904 case ECOND_FORANY:
2905 {
2906 const uschar * list;
2907 int sep = 0;
2908 uschar *save_iterate_item = iterate_item;
2909
2910 DEBUG(D_expand) debug_printf("condition: %s\n", name);
2911
2912 while (isspace(*s)) s++;
2913 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2914 sub[0] = expand_string_internal(s, TRUE, &s, (yield == NULL), TRUE, resetok);
2915 if (sub[0] == NULL) return NULL;
2916 /* {-for-text-editors */
2917 if (*s++ != '}') goto COND_FAILED_CURLY_END;
2918
2919 while (isspace(*s)) s++;
2920 if (*s++ != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2921
2922 sub[1] = s;
2923
2924 /* Call eval_condition once, with result discarded (as if scanning a
2925 "false" part). This allows us to find the end of the condition, because if
2926 the list it empty, we won't actually evaluate the condition for real. */
2927
2928 if (!(s = eval_condition(sub[1], resetok, NULL)))
2929 {
2930 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2931 expand_string_message, name);
2932 return NULL;
2933 }
2934 while (isspace(*s)) s++;
2935
2936 /* {-for-text-editors */
2937 if (*s++ != '}')
2938 {
2939 /* {-for-text-editors */
2940 expand_string_message = string_sprintf("missing } at end of condition "
2941 "inside \"%s\"", name);
2942 return NULL;
2943 }
2944
2945 if (yield != NULL) *yield = !testfor;
2946 list = sub[0];
2947 while ((iterate_item = string_nextinlist(&list, &sep, NULL, 0)) != NULL)
2948 {
2949 DEBUG(D_expand) debug_printf("%s: $item = \"%s\"\n", name, iterate_item);
2950 if (!eval_condition(sub[1], resetok, &tempcond))
2951 {
2952 expand_string_message = string_sprintf("%s inside \"%s\" condition",
2953 expand_string_message, name);
2954 iterate_item = save_iterate_item;
2955 return NULL;
2956 }
2957 DEBUG(D_expand) debug_printf("%s: condition evaluated to %s\n", name,
2958 tempcond? "true":"false");
2959
2960 if (yield != NULL) *yield = (tempcond == testfor);
2961 if (tempcond == (cond_type == ECOND_FORANY)) break;
2962 }
2963
2964 iterate_item = save_iterate_item;
2965 return s;
2966 }
2967
2968
2969 /* The bool{} expansion condition maps a string to boolean.
2970 The values supported should match those supported by the ACL condition
2971 (acl.c, ACLC_CONDITION) so that we keep to a minimum the different ideas
2972 of true/false. Note that Router "condition" rules have a different
2973 interpretation, where general data can be used and only a few values
2974 map to FALSE.
2975 Note that readconf.c boolean matching, for boolean configuration options,
2976 only matches true/yes/false/no.
2977 The bool_lax{} condition matches the Router logic, which is much more
2978 liberal. */
2979 case ECOND_BOOL:
2980 case ECOND_BOOL_LAX:
2981 {
2982 uschar *sub_arg[1];
2983 uschar *t, *t2;
2984 uschar *ourname;
2985 size_t len;
2986 BOOL boolvalue = FALSE;
2987 while (isspace(*s)) s++;
2988 if (*s != '{') goto COND_FAILED_CURLY_START; /* }-for-text-editors */
2989 ourname = cond_type == ECOND_BOOL_LAX ? US"bool_lax" : US"bool";
2990 switch(read_subs(sub_arg, 1, 1, &s, yield == NULL, FALSE, ourname, resetok))
2991 {
2992 case 1: expand_string_message = string_sprintf(
2993 "too few arguments or bracketing error for %s",
2994 ourname);
2995 /*FALLTHROUGH*/
2996 case 2:
2997 case 3: return NULL;
2998 }
2999 t = sub_arg[0];
3000 while (isspace(*t)) t++;
3001 len = Ustrlen(t);
3002 if (len)
3003 {
3004 /* trailing whitespace: seems like a good idea to ignore it too */
3005 t2 = t + len - 1;
3006 while (isspace(*t2)) t2--;
3007 if (t2 != (t + len))
3008 {
3009 *++t2 = '\0';
3010 len = t2 - t;
3011 }
3012 }
3013 DEBUG(D_expand)
3014 debug_printf("considering %s: %s\n", ourname, len ? t : US"<empty>");
3015 /* logic for the lax case from expand_check_condition(), which also does
3016 expands, and the logic is both short and stable enough that there should
3017 be no maintenance burden from replicating it. */
3018 if (len == 0)
3019 boolvalue = FALSE;
3020 else if (*t == '-'
3021 ? Ustrspn(t+1, "0123456789") == len-1
3022 : Ustrspn(t, "0123456789") == len)
3023 {
3024 boolvalue = (Uatoi(t) == 0) ? FALSE : TRUE;
3025 /* expand_check_condition only does a literal string "0" check */
3026 if ((cond_type == ECOND_BOOL_LAX) && (len > 1))
3027 boolvalue = TRUE;
3028 }
3029 else if (strcmpic(t, US"true") == 0 || strcmpic(t, US"yes") == 0)
3030 boolvalue = TRUE;
3031 else if (strcmpic(t, US"false") == 0 || strcmpic(t, US"no") == 0)
3032 boolvalue = FALSE;
3033 else if (cond_type == ECOND_BOOL_LAX)
3034 boolvalue = TRUE;
3035 else
3036 {
3037 expand_string_message = string_sprintf("unrecognised boolean "
3038 "value \"%s\"", t);
3039 return NULL;
3040 }
3041 if (yield != NULL) *yield = (boolvalue == testfor);
3042 return s;
3043 }
3044
3045 /* Unknown condition */
3046
3047 default:
3048 expand_string_message = string_sprintf("unknown condition \"%s\"", name);
3049 return NULL;
3050 } /* End switch on condition type */
3051
3052 /* Missing braces at start and end of data */
3053
3054 COND_FAILED_CURLY_START:
3055 expand_string_message = string_sprintf("missing { after \"%s\"", name);
3056 return NULL;
3057
3058 COND_FAILED_CURLY_END:
3059 expand_string_message = string_sprintf("missing } at end of \"%s\" condition",
3060 name);
3061 return NULL;
3062
3063 /* A condition requires code that is not compiled */
3064
3065 #if !defined(SUPPORT_PAM) || !defined(RADIUS_CONFIG_FILE) || \
3066 !defined(LOOKUP_LDAP) || !defined(CYRUS_PWCHECK_SOCKET) || \
3067 !defined(SUPPORT_CRYPTEQ) || !defined(CYRUS_SASLAUTHD_SOCKET)
3068 COND_FAILED_NOT_COMPILED:
3069 expand_string_message = string_sprintf("support for \"%s\" not compiled",
3070 name);
3071 return NULL;
3072 #endif
3073 }
3074
3075
3076
3077
3078 /*************************************************
3079 * Save numerical variables *
3080 *************************************************/
3081
3082 /* This function is called from items such as "if" that want to preserve and
3083 restore the numbered variables.
3084
3085 Arguments:
3086 save_expand_string points to an array of pointers to set
3087 save_expand_nlength points to an array of ints for the lengths
3088
3089 Returns: the value of expand max to save
3090 */
3091
3092 static int
3093 save_expand_strings(uschar **save_expand_nstring, int *save_expand_nlength)
3094 {
3095 int i;
3096 for (i = 0; i <= expand_nmax; i++)
3097 {
3098 save_expand_nstring[i] = expand_nstring[i];
3099 save_expand_nlength[i] = expand_nlength[i];
3100 }
3101 return expand_nmax;
3102 }
3103
3104
3105
3106 /*************************************************
3107 * Restore numerical variables *
3108 *************************************************/
3109
3110 /* This function restored saved values of numerical strings.
3111
3112 Arguments:
3113 save_expand_nmax the number of strings to restore
3114 save_expand_string points to an array of pointers
3115 save_expand_nlength points to an array of ints
3116
3117 Returns: nothing
3118 */
3119
3120 static void
3121 restore_expand_strings(int save_expand_nmax, uschar **save_expand_nstring,
3122 int *save_expand_nlength)
3123 {
3124 int i;
3125 expand_nmax = save_expand_nmax;
3126 for (i = 0; i <= expand_nmax; i++)
3127 {
3128 expand_nstring[i] = save_expand_nstring[i];
3129 expand_nlength[i] = save_expand_nlength[i];
3130 }
3131 }
3132
3133
3134
3135
3136
3137 /*************************************************
3138 * Handle yes/no substrings *
3139 *************************************************/
3140
3141 /* This function is used by ${if}, ${lookup} and ${extract} to handle the
3142 alternative substrings that depend on whether or not the condition was true,
3143 or the lookup or extraction succeeded. The substrings always have to be
3144 expanded, to check their syntax, but "skipping" is set when the result is not
3145 needed - this avoids unnecessary nested lookups.
3146
3147 Arguments:
3148 skipping TRUE if we were skipping when this item was reached
3149 yes TRUE if the first string is to be used, else use the second
3150 save_lookup a value to put back into lookup_value before the 2nd expansion
3151 sptr points to the input string pointer
3152 yieldptr points to the output string pointer
3153 sizeptr points to the output string size
3154 ptrptr points to the output string pointer
3155 type "lookup", "if", "extract", "run", "env", "listextract" or
3156 "certextract" for error message
3157 resetok if not NULL, pointer to flag - write FALSE if unsafe to reset
3158 the store.
3159
3160 Returns: 0 OK; lookup_value has been reset to save_lookup
3161 1 expansion failed
3162 2 expansion failed because of bracketing error
3163 */
3164
3165 static int
3166 process_yesno(BOOL skipping, BOOL yes, uschar *save_lookup, const uschar **sptr,
3167 uschar **yieldptr, int *sizeptr, int *ptrptr, uschar *type, BOOL *resetok)
3168 {
3169 int rc = 0;
3170 const uschar *s = *sptr; /* Local value */
3171 uschar *sub1, *sub2;
3172
3173 /* If there are no following strings, we substitute the contents of $value for
3174 lookups and for extractions in the success case. For the ${if item, the string
3175 "true" is substituted. In the fail case, nothing is substituted for all three
3176 items. */
3177
3178 while (isspace(*s)) s++;
3179 if (*s == '}')
3180 {
3181 if (type[0] == 'i')
3182 {
3183 if (yes) *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, US"true", 4);
3184 }
3185 else
3186 {
3187 if (yes && lookup_value)
3188 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, lookup_value,
3189 Ustrlen(lookup_value));
3190 lookup_value = save_lookup;
3191 }
3192 s++;
3193 goto RETURN;
3194 }
3195
3196 /* The first following string must be braced. */
3197
3198 if (*s++ != '{') goto FAILED_CURLY;
3199
3200 /* Expand the first substring. Forced failures are noticed only if we actually
3201 want this string. Set skipping in the call in the fail case (this will always
3202 be the case if we were already skipping). */
3203
3204 sub1 = expand_string_internal(s, TRUE, &s, !yes, TRUE, resetok);
3205 if (sub1 == NULL && (yes || !expand_string_forcedfail)) goto FAILED;
3206 expand_string_forcedfail = FALSE;
3207 if (*s++ != '}') goto FAILED_CURLY;
3208
3209 /* If we want the first string, add it to the output */
3210
3211 if (yes)
3212 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub1, Ustrlen(sub1));
3213
3214 /* If this is called from a lookup/env or a (cert)extract, we want to restore
3215 $value to what it was at the start of the item, so that it has this value
3216 during the second string expansion. For the call from "if" or "run" to this
3217 function, save_lookup is set to lookup_value, so that this statement does
3218 nothing. */
3219
3220 lookup_value = save_lookup;
3221
3222 /* There now follows either another substring, or "fail", or nothing. This
3223 time, forced failures are noticed only if we want the second string. We must
3224 set skipping in the nested call if we don't want this string, or if we were
3225 already skipping. */
3226
3227 while (isspace(*s)) s++;
3228 if (*s == '{')
3229 {
3230 sub2 = expand_string_internal(s+1, TRUE, &s, yes || skipping, TRUE, resetok);
3231 if (sub2 == NULL && (!yes || !expand_string_forcedfail)) goto FAILED;
3232 expand_string_forcedfail = FALSE;
3233 if (*s++ != '}') goto FAILED_CURLY;
3234
3235 /* If we want the second string, add it to the output */
3236
3237 if (!yes)
3238 *yieldptr = string_cat(*yieldptr, sizeptr, ptrptr, sub2, Ustrlen(sub2));
3239 }
3240
3241 /* If there is no second string, but the word "fail" is present when the use of
3242 the second string is wanted, set a flag indicating it was a forced failure
3243 rather than a syntactic error. Swallow the terminating } in case this is nested
3244 inside another lookup or if or extract. */
3245
3246 else if (*s != '}')
3247 {
3248 uschar name[256];
3249 /* deconst cast ok here as source is s anyway */
3250 s = US read_name(name, sizeof(name), s, US"_");
3251 if (Ustrcmp(name, "fail") == 0)
3252 {
3253 if (!yes && !skipping)
3254 {
3255 while (isspace(*s)) s++;
3256 if (*s++ != '}') goto FAILED_CURLY;
3257 expand_string_message =
3258 string_sprintf("\"%s\" failed and \"fail\" requested", type);
3259 expand_string_forcedfail = TRUE;
3260 goto FAILED;
3261 }
3262 }
3263 else
3264 {
3265 expand_string_message =
3266 string_sprintf("syntax error in \"%s\" item - \"fail\" expected", type);
3267 goto FAILED;
3268 }
3269 }
3270
3271 /* All we have to do now is to check on the final closing brace. */
3272
3273 while (isspace(*s)) s++;
3274 if (*s++ == '}') goto RETURN;
3275
3276 /* Get here if there is a bracketing failure */
3277
3278 FAILED_CURLY:
3279 rc++;
3280
3281 /* Get here for other failures */
3282
3283 FAILED:
3284 rc++;
3285
3286 /* Update the input pointer value before returning */
3287
3288 RETURN:
3289 *sptr = s;
3290 return rc;
3291 }
3292
3293
3294
3295
3296 /*************************************************
3297 * Handle MD5 or SHA-1 computation for HMAC *
3298 *************************************************/
3299
3300 /* These are some wrapping functions that enable the HMAC code to be a bit
3301 cleaner. A good compiler will spot the tail recursion.
3302
3303 Arguments:
3304 type HMAC_MD5 or HMAC_SHA1
3305 remaining are as for the cryptographic hash functions
3306
3307 Returns: nothing
3308 */
3309
3310 static void
3311 chash_start(int type, void *base)
3312 {
3313 if (type == HMAC_MD5)
3314 md5_start((md5 *)base);
3315 else
3316 sha1_start((sha1 *)base);
3317 }
3318
3319 static void
3320 chash_mid(int type, void *base, uschar *string)
3321 {
3322 if (type == HMAC_MD5)
3323 md5_mid((md5 *)base, string);
3324 else
3325 sha1_mid((sha1 *)base, string);
3326 }
3327
3328 static void
3329 chash_end(int type, void *base, uschar *string, int length, uschar *digest)
3330 {
3331 if (type == HMAC_MD5)
3332 md5_end((md5 *)base, string, length, digest);
3333 else
3334 sha1_end((sha1 *)base, string, length, digest);
3335 }
3336
3337
3338
3339
3340
3341 /********************************************************
3342 * prvs: Get last three digits of days since Jan 1, 1970 *
3343 ********************************************************/
3344
3345 /* This is needed to implement the "prvs" BATV reverse
3346 path signing scheme
3347
3348 Argument: integer "days" offset to add or substract to
3349 or from the current number of days.
3350
3351 Returns: pointer to string containing the last three
3352 digits of the number of days since Jan 1, 1970,
3353 modified by the offset argument, NULL if there
3354 was an error in the conversion.
3355
3356 */
3357
3358 static uschar *
3359 prvs_daystamp(int day_offset)
3360 {
3361 uschar *days = store_get(32); /* Need at least 24 for cases */
3362 (void)string_format(days, 32, TIME_T_FMT, /* where TIME_T_FMT is %lld */
3363 (time(NULL) + day_offset*86400)/86400);
3364 return (Ustrlen(days) >= 3) ? &</