3f1ba222f170a4c56ad4738403ac4e12a49e2ae9
[exim.git] / src / src / parse.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Functions for parsing addresses */
10
11
12 #include "exim.h"
13
14
15 static const uschar *last_comment_position;
16
17
18
19 /* In stand-alone mode, provide a replacement for deliver_make_addr()
20 and rewrite_address[_qualify]() so as to avoid having to drag in too much
21 redundant apparatus. */
22
23 #ifdef STAND_ALONE
24
25 address_item *deliver_make_addr(uschar *address, BOOL copy)
26 {
27 address_item *addr = store_get(sizeof(address_item), FALSE);
28 addr->next = NULL;
29 addr->parent = NULL;
30 addr->address = address;
31 return addr;
32 }
33
34 uschar *rewrite_address(uschar *recipient, BOOL dummy1, BOOL dummy2, rewrite_rule
35   *dummy3, int dummy4)
36 {
37 return recipient;
38 }
39
40 uschar *rewrite_address_qualify(uschar *recipient, BOOL dummy1)
41 {
42 return recipient;
43 }
44
45 #endif
46
47
48
49
50 /*************************************************
51 *             Find the end of an address         *
52 *************************************************/
53
54 /* Scan over a string looking for the termination of an address at a comma,
55 or end of the string. It's the source-routed addresses which cause much pain
56 here. Although Exim ignores source routes, it must recognize such addresses, so
57 we cannot get rid of this logic.
58
59 Argument:
60   s        pointer to the start of an address
61   nl_ends  if TRUE, '\n' terminates an address
62
63 Returns:   pointer past the end of the address
64            (i.e. points to null or comma)
65 */
66
67 uschar *
68 parse_find_address_end(uschar *s, BOOL nl_ends)
69 {
70 BOOL source_routing = *s == '@';
71 int no_term = source_routing? 1 : 0;
72
73 while (*s != 0 && (*s != ',' || no_term > 0) && (*s != '\n' || !nl_ends))
74   {
75   /* Skip single quoted characters. Strictly these should not occur outside
76   quoted strings in RFC 822 addresses, but they can in RFC 821 addresses. Pity
77   about the lack of consistency, isn't it? */
78
79   if (*s == '\\' && s[1] != 0) s += 2;
80
81   /* Skip quoted items that are not inside brackets. Note that
82   quoted pairs are allowed inside quoted strings. */
83
84   else if (*s == '\"')
85     {
86     while (*(++s) != 0 && (*s != '\n' || !nl_ends))
87       {
88       if (*s == '\\' && s[1] != 0) s++;
89         else if (*s == '\"') { s++; break; }
90       }
91     }
92
93   /* Skip comments, which may include nested brackets, but quotes
94   are not recognized inside comments, though quoted pairs are. */
95
96   else if (*s == '(')
97     {
98     int level = 1;
99     while (*(++s) != 0 && (*s != '\n' || !nl_ends))
100       {
101       if (*s == '\\' && s[1] != 0) s++;
102         else if (*s == '(') level++;
103           else if (*s == ')' && --level <= 0) { s++; break; }
104       }
105     }
106
107   /* Non-special character; just advance. Passing the colon in a source
108   routed address means that any subsequent comma or colon may terminate unless
109   inside angle brackets. */
110
111   else
112     {
113     if (*s == '<')
114       {
115       source_routing = s[1] == '@';
116       no_term = source_routing? 2 : 1;
117       }
118     else if (*s == '>') no_term--;
119     else if (source_routing && *s == ':') no_term--;
120     s++;
121     }
122   }
123
124 return s;
125 }
126
127
128
129 /*************************************************
130 *            Find last @ in an address           *
131 *************************************************/
132
133 /* This function is used when we have something that may not qualified. If we
134 know it's qualified, searching for the rightmost '@' is sufficient. Here we
135 have to be a bit more clever than just a plain search, in order to handle
136 unqualified local parts like "thing@thong" correctly. Since quotes may not
137 legally be part of a domain name, we can give up on hitting the first quote
138 when searching from the right. Now that the parsing also permits the RFC 821
139 form of address, where quoted-pairs are allowed in unquoted local parts, we
140 must take care to handle that too.
141
142 Argument:  pointer to an address, possibly unqualified
143 Returns:   pointer to the last @ in an address, or NULL if none
144 */
145
146 const uschar *
147 parse_find_at(const uschar *s)
148 {
149 const uschar * t = s + Ustrlen(s);
150 while (--t >= s)
151   if (*t == '@')
152     {
153     int backslash_count = 0;
154     const uschar *tt = t - 1;
155     while (tt > s && *tt-- == '\\') backslash_count++;
156     if ((backslash_count & 1) == 0) return t;
157     }
158   else if (*t == '\"')
159     return NULL;
160
161 return NULL;
162 }
163
164
165
166
167 /***************************************************************************
168 * In all the functions below that read a particular object type from       *
169 * the input, return the new value of the pointer s (the first argument),   *
170 * and put the object into the store pointed to by t (the second argument), *
171 * adding a terminating zero. If no object is found, t will point to zero   *
172 * on return.                                                               *
173 ***************************************************************************/
174
175
176 /*************************************************
177 *          Skip white space and comment          *
178 *************************************************/
179
180 /* Algorithm:
181   (1) Skip spaces.
182   (2) If uschar not '(', return.
183   (3) Skip till matching ')', not counting any characters
184       escaped with '\'.
185   (4) Move past ')' and goto (1).
186
187 The start of the last potential comment position is remembered to
188 make it possible to ignore comments at the end of compound items.
189
190 Argument: current character pointer
191 Returns:  new character pointer
192 */
193
194 static const uschar *
195 skip_comment(const uschar *s)
196 {
197 last_comment_position = s;
198 while (*s)
199   {
200   int c, level;
201
202   if (Uskip_whitespace(&s) != '(') break;
203   level = 1;
204   while((c = *(++s)))
205     {
206     if (c == '(') level++;
207     else if (c == ')') { if (--level <= 0) { s++; break; } }
208     else if (c == '\\' && s[1] != 0) s++;
209     }
210   }
211 return s;
212 }
213
214
215
216 /*************************************************
217 *             Read a domain                      *
218 *************************************************/
219
220 /* A domain is a sequence of subdomains, separated by dots. See comments below
221 for detailed syntax of the subdomains.
222
223 If allow_domain_literals is TRUE, a "domain" may also be an IP address enclosed
224 in []. Make sure the output is set to the null string if there is a syntax
225 error as well as if there is no domain at all.
226
227 Arguments:
228   s          current character pointer
229   t          where to put the domain
230   errorptr   put error message here on failure (*t will be 0 on exit)
231
232 Returns:     new character pointer
233 */
234
235 static const uschar *
236 read_domain(const uschar *s, uschar *t, uschar **errorptr)
237 {
238 uschar *tt = t;
239 s = skip_comment(s);
240
241 /* Handle domain literals if permitted. An RFC 822 domain literal may contain
242 any character except [ ] \, including linear white space, and may contain
243 quoted characters. However, RFC 821 restricts literals to being dot-separated
244 3-digit numbers, and we make the obvious extension for IPv6. Go for a sequence
245 of digits, dots, hex digits, and colons here; later this will be checked for
246 being a syntactically valid IP address if it ever gets to a router.
247
248 Allow both the formal IPv6 form, with IPV6: at the start, and the informal form
249 without it, and accept IPV4: as well, 'cause someone will use it sooner or
250 later. */
251
252 if (*s == '[')
253   {
254   *t++ = *s++;
255
256   if (strncmpic(s, US"IPv6:", 5) == 0 || strncmpic(s, US"IPv4:", 5) == 0)
257     {
258     memcpy(t, s, 5);
259     t += 5;
260     s += 5;
261     }
262   while (*s == '.' || *s == ':' || isxdigit(*s)) *t++ = *s++;
263
264   if (*s == ']') *t++ = *s++; else
265     {
266     *errorptr = US"malformed domain literal";
267     *tt = 0;
268     }
269
270   if (!allow_domain_literals)
271     {
272     *errorptr = US"domain literals not allowed";
273     *tt = 0;
274     }
275   *t = 0;
276   return skip_comment(s);
277   }
278
279 /* Handle a proper domain, which is a sequence of dot-separated atoms. Remove
280 trailing dots if strip_trailing_dot is set. A subdomain is an atom.
281
282 An atom is a sequence of any characters except specials, space, and controls.
283 The specials are ( ) < > @ , ; : \ " . [ and ]. This is the rule for RFC 822
284 and its successor (RFC 2822). However, RFC 821 and its successor (RFC 2821) is
285 tighter, allowing only letters, digits, and hyphens, not starting with a
286 hyphen.
287
288 There used to be a global flag that got set when checking addresses that came
289 in over SMTP and which should therefore should be checked according to the
290 stricter rule. However, it seems silly to make the distinction, because I don't
291 suppose anybody ever uses local domains that are 822-compliant and not
292 821-compliant. Furthermore, Exim now has additional data on the spool file line
293 after an address (after "one_time" processing), and it makes use of a #
294 character to delimit it. When I wrote that code, I forgot about this 822-domain
295 stuff, and assumed # could never appear in a domain.
296
297 So the old code is now cut out for Release 4.11 onwards, on 09-Aug-02. In a few
298 years, when we are sure this isn't actually causing trouble, throw it away.
299
300 March 2003: the story continues: There is a camp that is arguing for the use of
301 UTF-8 in domain names as the way to internationalization, and other MTAs
302 support this. Therefore, we now have a flag that permits the use of characters
303 with values greater than 127, encoded in UTF-8, in subdomains, so that Exim can
304 be used experimentally in this way. */
305
306 for (;;)
307   {
308   uschar *tsave = t;
309
310 /*********************
311   if (rfc821_domains)
312     {
313     if (*s != '-') while (isalnum(*s) || *s == '-') *t++ = *s++;
314     }
315   else
316     while (!mac_iscntrl_or_special(*s)) *t++ = *s++;
317 *********************/
318
319   if (*s != '-')
320     {
321     /* Only letters, digits, and hyphens */
322
323     if (!allow_utf8_domains)
324       {
325       while (isalnum(*s) || *s == '-') *t++ = *s++;
326       }
327
328     /* Permit legal UTF-8 characters to be included */
329
330     else for(;;)
331       {
332       int i, d;
333       if (isalnum(*s) || *s == '-')    /* legal ascii characters */
334         {
335         *t++ = *s++;
336         continue;
337         }
338       if ((*s & 0xc0) != 0xc0) break;  /* not start of UTF-8 character */
339       d = *s << 2;
340       for (i = 1; i < 6; i++)          /* i is the number of additional bytes */
341         {
342         if ((d & 0x80) == 0) break;
343         d <<= 1;
344         }
345       if (i == 6) goto BAD_UTF8;       /* invalid UTF-8 */
346       *t++ = *s++;                     /* leading UTF-8 byte */
347       while (i-- > 0)                  /* copy and check remainder */
348         {
349         if ((*s & 0xc0) != 0x80)
350           {
351           BAD_UTF8:
352           *errorptr = US"invalid UTF-8 byte sequence";
353           *tt = 0;
354           return s;
355           }
356         *t++ = *s++;
357         }
358       }    /* End of loop for UTF-8 character */
359     }      /* End of subdomain */
360
361   s = skip_comment(s);
362   *t = 0;
363
364   if (t == tsave)   /* empty component */
365     {
366     if (strip_trailing_dot && t > tt && *s != '.') t[-1] = 0; else
367       {
368       *errorptr = US"domain missing or malformed";
369       *tt = 0;
370       }
371     return s;
372     }
373
374   if (*s != '.') break;
375   *t++ = *s++;
376   s = skip_comment(s);
377   }
378
379 return s;
380 }
381
382
383
384 /*************************************************
385 *            Read a local-part                   *
386 *************************************************/
387
388 /* A local-part is a sequence of words, separated by periods. A null word
389 between dots is not strictly allowed but apparently many mailers permit it,
390 so, sigh, better be compatible. Even accept a trailing dot...
391
392 A <word> is either a quoted string, or an <atom>, which is a sequence
393 of any characters except specials, space, and controls. The specials are
394 ( ) < > @ , ; : \ " . [ and ]. In RFC 822, a single quoted character, (a
395 quoted-pair) is not allowed in a word. However, in RFC 821, it is permitted in
396 the local part of an address. Rather than have separate parsing functions for
397 the different cases, take the liberal attitude always. At least one MUA is
398 happy to recognize this case; I don't know how many other programs do.
399
400 Arguments:
401   s           current character pointer
402   t           where to put the local part
403   error       where to point error text
404   allow_null  TRUE if an empty local part is not an error
405
406 Returns:   new character pointer
407 */
408
409 static const uschar *
410 read_local_part(const uschar *s, uschar *t, uschar **error, BOOL allow_null)
411 {
412 uschar *tt = t;
413 *error = NULL;
414 for (;;)
415   {
416   int c;
417   uschar *tsave = t;
418   s = skip_comment(s);
419
420   /* Handle a quoted string */
421
422   if (*s == '\"')
423     {
424     *t++ = '\"';
425     while ((c = *++s) && c != '\"')
426       {
427       *t++ = c;
428       if (c == '\\' && s[1]) *t++ = *++s;
429       }
430     if (c == '\"')
431       {
432       s++;
433       *t++ = '\"';
434       }
435     else
436       {
437       *error = US"unmatched doublequote in local part";
438       return s;
439       }
440     }
441
442   /* Handle an atom, but allow quoted pairs within it. */
443
444   else while (!mac_iscntrl_or_special(*s) || *s == '\\')
445     {
446     c = *t++ = *s++;
447     if (c == '\\' && *s) *t++ = *s++;
448     }
449
450   /* Terminate the word and skip subsequent comment */
451
452   *t = 0;
453   s = skip_comment(s);
454
455   /* If we have read a null component at this point, give an error unless it is
456   terminated by a dot - an extension to RFC 822 - or if it is the first
457   component of the local part and an empty local part is permitted, in which
458   case just return normally. */
459
460   if (t == tsave && *s != '.')
461     {
462     if (t == tt && !allow_null)
463       *error = US"missing or malformed local part";
464     return s;
465     }
466
467   /* Anything other than a dot terminates the local part. Treat multiple dots
468   as a single dot, as this seems to be a common extension. */
469
470   if (*s != '.') break;
471   do { *t++ = *s++; } while (*s == '.');
472   }
473
474 return s;
475 }
476
477
478 /*************************************************
479 *            Read route part of route-addr       *
480 *************************************************/
481
482 /* The pointer is at the initial "@" on entry. Return it following the
483 terminating colon. Exim no longer supports the use of source routes, but it is
484 required to accept the syntax.
485
486 Arguments:
487   s          current character pointer
488   t          where to put the route
489   errorptr   where to put an error message
490
491 Returns:     new character pointer
492 */
493
494 static const uschar *
495 read_route(const uschar *s, uschar *t, uschar **errorptr)
496 {
497 BOOL commas = FALSE;
498 *errorptr = NULL;
499
500 while (*s == '@')
501   {
502   *t++ = '@';
503   s = read_domain(s+1, t, errorptr);
504   if (*t == 0) return s;
505   t += Ustrlen((const uschar *)t);
506   if (*s != ',') break;
507   *t++ = *s++;
508   commas = TRUE;
509   s = skip_comment(s);
510   }
511
512 if (*s == ':') *t++ = *s++;
513
514 /* If there is no colon, and there were no commas, the most likely error
515 is in fact a missing local part in the address rather than a missing colon
516 after the route. */
517
518 else *errorptr = commas?
519   US"colon expected after route list" :
520   US"no local part";
521
522 /* Terminate the route and return */
523
524 *t = 0;
525 return skip_comment(s);
526 }
527
528
529
530 /*************************************************
531 *                Read addr-spec                  *
532 *************************************************/
533
534 /* Addr-spec is local-part@domain. We make the domain optional -
535 the expected terminator for the whole thing is passed to check this.
536 This function is called only when we know we have a route-addr.
537
538 Arguments:
539   s          current character pointer
540   t          where to put the addr-spec
541   term       expected terminator (0 or >)
542   errorptr   where to put an error message
543   domainptr  set to point to the start of the domain
544
545 Returns:     new character pointer
546 */
547
548 static const uschar *
549 read_addr_spec(const uschar *s, uschar *t, int term, uschar **errorptr,
550   uschar **domainptr)
551 {
552 s = read_local_part(s, t, errorptr, FALSE);
553 if (*errorptr == NULL)
554   if (*s != term)
555     if (*s != '@')
556       *errorptr = string_sprintf("\"@\" or \".\" expected after \"%s\"", t);
557     else
558       {
559       t += Ustrlen((const uschar *)t);
560       *t++ = *s++;
561       *domainptr = t;
562       s = read_domain(s, t, errorptr);
563       }
564 return s;
565 }
566
567
568
569 /*************************************************
570 *         Extract operative address              *
571 *************************************************/
572
573 /* This function extracts an operative address from a full RFC822 mailbox and
574 returns it in a piece of dynamic store. We take the easy way and get a piece
575 of store the same size as the input, and then copy into it whatever is
576 necessary. If we cannot find a valid address (syntax error), return NULL, and
577 point the error pointer to the reason. The arguments "start" and "end" are used
578 to return the offsets of the first and one past the last characters in the
579 original mailbox of the address that has been extracted, to aid in re-writing.
580 The argument "domain" is set to point to the first character after "@" in the
581 final part of the returned address, or zero if there is no @.
582
583 Exim no longer supports the use of source routed addresses (those of the form
584 @domain,...:route_addr). It recognizes the syntax, but collapses such addresses
585 down to their final components. Formerly, collapse_source_routes had to be set
586 to achieve this effect. RFC 1123 allows collapsing with MAY, while the revision
587 of RFC 821 had increased this to SHOULD, so I've gone for it, because it makes
588 a lot of code elsewhere in Exim much simpler.
589
590 There are some special fudges here for handling RFC 822 group address notation
591 which may appear in certain headers. If the flag parse_allow_group is set
592 TRUE and parse_found_group is FALSE when this function is called, an address
593 which is the start of a group (i.e. preceded by a phrase and a colon) is
594 recognized; the phrase is ignored and the flag parse_found_group is set. If
595 this flag is TRUE at the end of an address, and if an extraneous semicolon is
596 found, it is ignored and the flag is cleared.
597
598 This logic is used only when scanning through addresses in headers, either to
599 fulfil the -t option, or for rewriting, or for checking header syntax. Because
600 the group "state" has to be remembered between multiple calls of this function,
601 the variables parse_{allow,found}_group are global. It is important to ensure
602 that they are reset to FALSE at the end of scanning a header's list of
603 addresses.
604
605 Arguments:
606   mailbox     points to the RFC822 mailbox
607   errorptr    where to point an error message
608   start       set to start offset in mailbox
609   end         set to end offset in mailbox
610   domain      set to domain offset in result, or 0 if no domain present
611   allow_null  allow <> if TRUE
612
613 Returns:      points to the extracted address, or NULL on error
614 */
615
616 #define FAILED(s) { *errorptr = s; goto PARSE_FAILED; }
617
618 uschar *
619 parse_extract_address(const uschar *mailbox, uschar **errorptr, int *start, int *end,
620   int *domain, BOOL allow_null)
621 {
622 uschar *yield = store_get(Ustrlen(mailbox) + 1, is_tainted(mailbox));
623 const uschar *startptr, *endptr;
624 const uschar *s = US mailbox;
625 uschar *t = US yield;
626
627 *domain = 0;
628
629 /* At the start of the string we expect either an addr-spec or a phrase
630 preceding a <route-addr>. If groups are allowed, we might also find a phrase
631 preceding a colon and an address. If we find an initial word followed by
632 a dot, strict interpretation of the RFC would cause it to be taken
633 as the start of an addr-spec. However, many mailers break the rules
634 and use addresses of the form "a.n.other <ano@somewhere>" and so we
635 allow this case. */
636
637 RESTART:   /* Come back here after passing a group name */
638
639 s = skip_comment(s);
640 startptr = s;                                 /* In case addr-spec */
641 s = read_local_part(s, t, errorptr, TRUE);    /* Dot separated words */
642 if (*errorptr) goto PARSE_FAILED;
643
644 /* If the terminator is neither < nor @ then the format of the address
645 must either be a bare local-part (we are now at the end), or a phrase
646 followed by a route-addr (more words must follow). */
647
648 if (*s != '@' && *s != '<')
649   {
650   if (*s == 0 || *s == ';')
651     {
652     if (*t == 0) FAILED(US"empty address");
653     endptr = last_comment_position;
654     goto PARSE_SUCCEEDED;              /* Bare local part */
655     }
656
657   /* Expect phrase route-addr, or phrase : if groups permitted, but allow
658   dots in the phrase; complete the loop only when '<' or ':' is encountered -
659   end of string will produce a null local_part and therefore fail. We don't
660   need to keep updating t, as the phrase isn't to be kept. */
661
662   while (*s != '<' && (!f.parse_allow_group || *s != ':'))
663     {
664     s = read_local_part(s, t, errorptr, FALSE);
665     if (*errorptr)
666       {
667       *errorptr = string_sprintf("%s (expected word or \"<\")", *errorptr);
668       goto PARSE_FAILED;
669       }
670     }
671
672   if (*s == ':')
673     {
674     f.parse_found_group = TRUE;
675     f.parse_allow_group = FALSE;
676     s++;
677     goto RESTART;
678     }
679
680   /* Assert *s == '<' */
681   }
682
683 /* At this point the next character is either '@' or '<'. If it is '@', only a
684 single local-part has previously been read. An angle bracket signifies the
685 start of an <addr-spec>. Throw away anything we have saved so far before
686 processing it. Note that this is "if" rather than "else if" because it's also
687 used after reading a preceding phrase.
688
689 There are a lot of broken sendmails out there that put additional pairs of <>
690 round <route-addr>s.  If strip_excess_angle_brackets is set, allow a limited
691 number of them, as long as they match. */
692
693 if (*s == '<')
694   {
695   uschar *domainptr = yield;
696   BOOL source_routed = FALSE;
697   int bracket_count = 1;
698
699   s++;
700   if (strip_excess_angle_brackets) while (*s == '<')
701    {
702    if(bracket_count++ > 5) FAILED(US"angle-brackets nested too deep");
703    s++;
704    }
705
706   t = yield;
707   startptr = s;
708   s = skip_comment(s);
709
710   /* Read an optional series of routes, each of which is a domain. They
711   are separated by commas and terminated by a colon. However, we totally ignore
712   such routes (RFC 1123 says we MAY, and the revision of RFC 821 says we
713   SHOULD). */
714
715   if (*s == '@')
716     {
717     s = read_route(s, t, errorptr);
718     if (*errorptr) goto PARSE_FAILED;
719     *t = 0;                  /* Ensure route is ignored - probably overkill */
720     source_routed = TRUE;
721     }
722
723   /* Now an addr-spec, terminated by '>'. If there is no preceding route,
724   we must allow an empty addr-spec if allow_null is TRUE, to permit the
725   address "<>" in some circumstances. A source-routed address MUST have
726   a domain in the final part. */
727
728   if (allow_null && !source_routed && *s == '>')
729     {
730     *t = 0;
731     *errorptr = NULL;
732     }
733   else
734     {
735     s = read_addr_spec(s, t, '>', errorptr, &domainptr);
736     if (*errorptr) goto PARSE_FAILED;
737     *domain = domainptr - yield;
738     if (source_routed && *domain == 0)
739       FAILED(US"domain missing in source-routed address");
740     }
741
742   endptr = s;
743   if (*errorptr != NULL) goto PARSE_FAILED;
744   while (bracket_count-- > 0) if (*s++ != '>')
745     {
746     *errorptr = s[-1] == 0
747       ? US"'>' missing at end of address"
748       : string_sprintf("malformed address: %.32s may not follow %.*s",
749           s-1, (int)(s - US mailbox - 1), mailbox);
750     goto PARSE_FAILED;
751     }
752
753   s = skip_comment(s);
754   }
755
756 /* Hitting '@' after the first local-part means we have definitely got an
757 addr-spec, on a strict reading of the RFC, and the rest of the string
758 should be the domain. However, for flexibility we allow for a route-address
759 not enclosed in <> as well, which is indicated by an empty first local
760 part preceding '@'. The source routing is, however, ignored. */
761
762 else if (*t == 0)
763   {
764   uschar *domainptr = yield;
765   s = read_route(s, t, errorptr);
766   if (*errorptr != NULL) goto PARSE_FAILED;
767   *t = 0;         /* Ensure route is ignored - probably overkill */
768   s = read_addr_spec(s, t, 0, errorptr, &domainptr);
769   if (*errorptr != NULL) goto PARSE_FAILED;
770   *domain = domainptr - yield;
771   endptr = last_comment_position;
772   if (*domain == 0) FAILED(US"domain missing in source-routed address");
773   }
774
775 /* This is the strict case of local-part@domain. */
776
777 else
778   {
779   t += Ustrlen((const uschar *)t);
780   *t++ = *s++;
781   *domain = t - yield;
782   s = read_domain(s, t, errorptr);
783   if (*t == 0) goto PARSE_FAILED;
784   endptr = last_comment_position;
785   }
786
787 /* Use goto to get here from the bare local part case. Arrive by falling
788 through for other cases. Endptr may have been moved over whitespace, so
789 move it back past white space if necessary. */
790
791 PARSE_SUCCEEDED:
792 if (*s != 0)
793   {
794   if (f.parse_found_group && *s == ';')
795     {
796     f.parse_found_group = FALSE;
797     f.parse_allow_group = TRUE;
798     }
799   else
800     {
801     *errorptr = string_sprintf("malformed address: %.32s may not follow %.*s",
802       s, (int)(s - US mailbox), mailbox);
803     goto PARSE_FAILED;
804     }
805   }
806 *start = startptr - US mailbox;      /* Return offsets */
807 while (isspace(endptr[-1])) endptr--;
808 *end = endptr - US mailbox;
809
810 /* Although this code has no limitation on the length of address extracted,
811 other parts of Exim may have limits, and in any case, RFC 5321 limits email
812 addresses to 256, so we do a check here, giving an error if the address is
813 ridiculously long. */
814
815 if (*end - *start > EXIM_EMAILADDR_MAX)
816   {
817   *errorptr = string_sprintf("address is ridiculously long: %.64s...", yield);
818   return NULL;
819   }
820
821 return yield;
822
823 /* Use goto (via the macro FAILED) to get to here from a variety of places.
824 We might have an empty address in a group - the caller can choose to ignore
825 this. We must, however, keep the flags correct. */
826
827 PARSE_FAILED:
828 if (f.parse_found_group && *s == ';')
829   {
830   f.parse_found_group = FALSE;
831   f.parse_allow_group = TRUE;
832   }
833 return NULL;
834 }
835
836 #undef FAILED
837
838
839
840 /*************************************************
841 *        Quote according to RFC 2047             *
842 *************************************************/
843
844 /* This function is used for quoting text in headers according to RFC 2047.
845 If the only characters that strictly need quoting are spaces, we return the
846 original string, unmodified.
847
848 Hmmph. As always, things get perverted for other uses. This function was
849 originally for the "phrase" part of addresses. Now it is being used for much
850 longer texts in ACLs and via the ${rfc2047: expansion item. This means we have
851 to check for overlong "encoded-word"s and split them. November 2004.
852
853 Arguments:
854   string       the string to quote - already checked to contain non-printing
855                  chars
856   len          the length of the string
857   charset      the name of the character set; NULL => iso-8859-1
858   fold         if TRUE, a newline is inserted before the separating space when
859                  more than one encoded-word is generated
860
861 Returns:       pointer to the original string, if no quoting needed, or
862                pointer to allocated memory containing the quoted string
863 */
864
865 const uschar *
866 parse_quote_2047(const uschar *string, int len, uschar *charset, BOOL fold)
867 {
868 const uschar * s = string;
869 int hlen, l;
870 BOOL coded = FALSE;
871 BOOL first_byte = FALSE;
872 gstring * g =
873   string_fmt_append(NULL, "=?%s?Q?", charset ? charset : US"iso-8859-1");
874
875 hlen = l = g->ptr;
876
877 for (s = string; len > 0; s++, len--)
878   {
879   int ch = *s;
880
881   if (g->ptr - l > 67 && !first_byte)
882     {
883     g = fold ? string_catn(g, US"?=\n ", 4) : string_catn(g, US"?= ", 3);
884     l = g->ptr;
885     g = string_catn(g, g->s, hlen);
886     }
887
888   if (  ch < 33 || ch > 126
889      || Ustrchr("?=()<>@,;:\\\".[]_", ch) != NULL)
890     {
891     if (ch == ' ')
892       {
893       g = string_catn(g, US"_", 1);
894       first_byte = FALSE;
895       }
896     else
897       {
898       g = string_fmt_append(g, "=%02X", ch);
899       coded = TRUE;
900       first_byte = !first_byte;
901       }
902     }
903   else
904     { g = string_catn(g, s, 1); first_byte = FALSE; }
905   }
906
907 g = string_catn(g, US"?=", 2);
908 return coded ? string_from_gstring(g) : string;
909 }
910
911
912
913
914 /*************************************************
915 *            Fix up an RFC 822 "phrase"          *
916 *************************************************/
917
918 /* This function is called to repair any syntactic defects in the "phrase" part
919 of an RFC822 address. In particular, it is applied to the user's name as read
920 from the passwd file when accepting a local message, and to the data from the
921 -F option.
922
923 If the string contains existing quoted strings or comments containing
924 freestanding quotes, then we just quote those bits that need quoting -
925 otherwise it would get awfully messy and probably not look good. If not, we
926 quote the whole thing if necessary. Thus
927
928    John Q. Smith            =>  "John Q. Smith"
929    John "Jack" Smith        =>  John "Jack" Smith
930    John "Jack" Q. Smith     =>  John "Jack" "Q." Smith
931    John (Jack) Q. Smith     =>  "John (Jack) Q. Smith"
932    John ("Jack") Q. Smith   =>  John ("Jack") "Q." Smith
933 but
934    John (\"Jack\") Q. Smith =>  "John (\"Jack\") Q. Smith"
935
936 Sheesh! This is tedious code. It is a great pity that the syntax of RFC822 is
937 the way it is...
938
939 August 2000: Additional code added:
940
941   Previously, non-printing characters were turned into question marks, which do
942   not need to be quoted.
943
944   Now, a different tactic is used if there are any non-printing ASCII
945   characters. The encoding method from RFC 2047 is used, assuming iso-8859-1 as
946   the character set.
947
948   We *could* use this for all cases, getting rid of the messy original code,
949   but leave it for now. It would complicate simple cases like "John Q. Smith".
950
951 The result is passed back in allocated memory.
952
953 Arguments:
954   phrase       an RFC822 phrase
955   len          the length of the phrase
956
957 Returns:       the fixed RFC822 phrase
958 */
959
960 const uschar *
961 parse_fix_phrase(const uschar *phrase, int len)
962 {
963 int ch, i;
964 BOOL quoted = FALSE;
965 const uschar *s, *end;
966 uschar * buffer;
967 uschar *t, *yield;
968
969 while (len > 0 && isspace(*phrase)) { phrase++; len--; }
970
971 /* See if there are any non-printing characters, and if so, use the RFC 2047
972 encoding for the whole thing. */
973
974 for (i = 0, s = phrase; i < len; i++, s++)
975   if ((*s < 32 && *s != '\t') || *s > 126) break;
976
977 if (i < len)
978   return parse_quote_2047(phrase, len, headers_charset, FALSE);
979
980 /* No non-printers; use the RFC 822 quoting rules */
981
982 if (!len)
983   {
984   return string_copy_taint(US"", is_tainted(phrase));
985   }
986
987 buffer = store_get(len*4, is_tainted(phrase));
988
989 s = phrase;
990 end = s + len;
991 yield = t = buffer + 1;
992
993 while (s < end)
994   {
995   ch = *s++;
996
997   /* Copy over quoted strings, remembering we encountered one */
998
999   if (ch == '\"')
1000     {
1001     *t++ = '\"';
1002     while (s < end && (ch = *s++) != '\"')
1003       {
1004       *t++ = ch;
1005       if (ch == '\\' && s < end) *t++ = *s++;
1006       }
1007     *t++ = '\"';
1008     if (s >= end) break;
1009     quoted = TRUE;
1010     }
1011
1012   /* Copy over comments, noting if they contain freestanding quote
1013   characters */
1014
1015   else if (ch == '(')
1016     {
1017     int level = 1;
1018     *t++ = '(';
1019     while (s < end)
1020       {
1021       ch = *s++;
1022       *t++ = ch;
1023       if (ch == '(') level++;
1024       else if (ch == ')') { if (--level <= 0) break; }
1025       else if (ch == '\\' && s < end) *t++ = *s++ & 127;
1026       else if (ch == '\"') quoted = TRUE;
1027       }
1028     if (ch == 0)
1029       {
1030       while (level--) *t++ = ')';
1031       break;
1032       }
1033     }
1034
1035   /* Handle special characters that need to be quoted */
1036
1037   else if (Ustrchr(")<>@,;:\\.[]", ch) != NULL)
1038     {
1039     /* If hit previous quotes just make one quoted "word" */
1040
1041     if (quoted)
1042       {
1043       uschar *tt = t++;
1044       while (*(--tt) != ' ' && *tt != '\"' && *tt != ')') tt[1] = *tt;
1045       tt[1] = '\"';
1046       *t++ = ch;
1047       while (s < end)
1048         {
1049         ch = *s++;
1050         if (ch == ' ' || ch == '\"') { s--; break; } else *t++ = ch;
1051         }
1052       *t++ = '\"';
1053       }
1054
1055     /* Else quote the whole string so far, and the rest up to any following
1056     quotes. We must treat anything following a backslash as a literal. */
1057
1058     else
1059       {
1060       BOOL escaped = (ch == '\\');
1061       *(--yield) = '\"';
1062       *t++ = ch;
1063
1064       /* Now look for the end or a quote */
1065
1066       while (s < end)
1067         {
1068         ch = *s++;
1069
1070         /* Handle escaped pairs */
1071
1072         if (escaped)
1073           {
1074           *t++ = ch;
1075           escaped = FALSE;
1076           }
1077
1078         else if (ch == '\\')
1079           {
1080           *t++ = ch;
1081           escaped = TRUE;
1082           }
1083
1084         /* If hit subsequent quotes, insert our quote before any trailing
1085         spaces and back up to re-handle the quote in the outer loop. */
1086
1087         else if (ch == '\"')
1088           {
1089           int count = 0;
1090           while (t[-1] == ' ') { t--; count++; }
1091           *t++ = '\"';
1092           while (count-- > 0) *t++ = ' ';
1093           s--;
1094           break;
1095           }
1096
1097         /* If hit a subsequent comment, check it for unescaped quotes,
1098         and if so, end our quote before it. */
1099
1100         else if (ch == '(')
1101           {
1102           const uschar *ss = s;     /* uschar after '(' */
1103           int level = 1;
1104           while(ss < end)
1105             {
1106             ch = *ss++;
1107             if (ch == '(') level++;
1108             else if (ch == ')') { if (--level <= 0) break; }
1109             else if (ch == '\\' && ss+1 < end) ss++;
1110             else if (ch == '\"') { quoted = TRUE; break; }
1111             }
1112
1113           /* Comment contains unescaped quotes; end our quote before
1114           the start of the comment. */
1115
1116           if (quoted)
1117             {
1118             int count = 0;
1119             while (t[-1] == ' ') { t--; count++; }
1120             *t++ = '\"';
1121             while (count-- > 0) *t++ = ' ';
1122             break;
1123             }
1124
1125           /* Comment does not contain unescaped quotes; include it in
1126           our quote. */
1127
1128           else
1129             {
1130             if (ss >= end) ss--;
1131             *t++ = '(';
1132             if (ss < s)
1133               {
1134               /* Someone has ended the string with "<punct>(". */
1135               ss = s;
1136               }
1137             else
1138               {
1139               Ustrncpy(t, s, ss-s);
1140               t += ss-s;
1141               s = ss;
1142               }
1143             }
1144           }
1145
1146         /* Not a comment or quote; include this character in our quotes. */
1147
1148         else *t++ = ch;
1149         }
1150       }
1151
1152     /* Add a final quote if we hit the end of the string. */
1153
1154     if (s >= end) *t++ = '\"';
1155     }
1156
1157   /* Non-special character; just copy it over */
1158
1159   else *t++ = ch;
1160   }
1161
1162 *t = 0;
1163 store_release_above(t+1);
1164 return yield;
1165 }
1166
1167
1168 /*************************************************
1169 *          Extract addresses from a list         *
1170 *************************************************/
1171
1172 /* This function is called by the redirect router to scan a string containing a
1173 list of addresses separated by commas (with optional white space) or by
1174 newlines, and to generate a chain of address items from them. In other words,
1175 to unpick data from an alias or .forward file.
1176
1177 The SunOS5 documentation for alias files is not very clear on the syntax; it
1178 does not say that either a comma or a newline can be used for separation.
1179 However, that is the way Smail does it, so we follow suit.
1180
1181 If a # character is encountered in a white space position, then characters from
1182 there to the next newline are skipped.
1183
1184 If an unqualified address begins with '\', just skip that character. This gives
1185 compatibility with Sendmail's use of \ to prevent looping. Exim has its own
1186 loop prevention scheme which handles other cases too - see the code in
1187 route_address().
1188
1189 An "address" can be a specification of a file or a pipe; the latter may often
1190 need to be quoted because it may contain spaces, but we don't want to retain
1191 the quotes. Quotes may appear in normal addresses too, and should be retained.
1192 We can distinguish between these cases, because in addresses, quotes are used
1193 only for parts of the address, not the whole thing. Therefore, we remove quotes
1194 from items when they entirely enclose them, but not otherwise.
1195
1196 An "address" can also be of the form :include:pathname to include a list of
1197 addresses contained in the specified file.
1198
1199 Any unqualified addresses are qualified with and rewritten if necessary, via
1200 the rewrite_address() function.
1201
1202 Arguments:
1203   s                the list of addresses (typically a complete
1204                      .forward file or a list of entries in an alias file)
1205   options          option bits for permitting or denying various special cases;
1206                      not all bits are relevant here - some are for filter
1207                      files; those we use here are:
1208                        RDO_DEFER
1209                        RDO_FREEZE
1210                        RDO_FAIL
1211                        RDO_BLACKHOLE
1212                        RDO_REWRITE
1213                        RDO_INCLUDE
1214   anchor           where to hang the chain of newly-created addresses. This
1215                      should be initialized to NULL.
1216   error            where to return an error text
1217   incoming domain  domain of the incoming address; used to qualify unqualified
1218                      local parts preceded by \
1219   directory        if NULL, no checks are done on :include: files
1220                    otherwise, included file names must start with the given
1221                      directory
1222   syntax_errors    if not NULL, it carries on after syntax errors in addresses,
1223                      building up a list of errors as error blocks chained on
1224                      here.
1225
1226 Returns:      FF_DELIVERED      addresses extracted
1227               FF_NOTDELIVERED   no addresses extracted, but no errors
1228               FF_BLACKHOLE      :blackhole:
1229               FF_DEFER          :defer:
1230               FF_FAIL           :fail:
1231               FF_INCLUDEFAIL    some problem with :include:; *error set
1232               FF_ERROR          other problems; *error is set
1233 */
1234
1235 int
1236 parse_forward_list(uschar *s, int options, address_item **anchor,
1237   uschar **error, const uschar *incoming_domain, uschar *directory,
1238   error_block **syntax_errors)
1239 {
1240 int count = 0;
1241
1242 DEBUG(D_route) debug_printf("parse_forward_list: %s\n", s);
1243
1244 for (;;)
1245   {
1246   int len;
1247   int special = 0;
1248   int specopt = 0;
1249   int specbit = 0;
1250   uschar *ss, *nexts;
1251   address_item *addr;
1252   BOOL inquote = FALSE;
1253
1254   for (;;)
1255     {
1256     while (isspace(*s) || *s == ',') s++;
1257     if (*s == '#') { while (*s != 0 && *s != '\n') s++; } else break;
1258     }
1259
1260   /* When we reach the end of the list, we return FF_DELIVERED if any child
1261   addresses have been generated. If nothing has been generated, there are two
1262   possibilities: either the list is really empty, or there were syntax errors
1263   that are being skipped. (If syntax errors are not being skipped, an FF_ERROR
1264   return is generated on hitting a syntax error and we don't get here.) For a
1265   truly empty list we return FF_NOTDELIVERED so that the router can decline.
1266   However, if the list is empty only because syntax errors were skipped, we
1267   return FF_DELIVERED. */
1268
1269   if (!*s)
1270     {
1271     return (count > 0 || (syntax_errors && *syntax_errors))
1272       ?  FF_DELIVERED : FF_NOTDELIVERED;
1273
1274     /* This previous code returns FF_ERROR if nothing is generated but a
1275     syntax error has been skipped. I now think it is the wrong approach, but
1276     have left this here just in case, and for the record. */
1277
1278     #ifdef NEVER
1279     if (count > 0) return FF_DELIVERED;   /* Something was generated */
1280
1281     if (syntax_errors == NULL ||          /* Not skipping syntax errors, or */
1282        *syntax_errors == NULL)            /*   we didn't actually skip any */
1283       return FF_NOTDELIVERED;
1284
1285     *error = string_sprintf("no addresses generated: syntax error in %s: %s",
1286        (*syntax_errors)->text2, (*syntax_errors)->text1);
1287     return FF_ERROR;
1288     #endif
1289
1290     }
1291
1292   /* Find the end of the next address. Quoted strings in addresses may contain
1293   escaped characters; I haven't found a proper specification of .forward or
1294   alias files that mentions the quoting properties, but it seems right to do
1295   the escaping thing in all cases, so use the function that finds the end of an
1296   address. However, don't let a quoted string extend over the end of a line. */
1297
1298   ss = parse_find_address_end(s, TRUE);
1299
1300   /* Remember where we finished, for starting the next one. */
1301
1302   nexts = ss;
1303
1304   /* Remove any trailing spaces; we know there's at least one non-space. */
1305
1306   while (isspace((ss[-1]))) ss--;
1307
1308   /* We now have s->start and ss->end of the next address. Remove quotes
1309   if they completely enclose, remembering the address started with a quote
1310   for handling pipes and files. Another round of removal of leading and
1311   trailing spaces is then required. */
1312
1313   if (*s == '\"' && ss[-1] == '\"')
1314     {
1315     s++;
1316     ss--;
1317     inquote = TRUE;
1318     while (s < ss && isspace(*s)) s++;
1319     while (ss > s && isspace((ss[-1]))) ss--;
1320     }
1321
1322   /* Set up the length of the address. */
1323
1324   len = ss - s;
1325
1326   DEBUG(D_route)
1327     {
1328     int save = s[len];
1329     s[len] = 0;
1330     debug_printf("extract item: %s\n", s);
1331     s[len] = save;
1332     }
1333
1334   /* Handle special addresses if permitted. If the address is :unknown:
1335   ignore it - this is for backward compatibility with old alias files. You
1336   don't need to use it nowadays - just generate an empty string. For :defer:,
1337   :blackhole:, or :fail: we have to set up the error message and give up right
1338   away. */
1339
1340   if (Ustrncmp(s, ":unknown:", len) == 0)
1341     {
1342     s = nexts;
1343     continue;
1344     }
1345
1346   if      (Ustrncmp(s, ":defer:", 7) == 0)
1347     { special = FF_DEFER; specopt = RDO_DEFER; }  /* specbit is 0 */
1348   else if (Ustrncmp(s, ":blackhole:", 11) == 0)
1349     { special = FF_BLACKHOLE; specopt = specbit = RDO_BLACKHOLE; }
1350   else if (Ustrncmp(s, ":fail:", 6) == 0)
1351     { special = FF_FAIL; specopt = RDO_FAIL; }  /* specbit is 0 */
1352
1353   if (special != 0)
1354     {
1355     uschar *ss = Ustrchr(s+1, ':') + 1;
1356     if ((options & specopt) == specbit)
1357       {
1358       *error = string_sprintf("\"%.*s\" is not permitted", len, s);
1359       return FF_ERROR;
1360       }
1361     while (*ss != 0 && isspace(*ss)) ss++;
1362     while (s[len] != 0 && s[len] != '\n') len++;
1363     s[len] = 0;
1364     *error = string_copy(ss);
1365     return special;
1366     }
1367
1368   /* If the address is of the form :include:pathname, read the file, and call
1369   this function recursively to extract the addresses from it. If directory is
1370   NULL, do no checks. Otherwise, insist that the file name starts with the
1371   given directory and is a regular file. */
1372
1373   if (Ustrncmp(s, ":include:", 9) == 0)
1374     {
1375     uschar *filebuf;
1376     uschar filename[256];
1377     uschar *t = s+9;
1378     int flen = len - 9;
1379     int frc;
1380     struct stat statbuf;
1381     address_item *last;
1382     FILE *f;
1383
1384     while (flen > 0 && isspace(*t)) { t++; flen--; }
1385
1386     if (flen <= 0)
1387       {
1388       *error = US"file name missing after :include:";
1389       return FF_ERROR;
1390       }
1391
1392     if (flen > 255)
1393       {
1394       *error = string_sprintf("included file name \"%s\" is too long", t);
1395       return FF_ERROR;
1396       }
1397
1398     Ustrncpy(filename, t, flen);
1399     filename[flen] = 0;
1400
1401     /* Insist on absolute path */
1402
1403     if (filename[0] != '/')
1404       {
1405       *error = string_sprintf("included file \"%s\" is not an absolute path",
1406         filename);
1407       return FF_ERROR;
1408       }
1409
1410     /* Check if include is permitted */
1411
1412     if (options & RDO_INCLUDE)
1413       {
1414       *error = US"included files not permitted";
1415       return FF_ERROR;
1416       }
1417
1418     if (is_tainted(filename))
1419       {
1420       *error = string_sprintf("Tainted name '%s' for included file  not permitted\n",
1421        filename);
1422       return FF_ERROR;
1423       }
1424
1425     /* Check file name if required */
1426
1427     if (directory)
1428       {
1429       int len = Ustrlen(directory);
1430       uschar *p = filename + len;
1431
1432       if (Ustrncmp(filename, directory, len) != 0 || *p != '/')
1433         {
1434         *error = string_sprintf("included file %s is not in directory %s",
1435           filename, directory);
1436         return FF_ERROR;
1437         }
1438
1439 #ifdef EXIM_HAVE_OPENAT
1440       /* It is necessary to check that every component inside the directory
1441       is NOT a symbolic link, in order to keep the file inside the directory.
1442       This is mighty tedious. We open the directory and openat every component,
1443       with a flag that fails symlinks. */
1444
1445       {
1446       int fd = exim_open2(CS directory, O_RDONLY);
1447       if (fd < 0)
1448         {
1449         *error = string_sprintf("failed to open directory %s", directory);
1450         return FF_ERROR;
1451         }
1452       while (*p)
1453         {
1454         uschar temp;
1455         int fd2;
1456         uschar * q = p;
1457
1458         while (*++p && *p != '/') ;
1459         temp = *p;
1460         *p = '\0';
1461
1462         fd2 = exim_openat(fd, CS q, O_RDONLY|O_NOFOLLOW);
1463         close(fd);
1464         *p = temp;
1465         if (fd2 < 0)
1466           {
1467           *error = string_sprintf("failed to open %s (component of included "
1468             "file); could be symbolic link", filename);
1469           return FF_ERROR;
1470           }
1471         fd = fd2;
1472         }
1473       f = fdopen(fd, "rb");
1474       }
1475 #else
1476       /* It is necessary to check that every component inside the directory
1477       is NOT a symbolic link, in order to keep the file inside the directory.
1478       This is mighty tedious. It is also not totally foolproof in that it
1479       leaves the possibility of a race attack, but I don't know how to do
1480       any better. */
1481
1482       while (*p)
1483         {
1484         int temp;
1485         while (*++p && *p != '/');
1486         temp = *p;
1487         *p = 0;
1488         if (Ulstat(filename, &statbuf) != 0)
1489           {
1490           *error = string_sprintf("failed to stat %s (component of included "
1491             "file)", filename);
1492           *p = temp;
1493           return FF_ERROR;
1494           }
1495
1496         *p = temp;
1497
1498         if ((statbuf.st_mode & S_IFMT) == S_IFLNK)
1499           {
1500           *error = string_sprintf("included file %s in the %s directory "
1501             "involves a symbolic link", filename, directory);
1502           return FF_ERROR;
1503           }
1504         }
1505 #endif
1506       }
1507
1508 #ifdef EXIM_HAVE_OPENAT
1509     else
1510 #endif
1511       /* Open and stat the file */
1512       f = Ufopen(filename, "rb");
1513
1514     if (!f)
1515       {
1516       *error = string_open_failed(errno, "included file %s", filename);
1517       return FF_INCLUDEFAIL;
1518       }
1519
1520     if (fstat(fileno(f), &statbuf) != 0)
1521       {
1522       *error = string_sprintf("failed to stat included file %s: %s",
1523         filename, strerror(errno));
1524       (void)fclose(f);
1525       return FF_INCLUDEFAIL;
1526       }
1527
1528     /* If directory was checked, double check that we opened a regular file */
1529
1530     if (directory && (statbuf.st_mode & S_IFMT) != S_IFREG)
1531       {
1532       *error = string_sprintf("included file %s is not a regular file in "
1533         "the %s directory", filename, directory);
1534       return FF_ERROR;
1535       }
1536
1537     /* Get a buffer and read the contents */
1538
1539     if (statbuf.st_size > MAX_INCLUDE_SIZE)
1540       {
1541       *error = string_sprintf("included file %s is too big (max %d)",
1542         filename, MAX_INCLUDE_SIZE);
1543       return FF_ERROR;
1544       }
1545
1546     filebuf = store_get(statbuf.st_size + 1, is_tainted(filename));
1547     if (fread(filebuf, 1, statbuf.st_size, f) != statbuf.st_size)
1548       {
1549       *error = string_sprintf("error while reading included file %s: %s",
1550         filename, strerror(errno));
1551       (void)fclose(f);
1552       return FF_ERROR;
1553       }
1554     filebuf[statbuf.st_size] = 0;
1555     (void)fclose(f);
1556
1557     addr = NULL;
1558     frc = parse_forward_list(filebuf, options, &addr,
1559       error, incoming_domain, directory, syntax_errors);
1560     if (frc != FF_DELIVERED && frc != FF_NOTDELIVERED) return frc;
1561
1562     if (addr)
1563       {
1564       for (last = addr; last->next; last = last->next) count++;
1565       last->next = *anchor;
1566       *anchor = addr;
1567       count++;
1568       }
1569     }
1570
1571   /* Else (not :include:) ensure address is syntactically correct and fully
1572   qualified if not a pipe or a file, removing a leading \ if present on an
1573   unqualified address. For pipes and files we must handle quoting. It's
1574   not quite clear exactly what to do for partially quoted things, but the
1575   common case of having the whole thing in quotes is straightforward. If this
1576   was the case, inquote will have been set TRUE above and the quotes removed.
1577
1578   There is a possible ambiguity over addresses whose local parts start with
1579   a vertical bar or a slash, and the latter do in fact occur, thanks to X.400.
1580   Consider a .forward file that contains the line
1581
1582      /X=xxx/Y=xxx/OU=xxx/@some.gate.way
1583
1584   Is this a file or an X.400 address? Does it make any difference if it is in
1585   quotes? On the grounds that file names of this type are rare, Exim treats
1586   something that parses as an RFC 822 address and has a domain as an address
1587   rather than a file or a pipe. This is also how an address such as the above
1588   would be treated if it came in from outside. */
1589
1590   else
1591     {
1592     int start, end, domain;
1593     const uschar *recipient = NULL;
1594     int save = s[len];
1595     s[len] = 0;
1596
1597     /* If it starts with \ and the rest of it parses as a valid mail address
1598     without a domain, carry on with that address, but qualify it with the
1599     incoming domain. Otherwise arrange for the address to fall through,
1600     causing an error message on the re-parse. */
1601
1602     if (*s == '\\')
1603       {
1604       recipient =
1605         parse_extract_address(s+1, error, &start, &end, &domain, FALSE);
1606       if (recipient)
1607         recipient = domain != 0 ? NULL :
1608           string_sprintf("%s@%s", recipient, incoming_domain);
1609       }
1610
1611     /* Try parsing the item as an address. */
1612
1613     if (!recipient) recipient =
1614       parse_extract_address(s, error, &start, &end, &domain, FALSE);
1615
1616     /* If item starts with / or | and is not a valid address, or there
1617     is no domain, treat it as a file or pipe. If it was a quoted item,
1618     remove the quoting occurrences of \ within it. */
1619
1620     if ((*s == '|' || *s == '/') && (recipient == NULL || domain == 0))
1621       {
1622       uschar *t = store_get(Ustrlen(s) + 1, is_tainted(s));
1623       uschar *p = t;
1624       uschar *q = s;
1625       while (*q != 0)
1626         {
1627         if (inquote)
1628           {
1629           *p++ = (*q == '\\')? *(++q) : *q;
1630           q++;
1631           }
1632         else *p++ = *q++;
1633         }
1634       *p = 0;
1635       addr = deliver_make_addr(t, TRUE);
1636       setflag(addr, af_pfr);                   /* indicates pipe/file/reply */
1637       if (*s != '|') setflag(addr, af_file);   /* indicates file */
1638       }
1639
1640     /* Item must be an address. Complain if not, else qualify, rewrite and set
1641     up the control block. It appears that people are in the habit of using
1642     empty addresses but with comments as a way of putting comments into
1643     alias and forward files. Therefore, ignore the error "empty address".
1644     Mailing lists might want to tolerate syntax errors; there is therefore
1645     an option to do so. */
1646
1647     else
1648       {
1649       if (recipient == NULL)
1650         {
1651         if (Ustrcmp(*error, "empty address") == 0)
1652           {
1653           *error = NULL;
1654           s[len] = save;
1655           s = nexts;
1656           continue;
1657           }
1658
1659         if (syntax_errors != NULL)
1660           {
1661           error_block *e = store_get(sizeof(error_block), FALSE);
1662           error_block *last = *syntax_errors;
1663           if (last == NULL) *syntax_errors = e; else
1664             {
1665             while (last->next != NULL) last = last->next;
1666             last->next = e;
1667             }
1668           e->next = NULL;
1669           e->text1 = *error;
1670           e->text2 = string_copy(s);
1671           s[len] = save;
1672           s = nexts;
1673           continue;
1674           }
1675         else
1676           {
1677           *error = string_sprintf("%s in \"%s\"", *error, s);
1678           s[len] = save;   /* _after_ using it for *error */
1679           return FF_ERROR;
1680           }
1681         }
1682
1683       /* Address was successfully parsed. Rewrite, and then make an address
1684       block. */
1685
1686       recipient = ((options & RDO_REWRITE) != 0)?
1687         rewrite_address(recipient, TRUE, FALSE, global_rewrite_rules,
1688           rewrite_existflags) :
1689         rewrite_address_qualify(recipient, TRUE);       /*XXX loses track of const */
1690       addr = deliver_make_addr(US recipient, TRUE);  /* TRUE => copy recipient, so deconst ok */
1691       }
1692
1693     /* Restore the final character in the original data, and add to the
1694     output chain. */
1695
1696     s[len] = save;
1697     addr->next = *anchor;
1698     *anchor = addr;
1699     count++;
1700     }
1701
1702   /* Advance pointer for the next address */
1703
1704   s = nexts;
1705   }
1706 }
1707
1708
1709 /*************************************************
1710 *            Extract a Message-ID                *
1711 *************************************************/
1712
1713 /* This function is used to extract message ids from In-Reply-To: and
1714 References: header lines.
1715
1716 Arguments:
1717   str          pointer to the start of the message-id
1718   yield        put pointer to the message id (in dynamic memory) here
1719   error        put error message here on failure
1720
1721 Returns:       points after the processed message-id or NULL on error
1722 */
1723
1724 const uschar *
1725 parse_message_id(const uschar *str, uschar **yield, uschar **error)
1726 {
1727 uschar *domain = NULL;
1728 uschar *id;
1729 rmark reset_point;
1730
1731 str = skip_comment(str);
1732 if (*str != '<')
1733   {
1734   *error = US"Missing '<' before message-id";
1735   return NULL;
1736   }
1737
1738 /* Getting a block the size of the input string will definitely be sufficient
1739 for the answer, but it may also be very long if we are processing a header
1740 line. Therefore, take care to release unwanted store afterwards. */
1741
1742 reset_point = store_mark();
1743 id = *yield = store_get(Ustrlen(str) + 1, is_tainted(str));
1744 *id++ = *str++;
1745
1746 str = read_addr_spec(str, id, '>', error, &domain);
1747
1748 if (!*error)
1749   {
1750   if (*str != '>') *error = US"Missing '>' after message-id";
1751     else if (domain == NULL) *error = US"domain missing in message-id";
1752   }
1753
1754 if (*error)
1755   {
1756   store_reset(reset_point);
1757   return NULL;
1758   }
1759
1760 while (*id) id++;
1761 *id++ = *str++;
1762 *id++ = 0;
1763 store_release_above(id);
1764
1765 return skip_comment(str);
1766 }
1767
1768
1769 /*************************************************
1770 *        Parse a fixed digit number              *
1771 *************************************************/
1772
1773 /* Parse a string containing an ASCII encoded fixed digits number
1774
1775 Arguments:
1776   str          pointer to the start of the ASCII encoded number
1777   n            pointer to the resulting value
1778   digits       number of required digits
1779
1780 Returns:       points after the processed date or NULL on error
1781 */
1782
1783 static const uschar *
1784 parse_number(const uschar *str, int *n, int digits)
1785 {
1786 *n=0;
1787 while (digits--)
1788   {
1789   if (*str<'0' || *str>'9') return NULL;
1790   *n=10*(*n)+(*str++-'0');
1791   }
1792 return str;
1793 }
1794
1795
1796 /*************************************************
1797 *        Parse a RFC 2822 day of week            *
1798 *************************************************/
1799
1800 /* Parse the day of the week from a RFC 2822 date, but do not
1801    decode it, because it is only for humans.
1802
1803 Arguments:
1804   str          pointer to the start of the day of the week
1805
1806 Returns:       points after the parsed day or NULL on error
1807 */
1808
1809 static const uschar *
1810 parse_day_of_week(const uschar * str)
1811 {
1812 /*
1813 day-of-week     =       ([FWS] day-name) / obs-day-of-week
1814
1815 day-name        =       "Mon" / "Tue" / "Wed" / "Thu" /
1816                         "Fri" / "Sat" / "Sun"
1817
1818 obs-day-of-week =       [CFWS] day-name [CFWS]
1819 */
1820
1821 static const uschar *day_name[7]={ US"mon", US"tue", US"wed", US"thu", US"fri", US"sat", US"sun" };
1822 int i;
1823 uschar day[4];
1824
1825 str = skip_comment(str);
1826 for (i = 0; i < 3; ++i)
1827   {
1828   if ((day[i] = tolower(*str)) == '\0') return NULL;
1829   ++str;
1830   }
1831 day[3] = '\0';
1832 for (i = 0; i<7; ++i) if (Ustrcmp(day,day_name[i]) == 0) break;
1833 if (i == 7) return NULL;
1834 return skip_comment(str);
1835 }
1836
1837
1838 /*************************************************
1839 *            Parse a RFC 2822 date               *
1840 *************************************************/
1841
1842 /* Parse the date part of a RFC 2822 date-time, extracting the
1843    day, month and year.
1844
1845 Arguments:
1846   str          pointer to the start of the date
1847   d            pointer to the resulting day
1848   m            pointer to the resulting month
1849   y            pointer to the resulting year
1850
1851 Returns:       points after the processed date or NULL on error
1852 */
1853
1854 static const uschar *
1855 parse_date(const uschar *str, int *d, int *m, int *y)
1856 {
1857 /*
1858 date            =       day month year
1859
1860 year            =       4*DIGIT / obs-year
1861
1862 obs-year        =       [CFWS] 2*DIGIT [CFWS]
1863
1864 month           =       (FWS month-name FWS) / obs-month
1865
1866 month-name      =       "Jan" / "Feb" / "Mar" / "Apr" /
1867                         "May" / "Jun" / "Jul" / "Aug" /
1868                         "Sep" / "Oct" / "Nov" / "Dec"
1869
1870 obs-month       =       CFWS month-name CFWS
1871
1872 day             =       ([FWS] 1*2DIGIT) / obs-day
1873
1874 obs-day         =       [CFWS] 1*2DIGIT [CFWS]
1875 */
1876
1877 const uschar * s, * n;
1878 static const uschar *month_name[]={ US"jan", US"feb", US"mar", US"apr", US"may", US"jun", US"jul", US"aug", US"sep", US"oct", US"nov", US"dec" };
1879 int i;
1880 uschar month[4];
1881
1882 str = skip_comment(str);
1883 if ((str = parse_number(str,d,1)) == NULL) return NULL;
1884
1885 if (*str>='0' && *str<='9') *d = 10*(*d)+(*str++-'0');
1886 s = skip_comment(str);
1887 if (s == str) return NULL;
1888 str = s;
1889
1890 for (i = 0; i<3; ++i) if ((month[i]=tolower(*(str+i))) == '\0') return NULL;
1891 month[3] = '\0';
1892 for (i = 0; i<12; ++i) if (Ustrcmp(month,month_name[i]) == 0) break;
1893 if (i == 12) return NULL;
1894 str+=3;
1895 *m = i;
1896 s = skip_comment(str);
1897 if (s == str) return NULL;
1898 str=s;
1899
1900 if ((n = parse_number(str,y,4)))
1901   {
1902   str = n;
1903   if (*y<1900) return NULL;
1904   *y = *y-1900;
1905   }
1906 else if ((n = parse_number(str,y,2)))
1907   {
1908   str = skip_comment(n);
1909   while (*(str-1) == ' ' || *(str-1) == '\t') --str; /* match last FWS later */
1910   if (*y<50) *y+=100;
1911   }
1912 else return NULL;
1913 return str;
1914 }
1915
1916
1917 /*************************************************
1918 *            Parse a RFC 2822 Time               *
1919 *************************************************/
1920
1921 /* Parse the time part of a RFC 2822 date-time, extracting the
1922    hour, minute, second and timezone.
1923
1924 Arguments:
1925   str          pointer to the start of the time
1926   h            pointer to the resulting hour
1927   m            pointer to the resulting minute
1928   s            pointer to the resulting second
1929   z            pointer to the resulting timezone (offset in seconds)
1930
1931 Returns:       points after the processed time or NULL on error
1932 */
1933
1934 static const uschar *
1935 parse_time(const uschar *str, int *h, int *m, int *s, int *z)
1936 {
1937 /*
1938 time            =       time-of-day FWS zone
1939
1940 time-of-day     =       hour ":" minute [ ":" second ]
1941
1942 hour            =       2DIGIT / obs-hour
1943
1944 obs-hour        =       [CFWS] 2DIGIT [CFWS]
1945
1946 minute          =       2DIGIT / obs-minute
1947
1948 obs-minute      =       [CFWS] 2DIGIT [CFWS]
1949
1950 second          =       2DIGIT / obs-second
1951
1952 obs-second      =       [CFWS] 2DIGIT [CFWS]
1953
1954 zone            =       (( "+" / "-" ) 4DIGIT) / obs-zone
1955
1956 obs-zone        =       "UT" / "GMT" /          ; Universal Time
1957                                                 ; North American UT
1958                                                 ; offsets
1959                         "EST" / "EDT" /         ; Eastern:  - 5/ - 4
1960                         "CST" / "CDT" /         ; Central:  - 6/ - 5
1961                         "MST" / "MDT" /         ; Mountain: - 7/ - 6
1962                         "PST" / "PDT" /         ; Pacific:  - 8/ - 7
1963
1964                         %d65-73 /               ; Military zones - "A"
1965                         %d75-90 /               ; through "I" and "K"
1966                         %d97-105 /              ; through "Z", both
1967                         %d107-122               ; upper and lower case
1968 */
1969
1970 const uschar * c;
1971
1972 str = skip_comment(str);
1973 if ((str = parse_number(str,h,2)) == NULL) return NULL;
1974 str = skip_comment(str);
1975 if (*str!=':') return NULL;
1976 ++str;
1977 str = skip_comment(str);
1978 if ((str = parse_number(str,m,2)) == NULL) return NULL;
1979 c = skip_comment(str);
1980 if (*str == ':')
1981   {
1982   ++str;
1983   str = skip_comment(str);
1984   if ((str = parse_number(str,s,2)) == NULL) return NULL;
1985   c = skip_comment(str);
1986   }
1987 if (c == str) return NULL;
1988 else str=c;
1989 if (*str == '+' || *str == '-')
1990   {
1991   int neg;
1992
1993   neg = (*str == '-');
1994   ++str;
1995   if ((str = parse_number(str,z,4)) == NULL) return NULL;
1996   *z = (*z/100)*3600+(*z%100)*60;
1997   if (neg) *z = -*z;
1998   }
1999 else
2000   {
2001   char zone[5];
2002   struct { const char *name; int off; } zone_name[10] =
2003   { {"gmt",0}, {"ut",0}, {"est",-5}, {"edt",-4}, {"cst",-6}, {"cdt",-5}, {"mst",-7}, {"mdt",-6}, {"pst",-8}, {"pdt",-7}};
2004   int i,j;
2005
2006   for (i = 0; i<4; ++i)
2007     {
2008     zone[i] = tolower(*(str+i));
2009     if (zone[i]<'a' || zone[i]>'z') break;
2010     }
2011   zone[i] = '\0';
2012   for (j = 0; j<10 && strcmp(zone,zone_name[j].name); ++j);
2013   /* Besides zones named in the grammar, RFC 2822 says other alphabetic */
2014   /* time zones should be treated as unknown offsets. */
2015   if (j<10)
2016     {
2017     *z = zone_name[j].off*3600;
2018     str+=i;
2019     }
2020   else if (zone[0]<'a' || zone[1]>'z') return 0;
2021   else
2022     {
2023     while ((*str>='a' && *str<='z') || (*str>='A' && *str<='Z')) ++str;
2024     *z = 0;
2025     }
2026   }
2027 return str;
2028 }
2029
2030
2031 /*************************************************
2032 *          Parse a RFC 2822 date-time            *
2033 *************************************************/
2034
2035 /* Parse a RFC 2822 date-time and return it in seconds since the epoch.
2036
2037 Arguments:
2038   str          pointer to the start of the date-time
2039   t            pointer to the parsed time
2040
2041 Returns:       points after the processed date-time or NULL on error
2042 */
2043
2044 const uschar *
2045 parse_date_time(const uschar *str, time_t *t)
2046 {
2047 /*
2048 date-time       =       [ day-of-week "," ] date FWS time [CFWS]
2049 */
2050
2051 struct tm tm;
2052 int zone;
2053 extern char **environ;
2054 char **old_environ;
2055 static char gmt0[]="TZ=GMT0";
2056 static char *gmt_env[]={ gmt0, (char*)0 };
2057 const uschar * try;
2058
2059 if ((try = parse_day_of_week(str)))
2060   {
2061   str = try;
2062   if (*str!=',') return 0;
2063   ++str;
2064   }
2065 if ((str = parse_date(str,&tm.tm_mday,&tm.tm_mon,&tm.tm_year)) == NULL) return NULL;
2066 if (*str!=' ' && *str!='\t') return NULL;
2067 while (*str == ' ' || *str == '\t') ++str;
2068 if ((str = parse_time(str,&tm.tm_hour,&tm.tm_min,&tm.tm_sec,&zone)) == NULL) return NULL;
2069 tm.tm_isdst = 0;
2070 old_environ = environ;
2071 environ = gmt_env;
2072 *t = mktime(&tm);
2073 environ = old_environ;
2074 if (*t == -1) return NULL;
2075 *t-=zone;
2076 return skip_comment(str);
2077 }
2078
2079
2080
2081
2082 /*************************************************
2083 **************************************************
2084 *             Stand-alone test program           *
2085 **************************************************
2086 *************************************************/
2087
2088 #if defined STAND_ALONE
2089 int main(void)
2090 {
2091 int start, end, domain;
2092 uschar buffer[1024];
2093
2094 big_buffer = store_malloc(big_buffer_size);
2095
2096 /* strip_trailing_dot = TRUE; */
2097 allow_domain_literals = TRUE;
2098
2099 printf("Testing parse_fix_phrase\n");
2100
2101 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2102   {
2103   buffer[Ustrlen(buffer)-1] = 0;
2104   if (buffer[0] == 0) break;
2105   printf("%s\n", CS parse_fix_phrase(buffer, Ustrlen(buffer)));
2106   }
2107
2108 printf("Testing parse_extract_address without group syntax and without UTF-8\n");
2109
2110 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2111   {
2112   uschar *out;
2113   uschar *errmess;
2114   buffer[Ustrlen(buffer) - 1] = 0;
2115   if (buffer[0] == 0) break;
2116   out = parse_extract_address(buffer, &errmess, &start, &end, &domain, FALSE);
2117   if (!out)
2118     printf("*** bad address: %s\n", errmess);
2119   else
2120     {
2121     uschar extract[1024];
2122     Ustrncpy(extract, buffer+start, end-start);
2123     extract[end-start] = 0;
2124     printf("%s %d %d %d \"%s\"\n", out, start, end, domain, extract);
2125     }
2126   }
2127
2128 printf("Testing parse_extract_address without group syntax but with UTF-8\n");
2129
2130 allow_utf8_domains = TRUE;
2131 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2132   {
2133   uschar *out;
2134   uschar *errmess;
2135   buffer[Ustrlen(buffer) - 1] = 0;
2136   if (buffer[0] == 0) break;
2137   out = parse_extract_address(buffer, &errmess, &start, &end, &domain, FALSE);
2138   if (!out)
2139     printf("*** bad address: %s\n", errmess);
2140   else
2141     {
2142     uschar extract[1024];
2143     Ustrncpy(extract, buffer+start, end-start);
2144     extract[end-start] = 0;
2145     printf("%s %d %d %d \"%s\"\n", out, start, end, domain, extract);
2146     }
2147   }
2148 allow_utf8_domains = FALSE;
2149
2150 printf("Testing parse_extract_address with group syntax\n");
2151
2152 f.parse_allow_group = TRUE;
2153 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2154   {
2155   uschar *out;
2156   uschar *errmess;
2157   uschar *s;
2158   buffer[Ustrlen(buffer) - 1] = 0;
2159   if (buffer[0] == 0) break;
2160   s = buffer;
2161   while (*s)
2162     {
2163     uschar *ss = parse_find_address_end(s, FALSE);
2164     int terminator = *ss;
2165     *ss = 0;
2166     out = parse_extract_address(buffer, &errmess, &start, &end, &domain, FALSE);
2167     *ss = terminator;
2168
2169     if (!out)
2170       printf("*** bad address: %s\n", errmess);
2171     else
2172       {
2173       uschar extract[1024];
2174       Ustrncpy(extract, buffer+start, end-start);
2175       extract[end-start] = 0;
2176       printf("%s %d %d %d \"%s\"\n", out, start, end, domain, extract);
2177       }
2178
2179     s = ss + (terminator? 1:0);
2180     Uskip_whitespace(&s);
2181     }
2182   }
2183
2184 printf("Testing parse_find_at\n");
2185
2186 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2187   {
2188   uschar *s;
2189   buffer[Ustrlen(buffer)-1] = 0;
2190   if (buffer[0] == 0) break;
2191   s = parse_find_at(buffer);
2192   if (s == NULL) printf("no @ found\n");
2193     else printf("offset = %d\n", s - buffer);
2194   }
2195
2196 printf("Testing parse_extract_addresses\n");
2197
2198 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2199   {
2200   uschar *errmess;
2201   int extracted;
2202   address_item *anchor = NULL;
2203   buffer[Ustrlen(buffer) - 1] = 0;
2204   if (buffer[0] == 0) break;
2205   if ((extracted = parse_forward_list(buffer, -1, &anchor,
2206       &errmess, US"incoming.domain", NULL, NULL)) == FF_DELIVERED)
2207     {
2208     while (anchor != NULL)
2209       {
2210       address_item *addr = anchor;
2211       anchor = anchor->next;
2212       printf("%d %s\n", testflag(addr, af_pfr), addr->address);
2213       }
2214     }
2215   else printf("Failed: %d %s\n", extracted, errmess);
2216   }
2217
2218 printf("Testing parse_message_id\n");
2219
2220 while (Ufgets(buffer, sizeof(buffer), stdin) != NULL)
2221   {
2222   uschar *s, *t, *errmess;
2223   buffer[Ustrlen(buffer) - 1] = 0;
2224   if (buffer[0] == 0) break;
2225   s = buffer;
2226   while (*s != 0)
2227     {
2228     s = parse_message_id(s, &t, &errmess);
2229     if (errmess != NULL)
2230       {
2231       printf("Failed: %s\n", errmess);
2232       break;
2233       }
2234     printf("%s\n", t);
2235     }
2236   }
2237
2238 return 0;
2239 }
2240
2241 #endif
2242
2243 /* End of parse.c */