static void
reply_part_content (GMimeObject *part)
{
GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (part);
if (g_mime_content_type_is_type (content_type, "multipart", "*") ||
g_mime_content_type_is_type (content_type, "message", "rfc822"))
{
/* Output nothing, since multipart subparts will be handled individually. */
}
else if (g_mime_content_type_is_type (content_type, "application", "pgp-encrypted") ||
g_mime_content_type_is_type (content_type, "application", "pgp-signature"))
{
/* Ignore PGP/MIME cruft parts */
}
else if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = NULL, *stream_filter = NULL;
GMimeDataWrapper *wrapper;
const char *charset;
charset = g_mime_object_get_content_type_parameter (part, "charset");
stream_stdout = g_mime_stream_file_new (stdout);
if (stream_stdout) {
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
stream_filter = g_mime_stream_filter_new(stream_stdout);
if (charset) {
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
g_mime_filter_charset_new(charset, "UTF-8"));
}
}
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
g_mime_filter_reply_new(TRUE));
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref(stream_filter);
if (stream_stdout)
g_object_unref(stream_stdout);
}
else
{
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
{
const char *filename = g_mime_part_get_filename (GMIME_PART (part));
printf ("Attachment: %s (%s)\n", filename,
g_mime_content_type_to_string (content_type));
}
else
{
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
}
static void
format_part_reply (mime_node_t *node)
{
int i;
if (node->envelope_file) {
printf ("On %s, %s wrote:\n",
notmuch_message_get_header (node->envelope_file, "date"),
notmuch_message_get_header (node->envelope_file, "from"));
} else if (GMIME_IS_MESSAGE (node->part)) {
GMimeMessage *message = GMIME_MESSAGE (node->part);
InternetAddressList *recipients;
const char *recipients_string;
printf ("> From: %s\n", g_mime_message_get_sender (message));
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("> To: %s\n",
recipients_string);
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("> Cc: %s\n",
recipients_string);
printf ("> Subject: %s\n", g_mime_message_get_subject (message));
printf ("> Date: %s\n", g_mime_message_get_date_as_string (message));
printf (">\n");
} else if (GMIME_IS_PART (node->part)) {
GMimeContentType *content_type = g_mime_object_get_content_type (node->part);
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (node->part);
if (g_mime_content_type_is_type (content_type, "application", "pgp-encrypted") ||
g_mime_content_type_is_type (content_type, "application", "pgp-signature")) {
/* Ignore PGP/MIME cruft parts */
} else if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html")) {
GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
show_text_part_content (node->part, stream_stdout, NOTMUCH_SHOW_TEXT_PART_REPLY);
g_object_unref(stream_stdout);
} else if (disposition &&
strcasecmp (g_mime_content_disposition_get_disposition (disposition),
GMIME_DISPOSITION_ATTACHMENT) == 0) {
const char *filename = g_mime_part_get_filename (GMIME_PART (node->part));
printf ("Attachment: %s (%s)\n", filename,
g_mime_content_type_to_string (content_type));
} else {
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
for (i = 0; i < node->nchildren; i++)
format_part_reply (mime_node_child (node, i));
}
/**
* g_mime_part_is_attachment:
* @mime_part: a #GMimePart object
*
* Determines whether or not the part is an attachment based on the
* value of the Content-Disposition header.
*
* Returns: %TRUE if the part is an attachment, otherwise %FALSE.
*
* Since: 2.6.21
**/
gboolean
g_mime_part_is_attachment (GMimePart *mime_part)
{
GMimeContentDisposition *disposition;
g_return_val_if_fail (GMIME_IS_PART (mime_part), FALSE);
disposition = g_mime_object_get_content_disposition ((GMimeObject *) mime_part);
return disposition != NULL && g_mime_content_disposition_is_attachment (disposition);
}
static void
reply_part_content (GMimeObject *part)
{
GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part));
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (part);
if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = NULL, *stream_filter = NULL;
GMimeDataWrapper *wrapper;
const char *charset;
charset = g_mime_object_get_content_type_parameter (part, "charset");
stream_stdout = g_mime_stream_file_new (stdout);
if (stream_stdout) {
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
stream_filter = g_mime_stream_filter_new(stream_stdout);
if (charset) {
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
g_mime_filter_charset_new(charset, "UTF-8"));
}
}
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
g_mime_filter_reply_new(TRUE));
wrapper = g_mime_part_get_content_object (GMIME_PART (part));
if (wrapper && stream_filter)
g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);
if (stream_filter)
g_object_unref(stream_filter);
if (stream_stdout)
g_object_unref(stream_stdout);
}
else
{
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
{
const char *filename = g_mime_part_get_filename (GMIME_PART (part));
printf ("Attachment: %s (%s)\n", filename,
g_mime_content_type_to_string (content_type));
}
else
{
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
}
static void
format_part_start_text (GMimeObject *part, int *part_count)
{
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (part);
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
{
printf ("\fattachment{ ID: %d", *part_count);
} else {
printf ("\fpart{ ID: %d", *part_count);
}
}
MuxMessagePart*
mux_message_part_new (const char *path, GMimeObject *mobj)
{
MuxMessagePart *self;
g_return_val_if_fail (path, NULL);
g_return_val_if_fail (GMIME_IS_OBJECT(mobj), NULL);
self = MUX_MESSAGE_PART(g_object_new(MUX_TYPE_MESSAGE_PART, NULL));
self->path = ext_path (path);
self->content_type = g_mime_object_get_content_type (mobj);
self->content_id = g_mime_object_get_content_id (mobj);
self->content_disposition = g_mime_object_get_content_disposition (mobj);
if (GMIME_IS_PART (mobj))
self->file_name = g_mime_part_get_filename ((GMimePart*)mobj);
self->mime_object = g_object_ref (mobj);
return self;
}
/**
* Output a list of the parts included in the current message.
*/
void dump_mail( char *filename )
{
std::string result;
GMimeMessage *m_message;
GMimeParser *parser;
GMimeStream *stream;
int fd;
std::cout << "File: " << filename << std::endl;
if ((fd = open( filename, O_RDONLY, 0)) == -1)
{
std::cout << "Opening failed ..." << std::endl;
return;
}
stream = g_mime_stream_fs_new (fd);
parser = g_mime_parser_new_with_stream (stream);
g_object_unref (stream);
m_message = g_mime_parser_construct_message (parser);
g_object_unref (parser);
/**
* Create an iterator
*/
GMimePartIter *iter = g_mime_part_iter_new ((GMimeObject *) m_message);
int count = 1;
/**
* Iterate over the message.
*/
do
{
GMimeObject *part = g_mime_part_iter_get_current (iter);
if ( ( GMIME_IS_OBJECT( part ) ) &&
( GMIME_IS_PART(part) ) )
{
/**
* Get the content-type
*/
GMimeContentType *content_type = g_mime_object_get_content_type (part);
const char *filename = g_mime_object_get_content_disposition_parameter(part, "filename");
gchar *type = g_mime_content_type_to_string ( content_type );
std::cout << count << " " << type << std::endl;
if ( filename )
std::cout << "\t[This is an attachment with file-name " << filename << "]" << std::endl;
}
/**
* Highlight inline parts - which are not attachments.
*/
GMimeContentDisposition *disp = g_mime_object_get_content_disposition(part);
if ( disp != NULL )
{
const char *str = g_mime_content_disposition_get_disposition (disp);
std::cout << "\tNOTE: Content-Disposition: " << str << std::endl;
}
count += 1;
}
while (g_mime_part_iter_next (iter));
g_mime_part_iter_free (iter);
g_object_unref(m_message);
}
static void
test_disposition_sync (void)
{
GMimeContentDisposition *disposition;
const char *raw_value, *value;
GMimeHeaderList *headers;
GMimeParamList *params;
GMimeObject *object;
GMimeHeader *header;
GMimePart *part;
object = (GMimeObject *) (part = g_mime_part_new ());
headers = g_mime_object_get_header_list (object);
testsuite_check ("content-disposition synchronization");
try {
g_mime_object_set_disposition (object, "attachment");
/* first, check that the current Content-Disposition header
* value is "application/octet-stream" as expected */
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("initial content-disposition header was unexpectedly null"));
if (strcmp ("attachment", value) != 0)
throw (exception_new ("initial content-disposition header had unexpected value: %s", value));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("initial content-disposition raw_value was unexpectedly null"));
if (strcmp (" attachment\n", raw_value) != 0)
throw (exception_new ("initial content-disposition raw_value had unexpected value: %s", raw_value));
/* now change the content-disposition's disposition */
disposition = g_mime_object_get_content_disposition (object);
g_mime_content_disposition_set_disposition (disposition, "inline");
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after changing type"));
if (strcmp ("inline", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after changing type"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after changing type"));
if (strcmp (" inline\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after changing type: %s", raw_value));
/* now change the content-disposition's parameters by setting a param */
g_mime_content_disposition_set_parameter (disposition, "filename", "hello.txt");
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after setting a param"));
if (strcmp ("inline; filename=hello.txt", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after setting a param"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after setting a param"));
if (strcmp (" inline; filename=hello.txt\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after setting a param: %s", raw_value));
/* now change the content-disposition's parameters by clearing the params */
params = g_mime_content_disposition_get_parameters (disposition);
g_mime_param_list_clear (params);
if (!(value = g_mime_object_get_header (object, "Content-Disposition")))
throw (exception_new ("content-disposition header was unexpectedly null after clearing params"));
if (strcmp ("inline", value) != 0)
throw (exception_new ("content-disposition header had unexpected value after clearing params"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after clearing params"));
if (strcmp (" inline\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after clearing params: %s", raw_value));
/* let's try this in reverse... set the header value and make sure GMimeContentDisposition gets updated */
header = g_mime_header_list_get_header_at (headers, 1);
g_mime_header_set_value (header, NULL, "attachment; filename=xyz", NULL);
disposition = g_mime_object_get_content_disposition (object);
if (!g_mime_content_disposition_is_attachment (disposition))
throw (exception_new ("GMimeContentDisposition object was not updated"));
header = g_mime_header_list_get_header (headers, "Content-Disposition");
if (!(raw_value = g_mime_header_get_raw_value (header)))
throw (exception_new ("content-disposition raw_value was unexpectedly null after setting value"));
if (strcmp (" attachment; filename=xyz\n", raw_value) != 0)
throw (exception_new ("content-disposition raw_value had unexpected value after setting value: %s", raw_value));
testsuite_check_passed ();
} catch (ex) {
testsuite_check_failed ("content-disposition header not synchronized: %s", ex->message);
} finally;
g_object_unref (part);
}
static notmuch_status_t
format_part_text (const void *ctx, mime_node_t *node,
int indent, const notmuch_show_params_t *params)
{
/* The disposition and content-type metadata are associated with
* the envelope for message parts */
GMimeObject *meta = node->envelope_part ?
GMIME_OBJECT (node->envelope_part) : node->part;
GMimeContentType *content_type = g_mime_object_get_content_type (meta);
const notmuch_bool_t leaf = GMIME_IS_PART (node->part);
const char *part_type;
int i;
if (node->envelope_file) {
notmuch_message_t *message = node->envelope_file;
part_type = "message";
printf ("\f%s{ id:%s depth:%d match:%d excluded:%d filename:%s\n",
part_type,
notmuch_message_get_message_id (message),
indent,
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_MATCH) ? 1 : 0,
notmuch_message_get_flag (message, NOTMUCH_MESSAGE_FLAG_EXCLUDED) ? 1 : 0,
notmuch_message_get_filename (message));
} else {
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (meta);
const char *cid = g_mime_object_get_content_id (meta);
const char *filename = leaf ?
g_mime_part_get_filename (GMIME_PART (node->part)) : NULL;
if (disposition &&
strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0)
part_type = "attachment";
else
part_type = "part";
printf ("\f%s{ ID: %d", part_type, node->part_num);
if (filename)
printf (", Filename: %s", filename);
if (cid)
printf (", Content-id: %s", cid);
printf (", Content-type: %s\n", g_mime_content_type_to_string (content_type));
}
if (GMIME_IS_MESSAGE (node->part)) {
GMimeMessage *message = GMIME_MESSAGE (node->part);
InternetAddressList *recipients;
const char *recipients_string;
printf ("\fheader{\n");
if (node->envelope_file)
printf ("%s\n", _get_one_line_summary (ctx, node->envelope_file));
printf ("Subject: %s\n", g_mime_message_get_subject (message));
printf ("From: %s\n", g_mime_message_get_sender (message));
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("To: %s\n", recipients_string);
recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);
recipients_string = internet_address_list_to_string (recipients, 0);
if (recipients_string)
printf ("Cc: %s\n", recipients_string);
printf ("Date: %s\n", g_mime_message_get_date_as_string (message));
printf ("\fheader}\n");
printf ("\fbody{\n");
}
if (leaf) {
if (g_mime_content_type_is_type (content_type, "text", "*") &&
!g_mime_content_type_is_type (content_type, "text", "html"))
{
GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
show_text_part_content (node->part, stream_stdout, 0);
g_object_unref(stream_stdout);
} else {
printf ("Non-text part: %s\n",
g_mime_content_type_to_string (content_type));
}
}
for (i = 0; i < node->nchildren; i++)
format_part_text (ctx, mime_node_child (node, i), indent, params);
if (GMIME_IS_MESSAGE (node->part))
printf ("\fbody}\n");
printf ("\f%s}\n", part_type);
return NOTMUCH_STATUS_SUCCESS;
}
static void collect_part(GMimeObject *part, PartCollectorData *fdata, gboolean multipart_parent) {
GMimeContentType *content_type = g_mime_object_get_content_type(part);
GMimeContentDisposition *disposition = g_mime_object_get_content_disposition(part);
if (!content_type)
return;
GMimeDataWrapper *wrapper = g_mime_part_get_content_object(GMIME_PART(part));
if (!wrapper)
return;
// All the information will be collected in the CollectedPart
CollectedPart *c_part = new_collected_part(fdata->part_id);
gboolean is_attachment = FALSE;
if (disposition) {
c_part->disposition = g_ascii_strdown(disposition->disposition, -1);
is_attachment = !g_ascii_strcasecmp(disposition->disposition, GMIME_DISPOSITION_ATTACHMENT);
}
// If a filename is given, collect it always
const gchar *filename = g_mime_part_get_filename(GMIME_PART(part));
if (filename)
c_part->filename = g_strdup(filename);
// If a contentID is given, collect it always
const char* content_id = g_mime_part_get_content_id (GMIME_PART(part));
if (content_id)
c_part->content_id = g_strdup(content_id);
// Get the contentType in lowercase
gchar *content_type_str = g_mime_content_type_to_string(content_type);
c_part->content_type = g_ascii_strdown(content_type_str, -1);
g_free(content_type_str);
// To qualify as a message body, a MIME entity MUST NOT have a Content-Disposition header with the value "attachment".
if (!is_attachment && g_mime_content_type_is_type(content_type, "text", "*")) {
gboolean is_text_plain = g_mime_content_type_is_type(content_type, "text", "plain");
gboolean is_text_html = g_mime_content_type_is_type(content_type, "text", "html");
gboolean is_text_rtf = g_mime_content_type_is_type(content_type, "text", "rtf");
gboolean is_text_enriched = g_mime_content_type_is_type(content_type, "text", "enriched");
gboolean is_new_text = !fdata->text_part && is_text_plain;
gboolean is_new_html = !fdata->html_part && (is_text_html || is_text_enriched || is_text_rtf);
GMimeStream *mem_stream = g_mime_stream_mem_new();
g_mime_stream_mem_set_owner(GMIME_STREAM_MEM(mem_stream), FALSE);
GMimeStream *filtered_mem_stream = g_mime_stream_filter_new(mem_stream);
const gchar *charset = g_mime_object_get_content_type_parameter(part, "charset");
if (charset && g_ascii_strcasecmp(charset, UTF8_CHARSET)) {
GMimeFilter *utf8_charset_filter = g_mime_filter_charset_new(charset, UTF8_CHARSET);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), utf8_charset_filter);
g_object_unref(utf8_charset_filter);
}
if (!fdata->raw && is_new_text) {
GMimeFilter *strip_filter = g_mime_filter_strip_new();
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), strip_filter);
g_object_unref(strip_filter);
GMimeFilter *crlf_filter = g_mime_filter_crlf_new(FALSE, FALSE);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), crlf_filter);
g_object_unref(crlf_filter);
GMimeFilter *html_filter = g_mime_filter_html_new(
GMIME_FILTER_HTML_CONVERT_NL |
GMIME_FILTER_HTML_CONVERT_SPACES |
GMIME_FILTER_HTML_CONVERT_URLS |
GMIME_FILTER_HTML_MARK_CITATION |
GMIME_FILTER_HTML_CONVERT_ADDRESSES |
GMIME_FILTER_HTML_CITE, CITATION_COLOUR);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), html_filter);
g_object_unref(html_filter);
}
if (!fdata->raw && (is_new_text || is_new_html)) {
GMimeFilter *from_filter = g_mime_filter_from_new(GMIME_FILTER_FROM_MODE_ESCAPE);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), from_filter);
g_object_unref(from_filter);
}
// Add Enriched/RTF filter for this content
if (!fdata->raw && (is_new_html && (is_text_enriched || is_text_rtf))) {
guint flags = 0;
if (is_text_rtf)
flags = GMIME_FILTER_ENRICHED_IS_RICHTEXT;
GMimeFilter *enriched_filter = g_mime_filter_enriched_new(flags);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), enriched_filter);
g_object_unref(enriched_filter);
}
g_mime_data_wrapper_write_to_stream(wrapper, filtered_mem_stream);
// Very important! Flush the the stream and get all content through.
g_mime_stream_flush(filtered_mem_stream);
// Freed by the mem_stream on its own (owner) [transfer none]
c_part->content = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(mem_stream));
// After we unref the mem_stream, part_content is NOT available anymore
g_object_unref(filtered_mem_stream);
g_object_unref(mem_stream);
// Without content, the collected body part is of no use, so we ignore it.
if (c_part->content->len == 0) {
free_collected_part(c_part);
return;
}
// We accept only the first text and first html content, everything
// else is considered an alternative body
if (is_new_text) {
fdata->text_part = c_part;
} else if (is_new_html) {
fdata->html_part = c_part;
} else {
g_ptr_array_add(fdata->alternative_bodies, c_part);
}
} else {
GMimeStream *attachment_mem_stream = g_mime_stream_mem_new();
g_mime_stream_mem_set_owner (GMIME_STREAM_MEM(attachment_mem_stream), FALSE);
g_mime_data_wrapper_write_to_stream(wrapper, attachment_mem_stream);
g_mime_stream_flush(attachment_mem_stream);
c_part->content = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(attachment_mem_stream));
g_object_unref(attachment_mem_stream);
// Some content may not have disposition defined so we need to determine better what it is
if ((disposition && !g_ascii_strcasecmp(disposition->disposition, GMIME_DISPOSITION_INLINE)) ||
g_mime_part_get_content_id(GMIME_PART(part))) {
g_ptr_array_add(fdata->inlines, c_part);
} else {
// All other disposition should be kept within attachments
g_ptr_array_add(fdata->attachments, c_part);
}
}
}
