#include "message.h"
#include "task.h"
#include "archives.h"
+#include "fstring.h"
static void
rspamd_archive_dtor (gpointer p)
struct rspamd_archive_file *f;
/* Zip files have interesting data at the end of archive */
- p = part->content->data + part->content->len - 1;
- start = part->content->data;
+ p = part->parsed_data.begin + part->parsed_data.len - 1;
+ start = part->parsed_data.begin;
end = p;
/* Search for EOCD:
if (eocd == NULL) {
/* Not a zip file */
- msg_debug_task ("zip archive is invalid (no EOCD): %s", part->filename);
+ msg_debug_task ("zip archive is invalid (no EOCD)");
return;
}
if (end - eocd < 21) {
- msg_debug_task ("zip archive is invalid (short EOCD): %s", part->filename);
+ msg_debug_task ("zip archive is invalid (short EOCD)");
return;
}
/* We need to check sanity as well */
if (cd_offset + cd_size != (guint)(eocd - start)) {
- msg_debug_task ("zip archive is invalid (bad size/offset for CD): %s",
- part->filename);
+ msg_debug_task ("zip archive is invalid (bad size/offset for CD)");
return;
}
/* Read central directory record */
if (eocd - cd < cd_basic_len ||
memcmp (cd, cd_magic, sizeof (cd_magic)) != 0) {
- msg_debug_task ("zip archive is invalid (bad cd record): %s",
- part->filename);
+ msg_debug_task ("zip archive is invalid (bad cd record)");
return;
}
comment_len = GUINT16_FROM_LE (comment_len);
if (cd + fname_len + comment_len + extra_len + cd_basic_len > eocd) {
- msg_debug_task ("zip archive is invalid (too large cd record): %s",
- part->filename);
+ msg_debug_task ("zip archive is invalid (too large cd record)");
return;
}
}
part->flags |= RSPAMD_MIME_PART_ARCHIVE;
- part->specific_data = arch;
- arch->archive_name = part->filename;
- arch->size = part->content->len;
+ part->specific.arch = arch;
+
+ if (part->cd) {
+ arch->archive_name = &part->cd->filename;
+ }
+
+ arch->size = part->parsed_data.len;
}
static inline gint
#define RAR_SKIP_BYTES(n) do { \
if ((n) <= 0) { \
- msg_debug_task ("rar archive is invalid (bad skip value): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (bad skip value)"); \
return; \
} \
if ((gsize)(end - p) < (n)) { \
- msg_debug_task ("rar archive is invalid (truncated): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (truncated)"); \
return; \
} \
p += (n); \
#define RAR_READ_VINT() do { \
r = rspamd_archive_rar_read_vint (p, end - p, &vint); \
if (r == -1) { \
- msg_debug_task ("rar archive is invalid (bad vint): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (bad vint)"); \
return; \
} \
else if (r == 0) { \
- msg_debug_task ("rar archive is invalid (BAD vint offset): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (BAD vint offset)"); \
return; \
}\
} while (0)
#define RAR_READ_VINT_SKIP() do { \
r = rspamd_archive_rar_read_vint (p, end - p, &vint); \
if (r == -1) { \
- msg_debug_task ("rar archive is invalid (bad vint): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (bad vint)"); \
return; \
} \
p += r; \
#define RAR_READ_UINT16(n) do { \
if (end - p < (glong)sizeof (guint16)) { \
- msg_debug_task ("rar archive is invalid (bad int16): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (bad int16)"); \
return; \
} \
n = p[0] + (p[1] << 8); \
#define RAR_READ_UINT32(n) do { \
if (end - p < (glong)sizeof (guint32)) { \
- msg_debug_task ("rar archive is invalid (bad int32): %s", part->filename); \
+ msg_debug_task ("rar archive is invalid (bad int32)"); \
return; \
} \
n = p[0] + (p[1] << 8) + (p[2] << 16) + (p[3] << 24); \
if (sz == 0) {
/* Zero sized block - error */
- msg_debug_task ("rar archive is invalid (zero size block): %s",
- part->filename);
+ msg_debug_task ("rar archive is invalid (zero size block)");
return;
}
RAR_READ_UINT16 (fname_len);
if (fname_len == 0 || fname_len > (gsize)(end - p)) {
- msg_debug_task ("rar archive is invalid (bad fileame size): %s", part->filename);
+ msg_debug_task ("rar archive is invalid (bad fileame size)");
return;
}
end:
part->flags |= RSPAMD_MIME_PART_ARCHIVE;
- part->specific_data = arch;
- arch->archive_name = part->filename;
- arch->size = part->content->len;
+ part->specific.arch = arch;
+ arch->archive_name = &part->cd->filename;
+ arch->size = part->parsed_data.len;
}
static void
struct rspamd_archive_file *f;
gint r;
- p = part->content->data;
- end = p + part->content->len;
+ p = part->parsed_data.begin;
+ end = p + part->parsed_data.len;
if ((gsize)(end - p) <= sizeof (rar_v5_magic)) {
- msg_debug_task ("rar archive is invalid (too small): %s", part->filename);
+ msg_debug_task ("rar archive is invalid (too small)");
return;
}
return;
}
else {
- msg_debug_task ("rar archive is invalid (no rar magic): %s", part->filename);
+ msg_debug_task ("rar archive is invalid (no rar magic)");
return;
}
goto end;
}
else if (type != rar_main_header) {
- msg_debug_task ("rar archive is invalid (bad main header): %s",
- part->filename);
+ msg_debug_task ("rar archive is invalid (bad main header)");
return;
}
sz = vint;
if (sz == 0) {
/* Zero sized block - error */
- msg_debug_task ("rar archive is invalid (zero size block): %s",
- part->filename);
+ msg_debug_task ("rar archive is invalid (zero size block)");
return;
}
fname_len = vint;
if (fname_len == 0 || fname_len > (gsize)(end - p)) {
- msg_debug_task ("rar archive is invalid (bad fileame size): %s", part->filename);
+ msg_debug_task ("rar archive is invalid (bad fileame size)");
return;
}
}
end:
- part->flags |= RSPAMD_MIME_PART_ARCHIVE;
- part->specific_data = arch;
- arch->archive_name = part->filename;
- arch->size = part->content->len;
+part->flags |= RSPAMD_MIME_PART_ARCHIVE;
+ part->specific.arch = arch;
+ if (part->cd != NULL) {
+ arch->archive_name = &part->cd->filename;
+ }
+ arch->size = part->parsed_data.len;
}
static gboolean
rspamd_archive_cheat_detect (struct rspamd_mime_part *part, const gchar *str,
const guchar *magic_start, gsize magic_len)
{
- GMimeContentType *ct;
- const gchar *fname, *p;
+ struct rspamd_content_type *ct;
+ const gchar *p;
+ rspamd_ftok_t srch, *fname;
- ct = part->type;
+ ct = part->ct;
+ RSPAMD_FTOK_ASSIGN (&srch, "application");
- if (ct && ct->type && ct->subtype && strcmp (ct->type,
- "application") == 0) {
- if (rspamd_substring_search_caseless (ct->subtype, strlen (ct->subtype),
+ if (ct && ct->type.len && ct->subtype.len > 0 && rspamd_ftok_cmp (&ct->type,
+ &srch) == 0) {
+ if (rspamd_substring_search_caseless (ct->subtype.begin, ct->subtype.len,
str, strlen (str)) != -1) {
return TRUE;
}
}
- fname = part->filename;
+ if (part->cd) {
+ fname = &part->cd->filename;
- if (fname && strlen (fname) > strlen (str)) {
- p = fname + strlen (fname) - strlen (str);
+ if (fname && fname->len > strlen (str)) {
+ p = fname->begin + fname->len - strlen (str);
- if (rspamd_lc_cmp (p, str, strlen (str)) == 0) {
- if (*(p - 1) == '.') {
- return TRUE;
+ if (rspamd_lc_cmp (p, str, strlen (str)) == 0) {
+ if (*(p - 1) == '.') {
+ return TRUE;
+ }
}
}
- }
- if (magic_start != NULL) {
- if (part->content->len > magic_len && memcmp (part->content->data,
- magic_start, magic_len) == 0) {
- return TRUE;
+ if (magic_start != NULL) {
+ if (part->parsed_data.len > magic_len && memcmp (part->parsed_data.begin,
+ magic_start, magic_len) == 0) {
+ return TRUE;
+ }
}
}
for (i = 0; i < task->parts->len; i ++) {
part = g_ptr_array_index (task->parts, i);
- if (part->content->len > 0) {
+ if (part->parsed_data.len > 0) {
if (rspamd_archive_cheat_detect (part, "zip",
zip_magic, sizeof (zip_magic))) {
rspamd_archive_process_zip (task, part);
struct rspamd_archive {
enum rspamd_archive_type type;
- const gchar *archive_name;
+ const rspamd_ftok_t *archive_name;
gsize size;
enum rspamd_archive_flags flags;
GPtrArray *files; /* Array of struct rspamd_archive_file */
{
guint i;
struct rspamd_mime_part *part;
+ rspamd_ftok_t srch;
+
+ RSPAMD_FTOK_ASSIGN (&srch, "image");
for (i = 0; i < task->parts->len; i ++) {
part = g_ptr_array_index (task->parts, i);
- if (g_mime_content_type_is_type (part->type, "image", "*") &&
- part->content->len > 0) {
+ if (rspamd_ftok_cmp (&part->ct->type, &srch) == 0 &&
+ part->parsed_data.len > 0) {
process_image (task, part);
}
}
}
static enum rspamd_image_type
-detect_image_type (GByteArray *data)
+detect_image_type (rspamd_ftok_t *data)
{
if (data->len > sizeof (png_signature) / sizeof (png_signature[0])) {
- if (memcmp (data->data, png_signature, sizeof (png_signature)) == 0) {
+ if (memcmp (data->begin, png_signature, sizeof (png_signature)) == 0) {
return IMAGE_TYPE_PNG;
}
}
if (data->len > 10) {
- if (memcmp (data->data, jpg_sig1, sizeof (jpg_sig1)) == 0) {
- if (memcmp (data->data + 2, jpg_sig_jfif, sizeof (jpg_sig_jfif)) == 0 ||
- memcmp (data->data + 2, jpg_sig_exif, sizeof (jpg_sig_exif)) == 0) {
+ if (memcmp (data->begin, jpg_sig1, sizeof (jpg_sig1)) == 0) {
+ if (memcmp (data->begin + 2, jpg_sig_jfif, sizeof (jpg_sig_jfif)) == 0 ||
+ memcmp (data->begin + 2, jpg_sig_exif, sizeof (jpg_sig_exif)) == 0) {
return IMAGE_TYPE_JPG;
}
}
}
if (data->len > sizeof (gif_signature) / sizeof (gif_signature[0])) {
- if (memcmp (data->data, gif_signature, sizeof (gif_signature)) == 0) {
+ if (memcmp (data->begin, gif_signature, sizeof (gif_signature)) == 0) {
return IMAGE_TYPE_GIF;
}
}
if (data->len > sizeof (bmp_signature) / sizeof (bmp_signature[0])) {
- if (memcmp (data->data, bmp_signature, sizeof (bmp_signature)) == 0) {
+ if (memcmp (data->begin, bmp_signature, sizeof (bmp_signature)) == 0) {
return IMAGE_TYPE_BMP;
}
}
static struct rspamd_image *
-process_png_image (struct rspamd_task *task, GByteArray *data)
+process_png_image (struct rspamd_task *task, rspamd_ftok_t *data)
{
struct rspamd_image *img;
guint32 t;
- guint8 *p;
+ const guint8 *p;
if (data->len < 24) {
msg_info_task ("bad png detected (maybe striped)");
/* In png we should find iHDR section and get data from it */
/* Skip signature and read header section */
- p = data->data + 12;
+ p = data->begin + 12;
if (memcmp (p, "IHDR", 4) != 0) {
msg_info_task ("png doesn't begins with IHDR section");
return NULL;
}
static struct rspamd_image *
-process_jpg_image (struct rspamd_task *task, GByteArray *data)
+process_jpg_image (struct rspamd_task *task, rspamd_ftok_t *data)
{
- guint8 *p, *end;
+ const guint8 *p, *end;
guint16 h, w;
struct rspamd_image *img;
img->type = IMAGE_TYPE_JPG;
img->data = data;
- p = data->data;
+ p = data->begin;
end = p + data->len - 8;
p += 2;
}
static struct rspamd_image *
-process_gif_image (struct rspamd_task *task, GByteArray *data)
+process_gif_image (struct rspamd_task *task, rspamd_ftok_t *data)
{
struct rspamd_image *img;
- guint8 *p;
+ const guint8 *p;
guint16 t;
if (data->len < 10) {
img->type = IMAGE_TYPE_GIF;
img->data = data;
- p = data->data + 6;
+ p = data->begin + 6;
memcpy (&t, p, sizeof (guint16));
img->width = GUINT16_FROM_LE (t);
memcpy (&t, p + 2, sizeof (guint16));
}
static struct rspamd_image *
-process_bmp_image (struct rspamd_task *task, GByteArray *data)
+process_bmp_image (struct rspamd_task *task, rspamd_ftok_t *data)
{
struct rspamd_image *img;
gint32 t;
- guint8 *p;
+ const guint8 *p;
if (data->len < 28) {
msg_info_task ("bad bmp detected (maybe striped)");
img = rspamd_mempool_alloc0 (task->task_pool, sizeof (struct rspamd_image));
img->type = IMAGE_TYPE_BMP;
img->data = data;
- p = data->data + 18;
+ p = data->begin + 18;
memcpy (&t, p, sizeof (gint32));
img->width = abs (GINT32_FROM_LE (t));
memcpy (&t, p + 4, sizeof (gint32));
switch (img->type) {
case IMAGE_TYPE_JPG:
- src = gdImageCreateFromJpegPtr (img->data->len, img->data->data);
+ src = gdImageCreateFromJpegPtr (img->data->len, (void *)img->data->begin);
break;
case IMAGE_TYPE_PNG:
- src = gdImageCreateFromPngPtr (img->data->len, img->data->data);
+ src = gdImageCreateFromPngPtr (img->data->len, (void *)img->data->begin);
break;
case IMAGE_TYPE_GIF:
- src = gdImageCreateFromGifPtr (img->data->len, img->data->data);
+ src = gdImageCreateFromGifPtr (img->data->len, (void *)img->data->begin);
break;
case IMAGE_TYPE_BMP:
- src = gdImageCreateFromBmpPtr (img->data->len, img->data->data);
+ src = gdImageCreateFromBmpPtr (img->data->len, (void *)img->data->begin);
break;
default:
return;
guint cid_len, i, j;
GPtrArray *ar;
- if ((type = detect_image_type (part->content)) != IMAGE_TYPE_UNKNOWN) {
+ if ((type = detect_image_type (&part->parsed_data)) != IMAGE_TYPE_UNKNOWN) {
switch (type) {
case IMAGE_TYPE_PNG:
- img = process_png_image (task, part->content);
+ img = process_png_image (task, &part->parsed_data);
break;
case IMAGE_TYPE_JPG:
- img = process_jpg_image (task, part->content);
+ img = process_jpg_image (task, &part->parsed_data);
break;
case IMAGE_TYPE_GIF:
- img = process_gif_image (task, part->content);
+ img = process_gif_image (task, &part->parsed_data);
break;
case IMAGE_TYPE_BMP:
- img = process_bmp_image (task, part->content);
+ img = process_bmp_image (task, &part->parsed_data);
break;
default:
img = NULL;
rspamd_image_type_str (img->type),
img->width, img->height,
task->message_id);
- img->filename = part->filename;
+
+ if (part->cd) {
+ img->filename = &part->cd->filename;
+ }
+
img->parent = part;
if (img->data->len <= task->cfg->max_pic_size) {
img->filename, img->data->len);
}
part->flags |= RSPAMD_MIME_PART_IMAGE;
- part->specific_data = img;
+ part->specific.img = img;
/* Check Content-Id */
ar = rspamd_message_get_header_from_hash (part->raw_headers,
#define IMAGES_H_
#include "config.h"
+#include "fstring.h"
struct html_image;
struct rspamd_task;
struct rspamd_image {
struct rspamd_mime_part *parent;
- GByteArray *data;
- const gchar *filename;
+ rspamd_ftok_t *data;
+ rspamd_ftok_t *filename;
struct html_image *html_image;
enum rspamd_image_type type;
guint32 width;
GPtrArray *hdrs;
struct rspamd_mime_header *rh;
struct rspamd_mime_text_part *p1, *p2;
- struct mime_foreach_data md;
struct received_header *recv, *trecv;
const gchar *p;
gsize len;
if (!rspamd_mime_parse_task (task, &err)) {
msg_err_task ("cannot construct mime from stream: %e", err);
- if (err) {
- g_error_free (err);
- }
if (task->cfg && (!task->cfg->allow_raw_input)) {
msg_err_task ("cannot construct mime from stream");
- g_set_error (&task->err,
- rspamd_message_quark (),
- RSPAMD_FILTER_ERROR, \
+ if (err) {
+ task->err = err;
+ }
- "cannot parse MIME in the message");
return FALSE;
}
else {
else {
GString str;
- str.str = p;
+ str.str = (gchar *)p;
str.len = len;
hdr_pos = rspamd_string_find_eoh (&str, &body_pos);
task->message_id = "undef";
}
- memset (&md, 0, sizeof (md));
- md.task = task;
-
debug_task ("found %ud parts in message", task->parts->len);
if (task->queue_id == NULL) {
task->queue_id = "undef";
hdrs = rspamd_message_get_header_array (task, to_hdrs[k], FALSE);
if (hdrs && hdrs->len > 0) {
- InternetAddress *tia;
+ InternetAddressList *tia;
for (i = 0; i < hdrs->len; i ++) {
rh = g_ptr_array_index (hdrs, i);
GByteArray *result_array, *part_content;
struct rspamd_mime_part *part = text_part->mime_part;
- part_content = rspamd_mempool_alloc0 (sizeof (GByteArray));
+ part_content = rspamd_mempool_alloc0 (task->task_pool, sizeof (GByteArray));
part_content->data = (guint8 *)text_part->parsed.begin;
part_content->len = text_part->parsed.len;
void *unused)
{
/* Check all types of addresses */
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
- GMIME_RECIPIENT_TYPE_TO)) == TRUE) {
- return TRUE;
- }
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
- GMIME_RECIPIENT_TYPE_BCC)) == TRUE) {
- return TRUE;
- }
- if (is_recipient_list_sorted (g_mime_message_get_recipients (task->message,
- GMIME_RECIPIENT_TYPE_CC)) == TRUE) {
- return TRUE;
- }
+
+ /* TODO: fix this function */
return FALSE;
}
GArray * args,
void *unused)
{
- const gchar *param_name;
- const gchar *param_data;
- rspamd_regexp_t *re;
- struct expression_argument *arg, *arg1, *arg_pattern;
- GMimeObject *part;
- GMimeContentType *ct;
- gint r;
- guint i;
- gboolean recursive = FALSE;
- struct rspamd_mime_part *cur_part;
-
- if (args == NULL || args->len < 2) {
- msg_warn_task ("no parameters to function");
- return FALSE;
- }
-
- arg = &g_array_index (args, struct expression_argument, 0);
- g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
- param_name = arg->data;
- arg_pattern = &g_array_index (args, struct expression_argument, 1);
-
- for (i = 0; i < task->parts->len; i ++) {
- cur_part = g_ptr_array_index (task->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) {
- recursive = TRUE;
- }
- }
- else {
- /*
- * If user did not specify argument, let's assume that he wants
- * recursive search if mime part is multipart/mixed
- */
- if (g_mime_content_type_is_type (ct, "multipart", "*")) {
- recursive = TRUE;
- }
- }
-#ifndef GMIME24
- g_object_unref (part);
-#endif
- if ((param_data =
- g_mime_content_type_get_parameter ((GMimeContentType *)ct,
- param_name)) != NULL) {
- if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
- re = arg_pattern->data;
- r = rspamd_regexp_search (re, param_data, 0,
- NULL, NULL, FALSE, NULL);
-
- if (r) {
- return TRUE;
- }
- }
- else {
- /* Just do strcasecmp */
- if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
- return TRUE;
- }
- }
- }
- /* Get next part */
- if (!recursive) {
- break;
- }
- }
+ /* TODO: fix */
+ msg_err_task ("content_type_compare_param is broken XXX");
return FALSE;
}
GArray * args,
void *unused)
{
- gchar *param_name;
- const gchar *param_data;
- struct expression_argument *arg, *arg1;
- GMimeObject *part;
- GMimeContentType *ct;
- gboolean recursive = FALSE, result = FALSE;
- guint i;
- struct rspamd_mime_part *cur_part;
-
- if (args == NULL || args->len < 1) {
- msg_warn_task ("no parameters to function");
- return FALSE;
- }
-
- arg = &g_array_index (args, struct expression_argument, 0);
- g_assert (arg->type == EXPRESSION_ARGUMENT_NORMAL);
- param_name = arg->data;
-
- for (i = 0; i < task->parts->len; i ++) {
- cur_part = g_ptr_array_index (task->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",
- sizeof ("true") - 1) == 0) {
- recursive = TRUE;
- }
- }
- else {
- /*
- * If user did not specify argument, let's assume that he wants
- * recursive search if mime part is multipart/mixed
- */
- if (g_mime_content_type_is_type (ct, "multipart", "*")) {
- recursive = TRUE;
- }
- }
-
-#ifndef GMIME24
- g_object_unref (part);
-#endif
- if ((param_data =
- g_mime_content_type_get_parameter ((GMimeContentType *)ct,
- param_name)) != NULL) {
- return TRUE;
- }
- /* Get next part */
- if (!recursive) {
- break;
- }
- }
+ /* TODO: fix */
+ msg_err_task ("content_type_compare_param is broken XXX");
- return result;
+ return FALSE;
}
static gboolean
GArray * args,
gboolean check_subtype)
{
- const gchar *param_data;
+ rspamd_ftok_t *param_data, srch;
rspamd_regexp_t *re;
struct expression_argument *arg1, *arg_pattern;
- GMimeObject *part;
- GMimeContentType *ct;
+ struct rspamd_content_type *ct;
gint r;
guint i;
gboolean recursive = FALSE;
for (i = 0; i < task->parts->len; i ++) {
cur_part = g_ptr_array_index (task->parts, i);
- part = cur_part->mime;
- ct = (GMimeContentType *)g_mime_object_get_content_type (part);
+ ct = cur_part->ct;
if (args->len >= 2) {
arg1 = &g_array_index (args, struct expression_argument, 1);
* If user did not specify argument, let's assume that he wants
* recursive search if mime part is multipart/mixed
*/
- if (g_mime_content_type_is_type (ct, "multipart", "*")) {
+ if (IS_CT_MULTIPART (ct)) {
recursive = TRUE;
}
}
g_object_unref (part);
#endif
if (check_subtype) {
- param_data = ct->subtype;
+ param_data = &ct->subtype;
}
else {
- param_data = ct->type;
+ param_data = &ct->type;
}
if (arg_pattern->type == EXPRESSION_ARGUMENT_REGEXP) {
re = arg_pattern->data;
- r = rspamd_regexp_search (re, param_data, 0,
+ r = rspamd_regexp_search (re, param_data->begin, param_data->len,
NULL, NULL, FALSE, NULL);
if (r) {
}
else {
/* Just do strcasecmp */
- if (g_ascii_strcasecmp (param_data, arg_pattern->data) == 0) {
+ srch.begin = arg_pattern->data;
+ srch.len = strlen (arg_pattern->data);
+
+ if (rspamd_ftok_casecmp (param_data, &srch) == 0) {
return TRUE;
}
}
}
static gboolean
-compare_subtype (struct rspamd_task *task, GMimeContentType * ct,
+compare_subtype (struct rspamd_task *task, struct rspamd_content_type *ct,
struct expression_argument *subtype)
{
rspamd_regexp_t *re;
+ rspamd_ftok_t srch;
gint r = 0;
if (subtype == NULL || ct == NULL) {
}
if (subtype->type == EXPRESSION_ARGUMENT_REGEXP) {
re = subtype->data;
- r = rspamd_regexp_search (re, ct->subtype, 0,
+ r = rspamd_regexp_search (re, ct->subtype.begin, ct->subtype.len,
NULL, NULL, FALSE, NULL);
}
else {
+ srch.begin = subtype->data;
+ srch.len = strlen (subtype->data);
+
/* Just do strcasecmp */
- if (ct->subtype && g_ascii_strcasecmp (ct->subtype, subtype->data) == 0) {
+ if (rspamd_ftok_casecmp (&ct->subtype, &srch) == 0) {
return TRUE;
}
}
}
if (min == 0) {
- return part->content->len <= max;
+ return part->parsed_data.len <= max;
}
else if (max == 0) {
- return part->content->len >= min;
+ return part->parsed_data.len >= min;
}
else {
- return part->content->len >= min && part->content->len <= max;
+ return part->parsed_data.len >= min && part->parsed_data.len <= max;
}
}
{
rspamd_regexp_t *re;
struct rspamd_mime_part *part;
- GMimeContentType *ct;
+ struct rspamd_content_type *ct;
+ rspamd_ftok_t srch;
gint r;
guint i;
for (i = 0; i < task->parts->len; i ++) {
part = g_ptr_array_index (task->parts, i);
- ct = part->type;
+ ct = part->ct;
if (ct == NULL) {
continue;
if (param_type->type == EXPRESSION_ARGUMENT_REGEXP) {
re = param_type->data;
- r = rspamd_regexp_search (re, ct->type, 0,
+ r = rspamd_regexp_search (re, ct->type.begin, ct->type.len,
NULL, NULL, FALSE, NULL);
/* Also check subtype and length of the part */
if (r && param_subtype) {
}
else {
/* Just do strcasecmp */
- if (ct->type && g_ascii_strcasecmp (ct->type, param_type->data) == 0) {
+ srch.begin = param_type->data;
+ srch.len = strlen (param_type->data);
+
+ if (rspamd_ftok_casecmp (&ct->type, &srch) == 0) {
if (param_subtype) {
if (compare_subtype (task, ct, param_subtype)) {
if (compare_len (part, min_len, max_len)) {
struct rspamd_image *img = lua_check_image (L);
if (img != NULL && img->filename != NULL) {
- lua_pushstring (L, img->filename);
+ lua_pushlstring (L, img->filename->begin, img->filename->len);
}
else {
return luaL_error (L, "invalid arguments");
struct rspamd_archive *arch = lua_check_archive (L);
if (arch != NULL) {
- lua_pushstring (L, arch->archive_name);
+ lua_pushlstring (L, arch->archive_name->begin, arch->archive_name->len);
}
else {
return luaL_error (L, "invalid arguments");
projects / thirdparty / rspamd.git / commitdiff
