src/src/rewrite.c

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