src/src/header.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2016 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8
   9 #include "exim.h"
  10
  11
  12 /*************************************************
  13 *         Test a header for matching name        *
  14 *************************************************/
  15
  16 /* This function tests the name of a header. It is made into a function because
  17 it isn't just a string comparison: spaces and tabs are permitted between the
  18 name and the colon. The h->text field should nowadays never be NULL, but check
  19 it just in case.
  20
  21 Arguments:
  22   h         points to the header
  23   name      the name to test
  24   len       the length of the name
  25   notdel    if TRUE, force FALSE for deleted headers
  26
  27 Returns:    TRUE or FALSE
  28 */
  29
  30 BOOL
  31 header_testname(header_line *h, const uschar *name, int len, BOOL notdel)
  32 {
  33 uschar *tt;
  34 if (h->type == '*' && notdel) return FALSE;
  35 if (h->text == NULL || strncmpic(h->text, name, len) != 0) return FALSE;
  36 tt = h->text + len;
  37 while (*tt == ' ' || *tt == '\t') tt++;
  38 return *tt == ':';
  39 }
  40
  41 /* This is a copy of the function above, only that it is possible to pass
  42    only the beginning of a header name. It simply does a front-anchored
  43    substring match. Arguments and Return codes are the same as for
  44    header_testname() above. */
  45
  46 BOOL
  47 header_testname_incomplete(header_line *h, const uschar *name,
  48     int len, BOOL notdel)
  49 {
  50 if (h->type == '*' && notdel) return FALSE;
  51 if (h->text == NULL || strncmpic(h->text, name, len) != 0) return FALSE;
  52 return TRUE;
  53 }
  54
  55
  56 /*************************************************
  57 *         Add new header backend function        *
  58 *************************************************/
  59
  60 /* The header_last variable points to the last header during message reception
  61 and delivery; otherwise it is NULL. We add new headers only when header_last is
  62 not NULL. The function may get called sometimes when it is NULL (e.g. during
  63 address verification where rewriting options exist). When called from a filter,
  64 there may be multiple header lines in a single string.
  65
  66 This is an internal static function that is the common back end to the external
  67 functions defined below. The general interface allows the header to be inserted
  68 before or after a given occurrence of a given header.
  69
  70 (a) if "name" is NULL, the header is added at the end of all the existing
  71     headers if "after" is true, or at the start if it is false. The "topnot"
  72     flag is not used.
  73
  74 (b) If "name" is not NULL, the first existing header with that name is sought.
  75     If "after" is false, the new header is added before it. If "after" is true,
  76     a check is made for adjacent headers with the same name, and the new header
  77     is added after the last of them. If a header of the given name is not
  78     found, the new header is added first if "topnot" is true, and at the bottom
  79     otherwise.
  80
  81 Arguments:
  82   after     TRUE for "after", FALSE for "before"
  83   name      name if adding at a specific header, else NULL
  84   topnot    TRUE to add at top if no header found
  85   type      Exim header type character (htype_something)
  86   format    sprintf format
  87   ap        va_list value for format arguments
  88
  89 Returns:    pointer to header struct (last one, if multiple added)
  90 */
  91
  92 static header_line *
  93 header_add_backend(BOOL after, uschar *name, BOOL topnot, int type,
  94   const char *format, va_list ap)
  95 {
  96 header_line *h, *new = NULL;
  97 header_line **hptr;
  98
  99 uschar *p, *q;
 100 uschar * buf = store_get(HEADER_ADD_BUFFER_SIZE, FALSE);
 101 gstring gs = { .size = HEADER_ADD_BUFFER_SIZE, .ptr = 0, .s = buf };
 102
 103 if (!header_last) return NULL;
 104
 105 if (!string_vformat(&gs, SVFMT_REBUFFER, format, ap))
 106   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string too long in header_add: "
 107     "%.100s ...", string_from_gstring(&gs));
 108
 109 if (gs.s != buf) store_release_above(buf);
 110 gstring_release_unused(&gs);
 111 string_from_gstring(&gs);
 112
 113 /* Find where to insert this header */
 114
 115 if (!name)
 116   if (after)
 117     {
 118     hptr = &header_last->next;
 119     h = NULL;
 120     }
 121   else
 122     {
 123     hptr = &header_list;
 124
 125     /* header_list->text can be NULL if we get here between when the new
 126     received header is allocated and when it is actually filled in. We want
 127     that header to be first, so skip it for now. */
 128
 129     if (!header_list->text)
 130       hptr = &header_list->next;
 131     h = *hptr;
 132     }
 133
 134 else
 135   {
 136   int len = Ustrlen(name);
 137
 138   /* Find the first non-deleted header with the correct name. */
 139
 140   for (hptr = &header_list; (h = *hptr); hptr = &h->next)
 141     if (header_testname(h, name, len, TRUE))
 142       break;
 143
 144   /* Handle the case where no header is found. To insert at the bottom, nothing
 145   needs to be done. */
 146
 147   if (!h)
 148     {
 149     if (topnot)
 150       {
 151       hptr = &header_list;
 152       h = header_list;
 153       }
 154     }
 155
 156   /* Handle the case where a header is found. Check for more if "after" is
 157   true. In this case, we want to include deleted headers in the block. */
 158
 159   else if (after)
 160     for (;;)
 161       {
 162       if (!h->next || !header_testname(h, name, len, FALSE)) break;
 163       hptr = &h->next;
 164       h = h->next;
 165       }
 166   }
 167
 168 /* Loop for multiple header lines, taking care about continuations. At this
 169 point, we have hptr pointing to the link field that will point to the new
 170 header, and h containing the following header, or NULL. */
 171
 172 for (p = q = gs.s; *p; p = q)
 173   {
 174   for (;;)
 175     {
 176     q = Ustrchr(q, '\n');
 177     if (!q) q = p + Ustrlen(p);
 178     if (*(++q) != ' ' && *q != '\t') break;
 179     }
 180
 181   new = store_get(sizeof(header_line), FALSE);
 182   new->text = string_copyn(p, q - p);
 183   new->slen = q - p;
 184   new->type = type;
 185   new->next = h;
 186
 187   *hptr = new;
 188   hptr = &new->next;
 189
 190   if (!h) header_last = new;
 191   }
 192 return new;
 193 }
 194
 195
 196 /*************************************************
 197 *      Add new header anywhere in the chain      *
 198 *************************************************/
 199
 200 /* This is an external interface to header_add_backend().
 201
 202 Arguments:
 203   after     TRUE for "after", FALSE for "before"
 204   name      name if adding at a specific header, else NULL
 205   topnot    TRUE to add at top if no header found
 206   type      Exim header type character (htype_something)
 207   format    sprintf format
 208   ...       format arguments
 209
 210 Returns:    pointer to header struct added
 211 */
 212
 213 header_line *
 214 header_add_at_position_internal(BOOL after, uschar *name, BOOL topnot, int type,
 215   const char *format, ...)
 216 {
 217 header_line * h;
 218 va_list ap;
 219 va_start(ap, format);
 220 h = header_add_backend(after, name, topnot, type, format, ap);
 221 va_end(ap);
 222 return h;
 223 }
 224
 225
 226 /* Documented external i/f for local_scan */
 227 void
 228 header_add_at_position(BOOL after, uschar *name, BOOL topnot, int type,
 229   const char *format, ...)
 230 {
 231 va_list ap;
 232 va_start(ap, format);
 233 (void) header_add_backend(after, name, topnot, type, format, ap);
 234 va_end(ap);
 235 }
 236
 237 /*************************************************
 238 *            Add new header on end of chain      *
 239 *************************************************/
 240
 241 /* This is now a convenience interface to header_add_backend().
 242
 243 Arguments:
 244   type      Exim header type character
 245   format    sprintf format
 246   ...       arguments for the format
 247
 248 Returns:    nothing
 249 */
 250
 251 void
 252 header_add(int type, const char *format, ...)
 253 {
 254 va_list ap;
 255 va_start(ap, format);
 256 (void) header_add_backend(TRUE, NULL, FALSE, type, format, ap);
 257 va_end(ap);
 258 }
 259
 260
 261
 262 /*************************************************
 263 *        Remove (mark as old) a header           *
 264 *************************************************/
 265
 266 /* This function is used by the filter code; it is also exported in the
 267 local_scan() API. If no header is found, the function does nothing.
 268
 269 Arguments:
 270   occ           the occurrence number for multiply-defined headers
 271                   <= 0 means "all"; deleted headers are not counted
 272   name          the header name
 273
 274 Returns:        nothing
 275 */
 276
 277 void
 278 header_remove(int occ, const uschar *name)
 279 {
 280 int hcount = 0;
 281 int len = Ustrlen(name);
 282 for (header_line * h = header_list; h; h = h->next)
 283   if (header_testname(h, name, len, TRUE) && (occ <= 0 || ++hcount == occ))
 284     {
 285     h->type = htype_old;
 286     if (occ > 0) return;
 287     }
 288 }
 289
 290
 291
 292 /*************************************************
 293 *          Check the name of a header            *
 294 *************************************************/
 295
 296 /* This function scans a table of header field names that Exim recognizes, and
 297 returns the identification of a match. If "resent" is true, the header is known
 298 to start with "resent-". In that case, the function matches only those fields
 299 that are allowed to appear with resent- in front of them.
 300
 301 Arguments:
 302   h             points to the header line
 303   is_resent     TRUE if the name starts "Resent-"
 304
 305 Returns:        One of the htype_ enum values, identifying the header
 306 */
 307
 308 int
 309 header_checkname(header_line *h, BOOL is_resent)
 310 {
 311 uschar *text = h->text;
 312 header_name *bot = header_names;
 313 header_name *top = header_names + header_names_size;
 314
 315 if (is_resent) text += 7;
 316
 317 while (bot < top)
 318   {
 319   header_name *mid = bot + (top - bot)/2;
 320   int c = strncmpic(text, mid->name, mid->len);
 321
 322   if (c == 0)
 323     {
 324     uschar *s = text + mid->len;
 325     while (isspace(*s)) s++;
 326     if (*s == ':')
 327       return (!is_resent || mid->allow_resent)? mid->htype : htype_other;
 328     c = 1;
 329     }
 330
 331   if (c > 0) bot = mid + 1; else top = mid;
 332   }
 333
 334 return htype_other;
 335 }
 336
 337
 338 /*************************************************
 339 *       Scan a header for certain strings        *
 340 *************************************************/
 341
 342 /* This function is used for the "personal" test. It scans a particular header
 343 line for any one of a number of strings, matched caselessly either as plain
 344 strings, or as regular expressions. If the header line contains a list of
 345 addresses, each match is applied only to the operative part of each address in
 346 the header, and non-regular expressions must be exact matches.
 347
 348 The patterns can be provided either as a chain of string_item structures, or
 349 inline in the argument list, or both. If there is more than one header of the
 350 same name, they are all searched.
 351
 352 Arguments:
 353   name           header name, including the trailing colon
 354   has_addresses  TRUE if the header contains a list of addresses
 355   cond           value to return if the header contains any of the strings
 356   strings        points to a chain of string_item blocks
 357   count          number of inline strings
 358   ...            the inline strings
 359
 360 Returns:         cond if the header exists and contains one of the strings;
 361                    otherwise !cond
 362 */
 363
 364
 365 /* First we have a local subroutine to handle a single pattern */
 366
 367 static BOOL
 368 one_pattern_match(uschar *name, int slen, BOOL has_addresses, uschar *pattern)
 369 {
 370 BOOL yield = FALSE;
 371 const pcre *re = NULL;
 372
 373 /* If the pattern is a regex, compile it. Bomb out if compiling fails; these
 374 patterns are all constructed internally and should be valid. */
 375
 376 if (*pattern == '^') re = regex_must_compile(pattern, TRUE, FALSE);
 377
 378 /* Scan for the required header(s) and scan each one */
 379
 380 for (header_line * h = header_list; !yield && h; h = h->next)
 381   {
 382   if (h->type == htype_old || slen > h->slen ||
 383       strncmpic(name, h->text, slen) != 0)
 384     continue;
 385
 386   /* If the header is a list of addresses, extract each one in turn, and scan
 387   it. A non-regex scan must be an exact match for the address. */
 388
 389   if (has_addresses)
 390     {
 391     uschar *s = h->text + slen;
 392
 393     while (!yield && *s)
 394       {
 395       uschar *error, *next;
 396       uschar *e = parse_find_address_end(s, FALSE);
 397       int terminator = *e;
 398       int start, end, domain;
 399
 400       /* Temporarily terminate the string at the address end while extracting
 401       the operative address within. */
 402
 403       *e = 0;
 404       next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
 405       *e = terminator;
 406
 407       /* Move on, ready for the next address */
 408
 409       s = e;
 410       if (*s == ',') s++;
 411
 412       /* If there is some kind of syntax error, just give up on this header
 413       line. */
 414
 415       if (next == NULL) break;
 416
 417       /* Otherwise, test for the pattern; a non-regex must be an exact match */
 418
 419       yield = (re == NULL)?
 420         (strcmpic(next, pattern) == 0)
 421         :
 422         (pcre_exec(re, NULL, CS next, Ustrlen(next), 0, PCRE_EOPT, NULL, 0)
 423           >= 0);
 424       }
 425     }
 426
 427   /* For headers that are not lists of addresses, scan the entire header line,
 428   and just require "contains" for non-regex patterns. */
 429
 430   else
 431     {
 432     yield = (re == NULL)?
 433       (strstric(h->text, pattern, FALSE) != NULL)
 434       :
 435       (pcre_exec(re, NULL, CS h->text, h->slen, 0, PCRE_EOPT, NULL, 0) >= 0);
 436     }
 437   }
 438
 439 return yield;
 440 }
 441
 442
 443 /* The externally visible interface */
 444
 445 BOOL
 446 header_match(uschar *name, BOOL has_addresses, BOOL cond, string_item *strings,
 447   int count, ...)
 448 {
 449 va_list ap;
 450 int slen = Ustrlen(name);
 451
 452 for (string_item * s = strings; s; s = s->next)
 453   if (one_pattern_match(name, slen, has_addresses, s->text))
 454     return cond;
 455
 456 va_start(ap, count);
 457 for (int i = 0; i < count; i++)
 458   if (one_pattern_match(name, slen, has_addresses, va_arg(ap, uschar *)))
 459     {
 460     va_end(ap);
 461     return cond;
 462     }
 463 va_end(ap);
 464
 465 return !cond;
 466 }
 467
 468 /* End of header.c */