src/plugins/mailmbox/mailmbox_folder.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto
   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, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20
  21 #ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 #  include "claws-features.h"
  24 #endif
  25
  26 #include <glib.h>
  27 #include <glib/gi18n.h>
  28
  29 #include "defs.h"
  30
  31 #include <glib.h>
  32 #include <glib/gi18n.h>
  33 #include <dirent.h>
  34 #include <sys/stat.h>
  35 #include <unistd.h>
  36 #include <string.h>
  37 #include <errno.h>
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #include <unistd.h>
  41 #include <sys/mman.h>
  42
  43 #undef MEASURE_TIME
  44
  45 #ifdef MEASURE_TIME
  46 #  include <sys/time.h>
  47 #endif
  48
  49 #include "folder.h"
  50 #include "procmsg.h"
  51 #include "procheader.h"
  52 #include "statusbar.h"
  53 #include "utils.h"
  54 #include "gtkutils.h"
  55 #include "localfolder.h"
  56 #include "mailmbox.h"
  57 #include "mailmbox_folder.h"
  58 #include "mailmbox_parse.h"
  59
  60 #define MAILMBOX_CACHE_DIR           "mailmboxcache"
  61
  62 static Folder *s_claws_mailmbox_folder_new(const gchar *name, const gchar *path);
  63
  64 static void claws_mailmbox_folder_destroy(Folder *folder);
  65
  66 static FolderItem *claws_mailmbox_folder_item_new(Folder *folder);
  67
  68 static void claws_mailmbox_folder_item_destroy(Folder *folder, FolderItem *_item);
  69
  70 static gchar *claws_mailmbox_item_get_path(Folder *folder, FolderItem *item);
  71
  72 static gint claws_mailmbox_get_num_list(Folder *folder, FolderItem *item,
  73     GSList **list, gboolean *old_uids_valid);
  74
  75 static MsgInfo *claws_mailmbox_get_msginfo(Folder *folder,
  76     FolderItem *item, gint num);
  77
  78 static GSList *claws_mailmbox_get_msginfos(Folder *folder, FolderItem *item,
  79     GSList *msgnum_list);
  80
  81 static gchar *s_claws_mailmbox_fetch_msg(Folder *folder, FolderItem *item, gint num);
  82
  83 static gint claws_mailmbox_add_msg(Folder *folder, FolderItem *dest,
  84     const gchar *file, MsgFlags *flags);
  85
  86 static gint claws_mailmbox_add_msgs(Folder *folder, FolderItem *dest,
  87     GSList *file_list,
  88     GHashTable *relation);
  89
  90 static gint s_claws_mailmbox_copy_msg(Folder *folder,
  91     FolderItem *dest, MsgInfo *msginfo);
  92
  93 static gint claws_mailmbox_copy_msgs(Folder *folder, FolderItem *dest,
  94     MsgInfoList *msglist, GHashTable *relation);
  95
  96 static gint claws_mailmbox_remove_msg(Folder *folder, FolderItem *item, gint num);
  97 static gint claws_mailmbox_remove_msgs( Folder *folder, FolderItem *item, MsgInfoList *msglist, GHashTable *relation );
  98 static gint claws_mailmbox_remove_all_msg(Folder *folder, FolderItem *item);
  99
 100 static FolderItem *claws_mailmbox_create_folder(Folder *folder, FolderItem *parent,
 101     const gchar *name);
 102
 103 static gboolean claws_mailmbox_scan_required(Folder *folder, FolderItem *_item);
 104
 105 static gint claws_mailmbox_rename_folder(Folder *folder,
 106     FolderItem *item, const gchar *name);
 107
 108 static gint claws_mailmbox_remove_folder(Folder *folder, FolderItem *item);
 109
 110 static gint claws_mailmbox_create_tree(Folder *folder);
 111
 112 static gint claws_mailmbox_folder_item_close(Folder *folder, FolderItem *item);
 113
 114 static FolderClass claws_mailmbox_class;
 115
 116 static gchar * get_cache_dir(void)
 117 {
 118         static gchar *mbox_cache_dir = NULL;
 119
 120         if (!mbox_cache_dir)
 121                 mbox_cache_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 122                                              MAILMBOX_CACHE_DIR, NULL);
 123
 124         return mbox_cache_dir;
 125 }
 126
 127
 128 FolderClass *claws_mailmbox_get_class(void)
 129 {
 130         if (claws_mailmbox_class.idstr == NULL) {
 131                 claws_mailmbox_class.type = F_MBOX;
 132                 claws_mailmbox_class.idstr = "mailmbox";
 133                 claws_mailmbox_class.uistr = "mbox";
 134
 135                 /* Folder functions */
 136                 claws_mailmbox_class.new_folder = s_claws_mailmbox_folder_new;
 137                 claws_mailmbox_class.destroy_folder = claws_mailmbox_folder_destroy;
 138                 claws_mailmbox_class.set_xml = folder_local_set_xml;
 139                 claws_mailmbox_class.get_xml = folder_local_get_xml;
 140                 claws_mailmbox_class.create_tree = claws_mailmbox_create_tree;
 141
 142                 /* FolderItem functions */
 143                 claws_mailmbox_class.item_new = claws_mailmbox_folder_item_new;
 144                 claws_mailmbox_class.item_destroy = claws_mailmbox_folder_item_destroy;
 145                 claws_mailmbox_class.item_get_path = claws_mailmbox_item_get_path;
 146                 claws_mailmbox_class.create_folder = claws_mailmbox_create_folder;
 147                 claws_mailmbox_class.rename_folder = claws_mailmbox_rename_folder;
 148                 claws_mailmbox_class.remove_folder = claws_mailmbox_remove_folder;
 149                 claws_mailmbox_class.close = claws_mailmbox_folder_item_close;
 150                 claws_mailmbox_class.get_num_list = claws_mailmbox_get_num_list;
 151                 claws_mailmbox_class.scan_required = claws_mailmbox_scan_required;
 152
 153                 /* Message functions */
 154                 claws_mailmbox_class.get_msginfo = claws_mailmbox_get_msginfo;
 155                 claws_mailmbox_class.get_msginfos = claws_mailmbox_get_msginfos;
 156                 claws_mailmbox_class.fetch_msg = s_claws_mailmbox_fetch_msg;
 157                 claws_mailmbox_class.add_msg = claws_mailmbox_add_msg;
 158                 claws_mailmbox_class.add_msgs = claws_mailmbox_add_msgs;
 159                 claws_mailmbox_class.copy_msg = s_claws_mailmbox_copy_msg;
 160                 claws_mailmbox_class.copy_msgs = claws_mailmbox_copy_msgs;
 161                 claws_mailmbox_class.remove_msg = claws_mailmbox_remove_msg;
 162                 claws_mailmbox_class.remove_msgs = claws_mailmbox_remove_msgs;
 163                 claws_mailmbox_class.remove_all_msg = claws_mailmbox_remove_all_msg;
 164         }
 165         return &claws_mailmbox_class;
 166 }
 167
 168
 169 static void claws_mailmbox_folder_init(Folder *folder,
 170     const gchar *name, const gchar *path)
 171 {
 172         folder_local_folder_init(folder, name, path);
 173 }
 174
 175 static Folder *s_claws_mailmbox_folder_new(const gchar *name, const gchar *path)
 176 {
 177         Folder *folder;
 178
 179         folder = (Folder *)g_new0(MAILMBOXFolder, 1);
 180         folder->klass = &claws_mailmbox_class;
 181         claws_mailmbox_folder_init(folder, name, path);
 182
 183         return folder;
 184 }
 185
 186 static void claws_mailmbox_folder_destroy(Folder *folder)
 187 {
 188         folder_local_folder_destroy(LOCAL_FOLDER(folder));
 189 }
 190
 191 typedef struct _MAILMBOXFolderItem      MAILMBOXFolderItem;
 192 struct _MAILMBOXFolderItem
 193 {
 194         FolderItem item;
 195         guint old_max_uid;
 196         struct claws_mailmbox_folder * mbox;
 197 };
 198
 199 static FolderItem *claws_mailmbox_folder_item_new(Folder *folder)
 200 {
 201         MAILMBOXFolderItem *item;
 202
 203         item = g_new0(MAILMBOXFolderItem, 1);
 204         item->mbox = NULL;
 205         item->old_max_uid = 0;
 206
 207         return (FolderItem *)item;
 208 }
 209
 210 #define MAX_UID_FILE "max-uid"
 211
 212 static void read_max_uid_value(FolderItem *item, guint * pmax_uid)
 213 {
 214         gchar * path;
 215         gchar * file;
 216         FILE * f;
 217         guint max_uid;
 218         size_t r;
 219
 220         path = folder_item_get_path(item);
 221         file = g_strconcat(path, G_DIR_SEPARATOR_S, MAX_UID_FILE, NULL);
 222         g_free(path);
 223
 224         f = fopen(file, "r");
 225         g_free(file);
 226         if (f == NULL)
 227                 return;
 228         r = fread(&max_uid, sizeof(max_uid), 1, f);
 229         if (r == 0) {
 230                 fclose(f);
 231                 return;
 232         }
 233
 234         fclose(f);
 235
 236         * pmax_uid = max_uid;
 237 }
 238
 239 static void write_max_uid_value(FolderItem *item, guint max_uid)
 240 {
 241         gchar * path;
 242         gchar * file;
 243         FILE * f;
 244         size_t r;
 245
 246         path = folder_item_get_path(item);
 247         file = g_strconcat(path, G_DIR_SEPARATOR_S, MAX_UID_FILE, NULL);
 248         g_free(path);
 249
 250         f = fopen(file, "w");
 251         g_free(file);
 252         if (f == NULL)
 253                 return;
 254         r = fwrite(&max_uid, sizeof(max_uid), 1, f);
 255         if (r == 0) {
 256                 fclose(f);
 257                 return;
 258         }
 259
 260         fclose(f);
 261 }
 262
 263 static void claws_mailmbox_folder_item_destroy(Folder *folder, FolderItem *_item)
 264 {
 265         MAILMBOXFolderItem *item = (MAILMBOXFolderItem *)_item;
 266
 267         g_return_if_fail(item != NULL);
 268
 269         if (item->mbox != NULL) {
 270                 write_max_uid_value(_item, item->mbox->mb_written_uid);
 271                 claws_mailmbox_done(item->mbox);
 272         }
 273         g_free(_item);
 274 }
 275
 276 static gint claws_mailmbox_folder_item_close(Folder *folder, FolderItem *item_)
 277 {
 278         MAILMBOXFolderItem *item = (MAILMBOXFolderItem *)item_;
 279
 280         g_return_val_if_fail(folder->klass->type == F_MBOX, -1);
 281         g_return_val_if_fail(item != NULL, -1);
 282         g_return_val_if_fail(item->mbox != NULL, -1);
 283
 284         return -claws_mailmbox_expunge(item->mbox);
 285 }
 286
 287 static void claws_mailmbox_folder_create_parent(const gchar * path)
 288 {
 289         if (!is_file_exist(path)) {
 290                 gchar * new_path;
 291
 292                 new_path = g_path_get_dirname(path);
 293                 if (new_path[strlen(new_path) - 1] == G_DIR_SEPARATOR)
 294                         new_path[strlen(new_path) - 1] = '\0';
 295
 296                 if (!is_dir_exist(new_path))
 297                         make_dir_hier(new_path);
 298                 g_free(new_path);
 299
 300         }
 301 }
 302
 303 static gchar * claws_mailmbox_folder_get_path(Folder *folder, FolderItem *item)
 304 {
 305         gchar *folder_path;
 306         gchar *path;
 307
 308         g_return_val_if_fail(item != NULL, NULL);
 309
 310         if (item->path && item->path[0] == G_DIR_SEPARATOR) {
 311                 claws_mailmbox_folder_create_parent(item->path);
 312                 return g_strdup(item->path);
 313         }
 314
 315         folder_path = g_strdup(LOCAL_FOLDER(item->folder)->rootpath);
 316         g_return_val_if_fail(folder_path != NULL, NULL);
 317
 318         if (folder_path[0] == G_DIR_SEPARATOR) {
 319                 if (item->path) {
 320                         path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
 321                                            item->path, NULL);
 322                 }
 323                 else
 324                         path = g_strdup(folder_path);
 325         } else {
 326                 if (item->path)
 327                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 328                                            folder_path, G_DIR_SEPARATOR_S,
 329                                            item->path, NULL);
 330                 else
 331                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 332                                            folder_path, NULL);
 333         }
 334
 335         g_free(folder_path);
 336
 337         claws_mailmbox_folder_create_parent(path);
 338
 339         return path;
 340 }
 341
 342 static int claws_mailmbox_item_sync(FolderItem *_item, int validate_uid)
 343 {
 344         MAILMBOXFolderItem *item = (MAILMBOXFolderItem *)_item;
 345         int r;
 346
 347         if (item->mbox == NULL) {
 348                 guint written_uid;
 349                 gchar * path;
 350
 351                 written_uid = 0;
 352                 read_max_uid_value(_item, &written_uid);
 353                 path = claws_mailmbox_folder_get_path(_item->folder, _item);
 354                 r = claws_mailmbox_init(path, 0, 0, written_uid, &item->mbox);
 355                 debug_print("init %d: %p\n", r, item->mbox);
 356                 g_free(path);
 357                 if (r != MAILMBOX_NO_ERROR)
 358                         return -1;
 359         }
 360
 361         if (!validate_uid) {
 362                 r = claws_mailmbox_validate_read_lock(item->mbox);
 363                 if (r != MAILMBOX_NO_ERROR) {
 364                         debug_print("read lock: %d\n", r);
 365                         goto err;
 366                 }
 367
 368                 claws_mailmbox_read_unlock(item->mbox);
 369         }
 370         else {
 371                 r = claws_mailmbox_validate_write_lock(item->mbox);
 372                 if (r != MAILMBOX_NO_ERROR) {
 373                         debug_print("write lock: %d\n", r);
 374                         goto err;
 375                 }
 376
 377                 if (item->mbox->mb_written_uid < item->mbox->mb_max_uid) {
 378                         r = claws_mailmbox_expunge_no_lock(item->mbox);
 379                         if (r != MAILMBOX_NO_ERROR)
 380                                 goto unlock;
 381                 }
 382                 claws_mailmbox_write_unlock(item->mbox);
 383         }
 384
 385         return 0;
 386
 387  unlock:
 388         claws_mailmbox_write_unlock(item->mbox);
 389  err:
 390         return -1;
 391 }
 392
 393 static struct claws_mailmbox_folder * get_mbox(FolderItem *_item, int validate_uid)
 394 {
 395         MAILMBOXFolderItem *item = (MAILMBOXFolderItem *)_item;
 396
 397         claws_mailmbox_item_sync(_item, validate_uid);
 398
 399         return item->mbox;
 400 }
 401
 402 static gint claws_mailmbox_get_num_list(Folder *folder, FolderItem *item,
 403     GSList **list, gboolean *old_uids_valid)
 404 {
 405         gint nummsgs = 0;
 406         guint i;
 407         struct claws_mailmbox_folder * mbox;
 408
 409         g_return_val_if_fail(item != NULL, -1);
 410
 411         debug_print("mbox_get_last_num(): Scanning %s ...\n", item->path);
 412
 413         *old_uids_valid = TRUE;
 414
 415         mbox = get_mbox(item, 1);
 416         if (mbox == NULL)
 417                 return -1;
 418
 419         for(i = 0 ; i < carray_count(mbox->mb_tab) ; i ++) {
 420                 struct claws_mailmbox_msg_info * msg;
 421
 422                 msg = carray_get(mbox->mb_tab, i);
 423                 if (msg != NULL) {
 424                         *list = g_slist_prepend(*list,
 425                             GINT_TO_POINTER(msg->msg_uid));
 426                         nummsgs ++;
 427                 }
 428         }
 429
 430         return nummsgs;
 431 }
 432
 433 static gchar *s_claws_mailmbox_fetch_msg(Folder *folder, FolderItem *item, gint num)
 434 {
 435         gchar *path;
 436         gchar *file;
 437         int r;
 438         struct claws_mailmbox_folder * mbox;
 439         const char * data;
 440         size_t len;
 441         FILE * f;
 442         mode_t old_mask;
 443
 444         g_return_val_if_fail(item != NULL, NULL);
 445         g_return_val_if_fail(num > 0, NULL);
 446
 447         mbox = get_mbox(item, 0);
 448         if (mbox == NULL)
 449                 return NULL;
 450
 451         path = folder_item_get_path(item);
 452         if (!is_dir_exist(path))
 453                 make_dir_hier(path);
 454         file = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
 455         g_free(path);
 456         if (is_file_exist(file)) {
 457                 return file;
 458         }
 459
 460         r = claws_mailmbox_fetch_msg(mbox, num, &data, &len);
 461         if (r != MAILMBOX_NO_ERROR)
 462                 goto free;
 463
 464         old_mask = umask(0077);
 465         f = fopen(file, "w");
 466         umask(old_mask);
 467         if (f == NULL)
 468                 goto free;
 469
 470         r = fwrite(data, 1, len, f);
 471         if (r == 0)
 472                 goto close;
 473
 474         fclose(f);
 475
 476         return file;
 477
 478  close:
 479         fclose(f);
 480         unlink(file);
 481  free:
 482         free(file);
 483         return NULL;
 484 }
 485
 486 static MsgInfo *claws_mailmbox_parse_msg(guint uid,
 487     const char * data, size_t len, FolderItem *_item)
 488 {
 489         MsgInfo *msginfo;
 490         MsgFlags flags;
 491         struct claws_mailmbox_folder * mbox;
 492         chashdatum key;
 493         chashdatum value;
 494         struct claws_mailmbox_msg_info * info;
 495         int r;
 496         MAILMBOXFolderItem * item = (MAILMBOXFolderItem *)_item;
 497
 498         flags.perm_flags = MSG_NEW|MSG_UNREAD;
 499         flags.tmp_flags = 0;
 500
 501         g_return_val_if_fail(item != NULL, NULL);
 502         g_return_val_if_fail(data != NULL, NULL);
 503
 504         if (_item->stype == F_QUEUE) {
 505                 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
 506         } else if (_item->stype == F_DRAFT) {
 507                 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
 508         }
 509
 510         mbox = item->mbox;
 511
 512         key.data = (char *) &uid;
 513         key.len = sizeof(uid);
 514
 515         r = chash_get(mbox->mb_hash, &key, &value);
 516         if (r < 0)
 517                 return NULL;
 518
 519         info = (struct claws_mailmbox_msg_info *) value.data;
 520
 521         msginfo = procheader_parse_str(data, flags, FALSE, FALSE);
 522         if (!msginfo) return NULL;
 523
 524         msginfo->msgnum = uid;
 525         msginfo->folder = _item;
 526         msginfo->size = (goffset)(info->msg_size - info->msg_start_len);
 527
 528         return msginfo;
 529 }
 530
 531 static MsgInfo *claws_mailmbox_get_msginfo(Folder *folder,
 532     FolderItem *item, gint num)
 533 {
 534         MsgInfo *msginfo;
 535         int r;
 536         const char * data;
 537         size_t len;
 538         struct claws_mailmbox_folder * mbox;
 539
 540         g_return_val_if_fail(item != NULL, NULL);
 541         g_return_val_if_fail(num > 0, NULL);
 542
 543         mbox = get_mbox(item, 0);
 544         if (mbox == NULL)
 545                 goto err;
 546
 547         r = claws_mailmbox_validate_read_lock(mbox);
 548         if (r != MAILMBOX_NO_ERROR)
 549                 goto err;
 550
 551         r = claws_mailmbox_fetch_msg_headers_no_lock(mbox, num, &data, &len);
 552         if (r != MAILMBOX_NO_ERROR)
 553                 goto unlock;
 554
 555         msginfo = claws_mailmbox_parse_msg(num, data, len, item);
 556         if (!msginfo)
 557                 goto unlock;
 558
 559         claws_mailmbox_read_unlock(mbox);
 560
 561         return msginfo;
 562
 563  unlock:
 564         claws_mailmbox_read_unlock(mbox);
 565  err:
 566         return NULL;
 567 }
 568
 569 static GSList *claws_mailmbox_get_msginfos(Folder *folder, FolderItem *item,
 570     GSList *msgnum_list)
 571 {
 572         int r;
 573         GSList * cur;
 574         GSList * ret;
 575         struct claws_mailmbox_folder * mbox;
 576
 577         g_return_val_if_fail(item != NULL, NULL);
 578
 579         mbox = get_mbox(item, 0);
 580         if (mbox == NULL)
 581                 goto err;
 582
 583         r = claws_mailmbox_validate_read_lock(mbox);
 584         if (r != MAILMBOX_NO_ERROR)
 585                 goto err;
 586
 587         ret = NULL;
 588
 589         for (cur = msgnum_list ; cur != NULL ; cur = g_slist_next(cur)) {
 590                 const char * data;
 591                 size_t len;
 592                 gint num;
 593                 MsgInfo *msginfo;
 594
 595                 num = GPOINTER_TO_INT(cur->data);
 596
 597                 r = claws_mailmbox_fetch_msg_headers_no_lock(mbox, num, &data, &len);
 598                 if (r != MAILMBOX_NO_ERROR)
 599                         continue;
 600
 601                 msginfo = claws_mailmbox_parse_msg(num, data, len, item);
 602                 if (!msginfo)
 603                         continue;
 604
 605                 ret = g_slist_append(ret, msginfo);
 606         }
 607
 608         claws_mailmbox_read_unlock(mbox);
 609
 610         return ret;
 611
 612         claws_mailmbox_read_unlock(mbox);
 613  err:
 614         return NULL;
 615 }
 616
 617 static gint claws_mailmbox_add_msg(Folder *folder, FolderItem *dest,
 618     const gchar *file, MsgFlags *flags)
 619 {
 620         gint ret;
 621         GSList file_list;
 622         MsgFileInfo fileinfo;
 623
 624         g_return_val_if_fail(file != NULL, -1);
 625
 626         fileinfo.msginfo = NULL;
 627         fileinfo.file = (gchar *)file;
 628         fileinfo.flags = flags;
 629         file_list.data = &fileinfo;
 630         file_list.next = NULL;
 631
 632         ret = claws_mailmbox_add_msgs(folder, dest, &file_list, NULL);
 633         return ret;
 634 }
 635
 636 /* ok */
 637
 638 static gint claws_mailmbox_add_msgs(Folder *folder, FolderItem *dest,
 639     GSList *file_list,
 640     GHashTable *relation)
 641 {
 642         GSList *cur;
 643         gint last_num;
 644         struct claws_mailmbox_folder * mbox;
 645         carray * append_list;
 646         struct claws_mailmbox_append_info append_info;
 647         int r;
 648
 649         g_return_val_if_fail(dest != NULL, -1);
 650         g_return_val_if_fail(file_list != NULL, -1);
 651
 652         mbox = get_mbox(dest, 0);
 653         if (mbox == NULL) {
 654                 debug_print("mbox not found\n");
 655                 return -1;
 656         }
 657         r = claws_mailmbox_validate_write_lock(mbox);
 658         if (r != MAILMBOX_NO_ERROR) {
 659                 debug_print("claws_mailmbox_validate_write_lock failed with %d\n", r);
 660                 return -1;
 661         }
 662         r = claws_mailmbox_expunge_no_lock(mbox);
 663         if (r != MAILMBOX_NO_ERROR) {
 664                 debug_print("claws_mailmbox_expunge_no_lock failed with %d\n", r);
 665                 goto unlock;
 666         }
 667
 668         last_num = -1;
 669
 670         append_list = carray_new(1);
 671         if (append_list == NULL) {
 672                 debug_print("append_list is null\n");
 673                 goto unlock;
 674         }
 675
 676         r = carray_set_size(append_list, 1);
 677         if (r < 0) {
 678                 debug_print("carray_set_size failed with %d\n", r);
 679                 goto free;
 680         }
 681
 682         carray_set(append_list, 0, &append_info);
 683
 684         for (cur = file_list; cur != NULL; cur = cur->next) {
 685                 int fd;
 686                 struct stat stat_info;
 687                 char * data;
 688                 size_t len;
 689                 struct claws_mailmbox_msg_info * msg;
 690                 size_t cur_token;
 691                 MsgFileInfo *fileinfo;
 692
 693                 fileinfo = (MsgFileInfo *)cur->data;
 694
 695                 fd = open(fileinfo->file, O_RDONLY);
 696                 if (fd == -1) {
 697                         debug_print("%s couldn't be opened\n", fileinfo->file);
 698                         goto err;
 699                 }
 700
 701                 r = fstat(fd, &stat_info);
 702                 if (r < 0) {
 703                         debug_print("%s couldn't be stat'ed\n", fileinfo->file);
 704                         goto close;
 705                 }
 706
 707                 len = stat_info.st_size;
 708                 data = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
 709                 if (data == MAP_FAILED) {
 710                         debug_print("mmap failed\n");
 711                         goto close;
 712                 }
 713
 714                 append_info.ai_message = data;
 715                 append_info.ai_size = len;
 716
 717                 cur_token = mbox->mb_mapping_size;
 718
 719                 r = claws_mailmbox_append_message_list_no_lock(mbox, append_list);
 720                 if (r != MAILMBOX_NO_ERROR) {
 721                         debug_print("claws_mailmbox_append_message_list_no_lock failed with %d\n", r);
 722                         goto unmap;
 723                 }
 724
 725                 munmap(data, len);
 726                 close(fd);
 727
 728                 r = claws_mailmbox_parse_additionnal(mbox, &cur_token);
 729                 if (r != MAILMBOX_NO_ERROR) {
 730                         debug_print("claws_mailmbox_parse_additionnal failed with %d\n", r);
 731                         goto unlock;
 732                 }
 733
 734                 msg = carray_get(mbox->mb_tab, carray_count(mbox->mb_tab) - 1);
 735
 736                 if (relation != NULL)
 737                         g_hash_table_insert(relation,
 738                             fileinfo->msginfo != NULL ?
 739                             (gpointer) fileinfo->msginfo :
 740                             (gpointer) fileinfo,
 741                             GINT_TO_POINTER(msg->msg_uid));
 742
 743                 last_num = msg->msg_uid;
 744
 745                 continue;
 746
 747         unmap:
 748                 munmap(data, len);
 749         close:
 750                 close(fd);
 751         err:
 752                 continue;
 753         }
 754
 755         claws_mailmbox_sync(mbox);
 756
 757         carray_free(append_list);
 758         claws_mailmbox_write_unlock(mbox);
 759
 760         return last_num;
 761
 762  free:
 763         carray_free(append_list);
 764  unlock:
 765         claws_mailmbox_write_unlock(mbox);
 766 return -1;
 767 }
 768
 769 static gint s_claws_mailmbox_copy_msg(Folder *folder,
 770     FolderItem *dest, MsgInfo *msginfo)
 771 {
 772         GSList msglist;
 773
 774         g_return_val_if_fail(msginfo != NULL, -1);
 775
 776         msglist.data = msginfo;
 777         msglist.next = NULL;
 778
 779         return claws_mailmbox_copy_msgs(folder, dest, &msglist, NULL);
 780 }
 781
 782 static gint claws_mailmbox_copy_msgs(Folder *folder, FolderItem *dest,
 783     MsgInfoList *msglist, GHashTable *relation)
 784 {
 785         MsgInfo *msginfo;
 786         GSList *file_list;
 787         gint ret;
 788
 789         g_return_val_if_fail(folder != NULL, -1);
 790         g_return_val_if_fail(dest != NULL, -1);
 791         g_return_val_if_fail(msglist != NULL, -1);
 792
 793         msginfo = (MsgInfo *)msglist->data;
 794         g_return_val_if_fail(msginfo->folder != NULL, -1);
 795
 796         file_list = procmsg_get_message_file_list(msglist);
 797         g_return_val_if_fail(file_list != NULL, -1);
 798
 799         ret = claws_mailmbox_add_msgs(folder, dest, file_list, relation);
 800
 801         procmsg_message_file_list_free(file_list);
 802
 803         return ret;
 804 }
 805
 806
 807 static gint claws_mailmbox_remove_msg(Folder *folder, FolderItem *item, gint num)
 808 {
 809         struct claws_mailmbox_folder * mbox;
 810         int r;
 811
 812         g_return_val_if_fail(item != NULL, -1);
 813
 814         mbox = get_mbox(item, 0);
 815         if (mbox == NULL)
 816                 return -1;
 817
 818         r = claws_mailmbox_delete_msg(mbox, num);
 819         if (r != MAILMBOX_NO_ERROR)
 820                 return -1;
 821
 822         return 0;
 823 }
 824
 825 static gint
 826 claws_mailmbox_remove_msgs( Folder *folder, FolderItem *item,
 827                             MsgInfoList *msglist, GHashTable *relation )
 828 {
 829     struct claws_mailmbox_folder *mbox;
 830     int r;
 831     gint total = 0, curnum = 0;
 832
 833     g_return_val_if_fail( item!=NULL, -1 );
 834     mbox=get_mbox(item,0);
 835     g_return_val_if_fail( mbox!=NULL, -1 );
 836
 837     total = g_slist_length(msglist);
 838     if (total > 100) {
 839         statusbar_print_all(_("Deleting messages..."));
 840     }
 841
 842     MsgInfoList *cur;
 843     for( cur=msglist; cur; cur=cur->next )
 844     {
 845        MsgInfo *msginfo=(MsgInfo*) cur->data;
 846        if( !msginfo )
 847        {
 848            continue;
 849        }
 850        if( MSG_IS_MOVE(msginfo->flags) && MSG_IS_MOVE_DONE(msginfo->flags) )
 851        {
 852            msginfo->flags.tmp_flags&=~MSG_MOVE_DONE;
 853            continue;
 854        }
 855        if (total > 100) {
 856                 statusbar_progress_all(curnum, total, 100);
 857                 if (curnum % 100 == 0)
 858                         GTK_EVENTS_FLUSH();
 859                 curnum++;
 860        }
 861       claws_mailmbox_delete_msg(mbox,msginfo->msgnum);
 862     }
 863
 864     /* Fix for bug 1434
 865      */
 866     r = claws_mailmbox_expunge(mbox);
 867     if (total > 100) {
 868                 statusbar_progress_all(0,0,0);
 869                 statusbar_pop_all();
 870     }
 871
 872     return r;
 873 }
 874
 875
 876 static gint claws_mailmbox_remove_all_msg(Folder *folder, FolderItem *item)
 877 {
 878         struct claws_mailmbox_folder * mbox;
 879         int r;
 880         guint i;
 881
 882         g_return_val_if_fail(item != NULL, -1);
 883
 884         mbox = get_mbox(item, 0);
 885         if (mbox == NULL)
 886                 return -1;
 887
 888         for(i = 0 ; i < carray_count(mbox->mb_tab) ; i ++) {
 889                 struct claws_mailmbox_msg_info * msg;
 890
 891                 msg = carray_get(mbox->mb_tab, i);
 892                 if (msg == NULL)
 893                         continue;
 894
 895                 r = claws_mailmbox_delete_msg(mbox, msg->msg_uid);
 896                 if (r != MAILMBOX_NO_ERROR)
 897                         continue;
 898         }
 899
 900         return 0;
 901 }
 902
 903
 904 static gchar * claws_mailmbox_get_new_path(FolderItem * parent, gchar * name)
 905 {
 906         gchar * path;
 907
 908         if (strchr(name, G_DIR_SEPARATOR) == NULL) {
 909                 if (parent->path != NULL)
 910                         path = g_strconcat(parent->path, ".sbd", G_DIR_SEPARATOR_S, name, NULL);
 911                 else
 912                         path = g_strdup(name);
 913         }
 914         else
 915                 path = g_strdup(name);
 916
 917         return path;
 918 }
 919
 920 static gchar * claws_mailmbox_get_folderitem_name(gchar * name)
 921 {
 922         gchar * foldername;
 923
 924         foldername = g_path_get_basename(name);
 925
 926         return foldername;
 927 }
 928
 929 static FolderItem *claws_mailmbox_create_folder(Folder *folder, FolderItem *parent,
 930     const gchar *name)
 931 {
 932         gchar * path;
 933         FolderItem *new_item;
 934         gchar * foldername;
 935
 936         g_return_val_if_fail(folder != NULL, NULL);
 937         g_return_val_if_fail(parent != NULL, NULL);
 938         g_return_val_if_fail(name != NULL, NULL);
 939
 940         path = claws_mailmbox_get_new_path(parent, (gchar *) name);
 941
 942         foldername = claws_mailmbox_get_folderitem_name((gchar *) name);
 943
 944         new_item = folder_item_new(folder, foldername, path);
 945         folder_item_append(parent, new_item);
 946
 947         if (!strcmp(name, "inbox")) {
 948                 new_item->stype = F_INBOX;
 949                 new_item->folder->inbox = new_item;
 950         } else if (!strcmp(name, "outbox")) {
 951                 new_item->stype = F_OUTBOX;
 952                 new_item->folder->outbox = new_item;
 953         } else if (!strcmp(name, "draft")) {
 954                 new_item->stype = F_DRAFT;
 955                 new_item->folder->draft = new_item;
 956         } else if (!strcmp(name, "queue")) {
 957                 new_item->stype = F_QUEUE;
 958                 new_item->folder->queue = new_item;
 959         } else if (!strcmp(name, "trash")) {
 960                 new_item->stype = F_TRASH;
 961                 new_item->folder->trash = new_item;
 962         }
 963
 964         g_free(foldername);
 965         g_free(path);
 966
 967         return new_item;
 968 }
 969
 970
 971
 972 static gboolean claws_mailmbox_scan_required(Folder *folder, FolderItem *_item)
 973 {
 974         struct claws_mailmbox_folder * mbox;
 975         MAILMBOXFolderItem *item = (MAILMBOXFolderItem *)_item;
 976         int scan_required;
 977
 978         g_return_val_if_fail(folder != NULL, FALSE);
 979         g_return_val_if_fail(item != NULL, FALSE);
 980
 981         if (item->item.path == NULL)
 982                 return FALSE;
 983
 984         mbox = get_mbox(_item, 0);
 985         if (mbox == NULL)
 986                 return FALSE;
 987
 988         scan_required = (item->old_max_uid != item->mbox->mb_max_uid);
 989
 990         item->old_max_uid = item->mbox->mb_max_uid;
 991
 992         return scan_required;
 993 }
 994
 995
 996 static gint claws_mailmbox_rename_folder(Folder *folder,
 997     FolderItem *item, const gchar *name)
 998 {
 999         gchar * path;
1000         gchar * foldername;
1001         FolderItem *parent;
1002
1003         g_return_val_if_fail(folder != NULL, -1);
1004         g_return_val_if_fail(item != NULL, -1);
1005         g_return_val_if_fail(item->path != NULL, -1);
1006         g_return_val_if_fail(name != NULL, -1);
1007
1008         parent = folder_item_parent(item);
1009         g_return_val_if_fail(parent, -1);
1010
1011         path = claws_mailmbox_get_new_path(parent, (gchar *) name);
1012         foldername = claws_mailmbox_get_folderitem_name((gchar *) name);
1013
1014         if (rename(item->path, path) == -1) {
1015                 g_free(foldername);
1016                 g_free(path);
1017                 debug_print("Cannot rename folder item\n");
1018
1019                 return -1;
1020         }
1021         else {
1022                 g_free(item->name);
1023                 g_free(item->path);
1024                 item->path = path;
1025                 item->name = foldername;
1026
1027                 return 0;
1028         }
1029 }
1030
1031 static gint claws_mailmbox_remove_folder(Folder *folder, FolderItem *item)
1032 {
1033         g_return_val_if_fail(folder != NULL, -1);
1034         g_return_val_if_fail(item != NULL, -1);
1035         g_return_val_if_fail(item->path != NULL, -1);
1036
1037         folder_item_remove(item);
1038         return 0;
1039 }
1040
1041 #define MAKE_DIR_IF_NOT_EXIST(dir) \
1042 { \
1043         if (!is_dir_exist(dir)) { \
1044                 if (is_file_exist(dir)) { \
1045                         debug_print("File `%s' already exists.\n" \
1046                                     "Can't create folder.", dir); \
1047                         return -1; \
1048                 } \
1049                 if (mkdir(dir, S_IRWXU) < 0) { \
1050                         FILE_OP_ERROR(dir, "mkdir"); \
1051                         return -1; \
1052                 } \
1053                 if (chmod(dir, S_IRWXU) < 0) \
1054                         FILE_OP_ERROR(dir, "chmod"); \
1055         } \
1056 }
1057
1058 static gint claws_mailmbox_create_tree(Folder *folder)
1059 {
1060         gchar *rootpath;
1061
1062         g_return_val_if_fail(folder != NULL, -1);
1063
1064         CHDIR_RETURN_VAL_IF_FAIL(get_home_dir(), -1);
1065         rootpath = LOCAL_FOLDER(folder)->rootpath;
1066         MAKE_DIR_IF_NOT_EXIST(rootpath);
1067         CHDIR_RETURN_VAL_IF_FAIL(rootpath, -1);
1068
1069         return 0;
1070 }
1071
1072 #undef MAKE_DIR_IF_NOT_EXIST
1073
1074
1075 static char * quote_mailbox(char * mb)
1076 {
1077         char path[PATH_MAX];
1078         char * str;
1079         size_t remaining;
1080         char * p;
1081
1082         remaining = sizeof(path) - 1;
1083         p = path;
1084
1085         while (* mb != 0) {
1086
1087                 if (((* mb >= 'a') && (* mb <= 'z')) ||
1088                     ((* mb >= 'A') && (* mb <= 'Z')) ||
1089                     ((* mb >= '0') && (* mb <= '9'))) {
1090                         if (remaining < 1)
1091                                 return NULL;
1092                         * p = * mb;
1093                         p ++;
1094                         remaining --;
1095                 }
1096                 else {
1097                         if (remaining < 3)
1098                                 return NULL;
1099                         * p = '%';
1100                         p ++;
1101                         snprintf(p, 3, "%02x", (unsigned char) (* mb));
1102                         p += 2;
1103                 }
1104                 mb ++;
1105         }
1106
1107         * p = 0;
1108
1109         str = strdup(path);
1110         if (str == NULL)
1111                 return NULL;
1112
1113         return str;
1114 }
1115
1116 static gchar *claws_mailmbox_item_get_path(Folder *folder, FolderItem *item)
1117 {
1118         gchar *itempath, *path;
1119         gchar * folderpath;
1120
1121         if (item->path == NULL)
1122                 return NULL;
1123
1124         if (folder->name == NULL)
1125                 return NULL;
1126
1127         folderpath = quote_mailbox(folder->name);
1128         if (folderpath == NULL)
1129                 return NULL;
1130         itempath = quote_mailbox(item->path);
1131         if (itempath == NULL) {
1132                 free(folderpath);
1133                 return NULL;
1134         }
1135         path = g_strconcat(get_cache_dir(),
1136             G_DIR_SEPARATOR_S, folderpath,
1137             G_DIR_SEPARATOR_S, itempath, NULL);
1138         free(itempath);
1139         free(folderpath);
1140
1141         return path;
1142 }