RSSyl: Free GError from memory where necessary.
[claws.git] / src / plugins / rssyl / rssyl.c
1 /*
2  * Claws-Mail-- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2004 Hiroyuki Yamamoto
4  * This file (C) 2005 Andrej Kacian <andrej@kacian.sk>
5  *
6  * - s-c folderclass callback handler functions
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #  include "config.h"
25 #endif
26
27 /* Global includes */
28 #include <glib.h>
29 #include <glib/gi18n.h>
30 #include <curl/curl.h>
31
32 /* Claws Mail includes */
33 #include <folder.h>
34 #include <procmsg.h>
35 #include <localfolder.h>
36 #include <common/utils.h>
37 #include <main.h>
38 #include <mh.h>
39 #include <xml.h>
40 #include <toolbar.h>
41 #include <prefs_toolbar.h>
42 #include <utils.h>
43
44 /* Local includes */
45 #include "libfeed/feeditem.h"
46 #include "rssyl.h"
47 #include "rssyl_deleted.h"
48 #include "rssyl_gtk.h"
49 #include "rssyl_feed.h"
50 #include "rssyl_prefs.h"
51 #include "rssyl_update_feed.h"
52 #include "rssyl_update_format.h"
53 #include "opml_import.h"
54 #include "opml_export.h"
55 #include "strutils.h"
56
57 FolderClass rssyl_class;
58
59 static gint rssyl_create_tree(Folder *folder);
60 static gint rssyl_scan_tree(Folder *folder);
61
62 static gboolean existing_tree_found = FALSE;
63
64 static void rssyl_init_read_func(FolderItem *item, gpointer data)
65 {
66         RFolderItem *ritem = (RFolderItem *)item;
67         RPrefs *rsprefs = NULL;
68
69         if( !IS_RSSYL_FOLDER_ITEM(item) )
70                 return;
71
72         existing_tree_found = TRUE;
73
74         /* Don't do anything if we're on root of our folder tree or on
75          * a regular folder (no feed) */
76         if( folder_item_parent(item) == NULL || ritem->url == NULL )
77                 return;
78
79         ritem->refresh_id = 0;
80
81         /* Start automatic refresh timer, if necessary */
82         if( ritem->default_refresh_interval ) {
83                 rsprefs = rssyl_prefs_get();
84                 if( !rsprefs->refresh_enabled )
85                         return;
86
87                 ritem->refresh_interval = rsprefs->refresh;
88         }
89
90         /* Start the timer, if determined interval is >0 */
91         if( ritem->refresh_interval > 0 )
92                 rssyl_feed_start_refresh_timeout(ritem);
93 }
94
95 static void rssyl_make_rc_dir(void)
96 {
97         gchar *rssyl_dir = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, RSSYL_DIR,
98                         NULL);
99
100         if( !is_dir_exist(rssyl_dir) ) {
101                 if( make_dir(rssyl_dir) < 0 ) {
102                         g_warning("couldn't create directory %s\n", rssyl_dir);
103                 }
104
105                 debug_print("RSSyl: created directory %s\n", rssyl_dir);
106         }
107
108         g_free(rssyl_dir);
109 }
110
111 static void rssyl_create_default_mailbox(void)
112 {
113         Folder *root = NULL;
114
115         rssyl_make_rc_dir();
116
117         root = folder_new(rssyl_folder_get_class(), RSSYL_DEFAULT_MAILBOX, NULL);
118
119         g_return_if_fail(root != NULL);
120         folder_add(root);
121
122         rssyl_scan_tree(root);
123
124         /* FIXME: subscribe default feed */
125 //      rssyl_subscribe_new_feed(item, RSSYL_DEFAULT_FEED, TRUE);
126 }
127
128 static gboolean rssyl_update_all_feeds_deferred(gpointer data)
129 {
130         rssyl_update_all_feeds();
131         return FALSE;
132 }
133
134 static void rssyl_toolbar_cb_refresh_all_feeds(gpointer parent, const gchar *item_name, gpointer data)
135 {
136         rssyl_update_all_feeds();
137 }
138
139 void rssyl_init(void)
140 {
141         folder_register_class(rssyl_folder_get_class());
142
143         rssyl_gtk_init();
144         rssyl_make_rc_dir();
145
146         rssyl_prefs_init();
147
148         folder_func_to_all_folders((FolderItemFunc)rssyl_init_read_func, NULL);
149
150         if( !existing_tree_found )
151                 rssyl_create_default_mailbox();
152         else
153                 rssyl_update_format();
154
155         prefs_toolbar_register_plugin_item(TOOLBAR_MAIN, "RSSyl", _("Refresh all feeds"), rssyl_toolbar_cb_refresh_all_feeds, NULL);
156
157         if( rssyl_prefs_get()->refresh_on_startup &&
158                         claws_is_starting() )
159                 g_timeout_add(2000, rssyl_update_all_feeds_deferred, NULL);
160 }
161
162 void rssyl_done(void)
163 {
164         rssyl_opml_export();
165
166         prefs_toolbar_unregister_plugin_item(TOOLBAR_MAIN, "RSSyl", _("Refresh all feeds"));
167
168         rssyl_prefs_done();
169         rssyl_gtk_done();
170
171         if( !claws_is_exiting() )
172                 folder_unregister_class(rssyl_folder_get_class());
173
174         debug_print("RSSyl is done\n");
175 }
176
177 static gchar *rssyl_get_new_msg_filename(FolderItem *dest)
178 {
179         gchar *destfile;
180         gchar *destpath;
181
182         destpath = folder_item_get_path(dest);
183         g_return_val_if_fail(destpath != NULL, NULL);
184
185         if( !is_dir_exist(destpath) )
186                 make_dir_hier(destpath);
187
188         for( ; ; ) {
189                 destfile = g_strdup_printf("%s%c%d", destpath, G_DIR_SEPARATOR,
190                                 dest->last_num + 1);
191                 if( is_file_entry_exist(destfile) ) {
192                         dest->last_num++;
193                         g_free(destfile);
194                 } else
195                         break;
196         }
197
198         g_free(destpath);
199
200         return destfile;
201 }
202
203 static void rssyl_get_last_num(Folder *folder, FolderItem *item)
204 {
205         gchar *path;
206         const char *f;
207         GDir *dp;
208         GError *error;
209         gint max = 0;
210         gint num;
211
212         g_return_if_fail(item != NULL);
213
214         debug_print("rssyl_get_last_num(): Scanning %s ...\n", item->path);
215         path = folder_item_get_path(item);
216         g_return_if_fail(path != NULL);
217
218         if( (dp = g_dir_open(path, 0, &error)) == NULL ) {
219                 FILE_OP_ERROR(item->path, "g_dir_open");
220                 debug_print("g_dir_open() failed on \"%s\", error %d (%s).\n",
221                                 path, error->code, error->message);
222                 g_error_free(error);
223                 g_free(path);
224                 return;
225         }
226
227         g_free(path);
228
229         while( (f = g_dir_read_name(dp)) != NULL) {
230                 if ((num = to_number(f)) > 0 &&
231                                 g_file_test(f, G_FILE_TEST_IS_REGULAR)) {
232                         if( max < num )
233                                 max = num;
234                 }
235         }
236         g_dir_close(dp);
237
238         debug_print("Last number in dir %s = %d\n", item->path, max);
239         item->last_num = max;
240 }
241
242 static Folder *rssyl_new_folder(const gchar *name, const gchar *path)
243 {
244         Folder *folder;
245
246         debug_print("RSSyl: new_folder: %s (%s)\n", name, path);
247
248         rssyl_make_rc_dir();
249
250         folder = g_new0(Folder, 1);
251         FOLDER(folder)->klass = &rssyl_class;
252         folder_init(FOLDER(folder), name);
253
254         return FOLDER(folder);
255 }
256
257 static void rssyl_destroy_folder(Folder *folder)
258 {
259         folder_local_folder_destroy(LOCAL_FOLDER(folder));
260 }
261
262 static void rssyl_item_set_xml(Folder *folder, FolderItem *item, XMLTag *tag)
263 {
264         GList *cur;
265         RFolderItem *ritem = (RFolderItem *)item;
266
267         folder_item_set_xml(folder, item, tag);
268
269         for( cur = tag->attr; cur != NULL; cur = g_list_next(cur)) {
270                 XMLAttr *attr = (XMLAttr *) cur->data;
271
272                 if( !attr || !attr->name || !attr->value)
273                         continue;
274
275                 /* (str) URL */
276                 if( !strcmp(attr->name, "uri")) {
277                         g_free(ritem->url);
278                         ritem->url = g_strdup(attr->value);
279                 }
280                 /* (int) URL auth */
281                 if (!strcmp(attr->name, "auth")) {
282                         ritem->auth->type = atoi(attr->value);
283                 }
284                 /* (str) Auth user */
285                 if (!strcmp(attr->name, "auth_user")) {
286                         g_free(ritem->auth->username);
287                         ritem->auth->username = g_strdup(attr->value);
288                 }
289                 /* (str) Auth pass */
290                 if (!strcmp(attr->name, "auth_pass")) {
291                         gsize len = 0;
292                         guchar *pwd = g_base64_decode(attr->value, &len);
293                         g_free(ritem->auth->password);
294                         ritem->auth->password = (gchar *)pwd;
295                 }
296                 /* (str) Official title */
297                 if( !strcmp(attr->name, "official_title")) {
298                         g_free(ritem->official_title);
299                         ritem->official_title = g_strdup(attr->value);
300                 }
301                 /* (bool) Keep old items */
302                 if( !strcmp(attr->name, "keep_old"))
303                         ritem->keep_old = (atoi(attr->value) == 0 ? FALSE : TRUE );
304                 /* (bool) Use default refresh_interval */
305                 if( !strcmp(attr->name, "default_refresh_interval"))
306                         ritem->default_refresh_interval = (atoi(attr->value) == 0 ? FALSE : TRUE );
307                 /* (int) Refresh interval */
308                 if( !strcmp(attr->name, "refresh_interval"))
309                         ritem->refresh_interval = atoi(attr->value);
310                 /* (bool) Fetch comments */
311                 if( !strcmp(attr->name, "fetch_comments"))
312                         ritem->fetch_comments = (atoi(attr->value) == 0 ? FALSE : TRUE );
313                 /* (int) Max age of posts to fetch comments for */
314                 if( !strcmp(attr->name, "fetch_comments_max_age"))
315                         ritem->fetch_comments_max_age = atoi(attr->value);
316                 /* (bool) Write heading */
317                 if( !strcmp(attr->name, "write_heading"))
318                         ritem->write_heading = (atoi(attr->value) == 0 ? FALSE : TRUE );
319                 /* (int) Silent update */
320                 if( !strcmp(attr->name, "silent_update"))
321                         ritem->silent_update = atoi(attr->value);
322                 /* (bool) Ignore title rename */
323                 if( !strcmp(attr->name, "ignore_title_rename"))
324                         ritem->ignore_title_rename = (atoi(attr->value) == 0 ? FALSE : TRUE );
325                 /* (bool) Verify SSL peer  */
326                 if( !strcmp(attr->name, "ssl_verify_peer"))
327                         ritem->ssl_verify_peer = (atoi(attr->value) == 0 ? FALSE : TRUE );
328         }
329 }
330
331 static XMLTag *rssyl_item_get_xml(Folder *folder, FolderItem *item)
332 {
333         XMLTag *tag;
334         RFolderItem *ri = (RFolderItem *)item;
335         gchar *tmp = NULL;
336
337         tag = folder_item_get_xml(folder, item);
338
339         /* (str) URL */
340         if( ri->url != NULL )
341                 xml_tag_add_attr(tag, xml_attr_new("uri", ri->url));
342         /* (int) Auth */
343         tmp = g_strdup_printf("%d", ri->auth->type);
344         xml_tag_add_attr(tag, xml_attr_new("auth", tmp));
345         g_free(tmp);
346         /* (str) Auth user */
347         if (ri->auth->username != NULL)
348                 xml_tag_add_attr(tag, xml_attr_new("auth_user", ri->auth->username));
349         /* (str) Auth pass */
350         if (ri->auth->password != NULL) {
351                 gchar *pwd = g_base64_encode(ri->auth->password, strlen(ri->auth->password));
352                 xml_tag_add_attr(tag, xml_attr_new("auth_pass", pwd));
353                 g_free(pwd);
354         }
355         /* (str) Official title */
356         if( ri->official_title != NULL )
357                 xml_tag_add_attr(tag, xml_attr_new("official_title", ri->official_title));
358         /* (bool) Keep old items */
359         xml_tag_add_attr(tag, xml_attr_new("keep_old",
360                                 (ri->keep_old ? "1" : "0")) );
361         /* (bool) Use default refresh interval */
362         xml_tag_add_attr(tag, xml_attr_new("default_refresh_interval",
363                                 (ri->default_refresh_interval ? "1" : "0")) );
364         /* (int) Refresh interval */
365         tmp = g_strdup_printf("%d", ri->refresh_interval);
366         xml_tag_add_attr(tag, xml_attr_new("refresh_interval", tmp));
367         g_free(tmp);
368         /* (bool) Fetch comments */
369         xml_tag_add_attr(tag, xml_attr_new("fetch_comments",
370                                 (ri->fetch_comments ? "1" : "0")) );
371         /* (int) Max age of posts to fetch comments for */
372         tmp = g_strdup_printf("%d", ri->fetch_comments_max_age);
373         xml_tag_add_attr(tag, xml_attr_new("fetch_comments_max_age", tmp));
374         g_free(tmp);
375         /* (bool) Write heading */
376         xml_tag_add_attr(tag, xml_attr_new("write_heading",
377                                 (ri->write_heading ? "1" : "0")) );
378         /* (int) Silent update */
379         tmp = g_strdup_printf("%d", ri->silent_update);
380         xml_tag_add_attr(tag, xml_attr_new("silent_update", tmp));
381         g_free(tmp);
382         /* (bool) Ignore title rename */
383         xml_tag_add_attr(tag, xml_attr_new("ignore_title_rename",
384                                 (ri->ignore_title_rename ? "1" : "0")) );
385         /* (bool) Verify SSL peer */
386         xml_tag_add_attr(tag, xml_attr_new("ssl_verify_peer",
387                                 (ri->ssl_verify_peer ? "1" : "0")) );
388
389         return tag;
390 }
391
392 static gint rssyl_scan_tree(Folder *folder)
393 {
394         g_return_val_if_fail(folder != NULL, -1);
395
396         folder->outbox = NULL;
397         folder->draft = NULL;
398         folder->queue = NULL;
399         folder->trash = NULL;
400
401         debug_print("RSSyl: scanning tree\n");
402         rssyl_create_tree(folder);
403
404         return 0;
405 }
406
407 static gint rssyl_create_tree(Folder *folder)
408 {
409         FolderItem *rootitem;
410         GNode *rootnode;
411
412         g_return_val_if_fail(folder != NULL, -1);
413
414         rssyl_make_rc_dir();
415
416         if( !folder->node ) {
417                 rootitem = folder_item_new(folder, folder->name, NULL);
418                 rootitem->folder = folder;
419                 rootnode = g_node_new(rootitem);
420                 folder->node = rootnode;
421                 rootitem->node = rootnode;
422         }
423
424         debug_print("RSSyl: created new rssyl tree\n");
425         return 0;
426 }
427
428 static FolderItem *rssyl_item_new(Folder *folder)
429 {
430         RFolderItem *ritem = g_new0(RFolderItem, 1);
431
432         ritem->url = NULL;
433         ritem->auth = g_new0(FeedAuth, 1);
434         ritem->auth->type = FEED_AUTH_NONE;
435         ritem->auth->username = NULL;
436         ritem->auth->password = NULL;
437         ritem->official_title = NULL;
438         ritem->source_id = NULL;
439         ritem->items = NULL;
440         ritem->keep_old = FALSE;
441         ritem->default_refresh_interval = TRUE;
442         ritem->refresh_interval = atoi(PREF_DEFAULT_REFRESH);
443         ritem->fetch_comments = FALSE;
444         ritem->fetch_comments_max_age = -1;
445         ritem->write_heading = TRUE;
446         ritem->fetching_comments = FALSE;
447         ritem->silent_update = 0;
448         ritem->last_update = 0;
449         ritem->ignore_title_rename = FALSE;
450
451         return (FolderItem *)ritem;
452 }
453
454 static void rssyl_item_destroy(Folder *folder, FolderItem *item)
455 {
456         RFolderItem *ritem = (RFolderItem *)item;
457
458         g_return_if_fail(ritem != NULL);
459
460         g_free(ritem->url);
461         if (ritem->auth->username)
462                 g_free(ritem->auth->username);
463         if (ritem->auth->password)
464                 g_free(ritem->auth->password);
465         g_free(ritem->auth);
466         g_free(ritem->official_title);
467         g_slist_free(ritem->items);
468
469         /* Remove a scheduled refresh, if any */
470         if( ritem->refresh_id != 0)
471                 g_source_remove(ritem->refresh_id);
472
473         g_free(ritem);
474 }
475
476 static FolderItem *rssyl_create_folder(Folder *folder,
477                                                                 FolderItem *parent, const gchar *name)
478 {
479         gchar *path = NULL, *basepath = NULL, *itempath = NULL;
480         FolderItem *newitem = NULL;
481
482         g_return_val_if_fail(folder != NULL, NULL);
483         g_return_val_if_fail(parent != NULL, NULL);
484         g_return_val_if_fail(name != NULL, NULL);
485
486         path = folder_item_get_path(parent);
487         if( !is_dir_exist(path) ) {
488                 if( (make_dir_hier(path) != 0) ) {
489                         debug_print("RSSyl: Couldn't create directory (rec) '%s'\n", path);
490                         return NULL;
491                 }
492         }
493
494         basepath = g_strdelimit(g_strdup(name), G_DIR_SEPARATOR_S, '_');
495         path = g_strconcat(path, G_DIR_SEPARATOR_S, basepath, NULL);
496
497         if( make_dir(path) < 0 ) {
498                 debug_print("RSSyl: Couldn't create directory '%s'\n", path);
499                 g_free(path);
500                 g_free(basepath);
501                 return NULL;
502         }
503         g_free(path);
504
505         itempath = g_strconcat((parent->path ? parent->path : ""),
506                         G_DIR_SEPARATOR_S, basepath, NULL);
507         newitem = folder_item_new(folder, name, itempath);
508         g_free(itempath);
509         g_free(basepath);
510
511         folder_item_append(parent, newitem);
512
513         return newitem;
514 }
515
516 FolderItem *rssyl_get_root_folderitem(FolderItem *item)
517 {
518         FolderItem *i;
519
520         for( i = item; folder_item_parent(i) != NULL; i = folder_item_parent(i) ) { }
521         return i;
522 }
523
524 static gchar *rssyl_item_get_path(Folder *folder, FolderItem *item)
525 {
526         gchar *path, *name;
527
528         g_return_val_if_fail(folder != NULL, NULL);
529         g_return_val_if_fail(item != NULL, NULL);
530
531         debug_print("RSSyl: item_get_path\n");
532
533         name = folder_item_get_name(rssyl_get_root_folderitem(item));
534         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, RSSYL_DIR,
535                         G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S, item->path, NULL);
536         g_free(name);
537
538         return path;
539 }
540
541 static gboolean rssyl_rename_folder_func(GNode *node, gpointer data)
542 {
543         FolderItem *item = node->data;
544         gchar **paths = data;
545         const gchar *oldpath = paths[0];
546         const gchar *newpath = paths[1];
547         gchar *base;
548         gchar *new_itempath;
549         gint oldpathlen;
550
551         oldpathlen = strlen(oldpath);
552         if (strncmp(oldpath, item->path, oldpathlen) != 0) {
553                 g_warning("path doesn't match: %s, %s\n", oldpath, item->path);
554                 return TRUE;
555         }
556
557         base = item->path + oldpathlen;
558         while (*base == G_DIR_SEPARATOR) base++;
559         if (*base == '\0')
560                 new_itempath = g_strdup(newpath);
561         else
562                 new_itempath = g_strconcat(newpath, G_DIR_SEPARATOR_S, base,
563                                 NULL);
564         g_free(item->path);
565         item->path = new_itempath;
566
567         return FALSE;
568 }
569
570 static gint rssyl_rename_folder(Folder *folder, FolderItem *item,
571                                 const gchar *name)
572 {
573         gchar *oldpath;
574         gchar *dirname;
575         gchar *newpath, *utf8newpath;
576         gchar *basenewpath;
577         gchar *paths[2];
578
579         g_return_val_if_fail(folder != NULL, -1);
580         g_return_val_if_fail(item != NULL, -1);
581         g_return_val_if_fail(item->path != NULL, -1);
582         g_return_val_if_fail(name != NULL, -1);
583
584         debug_print("RSSyl: rssyl_rename_folder '%s' -> '%s'\n",
585                         item->name, name);
586
587         if (!strcmp(item->name, name))
588                         return 0;
589
590         oldpath = folder_item_get_path(item);
591         if( !is_dir_exist(oldpath) )
592                 make_dir_hier(oldpath);
593
594         dirname = g_path_get_dirname(oldpath);
595         basenewpath = g_strdelimit(g_strdup(name), G_DIR_SEPARATOR_S, '_');
596         newpath = g_strconcat(dirname, G_DIR_SEPARATOR_S, basenewpath, NULL);
597         g_free(basenewpath);
598
599         if( g_rename(oldpath, newpath) < 0 ) {
600                 FILE_OP_ERROR(oldpath, "rename");
601                 g_free(oldpath);
602                 g_free(newpath);
603                 return -1;
604         }
605
606         g_free(oldpath);
607         g_free(newpath);
608
609         if( strchr(item->path, G_DIR_SEPARATOR) != NULL ) {
610                 dirname = g_path_get_dirname(item->path);
611                 utf8newpath = g_strconcat(dirname, G_DIR_SEPARATOR_S, name, NULL);
612                 g_free(dirname);
613         } else
614                 utf8newpath = g_strdup(name);
615
616         g_free(item->name);
617         item->name = g_strdup(name);
618
619         paths[0] = g_strdup(item->path);
620         paths[1] = utf8newpath;
621         g_node_traverse(item->node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
622                         rssyl_rename_folder_func, paths);
623
624         g_free(paths[0]);
625         g_free(paths[1]);
626
627         return 0;
628 }
629
630 static gint rssyl_remove_folder(Folder *folder, FolderItem *item)
631 {
632         gchar *path = NULL;
633
634         g_return_val_if_fail(folder != NULL, -1);
635         g_return_val_if_fail(item != NULL, -1);
636         g_return_val_if_fail(item->path != NULL, -1);
637         g_return_val_if_fail(item->stype == F_NORMAL, -1);
638
639         debug_print("RSSyl: removing folder item %s\n", item->path);
640
641         path = folder_item_get_path(item);
642         if( remove_dir_recursive(path) < 0 ) {
643                 g_warning("can't remove directory '%s'\n", path);
644                 g_free(path);
645                 return -1;
646         }
647
648         g_free(path);
649         folder_item_remove(item);
650
651         return 0;
652 }
653
654 static gint rssyl_get_num_list(Folder *folder, FolderItem *item,
655                 MsgNumberList **list, gboolean *old_uids_valid)
656 {
657         gchar *path;
658         GDir *dp;
659         const gchar *d;
660         GError *error;
661         gint num, nummsgs = 0;
662
663         g_return_val_if_fail(item != NULL, -1);
664
665         debug_print("RSSyl: get_num_list: scanning '%s'\n", item->path);
666
667         *old_uids_valid = TRUE;
668         
669         path = folder_item_get_path(item);
670         g_return_val_if_fail(path != NULL, -1);
671
672         if( (dp = g_dir_open(path, 0, &error)) == NULL ) {
673                 FILE_OP_ERROR(item->path, "opendir");
674                 debug_print("g_dir_open() failed on \"%s\", error %d (%s).\n",
675                                 path, error->code, error->message);
676                 g_error_free(error);
677                 g_free(path);
678                 return -1;
679         }
680
681         g_free(path);
682
683         while( (d = g_dir_read_name(dp)) != NULL ) {
684                 if( (num = to_number(d)) > 0 ) {
685                         *list = g_slist_prepend(*list, GINT_TO_POINTER(num));
686                         nummsgs++;
687                 }
688         }
689         g_dir_close(dp);
690
691         debug_print("RSSyl: get_num_list: returning %d\n", nummsgs);
692
693         return nummsgs;
694 }
695
696 static gboolean rssyl_is_msg_changed(Folder *folder, FolderItem *item,
697                 MsgInfo *msginfo)
698 {
699         GStatBuf s;
700         gchar *path = NULL;
701
702         g_return_val_if_fail(folder != NULL, FALSE);
703         g_return_val_if_fail(item != NULL, FALSE);
704         g_return_val_if_fail(msginfo != NULL, FALSE);
705
706         path = g_strconcat(folder_item_get_path(item), G_DIR_SEPARATOR_S,
707                         itos(msginfo->msgnum), NULL);
708
709         if (g_stat(path, &s) < 0 ||
710                 msginfo->size != s.st_size || (
711                                 (msginfo->mtime - s.st_mtime != 0) &&
712                                 (msginfo->mtime - s.st_mtime != 3600) &&
713                                 (msginfo->mtime - s.st_mtime != -3600))) {
714                 g_free(path);
715                 return TRUE;
716         }
717
718         g_free(path);
719         return FALSE;
720 }
721
722 static gchar *rssyl_fetch_msg(Folder *folder, FolderItem *item, gint num)
723 {
724         gchar *path;
725         gchar *file;
726
727         g_return_val_if_fail(item != NULL, NULL);
728         g_return_val_if_fail(num > 0, NULL);
729
730         path = folder_item_get_path(item);
731         file = g_strconcat(path, G_DIR_SEPARATOR_S, itos(num), NULL);
732         g_free(path);
733
734         debug_print("RSSyl: fetch_msg '%s'\n", file);
735
736         if( !is_file_exist(file)) {
737                 g_free(file);
738                 return NULL;
739         }
740
741         return file;
742 }
743
744 static MsgInfo *rssyl_get_msginfo(Folder *folder, FolderItem *item, gint num)
745 {
746         MsgInfo *msginfo = NULL;
747         gchar *file;
748         MsgFlags flags;
749
750         g_return_val_if_fail(folder != NULL, NULL);
751         g_return_val_if_fail(item != NULL, NULL);
752         g_return_val_if_fail(num > 0, NULL);
753
754         debug_print("RSSyl: get_msginfo: %d\n", num);
755
756         file = rssyl_fetch_msg(folder, item, num);
757         g_return_val_if_fail(file != NULL, NULL);
758
759         flags.perm_flags = 0;
760         flags.tmp_flags = 0;
761
762         msginfo = rssyl_feed_parse_item_to_msginfo(file, flags, TRUE, TRUE, item);
763         g_free(file);
764
765         if( msginfo )
766                 msginfo->msgnum = num;
767
768         return msginfo;
769 }
770
771 static gint rssyl_add_msgs(Folder *folder, FolderItem *dest, GSList *file_list,
772                 GHashTable *relation)
773 {
774         gchar *destfile;
775         GSList *cur;
776         MsgFileInfo *fileinfo;
777
778         g_return_val_if_fail(dest != NULL, -1);
779         g_return_val_if_fail(file_list != NULL, -1);
780
781         if( dest->last_num < 0 ) {
782                 rssyl_get_last_num(folder, dest);
783                 if( dest->last_num < 0 ) return -1;
784         }
785
786         for( cur = file_list; cur != NULL; cur = cur->next ) {
787                 fileinfo = (MsgFileInfo *)cur->data;
788
789                 destfile = rssyl_get_new_msg_filename(dest);
790                 g_return_val_if_fail(destfile != NULL, -1);
791                 debug_print("RSSyl: add_msgs: new filename is '%s'\n", destfile);
792
793                 if( copy_file(fileinfo->file, destfile, TRUE) < 0 ) {
794                         g_warning("can't copy message %s to %s\n", fileinfo->file, destfile);
795                         g_free(destfile);
796                         return -1;
797                 }
798
799                 if( relation != NULL )
800                         g_hash_table_insert(relation, fileinfo->msginfo != NULL ?
801                                         (gpointer) fileinfo->msginfo : (gpointer) fileinfo,
802                                         GINT_TO_POINTER(dest->last_num + 1));
803                 g_free(destfile);
804                 dest->last_num++;
805         }
806
807
808         return dest->last_num;
809 }
810
811 static gint rssyl_add_msg(Folder *folder, FolderItem *dest, const gchar *file,
812                 MsgFlags *flags)
813 {
814         GSList file_list;
815         MsgFileInfo fileinfo;
816
817         g_return_val_if_fail(file != NULL, -1);
818
819         fileinfo.msginfo = NULL;
820         fileinfo.file = (gchar *)file;
821         fileinfo.flags = flags;
822         file_list.data = &fileinfo;
823         file_list.next = NULL;
824
825         return rssyl_add_msgs(folder, dest, &file_list, NULL);
826 }
827
828 static gint rssyl_remove_msg(Folder *folder, FolderItem *item, gint num)
829 {
830         gboolean need_scan = FALSE;
831         gchar *file, *tmp;
832
833         g_return_val_if_fail(item != NULL, -1);
834
835         file = rssyl_fetch_msg(folder, item, num);
836         g_return_val_if_fail(file != NULL, -1);
837
838         need_scan = mh_get_class()->scan_required(folder, item);
839
840         /* are we doing a folder move ? */
841         tmp = g_strdup_printf("%s.tmp", file);
842         if (is_file_exist(tmp)) {
843                 g_unlink(tmp);
844                 g_free(tmp);
845                 g_free(file);
846                 return 0;
847         }
848         g_free(tmp);
849
850         rssyl_deleted_add((RFolderItem *)item, file);
851
852         if( g_unlink(file) < 0 ) {
853                 FILE_OP_ERROR(file, "unlink");
854                 g_free(file);
855                 return -1;
856         }
857
858         if( !need_scan )
859                 item->mtime = time(NULL);
860
861         g_free(file);
862         return 0;
863 }
864
865 static gboolean rssyl_subscribe_uri(Folder *folder, const gchar *uri)
866 {
867         if (folder->klass != rssyl_folder_get_class())
868                 return FALSE;
869         return (rssyl_feed_subscribe_new(FOLDER_ITEM(folder->node->data), uri, FALSE) ?
870                         TRUE : FALSE);
871 }
872
873 static void rssyl_copy_private_data(Folder *folder, FolderItem *oldi,
874                 FolderItem *newi)
875 {
876         gchar *dpathold, *dpathnew;
877         RFolderItem *olditem = (RFolderItem *)oldi,
878                                                                         *newitem = (RFolderItem *)newi;
879
880         g_return_if_fail(folder != NULL);
881         g_return_if_fail(olditem != NULL);
882         g_return_if_fail(newitem != NULL);
883
884         if (olditem->url != NULL) {
885                 g_free(newitem->url);
886                 newitem->url = g_strdup(olditem->url);
887         }
888
889         if (olditem->auth != NULL) {
890                 if (newitem->auth != NULL) {
891                         if (newitem->auth->username != NULL) {
892                                 g_free(newitem->auth->username);
893                                 newitem->auth->username = NULL;
894                         }
895                         if (newitem->auth->password != NULL) {
896                                 g_free(newitem->auth->password);
897                                 newitem->auth->password = NULL;
898                         }
899                         g_free(newitem->auth);
900                 }
901                 newitem->auth = g_new0(FeedAuth, 1);
902                 newitem->auth->type = olditem->auth->type;
903                 if (olditem->auth->username != NULL)
904                         newitem->auth->username = g_strdup(olditem->auth->username);
905                 if (olditem->auth->password != NULL)
906                         newitem->auth->password = g_strdup(olditem->auth->password);
907         }
908
909         if (olditem->official_title != NULL) {
910                 g_free(newitem->official_title);
911                 newitem->official_title = g_strdup(olditem->official_title);
912         }
913
914         if (olditem->source_id != NULL) {
915                 g_free(newitem->source_id);
916                 newitem->source_id = g_strdup(olditem->source_id);
917         }
918
919         newitem->keep_old = olditem->keep_old;
920         newitem->default_refresh_interval = olditem->default_refresh_interval;
921         newitem->refresh_interval = olditem->refresh_interval;
922         newitem->fetch_comments = olditem->fetch_comments;
923         newitem->fetch_comments_max_age = olditem->fetch_comments_max_age;
924         newitem->silent_update = olditem->silent_update;
925         newitem->write_heading = olditem->write_heading;
926         newitem->ignore_title_rename = olditem->ignore_title_rename;
927         newitem->ssl_verify_peer = olditem->ssl_verify_peer;
928         newitem->refresh_id = olditem->refresh_id;
929         newitem->fetching_comments = olditem->fetching_comments;
930         newitem->last_update = olditem->last_update;
931
932         dpathold = g_strconcat(rssyl_item_get_path(oldi->folder, oldi),
933                         G_DIR_SEPARATOR_S, RSSYL_DELETED_FILE, NULL);
934         dpathnew = g_strconcat(rssyl_item_get_path(newi->folder, newi),
935                         G_DIR_SEPARATOR_S, RSSYL_DELETED_FILE, NULL);
936         move_file(dpathold, dpathnew, TRUE);
937         g_free(dpathold);
938         g_free(dpathnew);
939
940 }
941
942 /************************************************************************/
943
944 FolderClass *rssyl_folder_get_class()
945 {
946         if( rssyl_class.idstr == NULL ) {
947                 rssyl_class.type = F_UNKNOWN;
948                 rssyl_class.idstr = "rssyl";
949                 rssyl_class.uistr = "RSSyl";
950
951                 /* Folder functions */
952                 rssyl_class.new_folder = rssyl_new_folder;
953                 rssyl_class.destroy_folder = rssyl_destroy_folder;
954                 rssyl_class.set_xml = folder_set_xml;
955                 rssyl_class.get_xml = folder_get_xml;
956                 rssyl_class.scan_tree = rssyl_scan_tree;
957                 rssyl_class.create_tree = rssyl_create_tree;
958
959                 /* FolderItem functions */
960                 rssyl_class.item_new = rssyl_item_new;
961                 rssyl_class.item_destroy = rssyl_item_destroy;
962                 rssyl_class.item_get_path = rssyl_item_get_path;
963                 rssyl_class.create_folder = rssyl_create_folder;
964                 rssyl_class.rename_folder = rssyl_rename_folder;
965                 rssyl_class.remove_folder = rssyl_remove_folder;
966                 rssyl_class.get_num_list = rssyl_get_num_list;
967                 rssyl_class.scan_required = mh_get_class()->scan_required;
968                 rssyl_class.item_set_xml = rssyl_item_set_xml;
969                 rssyl_class.item_get_xml = rssyl_item_get_xml;
970
971                 /* Message functions */
972                 rssyl_class.get_msginfo = rssyl_get_msginfo;
973                 rssyl_class.fetch_msg = rssyl_fetch_msg;
974                 rssyl_class.copy_msg = mh_get_class()->copy_msg;
975                 rssyl_class.copy_msgs = mh_get_class()->copy_msgs;
976                 rssyl_class.add_msg = rssyl_add_msg;
977                 rssyl_class.add_msgs = rssyl_add_msgs;
978                 rssyl_class.remove_msg = rssyl_remove_msg;
979                 rssyl_class.remove_msgs = NULL;
980                 rssyl_class.is_msg_changed = rssyl_is_msg_changed;
981 //              rssyl_class.change_flags = rssyl_change_flags;
982                 rssyl_class.change_flags = NULL;
983                 rssyl_class.subscribe = rssyl_subscribe_uri;
984                 rssyl_class.copy_private_data = rssyl_copy_private_data;
985                 rssyl_class.search_msgs = folder_item_search_msgs_local;
986         }
987
988         return &rssyl_class;
989 }