src/imap.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2016 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 3 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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include "config.h"
  21 #include "claws-features.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 #include "alertpanel.h"
  35
  36 #ifdef HAVE_LIBETPAN
  37
  38 #include <stdlib.h>
  39 #include <dirent.h>
  40 #include <unistd.h>
  41 #include <ctype.h>
  42 #include <time.h>
  43 #include <errno.h>
  44 #if HAVE_ICONV
  45 #  include <iconv.h>
  46 #endif
  47
  48 #ifdef USE_GNUTLS
  49 #  include "ssl.h"
  50 #endif
  51
  52 #include "folder.h"
  53 #include "session.h"
  54 #include "procmsg.h"
  55 #include "socket.h"
  56 #include "recv.h"
  57 #include "procheader.h"
  58 #include "prefs_account.h"
  59 #include "codeconv.h"
  60 #include "md5.h"
  61 #include "utils.h"
  62 #include "prefs_common.h"
  63 #include "inputdialog.h"
  64 #include "log.h"
  65 #include "remotefolder.h"
  66 #include "claws.h"
  67 #include "statusbar.h"
  68 #include "msgcache.h"
  69 #include "imap-thread.h"
  70 #include "account.h"
  71 #include "tags.h"
  72 #include "main.h"
  73 #include "passwordstore.h"
  74 #include "file-utils.h"
  75
  76 typedef struct _IMAPFolder      IMAPFolder;
  77 typedef struct _IMAPSession     IMAPSession;
  78 typedef struct _IMAPNameSpace   IMAPNameSpace;
  79 typedef struct _IMAPFolderItem  IMAPFolderItem;
  80
  81 #define IMAP_FOLDER(obj)        ((IMAPFolder *)obj)
  82 #define IMAP_FOLDER_ITEM(obj)   ((IMAPFolderItem *)obj)
  83 #define IMAP_SESSION(obj)       ((IMAPSession *)obj)
  84
  85 struct _IMAPFolder
  86 {
  87         RemoteFolder rfolder;
  88
  89         /* list of IMAPNameSpace */
  90         GList *ns_personal;
  91         GList *ns_others;
  92         GList *ns_shared;
  93         gchar last_seen_separator;
  94         guint refcnt;
  95         guint max_set_size;
  96         gchar *search_charset;
  97         gboolean search_charset_supported;
  98 };
  99
 100 struct _IMAPSession
 101 {
 102         Session session;
 103
 104         gboolean authenticated;
 105
 106         GSList *capability;
 107         gboolean uidplus;
 108
 109         gchar *mbox;
 110         guint cmd_count;
 111
 112         /* CLAWS */
 113         gboolean folder_content_changed;
 114         guint exists;
 115         guint recent;
 116         guint expunge;
 117         guint unseen;
 118         guint uid_validity;
 119         guint uid_next;
 120
 121         Folder * folder;
 122         gboolean busy;
 123         gboolean cancelled;
 124         gboolean sens_update_block;
 125         gboolean do_destroy;
 126 };
 127
 128 struct _IMAPNameSpace
 129 {
 130         gchar *name;
 131         gchar separator;
 132 };
 133
 134 #define IMAPBUFSIZE     8192
 135
 136 #define IMAP_IS_SEEN(flags)     ((flags & IMAP_FLAG_SEEN) != 0)
 137 #define IMAP_IS_ANSWERED(flags) ((flags & IMAP_FLAG_ANSWERED) != 0)
 138 #define IMAP_IS_FLAGGED(flags)  ((flags & IMAP_FLAG_FLAGGED) != 0)
 139 #define IMAP_IS_DELETED(flags)  ((flags & IMAP_FLAG_DELETED) != 0)
 140 #define IMAP_IS_DRAFT(flags)    ((flags & IMAP_FLAG_DRAFT) != 0)
 141 #define IMAP_IS_FORWARDED(flags)        ((flags & IMAP_FLAG_FORWARDED) != 0)
 142 #define IMAP_IS_SPAM(flags)     ((flags & IMAP_FLAG_SPAM) != 0)
 143 #define IMAP_IS_HAM(flags)      ((flags & IMAP_FLAG_HAM) != 0)
 144
 145
 146 #define IMAP4_PORT      143
 147 #ifdef USE_GNUTLS
 148 #define IMAPS_PORT      993
 149 #endif
 150
 151 #define IMAP_CMD_LIMIT  1000
 152
 153 enum {
 154         ITEM_CAN_CREATE_FLAGS_UNKNOWN = 0,
 155         ITEM_CAN_CREATE_FLAGS,
 156         ITEM_CANNOT_CREATE_FLAGS
 157 };
 158
 159 struct _IMAPFolderItem
 160 {
 161         FolderItem item;
 162
 163         guint lastuid;
 164         guint uid_next;
 165         GSList *uid_list;
 166         gboolean batching;
 167
 168         GHashTable *flags_set_table;
 169         GHashTable *flags_unset_table;
 170         guint32 last_change;
 171         guint32 last_sync;
 172         gboolean should_update;
 173         gboolean should_trash_cache;
 174         gint can_create_flags;
 175
 176         GHashTable *tags_set_table;
 177         GHashTable *tags_unset_table;
 178         GSList *ok_flags;
 179
 180 };
 181
 182 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
 183 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
 184
 185 static void imap_folder_init            (Folder         *folder,
 186                                          const gchar    *name,
 187                                          const gchar    *path);
 188
 189 static Folder   *imap_folder_new        (const gchar    *name,
 190                                          const gchar    *path);
 191 static void      imap_folder_destroy    (Folder         *folder);
 192
 193 static IMAPSession *imap_session_new    (Folder         *folder,
 194                                          const PrefsAccount     *account);
 195 static gint     imap_session_authenticate(IMAPSession   *session,
 196                                           PrefsAccount  *account);
 197 static void     imap_session_destroy    (Session        *session);
 198
 199 static gchar   *imap_fetch_msg          (Folder         *folder,
 200                                          FolderItem     *item,
 201                                          gint            uid);
 202 static gchar   *imap_fetch_msg_full     (Folder         *folder,
 203                                          FolderItem     *item,
 204                                          gint            uid,
 205                                          gboolean        headers,
 206                                          gboolean        body);
 207 static void     imap_remove_cached_msg  (Folder         *folder,
 208                                          FolderItem     *item,
 209                                          MsgInfo        *msginfo);
 210 static gint     imap_add_msg            (Folder         *folder,
 211                                          FolderItem     *dest,
 212                                          const gchar    *file,
 213                                          MsgFlags       *flags);
 214 static gint     imap_add_msgs           (Folder         *folder,
 215                                          FolderItem     *dest,
 216                                          GSList         *file_list,
 217                                          GHashTable     *relation);
 218
 219 static gint     imap_copy_msg           (Folder         *folder,
 220                                          FolderItem     *dest,
 221                                          MsgInfo        *msginfo);
 222 static gint     imap_copy_msgs          (Folder         *folder,
 223                                          FolderItem     *dest,
 224                                          MsgInfoList    *msglist,
 225                                          GHashTable     *relation);
 226
 227 static gint     search_msgs             (Folder                 *folder,
 228                                          FolderItem             *container,
 229                                          MsgNumberList          **msgs,
 230                                          gboolean               *on_server,
 231                                          MatcherList            *predicate,
 232                                          SearchProgressNotify   progress_cb,
 233                                          gpointer               progress_data);
 234
 235 static gint     imap_remove_msg         (Folder         *folder,
 236                                          FolderItem     *item,
 237                                          gint            uid);
 238 static gint     imap_remove_msgs        (Folder         *folder,
 239                                          FolderItem     *dest,
 240                                          MsgInfoList    *msglist,
 241                                          GHashTable     *relation);
 242 static gint     imap_expunge            (Folder         *folder,
 243                                          FolderItem     *dest);
 244 static gint     imap_remove_all_msg     (Folder         *folder,
 245                                          FolderItem     *item);
 246
 247 static gboolean imap_is_msg_changed     (Folder         *folder,
 248                                          FolderItem     *item,
 249                                          MsgInfo        *msginfo);
 250
 251 static gint     imap_close              (Folder         *folder,
 252                                          FolderItem     *item);
 253
 254 static gint     imap_scan_tree          (Folder         *folder);
 255
 256 static gint     imap_create_tree        (Folder         *folder);
 257
 258 static FolderItem *imap_create_folder   (Folder         *folder,
 259                                          FolderItem     *parent,
 260                                          const gchar    *name);
 261 static gint     imap_rename_folder      (Folder         *folder,
 262                                          FolderItem     *item,
 263                                          const gchar    *name);
 264 static gint     imap_remove_folder      (Folder         *folder,
 265                                          FolderItem     *item);
 266
 267 static FolderItem *imap_folder_item_new (Folder         *folder);
 268 static void imap_folder_item_destroy    (Folder         *folder,
 269                                          FolderItem     *item);
 270
 271 static IMAPSession *imap_session_get    (Folder         *folder);
 272
 273 static gint imap_auth                   (IMAPSession    *session,
 274                                          const gchar    *user,
 275                                          const gchar    *pass,
 276                                          IMAPAuthType    type);
 277
 278 static gint imap_scan_tree_recursive    (IMAPSession    *session,
 279                                          FolderItem     *item,
 280                                          gboolean        subs_only);
 281
 282 static void imap_create_missing_folders (Folder         *folder);
 283 static FolderItem *imap_create_special_folder
 284                                         (Folder                 *folder,
 285                                          SpecialFolderItemType   stype,
 286                                          const gchar            *name);
 287
 288 static gint imap_do_copy_msgs           (Folder         *folder,
 289                                          FolderItem     *dest,
 290                                          MsgInfoList    *msglist,
 291                                          GHashTable     *relation,
 292                                          gboolean        same_dest_ok);
 293
 294 static gint imap_do_remove_msgs         (Folder         *folder,
 295                                          FolderItem     *dest,
 296                                          MsgInfoList    *msglist,
 297                                          GHashTable     *relation);
 298
 299 static void imap_delete_all_cached_messages     (FolderItem     *item);
 300 static void imap_set_batch              (Folder         *folder,
 301                                          FolderItem     *item,
 302                                          gboolean        batch);
 303 static gint imap_set_message_flags      (IMAPSession    *session,
 304                                          IMAPFolderItem *item,
 305                                          MsgNumberList  *numlist,
 306                                          IMAPFlags       flags,
 307                                          GSList         *tags,
 308                                          gboolean        is_set);
 309 static gint imap_select                 (IMAPSession    *session,
 310                                          IMAPFolder     *folder,
 311                                          FolderItem     *item,
 312                                          gint           *exists,
 313                                          gint           *recent,
 314                                          gint           *unseen,
 315                                          guint32        *uid_validity,
 316                                          gint           *can_create_flags,
 317                                          gboolean        block);
 318 static gint imap_status                 (IMAPSession    *session,
 319                                          IMAPFolder     *folder,
 320                                          const gchar    *path,
 321                                          IMAPFolderItem *item,
 322                                          gint           *messages,
 323                                          guint32        *uid_next,
 324                                          guint32        *uid_validity,
 325                                          gint           *unseen,
 326                                          gboolean        block);
 327 static void     imap_commit_tags        (FolderItem     *item,
 328                                          MsgInfo        *msginfo,
 329                                          GSList         *set_tags,
 330                                          GSList         *unset_tags);
 331
 332 static gchar imap_get_path_separator            (IMAPSession    *session,
 333                                                  IMAPFolder     *folder,
 334                                                  const gchar    *path,
 335                                                  gint           *ok);
 336 static gchar *imap_get_real_path                (IMAPSession    *session,
 337                                                  IMAPFolder     *folder,
 338                                                  const gchar    *path,
 339                                                  gint           *ok);
 340 #ifdef HAVE_LIBETPAN
 341 static void imap_synchronise            (FolderItem     *item, gint days);
 342 #endif
 343 static gboolean imap_is_busy            (Folder *folder);
 344
 345 static void imap_free_capabilities      (IMAPSession    *session);
 346
 347 /* low-level IMAP4rev1 commands */
 348 static gint imap_cmd_login      (IMAPSession    *session,
 349                                  const gchar    *user,
 350                                  const gchar    *pass,
 351                                  const gchar    *type);
 352 static gint imap_cmd_noop       (IMAPSession    *session);
 353 #ifdef USE_GNUTLS
 354 static gint imap_cmd_starttls   (IMAPSession    *session);
 355 #endif
 356 static gint imap_cmd_select     (IMAPSession    *session,
 357                                  const gchar    *folder,
 358                                  gint           *exists,
 359                                  gint           *recent,
 360                                  gint           *unseen,
 361                                  guint32        *uid_validity,
 362                                  gint           *can_create_flags,
 363                                  GSList         **ok_flags,
 364                                  gboolean        block);
 365 static gint imap_cmd_close      (IMAPSession    *session);
 366 static gint imap_cmd_examine    (IMAPSession    *session,
 367                                  const gchar    *folder,
 368                                  gint           *exists,
 369                                  gint           *recent,
 370                                  gint           *unseen,
 371                                  guint32        *uid_validity,
 372                                  gboolean        block);
 373 static gint imap_cmd_create     (IMAPSession    *sock,
 374                                  const gchar    *folder);
 375 static gint imap_cmd_rename     (IMAPSession    *sock,
 376                                  const gchar    *oldfolder,
 377                                  const gchar    *newfolder);
 378 static gint imap_cmd_delete     (IMAPSession    *session,
 379                                  const gchar    *folder);
 380 static gint imap_cmd_fetch      (IMAPSession    *sock,
 381                                  guint32         uid,
 382                                  const gchar    *filename,
 383                                  gboolean        headers,
 384                                  gboolean        body);
 385 static gint imap_cmd_append     (IMAPSession    *session,
 386                                  IMAPFolderItem *item,
 387                                  const gchar    *destfolder,
 388                                  const gchar    *file,
 389                                  IMAPFlags       flags,
 390                                  guint32        *new_uid);
 391 static gint imap_cmd_copy       (IMAPSession *session,
 392                                  struct mailimap_set * set,
 393                                  const gchar *destfolder,
 394                                  struct mailimap_set ** source,
 395                                  struct mailimap_set ** dest);
 396 static gint imap_cmd_store      (IMAPSession    *session,
 397                                  IMAPFolderItem *item,
 398                                  struct mailimap_set * set,
 399                                  IMAPFlags flags,
 400                                  GSList *tags,
 401                                  int do_add);
 402 static gint imap_cmd_expunge    (IMAPSession    *session);
 403
 404 static void imap_path_separator_subst           (gchar          *str,
 405                                                  gchar           separator);
 406
 407 static gboolean imap_rename_folder_func         (GNode          *node,
 408                                                  gpointer        data);
 409 static gint imap_get_num_list                   (Folder         *folder,
 410                                                  FolderItem     *item,
 411                                                  GSList        **list,
 412                                                  gboolean       *old_uids_valid);
 413 static GSList *imap_get_msginfos                (Folder         *folder,
 414                                                  FolderItem     *item,
 415                                                  GSList         *msgnum_list);
 416 static MsgInfo *imap_get_msginfo                (Folder         *folder,
 417                                                  FolderItem     *item,
 418                                                  gint            num);
 419 static gboolean imap_scan_required              (Folder         *folder,
 420                                                  FolderItem     *item);
 421 static void imap_change_flags                   (Folder         *folder,
 422                                                  FolderItem     *item,
 423                                                  MsgInfo        *msginfo,
 424                                                  MsgPermFlags    newflags);
 425 static gint imap_get_flags                      (Folder         *folder,
 426                                                  FolderItem     *item,
 427                                                  MsgInfoList    *msglist,
 428                                                  GHashTable     *msgflags);
 429 static gchar *imap_item_get_path                (Folder         *folder,
 430                                                  FolderItem     *item);
 431 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item);
 432
 433
 434 /* data types conversion libetpan <-> claws */
 435 static GSList * imap_list_from_lep(IMAPFolder * folder,
 436                                    clist * list, const gchar * real_path, gboolean all);
 437 static GSList * imap_get_lep_set_from_numlist(IMAPFolder *folder, MsgNumberList *numlist);
 438 static GSList * imap_get_lep_set_from_msglist(IMAPFolder *folder, MsgInfoList *msglist);
 439 static GSList * imap_uid_list_from_lep(clist * list, gint* length);
 440 static GSList * imap_uid_list_from_lep_tab(carray * list);
 441 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
 442                                                    GHashTable * hash,
 443                                                    GHashTable *tags_hash);
 444 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
 445                                        FolderItem *item);
 446 static void imap_lep_set_free(GSList *seq_list);
 447 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFolderItem *item, IMAPFlags flags, GSList *tags);
 448
 449 typedef struct _hashtable_data {
 450         GSList *msglist;
 451         IMAPFolderItem *item;
 452 } hashtable_data;
 453
 454 static FolderClass imap_class;
 455
 456 FolderClass *imap_get_class(void)
 457 {
 458         if (imap_class.idstr == NULL) {
 459                 imap_class.type = F_IMAP;
 460                 imap_class.idstr = "imap";
 461                 imap_class.uistr = "IMAP";
 462                 imap_class.supports_server_search = TRUE;
 463
 464                 /* Folder functions */
 465                 imap_class.new_folder = imap_folder_new;
 466                 imap_class.destroy_folder = imap_folder_destroy;
 467                 imap_class.scan_tree = imap_scan_tree;
 468                 imap_class.create_tree = imap_create_tree;
 469
 470                 /* FolderItem functions */
 471                 imap_class.item_new = imap_folder_item_new;
 472                 imap_class.item_destroy = imap_folder_item_destroy;
 473                 imap_class.item_get_path = imap_item_get_path;
 474                 imap_class.create_folder = imap_create_folder;
 475                 imap_class.rename_folder = imap_rename_folder;
 476                 imap_class.remove_folder = imap_remove_folder;
 477                 imap_class.close = imap_close;
 478                 imap_class.get_num_list = imap_get_num_list;
 479                 imap_class.scan_required = imap_scan_required;
 480                 imap_class.set_xml = folder_set_xml;
 481                 imap_class.get_xml = folder_get_xml;
 482                 imap_class.item_set_xml = imap_item_set_xml;
 483                 imap_class.item_get_xml = imap_item_get_xml;
 484
 485                 /* Message functions */
 486                 imap_class.get_msginfo = imap_get_msginfo;
 487                 imap_class.get_msginfos = imap_get_msginfos;
 488                 imap_class.fetch_msg = imap_fetch_msg;
 489                 imap_class.fetch_msg_full = imap_fetch_msg_full;
 490                 imap_class.add_msg = imap_add_msg;
 491                 imap_class.add_msgs = imap_add_msgs;
 492                 imap_class.copy_msg = imap_copy_msg;
 493                 imap_class.copy_msgs = imap_copy_msgs;
 494                 imap_class.search_msgs = search_msgs;
 495                 imap_class.remove_msg = imap_remove_msg;
 496                 imap_class.remove_msgs = imap_remove_msgs;
 497                 imap_class.expunge = imap_expunge;
 498                 imap_class.remove_all_msg = imap_remove_all_msg;
 499                 imap_class.is_msg_changed = imap_is_msg_changed;
 500                 imap_class.change_flags = imap_change_flags;
 501                 imap_class.get_flags = imap_get_flags;
 502                 imap_class.set_batch = imap_set_batch;
 503                 imap_class.synchronise = imap_synchronise;
 504                 imap_class.remove_cached_msg = imap_remove_cached_msg;
 505                 imap_class.commit_tags = imap_commit_tags;
 506         }
 507
 508         return &imap_class;
 509 }
 510
 511 static void imap_refresh_sensitivity (IMAPSession *session)
 512 {
 513         MainWindow *mainwin;
 514
 515         if (session->sens_update_block)
 516                 return;
 517         mainwin = mainwindow_get_mainwindow();
 518         if (mainwin) {
 519                 toolbar_main_set_sensitive(mainwin);
 520                 main_window_set_menu_sensitive(mainwin);
 521         }
 522 }
 523
 524 static void lock_session(IMAPSession *session)
 525 {
 526         if (session) {
 527                 debug_print("locking session %p (%d)\n", session, session->busy);
 528                 if (session->busy)
 529                         debug_print("         SESSION WAS LOCKED !!      \n");
 530                 session->busy = TRUE;
 531                 imap_refresh_sensitivity(session);
 532         } else {
 533                 debug_print("can't lock null session\n");
 534         }
 535 }
 536
 537 static void unlock_session(IMAPSession *session)
 538 {
 539         if (session) {
 540                 debug_print("unlocking session %p\n", session);
 541                 session->busy = FALSE;
 542                 imap_refresh_sensitivity(session);
 543         } else {
 544                 debug_print("can't unlock null session\n");
 545         }
 546 }
 547
 548 static gboolean imap_ping(gpointer data)
 549 {
 550         Session *session = (Session *)data;
 551         IMAPSession *imap_session = IMAP_SESSION(session);
 552         int r;
 553
 554         if (session->state != SESSION_READY)
 555                 return FALSE;
 556         if (imap_session->busy || !imap_session->authenticated)
 557                 return TRUE;
 558
 559         lock_session(imap_session);
 560         r = imap_cmd_noop(imap_session);
 561         unlock_session(imap_session);
 562
 563         return r == MAILIMAP_NO_ERROR;
 564 }
 565
 566 static void imap_disc_session_destroy(IMAPSession *session)
 567 {
 568         RemoteFolder *rfolder = NULL;
 569
 570         if (session == NULL)
 571                 return;
 572
 573         rfolder = REMOTE_FOLDER(IMAP_SESSION(session)->folder);
 574
 575         if (rfolder == NULL)
 576                 return;
 577         log_warning(LOG_PROTOCOL, _("IMAP connection broken\n"));
 578         SESSION(session)->state = SESSION_DISCONNECTED;
 579         SESSION(session)->sock = NULL;
 580 }
 581
 582 static void imap_safe_destroy(IMAPSession *session)
 583 {
 584         if (!session->busy)
 585                 session_destroy(SESSION(session));
 586         else
 587                 session->do_destroy = TRUE;
 588 }
 589
 590 static gboolean is_fatal(int libetpan_errcode)
 591 {
 592         switch(libetpan_errcode) {
 593         case MAILIMAP_ERROR_STREAM:
 594         case MAILIMAP_ERROR_PROTOCOL:
 595         case MAILIMAP_ERROR_PARSE:
 596         case MAILIMAP_ERROR_BAD_STATE:
 597                 return TRUE;
 598         default:
 599                 return FALSE;
 600         }
 601 }
 602
 603 static void imap_handle_error(Session *session, const gchar *server, int libetpan_errcode)
 604 {
 605         const gchar *session_server = (session ? session->server : NULL);
 606
 607         if (session_server == NULL)
 608                 session_server = server;
 609         if (session_server == NULL)
 610                 session_server = "(null)";
 611
 612         switch(libetpan_errcode) {
 613         case MAILIMAP_NO_ERROR:
 614                 return;
 615         case MAILIMAP_NO_ERROR_AUTHENTICATED:
 616                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("authenticated"), "\n", NULL), session_server);
 617                 break;
 618         case MAILIMAP_NO_ERROR_NON_AUTHENTICATED:
 619                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("not authenticated"), "\n", NULL), session_server);
 620                 break;
 621         case MAILIMAP_ERROR_BAD_STATE:
 622                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("bad state"), "\n", NULL), session_server);
 623                 break;
 624         case MAILIMAP_ERROR_STREAM:
 625                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("stream error"), "\n", NULL), session_server);
 626                 break;
 627         case MAILIMAP_ERROR_PARSE:
 628                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("parse error "
 629                                             "(very probably non-RFC compliance from the server)"), "\n", NULL), session_server);
 630                 break;
 631         case MAILIMAP_ERROR_CONNECTION_REFUSED:
 632                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("connection refused"), "\n", NULL), session_server);
 633                 break;
 634         case MAILIMAP_ERROR_MEMORY:
 635                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("memory error"), "\n", NULL), session_server);
 636                 break;
 637         case MAILIMAP_ERROR_FATAL:
 638                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("fatal error"), "\n", NULL), session_server);
 639                 break;
 640         case MAILIMAP_ERROR_PROTOCOL:
 641                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("protocol error "
 642                                             "(very probably non-RFC compliance from the server)"), "\n", NULL), session_server);
 643                 break;
 644         case MAILIMAP_ERROR_DONT_ACCEPT_CONNECTION:
 645                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("connection not accepted"), "\n", NULL), session_server);
 646                 break;
 647         case MAILIMAP_ERROR_APPEND:
 648                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("APPEND error"), "\n", NULL), session_server);
 649                 break;
 650         case MAILIMAP_ERROR_NOOP:
 651                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("NOOP error"), "\n", NULL), session_server);
 652                 break;
 653         case MAILIMAP_ERROR_LOGOUT:
 654                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("LOGOUT error"), "\n", NULL), session_server);
 655                 break;
 656         case MAILIMAP_ERROR_CAPABILITY:
 657                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("CAPABILITY error"), "\n", NULL), session_server);
 658                 break;
 659         case MAILIMAP_ERROR_CHECK:
 660                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("CHECK error"), "\n", NULL), session_server);
 661                 break;
 662         case MAILIMAP_ERROR_CLOSE:
 663                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("CLOSE error"), "\n", NULL), session_server);
 664                 break;
 665         case MAILIMAP_ERROR_EXPUNGE:
 666                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("EXPUNGE error"), "\n", NULL), session_server);
 667                 break;
 668         case MAILIMAP_ERROR_COPY:
 669                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("COPY error"), "\n", NULL), session_server);
 670                 break;
 671         case MAILIMAP_ERROR_UID_COPY:
 672                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("UID COPY error"), "\n", NULL), session_server);
 673                 break;
 674         case MAILIMAP_ERROR_CREATE:
 675                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("CREATE error"), "\n", NULL), session_server);
 676                 break;
 677         case MAILIMAP_ERROR_DELETE:
 678                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("DELETE error"), "\n", NULL), session_server);
 679                 break;
 680         case MAILIMAP_ERROR_EXAMINE:
 681                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("EXAMINE error"), "\n", NULL), session_server);
 682                 break;
 683         case MAILIMAP_ERROR_FETCH:
 684                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("FETCH error"), "\n", NULL), session_server);
 685                 break;
 686         case MAILIMAP_ERROR_UID_FETCH:
 687                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("UID FETCH error"), "\n", NULL), session_server);
 688                 break;
 689         case MAILIMAP_ERROR_LIST:
 690                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("LIST error"), "\n", NULL), session_server);
 691                 break;
 692         case MAILIMAP_ERROR_LOGIN:
 693                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("LOGIN error"), "\n", NULL), session_server);
 694                 break;
 695         case MAILIMAP_ERROR_LSUB:
 696                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("LSUB error"), "\n", NULL), session_server);
 697                 break;
 698         case MAILIMAP_ERROR_RENAME:
 699                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("RENAME error"), "\n", NULL), session_server);
 700                 break;
 701         case MAILIMAP_ERROR_SEARCH:
 702                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("SEARCH error"), "\n", NULL), session_server);
 703                 break;
 704         case MAILIMAP_ERROR_UID_SEARCH:
 705                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("UID SEARCH error"), "\n", NULL), session_server);
 706                 break;
 707         case MAILIMAP_ERROR_SELECT:
 708                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("SELECT error"), "\n", NULL), session_server);
 709                 break;
 710         case MAILIMAP_ERROR_STATUS:
 711                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("STATUS error"), "\n", NULL), session_server);
 712                 break;
 713         case MAILIMAP_ERROR_STORE:
 714                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("STORE error"), "\n", NULL), session_server);
 715                 break;
 716         case MAILIMAP_ERROR_UID_STORE:
 717                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("UID STORE error"), "\n", NULL), session_server);
 718                 break;
 719         case MAILIMAP_ERROR_SUBSCRIBE:
 720                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("SUBSCRIBE error"), "\n", NULL), session_server);
 721                 break;
 722         case MAILIMAP_ERROR_UNSUBSCRIBE:
 723                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("UNSUBSCRIBE error"), "\n", NULL), session_server);
 724                 break;
 725         case MAILIMAP_ERROR_STARTTLS:
 726                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("STARTTLS error"), "\n", NULL), session_server);
 727                 break;
 728         case MAILIMAP_ERROR_INVAL:
 729                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("INVAL error"), "\n", NULL), session_server);
 730                 break;
 731         case MAILIMAP_ERROR_EXTENSION:
 732                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("EXTENSION error"), "\n", NULL), session_server);
 733                 break;
 734         case MAILIMAP_ERROR_SASL:
 735                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("SASL error"), "\n", NULL), session_server);
 736                 break;
 737 #ifdef USE_GNUTLS
 738         case MAILIMAP_ERROR_SSL:
 739                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("SSL/TLS error"), "\n", NULL), session_server);
 740                 break;
 741 #endif
 742         default:
 743                 log_warning(LOG_PROTOCOL, g_strconcat(_("IMAP error on %s:"), " ", _("Unknown error [%d]"), "\n", NULL),
 744                         session_server, libetpan_errcode);
 745                 break;
 746         }
 747
 748         if (session && is_fatal(libetpan_errcode)) {
 749                 imap_disc_session_destroy(IMAP_SESSION(session));
 750         } else if (session && !is_fatal(libetpan_errcode)) {
 751                 if (IMAP_SESSION(session)->busy)
 752                         unlock_session(IMAP_SESSION(session));
 753         }
 754 }
 755
 756 static Folder *imap_folder_new(const gchar *name, const gchar *path)
 757 {
 758         Folder *folder;
 759
 760         folder = (Folder *)g_new0(IMAPFolder, 1);
 761         folder->klass = &imap_class;
 762         imap_folder_init(folder, name, path);
 763
 764         return folder;
 765 }
 766
 767 static void imap_folder_destroy(Folder *folder)
 768 {
 769         while (imap_folder_get_refcnt(folder) > 0)
 770                 gtk_main_iteration();
 771
 772         g_free(IMAP_FOLDER(folder)->search_charset);
 773
 774         folder_remote_folder_destroy(REMOTE_FOLDER(folder));
 775         imap_done(folder);
 776 }
 777
 778 static void imap_folder_init(Folder *folder, const gchar *name,
 779                              const gchar *path)
 780 {
 781         folder_remote_folder_init((Folder *)folder, name, path);
 782         IMAP_FOLDER(folder)->max_set_size = IMAP_SET_MAX_COUNT;
 783         IMAP_FOLDER(folder)->search_charset_supported = TRUE;
 784         IMAP_FOLDER(folder)->search_charset = g_strdup(conv_get_locale_charset_str_no_utf8());
 785 }
 786
 787 static FolderItem *imap_folder_item_new(Folder *folder)
 788 {
 789         IMAPFolderItem *item;
 790
 791         item = g_new0(IMAPFolderItem, 1);
 792         item->lastuid = 0;
 793         item->uid_next = 0;
 794         item->uid_list = NULL;
 795
 796         return (FolderItem *)item;
 797 }
 798
 799 static void imap_folder_item_destroy(Folder *folder, FolderItem *_item)
 800 {
 801         IMAPFolderItem *item = (IMAPFolderItem *)_item;
 802
 803         g_return_if_fail(item != NULL);
 804         g_slist_free(item->uid_list);
 805
 806         g_free(_item);
 807 }
 808
 809 static gboolean imap_reset_uid_lists_func(GNode *node, gpointer data)
 810 {
 811         IMAPFolderItem *item = (IMAPFolderItem *)node->data;
 812
 813         item->lastuid = 0;
 814         g_slist_free(item->uid_list);
 815         item->uid_list = NULL;
 816
 817         return FALSE;
 818 }
 819
 820 static void imap_reset_uid_lists(Folder *folder)
 821 {
 822         if(folder->node == NULL)
 823                 return;
 824
 825         /* Destroy all uid lists and rest last uid */
 826         g_node_traverse(folder->node, G_IN_ORDER, G_TRAVERSE_ALL, -1, imap_reset_uid_lists_func, NULL);
 827 }
 828
 829 static int imap_get_capabilities(IMAPSession *session)
 830 {
 831         struct mailimap_capability_data *capabilities = NULL;
 832         clistiter *cur;
 833         int result;
 834
 835         if (session->capability != NULL)
 836                 return MAILIMAP_NO_ERROR;
 837
 838         result = imap_threaded_capability(session->folder, &capabilities);
 839
 840         if (result != MAILIMAP_NO_ERROR) {
 841                 return result;
 842         }
 843
 844         if (capabilities == NULL || capabilities->cap_list == NULL) {
 845                 return MAILIMAP_NO_ERROR;
 846         }
 847
 848         for(cur = clist_begin(capabilities->cap_list) ; cur != NULL ;
 849             cur = clist_next(cur)) {
 850                 struct mailimap_capability * cap =
 851                         clist_content(cur);
 852                 if (!cap || cap->cap_data.cap_name == NULL)
 853                         continue;
 854                 session->capability = g_slist_append
 855                                 (session->capability,
 856                                  g_strdup(cap->cap_data.cap_name));
 857                 debug_print("got capa %s\n", cap->cap_data.cap_name);
 858         }
 859         mailimap_capability_data_free(capabilities);
 860         return MAILIMAP_NO_ERROR;
 861 }
 862
 863 static gboolean imap_has_capability(IMAPSession *session, const gchar *cap)
 864 {
 865         GSList *cur;
 866         for (cur = session->capability; cur; cur = cur->next) {
 867                 if (!g_ascii_strcasecmp(cur->data, cap))
 868                         return TRUE;
 869         }
 870         return FALSE;
 871 }
 872
 873 static gint imap_auth(IMAPSession *session, const gchar *user, const gchar *pass,
 874                       IMAPAuthType type)
 875 {
 876         gint ok = MAILIMAP_ERROR_LOGIN;
 877         static time_t last_login_err = 0;
 878         gchar *ext_info = "";
 879         int r;
 880         gchar *server = NULL;
 881         if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
 882                 imap_handle_error(SESSION(session), NULL, r);
 883                 return r;
 884         }
 885         server = g_strdup(SESSION(session)->server);
 886         switch(type) {
 887         case IMAP_AUTH_ANON:
 888                 ok = imap_cmd_login(session, user, pass, "ANONYMOUS");
 889                 break;
 890         case IMAP_AUTH_CRAM_MD5:
 891                 ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
 892                 break;
 893         case IMAP_AUTH_DIGEST_MD5:
 894                 ok = imap_cmd_login(session, user, pass, "DIGEST-MD5");
 895                 break;
 896         case IMAP_AUTH_SCRAM_SHA1:
 897                 ok = imap_cmd_login(session, user, pass, "SCRAM-SHA-1");
 898                 break;
 899         case IMAP_AUTH_PLAIN:
 900                 ok = imap_cmd_login(session, user, pass, "PLAIN");
 901                 break;
 902         case IMAP_AUTH_LOGIN:
 903                 ok = imap_cmd_login(session, user, pass, "LOGIN");
 904                 break;
 905         case IMAP_AUTH_PLAINTEXT:
 906                 ok = imap_cmd_login(session, user, pass, "plaintext");
 907                 break;
 908         case IMAP_AUTH_GSSAPI:
 909                 ok = imap_cmd_login(session, user, pass, "GSSAPI");
 910                 break;
 911         default:
 912                 debug_print("capabilities:\n"
 913                                 "\t ANONYMOUS %d\n"
 914                                 "\t CRAM-MD5 %d\n"
 915                                 "\t DIGEST-MD5 %d\n"
 916                                 "\t SCRAM-SHA-1 %d\n"
 917                                 "\t PLAIN %d\n"
 918                                 "\t LOGIN %d\n"
 919                                 "\t GSSAPI %d\n",
 920                         imap_has_capability(session, "ANONYMOUS"),
 921                         imap_has_capability(session, "CRAM-MD5"),
 922                         imap_has_capability(session, "DIGEST-MD5"),
 923                         imap_has_capability(session, "SCRAM-SHA-1"),
 924                         imap_has_capability(session, "PLAIN"),
 925                         imap_has_capability(session, "LOGIN"),
 926                         imap_has_capability(session, "GSSAPI"));
 927                 if (imap_has_capability(session, "CRAM-MD5"))
 928                         ok = imap_cmd_login(session, user, pass, "CRAM-MD5");
 929                 if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "DIGEST-MD5"))
 930                         ok = imap_cmd_login(session, user, pass, "DIGEST-MD5");
 931                 if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "SCRAM-SHA-1"))
 932                         ok = imap_cmd_login(session, user, pass, "SCRAM-SHA-1");
 933                 if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "PLAIN"))
 934                         ok = imap_cmd_login(session, user, pass, "PLAIN");
 935                 if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "LOGIN"))
 936                         ok = imap_cmd_login(session, user, pass, "LOGIN");
 937                 if (ok == MAILIMAP_ERROR_LOGIN && imap_has_capability(session, "GSSAPI"))
 938                         ok = imap_cmd_login(session, user, pass, "GSSAPI");
 939                 if (ok == MAILIMAP_ERROR_LOGIN) /* we always try plaintext login before giving up */
 940                         ok = imap_cmd_login(session, user, pass, "plaintext");
 941         }
 942
 943         if (ok == MAILIMAP_NO_ERROR)
 944                 session->authenticated = TRUE;
 945         else {
 946                 if (type == IMAP_AUTH_CRAM_MD5) {
 947                         ext_info = _("\n\nCRAM-MD5 logins only work if libetpan has been "
 948                                      "compiled with SASL support and the "
 949                                      "CRAM-MD5 SASL plugin is installed.");
 950                 }
 951
 952                 if (type == IMAP_AUTH_DIGEST_MD5) {
 953                         ext_info = _("\n\nDIGEST-MD5 logins only work if libetpan has been "
 954                                      "compiled with SASL support and the "
 955                                      "DIGEST-MD5 SASL plugin is installed.");
 956                 }
 957
 958                 if (type == IMAP_AUTH_SCRAM_SHA1) {
 959                         ext_info = _("\n\nSCRAM-SHA-1 logins only work if libetpan has been "
 960                                      "compiled with SASL support and the "
 961                                      "SCRAM SASL plugin is installed.");
 962                 }
 963
 964                 if (type == IMAP_AUTH_PLAIN) {
 965                         ext_info = _("\n\nPLAIN logins only work if libetpan has been "
 966                                      "compiled with SASL support and the "
 967                                      "PLAIN SASL plugin is installed.");
 968                 }
 969
 970                 if (type == IMAP_AUTH_LOGIN) {
 971                         ext_info = _("\n\nLOGIN logins only work if libetpan has been "
 972                                      "compiled with SASL support and the "
 973                                      "LOGIN SASL plugin is installed.");
 974                 }
 975
 976                 if (time(NULL) - last_login_err > 10) {
 977                         if (!prefs_common.no_recv_err_panel) {
 978                                 alertpanel_error_log(_("Connection to %s failed: "
 979                                         "login refused.%s"),
 980                                         server, ext_info);
 981                         } else {
 982                                 log_error(LOG_PROTOCOL, _("Connection to %s failed: "
 983                                         "login refused.%s\n"),
 984                                         server, ext_info);
 985                         }
 986                 }
 987                 last_login_err = time(NULL);
 988         }
 989         g_free(server);
 990         return ok;
 991 }
 992
 993 static IMAPSession *imap_reconnect_if_possible(Folder *folder, IMAPSession *session)
 994 {
 995         RemoteFolder *rfolder = REMOTE_FOLDER(folder);
 996         /* Check if this is the first try to establish a
 997            connection, if yes we don't try to reconnect */
 998         debug_print("reconnecting\n");
 999         if (rfolder->session == NULL) {
1000                 log_warning(LOG_PROTOCOL, _("Connecting to %s failed"),
1001                             folder->account->recv_server);
1002                 SESSION(session)->sock = NULL;
1003                 imap_safe_destroy(session);
1004                 session = NULL;
1005         } else {
1006                 rfolder->session = NULL;
1007                 log_warning(LOG_PROTOCOL, _("IMAP connection to %s has been"
1008                             " disconnected. Reconnecting...\n"),
1009                             folder->account->recv_server);
1010                 statusbar_print_all(_("IMAP connection to %s has been"
1011                             " disconnected. Reconnecting...\n"),
1012                             folder->account->recv_server);
1013                 SESSION(session)->state = SESSION_DISCONNECTED;
1014                 SESSION(session)->sock = NULL;
1015                 imap_safe_destroy(session);
1016                 /* Clear folders session to make imap_session_get create
1017                    a new session, because of rfolder->session == NULL
1018                    it will not try to reconnect again and so avoid an
1019                    endless loop */
1020                 debug_print("getting session...\n");
1021                 session = imap_session_get(folder);
1022                 rfolder->session = SESSION(session);
1023                 statusbar_pop_all();
1024         }
1025         return session;
1026 }
1027
1028 static IMAPSession *imap_session_get(Folder *folder)
1029 {
1030         RemoteFolder *rfolder = REMOTE_FOLDER(folder);
1031         IMAPSession *session = NULL;
1032         gint r = MAILIMAP_NO_ERROR;
1033
1034         g_return_val_if_fail(folder != NULL, NULL);
1035         g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, NULL);
1036         g_return_val_if_fail(folder->account != NULL, NULL);
1037
1038         if (prefs_common.work_offline &&
1039             !inc_offline_should_override(FALSE,
1040                 _("Claws Mail needs network access in order "
1041                   "to access the IMAP server."))) {
1042                 return NULL;
1043         }
1044
1045         /* check for deferred destroy */
1046         if (rfolder->session != NULL) {
1047                 session = IMAP_SESSION(rfolder->session);
1048                 if (!session->busy && session->do_destroy) {
1049                         rfolder->session = NULL;
1050                         imap_safe_destroy(session);
1051                         session = NULL;
1052                 }
1053         }
1054
1055         /* Make sure we have a session */
1056         if (rfolder->session != NULL && rfolder->session->state != SESSION_DISCONNECTED) {
1057                 session = IMAP_SESSION(rfolder->session);
1058         } else if (rfolder->session != NULL && rfolder->session->state == SESSION_DISCONNECTED) {
1059                 imap_safe_destroy(IMAP_SESSION(rfolder->session));
1060                 rfolder->session = NULL;
1061                 goto new_conn;
1062         } else if (rfolder->connecting) {
1063                 debug_print("already connecting\n");
1064                 return NULL;
1065         } else {
1066 new_conn:
1067                 imap_reset_uid_lists(folder);
1068                 if (time(NULL) - rfolder->last_failure <= 2)
1069                         return NULL;
1070                 rfolder->connecting = TRUE;
1071                 session = imap_session_new(folder, folder->account);
1072         }
1073         if(session == NULL) {
1074                 rfolder->last_failure = time(NULL);
1075                 rfolder->connecting = FALSE;
1076                 return NULL;
1077         }
1078
1079         /* Make sure session is authenticated */
1080         if (!IMAP_SESSION(session)->authenticated)
1081                 r = imap_session_authenticate(IMAP_SESSION(session), folder->account);
1082
1083         if (r != MAILIMAP_NO_ERROR || (!is_fatal(r) && !IMAP_SESSION(session)->authenticated)) {
1084                 rfolder->session = NULL;
1085                 if (!is_fatal(r)) {
1086                         imap_threaded_disconnect(session->folder);
1087                 }
1088                 SESSION(session)->state = SESSION_DISCONNECTED;
1089                 SESSION(session)->sock = NULL;
1090                 imap_safe_destroy(session);
1091                 rfolder->last_failure = time(NULL);
1092                 rfolder->connecting = FALSE;
1093                 return NULL;
1094         }
1095
1096         /* I think the point of this code is to avoid sending a
1097          * keepalive if we've used the session recently and therefore
1098          * think it's still alive.  Unfortunately, most of the code
1099          * does not yet check for errors on the socket, and so if the
1100          * connection drops we don't notice until the timeout expires.
1101          * A better solution than sending a NOOP every time would be
1102          * for every command to be prepared to retry until it is
1103          * successfully sent. -- mbp */
1104         if ((time(NULL) - SESSION(session)->last_access_time > SESSION_TIMEOUT_INTERVAL) || session->cancelled) {
1105                 /* verify that the session is still alive */
1106                 r = imap_cmd_noop(session);
1107
1108                 if (r != MAILIMAP_NO_ERROR) {
1109                         debug_print("disconnected!\n");
1110                         if (!is_fatal(r))
1111                                 session = imap_reconnect_if_possible(folder, session);
1112                         else {
1113                                 rfolder->session = NULL;
1114                                 rfolder->connecting = FALSE;
1115                                 SESSION(session)->state = SESSION_DISCONNECTED;
1116                                 SESSION(session)->sock = NULL;
1117                                 imap_safe_destroy(session);
1118                                 session = imap_session_get(folder);
1119                         }
1120                 }
1121                 if (session)
1122                         session->cancelled = FALSE;
1123         }
1124
1125         rfolder->session = SESSION(session);
1126         rfolder->connecting = FALSE;
1127
1128         return IMAP_SESSION(session);
1129 }
1130
1131 static IMAPSession *imap_session_new(Folder * folder,
1132                                      const PrefsAccount *account)
1133 {
1134         IMAPSession *session;
1135         ProxyInfo *proxy_info = NULL;
1136         gushort port;
1137         int r;
1138         int authenticated = FALSE;
1139         gchar *buf;
1140
1141 #ifdef USE_GNUTLS
1142         /* FIXME: IMAP over SSL only... */
1143         SSLType ssl_type;
1144
1145         port = account->set_imapport ? account->imapport
1146                 : account->ssl_imap == SSL_TUNNEL ? IMAPS_PORT : IMAP4_PORT;
1147         ssl_type = account->ssl_imap;
1148 #else
1149         if (account->ssl_imap != SSL_NONE) {
1150                 if (alertpanel_full(_("Insecure connection"),
1151                         _("This connection is configured to be secured "
1152                           "using SSL/TLS, but SSL/TLS is not available "
1153                           "in this build of Claws Mail. \n\n"
1154                           "Do you want to continue connecting to this "
1155                           "server? The communication would not be "
1156                           "secure."),
1157                           GTK_STOCK_CANCEL, _("Con_tinue connecting"), NULL,
1158                                 ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING) != G_ALERTALTERNATE)
1159                         return NULL;
1160         }
1161         port = account->set_imapport ? account->imapport
1162                 : IMAP4_PORT;
1163 #endif
1164
1165         imap_init(folder);
1166         buf = g_strdup_printf(_("Account '%s': Connecting to IMAP server: %s:%d..."),
1167                                 folder->account->account_name, folder->account->recv_server,
1168                                 port);
1169         statusbar_print_all("%s", buf);
1170         log_message(LOG_PROTOCOL, "%s\n", buf);
1171         g_free(buf);
1172
1173         if (account->use_proxy) {
1174                 if (account->use_default_proxy) {
1175                         proxy_info = (ProxyInfo *)&(prefs_common.proxy_info);
1176                         if (proxy_info->use_proxy_auth)
1177                                 proxy_info->proxy_pass = passwd_store_get(PWS_CORE, PWS_CORE_PROXY,
1178                                         PWS_CORE_PROXY_PASS);
1179                 } else {
1180                         proxy_info = (ProxyInfo *)&(account->proxy_info);
1181                         if (proxy_info->use_proxy_auth)
1182                                 proxy_info->proxy_pass = passwd_store_get_account(account->account_id,
1183                                         PWS_ACCOUNT_PROXY_PASS);
1184                 }
1185         }
1186
1187 #ifndef G_OS_WIN32
1188         if (account->set_tunnelcmd) {
1189                 r = imap_threaded_connect_cmd(folder,
1190                                               account->tunnelcmd,
1191                                               account->recv_server,
1192                                               port);
1193         }
1194         else
1195 #endif
1196         {
1197 #ifdef USE_GNUTLS
1198
1199                 if (ssl_type == SSL_TUNNEL) {
1200                         r = imap_threaded_connect_ssl(folder,
1201                                                       account->recv_server,
1202                                                       port,
1203                                                       proxy_info);
1204                 }
1205                 else
1206 #endif
1207                 {
1208                         r = imap_threaded_connect(folder,
1209                                                   account->recv_server,
1210                                                   port,
1211                                                   proxy_info);
1212                 }
1213         }
1214
1215         statusbar_pop_all();
1216         if (r == MAILIMAP_NO_ERROR_AUTHENTICATED) {
1217                 authenticated = TRUE;
1218         }
1219         else if (r == MAILIMAP_NO_ERROR_NON_AUTHENTICATED) {
1220                 authenticated = FALSE;
1221         }
1222         else {
1223 #ifdef USE_GNUTLS
1224                 if (r == MAILIMAP_ERROR_SSL)
1225                         log_error(LOG_PROTOCOL, _("SSL/TLS handshake failed\n"));
1226                 else
1227 #endif
1228                         imap_handle_error(NULL, account->recv_server, r);
1229
1230                 if(!prefs_common.no_recv_err_panel) {
1231                         alertpanel_error_log(_("Can't connect to IMAP server: %s:%d"),
1232                                          account->recv_server, port);
1233                 } else {
1234                         log_error(LOG_PROTOCOL, _("Can't connect to IMAP server: %s:%d\n"),
1235                                          account->recv_server, port);
1236                 }
1237
1238                 return NULL;
1239         }
1240
1241         session = g_new0(IMAPSession, 1);
1242         session_init(SESSION(session), account, FALSE);
1243         SESSION(session)->type             = SESSION_IMAP;
1244         SESSION(session)->server           = g_strdup(account->recv_server);
1245         SESSION(session)->port             = port;
1246         SESSION(session)->sock             = NULL;
1247         SESSION(session)->proxy_info       = proxy_info;
1248         SESSION(session)->destroy          = imap_session_destroy;
1249
1250         session->capability = NULL;
1251         session->authenticated = authenticated;
1252         session->mbox = NULL;
1253         session->exists = 0;
1254         session->recent = 0;
1255         session->expunge = 0;
1256         session->cmd_count = 0;
1257         session->folder = folder;
1258         IMAP_FOLDER(session->folder)->last_seen_separator = 0;
1259
1260 #ifdef USE_GNUTLS
1261         if (account->ssl_imap == SSL_STARTTLS) {
1262                 gint ok;
1263
1264                 ok = imap_cmd_starttls(session);
1265                 if (ok != MAILIMAP_NO_ERROR) {
1266                         log_warning(LOG_PROTOCOL, _("Can't start STARTTLS session.\n"));
1267                         if (!is_fatal(ok)) {
1268                                 SESSION(session)->sock = NULL;
1269                                 imap_safe_destroy(session);
1270                         }
1271                         return NULL;
1272                 }
1273
1274                 imap_free_capabilities(session);
1275                 session->authenticated = FALSE;
1276                 session->uidplus = FALSE;
1277                 session->cmd_count = 1;
1278         }
1279         SESSION(session)->use_tls_sni = account->use_tls_sni;
1280 #endif
1281
1282         log_message(LOG_PROTOCOL, "IMAP connection is %s-authenticated\n",
1283                     (session->authenticated) ? "pre" : "un");
1284
1285         session_register_ping(SESSION(session), imap_ping);
1286
1287         return session;
1288 }
1289
1290 static gint imap_session_authenticate(IMAPSession *session,
1291                                       PrefsAccount *account)
1292 {
1293         gchar *pass, *acc_pass = NULL;
1294         gboolean failed = FALSE;
1295         gint ok = MAILIMAP_NO_ERROR;
1296         g_return_val_if_fail(account->userid != NULL, MAILIMAP_ERROR_BAD_STATE);
1297
1298         if (!password_get(account->userid, account->recv_server, "imap",
1299                          SESSION(session)->port, &acc_pass)) {
1300                 acc_pass = passwd_store_get_account(account->account_id,
1301                                 PWS_ACCOUNT_RECV);
1302         }
1303
1304 try_again:
1305         pass = acc_pass;
1306         if (!pass && account->imap_auth_type != IMAP_AUTH_ANON && account->imap_auth_type != IMAP_AUTH_GSSAPI) {
1307                 gchar *tmp_pass;
1308                 tmp_pass = input_dialog_query_password_keep(account->recv_server,
1309                                                             account->userid,
1310                                                             &(account->session_passwd));
1311                 if (!tmp_pass) {
1312                         return MAILIMAP_NO_ERROR;
1313                 }
1314                 Xstrdup_a(pass, tmp_pass, {g_free(tmp_pass); return MAILIMAP_NO_ERROR;});
1315                 g_free(tmp_pass);
1316         } else if (account->imap_auth_type == IMAP_AUTH_ANON || account->imap_auth_type == IMAP_AUTH_GSSAPI) {
1317                 pass = "";
1318         }
1319         if ((ok = imap_auth(session, account->userid, pass, account->imap_auth_type)) != MAILIMAP_NO_ERROR) {
1320
1321                 if (!failed && !is_fatal(ok)) {
1322                         if (acc_pass != NULL) {
1323                                 memset(acc_pass, 0, strlen(acc_pass));
1324                                 g_free(acc_pass);
1325                                 acc_pass = NULL;
1326                         }
1327                         failed = TRUE;
1328                         if (account->session_passwd != NULL) {
1329                                 g_free(account->session_passwd);
1330                                 account->session_passwd = NULL;
1331                         }
1332                         goto try_again;
1333                 } else {
1334                         if (prefs_common.no_recv_err_panel) {
1335                                 log_error(LOG_PROTOCOL, _("Couldn't login to IMAP server %s.\n"), account->recv_server);
1336                                 mainwindow_show_error();
1337                         } else
1338                                 alertpanel_error_log(_("Couldn't login to IMAP server %s."), account->recv_server);
1339                 }
1340
1341                 if (acc_pass != NULL) {
1342                         memset(acc_pass, 0, strlen(acc_pass));
1343                         g_free(acc_pass);
1344                         acc_pass = NULL;
1345                 }
1346
1347                 return ok;
1348         }
1349
1350         if (acc_pass) {
1351                 memset(acc_pass, 0, strlen(acc_pass));
1352                 g_free(acc_pass);
1353         }
1354         statusbar_pop_all();
1355         session->authenticated = TRUE;
1356         return MAILIMAP_NO_ERROR;
1357 }
1358
1359 static void imap_session_destroy(Session *session)
1360 {
1361         if (session->state != SESSION_DISCONNECTED)
1362                 imap_threaded_disconnect(IMAP_SESSION(session)->folder);
1363
1364         imap_free_capabilities(IMAP_SESSION(session));
1365         g_free(IMAP_SESSION(session)->mbox);
1366 }
1367
1368 static gchar *imap_fetch_msg(Folder *folder, FolderItem *item, gint uid)
1369 {
1370         return imap_fetch_msg_full(folder, item, uid, TRUE, TRUE);
1371 }
1372
1373 static guint get_file_size_with_crs(const gchar *filename)
1374 {
1375         FILE *fp = NULL;
1376         guint cnt = 0;
1377         gchar buf[4096];
1378
1379         if (filename == NULL)
1380                 return -1;
1381
1382         fp = claws_fopen(filename, "rb");
1383         if (!fp)
1384                 return -1;
1385
1386         while (claws_fgets(buf, sizeof (buf), fp) != NULL) {
1387                 cnt += strlen(buf);
1388                 if (!strstr(buf, "\r\n") && strstr(buf, "\n"))
1389                         cnt++;
1390         }
1391
1392         claws_fclose(fp);
1393         return cnt;
1394 }
1395
1396 static gchar *imap_get_cached_filename(FolderItem *item, guint msgnum)
1397 {
1398         gchar *path, *filename;
1399
1400         cm_return_val_if_fail(item != NULL, NULL);
1401
1402         path = folder_item_get_path(item);
1403
1404         if (!is_dir_exist(path)) {
1405                 g_free(path);
1406                 return NULL;
1407         }
1408
1409         filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(msgnum), NULL);
1410
1411         if (is_dir_exist(filename)) {
1412                 g_free(filename);
1413                 filename = g_strconcat(path, G_DIR_SEPARATOR_S, ".", itos(msgnum), NULL);
1414         }
1415         g_free(path);
1416
1417         return filename;
1418 }
1419
1420 static void imap_remove_cached_msg(Folder *folder, FolderItem *item, MsgInfo *msginfo)
1421 {
1422         gchar *filename;
1423
1424         filename = imap_get_cached_filename(item, msginfo->msgnum);
1425
1426         cm_return_if_fail(filename != NULL);
1427
1428         if (is_file_exist(filename)) {
1429                 claws_unlink(filename);
1430         }
1431         g_free(filename);
1432 }
1433
1434 typedef struct _TagsData {
1435         gchar *str;
1436         GSList *msglist;
1437         IMAPFolderItem *item;
1438 } TagsData;
1439
1440 static void imap_commit_tags(FolderItem *item, MsgInfo *msginfo, GSList *tags_set, GSList *tags_unset)
1441 {
1442         IMAPSession *session;
1443         gint ok, can_create_tags;
1444         Folder *folder = NULL;
1445         TagsData *ht_data = NULL;
1446         GSList *cur;
1447
1448         g_return_if_fail(item != NULL);
1449         g_return_if_fail(msginfo != NULL);
1450
1451         folder = item->folder;
1452         debug_print("getting session...\n");
1453         session = imap_session_get(folder);
1454
1455         if (!session) {
1456                 debug_print("can't get session\n");
1457                 return;
1458         }
1459
1460         ok = imap_select(session, IMAP_FOLDER(folder), item,
1461                          NULL, NULL, NULL, NULL, &can_create_tags, FALSE);
1462
1463         if (ok != MAILIMAP_NO_ERROR) {
1464                 return;
1465         }
1466
1467
1468         if (IMAP_FOLDER_ITEM(item)->can_create_flags != ITEM_CAN_CREATE_FLAGS)
1469                 return;
1470
1471         if (IMAP_FOLDER_ITEM(item)->batching) {
1472                 /* instead of performing an UID STORE command for each message change,
1473                  * as a lot of them can change "together", we just fill in hashtables
1474                  * and defer the treatment so that we're able to send only one
1475                  * command.
1476                  */
1477                 debug_print("IMAP batch mode on, deferring tags change\n");
1478                 for (cur = tags_set; cur; cur = cur->next) {
1479                         gint cur_tag = GPOINTER_TO_INT(cur->data);
1480                         if (cur_tag) {
1481                                 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->tags_set_table,
1482                                         GINT_TO_POINTER(cur_tag));
1483                                 if (ht_data == NULL) {
1484                                         ht_data = g_new0(TagsData, 1);
1485                                         ht_data->str = g_strdup(tags_get_tag(cur_tag));
1486                                         ht_data->item = IMAP_FOLDER_ITEM(item);
1487                                         g_hash_table_insert(IMAP_FOLDER_ITEM(item)->tags_set_table,
1488                                                 GINT_TO_POINTER(cur_tag), ht_data);
1489                                 }
1490                                 ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
1491                         }
1492                 }
1493                 for (cur = tags_unset; cur; cur = cur->next) {
1494                         gint cur_tag = GPOINTER_TO_INT(cur->data);
1495                         if (cur_tag) {
1496                                 ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->tags_unset_table,
1497                                         GINT_TO_POINTER(cur_tag));
1498                                 if (ht_data == NULL) {
1499                                         ht_data = g_new0(TagsData, 1);
1500                                         ht_data->str = g_strdup(tags_get_tag(cur_tag));
1501                                         ht_data->item = IMAP_FOLDER_ITEM(item);
1502                                         g_hash_table_insert(IMAP_FOLDER_ITEM(item)->tags_unset_table,
1503                                                 GINT_TO_POINTER(cur_tag), ht_data);
1504                                 }
1505                                 ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
1506                         }
1507                 }
1508         } else {
1509                 GSList *list_set = NULL;
1510                 GSList *list_unset = NULL;
1511                 GSList numlist;
1512
1513                 numlist.data = GINT_TO_POINTER(msginfo->msgnum);
1514                 numlist.next = NULL;
1515
1516                 debug_print("IMAP changing tags NOW\n");
1517                 for (cur = tags_set; cur; cur = cur->next) {
1518                         gint cur_tag = GPOINTER_TO_INT(cur->data);
1519                         const gchar *str = tags_get_tag(cur_tag);
1520                         if (IS_NOT_RESERVED_TAG(str))
1521                                 list_set = g_slist_prepend(list_set, g_strdup(str));
1522                 }
1523                 if (list_set) {
1524                         ok = imap_set_message_flags(session,
1525                                 IMAP_FOLDER_ITEM(item), &numlist, 0, list_set, TRUE);
1526                         slist_free_strings_full(list_set);
1527                         if (ok != MAILIMAP_NO_ERROR) {
1528                                 return;
1529                         }
1530                 }
1531
1532                 for (cur = tags_unset; cur; cur = cur->next) {
1533                         gint cur_tag = GPOINTER_TO_INT(cur->data);
1534                         const gchar *str = tags_get_tag(cur_tag);
1535                         if (IS_NOT_RESERVED_TAG(str))
1536                                 list_unset = g_slist_prepend(list_unset, g_strdup(str));
1537                 }
1538                 if (list_unset) {
1539                         ok = imap_set_message_flags(session,
1540                                 IMAP_FOLDER_ITEM(item), &numlist, 0, list_unset, FALSE);
1541                         slist_free_strings_full(list_unset);
1542                         if (ok != MAILIMAP_NO_ERROR) {
1543                                 return;
1544                         }
1545                 }
1546         }
1547 }
1548
1549 static gchar *imap_fetch_msg_full(Folder *folder, FolderItem *item, gint uid,
1550                                   gboolean headers, gboolean body)
1551 {
1552         gchar *path, *filename;
1553         IMAPSession *session;
1554         gint ok;
1555
1556         g_return_val_if_fail(folder != NULL, NULL);
1557         g_return_val_if_fail(item != NULL, NULL);
1558
1559         if (uid == 0)
1560                 return NULL;
1561
1562         path = folder_item_get_path(item);
1563         if (!is_dir_exist(path)) {
1564                 if(is_file_exist(path))
1565                         claws_unlink(path);
1566                 make_dir_hier(path);
1567         }
1568         g_free(path);
1569
1570         filename = imap_get_cached_filename(item, uid);
1571         debug_print("trying to fetch cached %s\n", filename);
1572
1573         if (is_file_exist(filename)) {
1574                 /* see whether the local file represents the whole message
1575                  * or not. As the IMAP server reports size with \r chars,
1576                  * we have to update the local file (UNIX \n only) size */
1577                 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1578                 guint have_size = -1;
1579
1580                 if (cached)
1581                         debug_print("message %d has been already %scached.\n", uid,
1582                                 MSG_IS_FULLY_CACHED(cached->flags) ? "fully ":"");
1583
1584                 if (!cached || !MSG_IS_FULLY_CACHED(cached->flags)) {
1585                         have_size = get_file_size_with_crs(filename);
1586                         if (cached && (cached->size <= have_size || !body)) {
1587                                 ok = file_strip_crs(filename);
1588                                 if (ok == 0 && cached && cached->size <= have_size) {
1589                                         /* we have it all and stripped */
1590                                         debug_print("...fully cached in fact (%u/%"G_GOFFSET_FORMAT"); setting flag.\n",
1591                                                         have_size, cached->size);
1592                                         procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1593                                 }
1594                                 procmsg_msginfo_free(&cached);
1595                                 return filename;
1596                         } else if (!cached && time(NULL) - get_file_mtime(filename) < 60) {
1597                                 debug_print("message not cached and file recent, considering file complete\n");
1598                                 ok = file_strip_crs(filename);
1599                                 if (ok == 0)
1600                                         return filename;
1601                         } else {
1602                                 procmsg_msginfo_free(&cached);
1603                         }
1604                 }
1605                 if (cached && MSG_IS_FULLY_CACHED(cached->flags)) {
1606                         procmsg_msginfo_free(&cached);
1607                         return filename;
1608                 }
1609         } else {
1610                 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1611                 if (cached) {
1612                         procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1613                         procmsg_msginfo_free(&cached);
1614                 }
1615         }
1616
1617         debug_print("getting session...\n");
1618         session = imap_session_get(folder);
1619
1620         if (!session) {
1621                 g_free(filename);
1622                 return NULL;
1623         }
1624         session_set_access_time(SESSION(session));
1625         lock_session(session); /* unlocked later in the function */
1626
1627         debug_print("IMAP fetching messages\n");
1628         ok = imap_select(session, IMAP_FOLDER(folder), item,
1629                          NULL, NULL, NULL, NULL, NULL, FALSE);
1630         if (ok != MAILIMAP_NO_ERROR) {
1631                 g_warning("can't select mailbox %s", item->path);
1632                 g_free(filename);
1633                 return NULL;
1634         }
1635
1636         session_set_access_time(SESSION(session));
1637
1638         debug_print("getting message %d...\n", uid);
1639         ok = imap_cmd_fetch(session, (guint32)uid, filename, headers, body);
1640
1641         if (ok != MAILIMAP_NO_ERROR) {
1642                 g_warning("can't fetch message %d", uid);
1643                 g_free(filename);
1644                 return NULL;
1645         }
1646
1647         session_set_access_time(SESSION(session));
1648         unlock_session(session);
1649
1650         ok = file_strip_crs(filename);
1651
1652         if (ok == 0 && headers && body) {
1653                 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1654                 if (cached) {
1655                         procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1656                         procmsg_msginfo_free(&cached);
1657                 }
1658         } else if (ok == -1) {
1659                 MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1660                 if (cached) {
1661                         procmsg_msginfo_unset_flags(cached, MSG_FULLY_CACHED, 0);
1662                         procmsg_msginfo_free(&cached);
1663                 }
1664         }
1665         return filename;
1666 }
1667
1668 static gboolean imap_is_msg_fully_cached(Folder *folder, FolderItem *item, gint uid)
1669 {
1670         gchar *filename;
1671         guint size = 0;
1672         MsgInfo *cached = msgcache_get_msg(item->cache,uid);
1673
1674         if (!cached)
1675                 return FALSE;
1676
1677         if (MSG_IS_FULLY_CACHED(cached->flags)) {
1678                 procmsg_msginfo_free(&cached);
1679                 return TRUE;
1680         }
1681
1682         filename = imap_get_cached_filename(item, uid);
1683
1684         if (is_file_exist(filename)) {
1685                 if (cached && cached->total_size == cached->size) {
1686                         /* fast path */
1687                         g_free(filename);
1688                         procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1689                         return TRUE;
1690                 }
1691                 size = get_file_size_with_crs(filename);
1692         }
1693         g_free(filename);
1694         debug_print("msg %d cached, has size %d, full should be %"G_GOFFSET_FORMAT".\n", uid, size, cached->size);
1695         if (cached && size >= cached->size) {
1696                 cached->total_size = cached->size;
1697                 procmsg_msginfo_set_flags(cached, MSG_FULLY_CACHED, 0);
1698                 procmsg_msginfo_free(&cached);
1699                 return TRUE;
1700         }
1701         if (cached)
1702                 procmsg_msginfo_free(&cached);
1703         return FALSE;
1704 }
1705
1706 void imap_cache_msg(FolderItem *item, gint msgnum)
1707 {
1708         Folder *folder = NULL;
1709
1710         if (!item)
1711                 return;
1712         folder = item->folder;
1713
1714         if (!imap_is_msg_fully_cached(folder, item, msgnum)) {
1715                 gchar *tmp = imap_fetch_msg_full(folder, item, msgnum, TRUE, TRUE);
1716                 debug_print("fetched %s\n", tmp);
1717                 g_free(tmp);
1718         }
1719 }
1720
1721 static gint imap_add_msg(Folder *folder, FolderItem *dest,
1722                          const gchar *file, MsgFlags *flags)
1723 {
1724         gint ret;
1725         GSList file_list;
1726         MsgFileInfo fileinfo;
1727
1728         g_return_val_if_fail(file != NULL, -1);
1729
1730         fileinfo.msginfo = NULL;
1731         fileinfo.file = (gchar *)file;
1732         fileinfo.flags = flags;
1733         file_list.data = &fileinfo;
1734         file_list.next = NULL;
1735
1736         ret = imap_add_msgs(folder, dest, &file_list, NULL);
1737         return ret;
1738 }
1739
1740 static gint imap_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
1741                    GHashTable *relation)
1742 {
1743         gchar *destdir;
1744         IMAPSession *session;
1745         guint32 last_uid = 0;
1746         GSList *cur;
1747         MsgFileInfo *fileinfo;
1748         gint ok = MAILIMAP_NO_ERROR;
1749         gint curnum = 0, total = 0;
1750         gboolean missing_uids = FALSE;
1751
1752         g_return_val_if_fail(folder != NULL, -1);
1753         g_return_val_if_fail(dest != NULL, -1);
1754         g_return_val_if_fail(file_list != NULL, -1);
1755
1756         debug_print("getting session...\n");
1757         session = imap_session_get(folder);
1758         if (!session) {
1759                 return -1;
1760         }
1761         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
1762         if (is_fatal(ok)) {
1763                 g_free(destdir);
1764                 return -1;
1765         }
1766         statusbar_print_all(_("Adding messages..."));
1767         total = g_slist_length(file_list);
1768         for (cur = file_list; cur != NULL; cur = cur->next) {
1769                 IMAPFlags iflags = 0;
1770                 guint32 new_uid = 0;
1771                 gchar *real_file = NULL;
1772                 fileinfo = (MsgFileInfo *)cur->data;
1773
1774                 statusbar_progress_all(curnum, total, total < 10 ? 1:10);
1775                 curnum++;
1776
1777                 if (fileinfo->flags) {
1778                         if (MSG_IS_MARKED(*fileinfo->flags))
1779                                 iflags |= IMAP_FLAG_FLAGGED;
1780                         if (MSG_IS_REPLIED(*fileinfo->flags))
1781                                 iflags |= IMAP_FLAG_ANSWERED;
1782                         if (MSG_IS_FORWARDED(*fileinfo->flags))
1783                                 iflags |= IMAP_FLAG_FORWARDED;
1784                         if (MSG_IS_SPAM(*fileinfo->flags))
1785                                 iflags |= IMAP_FLAG_SPAM;
1786                         else
1787                                 iflags |= IMAP_FLAG_HAM;
1788                         if (!MSG_IS_UNREAD(*fileinfo->flags))
1789                                 iflags |= IMAP_FLAG_SEEN;
1790
1791                 }
1792
1793                 if (real_file == NULL)
1794                         real_file = g_strdup(fileinfo->file);
1795
1796                 if (folder_has_parent_of_type(dest, F_QUEUE) ||
1797                     folder_has_parent_of_type(dest, F_OUTBOX) ||
1798                     folder_has_parent_of_type(dest, F_DRAFT) ||
1799                     folder_has_parent_of_type(dest, F_TRASH))
1800                         iflags |= IMAP_FLAG_SEEN;
1801
1802                 ok = imap_cmd_append(session, IMAP_FOLDER_ITEM(dest), destdir, real_file, iflags,
1803                                      &new_uid);
1804
1805                 if (ok != MAILIMAP_NO_ERROR) {
1806                         g_warning("can't append message %s", real_file);
1807                         g_free(real_file);
1808                         g_free(destdir);
1809                         statusbar_progress_all(0,0,0);
1810                         statusbar_pop_all();
1811                         return -1;
1812                 } else {
1813                         debug_print("appended new message as %d\n", new_uid);
1814                         /* put the local file in the imapcache, so that we don't
1815                          * have to fetch it back later. */
1816
1817                         if (new_uid == 0) {
1818                                 missing_uids = TRUE;
1819                                 debug_print("Missing UID (0)\n");
1820                         }
1821                         if (new_uid > 0) {
1822                                 gchar *cache_path = folder_item_get_path(dest);
1823                                 if (!is_dir_exist(cache_path))
1824                                         make_dir_hier(cache_path);
1825                                 if (is_dir_exist(cache_path)) {
1826                                         gchar *cache_file = g_strconcat(
1827                                                 cache_path, G_DIR_SEPARATOR_S,
1828                                                 itos(new_uid), NULL);
1829                                         copy_file(real_file, cache_file, TRUE);
1830                                         debug_print("got UID %d, copied to cache: %s\n", new_uid, cache_file);
1831                                         g_free(cache_file);
1832                                 }
1833                                 g_free(cache_path);
1834                         }
1835                 }
1836
1837                 if (relation != NULL)
1838                         g_hash_table_insert(relation, fileinfo->msginfo != NULL ?
1839                                           (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
1840                                           GINT_TO_POINTER(new_uid));
1841                 if (last_uid < new_uid) {
1842                         last_uid = new_uid;
1843                 }
1844
1845                 g_free(real_file);
1846         }
1847
1848         statusbar_progress_all(0,0,0);
1849         statusbar_pop_all();
1850
1851
1852         g_free(destdir);
1853
1854         imap_scan_required(folder, dest);
1855
1856         session = imap_session_get(folder);
1857         if (!session) {
1858                 return -1;
1859         }
1860         if (missing_uids) {
1861                 gint a;
1862                 ok = imap_select(session, IMAP_FOLDER(folder), dest,
1863                          &a, NULL, NULL, NULL, NULL, FALSE);
1864         }
1865         return last_uid;
1866 }
1867
1868 static GSList *flatten_mailimap_set(struct mailimap_set * set)
1869 {
1870         GSList *result = NULL;
1871         clistiter *list;
1872         guint32 start, end, t;
1873         GSList *cur;
1874
1875         if (!set || !set->set_list)
1876                 return NULL;
1877
1878         for (list = clist_begin(set->set_list); list; list = clist_next(list)) {
1879                 struct mailimap_set_item *item = (struct mailimap_set_item *)clist_content(list);
1880                 start = item->set_first;
1881                 end = item->set_last;
1882                 if (start <= end) {
1883                         for (t = start; t <= end; t++) {
1884                                 result = g_slist_prepend(result, GINT_TO_POINTER(t));
1885                         }
1886                 }
1887         }
1888         result = g_slist_reverse(result);
1889         if (debug_get_mode()) {
1890                 debug_print("flat imap set: ");
1891                 for (cur = result; cur; cur = cur->next) {
1892                         debug_print("%d ", GPOINTER_TO_INT(cur->data));
1893                 }
1894                 debug_print("\n");
1895         }
1896
1897         return result;
1898 }
1899 static gint imap_do_copy_msgs(Folder *folder, FolderItem *dest,
1900                               MsgInfoList *msglist, GHashTable *relation,
1901                               gboolean same_dest_ok)
1902 {
1903         FolderItem *src;
1904         gchar *destdir;
1905         GSList *seq_list, *cur;
1906         MsgInfo *msginfo;
1907         IMAPSession *session;
1908         gint ok = MAILIMAP_NO_ERROR;
1909         GHashTable *uid_hash;
1910         gint last_num = 0;
1911
1912         g_return_val_if_fail(folder != NULL, -1);
1913         g_return_val_if_fail(dest != NULL, -1);
1914         g_return_val_if_fail(msglist != NULL, -1);
1915
1916         debug_print("getting session...\n");
1917         session = imap_session_get(folder);
1918
1919         if (!session) {
1920                 return -1;
1921         }
1922
1923         msginfo = (MsgInfo *)msglist->data;
1924         src = msginfo->folder;
1925         if (!same_dest_ok && src == dest) {
1926                 g_warning("the src folder is identical to the dest.");
1927                 return -1;
1928         }
1929
1930         if (src->folder != dest->folder) {
1931                 GSList *infolist = NULL, *cur;
1932                 int res = -1;
1933                 for (cur = msglist; cur; cur = cur->next) {
1934                         msginfo = (MsgInfo *)cur->data;
1935                         MsgFileInfo *fileinfo = g_new0(MsgFileInfo, 1);
1936                         fileinfo->file = procmsg_get_message_file(msginfo);
1937                         fileinfo->flags = &(msginfo->flags);
1938                         infolist = g_slist_prepend(infolist, fileinfo);
1939                 }
1940                 infolist = g_slist_reverse(infolist);
1941                 res = folder_item_add_msgs(dest, infolist, FALSE);
1942                 for (cur = infolist; cur; cur = cur->next) {
1943                         MsgFileInfo *info = (MsgFileInfo *)cur->data;
1944                         g_free(info->file);
1945                         g_free(info);
1946                 }
1947                 g_slist_free(infolist);
1948                 return res;
1949         }
1950
1951         lock_session(session); /* unlocked later in the function */
1952
1953         ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder,
1954                          NULL, NULL, NULL, NULL, NULL, FALSE);
1955         if (ok != MAILIMAP_NO_ERROR) {
1956                 return ok;
1957         }
1958
1959         unlock_session(session);
1960
1961         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
1962
1963         if (is_fatal(ok)) {
1964                 g_free(destdir);
1965                 return ok;
1966         }
1967
1968         seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msglist);
1969         uid_hash = g_hash_table_new(g_direct_hash, g_direct_equal);
1970
1971         statusbar_print_all(_("Copying messages..."));
1972         for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
1973                 struct mailimap_set * seq_set;
1974                 struct mailimap_set * source = NULL;
1975                 struct mailimap_set * dest = NULL;
1976                 seq_set = cur->data;
1977
1978                 debug_print("Copying messages from %s to %s ...\n",
1979                             src->path, destdir);
1980
1981                 lock_session(session); /* unlocked later in the function */
1982                 ok = imap_cmd_copy(session, seq_set, destdir,
1983                         &source, &dest);
1984
1985                 if (is_fatal(ok)) {
1986                         session = NULL;
1987                 }
1988
1989                 if (ok == MAILIMAP_NO_ERROR) {
1990                         unlock_session(session);
1991                         if (relation && source && dest) {
1992                                 GSList *s_list = flatten_mailimap_set(source);
1993                                 GSList *d_list = flatten_mailimap_set(dest);
1994                                 GSList *s_cur, *d_cur;
1995                                 if (g_slist_length(s_list) == g_slist_length(d_list)) {
1996
1997                                         for (s_cur = s_list, d_cur = d_list;
1998                                              s_cur && d_cur;
1999                                              s_cur = s_cur->next, d_cur = d_cur->next) {
2000                                                 g_hash_table_insert(uid_hash, s_cur->data, d_cur->data);
2001                                         }
2002
2003                                 } else {
2004                                         debug_print("hhhmm, source list length != dest list length.\n");
2005                                 }
2006                                 g_slist_free(s_list);
2007                                 g_slist_free(d_list);
2008                         }
2009                 }
2010
2011
2012                 if (source)
2013                         mailimap_set_free(source);
2014                 if (dest)
2015                         mailimap_set_free(dest);
2016
2017                 if (ok != MAILIMAP_NO_ERROR) {
2018                         g_hash_table_destroy(uid_hash);
2019                         imap_lep_set_free(seq_list);
2020                         statusbar_pop_all();
2021                         return -1;
2022                 }
2023         }
2024
2025         for (cur = msglist; cur != NULL; cur = g_slist_next(cur)) {
2026                 MsgInfo *msginfo = (MsgInfo *)cur->data;
2027                 gpointer hashval;
2028
2029                 hashval = g_hash_table_lookup(uid_hash, GINT_TO_POINTER(msginfo->msgnum));
2030
2031                 if (hashval != NULL) {
2032                         gint num = GPOINTER_TO_INT(hashval);
2033                         g_hash_table_insert(relation, msginfo,
2034                                           GINT_TO_POINTER(num));
2035                         if (num > last_num)
2036                                 last_num = num;
2037                         debug_print("copied message %d as %d\n", msginfo->msgnum, num);
2038                         /* put the local file in the imapcache, so that we don't
2039                          * have to fetch it back later. */
2040                         if (num > 0) {
2041                                 gchar *cache_path = folder_item_get_path(msginfo->folder);
2042                                 gchar *real_file = g_strconcat(
2043                                         cache_path, G_DIR_SEPARATOR_S,
2044                                         itos(msginfo->msgnum), NULL);
2045                                 gchar *cache_file = NULL;
2046                                 g_free(cache_path);
2047                                 cache_path = folder_item_get_path(dest);
2048                                 cache_file = g_strconcat(
2049                                         cache_path, G_DIR_SEPARATOR_S,
2050                                         itos(num), NULL);
2051                                 if (!is_dir_exist(cache_path))
2052                                         make_dir_hier(cache_path);
2053                                 if (is_file_exist(real_file) && is_dir_exist(cache_path)) {
2054                                         if (copy_file(real_file, cache_file, TRUE) < 0)
2055                                                 debug_print("couldn't cache to %s: %s\n", cache_file,
2056                                                             strerror(errno));
2057                                         else
2058                                                 debug_print("copied to cache: %s\n", cache_file);
2059                                 }
2060                                 g_free(real_file);
2061                                 g_free(cache_file);
2062                                 g_free(cache_path);
2063                         }
2064                 } else
2065                         g_hash_table_insert(relation, msginfo,
2066                                           GINT_TO_POINTER(0));
2067         }
2068         statusbar_pop_all();
2069
2070         g_hash_table_destroy(uid_hash);
2071         imap_lep_set_free(seq_list);
2072
2073         g_free(destdir);
2074
2075         IMAP_FOLDER_ITEM(dest)->lastuid = 0;
2076         IMAP_FOLDER_ITEM(dest)->uid_next = 0;
2077         g_slist_free(IMAP_FOLDER_ITEM(dest)->uid_list);
2078         IMAP_FOLDER_ITEM(dest)->uid_list = NULL;
2079
2080         imap_scan_required(folder, dest);
2081         if (ok == MAILIMAP_NO_ERROR)
2082                 return last_num;
2083         else
2084                 return -1;
2085 }
2086
2087 static gint imap_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
2088 {
2089         GSList msglist;
2090
2091         g_return_val_if_fail(msginfo != NULL, -1);
2092
2093         msglist.data = msginfo;
2094         msglist.next = NULL;
2095
2096         return imap_copy_msgs(folder, dest, &msglist, NULL);
2097 }
2098
2099 static gint imap_copy_msgs(Folder *folder, FolderItem *dest,
2100                     MsgInfoList *msglist, GHashTable *relation)
2101 {
2102         MsgInfo *msginfo;
2103         gint ret;
2104
2105         g_return_val_if_fail(folder != NULL, -1);
2106         g_return_val_if_fail(dest != NULL, -1);
2107         g_return_val_if_fail(msglist != NULL, -1);
2108
2109         msginfo = (MsgInfo *)msglist->data;
2110         g_return_val_if_fail(msginfo->folder != NULL, -1);
2111
2112         ret = imap_do_copy_msgs(folder, dest, msglist, relation, FALSE);
2113         return ret;
2114 }
2115
2116 static gboolean imap_matcher_type_is_local(gint matchertype)
2117 {
2118         switch (matchertype) {
2119         case MATCHCRITERIA_FROM:
2120         case MATCHCRITERIA_TO:
2121         case MATCHCRITERIA_CC:
2122         case MATCHCRITERIA_TO_OR_CC:
2123         case MATCHCRITERIA_SUBJECT:
2124         case MATCHCRITERIA_REFERENCES:
2125         case MATCHCRITERIA_MESSAGEID:
2126         case MATCHCRITERIA_INREPLYTO:
2127         case MATCHCRITERIA_AGE_GREATER:
2128         case MATCHCRITERIA_AGE_LOWER:
2129         case MATCHCRITERIA_FORWARDED:
2130         case MATCHCRITERIA_SPAM:
2131         case MATCHCRITERIA_UNREAD:
2132         case MATCHCRITERIA_NEW:
2133         case MATCHCRITERIA_MARKED:
2134         case MATCHCRITERIA_REPLIED:
2135         case MATCHCRITERIA_DELETED:
2136         case MATCHCRITERIA_SIZE_GREATER:
2137         case MATCHCRITERIA_SIZE_SMALLER:
2138         case MATCHCRITERIA_SIZE_EQUAL:
2139                 return TRUE;
2140         }
2141         return FALSE;
2142 }
2143
2144 static IMAPSearchKey* search_make_key(MatcherProp* match, gboolean* is_all)
2145 {
2146         if (match->matchtype == MATCHTYPE_MATCHCASE || match->matchtype == MATCHTYPE_MATCH) {
2147                 IMAPSearchKey* result = NULL;
2148                 gboolean invert = FALSE;
2149                 gint matchertype = match->criteria;
2150
2151                 if (is_all) {
2152                         *is_all = FALSE;
2153                 }
2154
2155                 switch (matchertype) {
2156                 case MATCHCRITERIA_NOT_NEW: invert = TRUE; matchertype = MATCHCRITERIA_NEW; break;
2157                 case MATCHCRITERIA_NOT_MARKED: invert = TRUE; matchertype = MATCHCRITERIA_MARKED; break;
2158                 case MATCHCRITERIA_NOT_FORWARDED: invert = TRUE; matchertype = MATCHCRITERIA_FORWARDED; break;
2159                 case MATCHCRITERIA_NOT_SPAM: invert = TRUE; matchertype = MATCHCRITERIA_SPAM; break;
2160                 case MATCHCRITERIA_NOT_SUBJECT: invert = TRUE; matchertype = MATCHCRITERIA_SUBJECT; break;
2161                 case MATCHCRITERIA_NOT_FROM: invert = TRUE; matchertype = MATCHCRITERIA_FROM; break;
2162                 case MATCHCRITERIA_NOT_TO: invert = TRUE; matchertype = MATCHCRITERIA_TO; break;
2163                 case MATCHCRITERIA_NOT_CC: invert = TRUE; matchertype = MATCHCRITERIA_CC; break;
2164                 case MATCHCRITERIA_NOT_REFERENCES: invert = TRUE; matchertype = MATCHCRITERIA_REFERENCES; break;
2165                 case MATCHCRITERIA_NOT_HEADER: invert = TRUE; matchertype = MATCHCRITERIA_HEADER; break;
2166                 case MATCHCRITERIA_NOT_TAG: invert = TRUE; matchertype = MATCHCRITERIA_TAG; break;
2167                 case MATCHCRITERIA_NOT_HEADERS_PART: invert = TRUE; matchertype = MATCHCRITERIA_HEADERS_PART; break;
2168                 case MATCHCRITERIA_NOT_HEADERS_CONT: invert = TRUE; matchertype = MATCHCRITERIA_HEADERS_CONT; break;
2169                 case MATCHCRITERIA_NOT_MESSAGE: invert = TRUE; matchertype = MATCHCRITERIA_MESSAGE; break;
2170                 case MATCHCRITERIA_NOT_BODY_PART: invert = TRUE; matchertype = MATCHCRITERIA_BODY_PART; break;
2171                 case MATCHCRITERIA_NOT_TO_AND_NOT_CC: invert = TRUE; matchertype = MATCHCRITERIA_TO_OR_CC; break;
2172                 case MATCHCRITERIA_NOT_MESSAGEID: invert = TRUE; matchertype = MATCHCRITERIA_MESSAGEID; break;
2173                 case MATCHCRITERIA_NOT_INREPLYTO: invert = TRUE; matchertype = MATCHCRITERIA_INREPLYTO; break;
2174                 }
2175
2176                 /*
2177                  * this aborts conversion even for predicates understood by the following code.
2178                  * while that might seem wasteful, claws local search for information listed below
2179                  * has proven faster than IMAP search plus network roundtrips. once this changes,
2180                  * consider removing these exceptions.
2181                  */
2182                 if (imap_matcher_type_is_local(matchertype))
2183                         return NULL;
2184
2185                 /* the Message-ID header is also cached */
2186                 if (matchertype == MATCHCRITERIA_HEADER && g_strcmp0("Message-ID", match->header) == 0) {
2187                         return NULL;
2188                 }
2189
2190                 switch (matchertype) {
2191                 case MATCHCRITERIA_FORWARDED:
2192                         result = imap_search_new(IMAP_SEARCH_CRITERIA_TAG, NULL, RTAG_FORWARDED, 0);
2193                         break;
2194
2195                 case MATCHCRITERIA_SPAM:
2196                         result = imap_search_new(IMAP_SEARCH_CRITERIA_TAG, NULL, RTAG_JUNK, 0);
2197                         break;
2198
2199                 case MATCHCRITERIA_MESSAGEID:
2200                         result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, "Message-ID", match->expr, 0);
2201                         break;
2202
2203                 case MATCHCRITERIA_INREPLYTO:
2204                         result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, "In-Reply-To", match->expr, 0);
2205                         break;
2206
2207                 case MATCHCRITERIA_REFERENCES:
2208                         result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, "References", match->expr, 0);
2209                         break;
2210
2211                 case MATCHCRITERIA_TO_OR_CC:
2212                         result = imap_search_or(
2213                                         imap_search_new(IMAP_SEARCH_CRITERIA_TO, NULL, match->expr, 0),
2214                                         imap_search_new(IMAP_SEARCH_CRITERIA_CC, NULL, match->expr, 0)
2215                                         );
2216                         break;
2217
2218                 case MATCHCRITERIA_HEADERS_PART:
2219                 case MATCHCRITERIA_HEADERS_CONT:
2220                         result = imap_search_and(
2221                                         imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_BODY, NULL, match->expr, 0)),
2222                                         imap_search_new(IMAP_SEARCH_CRITERIA_MESSAGE, NULL, match->expr, 0)
2223                                         );
2224                         break;
2225
2226                 case MATCHCRITERIA_SIZE_EQUAL:
2227                         result = imap_search_and(
2228                                         imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_SMALLER, NULL, NULL, match->value)),
2229                                         imap_search_not(imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_GREATER, NULL, NULL, match->value))
2230                                         );
2231                         break;
2232
2233                 case MATCHCRITERIA_NOT_UNREAD:
2234                         result = imap_search_new(IMAP_SEARCH_CRITERIA_READ, NULL, NULL, 0);
2235                         break;
2236
2237                 case MATCHCRITERIA_UNREAD:
2238                         result = imap_search_new(IMAP_SEARCH_CRITERIA_UNREAD, NULL, NULL, 0);
2239                         break;
2240
2241                 case MATCHCRITERIA_NEW:
2242                         result = imap_search_new(IMAP_SEARCH_CRITERIA_NEW, NULL, NULL, 0);
2243                         break;
2244
2245                 case MATCHCRITERIA_MARKED:
2246                         result = imap_search_new(IMAP_SEARCH_CRITERIA_MARKED, NULL, NULL, 0);
2247                         break;
2248
2249                 case MATCHCRITERIA_DELETED:
2250                         result = imap_search_new(IMAP_SEARCH_CRITERIA_DELETED, NULL, NULL, 0);
2251                         break;
2252
2253                 case MATCHCRITERIA_REPLIED:
2254                         result = imap_search_new(IMAP_SEARCH_CRITERIA_REPLIED, NULL, NULL, 0);
2255                         break;
2256
2257                 case MATCHCRITERIA_TAG:
2258                         {
2259                                 gchar *tmp = imap_utf8_to_modified_utf7(match->expr, TRUE);
2260                                 result = imap_search_new(IMAP_SEARCH_CRITERIA_TAG, NULL, tmp, 0);
2261                                 g_free(tmp);
2262                         }
2263                         break;
2264
2265                 case MATCHCRITERIA_SUBJECT:
2266                         result = imap_search_new(IMAP_SEARCH_CRITERIA_SUBJECT, NULL, match->expr, 0);
2267                         break;
2268
2269                 case MATCHCRITERIA_FROM:
2270                         result = imap_search_new(IMAP_SEARCH_CRITERIA_FROM, NULL, match->expr, 0);
2271                         break;
2272
2273                 case MATCHCRITERIA_TO:
2274                         result = imap_search_new(IMAP_SEARCH_CRITERIA_TO, NULL, match->expr, 0);
2275                         break;
2276
2277                 case MATCHCRITERIA_CC:
2278                         result = imap_search_new(IMAP_SEARCH_CRITERIA_CC, NULL, match->expr, 0);
2279                         break;
2280
2281                 case MATCHCRITERIA_AGE_GREATER:
2282                         result = imap_search_new(IMAP_SEARCH_CRITERIA_AGE_GREATER, NULL, NULL, match->value);
2283                         break;
2284
2285                 case MATCHCRITERIA_AGE_LOWER:
2286                         result = imap_search_new(IMAP_SEARCH_CRITERIA_AGE_LOWER, NULL, NULL, match->value);
2287                         break;
2288
2289                 case MATCHCRITERIA_BODY_PART:
2290                         result = imap_search_new(IMAP_SEARCH_CRITERIA_BODY, NULL, match->expr, 0);
2291                         break;
2292
2293                 case MATCHCRITERIA_MESSAGE:
2294                         result = imap_search_new(IMAP_SEARCH_CRITERIA_MESSAGE, NULL, match->expr, 0);
2295                         break;
2296
2297                 case MATCHCRITERIA_HEADER:
2298                         result = imap_search_new(IMAP_SEARCH_CRITERIA_HEADER, match->header, match->expr, 0);
2299                         break;
2300
2301                 case MATCHCRITERIA_SIZE_GREATER:
2302                         result = imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_GREATER, NULL, NULL, match->value);
2303                         break;
2304
2305                 case MATCHCRITERIA_SIZE_SMALLER:
2306                         result = imap_search_new(IMAP_SEARCH_CRITERIA_SIZE_SMALLER, NULL, NULL, match->value);
2307                         break;
2308
2309                 default:
2310                         result = imap_search_new(IMAP_SEARCH_CRITERIA_ALL, NULL, NULL, 0);
2311                         if (is_all) {
2312                                 *is_all = TRUE;
2313                         }
2314                         break;
2315                 }
2316
2317                 if (invert) {
2318                         result = imap_search_not(result);
2319                         if (is_all && *is_all) {
2320                                 *is_all = FALSE;
2321                         }
2322                 }
2323
2324                 return result;
2325         }
2326
2327         return NULL;
2328 }
2329
2330 static void imap_change_search_charset(IMAPFolder *folder)
2331 {
2332         /* If server supports charset in searches, but the last used one failed,
2333          * changed to the next preferred charset. If none are still available,
2334          * disable charset searches.
2335          * Charsets are tried in the following order:
2336          * UTF-8, locale's charset, UTF-7.
2337          */
2338
2339         if (folder->search_charset_supported) {
2340                 if (folder->search_charset && !strcmp(folder->search_charset, conv_get_locale_charset_str_no_utf8()))
2341                         folder->search_charset = "UTF-8";
2342                 else if (folder->search_charset && !strcmp(folder->search_charset, "UTF-8"))
2343                         folder->search_charset = "UTF-7";
2344                 else {
2345                         folder->search_charset = NULL;
2346                         folder->search_charset_supported = FALSE;
2347                 }
2348         }
2349 }
2350
2351 static MatcherProp *imap_matcher_prop_set_charset(IMAPFolder *folder,
2352                                                   MatcherProp *utf8_prop,
2353                                                   gchar **charset)
2354 {
2355         /* If the match is going to be done locally, or the criteria is on
2356          * tag (special-cased to modified-UTF-7), or the expression searched
2357          * is ASCII, don't bother converting.
2358          */
2359         if (imap_matcher_type_is_local(utf8_prop->criteria)
2360          || utf8_prop->criteria == MATCHCRITERIA_TAG
2361          || utf8_prop->criteria == MATCHCRITERIA_NOT_TAG
2362          || utf8_prop->expr == NULL
2363          || is_ascii_str(utf8_prop->expr))
2364                 return matcherprop_new(utf8_prop->criteria,
2365                                utf8_prop->header,
2366                                utf8_prop->matchtype,
2367                                utf8_prop->expr,
2368                                utf8_prop->value);
2369         else {
2370                 gchar *conv_expr = NULL;
2371
2372                 /* If the search is server-side and the server doesn't support
2373                  * searching with the charsets we handle, bail out.
2374                  */
2375                 if (folder->search_charset_supported == FALSE)
2376                         return NULL;
2377
2378                 /* Else, convert. */
2379                 if (*charset == NULL)
2380                         *charset = g_strdup(folder->search_charset);
2381
2382                 conv_expr = conv_codeset_strdup(utf8_prop->expr, CS_UTF_8, *charset);
2383
2384                 if (conv_expr == NULL)
2385                         conv_expr = g_strdup(utf8_prop->expr);
2386
2387                 return matcherprop_new(utf8_prop->criteria,
2388                                utf8_prop->header,
2389                                utf8_prop->matchtype,
2390                                conv_expr,
2391                                utf8_prop->value);
2392         }
2393 }
2394
2395 static gint     search_msgs             (Folder                 *folder,
2396                                          FolderItem             *container,
2397                                          MsgNumberList          **msgs,
2398                                          gboolean               *on_server,
2399                                          MatcherList            *predicate,
2400                                          SearchProgressNotify   progress_cb,
2401                                          gpointer               progress_data)
2402 {
2403         IMAPSearchKey* key = NULL;
2404         GSList* cur;
2405         int result = -1;
2406         clist* uidlist = NULL;
2407         gboolean server_filtering_useless = FALSE;
2408         IMAPSession *session;
2409         gchar *charset_to_use = NULL;
2410
2411         if (on_server == NULL || !*on_server) {
2412                 return folder_item_search_msgs_local(folder, container, msgs, on_server,
2413                                 predicate, progress_cb, progress_data);
2414         }
2415
2416         for (cur = predicate->matchers; cur != NULL; cur = cur->next) {
2417                 IMAPSearchKey* matcherPart = NULL;
2418                 MatcherProp* prop = (MatcherProp*) cur->data;
2419                 gboolean is_all;
2420                 MatcherProp *imap_prop = imap_matcher_prop_set_charset(IMAP_FOLDER(folder), prop, &charset_to_use);
2421
2422                 if (imap_prop == NULL) {
2423                         /* Couldn't convert matcherprop to IMAP - probably not ascii
2424                          * and server doesn't support the charsets we do. */
2425                          return -1;
2426                 }
2427
2428                 matcherPart = search_make_key(imap_prop, &is_all);
2429
2430                 matcherprop_free(imap_prop);
2431
2432                 if (on_server) {
2433                         *on_server &= matcherPart != NULL && prop->matchtype == MATCHTYPE_MATCHCASE;
2434                 }
2435
2436                 if (matcherPart) {
2437                         if (key == NULL) {
2438                                 key = matcherPart;
2439                                 server_filtering_useless = is_all;
2440                         } else if (predicate->bool_and) {
2441                                 key = imap_search_and(key, matcherPart);
2442                                 server_filtering_useless &= is_all;
2443                         } else {
2444                                 key = imap_search_or(key, matcherPart);
2445                                 server_filtering_useless |= is_all;
2446                         }
2447                 }
2448         }
2449
2450         if (server_filtering_useless) {
2451                 imap_search_free(key);
2452                 key = NULL;
2453         }
2454
2455         if (key == NULL && progress_cb != NULL) {
2456                 GSList* cur;
2457                 GSList* list;
2458                 int count = 0;
2459
2460                 progress_cb(progress_data, TRUE, 0, 0, container->total_msgs);
2461                 progress_cb(progress_data, TRUE, container->total_msgs, 0, container->total_msgs);
2462
2463                 list = folder_item_get_msg_list(container);
2464                 for (cur = list; cur != NULL; cur = cur->next) {
2465                         *msgs = g_slist_prepend(*msgs, GUINT_TO_POINTER(((MsgInfo*) cur->data)->msgnum));
2466                         count++;
2467                 }
2468                 procmsg_msg_list_free(list);
2469
2470                 *msgs = g_slist_reverse(*msgs);
2471
2472                 return count;
2473         }
2474
2475         session = imap_session_get(folder);
2476         if (!session) {
2477                 return -1;
2478         }
2479         result = imap_select(session, IMAP_FOLDER(folder), FOLDER_ITEM(container),
2480                          NULL, NULL, NULL, NULL, NULL, TRUE);
2481         if (result != MAILIMAP_NO_ERROR)
2482                 return -1;
2483
2484         if (progress_cb)
2485                 progress_cb(progress_data, TRUE, 0, 0, container->total_msgs);
2486         result = imap_threaded_search(folder, IMAP_SEARCH_TYPE_KEYED, key, charset_to_use, NULL, &uidlist);
2487         if (progress_cb)
2488                 progress_cb(progress_data, TRUE, container->total_msgs, 0, container->total_msgs);
2489
2490         if (result == MAILIMAP_ERROR_PROTOCOL) {
2491                 debug_print("search_msgs - got protocol error, aborting\n");
2492                 imap_handle_error(SESSION(session), NULL, result);
2493                 alertpanel_error_log(_("Search failed due to server error."));
2494                 return -1;
2495         } if (result == MAILIMAP_NO_ERROR) {
2496                 gint result = 0;
2497
2498                 *msgs = imap_uid_list_from_lep(uidlist, &result);
2499
2500                 mailimap_search_result_free(uidlist);
2501
2502                 if (charset_to_use != NULL)
2503                         g_free(charset_to_use);
2504
2505                 return result;
2506         } else if (charset_to_use != NULL) {
2507                 /* If search failed and was on an 8-bit string, try the next
2508                  * available charset to search if there still are some.
2509                  */
2510                 g_free(charset_to_use);
2511
2512                 imap_change_search_charset(IMAP_FOLDER(folder));
2513                 if (IMAP_FOLDER(folder)->search_charset_supported)
2514                         return search_msgs(folder, container, msgs, on_server, predicate,
2515                                    progress_cb, progress_data);
2516                 else {
2517                         imap_handle_error(SESSION(session), NULL, result);
2518                         return -1;
2519                 }
2520         } else {
2521                 imap_handle_error(SESSION(session), NULL, result);
2522                 return -1;
2523         }
2524 }
2525
2526
2527 static gint imap_do_remove_msgs(Folder *folder, FolderItem *dest,
2528                                 MsgInfoList *msglist, GHashTable *relation)
2529 {
2530         gchar *destdir, *dir;
2531         GSList *numlist = NULL, *cur;
2532         MsgInfo *msginfo;
2533         IMAPSession *session;
2534         gint ok = MAILIMAP_NO_ERROR;
2535
2536         g_return_val_if_fail(folder != NULL, -1);
2537         g_return_val_if_fail(dest != NULL, -1);
2538         g_return_val_if_fail(msglist != NULL, -1);
2539
2540         debug_print("getting session...\n");
2541         session = imap_session_get(folder);
2542         if (!session) {
2543                 return -1;
2544         }
2545
2546         lock_session(session); /* unlocked later in the function */
2547
2548         msginfo = (MsgInfo *)msglist->data;
2549
2550         ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder,
2551                          NULL, NULL, NULL, NULL, NULL, FALSE);
2552         if (ok != MAILIMAP_NO_ERROR) {
2553                 return ok;
2554         }
2555
2556         destdir = imap_get_real_path(session, IMAP_FOLDER(folder), dest->path, &ok);
2557         if (is_fatal(ok)) {
2558                 g_free(destdir);
2559                 return ok;
2560         }
2561         for (cur = msglist; cur; cur = cur->next) {
2562                 msginfo = (MsgInfo *)cur->data;
2563                 if (!MSG_IS_DELETED(msginfo->flags))
2564                         numlist = g_slist_prepend(numlist, GINT_TO_POINTER(msginfo->msgnum));
2565         }
2566         numlist = g_slist_reverse(numlist);
2567
2568         if (numlist != NULL) {
2569                 ok = imap_set_message_flags
2570                         (session, IMAP_FOLDER_ITEM(msginfo->folder), numlist, IMAP_FLAG_DELETED, NULL, TRUE);
2571                 if (ok != MAILIMAP_NO_ERROR) {
2572                         log_warning(LOG_PROTOCOL, _("can't set deleted flags\n"));
2573                         g_free(destdir);
2574                         return ok;
2575                 }
2576         } /* else we just need to expunge */
2577         ok = imap_cmd_expunge(session);
2578         if (ok != MAILIMAP_NO_ERROR) {
2579                 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
2580                 g_free(destdir);
2581                 return ok;
2582         }
2583
2584         session->folder_content_changed = TRUE;
2585         unlock_session(session);
2586
2587         dir = folder_item_get_path(msginfo->folder);
2588         if (is_dir_exist(dir)) {
2589                 for (cur = msglist; cur; cur = cur->next) {
2590                         msginfo = (MsgInfo *)cur->data;
2591                         remove_numbered_files(dir, msginfo->msgnum, msginfo->msgnum);
2592                 }
2593         }
2594         g_free(dir);
2595
2596         g_slist_free(numlist);
2597
2598         imap_scan_required(folder, dest);
2599
2600         g_free(destdir);
2601
2602         return 0;
2603 }
2604
2605 static gint imap_remove_msgs(Folder *folder, FolderItem *dest,
2606                     MsgInfoList *msglist, GHashTable *relation)
2607 {
2608         MsgInfo *msginfo;
2609
2610         g_return_val_if_fail(folder != NULL, -1);
2611         g_return_val_if_fail(dest != NULL, -1);
2612         if (msglist == NULL)
2613                 return 0;
2614
2615         msginfo = (MsgInfo *)msglist->data;
2616         g_return_val_if_fail(msginfo->folder != NULL, -1);
2617
2618         return imap_do_remove_msgs(folder, dest, msglist, relation);
2619 }
2620
2621 static gint imap_remove_all_msg(Folder *folder, FolderItem *item)
2622 {
2623         GSList *list = folder_item_get_msg_list(item);
2624         gint res = imap_remove_msgs(folder, item, list, NULL);
2625         procmsg_msg_list_free(list);
2626         return res;
2627 }
2628
2629 static gboolean imap_is_msg_changed(Folder *folder, FolderItem *item,
2630                                     MsgInfo *msginfo)
2631 {
2632         /* TODO: properly implement this method */
2633         return FALSE;
2634 }
2635
2636 static gint imap_close(Folder *folder, FolderItem *item)
2637 {
2638         return 0;
2639 }
2640
2641 static gint imap_scan_tree_real(Folder *folder, gboolean subs_only)
2642 {
2643         FolderItem *item = NULL;
2644         IMAPSession *session;
2645         gchar *root_folder = NULL;
2646
2647         g_return_val_if_fail(folder != NULL, -1);
2648         g_return_val_if_fail(folder->account != NULL, -1);
2649
2650         debug_print("getting session...\n");
2651         session = imap_session_get(folder);
2652         if (!session) {
2653                 if (!folder->node) {
2654                         folder_tree_destroy(folder);
2655                         item = folder_item_new(folder, folder->name, NULL);
2656                         item->folder = folder;
2657                         folder->node = item->node = g_node_new(item);
2658                 }
2659                 return -1;
2660         }
2661
2662         if (folder->account->imap_dir && *folder->account->imap_dir) {
2663                 gchar *real_path;
2664                 int r = MAILIMAP_NO_ERROR;
2665                 clist * lep_list;
2666
2667                 Xstrdup_a(root_folder, folder->account->imap_dir, {return -1;});
2668                 extract_quote(root_folder, '"');
2669                 subst_char(root_folder,
2670                            imap_get_path_separator(session, IMAP_FOLDER(folder),
2671                                                    root_folder, &r),
2672                            '/');
2673                 if (is_fatal(r))
2674                         return -1;
2675                 strtailchomp(root_folder, '/');
2676                 real_path = imap_get_real_path
2677                         (session, IMAP_FOLDER(folder), root_folder, &r);
2678                 if (is_fatal(r)) {
2679                         g_free(real_path);
2680                         return -1;
2681                 }
2682                 debug_print("IMAP root directory: %s\n", real_path);
2683
2684                 /* check if root directory exist */
2685
2686                 r = imap_threaded_list(session->folder, "", real_path,
2687                                        &lep_list);
2688
2689                 if (r != MAILIMAP_NO_ERROR)
2690                         imap_handle_error(SESSION(session), NULL, r);
2691
2692                 if ((r != MAILIMAP_NO_ERROR) || (clist_count(lep_list) == 0)) {
2693                         if (!folder->node) {
2694                                 item = folder_item_new(folder, folder->name, NULL);
2695                                 item->folder = folder;
2696                                 folder->node = item->node = g_node_new(item);
2697                         }
2698                         return -1;
2699                 }
2700                 mailimap_list_result_free(lep_list);
2701
2702                 g_free(real_path);
2703         }
2704
2705         if (folder->node)
2706                 item = FOLDER_ITEM(folder->node->data);
2707
2708         if (item && !item->path && root_folder) {
2709                 item->path = g_strdup(root_folder);
2710         }
2711
2712         if (!item || ((item->path || root_folder) &&
2713                       g_strcmp0(item->path, root_folder) != 0)) {
2714                 folder_tree_destroy(folder);
2715                 item = folder_item_new(folder, folder->name, root_folder);
2716                 item->folder = folder;
2717                 folder->node = item->node = g_node_new(item);
2718         }
2719
2720         imap_scan_tree_recursive(session, FOLDER_ITEM(folder->node->data), subs_only);
2721         imap_create_missing_folders(folder);
2722
2723         return 0;
2724 }
2725
2726 static gint imap_scan_tree(Folder *folder)
2727 {
2728         gboolean subs_only = FALSE;
2729         if (folder->account) {
2730                 debug_print(" scanning only subs %d\n", folder->account->imap_subsonly);
2731                 subs_only = folder->account->imap_subsonly;
2732         }
2733         return imap_scan_tree_real(folder, subs_only);
2734 }
2735
2736 static gint imap_scan_tree_recursive(IMAPSession *session, FolderItem *item, gboolean subs_only)
2737 {
2738         Folder *folder;
2739         IMAPFolder *imapfolder;
2740         FolderItem *new_item;
2741         GSList *item_list, *cur;
2742         GNode *node;
2743         gchar *real_path;
2744         gchar *wildcard_path;
2745         gchar separator;
2746         gchar wildcard[3];
2747         clist * lep_list;
2748         int r = MAILIMAP_NO_ERROR;
2749
2750         g_return_val_if_fail(item != NULL, -1);
2751         g_return_val_if_fail(item->folder != NULL, -1);
2752         g_return_val_if_fail(item->no_sub == FALSE, -1);
2753
2754         folder = item->folder;
2755         imapfolder = IMAP_FOLDER(folder);
2756
2757         separator = imap_get_path_separator(session, imapfolder, item->path, &r);
2758         if (is_fatal(r))
2759                 return r;
2760
2761         if (folder->ui_func)
2762                 folder->ui_func(folder, item, folder->ui_func_data);
2763
2764         if (item->path) {
2765                 wildcard[0] = separator;
2766                 wildcard[1] = '%';
2767                 wildcard[2] = '\0';
2768                 real_path = imap_get_real_path(session, imapfolder, item->path, &r);
2769                 if (is_fatal(r)) {
2770                         g_free(real_path);
2771                         return r;
2772                 }
2773         } else {
2774                 wildcard[0] = '%';
2775                 wildcard[1] = '\0';
2776                 real_path = g_strdup("");
2777         }
2778
2779         Xstrcat_a(wildcard_path, real_path, wildcard,
2780                   {g_free(real_path); return MAILIMAP_ERROR_BAD_STATE;});
2781         lep_list = NULL;
2782
2783         if (subs_only)
2784                 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
2785         else
2786                 r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
2787
2788         if (r != MAILIMAP_NO_ERROR) {
2789                 imap_handle_error(SESSION(session), NULL, r);
2790                 item_list = NULL;
2791                 g_free(real_path);
2792                 return r;
2793         }
2794         else {
2795                 item_list = imap_list_from_lep(imapfolder,
2796                                                lep_list, real_path, FALSE);
2797                 mailimap_list_result_free(lep_list);
2798         }
2799
2800         g_free(real_path);
2801
2802         node = item->node->children;
2803         while (node != NULL) {
2804                 FolderItem *old_item = FOLDER_ITEM(node->data);
2805                 GNode *next = node->next;
2806
2807                 new_item = NULL;
2808                 for (cur = item_list; cur != NULL; cur = cur->next) {
2809                         FolderItem *cur_item = FOLDER_ITEM(cur->data);
2810                         if (!g_strcmp0(old_item->path, cur_item->path)) {
2811                                 new_item = cur_item;
2812                                 break;
2813                         }
2814                 }
2815                 if (!new_item) {
2816                         if (old_item && old_item->path && !strcasecmp(old_item->path, "INBOX")) {
2817                                 debug_print("not removing INBOX\n");
2818                         } else {
2819                                 debug_print("folder '%s' not found. removing...\n",
2820                                             old_item->path);
2821                                 folder_item_remove(old_item);
2822                         }
2823                 } else {
2824                         old_item->no_sub = new_item->no_sub;
2825                         old_item->no_select = new_item->no_select;
2826                         if (old_item->no_sub == TRUE && node->children) {
2827                                 debug_print("folder '%s' doesn't have "
2828                                             "subfolders. removing...\n",
2829                                             old_item->path);
2830                                 folder_item_remove_children(old_item);
2831                         }
2832                 }
2833
2834                 node = next;
2835         }
2836
2837         for (cur = item_list; cur != NULL; cur = cur->next) {
2838                 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2839                 new_item = NULL;
2840
2841                 for (node = item->node->children; node != NULL;
2842                      node = node->next) {
2843                         if (!g_strcmp0(FOLDER_ITEM(node->data)->path,
2844                                      cur_item->path)) {
2845                                 new_item = FOLDER_ITEM(node->data);
2846                                 folder_item_destroy(cur_item);
2847                                 cur_item = NULL;
2848                                 break;
2849                         }
2850                 }
2851                 if (!new_item) {
2852                         new_item = cur_item;
2853                         debug_print("new folder '%s' found.\n", new_item->path);
2854                         folder_item_append(item, new_item);
2855                 }
2856
2857                 if (!strcasecmp(new_item->path, "INBOX")) {
2858                         new_item->stype = F_INBOX;
2859                         folder->inbox = new_item;
2860                 } else if (!folder_item_parent(item) || item->stype == F_INBOX) {
2861                         gchar *base;
2862
2863                         base = g_path_get_basename(new_item->path);
2864
2865                         if (!folder->outbox && !g_ascii_strcasecmp(base, "Sent")) {
2866                                 new_item->stype = F_OUTBOX;
2867                                 folder->outbox = new_item;
2868                         } else if (!folder->draft && (!g_ascii_strcasecmp(base, "Drafts") || !g_ascii_strcasecmp(base, "Draft"))) {
2869                                 new_item->stype = F_DRAFT;
2870                                 folder->draft = new_item;
2871                         } else if (!folder->queue && !g_ascii_strcasecmp(base, "Queue")) {
2872                                 new_item->stype = F_QUEUE;
2873                                 folder->queue = new_item;
2874                         } else if (!folder->trash && !g_ascii_strcasecmp(base, "Trash")) {
2875                                 new_item->stype = F_TRASH;
2876                                 folder->trash = new_item;
2877                         }
2878                         g_free(base);
2879                 }
2880
2881                 if (new_item->no_sub == FALSE)
2882                         imap_scan_tree_recursive(session, new_item, subs_only);
2883         }
2884
2885         g_slist_free(item_list);
2886
2887         return MAILIMAP_NO_ERROR;
2888 }
2889
2890 GList *imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
2891 {
2892         IMAPSession *session = imap_session_get(folder);
2893         gchar *real_path;
2894         gchar *wildcard_path;
2895         gchar separator;
2896         gchar wildcard[3];
2897         clist * lep_list;
2898         GSList *item_list = NULL, *cur;
2899         GList *child_list = NULL, *tmplist = NULL;
2900         GSList *sub_list = NULL;
2901         int r = MAILIMAP_NO_ERROR;
2902
2903         if (!session)
2904                 return NULL;
2905
2906         separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &r);
2907         if (is_fatal(r))
2908                 return NULL;
2909
2910         if (item->path) {
2911                 wildcard[0] = separator;
2912                 wildcard[1] = '%';
2913                 wildcard[2] = '\0';
2914                 real_path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
2915                 if (is_fatal(r)) {
2916                         g_free(real_path);
2917                         return NULL;
2918                 }
2919         } else {
2920                 wildcard[0] = '%';
2921                 wildcard[1] = '\0';
2922                 real_path = g_strdup("");
2923         }
2924
2925         Xstrcat_a(wildcard_path, real_path, wildcard,
2926                   {g_free(real_path); return NULL;});
2927         lep_list = NULL;
2928
2929         if (unsubs_only)
2930                 statusbar_print_all(_("Looking for unsubscribed folders in %s..."),
2931                                 item->path?item->path:item->name);
2932         else
2933                 statusbar_print_all(_("Looking for subfolders of %s..."),
2934                                 item->path?item->path:item->name);
2935
2936         r = imap_threaded_list(folder, "", wildcard_path, &lep_list);
2937         if (r) {
2938                 g_free(real_path);
2939                 statusbar_pop_all();
2940                 return NULL;
2941         }
2942         item_list = imap_list_from_lep(IMAP_FOLDER(folder),
2943                                lep_list, real_path, FALSE);
2944         mailimap_list_result_free(lep_list);
2945
2946         for (cur = item_list; cur != NULL; cur = cur->next) {
2947                 FolderItem *cur_item = FOLDER_ITEM(cur->data);
2948                 if (recursive) {
2949                         tmplist = imap_scan_subtree(folder, cur_item,
2950                                         unsubs_only, recursive);
2951                         if (tmplist)
2952                                 child_list = g_list_concat(child_list, tmplist);
2953                 }
2954                 child_list = g_list_prepend(child_list,
2955                                 imap_get_real_path(session,
2956                                         IMAP_FOLDER(folder), cur_item->path, &r));
2957                 if (is_fatal(r)) {
2958                         g_free(real_path);
2959                         statusbar_pop_all();
2960                         return NULL;
2961                 }
2962                 folder_item_destroy(cur_item);
2963         }
2964         child_list = g_list_reverse(child_list);
2965         g_slist_free(item_list);
2966
2967         if (unsubs_only) {
2968                 r = imap_threaded_lsub(folder, "", wildcard_path, &lep_list);
2969                 if (r) {
2970                         g_free(real_path);
2971                         statusbar_pop_all();
2972                         return NULL;
2973                 }
2974                 sub_list = imap_list_from_lep(IMAP_FOLDER(folder),
2975                                        lep_list, real_path, FALSE);
2976                 mailimap_list_result_free(lep_list);
2977
2978                 for (cur = sub_list; cur != NULL; cur = cur->next) {
2979                         FolderItem *cur_item = FOLDER_ITEM(cur->data);
2980                         GList *oldlitem = NULL;
2981                         gchar *tmp = imap_get_real_path(session,
2982                                         IMAP_FOLDER(folder), cur_item->path, &r);
2983                         if (r) {
2984                                 g_free(real_path);
2985                                 statusbar_pop_all();
2986                                 g_free(tmp);
2987                                 return NULL;
2988                         }
2989                         folder_item_destroy(cur_item);
2990                         oldlitem = g_list_find_custom(
2991                                         child_list, tmp, (GCompareFunc)g_strcmp0);
2992                         if (oldlitem) {
2993                                 child_list = g_list_remove_link(child_list, oldlitem);
2994                                 g_free(oldlitem->data);
2995                                 g_list_free(oldlitem);
2996                         }
2997                         g_free(tmp);
2998                 }
2999         }
3000
3001         g_free(real_path);
3002         statusbar_pop_all();
3003
3004         return child_list;
3005 }
3006
3007 static gint imap_create_tree(Folder *folder)
3008 {
3009         g_return_val_if_fail(folder != NULL, -1);
3010         g_return_val_if_fail(folder->node != NULL, -1);
3011         g_return_val_if_fail(folder->node->data != NULL, -1);
3012         g_return_val_if_fail(folder->account != NULL, -1);
3013
3014         imap_scan_tree(folder);
3015         imap_create_missing_folders(folder);
3016
3017         return 0;
3018 }
3019
3020 static void imap_create_missing_folders(Folder *folder)
3021 {
3022         g_return_if_fail(folder != NULL);
3023
3024         if (!folder->inbox)
3025                 folder->inbox = imap_create_special_folder
3026                         (folder, F_INBOX, "INBOX");
3027         if (!folder->trash)
3028                 folder->trash = imap_create_special_folder
3029                         (folder, F_TRASH, "Trash");
3030         if (!folder->queue)
3031                 folder->queue = imap_create_special_folder
3032                         (folder, F_QUEUE, "Queue");
3033         if (!folder->outbox)
3034                 folder->outbox = imap_create_special_folder
3035                         (folder, F_OUTBOX, "Sent");
3036         if (!folder->draft)
3037                 folder->draft = imap_create_special_folder
3038                         (folder, F_DRAFT, "Drafts");
3039 }
3040
3041 static FolderItem *imap_create_special_folder(Folder *folder,
3042                                               SpecialFolderItemType stype,
3043                                               const gchar *name)
3044 {
3045         FolderItem *item;
3046         FolderItem *new_item;
3047
3048         g_return_val_if_fail(folder != NULL, NULL);
3049         g_return_val_if_fail(folder->node != NULL, NULL);
3050         g_return_val_if_fail(folder->node->data != NULL, NULL);
3051         g_return_val_if_fail(folder->account != NULL, NULL);
3052         g_return_val_if_fail(name != NULL, NULL);
3053
3054         item = FOLDER_ITEM(folder->node->data);
3055         new_item = imap_create_folder(folder, item, name);
3056
3057         if (!new_item) {
3058                 g_warning("Can't create '%s'", name);
3059                 if (!folder->inbox) return NULL;
3060
3061                 new_item = imap_create_folder(folder, folder->inbox, name);
3062                 if (!new_item)
3063                         g_warning("Can't create '%s' under INBOX", name);
3064                 else
3065                         new_item->stype = stype;
3066         } else
3067                 new_item->stype = stype;
3068
3069         return new_item;
3070 }
3071
3072 #ifdef G_OS_WIN32
3073 static gchar *imap_encode_unsafe_chars(const gchar *str)
3074 {
3075         gchar *ret = NULL, *o_ret;
3076         gchar *i;
3077         if (!str)
3078                 return NULL;
3079         ret = g_malloc(3*strlen(str)+1);
3080         o_ret = ret;
3081         for (i = (gchar *)str; *i; i++) {
3082                 switch(*i) {
3083                         case ':':
3084                         case '|':
3085                         case '<':
3086                         case '>':
3087                         case '*':
3088                         case '?':
3089                         case '#':
3090                                 *ret++ = '%';
3091                                 *ret++ = '0'+(*i/10);
3092                                 *ret++ = '0'+(*i%10);
3093                                 break;
3094                         default:
3095                                 *ret++ = *i;
3096                 }
3097         }
3098         *ret++ = '\0';
3099         return o_ret;
3100 }
3101 #endif
3102 static gchar *imap_item_get_path(Folder *folder, FolderItem *item)
3103 {
3104         gchar *folder_path, *path;
3105         gchar *item_path = NULL;
3106
3107         g_return_val_if_fail(folder != NULL, NULL);
3108         g_return_val_if_fail(folder->account != NULL, NULL);
3109         g_return_val_if_fail(item != NULL, NULL);
3110         folder_path = prefs_account_cache_dir(folder->account, FALSE);
3111
3112         g_return_val_if_fail(folder_path != NULL, NULL);
3113
3114 #ifdef G_OS_UNIX
3115         item_path = g_strdup(item->path);
3116 #else
3117         item_path = imap_encode_unsafe_chars(item->path);
3118 #endif
3119
3120         if (g_path_is_absolute(folder_path)) {
3121                 if (item_path)
3122                         path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
3123                                            item_path, NULL);
3124                 else
3125                         path = g_strdup(folder_path);
3126         } else {
3127                 if (item_path)
3128                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
3129                                            folder_path, G_DIR_SEPARATOR_S,
3130                                            item_path, NULL);
3131                 else
3132                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
3133                                            folder_path, NULL);
3134         }
3135         g_free(folder_path);
3136         g_free(item_path);
3137 #ifdef G_OS_WIN32
3138         while (strchr(path, '/'))
3139                 *strchr(path, '/') = '\\';
3140 #endif
3141
3142         return path;
3143 }
3144
3145 static FolderItem *imap_create_folder(Folder *folder, FolderItem *parent,
3146                                const gchar *name)
3147 {
3148         gchar *dirpath, *imap_path;
3149         IMAPSession *session;
3150         FolderItem *new_item;
3151         gchar separator;
3152         gchar *new_name;
3153         const gchar *p;
3154         gint ok = MAILIMAP_NO_ERROR;
3155         gboolean no_select = FALSE, no_sub = FALSE;
3156         gboolean exist = FALSE;
3157
3158         g_return_val_if_fail(folder != NULL, NULL);
3159         g_return_val_if_fail(folder->account != NULL, NULL);
3160         g_return_val_if_fail(parent != NULL, NULL);
3161         g_return_val_if_fail(name != NULL, NULL);
3162
3163         if (to_number(name) > 0) {
3164                 gchar *cached_msg = imap_get_cached_filename(parent, to_number(name));
3165                 if (is_file_exist(cached_msg)) {
3166                         if (claws_unlink(cached_msg) != 0) {
3167                                 return NULL;
3168                         }
3169                 }
3170         }
3171
3172         debug_print("getting session...\n");
3173         session = imap_session_get(folder);
3174         if (!session) {
3175                 return NULL;
3176         }
3177
3178         if (!folder_item_parent(parent) && strcasecmp(name, "INBOX") == 0) {
3179                 dirpath = g_strdup(name);
3180         }else if (parent->path)
3181                 dirpath = g_strconcat(parent->path, "/", name, NULL);
3182         else if ((p = strchr(name, '/')) != NULL && *(p + 1) != '\0')
3183                 dirpath = g_strdup(name);
3184         else if (folder->account->imap_dir && *folder->account->imap_dir) {
3185                 gchar *imap_dir;
3186
3187                 Xstrdup_a(imap_dir, folder->account->imap_dir, {return NULL;});
3188                 strtailchomp(imap_dir, '/');
3189                 dirpath = g_strconcat(imap_dir, "/", name, NULL);
3190         } else
3191                 dirpath = g_strdup(name);
3192
3193
3194
3195         /* keep trailing directory separator to create a folder that contains
3196            sub folder */
3197         imap_path = imap_utf8_to_modified_utf7(dirpath, FALSE);
3198
3199         strtailchomp(dirpath, '/');
3200         Xstrdup_a(new_name, name, {
3201                 g_free(dirpath);
3202                 g_free(imap_path);
3203                 return NULL;});
3204
3205         separator = imap_get_path_separator(session, IMAP_FOLDER(folder), imap_path, &ok);
3206         if (is_fatal(ok)) {
3207                 g_free(imap_path);
3208                 return NULL;
3209         }
3210         imap_path_separator_subst(imap_path, separator);
3211         /* remove trailing / for display */
3212         strtailchomp(new_name, '/');
3213
3214         if (strcasecmp(dirpath, "INBOX") != 0) {
3215                 int r;
3216                 clist * lep_list;
3217
3218                 r = imap_threaded_list(folder, "", imap_path, &lep_list);
3219                 if (r != MAILIMAP_NO_ERROR) {
3220                         imap_handle_error(SESSION(session), NULL, r);
3221                         log_warning(LOG_PROTOCOL, _("can't create mailbox: LIST failed\n"));
3222                         g_free(imap_path);
3223                         g_free(dirpath);
3224                         return NULL;
3225                 }
3226
3227                 if (clist_count(lep_list) > 0)
3228                         exist = TRUE;
3229                 mailimap_list_result_free(lep_list);
3230                 lep_list = NULL;
3231                 if (!exist) {
3232                         ok = imap_cmd_create(session, imap_path);
3233                         if (ok != MAILIMAP_NO_ERROR) {
3234                                 log_warning(LOG_PROTOCOL, _("can't create mailbox\n"));
3235                                 g_free(imap_path);
3236                                 g_free(dirpath);
3237                                 return NULL;
3238                         }
3239                         r = imap_threaded_list(folder, "", imap_path, &lep_list);
3240                         if (r == MAILIMAP_NO_ERROR) {
3241                                 GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
3242                                                lep_list, dirpath, TRUE);
3243                                 if (item_list) {
3244                                         FolderItem *cur_item = FOLDER_ITEM(item_list->data);
3245                                         no_select = cur_item->no_select;
3246                                         no_sub = cur_item->no_sub;
3247                                         g_slist_free(item_list);
3248                                 }
3249                                 mailimap_list_result_free(lep_list);
3250                         } else {
3251                                 imap_handle_error(SESSION(session), NULL, r);
3252                         }
3253                 }
3254                 imap_threaded_subscribe(folder, imap_path, TRUE);
3255         } else {
3256                 clist *lep_list;
3257                 int r;
3258                 /* just get flags */
3259                 r = imap_threaded_list(folder, "", "INBOX", &lep_list);
3260                 if (r == MAILIMAP_NO_ERROR) {
3261                         GSList *item_list = imap_list_from_lep(IMAP_FOLDER(folder),
3262                                        lep_list, dirpath, TRUE);
3263                         if (item_list) {
3264                                 FolderItem *cur_item = FOLDER_ITEM(item_list->data);
3265                                 no_select = cur_item->no_select;
3266                                 no_sub = cur_item->no_sub;
3267                                 g_slist_free(item_list);
3268                         }
3269                         mailimap_list_result_free(lep_list);
3270                 } else {
3271                         imap_handle_error(SESSION(session), NULL, r);
3272                 }
3273         }
3274
3275         new_item = folder_item_new(folder, new_name, dirpath);
3276         new_item->no_select = no_select;
3277         new_item->no_sub = no_sub;
3278         folder_item_append(parent, new_item);
3279         g_free(imap_path);
3280         g_free(dirpath);
3281
3282         dirpath = folder_item_get_path(new_item);
3283         if (!is_dir_exist(dirpath))
3284                 make_dir_hier(dirpath);
3285         g_free(dirpath);
3286
3287         if (exist) {
3288                 /* folder existed, scan it */
3289                 imap_scan_required(folder, new_item);
3290                 folder_item_scan_full(new_item, FALSE);
3291         }
3292
3293         return new_item;
3294 }
3295
3296 static gint imap_rename_folder(Folder *folder, FolderItem *item,
3297                                const gchar *name)
3298 {
3299         gchar *dirpath;
3300         gchar *newpath;
3301         gchar *real_oldpath;
3302         gchar *real_newpath;
3303         gchar *paths[2];
3304         gchar *old_cache_dir;
3305         gchar *new_cache_dir;
3306         IMAPSession *session;
3307         gchar separator;
3308         gint ok = MAILIMAP_NO_ERROR;
3309         gint exists, recent, unseen;
3310         guint32 uid_validity;
3311
3312         g_return_val_if_fail(folder != NULL, -1);
3313         g_return_val_if_fail(item != NULL, -1);
3314         g_return_val_if_fail(item->path != NULL, -1);
3315         g_return_val_if_fail(name != NULL, -1);
3316
3317         debug_print("getting session...\n");
3318         session = imap_session_get(folder);
3319         if (!session) {
3320                 return -1;
3321         }
3322
3323         if (strchr(name, imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &ok)) != NULL ||
3324                 is_fatal(ok)) {
3325                 g_warning("New folder name must not contain the namespace "
3326                             "path separator");
3327                 return -1;
3328         }
3329
3330         real_oldpath = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &ok);
3331         if (is_fatal(ok)) {
3332                 g_free(real_oldpath);
3333                 return -1;
3334         }
3335
3336         g_free(session->mbox);
3337         session->mbox = NULL;
3338         session->exists = 0;
3339         session->recent = 0;
3340         session->expunge = 0;
3341         ok = imap_cmd_examine(session, "INBOX",
3342                               &exists, &recent, &unseen, &uid_validity, FALSE);
3343         if (ok != MAILIMAP_NO_ERROR) {
3344                 g_free(real_oldpath);
3345                 return -1;
3346         }
3347
3348         separator = imap_get_path_separator(session, IMAP_FOLDER(folder), item->path, &ok);
3349         if (is_fatal(ok)) {
3350                 g_free(real_oldpath);
3351                 return -1;
3352         }
3353         if (strchr(item->path, '/')) {
3354                 dirpath = g_path_get_dirname(item->path);
3355                 newpath = g_strconcat(dirpath, "/", name, NULL);
3356                 g_free(dirpath);
3357         } else
3358                 newpath = g_strdup(name);
3359
3360         real_newpath = imap_utf8_to_modified_utf7(newpath, FALSE);
3361         imap_path_separator_subst(real_newpath, separator);
3362
3363         ok = imap_cmd_rename(session, real_oldpath, real_newpath);
3364         if (ok != MAILIMAP_NO_ERROR) {
3365                 log_warning(LOG_PROTOCOL, _("can't rename mailbox: %s to %s\n"),
3366                             real_oldpath, real_newpath);
3367                 g_free(real_oldpath);
3368                 g_free(newpath);
3369                 g_free(real_newpath);
3370                 return -1;
3371         }
3372         g_free(item->name);
3373         item->name = g_strdup(name);
3374
3375         old_cache_dir = folder_item_get_path(item);
3376
3377         paths[0] = g_strdup(item->path);
3378         paths[1] = newpath;
3379         g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
3380                         imap_rename_folder_func, paths);
3381
3382         if (is_dir_exist(old_cache_dir)) {
3383                 new_cache_dir = folder_item_get_path(item);
3384                 if (g_rename(old_cache_dir, new_cache_dir) < 0) {
3385                         FILE_OP_ERROR(old_cache_dir, "rename");
3386                 }
3387                 g_free(new_cache_dir);
3388         }
3389
3390         g_free(old_cache_dir);
3391         g_free(paths[0]);
3392         g_free(newpath);
3393         g_free(real_oldpath);
3394         g_free(real_newpath);
3395         return 0;
3396 }
3397
3398 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
3399 {
3400         gchar *path;
3401         gint r = MAILIMAP_NO_ERROR;
3402         IMAPSession *session;
3403         debug_print("getting session...\n");
3404
3405         session = imap_session_get(folder);
3406         if (!session) {
3407                 return -1;
3408         }
3409         if (item && item->path) {
3410                 path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &r);
3411                 if (!path)
3412                         return -1;
3413                 if (is_fatal(r)) {
3414                         g_free(path);
3415                         return -1;
3416                 }
3417                 if (!strcasecmp(path, "INBOX") && sub == FALSE) {
3418                         g_free(path);
3419                         return -1;
3420                 }
3421                 debug_print("%ssubscribing %s\n", sub?"":"un", path);
3422                 r = imap_threaded_subscribe(folder, path, sub);
3423                 g_free(path);
3424         } else if (rpath) {
3425                 r = imap_threaded_subscribe(folder, rpath, sub);
3426         } else
3427                 return -1;
3428         return r;
3429 }
3430
3431 static gint imap_remove_folder_real(Folder *folder, FolderItem *item)
3432 {
3433         gint ok = MAILIMAP_NO_ERROR;
3434         IMAPSession *session;
3435         gchar *path;
3436         gchar *cache_dir;
3437         gboolean selected_folder;
3438
3439         g_return_val_if_fail(folder != NULL, -1);
3440         g_return_val_if_fail(item != NULL, -1);
3441         g_return_val_if_fail(item->path != NULL, -1);
3442
3443         debug_print("getting session...\n");
3444         session = imap_session_get(folder);
3445         if (!session) {
3446                 return -1;
3447         }
3448         path = imap_get_real_path(session, IMAP_FOLDER(folder), item->path, &ok);
3449         if (is_fatal(ok)) {
3450                 g_free(path);
3451                 return -1;
3452         }
3453         imap_threaded_subscribe(folder, path, FALSE);
3454
3455         selected_folder = (session->mbox != NULL) &&
3456                           (!strcmp(session->mbox, item->path));
3457         if (selected_folder) {
3458                 ok = imap_cmd_close(session);
3459                 if (ok != MAILIMAP_NO_ERROR) {
3460                         debug_print("close err %d\n", ok);
3461                         return ok;
3462                 }
3463         }
3464         ok = imap_cmd_delete(session, path);
3465         if (ok != MAILIMAP_NO_ERROR && !is_fatal(ok)) {
3466                 gchar *tmp = NULL;
3467
3468                 ok = MAILIMAP_NO_ERROR;
3469                 tmp = g_strdup_printf("%s%c", path,
3470                                 imap_get_path_separator(session, IMAP_FOLDER(folder), path, &ok));
3471                 g_free(path);
3472                 path = tmp;
3473                 if (!is_fatal(ok))
3474                         ok = imap_cmd_delete(session, path);
3475         }
3476
3477         if (ok != MAILIMAP_NO_ERROR) {
3478                 log_warning(LOG_PROTOCOL, _("can't delete mailbox\n"));
3479                 g_free(path);
3480                 return -1;
3481         }
3482
3483         g_free(path);
3484         cache_dir = folder_item_get_path(item);
3485         if (is_dir_exist(cache_dir) && remove_dir_recursive(cache_dir) < 0)
3486                 g_warning("can't remove directory '%s'", cache_dir);
3487         g_free(cache_dir);
3488         folder_item_remove(item);
3489         return 0;
3490 }
3491
3492 static gint imap_remove_folder(Folder *folder, FolderItem *item)
3493 {
3494         GNode *node, *next;
3495
3496         g_return_val_if_fail(item != NULL, -1);
3497         g_return_val_if_fail(item->folder != NULL, -1);
3498         g_return_val_if_fail(item->node != NULL, -1);
3499
3500         node = item->node->children;
3501         while (node != NULL) {
3502                 next = node->next;
3503                 if (imap_remove_folder(folder, FOLDER_ITEM(node->data)) < 0)
3504                         return -1;
3505                 node = next;
3506         }
3507         debug_print("IMAP removing %s\n", item->path);
3508
3509         if (imap_remove_all_msg(folder, item) < 0)
3510                 return -1;
3511         return imap_remove_folder_real(folder, item);
3512 }
3513
3514 typedef struct _uncached_data {
3515         IMAPSession *session;
3516         FolderItem *item;
3517         MsgNumberList *numlist;
3518         guint cur;
3519         guint total;
3520         gboolean done;
3521         int ok;
3522 } uncached_data;
3523
3524 static void *imap_get_uncached_messages_thread(void *data)
3525 {
3526         uncached_data *stuff = (uncached_data *)data;
3527         IMAPSession *session = stuff->session;
3528         FolderItem *item = stuff->item;
3529         MsgNumberList *numlist = stuff->numlist;
3530         GSList *newlist = NULL;
3531         GSList *llast = NULL;
3532         GSList *seq_list, *cur;
3533         gboolean got_alien_tags = FALSE;
3534
3535         debug_print("uncached_messages\n");
3536
3537         if (session == NULL || item == NULL || item->folder == NULL
3538             || FOLDER_CLASS(item->folder) != &imap_class) {
3539                 stuff->done = TRUE;
3540                 return NULL;
3541         }
3542
3543         seq_list = imap_get_lep_set_from_numlist(IMAP_FOLDER(item->folder), numlist);
3544         debug_print("get msgs info\n");
3545         for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
3546                 struct mailimap_set * imapset;
3547                 unsigned int i;
3548                 int r;
3549                 carray * env_list;
3550                 int count;
3551
3552                 if (session->cancelled)
3553                         break;
3554
3555                 imapset = cur->data;
3556
3557                 r = imap_threaded_fetch_env(session->folder,
3558                                             imapset, &env_list);
3559                 if (r != MAILIMAP_NO_ERROR) {
3560                         imap_handle_error(SESSION(session), NULL, r);
3561                         if (is_fatal(r)) {
3562                                 stuff->ok = r;
3563                                 return NULL;
3564                         }
3565                         continue;
3566                 }
3567
3568                 session_set_access_time(SESSION(session));
3569
3570                 count = 0;
3571                 for(i = 0 ; i < carray_count(env_list) ; i += 2) {
3572                         struct imap_fetch_env_info * info;
3573                         MsgInfo * msginfo;
3574                         GSList *tags = NULL, *cur = NULL;
3575                         info = carray_get(env_list, i);
3576                         tags = carray_get(env_list, i+1);
3577                         msginfo = imap_envelope_from_lep(info, item);
3578                         if (msginfo == NULL) {
3579                                 slist_free_strings_full(tags);
3580                                 continue;
3581                         }
3582                         g_slist_free(msginfo->tags);
3583                         msginfo->tags = NULL;
3584
3585                         for (cur = tags; cur; cur = cur->next) {
3586                                 gchar *real_tag = imap_modified_utf7_to_utf8(cur->data, TRUE);
3587                                 gint id = 0;
3588                                 id = tags_get_id_for_str(real_tag);
3589                                 if (id == -1) {
3590                                         id = tags_add_tag(real_tag);
3591                                         got_alien_tags = TRUE;
3592                                 }
3593                                 if (!g_slist_find(msginfo->tags, GINT_TO_POINTER(id))) {
3594                                         msginfo->tags = g_slist_prepend(
3595                                                         msginfo->tags,
3596                                                         GINT_TO_POINTER(id));
3597                                 }
3598                                 g_free(real_tag);
3599                         }
3600                         if (msginfo->tags)
3601                                 msginfo->tags = g_slist_reverse(msginfo->tags);
3602                         slist_free_strings_full(tags);
3603                         msginfo->folder = item;
3604                         if (!newlist)
3605                                 llast = newlist = g_slist_append(newlist, msginfo);
3606                         else {
3607                                 llast = g_slist_append(llast, msginfo);
3608                                 llast = llast->next;
3609                         }
3610                         count ++;
3611                 }
3612
3613                 imap_fetch_env_free(env_list);
3614         }
3615
3616         if (got_alien_tags) {
3617                 tags_write_tags();
3618                 main_window_reflect_tags_changes(mainwindow_get_mainwindow());
3619         }
3620
3621         imap_lep_set_free(seq_list);
3622
3623         session_set_access_time(SESSION(session));
3624         stuff->done = TRUE;
3625         return newlist;
3626 }
3627
3628 #define MAX_MSG_NUM 50
3629
3630 static GSList *imap_get_uncached_messages(IMAPSession *session,
3631                                         FolderItem *item,
3632                                         MsgNumberList *numlist,
3633                                         int *r)
3634 {
3635         GSList *result = NULL;
3636         GSList * cur;
3637         uncached_data *data = g_new0(uncached_data, 1);
3638
3639         cur = numlist;
3640         data->total = g_slist_length(numlist);
3641         data->ok = MAILIMAP_NO_ERROR;
3642         debug_print("messages list : %i\n", data->total);
3643
3644         while (cur != NULL) {
3645                 GSList * partial_result;
3646                 int count;
3647                 GSList * newlist;
3648                 GSList * llast;
3649
3650                 llast = NULL;
3651                 count = 0;
3652                 newlist = NULL;
3653                 while (count < MAX_MSG_NUM) {
3654                         void * p;
3655
3656                         p = cur->data;
3657
3658                         if (newlist == NULL)
3659                                 llast = newlist = g_slist_append(newlist, p);
3660                         else {
3661                                 llast = g_slist_append(llast, p);
3662                                 llast = llast->next;
3663                         }
3664                         count ++;
3665
3666                         cur = cur->next;
3667                         if (cur == NULL)
3668                                 break;
3669                 }
3670
3671                 data->done = FALSE;
3672                 data->session = session;
3673                 data->item = item;
3674                 data->numlist = newlist;
3675                 data->cur += count;
3676
3677                 if (prefs_common.work_offline &&
3678                     !inc_offline_should_override(FALSE,
3679                         _("Claws Mail needs network access in order "
3680                           "to access the IMAP server."))) {
3681                         g_free(data);
3682                         return NULL;
3683                 }
3684
3685                 partial_result =
3686                         (GSList *)imap_get_uncached_messages_thread(data);
3687                 *r = data->ok;
3688                 if (data->ok != MAILIMAP_NO_ERROR) {
3689                         goto bail;
3690                 }
3691                 statusbar_progress_all(data->cur,data->total, 1);
3692
3693                 g_slist_free(newlist);
3694
3695                 result = g_slist_concat(result, partial_result);
3696         }
3697 bail:
3698         g_free(data);
3699
3700         statusbar_progress_all(0,0,0);
3701         statusbar_pop_all();
3702
3703         return result;
3704 }
3705
3706 static void imap_delete_all_cached_messages(FolderItem *item)
3707 {
3708         gchar *dir;
3709
3710         g_return_if_fail(item != NULL);
3711         g_return_if_fail(item->folder != NULL);
3712         g_return_if_fail(FOLDER_CLASS(item->folder) == &imap_class);
3713
3714         debug_print("Deleting all cached messages...\n");
3715
3716         dir = folder_item_get_path(item);
3717         if (is_dir_exist(dir))
3718                 remove_all_numbered_files(dir);
3719         g_free(dir);
3720
3721         debug_print("Deleting all cached messages done.\n");
3722 }
3723
3724 gchar imap_get_path_separator_for_item(FolderItem *item)
3725 {
3726         Folder *folder = NULL;
3727         IMAPFolder *imap_folder = NULL;
3728         IMAPSession *session = NULL;
3729         gchar result = '/';
3730         gint ok = MAILIMAP_NO_ERROR;
3731         if (!item)
3732                 return '/';
3733         folder = item->folder;
3734
3735         if (!folder)
3736                 return '/';
3737
3738         imap_folder = IMAP_FOLDER(folder);
3739
3740         debug_print("getting session...\n");
3741         session = imap_session_get(FOLDER(folder));
3742         result = imap_get_path_separator(session, imap_folder, item->path, &ok);
3743         return result;
3744 }
3745
3746 static gchar imap_refresh_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *subfolder, gint *ok)
3747 {
3748         clist * lep_list;
3749         int r;
3750         gchar separator = '\0';
3751
3752         g_return_val_if_fail(session != NULL, '/');
3753         r = imap_threaded_list((Folder *)folder, "", subfolder, &lep_list);
3754
3755         if (r != MAILIMAP_NO_ERROR) {
3756                 imap_handle_error(SESSION(session), NULL, r);
3757                 log_warning(LOG_PROTOCOL, _("LIST failed\n"));
3758                 *ok = r;
3759                 return '\0';
3760         }
3761
3762         if (lep_list != NULL && clist_count(lep_list) > 0) {
3763                 clistiter * iter = clist_begin(lep_list);
3764                 struct mailimap_mailbox_list * mb;
3765                 mb = clist_content(iter);
3766
3767                 separator = mb->mb_delimiter;
3768                 debug_print("got separator: %c\n", folder->last_seen_separator);
3769         }
3770         *ok = MAILIMAP_NO_ERROR;
3771         mailimap_list_result_free(lep_list);
3772         return separator;
3773 }
3774
3775 static gchar imap_get_path_separator(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
3776 {
3777         gchar separator = '/';
3778         *ok = MAILIMAP_NO_ERROR;
3779         if (folder->last_seen_separator == 0) {
3780                 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "", ok);
3781         }
3782
3783         if (folder->last_seen_separator == 0) {
3784                 folder->last_seen_separator = imap_refresh_path_separator(session, folder, "INBOX", ok);
3785         }
3786
3787         if (folder->last_seen_separator != 0) {
3788                 debug_print("using separator: %c\n", folder->last_seen_separator);
3789                 return folder->last_seen_separator;
3790         }
3791
3792         return separator;
3793 }
3794
3795 static gchar *imap_get_real_path(IMAPSession *session, IMAPFolder *folder, const gchar *path, gint *ok)
3796 {
3797         gchar *real_path = NULL;
3798         gchar separator;
3799
3800         g_return_val_if_fail(folder != NULL, NULL);
3801         g_return_val_if_fail(path != NULL, NULL);
3802
3803         *ok = MAILIMAP_NO_ERROR;
3804
3805         real_path = imap_utf8_to_modified_utf7(path, FALSE);
3806         separator = imap_get_path_separator(session, folder, path, ok);
3807         if (*ok == MAILIMAP_NO_ERROR)
3808                 imap_path_separator_subst(real_path, separator);
3809
3810         return real_path;
3811 }
3812
3813 static gint imap_set_message_flags(IMAPSession *session,
3814                                    IMAPFolderItem *item,
3815                                    MsgNumberList *numlist,
3816                                    IMAPFlags flags,
3817                                    GSList *tags,
3818                                    gboolean is_set)
3819 {
3820         gint ok = 0;
3821         GSList *seq_list;
3822         GSList * cur;
3823         gint total = 0;
3824         IMAPFolder *folder = NULL;
3825         GSList *sorted_list = NULL;
3826
3827         if (numlist == NULL || session == NULL)
3828                 return MAILIMAP_ERROR_BAD_STATE;
3829
3830         folder = IMAP_FOLDER(session->folder);
3831
3832         sorted_list = g_slist_copy(numlist);
3833         sorted_list = g_slist_sort(sorted_list, g_int_compare);
3834
3835         cur = g_slist_last(sorted_list);
3836
3837         if (cur)
3838                 total = GPOINTER_TO_INT(cur->data);
3839
3840         seq_list = imap_get_lep_set_from_numlist(IMAP_FOLDER(session->folder), sorted_list);
3841
3842         statusbar_print_all(_("Flagging messages..."));
3843
3844         for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
3845                 struct mailimap_set * imapset = (struct mailimap_set *)cur->data;
3846                 struct mailimap_set_item *set_item = NULL;
3847
3848                 if (imapset->set_list)
3849                         set_item = clist_content(clist_begin(imapset->set_list));
3850                 else
3851                         continue;
3852
3853                 if (set_item == NULL)
3854                         continue;
3855
3856                 statusbar_progress_all(set_item->set_first, total, 1);
3857
3858                 ok = imap_cmd_store(session, item, imapset,
3859                                     flags, tags, is_set);
3860                 statusbar_progress_all(set_item->set_last, total, 1);
3861                 if (ok != MAILIMAP_NO_ERROR && folder->max_set_size > 20) {
3862                         /* reduce max set size */
3863                         folder->max_set_size /= 2;
3864                 }
3865                 if (ok != MAILIMAP_NO_ERROR && is_fatal(ok)) {
3866                         break;
3867                 }
3868         }
3869
3870         g_slist_free(sorted_list);
3871
3872         statusbar_progress_all(0,0,0);
3873         statusbar_pop_all();
3874
3875         imap_lep_set_free(seq_list);
3876
3877         return ok;
3878 }
3879
3880 typedef struct _select_data {
3881         IMAPSession *session;
3882         gchar *real_path;
3883         gint *exists;
3884         gint *recent;
3885         gint *unseen;
3886         guint32 *uid_validity;
3887         gboolean done;
3888 } select_data;
3889
3890 static gint imap_select(IMAPSession *session, IMAPFolder *folder,
3891                         FolderItem *item,
3892                         gint *exists, gint *recent, gint *unseen,
3893                         guint32 *uid_validity, gint *can_create_flags,
3894                         gboolean block)
3895 {
3896         gchar *real_path;
3897         gint ok = MAILIMAP_NO_ERROR;
3898         gint exists_, recent_, unseen_;
3899         guint32 uid_validity_;
3900         gint can_create_flags_;
3901         const gchar *path = item ? item->path:NULL;
3902
3903         if (!item) {
3904                 return MAILIMAP_ERROR_BAD_STATE;
3905         }
3906
3907         if (!exists && !recent && !unseen && !uid_validity && !can_create_flags) {
3908                 if (session->mbox && strcmp(session->mbox, path) == 0)
3909                         return MAILIMAP_NO_ERROR;
3910         }
3911         if (!exists && !recent && !unseen && !uid_validity && can_create_flags) {
3912                 if (session->mbox && strcmp(session->mbox, path) == 0) {
3913                         if (IMAP_FOLDER_ITEM(item)->can_create_flags != ITEM_CAN_CREATE_FLAGS_UNKNOWN)
3914                                 return MAILIMAP_NO_ERROR;
3915                 }
3916         }
3917         if (!exists)
3918                 exists = &exists_;
3919         if (!recent)
3920                 recent = &recent_;
3921         if (!unseen)
3922                 unseen = &unseen_;
3923         if (!uid_validity)
3924                 uid_validity = &uid_validity_;
3925         if (!can_create_flags)
3926                 can_create_flags = &can_create_flags_;
3927
3928         g_free(session->mbox);
3929         session->mbox = NULL;
3930         session->exists = 0;
3931         session->recent = 0;
3932         session->expunge = 0;
3933
3934         real_path = imap_get_real_path(session, folder, path, &ok);
3935         if (is_fatal(ok)) {
3936                 g_free(real_path);
3937                 return ok;
3938         }
3939         g_slist_free(IMAP_FOLDER_ITEM(item)->ok_flags);
3940         IMAP_FOLDER_ITEM(item)->ok_flags = NULL;
3941         ok = imap_cmd_select(session, real_path,
3942                              exists, recent, unseen, uid_validity, can_create_flags,
3943                              &(IMAP_FOLDER_ITEM(item)->ok_flags), block);
3944         if (ok != MAILIMAP_NO_ERROR) {
3945                 log_warning(LOG_PROTOCOL, _("can't select folder: %s\n"), real_path);
3946         } else {
3947                 session->mbox = g_strdup(path);
3948                 session->folder_content_changed = FALSE;
3949                 session->exists = *exists;
3950                 session->recent = *recent;
3951                 session->expunge = 0;
3952                 session->unseen = *unseen;
3953                 session->uid_validity = *uid_validity;
3954                 debug_print("select: exists %d recent %d expunge %d uid_validity %d can_create_flags %d\n",
3955                         session->exists, session->recent, session->expunge,
3956                         session->uid_validity, *can_create_flags);
3957         }
3958         if (*can_create_flags) {
3959                 IMAP_FOLDER_ITEM(item)->can_create_flags = ITEM_CAN_CREATE_FLAGS;
3960         } else {
3961                 IMAP_FOLDER_ITEM(item)->can_create_flags = ITEM_CANNOT_CREATE_FLAGS;
3962         }
3963         g_free(real_path);
3964
3965         return ok;
3966 }
3967
3968 static gint imap_status(IMAPSession *session, IMAPFolder *folder,
3969                         const gchar *path, IMAPFolderItem *item,
3970                         gint *messages,
3971                         guint32 *uid_next, guint32 *uid_validity,
3972                         gint *unseen, gboolean block)
3973 {
3974         int r = MAILIMAP_NO_ERROR;
3975         clistiter * iter;
3976         struct mailimap_mailbox_data_status * data_status;
3977         int got_values;
3978         gchar *real_path;
3979         guint mask = 0;
3980
3981         real_path = imap_get_real_path(session, folder, path, &r);
3982         if (is_fatal(r)) {
3983                 g_free(real_path);
3984                 return r;
3985         }
3986         if (messages) {
3987                 mask |= 1 << 0;
3988                 *messages = 0;
3989         }
3990         if (uid_next) {
3991                 mask |= 1 << 2;
3992                 *uid_next = 0;
3993         }
3994         if (uid_validity) {
3995                 mask |= 1 << 3;
3996                 *uid_validity = 0;
3997         }
3998         if (unseen) {
3999                 mask |= 1 << 4;
4000                 *unseen = 0;
4001         }
4002
4003         if (session->mbox != NULL &&
4004             !strcmp(session->mbox, item->item.path)) {
4005                 r = imap_cmd_close(session);
4006                 if (r != MAILIMAP_NO_ERROR) {
4007                         debug_print("close err %d\n", r);
4008                         g_free(real_path);
4009                         return r;
4010                 }
4011         }
4012
4013         r = imap_threaded_status(FOLDER(folder), real_path,
4014                 &data_status, mask);
4015
4016         g_free(real_path);
4017         if (r != MAILIMAP_NO_ERROR) {
4018                 imap_handle_error(SESSION(session), NULL, r);
4019                 debug_print("status err %d\n", r);
4020                 return r;
4021         }
4022
4023         if (data_status == NULL || data_status->st_info_list == NULL) {
4024                 debug_print("data_status %p\n", data_status);
4025                 if (data_status) {
4026                         debug_print("data_status->st_info_list %p\n", data_status->st_info_list);
4027                         mailimap_mailbox_data_status_free(data_status);
4028                 }
4029                 return MAILIMAP_ERROR_BAD_STATE;
4030         }
4031
4032         got_values = 0;
4033         if (data_status->st_info_list) {
4034                 for(iter = clist_begin(data_status->st_info_list) ; iter != NULL ;
4035                     iter = clist_next(iter)) {
4036                         struct mailimap_status_info * info;
4037
4038                         info = clist_content(iter);
4039                         switch (info->st_att) {
4040                         case MAILIMAP_STATUS_ATT_MESSAGES:
4041                                 if (messages) {
4042                                         * messages = info->st_value;
4043                                         got_values |= 1 << 0;
4044                                 }
4045                                 break;
4046
4047                         case MAILIMAP_STATUS_ATT_UIDNEXT:
4048                                 if (uid_next) {
4049                                         * uid_next = info->st_value;
4050                                         got_values |= 1 << 2;
4051                                 }
4052                                 break;
4053
4054                         case MAILIMAP_STATUS_ATT_UIDVALIDITY:
4055                                 if (uid_validity) {
4056                                         * uid_validity = info->st_value;
4057                                         got_values |= 1 << 3;
4058                                 }
4059                                 break;
4060
4061                         case MAILIMAP_STATUS_ATT_UNSEEN:
4062                                 if (unseen) {
4063                                         * unseen = info->st_value;
4064                                         got_values |= 1 << 4;
4065                                 }
4066                                 break;
4067                         }
4068                 }
4069         }
4070         mailimap_mailbox_data_status_free(data_status);
4071
4072         if (got_values != mask) {
4073                 g_warning("status: incomplete values received (%d)", got_values);
4074         }
4075         return MAILIMAP_NO_ERROR;
4076 }
4077
4078 static void imap_free_capabilities(IMAPSession *session)
4079 {
4080         slist_free_strings_full(session->capability);
4081         session->capability = NULL;
4082 }
4083
4084 /* low-level IMAP4rev1 commands */
4085
4086 static gint imap_cmd_login(IMAPSession *session,
4087                            const gchar *user, const gchar *pass,
4088                            const gchar *type)
4089 {
4090         int r;
4091         gint ok;
4092
4093         if (!strcmp(type, "plaintext") && imap_has_capability(session, "LOGINDISABLED")) {
4094                 ok = MAILIMAP_ERROR_BAD_STATE;
4095                 if (imap_has_capability(session, "STARTTLS")) {
4096 #ifdef USE_GNUTLS
4097                         log_warning(LOG_PROTOCOL, _("Server requires STARTTLS to log in.\n"));
4098                         ok = imap_cmd_starttls(session);
4099                         if (ok != MAILIMAP_NO_ERROR) {
4100                                 log_warning(LOG_PROTOCOL, _("Can't start STARTTLS session.\n"));
4101                                 return ok;
4102                         } else {
4103                                 /* refresh capas */
4104                                 imap_free_capabilities(session);
4105                                 if ((r = imap_get_capabilities(session)) != MAILIMAP_NO_ERROR) {
4106                                         imap_handle_error(SESSION(session), NULL, r);
4107                                         log_warning(LOG_PROTOCOL, _("Can't refresh capabilities.\n"));
4108                                         return r;
4109                                 }
4110                         }
4111 #else
4112                         log_error(LOG_PROTOCOL, _("Connection to %s failed: "
4113                                         "server requires STARTTLS, but Claws Mail "
4114                                         "has been compiled without STARTTLS "
4115                                         "support.\n"),
4116                                         SESSION(session)->server);
4117                         return MAILIMAP_ERROR_LOGIN;
4118 #endif
4119                 } else {
4120                         log_error(LOG_PROTOCOL, _("Server logins are disabled.\n"));
4121                         return MAILIMAP_ERROR_LOGIN;
4122                 }
4123         }
4124
4125         log_print(LOG_PROTOCOL, "IMAP> Logging %s to %s using %s\n",
4126                         user,
4127                         SESSION(session)->server,
4128                         type);
4129         r = imap_threaded_login(session->folder, user, pass, type);
4130         if (r != MAILIMAP_NO_ERROR) {
4131                 imap_handle_error(SESSION(session), NULL, r);
4132                 log_print(LOG_PROTOCOL, "IMAP< Error logging in to %s\n",
4133                                 SESSION(session)->server);
4134                 ok = r;
4135         } else {
4136                 log_print(LOG_PROTOCOL, "IMAP< Login to %s successful\n",
4137                                 SESSION(session)->server);
4138                 ok = MAILIMAP_NO_ERROR;
4139         }
4140         return ok;
4141 }
4142
4143 static gint imap_cmd_noop(IMAPSession *session)
4144 {
4145         int r;
4146         unsigned int exists, recent, expunge, unseen, uidnext, uidval;
4147
4148         r = imap_threaded_noop(session->folder, &exists, &recent, &expunge, &unseen, &uidnext, &uidval);
4149         if (r != MAILIMAP_NO_ERROR) {
4150                 imap_handle_error(SESSION(session), NULL, r);
4151                 debug_print("noop err %d\n", r);
4152                 return r;
4153         }
4154
4155         if ((exists && exists != session->exists)
4156          || (recent && recent != session->recent)
4157          || (expunge && expunge != session->expunge)
4158          || (unseen && unseen != session->unseen)) {
4159                 session->folder_content_changed = TRUE;
4160         }
4161         if (uidnext != 0 && uidnext != session->uid_next) {
4162                 session->uid_next = uidnext;
4163                 session->folder_content_changed = TRUE;
4164         }
4165         if (uidval != 0 && uidval != session->uid_validity) {
4166                 session->uid_validity = uidval;
4167                 session->folder_content_changed = TRUE;
4168         }
4169
4170         session->exists = exists;
4171         session->recent = recent;
4172         session->expunge = expunge;
4173         session->unseen = unseen;
4174
4175         session_set_access_time(SESSION(session));
4176
4177         return MAILIMAP_NO_ERROR;
4178 }
4179
4180 #ifdef USE_GNUTLS
4181 static gint imap_cmd_starttls(IMAPSession *session)
4182 {
4183         int r;
4184
4185         r = imap_threaded_starttls(session->folder,
4186                 SESSION(session)->server, SESSION(session)->port);
4187         if (r != MAILIMAP_NO_ERROR) {
4188                 imap_handle_error(SESSION(session), NULL, r);
4189                 debug_print("STARTTLS err %d\n", r);
4190                 return r;
4191         }
4192         return MAILIMAP_NO_ERROR;
4193 }
4194 #endif
4195
4196 static gint imap_cmd_select(IMAPSession *session, const gchar *folder,
4197                             gint *exists, gint *recent, gint *unseen,
4198                             guint32 *uid_validity, gint *can_create_flags,
4199                             GSList **ok_flags, gboolean block)
4200 {
4201         int r;
4202
4203         r = imap_threaded_select(session->folder, folder,
4204                                  exists, recent, unseen, uid_validity, can_create_flags, ok_flags);
4205         if (r != MAILIMAP_NO_ERROR) {
4206                 imap_handle_error(SESSION(session), NULL, r);
4207                 debug_print("select err %d\n", r);
4208                 return r;
4209         }
4210         return MAILIMAP_NO_ERROR;
4211 }
4212
4213 static gint imap_cmd_close(IMAPSession *session)
4214 {
4215         int r;
4216
4217         r = imap_threaded_close(session->folder);
4218         if (r != MAILIMAP_NO_ERROR) {
4219                 imap_handle_error(SESSION(session), NULL, r);
4220                 debug_print("close err %d\n", r);
4221                 return r;
4222         }
4223         g_free(session->mbox);
4224         session->mbox = NULL;
4225         session->exists = 0;
4226         session->recent = 0;
4227         session->expunge = 0;
4228         return MAILIMAP_NO_ERROR;
4229 }
4230
4231 static gint imap_cmd_examine(IMAPSession *session, const gchar *folder,
4232                              gint *exists, gint *recent, gint *unseen,
4233                              guint32 *uid_validity, gboolean block)
4234 {
4235         int r;
4236
4237         r = imap_threaded_examine(session->folder, folder,
4238                                   exists, recent, unseen, uid_validity);
4239         if (r != MAILIMAP_NO_ERROR) {
4240                 imap_handle_error(SESSION(session), NULL, r);
4241                 debug_print("examine err %d\n", r);
4242
4243                 return r;
4244         }
4245         return MAILIMAP_NO_ERROR;
4246 }
4247
4248 static gint imap_cmd_create(IMAPSession *session, const gchar *folder)
4249 {
4250         int r;
4251
4252         r = imap_threaded_create(session->folder, folder);
4253         if (r != MAILIMAP_NO_ERROR) {
4254                 imap_handle_error(SESSION(session), NULL, r);
4255                 return r;
4256         }
4257
4258         return MAILIMAP_NO_ERROR;
4259 }
4260
4261 static gint imap_cmd_rename(IMAPSession *session, const gchar *old_folder,
4262                             const gchar *new_folder)
4263 {
4264         int r;
4265
4266         r = imap_threaded_rename(session->folder, old_folder,
4267                                  new_folder);
4268         if (r != MAILIMAP_NO_ERROR) {
4269                 imap_handle_error(SESSION(session), NULL, r);
4270                 return r;
4271         }
4272
4273         return MAILIMAP_NO_ERROR;
4274 }
4275
4276 static gint imap_cmd_delete(IMAPSession *session, const gchar *folder)
4277 {
4278         int r;
4279
4280
4281         r = imap_threaded_delete(session->folder, folder);
4282         if (r != MAILIMAP_NO_ERROR) {
4283                 imap_handle_error(SESSION(session), NULL, r);
4284                 return r;
4285         }
4286
4287         return MAILIMAP_NO_ERROR;
4288 }
4289
4290 typedef struct _fetch_data {
4291         IMAPSession *session;
4292         guint32 uid;
4293         const gchar *filename;
4294         gboolean headers;
4295         gboolean body;
4296         gboolean done;
4297 } fetch_data;
4298
4299 static void *imap_cmd_fetch_thread(void *data)
4300 {
4301         fetch_data *stuff = (fetch_data *)data;
4302         IMAPSession *session = stuff->session;
4303         guint32 uid = stuff->uid;
4304         const gchar *filename = stuff->filename;
4305         int r;
4306
4307         if (stuff->body) {
4308                 r = imap_threaded_fetch_content(session->folder,
4309                                                uid, 1, filename);
4310         }
4311         else {
4312                 r = imap_threaded_fetch_content(session->folder,
4313                                                 uid, 0, filename);
4314         }
4315         if (r != MAILIMAP_NO_ERROR) {
4316                 imap_handle_error(SESSION(session), NULL, r);
4317                 debug_print("fetch err %d\n", r);
4318                 return GINT_TO_POINTER(r);
4319         }
4320         return GINT_TO_POINTER(MAILIMAP_NO_ERROR);
4321 }
4322
4323 static gint imap_cmd_fetch(IMAPSession *session, guint32 uid,
4324                                 const gchar *filename, gboolean headers,
4325                                 gboolean body)
4326 {
4327         fetch_data *data = g_new0(fetch_data, 1);
4328         int result = 0;
4329         data->done = FALSE;
4330         data->session = session;
4331         data->uid = uid;
4332         data->filename = filename;
4333         data->headers = headers;
4334         data->body = body;
4335
4336         if (prefs_common.work_offline &&
4337             !inc_offline_should_override(FALSE,
4338                 _("Claws Mail needs network access in order "
4339                   "to access the IMAP server."))) {
4340                 g_free(data);
4341                 return -1;
4342         }
4343         statusbar_print_all(_("Fetching message..."));
4344         result = GPOINTER_TO_INT(imap_cmd_fetch_thread(data));
4345         statusbar_pop_all();
4346         g_free(data);
4347         return result;
4348 }
4349
4350
4351 static gint imap_cmd_append(IMAPSession *session,
4352                             IMAPFolderItem *item,
4353                             const gchar *destfolder,
4354                             const gchar *file, IMAPFlags flags,
4355                             guint32 *new_uid)
4356 {
4357         struct mailimap_flag_list * flag_list;
4358         int r;
4359
4360         cm_return_val_if_fail(file != NULL, MAILIMAP_ERROR_BAD_STATE);
4361
4362         flag_list = imap_flag_to_lep(item, flags, NULL);
4363         lock_session(session);
4364         r = imap_threaded_append(session->folder, destfolder,
4365                          file, flag_list, (int *)new_uid);
4366         mailimap_flag_list_free(flag_list);
4367
4368         if (r != MAILIMAP_NO_ERROR) {
4369                 imap_handle_error(SESSION(session), NULL, r);
4370                 debug_print("append err %d\n", r);
4371                 return r;
4372         }
4373
4374         unlock_session(session);
4375
4376         return MAILIMAP_NO_ERROR;
4377 }
4378
4379 static gint imap_cmd_copy(IMAPSession *session, struct mailimap_set * set,
4380                           const gchar *destfolder,
4381                           struct mailimap_set **source, struct mailimap_set **dest)
4382 {
4383         int r;
4384
4385         g_return_val_if_fail(session != NULL, MAILIMAP_ERROR_BAD_STATE);
4386         g_return_val_if_fail(set != NULL, MAILIMAP_ERROR_BAD_STATE);
4387         g_return_val_if_fail(destfolder != NULL, MAILIMAP_ERROR_BAD_STATE);
4388
4389         r = imap_threaded_copy(session->folder, set, destfolder, source, dest);
4390         if (r != MAILIMAP_NO_ERROR) {
4391                 imap_handle_error(SESSION(session), NULL, r);
4392                 return r;
4393         }
4394
4395         return MAILIMAP_NO_ERROR;
4396 }
4397
4398 static gint imap_cmd_store(IMAPSession *session,
4399                            IMAPFolderItem *item,
4400                            struct mailimap_set * set,
4401                            IMAPFlags flags, GSList *tags, int do_add)
4402 {
4403         int r;
4404         struct mailimap_flag_list * flag_list = NULL;
4405         struct mailimap_store_att_flags * store_att_flags;
4406
4407         flag_list = imap_flag_to_lep(item, flags, tags);
4408
4409         if (do_add)
4410                 store_att_flags =
4411                         mailimap_store_att_flags_new_add_flags_silent(flag_list);
4412         else
4413                 store_att_flags =
4414                         mailimap_store_att_flags_new_remove_flags_silent(flag_list);
4415
4416         r = imap_threaded_store(session->folder, set, store_att_flags);
4417         mailimap_store_att_flags_free(store_att_flags);
4418         if (r != MAILIMAP_NO_ERROR) {
4419                 imap_handle_error(SESSION(session), NULL, r);
4420                 return r;
4421         }
4422
4423         return MAILIMAP_NO_ERROR;
4424 }
4425
4426 static gint imap_cmd_expunge(IMAPSession *session)
4427 {
4428         int r;
4429
4430         if (prefs_common.work_offline &&
4431             !inc_offline_should_override(FALSE,
4432                 _("Claws Mail needs network access in order "
4433                   "to access the IMAP server."))) {
4434                 return -1;
4435         }
4436
4437         r = imap_threaded_expunge(session->folder);
4438         if (r != MAILIMAP_NO_ERROR) {
4439                 imap_handle_error(SESSION(session), NULL, r);
4440                 return r;
4441         }
4442
4443         return MAILIMAP_NO_ERROR;
4444 }
4445
4446 gint imap_expunge(Folder *folder, FolderItem *item)
4447 {
4448         IMAPSession *session = imap_session_get(folder);
4449         if (session == NULL)
4450                 return -1;
4451
4452         return imap_cmd_expunge(session);
4453 }
4454
4455 static void imap_path_separator_subst(gchar *str, gchar separator)
4456 {
4457         gchar *p;
4458         gboolean in_escape = FALSE;
4459
4460         if (!separator || separator == '/') return;
4461
4462         for (p = str; *p != '\0'; p++) {
4463                 if (*p == '/' && !in_escape)
4464                         *p = separator;
4465                 else if (*p == '&' && *(p + 1) != '-' && !in_escape)
4466                         in_escape = TRUE;
4467                 else if (*p == '-' && in_escape)
4468                         in_escape = FALSE;
4469         }
4470 }
4471
4472 static gboolean imap_rename_folder_func(GNode *node, gpointer data)
4473 {
4474         FolderItem *item = node->data;
4475         gchar **paths = data;
4476         const gchar *oldpath = paths[0];
4477         const gchar *newpath = paths[1];
4478         gchar *real_oldpath, *real_newpath;
4479         gchar *base;
4480         gchar *new_itempath;
4481         gint oldpathlen;
4482         IMAPSession *session = imap_session_get(item->folder);
4483         gint ok = MAILIMAP_NO_ERROR;
4484         oldpathlen = strlen(oldpath);
4485         if (strncmp(oldpath, item->path, oldpathlen) != 0) {
4486                 g_warning("path doesn't match: %s, %s", oldpath, item->path);
4487                 return TRUE;
4488         }
4489
4490         base = item->path + oldpathlen;
4491         while (*base == '/') base++;
4492         if (*base == '\0')
4493                 new_itempath = g_strdup(newpath);
4494         else
4495                 new_itempath = g_strconcat(newpath, "/", base,
4496                                            NULL);
4497
4498         real_oldpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path, &ok);
4499         g_free(item->path);
4500         item->path = new_itempath;
4501
4502         real_newpath = imap_get_real_path(session, IMAP_FOLDER(item->folder), item->path, &ok);
4503
4504         imap_threaded_subscribe(item->folder, real_oldpath, FALSE);
4505         imap_threaded_subscribe(item->folder, real_newpath, TRUE);
4506
4507         g_free(real_oldpath);
4508         g_free(real_newpath);
4509         return FALSE;
4510 }
4511
4512 static gint get_list_of_uids(IMAPSession *session, Folder *folder, IMAPFolderItem *item, GSList **msgnum_list)
4513 {
4514         GSList *uidlist, *elem;
4515         int r = -1;
4516         clist * lep_uidlist;
4517         gint ok, nummsgs = 0;
4518
4519         if (session == NULL) {
4520                 return -1;
4521         }
4522
4523         ok = imap_select(session, IMAP_FOLDER(folder), FOLDER_ITEM(item),
4524                          NULL, NULL, NULL, NULL, NULL, TRUE);
4525         if (ok != MAILIMAP_NO_ERROR) {
4526                 return -1;
4527         }
4528
4529         g_slist_free(item->uid_list);
4530         item->uid_list = NULL;
4531
4532         uidlist = NULL;
4533
4534         if (folder->account && folder->account->low_bandwidth) {
4535                 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SIMPLE,
4536                                 NULL, NULL, NULL, &lep_uidlist);
4537         }
4538
4539         if (r == MAILIMAP_NO_ERROR) {
4540                 uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
4541                 mailimap_search_result_free(lep_uidlist);
4542         } else {
4543                 carray * lep_uidtab;
4544                 if (r != -1) { /* inited */
4545                         imap_handle_error(SESSION(session), NULL, r);
4546                         if (is_fatal(r))
4547                                 return -1;
4548                 }
4549                 r = imap_threaded_fetch_uid(folder, 1,
4550                                     &lep_uidtab);
4551                 if (r == MAILIMAP_NO_ERROR) {
4552                         uidlist = imap_uid_list_from_lep_tab(lep_uidtab);
4553                         imap_fetch_uid_list_free(lep_uidtab);
4554                 }
4555         }
4556
4557         if (r != MAILIMAP_NO_ERROR) {
4558                 imap_handle_error(SESSION(session), NULL, r);
4559                 return -1;
4560         }
4561
4562         for (elem = uidlist; elem != NULL; elem = g_slist_next(elem)) {
4563                 guint msgnum;
4564
4565                 msgnum = GPOINTER_TO_INT(elem->data);
4566
4567                 *msgnum_list = g_slist_prepend(*msgnum_list, GINT_TO_POINTER(msgnum));
4568                 item->uid_list = g_slist_prepend(item->uid_list, GINT_TO_POINTER(msgnum));
4569                 nummsgs++;
4570         }
4571         g_slist_free(uidlist);
4572
4573         return nummsgs;
4574
4575 }
4576
4577 gint imap_get_num_list(Folder *folder, FolderItem *_item, GSList **msgnum_list, gboolean *old_uids_valid)
4578 {
4579         IMAPFolderItem *item = (IMAPFolderItem *)_item;
4580         IMAPSession *session;
4581         gint nummsgs;
4582         GSList *uidlist = NULL;
4583         gchar *dir;
4584         gint known_list_len = 0;
4585         gchar *path;
4586
4587         debug_print("get_num_list\n");
4588
4589         g_return_val_if_fail(folder != NULL, -1);
4590         g_return_val_if_fail(item != NULL, -1);
4591         g_return_val_if_fail(item->item.path != NULL, -1);
4592         g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
4593         g_return_val_if_fail(folder->account != NULL, -1);
4594
4595         known_list_len = g_slist_length(item->uid_list);
4596         if (!item->should_update) {
4597                 debug_print("get_num_list: nothing to update\n");
4598                 *old_uids_valid = TRUE;
4599                 if (known_list_len == item->item.total_msgs
4600                  && known_list_len > 0) {
4601                         *msgnum_list = g_slist_copy(item->uid_list);
4602                         return known_list_len;
4603                 } else {
4604                         debug_print("don't know the list length...\n");
4605                 }
4606         }
4607
4608         if (prefs_common.work_offline &&
4609             !inc_offline_should_override(FALSE,
4610                 _("Claws Mail needs network access in order "
4611                   "to access the IMAP server."))) {
4612                 return -1;
4613         }
4614
4615         path = folder_item_get_path(_item);
4616         if (!is_dir_exist(path)) {
4617                 if(is_file_exist(path))
4618                         claws_unlink(path);
4619                 make_dir_hier(path);
4620         }
4621         g_free(path);
4622
4623         debug_print("getting session...\n");
4624         session = imap_session_get(folder);
4625         g_return_val_if_fail(session != NULL, -1);
4626
4627         lock_session(session);
4628         if (FOLDER_ITEM(item)->path)
4629                 statusbar_print_all(_("Scanning folder %s/%s..."),
4630                                       FOLDER_ITEM(item)->folder->name,
4631                                       FOLDER_ITEM(item)->path);
4632         else
4633                 statusbar_print_all(_("Scanning folder %s..."),
4634                                       FOLDER_ITEM(item)->folder->name);
4635
4636         if (item->should_trash_cache) {
4637                 *old_uids_valid = FALSE;
4638                 debug_print("get_num_list: trashing num list\n");
4639                 debug_print("Freeing imap uid cache\n");
4640                 item->lastuid = 0;
4641                 g_slist_free(item->uid_list);
4642                 item->uid_list = NULL;
4643
4644                 imap_delete_all_cached_messages((FolderItem *)item);
4645         } else {
4646                 debug_print("get_num_list: updating num list\n");
4647                 *old_uids_valid = TRUE;
4648         }
4649
4650         nummsgs = get_list_of_uids(session, folder, item, &uidlist);
4651
4652         unlock_session(session);
4653
4654         /* session could be broken now, in case of fatal error */
4655
4656         debug_print("get_num_list: got %d msgs\n", nummsgs);
4657
4658         if (nummsgs < 0) {
4659                 statusbar_pop_all();
4660                 return -1;
4661         }
4662
4663         *msgnum_list = uidlist;
4664
4665         dir = folder_item_get_path((FolderItem *)item);
4666         debug_print("removing old messages from %s\n", dir);
4667         remove_numbered_files_not_in_list(dir, *msgnum_list);
4668         g_free(dir);
4669
4670         debug_print("get_num_list - ok - %i\n", nummsgs);
4671         statusbar_pop_all();
4672         item->should_trash_cache = FALSE;
4673         item->should_update = FALSE;
4674         return nummsgs;
4675 }
4676
4677 static MsgInfo *imap_parse_msg(const gchar *file, FolderItem *item)
4678 {
4679         MsgInfo *msginfo;
4680         MsgFlags flags;
4681
4682         flags.perm_flags = MSG_NEW|MSG_UNREAD;
4683         flags.tmp_flags = 0;
4684
4685         g_return_val_if_fail(item != NULL, NULL);
4686         g_return_val_if_fail(file != NULL, NULL);
4687
4688         if (folder_has_parent_of_type(item, F_QUEUE)) {
4689                 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
4690         } else if (folder_has_parent_of_type(item, F_DRAFT)) {
4691                 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
4692         }
4693
4694         msginfo = procheader_parse_file(file, flags, FALSE, FALSE);
4695         if (!msginfo) return NULL;
4696
4697         msginfo->plaintext_file = g_strdup(file);
4698         msginfo->folder = item;
4699
4700         return msginfo;
4701 }
4702
4703 GSList *imap_get_msginfos(Folder *folder, FolderItem *item,
4704                           GSList *msgnum_list)
4705 {
4706         IMAPSession *session;
4707         MsgInfoList *ret = NULL;
4708         gint ok;
4709
4710         debug_print("get_msginfos\n");
4711
4712         g_return_val_if_fail(folder != NULL, NULL);
4713         g_return_val_if_fail(item != NULL, NULL);
4714         g_return_val_if_fail(msgnum_list != NULL, NULL);
4715
4716         debug_print("getting session...\n");
4717         session = imap_session_get(folder);
4718         g_return_val_if_fail(session != NULL, NULL);
4719
4720         lock_session(session); /* unlocked later in the function */
4721
4722         debug_print("IMAP getting msginfos\n");
4723         ok = imap_select(session, IMAP_FOLDER(folder), item,
4724                          NULL, NULL, NULL, NULL, NULL, FALSE);
4725         if (ok != MAILIMAP_NO_ERROR) {
4726                 return NULL;
4727         }
4728         if (!(folder_has_parent_of_type(item, F_DRAFT) ||
4729               folder_has_parent_of_type(item, F_QUEUE))) {
4730                 ret = g_slist_concat(ret,
4731                         imap_get_uncached_messages(session, item,
4732                                                    msgnum_list, &ok));
4733                 if (ok != MAILIMAP_NO_ERROR)
4734                         return NULL;
4735                 unlock_session(session);
4736         } else {
4737                 MsgNumberList *sorted_list, *elem, *llast = NULL;
4738                 gint startnum, lastnum;
4739
4740                 unlock_session(session);
4741
4742                 sorted_list = g_slist_sort(g_slist_copy(msgnum_list), g_int_compare);
4743
4744                 startnum = lastnum = GPOINTER_TO_INT(sorted_list->data);
4745
4746                 llast = g_slist_last(ret);
4747                 for (elem = sorted_list;; elem = g_slist_next(elem)) {
4748                         guint num = 0;
4749
4750                         if (elem)
4751                                 num = GPOINTER_TO_INT(elem->data);
4752
4753                         if (num > lastnum + 1 || elem == NULL) {
4754                                 int i;
4755                                 for (i = startnum; i <= lastnum; ++i) {
4756                                         gchar *file;
4757                                         file = imap_fetch_msg(folder, item, i);
4758                                         if (file != NULL) {
4759                                                 MsgInfo *msginfo = imap_parse_msg(file, item);
4760                                                 if (msginfo != NULL) {
4761                                                         msginfo->msgnum = i;
4762                                                         if (llast == NULL)
4763                                                                 llast = ret = g_slist_append(ret, msginfo);
4764                                                         else {
4765                                                                 llast = g_slist_append(llast, msginfo);
4766                                                                 llast = llast->next;
4767                                                         }
4768                                                 }
4769                                                 g_free(file);
4770                                         }
4771                                 }
4772
4773                                 if (elem == NULL)
4774                                         break;
4775
4776                                 startnum = num;
4777                         }
4778                         lastnum = num;
4779                 }
4780
4781                 g_slist_free(sorted_list);
4782         }
4783         return ret;
4784 }
4785
4786 MsgInfo *imap_get_msginfo(Folder *folder, FolderItem *item, gint uid)
4787 {
4788         MsgInfo *msginfo = NULL;
4789         MsgInfoList *msginfolist;
4790         MsgNumberList numlist;
4791
4792         numlist.next = NULL;
4793         numlist.data = GINT_TO_POINTER(uid);
4794
4795         msginfolist = imap_get_msginfos(folder, item, &numlist);
4796         if (msginfolist != NULL) {
4797                 msginfo = msginfolist->data;
4798                 g_slist_free(msginfolist);
4799         }
4800
4801         return msginfo;
4802 }
4803
4804 gboolean imap_scan_required(Folder *folder, FolderItem *_item)
4805 {
4806         IMAPSession *session;
4807         IMAPFolderItem *item = (IMAPFolderItem *)_item;
4808         gint ok, exists = 0, unseen = 0;
4809         guint32 uid_next = 0, uid_val = 0;
4810         gboolean selected_folder;
4811
4812         g_return_val_if_fail(folder != NULL, FALSE);
4813         g_return_val_if_fail(item != NULL, FALSE);
4814         g_return_val_if_fail(item->item.folder != NULL, FALSE);
4815         g_return_val_if_fail(FOLDER_CLASS(item->item.folder) == &imap_class, FALSE);
4816
4817         if (item->item.path == NULL)
4818                 return FALSE;
4819
4820         if (item->should_update) {
4821                 debug_print("scan already required\n");
4822                 return TRUE;
4823         }
4824         debug_print("getting session...\n");
4825         session = imap_session_get(folder);
4826
4827         g_return_val_if_fail(session != NULL, FALSE);
4828         lock_session(session); /* unlocked later in the function */
4829
4830         selected_folder = (session->mbox != NULL) &&
4831                           (!strcmp(session->mbox, item->item.path));
4832         if (selected_folder) {
4833                 if (!session->folder_content_changed) {
4834                         ok = imap_cmd_noop(session);
4835                         if (ok != MAILIMAP_NO_ERROR) {
4836                                 debug_print("disconnected!\n");
4837                                 if (!is_fatal(ok))
4838                                         session = imap_reconnect_if_possible(folder, session);
4839                                 else
4840                                         session = imap_session_get(folder);
4841                                 if (session == NULL)
4842                                         return FALSE;
4843                         }
4844
4845                         if (session->folder_content_changed) {
4846                                 debug_print("CHANGED (self-noop)! scan_required\n");
4847                                 item->should_update = TRUE;
4848                                 if (session->uid_validity && session->uid_validity != item->item.mtime) {
4849                                         item->item.mtime = session->uid_validity;
4850                                         item->should_trash_cache = TRUE;
4851                                 }
4852                                 unlock_session(session);
4853                                 return TRUE;
4854                         }
4855                 } else {
4856                         debug_print("CHANGED (previous noop)! scan_required\n");
4857                         item->should_update = TRUE;
4858                         if (session->uid_validity && session->uid_validity != item->item.mtime) {
4859                                 item->item.mtime = session->uid_validity;
4860                                 item->should_trash_cache = TRUE;
4861                         }
4862                         unlock_session(session);
4863                         return TRUE;
4864                 }
4865         } else {
4866                 ok = imap_status(session, IMAP_FOLDER(folder), item->item.path, IMAP_FOLDER_ITEM(item),
4867                                  &exists, &uid_next, &uid_val, &unseen, FALSE);
4868                 if (ok != MAILIMAP_NO_ERROR) {
4869                         return FALSE;
4870                 }
4871
4872                 debug_print("exists %d, item->item.total_msgs %d\n"
4873                             "\tunseen %d, item->item.unread_msgs %d\n"
4874                             "\tuid_next %d, item->uid_next %d\n"
4875                             "\tuid_val %d, item->item.mtime %ld\n",
4876                             exists, item->item.total_msgs, unseen, item->item.unread_msgs,
4877                             uid_next, item->uid_next, uid_val, (long)(item->item.mtime));
4878                 if (exists != item->item.total_msgs
4879                     || unseen != item->item.unread_msgs
4880                     || uid_next != item->uid_next
4881                     || uid_val != item->item.mtime) {
4882                         debug_print("CHANGED (status)! scan_required\n");
4883                         item->last_change = time(NULL);
4884                         item->should_update = TRUE;
4885                         item->uid_next = uid_next;
4886                         if (uid_val != item->item.mtime) {
4887                                 item->item.mtime = uid_val;
4888                                 item->should_trash_cache = TRUE;
4889                         }
4890                         unlock_session(session);
4891                         return TRUE;
4892                 }
4893         }
4894         unlock_session(session);
4895
4896         item->should_update = FALSE;
4897         return FALSE;
4898 }
4899
4900 void imap_change_flags(Folder *folder, FolderItem *item, MsgInfo *msginfo, MsgPermFlags newflags)
4901 {
4902         IMAPSession *session;
4903         IMAPFlags flags_set = 0, flags_unset = 0;
4904         gint ok = MAILIMAP_NO_ERROR;
4905         MsgNumberList numlist;
4906         hashtable_data *ht_data = NULL;
4907
4908         g_return_if_fail(folder != NULL);
4909         g_return_if_fail(folder->klass == &imap_class);
4910         g_return_if_fail(item != NULL);
4911         g_return_if_fail(item->folder == folder);
4912         g_return_if_fail(msginfo != NULL);
4913         g_return_if_fail(msginfo->folder == item);
4914
4915         if (!MSG_IS_MARKED(msginfo->flags) &&  (newflags & MSG_MARKED))
4916                 flags_set |= IMAP_FLAG_FLAGGED;
4917         if ( MSG_IS_MARKED(msginfo->flags) && !(newflags & MSG_MARKED))
4918                 flags_unset |= IMAP_FLAG_FLAGGED;
4919
4920         if (!MSG_IS_UNREAD(msginfo->flags) &&  (newflags & MSG_UNREAD))
4921                 flags_unset |= IMAP_FLAG_SEEN;
4922         if ( MSG_IS_UNREAD(msginfo->flags) && !(newflags & MSG_UNREAD))
4923                 flags_set |= IMAP_FLAG_SEEN;
4924
4925         if (!MSG_IS_REPLIED(msginfo->flags) &&  (newflags & MSG_REPLIED))
4926                 flags_set |= IMAP_FLAG_ANSWERED;
4927         if ( MSG_IS_REPLIED(msginfo->flags) && !(newflags & MSG_REPLIED))
4928                 flags_unset |= IMAP_FLAG_ANSWERED;
4929
4930         if (!MSG_IS_FORWARDED(msginfo->flags) &&  (newflags & MSG_FORWARDED))
4931                 flags_set |= IMAP_FLAG_FORWARDED;
4932         if ( MSG_IS_FORWARDED(msginfo->flags) && !(newflags & MSG_FORWARDED))
4933                 flags_unset |= IMAP_FLAG_FORWARDED;
4934
4935         if (!MSG_IS_SPAM(msginfo->flags) &&  (newflags & MSG_SPAM)) {
4936                 flags_set |= IMAP_FLAG_SPAM;
4937                 flags_unset |= IMAP_FLAG_HAM;
4938         }
4939         if ( MSG_IS_SPAM(msginfo->flags) && !(newflags & MSG_SPAM)) {
4940                 flags_set |= IMAP_FLAG_HAM;
4941                 flags_unset |= IMAP_FLAG_SPAM;
4942         }
4943         if (!MSG_IS_DELETED(msginfo->flags) &&  (newflags & MSG_DELETED))
4944                 flags_set |= IMAP_FLAG_DELETED;
4945         if ( MSG_IS_DELETED(msginfo->flags) && !(newflags & MSG_DELETED))
4946                 flags_unset |= IMAP_FLAG_DELETED;
4947
4948         if (!flags_set && !flags_unset) {
4949                 /* the changed flags were not translatable to IMAP-speak.
4950                  * like MSG_POSTFILTERED, so just apply. */
4951                 msginfo->flags.perm_flags = newflags;
4952                 return;
4953         }
4954
4955         debug_print("getting session...\n");
4956         session = imap_session_get(folder);
4957         if (!session) {
4958                 return;
4959         }
4960
4961         if ((ok = imap_select(session, IMAP_FOLDER(folder), msginfo->folder,
4962             NULL, NULL, NULL, NULL, NULL, FALSE)) != MAILIMAP_NO_ERROR) {
4963                 return;
4964         }
4965         numlist.next = NULL;
4966         numlist.data = GINT_TO_POINTER(msginfo->msgnum);
4967
4968         if (IMAP_FOLDER_ITEM(item)->batching) {
4969                 /* instead of performing an UID STORE command for each message change,
4970                  * as a lot of them can change "together", we just fill in hashtables
4971                  * and defer the treatment so that we're able to send only one
4972                  * command.
4973                  */
4974                 debug_print("IMAP batch mode on, deferring flags change\n");
4975                 if (flags_set) {
4976                         ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_set_table,
4977                                 GINT_TO_POINTER(flags_set));
4978                         if (ht_data == NULL) {
4979                                 ht_data = g_new0(hashtable_data, 1);
4980                                 ht_data->item = IMAP_FOLDER_ITEM(item);
4981                                 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_set_table,
4982                                         GINT_TO_POINTER(flags_set), ht_data);
4983                         }
4984                         ht_data->msglist = g_slist_prepend(ht_data->msglist, GINT_TO_POINTER(msginfo->msgnum));
4985                 }
4986                 if (flags_unset) {
4987                         ht_data = g_hash_table_lookup(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4988                                 GINT_TO_POINTER(flags_unset));
4989                         if (ht_data == NULL) {
4990                                 ht_data = g_new0(hashtable_data, 1);
4991                                 ht_data->item = IMAP_FOLDER_ITEM(item);
4992                                 g_hash_table_insert(IMAP_FOLDER_ITEM(item)->flags_unset_table,
4993                                         GINT_TO_POINTER(flags_unset), ht_data);
4994                         }
4995                         ht_data->msglist = g_slist_prepend(ht_data->msglist,
4996                                         GINT_TO_POINTER(msginfo->msgnum));
4997                 }
4998         } else {
4999                 debug_print("IMAP changing flags\n");
5000                 if (flags_set) {
5001                         ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item), &numlist, flags_set, NULL, TRUE);
5002                         if (ok != MAILIMAP_NO_ERROR) {
5003                                 return;
5004                         }
5005                 }
5006
5007                 if (flags_unset) {
5008                         ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item), &numlist, flags_unset, NULL, FALSE);
5009                         if (ok != MAILIMAP_NO_ERROR) {
5010                                 return;
5011                         }
5012                 }
5013         }
5014         msginfo->flags.perm_flags = newflags;
5015         return;
5016 }
5017
5018 static gint imap_remove_msg(Folder *folder, FolderItem *item, gint uid)
5019 {
5020         gint ok;
5021         IMAPSession *session;
5022         gchar *dir;
5023         MsgNumberList numlist;
5024
5025         g_return_val_if_fail(folder != NULL, -1);
5026         g_return_val_if_fail(FOLDER_CLASS(folder) == &imap_class, -1);
5027         g_return_val_if_fail(item != NULL, -1);
5028
5029         debug_print("getting session...\n");
5030         session = imap_session_get(folder);
5031         if (!session) return -1;
5032
5033         ok = imap_select(session, IMAP_FOLDER(folder), item,
5034                          NULL, NULL, NULL, NULL, NULL, FALSE);
5035         if (ok != MAILIMAP_NO_ERROR) {
5036                 return ok;
5037         }
5038         numlist.next = NULL;
5039         numlist.data = GINT_TO_POINTER(uid);
5040
5041         ok = imap_set_message_flags
5042                 (session, IMAP_FOLDER_ITEM(item), &numlist, IMAP_FLAG_DELETED, NULL, TRUE);
5043         if (ok != MAILIMAP_NO_ERROR) {
5044                 log_warning(LOG_PROTOCOL, _("can't set deleted flags: %d\n"), uid);
5045                 return ok;
5046         }
5047
5048         ok = imap_cmd_expunge(session);
5049
5050         if (ok != MAILIMAP_NO_ERROR) {
5051                 log_warning(LOG_PROTOCOL, _("can't expunge\n"));
5052                 return ok;
5053         }
5054
5055         IMAP_FOLDER_ITEM(item)->uid_list = g_slist_remove(
5056             IMAP_FOLDER_ITEM(item)->uid_list, numlist.data);
5057         dir = folder_item_get_path(item);
5058         if (is_dir_exist(dir))
5059                 remove_numbered_files(dir, uid, uid);
5060         g_free(dir);
5061         return MAILIMAP_NO_ERROR;
5062 }
5063
5064 static gint compare_msginfo(gconstpointer a, gconstpointer b)
5065 {
5066         return ((MsgInfo *)a)->msgnum - ((MsgInfo *)b)->msgnum;
5067 }
5068
5069 static guint gslist_find_next_num(MsgNumberList **list, guint num)
5070 {
5071         GSList *elem;
5072
5073         g_return_val_if_fail(list != NULL, -1);
5074
5075         for (elem = *list; elem != NULL; elem = g_slist_next(elem))
5076                 if (GPOINTER_TO_INT(elem->data) >= num)
5077                         break;
5078         *list = elem;
5079         return elem != NULL ? GPOINTER_TO_INT(elem->data) : (gint)-1;
5080 }
5081
5082 static gboolean flag_ok(IMAPFolderItem *item, guint flag)
5083 {
5084         if (item->ok_flags && g_slist_find(item->ok_flags, GUINT_TO_POINTER(flag))) {
5085                 debug_print("flag %d is OK\n", flag);
5086                 return TRUE;
5087         }
5088         if (item->can_create_flags == ITEM_CAN_CREATE_FLAGS) {
5089                 debug_print("creating flags is OK\n");
5090                 return TRUE;
5091         }
5092         return FALSE;
5093 }
5094
5095 /*
5096  * NEW and DELETED flags are not syncronized
5097  * - The NEW/RECENT flags in IMAP folders can not really be directly
5098  *   modified by Claws Mail
5099  * - The DELETE/DELETED flag in IMAP and Claws Mail do not have the same
5100  *   meaning, in IMAP it always removes the messages from the FolderItem
5101  *   in Claws Mail it can mean to move the message to Trash
5102  */
5103
5104 typedef struct _get_flags_data {
5105         Folder *folder;
5106         FolderItem *item;
5107         MsgInfoList *msginfo_list;
5108         GHashTable *msgflags;
5109         gboolean full_search;
5110         gboolean done;
5111 } get_flags_data;
5112
5113 static /*gint*/ void *imap_get_flags_thread(void *data)
5114 {
5115         get_flags_data *stuff = (get_flags_data *)data;
5116         Folder *folder = stuff->folder;
5117         FolderItem *fitem = (FolderItem *) stuff->item;
5118         MsgInfoList *msginfo_list = stuff->msginfo_list;
5119         GHashTable *msgflags = stuff->msgflags;
5120         GSList *elem;
5121         carray * lep_uidtab;
5122         IMAPSession *session;
5123         gint ok;
5124         int r = MAILIMAP_NO_ERROR;
5125         GHashTable *flags_hash = NULL;
5126         GHashTable *tags_hash = NULL;
5127         gboolean full_search = stuff->full_search;
5128         GSList *sorted_list = NULL;
5129         GSList *unseen = NULL, *answered = NULL, *flagged = NULL, *deleted = NULL, *forwarded = NULL, *spam = NULL;
5130         GSList *seq_list, *cur;
5131         gboolean reverse_seen = FALSE;
5132         gboolean selected_folder;
5133         gint exists_cnt, unseen_cnt;
5134         gboolean got_alien_tags = FALSE;
5135
5136         session = imap_session_get(folder);
5137
5138         if (session == NULL) {
5139                 stuff->done = TRUE;
5140                 return GINT_TO_POINTER(-1);
5141         }
5142         selected_folder = (session->mbox != NULL) &&
5143                           (!strcmp(session->mbox, fitem->path));
5144
5145         lock_session(session);
5146         if (!selected_folder) {
5147                 ok = imap_select(session, IMAP_FOLDER(folder), fitem,
5148                         &exists_cnt, NULL, &unseen_cnt, NULL, NULL, TRUE);
5149                 if (ok != MAILIMAP_NO_ERROR) {
5150                         stuff->done = TRUE;
5151                         return GINT_TO_POINTER(-1);
5152                 }
5153
5154                 if (unseen_cnt > exists_cnt / 2)
5155                         reverse_seen = TRUE;
5156         }
5157         else {
5158                 if (fitem->unread_msgs > fitem->total_msgs / 2)
5159                         reverse_seen = TRUE;
5160         }
5161
5162         sorted_list = g_slist_sort(g_slist_copy(msginfo_list), compare_msginfo);
5163         if (!full_search) {
5164                 seq_list = imap_get_lep_set_from_msglist(IMAP_FOLDER(folder), msginfo_list);
5165         } else {
5166                 struct mailimap_set * set;
5167                 set = mailimap_set_new_interval(1, 0);
5168                 seq_list = g_slist_append(NULL, set);
5169         }
5170
5171         if (folder->account && folder->account->low_bandwidth) {
5172                 for (cur = seq_list; cur != NULL; cur = g_slist_next(cur)) {
5173                         struct mailimap_set * imapset;
5174                         clist * lep_uidlist;
5175                         int r;
5176
5177                         imapset = cur->data;
5178                         if (reverse_seen) {
5179                                 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SEEN, NULL,
5180                                                          NULL, full_search ? NULL:imapset, &lep_uidlist);
5181                         }
5182                         else {
5183                                 r = imap_threaded_search(folder,
5184                                                          IMAP_SEARCH_TYPE_UNSEEN, NULL,
5185                                                          NULL, full_search ? NULL:imapset, &lep_uidlist);
5186                         }
5187                         if (r == MAILIMAP_NO_ERROR) {
5188                                 GSList * uidlist;
5189
5190                                 uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5191                                 mailimap_search_result_free(lep_uidlist);
5192
5193                                 unseen = g_slist_concat(unseen, uidlist);
5194                         } else {
5195                                 imap_handle_error(SESSION(session), NULL, r);
5196                                 goto bail;
5197                         }
5198
5199                         r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FLAGGED, NULL,
5200                                                  NULL, full_search ? NULL:imapset, &lep_uidlist);
5201                         if (r == MAILIMAP_NO_ERROR) {
5202                                 GSList * uidlist;
5203
5204                                 uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5205                                 mailimap_search_result_free(lep_uidlist);
5206
5207                                 flagged = g_slist_concat(flagged, uidlist);
5208                         } else {
5209                                 imap_handle_error(SESSION(session), NULL, r);
5210                                 goto bail;
5211                         }
5212
5213                         if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
5214                                 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_ANSWERED, NULL,
5215                                                          NULL, full_search ? NULL:imapset, &lep_uidlist);
5216                                 if (r == MAILIMAP_NO_ERROR) {
5217                                         GSList * uidlist;
5218
5219                                         uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5220                                         mailimap_search_result_free(lep_uidlist);
5221
5222                                         answered = g_slist_concat(answered, uidlist);
5223                                 } else {
5224                                         imap_handle_error(SESSION(session), NULL, r);
5225                                         goto bail;
5226                                 }
5227
5228                                 if (flag_ok(IMAP_FOLDER_ITEM(fitem), IMAP_FLAG_FORWARDED)) {
5229                                         r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_FORWARDED, NULL,
5230                                                                  NULL, full_search ? NULL:imapset, &lep_uidlist);
5231                                         if (r == MAILIMAP_NO_ERROR) {
5232                                                 GSList * uidlist;
5233
5234                                                 uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5235                                                 mailimap_search_result_free(lep_uidlist);
5236
5237                                                 forwarded = g_slist_concat(forwarded, uidlist);
5238                                         } else {
5239                                                 imap_handle_error(SESSION(session), NULL, r);
5240                                                 goto bail;
5241                                         }
5242                                 }
5243
5244                                 if (flag_ok(IMAP_FOLDER_ITEM(fitem), IMAP_FLAG_SPAM)) {
5245                                         r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_SPAM, NULL,
5246                                                                  NULL, full_search ? NULL:imapset, &lep_uidlist);
5247                                         if (r == MAILIMAP_NO_ERROR) {
5248                                                 GSList * uidlist;
5249
5250                                                 uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5251                                                 mailimap_search_result_free(lep_uidlist);
5252
5253                                                 spam = g_slist_concat(spam, uidlist);
5254                                         } else {
5255                                                 imap_handle_error(SESSION(session), NULL, r);
5256                                                 goto bail;
5257                                         }
5258                                 }
5259
5260                                 r = imap_threaded_search(folder, IMAP_SEARCH_TYPE_DELETED, NULL,
5261                                                          NULL, full_search ? NULL:imapset, &lep_uidlist);
5262                                 if (r == MAILIMAP_NO_ERROR) {
5263                                         GSList * uidlist;
5264
5265                                         uidlist = imap_uid_list_from_lep(lep_uidlist, NULL);
5266                                         mailimap_search_result_free(lep_uidlist);
5267
5268                                         deleted = g_slist_concat(deleted, uidlist);
5269                                 } else {
5270                                         imap_handle_error(SESSION(session), NULL, r);
5271                                         goto bail;
5272                                 }
5273                         }
5274                 }
5275
5276         } else {
5277                 r = imap_threaded_fetch_uid_flags(folder, 1, &lep_uidtab);
5278                 if (r == MAILIMAP_NO_ERROR) {
5279                         flags_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
5280                         tags_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
5281                         imap_flags_hash_from_lep_uid_flags_tab(lep_uidtab, flags_hash, tags_hash);
5282                         imap_fetch_uid_flags_list_free(lep_uidtab);
5283                 } else {
5284                         imap_handle_error(SESSION(session), NULL, r);
5285                         goto bail;
5286                 }
5287         }
5288
5289 bail:
5290         if (r == MAILIMAP_NO_ERROR)
5291                 unlock_session(session);
5292
5293         for (elem = sorted_list; elem != NULL; elem = g_slist_next(elem)) {
5294                 MsgInfo *msginfo;
5295                 MsgPermFlags flags, oldflags;
5296                 gboolean wasnew;
5297
5298                 msginfo = (MsgInfo *) elem->data;
5299                 flags = msginfo->flags.perm_flags;
5300                 wasnew = (flags & MSG_NEW);
5301                 oldflags = flags & ~(MSG_NEW|MSG_UNREAD|MSG_REPLIED|MSG_FORWARDED|MSG_MARKED|MSG_DELETED|MSG_SPAM);
5302
5303                 if (folder->account && folder->account->low_bandwidth) {
5304                         if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
5305                                 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW) | MSG_REPLIED | MSG_FORWARDED | MSG_MARKED | MSG_SPAM);
5306                         } else {
5307                                 flags &= ~((reverse_seen ? 0 : MSG_UNREAD | MSG_NEW | MSG_MARKED));
5308                         }
5309                         if (reverse_seen)
5310                                 flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
5311                         if (gslist_find_next_num(&unseen, msginfo->msgnum) == msginfo->msgnum) {
5312                                 if (!reverse_seen) {
5313                                         flags |= MSG_UNREAD | (wasnew ? MSG_NEW : 0);
5314                                 } else {
5315                                         flags &= ~(MSG_UNREAD | MSG_NEW);
5316                                 }
5317                         }
5318
5319                         if (gslist_find_next_num(&flagged, msginfo->msgnum) == msginfo->msgnum)
5320                                 flags |= MSG_MARKED;
5321                         else
5322                                 flags &= ~MSG_MARKED;
5323
5324                         if (fitem->opened || fitem->processing_pending || fitem == folder->inbox) {
5325                                 if (gslist_find_next_num(&answered, msginfo->msgnum) == msginfo->msgnum)
5326                                         flags |= MSG_REPLIED;
5327                                 else
5328                                         flags &= ~MSG_REPLIED;
5329                                 if (gslist_find_next_num(&forwarded, msginfo->msgnum) == msginfo->msgnum)
5330                                         flags |= MSG_FORWARDED;
5331                                 else
5332                                         flags &= ~MSG_FORWARDED;
5333                                 if (gslist_find_next_num(&spam, msginfo->msgnum) == msginfo->msgnum)
5334                                         flags |= MSG_SPAM;
5335                                 else
5336                                         flags &= ~MSG_SPAM;
5337                                 if (gslist_find_next_num(&deleted, msginfo->msgnum) == msginfo->msgnum)
5338                                         flags |= MSG_DELETED;
5339                                 else
5340                                         flags &= ~MSG_DELETED;
5341                         }
5342                 } else {
5343                         if (flags_hash != NULL) {
5344
5345                                 flags = GPOINTER_TO_INT(g_hash_table_lookup(flags_hash,
5346                                                 GINT_TO_POINTER(msginfo->msgnum)));
5347                         }
5348
5349                         if ((flags & MSG_UNREAD) == 0)
5350                                 flags &= ~MSG_NEW;
5351                         else if (wasnew)
5352                                 flags |= MSG_NEW;
5353                         flags |= oldflags;
5354
5355                         if (tags_hash != NULL) {
5356                                 GSList *tags = g_hash_table_lookup(tags_hash, GINT_TO_POINTER(msginfo->msgnum));
5357                                 GSList *cur;
5358
5359                                 g_slist_free(msginfo->tags);
5360                                 msginfo->tags = NULL;
5361
5362                                 for (cur = tags; cur; cur = cur->next) {
5363                                         gchar *real_tag = imap_modified_utf7_to_utf8(cur->data, TRUE);
5364                                         gint id = 0;
5365                                         id = tags_get_id_for_str(real_tag);
5366                                         if (id == -1) {
5367                                                 id = tags_add_tag(real_tag);
5368                                                 got_alien_tags = TRUE;
5369                                         }
5370                                         msginfo->tags = g_slist_append(
5371                                                                 msginfo->tags,
5372                                                                 GINT_TO_POINTER(id));
5373                                         g_free(real_tag);
5374                                 }
5375                                 slist_free_strings_full(tags);
5376                         }
5377                 }
5378
5379                 g_hash_table_insert(msgflags, msginfo, GINT_TO_POINTER(flags));
5380         }
5381
5382         if (got_alien_tags) {
5383                 tags_write_tags();
5384                 main_window_reflect_tags_changes(mainwindow_get_mainwindow());
5385         }
5386
5387         if (flags_hash)
5388                 g_hash_table_destroy(flags_hash);
5389         if (tags_hash)
5390                 g_hash_table_destroy(tags_hash);
5391
5392         imap_lep_set_free(seq_list);
5393         g_slist_free(flagged);
5394         g_slist_free(deleted);
5395         g_slist_free(answered);
5396         g_slist_free(forwarded);
5397         g_slist_free(spam);
5398         g_slist_free(unseen);
5399         g_slist_free(sorted_list);
5400
5401         stuff->done = TRUE;
5402         return GINT_TO_POINTER(0);
5403 }
5404
5405 static gint imap_get_flags(Folder *folder, FolderItem *item,
5406                            MsgInfoList *msginfo_list, GHashTable *msgflags)
5407 {
5408         gint result;
5409         get_flags_data *data = g_new0(get_flags_data, 1);
5410         data->done = FALSE;
5411         data->folder = folder;
5412         data->item = item;
5413         data->msginfo_list = msginfo_list;
5414         data->msgflags = msgflags;
5415         data->full_search = FALSE;
5416
5417         GSList *tmp = NULL, *cur;
5418
5419         if (prefs_common.work_offline &&
5420             !inc_offline_should_override(FALSE,
5421                 _("Claws Mail needs network access in order "
5422                   "to access the IMAP server."))) {
5423                 g_free(data);
5424                 return -1;
5425         }
5426
5427         tmp = folder_item_get_msg_list(item);
5428
5429         if (g_slist_length(tmp) <= g_slist_length(msginfo_list))
5430                 data->full_search = TRUE;
5431
5432         for (cur = tmp; cur; cur = cur->next)
5433                 procmsg_msginfo_free((MsgInfo **)&(cur->data));
5434
5435         g_slist_free(tmp);
5436
5437         result = GPOINTER_TO_INT(imap_get_flags_thread(data));
5438
5439         g_free(data);
5440         return result;
5441
5442 }
5443
5444 static gboolean process_flags(gpointer key, gpointer value, gpointer user_data)
5445 {
5446         gboolean flags_set = GPOINTER_TO_INT(user_data);
5447         gint flags_value = GPOINTER_TO_INT(key);
5448         hashtable_data *data = (hashtable_data *)value;
5449         IMAPFolderItem *_item = data->item;
5450         FolderItem *item = (FolderItem *)_item;
5451         gint ok = MAILIMAP_ERROR_BAD_STATE;
5452         IMAPSession *session = NULL;
5453
5454         debug_print("getting session...\n");
5455         session = imap_session_get(item->folder);
5456
5457         data->msglist = g_slist_reverse(data->msglist);
5458
5459         debug_print("IMAP %ssetting flags to %d for %d messages\n",
5460                 flags_set?"":"un",
5461                 flags_value,
5462                 g_slist_length(data->msglist));
5463
5464         lock_session(session);
5465         if (session) {
5466                 ok = imap_select(session, IMAP_FOLDER(item->folder), item,
5467                          NULL, NULL, NULL, NULL, NULL, FALSE);
5468         }
5469         if (ok == MAILIMAP_NO_ERROR) {
5470                 ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item),
5471                         data->msglist, flags_value, NULL, flags_set);
5472         } else {
5473                 g_warning("can't select mailbox %s", item->path);
5474         }
5475
5476         if (!is_fatal(ok))
5477                 unlock_session(session);
5478
5479         g_slist_free(data->msglist);
5480         g_free(data);
5481         return TRUE;
5482 }
5483
5484 static gboolean process_tags(gpointer key, gpointer value, gpointer user_data)
5485 {
5486         gboolean tags_set = GPOINTER_TO_INT(user_data);
5487         TagsData *data = (TagsData *)value;
5488         IMAPFolderItem *_item = data->item;
5489         FolderItem *item = (FolderItem *)_item;
5490         gchar *str = data->str;
5491         gint ok = MAILIMAP_ERROR_BAD_STATE;
5492         IMAPSession *session = NULL;
5493
5494         debug_print("getting session...\n");
5495         session = imap_session_get(item->folder);
5496
5497         data->msglist = g_slist_reverse(data->msglist);
5498
5499         debug_print("IMAP %ssetting tags %s for %d messages\n",
5500                 tags_set?"":"un",
5501                 str,
5502                 g_slist_length(data->msglist));
5503
5504         lock_session(session);
5505         if (session) {
5506                 ok = imap_select(session, IMAP_FOLDER(item->folder), item,
5507                          NULL, NULL, NULL, NULL, NULL, FALSE);
5508         }
5509         if (ok == MAILIMAP_NO_ERROR) {
5510                 GSList list;
5511                 list.data = str;
5512                 list.next = NULL;
5513                 ok = imap_set_message_flags(session, IMAP_FOLDER_ITEM(item),
5514                         data->msglist, 0, &list, tags_set);
5515         } else {
5516                 g_warning("can't select mailbox %s", item->path);
5517         }
5518
5519         if (!is_fatal(ok))
5520                 unlock_session(session);
5521
5522         g_slist_free(data->msglist);
5523         g_free(data->str);
5524         g_free(data);
5525         return TRUE;
5526 }
5527
5528 static void process_hashtable(IMAPFolderItem *item)
5529 {
5530         if (item->flags_set_table) {
5531                 g_hash_table_foreach_remove(item->flags_set_table, process_flags, GINT_TO_POINTER(TRUE));
5532                 g_hash_table_destroy(item->flags_set_table);
5533                 item->flags_set_table = NULL;
5534         }
5535         if (item->flags_unset_table) {
5536                 g_hash_table_foreach_remove(item->flags_unset_table, process_flags, GINT_TO_POINTER(FALSE));
5537                 g_hash_table_destroy(item->flags_unset_table);
5538                 item->flags_unset_table = NULL;
5539         }
5540         if (item->tags_set_table) {
5541                 g_hash_table_foreach_remove(item->tags_set_table, process_tags, GINT_TO_POINTER(TRUE));
5542                 g_hash_table_destroy(item->tags_set_table);
5543                 item->tags_set_table = NULL;
5544         }
5545         if (item->tags_unset_table) {
5546                 g_hash_table_foreach_remove(item->tags_unset_table, process_tags, GINT_TO_POINTER(FALSE));
5547                 g_hash_table_destroy(item->tags_unset_table);
5548                 item->tags_unset_table = NULL;
5549         }
5550
5551 }
5552
5553 static void imap_set_batch (Folder *folder, FolderItem *_item, gboolean batch)
5554 {
5555         IMAPFolderItem *item = (IMAPFolderItem *)_item;
5556         IMAPSession *session;
5557
5558         g_return_if_fail(item != NULL);
5559
5560         if (item->batching == batch)
5561                 return;
5562
5563         if (batch) {
5564                 item->batching = TRUE;
5565                 debug_print("IMAP switching to batch mode\n");
5566                 if (!item->flags_set_table) {
5567                         item->flags_set_table = g_hash_table_new(NULL, g_direct_equal);
5568                 }
5569                 if (!item->flags_unset_table) {
5570                         item->flags_unset_table = g_hash_table_new(NULL, g_direct_equal);
5571                 }
5572                 if (!item->tags_set_table) {
5573                         item->tags_set_table = g_hash_table_new(NULL, g_direct_equal);
5574                 }
5575                 if (!item->tags_unset_table) {
5576                         item->tags_unset_table = g_hash_table_new(NULL, g_direct_equal);
5577                 }
5578                 session = imap_session_get(folder);
5579                 if (session) {
5580                         imap_refresh_sensitivity(session);
5581                         session->sens_update_block = TRUE;
5582                 }
5583         } else {
5584                 debug_print("IMAP switching away from batch mode\n");
5585                 /* process stuff */
5586                 process_hashtable(item);
5587                 item->batching = FALSE;
5588                 session = imap_session_get(folder);
5589                 if (session) {
5590                         session->sens_update_block = FALSE;
5591                         imap_refresh_sensitivity(session);
5592                 }
5593         }
5594 }
5595
5596
5597
5598 /* data types conversion libetpan <-> claws */
5599
5600
5601
5602 #define ETPAN_IMAP_MB_MARKED      1
5603 #define ETPAN_IMAP_MB_UNMARKED    2
5604 #define ETPAN_IMAP_MB_NOSELECT    4
5605 #define ETPAN_IMAP_MB_NOINFERIORS 8
5606
5607 static int imap_flags_to_flags(struct mailimap_mbx_list_flags * imap_flags)
5608 {
5609   int flags;
5610   clistiter * cur;
5611
5612   flags = 0;
5613   if (imap_flags->mbf_type == MAILIMAP_MBX_LIST_FLAGS_SFLAG) {
5614     switch (imap_flags->mbf_sflag) {
5615     case MAILIMAP_MBX_LIST_SFLAG_MARKED:
5616       flags |= ETPAN_IMAP_MB_MARKED;
5617       break;
5618     case MAILIMAP_MBX_LIST_SFLAG_NOSELECT:
5619       flags |= ETPAN_IMAP_MB_NOSELECT;
5620       break;
5621     case MAILIMAP_MBX_LIST_SFLAG_UNMARKED:
5622       flags |= ETPAN_IMAP_MB_UNMARKED;
5623       break;
5624     }
5625   }
5626
5627   if (imap_flags->mbf_oflags) {
5628     for(cur = clist_begin(imap_flags->mbf_oflags) ; cur != NULL ;
5629         cur = clist_next(cur)) {
5630       struct mailimap_mbx_list_oflag * oflag;
5631
5632       oflag = clist_content(cur);
5633
5634       switch (oflag->of_type) {
5635       case MAILIMAP_MBX_LIST_OFLAG_NOINFERIORS:
5636         flags |= ETPAN_IMAP_MB_NOINFERIORS;
5637         break;
5638       }
5639     }
5640   }
5641   return flags;
5642 }
5643
5644 static GSList * imap_list_from_lep(IMAPFolder * folder,
5645                                    clist * list, const gchar * real_path, gboolean all)
5646 {
5647         clistiter * iter;
5648         GSList * item_list = NULL, *llast = NULL;
5649
5650         if (list) {
5651                 for(iter = clist_begin(list) ; iter != NULL ;
5652                     iter = clist_next(iter)) {
5653                         struct mailimap_mailbox_list * mb;
5654                         int flags;
5655                         char delimiter;
5656                         char * name;
5657                         char * dup_name;
5658                         gchar * base;
5659                         gchar * loc_name;
5660                         gchar * loc_path;
5661                         FolderItem *new_item;
5662
5663                         mb = clist_content(iter);
5664
5665                         if (mb == NULL)
5666                                 continue;
5667
5668                         flags = 0;
5669                         if (mb->mb_flag != NULL)
5670                                 flags = imap_flags_to_flags(mb->mb_flag);
5671
5672                         delimiter = mb->mb_delimiter;
5673                         name = mb->mb_name;
5674
5675                         dup_name = strdup(name);
5676                         if (delimiter != '\0')
5677                                 subst_char(dup_name, delimiter, '/');
5678
5679                         base = g_path_get_basename(dup_name);
5680                         if (base[0] == '.') {
5681                                 g_free(base);
5682                                 free(dup_name);
5683                                 continue;
5684                         }
5685                         if (!all && path_cmp(name, real_path) == 0) {
5686                                 g_free(base);
5687                                 free(dup_name);
5688                                 continue;
5689                         }
5690
5691                         if (!all && dup_name[strlen(dup_name)-1] == '/') {
5692                                 g_free(base);
5693                                 free(dup_name);
5694                                 continue;
5695                         }
5696
5697                         loc_name = imap_modified_utf7_to_utf8(base, FALSE);
5698                         loc_path = imap_modified_utf7_to_utf8(dup_name, FALSE);
5699
5700                         new_item = folder_item_new(FOLDER(folder), loc_name, loc_path);
5701                         if ((flags & ETPAN_IMAP_MB_NOINFERIORS) != 0)
5702                                 new_item->no_sub = TRUE;
5703                         if (strcasecmp(dup_name, "INBOX") != 0 &&
5704                             ((flags & ETPAN_IMAP_MB_NOSELECT) != 0))
5705                                 new_item->no_select = TRUE;
5706
5707                         if (item_list == NULL)
5708                                 llast = item_list = g_slist_append(item_list, new_item);
5709                         else {
5710                                 llast = g_slist_append(llast, new_item);
5711                                 llast = llast->next;
5712                         }
5713                         debug_print("folder '%s' found.\n", loc_path);
5714                         g_free(base);
5715                         g_free(loc_path);
5716                         g_free(loc_name);
5717
5718                         free(dup_name);
5719                 }
5720         }
5721         return item_list;
5722 }
5723
5724 static GSList * imap_get_lep_set_from_numlist(IMAPFolder *folder, MsgNumberList *numlist)
5725 {
5726         GSList *sorted_list, *cur;
5727         guint first, last, next;
5728         GSList *ret_list = NULL, *llast = NULL;
5729         struct mailimap_set * current_set;
5730         unsigned int item_count;
5731
5732         if (numlist == NULL)
5733                 return NULL;
5734
5735         current_set = mailimap_set_new_empty();
5736
5737         sorted_list = g_slist_copy(numlist);
5738         sorted_list = g_slist_sort(sorted_list, g_int_compare);
5739
5740         first = GPOINTER_TO_INT(sorted_list->data);
5741
5742         item_count = 0;
5743         for (cur = sorted_list; cur != NULL; cur = g_slist_next(cur)) {
5744                 if (GPOINTER_TO_INT(cur->data) == 0)
5745                         continue;
5746
5747                 item_count ++;
5748
5749                 last = GPOINTER_TO_INT(cur->data);
5750                 if (cur->next)
5751                         next = GPOINTER_TO_INT(cur->next->data);
5752                 else
5753                         next = 0;
5754
5755                 if (last + 1 != next || next == 0 || item_count >= folder->max_set_size) {
5756
5757                         struct mailimap_set_item * item;
5758                         item = mailimap_set_item_new(first, last);
5759                         mailimap_set_add(current_set, item);
5760
5761                         first = next;
5762
5763                         if (item_count >= folder->max_set_size) {
5764                                 if (ret_list == NULL)
5765                                         llast = ret_list = g_slist_append(ret_list,
5766                                                           current_set);
5767                                 else {
5768                                         llast = g_slist_append(llast, current_set);
5769                                         llast = llast->next;
5770                                 }
5771
5772                                 current_set = mailimap_set_new_empty();
5773                                 item_count = 0;
5774                         }
5775                 }
5776         }
5777
5778         if (clist_count(current_set->set_list) > 0) {
5779                 ret_list = g_slist_append(ret_list,
5780                                           current_set);
5781         }
5782
5783         g_slist_free(sorted_list);
5784
5785         return ret_list;
5786 }
5787
5788 static GSList * imap_get_lep_set_from_msglist(IMAPFolder *folder, MsgInfoList *msglist)
5789 {
5790         MsgNumberList *numlist = NULL;
5791         GSList *seq_list;
5792
5793         numlist = procmsg_get_number_list_for_msgs(msglist);
5794
5795         seq_list = imap_get_lep_set_from_numlist(folder, numlist);
5796         g_slist_free(numlist);
5797
5798         return seq_list;
5799 }
5800
5801 static GSList * imap_uid_list_from_lep(clist * list, gint* length)
5802 {
5803         clistiter * iter;
5804         GSList * result;
5805         gint len = 0;
5806
5807         result = NULL;
5808
5809         if (list) {
5810                 for(iter = clist_begin(list) ; iter != NULL ;
5811                     iter = clist_next(iter)) {
5812                         uint32_t * puid;
5813
5814                         puid = clist_content(iter);
5815                         result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
5816                         len++;
5817                 }
5818                 result = g_slist_reverse(result);
5819         }
5820         if (length)
5821                 *length = len;
5822         return result;
5823 }
5824
5825 static GSList * imap_uid_list_from_lep_tab(carray * list)
5826 {
5827         unsigned int i;
5828         GSList * result;
5829
5830         result = NULL;
5831
5832         for(i = 0 ; i < carray_count(list) ; i ++) {
5833                 uint32_t * puid;
5834
5835                 puid = carray_get(list, i);
5836                 result = g_slist_prepend(result, GINT_TO_POINTER(* puid));
5837         }
5838         result = g_slist_reverse(result);
5839         return result;
5840 }
5841
5842 static void imap_flags_hash_from_lep_uid_flags_tab(carray * list,
5843                                                    GHashTable * hash,
5844                                                    GHashTable * tags_hash)
5845 {
5846         unsigned int i;
5847
5848         for(i = 0 ; i < carray_count(list) ; i += 3) {
5849                 uint32_t * puid;
5850                 int * pflags;
5851                 GSList *tags;
5852
5853                 puid = carray_get(list, i);
5854                 pflags = carray_get(list, i + 1);
5855                 tags = carray_get(list, i + 2);
5856
5857                 g_hash_table_insert(hash, GINT_TO_POINTER(*puid), GINT_TO_POINTER(* pflags));
5858                 g_hash_table_insert(tags_hash, GINT_TO_POINTER(*puid), tags);
5859         }
5860 }
5861
5862 static MsgInfo *imap_envelope_from_lep(struct imap_fetch_env_info * info,
5863                                        FolderItem *item)
5864 {
5865         MsgInfo *msginfo = NULL;
5866         guint32 uid = 0;
5867         goffset size = 0;
5868         MsgFlags flags = {0, 0};
5869
5870         if (info->headers == NULL)
5871                 return NULL;
5872
5873         MSG_SET_TMP_FLAGS(flags, MSG_IMAP);
5874         if (folder_has_parent_of_type(item, F_QUEUE)) {
5875                 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
5876         } else if (folder_has_parent_of_type(item, F_DRAFT)) {
5877                 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
5878         }
5879         flags.perm_flags = info->flags;
5880
5881         uid = info->uid;
5882         size = (goffset) info->size;
5883         msginfo = procheader_parse_str(info->headers, flags, FALSE, FALSE);
5884
5885         if (msginfo) {
5886                 msginfo->msgnum = uid;
5887                 msginfo->size = size;
5888         }
5889
5890         return msginfo;
5891 }
5892
5893 static void imap_lep_set_free(GSList *seq_list)
5894 {
5895         GSList * cur;
5896
5897         for(cur = seq_list ; cur != NULL ; cur = g_slist_next(cur)) {
5898                 struct mailimap_set * imapset;
5899
5900                 imapset = cur->data;
5901                 mailimap_set_free(imapset);
5902         }
5903         g_slist_free(seq_list);
5904 }
5905
5906 static struct mailimap_flag_list * imap_flag_to_lep(IMAPFolderItem *item, IMAPFlags flags, GSList *tags)
5907 {
5908         struct mailimap_flag_list * flag_list;
5909         GSList *cur = tags;
5910
5911         flag_list = mailimap_flag_list_new_empty();
5912
5913         if (IMAP_IS_SEEN(flags))
5914                 mailimap_flag_list_add(flag_list,
5915                                        mailimap_flag_new_seen());
5916         if (IMAP_IS_ANSWERED(flags))
5917                 mailimap_flag_list_add(flag_list,
5918                                        mailimap_flag_new_answered());
5919         if (IMAP_IS_FLAGGED(flags))
5920                 mailimap_flag_list_add(flag_list,
5921                                        mailimap_flag_new_flagged());
5922         if (IMAP_IS_DELETED(flags))
5923                 mailimap_flag_list_add(flag_list,
5924                                        mailimap_flag_new_deleted());
5925         if (IMAP_IS_DRAFT(flags))
5926                 mailimap_flag_list_add(flag_list,
5927                                        mailimap_flag_new_draft());
5928         if (IMAP_IS_FORWARDED(flags) && flag_ok(item, IMAP_FLAG_FORWARDED))
5929                 mailimap_flag_list_add(flag_list,
5930                                        mailimap_flag_new_flag_keyword(strdup(RTAG_FORWARDED)));
5931         if (IMAP_IS_SPAM(flags) && flag_ok(item, IMAP_FLAG_SPAM))
5932                 mailimap_flag_list_add(flag_list,
5933                                        mailimap_flag_new_flag_keyword(strdup(RTAG_JUNK)));
5934         else if (IMAP_IS_HAM(flags) && flag_ok(item, IMAP_FLAG_HAM))
5935                 mailimap_flag_list_add(flag_list,
5936                                        mailimap_flag_new_flag_keyword(strdup(RTAG_NON_JUNK)));
5937
5938         for (; cur; cur = cur->next) {
5939                 gchar *enc_str =
5940                         imap_utf8_to_modified_utf7(cur->data, TRUE);
5941                 g_strstrip(enc_str);
5942
5943                 mailimap_flag_list_add(flag_list,
5944                         mailimap_flag_new_flag_keyword(enc_str));
5945         }
5946
5947         return flag_list;
5948 }
5949
5950 guint imap_folder_get_refcnt(Folder *folder)
5951 {
5952         return ((IMAPFolder *)folder)->refcnt;
5953 }
5954
5955 void imap_folder_ref(Folder *folder)
5956 {
5957         ((IMAPFolder *)folder)->refcnt++;
5958 }
5959
5960 void imap_disconnect_all(gboolean have_connectivity)
5961 {
5962         GList *list;
5963         gboolean short_timeout;
5964 #ifdef HAVE_NETWORKMANAGER_SUPPORT
5965         GError *error = NULL;
5966
5967         short_timeout = !networkmanager_is_online(&error);
5968         if(error) {
5969                 short_timeout = TRUE;
5970                 g_error_free(error);
5971         }
5972 #else
5973         short_timeout = TRUE;
5974 #endif
5975
5976         if(short_timeout)
5977                 imap_main_set_timeout(1);
5978
5979         for (list = account_get_list(); list != NULL; list = list->next) {
5980                 PrefsAccount *account = list->data;
5981                 if (account->protocol == A_IMAP4) {
5982                         RemoteFolder *folder = (RemoteFolder *)account->folder;
5983                         if (folder && folder->session) {
5984                                 if (imap_is_busy(FOLDER(folder)))
5985                                         imap_threaded_cancel(FOLDER(folder));
5986
5987                                 IMAPSession *session = (IMAPSession *)folder->session;
5988                                 if (have_connectivity)
5989                                         imap_threaded_disconnect(FOLDER(folder));
5990                                 SESSION(session)->state = SESSION_DISCONNECTED;
5991                                 SESSION(session)->sock = NULL;
5992                                 imap_safe_destroy(session);
5993                                 folder->session = NULL;
5994                         }
5995                 }
5996         }
5997
5998         if(short_timeout)
5999                 imap_main_set_timeout(prefs_common.io_timeout_secs);
6000 }
6001
6002 void imap_folder_unref(Folder *folder)
6003 {
6004         if (((IMAPFolder *)folder)->refcnt > 0)
6005                 ((IMAPFolder *)folder)->refcnt--;
6006 }
6007
6008 void imap_cancel_all(void)
6009 {
6010         GList *folderlist;
6011         GList *cur;
6012
6013         folderlist = folder_get_list();
6014         for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
6015                 Folder *folder = (Folder *) cur->data;
6016
6017                 if (folder->klass == &imap_class) {
6018                         if (imap_is_busy(folder)) {
6019                                 IMAPSession *imap_session;
6020                                 RemoteFolder *rfolder;
6021
6022                                 g_printerr("cancelled\n");
6023                                 imap_threaded_cancel(folder);
6024                                 rfolder = (RemoteFolder *) folder;
6025                                 imap_session = (IMAPSession *) rfolder->session;
6026                                 if (imap_session)
6027                                         imap_session->cancelled = 1;
6028                         }
6029                 }
6030         }
6031 }
6032
6033 gboolean imap_cancel_all_enabled(void)
6034 {
6035         GList *folderlist;
6036         GList *cur;
6037
6038         folderlist = folder_get_list();
6039         for (cur = folderlist; cur != NULL; cur = g_list_next(cur)) {
6040                 Folder *folder = (Folder *) cur->data;
6041
6042                 if (folder->klass == &imap_class) {
6043                         if (imap_is_busy(folder)) {
6044                                 return TRUE;
6045                         }
6046                 }
6047         }
6048
6049         return FALSE;
6050 }
6051
6052 static gboolean imap_is_busy(Folder *folder)
6053 {
6054         IMAPSession *imap_session;
6055         RemoteFolder *rfolder;
6056
6057         rfolder = (RemoteFolder *) folder;
6058         imap_session = (IMAPSession *) rfolder->session;
6059         if (imap_session == NULL)
6060                 return FALSE;
6061
6062         return imap_session->busy;
6063 }
6064
6065 #else /* HAVE_LIBETPAN */
6066
6067 static FolderClass imap_class;
6068
6069 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item);
6070 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag);
6071
6072 static Folder   *imap_folder_new        (const gchar    *name,
6073                                          const gchar    *path)
6074 {
6075         static gboolean missing_imap_warning = TRUE;
6076         if (missing_imap_warning) {
6077                 missing_imap_warning = FALSE;
6078                 alertpanel_error(
6079                         _("You have one or more IMAP accounts "
6080                           "defined. However this version of "
6081                           "Claws Mail has been built without "
6082                           "IMAP support; your IMAP accounts are "
6083                           "disabled.\n\n"
6084                           "You probably need to "
6085                           "install libetpan and recompile "
6086                           "Claws Mail."));
6087         }
6088         return NULL;
6089 }
6090 static gint     imap_create_tree        (Folder         *folder)
6091 {
6092         return -1;
6093 }
6094 static FolderItem *imap_create_folder   (Folder         *folder,
6095                                          FolderItem     *parent,
6096                                          const gchar    *name)
6097 {
6098         return NULL;
6099 }
6100 static gint     imap_rename_folder      (Folder         *folder,
6101                                          FolderItem     *item,
6102                                          const gchar    *name)
6103 {
6104         return -1;
6105 }
6106
6107 gchar imap_get_path_separator_for_item(FolderItem *item)
6108 {
6109         return '/';
6110 }
6111
6112 FolderClass *imap_get_class(void)
6113 {
6114         if (imap_class.idstr == NULL) {
6115                 imap_class.type = F_IMAP;
6116                 imap_class.idstr = "imap";
6117                 imap_class.uistr = "IMAP";
6118
6119                 imap_class.new_folder = imap_folder_new;
6120                 imap_class.create_tree = imap_create_tree;
6121                 imap_class.create_folder = imap_create_folder;
6122                 imap_class.rename_folder = imap_rename_folder;
6123
6124                 imap_class.set_xml = folder_set_xml;
6125                 imap_class.get_xml = folder_get_xml;
6126                 imap_class.item_set_xml = imap_item_set_xml;
6127                 imap_class.item_get_xml = imap_item_get_xml;
6128                 /* nothing implemented */
6129         }
6130
6131         return &imap_class;
6132 }
6133
6134 void imap_disconnect_all(gboolean have_connectivity)
6135 {
6136 }
6137
6138 gint imap_subscribe(Folder *folder, FolderItem *item, gchar *rpath, gboolean sub)
6139 {
6140         return -1;
6141 }
6142
6143 GList * imap_scan_subtree(Folder *folder, FolderItem *item, gboolean unsubs_only, gboolean recursive)
6144 {
6145         return NULL;
6146 }
6147
6148 void imap_cache_msg(FolderItem *item, gint msgnum)
6149 {
6150 }
6151
6152 void imap_cancel_all(void)
6153 {
6154 }
6155
6156 gboolean imap_cancel_all_enabled(void)
6157 {
6158         return FALSE;
6159 }
6160
6161 #endif
6162
6163 #ifdef HAVE_LIBETPAN
6164 static void imap_synchronise(FolderItem *item, gint days)
6165 {
6166         if (IMAP_FOLDER_ITEM(item)->last_sync == IMAP_FOLDER_ITEM(item)->last_change) {
6167                 debug_print("%s already synced\n", item->path?item->path:item->name);
6168                 return;
6169         }
6170         debug_print("syncing %s\n", item->path?item->path:item->name);
6171         imap_gtk_synchronise(item, days);
6172         IMAP_FOLDER_ITEM(item)->last_sync = IMAP_FOLDER_ITEM(item)->last_change;
6173 }
6174 #endif
6175
6176 static void imap_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
6177 {
6178 #ifdef HAVE_LIBETPAN
6179         GList *cur;
6180 #endif
6181         folder_item_set_xml(folder, item, tag);
6182
6183 #ifdef HAVE_LIBETPAN
6184         for (cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
6185                 XMLAttr *attr = (XMLAttr *) cur->data;
6186
6187                 if (!attr || !attr->name || !attr->value) continue;
6188                 if (!strcmp(attr->name, "uidnext"))
6189                         IMAP_FOLDER_ITEM(item)->uid_next = atoi(attr->value);
6190                 if (!strcmp(attr->name, "last_sync"))
6191                         IMAP_FOLDER_ITEM(item)->last_sync = atoi(attr->value);
6192                 if (!strcmp(attr->name, "last_change"))
6193                         IMAP_FOLDER_ITEM(item)->last_change = atoi(attr->value);
6194         }
6195         if (IMAP_FOLDER_ITEM(item)->last_change == 0)
6196                 IMAP_FOLDER_ITEM(item)->last_change = time(NULL);
6197 #endif
6198 }
6199
6200 static XMLTag *imap_item_get_xml(Folder *folder, FolderItem *item)
6201 {
6202         XMLTag *tag;
6203
6204         tag = folder_item_get_xml(folder, item);
6205
6206 #ifdef HAVE_LIBETPAN
6207         xml_tag_add_attr(tag, xml_attr_new_int("uidnext",
6208                         IMAP_FOLDER_ITEM(item)->uid_next));
6209         xml_tag_add_attr(tag, xml_attr_new_int("last_sync",
6210                         IMAP_FOLDER_ITEM(item)->last_sync));
6211         xml_tag_add_attr(tag, xml_attr_new_int("last_change",
6212                         IMAP_FOLDER_ITEM(item)->last_change));
6213
6214 #endif
6215         return tag;
6216 }
6217
6218 /* ===================================================================
6219  * UTF-7 conversion routines as in RFC 2192
6220  * ===================================================================
6221  * These two functions from:
6222  * libimap library.
6223  * Copyright (C) 2003-2004 Pawel Salek. */
6224
6225 /* UTF7 modified base64 alphabet */
6226 static char base64chars[] =
6227   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
6228 #define UNDEFINED 64
6229
6230 /* UTF16 definitions */
6231 #define UTF16MASK       0x03FFUL
6232 #define UTF16SHIFT      10
6233 #define UTF16BASE       0x10000UL
6234 #define UTF16HIGHSTART  0xD800UL
6235 #define UTF16HIGHEND    0xDBFFUL
6236 #define UTF16LOSTART    0xDC00UL
6237 #define UTF16LOEND      0xDFFFUL
6238
6239
6240 /* Convert an IMAP mailbox to a UTF-8 string.
6241  *  dst needs to have roughly 4 times the storage space of src
6242  *    Hex encoding can triple the size of the input
6243  *    UTF-7 can be slightly denser than UTF-8
6244  *     (worst case: 8 octets UTF-7 becomes 9 octets UTF-8)
6245  */
6246 char* imap_modified_utf7_to_utf8(const char *mbox, gboolean change_spaces)
6247 {
6248   unsigned c, i, bitcount;
6249   unsigned long ucs4, utf16, bitbuf;
6250   unsigned char base64[256];
6251   const char *src;
6252   char *dst, *res  = g_malloc(2*strlen(mbox)+1);
6253
6254   dst = res;
6255   src = mbox;
6256   if(!dst) return NULL;
6257   /* initialize modified base64 decoding table */
6258   memset(base64, UNDEFINED, sizeof (base64));
6259   for (i = 0; i < sizeof (base64chars); ++i) {
6260     base64[(unsigned)base64chars[i]] = i;
6261   }
6262
6263   /* loop until end of string */
6264   while (*src != '\0') {
6265     c = *src++;
6266     /* deal with literal characters and &- */
6267     if (c != '&' || *src == '-') {
6268       /* encode literally */
6269       if (change_spaces && c == '_')
6270         *dst++ = ' ';
6271       else
6272         *dst++ = c;
6273       /* skip over the '-' if this is an &- sequence */
6274       if (c == '&') ++src;
6275     } else {
6276       /* convert modified UTF-7 -> UTF-16 -> UCS-4 -> UTF-8 -> HEX */
6277       bitbuf = 0;
6278       bitcount = 0;
6279       ucs4 = 0;
6280       while ((c = base64[(unsigned char) *src]) != UNDEFINED) {
6281         ++src;
6282         bitbuf = (bitbuf << 6) | c;
6283         bitcount += 6;
6284         /* enough bits for a UTF-16 character? */
6285         if (bitcount >= 16) {
6286           bitcount -= 16;
6287           utf16 = (bitcount ? bitbuf >> bitcount
6288                    : bitbuf) & 0xffff;
6289           /* convert UTF16 to UCS4 */
6290           if
6291             (utf16 >= UTF16HIGHSTART && utf16 <= UTF16HIGHEND) {
6292             ucs4 = (utf16 - UTF16HIGHSTART) << UTF16SHIFT;
6293             continue;
6294           } else if
6295             (utf16 >= UTF16LOSTART && utf16 <= UTF16LOEND) {
6296             ucs4 += utf16 - UTF16LOSTART + UTF16BASE;
6297           } else {
6298             ucs4 = utf16;
6299           }
6300
6301           /* convert UTF-16 range of UCS4 to UTF-8 */
6302           if (ucs4 <= 0x7fUL) {
6303             dst[0] = ucs4;
6304             dst += 1;
6305           } else if (ucs4 <= 0x7ffUL) {
6306             dst[0] = 0xc0 | (ucs4 >> 6);
6307             dst[1] = 0x80 | (ucs4 & 0x3f);
6308             dst += 2;
6309           } else if (ucs4 <= 0xffffUL) {
6310             dst[0] = 0xe0 | (ucs4 >> 12);
6311             dst[1] = 0x80 | ((ucs4 >> 6) & 0x3f);
6312             dst[2] = 0x80 | (ucs4 & 0x3f);
6313             dst += 3;
6314           } else {
6315             dst[0] = 0xf0 | (ucs4 >> 18);
6316             dst[1] = 0x80 | ((ucs4 >> 12) & 0x3f);
6317             dst[2] = 0x80 | ((ucs4 >> 6) & 0x3f);
6318             dst[3] = 0x80 | (ucs4 & 0x3f);
6319             dst += 4;
6320           }
6321         }
6322       }
6323       /* skip over trailing '-' in modified UTF-7 encoding */
6324       if (*src == '-') ++src;
6325     }
6326   }
6327   /* terminate destination string */
6328   *dst = '\0';
6329   return res;
6330 }
6331
6332 /* Convert hex coded UTF-8 string to modified UTF-7 IMAP mailbox
6333  *  dst should be about twice the length of src to deal with non-hex
6334  *  coded URLs
6335  */
6336 char* imap_utf8_to_modified_utf7(const char *src, gboolean change_spaces)
6337 {
6338   unsigned int utf8pos, utf8total, c, utf7mode, bitstogo, utf16flag;
6339   unsigned long ucs4 = 0, bitbuf = 0;
6340
6341   /* initialize hex lookup table */
6342   char *dst, *res;
6343
6344   if (!src) return NULL;
6345
6346   res = malloc(2*strlen(src)+1);
6347   dst = res;
6348   if(!dst) return NULL;
6349
6350   utf7mode = 0;
6351   utf8total = 0;
6352   bitstogo = 0;
6353   utf8pos = 0;
6354   while ((c = (unsigned char)*src) != '\0') {
6355     ++src;
6356     /* normal character? */
6357     if (c >= ' ' && c <= '~' && (c != '_' || !change_spaces)) {
6358       /* switch out of UTF-7 mode */
6359       if (utf7mode) {
6360         if (bitstogo) {
6361           *dst++ = base64chars[(bitbuf << (6 - bitstogo)) & 0x3F];
6362         }
6363         *dst++ = '-';
6364         utf7mode = 0;
6365         utf8pos  = 0;
6366         bitstogo = 0;
6367         utf8total= 0;
6368       }
6369       if (change_spaces && c == ' ')
6370         *dst++ = '_';
6371       else
6372         *dst++ = c;
6373       /* encode '&' as '&-' */
6374       if (c == '&') {
6375         *dst++ = '-';
6376       }
6377       continue;
6378     }
6379     /* switch to UTF-7 mode */
6380     if (!utf7mode) {
6381       *dst++ = '&';
6382       utf7mode = 1;
6383     }
6384     /* Encode US-ASCII characters as themselves */
6385     if (c < 0x80) {
6386       ucs4 = c;
6387     } else if (utf8total) {
6388       /* save UTF8 bits into UCS4 */
6389       ucs4 = (ucs4 << 6) | (c & 0x3FUL);
6390       if (++utf8pos < utf8total) {
6391         continue;
6392       }
6393     } else {
6394       utf8pos = 1;
6395       if (c < 0xE0) {
6396         utf8total = 2;
6397         ucs4 = c & 0x1F;
6398       } else if (c < 0xF0) {
6399         utf8total = 3;
6400         ucs4 = c & 0x0F;
6401       } else {
6402         /* NOTE: can't convert UTF8 sequences longer than 4 */
6403         utf8total = 4;
6404         ucs4 = c & 0x03;
6405       }
6406       continue;
6407     }
6408     /* loop to split ucs4 into two utf16 chars if necessary */
6409     utf8total = 0;
6410     do {
6411       if (ucs4 >= UTF16BASE) {
6412         ucs4 -= UTF16BASE;
6413         bitbuf = (bitbuf << 16) | ((ucs4 >> UTF16SHIFT)
6414                                    + UTF16HIGHSTART);
6415         ucs4 = (ucs4 & UTF16MASK) + UTF16LOSTART;
6416         utf16flag = 1;
6417       } else {
6418         bitbuf = (bitbuf << 16) | ucs4;
6419         utf16flag = 0;
6420       }
6421       bitstogo += 16;
6422       /* spew out base64 */
6423       while (bitstogo >= 6) {
6424         bitstogo -= 6;
6425         *dst++ = base64chars[(bitstogo ? (bitbuf >> bitstogo)
6426                               : bitbuf)
6427                              & 0x3F];
6428       }
6429     } while (utf16flag);
6430   }
6431   /* if in UTF-7 mode, finish in ASCII */
6432   if (utf7mode) {
6433     if (bitstogo) {
6434       *dst++ = base64chars[(bitbuf << (6 - bitstogo)) & 0x3F];
6435     }
6436     *dst++ = '-';
6437   }
6438   /* tie off string */
6439   *dst = '\0';
6440   return res;
6441 }