src/src/rewrite.c

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