2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail team
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 #include <glib/gi18n.h>
34 #include "alertpanel.h"
48 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
57 #include "procheader.h"
58 #include "prefs_account.h"
63 #include "prefs_common.h"
64 #include "inputdialog.h"
66 #include "remotefolder.h"
68 #include "statusbar.h"
70 #include "imap-thread.h"
73 typedef struct _IMAPFolder IMAPFolder;
74 typedef struct _IMAPSession IMAPSession;
75 typedef struct _IMAPNameSpace IMAPNameSpace;
76 typedef struct _IMAPFolderItem IMAPFolderItem;
78 #include "prefs_account.h"
80 #define IMAP_FOLDER(obj) ((IMAPFolder *)obj)
81 #define IMAP_FOLDER_ITEM(obj) ((IMAPFolderItem *)obj)
82 #define IMAP_SESSION(obj) ((IMAPSession *)obj)
88 /* list of IMAPNameSpace */
92 gchar last_seen_separator;
101 gboolean authenticated;
110 gboolean folder_content_changed;
121 gboolean sens_update_block;
124 struct _IMAPNameSpace
130 #define IMAPBUFSIZE 8192
134 IMAP_FLAG_SEEN = 1 << 0,
135 IMAP_FLAG_ANSWERED = 1 << 1,
136 IMAP_FLAG_FLAGGED = 1 << 2,
137 IMAP_FLAG_DELETED = 1 << 3,
138 IMAP_FLAG_DRAFT = 1 << 4
141 #define IMAP_IS_SEEN(flags) ((flags & IMAP_FLAG_SEEN) != 0)
142 #define IMAP_IS_ANSWERED(flags) ((flags & IMAP_FLAG_ANSWERED) != 0)
143 #define IMAP_IS_FLAGGED(flags) ((flags & IMAP_FLAG_FLAGGED) != 0)
144 #define IMAP_IS_DELETED(flags) ((flags & IMAP_FLAG_DELETED) != 0)
145 #define IMAP_IS_DRAFT(flags) ((flags & IMAP_FLAG_DRAFT) != 0)
148 #define IMAP4_PORT 143
149 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
150 #define IMAPS_PORT 993
153 #define IMAP_CMD_LIMIT 1000
155 struct _IMAPFolderItem
164 GHashTable *flags_set_table;
165 GHashTable *flags_unset_table;
168 gboolean should_update;
169 gboolean should_trash_cache;
172 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
173 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
175 static void imap_folder_init (Folder *folder,
179 static Folder *imap_folder_new (const gchar *name,
181 static void imap_folder_destroy (Folder *folder);
183 static IMAPSession *imap_session_new (Folder *folder,
184 const PrefsAccount *account);
185 static void imap_session_authenticate(IMAPSession *session,
186 const PrefsAccount *account);
187 static void imap_session_destroy (Session *session);
189 static gchar *imap_fetch_msg (Folder *folder,
192 static gchar *imap_fetch_msg_full (Folder *folder,
197 static void imap_remove_cached_msg (Folder *folder,
200 static gint imap_add_msg (Folder *folder,
204 static gint imap_add_msgs (Folder *folder,
207 GRelation *relation);
209 static gint imap_copy_msg (Folder *folder,
212 static gint imap_copy_msgs (Folder *folder,
214 MsgInfoList *msglist,
215 GRelation *relation);
217 static gint imap_remove_msg (Folder *folder,
220 static gint imap_remove_msgs (Folder *folder,
222 MsgInfoList *msglist,
223 GRelation *relation);
224 static gint imap_remove_all_msg (Folder *folder,
227 static gboolean imap_is_msg_changed (Folder *folder,
231 static gint imap_close (Folder *folder,
234 static gint imap_scan_tree (Folder *folder);
236 static gint imap_create_tree (Folder *folder);
238 static FolderItem *imap_create_folder (Folder *folder,
241 static gint imap_rename_folder (Folder *folder,
244 static gint imap_remove_folder (Folder *folder,
247 static FolderItem *imap_folder_item_new (Folder *folder);
248 static void imap_folder_item_destroy (Folder *folder,
251 static IMAPSession *imap_session_get (Folder *folder);
253 static gint imap_auth (IMAPSession *session,
258 static gint imap_scan_tree_recursive (IMAPSession *session,
262 static void imap_create_missing_folders (Folder *folder);
263 static FolderItem *imap_create_special_folder
265 SpecialFolderItemType stype,
268 static gint imap_do_copy_msgs (Folder *folder,
270 MsgInfoList *msglist,
271 GRelation *relation);
273 static void imap_delete_all_cached_messages (FolderItem *item);
274 static void imap_set_batch (Folder *folder,
277 static gint imap_set_message_flags (IMAPSession *session,
278 MsgNumberList *numlist,
281 static gint imap_select (IMAPSession *session,
287 guint32 *uid_validity,
289 static gint imap_status (IMAPSession *session,
292 IMAPFolderItem *item,
295 guint32 *uid_validity,
299 static gchar imap_get_path_separator (IMAPSession *session,
302 static gchar *imap_get_real_path (IMAPSession *session,
306 static void imap_synchronise (FolderItem *item, gint days);
308 static gboolean imap_is_busy (Folder *folder);
310 static void imap_free_capabilities (IMAPSession *session);
312 /* low-level IMAP4rev1 commands */
313 static gint imap_cmd_login (IMAPSession *session,
317 static gint imap_cmd_noop (IMAPSession *session);
318 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
319 static gint imap_cmd_starttls (IMAPSession *session);
321 static gint imap_cmd_select (IMAPSession *session,
326 guint32 *uid_validity,
328 static gint imap_cmd_close (IMAPSession *session);
329 static gint imap_cmd_examine (IMAPSession *session,
334 guint32 *uid_validity,
336 static gint imap_cmd_create (IMAPSession *sock,
337 const gchar *folder);
338 static gint imap_cmd_rename (IMAPSession *sock,
339 const gchar *oldfolder,
340 const gchar *newfolder);
341 static gint imap_cmd_delete (IMAPSession *session,
342 const gchar *folder);
343 static gint imap_cmd_fetch (IMAPSession *sock,
345 const gchar *filename,
348 static gint imap_cmd_append (IMAPSession *session,
349 const gchar *destfolder,
353 static gint imap_cmd_copy (IMAPSession *session,
354 struct mailimap_set * set,
355 const gchar *destfolder,
356 GRelation *uid_mapping,
357 struct mailimap_set ** source,
358 struct mailimap_set ** dest);
359 static gint imap_cmd_store (IMAPSession *session,
360 struct mailimap_set * set,
363 static gint imap_cmd_expunge (IMAPSession *session);
365 static void imap_path_separator_subst (gchar *str,
368 static gchar *imap_utf8_to_modified_utf7 (const gchar *from);
369 static gchar *imap_modified_utf7_to_utf8 (const gchar *mutf7_str);
371 static gboolean imap_rename_folder_func (GNode *node,
373 static gint imap_get_num_list (Folder *folder,
376 gboolean *old_uids_valid);
377 static GSList *imap_get_msginfos (Folder *folder,
379 GSList *msgnum_list);
380 static MsgInfo *imap_get_msginfo (Folder *folder,
383 static gboolean imap_scan_required (Folder *folder,
385 static void imap_change_flags (Folder *folder,
388 MsgPermFlags newflags);
389 static gint imap_get_flags (Folder *folder,
391 MsgInfoList *msglist,
392 GRelation *msgflags);
393 static gchar *imap_folder_get_path (Folder *folder);
394 static gchar *imap_item_get_path (Folder *folder,
396 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
399 /* data types conversion libetpan <-> claws */
400 static GSList * imap_list_from_lep(IMAPFolder * folder,
401 clist * list, const gchar * real_path, gboolean all);
402 static GSList * imap_get_lep_set_from_numlist(IMAPFolder *folder, MsgNumberList *numlist);
403 static GSList * imap_get_lep_set_from_msglist(IMAPFolder *folder, MsgInfoList *msglist);
404 static GSList * imap_uid_list_from_lep(clist * list);
405 static GSList * imap_uid_list_from_lep_tab(carray * list);
406 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
408 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
410 static void imap_lep_set_free(GSList *seq_list);
411 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags);
413 typedef struct _hashtable_data {
415 IMAPFolderItem *item;
418 static FolderClass imap_class;
420 typedef struct _thread_data {
425 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
430 FolderClass *imap_get_class(void)
432 if (imap_class.idstr == NULL) {
433 imap_class.type = F_IMAP;
434 imap_class.idstr = "imap";
435 imap_class.uistr = "IMAP4";
437 /* Folder functions */
438 imap_class.new_folder = imap_folder_new;
439 imap_class.destroy_folder = imap_folder_destroy;
440 imap_class.scan_tree = imap_scan_tree;
441 imap_class.create_tree = imap_create_tree;
443 /* FolderItem functions */
444 imap_class.item_new = imap_folder_item_new;
445 imap_class.item_destroy = imap_folder_item_destroy;
446 imap_class.item_get_path = imap_item_get_path;
447 imap_class.create_folder = imap_create_folder;
448 imap_class.rename_folder = imap_rename_folder;
449 imap_class.remove_folder = imap_remove_folder;
450 imap_class.close = imap_close;
451 imap_class.get_num_list = imap_get_num_list;
452 imap_class.scan_required = imap_scan_required;
453 imap_class.set_xml = folder_set_xml;
454 imap_class.get_xml = folder_get_xml;
455 imap_class.item_set_xml = imap_item_set_xml;
456 imap_class.item_get_xml = imap_item_get_xml;
458 /* Message functions */
459 imap_class.get_msginfo = imap_get_msginfo;
460 imap_class.get_msginfos = imap_get_msginfos;
461 imap_class.fetch_msg = imap_fetch_msg;
462 imap_class.fetch_msg_full = imap_fetch_msg_full;
463 imap_class.add_msg = imap_add_msg;
464 imap_class.add_msgs = imap_add_msgs;
465 imap_class.copy_msg = imap_copy_msg;
466 imap_class.copy_msgs = imap_copy_msgs;
467 imap_class.remove_msg = imap_remove_msg;
468 imap_class.remove_msgs = imap_remove_msgs;
469 imap_class.remove_all_msg = imap_remove_all_msg;
470 imap_class.is_msg_changed = imap_is_msg_changed;
471 imap_class.change_flags = imap_change_flags;
472 imap_class.get_flags = imap_get_flags;
473 imap_class.set_batch = imap_set_batch;
474 imap_class.synchronise = imap_synchronise;
475 imap_class.remove_cached_msg = imap_remove_cached_msg;
477 pthread_mutex_init(&imap_mutex, NULL);
484 static void imap_refresh_sensitivity (IMAPSession *session)
488 if (session->sens_update_block)
490 mainwin = mainwindow_get_mainwindow();
492 toolbar_main_set_sensitive(mainwin);
493 main_window_set_menu_sensitive(mainwin);
497 static void lock_session(IMAPSession *session)
500 debug_print("locking session %p (%d)\n", session, session->busy);
502 debug_print(" SESSION WAS LOCKED !! \n");
503 session->busy = TRUE;
504 imap_refresh_sensitivity(session);
506 debug_print("can't lock null session\n");
510 static void unlock_session(IMAPSession *session)
513 debug_print("unlocking session %p\n", session);
514 session->busy = FALSE;
515 imap_refresh_sensitivity(session);
517 debug_print("can't unlock null session\n");
521 static void imap_disc_session_destroy(Folder *folder)
523 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
524 IMAPSession *session = NULL;
528 session = IMAP_SESSION(rfolder->session);
531 rfolder->session = NULL;
532 log_warning(LOG_PROTOCOL, _("IMAP4 connection broken\n"));
533 SESSION(session)->state = SESSION_DISCONNECTED;
534 session_destroy(SESSION(session));
537 static gboolean is_fatal(int libetpan_errcode)
539 switch(libetpan_errcode) {
540 case MAILIMAP_ERROR_STREAM:
541 case MAILIMAP_ERROR_PROTOCOL:
542 case MAILIMAP_ERROR_PARSE:
543 case MAILIMAP_ERROR_BAD_STATE:
550 static void imap_handle_error(Session *session, int libetpan_errcode)
552 switch(libetpan_errcode) {
553 case MAILIMAP_NO_ERROR:
555 case MAILIMAP_NO_ERROR_AUTHENTICATED:
556 log_warning(LOG_PROTOCOL, _("IMAP error: authenticated\n"));
558 case MAILIMAP_NO_ERROR_NON_AUTHENTICATED:
559 log_warning(LOG_PROTOCOL, _("IMAP error: not authenticated\n"));
561 case MAILIMAP_ERROR_BAD_STATE:
562 log_warning(LOG_PROTOCOL, _("IMAP error: bad state\n"));
564 case MAILIMAP_ERROR_STREAM:
565 log_warning(LOG_PROTOCOL, _("IMAP error: stream error\n"));
567 case MAILIMAP_ERROR_PARSE:
568 log_warning(LOG_PROTOCOL, _("IMAP error: parse error "
569 "(very probably non-RFC compliance from the server)\n"));
571 case MAILIMAP_ERROR_CONNECTION_REFUSED:
572 log_warning(LOG_PROTOCOL, _("IMAP error: connection refused\n"));
574 case MAILIMAP_ERROR_MEMORY:
575 log_warning(LOG_PROTOCOL, _("IMAP error: memory error\n"));
577 case MAILIMAP_ERROR_FATAL:
578 log_warning(LOG_PROTOCOL, _("IMAP error: fatal error\n"));
580 case MAILIMAP_ERROR_PROTOCOL:
581 log_warning(LOG_PROTOCOL, _("IMAP error: protocol error"
582 "(very probably non-RFC compliance from the server)\n"));
584 case MAILIMAP_ERROR_DONT_ACCEPT_CONNECTION:
585 log_warning(LOG_PROTOCOL, _("IMAP error: connection not accepted\n"));
587 case MAILIMAP_ERROR_APPEND:
588 log_warning(LOG_PROTOCOL, _("IMAP error: APPEND error\n"));
590 case MAILIMAP_ERROR_NOOP:
591 log_warning(LOG_PROTOCOL, _("IMAP error: NOOP error\n"));
593 case MAILIMAP_ERROR_LOGOUT:
594 log_warning(LOG_PROTOCOL, _("IMAP error: LOGOUT error\n"));
596 case MAILIMAP_ERROR_CAPABILITY:
597 log_warning(LOG_PROTOCOL, _("IMAP error: CAPABILITY error\n"));
599 case MAILIMAP_ERROR_CHECK:
600 log_warning(LOG_PROTOCOL, _("IMAP error: CHECK error\n"));
602 case MAILIMAP_ERROR_CLOSE:
603 log_warning(LOG_PROTOCOL, _("IMAP error: CLOSE error\n"));
605 case MAILIMAP_ERROR_EXPUNGE:
606 log_warning(LOG_PROTOCOL, _("IMAP error: EXPUNGE error\n"));
608 case MAILIMAP_ERROR_COPY:
609 log_warning(LOG_PROTOCOL, _("IMAP error: COPY error\n"));
611 case MAILIMAP_ERROR_UID_COPY:
612 log_warning(LOG_PROTOCOL, _("IMAP error: UID COPY error\n"));
614 case MAILIMAP_ERROR_CREATE:
615 log_warning(LOG_PROTOCOL, _("IMAP error: CREATE error\n"));
617 case MAILIMAP_ERROR_DELETE:
618 log_warning(LOG_PROTOCOL, _("IMAP error: DELETE error\n"));
620 case MAILIMAP_ERROR_EXAMINE:
621 log_warning(LOG_PROTOCOL, _("IMAP error: EXAMINE error\n"));
623 case MAILIMAP_ERROR_FETCH:
624 log_warning(LOG_PROTOCOL, _("IMAP error: FETCH error\n"));
626 case MAILIMAP_ERROR_UID_FETCH:
627 log_warning(LOG_PROTOCOL, _("IMAP error: UID FETCH error\n"));
629 case MAILIMAP_ERROR_LIST:
630 log_warning(LOG_PROTOCOL, _("IMAP error: LIST error\n"));
632 case MAILIMAP_ERROR_LOGIN:
633 log_warning(LOG_PROTOCOL, _("IMAP error: LOGIN error\n"));
635 case MAILIMAP_ERROR_LSUB:
636 log_warning(LOG_PROTOCOL, _("IMAP error: LSUB error\n"));
638 case MAILIMAP_ERROR_RENAME:
639 log_warning(LOG_PROTOCOL, _("IMAP error: RENAME error\n"));
641 case MAILIMAP_ERROR_SEARCH:
642 log_warning(LOG_PROTOCOL, _("IMAP error: SEARCH error\n"));
644 case MAILIMAP_ERROR_UID_SEARCH:
645 log_warning(LOG_PROTOCOL, _("IMAP error: UID SEARCH error\n"));
647 case MAILIMAP_ERROR_SELECT:
648 log_warning(LOG_PROTOCOL, _("IMAP error: SELECT error\n"));
650 case MAILIMAP_ERROR_STATUS:
651 log_warning(LOG_PROTOCOL, _("IMAP error: STATUS error\n"));
653 case MAILIMAP_ERROR_STORE:
654 log_warning(LOG_PROTOCOL, _("IMAP error: STORE error\n"));
656 case MAILIMAP_ERROR_UID_STORE:
657 log_warning(LOG_PROTOCOL, _("IMAP error: UID STORE error\n"));
659 case MAILIMAP_ERROR_SUBSCRIBE:
660 log_warning(LOG_PROTOCOL, _("IMAP error: SUBSCRIBE error\n"));
662 case MAILIMAP_ERROR_UNSUBSCRIBE:
663 log_warning(LOG_PROTOCOL, _("IMAP error: UNSUBSCRIBE error\n"));
665 case MAILIMAP_ERROR_STARTTLS:
666 log_warning(LOG_PROTOCOL, _("IMAP error: STARTTLS error\n"));
668 case MAILIMAP_ERROR_INVAL:
669 log_warning(LOG_PROTOCOL, _("IMAP error: INVAL error\n"));
671 case MAILIMAP_ERROR_EXTENSION:
672 log_warning(LOG_PROTOCOL, _("IMAP error: EXTENSION error\n"));
674 case MAILIMAP_ERROR_SASL:
675 log_warning(LOG_PROTOCOL, _("IMAP error: SASL error\n"));
677 #if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
678 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
679 case MAILIMAP_ERROR_SSL:
680 log_warning(LOG_PROTOCOL, _("IMAP error: SSL error\n"));
685 log_warning(LOG_PROTOCOL, _("IMAP error: Unknown error [%d]\n"),
690 if (session && is_fatal(libetpan_errcode)) {
691 imap_disc_session_destroy(IMAP_SESSION(session)->folder);
692 } else if (session && !is_fatal(libetpan_errcode)) {
693 if (IMAP_SESSION(session)->busy)
694 unlock_session(IMAP_SESSION(session));
698 static Folder *imap_folder_new(const gchar *name, const gchar *path)
702 folder = (Folder *)g_new0(IMAPFolder, 1);
703 folder->klass = &imap_class;
704 imap_folder_init(folder, name, path);
709 static void imap_folder_destroy(Folder *folder)
711 while (imap_folder_get_refcnt(folder) > 0)
712 gtk_main_iteration();
714 folder_remote_folder_destroy(REMOTE_FOLDER(folder));
718 static void imap_folder_init(Folder *folder, const gchar *name,
721 folder_remote_folder_init((Folder *)folder, name, path);
722 IMAP_FOLDER(folder)->max_set_size = IMAP_SET_MAX_COUNT;
725 static FolderItem *imap_folder_item_new(Folder *folder)
727 IMAPFolderItem *item;
729 item = g_new0(IMAPFolderItem, 1);
732 item->uid_list = NULL;
734 return (FolderItem *)item;
737 static void imap_folder_item_destroy(Folder *folder, FolderItem *_item)
739 IMAPFolderItem *item = (IMAPFolderItem *)_item;
741 g_return_if_fail(item != NULL);
742 g_slist_free(item->uid_list);
747 static gboolean imap_reset_uid_lists_func(GNode *node, gpointer data)
749 IMAPFolderItem *item = (IMAPFolderItem *)node->data;
752 g_slist_free(item->uid_list);
753 item->uid_list = NULL;
758 static void imap_reset_uid_lists(Folder *folder)
760 if(folder->node == NULL)
763 /* Destroy all uid lists and rest last uid */
764 g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
767 static int imap_get_capabilities(IMAPSession *session)
769 struct mailimap_capability_data *capabilities = NULL;
773 if (session->capability != NULL)
774 return MAILIMAP_NO_ERROR;
776 capabilities = imap_threaded_capability(session->folder, &result);
778 if (result != MAILIMAP_NO_ERROR) {
779 imap_handle_error(SESSION(session), result);
780 return MAILIMAP_ERROR_CAPABILITY;
783 if (capabilities == NULL) {
784 return MAILIMAP_NO_ERROR;
787 for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
788 cur = clist_next(cur)) {
789 struct mailimap_capability * cap =
791 if (!cap || cap->cap_data.cap_name == NULL)
793 session->capability = g_slist_append
794 (session->capability,
795 g_strdup(cap->cap_data.cap_name));
796 debug_print("got capa %s\n", cap->cap_data.cap_name);
798 mailimap_capability_data_free(capabilities);
799 return MAILIMAP_NO_ERROR;
802 static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
805 for (cur = session->capability; cur; cur = cur->next) {
806 if (!g_ascii_strcasecmp(cur->data, cap))
812 static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
815 gint ok = MAILIMAP_ERROR_BAD_STATE;
816 static time_t last_login_err = 0;
817 gchar *ext_info = "";
819 if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
820 imap_handle_error(SESSION(session), r);
825 ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
827 case IMAP_AUTH_CRAM_MD5:
828 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
830 case IMAP_AUTH_LOGIN:
831 ok = imap_cmd_login(session, user, pass, "LOGIN");
833 case IMAP_AUTH_GSSAPI:
834 ok = imap_cmd_login(session, user, pass, "GSSAPI");
837 debug_print("capabilities:\n"
842 imap_has_capability(session, "ANONYMOUS"),
843 imap_has_capability(session, "CRAM-MD5"),
844 imap_has_capability(session, "LOGIN"),
845 imap_has_capability(session, "GSSAPI"));
846 if (imap_has_capability(session, "CRAM-MD5"))
847 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
848 if (ok == MAILIMAP_ERROR_BAD_STATE && imap_has_capability(session, "GSSAPI"))
849 ok = imap_cmd_login(session, user, pass, "GSSAPI");
850 if (ok == MAILIMAP_ERROR_BAD_STATE) /* we always try LOGIN before giving up */
851 ok = imap_cmd_login(session, user, pass, "LOGIN");
854 if (ok == MAILIMAP_NO_ERROR)
855 session->authenticated = TRUE;
857 if (type == IMAP_AUTH_CRAM_MD5) {
858 ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
859 "compiled with SASL support and the "
860 "CRAM-MD5 SASL plugin is installed.");
863 if (time(NULL) - last_login_err > 10) {
864 if (!prefs_common.no_recv_err_panel) {
865 alertpanel_error(_("Connection to %s failed: "
867 SESSION(session)->server, ext_info);
869 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
870 "login refused.%s\n"),
871 SESSION(session)->server, ext_info);
874 last_login_err = time(NULL);
879 static IMAPSession *imap_reconnect_if_possible(Folder *folder, IMAPSession *session)
881 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
882 /* Check if this is the first try to establish a
883 connection, if yes we don't try to reconnect */
884 debug_print("reconnecting\n");
885 if (rfolder->session == NULL) {
886 log_warning(LOG_PROTOCOL, _("Connecting to %s failed"),
887 folder->account->recv_server);
888 session_destroy(SESSION(session));
891 rfolder->session = NULL;
892 log_warning(LOG_PROTOCOL, _("IMAP4 connection to %s has been"
893 " disconnected. Reconnecting...\n"),
894 folder->account->recv_server);
895 statusbar_print_all(_("IMAP4 connection to %s has been"
896 " disconnected. Reconnecting...\n"),
897 folder->account->recv_server);
898 SESSION(session)->state = SESSION_DISCONNECTED;
899 session_destroy(SESSION(session));
900 /* Clear folders session to make imap_session_get create
901 a new session, because of rfolder->session == NULL
902 it will not try to reconnect again and so avoid an
904 debug_print("getting session...\n");
905 session = imap_session_get(folder);
906 rfolder->session = SESSION(session);
912 static IMAPSession *imap_session_get(Folder *folder)
914 RemoteFolder *rfolder = REMOTE_FOLDER(folder);
915 IMAPSession *session = NULL;
916 gint r = MAILIMAP_NO_ERROR;
918 g_return_val_if_fail(folder != NULL, NULL);
919 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
920 g_return_val_if_fail(folder->account != NULL, NULL);
922 if (prefs_common.work_offline &&
923 !inc_offline_should_override(FALSE,
924 _("Claws Mail needs network access in order "
925 "to access the IMAP server."))) {
929 /* Make sure we have a session */
930 if (rfolder->session != NULL) {
931 session = IMAP_SESSION(rfolder->session);
932 } else if (rfolder->connecting) {
933 debug_print("already connecting\n");
936 imap_reset_uid_lists(folder);
937 if (time(NULL) - rfolder->last_failure <= 2)
939 rfolder->connecting = TRUE;
940 session = imap_session_new(folder, folder->account);
942 if(session == NULL) {
943 rfolder->last_failure = time(NULL);
944 rfolder->connecting = FALSE;
948 /* Make sure session is authenticated */
949 if (!IMAP_SESSION(session)->authenticated)
950 imap_session_authenticate(IMAP_SESSION(session), folder->account);
952 if (!IMAP_SESSION(session)->authenticated) {
953 imap_threaded_disconnect(session->folder);
954 rfolder->session = NULL;
955 SESSION(session)->state = SESSION_DISCONNECTED;
956 session_destroy(SESSION(session));
957 rfolder->last_failure = time(NULL);
958 rfolder->connecting = FALSE;
962 /* I think the point of this code is to avoid sending a
963 * keepalive if we've used the session recently and therefore
964 * think it's still alive. Unfortunately, most of the code
965 * does not yet check for errors on the socket, and so if the
966 * connection drops we don't notice until the timeout expires.
967 * A better solution than sending a NOOP every time would be
968 * for every command to be prepared to retry until it is
969 * successfully sent. -- mbp */
970 if ((time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) || session->cancelled) {
971 /* verify that the session is still alive */
972 if ((r = imap_cmd_noop(session)) != MAILIMAP_NO_ERROR) {
973 debug_print("disconnected!\n");
975 session = imap_reconnect_if_possible(folder, session);
977 session = imap_session_get(folder);
980 session->cancelled = FALSE;
983 rfolder->session = SESSION(session);
984 rfolder->connecting = FALSE;
986 return IMAP_SESSION(session);
989 static IMAPSession *imap_session_new(Folder * folder,
990 const PrefsAccount *account)
992 IMAPSession *session;
995 int authenticated = FALSE;
997 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
998 /* FIXME: IMAP over SSL only... */
1001 port = account->set_imapport ? account->imapport
1002 : account->ssl_imap == SSL_TUNNEL ? IMAPS_PORT : IMAP4_PORT;
1003 ssl_type = account->ssl_imap;
1005 if (account->ssl_imap != SSL_NONE) {
1006 if (alertpanel_full(_("Insecure connection"),
1007 _("This connection is configured to be secured "
1008 "using SSL, but SSL is not available in this "
1009 "build of Claws Mail. \n\n"
1010 "Do you want to continue connecting to this "
1011 "server? The communication would not be "
1013 GTK_STOCK_CANCEL, _("Con_tinue connecting"),
1014 NULL, FALSE, NULL, ALERT_WARNING,
1015 G_ALERTDEFAULT) != G_ALERTALTERNATE)
1018 port = account->set_imapport ? account->imapport
1023 statuswindow_print_all(_("Connecting to IMAP4 server: %s..."), folder->account->recv_server);
1024 if (account->set_tunnelcmd) {
1025 r = imap_threaded_connect_cmd(folder,
1027 account->recv_server,
1031 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
1032 if (ssl_type == SSL_TUNNEL) {
1033 r = imap_threaded_connect_ssl(folder,
1034 account->recv_server,
1040 r = imap_threaded_connect(folder,
1041 account->recv_server,
1046 statuswindow_pop_all();
1047 if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
1048 authenticated = TRUE;
1050 else if (r == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
1051 authenticated = FALSE;
1054 #if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
1055 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
1056 if (r == MAILIMAP_ERROR_SSL)
1057 log_error(LOG_PROTOCOL, _("SSL handshake failed\n"));
1061 imap_handle_error(NULL, r);
1063 if(!prefs_common.no_recv_err_panel) {
1064 alertpanel_error_log(_("Can't connect to IMAP4 server: %s:%d"),
1065 account->recv_server, port);
1067 log_error(LOG_PROTOCOL, _("Can't connect to IMAP4 server: %s:%d\n"),
1068 account->recv_server, port);
1074 session = g_new0(IMAPSession, 1);
1075 session_init(SESSION(session));
1076 SESSION(session)->type = SESSION_IMAP;
1077 SESSION(session)->server = g_strdup(account->recv_server);
1078 SESSION(session)->sock = NULL;
1080 SESSION(session)->destroy = imap_session_destroy;
1082 session->capability = NULL;
1084 session->authenticated = authenticated;
1085 session->mbox = NULL;
1086 session->exists = 0;
1087 session->recent = 0;
1088 session->expunge = 0;
1089 session->cmd_count = 0;
1090 session->folder = folder;
1091 IMAP_FOLDER(session->folder)->last_seen_separator = 0;
1093 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
1094 if (account->ssl_imap == SSL_STARTTLS) {
1097 ok = imap_cmd_starttls(session);
1098 if (ok != MAILIMAP_NO_ERROR) {
1099 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
1100 session_destroy(SESSION(session));
1104 imap_free_capabilities(session);
1105 session->authenticated = FALSE;
1106 session->uidplus = FALSE;
1107 session->cmd_count = 1;
1110 log_message(LOG_PROTOCOL, "IMAP connection is %s-authenticated\n",
1111 (session->authenticated) ? "pre" : "un");
1116 static void imap_session_authenticate(IMAPSession *session,
1117 const PrefsAccount *account)
1119 gchar *pass, *acc_pass;
1120 gboolean failed = FALSE;
1122 g_return_if_fail(account->userid != NULL);
1123 acc_pass = account->passwd;
1126 if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
1128 tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
1131 Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
1133 } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
1136 statuswindow_print_all(_("Connecting to IMAP4 server %s...\n"),
1137 account->recv_server);
1138 if (imap_auth(session, account->userid, pass, account->imap_auth_type) != MAILIMAP_NO_ERROR) {
1139 statusbar_pop_all();
1146 if (prefs_common.no_recv_err_panel) {
1147 log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s."), account->recv_server);
1148 mainwindow_show_error();
1150 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
1156 statuswindow_pop_all();
1157 session->authenticated = TRUE;
1161 static void imap_session_destroy(Session *session)
1163 if (session->state != SESSION_DISCONNECTED)
1164 imap_threaded_disconnect(IMAP_SESSION(session)->folder);
1166 imap_free_capabilities(IMAP_SESSION(session));
1167 g_free(IMAP_SESSION(session)->mbox);
1168 sock_close(session->sock);
1169 session->sock = NULL;
1172 static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
1174 return imap_fetch_msg_full(folder, item, uid, TRUE, TRUE);
1177 static guint get_file_size_with_crs(const gchar *filename)
1183 if (filename == NULL)
1186 fp = fopen(filename, "rb");
1190 while (fgets(buf, sizeof (buf), fp) != NULL) {
1192 if (!strstr(buf, "\r\n") && strstr(buf, "\n"))
1200 static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
1202 gchar *path, *filename;
1204 path = folder_item_get_path(item);
1206 if (!is_dir_exist(path)) {
1211 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msginfo->msgnum), NULL);
1214 if (is_file_exist(filename)) {
1220 static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
1221 gboolean headers, gboolean body)
1223 gchar *path, *filename;
1224 IMAPSession *session;
1227 g_return_val_if_fail(folder != NULL, NULL);
1228 g_return_val_if_fail(item != NULL, NULL);
1233 path = folder_item_get_path(item);
1234 if (!is_dir_exist(path))
1235 make_dir_hier(path);
1236 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1238 debug_print("trying to fetch cached %s\n", filename);
1239 if (is_file_exist(filename)) {
1240 /* see whether the local file represents the whole message
1241 * or not. As the IMAP server reports size with \r chars,
1242 * we have to update the local file (UNIX \n only) size */
1243 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1244 guint have_size = -1;
1247 debug_print("message %d has been already %scached.\n", uid,
1248 MSG_IS_FULLY_CACHED(cached->flags) ? "fully ":"");
1250 if (!cached || !MSG_IS_FULLY_CACHED(cached->flags)) {
1251 have_size = get_file_size_with_crs(filename);
1252 if (cached && (cached->size <= have_size || !body)) {
1253 procmsg_msginfo_free(cached);
1254 ok = file_strip_crs(filename);
1255 if (ok == 0 && cached && cached->size <= have_size) {
1256 /* we have it all and stripped */
1257 debug_print("...fully cached in fact; setting flag.\n");
1258 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1261 } else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
1262 debug_print("message not cached and file recent, considering file complete\n");
1263 ok = file_strip_crs(filename);
1267 procmsg_msginfo_free(cached);
1270 if (cached && MSG_IS_FULLY_CACHED(cached->flags)) {
1271 procmsg_msginfo_free(cached);
1275 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1277 procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1278 procmsg_msginfo_free(cached);
1282 debug_print("getting session...\n");
1283 session = imap_session_get(folder);
1289 session_set_access_time(SESSION(session));
1290 lock_session(session); /* unlocked later in the function */
1292 debug_print("IMAP fetching messages\n");
1293 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
1294 NULL, NULL, NULL, NULL, FALSE);
1295 if (ok != MAILIMAP_NO_ERROR) {
1296 g_warning("can't select mailbox %s\n", item->path);
1301 session_set_access_time(SESSION(session));
1303 debug_print("getting message %d...\n", uid);
1304 ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
1306 if (ok != MAILIMAP_NO_ERROR) {
1307 g_warning("can't fetch message %d\n", uid);
1312 session_set_access_time(SESSION(session));
1313 unlock_session(session);
1315 ok = file_strip_crs(filename);
1317 if (ok == 0 && headers && body) {
1318 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1320 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1321 procmsg_msginfo_free(cached);
1323 } else if (ok == -1) {
1324 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1326 procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1327 procmsg_msginfo_free(cached);
1333 static gboolean imap_is_msg_fully_cached(Folder *folder, FolderItem *item, gint uid)
1335 gchar *path, *filename;
1337 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1342 if (MSG_IS_FULLY_CACHED(cached->flags)) {
1343 procmsg_msginfo_free(cached);
1346 path = folder_item_get_path(item);
1347 if (!is_dir_exist(path))
1350 filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
1352 if (is_file_exist(filename)) {
1353 if (cached && cached->total_size == cached->size) {
1356 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1359 size = get_file_size_with_crs(filename);
1362 if (cached && size >= cached->size) {
1363 cached->total_size = cached->size;
1364 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1365 procmsg_msginfo_free(cached);
1369 procmsg_msginfo_free(cached);
1373 void imap_cache_msg(FolderItem *item, gint msgnum)
1375 Folder *folder = NULL;
1379 folder = item->folder;
1381 if (!imap_is_msg_fully_cached(folder, item, msgnum)) {
1382 gchar *tmp = imap_fetch_msg_full(folder, item, msgnum, TRUE, TRUE);
1383 debug_print("fetched %s\n", tmp);
1388 static gint imap_add_msg(Folder *folder, FolderItem *dest,
1389 const gchar *file, MsgFlags *flags)
1393 MsgFileInfo fileinfo;
1395 g_return_val_if_fail(file != NULL, -1);
1397 fileinfo.msginfo = NULL;
1398 fileinfo.file = (gchar *)file;
1399 fileinfo.flags = flags;
1400 file_list.data = &fileinfo;
1401 file_list.next = NULL;
1403 ret = imap_add_msgs(folder, dest, &file_list, NULL);
1407 static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
1408 GRelation *relation)
1411 IMAPSession *session;
1412 guint32 last_uid = 0;
1414 MsgFileInfo *fileinfo;
1415 gint ok = MAILIMAP_NO_ERROR;
1416 gint curnum = 0, total = 0;
1417 gboolean missing_uids = FALSE;
1419 g_return_val_if_fail(folder != NULL, -1);
1420 g_return_val_if_fail(dest != NULL, -1);
1421 g_return_val_if_fail(file_list != NULL, -1);
1423 debug_print("getting session...\n");
1424 session = imap_session_get(folder);
1428 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1430 statusbar_print_all(_("Adding messages..."));
1431 total = g_slist_length(file_list);
1432 for (cur = file_list; cur != NULL; cur = cur->next) {
1433 IMAPFlags iflags = 0;
1434 guint32 new_uid = 0;
1435 gchar *real_file = NULL;
1436 fileinfo = (MsgFileInfo *)cur->data;
1438 statusbar_progress_all(curnum, total, total < 10 ? 1:10);
1441 if (fileinfo->flags) {
1442 if (MSG_IS_MARKED(*fileinfo->flags))
1443 iflags |= IMAP_FLAG_FLAGGED;
1444 if (MSG_IS_REPLIED(*fileinfo->flags))
1445 iflags |= IMAP_FLAG_ANSWERED;
1446 if (!MSG_IS_UNREAD(*fileinfo->flags))
1447 iflags |= IMAP_FLAG_SEEN;
1450 if (real_file == NULL)
1451 real_file = g_strdup(fileinfo->file);
1453 if (folder_has_parent_of_type(dest, F_QUEUE) ||
1454 folder_has_parent_of_type(dest, F_OUTBOX) ||
1455 folder_has_parent_of_type(dest, F_DRAFT) ||
1456 folder_has_parent_of_type(dest, F_TRASH))
1457 iflags |= IMAP_FLAG_SEEN;
1459 ok = imap_cmd_append(session, destdir, real_file, iflags,
1462 if (ok != MAILIMAP_NO_ERROR) {
1463 g_warning("can't append message %s\n", real_file);
1466 statusbar_progress_all(0,0,0);
1467 statusbar_pop_all();
1470 debug_print("appended new message as %d\n", new_uid);
1471 /* put the local file in the imapcache, so that we don't
1472 * have to fetch it back later. */
1475 missing_uids = TRUE;
1476 debug_print("Missing UID (0)\n");
1479 gchar *cache_path = folder_item_get_path(dest);
1480 if (!is_dir_exist(cache_path))
1481 make_dir_hier(cache_path);
1482 if (is_dir_exist(cache_path)) {
1483 gchar *cache_file = g_strconcat(
1484 cache_path, G_DIR_SEPARATOR_S,
1485 itos(new_uid), NULL);
1486 copy_file(real_file, cache_file, TRUE);
1487 debug_print("got UID %d, copied to cache: %s\n", new_uid, cache_file);
1494 if (relation != NULL)
1495 g_relation_insert(relation, fileinfo->msginfo != NULL ?
1496 (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
1497 GINT_TO_POINTER(new_uid));
1498 if (last_uid < new_uid) {
1505 statusbar_progress_all(0,0,0);
1506 statusbar_pop_all();
1511 imap_scan_required(folder, dest);
1513 session = imap_session_get(folder);
1519 ok = imap_select(session, IMAP_FOLDER(folder), dest->path,
1520 &a, NULL, NULL, NULL, FALSE);
1525 static GSList *flatten_mailimap_set(struct mailimap_set * set)
1527 GSList *result = NULL;
1532 for (list = clist_begin(set->set_list); list; list = clist_next(list)) {
1533 struct mailimap_set_item *item = (struct mailimap_set_item *)clist_content(list);
1534 start = item->set_first;
1535 end = item->set_last;
1536 for (t = start; t <= end; t++) {
1537 result = g_slist_prepend(result, GINT_TO_POINTER(t));
1540 result = g_slist_reverse(result);
1541 if (debug_get_mode()) {
1542 debug_print("flat imap set: ");
1543 for (cur = result; cur; cur = cur->next) {
1544 debug_print("%d ", GPOINTER_TO_INT(cur->data));
1551 static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
1552 MsgInfoList *msglist, GRelation *relation)
1556 GSList *seq_list, *cur;
1558 IMAPSession *session;
1559 gint ok = MAILIMAP_NO_ERROR;
1560 GRelation *uid_mapping;
1562 gboolean single = FALSE;
1564 g_return_val_if_fail(folder != NULL, -1);
1565 g_return_val_if_fail(dest != NULL, -1);
1566 g_return_val_if_fail(msglist != NULL, -1);
1568 debug_print("getting session...\n");
1569 session = imap_session_get(folder);
1575 msginfo = (MsgInfo *)msglist->data;
1576 if (msglist->next == NULL)
1578 src = msginfo->folder;
1580 g_warning("the src folder is identical to the dest.\n");
1584 if (src->folder != dest->folder) {
1585 GSList *infolist = NULL, *cur;
1587 for (cur = msglist; cur; cur = cur->next) {
1588 msginfo = (MsgInfo *)cur->data;
1589 MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
1590 fileinfo->file = procmsg_get_message_file(msginfo);
1591 fileinfo->flags = &(msginfo->flags);
1592 infolist = g_slist_prepend(infolist, fileinfo);
1594 infolist = g_slist_reverse(infolist);
1595 res = folder_item_add_msgs(dest, infolist, FALSE);
1596 for (cur = infolist; cur; cur = cur->next) {
1597 MsgFileInfo *info = (MsgFileInfo *)cur->data;
1601 g_slist_free(infolist);
1605 lock_session(session); /* unlocked later in the function */
1607 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1608 NULL, NULL, NULL, NULL, FALSE);
1609 if (ok != MAILIMAP_NO_ERROR) {
1613 unlock_session(session);
1615 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1616 seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msglist);
1617 uid_mapping = g_relation_new(2);
1618 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1620 statusbar_print_all(_("Copying messages..."));
1621 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
1622 struct mailimap_set * seq_set;
1623 struct mailimap_set * source = NULL;
1624 struct mailimap_set * dest = NULL;
1625 seq_set = cur->data;
1627 debug_print("Copying messages from %s to %s ...\n",
1628 src->path, destdir);
1630 lock_session(session); /* unlocked later in the function */
1631 ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping,
1638 if (ok == MAILIMAP_NO_ERROR) {
1639 unlock_session(session);
1640 if (relation && source && dest) {
1641 GSList *s_list = flatten_mailimap_set(source);
1642 GSList *d_list = flatten_mailimap_set(dest);
1643 GSList *s_cur, *d_cur;
1644 if (g_slist_length(s_list) == g_slist_length(d_list)) {
1646 for (s_cur = s_list, d_cur = d_list;
1648 s_cur = s_cur->next, d_cur = d_cur->next) {
1649 g_relation_insert(uid_mapping, s_cur->data, d_cur->data);
1653 debug_print("hhhmm, source list length != dest list length.\n");
1655 g_slist_free(s_list);
1656 g_slist_free(d_list);
1662 mailimap_set_free(source);
1664 mailimap_set_free(dest);
1666 if (ok != MAILIMAP_NO_ERROR) {
1667 g_relation_destroy(uid_mapping);
1668 imap_lep_set_free(seq_list);
1669 statusbar_pop_all();
1674 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
1675 MsgInfo *msginfo = (MsgInfo *)cur->data;
1678 tuples = g_relation_select(uid_mapping,
1679 GINT_TO_POINTER(msginfo->msgnum),
1681 if (tuples->len > 0) {
1682 gint num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1683 g_relation_insert(relation, msginfo,
1684 GINT_TO_POINTER(num));
1687 debug_print("copied message %d as %d\n", msginfo->msgnum, num);
1688 /* put the local file in the imapcache, so that we don't
1689 * have to fetch it back later. */
1691 gchar *cache_path = folder_item_get_path(msginfo->folder);
1692 gchar *real_file = g_strconcat(
1693 cache_path, G_DIR_SEPARATOR_S,
1694 itos(msginfo->msgnum), NULL);
1695 gchar *cache_file = NULL;
1697 cache_path = folder_item_get_path(dest);
1698 cache_file = g_strconcat(
1699 cache_path, G_DIR_SEPARATOR_S,
1701 if (!is_dir_exist(cache_path))
1702 make_dir_hier(cache_path);
1703 if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
1704 copy_file(real_file, cache_file, TRUE);
1705 debug_print("copied to cache: %s\n", cache_file);
1712 g_relation_insert(relation, msginfo,
1713 GINT_TO_POINTER(0));
1714 g_tuples_destroy(tuples);
1716 statusbar_pop_all();
1718 g_relation_destroy(uid_mapping);
1719 imap_lep_set_free(seq_list);
1723 IMAP_FOLDER_ITEM(dest)->lastuid = 0;
1724 IMAP_FOLDER_ITEM(dest)->uid_next = 0;
1725 g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
1726 IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
1728 imap_scan_required(folder, dest);
1729 if (ok == MAILIMAP_NO_ERROR)
1735 static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1739 g_return_val_if_fail(msginfo != NULL, -1);
1741 msglist.data = msginfo;
1742 msglist.next = NULL;
1744 return imap_copy_msgs(folder, dest, &msglist, NULL);
1747 static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
1748 MsgInfoList *msglist, GRelation *relation)
1753 g_return_val_if_fail(folder != NULL, -1);
1754 g_return_val_if_fail(dest != NULL, -1);
1755 g_return_val_if_fail(msglist != NULL, -1);
1757 msginfo = (MsgInfo *)msglist->data;
1758 g_return_val_if_fail(msginfo->folder != NULL, -1);
1760 ret = imap_do_copy_msgs(folder, dest, msglist, relation);
1765 static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
1766 MsgInfoList *msglist, GRelation *relation)
1768 gchar *destdir, *dir;
1769 GSList *numlist = NULL, *cur;
1771 IMAPSession *session;
1772 gint ok = MAILIMAP_NO_ERROR;
1773 GRelation *uid_mapping;
1775 g_return_val_if_fail(folder != NULL, -1);
1776 g_return_val_if_fail(dest != NULL, -1);
1777 g_return_val_if_fail(msglist != NULL, -1);
1779 debug_print("getting session...\n");
1780 session = imap_session_get(folder);
1785 lock_session(session); /* unlocked later in the function */
1787 msginfo = (MsgInfo *)msglist->data;
1789 ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1790 NULL, NULL, NULL, NULL, FALSE);
1791 if (ok != MAILIMAP_NO_ERROR) {
1795 destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1796 for (cur = msglist; cur; cur = cur->next) {
1797 msginfo = (MsgInfo *)cur->data;
1798 if (!MSG_IS_DELETED(msginfo->flags))
1799 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
1801 numlist = g_slist_reverse(numlist);
1803 uid_mapping = g_relation_new(2);
1804 g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1806 if (numlist != NULL) {
1807 ok = imap_set_message_flags
1808 (session, numlist, IMAP_FLAG_DELETED, TRUE);
1809 if (ok != MAILIMAP_NO_ERROR) {
1810 log_warning(LOG_PROTOCOL, _("can't set deleted flags\n"));
1813 } /* else we just need to expunge */
1814 ok = imap_cmd_expunge(session);
1815 if (ok != MAILIMAP_NO_ERROR) {
1816 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
1820 session->folder_content_changed = TRUE;
1821 unlock_session(session);
1823 dir = folder_item_get_path(msginfo->folder);
1824 if (is_dir_exist(dir)) {
1825 for (cur = msglist; cur; cur = cur->next) {
1826 msginfo = (MsgInfo *)cur->data;
1827 remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
1832 g_relation_destroy(uid_mapping);
1833 g_slist_free(numlist);
1835 imap_scan_required(folder, dest);
1838 if (ok == MAILIMAP_NO_ERROR)
1844 static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
1845 MsgInfoList *msglist, GRelation *relation)
1849 g_return_val_if_fail(folder != NULL, -1);
1850 g_return_val_if_fail(dest != NULL, -1);
1851 if (msglist == NULL)
1854 msginfo = (MsgInfo *)msglist->data;
1855 g_return_val_if_fail(msginfo->folder != NULL, -1);
1857 return imap_do_remove_msgs(folder, dest, msglist, relation);
1860 static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
1862 GSList *list = folder_item_get_msg_list(item);
1863 gint res = imap_remove_msgs(folder, item, list, NULL);
1864 procmsg_msg_list_free(list);
1868 static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
1871 /* TODO: properly implement this method */
1875 static gint imap_close(Folder *folder, FolderItem *item)
1880 static gint imap_scan_tree_real(Folder *folder, gboolean subs_only)
1882 FolderItem *item = NULL;
1883 IMAPSession *session;
1884 gchar *root_folder = NULL;
1886 g_return_val_if_fail(folder != NULL, -1);
1887 g_return_val_if_fail(folder->account != NULL, -1);
1889 debug_print("getting session...\n");
1890 session = imap_session_get(folder);
1892 if (!folder->node) {
1893 folder_tree_destroy(folder);
1894 item = folder_item_new(folder, folder->name, NULL);
1895 item->folder = folder;
1896 folder->node = item->node = g_node_new(item);
1901 if (folder->account->imap_dir && *folder->account->imap_dir) {
1906 Xstrdup_a(root_folder, folder->account->imap_dir, {return -1;});
1907 extract_quote(root_folder, '"');
1908 subst_char(root_folder,
1909 imap_get_path_separator(session, IMAP_FOLDER(folder),
1912 strtailchomp(root_folder, '/');
1913 real_path = imap_get_real_path
1914 (session, IMAP_FOLDER(folder), root_folder);
1915 debug_print("IMAP root directory: %s\n", real_path);
1917 /* check if root directory exist */
1919 r = imap_threaded_list(session->folder, "", real_path,
1922 if (r != MAILIMAP_NO_ERROR)
1923 imap_handle_error(SESSION(session), r);
1925 if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
1926 if (!folder->node) {
1927 item = folder_item_new(folder, folder->name, NULL);
1928 item->folder = folder;
1929 folder->node = item->node = g_node_new(item);
1933 mailimap_list_result_free(lep_list);
1939 item = FOLDER_ITEM(folder->node->data);
1941 if (item && !item->path && root_folder) {
1942 item->path = g_strdup(root_folder);
1945 if (!item || ((item->path || root_folder) &&
1946 strcmp2(item->path, root_folder) != 0)) {
1947 folder_tree_destroy(folder);
1948 item = folder_item_new(folder, folder->name, root_folder);
1949 item->folder = folder;
1950 folder->node = item->node = g_node_new(item);
1953 imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data), subs_only);
1954 imap_create_missing_folders(folder);
1959 static gint imap_scan_tree(Folder *folder)
1961 gboolean subs_only = FALSE;
1962 if (folder->account) {
1963 debug_print(" scanning only subs %d\n", folder->account->imap_subsonly);
1964 subs_only = folder->account->imap_subsonly;
1966 return imap_scan_tree_real(folder, subs_only);
1969 static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item, gboolean subs_only)
1972 IMAPFolder *imapfolder;
1973 FolderItem *new_item;
1974 GSList *item_list, *cur;
1977 gchar *wildcard_path;
1983 g_return_val_if_fail(item != NULL, -1);
1984 g_return_val_if_fail(item->folder != NULL, -1);
1985 g_return_val_if_fail(item->no_sub == FALSE, -1);
1987 folder = item->folder;
1988 imapfolder = IMAP_FOLDER(folder);
1990 separator = imap_get_path_separator(session, imapfolder, item->path);
1992 if (folder->ui_func)
1993 folder->ui_func(folder, item, folder->ui_func_data);
1996 wildcard[0] = separator;
1999 real_path = imap_get_real_path(session, imapfolder, item->path);
2003 real_path = g_strdup("");
2006 Xstrcat_a(wildcard_path, real_path, wildcard,
2007 {g_free(real_path); return MAILIMAP_ERROR_BAD_STATE;});
2011 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
2013 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
2015 if (r != MAILIMAP_NO_ERROR) {
2016 imap_handle_error(SESSION(session), r);
2020 item_list = imap_list_from_lep(imapfolder,
2021 lep_list, real_path, FALSE);
2022 mailimap_list_result_free(lep_list);
2027 node = item->node->children;
2028 while (node != NULL) {
2029 FolderItem *old_item = FOLDER_ITEM(node->data);
2030 GNode *next = node->next;
2033 for (cur = item_list; cur != NULL; cur = cur->next) {
2034 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2035 if (!strcmp2(old_item->path, cur_item->path)) {
2036 new_item = cur_item;
2041 if (old_item && old_item->path && !strcmp(old_item->path, "INBOX")) {
2042 debug_print("not removing INBOX\n");
2044 debug_print("folder '%s' not found. removing...\n",
2046 folder_item_remove(old_item);
2049 old_item->no_sub = new_item->no_sub;
2050 old_item->no_select = new_item->no_select;
2051 if (old_item->no_sub == TRUE && node->children) {
2052 debug_print("folder '%s' doesn't have "
2053 "subfolders. removing...\n",
2055 folder_item_remove_children(old_item);
2062 for (cur = item_list; cur != NULL; cur = cur->next) {
2063 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2066 for (node = item->node->children; node != NULL;
2067 node = node->next) {
2068 if (!strcmp2(FOLDER_ITEM(node->data)->path,
2070 new_item = FOLDER_ITEM(node->data);
2071 folder_item_destroy(cur_item);
2077 new_item = cur_item;
2078 debug_print("new folder '%s' found.\n", new_item->path);
2079 folder_item_append(item, new_item);
2082 if (!strcmp(new_item->path, "INBOX")) {
2083 new_item->stype = F_INBOX;
2084 folder->inbox = new_item;
2085 } else if (!folder_item_parent(item) || item->stype == F_INBOX) {
2088 base = g_path_get_basename(new_item->path);
2090 if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
2091 new_item->stype = F_OUTBOX;
2092 folder->outbox = new_item;
2093 } else if (!folder->draft && !g_ascii_strcasecmp(base, "Drafts")) {
2094 new_item->stype = F_DRAFT;
2095 folder->draft = new_item;
2096 } else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
2097 new_item->stype = F_QUEUE;
2098 folder->queue = new_item;
2099 } else if (!folder->trash && !g_ascii_strcasecmp(base, "Trash")) {
2100 new_item->stype = F_TRASH;
2101 folder->trash = new_item;
2106 if (new_item->no_sub == FALSE)
2107 imap_scan_tree_recursive(session, new_item, subs_only);
2110 g_slist_free(item_list);
2112 return MAILIMAP_NO_ERROR;
2115 GList *imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
2117 IMAPSession *session = imap_session_get(folder);
2119 gchar *wildcard_path;
2123 GSList *item_list = NULL, *cur;
2124 GList *child_list = NULL, *tmplist = NULL;
2125 GSList *sub_list = NULL;
2131 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
2134 wildcard[0] = separator;
2137 real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2141 real_path = g_strdup("");
2144 Xstrcat_a(wildcard_path, real_path, wildcard,
2145 {g_free(real_path); return NULL;});
2149 statusbar_print_all(_("Looking for unsubscribed folders in %s..."),
2150 item->path?item->path:item->name);
2152 statusbar_print_all(_("Looking for subfolders of %s..."),
2153 item->path?item->path:item->name);
2155 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
2157 statusbar_pop_all();
2160 item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2161 lep_list, real_path, FALSE);
2162 mailimap_list_result_free(lep_list);
2164 for (cur = item_list; cur != NULL; cur = cur->next) {
2165 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2167 tmplist = imap_scan_subtree(folder, cur_item,
2168 unsubs_only, recursive);
2170 child_list = g_list_concat(child_list, tmplist);
2172 child_list = g_list_prepend(child_list,
2173 imap_get_real_path(session,
2174 IMAP_FOLDER(folder), cur_item->path));
2176 folder_item_destroy(cur_item);
2178 child_list = g_list_reverse(child_list);
2179 g_slist_free(item_list);
2182 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
2184 statusbar_pop_all();
2187 sub_list = imap_list_from_lep(IMAP_FOLDER(folder),
2188 lep_list, real_path, FALSE);
2189 mailimap_list_result_free(lep_list);
2191 for (cur = sub_list; cur != NULL; cur = cur->next) {
2192 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2193 GList *oldlitem = NULL;
2194 gchar *tmp = imap_get_real_path(session,
2195 IMAP_FOLDER(folder), cur_item->path);
2196 folder_item_destroy(cur_item);
2197 oldlitem = g_list_find_custom(
2198 child_list, tmp, (GCompareFunc)strcmp2);
2200 child_list = g_list_remove_link(child_list, oldlitem);
2201 g_free(oldlitem->data);
2202 g_list_free(oldlitem);
2208 statusbar_pop_all();
2213 static gint imap_create_tree(Folder *folder)
2215 g_return_val_if_fail(folder != NULL, -1);
2216 g_return_val_if_fail(folder->node != NULL, -1);
2217 g_return_val_if_fail(folder->node->data != NULL, -1);
2218 g_return_val_if_fail(folder->account != NULL, -1);
2220 imap_scan_tree(folder);
2221 imap_create_missing_folders(folder);
2226 static void imap_create_missing_folders(Folder *folder)
2228 g_return_if_fail(folder != NULL);
2231 folder->inbox = imap_create_special_folder
2232 (folder, F_INBOX, "INBOX");
2234 folder->trash = imap_create_special_folder
2235 (folder, F_TRASH, "Trash");
2237 folder->queue = imap_create_special_folder
2238 (folder, F_QUEUE, "Queue");
2239 if (!folder->outbox)
2240 folder->outbox = imap_create_special_folder
2241 (folder, F_OUTBOX, "Sent");
2243 folder->draft = imap_create_special_folder
2244 (folder, F_DRAFT, "Drafts");
2247 static FolderItem *imap_create_special_folder(Folder *folder,
2248 SpecialFolderItemType stype,
2252 FolderItem *new_item;
2254 g_return_val_if_fail(folder != NULL, NULL);
2255 g_return_val_if_fail(folder->node != NULL, NULL);
2256 g_return_val_if_fail(folder->node->data != NULL, NULL);
2257 g_return_val_if_fail(folder->account != NULL, NULL);
2258 g_return_val_if_fail(name != NULL, NULL);
2260 item = FOLDER_ITEM(folder->node->data);
2261 new_item = imap_create_folder(folder, item, name);
2264 g_warning("Can't create '%s'\n", name);
2265 if (!folder->inbox) return NULL;
2267 new_item = imap_create_folder(folder, folder->inbox, name);
2269 g_warning("Can't create '%s' under INBOX\n", name);
2271 new_item->stype = stype;
2273 new_item->stype = stype;
2278 static gchar *imap_folder_get_path(Folder *folder)
2282 g_return_val_if_fail(folder != NULL, NULL);
2283 g_return_val_if_fail(folder->account != NULL, NULL);
2285 folder_path = g_strconcat(get_imap_cache_dir(),
2287 folder->account->recv_server,
2289 folder->account->userid,
2295 static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
2297 gchar *folder_path, *path;
2299 g_return_val_if_fail(folder != NULL, NULL);
2300 g_return_val_if_fail(item != NULL, NULL);
2301 folder_path = imap_folder_get_path(folder);
2303 g_return_val_if_fail(folder_path != NULL, NULL);
2304 if (folder_path[0] == G_DIR_SEPARATOR) {
2306 path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
2309 path = g_strdup(folder_path);
2312 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2313 folder_path, G_DIR_SEPARATOR_S,
2316 path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
2319 g_free(folder_path);
2324 static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
2327 gchar *dirpath, *imap_path;
2328 IMAPSession *session;
2329 FolderItem *new_item;
2334 gboolean no_select = FALSE, no_sub = FALSE;
2335 gboolean exist = FALSE;
2337 g_return_val_if_fail(folder != NULL, NULL);
2338 g_return_val_if_fail(folder->account != NULL, NULL);
2339 g_return_val_if_fail(parent != NULL, NULL);
2340 g_return_val_if_fail(name != NULL, NULL);
2342 debug_print("getting session...\n");
2343 session = imap_session_get(folder);
2348 if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
2349 dirpath = g_strdup(name);
2350 }else if (parent->path)
2351 dirpath = g_strconcat(parent->path, "/", name, NULL);
2352 else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
2353 dirpath = g_strdup(name);
2354 else if (folder->account->imap_dir && *folder->account->imap_dir) {
2357 Xstrdup_a(imap_dir, folder->account->imap_dir, {return NULL;});
2358 strtailchomp(imap_dir, '/');
2359 dirpath = g_strconcat(imap_dir, "/", name, NULL);
2361 dirpath = g_strdup(name);
2365 /* keep trailing directory separator to create a folder that contains
2367 imap_path = imap_utf8_to_modified_utf7(dirpath);
2369 strtailchomp(dirpath, '/');
2370 Xstrdup_a(new_name, name, {
2374 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path);
2375 imap_path_separator_subst(imap_path, separator);
2376 /* remove trailing / for display */
2377 strtailchomp(new_name, '/');
2379 if (strcmp(dirpath, "INBOX") != 0) {
2384 argbuf = g_ptr_array_new();
2385 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2386 if (r != MAILIMAP_NO_ERROR) {
2387 imap_handle_error(SESSION(session), r);
2388 log_warning(LOG_PROTOCOL, _("can't create mailbox: LIST failed\n"));
2391 ptr_array_free_strings(argbuf);
2392 g_ptr_array_free(argbuf, TRUE);
2396 if (clist_count(lep_list) > 0)
2398 mailimap_list_result_free(lep_list);
2401 ok = imap_cmd_create(session, imap_path);
2402 if (ok != MAILIMAP_NO_ERROR) {
2403 log_warning(LOG_PROTOCOL, _("can't create mailbox\n"));
2408 r = imap_threaded_list(folder, "", imap_path, &lep_list);
2409 if (r == MAILIMAP_NO_ERROR) {
2410 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2411 lep_list, dirpath, TRUE);
2413 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2414 no_select = cur_item->no_select;
2415 no_sub = cur_item->no_sub;
2416 g_slist_free(item_list);
2418 mailimap_list_result_free(lep_list);
2420 imap_handle_error(SESSION(session), r);
2423 imap_threaded_subscribe(folder, imap_path, TRUE);
2427 /* just get flags */
2428 r = imap_threaded_list(folder, "", "INBOX", &lep_list);
2429 if (r == MAILIMAP_NO_ERROR) {
2430 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2431 lep_list, dirpath, TRUE);
2433 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
2434 no_select = cur_item->no_select;
2435 no_sub = cur_item->no_sub;
2436 g_slist_free(item_list);
2438 mailimap_list_result_free(lep_list);
2440 imap_handle_error(SESSION(session), r);
2444 new_item = folder_item_new(folder, new_name, dirpath);
2445 new_item->no_select = no_select;
2446 new_item->no_sub = no_sub;
2447 folder_item_append(parent, new_item);
2451 dirpath = folder_item_get_path(new_item);
2452 if (!is_dir_exist(dirpath))
2453 make_dir_hier(dirpath);
2457 /* folder existed, scan it */
2458 imap_scan_required(folder, new_item);
2459 folder_item_scan_full(new_item, FALSE);
2465 static gint imap_rename_folder(Folder *folder, FolderItem *item,
2470 gchar *real_oldpath;
2471 gchar *real_newpath;
2473 gchar *old_cache_dir;
2474 gchar *new_cache_dir;
2475 IMAPSession *session;
2478 gint exists, recent, unseen;
2479 guint32 uid_validity;
2481 g_return_val_if_fail(folder != NULL, -1);
2482 g_return_val_if_fail(item != NULL, -1);
2483 g_return_val_if_fail(item->path != NULL, -1);
2484 g_return_val_if_fail(name != NULL, -1);
2486 debug_print("getting session...\n");
2487 session = imap_session_get(folder);
2492 if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path)) != NULL) {
2493 g_warning(_("New folder name must not contain the namespace "
2498 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2500 g_free(session->mbox);
2501 session->mbox = NULL;
2502 session->exists = 0;
2503 session->recent = 0;
2504 session->expunge = 0;
2505 ok = imap_cmd_examine(session, "INBOX",
2506 &exists, &recent, &unseen, &uid_validity, FALSE);
2507 if (ok != MAILIMAP_NO_ERROR) {
2508 g_free(real_oldpath);
2512 separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
2513 if (strchr(item->path, G_DIR_SEPARATOR)) {
2514 dirpath = g_path_get_dirname(item->path);
2515 newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
2518 newpath = g_strdup(name);
2520 real_newpath = imap_utf8_to_modified_utf7(newpath);
2521 imap_path_separator_subst(real_newpath, separator);
2523 ok = imap_cmd_rename(session, real_oldpath, real_newpath);
2524 if (ok != MAILIMAP_NO_ERROR) {
2525 log_warning(LOG_PROTOCOL, _("can't rename mailbox: %s to %s\n"),
2526 real_oldpath, real_newpath);
2527 g_free(real_oldpath);
2529 g_free(real_newpath);
2533 item->name = g_strdup(name);
2535 old_cache_dir = folder_item_get_path(item);
2537 paths[0] = g_strdup(item->path);
2539 g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
2540 imap_rename_folder_func, paths);
2542 if (is_dir_exist(old_cache_dir)) {
2543 new_cache_dir = folder_item_get_path(item);
2544 if (rename(old_cache_dir, new_cache_dir) < 0) {
2545 FILE_OP_ERROR(old_cache_dir, "rename");
2547 g_free(new_cache_dir);
2550 g_free(old_cache_dir);
2553 g_free(real_oldpath);
2554 g_free(real_newpath);
2558 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
2562 IMAPSession *session;
2563 debug_print("getting session...\n");
2565 session = imap_session_get(folder);
2569 if (item && item->path) {
2570 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2573 if (!strcmp(path, "INBOX") && sub == FALSE)
2575 debug_print("%ssubscribing %s\n", sub?"":"un", path);
2576 r = imap_threaded_subscribe(folder, path, sub);
2579 r = imap_threaded_subscribe(folder, rpath, sub);
2585 static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
2588 IMAPSession *session;
2591 gboolean selected_folder;
2593 g_return_val_if_fail(folder != NULL, -1);
2594 g_return_val_if_fail(item != NULL, -1);
2595 g_return_val_if_fail(item->path != NULL, -1);
2597 debug_print("getting session...\n");
2598 session = imap_session_get(folder);
2602 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2604 imap_threaded_subscribe(folder, path, FALSE);
2606 selected_folder = (session->mbox != NULL) &&
2607 (!strcmp(session->mbox, item->path));
2608 if (selected_folder) {
2609 ok = imap_cmd_close(session);
2610 if (ok != MAILIMAP_NO_ERROR) {
2611 debug_print("close err %d\n", ok);
2612 imap_handle_error(SESSION(session), ok);
2616 ok = imap_cmd_delete(session, path);
2617 if (ok != MAILIMAP_NO_ERROR) {
2618 gchar *tmp = g_strdup_printf("%s%c", path,
2619 imap_get_path_separator(session, IMAP_FOLDER(folder), path));
2622 ok = imap_cmd_delete(session, path);
2625 if (ok != MAILIMAP_NO_ERROR) {
2626 log_warning(LOG_PROTOCOL, _("can't delete mailbox\n"));
2632 cache_dir = folder_item_get_path(item);
2633 if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
2634 g_warning("can't remove directory '%s'\n", cache_dir);
2636 folder_item_remove(item);
2640 static gint imap_remove_folder(Folder *folder, FolderItem *item)
2644 g_return_val_if_fail(item != NULL, -1);
2645 g_return_val_if_fail(item->folder != NULL, -1);
2646 g_return_val_if_fail(item->node != NULL, -1);
2648 node = item->node->children;
2649 while (node != NULL) {
2651 if (imap_remove_folder(folder, FOLDER_ITEM(node->data)) < 0)
2655 debug_print("IMAP removing %s\n", item->path);
2657 if (imap_remove_all_msg(folder, item) < 0)
2659 return imap_remove_folder_real(folder, item);
2662 typedef struct _uncached_data {
2663 IMAPSession *session;
2665 MsgNumberList *numlist;
2672 static void *imap_get_uncached_messages_thread(void *data)
2674 uncached_data *stuff = (uncached_data *)data;
2675 IMAPSession *session = stuff->session;
2676 FolderItem *item = stuff->item;
2677 MsgNumberList *numlist = stuff->numlist;
2679 GSList *newlist = NULL;
2680 GSList *llast = NULL;
2681 GSList *seq_list, *cur;
2683 debug_print("uncached_messages\n");
2685 if (session == NULL || item == NULL || item->folder == NULL
2686 || FOLDER_CLASS(item->folder) != &imap_class) {
2691 seq_list = imap_get_lep_set_from_numlist(IMAP_FOLDER(item->folder), numlist);
2692 debug_print("get msgs info\n");
2693 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2694 struct mailimap_set * imapset;
2700 if (session->cancelled)
2703 imapset = cur->data;
2705 r = imap_threaded_fetch_env(session->folder,
2706 imapset, &env_list);
2707 if (r != MAILIMAP_NO_ERROR) {
2708 imap_handle_error(SESSION(session), r);
2716 session_set_access_time(SESSION(session));
2719 for(i = 0 ; i < carray_count(env_list) ; i ++) {
2720 struct imap_fetch_env_info * info;
2723 info = carray_get(env_list, i);
2724 msginfo = imap_envelope_from_lep(info, item);
2725 if (msginfo == NULL)
2727 msginfo->folder = item;
2729 llast = newlist = g_slist_append(newlist, msginfo);
2731 llast = g_slist_append(llast, msginfo);
2732 llast = llast->next;
2737 imap_fetch_env_free(env_list);
2740 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2741 struct mailimap_set * imapset;
2743 imapset = cur->data;
2744 mailimap_set_free(imapset);
2747 session_set_access_time(SESSION(session));
2752 #define MAX_MSG_NUM 50
2754 static GSList *imap_get_uncached_messages(IMAPSession *session,
2756 MsgNumberList *numlist,
2759 GSList *result = NULL;
2761 uncached_data *data = g_new0(uncached_data, 1);
2766 data->total = g_slist_length(numlist);
2767 data->ok = MAILIMAP_NO_ERROR;
2768 debug_print("messages list : %i\n", data->total);
2770 while (cur != NULL) {
2771 GSList * partial_result;
2779 while (count < MAX_MSG_NUM) {
2784 if (newlist == NULL)
2785 llast = newlist = g_slist_append(newlist, p);
2787 llast = g_slist_append(llast, p);
2788 llast = llast->next;
2798 data->session = session;
2800 data->numlist = newlist;
2803 if (prefs_common.work_offline &&
2804 !inc_offline_should_override(FALSE,
2805 _("Claws Mail needs network access in order "
2806 "to access the IMAP server."))) {
2812 (GSList *)imap_get_uncached_messages_thread(data);
2814 if (data->ok != MAILIMAP_NO_ERROR) {
2817 statusbar_progress_all(data->cur,data->total, 1);
2819 g_slist_free(newlist);
2821 result = g_slist_concat(result, partial_result);
2826 statusbar_progress_all(0,0,0);
2827 statusbar_pop_all();
2832 static void imap_delete_all_cached_messages(FolderItem *item)
2836 g_return_if_fail(item != NULL);
2837 g_return_if_fail(item->folder != NULL);
2838 g_return_if_fail(FOLDER_CLASS(item->folder) == &imap_class);
2840 debug_print("Deleting all cached messages...\n");
2842 dir = folder_item_get_path(item);
2843 if (is_dir_exist(dir))
2844 remove_all_numbered_files(dir);
2847 debug_print("done.\n");
2850 gchar imap_get_path_separator_for_item(FolderItem *item)
2852 Folder *folder = NULL;
2853 IMAPFolder *imap_folder = NULL;
2854 IMAPSession *session = NULL;
2859 folder = item->folder;
2864 imap_folder = IMAP_FOLDER(folder);
2869 debug_print("getting session...");
2870 session = imap_session_get(FOLDER(folder));
2871 result = imap_get_path_separator(session, imap_folder, item->path);
2875 static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder)
2879 gchar separator = '\0';
2881 g_return_val_if_fail(session != NULL, '/');
2882 r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
2884 if (r != MAILIMAP_NO_ERROR) {
2885 imap_handle_error(SESSION(session), r);
2886 log_warning(LOG_PROTOCOL, _("LIST failed\n"));
2890 if (clist_count(lep_list) > 0) {
2891 clistiter * iter = clist_begin(lep_list);
2892 struct mailimap_mailbox_list * mb;
2893 mb = clist_content(iter);
2895 separator = mb->mb_delimiter;
2896 debug_print("got separator: %c\n", folder->last_seen_separator);
2898 mailimap_list_result_free(lep_list);
2902 static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2904 gchar separator = '/';
2906 if (folder->last_seen_separator == 0) {
2907 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "");
2910 if (folder->last_seen_separator == 0) {
2911 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX");
2914 if (folder->last_seen_separator != 0) {
2915 debug_print("using separator: %c\n", folder->last_seen_separator);
2916 return folder->last_seen_separator;
2922 static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2927 g_return_val_if_fail(folder != NULL, NULL);
2928 g_return_val_if_fail(path != NULL, NULL);
2930 real_path = imap_utf8_to_modified_utf7(path);
2931 separator = imap_get_path_separator(session, folder, path);
2932 imap_path_separator_subst(real_path, separator);
2937 static gint imap_set_message_flags(IMAPSession *session,
2938 MsgNumberList *numlist,
2946 IMAPFolder *folder = NULL;
2947 GSList *sorted_list = NULL;
2949 if (numlist == NULL || session == NULL)
2950 return MAILIMAP_ERROR_BAD_STATE;
2952 folder = IMAP_FOLDER(session->folder);
2954 sorted_list = g_slist_copy(numlist);
2955 sorted_list = g_slist_sort(sorted_list, g_int_compare);
2957 cur = g_slist_last(sorted_list);
2960 total = GPOINTER_TO_INT(cur->data);
2962 seq_list = imap_get_lep_set_from_numlist(IMAP_FOLDER(session->folder), sorted_list);
2964 statusbar_print_all(_("Flagging messages..."));
2966 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
2967 struct mailimap_set * imapset = (struct mailimap_set *)cur->data;
2968 struct mailimap_set_item *set_item = clist_content(
2969 clist_begin(imapset->set_list));
2971 statusbar_progress_all(set_item->set_first, total, 1);
2973 ok = imap_cmd_store(session, imapset,
2975 statusbar_progress_all(set_item->set_last, total, 1);
2976 if (ok != MAILIMAP_NO_ERROR && folder->max_set_size > 20) {
2977 /* reduce max set size */
2978 folder->max_set_size /= 2;
2980 if (ok != MAILIMAP_NO_ERROR && is_fatal(ok)) {
2985 g_slist_free(sorted_list);
2987 statusbar_progress_all(0,0,0);
2988 statusbar_pop_all();
2990 imap_lep_set_free(seq_list);
2995 typedef struct _select_data {
2996 IMAPSession *session;
3001 guint32 *uid_validity;
3005 static gint imap_select(IMAPSession *session, IMAPFolder *folder,
3007 gint *exists, gint *recent, gint *unseen,
3008 guint32 *uid_validity, gboolean block)
3012 gint exists_, recent_, unseen_;
3013 guint32 uid_validity_;
3015 if (!exists && !recent && !unseen && !uid_validity) {
3016 if (session->mbox && strcmp(session->mbox, path) == 0)
3017 return MAILIMAP_NO_ERROR;
3026 uid_validity = &uid_validity_;
3028 g_free(session->mbox);
3029 session->mbox = NULL;
3030 session->exists = 0;
3031 session->recent = 0;
3032 session->expunge = 0;
3034 real_path = imap_get_real_path(session, folder, path);
3036 ok = imap_cmd_select(session, real_path,
3037 exists, recent, unseen, uid_validity, block);
3038 if (ok != MAILIMAP_NO_ERROR) {
3039 log_warning(LOG_PROTOCOL, _("can't select folder: %s\n"), real_path);
3041 session->mbox = g_strdup(path);
3042 session->folder_content_changed = FALSE;
3043 session->exists = *exists;
3044 session->recent = *recent;
3045 session->expunge = 0;
3046 session->unseen = *unseen;
3047 session->uid_validity = *uid_validity;
3048 debug_print("select: exists %d recent %d expunge %d uid_validity %d\n",
3049 session->exists, session->recent, session->expunge,
3050 session->uid_validity);
3057 static gint imap_status(IMAPSession *session, IMAPFolder *folder,
3058 const gchar *path, IMAPFolderItem *item,
3060 guint32 *uid_next, guint32 *uid_validity,
3061 gint *unseen, gboolean block)
3065 struct mailimap_mailbox_data_status * data_status;
3070 real_path = imap_get_real_path(session, folder, path);
3089 if (session->mbox != NULL &&
3090 !strcmp(session->mbox, item->item.path)) {
3091 r = imap_cmd_close(session);
3092 if (r != MAILIMAP_NO_ERROR) {
3093 imap_handle_error(SESSION(session), r);
3094 debug_print("close err %d\n", r);
3099 r = imap_threaded_status(FOLDER(folder), real_path,
3100 &data_status, mask);
3103 if (r != MAILIMAP_NO_ERROR) {
3104 imap_handle_error(SESSION(session), r);
3105 debug_print("status err %d\n", r);
3109 if (data_status->st_info_list == NULL) {
3110 mailimap_mailbox_data_status_free(data_status);
3111 debug_print("status->st_info_list == NULL\n");
3112 return MAILIMAP_ERROR_BAD_STATE;
3116 for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
3117 iter = clist_next(iter)) {
3118 struct mailimap_status_info * info;
3120 info = clist_content(iter);
3121 switch (info->st_att) {
3122 case MAILIMAP_STATUS_ATT_MESSAGES:
3124 * messages = info->st_value;
3125 got_values |= 1 << 0;
3129 case MAILIMAP_STATUS_ATT_UIDNEXT:
3131 * uid_next = info->st_value;
3132 got_values |= 1 << 2;
3136 case MAILIMAP_STATUS_ATT_UIDVALIDITY:
3138 * uid_validity = info->st_value;
3139 got_values |= 1 << 3;
3143 case MAILIMAP_STATUS_ATT_UNSEEN:
3145 * unseen = info->st_value;
3146 got_values |= 1 << 4;
3151 mailimap_mailbox_data_status_free(data_status);
3153 if (got_values != mask) {
3154 g_warning("status: incomplete values received (%d)\n", got_values);
3156 return MAILIMAP_NO_ERROR;
3159 static void imap_free_capabilities(IMAPSession *session)
3161 slist_free_strings(session->capability);
3162 g_slist_free(session->capability);
3163 session->capability = NULL;
3166 /* low-level IMAP4rev1 commands */
3168 static gint imap_cmd_login(IMAPSession *session,
3169 const gchar *user, const gchar *pass,
3175 if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
3176 gint ok = MAILIMAP_ERROR_BAD_STATE;
3177 if (imap_has_capability(session, "STARTTLS")) {
3178 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
3179 log_warning(LOG_PROTOCOL, _("Server requires TLS to log in.\n"));
3180 ok = imap_cmd_starttls(session);
3181 if (ok != MAILIMAP_NO_ERROR) {
3182 log_warning(LOG_PROTOCOL, _("Can't start TLS session.\n"));
3186 imap_free_capabilities(session);
3187 if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
3188 imap_handle_error(SESSION(session), r);
3189 log_warning(LOG_PROTOCOL, _("Can't refresh capabilities.\n"));
3194 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
3195 "server requires TLS, but Claws Mail "
3196 "has been compiled without OpenSSL "
3198 SESSION(session)->server);
3199 return MAILIMAP_ERROR_BAD_STATE;
3202 log_error(LOG_PROTOCOL, _("Server logins are disabled.\n"));
3203 return MAILIMAP_ERROR_BAD_STATE;
3207 log_print(LOG_PROTOCOL, "IMAP4> Logging %s to %s using %s\n",
3209 SESSION(session)->server,
3211 r = imap_threaded_login(session->folder, user, pass, type);
3212 if (r != MAILIMAP_NO_ERROR) {
3213 imap_handle_error(SESSION(session), r);
3214 log_print(LOG_PROTOCOL, "IMAP4< Error logging in to %s\n",
3215 SESSION(session)->server);
3218 log_print(LOG_PROTOCOL, "IMAP4< Login to %s successful\n",
3219 SESSION(session)->server);
3220 ok = MAILIMAP_NO_ERROR;
3225 static gint imap_cmd_noop(IMAPSession *session)
3228 unsigned int exists, recent, expunge, unseen, uidnext, uidval;
3230 r = imap_threaded_noop(session->folder, &exists, &recent, &expunge, &unseen, &uidnext, &uidval);
3231 if (r != MAILIMAP_NO_ERROR) {
3232 imap_handle_error(SESSION(session), r);
3233 debug_print("noop err %d\n", r);
3237 session->folder_content_changed = FALSE;
3239 if ((exists && exists != session->exists)
3240 || (recent && recent != session->recent)
3241 || (expunge && expunge != session->expunge)
3242 || (unseen && unseen != session->unseen)) {
3243 session->folder_content_changed = TRUE;
3245 if (uidnext != 0 && uidnext != session->uid_next) {
3246 session->uid_next = uidnext;
3247 session->folder_content_changed = TRUE;
3249 if (uidval != 0 && uidval != session->uid_validity) {
3250 session->uid_validity = uidval;
3251 session->folder_content_changed = TRUE;
3254 session->exists = exists;
3255 session->recent = recent;
3256 session->expunge = expunge;
3257 session->unseen = unseen;
3259 session_set_access_time(SESSION(session));
3261 return MAILIMAP_NO_ERROR;
3264 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
3265 static gint imap_cmd_starttls(IMAPSession *session)
3269 r = imap_threaded_starttls(session->folder,
3270 SESSION(session)->server, SESSION(session)->port);
3271 if (r != MAILIMAP_NO_ERROR) {
3272 imap_handle_error(SESSION(session), r);
3273 debug_print("starttls err %d\n", r);
3276 return MAILIMAP_NO_ERROR;
3280 static gint imap_cmd_select(IMAPSession *session, const gchar *folder,
3281 gint *exists, gint *recent, gint *unseen,
3282 guint32 *uid_validity, gboolean block)
3286 r = imap_threaded_select(session->folder, folder,
3287 exists, recent, unseen, uid_validity);
3288 if (r != MAILIMAP_NO_ERROR) {
3289 imap_handle_error(SESSION(session), r);
3290 debug_print("select err %d\n", r);
3293 return MAILIMAP_NO_ERROR;
3296 static gint imap_cmd_close(IMAPSession *session)
3300 r = imap_threaded_close(session->folder);
3301 if (r != MAILIMAP_NO_ERROR) {
3302 imap_handle_error(SESSION(session), r);
3303 debug_print("close err %d\n", r);
3306 g_free(session->mbox);
3307 session->mbox = NULL;
3308 session->exists = 0;
3309 session->recent = 0;
3310 session->expunge = 0;
3311 return MAILIMAP_NO_ERROR;
3314 static gint imap_cmd_examine(IMAPSession *session, const gchar *folder,
3315 gint *exists, gint *recent, gint *unseen,
3316 guint32 *uid_validity, gboolean block)
3320 r = imap_threaded_examine(session->folder, folder,
3321 exists, recent, unseen, uid_validity);
3322 if (r != MAILIMAP_NO_ERROR) {
3323 imap_handle_error(SESSION(session), r);
3324 debug_print("examine err %d\n", r);
3328 return MAILIMAP_NO_ERROR;
3331 static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
3335 r = imap_threaded_create(session->folder, folder);
3336 if (r != MAILIMAP_NO_ERROR) {
3337 imap_handle_error(SESSION(session), r);
3342 return MAILIMAP_NO_ERROR;
3345 static gint imap_cmd_rename(IMAPSession *session, const gchar *old_folder,
3346 const gchar *new_folder)
3350 r = imap_threaded_rename(session->folder, old_folder,
3352 if (r != MAILIMAP_NO_ERROR) {
3353 imap_handle_error(SESSION(session), r);
3357 return MAILIMAP_NO_ERROR;
3360 static gint imap_cmd_delete(IMAPSession *session, const gchar *folder)
3365 r = imap_threaded_delete(session->folder, folder);
3366 if (r != MAILIMAP_NO_ERROR) {
3367 imap_handle_error(SESSION(session), r);
3371 return MAILIMAP_NO_ERROR;
3374 typedef struct _fetch_data {
3375 IMAPSession *session;
3377 const gchar *filename;
3383 static void *imap_cmd_fetch_thread(void *data)
3385 fetch_data *stuff = (fetch_data *)data;
3386 IMAPSession *session = stuff->session;
3387 guint32 uid = stuff->uid;
3388 const gchar *filename = stuff->filename;
3392 r = imap_threaded_fetch_content(session->folder,
3396 r = imap_threaded_fetch_content(session->folder,
3399 if (r != MAILIMAP_NO_ERROR) {
3400 imap_handle_error(SESSION(session), r);
3401 debug_print("fetch err %d\n", r);
3402 return GINT_TO_POINTER(MAILIMAP_ERROR_BAD_STATE);
3404 return GINT_TO_POINTER(MAILIMAP_NO_ERROR);
3407 static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
3408 const gchar *filename, gboolean headers,
3411 fetch_data *data = g_new0(fetch_data, 1);
3414 data->session = session;
3416 data->filename = filename;
3417 data->headers = headers;
3420 if (prefs_common.work_offline &&
3421 !inc_offline_should_override(FALSE,
3422 _("Claws Mail needs network access in order "
3423 "to access the IMAP server."))) {
3427 statusbar_print_all(_("Fetching message..."));
3428 result = GPOINTER_TO_INT(imap_cmd_fetch_thread(data));
3429 statusbar_pop_all();
3435 static gint imap_cmd_append(IMAPSession *session, const gchar *destfolder,
3436 const gchar *file, IMAPFlags flags,
3439 struct mailimap_flag_list * flag_list;
3442 g_return_val_if_fail(file != NULL, MAILIMAP_ERROR_BAD_STATE);
3444 flag_list = imap_flag_to_lep(flags);
3445 lock_session(session);
3446 r = imap_threaded_append(session->folder, destfolder,
3447 file, flag_list, (int *)new_uid);
3448 mailimap_flag_list_free(flag_list);
3450 if (r != MAILIMAP_NO_ERROR) {
3451 imap_handle_error(SESSION(session), r);
3452 debug_print("append err %d\n", r);
3456 unlock_session(session);
3458 return MAILIMAP_NO_ERROR;
3461 static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
3462 const gchar *destfolder, GRelation *uid_mapping,
3463 struct mailimap_set **source, struct mailimap_set **dest)
3467 g_return_val_if_fail(session != NULL, MAILIMAP_ERROR_BAD_STATE);
3468 g_return_val_if_fail(set != NULL, MAILIMAP_ERROR_BAD_STATE);
3469 g_return_val_if_fail(destfolder != NULL, MAILIMAP_ERROR_BAD_STATE);
3471 r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
3472 if (r != MAILIMAP_NO_ERROR) {
3473 imap_handle_error(SESSION(session), r);
3477 return MAILIMAP_NO_ERROR;
3480 static gint imap_cmd_store(IMAPSession *session, struct mailimap_set * set,
3481 IMAPFlags flags, int do_add)
3484 struct mailimap_flag_list * flag_list;
3485 struct mailimap_store_att_flags * store_att_flags;
3487 flag_list = imap_flag_to_lep(flags);
3491 mailimap_store_att_flags_new_add_flags_silent(flag_list);
3494 mailimap_store_att_flags_new_remove_flags_silent(flag_list);
3496 r = imap_threaded_store(session->folder, set, store_att_flags);
3497 mailimap_store_att_flags_free(store_att_flags);
3498 if (r != MAILIMAP_NO_ERROR) {
3499 imap_handle_error(SESSION(session), r);
3503 return MAILIMAP_NO_ERROR;
3506 static gint imap_cmd_expunge(IMAPSession *session)
3510 if (prefs_common.work_offline &&
3511 !inc_offline_should_override(FALSE,
3512 _("Claws Mail needs network access in order "
3513 "to access the IMAP server."))) {
3517 r = imap_threaded_expunge(session->folder);
3518 if (r != MAILIMAP_NO_ERROR) {
3519 imap_handle_error(SESSION(session), r);
3523 return MAILIMAP_NO_ERROR;
3526 static void imap_path_separator_subst(gchar *str, gchar separator)
3529 gboolean in_escape = FALSE;
3531 if (!separator || separator == '/') return;
3533 for (p = str; *p != '\0'; p++) {
3534 if (*p == '/' && !in_escape)
3536 else if (*p == '&' && *(p + 1) != '-' && !in_escape)
3538 else if (*p == '-' && in_escape)
3543 static gchar *imap_modified_utf7_to_utf8(const gchar *mutf7_str)
3545 static iconv_t cd = (iconv_t)-1;
3546 static gboolean iconv_ok = TRUE;
3549 size_t norm_utf7_len;
3551 gchar *to_str, *to_p;
3553 gboolean in_escape = FALSE;
3555 if (!iconv_ok) return g_strdup(mutf7_str);
3557 if (cd == (iconv_t)-1) {
3558 cd = iconv_open(CS_INTERNAL, CS_UTF_7);
3559 if (cd == (iconv_t)-1) {
3560 g_warning("iconv cannot convert UTF-7 to %s\n",
3563 return g_strdup(mutf7_str);
3567 /* modified UTF-7 to normal UTF-7 conversion */
3568 norm_utf7 = g_string_new(NULL);
3570 for (p = mutf7_str; *p != '\0'; p++) {
3571 /* replace: '&' -> '+',
3573 escaped ',' -> '/' */
3574 if (!in_escape && *p == '&') {
3575 if (*(p + 1) != '-') {
3576 g_string_append_c(norm_utf7, '+');
3579 g_string_append_c(norm_utf7, '&');
3582 } else if (in_escape && *p == ',') {
3583 g_string_append_c(norm_utf7, '/');
3584 } else if (in_escape && *p == '-') {
3585 g_string_append_c(norm_utf7, '-');
3588 g_string_append_c(norm_utf7, *p);
3592 norm_utf7_p = norm_utf7->str;
3593 norm_utf7_len = norm_utf7->len;
3594 to_len = strlen(mutf7_str) * 5;
3595 to_p = to_str = g_malloc(to_len + 1);
3597 if (iconv(cd, (ICONV_CONST gchar **)&norm_utf7_p, &norm_utf7_len,
3598 &to_p, &to_len) == -1) {
3599 g_warning(_("iconv cannot convert UTF-7 to %s\n"),
3600 conv_get_locale_charset_str());
3601 g_string_free(norm_utf7, TRUE);
3603 return g_strdup(mutf7_str);
3606 /* second iconv() call for flushing */
3607 iconv(cd, NULL, NULL, &to_p, &to_len);
3608 g_string_free(norm_utf7, TRUE);
3614 static gchar *imap_utf8_to_modified_utf7(const gchar *from)
3616 static iconv_t cd = (iconv_t)-1;
3617 static gboolean iconv_ok = TRUE;
3618 gchar *norm_utf7, *norm_utf7_p;
3619 size_t from_len, norm_utf7_len;
3621 gchar *from_tmp, *to, *p;
3622 gboolean in_escape = FALSE;
3624 if (!iconv_ok) return g_strdup(from);
3626 if (cd == (iconv_t)-1) {
3627 cd = iconv_open(CS_UTF_7, CS_INTERNAL);
3628 if (cd == (iconv_t)-1) {
3629 g_warning(_("iconv cannot convert %s to UTF-7\n"),
3632 return g_strdup(from);
3636 /* UTF-8 to normal UTF-7 conversion */
3637 Xstrdup_a(from_tmp, from, return g_strdup(from));
3638 from_len = strlen(from);
3639 norm_utf7_len = from_len * 5;
3640 Xalloca(norm_utf7, norm_utf7_len + 1, return g_strdup(from));
3641 norm_utf7_p = norm_utf7;
3643 #define IS_PRINT(ch) (isprint(ch) && IS_ASCII(ch))
3645 while (from_len > 0) {
3646 if (*from_tmp == '+') {
3647 *norm_utf7_p++ = '+';
3648 *norm_utf7_p++ = '-';
3652 } else if (IS_PRINT(*(guchar *)from_tmp)) {
3653 /* printable ascii char */
3654 *norm_utf7_p = *from_tmp;
3660 size_t conv_len = 0;
3662 /* unprintable char: convert to UTF-7 */
3664 while (!IS_PRINT(*(guchar *)p) && conv_len < from_len) {
3665 conv_len += g_utf8_skip[*(guchar *)p];
3666 p += g_utf8_skip[*(guchar *)p];
3669 from_len -= conv_len;
3670 if (iconv(cd, (ICONV_CONST gchar **)&from_tmp,
3672 &norm_utf7_p, &norm_utf7_len) == -1) {
3673 g_warning(_("iconv cannot convert UTF-8 to UTF-7\n"));
3674 return g_strdup(from);
3677 /* second iconv() call for flushing */
3678 iconv(cd, NULL, NULL, &norm_utf7_p, &norm_utf7_len);
3684 *norm_utf7_p = '\0';
3685 to_str = g_string_new(NULL);
3686 for (p = norm_utf7; p < norm_utf7_p; p++) {
3687 /* replace: '&' -> "&-",
3690 BASE64 '/' -> ',' */
3691 if (!in_escape && *p == '&') {
3692 g_string_append(to_str, "&-");
3693 } else if (!in_escape && *p == '+') {
3694 if (*(p + 1) == '-') {
3695 g_string_append_c(to_str, '+');
3698 g_string_append_c(to_str, '&');
3701 } else if (in_escape && *p == '/') {
3702 g_string_append_c(to_str, ',');
3703 } else if (in_escape && *p == '-') {
3704 g_string_append_c(to_str, '-');
3707 g_string_append_c(to_str, *p);
3713 g_string_append_c(to_str, '-');
3717 g_string_free(to_str, FALSE);
3722 static gboolean imap_rename_folder_func(GNode *node, gpointer data)
3724 FolderItem *item = node->data;
3725 gchar **paths = data;
3726 const gchar *oldpath = paths[0];
3727 const gchar *newpath = paths[1];
3728 gchar *real_oldpath, *real_newpath;
3730 gchar *new_itempath;
3732 IMAPSession *session = imap_session_get(item->folder);
3734 oldpathlen = strlen(oldpath);
3735 if (strncmp(oldpath, item->path, oldpathlen) != 0) {
3736 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
3740 base = item->path + oldpathlen;
3741 while (*base == G_DIR_SEPARATOR) base++;
3743 new_itempath = g_strdup(newpath);
3745 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
3748 real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3750 item->path = new_itempath;
3752 real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path);
3754 imap_threaded_subscribe(item->folder, real_oldpath, FALSE);
3755 imap_threaded_subscribe(item->folder, real_newpath, TRUE);
3757 g_free(real_oldpath);
3758 g_free(real_newpath);
3762 static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
3764 GSList *uidlist, *elem;
3766 clist * lep_uidlist;
3767 gint ok, nummsgs = 0, lastuid_old;
3769 if (session == NULL) {
3773 ok = imap_select(session, IMAP_FOLDER(folder), item->item.path,
3774 NULL, NULL, NULL, NULL, TRUE);
3775 if (ok != MAILIMAP_NO_ERROR) {
3779 g_slist_free(item->uid_list);
3780 item->uid_list = NULL;
3784 if (folder->account && folder->account->low_bandwidth) {
3785 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, NULL,
3789 if (r == MAILIMAP_NO_ERROR) {
3790 GSList * fetchuid_list =
3791 imap_uid_list_from_lep(lep_uidlist);
3792 mailimap_search_result_free(lep_uidlist);
3794 uidlist = g_slist_concat(fetchuid_list, uidlist);
3796 carray * lep_uidtab;
3797 if (r != -1) /* inited */
3798 imap_handle_error(SESSION(session), r);
3799 r = imap_threaded_fetch_uid(folder, 1,
3801 if (r == MAILIMAP_NO_ERROR) {
3802 GSList * fetchuid_list =
3803 imap_uid_list_from_lep_tab(lep_uidtab);
3804 imap_fetch_uid_list_free(lep_uidtab);
3805 uidlist = g_slist_concat(fetchuid_list, uidlist);
3809 if (r != MAILIMAP_NO_ERROR) {
3810 imap_handle_error(SESSION(session), r);
3814 lastuid_old = item->lastuid;
3816 for (elem = uidlist; elem != NULL; elem = g_slist_next(elem)) {
3819 msgnum = GPOINTER_TO_INT(elem->data);
3821 *msgnum_list = g_slist_prepend(*msgnum_list, GINT_TO_POINTER(msgnum));
3822 item->uid_list = g_slist_prepend(item->uid_list, GINT_TO_POINTER(msgnum));
3825 g_slist_free(uidlist);
3827 unlock_session(session); /* locked from imap_get_num_list */
3833 gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
3835 IMAPFolderItem *item = (IMAPFolderItem *)_item;
3836 IMAPSession *session;
3838 GSList *uidlist = NULL;
3840 gboolean selected_folder;
3841 gint known_list_len = 0;
3842 debug_print("get_num_list\n");
3844 g_return_val_if_fail(folder != NULL, -1);
3845 g_return_val_if_fail(item != NULL, -1);
3846 g_return_val_if_fail(item->item.path != NULL, -1);
3847 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
3848 g_return_val_if_fail(folder->account != NULL, -1);
3850 known_list_len = g_slist_length(item->uid_list);
3851 if (!item->should_update) {
3852 debug_print("get_num_list: nothing to update\n");
3853 *old_uids_valid = TRUE;
3854 if (known_list_len == item->item.total_msgs
3855 && known_list_len > 0) {
3856 *msgnum_list = g_slist_copy(item->uid_list);
3857 return known_list_len;
3859 debug_print("don't know the list length...\n");
3863 if (prefs_common.work_offline &&
3864 !inc_offline_should_override(FALSE,
3865 _("Claws Mail needs network access in order "
3866 "to access the IMAP server."))) {
3870 debug_print("getting session...\n");
3871 session = imap_session_get(folder);
3872 g_return_val_if_fail(session != NULL, -1);
3874 lock_session(session); /* unlocked by get_list_of_uids */
3875 if (FOLDER_ITEM(item)->path)
3876 statusbar_print_all(_("Scanning folder %s%c%s ..."),
3877 FOLDER_ITEM(item)->folder->name,
3879 FOLDER_ITEM(item)->path);
3881 statusbar_print_all(_("Scanning folder %s ..."),
3882 FOLDER_ITEM(item)->folder->name);
3884 selected_folder = (session->mbox != NULL) &&
3885 (!strcmp(session->mbox, item->item.path));
3887 if (item->should_trash_cache) {
3888 *old_uids_valid = FALSE;
3889 debug_print("get_num_list: trashing num list\n");
3890 debug_print("Freeing imap uid cache\n");
3892 g_slist_free(item->uid_list);
3893 item->uid_list = NULL;
3895 imap_delete_all_cached_messages((FolderItem *)item);
3897 debug_print("get_num_list: updating num list\n");
3898 *old_uids_valid = TRUE;
3901 nummsgs = get_list_of_uids(session, folder, item, &uidlist);
3902 /* session could be broken now, in case of fatal error */
3904 debug_print("get_num_list: got %d msgs\n", nummsgs);
3907 statusbar_pop_all();
3911 *msgnum_list = uidlist;
3913 dir = folder_item_get_path((FolderItem *)item);
3914 debug_print("removing old messages from %s\n", dir);
3915 remove_numbered_files_not_in_list(dir, *msgnum_list);
3918 debug_print("get_num_list - ok - %i\n", nummsgs);
3919 statusbar_pop_all();
3920 item->should_trash_cache = FALSE;
3921 item->should_update = FALSE;
3925 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item)
3930 flags.perm_flags = MSG_NEW|MSG_UNREAD;
3931 flags.tmp_flags = 0;
3933 g_return_val_if_fail(item != NULL, NULL);
3934 g_return_val_if_fail(file != NULL, NULL);
3936 if (folder_has_parent_of_type(item, F_QUEUE)) {
3937 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
3938 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
3939 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
3942 msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
3943 if (!msginfo) return NULL;
3945 msginfo->plaintext_file = g_strdup(file);
3946 msginfo->folder = item;
3951 GSList *imap_get_msginfos(Folder *folder, FolderItem *item,
3952 GSList *msgnum_list)
3954 IMAPSession *session;
3955 MsgInfoList *ret = NULL;
3958 debug_print("get_msginfos\n");
3960 g_return_val_if_fail(folder != NULL, NULL);
3961 g_return_val_if_fail(item != NULL, NULL);
3962 g_return_val_if_fail(msgnum_list != NULL, NULL);
3964 debug_print("getting session...\n");
3965 session = imap_session_get(folder);
3966 g_return_val_if_fail(session != NULL, NULL);
3968 lock_session(session); /* unlocked later in the function */
3970 debug_print("IMAP getting msginfos\n");
3971 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
3972 NULL, NULL, NULL, NULL, FALSE);
3973 if (ok != MAILIMAP_NO_ERROR) {
3976 if (!(folder_has_parent_of_type(item, F_DRAFT) ||
3977 folder_has_parent_of_type(item, F_QUEUE))) {
3978 ret = g_slist_concat(ret,
3979 imap_get_uncached_messages(session, item,
3981 if (ok != MAILIMAP_NO_ERROR)
3983 unlock_session(session);
3985 MsgNumberList *sorted_list, *elem, *llast = NULL;
3986 gint startnum, lastnum;
3988 unlock_session(session);
3990 sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
3992 startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
3994 llast = g_slist_last(ret);
3995 for (elem = sorted_list;; elem = g_slist_next(elem)) {
3999 num = GPOINTER_TO_INT(elem->data);
4001 if (num > lastnum + 1 || elem == NULL) {
4003 for (i = startnum; i <= lastnum; ++i) {
4005 file = imap_fetch_msg(folder, item, i);
4007 MsgInfo *msginfo = imap_parse_msg(file, item);
4008 if (msginfo != NULL) {
4009 msginfo->msgnum = i;
4011 llast = ret = g_slist_append(ret, msginfo);
4013 llast = g_slist_append(llast, msginfo);
4014 llast = llast->next;
4029 g_slist_free(sorted_list);
4034 MsgInfo *imap_get_msginfo(Folder *folder, FolderItem *item, gint uid)
4036 MsgInfo *msginfo = NULL;
4037 MsgInfoList *msginfolist;
4038 MsgNumberList numlist;
4040 numlist.next = NULL;
4041 numlist.data = GINT_TO_POINTER(uid);
4043 msginfolist = imap_get_msginfos(folder, item, &numlist);
4044 if (msginfolist != NULL) {
4045 msginfo = msginfolist->data;
4046 g_slist_free(msginfolist);
4052 gboolean imap_scan_required(Folder *folder, FolderItem *_item)
4054 IMAPSession *session;
4055 IMAPFolderItem *item = (IMAPFolderItem *)_item;
4056 gint ok, exists = 0, unseen = 0;
4057 guint32 uid_next = 0, uid_val = 0;
4058 gboolean selected_folder;
4060 g_return_val_if_fail(folder != NULL, FALSE);
4061 g_return_val_if_fail(item != NULL, FALSE);
4062 g_return_val_if_fail(item->item.folder != NULL, FALSE);
4063 g_return_val_if_fail(FOLDER_CLASS(item->item.folder) == &imap_class, FALSE);
4065 if (item->item.path == NULL)
4068 if (item->should_update) {
4069 debug_print("scan already required\n");
4072 debug_print("getting session...\n");
4073 session = imap_session_get(folder);
4075 g_return_val_if_fail(session != NULL, FALSE);
4076 lock_session(session); /* unlocked later in the function */
4078 selected_folder = (session->mbox != NULL) &&
4079 (!strcmp(session->mbox, item->item.path));
4080 if (selected_folder) {
4081 if (!session->folder_content_changed) {
4082 ok = imap_cmd_noop(session);
4083 if (ok != MAILIMAP_NO_ERROR) {
4084 debug_print("disconnected!\n");
4086 session = imap_reconnect_if_possible(folder, session);
4088 session = imap_session_get(folder);
4089 if (session == NULL)
4093 if (session->folder_content_changed) {
4094 debug_print("CHANGED (self-noop)! scan_required\n");
4095 item->should_update = TRUE;
4096 if (session->uid_validity && session->uid_validity != item->item.mtime) {
4097 item->item.mtime = session->uid_validity;
4098 item->should_trash_cache = TRUE;
4100 unlock_session(session);
4104 debug_print("CHANGED (previous noop)! scan_required\n");
4105 item->should_update = TRUE;
4106 if (session->uid_validity && session->uid_validity != item->item.mtime) {
4107 item->item.mtime = session->uid_validity;
4108 item->should_trash_cache = TRUE;
4110 unlock_session(session);
4114 ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, IMAP_FOLDER_ITEM(item),
4115 &exists, &uid_next, &uid_val, &unseen, FALSE);
4116 if (ok != MAILIMAP_NO_ERROR) {
4120 debug_print("exists %d, item->item.total_msgs %d\n",
4121 exists, item->item.total_msgs);
4122 if (exists != item->item.total_msgs
4123 || unseen != item->item.unread_msgs
4124 || uid_next != item->uid_next
4125 || uid_val != item->item.mtime) {
4126 debug_print("CHANGED (status)! scan_required\n");
4127 item->last_change = time(NULL);
4128 item->should_update = TRUE;
4129 item->uid_next = uid_next;
4130 if (uid_val != item->item.mtime) {
4131 item->item.mtime = uid_val;
4132 item->should_trash_cache = TRUE;
4134 unlock_session(session);
4138 unlock_session(session);
4140 item->should_update = FALSE;
4144 void imap_change_flags(Folder *folder, FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
4146 IMAPSession *session;
4147 IMAPFlags flags_set = 0, flags_unset = 0;
4148 gint ok = MAILIMAP_NO_ERROR;
4149 MsgNumberList numlist;
4150 hashtable_data *ht_data = NULL;
4152 g_return_if_fail(folder != NULL);
4153 g_return_if_fail(folder->klass == &imap_class);
4154 g_return_if_fail(item != NULL);
4155 g_return_if_fail(item->folder == folder);
4156 g_return_if_fail(msginfo != NULL);
4157 g_return_if_fail(msginfo->folder == item);
4159 if (!MSG_IS_MARKED(msginfo->flags) && (newflags & MSG_MARKED))
4160 flags_set |= IMAP_FLAG_FLAGGED;
4161 if ( MSG_IS_MARKED(msginfo->flags) && !(newflags & MSG_MARKED))
4162 flags_unset |= IMAP_FLAG_FLAGGED;
4164 if (!MSG_IS_UNREAD(msginfo->flags) && (newflags & MSG_UNREAD))
4165 flags_unset |= IMAP_FLAG_SEEN;
4166 if ( MSG_IS_UNREAD(msginfo->flags) && !(newflags & MSG_UNREAD))
4167 flags_set |= IMAP_FLAG_SEEN;
4169 if (!MSG_IS_REPLIED(msginfo->flags) && (newflags & MSG_REPLIED))
4170 flags_set |= IMAP_FLAG_ANSWERED;
4171 if ( MSG_IS_REPLIED(msginfo->flags) && !(newflags & MSG_REPLIED))
4172 flags_unset |= IMAP_FLAG_ANSWERED;
4174 if (!MSG_IS_DELETED(msginfo->flags) && (newflags & MSG_DELETED))
4175 flags_set |= IMAP_FLAG_DELETED;
4176 if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
4177 flags_unset |= IMAP_FLAG_DELETED;
4179 if (!flags_set && !flags_unset) {
4180 /* the changed flags were not translatable to IMAP-speak.
4181 * like MSG_POSTFILTERED, so just apply. */
4182 msginfo->flags.perm_flags = newflags;
4186 debug_print("getting session...\n");
4187 session = imap_session_get(folder);
4192 if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
4193 NULL, NULL, NULL, NULL, FALSE)) != MAILIMAP_NO_ERROR) {
4196 numlist.next = NULL;
4197 numlist.data = GINT_TO_POINTER(msginfo->msgnum);
4199 if (IMAP_FOLDER_ITEM(item)->batching) {
4200 /* instead of performing an UID STORE command for each message change,
4201 * as a lot of them can change "together", we just fill in hashtables
4202 * and defer the treatment so that we're able to send only one
4205 debug_print("IMAP batch mode on, deferring flags change\n");
4207 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_set_table,
4208 GINT_TO_POINTER(flags_set));
4209 if (ht_data == NULL) {
4210 ht_data = g_new0(hashtable_data, 1);
4211 ht_data->item = IMAP_FOLDER_ITEM(item);
4212 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_set_table,
4213 GINT_TO_POINTER(flags_set), ht_data);
4215 ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
4218 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4219 GINT_TO_POINTER(flags_unset));
4220 if (ht_data == NULL) {
4221 ht_data = g_new0(hashtable_data, 1);
4222 ht_data->item = IMAP_FOLDER_ITEM(item);
4223 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4224 GINT_TO_POINTER(flags_unset), ht_data);
4226 ht_data->msglist = g_slist_prepend(ht_data->msglist,
4227 GINT_TO_POINTER(msginfo->msgnum));
4230 debug_print("IMAP changing flags\n");
4232 ok = imap_set_message_flags(session, &numlist, flags_set, TRUE);
4233 if (ok != MAILIMAP_NO_ERROR) {
4239 ok = imap_set_message_flags(session, &numlist, flags_unset, FALSE);
4240 if (ok != MAILIMAP_NO_ERROR) {
4245 msginfo->flags.perm_flags = newflags;
4249 static gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
4252 IMAPSession *session;
4254 MsgNumberList numlist;
4256 g_return_val_if_fail(folder != NULL, -1);
4257 g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
4258 g_return_val_if_fail(item != NULL, -1);
4260 debug_print("getting session...\n");
4261 session = imap_session_get(folder);
4262 if (!session) return -1;
4264 ok = imap_select(session, IMAP_FOLDER(folder), item->path,
4265 NULL, NULL, NULL, NULL, FALSE);
4266 if (ok != MAILIMAP_NO_ERROR) {
4269 numlist.next = NULL;
4270 numlist.data = GINT_TO_POINTER(uid);
4272 ok = imap_set_message_flags
4273 (session, &numlist, IMAP_FLAG_DELETED, TRUE);
4274 if (ok != MAILIMAP_NO_ERROR) {
4275 log_warning(LOG_PROTOCOL, _("can't set deleted flags: %d\n"), uid);
4279 if (!session->uidplus) {
4280 ok = imap_cmd_expunge(session);
4284 uidstr = g_strdup_printf("%u", uid);
4285 ok = imap_cmd_expunge(session);
4288 if (ok != MAILIMAP_NO_ERROR) {
4289 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
4293 IMAP_FOLDER_ITEM(item)->uid_list = g_slist_remove(
4294 IMAP_FOLDER_ITEM(item)->uid_list, numlist.data);
4295 dir = folder_item_get_path(item);
4296 if (is_dir_exist(dir))
4297 remove_numbered_files(dir, uid, uid);
4299 return MAILIMAP_NO_ERROR;
4302 static gint compare_msginfo(gconstpointer a, gconstpointer b)
4304 return ((MsgInfo *)a)->msgnum - ((MsgInfo *)b)->msgnum;
4307 static guint gslist_find_next_num(MsgNumberList **list, guint num)
4311 g_return_val_if_fail(list != NULL, -1);
4313 for (elem = *list; elem != NULL; elem = g_slist_next(elem))
4314 if (GPOINTER_TO_INT(elem->data) >= num)
4317 return elem != NULL ? GPOINTER_TO_INT(elem->data) : (gint)-1;
4321 * NEW and DELETED flags are not syncronized
4322 * - The NEW/RECENT flags in IMAP folders can not really be directly
4323 * modified by Sylpheed
4324 * - The DELETE/DELETED flag in IMAP and Sylpheed don't have the same
4325 * meaning, in IMAP it always removes the messages from the FolderItem
4326 * in Sylpheed it can mean to move the message to trash
4329 typedef struct _get_flags_data {
4332 MsgInfoList *msginfo_list;
4333 GRelation *msgflags;
4334 gboolean full_search;
4338 static /*gint*/ void *imap_get_flags_thread(void *data)
4340 get_flags_data *stuff = (get_flags_data *)data;
4341 Folder *folder = stuff->folder;
4342 FolderItem *fitem = (FolderItem *) stuff->item;
4343 MsgInfoList *msginfo_list = stuff->msginfo_list;
4344 GRelation *msgflags = stuff->msgflags;
4346 carray * lep_uidtab;
4347 IMAPSession *session;
4349 int r = MAILIMAP_NO_ERROR;
4350 GHashTable *flags_hash = NULL;
4351 gboolean full_search = stuff->full_search;
4352 GSList *sorted_list = NULL;
4353 GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL;
4354 GSList *p_unseen, *p_answered, *p_flagged, *p_deleted;
4355 GSList *seq_list, *cur;
4356 gboolean reverse_seen = FALSE;
4357 gboolean selected_folder;
4358 gint exists_cnt, unseen_cnt;
4360 session = imap_session_get(folder);
4362 if (session == NULL) {
4364 return GINT_TO_POINTER(-1);
4366 selected_folder = (session->mbox != NULL) &&
4367 (!strcmp(session->mbox, fitem->path));
4369 lock_session(session);
4370 if (!selected_folder) {
4371 ok = imap_select(session, IMAP_FOLDER(folder), fitem->path,
4372 &exists_cnt, NULL, &unseen_cnt, NULL, TRUE);
4373 if (ok != MAILIMAP_NO_ERROR) {
4375 return GINT_TO_POINTER(-1);
4378 if (unseen_cnt > exists_cnt / 2)
4379 reverse_seen = TRUE;
4382 if (fitem->unread_msgs > fitem->total_msgs / 2)
4383 reverse_seen = TRUE;
4386 sorted_list = g_slist_sort(g_slist_copy(msginfo_list), compare_msginfo);
4388 seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msginfo_list);
4390 struct mailimap_set * set;
4391 set = mailimap_set_new_interval(1, 0);
4392 seq_list = g_slist_append(NULL, set);
4395 if (folder->account && folder->account->low_bandwidth) {
4396 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
4397 struct mailimap_set * imapset;
4398 clist * lep_uidlist;
4401 imapset = cur->data;
4403 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SEEN,
4404 full_search ? NULL:imapset, &lep_uidlist);
4407 r = imap_threaded_search(folder,
4408 IMAP_SEARCH_TYPE_UNSEEN,
4409 full_search ? NULL:imapset, &lep_uidlist);
4411 if (r == MAILIMAP_NO_ERROR) {
4414 uidlist = imap_uid_list_from_lep(lep_uidlist);
4415 mailimap_search_result_free(lep_uidlist);
4417 unseen = g_slist_concat(unseen, uidlist);
4419 imap_handle_error(SESSION(session), r);
4423 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FLAGGED,
4424 full_search ? NULL:imapset, &lep_uidlist);
4425 if (r == MAILIMAP_NO_ERROR) {
4428 uidlist = imap_uid_list_from_lep(lep_uidlist);
4429 mailimap_search_result_free(lep_uidlist);
4431 flagged = g_slist_concat(flagged, uidlist);
4433 imap_handle_error(SESSION(session), r);
4437 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4438 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED,
4439 full_search ? NULL:imapset, &lep_uidlist);
4440 if (r == MAILIMAP_NO_ERROR) {
4443 uidlist = imap_uid_list_from_lep(lep_uidlist);
4444 mailimap_search_result_free(lep_uidlist);
4446 answered = g_slist_concat(answered, uidlist);
4448 imap_handle_error(SESSION(session), r);
4452 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED,
4453 full_search ? NULL:imapset, &lep_uidlist);
4454 if (r == MAILIMAP_NO_ERROR) {
4457 uidlist = imap_uid_list_from_lep(lep_uidlist);
4458 mailimap_search_result_free(lep_uidlist);
4460 deleted = g_slist_concat(deleted, uidlist);
4462 imap_handle_error(SESSION(session), r);
4468 p_answered = answered;
4469 p_flagged = flagged;
4470 p_deleted = deleted;
4473 r = imap_threaded_fetch_uid_flags(folder, 1, &lep_uidtab);
4474 if (r == MAILIMAP_NO_ERROR) {
4475 flags_hash = g_hash_table_new_full(g_int_hash, g_int_equal, free, NULL);
4476 imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab, flags_hash);
4477 imap_fetch_uid_flags_list_free(lep_uidtab);
4479 imap_handle_error(SESSION(session), r);
4485 if (r == MAILIMAP_NO_ERROR)
4486 unlock_session(session);
4488 for (elem = sorted_list; elem != NULL; elem = g_slist_next(elem)) {
4490 MsgPermFlags flags, oldflags;
4493 msginfo = (MsgInfo *) elem->data;
4494 flags = msginfo->flags.perm_flags;
4495 wasnew = (flags & MSG_NEW);
4496 oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_MARKED|MSG_DELETED);
4498 if (folder->account && folder->account->low_bandwidth) {
4499 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4500 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_MARKED);
4502 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
4505 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4506 if (gslist_find_next_num(&p_unseen, msginfo->msgnum) == msginfo->msgnum) {
4507 if (!reverse_seen) {
4508 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
4510 flags &= ~(MSG_UNREAD | MSG_NEW);
4514 if (gslist_find_next_num(&p_flagged, msginfo->msgnum) == msginfo->msgnum)
4515 flags |= MSG_MARKED;
4517 flags &= ~MSG_MARKED;
4519 if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
4520 if (gslist_find_next_num(&p_answered, msginfo->msgnum) == msginfo->msgnum)
4521 flags |= MSG_REPLIED;
4523 flags &= ~MSG_REPLIED;
4524 if (gslist_find_next_num(&p_deleted, msginfo->msgnum) == msginfo->msgnum)
4525 flags |= MSG_DELETED;
4527 flags &= ~MSG_DELETED;
4530 if (flags_hash != NULL) {
4533 puid = malloc(sizeof(* puid));
4534 * puid = msginfo->msgnum;
4536 flags = GPOINTER_TO_INT(g_hash_table_lookup(flags_hash, puid));
4540 if ((flags & MSG_UNREAD) == 0)
4547 g_relation_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
4551 g_hash_table_destroy(flags_hash);
4553 imap_lep_set_free(seq_list);
4554 g_slist_free(flagged);
4555 g_slist_free(deleted);
4556 g_slist_free(answered);
4557 g_slist_free(unseen);
4558 g_slist_free(sorted_list);
4561 return GINT_TO_POINTER(0);
4564 static gint imap_get_flags(Folder *folder, FolderItem *item,
4565 MsgInfoList *msginfo_list, GRelation *msgflags)
4568 get_flags_data *data = g_new0(get_flags_data, 1);
4570 data->folder = folder;
4572 data->msginfo_list = msginfo_list;
4573 data->msgflags = msgflags;
4574 data->full_search = FALSE;
4576 GSList *tmp = NULL, *cur;
4578 if (prefs_common.work_offline &&
4579 !inc_offline_should_override(FALSE,
4580 _("Claws Mail needs network access in order "
4581 "to access the IMAP server."))) {
4586 tmp = folder_item_get_msg_list(item);
4588 if (g_slist_length(tmp) <= g_slist_length(msginfo_list))
4589 data->full_search = TRUE;
4591 for (cur = tmp; cur; cur = cur->next)
4592 procmsg_msginfo_free((MsgInfo *)cur->data);
4596 result = GPOINTER_TO_INT(imap_get_flags_thread(data));
4603 static gboolean process_flags(gpointer key, gpointer value, gpointer user_data)
4605 gboolean flags_set = GPOINTER_TO_INT(user_data);
4606 gint flags_value = GPOINTER_TO_INT(key);
4607 hashtable_data *data = (hashtable_data *)value;
4608 IMAPFolderItem *_item = data->item;
4609 FolderItem *item = (FolderItem *)_item;
4610 gint ok = MAILIMAP_ERROR_BAD_STATE;
4611 IMAPSession *session = NULL;
4613 debug_print("getting session...\n");
4614 session = imap_session_get(item->folder);
4616 data->msglist = g_slist_reverse(data->msglist);
4618 debug_print("IMAP %ssetting flags to %d for %d messages\n",
4621 g_slist_length(data->msglist));
4623 lock_session(session);
4625 ok = imap_select(session, IMAP_FOLDER(item->folder), item->path,
4626 NULL, NULL, NULL, NULL, FALSE);
4628 if (ok == MAILIMAP_NO_ERROR) {
4629 ok = imap_set_message_flags(session, data->msglist, flags_value, flags_set);
4631 g_warning("can't select mailbox %s\n", item->path);
4635 unlock_session(session);
4637 g_slist_free(data->msglist);
4642 static void process_hashtable(IMAPFolderItem *item)
4644 if (item->flags_set_table) {
4645 g_hash_table_foreach_remove(item->flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
4646 g_hash_table_destroy(item->flags_set_table);
4647 item->flags_set_table = NULL;
4649 if (item->flags_unset_table) {
4650 g_hash_table_foreach_remove(item->flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
4651 g_hash_table_destroy(item->flags_unset_table);
4652 item->flags_unset_table = NULL;
4657 static void imap_set_batch (Folder *folder, FolderItem *_item, gboolean batch)
4659 IMAPFolderItem *item = (IMAPFolderItem *)_item;
4660 IMAPSession *session;
4662 g_return_if_fail(item != NULL);
4664 if (item->batching == batch)
4668 item->batching = TRUE;
4669 debug_print("IMAP switching to batch mode\n");
4670 if (!item->flags_set_table) {
4671 item->flags_set_table = g_hash_table_new(NULL, g_direct_equal);
4673 if (!item->flags_unset_table) {
4674 item->flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
4676 session = imap_session_get(folder);
4678 imap_refresh_sensitivity(session);
4679 session->sens_update_block = TRUE;
4682 debug_print("IMAP switching away from batch mode\n");
4684 process_hashtable(item);
4685 item->batching = FALSE;
4686 session = imap_session_get(folder);
4688 session->sens_update_block = FALSE;
4689 imap_refresh_sensitivity(session);
4696 /* data types conversion libetpan <-> claws */
4700 #define ETPAN_IMAP_MB_MARKED 1
4701 #define ETPAN_IMAP_MB_UNMARKED 2
4702 #define ETPAN_IMAP_MB_NOSELECT 4
4703 #define ETPAN_IMAP_MB_NOINFERIORS 8
4705 static int imap_flags_to_flags(struct mailimap_mbx_list_flags * imap_flags)
4711 if (imap_flags->mbf_type == MAILIMAP_MBX_LIST_FLAGS_SFLAG) {
4712 switch (imap_flags->mbf_sflag) {
4713 case MAILIMAP_MBX_LIST_SFLAG_MARKED:
4714 flags |= ETPAN_IMAP_MB_MARKED;
4716 case MAILIMAP_MBX_LIST_SFLAG_NOSELECT:
4717 flags |= ETPAN_IMAP_MB_NOSELECT;
4719 case MAILIMAP_MBX_LIST_SFLAG_UNMARKED:
4720 flags |= ETPAN_IMAP_MB_UNMARKED;
4725 for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
4726 cur = clist_next(cur)) {
4727 struct mailimap_mbx_list_oflag * oflag;
4729 oflag = clist_content(cur);
4731 switch (oflag->of_type) {
4732 case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
4733 flags |= ETPAN_IMAP_MB_NOINFERIORS;
4741 static GSList * imap_list_from_lep(IMAPFolder * folder,
4742 clist * list, const gchar * real_path, gboolean all)
4745 GSList * item_list = NULL, *llast = NULL;
4747 for(iter = clist_begin(list) ; iter != NULL ;
4748 iter = clist_next(iter)) {
4749 struct mailimap_mailbox_list * mb;
4757 FolderItem *new_item;
4759 mb = clist_content(iter);
4765 if (mb->mb_flag != NULL)
4766 flags = imap_flags_to_flags(mb->mb_flag);
4768 delimiter = mb->mb_delimiter;
4771 dup_name = strdup(name);
4772 if (delimiter != '\0')
4773 subst_char(dup_name, delimiter, '/');
4775 base = g_path_get_basename(dup_name);
4776 if (base[0] == '.') {
4781 if (!all && path_cmp(name, real_path) == 0) {
4787 if (!all && dup_name[strlen(dup_name)-1] == '/') {
4788 dup_name[strlen(dup_name)-1] = '\0';
4791 loc_name = imap_modified_utf7_to_utf8(base);
4792 loc_path = imap_modified_utf7_to_utf8(dup_name);
4794 new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
4795 if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
4796 new_item->no_sub = TRUE;
4797 if (strcmp(dup_name, "INBOX") != 0 &&
4798 ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
4799 new_item->no_select = TRUE;
4801 if (item_list == NULL)
4802 llast = item_list = g_slist_append(item_list, new_item);
4804 llast = g_slist_append(llast, new_item);
4805 llast = llast->next;
4807 debug_print("folder '%s' found.\n", loc_path);
4818 static GSList * imap_get_lep_set_from_numlist(IMAPFolder *folder, MsgNumberList *numlist)
4820 GSList *sorted_list, *cur;
4821 guint first, last, next;
4822 GSList *ret_list = NULL, *llast = NULL;
4823 struct mailimap_set * current_set;
4824 unsigned int item_count;
4826 if (numlist == NULL)
4829 current_set = mailimap_set_new_empty();
4831 sorted_list = g_slist_copy(numlist);
4832 sorted_list = g_slist_sort(sorted_list, g_int_compare);
4834 first = GPOINTER_TO_INT(sorted_list->data);
4837 for (cur = sorted_list; cur != NULL; cur = g_slist_next(cur)) {
4838 if (GPOINTER_TO_INT(cur->data) == 0)
4843 last = GPOINTER_TO_INT(cur->data);
4845 next = GPOINTER_TO_INT(cur->next->data);
4849 if (last + 1 != next || next == 0 || item_count >= folder->max_set_size) {
4851 struct mailimap_set_item * item;
4852 item = mailimap_set_item_new(first, last);
4853 mailimap_set_add(current_set, item);
4857 if (item_count >= folder->max_set_size) {
4858 if (ret_list == NULL)
4859 llast = ret_list = g_slist_append(ret_list,
4862 llast = g_slist_append(llast, current_set);
4863 llast = llast->next;
4866 current_set = mailimap_set_new_empty();
4872 if (clist_count(current_set->set_list) > 0) {
4873 ret_list = g_slist_append(ret_list,
4877 g_slist_free(sorted_list);
4882 static GSList * imap_get_lep_set_from_msglist(IMAPFolder *folder, MsgInfoList *msglist)
4884 MsgNumberList *numlist = NULL;
4888 for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
4889 MsgInfo *msginfo = (MsgInfo *) cur->data;
4891 numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
4893 numlist = g_slist_reverse(numlist);
4894 seq_list = imap_get_lep_set_from_numlist(folder, numlist);
4895 g_slist_free(numlist);
4900 static GSList * imap_uid_list_from_lep(clist * list)
4907 for(iter = clist_begin(list) ; iter != NULL ;
4908 iter = clist_next(iter)) {
4911 puid = clist_content(iter);
4912 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4915 result = g_slist_reverse(result);
4919 static GSList * imap_uid_list_from_lep_tab(carray * list)
4926 for(i = 0 ; i < carray_count(list) ; i ++) {
4929 puid = carray_get(list, i);
4930 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
4932 result = g_slist_reverse(result);
4936 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
4944 for(i = 0 ; i < carray_count(list) ; i += 2) {
4949 puid = carray_get(list, i);
4950 pflags = carray_get(list, i + 1);
4951 pguid = malloc(sizeof(* pguid));
4954 g_hash_table_insert(hash, pguid, GINT_TO_POINTER(* pflags));
4958 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
4961 MsgInfo *msginfo = NULL;
4964 MsgFlags flags = {0, 0};
4966 if (info->headers == NULL)
4969 MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
4970 if (folder_has_parent_of_type(item, F_QUEUE)) {
4971 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
4972 } else if (folder_has_parent_of_type(item, F_DRAFT)) {
4973 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
4975 flags.perm_flags = info->flags;
4979 msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
4982 msginfo->msgnum = uid;
4983 msginfo->size = size;
4989 static void imap_lep_set_free(GSList *seq_list)
4993 for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
4994 struct mailimap_set * imapset;
4996 imapset = cur->data;
4997 mailimap_set_free(imapset);
4999 g_slist_free(seq_list);
5002 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags)
5004 struct mailimap_flag_list * flag_list;
5006 flag_list = mailimap_flag_list_new_empty();
5008 if (IMAP_IS_SEEN(flags))
5009 mailimap_flag_list_add(flag_list,
5010 mailimap_flag_new_seen());
5011 if (IMAP_IS_ANSWERED(flags))
5012 mailimap_flag_list_add(flag_list,
5013 mailimap_flag_new_answered());
5014 if (IMAP_IS_FLAGGED(flags))
5015 mailimap_flag_list_add(flag_list,
5016 mailimap_flag_new_flagged());
5017 if (IMAP_IS_DELETED(flags))
5018 mailimap_flag_list_add(flag_list,
5019 mailimap_flag_new_deleted());
5020 if (IMAP_IS_DRAFT(flags))
5021 mailimap_flag_list_add(flag_list,
5022 mailimap_flag_new_draft());
5027 guint imap_folder_get_refcnt(Folder *folder)
5029 return ((IMAPFolder *)folder)->refcnt;
5032 void imap_folder_ref(Folder *folder)
5034 ((IMAPFolder *)folder)->refcnt++;
5037 void imap_disconnect_all(void)
5040 for (list = account_get_list(); list != NULL; list = list->next) {
5041 PrefsAccount *account = list->data;
5042 if (account->protocol == A_IMAP4) {
5043 RemoteFolder *folder = (RemoteFolder *)account->folder;
5044 if (folder && folder->session) {
5045 IMAPSession *session = (IMAPSession *)folder->session;
5046 imap_threaded_disconnect(FOLDER(folder));
5047 SESSION(session)->state = SESSION_DISCONNECTED;
5048 session_destroy(SESSION(session));
5049 folder->session = NULL;
5055 void imap_folder_unref(Folder *folder)
5057 if (((IMAPFolder *)folder)->refcnt > 0)
5058 ((IMAPFolder *)folder)->refcnt--;
5061 void imap_cancel_all(void)
5066 folderlist = folder_get_list();
5067 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
5068 Folder *folder = (Folder *) cur->data;
5070 if (folder->klass == &imap_class) {
5071 if (imap_is_busy(folder)) {
5072 IMAPSession *imap_session;
5073 RemoteFolder *rfolder;
5075 g_printerr("cancelled\n");
5076 imap_threaded_cancel(folder);
5077 rfolder = (RemoteFolder *) folder;
5078 imap_session = (IMAPSession *) rfolder->session;
5080 imap_session->cancelled = 1;
5086 gboolean imap_cancel_all_enabled(void)
5091 folderlist = folder_get_list();
5092 for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
5093 Folder *folder = (Folder *) cur->data;
5095 if (folder->klass == &imap_class) {
5096 if (imap_is_busy(folder)) {
5105 static gboolean imap_is_busy(Folder *folder)
5107 IMAPSession *imap_session;
5108 RemoteFolder *rfolder;
5110 rfolder = (RemoteFolder *) folder;
5111 imap_session = (IMAPSession *) rfolder->session;
5112 if (imap_session == NULL)
5115 return imap_session->busy;
5118 #else /* HAVE_LIBETPAN */
5120 static FolderClass imap_class;
5122 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
5123 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
5125 static Folder *imap_folder_new (const gchar *name,
5128 static gboolean missing_imap_warning = TRUE;
5129 if (missing_imap_warning) {
5130 missing_imap_warning = FALSE;
5132 _("You have one or more IMAP accounts "
5133 "defined. However this version of "
5134 "Claws Mail has been built without "
5135 "IMAP support; your IMAP account(s) are "
5137 "You probably need to "
5138 "install libetpan and recompile "
5143 static gint imap_create_tree (Folder *folder)
5147 static FolderItem *imap_create_folder (Folder *folder,
5153 static gint imap_rename_folder (Folder *folder,
5160 gchar imap_get_path_separator_for_item(FolderItem *item)
5165 FolderClass *imap_get_class(void)
5167 if (imap_class.idstr == NULL) {
5168 imap_class.type = F_IMAP;
5169 imap_class.idstr = "imap";
5170 imap_class.uistr = "IMAP4";
5172 imap_class.new_folder = imap_folder_new;
5173 imap_class.create_tree = imap_create_tree;
5174 imap_class.create_folder = imap_create_folder;
5175 imap_class.rename_folder = imap_rename_folder;
5177 imap_class.set_xml = folder_set_xml;
5178 imap_class.get_xml = folder_get_xml;
5179 imap_class.item_set_xml = imap_item_set_xml;
5180 imap_class.item_get_xml = imap_item_get_xml;
5181 /* nothing implemented */
5187 void imap_disconnect_all(void)
5191 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
5196 GList * imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
5201 void imap_cache_msg(FolderItem *item, gint msgnum)
5205 void imap_cancel_all(void)
5209 gboolean imap_cancel_all_enabled(void)
5216 #ifdef HAVE_LIBETPAN
5217 static void imap_synchronise(FolderItem *item, gint days)
5219 if (IMAP_FOLDER_ITEM(item)->last_sync == IMAP_FOLDER_ITEM(item)->last_change) {
5220 debug_print("%s already synced\n", item->path?item->path:item->name);
5223 debug_print("syncing %s\n", item->path?item->path:item->name);
5224 imap_gtk_synchronise(item, days);
5225 IMAP_FOLDER_ITEM(item)->last_sync = IMAP_FOLDER_ITEM(item)->last_change;
5229 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
5231 #ifdef HAVE_LIBETPAN
5234 folder_item_set_xml(folder, item, tag);
5236 #ifdef HAVE_LIBETPAN
5237 for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
5238 XMLAttr *attr = (XMLAttr *) cur->data;
5240 if (!attr || !attr->name || !attr->value) continue;
5241 if (!strcmp(attr->name, "uidnext"))
5242 IMAP_FOLDER_ITEM(item)->uid_next = atoi(attr->value);
5243 if (!strcmp(attr->name, "last_sync"))
5244 IMAP_FOLDER_ITEM(item)->last_sync = atoi(attr->value);
5245 if (!strcmp(attr->name, "last_change"))
5246 IMAP_FOLDER_ITEM(item)->last_change = atoi(attr->value);
5248 if (IMAP_FOLDER_ITEM(item)->last_change == 0)
5249 IMAP_FOLDER_ITEM(item)->last_change = time(NULL);
5253 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item)
5257 tag = folder_item_get_xml(folder, item);
5259 #ifdef HAVE_LIBETPAN
5260 xml_tag_add_attr(tag, xml_attr_new_int("uidnext",
5261 IMAP_FOLDER_ITEM(item)->uid_next));
5262 xml_tag_add_attr(tag, xml_attr_new_int("last_sync",
5263 IMAP_FOLDER_ITEM(item)->last_sync));
5264 xml_tag_add_attr(tag, xml_attr_new_int("last_change",
5265 IMAP_FOLDER_ITEM(item)->last_change));