ADD_LIBRARY(rspamd-server SHARED
${RSPAMD_CRYPTOBOX}
${RSPAMD_UTIL}
- ${RSPAMD_LUA}
${RSPAMD_SERVER}
${RSPAMD_STAT}
${RSPAMD_MIME}
+ ${RSPAMD_LUA}
${CMAKE_CURRENT_BINARY_DIR}/modules.c
${PLUGINSSRC}
"${RAGEL_ragel_smtp_addr_OUTPUTS}"
#else
#define MESSAGE_FIELD(task, field)
((!(task)->message) ? \
- (msg_err_task("no message when getting field %s", #field), g_assert(0)) : \
+ (__typeof__((task)->message->field))(msg_err_task("no message when getting field %s", #field), g_assert(0), NULL) : \
((task)->message->field))
#endif
const gchar *dkim_header,
const gchar *dkim_domain)
{
- struct rspamd_mime_header *rh;
- gint rh_num = 0;
- GPtrArray *ar;
+ struct rspamd_mime_header *rh, *cur, *sel = NULL;
+ gint hdr_cnt = 0;
if (dkim_header == NULL) {
- ar = g_hash_table_lookup (task->raw_headers, header_name);
+ rh = rspamd_message_get_header_array (task, header_name);
- if (ar) {
+ if (rh) {
/* Check uniqueness of the header */
- rh = g_ptr_array_index (ar, 0);
- if ((rh->flags & RSPAMD_HEADER_UNIQUE) && ar->len > 1) {
+ for (cur = rh->prev; ; cur = cur->prev) {
+ hdr_cnt ++;
+
+ if (hdr_cnt == count) {
+ sel = cur;
+ }
+
+ if (cur->next == NULL) {
+ /* Cycle */
+ break;
+ }
+ }
+
+ if ((rh->flags & RSPAMD_HEADER_UNIQUE) && hdr_cnt > 1) {
guint64 random_cookie = ottery_rand_uint64 ();
msg_warn_dkim ("header %s is intended to be unique by"
" email standards, but we have %d headers of this"
" type, artificially break DKIM check", header_name,
- ar->len);
+ hdr_cnt);
rspamd_dkim_hash_update (ctx->headers_hash,
(const gchar *)&random_cookie,
sizeof (random_cookie));
return FALSE;
}
- if (ar->len > count) {
- /* Set skip count */
- rh_num = ar->len - count - 1;
- }
- else {
+ if (hdr_cnt <= count) {
/*
* If DKIM has less headers requested than there are in a
* message, then it's fine, it allows adding extra headers
return TRUE;
}
- rh = g_ptr_array_index (ar, rh_num);
+ /* Selected header must be non-null if previous condition is false */
+ g_assert (sel != NULL);
if (ctx->header_canon_type == DKIM_CANON_SIMPLE) {
- rspamd_dkim_hash_update (ctx->headers_hash, rh->raw_value,
- rh->raw_len);
+ rspamd_dkim_hash_update (ctx->headers_hash, sel->raw_value,
+ sel->raw_len);
msg_debug_dkim ("update signature with header: %*s",
- (gint)rh->raw_len, rh->raw_value);
+ (gint)sel->raw_len, sel->raw_value);
}
else {
- if (ctx->is_sign && (rh->flags & RSPAMD_HEADER_FROM)) {
+ if (ctx->is_sign && (sel->flags & RSPAMD_HEADER_FROM)) {
/* Special handling of the From handling when rewrite is done */
gboolean has_rewrite = FALSE;
guint i;
struct rspamd_email_address *addr;
- PTR_ARRAY_FOREACH (task->from_mime, i, addr) {
+ PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, from_mime), i, addr) {
if ((addr->flags & RSPAMD_EMAIL_ADDR_ORIGINAL)
&& !(addr->flags & RSPAMD_EMAIL_ADDR_ALIASED)) {
has_rewrite = TRUE;
}
if (has_rewrite) {
- PTR_ARRAY_FOREACH (task->from_mime, i, addr) {
+ PTR_ARRAY_FOREACH (MESSAGE_FIELD (task, from_mime), i, addr) {
if (!(addr->flags & RSPAMD_EMAIL_ADDR_ORIGINAL)) {
if (!rspamd_dkim_canonize_header_relaxed (ctx, addr->raw,
header_name, FALSE)) {
}
}
- if (!rspamd_dkim_canonize_header_relaxed (ctx, rh->value,
+ if (!rspamd_dkim_canonize_header_relaxed (ctx, sel->value,
header_name, FALSE)) {
return FALSE;
}
/* For signature check just use the saved dkim header */
if (ctx->header_canon_type == DKIM_CANON_SIMPLE) {
/* We need to find our own signature and use it */
- guint i;
+ rh = rspamd_message_get_header_array (task, header_name);
- ar = g_hash_table_lookup (task->raw_headers, header_name);
-
- if (ar) {
+ if (rh) {
/* We need to find our own signature */
if (!dkim_domain) {
return FALSE;
}
- PTR_ARRAY_FOREACH (ar, i, rh) {
+ DL_FOREACH (rh, cur) {
guint64 th = rspamd_cryptobox_fast_hash (rh->decoded,
strlen (rh->decoded), rspamd_hash_seed ());
/* First of all find place of body */
body_end = task->msg.begin + task->msg.len;
- body_start = task->raw_headers_content.body_start;
+
+ body_start = MESSAGE_FIELD (task, raw_headers_content).body_start;
res = rspamd_mempool_alloc0 (task->task_pool, sizeof (*res));
res->ctx = ctx;
/* First of all find place of body */
body_end = task->msg.begin + task->msg.len;
- body_start = task->raw_headers_content.body_start;
+ body_start = MESSAGE_FIELD (task, raw_headers_content).body_start;
if (len > 0) {
ctx->common.len = len;
/* Now canonize headers */
for (i = 0; i < ctx->common.hlist->len; i++) {
+ struct rspamd_mime_header *rh, *cur;
+
dh = g_ptr_array_index (ctx->common.hlist, i);
/* We allow oversigning if dh->count > number of headers with this name */
if (hstat.s.flags & RSPAMD_DKIM_FLAG_OVERSIGN) {
/* Do oversigning */
- GPtrArray *ar;
guint count = 0;
- ar = g_hash_table_lookup (task->raw_headers, dh->name);
-
- if (ar) {
- count = ar->len;
- }
+ rh = rspamd_message_get_header_array (task, dh->name);
- for (j = 0; j < count; j ++) {
- /* Sign all existing headers */
- rspamd_dkim_canonize_header (&ctx->common, task, dh->name, j,
- NULL, NULL);
+ if (rh) {
+ DL_FOREACH (rh, cur) {
+ /* Sign all existing headers */
+ rspamd_dkim_canonize_header (&ctx->common, task, dh->name,
+ count,
+ NULL, NULL);
+ count++;
+ }
}
/* Now add one more entry to oversign */
if (count > 0 || !(hstat.s.flags & RSPAMD_DKIM_FLAG_OVERSIGN_EXISTING)) {
cur_len = (strlen (dh->name) + 1) * (count + 1);
headers_len += cur_len;
+
if (headers_len > 70 && i > 0 && i < ctx->common.hlist->len - 1) {
rspamd_printf_gstring (hdr, " ");
headers_len = cur_len;
}
}
else {
- if (g_hash_table_lookup (task->raw_headers, dh->name)) {
+ rh = rspamd_message_get_header_array (task, dh->name);
+
+ if (rh) {
if (hstat.s.count > 0) {
cur_len = (strlen (dh->name) + 1) * (hstat.s.count);
}
else {
b64_data = rspamd_encode_base64_fold (sig_buf, sig_len, 70, NULL,
- task->nlines_type);
+ MESSAGE_FIELD (task, nlines_type));
}
rspamd_printf_gstring (hdr, "%s", b64_data);
}
if (!forced && task->dns_requests >= task->cfg->dns_max_requests) {
- msg_info_task ("<%s> stop resolving on reaching %ud requests",
- task->message_id, task->dns_requests);
+ msg_info_task ("stop resolving on reaching %ud requests",
+ task->dns_requests);
}
return TRUE;
break;
case 's':
case 'S':
- IF_HEADER (SUBJECT_HEADER) {
- msg_debug_protocol ("read subject header, value: %V", hv);
- task->subject = rspamd_mempool_ftokdup (task->task_pool, hv_tok);
- }
IF_HEADER (SETTINGS_ID_HEADER) {
msg_debug_protocol ("read settings-id header, value: %V", hv);
task->settings_elt = rspamd_config_find_settings_name_ref (
}
msg_notice_task_encrypted ("<%s> %s: %*s; ip: %s; URL: %*s",
- task->message_id,
+ MESSAGE_FIELD (task, message_id),
has_user ? "user" : "from",
len, user_field,
rspamd_inet_address_to_string (task->from_addr),
}
p = c;
- s = task->subject;
+ s = MESSAGE_FIELD (task, subject);
if (s) {
slen = strlen (s);
sobj = rspamd_metric_symbol_ucl (task, sym);
ucl_object_insert_key (obj, sobj, sym->name, 0, false);
}
- });
+ })
if (task->cmd == CMD_CHECK_V2) {
ucl_object_insert_key (top, obj, "symbols", 0, false);
}
if (flags & RSPAMD_PROTOCOL_URLS) {
- if (g_hash_table_size (task->urls) > 0) {
+ if (g_hash_table_size (MESSAGE_FIELD (task, urls)) > 0) {
ucl_object_insert_key (top,
- rspamd_urls_tree_ucl (task->urls, task),
+ rspamd_urls_tree_ucl (MESSAGE_FIELD (task, urls), task),
"urls", 0, false);
}
- if (g_hash_table_size (task->emails) > 0) {
+ if (g_hash_table_size (MESSAGE_FIELD (task, emails)) > 0) {
ucl_object_insert_key (top,
- rspamd_emails_tree_ucl (task->emails, task),
+ rspamd_emails_tree_ucl (MESSAGE_FIELD (task, emails), task),
"emails", 0, false);
}
}
}
if (flags & RSPAMD_PROTOCOL_BASIC) {
- ucl_object_insert_key (top, ucl_object_fromstring (task->message_id),
+ ucl_object_insert_key (top,
+ ucl_object_fromstring (MESSAGE_FIELD (task, message_id)),
"message-id", 0, false);
ucl_object_insert_key (top,
ucl_object_fromdouble (task->time_real_finish - task->task_timestamp),
}
else {
folded_header = rspamd_header_value_fold ("DKIM-Signature",
- dkim_sig->str, 80, task->nlines_type, NULL);
+ dkim_sig->str, 80,
+ MESSAGE_FIELD (task, nlines_type),
+ NULL);
}
ucl_array_append (ar,
}
else {
folded_header = rspamd_header_value_fold ("DKIM-Signature",
- dkim_sig->str, 80, task->nlines_type, NULL);
+ dkim_sig->str, 80, MESSAGE_FIELD (task, nlines_type),
+ NULL);
}
ucl_object_insert_key (top,
struct rspamd_task *task, ucl_object_t **pobj)
{
struct rspamd_metric_result *metric_res;
- GHashTableIter hiter;
const struct rspamd_re_cache_stat *restat;
- gpointer h, v;
+
ucl_object_t *top = NULL;
rspamd_fstring_t *reply;
gint flags = RSPAMD_PROTOCOL_DEFAULT;
struct rspamd_action *action;
+ /* Removed in 2.0 */
#if 0
+ GHashTableIter hiter;
+ gpointer h, v;
/* Write custom headers */
g_hash_table_iter_init (&hiter, task->reply_headers);
while (g_hash_table_iter_next (&hiter, &h, &v)) {
msg = rspamd_http_new_message (HTTP_RESPONSE);
if (rspamd_http_connection_is_encrypted (task->http_conn)) {
- msg_info_protocol ("<%s> writing encrypted reply", task->message_id);
+ msg_info_protocol ("<%s> writing encrypted reply",
+ MESSAGE_FIELD (task, message_id));
}
if (!RSPAMD_TASK_IS_JSON (task)) {
*/
#include "config.h"
#include "rspamd.h"
+#include "libmime/message.h"
#include "lua/lua_common.h"
#include "unix-std.h"
#include "cfg_file_private.h"
row->timestamp = task->task_timestamp;
/* Strings */
- rspamd_strlcpy (row->message_id, task->message_id,
+ rspamd_strlcpy (row->message_id, MESSAGE_FIELD (task, message_id),
sizeof (row->message_id));
if (task->user) {
rspamd_strlcpy (row->user, task->user, sizeof (row->user));
wl = ucl_object_lookup (task->settings, "whitelist");
if (wl != NULL) {
- msg_info_task ("<%s> is whitelisted", task->message_id);
+ msg_info_task ("task is whitelisted");
task->flags |= RSPAMD_TASK_FLAG_SKIP;
return TRUE;
}
if (!(item->type & SYMBOL_TYPE_FINE)) {
if (rspamd_symcache_metric_limit (task, checkpoint)) {
- msg_info_task ("<%s> has already scored more than %.2f, so do "
+ msg_info_task ("task has already scored more than %.2f, so do "
"not "
- "plan more checks", task->message_id,
+ "plan more checks",
checkpoint->rs->score);
all_done = TRUE;
break;
do { \
if ((rec)->nested > SPF_MAX_NESTING || \
(rec)->dns_requests > SPF_MAX_DNS_REQUESTS) { \
- msg_info_spf ("<%s> spf recursion limit %d is reached, domain: %s", \
- (rec)->task->message_id, (rec)->dns_requests, \
+ msg_info_spf ("spf recursion limit %d is reached, domain: %s", \
+ (rec)->dns_requests, \
(rec)->sender_domain); \
return FALSE; \
} \
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
cb->addr->flags |= RSPAMD_SPF_FLAG_PERMFAIL;
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot find MX"
+ "spf error for domain %s: cannot find MX"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
cb->addr->flags |= RSPAMD_SPF_FLAG_PERMFAIL;
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve A"
+ "spf error for domain %s: cannot resolve A"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
cb->addr->flags |= RSPAMD_SPF_FLAG_PERMFAIL;
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve AAAA"
+ "spf error for domain %s: cannot resolve AAAA"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
case SPF_RESOLVE_PTR:
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve PTR"
+ "spf error for domain %s: cannot resolve PTR"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
cb->addr->flags |= RSPAMD_SPF_FLAG_PERMFAIL;
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve REDIRECT"
+ "spf error for domain %s: cannot resolve REDIRECT"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
case SPF_RESOLVE_INCLUDE:
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve INCLUDE"
+ "spf error for domain %s: cannot resolve INCLUDE"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
case SPF_RESOLVE_EXISTS:
if (!(cb->addr->flags & RSPAMD_SPF_FLAG_RESOLVED)) {
msg_debug_spf (
- "<%s>: spf error for domain %s: cannot resolve EXISTS"
+ "spf error for domain %s: cannot resolve EXISTS"
" record for %s: %s",
- task->message_id,
cb->rec->sender_domain,
cb->resolved->cur_domain,
rdns_strerror (reply->code));
else {
cb->addr->flags |= RSPAMD_SPF_FLAG_TEMPFAIL;
msg_info_spf (
- "<%s>: spf error for domain %s: cannot resolve %s DNS record for"
+ "spf error for domain %s: cannot resolve %s DNS record for"
" %s: %s",
- task->message_id,
cb->rec->sender_domain,
rspamd_spf_dns_action_to_str (cb->cur_action),
cb->ptr_host,
else {
/* Something unknown */
msg_info_spf (
- "<%s>: spf error for domain %s: unknown spf element",
- task->message_id, rec->sender_domain);
+ "spf error for domain %s: unknown spf element",
+ rec->sender_domain);
return begin;
}
p++;
break;
default:
msg_info_spf (
- "<%s>: spf error for domain %s: unknown or "
+ "spf error for domain %s: unknown or "
"unsupported spf macro %c in %s",
- task->message_id,
rec->sender_domain,
*p,
begin);
else {
/* Something unknown */
msg_info_spf (
- "<%s>: spf error for domain %s: unknown spf element",
- task->message_id, rec->sender_domain);
+ "spf error for domain %s: unknown spf element",
+ rec->sender_domain);
return begin;
}
p++;
break;
default:
msg_info_spf (
- "<%s>: spf error for domain %s: unknown or "
+ "spf error for domain %s: unknown or "
"unsupported spf macro %c in %s",
- task->message_id,
rec->sender_domain,
*p,
begin);
delim = *p;
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: unknown or "
+ msg_info_spf ("spf error for domain %s: unknown or "
"unsupported spf macro %c in %s",
- task->message_id,
rec->sender_domain,
*p,
begin);
res = parse_spf_a (rec, resolved, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'i':
res = parse_spf_ip6 (rec, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'm':
res = parse_spf_mx (rec, resolved, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'p':
res = parse_spf_ptr (rec, resolved, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'e':
res = parse_spf_exists (rec, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'r':
res = parse_spf_redirect (rec, resolved, addr);
}
else {
- msg_info_spf (
- "<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
}
break;
case 'v':
}
break;
default:
- msg_info_spf ("<%s>: spf error for domain %s: bad spf command %s",
- task->message_id, rec->sender_domain, begin);
+ msg_info_spf ("spf error for domain %s: bad spf command %s",
+ rec->sender_domain, begin);
break;
}
/* Skip one number of record, so no we are here spf2.0/ */
begin += sizeof (SPF_VER2_STR);
if (*begin != '/') {
- msg_info_spf ("<%s>: spf error for domain %s: sender id is invalid",
- rec->task->message_id, rec->sender_domain);
+ msg_info_spf ("spf error for domain %s: sender id is invalid",
+ rec->sender_domain);
}
else {
begin++;
}
else {
msg_debug_spf (
- "<%s>: spf error for domain %s: bad spf record start: %*s",
- rec->task->message_id,
+ "spf error for domain %s: bad spf record start: %*s",
rec->sender_domain,
(gint)len,
begin);
new_task->task_pool = pool;
}
- new_task->raw_headers = g_hash_table_new_full (rspamd_strcase_hash,
- rspamd_strcase_equal, NULL, rspamd_ptr_array_free_hard);
- new_task->headers_order = g_queue_new ();
new_task->request_headers = g_hash_table_new_full (rspamd_ftok_icase_hash,
rspamd_ftok_icase_equal, rspamd_fstring_mapped_ftok_free,
rspamd_request_header_dtor);
rspamd_mempool_add_destructor (new_task->task_pool,
(rspamd_mempool_destruct_t) g_hash_table_unref,
new_task->request_headers);
- rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_unref,
- new_task->raw_headers);
- rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_queue_free,
- new_task->headers_order);
- new_task->emails = g_hash_table_new (rspamd_email_hash, rspamd_emails_cmp);
- rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_unref,
- new_task->emails);
- new_task->urls = g_hash_table_new (rspamd_url_hash, rspamd_urls_cmp);
- rspamd_mempool_add_destructor (new_task->task_pool,
- (rspamd_mempool_destruct_t) g_hash_table_unref,
- new_task->urls);
- new_task->parts = g_ptr_array_sized_new (4);
- rspamd_mempool_add_destructor (new_task->task_pool,
- rspamd_ptr_array_free_hard, new_task->parts);
- new_task->text_parts = g_ptr_array_sized_new (2);
- rspamd_mempool_add_destructor (new_task->task_pool,
- rspamd_ptr_array_free_hard, new_task->text_parts);
- new_task->received = g_ptr_array_sized_new (8);
- rspamd_mempool_add_destructor (new_task->task_pool,
- rspamd_ptr_array_free_hard, new_task->received);
new_task->sock = -1;
new_task->flags |= (RSPAMD_TASK_FLAG_MIME|RSPAMD_TASK_FLAG_JSON);
new_task->result = rspamd_create_metric_result (new_task);
- new_task->message_id = new_task->queue_id = "undef";
+ new_task->queue_id = "undef";
new_task->messages = ucl_object_typed_new (UCL_OBJECT);
new_task->lua_cache = g_hash_table_new (rspamd_str_hash, rspamd_str_equal);
projects / thirdparty / rspamd.git / commitdiff
