src/plugins/mailmbox/mailmbox_folder.c

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