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"
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;
122 struct _IMAPNameSpace
128 #define IMAP_SUCCESS 0
129 #define IMAP_SOCKET 2
130 #define IMAP_AUTHFAIL 3
131 #define IMAP_PROTOCOL 4
132 #define IMAP_SYNTAX 5
136 #define IMAPBUFSIZE 8192
140 IMAP_FLAG_SEEN = 1 << 0,
141 IMAP_FLAG_ANSWERED = 1 << 1,
142 IMAP_FLAG_FLAGGED = 1 << 2,
143 IMAP_FLAG_DELETED = 1 << 3,
144 IMAP_FLAG_DRAFT = 1 << 4
147 #define IMAP_IS_SEEN(flags) ((flags & IMAP_FLAG_SEEN) != 0)
148 #define IMAP_IS_ANSWERED(flags) ((flags & IMAP_FLAG_ANSWERED) != 0)
149 #define IMAP_IS_FLAGGED(flags) ((flags & IMAP_FLAG_FLAGGED) != 0)
150 #define IMAP_IS_DELETED(flags) ((flags & IMAP_FLAG_DELETED) != 0)
151 #define IMAP_IS_DRAFT(flags) ((flags & IMAP_FLAG_DRAFT) != 0)
154 #define IMAP4_PORT 143
156 #define IMAPS_PORT 993
159 #define IMAP_CMD_LIMIT 1000
161 struct _IMAPFolderItem
170 GHashTable *flags_set_table;
171 GHashTable *flags_unset_table;
174 gboolean should_update;
175 gboolean should_trash_cache;
178 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
179 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
181 static void imap_folder_init (Folder *folder,
185 static Folder *imap_folder_new (const gchar *name,
187 static void imap_folder_destroy (Folder *folder);
189 static IMAPSession *imap_session_new (Folder *folder,
190 const PrefsAccount *account);
191 static void imap_session_authenticate(IMAPSession *session,
192 const PrefsAccount *account);
193 static void imap_session_destroy (Session *session);
195 static gchar *imap_fetch_msg (Folder *folder,
198 static gchar *imap_fetch_msg_full (Folder *folder,
203 static void imap_remove_cached_msg (Folder *folder,
206 static gint imap_add_msg (Folder *folder,
210 static gint imap_add_msgs (Folder *folder,
213 GRelation *relation);
215 static gint imap_copy_msg (Folder *folder,
218 static gint imap_copy_msgs (Folder *folder,
220 MsgInfoList *msglist,
221 GRelation *relation);
223 static gint imap_remove_msg (Folder *folder,
226 static gint imap_remove_msgs (Folder *folder,
228 MsgInfoList *msglist,
229 GRelation *relation);
230 static gint imap_remove_all_msg (Folder *folder,
233 static gboolean imap_is_msg_changed (Folder *folder,
237 static gint imap_close (Folder *folder,
240 static gint imap_scan_tree (Folder *folder);
242 static gint imap_create_tree (Folder *folder);
244 static FolderItem *imap_create_folder (Folder *folder,
247 static gint imap_rename_folder (Folder *folder,
250 static gint imap_remove_folder (Folder *folder,
253 static FolderItem *imap_folder_item_new (Folder *folder);
254 static void imap_folder_item_destroy (Folder *folder,
257 static IMAPSession *imap_session_get (Folder *folder);
259 static gint imap_auth (IMAPSession *session,
264 static gint imap_scan_tree_recursive (IMAPSession *session,
268 static void imap_create_missing_folders (Folder *folder);
269 static FolderItem *imap_create_special_folder
271 SpecialFolderItemType stype,
274 static gint imap_do_copy_msgs (Folder *folder,
276 MsgInfoList *msglist,
277 GRelation *relation);
279 static void imap_delete_all_cached_messages (FolderItem *item);
280 static void imap_set_batch (Folder *folder,
283 static gint imap_set_message_flags (IMAPSession *session,
284 MsgNumberList *numlist,
287 static gint imap_select (IMAPSession *session,
293 guint32 *uid_validity,
295 static gint imap_status (IMAPSession *session,
298 IMAPFolderItem *item,
301 guint32 *uid_validity,
305 static gchar imap_get_path_separator (IMAPSession *session,
308 static gchar *imap_get_real_path (IMAPSession *session,
311 static void imap_synchronise (FolderItem *item, gint days);
312 static gboolean imap_is_busy (Folder *folder);
314 static void imap_free_capabilities (IMAPSession *session);
316 /* low-level IMAP4rev1 commands */
317 static gint imap_cmd_login (IMAPSession *session,
321 static gint imap_cmd_noop (IMAPSession *session);
323 static gint imap_cmd_starttls (IMAPSession *session);
325 static gint imap_cmd_select (IMAPSession *session,
330 guint32 *uid_validity,
332 static gint imap_cmd_close (IMAPSession *session);
333 static gint imap_cmd_examine (IMAPSession *session,
338 guint32 *uid_validity,
340 static gint imap_cmd_create (IMAPSession *sock,
341 const gchar *folder);
342 static gint imap_cmd_rename (IMAPSession *sock,
343 const gchar *oldfolder,
344 const gchar *newfolder);
345 static gint imap_cmd_delete (IMAPSession *session,
346 const gchar *folder);
347 static gint imap_cmd_fetch (IMAPSession *sock,
349 const gchar *filename,
352 static gint imap_cmd_append (IMAPSession *session,
353 const gchar *destfolder,
357 static gint imap_cmd_copy (IMAPSession *session,
358 struct mailimap_set * set,
359 const gchar *destfolder,
360 GRelation *uid_mapping,
361 struct mailimap_set ** source,
362 struct mailimap_set ** dest);
363 static gint imap_cmd_store (IMAPSession *session,
364 struct mailimap_set * set,
367 static gint imap_cmd_expunge (IMAPSession *session);
369 static void imap_path_separator_subst (gchar *str,
372 static gchar *imap_utf8_to_modified_utf7 (const gchar *from);
373 static gchar *imap_modified_utf7_to_utf8 (const gchar *mutf7_str);
375 static gboolean imap_rename_folder_func (GNode *node,
377 static gint imap_get_num_list (Folder *folder,
380 gboolean *old_uids_valid);
381 static GSList *imap_get_msginfos (Folder *folder,
383 GSList *msgnum_list);
384 static MsgInfo *imap_get_msginfo (Folder *folder,
387 static gboolean imap_scan_required (Folder *folder,
389 static void imap_change_flags (Folder *folder,
392 MsgPermFlags newflags);
393 static gint imap_get_flags (Folder *folder,
395 MsgInfoList *msglist,
396 GRelation *msgflags);
397 static gchar *imap_folder_get_path (Folder *folder);
398 static gchar *imap_item_get_path (Folder *folder,
400 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
403 /* data types conversion libetpan <-> claws */
404 static GSList * imap_list_from_lep(IMAPFolder * folder,
405 clist * list, const gchar * real_path, gboolean all);
406 static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist);
407 static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist);
408 static GSList * imap_uid_list_from_lep(clist * list);
409 static GSList * imap_uid_list_from_lep_tab(carray * list);
410 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
412 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
414 static void imap_lep_set_free(GSList *seq_list);
415 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags);
417 typedef struct _hashtable_data {
418 IMAPSession *session;
420 IMAPFolderItem *item;
423 static FolderClass imap_class;
425 typedef struct _thread_data {
435 FolderClass *imap_get_class(void)
437 if (imap_class.idstr == NULL) {
438 imap_class.type = F_IMAP;
439 imap_class.idstr = "imap";
440 imap_class.uistr = "IMAP4";
442 /* Folder functions */
443 imap_class.new_folder = imap_folder_new;
444 imap_class.destroy_folder = imap_folder_destroy;
445 imap_class.scan_tree = imap_scan_tree;
446 imap_class.create_tree = imap_create_tree;
448 /* FolderItem functions */
449 imap_class.item_new = imap_folder_item_new;
450 imap_class.item_destroy = imap_folder_item_destroy;
451 imap_class.item_get_path = imap_item_get_path;
452 imap_class.create_folder = imap_create_folder;
453 imap_class.rename_folder = imap_rename_folder;
454 imap_class.remove_folder = imap_remove_folder;
455 imap_class.close = imap_close;
456 imap_class.get_num_list = imap_get_num_list;
457 imap_class.scan_required = imap_scan_required;
458 imap_class.set_xml = folder_set_xml;
459 imap_class.get_xml = folder_get_xml;
460 imap_class.item_set_xml = imap_item_set_xml;
461 imap_class.item_get_xml = imap_item_get_xml;
463 /* Message functions */
464 imap_class.get_msginfo = imap_get_msginfo;
465 imap_class.get_msginfos = imap_get_msginfos;
466 imap_class.fetch_msg = imap_fetch_msg;
467 imap_class.fetch_msg_full = imap_fetch_msg_full;
468 imap_class.add_msg = imap_add_msg;
469 imap_class.add_msgs = imap_add_msgs;
470 imap_class.copy_msg = imap_copy_msg;
471 imap_class.copy_msgs = imap_copy_msgs;
472 imap_class.remove_msg = imap_remove_msg;
473 imap_class.remove_msgs = imap_remove_msgs;
474 imap_class.remove_all_msg = imap_remove_all_msg;
475 imap_class.is_msg_changed = imap_is_msg_changed;
476 imap_class.change_flags = imap_change_flags;
477 imap_class.get_flags = imap_get_flags;
478 imap_class.set_batch = imap_set_batch;
479 imap_class.synchronise = imap_synchronise;
480 imap_class.remove_cached_msg = imap_remove_cached_msg;
482 pthread_mutex_init(&imap_mutex, NULL);
489 static Folder *imap_folder_new(const gchar *name, const gchar *path)
493 folder = (Folder *)g_new0(IMAPFolder, 1);
494 folder->klass = &imap_class;
495 imap_folder_init(folder, name, path);
500 static void imap_folder_destroy(Folder *folder)
502 while (imap_folder_get_refcnt(folder) > 0)
503 gtk_main_iteration();
505 folder_remote_folder_destroy(REMOTE_FOLDER(folder));
509 static void imap_folder_init(Folder *folder, const gchar *name,
512 folder_remote_folder_init((Folder *)folder, name, path);
515 static FolderItem *imap_folder_item_new(Folder *folder)
517 IMAPFolderItem *item;
519 item = g_new0(IMAPFolderItem, 1);
522 item->uid_list = NULL;
524 return (FolderItem *)item;
527 static void imap_folder_item_destroy(Folder *folder, FolderItem *_item)
529 IMAPFolderItem *item = (IMAPFolderItem *)_item;
531 g_return_if_fail(item != NULL);
532 g_slist_free(item->uid_list);
537 static gboolean imap_reset_uid_lists_func(GNode *node, gpointer data)
539 IMAPFolderItem *item = (IMAPFolderItem *)node->data;
542 g_slist_free(item->uid_list);
543 item->uid_list = NULL;
548 static void imap_reset_uid_lists(Folder *folder)
550 if(folder->node == NULL)
553 /* Destroy all uid lists and rest last uid */
554 g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
557 static int imap_get_capabilities(IMAPSession *session)
559 struct mailimap_capability_data *capabilities = NULL;
563 if (session->capability != NULL)
564 return MAILIMAP_NO_ERROR;
566 capabilities = imap_threaded_capability(session->folder, &result);
568 if (result != MAILIMAP_NO_ERROR) {
569 return MAILIMAP_ERROR_CAPABILITY;
572 if (capabilities == NULL) {
573 return MAILIMAP_NO_ERROR;
576 for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
577 cur = clist_next(cur)) {
578 struct mailimap_capability * cap =
580 if (!cap || cap->cap_data.cap_name == NULL)
582 session->capability = g_slist_append
583 (session->capability,
584 g_strdup(cap->cap_data.cap_name));
585 debug_print("got capa %s\n", cap->cap_data.cap_name);
587 mailimap_capability_data_free(capabilities);
588 return MAILIMAP_NO_ERROR;
591 static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
594 for (cur = session->capability; cur; cur = cur->next) {
595 if (!g_ascii_strcasecmp(cur->data, cap))
601 static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
604 gint ok = IMAP_ERROR;
605 static time_t last_login_err = 0;
606 gchar *ext_info = "";
608 if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR)
613 ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
615 case IMAP_AUTH_CRAM_MD5:
616 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
618 case IMAP_AUTH_LOGIN:
619 ok = imap_cmd_login(session, user, pass, "LOGIN");
621 case IMAP_AUTH_GSSAPI:
622 ok = imap_cmd_login(session, user, pass, "GSSAPI");
625 debug_print("capabilities:\n"
630 imap_has_capability(session, "ANONYMOUS"),
631 imap_has_capability(session, "CRAM-MD5"),
632 imap_has_capability(session, "LOGIN"),
633 imap_has_capability(session, "GSSAPI"));
634 if (imap_has_capability(session, "CRAM-MD5"))
635 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
636 if (ok == IMAP_ERROR && imap_has_capability(session, "GSSAPI"))
637 ok = imap_cmd_login(session, user, pass, "GSSAPI");
638 if (ok == IMAP_ERROR) /* we always try LOGIN before giving up */
639 ok = imap_cmd_login(session, user, pass, "LOGIN");
642 if (ok == IMAP_SUCCESS)
643 session->authenticated = TRUE;
645 if (type == IMAP_AUTH_CRAM_MD5) {
646 ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
647 "compiled with SASL support and the "
648 "CRAM-MD5 SASL plugin is installed.");
651 if (time(NULL) - last_login_err > 10) {
652 if (!prefs_common.no_recv_err_panel) {
653 alertpanel_error(_("Connection to %s failed: "
655 SESSION(session)->server, ext_info);
657 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
658 "login refused.%s\n"),
659 SESSION(session)->server, ext_info);
662 last_login_err = time(NULL);
667 static IMAPSession *imap_reconnect_if_possible(Folder *folder, IMAPSession *session)
669 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
670 /* Check if this is the first try to establish a
671 connection, if yes we don't try to reconnect */
672 debug_print("reconnecting\n");
673 if (rfolder->session == NULL) {
674 log_warning(LOG_PROTOCOL, _("Connecting to %s failed"),
675 folder->account->recv_server);
676 session_destroy(SESSION(session));
679 log_warning(LOG_PROTOCOL, _("IMAP4 connection to %s has been"
680 " disconnected. Reconnecting...\n"),
681 folder->account->recv_server);
682 statusbar_print_all(_("IMAP4 connection to %s has been"
683 " disconnected. Reconnecting...\n"),
684 folder->account->recv_server);
685 SESSION(session)->state = SESSION_DISCONNECTED;
686 session_destroy(SESSION(session));
687 /* Clear folders session to make imap_session_get create
688 a new session, because of rfolder->session == NULL
689 it will not try to reconnect again and so avoid an
691 rfolder->session = NULL;
692 debug_print("getting session...\n");
693 session = imap_session_get(folder);
694 rfolder->session = SESSION(session);
700 static void lock_session(IMAPSession *session)
705 debug_print("locking session %p (%d)\n", session, session->busy);
707 debug_print(" SESSION WAS LOCKED !! \n");
708 session->busy = TRUE;
709 mainwin = mainwindow_get_mainwindow();
711 toolbar_main_set_sensitive(mainwin);
712 main_window_set_menu_sensitive(mainwin);
715 debug_print("can't lock null session\n");
719 static void unlock_session(IMAPSession *session)
724 debug_print("unlocking session %p\n", session);
725 session->busy = FALSE;
726 mainwin = mainwindow_get_mainwindow();
728 toolbar_main_set_sensitive(mainwin);
729 main_window_set_menu_sensitive(mainwin);
732 debug_print("can't unlock null session\n");
736 static IMAPSession *imap_session_get(Folder *folder)
738 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
739 IMAPSession *session = NULL;
741 g_return_val_if_fail(folder != NULL, NULL);
742 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
743 g_return_val_if_fail(folder->account != NULL, NULL);
745 if (prefs_common.work_offline &&
746 !inc_offline_should_override(FALSE,
747 _("Claws Mail needs network access in order "
748 "to access the IMAP server."))) {
752 /* Make sure we have a session */
753 if (rfolder->session != NULL) {
754 session = IMAP_SESSION(rfolder->session);
755 } else if (rfolder->connecting) {
756 debug_print("already connecting\n");
759 imap_reset_uid_lists(folder);
760 if (time(NULL) - rfolder->last_failure <= 2)
762 rfolder->connecting = TRUE;
763 session = imap_session_new(folder, folder->account);
765 if(session == NULL) {
766 rfolder->last_failure = time(NULL);
767 rfolder->connecting = FALSE;
771 /* Make sure session is authenticated */
772 if (!IMAP_SESSION(session)->authenticated)
773 imap_session_authenticate(IMAP_SESSION(session), folder->account);
775 if (!IMAP_SESSION(session)->authenticated) {
776 imap_threaded_disconnect(session->folder);
777 SESSION(session)->state = SESSION_DISCONNECTED;
778 session_destroy(SESSION(session));
779 rfolder->session = NULL;
780 rfolder->last_failure = time(NULL);
781 rfolder->connecting = FALSE;
785 lock_session(session);
787 /* I think the point of this code is to avoid sending a
788 * keepalive if we've used the session recently and therefore
789 * think it's still alive. Unfortunately, most of the code
790 * does not yet check for errors on the socket, and so if the
791 * connection drops we don't notice until the timeout expires.
792 * A better solution than sending a NOOP every time would be
793 * for every command to be prepared to retry until it is
794 * successfully sent. -- mbp */
795 if ((time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) || session->cancelled) {
796 /* verify that the session is still alive */
797 if (imap_cmd_noop(session) != IMAP_SUCCESS) {
798 debug_print("disconnected!\n");
799 session = imap_reconnect_if_possible(folder, session);
802 session->cancelled = FALSE;
805 rfolder->session = SESSION(session);
806 rfolder->connecting = FALSE;
808 return IMAP_SESSION(session);
811 static IMAPSession *imap_session_new(Folder * folder,
812 const PrefsAccount *account)
814 IMAPSession *session;
817 int authenticated = FALSE;
820 /* FIXME: IMAP over SSL only... */
823 port = account->set_imapport ? account->imapport
824 : account->ssl_imap == SSL_TUNNEL ? IMAPS_PORT : IMAP4_PORT;
825 ssl_type = account->ssl_imap;
827 if (account->ssl_imap != SSL_NONE) {
828 if (alertpanel_full(_("Insecure connection"),
829 _("This connection is configured to be secured "
830 "using SSL, but SSL is not available in this "
831 "build of Claws Mail. \n\n"
832 "Do you want to continue connecting to this "
833 "server? The communication would not be "
835 GTK_STOCK_CANCEL, _("Con_tinue connecting"),
836 NULL, FALSE, NULL, ALERT_WARNING,
837 G_ALERTDEFAULT) != G_ALERTALTERNATE)
840 port = account->set_imapport ? account->imapport
845 statusbar_print_all(_("Connecting to IMAP4 server: %s..."), folder->account->recv_server);
846 if (account->set_tunnelcmd) {
847 r = imap_threaded_connect_cmd(folder,
849 account->recv_server,
854 if (ssl_type == SSL_TUNNEL) {
855 r = imap_threaded_connect_ssl(folder,
856 account->recv_server,
862 r = imap_threaded_connect(folder,
863 account->recv_server,
869 if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
870 authenticated = TRUE;
872 else if (r == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
873 authenticated = FALSE;
876 #if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
878 if (r == MAILIMAP_ERROR_SSL)
879 log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
882 if(!prefs_common.no_recv_err_panel) {
883 alertpanel_error_log(_("Can't connect to IMAP4 server: %s:%d"),
884 account->recv_server, port);
886 log_error(LOG_PROTOCOL, _("Can't connect to IMAP4 server: %s:%d\n"),
887 account->recv_server, port);
893 session = g_new0(IMAPSession, 1);
894 session_init(SESSION(session));
895 SESSION(session)->type = SESSION_IMAP;
896 SESSION(session)->server = g_strdup(account->recv_server);
897 SESSION(session)->sock = NULL;
899 SESSION(session)->destroy = imap_session_destroy;
901 session->capability = NULL;
903 session->authenticated = authenticated;
904 session->mbox = NULL;
907 session->expunge = 0;
908 session->cmd_count = 0;
909 session->folder = folder;
910 IMAP_FOLDER(session->folder)->last_seen_separator = 0;
913 if (account->ssl_imap == SSL_STARTTLS) {
916 ok = imap_cmd_starttls(session);
917 if (ok != IMAP_SUCCESS) {
918 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
919 session_destroy(SESSION(session));
923 imap_free_capabilities(session);
924 session->authenticated = FALSE;
925 session->uidplus = FALSE;
926 session->cmd_count = 1;
929 log_message(LOG_PROTOCOL, "IMAP connection is %s-authenticated\n",
930 (session->authenticated) ? "pre" : "un");
935 static void imap_session_authenticate(IMAPSession *session,
936 const PrefsAccount *account)
938 gchar *pass, *acc_pass;
939 gboolean failed = FALSE;
941 g_return_if_fail(account->userid != NULL);
942 acc_pass = account->passwd;
945 if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
947 tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
950 Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
952 } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
955 statusbar_print_all(_("Connecting to IMAP4 server %s...\n"),
956 account->recv_server);
957 if (imap_auth(session, account->userid, pass, account->imap_auth_type) != IMAP_SUCCESS) {
965 if (prefs_common.no_recv_err_panel) {
966 log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s."), account->recv_server);
967 mainwindow_show_error();
969 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
976 session->authenticated = TRUE;
980 static void imap_session_destroy(Session *session)
982 if (session->state != SESSION_DISCONNECTED)
983 imap_threaded_disconnect(IMAP_SESSION(session)->folder);
985 imap_free_capabilities(IMAP_SESSION(session));
986 g_free(IMAP_SESSION(session)->mbox);
987 sock_close(session->sock);
988 session->sock = NULL;
991 static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
993 return imap_fetch_msg_full(folder, item, uid, TRUE, TRUE);
996 static guint get_file_size_with_crs(const gchar *filename)
1002 if (filename == NULL)
1005 fp = fopen(filename, "rb");
1009 while (fgets(buf, sizeof (buf), fp) != NULL) {
1011 if (!strstr(buf, "\r\n") && strstr(buf, "\n"))
1019 static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
1021 gchar *path, *filename;
1023 path = folder_item_get_path(item);
1025 if (!is_dir_exist(path)) {
1030 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msginfo->msgnum), NULL);
1033 if (is_file_exist(filename)) {
1039 static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
1040 gboolean headers, gboolean body)
1042 gchar *path, *filename;
1043 IMAPSession *session;
1046 g_return_val_if_fail(folder != NULL, NULL);
1047 g_return_val_if_fail(item != NULL, NULL);
1052 path = folder_item_get_path(item);
1053 if (!is_dir_exist(path))
1054 make_dir_hier(path);
1055 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1057 debug_print("trying to fetch cached %s\n", filename);
1058 if (is_file_exist(filename)) {
1059 /* see whether the local file represents the whole message
1060 * or not. As the IMAP server reports size with \r chars,
1061 * we have to update the local file (UNIX \n only) size */
1062 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1063 guint have_size = get_file_size_with_crs(filename);
1066 debug_print("message %d has been already %scached (%d/%d).\n", uid,
1067 have_size >= cached->size ? "fully ":"",
1068 have_size, (int)cached->size);
1070 if (cached && (cached->size <= have_size || !body)) {
1071 procmsg_msginfo_free(cached);
1072 file_strip_crs(filename);
1074 } else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
1075 debug_print("message not cached and file recent, considering file complete\n");
1076 file_strip_crs(filename);
1079 procmsg_msginfo_free(cached);
1083 debug_print("getting session...\n");
1084 session = imap_session_get(folder);
1091 debug_print("IMAP fetching messages\n");
1092 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
1093 NULL, NULL, NULL, NULL, FALSE);
1094 if (ok != IMAP_SUCCESS) {
1095 g_warning("can't select mailbox %s\n", item->path);
1097 unlock_session(session);
1101 debug_print("getting message %d...\n", uid);
1102 ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
1104 if (ok != IMAP_SUCCESS) {
1105 g_warning("can't fetch message %d\n", uid);
1107 unlock_session(session);
1111 unlock_session(session);
1112 file_strip_crs(filename);
1116 static gboolean imap_is_msg_fully_cached(Folder *folder, FolderItem *item, gint uid)
1118 gchar *path, *filename;
1120 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1125 path = folder_item_get_path(item);
1126 if (!is_dir_exist(path))
1129 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1131 if (is_file_exist(filename)) {
1132 if (cached && cached->total_size == cached->size) {
1137 size = get_file_size_with_crs(filename);
1140 if (cached && size >= cached->size) {
1141 cached->total_size = cached->size;
1142 procmsg_msginfo_free(cached);
1146 procmsg_msginfo_free(cached);
1150 void imap_cache_msg(FolderItem *item, gint msgnum)
1152 Folder *folder = NULL;
1156 folder = item->folder;
1158 if (!imap_is_msg_fully_cached(folder, item, msgnum)) {
1159 gchar *tmp = imap_fetch_msg_full(folder, item, msgnum, TRUE, TRUE);
1160 debug_print("fetched %s\n", tmp);
1165 static gint imap_add_msg(Folder *folder, FolderItem *dest,
1166 const gchar *file, MsgFlags *flags)
1170 MsgFileInfo fileinfo;
1172 g_return_val_if_fail(file != NULL, -1);
1174 fileinfo.msginfo = NULL;
1175 fileinfo.file = (gchar *)file;
1176 fileinfo.flags = flags;
1177 file_list.data = &fileinfo;
1178 file_list.next = NULL;
1180 ret = imap_add_msgs(folder, dest, &file_list, NULL);
1184 static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
1185 GRelation *relation)
1188 IMAPSession *session;
1189 guint32 last_uid = 0;
1191 MsgFileInfo *fileinfo;
1193 gint curnum = 0, total = 0;
1194 gboolean missing_uids = FALSE;
1196 g_return_val_if_fail(folder != NULL, -1);
1197 g_return_val_if_fail(dest != NULL, -1);
1198 g_return_val_if_fail(file_list != NULL, -1);
1200 debug_print("getting session...\n");
1201 session = imap_session_get(folder);
1205 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1207 statusbar_print_all(_("Adding messages..."));
1208 total = g_slist_length(file_list);
1209 for (cur = file_list; cur != NULL; cur = cur->next) {
1210 IMAPFlags iflags = 0;
1211 guint32 new_uid = 0;
1212 gchar *real_file = NULL;
1213 fileinfo = (MsgFileInfo *)cur->data;
1215 statusbar_progress_all(curnum, total, total < 10 ? 1:10);
1218 if (fileinfo->flags) {
1219 if (MSG_IS_MARKED(*fileinfo->flags))
1220 iflags |= IMAP_FLAG_FLAGGED;
1221 if (MSG_IS_REPLIED(*fileinfo->flags))
1222 iflags |= IMAP_FLAG_ANSWERED;
1223 if (!MSG_IS_UNREAD(*fileinfo->flags))
1224 iflags |= IMAP_FLAG_SEEN;
1227 if (real_file == NULL)
1228 real_file = g_strdup(fileinfo->file);
1230 if (folder_has_parent_of_type(dest, F_QUEUE) ||
1231 folder_has_parent_of_type(dest, F_OUTBOX) ||
1232 folder_has_parent_of_type(dest, F_DRAFT) ||
1233 folder_has_parent_of_type(dest, F_TRASH))
1234 iflags |= IMAP_FLAG_SEEN;
1236 ok = imap_cmd_append(session, destdir, real_file, iflags,
1239 if (ok != IMAP_SUCCESS) {
1240 g_warning("can't append message %s\n", real_file);
1243 unlock_session(session);
1244 statusbar_progress_all(0,0,0);
1245 statusbar_pop_all();
1248 debug_print("appended new message as %d\n", new_uid);
1249 /* put the local file in the imapcache, so that we don't
1250 * have to fetch it back later. */
1253 missing_uids = TRUE;
1254 debug_print("Missing UID (0)\n");
1257 gchar *cache_path = folder_item_get_path(dest);
1258 if (!is_dir_exist(cache_path))
1259 make_dir_hier(cache_path);
1260 if (is_dir_exist(cache_path)) {
1261 gchar *cache_file = g_strconcat(
1262 cache_path, G_DIR_SEPARATOR_S,
1263 itos(new_uid), NULL);
1264 copy_file(real_file, cache_file, TRUE);
1265 debug_print("got UID %d, copied to cache: %s\n", new_uid, cache_file);
1272 if (relation != NULL)
1273 g_relation_insert(relation, fileinfo->msginfo != NULL ?
1274 (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
1275 GINT_TO_POINTER(new_uid));
1276 if (last_uid < new_uid) {
1283 statusbar_progress_all(0,0,0);
1284 statusbar_pop_all();
1286 unlock_session(session);
1290 imap_scan_required(folder, dest);
1294 ok = imap_select(session, IMAP_FOLDER(folder), dest->path,
1295 &a, NULL, NULL, NULL, FALSE);
1300 static GSList *flatten_mailimap_set(struct mailimap_set * set)
1302 GSList *result = NULL;
1307 for (list = clist_begin(set->set_list); list; list = clist_next(list)) {
1308 struct mailimap_set_item *item = (struct mailimap_set_item *)clist_content(list);
1309 start = item->set_first;
1310 end = item->set_last;
1311 for (t = start; t <= end; t++) {
1312 result = g_slist_prepend(result, GINT_TO_POINTER(t));
1315 result = g_slist_reverse(result);
1316 if (debug_get_mode()) {
1317 debug_print("flat imap set: ");
1318 for (cur = result; cur; cur = cur->next) {
1319 debug_print("%d ", GPOINTER_TO_INT(cur->data));
1326 static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
1327 MsgInfoList *msglist, GRelation *relation)
1331 GSList *seq_list, *cur;
1333 IMAPSession *session;
1334 gint ok = IMAP_SUCCESS;
1335 GRelation *uid_mapping;
1337 gboolean single = FALSE;
1339 g_return_val_if_fail(folder != NULL, -1);
1340 g_return_val_if_fail(dest != NULL, -1);
1341 g_return_val_if_fail(msglist != NULL, -1);
1343 debug_print("getting session...\n");
1344 session = imap_session_get(folder);
1350 msginfo = (MsgInfo *)msglist->data;
1351 if (msglist->next == NULL)
1353 src = msginfo->folder;
1355 g_warning("the src folder is identical to the dest.\n");
1356 unlock_session(session);
1360 if (src->folder != dest->folder) {
1361 GSList *infolist = NULL, *cur;
1363 for (cur = msglist; cur; cur = cur->next) {
1364 msginfo = (MsgInfo *)cur->data;
1365 MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
1366 fileinfo->file = procmsg_get_message_file(msginfo);
1367 fileinfo->flags = &(msginfo->flags);
1368 infolist = g_slist_prepend(infolist, fileinfo);
1370 infolist = g_slist_reverse(infolist);
1371 unlock_session(session);
1372 res = folder_item_add_msgs(dest, infolist, FALSE);
1373 for (cur = infolist; cur; cur = cur->next) {
1374 MsgFileInfo *info = (MsgFileInfo *)cur->data;
1378 g_slist_free(infolist);
1382 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1383 NULL, NULL, NULL, NULL, FALSE);
1384 if (ok != IMAP_SUCCESS) {
1385 unlock_session(session);
1389 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1390 seq_list = imap_get_lep_set_from_msglist(msglist);
1391 uid_mapping = g_relation_new(2);
1392 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1394 statusbar_print_all(_("Copying messages..."));
1395 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
1396 struct mailimap_set * seq_set;
1397 struct mailimap_set * source = NULL;
1398 struct mailimap_set * dest = NULL;
1399 seq_set = cur->data;
1401 debug_print("Copying messages from %s to %s ...\n",
1402 src->path, destdir);
1404 ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping,
1407 if (ok == IMAP_SUCCESS) {
1408 if (relation && source && dest) {
1409 GSList *s_list = flatten_mailimap_set(source);
1410 GSList *d_list = flatten_mailimap_set(dest);
1411 GSList *s_cur, *d_cur;
1412 if (g_slist_length(s_list) == g_slist_length(d_list)) {
1414 for (s_cur = s_list, d_cur = d_list;
1416 s_cur = s_cur->next, d_cur = d_cur->next) {
1417 g_relation_insert(uid_mapping, s_cur->data, d_cur->data);
1421 debug_print("hhhmm, source list length != dest list length.\n");
1423 g_slist_free(s_list);
1424 g_slist_free(d_list);
1430 mailimap_set_free(source);
1432 mailimap_set_free(dest);
1434 if (ok != IMAP_SUCCESS) {
1435 g_relation_destroy(uid_mapping);
1436 imap_lep_set_free(seq_list);
1437 unlock_session(session);
1438 statusbar_pop_all();
1443 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
1444 MsgInfo *msginfo = (MsgInfo *)cur->data;
1447 tuples = g_relation_select(uid_mapping,
1448 GINT_TO_POINTER(msginfo->msgnum),
1450 if (tuples->len > 0) {
1451 gint num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1452 g_relation_insert(relation, msginfo,
1453 GINT_TO_POINTER(num));
1456 debug_print("copied message %d as %d\n", msginfo->msgnum, num);
1457 /* put the local file in the imapcache, so that we don't
1458 * have to fetch it back later. */
1460 gchar *cache_path = folder_item_get_path(msginfo->folder);
1461 gchar *real_file = g_strconcat(
1462 cache_path, G_DIR_SEPARATOR_S,
1463 itos(msginfo->msgnum), NULL);
1464 gchar *cache_file = NULL;
1466 cache_path = folder_item_get_path(dest);
1467 cache_file = g_strconcat(
1468 cache_path, G_DIR_SEPARATOR_S,
1470 if (!is_dir_exist(cache_path))
1471 make_dir_hier(cache_path);
1472 if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
1473 copy_file(real_file, cache_file, TRUE);
1474 debug_print("copied to cache: %s\n", cache_file);
1481 g_relation_insert(relation, msginfo,
1482 GINT_TO_POINTER(0));
1483 g_tuples_destroy(tuples);
1485 statusbar_pop_all();
1487 g_relation_destroy(uid_mapping);
1488 imap_lep_set_free(seq_list);
1492 IMAP_FOLDER_ITEM(dest)->lastuid = 0;
1493 IMAP_FOLDER_ITEM(dest)->uid_next = 0;
1494 g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
1495 IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
1497 unlock_session(session);
1498 if (ok == IMAP_SUCCESS)
1504 static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1508 g_return_val_if_fail(msginfo != NULL, -1);
1510 msglist.data = msginfo;
1511 msglist.next = NULL;
1513 return imap_copy_msgs(folder, dest, &msglist, NULL);
1516 static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
1517 MsgInfoList *msglist, GRelation *relation)
1522 g_return_val_if_fail(folder != NULL, -1);
1523 g_return_val_if_fail(dest != NULL, -1);
1524 g_return_val_if_fail(msglist != NULL, -1);
1526 msginfo = (MsgInfo *)msglist->data;
1527 g_return_val_if_fail(msginfo->folder != NULL, -1);
1529 ret = imap_do_copy_msgs(folder, dest, msglist, relation);
1534 static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
1535 MsgInfoList *msglist, GRelation *relation)
1537 gchar *destdir, *dir;
1538 GSList *numlist = NULL, *cur;
1540 IMAPSession *session;
1541 gint ok = IMAP_SUCCESS;
1542 GRelation *uid_mapping;
1544 g_return_val_if_fail(folder != NULL, -1);
1545 g_return_val_if_fail(dest != NULL, -1);
1546 g_return_val_if_fail(msglist != NULL, -1);
1548 debug_print("getting session...\n");
1549 session = imap_session_get(folder);
1554 msginfo = (MsgInfo *)msglist->data;
1556 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1557 NULL, NULL, NULL, NULL, FALSE);
1558 if (ok != IMAP_SUCCESS) {
1559 unlock_session(session);
1563 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1564 for (cur = msglist; cur; cur = cur->next) {
1565 msginfo = (MsgInfo *)cur->data;
1566 if (!MSG_IS_DELETED(msginfo->flags))
1567 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
1569 numlist = g_slist_reverse(numlist);
1571 uid_mapping = g_relation_new(2);
1572 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1574 ok = imap_set_message_flags
1575 (session, numlist, IMAP_FLAG_DELETED, TRUE);
1576 if (ok != IMAP_SUCCESS) {
1577 log_warning(LOG_PROTOCOL, _("can't set deleted flags\n"));
1578 unlock_session(session);
1581 ok = imap_cmd_expunge(session);
1582 if (ok != IMAP_SUCCESS) {
1583 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
1584 unlock_session(session);
1588 dir = folder_item_get_path(msginfo->folder);
1589 if (is_dir_exist(dir)) {
1590 for (cur = msglist; cur; cur = cur->next) {
1591 msginfo = (MsgInfo *)cur->data;
1592 remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
1597 g_relation_destroy(uid_mapping);
1598 g_slist_free(numlist);
1601 unlock_session(session);
1602 if (ok == IMAP_SUCCESS)
1608 static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
1609 MsgInfoList *msglist, GRelation *relation)
1613 g_return_val_if_fail(folder != NULL, -1);
1614 g_return_val_if_fail(dest != NULL, -1);
1615 if (msglist == NULL)
1618 msginfo = (MsgInfo *)msglist->data;
1619 g_return_val_if_fail(msginfo->folder != NULL, -1);
1621 return imap_do_remove_msgs(folder, dest, msglist, relation);
1624 static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
1626 GSList *list = folder_item_get_msg_list(item);
1627 gint res = imap_remove_msgs(folder, item, list, NULL);
1628 procmsg_msg_list_free(list);
1632 static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
1635 /* TODO: properly implement this method */
1639 static gint imap_close(Folder *folder, FolderItem *item)
1644 gint imap_scan_tree_real(Folder *folder, gboolean subs_only)
1646 FolderItem *item = NULL;
1647 IMAPSession *session;
1648 gchar *root_folder = NULL;
1650 g_return_val_if_fail(folder != NULL, -1);
1651 g_return_val_if_fail(folder->account != NULL, -1);
1653 debug_print("getting session...\n");
1654 session = imap_session_get(folder);
1656 if (!folder->node) {
1657 folder_tree_destroy(folder);
1658 item = folder_item_new(folder, folder->name, NULL);
1659 item->folder = folder;
1660 folder->node = item->node = g_node_new(item);
1665 if (folder->account->imap_dir && *folder->account->imap_dir) {
1670 Xstrdup_a(root_folder, folder->account->imap_dir, {unlock_session(session);return -1;});
1671 extract_quote(root_folder, '"');
1672 subst_char(root_folder,
1673 imap_get_path_separator(session, IMAP_FOLDER(folder),
1676 strtailchomp(root_folder, '/');
1677 real_path = imap_get_real_path
1678 (session, IMAP_FOLDER(folder), root_folder);
1679 debug_print("IMAP root directory: %s\n", real_path);
1681 /* check if root directory exist */
1683 r = imap_threaded_list(session->folder, "", real_path,
1685 if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
1686 if (!folder->node) {
1687 item = folder_item_new(folder, folder->name, NULL);
1688 item->folder = folder;
1689 folder->node = item->node = g_node_new(item);
1691 unlock_session(session);
1694 mailimap_list_result_free(lep_list);
1700 item = FOLDER_ITEM(folder->node->data);
1702 if (item && !item->path && root_folder) {
1703 item->path = g_strdup(root_folder);
1706 if (!item || ((item->path || root_folder) &&
1707 strcmp2(item->path, root_folder) != 0)) {
1708 folder_tree_destroy(folder);
1709 item = folder_item_new(folder, folder->name, root_folder);
1710 item->folder = folder;
1711 folder->node = item->node = g_node_new(item);
1714 imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data), subs_only);
1715 imap_create_missing_folders(folder);
1716 unlock_session(session);
1721 static gint imap_scan_tree(Folder *folder)
1723 gboolean subs_only = FALSE;
1724 if (folder->account) {
1725 debug_print(" scanning only subs %d\n", folder->account->imap_subsonly);
1726 subs_only = folder->account->imap_subsonly;
1728 return imap_scan_tree_real(folder, subs_only);
1731 static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item, gboolean subs_only)
1734 IMAPFolder *imapfolder;
1735 FolderItem *new_item;
1736 GSList *item_list, *cur;
1739 gchar *wildcard_path;
1745 g_return_val_if_fail(item != NULL, -1);
1746 g_return_val_if_fail(item->folder != NULL, -1);
1747 g_return_val_if_fail(item->no_sub == FALSE, -1);
1749 folder = item->folder;
1750 imapfolder = IMAP_FOLDER(folder);
1752 separator = imap_get_path_separator(session, imapfolder, item->path);
1754 if (folder->ui_func)
1755 folder->ui_func(folder, item, folder->ui_func_data);
1758 wildcard[0] = separator;
1761 real_path = imap_get_real_path(session, imapfolder, item->path);
1765 real_path = g_strdup("");
1768 Xstrcat_a(wildcard_path, real_path, wildcard,
1769 {g_free(real_path); return IMAP_ERROR;});
1773 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
1775 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
1777 if (r != MAILIMAP_NO_ERROR) {
1781 item_list = imap_list_from_lep(imapfolder,
1782 lep_list, real_path, FALSE);
1783 mailimap_list_result_free(lep_list);
1788 node = item->node->children;
1789 while (node != NULL) {
1790 FolderItem *old_item = FOLDER_ITEM(node->data);
1791 GNode *next = node->next;
1794 for (cur = item_list; cur != NULL; cur = cur->next) {
1795 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1796 if (!strcmp2(old_item->path, cur_item->path)) {
1797 new_item = cur_item;
1802 if (old_item && old_item->path && !strcmp(old_item->path, "INBOX")) {
1803 debug_print("not removing INBOX\n");
1805 debug_print("folder '%s' not found. removing...\n",
1807 folder_item_remove(old_item);
1810 old_item->no_sub = new_item->no_sub;
1811 old_item->no_select = new_item->no_select;
1812 if (old_item->no_sub == TRUE && node->children) {
1813 debug_print("folder '%s' doesn't have "
1814 "subfolders. removing...\n",
1816 folder_item_remove_children(old_item);
1823 for (cur = item_list; cur != NULL; cur = cur->next) {
1824 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1827 for (node = item->node->children; node != NULL;
1828 node = node->next) {
1829 if (!strcmp2(FOLDER_ITEM(node->data)->path,
1831 new_item = FOLDER_ITEM(node->data);
1832 folder_item_destroy(cur_item);
1838 new_item = cur_item;
1839 debug_print("new folder '%s' found.\n", new_item->path);
1840 folder_item_append(item, new_item);
1843 if (!strcmp(new_item->path, "INBOX")) {
1844 new_item->stype = F_INBOX;
1845 folder->inbox = new_item;
1846 } else if (!folder_item_parent(item) || item->stype == F_INBOX) {
1849 base = g_path_get_basename(new_item->path);
1851 if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
1852 new_item->stype = F_OUTBOX;
1853 folder->outbox = new_item;
1854 } else if (!folder->draft && !g_ascii_strcasecmp(base, "Drafts")) {
1855 new_item->stype = F_DRAFT;
1856 folder->draft = new_item;
1857 } else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
1858 new_item->stype = F_QUEUE;
1859 folder->queue = new_item;
1860 } else if (!folder->trash && !g_ascii_strcasecmp(base, "Trash")) {
1861 new_item->stype = F_TRASH;
1862 folder->trash = new_item;
1867 if (new_item->no_sub == FALSE)
1868 imap_scan_tree_recursive(session, new_item, subs_only);
1871 g_slist_free(item_list);
1873 return IMAP_SUCCESS;
1876 GList *imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
1878 IMAPSession *session = imap_session_get(folder);
1880 gchar *wildcard_path;
1884 GSList *item_list = NULL, *cur;
1885 GList *child_list = NULL, *tmplist = NULL;
1886 GSList *sub_list = NULL;
1892 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
1895 wildcard[0] = separator;
1898 real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
1902 real_path = g_strdup("");
1905 Xstrcat_a(wildcard_path, real_path, wildcard,
1906 {g_free(real_path); return NULL;});
1910 statusbar_print_all(_("Looking for unsubscribed folders in %s..."),
1911 item->path?item->path:item->name);
1913 statusbar_print_all(_("Looking for subfolders of %s..."),
1914 item->path?item->path:item->name);
1916 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
1918 statusbar_pop_all();
1921 item_list = imap_list_from_lep(IMAP_FOLDER(folder),
1922 lep_list, real_path, FALSE);
1923 mailimap_list_result_free(lep_list);
1925 for (cur = item_list; cur != NULL; cur = cur->next) {
1926 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1928 tmplist = imap_scan_subtree(folder, cur_item,
1929 unsubs_only, recursive);
1931 child_list = g_list_concat(child_list, tmplist);
1933 child_list = g_list_prepend(child_list,
1934 imap_get_real_path(session,
1935 IMAP_FOLDER(folder), cur_item->path));
1937 folder_item_destroy(cur_item);
1939 child_list = g_list_reverse(child_list);
1940 g_slist_free(item_list);
1943 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
1945 statusbar_pop_all();
1948 sub_list = imap_list_from_lep(IMAP_FOLDER(folder),
1949 lep_list, real_path, FALSE);
1950 mailimap_list_result_free(lep_list);
1952 for (cur = sub_list; cur != NULL; cur = cur->next) {
1953 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1954 GList *oldlitem = NULL;
1955 gchar *tmp = imap_get_real_path(session,
1956 IMAP_FOLDER(folder), cur_item->path);
1957 folder_item_destroy(cur_item);
1958 oldlitem = g_list_find_custom(
1959 child_list, tmp, (GCompareFunc)strcmp2);
1961 child_list = g_list_remove_link(child_list, oldlitem);
1962 g_free(oldlitem->data);
1963 g_list_free(oldlitem);
1969 statusbar_pop_all();
1974 static gint imap_create_tree(Folder *folder)
1976 g_return_val_if_fail(folder != NULL, -1);
1977 g_return_val_if_fail(folder->node != NULL, -1);
1978 g_return_val_if_fail(folder->node->data != NULL, -1);
1979 g_return_val_if_fail(folder->account != NULL, -1);
1981 imap_scan_tree(folder);
1982 imap_create_missing_folders(folder);
1987 static void imap_create_missing_folders(Folder *folder)
1989 g_return_if_fail(folder != NULL);
1992 folder->inbox = imap_create_special_folder
1993 (folder, F_INBOX, "INBOX");
1995 folder->trash = imap_create_special_folder
1996 (folder, F_TRASH, "Trash");
1998 folder->queue = imap_create_special_folder
1999 (folder, F_QUEUE, "Queue");
2000 if (!folder->outbox)
2001 folder->outbox = imap_create_special_folder
2002 (folder, F_OUTBOX, "Sent");
2004 folder->draft = imap_create_special_folder
2005 (folder, F_DRAFT, "Drafts");
2008 static FolderItem *imap_create_special_folder(Folder *folder,
2009 SpecialFolderItemType stype,
2013 FolderItem *new_item;
2015 g_return_val_if_fail(folder != NULL, NULL);
2016 g_return_val_if_fail(folder->node != NULL, NULL);
2017 g_return_val_if_fail(folder->node->data != NULL, NULL);
2018 g_return_val_if_fail(folder->account != NULL, NULL);
2019 g_return_val_if_fail(name != NULL, NULL);
2021 item = FOLDER_ITEM(folder->node->data);
2022 new_item = imap_create_folder(folder, item, name);
2025 g_warning("Can't create '%s'\n", name);
2026 if (!folder->inbox) return NULL;
2028 new_item = imap_create_folder(folder, folder->inbox, name);
2030 g_warning("Can't create '%s' under INBOX\n", name);
2032 new_item->stype = stype;
2034 new_item->stype = stype;
2039 static gchar *imap_folder_get_path(Folder *folder)
2043 g_return_val_if_fail(folder != NULL, NULL);
2044 g_return_val_if_fail(folder->account != NULL, NULL);
2046 folder_path = g_strconcat(get_imap_cache_dir(),
2048 folder->account->recv_server,
2050 folder->account->userid,
2056 static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
2058 gchar *folder_path, *path;
2060 g_return_val_if_fail(folder != NULL, NULL);
2061 g_return_val_if_fail(item != NULL, NULL);
2062 folder_path = imap_folder_get_path(folder);
2064 g_return_val_if_fail(folder_path != NULL, NULL);
2065 if (folder_path[0] == G_DIR_SEPARATOR) {
2067 path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
2070 path = g_strdup(folder_path);
2073 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2074 folder_path, G_DIR_SEPARATOR_S,
2077 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2080 g_free(folder_path);
2085 static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
2088 gchar *dirpath, *imap_path;
2089 IMAPSession *session;
2090 FolderItem *new_item;
2095 gboolean no_select = FALSE, no_sub = FALSE;
2096 gboolean exist = FALSE;
2098 g_return_val_if_fail(folder != NULL, NULL);
2099 g_return_val_if_fail(folder->account != NULL, NULL);
2100 g_return_val_if_fail(parent != NULL, NULL);
2101 g_return_val_if_fail(name != NULL, NULL);
2103 debug_print("getting session...\n");
2104 session = imap_session_get(folder);
2109 if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
2110 dirpath = g_strdup(name);
2111 }else if (parent->path)
2112 dirpath = g_strconcat(parent->path, "/", name, NULL);
2113 else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
2114 dirpath = g_strdup(name);
2115 else if (folder->account->imap_dir && *folder->account->imap_dir) {
2118 Xstrdup_a(imap_dir, folder->account->imap_dir, {unlock_session(session);return NULL;});
2119 strtailchomp(imap_dir, '/');
2120 dirpath = g_strconcat(imap_dir, "/", name, NULL);
2122 dirpath = g_strdup(name);
2126 /* keep trailing directory separator to create a folder that contains
2128 imap_path = imap_utf8_to_modified_utf7(dirpath);
2130 strtailchomp(dirpath, '/');
2131 Xstrdup_a(new_name, name, {
2133 unlock_session(session);
2136 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path);
2137 imap_path_separator_subst(imap_path, separator);
2138 /* remove trailing / for display */
2139 strtailchomp(new_name, '/');
2141 if (strcmp(dirpath, "INBOX") != 0) {
2146 argbuf = g_ptr_array_new();
2147 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2148 if (r != MAILIMAP_NO_ERROR) {
2149 log_warning(LOG_PROTOCOL, _("can't create mailbox: LIST failed\n"));
2152 ptr_array_free_strings(argbuf);
2153 g_ptr_array_free(argbuf, TRUE);
2154 unlock_session(session);
2158 if (clist_count(lep_list) > 0)
2160 mailimap_list_result_free(lep_list);
2163 ok = imap_cmd_create(session, imap_path);
2164 if (ok != IMAP_SUCCESS) {
2165 log_warning(LOG_PROTOCOL, _("can't create mailbox\n"));
2168 unlock_session(session);
2171 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2172 if (r == MAILIMAP_NO_ERROR) {
2173 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2174 lep_list, dirpath, TRUE);
2176 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2177 no_select = cur_item->no_select;
2178 no_sub = cur_item->no_sub;
2179 g_slist_free(item_list);
2181 mailimap_list_result_free(lep_list);
2184 imap_threaded_subscribe(folder, imap_path, TRUE);
2188 /* just get flags */
2189 r = imap_threaded_list(folder, "", "INBOX", &lep_list);
2190 if (r == MAILIMAP_NO_ERROR) {
2191 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2192 lep_list, dirpath, TRUE);
2194 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2195 no_select = cur_item->no_select;
2196 no_sub = cur_item->no_sub;
2197 g_slist_free(item_list);
2199 mailimap_list_result_free(lep_list);
2203 new_item = folder_item_new(folder, new_name, dirpath);
2204 new_item->no_select = no_select;
2205 new_item->no_sub = no_sub;
2206 folder_item_append(parent, new_item);
2210 dirpath = folder_item_get_path(new_item);
2211 if (!is_dir_exist(dirpath))
2212 make_dir_hier(dirpath);
2214 unlock_session(session);
2217 /* folder existed, scan it */
2218 imap_scan_required(folder, new_item);
2219 folder_item_scan_full(new_item, FALSE);
2225 static gint imap_rename_folder(Folder *folder, FolderItem *item,
2230 gchar *real_oldpath;
2231 gchar *real_newpath;
2233 gchar *old_cache_dir;
2234 gchar *new_cache_dir;
2235 IMAPSession *session;
2238 gint exists, recent, unseen;
2239 guint32 uid_validity;
2241 g_return_val_if_fail(folder != NULL, -1);
2242 g_return_val_if_fail(item != NULL, -1);
2243 g_return_val_if_fail(item->path != NULL, -1);
2244 g_return_val_if_fail(name != NULL, -1);
2246 debug_print("getting session...\n");
2247 session = imap_session_get(folder);
2252 if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path)) != NULL) {
2253 g_warning(_("New folder name must not contain the namespace "
2255 unlock_session(session);
2259 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2261 g_free(session->mbox);
2262 session->mbox = NULL;
2263 session->exists = 0;
2264 session->recent = 0;
2265 session->expunge = 0;
2266 ok = imap_cmd_examine(session, "INBOX",
2267 &exists, &recent, &unseen, &uid_validity, FALSE);
2268 if (ok != IMAP_SUCCESS) {
2269 g_free(real_oldpath);
2270 unlock_session(session);
2274 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
2275 if (strchr(item->path, G_DIR_SEPARATOR)) {
2276 dirpath = g_path_get_dirname(item->path);
2277 newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
2280 newpath = g_strdup(name);
2282 real_newpath = imap_utf8_to_modified_utf7(newpath);
2283 imap_path_separator_subst(real_newpath, separator);
2285 ok = imap_cmd_rename(session, real_oldpath, real_newpath);
2286 if (ok != IMAP_SUCCESS) {
2287 log_warning(LOG_PROTOCOL, _("can't rename mailbox: %s to %s\n"),
2288 real_oldpath, real_newpath);
2289 g_free(real_oldpath);
2291 g_free(real_newpath);
2292 unlock_session(session);
2296 item->name = g_strdup(name);
2298 old_cache_dir = folder_item_get_path(item);
2300 paths[0] = g_strdup(item->path);
2302 g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
2303 imap_rename_folder_func, paths);
2305 if (is_dir_exist(old_cache_dir)) {
2306 new_cache_dir = folder_item_get_path(item);
2307 if (rename(old_cache_dir, new_cache_dir) < 0) {
2308 FILE_OP_ERROR(old_cache_dir, "rename");
2310 g_free(new_cache_dir);
2313 g_free(old_cache_dir);
2316 g_free(real_oldpath);
2317 g_free(real_newpath);
2318 unlock_session(session);
2322 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
2326 IMAPSession *session;
2327 debug_print("getting session...\n");
2329 session = imap_session_get(folder);
2333 if (item && item->path) {
2334 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2337 if (!strcmp(path, "INBOX") && sub == FALSE)
2339 debug_print("%ssubscribing %s\n", sub?"":"un", path);
2340 r = imap_threaded_subscribe(folder, path, sub);
2343 r = imap_threaded_subscribe(folder, rpath, sub);
2349 static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
2352 IMAPSession *session;
2355 gboolean selected_folder;
2357 g_return_val_if_fail(folder != NULL, -1);
2358 g_return_val_if_fail(item != NULL, -1);
2359 g_return_val_if_fail(item->path != NULL, -1);
2361 debug_print("getting session...\n");
2362 session = imap_session_get(folder);
2366 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2368 imap_threaded_subscribe(folder, path, FALSE);
2370 selected_folder = (session->mbox != NULL) &&
2371 (!strcmp(session->mbox, item->path));
2372 if (selected_folder) {
2373 ok = imap_cmd_close(session);
2374 if (ok != MAILIMAP_NO_ERROR) {
2375 debug_print("close err %d\n", ok);
2379 ok = imap_cmd_delete(session, path);
2380 if (ok != IMAP_SUCCESS) {
2381 gchar *tmp = g_strdup_printf("%s%c", path,
2382 imap_get_path_separator(session, IMAP_FOLDER(folder), path));
2385 ok = imap_cmd_delete(session, path);
2388 if (ok != IMAP_SUCCESS) {
2389 log_warning(LOG_PROTOCOL, _("can't delete mailbox\n"));
2391 unlock_session(session);
2396 cache_dir = folder_item_get_path(item);
2397 if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
2398 g_warning("can't remove directory '%s'\n", cache_dir);
2400 folder_item_remove(item);
2401 unlock_session(session);
2405 static gint imap_remove_folder(Folder *folder, FolderItem *item)
2409 g_return_val_if_fail(item != NULL, -1);
2410 g_return_val_if_fail(item->folder != NULL, -1);
2411 g_return_val_if_fail(item->node != NULL, -1);
2413 node = item->node->children;
2414 while (node != NULL) {
2416 if (imap_remove_folder(folder, FOLDER_ITEM(node->data)) < 0)
2420 debug_print("IMAP removing %s\n", item->path);
2422 if (imap_remove_all_msg(folder, item) < 0)
2424 return imap_remove_folder_real(folder, item);
2427 typedef struct _uncached_data {
2428 IMAPSession *session;
2430 MsgNumberList *numlist;
2436 static void *imap_get_uncached_messages_thread(void *data)
2438 uncached_data *stuff = (uncached_data *)data;
2439 IMAPSession *session = stuff->session;
2440 FolderItem *item = stuff->item;
2441 MsgNumberList *numlist = stuff->numlist;
2443 GSList *newlist = NULL;
2444 GSList *llast = NULL;
2445 GSList *seq_list, *cur;
2447 debug_print("uncached_messages\n");
2449 if (session == NULL || item == NULL || item->folder == NULL
2450 || FOLDER_CLASS(item->folder) != &imap_class) {
2455 seq_list = imap_get_lep_set_from_numlist(numlist);
2456 debug_print("get msgs info\n");
2457 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2458 struct mailimap_set * imapset;
2464 if (session->cancelled)
2467 imapset = cur->data;
2469 r = imap_threaded_fetch_env(session->folder,
2470 imapset, &env_list);
2471 if (r != MAILIMAP_NO_ERROR)
2474 session_set_access_time(SESSION(session));
2477 for(i = 0 ; i < carray_count(env_list) ; i ++) {
2478 struct imap_fetch_env_info * info;
2481 info = carray_get(env_list, i);
2482 msginfo = imap_envelope_from_lep(info, item);
2483 if (msginfo == NULL)
2485 msginfo->folder = item;
2487 llast = newlist = g_slist_append(newlist, msginfo);
2489 llast = g_slist_append(llast, msginfo);
2490 llast = llast->next;
2495 imap_fetch_env_free(env_list);
2498 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2499 struct mailimap_set * imapset;
2501 imapset = cur->data;
2502 mailimap_set_free(imapset);
2505 session_set_access_time(SESSION(session));
2510 #define MAX_MSG_NUM 50
2512 static GSList *imap_get_uncached_messages(IMAPSession *session,
2514 MsgNumberList *numlist)
2516 GSList *result = NULL;
2518 uncached_data *data = g_new0(uncached_data, 1);
2523 data->total = g_slist_length(numlist);
2524 debug_print("messages list : %i\n", data->total);
2526 while (cur != NULL) {
2527 GSList * partial_result;
2535 while (count < MAX_MSG_NUM) {
2540 if (newlist == NULL)
2541 llast = newlist = g_slist_append(newlist, p);
2543 llast = g_slist_append(llast, p);
2544 llast = llast->next;
2554 data->session = session;
2556 data->numlist = newlist;
2559 if (prefs_common.work_offline &&
2560 !inc_offline_should_override(FALSE,
2561 _("Claws Mail needs network access in order "
2562 "to access the IMAP server."))) {
2568 (GSList *)imap_get_uncached_messages_thread(data);
2570 statusbar_progress_all(data->cur,data->total, 1);
2572 g_slist_free(newlist);
2574 result = g_slist_concat(result, partial_result);
2578 statusbar_progress_all(0,0,0);
2579 statusbar_pop_all();
2584 static void imap_delete_all_cached_messages(FolderItem *item)
2588 g_return_if_fail(item != NULL);
2589 g_return_if_fail(item->folder != NULL);
2590 g_return_if_fail(FOLDER_CLASS(item->folder) == &imap_class);
2592 debug_print("Deleting all cached messages...\n");
2594 dir = folder_item_get_path(item);
2595 if (is_dir_exist(dir))
2596 remove_all_numbered_files(dir);
2599 debug_print("done.\n");
2602 gchar imap_get_path_separator_for_item(FolderItem *item)
2604 Folder *folder = NULL;
2605 IMAPFolder *imap_folder = NULL;
2606 IMAPSession *session = NULL;
2611 folder = item->folder;
2616 imap_folder = IMAP_FOLDER(folder);
2621 debug_print("getting session...");
2622 session = imap_session_get(FOLDER(folder));
2623 result = imap_get_path_separator(session, imap_folder, item->path);
2624 unlock_session(session);
2628 static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder)
2632 gchar separator = '\0';
2634 g_return_val_if_fail(session != NULL, '/');
2635 r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
2637 if (r != MAILIMAP_NO_ERROR) {
2638 log_warning(LOG_PROTOCOL, _("LIST failed\n"));
2642 if (clist_count(lep_list) > 0) {
2643 clistiter * iter = clist_begin(lep_list);
2644 struct mailimap_mailbox_list * mb;
2645 mb = clist_content(iter);
2647 separator = mb->mb_delimiter;
2648 debug_print("got separator: %c\n", folder->last_seen_separator);
2650 mailimap_list_result_free(lep_list);
2654 static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2656 gchar separator = '/';
2658 if (folder->last_seen_separator == 0) {
2659 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "");
2662 if (folder->last_seen_separator == 0) {
2663 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX");
2666 if (folder->last_seen_separator != 0) {
2667 debug_print("using separator: %c\n", folder->last_seen_separator);
2668 return folder->last_seen_separator;
2674 static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2679 g_return_val_if_fail(folder != NULL, NULL);
2680 g_return_val_if_fail(path != NULL, NULL);
2682 real_path = imap_utf8_to_modified_utf7(path);
2683 separator = imap_get_path_separator(session, folder, path);
2684 imap_path_separator_subst(real_path, separator);
2689 static gint imap_set_message_flags(IMAPSession *session,
2690 MsgNumberList *numlist,
2698 seq_list = imap_get_lep_set_from_numlist(numlist);
2700 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
2701 struct mailimap_set * imapset;
2703 imapset = cur->data;
2705 ok = imap_cmd_store(session, imapset,
2709 imap_lep_set_free(seq_list);
2711 return IMAP_SUCCESS;
2714 typedef struct _select_data {
2715 IMAPSession *session;
2720 guint32 *uid_validity;
2724 static gint imap_select(IMAPSession *session, IMAPFolder *folder,
2726 gint *exists, gint *recent, gint *unseen,
2727 guint32 *uid_validity, gboolean block)
2731 gint exists_, recent_, unseen_;
2732 guint32 uid_validity_;
2734 if (!exists && !recent && !unseen && !uid_validity) {
2735 if (session->mbox && strcmp(session->mbox, path) == 0)
2736 return IMAP_SUCCESS;
2745 uid_validity = &uid_validity_;
2747 g_free(session->mbox);
2748 session->mbox = NULL;
2749 session->exists = 0;
2750 session->recent = 0;
2751 session->expunge = 0;
2753 real_path = imap_get_real_path(session, folder, path);
2755 ok = imap_cmd_select(session, real_path,
2756 exists, recent, unseen, uid_validity, block);
2757 if (ok != IMAP_SUCCESS)
2758 log_warning(LOG_PROTOCOL, _("can't select folder: %s\n"), real_path);
2760 session->mbox = g_strdup(path);
2761 session->folder_content_changed = FALSE;
2762 session->exists = *exists;
2763 session->recent = *recent;
2764 session->expunge = 0;
2765 session->unseen = *unseen;
2766 session->uid_validity = *uid_validity;
2767 debug_print("select: exists %d recent %d expunge %d uid_validity %d\n",
2768 session->exists, session->recent, session->expunge,
2769 session->uid_validity);
2776 static gint imap_status(IMAPSession *session, IMAPFolder *folder,
2777 const gchar *path, IMAPFolderItem *item,
2779 guint32 *uid_next, guint32 *uid_validity,
2780 gint *unseen, gboolean block)
2784 struct mailimap_mailbox_data_status * data_status;
2789 real_path = imap_get_real_path(session, folder, path);
2808 if (session->mbox != NULL &&
2809 !strcmp(session->mbox, item->item.path)) {
2810 r = imap_cmd_close(session);
2811 if (r != MAILIMAP_NO_ERROR) {
2812 debug_print("close err %d\n", r);
2817 r = imap_threaded_status(FOLDER(folder), real_path,
2818 &data_status, mask);
2821 if (r != MAILIMAP_NO_ERROR) {
2822 debug_print("status err %d\n", r);
2826 if (data_status->st_info_list == NULL) {
2827 mailimap_mailbox_data_status_free(data_status);
2828 debug_print("status->st_info_list == NULL\n");
2833 for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
2834 iter = clist_next(iter)) {
2835 struct mailimap_status_info * info;
2837 info = clist_content(iter);
2838 switch (info->st_att) {
2839 case MAILIMAP_STATUS_ATT_MESSAGES:
2841 * messages = info->st_value;
2842 got_values |= 1 << 0;
2846 case MAILIMAP_STATUS_ATT_UIDNEXT:
2848 * uid_next = info->st_value;
2849 got_values |= 1 << 2;
2853 case MAILIMAP_STATUS_ATT_UIDVALIDITY:
2855 * uid_validity = info->st_value;
2856 got_values |= 1 << 3;
2860 case MAILIMAP_STATUS_ATT_UNSEEN:
2862 * unseen = info->st_value;
2863 got_values |= 1 << 4;
2868 mailimap_mailbox_data_status_free(data_status);
2870 if (got_values != mask) {
2871 g_warning("status: incomplete values received (%d)\n", got_values);
2873 return IMAP_SUCCESS;
2876 static void imap_free_capabilities(IMAPSession *session)
2878 slist_free_strings(session->capability);
2879 g_slist_free(session->capability);
2880 session->capability = NULL;
2883 /* low-level IMAP4rev1 commands */
2885 static gint imap_cmd_login(IMAPSession *session,
2886 const gchar *user, const gchar *pass,
2892 if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
2893 gint ok = IMAP_ERROR;
2894 if (imap_has_capability(session, "STARTTLS")) {
2896 log_warning(LOG_PROTOCOL, _("Server requires TLS to log in.\n"));
2897 ok = imap_cmd_starttls(session);
2898 if (ok != IMAP_SUCCESS) {
2899 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
2903 imap_free_capabilities(session);
2904 if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR) {
2905 log_warning(LOG_PROTOCOL, _("Can't refresh capabilities.\n"));
2910 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
2911 "server requires TLS, but Claws Mail "
2912 "has been compiled without OpenSSL "
2914 SESSION(session)->server);
2918 log_error(LOG_PROTOCOL, _("Server logins are disabled.\n"));
2923 log_print(LOG_PROTOCOL, "IMAP4> Logging %s to %s using %s\n",
2925 SESSION(session)->server,
2927 r = imap_threaded_login(session->folder, user, pass, type);
2928 if (r != MAILIMAP_NO_ERROR) {
2929 log_print(LOG_PROTOCOL, "IMAP4< Error logging in to %s\n",
2930 SESSION(session)->server);
2933 log_print(LOG_PROTOCOL, "IMAP4< Login to %s successful\n",
2934 SESSION(session)->server);
2940 static gint imap_cmd_noop(IMAPSession *session)
2943 unsigned int exists, recent, expunge, unseen, uidnext, uidval;
2945 r = imap_threaded_noop(session->folder, &exists, &recent, &expunge, &unseen, &uidnext, &uidval);
2946 if (r != MAILIMAP_NO_ERROR) {
2947 debug_print("noop err %d\n", r);
2951 session->folder_content_changed = FALSE;
2953 if ((exists && exists != session->exists)
2954 || (recent && recent != session->recent)
2955 || (expunge && expunge != session->expunge)
2956 || (unseen && unseen != session->unseen)) {
2957 session->folder_content_changed = TRUE;
2959 if (uidnext != 0 && uidnext != session->uid_next) {
2960 session->uid_next = uidnext;
2961 session->folder_content_changed = TRUE;
2963 if (uidval != 0 && uidval != session->uid_validity) {
2964 session->uid_validity = uidval;
2965 session->folder_content_changed = TRUE;
2968 session->exists = exists;
2969 session->recent = recent;
2970 session->expunge = expunge;
2971 session->unseen = unseen;
2973 session_set_access_time(SESSION(session));
2975 return IMAP_SUCCESS;
2979 static gint imap_cmd_starttls(IMAPSession *session)
2983 r = imap_threaded_starttls(session->folder,
2984 SESSION(session)->server, SESSION(session)->port);
2985 if (r != MAILIMAP_NO_ERROR) {
2986 debug_print("starttls err %d\n", r);
2989 return IMAP_SUCCESS;
2993 static gint imap_cmd_select(IMAPSession *session, const gchar *folder,
2994 gint *exists, gint *recent, gint *unseen,
2995 guint32 *uid_validity, gboolean block)
2999 r = imap_threaded_select(session->folder, folder,
3000 exists, recent, unseen, uid_validity);
3001 if (r != MAILIMAP_NO_ERROR) {
3002 debug_print("select err %d\n", r);
3005 return IMAP_SUCCESS;
3008 static gint imap_cmd_close(IMAPSession *session)
3012 r = imap_threaded_close(session->folder);
3013 if (r != MAILIMAP_NO_ERROR) {
3014 debug_print("close err %d\n", r);
3017 g_free(session->mbox);
3018 session->mbox = NULL;
3019 session->exists = 0;
3020 session->recent = 0;
3021 session->expunge = 0;
3022 return IMAP_SUCCESS;
3025 static gint imap_cmd_examine(IMAPSession *session, const gchar *folder,
3026 gint *exists, gint *recent, gint *unseen,
3027 guint32 *uid_validity, gboolean block)
3031 r = imap_threaded_examine(session->folder, folder,
3032 exists, recent, unseen, uid_validity);
3033 if (r != MAILIMAP_NO_ERROR) {
3034 debug_print("examine err %d\n", r);
3038 return IMAP_SUCCESS;
3041 static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
3045 r = imap_threaded_create(session->folder, folder);
3046 if (r != MAILIMAP_NO_ERROR) {
3051 return IMAP_SUCCESS;
3054 static gint imap_cmd_rename(IMAPSession *session, const gchar *old_folder,
3055 const gchar *new_folder)
3059 r = imap_threaded_rename(session->folder, old_folder,
3061 if (r != MAILIMAP_NO_ERROR) {
3066 return IMAP_SUCCESS;
3069 static gint imap_cmd_delete(IMAPSession *session, const gchar *folder)
3074 r = imap_threaded_delete(session->folder, folder);
3075 if (r != MAILIMAP_NO_ERROR) {
3080 return IMAP_SUCCESS;
3083 typedef struct _fetch_data {
3084 IMAPSession *session;
3086 const gchar *filename;
3092 static void *imap_cmd_fetch_thread(void *data)
3094 fetch_data *stuff = (fetch_data *)data;
3095 IMAPSession *session = stuff->session;
3096 guint32 uid = stuff->uid;
3097 const gchar *filename = stuff->filename;
3101 r = imap_threaded_fetch_content(session->folder,
3105 r = imap_threaded_fetch_content(session->folder,
3108 if (r != MAILIMAP_NO_ERROR) {
3109 debug_print("fetch err %d\n", r);
3110 return GINT_TO_POINTER(IMAP_ERROR);
3112 return GINT_TO_POINTER(IMAP_SUCCESS);
3115 static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
3116 const gchar *filename, gboolean headers,
3119 fetch_data *data = g_new0(fetch_data, 1);
3122 data->session = session;
3124 data->filename = filename;
3125 data->headers = headers;
3128 if (prefs_common.work_offline &&
3129 !inc_offline_should_override(FALSE,
3130 _("Claws Mail needs network access in order "
3131 "to access the IMAP server."))) {
3135 statusbar_print_all(_("Fetching message..."));
3136 result = GPOINTER_TO_INT(imap_cmd_fetch_thread(data));
3137 statusbar_pop_all();
3143 static gint imap_cmd_append(IMAPSession *session, const gchar *destfolder,
3144 const gchar *file, IMAPFlags flags,
3147 struct mailimap_flag_list * flag_list;
3150 g_return_val_if_fail(file != NULL, IMAP_ERROR);
3152 flag_list = imap_flag_to_lep(flags);
3153 r = imap_threaded_append(session->folder, destfolder,
3154 file, flag_list, (int *)new_uid);
3155 mailimap_flag_list_free(flag_list);
3157 if (r != MAILIMAP_NO_ERROR) {
3158 debug_print("append err %d\n", r);
3161 return IMAP_SUCCESS;
3164 static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
3165 const gchar *destfolder, GRelation *uid_mapping,
3166 struct mailimap_set **source, struct mailimap_set **dest)
3170 g_return_val_if_fail(session != NULL, IMAP_ERROR);
3171 g_return_val_if_fail(set != NULL, IMAP_ERROR);
3172 g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
3174 r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
3175 if (r != MAILIMAP_NO_ERROR) {
3180 return IMAP_SUCCESS;
3183 static gint imap_cmd_store(IMAPSession *session, struct mailimap_set * set,
3184 IMAPFlags flags, int do_add)
3187 struct mailimap_flag_list * flag_list;
3188 struct mailimap_store_att_flags * store_att_flags;
3190 flag_list = imap_flag_to_lep(flags);
3194 mailimap_store_att_flags_new_add_flags_silent(flag_list);
3197 mailimap_store_att_flags_new_remove_flags_silent(flag_list);
3199 r = imap_threaded_store(session->folder, set, store_att_flags);
3200 mailimap_store_att_flags_free(store_att_flags);
3201 if (r != MAILIMAP_NO_ERROR) {
3206 return IMAP_SUCCESS;
3209 static gint imap_cmd_expunge(IMAPSession *session)
3213 if (prefs_common.work_offline &&
3214 !inc_offline_should_override(FALSE,
3215 _("Claws Mail needs network access in order "
3216 "to access the IMAP server."))) {
3220 r = imap_threaded_expunge(session->folder);
3221 if (r != MAILIMAP_NO_ERROR) {
3226 return IMAP_SUCCESS;
3229 static void imap_path_separator_subst(gchar *str, gchar separator)
3232 gboolean in_escape = FALSE;
3234 if (!separator || separator == '/') return;
3236 for (p = str; *p != '\0'; p++) {
3237 if (*p == '/' && !in_escape)
3239 else if (*p == '&' && *(p + 1) != '-' && !in_escape)
3241 else if (*p == '-' && in_escape)
3246 static gchar *imap_modified_utf7_to_utf8(const gchar *mutf7_str)
3248 static iconv_t cd = (iconv_t)-1;
3249 static gboolean iconv_ok = TRUE;
3252 size_t norm_utf7_len;
3254 gchar *to_str, *to_p;
3256 gboolean in_escape = FALSE;
3258 if (!iconv_ok) return g_strdup(mutf7_str);
3260 if (cd == (iconv_t)-1) {
3261 cd = iconv_open(CS_INTERNAL, CS_UTF_7);
3262 if (cd == (iconv_t)-1) {
3263 g_warning("iconv cannot convert UTF-7 to %s\n",
3266 return g_strdup(mutf7_str);
3270 /* modified UTF-7 to normal UTF-7 conversion */
3271 norm_utf7 = g_string_new(NULL);
3273 for (p = mutf7_str; *p != '\0'; p++) {
3274 /* replace: '&' -> '+',
3276 escaped ',' -> '/' */
3277 if (!in_escape && *p == '&') {
3278 if (*(p + 1) != '-') {
3279 g_string_append_c(norm_utf7, '+');
3282 g_string_append_c(norm_utf7, '&');
3285 } else if (in_escape && *p == ',') {
3286 g_string_append_c(norm_utf7, '/');
3287 } else if (in_escape && *p == '-') {
3288 g_string_append_c(norm_utf7, '-');
3291 g_string_append_c(norm_utf7, *p);
3295 norm_utf7_p = norm_utf7->str;
3296 norm_utf7_len = norm_utf7->len;
3297 to_len = strlen(mutf7_str) * 5;
3298 to_p = to_str = g_malloc(to_len + 1);
3300 if (iconv(cd, (ICONV_CONST gchar **)&norm_utf7_p, &norm_utf7_len,
3301 &to_p, &to_len) == -1) {
3302 g_warning(_("iconv cannot convert UTF-7 to %s\n"),
3303 conv_get_locale_charset_str());
3304 g_string_free(norm_utf7, TRUE);
3306 return g_strdup(mutf7_str);
3309 /* second iconv() call for flushing */
3310 iconv(cd, NULL, NULL, &to_p, &to_len);
3311 g_string_free(norm_utf7, TRUE);
3317 static gchar *imap_utf8_to_modified_utf7(const gchar *from)
3319 static iconv_t cd = (iconv_t)-1;
3320 static gboolean iconv_ok = TRUE;
3321 gchar *norm_utf7, *norm_utf7_p;
3322 size_t from_len, norm_utf7_len;
3324 gchar *from_tmp, *to, *p;
3325 gboolean in_escape = FALSE;
3327 if (!iconv_ok) return g_strdup(from);
3329 if (cd == (iconv_t)-1) {
3330 cd = iconv_open(CS_UTF_7, CS_INTERNAL);
3331 if (cd == (iconv_t)-1) {
3332 g_warning(_("iconv cannot convert %s to UTF-7\n"),
3335 return g_strdup(from);
3339 /* UTF-8 to normal UTF-7 conversion */
3340 Xstrdup_a(from_tmp, from, return g_strdup(from));
3341 from_len = strlen(from);
3342 norm_utf7_len = from_len * 5;
3343 Xalloca(norm_utf7, norm_utf7_len + 1, return g_strdup(from));
3344 norm_utf7_p = norm_utf7;
3346 #define IS_PRINT(ch) (isprint(ch) && IS_ASCII(ch))
3348 while (from_len > 0) {
3349 if (*from_tmp == '+') {
3350 *norm_utf7_p++ = '+';
3351 *norm_utf7_p++ = '-';
3355 } else if (IS_PRINT(*(guchar *)from_tmp)) {
3356 /* printable ascii char */
3357 *norm_utf7_p = *from_tmp;
3363 size_t conv_len = 0;
3365 /* unprintable char: convert to UTF-7 */
3367 while (!IS_PRINT(*(guchar *)p) && conv_len < from_len) {
3368 conv_len += g_utf8_skip[*(guchar *)p];
3369 p += g_utf8_skip[*(guchar *)p];
3372 from_len -= conv_len;
3373 if (iconv(cd, (ICONV_CONST gchar **)&from_tmp,
3375 &norm_utf7_p, &norm_utf7_len) == -1) {
3376 g_warning(_("iconv cannot convert UTF-8 to UTF-7\n"));
3377 return g_strdup(from);
3380 /* second iconv() call for flushing */
3381 iconv(cd, NULL, NULL, &norm_utf7_p, &norm_utf7_len);
3387 *norm_utf7_p = '\0';
3388 to_str = g_string_new(NULL);
3389 for (p = norm_utf7; p < norm_utf7_p; p++) {
3390 /* replace: '&' -> "&-",
3393 BASE64 '/' -> ',' */
3394 if (!in_escape && *p == '&') {
3395 g_string_append(to_str, "&-");
3396 } else if (!in_escape && *p == '+') {
3397 if (*(p + 1) == '-') {
3398 g_string_append_c(to_str, '+');
3401 g_string_append_c(to_str, '&');
3404 } else if (in_escape && *p == '/') {
3405 g_string_append_c(to_str, ',');
3406 } else if (in_escape && *p == '-') {
3407 g_string_append_c(to_str, '-');
3410 g_string_append_c(to_str, *p);
3416 g_string_append_c(to_str, '-');
3420 g_string_free(to_str, FALSE);
3425 static gboolean imap_rename_folder_func(GNode *node, gpointer data)
3427 FolderItem *item = node->data;
3428 gchar **paths = data;
3429 const gchar *oldpath = paths[0];
3430 const gchar *newpath = paths[1];
3431 gchar *real_oldpath, *real_newpath;
3433 gchar *new_itempath;
3435 IMAPSession *session = imap_session_get(item->folder);
3437 oldpathlen = strlen(oldpath);
3438 if (strncmp(oldpath, item->path, oldpathlen) != 0) {
3439 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
3443 base = item->path + oldpathlen;
3444 while (*base == G_DIR_SEPARATOR) base++;
3446 new_itempath = g_strdup(newpath);
3448 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
3451 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3453 item->path = new_itempath;
3455 real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3457 imap_threaded_subscribe(item->folder, real_oldpath, FALSE);
3458 imap_threaded_subscribe(item->folder, real_newpath, TRUE);
3460 g_free(real_oldpath);
3461 g_free(real_newpath);
3465 typedef struct _get_list_uid_data {
3467 IMAPSession *session;
3468 IMAPFolderItem *item;
3469 GSList **msgnum_list;
3471 } get_list_uid_data;
3473 static void *get_list_of_uids_thread(void *data)
3475 get_list_uid_data *stuff = (get_list_uid_data *)data;
3476 Folder *folder = stuff->folder;
3477 IMAPFolderItem *item = stuff->item;
3478 GSList **msgnum_list = stuff->msgnum_list;
3479 gint ok, nummsgs = 0, lastuid_old;
3480 IMAPSession *session;
3481 GSList *uidlist, *elem;
3483 clist * lep_uidlist;
3485 session = stuff->session;
3486 if (session == NULL) {
3488 return GINT_TO_POINTER(-1);
3490 /* no session locking here, it's already locked by caller */
3491 ok = imap_select(session, IMAP_FOLDER(folder), item->item.path,
3492 NULL, NULL, NULL, NULL, TRUE);
3493 if (ok != IMAP_SUCCESS) {
3495 return GINT_TO_POINTER(-1);
3498 g_slist_free(item->uid_list);
3499 item->uid_list = NULL;
3503 if (folder->account && folder->account->low_bandwidth) {
3504 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, NULL,
3508 if (r == MAILIMAP_NO_ERROR) {
3509 GSList * fetchuid_list =
3510 imap_uid_list_from_lep(lep_uidlist);
3511 mailimap_search_result_free(lep_uidlist);
3513 uidlist = g_slist_concat(fetchuid_list, uidlist);
3515 carray * lep_uidtab;
3516 r = imap_threaded_fetch_uid(folder, 1,
3518 if (r == MAILIMAP_NO_ERROR) {
3519 GSList * fetchuid_list =
3520 imap_uid_list_from_lep_tab(lep_uidtab);
3521 imap_fetch_uid_list_free(lep_uidtab);
3522 uidlist = g_slist_concat(fetchuid_list, uidlist);
3526 if (r != MAILIMAP_NO_ERROR) {
3528 return GINT_TO_POINTER(-1);
3531 lastuid_old = item->lastuid;
3533 for (elem = uidlist; elem != NULL; elem = g_slist_next(elem)) {
3536 msgnum = GPOINTER_TO_INT(elem->data);
3538 *msgnum_list = g_slist_prepend(*msgnum_list, GINT_TO_POINTER(msgnum));
3539 item->uid_list = g_slist_prepend(item->uid_list, GINT_TO_POINTER(msgnum));
3542 g_slist_free(uidlist);
3544 return GINT_TO_POINTER(nummsgs);
3547 static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
3550 get_list_uid_data *data = g_new0(get_list_uid_data, 1);
3552 data->folder = folder;
3554 data->msgnum_list = msgnum_list;
3555 data->session = session;
3556 if (prefs_common.work_offline &&
3557 !inc_offline_should_override(FALSE,
3558 _("Claws Mail needs network access in order "
3559 "to access the IMAP server."))) {
3564 result = GPOINTER_TO_INT(get_list_of_uids_thread(data));
3570 gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
3572 IMAPFolderItem *item = (IMAPFolderItem *)_item;
3573 IMAPSession *session;
3575 GSList *uidlist = NULL;
3577 gboolean selected_folder;
3578 gint known_list_len = 0;
3579 debug_print("get_num_list\n");
3581 g_return_val_if_fail(folder != NULL, -1);
3582 g_return_val_if_fail(item != NULL, -1);
3583 g_return_val_if_fail(item->item.path != NULL, -1);
3584 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
3585 g_return_val_if_fail(folder->account != NULL, -1);
3587 known_list_len = g_slist_length(item->uid_list);
3588 if (!item->should_update) {
3589 debug_print("get_num_list: nothing to update\n");
3590 *old_uids_valid = TRUE;
3591 if (known_list_len == item->item.total_msgs) {
3592 *msgnum_list = g_slist_copy(item->uid_list);
3593 return known_list_len;
3595 debug_print("don't know the list length...\n");
3599 debug_print("getting session...\n");
3600 session = imap_session_get(folder);
3601 g_return_val_if_fail(session != NULL, -1);
3603 if (FOLDER_ITEM(item)->path)
3604 statusbar_print_all(_("Scanning folder %s%c%s ..."),
3605 FOLDER_ITEM(item)->folder->name,
3607 FOLDER_ITEM(item)->path);
3609 statusbar_print_all(_("Scanning folder %s ..."),
3610 FOLDER_ITEM(item)->folder->name);
3612 selected_folder = (session->mbox != NULL) &&
3613 (!strcmp(session->mbox, item->item.path));
3615 if (item->should_trash_cache) {
3616 *old_uids_valid = FALSE;
3617 debug_print("get_num_list: trashing num list\n");
3618 debug_print("Freeing imap uid cache\n");
3620 g_slist_free(item->uid_list);
3621 item->uid_list = NULL;
3623 imap_delete_all_cached_messages((FolderItem *)item);
3625 debug_print("get_num_list: updating num list\n");
3626 *old_uids_valid = TRUE;
3629 nummsgs = get_list_of_uids(session, folder, item, &uidlist);
3630 debug_print("get_num_list: got %d msgs\n", nummsgs);
3633 statusbar_pop_all();
3634 unlock_session(session);
3638 *msgnum_list = uidlist;
3640 dir = folder_item_get_path((FolderItem *)item);
3641 debug_print("removing old messages from %s\n", dir);
3642 remove_numbered_files_not_in_list(dir, *msgnum_list);
3645 debug_print("get_num_list - ok - %i\n", nummsgs);
3646 statusbar_pop_all();
3647 unlock_session(session);
3648 item->should_trash_cache = FALSE;
3649 item->should_update = FALSE;
3653 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item)
3658 flags.perm_flags = MSG_NEW|MSG_UNREAD;
3659 flags.tmp_flags = 0;
3661 g_return_val_if_fail(item != NULL, NULL);
3662 g_return_val_if_fail(file != NULL, NULL);
3664 if (folder_has_parent_of_type(item, F_QUEUE)) {
3665 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
3666 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
3667 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
3670 msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
3671 if (!msginfo) return NULL;
3673 msginfo->plaintext_file = g_strdup(file);
3674 msginfo->folder = item;
3679 GSList *imap_get_msginfos(Folder *folder, FolderItem *item,
3680 GSList *msgnum_list)
3682 IMAPSession *session;
3683 MsgInfoList *ret = NULL;
3686 debug_print("get_msginfos\n");
3688 g_return_val_if_fail(folder != NULL, NULL);
3689 g_return_val_if_fail(item != NULL, NULL);
3690 g_return_val_if_fail(msgnum_list != NULL, NULL);
3692 debug_print("getting session...\n");
3693 session = imap_session_get(folder);
3694 g_return_val_if_fail(session != NULL, NULL);
3696 debug_print("IMAP getting msginfos\n");
3697 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
3698 NULL, NULL, NULL, NULL, FALSE);
3699 if (ok != IMAP_SUCCESS) {
3700 unlock_session(session);
3703 if (!(folder_has_parent_of_type(item, F_DRAFT) ||
3704 folder_has_parent_of_type(item, F_QUEUE))) {
3705 ret = g_slist_concat(ret,
3706 imap_get_uncached_messages(session, item,
3709 MsgNumberList *sorted_list, *elem, *llast = NULL;
3710 gint startnum, lastnum;
3712 sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
3714 startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
3716 llast = g_slist_last(ret);
3717 for (elem = sorted_list;; elem = g_slist_next(elem)) {
3721 num = GPOINTER_TO_INT(elem->data);
3723 if (num > lastnum + 1 || elem == NULL) {
3725 for (i = startnum; i <= lastnum; ++i) {
3727 unlock_session(session);
3728 file = imap_fetch_msg(folder, item, i);
3729 lock_session(session);
3731 MsgInfo *msginfo = imap_parse_msg(file, item);
3732 if (msginfo != NULL) {
3733 msginfo->msgnum = i;
3735 llast = ret = g_slist_append(ret, msginfo);
3737 llast = g_slist_append(llast, msginfo);
3738 llast = llast->next;
3743 session_set_access_time(SESSION(session));
3754 g_slist_free(sorted_list);
3756 unlock_session(session);
3760 MsgInfo *imap_get_msginfo(Folder *folder, FolderItem *item, gint uid)
3762 MsgInfo *msginfo = NULL;
3763 MsgInfoList *msginfolist;
3764 MsgNumberList numlist;
3766 numlist.next = NULL;
3767 numlist.data = GINT_TO_POINTER(uid);
3769 msginfolist = imap_get_msginfos(folder, item, &numlist);
3770 if (msginfolist != NULL) {
3771 msginfo = msginfolist->data;
3772 g_slist_free(msginfolist);
3778 gboolean imap_scan_required(Folder *folder, FolderItem *_item)
3780 IMAPSession *session;
3781 IMAPFolderItem *item = (IMAPFolderItem *)_item;
3782 gint ok, exists = 0, unseen = 0;
3783 guint32 uid_next = 0, uid_val = 0;
3784 gboolean selected_folder;
3786 g_return_val_if_fail(folder != NULL, FALSE);
3787 g_return_val_if_fail(item != NULL, FALSE);
3788 g_return_val_if_fail(item->item.folder != NULL, FALSE);
3789 g_return_val_if_fail(FOLDER_CLASS(item->item.folder) == &imap_class, FALSE);
3791 if (item->item.path == NULL)
3794 if (item->should_update) {
3795 debug_print("scan already required\n");
3798 debug_print("getting session...\n");
3799 session = imap_session_get(folder);
3800 g_return_val_if_fail(session != NULL, FALSE);
3802 selected_folder = (session->mbox != NULL) &&
3803 (!strcmp(session->mbox, item->item.path));
3804 if (selected_folder) {
3805 if (!session->folder_content_changed) {
3806 ok = imap_cmd_noop(session);
3807 if (ok != IMAP_SUCCESS) {
3808 debug_print("disconnected!\n");
3809 session = imap_reconnect_if_possible(folder, session);
3810 if (session == NULL)
3814 if (session->folder_content_changed) {
3815 debug_print("CHANGED (self-noop)! scan_required\n");
3816 unlock_session(session);
3817 item->should_update = TRUE;
3818 if (session->uid_validity && session->uid_validity != item->item.mtime) {
3819 item->item.mtime = session->uid_validity;
3820 item->should_trash_cache = TRUE;
3826 debug_print("CHANGED (previous noop)! scan_required\n");
3827 unlock_session(session);
3828 item->should_update = TRUE;
3829 if (session->uid_validity && session->uid_validity != item->item.mtime) {
3830 item->item.mtime = session->uid_validity;
3831 item->should_trash_cache = TRUE;
3836 ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, IMAP_FOLDER_ITEM(item),
3837 &exists, &uid_next, &uid_val, &unseen, FALSE);
3838 if (ok != IMAP_SUCCESS) {
3839 unlock_session(session);
3843 debug_print("exists %d, item->item.total_msgs %d\n",
3844 exists, item->item.total_msgs);
3845 if (exists != item->item.total_msgs
3846 || unseen != item->item.unread_msgs
3847 || uid_next != item->uid_next
3848 || uid_val != item->item.mtime) {
3849 unlock_session(session);
3850 debug_print("CHANGED (status)! scan_required\n");
3851 item->last_change = time(NULL);
3852 item->should_update = TRUE;
3853 item->uid_next = uid_next;
3854 if (uid_val != item->item.mtime) {
3855 item->item.mtime = uid_val;
3856 item->should_trash_cache = TRUE;
3861 item->should_update = FALSE;
3862 unlock_session(session);
3866 void imap_change_flags(Folder *folder, FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
3868 IMAPSession *session;
3869 IMAPFlags flags_set = 0, flags_unset = 0;
3870 gint ok = IMAP_SUCCESS;
3871 MsgNumberList numlist;
3872 hashtable_data *ht_data = NULL;
3874 g_return_if_fail(folder != NULL);
3875 g_return_if_fail(folder->klass == &imap_class);
3876 g_return_if_fail(item != NULL);
3877 g_return_if_fail(item->folder == folder);
3878 g_return_if_fail(msginfo != NULL);
3879 g_return_if_fail(msginfo->folder == item);
3881 if (!MSG_IS_MARKED(msginfo->flags) && (newflags & MSG_MARKED))
3882 flags_set |= IMAP_FLAG_FLAGGED;
3883 if ( MSG_IS_MARKED(msginfo->flags) && !(newflags & MSG_MARKED))
3884 flags_unset |= IMAP_FLAG_FLAGGED;
3886 if (!MSG_IS_UNREAD(msginfo->flags) && (newflags & MSG_UNREAD))
3887 flags_unset |= IMAP_FLAG_SEEN;
3888 if ( MSG_IS_UNREAD(msginfo->flags) && !(newflags & MSG_UNREAD))
3889 flags_set |= IMAP_FLAG_SEEN;
3891 if (!MSG_IS_REPLIED(msginfo->flags) && (newflags & MSG_REPLIED))
3892 flags_set |= IMAP_FLAG_ANSWERED;
3893 if ( MSG_IS_REPLIED(msginfo->flags) && !(newflags & MSG_REPLIED))
3894 flags_unset |= IMAP_FLAG_ANSWERED;
3896 if (!MSG_IS_DELETED(msginfo->flags) && (newflags & MSG_DELETED))
3897 flags_set |= IMAP_FLAG_DELETED;
3898 if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
3899 flags_unset |= IMAP_FLAG_DELETED;
3901 if (!flags_set && !flags_unset) {
3902 /* the changed flags were not translatable to IMAP-speak.
3903 * like MSG_POSTFILTERED, so just apply. */
3904 msginfo->flags.perm_flags = newflags;
3908 debug_print("getting session...\n");
3909 session = imap_session_get(folder);
3914 if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
3915 NULL, NULL, NULL, NULL, FALSE)) != IMAP_SUCCESS) {
3916 unlock_session(session);
3919 numlist.next = NULL;
3920 numlist.data = GINT_TO_POINTER(msginfo->msgnum);
3922 if (IMAP_FOLDER_ITEM(item)->batching) {
3923 /* instead of performing an UID STORE command for each message change,
3924 * as a lot of them can change "together", we just fill in hashtables
3925 * and defer the treatment so that we're able to send only one
3928 debug_print("IMAP batch mode on, deferring flags change\n");
3930 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_set_table,
3931 GINT_TO_POINTER(flags_set));
3932 if (ht_data == NULL) {
3933 ht_data = g_new0(hashtable_data, 1);
3934 ht_data->session = session;
3935 ht_data->item = IMAP_FOLDER_ITEM(item);
3936 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_set_table,
3937 GINT_TO_POINTER(flags_set), ht_data);
3939 if (!g_slist_find(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum)))
3940 ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
3943 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_unset_table,
3944 GINT_TO_POINTER(flags_unset));
3945 if (ht_data == NULL) {
3946 ht_data = g_new0(hashtable_data, 1);
3947 ht_data->session = session;
3948 ht_data->item = IMAP_FOLDER_ITEM(item);
3949 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_unset_table,
3950 GINT_TO_POINTER(flags_unset), ht_data);
3952 if (!g_slist_find(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum)))
3953 ht_data->msglist = g_slist_prepend(ht_data->msglist,
3954 GINT_TO_POINTER(msginfo->msgnum));
3957 debug_print("IMAP changing flags\n");
3959 ok = imap_set_message_flags(session, &numlist, flags_set, TRUE);
3960 if (ok != IMAP_SUCCESS) {
3961 unlock_session(session);
3967 ok = imap_set_message_flags(session, &numlist, flags_unset, FALSE);
3968 if (ok != IMAP_SUCCESS) {
3969 unlock_session(session);
3974 msginfo->flags.perm_flags = newflags;
3975 unlock_session(session);
3979 static gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
3982 IMAPSession *session;
3984 MsgNumberList numlist;
3986 g_return_val_if_fail(folder != NULL, -1);
3987 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
3988 g_return_val_if_fail(item != NULL, -1);
3990 debug_print("getting session...\n");
3991 session = imap_session_get(folder);
3992 if (!session) return -1;
3994 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
3995 NULL, NULL, NULL, NULL, FALSE);
3996 if (ok != IMAP_SUCCESS) {
3997 unlock_session(session);
4000 numlist.next = NULL;
4001 numlist.data = GINT_TO_POINTER(uid);
4003 ok = imap_set_message_flags
4004 (session, &numlist, IMAP_FLAG_DELETED, TRUE);
4005 if (ok != IMAP_SUCCESS) {
4006 log_warning(LOG_PROTOCOL, _("can't set deleted flags: %d\n"), uid);
4007 unlock_session(session);
4011 if (!session->uidplus) {
4012 ok = imap_cmd_expunge(session);
4016 uidstr = g_strdup_printf("%u", uid);
4017 ok = imap_cmd_expunge(session);
4020 if (ok != IMAP_SUCCESS) {
4021 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
4022 unlock_session(session);
4026 IMAP_FOLDER_ITEM(item)->uid_list = g_slist_remove(
4027 IMAP_FOLDER_ITEM(item)->uid_list, numlist.data);
4028 dir = folder_item_get_path(item);
4029 if (is_dir_exist(dir))
4030 remove_numbered_files(dir, uid, uid);
4032 unlock_session(session);
4033 return IMAP_SUCCESS;
4036 static gint compare_msginfo(gconstpointer a, gconstpointer b)
4038 return ((MsgInfo *)a)->msgnum - ((MsgInfo *)b)->msgnum;
4041 static guint gslist_find_next_num(MsgNumberList **list, guint num)
4045 g_return_val_if_fail(list != NULL, -1);
4047 for (elem = *list; elem != NULL; elem = g_slist_next(elem))
4048 if (GPOINTER_TO_INT(elem->data) >= num)
4051 return elem != NULL ? GPOINTER_TO_INT(elem->data) : (gint)-1;
4055 * NEW and DELETED flags are not syncronized
4056 * - The NEW/RECENT flags in IMAP folders can not really be directly
4057 * modified by Sylpheed
4058 * - The DELETE/DELETED flag in IMAP and Sylpheed don't have the same
4059 * meaning, in IMAP it always removes the messages from the FolderItem
4060 * in Sylpheed it can mean to move the message to trash
4063 typedef struct _get_flags_data {
4066 MsgInfoList *msginfo_list;
4067 GRelation *msgflags;
4068 gboolean full_search;
4072 static /*gint*/ void *imap_get_flags_thread(void *data)
4074 get_flags_data *stuff = (get_flags_data *)data;
4075 Folder *folder = stuff->folder;
4076 FolderItem *fitem = (FolderItem *) stuff->item;
4077 MsgInfoList *msginfo_list = stuff->msginfo_list;
4078 GRelation *msgflags = stuff->msgflags;
4080 carray * lep_uidtab;
4081 IMAPSession *session;
4084 GHashTable *flags_hash = NULL;
4085 gboolean full_search = stuff->full_search;
4086 GSList *sorted_list = NULL;
4087 GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL;
4088 GSList *p_unseen, *p_answered, *p_flagged, *p_deleted;
4089 GSList *seq_list, *cur;
4090 gboolean reverse_seen = FALSE;
4091 gboolean selected_folder;
4092 gint exists_cnt, unseen_cnt;
4094 session = imap_session_get(folder);
4095 if (session == NULL) {
4097 return GINT_TO_POINTER(-1);
4099 selected_folder = (session->mbox != NULL) &&
4100 (!strcmp(session->mbox, fitem->path));
4102 if (!selected_folder) {
4103 ok = imap_select(session, IMAP_FOLDER(folder), fitem->path,
4104 &exists_cnt, NULL, &unseen_cnt, NULL, TRUE);
4105 if (ok != IMAP_SUCCESS) {
4107 unlock_session(session);
4108 return GINT_TO_POINTER(-1);
4111 if (unseen_cnt > exists_cnt / 2)
4112 reverse_seen = TRUE;
4115 if (fitem->unread_msgs > fitem->total_msgs / 2)
4116 reverse_seen = TRUE;
4119 sorted_list = g_slist_sort(g_slist_copy(msginfo_list), compare_msginfo);
4121 seq_list = imap_get_lep_set_from_msglist(msginfo_list);
4123 struct mailimap_set * set;
4124 set = mailimap_set_new_interval(1, 0);
4125 seq_list = g_slist_append(NULL, set);
4128 if (folder->account && folder->account->low_bandwidth) {
4129 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
4130 struct mailimap_set * imapset;
4131 clist * lep_uidlist;
4134 imapset = cur->data;
4136 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SEEN,
4137 full_search ? NULL:imapset, &lep_uidlist);
4140 r = imap_threaded_search(folder,
4141 IMAP_SEARCH_TYPE_UNSEEN,
4142 full_search ? NULL:imapset, &lep_uidlist);
4144 if (r == MAILIMAP_NO_ERROR) {
4147 uidlist = imap_uid_list_from_lep(lep_uidlist);
4148 mailimap_search_result_free(lep_uidlist);
4150 unseen = g_slist_concat(unseen, uidlist);
4153 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FLAGGED,
4154 full_search ? NULL:imapset, &lep_uidlist);
4155 if (r == MAILIMAP_NO_ERROR) {
4158 uidlist = imap_uid_list_from_lep(lep_uidlist);
4159 mailimap_search_result_free(lep_uidlist);
4161 flagged = g_slist_concat(flagged, uidlist);
4164 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4165 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED,
4166 full_search ? NULL:imapset, &lep_uidlist);
4167 if (r == MAILIMAP_NO_ERROR) {
4170 uidlist = imap_uid_list_from_lep(lep_uidlist);
4171 mailimap_search_result_free(lep_uidlist);
4173 answered = g_slist_concat(answered, uidlist);
4176 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
4177 full_search ? NULL:imapset, &lep_uidlist);
4178 if (r == MAILIMAP_NO_ERROR) {
4181 uidlist = imap_uid_list_from_lep(lep_uidlist);
4182 mailimap_search_result_free(lep_uidlist);
4184 deleted = g_slist_concat(deleted, uidlist);
4189 p_answered = answered;
4190 p_flagged = flagged;
4191 p_deleted = deleted;
4194 r = imap_threaded_fetch_uid_flags(folder, 1, &lep_uidtab);
4195 if (r == MAILIMAP_NO_ERROR) {
4196 flags_hash = g_hash_table_new_full(g_int_hash, g_int_equal, free, NULL);
4197 imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab, flags_hash);
4198 imap_fetch_uid_flags_list_free(lep_uidtab);
4201 for (elem = sorted_list; elem != NULL; elem = g_slist_next(elem)) {
4203 MsgPermFlags flags, oldflags;
4206 msginfo = (MsgInfo *) elem->data;
4207 flags = msginfo->flags.perm_flags;
4208 wasnew = (flags & MSG_NEW);
4209 oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_MARKED|MSG_DELETED);
4211 if (folder->account && folder->account->low_bandwidth) {
4212 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4213 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_MARKED);
4215 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
4218 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4219 if (gslist_find_next_num(&p_unseen, msginfo->msgnum) == msginfo->msgnum) {
4220 if (!reverse_seen) {
4221 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4223 flags &= ~(MSG_UNREAD | MSG_NEW);
4227 if (gslist_find_next_num(&p_flagged, msginfo->msgnum) == msginfo->msgnum)
4228 flags |= MSG_MARKED;
4230 flags &= ~MSG_MARKED;
4232 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4233 if (gslist_find_next_num(&p_answered, msginfo->msgnum) == msginfo->msgnum)
4234 flags |= MSG_REPLIED;
4236 flags &= ~MSG_REPLIED;
4237 if (gslist_find_next_num(&p_deleted, msginfo->msgnum) == msginfo->msgnum)
4238 flags |= MSG_DELETED;
4240 flags &= ~MSG_DELETED;
4243 if (flags_hash != NULL) {
4246 puid = malloc(sizeof(* puid));
4247 * puid = msginfo->msgnum;
4249 flags = GPOINTER_TO_INT(g_hash_table_lookup(flags_hash, puid));
4253 if ((flags & MSG_UNREAD) == 0)
4260 g_relation_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
4264 g_hash_table_destroy(flags_hash);
4266 imap_lep_set_free(seq_list);
4267 g_slist_free(flagged);
4268 g_slist_free(deleted);
4269 g_slist_free(answered);
4270 g_slist_free(unseen);
4271 g_slist_free(sorted_list);
4273 unlock_session(session);
4275 return GINT_TO_POINTER(0);
4278 static gint imap_get_flags(Folder *folder, FolderItem *item,
4279 MsgInfoList *msginfo_list, GRelation *msgflags)
4282 get_flags_data *data = g_new0(get_flags_data, 1);
4284 data->folder = folder;
4286 data->msginfo_list = msginfo_list;
4287 data->msgflags = msgflags;
4288 data->full_search = FALSE;
4290 GSList *tmp = NULL, *cur;
4292 if (prefs_common.work_offline &&
4293 !inc_offline_should_override(FALSE,
4294 _("Claws Mail needs network access in order "
4295 "to access the IMAP server."))) {
4300 tmp = folder_item_get_msg_list(item);
4302 if (g_slist_length(tmp) <= g_slist_length(msginfo_list))
4303 data->full_search = TRUE;
4305 for (cur = tmp; cur; cur = cur->next)
4306 procmsg_msginfo_free((MsgInfo *)cur->data);
4310 result = GPOINTER_TO_INT(imap_get_flags_thread(data));
4317 static gboolean process_flags(gpointer key, gpointer value, gpointer user_data)
4319 gboolean flags_set = GPOINTER_TO_INT(user_data);
4320 gint flags_value = GPOINTER_TO_INT(key);
4321 hashtable_data *data = (hashtable_data *)value;
4322 IMAPFolderItem *_item = data->item;
4323 FolderItem *item = (FolderItem *)_item;
4324 gint ok = IMAP_ERROR;
4325 IMAPSession *session = NULL;
4327 debug_print("getting session...\n");
4328 session = imap_session_get(item->folder);
4330 data->msglist = g_slist_reverse(data->msglist);
4332 debug_print("IMAP %ssetting flags to %d for %d messages\n",
4335 g_slist_length(data->msglist));
4338 ok = imap_select(session, IMAP_FOLDER(item->folder), item->path,
4339 NULL, NULL, NULL, NULL, FALSE);
4341 if (ok == IMAP_SUCCESS) {
4342 imap_set_message_flags(data->session, data->msglist, flags_value, flags_set);
4344 g_warning("can't select mailbox %s\n", item->path);
4347 unlock_session(session);
4348 g_slist_free(data->msglist);
4353 static void process_hashtable(IMAPFolderItem *item)
4355 if (item->flags_set_table) {
4356 g_hash_table_foreach_remove(item->flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
4357 g_hash_table_destroy(item->flags_set_table);
4358 item->flags_set_table = NULL;
4360 if (item->flags_unset_table) {
4361 g_hash_table_foreach_remove(item->flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
4362 g_hash_table_destroy(item->flags_unset_table);
4363 item->flags_unset_table = NULL;
4367 static void imap_set_batch (Folder *folder, FolderItem *_item, gboolean batch)
4369 IMAPFolderItem *item = (IMAPFolderItem *)_item;
4371 g_return_if_fail(item != NULL);
4373 if (item->batching == batch)
4377 item->batching = TRUE;
4378 debug_print("IMAP switching to batch mode\n");
4379 if (!item->flags_set_table) {
4380 item->flags_set_table = g_hash_table_new(NULL, g_direct_equal);
4382 if (!item->flags_unset_table) {
4383 item->flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
4386 debug_print("IMAP switching away from batch mode\n");
4388 process_hashtable(item);
4389 item->batching = FALSE;
4395 /* data types conversion libetpan <-> claws */
4399 #define ETPAN_IMAP_MB_MARKED 1
4400 #define ETPAN_IMAP_MB_UNMARKED 2
4401 #define ETPAN_IMAP_MB_NOSELECT 4
4402 #define ETPAN_IMAP_MB_NOINFERIORS 8
4404 static int imap_flags_to_flags(struct mailimap_mbx_list_flags * imap_flags)
4410 if (imap_flags->mbf_type == MAILIMAP_MBX_LIST_FLAGS_SFLAG) {
4411 switch (imap_flags->mbf_sflag) {
4412 case MAILIMAP_MBX_LIST_SFLAG_MARKED:
4413 flags |= ETPAN_IMAP_MB_MARKED;
4415 case MAILIMAP_MBX_LIST_SFLAG_NOSELECT:
4416 flags |= ETPAN_IMAP_MB_NOSELECT;
4418 case MAILIMAP_MBX_LIST_SFLAG_UNMARKED:
4419 flags |= ETPAN_IMAP_MB_UNMARKED;
4424 for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
4425 cur = clist_next(cur)) {
4426 struct mailimap_mbx_list_oflag * oflag;
4428 oflag = clist_content(cur);
4430 switch (oflag->of_type) {
4431 case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
4432 flags |= ETPAN_IMAP_MB_NOINFERIORS;
4440 static GSList * imap_list_from_lep(IMAPFolder * folder,
4441 clist * list, const gchar * real_path, gboolean all)
4444 GSList * item_list = NULL, *llast = NULL;
4446 for(iter = clist_begin(list) ; iter != NULL ;
4447 iter = clist_next(iter)) {
4448 struct mailimap_mailbox_list * mb;
4456 FolderItem *new_item;
4458 mb = clist_content(iter);
4464 if (mb->mb_flag != NULL)
4465 flags = imap_flags_to_flags(mb->mb_flag);
4467 delimiter = mb->mb_delimiter;
4470 dup_name = strdup(name);
4471 if (delimiter != '\0')
4472 subst_char(dup_name, delimiter, '/');
4474 base = g_path_get_basename(dup_name);
4475 if (base[0] == '.') {
4480 if (!all && path_cmp(name, real_path) == 0) {
4486 if (!all && dup_name[strlen(dup_name)-1] == '/') {
4487 dup_name[strlen(dup_name)-1] = '\0';
4490 loc_name = imap_modified_utf7_to_utf8(base);
4491 loc_path = imap_modified_utf7_to_utf8(dup_name);
4493 new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
4494 if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
4495 new_item->no_sub = TRUE;
4496 if (strcmp(dup_name, "INBOX") != 0 &&
4497 ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
4498 new_item->no_select = TRUE;
4500 if (item_list == NULL)
4501 llast = item_list = g_slist_append(item_list, new_item);
4503 llast = g_slist_append(llast, new_item);
4504 llast = llast->next;
4506 debug_print("folder '%s' found.\n", loc_path);
4517 static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist)
4519 GSList *sorted_list, *cur;
4520 guint first, last, next;
4521 GSList *ret_list = NULL, *llast = NULL;
4523 struct mailimap_set * current_set;
4524 unsigned int item_count;
4526 if (numlist == NULL)
4530 current_set = mailimap_set_new_empty();
4532 sorted_list = g_slist_copy(numlist);
4533 sorted_list = g_slist_sort(sorted_list, g_int_compare);
4535 first = GPOINTER_TO_INT(sorted_list->data);
4538 for (cur = sorted_list; cur != NULL; cur = g_slist_next(cur)) {
4539 if (GPOINTER_TO_INT(cur->data) == 0)
4544 last = GPOINTER_TO_INT(cur->data);
4546 next = GPOINTER_TO_INT(cur->next->data);
4550 if (last + 1 != next || next == 0) {
4552 struct mailimap_set_item * item;
4553 item = mailimap_set_item_new(first, last);
4554 mailimap_set_add(current_set, item);
4559 if (count >= IMAP_SET_MAX_COUNT) {
4560 if (ret_list == NULL)
4561 llast = ret_list = g_slist_append(ret_list,
4564 llast = g_slist_append(llast, current_set);
4565 llast = llast->next;
4567 current_set = mailimap_set_new_empty();
4574 if (clist_count(current_set->set_list) > 0) {
4575 ret_list = g_slist_append(ret_list,
4579 g_slist_free(sorted_list);
4584 static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist)
4586 MsgNumberList *numlist = NULL;
4590 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
4591 MsgInfo *msginfo = (MsgInfo *) cur->data;
4593 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
4595 numlist = g_slist_reverse(numlist);
4596 seq_list = imap_get_lep_set_from_numlist(numlist);
4597 g_slist_free(numlist);
4602 static GSList * imap_uid_list_from_lep(clist * list)
4609 for(iter = clist_begin(list) ; iter != NULL ;
4610 iter = clist_next(iter)) {
4613 puid = clist_content(iter);
4614 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4617 result = g_slist_reverse(result);
4621 static GSList * imap_uid_list_from_lep_tab(carray * list)
4628 for(i = 0 ; i < carray_count(list) ; i ++) {
4631 puid = carray_get(list, i);
4632 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4634 result = g_slist_reverse(result);
4638 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
4646 for(i = 0 ; i < carray_count(list) ; i += 2) {
4651 puid = carray_get(list, i);
4652 pflags = carray_get(list, i + 1);
4653 pguid = malloc(sizeof(* pguid));
4656 g_hash_table_insert(hash, pguid, GINT_TO_POINTER(* pflags));
4660 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
4663 MsgInfo *msginfo = NULL;
4666 MsgFlags flags = {0, 0};
4668 if (info->headers == NULL)
4671 MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
4672 if (folder_has_parent_of_type(item, F_QUEUE)) {
4673 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
4674 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
4675 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
4677 flags.perm_flags = info->flags;
4681 msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
4684 msginfo->msgnum = uid;
4685 msginfo->size = size;
4691 static void imap_lep_set_free(GSList *seq_list)
4695 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
4696 struct mailimap_set * imapset;
4698 imapset = cur->data;
4699 mailimap_set_free(imapset);
4701 g_slist_free(seq_list);
4704 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags)
4706 struct mailimap_flag_list * flag_list;
4708 flag_list = mailimap_flag_list_new_empty();
4710 if (IMAP_IS_SEEN(flags))
4711 mailimap_flag_list_add(flag_list,
4712 mailimap_flag_new_seen());
4713 if (IMAP_IS_ANSWERED(flags))
4714 mailimap_flag_list_add(flag_list,
4715 mailimap_flag_new_answered());
4716 if (IMAP_IS_FLAGGED(flags))
4717 mailimap_flag_list_add(flag_list,
4718 mailimap_flag_new_flagged());
4719 if (IMAP_IS_DELETED(flags))
4720 mailimap_flag_list_add(flag_list,
4721 mailimap_flag_new_deleted());
4722 if (IMAP_IS_DRAFT(flags))
4723 mailimap_flag_list_add(flag_list,
4724 mailimap_flag_new_draft());
4729 guint imap_folder_get_refcnt(Folder *folder)
4731 return ((IMAPFolder *)folder)->refcnt;
4734 void imap_folder_ref(Folder *folder)
4736 ((IMAPFolder *)folder)->refcnt++;
4739 void imap_disconnect_all(void)
4742 for (list = account_get_list(); list != NULL; list = list->next) {
4743 PrefsAccount *account = list->data;
4744 if (account->protocol == A_IMAP4) {
4745 RemoteFolder *folder = (RemoteFolder *)account->folder;
4746 if (folder && folder->session) {
4747 IMAPSession *session = (IMAPSession *)folder->session;
4748 imap_threaded_disconnect(FOLDER(folder));
4749 SESSION(session)->state = SESSION_DISCONNECTED;
4750 session_destroy(SESSION(session));
4751 folder->session = NULL;
4757 void imap_folder_unref(Folder *folder)
4759 if (((IMAPFolder *)folder)->refcnt > 0)
4760 ((IMAPFolder *)folder)->refcnt--;
4763 void imap_cancel_all(void)
4768 folderlist = folder_get_list();
4769 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
4770 Folder *folder = (Folder *) cur->data;
4772 if (folder->klass == &imap_class) {
4773 if (imap_is_busy(folder)) {
4774 IMAPSession *imap_session;
4775 RemoteFolder *rfolder;
4777 fprintf(stderr, "cancelled\n");
4778 imap_threaded_cancel(folder);
4779 rfolder = (RemoteFolder *) folder;
4780 imap_session = (IMAPSession *) rfolder->session;
4782 imap_session->cancelled = 1;
4788 gboolean imap_cancel_all_enabled(void)
4793 folderlist = folder_get_list();
4794 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
4795 Folder *folder = (Folder *) cur->data;
4797 if (folder->klass == &imap_class) {
4798 if (imap_is_busy(folder)) {
4807 static gboolean imap_is_busy(Folder *folder)
4809 IMAPSession *imap_session;
4810 RemoteFolder *rfolder;
4812 rfolder = (RemoteFolder *) folder;
4813 imap_session = (IMAPSession *) rfolder->session;
4814 if (imap_session == NULL)
4817 return imap_session->busy;
4820 #else /* HAVE_LIBETPAN */
4822 static FolderClass imap_class;
4824 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
4825 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
4827 static Folder *imap_folder_new (const gchar *name,
4830 static gboolean missing_imap_warning = TRUE;
4831 if (missing_imap_warning) {
4832 missing_imap_warning = FALSE;
4834 _("You have one or more IMAP accounts "
4835 "defined. However this version of "
4836 "Claws Mail has been built without "
4837 "IMAP support; your IMAP account(s) are "
4839 "You probably need to "
4840 "install libetpan and recompile "
4845 static gint imap_create_tree (Folder *folder)
4849 static FolderItem *imap_create_folder (Folder *folder,
4855 static gint imap_rename_folder (Folder *folder,
4862 gchar imap_get_path_separator_for_item(FolderItem *item)
4867 FolderClass *imap_get_class(void)
4869 if (imap_class.idstr == NULL) {
4870 imap_class.type = F_IMAP;
4871 imap_class.idstr = "imap";
4872 imap_class.uistr = "IMAP4";
4874 imap_class.new_folder = imap_folder_new;
4875 imap_class.create_tree = imap_create_tree;
4876 imap_class.create_folder = imap_create_folder;
4877 imap_class.rename_folder = imap_rename_folder;
4879 imap_class.set_xml = folder_set_xml;
4880 imap_class.get_xml = folder_get_xml;
4881 imap_class.item_set_xml = imap_item_set_xml;
4882 imap_class.item_get_xml = imap_item_get_xml;
4883 /* nothing implemented */
4889 void imap_disconnect_all(void)
4893 gint imap_scan_tree_real(Folder *folder, gboolean subs_only)
4898 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
4903 GList * imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
4908 void imap_cache_msg(FolderItem *item, gint msgnum)
4912 void imap_cancel_all(void)
4916 gboolean imap_cancel_all_enabled(void)
4923 void imap_synchronise(FolderItem *item, gint days)
4925 #ifdef HAVE_LIBETPAN
4926 if (IMAP_FOLDER_ITEM(item)->last_sync == IMAP_FOLDER_ITEM(item)->last_change) {
4927 debug_print("%s already synced\n", item->path?item->path:item->name);
4930 debug_print("syncing %s\n", item->path?item->path:item->name);
4931 imap_gtk_synchronise(item, days);
4932 IMAP_FOLDER_ITEM(item)->last_sync = IMAP_FOLDER_ITEM(item)->last_change;
4936 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
4938 #ifdef HAVE_LIBETPAN
4941 folder_item_set_xml(folder, item, tag);
4943 #ifdef HAVE_LIBETPAN
4944 for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
4945 XMLAttr *attr = (XMLAttr *) cur->data;
4947 if (!attr || !attr->name || !attr->value) continue;
4948 if (!strcmp(attr->name, "uidnext"))
4949 IMAP_FOLDER_ITEM(item)->uid_next = atoi(attr->value);
4950 if (!strcmp(attr->name, "last_sync"))
4951 IMAP_FOLDER_ITEM(item)->last_sync = atoi(attr->value);
4952 if (!strcmp(attr->name, "last_change"))
4953 IMAP_FOLDER_ITEM(item)->last_change = atoi(attr->value);
4955 if (IMAP_FOLDER_ITEM(item)->last_change == 0)
4956 IMAP_FOLDER_ITEM(item)->last_change = time(NULL);
4960 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item)
4964 tag = folder_item_get_xml(folder, item);
4966 #ifdef HAVE_LIBETPAN
4967 xml_tag_add_attr(tag, xml_attr_new_int("uidnext",
4968 IMAP_FOLDER_ITEM(item)->uid_next));
4969 xml_tag_add_attr(tag, xml_attr_new_int("last_sync",
4970 IMAP_FOLDER_ITEM(item)->last_sync));
4971 xml_tag_add_attr(tag, xml_attr_new_int("last_change",
4972 IMAP_FOLDER_ITEM(item)->last_change));