text_part->flags |= RSPAMD_MIME_PART_FLAG_EMPTY;
text_part->orig = NULL;
text_part->content = NULL;
- task->text_parts = g_list_prepend (task->text_parts, text_part);
+ g_ptr_array_add (task->text_parts, text_part);
return;
}
text_part->orig = part_content;
rspamd_mempool_add_destructor (task->task_pool,
(rspamd_mempool_destruct_t) free_byte_array_callback,
text_part->content);
- task->text_parts = g_list_prepend (task->text_parts, text_part);
+ g_ptr_array_add (task->text_parts, text_part);
}
else if (g_mime_content_type_is_type (type, "text", "*")) {
text_part->flags |= RSPAMD_MIME_PART_FLAG_EMPTY;
text_part->orig = NULL;
text_part->content = NULL;
- task->text_parts = g_list_prepend (task->text_parts, text_part);
+ g_ptr_array_add (task->text_parts, text_part);
return;
}
text_part->orig = part_content;
rspamd_url_text_extract (task->task_pool, task, text_part, FALSE);
rspamd_fuzzy_from_text_part (text_part, task->task_pool, task->cfg->max_diff);
- task->text_parts = g_list_prepend (task->text_parts, text_part);
+ g_ptr_array_add (task->text_parts, text_part);
}
else {
return;
}
}
+struct mime_foreach_data {
+ struct rspamd_task *task;
+ guint parser_recursion;
+ GMimeObject *parent;
+};
+
#ifdef GMIME24
static void
mime_foreach_callback (GMimeObject * parent,
mime_foreach_callback (GMimeObject * part, gpointer user_data)
#endif
{
- struct rspamd_task *task = (struct rspamd_task *)user_data;
+ struct mime_foreach_data *md = user_data;
+ struct rspamd_task *task;
struct mime_part *mime_part;
GMimeContentType *type;
GMimeDataWrapper *wrapper;
GMimeStream *part_stream;
GByteArray *part_content;
- task->parts_count++;
-
+ task = md->task;
/* 'part' points to the current part node that g_mime_message_foreach_part() is iterating over */
/* find out what class 'part' is... */
g_mime_message_foreach_part() again here. */
message = g_mime_message_part_get_message ((GMimeMessagePart *) part);
- if (task->scan_milliseconds++ < RECURSION_LIMIT) {
+ if (md->parser_recursion++ < RECURSION_LIMIT) {
#ifdef GMIME24
- g_mime_message_foreach (message, mime_foreach_callback, task);
+ g_mime_message_foreach (message, mime_foreach_callback, md);
#else
- g_mime_message_foreach_part (message, mime_foreach_callback, task);
+ g_mime_message_foreach_part (message, mime_foreach_callback, md);
#endif
}
else {
- msg_err ("too deep mime recursion detected: %d", task->scan_milliseconds);
+ msg_err ("too deep mime recursion detected: %d", md->parser_recursion);
return;
}
#ifndef GMIME24
}
else if (GMIME_IS_MULTIPART (part)) {
/* multipart/mixed, multipart/alternative, multipart/related, multipart/signed, multipart/encrypted, etc... */
- task->parser_parent_part = part;
+ md->parent = part;
#ifndef GMIME24
debug_task ("detected multipart part");
/* we'll get to finding out if this is a signed/encrypted multipart later... */
if (task->parser_recursion++ < RECURSION_LIMIT) {
g_mime_multipart_foreach ((GMimeMultipart *) part,
mime_foreach_callback,
- task);
+ md);
}
else {
msg_err ("endless recursion detected: %d", task->parser_recursion);
mime_part->type = type;
mime_part->content = part_content;
- mime_part->parent = task->parser_parent_part;
+ mime_part->parent = md->parent;
mime_part->filename = g_mime_part_get_filename (GMIME_PART (
part));
mime_part->mime = part;
debug_task ("found part with content-type: %s/%s",
type->type,
type->subtype);
- task->parts = g_list_prepend (task->parts, mime_part);
+ g_ptr_array_add (task->parts, mime_part);
/* Skip empty parts */
process_text_part (task,
part_content,
type,
mime_part,
- task->parser_parent_part,
+ md->parent,
(part_content->len <= 0));
}
else {
GList *first, *cur;
GMimePart *part;
GMimeDataWrapper *wrapper;
+ struct mime_foreach_data md;
struct received_header *recv;
gchar *mid, *url_str;
const gchar *url_end, *p, *end;
task->message_id = "undef";
}
- /*
- * XXX: we use this strange value to save bytes in the task for
- * saving foreach recursion
- */
- task->scan_milliseconds = 0;
+ memset (&md, 0, sizeof (md));
+ md.task = task;
#ifdef GMIME24
- g_mime_message_foreach (message, mime_foreach_callback, task);
+ g_mime_message_foreach (message, mime_foreach_callback, &md);
#else
/*
* This is rather strange, but gmime 2.2 do NOT pass top-level part to foreach callback
* so we need to set up parent part by hands
*/
- task->parser_parent_part = g_mime_message_get_mime_part (message);
- g_object_unref (task->parser_parent_part);
- g_mime_message_foreach_part (message, mime_foreach_callback, task);
+ md.parent = g_mime_message_get_mime_part (message);
+ g_object_unref (md.parent);
+ g_mime_message_foreach_part (message, mime_foreach_callback, &md);
#endif
- task->scan_milliseconds = 0;
- debug_task ("found %d parts in message", task->parts_count);
+ debug_task ("found %ud parts in message", task->parts->len);
if (task->queue_id == NULL) {
task->queue_id = "undef";
}
rspamd_mempool_alloc0 (task->task_pool,
sizeof (struct received_header));
parse_recv_header (task->task_pool, cur->data, recv);
- task->received = g_list_prepend (task->received, recv);
+ g_ptr_array_add (task->received, recv);
cur = g_list_next (cur);
}
/* Extract data from received header if we were not given IP */
if (task->received && (task->flags & RSPAMD_TASK_FLAG_NO_IP)) {
- recv = task->received->data;
+ recv = g_ptr_array_index (task->received, 0);
if (recv->real_ip) {
if (!rspamd_parse_inet_address (&task->from_addr, recv->real_ip)) {
msg_warn ("cannot get IP from received header: '%s'",
rspamd_mempool_add_destructor (task->task_pool,
(rspamd_mempool_destruct_t) destroy_message, task->message);
- /*
- * XXX: we use this strange value to save bytes in the task for
- * saving foreach recursion
- */
- task->scan_milliseconds = 0;
+ memset (&md, 0, sizeof (md));
+ md.task = task;
#ifdef GMIME24
- g_mime_message_foreach (task->message, mime_foreach_callback, task);
+ g_mime_message_foreach (task->message, mime_foreach_callback, &md);
#else
g_mime_message_foreach_part (task->message, mime_foreach_callback,
- task);
+ &md);
#endif
- task->scan_milliseconds = 0;
/* Generate message ID */
mid = g_mime_utils_generate_message_id ("localhost.localdomain");
rspamd_mempool_add_destructor (task->task_pool,
g_mime_message_set_message_id (task->message, mid);
task->message_id = mid;
task->queue_id = mid;
+
/* Set headers for message */
if (task->subject) {
g_mime_message_set_subject (task->message, task->subject);
const gchar *in;
gint ret = 0;
GList *cur, *headerlist;
+ guint i;
rspamd_regexp_t *regexp;
struct url_regexp_param callback_param = {
.task = task,
break;
case REGEXP_MIME:
/* Iterate throught text parts */
- cur = g_list_first (task->text_parts);
- while (cur) {
- part = (struct mime_text_part *)cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
+
/* Skip empty parts */
if (IS_PART_EMPTY (part)) {
- cur = g_list_next (cur);
continue;
}
if (!re->is_multiple && ret) {
break;
}
-
- cur = g_list_next (cur);
}
-
break;
case REGEXP_MESSAGE:
raw = TRUE;
{
gint threshold, threshold2 = -1, diff;
struct mime_text_part *p1, *p2;
- GList *cur;
struct expression_argument *arg;
GMimeObject *parent;
const GMimeContentType *ct;
}
}
- if (g_list_length (task->text_parts) == 2) {
- cur = g_list_first (task->text_parts);
- p1 = cur->data;
- cur = g_list_next (cur);
+ if (task->text_parts->len == 2) {
+ p1 = g_ptr_array_index (task->text_parts, 0);
+ p2 = g_ptr_array_index (task->text_parts, 1);
pdiff = rspamd_mempool_alloc (task->task_pool, sizeof (gint));
*pdiff = -1;
- if (cur == NULL) {
- msg_info ("bad parts list");
- return FALSE;
- }
- p2 = cur->data;
/* First of all check parent object */
if (p1->parent && p1->parent == p2->parent) {
parent = p1->parent;
void *unused)
{
struct mime_text_part *p;
- GList *cur;
gboolean res = FALSE;
- cur = g_list_first (task->text_parts);
- while (cur) {
- p = cur->data;
+ if (task->text_parts->len == 1) {
+ p = g_ptr_array_index (task->text_parts, 0);
+
if (IS_PART_HTML (p)) {
res = TRUE;
}
else {
res = FALSE;
- break;
}
- cur = g_list_next (cur);
}
return res;
rspamd_is_html_balanced (struct rspamd_task * task, GArray * args, void *unused)
{
struct mime_text_part *p;
- GList *cur;
+ guint i;
gboolean res = TRUE;
- cur = g_list_first (task->text_parts);
- while (cur) {
- p = cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+
+ p = g_ptr_array_index (task->text_parts, i);
if (!IS_PART_EMPTY (p) && IS_PART_HTML (p)) {
if (p->flags & RSPAMD_MIME_PART_FLAG_BALANCED) {
res = TRUE;
break;
}
}
- cur = g_list_next (cur);
}
return res;
rspamd_has_html_tag (struct rspamd_task * task, GArray * args, void *unused)
{
struct mime_text_part *p;
- GList *cur;
struct expression_argument *arg;
struct html_tag *tag;
+ guint i;
gboolean res = FALSE;
struct html_callback_data cd;
return FALSE;
}
- cur = g_list_first (task->text_parts);
cd.res = &res;
cd.tag = tag;
- while (cur && res == FALSE) {
- p = cur->data;
+ for (i = 0; i < task->text_parts->len && res; i ++) {
+ p = g_ptr_array_index (task->text_parts, i);
+
if (!IS_PART_EMPTY (p) && IS_PART_HTML (p) && p->html_nodes) {
g_node_traverse (p->html_nodes,
G_PRE_ORDER,
search_html_node_callback,
&cd);
}
- cur = g_list_next (cur);
}
return res;
rspamd_has_fake_html (struct rspamd_task * task, GArray * args, void *unused)
{
struct mime_text_part *p;
- GList *cur;
+ guint i;
gboolean res = FALSE;
- cur = g_list_first (task->text_parts);
+ for (i = 0; i < task->text_parts->len && res; i ++) {
+ p = g_ptr_array_index (task->text_parts, i);
- while (cur && res == FALSE) {
- p = cur->data;
if (!IS_PART_EMPTY (p) && IS_PART_HTML (p) && p->html_nodes == NULL) {
res = TRUE;
}
- cur = g_list_next (cur);
}
return res;
GMimeObject *part;
GMimeContentType *ct;
gint r;
+ guint i;
gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
struct mime_part *cur_part;
if (args == NULL || args->len < 2) {
param_name = arg->data;
arg_pattern = &g_array_index (args, struct expression_argument, 1);
-
- part = g_mime_message_get_mime_part (task->message);
- if (part) {
+ for (i = 0; i < task->text_parts->len; i ++) {
+ cur_part = g_ptr_array_index (task->text_parts, i);
+ part = cur_part->mime;
ct = (GMimeContentType *)g_mime_object_get_content_type (part);
+
if (args->len >= 3) {
arg1 = &g_array_index (args, struct expression_argument, 2);
if (g_ascii_strncasecmp (arg1->data, "true",
- sizeof ("true") - 1) == 0) {
+ sizeof ("true") - 1) == 0) {
recursive = TRUE;
}
}
recursive = TRUE;
}
}
-
- if (recursive) {
- cur = task->parts;
- }
-
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;; ) {
- if ((param_data =
+
+ if ((param_data =
g_mime_content_type_get_parameter ((GMimeContentType *)ct,
- param_name)) == NULL) {
- result = FALSE;
- }
- else {
- if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
- re = arg_pattern->data;
-
- if ((r = rspamd_task_re_cache_check (task,
- rspamd_regexp_get_pattern (re))) == -1) {
- r = rspamd_regexp_search (re, param_data, 0,
- NULL, NULL, FALSE, NULL);
- rspamd_task_re_cache_add (task,
- rspamd_regexp_get_pattern (re), r);
- }
- }
- else {
- /* Just do strcasecmp */
- if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
- return TRUE;
- }
- }
- }
- /* Get next part */
- if (!recursive) {
- return result;
- }
- else if (cur != NULL) {
- cur_part = cur->data;
- if (cur_part->type != NULL) {
- ct = cur_part->type;
+ param_name)) == NULL) {
+ result = FALSE;
+ }
+ else {
+ if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
+ re = arg_pattern->data;
+
+ if ((r = rspamd_task_re_cache_check (task,
+ rspamd_regexp_get_pattern (re))) == -1) {
+ r = rspamd_regexp_search (re, param_data, 0,
+ NULL, NULL, FALSE, NULL);
+ rspamd_task_re_cache_add (task,
+ rspamd_regexp_get_pattern (re), r);
}
- cur = g_list_next (cur);
}
else {
- /* All is done */
- return result;
+ /* Just do strcasecmp */
+ if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
+ return TRUE;
+ }
}
}
+ /* Get next part */
+ if (!recursive) {
+ break;
+ }
}
return FALSE;
GMimeObject *part;
GMimeContentType *ct;
gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
+ guint i;
struct mime_part *cur_part;
if (args == NULL || args->len < 1) {
g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
param_name = arg->data;
- part = g_mime_message_get_mime_part (task->message);
- if (part) {
+ for (i = 0; i < task->text_parts->len; i ++) {
+ cur_part = g_ptr_array_index (task->text_parts, i);
+ part = cur_part->mime;
ct = (GMimeContentType *)g_mime_object_get_content_type (part);
+
if (args->len >= 2) {
arg1 = &g_array_index (args, struct expression_argument, 2);
if (g_ascii_strncasecmp (arg1->data, "true",
}
}
- if (recursive) {
- cur = task->parts;
- }
-
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;; ) {
- if ((param_data =
+ if ((param_data =
g_mime_content_type_get_parameter ((GMimeContentType *)ct,
- param_name)) != NULL) {
- return TRUE;
- }
- /* Get next part */
- if (!recursive) {
- return result;
- }
- else if (cur != NULL) {
- cur_part = cur->data;
- if (cur_part->type != NULL) {
- ct = cur_part->type;
- }
- cur = g_list_next (cur);
- }
- else {
- /* All is done */
- return result;
- }
+ param_name)) != NULL) {
+ return TRUE;
+ }
+ /* Get next part */
+ if (!recursive) {
+ break;
}
-
}
- return TRUE;
+ return result;
}
static gboolean
GMimeObject *part;
GMimeContentType *ct;
gint r;
- gboolean recursive = FALSE, result = FALSE;
- GList *cur = NULL;
+ guint i;
+ gboolean recursive = FALSE;
struct mime_part *cur_part;
- if (args == NULL) {
+ if (args == NULL || args->len < 1) {
msg_warn ("no parameters to function");
return FALSE;
}
+
arg_pattern = &g_array_index (args, struct expression_argument, 0);
- part = g_mime_message_get_mime_part (task->message);
- if (part) {
+ for (i = 0; i < task->text_parts->len; i ++) {
+ cur_part = g_ptr_array_index (task->text_parts, i);
+ part = cur_part->mime;
ct = (GMimeContentType *)g_mime_object_get_content_type (part);
+
if (args->len >= 2) {
arg1 = &g_array_index (args, struct expression_argument, 1);
if (g_ascii_strncasecmp (arg1->data, "true",
}
}
- if (recursive) {
- cur = task->parts;
- }
-
#ifndef GMIME24
g_object_unref (part);
#endif
- for (;;) {
-
- if (check_subtype) {
- param_data = ct->subtype;
- }
- else {
- param_data = ct->type;
- }
+ if (check_subtype) {
+ param_data = ct->subtype;
+ }
+ else {
+ param_data = ct->type;
+ }
- if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
- re = arg_pattern->data;
+ if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
+ re = arg_pattern->data;
- if ((r = rspamd_task_re_cache_check (task,
- rspamd_regexp_get_pattern (re))) == -1) {
- r = rspamd_regexp_search (re, param_data, 0,
- NULL, NULL, FALSE, NULL);
- rspamd_task_re_cache_add (task,
- rspamd_regexp_get_pattern (re), r);
- }
- }
- else {
- /* Just do strcasecmp */
- if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
- return TRUE;
- }
- }
- /* Get next part */
- if (!recursive) {
- return result;
- }
- else if (cur != NULL) {
- cur_part = cur->data;
- if (cur_part->type != NULL) {
- ct = cur_part->type;
- }
- cur = g_list_next (cur);
+ if ((r = rspamd_task_re_cache_check (task,
+ rspamd_regexp_get_pattern (re))) == -1) {
+ r = rspamd_regexp_search (re, param_data, 0,
+ NULL, NULL, FALSE, NULL);
+ rspamd_task_re_cache_add (task,
+ rspamd_regexp_get_pattern (re), r);
}
- else {
- /* All is done */
- return result;
+ }
+ else {
+ /* Just do strcasecmp */
+ if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
+ return TRUE;
}
}
+ /* Get next part */
+ if (!recursive) {
+ break;
+ }
}
return FALSE;
{
rspamd_regexp_t *re;
struct mime_part *part;
- GList *cur;
GMimeContentType *ct;
gint r;
+ guint i;
- cur = g_list_first (task->parts);
- while (cur) {
- part = cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
ct = part->type;
+
if (ct == NULL) {
- cur = g_list_next (cur);
continue;
}
}
}
}
- cur = g_list_next (cur);
}
return FALSE;
cd->log_size - cd->log_offset,
"]), len: %z, time: %s,",
task->msg.len,
- calculate_check_time (task->time_real, task->time_virtual,
- task->cfg->clock_res,
- &task->scan_milliseconds));
+ rspamd_log_check_time (task->time_real, task->time_virtual,
+ task->cfg->clock_res));
}
gboolean
static void
write_hashes_to_log (struct rspamd_task *task, GString *logbuf)
{
- GList *cur;
struct mime_text_part *text_part;
+ guint i;
- cur = task->text_parts;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ text_part = g_ptr_array_index (task->text_parts, i);
- while (cur) {
- text_part = cur->data;
if (text_part->fuzzy) {
- if (cur->next != NULL) {
+ if (i != task->text_parts->len - 1) {
rspamd_printf_gstring (logbuf,
" part: %Xd,",
text_part->fuzzy->h);
text_part->fuzzy->h);
}
}
- cur = g_list_next (cur);
}
}
rspamd_printf_gstring (logbuf, "]), len: %z, time: %s, dns req: %d,",
task->msg.len,
- calculate_check_time (task->time_real,
+ rspamd_log_check_time (task->time_real,
task->time_virtual,
- task->cfg->clock_res,
- &task->scan_milliseconds),
+ task->cfg->clock_res),
task->dns_requests);
}
}
}
- row->scan_time = task->scan_milliseconds;
+ row->scan_time = rspamd_get_ticks () - task->time_real;
row->len = task->msg.len;
row->completed = TRUE;
}
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->pre_result.action = METRIC_ACTION_NOACTION;
void
rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
{
- GList *part;
struct mime_part *p;
struct mime_text_part *tp;
+ guint i;
if (task) {
debug_task ("free pointer %p", task);
- while ((part = g_list_first (task->parts))) {
- task->parts = g_list_remove_link (task->parts, part);
- p = (struct mime_part *) part->data;
+
+ for (i = 0; i < task->parts->len; i ++) {
+ p = g_ptr_array_index (task->parts, i);
g_byte_array_free (p->content, TRUE);
- g_list_free_1 (part);
}
- if (task->text_parts) {
- part = task->text_parts;
- while (part) {
- tp = (struct mime_text_part *)part->data;
- if (tp->words) {
- g_array_free (tp->words, TRUE);
- }
- if (tp->normalized_words) {
- g_array_free (tp->normalized_words, TRUE);
- }
- part = g_list_next (part);
- }
- g_list_free (task->text_parts);
+ for (i = 0; i < task->text_parts->len; i ++) {
+ tp = g_ptr_array_index (task->text_parts, i);
+ if (tp->words) {
+ g_array_free (tp->words, TRUE);
+ }
+ if (tp->normalized_words) {
+ g_array_free (tp->normalized_words, TRUE);
+ }
}
+
if (task->images) {
g_list_free (task->images);
}
+
if (task->messages) {
g_list_free (task->messages);
}
- if (task->received) {
- g_list_free (task->received);
- }
+
if (task->http_conn != NULL) {
rspamd_http_connection_unref (task->http_conn);
}
+
if (task->sock != -1) {
close (task->sock);
}
+
if (task->settings != NULL) {
ucl_object_unref (task->settings);
}
+
if (task->client_addr) {
rspamd_inet_address_destroy (task->client_addr);
}
+
if (task->from_addr) {
rspamd_inet_address_destroy (task->from_addr);
}
+
if (task->err) {
g_error_free (task->err);
}
* Worker task structure
*/
struct rspamd_task {
- struct rspamd_worker *worker; /**< pointer to worker object */
- struct custom_command *custom_cmd; /**< custom command if any */
- guint processed_stages; /**< bits of stages that are processed */
- enum rspamd_command cmd; /**< command */
- gint sock; /**< socket descriptor */
- guint flags; /**< Bit flags */
- guint message_len; /**< Message length */
-
- gchar *helo; /**< helo header value */
- gchar *queue_id; /**< queue id if specified */
- const gchar *message_id; /**< message id */
-
- rspamd_inet_addr_t *from_addr; /**< from addr for a task */
- rspamd_inet_addr_t *client_addr; /**< address of connected socket */
- gchar *deliver_to; /**< address to deliver */
- gchar *user; /**< user to deliver */
- gchar *subject; /**< subject (for non-mime) */
- gchar *hostname; /**< hostname reported by MTA */
- GHashTable *request_headers; /**< HTTP headers in a request */
- GHashTable *reply_headers; /**< Custom reply headers */
+ struct rspamd_worker *worker; /**< pointer to worker object */
+ struct custom_command *custom_cmd; /**< custom command if any */
+ guint processed_stages; /**< bits of stages that are processed */
+ enum rspamd_command cmd; /**< command */
+ gint sock; /**< socket descriptor */
+ guint flags; /**< Bit flags */
+ guint message_len; /**< Message length */
+ guint32 dns_requests; /**< number of DNS requests per this task */
+ gchar *helo; /**< helo header value */
+ gchar *queue_id; /**< queue id if specified */
+ const gchar *message_id; /**< message id */
+ rspamd_inet_addr_t *from_addr; /**< from addr for a task */
+ rspamd_inet_addr_t *client_addr; /**< address of connected socket */
+ gchar *deliver_to; /**< address to deliver */
+ gchar *user; /**< user to deliver */
+ gchar *subject; /**< subject (for non-mime) */
+ gchar *hostname; /**< hostname reported by MTA */
+ GHashTable *request_headers; /**< HTTP headers in a request */
+ GHashTable *reply_headers; /**< Custom reply headers */
struct {
const gchar *start;
gsize len;
- } msg; /**< message buffer */
- struct rspamd_http_connection *http_conn; /**< HTTP server connection */
- struct rspamd_async_session * s; /**< async session object */
- gint parts_count; /**< mime parts count */
- GMimeMessage *message; /**< message, parsed with GMime */
- GMimeObject *parser_parent_part; /**< current parent part */
- GList *parts; /**< list of parsed parts */
- GList *text_parts; /**< list of text parts */
- rspamd_fstring_t raw_headers_content; /**< list of raw headers */
- GList *received; /**< list of received headers */
- GHashTable *urls; /**< list of parsed urls */
- GHashTable *emails; /**< list of parsed emails */
- GList *images; /**< list of images */
- GHashTable *raw_headers; /**< list of raw headers */
- GHashTable *results; /**< hash table of metric_result indexed by
- * metric's name */
- GHashTable *tokens; /**< hash table of tokens indexed by tokenizer
- * pointer */
-
- InternetAddressList *rcpt_mime; /**< list of all recipients */
- InternetAddressList *rcpt_envelope; /**< list of all recipients */
+ } msg; /**< message buffer */
+ struct rspamd_http_connection *http_conn; /**< HTTP server connection */
+ struct rspamd_async_session * s; /**< async session object */
+ GMimeMessage *message; /**< message, parsed with GMime */
+ GPtrArray *parts; /**< list of parsed parts */
+ GPtrArray *text_parts; /**< list of text parts */
+ rspamd_fstring_t raw_headers_content; /**< list of raw headers */
+ GPtrArray *received; /**< list of received headers */
+ GHashTable *urls; /**< list of parsed urls */
+ GHashTable *emails; /**< list of parsed emails */
+ GList *images; /**< list of images */
+ GHashTable *raw_headers; /**< list of raw headers */
+ GHashTable *results; /**< hash table of metric_result indexed by
+ * metric's name */
+ GHashTable *tokens; /**< hash table of tokens indexed by tokenizer
+ * pointer */
+ InternetAddressList *rcpt_mime; /**< list of all recipients */
+ InternetAddressList *rcpt_envelope; /**< list of all recipients */
InternetAddressList *from_mime;
InternetAddressList *from_envelope;
- GList *messages; /**< list of messages that would be reported */
- GHashTable *re_cache; /**< cache for matched or not matched regexps */
- struct rspamd_config *cfg; /**< pointer to config object */
+ GList *messages; /**< list of messages that would be reported */
+ GHashTable *re_cache; /**< cache for matched or not matched regexps */
+ struct rspamd_config *cfg; /**< pointer to config object */
GError *err;
- rspamd_mempool_t *task_pool; /**< memory pool for task */
+ rspamd_mempool_t *task_pool; /**< memory pool for task */
double time_real;
double time_virtual;
struct timeval tv;
- guint32 scan_milliseconds; /**< how much milliseconds passed */
- gboolean (*fin_callback)(struct rspamd_task *task, void *arg); /**< calback for filters finalizing */
- void *fin_arg; /**< argument for fin callback */
-
- guint32 dns_requests; /**< number of DNS requests per this task */
+ gboolean (*fin_callback)(struct rspamd_task *task, void *arg);
+ /**< calback for filters finalizing */
+ void *fin_arg; /**< argument for fin callback */
- struct rspamd_dns_resolver *resolver; /**< DNS resolver */
- struct event_base *ev_base; /**< Event base */
+ struct rspamd_dns_resolver *resolver; /**< DNS resolver */
+ struct event_base *ev_base; /**< Event base */
- gpointer checkpoint; /**< Opaque checkpoint data */
+ gpointer checkpoint; /**< Opaque checkpoint data */
struct {
- enum rspamd_metric_action action; /**< Action of pre filters */
- gchar *str; /**< String describing action */
- } pre_result; /**< Result of pre-filters */
+ enum rspamd_metric_action action; /**< Action of pre filters */
+ gchar *str; /**< String describing action */
+ } pre_result; /**< Result of pre-filters */
- ucl_object_t *settings; /**< Settings applied to task */
+ ucl_object_t *settings; /**< Settings applied to task */
};
/**
blake2b_state st;
rspamd_fstring_t *word;
guchar out[BLAKE2B_OUTBYTES];
- GList *cur;
- guint i;
+ guint i, j;
if (ctx != NULL && ctx->db != NULL) {
blake2b_init (&st, sizeof (out));
- cur = task->text_parts;
- while (cur) {
- part = (struct mime_text_part *)cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
if (part->words != NULL) {
- for (i = 0; i < part->words->len; i ++) {
- word = &g_array_index (part->words, rspamd_fstring_t, i);
+ for (j = 0; j < part->words->len; j ++) {
+ word = &g_array_index (part->words, rspamd_fstring_t, j);
blake2b_update (&st, word->begin, word->len);
}
}
-
- cur = g_list_next (cur);
}
blake2b_final (&st, out, sizeof (out));
struct mime_text_part *part;
GArray *words;
gchar *sub;
- GList *cur;
-
- cur = task->text_parts;
+ guint i;
- while (cur != NULL) {
- part = (struct mime_text_part *)cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
if (!IS_PART_EMPTY (part) && part->words != NULL) {
if (compat) {
part->normalized_words, tok->tokens, IS_PART_UTF (part));
}
}
-
- cur = g_list_next (cur);
}
if (task->subject != NULL) {
}
const gchar *
-calculate_check_time (gdouble start_real, gdouble start_virtual, gint resolution,
- guint32 *scan_time)
+rspamd_log_check_time (gdouble start_real, gdouble start_virtual, gint resolution)
{
double vdiff, diff, end_real, end_virtual;
static gchar res[64];
vdiff = (end_virtual - start_virtual) * 1000;
diff = (end_real - start_real) * 1000;
- *scan_time = diff;
-
sprintf (fmt, "%%.%dfms real, %%.%dfms virtual", resolution, resolution);
snprintf (res, sizeof (res), fmt, diff, vdiff);
gchar *from);
const gchar *
-calculate_check_time (gdouble start_real, gdouble start_virtual, gint resolution,
- guint32 *scan_time);
+rspamd_log_check_time (gdouble start_real, gdouble start_virtual, gint resolution);
/*
* File locking functions
static gint
lua_task_get_text_parts (lua_State * L)
{
- gint i = 1;
+ guint i;
struct rspamd_task *task = lua_check_task (L, 1);
- GList *cur;
struct mime_text_part *part, **ppart;
if (task != NULL) {
lua_newtable (L);
- cur = task->text_parts;
- while (cur) {
- part = cur->data;
+
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
ppart = lua_newuserdata (L, sizeof (struct mime_text_part *));
*ppart = part;
rspamd_lua_setclass (L, "rspamd{textpart}", -1);
/* Make it array */
- lua_rawseti (L, -2, i++);
- cur = g_list_next (cur);
+ lua_rawseti (L, -2, i + 1);
}
+
return 1;
}
lua_pushnil (L);
static gint
lua_task_get_parts (lua_State * L)
{
- gint i = 1;
+ guint i;
struct rspamd_task *task = lua_check_task (L, 1);
- GList *cur;
struct mime_part *part, **ppart;
if (task != NULL) {
lua_newtable (L);
- cur = task->parts;
- while (cur) {
- part = cur->data;
+
+ for (i = 0; i < task->parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
ppart = lua_newuserdata (L, sizeof (struct mime_part *));
*ppart = part;
rspamd_lua_setclass (L, "rspamd{mimepart}", -1);
/* Make it array */
- lua_rawseti (L, -2, i++);
- cur = g_list_next (cur);
+ lua_rawseti (L, -2, i + 1);
}
return 1;
}
lua_task_get_received_headers (lua_State * L)
{
struct rspamd_task *task = lua_check_task (L, 1);
- GList *cur;
struct received_header *rh;
- gint i = 1;
+ guint i;
if (task) {
lua_newtable (L);
- cur = g_list_first (task->received);
- while (cur) {
- rh = cur->data;
+
+ for (i = 0; i < task->received->len; i ++) {
+ rh = g_ptr_array_index (task->received, i);
+
if (rh->is_error || G_UNLIKELY (
rh->from_ip == NULL &&
rh->real_ip == NULL &&
rh->real_hostname == NULL &&
rh->by_hostname == NULL)) {
- cur = g_list_next (cur);
continue;
}
+
lua_newtable (L);
rspamd_lua_table_set (L, "from_hostname", rh->from_hostname);
lua_pushstring (L, "from_ip");
rspamd_lua_ip_push_fromstring (L, rh->real_ip);
lua_settable (L, -3);
rspamd_lua_table_set (L, "by_hostname", rh->by_hostname);
- lua_rawseti (L, -2, i++);
- cur = g_list_next (cur);
+ lua_rawseti (L, -2, i + 1);
}
}
else {
ac_trie_t *trie = lua_check_trie (L, 1);
struct rspamd_task *task = lua_check_task (L, 2);
struct mime_text_part *part;
- GList *cur;
const gchar *text;
gint state = 0;
- gsize len;
+ gsize len, i;
gboolean found = FALSE;
if (trie) {
- cur = task->text_parts;
-
- while (cur) {
- part = cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
if (!IS_PART_EMPTY (part) && part->content != NULL) {
text = part->content->data;
found = TRUE;
}
}
-
- cur = g_list_next (cur);
}
}
static void
chartable_symbol_callback (struct rspamd_task *task, void *unused)
{
- GList *cur;
+ guint i;
struct mime_text_part *part;
- cur = g_list_first (task->text_parts);
- while (cur) {
- part = cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
+
if (!IS_PART_EMPTY (part) && check_part (part, task->cfg->raw_mode)) {
rspamd_task_insert_result (task, chartable_module_ctx->symbol, 1, NULL);
}
- cur = g_list_next (cur);
}
}
struct rspamd_image *image;
struct rspamd_fuzzy_cmd *cmd;
gsize hashlen;
- GList *cur;
+ guint i;
GPtrArray *res;
- cur = task->text_parts;
res = g_ptr_array_new ();
- while (cur) {
- part = cur->data;
+ for (i = 0; i < task->text_parts->len; i ++) {
+ part = g_ptr_array_index (task->text_parts, i);
+
if (IS_PART_EMPTY (part)) {
- cur = g_list_next (cur);
continue;
}
if (fuzzy_module_ctx->min_bytes > part->content->len) {
msg_info ("<%s>, part is shorter than %d symbols, skip fuzzy check",
task->message_id, fuzzy_module_ctx->min_bytes);
- cur = g_list_next (cur);
continue;
}
/* Check length of hash */
hashlen = strlen (part->fuzzy->hash_pipe);
+
if (hashlen == 0) {
msg_info ("<%s>, part hash empty, skip fuzzy check",
task->message_id, fuzzy_module_ctx->min_hash_len);
- cur = g_list_next (cur);
continue;
}
+
if (fuzzy_module_ctx->min_hash_len != 0 &&
hashlen * part->fuzzy->block_size <
fuzzy_module_ctx->min_hash_len) {
"<%s>, part hash is shorter than %d symbols, skip fuzzy check",
task->message_id,
fuzzy_module_ctx->min_hash_len);
- cur = g_list_next (cur);
continue;
}
if (cmd) {
g_ptr_array_add (res, cmd);
}
-
- cur = g_list_next (cur);
}
+
/* Process images */
+ GList *cur;
+
cur = task->images;
while (cur) {
image = cur->data;
}
cur = g_list_next (cur);
}
+
/* Process other parts */
- cur = task->parts;
- while (cur) {
- mime_part = cur->data;
+ for (i = 0; i < task->parts->len; i ++) {
+ mime_part = g_ptr_array_index (task->parts, i);
+
if (mime_part->content->len > 0 &&
fuzzy_check_content_type (rule, mime_part->type)) {
if (fuzzy_module_ctx->min_bytes <= 0 || mime_part->content->len >=
}
}
}
- cur = g_list_next (cur);
}
if (res->len == 0) {
projects / rspamd.git / commitdiff