Example #1
0
static void part_extractor_foreach_callback(GMimeObject *parent, GMimeObject *part, gpointer user_data) {
  PartExtractorData *a_data = (PartExtractorData *) user_data;

  if (GMIME_IS_MESSAGE_PART(part)) {

    if (a_data->recursion_depth < RECURSION_LIMIT) {
      GMimeMessage *message = g_mime_message_part_get_message((GMimeMessagePart *) part); // transfer none
      if (message)
        g_mime_message_foreach(message, part_extractor_foreach_callback, a_data);

    } else {
      g_printerr("endless recursion detected: %d\r\n", a_data->recursion_depth);
      return;
    }

  } else if (GMIME_IS_MESSAGE_PARTIAL (part)) {
    // Save into an array ? Todo: Look into the specs
  } else if (GMIME_IS_MULTIPART (part)) {
    // Nothing special needed on multipart, let descend further
  } else if (GMIME_IS_PART (part)) {

    // We are interested only in the part 0 (counting down by same logic)
    if (a_data->part_id == 0)
      extract_part(part, a_data);

    a_data->part_id--;

  } else {
    g_assert_not_reached();
  }
}
Example #2
0
static void collector_foreach_callback(GMimeObject *parent, GMimeObject *part, gpointer user_data) {
  g_return_if_fail(user_data != NULL);

  PartCollectorData *fdata = (PartCollectorData *) user_data;

  if (GMIME_IS_MESSAGE_PART(part)) {

    if (fdata->recursion_depth++ < RECURSION_LIMIT) {
      GMimeMessage *message = g_mime_message_part_get_message((GMimeMessagePart *) part); // transfer none
      if (message)
        g_mime_message_foreach(message, collector_foreach_callback, user_data);

    } else {
      g_printerr("endless recursion detected: %d\r\n", fdata->recursion_depth);
      return;
    }

  } else if (GMIME_IS_MESSAGE_PARTIAL(part)) {
    // Save into an array ? Todo: Look into the specs
  } else if (GMIME_IS_MULTIPART(part)) {
    // Nothing special needed on multipart, let descend further
  } else if (GMIME_IS_PART(part)) {
    collect_part(part, fdata, GMIME_IS_MULTIPART(parent));
    fdata->part_id++;
  } else {
    g_assert_not_reached();
  }
}
Example #3
0
void count_parts_in_message (GMimeMessage *message)
{
    int count = 0;

    /* count the number of parts (recursively) in the message
     * including the container multiparts */
    g_mime_message_foreach (message, count_foreach_callback, &count);
    printf ("There are %d parts in the message\n", count);
}
Example #4
0
static GByteArray *gmime_message_get_part_data(GMimeMessage* message, guint part_id) {
  g_return_val_if_fail(message != NULL, NULL);

  PartExtractorData *a_data = new_part_extractor_data(part_id);
  g_mime_message_foreach(message, part_extractor_foreach_callback, a_data);
  GByteArray *content = a_data->content;
  free_part_extractor_data(a_data, FALSE);

  if (!content)
    g_printerr("could not locate partId %d\r\n", part_id);

  return content;
}
Example #5
0
static gboolean
handle_children (MuMsg *msg,
		 GMimeMessage *mime_msg, MuMsgOptions opts,
		 unsigned index, MuMsgPartForeachFunc func,
		 gpointer user_data)
{
	ForeachData fdata;

 	fdata.func	= func;
	fdata.user_data = user_data;
	fdata.opts	= opts;
	fdata.msg	= msg;
	fdata.index	= 0;

	g_mime_message_foreach (mime_msg, (GMimeObjectForeachFunc)each_child,
				&fdata);

	return TRUE;
}
Example #6
0
static int process_message(GMimeMessage *message, const char *post_dir)
{
	struct mime_cbinfo cbinfo = {
		.count = 0,
		.post_dir = post_dir,
	};

#ifdef AST_GMIME_VER_24
	g_mime_message_foreach(message, process_message_callback, &cbinfo);
#else
	g_mime_message_foreach_part(message, process_message_callback, &cbinfo);
#endif

	return cbinfo.count;
}

/* Find a sequence of bytes within a binary array. */
static int find_sequence(char * inbuf, int inlen, char * matchbuf, int matchlen)
{
	int current;
	int comp;
	int found = 0;

	for (current = 0; current < inlen-matchlen; current++, inbuf++) {
		if (*inbuf == *matchbuf) {
			found=1;
			for (comp = 1; comp < matchlen; comp++) {
				if (inbuf[comp] != matchbuf[comp]) {
					found = 0;
					break;
				}
			}
			if (found) {
				break;
			}
		}
	}
	if (found) {
		return current;
	} else {
		return -1;
	}
}
Example #7
0
static void
mime_foreach_callback (GMimeObject * parent,
	GMimeObject * part,
	gpointer user_data)
{
	GMimeContentType *type;

	if (GMIME_IS_MESSAGE_PART (part)) {
		/* message/rfc822 or message/news */
		GMimeMessage *message;

		/* g_mime_message_foreach_part() won't descend into
			   child message parts, so if we want to count any
			   subparts of this child message, we'll have to call
			   g_mime_message_foreach_part() again here. */
		rspamd_printf ("got message part %p: parent: %p\n",
						part, parent);
		message = g_mime_message_part_get_message ((GMimeMessagePart *) part);
		g_mime_message_foreach (message, mime_foreach_callback, part);
	}
	else if (GMIME_IS_MULTIPART (part)) {
		type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (
						part));
		rspamd_printf ("got multipart part %p, boundary: %s: parent: %p, type: %s/%s\n",
					part, g_mime_multipart_get_boundary (GMIME_MULTIPART(part)),
					parent,
					g_mime_content_type_get_media_type (type),
					g_mime_content_type_get_media_subtype (type));
	}
	else {
		type = (GMimeContentType *) g_mime_object_get_content_type (GMIME_OBJECT (
				part));
		rspamd_printf ("got normal part %p, parent: %p, type: %s/%s\n",
				part,
				parent,
				g_mime_content_type_get_media_type (type),
				g_mime_content_type_get_media_subtype (type));
	}
}
Example #8
0
static void
count_foreach_callback (GMimeObject *parent, GMimeObject *part, gpointer user_data)
{
    int *count = user_data;
    (*count)++;

    /* 'part' points to the current part node that
     * g_mime_message_foreach() is iterating over */

    /* find out what class 'part' is... */
    if (GMIME_IS_MESSAGE_PART (part))
    {
        /* message/rfc822 or message/news */
        GMimeMessage *message;

        /* g_mime_message_foreach() won't descend into
                   child message parts, so if we want to count any
                   subparts of this child message, we'll have to call
                   g_mime_message_foreach() again here. */
        printf("\n===============descend into subparts=================\n");
        message = g_mime_message_part_get_message ((GMimeMessagePart *) part);
        g_mime_message_foreach (message, count_foreach_callback, count);
    }
    else if (GMIME_IS_MESSAGE_PARTIAL (part))
    {
        /* message/partial */

        /* this is an incomplete message part, probably a
                   large message that the sender has broken into
                   smaller parts and is sending us bit by bit. we
                   could save some info about it so that we could
                   piece this back together again once we get all the
                   parts? */
        printf("\n===============partial=================\n");
    }
    else if (GMIME_IS_MULTIPART (part))
    {
        /* multipart/mixed, multipart/alternative,
         * multipart/related, multipart/signed,
         * multipart/encrypted, etc... */

        /* we'll get to finding out if this is a
         * signed/encrypted multipart later... */
        printf("\n===============multipart=================\n");
    }
    else if (GMIME_IS_PART (part))
    {
        /* a normal leaf part, could be text/plain or
         * image/jpeg etc */
        printf("\n===============normal leaf part=================\n");
        printf("====>>>>====>>>>====>>>>Decode start here<<<<====<<<<====<<<<====\n");
        {
#if 0
            printf("\ndecode this normal leaf part================\n" );
            //GMimeStream *stream = g_mime_stream_file_new (stdout);
            //GMimeDataWrapper * content=g_mime_part_get_content_object(part);
            //g_mime_data_wrapper_write_to_stream(content,stream);
#endif
        }
        AnalyseMessageParse((GMimePart*)part);
    }
    else
    {
        printf("\n===============descend not reached=================\n");
        g_assert_not_reached ();
    }
}
Example #9
0
static PartCollectorData *collect_parts(GMimeMessage *message, guint content_option) {
  PartCollectorData *pc = new_part_collector_data(content_option);
  g_mime_message_foreach(message, collector_foreach_callback, pc);
  return pc;
}
Example #10
0
static void
rspamd_process_file (struct rspamd_config *cfg, const gchar *fname, gint mode)
{
	struct rspamd_task *task;
	gint fd;
	gpointer map;
	struct stat st;
	GError *err = NULL;
#if 0
	GMimeMessage *message;
	GMimeParser *parser;
	GMimeStream *stream;
	GByteArray tmp;
#endif
	struct rspamd_mime_part *part;
	guint i;
	gdouble ts1, ts2;

	fd = open (fname, O_RDONLY);

	if (fd == -1) {
		rspamd_fprintf (stderr, "cannot open %s: %s\n", fname, strerror (errno));
		exit (EXIT_FAILURE);
	}

	if (fstat (fd, &st) == -1) {
		rspamd_fprintf (stderr, "cannot stat %s: %s\n", fname, strerror (errno));
		exit (EXIT_FAILURE);
	}

	map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
	close (fd);

	if (map == MAP_FAILED) {
		rspamd_fprintf (stderr, "cannot mmap %s: %s\n", fname, strerror (errno));
		exit (EXIT_FAILURE);
	}

	task = rspamd_task_new (NULL, cfg);
	task->msg.begin = map;
	task->msg.len = st.st_size;

	ts1 = rspamd_get_ticks ();

	if (mode == MODE_NORMAL) {
		if (!rspamd_mime_parse_task (task, &err)) {
			rspamd_fprintf (stderr, "cannot parse %s: %e\n", fname, err);
			g_error_free (err);
		}
	}
#if 0
	else if (mode == MODE_GMIME) {
		tmp.data = map;
		tmp.len = st.st_size;
		stream = g_mime_stream_mem_new_with_byte_array (&tmp);
		g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), FALSE);
		parser = g_mime_parser_new_with_stream (stream);
		message = g_mime_parser_construct_message (parser);
	}
#endif
	ts2 = rspamd_get_ticks ();
	total_time += ts2 - ts1;

	if (mode == MODE_NORMAL) {
		for (i = 0; i < task->parts->len; i ++) {
			part = g_ptr_array_index (task->parts, i);

			if (part->ct->flags & RSPAMD_CONTENT_TYPE_MULTIPART) {
				rspamd_show_multipart (part);
			}
			else if (part->ct->flags & RSPAMD_CONTENT_TYPE_MESSAGE) {
				rspamd_show_message (part);
			}
			else {
				rspamd_show_normal (part);
			}
		}
	}
#if 0
	else if (mode == MODE_GMIME) {
		g_mime_message_foreach (message, mime_foreach_callback, NULL);
	}
#endif

	rspamd_task_free (task);
	munmap (map, st.st_size);
#if 0
	if (mode == MODE_GMIME) {
		g_object_unref (message);
	}
#endif
}