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