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