2bb0a8793286e1b5ad2f799c30397da4e31578a2
[claws.git] / src / msgcache.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2005 Hiroyuki Yamamoto & The Sylpheed Claws Team
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #include "defs.h"
21
22 #include <glib.h>
23 #include <glib/gi18n.h>
24
25 #include <time.h>
26
27 #include "msgcache.h"
28 #include "utils.h"
29 #include "procmsg.h"
30 #include "codeconv.h"
31
32 #if G_BYTE_ORDER == G_BIG_ENDIAN
33 #define bswap_32(x) \
34      ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
35       (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
36 #else
37 #define bswap_32(x) (x)
38 #endif
39
40 static gboolean swapping = TRUE;
41
42 typedef enum
43 {
44         DATA_READ,
45         DATA_WRITE,
46         DATA_APPEND
47 } DataOpenMode;
48
49 struct _MsgCache {
50         GHashTable      *msgnum_table;
51         GHashTable      *msgid_table;
52         guint            memusage;
53         time_t           last_access;
54 };
55
56 typedef struct _StringConverter StringConverter;
57 struct _StringConverter {
58         gchar *(*convert) (StringConverter *converter, gchar *srcstr);
59         void   (*free)    (StringConverter *converter);
60 };
61
62 typedef struct _StrdupConverter StrdupConverter;
63 struct _StrdupConverter {
64         StringConverter converter;
65 };
66
67 typedef struct _CharsetConverter CharsetConverter;
68 struct _CharsetConverter {
69         StringConverter converter;
70
71         gchar *srccharset;
72         gchar *dstcharset;
73 };
74
75 MsgCache *msgcache_new(void)
76 {
77         MsgCache *cache;
78         
79         cache = g_new0(MsgCache, 1),
80         cache->msgnum_table = g_hash_table_new(g_int_hash, g_int_equal);
81         cache->msgid_table = g_hash_table_new(g_str_hash, g_str_equal);
82         cache->last_access = time(NULL);
83
84         return cache;
85 }
86
87 static gboolean msgcache_msginfo_free_func(gpointer num, gpointer msginfo, gpointer user_data)
88 {
89         procmsg_msginfo_free((MsgInfo *)msginfo);
90         return TRUE;
91 }                                                                                         
92
93 void msgcache_destroy(MsgCache *cache)
94 {
95         g_return_if_fail(cache != NULL);
96
97         g_hash_table_foreach_remove(cache->msgnum_table, msgcache_msginfo_free_func, NULL);
98         g_hash_table_destroy(cache->msgid_table);
99         g_hash_table_destroy(cache->msgnum_table);
100         g_free(cache);
101 }
102
103 void msgcache_add_msg(MsgCache *cache, MsgInfo *msginfo) 
104 {
105         MsgInfo *newmsginfo;
106
107         g_return_if_fail(cache != NULL);
108         g_return_if_fail(msginfo != NULL);
109
110         newmsginfo = procmsg_msginfo_new_ref(msginfo);
111         g_hash_table_insert(cache->msgnum_table, &newmsginfo->msgnum, newmsginfo);
112         if(newmsginfo->msgid != NULL)
113                 g_hash_table_insert(cache->msgid_table, newmsginfo->msgid, newmsginfo);
114         cache->memusage += procmsg_msginfo_memusage(msginfo);
115         cache->last_access = time(NULL);
116
117         debug_print("Cache size: %d messages, %d bytes\n", g_hash_table_size(cache->msgnum_table), cache->memusage);
118 }
119
120 void msgcache_remove_msg(MsgCache *cache, guint msgnum)
121 {
122         MsgInfo *msginfo;
123
124         g_return_if_fail(cache != NULL);
125         g_return_if_fail(msgnum > 0);
126
127         msginfo = (MsgInfo *) g_hash_table_lookup(cache->msgnum_table, &msgnum);
128         if(!msginfo)
129                 return;
130
131         cache->memusage -= procmsg_msginfo_memusage(msginfo);
132         if(msginfo->msgid)
133                 g_hash_table_remove(cache->msgid_table, msginfo->msgid);
134         g_hash_table_remove(cache->msgnum_table, &msginfo->msgnum);
135         procmsg_msginfo_free(msginfo);
136         cache->last_access = time(NULL);
137
138         debug_print("Cache size: %d messages, %d byte\n", g_hash_table_size(cache->msgnum_table), cache->memusage);
139 }
140
141 void msgcache_update_msg(MsgCache *cache, MsgInfo *msginfo)
142 {
143         MsgInfo *oldmsginfo, *newmsginfo;
144         
145         g_return_if_fail(cache != NULL);
146         g_return_if_fail(msginfo != NULL);
147
148         oldmsginfo = g_hash_table_lookup(cache->msgnum_table, &msginfo->msgnum);
149         if(oldmsginfo && oldmsginfo->msgid) 
150                 g_hash_table_remove(cache->msgid_table, oldmsginfo->msgid);
151         if (oldmsginfo) {
152                 g_hash_table_remove(cache->msgnum_table, &oldmsginfo->msgnum);
153                 cache->memusage -= procmsg_msginfo_memusage(oldmsginfo);
154                 procmsg_msginfo_free(oldmsginfo);
155         }
156
157         newmsginfo = procmsg_msginfo_new_ref(msginfo);
158         g_hash_table_insert(cache->msgnum_table, &newmsginfo->msgnum, newmsginfo);
159         if(newmsginfo->msgid)
160                 g_hash_table_insert(cache->msgid_table, newmsginfo->msgid, newmsginfo);
161         cache->memusage += procmsg_msginfo_memusage(newmsginfo);
162         cache->last_access = time(NULL);
163         
164         debug_print("Cache size: %d messages, %d byte\n", g_hash_table_size(cache->msgnum_table), cache->memusage);
165
166         return;
167 }
168
169 MsgInfo *msgcache_get_msg(MsgCache *cache, guint num)
170 {
171         MsgInfo *msginfo;
172
173         g_return_val_if_fail(cache != NULL, NULL);
174
175         msginfo = g_hash_table_lookup(cache->msgnum_table, &num);
176         if(!msginfo)
177                 return NULL;
178         cache->last_access = time(NULL);
179         
180         return procmsg_msginfo_new_ref(msginfo);
181 }
182
183 MsgInfo *msgcache_get_msg_by_id(MsgCache *cache, const gchar *msgid)
184 {
185         MsgInfo *msginfo;
186         
187         g_return_val_if_fail(cache != NULL, NULL);
188         g_return_val_if_fail(msgid != NULL, NULL);
189
190         msginfo = g_hash_table_lookup(cache->msgid_table, msgid);
191         if(!msginfo)
192                 return NULL;
193         cache->last_access = time(NULL);
194         
195         return procmsg_msginfo_new_ref(msginfo);        
196 }
197
198 static void msgcache_get_msg_list_func(gpointer key, gpointer value, gpointer user_data)
199 {
200         MsgInfoList **listptr = user_data;
201         MsgInfo *msginfo = value;
202
203         *listptr = g_slist_prepend(*listptr, procmsg_msginfo_new_ref(msginfo));
204 }
205
206 MsgInfoList *msgcache_get_msg_list(MsgCache *cache)
207 {
208         MsgInfoList *msg_list = NULL;
209
210         g_return_val_if_fail(cache != NULL, NULL);
211
212         g_hash_table_foreach((GHashTable *)cache->msgnum_table, msgcache_get_msg_list_func, (gpointer)&msg_list);       
213         cache->last_access = time(NULL);
214         
215         msg_list = g_slist_reverse(msg_list);
216
217         return msg_list;
218 }
219
220 time_t msgcache_get_last_access_time(MsgCache *cache)
221 {
222         g_return_val_if_fail(cache != NULL, 0);
223         
224         return cache->last_access;
225 }
226
227 gint msgcache_get_memory_usage(MsgCache *cache)
228 {
229         g_return_val_if_fail(cache != NULL, 0);
230
231         return cache->memusage;
232 }
233
234 /*
235  *  Cache saving functions
236  */
237
238 #define READ_CACHE_DATA(data, fp, total_len) \
239 { \
240         if ((tmp_len = msgcache_read_cache_data_str(fp, &data, conv)) < 0) { \
241                 procmsg_msginfo_free(msginfo); \
242                 error = TRUE; \
243                 break; \
244         } \
245         total_len += tmp_len; \
246 }
247
248 #define READ_CACHE_DATA_INT(n, fp) \
249 { \
250         guint32 idata; \
251         size_t ni; \
252  \
253         if ((ni = fread(&idata, sizeof(idata), 1, fp)) != 1) { \
254                 g_warning("read_int: Cache data corrupted, read %d of %d at " \
255                           "offset %ld\n", ni, sizeof(idata), ftell(fp)); \
256                 procmsg_msginfo_free(msginfo); \
257                 error = TRUE; \
258                 break; \
259         } else \
260                 n = swapping ? bswap_32(idata) : (idata);\
261 }
262
263 #define WRITE_CACHE_DATA_INT(n, fp)             \
264 {                                               \
265         guint32 idata;                          \
266                                                 \
267         idata = (guint32)bswap_32(n);                   \
268         fwrite(&idata, sizeof(idata), 1, fp);   \
269 }
270
271 #define WRITE_CACHE_DATA(data, fp) \
272 { \
273         size_t len; \
274         if (data == NULL) \
275                 len = 0; \
276         else \
277                 len = strlen(data); \
278         WRITE_CACHE_DATA_INT(len, fp); \
279         if (len > 0) { \
280                 fwrite(data, len, 1, fp); \
281         } \
282 }
283
284 static FILE *msgcache_open_data_file(const gchar *file, guint version,
285                                      DataOpenMode mode,
286                                      gchar *buf, size_t buf_size)
287 {
288         FILE *fp;
289         gint32 data_ver;
290
291         g_return_val_if_fail(file != NULL, NULL);
292
293         if (mode == DATA_WRITE) {
294                 if ((fp = fopen(file, "wb")) == NULL) {
295                         FILE_OP_ERROR(file, "fopen");
296                         return NULL;
297                 }
298                 if (change_file_mode_rw(fp, file) < 0)
299                         FILE_OP_ERROR(file, "chmod");
300
301                 WRITE_CACHE_DATA_INT(version, fp);
302                 return fp;
303         }
304
305         /* check version */
306         if ((fp = fopen(file, "rb")) == NULL)
307                 debug_print("Mark/Cache file '%s' not found\n", file);
308         else {
309                 if (buf && buf_size > 0)
310                         setvbuf(fp, buf, _IOFBF, buf_size);
311                 if (fread(&data_ver, sizeof(data_ver), 1, fp) != 1 ||
312                          version != bswap_32(data_ver)) {
313                         g_message("%s: Mark/Cache version is different (%u != %u).\n",
314                                   file, bswap_32(data_ver), version);
315                         fclose(fp);
316                         fp = NULL;
317                 }
318                 data_ver = bswap_32(data_ver);
319         }
320         
321         if (mode == DATA_READ)
322                 return fp;
323
324         if (fp) {
325                 /* reopen with append mode */
326                 fclose(fp);
327                 if ((fp = fopen(file, "ab")) == NULL)
328                         FILE_OP_ERROR(file, "fopen");
329         } else {
330                 /* open with overwrite mode if mark file doesn't exist or
331                    version is different */
332                 fp = msgcache_open_data_file(file, version, DATA_WRITE, buf,
333                                             buf_size);
334         }
335
336         return fp;
337 }
338
339 static gint msgcache_read_cache_data_str(FILE *fp, gchar **str, 
340                                          StringConverter *conv)
341 {
342         gchar *tmpstr = NULL;
343         size_t ni;
344         guint32 len;
345
346         *str = NULL;
347         if (!swapping) {
348                 if ((ni = fread(&len, sizeof(len), 1, fp) != 1) ||
349                     len > G_MAXINT) {
350                         g_warning("read_data_str: Cache data (len) corrupted, read %d "
351                                   "of %d bytes at offset %ld\n", ni, sizeof(len), 
352                                   ftell(fp));
353                         return -1;
354                 }
355         } else {
356                 if ((ni = fread(&len, sizeof(len), 1, fp) != 1) ||
357                     bswap_32(len) > G_MAXINT) {
358                         g_warning("read_data_str: Cache data (len) corrupted, read %d "
359                                   "of %d bytes at offset %ld\n", ni, sizeof(len), 
360                                   ftell(fp));
361                         return -1;
362                 }
363                 len = bswap_32(len);
364         }
365
366         if (len == 0)
367                 return 0;
368
369         tmpstr = g_malloc(len + 1);
370
371         if ((ni = fread(tmpstr, 1, len, fp)) != len) {
372                 g_warning("read_data_str: Cache data corrupted, read %d of %d "
373                           "bytes at offset %ld\n", 
374                           ni, len, ftell(fp));
375                 g_free(tmpstr);
376                 return -1;
377         }
378         tmpstr[len] = 0;
379
380         if (conv != NULL) {
381                 *str = conv->convert(conv, tmpstr);
382                 g_free(tmpstr);
383         } else 
384                 *str = tmpstr;
385
386         return len;
387 }
388
389 gchar *strconv_strdup_convert(StringConverter *conv, gchar *srcstr)
390 {
391         return g_strdup(srcstr);
392 }
393
394 gchar *strconv_charset_convert(StringConverter *conv, gchar *srcstr)
395 {
396         CharsetConverter *charsetconv = (CharsetConverter *) conv;
397
398         return conv_codeset_strdup(srcstr, charsetconv->srccharset, charsetconv->dstcharset);
399 }
400
401 void strconv_charset_free(StringConverter *conv)
402 {
403         CharsetConverter *charsetconv = (CharsetConverter *) conv;
404
405         g_free(charsetconv->srccharset);
406         g_free(charsetconv->dstcharset);
407 }
408
409 MsgCache *msgcache_read_cache(FolderItem *item, const gchar *cache_file)
410 {
411         MsgCache *cache;
412         FILE *fp;
413         MsgInfo *msginfo;
414         MsgTmpFlags tmp_flags = 0;
415         gchar file_buf[BUFFSIZE];
416         guint32 num;
417         guint refnum;
418         gboolean error = FALSE;
419         StringConverter *conv = NULL;
420         gchar *srccharset = NULL;
421         const gchar *dstcharset = NULL;
422         gchar *ref = NULL;
423         guint memusage = 0;
424         guint tmp_len = 0;
425 #if 0
426         struct timeval start;
427         struct timeval end;
428         struct timeval diff;
429         gettimeofday(&start, NULL);
430 #endif
431         g_return_val_if_fail(cache_file != NULL, NULL);
432         g_return_val_if_fail(item != NULL, NULL);
433
434         swapping = TRUE;
435
436         /* In case we can't open the mark file with MARK_VERSION, check if we can open it with the
437          * swapped MARK_VERSION. As msgcache_open_data_file swaps it too, if this succeeds, 
438          * it means it's the old version (not little-endian) on a big-endian machine. The code has
439          * no effect on x86 as their file doesn't change. */
440
441         if ((fp = msgcache_open_data_file
442                 (cache_file, CACHE_VERSION, DATA_READ, file_buf, sizeof(file_buf))) == NULL) {
443                 if ((fp = msgcache_open_data_file
444                 (cache_file, bswap_32(CACHE_VERSION), DATA_READ, file_buf, sizeof(file_buf))) == NULL)
445                         return NULL;
446                 else
447                         swapping = FALSE;
448         }
449
450         debug_print("\tReading %sswapped message cache from %s...\n", swapping?"":"un", cache_file);
451
452         if (folder_has_parent_of_type(item, F_QUEUE)) {
453                 tmp_flags |= MSG_QUEUED;
454         } else if (folder_has_parent_of_type(item, F_DRAFT)) {
455                 tmp_flags |= MSG_DRAFT;
456         }
457
458         if (msgcache_read_cache_data_str(fp, &srccharset, NULL) < 0)
459                 return NULL;
460         dstcharset = CS_UTF_8;
461         if (srccharset == NULL || dstcharset == NULL) {
462                 conv = NULL;
463         } else if (strcmp(srccharset, dstcharset) == 0) {
464                 StrdupConverter *strdupconv;
465
466                 debug_print("using StrdupConverter\n");
467
468                 strdupconv = g_new0(StrdupConverter, 1);
469                 strdupconv->converter.convert = strconv_strdup_convert;
470                 strdupconv->converter.free = NULL;
471
472                 conv = (StringConverter *) strdupconv;
473         } else {
474                 CharsetConverter *charsetconv;
475
476                 debug_print("using CharsetConverter\n");
477
478                 charsetconv = g_new0(CharsetConverter, 1);
479                 charsetconv->converter.convert = strconv_charset_convert;
480                 charsetconv->converter.free = strconv_charset_free;
481                 charsetconv->srccharset = g_strdup(srccharset);
482                 charsetconv->dstcharset = g_strdup(dstcharset);
483
484                 conv = (StringConverter *) charsetconv;
485         }
486         g_free(srccharset);
487
488         cache = msgcache_new();
489         g_hash_table_freeze(cache->msgnum_table);
490         g_hash_table_freeze(cache->msgid_table);
491
492         while (fread(&num, sizeof(num), 1, fp) == 1) {
493                 if (swapping)
494                         num = bswap_32(num);
495
496                 msginfo = procmsg_msginfo_new();
497                 msginfo->msgnum = num;
498                 memusage += sizeof(MsgInfo);
499                 
500                 READ_CACHE_DATA_INT(msginfo->size, fp);
501                 READ_CACHE_DATA_INT(msginfo->mtime, fp);
502                 READ_CACHE_DATA_INT(msginfo->date_t, fp);
503                 READ_CACHE_DATA_INT(msginfo->flags.tmp_flags, fp);
504                                 
505                 READ_CACHE_DATA(msginfo->fromname, fp, memusage);
506
507                 READ_CACHE_DATA(msginfo->date, fp, memusage);
508                 READ_CACHE_DATA(msginfo->from, fp, memusage);
509                 READ_CACHE_DATA(msginfo->to, fp, memusage);
510                 READ_CACHE_DATA(msginfo->cc, fp, memusage);
511                 READ_CACHE_DATA(msginfo->newsgroups, fp, memusage);
512                 READ_CACHE_DATA(msginfo->subject, fp, memusage);
513                 READ_CACHE_DATA(msginfo->msgid, fp, memusage);
514                 READ_CACHE_DATA(msginfo->inreplyto, fp, memusage);
515                 READ_CACHE_DATA(msginfo->xref, fp, memusage);
516                 
517                 READ_CACHE_DATA_INT(msginfo->planned_download, fp);
518                 READ_CACHE_DATA_INT(msginfo->total_size, fp);
519                 READ_CACHE_DATA_INT(refnum, fp);
520                 
521                 for (; refnum != 0; refnum--) {
522                         ref = NULL;
523
524                         READ_CACHE_DATA(ref, fp, memusage);
525
526                         if (ref && strlen(ref))
527                                 msginfo->references =
528                                         g_slist_prepend(msginfo->references, ref);
529                 }
530                 if (msginfo->references)
531                         msginfo->references =
532                                 g_slist_reverse(msginfo->references);
533
534                 msginfo->folder = item;
535                 msginfo->flags.tmp_flags |= tmp_flags;
536
537                 g_hash_table_insert(cache->msgnum_table, &msginfo->msgnum, msginfo);
538                 if(msginfo->msgid)
539                         g_hash_table_insert(cache->msgid_table, msginfo->msgid, msginfo);
540         }
541         fclose(fp);
542         g_hash_table_thaw(cache->msgnum_table);
543         g_hash_table_thaw(cache->msgid_table);
544
545         if (conv != NULL) {
546                 if (conv->free != NULL)
547                         conv->free(conv);
548                 g_free(conv);
549         }
550
551         if(error) {
552                 msgcache_destroy(cache);
553                 return NULL;
554         }
555
556         cache->last_access = time(NULL);
557         cache->memusage = memusage;
558
559         debug_print("done. (%d items read)\n", g_hash_table_size(cache->msgnum_table));
560         debug_print("Cache size: %d messages, %d byte\n", g_hash_table_size(cache->msgnum_table), cache->memusage);
561 #if 0
562         gettimeofday(&end, NULL);
563         timersub(&end, &start, &diff);
564         printf("spent %d seconds %d usages %d;%d\n", diff.tv_sec, diff.tv_usec, cache->memusage, memusage);
565 #endif
566         return cache;
567 }
568
569 void msgcache_read_mark(MsgCache *cache, const gchar *mark_file)
570 {
571         FILE *fp;
572         MsgInfo *msginfo;
573         MsgPermFlags perm_flags;
574         guint32 num;
575         
576         swapping = TRUE;
577
578         /* In case we can't open the mark file with MARK_VERSION, check if we can open it with the
579          * swapped MARK_VERSION. As msgcache_open_data_file swaps it too, if this succeeds, 
580          * it means it's the old version (not little-endian) on a big-endian machine. The code has
581          * no effect on x86 as their file doesn't change. */
582
583         if ((fp = msgcache_open_data_file(mark_file, MARK_VERSION, DATA_READ, NULL, 0)) == NULL) {
584                 /* see if it isn't swapped ? */
585                 if ((fp = msgcache_open_data_file(mark_file, bswap_32(MARK_VERSION), DATA_READ, NULL, 0)) == NULL)
586                         return;
587                 else
588                         swapping = FALSE; /* yay */
589         }
590         debug_print("reading %sswapped mark file.\n", swapping?"":"un");
591         while (fread(&num, sizeof(num), 1, fp) == 1) {
592                 if (swapping)
593                         num = bswap_32(num);
594                 if (fread(&perm_flags, sizeof(perm_flags), 1, fp) != 1) break;
595                 if (swapping)
596                         perm_flags = bswap_32(perm_flags);
597                 msginfo = g_hash_table_lookup(cache->msgnum_table, &num);
598                 if(msginfo) {
599                         msginfo->flags.perm_flags = perm_flags;
600                 }
601         }       
602         fclose(fp);
603 }
604
605 void msgcache_write_cache(MsgInfo *msginfo, FILE *fp)
606 {
607         MsgTmpFlags flags = msginfo->flags.tmp_flags & MSG_CACHED_FLAG_MASK;
608         GSList *cur;
609
610         WRITE_CACHE_DATA_INT(msginfo->msgnum, fp);
611         WRITE_CACHE_DATA_INT(msginfo->size, fp);
612         WRITE_CACHE_DATA_INT(msginfo->mtime, fp);
613         WRITE_CACHE_DATA_INT(msginfo->date_t, fp);
614         WRITE_CACHE_DATA_INT(flags, fp);
615
616         WRITE_CACHE_DATA(msginfo->fromname, fp);
617
618         WRITE_CACHE_DATA(msginfo->date, fp);
619         WRITE_CACHE_DATA(msginfo->from, fp);
620         WRITE_CACHE_DATA(msginfo->to, fp);
621         WRITE_CACHE_DATA(msginfo->cc, fp);
622         WRITE_CACHE_DATA(msginfo->newsgroups, fp);
623         WRITE_CACHE_DATA(msginfo->subject, fp);
624         WRITE_CACHE_DATA(msginfo->msgid, fp);
625         WRITE_CACHE_DATA(msginfo->inreplyto, fp);
626         WRITE_CACHE_DATA(msginfo->xref, fp);
627         WRITE_CACHE_DATA_INT(msginfo->planned_download, fp);
628         WRITE_CACHE_DATA_INT(msginfo->total_size, fp);
629         
630         WRITE_CACHE_DATA_INT(g_slist_length(msginfo->references), fp);
631
632         for (cur = msginfo->references; cur != NULL; cur = cur->next) {
633                 WRITE_CACHE_DATA((gchar *)cur->data, fp);
634         }
635 }
636
637 static void msgcache_write_flags(MsgInfo *msginfo, FILE *fp)
638 {
639         MsgPermFlags flags = msginfo->flags.perm_flags;
640
641         WRITE_CACHE_DATA_INT(msginfo->msgnum, fp);
642         WRITE_CACHE_DATA_INT(flags, fp);
643 }
644
645 struct write_fps
646 {
647         FILE *cache_fp;
648         FILE *mark_fp;
649 };
650
651 static void msgcache_write_func(gpointer key, gpointer value, gpointer user_data)
652 {
653         MsgInfo *msginfo;
654         struct write_fps *write_fps;
655
656         msginfo = (MsgInfo *)value;
657         write_fps = user_data;
658
659         msgcache_write_cache(msginfo, write_fps->cache_fp);
660         msgcache_write_flags(msginfo, write_fps->mark_fp);
661 }
662
663 gint msgcache_write(const gchar *cache_file, const gchar *mark_file, MsgCache *cache)
664 {
665         struct write_fps write_fps;
666
667         g_return_val_if_fail(cache_file != NULL, -1);
668         g_return_val_if_fail(mark_file != NULL, -1);
669         g_return_val_if_fail(cache != NULL, -1);
670
671         write_fps.cache_fp = msgcache_open_data_file(cache_file, CACHE_VERSION,
672                 DATA_WRITE, NULL, 0);
673         if (write_fps.cache_fp == NULL)
674                 return -1;
675
676         WRITE_CACHE_DATA(CS_UTF_8, write_fps.cache_fp);
677
678         write_fps.mark_fp = msgcache_open_data_file(mark_file, MARK_VERSION,
679                 DATA_WRITE, NULL, 0);
680         if (write_fps.mark_fp == NULL) {
681                 fclose(write_fps.cache_fp);
682                 return -1;
683         }
684
685         debug_print("\tWriting message cache to %s and %s...\n", cache_file, mark_file);
686
687         if (change_file_mode_rw(write_fps.cache_fp, cache_file) < 0)
688                 FILE_OP_ERROR(cache_file, "chmod");
689
690         g_hash_table_foreach(cache->msgnum_table, msgcache_write_func, (gpointer)&write_fps);
691
692         fclose(write_fps.cache_fp);
693         fclose(write_fps.mark_fp);
694
695         cache->last_access = time(NULL);
696
697         debug_print("done.\n");
698         return 0;
699 }
700