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);
}
}
}
gboolean
g_mime_gpgme_mps_sign(GMimeMultipartSigned * mps, GMimeObject * content,
const gchar * userid, gpgme_protocol_t protocol,
GtkWindow * parent, GError ** err)
{
GMimeStream *stream;
GMimeStream *filtered;
GMimeStream *sigstream;
GMimeFilter *filter;
GMimeContentType *content_type;
GMimeDataWrapper *wrapper;
GMimeParser *parser;
GMimePart *signature;
gchar *micalg;
const gchar *proto_type;
const gchar *sig_subtype;
gpgme_hash_algo_t hash_algo;
g_return_val_if_fail(GMIME_IS_MULTIPART_SIGNED(mps), FALSE);
g_return_val_if_fail(GMIME_IS_OBJECT(content), FALSE);
/* Prepare all the parts for signing... */
sign_prepare(content);
/* get the cleartext */
stream = g_mime_stream_mem_new();
filtered = g_mime_stream_filter_new(stream);
/* Note: see rfc3156, section 3 - second note */
filter = g_mime_filter_from_new(GMIME_FILTER_FROM_MODE_ARMOR);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered), filter);
g_object_unref(filter);
/* Note: see rfc3156, section 5.4 (this is the main difference between rfc2015 and rfc3156) */
filter = g_mime_filter_strip_new();
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered), filter);
g_object_unref(filter);
g_mime_object_write_to_stream(content, filtered);
g_mime_stream_flush(filtered);
g_object_unref(filtered);
g_mime_stream_reset(stream);
/* Note: see rfc2015 or rfc3156, section 5.1 */
filtered = g_mime_stream_filter_new(stream);
filter = g_mime_filter_crlf_new(TRUE, FALSE);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered), filter);
g_object_unref(filter);
/* construct the signature stream */
sigstream = g_mime_stream_mem_new();
/* sign the content stream */
hash_algo =
libbalsa_gpgme_sign(userid, filtered, sigstream, protocol, FALSE,
parent, err);
g_object_unref(filtered);
if (hash_algo == GPGME_MD_NONE) {
g_object_unref(sigstream);
g_object_unref(stream);
return FALSE;
}
g_mime_stream_reset(sigstream);
g_mime_stream_reset(stream);
/* set the multipart/signed protocol and micalg */
content_type = g_mime_object_get_content_type(GMIME_OBJECT(mps));
if (protocol == GPGME_PROTOCOL_OpenPGP) {
micalg =
g_strdup_printf("PGP-%s", gpgme_hash_algo_name(hash_algo));
proto_type = "application/pgp-signature";
sig_subtype = "pgp-signature";
} else {
micalg = g_strdup(gpgme_hash_algo_name(hash_algo));
proto_type = "application/pkcs7-signature";
sig_subtype = "pkcs7-signature";
}
g_mime_content_type_set_parameter(content_type, "micalg", micalg);
g_free(micalg);
g_mime_content_type_set_parameter(content_type, "protocol", proto_type);
g_mime_multipart_set_boundary(GMIME_MULTIPART(mps), NULL);
/* construct the content part */
parser = g_mime_parser_new_with_stream(stream);
content = g_mime_parser_construct_part(parser);
g_object_unref(stream);
g_object_unref(parser);
/* construct the signature part */
signature = g_mime_part_new_with_type("application", sig_subtype);
wrapper = g_mime_data_wrapper_new();
g_mime_data_wrapper_set_stream(wrapper, sigstream);
g_mime_part_set_content_object(signature, wrapper);
g_object_unref(sigstream);
g_object_unref(wrapper);
/* FIXME: temporary hack, this info should probably be set in
* the CipherContext class - maybe ::sign can take/output a
* GMimePart instead. */
if (protocol == GPGME_PROTOCOL_CMS) {
g_mime_part_set_content_encoding(signature,
GMIME_CONTENT_ENCODING_BASE64);
g_mime_part_set_filename(signature, "smime.p7m");
}
/* save the content and signature parts */
/* FIXME: make sure there aren't any other parts?? */
g_mime_multipart_add(GMIME_MULTIPART(mps), content);
g_mime_multipart_add(GMIME_MULTIPART(mps), (GMimeObject *) signature);
g_object_unref(signature);
g_object_unref(content);
return TRUE;
}
