src/plugins/mailmbox/mailmbox_folder.c

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