f2bb0fb41101dff66b03081f37eefdfe82bfaf4e
[claws.git] / src / mh.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 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 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include "defs.h"
25
26 #include <glib.h>
27 #include <dirent.h>
28 #include <sys/stat.h>
29 #include <unistd.h>
30 #include <string.h>
31 #include <errno.h>
32
33 #undef MEASURE_TIME
34
35 #ifdef MEASURE_TIME
36 #  include <sys/time.h>
37 #endif
38
39 #include "intl.h"
40 #include "folder.h"
41 #include "mh.h"
42 #include "procmsg.h"
43 #include "procheader.h"
44 #include "utils.h"
45
46 static void     mh_folder_init                  (Folder         *folder,
47                                                  const gchar    *name,
48                                                  const gchar    *path);
49
50 static GSList  *mh_get_uncached_msgs            (GHashTable     *msg_table,
51                                                  FolderItem     *item);
52 static MsgInfo *mh_parse_msg                    (const gchar    *file,
53                                                  FolderItem     *item);
54 static void     mh_scan_tree_recursive          (FolderItem     *item, 
55                                                  GHashTable *pptable);
56
57 static gboolean mh_rename_folder_func           (GNode          *node,
58                                                  gpointer        data);
59
60
61 Folder *mh_folder_new(const gchar *name, const gchar *path)
62 {
63         Folder *folder;
64
65         folder = (Folder *)g_new0(MHFolder, 1);
66         mh_folder_init(folder, name, path);
67
68         return folder;
69 }
70
71 void mh_folder_destroy(MHFolder *folder)
72 {
73         folder_local_folder_destroy(LOCAL_FOLDER(folder));
74 }
75
76 static void mh_folder_init(Folder *folder, const gchar *name, const gchar *path)
77 {
78         folder_local_folder_init(folder, name, path);
79
80         folder->type = F_MH;
81
82         folder->get_msg_list        = mh_get_msg_list;
83         folder->fetch_msg           = mh_fetch_msg;
84         folder->add_msg             = mh_add_msg;
85         folder->move_msg            = mh_move_msg;
86         folder->move_msgs_with_dest = mh_move_msgs_with_dest;
87         folder->copy_msg            = mh_copy_msg;
88         folder->copy_msgs_with_dest = mh_copy_msgs_with_dest;
89         folder->remove_msg          = mh_remove_msg;
90         folder->remove_all_msg      = mh_remove_all_msg;
91         folder->is_msg_changed      = mh_is_msg_changed;
92         folder->scan                = mh_scan_folder;
93         folder->scan_tree           = mh_scan_tree;
94         folder->create_tree         = mh_create_tree;
95         folder->create_folder       = mh_create_folder;
96         folder->rename_folder       = mh_rename_folder;
97         folder->remove_folder       = mh_remove_folder;
98 }
99
100 GSList *mh_get_msg_list(Folder *folder, FolderItem *item, gboolean use_cache)
101 {
102         GSList *mlist;
103         GHashTable *msg_table;
104         gchar *path;
105         struct stat s;
106         gboolean scan_new = TRUE;
107 #ifdef MEASURE_TIME
108         struct timeval tv_before, tv_after, tv_result;
109
110         gettimeofday(&tv_before, NULL);
111 #endif
112
113         g_return_val_if_fail(item != NULL, NULL);
114
115         path = folder_item_get_path(item);
116         if (stat(path, &s) < 0) {
117                 FILE_OP_ERROR(path, "stat");
118         } else {
119                 time_t mtime;
120
121                 mtime = MAX(s.st_mtime, s.st_ctime);
122                 if (item->mtime == mtime) {
123                         debug_print("Folder is not modified.\n");
124                         scan_new = FALSE;
125                 } else
126                         item->mtime = mtime;
127         }
128         g_free(path);
129
130         if (use_cache && !scan_new) {
131                 mlist = procmsg_read_cache(item, FALSE);
132                 if (!mlist)
133                         mlist = mh_get_uncached_msgs(NULL, item);
134         } else if (use_cache) {
135                 GSList *newlist;
136
137                 mlist = procmsg_read_cache(item, TRUE);
138                 msg_table = procmsg_msg_hash_table_create(mlist);
139
140                 newlist = mh_get_uncached_msgs(msg_table, item);
141                 if (msg_table)
142                         g_hash_table_destroy(msg_table);
143
144                 mlist = g_slist_concat(mlist, newlist);
145         } else
146                 mlist = mh_get_uncached_msgs(NULL, item);
147
148         procmsg_set_flags(mlist, item);
149
150 #ifdef MEASURE_TIME
151         gettimeofday(&tv_after, NULL);
152
153         timersub(&tv_after, &tv_before, &tv_result);
154         g_print("mh_get_msg_list: %s: elapsed time: %ld.%06ld sec\n",
155                 item->path, tv_result.tv_sec, tv_result.tv_usec);
156 #endif
157
158         return mlist;
159 }
160
161 gchar *mh_fetch_msg(Folder *folder, FolderItem *item, gint num)
162 {
163         gchar *path;
164         gchar *file;
165
166         g_return_val_if_fail(item != NULL, NULL);
167         g_return_val_if_fail(num > 0 && num <= item->last_num, NULL);
168
169         path = folder_item_get_path(item);
170         file = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
171         g_free(path);
172         if (!is_file_exist(file)) {
173                 g_free(file);
174                 return NULL;
175         }
176
177         return file;
178 }
179
180 gchar *mh_get_newmsg_filename(FolderItem *dest)
181 {
182         gchar *destfile;
183         gchar *destpath;
184         gboolean found = FALSE;
185
186         destpath = folder_item_get_path(dest);
187         g_return_val_if_fail(destpath != NULL, NULL);
188         if (!is_dir_exist(destpath))
189                 make_dir_hier(destpath);
190
191         do {
192                 destfile = g_strdup_printf("%s%c%d", destpath, G_DIR_SEPARATOR,
193                                            dest->last_num + 1);
194                 if(is_file_exist(destfile)) {
195                         dest->last_num++;
196                         g_free(destfile);
197                 } else {
198                         found = TRUE;
199                 }
200         } while(!found);
201         g_free(destpath);
202
203         return destfile;
204 }
205
206 #define SET_DEST_MSG_FLAGS(fp, dest, msginfo) \
207 { \
208         MsgInfo newmsginfo; \
209  \
210         newmsginfo.msgnum = dest->last_num; \
211         newmsginfo.flags = msginfo->flags; \
212         if (dest->stype == F_OUTBOX || \
213             dest->stype == F_QUEUE  || \
214             dest->stype == F_DRAFT  || \
215             dest->stype == F_TRASH) \
216                 MSG_UNSET_PERM_FLAGS(newmsginfo.flags, \
217                                      MSG_NEW|MSG_UNREAD|MSG_DELETED); \
218  \
219         procmsg_write_flags(&newmsginfo, fp); \
220 }
221
222 gint mh_add_msg(Folder *folder, FolderItem *dest, const gchar *file,
223                 gboolean remove_source)
224 {
225         gchar *destfile;
226
227         g_return_val_if_fail(dest != NULL, -1);
228         g_return_val_if_fail(file != NULL, -1);
229
230         if (dest->last_num < 0) {
231                 mh_scan_folder(folder, dest);
232                 if (dest->last_num < 0) return -1;
233         }
234
235         destfile = mh_get_newmsg_filename(dest);
236         if(!destfile) return -1;
237
238         if (link(file, destfile) < 0) {
239                 if (copy_file(file, destfile) < 0) {
240                         g_warning(_("can't copy message %s to %s\n"),
241                                   file, destfile);
242                         g_free(destfile);
243                         return -1;
244                 }
245         }
246
247         if (remove_source) {
248                 if (unlink(file) < 0)
249                         FILE_OP_ERROR(file, "unlink");
250         }
251
252         g_free(destfile);
253         dest->last_num++;
254         return dest->last_num;
255 }
256
257 static gint mh_do_move(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
258 {
259         gchar *destdir;
260         gchar *srcfile;
261         gchar *destfile;
262         FILE *fp;
263         gint filemode = 0;
264         PrefsFolderItem *prefs;
265
266         g_return_val_if_fail(dest != NULL, -1);
267         g_return_val_if_fail(msginfo != NULL, -1);
268
269         if (msginfo->folder == dest) {
270                 g_warning(_("the src folder is identical to the dest.\n"));
271                 return -1;
272         }
273
274         if (dest->last_num < 0) {
275                 mh_scan_folder(folder, dest);
276                 if (dest->last_num < 0) return -1;
277         }
278
279         prefs = dest->prefs;
280
281         destdir = folder_item_get_path(dest);
282
283         debug_print(_("Moving message %s%c%d to %s ...\n"),
284                     msginfo->folder->path, G_DIR_SEPARATOR,
285                     msginfo->msgnum, dest->path);
286         srcfile = procmsg_get_message_file(msginfo);
287
288         destfile = mh_get_newmsg_filename(dest);
289         if(!destfile) return -1;
290
291
292         if (move_file(srcfile, destfile) < 0) {
293                 g_free(srcfile);
294                 g_free(destfile);
295                 g_free(destdir);
296                 return -1;
297         }
298
299         if (prefs && prefs->enable_folder_chmod && prefs->folder_chmod) {
300                 if (chmod(destfile, prefs->folder_chmod) < 0)
301                         FILE_OP_ERROR(destfile, "chmod");
302
303                 /* for mark file */
304                 filemode = prefs->folder_chmod;
305                 if (filemode & S_IRGRP) filemode |= S_IWGRP;
306                 if (filemode & S_IROTH) filemode |= S_IWOTH;
307         }
308
309         g_free(srcfile);
310         g_free(destfile);
311         dest->last_num++;
312
313         if ((fp = procmsg_open_mark_file(destdir, TRUE)) == NULL)
314                 g_warning(_("Can't open mark file.\n"));
315         else {
316                 SET_DEST_MSG_FLAGS(fp, dest, msginfo);
317                 if (filemode) {
318 #if HAVE_FCHMOD
319                         fchmod(fileno(fp), filemode);
320 #else
321                         gchar *markfile;
322
323                         markfile = folder_item_get_mark_file(dest);
324                         if (markfile) {
325                                 chmod(markfile, filemode);
326                                 g_free(markfile);
327                         }
328 #endif
329                 }
330
331                 fclose(fp);
332         }
333         g_free(destdir);
334
335         return dest->last_num;
336 }
337
338 gint mh_move_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
339 {
340         gchar *srcfile;
341         gint ret = 0;
342  
343         g_return_val_if_fail(folder != NULL, -1);
344         g_return_val_if_fail(dest != NULL, -1);
345         g_return_val_if_fail(msginfo != NULL, -1);
346         g_return_val_if_fail(msginfo->folder != NULL, -1);
347  
348         if (folder == msginfo->folder->folder)
349                 return mh_do_move(folder, dest, msginfo);
350  
351         srcfile = procmsg_get_message_file(msginfo);
352         if (!srcfile) return -1;
353  
354         ret = mh_add_msg(folder, dest, srcfile, FALSE);
355         g_free(srcfile);
356  
357         if (ret != -1) {
358                 gchar *destdir;
359                 FILE *fp;
360  
361                 destdir = folder_item_get_path(dest);
362                 if ((fp = procmsg_open_mark_file(destdir, TRUE)) == NULL)
363                         g_warning(_("Can't open mark file.\n"));
364                 else {
365                         SET_DEST_MSG_FLAGS(fp, dest, msginfo);
366                         fclose(fp);
367                 }
368                 g_free(destdir);
369  
370                 ret = folder_item_remove_msg(msginfo->folder, msginfo->msgnum);
371         }
372  
373         return ret;
374 }
375
376 static gint mh_do_move_msgs_with_dest(Folder *folder, FolderItem *dest,
377                                       GSList *msglist)
378 {
379         gchar *destdir;
380         gchar *srcfile;
381         gchar *destfile;
382         FILE *fp;
383         GSList *cur;
384         MsgInfo *msginfo;
385         PrefsFolderItem *prefs;
386
387         g_return_val_if_fail(dest != NULL, -1);
388         g_return_val_if_fail(msglist != NULL, -1);
389
390         if (dest->last_num < 0) {
391                 mh_scan_folder(folder, dest);
392                 if (dest->last_num < 0) return -1;
393         }
394
395         prefs = dest->prefs;
396
397         destdir = folder_item_get_path(dest);
398         if ((fp = procmsg_open_mark_file(destdir, TRUE)) == NULL)
399                 g_warning(_("Can't open mark file.\n"));
400
401         for (cur = msglist; cur != NULL; cur = cur->next) {
402                 msginfo = (MsgInfo *)cur->data;
403
404                 if (msginfo->folder == dest) {
405                         g_warning(_("the src folder is identical to the dest.\n"));
406                         continue;
407                 }
408                 debug_print(_("Moving message %s%c%d to %s ...\n"),
409                             msginfo->folder->path, G_DIR_SEPARATOR,
410                             msginfo->msgnum, dest->path);
411
412                 srcfile = procmsg_get_message_file(msginfo);
413                 destfile = mh_get_newmsg_filename(dest);
414                 if(!destfile) return -1;
415
416                 if (move_file(srcfile, destfile) < 0) {
417                         g_free(srcfile);
418                         g_free(destfile);
419                         break;
420                 }
421
422                 g_free(srcfile);
423                 g_free(destfile);
424                 dest->last_num++;
425
426                 if (fp) {
427                         SET_DEST_MSG_FLAGS(fp, dest, msginfo);
428                 }
429         }
430
431         g_free(destdir);
432         if (fp) fclose(fp);
433
434         return dest->last_num;
435 }
436
437 gint mh_move_msgs_with_dest(Folder *folder, FolderItem *dest, GSList *msglist)
438 {
439         MsgInfo *msginfo;
440         GSList *cur;
441         gint ret = 0;
442
443         msginfo = (MsgInfo *)msglist->data;
444         if (folder == msginfo->folder->folder)
445                 return mh_do_move_msgs_with_dest(folder, dest, msglist);
446
447         for (cur = msglist; cur != NULL; cur = cur->next) {
448                 msginfo = (MsgInfo *)cur->data;
449                 ret = mh_move_msg(folder, dest, msginfo);
450                 if (ret == -1) break;
451         }
452
453         return ret;
454 }
455
456 gint mh_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
457 {
458         gchar *destdir;
459         gchar *srcfile;
460         gchar *destfile;
461         FILE *fp;
462         gint filemode = 0;
463         PrefsFolderItem *prefs;
464
465         g_return_val_if_fail(dest != NULL, -1);
466         g_return_val_if_fail(msginfo != NULL, -1);
467
468         if (msginfo->folder == dest) {
469                 g_warning(_("the src folder is identical to the dest.\n"));
470                 return -1;
471         }
472
473         if (dest->last_num < 0) {
474                 mh_scan_folder(folder, dest);
475                 if (dest->last_num < 0) return -1;
476         }
477
478         prefs = dest->prefs;
479
480         destdir = folder_item_get_path(dest);
481         if (!is_dir_exist(destdir))
482                 make_dir_hier(destdir);
483
484         debug_print(_("Copying message %s%c%d to %s ...\n"),
485                     msginfo->folder->path, G_DIR_SEPARATOR,
486                     msginfo->msgnum, dest->path);
487         srcfile = procmsg_get_message_file(msginfo);
488         destfile = mh_get_newmsg_filename(dest);
489         if(!destfile) {
490                 g_free(srcfile);
491                 if (fp) fclose(fp);
492                 return -1;
493         }
494         
495         dest->op_count--;
496
497         if (copy_file(srcfile, destfile) < 0) {
498                 FILE_OP_ERROR(srcfile, "copy");
499                 g_free(srcfile);
500                 g_free(destfile);
501                 g_free(destdir);
502                 return -1;
503         }
504
505         if (prefs && prefs->enable_folder_chmod && prefs->folder_chmod) {
506                 if (chmod(destfile, prefs->folder_chmod) < 0)
507                         FILE_OP_ERROR(destfile, "chmod");
508
509                 /* for mark file */
510                 filemode = prefs->folder_chmod;
511                 if (filemode & S_IRGRP) filemode |= S_IWGRP;
512                 if (filemode & S_IROTH) filemode |= S_IWOTH;
513         }
514
515         g_free(srcfile);
516         g_free(destfile);
517         dest->last_num++;
518
519         if ((fp = procmsg_open_mark_file(destdir, TRUE)) == NULL)
520                 g_warning(_("Can't open mark file.\n"));
521         else {
522                 SET_DEST_MSG_FLAGS(fp, dest, msginfo);
523
524                 if (filemode) {
525 #if HAVE_FCHMOD
526                         fchmod(fileno(fp), filemode);
527 #else
528                         gchar *markfile;
529
530                         markfile = folder_item_get_mark_file(dest);
531                         if (markfile) {
532                                 chmod(markfile, filemode);
533                                 g_free(markfile);
534                         }
535 #endif
536                 }
537
538                 fclose(fp);
539         }
540         g_free(destdir);
541
542         return dest->last_num;
543 }
544
545 /*
546 gint mh_copy_msg(Folder *folder, FolderItem *dest, MsgInfo *msginfo)
547 {
548         Folder * src_folder;
549         gchar * filename;
550         gint num;
551         gchar * destdir;
552         FILE * fp;
553
554         src_folder = msginfo->folder->folder;
555         
556         g_return_val_if_fail(src_folder->fetch_msg != NULL, -1);
557         
558         filename = src_folder->fetch_msg(src_folder,
559                                          msginfo->folder,
560                                          msginfo->msgnum);
561         if (filename == NULL)
562                 return -1;
563
564         num = folder->add_msg(folder, dest, filename, FALSE);
565
566         destdir = folder_item_get_path(dest);
567
568         if (fp) {
569                 MsgInfo newmsginfo;
570
571                 newmsginfo.msgnum = dest->last_num;
572                 newmsginfo.flags = msginfo->flags;
573                 if (dest->stype == F_OUTBOX ||
574                     dest->stype == F_QUEUE  ||
575                     dest->stype == F_DRAFT  ||
576                     dest->stype == F_TRASH)
577                         MSG_UNSET_FLAGS(newmsginfo.flags,
578                                         MSG_NEW|MSG_UNREAD|MSG_DELETED);
579
580                 procmsg_write_flags(&newmsginfo, fp);
581                 fclose(fp);
582         }
583         
584         return num;
585 }
586 */
587
588 gint mh_copy_msgs_with_dest(Folder *folder, FolderItem *dest, GSList *msglist)
589 {
590         gchar *destdir;
591         gchar *srcfile;
592         gchar *destfile;
593         FILE *fp;
594         GSList *cur;
595         MsgInfo *msginfo;
596
597         g_return_val_if_fail(dest != NULL, -1);
598         g_return_val_if_fail(msglist != NULL, -1);
599
600         if (dest->last_num < 0) {
601                 mh_scan_folder(folder, dest);
602                 if (dest->last_num < 0) return -1;
603         }
604
605         destdir = folder_item_get_path(dest);
606         if (!is_dir_exist(destdir))
607                 make_dir_hier(destdir);
608
609         if ((fp = procmsg_open_mark_file(destdir, TRUE)) == NULL)
610                 g_warning(_("Can't open mark file.\n"));
611
612         for (cur = msglist; cur != NULL; cur = cur->next) {
613                 msginfo = (MsgInfo *)cur->data;
614
615                 if (msginfo->folder == dest) {
616                         g_warning(_("the src folder is identical to the dest.\n"));
617                         continue;
618                 }
619                 debug_print(_("Copying message %s%c%d to %s ...\n"),
620                             msginfo->folder->path, G_DIR_SEPARATOR,
621                             msginfo->msgnum, dest->path);
622
623                 srcfile = procmsg_get_message_file(msginfo);
624                 destfile = mh_get_newmsg_filename(dest);
625                 if(!destfile) {
626                         g_free(srcfile);
627                         break;
628                 }
629
630                 if (copy_file(srcfile, destfile) < 0) {
631                         FILE_OP_ERROR(srcfile, "copy");
632                         g_free(srcfile);
633                         g_free(destfile);
634                         break;
635                 }
636
637                 g_free(srcfile);
638                 g_free(destfile);
639                 dest->last_num++;
640
641                 if (fp) {
642                         SET_DEST_MSG_FLAGS(fp, dest, msginfo);
643                 }
644         }
645
646         g_free(destdir);
647         if (fp) fclose(fp);
648
649         return dest->last_num;
650 }
651
652 gint mh_remove_msg(Folder *folder, FolderItem *item, gint num)
653 {
654         gchar *file;
655
656         g_return_val_if_fail(item != NULL, -1);
657
658         file = mh_fetch_msg(folder, item, num);
659         g_return_val_if_fail(file != NULL, -1);
660
661         if (unlink(file) < 0) {
662                 FILE_OP_ERROR(file, "unlink");
663                 g_free(file);
664                 return -1;
665         }
666
667         g_free(file);
668         return 0;
669 }
670
671 gint mh_remove_all_msg(Folder *folder, FolderItem *item)
672 {
673         gchar *path;
674         gint val;
675
676         g_return_val_if_fail(item != NULL, -1);
677
678         path = folder_item_get_path(item);
679         g_return_val_if_fail(path != NULL, -1);
680         val = remove_all_numbered_files(path);
681         g_free(path);
682
683         return val;
684 }
685
686 gboolean mh_is_msg_changed(Folder *folder, FolderItem *item, MsgInfo *msginfo)
687 {
688         struct stat s;
689
690         if (stat(itos(msginfo->msgnum), &s) < 0 ||
691             msginfo->size  != s.st_size ||
692             msginfo->mtime != s.st_mtime)
693                 return TRUE;
694
695         return FALSE;
696 }
697
698 void mh_scan_folder(Folder *folder, FolderItem *item)
699 {
700         gchar *path;
701         DIR *dp;
702         struct dirent *d;
703         struct stat s;
704         gint max = 0;
705         gint num;
706         gint n_msg = 0;
707
708         g_return_if_fail(item != NULL);
709
710         debug_print("mh_scan_folder(): Scanning %s ...\n", item->path);
711
712         path = folder_item_get_path(item);
713         g_return_if_fail(path != NULL);
714         if (change_dir(path) < 0) {
715                 g_free(path);
716                 return;
717         }
718         g_free(path);
719
720         if ((dp = opendir(".")) == NULL) {
721                 FILE_OP_ERROR(item->path, "opendir");
722                 return;
723         }
724
725         if (folder->ui_func)
726                 folder->ui_func(folder, item, folder->ui_func_data);
727
728         while ((d = readdir(dp)) != NULL) {
729                 if ((num = to_number(d->d_name)) >= 0 &&
730                     stat(d->d_name, &s) == 0 &&
731                     S_ISREG(s.st_mode)) {
732                         n_msg++;
733                         if (max < num)
734                                 max = num;
735                 }
736         }
737
738         closedir(dp);
739
740         if (n_msg == 0)
741                 item->new = item->unread = item->total = 0;
742         else {
743                 gint new, unread, total, min, max;
744
745                 procmsg_get_mark_sum(".", &new, &unread, &total, &min, &max, 0);
746                 if (n_msg > total) {
747                         new += n_msg - total;
748                         unread += n_msg - total;
749                 }
750                 item->new = new;
751                 item->unread = unread;
752                 item->total = n_msg;
753         }
754
755         debug_print(_("Last number in dir %s = %d\n"), item->path, max);
756         item->last_num = max;
757 }
758
759 void mh_scan_tree(Folder *folder)
760 {
761         FolderItem *item;
762         gchar *rootpath;
763         GHashTable *pptable;
764
765         g_return_if_fail(folder != NULL);
766
767         pptable = folder_persist_prefs_new(folder);
768
769         folder_tree_destroy(folder);
770         item = folder_item_new(folder->name, NULL);
771         item->folder = folder;
772         folder->node = g_node_new(item);
773
774         rootpath = folder_item_get_path(item);
775         if (change_dir(rootpath) < 0) {
776                 g_free(rootpath);
777                 return;
778         }
779         g_free(rootpath);
780
781         mh_scan_tree_recursive(item, pptable);
782         
783         folder_persist_prefs_free(pptable);
784 }
785
786 #define MAKE_DIR_IF_NOT_EXIST(dir) \
787 { \
788         if (!is_dir_exist(dir)) { \
789                 if (is_file_exist(dir)) { \
790                         g_warning(_("File `%s' already exists.\n" \
791                                     "Can't create folder."), dir); \
792                         return -1; \
793                 } \
794                 if (mkdir(dir, S_IRWXU) < 0) { \
795                         FILE_OP_ERROR(dir, "mkdir"); \
796                         return -1; \
797                 } \
798                 if (chmod(dir, S_IRWXU) < 0) \
799                         FILE_OP_ERROR(dir, "chmod"); \
800         } \
801 }
802
803 gint mh_create_tree(Folder *folder)
804 {
805         gchar *rootpath;
806
807         g_return_val_if_fail(folder != NULL, -1);
808
809         CHDIR_RETURN_VAL_IF_FAIL(get_home_dir(), -1);
810         rootpath = LOCAL_FOLDER(folder)->rootpath;
811         MAKE_DIR_IF_NOT_EXIST(rootpath);
812         CHDIR_RETURN_VAL_IF_FAIL(rootpath, -1);
813         MAKE_DIR_IF_NOT_EXIST(INBOX_DIR);
814         MAKE_DIR_IF_NOT_EXIST(OUTBOX_DIR);
815         MAKE_DIR_IF_NOT_EXIST(QUEUE_DIR);
816         MAKE_DIR_IF_NOT_EXIST(DRAFT_DIR);
817         MAKE_DIR_IF_NOT_EXIST(TRASH_DIR);
818
819         return 0;
820 }
821
822 #undef MAKE_DIR_IF_NOT_EXIST
823
824 FolderItem *mh_create_folder(Folder *folder, FolderItem *parent,
825                              const gchar *name)
826 {
827         gchar *path;
828         gchar *fullpath;
829         FolderItem *new_item;
830
831         g_return_val_if_fail(folder != NULL, NULL);
832         g_return_val_if_fail(parent != NULL, NULL);
833         g_return_val_if_fail(name != NULL, NULL);
834
835         path = folder_item_get_path(parent);
836         if (!is_dir_exist(path))
837                 make_dir_hier(path);
838
839         fullpath = g_strconcat(path, G_DIR_SEPARATOR_S, name, NULL);
840         g_free(path);
841
842         if (mkdir(fullpath, S_IRWXU) < 0) {
843                 FILE_OP_ERROR(fullpath, "mkdir");
844                 g_free(fullpath);
845                 return NULL;
846         }
847         if (chmod(fullpath, S_IRWXU) < 0)
848                 FILE_OP_ERROR(fullpath, "chmod");
849
850         g_free(fullpath);
851
852         if (parent->path)
853                 path = g_strconcat(parent->path, G_DIR_SEPARATOR_S, name,
854                                    NULL);
855         else
856                 path = g_strdup(name);
857         new_item = folder_item_new(name, path);
858         folder_item_append(parent, new_item);
859         g_free(path);
860
861         return new_item;
862 }
863
864 gint mh_rename_folder(Folder *folder, FolderItem *item, const gchar *name)
865 {
866         gchar *oldpath;
867         gchar *dirname;
868         gchar *newpath;
869         GNode *node;
870         gchar *paths[2];
871
872         g_return_val_if_fail(folder != NULL, -1);
873         g_return_val_if_fail(item != NULL, -1);
874         g_return_val_if_fail(item->path != NULL, -1);
875         g_return_val_if_fail(name != NULL, -1);
876
877         oldpath = folder_item_get_path(item);
878         if (!is_dir_exist(oldpath))
879                 make_dir_hier(oldpath);
880
881         dirname = g_dirname(oldpath);
882         newpath = g_strconcat(dirname, G_DIR_SEPARATOR_S, name, NULL);
883         g_free(dirname);
884
885         if (rename(oldpath, newpath) < 0) {
886                 FILE_OP_ERROR(oldpath, "rename");
887                 g_free(oldpath);
888                 g_free(newpath);
889                 return -1;
890         }
891
892         g_free(oldpath);
893         g_free(newpath);
894
895         if (strchr(item->path, G_DIR_SEPARATOR) != NULL) {
896                 dirname = g_dirname(item->path);
897                 newpath = g_strconcat(dirname, G_DIR_SEPARATOR_S, name, NULL);
898                 g_free(dirname);
899         } else
900                 newpath = g_strdup(name);
901
902         g_free(item->name);
903         item->name = g_strdup(name);
904
905         node = g_node_find(item->folder->node, G_PRE_ORDER, G_TRAVERSE_ALL,
906                            item);
907         paths[0] = g_strdup(item->path);
908         paths[1] = newpath;
909         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
910                         mh_rename_folder_func, paths);
911
912         g_free(paths[0]);
913         g_free(paths[1]);
914         return 0;
915 }
916
917 gint mh_remove_folder(Folder *folder, FolderItem *item)
918 {
919         gchar *path;
920
921         g_return_val_if_fail(folder != NULL, -1);
922         g_return_val_if_fail(item != NULL, -1);
923         g_return_val_if_fail(item->path != NULL, -1);
924
925         path = folder_item_get_path(item);
926         if (remove_dir_recursive(path) < 0) {
927                 g_warning("can't remove directory `%s'\n", path);
928                 g_free(path);
929                 return -1;
930         }
931
932         g_free(path);
933         folder_item_remove(item);
934         return 0;
935 }
936
937
938 static GSList *mh_get_uncached_msgs(GHashTable *msg_table, FolderItem *item)
939 {
940         gchar *path;
941         DIR *dp;
942         struct dirent *d;
943         struct stat s;
944         GSList *newlist = NULL;
945         GSList *last = NULL;
946         MsgInfo *msginfo;
947         gint n_newmsg = 0;
948         gint num;
949
950         g_return_val_if_fail(item != NULL, NULL);
951
952         path = folder_item_get_path(item);
953         g_return_val_if_fail(path != NULL, NULL);
954         if (change_dir(path) < 0) {
955                 g_free(path);
956                 return NULL;
957         }
958         g_free(path);
959
960         if ((dp = opendir(".")) == NULL) {
961                 FILE_OP_ERROR(item->path, "opendir");
962                 return NULL;
963         }
964
965         debug_print(_("\tSearching uncached messages... "));
966
967         if (msg_table) {
968                 while ((d = readdir(dp)) != NULL) {
969                         if ((num = to_number(d->d_name)) < 0) continue;
970                         if (stat(d->d_name, &s) < 0) {
971                                 FILE_OP_ERROR(d->d_name, "stat");
972                                 continue;
973                         }
974                         if (!S_ISREG(s.st_mode)) continue;
975
976                         msginfo = g_hash_table_lookup
977                                 (msg_table, GUINT_TO_POINTER(num));
978
979                         if (!msginfo) {
980                                 /* not found in the cache (uncached message) */
981                                 msginfo = mh_parse_msg(d->d_name, item);
982                                 if (!msginfo) continue;
983
984                                 if (!newlist)
985                                         last = newlist =
986                                                 g_slist_append(NULL, msginfo);
987                                 else {
988                                         last = g_slist_append(last, msginfo);
989                                         last = last->next;
990                                 }
991                                 n_newmsg++;
992                         }
993                 }
994         } else {
995                 /* discard all previous cache */
996                 while ((d = readdir(dp)) != NULL) {
997                         if (to_number(d->d_name) < 0) continue;
998                         if (stat(d->d_name, &s) < 0) {
999                                 FILE_OP_ERROR(d->d_name, "stat");
1000                                 continue;
1001                         }
1002                         if (!S_ISREG(s.st_mode)) continue;
1003
1004                         msginfo = mh_parse_msg(d->d_name, item);
1005                         if (!msginfo) continue;
1006
1007                         if (!newlist)
1008                                 last = newlist = g_slist_append(NULL, msginfo);
1009                         else {
1010                                 last = g_slist_append(last, msginfo);
1011                                 last = last->next;
1012                         }
1013                         n_newmsg++;
1014                 }
1015         }
1016
1017         closedir(dp);
1018
1019         if (n_newmsg)
1020                 debug_print(_("%d uncached message(s) found.\n"), n_newmsg);
1021         else
1022                 debug_print(_("done.\n"));
1023
1024         /* sort new messages in numerical order */
1025         if (newlist) {
1026                 debug_print(_("\tSorting uncached messages in numerical order... "));
1027                 newlist = g_slist_sort
1028                         (newlist, (GCompareFunc)procmsg_cmp_msgnum_for_sort);
1029                 debug_print(_("done.\n"));
1030         }
1031
1032         return newlist;
1033 }
1034
1035 static MsgInfo *mh_parse_msg(const gchar *file, FolderItem *item)
1036 {
1037         struct stat s;
1038         MsgInfo *msginfo;
1039         MsgFlags flags;
1040
1041         flags.perm_flags = MSG_NEW|MSG_UNREAD;
1042         flags.tmp_flags = 0;
1043
1044         g_return_val_if_fail(item != NULL, NULL);
1045         g_return_val_if_fail(file != NULL, NULL);
1046
1047         if (item->stype == F_QUEUE) {
1048                 MSG_SET_TMP_FLAGS(flags, MSG_QUEUED);
1049         } else if (item->stype == F_DRAFT) {
1050                 MSG_SET_TMP_FLAGS(flags, MSG_DRAFT);
1051         }
1052
1053         msginfo = procheader_parse(file, flags, FALSE, FALSE);
1054         if (!msginfo) return NULL;
1055
1056         msginfo->msgnum = atoi(file);
1057         msginfo->folder = item;
1058
1059         if (stat(file, &s) < 0) {
1060                 FILE_OP_ERROR(file, "stat");
1061                 msginfo->size = 0;
1062                 msginfo->mtime = 0;
1063         } else {
1064                 msginfo->size = s.st_size;
1065                 msginfo->mtime = s.st_mtime;
1066         }
1067
1068         return msginfo;
1069 }
1070
1071 static gboolean mh_is_maildir_one(const gchar *path, const gchar *dir)
1072 {
1073         gchar *entry;
1074         gboolean result;
1075
1076         entry = g_strconcat(path, G_DIR_SEPARATOR_S, dir, NULL);
1077         result = is_dir_exist(entry);
1078         g_free(entry);
1079
1080         return result;
1081 }
1082
1083 /*
1084  * check whether PATH is a Maildir style mailbox.
1085  * This is the case if the 3 subdir: new, cur, tmp are existing.
1086  * This functon assumes that entry is an directory
1087  */
1088 static gboolean mh_is_maildir(const gchar *path)
1089 {
1090         return mh_is_maildir_one(path, "new") &&
1091                mh_is_maildir_one(path, "cur") &&
1092                mh_is_maildir_one(path, "tmp");
1093 }
1094
1095 static void mh_scan_tree_recursive(FolderItem *item, GHashTable *pptable)
1096 {
1097         DIR *dp;
1098         struct dirent *d;
1099         struct stat s;
1100         gchar *entry;
1101         gint n_msg = 0;
1102
1103         g_return_if_fail(item != NULL);
1104         g_return_if_fail(item->folder != NULL);
1105
1106         dp = opendir(item->path ? item->path : ".");
1107         if (!dp) {
1108                 FILE_OP_ERROR(item->path ? item->path : ".", "opendir");
1109                 return;
1110         }
1111
1112         debug_print("scanning %s ...\n",
1113                     item->path ? item->path
1114                     : LOCAL_FOLDER(item->folder)->rootpath);
1115         if (item->folder->ui_func)
1116                 item->folder->ui_func(item->folder, item,
1117                                       item->folder->ui_func_data);
1118
1119         while ((d = readdir(dp)) != NULL) {
1120                 if (d->d_name[0] == '.') continue;
1121
1122                 if (item->path)
1123                         entry = g_strconcat(item->path, G_DIR_SEPARATOR_S,
1124                                             d->d_name, NULL);
1125                 else
1126                         entry = g_strdup(d->d_name);
1127
1128                 if (stat(entry, &s) < 0) {
1129                         FILE_OP_ERROR(entry, "stat");
1130                         g_free(entry);
1131                         continue;
1132                 }
1133
1134                 if (S_ISDIR(s.st_mode)) {
1135                         FolderItem *new_item;
1136
1137                         if (mh_is_maildir(entry)) {
1138                                 g_free(entry);
1139                                 continue;
1140                         }
1141
1142                         new_item = folder_item_new(d->d_name, entry);
1143                         folder_item_append(item, new_item);
1144                         if (!item->path) {
1145                                 if (!strcmp(d->d_name, INBOX_DIR)) {
1146                                         new_item->stype = F_INBOX;
1147                                         item->folder->inbox = new_item;
1148                                 } else if (!strcmp(d->d_name, OUTBOX_DIR)) {
1149                                         new_item->stype = F_OUTBOX;
1150                                         item->folder->outbox = new_item;
1151                                 } else if (!strcmp(d->d_name, DRAFT_DIR)) {
1152                                         new_item->stype = F_DRAFT;
1153                                         item->folder->draft = new_item;
1154                                 } else if (!strcmp(d->d_name, QUEUE_DIR)) {
1155                                         new_item->stype = F_QUEUE;
1156                                         item->folder->queue = new_item;
1157                                 } else if (!strcmp(d->d_name, TRASH_DIR)) {
1158                                         new_item->stype = F_TRASH;
1159                                         item->folder->trash = new_item;
1160                                 }
1161                         }
1162                         folder_item_restore_persist_prefs(new_item, pptable);
1163                         mh_scan_tree_recursive(new_item, pptable);
1164                 } else if (to_number(d->d_name) != -1) n_msg++;
1165
1166                 g_free(entry);
1167         }
1168
1169         closedir(dp);
1170
1171         if (item->path) {
1172                 gint new, unread, total, min, max;
1173
1174                 procmsg_get_mark_sum(item->path, &new, &unread, &total,
1175                                      &min, &max, 0);
1176                 if (n_msg > total) {
1177                         new += n_msg - total;
1178                         unread += n_msg - total;
1179                 }
1180                 item->new = new;
1181                 item->unread = unread;
1182                 item->total = n_msg;
1183         }
1184 }
1185
1186 static gboolean mh_rename_folder_func(GNode *node, gpointer data)
1187 {
1188         FolderItem *item = node->data;
1189         gchar **paths = data;
1190         const gchar *oldpath = paths[0];
1191         const gchar *newpath = paths[1];
1192         gchar *base;
1193         gchar *new_itempath;
1194         gint oldpathlen;
1195
1196         oldpathlen = strlen(oldpath);
1197         if (strncmp(oldpath, item->path, oldpathlen) != 0) {
1198                 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
1199                 return TRUE;
1200         }
1201
1202         base = item->path + oldpathlen;
1203         while (*base == G_DIR_SEPARATOR) base++;
1204         if (*base == '\0')
1205                 new_itempath = g_strdup(newpath);
1206         else
1207                 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
1208                                            NULL);
1209         g_free(item->path);
1210         item->path = new_itempath;
1211
1212         return FALSE;
1213 }