2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include <glib/gi18n.h>
34 #include "alertpanel.h"
48 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
57 #include "procheader.h"
58 #include "prefs_account.h"
63 #include "prefs_common.h"
64 #include "inputdialog.h"
66 #include "remotefolder.h"
68 #include "statusbar.h"
70 #include "imap-thread.h"
73 typedef struct _IMAPFolder IMAPFolder;
74 typedef struct _IMAPSession IMAPSession;
75 typedef struct _IMAPNameSpace IMAPNameSpace;
76 typedef struct _IMAPFolderItem IMAPFolderItem;
78 #include "prefs_account.h"
80 #define IMAP_FOLDER(obj) ((IMAPFolder *)obj)
81 #define IMAP_FOLDER_ITEM(obj) ((IMAPFolderItem *)obj)
82 #define IMAP_SESSION(obj) ((IMAPSession *)obj)
88 /* list of IMAPNameSpace */
92 gchar last_seen_separator;
100 gboolean authenticated;
109 gboolean folder_content_changed;
120 gboolean sens_update_block;
123 struct _IMAPNameSpace
129 #define IMAP_SUCCESS 0
130 #define IMAP_SOCKET 2
131 #define IMAP_AUTHFAIL 3
132 #define IMAP_PROTOCOL 4
133 #define IMAP_SYNTAX 5
137 #define IMAPBUFSIZE 8192
141 IMAP_FLAG_SEEN = 1 << 0,
142 IMAP_FLAG_ANSWERED = 1 << 1,
143 IMAP_FLAG_FLAGGED = 1 << 2,
144 IMAP_FLAG_DELETED = 1 << 3,
145 IMAP_FLAG_DRAFT = 1 << 4
148 #define IMAP_IS_SEEN(flags) ((flags & IMAP_FLAG_SEEN) != 0)
149 #define IMAP_IS_ANSWERED(flags) ((flags & IMAP_FLAG_ANSWERED) != 0)
150 #define IMAP_IS_FLAGGED(flags) ((flags & IMAP_FLAG_FLAGGED) != 0)
151 #define IMAP_IS_DELETED(flags) ((flags & IMAP_FLAG_DELETED) != 0)
152 #define IMAP_IS_DRAFT(flags) ((flags & IMAP_FLAG_DRAFT) != 0)
155 #define IMAP4_PORT 143
156 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
157 #define IMAPS_PORT 993
160 #define IMAP_CMD_LIMIT 1000
162 struct _IMAPFolderItem
171 GHashTable *flags_set_table;
172 GHashTable *flags_unset_table;
175 gboolean should_update;
176 gboolean should_trash_cache;
179 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
180 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
182 static void imap_folder_init (Folder *folder,
186 static Folder *imap_folder_new (const gchar *name,
188 static void imap_folder_destroy (Folder *folder);
190 static IMAPSession *imap_session_new (Folder *folder,
191 const PrefsAccount *account);
192 static void imap_session_authenticate(IMAPSession *session,
193 const PrefsAccount *account);
194 static void imap_session_destroy (Session *session);
196 static gchar *imap_fetch_msg (Folder *folder,
199 static gchar *imap_fetch_msg_full (Folder *folder,
204 static void imap_remove_cached_msg (Folder *folder,
207 static gint imap_add_msg (Folder *folder,
211 static gint imap_add_msgs (Folder *folder,
214 GRelation *relation);
216 static gint imap_copy_msg (Folder *folder,
219 static gint imap_copy_msgs (Folder *folder,
221 MsgInfoList *msglist,
222 GRelation *relation);
224 static gint imap_remove_msg (Folder *folder,
227 static gint imap_remove_msgs (Folder *folder,
229 MsgInfoList *msglist,
230 GRelation *relation);
231 static gint imap_remove_all_msg (Folder *folder,
234 static gboolean imap_is_msg_changed (Folder *folder,
238 static gint imap_close (Folder *folder,
241 static gint imap_scan_tree (Folder *folder);
243 static gint imap_create_tree (Folder *folder);
245 static FolderItem *imap_create_folder (Folder *folder,
248 static gint imap_rename_folder (Folder *folder,
251 static gint imap_remove_folder (Folder *folder,
254 static FolderItem *imap_folder_item_new (Folder *folder);
255 static void imap_folder_item_destroy (Folder *folder,
258 static IMAPSession *imap_session_get (Folder *folder);
260 static gint imap_auth (IMAPSession *session,
265 static gint imap_scan_tree_recursive (IMAPSession *session,
269 static void imap_create_missing_folders (Folder *folder);
270 static FolderItem *imap_create_special_folder
272 SpecialFolderItemType stype,
275 static gint imap_do_copy_msgs (Folder *folder,
277 MsgInfoList *msglist,
278 GRelation *relation);
280 static void imap_delete_all_cached_messages (FolderItem *item);
281 static void imap_set_batch (Folder *folder,
284 static gint imap_set_message_flags (IMAPSession *session,
285 MsgNumberList *numlist,
288 static gint imap_select (IMAPSession *session,
294 guint32 *uid_validity,
296 static gint imap_status (IMAPSession *session,
299 IMAPFolderItem *item,
302 guint32 *uid_validity,
306 static gchar imap_get_path_separator (IMAPSession *session,
309 static gchar *imap_get_real_path (IMAPSession *session,
313 static void imap_synchronise (FolderItem *item, gint days);
315 static gboolean imap_is_busy (Folder *folder);
317 static void imap_free_capabilities (IMAPSession *session);
319 /* low-level IMAP4rev1 commands */
320 static gint imap_cmd_login (IMAPSession *session,
324 static gint imap_cmd_noop (IMAPSession *session);
325 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
326 static gint imap_cmd_starttls (IMAPSession *session);
328 static gint imap_cmd_select (IMAPSession *session,
333 guint32 *uid_validity,
335 static gint imap_cmd_close (IMAPSession *session);
336 static gint imap_cmd_examine (IMAPSession *session,
341 guint32 *uid_validity,
343 static gint imap_cmd_create (IMAPSession *sock,
344 const gchar *folder);
345 static gint imap_cmd_rename (IMAPSession *sock,
346 const gchar *oldfolder,
347 const gchar *newfolder);
348 static gint imap_cmd_delete (IMAPSession *session,
349 const gchar *folder);
350 static gint imap_cmd_fetch (IMAPSession *sock,
352 const gchar *filename,
355 static gint imap_cmd_append (IMAPSession *session,
356 const gchar *destfolder,
360 static gint imap_cmd_copy (IMAPSession *session,
361 struct mailimap_set * set,
362 const gchar *destfolder,
363 GRelation *uid_mapping,
364 struct mailimap_set ** source,
365 struct mailimap_set ** dest);
366 static gint imap_cmd_store (IMAPSession *session,
367 struct mailimap_set * set,
370 static gint imap_cmd_expunge (IMAPSession *session);
372 static void imap_path_separator_subst (gchar *str,
375 static gchar *imap_utf8_to_modified_utf7 (const gchar *from);
376 static gchar *imap_modified_utf7_to_utf8 (const gchar *mutf7_str);
378 static gboolean imap_rename_folder_func (GNode *node,
380 static gint imap_get_num_list (Folder *folder,
383 gboolean *old_uids_valid);
384 static GSList *imap_get_msginfos (Folder *folder,
386 GSList *msgnum_list);
387 static MsgInfo *imap_get_msginfo (Folder *folder,
390 static gboolean imap_scan_required (Folder *folder,
392 static void imap_change_flags (Folder *folder,
395 MsgPermFlags newflags);
396 static gint imap_get_flags (Folder *folder,
398 MsgInfoList *msglist,
399 GRelation *msgflags);
400 static gchar *imap_folder_get_path (Folder *folder);
401 static gchar *imap_item_get_path (Folder *folder,
403 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
406 /* data types conversion libetpan <-> claws */
407 static GSList * imap_list_from_lep(IMAPFolder * folder,
408 clist * list, const gchar * real_path, gboolean all);
409 static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist);
410 static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist);
411 static GSList * imap_uid_list_from_lep(clist * list);
412 static GSList * imap_uid_list_from_lep_tab(carray * list);
413 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
415 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
417 static void imap_lep_set_free(GSList *seq_list);
418 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags);
420 typedef struct _hashtable_data {
421 IMAPSession *session;
423 IMAPFolderItem *item;
426 static FolderClass imap_class;
428 typedef struct _thread_data {
433 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
438 FolderClass *imap_get_class(void)
440 if (imap_class.idstr == NULL) {
441 imap_class.type = F_IMAP;
442 imap_class.idstr = "imap";
443 imap_class.uistr = "IMAP4";
445 /* Folder functions */
446 imap_class.new_folder = imap_folder_new;
447 imap_class.destroy_folder = imap_folder_destroy;
448 imap_class.scan_tree = imap_scan_tree;
449 imap_class.create_tree = imap_create_tree;
451 /* FolderItem functions */
452 imap_class.item_new = imap_folder_item_new;
453 imap_class.item_destroy = imap_folder_item_destroy;
454 imap_class.item_get_path = imap_item_get_path;
455 imap_class.create_folder = imap_create_folder;
456 imap_class.rename_folder = imap_rename_folder;
457 imap_class.remove_folder = imap_remove_folder;
458 imap_class.close = imap_close;
459 imap_class.get_num_list = imap_get_num_list;
460 imap_class.scan_required = imap_scan_required;
461 imap_class.set_xml = folder_set_xml;
462 imap_class.get_xml = folder_get_xml;
463 imap_class.item_set_xml = imap_item_set_xml;
464 imap_class.item_get_xml = imap_item_get_xml;
466 /* Message functions */
467 imap_class.get_msginfo = imap_get_msginfo;
468 imap_class.get_msginfos = imap_get_msginfos;
469 imap_class.fetch_msg = imap_fetch_msg;
470 imap_class.fetch_msg_full = imap_fetch_msg_full;
471 imap_class.add_msg = imap_add_msg;
472 imap_class.add_msgs = imap_add_msgs;
473 imap_class.copy_msg = imap_copy_msg;
474 imap_class.copy_msgs = imap_copy_msgs;
475 imap_class.remove_msg = imap_remove_msg;
476 imap_class.remove_msgs = imap_remove_msgs;
477 imap_class.remove_all_msg = imap_remove_all_msg;
478 imap_class.is_msg_changed = imap_is_msg_changed;
479 imap_class.change_flags = imap_change_flags;
480 imap_class.get_flags = imap_get_flags;
481 imap_class.set_batch = imap_set_batch;
482 imap_class.synchronise = imap_synchronise;
483 imap_class.remove_cached_msg = imap_remove_cached_msg;
485 pthread_mutex_init(&imap_mutex, NULL);
492 static Folder *imap_folder_new(const gchar *name, const gchar *path)
496 folder = (Folder *)g_new0(IMAPFolder, 1);
497 folder->klass = &imap_class;
498 imap_folder_init(folder, name, path);
503 static void imap_folder_destroy(Folder *folder)
505 while (imap_folder_get_refcnt(folder) > 0)
506 gtk_main_iteration();
508 folder_remote_folder_destroy(REMOTE_FOLDER(folder));
512 static void imap_folder_init(Folder *folder, const gchar *name,
515 folder_remote_folder_init((Folder *)folder, name, path);
518 static FolderItem *imap_folder_item_new(Folder *folder)
520 IMAPFolderItem *item;
522 item = g_new0(IMAPFolderItem, 1);
525 item->uid_list = NULL;
527 return (FolderItem *)item;
530 static void imap_folder_item_destroy(Folder *folder, FolderItem *_item)
532 IMAPFolderItem *item = (IMAPFolderItem *)_item;
534 g_return_if_fail(item != NULL);
535 g_slist_free(item->uid_list);
540 static gboolean imap_reset_uid_lists_func(GNode *node, gpointer data)
542 IMAPFolderItem *item = (IMAPFolderItem *)node->data;
545 g_slist_free(item->uid_list);
546 item->uid_list = NULL;
551 static void imap_reset_uid_lists(Folder *folder)
553 if(folder->node == NULL)
556 /* Destroy all uid lists and rest last uid */
557 g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
560 static int imap_get_capabilities(IMAPSession *session)
562 struct mailimap_capability_data *capabilities = NULL;
566 if (session->capability != NULL)
567 return MAILIMAP_NO_ERROR;
569 capabilities = imap_threaded_capability(session->folder, &result);
571 if (result != MAILIMAP_NO_ERROR) {
572 return MAILIMAP_ERROR_CAPABILITY;
575 if (capabilities == NULL) {
576 return MAILIMAP_NO_ERROR;
579 for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
580 cur = clist_next(cur)) {
581 struct mailimap_capability * cap =
583 if (!cap || cap->cap_data.cap_name == NULL)
585 session->capability = g_slist_append
586 (session->capability,
587 g_strdup(cap->cap_data.cap_name));
588 debug_print("got capa %s\n", cap->cap_data.cap_name);
590 mailimap_capability_data_free(capabilities);
591 return MAILIMAP_NO_ERROR;
594 static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
597 for (cur = session->capability; cur; cur = cur->next) {
598 if (!g_ascii_strcasecmp(cur->data, cap))
604 static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
607 gint ok = IMAP_ERROR;
608 static time_t last_login_err = 0;
609 gchar *ext_info = "";
611 if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR)
616 ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
618 case IMAP_AUTH_CRAM_MD5:
619 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
621 case IMAP_AUTH_LOGIN:
622 ok = imap_cmd_login(session, user, pass, "LOGIN");
624 case IMAP_AUTH_GSSAPI:
625 ok = imap_cmd_login(session, user, pass, "GSSAPI");
628 debug_print("capabilities:\n"
633 imap_has_capability(session, "ANONYMOUS"),
634 imap_has_capability(session, "CRAM-MD5"),
635 imap_has_capability(session, "LOGIN"),
636 imap_has_capability(session, "GSSAPI"));
637 if (imap_has_capability(session, "CRAM-MD5"))
638 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
639 if (ok == IMAP_ERROR && imap_has_capability(session, "GSSAPI"))
640 ok = imap_cmd_login(session, user, pass, "GSSAPI");
641 if (ok == IMAP_ERROR) /* we always try LOGIN before giving up */
642 ok = imap_cmd_login(session, user, pass, "LOGIN");
645 if (ok == IMAP_SUCCESS)
646 session->authenticated = TRUE;
648 if (type == IMAP_AUTH_CRAM_MD5) {
649 ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
650 "compiled with SASL support and the "
651 "CRAM-MD5 SASL plugin is installed.");
654 if (time(NULL) - last_login_err > 10) {
655 if (!prefs_common.no_recv_err_panel) {
656 alertpanel_error(_("Connection to %s failed: "
658 SESSION(session)->server, ext_info);
660 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
661 "login refused.%s\n"),
662 SESSION(session)->server, ext_info);
665 last_login_err = time(NULL);
670 static IMAPSession *imap_reconnect_if_possible(Folder *folder, IMAPSession *session)
672 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
673 /* Check if this is the first try to establish a
674 connection, if yes we don't try to reconnect */
675 debug_print("reconnecting\n");
676 if (rfolder->session == NULL) {
677 log_warning(LOG_PROTOCOL, _("Connecting to %s failed"),
678 folder->account->recv_server);
679 session_destroy(SESSION(session));
682 rfolder->session = NULL;
683 log_warning(LOG_PROTOCOL, _("IMAP4 connection to %s has been"
684 " disconnected. Reconnecting...\n"),
685 folder->account->recv_server);
686 statusbar_print_all(_("IMAP4 connection to %s has been"
687 " disconnected. Reconnecting...\n"),
688 folder->account->recv_server);
689 SESSION(session)->state = SESSION_DISCONNECTED;
690 session_destroy(SESSION(session));
691 /* Clear folders session to make imap_session_get create
692 a new session, because of rfolder->session == NULL
693 it will not try to reconnect again and so avoid an
695 debug_print("getting session...\n");
696 session = imap_session_get(folder);
697 rfolder->session = SESSION(session);
703 static void imap_refresh_sensitivity (IMAPSession *session)
707 if (session->sens_update_block)
709 mainwin = mainwindow_get_mainwindow();
711 toolbar_main_set_sensitive(mainwin);
712 main_window_set_menu_sensitive(mainwin);
716 static void lock_session(IMAPSession *session)
719 debug_print("locking session %p (%d)\n", session, session->busy);
721 debug_print(" SESSION WAS LOCKED !! \n");
722 session->busy = TRUE;
723 imap_refresh_sensitivity(session);
725 debug_print("can't lock null session\n");
729 static void unlock_session(IMAPSession *session)
732 debug_print("unlocking session %p\n", session);
733 session->busy = FALSE;
734 imap_refresh_sensitivity(session);
736 debug_print("can't unlock null session\n");
740 static void imap_disc_session_destroy(Folder *folder)
742 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
743 IMAPSession *session = NULL;
747 session = IMAP_SESSION(rfolder->session);
750 rfolder->session = NULL;
751 log_warning(LOG_PROTOCOL, _("IMAP4 connection broken\n"));
752 SESSION(session)->state = SESSION_DISCONNECTED;
753 session_destroy(SESSION(session));
756 static IMAPSession *imap_session_get(Folder *folder)
758 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
759 IMAPSession *session = NULL;
761 g_return_val_if_fail(folder != NULL, NULL);
762 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
763 g_return_val_if_fail(folder->account != NULL, NULL);
765 if (prefs_common.work_offline &&
766 !inc_offline_should_override(FALSE,
767 _("Claws Mail needs network access in order "
768 "to access the IMAP server."))) {
772 /* Make sure we have a session */
773 if (rfolder->session != NULL) {
774 session = IMAP_SESSION(rfolder->session);
775 } else if (rfolder->connecting) {
776 debug_print("already connecting\n");
779 imap_reset_uid_lists(folder);
780 if (time(NULL) - rfolder->last_failure <= 2)
782 rfolder->connecting = TRUE;
783 session = imap_session_new(folder, folder->account);
785 if(session == NULL) {
786 rfolder->last_failure = time(NULL);
787 rfolder->connecting = FALSE;
791 /* Make sure session is authenticated */
792 if (!IMAP_SESSION(session)->authenticated)
793 imap_session_authenticate(IMAP_SESSION(session), folder->account);
795 if (!IMAP_SESSION(session)->authenticated) {
796 imap_threaded_disconnect(session->folder);
797 rfolder->session = NULL;
798 SESSION(session)->state = SESSION_DISCONNECTED;
799 session_destroy(SESSION(session));
800 rfolder->last_failure = time(NULL);
801 rfolder->connecting = FALSE;
805 lock_session(session);
807 /* I think the point of this code is to avoid sending a
808 * keepalive if we've used the session recently and therefore
809 * think it's still alive. Unfortunately, most of the code
810 * does not yet check for errors on the socket, and so if the
811 * connection drops we don't notice until the timeout expires.
812 * A better solution than sending a NOOP every time would be
813 * for every command to be prepared to retry until it is
814 * successfully sent. -- mbp */
815 if ((time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) || session->cancelled) {
816 /* verify that the session is still alive */
817 if (imap_cmd_noop(session) != IMAP_SUCCESS) {
818 debug_print("disconnected!\n");
819 session = imap_reconnect_if_possible(folder, session);
822 session->cancelled = FALSE;
825 rfolder->session = SESSION(session);
826 rfolder->connecting = FALSE;
828 return IMAP_SESSION(session);
831 static IMAPSession *imap_session_new(Folder * folder,
832 const PrefsAccount *account)
834 IMAPSession *session;
837 int authenticated = FALSE;
839 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
840 /* FIXME: IMAP over SSL only... */
843 port = account->set_imapport ? account->imapport
844 : account->ssl_imap == SSL_TUNNEL ? IMAPS_PORT : IMAP4_PORT;
845 ssl_type = account->ssl_imap;
847 if (account->ssl_imap != SSL_NONE) {
848 if (alertpanel_full(_("Insecure connection"),
849 _("This connection is configured to be secured "
850 "using SSL, but SSL is not available in this "
851 "build of Claws Mail. \n\n"
852 "Do you want to continue connecting to this "
853 "server? The communication would not be "
855 GTK_STOCK_CANCEL, _("Con_tinue connecting"),
856 NULL, FALSE, NULL, ALERT_WARNING,
857 G_ALERTDEFAULT) != G_ALERTALTERNATE)
860 port = account->set_imapport ? account->imapport
865 statuswindow_print_all(_("Connecting to IMAP4 server: %s..."), folder->account->recv_server);
866 if (account->set_tunnelcmd) {
867 r = imap_threaded_connect_cmd(folder,
869 account->recv_server,
873 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
874 if (ssl_type == SSL_TUNNEL) {
875 r = imap_threaded_connect_ssl(folder,
876 account->recv_server,
882 r = imap_threaded_connect(folder,
883 account->recv_server,
888 statuswindow_pop_all();
889 if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
890 authenticated = TRUE;
892 else if (r == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
893 authenticated = FALSE;
896 #if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
897 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
898 if (r == MAILIMAP_ERROR_SSL)
899 log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
902 if(!prefs_common.no_recv_err_panel) {
903 alertpanel_error_log(_("Can't connect to IMAP4 server: %s:%d"),
904 account->recv_server, port);
906 log_error(LOG_PROTOCOL, _("Can't connect to IMAP4 server: %s:%d\n"),
907 account->recv_server, port);
913 session = g_new0(IMAPSession, 1);
914 session_init(SESSION(session));
915 SESSION(session)->type = SESSION_IMAP;
916 SESSION(session)->server = g_strdup(account->recv_server);
917 SESSION(session)->sock = NULL;
919 SESSION(session)->destroy = imap_session_destroy;
921 session->capability = NULL;
923 session->authenticated = authenticated;
924 session->mbox = NULL;
927 session->expunge = 0;
928 session->cmd_count = 0;
929 session->folder = folder;
930 IMAP_FOLDER(session->folder)->last_seen_separator = 0;
932 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
933 if (account->ssl_imap == SSL_STARTTLS) {
936 ok = imap_cmd_starttls(session);
937 if (ok != IMAP_SUCCESS) {
938 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
939 session_destroy(SESSION(session));
943 imap_free_capabilities(session);
944 session->authenticated = FALSE;
945 session->uidplus = FALSE;
946 session->cmd_count = 1;
949 log_message(LOG_PROTOCOL, "IMAP connection is %s-authenticated\n",
950 (session->authenticated) ? "pre" : "un");
955 static void imap_session_authenticate(IMAPSession *session,
956 const PrefsAccount *account)
958 gchar *pass, *acc_pass;
959 gboolean failed = FALSE;
961 g_return_if_fail(account->userid != NULL);
962 acc_pass = account->passwd;
965 if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
967 tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
970 Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
972 } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
975 statuswindow_print_all(_("Connecting to IMAP4 server %s...\n"),
976 account->recv_server);
977 if (imap_auth(session, account->userid, pass, account->imap_auth_type) != IMAP_SUCCESS) {
985 if (prefs_common.no_recv_err_panel) {
986 log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s."), account->recv_server);
987 mainwindow_show_error();
989 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
995 statuswindow_pop_all();
996 session->authenticated = TRUE;
1000 static void imap_session_destroy(Session *session)
1002 if (session->state != SESSION_DISCONNECTED)
1003 imap_threaded_disconnect(IMAP_SESSION(session)->folder);
1005 imap_free_capabilities(IMAP_SESSION(session));
1006 g_free(IMAP_SESSION(session)->mbox);
1007 sock_close(session->sock);
1008 session->sock = NULL;
1011 static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
1013 return imap_fetch_msg_full(folder, item, uid, TRUE, TRUE);
1016 static guint get_file_size_with_crs(const gchar *filename)
1022 if (filename == NULL)
1025 fp = fopen(filename, "rb");
1029 while (fgets(buf, sizeof (buf), fp) != NULL) {
1031 if (!strstr(buf, "\r\n") && strstr(buf, "\n"))
1039 static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
1041 gchar *path, *filename;
1043 path = folder_item_get_path(item);
1045 if (!is_dir_exist(path)) {
1050 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msginfo->msgnum), NULL);
1053 if (is_file_exist(filename)) {
1059 static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
1060 gboolean headers, gboolean body)
1062 gchar *path, *filename;
1063 IMAPSession *session;
1066 g_return_val_if_fail(folder != NULL, NULL);
1067 g_return_val_if_fail(item != NULL, NULL);
1072 path = folder_item_get_path(item);
1073 if (!is_dir_exist(path))
1074 make_dir_hier(path);
1075 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1077 debug_print("trying to fetch cached %s\n", filename);
1078 if (is_file_exist(filename)) {
1079 /* see whether the local file represents the whole message
1080 * or not. As the IMAP server reports size with \r chars,
1081 * we have to update the local file (UNIX \n only) size */
1082 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1083 guint have_size = -1;
1086 debug_print("message %d has been already %scached.\n", uid,
1087 MSG_IS_FULLY_CACHED(cached->flags) ? "fully ":"");
1089 if (!cached || !MSG_IS_FULLY_CACHED(cached->flags)) {
1090 have_size = get_file_size_with_crs(filename);
1091 if (cached && (cached->size <= have_size || !body)) {
1092 procmsg_msginfo_free(cached);
1093 ok = file_strip_crs(filename);
1094 if (ok == 0 && cached && cached->size <= have_size) {
1095 /* we have it all and stripped */
1096 debug_print("...fully cached in fact; setting flag.\n");
1097 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1100 } else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
1101 debug_print("message not cached and file recent, considering file complete\n");
1102 ok = file_strip_crs(filename);
1106 procmsg_msginfo_free(cached);
1109 if (cached && MSG_IS_FULLY_CACHED(cached->flags)) {
1110 procmsg_msginfo_free(cached);
1114 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1116 procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1117 procmsg_msginfo_free(cached);
1121 debug_print("getting session...\n");
1122 session = imap_session_get(folder);
1129 debug_print("IMAP fetching messages\n");
1130 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
1131 NULL, NULL, NULL, NULL, FALSE);
1132 if (ok != IMAP_SUCCESS) {
1133 g_warning("can't select mailbox %s\n", item->path);
1135 unlock_session(session);
1136 if (ok == MAILIMAP_ERROR_STREAM) {
1137 imap_disc_session_destroy(folder);
1143 debug_print("getting message %d...\n", uid);
1144 ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
1146 if (ok != IMAP_SUCCESS) {
1147 g_warning("can't fetch message %d\n", uid);
1149 unlock_session(session);
1150 if (ok == MAILIMAP_ERROR_STREAM) {
1151 imap_disc_session_destroy(folder);
1157 unlock_session(session);
1158 ok = file_strip_crs(filename);
1160 if (ok == 0 && headers && body) {
1161 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1163 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1164 procmsg_msginfo_free(cached);
1166 } else if (ok == -1) {
1167 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1169 procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1170 procmsg_msginfo_free(cached);
1176 static gboolean imap_is_msg_fully_cached(Folder *folder, FolderItem *item, gint uid)
1178 gchar *path, *filename;
1180 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1185 if (MSG_IS_FULLY_CACHED(cached->flags)) {
1186 procmsg_msginfo_free(cached);
1189 path = folder_item_get_path(item);
1190 if (!is_dir_exist(path))
1193 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1195 if (is_file_exist(filename)) {
1196 if (cached && cached->total_size == cached->size) {
1199 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1202 size = get_file_size_with_crs(filename);
1205 if (cached && size >= cached->size) {
1206 cached->total_size = cached->size;
1207 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1208 procmsg_msginfo_free(cached);
1212 procmsg_msginfo_free(cached);
1216 void imap_cache_msg(FolderItem *item, gint msgnum)
1218 Folder *folder = NULL;
1222 folder = item->folder;
1224 if (!imap_is_msg_fully_cached(folder, item, msgnum)) {
1225 gchar *tmp = imap_fetch_msg_full(folder, item, msgnum, TRUE, TRUE);
1226 debug_print("fetched %s\n", tmp);
1231 static gint imap_add_msg(Folder *folder, FolderItem *dest,
1232 const gchar *file, MsgFlags *flags)
1236 MsgFileInfo fileinfo;
1238 g_return_val_if_fail(file != NULL, -1);
1240 fileinfo.msginfo = NULL;
1241 fileinfo.file = (gchar *)file;
1242 fileinfo.flags = flags;
1243 file_list.data = &fileinfo;
1244 file_list.next = NULL;
1246 ret = imap_add_msgs(folder, dest, &file_list, NULL);
1250 static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
1251 GRelation *relation)
1254 IMAPSession *session;
1255 guint32 last_uid = 0;
1257 MsgFileInfo *fileinfo;
1259 gint curnum = 0, total = 0;
1260 gboolean missing_uids = FALSE;
1262 g_return_val_if_fail(folder != NULL, -1);
1263 g_return_val_if_fail(dest != NULL, -1);
1264 g_return_val_if_fail(file_list != NULL, -1);
1266 debug_print("getting session...\n");
1267 session = imap_session_get(folder);
1271 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1273 statusbar_print_all(_("Adding messages..."));
1274 total = g_slist_length(file_list);
1275 for (cur = file_list; cur != NULL; cur = cur->next) {
1276 IMAPFlags iflags = 0;
1277 guint32 new_uid = 0;
1278 gchar *real_file = NULL;
1279 fileinfo = (MsgFileInfo *)cur->data;
1281 statusbar_progress_all(curnum, total, total < 10 ? 1:10);
1284 if (fileinfo->flags) {
1285 if (MSG_IS_MARKED(*fileinfo->flags))
1286 iflags |= IMAP_FLAG_FLAGGED;
1287 if (MSG_IS_REPLIED(*fileinfo->flags))
1288 iflags |= IMAP_FLAG_ANSWERED;
1289 if (!MSG_IS_UNREAD(*fileinfo->flags))
1290 iflags |= IMAP_FLAG_SEEN;
1293 if (real_file == NULL)
1294 real_file = g_strdup(fileinfo->file);
1296 if (folder_has_parent_of_type(dest, F_QUEUE) ||
1297 folder_has_parent_of_type(dest, F_OUTBOX) ||
1298 folder_has_parent_of_type(dest, F_DRAFT) ||
1299 folder_has_parent_of_type(dest, F_TRASH))
1300 iflags |= IMAP_FLAG_SEEN;
1302 ok = imap_cmd_append(session, destdir, real_file, iflags,
1305 if (ok != IMAP_SUCCESS) {
1306 g_warning("can't append message %s\n", real_file);
1309 unlock_session(session);
1310 statusbar_progress_all(0,0,0);
1311 statusbar_pop_all();
1312 if (ok == MAILIMAP_ERROR_STREAM) {
1313 imap_disc_session_destroy(folder);
1318 debug_print("appended new message as %d\n", new_uid);
1319 /* put the local file in the imapcache, so that we don't
1320 * have to fetch it back later. */
1323 missing_uids = TRUE;
1324 debug_print("Missing UID (0)\n");
1327 gchar *cache_path = folder_item_get_path(dest);
1328 if (!is_dir_exist(cache_path))
1329 make_dir_hier(cache_path);
1330 if (is_dir_exist(cache_path)) {
1331 gchar *cache_file = g_strconcat(
1332 cache_path, G_DIR_SEPARATOR_S,
1333 itos(new_uid), NULL);
1334 copy_file(real_file, cache_file, TRUE);
1335 debug_print("got UID %d, copied to cache: %s\n", new_uid, cache_file);
1342 if (relation != NULL)
1343 g_relation_insert(relation, fileinfo->msginfo != NULL ?
1344 (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
1345 GINT_TO_POINTER(new_uid));
1346 if (last_uid < new_uid) {
1353 statusbar_progress_all(0,0,0);
1354 statusbar_pop_all();
1356 unlock_session(session);
1360 imap_scan_required(folder, dest);
1362 session = imap_session_get(folder);
1366 unlock_session(session);
1370 ok = imap_select(session, IMAP_FOLDER(folder), dest->path,
1371 &a, NULL, NULL, NULL, FALSE);
1372 if (ok == MAILIMAP_ERROR_STREAM) {
1373 imap_disc_session_destroy(folder);
1380 static GSList *flatten_mailimap_set(struct mailimap_set * set)
1382 GSList *result = NULL;
1387 for (list = clist_begin(set->set_list); list; list = clist_next(list)) {
1388 struct mailimap_set_item *item = (struct mailimap_set_item *)clist_content(list);
1389 start = item->set_first;
1390 end = item->set_last;
1391 for (t = start; t <= end; t++) {
1392 result = g_slist_prepend(result, GINT_TO_POINTER(t));
1395 result = g_slist_reverse(result);
1396 if (debug_get_mode()) {
1397 debug_print("flat imap set: ");
1398 for (cur = result; cur; cur = cur->next) {
1399 debug_print("%d ", GPOINTER_TO_INT(cur->data));
1406 static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
1407 MsgInfoList *msglist, GRelation *relation)
1411 GSList *seq_list, *cur;
1413 IMAPSession *session;
1414 gint ok = IMAP_SUCCESS;
1415 GRelation *uid_mapping;
1417 gboolean single = FALSE;
1419 g_return_val_if_fail(folder != NULL, -1);
1420 g_return_val_if_fail(dest != NULL, -1);
1421 g_return_val_if_fail(msglist != NULL, -1);
1423 debug_print("getting session...\n");
1424 session = imap_session_get(folder);
1430 msginfo = (MsgInfo *)msglist->data;
1431 if (msglist->next == NULL)
1433 src = msginfo->folder;
1435 g_warning("the src folder is identical to the dest.\n");
1436 unlock_session(session);
1440 if (src->folder != dest->folder) {
1441 GSList *infolist = NULL, *cur;
1443 for (cur = msglist; cur; cur = cur->next) {
1444 msginfo = (MsgInfo *)cur->data;
1445 MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
1446 fileinfo->file = procmsg_get_message_file(msginfo);
1447 fileinfo->flags = &(msginfo->flags);
1448 infolist = g_slist_prepend(infolist, fileinfo);
1450 infolist = g_slist_reverse(infolist);
1451 unlock_session(session);
1452 res = folder_item_add_msgs(dest, infolist, FALSE);
1453 for (cur = infolist; cur; cur = cur->next) {
1454 MsgFileInfo *info = (MsgFileInfo *)cur->data;
1458 g_slist_free(infolist);
1462 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1463 NULL, NULL, NULL, NULL, FALSE);
1464 if (ok != IMAP_SUCCESS) {
1465 unlock_session(session);
1466 if (ok == MAILIMAP_ERROR_STREAM) {
1467 imap_disc_session_destroy(folder);
1473 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1474 seq_list = imap_get_lep_set_from_msglist(msglist);
1475 uid_mapping = g_relation_new(2);
1476 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1478 statusbar_print_all(_("Copying messages..."));
1479 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
1480 struct mailimap_set * seq_set;
1481 struct mailimap_set * source = NULL;
1482 struct mailimap_set * dest = NULL;
1483 seq_set = cur->data;
1485 debug_print("Copying messages from %s to %s ...\n",
1486 src->path, destdir);
1488 ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping,
1491 if (ok == MAILIMAP_ERROR_STREAM) {
1492 imap_disc_session_destroy(folder);
1495 if (ok == IMAP_SUCCESS) {
1496 if (relation && source && dest) {
1497 GSList *s_list = flatten_mailimap_set(source);
1498 GSList *d_list = flatten_mailimap_set(dest);
1499 GSList *s_cur, *d_cur;
1500 if (g_slist_length(s_list) == g_slist_length(d_list)) {
1502 for (s_cur = s_list, d_cur = d_list;
1504 s_cur = s_cur->next, d_cur = d_cur->next) {
1505 g_relation_insert(uid_mapping, s_cur->data, d_cur->data);
1509 debug_print("hhhmm, source list length != dest list length.\n");
1511 g_slist_free(s_list);
1512 g_slist_free(d_list);
1518 mailimap_set_free(source);
1520 mailimap_set_free(dest);
1522 if (ok != IMAP_SUCCESS) {
1523 g_relation_destroy(uid_mapping);
1524 imap_lep_set_free(seq_list);
1525 unlock_session(session);
1526 statusbar_pop_all();
1531 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
1532 MsgInfo *msginfo = (MsgInfo *)cur->data;
1535 tuples = g_relation_select(uid_mapping,
1536 GINT_TO_POINTER(msginfo->msgnum),
1538 if (tuples->len > 0) {
1539 gint num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1540 g_relation_insert(relation, msginfo,
1541 GINT_TO_POINTER(num));
1544 debug_print("copied message %d as %d\n", msginfo->msgnum, num);
1545 /* put the local file in the imapcache, so that we don't
1546 * have to fetch it back later. */
1548 gchar *cache_path = folder_item_get_path(msginfo->folder);
1549 gchar *real_file = g_strconcat(
1550 cache_path, G_DIR_SEPARATOR_S,
1551 itos(msginfo->msgnum), NULL);
1552 gchar *cache_file = NULL;
1554 cache_path = folder_item_get_path(dest);
1555 cache_file = g_strconcat(
1556 cache_path, G_DIR_SEPARATOR_S,
1558 if (!is_dir_exist(cache_path))
1559 make_dir_hier(cache_path);
1560 if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
1561 copy_file(real_file, cache_file, TRUE);
1562 debug_print("copied to cache: %s\n", cache_file);
1569 g_relation_insert(relation, msginfo,
1570 GINT_TO_POINTER(0));
1571 g_tuples_destroy(tuples);
1573 statusbar_pop_all();
1575 g_relation_destroy(uid_mapping);
1576 imap_lep_set_free(seq_list);
1580 IMAP_FOLDER_ITEM(dest)->lastuid = 0;
1581 IMAP_FOLDER_ITEM(dest)->uid_next = 0;
1582 g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
1583 IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
1585 unlock_session(session);
1586 imap_scan_required(folder, dest);
1587 if (ok == IMAP_SUCCESS)
1593 static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1597 g_return_val_if_fail(msginfo != NULL, -1);
1599 msglist.data = msginfo;
1600 msglist.next = NULL;
1602 return imap_copy_msgs(folder, dest, &msglist, NULL);
1605 static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
1606 MsgInfoList *msglist, GRelation *relation)
1611 g_return_val_if_fail(folder != NULL, -1);
1612 g_return_val_if_fail(dest != NULL, -1);
1613 g_return_val_if_fail(msglist != NULL, -1);
1615 msginfo = (MsgInfo *)msglist->data;
1616 g_return_val_if_fail(msginfo->folder != NULL, -1);
1618 ret = imap_do_copy_msgs(folder, dest, msglist, relation);
1623 static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
1624 MsgInfoList *msglist, GRelation *relation)
1626 gchar *destdir, *dir;
1627 GSList *numlist = NULL, *cur;
1629 IMAPSession *session;
1630 gint ok = IMAP_SUCCESS;
1631 GRelation *uid_mapping;
1633 g_return_val_if_fail(folder != NULL, -1);
1634 g_return_val_if_fail(dest != NULL, -1);
1635 g_return_val_if_fail(msglist != NULL, -1);
1637 debug_print("getting session...\n");
1638 session = imap_session_get(folder);
1643 msginfo = (MsgInfo *)msglist->data;
1645 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1646 NULL, NULL, NULL, NULL, FALSE);
1647 if (ok != IMAP_SUCCESS) {
1648 unlock_session(session);
1649 if (ok == MAILIMAP_ERROR_STREAM) {
1650 imap_disc_session_destroy(folder);
1656 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1657 for (cur = msglist; cur; cur = cur->next) {
1658 msginfo = (MsgInfo *)cur->data;
1659 if (!MSG_IS_DELETED(msginfo->flags))
1660 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
1662 numlist = g_slist_reverse(numlist);
1664 uid_mapping = g_relation_new(2);
1665 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1667 ok = imap_set_message_flags
1668 (session, numlist, IMAP_FLAG_DELETED, TRUE);
1669 if (ok != IMAP_SUCCESS) {
1670 log_warning(LOG_PROTOCOL, _("can't set deleted flags\n"));
1671 unlock_session(session);
1672 if (ok == MAILIMAP_ERROR_STREAM) {
1673 imap_disc_session_destroy(folder);
1678 ok = imap_cmd_expunge(session);
1679 if (ok != IMAP_SUCCESS) {
1680 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
1681 unlock_session(session);
1682 if (ok == MAILIMAP_ERROR_STREAM) {
1683 imap_disc_session_destroy(folder);
1689 dir = folder_item_get_path(msginfo->folder);
1690 if (is_dir_exist(dir)) {
1691 for (cur = msglist; cur; cur = cur->next) {
1692 msginfo = (MsgInfo *)cur->data;
1693 remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
1698 g_relation_destroy(uid_mapping);
1699 g_slist_free(numlist);
1702 unlock_session(session);
1703 if (ok == IMAP_SUCCESS)
1709 static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
1710 MsgInfoList *msglist, GRelation *relation)
1714 g_return_val_if_fail(folder != NULL, -1);
1715 g_return_val_if_fail(dest != NULL, -1);
1716 if (msglist == NULL)
1719 msginfo = (MsgInfo *)msglist->data;
1720 g_return_val_if_fail(msginfo->folder != NULL, -1);
1722 return imap_do_remove_msgs(folder, dest, msglist, relation);
1725 static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
1727 GSList *list = folder_item_get_msg_list(item);
1728 gint res = imap_remove_msgs(folder, item, list, NULL);
1729 procmsg_msg_list_free(list);
1733 static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
1736 /* TODO: properly implement this method */
1740 static gint imap_close(Folder *folder, FolderItem *item)
1745 static gint imap_scan_tree_real(Folder *folder, gboolean subs_only)
1747 FolderItem *item = NULL;
1748 IMAPSession *session;
1749 gchar *root_folder = NULL;
1751 g_return_val_if_fail(folder != NULL, -1);
1752 g_return_val_if_fail(folder->account != NULL, -1);
1754 debug_print("getting session...\n");
1755 session = imap_session_get(folder);
1757 if (!folder->node) {
1758 folder_tree_destroy(folder);
1759 item = folder_item_new(folder, folder->name, NULL);
1760 item->folder = folder;
1761 folder->node = item->node = g_node_new(item);
1766 if (folder->account->imap_dir && *folder->account->imap_dir) {
1771 Xstrdup_a(root_folder, folder->account->imap_dir, {unlock_session(session);return -1;});
1772 extract_quote(root_folder, '"');
1773 subst_char(root_folder,
1774 imap_get_path_separator(session, IMAP_FOLDER(folder),
1777 strtailchomp(root_folder, '/');
1778 real_path = imap_get_real_path
1779 (session, IMAP_FOLDER(folder), root_folder);
1780 debug_print("IMAP root directory: %s\n", real_path);
1782 /* check if root directory exist */
1784 r = imap_threaded_list(session->folder, "", real_path,
1786 if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
1787 if (!folder->node) {
1788 item = folder_item_new(folder, folder->name, NULL);
1789 item->folder = folder;
1790 folder->node = item->node = g_node_new(item);
1792 unlock_session(session);
1795 mailimap_list_result_free(lep_list);
1801 item = FOLDER_ITEM(folder->node->data);
1803 if (item && !item->path && root_folder) {
1804 item->path = g_strdup(root_folder);
1807 if (!item || ((item->path || root_folder) &&
1808 strcmp2(item->path, root_folder) != 0)) {
1809 folder_tree_destroy(folder);
1810 item = folder_item_new(folder, folder->name, root_folder);
1811 item->folder = folder;
1812 folder->node = item->node = g_node_new(item);
1815 imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data), subs_only);
1816 imap_create_missing_folders(folder);
1817 unlock_session(session);
1822 static gint imap_scan_tree(Folder *folder)
1824 gboolean subs_only = FALSE;
1825 if (folder->account) {
1826 debug_print(" scanning only subs %d\n", folder->account->imap_subsonly);
1827 subs_only = folder->account->imap_subsonly;
1829 return imap_scan_tree_real(folder, subs_only);
1832 static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item, gboolean subs_only)
1835 IMAPFolder *imapfolder;
1836 FolderItem *new_item;
1837 GSList *item_list, *cur;
1840 gchar *wildcard_path;
1846 g_return_val_if_fail(item != NULL, -1);
1847 g_return_val_if_fail(item->folder != NULL, -1);
1848 g_return_val_if_fail(item->no_sub == FALSE, -1);
1850 folder = item->folder;
1851 imapfolder = IMAP_FOLDER(folder);
1853 separator = imap_get_path_separator(session, imapfolder, item->path);
1855 if (folder->ui_func)
1856 folder->ui_func(folder, item, folder->ui_func_data);
1859 wildcard[0] = separator;
1862 real_path = imap_get_real_path(session, imapfolder, item->path);
1866 real_path = g_strdup("");
1869 Xstrcat_a(wildcard_path, real_path, wildcard,
1870 {g_free(real_path); return IMAP_ERROR;});
1874 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
1876 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
1878 if (r != MAILIMAP_NO_ERROR) {
1882 item_list = imap_list_from_lep(imapfolder,
1883 lep_list, real_path, FALSE);
1884 mailimap_list_result_free(lep_list);
1889 node = item->node->children;
1890 while (node != NULL) {
1891 FolderItem *old_item = FOLDER_ITEM(node->data);
1892 GNode *next = node->next;
1895 for (cur = item_list; cur != NULL; cur = cur->next) {
1896 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1897 if (!strcmp2(old_item->path, cur_item->path)) {
1898 new_item = cur_item;
1903 if (old_item && old_item->path && !strcmp(old_item->path, "INBOX")) {
1904 debug_print("not removing INBOX\n");
1906 debug_print("folder '%s' not found. removing...\n",
1908 folder_item_remove(old_item);
1911 old_item->no_sub = new_item->no_sub;
1912 old_item->no_select = new_item->no_select;
1913 if (old_item->no_sub == TRUE && node->children) {
1914 debug_print("folder '%s' doesn't have "
1915 "subfolders. removing...\n",
1917 folder_item_remove_children(old_item);
1924 for (cur = item_list; cur != NULL; cur = cur->next) {
1925 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1928 for (node = item->node->children; node != NULL;
1929 node = node->next) {
1930 if (!strcmp2(FOLDER_ITEM(node->data)->path,
1932 new_item = FOLDER_ITEM(node->data);
1933 folder_item_destroy(cur_item);
1939 new_item = cur_item;
1940 debug_print("new folder '%s' found.\n", new_item->path);
1941 folder_item_append(item, new_item);
1944 if (!strcmp(new_item->path, "INBOX")) {
1945 new_item->stype = F_INBOX;
1946 folder->inbox = new_item;
1947 } else if (!folder_item_parent(item) || item->stype == F_INBOX) {
1950 base = g_path_get_basename(new_item->path);
1952 if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
1953 new_item->stype = F_OUTBOX;
1954 folder->outbox = new_item;
1955 } else if (!folder->draft && !g_ascii_strcasecmp(base, "Drafts")) {
1956 new_item->stype = F_DRAFT;
1957 folder->draft = new_item;
1958 } else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
1959 new_item->stype = F_QUEUE;
1960 folder->queue = new_item;
1961 } else if (!folder->trash && !g_ascii_strcasecmp(base, "Trash")) {
1962 new_item->stype = F_TRASH;
1963 folder->trash = new_item;
1968 if (new_item->no_sub == FALSE)
1969 imap_scan_tree_recursive(session, new_item, subs_only);
1972 g_slist_free(item_list);
1974 return IMAP_SUCCESS;
1977 GList *imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
1979 IMAPSession *session = imap_session_get(folder);
1981 gchar *wildcard_path;
1985 GSList *item_list = NULL, *cur;
1986 GList *child_list = NULL, *tmplist = NULL;
1987 GSList *sub_list = NULL;
1993 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
1996 wildcard[0] = separator;
1999 real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2003 real_path = g_strdup("");
2006 Xstrcat_a(wildcard_path, real_path, wildcard,
2007 {g_free(real_path); return NULL;});
2011 statusbar_print_all(_("Looking for unsubscribed folders in %s..."),
2012 item->path?item->path:item->name);
2014 statusbar_print_all(_("Looking for subfolders of %s..."),
2015 item->path?item->path:item->name);
2017 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
2019 statusbar_pop_all();
2022 item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2023 lep_list, real_path, FALSE);
2024 mailimap_list_result_free(lep_list);
2026 for (cur = item_list; cur != NULL; cur = cur->next) {
2027 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2029 tmplist = imap_scan_subtree(folder, cur_item,
2030 unsubs_only, recursive);
2032 child_list = g_list_concat(child_list, tmplist);
2034 child_list = g_list_prepend(child_list,
2035 imap_get_real_path(session,
2036 IMAP_FOLDER(folder), cur_item->path));
2038 folder_item_destroy(cur_item);
2040 child_list = g_list_reverse(child_list);
2041 g_slist_free(item_list);
2044 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
2046 statusbar_pop_all();
2049 sub_list = imap_list_from_lep(IMAP_FOLDER(folder),
2050 lep_list, real_path, FALSE);
2051 mailimap_list_result_free(lep_list);
2053 for (cur = sub_list; cur != NULL; cur = cur->next) {
2054 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2055 GList *oldlitem = NULL;
2056 gchar *tmp = imap_get_real_path(session,
2057 IMAP_FOLDER(folder), cur_item->path);
2058 folder_item_destroy(cur_item);
2059 oldlitem = g_list_find_custom(
2060 child_list, tmp, (GCompareFunc)strcmp2);
2062 child_list = g_list_remove_link(child_list, oldlitem);
2063 g_free(oldlitem->data);
2064 g_list_free(oldlitem);
2070 statusbar_pop_all();
2075 static gint imap_create_tree(Folder *folder)
2077 g_return_val_if_fail(folder != NULL, -1);
2078 g_return_val_if_fail(folder->node != NULL, -1);
2079 g_return_val_if_fail(folder->node->data != NULL, -1);
2080 g_return_val_if_fail(folder->account != NULL, -1);
2082 imap_scan_tree(folder);
2083 imap_create_missing_folders(folder);
2088 static void imap_create_missing_folders(Folder *folder)
2090 g_return_if_fail(folder != NULL);
2093 folder->inbox = imap_create_special_folder
2094 (folder, F_INBOX, "INBOX");
2096 folder->trash = imap_create_special_folder
2097 (folder, F_TRASH, "Trash");
2099 folder->queue = imap_create_special_folder
2100 (folder, F_QUEUE, "Queue");
2101 if (!folder->outbox)
2102 folder->outbox = imap_create_special_folder
2103 (folder, F_OUTBOX, "Sent");
2105 folder->draft = imap_create_special_folder
2106 (folder, F_DRAFT, "Drafts");
2109 static FolderItem *imap_create_special_folder(Folder *folder,
2110 SpecialFolderItemType stype,
2114 FolderItem *new_item;
2116 g_return_val_if_fail(folder != NULL, NULL);
2117 g_return_val_if_fail(folder->node != NULL, NULL);
2118 g_return_val_if_fail(folder->node->data != NULL, NULL);
2119 g_return_val_if_fail(folder->account != NULL, NULL);
2120 g_return_val_if_fail(name != NULL, NULL);
2122 item = FOLDER_ITEM(folder->node->data);
2123 new_item = imap_create_folder(folder, item, name);
2126 g_warning("Can't create '%s'\n", name);
2127 if (!folder->inbox) return NULL;
2129 new_item = imap_create_folder(folder, folder->inbox, name);
2131 g_warning("Can't create '%s' under INBOX\n", name);
2133 new_item->stype = stype;
2135 new_item->stype = stype;
2140 static gchar *imap_folder_get_path(Folder *folder)
2144 g_return_val_if_fail(folder != NULL, NULL);
2145 g_return_val_if_fail(folder->account != NULL, NULL);
2147 folder_path = g_strconcat(get_imap_cache_dir(),
2149 folder->account->recv_server,
2151 folder->account->userid,
2157 static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
2159 gchar *folder_path, *path;
2161 g_return_val_if_fail(folder != NULL, NULL);
2162 g_return_val_if_fail(item != NULL, NULL);
2163 folder_path = imap_folder_get_path(folder);
2165 g_return_val_if_fail(folder_path != NULL, NULL);
2166 if (folder_path[0] == G_DIR_SEPARATOR) {
2168 path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
2171 path = g_strdup(folder_path);
2174 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2175 folder_path, G_DIR_SEPARATOR_S,
2178 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2181 g_free(folder_path);
2186 static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
2189 gchar *dirpath, *imap_path;
2190 IMAPSession *session;
2191 FolderItem *new_item;
2196 gboolean no_select = FALSE, no_sub = FALSE;
2197 gboolean exist = FALSE;
2199 g_return_val_if_fail(folder != NULL, NULL);
2200 g_return_val_if_fail(folder->account != NULL, NULL);
2201 g_return_val_if_fail(parent != NULL, NULL);
2202 g_return_val_if_fail(name != NULL, NULL);
2204 debug_print("getting session...\n");
2205 session = imap_session_get(folder);
2210 if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
2211 dirpath = g_strdup(name);
2212 }else if (parent->path)
2213 dirpath = g_strconcat(parent->path, "/", name, NULL);
2214 else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
2215 dirpath = g_strdup(name);
2216 else if (folder->account->imap_dir && *folder->account->imap_dir) {
2219 Xstrdup_a(imap_dir, folder->account->imap_dir, {unlock_session(session);return NULL;});
2220 strtailchomp(imap_dir, '/');
2221 dirpath = g_strconcat(imap_dir, "/", name, NULL);
2223 dirpath = g_strdup(name);
2227 /* keep trailing directory separator to create a folder that contains
2229 imap_path = imap_utf8_to_modified_utf7(dirpath);
2231 strtailchomp(dirpath, '/');
2232 Xstrdup_a(new_name, name, {
2234 unlock_session(session);
2237 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path);
2238 imap_path_separator_subst(imap_path, separator);
2239 /* remove trailing / for display */
2240 strtailchomp(new_name, '/');
2242 if (strcmp(dirpath, "INBOX") != 0) {
2247 argbuf = g_ptr_array_new();
2248 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2249 if (r != MAILIMAP_NO_ERROR) {
2250 log_warning(LOG_PROTOCOL, _("can't create mailbox: LIST failed\n"));
2253 ptr_array_free_strings(argbuf);
2254 g_ptr_array_free(argbuf, TRUE);
2255 unlock_session(session);
2259 if (clist_count(lep_list) > 0)
2261 mailimap_list_result_free(lep_list);
2264 ok = imap_cmd_create(session, imap_path);
2265 if (ok != IMAP_SUCCESS) {
2266 log_warning(LOG_PROTOCOL, _("can't create mailbox\n"));
2269 unlock_session(session);
2270 if (ok == MAILIMAP_ERROR_STREAM) {
2271 imap_disc_session_destroy(folder);
2276 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2277 if (r == MAILIMAP_NO_ERROR) {
2278 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2279 lep_list, dirpath, TRUE);
2281 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2282 no_select = cur_item->no_select;
2283 no_sub = cur_item->no_sub;
2284 g_slist_free(item_list);
2286 mailimap_list_result_free(lep_list);
2289 imap_threaded_subscribe(folder, imap_path, TRUE);
2293 /* just get flags */
2294 r = imap_threaded_list(folder, "", "INBOX", &lep_list);
2295 if (r == MAILIMAP_NO_ERROR) {
2296 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2297 lep_list, dirpath, TRUE);
2299 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2300 no_select = cur_item->no_select;
2301 no_sub = cur_item->no_sub;
2302 g_slist_free(item_list);
2304 mailimap_list_result_free(lep_list);
2308 new_item = folder_item_new(folder, new_name, dirpath);
2309 new_item->no_select = no_select;
2310 new_item->no_sub = no_sub;
2311 folder_item_append(parent, new_item);
2315 dirpath = folder_item_get_path(new_item);
2316 if (!is_dir_exist(dirpath))
2317 make_dir_hier(dirpath);
2319 unlock_session(session);
2322 /* folder existed, scan it */
2323 imap_scan_required(folder, new_item);
2324 folder_item_scan_full(new_item, FALSE);
2330 static gint imap_rename_folder(Folder *folder, FolderItem *item,
2335 gchar *real_oldpath;
2336 gchar *real_newpath;
2338 gchar *old_cache_dir;
2339 gchar *new_cache_dir;
2340 IMAPSession *session;
2343 gint exists, recent, unseen;
2344 guint32 uid_validity;
2346 g_return_val_if_fail(folder != NULL, -1);
2347 g_return_val_if_fail(item != NULL, -1);
2348 g_return_val_if_fail(item->path != NULL, -1);
2349 g_return_val_if_fail(name != NULL, -1);
2351 debug_print("getting session...\n");
2352 session = imap_session_get(folder);
2357 if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path)) != NULL) {
2358 g_warning(_("New folder name must not contain the namespace "
2360 unlock_session(session);
2364 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2366 g_free(session->mbox);
2367 session->mbox = NULL;
2368 session->exists = 0;
2369 session->recent = 0;
2370 session->expunge = 0;
2371 ok = imap_cmd_examine(session, "INBOX",
2372 &exists, &recent, &unseen, &uid_validity, FALSE);
2373 if (ok != IMAP_SUCCESS) {
2374 g_free(real_oldpath);
2375 unlock_session(session);
2376 if (ok == MAILIMAP_ERROR_STREAM) {
2377 imap_disc_session_destroy(folder);
2383 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
2384 if (strchr(item->path, G_DIR_SEPARATOR)) {
2385 dirpath = g_path_get_dirname(item->path);
2386 newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
2389 newpath = g_strdup(name);
2391 real_newpath = imap_utf8_to_modified_utf7(newpath);
2392 imap_path_separator_subst(real_newpath, separator);
2394 ok = imap_cmd_rename(session, real_oldpath, real_newpath);
2395 if (ok != IMAP_SUCCESS) {
2396 log_warning(LOG_PROTOCOL, _("can't rename mailbox: %s to %s\n"),
2397 real_oldpath, real_newpath);
2398 g_free(real_oldpath);
2400 g_free(real_newpath);
2401 unlock_session(session);
2402 if (ok == MAILIMAP_ERROR_STREAM) {
2403 imap_disc_session_destroy(folder);
2409 item->name = g_strdup(name);
2411 old_cache_dir = folder_item_get_path(item);
2413 paths[0] = g_strdup(item->path);
2415 g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
2416 imap_rename_folder_func, paths);
2418 if (is_dir_exist(old_cache_dir)) {
2419 new_cache_dir = folder_item_get_path(item);
2420 if (rename(old_cache_dir, new_cache_dir) < 0) {
2421 FILE_OP_ERROR(old_cache_dir, "rename");
2423 g_free(new_cache_dir);
2426 g_free(old_cache_dir);
2429 g_free(real_oldpath);
2430 g_free(real_newpath);
2431 unlock_session(session);
2435 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
2439 IMAPSession *session;
2440 debug_print("getting session...\n");
2442 session = imap_session_get(folder);
2446 if (item && item->path) {
2447 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2450 if (!strcmp(path, "INBOX") && sub == FALSE)
2452 debug_print("%ssubscribing %s\n", sub?"":"un", path);
2453 r = imap_threaded_subscribe(folder, path, sub);
2456 r = imap_threaded_subscribe(folder, rpath, sub);
2462 static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
2465 IMAPSession *session;
2468 gboolean selected_folder;
2470 g_return_val_if_fail(folder != NULL, -1);
2471 g_return_val_if_fail(item != NULL, -1);
2472 g_return_val_if_fail(item->path != NULL, -1);
2474 debug_print("getting session...\n");
2475 session = imap_session_get(folder);
2479 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2481 imap_threaded_subscribe(folder, path, FALSE);
2483 selected_folder = (session->mbox != NULL) &&
2484 (!strcmp(session->mbox, item->path));
2485 if (selected_folder) {
2486 ok = imap_cmd_close(session);
2487 if (ok != MAILIMAP_NO_ERROR) {
2488 debug_print("close err %d\n", ok);
2489 if (ok == MAILIMAP_ERROR_STREAM) {
2490 imap_disc_session_destroy(folder);
2496 ok = imap_cmd_delete(session, path);
2497 if (ok != IMAP_SUCCESS) {
2498 gchar *tmp = g_strdup_printf("%s%c", path,
2499 imap_get_path_separator(session, IMAP_FOLDER(folder), path));
2502 ok = imap_cmd_delete(session, path);
2505 if (ok != IMAP_SUCCESS) {
2506 log_warning(LOG_PROTOCOL, _("can't delete mailbox\n"));
2508 unlock_session(session);
2509 if (ok == MAILIMAP_ERROR_STREAM) {
2510 imap_disc_session_destroy(folder);
2517 cache_dir = folder_item_get_path(item);
2518 if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
2519 g_warning("can't remove directory '%s'\n", cache_dir);
2521 folder_item_remove(item);
2522 unlock_session(session);
2526 static gint imap_remove_folder(Folder *folder, FolderItem *item)
2530 g_return_val_if_fail(item != NULL, -1);
2531 g_return_val_if_fail(item->folder != NULL, -1);
2532 g_return_val_if_fail(item->node != NULL, -1);
2534 node = item->node->children;
2535 while (node != NULL) {
2537 if (imap_remove_folder(folder, FOLDER_ITEM(node->data)) < 0)
2541 debug_print("IMAP removing %s\n", item->path);
2543 if (imap_remove_all_msg(folder, item) < 0)
2545 return imap_remove_folder_real(folder, item);
2548 typedef struct _uncached_data {
2549 IMAPSession *session;
2551 MsgNumberList *numlist;
2557 static void *imap_get_uncached_messages_thread(void *data)
2559 uncached_data *stuff = (uncached_data *)data;
2560 IMAPSession *session = stuff->session;
2561 FolderItem *item = stuff->item;
2562 MsgNumberList *numlist = stuff->numlist;
2564 GSList *newlist = NULL;
2565 GSList *llast = NULL;
2566 GSList *seq_list, *cur;
2568 debug_print("uncached_messages\n");
2570 if (session == NULL || item == NULL || item->folder == NULL
2571 || FOLDER_CLASS(item->folder) != &imap_class) {
2576 seq_list = imap_get_lep_set_from_numlist(numlist);
2577 debug_print("get msgs info\n");
2578 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2579 struct mailimap_set * imapset;
2585 if (session->cancelled)
2588 imapset = cur->data;
2590 r = imap_threaded_fetch_env(session->folder,
2591 imapset, &env_list);
2592 if (r != MAILIMAP_NO_ERROR)
2595 session_set_access_time(SESSION(session));
2598 for(i = 0 ; i < carray_count(env_list) ; i ++) {
2599 struct imap_fetch_env_info * info;
2602 info = carray_get(env_list, i);
2603 msginfo = imap_envelope_from_lep(info, item);
2604 if (msginfo == NULL)
2606 msginfo->folder = item;
2608 llast = newlist = g_slist_append(newlist, msginfo);
2610 llast = g_slist_append(llast, msginfo);
2611 llast = llast->next;
2616 imap_fetch_env_free(env_list);
2619 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2620 struct mailimap_set * imapset;
2622 imapset = cur->data;
2623 mailimap_set_free(imapset);
2626 session_set_access_time(SESSION(session));
2631 #define MAX_MSG_NUM 50
2633 static GSList *imap_get_uncached_messages(IMAPSession *session,
2635 MsgNumberList *numlist)
2637 GSList *result = NULL;
2639 uncached_data *data = g_new0(uncached_data, 1);
2644 data->total = g_slist_length(numlist);
2645 debug_print("messages list : %i\n", data->total);
2647 while (cur != NULL) {
2648 GSList * partial_result;
2656 while (count < MAX_MSG_NUM) {
2661 if (newlist == NULL)
2662 llast = newlist = g_slist_append(newlist, p);
2664 llast = g_slist_append(llast, p);
2665 llast = llast->next;
2675 data->session = session;
2677 data->numlist = newlist;
2680 if (prefs_common.work_offline &&
2681 !inc_offline_should_override(FALSE,
2682 _("Claws Mail needs network access in order "
2683 "to access the IMAP server."))) {
2689 (GSList *)imap_get_uncached_messages_thread(data);
2691 statusbar_progress_all(data->cur,data->total, 1);
2693 g_slist_free(newlist);
2695 result = g_slist_concat(result, partial_result);
2699 statusbar_progress_all(0,0,0);
2700 statusbar_pop_all();
2705 static void imap_delete_all_cached_messages(FolderItem *item)
2709 g_return_if_fail(item != NULL);
2710 g_return_if_fail(item->folder != NULL);
2711 g_return_if_fail(FOLDER_CLASS(item->folder) == &imap_class);
2713 debug_print("Deleting all cached messages...\n");
2715 dir = folder_item_get_path(item);
2716 if (is_dir_exist(dir))
2717 remove_all_numbered_files(dir);
2720 debug_print("done.\n");
2723 gchar imap_get_path_separator_for_item(FolderItem *item)
2725 Folder *folder = NULL;
2726 IMAPFolder *imap_folder = NULL;
2727 IMAPSession *session = NULL;
2732 folder = item->folder;
2737 imap_folder = IMAP_FOLDER(folder);
2742 debug_print("getting session...");
2743 session = imap_session_get(FOLDER(folder));
2744 result = imap_get_path_separator(session, imap_folder, item->path);
2745 unlock_session(session);
2749 static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder)
2753 gchar separator = '\0';
2755 g_return_val_if_fail(session != NULL, '/');
2756 r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
2758 if (r != MAILIMAP_NO_ERROR) {
2759 log_warning(LOG_PROTOCOL, _("LIST failed\n"));
2763 if (clist_count(lep_list) > 0) {
2764 clistiter * iter = clist_begin(lep_list);
2765 struct mailimap_mailbox_list * mb;
2766 mb = clist_content(iter);
2768 separator = mb->mb_delimiter;
2769 debug_print("got separator: %c\n", folder->last_seen_separator);
2771 mailimap_list_result_free(lep_list);
2775 static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2777 gchar separator = '/';
2779 if (folder->last_seen_separator == 0) {
2780 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "");
2783 if (folder->last_seen_separator == 0) {
2784 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX");
2787 if (folder->last_seen_separator != 0) {
2788 debug_print("using separator: %c\n", folder->last_seen_separator);
2789 return folder->last_seen_separator;
2795 static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2800 g_return_val_if_fail(folder != NULL, NULL);
2801 g_return_val_if_fail(path != NULL, NULL);
2803 real_path = imap_utf8_to_modified_utf7(path);
2804 separator = imap_get_path_separator(session, folder, path);
2805 imap_path_separator_subst(real_path, separator);
2810 static gint imap_set_message_flags(IMAPSession *session,
2811 MsgNumberList *numlist,
2819 seq_list = imap_get_lep_set_from_numlist(numlist);
2821 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
2822 struct mailimap_set * imapset;
2824 imapset = cur->data;
2826 ok = imap_cmd_store(session, imapset,
2830 imap_lep_set_free(seq_list);
2832 return IMAP_SUCCESS;
2835 typedef struct _select_data {
2836 IMAPSession *session;
2841 guint32 *uid_validity;
2845 static gint imap_select(IMAPSession *session, IMAPFolder *folder,
2847 gint *exists, gint *recent, gint *unseen,
2848 guint32 *uid_validity, gboolean block)
2852 gint exists_, recent_, unseen_;
2853 guint32 uid_validity_;
2855 if (!exists && !recent && !unseen && !uid_validity) {
2856 if (session->mbox && strcmp(session->mbox, path) == 0)
2857 return IMAP_SUCCESS;
2866 uid_validity = &uid_validity_;
2868 g_free(session->mbox);
2869 session->mbox = NULL;
2870 session->exists = 0;
2871 session->recent = 0;
2872 session->expunge = 0;
2874 real_path = imap_get_real_path(session, folder, path);
2876 ok = imap_cmd_select(session, real_path,
2877 exists, recent, unseen, uid_validity, block);
2878 if (ok != IMAP_SUCCESS) {
2879 log_warning(LOG_PROTOCOL, _("can't select folder: %s\n"), real_path);
2880 if (ok == MAILIMAP_ERROR_STREAM) {
2881 imap_disc_session_destroy(FOLDER(folder));
2885 session->mbox = g_strdup(path);
2886 session->folder_content_changed = FALSE;
2887 session->exists = *exists;
2888 session->recent = *recent;
2889 session->expunge = 0;
2890 session->unseen = *unseen;
2891 session->uid_validity = *uid_validity;
2892 debug_print("select: exists %d recent %d expunge %d uid_validity %d\n",
2893 session->exists, session->recent, session->expunge,
2894 session->uid_validity);
2901 static gint imap_status(IMAPSession *session, IMAPFolder *folder,
2902 const gchar *path, IMAPFolderItem *item,
2904 guint32 *uid_next, guint32 *uid_validity,
2905 gint *unseen, gboolean block)
2909 struct mailimap_mailbox_data_status * data_status;
2914 real_path = imap_get_real_path(session, folder, path);
2933 if (session->mbox != NULL &&
2934 !strcmp(session->mbox, item->item.path)) {
2935 r = imap_cmd_close(session);
2936 if (r != MAILIMAP_NO_ERROR) {
2937 debug_print("close err %d\n", r);
2942 r = imap_threaded_status(FOLDER(folder), real_path,
2943 &data_status, mask);
2946 if (r != MAILIMAP_NO_ERROR) {
2947 debug_print("status err %d\n", r);
2951 if (data_status->st_info_list == NULL) {
2952 mailimap_mailbox_data_status_free(data_status);
2953 debug_print("status->st_info_list == NULL\n");
2958 for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
2959 iter = clist_next(iter)) {
2960 struct mailimap_status_info * info;
2962 info = clist_content(iter);
2963 switch (info->st_att) {
2964 case MAILIMAP_STATUS_ATT_MESSAGES:
2966 * messages = info->st_value;
2967 got_values |= 1 << 0;
2971 case MAILIMAP_STATUS_ATT_UIDNEXT:
2973 * uid_next = info->st_value;
2974 got_values |= 1 << 2;
2978 case MAILIMAP_STATUS_ATT_UIDVALIDITY:
2980 * uid_validity = info->st_value;
2981 got_values |= 1 << 3;
2985 case MAILIMAP_STATUS_ATT_UNSEEN:
2987 * unseen = info->st_value;
2988 got_values |= 1 << 4;
2993 mailimap_mailbox_data_status_free(data_status);
2995 if (got_values != mask) {
2996 g_warning("status: incomplete values received (%d)\n", got_values);
2998 return IMAP_SUCCESS;
3001 static void imap_free_capabilities(IMAPSession *session)
3003 slist_free_strings(session->capability);
3004 g_slist_free(session->capability);
3005 session->capability = NULL;
3008 /* low-level IMAP4rev1 commands */
3010 static gint imap_cmd_login(IMAPSession *session,
3011 const gchar *user, const gchar *pass,
3017 if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
3018 gint ok = IMAP_ERROR;
3019 if (imap_has_capability(session, "STARTTLS")) {
3020 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
3021 log_warning(LOG_PROTOCOL, _("Server requires TLS to log in.\n"));
3022 ok = imap_cmd_starttls(session);
3023 if (ok != IMAP_SUCCESS) {
3024 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
3028 imap_free_capabilities(session);
3029 if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR) {
3030 log_warning(LOG_PROTOCOL, _("Can't refresh capabilities.\n"));
3035 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
3036 "server requires TLS, but Claws Mail "
3037 "has been compiled without OpenSSL "
3039 SESSION(session)->server);
3043 log_error(LOG_PROTOCOL, _("Server logins are disabled.\n"));
3048 log_print(LOG_PROTOCOL, "IMAP4> Logging %s to %s using %s\n",
3050 SESSION(session)->server,
3052 r = imap_threaded_login(session->folder, user, pass, type);
3053 if (r != MAILIMAP_NO_ERROR) {
3054 log_print(LOG_PROTOCOL, "IMAP4< Error logging in to %s\n",
3055 SESSION(session)->server);
3058 log_print(LOG_PROTOCOL, "IMAP4< Login to %s successful\n",
3059 SESSION(session)->server);
3065 static gint imap_cmd_noop(IMAPSession *session)
3068 unsigned int exists, recent, expunge, unseen, uidnext, uidval;
3070 r = imap_threaded_noop(session->folder, &exists, &recent, &expunge, &unseen, &uidnext, &uidval);
3071 if (r != MAILIMAP_NO_ERROR) {
3072 debug_print("noop err %d\n", r);
3076 session->folder_content_changed = FALSE;
3078 if ((exists && exists != session->exists)
3079 || (recent && recent != session->recent)
3080 || (expunge && expunge != session->expunge)
3081 || (unseen && unseen != session->unseen)) {
3082 session->folder_content_changed = TRUE;
3084 if (uidnext != 0 && uidnext != session->uid_next) {
3085 session->uid_next = uidnext;
3086 session->folder_content_changed = TRUE;
3088 if (uidval != 0 && uidval != session->uid_validity) {
3089 session->uid_validity = uidval;
3090 session->folder_content_changed = TRUE;
3093 session->exists = exists;
3094 session->recent = recent;
3095 session->expunge = expunge;
3096 session->unseen = unseen;
3098 session_set_access_time(SESSION(session));
3100 return IMAP_SUCCESS;
3103 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
3104 static gint imap_cmd_starttls(IMAPSession *session)
3108 r = imap_threaded_starttls(session->folder,
3109 SESSION(session)->server, SESSION(session)->port);
3110 if (r != MAILIMAP_NO_ERROR) {
3111 debug_print("starttls err %d\n", r);
3114 return IMAP_SUCCESS;
3118 static gint imap_cmd_select(IMAPSession *session, const gchar *folder,
3119 gint *exists, gint *recent, gint *unseen,
3120 guint32 *uid_validity, gboolean block)
3124 r = imap_threaded_select(session->folder, folder,
3125 exists, recent, unseen, uid_validity);
3126 if (r != MAILIMAP_NO_ERROR) {
3127 debug_print("select err %d\n", r);
3130 return IMAP_SUCCESS;
3133 static gint imap_cmd_close(IMAPSession *session)
3137 r = imap_threaded_close(session->folder);
3138 if (r != MAILIMAP_NO_ERROR) {
3139 debug_print("close err %d\n", r);
3142 g_free(session->mbox);
3143 session->mbox = NULL;
3144 session->exists = 0;
3145 session->recent = 0;
3146 session->expunge = 0;
3147 return IMAP_SUCCESS;
3150 static gint imap_cmd_examine(IMAPSession *session, const gchar *folder,
3151 gint *exists, gint *recent, gint *unseen,
3152 guint32 *uid_validity, gboolean block)
3156 r = imap_threaded_examine(session->folder, folder,
3157 exists, recent, unseen, uid_validity);
3158 if (r != MAILIMAP_NO_ERROR) {
3159 debug_print("examine err %d\n", r);
3163 return IMAP_SUCCESS;
3166 static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
3170 r = imap_threaded_create(session->folder, folder);
3171 if (r != MAILIMAP_NO_ERROR) {
3176 return IMAP_SUCCESS;
3179 static gint imap_cmd_rename(IMAPSession *session, const gchar *old_folder,
3180 const gchar *new_folder)
3184 r = imap_threaded_rename(session->folder, old_folder,
3186 if (r != MAILIMAP_NO_ERROR) {
3191 return IMAP_SUCCESS;
3194 static gint imap_cmd_delete(IMAPSession *session, const gchar *folder)
3199 r = imap_threaded_delete(session->folder, folder);
3200 if (r != MAILIMAP_NO_ERROR) {
3205 return IMAP_SUCCESS;
3208 typedef struct _fetch_data {
3209 IMAPSession *session;
3211 const gchar *filename;
3217 static void *imap_cmd_fetch_thread(void *data)
3219 fetch_data *stuff = (fetch_data *)data;
3220 IMAPSession *session = stuff->session;
3221 guint32 uid = stuff->uid;
3222 const gchar *filename = stuff->filename;
3226 r = imap_threaded_fetch_content(session->folder,
3230 r = imap_threaded_fetch_content(session->folder,
3233 if (r != MAILIMAP_NO_ERROR) {
3234 debug_print("fetch err %d\n", r);
3235 return GINT_TO_POINTER(IMAP_ERROR);
3237 return GINT_TO_POINTER(IMAP_SUCCESS);
3240 static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
3241 const gchar *filename, gboolean headers,
3244 fetch_data *data = g_new0(fetch_data, 1);
3247 data->session = session;
3249 data->filename = filename;
3250 data->headers = headers;
3253 if (prefs_common.work_offline &&
3254 !inc_offline_should_override(FALSE,
3255 _("Claws Mail needs network access in order "
3256 "to access the IMAP server."))) {
3260 statusbar_print_all(_("Fetching message..."));
3261 result = GPOINTER_TO_INT(imap_cmd_fetch_thread(data));
3262 statusbar_pop_all();
3268 static gint imap_cmd_append(IMAPSession *session, const gchar *destfolder,
3269 const gchar *file, IMAPFlags flags,
3272 struct mailimap_flag_list * flag_list;
3275 g_return_val_if_fail(file != NULL, IMAP_ERROR);
3277 flag_list = imap_flag_to_lep(flags);
3278 r = imap_threaded_append(session->folder, destfolder,
3279 file, flag_list, (int *)new_uid);
3280 mailimap_flag_list_free(flag_list);
3282 if (r != MAILIMAP_NO_ERROR) {
3283 debug_print("append err %d\n", r);
3286 return IMAP_SUCCESS;
3289 static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
3290 const gchar *destfolder, GRelation *uid_mapping,
3291 struct mailimap_set **source, struct mailimap_set **dest)
3295 g_return_val_if_fail(session != NULL, IMAP_ERROR);
3296 g_return_val_if_fail(set != NULL, IMAP_ERROR);
3297 g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
3299 r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
3300 if (r != MAILIMAP_NO_ERROR) {
3305 return IMAP_SUCCESS;
3308 static gint imap_cmd_store(IMAPSession *session, struct mailimap_set * set,
3309 IMAPFlags flags, int do_add)
3312 struct mailimap_flag_list * flag_list;
3313 struct mailimap_store_att_flags * store_att_flags;
3315 flag_list = imap_flag_to_lep(flags);
3319 mailimap_store_att_flags_new_add_flags_silent(flag_list);
3322 mailimap_store_att_flags_new_remove_flags_silent(flag_list);
3324 r = imap_threaded_store(session->folder, set, store_att_flags);
3325 mailimap_store_att_flags_free(store_att_flags);
3326 if (r != MAILIMAP_NO_ERROR) {
3331 return IMAP_SUCCESS;
3334 static gint imap_cmd_expunge(IMAPSession *session)
3338 if (prefs_common.work_offline &&
3339 !inc_offline_should_override(FALSE,
3340 _("Claws Mail needs network access in order "
3341 "to access the IMAP server."))) {
3345 r = imap_threaded_expunge(session->folder);
3346 if (r != MAILIMAP_NO_ERROR) {
3351 return IMAP_SUCCESS;
3354 static void imap_path_separator_subst(gchar *str, gchar separator)
3357 gboolean in_escape = FALSE;
3359 if (!separator || separator == '/') return;
3361 for (p = str; *p != '\0'; p++) {
3362 if (*p == '/' && !in_escape)
3364 else if (*p == '&' && *(p + 1) != '-' && !in_escape)
3366 else if (*p == '-' && in_escape)
3371 static gchar *imap_modified_utf7_to_utf8(const gchar *mutf7_str)
3373 static iconv_t cd = (iconv_t)-1;
3374 static gboolean iconv_ok = TRUE;
3377 size_t norm_utf7_len;
3379 gchar *to_str, *to_p;
3381 gboolean in_escape = FALSE;
3383 if (!iconv_ok) return g_strdup(mutf7_str);
3385 if (cd == (iconv_t)-1) {
3386 cd = iconv_open(CS_INTERNAL, CS_UTF_7);
3387 if (cd == (iconv_t)-1) {
3388 g_warning("iconv cannot convert UTF-7 to %s\n",
3391 return g_strdup(mutf7_str);
3395 /* modified UTF-7 to normal UTF-7 conversion */
3396 norm_utf7 = g_string_new(NULL);
3398 for (p = mutf7_str; *p != '\0'; p++) {
3399 /* replace: '&' -> '+',
3401 escaped ',' -> '/' */
3402 if (!in_escape && *p == '&') {
3403 if (*(p + 1) != '-') {
3404 g_string_append_c(norm_utf7, '+');
3407 g_string_append_c(norm_utf7, '&');
3410 } else if (in_escape && *p == ',') {
3411 g_string_append_c(norm_utf7, '/');
3412 } else if (in_escape && *p == '-') {
3413 g_string_append_c(norm_utf7, '-');
3416 g_string_append_c(norm_utf7, *p);
3420 norm_utf7_p = norm_utf7->str;
3421 norm_utf7_len = norm_utf7->len;
3422 to_len = strlen(mutf7_str) * 5;
3423 to_p = to_str = g_malloc(to_len + 1);
3425 if (iconv(cd, (ICONV_CONST gchar **)&norm_utf7_p, &norm_utf7_len,
3426 &to_p, &to_len) == -1) {
3427 g_warning(_("iconv cannot convert UTF-7 to %s\n"),
3428 conv_get_locale_charset_str());
3429 g_string_free(norm_utf7, TRUE);
3431 return g_strdup(mutf7_str);
3434 /* second iconv() call for flushing */
3435 iconv(cd, NULL, NULL, &to_p, &to_len);
3436 g_string_free(norm_utf7, TRUE);
3442 static gchar *imap_utf8_to_modified_utf7(const gchar *from)
3444 static iconv_t cd = (iconv_t)-1;
3445 static gboolean iconv_ok = TRUE;
3446 gchar *norm_utf7, *norm_utf7_p;
3447 size_t from_len, norm_utf7_len;
3449 gchar *from_tmp, *to, *p;
3450 gboolean in_escape = FALSE;
3452 if (!iconv_ok) return g_strdup(from);
3454 if (cd == (iconv_t)-1) {
3455 cd = iconv_open(CS_UTF_7, CS_INTERNAL);
3456 if (cd == (iconv_t)-1) {
3457 g_warning(_("iconv cannot convert %s to UTF-7\n"),
3460 return g_strdup(from);
3464 /* UTF-8 to normal UTF-7 conversion */
3465 Xstrdup_a(from_tmp, from, return g_strdup(from));
3466 from_len = strlen(from);
3467 norm_utf7_len = from_len * 5;
3468 Xalloca(norm_utf7, norm_utf7_len + 1, return g_strdup(from));
3469 norm_utf7_p = norm_utf7;
3471 #define IS_PRINT(ch) (isprint(ch) && IS_ASCII(ch))
3473 while (from_len > 0) {
3474 if (*from_tmp == '+') {
3475 *norm_utf7_p++ = '+';
3476 *norm_utf7_p++ = '-';
3480 } else if (IS_PRINT(*(guchar *)from_tmp)) {
3481 /* printable ascii char */
3482 *norm_utf7_p = *from_tmp;
3488 size_t conv_len = 0;
3490 /* unprintable char: convert to UTF-7 */
3492 while (!IS_PRINT(*(guchar *)p) && conv_len < from_len) {
3493 conv_len += g_utf8_skip[*(guchar *)p];
3494 p += g_utf8_skip[*(guchar *)p];
3497 from_len -= conv_len;
3498 if (iconv(cd, (ICONV_CONST gchar **)&from_tmp,
3500 &norm_utf7_p, &norm_utf7_len) == -1) {
3501 g_warning(_("iconv cannot convert UTF-8 to UTF-7\n"));
3502 return g_strdup(from);
3505 /* second iconv() call for flushing */
3506 iconv(cd, NULL, NULL, &norm_utf7_p, &norm_utf7_len);
3512 *norm_utf7_p = '\0';
3513 to_str = g_string_new(NULL);
3514 for (p = norm_utf7; p < norm_utf7_p; p++) {
3515 /* replace: '&' -> "&-",
3518 BASE64 '/' -> ',' */
3519 if (!in_escape && *p == '&') {
3520 g_string_append(to_str, "&-");
3521 } else if (!in_escape && *p == '+') {
3522 if (*(p + 1) == '-') {
3523 g_string_append_c(to_str, '+');
3526 g_string_append_c(to_str, '&');
3529 } else if (in_escape && *p == '/') {
3530 g_string_append_c(to_str, ',');
3531 } else if (in_escape && *p == '-') {
3532 g_string_append_c(to_str, '-');
3535 g_string_append_c(to_str, *p);
3541 g_string_append_c(to_str, '-');
3545 g_string_free(to_str, FALSE);
3550 static gboolean imap_rename_folder_func(GNode *node, gpointer data)
3552 FolderItem *item = node->data;
3553 gchar **paths = data;
3554 const gchar *oldpath = paths[0];
3555 const gchar *newpath = paths[1];
3556 gchar *real_oldpath, *real_newpath;
3558 gchar *new_itempath;
3560 IMAPSession *session = imap_session_get(item->folder);
3562 oldpathlen = strlen(oldpath);
3563 if (strncmp(oldpath, item->path, oldpathlen) != 0) {
3564 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
3568 base = item->path + oldpathlen;
3569 while (*base == G_DIR_SEPARATOR) base++;
3571 new_itempath = g_strdup(newpath);
3573 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
3576 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3578 item->path = new_itempath;
3580 real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3582 imap_threaded_subscribe(item->folder, real_oldpath, FALSE);
3583 imap_threaded_subscribe(item->folder, real_newpath, TRUE);
3585 g_free(real_oldpath);
3586 g_free(real_newpath);
3590 typedef struct _get_list_uid_data {
3592 IMAPSession *session;
3593 IMAPFolderItem *item;
3594 GSList **msgnum_list;
3596 } get_list_uid_data;
3598 static void *get_list_of_uids_thread(void *data)
3600 get_list_uid_data *stuff = (get_list_uid_data *)data;
3601 Folder *folder = stuff->folder;
3602 IMAPFolderItem *item = stuff->item;
3603 GSList **msgnum_list = stuff->msgnum_list;
3604 gint ok, nummsgs = 0, lastuid_old;
3605 IMAPSession *session;
3606 GSList *uidlist, *elem;
3608 clist * lep_uidlist;
3610 session = stuff->session;
3611 if (session == NULL) {
3613 return GINT_TO_POINTER(-1);
3615 /* no session locking here, it's already locked by caller */
3616 ok = imap_select(session, IMAP_FOLDER(folder), item->item.path,
3617 NULL, NULL, NULL, NULL, TRUE);
3618 if (ok != IMAP_SUCCESS) {
3620 if (ok == MAILIMAP_ERROR_STREAM) {
3621 imap_disc_session_destroy(folder);
3624 return GINT_TO_POINTER(-1);
3627 g_slist_free(item->uid_list);
3628 item->uid_list = NULL;
3632 if (folder->account && folder->account->low_bandwidth) {
3633 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, NULL,
3637 if (r == MAILIMAP_NO_ERROR) {
3638 GSList * fetchuid_list =
3639 imap_uid_list_from_lep(lep_uidlist);
3640 mailimap_search_result_free(lep_uidlist);
3642 uidlist = g_slist_concat(fetchuid_list, uidlist);
3644 carray * lep_uidtab;
3645 r = imap_threaded_fetch_uid(folder, 1,
3647 if (r == MAILIMAP_NO_ERROR) {
3648 GSList * fetchuid_list =
3649 imap_uid_list_from_lep_tab(lep_uidtab);
3650 imap_fetch_uid_list_free(lep_uidtab);
3651 uidlist = g_slist_concat(fetchuid_list, uidlist);
3655 if (r != MAILIMAP_NO_ERROR) {
3657 return GINT_TO_POINTER(-1);
3660 lastuid_old = item->lastuid;
3662 for (elem = uidlist; elem != NULL; elem = g_slist_next(elem)) {
3665 msgnum = GPOINTER_TO_INT(elem->data);
3667 *msgnum_list = g_slist_prepend(*msgnum_list, GINT_TO_POINTER(msgnum));
3668 item->uid_list = g_slist_prepend(item->uid_list, GINT_TO_POINTER(msgnum));
3671 g_slist_free(uidlist);
3673 return GINT_TO_POINTER(nummsgs);
3676 static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
3679 get_list_uid_data *data = g_new0(get_list_uid_data, 1);
3681 data->folder = folder;
3683 data->msgnum_list = msgnum_list;
3684 data->session = session;
3685 if (prefs_common.work_offline &&
3686 !inc_offline_should_override(FALSE,
3687 _("Claws Mail needs network access in order "
3688 "to access the IMAP server."))) {
3693 result = GPOINTER_TO_INT(get_list_of_uids_thread(data));
3699 gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
3701 IMAPFolderItem *item = (IMAPFolderItem *)_item;
3702 IMAPSession *session;
3704 GSList *uidlist = NULL;
3706 gboolean selected_folder;
3707 gint known_list_len = 0;
3708 debug_print("get_num_list\n");
3710 g_return_val_if_fail(folder != NULL, -1);
3711 g_return_val_if_fail(item != NULL, -1);
3712 g_return_val_if_fail(item->item.path != NULL, -1);
3713 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
3714 g_return_val_if_fail(folder->account != NULL, -1);
3716 known_list_len = g_slist_length(item->uid_list);
3717 if (!item->should_update) {
3718 debug_print("get_num_list: nothing to update\n");
3719 *old_uids_valid = TRUE;
3720 if (known_list_len == item->item.total_msgs
3721 && known_list_len > 0) {
3722 *msgnum_list = g_slist_copy(item->uid_list);
3723 return known_list_len;
3725 debug_print("don't know the list length...\n");
3729 debug_print("getting session...\n");
3730 session = imap_session_get(folder);
3731 g_return_val_if_fail(session != NULL, -1);
3733 if (FOLDER_ITEM(item)->path)
3734 statusbar_print_all(_("Scanning folder %s%c%s ..."),
3735 FOLDER_ITEM(item)->folder->name,
3737 FOLDER_ITEM(item)->path);
3739 statusbar_print_all(_("Scanning folder %s ..."),
3740 FOLDER_ITEM(item)->folder->name);
3742 selected_folder = (session->mbox != NULL) &&
3743 (!strcmp(session->mbox, item->item.path));
3745 if (item->should_trash_cache) {
3746 *old_uids_valid = FALSE;
3747 debug_print("get_num_list: trashing num list\n");
3748 debug_print("Freeing imap uid cache\n");
3750 g_slist_free(item->uid_list);
3751 item->uid_list = NULL;
3753 imap_delete_all_cached_messages((FolderItem *)item);
3755 debug_print("get_num_list: updating num list\n");
3756 *old_uids_valid = TRUE;
3759 nummsgs = get_list_of_uids(session, folder, item, &uidlist);
3760 debug_print("get_num_list: got %d msgs\n", nummsgs);
3763 statusbar_pop_all();
3764 unlock_session(session);
3768 *msgnum_list = uidlist;
3770 dir = folder_item_get_path((FolderItem *)item);
3771 debug_print("removing old messages from %s\n", dir);
3772 remove_numbered_files_not_in_list(dir, *msgnum_list);
3775 debug_print("get_num_list - ok - %i\n", nummsgs);
3776 statusbar_pop_all();
3777 unlock_session(session);
3778 item->should_trash_cache = FALSE;
3779 item->should_update = FALSE;
3783 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item)
3788 flags.perm_flags = MSG_NEW|MSG_UNREAD;
3789 flags.tmp_flags = 0;
3791 g_return_val_if_fail(item != NULL, NULL);
3792 g_return_val_if_fail(file != NULL, NULL);
3794 if (folder_has_parent_of_type(item, F_QUEUE)) {
3795 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
3796 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
3797 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
3800 msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
3801 if (!msginfo) return NULL;
3803 msginfo->plaintext_file = g_strdup(file);
3804 msginfo->folder = item;
3809 GSList *imap_get_msginfos(Folder *folder, FolderItem *item,
3810 GSList *msgnum_list)
3812 IMAPSession *session;
3813 MsgInfoList *ret = NULL;
3816 debug_print("get_msginfos\n");
3818 g_return_val_if_fail(folder != NULL, NULL);
3819 g_return_val_if_fail(item != NULL, NULL);
3820 g_return_val_if_fail(msgnum_list != NULL, NULL);
3822 debug_print("getting session...\n");
3823 session = imap_session_get(folder);
3824 g_return_val_if_fail(session != NULL, NULL);
3826 debug_print("IMAP getting msginfos\n");
3827 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
3828 NULL, NULL, NULL, NULL, FALSE);
3829 if (ok != IMAP_SUCCESS) {
3830 unlock_session(session);
3831 if (ok == MAILIMAP_ERROR_STREAM) {
3832 imap_disc_session_destroy(folder);
3837 if (!(folder_has_parent_of_type(item, F_DRAFT) ||
3838 folder_has_parent_of_type(item, F_QUEUE))) {
3839 ret = g_slist_concat(ret,
3840 imap_get_uncached_messages(session, item,
3843 MsgNumberList *sorted_list, *elem, *llast = NULL;
3844 gint startnum, lastnum;
3846 sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
3848 startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
3850 llast = g_slist_last(ret);
3851 for (elem = sorted_list;; elem = g_slist_next(elem)) {
3855 num = GPOINTER_TO_INT(elem->data);
3857 if (num > lastnum + 1 || elem == NULL) {
3859 for (i = startnum; i <= lastnum; ++i) {
3861 unlock_session(session);
3862 file = imap_fetch_msg(folder, item, i);
3863 lock_session(session);
3865 MsgInfo *msginfo = imap_parse_msg(file, item);
3866 if (msginfo != NULL) {
3867 msginfo->msgnum = i;
3869 llast = ret = g_slist_append(ret, msginfo);
3871 llast = g_slist_append(llast, msginfo);
3872 llast = llast->next;
3877 session_set_access_time(SESSION(session));
3888 g_slist_free(sorted_list);
3890 unlock_session(session);
3894 MsgInfo *imap_get_msginfo(Folder *folder, FolderItem *item, gint uid)
3896 MsgInfo *msginfo = NULL;
3897 MsgInfoList *msginfolist;
3898 MsgNumberList numlist;
3900 numlist.next = NULL;
3901 numlist.data = GINT_TO_POINTER(uid);
3903 msginfolist = imap_get_msginfos(folder, item, &numlist);
3904 if (msginfolist != NULL) {
3905 msginfo = msginfolist->data;
3906 g_slist_free(msginfolist);
3912 gboolean imap_scan_required(Folder *folder, FolderItem *_item)
3914 IMAPSession *session;
3915 IMAPFolderItem *item = (IMAPFolderItem *)_item;
3916 gint ok, exists = 0, unseen = 0;
3917 guint32 uid_next = 0, uid_val = 0;
3918 gboolean selected_folder;
3920 g_return_val_if_fail(folder != NULL, FALSE);
3921 g_return_val_if_fail(item != NULL, FALSE);
3922 g_return_val_if_fail(item->item.folder != NULL, FALSE);
3923 g_return_val_if_fail(FOLDER_CLASS(item->item.folder) == &imap_class, FALSE);
3925 if (item->item.path == NULL)
3928 if (item->should_update) {
3929 debug_print("scan already required\n");
3932 debug_print("getting session...\n");
3933 session = imap_session_get(folder);
3934 g_return_val_if_fail(session != NULL, FALSE);
3936 selected_folder = (session->mbox != NULL) &&
3937 (!strcmp(session->mbox, item->item.path));
3938 if (selected_folder) {
3939 if (!session->folder_content_changed) {
3940 ok = imap_cmd_noop(session);
3941 if (ok != IMAP_SUCCESS) {
3942 debug_print("disconnected!\n");
3943 session = imap_reconnect_if_possible(folder, session);
3944 if (session == NULL)
3948 if (session->folder_content_changed) {
3949 debug_print("CHANGED (self-noop)! scan_required\n");
3950 unlock_session(session);
3951 item->should_update = TRUE;
3952 if (session->uid_validity && session->uid_validity != item->item.mtime) {
3953 item->item.mtime = session->uid_validity;
3954 item->should_trash_cache = TRUE;
3960 debug_print("CHANGED (previous noop)! scan_required\n");
3961 unlock_session(session);
3962 item->should_update = TRUE;
3963 if (session->uid_validity && session->uid_validity != item->item.mtime) {
3964 item->item.mtime = session->uid_validity;
3965 item->should_trash_cache = TRUE;
3970 ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, IMAP_FOLDER_ITEM(item),
3971 &exists, &uid_next, &uid_val, &unseen, FALSE);
3972 if (ok != IMAP_SUCCESS) {
3973 unlock_session(session);
3974 if (ok == MAILIMAP_ERROR_STREAM) {
3975 imap_disc_session_destroy(folder);
3981 debug_print("exists %d, item->item.total_msgs %d\n",
3982 exists, item->item.total_msgs);
3983 if (exists != item->item.total_msgs
3984 || unseen != item->item.unread_msgs
3985 || uid_next != item->uid_next
3986 || uid_val != item->item.mtime) {
3987 unlock_session(session);
3988 debug_print("CHANGED (status)! scan_required\n");
3989 item->last_change = time(NULL);
3990 item->should_update = TRUE;
3991 item->uid_next = uid_next;
3992 if (uid_val != item->item.mtime) {
3993 item->item.mtime = uid_val;
3994 item->should_trash_cache = TRUE;
3999 item->should_update = FALSE;
4000 unlock_session(session);
4004 void imap_change_flags(Folder *folder, FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
4006 IMAPSession *session;
4007 IMAPFlags flags_set = 0, flags_unset = 0;
4008 gint ok = IMAP_SUCCESS;
4009 MsgNumberList numlist;
4010 hashtable_data *ht_data = NULL;
4012 g_return_if_fail(folder != NULL);
4013 g_return_if_fail(folder->klass == &imap_class);
4014 g_return_if_fail(item != NULL);
4015 g_return_if_fail(item->folder == folder);
4016 g_return_if_fail(msginfo != NULL);
4017 g_return_if_fail(msginfo->folder == item);
4019 if (!MSG_IS_MARKED(msginfo->flags) && (newflags & MSG_MARKED))
4020 flags_set |= IMAP_FLAG_FLAGGED;
4021 if ( MSG_IS_MARKED(msginfo->flags) && !(newflags & MSG_MARKED))
4022 flags_unset |= IMAP_FLAG_FLAGGED;
4024 if (!MSG_IS_UNREAD(msginfo->flags) && (newflags & MSG_UNREAD))
4025 flags_unset |= IMAP_FLAG_SEEN;
4026 if ( MSG_IS_UNREAD(msginfo->flags) && !(newflags & MSG_UNREAD))
4027 flags_set |= IMAP_FLAG_SEEN;
4029 if (!MSG_IS_REPLIED(msginfo->flags) && (newflags & MSG_REPLIED))
4030 flags_set |= IMAP_FLAG_ANSWERED;
4031 if ( MSG_IS_REPLIED(msginfo->flags) && !(newflags & MSG_REPLIED))
4032 flags_unset |= IMAP_FLAG_ANSWERED;
4034 if (!MSG_IS_DELETED(msginfo->flags) && (newflags & MSG_DELETED))
4035 flags_set |= IMAP_FLAG_DELETED;
4036 if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
4037 flags_unset |= IMAP_FLAG_DELETED;
4039 if (!flags_set && !flags_unset) {
4040 /* the changed flags were not translatable to IMAP-speak.
4041 * like MSG_POSTFILTERED, so just apply. */
4042 msginfo->flags.perm_flags = newflags;
4046 debug_print("getting session...\n");
4047 session = imap_session_get(folder);
4052 if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
4053 NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
4054 unlock_session(session);
4055 if (ok == MAILIMAP_ERROR_STREAM) {
4056 imap_disc_session_destroy(folder);
4061 numlist.next = NULL;
4062 numlist.data = GINT_TO_POINTER(msginfo->msgnum);
4064 if (IMAP_FOLDER_ITEM(item)->batching) {
4065 /* instead of performing an UID STORE command for each message change,
4066 * as a lot of them can change "together", we just fill in hashtables
4067 * and defer the treatment so that we're able to send only one
4070 debug_print("IMAP batch mode on, deferring flags change\n");
4072 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_set_table,
4073 GINT_TO_POINTER(flags_set));
4074 if (ht_data == NULL) {
4075 ht_data = g_new0(hashtable_data, 1);
4076 ht_data->session = session;
4077 ht_data->item = IMAP_FOLDER_ITEM(item);
4078 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_set_table,
4079 GINT_TO_POINTER(flags_set), ht_data);
4081 ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
4084 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4085 GINT_TO_POINTER(flags_unset));
4086 if (ht_data == NULL) {
4087 ht_data = g_new0(hashtable_data, 1);
4088 ht_data->session = session;
4089 ht_data->item = IMAP_FOLDER_ITEM(item);
4090 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4091 GINT_TO_POINTER(flags_unset), ht_data);
4093 ht_data->msglist = g_slist_prepend(ht_data->msglist,
4094 GINT_TO_POINTER(msginfo->msgnum));
4097 debug_print("IMAP changing flags\n");
4099 ok = imap_set_message_flags(session, &numlist, flags_set, TRUE);
4100 if (ok != IMAP_SUCCESS) {
4101 unlock_session(session);
4102 if (ok == MAILIMAP_ERROR_STREAM) {
4103 imap_disc_session_destroy(folder);
4111 ok = imap_set_message_flags(session, &numlist, flags_unset, FALSE);
4112 if (ok != IMAP_SUCCESS) {
4113 unlock_session(session);
4114 if (ok == MAILIMAP_ERROR_STREAM) {
4115 imap_disc_session_destroy(folder);
4122 msginfo->flags.perm_flags = newflags;
4123 unlock_session(session);
4127 static gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
4130 IMAPSession *session;
4132 MsgNumberList numlist;
4134 g_return_val_if_fail(folder != NULL, -1);
4135 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
4136 g_return_val_if_fail(item != NULL, -1);
4138 debug_print("getting session...\n");
4139 session = imap_session_get(folder);
4140 if (!session) return -1;
4142 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
4143 NULL, NULL, NULL, NULL, FALSE);
4144 if (ok != IMAP_SUCCESS) {
4145 unlock_session(session);
4146 if (ok == MAILIMAP_ERROR_STREAM) {
4147 imap_disc_session_destroy(folder);
4152 numlist.next = NULL;
4153 numlist.data = GINT_TO_POINTER(uid);
4155 ok = imap_set_message_flags
4156 (session, &numlist, IMAP_FLAG_DELETED, TRUE);
4157 if (ok != IMAP_SUCCESS) {
4158 log_warning(LOG_PROTOCOL, _("can't set deleted flags: %d\n"), uid);
4159 unlock_session(session);
4160 if (ok == MAILIMAP_ERROR_STREAM) {
4161 imap_disc_session_destroy(folder);
4167 if (!session->uidplus) {
4168 ok = imap_cmd_expunge(session);
4172 uidstr = g_strdup_printf("%u", uid);
4173 ok = imap_cmd_expunge(session);
4176 if (ok != IMAP_SUCCESS) {
4177 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
4178 unlock_session(session);
4179 if (ok == MAILIMAP_ERROR_STREAM) {
4180 imap_disc_session_destroy(folder);
4186 IMAP_FOLDER_ITEM(item)->uid_list = g_slist_remove(
4187 IMAP_FOLDER_ITEM(item)->uid_list, numlist.data);
4188 dir = folder_item_get_path(item);
4189 if (is_dir_exist(dir))
4190 remove_numbered_files(dir, uid, uid);
4192 unlock_session(session);
4193 return IMAP_SUCCESS;
4196 static gint compare_msginfo(gconstpointer a, gconstpointer b)
4198 return ((MsgInfo *)a)->msgnum - ((MsgInfo *)b)->msgnum;
4201 static guint gslist_find_next_num(MsgNumberList **list, guint num)
4205 g_return_val_if_fail(list != NULL, -1);
4207 for (elem = *list; elem != NULL; elem = g_slist_next(elem))
4208 if (GPOINTER_TO_INT(elem->data) >= num)
4211 return elem != NULL ? GPOINTER_TO_INT(elem->data) : (gint)-1;
4215 * NEW and DELETED flags are not syncronized
4216 * - The NEW/RECENT flags in IMAP folders can not really be directly
4217 * modified by Sylpheed
4218 * - The DELETE/DELETED flag in IMAP and Sylpheed don't have the same
4219 * meaning, in IMAP it always removes the messages from the FolderItem
4220 * in Sylpheed it can mean to move the message to trash
4223 typedef struct _get_flags_data {
4226 MsgInfoList *msginfo_list;
4227 GRelation *msgflags;
4228 gboolean full_search;
4232 static /*gint*/ void *imap_get_flags_thread(void *data)
4234 get_flags_data *stuff = (get_flags_data *)data;
4235 Folder *folder = stuff->folder;
4236 FolderItem *fitem = (FolderItem *) stuff->item;
4237 MsgInfoList *msginfo_list = stuff->msginfo_list;
4238 GRelation *msgflags = stuff->msgflags;
4240 carray * lep_uidtab;
4241 IMAPSession *session;
4244 GHashTable *flags_hash = NULL;
4245 gboolean full_search = stuff->full_search;
4246 GSList *sorted_list = NULL;
4247 GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL;
4248 GSList *p_unseen, *p_answered, *p_flagged, *p_deleted;
4249 GSList *seq_list, *cur;
4250 gboolean reverse_seen = FALSE;
4251 gboolean selected_folder;
4252 gint exists_cnt, unseen_cnt;
4254 session = imap_session_get(folder);
4255 if (session == NULL) {
4257 return GINT_TO_POINTER(-1);
4259 selected_folder = (session->mbox != NULL) &&
4260 (!strcmp(session->mbox, fitem->path));
4262 if (!selected_folder) {
4263 ok = imap_select(session, IMAP_FOLDER(folder), fitem->path,
4264 &exists_cnt, NULL, &unseen_cnt, NULL, TRUE);
4265 if (ok != IMAP_SUCCESS) {
4267 unlock_session(session);
4268 if (ok == MAILIMAP_ERROR_STREAM) {
4269 imap_disc_session_destroy(folder);
4272 return GINT_TO_POINTER(-1);
4275 if (unseen_cnt > exists_cnt / 2)
4276 reverse_seen = TRUE;
4279 if (fitem->unread_msgs > fitem->total_msgs / 2)
4280 reverse_seen = TRUE;
4283 sorted_list = g_slist_sort(g_slist_copy(msginfo_list), compare_msginfo);
4285 seq_list = imap_get_lep_set_from_msglist(msginfo_list);
4287 struct mailimap_set * set;
4288 set = mailimap_set_new_interval(1, 0);
4289 seq_list = g_slist_append(NULL, set);
4292 if (folder->account && folder->account->low_bandwidth) {
4293 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
4294 struct mailimap_set * imapset;
4295 clist * lep_uidlist;
4298 imapset = cur->data;
4300 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SEEN,
4301 full_search ? NULL:imapset, &lep_uidlist);
4304 r = imap_threaded_search(folder,
4305 IMAP_SEARCH_TYPE_UNSEEN,
4306 full_search ? NULL:imapset, &lep_uidlist);
4308 if (r == MAILIMAP_NO_ERROR) {
4311 uidlist = imap_uid_list_from_lep(lep_uidlist);
4312 mailimap_search_result_free(lep_uidlist);
4314 unseen = g_slist_concat(unseen, uidlist);
4317 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FLAGGED,
4318 full_search ? NULL:imapset, &lep_uidlist);
4319 if (r == MAILIMAP_NO_ERROR) {
4322 uidlist = imap_uid_list_from_lep(lep_uidlist);
4323 mailimap_search_result_free(lep_uidlist);
4325 flagged = g_slist_concat(flagged, uidlist);
4328 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4329 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED,
4330 full_search ? NULL:imapset, &lep_uidlist);
4331 if (r == MAILIMAP_NO_ERROR) {
4334 uidlist = imap_uid_list_from_lep(lep_uidlist);
4335 mailimap_search_result_free(lep_uidlist);
4337 answered = g_slist_concat(answered, uidlist);
4340 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
4341 full_search ? NULL:imapset, &lep_uidlist);
4342 if (r == MAILIMAP_NO_ERROR) {
4345 uidlist = imap_uid_list_from_lep(lep_uidlist);
4346 mailimap_search_result_free(lep_uidlist);
4348 deleted = g_slist_concat(deleted, uidlist);
4353 p_answered = answered;
4354 p_flagged = flagged;
4355 p_deleted = deleted;
4358 r = imap_threaded_fetch_uid_flags(folder, 1, &lep_uidtab);
4359 if (r == MAILIMAP_NO_ERROR) {
4360 flags_hash = g_hash_table_new_full(g_int_hash, g_int_equal, free, NULL);
4361 imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab, flags_hash);
4362 imap_fetch_uid_flags_list_free(lep_uidtab);
4365 for (elem = sorted_list; elem != NULL; elem = g_slist_next(elem)) {
4367 MsgPermFlags flags, oldflags;
4370 msginfo = (MsgInfo *) elem->data;
4371 flags = msginfo->flags.perm_flags;
4372 wasnew = (flags & MSG_NEW);
4373 oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_MARKED|MSG_DELETED);
4375 if (folder->account && folder->account->low_bandwidth) {
4376 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4377 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_MARKED);
4379 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
4382 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4383 if (gslist_find_next_num(&p_unseen, msginfo->msgnum) == msginfo->msgnum) {
4384 if (!reverse_seen) {
4385 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4387 flags &= ~(MSG_UNREAD | MSG_NEW);
4391 if (gslist_find_next_num(&p_flagged, msginfo->msgnum) == msginfo->msgnum)
4392 flags |= MSG_MARKED;
4394 flags &= ~MSG_MARKED;
4396 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4397 if (gslist_find_next_num(&p_answered, msginfo->msgnum) == msginfo->msgnum)
4398 flags |= MSG_REPLIED;
4400 flags &= ~MSG_REPLIED;
4401 if (gslist_find_next_num(&p_deleted, msginfo->msgnum) == msginfo->msgnum)
4402 flags |= MSG_DELETED;
4404 flags &= ~MSG_DELETED;
4407 if (flags_hash != NULL) {
4410 puid = malloc(sizeof(* puid));
4411 * puid = msginfo->msgnum;
4413 flags = GPOINTER_TO_INT(g_hash_table_lookup(flags_hash, puid));
4417 if ((flags & MSG_UNREAD) == 0)
4424 g_relation_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
4428 g_hash_table_destroy(flags_hash);
4430 imap_lep_set_free(seq_list);
4431 g_slist_free(flagged);
4432 g_slist_free(deleted);
4433 g_slist_free(answered);
4434 g_slist_free(unseen);
4435 g_slist_free(sorted_list);
4437 unlock_session(session);
4439 return GINT_TO_POINTER(0);
4442 static gint imap_get_flags(Folder *folder, FolderItem *item,
4443 MsgInfoList *msginfo_list, GRelation *msgflags)
4446 get_flags_data *data = g_new0(get_flags_data, 1);
4448 data->folder = folder;
4450 data->msginfo_list = msginfo_list;
4451 data->msgflags = msgflags;
4452 data->full_search = FALSE;
4454 GSList *tmp = NULL, *cur;
4456 if (prefs_common.work_offline &&
4457 !inc_offline_should_override(FALSE,
4458 _("Claws Mail needs network access in order "
4459 "to access the IMAP server."))) {
4464 tmp = folder_item_get_msg_list(item);
4466 if (g_slist_length(tmp) <= g_slist_length(msginfo_list))
4467 data->full_search = TRUE;
4469 for (cur = tmp; cur; cur = cur->next)
4470 procmsg_msginfo_free((MsgInfo *)cur->data);
4474 result = GPOINTER_TO_INT(imap_get_flags_thread(data));
4481 static gboolean process_flags(gpointer key, gpointer value, gpointer user_data)
4483 gboolean flags_set = GPOINTER_TO_INT(user_data);
4484 gint flags_value = GPOINTER_TO_INT(key);
4485 hashtable_data *data = (hashtable_data *)value;
4486 IMAPFolderItem *_item = data->item;
4487 FolderItem *item = (FolderItem *)_item;
4488 gint ok = IMAP_ERROR;
4489 IMAPSession *session = NULL;
4491 debug_print("getting session...\n");
4492 session = imap_session_get(item->folder);
4494 data->msglist = g_slist_reverse(data->msglist);
4496 debug_print("IMAP %ssetting flags to %d for %d messages\n",
4499 g_slist_length(data->msglist));
4502 ok = imap_select(session, IMAP_FOLDER(item->folder), item->path,
4503 NULL, NULL, NULL, NULL, FALSE);
4505 if (ok == IMAP_SUCCESS) {
4506 imap_set_message_flags(data->session, data->msglist, flags_value, flags_set);
4508 g_warning("can't select mailbox %s\n", item->path);
4511 unlock_session(session);
4512 if (ok == MAILIMAP_ERROR_STREAM) {
4513 imap_disc_session_destroy(item->folder);
4516 g_slist_free(data->msglist);
4521 static void process_hashtable(IMAPFolderItem *item)
4523 if (item->flags_set_table) {
4524 g_hash_table_foreach_remove(item->flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
4525 g_hash_table_destroy(item->flags_set_table);
4526 item->flags_set_table = NULL;
4528 if (item->flags_unset_table) {
4529 g_hash_table_foreach_remove(item->flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
4530 g_hash_table_destroy(item->flags_unset_table);
4531 item->flags_unset_table = NULL;
4536 static void imap_set_batch (Folder *folder, FolderItem *_item, gboolean batch)
4538 IMAPFolderItem *item = (IMAPFolderItem *)_item;
4539 IMAPSession *session;
4541 g_return_if_fail(item != NULL);
4543 if (item->batching == batch)
4547 item->batching = TRUE;
4548 debug_print("IMAP switching to batch mode\n");
4549 if (!item->flags_set_table) {
4550 item->flags_set_table = g_hash_table_new(NULL, g_direct_equal);
4552 if (!item->flags_unset_table) {
4553 item->flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
4555 session = imap_session_get(folder);
4557 imap_refresh_sensitivity(session);
4558 session->sens_update_block = TRUE;
4559 unlock_session(session);
4562 debug_print("IMAP switching away from batch mode\n");
4564 process_hashtable(item);
4565 item->batching = FALSE;
4566 session = imap_session_get(folder);
4568 unlock_session(session);
4569 session->sens_update_block = FALSE;
4570 imap_refresh_sensitivity(session);
4577 /* data types conversion libetpan <-> claws */
4581 #define ETPAN_IMAP_MB_MARKED 1
4582 #define ETPAN_IMAP_MB_UNMARKED 2
4583 #define ETPAN_IMAP_MB_NOSELECT 4
4584 #define ETPAN_IMAP_MB_NOINFERIORS 8
4586 static int imap_flags_to_flags(struct mailimap_mbx_list_flags * imap_flags)
4592 if (imap_flags->mbf_type == MAILIMAP_MBX_LIST_FLAGS_SFLAG) {
4593 switch (imap_flags->mbf_sflag) {
4594 case MAILIMAP_MBX_LIST_SFLAG_MARKED:
4595 flags |= ETPAN_IMAP_MB_MARKED;
4597 case MAILIMAP_MBX_LIST_SFLAG_NOSELECT:
4598 flags |= ETPAN_IMAP_MB_NOSELECT;
4600 case MAILIMAP_MBX_LIST_SFLAG_UNMARKED:
4601 flags |= ETPAN_IMAP_MB_UNMARKED;
4606 for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
4607 cur = clist_next(cur)) {
4608 struct mailimap_mbx_list_oflag * oflag;
4610 oflag = clist_content(cur);
4612 switch (oflag->of_type) {
4613 case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
4614 flags |= ETPAN_IMAP_MB_NOINFERIORS;
4622 static GSList * imap_list_from_lep(IMAPFolder * folder,
4623 clist * list, const gchar * real_path, gboolean all)
4626 GSList * item_list = NULL, *llast = NULL;
4628 for(iter = clist_begin(list) ; iter != NULL ;
4629 iter = clist_next(iter)) {
4630 struct mailimap_mailbox_list * mb;
4638 FolderItem *new_item;
4640 mb = clist_content(iter);
4646 if (mb->mb_flag != NULL)
4647 flags = imap_flags_to_flags(mb->mb_flag);
4649 delimiter = mb->mb_delimiter;
4652 dup_name = strdup(name);
4653 if (delimiter != '\0')
4654 subst_char(dup_name, delimiter, '/');
4656 base = g_path_get_basename(dup_name);
4657 if (base[0] == '.') {
4662 if (!all && path_cmp(name, real_path) == 0) {
4668 if (!all && dup_name[strlen(dup_name)-1] == '/') {
4669 dup_name[strlen(dup_name)-1] = '\0';
4672 loc_name = imap_modified_utf7_to_utf8(base);
4673 loc_path = imap_modified_utf7_to_utf8(dup_name);
4675 new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
4676 if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
4677 new_item->no_sub = TRUE;
4678 if (strcmp(dup_name, "INBOX") != 0 &&
4679 ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
4680 new_item->no_select = TRUE;
4682 if (item_list == NULL)
4683 llast = item_list = g_slist_append(item_list, new_item);
4685 llast = g_slist_append(llast, new_item);
4686 llast = llast->next;
4688 debug_print("folder '%s' found.\n", loc_path);
4699 static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist)
4701 GSList *sorted_list, *cur;
4702 guint first, last, next;
4703 GSList *ret_list = NULL, *llast = NULL;
4705 struct mailimap_set * current_set;
4706 unsigned int item_count;
4708 if (numlist == NULL)
4712 current_set = mailimap_set_new_empty();
4714 sorted_list = g_slist_copy(numlist);
4715 sorted_list = g_slist_sort(sorted_list, g_int_compare);
4717 first = GPOINTER_TO_INT(sorted_list->data);
4720 for (cur = sorted_list; cur != NULL; cur = g_slist_next(cur)) {
4721 if (GPOINTER_TO_INT(cur->data) == 0)
4726 last = GPOINTER_TO_INT(cur->data);
4728 next = GPOINTER_TO_INT(cur->next->data);
4732 if (last + 1 != next || next == 0) {
4734 struct mailimap_set_item * item;
4735 item = mailimap_set_item_new(first, last);
4736 mailimap_set_add(current_set, item);
4741 if (count >= IMAP_SET_MAX_COUNT) {
4742 if (ret_list == NULL)
4743 llast = ret_list = g_slist_append(ret_list,
4746 llast = g_slist_append(llast, current_set);
4747 llast = llast->next;
4749 current_set = mailimap_set_new_empty();
4756 if (clist_count(current_set->set_list) > 0) {
4757 ret_list = g_slist_append(ret_list,
4761 g_slist_free(sorted_list);
4766 static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist)
4768 MsgNumberList *numlist = NULL;
4772 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
4773 MsgInfo *msginfo = (MsgInfo *) cur->data;
4775 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
4777 numlist = g_slist_reverse(numlist);
4778 seq_list = imap_get_lep_set_from_numlist(numlist);
4779 g_slist_free(numlist);
4784 static GSList * imap_uid_list_from_lep(clist * list)
4791 for(iter = clist_begin(list) ; iter != NULL ;
4792 iter = clist_next(iter)) {
4795 puid = clist_content(iter);
4796 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4799 result = g_slist_reverse(result);
4803 static GSList * imap_uid_list_from_lep_tab(carray * list)
4810 for(i = 0 ; i < carray_count(list) ; i ++) {
4813 puid = carray_get(list, i);
4814 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4816 result = g_slist_reverse(result);
4820 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
4828 for(i = 0 ; i < carray_count(list) ; i += 2) {
4833 puid = carray_get(list, i);
4834 pflags = carray_get(list, i + 1);
4835 pguid = malloc(sizeof(* pguid));
4838 g_hash_table_insert(hash, pguid, GINT_TO_POINTER(* pflags));
4842 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
4845 MsgInfo *msginfo = NULL;
4848 MsgFlags flags = {0, 0};
4850 if (info->headers == NULL)
4853 MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
4854 if (folder_has_parent_of_type(item, F_QUEUE)) {
4855 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
4856 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
4857 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
4859 flags.perm_flags = info->flags;
4863 msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
4866 msginfo->msgnum = uid;
4867 msginfo->size = size;
4873 static void imap_lep_set_free(GSList *seq_list)
4877 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
4878 struct mailimap_set * imapset;
4880 imapset = cur->data;
4881 mailimap_set_free(imapset);
4883 g_slist_free(seq_list);
4886 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags)
4888 struct mailimap_flag_list * flag_list;
4890 flag_list = mailimap_flag_list_new_empty();
4892 if (IMAP_IS_SEEN(flags))
4893 mailimap_flag_list_add(flag_list,
4894 mailimap_flag_new_seen());
4895 if (IMAP_IS_ANSWERED(flags))
4896 mailimap_flag_list_add(flag_list,
4897 mailimap_flag_new_answered());
4898 if (IMAP_IS_FLAGGED(flags))
4899 mailimap_flag_list_add(flag_list,
4900 mailimap_flag_new_flagged());
4901 if (IMAP_IS_DELETED(flags))
4902 mailimap_flag_list_add(flag_list,
4903 mailimap_flag_new_deleted());
4904 if (IMAP_IS_DRAFT(flags))
4905 mailimap_flag_list_add(flag_list,
4906 mailimap_flag_new_draft());
4911 guint imap_folder_get_refcnt(Folder *folder)
4913 return ((IMAPFolder *)folder)->refcnt;
4916 void imap_folder_ref(Folder *folder)
4918 ((IMAPFolder *)folder)->refcnt++;
4921 void imap_disconnect_all(void)
4924 for (list = account_get_list(); list != NULL; list = list->next) {
4925 PrefsAccount *account = list->data;
4926 if (account->protocol == A_IMAP4) {
4927 RemoteFolder *folder = (RemoteFolder *)account->folder;
4928 if (folder && folder->session) {
4929 IMAPSession *session = (IMAPSession *)folder->session;
4930 imap_threaded_disconnect(FOLDER(folder));
4931 SESSION(session)->state = SESSION_DISCONNECTED;
4932 session_destroy(SESSION(session));
4933 folder->session = NULL;
4939 void imap_folder_unref(Folder *folder)
4941 if (((IMAPFolder *)folder)->refcnt > 0)
4942 ((IMAPFolder *)folder)->refcnt--;
4945 void imap_cancel_all(void)
4950 folderlist = folder_get_list();
4951 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
4952 Folder *folder = (Folder *) cur->data;
4954 if (folder->klass == &imap_class) {
4955 if (imap_is_busy(folder)) {
4956 IMAPSession *imap_session;
4957 RemoteFolder *rfolder;
4959 g_printerr("cancelled\n");
4960 imap_threaded_cancel(folder);
4961 rfolder = (RemoteFolder *) folder;
4962 imap_session = (IMAPSession *) rfolder->session;
4964 imap_session->cancelled = 1;
4970 gboolean imap_cancel_all_enabled(void)
4975 folderlist = folder_get_list();
4976 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
4977 Folder *folder = (Folder *) cur->data;
4979 if (folder->klass == &imap_class) {
4980 if (imap_is_busy(folder)) {
4989 static gboolean imap_is_busy(Folder *folder)
4991 IMAPSession *imap_session;
4992 RemoteFolder *rfolder;
4994 rfolder = (RemoteFolder *) folder;
4995 imap_session = (IMAPSession *) rfolder->session;
4996 if (imap_session == NULL)
4999 return imap_session->busy;
5002 #else /* HAVE_LIBETPAN */
5004 static FolderClass imap_class;
5006 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
5007 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
5009 static Folder *imap_folder_new (const gchar *name,
5012 static gboolean missing_imap_warning = TRUE;
5013 if (missing_imap_warning) {
5014 missing_imap_warning = FALSE;
5016 _("You have one or more IMAP accounts "
5017 "defined. However this version of "
5018 "Claws Mail has been built without "
5019 "IMAP support; your IMAP account(s) are "
5021 "You probably need to "
5022 "install libetpan and recompile "
5027 static gint imap_create_tree (Folder *folder)
5031 static FolderItem *imap_create_folder (Folder *folder,
5037 static gint imap_rename_folder (Folder *folder,
5044 gchar imap_get_path_separator_for_item(FolderItem *item)
5049 FolderClass *imap_get_class(void)
5051 if (imap_class.idstr == NULL) {
5052 imap_class.type = F_IMAP;
5053 imap_class.idstr = "imap";
5054 imap_class.uistr = "IMAP4";
5056 imap_class.new_folder = imap_folder_new;
5057 imap_class.create_tree = imap_create_tree;
5058 imap_class.create_folder = imap_create_folder;
5059 imap_class.rename_folder = imap_rename_folder;
5061 imap_class.set_xml = folder_set_xml;
5062 imap_class.get_xml = folder_get_xml;
5063 imap_class.item_set_xml = imap_item_set_xml;
5064 imap_class.item_get_xml = imap_item_get_xml;
5065 /* nothing implemented */
5071 void imap_disconnect_all(void)
5075 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
5080 GList * imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
5085 void imap_cache_msg(FolderItem *item, gint msgnum)
5089 void imap_cancel_all(void)
5093 gboolean imap_cancel_all_enabled(void)
5100 #ifdef HAVE_LIBETPAN
5101 static void imap_synchronise(FolderItem *item, gint days)
5103 if (IMAP_FOLDER_ITEM(item)->last_sync == IMAP_FOLDER_ITEM(item)->last_change) {
5104 debug_print("%s already synced\n", item->path?item->path:item->name);
5107 debug_print("syncing %s\n", item->path?item->path:item->name);
5108 imap_gtk_synchronise(item, days);
5109 IMAP_FOLDER_ITEM(item)->last_sync = IMAP_FOLDER_ITEM(item)->last_change;
5113 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
5115 #ifdef HAVE_LIBETPAN
5118 folder_item_set_xml(folder, item, tag);
5120 #ifdef HAVE_LIBETPAN
5121 for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
5122 XMLAttr *attr = (XMLAttr *) cur->data;
5124 if (!attr || !attr->name || !attr->value) continue;
5125 if (!strcmp(attr->name, "uidnext"))
5126 IMAP_FOLDER_ITEM(item)->uid_next = atoi(attr->value);
5127 if (!strcmp(attr->name, "last_sync"))
5128 IMAP_FOLDER_ITEM(item)->last_sync = atoi(attr->value);
5129 if (!strcmp(attr->name, "last_change"))
5130 IMAP_FOLDER_ITEM(item)->last_change = atoi(attr->value);
5132 if (IMAP_FOLDER_ITEM(item)->last_change == 0)
5133 IMAP_FOLDER_ITEM(item)->last_change = time(NULL);
5137 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item)
5141 tag = folder_item_get_xml(folder, item);
5143 #ifdef HAVE_LIBETPAN
5144 xml_tag_add_attr(tag, xml_attr_new_int("uidnext",
5145 IMAP_FOLDER_ITEM(item)->uid_next));
5146 xml_tag_add_attr(tag, xml_attr_new_int("last_sync",
5147 IMAP_FOLDER_ITEM(item)->last_sync));
5148 xml_tag_add_attr(tag, xml_attr_new_int("last_change",
5149 IMAP_FOLDER_ITEM(item)->last_change));