2 * Claws Mail -- a GTK based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2023 the Claws Mail team and Hiroyuki Yamamoto
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/>.
21 #include "claws-features.h"
27 #include <glib/gi18n.h>
34 #include "alertpanel.h"
57 #include "procheader.h"
58 #include "prefs_account.h"
62 #include "prefs_common.h"
63 #include "inputdialog.h"
65 #include "remotefolder.h"
67 #include "statusbar.h"
69 #include "imap-thread.h"
73 #include "passwordstore.h"
74 #include "file-utils.h"
79 typedef struct _IMAPFolder IMAPFolder
;
80 typedef struct _IMAPSession IMAPSession
;
81 typedef struct _IMAPNameSpace IMAPNameSpace
;
82 typedef struct _IMAPFolderItem IMAPFolderItem
;
84 #define IMAP_FOLDER(obj) ((IMAPFolder *)obj)
85 #define IMAP_FOLDER_ITEM(obj) ((IMAPFolderItem *)obj)
86 #define IMAP_SESSION(obj) ((IMAPSession *)obj)
92 /* list of IMAPNameSpace */
96 gchar last_seen_separator
;
99 gchar
*search_charset
;
100 gboolean search_charset_supported
;
107 gboolean authenticated
;
116 gboolean folder_content_changed
;
127 gboolean sens_update_block
;
130 gint scan_tree_recurs_depth
;
133 struct _IMAPNameSpace
139 #define IMAPBUFSIZE 8192
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)
146 #define IMAP_IS_FORWARDED(flags) ((flags & IMAP_FLAG_FORWARDED) != 0)
147 #define IMAP_IS_SPAM(flags) ((flags & IMAP_FLAG_SPAM) != 0)
148 #define IMAP_IS_HAM(flags) ((flags & IMAP_FLAG_HAM) != 0)
151 #define IMAP4_PORT 143
153 #define IMAPS_PORT 993
156 #define IMAP_CMD_LIMIT 1000
159 ITEM_CAN_CREATE_FLAGS_UNKNOWN
= 0,
160 ITEM_CAN_CREATE_FLAGS
,
161 ITEM_CANNOT_CREATE_FLAGS
164 struct _IMAPFolderItem
173 GHashTable
*flags_set_table
;
174 GHashTable
*flags_unset_table
;
177 gboolean should_update
;
178 gboolean should_trash_cache
;
179 gint can_create_flags
;
181 GHashTable
*tags_set_table
;
182 GHashTable
*tags_unset_table
;
187 static XMLTag
*imap_item_get_xml(Folder
*folder
, FolderItem
*item
);
188 static void imap_item_set_xml(Folder
*folder
, FolderItem
*item
, XMLTag
*tag
);
190 static void imap_folder_init (Folder
*folder
,
194 static Folder
*imap_folder_new (const gchar
*name
,
196 static void imap_folder_destroy (Folder
*folder
);
198 static IMAPSession
*imap_session_new (Folder
*folder
,
199 const PrefsAccount
*account
);
200 static gint
imap_session_authenticate(IMAPSession
*session
,
201 PrefsAccount
*account
);
202 static void imap_session_destroy (Session
*session
);
204 static gchar
*imap_fetch_msg (Folder
*folder
,
207 static gchar
*imap_fetch_msg_full (Folder
*folder
,
212 static void imap_remove_cached_msg (Folder
*folder
,
215 static gint
imap_add_msg (Folder
*folder
,
219 static gint
imap_add_msgs (Folder
*folder
,
222 GHashTable
*relation
);
224 static gint
imap_copy_msg (Folder
*folder
,
227 static gint
imap_copy_msgs (Folder
*folder
,
229 MsgInfoList
*msglist
,
230 GHashTable
*relation
);
232 static gint
search_msgs (Folder
*folder
,
233 FolderItem
*container
,
234 MsgNumberList
**msgs
,
236 MatcherList
*predicate
,
237 SearchProgressNotify progress_cb
,
238 gpointer progress_data
);
240 static gint
imap_remove_msg (Folder
*folder
,
243 static gint
imap_remove_msgs (Folder
*folder
,
245 MsgInfoList
*msglist
,
246 GHashTable
*relation
);
247 static gint
imap_expunge (Folder
*folder
,
249 static gint
imap_remove_all_msg (Folder
*folder
,
252 static gboolean
imap_is_msg_changed (Folder
*folder
,
256 static gint
imap_close (Folder
*folder
,
259 static gint
imap_scan_tree (Folder
*folder
);
261 static gint
imap_create_tree (Folder
*folder
);
263 static FolderItem
*imap_create_folder (Folder
*folder
,
266 static gint
imap_rename_folder (Folder
*folder
,
269 static gint
imap_remove_folder (Folder
*folder
,
272 static FolderItem
*imap_folder_item_new (Folder
*folder
);
273 static void imap_folder_item_destroy (Folder
*folder
,
276 static IMAPSession
*imap_session_get (Folder
*folder
);
278 static gint
imap_auth (IMAPSession
*session
,
283 static gint
imap_scan_tree_recursive (IMAPSession
*session
,
286 static gint
imap_scan_tree_recursive_dive (IMAPSession
*session
,
290 static void imap_create_missing_folders (Folder
*folder
);
291 static FolderItem
*imap_create_special_folder
293 SpecialFolderItemType stype
,
296 static gint
imap_do_copy_msgs (Folder
*folder
,
298 MsgInfoList
*msglist
,
299 GHashTable
*relation
,
300 gboolean same_dest_ok
);
302 static gint
imap_do_remove_msgs (Folder
*folder
,
304 MsgInfoList
*msglist
,
305 GHashTable
*relation
);
307 static void imap_delete_all_cached_messages (FolderItem
*item
);
308 static void imap_set_batch (Folder
*folder
,
311 static gint
imap_set_message_flags (IMAPSession
*session
,
312 IMAPFolderItem
*item
,
313 MsgNumberList
*numlist
,
317 static gint
imap_select (IMAPSession
*session
,
323 guint32
*uid_validity
,
324 gint
*can_create_flags
,
326 static gint
imap_status (IMAPSession
*session
,
329 IMAPFolderItem
*item
,
332 guint32
*uid_validity
,
335 static void imap_commit_tags (FolderItem
*item
,
340 static gchar
imap_get_path_separator (IMAPSession
*session
,
344 static gchar
*imap_get_real_path (IMAPSession
*session
,
349 static void imap_synchronise (FolderItem
*item
, gint days
);
351 static gboolean
imap_is_busy (Folder
*folder
);
353 static void imap_free_capabilities (IMAPSession
*session
);
355 /* low-level IMAP4rev1 commands */
356 static gint
imap_cmd_login (IMAPSession
*session
,
360 static gint
imap_cmd_noop (IMAPSession
*session
);
362 static gint
imap_cmd_starttls (IMAPSession
*session
);
364 static gint
imap_cmd_select (IMAPSession
*session
,
369 guint32
*uid_validity
,
370 gint
*can_create_flags
,
373 static gint
imap_cmd_close (IMAPSession
*session
);
374 static gint
imap_cmd_examine (IMAPSession
*session
,
379 guint32
*uid_validity
,
381 static gint
imap_cmd_create (IMAPSession
*sock
,
382 const gchar
*folder
);
383 static gint
imap_cmd_rename (IMAPSession
*sock
,
384 const gchar
*oldfolder
,
385 const gchar
*newfolder
);
386 static gint
imap_cmd_delete (IMAPSession
*session
,
387 const gchar
*folder
);
388 static gint
imap_cmd_fetch (IMAPSession
*sock
,
390 const gchar
*filename
,
393 static gint
imap_cmd_append (IMAPSession
*session
,
394 IMAPFolderItem
*item
,
395 const gchar
*destfolder
,
399 static gint
imap_cmd_copy (IMAPSession
*session
,
400 struct mailimap_set
* set
,
401 const gchar
*destfolder
,
402 struct mailimap_set
** source
,
403 struct mailimap_set
** dest
);
404 static gint
imap_cmd_store (IMAPSession
*session
,
405 IMAPFolderItem
*item
,
406 struct mailimap_set
* set
,
410 static gint
imap_cmd_expunge (IMAPSession
*session
);
412 static void imap_path_separator_subst (gchar
*str
,
415 static gboolean
imap_rename_folder_func (GNode
*node
,
417 static gint
imap_get_num_list (Folder
*folder
,
420 gboolean
*old_uids_valid
);
421 static GSList
*imap_get_msginfos (Folder
*folder
,
423 GSList
*msgnum_list
);
424 static MsgInfo
*imap_get_msginfo (Folder
*folder
,
427 static gboolean
imap_scan_required (Folder
*folder
,
429 static void imap_change_flags (Folder
*folder
,
432 MsgPermFlags newflags
);
433 static gint
imap_get_flags (Folder
*folder
,
435 MsgInfoList
*msglist
,
436 GHashTable
*msgflags
);
437 static gchar
*imap_item_get_path (Folder
*folder
,
439 static MsgInfo
*imap_parse_msg(const gchar
*file
, FolderItem
*item
);
442 /* data types conversion libetpan <-> claws */
443 static GSList
* imap_list_from_lep(IMAPFolder
* folder
,
444 clist
* list
, const gchar
* real_path
, gboolean all
);
445 static GSList
* imap_get_lep_set_from_numlist(IMAPFolder
*folder
, MsgNumberList
*numlist
);
446 static GSList
* imap_get_lep_set_from_msglist(IMAPFolder
*folder
, MsgInfoList
*msglist
);
447 static GSList
* imap_uid_list_from_lep(clist
* list
, gint
* length
);
448 static GSList
* imap_uid_list_from_lep_tab(carray
* list
);
449 static void imap_flags_hash_from_lep_uid_flags_tab(carray
* list
,
451 GHashTable
*tags_hash
);
452 static MsgInfo
*imap_envelope_from_lep(struct imap_fetch_env_info
* info
,
454 static void imap_lep_set_free(GSList
*seq_list
);
455 static struct mailimap_flag_list
* imap_flag_to_lep(IMAPFolderItem
*item
, IMAPFlags flags
, GSList
*tags
);
457 typedef struct _hashtable_data
{
459 IMAPFolderItem
*item
;
462 static FolderClass imap_class
;
464 FolderClass
*imap_get_class(void)
466 if (imap_class
.idstr
== NULL
) {
467 imap_class
.type
= F_IMAP
;
468 imap_class
.idstr
= "imap";
469 imap_class
.uistr
= "IMAP";
470 imap_class
.supports_server_search
= TRUE
;
472 /* Folder functions */
473 imap_class
.new_folder
= imap_folder_new
;
474 imap_class
.destroy_folder
= imap_folder_destroy
;
475 imap_class
.scan_tree
= imap_scan_tree
;
476 imap_class
.create_tree
= imap_create_tree
;
478 /* FolderItem functions */
479 imap_class
.item_new
= imap_folder_item_new
;
480 imap_class
.item_destroy
= imap_folder_item_destroy
;
481 imap_class
.item_get_path
= imap_item_get_path
;
482 imap_class
.create_folder
= imap_create_folder
;
483 imap_class
.rename_folder
= imap_rename_folder
;
484 imap_class
.remove_folder
= imap_remove_folder
;
485 imap_class
.close
= imap_close
;
486 imap_class
.get_num_list
= imap_get_num_list
;
487 imap_class
.scan_required
= imap_scan_required
;
488 imap_class
.set_xml
= folder_set_xml
;
489 imap_class
.get_xml
= folder_get_xml
;
490 imap_class
.item_set_xml
= imap_item_set_xml
;
491 imap_class
.item_get_xml
= imap_item_get_xml
;
493 /* Message functions */
494 imap_class
.get_msginfo
= imap_get_msginfo
;
495 imap_class
.get_msginfos
= imap_get_msginfos
;
496 imap_class
.fetch_msg
= imap_fetch_msg
;
497 imap_class
.fetch_msg_full
= imap_fetch_msg_full
;
498 imap_class
.add_msg
= imap_add_msg
;
499 imap_class
.add_msgs
= imap_add_msgs
;
500 imap_class
.copy_msg
= imap_copy_msg
;
501 imap_class
.copy_msgs
= imap_copy_msgs
;
502 imap_class
.search_msgs
= search_msgs
;
503 imap_class
.remove_msg
= imap_remove_msg
;
504 imap_class
.remove_msgs
= imap_remove_msgs
;
505 imap_class
.expunge
= imap_expunge
;
506 imap_class
.remove_all_msg
= imap_remove_all_msg
;
507 imap_class
.is_msg_changed
= imap_is_msg_changed
;
508 imap_class
.change_flags
= imap_change_flags
;
509 imap_class
.get_flags
= imap_get_flags
;
510 imap_class
.set_batch
= imap_set_batch
;
511 imap_class
.synchronise
= imap_synchronise
;
512 imap_class
.remove_cached_msg
= imap_remove_cached_msg
;
513 imap_class
.commit_tags
= imap_commit_tags
;
519 static void imap_refresh_sensitivity (IMAPSession
*session
)
523 if (session
->sens_update_block
)
525 mainwin
= mainwindow_get_mainwindow();
527 toolbar_main_set_sensitive(mainwin
);
528 main_window_set_menu_sensitive(mainwin
);
532 static void lock_session(IMAPSession
*session
)
535 debug_print("locking session %p (%d)\n", session
, session
->busy
);
537 debug_print(" SESSION WAS LOCKED !! \n");
538 session
->busy
= TRUE
;
539 imap_refresh_sensitivity(session
);
541 debug_print("can't lock null session\n");
545 static void unlock_session(IMAPSession
*session
)
548 debug_print("unlocking session %p\n", session
);
549 session
->busy
= FALSE
;
550 imap_refresh_sensitivity(session
);
552 debug_print("can't unlock null session\n");
556 static gboolean
imap_ping(gpointer data
)
558 Session
*session
= (Session
*)data
;
559 IMAPSession
*imap_session
= IMAP_SESSION(session
);
562 if (session
->state
!= SESSION_READY
)
564 if (imap_session
->busy
|| !imap_session
->authenticated
)
567 lock_session(imap_session
);
568 r
= imap_cmd_noop(imap_session
);
569 unlock_session(imap_session
);
571 return r
== MAILIMAP_NO_ERROR
;
574 static void imap_disc_session_destroy(IMAPSession
*session
)
576 RemoteFolder
*rfolder
= NULL
;
581 rfolder
= REMOTE_FOLDER(IMAP_SESSION(session
)->folder
);
585 log_warning(LOG_PROTOCOL
, _("IMAP connection broken\n"));
586 SESSION(session
)->state
= SESSION_DISCONNECTED
;
587 SESSION(session
)->sock
= NULL
;
590 static void imap_safe_destroy(IMAPSession
*session
)
593 session_destroy(SESSION(session
));
595 session
->do_destroy
= TRUE
;
598 static gboolean
is_fatal(int libetpan_errcode
)
600 switch(libetpan_errcode
) {
601 case MAILIMAP_ERROR_STREAM
:
602 case MAILIMAP_ERROR_PROTOCOL
:
603 case MAILIMAP_ERROR_PARSE
:
604 case MAILIMAP_ERROR_BAD_STATE
:
611 #define MY_LOG_WARNING(concat_cmd, ...) \
613 log_warning(LOG_PROTOCOL, msg, __VA_ARGS__); \
616 static void imap_handle_error(Session
*session
, const gchar
*server
, int libetpan_errcode
)
618 const gchar
*session_server
= (session
? session
->server
: NULL
);
621 if (session_server
== NULL
)
622 session_server
= server
;
623 if (session_server
== NULL
)
624 session_server
= "(null)";
626 switch(libetpan_errcode
) {
627 case MAILIMAP_NO_ERROR
:
629 case MAILIMAP_NO_ERROR_AUTHENTICATED
:
630 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("authenticated"), "\n", NULL
), session_server
)
632 case MAILIMAP_NO_ERROR_NON_AUTHENTICATED
:
633 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("not authenticated"), "\n", NULL
), session_server
)
635 case MAILIMAP_ERROR_BAD_STATE
:
636 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("bad state"), "\n", NULL
), session_server
)
638 case MAILIMAP_ERROR_STREAM
:
639 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("stream error"), "\n", NULL
), session_server
)
641 case MAILIMAP_ERROR_PARSE
:
642 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("parse error "
643 "(very probably non-RFC compliance from the server)"), "\n", NULL
), session_server
)
645 case MAILIMAP_ERROR_CONNECTION_REFUSED
:
646 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("connection refused"), "\n", NULL
), session_server
)
648 case MAILIMAP_ERROR_MEMORY
:
649 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("memory error"), "\n", NULL
), session_server
)
651 case MAILIMAP_ERROR_FATAL
:
652 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("fatal error"), "\n", NULL
), session_server
)
654 case MAILIMAP_ERROR_PROTOCOL
:
655 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("protocol error "
656 "(very probably non-RFC compliance from the server)"), "\n", NULL
), session_server
)
658 case MAILIMAP_ERROR_DONT_ACCEPT_CONNECTION
:
659 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("connection not accepted"), "\n", NULL
), session_server
)
661 case MAILIMAP_ERROR_APPEND
:
662 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("APPEND error"), "\n", NULL
), session_server
)
664 case MAILIMAP_ERROR_NOOP
:
665 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("NOOP error"), "\n", NULL
), session_server
)
667 case MAILIMAP_ERROR_LOGOUT
:
668 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LOGOUT error"), "\n", NULL
), session_server
)
670 case MAILIMAP_ERROR_CAPABILITY
:
671 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CAPABILITY error"), "\n", NULL
), session_server
)
673 case MAILIMAP_ERROR_CHECK
:
674 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CHECK error"), "\n", NULL
), session_server
)
676 case MAILIMAP_ERROR_CLOSE
:
677 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CLOSE error"), "\n", NULL
), session_server
)
679 case MAILIMAP_ERROR_EXPUNGE
:
680 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXPUNGE error"), "\n", NULL
), session_server
)
682 case MAILIMAP_ERROR_COPY
:
683 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("COPY error"), "\n", NULL
), session_server
)
685 case MAILIMAP_ERROR_UID_COPY
:
686 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID COPY error"), "\n", NULL
), session_server
)
688 case MAILIMAP_ERROR_CREATE
:
689 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("CREATE error"), "\n", NULL
), session_server
)
691 case MAILIMAP_ERROR_DELETE
:
692 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("DELETE error"), "\n", NULL
), session_server
)
694 case MAILIMAP_ERROR_EXAMINE
:
695 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXAMINE error"), "\n", NULL
), session_server
)
697 case MAILIMAP_ERROR_FETCH
:
698 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("FETCH error"), "\n", NULL
), session_server
)
700 case MAILIMAP_ERROR_UID_FETCH
:
701 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID FETCH error"), "\n", NULL
), session_server
)
703 case MAILIMAP_ERROR_LIST
:
704 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LIST error"), "\n", NULL
), session_server
)
706 case MAILIMAP_ERROR_LOGIN
:
707 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LOGIN error"), "\n", NULL
), session_server
)
709 case MAILIMAP_ERROR_LSUB
:
710 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("LSUB error"), "\n", NULL
), session_server
)
712 case MAILIMAP_ERROR_RENAME
:
713 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("RENAME error"), "\n", NULL
), session_server
)
715 case MAILIMAP_ERROR_SEARCH
:
716 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SEARCH error"), "\n", NULL
), session_server
)
718 case MAILIMAP_ERROR_UID_SEARCH
:
719 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID SEARCH error"), "\n", NULL
), session_server
)
721 case MAILIMAP_ERROR_SELECT
:
722 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SELECT error"), "\n", NULL
), session_server
)
724 case MAILIMAP_ERROR_STATUS
:
725 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STATUS error"), "\n", NULL
), session_server
)
727 case MAILIMAP_ERROR_STORE
:
728 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STORE error"), "\n", NULL
), session_server
)
730 case MAILIMAP_ERROR_UID_STORE
:
731 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UID STORE error"), "\n", NULL
), session_server
)
733 case MAILIMAP_ERROR_SUBSCRIBE
:
734 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SUBSCRIBE error"), "\n", NULL
), session_server
)
736 case MAILIMAP_ERROR_UNSUBSCRIBE
:
737 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("UNSUBSCRIBE error"), "\n", NULL
), session_server
)
739 case MAILIMAP_ERROR_STARTTLS
:
740 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("STARTTLS error"), "\n", NULL
), session_server
)
742 case MAILIMAP_ERROR_INVAL
:
743 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("INVAL error"), "\n", NULL
), session_server
)
745 case MAILIMAP_ERROR_EXTENSION
:
746 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("EXTENSION error"), "\n", NULL
), session_server
)
748 case MAILIMAP_ERROR_SASL
:
749 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("SASL error"), "\n", NULL
), session_server
)
752 case MAILIMAP_ERROR_SSL
:
753 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("TLS error"), "\n", NULL
), session_server
)
757 MY_LOG_WARNING(g_strconcat(_("IMAP error on %s:"), " ", _("Unknown error [%d]"), "\n", NULL
),
758 session_server
, libetpan_errcode
)
762 if (session
&& is_fatal(libetpan_errcode
)) {
763 imap_disc_session_destroy(IMAP_SESSION(session
));
764 } else if (session
&& !is_fatal(libetpan_errcode
)) {
765 if (IMAP_SESSION(session
)->busy
)
766 unlock_session(IMAP_SESSION(session
));
770 #undef MY_LOG_WARNING
772 static Folder
*imap_folder_new(const gchar
*name
, const gchar
*path
)
776 folder
= (Folder
*)g_new0(IMAPFolder
, 1);
777 folder
->klass
= &imap_class
;
778 imap_folder_init(folder
, name
, path
);
783 static void imap_folder_destroy(Folder
*folder
)
785 while (imap_folder_get_refcnt(folder
) > 0)
786 gtk_main_iteration();
788 g_free(IMAP_FOLDER(folder
)->search_charset
);
790 folder_remote_folder_destroy(REMOTE_FOLDER(folder
));
794 static void imap_folder_init(Folder
*folder
, const gchar
*name
,
797 folder_remote_folder_init((Folder
*)folder
, name
, path
);
798 IMAP_FOLDER(folder
)->search_charset_supported
= TRUE
;
799 IMAP_FOLDER(folder
)->search_charset
= g_strdup(conv_get_locale_charset_str_no_utf8());
802 static FolderItem
*imap_folder_item_new(Folder
*folder
)
804 IMAPFolderItem
*item
;
806 item
= g_new0(IMAPFolderItem
, 1);
809 item
->uid_list
= NULL
;
811 return (FolderItem
*)item
;
814 static void imap_folder_item_destroy(Folder
*folder
, FolderItem
*_item
)
816 IMAPFolderItem
*item
= (IMAPFolderItem
*)_item
;
818 g_return_if_fail(item
!= NULL
);
819 g_slist_free(item
->uid_list
);
824 static gboolean
imap_reset_uid_lists_func(GNode
*node
, gpointer data
)
826 IMAPFolderItem
*item
= (IMAPFolderItem
*)node
->data
;
829 g_slist_free(item
->uid_list
);
830 item
->uid_list
= NULL
;
835 static void imap_reset_uid_lists(Folder
*folder
)
837 if(folder
->node
== NULL
)
840 /* Destroy all uid lists and rest last uid */
841 g_node_traverse(folder
->node
, G_IN_ORDER
, G_TRAVERSE_ALL
, -1, imap_reset_uid_lists_func
, NULL
);
844 static int imap_get_capabilities(IMAPSession
*session
)
846 struct mailimap_capability_data
*capabilities
= NULL
;
850 if (session
->capability
!= NULL
)
851 return MAILIMAP_NO_ERROR
;
853 result
= imap_threaded_capability(session
->folder
, &capabilities
);
855 if (result
!= MAILIMAP_NO_ERROR
) {
859 if (capabilities
== NULL
|| capabilities
->cap_list
== NULL
) {
860 return MAILIMAP_NO_ERROR
;
863 for(cur
= clist_begin(capabilities
->cap_list
) ; cur
!= NULL
;
864 cur
= clist_next(cur
)) {
865 struct mailimap_capability
* cap
=
867 if (!cap
|| cap
->cap_data
.cap_name
== NULL
)
869 session
->capability
= g_slist_append
870 (session
->capability
,
871 g_strdup(cap
->cap_data
.cap_name
));
872 debug_print("got capa %s\n", cap
->cap_data
.cap_name
);
874 mailimap_capability_data_free(capabilities
);
875 return MAILIMAP_NO_ERROR
;
878 static gboolean
imap_has_capability(IMAPSession
*session
, const gchar
*cap
)
881 for (cur
= session
->capability
; cur
; cur
= cur
->next
) {
882 if (!g_ascii_strcasecmp(cur
->data
, cap
))
888 static gint
imap_auth(IMAPSession
*session
, const gchar
*user
, const gchar
*pass
,
891 gint ok
= MAILIMAP_ERROR_LOGIN
;
892 static time_t last_login_err
= 0;
893 gchar
*ext_info
= "";
895 gchar
*server
= NULL
;
896 if ((r
= imap_get_capabilities(session
)) != MAILIMAP_NO_ERROR
) {
897 imap_handle_error(SESSION(session
), NULL
, r
);
900 server
= g_strdup(SESSION(session
)->server
);
903 ok
= imap_cmd_login(session
, user
, pass
, "ANONYMOUS");
905 case IMAP_AUTH_CRAM_MD5
:
906 ok
= imap_cmd_login(session
, user
, pass
, "CRAM-MD5");
908 case IMAP_AUTH_DIGEST_MD5
:
909 ok
= imap_cmd_login(session
, user
, pass
, "DIGEST-MD5");
911 case IMAP_AUTH_SCRAM_SHA1
:
912 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-1");
914 case IMAP_AUTH_SCRAM_SHA224
:
915 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-224");
917 case IMAP_AUTH_SCRAM_SHA256
:
918 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-256");
920 case IMAP_AUTH_SCRAM_SHA384
:
921 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-384");
923 case IMAP_AUTH_SCRAM_SHA512
:
924 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-512");
926 case IMAP_AUTH_PLAIN
:
927 ok
= imap_cmd_login(session
, user
, pass
, "PLAIN");
930 case IMAP_AUTH_OAUTH2
:
931 ok
= imap_cmd_login(session
, user
, pass
, "XOAUTH2");
934 case IMAP_AUTH_LOGIN
:
935 ok
= imap_cmd_login(session
, user
, pass
, "LOGIN");
937 case IMAP_AUTH_PLAINTEXT
:
938 ok
= imap_cmd_login(session
, user
, pass
, "plaintext");
940 case IMAP_AUTH_GSSAPI
:
941 ok
= imap_cmd_login(session
, user
, pass
, "GSSAPI");
944 debug_print("capabilities:\n"
948 "\t SCRAM-SHA-1 %d\n"
949 "\t SCRAM-SHA-224 %d\n"
950 "\t SCRAM-SHA-256 %d\n"
951 "\t SCRAM-SHA-384 %d\n"
952 "\t SCRAM-SHA-512 %d\n"
959 imap_has_capability(session
, "ANONYMOUS"),
960 imap_has_capability(session
, "CRAM-MD5"),
961 imap_has_capability(session
, "DIGEST-MD5"),
962 imap_has_capability(session
, "SCRAM-SHA-1"),
963 imap_has_capability(session
, "SCRAM-SHA-224"),
964 imap_has_capability(session
, "SCRAM-SHA-256"),
965 imap_has_capability(session
, "SCRAM-SHA-384"),
966 imap_has_capability(session
, "SCRAM-SHA-512"),
967 imap_has_capability(session
, "PLAIN"),
969 imap_has_capability(session
, "XOAUTH2"),
971 imap_has_capability(session
, "LOGIN"),
972 imap_has_capability(session
, "GSSAPI"));
973 if (imap_has_capability(session
, "CRAM-MD5"))
974 ok
= imap_cmd_login(session
, user
, pass
, "CRAM-MD5");
975 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "DIGEST-MD5"))
976 ok
= imap_cmd_login(session
, user
, pass
, "DIGEST-MD5");
977 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "SCRAM-SHA-512"))
978 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-512");
979 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "SCRAM-SHA-384"))
980 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-384");
981 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "SCRAM-SHA-256"))
982 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-256");
983 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "SCRAM-SHA-224"))
984 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-224");
985 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "SCRAM-SHA-1"))
986 ok
= imap_cmd_login(session
, user
, pass
, "SCRAM-SHA-1");
987 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "PLAIN"))
988 ok
= imap_cmd_login(session
, user
, pass
, "PLAIN");
989 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "LOGIN"))
990 ok
= imap_cmd_login(session
, user
, pass
, "LOGIN");
991 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "GSSAPI"))
992 ok
= imap_cmd_login(session
, user
, pass
, "GSSAPI");
993 if (ok
== MAILIMAP_ERROR_LOGIN
) /* we always try plaintext login before giving up */
994 ok
= imap_cmd_login(session
, user
, pass
, "plaintext");
996 if (ok
== MAILIMAP_ERROR_LOGIN
&& imap_has_capability(session
, "XOAUTH2"))
997 ok
= imap_cmd_login(session
, user
, pass
, "XOAUTH2");
1001 if (ok
== MAILIMAP_NO_ERROR
)
1002 session
->authenticated
= TRUE
;
1004 if (type
== IMAP_AUTH_CRAM_MD5
) {
1005 ext_info
= _("\n\nCRAM-MD5 logins only work if libetpan has been "
1006 "compiled with SASL support and the "
1007 "CRAM-MD5 SASL plugin is installed.");
1010 if (type
== IMAP_AUTH_DIGEST_MD5
) {
1011 ext_info
= _("\n\nDIGEST-MD5 logins only work if libetpan has been "
1012 "compiled with SASL support and the "
1013 "DIGEST-MD5 SASL plugin is installed.");
1016 if (type
== IMAP_AUTH_SCRAM_SHA1
) {
1017 ext_info
= _("\n\nSCRAM-SHA-1 logins only work if libetpan has been "
1018 "compiled with SASL support and the "
1019 "SCRAM SASL plugin is installed.");
1022 if (type
== IMAP_AUTH_SCRAM_SHA224
) {
1023 ext_info
= _("\n\nSCRAM-SHA-224 logins only work if libetpan has been "
1024 "compiled with SASL support and the "
1025 "SCRAM SASL plugin is installed.");
1028 if (type
== IMAP_AUTH_SCRAM_SHA256
) {
1029 ext_info
= _("\n\nSCRAM-SHA-256 logins only work if libetpan has been "
1030 "compiled with SASL support and the "
1031 "SCRAM SASL plugin is installed.");
1034 if (type
== IMAP_AUTH_SCRAM_SHA384
) {
1035 ext_info
= _("\n\nSCRAM-SHA-384 logins only work if libetpan has been "
1036 "compiled with SASL support and the "
1037 "SCRAM SASL plugin is installed.");
1040 if (type
== IMAP_AUTH_SCRAM_SHA512
) {
1041 ext_info
= _("\n\nSCRAM-SHA-512 logins only work if libetpan has been "
1042 "compiled with SASL support and the "
1043 "SCRAM SASL plugin is installed.");
1046 if (type
== IMAP_AUTH_PLAIN
) {
1047 ext_info
= _("\n\nPLAIN logins only work if libetpan has been "
1048 "compiled with SASL support and the "
1049 "PLAIN SASL plugin is installed.");
1052 if (type
== IMAP_AUTH_LOGIN
) {
1053 ext_info
= _("\n\nLOGIN logins only work if libetpan has been "
1054 "compiled with SASL support and the "
1055 "LOGIN SASL plugin is installed.");
1058 if (type
== IMAP_AUTH_OAUTH2
) {
1059 ext_info
= _("\n\nOAuth2 error. Check and correct your OAuth2 "
1060 "account preferences.");
1063 if (time(NULL
) - last_login_err
> 10) {
1064 if (!prefs_common
.no_recv_err_panel
) {
1065 alertpanel_error_log(_("Connection to %s failed: "
1066 "login refused.%s"),
1069 log_error(LOG_PROTOCOL
, _("Connection to %s failed: "
1070 "login refused.%s\n"),
1074 last_login_err
= time(NULL
);
1080 static IMAPSession
*imap_reconnect_if_possible(Folder
*folder
, IMAPSession
*session
)
1082 RemoteFolder
*rfolder
= REMOTE_FOLDER(folder
);
1083 /* Check if this is the first try to establish a
1084 connection, if yes we don't try to reconnect */
1085 debug_print("reconnecting\n");
1086 if (rfolder
->session
== NULL
) {
1087 log_warning(LOG_PROTOCOL
, _("Connecting to %s failed"),
1088 folder
->account
->recv_server
);
1089 SESSION(session
)->sock
= NULL
;
1090 imap_safe_destroy(session
);
1093 rfolder
->session
= NULL
;
1094 log_warning(LOG_PROTOCOL
, _("IMAP connection to %s has been"
1095 " disconnected. Reconnecting...\n"),
1096 folder
->account
->recv_server
);
1097 statusbar_print_all(_("IMAP connection to %s has been"
1098 " disconnected. Reconnecting...\n"),
1099 folder
->account
->recv_server
);
1100 SESSION(session
)->state
= SESSION_DISCONNECTED
;
1101 SESSION(session
)->sock
= NULL
;
1102 imap_safe_destroy(session
);
1103 /* Clear folders session to make imap_session_get create
1104 a new session, because of rfolder->session == NULL
1105 it will not try to reconnect again and so avoid an
1107 debug_print("getting session...\n");
1108 session
= imap_session_get(folder
);
1109 rfolder
->session
= SESSION(session
);
1110 statusbar_pop_all();
1115 static IMAPSession
*imap_session_get(Folder
*folder
)
1117 RemoteFolder
*rfolder
= REMOTE_FOLDER(folder
);
1118 IMAPSession
*session
= NULL
;
1119 gint r
= MAILIMAP_NO_ERROR
;
1121 g_return_val_if_fail(folder
!= NULL
, NULL
);
1122 g_return_val_if_fail(FOLDER_CLASS(folder
) == &imap_class
, NULL
);
1123 g_return_val_if_fail(folder
->account
!= NULL
, NULL
);
1125 if (prefs_common
.work_offline
&&
1126 !inc_offline_should_override(FALSE
,
1127 _("Claws Mail needs network access in order "
1128 "to access the IMAP server."))) {
1132 /* check for deferred destroy */
1133 if (rfolder
->session
!= NULL
) {
1134 session
= IMAP_SESSION(rfolder
->session
);
1135 if (!session
->busy
&& session
->do_destroy
) {
1136 rfolder
->session
= NULL
;
1137 imap_safe_destroy(session
);
1142 /* Make sure we have a session */
1143 if (rfolder
->session
!= NULL
&& rfolder
->session
->state
!= SESSION_DISCONNECTED
) {
1144 session
= IMAP_SESSION(rfolder
->session
);
1145 } else if (rfolder
->session
!= NULL
&& rfolder
->session
->state
== SESSION_DISCONNECTED
) {
1146 imap_safe_destroy(IMAP_SESSION(rfolder
->session
));
1147 rfolder
->session
= NULL
;
1149 } else if (rfolder
->connecting
) {
1150 debug_print("already connecting\n");
1154 imap_reset_uid_lists(folder
);
1155 if (time(NULL
) - rfolder
->last_failure
<= 2)
1157 rfolder
->connecting
= TRUE
;
1158 session
= imap_session_new(folder
, folder
->account
);
1160 if(session
== NULL
) {
1161 rfolder
->last_failure
= time(NULL
);
1162 rfolder
->connecting
= FALSE
;
1166 /* Make sure session is authenticated */
1167 if (!IMAP_SESSION(session
)->authenticated
)
1168 r
= imap_session_authenticate(IMAP_SESSION(session
), folder
->account
);
1170 if (r
!= MAILIMAP_NO_ERROR
|| (!is_fatal(r
) && !IMAP_SESSION(session
)->authenticated
)) {
1171 rfolder
->session
= NULL
;
1173 imap_threaded_disconnect(session
->folder
);
1175 SESSION(session
)->state
= SESSION_DISCONNECTED
;
1176 SESSION(session
)->sock
= NULL
;
1177 imap_safe_destroy(session
);
1178 rfolder
->last_failure
= time(NULL
);
1179 rfolder
->connecting
= FALSE
;
1183 /* I think the point of this code is to avoid sending a
1184 * keepalive if we've used the session recently and therefore
1185 * think it's still alive. Unfortunately, most of the code
1186 * does not yet check for errors on the socket, and so if the
1187 * connection drops we don't notice until the timeout expires.
1188 * A better solution than sending a NOOP every time would be
1189 * for every command to be prepared to retry until it is
1190 * successfully sent. -- mbp */
1191 if ((time(NULL
) - SESSION(session
)->last_access_time
> SESSION_TIMEOUT_INTERVAL
) || session
->cancelled
) {
1192 /* verify that the session is still alive */
1193 r
= imap_cmd_noop(session
);
1195 if (r
!= MAILIMAP_NO_ERROR
) {
1196 debug_print("disconnected!\n");
1198 session
= imap_reconnect_if_possible(folder
, session
);
1200 rfolder
->session
= NULL
;
1201 rfolder
->connecting
= FALSE
;
1202 SESSION(session
)->state
= SESSION_DISCONNECTED
;
1203 SESSION(session
)->sock
= NULL
;
1204 imap_safe_destroy(session
);
1205 session
= imap_session_get(folder
);
1209 session
->cancelled
= FALSE
;
1212 rfolder
->session
= SESSION(session
);
1213 rfolder
->connecting
= FALSE
;
1215 return IMAP_SESSION(session
);
1218 static IMAPSession
*imap_session_new(Folder
* folder
,
1219 const PrefsAccount
*account
)
1221 IMAPSession
*session
;
1222 ProxyInfo
*proxy_info
= NULL
;
1225 int authenticated
= FALSE
;
1229 /* FIXME: IMAP over SSL only... */
1232 port
= account
->set_imapport
? account
->imapport
1233 : account
->ssl_imap
== SSL_TUNNEL
? IMAPS_PORT
: IMAP4_PORT
;
1234 ssl_type
= account
->ssl_imap
;
1236 if (account
->ssl_imap
!= SSL_NONE
) {
1237 if (alertpanel_full(_("Insecure connection"),
1238 _("This connection is configured to be secured "
1239 "using TLS, but TLS is not available "
1240 "in this build of Claws Mail. \n\n"
1241 "Do you want to continue connecting to this "
1242 "server? The communication would not be "
1244 NULL
, _("_Cancel"), NULL
, _("Con_tinue connecting"), NULL
, NULL
,
1245 ALERTFOCUS_FIRST
, FALSE
, NULL
, ALERT_WARNING
) != G_ALERTALTERNATE
)
1248 port
= account
->set_imapport
? account
->imapport
1253 IMAP_FOLDER(folder
)->max_set_size
= account
->imap_batch_size
;
1254 buf
= g_strdup_printf(_("Account '%s': Connecting to IMAP server: %s:%d..."),
1255 folder
->account
->account_name
, folder
->account
->recv_server
,
1257 statusbar_print_all("%s", buf
);
1258 log_message(LOG_PROTOCOL
, "%s\n", buf
);
1261 if (account
->use_proxy
) {
1262 if (account
->use_default_proxy
) {
1263 proxy_info
= (ProxyInfo
*)&(prefs_common
.proxy_info
);
1264 if (proxy_info
->use_proxy_auth
)
1265 proxy_info
->proxy_pass
= passwd_store_get(PWS_CORE
, PWS_CORE_PROXY
,
1266 PWS_CORE_PROXY_PASS
);
1268 proxy_info
= (ProxyInfo
*)&(account
->proxy_info
);
1269 if (proxy_info
->use_proxy_auth
)
1270 proxy_info
->proxy_pass
= passwd_store_get_account(account
->account_id
,
1271 PWS_ACCOUNT_PROXY_PASS
);
1276 if (account
->set_tunnelcmd
) {
1277 r
= imap_threaded_connect_cmd(folder
,
1279 account
->recv_server
,
1287 if (ssl_type
== SSL_TUNNEL
) {
1288 r
= imap_threaded_connect_ssl(folder
,
1289 account
->recv_server
,
1296 r
= imap_threaded_connect(folder
,
1297 account
->recv_server
,
1303 statusbar_pop_all();
1304 if (r
== MAILIMAP_NO_ERROR_AUTHENTICATED
) {
1305 authenticated
= TRUE
;
1307 else if (r
== MAILIMAP_NO_ERROR_NON_AUTHENTICATED
) {
1308 authenticated
= FALSE
;
1312 if (r
== MAILIMAP_ERROR_SSL
)
1313 log_error(LOG_PROTOCOL
, _("TLS handshake failed\n"));
1316 imap_handle_error(NULL
, account
->recv_server
, r
);
1318 if(!prefs_common
.no_recv_err_panel
) {
1319 alertpanel_error_log(_("Can't connect to IMAP server: %s:%d"),
1320 account
->recv_server
, port
);
1322 log_error(LOG_PROTOCOL
, _("Can't connect to IMAP server: %s:%d\n"),
1323 account
->recv_server
, port
);
1329 session
= g_new0(IMAPSession
, 1);
1330 session_init(SESSION(session
), account
, FALSE
);
1331 SESSION(session
)->type
= SESSION_IMAP
;
1332 SESSION(session
)->server
= g_strdup(account
->recv_server
);
1333 SESSION(session
)->port
= port
;
1334 SESSION(session
)->sock
= NULL
;
1335 SESSION(session
)->proxy_info
= proxy_info
;
1336 SESSION(session
)->destroy
= imap_session_destroy
;
1338 session
->capability
= NULL
;
1339 session
->authenticated
= authenticated
;
1340 session
->mbox
= NULL
;
1341 session
->exists
= 0;
1342 session
->recent
= 0;
1343 session
->expunge
= 0;
1344 session
->cmd_count
= 0;
1345 session
->folder
= folder
;
1346 IMAP_FOLDER(session
->folder
)->last_seen_separator
= 0;
1349 if (account
->ssl_imap
== SSL_STARTTLS
) {
1352 ok
= imap_cmd_starttls(session
);
1353 if (ok
!= MAILIMAP_NO_ERROR
) {
1354 log_warning(LOG_PROTOCOL
, _("Can't start STARTTLS session.\n"));
1355 if (!is_fatal(ok
)) {
1356 SESSION(session
)->sock
= NULL
;
1357 imap_safe_destroy(session
);
1362 imap_free_capabilities(session
);
1363 session
->authenticated
= FALSE
;
1364 session
->uidplus
= FALSE
;
1365 session
->cmd_count
= 1;
1367 SESSION(session
)->use_tls_sni
= account
->use_tls_sni
;
1370 log_message(LOG_PROTOCOL
, "IMAP connection is %s-authenticated\n",
1371 (session
->authenticated
) ? "pre" : "un");
1373 session_register_ping(SESSION(session
), imap_ping
);
1378 static gint
imap_session_authenticate(IMAPSession
*session
,
1379 PrefsAccount
*account
)
1381 gchar
*pass
, *acc_pass
= NULL
;
1382 gboolean failed
= FALSE
;
1383 gint ok
= MAILIMAP_NO_ERROR
;
1384 g_return_val_if_fail(account
->userid
!= NULL
, MAILIMAP_ERROR_BAD_STATE
);
1386 if(account
->imap_auth_type
== IMAP_AUTH_OAUTH2
)
1387 oauth2_check_passwds (account
);
1389 if (!password_get(account
->userid
, account
->recv_server
, "imap",
1390 SESSION(session
)->port
, &acc_pass
)) {
1391 acc_pass
= passwd_store_get_account(account
->account_id
,
1397 if (!pass
&& account
->imap_auth_type
!= IMAP_AUTH_ANON
&& account
->imap_auth_type
!= IMAP_AUTH_GSSAPI
) {
1399 tmp_pass
= input_dialog_query_password_keep(account
->recv_server
,
1401 &(account
->session_passwd
));
1403 return MAILIMAP_NO_ERROR
;
1405 Xstrdup_a(pass
, tmp_pass
, {g_free(tmp_pass
); return MAILIMAP_NO_ERROR
;});
1407 } else if (account
->imap_auth_type
== IMAP_AUTH_ANON
|| account
->imap_auth_type
== IMAP_AUTH_GSSAPI
) {
1410 if ((ok
= imap_auth(session
, account
->userid
, pass
, account
->imap_auth_type
)) != MAILIMAP_NO_ERROR
) {
1412 if (!failed
&& !is_fatal(ok
)) {
1413 if (acc_pass
!= NULL
) {
1414 memset(acc_pass
, 0, strlen(acc_pass
));
1419 if (account
->session_passwd
!= NULL
) {
1420 g_free(account
->session_passwd
);
1421 account
->session_passwd
= NULL
;
1425 if (prefs_common
.no_recv_err_panel
) {
1426 log_error(LOG_PROTOCOL
, _("Couldn't login to IMAP server %s.\n"), account
->recv_server
);
1427 mainwindow_show_error();
1429 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account
->recv_server
);
1432 if (acc_pass
!= NULL
) {
1433 memset(acc_pass
, 0, strlen(acc_pass
));
1442 memset(acc_pass
, 0, strlen(acc_pass
));
1445 statusbar_pop_all();
1446 session
->authenticated
= TRUE
;
1447 return MAILIMAP_NO_ERROR
;
1450 static void imap_session_destroy(Session
*session
)
1452 if (session
->state
!= SESSION_DISCONNECTED
)
1453 imap_threaded_disconnect(IMAP_SESSION(session
)->folder
);
1455 imap_free_capabilities(IMAP_SESSION(session
));
1456 g_free(IMAP_SESSION(session
)->mbox
);
1459 static gchar
*imap_fetch_msg(Folder
*folder
, FolderItem
*item
, gint uid
)
1461 return imap_fetch_msg_full(folder
, item
, uid
, TRUE
, TRUE
);
1464 static guint
get_file_size_with_crs(const gchar
*filename
)
1470 if (filename
== NULL
)
1473 fp
= claws_fopen(filename
, "rb");
1477 while (claws_fgets(buf
, sizeof (buf
), fp
) != NULL
) {
1479 if (!strstr(buf
, "\r\n") && strstr(buf
, "\n"))
1487 static gchar
*imap_get_cached_filename(FolderItem
*item
, guint msgnum
)
1489 gchar
*path
, *filename
;
1491 cm_return_val_if_fail(item
!= NULL
, NULL
);
1493 path
= folder_item_get_path(item
);
1495 if (!is_dir_exist(path
)) {
1500 filename
= g_strconcat(path
, G_DIR_SEPARATOR_S
, itos(msgnum
), NULL
);
1502 if (is_dir_exist(filename
)) {
1504 filename
= g_strconcat(path
, G_DIR_SEPARATOR_S
, ".", itos(msgnum
), NULL
);
1511 static void imap_remove_cached_msg(Folder
*folder
, FolderItem
*item
, MsgInfo
*msginfo
)
1515 filename
= imap_get_cached_filename(item
, msginfo
->msgnum
);
1517 cm_return_if_fail(filename
!= NULL
);
1519 if (is_file_exist(filename
)) {
1520 claws_unlink(filename
);
1525 typedef struct _TagsData
{
1528 IMAPFolderItem
*item
;
1531 static void imap_commit_tags(FolderItem
*item
, MsgInfo
*msginfo
, GSList
*tags_set
, GSList
*tags_unset
)
1533 IMAPSession
*session
;
1534 gint ok
, can_create_tags
;
1535 Folder
*folder
= NULL
;
1536 TagsData
*ht_data
= NULL
;
1539 g_return_if_fail(item
!= NULL
);
1540 g_return_if_fail(msginfo
!= NULL
);
1542 folder
= item
->folder
;
1543 debug_print("getting session...\n");
1544 session
= imap_session_get(folder
);
1547 debug_print("can't get session\n");
1551 ok
= imap_select(session
, IMAP_FOLDER(folder
), item
,
1552 NULL
, NULL
, NULL
, NULL
, &can_create_tags
, FALSE
);
1554 if (ok
!= MAILIMAP_NO_ERROR
) {
1559 if (IMAP_FOLDER_ITEM(item
)->can_create_flags
!= ITEM_CAN_CREATE_FLAGS
)
1562 if (IMAP_FOLDER_ITEM(item
)->batching
) {
1563 /* instead of performing an UID STORE command for each message change,
1564 * as a lot of them can change "together", we just fill in hashtables
1565 * and defer the treatment so that we're able to send only one
1568 debug_print("IMAP batch mode on, deferring tags change\n");
1569 for (cur
= tags_set
; cur
; cur
= cur
->next
) {
1570 gint cur_tag
= GPOINTER_TO_INT(cur
->data
);
1572 ht_data
= g_hash_table_lookup(IMAP_FOLDER_ITEM(item
)->tags_set_table
,
1573 GINT_TO_POINTER(cur_tag
));
1574 if (ht_data
== NULL
) {
1575 ht_data
= g_new0(TagsData
, 1);
1576 ht_data
->str
= g_strdup(tags_get_tag(cur_tag
));
1577 ht_data
->item
= IMAP_FOLDER_ITEM(item
);
1578 g_hash_table_insert(IMAP_FOLDER_ITEM(item
)->tags_set_table
,
1579 GINT_TO_POINTER(cur_tag
), ht_data
);
1581 ht_data
->msglist
= g_slist_prepend(ht_data
->msglist
, GINT_TO_POINTER(msginfo
->msgnum
));
1584 for (cur
= tags_unset
; cur
; cur
= cur
->next
) {
1585 gint cur_tag
= GPOINTER_TO_INT(cur
->data
);
1587 ht_data
= g_hash_table_lookup(IMAP_FOLDER_ITEM(item
)->tags_unset_table
,
1588 GINT_TO_POINTER(cur_tag
));
1589 if (ht_data
== NULL
) {
1590 ht_data
= g_new0(TagsData
, 1);
1591 ht_data
->str
= g_strdup(tags_get_tag(cur_tag
));
1592 ht_data
->item
= IMAP_FOLDER_ITEM(item
);
1593 g_hash_table_insert(IMAP_FOLDER_ITEM(item
)->tags_unset_table
,
1594 GINT_TO_POINTER(cur_tag
), ht_data
);
1596 ht_data
->msglist
= g_slist_prepend(ht_data
->msglist
, GINT_TO_POINTER(msginfo
->msgnum
));
1600 GSList
*list_set
= NULL
;
1601 GSList
*list_unset
= NULL
;
1604 numlist
.data
= GINT_TO_POINTER(msginfo
->msgnum
);
1605 numlist
.next
= NULL
;
1607 debug_print("IMAP changing tags NOW\n");
1608 for (cur
= tags_set
; cur
; cur
= cur
->next
) {
1609 gint cur_tag
= GPOINTER_TO_INT(cur
->data
);
1610 const gchar
*str
= tags_get_tag(cur_tag
);
1611 if (IS_NOT_RESERVED_TAG(str
))
1612 list_set
= g_slist_prepend(list_set
, g_strdup(str
));
1615 ok
= imap_set_message_flags(session
,
1616 IMAP_FOLDER_ITEM(item
), &numlist
, 0, list_set
, TRUE
);
1617 slist_free_strings_full(list_set
);
1618 if (ok
!= MAILIMAP_NO_ERROR
) {
1623 for (cur
= tags_unset
; cur
; cur
= cur
->next
) {
1624 gint cur_tag
= GPOINTER_TO_INT(cur
->data
);
1625 const gchar
*str
= tags_get_tag(cur_tag
);
1626 if (IS_NOT_RESERVED_TAG(str
))
1627 list_unset
= g_slist_prepend(list_unset
, g_strdup(str
));
1630 ok
= imap_set_message_flags(session
,
1631 IMAP_FOLDER_ITEM(item
), &numlist
, 0, list_unset
, FALSE
);
1632 slist_free_strings_full(list_unset
);
1633 if (ok
!= MAILIMAP_NO_ERROR
) {
1640 static gchar
*imap_fetch_msg_full(Folder
*folder
, FolderItem
*item
, gint uid
,
1641 gboolean headers
, gboolean body
)
1643 gchar
*path
, *filename
;
1644 IMAPSession
*session
;
1647 g_return_val_if_fail(folder
!= NULL
, NULL
);
1648 g_return_val_if_fail(item
!= NULL
, NULL
);
1653 path
= folder_item_get_path(item
);
1654 if (!is_dir_exist(path
)) {
1655 if(is_file_exist(path
))
1657 make_dir_hier(path
);
1661 filename
= imap_get_cached_filename(item
, uid
);
1662 debug_print("trying to fetch cached %s\n", filename
);
1664 if (is_file_exist(filename
)) {
1665 /* see whether the local file represents the whole message
1666 * or not. As the IMAP server reports size with \r chars,
1667 * we have to update the local file (UNIX \n only) size */
1668 MsgInfo
*cached
= msgcache_get_msg(item
->cache
,uid
);
1669 guint have_size
= -1;
1672 debug_print("message %d has been already %scached.\n", uid
,
1673 MSG_IS_FULLY_CACHED(cached
->flags
) ? "fully ":"");
1675 if (!cached
|| !MSG_IS_FULLY_CACHED(cached
->flags
)) {
1676 have_size
= get_file_size_with_crs(filename
);
1677 if (cached
&& (cached
->size
<= have_size
|| !body
)) {
1678 ok
= file_strip_crs(filename
);
1679 if (ok
== 0 && cached
&& cached
->size
<= have_size
) {
1680 /* we have it all and stripped */
1681 debug_print("...fully cached in fact (%u/%"G_GOFFSET_FORMAT
"); setting flag.\n",
1682 have_size
, cached
->size
);
1683 procmsg_msginfo_set_flags(cached
, MSG_FULLY_CACHED
, 0);
1685 procmsg_msginfo_free(&cached
);
1687 } else if (!cached
&& time(NULL
) - get_file_mtime(filename
) < 60) {
1688 debug_print("message not cached and file recent, considering file complete\n");
1689 ok
= file_strip_crs(filename
);
1693 procmsg_msginfo_free(&cached
);
1696 if (cached
&& MSG_IS_FULLY_CACHED(cached
->flags
)) {
1697 procmsg_msginfo_free(&cached
);
1701 MsgInfo
*cached
= msgcache_get_msg(item
->cache
,uid
);
1703 procmsg_msginfo_unset_flags(cached
, MSG_FULLY_CACHED
, 0);
1704 procmsg_msginfo_free(&cached
);
1708 debug_print("getting session...\n");
1709 session
= imap_session_get(folder
);
1715 session_set_access_time(SESSION(session
));
1716 lock_session(session
); /* unlocked later in the function */
1718 debug_print("IMAP fetching messages\n");
1719 ok
= imap_select(session
, IMAP_FOLDER(folder
), item
,
1720 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
1721 if (ok
!= MAILIMAP_NO_ERROR
) {
1722 g_warning("can't select mailbox %s", item
->path
);
1727 session_set_access_time(SESSION(session
));
1729 debug_print("getting message %d...\n", uid
);
1730 ok
= imap_cmd_fetch(session
, (guint32
)uid
, filename
, headers
, body
);
1732 if (ok
!= MAILIMAP_NO_ERROR
) {
1733 g_warning("can't fetch message %d", uid
);
1738 session_set_access_time(SESSION(session
));
1739 unlock_session(session
);
1741 ok
= file_strip_crs(filename
);
1743 if (ok
== 0 && headers
&& body
) {
1744 MsgInfo
*cached
= msgcache_get_msg(item
->cache
,uid
);
1746 procmsg_msginfo_set_flags(cached
, MSG_FULLY_CACHED
, 0);
1747 procmsg_msginfo_free(&cached
);
1749 } else if (ok
== -1) {
1750 MsgInfo
*cached
= msgcache_get_msg(item
->cache
,uid
);
1752 procmsg_msginfo_unset_flags(cached
, MSG_FULLY_CACHED
, 0);
1753 procmsg_msginfo_free(&cached
);
1759 static gboolean
imap_is_msg_fully_cached(Folder
*folder
, FolderItem
*item
, gint uid
)
1763 MsgInfo
*cached
= msgcache_get_msg(item
->cache
,uid
);
1768 if (MSG_IS_FULLY_CACHED(cached
->flags
)) {
1769 procmsg_msginfo_free(&cached
);
1773 filename
= imap_get_cached_filename(item
, uid
);
1775 if (is_file_exist(filename
)) {
1776 if (cached
&& cached
->total_size
== cached
->size
) {
1779 procmsg_msginfo_set_flags(cached
, MSG_FULLY_CACHED
, 0);
1782 size
= get_file_size_with_crs(filename
);
1785 debug_print("msg %d cached, has size %d, full should be %"G_GOFFSET_FORMAT
".\n", uid
, size
, cached
->size
);
1786 if (cached
&& size
>= cached
->size
) {
1787 cached
->total_size
= cached
->size
;
1788 procmsg_msginfo_set_flags(cached
, MSG_FULLY_CACHED
, 0);
1789 procmsg_msginfo_free(&cached
);
1793 procmsg_msginfo_free(&cached
);
1797 void imap_cache_msg(FolderItem
*item
, gint msgnum
)
1799 Folder
*folder
= NULL
;
1803 folder
= item
->folder
;
1805 if (!imap_is_msg_fully_cached(folder
, item
, msgnum
)) {
1806 gchar
*tmp
= imap_fetch_msg_full(folder
, item
, msgnum
, TRUE
, TRUE
);
1807 debug_print("fetched %s\n", tmp
);
1812 static gint
imap_add_msg(Folder
*folder
, FolderItem
*dest
,
1813 const gchar
*file
, MsgFlags
*flags
)
1817 MsgFileInfo fileinfo
;
1819 g_return_val_if_fail(file
!= NULL
, -1);
1821 fileinfo
.msginfo
= NULL
;
1822 fileinfo
.file
= (gchar
*)file
;
1823 fileinfo
.flags
= flags
;
1824 file_list
.data
= &fileinfo
;
1825 file_list
.next
= NULL
;
1827 ret
= imap_add_msgs(folder
, dest
, &file_list
, NULL
);
1831 static gint
imap_add_msgs(Folder
*folder
, FolderItem
*dest
, GSList
*file_list
,
1832 GHashTable
*relation
)
1835 IMAPSession
*session
;
1836 guint32 last_uid
= 0;
1838 MsgFileInfo
*fileinfo
;
1839 gint ok
= MAILIMAP_NO_ERROR
;
1840 gint curnum
= 0, total
= 0;
1841 gboolean missing_uids
= FALSE
;
1843 g_return_val_if_fail(folder
!= NULL
, -1);
1844 g_return_val_if_fail(dest
!= NULL
, -1);
1845 g_return_val_if_fail(file_list
!= NULL
, -1);
1847 debug_print("getting session...\n");
1848 session
= imap_session_get(folder
);
1852 destdir
= imap_get_real_path(session
, IMAP_FOLDER(folder
), dest
->path
, &ok
);
1857 statusbar_print_all(_("Adding messages..."));
1858 total
= g_slist_length(file_list
);
1859 for (cur
= file_list
; cur
!= NULL
; cur
= cur
->next
) {
1860 IMAPFlags iflags
= 0;
1861 guint32 new_uid
= 0;
1862 gchar
*real_file
= NULL
;
1863 fileinfo
= (MsgFileInfo
*)cur
->data
;
1865 statusbar_progress_all(curnum
, total
, total
< 10 ? 1:10);
1868 if (fileinfo
->flags
) {
1869 if (MSG_IS_MARKED(*fileinfo
->flags
))
1870 iflags
|= IMAP_FLAG_FLAGGED
;
1871 if (MSG_IS_REPLIED(*fileinfo
->flags
))
1872 iflags
|= IMAP_FLAG_ANSWERED
;
1873 if (MSG_IS_FORWARDED(*fileinfo
->flags
))
1874 iflags
|= IMAP_FLAG_FORWARDED
;
1875 if (MSG_IS_SPAM(*fileinfo
->flags
))
1876 iflags
|= IMAP_FLAG_SPAM
;
1878 iflags
|= IMAP_FLAG_HAM
;
1879 if (!MSG_IS_UNREAD(*fileinfo
->flags
))
1880 iflags
|= IMAP_FLAG_SEEN
;
1884 if (real_file
== NULL
)
1885 real_file
= g_strdup(fileinfo
->file
);
1887 if (folder_has_parent_of_type(dest
, F_QUEUE
) ||
1888 folder_has_parent_of_type(dest
, F_OUTBOX
) ||
1889 folder_has_parent_of_type(dest
, F_DRAFT
) ||
1890 folder_has_parent_of_type(dest
, F_TRASH
))
1891 iflags
|= IMAP_FLAG_SEEN
;
1893 ok
= imap_cmd_append(session
, IMAP_FOLDER_ITEM(dest
), destdir
, real_file
, iflags
,
1896 if (ok
!= MAILIMAP_NO_ERROR
) {
1897 g_warning("can't append message %s", real_file
);
1900 statusbar_progress_all(0,0,0);
1901 statusbar_pop_all();
1904 debug_print("appended new message as %d\n", new_uid
);
1905 /* put the local file in the imapcache, so that we don't
1906 * have to fetch it back later. */
1909 missing_uids
= TRUE
;
1910 debug_print("Missing UID (0)\n");
1913 gchar
*cache_path
= folder_item_get_path(dest
);
1914 if (!is_dir_exist(cache_path
))
1915 make_dir_hier(cache_path
);
1916 if (is_dir_exist(cache_path
)) {
1917 gchar
*cache_file
= g_strconcat(
1918 cache_path
, G_DIR_SEPARATOR_S
,
1919 itos(new_uid
), NULL
);
1920 copy_file(real_file
, cache_file
, TRUE
);
1921 debug_print("got UID %d, copied to cache: %s\n", new_uid
, cache_file
);
1928 if (relation
!= NULL
)
1929 g_hash_table_insert(relation
, fileinfo
->msginfo
!= NULL
?
1930 (gpointer
) fileinfo
->msginfo
: (gpointer
) fileinfo
,
1931 GINT_TO_POINTER(new_uid
));
1932 if (last_uid
< new_uid
) {
1939 statusbar_progress_all(0,0,0);
1940 statusbar_pop_all();
1945 imap_scan_required(folder
, dest
);
1947 session
= imap_session_get(folder
);
1953 ok
= imap_select(session
, IMAP_FOLDER(folder
), dest
,
1954 &a
, NULL
, NULL
, NULL
, NULL
, FALSE
);
1959 static GSList
*flatten_mailimap_set(struct mailimap_set
* set
)
1961 GSList
*result
= NULL
;
1963 guint32 start
, end
, t
;
1966 if (!set
|| !set
->set_list
)
1969 for (list
= clist_begin(set
->set_list
); list
; list
= clist_next(list
)) {
1970 struct mailimap_set_item
*item
= (struct mailimap_set_item
*)clist_content(list
);
1971 start
= item
->set_first
;
1972 end
= item
->set_last
;
1974 for (t
= start
; t
<= end
; t
++) {
1975 result
= g_slist_prepend(result
, GINT_TO_POINTER(t
));
1979 result
= g_slist_reverse(result
);
1980 if (debug_get_mode()) {
1981 debug_print("flat imap set: ");
1982 for (cur
= result
; cur
; cur
= cur
->next
) {
1983 debug_print("%d ", GPOINTER_TO_INT(cur
->data
));
1990 static gint
imap_do_copy_msgs(Folder
*folder
, FolderItem
*dest
,
1991 MsgInfoList
*msglist
, GHashTable
*relation
,
1992 gboolean same_dest_ok
)
1996 GSList
*seq_list
, *cur
;
1998 IMAPSession
*session
;
1999 gint ok
= MAILIMAP_NO_ERROR
;
2000 GHashTable
*uid_hash
;
2003 g_return_val_if_fail(folder
!= NULL
, -1);
2004 g_return_val_if_fail(dest
!= NULL
, -1);
2005 g_return_val_if_fail(msglist
!= NULL
, -1);
2007 debug_print("getting session...\n");
2008 session
= imap_session_get(folder
);
2014 msginfo
= (MsgInfo
*)msglist
->data
;
2015 src
= msginfo
->folder
;
2016 if (!same_dest_ok
&& src
== dest
) {
2017 g_warning("the src folder is identical to the dest");
2021 if (src
->folder
!= dest
->folder
) {
2022 GSList
*infolist
= NULL
, *cur
;
2024 for (cur
= msglist
; cur
; cur
= cur
->next
) {
2025 msginfo
= (MsgInfo
*)cur
->data
;
2026 MsgFileInfo
*fileinfo
= g_new0(MsgFileInfo
, 1);
2027 fileinfo
->file
= procmsg_get_message_file(msginfo
);
2028 fileinfo
->flags
= &(msginfo
->flags
);
2029 infolist
= g_slist_prepend(infolist
, fileinfo
);
2031 infolist
= g_slist_reverse(infolist
);
2032 res
= folder_item_add_msgs(dest
, infolist
, FALSE
);
2033 for (cur
= infolist
; cur
; cur
= cur
->next
) {
2034 MsgFileInfo
*info
= (MsgFileInfo
*)cur
->data
;
2038 g_slist_free(infolist
);
2042 lock_session(session
); /* unlocked later in the function */
2044 ok
= imap_select(session
, IMAP_FOLDER(folder
), msginfo
->folder
,
2045 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
2046 if (ok
!= MAILIMAP_NO_ERROR
) {
2050 unlock_session(session
);
2052 destdir
= imap_get_real_path(session
, IMAP_FOLDER(folder
), dest
->path
, &ok
);
2059 seq_list
= imap_get_lep_set_from_msglist(IMAP_FOLDER(folder
), msglist
);
2060 uid_hash
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
2062 statusbar_print_all(_("Copying messages..."));
2063 for (cur
= seq_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
2064 struct mailimap_set
* seq_set
;
2065 struct mailimap_set
* source
= NULL
;
2066 struct mailimap_set
* dest
= NULL
;
2067 seq_set
= cur
->data
;
2069 debug_print("Copying messages from %s to %s ...\n",
2070 src
->path
, destdir
);
2072 lock_session(session
); /* unlocked later in the function */
2073 ok
= imap_cmd_copy(session
, seq_set
, destdir
,
2080 if (ok
== MAILIMAP_NO_ERROR
) {
2081 unlock_session(session
);
2082 if (relation
&& source
&& dest
) {
2083 GSList
*s_list
= flatten_mailimap_set(source
);
2084 GSList
*d_list
= flatten_mailimap_set(dest
);
2085 GSList
*s_cur
, *d_cur
;
2086 if (g_slist_length(s_list
) == g_slist_length(d_list
)) {
2088 for (s_cur
= s_list
, d_cur
= d_list
;
2090 s_cur
= s_cur
->next
, d_cur
= d_cur
->next
) {
2091 g_hash_table_insert(uid_hash
, s_cur
->data
, d_cur
->data
);
2095 debug_print("hhhmm, source list length != dest list length.\n");
2097 g_slist_free(s_list
);
2098 g_slist_free(d_list
);
2104 mailimap_set_free(source
);
2106 mailimap_set_free(dest
);
2108 if (ok
!= MAILIMAP_NO_ERROR
) {
2109 g_hash_table_destroy(uid_hash
);
2110 imap_lep_set_free(seq_list
);
2111 statusbar_pop_all();
2116 for (cur
= msglist
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
2117 MsgInfo
*msginfo
= (MsgInfo
*)cur
->data
;
2120 hashval
= g_hash_table_lookup(uid_hash
, GINT_TO_POINTER(msginfo
->msgnum
));
2122 if (hashval
!= NULL
) {
2123 gint num
= GPOINTER_TO_INT(hashval
);
2124 g_hash_table_insert(relation
, msginfo
,
2125 GINT_TO_POINTER(num
));
2128 debug_print("copied message %d as %d\n", msginfo
->msgnum
, num
);
2129 /* put the local file in the imapcache, so that we don't
2130 * have to fetch it back later. */
2132 gchar
*cache_path
= folder_item_get_path(msginfo
->folder
);
2133 gchar
*real_file
= g_strconcat(
2134 cache_path
, G_DIR_SEPARATOR_S
,
2135 itos(msginfo
->msgnum
), NULL
);
2136 gchar
*cache_file
= NULL
;
2138 cache_path
= folder_item_get_path(dest
);
2139 cache_file
= g_strconcat(
2140 cache_path
, G_DIR_SEPARATOR_S
,
2142 if (!is_dir_exist(cache_path
))
2143 make_dir_hier(cache_path
);
2144 if (is_file_exist(real_file
) && is_dir_exist(cache_path
)) {
2145 if (copy_file(real_file
, cache_file
, TRUE
) < 0)
2146 debug_print("couldn't cache to %s: %s\n", cache_file
,
2149 debug_print("copied to cache: %s\n", cache_file
);
2156 g_hash_table_insert(relation
, msginfo
,
2157 GINT_TO_POINTER(0));
2159 statusbar_pop_all();
2161 g_hash_table_destroy(uid_hash
);
2162 imap_lep_set_free(seq_list
);
2166 IMAP_FOLDER_ITEM(dest
)->lastuid
= 0;
2167 IMAP_FOLDER_ITEM(dest
)->uid_next
= 0;
2168 g_slist_free(IMAP_FOLDER_ITEM(dest
)->uid_list
);
2169 IMAP_FOLDER_ITEM(dest
)->uid_list
= NULL
;
2171 imap_scan_required(folder
, dest
);
2172 if (ok
== MAILIMAP_NO_ERROR
)
2178 static gint
imap_copy_msg(Folder
*folder
, FolderItem
*dest
, MsgInfo
*msginfo
)
2182 g_return_val_if_fail(msginfo
!= NULL
, -1);
2184 msglist
.data
= msginfo
;
2185 msglist
.next
= NULL
;
2187 return imap_copy_msgs(folder
, dest
, &msglist
, NULL
);
2190 static gint
imap_copy_msgs(Folder
*folder
, FolderItem
*dest
,
2191 MsgInfoList
*msglist
, GHashTable
*relation
)
2196 g_return_val_if_fail(folder
!= NULL
, -1);
2197 g_return_val_if_fail(dest
!= NULL
, -1);
2198 g_return_val_if_fail(msglist
!= NULL
, -1);
2200 msginfo
= (MsgInfo
*)msglist
->data
;
2201 g_return_val_if_fail(msginfo
->folder
!= NULL
, -1);
2203 ret
= imap_do_copy_msgs(folder
, dest
, msglist
, relation
, FALSE
);
2207 static gboolean
imap_matcher_type_is_local(gint matchertype
)
2209 switch (matchertype
) {
2210 case MATCHCRITERIA_FROM
:
2211 case MATCHCRITERIA_TO
:
2212 case MATCHCRITERIA_CC
:
2213 case MATCHCRITERIA_TO_OR_CC
:
2214 case MATCHCRITERIA_SUBJECT
:
2215 case MATCHCRITERIA_REFERENCES
:
2216 case MATCHCRITERIA_MESSAGEID
:
2217 case MATCHCRITERIA_INREPLYTO
:
2218 case MATCHCRITERIA_AGE_GREATER
:
2219 case MATCHCRITERIA_AGE_LOWER
:
2220 case MATCHCRITERIA_FORWARDED
:
2221 case MATCHCRITERIA_SPAM
:
2222 case MATCHCRITERIA_UNREAD
:
2223 case MATCHCRITERIA_NEW
:
2224 case MATCHCRITERIA_MARKED
:
2225 case MATCHCRITERIA_REPLIED
:
2226 case MATCHCRITERIA_DELETED
:
2227 case MATCHCRITERIA_SIZE_GREATER
:
2228 case MATCHCRITERIA_SIZE_SMALLER
:
2229 case MATCHCRITERIA_SIZE_EQUAL
:
2235 static IMAPSearchKey
* search_make_key(MatcherProp
* match
, gboolean
* is_all
)
2237 if (match
->matchtype
== MATCHTYPE_MATCHCASE
|| match
->matchtype
== MATCHTYPE_MATCH
) {
2238 IMAPSearchKey
* result
= NULL
;
2239 gboolean invert
= FALSE
;
2240 gint matchertype
= match
->criteria
;
2246 switch (matchertype
) {
2247 case MATCHCRITERIA_NOT_NEW
: invert
= TRUE
; matchertype
= MATCHCRITERIA_NEW
; break;
2248 case MATCHCRITERIA_NOT_MARKED
: invert
= TRUE
; matchertype
= MATCHCRITERIA_MARKED
; break;
2249 case MATCHCRITERIA_NOT_FORWARDED
: invert
= TRUE
; matchertype
= MATCHCRITERIA_FORWARDED
; break;
2250 case MATCHCRITERIA_NOT_SPAM
: invert
= TRUE
; matchertype
= MATCHCRITERIA_SPAM
; break;
2251 case MATCHCRITERIA_NOT_SUBJECT
: invert
= TRUE
; matchertype
= MATCHCRITERIA_SUBJECT
; break;
2252 case MATCHCRITERIA_NOT_FROM
: invert
= TRUE
; matchertype
= MATCHCRITERIA_FROM
; break;
2253 case MATCHCRITERIA_NOT_TO
: invert
= TRUE
; matchertype
= MATCHCRITERIA_TO
; break;
2254 case MATCHCRITERIA_NOT_CC
: invert
= TRUE
; matchertype
= MATCHCRITERIA_CC
; break;
2255 case MATCHCRITERIA_NOT_REFERENCES
: invert
= TRUE
; matchertype
= MATCHCRITERIA_REFERENCES
; break;
2256 case MATCHCRITERIA_NOT_HEADER
: invert
= TRUE
; matchertype
= MATCHCRITERIA_HEADER
; break;
2257 case MATCHCRITERIA_NOT_TAG
: invert
= TRUE
; matchertype
= MATCHCRITERIA_TAG
; break;
2258 case MATCHCRITERIA_NOT_HEADERS_PART
: invert
= TRUE
; matchertype
= MATCHCRITERIA_HEADERS_PART
; break;
2259 case MATCHCRITERIA_NOT_HEADERS_CONT
: invert
= TRUE
; matchertype
= MATCHCRITERIA_HEADERS_CONT
; break;
2260 case MATCHCRITERIA_NOT_MESSAGE
: invert
= TRUE
; matchertype
= MATCHCRITERIA_MESSAGE
; break;
2261 case MATCHCRITERIA_NOT_BODY_PART
: invert
= TRUE
; matchertype
= MATCHCRITERIA_BODY_PART
; break;
2262 case MATCHCRITERIA_NOT_TO_AND_NOT_CC
: invert
= TRUE
; matchertype
= MATCHCRITERIA_TO_OR_CC
; break;
2263 case MATCHCRITERIA_NOT_MESSAGEID
: invert
= TRUE
; matchertype
= MATCHCRITERIA_MESSAGEID
; break;
2264 case MATCHCRITERIA_NOT_INREPLYTO
: invert
= TRUE
; matchertype
= MATCHCRITERIA_INREPLYTO
; break;
2268 * this aborts conversion even for predicates understood by the following code.
2269 * while that might seem wasteful, claws local search for information listed below
2270 * has proven faster than IMAP search plus network roundtrips. once this changes,
2271 * consider removing these exceptions.
2273 if (imap_matcher_type_is_local(matchertype
))
2276 /* the Message-ID header is also cached */
2277 if (matchertype
== MATCHCRITERIA_HEADER
&& g_strcmp0("Message-ID", match
->header
) == 0) {
2281 switch (matchertype
) {
2282 case MATCHCRITERIA_FORWARDED
:
2283 result
= imap_search_new(IMAP_SEARCH_CRITERIA_TAG
, NULL
, RTAG_FORWARDED
, 0);
2286 case MATCHCRITERIA_SPAM
:
2287 result
= imap_search_new(IMAP_SEARCH_CRITERIA_TAG
, NULL
, RTAG_JUNK
, 0);
2290 case MATCHCRITERIA_MESSAGEID
:
2291 result
= imap_search_new(IMAP_SEARCH_CRITERIA_HEADER
, "Message-ID", match
->expr
, 0);
2294 case MATCHCRITERIA_INREPLYTO
:
2295 result
= imap_search_new(IMAP_SEARCH_CRITERIA_HEADER
, "In-Reply-To", match
->expr
, 0);
2298 case MATCHCRITERIA_REFERENCES
:
2299 result
= imap_search_new(IMAP_SEARCH_CRITERIA_HEADER
, "References", match
->expr
, 0);
2302 case MATCHCRITERIA_TO_OR_CC
:
2303 result
= imap_search_or(
2304 imap_search_new(IMAP_SEARCH_CRITERIA_TO
, NULL
, match
->expr
, 0),
2305 imap_search_new(IMAP_SEARCH_CRITERIA_CC
, NULL
, match
->expr
, 0)
2309 case MATCHCRITERIA_HEADERS_PART
:
2310 case MATCHCRITERIA_HEADERS_CONT
:
2311 result
= imap_search_and(
2312 imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_BODY
, NULL
, match
->expr
, 0)),
2313 imap_search_new(IMAP_SEARCH_CRITERIA_MESSAGE
, NULL
, match
->expr
, 0)
2317 case MATCHCRITERIA_SIZE_EQUAL
:
2318 result
= imap_search_and(
2319 imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_SMALLER
, NULL
, NULL
, match
->value
)),
2320 imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_GREATER
, NULL
, NULL
, match
->value
))
2324 case MATCHCRITERIA_NOT_UNREAD
:
2325 result
= imap_search_new(IMAP_SEARCH_CRITERIA_READ
, NULL
, NULL
, 0);
2328 case MATCHCRITERIA_UNREAD
:
2329 result
= imap_search_new(IMAP_SEARCH_CRITERIA_UNREAD
, NULL
, NULL
, 0);
2332 case MATCHCRITERIA_NEW
:
2333 result
= imap_search_new(IMAP_SEARCH_CRITERIA_NEW
, NULL
, NULL
, 0);
2336 case MATCHCRITERIA_MARKED
:
2337 result
= imap_search_new(IMAP_SEARCH_CRITERIA_MARKED
, NULL
, NULL
, 0);
2340 case MATCHCRITERIA_DELETED
:
2341 result
= imap_search_new(IMAP_SEARCH_CRITERIA_DELETED
, NULL
, NULL
, 0);
2344 case MATCHCRITERIA_REPLIED
:
2345 result
= imap_search_new(IMAP_SEARCH_CRITERIA_REPLIED
, NULL
, NULL
, 0);
2348 case MATCHCRITERIA_TAG
:
2350 gchar
*tmp
= imap_utf8_to_modified_utf7(match
->expr
, TRUE
);
2351 result
= imap_search_new(IMAP_SEARCH_CRITERIA_TAG
, NULL
, tmp
, 0);
2356 case MATCHCRITERIA_SUBJECT
:
2357 result
= imap_search_new(IMAP_SEARCH_CRITERIA_SUBJECT
, NULL
, match
->expr
, 0);
2360 case MATCHCRITERIA_FROM
:
2361 result
= imap_search_new(IMAP_SEARCH_CRITERIA_FROM
, NULL
, match
->expr
, 0);
2364 case MATCHCRITERIA_TO
:
2365 result
= imap_search_new(IMAP_SEARCH_CRITERIA_TO
, NULL
, match
->expr
, 0);
2368 case MATCHCRITERIA_CC
:
2369 result
= imap_search_new(IMAP_SEARCH_CRITERIA_CC
, NULL
, match
->expr
, 0);
2372 case MATCHCRITERIA_AGE_GREATER
:
2373 result
= imap_search_new(IMAP_SEARCH_CRITERIA_AGE_GREATER
, NULL
, NULL
, match
->value
);
2376 case MATCHCRITERIA_AGE_LOWER
:
2377 result
= imap_search_new(IMAP_SEARCH_CRITERIA_AGE_LOWER
, NULL
, NULL
, match
->value
);
2380 case MATCHCRITERIA_BODY_PART
:
2381 result
= imap_search_new(IMAP_SEARCH_CRITERIA_BODY
, NULL
, match
->expr
, 0);
2384 case MATCHCRITERIA_MESSAGE
:
2385 result
= imap_search_new(IMAP_SEARCH_CRITERIA_MESSAGE
, NULL
, match
->expr
, 0);
2388 case MATCHCRITERIA_HEADER
:
2389 result
= imap_search_new(IMAP_SEARCH_CRITERIA_HEADER
, match
->header
, match
->expr
, 0);
2392 case MATCHCRITERIA_SIZE_GREATER
:
2393 result
= imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_GREATER
, NULL
, NULL
, match
->value
);
2396 case MATCHCRITERIA_SIZE_SMALLER
:
2397 result
= imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_SMALLER
, NULL
, NULL
, match
->value
);
2401 result
= imap_search_new(IMAP_SEARCH_CRITERIA_ALL
, NULL
, NULL
, 0);
2409 result
= imap_search_not(result
);
2410 if (is_all
&& *is_all
) {
2421 static void imap_change_search_charset(IMAPFolder
*folder
)
2423 /* If server supports charset in searches, but the last used one failed,
2424 * changed to the next preferred charset. If none are still available,
2425 * disable charset searches.
2426 * Charsets are tried in the following order:
2427 * UTF-8, locale's charset, UTF-7.
2430 if (folder
->search_charset_supported
) {
2431 if (folder
->search_charset
&& !strcmp(folder
->search_charset
, conv_get_locale_charset_str_no_utf8()))
2432 folder
->search_charset
= "UTF-8";
2433 else if (folder
->search_charset
&& !strcmp(folder
->search_charset
, "UTF-8"))
2434 folder
->search_charset
= "UTF-7";
2436 folder
->search_charset
= NULL
;
2437 folder
->search_charset_supported
= FALSE
;
2442 static MatcherProp
*imap_matcher_prop_set_charset(IMAPFolder
*folder
,
2443 MatcherProp
*utf8_prop
,
2446 /* If the match is going to be done locally, or the criteria is on
2447 * tag (special-cased to modified-UTF-7), or the expression searched
2448 * is ASCII, don't bother converting.
2450 if (imap_matcher_type_is_local(utf8_prop
->criteria
)
2451 || utf8_prop
->criteria
== MATCHCRITERIA_TAG
2452 || utf8_prop
->criteria
== MATCHCRITERIA_NOT_TAG
2453 || utf8_prop
->expr
== NULL
2454 || is_ascii_str(utf8_prop
->expr
))
2455 return matcherprop_new(utf8_prop
->criteria
,
2457 utf8_prop
->matchtype
,
2461 gchar
*conv_expr
= NULL
;
2463 /* If the search is server-side and the server doesn't support
2464 * searching with the charsets we handle, bail out.
2466 if (folder
->search_charset_supported
== FALSE
)
2469 /* Else, convert. */
2470 if (*charset
== NULL
)
2471 *charset
= g_strdup(folder
->search_charset
);
2473 conv_expr
= conv_codeset_strdup(utf8_prop
->expr
, CS_UTF_8
, *charset
);
2475 if (conv_expr
== NULL
)
2476 conv_expr
= g_strdup(utf8_prop
->expr
);
2478 return matcherprop_new(utf8_prop
->criteria
,
2480 utf8_prop
->matchtype
,
2486 static gint
search_msgs (Folder
*folder
,
2487 FolderItem
*container
,
2488 MsgNumberList
**msgs
,
2489 gboolean
*on_server
,
2490 MatcherList
*predicate
,
2491 SearchProgressNotify progress_cb
,
2492 gpointer progress_data
)
2494 IMAPSearchKey
* key
= NULL
;
2497 clist
* uidlist
= NULL
;
2498 gboolean server_filtering_useless
= FALSE
;
2499 IMAPSession
*session
;
2500 gchar
*charset_to_use
= NULL
;
2502 if (on_server
== NULL
|| !*on_server
) {
2503 return folder_item_search_msgs_local(folder
, container
, msgs
, on_server
,
2504 predicate
, progress_cb
, progress_data
);
2507 for (cur
= predicate
->matchers
; cur
!= NULL
; cur
= cur
->next
) {
2508 IMAPSearchKey
* matcherPart
= NULL
;
2509 MatcherProp
* prop
= (MatcherProp
*) cur
->data
;
2511 MatcherProp
*imap_prop
= imap_matcher_prop_set_charset(IMAP_FOLDER(folder
), prop
, &charset_to_use
);
2513 if (imap_prop
== NULL
) {
2514 /* Couldn't convert matcherprop to IMAP - probably not ascii
2515 * and server doesn't support the charsets we do. */
2519 matcherPart
= search_make_key(imap_prop
, &is_all
);
2521 matcherprop_free(imap_prop
);
2524 *on_server
&= matcherPart
!= NULL
&& prop
->matchtype
== MATCHTYPE_MATCHCASE
;
2530 server_filtering_useless
= is_all
;
2531 } else if (predicate
->bool_and
) {
2532 key
= imap_search_and(key
, matcherPart
);
2533 server_filtering_useless
&= is_all
;
2535 key
= imap_search_or(key
, matcherPart
);
2536 server_filtering_useless
|= is_all
;
2541 if (server_filtering_useless
) {
2542 imap_search_free(key
);
2546 if (key
== NULL
&& progress_cb
!= NULL
) {
2551 progress_cb(progress_data
, TRUE
, 0, 0, container
->total_msgs
);
2552 progress_cb(progress_data
, TRUE
, container
->total_msgs
, 0, container
->total_msgs
);
2554 list
= folder_item_get_msg_list(container
);
2555 for (cur
= list
; cur
!= NULL
; cur
= cur
->next
) {
2556 *msgs
= g_slist_prepend(*msgs
, GUINT_TO_POINTER(((MsgInfo
*) cur
->data
)->msgnum
));
2559 procmsg_msg_list_free(list
);
2561 *msgs
= g_slist_reverse(*msgs
);
2566 session
= imap_session_get(folder
);
2570 result
= imap_select(session
, IMAP_FOLDER(folder
), FOLDER_ITEM(container
),
2571 NULL
, NULL
, NULL
, NULL
, NULL
, TRUE
);
2572 if (result
!= MAILIMAP_NO_ERROR
)
2576 progress_cb(progress_data
, TRUE
, 0, 0, container
->total_msgs
);
2577 result
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_KEYED
, key
, charset_to_use
, NULL
, &uidlist
);
2579 progress_cb(progress_data
, TRUE
, container
->total_msgs
, 0, container
->total_msgs
);
2581 if (result
== MAILIMAP_ERROR_PROTOCOL
) {
2582 debug_print("Server side search unavailable, using local search\n");
2583 imap_handle_error(SESSION(session
), NULL
, result
);
2584 result
= folder_item_search_msgs_local(folder
, container
, msgs
, NULL
,
2585 predicate
, progress_cb
, progress_data
);
2587 debug_print("search_msgs - got protocol error, aborting\n");
2588 alertpanel_error_log(_("Search failed due to server error."));
2595 if (result
== MAILIMAP_NO_ERROR
) {
2598 *msgs
= imap_uid_list_from_lep(uidlist
, &result
);
2600 mailimap_search_result_free(uidlist
);
2602 if (charset_to_use
!= NULL
)
2603 g_free(charset_to_use
);
2606 } else if (charset_to_use
!= NULL
) {
2607 /* If search failed and was on an 8-bit string, try the next
2608 * available charset to search if there still are some.
2610 g_free(charset_to_use
);
2612 imap_change_search_charset(IMAP_FOLDER(folder
));
2613 if (IMAP_FOLDER(folder
)->search_charset_supported
)
2614 return search_msgs(folder
, container
, msgs
, on_server
, predicate
,
2615 progress_cb
, progress_data
);
2617 imap_handle_error(SESSION(session
), NULL
, result
);
2621 imap_handle_error(SESSION(session
), NULL
, result
);
2627 static gint
imap_do_remove_msgs(Folder
*folder
, FolderItem
*dest
,
2628 MsgInfoList
*msglist
, GHashTable
*relation
)
2630 gchar
*destdir
, *dir
;
2631 GSList
*numlist
= NULL
, *cur
;
2633 IMAPSession
*session
;
2634 gint ok
= MAILIMAP_NO_ERROR
;
2636 g_return_val_if_fail(folder
!= NULL
, -1);
2637 g_return_val_if_fail(dest
!= NULL
, -1);
2638 g_return_val_if_fail(msglist
!= NULL
, -1);
2640 debug_print("getting session...\n");
2641 session
= imap_session_get(folder
);
2646 lock_session(session
); /* unlocked later in the function */
2648 msginfo
= (MsgInfo
*)msglist
->data
;
2650 ok
= imap_select(session
, IMAP_FOLDER(folder
), msginfo
->folder
,
2651 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
2652 if (ok
!= MAILIMAP_NO_ERROR
) {
2656 destdir
= imap_get_real_path(session
, IMAP_FOLDER(folder
), dest
->path
, &ok
);
2661 for (cur
= msglist
; cur
; cur
= cur
->next
) {
2662 msginfo
= (MsgInfo
*)cur
->data
;
2663 if (!MSG_IS_DELETED(msginfo
->flags
))
2664 numlist
= g_slist_prepend(numlist
, GINT_TO_POINTER(msginfo
->msgnum
));
2666 numlist
= g_slist_reverse(numlist
);
2668 if (numlist
!= NULL
) {
2669 ok
= imap_set_message_flags
2670 (session
, IMAP_FOLDER_ITEM(msginfo
->folder
), numlist
, IMAP_FLAG_DELETED
, NULL
, TRUE
);
2671 if (ok
!= MAILIMAP_NO_ERROR
) {
2672 log_warning(LOG_PROTOCOL
, _("can't set deleted flags\n"));
2676 } /* else we just need to expunge */
2677 ok
= imap_cmd_expunge(session
);
2678 if (ok
!= MAILIMAP_NO_ERROR
) {
2679 log_warning(LOG_PROTOCOL
, _("can't expunge\n"));
2684 session
->folder_content_changed
= TRUE
;
2685 unlock_session(session
);
2687 dir
= folder_item_get_path(msginfo
->folder
);
2688 if (is_dir_exist(dir
)) {
2689 for (cur
= msglist
; cur
; cur
= cur
->next
) {
2690 msginfo
= (MsgInfo
*)cur
->data
;
2691 remove_numbered_files(dir
, msginfo
->msgnum
, msginfo
->msgnum
);
2696 g_slist_free(numlist
);
2698 imap_scan_required(folder
, dest
);
2705 static gint
imap_remove_msgs(Folder
*folder
, FolderItem
*dest
,
2706 MsgInfoList
*msglist
, GHashTable
*relation
)
2710 g_return_val_if_fail(folder
!= NULL
, -1);
2711 g_return_val_if_fail(dest
!= NULL
, -1);
2712 if (msglist
== NULL
)
2715 msginfo
= (MsgInfo
*)msglist
->data
;
2716 g_return_val_if_fail(msginfo
->folder
!= NULL
, -1);
2718 return imap_do_remove_msgs(folder
, dest
, msglist
, relation
);
2721 static gint
imap_remove_all_msg(Folder
*folder
, FolderItem
*item
)
2723 GSList
*list
= folder_item_get_msg_list(item
);
2724 gint res
= imap_remove_msgs(folder
, item
, list
, NULL
);
2725 procmsg_msg_list_free(list
);
2729 static gboolean
imap_is_msg_changed(Folder
*folder
, FolderItem
*item
,
2732 /* TODO: properly implement this method */
2736 static gint
imap_close(Folder
*folder
, FolderItem
*item
)
2741 static gint
imap_scan_tree_real(Folder
*folder
, gboolean subs_only
)
2743 FolderItem
*item
= NULL
;
2744 IMAPSession
*session
;
2745 gchar
*root_folder
= NULL
;
2747 g_return_val_if_fail(folder
!= NULL
, -1);
2748 g_return_val_if_fail(folder
->account
!= NULL
, -1);
2750 debug_print("getting session...\n");
2751 session
= imap_session_get(folder
);
2753 if (!folder
->node
) {
2754 folder_tree_destroy(folder
);
2755 item
= folder_item_new(folder
, folder
->name
, NULL
);
2756 item
->folder
= folder
;
2757 folder
->node
= item
->node
= g_node_new(item
);
2762 if (folder
->account
->imap_dir
&& *folder
->account
->imap_dir
) {
2764 int r
= MAILIMAP_NO_ERROR
;
2767 Xstrdup_a(root_folder
, folder
->account
->imap_dir
, {return -1;});
2768 extract_quote(root_folder
, '"');
2769 subst_char(root_folder
,
2770 imap_get_path_separator(session
, IMAP_FOLDER(folder
),
2775 strtailchomp(root_folder
, '/');
2776 real_path
= imap_get_real_path
2777 (session
, IMAP_FOLDER(folder
), root_folder
, &r
);
2782 debug_print("IMAP root directory: %s\n", real_path
);
2784 /* check if root directory exist */
2786 r
= imap_threaded_list(session
->folder
, "", real_path
,
2789 if (r
!= MAILIMAP_NO_ERROR
)
2790 imap_handle_error(SESSION(session
), NULL
, r
);
2792 if ((r
!= MAILIMAP_NO_ERROR
) || (clist_count(lep_list
) == 0)) {
2793 if (!folder
->node
) {
2794 item
= folder_item_new(folder
, folder
->name
, NULL
);
2795 item
->folder
= folder
;
2796 folder
->node
= item
->node
= g_node_new(item
);
2800 mailimap_list_result_free(lep_list
);
2806 item
= FOLDER_ITEM(folder
->node
->data
);
2808 if (item
&& !item
->path
&& root_folder
) {
2809 item
->path
= g_strdup(root_folder
);
2812 if (!item
|| ((item
->path
|| root_folder
) &&
2813 g_strcmp0(item
->path
, root_folder
) != 0)) {
2814 folder_tree_destroy(folder
);
2815 item
= folder_item_new(folder
, folder
->name
, root_folder
);
2816 item
->folder
= folder
;
2817 folder
->node
= item
->node
= g_node_new(item
);
2820 imap_scan_tree_recursive(session
, FOLDER_ITEM(folder
->node
->data
), subs_only
);
2821 imap_create_missing_folders(folder
);
2826 static gint
imap_scan_tree(Folder
*folder
)
2828 gboolean subs_only
= FALSE
;
2829 if (folder
->account
) {
2830 debug_print(" scanning only subs %d\n", folder
->account
->imap_subsonly
);
2831 subs_only
= folder
->account
->imap_subsonly
;
2833 return imap_scan_tree_real(folder
, subs_only
);
2836 static gint
imap_scan_tree_recursive(IMAPSession
*session
, FolderItem
*item
, gboolean subs_only
)
2838 /* reset recursion depth counter */
2839 session
->scan_tree_recurs_depth
= 0;
2841 return imap_scan_tree_recursive_dive(session
, item
, subs_only
);
2844 static gint
imap_scan_tree_recursive_dive(IMAPSession
*session
, FolderItem
*item
, gboolean subs_only
)
2847 IMAPFolder
*imapfolder
;
2848 FolderItem
*new_item
;
2849 GSList
*item_list
, *cur
;
2852 gchar
*wildcard_path
;
2856 int r
= MAILIMAP_NO_ERROR
;
2858 g_return_val_if_fail(item
!= NULL
, -1);
2859 g_return_val_if_fail(item
->folder
!= NULL
, -1);
2860 g_return_val_if_fail(item
->no_sub
== FALSE
, -1);
2862 /* recursion depth limiter */
2863 if(session
->scan_tree_recurs_depth
>= prefs_common
.imap_scan_tree_recurs_limit
) {
2864 g_warning("IMAP scan tree recursion limit reached (%d, folder '%s')",
2865 prefs_common
.imap_scan_tree_recurs_limit
, item
->folder
->name
);
2868 /* entering recursion func: increase depth counter */
2869 session
->scan_tree_recurs_depth
++;
2871 folder
= item
->folder
;
2872 imapfolder
= IMAP_FOLDER(folder
);
2874 separator
= imap_get_path_separator(session
, imapfolder
, item
->path
, &r
);
2878 if (folder
->ui_func
)
2879 folder
->ui_func(folder
, item
, folder
->ui_func_data
);
2882 wildcard
[0] = separator
;
2885 real_path
= imap_get_real_path(session
, imapfolder
, item
->path
, &r
);
2893 real_path
= g_strdup("");
2896 Xstrcat_a(wildcard_path
, real_path
, wildcard
,
2897 {g_free(real_path
); return MAILIMAP_ERROR_BAD_STATE
;});
2901 r
= imap_threaded_lsub(folder
, "", wildcard_path
, &lep_list
);
2903 r
= imap_threaded_list(folder
, "", wildcard_path
, &lep_list
);
2905 if (r
!= MAILIMAP_NO_ERROR
) {
2906 imap_handle_error(SESSION(session
), NULL
, r
);
2912 item_list
= imap_list_from_lep(imapfolder
,
2913 lep_list
, real_path
, FALSE
);
2914 mailimap_list_result_free(lep_list
);
2919 node
= item
->node
->children
;
2920 while (node
!= NULL
) {
2921 FolderItem
*old_item
= FOLDER_ITEM(node
->data
);
2922 GNode
*next
= node
->next
;
2925 for (cur
= item_list
; cur
!= NULL
; cur
= cur
->next
) {
2926 FolderItem
*cur_item
= FOLDER_ITEM(cur
->data
);
2927 if (!g_strcmp0(old_item
->path
, cur_item
->path
)) {
2928 new_item
= cur_item
;
2933 if (old_item
&& old_item
->path
&& !strcasecmp(old_item
->path
, "INBOX")) {
2934 debug_print("not removing INBOX\n");
2936 debug_print("folder '%s' not found. removing...\n",
2938 folder_item_remove(old_item
);
2941 old_item
->no_sub
= new_item
->no_sub
;
2942 old_item
->no_select
= new_item
->no_select
;
2943 if (old_item
->no_sub
== TRUE
&& node
->children
) {
2944 debug_print("folder '%s' doesn't have "
2945 "subfolders. removing...\n",
2947 folder_item_remove_children(old_item
);
2954 for (cur
= item_list
; cur
!= NULL
; cur
= cur
->next
) {
2955 FolderItem
*cur_item
= FOLDER_ITEM(cur
->data
);
2958 for (node
= item
->node
->children
; node
!= NULL
;
2959 node
= node
->next
) {
2960 if (!g_strcmp0(FOLDER_ITEM(node
->data
)->path
,
2962 new_item
= FOLDER_ITEM(node
->data
);
2963 folder_item_destroy(cur_item
);
2969 new_item
= cur_item
;
2970 debug_print("new folder '%s' found.\n", new_item
->path
);
2971 folder_item_append(item
, new_item
);
2974 if (!strcasecmp(new_item
->path
, "INBOX")) {
2975 new_item
->stype
= F_INBOX
;
2976 folder
->inbox
= new_item
;
2977 } else if (!folder_item_parent(item
) || item
->stype
== F_INBOX
) {
2980 base
= g_path_get_basename(new_item
->path
);
2982 if (!folder
->outbox
&& !g_ascii_strcasecmp(base
, "Sent")) {
2983 new_item
->stype
= F_OUTBOX
;
2984 folder
->outbox
= new_item
;
2985 } else if (!folder
->draft
&& (!g_ascii_strcasecmp(base
, "Drafts") || !g_ascii_strcasecmp(base
, "Draft"))) {
2986 new_item
->stype
= F_DRAFT
;
2987 folder
->draft
= new_item
;
2988 } else if (!folder
->queue
&& !g_ascii_strcasecmp(base
, "Queue")) {
2989 new_item
->stype
= F_QUEUE
;
2990 folder
->queue
= new_item
;
2991 } else if (!folder
->trash
&& !g_ascii_strcasecmp(base
, "Trash")) {
2992 new_item
->stype
= F_TRASH
;
2993 folder
->trash
= new_item
;
2998 if (new_item
->no_sub
== FALSE
) {
2999 imap_scan_tree_recursive_dive(session
, new_item
, subs_only
);
3001 /* entering recursion func: increase depth counter */
3002 session
->scan_tree_recurs_depth
--;
3003 if (session
->scan_tree_recurs_depth
< 0)
3004 g_error("IMAP scan tree recursion underflow (%d)",
3005 session
->scan_tree_recurs_depth
);
3009 g_slist_free(item_list
);
3011 return MAILIMAP_NO_ERROR
;
3014 GList
*imap_scan_subtree(Folder
*folder
, FolderItem
*item
, gboolean unsubs_only
, gboolean recursive
)
3016 IMAPSession
*session
= imap_session_get(folder
);
3018 gchar
*wildcard_path
;
3022 GSList
*item_list
= NULL
, *cur
;
3023 GList
*child_list
= NULL
, *tmplist
= NULL
;
3024 GSList
*sub_list
= NULL
;
3025 int r
= MAILIMAP_NO_ERROR
;
3030 separator
= imap_get_path_separator(session
, IMAP_FOLDER(folder
), item
->path
, &r
);
3035 wildcard
[0] = separator
;
3038 real_path
= imap_get_real_path(session
, IMAP_FOLDER(folder
), item
->path
, &r
);
3046 real_path
= g_strdup("");
3049 Xstrcat_a(wildcard_path
, real_path
, wildcard
,
3050 {g_free(real_path
); return NULL
;});
3054 statusbar_print_all(_("Looking for unsubscribed folders in %s..."),
3055 item
->path
?item
->path
:item
->name
);
3057 statusbar_print_all(_("Looking for subfolders of %s..."),
3058 item
->path
?item
->path
:item
->name
);
3060 r
= imap_threaded_list(folder
, "", wildcard_path
, &lep_list
);
3063 statusbar_pop_all();
3066 item_list
= imap_list_from_lep(IMAP_FOLDER(folder
),
3067 lep_list
, real_path
, FALSE
);
3068 mailimap_list_result_free(lep_list
);
3070 for (cur
= item_list
; cur
!= NULL
; cur
= cur
->next
) {
3071 FolderItem
*cur_item
= FOLDER_ITEM(cur
->data
);
3073 tmplist
= imap_scan_subtree(folder
, cur_item
,
3074 unsubs_only
, recursive
);
3076 child_list
= g_list_concat(child_list
, tmplist
);
3078 child_list
= g_list_prepend(child_list
,
3079 imap_get_real_path(session
,
3080 IMAP_FOLDER(folder
), cur_item
->path
, &r
));
3083 statusbar_pop_all();
3086 folder_item_destroy(cur_item
);
3088 child_list
= g_list_reverse(child_list
);
3089 g_slist_free(item_list
);
3092 r
= imap_threaded_lsub(folder
, "", wildcard_path
, &lep_list
);
3095 statusbar_pop_all();
3098 sub_list
= imap_list_from_lep(IMAP_FOLDER(folder
),
3099 lep_list
, real_path
, FALSE
);
3100 mailimap_list_result_free(lep_list
);
3102 for (cur
= sub_list
; cur
!= NULL
; cur
= cur
->next
) {
3103 FolderItem
*cur_item
= FOLDER_ITEM(cur
->data
);
3104 GList
*oldlitem
= NULL
;
3105 gchar
*tmp
= imap_get_real_path(session
,
3106 IMAP_FOLDER(folder
), cur_item
->path
, &r
);
3109 statusbar_pop_all();
3113 folder_item_destroy(cur_item
);
3114 oldlitem
= g_list_find_custom(
3115 child_list
, tmp
, (GCompareFunc
)g_strcmp0
);
3117 child_list
= g_list_remove_link(child_list
, oldlitem
);
3118 g_free(oldlitem
->data
);
3119 g_list_free(oldlitem
);
3126 statusbar_pop_all();
3131 static gint
imap_create_tree(Folder
*folder
)
3133 g_return_val_if_fail(folder
!= NULL
, -1);
3134 g_return_val_if_fail(folder
->node
!= NULL
, -1);
3135 g_return_val_if_fail(folder
->node
->data
!= NULL
, -1);
3136 g_return_val_if_fail(folder
->account
!= NULL
, -1);
3138 imap_scan_tree(folder
);
3139 imap_create_missing_folders(folder
);
3144 static void imap_create_missing_folders(Folder
*folder
)
3146 g_return_if_fail(folder
!= NULL
);
3149 folder
->inbox
= imap_create_special_folder
3150 (folder
, F_INBOX
, "INBOX");
3152 folder
->trash
= imap_create_special_folder
3153 (folder
, F_TRASH
, "Trash");
3155 folder
->queue
= imap_create_special_folder
3156 (folder
, F_QUEUE
, "Queue");
3157 if (!folder
->outbox
)
3158 folder
->outbox
= imap_create_special_folder
3159 (folder
, F_OUTBOX
, "Sent");
3161 folder
->draft
= imap_create_special_folder
3162 (folder
, F_DRAFT
, "Drafts");
3165 static FolderItem
*imap_create_special_folder(Folder
*folder
,
3166 SpecialFolderItemType stype
,
3170 FolderItem
*new_item
;
3172 g_return_val_if_fail(folder
!= NULL
, NULL
);
3173 g_return_val_if_fail(folder
->node
!= NULL
, NULL
);
3174 g_return_val_if_fail(folder
->node
->data
!= NULL
, NULL
);
3175 g_return_val_if_fail(folder
->account
!= NULL
, NULL
);
3176 g_return_val_if_fail(name
!= NULL
, NULL
);
3178 item
= FOLDER_ITEM(folder
->node
->data
);
3179 new_item
= imap_create_folder(folder
, item
, name
);
3182 g_warning("can't create '%s'", name
);
3183 if (!folder
->inbox
) return NULL
;
3185 new_item
= imap_create_folder(folder
, folder
->inbox
, name
);
3187 g_warning("can't create '%s' under INBOX", name
);
3189 new_item
->stype
= stype
;
3191 new_item
->stype
= stype
;
3197 static gchar
*imap_encode_unsafe_chars(const gchar
*str
)
3199 gchar
*ret
= NULL
, *o_ret
;
3203 ret
= g_malloc(3*strlen(str
)+1);
3205 for (i
= (gchar
*)str
; *i
; i
++) {
3215 *ret
++ = '0'+(*i
/10);
3216 *ret
++ = '0'+(*i
%10);
3226 static gchar
*imap_item_get_path(Folder
*folder
, FolderItem
*item
)
3228 gchar
*folder_path
, *path
;
3229 gchar
*item_path
= NULL
;
3231 g_return_val_if_fail(folder
!= NULL
, NULL
);
3232 g_return_val_if_fail(folder
->account
!= NULL
, NULL
);
3233 g_return_val_if_fail(item
!= NULL
, NULL
);
3234 folder_path
= prefs_account_cache_dir(folder
->account
, FALSE
);
3236 g_return_val_if_fail(folder_path
!= NULL
, NULL
);
3239 item_path
= g_strdup(item
->path
);
3241 item_path
= imap_encode_unsafe_chars(item
->path
);
3244 if (g_path_is_absolute(folder_path
)) {
3246 path
= g_strconcat(folder_path
, G_DIR_SEPARATOR_S
,
3249 path
= g_strdup(folder_path
);
3252 path
= g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S
,
3253 folder_path
, G_DIR_SEPARATOR_S
,
3256 path
= g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S
,
3259 g_free(folder_path
);
3262 while (strchr(path
, '/'))
3263 *strchr(path
, '/') = '\\';
3269 static FolderItem
*imap_create_folder(Folder
*folder
, FolderItem
*parent
,
3272 gchar
*dirpath
, *imap_path
;
3273 IMAPSession
*session
;
3274 FolderItem
*new_item
;
3278 gint ok
= MAILIMAP_NO_ERROR
;
3279 gboolean no_select
= FALSE
, no_sub
= FALSE
;
3280 gboolean exist
= FALSE
;
3282 g_return_val_if_fail(folder
!= NULL
, NULL
);
3283 g_return_val_if_fail(folder
->account
!= NULL
, NULL
);
3284 g_return_val_if_fail(parent
!= NULL
, NULL
);
3285 g_return_val_if_fail(name
!= NULL
, NULL
);
3287 if (to_number(name
) > 0) {
3288 gchar
*cached_msg
= imap_get_cached_filename(parent
, to_number(name
));
3289 if (is_file_exist(cached_msg
)) {
3290 if (claws_unlink(cached_msg
) != 0) {
3298 debug_print("getting session...\n");
3299 session
= imap_session_get(folder
);
3304 if (!folder_item_parent(parent
) && strcasecmp(name
, "INBOX") == 0) {
3305 dirpath
= g_strdup(name
);
3306 }else if (parent
->path
)
3307 dirpath
= g_strconcat(parent
->path
, "/", name
, NULL
);
3308 else if ((p
= strchr(name
, '/')) != NULL
&& *(p
+ 1) != '\0')
3309 dirpath
= g_strdup(name
);
3310 else if (folder
->account
->imap_dir
&& *folder
->account
->imap_dir
) {
3313 Xstrdup_a(imap_dir
, folder
->account
->imap_dir
, {return NULL
;});
3314 strtailchomp(imap_dir
, '/');
3315 dirpath
= g_strconcat(imap_dir
, "/", name
, NULL
);
3317 dirpath
= g_strdup(name
);
3321 /* keep trailing directory separator to create a folder that contains
3323 imap_path
= imap_utf8_to_modified_utf7(dirpath
, FALSE
);
3325 strtailchomp(dirpath
, '/');
3326 Xstrdup_a(new_name
, name
, {
3331 separator
= imap_get_path_separator(session
, IMAP_FOLDER(folder
), imap_path
, &ok
);
3337 imap_path_separator_subst(imap_path
, separator
);
3338 /* remove trailing / for display */
3339 strtailchomp(new_name
, '/');
3341 if (strcasecmp(dirpath
, "INBOX") != 0) {
3345 r
= imap_threaded_list(folder
, "", imap_path
, &lep_list
);
3346 if (r
!= MAILIMAP_NO_ERROR
) {
3347 imap_handle_error(SESSION(session
), NULL
, r
);
3348 log_warning(LOG_PROTOCOL
, _("can't create mailbox: LIST failed\n"));
3354 if (clist_count(lep_list
) > 0)
3356 mailimap_list_result_free(lep_list
);
3359 ok
= imap_cmd_create(session
, imap_path
);
3360 if (ok
!= MAILIMAP_NO_ERROR
) {
3361 log_warning(LOG_PROTOCOL
, _("can't create mailbox\n"));
3366 r
= imap_threaded_list(folder
, "", imap_path
, &lep_list
);
3367 if (r
== MAILIMAP_NO_ERROR
) {
3368 GSList
*item_list
= imap_list_from_lep(IMAP_FOLDER(folder
),
3369 lep_list
, dirpath
, TRUE
);
3371 FolderItem
*cur_item
= FOLDER_ITEM(item_list
->data
);
3372 no_select
= cur_item
->no_select
;
3373 no_sub
= cur_item
->no_sub
;
3374 g_slist_free(item_list
);
3376 mailimap_list_result_free(lep_list
);
3378 imap_handle_error(SESSION(session
), NULL
, r
);
3381 imap_threaded_subscribe(folder
, imap_path
, TRUE
);
3385 /* just get flags */
3386 r
= imap_threaded_list(folder
, "", "INBOX", &lep_list
);
3387 if (r
== MAILIMAP_NO_ERROR
) {
3388 GSList
*item_list
= imap_list_from_lep(IMAP_FOLDER(folder
),
3389 lep_list
, dirpath
, TRUE
);
3391 FolderItem
*cur_item
= FOLDER_ITEM(item_list
->data
);
3392 no_select
= cur_item
->no_select
;
3393 no_sub
= cur_item
->no_sub
;
3394 g_slist_free(item_list
);
3396 mailimap_list_result_free(lep_list
);
3398 imap_handle_error(SESSION(session
), NULL
, r
);
3402 new_item
= folder_item_new(folder
, new_name
, dirpath
);
3403 new_item
->no_select
= no_select
;
3404 new_item
->no_sub
= no_sub
;
3405 folder_item_append(parent
, new_item
);
3409 dirpath
= folder_item_get_path(new_item
);
3410 if (!is_dir_exist(dirpath
))
3411 make_dir_hier(dirpath
);
3415 /* folder existed, scan it */
3416 imap_scan_required(folder
, new_item
);
3417 folder_item_scan_full(new_item
, FALSE
);
3423 static gint
imap_rename_folder(Folder
*folder
, FolderItem
*item
,
3428 gchar
*real_oldpath
;
3429 gchar
*real_newpath
;
3431 gchar
*old_cache_dir
;
3432 gchar
*new_cache_dir
;
3433 IMAPSession
*session
;
3435 gint ok
= MAILIMAP_NO_ERROR
;
3436 gint exists
, recent
, unseen
;
3437 guint32 uid_validity
;
3439 g_return_val_if_fail(folder
!= NULL
, -1);
3440 g_return_val_if_fail(item
!= NULL
, -1);
3441 g_return_val_if_fail(item
->path
!= NULL
, -1);
3442 g_return_val_if_fail(name
!= NULL
, -1);
3444 debug_print("getting session...\n");
3445 session
= imap_session_get(folder
);
3450 if (strchr(name
, imap_get_path_separator(session
, IMAP_FOLDER(folder
), item
->path
, &ok
)) != NULL
||
3452 g_warning("new folder name must not contain the namespace path separator");
3456 real_oldpath
= imap_get_real_path(session
, IMAP_FOLDER(folder
), item
->path
, &ok
);
3458 g_free(real_oldpath
);
3462 g_free(session
->mbox
);
3463 session
->mbox
= NULL
;
3464 session
->exists
= 0;
3465 session
->recent
= 0;
3466 session
->expunge
= 0;
3467 ok
= imap_cmd_examine(session
, "INBOX",
3468 &exists
, &recent
, &unseen
, &uid_validity
, FALSE
);
3469 if (ok
!= MAILIMAP_NO_ERROR
) {
3470 g_free(real_oldpath
);
3474 separator
= imap_get_path_separator(session
, IMAP_FOLDER(folder
), item
->path
, &ok
);
3476 g_free(real_oldpath
);
3479 if (strchr(item
->path
, '/')) {
3480 dirpath
= g_path_get_dirname(item
->path
);
3481 newpath
= g_strconcat(dirpath
, "/", name
, NULL
);
3484 newpath
= g_strdup(name
);
3486 real_newpath
= imap_utf8_to_modified_utf7(newpath
, FALSE
);
3487 imap_path_separator_subst(real_newpath
, separator
);
3489 ok
= imap_cmd_rename(session
, real_oldpath
, real_newpath
);
3490 if (ok
!= MAILIMAP_NO_ERROR
) {
3491 log_warning(LOG_PROTOCOL
, _("can't rename mailbox: %s to %s\n"),
3492 real_oldpath
, real_newpath
);
3493 g_free(real_oldpath
);
3495 g_free(real_newpath
);
3499 item
->name
= g_strdup(name
);
3501 old_cache_dir
= folder_item_get_path(item
);
3503 paths
[0] = g_strdup(item
->path
);
3505 g_node_traverse(item
->node
, G_PRE_ORDER
, G_TRAVERSE_ALL
, -1,
3506 imap_rename_folder_func
, paths
);
3508 if (is_dir_exist(old_cache_dir
)) {
3509 new_cache_dir
= folder_item_get_path(item
);
3510 if (g_rename(old_cache_dir
, new_cache_dir
) < 0) {
3511 FILE_OP_ERROR(old_cache_dir
, "rename");
3513 g_free(new_cache_dir
);
3516 g_free(old_cache_dir
);
3519 g_free(real_oldpath
);
3520 g_free(real_newpath
);
3524 gint
imap_subscribe(Folder
*folder
, FolderItem
*item
, gchar
*rpath
, gboolean sub
)
3527 gint r
= MAILIMAP_NO_ERROR
;
3528 IMAPSession
*session
;
3529 debug_print("getting session...\n");
3531 session
= imap_session_get(folder
);
3535 if (item
&& item
->path
) {
3536 path
= imap_get_real_path(session
, IMAP_FOLDER(folder
), item
->path
, &r
);
3543 if (!strcasecmp(path
, "INBOX") && sub
== FALSE
) {
3547 debug_print("%ssubscribing %s\n", sub
?"":"un", path
);
3548 r
= imap_threaded_subscribe(folder
, path
, sub
);
3551 r
= imap_threaded_subscribe(folder
, rpath
, sub
);
3557 static gint
imap_remove_folder_real(Folder
*folder
, FolderItem
*item
)
3559 gint ok
= MAILIMAP_NO_ERROR
;
3560 IMAPSession
*session
;
3563 gboolean selected_folder
;
3565 g_return_val_if_fail(folder
!= NULL
, -1);
3566 g_return_val_if_fail(item
!= NULL
, -1);
3567 g_return_val_if_fail(item
->path
!= NULL
, -1);
3569 debug_print("getting session...\n");
3570 session
= imap_session_get(folder
);
3574 path
= imap_get_real_path(session
, IMAP_FOLDER(folder
), item
->path
, &ok
);
3579 imap_threaded_subscribe(folder
, path
, FALSE
);
3581 selected_folder
= (session
->mbox
!= NULL
) &&
3582 (!strcmp(session
->mbox
, item
->path
));
3583 if (selected_folder
) {
3584 ok
= imap_cmd_close(session
);
3585 if (ok
!= MAILIMAP_NO_ERROR
) {
3586 debug_print("close err %d\n", ok
);
3590 ok
= imap_cmd_delete(session
, path
);
3591 if (ok
!= MAILIMAP_NO_ERROR
&& !is_fatal(ok
)) {
3594 ok
= MAILIMAP_NO_ERROR
;
3595 tmp
= g_strdup_printf("%s%c", path
,
3596 imap_get_path_separator(session
, IMAP_FOLDER(folder
), path
, &ok
));
3600 ok
= imap_cmd_delete(session
, path
);
3603 if (ok
!= MAILIMAP_NO_ERROR
) {
3604 log_warning(LOG_PROTOCOL
, _("can't delete mailbox\n"));
3610 cache_dir
= folder_item_get_path(item
);
3611 if (is_dir_exist(cache_dir
) && remove_dir_recursive(cache_dir
) < 0)
3612 g_warning("can't remove directory '%s'", cache_dir
);
3614 folder_item_remove(item
);
3618 static gint
imap_remove_folder(Folder
*folder
, FolderItem
*item
)
3622 g_return_val_if_fail(item
!= NULL
, -1);
3623 g_return_val_if_fail(item
->folder
!= NULL
, -1);
3624 g_return_val_if_fail(item
->node
!= NULL
, -1);
3626 node
= item
->node
->children
;
3627 while (node
!= NULL
) {
3629 if (imap_remove_folder(folder
, FOLDER_ITEM(node
->data
)) < 0)
3633 debug_print("IMAP removing %s\n", item
->path
);
3635 if (imap_remove_all_msg(folder
, item
) < 0)
3637 return imap_remove_folder_real(folder
, item
);
3640 typedef struct _uncached_data
{
3641 IMAPSession
*session
;
3643 MsgNumberList
*numlist
;
3650 static void *imap_get_uncached_messages_thread(void *data
)
3652 uncached_data
*stuff
= (uncached_data
*)data
;
3653 IMAPSession
*session
= stuff
->session
;
3654 FolderItem
*item
= stuff
->item
;
3655 MsgNumberList
*numlist
= stuff
->numlist
;
3656 GSList
*newlist
= NULL
;
3657 GSList
*llast
= NULL
;
3658 GSList
*seq_list
, *cur
;
3659 gboolean got_alien_tags
= FALSE
;
3661 debug_print("uncached_messages\n");
3663 if (session
== NULL
|| item
== NULL
|| item
->folder
== NULL
3664 || FOLDER_CLASS(item
->folder
) != &imap_class
) {
3669 seq_list
= imap_get_lep_set_from_numlist(IMAP_FOLDER(item
->folder
), numlist
);
3670 debug_print("get msgs info\n");
3671 for (cur
= seq_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
3672 struct mailimap_set
* imapset
;
3678 if (session
->cancelled
)
3681 imapset
= cur
->data
;
3683 r
= imap_threaded_fetch_env(session
->folder
,
3684 imapset
, &env_list
);
3685 if (r
!= MAILIMAP_NO_ERROR
) {
3686 imap_handle_error(SESSION(session
), NULL
, r
);
3694 session_set_access_time(SESSION(session
));
3697 for(i
= 0 ; i
< carray_count(env_list
) ; i
+= 2) {
3698 struct imap_fetch_env_info
* info
;
3700 GSList
*tags
= NULL
, *cur
= NULL
;
3701 info
= carray_get(env_list
, i
);
3702 tags
= carray_get(env_list
, i
+1);
3703 msginfo
= imap_envelope_from_lep(info
, item
);
3704 if (msginfo
== NULL
) {
3705 slist_free_strings_full(tags
);
3708 g_slist_free(msginfo
->tags
);
3709 msginfo
->tags
= NULL
;
3711 for (cur
= tags
; cur
; cur
= cur
->next
) {
3712 gchar
*real_tag
= imap_modified_utf7_to_utf8(cur
->data
, TRUE
);
3714 id
= tags_get_id_for_str(real_tag
);
3716 id
= tags_add_tag(real_tag
);
3717 got_alien_tags
= TRUE
;
3719 if (!g_slist_find(msginfo
->tags
, GINT_TO_POINTER(id
))) {
3720 msginfo
->tags
= g_slist_prepend(
3722 GINT_TO_POINTER(id
));
3727 msginfo
->tags
= g_slist_reverse(msginfo
->tags
);
3728 slist_free_strings_full(tags
);
3729 msginfo
->folder
= item
;
3731 llast
= newlist
= g_slist_append(newlist
, msginfo
);
3733 llast
= g_slist_append(llast
, msginfo
);
3734 llast
= llast
->next
;
3739 imap_fetch_env_free(env_list
);
3742 if (got_alien_tags
) {
3744 main_window_reflect_tags_changes(mainwindow_get_mainwindow());
3747 imap_lep_set_free(seq_list
);
3749 session_set_access_time(SESSION(session
));
3754 #define MAX_MSG_NUM 50
3756 static GSList
*imap_get_uncached_messages(IMAPSession
*session
,
3758 MsgNumberList
*numlist
,
3761 GSList
*result
= NULL
;
3763 uncached_data
*data
= g_new0(uncached_data
, 1);
3766 data
->total
= g_slist_length(numlist
);
3767 data
->ok
= MAILIMAP_NO_ERROR
;
3768 debug_print("messages list : %i\n", data
->total
);
3770 while (cur
!= NULL
) {
3771 GSList
* partial_result
;
3779 while (count
< MAX_MSG_NUM
) {
3784 if (newlist
== NULL
)
3785 llast
= newlist
= g_slist_append(newlist
, p
);
3787 llast
= g_slist_append(llast
, p
);
3788 llast
= llast
->next
;
3798 data
->session
= session
;
3800 data
->numlist
= newlist
;
3803 if (prefs_common
.work_offline
&&
3804 !inc_offline_should_override(FALSE
,
3805 _("Claws Mail needs network access in order "
3806 "to access the IMAP server."))) {
3812 (GSList
*)imap_get_uncached_messages_thread(data
);
3814 if (data
->ok
!= MAILIMAP_NO_ERROR
) {
3817 statusbar_progress_all(data
->cur
,data
->total
, 1);
3819 g_slist_free(newlist
);
3821 result
= g_slist_concat(result
, partial_result
);
3826 statusbar_progress_all(0,0,0);
3827 statusbar_pop_all();
3832 static void imap_delete_all_cached_messages(FolderItem
*item
)
3836 g_return_if_fail(item
!= NULL
);
3837 g_return_if_fail(item
->folder
!= NULL
);
3838 g_return_if_fail(FOLDER_CLASS(item
->folder
) == &imap_class
);
3840 debug_print("Deleting all cached messages...\n");
3842 dir
= folder_item_get_path(item
);
3843 if (is_dir_exist(dir
))
3844 remove_all_numbered_files(dir
);
3847 debug_print("Deleting all cached messages done.\n");
3850 gchar
imap_get_path_separator_for_item(FolderItem
*item
)
3852 Folder
*folder
= NULL
;
3853 IMAPFolder
*imap_folder
= NULL
;
3854 IMAPSession
*session
= NULL
;
3856 gint ok
= MAILIMAP_NO_ERROR
;
3859 folder
= item
->folder
;
3864 imap_folder
= IMAP_FOLDER(folder
);
3866 debug_print("getting session...\n");
3867 session
= imap_session_get(FOLDER(folder
));
3868 result
= imap_get_path_separator(session
, imap_folder
, item
->path
, &ok
);
3872 static gchar
imap_refresh_path_separator(IMAPSession
*session
, IMAPFolder
*folder
, const gchar
*subfolder
, gint
*ok
)
3876 gchar separator
= '\0';
3878 g_return_val_if_fail(session
!= NULL
, '/');
3879 r
= imap_threaded_list((Folder
*)folder
, "", subfolder
, &lep_list
);
3881 if (r
!= MAILIMAP_NO_ERROR
) {
3882 imap_handle_error(SESSION(session
), NULL
, r
);
3883 log_warning(LOG_PROTOCOL
, _("LIST failed\n"));
3888 if (lep_list
!= NULL
&& clist_count(lep_list
) > 0) {
3889 clistiter
* iter
= clist_begin(lep_list
);
3890 struct mailimap_mailbox_list
* mb
;
3891 mb
= clist_content(iter
);
3893 separator
= mb
->mb_delimiter
;
3894 debug_print("got separator: %c\n", folder
->last_seen_separator
);
3896 *ok
= MAILIMAP_NO_ERROR
;
3897 mailimap_list_result_free(lep_list
);
3901 static gchar
imap_get_path_separator(IMAPSession
*session
, IMAPFolder
*folder
, const gchar
*path
, gint
*ok
)
3903 gchar separator
= '/';
3904 *ok
= MAILIMAP_NO_ERROR
;
3905 if (folder
->last_seen_separator
== 0) {
3906 folder
->last_seen_separator
= imap_refresh_path_separator(session
, folder
, "", ok
);
3909 if (folder
->last_seen_separator
== 0) {
3910 folder
->last_seen_separator
= imap_refresh_path_separator(session
, folder
, "INBOX", ok
);
3913 if (folder
->last_seen_separator
!= 0) {
3914 debug_print("using separator: %c\n", folder
->last_seen_separator
);
3915 return folder
->last_seen_separator
;
3921 static gchar
*imap_get_real_path(IMAPSession
*session
, IMAPFolder
*folder
, const gchar
*path
, gint
*ok
)
3923 gchar
*real_path
= NULL
;
3926 g_return_val_if_fail(folder
!= NULL
, NULL
);
3927 g_return_val_if_fail(path
!= NULL
, NULL
);
3929 *ok
= MAILIMAP_NO_ERROR
;
3931 real_path
= imap_utf8_to_modified_utf7(path
, FALSE
);
3932 separator
= imap_get_path_separator(session
, folder
, path
, ok
);
3933 if (*ok
== MAILIMAP_NO_ERROR
)
3934 imap_path_separator_subst(real_path
, separator
);
3939 static gint
imap_set_message_flags(IMAPSession
*session
,
3940 IMAPFolderItem
*item
,
3941 MsgNumberList
*numlist
,
3950 IMAPFolder
*folder
= NULL
;
3951 GSList
*sorted_list
= NULL
;
3953 if (numlist
== NULL
|| session
== NULL
)
3954 return MAILIMAP_ERROR_BAD_STATE
;
3956 folder
= IMAP_FOLDER(session
->folder
);
3958 sorted_list
= g_slist_copy(numlist
);
3959 sorted_list
= g_slist_sort(sorted_list
, g_int_compare
);
3961 cur
= g_slist_last(sorted_list
);
3964 total
= GPOINTER_TO_INT(cur
->data
);
3966 seq_list
= imap_get_lep_set_from_numlist(IMAP_FOLDER(session
->folder
), sorted_list
);
3968 statusbar_print_all(_("Flagging messages..."));
3970 for(cur
= seq_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
3971 struct mailimap_set
* imapset
= (struct mailimap_set
*)cur
->data
;
3972 struct mailimap_set_item
*set_item
= NULL
;
3974 if (imapset
->set_list
)
3975 set_item
= clist_content(clist_begin(imapset
->set_list
));
3979 if (set_item
== NULL
)
3982 statusbar_progress_all(set_item
->set_first
, total
, 1);
3984 ok
= imap_cmd_store(session
, item
, imapset
,
3985 flags
, tags
, is_set
);
3986 statusbar_progress_all(set_item
->set_last
, total
, 1);
3987 if (ok
!= MAILIMAP_NO_ERROR
&& folder
->max_set_size
> 20) {
3988 /* reduce max set size */
3989 folder
->max_set_size
/= 2;
3991 if (ok
!= MAILIMAP_NO_ERROR
&& is_fatal(ok
)) {
3996 g_slist_free(sorted_list
);
3998 statusbar_progress_all(0,0,0);
3999 statusbar_pop_all();
4001 imap_lep_set_free(seq_list
);
4006 typedef struct _select_data
{
4007 IMAPSession
*session
;
4012 guint32
*uid_validity
;
4016 static gint
imap_select(IMAPSession
*session
, IMAPFolder
*folder
,
4018 gint
*exists
, gint
*recent
, gint
*unseen
,
4019 guint32
*uid_validity
, gint
*can_create_flags
,
4023 gint ok
= MAILIMAP_NO_ERROR
;
4024 gint exists_
, recent_
, unseen_
;
4025 guint32 uid_validity_
;
4026 gint can_create_flags_
;
4027 const gchar
*path
= item
? item
->path
:NULL
;
4030 return MAILIMAP_ERROR_BAD_STATE
;
4033 if (!exists
&& !recent
&& !unseen
&& !uid_validity
&& !can_create_flags
) {
4034 if (session
->mbox
&& strcmp(session
->mbox
, path
) == 0)
4035 return MAILIMAP_NO_ERROR
;
4037 if (!exists
&& !recent
&& !unseen
&& !uid_validity
&& can_create_flags
) {
4038 if (session
->mbox
&& strcmp(session
->mbox
, path
) == 0) {
4039 if (IMAP_FOLDER_ITEM(item
)->can_create_flags
!= ITEM_CAN_CREATE_FLAGS_UNKNOWN
)
4040 return MAILIMAP_NO_ERROR
;
4050 uid_validity
= &uid_validity_
;
4051 if (!can_create_flags
)
4052 can_create_flags
= &can_create_flags_
;
4054 g_free(session
->mbox
);
4055 session
->mbox
= NULL
;
4056 session
->exists
= 0;
4057 session
->recent
= 0;
4058 session
->expunge
= 0;
4060 real_path
= imap_get_real_path(session
, folder
, path
, &ok
);
4065 g_slist_free(IMAP_FOLDER_ITEM(item
)->ok_flags
);
4066 IMAP_FOLDER_ITEM(item
)->ok_flags
= NULL
;
4067 ok
= imap_cmd_select(session
, real_path
,
4068 exists
, recent
, unseen
, uid_validity
, can_create_flags
,
4069 &(IMAP_FOLDER_ITEM(item
)->ok_flags
), block
);
4070 if (ok
!= MAILIMAP_NO_ERROR
) {
4071 log_warning(LOG_PROTOCOL
, _("can't select folder: %s\n"), real_path
);
4073 session
->mbox
= g_strdup(path
);
4074 session
->folder_content_changed
= FALSE
;
4075 session
->exists
= *exists
;
4076 session
->recent
= *recent
;
4077 session
->expunge
= 0;
4078 session
->unseen
= *unseen
;
4079 session
->uid_validity
= *uid_validity
;
4080 debug_print("select: exists %d recent %d expunge %d uid_validity %d can_create_flags %d\n",
4081 session
->exists
, session
->recent
, session
->expunge
,
4082 session
->uid_validity
, *can_create_flags
);
4084 if (*can_create_flags
) {
4085 IMAP_FOLDER_ITEM(item
)->can_create_flags
= ITEM_CAN_CREATE_FLAGS
;
4087 IMAP_FOLDER_ITEM(item
)->can_create_flags
= ITEM_CANNOT_CREATE_FLAGS
;
4094 static gint
imap_status(IMAPSession
*session
, IMAPFolder
*folder
,
4095 const gchar
*path
, IMAPFolderItem
*item
,
4097 guint32
*uid_next
, guint32
*uid_validity
,
4098 gint
*unseen
, gboolean block
)
4100 int r
= MAILIMAP_NO_ERROR
;
4102 struct mailimap_mailbox_data_status
* data_status
;
4107 real_path
= imap_get_real_path(session
, folder
, path
, &r
);
4129 if (session
->mbox
!= NULL
&&
4130 !strcmp(session
->mbox
, item
->item
.path
)) {
4131 r
= imap_cmd_close(session
);
4132 if (r
!= MAILIMAP_NO_ERROR
) {
4133 debug_print("close err %d\n", r
);
4139 r
= imap_threaded_status(FOLDER(folder
), real_path
,
4140 &data_status
, mask
);
4143 if (r
!= MAILIMAP_NO_ERROR
) {
4144 imap_handle_error(SESSION(session
), NULL
, r
);
4145 debug_print("status err %d\n", r
);
4149 if (data_status
== NULL
|| data_status
->st_info_list
== NULL
) {
4150 debug_print("data_status %p\n", data_status
);
4152 debug_print("data_status->st_info_list %p\n", data_status
->st_info_list
);
4153 mailimap_mailbox_data_status_free(data_status
);
4155 return MAILIMAP_ERROR_BAD_STATE
;
4159 if (data_status
->st_info_list
) {
4160 for(iter
= clist_begin(data_status
->st_info_list
) ; iter
!= NULL
;
4161 iter
= clist_next(iter
)) {
4162 struct mailimap_status_info
* info
;
4164 info
= clist_content(iter
);
4165 switch (info
->st_att
) {
4166 case MAILIMAP_STATUS_ATT_MESSAGES
:
4168 * messages
= info
->st_value
;
4169 got_values
|= 1 << 0;
4173 case MAILIMAP_STATUS_ATT_UIDNEXT
:
4175 * uid_next
= info
->st_value
;
4176 got_values
|= 1 << 2;
4180 case MAILIMAP_STATUS_ATT_UIDVALIDITY
:
4182 * uid_validity
= info
->st_value
;
4183 got_values
|= 1 << 3;
4187 case MAILIMAP_STATUS_ATT_UNSEEN
:
4189 * unseen
= info
->st_value
;
4190 got_values
|= 1 << 4;
4196 mailimap_mailbox_data_status_free(data_status
);
4198 if (got_values
!= mask
) {
4199 g_warning("status: incomplete values received (%d)", got_values
);
4201 return MAILIMAP_NO_ERROR
;
4204 static void imap_free_capabilities(IMAPSession
*session
)
4206 slist_free_strings_full(session
->capability
);
4207 session
->capability
= NULL
;
4210 /* low-level IMAP4rev1 commands */
4212 static gint
imap_cmd_login(IMAPSession
*session
,
4213 const gchar
*user
, const gchar
*pass
,
4219 if (!strcmp(type
, "plaintext") && imap_has_capability(session
, "LOGINDISABLED")) {
4220 ok
= MAILIMAP_ERROR_BAD_STATE
;
4221 if (imap_has_capability(session
, "STARTTLS")) {
4223 log_warning(LOG_PROTOCOL
, _("Server requires STARTTLS to log in.\n"));
4224 ok
= imap_cmd_starttls(session
);
4225 if (ok
!= MAILIMAP_NO_ERROR
) {
4226 log_warning(LOG_PROTOCOL
, _("Can't start STARTTLS session.\n"));
4230 imap_free_capabilities(session
);
4231 if ((r
= imap_get_capabilities(session
)) != MAILIMAP_NO_ERROR
) {
4232 imap_handle_error(SESSION(session
), NULL
, r
);
4233 log_warning(LOG_PROTOCOL
, _("Can't refresh capabilities.\n"));
4238 log_error(LOG_PROTOCOL
, _("Connection to %s failed: "
4239 "server requires STARTTLS, but Claws Mail "
4240 "has been compiled without STARTTLS "
4242 SESSION(session
)->server
);
4243 return MAILIMAP_ERROR_LOGIN
;
4246 log_error(LOG_PROTOCOL
, _("Server logins are disabled.\n"));
4247 return MAILIMAP_ERROR_LOGIN
;
4251 log_print(LOG_PROTOCOL
, "IMAP> Logging %s to %s using %s\n",
4253 SESSION(session
)->server
,
4255 r
= imap_threaded_login(session
->folder
, user
, pass
, type
);
4256 if (r
!= MAILIMAP_NO_ERROR
) {
4257 imap_handle_error(SESSION(session
), NULL
, r
);
4258 log_print(LOG_PROTOCOL
, "IMAP< Error logging in to %s\n",
4259 SESSION(session
)->server
);
4262 log_print(LOG_PROTOCOL
, "IMAP< Login to %s successful\n",
4263 SESSION(session
)->server
);
4264 ok
= MAILIMAP_NO_ERROR
;
4269 static gint
imap_cmd_noop(IMAPSession
*session
)
4272 unsigned int exists
, recent
, expunge
, unseen
, uidnext
, uidval
;
4274 r
= imap_threaded_noop(session
->folder
, &exists
, &recent
, &expunge
, &unseen
, &uidnext
, &uidval
);
4275 if (r
!= MAILIMAP_NO_ERROR
) {
4276 imap_handle_error(SESSION(session
), NULL
, r
);
4277 debug_print("noop err %d\n", r
);
4281 if ((exists
&& exists
!= session
->exists
)
4282 || (recent
&& recent
!= session
->recent
)
4283 || (expunge
&& expunge
!= session
->expunge
)
4284 || (unseen
&& unseen
!= session
->unseen
)) {
4285 session
->folder_content_changed
= TRUE
;
4287 if (uidnext
!= 0 && uidnext
!= session
->uid_next
) {
4288 session
->uid_next
= uidnext
;
4289 session
->folder_content_changed
= TRUE
;
4291 if (uidval
!= 0 && uidval
!= session
->uid_validity
) {
4292 session
->uid_validity
= uidval
;
4293 session
->folder_content_changed
= TRUE
;
4296 session
->exists
= exists
;
4297 session
->recent
= recent
;
4298 session
->expunge
= expunge
;
4299 session
->unseen
= unseen
;
4301 session_set_access_time(SESSION(session
));
4303 return MAILIMAP_NO_ERROR
;
4307 static gint
imap_cmd_starttls(IMAPSession
*session
)
4311 r
= imap_threaded_starttls(session
->folder
,
4312 SESSION(session
)->server
, SESSION(session
)->port
);
4313 if (r
!= MAILIMAP_NO_ERROR
) {
4314 imap_handle_error(SESSION(session
), NULL
, r
);
4315 debug_print("STARTTLS err %d\n", r
);
4318 return MAILIMAP_NO_ERROR
;
4322 static gint
imap_cmd_select(IMAPSession
*session
, const gchar
*folder
,
4323 gint
*exists
, gint
*recent
, gint
*unseen
,
4324 guint32
*uid_validity
, gint
*can_create_flags
,
4325 GSList
**ok_flags
, gboolean block
)
4329 r
= imap_threaded_select(session
->folder
, folder
,
4330 exists
, recent
, unseen
, uid_validity
, can_create_flags
, ok_flags
);
4331 if (r
!= MAILIMAP_NO_ERROR
) {
4332 imap_handle_error(SESSION(session
), NULL
, r
);
4333 debug_print("select err %d\n", r
);
4336 return MAILIMAP_NO_ERROR
;
4339 static gint
imap_cmd_close(IMAPSession
*session
)
4343 r
= imap_threaded_close(session
->folder
);
4344 if (r
!= MAILIMAP_NO_ERROR
) {
4345 imap_handle_error(SESSION(session
), NULL
, r
);
4346 debug_print("close err %d\n", r
);
4349 g_free(session
->mbox
);
4350 session
->mbox
= NULL
;
4351 session
->exists
= 0;
4352 session
->recent
= 0;
4353 session
->expunge
= 0;
4354 return MAILIMAP_NO_ERROR
;
4357 static gint
imap_cmd_examine(IMAPSession
*session
, const gchar
*folder
,
4358 gint
*exists
, gint
*recent
, gint
*unseen
,
4359 guint32
*uid_validity
, gboolean block
)
4363 r
= imap_threaded_examine(session
->folder
, folder
,
4364 exists
, recent
, unseen
, uid_validity
);
4365 if (r
!= MAILIMAP_NO_ERROR
) {
4366 imap_handle_error(SESSION(session
), NULL
, r
);
4367 debug_print("examine err %d\n", r
);
4371 return MAILIMAP_NO_ERROR
;
4374 static gint
imap_cmd_create(IMAPSession
*session
, const gchar
*folder
)
4378 r
= imap_threaded_create(session
->folder
, folder
);
4379 if (r
!= MAILIMAP_NO_ERROR
) {
4380 imap_handle_error(SESSION(session
), NULL
, r
);
4384 return MAILIMAP_NO_ERROR
;
4387 static gint
imap_cmd_rename(IMAPSession
*session
, const gchar
*old_folder
,
4388 const gchar
*new_folder
)
4392 r
= imap_threaded_rename(session
->folder
, old_folder
,
4394 if (r
!= MAILIMAP_NO_ERROR
) {
4395 imap_handle_error(SESSION(session
), NULL
, r
);
4399 return MAILIMAP_NO_ERROR
;
4402 static gint
imap_cmd_delete(IMAPSession
*session
, const gchar
*folder
)
4407 r
= imap_threaded_delete(session
->folder
, folder
);
4408 if (r
!= MAILIMAP_NO_ERROR
) {
4409 imap_handle_error(SESSION(session
), NULL
, r
);
4413 return MAILIMAP_NO_ERROR
;
4416 typedef struct _fetch_data
{
4417 IMAPSession
*session
;
4419 const gchar
*filename
;
4425 static void *imap_cmd_fetch_thread(void *data
)
4427 fetch_data
*stuff
= (fetch_data
*)data
;
4428 IMAPSession
*session
= stuff
->session
;
4429 guint32 uid
= stuff
->uid
;
4430 const gchar
*filename
= stuff
->filename
;
4434 r
= imap_threaded_fetch_content(session
->folder
,
4438 r
= imap_threaded_fetch_content(session
->folder
,
4441 if (r
!= MAILIMAP_NO_ERROR
) {
4442 imap_handle_error(SESSION(session
), NULL
, r
);
4443 debug_print("fetch err %d\n", r
);
4444 return GINT_TO_POINTER(r
);
4446 return GINT_TO_POINTER(MAILIMAP_NO_ERROR
);
4449 static gint
imap_cmd_fetch(IMAPSession
*session
, guint32 uid
,
4450 const gchar
*filename
, gboolean headers
,
4453 fetch_data
*data
= g_new0(fetch_data
, 1);
4456 data
->session
= session
;
4458 data
->filename
= filename
;
4459 data
->headers
= headers
;
4462 if (prefs_common
.work_offline
&&
4463 !inc_offline_should_override(FALSE
,
4464 _("Claws Mail needs network access in order "
4465 "to access the IMAP server."))) {
4469 statusbar_print_all(_("Fetching message..."));
4470 result
= GPOINTER_TO_INT(imap_cmd_fetch_thread(data
));
4471 statusbar_pop_all();
4477 static gint
imap_cmd_append(IMAPSession
*session
,
4478 IMAPFolderItem
*item
,
4479 const gchar
*destfolder
,
4480 const gchar
*file
, IMAPFlags flags
,
4483 struct mailimap_flag_list
* flag_list
;
4486 cm_return_val_if_fail(file
!= NULL
, MAILIMAP_ERROR_BAD_STATE
);
4488 flag_list
= imap_flag_to_lep(item
, flags
, NULL
);
4489 lock_session(session
);
4490 r
= imap_threaded_append(session
->folder
, destfolder
,
4491 file
, flag_list
, (int *)new_uid
);
4492 mailimap_flag_list_free(flag_list
);
4494 if (r
!= MAILIMAP_NO_ERROR
) {
4495 imap_handle_error(SESSION(session
), NULL
, r
);
4496 debug_print("append err %d\n", r
);
4500 unlock_session(session
);
4502 return MAILIMAP_NO_ERROR
;
4505 static gint
imap_cmd_copy(IMAPSession
*session
, struct mailimap_set
* set
,
4506 const gchar
*destfolder
,
4507 struct mailimap_set
**source
, struct mailimap_set
**dest
)
4511 g_return_val_if_fail(session
!= NULL
, MAILIMAP_ERROR_BAD_STATE
);
4512 g_return_val_if_fail(set
!= NULL
, MAILIMAP_ERROR_BAD_STATE
);
4513 g_return_val_if_fail(destfolder
!= NULL
, MAILIMAP_ERROR_BAD_STATE
);
4515 r
= imap_threaded_copy(session
->folder
, set
, destfolder
, source
, dest
);
4516 if (r
!= MAILIMAP_NO_ERROR
) {
4517 imap_handle_error(SESSION(session
), NULL
, r
);
4521 return MAILIMAP_NO_ERROR
;
4524 static gint
imap_cmd_store(IMAPSession
*session
,
4525 IMAPFolderItem
*item
,
4526 struct mailimap_set
* set
,
4527 IMAPFlags flags
, GSList
*tags
, int do_add
)
4530 struct mailimap_flag_list
* flag_list
= NULL
;
4531 struct mailimap_store_att_flags
* store_att_flags
;
4533 flag_list
= imap_flag_to_lep(item
, flags
, tags
);
4537 mailimap_store_att_flags_new_add_flags_silent(flag_list
);
4540 mailimap_store_att_flags_new_remove_flags_silent(flag_list
);
4542 r
= imap_threaded_store(session
->folder
, set
, store_att_flags
);
4543 mailimap_store_att_flags_free(store_att_flags
);
4544 if (r
!= MAILIMAP_NO_ERROR
) {
4545 imap_handle_error(SESSION(session
), NULL
, r
);
4549 return MAILIMAP_NO_ERROR
;
4552 static gint
imap_cmd_expunge(IMAPSession
*session
)
4556 if (prefs_common
.work_offline
&&
4557 !inc_offline_should_override(FALSE
,
4558 _("Claws Mail needs network access in order "
4559 "to access the IMAP server."))) {
4563 statusbar_print_all(_("Expunging deleted messages..."));
4564 r
= imap_threaded_expunge(session
->folder
);
4565 statusbar_pop_all();
4566 if (r
!= MAILIMAP_NO_ERROR
) {
4567 imap_handle_error(SESSION(session
), NULL
, r
);
4571 return MAILIMAP_NO_ERROR
;
4574 gint
imap_expunge(Folder
*folder
, FolderItem
*item
)
4576 IMAPSession
*session
= imap_session_get(folder
);
4577 if (session
== NULL
)
4580 return imap_cmd_expunge(session
);
4583 static void imap_path_separator_subst(gchar
*str
, gchar separator
)
4586 gboolean in_escape
= FALSE
;
4588 if (!separator
|| separator
== '/') return;
4590 for (p
= str
; *p
!= '\0'; p
++) {
4591 if (*p
== '/' && !in_escape
)
4593 else if (*p
== '&' && *(p
+ 1) != '-' && !in_escape
)
4595 else if (*p
== '-' && in_escape
)
4600 static gboolean
imap_rename_folder_func(GNode
*node
, gpointer data
)
4602 FolderItem
*item
= node
->data
;
4603 gchar
**paths
= data
;
4604 const gchar
*oldpath
= paths
[0];
4605 const gchar
*newpath
= paths
[1];
4606 gchar
*real_oldpath
, *real_newpath
;
4608 gchar
*new_itempath
;
4610 IMAPSession
*session
= imap_session_get(item
->folder
);
4611 gint ok
= MAILIMAP_NO_ERROR
;
4612 oldpathlen
= strlen(oldpath
);
4613 if (strncmp(oldpath
, item
->path
, oldpathlen
) != 0) {
4614 g_warning("path doesn't match: %s, %s", oldpath
, item
->path
);
4618 base
= item
->path
+ oldpathlen
;
4619 while (*base
== '/') base
++;
4621 new_itempath
= g_strdup(newpath
);
4623 new_itempath
= g_strconcat(newpath
, "/", base
,
4626 real_oldpath
= imap_get_real_path(session
, IMAP_FOLDER(item
->folder
), item
->path
, &ok
);
4628 item
->path
= new_itempath
;
4630 real_newpath
= imap_get_real_path(session
, IMAP_FOLDER(item
->folder
), item
->path
, &ok
);
4632 imap_threaded_subscribe(item
->folder
, real_oldpath
, FALSE
);
4633 imap_threaded_subscribe(item
->folder
, real_newpath
, TRUE
);
4635 g_free(real_oldpath
);
4636 g_free(real_newpath
);
4640 static gint
get_list_of_uids(IMAPSession
*session
, Folder
*folder
, IMAPFolderItem
*item
, GSList
**msgnum_list
)
4642 GSList
*uidlist
, *elem
;
4644 clist
* lep_uidlist
;
4645 gint ok
, nummsgs
= 0;
4647 if (session
== NULL
) {
4651 ok
= imap_select(session
, IMAP_FOLDER(folder
), FOLDER_ITEM(item
),
4652 NULL
, NULL
, NULL
, NULL
, NULL
, TRUE
);
4653 if (ok
!= MAILIMAP_NO_ERROR
) {
4657 g_slist_free(item
->uid_list
);
4658 item
->uid_list
= NULL
;
4662 if (folder
->account
&& folder
->account
->low_bandwidth
) {
4663 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_SIMPLE
,
4664 NULL
, NULL
, NULL
, &lep_uidlist
);
4667 if (r
== MAILIMAP_NO_ERROR
) {
4668 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
4669 mailimap_search_result_free(lep_uidlist
);
4671 carray
* lep_uidtab
;
4672 if (r
!= -1) { /* inited */
4673 imap_handle_error(SESSION(session
), NULL
, r
);
4677 r
= imap_threaded_fetch_uid(folder
, 1,
4679 if (r
== MAILIMAP_NO_ERROR
) {
4680 uidlist
= imap_uid_list_from_lep_tab(lep_uidtab
);
4681 imap_fetch_uid_list_free(lep_uidtab
);
4685 if (r
!= MAILIMAP_NO_ERROR
) {
4686 imap_handle_error(SESSION(session
), NULL
, r
);
4690 for (elem
= uidlist
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
4693 msgnum
= GPOINTER_TO_INT(elem
->data
);
4695 *msgnum_list
= g_slist_prepend(*msgnum_list
, GINT_TO_POINTER(msgnum
));
4696 item
->uid_list
= g_slist_prepend(item
->uid_list
, GINT_TO_POINTER(msgnum
));
4699 g_slist_free(uidlist
);
4705 gint
imap_get_num_list(Folder
*folder
, FolderItem
*_item
, GSList
**msgnum_list
, gboolean
*old_uids_valid
)
4707 IMAPFolderItem
*item
= (IMAPFolderItem
*)_item
;
4708 IMAPSession
*session
;
4710 GSList
*uidlist
= NULL
;
4712 gint known_list_len
= 0;
4715 debug_print("get_num_list\n");
4717 g_return_val_if_fail(folder
!= NULL
, -1);
4718 g_return_val_if_fail(item
!= NULL
, -1);
4719 g_return_val_if_fail(item
->item
.path
!= NULL
, -1);
4720 g_return_val_if_fail(FOLDER_CLASS(folder
) == &imap_class
, -1);
4721 g_return_val_if_fail(folder
->account
!= NULL
, -1);
4723 known_list_len
= g_slist_length(item
->uid_list
);
4724 if (!item
->should_update
) {
4725 debug_print("get_num_list: nothing to update\n");
4726 *old_uids_valid
= TRUE
;
4727 if (known_list_len
== item
->item
.total_msgs
4728 && known_list_len
> 0) {
4729 *msgnum_list
= g_slist_copy(item
->uid_list
);
4730 return known_list_len
;
4732 debug_print("don't know the list length...\n");
4736 if (prefs_common
.work_offline
&&
4737 !inc_offline_should_override(FALSE
,
4738 _("Claws Mail needs network access in order "
4739 "to access the IMAP server."))) {
4743 path
= folder_item_get_path(_item
);
4744 if (!is_dir_exist(path
)) {
4745 if(is_file_exist(path
))
4747 make_dir_hier(path
);
4751 debug_print("getting session...\n");
4752 session
= imap_session_get(folder
);
4753 g_return_val_if_fail(session
!= NULL
, -1);
4755 lock_session(session
);
4756 if (FOLDER_ITEM(item
)->path
)
4757 statusbar_print_all(_("Scanning folder %s/%s..."),
4758 FOLDER_ITEM(item
)->folder
->name
,
4759 FOLDER_ITEM(item
)->path
);
4761 statusbar_print_all(_("Scanning folder %s..."),
4762 FOLDER_ITEM(item
)->folder
->name
);
4764 if (item
->should_trash_cache
) {
4765 *old_uids_valid
= FALSE
;
4766 debug_print("get_num_list: trashing num list\n");
4767 debug_print("Freeing imap uid cache\n");
4769 g_slist_free(item
->uid_list
);
4770 item
->uid_list
= NULL
;
4772 imap_delete_all_cached_messages((FolderItem
*)item
);
4774 debug_print("get_num_list: updating num list\n");
4775 *old_uids_valid
= TRUE
;
4778 nummsgs
= get_list_of_uids(session
, folder
, item
, &uidlist
);
4780 unlock_session(session
);
4782 /* session could be broken now, in case of fatal error */
4784 debug_print("get_num_list: got %d msgs\n", nummsgs
);
4787 statusbar_pop_all();
4791 *msgnum_list
= uidlist
;
4793 dir
= folder_item_get_path((FolderItem
*)item
);
4794 debug_print("removing old messages from %s\n", dir
);
4795 remove_numbered_files_not_in_list(dir
, *msgnum_list
);
4798 debug_print("get_num_list - ok - %i\n", nummsgs
);
4799 statusbar_pop_all();
4800 item
->should_trash_cache
= FALSE
;
4801 item
->should_update
= FALSE
;
4805 static MsgInfo
*imap_parse_msg(const gchar
*file
, FolderItem
*item
)
4810 flags
.perm_flags
= MSG_NEW
|MSG_UNREAD
;
4811 flags
.tmp_flags
= 0;
4813 g_return_val_if_fail(item
!= NULL
, NULL
);
4814 g_return_val_if_fail(file
!= NULL
, NULL
);
4816 if (folder_has_parent_of_type(item
, F_QUEUE
)) {
4817 MSG_SET_TMP_FLAGS(flags
, MSG_QUEUED
);
4818 } else if (folder_has_parent_of_type(item
, F_DRAFT
)) {
4819 MSG_SET_TMP_FLAGS(flags
, MSG_DRAFT
);
4822 msginfo
= procheader_parse_file(file
, flags
, FALSE
, FALSE
);
4823 if (!msginfo
) return NULL
;
4825 msginfo
->plaintext_file
= g_strdup(file
);
4826 msginfo
->folder
= item
;
4831 GSList
*imap_get_msginfos(Folder
*folder
, FolderItem
*item
,
4832 GSList
*msgnum_list
)
4834 IMAPSession
*session
;
4835 MsgInfoList
*ret
= NULL
;
4838 debug_print("get_msginfos\n");
4840 g_return_val_if_fail(folder
!= NULL
, NULL
);
4841 g_return_val_if_fail(item
!= NULL
, NULL
);
4842 g_return_val_if_fail(msgnum_list
!= NULL
, NULL
);
4844 debug_print("getting session...\n");
4845 session
= imap_session_get(folder
);
4846 g_return_val_if_fail(session
!= NULL
, NULL
);
4848 lock_session(session
); /* unlocked later in the function */
4850 debug_print("IMAP getting msginfos\n");
4851 ok
= imap_select(session
, IMAP_FOLDER(folder
), item
,
4852 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
4853 if (ok
!= MAILIMAP_NO_ERROR
) {
4856 if (!(folder_has_parent_of_type(item
, F_DRAFT
) ||
4857 folder_has_parent_of_type(item
, F_QUEUE
))) {
4858 ret
= g_slist_concat(ret
,
4859 imap_get_uncached_messages(session
, item
,
4861 if (ok
!= MAILIMAP_NO_ERROR
)
4863 unlock_session(session
);
4865 MsgNumberList
*sorted_list
, *elem
, *llast
= NULL
;
4866 gint startnum
, lastnum
;
4868 unlock_session(session
);
4870 sorted_list
= g_slist_sort(g_slist_copy(msgnum_list
), g_int_compare
);
4872 startnum
= lastnum
= GPOINTER_TO_INT(sorted_list
->data
);
4874 llast
= g_slist_last(ret
);
4875 for (elem
= sorted_list
;; elem
= g_slist_next(elem
)) {
4879 num
= GPOINTER_TO_INT(elem
->data
);
4881 if (num
> lastnum
+ 1 || elem
== NULL
) {
4883 for (i
= startnum
; i
<= lastnum
; ++i
) {
4885 file
= imap_fetch_msg(folder
, item
, i
);
4887 MsgInfo
*msginfo
= imap_parse_msg(file
, item
);
4888 if (msginfo
!= NULL
) {
4889 msginfo
->msgnum
= i
;
4891 llast
= ret
= g_slist_append(ret
, msginfo
);
4893 llast
= g_slist_append(llast
, msginfo
);
4894 llast
= llast
->next
;
4909 g_slist_free(sorted_list
);
4914 MsgInfo
*imap_get_msginfo(Folder
*folder
, FolderItem
*item
, gint uid
)
4916 MsgInfo
*msginfo
= NULL
;
4917 MsgInfoList
*msginfolist
;
4918 MsgNumberList numlist
;
4920 numlist
.next
= NULL
;
4921 numlist
.data
= GINT_TO_POINTER(uid
);
4923 msginfolist
= imap_get_msginfos(folder
, item
, &numlist
);
4924 if (msginfolist
!= NULL
) {
4925 msginfo
= msginfolist
->data
;
4926 g_slist_free(msginfolist
);
4932 gboolean
imap_scan_required(Folder
*folder
, FolderItem
*_item
)
4934 IMAPSession
*session
;
4935 IMAPFolderItem
*item
= (IMAPFolderItem
*)_item
;
4936 gint ok
, exists
= 0, unseen
= 0;
4937 guint32 uid_next
= 0, uid_val
= 0;
4938 gboolean selected_folder
;
4940 g_return_val_if_fail(folder
!= NULL
, FALSE
);
4941 g_return_val_if_fail(item
!= NULL
, FALSE
);
4942 g_return_val_if_fail(item
->item
.folder
!= NULL
, FALSE
);
4943 g_return_val_if_fail(FOLDER_CLASS(item
->item
.folder
) == &imap_class
, FALSE
);
4945 if (item
->item
.path
== NULL
)
4948 if (item
->should_update
) {
4949 debug_print("scan already required\n");
4952 debug_print("getting session...\n");
4953 session
= imap_session_get(folder
);
4955 g_return_val_if_fail(session
!= NULL
, FALSE
);
4956 lock_session(session
); /* unlocked later in the function */
4958 selected_folder
= (session
->mbox
!= NULL
) &&
4959 (!strcmp(session
->mbox
, item
->item
.path
));
4960 if (selected_folder
) {
4961 if (!session
->folder_content_changed
) {
4962 ok
= imap_cmd_noop(session
);
4963 if (ok
!= MAILIMAP_NO_ERROR
) {
4964 debug_print("disconnected!\n");
4966 session
= imap_reconnect_if_possible(folder
, session
);
4968 session
= imap_session_get(folder
);
4969 if (session
== NULL
)
4973 if (session
->folder_content_changed
) {
4974 debug_print("CHANGED (self-noop)! scan_required\n");
4975 item
->should_update
= TRUE
;
4976 if (session
->uid_validity
&& session
->uid_validity
!= item
->item
.mtime
) {
4977 item
->item
.mtime
= session
->uid_validity
;
4978 item
->should_trash_cache
= TRUE
;
4980 unlock_session(session
);
4984 debug_print("CHANGED (previous noop)! scan_required\n");
4985 item
->should_update
= TRUE
;
4986 if (session
->uid_validity
&& session
->uid_validity
!= item
->item
.mtime
) {
4987 item
->item
.mtime
= session
->uid_validity
;
4988 item
->should_trash_cache
= TRUE
;
4990 unlock_session(session
);
4994 ok
= imap_status(session
, IMAP_FOLDER(folder
), item
->item
.path
, IMAP_FOLDER_ITEM(item
),
4995 &exists
, &uid_next
, &uid_val
, &unseen
, FALSE
);
4996 if (ok
!= MAILIMAP_NO_ERROR
) {
5000 debug_print("exists %d, item->item.total_msgs %d\n"
5001 "\tunseen %d, item->item.unread_msgs %d\n"
5002 "\tuid_next %d, item->uid_next %d\n"
5003 "\tuid_val %d, item->item.mtime %ld\n",
5004 exists
, item
->item
.total_msgs
, unseen
, item
->item
.unread_msgs
,
5005 uid_next
, item
->uid_next
, uid_val
, (long)(item
->item
.mtime
));
5006 if (exists
!= item
->item
.total_msgs
5007 || unseen
!= item
->item
.unread_msgs
5008 || uid_next
!= item
->uid_next
5009 || uid_val
!= item
->item
.mtime
) {
5010 debug_print("CHANGED (status)! scan_required\n");
5011 item
->last_change
= time(NULL
);
5012 item
->should_update
= TRUE
;
5013 item
->uid_next
= uid_next
;
5014 if (uid_val
!= item
->item
.mtime
) {
5015 item
->item
.mtime
= uid_val
;
5016 item
->should_trash_cache
= TRUE
;
5018 unlock_session(session
);
5022 unlock_session(session
);
5024 item
->should_update
= FALSE
;
5028 void imap_change_flags(Folder
*folder
, FolderItem
*item
, MsgInfo
*msginfo
, MsgPermFlags newflags
)
5030 IMAPSession
*session
;
5031 IMAPFlags flags_set
= 0, flags_unset
= 0;
5032 gint ok
= MAILIMAP_NO_ERROR
;
5033 MsgNumberList numlist
;
5034 hashtable_data
*ht_data
= NULL
;
5036 g_return_if_fail(folder
!= NULL
);
5037 g_return_if_fail(folder
->klass
== &imap_class
);
5038 g_return_if_fail(item
!= NULL
);
5039 g_return_if_fail(item
->folder
== folder
);
5040 g_return_if_fail(msginfo
!= NULL
);
5041 g_return_if_fail(msginfo
->folder
== item
);
5043 if (!MSG_IS_MARKED(msginfo
->flags
) && (newflags
& MSG_MARKED
))
5044 flags_set
|= IMAP_FLAG_FLAGGED
;
5045 if ( MSG_IS_MARKED(msginfo
->flags
) && !(newflags
& MSG_MARKED
))
5046 flags_unset
|= IMAP_FLAG_FLAGGED
;
5048 if (!MSG_IS_UNREAD(msginfo
->flags
) && (newflags
& MSG_UNREAD
))
5049 flags_unset
|= IMAP_FLAG_SEEN
;
5050 if ( MSG_IS_UNREAD(msginfo
->flags
) && !(newflags
& MSG_UNREAD
))
5051 flags_set
|= IMAP_FLAG_SEEN
;
5053 if (!MSG_IS_REPLIED(msginfo
->flags
) && (newflags
& MSG_REPLIED
))
5054 flags_set
|= IMAP_FLAG_ANSWERED
;
5055 if ( MSG_IS_REPLIED(msginfo
->flags
) && !(newflags
& MSG_REPLIED
))
5056 flags_unset
|= IMAP_FLAG_ANSWERED
;
5058 if (!MSG_IS_FORWARDED(msginfo
->flags
) && (newflags
& MSG_FORWARDED
))
5059 flags_set
|= IMAP_FLAG_FORWARDED
;
5060 if ( MSG_IS_FORWARDED(msginfo
->flags
) && !(newflags
& MSG_FORWARDED
))
5061 flags_unset
|= IMAP_FLAG_FORWARDED
;
5063 if (!MSG_IS_SPAM(msginfo
->flags
) && (newflags
& MSG_SPAM
)) {
5064 flags_set
|= IMAP_FLAG_SPAM
;
5065 flags_unset
|= IMAP_FLAG_HAM
;
5067 if ( MSG_IS_SPAM(msginfo
->flags
) && !(newflags
& MSG_SPAM
)) {
5068 flags_set
|= IMAP_FLAG_HAM
;
5069 flags_unset
|= IMAP_FLAG_SPAM
;
5071 if (!MSG_IS_DELETED(msginfo
->flags
) && (newflags
& MSG_DELETED
))
5072 flags_set
|= IMAP_FLAG_DELETED
;
5073 if ( MSG_IS_DELETED(msginfo
->flags
) && !(newflags
& MSG_DELETED
))
5074 flags_unset
|= IMAP_FLAG_DELETED
;
5076 if (!flags_set
&& !flags_unset
) {
5077 /* the changed flags were not translatable to IMAP-speak.
5078 * like MSG_POSTFILTERED, so just apply. */
5079 msginfo
->flags
.perm_flags
= newflags
;
5083 debug_print("getting session...\n");
5084 session
= imap_session_get(folder
);
5089 if ((ok
= imap_select(session
, IMAP_FOLDER(folder
), msginfo
->folder
,
5090 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
)) != MAILIMAP_NO_ERROR
) {
5093 numlist
.next
= NULL
;
5094 numlist
.data
= GINT_TO_POINTER(msginfo
->msgnum
);
5096 if (IMAP_FOLDER_ITEM(item
)->batching
) {
5097 /* instead of performing an UID STORE command for each message change,
5098 * as a lot of them can change "together", we just fill in hashtables
5099 * and defer the treatment so that we're able to send only one
5102 debug_print("IMAP batch mode on, deferring flags change\n");
5104 ht_data
= g_hash_table_lookup(IMAP_FOLDER_ITEM(item
)->flags_set_table
,
5105 GINT_TO_POINTER(flags_set
));
5106 if (ht_data
== NULL
) {
5107 ht_data
= g_new0(hashtable_data
, 1);
5108 ht_data
->item
= IMAP_FOLDER_ITEM(item
);
5109 g_hash_table_insert(IMAP_FOLDER_ITEM(item
)->flags_set_table
,
5110 GINT_TO_POINTER(flags_set
), ht_data
);
5112 ht_data
->msglist
= g_slist_prepend(ht_data
->msglist
, GINT_TO_POINTER(msginfo
->msgnum
));
5115 ht_data
= g_hash_table_lookup(IMAP_FOLDER_ITEM(item
)->flags_unset_table
,
5116 GINT_TO_POINTER(flags_unset
));
5117 if (ht_data
== NULL
) {
5118 ht_data
= g_new0(hashtable_data
, 1);
5119 ht_data
->item
= IMAP_FOLDER_ITEM(item
);
5120 g_hash_table_insert(IMAP_FOLDER_ITEM(item
)->flags_unset_table
,
5121 GINT_TO_POINTER(flags_unset
), ht_data
);
5123 ht_data
->msglist
= g_slist_prepend(ht_data
->msglist
,
5124 GINT_TO_POINTER(msginfo
->msgnum
));
5127 debug_print("IMAP changing flags\n");
5129 ok
= imap_set_message_flags(session
, IMAP_FOLDER_ITEM(item
), &numlist
, flags_set
, NULL
, TRUE
);
5130 if (ok
!= MAILIMAP_NO_ERROR
) {
5136 ok
= imap_set_message_flags(session
, IMAP_FOLDER_ITEM(item
), &numlist
, flags_unset
, NULL
, FALSE
);
5137 if (ok
!= MAILIMAP_NO_ERROR
) {
5142 msginfo
->flags
.perm_flags
= newflags
;
5146 static gint
imap_remove_msg(Folder
*folder
, FolderItem
*item
, gint uid
)
5149 IMAPSession
*session
;
5151 MsgNumberList numlist
;
5153 g_return_val_if_fail(folder
!= NULL
, -1);
5154 g_return_val_if_fail(FOLDER_CLASS(folder
) == &imap_class
, -1);
5155 g_return_val_if_fail(item
!= NULL
, -1);
5157 debug_print("getting session...\n");
5158 session
= imap_session_get(folder
);
5159 if (!session
) return -1;
5161 ok
= imap_select(session
, IMAP_FOLDER(folder
), item
,
5162 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
5163 if (ok
!= MAILIMAP_NO_ERROR
) {
5166 numlist
.next
= NULL
;
5167 numlist
.data
= GINT_TO_POINTER(uid
);
5169 ok
= imap_set_message_flags
5170 (session
, IMAP_FOLDER_ITEM(item
), &numlist
, IMAP_FLAG_DELETED
, NULL
, TRUE
);
5171 if (ok
!= MAILIMAP_NO_ERROR
) {
5172 log_warning(LOG_PROTOCOL
, _("can't set deleted flags: %d\n"), uid
);
5176 ok
= imap_cmd_expunge(session
);
5178 if (ok
!= MAILIMAP_NO_ERROR
) {
5179 log_warning(LOG_PROTOCOL
, _("can't expunge\n"));
5183 IMAP_FOLDER_ITEM(item
)->uid_list
= g_slist_remove(
5184 IMAP_FOLDER_ITEM(item
)->uid_list
, numlist
.data
);
5185 dir
= folder_item_get_path(item
);
5186 if (is_dir_exist(dir
))
5187 remove_numbered_files(dir
, uid
, uid
);
5189 return MAILIMAP_NO_ERROR
;
5192 static gint
compare_msginfo(gconstpointer a
, gconstpointer b
)
5194 return ((MsgInfo
*)a
)->msgnum
- ((MsgInfo
*)b
)->msgnum
;
5197 static guint
gslist_find_next_num(MsgNumberList
**list
, guint num
)
5201 g_return_val_if_fail(list
!= NULL
, -1);
5203 for (elem
= *list
; elem
!= NULL
; elem
= g_slist_next(elem
))
5204 if (GPOINTER_TO_INT(elem
->data
) >= num
)
5207 return elem
!= NULL
? GPOINTER_TO_INT(elem
->data
) : (gint
)-1;
5210 static gboolean
flag_ok(IMAPFolderItem
*item
, guint flag
)
5212 if (item
->ok_flags
&& g_slist_find(item
->ok_flags
, GUINT_TO_POINTER(flag
))) {
5213 debug_print("flag %d is OK\n", flag
);
5216 if (item
->can_create_flags
== ITEM_CAN_CREATE_FLAGS
) {
5217 debug_print("creating flags is OK\n");
5224 * NEW and DELETED flags are not syncronized
5225 * - The NEW/RECENT flags in IMAP folders can not really be directly
5226 * modified by Claws Mail
5227 * - The DELETE/DELETED flag in IMAP and Claws Mail do not have the same
5228 * meaning, in IMAP it always removes the messages from the FolderItem
5229 * in Claws Mail it can mean to move the message to Trash
5232 typedef struct _get_flags_data
{
5235 MsgInfoList
*msginfo_list
;
5236 GHashTable
*msgflags
;
5237 gboolean full_search
;
5241 static /*gint*/ void *imap_get_flags_thread(void *data
)
5243 get_flags_data
*stuff
= (get_flags_data
*)data
;
5244 Folder
*folder
= stuff
->folder
;
5245 FolderItem
*fitem
= (FolderItem
*) stuff
->item
;
5246 MsgInfoList
*msginfo_list
= stuff
->msginfo_list
;
5247 GHashTable
*msgflags
= stuff
->msgflags
;
5249 carray
* lep_uidtab
;
5250 IMAPSession
*session
;
5252 int r
= MAILIMAP_NO_ERROR
;
5253 GHashTable
*flags_hash
= NULL
;
5254 GHashTable
*tags_hash
= NULL
;
5255 gboolean full_search
= stuff
->full_search
;
5256 GSList
*sorted_list
= NULL
;
5257 GSList
*unseen
= NULL
, *answered
= NULL
, *flagged
= NULL
, *deleted
= NULL
, *forwarded
= NULL
, *spam
= NULL
;
5258 GSList
*seq_list
, *cur
;
5259 gboolean reverse_seen
= FALSE
;
5260 gboolean selected_folder
;
5261 gint exists_cnt
, unseen_cnt
;
5262 gboolean got_alien_tags
= FALSE
;
5264 session
= imap_session_get(folder
);
5266 if (session
== NULL
) {
5268 return GINT_TO_POINTER(-1);
5270 selected_folder
= (session
->mbox
!= NULL
) &&
5271 (!strcmp(session
->mbox
, fitem
->path
));
5273 lock_session(session
);
5274 if (!selected_folder
) {
5275 ok
= imap_select(session
, IMAP_FOLDER(folder
), fitem
,
5276 &exists_cnt
, NULL
, &unseen_cnt
, NULL
, NULL
, TRUE
);
5277 if (ok
!= MAILIMAP_NO_ERROR
) {
5279 return GINT_TO_POINTER(-1);
5282 if (unseen_cnt
> exists_cnt
/ 2)
5283 reverse_seen
= TRUE
;
5286 if (fitem
->unread_msgs
> fitem
->total_msgs
/ 2)
5287 reverse_seen
= TRUE
;
5290 sorted_list
= g_slist_sort(g_slist_copy(msginfo_list
), compare_msginfo
);
5292 seq_list
= imap_get_lep_set_from_msglist(IMAP_FOLDER(folder
), msginfo_list
);
5294 struct mailimap_set
* set
;
5295 set
= mailimap_set_new_interval(1, 0);
5296 seq_list
= g_slist_append(NULL
, set
);
5299 if (folder
->account
&& folder
->account
->low_bandwidth
) {
5300 for (cur
= seq_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
5301 struct mailimap_set
* imapset
;
5302 clist
* lep_uidlist
;
5305 imapset
= cur
->data
;
5307 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_SEEN
, NULL
,
5308 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5311 r
= imap_threaded_search(folder
,
5312 IMAP_SEARCH_TYPE_UNSEEN
, NULL
,
5313 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5315 if (r
== MAILIMAP_NO_ERROR
) {
5318 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5319 mailimap_search_result_free(lep_uidlist
);
5321 unseen
= g_slist_concat(unseen
, uidlist
);
5323 imap_handle_error(SESSION(session
), NULL
, r
);
5327 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_FLAGGED
, NULL
,
5328 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5329 if (r
== MAILIMAP_NO_ERROR
) {
5332 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5333 mailimap_search_result_free(lep_uidlist
);
5335 flagged
= g_slist_concat(flagged
, uidlist
);
5337 imap_handle_error(SESSION(session
), NULL
, r
);
5341 if (fitem
->opened
|| fitem
->processing_pending
|| fitem
== folder
->inbox
) {
5342 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_ANSWERED
, NULL
,
5343 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5344 if (r
== MAILIMAP_NO_ERROR
) {
5347 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5348 mailimap_search_result_free(lep_uidlist
);
5350 answered
= g_slist_concat(answered
, uidlist
);
5352 imap_handle_error(SESSION(session
), NULL
, r
);
5356 if (flag_ok(IMAP_FOLDER_ITEM(fitem
), IMAP_FLAG_FORWARDED
)) {
5357 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_FORWARDED
, NULL
,
5358 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5359 if (r
== MAILIMAP_NO_ERROR
) {
5362 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5363 mailimap_search_result_free(lep_uidlist
);
5365 forwarded
= g_slist_concat(forwarded
, uidlist
);
5367 imap_handle_error(SESSION(session
), NULL
, r
);
5372 if (flag_ok(IMAP_FOLDER_ITEM(fitem
), IMAP_FLAG_SPAM
)) {
5373 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_SPAM
, NULL
,
5374 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5375 if (r
== MAILIMAP_NO_ERROR
) {
5378 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5379 mailimap_search_result_free(lep_uidlist
);
5381 spam
= g_slist_concat(spam
, uidlist
);
5383 imap_handle_error(SESSION(session
), NULL
, r
);
5388 r
= imap_threaded_search(folder
, IMAP_SEARCH_TYPE_DELETED
, NULL
,
5389 NULL
, full_search
? NULL
:imapset
, &lep_uidlist
);
5390 if (r
== MAILIMAP_NO_ERROR
) {
5393 uidlist
= imap_uid_list_from_lep(lep_uidlist
, NULL
);
5394 mailimap_search_result_free(lep_uidlist
);
5396 deleted
= g_slist_concat(deleted
, uidlist
);
5398 imap_handle_error(SESSION(session
), NULL
, r
);
5405 r
= imap_threaded_fetch_uid_flags(folder
, 1, &lep_uidtab
);
5406 if (r
== MAILIMAP_NO_ERROR
) {
5407 flags_hash
= g_hash_table_new_full(g_direct_hash
, g_direct_equal
, NULL
, NULL
);
5408 tags_hash
= g_hash_table_new_full(g_direct_hash
, g_direct_equal
, NULL
, NULL
);
5409 imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab
, flags_hash
, tags_hash
);
5410 imap_fetch_uid_flags_list_free(lep_uidtab
);
5412 imap_handle_error(SESSION(session
), NULL
, r
);
5418 if (r
== MAILIMAP_NO_ERROR
)
5419 unlock_session(session
);
5421 for (elem
= sorted_list
; elem
!= NULL
; elem
= g_slist_next(elem
)) {
5423 MsgPermFlags flags
, oldflags
;
5426 msginfo
= (MsgInfo
*) elem
->data
;
5427 flags
= msginfo
->flags
.perm_flags
;
5428 wasnew
= (flags
& MSG_NEW
);
5429 oldflags
= flags
& ~(MSG_NEW
|MSG_UNREAD
|MSG_REPLIED
|MSG_FORWARDED
|MSG_MARKED
|MSG_DELETED
|MSG_SPAM
);
5431 if (folder
->account
&& folder
->account
->low_bandwidth
) {
5432 if (fitem
->opened
|| fitem
->processing_pending
|| fitem
== folder
->inbox
) {
5433 flags
&= ~((reverse_seen
? 0 : MSG_UNREAD
| MSG_NEW
) | MSG_REPLIED
| MSG_FORWARDED
| MSG_MARKED
| MSG_SPAM
);
5435 flags
&= ~((reverse_seen
? 0 : MSG_UNREAD
| MSG_NEW
| MSG_MARKED
));
5438 flags
|= MSG_UNREAD
| (wasnew
? MSG_NEW
: 0);
5439 if (gslist_find_next_num(&unseen
, msginfo
->msgnum
) == msginfo
->msgnum
) {
5440 if (!reverse_seen
) {
5441 flags
|= MSG_UNREAD
| (wasnew
? MSG_NEW
: 0);
5443 flags
&= ~(MSG_UNREAD
| MSG_NEW
);
5447 if (gslist_find_next_num(&flagged
, msginfo
->msgnum
) == msginfo
->msgnum
)
5448 flags
|= MSG_MARKED
;
5450 flags
&= ~MSG_MARKED
;
5452 if (fitem
->opened
|| fitem
->processing_pending
|| fitem
== folder
->inbox
) {
5453 if (gslist_find_next_num(&answered
, msginfo
->msgnum
) == msginfo
->msgnum
)
5454 flags
|= MSG_REPLIED
;
5456 flags
&= ~MSG_REPLIED
;
5457 if (gslist_find_next_num(&forwarded
, msginfo
->msgnum
) == msginfo
->msgnum
)
5458 flags
|= MSG_FORWARDED
;
5460 flags
&= ~MSG_FORWARDED
;
5461 if (gslist_find_next_num(&spam
, msginfo
->msgnum
) == msginfo
->msgnum
)
5465 if (gslist_find_next_num(&deleted
, msginfo
->msgnum
) == msginfo
->msgnum
)
5466 flags
|= MSG_DELETED
;
5468 flags
&= ~MSG_DELETED
;
5471 if (flags_hash
!= NULL
) {
5473 flags
= GPOINTER_TO_INT(g_hash_table_lookup(flags_hash
,
5474 GINT_TO_POINTER(msginfo
->msgnum
)));
5477 if ((flags
& MSG_UNREAD
) == 0)
5483 if (tags_hash
!= NULL
) {
5484 GSList
*tags
= g_hash_table_lookup(tags_hash
, GINT_TO_POINTER(msginfo
->msgnum
));
5487 g_slist_free(msginfo
->tags
);
5488 msginfo
->tags
= NULL
;
5490 for (cur
= tags
; cur
; cur
= cur
->next
) {
5491 gchar
*real_tag
= imap_modified_utf7_to_utf8(cur
->data
, TRUE
);
5493 id
= tags_get_id_for_str(real_tag
);
5495 id
= tags_add_tag(real_tag
);
5496 got_alien_tags
= TRUE
;
5498 msginfo
->tags
= g_slist_append(
5500 GINT_TO_POINTER(id
));
5503 slist_free_strings_full(tags
);
5507 g_hash_table_insert(msgflags
, msginfo
, GINT_TO_POINTER(flags
));
5510 if (got_alien_tags
) {
5512 main_window_reflect_tags_changes(mainwindow_get_mainwindow());
5516 g_hash_table_destroy(flags_hash
);
5518 g_hash_table_destroy(tags_hash
);
5520 imap_lep_set_free(seq_list
);
5521 g_slist_free(flagged
);
5522 g_slist_free(deleted
);
5523 g_slist_free(answered
);
5524 g_slist_free(forwarded
);
5526 g_slist_free(unseen
);
5527 g_slist_free(sorted_list
);
5530 return GINT_TO_POINTER(0);
5533 static gint
imap_get_flags(Folder
*folder
, FolderItem
*item
,
5534 MsgInfoList
*msginfo_list
, GHashTable
*msgflags
)
5537 get_flags_data
*data
= g_new0(get_flags_data
, 1);
5539 data
->folder
= folder
;
5541 data
->msginfo_list
= msginfo_list
;
5542 data
->msgflags
= msgflags
;
5543 data
->full_search
= FALSE
;
5545 GSList
*tmp
= NULL
, *cur
;
5547 if (prefs_common
.work_offline
&&
5548 !inc_offline_should_override(FALSE
,
5549 _("Claws Mail needs network access in order "
5550 "to access the IMAP server."))) {
5555 tmp
= folder_item_get_msg_list(item
);
5557 if (g_slist_length(tmp
) <= g_slist_length(msginfo_list
))
5558 data
->full_search
= TRUE
;
5560 for (cur
= tmp
; cur
; cur
= cur
->next
)
5561 procmsg_msginfo_free((MsgInfo
**)&(cur
->data
));
5565 result
= GPOINTER_TO_INT(imap_get_flags_thread(data
));
5572 static gboolean
process_flags(gpointer key
, gpointer value
, gpointer user_data
)
5574 gboolean flags_set
= GPOINTER_TO_INT(user_data
);
5575 gint flags_value
= GPOINTER_TO_INT(key
);
5576 hashtable_data
*data
= (hashtable_data
*)value
;
5577 IMAPFolderItem
*_item
= data
->item
;
5578 FolderItem
*item
= (FolderItem
*)_item
;
5579 gint ok
= MAILIMAP_ERROR_BAD_STATE
;
5580 IMAPSession
*session
= NULL
;
5582 debug_print("getting session...\n");
5583 session
= imap_session_get(item
->folder
);
5585 data
->msglist
= g_slist_reverse(data
->msglist
);
5587 debug_print("IMAP %ssetting flags to %d for %d messages\n",
5590 g_slist_length(data
->msglist
));
5592 lock_session(session
);
5594 ok
= imap_select(session
, IMAP_FOLDER(item
->folder
), item
,
5595 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
5597 if (ok
== MAILIMAP_NO_ERROR
) {
5598 ok
= imap_set_message_flags(session
, IMAP_FOLDER_ITEM(item
),
5599 data
->msglist
, flags_value
, NULL
, flags_set
);
5601 g_warning("can't select mailbox %s", item
->path
);
5605 unlock_session(session
);
5607 g_slist_free(data
->msglist
);
5612 static gboolean
process_tags(gpointer key
, gpointer value
, gpointer user_data
)
5614 gboolean tags_set
= GPOINTER_TO_INT(user_data
);
5615 TagsData
*data
= (TagsData
*)value
;
5616 IMAPFolderItem
*_item
= data
->item
;
5617 FolderItem
*item
= (FolderItem
*)_item
;
5618 gchar
*str
= data
->str
;
5619 gint ok
= MAILIMAP_ERROR_BAD_STATE
;
5620 IMAPSession
*session
= NULL
;
5622 debug_print("getting session...\n");
5623 session
= imap_session_get(item
->folder
);
5625 data
->msglist
= g_slist_reverse(data
->msglist
);
5627 debug_print("IMAP %ssetting tags %s for %d messages\n",
5630 g_slist_length(data
->msglist
));
5632 lock_session(session
);
5634 ok
= imap_select(session
, IMAP_FOLDER(item
->folder
), item
,
5635 NULL
, NULL
, NULL
, NULL
, NULL
, FALSE
);
5637 if (ok
== MAILIMAP_NO_ERROR
) {
5641 ok
= imap_set_message_flags(session
, IMAP_FOLDER_ITEM(item
),
5642 data
->msglist
, 0, &list
, tags_set
);
5644 g_warning("can't select mailbox %s", item
->path
);
5648 unlock_session(session
);
5650 g_slist_free(data
->msglist
);
5656 static void process_hashtable(IMAPFolderItem
*item
)
5658 if (item
->flags_set_table
) {
5659 g_hash_table_foreach_remove(item
->flags_set_table
, process_flags
, GINT_TO_POINTER(TRUE
));
5660 g_hash_table_destroy(item
->flags_set_table
);
5661 item
->flags_set_table
= NULL
;
5663 if (item
->flags_unset_table
) {
5664 g_hash_table_foreach_remove(item
->flags_unset_table
, process_flags
, GINT_TO_POINTER(FALSE
));
5665 g_hash_table_destroy(item
->flags_unset_table
);
5666 item
->flags_unset_table
= NULL
;
5668 if (item
->tags_set_table
) {
5669 g_hash_table_foreach_remove(item
->tags_set_table
, process_tags
, GINT_TO_POINTER(TRUE
));
5670 g_hash_table_destroy(item
->tags_set_table
);
5671 item
->tags_set_table
= NULL
;
5673 if (item
->tags_unset_table
) {
5674 g_hash_table_foreach_remove(item
->tags_unset_table
, process_tags
, GINT_TO_POINTER(FALSE
));
5675 g_hash_table_destroy(item
->tags_unset_table
);
5676 item
->tags_unset_table
= NULL
;
5681 static void imap_set_batch (Folder
*folder
, FolderItem
*_item
, gboolean batch
)
5683 IMAPFolderItem
*item
= (IMAPFolderItem
*)_item
;
5684 IMAPSession
*session
;
5686 g_return_if_fail(item
!= NULL
);
5688 if (item
->batching
== batch
)
5692 item
->batching
= TRUE
;
5693 debug_print("IMAP switching to batch mode\n");
5694 if (!item
->flags_set_table
) {
5695 item
->flags_set_table
= g_hash_table_new(NULL
, g_direct_equal
);
5697 if (!item
->flags_unset_table
) {
5698 item
->flags_unset_table
= g_hash_table_new(NULL
, g_direct_equal
);
5700 if (!item
->tags_set_table
) {
5701 item
->tags_set_table
= g_hash_table_new(NULL
, g_direct_equal
);
5703 if (!item
->tags_unset_table
) {
5704 item
->tags_unset_table
= g_hash_table_new(NULL
, g_direct_equal
);
5706 session
= imap_session_get(folder
);
5708 imap_refresh_sensitivity(session
);
5709 session
->sens_update_block
= TRUE
;
5712 debug_print("IMAP switching away from batch mode\n");
5714 process_hashtable(item
);
5715 item
->batching
= FALSE
;
5716 session
= imap_session_get(folder
);
5718 session
->sens_update_block
= FALSE
;
5719 imap_refresh_sensitivity(session
);
5726 /* data types conversion libetpan <-> claws */
5730 #define ETPAN_IMAP_MB_MARKED 1
5731 #define ETPAN_IMAP_MB_UNMARKED 2
5732 #define ETPAN_IMAP_MB_NOSELECT 4
5733 #define ETPAN_IMAP_MB_NOINFERIORS 8
5735 static int imap_flags_to_flags(struct mailimap_mbx_list_flags
* imap_flags
)
5741 if (imap_flags
->mbf_type
== MAILIMAP_MBX_LIST_FLAGS_SFLAG
) {
5742 switch (imap_flags
->mbf_sflag
) {
5743 case MAILIMAP_MBX_LIST_SFLAG_MARKED
:
5744 flags
|= ETPAN_IMAP_MB_MARKED
;
5746 case MAILIMAP_MBX_LIST_SFLAG_NOSELECT
:
5747 flags
|= ETPAN_IMAP_MB_NOSELECT
;
5749 case MAILIMAP_MBX_LIST_SFLAG_UNMARKED
:
5750 flags
|= ETPAN_IMAP_MB_UNMARKED
;
5755 if (imap_flags
->mbf_oflags
) {
5756 for(cur
= clist_begin(imap_flags
->mbf_oflags
) ; cur
!= NULL
;
5757 cur
= clist_next(cur
)) {
5758 struct mailimap_mbx_list_oflag
* oflag
;
5760 oflag
= clist_content(cur
);
5762 switch (oflag
->of_type
) {
5763 case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS
:
5764 flags
|= ETPAN_IMAP_MB_NOINFERIORS
;
5772 static GSList
* imap_list_from_lep(IMAPFolder
* folder
,
5773 clist
* list
, const gchar
* real_path
, gboolean all
)
5776 GSList
* item_list
= NULL
, *llast
= NULL
;
5779 for(iter
= clist_begin(list
) ; iter
!= NULL
;
5780 iter
= clist_next(iter
)) {
5781 struct mailimap_mailbox_list
* mb
;
5789 FolderItem
*new_item
;
5791 mb
= clist_content(iter
);
5797 if (mb
->mb_flag
!= NULL
)
5798 flags
= imap_flags_to_flags(mb
->mb_flag
);
5800 delimiter
= mb
->mb_delimiter
;
5803 dup_name
= strdup(name
);
5804 if (delimiter
!= '\0')
5805 subst_char(dup_name
, delimiter
, '/');
5807 base
= g_path_get_basename(dup_name
);
5808 if (base
[0] == '.') {
5813 if (!all
&& path_cmp(name
, real_path
) == 0) {
5819 if (!all
&& dup_name
[strlen(dup_name
)-1] == '/') {
5825 loc_name
= imap_modified_utf7_to_utf8(base
, FALSE
);
5826 loc_path
= imap_modified_utf7_to_utf8(dup_name
, FALSE
);
5828 new_item
= folder_item_new(FOLDER(folder
), loc_name
, loc_path
);
5829 if ((flags
& ETPAN_IMAP_MB_NOINFERIORS
) != 0)
5830 new_item
->no_sub
= TRUE
;
5831 if (strcasecmp(dup_name
, "INBOX") != 0 &&
5832 ((flags
& ETPAN_IMAP_MB_NOSELECT
) != 0))
5833 new_item
->no_select
= TRUE
;
5835 if (item_list
== NULL
)
5836 llast
= item_list
= g_slist_append(item_list
, new_item
);
5838 llast
= g_slist_append(llast
, new_item
);
5839 llast
= llast
->next
;
5841 debug_print("folder '%s' found.\n", loc_path
);
5852 static GSList
* imap_get_lep_set_from_numlist(IMAPFolder
*folder
, MsgNumberList
*numlist
)
5854 GSList
*sorted_list
, *cur
;
5855 guint first
, last
, next
;
5856 GSList
*ret_list
= NULL
, *llast
= NULL
;
5857 struct mailimap_set
* current_set
;
5858 unsigned int item_count
;
5860 if (numlist
== NULL
)
5863 current_set
= mailimap_set_new_empty();
5865 sorted_list
= g_slist_copy(numlist
);
5866 sorted_list
= g_slist_sort(sorted_list
, g_int_compare
);
5868 first
= GPOINTER_TO_INT(sorted_list
->data
);
5871 for (cur
= sorted_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
5872 if (GPOINTER_TO_INT(cur
->data
) == 0)
5877 last
= GPOINTER_TO_INT(cur
->data
);
5879 next
= GPOINTER_TO_INT(cur
->next
->data
);
5883 if (last
+ 1 != next
|| next
== 0 || item_count
>= folder
->max_set_size
) {
5885 struct mailimap_set_item
* item
;
5886 item
= mailimap_set_item_new(first
, last
);
5887 mailimap_set_add(current_set
, item
);
5891 if (item_count
>= folder
->max_set_size
) {
5892 if (ret_list
== NULL
)
5893 llast
= ret_list
= g_slist_append(ret_list
,
5896 llast
= g_slist_append(llast
, current_set
);
5897 llast
= llast
->next
;
5900 current_set
= mailimap_set_new_empty();
5906 if (clist_count(current_set
->set_list
) > 0) {
5907 ret_list
= g_slist_append(ret_list
,
5911 g_slist_free(sorted_list
);
5916 static GSList
* imap_get_lep_set_from_msglist(IMAPFolder
*folder
, MsgInfoList
*msglist
)
5918 MsgNumberList
*numlist
= NULL
;
5921 numlist
= procmsg_get_number_list_for_msgs(msglist
);
5923 seq_list
= imap_get_lep_set_from_numlist(folder
, numlist
);
5924 g_slist_free(numlist
);
5929 static GSList
* imap_uid_list_from_lep(clist
* list
, gint
* length
)
5938 for(iter
= clist_begin(list
) ; iter
!= NULL
;
5939 iter
= clist_next(iter
)) {
5942 puid
= clist_content(iter
);
5943 result
= g_slist_prepend(result
, GINT_TO_POINTER(* puid
));
5946 result
= g_slist_reverse(result
);
5953 static GSList
* imap_uid_list_from_lep_tab(carray
* list
)
5960 for(i
= 0 ; i
< carray_count(list
) ; i
++) {
5963 puid
= carray_get(list
, i
);
5964 result
= g_slist_prepend(result
, GINT_TO_POINTER(* puid
));
5966 result
= g_slist_reverse(result
);
5970 static void imap_flags_hash_from_lep_uid_flags_tab(carray
* list
,
5972 GHashTable
* tags_hash
)
5976 for(i
= 0 ; i
< carray_count(list
) ; i
+= 3) {
5981 puid
= carray_get(list
, i
);
5982 pflags
= carray_get(list
, i
+ 1);
5983 tags
= carray_get(list
, i
+ 2);
5985 g_hash_table_insert(hash
, GINT_TO_POINTER(*puid
), GINT_TO_POINTER(* pflags
));
5986 g_hash_table_insert(tags_hash
, GINT_TO_POINTER(*puid
), tags
);
5990 static MsgInfo
*imap_envelope_from_lep(struct imap_fetch_env_info
* info
,
5993 MsgInfo
*msginfo
= NULL
;
5996 MsgFlags flags
= {0, 0};
5998 if (info
->headers
== NULL
)
6001 MSG_SET_TMP_FLAGS(flags
, MSG_IMAP
);
6002 if (folder_has_parent_of_type(item
, F_QUEUE
)) {
6003 MSG_SET_TMP_FLAGS(flags
, MSG_QUEUED
);
6004 } else if (folder_has_parent_of_type(item
, F_DRAFT
)) {
6005 MSG_SET_TMP_FLAGS(flags
, MSG_DRAFT
);
6007 flags
.perm_flags
= info
->flags
;
6010 size
= (goffset
) info
->size
;
6011 msginfo
= procheader_parse_str(info
->headers
, flags
, FALSE
, FALSE
);
6014 msginfo
->msgnum
= uid
;
6015 msginfo
->size
= size
;
6021 static void imap_lep_set_free(GSList
*seq_list
)
6025 for(cur
= seq_list
; cur
!= NULL
; cur
= g_slist_next(cur
)) {
6026 struct mailimap_set
* imapset
;
6028 imapset
= cur
->data
;
6029 mailimap_set_free(imapset
);
6031 g_slist_free(seq_list
);
6034 static struct mailimap_flag_list
* imap_flag_to_lep(IMAPFolderItem
*item
, IMAPFlags flags
, GSList
*tags
)
6036 struct mailimap_flag_list
* flag_list
;
6039 flag_list
= mailimap_flag_list_new_empty();
6041 if (IMAP_IS_SEEN(flags
))
6042 mailimap_flag_list_add(flag_list
,
6043 mailimap_flag_new_seen());
6044 if (IMAP_IS_ANSWERED(flags
))
6045 mailimap_flag_list_add(flag_list
,
6046 mailimap_flag_new_answered());
6047 if (IMAP_IS_FLAGGED(flags
))
6048 mailimap_flag_list_add(flag_list
,
6049 mailimap_flag_new_flagged());
6050 if (IMAP_IS_DELETED(flags
))
6051 mailimap_flag_list_add(flag_list
,
6052 mailimap_flag_new_deleted());
6053 if (IMAP_IS_DRAFT(flags
))
6054 mailimap_flag_list_add(flag_list
,
6055 mailimap_flag_new_draft());
6056 if (IMAP_IS_FORWARDED(flags
) && flag_ok(item
, IMAP_FLAG_FORWARDED
))
6057 mailimap_flag_list_add(flag_list
,
6058 mailimap_flag_new_flag_keyword(strdup(RTAG_FORWARDED
)));
6059 if (IMAP_IS_SPAM(flags
) && flag_ok(item
, IMAP_FLAG_SPAM
))
6060 mailimap_flag_list_add(flag_list
,
6061 mailimap_flag_new_flag_keyword(strdup(RTAG_JUNK
)));
6062 else if (IMAP_IS_HAM(flags
) && flag_ok(item
, IMAP_FLAG_HAM
))
6063 mailimap_flag_list_add(flag_list
,
6064 mailimap_flag_new_flag_keyword(strdup(RTAG_NON_JUNK
)));
6066 for (; cur
; cur
= cur
->next
) {
6068 imap_utf8_to_modified_utf7(cur
->data
, TRUE
);
6069 g_strstrip(enc_str
);
6071 mailimap_flag_list_add(flag_list
,
6072 mailimap_flag_new_flag_keyword(enc_str
));
6078 guint
imap_folder_get_refcnt(Folder
*folder
)
6080 return ((IMAPFolder
*)folder
)->refcnt
;
6083 void imap_folder_ref(Folder
*folder
)
6085 ((IMAPFolder
*)folder
)->refcnt
++;
6088 void imap_disconnect_all(gboolean have_connectivity
)
6091 gboolean short_timeout
;
6092 #ifdef HAVE_NETWORKMANAGER_SUPPORT
6093 GError
*error
= NULL
;
6095 short_timeout
= !networkmanager_is_online(&error
);
6097 short_timeout
= TRUE
;
6098 g_error_free(error
);
6101 short_timeout
= TRUE
;
6105 imap_main_set_timeout(1);
6107 for (list
= account_get_list(); list
!= NULL
; list
= list
->next
) {
6108 PrefsAccount
*account
= list
->data
;
6109 if (account
->protocol
== A_IMAP4
) {
6110 RemoteFolder
*folder
= (RemoteFolder
*)account
->folder
;
6111 if (folder
&& folder
->session
) {
6112 if (imap_is_busy(FOLDER(folder
)))
6113 imap_threaded_cancel(FOLDER(folder
));
6115 IMAPSession
*session
= (IMAPSession
*)folder
->session
;
6116 if (have_connectivity
)
6117 imap_threaded_disconnect(FOLDER(folder
));
6118 SESSION(session
)->state
= SESSION_DISCONNECTED
;
6119 SESSION(session
)->sock
= NULL
;
6120 imap_safe_destroy(session
);
6121 folder
->session
= NULL
;
6127 imap_main_set_timeout(prefs_common
.io_timeout_secs
);
6130 void imap_folder_unref(Folder
*folder
)
6132 if (((IMAPFolder
*)folder
)->refcnt
> 0)
6133 ((IMAPFolder
*)folder
)->refcnt
--;
6136 void imap_cancel_all(void)
6141 folderlist
= folder_get_list();
6142 for (cur
= folderlist
; cur
!= NULL
; cur
= g_list_next(cur
)) {
6143 Folder
*folder
= (Folder
*) cur
->data
;
6145 if (folder
->klass
== &imap_class
) {
6146 if (imap_is_busy(folder
)) {
6147 IMAPSession
*imap_session
;
6148 RemoteFolder
*rfolder
;
6150 g_printerr("cancelled\n");
6151 imap_threaded_cancel(folder
);
6152 rfolder
= (RemoteFolder
*) folder
;
6153 imap_session
= (IMAPSession
*) rfolder
->session
;
6155 imap_session
->cancelled
= 1;
6161 gboolean
imap_cancel_all_enabled(void)
6166 folderlist
= folder_get_list();
6167 for (cur
= folderlist
; cur
!= NULL
; cur
= g_list_next(cur
)) {
6168 Folder
*folder
= (Folder
*) cur
->data
;
6170 if (folder
->klass
== &imap_class
) {
6171 if (imap_is_busy(folder
)) {
6180 static gboolean
imap_is_busy(Folder
*folder
)
6182 IMAPSession
*imap_session
;
6183 RemoteFolder
*rfolder
;
6185 rfolder
= (RemoteFolder
*) folder
;
6186 imap_session
= (IMAPSession
*) rfolder
->session
;
6187 if (imap_session
== NULL
)
6190 return imap_session
->busy
;
6193 #else /* HAVE_LIBETPAN */
6195 static FolderClass imap_class
;
6197 static XMLTag
*imap_item_get_xml(Folder
*folder
, FolderItem
*item
);
6198 static void imap_item_set_xml(Folder
*folder
, FolderItem
*item
, XMLTag
*tag
);
6200 static Folder
*imap_folder_new (const gchar
*name
,
6203 static gboolean missing_imap_warning
= TRUE
;
6204 if (missing_imap_warning
) {
6205 missing_imap_warning
= FALSE
;
6207 _("You have one or more IMAP accounts "
6208 "defined. However this version of "
6209 "Claws Mail has been built without "
6210 "IMAP support; your IMAP accounts are "
6212 "You probably need to "
6213 "install libetpan and recompile "
6218 static gint
imap_create_tree (Folder
*folder
)
6222 static FolderItem
*imap_create_folder (Folder
*folder
,
6228 static gint
imap_rename_folder (Folder
*folder
,
6235 gchar
imap_get_path_separator_for_item(FolderItem
*item
)
6240 FolderClass
*imap_get_class(void)
6242 if (imap_class
.idstr
== NULL
) {
6243 imap_class
.type
= F_IMAP
;
6244 imap_class
.idstr
= "imap";
6245 imap_class
.uistr
= "IMAP";
6247 imap_class
.new_folder
= imap_folder_new
;
6248 imap_class
.create_tree
= imap_create_tree
;
6249 imap_class
.create_folder
= imap_create_folder
;
6250 imap_class
.rename_folder
= imap_rename_folder
;
6252 imap_class
.set_xml
= folder_set_xml
;
6253 imap_class
.get_xml
= folder_get_xml
;
6254 imap_class
.item_set_xml
= imap_item_set_xml
;
6255 imap_class
.item_get_xml
= imap_item_get_xml
;
6256 /* nothing implemented */
6262 void imap_disconnect_all(gboolean have_connectivity
)
6266 gint
imap_subscribe(Folder
*folder
, FolderItem
*item
, gchar
*rpath
, gboolean sub
)
6271 GList
* imap_scan_subtree(Folder
*folder
, FolderItem
*item
, gboolean unsubs_only
, gboolean recursive
)
6276 void imap_cache_msg(FolderItem
*item
, gint msgnum
)
6280 void imap_cancel_all(void)
6284 gboolean
imap_cancel_all_enabled(void)
6291 #ifdef HAVE_LIBETPAN
6292 static void imap_synchronise(FolderItem
*item
, gint days
)
6294 if (IMAP_FOLDER_ITEM(item
)->last_sync
== IMAP_FOLDER_ITEM(item
)->last_change
) {
6295 debug_print("%s already synced\n", item
->path
?item
->path
:item
->name
);
6298 debug_print("syncing %s\n", item
->path
?item
->path
:item
->name
);
6299 imap_gtk_synchronise(item
, days
);
6300 IMAP_FOLDER_ITEM(item
)->last_sync
= IMAP_FOLDER_ITEM(item
)->last_change
;
6304 static void imap_item_set_xml(Folder
*folder
, FolderItem
*item
, XMLTag
*tag
)
6306 #ifdef HAVE_LIBETPAN
6309 folder_item_set_xml(folder
, item
, tag
);
6311 #ifdef HAVE_LIBETPAN
6312 for (cur
= tag
->attr
; cur
!= NULL
; cur
= g_list_next(cur
)) {
6313 XMLAttr
*attr
= (XMLAttr
*) cur
->data
;
6315 if (!attr
|| !attr
->name
|| !attr
->value
) continue;
6316 if (!strcmp(attr
->name
, "uidnext"))
6317 IMAP_FOLDER_ITEM(item
)->uid_next
= atoi(attr
->value
);
6318 if (!strcmp(attr
->name
, "last_sync"))
6319 IMAP_FOLDER_ITEM(item
)->last_sync
= atoi(attr
->value
);
6320 if (!strcmp(attr
->name
, "last_change"))
6321 IMAP_FOLDER_ITEM(item
)->last_change
= atoi(attr
->value
);
6323 if (IMAP_FOLDER_ITEM(item
)->last_change
== 0)
6324 IMAP_FOLDER_ITEM(item
)->last_change
= time(NULL
);
6328 static XMLTag
*imap_item_get_xml(Folder
*folder
, FolderItem
*item
)
6332 tag
= folder_item_get_xml(folder
, item
);
6334 #ifdef HAVE_LIBETPAN
6335 xml_tag_add_attr(tag
, xml_attr_new_int("uidnext",
6336 IMAP_FOLDER_ITEM(item
)->uid_next
));
6337 xml_tag_add_attr(tag
, xml_attr_new_int("last_sync",
6338 IMAP_FOLDER_ITEM(item
)->last_sync
));
6339 xml_tag_add_attr(tag
, xml_attr_new_int("last_change",
6340 IMAP_FOLDER_ITEM(item
)->last_change
));
6346 /* ===================================================================
6347 * UTF-7 conversion routines as in RFC 2192
6348 * ===================================================================
6349 * These two functions from:
6351 * Copyright (C) 2003-2004 Pawel Salek. */
6353 /* UTF7 modified base64 alphabet */
6354 static char base64chars
[] =
6355 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
6356 #define UNDEFINED 64
6358 /* UTF16 definitions */
6359 #define UTF16MASK 0x03FFUL
6360 #define UTF16SHIFT 10
6361 #define UTF16BASE 0x10000UL
6362 #define UTF16HIGHSTART 0xD800UL
6363 #define UTF16HIGHEND 0xDBFFUL
6364 #define UTF16LOSTART 0xDC00UL
6365 #define UTF16LOEND 0xDFFFUL
6368 /* Convert an IMAP mailbox to a UTF-8 string.
6369 * dst needs to have roughly 4 times the storage space of src
6370 * Hex encoding can triple the size of the input
6371 * UTF-7 can be slightly denser than UTF-8
6372 * (worst case: 8 octets UTF-7 becomes 9 octets UTF-8)
6374 char* imap_modified_utf7_to_utf8(const char *mbox
, gboolean change_spaces
)
6376 unsigned c
, i
, bitcount
;
6377 unsigned long ucs4
, utf16
, bitbuf
;
6378 unsigned char base64
[256];
6380 char *dst
, *res
= g_malloc(2*strlen(mbox
)+1);
6384 if(!dst
) return NULL
;
6385 /* initialize modified base64 decoding table */
6386 memset(base64
, UNDEFINED
, sizeof (base64
));
6387 for (i
= 0; i
< sizeof (base64chars
); ++i
) {
6388 base64
[(unsigned)base64chars
[i
]] = i
;
6391 /* loop until end of string */
6392 while (*src
!= '\0') {
6394 /* deal with literal characters and &- */
6395 if (c
!= '&' || *src
== '-') {
6396 /* encode literally */
6397 if (change_spaces
&& c
== '_')
6401 /* skip over the '-' if this is an &- sequence */
6402 if (c
== '&') ++src
;
6404 /* convert modified UTF-7 -> UTF-16 -> UCS-4 -> UTF-8 -> HEX */
6408 while ((c
= base64
[(unsigned char) *src
]) != UNDEFINED
) {
6410 bitbuf
= (bitbuf
<< 6) | c
;
6412 /* enough bits for a UTF-16 character? */
6413 if (bitcount
>= 16) {
6415 utf16
= (bitcount
? bitbuf
>> bitcount
6417 /* convert UTF16 to UCS4 */
6419 (utf16
>= UTF16HIGHSTART
&& utf16
<= UTF16HIGHEND
) {
6420 ucs4
= (utf16
- UTF16HIGHSTART
) << UTF16SHIFT
;
6423 (utf16
>= UTF16LOSTART
&& utf16
<= UTF16LOEND
) {
6424 ucs4
+= utf16
- UTF16LOSTART
+ UTF16BASE
;
6429 /* convert UTF-16 range of UCS4 to UTF-8 */
6430 if (ucs4
<= 0x7fUL
) {
6433 } else if (ucs4
<= 0x7ffUL
) {
6434 dst
[0] = 0xc0 | (ucs4
>> 6);
6435 dst
[1] = 0x80 | (ucs4
& 0x3f);
6437 } else if (ucs4
<= 0xffffUL
) {
6438 dst
[0] = 0xe0 | (ucs4
>> 12);
6439 dst
[1] = 0x80 | ((ucs4
>> 6) & 0x3f);
6440 dst
[2] = 0x80 | (ucs4
& 0x3f);
6443 dst
[0] = 0xf0 | (ucs4
>> 18);
6444 dst
[1] = 0x80 | ((ucs4
>> 12) & 0x3f);
6445 dst
[2] = 0x80 | ((ucs4
>> 6) & 0x3f);
6446 dst
[3] = 0x80 | (ucs4
& 0x3f);
6451 /* skip over trailing '-' in modified UTF-7 encoding */
6452 if (*src
== '-') ++src
;
6455 /* terminate destination string */
6460 /* Convert hex coded UTF-8 string to modified UTF-7 IMAP mailbox
6461 * dst should be about twice the length of src to deal with non-hex
6464 char* imap_utf8_to_modified_utf7(const char *src
, gboolean change_spaces
)
6466 unsigned int utf8pos
, utf8total
, c
, utf7mode
, bitstogo
, utf16flag
;
6467 unsigned long ucs4
= 0, bitbuf
= 0;
6469 /* initialize hex lookup table */
6472 if (!src
) return NULL
;
6474 res
= malloc(2*strlen(src
)+1);
6476 if(!dst
) return NULL
;
6482 while ((c
= (unsigned char)*src
) != '\0') {
6484 /* normal character? */
6485 if (c
>= ' ' && c
<= '~' && (c
!= '_' || !change_spaces
)) {
6486 /* switch out of UTF-7 mode */
6489 *dst
++ = base64chars
[(bitbuf
<< (6 - bitstogo
)) & 0x3F];
6497 if (change_spaces
&& c
== ' ')
6501 /* encode '&' as '&-' */
6507 /* switch to UTF-7 mode */
6512 /* Encode US-ASCII characters as themselves */
6515 } else if (utf8total
) {
6516 /* save UTF8 bits into UCS4 */
6517 ucs4
= (ucs4
<< 6) | (c
& 0x3FUL
);
6518 if (++utf8pos
< utf8total
) {
6526 } else if (c
< 0xF0) {
6530 /* NOTE: can't convert UTF8 sequences longer than 4 */
6536 /* loop to split ucs4 into two utf16 chars if necessary */
6539 if (ucs4
>= UTF16BASE
) {
6541 bitbuf
= (bitbuf
<< 16) | ((ucs4
>> UTF16SHIFT
)
6543 ucs4
= (ucs4
& UTF16MASK
) + UTF16LOSTART
;
6546 bitbuf
= (bitbuf
<< 16) | ucs4
;
6550 /* spew out base64 */
6551 while (bitstogo
>= 6) {
6553 *dst
++ = base64chars
[(bitstogo
? (bitbuf
>> bitstogo
)
6557 } while (utf16flag
);
6559 /* if in UTF-7 mode, finish in ASCII */
6562 *dst
++ = base64chars
[(bitbuf
<< (6 - bitstogo
)) & 0x3F];
6566 /* tie off string */