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