ab5f78020ecdff3dd35947ac558f02daff3f9694
[exim.git] / src / src / rewrite.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions concerned with rewriting headers */
9
10
11 #include "exim.h"
12
13 /* Names for testing rewriting */
14
15 static const char *rrname[] = {
16   "  sender",
17   "    from",
18   "      to",
19   "      cc",
20   "     bcc",
21   "reply-to",
22   "env-from",
23   "  env-to"
24 };
25
26 /* Structure and table for finding source of address for debug printing */
27
28 typedef struct where_list_block {
29   int bit;
30   const uschar *string;
31 } where_list_block;
32
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" }
44 };
45
46 static int where_list_size = sizeof(where_list)/sizeof(where_list_block);
47
48
49
50 /*************************************************
51 *            Ensure an address is qualified      *
52 *************************************************/
53
54 /*
55 Arguments:
56   s              address to check
57   is_recipient   TRUE if a recipient address; FALSE if a sender address
58
59 Returns:         fully-qualified address
60 */
61
62 const uschar *
63 rewrite_address_qualify(const uschar *s, BOOL is_recipient)
64 {
65 return parse_find_at(s)
66   ? s : string_sprintf("%s@%s", s,
67           is_recipient ? qualify_domain_recipient : qualify_domain_sender);
68 }
69
70
71
72 /*************************************************
73 *               Rewrite a single address         *
74 *************************************************/
75
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.
81
82 Arguments:
83   s              address to rewrite
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
93
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.
97 */
98
99 const uschar *
100 rewrite_one(const uschar *s, int flag, BOOL *whole, BOOL add_header, uschar *name,
101   rewrite_rule *rewrite_rules)
102 {
103 const uschar *yield = s;
104 const uschar *subject = s;
105 uschar *domain = NULL;
106 BOOL done = FALSE;
107 int rule_number = 1;
108 int yield_start = 0, yield_end = 0;
109
110 if (whole) *whole = FALSE;
111
112 /* Scan the rewriting rules, ignoring any without matching flag */
113
114 for (rewrite_rule * rule = rewrite_rules;
115      rule && !done;
116      rule_number++, rule = rule->next) if (rule->flags & flag)
117   {
118   int start, end, pdomain;
119   int count = 0;
120   uschar *save_localpart;
121   const uschar *save_domain;
122   uschar *error, *new;
123   const uschar * newparsed;
124
125   /* Come back here for a repeat after a successful rewrite. We do this
126   only so many times. */
127
128   REPEAT_RULE:
129
130   /* If this is an SMTP-time rewrite, the pattern must be a regex and
131   the subject may have any structure. No local part or domain variables
132   can be set for the expansion. We expand the pattern in order to be consistent
133   with the other kinds of rewrite, where expansion happens inside
134   match_address_list(). */
135
136   if (flag & rewrite_smtp)
137     {
138     uschar *key = expand_string(rule->key);
139     if (!key)
140       {
141       if (!f.expand_string_forcedfail)
142         log_write(0, LOG_MAIN|LOG_PANIC, "failed to expand \"%s\" while "
143           "checking for SMTP rewriting: %s", rule->key, expand_string_message);
144       continue;
145       }
146     if (match_check_string(subject, key, 0, TRUE, FALSE, FALSE, NULL) != OK)
147       continue;
148     new = expand_string(rule->replacement);
149     }
150
151   /* All other rewrites expect the input to be a valid address, so local part
152   and domain variables can be set for expansion. For the first rule, to be
153   applied to this address, domain will be NULL and needs to be set. */
154
155   else
156     {
157     if (!domain) domain = Ustrrchr(subject, '@') + 1;
158
159     /* Use the general function for matching an address against a list (here
160     just one item, so use the "impossible value" separator UCHAR_MAX+1). */
161
162     if (match_address_list(subject, FALSE, TRUE, CUSS &(rule->key), NULL, 0,
163         UCHAR_MAX + 1, NULL) != OK)
164       continue;
165
166     /* The source address matches, and numerical variables have been
167     set up. If the replacement string consists of precisely "*" then no
168     rewriting is required for this address - the behaviour is as for "fail"
169     in the replacement expansion, but assuming the quit flag. */
170
171     if (Ustrcmp(rule->replacement, "*") == 0) break;
172
173     /* Otherwise, expand the replacement string. Set $local_part and $domain to
174     the appropriate values, restoring whatever value they previously had
175     afterwards. */
176
177     save_localpart = deliver_localpart;
178     save_domain = deliver_domain;
179
180     /* We have subject pointing to "localpart@domain" and domain pointing to
181     the domain. Temporarily terminate the local part so that it can be
182     set up as an expansion variable */
183
184     domain[-1] = 0;
185     deliver_localpart = US subject;
186     deliver_domain = domain;
187
188     new = expand_string(rule->replacement);
189
190     domain[-1] = '@';
191     deliver_localpart = save_localpart;
192     deliver_domain = save_domain;
193     }
194
195   /* If the expansion failed with the "forcedfail" flag, don't generate
196   an error - just give up on this rewriting rule. If the "q" flag is set,
197   give up altogether. For other expansion failures we have a configuration
198   error. */
199
200   if (!new)
201     {
202     if (f.expand_string_forcedfail)
203       { if (rule->flags & rewrite_quit) break; else continue; }
204
205     expand_string_message = expand_hide_passwords(expand_string_message);
206
207     log_write(0, LOG_MAIN|LOG_PANIC, "Expansion of %s failed while rewriting: "
208       "%s", rule->replacement, expand_string_message);
209     break;
210     }
211
212   /* Check the what has been generated is a valid RFC 2822 address. Only
213   envelope from or SMTP sender is permitted to be rewritten as <>.*/
214
215   newparsed = parse_extract_address(new, &error, &start, &end, &pdomain,
216     flag == rewrite_envfrom || flag == (rewrite_smtp|rewrite_smtp_sender));
217
218   if (!newparsed)
219     {
220     log_write(0, LOG_MAIN|LOG_PANIC, "Rewrite of %s yielded unparseable "
221       "address: %s in address %s", subject, error, new);
222     break;   /* Give up on this address */
223     }
224
225   /* A non-null unqualified address can be qualified if requested. Otherwise,
226   this is an error unless it's the empty address in circumstances where that is
227   permitted. */
228
229   if (pdomain == 0 && (*newparsed != 0 ||
230       (flag != rewrite_envfrom && flag != (rewrite_smtp|rewrite_smtp_sender))))
231     {
232     if (rule->flags & rewrite_qualify)
233       {
234       newparsed = rewrite_address_qualify(newparsed, TRUE);
235       new = string_sprintf("%.*s%s%.*s", start, new, newparsed,
236         Ustrlen(new) - end, new + end);
237       end = start + Ustrlen(newparsed);
238       }
239     else
240       {
241       log_write(0, LOG_MAIN|LOG_PANIC, "Rewrite of %s yielded unqualified "
242         "address \"%s\"", subject, new);
243       break;   /* Give up on this address */
244       }
245     }
246
247   /* We have a validly rewritten address */
248
249   if (LOGGING(address_rewrite) || (debug_selector & D_rewrite) != 0)
250     {
251     const uschar *where = CUS"?";
252
253     for (int i = 0; i < where_list_size; i++)
254       if (flag == where_list[i].bit)
255         {
256         where = where_list[i].string;
257         break;
258         }
259     log_write(L_address_rewrite,
260            LOG_MAIN, "\"%s\" from %s rewritten as \"%s\" by rule %d",
261            yield, where, new, rule_number);
262     }
263
264   /* A header will only actually be added if header_last is non-NULL,
265   i.e. during message reception or delivery, but add_header should not
266   be set TRUE during delivery, as otherwise multiple instances of the header
267   can fill up the -H file and make it embarrassingly large. We don't need
268   to set header_rewritten because the -H file always gets written at the end
269   of message reception. */
270
271   if (add_header)
272     header_add(htype_old, "X-rewrote-%s: %s\n", name, subject);
273
274   /* Handle the case when replacement of the whole address is possible.
275   This happens only when whole is not NULL and we are rewriting a header.
276   If *whole is already TRUE it means that a previous rule had the w
277   flag set and so we must preserve the non-active portion of the current
278   subject unless the current rule also has the w flag set. */
279
280   if (whole && (flag & rewrite_all_headers))
281     {
282     /* Current rule has the w flag set. We must ensure the phrase parts
283     are syntactically valid if they are present. */
284
285     if (rule->flags & rewrite_whole)
286       {
287       if (start > 0 && new[start-1] == '<')
288         {
289         uschar *p1 = new + start - 1;
290         uschar *p2 = new + end + 1;
291         const uschar *pf1, *pf2;
292
293         while (p1 > new && p1[-1] == ' ') p1--;
294         pf1 = parse_fix_phrase(new, p1 - new);
295         while (*p2 == ' ') p2++;
296         pf2 = parse_fix_phrase(p2, Ustrlen(p2));
297
298         start = Ustrlen(pf1) + start + new - p1;
299         end = start + Ustrlen(newparsed);
300         new = string_sprintf("%s%.*s%s", pf1, (int)(p2 - p1), p1, pf2);
301         }
302
303       /* Now accept the whole thing */
304
305       yield = new;
306       yield_start = start;
307       yield_end = end;
308       subject = newparsed;
309       *whole = TRUE;
310       }
311
312     /* Current rule does not have the w flag set; if not previously
313     done any whole rewriting, behave in non-whole manner. */
314
315     else if (!*whole) goto NEVER_WHOLE;
316
317     /* Current rule does not have the w flag set, but a previous
318     rule did rewrite the whole address. Thus yield and subject will be
319     different. Preserve the previous non-active part of the address. */
320
321     else
322       {
323       subject = newparsed;
324       new = string_sprintf("%.*s%s%n%s",
325          yield_start, yield, subject, &end, yield + yield_end);
326       yield_end = end;
327       yield = new;
328       }
329     }
330
331   /* Rule just rewrites active part, or handling an envelope. This
332   code is obeyed only when all rules so far have not done "whole"
333   replacement. */
334
335   else
336     {
337     NEVER_WHOLE:
338     subject = yield = newparsed;
339     }
340
341   domain = NULL;    /* Reset for next rule */
342
343   /* If no further rewrites are to be done, set the done flag. This allows
344   repeats of the current rule if configured before breaking the loop. */
345
346   if (rule->flags & rewrite_quit) done = TRUE;
347
348   /* Allow the current rule to be applied up to 10 times if
349   requested. */
350
351   if (rule->flags & rewrite_repeat)
352     {
353     if (count++ < 10) goto REPEAT_RULE;
354     log_write(0, LOG_MAIN|LOG_PANIC, "rewrite rule repeat ignored after 10 "
355       "times");
356     }
357   }
358
359 /* Unset expansion numeric variables, and that's it. */
360
361 expand_nmax = -1;
362 return yield;
363 }
364
365
366
367 /*************************************************
368 *         Ensure qualification and rewrite       *
369 *************************************************/
370
371 /* This function is called for envelope addresses, the boolean specifying
372 whether a recipient or a sender. It must first of all ensure the address is
373 fully qualified, and then apply any relevant re-writing rules. The add-header
374 flag causes a header to be added, recording the old address. This is marked
375 "old", so that it is never transported anywhere; it exists for local checking
376 and debugging purposes.
377
378 Arguments:
379   s              the address to be considered
380   is_recipient   TRUE for recipient addresses; FALSE otherwise
381   add_header     add "X-rewrote-xxx" header when rewriting; this is
382                    set TRUE only for calls from the reception functions
383   rewrite_rules  points to chain of rewrite rules
384   existflags     bits indicating which headers there are rewrites for
385                  (just an optimisation)
386
387 Returns:         possibly rewritten address
388 */
389
390 const uschar *
391 rewrite_address(const uschar *s, BOOL is_recipient, BOOL add_header,
392   rewrite_rule *rewrite_rules, int existflags)
393 {
394 int flag = is_recipient ? rewrite_envto : rewrite_envfrom;
395
396 s = rewrite_address_qualify(s, is_recipient);
397 if (existflags & flag)
398   {
399   const uschar *new = rewrite_one(s, flag, NULL, add_header, is_recipient?
400     US"original-recipient" : US"sender", rewrite_rules);
401   if (new != s) s = new;
402   }
403 return s;
404 }
405
406
407
408 /*************************************************
409 *    Qualify and possibly rewrite one header     *
410 *************************************************/
411
412 /* This is called only from rewrite_header() below, either when reading a
413 message. or when routing, in order to rewrite addresses that get changed by a
414 router. This is normally the addition of full qualification to a partial
415 domain. The first rewriting rule in this case is "change routed_old into
416 routed_new", and it applies to all header lines that contain addresses. Then
417 header-specific rewriting rules are applied.
418
419 Before rewriting can be done, addresses without domains have to be qualified.
420 This should only be done for messages from "local" senders. This is a difficult
421 concept to pin down, what with the use of SMTP both as a submission and as a
422 transmission protocol. Exim normally requires incoming SMTP to contain fully-
423 qualified addresses, but there are options to permit unqualified ones from
424 certain hosts. For those hosts only, addresses in headers can also be
425 qualified. For other hosts, unqualified addresses in headers do not get touched
426 in any way. For locally sourced messages, unqualified addresses always get
427 qualified, except when -bnq is used to explicitly suppress this.
428
429 Arguments:
430   h              pointer to header line block
431   flag           indicates which header this is
432   routed_old     if not NULL, this is a rewrite caused by a router, changing
433                    this domain into routed_new
434   routed_new     new routed domain if routed_old is not NULL
435   rewrite_rules  points to chain of rewriting rules
436   existflags     bits indicating which rewrites exist
437   replace        if TRUE, insert the new header in the chain after the old
438                    one, and mark the old one "replaced"
439
440 Returns:         NULL if header unchanged; otherwise the rewritten header
441 */
442
443 static header_line *
444 rewrite_one_header(header_line *h, int flag,
445   const uschar *routed_old, const uschar *routed_new,
446   rewrite_rule *rewrite_rules, int existflags, BOOL replace)
447 {
448 int lastnewline = 0;
449 header_line *newh = NULL;
450 rmark function_reset_point = store_mark();
451 uschar *s = Ustrchr(h->text, ':') + 1;
452
453 while (isspace(*s)) s++;
454
455 DEBUG(D_rewrite)
456   debug_printf("rewrite_one_header: type=%c:\n  %s", h->type, h->text);
457
458 f.parse_allow_group = TRUE;     /* Allow group syntax */
459
460 /* Loop for multiple addresses in the header. We have to go through them all
461 in case any need qualifying, even if there's no rewriting. Pathological headers
462 may have thousands of addresses in them, so cause the store to be reset for
463 any that don't actually get rewritten. We also play silly games for those that
464 _are_ rewritten so as to avoid runaway store usage for these kinds of header.
465 We want to avoid keeping store for any intermediate versions. */
466
467 while (*s)
468   {
469   uschar *sprev;
470   uschar *ss = parse_find_address_end(s, FALSE);
471   uschar *recipient, *new, *errmess;
472   rmark loop_reset_point = store_mark();
473   BOOL changed = FALSE;
474   int terminator = *ss;
475   int start, end, domain;
476
477   /* Temporarily terminate the string at this point, and extract the
478   operative address within. Then put back the terminator and prepare for
479   the next address, saving the start of the old one. */
480
481   *ss = 0;
482   recipient = parse_extract_address(s, &errmess, &start, &end, &domain, FALSE);
483   *ss = terminator;
484   sprev = s;
485   s = ss + (terminator ? 1 :0);
486   while (isspace(*s)) s++;
487
488   /* There isn't much we can do for syntactic disasters at this stage.
489   Pro tem (possibly for ever) ignore them. */
490
491   if (!recipient)
492     {
493     loop_reset_point = store_reset(loop_reset_point);
494     continue;
495     }
496
497   /* If routed_old is not NULL, this is a rewrite caused by a router,
498   consisting of changing routed_old into routed_new, and applying to all
499   headers. If the header address has no domain, it is excluded, since a router
500   rewrite affects domains only. The new value should always be fully qualified,
501   but it may be something that has an explicit re-write rule set, so we need to
502   check the configured rules subsequently as well. (Example: there's an
503   explicit rewrite turning *.foo.com into foo.com, and an address is supplied
504   as abc@xyz, which the DNS lookup turns into abc@xyz.foo.com). However, if no
505   change is made here, don't bother carrying on. */
506
507   if (routed_old)
508     {
509     if (domain <= 0 || strcmpic(recipient+domain, routed_old) != 0) continue;
510     recipient[domain-1] = 0;
511     new = string_sprintf("%s@%s", recipient, routed_new);
512     DEBUG(D_rewrite)
513       {
514       recipient[domain-1] = '@';
515       debug_printf("%s rewritten by router as %s\n", recipient, new);
516       }
517     recipient = new;
518     changed = TRUE;
519     }
520
521   /* This is not a router-inspired rewrite. Ensure the address is fully
522   qualified if that is permitted. If an unqualified address was received
523   from a host that isn't listed, do not continue rewriting this address.
524   Sender, From or Reply-To headers are treated as senders, the rest as
525   recipients. This matters only when there are different qualify strings. */
526
527   else
528     {
529     BOOL is_recipient =
530       (flag & (rewrite_sender | rewrite_from | rewrite_replyto)) == 0;
531     /* deconst ok as recipient was notconst */
532     new = US rewrite_address_qualify(recipient, is_recipient);
533     changed = (new != recipient);
534     recipient = new;
535
536     /* Can only qualify if permitted; if not, no rewrite. */
537
538     if (changed && ((is_recipient && !f.allow_unqualified_recipient) ||
539                     (!is_recipient && !f.allow_unqualified_sender)))
540       {
541       loop_reset_point = store_reset(loop_reset_point);
542       continue;
543       }
544     }
545
546   /* If there are rewrite rules for this type of header, apply
547   them. This test is just for efficiency, to save scanning the rules
548   in cases when nothing is going to change. If any rewrite rule had the
549   "whole" flag set, adjust the pointers so that the whole address gets
550   replaced, except possibly a final \n. */
551
552   if (existflags & flag)
553     {
554     BOOL whole;
555     /* deconst ok as recipient was notconst */
556     new = US rewrite_one(recipient, flag, &whole, FALSE, NULL, rewrite_rules);
557     if (new != recipient)
558       {
559       changed = TRUE;
560       if (whole)
561         {
562         start = 0;
563         end = ss - sprev;
564         if (sprev[end-1] == '\n') end--;
565         }
566       }
567     }
568
569   /* If nothing has changed, lose all dynamic store obtained in this loop, and
570   move on to the next address. We can't reset to the function start store
571   point, because we may have a rewritten line from a previous time round the
572   loop. */
573
574   if (!changed) loop_reset_point = store_reset(loop_reset_point);
575
576   /* If the address has changed, create a new header containing the
577   rewritten address. We do not need to set the chain pointers at this
578   stage. We want to avoid using more and more memory if the header is very long
579   and contains lots and lots of rewritten addresses. Therefore, we build the
580   new text string in malloc store, then at the end we reset dynamic store
581   before copying the new header to a new block (and then freeing the malloc
582   block). The header must end up in dynamic store so that it's freed at the end
583   of receiving a message. */
584
585   else
586     {
587     int remlen;
588     int newlen = Ustrlen(new);
589     int oldlen = end - start;
590
591     header_line * prev = newh ? newh : h;
592     uschar * newt = store_get_perm(prev->slen - oldlen + newlen + 4, TRUE);
593     uschar * newtstart = newt;
594
595     int type = prev->type;
596     int slen = prev->slen - oldlen + newlen;
597
598     /* Build the new header text by copying the old and putting in the
599     replacement. This process may make the header substantially longer
600     than it was before - qualification of a list of bare addresses can
601     often do this - so we stick in a newline after the re-written address
602     if it has increased in length and ends more than 40 characters in. In
603     fact, the code is not perfect, since it does not scan for existing
604     newlines in the header, but it doesn't seem worth going to that
605     amount of trouble. */
606
607     Ustrncpy(newt, prev->text, sprev - prev->text + start);
608     newt += sprev - prev->text + start;
609     *newt = 0;
610     Ustrcat(newt, new);
611     newt += newlen;
612     remlen = s - (sprev + end);
613     if (remlen > 0)
614       {
615       Ustrncpy(newt, sprev + end, remlen);
616       newt += remlen;
617       *newt = 0;
618       }
619
620     /* Must check that there isn't a newline here anyway; in particular, there
621     will be one at the very end of the header, where we DON'T want to insert
622     another one! The pointer s has been skipped over white space, so just
623     look back to see if the last non-space-or-tab was a newline. */
624
625     if (newlen > oldlen && newt - newtstart - lastnewline > 40)
626       {
627       uschar *p = s - 1;
628       while (p >= prev->text && (*p == ' ' || *p == '\t')) p--;
629       if (*p != '\n')
630         {
631         lastnewline = newt - newtstart;
632         Ustrcat(newt, US"\n\t");
633         slen += 2;
634         }
635       }
636
637     /* Finally, the remaining unprocessed addresses, if any. */
638
639     Ustrcat(newt, s);
640
641     DEBUG(D_rewrite) debug_printf("newlen=%d newtype=%c newtext:\n%s",
642       slen, type, newtstart);
643
644     /* Compute the length of the rest of the header line before we possibly
645     flatten a previously rewritten copy. */
646
647     remlen = (s - prev->text) - oldlen + newlen;
648
649     /* We have the new text in a malloc block. That enables us to release all
650     the memory that has been used, back to the point at which the function was
651     entered. Then set up a new header in dynamic store. This will override a
652     rewritten copy from a previous time round this loop. */
653
654     store_reset(function_reset_point);
655     function_reset_point = store_mark();
656     newh = store_get(sizeof(header_line), FALSE);
657     newh->type = type;
658     newh->slen = slen;
659     newh->text = string_copyn(newtstart, slen);
660
661     /* Set up for scanning the rest of the header */
662
663     s = newh->text + remlen;
664     DEBUG(D_rewrite) debug_printf("remainder: %s", *s ? s : US"\n");
665     }
666   }
667
668 f.parse_allow_group = FALSE;  /* Reset group flags */
669 f.parse_found_group = FALSE;
670
671 /* If a rewrite happened and "replace" is true, put the new header into the
672 chain following the old one, and mark the old one as replaced. */
673
674 if (newh && replace)
675   {
676   newh->next = h->next;
677   if (!newh->next) header_last = newh;
678   h->type = htype_old;
679   h->next = newh;
680   }
681
682 return newh;
683 }
684
685
686
687
688 /*************************************************
689 *              Rewrite a header line             *
690 *************************************************/
691
692 /* This function may be passed any old header line. It must detect those which
693 contain addresses, then then apply any rewriting rules that apply. If
694 routed_old is NULL, only the configured rewriting rules are consulted.
695 Otherwise, the rewriting rule is "change routed_old into routed_new", and it
696 applies to all header lines that contain addresses. Then header-specific
697 rewriting rules are applied.
698
699 The old header line is flagged as "old". Old headers are saved on the spool for
700 debugging but are never sent to any recipients.
701
702 Arguments:
703   h              header line to rewrite
704   routed_old     if not NULL, this is a rewrite caused by a router, changing
705                    this domain into routed_new
706   routed_new     new routed domain if routed_old is not NULL
707   rewrite_rules  points to chain of rewrite rules
708   existflags     bits indicating which rewrites exist
709   replace        if TRUE, the new header is inserted into the header chain
710                     after the old one, and the old one is marked replaced
711
712 Returns:         NULL if header unchanged; otherwise the rewritten header
713 */
714
715 header_line *
716 rewrite_header(header_line *h,
717   const uschar *routed_old, const uschar *routed_new,
718   rewrite_rule *rewrite_rules, int existflags, BOOL replace)
719 {
720 int flag;
721 switch (h->type)
722   {
723   case htype_sender:    flag = rewrite_sender;  break;
724   case htype_from:      flag = rewrite_from;    break;
725   case htype_to:        flag = rewrite_to;      break;
726   case htype_cc:        flag = rewrite_cc;      break;
727   case htype_bcc:       flag = rewrite_bcc;     break;
728   case htype_reply_to:  flag = rewrite_replyto; break;
729   default:              return NULL;
730   }
731 return rewrite_one_header(h, flag, routed_old, routed_new,
732   rewrite_rules, existflags, replace);
733 }
734
735
736
737 /************************************************
738 *            Test rewriting rules               *
739 ************************************************/
740
741 /* Called from the mainline as a result of the -brw option. Test the
742 address for all possible cases.
743
744 Argument: the address to test
745 Returns:  nothing
746 */
747
748 void
749 rewrite_test(const uschar *s)
750 {
751 uschar *recipient, *error;
752 int start, end, domain;
753 BOOL done_smtp = FALSE;
754
755 if (rewrite_existflags == 0)
756   {
757   printf("No rewrite rules are defined\n");
758   return;
759   }
760
761 /* Do SMTP rewrite only if a rule with the S flag exists. Allow <> by
762 pretending it is a sender. */
763
764 if ((rewrite_existflags & rewrite_smtp) != 0)
765   {
766   const uschar * new = rewrite_one(s, rewrite_smtp|rewrite_smtp_sender, NULL,
767     FALSE, US"", global_rewrite_rules);
768   if (new != s)
769     {
770     if (*new == 0)
771       printf("    SMTP: <>\n");
772     else
773       printf("    SMTP: %s\n", new);
774     done_smtp = TRUE;
775     }
776   }
777
778 /* Do the other rewrites only if a rule without the S flag exists */
779
780 if ((rewrite_existflags & ~rewrite_smtp) == 0) return;
781
782 /* Qualify if necessary before extracting the address */
783
784 if (parse_find_at(s) == NULL)
785   s = string_sprintf("%s@%s", s, qualify_domain_recipient);
786
787 recipient = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
788
789 if (!recipient)
790   {
791   if (!done_smtp)
792     printf("Syntax error in %s\n%c%s\n", s, toupper(error[0]), error+1);
793   return;
794   }
795
796 for (int i = 0; i < 8; i++)
797   {
798   BOOL whole = FALSE;
799   int flag = 1 << i;
800   const uschar * new = rewrite_one(recipient, flag, &whole, FALSE, US"",
801     global_rewrite_rules);
802   printf("%s: ", rrname[i]);
803   if (*new == 0)
804     printf("<>\n");
805   else if (whole || (flag & rewrite_all_headers) == 0)
806     printf("%s\n", CS new);
807   else printf("%.*s%s%s\n", start, s, new, s+end);
808   }
809 }
810
811 /* End of rewrite.c */