src/mbox_folder.c

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