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