[balsa] message: Declare it final
- From: Peter Bloomfield <peterb src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [balsa] message: Declare it final
- Date: Thu, 11 Jul 2019 17:34:10 +0000 (UTC)
commit 76e30816ef7d33bc12924bf015d79d443a8c4ffe
Author: Peter Bloomfield <PeterBloomfield bellsouth net>
Date: Thu Jul 11 13:32:26 2019 -0400
message: Declare it final
Use G_DECLARE_FINAL_TYPE to declare LibBalsaMessage, make it
private, and provide necessary getters and setters.
* libbalsa/autocrypt.c (autocrypt_from_message):
* libbalsa/body.c (libbalsa_message_body_set_text_rfc822headers),
(libbalsa_message_body_get_part_stream),
(libbalsa_message_body_get_message_part_stream),
(libbalsa_message_body_get_stream),
(libbalsa_message_body_get_content),
(libbalsa_message_body_get_pixbuf),
(libbalsa_message_body_save_stream):
* libbalsa/filter.c (libbalsa_condition_matches),
(libbalsa_condition_can_match):
* libbalsa/mailbox.c (get_from_field),
(lbm_index_entry_populate_from_msg),
(libbalsa_mailbox_real_release_message),
(libbalsa_mailbox_release_message),
(libbalsa_mailbox_set_msg_headers),
(libbalsa_mailbox_get_message_part), (lbm_get_mime_msg),
(lbm_try_reassemble):
* libbalsa/mailbox_imap.c (lbimap_update_flags), (imap_flags_cb),
(imap_expunge_cb), (free_messages_info),
(libbalsa_mailbox_imap_load_envelope),
(libbalsa_mailbox_imap_get_message), (get_struct_from_cache),
(libbalsa_mailbox_imap_fetch_structure),
(libbalsa_mailbox_imap_fetch_headers), (get_section_for),
(lbm_imap_get_msg_part_from_cache):
* libbalsa/mailbox_local.c (lbm_local_get_message_with_msg_info),
(message_match_real), (libbalsa_mailbox_local_cache_message),
(libbalsa_mailbox_local_fetch_structure),
(libbalsa_mailbox_local_fetch_headers),
(libbalsa_mailbox_local_messages_change_flags):
* libbalsa/mailbox_maildir.c (libbalsa_mailbox_maildir_check),
(free_message_info), (libbalsa_mailbox_maildir_sync),
(libbalsa_mailbox_maildir_fetch_message_structure):
* libbalsa/mailbox_mbox.c (parse_mailbox), (free_message_info),
(libbalsa_mailbox_mbox_sync),
(libbalsa_mailbox_mbox_fetch_message_structure),
(lbm_mbox_add_message):
* libbalsa/mailbox_mh.c (lbm_mh_free_message_info),
(libbalsa_mailbox_mh_check), (libbalsa_mailbox_mh_sync),
(libbalsa_mailbox_mh_fetch_message_structure):
* libbalsa/message.c (libbalsa_message_class_init),
(libbalsa_message_dispose), (libbalsa_message_finalize),
(lb_message_headers_extra_destroy),
(libbalsa_message_headers_destroy),
(libbalsa_message_body_charset),
(libbalsa_message_header_get_helper),
ChangeLog | 145 +++++
libbalsa/autocrypt.c | 37 +-
libbalsa/body.c | 39 +-
libbalsa/filter.c | 43 +-
libbalsa/mailbox.c | 92 +--
libbalsa/mailbox_imap.c | 184 +++---
libbalsa/mailbox_local.c | 78 ++-
libbalsa/mailbox_maildir.c | 26 +-
libbalsa/mailbox_mbox.c | 48 +-
libbalsa/mailbox_mh.c | 38 +-
libbalsa/message.c | 1270 ++++++++++++++++++++++++++-----------
libbalsa/message.h | 232 +++----
libbalsa/rfc3156.c | 14 +-
libbalsa/send.c | 217 ++++---
libbalsa/source-viewer.c | 18 +-
src/balsa-message.c | 151 +++--
src/balsa-mime-widget-message.c | 8 +-
src/balsa-mime-widget-text.c | 2 +-
src/balsa-mime-widget-vcalendar.c | 40 +-
src/balsa-mime-widget.c | 2 +-
src/balsa-print-object-header.c | 6 +-
src/main-window.c | 5 +-
src/message-window.c | 41 +-
src/print-gtk.c | 9 +-
src/sendmsg-window.c | 243 ++++---
src/store-address.c | 13 +-
26 files changed, 1932 insertions(+), 1069 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 2158d7b4f..6eeaa5ca3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,148 @@
+2019-07-11 Peter Bloomfield <pbloomfield bellsouth net>
+
+ message: Declare it final
+
+ Use G_DECLARE_FINAL_TYPE to declare LibBalsaMessage, make it
+ private, and provide necessary getters and setters.
+
+ * libbalsa/autocrypt.c (autocrypt_from_message):
+ * libbalsa/body.c (libbalsa_message_body_set_text_rfc822headers),
+ (libbalsa_message_body_get_part_stream),
+ (libbalsa_message_body_get_message_part_stream),
+ (libbalsa_message_body_get_stream),
+ (libbalsa_message_body_get_content),
+ (libbalsa_message_body_get_pixbuf),
+ (libbalsa_message_body_save_stream):
+ * libbalsa/filter.c (libbalsa_condition_matches),
+ (libbalsa_condition_can_match):
+ * libbalsa/mailbox.c (get_from_field),
+ (lbm_index_entry_populate_from_msg),
+ (libbalsa_mailbox_real_release_message),
+ (libbalsa_mailbox_release_message),
+ (libbalsa_mailbox_set_msg_headers),
+ (libbalsa_mailbox_get_message_part), (lbm_get_mime_msg),
+ (lbm_try_reassemble):
+ * libbalsa/mailbox_imap.c (lbimap_update_flags), (imap_flags_cb),
+ (imap_expunge_cb), (free_messages_info),
+ (libbalsa_mailbox_imap_load_envelope),
+ (libbalsa_mailbox_imap_get_message), (get_struct_from_cache),
+ (libbalsa_mailbox_imap_fetch_structure),
+ (libbalsa_mailbox_imap_fetch_headers), (get_section_for),
+ (lbm_imap_get_msg_part_from_cache):
+ * libbalsa/mailbox_local.c (lbm_local_get_message_with_msg_info),
+ (message_match_real), (libbalsa_mailbox_local_cache_message),
+ (libbalsa_mailbox_local_fetch_structure),
+ (libbalsa_mailbox_local_fetch_headers),
+ (libbalsa_mailbox_local_messages_change_flags):
+ * libbalsa/mailbox_maildir.c (libbalsa_mailbox_maildir_check),
+ (free_message_info), (libbalsa_mailbox_maildir_sync),
+ (libbalsa_mailbox_maildir_fetch_message_structure):
+ * libbalsa/mailbox_mbox.c (parse_mailbox), (free_message_info),
+ (libbalsa_mailbox_mbox_sync),
+ (libbalsa_mailbox_mbox_fetch_message_structure),
+ (lbm_mbox_add_message):
+ * libbalsa/mailbox_mh.c (lbm_mh_free_message_info),
+ (libbalsa_mailbox_mh_check), (libbalsa_mailbox_mh_sync),
+ (libbalsa_mailbox_mh_fetch_message_structure):
+ * libbalsa/message.c (libbalsa_message_class_init),
+ (libbalsa_message_dispose), (libbalsa_message_finalize),
+ (lb_message_headers_extra_destroy),
+ (libbalsa_message_headers_destroy),
+ (libbalsa_message_body_charset),
+ (libbalsa_message_header_get_helper),
+ (libbalsa_message_find_user_hdr),
+ (libbalsa_message_header_get_one),
+ (libbalsa_message_header_get_all),
+ (libbalsa_message_get_user_header),
+ (libbalsa_message_set_user_header), (prepend_header_misc),
+ (libbalsa_message_user_hdrs_from_gmime),
+ (libbalsa_message_get_part_by_id), (libbalsa_message_save),
+ (libbalsa_message_get_attach_icon), (libbalsa_message_reply),
+ (libbalsa_message_body_ref), (libbalsa_message_body_unref),
+ (libbalsa_message_is_multipart), (libbalsa_message_is_partial),
+ (has_attached_part), (libbalsa_message_has_attachment),
+ (libbalsa_message_get_subject), (libbalsa_message_get_lines),
+ (libbalsa_message_get_length), (lb_message_recipients),
+ (lb_message_headers_basic_from_gmime),
+ (lb_message_headers_extra_from_gmime),
+ (libbalsa_message_init_from_gmime),
+ (libbalsa_message_refs_for_threading), (references_decode),
+ (libbalsa_message_set_references_from_string),
+ (libbalsa_message_set_in_reply_to_from_string), (lbmsg_set_header),
+ (lb_message_set_headers_from_string),
+ (libbalsa_message_load_envelope_from_stream),
+ (libbalsa_message_load_envelope), (libbalsa_message_stream),
+ (libbalsa_message_copy), (libbalsa_message_set_subject),
+ (libbalsa_message_set_subject_from_header),
+ (libbalsa_message_get_tempdir), (libbalsa_message_get_mailbox),
+ (libbalsa_message_get_headers), (libbalsa_message_get_body_list),
+ (libbalsa_message_get_mime_message), (libbalsa_message_get_flags),
+ (libbalsa_message_get_message_id), (libbalsa_message_get_msgno),
+ (libbalsa_message_get_has_all_headers),
+ (libbalsa_message_get_sender), (libbalsa_message_get_request_dsn),
+ (libbalsa_message_get_references), (libbalsa_message_get_identity),
+ (libbalsa_message_get_parameters), (libbalsa_message_get_subtype),
+ (libbalsa_message_get_gpg_mode),
+ (libbalsa_message_get_in_reply_to),
+ (libbalsa_message_get_attach_pubkey),
+ (libbalsa_message_get_protect_state),
+ (libbalsa_message_get_body_ref), (libbalsa_message_set_flags),
+ (libbalsa_message_set_mailbox), (libbalsa_message_set_msgno),
+ (libbalsa_message_set_has_all_headers),
+ (libbalsa_message_set_length), (libbalsa_message_set_mime_message),
+ (libbalsa_message_set_sender), (libbalsa_message_set_message_id),
+ (libbalsa_message_set_protect_state),
+ (libbalsa_message_set_request_dsn), (libbalsa_message_set_subtype),
+ (libbalsa_message_set_body_list),
+ (libbalsa_message_set_references),
+ (libbalsa_message_set_in_reply_to),
+ (libbalsa_message_set_gpg_mode),
+ (libbalsa_message_set_attach_pubkey),
+ (libbalsa_message_set_identity), (libbalsa_message_add_parameters):
+ * libbalsa/message.h:
+ * libbalsa/rfc3156.c (libbalsa_body_check_signature),
+ (libbalsa_body_decrypt):
+ * libbalsa/send.c (lbs_message_queue_real),
+ (lbs_process_queue_msg), (balsa_send_message_success),
+ (balsa_send_message_error), (balsa_send_message_real),
+ (message_add_references), (libbalsa_message_create_mime_message),
+ (libbalsa_message_postpone), (libbalsa_create_msg),
+ (libbalsa_fill_msg_queue_item_from_queu), (lb_send_from),
+ (libbalsa_create_rfc2440_buffer), (do_multipart_crypto):
+ * libbalsa/source-viewer.c (lsv_escape_change_state),
+ (libbalsa_show_message_source):
+ * src/balsa-message.c (balsa_message_set),
+ (balsa_message_set_displayed_headers), (balsa_message_set_wrap),
+ (display_headers), (display_content), (handle_mdn_request),
+ (create_mdn_reply), (balsa_message_scan_signatures),
+ (libbalsa_msg_try_decrypt), (libbalsa_msg_part_2440),
+ (balsa_message_perform_crypto), (message_recheck_crypto_cb):
+ * src/balsa-mime-widget-message.c (extbody_send_mail):
+ * src/balsa-mime-widget-text.c (check_text_encoding):
+ * src/balsa-mime-widget-vcalendar.c
+ (balsa_mime_widget_new_vcalendar), (vevent_reply):
+ * src/balsa-mime-widget.c (balsa_mime_widget_new_unknown):
+ * src/balsa-print-object-header.c
+ (balsa_print_object_header_from_message):
+ * src/main-window.c (bw_index_changed_cb):
+ * src/message-window.c (message_window_idle_handler),
+ (mw_set_buttons_sensitive), (mw_expunged_cb), (mw_reply_activated),
+ (mw_reply_all_activated), (mw_reply_group_activated),
+ (mw_forward_attached_activated), (mw_forward_inline_activated),
+ (mw_forward_default_activated):
+ * src/print-gtk.c (begin_print):
+ * src/sendmsg-window.c (sw_delete_draft),
+ (balsa_sendmsg_destroy_handler), (update_bsmsg_identity),
+ (create_info_pane), (continue_body), (message_part_get_subject),
+ (quote_message_body), (fill_body_from_message),
+ (bsmsg_set_subject_from_body), (sw_save_draft),
+ (setup_headers_from_message), (set_identity_from_mailbox),
+ (guess_identity), (bsm_prepare_for_setup), (bsm_finish_setup),
+ (bsmsg2message), (check_autocrypt_recommendation),
+ (send_message_handler), (sendmsg_window_reply),
+ (sendmsg_window_forward), (sendmsg_window_continue):
+ * src/store-address.c (store_address_note_frame):
+
2019-07-11 Peter Bloomfield <pbloomfield bellsouth net>
Rename LIBBALSA_MAILBOX_REMOTE_SERVER() to
diff --git a/libbalsa/autocrypt.c b/libbalsa/autocrypt.c
index 739cd62aa..368f9c492 100644
--- a/libbalsa/autocrypt.c
+++ b/libbalsa/autocrypt.c
@@ -201,41 +201,46 @@ autocrypt_from_message(LibBalsaMessage *message,
{
const gchar *from_addr;
AutocryptData *autocrypt;
+ LibBalsaMessageHeaders *headers;
- g_return_if_fail(LIBBALSA_IS_MESSAGE(message) && (message->headers != NULL) &&
(message->headers->from != NULL) &&
- (message->headers->content_type != NULL) && (autocrypt_db != NULL));
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+ headers = libbalsa_message_get_headers(message);
+ g_return_if_fail(headers != NULL);
+ g_return_if_fail(headers->from != NULL);
+ g_return_if_fail(headers->content_type != NULL);
+ g_return_if_fail(autocrypt_db != NULL);
// FIXME - we should ignore spam - how can we detect it?
/* check for content types which shall be ignored
* Note: see Autocrypt Level 1 standard, section 2.3
(https://autocrypt.org/level1.html#updating-autocrypt-peer-state) for
* details about this and the following checks which may result in completely ignoring the
message. */
- if (autocrypt_ignore(message->headers->content_type)) {
- g_debug("ignore %s/%s", g_mime_content_type_get_media_type(message->headers->content_type),
- g_mime_content_type_get_media_subtype(message->headers->content_type));
+ if (autocrypt_ignore(headers->content_type)) {
+ g_debug("ignore %s/%s", g_mime_content_type_get_media_type(headers->content_type),
+ g_mime_content_type_get_media_subtype(headers->content_type));
return;
}
/* check for exactly one From: mailbox address - others shall be ignored */
- if ((internet_address_list_length(message->headers->from) != 1) ||
- !INTERNET_ADDRESS_IS_MAILBOX(internet_address_list_get_address(message->headers->from, 0))) {
+ if ((internet_address_list_length(headers->from) != 1) ||
+ !INTERNET_ADDRESS_IS_MAILBOX(internet_address_list_get_address(headers->from, 0))) {
g_debug("require exactly one From: address, ignored");
return;
}
/* ignore messages without a Date: header or with a date in the future */
- if ((message->headers->date == 0) || (message->headers->date > time(NULL))) {
+ if ((headers->date == 0) || (headers->date > time(NULL))) {
g_debug("no Date: header or value in the future, ignored");
return;
}
/* get the From: address (is a mailbox, checked above) */
from_addr =
-
internet_address_mailbox_get_addr(INTERNET_ADDRESS_MAILBOX(internet_address_list_get_address(message->headers->from,
0)));
- g_debug("message from '%s', date %ld", from_addr, message->headers->date);
+
internet_address_mailbox_get_addr(INTERNET_ADDRESS_MAILBOX(internet_address_list_get_address(headers->from,
0)));
+ g_debug("message from '%s', date %ld", from_addr, headers->date);
/* scan for Autocrypt headers */
- autocrypt = scan_autocrypt_headers(message->headers->user_hdrs, from_addr);
+ autocrypt = scan_autocrypt_headers(headers->user_hdrs, from_addr);
/* update the database */
G_LOCK(db_mutex);
@@ -244,19 +249,19 @@ autocrypt_from_message(LibBalsaMessage *message,
db_info = autocrypt_user_info(autocrypt->addr, error);
if (db_info != NULL) {
- if (message->headers->date > db_info->ac_timestamp) {
- add_or_update_user_info(autocrypt, message->headers->date, TRUE, error);
+ if (headers->date > db_info->ac_timestamp) {
+ add_or_update_user_info(autocrypt, headers->date, TRUE, error);
} else {
g_info("message timestamp %ld not newer than autocrypt db timestamp %ld, ignore
message",
- (long) message->headers->date, (long) db_info->ac_timestamp);
+ (long) headers->date, (long) db_info->ac_timestamp);
}
autocrypt_free(db_info);
} else {
- add_or_update_user_info(autocrypt, message->headers->date, FALSE, error);
+ add_or_update_user_info(autocrypt, headers->date, FALSE, error);
}
autocrypt_free(autocrypt);
} else {
- update_last_seen(from_addr, message->headers->date, error);
+ update_last_seen(from_addr, headers->date, error);
}
G_UNLOCK(db_mutex);
}
diff --git a/libbalsa/body.c b/libbalsa/body.c
index ffcd9738b..65be001bd 100644
--- a/libbalsa/body.c
+++ b/libbalsa/body.c
@@ -213,9 +213,11 @@ libbalsa_message_body_set_multipart(LibBalsaMessageBody * body,
static void
libbalsa_message_body_set_text_rfc822headers(LibBalsaMessageBody *body)
{
+ LibBalsaMailbox *mailbox;
GMimeStream *headers;
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
headers = libbalsa_message_body_get_stream(body, NULL);
if (headers != NULL) {
@@ -232,7 +234,7 @@ libbalsa_message_body_set_text_rfc822headers(LibBalsaMessageBody *body)
g_object_unref(dummy_msg);
}
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
}
static void
@@ -510,6 +512,8 @@ libbalsa_message_body_get_part_stream(LibBalsaMessageBody * body,
GMimeStream *stream_null;
GMimeStream *stream_filter;
GMimeFilter *filter_windows;
+ LibBalsaMailbox *mailbox;
+
stream_null = g_mime_stream_null_new();
stream_filter = g_mime_stream_filter_new(stream_null);
@@ -519,10 +523,11 @@ libbalsa_message_body_get_part_stream(LibBalsaMessageBody * body,
g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter),
filter_windows);
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
g_mime_stream_reset(stream);
g_mime_stream_write_to_stream(stream, stream_filter);
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
g_object_unref(stream_filter);
charset = g_mime_filter_windows_real_charset(GMIME_FILTER_WINDOWS
@@ -546,15 +551,17 @@ libbalsa_message_body_get_message_part_stream(LibBalsaMessageBody * body,
GError ** err)
{
GMimeStream *stream;
+ LibBalsaMailbox *mailbox;
ssize_t bytes_written;
GMimeMessage *msg = g_mime_message_part_get_message
(GMIME_MESSAGE_PART(body->mime_part));
stream = g_mime_stream_mem_new();
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
bytes_written =
g_mime_object_write_to_stream(GMIME_OBJECT(msg), stream);
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
printf("Written %ld bytes of embedded message\n",
(long) bytes_written);
@@ -576,7 +583,7 @@ libbalsa_message_body_get_stream(LibBalsaMessageBody * body, GError **err)
g_return_val_if_fail(body != NULL, NULL);
g_return_val_if_fail(body->message != NULL, NULL);
- if (!body->message->mailbox) {
+ if (libbalsa_message_get_mailbox(body->message) == NULL) {
if (err != NULL && *err == NULL) {
g_set_error(err, LIBBALSA_MAILBOX_ERROR,
LIBBALSA_MAILBOX_ACCESS_ERROR,
@@ -622,6 +629,7 @@ libbalsa_message_body_get_content(LibBalsaMessageBody * body, gchar ** buf,
{
GMimeStream *stream, *stream_mem;
GByteArray *array;
+ LibBalsaMailbox *mailbox;
gssize len;
g_return_val_if_fail(body != NULL, -1);
@@ -637,10 +645,11 @@ libbalsa_message_body_get_content(LibBalsaMessageBody * body, gchar ** buf,
stream_mem = g_mime_stream_mem_new_with_byte_array(array);
g_mime_stream_mem_set_owner(GMIME_STREAM_MEM(stream_mem), FALSE);
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
g_mime_stream_reset(stream);
len = g_mime_stream_write_to_stream(stream, stream_mem);
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
g_object_unref(stream);
g_object_unref(stream_mem);
@@ -664,6 +673,7 @@ GdkPixbuf *
libbalsa_message_body_get_pixbuf(LibBalsaMessageBody * body, GError ** err)
{
GMimeStream *stream;
+ LibBalsaMailbox *mailbox;
gchar *mime_type;
GdkPixbufLoader *loader;
GdkPixbuf *pixbuf = NULL;
@@ -672,7 +682,8 @@ libbalsa_message_body_get_pixbuf(LibBalsaMessageBody * body, GError ** err)
if (!stream)
return pixbuf;
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
g_mime_stream_reset(stream);
mime_type = libbalsa_message_body_get_mime_type(body);
@@ -706,7 +717,7 @@ libbalsa_message_body_get_pixbuf(LibBalsaMessageBody * body, GError ** err)
g_object_unref(loader);
}
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
g_object_unref(stream);
return pixbuf;
@@ -718,6 +729,7 @@ libbalsa_message_body_save_stream(LibBalsaMessageBody * body,
GError ** err)
{
GMimeStream *stream;
+ LibBalsaMailbox *mailbox;
ssize_t len;
stream = libbalsa_message_body_get_stream(body, err);
@@ -725,7 +737,8 @@ libbalsa_message_body_save_stream(LibBalsaMessageBody * body,
return FALSE;
g_clear_error(err);
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
if (stream) {
g_mime_stream_reset(stream);
@@ -742,7 +755,7 @@ libbalsa_message_body_save_stream(LibBalsaMessageBody * body,
/* body->mime_part is neither a GMimePart nor a GMimeMessagePart. */
len = g_mime_object_write_to_stream(body->mime_part, dest);
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
g_object_unref(dest);
if (len < 0)
diff --git a/libbalsa/filter.c b/libbalsa/filter.c
index 51e48d7c6..e85d36e09 100644
--- a/libbalsa/filter.c
+++ b/libbalsa/filter.c
@@ -104,13 +104,15 @@ gboolean
libbalsa_condition_matches(LibBalsaCondition* cond,
LibBalsaMessage * message)
{
+ LibBalsaMessageHeaders *headers;
gboolean match = FALSE;
gchar * str;
GString * body;
gboolean will_ref;
- g_return_val_if_fail(cond, FALSE);
- g_return_val_if_fail(message->headers != NULL, FALSE);
+ g_return_val_if_fail(cond != NULL, FALSE);
+ headers = libbalsa_message_get_headers(message);
+ g_return_val_if_fail(headers != NULL, FALSE);
switch (cond->type) {
case CONDITION_STRING:
@@ -128,20 +130,14 @@ libbalsa_condition_matches(LibBalsaCondition* cond,
}
}
/* do the work */
- if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_TO)
- && message->headers->to_list) {
- str =
- internet_address_list_to_string(message->headers->to_list,
- FALSE);
- match=libbalsa_utf8_strstr(str,cond->match.string.string);
+ if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_TO) && headers->to_list != NULL) {
+ str = internet_address_list_to_string(headers->to_list, FALSE);
+ match = libbalsa_utf8_strstr(str,cond->match.string.string);
g_free(str);
if(match) break;
}
- if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_FROM)
- && message->headers->from) {
- str =
- internet_address_list_to_string(message->headers->from,
- FALSE);
+ if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_FROM) && headers->from != NULL) {
+ str = internet_address_list_to_string(headers->from, FALSE);
match=libbalsa_utf8_strstr(str,cond->match.string.string);
g_free(str);
if (match) break;
@@ -153,11 +149,8 @@ libbalsa_condition_matches(LibBalsaCondition* cond,
break;
}
}
- if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_CC)
- && message->headers->cc_list) {
- str =
- internet_address_list_to_string(message->headers->cc_list,
- FALSE);
+ if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_CC) && headers->cc_list != NULL) {
+ str = internet_address_list_to_string(headers->cc_list, FALSE);
match=libbalsa_utf8_strstr(str,cond->match.string.string);
g_free(str);
if (match) break;
@@ -177,10 +170,10 @@ libbalsa_condition_matches(LibBalsaCondition* cond,
}
}
if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_BODY)) {
- if (!message->mailbox)
+ if (libbalsa_message_get_mailbox(message) == NULL)
return FALSE; /* We don't want to match if an error occurred */
- body =
- content2reply(message->body_list, NULL, 0, FALSE, FALSE);
+ body = content2reply(libbalsa_message_get_body_list(message),
+ NULL, 0, FALSE, FALSE);
if (body) {
if (body->str)
match = libbalsa_utf8_strstr(body->str,
@@ -193,9 +186,9 @@ libbalsa_condition_matches(LibBalsaCondition* cond,
case CONDITION_REGEX:
break;
case CONDITION_DATE:
- match = message->headers->date>=cond->match.date.date_low
+ match = headers->date >= cond->match.date.date_low
&& (cond->match.date.date_high==0 ||
- message->headers->date<=cond->match.date.date_high);
+ headers->date <= cond->match.date.date_high);
break;
case CONDITION_FLAG:
match = LIBBALSA_MESSAGE_HAS_FLAG(message, cond->match.flags);
@@ -373,9 +366,9 @@ libbalsa_condition_can_match(LibBalsaCondition * cond,
switch (cond->type) {
case CONDITION_STRING:
return !(CONDITION_CHKMATCH(cond, CONDITION_MATCH_BODY)
- && message->body_list == NULL)
+ && libbalsa_message_get_body_list(message) == NULL)
&& !(CONDITION_CHKMATCH(cond, CONDITION_MATCH_US_HEAD)
- && message->mime_msg == NULL);
+ && libbalsa_message_get_mime_message(message) == NULL);
case CONDITION_AND:
case CONDITION_OR:
return libbalsa_condition_can_match(cond->match.andor.left,
diff --git a/libbalsa/mailbox.c b/libbalsa/mailbox.c
index 6d9152bc7..a273ba0ef 100644
--- a/libbalsa/mailbox.c
+++ b/libbalsa/mailbox.c
@@ -295,26 +295,26 @@ libbalsa_mailbox_dispose(GObject * object)
static gchar*
-get_from_field(LibBalsaMessage *message)
+get_from_field(LibBalsaMailbox *mailbox, LibBalsaMessage *message)
{
- LibBalsaMailbox *mailbox = message->mailbox;
LibBalsaMailboxPrivate *priv = libbalsa_mailbox_get_instance_private(mailbox);
+ LibBalsaMessageHeaders *headers;
InternetAddressList *address_list = NULL;
const gchar *name_str = NULL;
gboolean append_dots = FALSE;
gchar *from;
- g_return_val_if_fail(message->mailbox, NULL);
+ headers = libbalsa_message_get_headers(message);
- if (message->headers) {
+ if (headers != NULL) {
if (priv->view &&
priv->view->show == LB_MAILBOX_SHOW_TO)
- address_list = message->headers->to_list;
+ address_list = headers->to_list;
else
- address_list = message->headers->from;
+ address_list = headers->from;
}
- if (address_list) {
+ if (address_list != NULL) {
gint i, len = internet_address_list_length(address_list);
for (i = 0; i < len && name_str == NULL; i++) {
@@ -360,22 +360,25 @@ get_from_field(LibBalsaMessage *message)
static void
lbm_index_entry_populate_from_msg(LibBalsaMailboxIndexEntry * entry,
- LibBalsaMessage * msg)
+ LibBalsaMessage * message)
{
- entry->from = get_from_field(msg);
- entry->subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(msg));
- entry->msg_date = msg->headers->date;
+ LibBalsaMailbox *mailbox = libbalsa_message_get_mailbox(message);
+
+ entry->from = get_from_field(mailbox, message);
+ entry->subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(message));
+ entry->msg_date = libbalsa_message_get_headers(message)->date;
entry->internal_date = 0; /* FIXME */
- entry->status_icon = libbalsa_get_icon_from_flags(msg->flags);
- entry->attach_icon = libbalsa_message_get_attach_icon(msg);
- entry->size = msg->length;
+ entry->status_icon = libbalsa_get_icon_from_flags(libbalsa_message_get_flags(message));
+ entry->attach_icon = libbalsa_message_get_attach_icon(message);
+ entry->size = libbalsa_message_get_length(message);
entry->foreground = NULL;
entry->background = NULL;
entry->foreground_set = 0;
entry->background_set = 0;
- entry->unseen = LIBBALSA_MESSAGE_IS_UNREAD(msg);
+ entry->unseen = LIBBALSA_MESSAGE_IS_UNREAD(message);
entry->idle_pending = 0;
- libbalsa_mailbox_msgno_changed(msg->mailbox, msg->msgno);
+
+ libbalsa_mailbox_msgno_changed(mailbox, libbalsa_message_get_msgno(message));
}
static LibBalsaMailboxIndexEntry*
@@ -982,10 +985,7 @@ static void
libbalsa_mailbox_real_release_message(LibBalsaMailbox * mailbox,
LibBalsaMessage * message)
{
- if (message->mime_msg) {
- g_object_unref(message->mime_msg);
- message->mime_msg = NULL;
- }
+ libbalsa_message_set_mime_message(message, NULL);
}
struct MsgCopyData {
@@ -2057,10 +2057,9 @@ libbalsa_mailbox_release_message(LibBalsaMailbox * mailbox,
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
g_return_if_fail(message != NULL);
g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
- g_return_if_fail(mailbox == message->mailbox);
+ g_return_if_fail(mailbox == libbalsa_message_get_mailbox(message));
- LIBBALSA_MAILBOX_GET_CLASS(mailbox)
- ->release_message(mailbox, message);
+ LIBBALSA_MAILBOX_GET_CLASS(mailbox)->release_message(mailbox, message);
}
void
@@ -2070,10 +2069,11 @@ libbalsa_mailbox_set_msg_headers(LibBalsaMailbox *mailbox,
g_return_if_fail(mailbox != NULL);
g_return_if_fail(LIBBALSA_IS_MAILBOX(mailbox));
g_return_if_fail(message != NULL);
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
- if(!message->has_all_headers) {
+ if(!libbalsa_message_get_has_all_headers(message)) {
LIBBALSA_MAILBOX_GET_CLASS(mailbox)->fetch_headers(mailbox, message);
- message->has_all_headers = 1;
+ libbalsa_message_set_has_all_headers(message, TRUE);
}
}
@@ -2082,13 +2082,16 @@ libbalsa_mailbox_get_message_part(LibBalsaMessage *message,
LibBalsaMessageBody *part,
GError **err)
{
- g_return_val_if_fail(message != NULL, FALSE);
- g_return_val_if_fail(message->mailbox != NULL, FALSE);
- g_return_val_if_fail(LIBBALSA_IS_MAILBOX(message->mailbox), FALSE);
+ LibBalsaMailbox *mailbox;
+
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
+
+ mailbox = libbalsa_message_get_mailbox(message);
+ g_return_val_if_fail(mailbox != NULL, FALSE);
+ g_return_val_if_fail(LIBBALSA_IS_MAILBOX(mailbox), FALSE);
g_return_val_if_fail(part != NULL, FALSE);
- return LIBBALSA_MAILBOX_GET_CLASS(message->mailbox)
- ->get_message_part(message, part, err);
+ return LIBBALSA_MAILBOX_GET_CLASS(mailbox)->get_message_part(message, part, err);
}
GMimeStream *
@@ -4177,28 +4180,32 @@ libbalsa_mailbox_set_msg_tree(LibBalsaMailbox * mailbox, GNode * new_tree)
}
static GMimeMessage *
-lbm_get_mime_msg(LibBalsaMailbox * mailbox, LibBalsaMessage * msg)
+lbm_get_mime_msg(LibBalsaMailbox * mailbox, LibBalsaMessage *message)
{
GMimeMessage *mime_msg;
- if (!msg->mime_msg)
- libbalsa_mailbox_fetch_message_structure(mailbox, msg,
+ mime_msg = libbalsa_message_get_mime_message(message);
+ if (mime_msg == NULL) {
+ libbalsa_mailbox_fetch_message_structure(mailbox, message,
LB_FETCH_RFC822_HEADERS);
- mime_msg = msg->mime_msg;
- if (mime_msg)
+ }
+ mime_msg = libbalsa_message_get_mime_message(message);
+
+ if (mime_msg != NULL) {
g_object_ref(mime_msg);
- else {
+ } else {
GMimeStream *stream;
GMimeParser *parser;
- stream = libbalsa_mailbox_get_message_stream(mailbox, msg->msgno,
+ stream = libbalsa_mailbox_get_message_stream(mailbox,
+ libbalsa_message_get_msgno(message),
TRUE);
parser = g_mime_parser_new_with_stream(stream);
g_object_unref(stream);
mime_msg = g_mime_parser_construct_message(parser);
g_object_unref(parser);
}
- libbalsa_mailbox_release_message(mailbox, msg);
+ libbalsa_mailbox_release_message(mailbox, message);
return mime_msg;
}
@@ -4316,16 +4323,21 @@ lbm_try_reassemble(LibBalsaMailbox * mailbox, const gchar * id)
}
if (partials->len == total) {
+ GMimeMessage *mime_message;
LibBalsaMessage *message = libbalsa_message_new();
- message->flags |= LIBBALSA_MESSAGE_FLAG_NEW;
+ libbalsa_message_set_flags(message, LIBBALSA_MESSAGE_FLAG_NEW);
libbalsa_information(LIBBALSA_INFORMATION_MESSAGE,
_("Reconstructing message"));
libbalsa_mailbox_lock_store(mailbox);
- message->mime_msg =
+
+ mime_message =
g_mime_message_partial_reconstruct_message((GMimeMessagePartial
**) partials->
pdata, total);
+ libbalsa_message_set_mime_message(message, mime_message);
+ g_object_unref(mime_message);
+
libbalsa_message_copy(message, mailbox, NULL);
libbalsa_mailbox_unlock_store(mailbox);
diff --git a/libbalsa/mailbox_imap.c b/libbalsa/mailbox_imap.c
index 15d675063..d87bd6247 100644
--- a/libbalsa/mailbox_imap.c
+++ b/libbalsa/mailbox_imap.c
@@ -637,17 +637,20 @@ libbalsa_mailbox_imap_get_handle(LibBalsaMailboxImap *mimap, GError **err)
static void
lbimap_update_flags(LibBalsaMessage *message, ImapMessage *imsg)
{
- message->flags = 0;
+ LibBalsaMessageFlag flags = 0;
+
if (!IMSG_FLAG_SEEN(imsg->flags))
- message->flags |= LIBBALSA_MESSAGE_FLAG_NEW;
+ flags |= LIBBALSA_MESSAGE_FLAG_NEW;
if (IMSG_FLAG_DELETED(imsg->flags))
- message->flags |= LIBBALSA_MESSAGE_FLAG_DELETED;
+ flags |= LIBBALSA_MESSAGE_FLAG_DELETED;
if (IMSG_FLAG_FLAGGED(imsg->flags))
- message->flags |= LIBBALSA_MESSAGE_FLAG_FLAGGED;
+ flags |= LIBBALSA_MESSAGE_FLAG_FLAGGED;
if (IMSG_FLAG_ANSWERED(imsg->flags))
- message->flags |= LIBBALSA_MESSAGE_FLAG_REPLIED;
+ flags |= LIBBALSA_MESSAGE_FLAG_REPLIED;
if (IMSG_FLAG_RECENT(imsg->flags))
- message->flags |= LIBBALSA_MESSAGE_FLAG_RECENT;
+ flags |= LIBBALSA_MESSAGE_FLAG_RECENT;
+
+ libbalsa_message_set_flags(message, flags);
}
/* mi_get_imsg is a thin wrapper around imap_mbox_handle_get_msg().
@@ -774,6 +777,7 @@ imap_flags_cb(unsigned cnt, const unsigned seqno[], LibBalsaMailboxImap *mimap)
message_info_from_msgno(mimap, seqno[i]);
if(msg_info && msg_info->message) {
LibBalsaMessageFlag flags;
+ LibBalsaMessageFlag new_flags;
/* since we are talking here about updating just received,
usually unsolicited flags from the server, we do not
need to go to great lengths to assure that the
@@ -782,17 +786,17 @@ imap_flags_cb(unsigned cnt, const unsigned seqno[], LibBalsaMailboxImap *mimap)
imap_mbox_handle_get_msg(mimap->handle, seqno[i]);
if(!imsg) continue;
- flags = msg_info->message->flags;
+ flags = libbalsa_message_get_flags(msg_info->message);
lbimap_update_flags(msg_info->message, imsg);
- if (flags == msg_info->message->flags)
+ new_flags = libbalsa_message_get_flags(msg_info->message);
+ if (flags == new_flags)
continue;
- libbalsa_mailbox_index_set_flags(mailbox, seqno[i],
- msg_info->message->flags);
+ libbalsa_mailbox_index_set_flags(mailbox, seqno[i], new_flags);
++mimap->search_stamp;
}
}
- if(!mimap->unread_update_id)
+ if (mimap->unread_update_id == 0)
mimap->unread_update_id =
g_idle_add((GSourceFunc)idle_unread_update_cb, mailbox);
libbalsa_unlock_mailbox(mailbox);
@@ -924,8 +928,8 @@ imap_expunge_cb(ImapMboxHandle *handle, unsigned seqno,
&g_array_index(mimap->messages_info, struct message_info, i);
g_assert(info != NULL);
- if (info->message)
- info->message->msgno = i + 1;
+ if (info->message != NULL)
+ libbalsa_message_set_msgno(info->message, i + 1);
}
libbalsa_unlock_mailbox(mailbox);
@@ -1122,8 +1126,8 @@ free_messages_info(LibBalsaMailboxImap * mbox)
gchar *msgid;
struct message_info *msg_info =
&g_array_index(messages_info, struct message_info, i);
- if (msg_info->message) {
- msg_info->message->mailbox = NULL;
+ if (msg_info->message != NULL) {
+ libbalsa_message_set_mailbox(msg_info->message, NULL);
g_object_unref(msg_info->message);
}
msgid = g_ptr_array_index(mbox->msgids, i);
@@ -1997,7 +2001,7 @@ libbalsa_mailbox_imap_load_envelope(LibBalsaMailboxImap *mimap,
gchar *hdr;
g_return_val_if_fail(mimap->opened, FALSE);
- imsg = mi_get_imsg(mimap, message->msgno);
+ imsg = mi_get_imsg(mimap, libbalsa_message_get_msgno(message));
if(!imsg || !imsg->envelope) {/* Connection severed and and restore
* failed - deal with it! */
@@ -2007,19 +2011,21 @@ libbalsa_mailbox_imap_load_envelope(LibBalsaMailboxImap *mimap,
lbimap_update_flags(message, imsg);
- lb_set_headers(message->headers, imsg->envelope, FALSE);
+ lb_set_headers(libbalsa_message_get_headers(message), imsg->envelope, FALSE);
+
if ((hdr = imsg->fetched_header_fields) && *hdr && *hdr != '\r')
libbalsa_message_set_headers_from_string(message, hdr);
- envelope = imsg->envelope;
- message->length = imsg->rfc822size;
+
+ libbalsa_message_set_length(message, imsg->rfc822size);
+ envelope = imsg->envelope;
libbalsa_message_set_subject_from_header(message, envelope->subject);
- message->sender =
- internet_address_new_list_from_imap_address_list(envelope->sender);
- libbalsa_message_set_in_reply_to_from_string(message,
- envelope->in_reply_to);
- if (envelope->message_id) {
- message->message_id =
- g_mime_utils_decode_message_id(envelope->message_id);
+ libbalsa_message_set_sender(message,
+ internet_address_new_list_from_imap_address_list(envelope->sender));
+ libbalsa_message_set_in_reply_to_from_string(message, envelope->in_reply_to);
+ if (envelope->message_id != NULL) {
+ gchar *message_id = g_mime_utils_decode_message_id(envelope->message_id);
+ libbalsa_message_set_message_id(message, message_id);
+ g_free(message_id);
}
return TRUE;
@@ -2040,18 +2046,20 @@ libbalsa_mailbox_imap_get_message(LibBalsaMailbox * mailbox, guint msgno)
}
if (!msg_info->message) {
- LibBalsaMessage *msg = libbalsa_message_new();
- msg->msgno = msgno;
- msg->mailbox = mailbox;
- if (libbalsa_mailbox_imap_load_envelope(mimap, msg)) {
+ LibBalsaMessage *message;
+
+ message = libbalsa_message_new();
+ libbalsa_message_set_msgno(message, msgno);
+ libbalsa_message_set_mailbox(message, mailbox);
+ if (libbalsa_mailbox_imap_load_envelope(mimap, message)) {
gchar *id;
- msg_info->message = msg;
- if (libbalsa_message_is_partial(msg, &id)) {
+ msg_info->message = message;
+ if (libbalsa_message_is_partial(message, &id)) {
libbalsa_mailbox_try_reassemble(mailbox, id);
g_free(id);
}
- } else
- g_object_unref(G_OBJECT(msg));
+ } else
+ g_object_unref(G_OBJECT(message));
}
if (msg_info->message)
g_object_ref(msg_info->message); /* we want to keep one copy */
@@ -2133,16 +2141,19 @@ static gboolean
get_struct_from_cache(LibBalsaMailbox *mailbox, LibBalsaMessage *message,
LibBalsaFetchFlag flags)
{
- if (!message->mime_msg) {
+ GMimeMessage *mime_msg;
+ LibBalsaMessageHeaders *headers;
+
+ if ((mime_msg = libbalsa_message_get_mime_message(message)) == NULL) {
gchar **pair, *filename;
int fd;
GMimeStream *stream, *fstream;
GMimeFilter *filter;
GMimeParser *mime_parser;
LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
- ImapMessage *imsg = mi_get_imsg(mimap, message->msgno);
+ ImapMessage *imsg = mi_get_imsg(mimap, libbalsa_message_get_msgno(message));
- if (!imsg)
+ if (imsg == NULL)
return FALSE;
pair = get_cache_name_pair(mimap, "body", imsg->uid);
@@ -2166,25 +2177,25 @@ get_struct_from_cache(LibBalsaMailbox *mailbox, LibBalsaMessage *message,
g_object_unref(fstream);
g_mime_parser_set_scan_from(mime_parser, FALSE);
- message->mime_msg = g_mime_parser_construct_message(mime_parser);
+ mime_msg = g_mime_parser_construct_message(mime_parser);
g_object_unref(mime_parser);
+
+ libbalsa_message_set_mime_message(message, mime_msg);
}
-
+
/* follow libbalsa_mailbox_local_fetch_structure here;
* perhaps create common helper */
- if(flags & LB_FETCH_STRUCTURE) {
+ headers = libbalsa_message_get_headers(message);
+ if (flags & LB_FETCH_STRUCTURE) {
LibBalsaMessageBody *body = libbalsa_message_body_new(message);
libbalsa_message_body_set_mime_body(body,
- message->mime_msg->mime_part);
+ mime_msg->mime_part);
libbalsa_message_append_part(message, body);
- libbalsa_message_headers_from_gmime(message->headers,
- message->mime_msg);
+ libbalsa_message_headers_from_gmime(headers, mime_msg);
}
- if(flags & LB_FETCH_RFC822_HEADERS) {
- g_assert(message->headers != NULL);
- message->headers->user_hdrs =
- libbalsa_message_user_hdrs_from_gmime(message->mime_msg);
- message->has_all_headers = 1;
+ if (flags & LB_FETCH_RFC822_HEADERS) {
+ headers->user_hdrs = libbalsa_message_user_hdrs_from_gmime(mime_msg);
+ libbalsa_message_set_has_all_headers(message, TRUE);
}
return TRUE;
}
@@ -2197,7 +2208,10 @@ libbalsa_mailbox_imap_fetch_structure(LibBalsaMailbox *mailbox,
ImapResponse rc;
LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
LibBalsaServer *server;
+ LibBalsaMessageHeaders *headers;
+ glong msgno;
ImapFetchType ift = 0;
+
g_return_val_if_fail(mimap->opened, FALSE);
/* Work around some server bugs by fetching the RFC2822 form of
@@ -2209,19 +2223,19 @@ libbalsa_mailbox_imap_fetch_structure(LibBalsaMailbox *mailbox,
parts yet. Also, we save some RTTS for very small messages by
fetching them in their entirety. */
server = LIBBALSA_MAILBOX_REMOTE_GET_SERVER(mailbox);
+ headers = libbalsa_message_get_headers(message);
+ msgno = libbalsa_message_get_msgno(message);
if(!imap_mbox_handle_can_do(mimap->handle, IMCAP_FETCHBODY) ||
libbalsa_imap_server_has_bug(LIBBALSA_IMAP_SERVER(server),
ISBUG_FETCH) ||
LIBBALSA_MESSAGE_GET_LENGTH(message)<8192 ||
- (message->headers &&
- (!message->headers->content_type ||
- !g_mime_content_type_is_type(message->headers->content_type,
- "multipart", "*"))) ){
+ (headers != NULL &&
+ (headers->content_type == NULL ||
+ !g_mime_content_type_is_type(headers->content_type, "multipart", "*"))) ){
/* we could optimize this part a little bit: we do not need to
* keep reopening the stream. */
GMimeStream *stream =
- libbalsa_mailbox_imap_get_message_stream(mailbox, message->msgno,
- FALSE);
+ libbalsa_mailbox_imap_get_message_stream(mailbox, msgno, FALSE);
if(!stream) /* oops, connection broken or the message disappeared? */
return FALSE;
g_object_unref(stream);
@@ -2234,12 +2248,10 @@ libbalsa_mailbox_imap_fetch_structure(LibBalsaMailbox *mailbox,
if(flags & LB_FETCH_STRUCTURE) ift |= IMFETCH_BODYSTRUCT;
II(rc, mimap->handle,
- imap_mbox_handle_fetch_range(mimap->handle, message->msgno,
- message->msgno, ift));
+ imap_mbox_handle_fetch_range(mimap->handle, msgno, msgno, ift));
if(rc == IMR_OK) { /* translate ImapData to LibBalsaMessage */
gchar *hdr;
- ImapMessage *im = imap_mbox_handle_get_msg(mimap->handle,
- message->msgno);
+ ImapMessage *im = imap_mbox_handle_get_msg(mimap->handle, msgno);
/* in case of msg number discrepancies: */
g_return_val_if_fail(im != NULL, FALSE);
if(flags & LB_FETCH_STRUCTURE) {
@@ -2250,7 +2262,7 @@ libbalsa_mailbox_imap_fetch_structure(LibBalsaMailbox *mailbox,
if( (flags & LB_FETCH_RFC822_HEADERS) &&
(hdr = im->fetched_header_fields) && *hdr && *hdr != '\r') {
libbalsa_message_set_headers_from_string(message, hdr);
- message->has_all_headers = 1;
+ libbalsa_message_set_has_all_headers(message, TRUE);
}
return TRUE;
}
@@ -2264,16 +2276,16 @@ libbalsa_mailbox_imap_fetch_headers(LibBalsaMailbox *mailbox,
{
LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
ImapResponse rc;
+ glong msgno;
+
+ msgno = libbalsa_message_get_msgno(message);
II(rc,mimap->handle,
- imap_mbox_handle_fetch_range(mimap->handle,
- message->msgno,
- message->msgno,
+ imap_mbox_handle_fetch_range(mimap->handle, msgno, msgno,
IMFETCH_RFC822HEADERS_SELECTED));
if(rc == IMR_OK) { /* translate ImapData to LibBalsaMessage */
const gchar *hdr;
- ImapMessage *im = imap_mbox_handle_get_msg(mimap->handle,
- message->msgno);
+ ImapMessage *im = imap_mbox_handle_get_msg(mimap->handle, msgno);
if ((hdr = im->fetched_header_fields) && *hdr && *hdr != '\r')
libbalsa_message_set_headers_from_string(message, hdr);
}
@@ -2334,27 +2346,26 @@ print_structure(LibBalsaMessageBody *part, LibBalsaMessageBody* m, int ind)
}
#endif
static gchar*
-get_section_for(LibBalsaMessage *msg, LibBalsaMessageBody *part)
+get_section_for(LibBalsaMessage *message, LibBalsaMessageBody *part)
{
GString *section = g_string_new("");
LibBalsaMessageBody *parent;
- parent = msg->body_list;
+ parent = libbalsa_message_get_body_list(message);
if (libbalsa_message_body_is_multipart(parent))
parent = parent->parts;
- if(!is_child_of(parent, part, section, TRUE)) {
- g_warning("Internal error, part %p not found in msg %p.\n",
- part, msg);
+ if (!is_child_of(parent, part, section, TRUE)) {
+ g_warning("Internal error, part %p not found in message %p.\n",
+ part, message);
g_string_free(section, TRUE);
+
return g_strdup("1");
}
-#if 0
- print_structure(msg->body_list, part, 0);
- printf("section: %s\n", section->str);
-#endif
+
return g_string_free(section, FALSE);
}
+
struct part_data { char *block; unsigned pos; ImapBody *body; };
static void
append_str(unsigned seqno, const char *buf, size_t buflen, void *arg)
@@ -2400,19 +2411,20 @@ get_parent(LibBalsaMessageBody *root, LibBalsaMessageBody *part,
return NULL;
}
static gboolean
-lbm_imap_get_msg_part_from_cache(LibBalsaMessage * msg,
+lbm_imap_get_msg_part_from_cache(LibBalsaMessage * message,
LibBalsaMessageBody * part,
GError **err)
{
GMimeStream *partstream = NULL;
-
- gchar **pair, *part_name;
- LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(msg->mailbox);
+ gchar **pair, *part_name;
+ LibBalsaMailbox *mailbox = libbalsa_message_get_mailbox(message);
+ LibBalsaMailboxImap *mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
FILE *fp;
gchar *section;
- ImapMessage *imsg = mi_get_imsg(mimap, msg->msgno);
+ glong msgno = libbalsa_message_get_msgno(message);
+ ImapMessage *imsg = mi_get_imsg(mimap, msgno);
- if (!imsg) {
+ if (imsg == NULL) {
g_set_error(err,
LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_ACCESS_ERROR,
_("Error fetching message from IMAP server: %s"),
@@ -2421,7 +2433,7 @@ lbm_imap_get_msg_part_from_cache(LibBalsaMessage * msg,
}
/* look for a part cache */
- section = get_section_for(msg, part);
+ section = get_section_for(message, part);
pair = get_cache_name_pair(mimap, "part", imsg->uid);
part_name = g_strconcat(pair[0], G_DIR_SEPARATOR_S,
pair[1], "-", section, NULL);
@@ -2433,8 +2445,8 @@ lbm_imap_get_msg_part_from_cache(LibBalsaMessage * msg,
ImapResponse rc;
LibBalsaMessageBody *parent;
- libbalsa_lock_mailbox(msg->mailbox);
- mimap = LIBBALSA_MAILBOX_IMAP(msg->mailbox);
+ libbalsa_lock_mailbox(mailbox);
+ mimap = LIBBALSA_MAILBOX_IMAP(mailbox);
dt.body = imap_message_get_body_from_section(imsg, section);
if(!dt.body) {
@@ -2458,7 +2470,7 @@ lbm_imap_get_msg_part_from_cache(LibBalsaMessage * msg,
* which has no headers. In this case, we have to fake them.
* We could and probably should dump there first the headers
* that we have already fetched... */
- parent = get_parent(msg->body_list, part, NULL);
+ parent = get_parent(libbalsa_message_get_body_list(message), part, NULL);
if(parent == NULL)
ifbo = IMFB_NONE;
else {
@@ -2470,12 +2482,12 @@ lbm_imap_get_msg_part_from_cache(LibBalsaMessage * msg,
rc = IMR_OK;
if (dt.body->octets > 0)
II(rc,mimap->handle,
- imap_mbox_handle_fetch_body(mimap->handle, msg->msgno,
+ imap_mbox_handle_fetch_body(mimap->handle, msgno,
section, FALSE, ifbo, append_str, &dt));
- libbalsa_unlock_mailbox(msg->mailbox);
+ libbalsa_unlock_mailbox(mailbox);
if(rc != IMR_OK) {
fprintf(stderr, "Error fetching imap message no %lu section %s\n",
- msg->msgno, section);
+ msgno, section);
g_set_error(err,
LIBBALSA_MAILBOX_ERROR, LIBBALSA_MAILBOX_ACCESS_ERROR,
_("Error fetching message from IMAP server: %s"),
diff --git a/libbalsa/mailbox_local.c b/libbalsa/mailbox_local.c
index c7040e4dd..cb5fc4bde 100644
--- a/libbalsa/mailbox_local.c
+++ b/libbalsa/mailbox_local.c
@@ -306,9 +306,9 @@ lbm_local_get_message_with_msg_info(LibBalsaMailboxLocal * local,
g_object_add_weak_pointer(G_OBJECT(message),
(gpointer *) & msg_info->message);
- message->flags = msg_info->flags & LIBBALSA_MESSAGE_FLAGS_REAL;
- message->mailbox = LIBBALSA_MAILBOX(local);
- message->msgno = msgno;
+ libbalsa_message_set_flags(message, msg_info->flags & LIBBALSA_MESSAGE_FLAGS_REAL);
+ libbalsa_message_set_mailbox(message, LIBBALSA_MAILBOX(local));
+ libbalsa_message_set_msgno(message, msgno);
libbalsa_message_load_envelope(message);
lbml_message_pool_take_message(local, message);
}
@@ -869,11 +869,13 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
/* do the work */
if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_TO)) {
+ LibBalsaMessageHeaders *headers;
+
g_assert(is_refed);
- if (message->headers->to_list) {
+ headers = libbalsa_message_get_headers(message);
+ if (headers->to_list != NULL) {
gchar *str =
- internet_address_list_to_string(message->headers->
- to_list, FALSE);
+ internet_address_list_to_string(headers->to_list, FALSE);
match =
libbalsa_utf8_strstr(str, cond->match.string.string);
g_free(str);
@@ -896,11 +898,13 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
}
}
if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_CC)) {
+ LibBalsaMessageHeaders *headers;
+
g_assert(is_refed);
- if (message->headers->cc_list) {
+ headers = libbalsa_message_get_headers(message);
+ if (headers->cc_list != NULL) {
gchar *str =
- internet_address_list_to_string(message->headers->
- cc_list, FALSE);
+ internet_address_list_to_string(headers->cc_list, FALSE);
match =
libbalsa_utf8_strstr(str, cond->match.string.string);
g_free(str);
@@ -930,12 +934,13 @@ message_match_real(LibBalsaMailbox *mailbox, guint msgno,
if (CONDITION_CHKMATCH(cond,CONDITION_MATCH_BODY)) {
GString *body;
g_assert(is_refed);
- if (!message->mailbox) {
+ if (libbalsa_message_get_mailbox(message) == NULL) {
/* No need to body-unref */
g_object_unref(message);
return FALSE; /* We don't want to match if an error occurred */
}
- body = content2reply(message->body_list, NULL, 0, FALSE, FALSE);
+ body = content2reply(libbalsa_message_get_body_list(message),
+ NULL, 0, FALSE, FALSE);
if (body) {
if (body->str)
match = libbalsa_utf8_strstr(body->str,
@@ -1005,8 +1010,9 @@ libbalsa_mailbox_local_cache_message(LibBalsaMailboxLocal * local,
libbalsa_mailbox_local_get_instance_private(local);
gpointer *entry;
LibBalsaMailboxLocalInfo *info;
+ LibBalsaMessageHeaders *headers;
- if (!message)
+ if (message == NULL)
return;
libbalsa_mailbox_cache_message(LIBBALSA_MAILBOX(local), msgno,
@@ -1023,15 +1029,15 @@ libbalsa_mailbox_local_cache_message(LibBalsaMailboxLocal * local,
return;
*entry = info = g_new(LibBalsaMailboxLocalInfo, 1);
- info->message_id = g_strdup(message->message_id);
+ info->message_id = g_strdup(libbalsa_message_get_message_id(message));
info->refs_for_threading =
libbalsa_message_refs_for_threading(message);
info->sender = NULL;
- if (message->headers->from)
- info->sender =
- internet_address_list_to_string(message->headers->from, FALSE);
- if (!info->sender)
+ headers = libbalsa_message_get_headers(message);
+ if (headers->from != NULL)
+ info->sender = internet_address_list_to_string(headers->from, FALSE);
+ if (info->sender == NULL)
info->sender = g_strdup("");
}
@@ -1384,22 +1390,26 @@ libbalsa_mailbox_local_fetch_structure(LibBalsaMailbox *mailbox,
LibBalsaMessage *message,
LibBalsaFetchFlag flags)
{
- GMimeMessage *mime_message = message->mime_msg;
+ GMimeMessage *mime_message;
+ LibBalsaMessageHeaders *headers;
- if (!mime_message || !mime_message->mime_part)
+ mime_message = libbalsa_message_get_mime_message(message);
+ if (mime_message == NULL || mime_message->mime_part == NULL)
return FALSE;
- if(flags & LB_FETCH_STRUCTURE) {
+ headers = libbalsa_message_get_headers(message);
+
+ if ((flags & LB_FETCH_STRUCTURE) != 0) {
LibBalsaMessageBody *body = libbalsa_message_body_new(message);
libbalsa_message_body_set_mime_body(body,
mime_message->mime_part);
libbalsa_message_append_part(message, body);
- libbalsa_message_headers_from_gmime(message->headers, mime_message);
+ libbalsa_message_headers_from_gmime(headers, mime_message);
}
- if(flags & LB_FETCH_RFC822_HEADERS) {
- message->headers->user_hdrs =
- libbalsa_message_user_hdrs_from_gmime(mime_message);
- message->has_all_headers = 1;
+
+ if ((flags & LB_FETCH_RFC822_HEADERS) != 0) {
+ headers->user_hdrs = libbalsa_message_user_hdrs_from_gmime(mime_message);
+ libbalsa_message_set_has_all_headers(message, TRUE);
}
return TRUE;
@@ -1409,12 +1419,16 @@ static void
libbalsa_mailbox_local_fetch_headers(LibBalsaMailbox * mailbox,
LibBalsaMessage * message)
{
- g_return_if_fail(message->headers->user_hdrs == NULL);
+ LibBalsaMessageHeaders *headers;
+ GMimeMessage *mime_msg;
- if (message->mime_msg)
- message->headers->user_hdrs =
- libbalsa_message_user_hdrs_from_gmime(message->mime_msg);
- else {
+ headers = libbalsa_message_get_headers(message);
+ g_return_if_fail(headers->user_hdrs == NULL);
+
+ mime_msg = libbalsa_message_get_mime_message(message);
+ if (mime_msg != NULL) {
+ headers->user_hdrs = libbalsa_message_user_hdrs_from_gmime(mime_msg);
+ } else {
libbalsa_mailbox_fetch_message_structure(mailbox, message,
LB_FETCH_RFC822_HEADERS);
libbalsa_mailbox_release_message(mailbox, message);
@@ -2226,8 +2240,8 @@ libbalsa_mailbox_local_messages_change_flags(LibBalsaMailbox * mailbox,
continue;
++changed;
- if (msg_info->message)
- msg_info->message->flags = msg_info->flags;
+ if (msg_info->message != NULL)
+ libbalsa_message_set_flags(msg_info->message, msg_info->flags);
libbalsa_mailbox_index_set_flags(mailbox, msgno, msg_info->flags);
diff --git a/libbalsa/mailbox_maildir.c b/libbalsa/mailbox_maildir.c
index 817151c95..0e56d0b14 100644
--- a/libbalsa/mailbox_maildir.c
+++ b/libbalsa/mailbox_maildir.c
@@ -578,8 +578,8 @@ libbalsa_mailbox_maildir_check(LibBalsaMailbox * mailbox)
}
for (msgno = renumber; msgno <= mdir->msgno_2_msg_info->len; msgno++) {
msg_info = message_info_from_msgno(mdir, msgno);
- if (msg_info->local_info.message)
- msg_info->local_info.message->msgno = msgno;
+ if (msg_info->local_info.message != NULL)
+ libbalsa_message_set_msgno(msg_info->local_info.message, msgno);
}
msgno = mdir->msgno_2_msg_info->len;
@@ -594,9 +594,9 @@ free_message_info(struct message_info *msg_info)
return;
g_free(msg_info->key);
g_free(msg_info->filename);
- if (msg_info->local_info.message) {
- msg_info->local_info.message->mailbox = NULL;
- msg_info->local_info.message->msgno = 0;
+ if (msg_info->local_info.message != NULL) {
+ libbalsa_message_set_mailbox(msg_info->local_info.message, NULL);
+ libbalsa_message_set_msgno(msg_info->local_info.message, 0);
g_object_remove_weak_pointer(G_OBJECT(msg_info->local_info.message),
(gpointer *) & msg_info->local_info.message);
}
@@ -790,8 +790,8 @@ libbalsa_mailbox_maildir_sync(LibBalsaMailbox * mailbox, gboolean expunge)
g_slist_free(removed_list);
for (msgno = renumber; msgno <= mdir->msgno_2_msg_info->len; msgno++) {
msg_info = message_info_from_msgno(mdir, msgno);
- if (msg_info->local_info.message)
- msg_info->local_info.message->msgno = msgno;
+ if (msg_info->local_info.message != NULL)
+ libbalsa_message_set_msgno(msg_info->local_info.message, msgno);
}
if (changes) { /* Record mtime of dir. */
@@ -824,14 +824,20 @@ libbalsa_mailbox_maildir_fetch_message_structure(LibBalsaMailbox * mailbox,
LibBalsaMessage * message,
LibBalsaFetchFlag flags)
{
- if (!message->mime_msg) {
+ GMimeMessage *mime_message;
+
+ mime_message = libbalsa_message_get_mime_message(message);
+
+ if (mime_message == NULL) {
struct message_info *msg_info =
message_info_from_msgno((LibBalsaMailboxMaildir *) mailbox,
- message->msgno);
- message->mime_msg =
+ libbalsa_message_get_msgno(message));
+ mime_message =
libbalsa_mailbox_local_get_mime_message(mailbox,
msg_info->subdir,
msg_info->filename);
+ libbalsa_message_set_mime_message(message, mime_message);
+ g_object_unref(mime_message);
}
return LIBBALSA_MAILBOX_CLASS(libbalsa_mailbox_maildir_parent_class)->
diff --git a/libbalsa/mailbox_mbox.c b/libbalsa/mailbox_mbox.c
index df68cd650..9f20b4a54 100644
--- a/libbalsa/mailbox_mbox.c
+++ b/libbalsa/mailbox_mbox.c
@@ -1,7 +1,7 @@
/* -*-mode:c; c-style:k&r; c-basic-offset:4; -*- */
/* Balsa E-Mail Client
*
- * Copyright (C) 1997-2016 Stuart Parmenter and others,
+ * Copyright (C) 1997-2019 Stuart Parmenter and others,
* See the file AUTHORS for a list.
*
* This program is free software; you can redistribute it and/or modify
@@ -508,10 +508,10 @@ parse_mailbox(LibBalsaMailboxMbox * mbox)
g_memdup(&msg_info, sizeof(msg_info)));
mbox->messages_info_changed = TRUE;
- msg->flags = msg_info.orig_flags;
- msg->length = msg_info.end - (msg_info.start + msg_info.from_len);
- msg->mailbox = LIBBALSA_MAILBOX(mbox);
- msg->msgno = ++msgno;
+ libbalsa_message_set_flags(msg, msg_info.orig_flags);
+ libbalsa_message_set_length(msg, msg_info.end - (msg_info.start + msg_info.from_len));
+ libbalsa_message_set_mailbox(msg, LIBBALSA_MAILBOX(mbox));
+ libbalsa_message_set_msgno(msg, ++msgno);
/* We must drop the mime-stream lock to call
* libbalsa_mailbox_local_cache_message, which calls
* libbalsa_mailbox_cache_message(), as it may grab the
@@ -635,12 +635,13 @@ free_message_info(struct message_info *msg_info)
LibBalsaMessage *message;
if ((message = msg_info->local_info.message) != NULL) {
- message->mailbox = NULL;
- message->msgno = 0;
+ libbalsa_message_set_mailbox(message, NULL);
+ libbalsa_message_set_msgno(message, 0);
g_object_remove_weak_pointer(G_OBJECT(message),
(gpointer *) &msg_info->local_info.message);
msg_info->local_info.message = NULL;
}
+
g_free(msg_info);
}
@@ -1666,8 +1667,8 @@ libbalsa_mailbox_mbox_sync(LibBalsaMailbox * mailbox, gboolean expunge)
mbox->messages_info_changed = TRUE;
continue;
}
- if (msg_info->local_info.message)
- msg_info->local_info.message->msgno = j + 1;
+ if (msg_info->local_info.message != NULL)
+ libbalsa_message_set_msgno(msg_info->local_info.message, j + 1);
msg_info->status = msg_info->x_status = msg_info->mime_version = -1;
mime_msg = g_mime_parser_construct_message(gmime_parser);
@@ -1696,18 +1697,19 @@ libbalsa_mailbox_mbox_sync(LibBalsaMailbox * mailbox, gboolean expunge)
msg_info->end = g_mime_parser_tell(gmime_parser);
msg_info->orig_flags = REAL_FLAGS(msg_info->local_info.flags);
g_assert(mime_msg->mime_part != NULL);
- if (!msg_info->local_info.message || !msg_info->local_info.message->mime_msg)
- g_object_unref(mime_msg);
- else {
- g_object_unref(msg_info->local_info.message->mime_msg);
- msg_info->local_info.message->mime_msg = mime_msg;
+
+ if (msg_info->local_info.message != NULL &&
+ libbalsa_message_get_mime_message(msg_info->local_info.message) != NULL) {
+ libbalsa_message_set_mime_message(msg_info->local_info.message, mime_msg);
/*
* reinit the message parts info
*/
- libbalsa_message_body_set_mime_body(msg_info->local_info.message->body_list,
+ libbalsa_message_body_set_mime_body(libbalsa_message_get_body_list(msg_info->local_info.message),
mime_msg->mime_part);
}
+ g_object_unref(mime_msg);
+
j++;
}
libbalsa_mime_stream_shared_unlock(mbox_stream);
@@ -1732,8 +1734,12 @@ libbalsa_mailbox_mbox_fetch_message_structure(LibBalsaMailbox * mailbox,
LibBalsaMessage * message,
LibBalsaFetchFlag flags)
{
- if (!message->mime_msg)
- message->mime_msg = lbm_mbox_get_mime_message(mailbox, message->msgno);
+ if (libbalsa_message_get_mime_message(message) == NULL) {
+ GMimeMessage *mime_msg =
+ lbm_mbox_get_mime_message(mailbox, libbalsa_message_get_msgno(message));
+ libbalsa_message_set_mime_message(message, mime_msg);
+ g_object_unref(mime_msg);
+ }
return LIBBALSA_MAILBOX_CLASS(libbalsa_mailbox_mbox_parent_class)->
fetch_message_structure(mailbox, message, flags);
@@ -1854,6 +1860,7 @@ lbm_mbox_add_message(LibBalsaMailboxLocal * local,
{
LibBalsaMailbox *mailbox = (LibBalsaMailbox *) local;
LibBalsaMessage *message;
+ LibBalsaMessageHeaders *headers;
gchar date_string[27];
gchar *sender;
gchar *address;
@@ -1870,10 +1877,11 @@ lbm_mbox_add_message(LibBalsaMailboxLocal * local,
message = libbalsa_message_new();
libbalsa_message_load_envelope_from_stream(message, stream);
- ctime_r(&(message->headers->date), date_string);
+ headers = libbalsa_message_get_headers(message);
+ ctime_r(&(headers->date), date_string);
- sender = message->headers->from ?
- internet_address_list_to_string(message->headers->from, FALSE) :
+ sender = headers->from != NULL ?
+ internet_address_list_to_string(headers->from, FALSE) :
g_strdup("none");
g_object_unref(message);
diff --git a/libbalsa/mailbox_mh.c b/libbalsa/mailbox_mh.c
index f22129e62..4ccd821ad 100644
--- a/libbalsa/mailbox_mh.c
+++ b/libbalsa/mailbox_mh.c
@@ -481,14 +481,16 @@ lbm_mh_parse_both(LibBalsaMailboxMh * mh)
static void
lbm_mh_free_message_info(struct message_info *msg_info)
{
- if (!msg_info)
+ if (msg_info == NULL)
return;
- if (msg_info->local_info.message) {
- msg_info->local_info.message->mailbox = NULL;
- msg_info->local_info.message->msgno = 0;
+
+ if (msg_info->local_info.message != NULL) {
+ libbalsa_message_set_mailbox(msg_info->local_info.message, NULL);
+ libbalsa_message_set_msgno(msg_info->local_info.message, 0);
g_object_remove_weak_pointer(G_OBJECT(msg_info->local_info.message),
(gpointer *) &msg_info->local_info.message);
}
+
g_free(msg_info);
}
@@ -674,8 +676,8 @@ libbalsa_mailbox_mh_check(LibBalsaMailbox * mailbox)
}
for (msgno = renumber; msgno <= mh->msgno_2_msg_info->len; msgno++) {
msg_info = lbm_mh_message_info_from_msgno(mh, msgno);
- if (msg_info->local_info.message)
- msg_info->local_info.message->msgno = msgno;
+ if (msg_info->local_info.message != NULL)
+ libbalsa_message_set_msgno(msg_info->local_info.message, msgno);
}
msgno = mh->msgno_2_msg_info->len;
@@ -871,8 +873,8 @@ libbalsa_mailbox_mh_sync(LibBalsaMailbox * mailbox, gboolean expunge)
/* Renumber */
for (msgno = 1; msgno <= mh->msgno_2_msg_info->len; msgno++) {
msg_info = lbm_mh_message_info_from_msgno(mh, msgno);
- if (msg_info->local_info.message)
- msg_info->local_info.message->msgno = msgno;
+ if (msg_info->local_info.message != NULL)
+ libbalsa_message_set_msgno(msg_info->local_info.message, msgno);
}
/* open tempfile */
@@ -987,24 +989,30 @@ libbalsa_mailbox_mh_fetch_message_structure(LibBalsaMailbox * mailbox,
LibBalsaMessage * message,
LibBalsaFetchFlag flags)
{
- if (!message->mime_msg) {
+ GMimeMessage *mime_msg;
+
+ mime_msg = libbalsa_message_get_mime_message(message);
+
+ if (mime_msg == NULL) {
struct message_info *msg_info;
gchar *base_name;
msg_info =
lbm_mh_message_info_from_msgno(LIBBALSA_MAILBOX_MH(mailbox),
- message->msgno);
+ libbalsa_message_get_msgno(message));
base_name = MH_BASENAME(msg_info);
- message->mime_msg =
- libbalsa_mailbox_local_get_mime_message(mailbox, base_name, NULL);
+ mime_msg = libbalsa_mailbox_local_get_mime_message(mailbox, base_name, NULL);
g_free(base_name);
- if (message->mime_msg) {
- g_mime_object_remove_header(GMIME_OBJECT(message->mime_msg),
+ libbalsa_message_set_mime_message(message, mime_msg);
+
+ if (mime_msg != NULL) {
+ g_mime_object_remove_header(GMIME_OBJECT(mime_msg),
"Status");
- g_mime_object_remove_header(GMIME_OBJECT(message->mime_msg),
+ g_mime_object_remove_header(GMIME_OBJECT(mime_msg),
"X-Status");
+ g_object_unref(mime_msg);
}
}
diff --git a/libbalsa/message.c b/libbalsa/message.c
index fc061cbfe..8a2101fd4 100644
--- a/libbalsa/message.c
+++ b/libbalsa/message.c
@@ -5,14 +5,14 @@
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
+ * the Free Software Foundation; either version 2, or (at your option)
* any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
@@ -26,10 +26,10 @@
- Lack of inline functions in C increases program complexity. This cost
can be accepted.
- thorough analysis of memory usage is needed.
-*/
-
+ */
+
#if defined(HAVE_CONFIG_H) && HAVE_CONFIG_H
-# include "config.h"
+# include "config.h"
#endif /* HAVE_CONFIG_H */
#include <ctype.h>
@@ -40,6 +40,7 @@
#include "libbalsa.h"
#include "libbalsa_private.h"
+#include "identity.h"
/* needed for truncate_string */
#include "misc.h"
@@ -49,39 +50,92 @@
#include <gmime/gmime.h>
-static void libbalsa_message_class_init(LibBalsaMessageClass * klass);
-static void libbalsa_message_init(LibBalsaMessage * message);
-
+static void libbalsa_message_dispose(GObject * object);
static void libbalsa_message_finalize(GObject * object);
+struct _LibBalsaMessageClass {
+ GObjectClass parent_class;
-static GObjectClass *parent_class = NULL;
+ /* deal with flags being set/unset */
+ /* Signal: */
+ void (*status_changed) (LibBalsaMessage *message,
+ LibBalsaMessageFlag flag,
+ gboolean);
+};
-GType
-libbalsa_message_get_type()
-{
- static GType libbalsa_message_type = 0;
+struct _LibBalsaMessage {
+ GObject object;
- if (!libbalsa_message_type) {
- static const GTypeInfo libbalsa_message_info = {
- sizeof(LibBalsaMessageClass),
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc) libbalsa_message_class_init,
- NULL, /* class_finalize */
- NULL, /* class_data */
- sizeof(LibBalsaMessage),
- 0, /* n_preallocs */
- (GInstanceInitFunc) libbalsa_message_init
- };
+ /* the mailbox this message belongs to */
+ LibBalsaMailbox *mailbox;
- libbalsa_message_type =
- g_type_register_static(G_TYPE_OBJECT, "LibBalsaMessage",
- &libbalsa_message_info, 0);
- }
+ /* flags */
+ LibBalsaMessageFlag flags;
- return libbalsa_message_type;
-}
+ /* headers */
+ LibBalsaMessageHeaders *headers;
+ int updated; /** whether complete headers have been fetched */
+
+ GMimeMessage *mime_msg;
+
+ /* sender address */
+ InternetAddressList *sender;
+
+ /* subject line; we still need it here for sending;
+ * although _SET_SUBJECT might resolve it(?)
+ * but we can set to to NULL unless there is no mailbox, like
+ * on sending. */
+ gchar *subj;
+
+ /* replied message ID's */
+ GList *references;
+
+ /* replied message ID; from address on date */
+ GList *in_reply_to;
+
+ /* message ID */
+ gchar *message_id;
+
+ /* GPG sign and/or encrypt message (sending) */
+ guint gpg_mode;
+
+ /* attach the GnuPG public key to the message (sending) */
+ gboolean att_pubkey;
+
+ /* protection (i.e. sign/encrypt) status (received message) */
+ LibBalsaMsgProtectState prot_state;
+
+ /* sender identity, required for choosing a forced GnuPG or S/MIME key */
+ LibBalsaIdentity *ident;
+
+ /* request a DSN (sending) */
+ gboolean request_dsn;
+
+ /* a forced multipart subtype or NULL for mixed; used only for
+ * sending */
+ gchar *subtype;
+
+ /* additional message content type parameters; used only for sending */
+ GList *parameters;
+
+ /* message body */
+ guint body_ref;
+ LibBalsaMessageBody *body_list;
+
+ glong msgno; /* message no; always copy for faster sorting;
+ * counting starts at 1. */
+#if MESSAGE_COPY_CONTENT
+ glong length; /* byte len */
+#endif /* MESSAGE_COPY_CONTENT */
+
+ gchar *tempdir; /* to hold named parts */
+
+ unsigned has_all_headers : 1;
+};
+
+G_DEFINE_TYPE(LibBalsaMessage,
+ libbalsa_message,
+ G_TYPE_OBJECT)
static void
libbalsa_message_init(LibBalsaMessage * message)
@@ -109,8 +163,7 @@ libbalsa_message_class_init(LibBalsaMessageClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
- parent_class = g_type_class_peek_parent(klass);
-
+ object_class->dispose = libbalsa_message_dispose;
object_class->finalize = libbalsa_message_finalize;
}
@@ -124,74 +177,56 @@ libbalsa_message_new(void)
return message;
}
-/* libbalsa_message_finalize:
- finalize methods must leave object in 'sane' state.
+/* libbalsa_message_dispose:
+ dispose methods must leave object in 'sane' state.
This means NULLifing released pointers.
*/
static void
-libbalsa_message_finalize(GObject * object)
+libbalsa_message_dispose(GObject * object)
{
- LibBalsaMessage *message;
+ LibBalsaMessage *message = LIBBALSA_MESSAGE(object);
- g_return_if_fail(object != NULL);
- g_return_if_fail(LIBBALSA_IS_MESSAGE(object));
+ g_clear_object(&message->sender);
+ g_clear_object(&message->mime_msg);
+ g_clear_object(&message->ident);
- message = LIBBALSA_MESSAGE(object);
+ G_OBJECT_CLASS(libbalsa_message_parent_class)->dispose(object);
+}
- libbalsa_message_headers_destroy(message->headers);
- message->headers = NULL;
+/* libbalsa_message_finalize: */
+static void
+libbalsa_message_finalize(GObject * object)
+{
+ LibBalsaMessage *message = LIBBALSA_MESSAGE(object);
- if (message->sender) {
- g_object_unref(message->sender);
- message->sender = NULL;
- }
+ libbalsa_message_headers_destroy(message->headers);
-#if MESSAGE_COPY_CONTENT
- g_free(message->subj);
- message->subj = NULL;
-#endif
g_list_free_full(message->references, g_free);
- message->references = NULL;
-
g_list_free_full(message->in_reply_to, g_free);
- message->in_reply_to = NULL;
+ g_list_free_full(message->parameters, (GDestroyNotify) g_strfreev);
g_free(message->message_id);
- message->message_id = NULL;
-
g_free(message->subtype);
- message->subtype = NULL;
-
- g_list_free_full(message->parameters, (GDestroyNotify) g_strfreev);
- message->parameters = NULL;
-
+#if MESSAGE_COPY_CONTENT
+ g_free(message->subj);
+#endif /* MESSAGE_COPY_CONTENT */
libbalsa_message_body_free(message->body_list);
- message->body_list = NULL;
-
- if (message->mime_msg) {
- g_object_unref(message->mime_msg);
- message->mime_msg = NULL;
- }
-
- if (message->ident != NULL) {
- g_object_unref(message->ident);
- }
if (message->tempdir) {
- if (rmdir(message->tempdir))
+ if (rmdir(message->tempdir) != 0)
g_warning("Could not remove %s", message->tempdir);
g_free(message->tempdir);
- message->tempdir = NULL;
}
- G_OBJECT_CLASS(parent_class)->finalize(object);
+ G_OBJECT_CLASS(libbalsa_message_parent_class)->finalize(object);
}
+
static void
-lb_message_headers_extra_destroy(LibBalsaMessageHeaders * headers)
+lb_message_headers_extra_destroy(LibBalsaMessageHeaders *headers)
{
- if (!headers)
+ if (headers == NULL)
return;
FREE_HEADER_LIST(headers->user_hdrs);
@@ -201,11 +236,13 @@ lb_message_headers_extra_destroy(LibBalsaMessageHeaders * headers)
headers->fcc_url = NULL;
}
-void
-libbalsa_message_headers_destroy(LibBalsaMessageHeaders * headers)
+
+void
+libbalsa_message_headers_destroy(LibBalsaMessageHeaders *headers)
{
- if (!headers)
- return;
+ if (headers == NULL)
+ return;
+
g_free(headers->subject);
headers->subject = NULL;
@@ -250,17 +287,22 @@ libbalsa_message_headers_destroy(LibBalsaMessageHeaders * headers)
g_free(headers);
}
+
const gchar *
-libbalsa_message_body_charset(LibBalsaMessageBody * body)
+libbalsa_message_body_charset(LibBalsaMessageBody *body)
{
const gchar *charset;
- if (!body)
- return NULL;
+ if (body == NULL)
+ return NULL;
+
- if (body->charset) /* This overrides all! Important for non
- * us-ascii messages over IMAP. */
+ 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;
@@ -273,9 +315,11 @@ libbalsa_message_body_charset(LibBalsaMessageBody * body)
if (charset)
return charset;
+
return libbalsa_message_body_charset(body->next);
}
+
/* UTF-8-aware header cleaning by Albrecht */
static void
canonize_header_value(gchar *value)
@@ -318,89 +362,101 @@ libbalsa_create_hdr_pair(const gchar * name, gchar * value)
return item;
}
-static GList*
-libbalsa_message_header_get_helper(LibBalsaMessageHeaders* headers,
- const gchar *find)
+
+static GList *
+libbalsa_message_header_get_helper(LibBalsaMessageHeaders *headers,
+ const gchar *find)
{
GList *list;
for (list = headers->user_hdrs; list; list = list->next) {
- const gchar * const *tmp = list->data;
-
- if (g_ascii_strcasecmp(tmp[0], find) == 0)
+ const gchar *const *tmp = list->data;
+
+ if (g_ascii_strcasecmp(tmp[0], find) == 0)
return list;
}
return NULL;
}
+
/** libbalsa_message_find_user_hdr:
returns.... list element matching given header.
-*/
+ */
static GList *
-libbalsa_message_find_user_hdr(LibBalsaMessage * message, const gchar * find)
+libbalsa_message_find_user_hdr(LibBalsaMessage *message,
+ const gchar *find)
{
LibBalsaMessageHeaders *headers = message->headers;
-
+
g_return_val_if_fail(headers, NULL);
- if (!headers->user_hdrs && message->mailbox)
+ if (headers->user_hdrs == NULL && message->mailbox)
libbalsa_mailbox_set_msg_headers(message->mailbox, message);
return libbalsa_message_header_get_helper(headers, find);
}
-/*
+
+/*
* Public user header methods
*/
-const gchar*
-libbalsa_message_header_get_one(LibBalsaMessageHeaders* headers,
- const gchar *find)
+const gchar *
+libbalsa_message_header_get_one(LibBalsaMessageHeaders *headers,
+ const gchar *find)
{
GList *header;
const gchar *const *pair;
-
- if (!(header = libbalsa_message_header_get_helper(headers, find)))
+
+ if ((header = libbalsa_message_header_get_helper(headers, find)) == NULL)
return NULL;
+
pair = header->data;
return pair[1];
}
-GList*
-libbalsa_message_header_get_all(LibBalsaMessageHeaders* headers,
- const gchar *find)
+
+GList *
+libbalsa_message_header_get_all(LibBalsaMessageHeaders *headers,
+ const gchar *find)
{
GList *header;
const gchar *const *pair;
GList *res = NULL;
-
- if (!(header = libbalsa_message_header_get_helper(headers, find)))
+
+ if ((header = libbalsa_message_header_get_helper(headers, find)) == NULL)
return NULL;
+
pair = header->data;
- for(pair++; *pair; pair++)
+ for (pair++; *pair; pair++) {
res = g_list_append(res, g_strdup(*pair));
-
+ }
+
return res;
}
+
const gchar *
-libbalsa_message_get_user_header(LibBalsaMessage * message,
- const gchar * name)
+libbalsa_message_get_user_header(LibBalsaMessage *message,
+ const gchar *name)
{
GList *header;
const gchar *const *pair;
-
+
g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
g_return_val_if_fail(name != NULL, NULL);
- if (!(header = libbalsa_message_find_user_hdr(message, name)))
+ if ((header = libbalsa_message_find_user_hdr(message, name)) == NULL)
return NULL;
+
pair = header->data;
return pair[1];
}
+
void
-libbalsa_message_set_user_header(LibBalsaMessage * message,
- const gchar * name, const gchar * value)
+libbalsa_message_set_user_header(LibBalsaMessage *message,
+ const gchar *name,
+ const gchar *value)
{
LibBalsaMessageHeaders *headers;
GList *header;
@@ -417,13 +473,15 @@ libbalsa_message_set_user_header(LibBalsaMessage * message,
FREE_HEADER_LIST(header);
}
- if (value && *value)
+ if (value && *value) {
headers->user_hdrs =
g_list_prepend(headers->user_hdrs,
libbalsa_create_hdr_pair(name,
g_strdup(value)));
+ }
}
+
static GList *
prepend_header_misc(GList *res,
const char *name,
@@ -436,17 +494,18 @@ prepend_header_misc(GList *res,
"disposition-notification-to";
unsigned i;
- if (value[0] == '\0')
+ if (value[0] == '\0') {
/* Empty header */
return res;
+ }
/* Standard Headers*/
- for(i = 0; i < sizeof(lcname) - 1 && name[i] != '\0'; i++) {
+ for (i = 0; i < sizeof(lcname) - 1 && name[i] != '\0'; i++) {
lcname[i] = tolower(name[i]);
}
lcname[i] = '\0';
- if(strstr(ignored_headers, lcname) != NULL)
+ if (strstr(ignored_headers, lcname) != NULL)
return res;
return
@@ -478,30 +537,31 @@ libbalsa_message_user_hdrs_from_gmime(GMimeMessage * message)
g_return_val_if_fail(message != NULL, NULL);
value = g_mime_message_get_message_id(message);
- if (value)
- res = g_list_prepend(res, libbalsa_create_hdr_pair("Message-ID",
- g_strdup_printf("<%s>", value)));
+ if (value) {
+ res = g_list_prepend(res, libbalsa_create_hdr_pair("Message-ID",
+ g_strdup_printf("<%s>", value)));
+ }
/* FIXME: This duplicates References headers since they are
already present in LibBalsaMessage::references field. FWIW,
mailbox driver does not copy references to user_headers.
- */
+ */
value = g_mime_object_get_header(GMIME_OBJECT(message), "References");
if (value) {
#if BALSA_NEEDS_SEPARATE_USER_HEADERS
- GMimeReferences *references, *reference;
- reference = references = g_mime_references_decode(value);
- while (reference) {
- res =
- g_list_prepend(res,
- libbalsa_create_hdr_pair("References",
- g_strdup_printf
- ("<%s>",
- reference->
- msgid)));
- reference = reference->next;
- }
- g_mime_references_clear(&references);
+ GMimeReferences *references, *reference;
+ reference = references = g_mime_references_decode(value);
+ while (reference) {
+ res =
+ g_list_prepend(res,
+ libbalsa_create_hdr_pair("References",
+ g_strdup_printf
+ ("<%s>",
+ reference->
+ msgid)));
+ reference = reference->next;
+ }
+ g_mime_references_clear(&references);
#else
res = g_list_prepend(res,
libbalsa_create_hdr_pair("References",
@@ -514,37 +574,41 @@ libbalsa_message_user_hdrs_from_gmime(GMimeMessage * message)
res =
g_list_prepend(res,
libbalsa_create_hdr_pair
- ("In-Reply-To",
- g_mime_utils_header_decode_text(value)));
+ ("In-Reply-To",
+ g_mime_utils_header_decode_text(value)));
}
hdrlist = g_mime_object_get_header_list (GMIME_OBJECT(message));
if (g_mime_header_list_get_iter (hdrlist, &iter)) {
- do {
+ do {
res = prepend_header_misc(res,
g_mime_header_iter_get_name (&iter),
g_mime_header_iter_get_value (&iter));
- } while (g_mime_header_iter_next (&iter));
+ } while (g_mime_header_iter_next (&iter));
}
-
+
return g_list_reverse(res);
}
+
/* libbalsa_message_get_part_by_id:
return a message part identified by Content-ID=id
message must be referenced. (FIXME?)
-*/
+ */
LibBalsaMessageBody *
-libbalsa_message_get_part_by_id(LibBalsaMessage* msg, const gchar* id)
+libbalsa_message_get_part_by_id(LibBalsaMessage *msg,
+ const gchar *id)
{
return libbalsa_message_body_get_by_id(msg->body_list, id);
}
+
/* libbalsa_message_save:
return TRUE on success and FALSE on failure.
-*/
+ */
gboolean
-libbalsa_message_save(LibBalsaMessage * message, const gchar *filename)
+libbalsa_message_save(LibBalsaMessage *message,
+ const gchar *filename)
{
FILE *outfile;
int res;
@@ -553,12 +617,15 @@ libbalsa_message_save(LibBalsaMessage * message, const gchar *filename)
g_return_val_if_fail(message->mailbox, FALSE);
- if( (outfile = fopen(filename, "w")) == NULL) return FALSE;
+ if ((outfile = fopen(filename, "w")) == NULL)
+ return FALSE;
+
g_return_val_if_fail(outfile, FALSE);
msg_stream = libbalsa_message_stream(message);
if (msg_stream == NULL)
- return FALSE;
+ return FALSE;
+
out_stream = g_mime_stream_file_new(outfile);
libbalsa_mailbox_lock_store(message->mailbox);
res = g_mime_stream_write_to_stream(msg_stream, out_stream);
@@ -573,27 +640,36 @@ libbalsa_message_save(LibBalsaMessage * message, const gchar *filename)
LibBalsaMessageAttach
libbalsa_message_get_attach_icon(LibBalsaMessage * message)
{
- if (libbalsa_message_is_pgp_encrypted(message))
- return LIBBALSA_MESSAGE_ATTACH_ENCR;
- else if (message->prot_state != LIBBALSA_MSG_PROTECT_NONE ||
+ LibBalsaMessageAttach attach_icon;
+
+ if (libbalsa_message_is_pgp_encrypted(message)) {
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_ENCR;
+ } else if (message->prot_state != LIBBALSA_MSG_PROTECT_NONE ||
libbalsa_message_is_pgp_signed(message)) {
switch (message->prot_state) {
case LIBBALSA_MSG_PROTECT_SIGN_GOOD:
- return LIBBALSA_MESSAGE_ATTACH_GOOD;
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_GOOD;
+ break;
case LIBBALSA_MSG_PROTECT_SIGN_NOTRUST:
- return LIBBALSA_MESSAGE_ATTACH_NOTRUST;
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_NOTRUST;
+ break;
case LIBBALSA_MSG_PROTECT_SIGN_BAD:
- return LIBBALSA_MESSAGE_ATTACH_BAD;
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_BAD;
+ break;
case LIBBALSA_MSG_PROTECT_CRYPT:
- return LIBBALSA_MESSAGE_ATTACH_ENCR;
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_ENCR;
+ break;
default:
- return LIBBALSA_MESSAGE_ATTACH_SIGN;
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_SIGN;
+ break;
}
- } else
- if (libbalsa_message_has_attachment(message))
- return LIBBALSA_MESSAGE_ATTACH_ATTACH;
- else
- return LIBBALSA_MESSAGE_ATTACH_ICONS_NUM;
+ } else if (libbalsa_message_has_attachment(message)) {
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_ATTACH;
+ } else {
+ attach_icon = LIBBALSA_MESSAGE_ATTACH_ICONS_NUM;
+ }
+
+ return attach_icon;
}
/* Tell the mailbox driver to change flags. */
@@ -618,8 +694,9 @@ libbalsa_message_change_flags(LibBalsaMessage * message,
set, clear);
}
+
void
-libbalsa_message_reply(LibBalsaMessage * message)
+libbalsa_message_reply(LibBalsaMessage *message)
{
g_return_if_fail(message->mailbox);
libbalsa_lock_mailbox(message->mailbox);
@@ -630,93 +707,107 @@ libbalsa_message_reply(LibBalsaMessage * message)
/* libbalsa_message_body_ref:
references the structure of given message possibly fetching also all
- headers.
+ headers.
message parts can be fetched later on.
-*/
+ */
gboolean
-libbalsa_message_body_ref(LibBalsaMessage * message, gboolean read,
- gboolean fetch_all_headers)
+libbalsa_message_body_ref(LibBalsaMessage *message,
+ gboolean read,
+ gboolean fetch_all_headers)
{
LibBalsaFetchFlag flags = 0;
- gboolean retval = TRUE;
+ gboolean retval = TRUE;
g_return_val_if_fail(message, FALSE);
- if (!message->mailbox) return FALSE;
+ if (message->mailbox == NULL)
+ return FALSE;
+
g_return_val_if_fail(MAILBOX_OPEN(message->mailbox), FALSE);
libbalsa_lock_mailbox(message->mailbox);
- if(fetch_all_headers && !message->has_all_headers)
- flags |= LB_FETCH_RFC822_HEADERS;
+ if (fetch_all_headers && !message->has_all_headers)
+ flags |= LB_FETCH_RFC822_HEADERS;
- if (message->body_ref == 0 && !message->body_list)
+ if ((message->body_ref == 0) && !message->body_list) {
/* not fetched yet */
flags |= LB_FETCH_STRUCTURE;
+ }
- if (flags)
+ if (flags) {
retval =
libbalsa_mailbox_fetch_message_structure(message->mailbox,
message, flags);
+ }
+
if (retval)
- message->body_ref++;
+ message->body_ref++;
libbalsa_unlock_mailbox(message->mailbox);
-
+
return retval;
}
void
-libbalsa_message_body_unref(LibBalsaMessage * message)
+libbalsa_message_body_unref(LibBalsaMessage *message)
{
g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
if (message->body_ref == 0)
- return;
+ return;
- if(message->mailbox) { libbalsa_lock_mailbox(message->mailbox); }
- if (--message->body_ref == 0) {
- libbalsa_message_body_free(message->body_list);
- message->body_list = NULL;
- if (message->mailbox)
- libbalsa_mailbox_release_message(message->mailbox, message);
- /* Free headers that we no longer need. */
- lb_message_headers_extra_destroy(message->headers);
- message->has_all_headers = 0;
- }
- if(message->mailbox) { libbalsa_unlock_mailbox(message->mailbox); }
+ if (message->mailbox)
+ libbalsa_lock_mailbox(message->mailbox);
+ if (--message->body_ref == 0) {
+ libbalsa_message_body_free(message->body_list);
+ message->body_list = NULL;
+ if (message->mailbox)
+ libbalsa_mailbox_release_message(message->mailbox, message);
+
+ /* Free headers that we no longer need. */
+ lb_message_headers_extra_destroy(message->headers);
+ message->has_all_headers = 0;
+ }
+ if (message->mailbox)
+ libbalsa_unlock_mailbox(message->mailbox);
}
+
gboolean
-libbalsa_message_is_multipart(LibBalsaMessage * message)
+libbalsa_message_is_multipart(LibBalsaMessage *message)
{
g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
return message->headers->content_type ?
- g_mime_content_type_is_type(message->headers->content_type,
- "multipart", "*") : FALSE;
+ g_mime_content_type_is_type(message->headers->content_type,
+ "multipart", "*") : FALSE;
}
+
gboolean
-libbalsa_message_is_partial(LibBalsaMessage * message, gchar ** id)
+libbalsa_message_is_partial(LibBalsaMessage *message,
+ gchar **id)
{
GMimeContentType *content_type;
g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
content_type = message->headers->content_type;
- if (!content_type
- || !g_mime_content_type_is_type(content_type,
- "message", "partial"))
- return FALSE;
+ if (content_type == NULL
+ || !g_mime_content_type_is_type(content_type,
+ "message", "partial"))
+ return FALSE;
+
if (id)
- *id = g_strdup(g_mime_content_type_get_parameter(content_type,
- "id"));
+ *id = g_strdup(g_mime_content_type_get_parameter(content_type,
+ "id"));
return TRUE;
}
+
/* Go through all parts and try to figure out whether it is a message
with attachments or not. It still yields insatsfactory
results... */
@@ -725,23 +816,25 @@ has_attached_part(LibBalsaMessageBody *body)
{
LibBalsaMessageBody *lbbody;
/* the condition matches the one used in add_multipart_mixed() */
- for(lbbody=body; lbbody; lbbody = lbbody->next) {
+ for (lbbody = body; lbbody; lbbody = lbbody->next) {
/* printf("part %s has disposition %s\n",
lbbody->content_type, lbbody->content_dsp); */
- if(!libbalsa_message_body_is_multipart(lbbody) &&
- !libbalsa_message_body_is_inline(lbbody) ) {
+ if (!libbalsa_message_body_is_multipart(lbbody) &&
+ !libbalsa_message_body_is_inline(lbbody)) {
/* puts("Attachment found!"); */
return TRUE;
}
- if(lbbody->parts && has_attached_part(lbbody->parts))
+
+ if (lbbody->parts && has_attached_part(lbbody->parts))
return TRUE;
}
/* no part was an attachment */
return FALSE;
}
+
gboolean
-libbalsa_message_has_attachment(LibBalsaMessage * message)
+libbalsa_message_has_attachment(LibBalsaMessage *message)
{
g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
@@ -749,7 +842,7 @@ libbalsa_message_has_attachment(LibBalsaMessage * message)
has Content-type: multipart/mixed AND members with
Content-disposition: attachment. Unfortunately, part list may
not be available at this stage. */
- if(!message->body_list) {
+ if (message->body_list == NULL) {
return message->headers->content_type &&
g_mime_content_type_is_type(message->headers->content_type,
"multipart", "mixed");
@@ -820,16 +913,24 @@ libbalsa_message_set_dispnotify(LibBalsaMessage * message,
}
}
-#ifndef MESSAGE_COPY_CONTENT
/* libbalsa_message_get_subject:
get constant pointer to the subject of the message;
*/
+#ifdef MESSAGE_COPY_CONTENT
+const gchar *
+libbalsa_message_get_subject(LibBalsaMessage *message)
+{
+ return message->subj != NULL ? message->subj : _("(No subject)");
+}
+
+
+#else /* MESSAGE_COPY_CONTENT */
const gchar *
libbalsa_message_get_subject(LibBalsaMessage* msg)
{
const gchar *ret;
- if(!msg->subj &&
- msg->mime_msg && msg->mailbox) { /* a message in a mailbox... */
+ if(msg->subj == NULL &&
+ msg->mime_msg != NULL && msg->mailbox != NULL) { /* a message in a mailbox... */
g_return_val_if_fail(MAILBOX_OPEN(msg->mailbox), NULL);
ret = g_mime_message_get_subject(msg->mime_msg);
libbalsa_message_set_subject_from_header(msg, ret);
@@ -845,10 +946,10 @@ libbalsa_message_get_lines(LibBalsaMessage* msg)
{
/* set the line count */
const char *value;
- if (!msg->mime_msg)
+ if (msg->mime_msg == NULL)
return 0;
value = g_mime_object_get_header(msg->mime_msg, "Lines");
- if (!value)
+ if (value == NULL)
return 0;
return atoi(value);
}
@@ -857,10 +958,10 @@ libbalsa_message_get_length(LibBalsaMessage* msg)
{
/* set the length */
const char *value;
- if (!msg->mime_msg)
+ if (msg->mime_msg == NULL)
return 0;
value = g_mime_object_get_header(msg->mime_msg, "Content-Length");
- if (!value)
+ if (value == NULL)
return 0;
return atoi(value);
}
@@ -872,104 +973,115 @@ libbalsa_message_get_no(LibBalsaMessage* msg)
}
-#endif
+#endif /* MESSAGE_COPY_CONTENT */
/* Populate headers from mime_msg, but only the members that are needed
* all the time. */
static InternetAddressList *
-lb_message_recipients(GMimeMessage * message, GMimeRecipientType type)
+lb_message_recipients(GMimeMessage *message,
+ GMimeRecipientType type)
{
const InternetAddressList *list;
InternetAddressList *copy = NULL;
if ((list = g_mime_message_get_recipients (message, type))) {
- copy = internet_address_list_new ();
- internet_address_list_append (copy, (InternetAddressList *) list);
+ copy = internet_address_list_new ();
+ internet_address_list_append (copy, (InternetAddressList *) list);
}
-
+
return copy;
}
+
static void
lb_message_headers_basic_from_gmime(LibBalsaMessageHeaders *headers,
- GMimeMessage *mime_msg)
+ GMimeMessage *mime_msg)
{
g_return_if_fail(headers);
g_return_if_fail(mime_msg != NULL);
- if (!headers->from)
+ if (headers->from == NULL)
headers->from = internet_address_list_parse_string(mime_msg->from);
- if (!headers->date)
- g_mime_message_get_date(mime_msg, &headers->date, NULL);
+ if (headers->date == 0)
+ g_mime_message_get_date(mime_msg, &headers->date, NULL);
- if (!headers->to_list)
+ if (headers->to_list == NULL) {
headers->to_list =
lb_message_recipients(mime_msg, GMIME_RECIPIENT_TYPE_TO);
+ }
- if (!headers->content_type) {
- /* If we could:
- * headers->content_type =
- * g_mime_content_type_copy
- * (g_mime_object_get_content_type(mime_msg->mime_part));
- */
- GMimeContentType *content_type;
- gchar *str;
- g_return_if_fail(headers->content_type == NULL);
- content_type = g_mime_object_get_content_type(mime_msg->mime_part);
- str = g_mime_content_type_to_string(content_type);
- headers->content_type = g_mime_content_type_new_from_string(str);
- g_free(str);
+ if (headers->content_type == NULL) {
+ /* If we could:
+ * headers->content_type =
+ * g_mime_content_type_copy
+ * (g_mime_object_get_content_type(mime_msg->mime_part));
+ */
+ GMimeContentType *content_type;
+ gchar *str;
+ g_return_if_fail(headers->content_type == NULL);
+ content_type = g_mime_object_get_content_type(mime_msg->mime_part);
+ str = g_mime_content_type_to_string(content_type);
+ headers->content_type = g_mime_content_type_new_from_string(str);
+ g_free(str);
}
}
+
/* Populate headers from mime_msg, but only the members not handled in
* lb_message_headers_basic_from_gmime. */
static void
lb_message_headers_extra_from_gmime(LibBalsaMessageHeaders *headers,
- GMimeMessage *mime_msg)
+ GMimeMessage *mime_msg)
{
g_return_if_fail(headers);
g_return_if_fail(mime_msg != NULL);
- if (!headers->reply_to)
+ if (headers->reply_to == NULL) {
headers->reply_to =
- internet_address_list_parse_string(mime_msg->reply_to);
+ internet_address_list_parse_string(mime_msg->reply_to);
+ }
- if (!headers->dispnotify_to)
+ if (headers->dispnotify_to == NULL) {
headers->dispnotify_to =
internet_address_list_parse_string(g_mime_object_get_header
- (GMIME_OBJECT(mime_msg),
- "Disposition-Notification-To"));
+ (GMIME_OBJECT(mime_msg),
+ "Disposition-Notification-To"));
+ }
- if (!headers->cc_list)
+ if (headers->cc_list == NULL) {
headers->cc_list =
lb_message_recipients(mime_msg, GMIME_RECIPIENT_TYPE_CC);
+ }
- if (!headers->bcc_list)
+ if (headers->bcc_list == NULL) {
headers->bcc_list =
lb_message_recipients(mime_msg, GMIME_RECIPIENT_TYPE_BCC);
+ }
/* Get fcc from message */
- if (!headers->fcc_url)
- headers->fcc_url =
- g_strdup(g_mime_object_get_header(GMIME_OBJECT(mime_msg), "X-Balsa-Fcc"));
+ if (headers->fcc_url == NULL) {
+ headers->fcc_url =
+ g_strdup(g_mime_object_get_header(GMIME_OBJECT(mime_msg), "X-Balsa-Fcc"));
+ }
}
+
/* Populate headers from the info in mime_msg. */
void
libbalsa_message_headers_from_gmime(LibBalsaMessageHeaders *headers,
- GMimeMessage *mime_msg)
+ GMimeMessage *mime_msg)
{
lb_message_headers_basic_from_gmime(headers, mime_msg);
lb_message_headers_extra_from_gmime(headers, mime_msg);
}
+
/* Populate message and message->headers from the info in mime_msg,
* but only the members that are needed all the time. */
void
-libbalsa_message_init_from_gmime(LibBalsaMessage * message,
- GMimeMessage *mime_msg)
+libbalsa_message_init_from_gmime(LibBalsaMessage *message,
+ GMimeMessage *mime_msg)
{
const gchar *header;
@@ -982,28 +1094,30 @@ libbalsa_message_init_from_gmime(LibBalsaMessage * message,
header = g_mime_object_get_header(GMIME_OBJECT(mime_msg), "Content-Length");
if (header)
- message->length = atoi(header);
-#endif
+ message->length = atoi(header);
+
+#endif /* MESSAGE_COPY_CONTENT */
header = g_mime_message_get_message_id(mime_msg);
if (header)
- message->message_id = g_strdup(header);
+ message->message_id = g_strdup(header);
header = g_mime_object_get_header(GMIME_OBJECT(mime_msg), "References");
if (header)
- libbalsa_message_set_references_from_string(message, header);
+ libbalsa_message_set_references_from_string(message, header);
header = g_mime_object_get_header(GMIME_OBJECT(mime_msg), "In-Reply-To");
if (header)
- libbalsa_message_set_in_reply_to_from_string(message, header);
+ libbalsa_message_set_in_reply_to_from_string(message, header);
lb_message_headers_basic_from_gmime(message->headers, mime_msg);
}
+
/* Create a newly allocated list of references for threading.
* This is a deep copy, with its own strings: deallocate with
* g_free and g_list_free. */
GList *
-libbalsa_message_refs_for_threading(LibBalsaMessage * message)
+libbalsa_message_refs_for_threading(LibBalsaMessage *message)
{
GList *tmp;
GList *foo;
@@ -1011,71 +1125,77 @@ libbalsa_message_refs_for_threading(LibBalsaMessage * message)
g_return_val_if_fail(message != NULL, NULL);
if (message->in_reply_to && message->in_reply_to->next)
- return NULL;
+ return NULL;
+
tmp = g_list_copy(message->references);
if (message->in_reply_to) {
- /* some mailers provide in_reply_to but no references, and
- * some apparently provide both but with the references in
- * the wrong order; we'll just make sure it's the last item
- * of this list */
- foo = g_list_find_custom(tmp, message->in_reply_to->data,
- (GCompareFunc) strcmp);
-
- if (foo) {
- tmp = g_list_remove_link(tmp, foo);
- g_list_free_1(foo);
- }
- tmp = g_list_append(tmp, message->in_reply_to->data);
+ /* some mailers provide in_reply_to but no references, and
+ * some apparently provide both but with the references in
+ * the wrong order; we'll just make sure it's the last item
+ * of this list */
+ foo = g_list_find_custom(tmp, message->in_reply_to->data,
+ (GCompareFunc) strcmp);
+
+ if (foo) {
+ tmp = g_list_remove_link(tmp, foo);
+ g_list_free_1(foo);
+ }
+ tmp = g_list_append(tmp, message->in_reply_to->data);
}
- for (foo = tmp; foo; foo = foo->next)
- foo->data = g_strdup((gchar *) foo->data);
+ for (foo = tmp; foo; foo = foo->next) {
+ foo->data = g_strdup((gchar *) foo->data);
+ }
return tmp;
}
+
static GList *
-references_decode(const gchar * str)
+references_decode(const gchar *str)
{
GMimeReferences *references, *reference;
GList *list = NULL;
reference = references = g_mime_references_decode(str);
while (reference) {
- list = g_list_prepend(list, g_strdup(reference->msgid));
- reference = reference->next;
+ list = g_list_prepend(list, g_strdup(reference->msgid));
+ reference = reference->next;
}
g_mime_references_clear(&references);
return g_list_reverse(list);
}
+
void
-libbalsa_message_set_references_from_string(LibBalsaMessage * message,
- const gchar *str)
+libbalsa_message_set_references_from_string(LibBalsaMessage *message,
+ const gchar *str)
{
- /* Empty references are acceptable but require no action. Similarly,
- if references were set already, there is not reason to set them
- again - they are immutable anyway. */
- if(!message->references && str)
+ /* Empty references are acceptable but require no action. Similarly,
+ if references were set already, there is not reason to set them
+ again - they are immutable anyway. */
+ if (message->references == NULL && str != NULL)
message->references = references_decode(str);
}
+
void
-libbalsa_message_set_in_reply_to_from_string(LibBalsaMessage * message,
- const gchar * str)
-{
- if (!message->in_reply_to && str) {
- /* FIXME for Balsa's old non-compliant header */
- gchar *p = strrchr(str, ';');
- p = p ? g_strndup(str, p - str) : g_strdup(str);
- message->in_reply_to = references_decode(p);
- g_free(p);
+libbalsa_message_set_in_reply_to_from_string(LibBalsaMessage *message,
+ const gchar *str)
+{
+ if (message->in_reply_to == NULL && str != NULL) {
+ /* FIXME for Balsa's old non-compliant header */
+ gchar *p = strrchr(str, ';');
+ p = p ? g_strndup(str, p - str) : g_strdup(str);
+ message->in_reply_to = references_decode(p);
+ g_free(p);
}
}
+
/* set a header, if (all) or if it's needed all the time:
* headers->from
* headers->date
@@ -1090,8 +1210,10 @@ libbalsa_message_set_in_reply_to_from_string(LibBalsaMessage * message,
* in_reply_to
*/
static gboolean
-lbmsg_set_header(LibBalsaMessage *message, const gchar *name,
- const gchar* value, gboolean all)
+lbmsg_set_header(LibBalsaMessage *message,
+ const gchar *name,
+ const gchar *value,
+ gboolean all)
{
gchar *val = NULL;
@@ -1111,99 +1233,99 @@ lbmsg_set_header(LibBalsaMessage *message, const gchar *name,
}
if (g_ascii_strcasecmp(name, "Subject") == 0) {
- if (!strcmp(value,
- "DON'T DELETE THIS MESSAGE -- FOLDER INTERNAL DATA")) {
+ if (strcmp(value,
+ "DON'T DELETE THIS MESSAGE -- FOLDER INTERNAL DATA") == 0) {
g_free(val);
- return FALSE;
+ return FALSE;
}
#if MESSAGE_COPY_CONTENT
libbalsa_message_set_subject_from_header(message, value);
-#endif
- } else
- if (g_ascii_strcasecmp(name, "Date") == 0) {
- message->headers->date = g_mime_utils_header_decode_date(value, NULL);
- } else
- if (message->headers->from == NULL &&
- g_ascii_strcasecmp(name, "From") == 0) {
+#endif /* MESSAGE_COPY_CONTENT */
+ } else if (g_ascii_strcasecmp(name, "Date") == 0) {
+ message->headers->date = g_mime_utils_header_decode_date(value, NULL);
+ } else if ((message->headers->from == NULL) &&
+ (g_ascii_strcasecmp(name, "From") == 0)) {
message->headers->from = internet_address_list_parse_string(value);
- } else
- if (message->headers->to_list == NULL &&
- g_ascii_strcasecmp(name, "To") == 0) {
- message->headers->to_list = internet_address_list_parse_string(value);
- } else
- if (g_ascii_strcasecmp(name, "In-Reply-To") == 0) {
- libbalsa_message_set_in_reply_to_from_string(message, value);
- } else
- if (message->message_id == NULL &&
- g_ascii_strcasecmp(name, "Message-ID") == 0) {
- message->message_id = g_mime_utils_decode_message_id(value);
- } else
- if (g_ascii_strcasecmp(name, "References") == 0) {
- libbalsa_message_set_references_from_string(message, value);
- } else
- if (message->headers->content_type == NULL &&
- g_ascii_strcasecmp(name, "Content-Type") == 0) {
- message->headers->content_type =
- g_mime_content_type_new_from_string(value);
- } else
- if (message->headers->dispnotify_to == NULL &&
- g_ascii_strcasecmp(name, "Disposition-Notification-To") == 0) {
- message->headers->dispnotify_to =
- internet_address_list_parse_string(value);
+ } else if ((message->headers->to_list == NULL) &&
+ (g_ascii_strcasecmp(name, "To") == 0)) {
+ message->headers->to_list = internet_address_list_parse_string(value);
+ } else if (g_ascii_strcasecmp(name, "In-Reply-To") == 0) {
+ libbalsa_message_set_in_reply_to_from_string(message, value);
+ } else if ((message->message_id == NULL) &&
+ (g_ascii_strcasecmp(name, "Message-ID") == 0)) {
+ message->message_id = g_mime_utils_decode_message_id(value);
+ } else if (g_ascii_strcasecmp(name, "References") == 0) {
+ libbalsa_message_set_references_from_string(message, value);
+ } else if ((message->headers->content_type == NULL) &&
+ (g_ascii_strcasecmp(name, "Content-Type") == 0)) {
+ message->headers->content_type = g_mime_content_type_new_from_string(value);
+ } else if ((message->headers->dispnotify_to == NULL) &&
+ (g_ascii_strcasecmp(name, "Disposition-Notification-To") == 0)) {
+ message->headers->dispnotify_to = internet_address_list_parse_string(value);
} else
#ifdef MESSAGE_COPY_CONTENT
if (g_ascii_strcasecmp(name, "Content-Length") == 0) {
- message->length = atoi(value);
+ message->length = atoi(value);
} else
-#endif
- if (all)
+#endif /* MESSAGE_COPY_CONTENT */
+ if (all) {
message->headers->user_hdrs =
g_list_prepend(message->headers->user_hdrs,
- libbalsa_create_hdr_pair(name,
- g_strdup(value)));
+ libbalsa_create_hdr_pair(name, g_strdup(value)));
+ }
g_free(val);
return TRUE;
}
+
static gboolean
lb_message_set_headers_from_string(LibBalsaMessage *message,
- const gchar *lines, gboolean all)
+ const gchar *lines,
+ gboolean all)
{
gchar *header, *value;
const gchar *val, *eoh;
do {
- for(val = lines; *val && *val >32 && *val<127 && *val != ':'; val++)
- ;
- if(*val != ':') /* parsing error */
+ for (val = lines; *val && *val > 32 && *val < 127 && *val != ':'; val++) {
+ }
+ if (*val != ':') /* parsing error */
return FALSE;
- for(eoh = val+1; *eoh && (eoh[0] != '\n' || isspace(eoh[1])); eoh++)
- ;
- header = g_strndup(lines, val-lines);
- lines = eoh;
- for(val=val+1; *val && isspace(*val); val++)
- ; /* strip spaces at front... */
- while(eoh>val && isspace(*eoh)) eoh--; /* .. and at the end */
- value = g_strndup(val, eoh-val+1);
-
+
+ for (eoh = val + 1; *eoh && (eoh[0] != '\n' || isspace(eoh[1])); eoh++) {
+ }
+ header = g_strndup(lines, val - lines);
+ lines = eoh;
+ for (val = val + 1; *val && isspace(*val); val++) {
+ /* strip spaces at front... */
+ }
+ while (eoh > val && isspace(*eoh)) {
+ eoh--; /* .. and at the end */
+ }
+ value = g_strndup(val, eoh - val + 1);
+
lbmsg_set_header(message, header, value, all);
- g_free(header); g_free(value);
- if(!*lines || !*++lines) break;
- } while(1);
+ g_free(header);
+ g_free(value);
+ if (*lines == '\0' || *++lines == '\0')
+ break;
+ } while (1);
return TRUE;
}
+
gboolean
libbalsa_message_set_headers_from_string(LibBalsaMessage *message,
- const gchar *lines)
+ const gchar *lines)
{
return lb_message_set_headers_from_string(message, lines, TRUE);
}
+
void
-libbalsa_message_load_envelope_from_stream(LibBalsaMessage * message,
- GMimeStream *gmime_stream)
+libbalsa_message_load_envelope_from_stream(LibBalsaMessage *message,
+ GMimeStream *gmime_stream)
{
GMimeStream *gmime_stream_filter;
GMimeFilter *gmime_filter_crlf;
@@ -1223,7 +1345,7 @@ libbalsa_message_load_envelope_from_stream(LibBalsaMessage * message,
g_mime_filter_crlf_new(FALSE,
FALSE);
g_mime_stream_filter_add(GMIME_STREAM_FILTER(gmime_stream_filter),
- gmime_filter_crlf);
+ gmime_filter_crlf);
g_object_unref(gmime_filter_crlf);
/* Buffer the message stream, so we can read it line by line. */
@@ -1238,30 +1360,28 @@ libbalsa_message_load_envelope_from_stream(LibBalsaMessage * message,
*/
line = g_byte_array_new();
do {
- g_mime_stream_buffer_readln(gmime_stream_buffer, line);
- while (g_mime_stream_read(gmime_stream_buffer,
- (char *) &lookahead, 1) == 1
+ g_mime_stream_buffer_readln(gmime_stream_buffer, line);
+ while (g_mime_stream_read(gmime_stream_buffer,
+ (char *) &lookahead, 1) == 1
&& (lookahead == ' ' || lookahead == '\t')) {
g_byte_array_append(line, &lookahead, 1);
g_mime_stream_buffer_readln(gmime_stream_buffer, line);
- }
- if (line->len == 0 || line->data[line->len-1]!='\n') {
- /* EOF or read error; in either case, message has no body. */
- break;
- }
- line->data[line->len-1]='\0'; /* terminate line by overwriting '\n' */
- if (!lb_message_set_headers_from_string(message,
- (gchar *) line->data,
- FALSE)) {
- /* Ignore error return caused by malformed header. */
- }
- if (lookahead == '\n') {/* end of header */
+ }
+ if ((line->len == 0) || (line->data[line->len - 1] != '\n')) {
+ /* EOF or read error; in either case, message has no body. */
+ break;
+ }
+ line->data[line->len - 1] = '\0'; /* terminate line by overwriting '\n' */
+ if (!lb_message_set_headers_from_string(message, (gchar *) line->data, FALSE)) {
+ /* Ignore error return caused by malformed header. */
+ }
+ if (lookahead == '\n') {/* end of header */
/* Message looks valid--set its length. */
message->length = g_mime_stream_length(gmime_stream);
- break;
- }
- line->len = 0;
- g_byte_array_append(line, &lookahead, 1);
+ break;
+ }
+ line->len = 0;
+ g_byte_array_append(line, &lookahead, 1);
} while (TRUE);
g_byte_array_free(line, TRUE);
@@ -1270,21 +1390,24 @@ libbalsa_message_load_envelope_from_stream(LibBalsaMessage * message,
libbalsa_mime_stream_shared_unlock(gmime_stream);
}
+
void
libbalsa_message_load_envelope(LibBalsaMessage *message)
{
GMimeStream *gmime_stream;
gmime_stream = libbalsa_message_stream(message);
- if (!gmime_stream)
- return;
+ if (gmime_stream == NULL)
+ return;
+
libbalsa_message_load_envelope_from_stream(message, gmime_stream);
g_object_unref(gmime_stream);
}
+
GMimeStream *
-libbalsa_message_stream(LibBalsaMessage * message)
+libbalsa_message_stream(LibBalsaMessage *message)
{
LibBalsaMailbox *mailbox;
GMimeStream *mime_stream;
@@ -1298,6 +1421,7 @@ libbalsa_message_stream(LibBalsaMessage * message)
return libbalsa_mailbox_get_message_stream(mailbox,
message->msgno, FALSE);
+
mime_stream = g_mime_stream_mem_new();
g_mime_object_write_to_stream(GMIME_OBJECT(message->mime_msg),
mime_stream);
@@ -1306,9 +1430,11 @@ libbalsa_message_stream(LibBalsaMessage * message)
return mime_stream;
}
+
gboolean
-libbalsa_message_copy(LibBalsaMessage * message, LibBalsaMailbox * dest,
- GError ** err)
+libbalsa_message_copy(LibBalsaMessage *message,
+ LibBalsaMailbox *dest,
+ GError **err)
{
LibBalsaMailbox *mailbox;
gboolean retval;
@@ -1335,9 +1461,10 @@ libbalsa_message_copy(LibBalsaMessage * message, LibBalsaMailbox * dest,
return retval;
}
+
void
-libbalsa_message_set_subject(LibBalsaMessage * message,
- const gchar * subject)
+libbalsa_message_set_subject(LibBalsaMessage *message,
+ const gchar *subject)
{
g_free(message->subj);
message->subj = g_strdup(subject);
@@ -1345,10 +1472,13 @@ libbalsa_message_set_subject(LibBalsaMessage * message,
canonize_header_value(message->subj);
}
+
void
-libbalsa_message_set_subject_from_header(LibBalsaMessage * message,
- const gchar * header)
+libbalsa_message_set_subject_from_header(LibBalsaMessage *message,
+ const gchar *header)
{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
if (header) {
gchar *subject =
g_mime_utils_header_decode_text(header);
@@ -1357,13 +1487,397 @@ libbalsa_message_set_subject_from_header(LibBalsaMessage * message,
}
}
+
const gchar *
-libbalsa_message_get_tempdir(LibBalsaMessage * message)
+libbalsa_message_get_tempdir(LibBalsaMessage *message)
{
- if (!message->tempdir) {
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ if (message->tempdir == NULL)
if (!libbalsa_mktempdir(&message->tempdir))
g_warning("Could not make tempdir");
- }
return message->tempdir;
}
+
+
+/*
+ * Getters
+ */
+
+LibBalsaMailbox *
+libbalsa_message_get_mailbox(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->mailbox;
+}
+
+
+LibBalsaMessageHeaders *
+libbalsa_message_get_headers(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->headers;
+}
+
+
+LibBalsaMessageBody *
+libbalsa_message_get_body_list(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->body_list;
+}
+
+
+GMimeMessage *
+libbalsa_message_get_mime_message(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->mime_msg;
+}
+
+
+LibBalsaMessageFlag
+libbalsa_message_get_flags(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->flags;
+}
+
+
+const gchar *
+libbalsa_message_get_message_id(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->message_id;
+}
+
+
+glong
+libbalsa_message_get_msgno(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->msgno;
+}
+
+
+glong
+libbalsa_message_get_length(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->length;
+}
+
+
+gboolean
+libbalsa_message_get_has_all_headers(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
+
+ return message->has_all_headers;
+}
+
+
+InternetAddressList *
+libbalsa_message_get_sender(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->sender;
+}
+
+
+gboolean
+libbalsa_message_get_request_dsn(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
+
+ return message->request_dsn;
+}
+
+
+GList *
+libbalsa_message_get_references(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->references;
+}
+
+
+LibBalsaIdentity *
+libbalsa_message_get_identity(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->ident;
+}
+
+
+
+GList *
+libbalsa_message_get_parameters(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->parameters;
+}
+
+
+const gchar *
+libbalsa_message_get_subtype(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->subtype;
+}
+
+
+guint
+libbalsa_message_get_gpg_mode(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->gpg_mode;
+}
+
+
+GList *
+libbalsa_message_get_in_reply_to(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), NULL);
+
+ return message->in_reply_to;
+}
+
+
+gboolean
+libbalsa_message_get_attach_pubkey(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), FALSE);
+
+ return message->att_pubkey;
+}
+
+
+LibBalsaMsgProtectState
+libbalsa_message_get_protect_state(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->prot_state;
+}
+
+
+guint
+libbalsa_message_get_body_ref(LibBalsaMessage *message)
+{
+ g_return_val_if_fail(LIBBALSA_IS_MESSAGE(message), 0);
+
+ return message->body_ref;
+}
+
+
+/*
+ * Setters
+ */
+
+void
+libbalsa_message_set_flags(LibBalsaMessage *message,
+ LibBalsaMessageFlag flags)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->flags = flags;
+}
+
+
+void
+libbalsa_message_set_mailbox(LibBalsaMessage *message,
+ LibBalsaMailbox *mailbox)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+ g_return_if_fail(mailbox == NULL || LIBBALSA_IS_MAILBOX(mailbox));
+
+ message->mailbox = mailbox;
+}
+
+
+void
+libbalsa_message_set_msgno(LibBalsaMessage *message,
+ glong msgno)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->msgno = msgno;
+}
+
+
+void
+libbalsa_message_set_has_all_headers(LibBalsaMessage *message,
+ gboolean has_all_headers)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->has_all_headers = has_all_headers;
+}
+
+
+#if MESSAGE_COPY_CONTENT
+void
+libbalsa_message_set_length(LibBalsaMessage *message,
+ glong length)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->length = length;
+}
+
+
+#endif /* MESSAGE_COPY_CONTENT */
+
+void
+libbalsa_message_set_mime_message(LibBalsaMessage *message,
+ GMimeMessage *mime_message)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+ g_return_if_fail(mime_message == NULL || GMIME_IS_MESSAGE(mime_message));
+
+ g_set_object(&message->mime_msg, mime_message);
+}
+
+
+void
+libbalsa_message_set_sender(LibBalsaMessage *message,
+ InternetAddressList *sender)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+ g_return_if_fail(sender == NULL || IS_INTERNET_ADDRESS_LIST(sender));
+
+ g_set_object(&message->sender, sender);
+}
+
+
+void
+libbalsa_message_set_message_id(LibBalsaMessage *message,
+ const gchar *message_id)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ g_free(message->message_id);
+ message->message_id = g_strdup(message_id);
+}
+
+
+void
+libbalsa_message_set_protect_state(LibBalsaMessage *message,
+ LibBalsaMsgProtectState prot_state)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->prot_state = prot_state;
+}
+
+
+void
+libbalsa_message_set_request_dsn(LibBalsaMessage *message,
+ gboolean request_dsn)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->request_dsn = request_dsn;
+}
+
+
+void
+libbalsa_message_set_subtype(LibBalsaMessage *message,
+ const gchar *subtype)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ g_free(message->subtype);
+ message->subtype = g_strdup(subtype);
+}
+
+
+void
+libbalsa_message_set_body_list(LibBalsaMessage *message,
+ LibBalsaMessageBody *body_list)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->body_list = body_list;
+}
+
+
+void
+libbalsa_message_set_references(LibBalsaMessage *message,
+ GList *references)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ g_list_free_full(message->references, g_free);
+ /* We steal the GList and its data; see libbalsa_message_finalize */
+ message->references = references;
+}
+
+
+void
+libbalsa_message_set_in_reply_to(LibBalsaMessage *message,
+ GList *in_reply_to)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ g_list_free_full(message->in_reply_to, g_free);
+ /* We steal the GList and its data; see libbalsa_message_finalize */
+ message->in_reply_to = in_reply_to;
+}
+
+
+void
+libbalsa_message_set_gpg_mode(LibBalsaMessage *message,
+ guint mode)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->gpg_mode = mode;
+}
+
+
+void
+libbalsa_message_set_attach_pubkey(LibBalsaMessage *message,
+ gboolean att_pubkey)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->att_pubkey = att_pubkey;
+}
+
+
+void
+libbalsa_message_set_identity(LibBalsaMessage *message,
+ LibBalsaIdentity *ident)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+ g_return_if_fail(ident == NULL || LIBBALSA_IS_IDENTITY(ident));
+
+ g_set_object(&message->ident, ident);
+}
+
+
+void
+libbalsa_message_add_parameters(LibBalsaMessage *message,
+ gchar **parameters)
+{
+ g_return_if_fail(LIBBALSA_IS_MESSAGE(message));
+
+ message->parameters = g_list_prepend(message->parameters, parameters);
+}
diff --git a/libbalsa/message.h b/libbalsa/message.h
index a45362dc6..7841a90d7 100644
--- a/libbalsa/message.h
+++ b/libbalsa/message.h
@@ -5,14 +5,14 @@
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
+ * the Free Software Foundation; either version 2, or (at your option)
* any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
@@ -21,7 +21,7 @@
#define __LIBBALSA_MESSAGE_H__
#ifndef BALSA_VERSION
-# error "Include config.h before this file."
+# error "Include config.h before this file."
#endif
#include <glib.h>
@@ -34,19 +34,15 @@
#include "rfc3156.h"
#define MESSAGE_COPY_CONTENT 1
-#define LIBBALSA_TYPE_MESSAGE \
- (libbalsa_message_get_type())
-#define LIBBALSA_MESSAGE(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST(obj, LIBBALSA_TYPE_MESSAGE, LibBalsaMessage))
-#define LIBBALSA_MESSAGE_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST(klass, LIBBALSA_TYPE_MESSAGE, \
- LibBalsaMessageClass))
-#define LIBBALSA_IS_MESSAGE(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE(obj, LIBBALSA_TYPE_MESSAGE))
-#define LIBBALSA_IS_MESSAGE_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE(klass, LIBBALSA_TYPE_MESSAGE))
-
-typedef struct _LibBalsaMessageClass LibBalsaMessageClass;
+
+#define LIBBALSA_TYPE_MESSAGE libbalsa_message_get_type()
+
+G_DECLARE_FINAL_TYPE(LibBalsaMessage,
+ libbalsa_message,
+ LIBBALSA,
+ MESSAGE,
+ GObject)
+
typedef enum _LibBalsaMessageFlag LibBalsaMessageFlag;
enum _LibBalsaMessageFlag {
@@ -55,16 +51,16 @@ enum _LibBalsaMessageFlag {
LIBBALSA_MESSAGE_FLAG_REPLIED = 1 << 2,
LIBBALSA_MESSAGE_FLAG_FLAGGED = 1 << 3,
LIBBALSA_MESSAGE_FLAG_RECENT = 1 << 4,
- LIBBALSA_MESSAGE_FLAG_SELECTED= 1 << 5, /* pseudo flag */
- LIBBALSA_MESSAGE_FLAG_INVALID = 1 << 6 /* pseudo flag */
+ LIBBALSA_MESSAGE_FLAG_SELECTED= 1 << 5, /* pseudo flag */
+ LIBBALSA_MESSAGE_FLAG_INVALID = 1 << 6 /* pseudo flag */
};
#define LIBBALSA_MESSAGE_FLAGS_REAL \
- (LIBBALSA_MESSAGE_FLAG_NEW | \
- LIBBALSA_MESSAGE_FLAG_DELETED | \
- LIBBALSA_MESSAGE_FLAG_REPLIED | \
- LIBBALSA_MESSAGE_FLAG_FLAGGED | \
- LIBBALSA_MESSAGE_FLAG_RECENT)
+ (LIBBALSA_MESSAGE_FLAG_NEW | \
+ LIBBALSA_MESSAGE_FLAG_DELETED | \
+ LIBBALSA_MESSAGE_FLAG_REPLIED | \
+ LIBBALSA_MESSAGE_FLAG_FLAGGED | \
+ LIBBALSA_MESSAGE_FLAG_RECENT)
typedef enum _LibBalsaMessageStatus LibBalsaMessageStatus;
enum _LibBalsaMessageStatus {
@@ -153,90 +149,8 @@ struct _LibBalsaMessageHeaders {
/** FREE_HEADER_LIST() frees user_hdrs */
#define FREE_HEADER_LIST(l) do{g_list_free_full((l),(GDestroyNotify)g_strfreev);}while(0)
-struct _LibBalsaMessage {
- GObject object;
-
- /* the mailbox this message belongs to */
- LibBalsaMailbox *mailbox;
-
- /* flags */
- LibBalsaMessageFlag flags;
-
- /* headers */
- LibBalsaMessageHeaders *headers;
- int updated; /** whether complete headers have been fetched */
-
- GMimeMessage *mime_msg;
-
- /* sender address */
- InternetAddressList *sender;
-
- /* subject line; we still need it here for sending;
- * although _SET_SUBJECT might resolve it(?)
- * but we can set to to NULL unless there is no mailbox, like
- * on sending. */
- gchar *subj;
-#ifdef MESSAGE_COPY_CONTENT
-#define LIBBALSA_MESSAGE_GET_SUBJECT(m) \
- ((m)->subj ? (m)->subj : _("(No subject)"))
-#else
-#define LIBBALSA_MESSAGE_GET_SUBJECT(m) libbalsa_message_get_subject(m)
-#endif
-
- /* replied message ID's */
- GList *references;
-
- /* replied message ID; from address on date */
- GList *in_reply_to;
-
- /* message ID */
- gchar *message_id;
-
- /* GPG sign and/or encrypt message (sending) */
- guint gpg_mode;
-
- /* attach the GnuPG public key to the message (sending) */
- gboolean att_pubkey;
-
- /* protection (i.e. sign/encrypt) status (received message) */
- LibBalsaMsgProtectState prot_state;
-
- /* sender identity, required for choosing a forced GnuPG or S/MIME key */
- LibBalsaIdentity *ident;
-
- /* request a DSN (sending) */
- gboolean request_dsn;
-
- /* a forced multipart subtype or NULL for mixed; used only for
- * sending */
- gchar *subtype;
-
- /* additional message content type parameters; used only for sending */
- GList *parameters;
-
- /* message body */
- guint body_ref;
- LibBalsaMessageBody *body_list;
- /* GList *body_list; */
-
- glong msgno; /* message no; always copy for faster sorting;
- * counting starts at 1. */
-#if MESSAGE_COPY_CONTENT
-#define LIBBALSA_MESSAGE_GET_NO(m) ((m)->msgno)
- glong length; /* byte len */
-#define LIBBALSA_MESSAGE_GET_LENGTH(m) ((m)->length)
-#else
-#define LIBBALSA_MESSAGE_GET_LENGTH(m) libbalsa_message_get_length(m)
-#define LIBBALSA_MESSAGE_GET_NO(m) libbalsa_message_get_no(m)
-#endif
-
- gchar *tempdir; /* to hold named parts */
-
- unsigned has_all_headers:1;
-};
-
#define LIBBALSA_MESSAGE_HAS_FLAG(message, mask) \
- ((LIBBALSA_MESSAGE(message)->flags & mask) != 0)
+ ((libbalsa_message_get_flags(LIBBALSA_MESSAGE(message)) & mask) != 0)
#define LIBBALSA_MESSAGE_IS_UNREAD(message) \
LIBBALSA_MESSAGE_HAS_FLAG(message, LIBBALSA_MESSAGE_FLAG_NEW)
#define LIBBALSA_MESSAGE_IS_DELETED(message) \
@@ -248,26 +162,18 @@ struct _LibBalsaMessage {
#define LIBBALSA_MESSAGE_IS_RECENT(message) \
LIBBALSA_MESSAGE_HAS_FLAG(message, LIBBALSA_MESSAGE_FLAG_RECENT)
-struct _LibBalsaMessageClass {
- GObjectClass parent_class;
-
- /* deal with flags being set/unset */
- /* Signal: */
- void (*status_changed) (LibBalsaMessage * message,
- LibBalsaMessageFlag flag, gboolean);
-};
-
-
-GType libbalsa_message_get_type(void);
+#define LIBBALSA_MESSAGE_GET_SUBJECT(m) libbalsa_message_get_subject(m)
+#define LIBBALSA_MESSAGE_GET_NO(m) libbalsa_message_get_msgno(m)
+#define LIBBALSA_MESSAGE_GET_LENGTH(m) libbalsa_message_get_length(m)
/*
* message headers
*/
-void libbalsa_message_headers_destroy(LibBalsaMessageHeaders * headers);
-void libbalsa_message_headers_from_gmime(LibBalsaMessageHeaders *headers,
- GMimeMessage *msg);
-void libbalsa_message_init_from_gmime(LibBalsaMessage * message,
- GMimeMessage * msg);
+void libbalsa_message_headers_destroy(LibBalsaMessageHeaders *headers);
+void libbalsa_message_headers_from_gmime(LibBalsaMessageHeaders *headers,
+ GMimeMessage *msg);
+void libbalsa_message_init_from_gmime(LibBalsaMessage *message,
+ GMimeMessage *msg);
GList *libbalsa_message_user_hdrs_from_gmime(GMimeMessage *msg);
@@ -324,15 +230,16 @@ void libbalsa_message_set_subject_from_header(LibBalsaMessage * message,
/* use LIBBALSA_MESSAGE_GET_SUBJECT() macro, we may optimize this
function out if we find a way.
*/
-#ifndef MESSAGE_COPY_CONTENT
const gchar* libbalsa_message_get_subject(LibBalsaMessage* message);
+#ifndef MESSAGE_COPY_CONTENT
guint libbalsa_message_get_lines(LibBalsaMessage* msg);
glong libbalsa_message_get_length(LibBalsaMessage* msg);
-#endif
+#endif /* !MESSAGE_COPY_CONTENT */
glong libbalsa_message_get_no(LibBalsaMessage* msg);
LibBalsaMessageAttach libbalsa_message_get_attach_icon(LibBalsaMessage *
message);
-#define libbalsa_message_date_to_utf8(m, f) libbalsa_date_to_utf8((m)->headers->date, (f))
+#define libbalsa_message_date_to_utf8(m, f) \
+ libbalsa_date_to_utf8(libbalsa_message_get_headers(m)->date, (f))
#define libbalsa_message_headers_date_to_utf8(h, f) libbalsa_date_to_utf8((h)->date, (f))
GList *libbalsa_message_refs_for_threading(LibBalsaMessage* msg);
@@ -354,4 +261,73 @@ void libbalsa_message_change_flags(LibBalsaMessage * message,
LibBalsaMessageFlag clear);
const gchar *libbalsa_message_get_tempdir(LibBalsaMessage * message);
+/*
+ * Getters
+ */
+LibBalsaMailbox *libbalsa_message_get_mailbox(LibBalsaMessage *message);
+LibBalsaMessageHeaders *libbalsa_message_get_headers(LibBalsaMessage *message);
+LibBalsaMessageBody *libbalsa_message_get_body_list(LibBalsaMessage *message);
+GMimeMessage *libbalsa_message_get_mime_message(LibBalsaMessage *message);
+LibBalsaMessageFlag libbalsa_message_get_flags(LibBalsaMessage *message);
+const gchar *libbalsa_message_get_message_id(LibBalsaMessage *message);
+glong libbalsa_message_get_msgno(LibBalsaMessage *message);
+glong libbalsa_message_get_length(LibBalsaMessage *message);
+gboolean libbalsa_message_get_has_all_headers(LibBalsaMessage *message);
+InternetAddressList *libbalsa_message_get_sender(LibBalsaMessage *message);
+gboolean libbalsa_message_get_request_dsn(LibBalsaMessage *message);
+GList *libbalsa_message_get_references(LibBalsaMessage *message);
+LibBalsaIdentity *libbalsa_message_get_identity(LibBalsaMessage *message);
+GList *libbalsa_message_get_parameters(LibBalsaMessage *message);
+const gchar *libbalsa_message_get_subtype(LibBalsaMessage *message);
+guint libbalsa_message_get_gpg_mode(LibBalsaMessage *message);
+GList *libbalsa_message_get_in_reply_to(LibBalsaMessage *message);
+gboolean libbalsa_message_get_attach_pubkey(LibBalsaMessage *message);
+LibBalsaMsgProtectState libbalsa_message_get_protect_state(LibBalsaMessage *message);
+guint libbalsa_message_get_body_ref(LibBalsaMessage *message);
+
+/*
+ * Setters
+ */
+void libbalsa_message_set_flags(LibBalsaMessage *message,
+ LibBalsaMessageFlag flags);
+void libbalsa_message_set_mailbox(LibBalsaMessage *message,
+ LibBalsaMailbox *mailbox);
+void libbalsa_message_set_msgno(LibBalsaMessage *message,
+ glong msgno);
+void libbalsa_message_set_has_all_headers(LibBalsaMessage *message,
+ gboolean has_all_headers);
+
+#if MESSAGE_COPY_CONTENT
+void libbalsa_message_set_length(LibBalsaMessage *message,
+ glong length);
+
+#endif /* MESSAGE_COPY_CONTENT */
+
+void libbalsa_message_set_mime_message(LibBalsaMessage *message,
+ GMimeMessage *mime_message);
+void libbalsa_message_set_sender(LibBalsaMessage *message,
+ InternetAddressList *sender);
+void libbalsa_message_set_message_id(LibBalsaMessage *message,
+ const gchar *message_id);
+void libbalsa_message_set_protect_state(LibBalsaMessage *message,
+ LibBalsaMsgProtectState prot_state);
+void libbalsa_message_set_request_dsn(LibBalsaMessage *message,
+ gboolean request_dsn);
+void libbalsa_message_set_subtype(LibBalsaMessage *message,
+ const gchar *subtype);
+void libbalsa_message_set_body_list(LibBalsaMessage *message,
+ LibBalsaMessageBody *body_list);
+void libbalsa_message_set_references(LibBalsaMessage *message,
+ GList *references);
+void libbalsa_message_set_in_reply_to(LibBalsaMessage *message,
+ GList *in_reply_to);
+void libbalsa_message_set_gpg_mode(LibBalsaMessage *message,
+ guint mode);
+void libbalsa_message_set_attach_pubkey(LibBalsaMessage *message,
+ gboolean att_pubkey);
+void libbalsa_message_set_identity(LibBalsaMessage *message,
+ LibBalsaIdentity *identity);
+void libbalsa_message_add_parameters(LibBalsaMessage *message,
+ gchar **parameters);
+
#endif /* __LIBBALSA_MESSAGE_H__ */
diff --git a/libbalsa/rfc3156.c b/libbalsa/rfc3156.c
index d31fbd171..81d002daf 100644
--- a/libbalsa/rfc3156.c
+++ b/libbalsa/rfc3156.c
@@ -338,6 +338,7 @@ gboolean
libbalsa_body_check_signature(LibBalsaMessageBody * body,
gpgme_protocol_t protocol)
{
+ LibBalsaMailbox *mailbox;
GError *error = NULL;
GMimeGpgmeSigstat *result;
@@ -359,7 +360,8 @@ libbalsa_body_check_signature(LibBalsaMessageBody * body,
g_object_unref(G_OBJECT(body->parts->next->sig_info));
/* verify the signature */
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
result = g_mime_gpgme_mps_verify(GMIME_MULTIPART_SIGNED(body->mime_part), &error);
if (!result) {
if (error) {
@@ -373,7 +375,7 @@ libbalsa_body_check_signature(LibBalsaMessageBody * body,
}
body->parts->next->sig_info = result;
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
return TRUE;
}
@@ -386,6 +388,7 @@ libbalsa_body_check_signature(LibBalsaMessageBody * body,
LibBalsaMessageBody *
libbalsa_body_decrypt(LibBalsaMessageBody *body, gpgme_protocol_t protocol, GtkWindow *parent)
{
+ LibBalsaMailbox *mailbox;
GMimeObject *mime_obj = NULL;
GError *error = NULL;
LibBalsaMessage *message;
@@ -418,7 +421,8 @@ libbalsa_body_decrypt(LibBalsaMessageBody *body, gpgme_protocol_t protocol, GtkW
smime_encrypted = body->was_encrypted;
}
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
if (protocol == GPGME_PROTOCOL_OpenPGP) {
mime_obj =
g_mime_gpgme_mpe_decrypt(GMIME_MULTIPART_ENCRYPTED(body->mime_part),
@@ -428,7 +432,7 @@ libbalsa_body_decrypt(LibBalsaMessageBody *body, gpgme_protocol_t protocol, GtkW
g_mime_application_pkcs7_decrypt_verify(GMIME_PART(body->mime_part),
&sig_state, parent, &error);
}
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
/* check the result */
if (mime_obj == NULL) {
@@ -454,7 +458,7 @@ libbalsa_body_decrypt(LibBalsaMessageBody *body, gpgme_protocol_t protocol, GtkW
body->was_encrypted = smime_encrypted;
}
if (body->was_encrypted)
- body->message->prot_state = LIBBALSA_MSG_PROTECT_CRYPT;
+ libbalsa_message_set_protect_state(body->message, LIBBALSA_MSG_PROTECT_CRYPT);
libbalsa_message_body_set_mime_body(body, mime_obj);
if (sig_state) {
diff --git a/libbalsa/send.c b/libbalsa/send.c
index e83846dc0..07753a65d 100644
--- a/libbalsa/send.c
+++ b/libbalsa/send.c
@@ -424,6 +424,7 @@ lbs_message_queue_real(LibBalsaMessage *message,
GError **error)
{
LibBalsaMsgCreateResult result;
+ GMimeMessage *mime_msg;
guint big_message;
gboolean rc;
@@ -435,23 +436,22 @@ lbs_message_queue_real(LibBalsaMessage *message,
return result;
}
+ mime_msg = libbalsa_message_get_mime_message(message);
if (fccbox != NULL) {
- g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), "X-Balsa-Fcc",
+ g_mime_object_set_header(GMIME_OBJECT(mime_msg), "X-Balsa-Fcc",
libbalsa_mailbox_get_url(fccbox));
}
- g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), "X-Balsa-DSN",
- message->request_dsn ? "1" : "0");
- g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), "X-Balsa-SmtpServer",
+ g_mime_object_set_header(GMIME_OBJECT(mime_msg), "X-Balsa-DSN",
+ libbalsa_message_get_request_dsn(message) ? "1" : "0");
+ g_mime_object_set_header(GMIME_OBJECT(mime_msg), "X-Balsa-SmtpServer",
libbalsa_smtp_server_get_name(smtp_server));
big_message = libbalsa_smtp_server_get_big_message(smtp_server);
if (big_message > 0) {
- GMimeMessage *mime_msg;
GMimeMessage **mime_msgs;
size_t nparts;
guint i;
- mime_msg = message->mime_msg;
mime_msgs =
g_mime_message_partial_split_message(mime_msg, big_message,
&nparts);
@@ -467,13 +467,15 @@ lbs_message_queue_real(LibBalsaMessage *message,
libbalsa_set_message_id(mime_msgs[i]);
}
if (rc) {
- message->mime_msg = mime_msgs[i];
+ /* Temporarily modify message by changing its mime_msg: */
+ libbalsa_message_set_mime_message(message, mime_msgs[i]);
rc = libbalsa_message_copy(message, outbox, error);
}
g_object_unref(mime_msgs[i]);
}
g_free(mime_msgs);
- message->mime_msg = mime_msg;
+ /* Restore message's original mime_msg: */
+ libbalsa_message_set_mime_message(message, mime_msg);
} else {
rc = libbalsa_message_copy(message, outbox, error);
}
@@ -711,7 +713,7 @@ lbs_process_queue_msg(guint msgno,
}
dsn_header = libbalsa_message_get_user_header(msg, "X-Balsa-DSN");
- msg->request_dsn = dsn_header != NULL ? atoi(dsn_header) != 0 : FALSE;
+ libbalsa_message_set_request_dsn(msg, dsn_header != NULL ? atoi(dsn_header) != 0 : FALSE);
new_message = msg_queue_item_new(send_message_info);
created = libbalsa_fill_msg_queue_item_from_queu(msg, new_message);
libbalsa_message_body_unref(msg);
@@ -719,18 +721,27 @@ lbs_process_queue_msg(guint msgno,
if (created != LIBBALSA_MESSAGE_CREATE_OK) {
msg_queue_item_destroy(new_message);
} else {
+ gboolean request_dsn;
+ LibBalsaMessageHeaders *headers;
+ InternetAddressList *from;
const InternetAddress* ia;
const gchar* mailbox;
libbalsa_message_change_flags(msg, LIBBALSA_MESSAGE_FLAG_FLAGGED, 0);
send_message_info->items = g_list_prepend(send_message_info->items, new_message);
new_message->smtp_msg = net_client_smtp_msg_new(send_message_data_cb, new_message);
- if (msg->request_dsn) {
- net_client_smtp_msg_set_dsn_opts(new_message->smtp_msg, msg->message_id, FALSE);
+ request_dsn = libbalsa_message_get_request_dsn(msg);
+ if (request_dsn) {
+ const gchar *message_id = libbalsa_message_get_message_id(msg);
+ net_client_smtp_msg_set_dsn_opts(new_message->smtp_msg,
+ message_id, FALSE);
}
/* Add the sender info */
- if (msg->headers->from && (ia = internet_address_list_get_address(msg->headers->from, 0))) {
+ headers = libbalsa_message_get_headers(msg);
+ from = headers->from;
+ if (from != NULL &&
+ (ia = internet_address_list_get_address(from, 0)) != NULL) {
while (ia != NULL && INTERNET_ADDRESS_IS_GROUP(ia)) {
ia = internet_address_list_get_address(INTERNET_ADDRESS_GROUP(
ia)->members, 0);
@@ -743,9 +754,9 @@ lbs_process_queue_msg(guint msgno,
net_client_smtp_msg_set_sender(new_message->smtp_msg, mailbox);
/* Now need to add the recipients to the message. */
- add_recipients(new_message->smtp_msg, msg->headers->to_list, msg->request_dsn);
- add_recipients(new_message->smtp_msg, msg->headers->cc_list, msg->request_dsn);
- add_recipients(new_message->smtp_msg, msg->headers->bcc_list, msg->request_dsn);
+ add_recipients(new_message->smtp_msg, headers->to_list, request_dsn);
+ add_recipients(new_message->smtp_msg, headers->cc_list, request_dsn);
+ add_recipients(new_message->smtp_msg, headers->bcc_list, request_dsn);
/* Estimate the size of the message. This need not be exact but it's better to err
* on the large side since some message headers may be altered during the transfer. */
@@ -930,8 +941,12 @@ static inline void
balsa_send_message_success(MessageQueueItem *mqi,
SendMessageInfo *info)
{
+ LibBalsaMailbox *mailbox;
+
+ mailbox = mqi->orig != NULL ? libbalsa_message_get_mailbox(mqi->orig) : NULL;
+
/* sending message successful */
- if ((mqi->orig != NULL) && (mqi->orig->mailbox != NULL)) {
+ if (mailbox != NULL) {
gboolean remove = TRUE;
const gchar *fccurl = libbalsa_message_get_user_header(mqi->orig, "X-Balsa-Fcc");
@@ -946,7 +961,7 @@ balsa_send_message_success(MessageQueueItem *mqi,
}
libbalsa_message_change_flags(mqi->orig, 0, LIBBALSA_MESSAGE_FLAG_NEW |
LIBBALSA_MESSAGE_FLAG_FLAGGED);
- libbalsa_mailbox_sync_storage(mqi->orig->mailbox, FALSE);
+ libbalsa_mailbox_sync_storage(mailbox, FALSE);
remove = libbalsa_message_copy(mqi->orig, fccbox, &err);
if (!remove) {
libbalsa_information(LIBBALSA_INFORMATION_ERROR,
@@ -967,8 +982,12 @@ static inline void
balsa_send_message_error(MessageQueueItem *mqi,
GError *error)
{
+ LibBalsaMailbox *mailbox;
+
+ mailbox = mqi->orig != NULL ? libbalsa_message_get_mailbox(mqi->orig) : NULL;
+
/* sending message failed */
- if ((mqi->orig != NULL) && (mqi->orig->mailbox != NULL)) {
+ if (mailbox != NULL) {
if (ERROR_IS_TRANSIENT(error)) {
/* Mark it as:
* - neither flagged nor deleted, so it can be resent later
@@ -1014,6 +1033,9 @@ balsa_send_message_real(SendMessageInfo *info)
for (this_msg = info->items; this_msg != NULL; this_msg = this_msg->next) {
MessageQueueItem *mqi = (MessageQueueItem *) this_msg->data;
gboolean send_res;
+ LibBalsaMailbox *mailbox;
+
+ mailbox = mqi->orig != NULL ? libbalsa_message_get_mailbox(mqi->orig) : NULL;
info->curr_msg++;
g_debug("%s: %u/%u mqi = %p", __func__, info->msg_count, info->curr_msg, mqi);
@@ -1021,13 +1043,11 @@ balsa_send_message_real(SendMessageInfo *info)
send_res = net_client_smtp_send_msg(info->session, mqi->smtp_msg, &error);
g_mutex_lock(&send_messages_lock);
- if ((mqi->orig != NULL) && (mqi->orig->mailbox != NULL)) {
+ if (mailbox != NULL) {
libbalsa_message_change_flags(mqi->orig, 0, LIBBALSA_MESSAGE_FLAG_FLAGGED);
} else {
- g_message("mqi: %p mqi->orig: %p mqi->orig->mailbox: %p\n",
- mqi,
- mqi ? mqi->orig : NULL,
- mqi && mqi->orig ? mqi->orig->mailbox : NULL);
+ g_message("mqi: %p mqi->orig: %p mailbox: %p\n",
+ mqi, mqi->orig, mailbox);
}
if (send_res) {
@@ -1051,8 +1071,12 @@ balsa_send_message_real(SendMessageInfo *info)
* without changing flags. */
for (this_msg = info->items; this_msg != NULL; this_msg = this_msg->next) {
MessageQueueItem *mqi = (MessageQueueItem *) this_msg->data;
+ LibBalsaMailbox *mailbox;
+
+ mailbox = mqi->orig != NULL ?
+ libbalsa_message_get_mailbox(mqi->orig) : NULL;
- if ((mqi->orig != NULL) && (mqi->orig->mailbox != NULL)) {
+ if (mailbox != NULL) {
libbalsa_message_change_flags(mqi->orig,
0,
LIBBALSA_MESSAGE_FLAG_FLAGGED |
@@ -1099,12 +1123,14 @@ balsa_send_message_real(SendMessageInfo *info)
static void
-message_add_references(const LibBalsaMessage *message,
+message_add_references(LibBalsaMessage *message,
GMimeMessage *msg)
{
+ GList *list;
+
/* If the message has references set, add them to the envelope */
- if (message->references != NULL) {
- GList *list = message->references;
+ list = libbalsa_message_get_references(message);
+ if (list != NULL) {
GString *str = g_string_new(NULL);
do {
@@ -1117,10 +1143,10 @@ message_add_references(const LibBalsaMessage *message,
g_string_free(str, TRUE);
}
- if (message->in_reply_to != NULL) {
+ list = libbalsa_message_get_in_reply_to(message);
+ if (list != NULL) {
/* There's no specific header function for In-Reply-To */
- g_mime_object_set_header(GMIME_OBJECT(msg), "In-Reply-To",
- message->in_reply_to->data);
+ g_mime_object_set_header(GMIME_OBJECT(msg), "In-Reply-To", list->data);
}
}
@@ -1194,20 +1220,25 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
GMimeObject *mime_root = NULL;
GMimeMessage *mime_message;
LibBalsaMessageBody *body;
+ LibBalsaMessageHeaders *headers;
InternetAddressList *ia_list;
gchar *tmp;
GList *list;
gboolean attach_pubkey = FALSE;
GtkWindow *parent = g_object_get_data(G_OBJECT(message), "parent-window");
+ LibBalsaIdentity *identity;
/* attach the public key only if we send the message, not if we just postpone it */
- if (!postponing && message->att_pubkey && ((message->gpg_mode & LIBBALSA_PROTECT_PROTOCOL) != 0)) {
+ if (!postponing &&
+ libbalsa_message_get_attach_pubkey(message) &&
+ ((libbalsa_message_get_gpg_mode(message) & LIBBALSA_PROTECT_PROTOCOL) != 0)) {
attach_pubkey = TRUE;
}
- body = message->body_list;
+ body = libbalsa_message_get_body_list(message);
if ((body != NULL) && ((body->next != NULL) || attach_pubkey)) {
- mime_root = GMIME_OBJECT(g_mime_multipart_new_with_subtype(message->subtype));
+ mime_root =
+ GMIME_OBJECT(g_mime_multipart_new_with_subtype(libbalsa_message_get_subtype(message)));
}
while (body != NULL) {
@@ -1346,14 +1377,16 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
}
g_strfreev(mime_type);
} else if (body->buffer != NULL) {
+ guint gpg_mode;
guint use_gpg_mode;
LibBalsaMsgCreateResult crypt_res = LIBBALSA_MESSAGE_CREATE_OK;
/* in '2440 mode, touch *only* the first body! */
- if (!postponing && (body == body->message->body_list) &&
- (message->gpg_mode > 0) &&
- ((message->gpg_mode & LIBBALSA_PROTECT_OPENPGP) != 0)) {
- use_gpg_mode = message->gpg_mode;
+ if (!postponing &&
+ (body == libbalsa_message_get_body_list(body->message)) &&
+ ((gpg_mode = libbalsa_message_get_gpg_mode(message)) > 0) &&
+ ((gpg_mode & LIBBALSA_PROTECT_OPENPGP) != 0)) {
+ use_gpg_mode = gpg_mode;
} else {
use_gpg_mode = 0;
}
@@ -1396,7 +1429,7 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
}
}
- if ((message->body_list != NULL) && !postponing) {
+ if ((libbalsa_message_get_body_list(message) != NULL) && !postponing) {
LibBalsaMsgCreateResult crypt_res =
do_multipart_crypto(message, &mime_root, parent, error);
if (crypt_res != LIBBALSA_MESSAGE_CREATE_OK) {
@@ -1406,7 +1439,7 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
mime_message = g_mime_message_new(TRUE);
if (mime_root != NULL) {
- GList *param = message->parameters;
+ GList *param = libbalsa_message_get_parameters(message);
while (param != NULL) {
gchar **vals = (gchar **)param->data;
@@ -1420,17 +1453,16 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
}
message_add_references(message, mime_message);
- if (message->headers->from != NULL) {
- tmp = internet_address_list_to_string(message->headers->from,
- TRUE);
+ headers = libbalsa_message_get_headers(message);
+ if (headers->from != NULL) {
+ tmp = internet_address_list_to_string(headers->from, TRUE);
if (tmp != NULL) {
g_mime_message_set_sender(mime_message, tmp);
g_free(tmp);
}
}
- if (message->headers->reply_to != NULL) {
- tmp = internet_address_list_to_string(message->headers->reply_to,
- TRUE);
+ if (headers->reply_to != NULL) {
+ tmp = internet_address_list_to_string(headers->reply_to, TRUE);
if (tmp != NULL) {
g_mime_message_set_reply_to(mime_message, tmp);
g_free(tmp);
@@ -1442,32 +1474,31 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
LIBBALSA_MESSAGE_GET_SUBJECT(message));
}
- g_mime_message_set_date(mime_message, message->headers->date,
- get_tz_offset(message->headers->date));
+ g_mime_message_set_date(mime_message, headers->date, get_tz_offset(headers->date));
- if ((ia_list = message->headers->to_list)) {
+ if ((ia_list = headers->to_list) != NULL) {
InternetAddressList *recipients =
g_mime_message_get_recipients(mime_message,
GMIME_RECIPIENT_TYPE_TO);
internet_address_list_append(recipients, ia_list);
}
- if ((ia_list = message->headers->cc_list)) {
+ if ((ia_list = headers->cc_list) != NULL) {
InternetAddressList *recipients =
g_mime_message_get_recipients(mime_message,
GMIME_RECIPIENT_TYPE_CC);
internet_address_list_append(recipients, ia_list);
}
- if ((ia_list = message->headers->bcc_list)) {
+ if ((ia_list = headers->bcc_list) != NULL) {
InternetAddressList *recipients =
g_mime_message_get_recipients(mime_message,
GMIME_RECIPIENT_TYPE_BCC);
internet_address_list_append(recipients, ia_list);
}
- if (message->headers->dispnotify_to != NULL) {
- tmp = internet_address_list_to_string(message->headers->dispnotify_to, TRUE);
+ if (headers->dispnotify_to != NULL) {
+ tmp = internet_address_list_to_string(headers->dispnotify_to, TRUE);
if (tmp != NULL) {
g_mime_object_append_header(GMIME_OBJECT(mime_message),
"Disposition-Notification-To", tmp);
@@ -1475,7 +1506,7 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
}
}
- for (list = message->headers->user_hdrs; list; list = list->next) {
+ for (list = headers->user_hdrs; list; list = list->next) {
gchar **pair = list->data;
g_strchug(pair[1]);
g_mime_object_append_header(GMIME_OBJECT(mime_message), pair[0], pair[1]);
@@ -1490,10 +1521,10 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
#ifdef ENABLE_AUTOCRYPT
/* add Autocrypt header if requested */
- if (!postponing && (message->ident != NULL) &&
- (libbalsa_identity_get_autocrypt_mode(message->ident) != AUTOCRYPT_DISABLE) &&
+ if (!postponing && ((identity = libbalsa_message_get_identity(message)) != NULL) &&
+ (libbalsa_identity_get_autocrypt_mode(identity) != AUTOCRYPT_DISABLE) &&
!autocrypt_ignore(g_mime_object_get_content_type(mime_root))) {
- tmp = autocrypt_header(message->ident, error);
+ tmp = autocrypt_header(identity, error);
if (tmp == NULL) {
g_object_unref(G_OBJECT(mime_message));
return LIBBALSA_MESSAGE_CREATE_ERROR;
@@ -1503,7 +1534,8 @@ libbalsa_message_create_mime_message(LibBalsaMessage *message,
}
#endif
- message->mime_msg = mime_message;
+ libbalsa_message_set_mime_message(message, mime_message);
+ g_object_unref(mime_message);
return LIBBALSA_MESSAGE_CREATE_OK;
}
@@ -1523,7 +1555,7 @@ libbalsa_message_postpone(LibBalsaMessage *message,
gboolean flow,
GError **error)
{
- if (!message->mime_msg
+ if (!libbalsa_message_get_mime_message(message)
&& (libbalsa_message_create_mime_message(message, flow,
TRUE, error) !=
LIBBALSA_MESSAGE_CREATE_OK)) {
@@ -1534,7 +1566,7 @@ libbalsa_message_postpone(LibBalsaMessage *message,
gint i;
for (i = 0; extra_headers[i] && extra_headers[i + 1]; i += 2) {
- g_mime_object_set_header(GMIME_OBJECT(message->mime_msg), extra_headers[i],
+ g_mime_object_set_header(GMIME_OBJECT(libbalsa_message_get_mime_message(message)),
extra_headers[i],
extra_headers[i + 1]);
}
}
@@ -1635,7 +1667,7 @@ libbalsa_create_msg(LibBalsaMessage *message,
gboolean flow,
GError **error)
{
- if (!message->mime_msg) {
+ if (libbalsa_message_get_mime_message(message) == NULL) {
LibBalsaMsgCreateResult res =
libbalsa_message_create_mime_message(message, flow,
FALSE, error);
@@ -1644,7 +1676,7 @@ libbalsa_create_msg(LibBalsaMessage *message,
}
}
- libbalsa_set_message_id(message->mime_msg);
+ libbalsa_set_message_id(libbalsa_message_get_mime_message(message));
return LIBBALSA_MESSAGE_CREATE_OK;
}
@@ -1658,11 +1690,13 @@ libbalsa_fill_msg_queue_item_from_queu(LibBalsaMessage *message,
LibBalsaMsgCreateResult result = LIBBALSA_MESSAGE_CREATE_ERROR;
mqi->orig = message;
- if (message->mime_msg != NULL) {
+ if (libbalsa_message_get_mime_message(message) != NULL) {
+ LibBalsaMailbox *mailbox = libbalsa_message_get_mailbox(message);
+
msg_stream = g_mime_stream_mem_new();
- libbalsa_mailbox_lock_store(message->mailbox);
- g_mime_object_write_to_stream(GMIME_OBJECT(message->mime_msg), msg_stream);
- libbalsa_mailbox_unlock_store(message->mailbox);
+ libbalsa_mailbox_lock_store(mailbox);
+ g_mime_object_write_to_stream(GMIME_OBJECT(libbalsa_message_get_mime_message(message)), msg_stream);
+ libbalsa_mailbox_unlock_store(mailbox);
g_mime_stream_reset(msg_stream);
} else {
msg_stream = libbalsa_message_stream(message);
@@ -1711,18 +1745,17 @@ lb_send_from(LibBalsaMessage * message, gpgme_protocol_t protocol)
if ((protocol == GPGME_PROTOCOL_OpenPGP) &&
((key_id =
- libbalsa_identity_get_force_gpg_key_id(message->ident)) != NULL)
+ libbalsa_identity_get_force_gpg_key_id(libbalsa_message_get_identity(message))) != NULL)
&& (key_id[0] != '\0')) {
from_id = key_id;
} else if ((protocol == GPGME_PROTOCOL_CMS) &&
((key_id =
- libbalsa_identity_get_force_smime_key_id(message->
- ident)) != NULL)
+ libbalsa_identity_get_force_smime_key_id(libbalsa_message_get_identity(message))) != NULL)
&& (key_id[0] != '\0')) {
from_id = key_id;
} else {
InternetAddress *ia =
- internet_address_list_get_address(message->headers->from, 0);
+ internet_address_list_get_address(libbalsa_message_get_headers(message)->from, 0);
while (INTERNET_ADDRESS_IS_GROUP(ia)) {
ia = internet_address_list_get_address(((InternetAddressGroup
@@ -1779,7 +1812,7 @@ libbalsa_create_rfc2440_buffer(LibBalsaMessage *message,
GtkWindow *parent,
GError **error)
{
- gint mode = message->gpg_mode;
+ gint mode = libbalsa_message_get_gpg_mode(message);
gboolean always_trust = (mode & LIBBALSA_PROTECT_ALWAYS_TRUST) != 0;
switch (mode & LIBBALSA_PROTECT_MODE) {
@@ -1795,6 +1828,7 @@ libbalsa_create_rfc2440_buffer(LibBalsaMessage *message,
case LIBBALSA_PROTECT_ENCRYPT:
case LIBBALSA_PROTECT_SIGN | LIBBALSA_PROTECT_ENCRYPT:
{
+ LibBalsaMessageHeaders *headers = libbalsa_message_get_headers(message);
GList *encrypt_for = NULL;
gboolean result;
@@ -1802,13 +1836,13 @@ libbalsa_create_rfc2440_buffer(LibBalsaMessage *message,
and the from: address. Note: don't add bcc: addresses
as they would be visible in the encrypted block. */
encrypt_for = get_mailbox_names(encrypt_for,
- message->headers->to_list);
+ headers->to_list);
encrypt_for = get_mailbox_names(encrypt_for,
- message->headers->cc_list);
+ headers->cc_list);
encrypt_for = get_mailbox_names(encrypt_for,
- message->headers->from);
- if ((message->headers->bcc_list != NULL) &&
- (internet_address_list_length(message->headers->bcc_list) > 0)) {
+ headers->from);
+ if ((headers->bcc_list != NULL) &&
+ (internet_address_list_length(headers->bcc_list) > 0)) {
libbalsa_information
(LIBBALSA_INFORMATION_WARNING,
ngettext("This message will not be encrypted "
@@ -1816,7 +1850,7 @@ libbalsa_create_rfc2440_buffer(LibBalsaMessage *message,
"This message will not be encrypted "
"for the BCC: recipients.",
internet_address_list_length
- (message->headers->bcc_list)));
+ (headers->bcc_list)));
}
if (mode & LIBBALSA_PROTECT_SIGN) {
@@ -1856,27 +1890,30 @@ do_multipart_crypto(LibBalsaMessage *message,
GtkWindow *parent,
GError **error)
{
+ guint mode;
gpgme_protocol_t protocol;
gboolean always_trust;
+ mode = libbalsa_message_get_gpg_mode(message);
+
/* check if we shall do any protection */
- if (!(message->gpg_mode & LIBBALSA_PROTECT_MODE)) {
+ if ((mode & LIBBALSA_PROTECT_MODE) == 0) {
return LIBBALSA_MESSAGE_CREATE_OK;
}
/* check which protocol should be used */
- if (message->gpg_mode & LIBBALSA_PROTECT_RFC3156) {
+ if (mode & LIBBALSA_PROTECT_RFC3156) {
protocol = GPGME_PROTOCOL_OpenPGP;
- } else if (message->gpg_mode & LIBBALSA_PROTECT_SMIMEV3) {
+ } else if (mode & LIBBALSA_PROTECT_SMIMEV3) {
protocol = GPGME_PROTOCOL_CMS;
- } else if (message->gpg_mode & LIBBALSA_PROTECT_OPENPGP) {
+ } else if (mode & LIBBALSA_PROTECT_OPENPGP) {
return LIBBALSA_MESSAGE_CREATE_OK; /* already done... */
} else {
return LIBBALSA_MESSAGE_ENCRYPT_ERROR; /* hmmm.... */
}
- always_trust = (message->gpg_mode & LIBBALSA_PROTECT_ALWAYS_TRUST) != 0;
+ always_trust = (mode & LIBBALSA_PROTECT_ALWAYS_TRUST) != 0;
/* sign and/or encrypt */
- switch (message->gpg_mode & LIBBALSA_PROTECT_MODE) {
+ switch (mode & LIBBALSA_PROTECT_MODE) {
case LIBBALSA_PROTECT_SIGN: /* sign message */
if (!libbalsa_sign_mime_object(mime_root,
lb_send_from(message, protocol),
@@ -1888,6 +1925,7 @@ do_multipart_crypto(LibBalsaMessage *message,
case LIBBALSA_PROTECT_ENCRYPT:
case LIBBALSA_PROTECT_ENCRYPT | LIBBALSA_PROTECT_SIGN:
{
+ LibBalsaMessageHeaders *headers = libbalsa_message_get_headers(message);
GList *encrypt_for = NULL;
gboolean success;
@@ -1895,13 +1933,13 @@ do_multipart_crypto(LibBalsaMessage *message,
and the from: address. Note: don't add bcc: addresses
as they would be visible in the encrypted block. */
encrypt_for = get_mailbox_names(encrypt_for,
- message->headers->to_list);
+ headers->to_list);
encrypt_for = get_mailbox_names(encrypt_for,
- message->headers->cc_list);
+ headers->cc_list);
encrypt_for = g_list_append(encrypt_for,
g_strdup(lb_send_from(message, protocol)));
- if (message->headers->bcc_list
- && (internet_address_list_length(message->headers->
+ if (headers->bcc_list
+ && (internet_address_list_length(headers->
bcc_list) > 0)) {
libbalsa_information
(LIBBALSA_INFORMATION_WARNING,
@@ -1910,10 +1948,10 @@ do_multipart_crypto(LibBalsaMessage *message,
"This message will not be encrypted "
"for the BCC: recipients.",
internet_address_list_length
- (message->headers->bcc_list)));
+ (headers->bcc_list)));
}
- if (message->gpg_mode & LIBBALSA_PROTECT_SIGN) {
+ if ((libbalsa_message_get_gpg_mode(message) & LIBBALSA_PROTECT_SIGN) != 0) {
success =
libbalsa_sign_encrypt_mime_object(mime_root,
lb_send_from(message, protocol),
@@ -1935,8 +1973,7 @@ do_multipart_crypto(LibBalsaMessage *message,
}
default:
- g_error("illegal gpg_mode %d (" __FILE__ " line %d)",
- message->gpg_mode, __LINE__);
+ g_error("illegal gpg_mode %d (" __FILE__ " line %d)", mode, __LINE__);
}
return LIBBALSA_MESSAGE_CREATE_OK;
diff --git a/libbalsa/source-viewer.c b/libbalsa/source-viewer.c
index bec50f9c8..f0aa3a179 100644
--- a/libbalsa/source-viewer.c
+++ b/libbalsa/source-viewer.c
@@ -118,24 +118,28 @@ lsv_escape_change_state(GSimpleAction * action,
LibBalsaSourceViewerInfo *lsvi =
g_object_get_data(G_OBJECT(user_data), "lsvi");
LibBalsaMessage *msg = lsvi->msg;
+ LibBalsaMailbox *mailbox;
GMimeStream *msg_stream;
GMimeStream *mem_stream;
char *raw_message;
- if (!msg->mailbox) {
+ mailbox = libbalsa_message_get_mailbox(msg);
+ if (mailbox == NULL) {
libbalsa_information(LIBBALSA_INFORMATION_WARNING,
_("Mailbox closed"));
return;
}
- msg_stream = libbalsa_mailbox_get_message_stream(msg->mailbox, msg->msgno,
- TRUE);
+ msg_stream =
+ libbalsa_mailbox_get_message_stream(mailbox,
+ libbalsa_message_get_msgno(msg),
+ TRUE);
if (msg_stream == NULL)
return;
mem_stream = g_mime_stream_mem_new();
- libbalsa_mailbox_lock_store(msg->mailbox);
+ libbalsa_mailbox_lock_store(mailbox);
g_mime_stream_write_to_stream(msg_stream, mem_stream);
- libbalsa_mailbox_unlock_store(msg->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
g_mime_stream_write(mem_stream, "", 1); /* close string */
raw_message = (char *) GMIME_STREAM_MEM(mem_stream)->buffer->data;
@@ -186,8 +190,8 @@ libbalsa_show_message_source(GtkApplication * application,
LibBalsaSourceViewerInfo *lsvi;
GAction *escape_action;
- g_return_if_fail(msg);
- g_return_if_fail(MAILBOX_OPEN(msg->mailbox));
+ g_return_if_fail(msg != NULL);
+ g_return_if_fail(MAILBOX_OPEN(libbalsa_message_get_mailbox(msg)));
text = gtk_text_view_new();
diff --git a/src/balsa-message.c b/src/balsa-message.c
index de456b3b5..323bed37b 100644
--- a/src/balsa-message.c
+++ b/src/balsa-message.c
@@ -1145,6 +1145,7 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
BalsaPartInfo *info;
gboolean has_focus;
LibBalsaMessage *message;
+ LibBalsaMsgProtectState prot_state;
g_return_val_if_fail(bm != NULL, FALSE);
has_focus = bm->focus_state != BALSA_MESSAGE_FOCUS_STATE_NO;
@@ -1186,7 +1187,8 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
balsa_information(LIBBALSA_INFORMATION_WARNING,
_("Could not access message %u "
"in mailbox “%s”."),
- (unsigned int) message->msgno, libbalsa_mailbox_get_name(mailbox));
+ (guint) libbalsa_message_get_msgno(message),
+ libbalsa_mailbox_get_name(mailbox));
return FALSE;
}
@@ -1194,16 +1196,17 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
libbalsa_mailbox_get_crypto_mode(mailbox),
FALSE, 1);
/* calculate the signature summary state if not set earlier */
- if(message->prot_state == LIBBALSA_MSG_PROTECT_NONE) {
- LibBalsaMsgProtectState prot_state =
- balsa_message_scan_signatures(message->body_list, message);
+ prot_state = libbalsa_message_get_protect_state(message);
+ if (prot_state == LIBBALSA_MSG_PROTECT_NONE) {
+ LibBalsaMsgProtectState new_prot_state =
+ balsa_message_scan_signatures(libbalsa_message_get_body_list(message), message);
/* update the icon if necessary */
- if (message->prot_state != prot_state)
- message->prot_state = prot_state;
+ if (prot_state != new_prot_state)
+ libbalsa_message_set_protect_state(message, new_prot_state);
}
/* may update the icon */
- libbalsa_mailbox_msgno_update_attach(mailbox, message->msgno, message);
+ libbalsa_mailbox_msgno_update_attach(mailbox, libbalsa_message_get_msgno(message), message);
display_headers(bm);
display_content(bm);
@@ -1221,7 +1224,7 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
* present.
*
*/
- if (is_new && message->headers->dispnotify_to) {
+ if (is_new && (libbalsa_message_get_headers(message)->dispnotify_to != NULL)) {
handle_mdn_request (balsa_get_parent_window(GTK_WIDGET(bm)), message);
}
@@ -1253,8 +1256,9 @@ balsa_message_set(BalsaMessage * bm, LibBalsaMailbox * mailbox, guint msgno)
* emit read message
*/
if (is_new && !libbalsa_mailbox_get_readonly(mailbox))
- libbalsa_mailbox_msgno_change_flags(mailbox, message->msgno, 0,
- LIBBALSA_MESSAGE_FLAG_NEW);
+ libbalsa_mailbox_msgno_change_flags(mailbox,
+ libbalsa_message_get_msgno(message),
+ 0, LIBBALSA_MESSAGE_FLAG_NEW);
/* restore keyboard focus to the content, if it was there before */
if (has_focus)
@@ -1304,10 +1308,11 @@ balsa_message_set_displayed_headers(BalsaMessage * bmessage,
bmessage->shown_headers = sh;
- if (bmessage->message) {
- if(sh == HEADERS_ALL)
- libbalsa_mailbox_set_msg_headers(bmessage->message->mailbox,
+ if (bmessage->message != NULL) {
+ if (sh == HEADERS_ALL) {
+ libbalsa_mailbox_set_msg_headers(libbalsa_message_get_mailbox(bmessage->message),
bmessage->message);
+ }
display_headers(bmessage);
gtk_tree_model_foreach
(gtk_tree_view_get_model(GTK_TREE_VIEW(bmessage->treeview)),
@@ -1331,9 +1336,11 @@ balsa_message_set_wrap(BalsaMessage * bm, gboolean wrap)
bm->wrap_text = wrap;
/* This is easier than reformating all the widgets... */
- if (bm->message) {
+ if (bm->message != NULL) {
LibBalsaMessage *msg = bm->message;
- balsa_message_set(bm, msg->mailbox, msg->msgno);
+ balsa_message_set(bm,
+ libbalsa_message_get_mailbox(msg),
+ libbalsa_message_get_msgno(msg));
}
}
@@ -1342,8 +1349,8 @@ static void
display_headers(BalsaMessage * bm)
{
balsa_mime_widget_message_set_headers_d(bm, bm->bm_widget,
- bm->message->headers,
- bm->message->body_list,
+ libbalsa_message_get_headers(bm->message),
+ libbalsa_message_get_body_list(bm->message),
LIBBALSA_MESSAGE_GET_SUBJECT(bm->message));
}
@@ -1629,7 +1636,7 @@ display_content(BalsaMessage * bm)
g_object_unref(bm->parts_popup);
bm->parts_popup = gtk_menu_new();
g_object_ref_sink(bm->parts_popup);
- display_parts(bm, bm->message->body_list, NULL, NULL);
+ display_parts(bm, libbalsa_message_get_body_list(bm->message), NULL, NULL);
if (bm->info_count > 1) {
gtk_widget_show_all(bm->parts_popup);
gtk_widget_show_all
@@ -2406,8 +2413,9 @@ bm_get_mailbox(InternetAddressList * list)
static void
handle_mdn_request(GtkWindow *parent, LibBalsaMessage *message)
{
+ LibBalsaMessageHeaders *headers;
gboolean suspicious;
- InternetAddressList *use_from;
+ InternetAddressList *use_from = NULL;
InternetAddressList *list;
InternetAddress *from, *dn;
BalsaMDNReply action;
@@ -2415,24 +2423,34 @@ handle_mdn_request(GtkWindow *parent, LibBalsaMessage *message)
LibBalsaIdentity *mdn_ident = NULL;
gint i, len;
+ headers = libbalsa_message_get_headers(message);
+
/* Check if the dispnotify_to address is equal to the (in this order,
if present) reply_to, from or sender address. */
- if (message->headers->reply_to)
- use_from = message->headers->reply_to;
- else if (message->headers->from)
- use_from = message->headers->from;
- else if (message->sender)
- use_from = message->sender;
- else
- use_from = NULL;
+ if (headers != NULL) {
+ if (headers->reply_to != NULL) {
+ use_from = headers->reply_to;
+ } else if (headers->from != NULL) {
+ use_from = headers->from;
+ }
+ }
+ if (use_from == NULL) {
+ InternetAddressList *sender;
+
+ sender = libbalsa_message_get_sender(message);
+ if (sender != NULL)
+ use_from = sender;
+ else
+ use_from = NULL;
+ }
/* note: neither Disposition-Notification-To: nor Reply-To:, From: or
Sender: may be address groups */
from = use_from ? internet_address_list_get_address (use_from, 0) : NULL;
- dn = internet_address_list_get_address (message->headers->dispnotify_to, 0);
+ dn = internet_address_list_get_address (headers->dispnotify_to, 0);
suspicious = !libbalsa_ia_rfc2821_equal(dn, from);
/* Try to find "my" identity first in the to, then in the cc list */
- list = message->headers->to_list;
+ list = headers->to_list;
len = list ? internet_address_list_length(list) : 0;
for (i = 0; i < len && !mdn_ident; i++) {
GList * id_list;
@@ -2448,7 +2466,7 @@ handle_mdn_request(GtkWindow *parent, LibBalsaMessage *message)
}
}
- list = message->headers->cc_list;
+ list = headers->cc_list;
for (i = 0; i < len && !mdn_ident; i++) {
GList * id_list;
@@ -2487,7 +2505,7 @@ handle_mdn_request(GtkWindow *parent, LibBalsaMessage *message)
gchar *reply_to;
sender = from ? internet_address_to_string (from, FALSE) : NULL;
reply_to =
- internet_address_list_to_string (message->headers->dispnotify_to,
+ internet_address_list_to_string (headers->dispnotify_to,
FALSE);
gtk_widget_show_all (create_mdn_dialog (parent, sender, reply_to, mdn,
mdn_ident));
@@ -2517,6 +2535,8 @@ static LibBalsaMessage *create_mdn_reply (const LibBalsaIdentity *mdn_ident,
gboolean manual)
{
LibBalsaMessage *message;
+ LibBalsaMessageHeaders *headers;
+ LibBalsaMessageHeaders *for_msg_headers;
LibBalsaMessageBody *body;
gchar *date, *dummy;
GString *report;
@@ -2526,27 +2546,28 @@ static LibBalsaMessage *create_mdn_reply (const LibBalsaIdentity *mdn_ident,
/* create a message with the header set from the incoming message */
message = libbalsa_message_new();
- message->headers->from = internet_address_list_new();
- internet_address_list_add(message->headers->from,
+ headers = libbalsa_message_get_headers(message);
+ headers->from = internet_address_list_new();
+ internet_address_list_add(headers->from,
libbalsa_identity_get_address(balsa_app.current_ident));
- message->headers->date = time(NULL);
+ headers->date = time(NULL);
libbalsa_message_set_subject(message, "Message Disposition Notification");
- message->headers->to_list = internet_address_list_new ();
- internet_address_list_append(message->headers->to_list,
- for_msg->headers->dispnotify_to);
+ headers->to_list = internet_address_list_new ();
+ for_msg_headers = libbalsa_message_get_headers(for_msg);
+ internet_address_list_append(headers->to_list, for_msg_headers->dispnotify_to);
/* RFC 2298 requests this mime type... */
- message->subtype = g_strdup("report");
+ libbalsa_message_set_subtype(message, "report");
params = g_new(gchar *, 3);
params[0] = g_strdup("report-type");
params[1] = g_strdup("disposition-notification");
params[2] = NULL;
- message->parameters = g_list_prepend(message->parameters, params);
+ libbalsa_message_add_parameters(message, params);
/* the first part of the body is an informational note */
body = libbalsa_message_body_new(message);
date = libbalsa_message_date_to_utf8(for_msg, balsa_app.date_string);
- dummy = internet_address_list_to_string(for_msg->headers->to_list, FALSE);
+ dummy = internet_address_list_to_string(for_msg_headers->to_list, FALSE);
body->buffer = g_strdup_printf(
"The message sent on %s to %s with subject “%s” has been displayed.\n"
"There is no guarantee that the message has been read or understood.\n\n",
@@ -2576,18 +2597,18 @@ static LibBalsaMessage *create_mdn_reply (const LibBalsaIdentity *mdn_ident,
INTERNET_ADDRESS_MAILBOX
(libbalsa_identity_get_address
(balsa_app.current_ident))->addr);
- if (for_msg->message_id)
+ if (libbalsa_message_get_message_id(for_msg) != NULL)
g_string_append_printf(report, "Original-Message-ID: <%s>\n",
- for_msg->message_id);
+ libbalsa_message_get_message_id(for_msg));
g_string_append_printf(report,
"Disposition: %s-action/MDN-sent-%sly; displayed",
manual ? "manual" : "automatic",
manual ? "manual" : "automatical");
- body->buffer = report->str;
- g_string_free(report, FALSE);
+ body->buffer = g_string_free(report, FALSE);
body->content_type = g_strdup("message/disposition-notification");
body->charset = g_strdup ("US-ASCII");
libbalsa_message_append_part(message, body);
+
return message;
}
@@ -2706,7 +2727,7 @@ balsa_message_scan_signatures(LibBalsaMessageBody *body,
{
LibBalsaMsgProtectState result = LIBBALSA_MSG_PROTECT_NONE;
- g_return_val_if_fail(message->headers != NULL, result);
+ g_return_val_if_fail(libbalsa_message_get_headers(message) != NULL, result);
while (body) {
LibBalsaMsgProtectState this_part_state =
@@ -2818,7 +2839,7 @@ libbalsa_msg_try_decrypt(LibBalsaMessage * message, LibBalsaMessageBody * body,
* adds an extra ref) leads to a crash if we have both the encrypted and
* the unencrypted version open as the body chain of the first one will be
* unref'd. */
- if (message->body_ref > chk_crypto->max_ref) {
+ if (libbalsa_message_get_body_ref(message) > chk_crypto->max_ref) {
if (chk_crypto->chk_mode == LB_MAILBOX_CHK_CRYPT_ALWAYS) {
libbalsa_information
(LIBBALSA_INFORMATION_ERROR,
@@ -3034,6 +3055,7 @@ static void
libbalsa_msg_part_2440(LibBalsaMessage * message, LibBalsaMessageBody * body,
chk_crypto_t * chk_crypto)
{
+ LibBalsaMailbox *mailbox;
gpgme_error_t sig_res;
GMimePartRfc2440Mode rfc2440mode;
@@ -3064,9 +3086,11 @@ libbalsa_msg_part_2440(LibBalsaMessage * message, LibBalsaMessageBody * body,
/* check if this is a RFC2440 part */
if (!GMIME_IS_PART(body->mime_part))
return;
- libbalsa_mailbox_lock_store(body->message->mailbox);
+
+ mailbox = libbalsa_message_get_mailbox(body->message);
+ libbalsa_mailbox_lock_store(mailbox);
rfc2440mode = g_mime_part_check_rfc2440(GMIME_PART(body->mime_part));
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
/* if not, or if we have more than one instance of this message open, eject
(see remark for libbalsa_msg_try_decrypt above) - remember that
@@ -3074,7 +3098,7 @@ libbalsa_msg_part_2440(LibBalsaMessage * message, LibBalsaMessageBody * body,
(i.e. RFC2440 stuff removed) one! */
if (rfc2440mode == GMIME_PART_RFC2440_NONE)
return;
- if (message->body_ref > chk_crypto->max_ref) {
+ if (libbalsa_message_get_body_ref(message) > chk_crypto->max_ref) {
if (chk_crypto->chk_mode == LB_MAILBOX_CHK_CRYPT_ALWAYS) {
libbalsa_information
(LIBBALSA_INFORMATION_ERROR, "%s\n%s",
@@ -3093,7 +3117,7 @@ libbalsa_msg_part_2440(LibBalsaMessage * message, LibBalsaMessageBody * body,
}
/* do the rfc2440 stuff */
- libbalsa_mailbox_lock_store(body->message->mailbox);
+ libbalsa_mailbox_lock_store(mailbox);
if (rfc2440mode == GMIME_PART_RFC2440_SIGNED)
sig_res =
libbalsa_rfc2440_verify(GMIME_PART(body->mime_part),
@@ -3111,7 +3135,7 @@ libbalsa_msg_part_2440(LibBalsaMessage * message, LibBalsaMessageBody * body,
body->charset = NULL;
}
}
- libbalsa_mailbox_unlock_store(body->message->mailbox);
+ libbalsa_mailbox_unlock_store(mailbox);
if (body->sig_info && sig_res == GPG_ERR_NO_ERROR) {
if ((g_mime_gpgme_sigstat_summary(body->sig_info) & GPGME_SIGSUM_VALID) == GPGME_SIGSUM_VALID) {
@@ -3196,9 +3220,11 @@ balsa_message_perform_crypto(LibBalsaMessage * message,
LibBalsaChkCryptoMode chk_mode,
gboolean no_mp_signed, guint max_ref)
{
+ LibBalsaMessageBody *body_list;
chk_crypto_t chk_crypto;
- if (!message->body_list)
+ body_list = libbalsa_message_get_body_list(message);
+ if (body_list == NULL)
return;
/* check if the user requested to ignore any crypto stuff */
@@ -3209,15 +3235,15 @@ balsa_message_perform_crypto(LibBalsaMessage * message,
chk_crypto.chk_mode = chk_mode;
chk_crypto.no_mp_signed = no_mp_signed;
chk_crypto.max_ref = max_ref;
- chk_crypto.sender = balsa_message_sender_to_gchar(message->headers->from, -1);
+ chk_crypto.sender =
+ balsa_message_sender_to_gchar(libbalsa_message_get_headers(message)->from, -1);
chk_crypto.subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(message));
libbalsa_utf8_sanitize(&chk_crypto.subject, balsa_app.convert_unknown_8bit,
NULL);
/* do the real work */
- message->body_list =
- libbalsa_msg_perform_crypto_real(message, message->body_list,
- &chk_crypto);
+ body_list = libbalsa_msg_perform_crypto_real(message, body_list, &chk_crypto);
+ libbalsa_message_set_body_list(message, body_list);
/* clean up */
g_free(chk_crypto.subject);
@@ -3234,6 +3260,7 @@ balsa_message_perform_crypto(LibBalsaMessage * message,
static void
message_recheck_crypto_cb(GtkWidget * button, BalsaMessage * bm)
{
+ LibBalsaMessageBody *body_list;
LibBalsaMsgProtectState prot_state;
LibBalsaMessage * message;
GtkTreeIter iter;
@@ -3258,16 +3285,16 @@ message_recheck_crypto_cb(GtkWidget * button, BalsaMessage * bm)
balsa_message_perform_crypto(message, LB_MAILBOX_CHK_CRYPT_ALWAYS, FALSE, 2);
/* calculate the signature summary state */
- prot_state =
- balsa_message_scan_signatures(message->body_list, message);
+ body_list = libbalsa_message_get_body_list(message);
+ prot_state = balsa_message_scan_signatures(body_list, message);
/* update the icon if necessary */
- if (message->prot_state != prot_state)
- message->prot_state = prot_state;
+ libbalsa_message_set_protect_state(message, prot_state);
/* may update the icon */
- libbalsa_mailbox_msgno_update_attach(bm->message->mailbox,
- bm->message->msgno, bm->message);
+ libbalsa_mailbox_msgno_update_attach(libbalsa_message_get_mailbox(bm->message),
+ libbalsa_message_get_msgno(bm->message),
+ bm->message);
display_headers(bm);
display_content(bm);
diff --git a/src/balsa-mime-widget-message.c b/src/balsa-mime-widget-message.c
index 2fb251c10..f85d2a261 100644
--- a/src/balsa-mime-widget-message.c
+++ b/src/balsa-mime-widget-message.c
@@ -327,6 +327,7 @@ static void
extbody_send_mail(GtkWidget * button, LibBalsaMessageBody * mime_body)
{
LibBalsaMessage *message;
+ LibBalsaMessageHeaders *headers;
LibBalsaMessageBody *body;
gchar *data;
GError *err = NULL;
@@ -334,8 +335,9 @@ extbody_send_mail(GtkWidget * button, LibBalsaMessageBody * mime_body)
/* create a message */
message = libbalsa_message_new();
- message->headers->from = internet_address_list_new();
- internet_address_list_add(message->headers->from,
+ headers = libbalsa_message_get_headers(message);
+ headers->from = internet_address_list_new();
+ internet_address_list_add(headers->from,
libbalsa_identity_get_address(balsa_app.current_ident));
data = libbalsa_message_body_get_parameter(mime_body, "subject");
@@ -345,7 +347,7 @@ extbody_send_mail(GtkWidget * button, LibBalsaMessageBody * mime_body)
}
data = libbalsa_message_body_get_parameter(mime_body, "server");
- message->headers->to_list = internet_address_list_parse_string(data);
+ headers->to_list = internet_address_list_parse_string(data);
g_free(data);
/* the original body my have some data to be returned as commands... */
diff --git a/src/balsa-mime-widget-text.c b/src/balsa-mime-widget-text.c
index fd2f6251d..14ecd1be1 100644
--- a/src/balsa-mime-widget-text.c
+++ b/src/balsa-mime-widget-text.c
@@ -1264,7 +1264,7 @@ check_text_encoding(BalsaMessage * bm, gchar *text_buf)
&& !g_object_get_data(G_OBJECT(bm->message),
BALSA_MIME_WIDGET_NEW_TEXT_NOTIFIED)) {
gchar *from =
- balsa_message_sender_to_gchar(bm->message->headers->from, 0);
+ balsa_message_sender_to_gchar(libbalsa_message_get_headers(bm->message)->from, 0);
gchar *subject =
g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(bm->message));
diff --git a/src/balsa-mime-widget-vcalendar.c b/src/balsa-mime-widget-vcalendar.c
index 0ee021fe7..01b8c2036 100644
--- a/src/balsa-mime-widget-vcalendar.c
+++ b/src/balsa-mime-widget-vcalendar.c
@@ -73,18 +73,24 @@ balsa_mime_widget_new_vcalendar(BalsaMessage * bm,
/* a reply may be created only for unread requests */
if ((libbalsa_vcal_method(vcal_obj) == ITIP_REQUEST) &&
LIBBALSA_MESSAGE_IS_UNREAD(lbm)) {
+ LibBalsaMessageHeaders *headers;
+
may_reply = TRUE;
- if (lbm->headers) {
- if (lbm->headers->reply_to)
- sender =
- internet_address_list_get_address(lbm->headers->
- reply_to, 0);
- else if (lbm->headers && lbm->headers->from)
- sender =
- internet_address_list_get_address(lbm->headers->from,
- 0);
- } else if (lbm->sender)
- sender = internet_address_list_get_address(lbm->sender, 0);
+ headers = libbalsa_message_get_headers(lbm);
+ if (headers != NULL) {
+ if (headers->reply_to != NULL)
+ sender = internet_address_list_get_address(headers->reply_to, 0);
+ else if (headers->from != NULL)
+ sender = internet_address_list_get_address(headers->from, 0);
+ }
+ if (sender == NULL) {
+ InternetAddressList *ia_list;
+
+ ia_list = libbalsa_message_get_sender(lbm);
+
+ if (ia_list != NULL)
+ sender = internet_address_list_get_address(ia_list, 0);
+ }
}
/* add events */
@@ -277,6 +283,7 @@ vevent_reply(GObject * button, GtkWidget * box)
GPOINTER_TO_INT(g_object_get_data(button, "mode"));
gchar *rcpt;
LibBalsaMessage *message;
+ LibBalsaMessageHeaders *headers;
LibBalsaMessageBody *body;
const gchar *summary;
gchar *dummy;
@@ -298,10 +305,11 @@ vevent_reply(GObject * button, GtkWidget * box)
/* create a message with the header set from the incoming message */
message = libbalsa_message_new();
- message->headers->from = internet_address_list_new();
- internet_address_list_add(message->headers->from, ia);
- message->headers->to_list = internet_address_list_parse_string(rcpt);
- message->headers->date = time(NULL);
+ headers = libbalsa_message_get_headers(message);
+ headers->from = internet_address_list_new();
+ internet_address_list_add(headers->from, ia);
+ headers->to_list = internet_address_list_parse_string(rcpt);
+ headers->date = time(NULL);
/* create the message subject */
summary = libbalsa_vevent_summary(event);
@@ -326,7 +334,7 @@ vevent_reply(GObject * button, GtkWidget * box)
params[0] = g_strdup("method");
params[1] = g_strdup("reply");
params[2] = NULL;
- message->parameters = g_list_prepend(message->parameters, params);
+ libbalsa_message_add_parameters(message, params);
result = libbalsa_message_send(message, balsa_app.outbox, NULL,
balsa_find_sentbox_by_url,
diff --git a/src/balsa-mime-widget.c b/src/balsa-mime-widget.c
index 1f5c360e0..982b00bef 100644
--- a/src/balsa-mime-widget.c
+++ b/src/balsa-mime-widget.c
@@ -225,7 +225,7 @@ balsa_mime_widget_new_unknown(BalsaMessage * bm,
/* on local mailboxes only, to avoid possibly long downloads */
if ((content_type == NULL ||
g_ascii_strcasecmp(content_type, "application/octet-stream") == 0)
- && LIBBALSA_IS_MAILBOX_LOCAL(mime_body->message->mailbox)) {
+ && LIBBALSA_IS_MAILBOX_LOCAL(libbalsa_message_get_mailbox(mime_body->message))) {
GError *err = NULL;
GMimeStream *stream =
libbalsa_message_body_get_stream(mime_body, &err);
diff --git a/src/balsa-print-object-header.c b/src/balsa-print-object-header.c
index 39921fc5b..b255fe27d 100644
--- a/src/balsa-print-object-header.c
+++ b/src/balsa-print-object-header.c
@@ -299,9 +299,9 @@ balsa_print_object_header_from_message(GList *list,
BalsaPrintSetup * psetup)
{
return balsa_print_object_header_new_real(list, context,
- message->body_list,
- message->headers, subject,
- psetup, FALSE);
+ libbalsa_message_get_body_list(message),
+ libbalsa_message_get_headers(message),
+ subject, psetup, FALSE);
}
diff --git a/src/main-window.c b/src/main-window.c
index 36ff76e27..1d295b74f 100644
--- a/src/main-window.c
+++ b/src/main-window.c
@@ -4179,6 +4179,7 @@ bw_index_changed_cb(GtkWidget * widget, gpointer data)
{
BalsaWindow *window = data;
BalsaIndex *index;
+ LibBalsaMessage *message;
guint current_msgno;
if (widget != window->current_index)
@@ -4188,8 +4189,8 @@ bw_index_changed_cb(GtkWidget * widget, gpointer data)
bw_enable_message_menus(window, index->current_msgno);
bw_enable_mailbox_menus(window, index);
- current_msgno = BALSA_MESSAGE(window->preview)->message ?
- BALSA_MESSAGE(window->preview)->message->msgno : 0;
+ message = BALSA_MESSAGE(window->preview)->message;
+ current_msgno = message != NULL ? libbalsa_message_get_msgno(message) : 0;
if (current_msgno != index->current_msgno)
bw_idle_replace(window, index);
diff --git a/src/message-window.c b/src/message-window.c
index aec53beac..c89b8d1a0 100644
--- a/src/message-window.c
+++ b/src/message-window.c
@@ -116,7 +116,9 @@ message_window_idle_handler(MessageWindow * mw)
mw->idle_handler_id = 0;
msg = BALSA_MESSAGE(mw->bmessage);
- if (!balsa_message_set(msg, mw->message->mailbox, mw->message->msgno)) {
+ if (!balsa_message_set(msg,
+ libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message))) {
gtk_widget_destroy(mw->window);
return FALSE;
}
@@ -304,9 +306,9 @@ mw_menubar_foreach(GtkWidget *widget, gpointer data)
static void
mw_set_buttons_sensitive(MessageWindow * mw)
{
- LibBalsaMailbox *mailbox = mw->message->mailbox;
+ LibBalsaMailbox *mailbox = libbalsa_message_get_mailbox(mw->message);
BalsaIndex *index = mw->bindex;
- guint current_msgno = mw->message->msgno;
+ guint current_msgno = libbalsa_message_get_msgno(mw->message);
gboolean enable;
if (!mailbox) {
@@ -387,7 +389,7 @@ destroy_message_window(GtkWidget * widget, MessageWindow * mw)
static void
mw_expunged_cb(LibBalsaMailbox * mailbox, guint msgno, MessageWindow * mw)
{
- if (mw->message && (guint) mw->message->msgno == msgno)
+ if (mw->message != NULL && (guint) libbalsa_message_get_msgno(mw->message) == msgno)
gtk_widget_destroy(mw->window);
}
@@ -399,7 +401,8 @@ mw_reply_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_reply(mw->message->mailbox, mw->message->msgno,
+ sendmsg_window_reply(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message),
SEND_REPLY);
}
@@ -411,7 +414,8 @@ mw_reply_all_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_reply(mw->message->mailbox, mw->message->msgno,
+ sendmsg_window_reply(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message),
SEND_REPLY_ALL);
}
@@ -423,7 +427,8 @@ mw_reply_group_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_reply(mw->message->mailbox, mw->message->msgno,
+ sendmsg_window_reply(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message),
SEND_REPLY_GROUP);
}
@@ -435,7 +440,9 @@ mw_forward_attached_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_forward(mw->message->mailbox, mw->message->msgno, TRUE);
+ sendmsg_window_forward(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message),
+ TRUE);
}
static void
@@ -446,7 +453,8 @@ mw_forward_inline_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_forward(mw->message->mailbox, mw->message->msgno,
+ sendmsg_window_forward(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message_get_msgno(mw->message),
FALSE);
}
@@ -459,7 +467,8 @@ mw_forward_default_activated(GSimpleAction * action, GVariant * parameter,
g_return_if_fail(mw != NULL);
- sendmsg_window_forward(mw->message->mailbox, mw->message->msgno,
+ sendmsg_window_forward(libbalsa_message_get_mailbox(mw->message),
+ libbalsa_message(get_msgno(mw->message),
balsa_app.forward_attached);
}
#endif
@@ -548,10 +557,10 @@ mw_set_selected(MessageWindow * mw, void (*select_func) (BalsaIndex *))
LibBalsaMessage *message;
MessageWindow *tmp;
- balsa_index_set_next_msgno(mw->bindex, mw->message->msgno);
+ balsa_index_set_next_msgno(mw->bindex, libbalsa_message_get_msgno(mw->message));
select_func(mw->bindex);
msgno = balsa_index_get_next_msgno(mw->bindex);
- message = libbalsa_mailbox_get_message(mw->message->mailbox, msgno);
+ message = libbalsa_mailbox_get_message(libbalsa_message_get_mailbox(mw->message), msgno);
if (!message)
return;
@@ -574,16 +583,18 @@ static void
message_window_move_message(MessageWindow * mw, LibBalsaMailbox * mailbox)
{
GArray *messages;
+ guint msgno;
LibBalsaMessage *original = mw->message;
g_return_if_fail(mailbox != NULL);
/* Transferring to same mailbox? */
- if (mw->message->mailbox == mailbox)
+ if (libbalsa_message_get_mailbox(mw->message) == mailbox)
return;
messages = g_array_new(FALSE, FALSE, sizeof(guint));
- g_array_append_val(messages, mw->message->msgno);
+ msgno = libbalsa_message_get_msgno(mw->message);
+ g_array_append_val(messages, msgno);
if (balsa_app.mw_action_after_move == NEXT_UNREAD)
/* Try selecting the next unread message. */
@@ -720,7 +731,7 @@ mw_select_part_cb(BalsaMessage * bm, gpointer data)
/* set window title */
if (bm && bm->message) {
- from = internet_address_list_to_string(bm->message->headers->from,
+ from = internet_address_list_to_string(libbalsa_message_get_headers(bm->message)->from,
FALSE);
title = g_strdup_printf(_("Message from %s: %s"), from,
LIBBALSA_MESSAGE_GET_SUBJECT(bm->message));
diff --git a/src/print-gtk.c b/src/print-gtk.c
index 53fccf530..bc515d4bb 100644
--- a/src/print-gtk.c
+++ b/src/print-gtk.c
@@ -276,6 +276,7 @@ begin_print(GtkPrintOperation * operation, GtkPrintContext * context,
gchar *subject;
gchar *date;
GString *footer_string;
+ InternetAddressList *from_list;
/* initialise the context */
page_setup = gtk_print_context_get_page_setup(context);
@@ -340,9 +341,9 @@ begin_print(GtkPrintOperation * operation, GtkPrintContext * context,
g_free(date);
}
- if (pdata->message->headers->from) {
- gchar *from =
- internet_address_list_to_string(pdata->message->headers->from, FALSE);
+ from_list = libbalsa_message_get_headers(pdata->message)->from;
+ if (from_list != NULL) {
+ gchar *from = internet_address_list_to_string(from_list, FALSE);
libbalsa_utf8_sanitize(&from, balsa_app.convert_unknown_8bit,
NULL);
@@ -388,7 +389,7 @@ begin_print(GtkPrintOperation * operation, GtkPrintContext * context,
/* add the mime bodies */
pdata->print_parts =
scan_body(pdata->print_parts, context, &pdata->setup,
- pdata->message->body_list, FALSE);
+ libbalsa_message_get_body_list(pdata->message), FALSE);
/* done */
gtk_print_operation_set_n_pages(operation, pdata->setup.page_count);
diff --git a/src/sendmsg-window.c b/src/sendmsg-window.c
index f0293ad85..dfce2950b 100644
--- a/src/sendmsg-window.c
+++ b/src/sendmsg-window.c
@@ -487,10 +487,12 @@ static void
sw_delete_draft(BalsaSendmsg * bsmsg)
{
LibBalsaMessage *message;
+ LibBalsaMailbox *mailbox;
message = bsmsg->draft_message;
- if (message != NULL && message->mailbox != NULL
- && !libbalsa_mailbox_get_readonly(message->mailbox))
+ if (message != NULL &&
+ (mailbox = libbalsa_message_get_mailbox(message)) != NULL &&
+ !libbalsa_mailbox_get_readonly(mailbox))
libbalsa_message_change_flags(message,
LIBBALSA_MESSAGE_FLAG_DELETED, 0);
}
@@ -608,20 +610,26 @@ balsa_sendmsg_destroy_handler(BalsaSendmsg * bsmsg)
}
if(balsa_app.debug) g_message("balsa_sendmsg_destroy()_handler: Start.");
- if (bsmsg->parent_message) {
- if (bsmsg->parent_message->mailbox)
- libbalsa_mailbox_close(bsmsg->parent_message->mailbox,
+ if (bsmsg->parent_message != NULL) {
+ LibBalsaMailbox *mailbox;
+
+ mailbox = libbalsa_message_get_mailbox(bsmsg->parent_message);
+ if (mailbox != NULL)
+ libbalsa_mailbox_close(mailbox,
/* Respect pref setting: */
balsa_app.expunge_on_close);
g_object_unref(G_OBJECT(bsmsg->parent_message));
bsmsg->parent_message = NULL;
}
- if (bsmsg->draft_message) {
+ if (bsmsg->draft_message != NULL) {
+ LibBalsaMailbox *mailbox;
+
+ mailbox = libbalsa_message_get_mailbox(bsmsg->draft_message);
g_object_set_data(G_OBJECT(bsmsg->draft_message),
BALSA_SENDMSG_WINDOW_KEY, NULL);
- if (bsmsg->draft_message->mailbox)
- libbalsa_mailbox_close(bsmsg->draft_message->mailbox,
+ if (mailbox != NULL)
+ libbalsa_mailbox_close(mailbox,
/* Respect pref setting: */
balsa_app.expunge_on_close);
g_object_unref(G_OBJECT(bsmsg->draft_message));
@@ -1204,11 +1212,11 @@ update_bsmsg_identity(BalsaSendmsg* bsmsg, LibBalsaIdentity* ident)
gtk_entry_set_text(GTK_ENTRY(bsmsg->subject[1]), tmpstr);
g_free(tmpstr);
} else {
- if ( (replen == 0 && reply_type) ||
- (fwdlen == 0 && forward_type) ) {
+ if ((replen == 0 && reply_type) ||
+ (fwdlen == 0 && forward_type) ) {
LibBalsaMessage *msg = bsmsg->parent_message ?
bsmsg->parent_message : bsmsg->draft_message;
- bsmsg_set_subject_from_body(bsmsg, msg->body_list, ident);
+ bsmsg_set_subject_from_body(bsmsg, libbalsa_message_get_body_list(msg), ident);
}
}
@@ -2602,10 +2610,13 @@ create_info_pane(BalsaSendmsg * bsmsg)
balsa_mblist_mru_add(&balsa_app.fcc_mru, "");
balsa_app.fcc_mru = g_list_reverse(balsa_app.fcc_mru);
}
- if (bsmsg->draft_message && bsmsg->draft_message->headers &&
- bsmsg->draft_message->headers->fcc_url)
- balsa_mblist_mru_add(&balsa_app.fcc_mru,
- bsmsg->draft_message->headers->fcc_url);
+ if (bsmsg->draft_message != NULL) {
+ LibBalsaMessageHeaders *headers;
+
+ headers = libbalsa_message_get_headers(bsmsg->draft_message);
+ if (headers != NULL && headers->fcc_url != NULL)
+ balsa_mblist_mru_add(&balsa_app.fcc_mru, headers->fcc_url);
+ }
bsmsg->fcc[1] =
balsa_mblist_mru_option_menu(GTK_WINDOW(bsmsg->window),
&balsa_app.fcc_mru);
@@ -2982,7 +2993,7 @@ continue_body(BalsaSendmsg * bsmsg, LibBalsaMessage * message)
{
LibBalsaMessageBody *body;
- body = message->body_list;
+ body = libbalsa_message_get_body_list(message);
if (body) {
if (libbalsa_message_body_type(body) == LIBBALSA_MESSAGE_BODY_TYPE_MULTIPART)
body = body->parts;
@@ -3053,13 +3064,19 @@ static gchar*
message_part_get_subject(LibBalsaMessageBody *part)
{
gchar *subject = NULL;
- if(part->embhdrs && part->embhdrs->subject)
+
+ if (part->embhdrs != NULL && part->embhdrs->subject != NULL)
subject = g_strdup(part->embhdrs->subject);
- else if(part->message && part->message->subj)
- subject = g_strdup(part->message->subj);
- else subject = g_strdup(_("No subject"));
+
+ if (subject == NULL && part->message != NULL)
+ subject = g_strdup(LIBBALSA_MESSAGE_GET_SUBJECT(part->message));
+
+ if (subject == NULL)
+ subject = g_strdup(_("No subject"));
+
libbalsa_utf8_sanitize(&subject, balsa_app.convert_unknown_8bit,
NULL);
+
return subject;
}
@@ -3735,9 +3752,14 @@ quote_message_body(BalsaSendmsg * bsmsg,
QuoteType qtype)
{
GString *res;
- if(libbalsa_message_body_ref(message, FALSE, FALSE)) {
- res = quote_body(bsmsg, message->headers, message->message_id,
- message->references, message->body_list, qtype);
+
+ if (libbalsa_message_body_ref(message, FALSE, FALSE)) {
+ res = quote_body(bsmsg,
+ libbalsa_message_get_headers(message),
+ libbalsa_message_get_message_id(message),
+ libbalsa_message_get_references(message),
+ libbalsa_message_get_body_list(message),
+ qtype);
libbalsa_message_body_unref(message);
} else res = g_string_new("");
return res;
@@ -3747,8 +3769,12 @@ static void
fill_body_from_message(BalsaSendmsg *bsmsg, LibBalsaMessage *message,
QuoteType qtype)
{
- fill_body_from_part(bsmsg, message->headers, message->message_id,
- message->references, message->body_list, qtype);
+ fill_body_from_part(bsmsg,
+ libbalsa_message_get_headers(message),
+ libbalsa_message_get_message_id(message),
+ libbalsa_message_get_references(message),
+ libbalsa_message_get_body_list(message),
+ qtype);
}
@@ -3896,7 +3922,7 @@ bsmsg_set_subject_from_body(BalsaSendmsg * bsmsg,
case SEND_FORWARD_ATTACH:
case SEND_FORWARD_INLINE:
headers =
- part->embhdrs ? part->embhdrs : part->message->headers;
+ part->embhdrs ? part->embhdrs : libbalsa_message_get_headers(part->message);
newsubject =
generate_forwarded_subject(subject, headers, ident);
break;
@@ -3935,13 +3961,17 @@ sw_save_draft(BalsaSendmsg * bsmsg)
return FALSE;
}
- if (bsmsg->draft_message) {
+ if (bsmsg->draft_message != NULL) {
+ LibBalsaMailbox *mailbox;
+
g_object_set_data(G_OBJECT(bsmsg->draft_message),
BALSA_SENDMSG_WINDOW_KEY, NULL);
- if (bsmsg->draft_message->mailbox)
- libbalsa_mailbox_close(bsmsg->draft_message->mailbox,
+ mailbox = libbalsa_message_get_mailbox(bsmsg->draft_message);
+ if (mailbox != NULL) {
+ libbalsa_mailbox_close(mailbox,
/* Respect pref setting: */
balsa_app.expunge_on_close);
+ }
g_object_unref(G_OBJECT(bsmsg->draft_message));
}
bsmsg->state = SENDMSG_STATE_CLEAN;
@@ -3973,7 +4003,9 @@ sw_autosave_timeout_cb(BalsaSendmsg * bsmsg)
static void
setup_headers_from_message(BalsaSendmsg* bsmsg, LibBalsaMessage *message)
{
- g_return_if_fail(message->headers);
+ LibBalsaMessageHeaders *headers;
+
+ headers = libbalsa_message_get_headers(message);
/* Try to make the blank line in the address view useful;
* - never make it a Bcc: line;
@@ -3983,13 +4015,13 @@ setup_headers_from_message(BalsaSendmsg* bsmsg, LibBalsaMessage *message)
* will be a To: line */
libbalsa_address_view_set_from_list(bsmsg->recipient_view,
"BCC:",
- message->headers->bcc_list);
+ headers->bcc_list);
libbalsa_address_view_set_from_list(bsmsg->recipient_view,
"To:",
- message->headers->to_list);
+ headers->to_list);
libbalsa_address_view_set_from_list(bsmsg->recipient_view,
"CC:",
- message->headers->cc_list);
+ headers->cc_list);
}
@@ -4002,13 +4034,18 @@ setup_headers_from_message(BalsaSendmsg* bsmsg, LibBalsaMessage *message)
static gboolean
set_identity_from_mailbox(BalsaSendmsg *bsmsg, LibBalsaMessage *message)
{
+ LibBalsaMailbox *mailbox;
const gchar *identity;
GList *ilist;
- if (message == NULL || message->mailbox == NULL)
+ if (message == NULL)
return FALSE;
- identity = libbalsa_mailbox_get_identity_name(message->mailbox);
+ mailbox = libbalsa_message_get_mailbox(message);
+ if (mailbox == NULL)
+ return FALSE;
+
+ identity = libbalsa_mailbox_get_identity_name(mailbox);
if (identity == NULL)
return FALSE;
@@ -4074,21 +4111,24 @@ guess_identity_from_list(BalsaSendmsg * bsmsg, InternetAddressList * list,
static gboolean
guess_identity(BalsaSendmsg* bsmsg, LibBalsaMessage * message)
{
- if (!message || !message->headers || !balsa_app.identities)
+ LibBalsaMessageHeaders *headers;
+
+ if (message == NULL || balsa_app.identities == NULL)
+ return FALSE; /* use default */
+
+ headers = libbalsa_message_get_headers(message);
+ if (headers == NULL)
return FALSE; /* use default */
if (bsmsg->is_continue)
- return guess_identity_from_list(bsmsg, message->headers->from,
- FALSE);
+ return guess_identity_from_list(bsmsg, headers->from, FALSE);
if (bsmsg->type != SEND_NORMAL)
/* bsmsg->type == SEND_REPLY || bsmsg->type == SEND_REPLY_ALL ||
* bsmsg->type == SEND_REPLY_GROUP || bsmsg->type == SEND_FORWARD_ATTACH ||
* bsmsg->type == SEND_FORWARD_INLINE */
- return guess_identity_from_list(bsmsg, message->headers->to_list,
- TRUE)
- || guess_identity_from_list(bsmsg, message->headers->cc_list,
- TRUE);
+ return guess_identity_from_list(bsmsg, headers->to_list, TRUE)
+ || guess_identity_from_list(bsmsg, headers->cc_list, TRUE);
return FALSE;
}
@@ -4373,8 +4413,11 @@ insert_initial_sig(BalsaSendmsg *bsmsg)
static void
bsm_prepare_for_setup(LibBalsaMessage *message)
{
- if (message->mailbox)
- libbalsa_mailbox_open(message->mailbox, NULL);
+ LibBalsaMailbox *mailbox;
+
+ mailbox = libbalsa_message_get_mailbox(message);
+ if (mailbox != NULL)
+ libbalsa_mailbox_open(mailbox, NULL);
/* fill in that info:
* ref the message so that we have all needed headers */
libbalsa_message_body_ref(message, TRUE, TRUE);
@@ -4389,12 +4432,12 @@ bsm_prepare_for_setup(LibBalsaMessage *message)
static void
bsm_finish_setup(BalsaSendmsg *bsmsg, LibBalsaMessageBody *part)
{
- g_return_if_fail(part != NULL);
- g_return_if_fail(part->message != NULL);
+ LibBalsaMailbox *mailbox;
- if (part->message->mailbox &&
- !bsmsg->parent_message && !bsmsg->draft_message)
- libbalsa_mailbox_close(part->message->mailbox, FALSE);
+ mailbox = libbalsa_message_get_mailbox(part->message);
+ if (mailbox != NULL &&
+ bsmsg->parent_message == NULL && bsmsg->draft_message == NULL)
+ libbalsa_mailbox_close(mailbox, FALSE);
/* ...but mark it as unmodified. */
bsmsg->state = SENDMSG_STATE_CLEAN;
bsmsg_set_subject_from_body(bsmsg, part, bsmsg->ident);
@@ -4944,6 +4987,7 @@ static LibBalsaMessage *
bsmsg2message(BalsaSendmsg * bsmsg)
{
LibBalsaMessage *message;
+ LibBalsaMessageHeaders *headers;
LibBalsaMessageBody *body;
gchar *tmp;
GtkTextIter start, end;
@@ -4953,22 +4997,23 @@ bsmsg2message(BalsaSendmsg * bsmsg)
GtkTextBuffer *new_buffer = NULL;
message = libbalsa_message_new();
+ headers = libbalsa_message_get_headers(message);
- message->headers->from = internet_address_list_new ();
- internet_address_list_add(message->headers->from, ia);
+ headers->from = internet_address_list_new ();
+ internet_address_list_add(headers->from, ia);
tmp = gtk_editable_get_chars(GTK_EDITABLE(bsmsg->subject[1]), 0, -1);
strip_chars(tmp, "\r\n");
libbalsa_message_set_subject(message, tmp);
g_free(tmp);
- message->headers->to_list =
+ headers->to_list =
libbalsa_address_view_get_list(bsmsg->recipient_view, "To:");
- message->headers->cc_list =
+ headers->cc_list =
libbalsa_address_view_get_list(bsmsg->recipient_view, "CC:");
- message->headers->bcc_list =
+ headers->bcc_list =
libbalsa_address_view_get_list(bsmsg->recipient_view, "BCC:");
@@ -4976,12 +5021,13 @@ bsmsg2message(BalsaSendmsg * bsmsg)
bsmsg->fcc_url =
g_strdup(balsa_mblist_mru_option_menu_get(bsmsg->fcc[1]));
- message->headers->reply_to =
+ headers->reply_to =
libbalsa_address_view_get_list(bsmsg->replyto_view, "Reply To:");
if (bsmsg->req_mdn)
libbalsa_message_set_dispnotify(message, ia);
- message->request_dsn = bsmsg->req_dsn;
+ libbalsa_message_set_request_dsn(message, bsmsg->req_dsn);
+
sw_set_header_from_path(message, "Face", libbalsa_identity_get_face_path(ident),
/* Translators: please do not translate Face. */
@@ -4990,12 +5036,14 @@ bsmsg2message(BalsaSendmsg * bsmsg)
/* Translators: please do not translate Face. */
_("Could not load X-Face header file %s: %s"));
- message->references = bsmsg->references;
+ libbalsa_message_set_references(message, bsmsg->references);
bsmsg->references = NULL; /* steal it */
- if (bsmsg->in_reply_to)
- message->in_reply_to =
- g_list_prepend(NULL, g_strdup(bsmsg->in_reply_to));
+ if (bsmsg->in_reply_to != NULL) {
+ libbalsa_message_set_in_reply_to(message,
+ g_list_prepend(NULL,
+ g_strdup(bsmsg->in_reply_to)));
+ }
body = libbalsa_message_body_new(message);
@@ -5026,7 +5074,7 @@ bsmsg2message(BalsaSendmsg * bsmsg)
if (bsmsg->send_mp_alt)
body->html_buffer =
- libbalsa_text_to_html(message->subj, body->buffer,
+ libbalsa_text_to_html(LIBBALSA_MESSAGE_GET_SUBJECT(message), body->buffer,
bsmsg->spell_check_lang);
if (bsmsg->flow)
body->buffer =
@@ -5049,15 +5097,15 @@ bsmsg2message(BalsaSendmsg * bsmsg)
gtk_tree_model_foreach(BALSA_MSG_ATTACH_MODEL(bsmsg),
attachment2message, message);
- message->headers->date = time(NULL);
+ headers->date = time(NULL);
if (balsa_app.has_openpgp || balsa_app.has_smime) {
- message->gpg_mode =
- (bsmsg->gpg_mode & LIBBALSA_PROTECT_MODE) != 0 ? bsmsg->gpg_mode : 0;
- message->att_pubkey = bsmsg->attach_pubkey;
- message->ident = g_object_ref(ident);
+ libbalsa_message_set_gpg_mode(message,
+ (bsmsg->gpg_mode & LIBBALSA_PROTECT_MODE) != 0 ? bsmsg->gpg_mode : 0);
+ libbalsa_message_set_attach_pubkey(message, bsmsg->attach_pubkey);
+ libbalsa_message_set_identity(message, ident);
} else {
- message->gpg_mode = 0;
- message->att_pubkey = FALSE;
+ libbalsa_message_set_gpg_mode(message, 0);
+ libbalsa_message_set_attach_pubkey(message, FALSE);
}
/* remember the parent window */
@@ -5355,7 +5403,7 @@ check_autocrypt_recommendation(BalsaSendmsg *bsmsg)
if (((autocrypt_mode == AUTOCRYPT_ENCR_AVAIL_MUTUAL) &&
(libbalsa_identity_get_autocrypt_mode(bsmsg->ident) == AUTOCRYPT_PREFER_ENCRYPT)) ||
((bsmsg->parent_message != NULL) &&
- (bsmsg->parent_message->prot_state == LIBBALSA_MSG_PROTECT_CRYPT))) {
+ (libbalsa_message_get_protect_state(bsmsg->parent_message) == LIBBALSA_MSG_PROTECT_CRYPT))) {
default_choice = GTK_RESPONSE_YES;
} else if (autocrypt_mode == AUTOCRYPT_ENCR_AVAIL) {
default_choice = GTK_RESPONSE_NO;
@@ -5500,7 +5548,7 @@ send_message_handler(BalsaSendmsg * bsmsg, gboolean queue_only)
balsa_information_parented(GTK_WINDOW(bsmsg->window),
LIBBALSA_INFORMATION_DEBUG,
_("sending message with GPG mode %d"),
- message->gpg_mode);
+ libbalsa_message_get_gpg_mode(message));
if(queue_only)
result = libbalsa_message_queue(message, balsa_app.outbox, fcc,
@@ -5514,9 +5562,11 @@ send_message_handler(BalsaSendmsg * bsmsg, gboolean queue_only)
GTK_WINDOW(balsa_app.main_window),
bsmsg->flow, &error);
if (result == LIBBALSA_MESSAGE_CREATE_OK) {
- if (bsmsg->parent_message && bsmsg->parent_message->mailbox
- && !libbalsa_mailbox_get_readonly(bsmsg->parent_message->mailbox))
- libbalsa_message_reply(bsmsg->parent_message);
+ if (bsmsg->parent_message != NULL) {
+ LibBalsaMailbox *mailbox = libbalsa_message_get_mailbox(bsmsg->parent_message);
+ if (mailbox != NULL && !libbalsa_mailbox_get_readonly(mailbox))
+ libbalsa_message_reply(bsmsg->parent_message);
+ }
sw_delete_draft(bsmsg);
}
@@ -5539,18 +5589,19 @@ send_message_handler(BalsaSendmsg * bsmsg, gboolean queue_only)
case LIBBALSA_MESSAGE_ENCRYPT_ERROR:
msg = _("Message could not be encrypted"); break;
}
- if (error)
+ if (error) {
balsa_information_parented(GTK_WINDOW(bsmsg->window),
LIBBALSA_INFORMATION_ERROR,
_("Send failed: %s\n%s"), msg,
error->message);
- else
+ g_error_free(error);
+ } else {
balsa_information_parented(GTK_WINDOW(bsmsg->window),
LIBBALSA_INFORMATION_ERROR,
_("Send failed: %s"), msg);
+ }
return FALSE;
}
- g_clear_error(&error);
gtk_widget_destroy(bsmsg->window);
@@ -7019,6 +7070,9 @@ sendmsg_window_reply(LibBalsaMailbox * mailbox, guint msgno,
LibBalsaMessage *message =
libbalsa_mailbox_get_message(mailbox, msgno);
BalsaSendmsg *bsmsg;
+ LibBalsaMessageHeaders *headers;
+ const gchar *message_id;
+ GList *in_reply_to;
g_assert(message);
switch(reply_type) {
@@ -7038,21 +7092,24 @@ sendmsg_window_reply(LibBalsaMailbox * mailbox, guint msgno,
bsm_prepare_for_setup(message);
- set_to(bsmsg, message->headers);
+ headers = libbalsa_message_get_headers(message);
+ set_to(bsmsg, headers);
- if (message->message_id)
- set_in_reply_to(bsmsg, message->message_id, message->headers);
+ message_id = libbalsa_message_get_message_id(message);
+ if (message_id != NULL)
+ set_in_reply_to(bsmsg, message_id, headers);
if (reply_type == SEND_REPLY_ALL)
- set_cc_from_all_recipients(bsmsg, message->headers);
- set_references_reply(bsmsg, message->references,
- message->in_reply_to
- ? message->in_reply_to->data : NULL,
- message->message_id);
+ set_cc_from_all_recipients(bsmsg, headers);
+
+ in_reply_to = libbalsa_message_get_in_reply_to(message);
+ set_references_reply(bsmsg, libbalsa_message_get_references(message),
+ in_reply_to != NULL ? in_reply_to->data : NULL,
+ message_id);
if(balsa_app.autoquote)
fill_body_from_message(bsmsg, message, QUOTE_ALL);
if (libbalsa_identity_get_sig_whenreply(bsmsg->ident))
insert_initial_sig(bsmsg);
- bsm_finish_setup(bsmsg, message->body_list);
+ bsm_finish_setup(bsmsg, libbalsa_message_get_body_list(message));
g_idle_add((GSourceFunc) sw_grab_focus_to_text,
g_object_ref(bsmsg->text));
return bsmsg;
@@ -7124,11 +7181,11 @@ sendmsg_window_forward(LibBalsaMailbox *mailbox, guint msgno,
_("Attaching message failed.\n"
"Possible reason: not enough temporary space"));
bsmsg->state = SENDMSG_STATE_CLEAN;
- bsmsg_set_subject_from_body(bsmsg, message->body_list, bsmsg->ident);
+ bsmsg_set_subject_from_body(bsmsg, libbalsa_message_get_body_list(message), bsmsg->ident);
} else {
bsm_prepare_for_setup(message);
fill_body_from_message(bsmsg, message, QUOTE_NOPREFIX);
- bsm_finish_setup(bsmsg, message->body_list);
+ bsm_finish_setup(bsmsg, libbalsa_message_get_body_list(message));
}
if (libbalsa_identity_get_sig_whenforward(bsmsg->ident))
insert_initial_sig(bsmsg);
@@ -7153,6 +7210,7 @@ sendmsg_window_continue(LibBalsaMailbox * mailbox, guint msgno)
BalsaSendmsg *bsmsg;
const gchar *postpone_hdr;
GList *list, *refs = NULL;
+ GList *in_reply_to;
g_assert(message);
@@ -7174,10 +7232,11 @@ sendmsg_window_continue(LibBalsaMailbox * mailbox, guint msgno)
libbalsa_address_view_set_from_list(bsmsg->replyto_view,
"Reply To:",
- message->headers->reply_to);
- if (message->in_reply_to)
+ libbalsa_message_get_headers(message)->reply_to);
+ in_reply_to = libbalsa_message_get_in_reply_to(message);
+ if (in_reply_to != NULL)
bsmsg->in_reply_to =
- g_strconcat("<", message->in_reply_to->data, ">", NULL);
+ g_strconcat("<", in_reply_to->data, ">", NULL);
if ((postpone_hdr =
libbalsa_message_get_user_header(message, "X-Balsa-Crypto")))
@@ -7221,12 +7280,12 @@ sendmsg_window_continue(LibBalsaMailbox * mailbox, guint msgno)
libbalsa_message_get_user_header(message, "X-Balsa-Send-Type")))
bsmsg->type = atoi(postpone_hdr);
- for (list = message->references; list; list = list->next)
+ for (list = libbalsa_message_get_references(message); list != NULL; list = list->next)
refs = g_list_prepend(refs, g_strdup(list->data));
bsmsg->references = g_list_reverse(refs);
continue_body(bsmsg, message);
- bsm_finish_setup(bsmsg, message->body_list);
+ bsm_finish_setup(bsmsg, libbalsa_message_get_body_list(message));
g_idle_add((GSourceFunc) sw_grab_focus_to_text,
g_object_ref(bsmsg->text));
return bsmsg;
diff --git a/src/store-address.c b/src/store-address.c
index 6eaffe48e..26f46917f 100644
--- a/src/store-address.c
+++ b/src/store-address.c
@@ -331,12 +331,15 @@ store_address_note_frame(StoreAddressInfo *info)
gtk_container_set_border_width(GTK_CONTAINER(info->notebook), 4);
for (list = info->message_list; list; list = list->next) {
+ LibBalsaMessageHeaders *headers;
+
message = LIBBALSA_MESSAGE(list->data);
- if (message->headers) {
- store_address_add_list(info, _("From: "), message->headers->from);
- store_address_add_list(info, _("To: "), message->headers->to_list);
- store_address_add_list(info, _("CC: "), message->headers->cc_list);
- store_address_add_list(info, _("BCC: "), message->headers->bcc_list);
+ headers = libbalsa_message_get_headers(message);
+ if (headers != NULL) {
+ store_address_add_list(info, _("From: "), headers->from);
+ store_address_add_list(info, _("To: "), headers->to_list);
+ store_address_add_list(info, _("CC: "), headers->cc_list);
+ store_address_add_list(info, _("BCC: "), headers->bcc_list);
}
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
