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;
  97 header_line **hptr;
  98
  99 uschar *p, *q;
 100 uschar buffer[HEADER_ADD_BUFFER_SIZE];
 101 gstring gs = { .size = HEADER_ADD_BUFFER_SIZE, .ptr = 0, .s = buffer };
 102
 103 if (!header_last) return NULL;
 104
 105 if (!string_vformat(&gs, FALSE, format, ap))
 106   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string too long in header_add: "
 107     "%.100s ...", string_from_gstring(&gs));
 108 string_from_gstring(&gs);
 109
 110 /* Find where to insert this header */
 111
 112 if (!name)
 113   {
 114   if (after)
 115     {
 116     hptr = &(header_last->next);
 117     h = NULL;
 118     }
 119   else
 120     {
 121     hptr = &header_list;
 122
 123     /* header_list->text can be NULL if we get here between when the new
 124     received header is allocated and when it is actually filled in. We want
 125     that header to be first, so skip it for now. */
 126
 127     if (!header_list->text)
 128       hptr = &header_list->next;
 129     h = *hptr;
 130     }
 131   }
 132
 133 else
 134   {
 135   int len = Ustrlen(name);
 136
 137   /* Find the first non-deleted header with the correct name. */
 138
 139   for (hptr = &header_list; (h = *hptr); hptr = &h->next)
 140     if (header_testname(h, name, len, TRUE))
 141       break;
 142
 143   /* Handle the case where no header is found. To insert at the bottom, nothing
 144   needs to be done. */
 145
 146   if (!h)
 147     {
 148     if (topnot)
 149       {
 150       hptr = &header_list;
 151       h = header_list;
 152       }
 153     }
 154
 155   /* Handle the case where a header is found. Check for more if "after" is
 156   true. In this case, we want to include deleted headers in the block. */
 157
 158   else if (after)
 159     for (;;)
 160       {
 161       if (!h->next || !header_testname(h, name, len, FALSE)) break;
 162       hptr = &(h->next);
 163       h = h->next;
 164       }
 165   }
 166
 167 /* Loop for multiple header lines, taking care about continuations. At this
 168 point, we have hptr pointing to the link field that will point to the new
 169 header, and h containing the following header, or NULL. */
 170
 171 for (p = q = buffer; *p != 0; )
 172   {
 173   for (;;)
 174     {
 175     q = Ustrchr(q, '\n');
 176     if (!q) q = p + Ustrlen(p);
 177     if (*(++q) != ' ' && *q != '\t') break;
 178     }
 179
 180   new = store_get(sizeof(header_line));
 181   new->text = string_copyn(p, q - p);
 182   new->slen = q - p;
 183   new->type = type;
 184   new->next = h;
 185
 186   *hptr = new;
 187   hptr = &(new->next);
 188
 189   if (!h) header_last = new;
 190   p = q;
 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 header_line * h;
 232 va_list ap;
 233 va_start(ap, format);
 234 (void) header_add_backend(after, name, topnot, type, format, ap);
 235 va_end(ap);
 236 }
 237
 238 /*************************************************
 239 *            Add new header on end of chain      *
 240 *************************************************/
 241
 242 /* This is now a convenience interface to header_add_backend().
 243
 244 Arguments:
 245   type      Exim header type character
 246   format    sprintf format
 247   ...       arguments for the format
 248
 249 Returns:    nothing
 250 */
 251
 252 void
 253 header_add(int type, const char *format, ...)
 254 {
 255 va_list ap;
 256 va_start(ap, format);
 257 (void) header_add_backend(TRUE, NULL, FALSE, type, format, ap);
 258 va_end(ap);
 259 }
 260
 261
 262
 263 /*************************************************
 264 *        Remove (mark as old) a header           *
 265 *************************************************/
 266
 267 /* This function is used by the filter code; it is also exported in the
 268 local_scan() API. If no header is found, the function does nothing.
 269
 270 Arguments:
 271   occ           the occurrence number for multiply-defined headers
 272                   <= 0 means "all"; deleted headers are not counted
 273   name          the header name
 274
 275 Returns:        nothing
 276 */
 277
 278 void
 279 header_remove(int occ, const uschar *name)
 280 {
 281 int hcount = 0;
 282 int len = Ustrlen(name);
 283 for (header_line * h = header_list; h; h = h->next)
 284   if (header_testname(h, name, len, TRUE) && (occ <= 0 || ++hcount == occ))
 285     {
 286     h->type = htype_old;
 287     if (occ > 0) return;
 288     }
 289 }
 290
 291
 292
 293 /*************************************************
 294 *          Check the name of a header            *
 295 *************************************************/
 296
 297 /* This function scans a table of header field names that Exim recognizes, and
 298 returns the identification of a match. If "resent" is true, the header is known
 299 to start with "resent-". In that case, the function matches only those fields
 300 that are allowed to appear with resent- in front of them.
 301
 302 Arguments:
 303   h             points to the header line
 304   is_resent     TRUE if the name starts "Resent-"
 305
 306 Returns:        One of the htype_ enum values, identifying the header
 307 */
 308
 309 int
 310 header_checkname(header_line *h, BOOL is_resent)
 311 {
 312 uschar *text = h->text;
 313 header_name *bot = header_names;
 314 header_name *top = header_names + header_names_size;
 315
 316 if (is_resent) text += 7;
 317
 318 while (bot < top)
 319   {
 320   header_name *mid = bot + (top - bot)/2;
 321   int c = strncmpic(text, mid->name, mid->len);
 322
 323   if (c == 0)
 324     {
 325     uschar *s = text + mid->len;
 326     while (isspace(*s)) s++;
 327     if (*s == ':')
 328       return (!is_resent || mid->allow_resent)? mid->htype : htype_other;
 329     c = 1;
 330     }
 331
 332   if (c > 0) bot = mid + 1; else top = mid;
 333   }
 334
 335 return htype_other;
 336 }
 337
 338
 339 /*************************************************
 340 *       Scan a header for certain strings        *
 341 *************************************************/
 342
 343 /* This function is used for the "personal" test. It scans a particular header
 344 line for any one of a number of strings, matched caselessly either as plain
 345 strings, or as regular expressions. If the header line contains a list of
 346 addresses, each match is applied only to the operative part of each address in
 347 the header, and non-regular expressions must be exact matches.
 348
 349 The patterns can be provided either as a chain of string_item structures, or
 350 inline in the argument list, or both. If there is more than one header of the
 351 same name, they are all searched.
 352
 353 Arguments:
 354   name           header name, including the trailing colon
 355   has_addresses  TRUE if the header contains a list of addresses
 356   cond           value to return if the header contains any of the strings
 357   strings        points to a chain of string_item blocks
 358   count          number of inline strings
 359   ...            the inline strings
 360
 361 Returns:         cond if the header exists and contains one of the strings;
 362                    otherwise !cond
 363 */
 364
 365
 366 /* First we have a local subroutine to handle a single pattern */
 367
 368 static BOOL
 369 one_pattern_match(uschar *name, int slen, BOOL has_addresses, uschar *pattern)
 370 {
 371 BOOL yield = FALSE;
 372 const pcre *re = NULL;
 373
 374 /* If the pattern is a regex, compile it. Bomb out if compiling fails; these
 375 patterns are all constructed internally and should be valid. */
 376
 377 if (*pattern == '^') re = regex_must_compile(pattern, TRUE, FALSE);
 378
 379 /* Scan for the required header(s) and scan each one */
 380
 381 for (header_line * h = header_list; !yield && h; h = h->next)
 382   {
 383   if (h->type == htype_old || slen > h->slen ||
 384       strncmpic(name, h->text, slen) != 0)
 385     continue;
 386
 387   /* If the header is a list of addresses, extract each one in turn, and scan
 388   it. A non-regex scan must be an exact match for the address. */
 389
 390   if (has_addresses)
 391     {
 392     uschar *s = h->text + slen;
 393
 394     while (!yield && *s)
 395       {
 396       uschar *error, *next;
 397       uschar *e = parse_find_address_end(s, FALSE);
 398       int terminator = *e;
 399       int start, end, domain;
 400
 401       /* Temporarily terminate the string at the address end while extracting
 402       the operative address within. */
 403
 404       *e = 0;
 405       next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
 406       *e = terminator;
 407
 408       /* Move on, ready for the next address */
 409
 410       s = e;
 411       if (*s == ',') s++;
 412
 413       /* If there is some kind of syntax error, just give up on this header
 414       line. */
 415
 416       if (next == NULL) break;
 417
 418       /* Otherwise, test for the pattern; a non-regex must be an exact match */
 419
 420       yield = (re == NULL)?
 421         (strcmpic(next, pattern) == 0)
 422         :
 423         (pcre_exec(re, NULL, CS next, Ustrlen(next), 0, PCRE_EOPT, NULL, 0)
 424           >= 0);
 425       }
 426     }
 427
 428   /* For headers that are not lists of addresses, scan the entire header line,
 429   and just require "contains" for non-regex patterns. */
 430
 431   else
 432     {
 433     yield = (re == NULL)?
 434       (strstric(h->text, pattern, FALSE) != NULL)
 435       :
 436       (pcre_exec(re, NULL, CS h->text, h->slen, 0, PCRE_EOPT, NULL, 0) >= 0);
 437     }
 438   }
 439
 440 return yield;
 441 }
 442
 443
 444 /* The externally visible interface */
 445
 446 BOOL
 447 header_match(uschar *name, BOOL has_addresses, BOOL cond, string_item *strings,
 448   int count, ...)
 449 {
 450 va_list ap;
 451 int slen = Ustrlen(name);
 452
 453 for (string_item * s = strings; s; s = s->next)
 454   if (one_pattern_match(name, slen, has_addresses, s->text))
 455     return cond;
 456
 457 va_start(ap, count);
 458 for (int i = 0; i < count; i++)
 459   if (one_pattern_match(name, slen, has_addresses, va_arg(ap, uschar *)))
 460     {
 461     va_end(ap);
 462     return cond;
 463     }
 464 va_end(ap);
 465
 466 return !cond;
 467 }
 468
 469 /* End of header.c */