1 /******************************************************************************/
2 /* pfixtools: a collection of postfix related tools */
4 /* ________________________________________________________________________ */
6 /* Redistribution and use in source and binary forms, with or without */
7 /* modification, are permitted provided that the following conditions */
10 /* 1. Redistributions of source code must retain the above copyright */
11 /* notice, this list of conditions and the following disclaimer. */
12 /* 2. Redistributions in binary form must reproduce the above copyright */
13 /* notice, this list of conditions and the following disclaimer in the */
14 /* documentation and/or other materials provided with the distribution. */
15 /* 3. The names of its contributors may not be used to endorse or promote */
16 /* products derived from this software without specific prior written */
19 /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND */
20 /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE */
21 /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
22 /* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS */
23 /* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR */
24 /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF */
25 /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS */
26 /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN */
27 /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) */
28 /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF */
29 /* THE POSSIBILITY OF SUCH DAMAGE. */
30 /******************************************************************************/
33 * Copyright © 2008 Florent Bruneau
40 #include "policy_tokens.h"
42 typedef struct strlist_config_t {
52 unsigned is_hostname :1;
54 unsigned match_sender :1;
55 unsigned match_recipient :1;
57 unsigned match_helo :1;
58 unsigned match_client :1;
59 unsigned match_reverse :1;
63 static strlist_config_t *strlist_config_new(void)
65 return p_new(strlist_config_t, 1);
68 static void strlist_config_delete(strlist_config_t **config)
71 array_deep_wipe((*config)->tries, trie_delete);
72 array_wipe((*config)->weights);
73 array_wipe((*config)->reverses);
74 array_wipe((*config)->partiales);
79 static inline void strlist_copy(char *dest, const char *str, ssize_t str_len,
84 for (const char *src = str + str_len - 1 ; src >= str ; --src) {
85 *dest = ascii_tolower(*src);
89 for (int i = 0 ; i < str_len ; ++i) {
90 *dest = ascii_tolower(str[i]);
99 static trie_t *strlist_create(const char *file, bool reverse, bool lock)
106 if (!file_map_open(&map, file, false)) {
111 while (end > p && end[-1] != '\n') {
114 if (end != map.end) {
115 warn("file %s miss a final \\n, ignoring last line",
120 while (p < end && p != NULL) {
121 const char *eol = (char *)memchr(p, '\n', end - p);
125 if (eol - p >= BUFSIZ) {
126 err("unreasonnable long line");
127 file_map_close(&map);
132 const char *eos = eol;
133 while (p < eos && isspace(*p)) {
136 while (p < eos && isspace(eos[-1])) {
140 strlist_copy(line, p, eos - p, reverse);
141 trie_insert(db, line);
146 file_map_close(&map);
147 trie_compile(db, lock);
151 static bool strlist_create_from_rhbl(const char *file, bool lock,
152 trie_t **phosts, trie_t **pdomains)
154 trie_t *hosts, *domains;
155 uint32_t host_count, domain_count;
160 if (!file_map_open(&map, file, false)) {
165 while (end > p && end[-1] != '\n') {
168 if (end != map.end) {
169 warn("file %s miss a final \\n, ignoring last line",
175 domains = trie_new();
177 while (p < end && p != NULL) {
178 const char *eol = (char *)memchr(p, '\n', end - p);
182 if (eol - p >= BUFSIZ) {
183 err("unreasonnable long line");
184 file_map_close(&map);
186 trie_delete(&domains);
190 const char *eos = eol;
191 while (p < eos && isspace(*p)) {
194 while (p < eos && isspace(eos[-1])) {
199 strlist_copy(line, p, eos - p, true);
200 trie_insert(hosts, line);
202 } else if (*p == '*') {
204 strlist_copy(line, p, eos - p, true);
205 trie_insert(domains, line);
212 file_map_close(&map);
213 if (host_count > 0) {
214 trie_compile(hosts, lock);
220 if (domain_count > 0) {
221 trie_compile(domains, lock);
224 trie_delete(&domains);
227 return hosts != NULL || domains != NULL;
232 static bool strlist_filter_constructor(filter_t *filter)
234 strlist_config_t *config = strlist_config_new();
236 #define PARSE_CHECK(Expr, Str, ...) \
238 err(Str, ##__VA_ARGS__); \
239 strlist_config_delete(&config); \
243 config->hard_threshold = 1;
244 config->soft_threshold = 1;
245 foreach (filter_param_t *param, filter->params) {
246 switch (param->type) {
247 /* file parameter is:
248 * [no]lock:(partial-)(prefix|suffix):weight:filename
250 * - lock: memlock the database in memory.
251 * - nolock: don't memlock the database in memory.
252 * - prefix: perform "prefix" compression on storage.
253 * - suffix perform "suffix" compression on storage.
254 * - \d+: a number describing the weight to give to the match
255 * the given list [mandatory]
256 * the file pointed by filename MUST be a valid string list (one string per
257 * line, empty lines and lines beginning with a '#' are ignored).
262 bool reverse = false;
263 bool partial = false;
265 const char *current = param->value;
266 const char *p = m_strchrnul(param->value, ':');
268 for (int i = 0 ; i < 4 ; ++i) {
269 PARSE_CHECK(i == 3 || *p,
270 "file parameter must contains a locking state "
271 "and a weight option");
274 if ((p - current) == 4 && strncmp(current, "lock", 4) == 0) {
276 } else if ((p - current) == 6 && strncmp(current, "nolock", 6) == 0) {
279 PARSE_CHECK(false, "illegal locking state %.*s",
280 p - current, current);
285 if (p - current > (ssize_t)strlen("partial-")
286 && strncmp(current, "partial-", strlen("partial-")) == 0) {
288 current += strlen("partial-");
290 if ((p - current) == 6 && strncmp(current, "suffix", 6) == 0) {
292 } else if ((p - current) == 6 && strncmp(current, "prefix", 6) == 0) {
295 PARSE_CHECK(false, "illegal character order value %.*s",
296 p - current, current);
301 weight = strtol(current, &next, 10);
302 PARSE_CHECK(next == p && weight >= 0 && weight <= 1024,
303 "illegal weight value %.*s",
304 (p - current), current);
308 trie = strlist_create(current, reverse, lock);
309 PARSE_CHECK(trie != NULL,
310 "cannot load string list from %s", current);
311 array_add(config->tries, trie);
312 array_add(config->weights, weight);
313 array_add(config->reverses, reverse);
314 array_add(config->partiales, partial);
319 p = m_strchrnul(current, ':');
324 /* rbldns parameter is:
325 * [no]lock::weight:filename
327 * - lock: memlock the database in memory.
328 * - nolock: don't memlock the database in memory.
329 * - \d+: a number describing the weight to give to the match
330 * the given list [mandatory]
331 * directly import a file issued from a rhbl in rbldns format.
336 trie_t *trie_hosts = NULL;
337 trie_t *trie_domains = NULL;
338 const char *current = param->value;
339 const char *p = m_strchrnul(param->value, ':');
341 for (int i = 0 ; i < 3 ; ++i) {
342 PARSE_CHECK(i == 2 || *p,
343 "file parameter must contains a locking state "
344 "and a weight option");
347 if ((p - current) == 4 && strncmp(current, "lock", 4) == 0) {
349 } else if ((p - current) == 6 && strncmp(current, "nolock", 6) == 0) {
352 PARSE_CHECK(false, "illegal locking state %.*s",
353 p - current, current);
358 weight = strtol(current, &next, 10);
359 PARSE_CHECK(next == p && weight >= 0 && weight <= 1024,
360 "illegal weight value %.*s",
361 (p - current), current);
365 PARSE_CHECK(strlist_create_from_rhbl(current, lock,
366 &trie_hosts, &trie_domains),
367 "cannot load string list from rhbl %s", current);
368 if (trie_hosts != NULL) {
369 array_add(config->tries, trie_hosts);
370 array_add(config->weights, weight);
371 array_add(config->reverses, true);
372 array_add(config->partiales, false);
374 if (trie_domains != NULL) {
375 array_add(config->tries, trie_domains);
376 array_add(config->weights, weight);
377 array_add(config->reverses, true);
378 array_add(config->partiales, true);
380 config->is_hostname = true;
385 p = m_strchrnul(current, ':');
390 /* hard_threshold parameter is an integer.
391 * If the matching score is greater or equal than this threshold,
392 * the hook "hard_match" is called.
393 * hard_threshold = 1 means, that all matches are hard matches.
396 FILTER_PARAM_PARSE_INT(HARD_THRESHOLD, config->hard_threshold);
398 /* soft_threshold parameter is an integer.
399 * if the matching score is greater or equal than this threshold
400 * and smaller or equal than the hard_threshold, the hook "soft_match"
404 FILTER_PARAM_PARSE_INT(SOFT_THRESHOLD, config->soft_threshold);
406 /* fields to match againes:
407 * fields = field_name(,field_name)*
409 * - hostname: helo_name,client_name,reverse_client_name
410 * - email: sender,recipient
413 const char *current = param->value;
414 const char *p = m_strchrnul(param->value, ',');
416 postlicyd_token tok = policy_tokenize(current, p - current);
418 #define CASE(Up, Low, Type) \
420 config->match_ ## Low = true; \
421 config->is_ ## Type = true; \
423 CASE(HELO_NAME, helo, hostname);
424 CASE(CLIENT_NAME, client, hostname);
425 CASE(REVERSE_CLIENT_NAME, reverse, hostname);
426 CASE(SENDER_DOMAIN, sender, hostname);
427 CASE(RECIPIENT_DOMAIN, recipient, hostname);
428 CASE(SENDER, sender, email);
429 CASE(RECIPIENT, recipient, email);
432 PARSE_CHECK(false, "unknown field %.*s", p - current, current);
439 p = m_strchrnul(current, ',');
447 PARSE_CHECK(config->is_email != config->is_hostname,
448 "matched field MUST be emails XOR hostnames");
449 PARSE_CHECK(config->tries.len,
450 "no file parameter in the filter %s", filter->name);
451 filter->data = config;
455 static void strlist_filter_destructor(filter_t *filter)
457 strlist_config_t *config = filter->data;
458 strlist_config_delete(&config);
459 filter->data = config;
462 static filter_result_t strlist_filter(const filter_t *filter, const query_t *query)
464 char reverse[BUFSIZ];
466 const strlist_config_t *config = filter->data;
468 if (config->is_email &&
469 ((config->match_sender && query->state < SMTP_MAIL)
470 || (config->match_recipient && query->state != SMTP_RCPT))) {
471 warn("trying to match an email against a field that is not "
472 "available in current protocol state");
474 } else if (config->is_hostname && config->match_helo && query->state < SMTP_HELO) {
475 warn("trying to match hostname against helo before helo is received");
478 #define LOOKUP(Flag, Field) \
479 if (config->match_ ## Flag) { \
480 const int len = m_strlen(query->Field); \
481 strlist_copy(normal, query->Field, len, false); \
482 strlist_copy(reverse, query->Field, len, true); \
483 for (uint32_t i = 0 ; i < config->tries.len ; ++i) { \
484 const int weight = array_elt(config->weights, i); \
485 const trie_t *trie = array_elt(config->tries, i); \
486 const bool rev = array_elt(config->reverses, i); \
487 const bool part = array_elt(config->partiales, i); \
488 if ((!part && trie_lookup(trie, rev ? reverse : normal)) \
489 || (part && trie_prefix(trie, rev ? reverse : normal))) { \
491 if (sum >= config->hard_threshold) { \
492 return HTK_HARD_MATCH; \
497 if (config->is_email) {
498 LOOKUP(sender, sender);
499 LOOKUP(recipient, recipient);
500 } else if (config->is_hostname) {
501 LOOKUP(helo, helo_name);
502 LOOKUP(client, client_name);
503 LOOKUP(reverse, reverse_client_name);
504 LOOKUP(recipient, recipient_domain);
505 LOOKUP(sender, sender_domain);
508 if (sum >= config->hard_threshold) {
509 return HTK_HARD_MATCH;
510 } else if (sum >= config->soft_threshold) {
511 return HTK_SOFT_MATCH;
517 static int strlist_init(void)
519 filter_type_t type = filter_register("strlist", strlist_filter_constructor,
520 strlist_filter_destructor, strlist_filter);
523 (void)filter_hook_register(type, "abort");
524 (void)filter_hook_register(type, "error");
525 (void)filter_hook_register(type, "fail");
526 (void)filter_hook_register(type, "hard_match");
527 (void)filter_hook_register(type, "soft_match");
531 (void)filter_param_register(type, "file");
532 (void)filter_param_register(type, "rbldns");
533 (void)filter_param_register(type, "hard_threshold");
534 (void)filter_param_register(type, "soft_threshold");
535 (void)filter_param_register(type, "fields");
538 module_init(strlist_init);