1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2015 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions for parsing addresses */
14 static uschar
*last_comment_position
;
18 /* In stand-alone mode, provide a replacement for deliver_make_addr()
19 and rewrite_address[_qualify]() so as to avoid having to drag in too much
20 redundant apparatus. */
24 address_item
*deliver_make_addr(uschar
*address
, BOOL copy
)
26 address_item
*addr
= store_get(sizeof(address_item
));
29 addr
->address
= address
;
33 uschar
*rewrite_address(uschar
*recipient
, BOOL dummy1
, BOOL dummy2
, rewrite_rule
39 uschar
*rewrite_address_qualify(uschar
*recipient
, BOOL dummy1
)
49 /*************************************************
50 * Find the end of an address *
51 *************************************************/
53 /* Scan over a string looking for the termination of an address at a comma,
54 or end of the string. It's the source-routed addresses which cause much pain
55 here. Although Exim ignores source routes, it must recognize such addresses, so
56 we cannot get rid of this logic.
59 s pointer to the start of an address
60 nl_ends if TRUE, '\n' terminates an address
62 Returns: pointer past the end of the address
63 (i.e. points to null or comma)
67 parse_find_address_end(uschar
*s
, BOOL nl_ends
)
69 BOOL source_routing
= *s
== '@';
70 int no_term
= source_routing
? 1 : 0;
72 while (*s
!= 0 && (*s
!= ',' || no_term
> 0) && (*s
!= '\n' || !nl_ends
))
74 /* Skip single quoted characters. Strictly these should not occur outside
75 quoted strings in RFC 822 addresses, but they can in RFC 821 addresses. Pity
76 about the lack of consistency, isn't it? */
78 if (*s
== '\\' && s
[1] != 0) s
+= 2;
80 /* Skip quoted items that are not inside brackets. Note that
81 quoted pairs are allowed inside quoted strings. */
85 while (*(++s
) != 0 && (*s
!= '\n' || !nl_ends
))
87 if (*s
== '\\' && s
[1] != 0) s
++;
88 else if (*s
== '\"') { s
++; break; }
92 /* Skip comments, which may include nested brackets, but quotes
93 are not recognized inside comments, though quoted pairs are. */
98 while (*(++s
) != 0 && (*s
!= '\n' || !nl_ends
))
100 if (*s
== '\\' && s
[1] != 0) s
++;
101 else if (*s
== '(') level
++;
102 else if (*s
== ')' && --level
<= 0) { s
++; break; }
106 /* Non-special character; just advance. Passing the colon in a source
107 routed address means that any subsequent comma or colon may terminate unless
108 inside angle brackets. */
114 source_routing
= s
[1] == '@';
115 no_term
= source_routing
? 2 : 1;
117 else if (*s
== '>') no_term
--;
118 else if (source_routing
&& *s
== ':') no_term
--;
128 /*************************************************
129 * Find last @ in an address *
130 *************************************************/
132 /* This function is used when we have something that may not qualified. If we
133 know it's qualified, searching for the rightmost '@' is sufficient. Here we
134 have to be a bit more clever than just a plain search, in order to handle
135 unqualified local parts like "thing@thong" correctly. Since quotes may not
136 legally be part of a domain name, we can give up on hitting the first quote
137 when searching from the right. Now that the parsing also permits the RFC 821
138 form of address, where quoted-pairs are allowed in unquoted local parts, we
139 must take care to handle that too.
141 Argument: pointer to an address, possibly unqualified
142 Returns: pointer to the last @ in an address, or NULL if none
146 parse_find_at(uschar
*s
)
148 uschar
*t
= s
+ Ustrlen(s
);
153 int backslash_count
= 0;
155 while (tt
> s
&& *tt
-- == '\\') backslash_count
++;
156 if ((backslash_count
& 1) == 0) return t
;
158 else if (*t
== '\"') return NULL
;
166 /***************************************************************************
167 * In all the functions below that read a particular object type from *
168 * the input, return the new value of the pointer s (the first argument), *
169 * and put the object into the store pointed to by t (the second argument), *
170 * adding a terminating zero. If no object is found, t will point to zero *
172 ***************************************************************************/
175 /*************************************************
176 * Skip white space and comment *
177 *************************************************/
181 (2) If uschar not '(', return.
182 (3) Skip till matching ')', not counting any characters
184 (4) Move past ')' and goto (1).
186 The start of the last potential comment position is remembered to
187 make it possible to ignore comments at the end of compound items.
189 Argument: current character pointer
190 Regurns: new character pointer
194 skip_comment(uschar
*s
)
196 last_comment_position
= s
;
200 while (isspace(*s
)) s
++;
201 if (*s
!= '(') break;
203 while((c
= *(++s
)) != 0)
205 if (c
== '(') level
++;
206 else if (c
== ')') { if (--level
<= 0) { s
++; break; } }
207 else if (c
== '\\' && s
[1] != 0) s
++;
215 /*************************************************
217 *************************************************/
219 /* A domain is a sequence of subdomains, separated by dots. See comments below
220 for detailed syntax of the subdomains.
222 If allow_domain_literals is TRUE, a "domain" may also be an IP address enclosed
223 in []. Make sure the output is set to the null string if there is a syntax
224 error as well as if there is no domain at all.
227 s current character pointer
228 t where to put the domain
229 errorptr put error message here on failure (*t will be 0 on exit)
231 Returns: new character pointer
235 read_domain(uschar
*s
, uschar
*t
, uschar
**errorptr
)
240 /* Handle domain literals if permitted. An RFC 822 domain literal may contain
241 any character except [ ] \, including linear white space, and may contain
242 quoted characters. However, RFC 821 restricts literals to being dot-separated
243 3-digit numbers, and we make the obvious extension for IPv6. Go for a sequence
244 of digits, dots, hex digits, and colons here; later this will be checked for
245 being a syntactically valid IP address if it ever gets to a router.
247 Allow both the formal IPv6 form, with IPV6: at the start, and the informal form
248 without it, and accept IPV4: as well, 'cause someone will use it sooner or
255 if (strncmpic(s
, US
"IPv6:", 5) == 0 || strncmpic(s
, US
"IPv4:", 5) == 0)
261 while (*s
== '.' || *s
== ':' || isxdigit(*s
)) *t
++ = *s
++;
263 if (*s
== ']') *t
++ = *s
++; else
265 *errorptr
= US
"malformed domain literal";
269 if (!allow_domain_literals
)
271 *errorptr
= US
"domain literals not allowed";
275 return skip_comment(s
);
278 /* Handle a proper domain, which is a sequence of dot-separated atoms. Remove
279 trailing dots if strip_trailing_dot is set. A subdomain is an atom.
281 An atom is a sequence of any characters except specials, space, and controls.
282 The specials are ( ) < > @ , ; : \ " . [ and ]. This is the rule for RFC 822
283 and its successor (RFC 2822). However, RFC 821 and its successor (RFC 2821) is
284 tighter, allowing only letters, digits, and hyphens, not starting with a
287 There used to be a global flag that got set when checking addresses that came
288 in over SMTP and which should therefore should be checked according to the
289 stricter rule. However, it seems silly to make the distinction, because I don't
290 suppose anybody ever uses local domains that are 822-compliant and not
291 821-compliant. Furthermore, Exim now has additional data on the spool file line
292 after an address (after "one_time" processing), and it makes use of a #
293 character to delimit it. When I wrote that code, I forgot about this 822-domain
294 stuff, and assumed # could never appear in a domain.
296 So the old code is now cut out for Release 4.11 onwards, on 09-Aug-02. In a few
297 years, when we are sure this isn't actually causing trouble, throw it away.
299 March 2003: the story continues: There is a camp that is arguing for the use of
300 UTF-8 in domain names as the way to internationalization, and other MTAs
301 support this. Therefore, we now have a flag that permits the use of characters
302 with values greater than 127, encoded in UTF-8, in subdomains, so that Exim can
303 be used experimentally in this way. */
309 /*********************
312 if (*s != '-') while (isalnum(*s) || *s == '-') *t++ = *s++;
315 while (!mac_iscntrl_or_special(*s)) *t++ = *s++;
316 *********************/
320 /* Only letters, digits, and hyphens */
322 if (!allow_utf8_domains
)
324 while (isalnum(*s
) || *s
== '-') *t
++ = *s
++;
327 /* Permit legal UTF-8 characters to be included */
332 if (isalnum(*s
) || *s
== '-') /* legal ascii characters */
337 if ((*s
& 0xc0) != 0xc0) break; /* not start of UTF-8 character */
339 for (i
= 1; i
< 6; i
++) /* i is the number of additional bytes */
341 if ((d
& 0x80) == 0) break;
344 if (i
== 6) goto BAD_UTF8
; /* invalid UTF-8 */
345 *t
++ = *s
++; /* leading UTF-8 byte */
346 while (i
-- > 0) /* copy and check remainder */
348 if ((*s
& 0xc0) != 0x80)
351 *errorptr
= US
"invalid UTF-8 byte sequence";
357 } /* End of loop for UTF-8 character */
358 } /* End of subdomain */
363 if (t
== tsave
) /* empty component */
365 if (strip_trailing_dot
&& t
> tt
&& *s
!= '.') t
[-1] = 0; else
367 *errorptr
= US
"domain missing or malformed";
373 if (*s
!= '.') break;
383 /*************************************************
384 * Read a local-part *
385 *************************************************/
387 /* A local-part is a sequence of words, separated by periods. A null word
388 between dots is not strictly allowed but apparently many mailers permit it,
389 so, sigh, better be compatible. Even accept a trailing dot...
391 A <word> is either a quoted string, or an <atom>, which is a sequence
392 of any characters except specials, space, and controls. The specials are
393 ( ) < > @ , ; : \ " . [ and ]. In RFC 822, a single quoted character, (a
394 quoted-pair) is not allowed in a word. However, in RFC 821, it is permitted in
395 the local part of an address. Rather than have separate parsing functions for
396 the different cases, take the liberal attitude always. At least one MUA is
397 happy to recognize this case; I don't know how many other programs do.
400 s current character pointer
401 t where to put the local part
402 error where to point error text
403 allow_null TRUE if an empty local part is not an error
405 Returns: new character pointer
409 read_local_part(uschar
*s
, uschar
*t
, uschar
**error
, BOOL allow_null
)
419 /* Handle a quoted string */
424 while ((c
= *(++s
)) != 0 && c
!= '\"')
427 if (c
== '\\' && s
[1] != 0) *t
++ = *(++s
);
436 *error
= US
"unmatched doublequote in local part";
441 /* Handle an atom, but allow quoted pairs within it. */
443 else while (!mac_iscntrl_or_special(*s
) || *s
== '\\')
446 if (c
== '\\' && *s
!= 0) *t
++ = *s
++;
449 /* Terminate the word and skip subsequent comment */
454 /* If we have read a null component at this point, give an error unless it is
455 terminated by a dot - an extension to RFC 822 - or if it is the first
456 component of the local part and an empty local part is permitted, in which
457 case just return normally. */
459 if (t
== tsave
&& *s
!= '.')
461 if (t
== tt
&& !allow_null
)
462 *error
= US
"missing or malformed local part";
466 /* Anything other than a dot terminates the local part. Treat multiple dots
467 as a single dot, as this seems to be a common extension. */
469 if (*s
!= '.') break;
470 do { *t
++ = *s
++; } while (*s
== '.');
477 /*************************************************
478 * Read route part of route-addr *
479 *************************************************/
481 /* The pointer is at the initial "@" on entry. Return it following the
482 terminating colon. Exim no longer supports the use of source routes, but it is
483 required to accept the syntax.
486 s current character pointer
487 t where to put the route
488 errorptr where to put an error message
490 Returns: new character pointer
494 read_route(uschar
*s
, uschar
*t
, uschar
**errorptr
)
502 s
= read_domain(s
+1, t
, errorptr
);
503 if (*t
== 0) return s
;
504 t
+= Ustrlen((const uschar
*)t
);
505 if (*s
!= ',') break;
511 if (*s
== ':') *t
++ = *s
++;
513 /* If there is no colon, and there were no commas, the most likely error
514 is in fact a missing local part in the address rather than a missing colon
517 else *errorptr
= commas
?
518 US
"colon expected after route list" :
521 /* Terminate the route and return */
524 return skip_comment(s
);
529 /*************************************************
531 *************************************************/
533 /* Addr-spec is local-part@domain. We make the domain optional -
534 the expected terminator for the whole thing is passed to check this.
535 This function is called only when we know we have a route-addr.
538 s current character pointer
539 t where to put the addr-spec
540 term expected terminator (0 or >)
541 errorptr where to put an error message
542 domainptr set to point to the start of the domain
544 Returns: new character pointer
548 read_addr_spec(uschar
*s
, uschar
*t
, int term
, uschar
**errorptr
,
551 s
= read_local_part(s
, t
, errorptr
, FALSE
);
552 if (*errorptr
== NULL
)
555 *errorptr
= string_sprintf("\"@\" or \".\" expected after \"%s\"", t
);
558 t
+= Ustrlen((const uschar
*)t
);
561 s
= read_domain(s
, t
, errorptr
);
568 /*************************************************
569 * Extract operative address *
570 *************************************************/
572 /* This function extracts an operative address from a full RFC822 mailbox and
573 returns it in a piece of dynamic store. We take the easy way and get a piece
574 of store the same size as the input, and then copy into it whatever is
575 necessary. If we cannot find a valid address (syntax error), return NULL, and
576 point the error pointer to the reason. The arguments "start" and "end" are used
577 to return the offsets of the first and one past the last characters in the
578 original mailbox of the address that has been extracted, to aid in re-writing.
579 The argument "domain" is set to point to the first character after "@" in the
580 final part of the returned address, or zero if there is no @.
582 Exim no longer supports the use of source routed addresses (those of the form
583 @domain,...:route_addr). It recognizes the syntax, but collapses such addresses
584 down to their final components. Formerly, collapse_source_routes had to be set
585 to achieve this effect. RFC 1123 allows collapsing with MAY, while the revision
586 of RFC 821 had increased this to SHOULD, so I've gone for it, because it makes
587 a lot of code elsewhere in Exim much simpler.
589 There are some special fudges here for handling RFC 822 group address notation
590 which may appear in certain headers. If the flag parse_allow_group is set
591 TRUE and parse_found_group is FALSE when this function is called, an address
592 which is the start of a group (i.e. preceded by a phrase and a colon) is
593 recognized; the phrase is ignored and the flag parse_found_group is set. If
594 this flag is TRUE at the end of an address, and if an extraneous semicolon is
595 found, it is ignored and the flag is cleared.
597 This logic is used only when scanning through addresses in headers, either to
598 fulfil the -t option, or for rewriting, or for checking header syntax. Because
599 the group "state" has to be remembered between multiple calls of this function,
600 the variables parse_{allow,found}_group are global. It is important to ensure
601 that they are reset to FALSE at the end of scanning a header's list of
605 mailbox points to the RFC822 mailbox
606 errorptr where to point an error message
607 start set to start offset in mailbox
608 end set to end offset in mailbox
609 domain set to domain offset in result, or 0 if no domain present
610 allow_null allow <> if TRUE
612 Returns: points to the extracted address, or NULL on error
615 #define FAILED(s) { *errorptr = s; goto PARSE_FAILED; }
618 parse_extract_address(uschar
*mailbox
, uschar
**errorptr
, int *start
, int *end
,
619 int *domain
, BOOL allow_null
)
621 uschar
*yield
= store_get(Ustrlen(mailbox
) + 1);
622 uschar
*startptr
, *endptr
;
623 uschar
*s
= (uschar
*)mailbox
;
624 uschar
*t
= (uschar
*)yield
;
628 /* At the start of the string we expect either an addr-spec or a phrase
629 preceding a <route-addr>. If groups are allowed, we might also find a phrase
630 preceding a colon and an address. If we find an initial word followed by
631 a dot, strict interpretation of the RFC would cause it to be taken
632 as the start of an addr-spec. However, many mailers break the rules
633 and use addresses of the form "a.n.other <ano@somewhere>" and so we
636 RESTART
: /* Come back here after passing a group name */
639 startptr
= s
; /* In case addr-spec */
640 s
= read_local_part(s
, t
, errorptr
, TRUE
); /* Dot separated words */
641 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
643 /* If the terminator is neither < nor @ then the format of the address
644 must either be a bare local-part (we are now at the end), or a phrase
645 followed by a route-addr (more words must follow). */
647 if (*s
!= '@' && *s
!= '<')
649 if (*s
== 0 || *s
== ';')
651 if (*t
== 0) FAILED(US
"empty address");
652 endptr
= last_comment_position
;
653 goto PARSE_SUCCEEDED
; /* Bare local part */
656 /* Expect phrase route-addr, or phrase : if groups permitted, but allow
657 dots in the phrase; complete the loop only when '<' or ':' is encountered -
658 end of string will produce a null local_part and therefore fail. We don't
659 need to keep updating t, as the phrase isn't to be kept. */
661 while (*s
!= '<' && (!parse_allow_group
|| *s
!= ':'))
663 s
= read_local_part(s
, t
, errorptr
, FALSE
);
664 if (*errorptr
!= NULL
)
666 *errorptr
= string_sprintf("%s (expected word or \"<\")", *errorptr
);
673 parse_found_group
= TRUE
;
674 parse_allow_group
= FALSE
;
679 /* Assert *s == '<' */
682 /* At this point the next character is either '@' or '<'. If it is '@', only a
683 single local-part has previously been read. An angle bracket signifies the
684 start of an <addr-spec>. Throw away anything we have saved so far before
685 processing it. Note that this is "if" rather than "else if" because it's also
686 used after reading a preceding phrase.
688 There are a lot of broken sendmails out there that put additional pairs of <>
689 round <route-addr>s. If strip_excess_angle_brackets is set, allow any number of
690 them, as long as they match. */
694 uschar
*domainptr
= yield
;
695 BOOL source_routed
= FALSE
;
696 int bracket_count
= 1;
699 if (strip_excess_angle_brackets
)
700 while (*s
== '<') { bracket_count
++; s
++; }
706 /* Read an optional series of routes, each of which is a domain. They
707 are separated by commas and terminated by a colon. However, we totally ignore
708 such routes (RFC 1123 says we MAY, and the revision of RFC 821 says we
713 s
= read_route(s
, t
, errorptr
);
714 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
715 *t
= 0; /* Ensure route is ignored - probably overkill */
716 source_routed
= TRUE
;
719 /* Now an addr-spec, terminated by '>'. If there is no preceding route,
720 we must allow an empty addr-spec if allow_null is TRUE, to permit the
721 address "<>" in some circumstances. A source-routed address MUST have
722 a domain in the final part. */
724 if (allow_null
&& !source_routed
&& *s
== '>')
731 s
= read_addr_spec(s
, t
, '>', errorptr
, &domainptr
);
732 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
733 *domain
= domainptr
- yield
;
734 if (source_routed
&& *domain
== 0)
735 FAILED(US
"domain missing in source-routed address");
739 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
740 while (bracket_count
-- > 0) if (*s
++ != '>')
742 *errorptr
= (s
[-1] == 0)? US
"'>' missing at end of address" :
743 string_sprintf("malformed address: %.32s may not follow %.*s",
744 s
-1, s
- (uschar
*)mailbox
- 1, mailbox
);
751 /* Hitting '@' after the first local-part means we have definitely got an
752 addr-spec, on a strict reading of the RFC, and the rest of the string
753 should be the domain. However, for flexibility we allow for a route-address
754 not enclosed in <> as well, which is indicated by an empty first local
755 part preceding '@'. The source routing is, however, ignored. */
759 uschar
*domainptr
= yield
;
760 s
= read_route(s
, t
, errorptr
);
761 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
762 *t
= 0; /* Ensure route is ignored - probably overkill */
763 s
= read_addr_spec(s
, t
, 0, errorptr
, &domainptr
);
764 if (*errorptr
!= NULL
) goto PARSE_FAILED
;
765 *domain
= domainptr
- yield
;
766 endptr
= last_comment_position
;
767 if (*domain
== 0) FAILED(US
"domain missing in source-routed address");
770 /* This is the strict case of local-part@domain. */
774 t
+= Ustrlen((const uschar
*)t
);
777 s
= read_domain(s
, t
, errorptr
);
778 if (*t
== 0) goto PARSE_FAILED
;
779 endptr
= last_comment_position
;
782 /* Use goto to get here from the bare local part case. Arrive by falling
783 through for other cases. Endptr may have been moved over whitespace, so
784 move it back past white space if necessary. */
789 if (parse_found_group
&& *s
== ';')
791 parse_found_group
= FALSE
;
792 parse_allow_group
= TRUE
;
796 *errorptr
= string_sprintf("malformed address: %.32s may not follow %.*s",
797 s
, s
- (uschar
*)mailbox
, mailbox
);
801 *start
= startptr
- (uschar
*)mailbox
; /* Return offsets */
802 while (isspace(endptr
[-1])) endptr
--;
803 *end
= endptr
- (uschar
*)mailbox
;
805 /* Although this code has no limitation on the length of address extracted,
806 other parts of Exim may have limits, and in any case, RFC 2821 limits local
807 parts to 64 and domains to 255, so we do a check here, giving an error if the
808 address is ridiculously long. */
810 if (*end
- *start
> ADDRESS_MAXLENGTH
)
812 *errorptr
= string_sprintf("address is ridiculously long: %.64s...", yield
);
818 /* Use goto (via the macro FAILED) to get to here from a variety of places.
819 We might have an empty address in a group - the caller can choose to ignore
820 this. We must, however, keep the flags correct. */
823 if (parse_found_group
&& *s
== ';')
825 parse_found_group
= FALSE
;
826 parse_allow_group
= TRUE
;
835 /*************************************************
836 * Quote according to RFC 2047 *
837 *************************************************/
839 /* This function is used for quoting text in headers according to RFC 2047.
840 If the only characters that strictly need quoting are spaces, we return the
841 original string, unmodified. If a quoted string is too long for the buffer, it
842 is truncated. (This shouldn't happen: this is normally handling short strings.)
844 Hmmph. As always, things get perverted for other uses. This function was
845 originally for the "phrase" part of addresses. Now it is being used for much
846 longer texts in ACLs and via the ${rfc2047: expansion item. This means we have
847 to check for overlong "encoded-word"s and split them. November 2004.
850 string the string to quote - already checked to contain non-printing
852 len the length of the string
853 charset the name of the character set; NULL => iso-8859-1
854 buffer the buffer to put the answer in
855 buffer_size the size of the buffer
856 fold if TRUE, a newline is inserted before the separating space when
857 more than one encoded-word is generated
859 Returns: pointer to the original string, if no quoting needed, or
860 pointer to buffer containing the quoted string, or
861 a pointer to "String too long" if the buffer can't even hold
866 parse_quote_2047(const uschar
*string
, int len
, uschar
*charset
, uschar
*buffer
,
867 int buffer_size
, BOOL fold
)
869 const uschar
*s
= string
;
873 BOOL first_byte
= FALSE
;
875 if (charset
== NULL
) charset
= US
"iso-8859-1";
877 /* We don't expect this to fail! */
879 if (!string_format(buffer
, buffer_size
, "=?%s?Q?", charset
))
880 return US
"String too long";
882 hlen
= Ustrlen(buffer
);
886 for (; len
> 0; len
--)
889 if (t
> buffer
+ buffer_size
- hlen
- 8) break;
891 if ((t
- p
> 67) && !first_byte
)
895 if (fold
) *t
++ = '\n';
898 Ustrncpy(p
, buffer
, hlen
);
902 if (ch
< 33 || ch
> 126 ||
903 Ustrchr("?=()<>@,;:\\\".[]_", ch
) != NULL
)
912 sprintf(CS t
, "=%02X", ch
);
915 first_byte
= !first_byte
;
918 else { *t
++ = ch
; first_byte
= FALSE
; }
925 return coded
? buffer
: string
;
931 /*************************************************
932 * Fix up an RFC 822 "phrase" *
933 *************************************************/
935 /* This function is called to repair any syntactic defects in the "phrase" part
936 of an RFC822 address. In particular, it is applied to the user's name as read
937 from the passwd file when accepting a local message, and to the data from the
940 If the string contains existing quoted strings or comments containing
941 freestanding quotes, then we just quote those bits that need quoting -
942 otherwise it would get awfully messy and probably not look good. If not, we
943 quote the whole thing if necessary. Thus
945 John Q. Smith => "John Q. Smith"
946 John "Jack" Smith => John "Jack" Smith
947 John "Jack" Q. Smith => John "Jack" "Q." Smith
948 John (Jack) Q. Smith => "John (Jack) Q. Smith"
949 John ("Jack") Q. Smith => John ("Jack") "Q." Smith
951 John (\"Jack\") Q. Smith => "John (\"Jack\") Q. Smith"
953 Sheesh! This is tedious code. It is a great pity that the syntax of RFC822 is
956 August 2000: Additional code added:
958 Previously, non-printing characters were turned into question marks, which do
959 not need to be quoted.
961 Now, a different tactic is used if there are any non-printing ASCII
962 characters. The encoding method from RFC 2047 is used, assuming iso-8859-1 as
965 We *could* use this for all cases, getting rid of the messy original code,
966 but leave it for now. It would complicate simple cases like "John Q. Smith".
968 The result is passed back in the buffer; it is usually going to be added to
969 some other string. In order to be sure there is going to be no overflow,
970 restrict the length of the input to 1/4 of the buffer size - this allows for
971 every single character to be quoted or encoded without overflowing, and that
972 wouldn't happen because of amalgamation. If the phrase is too long, return a
976 phrase an RFC822 phrase
977 len the length of the phrase
978 buffer a buffer to put the result in
979 buffer_size the size of the buffer
981 Returns: the fixed RFC822 phrase
985 parse_fix_phrase(const uschar
*phrase
, int len
, uschar
*buffer
, int buffer_size
)
989 const uschar
*s
, *end
;
992 while (len
> 0 && isspace(*phrase
)) { phrase
++; len
--; }
993 if (len
> buffer_size
/4) return US
"Name too long";
995 /* See if there are any non-printing characters, and if so, use the RFC 2047
996 encoding for the whole thing. */
998 for (i
= 0, s
= phrase
; i
< len
; i
++, s
++)
999 if ((*s
< 32 && *s
!= '\t') || *s
> 126) break;
1001 if (i
< len
) return parse_quote_2047(phrase
, len
, headers_charset
, buffer
,
1002 buffer_size
, FALSE
);
1004 /* No non-printers; use the RFC 822 quoting rules */
1008 yield
= t
= buffer
+ 1;
1014 /* Copy over quoted strings, remembering we encountered one */
1019 while (s
< end
&& (ch
= *s
++) != '\"')
1022 if (ch
== '\\' && s
< end
) *t
++ = *s
++;
1025 if (s
>= end
) break;
1029 /* Copy over comments, noting if they contain freestanding quote
1040 if (ch
== '(') level
++;
1041 else if (ch
== ')') { if (--level
<= 0) break; }
1042 else if (ch
== '\\' && s
< end
) *t
++ = *s
++ & 127;
1043 else if (ch
== '\"') quoted
= TRUE
;
1047 while (level
--) *t
++ = ')';
1052 /* Handle special characters that need to be quoted */
1054 else if (Ustrchr(")<>@,;:\\.[]", ch
) != NULL
)
1056 /* If hit previous quotes just make one quoted "word" */
1061 while (*(--tt
) != ' ' && *tt
!= '\"' && *tt
!= ')') tt
[1] = *tt
;
1067 if (ch
== ' ' || ch
== '\"') { s
--; break; } else *t
++ = ch
;
1072 /* Else quote the whole string so far, and the rest up to any following
1073 quotes. We must treat anything following a backslash as a literal. */
1077 BOOL escaped
= (ch
== '\\');
1081 /* Now look for the end or a quote */
1087 /* Handle escaped pairs */
1095 else if (ch
== '\\')
1101 /* If hit subsequent quotes, insert our quote before any trailing
1102 spaces and back up to re-handle the quote in the outer loop. */
1104 else if (ch
== '\"')
1107 while (t
[-1] == ' ') { t
--; count
++; }
1109 while (count
-- > 0) *t
++ = ' ';
1114 /* If hit a subsequent comment, check it for unescaped quotes,
1115 and if so, end our quote before it. */
1119 const uschar
*ss
= s
; /* uschar after '(' */
1124 if (ch
== '(') level
++;
1125 else if (ch
== ')') { if (--level
<= 0) break; }
1126 else if (ch
== '\\' && ss
+1 < end
) ss
++;
1127 else if (ch
== '\"') { quoted
= TRUE
; break; }
1130 /* Comment contains unescaped quotes; end our quote before
1131 the start of the comment. */
1136 while (t
[-1] == ' ') { t
--; count
++; }
1138 while (count
-- > 0) *t
++ = ' ';
1142 /* Comment does not contain unescaped quotes; include it in
1147 if (ss
>= end
) ss
--;
1149 Ustrncpy(t
, s
, ss
-s
);
1155 /* Not a comment or quote; include this character in our quotes. */
1161 /* Add a final quote if we hit the end of the string. */
1163 if (s
>= end
) *t
++ = '\"';
1166 /* Non-special character; just copy it over */
1176 /*************************************************
1177 * Extract addresses from a list *
1178 *************************************************/
1180 /* This function is called by the redirect router to scan a string containing a
1181 list of addresses separated by commas (with optional white space) or by
1182 newlines, and to generate a chain of address items from them. In other words,
1183 to unpick data from an alias or .forward file.
1185 The SunOS5 documentation for alias files is not very clear on the syntax; it
1186 does not say that either a comma or a newline can be used for separation.
1187 However, that is the way Smail does it, so we follow suit.
1189 If a # character is encountered in a white space position, then characters from
1190 there to the next newline are skipped.
1192 If an unqualified address begins with '\', just skip that character. This gives
1193 compatibility with Sendmail's use of \ to prevent looping. Exim has its own
1194 loop prevention scheme which handles other cases too - see the code in
1197 An "address" can be a specification of a file or a pipe; the latter may often
1198 need to be quoted because it may contain spaces, but we don't want to retain
1199 the quotes. Quotes may appear in normal addresses too, and should be retained.
1200 We can distinguish between these cases, because in addresses, quotes are used
1201 only for parts of the address, not the whole thing. Therefore, we remove quotes
1202 from items when they entirely enclose them, but not otherwise.
1204 An "address" can also be of the form :include:pathname to include a list of
1205 addresses contained in the specified file.
1207 Any unqualified addresses are qualified with and rewritten if necessary, via
1208 the rewrite_address() function.
1211 s the list of addresses (typically a complete
1212 .forward file or a list of entries in an alias file)
1213 options option bits for permitting or denying various special cases;
1214 not all bits are relevant here - some are for filter
1215 files; those we use here are:
1222 anchor where to hang the chain of newly-created addresses. This
1223 should be initialized to NULL.
1224 error where to return an error text
1225 incoming domain domain of the incoming address; used to qualify unqualified
1226 local parts preceded by \
1227 directory if NULL, no checks are done on :include: files
1228 otherwise, included file names must start with the given
1230 syntax_errors if not NULL, it carries on after syntax errors in addresses,
1231 building up a list of errors as error blocks chained on
1234 Returns: FF_DELIVERED addresses extracted
1235 FF_NOTDELIVERED no addresses extracted, but no errors
1236 FF_BLACKHOLE :blackhole:
1239 FF_INCLUDEFAIL some problem with :include:; *error set
1240 FF_ERROR other problems; *error is set
1244 parse_forward_list(uschar
*s
, int options
, address_item
**anchor
,
1245 uschar
**error
, const uschar
*incoming_domain
, uschar
*directory
,
1246 error_block
**syntax_errors
)
1250 DEBUG(D_route
) debug_printf("parse_forward_list: %s\n", s
);
1260 BOOL inquote
= FALSE
;
1264 while (isspace(*s
) || *s
== ',') s
++;
1265 if (*s
== '#') { while (*s
!= 0 && *s
!= '\n') s
++; } else break;
1268 /* When we reach the end of the list, we return FF_DELIVERED if any child
1269 addresses have been generated. If nothing has been generated, there are two
1270 possibilities: either the list is really empty, or there were syntax errors
1271 that are being skipped. (If syntax errors are not being skipped, an FF_ERROR
1272 return is generated on hitting a syntax error and we don't get here.) For a
1273 truly empty list we return FF_NOTDELIVERED so that the router can decline.
1274 However, if the list is empty only because syntax errors were skipped, we
1275 return FF_DELIVERED. */
1279 return (count
> 0 || (syntax_errors
!= NULL
&& *syntax_errors
!= NULL
))?
1280 FF_DELIVERED
: FF_NOTDELIVERED
;
1282 /* This previous code returns FF_ERROR if nothing is generated but a
1283 syntax error has been skipped. I now think it is the wrong approach, but
1284 have left this here just in case, and for the record. */
1287 if (count
> 0) return FF_DELIVERED
; /* Something was generated */
1289 if (syntax_errors
== NULL
|| /* Not skipping syntax errors, or */
1290 *syntax_errors
== NULL
) /* we didn't actually skip any */
1291 return FF_NOTDELIVERED
;
1293 *error
= string_sprintf("no addresses generated: syntax error in %s: %s",
1294 (*syntax_errors
)->text2
, (*syntax_errors
)->text1
);
1300 /* Find the end of the next address. Quoted strings in addresses may contain
1301 escaped characters; I haven't found a proper specification of .forward or
1302 alias files that mentions the quoting properties, but it seems right to do
1303 the escaping thing in all cases, so use the function that finds the end of an
1304 address. However, don't let a quoted string extend over the end of a line. */
1306 ss
= parse_find_address_end(s
, TRUE
);
1308 /* Remember where we finished, for starting the next one. */
1312 /* Remove any trailing spaces; we know there's at least one non-space. */
1314 while (isspace((ss
[-1]))) ss
--;
1316 /* We now have s->start and ss->end of the next address. Remove quotes
1317 if they completely enclose, remembering the address started with a quote
1318 for handling pipes and files. Another round of removal of leading and
1319 trailing spaces is then required. */
1321 if (*s
== '\"' && ss
[-1] == '\"')
1326 while (s
< ss
&& isspace(*s
)) s
++;
1327 while (ss
> s
&& isspace((ss
[-1]))) ss
--;
1330 /* Set up the length of the address. */
1338 debug_printf("extract item: %s\n", s
);
1342 /* Handle special addresses if permitted. If the address is :unknown:
1343 ignore it - this is for backward compatibility with old alias files. You
1344 don't need to use it nowadays - just generate an empty string. For :defer:,
1345 :blackhole:, or :fail: we have to set up the error message and give up right
1348 if (Ustrncmp(s
, ":unknown:", len
) == 0)
1354 if (Ustrncmp(s
, ":defer:", 7) == 0)
1355 { special
= FF_DEFER
; specopt
= RDO_DEFER
; } /* specbit is 0 */
1356 else if (Ustrncmp(s
, ":blackhole:", 11) == 0)
1357 { special
= FF_BLACKHOLE
; specopt
= specbit
= RDO_BLACKHOLE
; }
1358 else if (Ustrncmp(s
, ":fail:", 6) == 0)
1359 { special
= FF_FAIL
; specopt
= RDO_FAIL
; } /* specbit is 0 */
1363 uschar
*ss
= Ustrchr(s
+1, ':') + 1;
1364 if ((options
& specopt
) == specbit
)
1366 *error
= string_sprintf("\"%.*s\" is not permitted", len
, s
);
1369 while (*ss
!= 0 && isspace(*ss
)) ss
++;
1370 while (s
[len
] != 0 && s
[len
] != '\n') len
++;
1372 *error
= string_copy(ss
);
1376 /* If the address is of the form :include:pathname, read the file, and call
1377 this function recursively to extract the addresses from it. If directory is
1378 NULL, do no checks. Otherwise, insist that the file name starts with the
1379 given directory and is a regular file. */
1381 if (Ustrncmp(s
, ":include:", 9) == 0)
1384 uschar filename
[256];
1388 struct stat statbuf
;
1392 while (flen
> 0 && isspace(*t
)) { t
++; flen
--; }
1396 *error
= string_sprintf("file name missing after :include:");
1402 *error
= string_sprintf("included file name \"%s\" is too long", t
);
1406 Ustrncpy(filename
, t
, flen
);
1409 /* Insist on absolute path */
1411 if (filename
[0]!= '/')
1413 *error
= string_sprintf("included file \"%s\" is not an absolute path",
1418 /* Check if include is permitted */
1420 if ((options
& RDO_INCLUDE
) != 0)
1422 *error
= US
"included files not permitted";
1426 /* Check file name if required */
1430 int len
= Ustrlen(directory
);
1431 uschar
*p
= filename
+ len
;
1433 if (Ustrncmp(filename
, directory
, len
) != 0 || *p
!= '/')
1435 *error
= string_sprintf("included file %s is not in directory %s",
1436 filename
, directory
);
1440 #ifdef EXIM_HAVE_OPENAT
1441 /* It is necessary to check that every component inside the directory
1442 is NOT a symbolic link, in order to keep the file inside the directory.
1443 This is mighty tedious. We open the directory and openat every component,
1444 with a flag that fails symlinks. */
1447 int fd
= open(directory
, O_RDONLY
);
1450 *error
= string_sprintf("failed to open directory %s", directory
);
1459 while (*++p
&& *p
!= '/') ;
1463 if ((fd2
= openat(fd
, q
, O_RDONLY
|O_NOFOLLOW
)) < 0)
1465 *error
= string_sprintf("failed to open %s (component of included "
1466 "file); could be symbolic link", filename
);
1473 f
= fdopen(fd
, "rb");
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
1485 while (*++p
&& *p
!= '/');
1488 if (Ulstat(filename
, &statbuf
) != 0)
1490 *error
= string_sprintf("failed to stat %s (component of included "
1498 if ((statbuf
.st_mode
& S_IFMT
) == S_IFLNK
)
1500 *error
= string_sprintf("included file %s in the %s directory "
1501 "involves a symbolic link", filename
, directory
);
1508 #ifdef EXIM_HAVE_OPENAT
1511 /* Open and stat the file */
1512 f
= Ufopen(filename
, "rb");
1516 *error
= string_open_failed(errno
, "included file %s", filename
);
1517 return FF_INCLUDEFAIL
;
1520 if (fstat(fileno(f
), &statbuf
) != 0)
1522 *error
= string_sprintf("failed to stat included file %s: %s",
1523 filename
, strerror(errno
));
1525 return FF_INCLUDEFAIL
;
1528 /* If directory was checked, double check that we opened a regular file */
1530 if (directory
&& (statbuf
.st_mode
& S_IFMT
) != S_IFREG
)
1532 *error
= string_sprintf("included file %s is not a regular file in "
1533 "the %s directory", filename
, directory
);
1537 /* Get a buffer and read the contents */
1539 if (statbuf
.st_size
> MAX_INCLUDE_SIZE
)
1541 *error
= string_sprintf("included file %s is too big (max %d)",
1542 filename
, MAX_INCLUDE_SIZE
);
1546 filebuf
= store_get(statbuf
.st_size
+ 1);
1547 if (fread(filebuf
, 1, statbuf
.st_size
, f
) != statbuf
.st_size
)
1549 *error
= string_sprintf("error while reading included file %s: %s",
1550 filename
, strerror(errno
));
1554 filebuf
[statbuf
.st_size
] = 0;
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
;
1564 for (last
= addr
; last
->next
; last
= last
->next
) count
++;
1565 last
->next
= *anchor
;
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.
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
1582 /X=xxx/Y=xxx/OU=xxx/@some.gate.way
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. */
1592 int start
, end
, domain
;
1593 uschar
*recipient
= NULL
;
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. */
1605 parse_extract_address(s
+1, error
, &start
, &end
, &domain
, FALSE
);
1606 if (recipient
!= NULL
)
1607 recipient
= (domain
!= 0)? NULL
:
1608 string_sprintf("%s@%s", recipient
, incoming_domain
);
1611 /* Try parsing the item as an address. */
1613 if (recipient
== NULL
) recipient
=
1614 parse_extract_address(s
, error
, &start
, &end
, &domain
, FALSE
);
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. */
1620 if ((*s
== '|' || *s
== '/') && (recipient
== NULL
|| domain
== 0))
1622 uschar
*t
= store_get(Ustrlen(s
) + 1);
1629 *p
++ = (*q
== '\\')? *(++q
) : *q
;
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 */
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. */
1649 if (recipient
== NULL
)
1651 if (Ustrcmp(*error
, "empty address") == 0)
1659 if (syntax_errors
!= NULL
)
1661 error_block
*e
= store_get(sizeof(error_block
));
1662 error_block
*last
= *syntax_errors
;
1663 if (last
== NULL
) *syntax_errors
= e
; else
1665 while (last
->next
!= NULL
) last
= last
->next
;
1670 e
->text2
= string_copy(s
);
1677 *error
= string_sprintf("%s in \"%s\"", *error
, s
);
1678 s
[len
] = save
; /* _after_ using it for *error */
1683 /* Address was successfully parsed. Rewrite, and then make an address
1686 recipient
= ((options
& RDO_REWRITE
) != 0)?
1687 rewrite_address(recipient
, TRUE
, FALSE
, global_rewrite_rules
,
1688 rewrite_existflags
) :
1689 rewrite_address_qualify(recipient
, TRUE
);
1690 addr
= deliver_make_addr(recipient
, TRUE
); /* TRUE => copy recipient */
1693 /* Restore the final character in the original data, and add to the
1697 addr
->next
= *anchor
;
1702 /* Advance pointer for the next address */
1709 /*************************************************
1710 * Extract a Message-ID *
1711 *************************************************/
1713 /* This function is used to extract message ids from In-Reply-To: and
1714 References: header lines.
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
1721 Returns: points after the processed message-id or NULL on error
1725 parse_message_id(uschar
*str
, uschar
**yield
, uschar
**error
)
1727 uschar
*domain
= NULL
;
1730 str
= skip_comment(str
);
1733 *error
= US
"Missing '<' before message-id";
1737 /* Getting a block the size of the input string will definitely be sufficient
1738 for the answer, but it may also be very long if we are processing a header
1739 line. Therefore, take care to release unwanted store afterwards. */
1741 id
= *yield
= store_get(Ustrlen(str
) + 1);
1744 str
= read_addr_spec(str
, id
, '>', error
, &domain
);
1748 if (*str
!= '>') *error
= US
"Missing '>' after message-id";
1749 else if (domain
== NULL
) *error
= US
"domain missing in message-id";
1754 store_reset(*yield
);
1758 while (*id
!= 0) id
++;
1763 str
= skip_comment(str
);
1768 /*************************************************
1769 * Parse a fixed digit number *
1770 *************************************************/
1772 /* Parse a string containing an ASCII encoded fixed digits number
1775 str pointer to the start of the ASCII encoded number
1776 n pointer to the resulting value
1777 digits number of required digits
1779 Returns: points after the processed date or NULL on error
1783 parse_number(uschar
*str
, int *n
, int digits
)
1788 if (*str
<'0' || *str
>'9') return NULL
;
1789 *n
=10*(*n
)+(*str
++-'0');
1795 /*************************************************
1796 * Parse a RFC 2822 day of week *
1797 *************************************************/
1799 /* Parse the day of the week from a RFC 2822 date, but do not
1800 decode it, because it is only for humans.
1803 str pointer to the start of the day of the week
1805 Returns: points after the parsed day or NULL on error
1809 parse_day_of_week(uschar
*str
)
1812 day-of-week = ([FWS] day-name) / obs-day-of-week
1814 day-name = "Mon" / "Tue" / "Wed" / "Thu" /
1815 "Fri" / "Sat" / "Sun"
1817 obs-day-of-week = [CFWS] day-name [CFWS]
1820 static const uschar
*day_name
[7]={ US
"mon", US
"tue", US
"wed", US
"thu", US
"fri", US
"sat", US
"sun" };
1824 str
=skip_comment(str
);
1827 if ((day
[i
]=tolower(*str
))=='\0') return NULL
;
1831 for (i
=0; i
<7; ++i
) if (Ustrcmp(day
,day_name
[i
])==0) break;
1832 if (i
==7) return NULL
;
1833 str
=skip_comment(str
);
1838 /*************************************************
1839 * Parse a RFC 2822 date *
1840 *************************************************/
1842 /* Parse the date part of a RFC 2822 date-time, extracting the
1843 day, month and year.
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
1851 Returns: points after the processed date or NULL on error
1855 parse_date(uschar
*str
, int *d
, int *m
, int *y
)
1858 date = day month year
1860 year = 4*DIGIT / obs-year
1862 obs-year = [CFWS] 2*DIGIT [CFWS]
1864 month = (FWS month-name FWS) / obs-month
1866 month-name = "Jan" / "Feb" / "Mar" / "Apr" /
1867 "May" / "Jun" / "Jul" / "Aug" /
1868 "Sep" / "Oct" / "Nov" / "Dec"
1870 obs-month = CFWS month-name CFWS
1872 day = ([FWS] 1*2DIGIT) / obs-day
1874 obs-day = [CFWS] 1*2DIGIT [CFWS]
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" };
1882 str
=skip_comment(str
);
1883 if ((str
=parse_number(str
,d
,1))==NULL
) return NULL
;
1884 if (*str
>='0' && *str
<='9') *d
=10*(*d
)+(*str
++-'0');
1885 c
=skip_comment(str
);
1886 if (c
==str
) return NULL
;
1888 for (i
=0; i
<3; ++i
) if ((month
[i
]=tolower(*(str
+i
)))=='\0') return NULL
;
1890 for (i
=0; i
<12; ++i
) if (Ustrcmp(month
,month_name
[i
])==0) break;
1891 if (i
==12) return NULL
;
1894 c
=skip_comment(str
);
1895 if (c
==str
) return NULL
;
1897 if ((n
=parse_number(str
,y
,4)))
1900 if (*y
<1900) return NULL
;
1903 else if ((n
=parse_number(str
,y
,2)))
1905 str
=skip_comment(n
);
1906 while (*(str
-1)==' ' || *(str
-1)=='\t') --str
; /* match last FWS later */
1914 /*************************************************
1915 * Parse a RFC 2822 Time *
1916 *************************************************/
1918 /* Parse the time part of a RFC 2822 date-time, extracting the
1919 hour, minute, second and timezone.
1922 str pointer to the start of the time
1923 h pointer to the resulting hour
1924 m pointer to the resulting minute
1925 s pointer to the resulting second
1926 z pointer to the resulting timezone (offset in seconds)
1928 Returns: points after the processed time or NULL on error
1932 parse_time(uschar
*str
, int *h
, int *m
, int *s
, int *z
)
1935 time = time-of-day FWS zone
1937 time-of-day = hour ":" minute [ ":" second ]
1939 hour = 2DIGIT / obs-hour
1941 obs-hour = [CFWS] 2DIGIT [CFWS]
1943 minute = 2DIGIT / obs-minute
1945 obs-minute = [CFWS] 2DIGIT [CFWS]
1947 second = 2DIGIT / obs-second
1949 obs-second = [CFWS] 2DIGIT [CFWS]
1951 zone = (( "+" / "-" ) 4DIGIT) / obs-zone
1953 obs-zone = "UT" / "GMT" / ; Universal Time
1956 "EST" / "EDT" / ; Eastern: - 5/ - 4
1957 "CST" / "CDT" / ; Central: - 6/ - 5
1958 "MST" / "MDT" / ; Mountain: - 7/ - 6
1959 "PST" / "PDT" / ; Pacific: - 8/ - 7
1961 %d65-73 / ; Military zones - "A"
1962 %d75-90 / ; through "I" and "K"
1963 %d97-105 / ; through "Z", both
1964 %d107-122 ; upper and lower case
1969 str
=skip_comment(str
);
1970 if ((str
=parse_number(str
,h
,2))==NULL
) return NULL
;
1971 str
=skip_comment(str
);
1972 if (*str
!=':') return NULL
;
1974 str
=skip_comment(str
);
1975 if ((str
=parse_number(str
,m
,2))==NULL
) return NULL
;
1976 c
=skip_comment(str
);
1980 str
=skip_comment(str
);
1981 if ((str
=parse_number(str
,s
,2))==NULL
) return NULL
;
1982 c
=skip_comment(str
);
1984 if (c
==str
) return NULL
;
1986 if (*str
=='+' || *str
=='-')
1992 if ((str
=parse_number(str
,z
,4))==NULL
) return NULL
;
1993 *z
=(*z
/100)*3600+(*z
%100)*60;
1999 struct { const char *name
; int off
; } zone_name
[10]=
2000 { {"gmt",0}, {"ut",0}, {"est",-5}, {"edt",-4}, {"cst",-6}, {"cdt",-5}, {"mst",-7}, {"mdt",-6}, {"pst",-8}, {"pdt",-7}};
2005 zone
[i
]=tolower(*(str
+i
));
2006 if (zone
[i
]<'a' || zone
[i
]>'z') break;
2009 for (j
=0; j
<10 && strcmp(zone
,zone_name
[j
].name
); ++j
);
2010 /* Besides zones named in the grammar, RFC 2822 says other alphabetic */
2011 /* time zones should be treated as unknown offsets. */
2014 *z
=zone_name
[j
].off
*3600;
2017 else if (zone
[0]<'a' || zone
[1]>'z') return 0;
2020 while ((*str
>='a' && *str
<='z') || (*str
>='A' && *str
<='Z')) ++str
;
2028 /*************************************************
2029 * Parse a RFC 2822 date-time *
2030 *************************************************/
2032 /* Parse a RFC 2822 date-time and return it in seconds since the epoch.
2035 str pointer to the start of the date-time
2036 t pointer to the parsed time
2038 Returns: points after the processed date-time or NULL on error
2042 parse_date_time(uschar
*str
, time_t *t
)
2045 date-time = [ day-of-week "," ] date FWS time [CFWS]
2050 extern char **environ
;
2052 static char gmt0
[]="TZ=GMT0";
2053 static char *gmt_env
[]={ gmt0
, (char*)0 };
2056 if ((try=parse_day_of_week(str
)))
2059 if (*str
!=',') return 0;
2062 if ((str
=parse_date(str
,&tm
.tm_mday
,&tm
.tm_mon
,&tm
.tm_year
))==NULL
) return NULL
;
2063 if (*str
!=' ' && *str
!='\t') return NULL
;
2064 while (*str
==' ' || *str
=='\t') ++str
;
2065 if ((str
=parse_time(str
,&tm
.tm_hour
,&tm
.tm_min
,&tm
.tm_sec
,&zone
))==NULL
) return NULL
;
2067 old_environ
=environ
;
2070 environ
=old_environ
;
2071 if (*t
==-1) return NULL
;
2073 str
=skip_comment(str
);
2080 /*************************************************
2081 **************************************************
2082 * Stand-alone test program *
2083 **************************************************
2084 *************************************************/
2086 #if defined STAND_ALONE
2089 int start
, end
, domain
;
2090 uschar buffer
[1024];
2091 uschar outbuff
[1024];
2093 big_buffer
= store_malloc(big_buffer_size
);
2095 /* strip_trailing_dot = TRUE; */
2096 allow_domain_literals
= TRUE
;
2098 printf("Testing parse_fix_phrase\n");
2100 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2102 buffer
[Ustrlen(buffer
)-1] = 0;
2103 if (buffer
[0] == 0) break;
2104 printf("%s\n", CS
parse_fix_phrase(buffer
, Ustrlen(buffer
), outbuff
,
2108 printf("Testing parse_extract_address without group syntax and without UTF-8\n");
2110 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
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
== NULL
) printf("*** bad address: %s\n", errmess
); else
2119 uschar extract
[1024];
2120 Ustrncpy(extract
, buffer
+start
, end
-start
);
2121 extract
[end
-start
] = 0;
2122 printf("%s %d %d %d \"%s\"\n", out
, start
, end
, domain
, extract
);
2126 printf("Testing parse_extract_address without group syntax but with UTF-8\n");
2128 allow_utf8_domains
= TRUE
;
2129 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2133 buffer
[Ustrlen(buffer
) - 1] = 0;
2134 if (buffer
[0] == 0) break;
2135 out
= parse_extract_address(buffer
, &errmess
, &start
, &end
, &domain
, FALSE
);
2136 if (out
== NULL
) printf("*** bad address: %s\n", errmess
); else
2138 uschar extract
[1024];
2139 Ustrncpy(extract
, buffer
+start
, end
-start
);
2140 extract
[end
-start
] = 0;
2141 printf("%s %d %d %d \"%s\"\n", out
, start
, end
, domain
, extract
);
2144 allow_utf8_domains
= FALSE
;
2146 printf("Testing parse_extract_address with group syntax\n");
2148 parse_allow_group
= TRUE
;
2149 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2154 buffer
[Ustrlen(buffer
) - 1] = 0;
2155 if (buffer
[0] == 0) break;
2159 uschar
*ss
= parse_find_address_end(s
, FALSE
);
2160 int terminator
= *ss
;
2162 out
= parse_extract_address(buffer
, &errmess
, &start
, &end
, &domain
, FALSE
);
2165 if (out
== NULL
) printf("*** bad address: %s\n", errmess
); else
2167 uschar extract
[1024];
2168 Ustrncpy(extract
, buffer
+start
, end
-start
);
2169 extract
[end
-start
] = 0;
2170 printf("%s %d %d %d \"%s\"\n", out
, start
, end
, domain
, extract
);
2173 s
= ss
+ (terminator
? 1:0);
2174 while (isspace(*s
)) s
++;
2178 printf("Testing parse_find_at\n");
2180 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2183 buffer
[Ustrlen(buffer
)-1] = 0;
2184 if (buffer
[0] == 0) break;
2185 s
= parse_find_at(buffer
);
2186 if (s
== NULL
) printf("no @ found\n");
2187 else printf("offset = %d\n", s
- buffer
);
2190 printf("Testing parse_extract_addresses\n");
2192 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2196 address_item
*anchor
= NULL
;
2197 buffer
[Ustrlen(buffer
) - 1] = 0;
2198 if (buffer
[0] == 0) break;
2199 if ((extracted
= parse_forward_list(buffer
, -1, &anchor
,
2200 &errmess
, US
"incoming.domain", NULL
, NULL
)) == FF_DELIVERED
)
2202 while (anchor
!= NULL
)
2204 address_item
*addr
= anchor
;
2205 anchor
= anchor
->next
;
2206 printf("%d %s\n", testflag(addr
, af_pfr
), addr
->address
);
2209 else printf("Failed: %d %s\n", extracted
, errmess
);
2212 printf("Testing parse_message_id\n");
2214 while (Ufgets(buffer
, sizeof(buffer
), stdin
) != NULL
)
2216 uschar
*s
, *t
, *errmess
;
2217 buffer
[Ustrlen(buffer
) - 1] = 0;
2218 if (buffer
[0] == 0) break;
2222 s
= parse_message_id(s
, &t
, &errmess
);
2223 if (errmess
!= NULL
)
2225 printf("Failed: %s\n", errmess
);
2237 /* End of parse.c */