1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Functions concerned with rewriting headers */
13 /* Names for testing rewriting */
15 static const char *rrname[] = {
26 /* Structure and table for finding source of address for debug printing */
28 typedef struct where_list_block {
33 static where_list_block where_list[] = {
34 { rewrite_sender, CUS"sender:" },
35 { rewrite_from, CUS"from:" },
36 { rewrite_to, CUS"to:" },
37 { rewrite_cc, CUS"cc:" },
38 { rewrite_bcc, CUS"bcc:" },
39 { rewrite_replyto, CUS"reply-to:" },
40 { rewrite_envfrom, CUS"env-from" },
41 { rewrite_envto, CUS"env-to" },
42 { rewrite_smtp, CUS"smtp recipient" },
43 { rewrite_smtp|rewrite_smtp_sender, CUS"smtp sender" }
46 static int where_list_size = sizeof(where_list)/sizeof(where_list_block);
50 /*************************************************
51 * Ensure an address is qualified *
52 *************************************************/
57 is_recipient TRUE if a recipient address; FALSE if a sender address
59 Returns: fully-qualified address
63 rewrite_address_qualify(const uschar *s, BOOL is_recipient)
65 return parse_find_at(s)
66 ? s : string_sprintf("%s@%s", s,
67 is_recipient ? qualify_domain_recipient : qualify_domain_sender);
72 /*************************************************
73 * Rewrite a single address *
74 *************************************************/
76 /* The yield is the input address if there is no rewriting to be done. Assume
77 the input is a valid address, except in the case of SMTP-time rewriting, which
78 is handled specially. When this function is called while processing filter and
79 forward files, the uid may be that of the user. Ensure it is reset while
80 expanding a replacement, in case that involves file lookups.
84 flag indicates where this address comes from; it must match the
85 flags in the rewriting rule
86 whole if not NULL, set TRUE if any rewriting rule contained the
87 "whole" bit and it is a header that is being rewritten
88 add_header if TRUE and rewriting occurs, add an "X-rewrote-xxx" header
89 if headers are in existence; this should be TRUE only when
90 a message is being received, not during delivery
91 name name of header, for use when adding X-rewrote-xxxx
92 rewrite_rules chain of rewriting rules
94 Returns: new address if rewritten; the input address if no change;
95 for a header rewrite, if the "whole" bit is set, the entire
96 rewritten address is returned, not just the active bit.
100 rewrite_one(const uschar *s, int flag, BOOL *whole, BOOL add_header, uschar *name,
101 rewrite_rule *rewrite_rules)
103 const uschar *yield = s;
104 const uschar *subject = s;
105 uschar *domain = NULL;
108 int yield_start = 0, yield_end = 0;
110 if (whole) *whole = FALSE;
112 /* Scan the rewriting rules */
114 for (rewrite_rule * rule = rewrite_rules;
116 rule_number++, rule = rule->next)
118 int start, end, pdomain;
120 uschar *save_localpart;
121 const uschar *save_domain;
123 const uschar * newparsed;
125 /* Ensure that the flag matches the flags in the rule. */
127 if (!(rule->flags & flag)) continue;
129 /* Come back here for a repeat after a successful rewrite. We do this
130 only so many times. */
134 /* If this is an SMTP-time rewrite, the pattern must be a regex and
135 the subject may have any structure. No local part or domain variables
136 can be set for the expansion. We expand the pattern in order to be consistent
137 with the other kinds of rewrite, where expansion happens inside
138 match_address_list(). */
140 if (flag & rewrite_smtp)
142 uschar *key = expand_string(rule->key);
145 if (!f.expand_string_forcedfail)
146 log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while "
147 "checking for SMTP rewriting: %s", rule->key, expand_string_message);
150 if (match_check_string(subject, key, 0, TRUE, FALSE, FALSE, NULL) != OK)
152 new = expand_string(rule->replacement);
155 /* All other rewrites expect the input to be a valid address, so local part
156 and domain variables can be set for expansion. For the first rule, to be
157 applied to this address, domain will be NULL and needs to be set. */
161 if (!domain) domain = Ustrrchr(subject, '@') + 1;
163 /* Use the general function for matching an address against a list (here
164 just one item, so use the "impossible value" separator UCHAR_MAX+1). */
166 if (match_address_list(subject, FALSE, TRUE, CUSS &(rule->key), NULL, 0,
167 UCHAR_MAX + 1, NULL) != OK)
170 /* The source address matches, and numerical variables have been
171 set up. If the replacement string consists of precisely "*" then no
172 rewriting is required for this address - the behaviour is as for "fail"
173 in the replacement expansion, but assuming the quit flag. */
175 if (Ustrcmp(rule->replacement, "*") == 0) break;
177 /* Otherwise, expand the replacement string. Set $local_part and $domain to
178 the appropriate values, restoring whatever value they previously had
181 save_localpart = deliver_localpart;
182 save_domain = deliver_domain;
184 /* We have subject pointing to "localpart@domain" and domain pointing to
185 the domain. Temporarily terminate the local part so that it can be
186 set up as an expansion variable */
189 deliver_localpart = US subject;
190 deliver_domain = domain;
192 new = expand_string(rule->replacement);
195 deliver_localpart = save_localpart;
196 deliver_domain = save_domain;
199 /* If the expansion failed with the "forcedfail" flag, don't generate
200 an error - just give up on this rewriting rule. If the "q" flag is set,
201 give up altogether. For other expansion failures we have a configuration
206 if (f.expand_string_forcedfail)
207 { if (rule->flags & rewrite_quit) break; else continue; }
209 expand_string_message = expand_hide_passwords(expand_string_message);
211 log_write(0, LOG_MAIN|LOG_PANIC, "Expansion of %s failed while rewriting: "
212 "%s", rule->replacement, expand_string_message);
216 /* Check the what has been generated is a valid RFC 2822 address. Only
217 envelope from or SMTP sender is permitted to be rewritten as <>.*/
219 newparsed = parse_extract_address(new, &error, &start, &end, &pdomain,
220 flag == rewrite_envfrom || flag == (rewrite_smtp|rewrite_smtp_sender));
224 log_write(0, LOG_MAIN|LOG_PANIC, "Rewrite of %s yielded unparseable "
225 "address: %s in address %s", subject, error, new);
226 break; /* Give up on this address */
229 /* A non-null unqualified address can be qualified if requested. Otherwise,
230 this is an error unless it's the empty address in circumstances where that is
233 if (pdomain == 0 && (*newparsed != 0 ||
234 (flag != rewrite_envfrom && flag != (rewrite_smtp|rewrite_smtp_sender))))
236 if (rule->flags & rewrite_qualify)
238 newparsed = rewrite_address_qualify(newparsed, TRUE);
239 new = string_sprintf("%.*s%s%.*s", start, new, newparsed,
240 Ustrlen(new) - end, new + end);
241 end = start + Ustrlen(newparsed);
245 log_write(0, LOG_MAIN|LOG_PANIC, "Rewrite of %s yielded unqualified "
246 "address \"%s\"", subject, new);
247 break; /* Give up on this address */
251 /* We have a validly rewritten address */
253 if (LOGGING(address_rewrite) || (debug_selector & D_rewrite) != 0)
255 const uschar *where = CUS"?";
257 for (int i = 0; i < where_list_size; i++)
258 if (flag == where_list[i].bit)
260 where = where_list[i].string;
263 log_write(L_address_rewrite,
264 LOG_MAIN, "\"%s\" from %s rewritten as \"%s\" by rule %d",
265 yield, where, new, rule_number);
268 /* A header will only actually be added if header_last is non-NULL,
269 i.e. during message reception or delivery, but add_header should not
270 be set TRUE during delivery, as otherwise multiple instances of the header
271 can fill up the -H file and make it embarrassingly large. We don't need
272 to set header_rewritten because the -H file always gets written at the end
273 of message reception. */
276 header_add(htype_old, "X-rewrote-%s: %s\n", name, subject);
278 /* Handle the case when replacement of the whole address is possible.
279 This happens only when whole is not NULL and we are rewriting a header.
280 If *whole is already TRUE it means that a previous rule had the w
281 flag set and so we must preserve the non-active portion of the current
282 subject unless the current rule also has the w flag set. */
284 if (whole && (flag & rewrite_all_headers))
286 /* Current rule has the w flag set. We must ensure the phrase parts
287 are syntactically valid if they are present. */
289 if (rule->flags & rewrite_whole)
291 if (start > 0 && new[start-1] == '<')
293 uschar *p1 = new + start - 1;
294 uschar *p2 = new + end + 1;
295 const uschar *pf1, *pf2;
297 while (p1 > new && p1[-1] == ' ') p1--;
298 pf1 = parse_fix_phrase(new, p1 - new);
299 while (*p2 == ' ') p2++;
300 pf2 = parse_fix_phrase(p2, Ustrlen(p2));
302 start = Ustrlen(pf1) + start + new - p1;
303 end = start + Ustrlen(newparsed);
304 new = string_sprintf("%s%.*s%s", pf1, (int)(p2 - p1), p1, pf2);
307 /* Now accept the whole thing */
316 /* Current rule does not have the w flag set; if not previously
317 done any whole rewriting, behave in non-whole manner. */
319 else if (!*whole) goto NEVER_WHOLE;
321 /* Current rule does not have the w flag set, but a previous
322 rule did rewrite the whole address. Thus yield and subject will be
323 different. Preserve the previous non-active part of the address. */
328 new = string_sprintf("%.*s%s%n%s",
329 yield_start, yield, subject, &end, yield + yield_end);
335 /* Rule just rewrites active part, or handling an envelope. This
336 code is obeyed only when all rules so far have not done "whole"
342 subject = yield = newparsed;
345 domain = NULL; /* Reset for next rule */
347 /* If no further rewrites are to be done, set the done flag. This allows
348 repeats of the current rule if configured before breaking the loop. */
350 if (rule->flags & rewrite_quit) done = TRUE;
352 /* Allow the current rule to be applied up to 10 times if
355 if (rule->flags & rewrite_repeat)
357 if (count++ < 10) goto REPEAT_RULE;
358 log_write(0, LOG_MAIN|LOG_PANIC, "rewrite rule repeat ignored after 10 "
363 /* Unset expansion numeric variables, and that's it. */
371 /*************************************************
372 * Ensure qualification and rewrite *
373 *************************************************/
375 /* This function is called for envelope addresses, the boolean specifying
376 whether a recipient or a sender. It must first of all ensure the address is
377 fully qualified, and then apply any relevant re-writing rules. The add-header
378 flag causes a header to be added, recording the old address. This is marked
379 "old", so that it is never transported anywhere; it exists for local checking
380 and debugging purposes.
383 s the address to be considered
384 is_recipient TRUE for recipient addresses; FALSE otherwise
385 add_header add "X-rewrote-xxx" header when rewriting; this is
386 set TRUE only for calls from the reception functions
387 rewrite_rules points to chain of rewrite rules
388 existflags bits indicating which headers there are rewrites for
389 (just an optimisation)
391 Returns: possibly rewritten address
395 rewrite_address(const uschar *s, BOOL is_recipient, BOOL add_header,
396 rewrite_rule *rewrite_rules, int existflags)
398 int flag = is_recipient ? rewrite_envto : rewrite_envfrom;
400 s = rewrite_address_qualify(s, is_recipient);
401 if (existflags & flag)
403 const uschar *new = rewrite_one(s, flag, NULL, add_header, is_recipient?
404 US"original-recipient" : US"sender", rewrite_rules);
405 if (new != s) s = new;
412 /*************************************************
413 * Qualify and possibly rewrite one header *
414 *************************************************/
416 /* This is called only from rewrite_header() below, either when reading a
417 message. or when routing, in order to rewrite addresses that get changed by a
418 router. This is normally the addition of full qualification to a partial
419 domain. The first rewriting rule in this case is "change routed_old into
420 routed_new", and it applies to all header lines that contain addresses. Then
421 header-specific rewriting rules are applied.
423 Before rewriting can be done, addresses without domains have to be qualified.
424 This should only be done for messages from "local" senders. This is a difficult
425 concept to pin down, what with the use of SMTP both as a submission and as a
426 transmission protocol. Exim normally requires incoming SMTP to contain fully-
427 qualified addresses, but there are options to permit unqualified ones from
428 certain hosts. For those hosts only, addresses in headers can also be
429 qualified. For other hosts, unqualified addresses in headers do not get touched
430 in any way. For locally sourced messages, unqualified addresses always get
431 qualified, except when -bnq is used to explicitly suppress this.
434 h pointer to header line block
435 flag indicates which header this is
436 routed_old if not NULL, this is a rewrite caused by a router, changing
437 this domain into routed_new
438 routed_new new routed domain if routed_old is not NULL
439 rewrite_rules points to chain of rewriting rules
440 existflags bits indicating which rewrites exist
441 replace if TRUE, insert the new header in the chain after the old
442 one, and mark the old one "replaced"
444 Returns: NULL if header unchanged; otherwise the rewritten header
448 rewrite_one_header(header_line *h, int flag,
449 const uschar *routed_old, const uschar *routed_new,
450 rewrite_rule *rewrite_rules, int existflags, BOOL replace)
453 header_line *newh = NULL;
454 rmark function_reset_point = store_mark();
455 uschar *s = Ustrchr(h->text, ':') + 1;
456 while (isspace(*s)) s++;
459 debug_printf("rewrite_one_header: type=%c:\n %s", h->type, h->text);
461 f.parse_allow_group = TRUE; /* Allow group syntax */
463 /* Loop for multiple addresses in the header. We have to go through them all
464 in case any need qualifying, even if there's no rewriting. Pathological headers
465 may have thousands of addresses in them, so cause the store to be reset for
466 any that don't actually get rewritten. We also play silly games for those that
467 _are_ rewritten so as to avoid runaway store usage for these kinds of header.
468 We want to avoid keeping store for any intermediate versions. */
473 uschar *ss = parse_find_address_end(s, FALSE);
474 uschar *recipient, *new, *errmess;
475 rmark loop_reset_point = store_mark();
476 BOOL changed = FALSE;
477 int terminator = *ss;
478 int start, end, domain;
480 /* Temporarily terminate the string at this point, and extract the
481 operative address within. Then put back the terminator and prepare for
482 the next address, saving the start of the old one. */
485 recipient = parse_extract_address(s,&errmess,&start,&end,&domain,FALSE);
488 s = ss + (terminator? 1:0);
489 while (isspace(*s)) s++;
491 /* There isn't much we can do for syntactic disasters at this stage.
492 Pro tem (possibly for ever) ignore them. */
496 loop_reset_point = store_reset(loop_reset_point);
500 /* If routed_old is not NULL, this is a rewrite caused by a router,
501 consisting of changing routed_old into routed_new, and applying to all
502 headers. If the header address has no domain, it is excluded, since a router
503 rewrite affects domains only. The new value should always be fully qualified,
504 but it may be something that has an explicit re-write rule set, so we need to
505 check the configured rules subsequently as well. (Example: there's an
506 explicit rewrite turning *.foo.com into foo.com, and an address is supplied
507 as abc@xyz, which the DNS lookup turns into abc@xyz.foo.com). However, if no
508 change is made here, don't bother carrying on. */
510 if (routed_old != NULL)
512 if (domain <= 0 || strcmpic(recipient+domain, routed_old) != 0) continue;
513 recipient[domain-1] = 0;
514 new = string_sprintf("%s@%s", recipient, routed_new);
517 recipient[domain-1] = '@';
518 debug_printf("%s rewritten by router as %s\n", recipient, new);
524 /* This is not a router-inspired rewrite. Ensure the address is fully
525 qualified if that is permitted. If an unqualified address was received
526 from a host that isn't listed, do not continue rewriting this address.
527 Sender, From or Reply-To headers are treated as senders, the rest as
528 recipients. This matters only when there are different qualify strings. */
533 (flag & (rewrite_sender | rewrite_from | rewrite_replyto)) == 0;
534 /* deconst ok as recipient was notconst */
535 new = US rewrite_address_qualify(recipient, is_recipient);
536 changed = (new != recipient);
539 /* Can only qualify if permitted; if not, no rewrite. */
541 if (changed && ((is_recipient && !f.allow_unqualified_recipient) ||
542 (!is_recipient && !f.allow_unqualified_sender)))
544 loop_reset_point = store_reset(loop_reset_point);
549 /* If there are rewrite rules for this type of header, apply
550 them. This test is just for efficiency, to save scanning the rules
551 in cases when nothing is going to change. If any rewrite rule had the
552 "whole" flag set, adjust the pointers so that the whole address gets
553 replaced, except possibly a final \n. */
555 if ((existflags & flag) != 0)
558 /* deconst ok as recipient was notconst */
559 new = US rewrite_one(recipient, flag, &whole, FALSE, NULL, rewrite_rules);
560 if (new != recipient)
567 if (sprev[end-1] == '\n') end--;
572 /* If nothing has changed, lose all dynamic store obtained in this loop, and
573 move on to the next address. We can't reset to the function start store
574 point, because we may have a rewritten line from a previous time round the
577 if (!changed) loop_reset_point = store_reset(loop_reset_point);
579 /* If the address has changed, create a new header containing the
580 rewritten address. We do not need to set the chain pointers at this
581 stage. We want to avoid using more and more memory if the header is very long
582 and contains lots and lots of rewritten addresses. Therefore, we build the
583 new text string in malloc store, then at the end we reset dynamic store
584 before copying the new header to a new block (and then freeing the malloc
585 block). The header must end up in dynamic store so that it's freed at the end
586 of receiving a message. */
591 int newlen = Ustrlen(new);
592 int oldlen = end - start;
594 header_line * prev = newh ? newh : h;
595 uschar * newt = store_get_perm(prev->slen - oldlen + newlen + 4, TRUE);
596 uschar * newtstart = newt;
598 int type = prev->type;
599 int slen = prev->slen - oldlen + newlen;
601 /* Build the new header text by copying the old and putting in the
602 replacement. This process may make the header substantially longer
603 than it was before - qualification of a list of bare addresses can
604 often do this - so we stick in a newline after the re-written address
605 if it has increased in length and ends more than 40 characters in. In
606 fact, the code is not perfect, since it does not scan for existing
607 newlines in the header, but it doesn't seem worth going to that
608 amount of trouble. */
610 Ustrncpy(newt, prev->text, sprev - prev->text + start);
611 newt += sprev - prev->text + start;
615 remlen = s - (sprev + end);
618 Ustrncpy(newt, sprev + end, remlen);
623 /* Must check that there isn't a newline here anyway; in particular, there
624 will be one at the very end of the header, where we DON'T want to insert
625 another one! The pointer s has been skipped over white space, so just
626 look back to see if the last non-space-or-tab was a newline. */
628 if (newlen > oldlen && newt - newtstart - lastnewline > 40)
631 while (p >= prev->text && (*p == ' ' || *p == '\t')) p--;
634 lastnewline = newt - newtstart;
635 Ustrcat(newt, US"\n\t");
640 /* Finally, the remaining unprocessed addresses, if any. */
644 DEBUG(D_rewrite) debug_printf("newlen=%d newtype=%c newtext:\n%s",
645 slen, type, newtstart);
647 /* Compute the length of the rest of the header line before we possibly
648 flatten a previously rewritten copy. */
650 remlen = (s - prev->text) - oldlen + newlen;
652 /* We have the new text in a malloc block. That enables us to release all
653 the memory that has been used, back to the point at which the function was
654 entered. Then set up a new header in dynamic store. This will override a
655 rewritten copy from a previous time round this loop. */
657 store_reset(function_reset_point);
658 function_reset_point = store_mark();
659 newh = store_get(sizeof(header_line), FALSE);
662 newh->text = string_copyn(newtstart, slen);
664 /* Set up for scanning the rest of the header */
666 s = newh->text + remlen;
667 DEBUG(D_rewrite) debug_printf("remainder: %s", (*s == 0)? US"\n" : s);
671 f.parse_allow_group = FALSE; /* Reset group flags */
672 f.parse_found_group = FALSE;
674 /* If a rewrite happened and "replace" is true, put the new header into the
675 chain following the old one, and mark the old one as replaced. */
677 if (newh != NULL && replace)
679 newh->next = h->next;
680 if (newh->next == NULL) header_last = newh;
691 /*************************************************
692 * Rewrite a header line *
693 *************************************************/
695 /* This function may be passed any old header line. It must detect those which
696 contain addresses, then then apply any rewriting rules that apply. If
697 routed_old is NULL, only the configured rewriting rules are consulted.
698 Otherwise, the rewriting rule is "change routed_old into routed_new", and it
699 applies to all header lines that contain addresses. Then header-specific
700 rewriting rules are applied.
702 The old header line is flagged as "old". Old headers are saved on the spool for
703 debugging but are never sent to any recipients.
706 h header line to rewrite
707 routed_old if not NULL, this is a rewrite caused by a router, changing
708 this domain into routed_new
709 routed_new new routed domain if routed_old is not NULL
710 rewrite_rules points to chain of rewrite rules
711 existflags bits indicating which rewrites exist
712 replace if TRUE, the new header is inserted into the header chain
713 after the old one, and the old one is marked replaced
715 Returns: NULL if header unchanged; otherwise the rewritten header
719 rewrite_header(header_line *h,
720 const uschar *routed_old, const uschar *routed_new,
721 rewrite_rule *rewrite_rules, int existflags, BOOL replace)
726 case htype_sender: flag = rewrite_sender; break;
727 case htype_from: flag = rewrite_from; break;
728 case htype_to: flag = rewrite_to; break;
729 case htype_cc: flag = rewrite_cc; break;
730 case htype_bcc: flag = rewrite_bcc; break;
731 case htype_reply_to: flag = rewrite_replyto; break;
732 default: return NULL;
734 return rewrite_one_header(h, flag, routed_old, routed_new,
735 rewrite_rules, existflags, replace);
740 /************************************************
741 * Test rewriting rules *
742 ************************************************/
744 /* Called from the mainline as a result of the -brw option. Test the
745 address for all possible cases.
747 Argument: the address to test
752 rewrite_test(const uschar *s)
754 uschar *recipient, *error;
755 int start, end, domain;
756 BOOL done_smtp = FALSE;
758 if (rewrite_existflags == 0)
760 printf("No rewrite rules are defined\n");
764 /* Do SMTP rewrite only if a rule with the S flag exists. Allow <> by
765 pretending it is a sender. */
767 if ((rewrite_existflags & rewrite_smtp) != 0)
769 const uschar * new = rewrite_one(s, rewrite_smtp|rewrite_smtp_sender, NULL,
770 FALSE, US"", global_rewrite_rules);
774 printf(" SMTP: <>\n");
776 printf(" SMTP: %s\n", new);
781 /* Do the other rewrites only if a rule without the S flag exists */
783 if ((rewrite_existflags & ~rewrite_smtp) == 0) return;
785 /* Qualify if necessary before extracting the address */
787 if (parse_find_at(s) == NULL)
788 s = string_sprintf("%s@%s", s, qualify_domain_recipient);
790 recipient = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
795 printf("Syntax error in %s\n%c%s\n", s, toupper(error[0]), error+1);
799 for (int i = 0; i < 8; i++)
803 const uschar * new = rewrite_one(recipient, flag, &whole, FALSE, US"",
804 global_rewrite_rules);
805 printf("%s: ", rrname[i]);
808 else if (whole || (flag & rewrite_all_headers) == 0)
809 printf("%s\n", CS new);
810 else printf("%.*s%s%s\n", start, s, new, s+end);
814 /* End of rewrite.c */