1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* Copyright (c) The Exim Maintainers 2020 */
7 /* See the file NOTICE for conditions of use and distribution. */
13 /*************************************************
14 * Test a header for matching name *
15 *************************************************/
17 /* This function tests the name of a header. It is made into a function because
18 it isn't just a string comparison: spaces and tabs are permitted between the
19 name and the colon. The h->text field should nowadays never be NULL, but check
23 h points to the header
25 len the length of the name
26 notdel if TRUE, force FALSE for deleted headers
28 Returns: TRUE or FALSE
32 header_testname(header_line *h, const uschar *name, int len, BOOL notdel)
35 if (h->type == '*' && notdel) return FALSE;
36 if (h->text == NULL || strncmpic(h->text, name, len) != 0) return FALSE;
38 while (*tt == ' ' || *tt == '\t') tt++;
42 /* This is a copy of the function above, only that it is possible to pass
43 only the beginning of a header name. It simply does a front-anchored
44 substring match. Arguments and Return codes are the same as for
45 header_testname() above. */
48 header_testname_incomplete(header_line *h, const uschar *name,
51 if (h->type == '*' && notdel) return FALSE;
52 if (h->text == NULL || strncmpic(h->text, name, len) != 0) return FALSE;
57 /*************************************************
58 * Add new header backend function *
59 *************************************************/
61 /* The header_last variable points to the last header during message reception
62 and delivery; otherwise it is NULL. We add new headers only when header_last is
63 not NULL. The function may get called sometimes when it is NULL (e.g. during
64 address verification where rewriting options exist). When called from a filter,
65 there may be multiple header lines in a single string.
67 This is an internal static function that is the common back end to the external
68 functions defined below. The general interface allows the header to be inserted
69 before or after a given occurrence of a given header.
71 (a) if "name" is NULL, the header is added at the end of all the existing
72 headers if "after" is true, or at the start if it is false. The "topnot"
75 (b) If "name" is not NULL, the first existing header with that name is sought.
76 If "after" is false, the new header is added before it. If "after" is true,
77 a check is made for adjacent headers with the same name, and the new header
78 is added after the last of them. If a header of the given name is not
79 found, the new header is added first if "topnot" is true, and at the bottom
83 after TRUE for "after", FALSE for "before"
84 name name if adding at a specific header, else NULL
85 topnot TRUE to add at top if no header found
86 type Exim header type character (htype_something)
88 ap va_list value for format arguments
90 Returns: pointer to header struct (last one, if multiple added)
94 header_add_backend(BOOL after, uschar *name, BOOL topnot, int type,
95 const char *format, va_list ap)
97 header_line *h, *new = NULL;
101 uschar * buf = store_get(HEADER_ADD_BUFFER_SIZE, FALSE);
102 gstring gs = { .size = HEADER_ADD_BUFFER_SIZE, .ptr = 0, .s = buf };
104 if (!header_last) return NULL;
106 if (!string_vformat(&gs, SVFMT_REBUFFER, format, ap))
107 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string too long in header_add: "
108 "%.100s ...", string_from_gstring(&gs));
110 if (gs.s != buf) store_release_above(buf);
111 gstring_release_unused(&gs);
112 string_from_gstring(&gs);
114 /* Find where to insert this header */
119 hptr = &header_last->next;
126 /* header_list->text can be NULL if we get here between when the new
127 received header is allocated and when it is actually filled in. We want
128 that header to be first, so skip it for now. */
130 if (!header_list->text)
131 hptr = &header_list->next;
137 int len = Ustrlen(name);
139 /* Find the first non-deleted header with the correct name. */
141 for (hptr = &header_list; (h = *hptr); hptr = &h->next)
142 if (header_testname(h, name, len, TRUE))
145 /* Handle the case where no header is found. To insert at the bottom, nothing
157 /* Handle the case where a header is found. Check for more if "after" is
158 true. In this case, we want to include deleted headers in the block. */
163 if (!h->next || !header_testname(h, name, len, FALSE)) break;
169 /* Loop for multiple header lines, taking care about continuations. At this
170 point, we have hptr pointing to the link field that will point to the new
171 header, and h containing the following header, or NULL. */
173 for (p = q = gs.s; *p; p = q)
177 q = Ustrchr(q, '\n');
178 if (!q) q = p + Ustrlen(p);
179 if (*(++q) != ' ' && *q != '\t') break;
182 new = store_get(sizeof(header_line), FALSE);
183 new->text = string_copyn(p, q - p);
191 if (!h) header_last = new;
197 /*************************************************
198 * Add new header anywhere in the chain *
199 *************************************************/
201 /* This is an external interface to header_add_backend().
204 after TRUE for "after", FALSE for "before"
205 name name if adding at a specific header, else NULL
206 topnot TRUE to add at top if no header found
207 type Exim header type character (htype_something)
208 format sprintf format
211 Returns: pointer to header struct added
215 header_add_at_position_internal(BOOL after, uschar *name, BOOL topnot, int type,
216 const char *format, ...)
220 va_start(ap, format);
221 h = header_add_backend(after, name, topnot, type, format, ap);
227 /* Documented external i/f for local_scan */
229 header_add_at_position(BOOL after, uschar *name, BOOL topnot, int type,
230 const char *format, ...)
233 va_start(ap, format);
234 (void) header_add_backend(after, name, topnot, type, format, ap);
238 /*************************************************
239 * Add new header on end of chain *
240 *************************************************/
242 /* This is now a convenience interface to header_add_backend().
245 type Exim header type character
246 format sprintf format
247 ... arguments for the format
253 header_add(int type, const char *format, ...)
256 va_start(ap, format);
257 (void) header_add_backend(TRUE, NULL, FALSE, type, format, ap);
263 /*************************************************
264 * Remove (mark as old) a header *
265 *************************************************/
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.
271 occ the occurrence number for multiply-defined headers
272 <= 0 means "all"; deleted headers are not counted
279 header_remove(int occ, const uschar *name)
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))
293 /*************************************************
294 * Check the name of a header *
295 *************************************************/
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.
303 h points to the header line
304 is_resent TRUE if the name starts "Resent-"
306 Returns: One of the htype_ enum values, identifying the header
310 header_checkname(header_line *h, BOOL is_resent)
312 uschar *text = h->text;
313 header_name *bot = header_names;
314 header_name *top = header_names + header_names_size;
316 if (is_resent) text += 7;
320 header_name *mid = bot + (top - bot)/2;
321 int c = strncmpic(text, mid->name, mid->len);
325 uschar * s = text + mid->len;
326 if (Uskip_whitespace(&s) == ':')
327 return (!is_resent || mid->allow_resent)? mid->htype : htype_other;
331 if (c > 0) bot = mid + 1; else top = mid;
338 /*************************************************
339 * Scan a header for certain strings *
340 *************************************************/
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.
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.
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
360 Returns: cond if the header exists and contains one of the strings;
365 /* First we have a local subroutine to handle a single pattern */
368 one_pattern_match(uschar *name, int slen, BOOL has_addresses, uschar *pattern)
371 const pcre *re = NULL;
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. */
376 if (*pattern == '^') re = regex_must_compile(pattern, TRUE, FALSE);
378 /* Scan for the required header(s) and scan each one */
380 for (header_line * h = header_list; !yield && h; h = h->next)
382 if (h->type == htype_old || slen > h->slen ||
383 strncmpic(name, h->text, slen) != 0)
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. */
391 uschar *s = h->text + slen;
395 uschar *error, *next;
396 uschar *e = parse_find_address_end(s, FALSE);
398 int start, end, domain;
400 /* Temporarily terminate the string at the address end while extracting
401 the operative address within. */
404 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
407 /* Move on, ready for the next address */
412 /* If there is some kind of syntax error, just give up on this header
417 /* Otherwise, test for the pattern; a non-regex must be an exact match */
420 ? (strcmpic(next, pattern) == 0)
421 : (pcre_exec(re, NULL, CS next, Ustrlen(next), 0, PCRE_EOPT, NULL, 0)
426 /* For headers that are not lists of addresses, scan the entire header line,
427 and just require "contains" for non-regex patterns. */
431 yield = (re == NULL)?
432 (strstric(h->text, pattern, FALSE) != NULL)
434 (pcre_exec(re, NULL, CS h->text, h->slen, 0, PCRE_EOPT, NULL, 0) >= 0);
442 /* The externally visible interface */
445 header_match(uschar *name, BOOL has_addresses, BOOL cond, string_item *strings,
449 int slen = Ustrlen(name);
451 for (string_item * s = strings; s; s = s->next)
452 if (one_pattern_match(name, slen, has_addresses, s->text))
456 for (int i = 0; i < count; i++)
457 if (one_pattern_match(name, slen, has_addresses, va_arg(ap, uschar *)))
467 /* End of header.c */