1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
6 /* Copyright (c) University of Cambridge 1995 - 2016 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
14 /*************************************************
15 * Test a header for matching name *
16 *************************************************/
18 /* This function tests the name of a header. It is made into a function because
19 it isn't just a string comparison: spaces and tabs are permitted between the
20 name and the colon. The h->text field should nowadays never be NULL, but check
24 h points to the header
26 len the length of the name
27 notdel if TRUE, force FALSE for deleted headers
29 Returns: TRUE or FALSE
33 header_testname(const header_line * h, const uschar * name, int len,
37 if (h->type == '*' && notdel) return FALSE;
38 if (!h->text || strncmpic(h->text, name, len) != 0) return FALSE;
40 while (*tt == ' ' || *tt == '\t') tt++;
44 /* This is a copy of the function above, only that it is possible to pass
45 only the beginning of a header name. It simply does a front-anchored
46 substring match. Arguments and Return codes are the same as for
47 header_testname() above. */
50 header_testname_incomplete(const header_line * h, const uschar * name,
53 if (h->type == '*' && notdel) return FALSE;
54 if (!h->text || strncmpic(h->text, name, len) != 0) return FALSE;
59 /*************************************************
60 * Add new header backend function *
61 *************************************************/
63 /* The header_last variable points to the last header during message reception
64 and delivery; otherwise it is NULL. We add new headers only when header_last is
65 not NULL. The function may get called sometimes when it is NULL (e.g. during
66 address verification where rewriting options exist). When called from a filter,
67 there may be multiple header lines in a single string.
69 This is an internal static function that is the common back end to the external
70 functions defined below. The general interface allows the header to be inserted
71 before or after a given occurrence of a given header.
73 (a) if "name" is NULL, the header is added at the end of all the existing
74 headers if "after" is true, or at the start if it is false. The "topnot"
77 (b) If "name" is not NULL, the first existing header with that name is sought.
78 If "after" is false, the new header is added before it. If "after" is true,
79 a check is made for adjacent headers with the same name, and the new header
80 is added after the last of them. If a header of the given name is not
81 found, the new header is added first if "topnot" is true, and at the bottom
85 after TRUE for "after", FALSE for "before"
86 name name if adding at a specific header, else NULL
87 topnot TRUE to add at top if no header found
88 type Exim header type character (htype_something)
90 ap va_list value for format arguments
92 Returns: pointer to header struct (last one, if multiple added)
96 header_add_backend(BOOL after, uschar *name, BOOL topnot, int type,
97 const char *format, va_list ap)
99 header_line *h, *new = NULL;
102 uschar * p, * q, * buf;
105 if (!header_last) return NULL;
107 gs.s = buf = store_get(HEADER_ADD_BUFFER_SIZE, GET_UNTAINTED);
108 gs.size = HEADER_ADD_BUFFER_SIZE;
111 if (!string_vformat(&gs, SVFMT_REBUFFER, format, ap))
112 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "string too long in header_add: "
113 "%.100s ...", string_from_gstring(&gs));
115 if (gs.s != buf) store_release_above(buf);
116 gstring_release_unused(&gs);
117 string_from_gstring(&gs);
119 /* Find where to insert this header */
124 hptr = &header_last->next;
131 /* header_list->text can be NULL if we get here between when the new
132 received header is allocated and when it is actually filled in. We want
133 that header to be first, so skip it for now. */
135 if (!header_list->text)
136 hptr = &header_list->next;
142 int len = Ustrlen(name);
144 /* Find the first non-deleted header with the correct name. */
146 for (hptr = &header_list; (h = *hptr); hptr = &h->next)
147 if (header_testname(h, name, len, TRUE))
150 /* Handle the case where no header is found. To insert at the bottom, nothing
162 /* Handle the case where a header is found. Check for more if "after" is
163 true. In this case, we want to include deleted headers in the block. */
168 if (!h->next || !header_testname(h, name, len, FALSE)) break;
174 /* Loop for multiple header lines, taking care about continuations. At this
175 point, we have hptr pointing to the link field that will point to the new
176 header, and h containing the following header, or NULL. */
178 for (p = q = gs.s; *p; p = q)
182 q = Ustrchr(q, '\n');
183 if (!q) q = p + Ustrlen(p);
184 if (*(++q) != ' ' && *q != '\t') break;
187 new = store_get(sizeof(header_line), GET_UNTAINTED);
188 new->text = string_copyn(p, q - p);
196 if (!h) header_last = new;
202 /*************************************************
203 * Add new header anywhere in the chain *
204 *************************************************/
206 /* This is an external interface to header_add_backend().
209 after TRUE for "after", FALSE for "before"
210 name name if adding at a specific header, else NULL
211 topnot TRUE to add at top if no header found
212 type Exim header type character (htype_something)
213 format sprintf format
216 Returns: pointer to header struct added
220 header_add_at_position_internal(BOOL after, uschar *name, BOOL topnot, int type,
221 const char *format, ...)
225 va_start(ap, format);
226 h = header_add_backend(after, name, topnot, type, format, ap);
232 /* Documented external i/f for local_scan */
234 header_add_at_position(BOOL after, uschar *name, BOOL topnot, int type,
235 const char *format, ...)
238 va_start(ap, format);
239 (void) header_add_backend(after, name, topnot, type, format, ap);
243 /*************************************************
244 * Add new header on end of chain *
245 *************************************************/
247 /* This is now a convenience interface to header_add_backend().
250 type Exim header type character
251 format sprintf format
252 ... arguments for the format
258 header_add(int type, const char *format, ...)
261 va_start(ap, format);
262 (void) header_add_backend(TRUE, NULL, FALSE, type, format, ap);
268 /*************************************************
269 * Remove (mark as old) a header *
270 *************************************************/
272 /* This function is used by the filter code; it is also exported in the
273 local_scan() API. If no header is found, the function does nothing.
276 occ the occurrence number for multiply-defined headers
277 <= 0 means "all"; deleted headers are not counted
284 header_remove(int occ, const uschar *name)
287 int len = Ustrlen(name);
288 for (header_line * h = header_list; h; h = h->next)
289 if (header_testname(h, name, len, TRUE) && (occ <= 0 || ++hcount == occ))
298 /*************************************************
299 * Check the name of a header *
300 *************************************************/
302 /* This function scans a table of header field names that Exim recognizes, and
303 returns the identification of a match. If "resent" is true, the header is known
304 to start with "resent-". In that case, the function matches only those fields
305 that are allowed to appear with resent- in front of them.
308 h points to the header line
309 is_resent TRUE if the name starts "Resent-"
311 Returns: One of the htype_ enum values, identifying the header
315 header_checkname(header_line *h, BOOL is_resent)
317 uschar *text = h->text;
318 header_name *bot = header_names;
319 header_name *top = header_names + header_names_size;
321 if (is_resent) text += 7;
325 header_name *mid = bot + (top - bot)/2;
326 int c = strncmpic(text, mid->name, mid->len);
330 uschar * s = text + mid->len;
331 if (Uskip_whitespace(&s) == ':')
332 return (!is_resent || mid->allow_resent)? mid->htype : htype_other;
336 if (c > 0) bot = mid + 1; else top = mid;
343 /*************************************************
344 * Scan a header for certain strings *
345 *************************************************/
347 /* This function is used for the "personal" test. It scans a particular header
348 line for any one of a number of strings, matched caselessly either as plain
349 strings, or as regular expressions. If the header line contains a list of
350 addresses, each match is applied only to the operative part of each address in
351 the header, and non-regular expressions must be exact matches.
353 The patterns can be provided either as a chain of string_item structures, or
354 inline in the argument list, or both. If there is more than one header of the
355 same name, they are all searched.
358 name header name, including the trailing colon
359 has_addresses TRUE if the header contains a list of addresses
360 cond value to return if the header contains any of the strings
361 strings points to a chain of string_item blocks
362 count number of inline strings
363 ... the inline strings
365 Returns: cond if the header exists and contains one of the strings;
370 /* First we have a local subroutine to handle a single pattern */
373 one_pattern_match(uschar * name, int slen, BOOL has_addresses, uschar * pattern)
376 const pcre2_code *re = NULL;
378 /* If the pattern is a regex, compile it. Bomb out if compiling fails; these
379 patterns are all constructed internally and should be valid. */
381 if (*pattern == '^') re = regex_must_compile(pattern, MCS_CASELESS, FALSE);
383 /* Scan for the required header(s) and scan each one */
385 for (header_line * h = header_list; !yield && h; h = h->next)
387 if (h->type == htype_old || slen > h->slen ||
388 strncmpic(name, h->text, slen) != 0)
391 /* If the header is a list of addresses, extract each one in turn, and scan
392 it. A non-regex scan must be an exact match for the address. */
396 uschar *s = h->text + slen;
400 uschar *error, *next;
401 uschar *e = parse_find_address_end(s, FALSE);
403 int start, end, domain;
405 /* Temporarily terminate the string at the address end while extracting
406 the operative address within. */
409 next = parse_extract_address(s, &error, &start, &end, &domain, FALSE);
412 /* Move on, ready for the next address */
417 /* If there is some kind of syntax error, just give up on this header
422 /* Otherwise, test for the pattern; a non-regex must be an exact match */
425 ? regex_match(re, next, -1, NULL)
426 : (strcmpic(next, pattern) == 0);
430 /* For headers that are not lists of addresses, scan the entire header line,
431 and just require "contains" for non-regex patterns. */
436 ? regex_match(re, h->text, h->slen, NULL)
437 : (strstric(h->text, pattern, FALSE) != NULL);
445 /* The externally visible interface */
448 header_match(uschar * name, BOOL has_addresses, BOOL cond, string_item * strings,
452 int slen = Ustrlen(name);
454 for (string_item * s = strings; s; s = s->next)
455 if (one_pattern_match(name, slen, has_addresses, s->text))
459 for (int i = 0; i < count; i++)
460 if (one_pattern_match(name, slen, has_addresses, va_arg(ap, uschar *)))
472 /* Wrap and truncate a string for use as a header.
473 Convert either the sequence "\n" or a real newline into newline plus indent.
474 If that still takes us past the column limit, look for the last space
476 Limit to the given max total char count.
478 Return: string or NULL */
481 wrap_header(const uschar * s, unsigned cols, unsigned maxchars,
482 const uschar * indent, unsigned indent_cols)
486 if (maxchars == 0) maxchars = INT_MAX;
487 if (cols == 0) cols = INT_MAX;
491 int sleft = Ustrlen(s);
492 for(unsigned llen = 0; ; llen = indent_cols)
495 unsigned ltail = 0, glen;
497 if ((t = Ustrchr(s, '\\')) && t[1] == 'n')
499 else if ((t = Ustrchr(s, '\n')))
504 if ((llen + t - s) > cols) /* more than a linesworth of s */
505 { /* look backward for whitespace */
506 for (const uschar * u = s + cols - llen; u > s + 10; --u) if (isspace(*u))
509 while (u > s+1 && isspace(u[-1])) --u; /* find start of whitespace */
510 g = string_catn(g, s, u - s);
511 s += ++llen; /* skip the space */
512 while (*s && isspace(*s)) /* and any trailing */
518 { /* just linebreak at 80 */
520 g = string_catn(g, s, llen);
527 else /* rest of s fits in line */
530 g = string_catn(g, s, llen);
535 break; /* no trailing linebreak */
536 if ((glen = gstring_length(g)) >= maxchars)
538 gstring_trim(g, glen - maxchars);
539 break; /* no trailing linebreak */
542 g = string_catn(g, US"\n", 1);
543 g = string_catn(g, indent, 1);
546 gstring_release_unused(g);
547 return string_from_gstring(g);
551 /* End of header.c */