static char*
mime_part_get_filename (GMimeObject *mobj, unsigned index,
gboolean construct_if_needed)
{
gchar *fname;
fname = NULL;
if (GMIME_IS_PART (mobj)) {
/* the easy case: the part has a filename */
fname = (gchar*)g_mime_part_get_filename (GMIME_PART(mobj));
if (fname) /* don't include directory components */
fname = g_path_get_basename (fname);
}
if (!fname && !construct_if_needed)
return NULL;
if (GMIME_IS_MESSAGE_PART(mobj)) {
GMimeMessage *msg;
const char *subj;
msg = g_mime_message_part_get_message
(GMIME_MESSAGE_PART(mobj));
subj = g_mime_message_get_subject (msg);
fname = g_strdup_printf ("%s.eml", subj ? subj : "message");
}
if (!fname)
fname = g_strdup_printf ("%u.part", index);
/* remove slashes, spaces, colons... */
cleanup_filename (fname);
return fname;
}
static GMimeStream*
get_mime_stream (GMimeObject *obj, GError **err)
{
GMimeStream *mstream;
GMimeDataWrapper *wrapper;
if (!GMIME_IS_PART(obj)) {
char *str;
GByteArray *ar;
str = g_mime_object_to_string (obj);
ar = g_byte_array_new_take ((guchar*)str, strlen(str));
mstream = g_mime_stream_mem_new_with_byte_array (ar);
g_mime_stream_mem_set_owner (
GMIME_STREAM_MEM(mstream), TRUE);
return mstream;
}
wrapper = get_data_wrapper (obj, err);
if (!wrapper)
return NULL;
mstream = g_mime_data_wrapper_get_stream (wrapper);
if (!mstream || g_mime_stream_reset (mstream) != 0) {
g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED,
"invalid mime-stream");
return NULL;
}
return mstream;
}
gboolean
mu_msg_part_save (MuMsg *msg, MuMsgOptions opts,
const char *fullpath, guint partidx, GError **err)
{
GMimeObject *part;
g_return_val_if_fail (msg, FALSE);
g_return_val_if_fail (fullpath, FALSE);
g_return_val_if_fail (!((opts & MU_MSG_OPTION_OVERWRITE) &&
(opts & MU_MSG_OPTION_USE_EXISTING)), FALSE);
if (!mu_msg_load_msg_file (msg, err))
return FALSE;
part = get_mime_object_at_index (msg, opts, partidx);
if (!GMIME_IS_PART(part) || GMIME_IS_MESSAGE_PART(part)) {
g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,
"unexpected type %s for part %u",
G_OBJECT_TYPE_NAME((GObject*)part),
partidx);
return FALSE;
}
return save_object (part, opts, fullpath, err);
}
/**
* g_mime_part_get_content_id:
* @mime_part: a #GMimePart object
*
* Gets the content-id of the specified mime part if it exists, or
* %NULL otherwise.
*
* Returns: the content id for the specified mime part.
**/
const char *
g_mime_part_get_content_id (GMimePart *mime_part)
{
g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);
return g_mime_object_get_content_id (GMIME_OBJECT (mime_part));
}
/**
* g_mime_part_set_content_id:
* @mime_part: a #GMimePart object
* @content_id: content id
*
* Set the content id for the specified mime part.
**/
void
g_mime_part_set_content_id (GMimePart *mime_part, const char *content_id)
{
g_return_if_fail (GMIME_IS_PART (mime_part));
g_mime_object_set_content_id (GMIME_OBJECT (mime_part), content_id);
}
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();
}
}
/**
* g_mime_part_get_content_location:
* @mime_part: a #GMimePart object
*
* Gets the value of the Content-Location header if it exists, or
* %NULL otherwise.
*
* Returns: the content location for the specified mime part.
**/
const char *
g_mime_part_get_content_location (GMimePart *mime_part)
{
g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);
return mime_part->content_location;
}
/**
* g_mime_part_get_content_encoding:
* @mime_part: a #GMimePart object
*
* Gets the content encoding of the mime part.
*
* Returns: the content encoding for the specified mime part.
**/
GMimeContentEncoding
g_mime_part_get_content_encoding (GMimePart *mime_part)
{
g_return_val_if_fail (GMIME_IS_PART (mime_part), GMIME_CONTENT_ENCODING_DEFAULT);
return mime_part->encoding;
}
QNetworkReply*
MailNetworkManager::makeReply(const QNetworkRequest& req, GMimeObject* content)
{
auto ctype = g_mime_object_get_content_type(content);
char *mtstr = g_mime_content_type_to_string(ctype);
QString mediaType = QString::fromUtf8(mtstr);
g_free(mtstr);
const char *enc = g_mime_content_type_get_parameter(ctype, "charset");
if (enc != NULL) {
mediaType += "; charset=\"";
mediaType += QString::fromUtf8(enc);
mediaType += "\"";
}
g_return_val_if_fail(GMIME_IS_PART(content), NULL);
GMimeStream *stream = g_mime_stream_mem_new();
GMimeDataWrapper *wrapper = g_mime_part_get_content_object(GMIME_PART(content));
g_mime_data_wrapper_write_to_stream(wrapper, stream);
GByteArray *bytes = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(stream));
QByteArray buffer((const char*) bytes->data, bytes->len);
g_object_unref(stream);
qDebug() <<"making reply of length" <<buffer.size() <<"and type" <<mediaType;
return StaticHTTPReply::ok(req, buffer, mediaType);
}
static void
format_part_content_raw (GMimeObject *part)
{
if (! GMIME_IS_PART (part))
return;
GMimeStream *stream_stdout;
GMimeStream *stream_filter = NULL;
GMimeDataWrapper *wrapper;
stream_stdout = g_mime_stream_file_new (stdout);
g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);
stream_filter = g_mime_stream_filter_new (stream_stdout);
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);
}
static void process_message_callback(GMimeObject *part, gpointer user_data)
{
struct mime_cbinfo *cbinfo = user_data;
cbinfo->count++;
/* We strip off the headers before we get here, so should only see GMIME_IS_PART */
if (GMIME_IS_MESSAGE_PART(part)) {
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PART\n");
return;
} else if (GMIME_IS_MESSAGE_PARTIAL(part)) {
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PARTIAL\n");
return;
} else if (GMIME_IS_MULTIPART(part)) {
GList *l;
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MULTIPART, trying to process subparts\n");
l = GMIME_MULTIPART(part)->subparts;
while (l) {
process_message_callback(l->data, cbinfo);
l = l->next;
}
} else if (GMIME_IS_PART(part)) {
const char *filename;
if (ast_strlen_zero(filename = g_mime_part_get_filename(GMIME_PART(part)))) {
ast_debug(1, "Skipping part with no filename\n");
return;
}
post_raw(GMIME_PART(part), cbinfo->post_dir, filename);
} else {
ast_log(LOG_ERROR, "Encountered unknown MIME part. This should never happen!\n");
}
}
/**
* g_mime_part_get_content_object:
* @mime_part: a #GMimePart object
*
* Gets the internal data-wrapper of the specified mime part, or %NULL
* on error.
*
* Returns: (transfer none): the data-wrapper for the mime part's
* contents.
**/
GMimeDataWrapper *
g_mime_part_get_content_object (GMimePart *mime_part)
{
g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);
return mime_part->content;
}
const gchar *
libbalsa_message_body_charset(LibBalsaMessageBody * body)
{
const gchar *charset;
if (!body)
return NULL;
if (body->charset) /* This overrides all! Important for non
* us-ascii messages over IMAP. */
return body->charset;
if (GMIME_IS_PART(body->mime_part)) {
GMimeContentType *type;
type = g_mime_object_get_content_type(body->mime_part);
return g_mime_content_type_get_parameter(type, "charset");
}
charset = libbalsa_message_body_charset(body->parts);
if (charset)
return charset;
return libbalsa_message_body_charset(body->next);
}
static gboolean
handle_mime_object (MuMsg *msg, GMimeObject *mobj, GMimeObject *parent,
MuMsgOptions opts, unsigned *index, gboolean decrypted,
MuMsgPartForeachFunc func, gpointer user_data)
{
if (GMIME_IS_PART (mobj))
return handle_part
(msg, GMIME_PART(mobj), parent,
opts, index, decrypted, func, user_data);
else if (GMIME_IS_MESSAGE_PART (mobj))
return handle_message_part
(msg, GMIME_MESSAGE_PART(mobj),
parent, opts, index, decrypted, func, user_data);
else if ((opts & MU_MSG_OPTION_VERIFY) &&
GMIME_IS_MULTIPART_SIGNED (mobj)) {
check_signature
(msg, GMIME_MULTIPART_SIGNED (mobj), opts);
return handle_multipart
(msg, GMIME_MULTIPART (mobj), mobj, opts,
index, decrypted, func, user_data);
} else if ((opts & MU_MSG_OPTION_DECRYPT) &&
GMIME_IS_MULTIPART_ENCRYPTED (mobj))
return handle_encrypted_part
(msg, GMIME_MULTIPART_ENCRYPTED (mobj),
opts, index, func, user_data);
else if (GMIME_IS_MULTIPART (mobj))
return handle_multipart
(msg, GMIME_MULTIPART (mobj), parent, opts,
index, decrypted, func, user_data);
return TRUE;
}
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();
}
}
/**
* g_mime_part_get_best_content_encoding:
* @mime_part: a #GMimePart object
* @constraint: a #GMimeEncodingConstraint
*
* Calculates the most efficient content encoding for the @mime_part
* given the @constraint.
*
* Returns: the best content encoding for the specified mime part.
**/
GMimeContentEncoding
g_mime_part_get_best_content_encoding (GMimePart *mime_part, GMimeEncodingConstraint constraint)
{
GMimeStream *filtered, *stream;
GMimeContentEncoding encoding;
GMimeFilterBest *best;
GMimeFilter *filter;
g_return_val_if_fail (GMIME_IS_PART (mime_part), GMIME_CONTENT_ENCODING_DEFAULT);
stream = g_mime_stream_null_new ();
filtered = g_mime_stream_filter_new (stream);
g_object_unref (stream);
filter = g_mime_filter_best_new (GMIME_FILTER_BEST_ENCODING);
g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter);
best = (GMimeFilterBest *) filter;
g_mime_data_wrapper_write_to_stream (mime_part->content, filtered);
g_mime_stream_flush (filtered);
g_object_unref (filtered);
encoding = g_mime_filter_best_encoding (best, constraint);
g_object_unref (best);
return encoding;
}
static void
accumulate_body (MuMsg *msg, MuMsgPart *mpart, BodyData *bdata)
{
char *txt;
gboolean err;
/* if it looks like an attachment, skip it */
if (mpart->part_type & MU_MSG_PART_TYPE_ATTACHMENT)
return;
if (!GMIME_IS_PART(mpart->data))
return;
txt = NULL;
err = TRUE;
if (!bdata->want_html &&
(mpart->part_type & MU_MSG_PART_TYPE_TEXT_PLAIN))
txt = mu_msg_mime_part_to_string (
(GMimePart*)mpart->data, &err);
else if (bdata->want_html &&
(mpart->part_type & MU_MSG_PART_TYPE_TEXT_HTML))
txt = mu_msg_mime_part_to_string (
(GMimePart*)mpart->data, &err);
if (!err && txt)
bdata->gstr = g_string_append (bdata->gstr, txt);
g_free (txt);
}
static void
accumulate_text (MuMsg *msg, MuMsgPart *part, GString **gstrp)
{
if (GMIME_IS_MESSAGE(part->data))
accumulate_text_message (msg, part, gstrp);
else if (GMIME_IS_PART (part->data))
accumulate_text_part (msg, part, gstrp);
}
/**
* g_mime_part_set_content_encoding:
* @mime_part: a #GMimePart object
* @encoding: a #GMimeContentEncoding
*
* Set the content encoding for the specified mime part.
**/
void
g_mime_part_set_content_encoding (GMimePart *mime_part, GMimeContentEncoding encoding)
{
g_return_if_fail (GMIME_IS_PART (mime_part));
mime_part->encoding = encoding;
g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Transfer-Encoding",
g_mime_content_encoding_to_string (encoding));
}
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_set_filename:
* @mime_part: a #GMimePart object
* @filename: the file name
*
* Sets the "filename" parameter on the Content-Disposition and also sets the
* "name" parameter on the Content-Type.
*
* Note: The @filename string should be in UTF-8.
**/
void
g_mime_part_set_filename (GMimePart *mime_part, const char *filename)
{
GMimeObject *object = (GMimeObject *) mime_part;
g_return_if_fail (GMIME_IS_PART (mime_part));
g_mime_object_set_content_disposition_parameter (object, "filename", filename);
g_mime_object_set_content_type_parameter (object, "name", filename);
}
/**
* g_mime_part_set_content_object:
* @mime_part: a #GMimePart object
* @content: a #GMimeDataWrapper content object
*
* Sets the content object on the mime part.
**/
void
g_mime_part_set_content_object (GMimePart *mime_part, GMimeDataWrapper *content)
{
g_return_if_fail (GMIME_IS_PART (mime_part));
if (mime_part->content == content)
return;
GMIME_PART_GET_CLASS (mime_part)->set_content_object (mime_part, content);
}
/**
* 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);
}
/**
* g_mime_part_set_content_location:
* @mime_part: a #GMimePart object
* @content_location: content location
*
* Set the content location for the specified mime part.
**/
void
g_mime_part_set_content_location (GMimePart *mime_part, const char *content_location)
{
g_return_if_fail (GMIME_IS_PART (mime_part));
if (mime_part->content_location == content_location)
return;
g_free (mime_part->content_location);
mime_part->content_location = g_strdup (content_location);
g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Location", content_location);
}
/**
* g_mime_part_set_content_md5:
* @mime_part: a #GMimePart object
* @content_md5: content md5 or %NULL to generate the md5 digest.
*
* Set the content md5 for the specified mime part.
**/
void
g_mime_part_set_content_md5 (GMimePart *mime_part, const char *content_md5)
{
unsigned char digest[16], b64digest[32];
GMimeStreamFilter *filtered_stream;
GMimeContentType *content_type;
GMimeFilter *md5_filter;
GMimeStream *stream;
guint32 save = 0;
int state = 0;
size_t len;
g_return_if_fail (GMIME_IS_PART (mime_part));
g_free (mime_part->content_md5);
if (!content_md5) {
/* compute a md5sum */
stream = g_mime_stream_null_new ();
filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream);
g_object_unref (stream);
content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part);
if (g_mime_content_type_is_type (content_type, "text", "*")) {
GMimeFilter *crlf_filter;
crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE);
g_mime_stream_filter_add (filtered_stream, crlf_filter);
g_object_unref (crlf_filter);
}
md5_filter = g_mime_filter_md5_new ();
g_mime_stream_filter_add (filtered_stream, md5_filter);
stream = (GMimeStream *) filtered_stream;
g_mime_data_wrapper_write_to_stream (mime_part->content, stream);
g_object_unref (stream);
memset (digest, 0, 16);
g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest);
g_object_unref (md5_filter);
len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save);
b64digest[len] = '\0';
g_strstrip ((char *) b64digest);
content_md5 = (const char *) b64digest;
}
mime_part->content_md5 = g_strdup (content_md5);
g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Md5", content_md5);
}
/**
* g_mime_part_get_filename:
* @mime_part: a #GMimePart object
*
* Gets the filename of the specificed mime part, or %NULL if the
* @mime_part does not have the filename or name parameter set.
*
* Returns: the filename of the specified @mime_part or %NULL if
* neither of the parameters is set. If a file name is set, the
* returned string will be in UTF-8.
**/
const char *
g_mime_part_get_filename (GMimePart *mime_part)
{
GMimeObject *object = (GMimeObject *) mime_part;
const char *filename = NULL;
g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);
if ((filename = g_mime_object_get_content_disposition_parameter (object, "filename")))
return filename;
/* check the "name" param in the content-type */
return g_mime_object_get_content_type_parameter (object, "name");
}
/**
* g_mime_part_verify_content_md5:
* @mime_part: a #GMimePart object
*
* Verify the content md5 for the specified mime part.
*
* Returns: %TRUE if the md5 is valid or %FALSE otherwise. Note: will
* return %FALSE if the mime part does not contain a Content-MD5.
**/
gboolean
g_mime_part_verify_content_md5 (GMimePart *mime_part)
{
unsigned char digest[16], b64digest[32];
GMimeStreamFilter *filtered_stream;
GMimeContentType *content_type;
GMimeFilter *md5_filter;
GMimeStream *stream;
guint32 save = 0;
int state = 0;
size_t len;
g_return_val_if_fail (GMIME_IS_PART (mime_part), FALSE);
g_return_val_if_fail (mime_part->content != NULL, FALSE);
if (!mime_part->content_md5)
return FALSE;
stream = g_mime_stream_null_new ();
filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream);
g_object_unref (stream);
content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part);
if (g_mime_content_type_is_type (content_type, "text", "*")) {
GMimeFilter *crlf_filter;
crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE);
g_mime_stream_filter_add (filtered_stream, crlf_filter);
g_object_unref (crlf_filter);
}
md5_filter = g_mime_filter_md5_new ();
g_mime_stream_filter_add (filtered_stream, md5_filter);
stream = (GMimeStream *) filtered_stream;
g_mime_data_wrapper_write_to_stream (mime_part->content, stream);
g_object_unref (stream);
memset (digest, 0, 16);
g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest);
g_object_unref (md5_filter);
len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save);
b64digest[len] = '\0';
g_strstrip ((char *) b64digest);
return !strcmp ((char *) b64digest, mime_part->content_md5);
}
gint64
mux_message_part_get_size (MuxMessagePart *self)
{
GMimeStream *mstream;
g_return_val_if_fail (MUX_IS_MESSAGE_PART(self), FALSE);
if (!GMIME_IS_PART(self->mime_object))
return 0;
mstream = get_mime_stream (self->mime_object, NULL);
if (!mstream)
return -1;
return g_mime_stream_length (mstream);
}
static gboolean
handle_encrypted_part (MuMsg *msg, GMimeMultipartEncrypted *part,
MuMsgOptions opts, unsigned *index,
MuMsgPartForeachFunc func, gpointer user_data)
{
GError *err;
gboolean rv;
GMimeObject *dec;
MuMsgPartPasswordFunc pw_func;
if (opts & MU_MSG_OPTION_CONSOLE_PASSWORD)
pw_func = (MuMsgPartPasswordFunc)get_console_pw;
else
pw_func = NULL;
err = NULL;
dec = mu_msg_crypto_decrypt_part (part, opts, pw_func, NULL, &err);
if (err) {
g_warning ("error decrypting part: %s", err->message);
g_clear_error (&err);
}
if (dec) {
rv = handle_mime_object (msg, dec, (GMimeObject *) part,
opts, index, TRUE, func, user_data);
g_object_unref (dec);
} else {
/* On failure to decrypt, list the encrypted part as
* an attachment
*/
GMimeObject *encrypted;
encrypted = g_mime_multipart_get_part (
GMIME_MULTIPART (part), 1);
g_return_val_if_fail (GMIME_IS_PART(encrypted), FALSE);
rv = handle_mime_object (msg, encrypted, (GMimeObject *) part,
opts, index, FALSE, func, user_data);
}
return rv;
}
static gboolean
save_object (GMimeObject *obj, MuMsgOptions opts, const char *fullpath,
GError **err)
{
int fd;
gboolean rv;
gboolean use_existing, overwrite;
use_existing = opts & MU_MSG_OPTION_USE_EXISTING;
overwrite = opts & MU_MSG_OPTION_OVERWRITE;
/* don't try to overwrite when we already have it; useful when
* you're sure it's not a different file with the same name */
if (use_existing && access (fullpath, F_OK) == 0)
return TRUE;
/* ok, try to create the file */
fd = mu_util_create_writeable_fd (fullpath, 0600, overwrite);
if (fd == -1) {
g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_FILE,
"could not open '%s' for writing: %s",
fullpath, errno ? strerror(errno) : "error");
return FALSE;
}
if (GMIME_IS_PART (obj))
rv = write_part_to_fd ((GMimePart*)obj, fd, err);
else
rv = write_object_to_fd (obj, fd, err);
/* Unref it since it was referenced earlier by
* get_mime_object_at_index */
g_object_unref (obj);
if (close (fd) != 0 && !err) { /* don't write on top of old err */
g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_FILE,
"could not close '%s': %s",
fullpath, errno ? strerror(errno) : "error");
return FALSE;
}
return rv;
}