2006-12-27 [wwp] 2.6.1cvs78
[claws.git] / src / imap.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2006 Hiroyuki Yamamoto and the Claws Mail team
4  *
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 2 of the License, or
8  * (at your option) any later version.
9  *
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.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include "defs.h"
25
26 #include <glib.h>
27 #include <glib/gi18n.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include "imap.h"
31 #include "imap_gtk.h"
32 #include "inc.h"
33 #include "xml.h"
34
35 #ifdef HAVE_LIBETPAN
36
37 #include <stdlib.h>
38 #include <dirent.h>
39 #include <unistd.h>
40 #include <ctype.h>
41 #include <time.h>
42 #include <errno.h>
43 #if HAVE_ICONV
44 #  include <iconv.h>
45 #endif
46
47 #if USE_OPENSSL
48 #  include "ssl.h"
49 #endif
50
51 #include "folder.h"
52 #include "session.h"
53 #include "procmsg.h"
54 #include "socket.h"
55 #include "recv.h"
56 #include "procheader.h"
57 #include "prefs_account.h"
58 #include "codeconv.h"
59 #include "md5.h"
60 #include "base64.h"
61 #include "utils.h"
62 #include "prefs_common.h"
63 #include "inputdialog.h"
64 #include "log.h"
65 #include "remotefolder.h"
66 #include "alertpanel.h"
67 #include "claws.h"
68 #include "statusbar.h"
69 #include "msgcache.h"
70 #include "imap-thread.h"
71 #include "account.h"
72
73 typedef struct _IMAPFolder      IMAPFolder;
74 typedef struct _IMAPSession     IMAPSession;
75 typedef struct _IMAPNameSpace   IMAPNameSpace;
76 typedef struct _IMAPFolderItem  IMAPFolderItem;
77
78 #include "prefs_account.h"
79
80 #define IMAP_FOLDER(obj)        ((IMAPFolder *)obj)
81 #define IMAP_FOLDER_ITEM(obj)   ((IMAPFolderItem *)obj)
82 #define IMAP_SESSION(obj)       ((IMAPSession *)obj)
83
84 struct _IMAPFolder
85 {
86         RemoteFolder rfolder;
87
88         /* list of IMAPNameSpace */
89         GList *ns_personal;
90         GList *ns_others;
91         GList *ns_shared;
92         gchar last_seen_separator;
93         guint refcnt;
94 };
95
96 struct _IMAPSession
97 {
98         Session session;
99
100         gboolean authenticated;
101
102         GSList *capability;
103         gboolean uidplus;
104
105         gchar *mbox;
106         guint cmd_count;
107
108         /* CLAWS */
109         gboolean folder_content_changed;
110         guint exists;
111         Folder * folder;
112         gboolean busy;
113 };
114
115 struct _IMAPNameSpace
116 {
117         gchar *name;
118         gchar separator;
119 };
120
121 #define IMAP_SUCCESS    0
122 #define IMAP_SOCKET     2
123 #define IMAP_AUTHFAIL   3
124 #define IMAP_PROTOCOL   4
125 #define IMAP_SYNTAX     5
126 #define IMAP_IOERR      6
127 #define IMAP_ERROR      7
128
129 #define IMAPBUFSIZE     8192
130
131 typedef enum
132 {
133         IMAP_FLAG_SEEN          = 1 << 0,
134         IMAP_FLAG_ANSWERED      = 1 << 1,
135         IMAP_FLAG_FLAGGED       = 1 << 2,
136         IMAP_FLAG_DELETED       = 1 << 3,
137         IMAP_FLAG_DRAFT         = 1 << 4
138 } IMAPFlags;
139
140 #define IMAP_IS_SEEN(flags)     ((flags & IMAP_FLAG_SEEN) != 0)
141 #define IMAP_IS_ANSWERED(flags) ((flags & IMAP_FLAG_ANSWERED) != 0)
142 #define IMAP_IS_FLAGGED(flags)  ((flags & IMAP_FLAG_FLAGGED) != 0)
143 #define IMAP_IS_DELETED(flags)  ((flags & IMAP_FLAG_DELETED) != 0)
144 #define IMAP_IS_DRAFT(flags)    ((flags & IMAP_FLAG_DRAFT) != 0)
145
146
147 #define IMAP4_PORT      143
148 #if USE_OPENSSL
149 #define IMAPS_PORT      993
150 #endif
151
152 #define IMAP_CMD_LIMIT  1000
153
154 struct _IMAPFolderItem
155 {
156         FolderItem item;
157
158         guint lastuid;
159         guint uid_next;
160         GSList *uid_list;
161         gboolean batching;
162
163         time_t use_cache;
164         gint c_messages;
165         guint32 c_uid_next;
166         guint32 c_uid_validity;
167         gint c_unseen;
168
169         GHashTable *flags_set_table;
170         GHashTable *flags_unset_table;
171 };
172
173 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
174 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
175
176 static void imap_folder_init            (Folder         *folder,
177                                          const gchar    *name,
178                                          const gchar    *path);
179
180 static Folder   *imap_folder_new        (const gchar    *name,
181                                          const gchar    *path);
182 static void      imap_folder_destroy    (Folder         *folder);
183
184 static IMAPSession *imap_session_new    (Folder         *folder,
185                                          const PrefsAccount     *account);
186 static void     imap_session_authenticate(IMAPSession           *session,
187                                           const PrefsAccount    *account);
188 static void     imap_session_destroy    (Session        *session);
189
190 static gchar   *imap_fetch_msg          (Folder         *folder, 
191                                          FolderItem     *item, 
192                                          gint            uid);
193 static gchar   *imap_fetch_msg_full     (Folder         *folder, 
194                                          FolderItem     *item, 
195                                          gint            uid,
196                                          gboolean        headers,
197                                          gboolean        body);
198 static gint     imap_add_msg            (Folder         *folder,
199                                          FolderItem     *dest,
200                                          const gchar    *file, 
201                                          MsgFlags       *flags);
202 static gint     imap_add_msgs           (Folder         *folder, 
203                                          FolderItem     *dest,
204                                          GSList         *file_list,
205                                          GRelation      *relation);
206
207 static gint     imap_copy_msg           (Folder         *folder,
208                                          FolderItem     *dest, 
209                                          MsgInfo        *msginfo);
210 static gint     imap_copy_msgs          (Folder         *folder, 
211                                          FolderItem     *dest, 
212                                          MsgInfoList    *msglist, 
213                                          GRelation      *relation);
214
215 static gint     imap_remove_msg         (Folder         *folder, 
216                                          FolderItem     *item, 
217                                          gint            uid);
218 static gint     imap_remove_msgs        (Folder         *folder, 
219                                          FolderItem     *dest, 
220                                          MsgInfoList    *msglist, 
221                                          GRelation      *relation);
222 static gint     imap_remove_all_msg     (Folder         *folder, 
223                                          FolderItem     *item);
224
225 static gboolean imap_is_msg_changed     (Folder         *folder,
226                                          FolderItem     *item, 
227                                          MsgInfo        *msginfo);
228
229 static gint     imap_close              (Folder         *folder, 
230                                          FolderItem     *item);
231
232 static gint     imap_scan_tree          (Folder         *folder);
233
234 static gint     imap_create_tree        (Folder         *folder);
235
236 static FolderItem *imap_create_folder   (Folder         *folder,
237                                          FolderItem     *parent,
238                                          const gchar    *name);
239 static gint     imap_rename_folder      (Folder         *folder,
240                                          FolderItem     *item, 
241                                          const gchar    *name);
242 static gint     imap_remove_folder      (Folder         *folder, 
243                                          FolderItem     *item);
244
245 static FolderItem *imap_folder_item_new (Folder         *folder);
246 static void imap_folder_item_destroy    (Folder         *folder,
247                                          FolderItem     *item);
248
249 static IMAPSession *imap_session_get    (Folder         *folder);
250
251 static gint imap_auth                   (IMAPSession    *session,
252                                          const gchar    *user,
253                                          const gchar    *pass,
254                                          IMAPAuthType    type);
255
256 static gint imap_scan_tree_recursive    (IMAPSession    *session,
257                                          FolderItem     *item);
258
259 static void imap_create_missing_folders (Folder         *folder);
260 static FolderItem *imap_create_special_folder
261                                         (Folder                 *folder,
262                                          SpecialFolderItemType   stype,
263                                          const gchar            *name);
264
265 static gint imap_do_copy_msgs           (Folder         *folder,
266                                          FolderItem     *dest,
267                                          MsgInfoList    *msglist,
268                                          GRelation      *relation);
269
270 static void imap_delete_all_cached_messages     (FolderItem     *item);
271 static void imap_set_batch              (Folder         *folder,
272                                          FolderItem     *item,
273                                          gboolean        batch);
274 static gint imap_set_message_flags      (IMAPSession    *session,
275                                          MsgNumberList  *numlist,
276                                          IMAPFlags       flags,
277                                          gboolean        is_set);
278 static gint imap_select                 (IMAPSession    *session,
279                                          IMAPFolder     *folder,
280                                          const gchar    *path,
281                                          gint           *exists,
282                                          gint           *recent,
283                                          gint           *unseen,
284                                          guint32        *uid_validity,
285                                          gboolean        block);
286 static gint imap_status                 (IMAPSession    *session,
287                                          IMAPFolder     *folder,
288                                          const gchar    *path,
289                                          IMAPFolderItem *item,
290                                          gint           *messages,
291                                          guint32        *uid_next,
292                                          guint32        *uid_validity,
293                                          gint           *unseen,
294                                          gboolean        block);
295
296 static gchar imap_get_path_separator            (IMAPSession    *session,
297                                                  IMAPFolder     *folder,
298                                                  const gchar    *path);
299 static gchar *imap_get_real_path                (IMAPSession    *session,
300                                                  IMAPFolder     *folder,
301                                                  const gchar    *path);
302 static void imap_synchronise            (FolderItem     *item);
303
304 static void imap_free_capabilities      (IMAPSession    *session);
305
306 /* low-level IMAP4rev1 commands */
307 static gint imap_cmd_login      (IMAPSession    *session,
308                                  const gchar    *user,
309                                  const gchar    *pass,
310                                  const gchar    *type);
311 static gint imap_cmd_noop       (IMAPSession    *session);
312 #if USE_OPENSSL
313 static gint imap_cmd_starttls   (IMAPSession    *session);
314 #endif
315 static gint imap_cmd_select     (IMAPSession    *session,
316                                  const gchar    *folder,
317                                  gint           *exists,
318                                  gint           *recent,
319                                  gint           *unseen,
320                                  guint32        *uid_validity,
321                                  gboolean        block);
322 static gint imap_cmd_examine    (IMAPSession    *session,
323                                  const gchar    *folder,
324                                  gint           *exists,
325                                  gint           *recent,
326                                  gint           *unseen,
327                                  guint32        *uid_validity,
328                                  gboolean        block);
329 static gint imap_cmd_create     (IMAPSession    *sock,
330                                  const gchar    *folder);
331 static gint imap_cmd_rename     (IMAPSession    *sock,
332                                  const gchar    *oldfolder,
333                                  const gchar    *newfolder);
334 static gint imap_cmd_delete     (IMAPSession    *session,
335                                  const gchar    *folder);
336 static gint imap_cmd_fetch      (IMAPSession    *sock,
337                                  guint32         uid,
338                                  const gchar    *filename,
339                                  gboolean        headers,
340                                  gboolean        body);
341 static gint imap_cmd_append     (IMAPSession    *session,
342                                  const gchar    *destfolder,
343                                  const gchar    *file,
344                                  IMAPFlags       flags,
345                                  guint32        *new_uid);
346 static gint imap_cmd_copy       (IMAPSession *session,
347                                  struct mailimap_set * set,
348                                  const gchar *destfolder,
349                                  GRelation *uid_mapping,
350                                  struct mailimap_set ** source,
351                                  struct mailimap_set ** dest);
352 static gint imap_cmd_store      (IMAPSession    *session,
353                                  struct mailimap_set * set,
354                                  IMAPFlags flags,
355                                  int do_add);
356 static gint imap_cmd_expunge    (IMAPSession    *session);
357
358 static void imap_path_separator_subst           (gchar          *str,
359                                                  gchar           separator);
360
361 static gchar *imap_utf8_to_modified_utf7        (const gchar    *from);
362 static gchar *imap_modified_utf7_to_utf8        (const gchar    *mutf7_str);
363
364 static gboolean imap_rename_folder_func         (GNode          *node,
365                                                  gpointer        data);
366 static gint imap_get_num_list                   (Folder         *folder,
367                                                  FolderItem     *item,
368                                                  GSList        **list,
369                                                  gboolean       *old_uids_valid);
370 static GSList *imap_get_msginfos                (Folder         *folder,
371                                                  FolderItem     *item,
372                                                  GSList         *msgnum_list);
373 static MsgInfo *imap_get_msginfo                (Folder         *folder,
374                                                  FolderItem     *item,
375                                                  gint            num);
376 static gboolean imap_scan_required              (Folder         *folder,
377                                                  FolderItem     *item);
378 static void imap_change_flags                   (Folder         *folder,
379                                                  FolderItem     *item,
380                                                  MsgInfo        *msginfo,
381                                                  MsgPermFlags    newflags);
382 static gint imap_get_flags                      (Folder         *folder,
383                                                  FolderItem     *item,
384                                                  MsgInfoList    *msglist,
385                                                  GRelation      *msgflags);
386 static gchar *imap_folder_get_path              (Folder         *folder);
387 static gchar *imap_item_get_path                (Folder         *folder,
388                                                  FolderItem     *item);
389 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
390
391
392 /* data types conversion libetpan <-> claws */
393 static GSList * imap_list_from_lep(IMAPFolder * folder,
394                                    clist * list, const gchar * real_path, gboolean all);
395 static GSList * imap_get_lep_set_from_numlist(MsgNumberList *numlist);
396 static GSList * imap_get_lep_set_from_msglist(MsgInfoList *msglist);
397 static GSList * imap_uid_list_from_lep(clist * list);
398 static GSList * imap_uid_list_from_lep_tab(carray * list);
399 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
400                                        FolderItem *item);
401 static void imap_lep_set_free(GSList *seq_list);
402 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFlags flags);
403
404 typedef struct _hashtable_data {
405         IMAPSession *session;
406         GSList *msglist;
407         IMAPFolderItem *item;
408 } hashtable_data;
409
410 static FolderClass imap_class;
411
412 typedef struct _thread_data {
413         gchar *server;
414         gushort port;
415         gboolean done;
416         SockInfo *sock;
417 #ifdef USE_OPENSSL
418         SSLType ssl_type;
419 #endif
420 } thread_data;
421
422 FolderClass *imap_get_class(void)
423 {
424         if (imap_class.idstr == NULL) {
425                 imap_class.type = F_IMAP;
426                 imap_class.idstr = "imap";
427                 imap_class.uistr = "IMAP4";
428
429                 /* Folder functions */
430                 imap_class.new_folder = imap_folder_new;
431                 imap_class.destroy_folder = imap_folder_destroy;
432                 imap_class.scan_tree = imap_scan_tree;
433                 imap_class.create_tree = imap_create_tree;
434
435                 /* FolderItem functions */
436                 imap_class.item_new = imap_folder_item_new;
437                 imap_class.item_destroy = imap_folder_item_destroy;
438                 imap_class.item_get_path = imap_item_get_path;
439                 imap_class.create_folder = imap_create_folder;
440                 imap_class.rename_folder = imap_rename_folder;
441                 imap_class.remove_folder = imap_remove_folder;
442                 imap_class.close = imap_close;
443                 imap_class.get_num_list = imap_get_num_list;
444                 imap_class.scan_required = imap_scan_required;
445                 imap_class.set_xml = folder_set_xml;
446                 imap_class.get_xml = folder_get_xml;
447                 imap_class.item_set_xml = imap_item_set_xml;
448                 imap_class.item_get_xml = imap_item_get_xml;
449
450                 /* Message functions */
451                 imap_class.get_msginfo = imap_get_msginfo;
452                 imap_class.get_msginfos = imap_get_msginfos;
453                 imap_class.fetch_msg = imap_fetch_msg;
454                 imap_class.fetch_msg_full = imap_fetch_msg_full;
455                 imap_class.add_msg = imap_add_msg;
456                 imap_class.add_msgs = imap_add_msgs;
457                 imap_class.copy_msg = imap_copy_msg;
458                 imap_class.copy_msgs = imap_copy_msgs;
459                 imap_class.remove_msg = imap_remove_msg;
460                 imap_class.remove_msgs = imap_remove_msgs;
461                 imap_class.remove_all_msg = imap_remove_all_msg;
462                 imap_class.is_msg_changed = imap_is_msg_changed;
463                 imap_class.change_flags = imap_change_flags;
464                 imap_class.get_flags = imap_get_flags;
465                 imap_class.set_batch = imap_set_batch;
466                 imap_class.synchronise = imap_synchronise;
467 #ifdef USE_PTREAD
468                 pthread_mutex_init(&imap_mutex, NULL);
469 #endif
470         }
471         
472         return &imap_class;
473 }
474
475 static Folder *imap_folder_new(const gchar *name, const gchar *path)
476 {
477         Folder *folder;
478
479         folder = (Folder *)g_new0(IMAPFolder, 1);
480         folder->klass = &imap_class;
481         imap_folder_init(folder, name, path);
482
483         return folder;
484 }
485
486 static void imap_folder_destroy(Folder *folder)
487 {
488         while (imap_folder_get_refcnt(folder) > 0)
489                 gtk_main_iteration();
490         
491         folder_remote_folder_destroy(REMOTE_FOLDER(folder));
492         imap_done(folder);
493 }
494
495 static void imap_folder_init(Folder *folder, const gchar *name,
496                              const gchar *path)
497 {
498         folder_remote_folder_init((Folder *)folder, name, path);
499 }
500
501 static FolderItem *imap_folder_item_new(Folder *folder)
502 {
503         IMAPFolderItem *item;
504         
505         item = g_new0(IMAPFolderItem, 1);
506         item->lastuid = 0;
507         item->uid_next = 0;
508         item->uid_list = NULL;
509
510         return (FolderItem *)item;
511 }
512
513 static void imap_folder_item_destroy(Folder *folder, FolderItem *_item)
514 {
515         IMAPFolderItem *item = (IMAPFolderItem *)_item;
516
517         g_return_if_fail(item != NULL);
518         g_slist_free(item->uid_list);
519
520         g_free(_item);
521 }
522
523 static gboolean imap_reset_uid_lists_func(GNode *node, gpointer data)
524 {
525         IMAPFolderItem *item = (IMAPFolderItem *)node->data;
526         
527         item->lastuid = 0;
528         g_slist_free(item->uid_list);
529         item->uid_list = NULL;
530         
531         return FALSE;
532 }
533
534 static void imap_reset_uid_lists(Folder *folder)
535 {
536         if(folder->node == NULL)
537                 return;
538         
539         /* Destroy all uid lists and rest last uid */
540         g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL); 
541 }
542
543 int imap_get_capabilities(IMAPSession *session)
544 {
545         struct mailimap_capability_data *capabilities = NULL;
546         clistiter *cur;
547         int result = -1;
548
549         if (session->capability != NULL)
550                 return MAILIMAP_NO_ERROR;
551
552         capabilities = imap_threaded_capability(session->folder, &result);
553
554         if (result != MAILIMAP_NO_ERROR) {
555                 return MAILIMAP_ERROR_CAPABILITY;
556         }
557
558         if (capabilities == NULL) {
559                 return MAILIMAP_NO_ERROR;
560         }
561
562         for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
563             cur = clist_next(cur)) {
564                 struct mailimap_capability * cap = 
565                         clist_content(cur);
566                 if (!cap || cap->cap_data.cap_name == NULL)
567                         continue;
568                 session->capability = g_slist_append
569                                 (session->capability,
570                                  g_strdup(cap->cap_data.cap_name));
571                 debug_print("got capa %s\n", cap->cap_data.cap_name);
572         }
573         mailimap_capability_data_free(capabilities);
574         return MAILIMAP_NO_ERROR;
575 }
576
577 gboolean imap_has_capability(IMAPSession *session, const gchar *cap) 
578 {
579         GSList *cur;
580         for (cur = session->capability; cur; cur = cur->next) {
581                 if (!g_ascii_strcasecmp(cur->data, cap))
582                         return TRUE;
583         }
584         return FALSE;
585 }
586
587 static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
588                       IMAPAuthType type)
589 {
590         gint ok = IMAP_ERROR;
591         static time_t last_login_err = 0;
592         gchar *ext_info = "";
593         
594         if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR)
595                 return IMAP_ERROR;
596
597         switch(type) {
598         case IMAP_AUTH_ANON:
599                 ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
600                 break;
601         case IMAP_AUTH_CRAM_MD5:
602                 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
603                 break;
604         case IMAP_AUTH_LOGIN:
605                 ok = imap_cmd_login(session, user, pass, "LOGIN");
606                 break;
607         case IMAP_AUTH_GSSAPI:
608                 ok = imap_cmd_login(session, user, pass, "GSSAPI");
609                 break;
610         default:
611                 debug_print("capabilities:\n"
612                                 "\t ANONYMOUS %d\n"
613                                 "\t CRAM-MD5 %d\n"
614                                 "\t LOGIN %d\n"
615                                 "\t GSSAPI %d\n", 
616                         imap_has_capability(session, "ANONYMOUS"),
617                         imap_has_capability(session, "CRAM-MD5"),
618                         imap_has_capability(session, "LOGIN"),
619                         imap_has_capability(session, "GSSAPI"));
620                 if (imap_has_capability(session, "CRAM-MD5"))
621                         ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
622                 if (ok == IMAP_ERROR && imap_has_capability(session, "GSSAPI"))
623                         ok = imap_cmd_login(session, user, pass, "GSSAPI");
624                 if (ok == IMAP_ERROR) /* we always try LOGIN before giving up */
625                         ok = imap_cmd_login(session, user, pass, "LOGIN");
626         }
627
628         if (ok == IMAP_SUCCESS)
629                 session->authenticated = TRUE;
630         else {
631                 if (type == IMAP_AUTH_CRAM_MD5) {
632                         ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
633                                      "compiled with SASL support and the "
634                                      "CRAM-MD5 SASL plugin is installed.");
635                 } 
636
637                 if (time(NULL) - last_login_err > 10) {
638                         if (!prefs_common.no_recv_err_panel) {
639                                 alertpanel_error(_("Connection to %s failed: "
640                                         "login refused.%s"),
641                                         SESSION(session)->server, ext_info);
642                         } else {
643                                 log_error(_("Connection to %s failed: "
644                                         "login refused.%s\n"),
645                                         SESSION(session)->server, ext_info);
646                         }
647                 }
648                 last_login_err = time(NULL);
649         }
650         return ok;
651 }
652
653 static IMAPSession *imap_reconnect_if_possible(Folder *folder, IMAPSession *session)
654 {
655         RemoteFolder *rfolder = REMOTE_FOLDER(folder);
656         /* Check if this is the first try to establish a
657            connection, if yes we don't try to reconnect */
658         debug_print("reconnecting\n");
659         if (rfolder->session == NULL) {
660                 log_warning(_("Connecting to %s failed"),
661                             folder->account->recv_server);
662                 session_destroy(SESSION(session));
663                 session = NULL;
664         } else {
665                 log_warning(_("IMAP4 connection to %s has been"
666                             " disconnected. Reconnecting...\n"),
667                             folder->account->recv_server);
668                 statusbar_print_all(_("IMAP4 connection to %s has been"
669                             " disconnected. Reconnecting...\n"),
670                             folder->account->recv_server);
671                 SESSION(session)->state = SESSION_DISCONNECTED;
672                 session_destroy(SESSION(session));
673                 /* Clear folders session to make imap_session_get create
674                    a new session, because of rfolder->session == NULL
675                    it will not try to reconnect again and so avoid an
676                    endless loop */
677                 rfolder->session = NULL;
678                 debug_print("getting session...\n");
679                 session = imap_session_get(folder);
680                 rfolder->session = SESSION(session);
681                 statusbar_pop_all();
682         }
683         return session;
684 }
685
686 #define lock_session() {\
687         if (session) { \
688                 debug_print("locking session %p (%d)\n", session, session->busy); \
689                 if (session->busy) \
690                         g_warning("         SESSION WAS LOCKED !!      "); \
691                 session->busy = TRUE;\
692         } else {\
693                 debug_print("can't lock null session\n"); \
694         }\
695 }
696
697 #define unlock_session() {\
698         if (session) { \
699                 debug_print("unlocking session %p\n", session); \
700                 session->busy = FALSE;\
701         } else {\
702                 debug_print("can't unlock null session\n"); \
703         }\
704 }
705
706 static IMAPSession *imap_session_get(Folder *folder)
707 {
708         RemoteFolder *rfolder = REMOTE_FOLDER(folder);
709         IMAPSession *session = NULL;
710
711         g_return_val_if_fail(folder != NULL, NULL);
712         g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
713         g_return_val_if_fail(folder->account != NULL, NULL);
714         
715         if (prefs_common.work_offline && 
716             !inc_offline_should_override(
717                 _("Claws Mail needs network access in order "
718                   "to access the IMAP server."))) {
719                 return NULL;
720         }
721
722         /* Make sure we have a session */
723         if (rfolder->session != NULL) {
724                 session = IMAP_SESSION(rfolder->session);
725         } else {
726                 imap_reset_uid_lists(folder);
727                 if (time(NULL) - rfolder->last_failure <= 2)
728                         return NULL;
729                 session = imap_session_new(folder, folder->account);
730         }
731         if(session == NULL) {
732                 rfolder->last_failure = time(NULL);
733                 return NULL;
734         }
735
736         /* Make sure session is authenticated */
737         if (!IMAP_SESSION(session)->authenticated)
738                 imap_session_authenticate(IMAP_SESSION(session), folder->account);
739         
740         if (!IMAP_SESSION(session)->authenticated) {
741                 imap_threaded_disconnect(session->folder);
742                 SESSION(session)->state = SESSION_DISCONNECTED;
743                 session_destroy(SESSION(session));
744                 rfolder->session = NULL;
745                 rfolder->last_failure = time(NULL);
746                 return NULL;
747         }
748
749         lock_session();
750
751         /* I think the point of this code is to avoid sending a
752          * keepalive if we've used the session recently and therefore
753          * think it's still alive.  Unfortunately, most of the code
754          * does not yet check for errors on the socket, and so if the
755          * connection drops we don't notice until the timeout expires.
756          * A better solution than sending a NOOP every time would be
757          * for every command to be prepared to retry until it is
758          * successfully sent. -- mbp */
759         if (time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) {
760                 /* verify that the session is still alive */
761                 if (imap_cmd_noop(session) != IMAP_SUCCESS) {
762                         debug_print("disconnected!\n");
763                         session = imap_reconnect_if_possible(folder, session);
764                 }
765         }
766
767         rfolder->session = SESSION(session);
768
769         return IMAP_SESSION(session);
770 }
771
772 static IMAPSession *imap_session_new(Folder * folder,
773                                      const PrefsAccount *account)
774 {
775         IMAPSession *session;
776         gushort port;
777         int r;
778         int authenticated = FALSE;
779         
780 #ifdef USE_OPENSSL
781         /* FIXME: IMAP over SSL only... */ 
782         SSLType ssl_type;
783
784         port = account->set_imapport ? account->imapport
785                 : account->ssl_imap == SSL_TUNNEL ? IMAPS_PORT : IMAP4_PORT;
786         ssl_type = account->ssl_imap;   
787 #else
788         if (account->ssl_imap != SSL_NONE) {
789                 if (alertpanel_full(_("Insecure connection"),
790                         _("This connection is configured to be secured "
791                           "using SSL, but SSL is not available in this "
792                           "build of Claws Mail. \n\n"
793                           "Do you want to continue connecting to this "
794                           "server? The communication would not be "
795                           "secure."),
796                           GTK_STOCK_CANCEL, _("Con_tinue connecting"), 
797                           NULL, FALSE, NULL, ALERT_WARNING,
798                           G_ALERTDEFAULT) != G_ALERTALTERNATE)
799                         return NULL;
800         }
801         port = account->set_imapport ? account->imapport
802                 : IMAP4_PORT;
803 #endif
804
805         imap_init(folder);
806         statusbar_print_all(_("Connecting to IMAP4 server: %s..."), folder->account->recv_server);
807         if (account->set_tunnelcmd) {
808                 r = imap_threaded_connect_cmd(folder,
809                                               account->tunnelcmd,
810                                               account->recv_server,
811                                               port);
812         }
813         else {
814 #ifdef USE_OPENSSL
815                 if (ssl_type == SSL_TUNNEL) {
816                         r = imap_threaded_connect_ssl(folder,
817                                                       account->recv_server,
818                                                       port);
819                 }
820                 else 
821 #endif
822                 {
823                         r = imap_threaded_connect(folder,
824                                                   account->recv_server,
825                                                   port);
826                 }
827         }
828         
829         statusbar_pop_all();
830         if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
831                 authenticated = TRUE;
832         }
833         else if (r == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
834                 authenticated = FALSE;
835         }
836         else {
837 #if (LIBETPAN_VERSION_MAJOR > 0 || LIBETPAN_VERSION_MINOR > 48)
838 #ifdef USE_OPENSSL
839                 if (r == MAILIMAP_ERROR_SSL)
840                         log_error(_("SSL handshake failed\n"));
841 #endif
842 #endif
843                 if(!prefs_common.no_recv_err_panel) {
844                         alertpanel_error_log(_("Can't connect to IMAP4 server: %s:%d"),
845                                          account->recv_server, port);
846                 } else {
847                         log_error(_("Can't connect to IMAP4 server: %s:%d\n"),
848                                          account->recv_server, port);
849                 } 
850                 
851                 return NULL;
852         }
853         
854         session = g_new0(IMAPSession, 1);
855         session_init(SESSION(session));
856         SESSION(session)->type             = SESSION_IMAP;
857         SESSION(session)->server           = g_strdup(account->recv_server);
858         SESSION(session)->sock             = NULL;
859         
860         SESSION(session)->destroy          = imap_session_destroy;
861
862         session->capability = NULL;
863         
864         session->authenticated = authenticated;
865         session->mbox = NULL;
866         session->cmd_count = 0;
867         session->folder = folder;
868         IMAP_FOLDER(session->folder)->last_seen_separator = 0;
869
870 #if USE_OPENSSL
871         if (account->ssl_imap == SSL_STARTTLS) {
872                 gint ok;
873
874                 ok = imap_cmd_starttls(session);
875                 if (ok != IMAP_SUCCESS) {
876                         log_warning(_("Can't start TLS session.\n"));
877                         session_destroy(SESSION(session));
878                         return NULL;
879                 }
880
881                 imap_free_capabilities(session);
882                 session->authenticated = FALSE;
883                 session->uidplus = FALSE;
884                 session->cmd_count = 1;
885         }
886 #endif
887         log_message("IMAP connection is %s-authenticated\n",
888                     (session->authenticated) ? "pre" : "un");
889         
890         return session;
891 }
892
893 static void imap_session_authenticate(IMAPSession *session, 
894                                       const PrefsAccount *account)
895 {
896         gchar *pass, *acc_pass;
897         gboolean failed = FALSE;
898
899         g_return_if_fail(account->userid != NULL);
900         acc_pass = account->passwd;
901 try_again:
902         pass = acc_pass;
903         if (!pass && account->imap_auth_type != IMAP_AUTH_ANON) {
904                 gchar *tmp_pass;
905                 tmp_pass = input_dialog_query_password(account->recv_server, account->userid);
906                 if (!tmp_pass)
907                         return;
908                 Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return;});
909                 g_free(tmp_pass);
910         } else if (account->imap_auth_type == IMAP_AUTH_ANON) {
911                 pass = "";
912         }
913         statusbar_print_all(_("Connecting to IMAP4 server %s...\n"),
914                                 account->recv_server);
915         if (imap_auth(session, account->userid, pass, account->imap_auth_type) != IMAP_SUCCESS) {
916                 statusbar_pop_all();
917                 
918                 if (!failed) {
919                         acc_pass = NULL;
920                         failed = TRUE;
921                         goto try_again;
922                 } else {
923                         if (prefs_common.no_recv_err_panel) {
924                                 log_error(_("Couldn't login to IMAP server %s."), account->recv_server);
925                                 mainwindow_show_error();
926                         } else
927                                 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
928                 }               
929
930                 return;
931         } 
932
933         statusbar_pop_all();
934         session->authenticated = TRUE;
935         return;
936 }
937
938 static void imap_session_destroy(Session *session)
939 {
940         if (session->state != SESSION_DISCONNECTED)
941                 imap_threaded_disconnect(IMAP_SESSION(session)->folder);
942         
943         imap_free_capabilities(IMAP_SESSION(session));
944         g_free(IMAP_SESSION(session)->mbox);
945         sock_close(session->sock);
946         session->sock = NULL;
947 }
948
949 static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
950 {
951         return imap_fetch_msg_full(folder, item, uid, TRUE, TRUE);
952 }
953
954 static guint get_size_with_crs(MsgInfo *info) 
955 {
956         FILE *fp = NULL;
957         guint cnt = 0;
958         gchar buf[4096];
959         
960         if (info == NULL)
961                 return -1;
962         
963         fp = procmsg_open_message(info);
964         if (!fp)
965                 return -1;
966         
967         while (fgets(buf, sizeof (buf), fp) != NULL) {
968                 cnt += strlen(buf);
969                 if (!strstr(buf, "\r") && strstr(buf, "\n"))
970                         cnt++;
971         }
972         
973         fclose(fp);
974         return cnt;
975 }
976
977 static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
978                                   gboolean headers, gboolean body)
979 {
980         gchar *path, *filename;
981         IMAPSession *session;
982         gint ok;
983
984         g_return_val_if_fail(folder != NULL, NULL);
985         g_return_val_if_fail(item != NULL, NULL);
986
987         if (uid == 0)
988                 return NULL;
989
990         path = folder_item_get_path(item);
991         if (!is_dir_exist(path))
992                 make_dir_hier(path);
993         filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(uid), NULL);
994         g_free(path);
995         debug_print("trying to fetch cached %s\n", filename);
996         if (is_file_exist(filename)) {
997                 /* see whether the local file represents the whole message
998                  * or not. As the IMAP server reports size with \r chars,
999                  * we have to update the local file (UNIX \n only) size */
1000                 MsgInfo *msginfo = imap_parse_msg(filename, item);
1001                 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1002                 guint have_size = get_size_with_crs(msginfo);
1003
1004                 if (cached)
1005                         debug_print("message %d has been already %scached (%d/%d).\n", uid,
1006                                 have_size >= cached->size ? "fully ":"",
1007                                 have_size, (int)cached->size);
1008                 
1009                 if (cached && (cached->size <= have_size || !body)) {
1010                         procmsg_msginfo_free(cached);
1011                         procmsg_msginfo_free(msginfo);
1012                         file_strip_crs(filename);
1013                         return filename;
1014                 } else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
1015                         debug_print("message not cached and file recent, considering file complete\n");
1016                         procmsg_msginfo_free(msginfo);
1017                         file_strip_crs(filename);
1018                         return filename;
1019                 } else {
1020                         procmsg_msginfo_free(cached);
1021                         procmsg_msginfo_free(msginfo);
1022                 }
1023         }
1024
1025         debug_print("getting session...\n");
1026         session = imap_session_get(folder);
1027         
1028         if (!session) {
1029                 g_free(filename);
1030                 return NULL;
1031         }
1032
1033         debug_print("IMAP fetching messages\n");
1034         ok = imap_select(session, IMAP_FOLDER(folder), item->path,
1035                          NULL, NULL, NULL, NULL, FALSE);
1036         if (ok != IMAP_SUCCESS) {
1037                 g_warning("can't select mailbox %s\n", item->path);
1038                 g_free(filename);
1039                 unlock_session();
1040                 return NULL;
1041         }
1042
1043         debug_print("getting message %d...\n", uid);
1044         ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
1045
1046         if (ok != IMAP_SUCCESS) {
1047                 g_warning("can't fetch message %d\n", uid);
1048                 g_free(filename);
1049                 unlock_session();
1050                 return NULL;
1051         }
1052
1053         unlock_session();
1054         file_strip_crs(filename);
1055         return filename;
1056 }
1057
1058 static gint imap_add_msg(Folder *folder, FolderItem *dest, 
1059                          const gchar *file, MsgFlags *flags)
1060 {
1061         gint ret;
1062         GSList file_list;
1063         MsgFileInfo fileinfo;
1064
1065         g_return_val_if_fail(file != NULL, -1);
1066
1067         fileinfo.msginfo = NULL;
1068         fileinfo.file = (gchar *)file;
1069         fileinfo.flags = flags;
1070         file_list.data = &fileinfo;
1071         file_list.next = NULL;
1072
1073         ret = imap_add_msgs(folder, dest, &file_list, NULL);
1074         return ret;
1075 }
1076
1077 static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
1078                    GRelation *relation)
1079 {
1080         gchar *destdir;
1081         IMAPSession *session;
1082         guint32 last_uid = 0;
1083         GSList *cur;
1084         MsgFileInfo *fileinfo;
1085         gint ok;
1086         gint curnum = 0, total = 0;
1087
1088
1089         g_return_val_if_fail(folder != NULL, -1);
1090         g_return_val_if_fail(dest != NULL, -1);
1091         g_return_val_if_fail(file_list != NULL, -1);
1092         
1093         debug_print("getting session...\n");
1094         session = imap_session_get(folder);
1095         if (!session) {
1096                 return -1;
1097         }
1098         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1099
1100         statusbar_print_all(_("Adding messages..."));
1101         total = g_slist_length(file_list);
1102         for (cur = file_list; cur != NULL; cur = cur->next) {
1103                 IMAPFlags iflags = 0;
1104                 guint32 new_uid = 0;
1105                 gchar *real_file = NULL;
1106                 fileinfo = (MsgFileInfo *)cur->data;
1107
1108                 statusbar_progress_all(curnum, total, total < 10 ? 1:10);
1109                 curnum++;
1110
1111                 if (fileinfo->flags) {
1112                         if (MSG_IS_MARKED(*fileinfo->flags))
1113                                 iflags |= IMAP_FLAG_FLAGGED;
1114                         if (MSG_IS_REPLIED(*fileinfo->flags))
1115                                 iflags |= IMAP_FLAG_ANSWERED;
1116                         if (!MSG_IS_UNREAD(*fileinfo->flags))
1117                                 iflags |= IMAP_FLAG_SEEN;
1118                 }
1119                 
1120                 if (real_file == NULL)
1121                         real_file = g_strdup(fileinfo->file);
1122                 
1123                 if (folder_has_parent_of_type(dest, F_QUEUE) ||
1124                     folder_has_parent_of_type(dest, F_OUTBOX) ||
1125                     folder_has_parent_of_type(dest, F_DRAFT) ||
1126                     folder_has_parent_of_type(dest, F_TRASH))
1127                         iflags |= IMAP_FLAG_SEEN;
1128
1129                 ok = imap_cmd_append(session, destdir, real_file, iflags, 
1130                                      &new_uid);
1131
1132                 if (ok != IMAP_SUCCESS) {
1133                         g_warning("can't append message %s\n", real_file);
1134                         g_free(real_file);
1135                         g_free(destdir);
1136                         unlock_session();
1137                         statusbar_progress_all(0,0,0);
1138                         statusbar_pop_all();
1139                         return -1;
1140                 } else {
1141                         debug_print("appended new message as %d\n", new_uid);
1142                         /* put the local file in the imapcache, so that we don't
1143                          * have to fetch it back later. */
1144                         if (new_uid > 0) {
1145                                 gchar *cache_path = folder_item_get_path(dest);
1146                                 if (!is_dir_exist(cache_path))
1147                                         make_dir_hier(cache_path);
1148                                 if (is_dir_exist(cache_path)) {
1149                                         gchar *cache_file = g_strconcat(
1150                                                 cache_path, G_DIR_SEPARATOR_S, 
1151                                                 itos(new_uid), NULL);
1152                                         copy_file(real_file, cache_file, TRUE);
1153                                         debug_print("copied to cache: %s\n", cache_file);
1154                                         g_free(cache_file);
1155                                 }
1156                                 g_free(cache_path);
1157                         }
1158                 }
1159
1160                 if (relation != NULL)
1161                         g_relation_insert(relation, fileinfo->msginfo != NULL ? 
1162                                           (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
1163                                           GINT_TO_POINTER(dest->last_num + 1));
1164                 if (new_uid == 0) {
1165                         new_uid = dest->last_num+1;
1166                 }
1167                 if (last_uid < new_uid) {
1168                         last_uid = new_uid;
1169                 }
1170
1171                 g_free(real_file);
1172         }
1173         statusbar_progress_all(0,0,0);
1174         statusbar_pop_all();
1175         
1176         imap_cmd_expunge(session);
1177         unlock_session();
1178         
1179         g_free(destdir);
1180
1181         return last_uid;
1182 }
1183
1184 static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest, 
1185                               MsgInfoList *msglist, GRelation *relation)
1186 {
1187         FolderItem *src;
1188         gchar *destdir;
1189         GSList *seq_list, *cur;
1190         MsgInfo *msginfo;
1191         IMAPSession *session;
1192         gint ok = IMAP_SUCCESS;
1193         GRelation *uid_mapping;
1194         gint last_num = 0;
1195         gboolean single = FALSE;
1196
1197         g_return_val_if_fail(folder != NULL, -1);
1198         g_return_val_if_fail(dest != NULL, -1);
1199         g_return_val_if_fail(msglist != NULL, -1);
1200         
1201         debug_print("getting session...\n");
1202         session = imap_session_get(folder);
1203         
1204         if (!session) {
1205                 return -1;
1206         }
1207
1208         msginfo = (MsgInfo *)msglist->data;
1209         if (msglist->next == NULL)
1210                 single = TRUE;
1211         src = msginfo->folder;
1212         if (src == dest) {
1213                 g_warning("the src folder is identical to the dest.\n");
1214                 unlock_session();
1215                 return -1;
1216         }
1217
1218         if (src->folder != dest->folder) {
1219                 GSList *infolist = NULL, *cur;
1220                 int res = -1;
1221                 for (cur = msglist; cur; cur = cur->next) {
1222                         msginfo = (MsgInfo *)cur->data;
1223                         MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
1224                         fileinfo->file = procmsg_get_message_file(msginfo);
1225                         fileinfo->flags = &(msginfo->flags);
1226                         infolist = g_slist_prepend(infolist, fileinfo);
1227                 }
1228                 infolist = g_slist_reverse(infolist);
1229                 unlock_session();
1230                 res = folder_item_add_msgs(dest, infolist, FALSE);
1231                 for (cur = infolist; cur; cur = cur->next) {
1232                         MsgFileInfo *info = (MsgFileInfo *)cur->data;
1233                         g_free(info->file);
1234                         g_free(info);
1235                 }
1236                 g_slist_free(infolist);
1237                 return res;
1238         } 
1239
1240         ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1241                          NULL, NULL, NULL, NULL, FALSE);
1242         if (ok != IMAP_SUCCESS) {
1243                 unlock_session();
1244                 return ok;
1245         }
1246
1247         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1248         seq_list = imap_get_lep_set_from_msglist(msglist);
1249         uid_mapping = g_relation_new(2);
1250         g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1251         
1252         statusbar_print_all(_("Copying messages..."));
1253         for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
1254                 struct mailimap_set * seq_set;
1255                 struct mailimap_set * source = NULL;
1256                 struct mailimap_set * dest = NULL;
1257                 seq_set = cur->data;
1258
1259                 debug_print("Copying messages from %s to %s ...\n",
1260                             src->path, destdir);
1261
1262                 ok = imap_cmd_copy(session, seq_set, destdir, uid_mapping,
1263                         &source, &dest);
1264                 
1265                 if (ok == IMAP_SUCCESS) {
1266                         if (single && relation && source && dest) {
1267                                 clistiter *l = clist_begin(source->set_list);
1268                                 struct mailimap_set_item *i = (struct mailimap_set_item *)clist_content(l);
1269                                 int snum = i->set_first;
1270                                 int dnum = 0;
1271                                 l = clist_begin(dest->set_list);
1272                                 i = (struct mailimap_set_item *)clist_content(l);
1273                                 dnum = i->set_first;
1274                                 g_relation_insert(uid_mapping, GINT_TO_POINTER(snum), 
1275                                         GINT_TO_POINTER(dnum));
1276                         }
1277                 }
1278
1279
1280                 if (source)
1281                         mailimap_set_free(source);
1282                 if (dest)
1283                         mailimap_set_free(dest);
1284
1285                 if (ok != IMAP_SUCCESS) {
1286                         g_relation_destroy(uid_mapping);
1287                         imap_lep_set_free(seq_list);
1288                         unlock_session();
1289                         return -1;
1290                 }
1291         }
1292
1293         for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
1294                 MsgInfo *msginfo = (MsgInfo *)cur->data;
1295                 GTuples *tuples;
1296
1297                 tuples = g_relation_select(uid_mapping, 
1298                                            GINT_TO_POINTER(msginfo->msgnum),
1299                                            0);
1300                 if (tuples->len > 0) {
1301                         gint num = GPOINTER_TO_INT(g_tuples_index(tuples, 0, 1));
1302                         g_relation_insert(relation, msginfo,
1303                                           GINT_TO_POINTER(num));
1304                         if (num > last_num)
1305                                 last_num = num;
1306                         debug_print("copied new message as %d\n", num);
1307                         /* put the local file in the imapcache, so that we don't
1308                          * have to fetch it back later. */
1309                         if (num > 0) {
1310                                 gchar *cache_path = folder_item_get_path(msginfo->folder);
1311                                 gchar *real_file = g_strconcat(
1312                                         cache_path, G_DIR_SEPARATOR_S, 
1313                                         itos(msginfo->msgnum), NULL);
1314                                 gchar *cache_file = NULL;
1315                                 g_free(cache_path);
1316                                 cache_path = folder_item_get_path(dest);
1317                                 cache_file = g_strconcat(
1318                                         cache_path, G_DIR_SEPARATOR_S, 
1319                                         itos(num), NULL);
1320                                 if (!is_dir_exist(cache_path))
1321                                         make_dir_hier(cache_path);
1322                                 if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
1323                                         copy_file(real_file, cache_file, TRUE);
1324                                         debug_print("copied to cache: %s\n", cache_file);
1325                                 }
1326                                 g_free(real_file);
1327                                 g_free(cache_file);
1328                                 g_free(cache_path);
1329                         }
1330                 } else
1331                         g_relation_insert(relation, msginfo,
1332                                           GINT_TO_POINTER(0));
1333                 g_tuples_destroy(tuples);
1334         }
1335         statusbar_pop_all();
1336
1337         g_relation_destroy(uid_mapping);
1338         imap_lep_set_free(seq_list);
1339
1340         g_free(destdir);
1341         
1342         IMAP_FOLDER_ITEM(dest)->lastuid = 0;
1343         IMAP_FOLDER_ITEM(dest)->uid_next = 0;
1344         g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
1345         IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
1346
1347         unlock_session();
1348         if (ok == IMAP_SUCCESS)
1349                 return last_num;
1350         else
1351                 return -1;
1352 }
1353
1354 static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1355 {
1356         GSList msglist;
1357
1358         g_return_val_if_fail(msginfo != NULL, -1);
1359
1360         msglist.data = msginfo;
1361         msglist.next = NULL;
1362
1363         return imap_copy_msgs(folder, dest, &msglist, NULL);
1364 }
1365
1366 static gint imap_copy_msgs(Folder *folder, FolderItem *dest, 
1367                     MsgInfoList *msglist, GRelation *relation)
1368 {
1369         MsgInfo *msginfo;
1370         gint ret;
1371
1372         g_return_val_if_fail(folder != NULL, -1);
1373         g_return_val_if_fail(dest != NULL, -1);
1374         g_return_val_if_fail(msglist != NULL, -1);
1375
1376         msginfo = (MsgInfo *)msglist->data;
1377         g_return_val_if_fail(msginfo->folder != NULL, -1);
1378
1379         ret = imap_do_copy_msgs(folder, dest, msglist, relation);
1380         return ret;
1381 }
1382
1383
1384 static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest, 
1385                                 MsgInfoList *msglist, GRelation *relation)
1386 {
1387         gchar *destdir, *dir;
1388         GSList *numlist = NULL, *cur;
1389         MsgInfo *msginfo;
1390         IMAPSession *session;
1391         gint ok = IMAP_SUCCESS;
1392         GRelation *uid_mapping;
1393         
1394         g_return_val_if_fail(folder != NULL, -1);
1395         g_return_val_if_fail(dest != NULL, -1);
1396         g_return_val_if_fail(msglist != NULL, -1);
1397
1398         debug_print("getting session...\n");
1399         session = imap_session_get(folder);
1400         if (!session) {
1401                 return -1;
1402         }
1403
1404         msginfo = (MsgInfo *)msglist->data;
1405
1406         ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder->path,
1407                          NULL, NULL, NULL, NULL, FALSE);
1408         if (ok != IMAP_SUCCESS) {
1409                 unlock_session();
1410                 return ok;
1411         }
1412
1413         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path);
1414         for (cur = msglist; cur; cur = cur->next) {
1415                 msginfo = (MsgInfo *)cur->data;
1416                 if (!MSG_IS_DELETED(msginfo->flags))
1417                         numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
1418         }
1419         numlist = g_slist_reverse(numlist);
1420
1421         uid_mapping = g_relation_new(2);
1422         g_relation_index(uid_mapping, 0, g_direct_hash, g_direct_equal);
1423
1424         ok = imap_set_message_flags
1425                 (IMAP_SESSION(REMOTE_FOLDER(folder)->session),
1426                 numlist, IMAP_FLAG_DELETED, TRUE);
1427         if (ok != IMAP_SUCCESS) {
1428                 log_warning(_("can't set deleted flags\n"));
1429                 unlock_session();
1430                 return ok;
1431         }
1432         ok = imap_cmd_expunge(session);
1433         if (ok != IMAP_SUCCESS) {
1434                 log_warning(_("can't expunge\n"));
1435                 unlock_session();
1436                 return ok;
1437         }
1438         
1439         dir = folder_item_get_path(msginfo->folder);
1440         if (is_dir_exist(dir)) {
1441                 for (cur = msglist; cur; cur = cur->next) {
1442                         msginfo = (MsgInfo *)cur->data;
1443                         remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
1444                 }
1445         }
1446         g_free(dir);
1447
1448         g_relation_destroy(uid_mapping);
1449         g_slist_free(numlist);
1450
1451         g_free(destdir);
1452         unlock_session();
1453         if (ok == IMAP_SUCCESS)
1454                 return 0;
1455         else
1456                 return -1;
1457 }
1458
1459 static gint imap_remove_msgs(Folder *folder, FolderItem *dest, 
1460                     MsgInfoList *msglist, GRelation *relation)
1461 {
1462         MsgInfo *msginfo;
1463
1464         g_return_val_if_fail(folder != NULL, -1);
1465         g_return_val_if_fail(dest != NULL, -1);
1466         if (msglist == NULL)
1467                 return 0;
1468
1469         msginfo = (MsgInfo *)msglist->data;
1470         g_return_val_if_fail(msginfo->folder != NULL, -1);
1471
1472         return imap_do_remove_msgs(folder, dest, msglist, relation);
1473 }
1474
1475 static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
1476 {
1477         GSList *list = folder_item_get_msg_list(item);
1478         gint res = imap_remove_msgs(folder, item, list, NULL);
1479         procmsg_msg_list_free(list);
1480         return res;
1481 }
1482
1483 static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
1484                                     MsgInfo *msginfo)
1485 {
1486         /* TODO: properly implement this method */
1487         return FALSE;
1488 }
1489
1490 static gint imap_close(Folder *folder, FolderItem *item)
1491 {
1492         return 0;
1493 }
1494
1495 static gint imap_scan_tree(Folder *folder)
1496 {
1497         FolderItem *item = NULL;
1498         IMAPSession *session;
1499         gchar *root_folder = NULL;
1500
1501         g_return_val_if_fail(folder != NULL, -1);
1502         g_return_val_if_fail(folder->account != NULL, -1);
1503
1504         debug_print("getting session...\n");
1505         session = imap_session_get(folder);
1506         if (!session) {
1507                 if (!folder->node) {
1508                         folder_tree_destroy(folder);
1509                         item = folder_item_new(folder, folder->name, NULL);
1510                         item->folder = folder;
1511                         folder->node = item->node = g_node_new(item);
1512                 }
1513                 return -1;
1514         }
1515
1516         if (folder->account->imap_dir && *folder->account->imap_dir) {
1517                 gchar *real_path;
1518                 int r;
1519                 clist * lep_list;
1520
1521                 Xstrdup_a(root_folder, folder->account->imap_dir, {unlock_session();return -1;});
1522                 extract_quote(root_folder, '"');
1523                 subst_char(root_folder,
1524                            imap_get_path_separator(session, IMAP_FOLDER(folder),
1525                                                    root_folder),
1526                            '/');
1527                 strtailchomp(root_folder, '/');
1528                 real_path = imap_get_real_path
1529                         (session, IMAP_FOLDER(folder), root_folder);
1530                 debug_print("IMAP root directory: %s\n", real_path);
1531
1532                 /* check if root directory exist */
1533
1534                 r = imap_threaded_list(session->folder, "", real_path,
1535                                        &lep_list);
1536                 if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
1537                         if (!folder->node) {
1538                                 item = folder_item_new(folder, folder->name, NULL);
1539                                 item->folder = folder;
1540                                 folder->node = item->node = g_node_new(item);
1541                         }
1542                         unlock_session();
1543                         return -1;
1544                 }
1545                 mailimap_list_result_free(lep_list);
1546                 
1547                 g_free(real_path);
1548         }
1549
1550         if (folder->node)
1551                 item = FOLDER_ITEM(folder->node->data);
1552         if (!item || ((item->path || root_folder) &&
1553                       strcmp2(item->path, root_folder) != 0)) {
1554                 folder_tree_destroy(folder);
1555                 item = folder_item_new(folder, folder->name, root_folder);
1556                 item->folder = folder;
1557                 folder->node = item->node = g_node_new(item);
1558         }
1559
1560         imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data));
1561         imap_create_missing_folders(folder);
1562         unlock_session();
1563
1564         return 0;
1565 }
1566
1567 static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item)
1568 {
1569         Folder *folder;
1570         IMAPFolder *imapfolder;
1571         FolderItem *new_item;
1572         GSList *item_list, *cur;
1573         GNode *node;
1574         gchar *real_path;
1575         gchar *wildcard_path;
1576         gchar separator;
1577         gchar wildcard[3];
1578         clist * lep_list;
1579         int r;
1580         
1581         g_return_val_if_fail(item != NULL, -1);
1582         g_return_val_if_fail(item->folder != NULL, -1);
1583         g_return_val_if_fail(item->no_sub == FALSE, -1);
1584
1585         folder = item->folder;
1586         imapfolder = IMAP_FOLDER(folder);
1587
1588         separator = imap_get_path_separator(session, imapfolder, item->path);
1589
1590         if (folder->ui_func)
1591                 folder->ui_func(folder, item, folder->ui_func_data);
1592
1593         if (item->path) {
1594                 wildcard[0] = separator;
1595                 wildcard[1] = '%';
1596                 wildcard[2] = '\0';
1597                 real_path = imap_get_real_path(session, imapfolder, item->path);
1598         } else {
1599                 wildcard[0] = '%';
1600                 wildcard[1] = '\0';
1601                 real_path = g_strdup("");
1602         }
1603
1604         Xstrcat_a(wildcard_path, real_path, wildcard,
1605                   {g_free(real_path); return IMAP_ERROR;});
1606         lep_list = NULL;
1607         r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
1608         if (r != MAILIMAP_NO_ERROR) {
1609                 item_list = NULL;
1610         }
1611         else {
1612                 item_list = imap_list_from_lep(imapfolder,
1613                                                lep_list, real_path, FALSE);
1614                 mailimap_list_result_free(lep_list);
1615         }
1616         
1617         g_free(real_path);
1618
1619         node = item->node->children;
1620         while (node != NULL) {
1621                 FolderItem *old_item = FOLDER_ITEM(node->data);
1622                 GNode *next = node->next;
1623
1624                 new_item = NULL;
1625                 for (cur = item_list; cur != NULL; cur = cur->next) {
1626                         FolderItem *cur_item = FOLDER_ITEM(cur->data);
1627                         if (!strcmp2(old_item->path, cur_item->path)) {
1628                                 new_item = cur_item;
1629                                 break;
1630                         }
1631                 }
1632                 if (!new_item) {
1633                         debug_print("folder '%s' not found. removing...\n",
1634                                     old_item->path);
1635                         folder_item_remove(old_item);
1636                 } else {
1637                         old_item->no_sub = new_item->no_sub;
1638                         old_item->no_select = new_item->no_select;
1639                         if (old_item->no_sub == TRUE && node->children) {
1640                                 debug_print("folder '%s' doesn't have "
1641                                             "subfolders. removing...\n",
1642                                             old_item->path);
1643                                 folder_item_remove_children(old_item);
1644                         }
1645                 }
1646
1647                 node = next;
1648         }
1649
1650         for (cur = item_list; cur != NULL; cur = cur->next) {
1651                 FolderItem *cur_item = FOLDER_ITEM(cur->data);
1652                 new_item = NULL;
1653
1654                 for (node = item->node->children; node != NULL;
1655                      node = node->next) {
1656                         if (!strcmp2(FOLDER_ITEM(node->data)->path,
1657                                      cur_item->path)) {
1658                                 new_item = FOLDER_ITEM(node->data);
1659                                 folder_item_destroy(cur_item);
1660                                 cur_item = NULL;
1661                                 break;
1662                         }
1663                 }
1664                 if (!new_item) {
1665                         new_item = cur_item;
1666                         debug_print("new folder '%s' found.\n", new_item->path);
1667                         folder_item_append(item, new_item);
1668                 }
1669
1670                 if (!strcmp(new_item->path, "INBOX")) {
1671                         new_item->stype = F_INBOX;
1672                         folder->inbox = new_item;
1673                 } else if (!folder_item_parent(item) || item->stype == F_INBOX) {
1674                         gchar *base;
1675
1676                         base = g_path_get_basename(new_item->path);
1677
1678                         if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
1679                                 new_item->stype = F_OUTBOX;
1680                                 folder->outbox = new_item;
1681                         } else if (!folder->draft && !g_ascii_strcasecmp(base, "Drafts")) {
1682                                 new_item->stype = F_DRAFT;
1683                                 folder->draft = new_item;
1684                         } else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
1685                                 new_item->stype = F_QUEUE;
1686                                 folder->queue = new_item;
1687                         } else if (!folder->trash && !g_ascii_strcasecmp(base, "Trash")) {
1688                                 new_item->stype = F_TRASH;
1689                                 folder->trash = new_item;
1690                         }
1691                         g_free(base);
1692                 }
1693
1694                 if (new_item->no_sub == FALSE)
1695                         imap_scan_tree_recursive(session, new_item);
1696         }
1697
1698         g_slist_free(item_list);
1699
1700         return IMAP_SUCCESS;
1701 }
1702
1703 static gint imap_create_tree(Folder *folder)
1704 {
1705         g_return_val_if_fail(folder != NULL, -1);
1706         g_return_val_if_fail(folder->node != NULL, -1);
1707         g_return_val_if_fail(folder->node->data != NULL, -1);
1708         g_return_val_if_fail(folder->account != NULL, -1);
1709
1710         imap_scan_tree(folder);
1711         imap_create_missing_folders(folder);
1712
1713         return 0;
1714 }
1715
1716 static void imap_create_missing_folders(Folder *folder)
1717 {
1718         g_return_if_fail(folder != NULL);
1719
1720         if (!folder->inbox)
1721                 folder->inbox = imap_create_special_folder
1722                         (folder, F_INBOX, "INBOX");
1723         if (!folder->trash)
1724                 folder->trash = imap_create_special_folder
1725                         (folder, F_TRASH, "Trash");
1726         if (!folder->queue)
1727                 folder->queue = imap_create_special_folder
1728                         (folder, F_QUEUE, "Queue");
1729         if (!folder->outbox)
1730                 folder->outbox = imap_create_special_folder
1731                         (folder, F_OUTBOX, "Sent");
1732         if (!folder->draft)
1733                 folder->draft = imap_create_special_folder
1734                         (folder, F_DRAFT, "Drafts");
1735 }
1736
1737 static FolderItem *imap_create_special_folder(Folder *folder,
1738                                               SpecialFolderItemType stype,
1739                                               const gchar *name)
1740 {
1741         FolderItem *item;
1742         FolderItem *new_item;
1743
1744         g_return_val_if_fail(folder != NULL, NULL);
1745         g_return_val_if_fail(folder->node != NULL, NULL);
1746         g_return_val_if_fail(folder->node->data != NULL, NULL);
1747         g_return_val_if_fail(folder->account != NULL, NULL);
1748         g_return_val_if_fail(name != NULL, NULL);
1749
1750         item = FOLDER_ITEM(folder->node->data);
1751         new_item = imap_create_folder(folder, item, name);
1752
1753         if (!new_item) {
1754                 g_warning("Can't create '%s'\n", name);
1755                 if (!folder->inbox) return NULL;
1756
1757                 new_item = imap_create_folder(folder, folder->inbox, name);
1758                 if (!new_item)
1759                         g_warning("Can't create '%s' under INBOX\n", name);
1760                 else
1761                         new_item->stype = stype;
1762         } else
1763                 new_item->stype = stype;
1764
1765         return new_item;
1766 }
1767
1768 static gchar *imap_folder_get_path(Folder *folder)
1769 {
1770         gchar *folder_path;
1771
1772         g_return_val_if_fail(folder != NULL, NULL);
1773         g_return_val_if_fail(folder->account != NULL, NULL);
1774
1775         folder_path = g_strconcat(get_imap_cache_dir(),
1776                                   G_DIR_SEPARATOR_S,
1777                                   folder->account->recv_server,
1778                                   G_DIR_SEPARATOR_S,
1779                                   folder->account->userid,
1780                                   NULL);
1781
1782         return folder_path;
1783 }
1784
1785 static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
1786 {
1787         gchar *folder_path, *path;
1788
1789         g_return_val_if_fail(folder != NULL, NULL);
1790         g_return_val_if_fail(item != NULL, NULL);
1791         folder_path = imap_folder_get_path(folder);
1792
1793         g_return_val_if_fail(folder_path != NULL, NULL);
1794         if (folder_path[0] == G_DIR_SEPARATOR) {
1795                 if (item->path)
1796                         path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
1797                                            item->path, NULL);
1798                 else
1799                         path = g_strdup(folder_path);
1800         } else {
1801                 if (item->path)
1802                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1803                                            folder_path, G_DIR_SEPARATOR_S,
1804                                            item->path, NULL);
1805                 else
1806                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
1807                                            folder_path, NULL);
1808         }
1809         g_free(folder_path);
1810
1811         return path;
1812 }
1813
1814 static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
1815                                const gchar *name)
1816 {
1817         gchar *dirpath, *imap_path;
1818         IMAPSession *session;
1819         FolderItem *new_item;
1820         gchar separator;
1821         gchar *new_name;
1822         const gchar *p;
1823         gint ok;
1824         gboolean no_select = FALSE, no_sub = FALSE;
1825         
1826         g_return_val_if_fail(folder != NULL, NULL);
1827         g_return_val_if_fail(folder->account != NULL, NULL);
1828         g_return_val_if_fail(parent != NULL, NULL);
1829         g_return_val_if_fail(name != NULL, NULL);
1830
1831         debug_print("getting session...\n");
1832         session = imap_session_get(folder);
1833         if (!session) {
1834                 return NULL;
1835         }
1836
1837         if (!folder_item_parent(parent) && strcmp(name, "INBOX") == 0) {
1838                 dirpath = g_strdup(name);
1839         }else if (parent->path)
1840                 dirpath = g_strconcat(parent->path, "/", name, NULL);
1841         else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
1842                 dirpath = g_strdup(name);
1843         else if (folder->account->imap_dir && *folder->account->imap_dir) {
1844                 gchar *imap_dir;
1845
1846                 Xstrdup_a(imap_dir, folder->account->imap_dir, {unlock_session();return NULL;});
1847                 strtailchomp(imap_dir, '/');
1848                 dirpath = g_strconcat(imap_dir, "/", name, NULL);
1849         } else
1850                 dirpath = g_strdup(name);
1851                 
1852         
1853
1854         /* keep trailing directory separator to create a folder that contains
1855            sub folder */
1856         imap_path = imap_utf8_to_modified_utf7(dirpath);
1857
1858         strtailchomp(dirpath, '/');
1859         Xstrdup_a(new_name, name, {
1860                 g_free(dirpath); 
1861                 unlock_session();               
1862                 return NULL;});
1863
1864         separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path);
1865         imap_path_separator_subst(imap_path, separator);
1866         /* remove trailing / for display */
1867         strtailchomp(new_name, '/');
1868
1869         if (strcmp(dirpath, "INBOX") != 0) {
1870                 GPtrArray *argbuf;
1871                 gboolean exist = FALSE;
1872                 int r;
1873                 clist * lep_list;
1874                 
1875                 argbuf = g_ptr_array_new();
1876                 r = imap_threaded_list(folder, "", imap_path, &lep_list);
1877                 if (r != MAILIMAP_NO_ERROR) {
1878                         log_warning(_("can't create mailbox: LIST failed\n"));
1879                         g_free(imap_path);
1880                         g_free(dirpath);
1881                         ptr_array_free_strings(argbuf);
1882                         g_ptr_array_free(argbuf, TRUE);
1883                         unlock_session();
1884                         return NULL;
1885                 }
1886                 
1887                 if (clist_count(lep_list) > 0)
1888                         exist = TRUE;
1889                 mailimap_list_result_free(lep_list);
1890                 lep_list = NULL;
1891                 if (!exist) {
1892                         ok = imap_cmd_create(session, imap_path);
1893                         if (ok != IMAP_SUCCESS) {
1894                                 log_warning(_("can't create mailbox\n"));
1895                                 g_free(imap_path);
1896                                 g_free(dirpath);
1897                                 unlock_session();
1898                                 return NULL;
1899                         }
1900                         r = imap_threaded_list(folder, "", imap_path, &lep_list);
1901                         if (r == MAILIMAP_NO_ERROR) {
1902                                 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
1903                                                lep_list, dirpath, TRUE);
1904                                 if (item_list) {
1905                                         FolderItem *cur_item = FOLDER_ITEM(item_list->data);
1906                                         no_select = cur_item->no_select;
1907                                         no_sub = cur_item->no_sub;
1908                                         g_slist_free(item_list);
1909                                 } 
1910                                 mailimap_list_result_free(lep_list);
1911                         }
1912
1913                 }
1914         } else {
1915                 clist *lep_list;
1916                 int r;
1917                 /* just get flags */
1918                 r = imap_threaded_list(folder, "", "INBOX", &lep_list);
1919                 if (r == MAILIMAP_NO_ERROR) {
1920                         GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
1921                                        lep_list, dirpath, TRUE);
1922                         if (item_list) {
1923                                 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
1924                                 no_select = cur_item->no_select;
1925                                 no_sub = cur_item->no_sub;
1926                                 g_slist_free(item_list);
1927                         } 
1928                         mailimap_list_result_free(lep_list);
1929                 }
1930         }
1931
1932         new_item = folder_item_new(folder, new_name, dirpath);
1933         new_item->no_select = no_select;
1934         new_item->no_sub = no_sub;
1935         folder_item_append(parent, new_item);
1936         g_free(imap_path);
1937         g_free(dirpath);
1938
1939         dirpath = folder_item_get_path(new_item);
1940         if (!is_dir_exist(dirpath))
1941                 make_dir_hier(dirpath);
1942         g_free(dirpath);
1943         unlock_session();
1944         return new_item;
1945 }
1946
1947 static gint imap_rename_folder(Folder *folder, FolderItem *item,
1948                                const gchar *name)
1949 {
1950         gchar *dirpath;
1951         gchar *newpath;
1952         gchar *real_oldpath;
1953         gchar *real_newpath;
1954         gchar *paths[2];
1955         gchar *old_cache_dir;
1956         gchar *new_cache_dir;
1957         IMAPSession *session;
1958         gchar separator;
1959         gint ok;
1960         gint exists, recent, unseen;
1961         guint32 uid_validity;
1962
1963         g_return_val_if_fail(folder != NULL, -1);
1964         g_return_val_if_fail(item != NULL, -1);
1965         g_return_val_if_fail(item->path != NULL, -1);
1966         g_return_val_if_fail(name != NULL, -1);
1967
1968         debug_print("getting session...\n");
1969         session = imap_session_get(folder);
1970         if (!session) {
1971                 return -1;
1972         }
1973
1974         if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path)) != NULL) {
1975                 g_warning(_("New folder name must not contain the namespace "
1976                             "path separator"));
1977                 unlock_session();
1978                 return -1;
1979         }
1980
1981         real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
1982
1983         g_free(session->mbox);
1984         session->mbox = NULL;
1985         ok = imap_cmd_examine(session, "INBOX",
1986                               &exists, &recent, &unseen, &uid_validity, FALSE);
1987         if (ok != IMAP_SUCCESS) {
1988                 g_free(real_oldpath);
1989                 unlock_session();
1990                 return -1;
1991         }
1992
1993         separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path);
1994         if (strchr(item->path, G_DIR_SEPARATOR)) {
1995                 dirpath = g_path_get_dirname(item->path);
1996                 newpath = g_strconcat(dirpath, G_DIR_SEPARATOR_S, name, NULL);
1997                 g_free(dirpath);
1998         } else
1999                 newpath = g_strdup(name);
2000
2001         real_newpath = imap_utf8_to_modified_utf7(newpath);
2002         imap_path_separator_subst(real_newpath, separator);
2003
2004         ok = imap_cmd_rename(session, real_oldpath, real_newpath);
2005         if (ok != IMAP_SUCCESS) {
2006                 log_warning(_("can't rename mailbox: %s to %s\n"),
2007                             real_oldpath, real_newpath);
2008                 g_free(real_oldpath);
2009                 g_free(newpath);
2010                 g_free(real_newpath);
2011                 unlock_session();
2012                 return -1;
2013         }
2014
2015         g_free(item->name);
2016         item->name = g_strdup(name);
2017
2018         old_cache_dir = folder_item_get_path(item);
2019
2020         paths[0] = g_strdup(item->path);
2021         paths[1] = newpath;
2022         g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
2023                         imap_rename_folder_func, paths);
2024
2025         if (is_dir_exist(old_cache_dir)) {
2026                 new_cache_dir = folder_item_get_path(item);
2027                 if (rename(old_cache_dir, new_cache_dir) < 0) {
2028                         FILE_OP_ERROR(old_cache_dir, "rename");
2029                 }
2030                 g_free(new_cache_dir);
2031         }
2032
2033         g_free(old_cache_dir);
2034         g_free(paths[0]);
2035         g_free(newpath);
2036         g_free(real_oldpath);
2037         g_free(real_newpath);
2038         unlock_session();
2039         return 0;
2040 }
2041
2042 static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
2043 {
2044         gint ok;
2045         IMAPSession *session;
2046         gchar *path;
2047         gchar *cache_dir;
2048
2049         g_return_val_if_fail(folder != NULL, -1);
2050         g_return_val_if_fail(item != NULL, -1);
2051         g_return_val_if_fail(item->path != NULL, -1);
2052
2053         debug_print("getting session...\n");
2054         session = imap_session_get(folder);
2055         if (!session) {
2056                 return -1;
2057         }
2058         path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path);
2059
2060         ok = imap_cmd_delete(session, path);
2061         if (ok != IMAP_SUCCESS) {
2062                 gchar *tmp = g_strdup_printf("%s%c", path, 
2063                                 imap_get_path_separator(session, IMAP_FOLDER(folder), path));
2064                 g_free(path);
2065                 path = tmp;
2066                 ok = imap_cmd_delete(session, path);
2067         }
2068
2069         if (ok != IMAP_SUCCESS) {
2070                 log_warning(_("can't delete mailbox\n"));
2071                 g_free(path);
2072                 unlock_session();
2073                 return -1;
2074         }
2075
2076         g_free(path);
2077         cache_dir = folder_item_get_path(item);
2078         if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
2079                 g_warning("can't remove directory '%s'\n", cache_dir);
2080         g_free(cache_dir);
2081         folder_item_remove(item);
2082         unlock_session();
2083         return 0;
2084 }
2085
2086 static gint imap_remove_folder(Folder *folder, FolderItem *item)
2087 {
2088         GNode *node, *next;
2089
2090         g_return_val_if_fail(item != NULL, -1);
2091         g_return_val_if_fail(item->folder != NULL, -1);
2092         g_return_val_if_fail(item->node != NULL, -1);
2093
2094         node = item->node->children;
2095         while (node != NULL) {
2096                 next = node->next;
2097                 if (imap_remove_folder(folder, FOLDER_ITEM(node->data)) < 0)
2098                         return -1;
2099                 node = next;
2100         }
2101         debug_print("IMAP removing %s\n", item->path);
2102
2103         if (imap_remove_all_msg(folder, item) < 0)
2104                 return -1;
2105         return imap_remove_folder_real(folder, item);
2106 }
2107
2108 typedef struct _uncached_data {
2109         IMAPSession *session;
2110         FolderItem *item;
2111         MsgNumberList *numlist;
2112         guint cur;
2113         guint total;
2114         gboolean done;
2115 } uncached_data;
2116
2117 static void *imap_get_uncached_messages_thread(void *data)
2118 {
2119         uncached_data *stuff = (uncached_data *)data;
2120         IMAPSession *session = stuff->session;
2121         FolderItem *item = stuff->item;
2122         MsgNumberList *numlist = stuff->numlist;
2123         
2124         GSList *newlist = NULL;
2125         GSList *llast = NULL;
2126         GSList *seq_list, *cur;
2127
2128         debug_print("uncached_messages\n");
2129         
2130         if (session == NULL || item == NULL || item->folder == NULL
2131             || FOLDER_CLASS(item->folder) != &imap_class) {
2132                 stuff->done = TRUE;
2133                 return NULL;
2134         }
2135         
2136         seq_list = imap_get_lep_set_from_numlist(numlist);
2137         debug_print("get msgs info\n");
2138         for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2139                 struct mailimap_set * imapset;
2140                 unsigned int i;
2141                 int r;
2142                 carray * env_list;
2143                 int count;
2144                 
2145                 imapset = cur->data;
2146                 
2147                 r = imap_threaded_fetch_env(session->folder,
2148                                             imapset, &env_list);
2149                 if (r != MAILIMAP_NO_ERROR)
2150                         continue;
2151                 
2152                 session_set_access_time(SESSION(session));
2153
2154                 count = 0;
2155                 for(i = 0 ; i < carray_count(env_list) ; i ++) {
2156                         struct imap_fetch_env_info * info;
2157                         MsgInfo * msginfo;
2158                         
2159                         info = carray_get(env_list, i);
2160                         msginfo = imap_envelope_from_lep(info, item);
2161                         if (msginfo == NULL)
2162                                 continue;
2163                         msginfo->folder = item;
2164                         if (!newlist)
2165                                 llast = newlist = g_slist_append(newlist, msginfo);
2166                         else {
2167                                 llast = g_slist_append(llast, msginfo);
2168                                 llast = llast->next;
2169                         }
2170                         count ++;
2171                 }
2172                 
2173                 imap_fetch_env_free(env_list);
2174         }
2175         
2176         for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
2177                 struct mailimap_set * imapset;
2178                 
2179                 imapset = cur->data;
2180                 mailimap_set_free(imapset);
2181         }
2182         
2183         session_set_access_time(SESSION(session));
2184         stuff->done = TRUE;
2185         return newlist;
2186 }
2187
2188 #define MAX_MSG_NUM 50
2189
2190 static GSList *imap_get_uncached_messages(IMAPSession *session,
2191                                         FolderItem *item,
2192                                         MsgNumberList *numlist)
2193 {
2194         GSList *result = NULL;
2195         GSList * cur;
2196         uncached_data *data = g_new0(uncached_data, 1);
2197         int finished;
2198         
2199         finished = 0;
2200         cur = numlist;
2201         data->total = g_slist_length(numlist);
2202         debug_print("messages list : %i\n", data->total);
2203
2204         while (cur != NULL) {
2205                 GSList * partial_result;
2206                 int count;
2207                 GSList * newlist;
2208                 GSList * llast;
2209                 
2210                 llast = NULL;
2211                 count = 0;
2212                 newlist = NULL;
2213                 while (count < MAX_MSG_NUM) {
2214                         void * p;
2215                         
2216                         p = cur->data;
2217                         
2218                         if (newlist == NULL)
2219                                 llast = newlist = g_slist_append(newlist, p);
2220                         else {
2221                                 llast = g_slist_append(llast, p);
2222                                 llast = llast->next;
2223                         }
2224                         count ++;
2225                         
2226                         cur = cur->next;
2227                         if (cur == NULL)
2228                                 break;
2229                 }
2230                 
2231                 data->done = FALSE;
2232                 data->session = session;
2233                 data->item = item;
2234                 data->numlist = newlist;
2235                 data->cur += count;
2236                 
2237                 if (prefs_common.work_offline && 
2238                     !inc_offline_should_override(
2239                         _("Claws Mail needs network access in order "
2240                           "to access the IMAP server."))) {
2241                         g_free(data);
2242                         return NULL;
2243                 }
2244                 
2245                 partial_result =
2246                         (GSList *)imap_get_uncached_messages_thread(data);
2247                 
2248                 statusbar_progress_all(data->cur,data->total, 1);
2249                 
2250                 g_slist_free(newlist);
2251                 
2252                 result = g_slist_concat(result, partial_result);
2253         }
2254         g_free(data);
2255         
2256         statusbar_progress_all(0,0,0);
2257         statusbar_pop_all();
2258         
2259         return result;
2260 }
2261
2262 static void imap_delete_all_cached_messages(FolderItem *item)
2263 {
2264         gchar *dir;
2265
2266         g_return_if_fail(item != NULL);
2267         g_return_if_fail(item->folder != NULL);
2268         g_return_if_fail(FOLDER_CLASS(item->folder) == &imap_class);
2269
2270         debug_print("Deleting all cached messages...\n");
2271
2272         dir = folder_item_get_path(item);
2273         if (is_dir_exist(dir))
2274                 remove_all_numbered_files(dir);
2275         g_free(dir);
2276
2277         debug_print("done.\n");
2278 }
2279
2280 gchar imap_get_path_separator_for_item(FolderItem *item)
2281 {
2282         Folder *folder = NULL;
2283         IMAPFolder *imap_folder = NULL;
2284         IMAPSession *session = NULL;
2285         gchar result = '/';
2286         
2287         if (!item)
2288                 return '/';
2289         folder = item->folder;
2290         
2291         if (!folder)
2292                 return '/';
2293         
2294         imap_folder = IMAP_FOLDER(folder);
2295         
2296         if (!imap_folder)
2297                 return '/';
2298         
2299         debug_print("getting session...");
2300         session = imap_session_get(FOLDER(folder));
2301         result = imap_get_path_separator(session, imap_folder, item->path);
2302         unlock_session();
2303         return result;
2304 }
2305
2306 static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder)
2307 {
2308         clist * lep_list;
2309         int r;
2310         gchar separator = '\0';
2311         
2312         g_return_val_if_fail(session != NULL, '/');
2313         r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
2314         
2315         if (r != MAILIMAP_NO_ERROR) {
2316                 log_warning(_("LIST failed\n"));
2317                 return '\0';
2318         }
2319
2320         if (clist_count(lep_list) > 0) {
2321                 clistiter * iter = clist_begin(lep_list); 
2322                 struct mailimap_mailbox_list * mb;
2323                 mb = clist_content(iter);
2324
2325                 separator = mb->mb_delimiter;
2326                 debug_print("got separator: %c\n", folder->last_seen_separator);
2327         }
2328         mailimap_list_result_free(lep_list);
2329         return separator;
2330 }
2331
2332 static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2333 {
2334         gchar separator = '/';
2335
2336         if (folder->last_seen_separator == 0) {
2337                 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "");
2338         }
2339
2340         if (folder->last_seen_separator == 0) {
2341                 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX");
2342         }
2343
2344         if (folder->last_seen_separator != 0) {
2345                 debug_print("using separator: %c\n", folder->last_seen_separator);
2346                 return folder->last_seen_separator;
2347         }
2348
2349         return separator;
2350 }
2351
2352 static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path)
2353 {
2354         gchar *real_path;
2355         gchar separator;
2356
2357         g_return_val_if_fail(folder != NULL, NULL);
2358         g_return_val_if_fail(path != NULL, NULL);
2359
2360         real_path = imap_utf8_to_modified_utf7(path);
2361         separator = imap_get_path_separator(session, folder, path);
2362         imap_path_separator_subst(real_path, separator);
2363
2364         return real_path;
2365 }
2366
2367 static gint imap_set_message_flags(IMAPSession *session,
2368                                    MsgNumberList *numlist,
2369                                    IMAPFlags flags,
2370                                    gboolean is_set)
2371 {
2372         gint ok = 0;
2373         GSList *seq_list;
2374         GSList * cur;
2375
2376         seq_list = imap_get_lep_set_from_numlist(numlist);
2377         
2378         for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
2379                 struct mailimap_set * imapset;
2380                 
2381                 imapset = cur->data;
2382                 
2383                 ok = imap_cmd_store(session, imapset,
2384                                     flags, is_set);
2385         }
2386         
2387         imap_lep_set_free(seq_list);
2388         
2389         return IMAP_SUCCESS;
2390 }
2391
2392 typedef struct _select_data {
2393         IMAPSession *session;
2394         gchar *real_path;
2395         gint *exists;
2396         gint *recent;
2397         gint *unseen;
2398         guint32 *uid_validity;
2399         gboolean done;
2400 } select_data;
2401
2402 static gint imap_select(IMAPSession *session, IMAPFolder *folder,
2403                         const gchar *path,
2404                         gint *exists, gint *recent, gint *unseen,
2405                         guint32 *uid_validity, gboolean block)
2406 {
2407         gchar *real_path;
2408         gint ok;
2409         gint exists_, recent_, unseen_;
2410         guint32 uid_validity_;
2411         
2412         if (!exists && !recent && !unseen && !uid_validity) {
2413                 if (session->mbox && strcmp(session->mbox, path) == 0)
2414                         return IMAP_SUCCESS;
2415         }
2416         if (!exists)
2417                 exists = &exists_;
2418         if (!recent)
2419                 recent = &recent_;
2420         if (!unseen)
2421                 unseen = &unseen_;
2422         if (!uid_validity)
2423                 uid_validity = &uid_validity_;
2424
2425         g_free(session->mbox);
2426         session->mbox = NULL;
2427
2428         real_path = imap_get_real_path(session, folder, path);
2429
2430         ok = imap_cmd_select(session, real_path,
2431                              exists, recent, unseen, uid_validity, block);
2432         if (ok != IMAP_SUCCESS)
2433                 log_warning(_("can't select folder: %s\n"), real_path);
2434         else {
2435                 session->mbox = g_strdup(path);
2436                 session->folder_content_changed = FALSE;
2437         }
2438         g_free(real_path);
2439
2440         return ok;
2441 }
2442
2443 static gint imap_status(IMAPSession *session, IMAPFolder *folder,
2444                         const gchar *path, IMAPFolderItem *item,
2445                         gint *messages,
2446                         guint32 *uid_next, guint32 *uid_validity,
2447                         gint *unseen, gboolean block)
2448 {
2449         int r;
2450         clistiter * iter;
2451         struct mailimap_mailbox_data_status * data_status;
2452         int got_values;
2453         gchar *real_path;
2454         guint mask = 0;
2455         
2456         real_path = imap_get_real_path(session, folder, path);
2457
2458         if (messages) {
2459                 mask |= 1 << 0;
2460         }
2461         if (uid_next) {
2462                 mask |= 1 << 2;
2463         }
2464         if (uid_validity) {
2465                 mask |= 1 << 3;
2466         }
2467         if (unseen) {
2468                 mask |= 1 << 4;
2469         }
2470         r = imap_threaded_status(FOLDER(folder), real_path, 
2471                 &data_status, mask);
2472
2473         g_free(real_path);
2474         if (r != MAILIMAP_NO_ERROR) {
2475                 debug_print("status err %d\n", r);
2476                 return IMAP_ERROR;
2477         }
2478         
2479         if (data_status->st_info_list == NULL) {
2480                 mailimap_mailbox_data_status_free(data_status);
2481                 debug_print("status->st_info_list == NULL\n");
2482                 return IMAP_ERROR;
2483         }
2484         
2485         got_values = 0;
2486         for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
2487             iter = clist_next(iter)) {
2488                 struct mailimap_status_info * info;             
2489                 
2490                 info = clist_content(iter);
2491                 switch (info->st_att) {
2492                 case MAILIMAP_STATUS_ATT_MESSAGES:
2493                         * messages = info->st_value;
2494                         got_values |= 1 << 0;
2495                         break;
2496                         
2497                 case MAILIMAP_STATUS_ATT_UIDNEXT:
2498                         * uid_next = info->st_value;
2499                         got_values |= 1 << 2;
2500                         break;
2501                         
2502                 case MAILIMAP_STATUS_ATT_UIDVALIDITY:
2503                         * uid_validity = info->st_value;
2504                         got_values |= 1 << 3;
2505                         break;
2506                         
2507                 case MAILIMAP_STATUS_ATT_UNSEEN:
2508                         * unseen = info->st_value;
2509                         got_values |= 1 << 4;
2510                         break;
2511                 }
2512         }
2513         mailimap_mailbox_data_status_free(data_status);
2514         
2515         if (got_values != mask) {
2516                 debug_print("status: incomplete values received (%d)\n", got_values);
2517                 return IMAP_ERROR;
2518         }
2519         return IMAP_SUCCESS;
2520 }
2521
2522 static void imap_free_capabilities(IMAPSession *session)
2523 {
2524         slist_free_strings(session->capability);
2525         g_slist_free(session->capability);
2526         session->capability = NULL;
2527 }
2528
2529 /* low-level IMAP4rev1 commands */
2530
2531 static gint imap_cmd_login(IMAPSession *session,
2532                            const gchar *user, const gchar *pass,
2533                            const gchar *type)
2534 {
2535         int r;
2536         gint ok;
2537
2538         if (!strcmp(type, "LOGIN") && imap_has_capability(session, "LOGINDISABLED")) {
2539                 gint ok = IMAP_ERROR;
2540                 if (imap_has_capability(session, "STARTTLS")) {
2541 #if USE_OPENSSL
2542                         log_warning(_("Server requires TLS to log in.\n"));
2543                         ok = imap_cmd_starttls(session);
2544                         if (ok != IMAP_SUCCESS) {
2545                                 log_warning(_("Can't start TLS session.\n"));
2546                                 return IMAP_ERROR;
2547                         } else {
2548                                 /* refresh capas */
2549                                 imap_free_capabilities(session);
2550                                 if (imap_get_capabilities(session) != MAILIMAP_NO_ERROR) {
2551                                         log_warning(_("Can't refresh capabilities.\n"));
2552                                         return IMAP_ERROR;
2553                                 }
2554                         }
2555 #else           
2556                         log_error(_("Connection to %s failed: "
2557                                         "server requires TLS, but Claws Mail "
2558                                         "has been compiled without OpenSSL "
2559                                         "support.\n"),
2560                                         SESSION(session)->server);
2561                         return IMAP_ERROR;
2562 #endif
2563                 } else {
2564                         log_error(_("Server logins are disabled.\n"));
2565                         return IMAP_ERROR;
2566                 }
2567         }
2568
2569         log_print("IMAP4> Logging %s to %s using %s\n", 
2570                         user,
2571                         SESSION(session)->server,
2572                         type);
2573         r = imap_threaded_login(session->folder, user, pass, type);
2574         if (r != MAILIMAP_NO_ERROR) {
2575                 log_print("IMAP4< Error logging in to %s\n",
2576                                 SESSION(session)->server);
2577                 ok = IMAP_ERROR;
2578         } else {
2579                 log_print("IMAP4< Login to %s successful\n",
2580                                 SESSION(session)->server);
2581                 ok = IMAP_SUCCESS;
2582         }
2583         return ok;
2584 }
2585
2586 static gint imap_cmd_noop(IMAPSession *session)
2587 {
2588         int r;
2589         unsigned int exists;
2590         
2591         r = imap_threaded_noop(session->folder, &exists);
2592         if (r != MAILIMAP_NO_ERROR) {
2593                 debug_print("noop err %d\n", r);
2594                 return IMAP_ERROR;
2595         }
2596         session->exists = exists;
2597         session_set_access_time(SESSION(session));
2598
2599         return IMAP_SUCCESS;
2600 }
2601
2602 #if USE_OPENSSL
2603 static gint imap_cmd_starttls(IMAPSession *session)
2604 {
2605         int r;
2606         
2607         r = imap_threaded_starttls(session->folder, 
2608                 SESSION(session)->server, SESSION(session)->port);
2609         if (r != MAILIMAP_NO_ERROR) {
2610                 debug_print("starttls err %d\n", r);
2611                 return IMAP_ERROR;
2612         }
2613         return IMAP_SUCCESS;
2614 }
2615 #endif
2616
2617 static gint imap_cmd_select(IMAPSession *session, const gchar *folder,
2618                             gint *exists, gint *recent, gint *unseen,
2619                             guint32 *uid_validity, gboolean block)
2620 {
2621         int r;
2622
2623         r = imap_threaded_select(session->folder, folder,
2624                                  exists, recent, unseen, uid_validity);
2625         if (r != MAILIMAP_NO_ERROR) {
2626                 debug_print("select err %d\n", r);
2627                 return IMAP_ERROR;
2628         }
2629         return IMAP_SUCCESS;
2630 }
2631
2632 static gint imap_cmd_examine(IMAPSession *session, const gchar *folder,
2633                              gint *exists, gint *recent, gint *unseen,
2634                              guint32 *uid_validity, gboolean block)
2635 {
2636         int r;
2637
2638         r = imap_threaded_examine(session->folder, folder,
2639                                   exists, recent, unseen, uid_validity);
2640         if (r != MAILIMAP_NO_ERROR) {
2641                 debug_print("examine err %d\n", r);
2642                 
2643                 return IMAP_ERROR;
2644         }
2645         return IMAP_SUCCESS;
2646 }
2647
2648 static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
2649 {
2650         int r;
2651
2652         r = imap_threaded_create(session->folder, folder);
2653         if (r != MAILIMAP_NO_ERROR) {
2654                 
2655                 return IMAP_ERROR;
2656         }
2657
2658         return IMAP_SUCCESS;
2659 }
2660
2661 static gint imap_cmd_rename(IMAPSession *session, const gchar *old_folder,
2662                             const gchar *new_folder)
2663 {
2664         int r;
2665
2666         r = imap_threaded_rename(session->folder, old_folder,
2667                                  new_folder);
2668         if (r != MAILIMAP_NO_ERROR) {
2669                 
2670                 return IMAP_ERROR;
2671         }
2672
2673         return IMAP_SUCCESS;
2674 }
2675
2676 static gint imap_cmd_delete(IMAPSession *session, const gchar *folder)
2677 {
2678         int r;
2679         
2680
2681         r = imap_threaded_delete(session->folder, folder);
2682         if (r != MAILIMAP_NO_ERROR) {
2683                 
2684                 return IMAP_ERROR;
2685         }
2686
2687         return IMAP_SUCCESS;
2688 }
2689
2690 typedef struct _fetch_data {
2691         IMAPSession *session;
2692         guint32 uid;
2693         const gchar *filename;
2694         gboolean headers;
2695         gboolean body;
2696         gboolean done;
2697 } fetch_data;
2698
2699 static void *imap_cmd_fetch_thread(void *data)
2700 {
2701         fetch_data *stuff = (fetch_data *)data;
2702         IMAPSession *session = stuff->session;
2703         guint32 uid = stuff->uid;
2704         const gchar *filename = stuff->filename;
2705         int r;
2706         
2707         if (stuff->body) {
2708                 r = imap_threaded_fetch_content(session->folder,
2709                                                uid, 1, filename);
2710         }
2711         else {
2712                 r = imap_threaded_fetch_content(session->folder,
2713                                                 uid, 0, filename);
2714         }
2715         if (r != MAILIMAP_NO_ERROR) {
2716                 debug_print("fetch err %d\n", r);
2717                 return GINT_TO_POINTER(IMAP_ERROR);
2718         }
2719         return GINT_TO_POINTER(IMAP_SUCCESS);
2720 }
2721
2722 static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
2723                                 const gchar *filename, gboolean headers,
2724                                 gboolean body)
2725 {
2726         fetch_data *data = g_new0(fetch_data, 1);
2727         int result = 0;
2728         data->done = FALSE;
2729         data->session = session;
2730         data->uid = uid;
2731         data->filename = filename;
2732         data->headers = headers;
2733         data->body = body;
2734
2735         if (prefs_common.work_offline && 
2736             !inc_offline_should_override(
2737                 _("Claws Mail needs network access in order "
2738                   "to access the IMAP server."))) {
2739                 g_free(data);
2740                 return -1;
2741         }
2742         statusbar_print_all(_("Fetching message..."));
2743         result = GPOINTER_TO_INT(imap_cmd_fetch_thread(data));
2744         statusbar_pop_all();
2745         g_free(data);
2746         return result;
2747 }
2748
2749
2750 static gint imap_cmd_append(IMAPSession *session, const gchar *destfolder,
2751                             const gchar *file, IMAPFlags flags, 
2752                             guint32 *new_uid)
2753 {
2754         struct mailimap_flag_list * flag_list;
2755         int r;
2756         
2757         g_return_val_if_fail(file != NULL, IMAP_ERROR);
2758
2759         flag_list = imap_flag_to_lep(flags);
2760         r = imap_threaded_append(session->folder, destfolder,
2761                          file, flag_list, (int *)new_uid);
2762         mailimap_flag_list_free(flag_list);
2763
2764         if (r != MAILIMAP_NO_ERROR) {
2765                 debug_print("append err %d\n", r);
2766                 return IMAP_ERROR;
2767         }
2768         return IMAP_SUCCESS;
2769 }
2770
2771 static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
2772                           const gchar *destfolder, GRelation *uid_mapping,
2773                           struct mailimap_set **source, struct mailimap_set **dest)
2774 {
2775         int r;
2776         
2777         g_return_val_if_fail(session != NULL, IMAP_ERROR);
2778         g_return_val_if_fail(set != NULL, IMAP_ERROR);
2779         g_return_val_if_fail(destfolder != NULL, IMAP_ERROR);
2780
2781         r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
2782         if (r != MAILIMAP_NO_ERROR) {
2783                 
2784                 return IMAP_ERROR;
2785         }
2786
2787         return IMAP_SUCCESS;
2788 }
2789
2790 static gint imap_cmd_store(IMAPSession *session, struct mailimap_set * set,
2791                            IMAPFlags flags, int do_add)
2792 {
2793         int r;
2794         struct mailimap_flag_list * flag_list;
2795         struct mailimap_store_att_flags * store_att_flags;
2796         
2797         flag_list = imap_flag_to_lep(flags);
2798         
2799         if (do_add)
2800                 store_att_flags =
2801                         mailimap_store_att_flags_new_add_flags_silent(flag_list);
2802         else
2803                 store_att_flags =
2804                         mailimap_store_att_flags_new_remove_flags_silent(flag_list);
2805         
2806         r = imap_threaded_store(session->folder, set, store_att_flags);
2807         mailimap_store_att_flags_free(store_att_flags);
2808         if (r != MAILIMAP_NO_ERROR) {
2809                 
2810                 return IMAP_ERROR;
2811         }
2812         
2813         return IMAP_SUCCESS;
2814 }
2815
2816 static gint imap_cmd_expunge(IMAPSession *session)
2817 {
2818         int r;
2819         
2820         if (prefs_common.work_offline && 
2821             !inc_offline_should_override(
2822                 _("Claws Mail needs network access in order "
2823                   "to access the IMAP server."))) {
2824                 return -1;
2825         }
2826
2827         r = imap_threaded_expunge(session->folder);
2828         if (r != MAILIMAP_NO_ERROR) {
2829                 
2830                 return IMAP_ERROR;
2831         }
2832
2833         return IMAP_SUCCESS;
2834 }
2835
2836 static void imap_path_separator_subst(gchar *str, gchar separator)
2837 {
2838         gchar *p;
2839         gboolean in_escape = FALSE;
2840
2841         if (!separator || separator == '/') return;
2842
2843         for (p = str; *p != '\0'; p++) {
2844                 if (*p == '/' && !in_escape)
2845                         *p = separator;
2846                 else if (*p == '&' && *(p + 1) != '-' && !in_escape)
2847                         in_escape = TRUE;
2848                 else if (*p == '-' && in_escape)
2849                         in_escape = FALSE;
2850         }
2851 }
2852
2853 static gchar *imap_modified_utf7_to_utf8(const gchar *mutf7_str)
2854 {
2855         static iconv_t cd = (iconv_t)-1;
2856         static gboolean iconv_ok = TRUE;
2857         GString *norm_utf7;
2858         gchar *norm_utf7_p;
2859         size_t norm_utf7_len;
2860         const gchar *p;
2861         gchar *to_str, *to_p;
2862         size_t to_len;
2863         gboolean in_escape = FALSE;
2864
2865         if (!iconv_ok) return g_strdup(mutf7_str);
2866
2867         if (cd == (iconv_t)-1) {
2868                 cd = iconv_open(CS_INTERNAL, CS_UTF_7);
2869                 if (cd == (iconv_t)-1) {
2870                         g_warning("iconv cannot convert UTF-7 to %s\n",
2871                                   CS_INTERNAL);
2872                         iconv_ok = FALSE;
2873                         return g_strdup(mutf7_str);
2874                 }
2875         }
2876
2877         /* modified UTF-7 to normal UTF-7 conversion */
2878         norm_utf7 = g_string_new(NULL);
2879
2880         for (p = mutf7_str; *p != '\0'; p++) {
2881                 /* replace: '&'  -> '+',
2882                             "&-" -> '&',
2883                             escaped ','  -> '/' */
2884                 if (!in_escape && *p == '&') {
2885                         if (*(p + 1) != '-') {
2886                                 g_string_append_c(norm_utf7, '+');
2887                                 in_escape = TRUE;
2888                         } else {
2889                                 g_string_append_c(norm_utf7, '&');
2890                                 p++;
2891                         }
2892                 } else if (in_escape && *p == ',') {
2893                         g_string_append_c(norm_utf7, '/');
2894                 } else if (in_escape && *p == '-') {
2895                         g_string_append_c(norm_utf7, '-');
2896                         in_escape = FALSE;
2897                 } else {
2898                         g_string_append_c(norm_utf7, *p);
2899                 }
2900         }
2901
2902         norm_utf7_p = norm_utf7->str;
2903         norm_utf7_len = norm_utf7->len;
2904         to_len = strlen(mutf7_str) * 5;
2905         to_p = to_str = g_malloc(to_len + 1);
2906
2907         if (iconv(cd, (ICONV_CONST gchar **)&norm_utf7_p, &norm_utf7_len,
2908                   &to_p, &to_len) == -1) {
2909                 g_warning(_("iconv cannot convert UTF-7 to %s\n"),
2910                           conv_get_locale_charset_str());
2911                 g_string_free(norm_utf7, TRUE);
2912                 g_free(to_str);
2913                 return g_strdup(mutf7_str);
2914         }
2915
2916         /* second iconv() call for flushing */
2917         iconv(cd, NULL, NULL, &to_p, &to_len);
2918         g_string_free(norm_utf7, TRUE);
2919         *to_p = '\0';
2920
2921         return to_str;
2922 }
2923
2924 static gchar *imap_utf8_to_modified_utf7(const gchar *from)
2925 {
2926         static iconv_t cd = (iconv_t)-1;
2927         static gboolean iconv_ok = TRUE;
2928         gchar *norm_utf7, *norm_utf7_p;
2929         size_t from_len, norm_utf7_len;
2930         GString *to_str;
2931         gchar *from_tmp, *to, *p;
2932         gboolean in_escape = FALSE;
2933
2934         if (!iconv_ok) return g_strdup(from);
2935
2936         if (cd == (iconv_t)-1) {
2937                 cd = iconv_open(CS_UTF_7, CS_INTERNAL);
2938                 if (cd == (iconv_t)-1) {
2939                         g_warning(_("iconv cannot convert %s to UTF-7\n"),
2940                                   CS_INTERNAL);
2941                         iconv_ok = FALSE;
2942                         return g_strdup(from);
2943                 }
2944         }
2945
2946         /* UTF-8 to normal UTF-7 conversion */
2947         Xstrdup_a(from_tmp, from, return g_strdup(from));
2948         from_len = strlen(from);
2949         norm_utf7_len = from_len * 5;
2950         Xalloca(norm_utf7, norm_utf7_len + 1, return g_strdup(from));
2951         norm_utf7_p = norm_utf7;
2952
2953 #define IS_PRINT(ch) (isprint(ch) && IS_ASCII(ch))
2954
2955         while (from_len > 0) {
2956                 if (*from_tmp == '+') {
2957                         *norm_utf7_p++ = '+';
2958                         *norm_utf7_p++ = '-';
2959                         norm_utf7_len -= 2;
2960                         from_tmp++;
2961                         from_len--;
2962                 } else if (IS_PRINT(*(guchar *)from_tmp)) {
2963                         /* printable ascii char */
2964                         *norm_utf7_p = *from_tmp;
2965                         norm_utf7_p++;
2966                         norm_utf7_len--;
2967                         from_tmp++;
2968                         from_len--;
2969                 } else {
2970                         size_t conv_len = 0;
2971
2972                         /* unprintable char: convert to UTF-7 */
2973                         p = from_tmp;
2974                         while (!IS_PRINT(*(guchar *)p) && conv_len < from_len) {
2975                                 conv_len += g_utf8_skip[*(guchar *)p];
2976                                 p += g_utf8_skip[*(guchar *)p];
2977                         }
2978
2979                         from_len -= conv_len;
2980                         if (iconv(cd, (ICONV_CONST gchar **)&from_tmp,
2981                                   &conv_len,
2982                                   &norm_utf7_p, &norm_utf7_len) == -1) {
2983                                 g_warning(_("iconv cannot convert UTF-8 to UTF-7\n"));
2984                                 return g_strdup(from);
2985                         }
2986
2987                         /* second iconv() call for flushing */
2988                         iconv(cd, NULL, NULL, &norm_utf7_p, &norm_utf7_len);
2989                 }
2990         }
2991
2992 #undef IS_PRINT
2993
2994         *norm_utf7_p = '\0';
2995         to_str = g_string_new(NULL);
2996         for (p = norm_utf7; p < norm_utf7_p; p++) {
2997                 /* replace: '&' -> "&-",
2998                             '+' -> '&',
2999                             "+-" -> '+',
3000                             BASE64 '/' -> ',' */
3001                 if (!in_escape && *p == '&') {
3002                         g_string_append(to_str, "&-");
3003                 } else if (!in_escape && *p == '+') {
3004                         if (*(p + 1) == '-') {
3005                                 g_string_append_c(to_str, '+');
3006                                 p++;
3007                         } else {
3008                                 g_string_append_c(to_str, '&');
3009                                 in_escape = TRUE;
3010                         }
3011                 } else if (in_escape && *p == '/') {
3012                         g_string_append_c(to_str, ',');
3013                 } else if (in_escape && *p == '-') {
3014                         g_string_append_c(to_str, '-');
3015                         in_escape = FALSE;
3016                 } else {
3017                         g_string_append_c(to_str, *p);
3018                 }
3019         }
3020
3021         if (in_escape) {
3022                 in_escape = FALSE;
3023                 g_string_append_c(to_str, '-');
3024         }
3025
3026         to = to_str->str;
3027         g_string_free(to_str, FALSE);
3028
3029         return to;
3030 }
3031
3032 static gboolean imap_rename_folder_func(GNode *node, gpointer data)
3033 {
3034         FolderItem *item = node->data;
3035         gchar **paths = data;
3036         const gchar *oldpath = paths[0];
3037         const gchar *newpath = paths[1];
3038         gchar *base;
3039         gchar *new_itempath;
3040         gint oldpathlen;
3041
3042         oldpathlen = strlen(oldpath);
3043         if (strncmp(oldpath, item->path, oldpathlen) != 0) {
3044                 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
3045                 return TRUE;
3046         }
3047
3048         base = item->path + oldpathlen;
3049         while (*base == G_DIR_SEPARATOR) base++;
3050         if (*base == '\0')
3051                 new_itempath = g_strdup(newpath);
3052         else
3053                 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
3054                                            NULL);
3055         g_free(item->path);
3056         item->path = new_itempath;
3057
3058         return FALSE;
3059 }
3060
3061 typedef struct _get_list_uid_data {
3062         Folder *folder;
3063         IMAPSession *session;
3064         IMAPFolderItem *item;
3065         GSList **msgnum_list;
3066         gboolean done;
3067 } get_list_uid_data;
3068
3069 static void *get_list_of_uids_thread(void *data)
3070 {
3071         get_list_uid_data *stuff = (get_list_uid_data *)data;
3072         Folder *folder = stuff->folder;
3073         IMAPFolderItem *item = stuff->item;
3074         GSList **msgnum_list = stuff->msgnum_list;
3075         gint ok, nummsgs = 0, lastuid_old;
3076         IMAPSession *session;
3077         GSList *uidlist, *elem;
3078         clist * lep_uidlist;
3079         int r;
3080
3081         session = stuff->session;
3082         if (session == NULL) {
3083                 stuff->done = TRUE;
3084                 return GINT_TO_POINTER(-1);
3085         }
3086         /* no session locking here, it's already locked by caller */
3087         ok = imap_select(session, IMAP_FOLDER(folder), item->item.path,
3088                          NULL, NULL, NULL, NULL, TRUE);
3089         if (ok != IMAP_SUCCESS) {
3090                 stuff->done = TRUE;
3091                 return GINT_TO_POINTER(-1);
3092         }
3093
3094         uidlist = NULL;
3095         
3096         r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE, NULL,
3097                                  &lep_uidlist);
3098         
3099         if (r == MAILIMAP_NO_ERROR) {
3100                 GSList * fetchuid_list;
3101                 
3102                 fetchuid_list =
3103                         imap_uid_list_from_lep(lep_uidlist);
3104                 mailimap_search_result_free(lep_uidlist);
3105                 
3106                 uidlist = g_slist_concat(fetchuid_list, uidlist);
3107         }
3108         else {
3109                 GSList * fetchuid_list;
3110                 carray * lep_uidtab;
3111                 
3112                 r = imap_threaded_fetch_uid(folder, item->lastuid + 1,
3113                                             &lep_uidtab);
3114                 if (r == MAILIMAP_NO_ERROR) {
3115                         fetchuid_list =
3116                                 imap_uid_list_from_lep_tab(lep_uidtab);
3117                         imap_fetch_uid_list_free(lep_uidtab);
3118                         uidlist = g_slist_concat(fetchuid_list, uidlist);
3119                 }
3120         }
3121         
3122         lastuid_old = item->lastuid;
3123         *msgnum_list = g_slist_copy(item->uid_list);
3124         nummsgs = g_slist_length(*msgnum_list);
3125         debug_print("Got %d uids from cache\n", g_slist_length(item->uid_list));
3126
3127         for (elem = uidlist; elem != NULL; elem = g_slist_next(elem)) {
3128                 guint msgnum;
3129
3130                 msgnum = GPOINTER_TO_INT(elem->data);
3131                 if (msgnum > lastuid_old) {
3132                         *msgnum_list = g_slist_prepend(*msgnum_list, GINT_TO_POINTER(msgnum));
3133                         item->uid_list = g_slist_prepend(item->uid_list, GINT_TO_POINTER(msgnum));
3134                         nummsgs++;
3135
3136                         if(msgnum > item->lastuid)
3137                                 item->lastuid = msgnum;
3138                 }
3139         }
3140         g_slist_free(uidlist);
3141         stuff->done = TRUE;
3142         return GINT_TO_POINTER(nummsgs);
3143 }
3144
3145 static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
3146 {
3147         gint result;
3148         get_list_uid_data *data = g_new0(get_list_uid_data, 1);
3149         data->done = FALSE;
3150         data->folder = folder;
3151         data->item = item;
3152         data->msgnum_list = msgnum_list;
3153         data->session = session;
3154         if (prefs_common.work_offline && 
3155             !inc_offline_should_override(
3156                 _("Claws Mail needs network access in order "
3157                   "to access the IMAP server."))) {
3158                 g_free(data);
3159                 return -1;
3160         }
3161
3162         result = GPOINTER_TO_INT(get_list_of_uids_thread(data));
3163         g_free(data);
3164         return result;
3165
3166 }
3167
3168 gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
3169 {
3170         IMAPFolderItem *item = (IMAPFolderItem *)_item;
3171         IMAPSession *session;
3172         gint ok, nummsgs = 0, exists;
3173         guint32 uid_next = 0, uid_val = 0;
3174         GSList *uidlist = NULL;
3175         gchar *dir;
3176         gboolean selected_folder;
3177         debug_print("get_num_list\n");
3178         
3179         g_return_val_if_fail(folder != NULL, -1);
3180         g_return_val_if_fail(item != NULL, -1);
3181         g_return_val_if_fail(item->item.path != NULL, -1);
3182         g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
3183         g_return_val_if_fail(folder->account != NULL, -1);
3184
3185         debug_print("getting session...\n");
3186         session = imap_session_get(folder);
3187         g_return_val_if_fail(session != NULL, -1);
3188
3189         if (FOLDER_ITEM(item)->path) 
3190                 statusbar_print_all(_("Scanning folder %s%c%s ..."),
3191                                       FOLDER_ITEM(item)->folder->name, 
3192                                       G_DIR_SEPARATOR,
3193                                       FOLDER_ITEM(item)->path);
3194         else
3195                 statusbar_print_all(_("Scanning folder %s ..."),
3196                                       FOLDER_ITEM(item)->folder->name);
3197
3198         selected_folder = (session->mbox != NULL) &&
3199                           (!strcmp(session->mbox, item->item.path));
3200         if (selected_folder && time(NULL) - item->use_cache < 2) {
3201                 ok = imap_cmd_noop(session);
3202                 if (ok != IMAP_SUCCESS) {
3203                         debug_print("disconnected!\n");
3204                         session = imap_reconnect_if_possible(folder, session);
3205                         if (session == NULL) {
3206                                 statusbar_pop_all();
3207                                 unlock_session();
3208                                 return -1;
3209                         }
3210                 }
3211                 exists = session->exists;
3212
3213                 uid_next = item->c_uid_next;
3214                 uid_val = item->c_uid_validity;
3215                 *old_uids_valid = TRUE;
3216         } else {
3217                 if (item->use_cache && time(NULL) - item->use_cache < 2) {
3218                         exists = item->c_messages;
3219                         uid_next = item->c_uid_next;
3220                         uid_val = item->c_uid_validity;
3221                         ok = IMAP_SUCCESS;
3222                         debug_print("using cache %d %d %d\n", exists, uid_next, uid_val);
3223                 } else {
3224                         ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, item,
3225                                  &exists, &uid_next, &uid_val, NULL, FALSE);
3226                 }
3227                 item->item.last_num = uid_next - 1;
3228                 
3229                 item->use_cache = (time_t)0;
3230                 if (ok != IMAP_SUCCESS) {
3231                         statusbar_pop_all();
3232                         unlock_session();
3233                         return -1;
3234                 }
3235                 if(item->item.mtime == uid_val)
3236                         *old_uids_valid = TRUE;
3237                 else {
3238                         *old_uids_valid = FALSE;
3239
3240                         debug_print("Freeing imap uid cache (%d != %d)\n",
3241                                         (int)item->item.mtime, uid_val);
3242                         item->lastuid = 0;
3243                         g_slist_free(item->uid_list);
3244                         item->uid_list = NULL;
3245                 
3246                         item->item.mtime = uid_val;
3247
3248                         imap_delete_all_cached_messages((FolderItem *)item);
3249                 }
3250         }
3251
3252         /* If old uid_next matches new uid_next we can be sure no message
3253            was added to the folder */
3254         debug_print("uid_next is %d and item->uid_next %d \n", 
3255                 uid_next, item->uid_next);
3256         if (uid_next == item->uid_next) {
3257                 nummsgs = g_slist_length(item->uid_list);
3258
3259                 /* If number of messages is still the same we
3260                    know our caches message numbers are still valid,
3261                    otherwise if the number of messages has decrease
3262                    we discard our cache to start a new scan to find
3263                    out which numbers have been removed */
3264                 if (exists == nummsgs) {
3265                         debug_print("exists == nummsgs\n");
3266                         *msgnum_list = g_slist_copy(item->uid_list);
3267                         statusbar_pop_all();
3268                         unlock_session();
3269                         return nummsgs;
3270                 } else if (exists < nummsgs) {
3271                         debug_print("Freeing imap uid cache");
3272                         item->lastuid = 0;
3273                         g_slist_free(item->uid_list);
3274                         item->uid_list = NULL;
3275                 }
3276         }
3277
3278         if (exists == 0) {
3279                 *msgnum_list = NULL;
3280                 statusbar_pop_all();
3281                 unlock_session();
3282                 return 0;
3283         }
3284
3285         nummsgs = get_list_of_uids(session, folder, item, &uidlist);
3286
3287         if (nummsgs < 0) {
3288                 statusbar_pop_all();
3289                 unlock_session();
3290                 return -1;
3291         }
3292
3293         if (nummsgs != exists) {
3294                 /* Cache contains more messages then folder, we have cached
3295                    an old UID of a message that was removed and new messages
3296                    have been added too, otherwise the uid_next check would
3297                    not have failed */
3298                 debug_print("Freeing imap uid cache");
3299                 item->lastuid = 0;
3300                 g_slist_free(item->uid_list);
3301                 item->uid_list = NULL;
3302
3303                 g_slist_free(*msgnum_list);
3304
3305                 nummsgs = get_list_of_uids(session, folder, item, &uidlist);
3306         }
3307
3308         *msgnum_list = uidlist;
3309
3310         dir = folder_item_get_path((FolderItem *)item);
3311         debug_print("removing old messages from %s\n", dir);
3312         remove_numbered_files_not_in_list(dir, *msgnum_list);
3313         g_free(dir);
3314         
3315         item->uid_next = uid_next;
3316         
3317         debug_print("get_num_list - ok - %i\n", nummsgs);
3318         statusbar_pop_all();
3319         unlock_session();
3320         return nummsgs;
3321 }
3322
3323 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item)
3324 {
3325         MsgInfo *msginfo;
3326         MsgFlags flags;
3327
3328         flags.perm_flags = MSG_NEW|MSG_UNREAD;
3329         flags.tmp_flags = 0;
3330
3331         g_return_val_if_fail(item != NULL, NULL);
3332         g_return_val_if_fail(file != NULL, NULL);
3333
3334         if (folder_has_parent_of_type(item, F_QUEUE)) {
3335                 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
3336         } else if (folder_has_parent_of_type(item, F_DRAFT)) {
3337                 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
3338         }
3339
3340         msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
3341         if (!msginfo) return NULL;
3342         
3343         msginfo->plaintext_file = g_strdup(file);
3344         msginfo->folder = item;
3345
3346         return msginfo;
3347 }
3348
3349 GSList *imap_get_msginfos(Folder *folder, FolderItem *item,
3350                           GSList *msgnum_list)
3351 {
3352         IMAPSession *session;
3353         MsgInfoList *ret = NULL;
3354         gint ok;
3355         
3356         debug_print("get_msginfos\n");
3357         
3358         g_return_val_if_fail(folder != NULL, NULL);
3359         g_return_val_if_fail(item != NULL, NULL);
3360         g_return_val_if_fail(msgnum_list != NULL, NULL);
3361
3362         debug_print("getting session...\n");
3363         session = imap_session_get(folder);
3364         g_return_val_if_fail(session != NULL, NULL);
3365
3366         debug_print("IMAP getting msginfos\n");
3367         ok = imap_select(session, IMAP_FOLDER(folder), item->path,
3368                          NULL, NULL, NULL, NULL, FALSE);
3369         if (ok != IMAP_SUCCESS) {
3370                 unlock_session();
3371                 return NULL;
3372         }
3373         if (!(folder_has_parent_of_type(item, F_DRAFT) || 
3374               folder_has_parent_of_type(item, F_QUEUE))) {
3375                 ret = g_slist_concat(ret,
3376                         imap_get_uncached_messages(session, item,
3377                                                    msgnum_list));
3378         } else {
3379                 MsgNumberList *sorted_list, *elem, *llast = NULL;
3380                 gint startnum, lastnum;
3381
3382                 sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
3383
3384                 startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
3385
3386                 llast = g_slist_last(ret);
3387                 for (elem = sorted_list;; elem = g_slist_next(elem)) {
3388                         guint num = 0;
3389
3390                         if (elem)
3391                                 num = GPOINTER_TO_INT(elem->data);
3392
3393                         if (num > lastnum + 1 || elem == NULL) {
3394                                 int i;
3395                                 for (i = startnum; i <= lastnum; ++i) {
3396                                         gchar *file;
3397                         
3398                                         file = imap_fetch_msg(folder, item, i);
3399                                         if (file != NULL) {
3400                                                 MsgInfo *msginfo = imap_parse_msg(file, item);
3401                                                 if (msginfo != NULL) {
3402                                                         msginfo->msgnum = i;
3403                                                         if (llast == NULL)
3404                                                                 llast = ret = g_slist_append(ret, msginfo);
3405                                                         else {
3406                                                                 llast = g_slist_append(llast, msginfo);