src/mbox_folder.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2001 Hiroyuki Yamamoto & The Sylpheed Claws Team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <glib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28
  29 #include "mbox_folder.h"
  30 #include "folder.h"
  31 #include "procmsg.h"
  32 #include "procheader.h"
  33 #include "utils.h"
  34 #include "intl.h"
  35
  36 #define MSGBUFSIZE      8192
  37
  38 static Folder *mbox_folder_new(const gchar * name, const gchar * path);
  39 static void mbox_folder_destroy(Folder * folder);
  40
  41 static gchar *mbox_fetch_msg(Folder * folder, FolderItem * item, gint num);
  42
  43 static void mbox_scan_folder(Folder * folder, FolderItem * item);
  44 static gint mbox_add_msg(Folder * folder, FolderItem * dest,
  45                          const gchar * file, MsgFlags *flags);
  46
  47 static gint mbox_remove_all_msg(Folder * folder, FolderItem * item);
  48 static gint mbox_remove_msg(Folder * folder, FolderItem * item, gint num);
  49 static void mbox_change_flags(Folder * folder, FolderItem * item,
  50                               MsgInfo * info, MsgPermFlags newflags);
  51 static gint mbox_copy_msg(Folder * folder, FolderItem * dest,
  52                           MsgInfo * msginfo);
  53 static gint mbox_create_tree(Folder * folder);
  54 static FolderItem *mbox_create_folder(Folder * folder, FolderItem * parent,
  55                                       const gchar * name);
  56 static gint mbox_rename_folder(Folder * folder, FolderItem * item,
  57                                const gchar * name);
  58 static gint mbox_remove_folder(Folder * folder, FolderItem * item);
  59
  60 static void     mbox_folder_init                (Folder         *folder,
  61                                                  const gchar    *name,
  62                                                  const gchar    *path);
  63
  64 static gboolean mbox_write_data(FILE * mbox_fp, FILE * new_fp,
  65                                 gchar * new_filename, gint size);
  66 static gboolean mbox_purge_deleted(gchar * mbox);
  67 static gchar * mbox_get_new_path(FolderItem * parent, gchar * name);
  68 static gchar * mbox_get_folderitem_name(gchar * name);
  69
  70 static MsgInfo *mbox_get_msginfo(Folder *folder, FolderItem *item, gint num);
  71 static gint mbox_get_num_list(Folder *folder, FolderItem *item,
  72                               GSList **list, gboolean *old_uids_valid);
  73 static gboolean mbox_scan_required(Folder *folder, FolderItem *item);
  74 static gchar *mbox_folder_get_path(Folder *folder, FolderItem *item);
  75
  76 FolderClass mbox_class =
  77 {
  78         F_MBOX,
  79         "mbox",
  80         "MBOX",
  81
  82         /* Folder functions */
  83         mbox_folder_new,
  84         mbox_folder_destroy,
  85         NULL,
  86         mbox_create_tree,
  87
  88         /* FolderItem functions */
  89         NULL,
  90         NULL,
  91         mbox_folder_get_path,
  92         mbox_create_folder,
  93         mbox_rename_folder,
  94         mbox_remove_folder,
  95         NULL,
  96         mbox_get_num_list,
  97         NULL,
  98         NULL,
  99         NULL,
 100         mbox_scan_required,
 101
 102         /* Message functions */
 103         mbox_get_msginfo,
 104         NULL,
 105         mbox_fetch_msg,
 106         mbox_add_msg,
 107         NULL,
 108         mbox_copy_msg,
 109         NULL,
 110         mbox_remove_msg,
 111         mbox_remove_all_msg,
 112         NULL,
 113         mbox_change_flags,
 114 };
 115
 116 FolderClass *mbox_get_class(void)
 117 {
 118         return &mbox_class;
 119 }
 120
 121 Folder *mbox_folder_new(const gchar *name, const gchar *path)
 122 {
 123         Folder *folder;
 124
 125         folder = (Folder *)g_new0(MBOXFolder, 1);
 126         folder->klass = &mbox_class;
 127         mbox_folder_init(folder, name, path);
 128
 129         return folder;
 130 }
 131
 132 void mbox_folder_destroy(Folder *folder)
 133 {
 134         folder_local_folder_destroy(LOCAL_FOLDER(folder));
 135 }
 136
 137 static void mbox_folder_init(Folder *folder, const gchar *name, const gchar *path)
 138 {
 139         folder_local_folder_init(folder, name, path);
 140 }
 141
 142 static void mbox_folder_create_parent(const gchar * path)
 143 {
 144         if (!is_file_exist(path)) {
 145                 gchar * new_path;
 146
 147                 new_path = g_dirname(path);
 148                 if (new_path[strlen(new_path) - 1] == G_DIR_SEPARATOR)
 149                         new_path[strlen(new_path) - 1] = '\0';
 150
 151                 if (!is_dir_exist(new_path))
 152                         make_dir_hier(new_path);
 153                 g_free(new_path);
 154
 155         }
 156 }
 157
 158
 159 gchar *mbox_folder_get_path(Folder *folder, FolderItem *item)
 160 {
 161         gchar *folder_path;
 162         gchar *path;
 163
 164         g_return_val_if_fail(item != NULL, NULL);
 165
 166         if (item->path && item->path[0] == G_DIR_SEPARATOR) {
 167                 mbox_folder_create_parent(item->path);
 168                 return g_strdup(item->path);
 169         }
 170
 171         folder_path = g_strdup(LOCAL_FOLDER(item->folder)->rootpath);
 172         g_return_val_if_fail(folder_path != NULL, NULL);
 173
 174         if (folder_path[0] == G_DIR_SEPARATOR) {
 175                 if (item->path) {
 176                         path = g_strconcat(folder_path, G_DIR_SEPARATOR_S,
 177                                            item->path, NULL);
 178                 }
 179                 else
 180                         path = g_strdup(folder_path);
 181         } else {
 182                 if (item->path)
 183                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 184                                            folder_path, G_DIR_SEPARATOR_S,
 185                                            item->path, NULL);
 186                 else
 187                         path = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S,
 188                                            folder_path, NULL);
 189         }
 190
 191         g_free(folder_path);
 192
 193         mbox_folder_create_parent(path);
 194
 195         return path;
 196 }
 197
 198
 199 /**********************************************************/
 200 /*                                                        */
 201 /*                   file lock                            */
 202 /*                                                        */
 203 /**********************************************************/
 204
 205
 206 static GSList * file_lock = NULL;
 207
 208 static gboolean mbox_file_lock_file(gchar * base)
 209 {
 210         gchar *lockfile, *locklink;
 211         gint retry = 0;
 212         FILE *lockfp;
 213
 214         lockfile = g_strdup_printf("%s.%d", base, getpid());
 215         if ((lockfp = fopen(lockfile, "wb")) == NULL) {
 216                 FILE_OP_ERROR(lockfile, "fopen");
 217                 g_warning("can't create lock file %s\n", lockfile);
 218                 g_warning("use 'flock' instead of 'file' if possible.\n");
 219                 g_free(lockfile);
 220                 return FALSE;
 221         }
 222
 223         fprintf(lockfp, "%d\n", getpid());
 224         fclose(lockfp);
 225
 226         locklink = g_strconcat(base, ".lock", NULL);
 227         while (link(lockfile, locklink) < 0) {
 228                 FILE_OP_ERROR(lockfile, "link");
 229                 if (retry >= 5) {
 230                         g_warning("can't create %s\n", lockfile);
 231                         unlink(lockfile);
 232                         g_free(lockfile);
 233                         g_free(locklink);
 234                         return -1;
 235                 }
 236                 if (retry == 0)
 237                         g_warning("mailbox is owned by another"
 238                                     " process, waiting...\n");
 239                 retry++;
 240                 sleep(5);
 241         }
 242         unlink(lockfile);
 243         g_free(lockfile);
 244         g_free(locklink);
 245
 246         return TRUE;
 247 }
 248
 249 static gboolean mbox_fcntl_lockwrite_file(FILE * fp)
 250 {
 251         struct flock lck;
 252
 253         lck.l_type = F_WRLCK;
 254         lck.l_whence = 0;
 255         lck.l_start = 0;
 256         lck.l_len = 0;
 257
 258         if (fcntl(fileno(fp), F_SETLK, &lck) < 0)
 259                 return FALSE;
 260         else
 261                 return TRUE;
 262 }
 263
 264 static gboolean mbox_fcntl_lockread_file(FILE * fp)
 265 {
 266         struct flock lck;
 267
 268         lck.l_type = F_RDLCK;
 269         lck.l_whence = 0;
 270         lck.l_start = 0;
 271         lck.l_len = 0;
 272
 273         if (fcntl(fileno(fp), F_SETLK, &lck) < 0)
 274                 return FALSE;
 275         else
 276                 return TRUE;
 277 }
 278
 279 static gboolean mbox_fcntl_unlock_file(FILE * fp)
 280 {
 281         struct flock lck;
 282
 283         lck.l_type = F_UNLCK;
 284         lck.l_whence = 0;
 285         lck.l_start = 0;
 286         lck.l_len = 0;
 287
 288         if (fcntl(fileno(fp), F_SETLK, &lck) < 0)
 289                 return FALSE;
 290         else
 291                 return TRUE;
 292 }
 293
 294 static gboolean mbox_file_unlock_file(gchar * base)
 295 {
 296         gchar *lockfile;
 297
 298         lockfile = g_strdup_printf("%s.lock", base);
 299         unlink(lockfile);
 300         g_free(lockfile);
 301
 302         return TRUE;
 303 }
 304
 305 static gboolean mbox_lockread_file(FILE * fp, gchar * base)
 306 {
 307         gboolean result;
 308
 309         result = mbox_fcntl_lockread_file(fp);
 310         if (!result) {
 311                 if ((result = mbox_file_lock_file(base)) == TRUE) {
 312                         file_lock = g_slist_append(file_lock, g_strdup(base));
 313                         debug_print("lockfile lock %s.\n", base);
 314                 }
 315                 else
 316                         g_warning("could not lock read file %s\n", base);
 317         }
 318         else
 319                 debug_print("fcntl lock %s.\n", base);
 320
 321         return result;
 322 }
 323
 324 static gboolean mbox_lockwrite_file(FILE * fp, gchar * base)
 325 {
 326         gboolean result;
 327
 328         result = mbox_fcntl_lockwrite_file(fp);
 329         if (!result) {
 330                 if ((result = mbox_file_lock_file(base)) == TRUE) {
 331                         file_lock = g_slist_append(file_lock, g_strdup(base));
 332                         debug_print("lockfile lock %s.\n", base);
 333                 }
 334                 else
 335                         g_warning("could not lock write file %s\n", base);
 336         }
 337         else
 338                 debug_print("fcntl lock %s.\n", base);
 339
 340         return result;
 341 }
 342
 343 static gboolean mbox_unlock_file(FILE * fp, gchar * base)
 344 {
 345         gboolean result = FALSE;
 346         GSList * l;
 347         gboolean unlocked = FALSE;
 348
 349         for(l = file_lock ; l != NULL ; l = g_slist_next(l)) {
 350                 gchar * data = l->data;
 351
 352                 if (strcmp(data, base) == 0) {
 353                         file_lock = g_slist_remove(file_lock, data);
 354                         g_free(data);
 355                         result = mbox_file_unlock_file(base);
 356                         unlocked = TRUE;
 357                         debug_print("lockfile unlock - %s.\n", base);
 358                         break;
 359                 }
 360         }
 361
 362         if (!unlocked) {
 363                 result = mbox_fcntl_unlock_file(fp);
 364                 debug_print("fcntl unlock - %s.\n", base);
 365         }
 366
 367         return result;
 368 }
 369
 370 /**********************************************************/
 371 /*                                                        */
 372 /*                   mbox parsing                         */
 373 /*                                                        */
 374 /**********************************************************/
 375
 376 #define MAILFILE_ERROR_NO_ERROR          0x000
 377 #define MAILFILE_ERROR_FILE_NOT_FOUND    0x001
 378 #define MAILFILE_ERROR_MEMORY            0x002
 379 #define MAILFILE_ERROR_MESSAGE_NOT_FOUND 0x003
 380
 381 static int mailfile_error = MAILFILE_ERROR_NO_ERROR;
 382
 383 #define STATE_BEGIN       0x000
 384 #define STATE_TEXT_READ   0x001
 385 #define STATE_FROM_READ   0x002
 386 #define STATE_FIELD_READ  0x003
 387 #define STATE_END         0x004
 388 #define STATE_END_OF_FILE 0x005
 389 #define STATE_MEM_ERROR   0x006
 390 #define STATE_TEXT_BEGIN  0x007
 391
 392 #define STATE_MASK        0x0FF /* filter state from functions */
 393
 394 #define STATE_RESTORE_POS       0x100 /* go back while reading */
 395
 396 typedef struct _mailfile mailfile;
 397
 398 struct _mailfile
 399 {
 400         gint count;
 401         gchar * filename;
 402         GList * msg_list;
 403 };
 404
 405 struct _message
 406 {
 407         int msgnum;
 408         int offset;
 409         int header;
 410         int content;
 411         int end;
 412         int marked;
 413         gchar * messageid;
 414         gchar * fromspace;
 415         MsgFlags flags;
 416         MsgFlags old_flags;
 417         gboolean fetched;
 418 };
 419
 420 #define MSG_IS_INVALID(msg) \
 421         ((msg).perm_flags == (msg).tmp_flags && (msg).tmp_flags == -1)
 422
 423 #define MSG_SET_INVALID(msg) \
 424         ((msg).perm_flags = (msg).tmp_flags = -1)
 425
 426 static int startFrom(char * s)
 427 {
 428         return (strncmp(s, "From ", 5) == 0);
 429 }
 430
 431 static int startSpace(char * s)
 432 {
 433         return ((*s == ' ') || (*s == '\t'));
 434 }
 435
 436 static int startEmpty(char * s)
 437 {
 438         return (*s == '\n');
 439 }
 440
 441 static void free_msg_list(GList * l)
 442 {
 443         GList * elt = g_list_first(l);
 444
 445         while (elt)
 446                 {
 447                         g_free(elt->data);
 448                         elt = g_list_next(elt);
 449                 }
 450
 451         g_list_free(l);
 452 }
 453
 454
 455 static mailfile * mailfile_init_from_file(FILE * f, gchar * filename)
 456 {
 457         int state;
 458         GList * msg_list = NULL;
 459         char * r = NULL;
 460         char s[256];
 461         int lastpos = 0;
 462         int former_pos = 0;
 463         int ignore_next = 0;
 464         int msgnum = 0;
 465         struct _message * data = NULL;
 466         mailfile * mf;
 467
 468         state = STATE_BEGIN;
 469
 470
 471         while (state != STATE_END_OF_FILE) {
 472                 if ((state & STATE_RESTORE_POS) == 0) {
 473                         former_pos = lastpos;
 474                         lastpos = ftell(f);
 475
 476                         r = fgets(s, 256, f);
 477
 478                         if (r != NULL && *r)
 479                                 ignore_next = (s[strlen(s) - 1] != '\n');
 480                         else
 481                                 ignore_next = 0;
 482                 }
 483
 484                 switch(state & 0x0F) {
 485                 case STATE_BEGIN:
 486                         if (r == NULL)
 487                                 state = STATE_END_OF_FILE;
 488                         else if (startFrom(s)) {
 489                                 state = STATE_FROM_READ;
 490
 491                                 data = g_new0(struct _message, 1);
 492                                 if (data == NULL) {
 493                                         free_msg_list(msg_list);
 494                                         return NULL;
 495                                 }
 496
 497                                 msgnum ++;
 498                                 data->msgnum = msgnum;
 499                                 data->offset = lastpos;
 500                                 data->header = lastpos;
 501                                 data->end = 0;
 502                                 data->content = 0;
 503                                 data->messageid = NULL;
 504                                 data->fromspace = NULL;
 505                                 MSG_SET_INVALID(data->flags);
 506                                 MSG_SET_INVALID(data->old_flags);
 507                                 data->fetched = FALSE;
 508                                 msg_list = g_list_append(msg_list,
 509                                                          (gpointer) data);
 510                         }
 511                         else
 512                                 state = STATE_BEGIN;
 513
 514                         break;
 515
 516                 case STATE_TEXT_READ:
 517                         if (r == NULL)
 518                                 state = STATE_END;
 519                         else if (startFrom(s))
 520                                 state = STATE_END | STATE_RESTORE_POS;
 521                         else
 522                                 state = STATE_TEXT_READ;
 523                         break;
 524
 525                 case STATE_TEXT_BEGIN:
 526                         data->content = lastpos;
 527                         if (r == NULL)
 528                                 state = STATE_END;
 529                         else if (startFrom(s)) {
 530                                 state = STATE_END | STATE_RESTORE_POS;
 531                         }
 532                         else {
 533                                 state = STATE_TEXT_READ;
 534                         }
 535                         break;
 536
 537                 case STATE_FROM_READ:
 538                         data->content = lastpos;
 539                         if (r == NULL)
 540                                 state = STATE_END;
 541                         else if (startSpace(s))
 542                                 state = STATE_FROM_READ;
 543                         else if (startEmpty(s))
 544                                 state = STATE_TEXT_READ;
 545                         else
 546                                 state = STATE_FIELD_READ;
 547                         break;
 548
 549                 case STATE_FIELD_READ:
 550                         data->content = lastpos;
 551                         if (r == NULL)
 552                                 state = STATE_END;
 553                         else if (startSpace(s))
 554                                 state = STATE_FIELD_READ;
 555                         else if (startEmpty(s)) {
 556                                 state = STATE_TEXT_BEGIN;
 557                         }
 558                         else
 559                                 state = STATE_FIELD_READ;
 560                         break;
 561                 }
 562
 563                 if ((state & STATE_MASK) == STATE_END) {
 564                         state = STATE_BEGIN | (state & STATE_RESTORE_POS);
 565                         data->end = lastpos;
 566                 }
 567
 568                 if (ignore_next) {
 569                         do {
 570                                 r = fgets(s, 256, f);
 571                                 if (r == NULL || *r == '\0')
 572                                         break;
 573                         }
 574                         while (s[strlen(s) - 1] != '\n');
 575                 }
 576         }
 577
 578         mf = (mailfile *) g_new0(struct _mailfile, 1);
 579         if (mf == NULL) {
 580                 free_msg_list(msg_list);
 581                 mailfile_error = MAILFILE_ERROR_MEMORY;
 582                 return NULL;
 583         }
 584
 585         mf->msg_list = g_list_first(msg_list);
 586
 587         mf->filename = g_strdup(filename);
 588         mf->count = msgnum;
 589
 590         mailfile_error = MAILFILE_ERROR_NO_ERROR;
 591
 592         return mf;
 593 }
 594
 595 static mailfile * mailfile_init(char * filename)
 596 {
 597
 598         FILE * f;
 599         mailfile * mf;
 600
 601         f = fopen(filename, "rb");
 602
 603         if (f == NULL) {
 604                 mailfile_error = MAILFILE_ERROR_FILE_NOT_FOUND;
 605                 return NULL;
 606         }
 607
 608         mbox_lockread_file(f, filename);
 609
 610         mf = mailfile_init_from_file(f, filename);
 611
 612         mbox_unlock_file(f, filename);
 613
 614         fclose(f);
 615
 616         return mf;
 617 }
 618
 619 static void mailfile_done(mailfile * f)
 620 {
 621         free_msg_list(f->msg_list);
 622         g_free(f->filename);
 623
 624         g_free(f);
 625 }
 626
 627 /*
 628 #define MAX_READ 4096
 629
 630 static char * readfile(char * filename, int offset, int max_offset)
 631 {
 632         char * message;
 633         int size;
 634         int pos;
 635         int max;
 636         int bread;
 637         FILE * handle;
 638
 639         handle = fopen(filename, "rb");
 640
 641         if (handle == NULL) {
 642                 mailfile_error = MAILFILE_ERROR_FILE_NOT_FOUND;
 643                 return NULL;
 644         }
 645
 646         size = max_offset - offset;
 647
 648         message = (char *) malloc(size + 1);
 649         if (message == NULL) {
 650                 fclose(handle);
 651                 mailfile_error = MAILFILE_ERROR_MEMORY;
 652                 return NULL;
 653         }
 654
 655         fseek(handle, offset, SEEK_SET);
 656
 657         pos = 0;
 658         while (pos < size) {
 659                 if ((size - pos) > MAX_READ)
 660                         max = MAX_READ;
 661                 else
 662                         max = (size - pos);
 663
 664                 bread = fread(message + pos, 1, max, handle);
 665
 666                 if (bread != -1)
 667                         pos += bread;
 668
 669                 if (bread < max)
 670                         break;
 671         }
 672
 673         message[pos] = 0;
 674
 675         fclose(handle);
 676
 677         return message;
 678 }
 679
 680 static char * mailfile_readmsg(mailfile f, int index)
 681 {
 682         GList * nth;
 683         int max_offset;
 684         int offset;
 685         char * message;
 686         struct _message * msginfo;
 687
 688         nth = g_list_nth(f->msg_list, index);
 689
 690         if (!nth) {
 691                 mailfile_error = MAILFILE_ERROR_MESSAGE_NOT_FOUND;
 692                 return NULL;
 693         }
 694
 695         msginfo = (struct _message *)nth->data;
 696
 697         offset = msginfo->offset;
 698         max_offset = msginfo->end;
 699         message = readfile(f->filename, offset, max_offset);
 700
 701         mailfile_error = MAILFILE_ERROR_NO_ERROR;
 702
 703         return message;
 704 }
 705
 706 static char * mailfile_readheader(mailfile f, int index)
 707 {
 708         GList * nth;
 709         int max_offset;
 710         int offset;
 711         char * message;
 712         struct _message * msginfo;
 713
 714         nth = g_list_nth(f->msg_list, index);
 715
 716         if (!nth) {
 717                 mailfile_error = MAILFILE_ERROR_MESSAGE_NOT_FOUND;
 718                 return NULL;
 719         }
 720
 721         msginfo = (struct _message *)nth->data;
 722
 723         offset = msginfo->offset;
 724         max_offset = msginfo->content;
 725         message = readfile(f->filename, offset, max_offset);
 726
 727         mailfile_error = MAILFILE_ERROR_NO_ERROR;
 728
 729         return message;
 730 }
 731
 732 static int mailfile_count(mailfile * f)
 733 {
 734         return g_list_length(f->msg_list);
 735 }
 736
 737 static int mailfile_find_deleted(mailfile f, char * filename)
 738 {
 739         FILE * handle;
 740
 741         handle = fopen(filename, "rb");
 742
 743         while (elt) {
 744                 struct _message m = elt->data;
 745                 n = fread(&m.deleted, sizeof(int), 1, handle);
 746                 if (!n)
 747                         break;
 748                 elt = g_list_next(elt);
 749         }
 750
 751         fclose(handle);
 752 }
 753 */
 754
 755
 756
 757 /**********************************************************/
 758 /*                                                        */
 759 /*                   mbox cache operations                */
 760 /*                                                        */
 761 /**********************************************************/
 762
 763 struct _mboxcache {
 764         gchar * filename;
 765         mailfile * mf;
 766         GPtrArray * tab_mf;
 767         gint mtime;
 768         gboolean modification;
 769 };
 770
 771 typedef struct _mboxcache mboxcache;
 772
 773 static GHashTable * mbox_cache_table = NULL;
 774
 775 static MsgInfo *mbox_parse_msg(FILE * fp, struct _message * msg,
 776                                FolderItem *item)
 777 {
 778         MsgInfo *msginfo;
 779         MsgFlags flags = { 0, 0 };
 780
 781         MSG_SET_PERM_FLAGS(flags, MSG_NEW | MSG_UNREAD);
 782
 783         g_return_val_if_fail(fp != NULL, NULL);
 784
 785         if (item != NULL) {
 786                 if (item->stype == F_QUEUE) {
 787                         MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
 788                 } else if (item->stype == F_DRAFT) {
 789                         MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
 790                 }
 791         }
 792
 793         msginfo = procheader_parse_stream(fp, flags, FALSE, FALSE);
 794
 795         if (!msginfo) return NULL;
 796
 797         if (item != NULL) {
 798                 msginfo->msgnum = msg->msgnum;
 799                 msginfo->folder = item;
 800         }
 801
 802         return msginfo;
 803 }
 804
 805 static void mbox_cache_init()
 806 {
 807         mbox_cache_table = g_hash_table_new(g_str_hash, g_str_equal);
 808 }
 809
 810 static void mbox_cache_free_mbox(mboxcache * cache)
 811 {
 812         g_hash_table_remove(mbox_cache_table, cache->filename);
 813
 814         if (cache->mf)
 815                 mailfile_done(cache->mf);
 816         if (cache->tab_mf)
 817                 g_ptr_array_free(cache->tab_mf, FALSE);
 818         if (cache->filename)
 819                 g_free(cache->filename);
 820         g_free(cache);
 821 }
 822
 823 static void mbox_cache_get_msginfo_from_file(FILE * fp, GList * msg_list)
 824 {
 825         GList * l;
 826         MsgInfo * msginfo;
 827
 828         for(l = msg_list ; l != NULL ; l = g_list_next(l)) {
 829                 struct _message * msg;
 830
 831                 msg = (struct _message *) l->data;
 832
 833                 fseek(fp, msg->header, SEEK_SET);
 834                 msginfo = mbox_parse_msg(fp, msg, NULL);
 835                 if (msginfo) {
 836                         if (msginfo->msgid)
 837                                 msg->messageid =
 838                                         g_strdup(msginfo->msgid);
 839                         if (msginfo->fromspace)
 840                                 msg->fromspace =
 841                                         g_strdup(msginfo->fromspace);
 842                         msg->flags = msginfo->flags;
 843                         msg->old_flags = msginfo->flags;
 844
 845                         procmsg_msginfo_free(msginfo);
 846                 }
 847         }
 848 }
 849
 850 static void mbox_cache_get_msginfo(gchar * filename, GList * msg_list)
 851 {
 852         FILE * fp;
 853
 854         fp = fopen(filename, "rb");
 855         if (fp == NULL)
 856                 return;
 857
 858         mbox_cache_get_msginfo_from_file(fp, msg_list);
 859         fclose(fp);
 860 }
 861
 862 static mboxcache * mbox_cache_read_mbox(gchar * filename)
 863 {
 864         mboxcache * cache;
 865         struct stat s;
 866         mailfile * mf;
 867         GList * l;
 868
 869         if (stat(filename, &s) < 0)
 870                 return NULL;
 871
 872         mf = mailfile_init(filename);
 873         if (mf == NULL)
 874                 return NULL;
 875
 876         cache = g_new0(mboxcache, 1);
 877
 878         cache->mtime = s.st_mtime;
 879         cache->mf = mf;
 880         cache->filename = g_strdup(filename);
 881         cache->modification = FALSE;
 882
 883         cache->tab_mf = g_ptr_array_new();
 884         for(l = mf->msg_list ; l != NULL ; l = g_list_next(l))
 885                 g_ptr_array_add(cache->tab_mf, l->data);
 886
 887         mbox_cache_get_msginfo(filename, mf->msg_list);
 888
 889         debug_print("read mbox - %s\n", filename);
 890
 891         return cache;
 892 }
 893
 894 static mboxcache * mbox_cache_read_mbox_from_file(FILE * fp, gchar * filename)
 895 {
 896         mboxcache * cache;
 897         struct stat s;
 898         mailfile * mf;
 899         GList * l;
 900
 901         if (stat(filename, &s) < 0)
 902                 return NULL;
 903
 904         mf = mailfile_init_from_file(fp, filename);
 905         if (mf == NULL)
 906                 return NULL;
 907
 908         cache = g_new0(mboxcache, 1);
 909
 910         cache->mtime = s.st_mtime;
 911         cache->mf = mf;
 912         cache->filename = g_strdup(filename);
 913
 914         cache->tab_mf = g_ptr_array_new();
 915         for(l = mf->msg_list ; l != NULL ; l = g_list_next(l))
 916                 g_ptr_array_add(cache->tab_mf, l->data);
 917
 918         mbox_cache_get_msginfo_from_file(fp, mf->msg_list);
 919
 920         debug_print("read mbox from file - %s\n", filename);
 921
 922         return cache;
 923 }
 924
 925 static void mbox_cache_insert_mbox(mboxcache * data)
 926 {
 927         if (mbox_cache_table == NULL)
 928                 mbox_cache_init();
 929
 930         g_hash_table_insert(mbox_cache_table, data->filename, data);
 931 }
 932
 933 static mboxcache * mbox_cache_get_mbox(gchar * filename)
 934 {
 935         if (mbox_cache_table == NULL)
 936                 mbox_cache_init();
 937
 938         return g_hash_table_lookup(mbox_cache_table, filename);
 939 }
 940
 941
 942 static gint mbox_cache_get_count(gchar * filename)
 943 {
 944         mboxcache * cache;
 945
 946         cache = mbox_cache_get_mbox(filename);
 947         if (cache == NULL)
 948                 return -1;
 949         if (cache->mf == NULL)
 950                 return -1;
 951         return cache->mf->count;
 952 }
 953
 954 static GList * mbox_cache_get_msg_list(gchar * filename)
 955 {
 956         mboxcache * cache;
 957
 958         cache = mbox_cache_get_mbox(filename);
 959
 960         if (cache == NULL)
 961                 return NULL;
 962
 963         if (cache->mf == NULL)
 964                 return NULL;
 965
 966         return cache->mf->msg_list;
 967 }
 968
 969 static void mbox_cache_synchronize_lists(GList * old_msg_list,
 970                                          GList * new_msg_list)
 971 {
 972         GList * l;
 973         GList * l2;
 974
 975         for(l2 = old_msg_list ; l2 != NULL ; l2 = g_list_next(l2)) {
 976                 struct _message * msg2 = l2->data;
 977
 978                 if ((msg2->messageid == NULL) ||
 979                     (msg2->fromspace == NULL))
 980                         continue;
 981
 982                 for(l = new_msg_list ; l != NULL ; l = g_list_next(l)) {
 983                         struct _message * msg = l->data;
 984
 985                         if ((msg->messageid == NULL) ||
 986                             (msg->fromspace == NULL))
 987                                 continue;
 988
 989                         if ((strcmp(msg->messageid, msg2->messageid) == 0) &&
 990                             (strcmp(msg->fromspace, msg2->fromspace) == 0)) {
 991                                 if (msg2->flags.perm_flags != msg2->old_flags.perm_flags) {
 992                                         msg->flags = msg2->flags;
 993                                         break;
 994                                 }
 995                         }
 996                 }
 997         }
 998 }
 999
1000 static void mbox_cache_synchronize(gchar * filename, gboolean sync)
1001 {
1002         mboxcache * new_cache;
1003         mboxcache * old_cache;
1004         gboolean scan_new = TRUE;
1005         struct stat s;
1006
1007         old_cache = mbox_cache_get_mbox(filename);
1008
1009         if (old_cache != NULL) {
1010                 if (stat(filename, &s) < 0) {
1011                         FILE_OP_ERROR(filename, "stat");
1012                 } else if (old_cache->mtime == s.st_mtime) {
1013                         debug_print("Folder is not modified.\n");
1014                         scan_new = FALSE;
1015                 }
1016         }
1017
1018         if (scan_new) {
1019                 /*
1020                 if (strstr(filename, "trash") == 0)
1021                         printf("old_cache: %p %s\n", old_cache, filename);
1022                         if (old_cache) {
1023                                 printf("begin old\n");
1024                                 for(l = old_cache->mf->msg_list ; l != NULL ;
1025                                     l = g_list_next(l)) {
1026                                         struct _message * msg = l->data;
1027                                         printf("%p\n", msg);
1028                                 }
1029                                 printf("end old\n");
1030                         }
1031                 */
1032
1033                 new_cache = mbox_cache_read_mbox(filename);
1034
1035                 /*
1036                 if (strstr(filename, "trash") == 0)
1037                         printf("new_cache: %p %s\n", new_cache, filename);
1038                         if (new_cache) {
1039                                 printf("begin new\n");
1040                                 for(l = new_cache->mf->msg_list ; l != NULL ;
1041                                     l = g_list_next(l)) {
1042                                         struct _message * msg = l->data;
1043                                         printf("%p\n", msg);
1044                                 }
1045                                 printf("end new\n");
1046                         }
1047                 */
1048
1049                 if (!new_cache)
1050                         return;
1051
1052                 if (sync && new_cache && old_cache)
1053                         mbox_cache_synchronize_lists(old_cache->mf->msg_list,
1054                                                      new_cache->mf->msg_list);
1055
1056                 if (old_cache != NULL)
1057                         mbox_cache_free_mbox(old_cache);
1058
1059                 if (new_cache) {
1060                         mbox_cache_insert_mbox(new_cache);
1061                         /*
1062                         printf("insert %p %s\n", new_cache, new_cache->filename);
1063                         printf("inserted %s %p\n", filename,
1064                                mbox_cache_get_mbox(filename));
1065                         */
1066                 }
1067         }
1068 }
1069
1070 static void mbox_cache_synchronize_from_file(FILE * fp, gchar * filename,
1071                                              gboolean sync)
1072 {
1073         mboxcache * new_cache;
1074         mboxcache * old_cache;
1075         gboolean scan_new = TRUE;
1076         struct stat s;
1077
1078         old_cache = mbox_cache_get_mbox(filename);
1079
1080         if (old_cache != NULL) {
1081                 if (stat(filename, &s) < 0) {
1082                         FILE_OP_ERROR(filename, "stat");
1083                 } else if (old_cache->mtime == s.st_mtime) {
1084                         debug_print("Folder is not modified.\n");
1085                         scan_new = FALSE;
1086                 }
1087         }
1088
1089
1090         if (scan_new) {
1091
1092                 /*
1093                 GList * l;
1094
1095                 if (strstr(filename, "trash") == 0)
1096                         printf("old_cache: %p %s\n", old_cache, filename);
1097
1098                         if (old_cache) {
1099                                 printf("begin old\n");
1100                                 for(l = old_cache->mf->msg_list ; l != NULL ;
1101                                     l = g_list_next(l)) {
1102                                         struct _message * msg = l->data;
1103                                         printf("%p\n", msg);
1104                                 }
1105                                 printf("end old\n");
1106                         }
1107                 */
1108
1109                 new_cache = mbox_cache_read_mbox_from_file(fp, filename);
1110
1111                 /*
1112                 if (strstr(filename, "trash") == 0)
1113                         printf("new_cache: %p %s\n", new_cache, filename);
1114
1115                         if (new_cache) {
1116                                 printf("begin new\n");
1117                                 for(l = new_cache->mf->msg_list ; l != NULL ;
1118                                     l = g_list_next(l)) {
1119                                         struct _message * msg = l->data;
1120                                         printf("%p\n", msg);
1121                                 }
1122                                 printf("end new\n");
1123                         }
1124                 */
1125
1126                 if (!new_cache)
1127                         return;
1128
1129                 if (sync && new_cache && old_cache)
1130                         mbox_cache_synchronize_lists(old_cache->mf->msg_list,
1131                                                      new_cache->mf->msg_list);
1132
1133                 if (old_cache != NULL)
1134                         mbox_cache_free_mbox(old_cache);
1135
1136                 if (new_cache) {
1137                         mbox_cache_insert_mbox(new_cache);
1138                         /*
1139                         printf("insert %p %s\n", new_cache, new_cache->filename);
1140                         printf("inserted %s %p\n", filename,
1141                                mbox_cache_get_mbox(filename));
1142                         */
1143                 }
1144         }
1145 }
1146
1147 gboolean mbox_cache_msg_fetched(gchar * filename, gint num)
1148 {
1149         struct _message * msg;
1150         mboxcache * cache;
1151
1152         cache = mbox_cache_get_mbox(filename);
1153
1154         if (cache == NULL)
1155                 return FALSE;
1156
1157         msg = (struct _message *) g_ptr_array_index(cache->tab_mf,
1158                                                     num - 1);
1159         if (msg == NULL)
1160                 return FALSE;
1161
1162         return msg->fetched;
1163 }
1164
1165 void mbox_cache_msg_set_fetched(gchar * filename, gint num)
1166 {
1167         struct _message * msg;
1168         mboxcache * cache;
1169
1170         cache = mbox_cache_get_mbox(filename);
1171
1172         if (cache == NULL)
1173                 return;
1174
1175         msg = (struct _message *) g_ptr_array_index(cache->tab_mf,
1176                                                     num - 1);
1177         if (msg == NULL)
1178                 return;
1179
1180         msg->fetched = TRUE;
1181 }
1182
1183 struct _message * mbox_cache_get_msg(gchar * filename, gint num)
1184 {
1185         mboxcache * cache;
1186
1187         cache = mbox_cache_get_mbox(filename);
1188
1189         if (cache == NULL) {
1190                 return NULL;
1191         }
1192
1193         return (struct _message *) g_ptr_array_index(cache->tab_mf,
1194                                                      num - 1);
1195 }
1196
1197
1198 /**********************************************************/
1199 /*                                                        */
1200 /*                   mbox operations                      */
1201 /*                                                        */
1202 /**********************************************************/
1203
1204 static gboolean mbox_extract_msg(FolderItem * item, gint msgnum,
1205                                  gchar * dest_filename)
1206 {
1207         struct _message * msg;
1208         gint offset;
1209         gint max_offset;
1210         gint size;
1211         FILE * src;
1212         FILE * dest;
1213         gboolean err;
1214         /*      GList * msg_list;*/
1215         gboolean already_fetched;
1216         gchar * mbox_path;
1217
1218         mbox_path = mbox_folder_get_path(item->folder, item);
1219
1220         if (mbox_path == NULL)
1221                 return FALSE;
1222
1223         src = fopen(mbox_path, "rb");
1224         if (src == NULL) {
1225                 g_free(mbox_path);
1226                 return FALSE;
1227         }
1228
1229         mbox_lockread_file(src, mbox_path);
1230
1231         mbox_cache_synchronize_from_file(src, mbox_path, TRUE);
1232
1233         already_fetched = mbox_cache_msg_fetched(mbox_path, msgnum);
1234
1235         if (already_fetched) {
1236                 mbox_unlock_file(src, mbox_path);
1237                 fclose(src);
1238                 g_free(mbox_path);
1239                 return TRUE;
1240         }
1241
1242         msg = mbox_cache_get_msg(mbox_path, msgnum);
1243
1244         if (msg == NULL) {
1245                 mbox_unlock_file(src, mbox_path);
1246                 fclose(src);
1247                 g_free(mbox_path);
1248                 return FALSE;
1249         }
1250
1251         offset = msg->offset;
1252         max_offset = msg->end;
1253
1254         size = max_offset - offset;
1255
1256         fseek(src, offset, SEEK_SET);
1257
1258         dest = fopen(dest_filename, "wb");
1259         if (dest == NULL) {
1260                 mbox_unlock_file(src, mbox_path);
1261                 fclose(src);
1262                 g_free(mbox_path);
1263                 return FALSE;
1264         }
1265
1266         if (change_file_mode_rw(dest, dest_filename) < 0) {
1267                 FILE_OP_ERROR(dest_filename, "chmod");
1268                 g_warning("can't change file mode\n");
1269         }
1270
1271         if (!mbox_write_data(src, dest, dest_filename, size)) {
1272                 mbox_unlock_file(src, mbox_path);
1273                 fclose(dest);
1274                 fclose(src);
1275                 unlink(dest_filename);
1276                 g_free(mbox_path);
1277                 return FALSE;
1278         }
1279
1280         err = FALSE;
1281
1282         if (ferror(src)) {
1283                 FILE_OP_ERROR(mbox_path, "fread");
1284                 err = TRUE;
1285         }
1286
1287         mbox_cache_msg_set_fetched(mbox_path, msgnum);
1288
1289         if (fclose(dest) == -1) {
1290                 FILE_OP_ERROR(dest_filename, "fclose");
1291                 err = TRUE;
1292         }
1293
1294         mbox_unlock_file(src, mbox_path);
1295
1296         if (fclose(src) == -1) {
1297                 FILE_OP_ERROR(mbox_path, "fclose");
1298                 err = TRUE;
1299         }
1300
1301         g_free(mbox_path);
1302
1303         if (err) {
1304                 unlink(dest_filename);
1305                 return FALSE;
1306         }
1307
1308         return TRUE;
1309 }
1310
1311 gchar *mbox_fetch_msg(Folder *folder, FolderItem *item, gint num)
1312 {
1313         gchar *path;
1314         gchar *filename;
1315
1316         g_return_val_if_fail(item != NULL, NULL);
1317
1318         path = folder_item_get_path(item);
1319         if (!is_dir_exist(path))
1320                 make_dir_hier(path);
1321
1322         filename = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
1323
1324         g_free(path);
1325
1326         if (!mbox_extract_msg(item, num, filename)) {
1327                 g_free(filename);
1328                 return NULL;
1329         }
1330
1331         return filename;
1332 }
1333
1334 gint mbox_add_msg(Folder *folder, FolderItem *dest, const gchar *file,
1335                   MsgFlags *flags)
1336 {
1337         FILE * src_fp;
1338         FILE * dest_fp;
1339         gchar buf[BUFSIZ];
1340         gint old_size;
1341         gint n_read;
1342         gboolean err;
1343         gchar * mbox_path;
1344         gchar from_line[MSGBUFSIZE];
1345
1346         if (dest->last_num < 0) {
1347                 mbox_scan_folder(folder, dest);
1348                 if (dest->last_num < 0) return -1;
1349         }
1350
1351         src_fp = fopen(file, "rb");
1352         if (src_fp == NULL) {
1353                 return -1;
1354         }
1355
1356         mbox_path = mbox_folder_get_path(folder, dest);
1357         if (mbox_path == NULL)
1358                 return -1;
1359
1360         dest_fp = fopen(mbox_path, "ab");
1361         if (dest_fp == NULL) {
1362                 fclose(src_fp);
1363                 g_free(mbox_path);
1364                 return -1;
1365         }
1366
1367         if (change_file_mode_rw(dest_fp, mbox_path) < 0) {
1368                 FILE_OP_ERROR(mbox_path, "chmod");
1369                 g_warning("can't change file mode\n");
1370         }
1371
1372         old_size = ftell(dest_fp);
1373
1374         mbox_lockwrite_file(dest_fp, mbox_path);
1375
1376         if (fgets(from_line, sizeof(from_line), src_fp) == NULL) {
1377                 mbox_unlock_file(dest_fp, mbox_path);
1378                 g_warning("unvalid file - %s.\n", file);
1379                 fclose(dest_fp);
1380                 fclose(src_fp);
1381                 g_free(mbox_path);
1382                 return -1;
1383         }
1384
1385         if (strncmp(from_line, "From ", 5) != 0) {
1386                 struct stat s;
1387
1388                 if (stat(file, &s) < 0) {
1389                         mbox_unlock_file(dest_fp, mbox_path);
1390                         g_warning("invalid file - %s.\n", file);
1391                         fclose(dest_fp);
1392                         fclose(src_fp);
1393                         g_free(mbox_path);
1394                         return -1;
1395                 }
1396
1397                 fprintf(dest_fp, "From - %s", ctime(&s.st_mtime));
1398         }
1399
1400         fputs(from_line, dest_fp);
1401
1402         while (1) {
1403                 n_read = fread(buf, 1, sizeof(buf), src_fp);
1404                 if ((n_read < (gint) sizeof(buf)) && ferror(src_fp))
1405                         break;
1406                 if (fwrite(buf, n_read, 1, dest_fp) < 1) {
1407                         mbox_unlock_file(dest_fp, mbox_path);
1408                         g_warning("writing to %s failed.\n", mbox_path);
1409                         ftruncate(fileno(dest_fp), old_size);
1410                         fclose(dest_fp);
1411                         fclose(src_fp);
1412                         g_free(mbox_path);
1413                         return -1;
1414                 }
1415
1416                 if (n_read < (gint) sizeof(buf))
1417                         break;
1418         }
1419
1420         err = FALSE;
1421
1422         if (ferror(src_fp)) {
1423                 FILE_OP_ERROR(mbox_path, "fread");
1424         }
1425
1426         mbox_unlock_file(dest_fp, mbox_path);
1427
1428         if (fclose(src_fp) == -1) {
1429                 FILE_OP_ERROR(file, "fclose");
1430                 err = TRUE;
1431         }
1432
1433         if (fclose(dest_fp) == -1) {
1434                 FILE_OP_ERROR(mbox_path, "fclose");
1435                 g_free(mbox_path);
1436                 return -1;
1437         }
1438
1439         if (err) {
1440                 ftruncate(fileno(dest_fp), old_size);
1441                 g_free(mbox_path);
1442                 return -1;
1443         }
1444
1445         g_free(mbox_path);
1446
1447         dest->last_num++;
1448         return dest->last_num;
1449
1450 }
1451
1452 gint mbox_remove_msg(Folder *folder, FolderItem *item, gint num)
1453 {
1454         struct _message * msg;
1455         gchar * mbox_path;
1456
1457         mbox_path = mbox_folder_get_path(folder, item);
1458         if (mbox_path == NULL)
1459                 return -1;
1460
1461         mbox_cache_synchronize(mbox_path, TRUE);
1462
1463         msg = mbox_cache_get_msg(mbox_path, num);
1464
1465         g_free(mbox_path);
1466
1467         if (msg != NULL)
1468                 MSG_SET_PERM_FLAGS(msg->flags, MSG_REALLY_DELETED);
1469
1470         return 0;
1471 }
1472
1473 gint mbox_remove_all_msg(Folder *folder, FolderItem *item)
1474 {
1475         FILE * fp;
1476         gchar * mbox_path;
1477
1478         mbox_path = mbox_folder_get_path(folder, item);
1479         if (mbox_path == NULL)
1480                 return -1;
1481
1482         fp = fopen(mbox_path, "wb");
1483         if (fp == NULL) {
1484                 g_free(mbox_path);
1485                 return -1;
1486         }
1487
1488         fclose(fp);
1489
1490         g_free(mbox_path);
1491
1492         return 0;
1493 }
1494
1495 /*
1496 gint mbox_move_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1497 {
1498         gchar * filename;
1499         gint msgnum;
1500
1501         filename = mbox_fetch_msg(folder, msginfo->folder, msginfo->msgnum);
1502         if (filename == NULL)
1503                 return -1;
1504
1505         msgnum = mbox_add_msg(folder, dest, filename, TRUE);
1506
1507         if (msgnum != -1) {
1508                 MSG_SET_FLAGS(msginfo->flags, MSG_REALLY_DELETED);
1509                 mbox_change_flags(folder, msginfo->folder, msginfo);
1510         }
1511
1512         return msgnum;
1513 }
1514
1515 gint mbox_move_msgs_with_dest(Folder *folder, FolderItem *dest, GSList *msglist)
1516 {
1517         GSList * l;
1518         gchar * mbox_path = NULL;
1519
1520         for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
1521                 MsgInfo * msginfo = (MsgInfo *) l->data;
1522
1523                 if (msginfo->folder && mbox_path == NULL)
1524                         mbox_path = mbox_folder_get_path(msginfo->folder);
1525
1526                 mbox_move_msg(folder, dest, msginfo);
1527         }
1528
1529         if (mbox_path) {
1530                 mbox_cache_synchronize(mbox_path);
1531                 g_free(mbox_path);
1532         }
1533
1534         mbox_path = mbox_folder_get_path(dest);
1535         mbox_cache_synchronize(mbox_path);
1536         g_free(mbox_path);
1537
1538         return dest->last_num;
1539 }
1540 */
1541
1542 /*
1543 gint mbox_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1544 {
1545         gchar * filename;
1546         gint msgnum;
1547
1548         filename = mbox_fetch_msg(folder, msginfo->folder, msginfo->msgnum);
1549         if (filename == NULL)
1550                 return -1;
1551
1552         msgnum = mbox_add_msg(folder, dest, filename, FALSE);
1553
1554         return msgnum;
1555 }
1556
1557 gint mbox_copy_msgs_with_dest(Folder *folder, FolderItem *dest, GSList *msglist)
1558 {
1559         GSList * l;
1560         gchar * mbox_path = NULL;
1561
1562         for(l = msglist ; l != NULL ; l = g_slist_next(l)) {
1563                 MsgInfo * msginfo = (MsgInfo *) l->data;
1564
1565                 if (msginfo->folder && mbox_path == NULL)
1566                         mbox_path = mbox_folder_get_path(msginfo->folder);
1567
1568                 mbox_copy_msg(folder, dest, msginfo);
1569         }
1570
1571         if (mbox_path) {
1572                 mbox_cache_synchronize(mbox_path);
1573                 g_free(mbox_path);
1574         }
1575
1576         mbox_path = mbox_folder_get_path(dest);
1577         mbox_cache_synchronize(mbox_path);
1578         g_free(mbox_path);
1579
1580         return dest->last_num;
1581 }
1582 */
1583
1584 struct _copy_flags_info
1585 {
1586         gint num;
1587         MsgFlags flags;
1588 };
1589
1590 typedef struct _copy_flags_info CopyFlagsInfo;
1591
1592 GSList * copy_flags_data = NULL;
1593
1594 gint mbox_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
1595 {
1596         Folder * src_folder;
1597         gchar * filename;
1598         gint num;
1599         CopyFlagsInfo * flags_info;
1600
1601         src_folder = msginfo->folder->folder;
1602
1603         /*
1604         mbox_path = mbox_folder_get_path(msginfo->folder);
1605         mbox_rewrite(mbox_path);
1606         g_free(mbox_path);
1607         */
1608
1609         filename = folder_item_fetch_msg(msginfo->folder,
1610                                          msginfo->msgnum);
1611         if (filename == NULL)
1612                 return -1;
1613
1614         num = mbox_add_msg(folder, dest, filename, FALSE);
1615
1616         /*
1617         mbox_path = mbox_folder_get_path(dest);
1618         msg = mbox_cache_get_msg(mbox_path, num);
1619         if (msg != NULL)
1620                 msg->flags = msginfo->flags;
1621         g_free(mbox_path);
1622         */
1623
1624         if (num == -1)
1625                 return -1;
1626
1627         flags_info = g_new0(CopyFlagsInfo, 1);
1628         flags_info->num = num;
1629         flags_info->flags = msginfo->flags;
1630         copy_flags_data = g_slist_append(copy_flags_data, flags_info);
1631
1632         return num;
1633 }
1634
1635 void mbox_scan_folder(Folder *folder, FolderItem *item)
1636 {
1637         gchar *mbox_path;
1638         gint n_msg;
1639         mboxcache * cached;
1640         GList * l;
1641
1642         mbox_path = mbox_folder_get_path(folder, item);
1643         if (mbox_path == NULL)
1644                 return;
1645
1646         mbox_cache_synchronize(mbox_path, TRUE);
1647
1648         cached = mbox_cache_get_mbox(mbox_path);
1649
1650         if (cached == NULL) {
1651                 item->new_msgs = 0;
1652                 item->unread_msgs = 0;
1653                 item->total_msgs = 0;
1654                 item->last_num = 0;
1655                 g_free(mbox_path);
1656                 return;
1657         }
1658
1659         n_msg = mbox_cache_get_count(mbox_path);
1660
1661         if (n_msg == 0) {
1662                 item->new_msgs = item->unread_msgs = item->total_msgs = 0;
1663         }
1664         else {
1665                 gint new = 0;
1666                 gint unread = 0;
1667                 gint total = 0;
1668
1669                 for(l = mbox_cache_get_msg_list(mbox_path) ; l != NULL ;
1670                     l = g_list_next(l)) {
1671                         struct _message * msg = (struct _message *) l->data;
1672                         if (!MSG_IS_REALLY_DELETED(msg->flags))
1673                                 total ++;
1674                         if (MSG_IS_NEW(msg->flags) && !MSG_IS_IGNORE_THREAD(msg->flags))
1675                                 new ++;
1676                         if (MSG_IS_UNREAD(msg->flags) && !MSG_IS_IGNORE_THREAD(msg->flags))
1677                                 unread ++;
1678                 }
1679
1680                 item->new_msgs = new;
1681                 item->unread_msgs = unread;
1682                 item->total_msgs = total;
1683         }
1684
1685         debug_print("Last number in dir %s = %d\n", mbox_path,
1686                     item->total_msgs);
1687         item->last_num = n_msg;
1688         g_free(mbox_path);
1689 }
1690
1691 gchar * mbox_get_virtual_path(FolderItem * item)
1692 {
1693         if (item == NULL)
1694                 return NULL;
1695
1696         if (item->parent == NULL) {
1697                 return NULL;
1698         }
1699         else {
1700                 gchar * parent_path;
1701                 gchar * result_path;
1702
1703                 parent_path = mbox_get_virtual_path(item->parent);
1704                 if (parent_path == NULL)
1705                         result_path = g_strdup(item->name);
1706                 else
1707                         result_path = g_strconcat(parent_path,
1708                                                   G_DIR_SEPARATOR_S,
1709                                                   item->name, NULL);
1710                 g_free(parent_path);
1711
1712                 return result_path;
1713         }
1714 }
1715
1716 static gboolean mbox_write_data(FILE * mbox_fp, FILE * new_fp,
1717                                 gchar * new_filename, gint size)
1718 {
1719         gint n_read;
1720         gint pos;
1721         gchar buf[BUFSIZ];
1722         gint max;
1723
1724         pos = 0;
1725         while (pos < size) {
1726                 if ((size - pos) > (gint) sizeof(buf))
1727                         max = sizeof(buf);
1728                 else
1729                         max = (size - pos);
1730
1731                 n_read = fread(buf, 1, max, mbox_fp);
1732
1733                 if (n_read < max && ferror(mbox_fp)) {
1734                         return FALSE;
1735                 }
1736                 if (fwrite(buf, n_read, 1, new_fp) < 1) {
1737                         g_warning("writing to %s failed.\n", new_filename);
1738                         return FALSE;
1739                 }
1740
1741                 if (n_read != -1)
1742                         pos += n_read;
1743
1744                 if (n_read < max)
1745                         break;
1746         }
1747         return TRUE;
1748 }
1749
1750 static gboolean mbox_write_message(FILE * mbox_fp, FILE * new_fp,
1751                                    gchar * new_filename,
1752                                    struct _message * msg)
1753 {
1754         gint size;
1755         GPtrArray * headers;
1756         gint i;
1757
1758         fseek(mbox_fp, msg->header, SEEK_SET);
1759
1760         headers = procheader_get_header_array_asis(mbox_fp);
1761
1762         for (i = 0; i < (gint) headers->len; i++) {
1763                 Header * h = g_ptr_array_index(headers, i);
1764
1765                 if (!procheader_headername_equal(h->name,
1766                                                  "Status") &&
1767                     !procheader_headername_equal(h->name,
1768                                                  "X-Status")) {
1769                         fwrite(h->name, strlen(h->name),
1770                                1, new_fp);
1771                         if (h->name[strlen(h->name) - 1] != ' ')
1772                                 fwrite(" ", 1, 1, new_fp);
1773                         fwrite(h->body, strlen(h->body),
1774                                1, new_fp);
1775                         fwrite("\n", 1, 1, new_fp);
1776                 }
1777                 procheader_header_free(h);
1778                 g_ptr_array_remove_index(headers, i);
1779                 i--;
1780         }
1781
1782         g_ptr_array_free(headers, FALSE);
1783
1784         if (!MSG_IS_INVALID(msg->flags)) {
1785                 /* Status header */
1786                 fwrite("Status: ", strlen("Status: "), 1, new_fp);
1787                 if (!MSG_IS_UNREAD(msg->flags))
1788                         fwrite("R", 1, 1, new_fp);
1789                 fwrite("O", 1, 1, new_fp);
1790                 fwrite("\n", 1, 1, new_fp);
1791
1792                 /* X-Status header */
1793                 if (MSG_IS_REALLY_DELETED(msg->flags)
1794                 ||  MSG_IS_MARKED(msg->flags)
1795                 ||  MSG_IS_DELETED(msg->flags)
1796                 ||  MSG_IS_REPLIED(msg->flags)
1797                 ||  MSG_IS_FORWARDED(msg->flags)) {
1798                         fwrite("X-Status: ", strlen("X-Status: "), 1, new_fp);
1799                         if (MSG_IS_REALLY_DELETED(msg->flags))
1800                                 fwrite("D", 1, 1, new_fp); /* really deleted */
1801                         else {
1802                                 if (MSG_IS_MARKED(msg->flags))
1803                                         fwrite("F", 1, 1, new_fp);
1804                                 if (MSG_IS_DELETED(msg->flags))
1805                                         fwrite("d", 1, 1, new_fp);
1806                                 if (MSG_IS_REPLIED(msg->flags))
1807                                         fwrite("r", 1, 1, new_fp);
1808                                 if (MSG_IS_FORWARDED(msg->flags))
1809                                         fwrite("f", 1, 1, new_fp);
1810                         }
1811                         fwrite("\n", 1, 1, new_fp);
1812                 }
1813         }
1814
1815         fwrite("\n", 1, 1, new_fp);
1816
1817         size = msg->end - msg->content;
1818         fseek(mbox_fp, msg->content, SEEK_SET);
1819
1820         return mbox_write_data(mbox_fp, new_fp, new_filename, size);
1821 }
1822
1823 void mbox_change_flags(Folder * folder, FolderItem * item, MsgInfo * info, MsgPermFlags newflags)
1824 {
1825         struct _message * msg;
1826         mboxcache * cache;
1827         gchar * mbox_path;
1828
1829         mbox_path = mbox_folder_get_path(folder, item);
1830         if (mbox_path == NULL)
1831                 return;
1832
1833         info->flags.perm_flags = newflags;
1834
1835         msg = mbox_cache_get_msg(mbox_path, info->msgnum);
1836
1837         cache = mbox_cache_get_mbox(mbox_path);
1838
1839         g_free(mbox_path);
1840
1841         if ((msg == NULL) || (cache == NULL))
1842                 return;
1843
1844         msg->flags = info->flags;
1845
1846         cache->modification = TRUE;
1847 }
1848
1849
1850 static gboolean mbox_purge_deleted(gchar * mbox)
1851 {
1852         FILE * mbox_fp;
1853         FILE * new_fp;
1854         gchar * new;
1855         GList * l;
1856         gboolean result;
1857         gboolean modification = FALSE;
1858         GList * msg_list;
1859         gint count;
1860
1861         mbox_cache_synchronize(mbox, TRUE);
1862
1863         msg_list = mbox_cache_get_msg_list(mbox);
1864
1865         for(l = msg_list ; l != NULL ; l = g_list_next(l)) {
1866                 struct _message * msg = (struct _message *) l->data;
1867                 if (!MSG_IS_INVALID(msg->flags) && MSG_IS_REALLY_DELETED(msg->flags)) {
1868                         modification = TRUE;
1869                         break;
1870                 }
1871         }
1872
1873         if (!modification) {
1874                 debug_print("no deleted messages - %s\n", mbox);
1875                 return FALSE;
1876         }
1877
1878         debug_print("purge deleted messages - %s\n", mbox);
1879
1880         mbox_fp = fopen(mbox, "rb+");
1881         mbox_lockwrite_file(mbox_fp, mbox);
1882
1883         mbox_cache_synchronize_from_file(mbox_fp, mbox, TRUE);
1884
1885         new = g_strconcat(mbox, ".", itos((int) mbox), NULL);
1886         new_fp = fopen(new, "wb");
1887
1888         if (change_file_mode_rw(new_fp, new) < 0) {
1889                 FILE_OP_ERROR(new, "chmod");
1890                 g_warning("can't change file mode\n");
1891         }
1892
1893         mbox_lockwrite_file(new_fp, new);
1894
1895         result = TRUE;
1896
1897         count = 0;
1898         msg_list = mbox_cache_get_msg_list(mbox);
1899         for(l = msg_list ; l != NULL ; l = g_list_next(l)) {
1900                 struct _message * msg = (struct _message *) l->data;
1901                 if (MSG_IS_INVALID(msg->flags) || !MSG_IS_REALLY_DELETED(msg->flags)) {
1902                         if (!mbox_write_message(mbox_fp, new_fp, new, msg)) {
1903                                 result = FALSE;
1904                                 break;
1905                         }
1906                         count ++;
1907                 }
1908         }
1909
1910         unlink(mbox);
1911
1912         if (rename(new, mbox) == -1) {
1913                 g_warning("can't rename %s to %s\n", new, mbox);
1914                 mbox_unlock_file(new_fp, new);
1915                 fclose(new_fp);
1916                 mbox_unlock_file(mbox_fp, mbox);
1917                 fclose(mbox_fp);
1918                 g_free(new);
1919                 return -1;
1920         }
1921
1922         if (change_file_mode_rw(new_fp, mbox) < 0) {
1923                 FILE_OP_ERROR(new, "chmod");
1924                 g_warning("can't change file mode\n");
1925         }
1926
1927         mbox_unlock_file(new_fp, new);
1928
1929         fclose(new_fp);
1930
1931         mbox_unlock_file(mbox_fp, mbox);
1932
1933         fclose(mbox_fp);
1934
1935         debug_print("%i messages written - %s\n", count, mbox);
1936
1937         mbox_cache_synchronize(mbox, FALSE);
1938         g_free(new);
1939         return result;
1940 }
1941
1942 #define MAKE_DIR_IF_NOT_EXIST(dir) \
1943 { \
1944         if (!is_dir_exist(dir)) { \
1945                 if (is_file_exist(dir)) { \
1946                         g_warning("File `%s' already exists.\n" \
1947                                     "Can't create folder.", dir); \
1948                         return -1; \
1949                 } \
1950                 if (mkdir(dir, S_IRWXU) < 0) { \
1951                         FILE_OP_ERROR(dir, "mkdir"); \
1952                         return -1; \
1953                 } \
1954                 if (chmod(dir, S_IRWXU) < 0) \
1955                         FILE_OP_ERROR(dir, "chmod"); \
1956         } \
1957 }
1958
1959 gint mbox_create_tree(Folder *folder)
1960 {
1961         gchar *rootpath;
1962
1963         g_return_val_if_fail(folder != NULL, -1);
1964
1965         CHDIR_RETURN_VAL_IF_FAIL(get_home_dir(), -1);
1966         rootpath = LOCAL_FOLDER(folder)->rootpath;
1967         MAKE_DIR_IF_NOT_EXIST(rootpath);
1968         CHDIR_RETURN_VAL_IF_FAIL(rootpath, -1);
1969
1970         return 0;
1971 }
1972
1973 #undef MAKE_DIR_IF_NOT_EXIST
1974
1975 static gchar * mbox_get_new_path(FolderItem * parent, gchar * name)
1976 {
1977         gchar * path;
1978
1979         if (strchr(name, '/') == NULL) {
1980                 if (parent->path != NULL)
1981                         path = g_strconcat(parent->path, ".sbd", G_DIR_SEPARATOR_S, name, NULL);
1982                 else
1983                         path = g_strdup(name);
1984         }
1985         else
1986                 path = g_strdup(name);
1987
1988         return path;
1989 }
1990
1991 static gchar * mbox_get_folderitem_name(gchar * name)
1992 {
1993         gchar * foldername;
1994
1995         foldername = g_strdup(g_basename(name));
1996
1997         return foldername;
1998 }
1999
2000 FolderItem *mbox_create_folder(Folder *folder, FolderItem *parent,
2001                                const gchar *name)
2002 {
2003         gchar * path;
2004         FolderItem *new_item;
2005         gchar * foldername;
2006
2007         g_return_val_if_fail(folder != NULL, NULL);
2008         g_return_val_if_fail(parent != NULL, NULL);
2009         g_return_val_if_fail(name != NULL, NULL);
2010
2011         path = mbox_get_new_path(parent, (gchar *) name);
2012
2013         foldername = mbox_get_folderitem_name((gchar *) name);
2014
2015         new_item = folder_item_new(folder, foldername, path);
2016         folder_item_append(parent, new_item);
2017
2018         if (!strcmp(name, "inbox")) {
2019                 new_item->stype = F_INBOX;
2020                 new_item->folder->inbox = new_item;
2021         } else if (!strcmp(name, "outbox")) {
2022                 new_item->stype = F_OUTBOX;
2023                 new_item->folder->outbox = new_item;
2024         } else if (!strcmp(name, "draft")) {
2025                 new_item->stype = F_DRAFT;
2026                 new_item->folder->draft = new_item;
2027         } else if (!strcmp(name, "queue")) {
2028                 new_item->stype = F_QUEUE;
2029                 new_item->folder->queue = new_item;
2030         } else if (!strcmp(name, "trash")) {
2031                 new_item->stype = F_TRASH;
2032                 new_item->folder->trash = new_item;
2033         }
2034
2035         g_free(foldername);
2036         g_free(path);
2037
2038         return new_item;
2039 }
2040
2041 gint mbox_rename_folder(Folder *folder, FolderItem *item, const gchar *name)
2042 {
2043         gchar * path;
2044         gchar * foldername;
2045
2046         g_return_val_if_fail(folder != NULL, -1);
2047         g_return_val_if_fail(item != NULL, -1);
2048         g_return_val_if_fail(item->path != NULL, -1);
2049         g_return_val_if_fail(name != NULL, -1);
2050
2051         path = mbox_get_new_path(item->parent, (gchar *) name);
2052         foldername = mbox_get_folderitem_name((gchar *) name);
2053
2054         if (rename(item->path, path) == -1) {
2055                 g_free(foldername);
2056                 g_free(path);
2057                 g_warning("Cannot rename folder item");
2058
2059                 return -1;
2060         }
2061         else {
2062                 g_free(item->name);
2063                 g_free(item->path);
2064                 item->path = path;
2065                 item->name = foldername;
2066
2067                 return 0;
2068         }
2069 }
2070
2071 gint mbox_remove_folder(Folder *folder, FolderItem *item)
2072 {
2073         g_return_val_if_fail(folder != NULL, -1);
2074         g_return_val_if_fail(item != NULL, -1);
2075         g_return_val_if_fail(item->path != NULL, -1);
2076
2077         folder_item_remove(item);
2078         return 0;
2079 }
2080
2081 gint mbox_get_num_list(Folder *folder, FolderItem *item, GSList **mlist, gboolean *old_uids_valid)
2082 {
2083         GList * l;
2084         FILE * fp;
2085         gchar * mbox_path;
2086         mboxcache * old_cache;
2087         gint nummsgs = 0;
2088         struct stat s;
2089
2090         mbox_path = mbox_folder_get_path(folder, item);
2091         if (mbox_path == NULL)
2092                 return -1;
2093
2094         old_cache = mbox_cache_get_mbox(mbox_path);
2095         *old_uids_valid = TRUE;
2096         if (old_cache != NULL) {
2097                 if (stat(mbox_path, &s) < 0) {
2098                         FILE_OP_ERROR(mbox_path, "stat");
2099                 } else if (old_cache->mtime == s.st_mtime) {
2100                         debug_print("Folder is not modified.\n");
2101                         *old_uids_valid = FALSE;
2102                 }
2103         }
2104
2105         mbox_purge_deleted(mbox_path);
2106
2107         fp = fopen(mbox_path, "rb");
2108
2109         if (fp == NULL) {
2110                 g_free(mbox_path);
2111                 return -1;
2112         }
2113
2114         mbox_lockread_file(fp, mbox_path);
2115
2116         mbox_cache_synchronize_from_file(fp, mbox_path, TRUE);
2117
2118         item->last_num = mbox_cache_get_count(mbox_path);
2119
2120         for(l = mbox_cache_get_msg_list(mbox_path) ; l != NULL ;
2121             l = g_list_next(l)) {
2122                 struct _message * msg;
2123
2124                 msg = (struct _message *) l->data;
2125
2126                 if (MSG_IS_INVALID(msg->flags) || !MSG_IS_REALLY_DELETED(msg->flags)) {
2127                         *mlist = g_slist_append(*mlist, GINT_TO_POINTER(msg->msgnum));
2128                         nummsgs++;
2129                 } else {
2130                         MSG_SET_PERM_FLAGS(msg->flags, MSG_REALLY_DELETED);
2131                 }
2132         }
2133
2134         mbox_unlock_file(fp, mbox_path);
2135
2136         g_free(mbox_path);
2137
2138         fclose(fp);
2139
2140         return nummsgs;
2141 }
2142
2143 MsgInfo *mbox_get_msginfo(Folder *folder, FolderItem *item, gint num)
2144 {
2145         gchar *mbox_path;
2146         struct _message *msg;
2147         FILE *src;
2148         MsgInfo *msginfo;
2149
2150         g_return_val_if_fail(folder != NULL, NULL);
2151         g_return_val_if_fail(item != NULL, NULL);
2152
2153         mbox_path = mbox_folder_get_path(folder, item);
2154
2155         g_return_val_if_fail(mbox_path != NULL, NULL);
2156
2157         src = fopen(mbox_path, "rb");
2158         if (src == NULL) {
2159                 g_free(mbox_path);
2160                 return NULL;
2161         }
2162         mbox_lockread_file(src, mbox_path);
2163         mbox_cache_synchronize_from_file(src, mbox_path, TRUE);
2164
2165         msg = mbox_cache_get_msg(mbox_path, num);
2166         if (msg == NULL) {
2167                 mbox_unlock_file(src, mbox_path);
2168                 fclose(src);
2169                 g_free(mbox_path);
2170                 return NULL;
2171         }
2172
2173         fseek(src, msg->header, SEEK_SET);
2174         msginfo = mbox_parse_msg(src, msg, item);
2175
2176         mbox_unlock_file(src, mbox_path);
2177         fclose(src);
2178         g_free(mbox_path);
2179
2180         return msginfo;
2181 }
2182
2183 gboolean mbox_scan_required(Folder *folder, FolderItem *item)
2184 {
2185         mboxcache * old_cache;
2186         gboolean scan_new = TRUE;
2187         struct stat s;
2188         gchar *filename;
2189
2190         filename = mbox_folder_get_path(folder, item);
2191         old_cache = mbox_cache_get_mbox(filename);
2192
2193         if (old_cache != NULL) {
2194                 if (stat(filename, &s) < 0) {
2195                         FILE_OP_ERROR(filename, "stat");
2196                 } else if (old_cache->mtime == s.st_mtime) {
2197                         debug_print("Folder is not modified.\n");
2198                         scan_new = FALSE;
2199                 }
2200         }
2201
2202         g_free(filename);
2203
2204         return !scan_new;
2205 }
2206