/************************************************* * Exim - an Internet mail transport agent * *************************************************/ /* Copyright (c) The Exim Maintainers 2021 - 2024 */ /* Copyright (c) University of Cambridge 1995 - 2009 */ /* See the file NOTICE for conditions of use and distribution. */ /* SPDX-License-Identifier: GPL-2.0-or-later */ /* Code for the filter test function. */ #include "exim.h" /************************************************* * Read message and set body/size variables * *************************************************/ /* We have to read the remainder of the message in order to find its size, so we can set up the message_body variables at the same time (in normal use, the message_body variables are not set up unless needed). The reading code is written out here rather than having options in read_message_data, in order to keep that function as efficient as possible. (Later: this function is now global because it is also used by the -bem testing option.) Handling message_body_end is somewhat more tedious. Pile it all into a circular buffer and sort out at the end. Arguments: dot_ended TRUE if message already terminated by '.' Returns: nothing */ void read_message_body(BOOL dot_ended) { register int ch; int body_len, body_end_len, header_size; uschar *s; message_body = store_malloc(message_body_visible + 1); message_body_end = store_malloc(message_body_visible + 1); s = message_body_end; body_len = 0; body_linecount = 0; header_size = message_size; if (!dot_ended && !stdin_feof()) { if (!f.dot_ends) { while ((ch = stdin_getc(GETC_BUFFER_UNLIMITED)) != EOF) { if (ch == 0) body_zerocount++; if (ch == '\n') body_linecount++; if (body_len < message_body_visible) message_body[body_len++] = ch; *s++ = ch; if (s > message_body_end + message_body_visible) s = message_body_end; message_size++; } } else { int ch_state = 1; while ((ch = stdin_getc(GETC_BUFFER_UNLIMITED)) != EOF) { if (ch == 0) body_zerocount++; switch (ch_state) { case 0: /* Normal state */ if (ch == '\n') { body_linecount++; ch_state = 1; } break; case 1: /* After "\n" */ if (ch == '.') { ch_state = 2; continue; } if (ch != '\n') ch_state = 0; break; case 2: /* After "\n." */ if (ch == '\n') goto READ_END; if (body_len < message_body_visible) message_body[body_len++] = '.'; *s++ = '.'; if (s > message_body_end + message_body_visible) s = message_body_end; message_size++; ch_state = 0; break; } if (body_len < message_body_visible) message_body[body_len++] = ch; *s++ = ch; if (s > message_body_end + message_body_visible) s = message_body_end; message_size++; } READ_END: ; } if (s == message_body_end || s[-1] != '\n') body_linecount++; } message_body[body_len] = 0; message_body_size = message_size - header_size; /* body_len stops at message_body_visible; it if got there, we may have wrapped round in message_body_end. */ if (body_len >= message_body_visible) { int below = s - message_body_end; int above = message_body_visible - below; if (above > 0) { uschar * temp = store_get(below, GET_UNTAINTED); memcpy(temp, message_body_end, below); memmove(message_body_end, s+1, above); memcpy(message_body_end + above, temp, below); s = message_body_end + message_body_visible; } } *s = 0; body_end_len = s - message_body_end; /* Convert newlines and nulls in the body variables to spaces */ while (body_len > 0) { if (message_body[--body_len] == '\n' || message_body[body_len] == 0) message_body[body_len] = ' '; } while (body_end_len > 0) { if (message_body_end[--body_end_len] == '\n' || message_body_end[body_end_len] == 0) message_body_end[body_end_len] = ' '; } } static int exim_filter_interpret(const uschar * filebuf, int options, address_item ** addrp, uschar ** error) { #ifdef DISABLE_EXIM_FILTER printf("exim: Exim-filtering not available\n"); return FF_ERROR; #else const misc_module_info * mi; uschar * errstr = NULL; typedef int (*fn_t)(const uschar *, int, address_item **, uschar **); if (!(mi = misc_mod_find(US"exim_filter", &errstr))) { printf("exim: Exim-filtering not available: %s\n", errstr ? errstr : US"?"); return FF_ERROR; } return(((fn_t *) mi->functions)[EXIM_INTERPRET]) (filebuf, options, addrp, error); #endif } /************************************************* * Test a mail filter * *************************************************/ /* This is called when exim is run with the -bf option. At this point it is running under an unprivileged uid/gid. A test message's headers have been read into store, and the body of the message is still accessible on the standard input if this is the first time this function has been called. It may be called twice if both system and user filters are being tested. Argument: fd an fd containing the filter file filename the name of the filter file is_system TRUE if testing is to be as a system filter dot_ended TRUE if message already terminated by '.' Returns: TRUE if no errors */ BOOL filter_runtest(int fd, const uschar * filename, BOOL is_system, BOOL dot_ended) { int rc, filter_type; BOOL yield; struct stat statbuf; address_item *generated = NULL; uschar *error, *filebuf; /* Read the filter file into store as will be done by the router in a real case. */ if (fstat(fd, &statbuf) != 0) { printf("exim: failed to get size of %s: %s\n", filename, strerror(errno)); return FALSE; } filebuf = store_get(statbuf.st_size + 1, filename); rc = read(fd, filebuf, statbuf.st_size); (void)close(fd); if (rc != statbuf.st_size) { printf("exim: error while reading %s: %s\n", filename, strerror(errno)); return FALSE; } filebuf[statbuf.st_size] = 0; /* Check the filter type. User filters start with "# Exim filter" or "# Sieve filter". If the filter type is not recognized, the file is treated as an ordinary .forward file. System filters do not need the "# Exim filter" in order to be recognized as Exim filters. */ filter_type = rda_is_filter(filebuf); if (is_system && filter_type == FILTER_FORWARD) filter_type = FILTER_EXIM; printf("Testing %s file \"%s\"\n\n", filter_type == FILTER_EXIM ? "Exim filter" : filter_type == FILTER_SIEVE ? "Sieve filter" : "forward file", filename); /* Handle a plain .forward file */ if (filter_type == FILTER_FORWARD) { yield = parse_forward_list(filebuf, RDO_REWRITE, &generated, /* for generated addresses */ &error, /* for errors */ deliver_domain, /* incoming domain for \name */ NULL, /* no check on includes */ NULL); /* fail on syntax errors */ switch(yield) { case FF_FAIL: printf("exim: forward file contains \":fail:\"\n"); break; case FF_BLACKHOLE: printf("exim: forwardfile contains \":blackhole:\"\n"); break; case FF_ERROR: printf("exim: error in forward file: %s\n", error); return FALSE; } if (!generated) printf("exim: no addresses generated from forward file\n"); else { printf("exim: forward file generated:\n"); while (generated) { printf(" %s\n", generated->address); generated = generated->next; } } return TRUE; } /* For a filter, set up the message_body variables and the message size if this is the first time this function has been called. */ if (!message_body) read_message_body(dot_ended); /* Now pass the filter file to the function that interprets it. Because filter_test is not FILTER_NONE, the interpreter will output comments about what it is doing. No need to clean up store. Indeed, we must not, because we may be testing a system filter that is going to be followed by a user filter test. */ if (is_system) { f.system_filtering = TRUE; f.enable_dollar_recipients = TRUE; /* Permit $recipients in system filter */ yield = exim_filter_interpret(filebuf, RDO_DEFER|RDO_FAIL|RDO_FILTER|RDO_FREEZE|RDO_REWRITE, &generated, &error); f.enable_dollar_recipients = FALSE; f.system_filtering = FALSE; } else if (filter_type == FILTER_SIEVE) { const misc_module_info * mi; uschar * errstr = NULL; typedef int (*fn_t)(const uschar *, int, const sieve_block *, address_item **, uschar **); if (!(mi = misc_mod_find(US"sieve_filter", &errstr))) { printf("exim: Sieve filtering not available: %s\n", errstr ? errstr : US"?"); yield = FF_ERROR; } else yield = (((fn_t *) mi->functions)[SIEVE_INTERPRET]) (filebuf, RDO_REWRITE, NULL, &generated, &error); } else yield = exim_filter_interpret(filebuf, RDO_REWRITE, &generated, &error); return yield != FF_ERROR; } /* End of filtertest.c */