gint
test_message_compare (CamelMimeMessage *msg)
{
CamelMimeMessage *msg2;
CamelStream *stream1;
CamelStream *stream2;
GByteArray *byte_array1;
GByteArray *byte_array2;
byte_array1 = g_byte_array_new ();
stream1 = camel_stream_mem_new_with_byte_array (byte_array1);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg), stream1, NULL, NULL) != -1,
"write_to_stream 1 failed", NULL);
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
msg2 = camel_mime_message_new ();
check_msg (camel_data_wrapper_construct_from_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream1, NULL, NULL) != -1,
"construct_from_stream 1 failed");
g_seekable_seek (G_SEEKABLE (stream1), 0, G_SEEK_SET, NULL, NULL);
byte_array2 = g_byte_array_new ();
stream2 = camel_stream_mem_new_with_byte_array (byte_array2);
check_msg (camel_data_wrapper_write_to_stream_sync (
CAMEL_DATA_WRAPPER (msg2), stream2, NULL, NULL) != -1,
"write_to_stream 2 failed");
g_seekable_seek (G_SEEKABLE (stream2), 0, G_SEEK_SET, NULL, NULL);
if (byte_array1->len != byte_array2->len) {
CamelDataWrapper *content;
printf ("stream1 stream:\n%.*s\n", byte_array1->len, byte_array1->data);
printf ("stream2 stream:\n%.*s\n\n", byte_array2->len, byte_array2->data);
printf ("msg1:\n");
test_message_dump_structure (msg);
printf ("msg2:\n");
test_message_dump_structure (msg2);
content = camel_medium_get_content ((CamelMedium *) msg);
}
check_unref (msg2, 1);
check_msg (
byte_array1->len == byte_array2->len,
"byte_array1->len = %d, byte_array2->len = %d",
byte_array1->len, byte_array2->len);
check_msg (memcmp (byte_array1->data, byte_array2->data, byte_array1->len) == 0, "msg/stream compare");
g_object_unref (stream1);
g_object_unref (stream2);
return 0;
}
static CamelStream *
multipart_signed_clip_stream (CamelMultipartSigned *mps,
goffset start,
goffset end)
{
CamelDataWrapper *data_wrapper;
GByteArray *src;
GByteArray *dst;
g_return_val_if_fail (start != -1, NULL);
g_return_val_if_fail (end != -1, NULL);
g_return_val_if_fail (end >= start, NULL);
data_wrapper = CAMEL_DATA_WRAPPER (mps);
src = camel_data_wrapper_get_byte_array (data_wrapper);
dst = g_byte_array_new ();
if (start >= 0 && end < src->len) {
const guint8 *data = &src->data[start];
g_byte_array_append (dst, data, end - start);
}
/* Stream takes ownership of the byte array. */
return camel_stream_mem_new_with_byte_array (dst);
}
gint
test_message_compare_content (CamelDataWrapper *dw,
const gchar *text,
gint len)
{
GByteArray *byte_array;
CamelStream *stream;
/* sigh, ok, so i len == 0, dw will probably be 0 too
* camel_mime_part_set_content is weird like that */
if (dw == 0 && len == 0)
return 0;
byte_array = g_byte_array_new ();
stream = camel_stream_mem_new_with_byte_array (byte_array);
camel_data_wrapper_decode_to_stream_sync (dw, stream, NULL, NULL);
if (byte_array->len != len) {
printf ("original text:\n");
hexdump ((guchar *) text, len);
printf ("new text:\n");
hexdump (byte_array->data, byte_array->len);
}
check_msg (byte_array->len == len, "buffer->len = %d, len = %d", byte_array->len, len);
check_msg (memcmp (byte_array->data, text, byte_array->len) == 0, "len = %d", len);
check_unref (stream, 1);
return 0;
}
/**
* camel_stream_mem_new_with_buffer:
* @buffer: a memory buffer to use as the stream data
* @len: length of @buffer
*
* Create a new memory stream using @buffer as the stream data.
*
* Note: @buffer will be copied into an internal #GByteArray structure
* for use as the stream backing. This may have resource implications
* you may wish to consider.
*
* Returns a new #CamelStreamMem
**/
CamelStream *
camel_stream_mem_new_with_buffer (const char *buffer, size_t len)
{
GByteArray *ba;
ba = g_byte_array_new ();
g_byte_array_append (ba, (const guint8 *)buffer, len);
return camel_stream_mem_new_with_byte_array (ba);
}
void
test_message_set_content_simple (CamelMimePart *part,
gint how,
const gchar *type,
const gchar *text,
gint len)
{
CamelStreamMem *content = NULL;
CamelDataWrapper *dw;
static GByteArray *ba;
switch (how) {
case 0:
camel_mime_part_set_content (part, text, len, type);
break;
case 1:
content = (CamelStreamMem *) camel_stream_mem_new_with_buffer (text, len);
break;
case 2:
content = (CamelStreamMem *) camel_stream_mem_new ();
camel_stream_mem_set_buffer (content, text, len);
break;
case 3:
ba = g_byte_array_new ();
g_byte_array_append (ba, (guint8 *) text, len);
content = (CamelStreamMem *) camel_stream_mem_new_with_byte_array (ba);
ba = NULL;
break;
case 4:
ba = g_byte_array_new ();
g_byte_array_append (ba, (guint8 *) text, len);
content = (CamelStreamMem *) camel_stream_mem_new ();
camel_stream_mem_set_byte_array (content, ba);
g_object_weak_ref (
G_OBJECT (content), (GWeakNotify)
content_weak_notify, ba);
break;
}
if (content != 0) {
dw = camel_data_wrapper_new ();
camel_data_wrapper_set_mime_type (dw, type);
camel_data_wrapper_construct_from_stream_sync (
dw, (CamelStream *) content, NULL, NULL);
camel_medium_set_content ((CamelMedium *) part, dw);
check_unref (content, 2);
check_unref (dw, 2);
}
}
static gboolean
set_ical_from_mime_part (CamelMimePart * part, ScalixObject * object)
{
CamelDataWrapper *content;
CamelStream *stream;
GByteArray *data;
icalcomponent *icomp = NULL;
icalcomponent *subcomp = NULL;
ScalixAppointmentPrivate *priv;
priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object));
content = camel_medium_get_content_object (CAMEL_MEDIUM (part));
data = g_byte_array_new ();
stream = camel_stream_mem_new_with_byte_array (data);
camel_data_wrapper_decode_to_stream (content, stream);
if (data == NULL || data->data == NULL) {
g_print ("Found corrupt ical data\n");
return FALSE;
}
icomp = icalparser_parse_string ((const char *) data->data);
if (icalcomponent_isa (icomp) != ICAL_VCALENDAR_COMPONENT) {
icalcomponent_free (icomp);
return FALSE;
}
/* Grab the timezone if any */
subcomp = icalcomponent_get_first_component (icomp,
ICAL_VTIMEZONE_COMPONENT);
if (subcomp != NULL) {
icaltimezone *zone;
zone = icaltimezone_new ();
icaltimezone_set_component (zone, subcomp);
priv->timezone = zone;
}
/* Grab the main VEVENT */
subcomp = icalcomponent_get_first_component (icomp, ICAL_VEVENT_COMPONENT);
e_cal_component_set_icalcomponent (E_CAL_COMPONENT (object), subcomp);
return TRUE;
}
/* there is also an identical copy of this in camel-filter-search.c */
gboolean
camel_search_message_body_contains (CamelDataWrapper *object, regex_t *pattern)
{
CamelDataWrapper *containee;
gint truth = FALSE;
gint parts, i;
containee = camel_medium_get_content (CAMEL_MEDIUM (object));
if (containee == NULL)
return FALSE;
/* using the object types is more accurate than using the mime/types */
if (CAMEL_IS_MULTIPART (containee)) {
parts = camel_multipart_get_number (CAMEL_MULTIPART (containee));
for (i = 0; i < parts && truth == FALSE; i++) {
CamelDataWrapper *part = (CamelDataWrapper *)camel_multipart_get_part (CAMEL_MULTIPART (containee), i);
if (part)
truth = camel_search_message_body_contains (part, pattern);
}
} else if (CAMEL_IS_MIME_MESSAGE (containee)) {
/* for messages we only look at its contents */
truth = camel_search_message_body_contains ((CamelDataWrapper *)containee, pattern);
} else if (camel_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_type, "text", "*")
|| camel_content_type_is(CAMEL_DATA_WRAPPER (containee)->mime_type, "x-evolution", "evolution-rss-feed")) {
/* for all other text parts, we look inside, otherwise we dont care */
CamelStream *stream;
GByteArray *byte_array;
byte_array = g_byte_array_new ();
stream = camel_stream_mem_new_with_byte_array (byte_array);
camel_data_wrapper_write_to_stream_sync (
containee, stream, NULL, NULL);
camel_stream_write (stream, "", 1, NULL, NULL);
truth = regexec (pattern, (gchar *) byte_array->data, 0, NULL, 0) == 0;
g_object_unref (stream);
}
return truth;
}
static void
set_description (ECalComponent *comp,
CamelMimeMessage *message)
{
CamelDataWrapper *content;
CamelStream *stream;
CamelContentType *type;
CamelMimePart *mime_part = CAMEL_MIME_PART (message);
ECalComponentText *text = NULL;
GByteArray *byte_array;
GSList *sl = NULL;
gchar *str, *convert_str = NULL;
gsize bytes_read, bytes_written;
gint count = 2;
content = camel_medium_get_content ((CamelMedium *) message);
if (!content)
return;
/*
* Get non-multipart content from multipart message.
*/
while (CAMEL_IS_MULTIPART (content) && count > 0) {
mime_part = camel_multipart_get_part (CAMEL_MULTIPART (content), 0);
content = camel_medium_get_content (CAMEL_MEDIUM (mime_part));
count--;
}
if (!mime_part)
return;
type = camel_mime_part_get_content_type (mime_part);
if (!camel_content_type_is (type, "text", "plain"))
return;
byte_array = g_byte_array_new ();
stream = camel_stream_mem_new_with_byte_array (byte_array);
camel_data_wrapper_decode_to_stream_sync (content, stream, NULL, NULL);
str = g_strndup ((gchar *) byte_array->data, byte_array->len);
g_object_unref (stream);
/* convert to UTF-8 string */
if (str && content->mime_type->params && content->mime_type->params->value) {
convert_str = g_convert (
str, strlen (str),
"UTF-8", content->mime_type->params->value,
&bytes_read, &bytes_written, NULL);
}
text = g_new0 (ECalComponentText, 1);
if (convert_str)
text->value = prepend_from (message, &convert_str);
else
text->value = prepend_from (message, &str);
text->altrep = NULL;
sl = g_slist_append (sl, text);
e_cal_component_set_description_list (comp, sl);
g_free (str);
if (convert_str)
g_free (convert_str);
e_cal_component_free_text_list (sl);
}
/**
* camel_stream_mem_new:
*
* Create a new #CamelStreamMem object.
*
* Returns a new #CamelStreamMem
**/
CamelStream *
camel_stream_mem_new (void)
{
return camel_stream_mem_new_with_byte_array (g_byte_array_new ());
}
