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