2007-11-16 [colin] 3.0.2cvs140
[claws.git] / src / main.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2007 Hiroyuki Yamamoto and the Claws Mail 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 3 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, see <http://www.gnu.org/licenses/>.
17  * 
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 <glib/gi18n.h>
28 #include <gtk/gtkmain.h>
29 #include <gtk/gtkrc.h>
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <ctype.h>
35 #include <unistd.h>
36 #include <time.h>
37 #include <sys/stat.h>
38 #include <sys/types.h>
39 #ifdef G_OS_UNIX
40 #  include <signal.h>
41 #endif
42 #ifdef HAVE_LIBSM
43 #include <X11/SM/SMlib.h>
44 #include <fcntl.h>
45 #endif
46
47 #include "wizard.h"
48 #ifdef HAVE_STARTUP_NOTIFICATION
49 # define SN_API_NOT_YET_FROZEN
50 # include <libsn/sn-launchee.h>
51 # include <gdk/gdkx.h>
52 #endif
53
54 #include "claws.h"
55 #include "main.h"
56 #include "mainwindow.h"
57 #include "folderview.h"
58 #include "image_viewer.h"
59 #include "summaryview.h"
60 #include "prefs_common.h"
61 #include "prefs_account.h"
62 #include "prefs_actions.h"
63 #include "prefs_ext_prog.h"
64 #include "prefs_fonts.h"
65 #include "prefs_image_viewer.h"
66 #include "prefs_message.h"
67 #include "prefs_receive.h"
68 #include "prefs_msg_colors.h"
69 #include "prefs_quote.h"
70 #include "prefs_spelling.h"
71 #include "prefs_summaries.h"
72 #include "prefs_themes.h"
73 #include "prefs_other.h"
74 #include "prefs_logging.h"
75 #include "prefs_send.h"
76 #include "prefs_wrapping.h"
77 #include "prefs_compose_writing.h"
78 #include "prefs_display_header.h"
79 #include "account.h"
80 #include "procmsg.h"
81 #include "inc.h"
82 #include "import.h"
83 #include "manage_window.h"
84 #include "alertpanel.h"
85 #include "statusbar.h"
86 #include "addressbook.h"
87 #include "compose.h"
88 #include "folder.h"
89 #include "setup.h"
90 #include "utils.h"
91 #include "gtkutils.h"
92 #include "socket.h"
93 #include "log.h"
94 #include "prefs_toolbar.h"
95 #include "plugin.h"
96 #include "mh_gtk.h"
97 #include "imap_gtk.h"
98 #include "news_gtk.h"
99 #include "matcher.h"
100 #include "tags.h"
101 #ifdef HAVE_LIBETPAN
102 #include "imap-thread.h"
103 #include "nntp-thread.h"
104 #endif
105 #include "stock_pixmap.h"
106 #ifdef HAVE_VALGRIND
107 #include "valgrind.h"
108 #endif
109 #if (defined(USE_OPENSSL) || defined (USE_GNUTLS))
110 #  include "ssl.h"
111 #endif
112
113 #include "version.h"
114
115 #include "crash.h"
116
117 #include "timing.h"
118
119 #ifdef MAEMO
120 #ifdef CHINOOK
121 #include <hildon/hildon-banner.h>
122 #include <hildon/hildon-program.h>
123 #else
124 #include <hildon-widgets/hildon-banner.h>
125 #include <hildon-widgets/hildon-program.h>
126 #endif
127 #include <gtk/gtkmain.h>
128 #include <libosso.h>
129 #include <libgnomevfs/gnome-vfs-volume.h>
130 #include <libgnomevfs/gnome-vfs-volume-monitor.h>
131 #include <libgnomevfs/gnome-vfs-utils.h>
132
133 #define OSSO_NAME    "claws_mail"
134 #define OSSO_SERVICE "com.nokia."OSSO_NAME
135 #define OSSO_OBJECT  "/com/nokia/"OSSO_NAME
136 #define OSSO_IFACE   "com.nokia."OSSO_NAME
137
138 typedef struct _AppData AppData;
139 struct _AppData {
140     HildonProgram *program;
141     HildonWindow *window;
142     osso_context_t *osso_context;
143 };
144
145 static GnomeVFSVolumeMonitor *volmon;
146 #endif
147
148 gchar *prog_version;
149 gchar *argv0;
150
151 #ifdef MAEMO
152 HildonProgram *hildon_program;
153 #endif
154
155 #ifdef HAVE_STARTUP_NOTIFICATION
156 static SnLauncheeContext *sn_context = NULL;
157 static SnDisplay *sn_display = NULL;
158 #endif
159
160 static gint lock_socket = -1;
161 static gint lock_socket_tag = 0;
162 static gchar *x_display = NULL;
163 typedef enum 
164 {
165         ONLINE_MODE_DONT_CHANGE,
166         ONLINE_MODE_ONLINE,
167         ONLINE_MODE_OFFLINE
168 } OnlineMode;
169
170 static struct RemoteCmd {
171         gboolean receive;
172         gboolean receive_all;
173         gboolean compose;
174         const gchar *compose_mailto;
175         GPtrArray *attach_files;
176         gboolean status;
177         gboolean status_full;
178         GPtrArray *status_folders;
179         GPtrArray *status_full_folders;
180         gboolean send;
181         gboolean crash;
182         int online_mode;
183         gchar   *crash_params;
184         gboolean exit;
185         gboolean subscribe;
186         const gchar *subscribe_uri;
187         const gchar *target;
188 } cmd;
189
190 static void parse_cmd_opt(int argc, char *argv[]);
191
192 static gint prohibit_duplicate_launch   (void);
193 static gchar * get_crashfile_name       (void);
194 static gint lock_socket_remove          (void);
195 static void lock_socket_input_cb        (gpointer          data,
196                                          gint              source,
197                                          GdkInputCondition condition);
198
199 static void open_compose_new            (const gchar    *address,
200                                          GPtrArray      *attach_files);
201
202 static void send_queue                  (void);
203 static void initial_processing          (FolderItem *item, gpointer data);
204 static void quit_signal_handler         (int sig);
205 static void install_basic_sighandlers   (void);
206 static void exit_claws                  (MainWindow *mainwin);
207
208 #define MAKE_DIR_IF_NOT_EXIST(dir) \
209 { \
210         if (!is_dir_exist(dir)) { \
211                 if (is_file_exist(dir)) { \
212                         alertpanel_warning \
213                                 (_("File '%s' already exists.\n" \
214                                    "Can't create folder."), \
215                                  dir); \
216                         return 1; \
217                 } \
218                 if (make_dir(dir) < 0) \
219                         return 1; \
220         } \
221 }
222
223 static MainWindow *static_mainwindow;
224
225 #ifdef MAEMO
226 static osso_context_t *static_osso_context;
227
228 void exit_event_handler(gboolean die_now, gpointer data)
229 {
230         AppData *appdata;
231         appdata = (AppData *) data;
232         /* Do whatever application needs to do before exiting */
233         exit_claws(static_mainwindow);
234         hildon_banner_show_information(GTK_WIDGET(appdata->window), NULL,
235                                    _("Exiting..."));
236
237 }
238
239 /* Callback for normal D-BUS messages */
240 gint dbus_req_handler(const gchar * interface, const gchar * method,
241                       GArray * arguments, gpointer data,
242                       osso_rpc_t * retval)
243 {
244     AppData *appdata;
245     appdata = (AppData *) data;
246
247     if (!strcmp(method, "top_application")) {
248             osso_rpc_free_val(retval);
249             return OSSO_OK;
250     }
251     osso_system_note_infoprint(appdata->osso_context, method, retval);
252     osso_rpc_free_val(retval);
253
254     return OSSO_OK;
255 }
256 #endif
257 static gboolean emergency_exit = FALSE;
258
259 #ifdef HAVE_STARTUP_NOTIFICATION
260 static void sn_error_trap_push(SnDisplay *display, Display *xdisplay)
261 {
262         gdk_error_trap_push();
263 }
264
265 static void sn_error_trap_pop(SnDisplay *display, Display *xdisplay)
266 {
267         gdk_error_trap_pop();
268 }
269
270 static void startup_notification_complete(gboolean with_window)
271 {
272         Display *xdisplay;
273         GtkWidget *hack = NULL;
274
275         if (with_window) {
276                 /* this is needed to make the startup notification leave,
277                  * if we have been launched from a menu.
278                  * We have to display a window, so let it be very little */
279                 hack = gtk_window_new(GTK_WINDOW_POPUP);
280                 gtk_widget_set_uposition(hack, 0, 0);
281                 gtk_widget_set_size_request(hack, 1, 1);
282                 gtk_widget_show(hack);
283         }
284
285         xdisplay = GDK_DISPLAY();
286         sn_display = sn_display_new(xdisplay,
287                                 sn_error_trap_push,
288                                 sn_error_trap_pop);
289         sn_context = sn_launchee_context_new_from_environment(sn_display,
290                                                  DefaultScreen(xdisplay));
291
292         if (sn_context != NULL) {
293                 sn_launchee_context_complete(sn_context);
294                 sn_launchee_context_unref(sn_context);
295                 sn_display_unref(sn_display);
296         }
297         if (with_window) {
298                 gtk_widget_destroy(hack);
299         }
300 }
301 #endif /* HAVE_STARTUP_NOTIFICATION */
302
303 static void claws_gtk_idle(void) 
304 {
305         while(gtk_events_pending()) {
306                 gtk_main_iteration();
307         }
308         g_usleep(50000);
309 }
310
311 static gboolean sc_starting = FALSE;
312
313 static gboolean defer_check_all(void *data)
314 {
315         gboolean autochk = GPOINTER_TO_INT(data);
316
317         inc_all_account_mail(static_mainwindow, autochk, 
318                         prefs_common.newmail_notify_manu);
319
320         if (sc_starting) {
321                 sc_starting = FALSE;
322                 main_window_set_menu_sensitive(static_mainwindow);
323                 toolbar_main_set_sensitive(static_mainwindow);
324         }
325         return FALSE;
326 }
327
328 static gboolean defer_check(void *data)
329 {
330         inc_mail(static_mainwindow, prefs_common.newmail_notify_manu);
331
332         if (sc_starting) {
333                 sc_starting = FALSE;
334                 main_window_set_menu_sensitive(static_mainwindow);
335                 toolbar_main_set_sensitive(static_mainwindow);
336         }
337         return FALSE;
338 }
339
340 static gboolean defer_jump(void *data)
341 {
342         if (cmd.receive_all) {
343                 defer_check_all(GINT_TO_POINTER(FALSE));
344         } else if (prefs_common.chk_on_startup) {
345                 defer_check_all(GINT_TO_POINTER(TRUE));
346         } else if (cmd.receive) {
347                 defer_check(NULL);
348         } 
349         mainwindow_jump_to(data, FALSE);
350         if (sc_starting) {
351                 sc_starting = FALSE;
352                 main_window_set_menu_sensitive(static_mainwindow);
353                 toolbar_main_set_sensitive(static_mainwindow);
354         }
355         return FALSE;
356 }
357
358 static void chk_update_val(GtkWidget *widget, gpointer data)
359 {
360         gboolean *val = (gboolean *)data;
361         *val = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
362 }
363
364 static gboolean migrate_old_config(const gchar *old_cfg_dir, const gchar *new_cfg_dir, const gchar *oldversion)
365 {
366         gchar *message = g_strdup_printf(_("Configuration for %s found.\n"
367                          "Do you want to migrate this configuration?"), oldversion);
368         gchar *message2 = g_strdup_printf(_("\n\nYour Sylpheed filtering rules can be converted by a\n"
369                              "script available at %s."), TOOLS_URI);
370
371         if (!strcmp(oldversion, "Sylpheed"))
372                 message = g_strconcat(message, message2, NULL);
373         g_free(message2);
374
375         gint r = 0;
376         GtkWidget *window = NULL;
377         GtkWidget *keep_backup_chk;
378         GtkTooltips *tips = gtk_tooltips_new();
379         gboolean backup = TRUE;
380
381         keep_backup_chk = gtk_check_button_new_with_label (_("Keep old configuration"));
382         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keep_backup_chk), TRUE);
383         gtk_tooltips_set_tip(GTK_TOOLTIPS(tips), keep_backup_chk,
384                              _("Keeping a backup will allow you to go back to an "
385                                "older version, but may take a while if you have "
386                                "cached IMAP or News data, and will take some extra "
387                                "room on your disk."),
388                              NULL);
389
390         g_signal_connect(G_OBJECT(keep_backup_chk), "toggled", 
391                         G_CALLBACK(chk_update_val), &backup);
392
393         if (alertpanel_full(_("Migration of configuration"), message,
394                         GTK_STOCK_NO, "+" GTK_STOCK_YES, NULL, FALSE,
395                         keep_backup_chk, ALERT_QUESTION, G_ALERTDEFAULT) != G_ALERTALTERNATE) {
396                 return FALSE;
397         }
398         
399         /* we can either do a fast migration requiring not any extra disk
400          * space, or a slow one that copies the old configuration and leaves
401          * it in place. */
402         if (backup) {
403 backup_mode:
404                 window = label_window_create(_("Copying configuration... This may take a while..."));
405                 GTK_EVENTS_FLUSH();
406                 
407                 r = copy_dir(old_cfg_dir, new_cfg_dir);
408                 label_window_destroy(window);
409                 
410                 /* if copy failed, we'll remove the partially copied
411                  * new directory */
412                 if (r != 0) {
413                         alertpanel_error(_("Migration failed!"));
414                         remove_dir_recursive(new_cfg_dir);
415                 } else {
416                         if (!backup) {
417                                 /* fast mode failed, but we don't want backup */
418                                 remove_dir_recursive(old_cfg_dir);
419                         }
420                 }
421         } else {
422                 window = label_window_create(_("Migrating configuration..."));
423                 GTK_EVENTS_FLUSH();
424                 
425                 r = g_rename(old_cfg_dir, new_cfg_dir);
426                 label_window_destroy(window);
427                 
428                 /* if g_rename failed, we'll try to copy */
429                 if (r != 0) {
430                         FILE_OP_ERROR(new_cfg_dir, "g_rename failed, trying copy\n");
431                         goto backup_mode;
432                 }
433         }
434         return (r == 0);
435 }
436
437 static int migrate_common_rc(const gchar *old_rc, const gchar *new_rc)
438 {
439         FILE *oldfp, *newfp;
440         gchar *plugin_path, *old_plugin_path, *new_plugin_path;
441         gchar buf[BUFFSIZE];
442         gboolean err = FALSE;
443
444         oldfp = g_fopen(old_rc, "r");
445         if (!oldfp)
446                 return -1;
447         newfp = g_fopen(new_rc, "w");
448         if (!newfp) {
449                 fclose(oldfp);
450                 return -1;
451         }
452         
453         plugin_path = g_strdup(get_plugin_dir());
454         new_plugin_path = g_strdup(plugin_path);
455         
456         if (strstr(plugin_path, "/claws-mail/")) {
457                 gchar *end = g_strdup(strstr(plugin_path, "/claws-mail/")+strlen("/claws-mail/"));
458                 *(strstr(plugin_path, "/claws-mail/")) = '\0';
459                 old_plugin_path = g_strconcat(plugin_path, "/sylpheed-claws/", end, NULL);
460                 g_free(end);
461         } else {
462                 old_plugin_path = g_strdup(new_plugin_path);
463         }
464         debug_print("replacing %s with %s\n", old_plugin_path, new_plugin_path);
465         while (fgets(buf, sizeof(buf), oldfp)) {
466                 if (strncmp(buf, old_plugin_path, strlen(old_plugin_path))) {
467                         err |= (fputs(buf, newfp) == EOF);
468                 } else {
469                         debug_print("->replacing %s", buf);
470                         debug_print("  with %s%s", new_plugin_path, buf+strlen(old_plugin_path));
471                         err |= (fputs(new_plugin_path, newfp) == EOF);
472                         err |= (fputs(buf+strlen(old_plugin_path), newfp) == EOF);
473                 }
474         }
475         g_free(plugin_path);
476         g_free(new_plugin_path);
477         g_free(old_plugin_path);
478         fclose(oldfp);
479         if (fclose(newfp) == EOF)
480                 err = TRUE;
481         
482         return (err ? -1:0);
483 }
484
485 #ifdef HAVE_LIBSM
486 static void
487 sc_client_set_value (MainWindow *mainwin,
488                   gchar       *name,
489                   char        *type,
490                   int          num_vals,
491                   SmPropValue *vals)
492 {
493         SmProp *proplist[1];
494         SmProp prop;
495
496         prop.name = name;
497         prop.type = type;
498         prop.num_vals = num_vals;
499         prop.vals = vals;
500
501         proplist[0]= &prop;
502         if (mainwin->smc_conn)
503                 SmcSetProperties ((SmcConn) mainwin->smc_conn, 1, proplist);
504 }
505
506 static void sc_die_callback (SmcConn smc_conn, SmPointer client_data)
507 {
508         clean_quit(NULL);
509 }
510
511 static void sc_save_complete_callback(SmcConn smc_conn, SmPointer client_data)
512 {
513 }
514
515 static void sc_shutdown_cancelled_callback (SmcConn smc_conn, SmPointer client_data)
516 {
517         MainWindow *mainwin = (MainWindow *)client_data;
518         if (mainwin->smc_conn)
519                 SmcSaveYourselfDone ((SmcConn) mainwin->smc_conn, TRUE);
520 }
521
522 static void sc_save_yourself_callback (SmcConn   smc_conn,
523                                SmPointer client_data,
524                                int       save_style,
525                                gboolean  shutdown,
526                                int       interact_style,
527                                gboolean  fast) {
528
529         MainWindow *mainwin = (MainWindow *)client_data;
530         if (mainwin->smc_conn)
531                 SmcSaveYourselfDone ((SmcConn) mainwin->smc_conn, TRUE);
532 }
533
534 static IceIOErrorHandler sc_ice_installed_handler;
535
536 static void sc_ice_io_error_handler (IceConn connection)
537 {
538         if (sc_ice_installed_handler)
539                 (*sc_ice_installed_handler) (connection);
540 }
541 static gboolean sc_process_ice_messages (GIOChannel   *source,
542                       GIOCondition  condition,
543                       gpointer      data)
544 {
545         IceConn connection = (IceConn) data;
546         IceProcessMessagesStatus status;
547
548         status = IceProcessMessages (connection, NULL, NULL);
549
550         if (status == IceProcessMessagesIOError) {
551                 IcePointer context = IceGetConnectionContext (connection);
552
553                 if (context && GTK_IS_OBJECT (context)) {
554                 guint disconnect_id = g_signal_lookup ("disconnect", G_OBJECT_TYPE (context));
555
556                 if (disconnect_id > 0)
557                         g_signal_emit (context, disconnect_id, 0);
558                 } else {
559                         IceSetShutdownNegotiation (connection, False);
560                         IceCloseConnection (connection);
561                 }
562         }
563
564         return TRUE;
565 }
566
567 static void new_ice_connection (IceConn connection, IcePointer client_data, Bool opening,
568                     IcePointer *watch_data)
569 {
570         guint input_id;
571
572         if (opening) {
573                 GIOChannel *channel;
574                 /* Make sure we don't pass on these file descriptors to any
575                 exec'ed children */
576                 fcntl(IceConnectionNumber(connection),F_SETFD,
577                 fcntl(IceConnectionNumber(connection),F_GETFD,0) | FD_CLOEXEC);
578
579                 channel = g_io_channel_unix_new (IceConnectionNumber (connection));
580                 input_id = g_io_add_watch (channel,
581                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI,
582                 sc_process_ice_messages,
583                 connection);
584                 g_io_channel_unref (channel);
585
586                 *watch_data = (IcePointer) GUINT_TO_POINTER (input_id);
587         } else {
588                 input_id = GPOINTER_TO_UINT ((gpointer) *watch_data);
589                 g_source_remove (input_id);
590         }
591 }
592
593 static void sc_session_manager_connect(MainWindow *mainwin)
594 {
595         static gboolean connected = FALSE;
596         SmcCallbacks      callbacks;
597         gchar            *client_id;
598         IceIOErrorHandler default_handler;
599
600         if (connected)
601                 return;
602         connected = TRUE;
603
604
605         sc_ice_installed_handler = IceSetIOErrorHandler (NULL);
606         default_handler = IceSetIOErrorHandler (sc_ice_io_error_handler);
607
608         if (sc_ice_installed_handler == default_handler)
609                 sc_ice_installed_handler = NULL;
610
611         IceAddConnectionWatch (new_ice_connection, NULL);
612       
613       
614         callbacks.save_yourself.callback      = sc_save_yourself_callback;
615         callbacks.die.callback                = sc_die_callback;
616         callbacks.save_complete.callback      = sc_save_complete_callback;
617         callbacks.shutdown_cancelled.callback = sc_shutdown_cancelled_callback;
618
619         callbacks.save_yourself.client_data =
620                 callbacks.die.client_data =
621                 callbacks.save_complete.client_data =
622                 callbacks.shutdown_cancelled.client_data = (SmPointer) mainwin;
623         if (g_getenv ("SESSION_MANAGER")) {
624                 gchar error_string_ret[256] = "";
625
626                 mainwin->smc_conn = (gpointer)
627                         SmcOpenConnection (NULL, mainwin,
628                                 SmProtoMajor, SmProtoMinor,
629                                 SmcSaveYourselfProcMask | SmcDieProcMask |
630                                 SmcSaveCompleteProcMask |
631                                 SmcShutdownCancelledProcMask,
632                                 &callbacks,
633                                 NULL, &client_id,
634                                 256, error_string_ret);
635
636                 if (error_string_ret[0] || mainwin->smc_conn == NULL)
637                         g_warning ("While connecting to session manager:\n%s.",
638                                 error_string_ret);
639                 else {
640                         SmPropValue *vals;
641                         vals = g_new (SmPropValue, 1);
642                         vals[0].length = strlen(argv0);
643                         vals[0].value = argv0;
644                         sc_client_set_value (mainwin, SmCloneCommand, SmLISTofARRAY8, 1, vals);
645                         sc_client_set_value (mainwin, SmRestartCommand, SmLISTofARRAY8, 1, vals);
646                         sc_client_set_value (mainwin, SmProgram, SmARRAY8, 1, vals);
647
648                         vals[0].length = strlen(g_get_user_name()?g_get_user_name():"");
649                         vals[0].value = g_strdup(g_get_user_name()?g_get_user_name():"");
650                         sc_client_set_value (mainwin, SmUserID, SmARRAY8, 1, vals);
651                 }
652         }
653 }
654 #endif
655
656 static gboolean sc_exiting = FALSE;
657 static gboolean show_at_startup = TRUE;
658 static gboolean claws_crashed_bool = FALSE;
659
660 gboolean claws_crashed(void) {
661         return claws_crashed_bool;
662 }
663
664 void main_set_show_at_startup(gboolean show)
665 {
666         show_at_startup = show;
667 }
668
669 #ifdef MAEMO
670 static void main_vol_mount_cb(GnomeVFSVolumeMonitor *vfs, GnomeVFSVolume *vol, MainWindow *mainwin)
671 {
672         gchar *uri = gnome_vfs_volume_get_activation_uri (vol);
673         gchar *mount_path = uri?gnome_vfs_get_local_path_from_uri (uri):NULL;
674         g_free (uri);
675         if (mount_path) {
676                 if(!strcmp(mount_path, prefs_common.data_root)) {
677                         gtk_widget_set_sensitive(mainwin->window, TRUE);
678                         inc_unlock();
679                 }
680         }
681         g_free(mount_path);
682 }
683 static void main_vol_unmount_cb(GnomeVFSVolumeMonitor *vfs, GnomeVFSVolume *vol, MainWindow *mainwin)
684 {
685         gchar *uri = gnome_vfs_volume_get_activation_uri (vol);
686         gchar *mount_path = uri?gnome_vfs_get_local_path_from_uri (uri):NULL;
687         g_free (uri);
688         if (mount_path) {
689                 if(!strcmp(mount_path, prefs_common.data_root)) {
690                         gtk_widget_set_sensitive(mainwin->window, FALSE);
691                         inc_lock();
692                 }
693         }
694         g_free(mount_path);
695 }
696 #endif
697
698 #ifdef G_OS_WIN32
699 static FILE* win32_debug_fp=NULL;
700 static guint win32_log_handler_app_id;
701 static guint win32_log_handler_glib_id;
702 static guint win32_log_handler_gtk_id;
703
704 static void win32_print_stdout(const gchar *string)
705 {
706         if (win32_debug_fp) {
707                 fprintf(win32_debug_fp, string);
708                 fflush(win32_debug_fp);
709         }
710 }
711
712 static void win32_print_stderr(const gchar *string)
713 {
714         if (win32_debug_fp) {
715                 fprintf(win32_debug_fp, string);
716                 fflush(win32_debug_fp);
717         }
718 }
719
720 static void win32_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar* message, gpointer user_data)
721 {
722         if (win32_debug_fp) {
723                 const gchar* type;
724
725                 switch(log_level & G_LOG_LEVEL_MASK)
726                 {
727                         case G_LOG_LEVEL_ERROR:
728                                 type="error";
729                                 break;
730                         case G_LOG_LEVEL_CRITICAL:
731                                 type="critical";
732                                 break;
733                         case G_LOG_LEVEL_WARNING:
734                                 type="warning";
735                                 break;
736                         case G_LOG_LEVEL_MESSAGE:
737                                 type="message";
738                                 break;
739                         case G_LOG_LEVEL_INFO:
740                                 type="info";
741                                 break;
742                         case G_LOG_LEVEL_DEBUG:
743                                 type="debug";
744                                 break;
745                         default:
746                                 type="N/A";
747                 }
748                 if (log_domain)
749                         fprintf(win32_debug_fp, "%s: %s: %s", log_domain, type, message);
750                 else
751                         fprintf(win32_debug_fp, "%s: %s", type, message);
752                 fflush(win32_debug_fp);
753         }
754 }
755
756 static void win32_open_log(void)
757 {
758         if (is_file_exist("claws-win32.log")) {
759                 if (rename_force("claws-win32.log", "claws-win32.log.bak") < 0)
760                         FILE_OP_ERROR("claws-win32.log", "rename");
761         }
762         win32_debug_fp = fopen("claws-win32.log", "w");
763         if (win32_debug_fp)
764         {
765                 g_set_print_handler(win32_print_stdout);
766                 g_set_printerr_handler(win32_print_stdout);
767                 win32_log_handler_app_id = g_log_set_handler(NULL, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL
768                      | G_LOG_FLAG_RECURSION, win32_log, NULL);
769                 win32_log_handler_glib_id = g_log_set_handler("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL
770                      | G_LOG_FLAG_RECURSION, win32_log, NULL);
771                 win32_log_handler_gtk_id = g_log_set_handler("Gtk", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL
772                      | G_LOG_FLAG_RECURSION, win32_log, NULL);
773         }
774 }
775
776 static void win32_close_log(void)
777 {
778         if (win32_debug_fp)
779         {
780                 g_log_remove_handler("", win32_log_handler_app_id);
781                 g_log_remove_handler("GLib", win32_log_handler_glib_id);
782                 g_log_remove_handler("Gtk", win32_log_handler_gtk_id);
783                 fclose(win32_debug_fp);
784                 win32_debug_fp=NULL;
785         }
786 }               
787 #endif
788
789 int main(int argc, char *argv[])
790 {
791 #ifdef MAEMO
792         osso_context_t *osso_context;
793         osso_return_t result;
794 #endif
795         gchar *userrc;
796         MainWindow *mainwin;
797         FolderView *folderview;
798         GdkPixbuf *icon;
799         gboolean crash_file_present = FALSE;
800         gint num_folder_class = 0;
801         gboolean asked_for_migration = FALSE;
802         gboolean start_done = TRUE;
803
804         START_TIMING("startup");
805         
806         sc_starting = TRUE;
807
808 #ifdef G_OS_WIN32
809         win32_open_log();
810 #endif
811         if (!claws_init(&argc, &argv)) {
812 #ifdef G_OS_WIN32
813                 win32_close_log();
814 #endif
815                 return 0;
816         }
817
818         debug_print("GTK+ %d.%d.%d / GLib %d.%d.%d\n",
819                    gtk_major_version, gtk_minor_version, gtk_micro_version,
820                    glib_major_version, glib_minor_version, glib_micro_version);
821         debug_print("Compiled-in features:\n");
822 #if HAVE_LIBCOMPFACE
823         debug_print(" compface\n");
824 #endif
825 #if USE_ASPELL
826         debug_print(" aspell\n");
827 #endif
828 #if USE_GNUTLS
829         debug_print(" gnutls\n");
830 #endif
831 #if INET6
832         debug_print(" ipv6\n");
833 #endif
834 #if HAVE_ICONV
835         debug_print(" iconv\n");
836 #endif
837 #if USE_JPILOT
838         debug_print(" jpilot\n");
839 #endif
840 #if USE_LDAP
841         debug_print(" ldap\n");
842 #endif
843 #if HAVE_LIBETPAN
844         debug_print(" libetpan %d.%d\n", LIBETPAN_VERSION_MAJOR, LIBETPAN_VERSION_MINOR);
845 #endif
846 #if USE_GNOMEPRINT
847         debug_print(" gnomeprint\n");
848 #endif
849 #if HAVE_LIBSM
850         debug_print(" libsm\n");
851 #endif
852 #if USE_OPENSSL
853         debug_print(" openssl\n");
854 #endif
855
856         prog_version = PROG_VERSION;
857         argv0 = g_strdup(argv[0]);
858
859         parse_cmd_opt(argc, argv);
860
861         prefs_prepare_cache();
862
863 #ifdef CRASH_DIALOG
864         if (cmd.crash) {
865                 gtk_set_locale();
866                 gtk_init(&argc, &argv);
867                 crash_main(cmd.crash_params);
868 #ifdef G_OS_WIN32
869                 win32_close_log();
870 #endif
871                 return 0;
872         }
873         crash_install_handlers();
874 #endif
875         install_basic_sighandlers();
876         sock_init();
877
878         /* check and create unix domain socket for remote operation */
879 #ifdef G_OS_UNIX
880         lock_socket = prohibit_duplicate_launch();
881         if (lock_socket < 0) {
882 #ifdef HAVE_STARTUP_NOTIFICATION
883                 if(gtk_init_check(&argc, &argv))
884                         startup_notification_complete(TRUE);
885 #endif
886                 return 0;
887         }
888
889         if (cmd.status || cmd.status_full) {
890                 puts("0 Claws Mail not running.");
891                 lock_socket_remove();
892                 return 0;
893         }
894         
895         if (cmd.exit)
896                 return 0;
897 #endif
898         if (!g_thread_supported())
899                 g_thread_init(NULL);
900
901         gtk_set_locale();
902         gtk_init(&argc, &argv);
903
904 #ifdef MAEMO
905         osso_context = osso_initialize(OSSO_SERVICE, "2.8.1", TRUE, NULL);
906         if (osso_context == NULL) {
907                 return OSSO_ERROR;
908         }
909         hildon_program = HILDON_PROGRAM(hildon_program_get_instance());
910         static_osso_context = osso_context;
911 #endif  
912         gdk_rgb_init();
913         gtk_widget_set_default_colormap(gdk_rgb_get_colormap());
914         gtk_widget_set_default_visual(gdk_rgb_get_visual());
915
916         if (!g_thread_supported()) {
917                 g_error(_("g_thread is not supported by glib.\n"));
918         }
919
920         /* check that we're not on a too recent/old gtk+ */
921 #if GTK_CHECK_VERSION(2, 9, 0)
922         if (gtk_check_version(2, 9, 0) != NULL) {
923                 alertpanel_error(_("Claws Mail has been compiled with "
924                                    "a more recent GTK+ library than is "
925                                    "currently available. This will cause "
926                                    "crashes. You need to upgrade GTK+ or "
927                                    "recompile Claws Mail."));
928 #ifdef G_OS_WIN32
929                 win32_close_log();
930 #endif
931                 exit(1);
932         }
933 #else
934         if (gtk_check_version(2, 9, 0) == NULL) {
935                 alertpanel_error(_("Claws Mail has been compiled with "
936                                    "an older GTK+ library than is "
937                                    "currently available. This will cause "
938                                    "crashes. You need to recompile "
939                                    "Claws Mail."));
940 #ifdef G_OS_WIN32
941                 win32_close_log();
942 #endif
943                 exit(1);
944         }
945 #endif  
946         /* parse gtkrc files */
947         userrc = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S, ".gtkrc-2.0",
948                              NULL);
949         gtk_rc_parse(userrc);
950         g_free(userrc);
951         userrc = g_strconcat(get_home_dir(), G_DIR_SEPARATOR_S, ".gtk",
952                              G_DIR_SEPARATOR_S, "gtkrc-2.0", NULL);
953         gtk_rc_parse(userrc);
954         g_free(userrc);
955
956 #ifdef G_OS_WIN32
957         CHDIR_EXEC_CODE_RETURN_VAL_IF_FAIL(get_home_dir(), 1, win32_close_log(););
958 #else
959         CHDIR_RETURN_VAL_IF_FAIL(get_home_dir(), 1);
960 #endif
961         
962         /* no config dir exists. See if we can migrate an old config. */
963         if (!is_dir_exist(RC_DIR)) {
964                 prefs_destroy_cache();
965                 gboolean r = FALSE;
966                 
967                 /* if one of the old dirs exist, we'll ask if the user 
968                  * want to migrates, and r will be TRUE if he said yes
969                  * and migration succeeded, and FALSE otherwise.
970                  */
971                 if (is_dir_exist(OLD_GTK2_RC_DIR)) {
972                         r = migrate_old_config(OLD_GTK2_RC_DIR, RC_DIR, _("Sylpheed-Claws 2.6.0 (or older)"));
973                         asked_for_migration = TRUE;
974                 } else if (is_dir_exist(OLDER_GTK2_RC_DIR)) {
975                         r = migrate_old_config(OLDER_GTK2_RC_DIR, RC_DIR, _("Sylpheed-Claws 1.9.15 (or older)"));
976                         asked_for_migration = TRUE;
977                 } else if (is_dir_exist(OLD_GTK1_RC_DIR)) {
978                         r = migrate_old_config(OLD_GTK1_RC_DIR, RC_DIR, _("Sylpheed-Claws 1.0.5 (or older)"));
979                         asked_for_migration = TRUE;
980                 } else if (is_dir_exist(SYLPHEED_RC_DIR)) {
981                         r = migrate_old_config(SYLPHEED_RC_DIR, RC_DIR, "Sylpheed");
982                         asked_for_migration = TRUE;
983                 }
984                 
985                 /* If migration failed or the user didn't want to do it,
986                  * we create a new one (and we'll hit wizard later). 
987                  */
988                 if (r == FALSE && !is_dir_exist(RC_DIR) && make_dir(RC_DIR) < 0) {
989 #ifdef G_OS_WIN32
990                         win32_close_log();
991 #endif
992                         exit(1);
993         }
994         }
995         
996
997         if (!is_file_exist(RC_DIR G_DIR_SEPARATOR_S COMMON_RC) &&
998             is_file_exist(RC_DIR G_DIR_SEPARATOR_S OLD_COMMON_RC)) {
999                 /* post 2.6 name change */
1000                 migrate_common_rc(RC_DIR G_DIR_SEPARATOR_S OLD_COMMON_RC,
1001                           RC_DIR G_DIR_SEPARATOR_S COMMON_RC);
1002         }
1003
1004         if (!cmd.exit)
1005                 plugin_load_all("Common");
1006
1007         userrc = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "gtkrc-2.0", NULL);
1008         gtk_rc_parse(userrc);
1009         g_free(userrc);
1010
1011         userrc = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MENU_RC, NULL);
1012         gtk_accel_map_load (userrc);
1013         g_free(userrc);
1014
1015 #ifdef G_OS_WIN32
1016         CHDIR_EXEC_CODE_RETURN_VAL_IF_FAIL(get_rc_dir(), 1, win32_close_log(););
1017 #else
1018         CHDIR_RETURN_VAL_IF_FAIL(get_rc_dir(), 1);
1019 #endif
1020
1021         MAKE_DIR_IF_NOT_EXIST(get_mail_base_dir());
1022         MAKE_DIR_IF_NOT_EXIST(get_imap_cache_dir());
1023         MAKE_DIR_IF_NOT_EXIST(get_news_cache_dir());
1024         MAKE_DIR_IF_NOT_EXIST(get_mime_tmp_dir());
1025         MAKE_DIR_IF_NOT_EXIST(get_tmp_dir());
1026         MAKE_DIR_IF_NOT_EXIST(UIDL_DIR);
1027
1028         crash_file_present = is_file_exist(get_crashfile_name());
1029         /* remove temporary files */
1030         remove_all_files(get_tmp_dir());
1031         remove_all_files(get_mime_tmp_dir());
1032
1033         if (!cmd.crash && crash_file_present)
1034                 claws_crashed_bool = TRUE;
1035
1036         if (is_file_exist("claws.log")) {
1037                 if (rename_force("claws.log", "claws.log.bak") < 0)
1038                         FILE_OP_ERROR("claws.log", "rename");
1039         }
1040         set_log_file(LOG_PROTOCOL, "claws.log");
1041
1042         if (is_file_exist("filtering.log")) {
1043                 if (rename_force("filtering.log", "filtering.log.bak") < 0)
1044                         FILE_OP_ERROR("filtering.log", "rename");
1045         }
1046         set_log_file(LOG_DEBUG_FILTERING, "filtering.log");
1047
1048 #ifdef G_OS_WIN32
1049         CHDIR_EXEC_CODE_RETURN_VAL_IF_FAIL(get_home_dir(), 1, win32_close_log(););
1050 #else
1051         CHDIR_RETURN_VAL_IF_FAIL(get_home_dir(), 1);
1052 #endif
1053
1054         folder_system_init();
1055         prefs_common_read_config();
1056
1057         prefs_themes_init();
1058         prefs_fonts_init();
1059         prefs_ext_prog_init();
1060         prefs_wrapping_init();
1061         prefs_compose_writing_init();
1062         prefs_msg_colors_init();
1063         image_viewer_init();
1064         prefs_image_viewer_init();
1065         prefs_quote_init();
1066         prefs_summaries_init();
1067         prefs_message_init();
1068         prefs_other_init();
1069         prefs_logging_init();
1070         prefs_receive_init();
1071         prefs_send_init();
1072         tags_read_tags();
1073 #ifdef USE_ASPELL
1074         gtkaspell_checkers_init();
1075         prefs_spelling_init();
1076 #endif
1077
1078         sock_set_io_timeout(prefs_common.io_timeout_secs);
1079         prefs_actions_read_config();
1080         prefs_display_header_read_config();
1081         /* prefs_filtering_read_config(); */
1082         addressbook_read_file();
1083
1084         gtkut_widget_init();
1085         stock_pixbuf_gdk(NULL, STOCK_PIXMAP_CLAWS_MAIL_ICON, &icon);
1086         gtk_window_set_default_icon(icon);
1087
1088         folderview_initialize();
1089
1090         mh_gtk_init();
1091         imap_gtk_init();
1092         news_gtk_init();
1093
1094         mainwin = main_window_create();
1095 #ifdef MAEMO
1096         AppData *appdata;
1097         appdata = g_new0(AppData, 1);
1098         appdata->program = hildon_program;
1099         appdata->window = HILDON_WINDOW(mainwin->window);
1100         appdata->osso_context = osso_context;
1101         result = osso_rpc_set_cb_f(appdata->osso_context, 
1102                 OSSO_SERVICE, 
1103                 OSSO_OBJECT, 
1104                 OSSO_IFACE,
1105                 dbus_req_handler, appdata);
1106         if (result != OSSO_OK) {
1107                 return OSSO_ERROR;
1108         }
1109
1110 #ifndef CHINOOK
1111         /* Add handler for Exit D-BUS messages */
1112         result = osso_application_set_exit_cb(appdata->osso_context,
1113                                                 exit_event_handler,
1114                                                 (gpointer) appdata);
1115         if (result != OSSO_OK) {
1116                 return OSSO_ERROR;
1117         }
1118 #endif
1119 #endif
1120         manage_window_focus_in(mainwin->window, NULL, NULL);
1121         folderview = mainwin->folderview;
1122
1123         gtk_clist_freeze(GTK_CLIST(mainwin->folderview->ctree));
1124         folder_item_update_freeze();
1125
1126         /* register the callback of unix domain socket input */
1127 #ifdef G_OS_UNIX
1128         lock_socket_tag = gdk_input_add(lock_socket,
1129                                         GDK_INPUT_READ | GDK_INPUT_EXCEPTION,
1130                                         lock_socket_input_cb,
1131                                         mainwin);
1132 #endif
1133
1134         prefs_account_init();
1135         account_read_config_all();
1136
1137         /* If we can't read a folder list or don't have accounts,
1138          * it means the configuration's not done. Either this is
1139          * a brand new install, either a failed/refused migration.
1140          * So we'll start the wizard.
1141          */
1142         if (folder_read_list() < 0) {
1143                 prefs_destroy_cache();
1144                 
1145                 /* if run_wizard returns FALSE it's because it's
1146                  * been cancelled. We can't do much but exit.
1147                  * however, if the user was asked for a migration,
1148                  * we remove the newly created directory so that
1149                  * he's asked again for migration on next launch.*/
1150                 if (!run_wizard(mainwin, TRUE)) {
1151                         if (asked_for_migration)
1152                                 remove_dir_recursive(RC_DIR);
1153 #ifdef G_OS_WIN32
1154                         win32_close_log();
1155 #endif
1156                         exit(1);
1157                 }
1158                 main_window_reflect_prefs_all_now();
1159                 folder_write_list();
1160         }
1161
1162         if (!account_get_list()) {
1163                 prefs_destroy_cache();
1164                 if (!run_wizard(mainwin, FALSE)) {
1165                         if (asked_for_migration)
1166                                 remove_dir_recursive(RC_DIR);
1167 #ifdef G_OS_WIN32
1168                         win32_close_log();
1169 #endif
1170                         exit(1);
1171                 }
1172                 if(!account_get_list()) {
1173                         exit_claws(mainwin);
1174 #ifdef G_OS_WIN32
1175                         win32_close_log();
1176 #endif
1177                         exit(1);
1178                 }
1179         }
1180
1181         
1182         toolbar_main_set_sensitive(mainwin);
1183         main_window_set_menu_sensitive(mainwin);
1184
1185         /* if crashed, show window early so that the user
1186          * sees what's happening */
1187         if (claws_crashed())
1188                 main_window_popup(mainwin);
1189
1190 #ifdef HAVE_LIBETPAN
1191         imap_main_init(prefs_common.skip_ssl_cert_check);
1192         imap_main_set_timeout(prefs_common.io_timeout_secs);
1193         nntp_main_init(prefs_common.skip_ssl_cert_check);
1194 #endif  
1195         account_set_missing_folder();
1196         folder_set_missing_folders();
1197         folderview_set(folderview);
1198
1199         prefs_matcher_read_config();
1200
1201         /* make one all-folder processing before using claws */
1202         main_window_cursor_wait(mainwin);
1203         folder_func_to_all_folders(initial_processing, (gpointer *)mainwin);
1204
1205         /* if claws crashed, rebuild caches */
1206         if (claws_crashed()) {
1207                 GTK_EVENTS_FLUSH();
1208                 debug_print("Claws Mail crashed, checking for new messages in local folders\n");
1209                 folder_item_update_thaw();
1210                 folderview_check_new(NULL);
1211                 folder_clean_cache_memory_force();
1212                 folder_item_update_freeze();
1213         }
1214         /* make the crash-indicator file */
1215         str_write_to_file("foo", get_crashfile_name());
1216
1217         inc_autocheck_timer_init(mainwin);
1218
1219         /* ignore SIGPIPE signal for preventing sudden death of program */
1220 #ifdef G_OS_UNIX
1221         signal(SIGPIPE, SIG_IGN);
1222 #endif
1223         if (cmd.online_mode == ONLINE_MODE_OFFLINE) {
1224                 main_window_toggle_work_offline(mainwin, TRUE, FALSE);
1225         }
1226         if (cmd.online_mode == ONLINE_MODE_ONLINE) {
1227                 main_window_toggle_work_offline(mainwin, FALSE, FALSE);
1228         }
1229
1230         if (cmd.status_folders) {
1231                 g_ptr_array_free(cmd.status_folders, TRUE);
1232                 cmd.status_folders = NULL;
1233         }
1234         if (cmd.status_full_folders) {
1235                 g_ptr_array_free(cmd.status_full_folders, TRUE);
1236                 cmd.status_full_folders = NULL;
1237         }
1238
1239         claws_register_idle_function(claws_gtk_idle);
1240
1241         prefs_toolbar_init();
1242
1243         num_folder_class = g_list_length(folder_get_list());
1244
1245         plugin_load_all("GTK2");
1246
1247         if (g_list_length(folder_get_list()) != num_folder_class) {
1248                 debug_print("new folders loaded, reloading processing rules\n");
1249                 prefs_matcher_read_config();
1250         }
1251         
1252         if (plugin_get_unloaded_list() != NULL) {
1253                 main_window_cursor_normal(mainwin);
1254                 alertpanel_warning(_("Some plugin(s) failed to load. "
1255                                      "Check the Plugins configuration "
1256                                      "for more information."));
1257                 main_window_cursor_wait(mainwin);
1258         }
1259
1260         plugin_load_standard_plugins ();
1261       
1262         /* if not crashed, show window now */
1263         if (!claws_crashed()) {
1264                 /* apart if something told not to show */
1265                 if (show_at_startup)
1266                         main_window_popup(mainwin);
1267         }
1268         
1269         if (!folder_have_mailbox()) {
1270                 prefs_destroy_cache();
1271                 main_window_cursor_normal(mainwin);
1272                 if (folder_get_list() != NULL) {
1273                         alertpanel_error(_("Claws Mail has detected a configured "
1274                                    "mailbox, but it is incomplete. It is "
1275                                    "possibly due to a failing IMAP account. Use "
1276                                    "\"Rebuild folder tree\" on the mailbox parent "
1277                                    "folder's context menu to try to fix it."));
1278                 } else {
1279                         alertpanel_error(_("Claws Mail has detected a configured "
1280                                    "mailbox, but could not load it. It is "
1281                                    "probably provided by an out-of-date "
1282                                    "external plugin. Please reinstall the "
1283                                    "plugin and try again."));
1284                         exit_claws(mainwin);
1285 #ifdef G_OS_WIN32
1286                         win32_close_log();
1287 #endif
1288                         exit(1);
1289                 }
1290         }
1291         
1292         static_mainwindow = mainwin;
1293
1294 #ifdef MAEMO
1295         if (prefs_common.data_root != NULL && *prefs_common.data_root != '\0') {
1296                 GnomeVFSVolume *vol = NULL;
1297                 gchar *uri, *mount_path;
1298
1299                 volmon = gnome_vfs_get_volume_monitor();
1300                 vol = gnome_vfs_volume_monitor_get_volume_for_path(volmon, prefs_common.data_root);
1301
1302                 uri = gnome_vfs_volume_get_activation_uri (vol);
1303                 mount_path = uri?gnome_vfs_get_local_path_from_uri (uri):NULL;
1304                 g_free(uri);
1305
1306                 if (vol == NULL || !gnome_vfs_volume_is_mounted(vol) 
1307                     || strcmp(mount_path, prefs_common.data_root)) {
1308                         alertpanel_error(_("Claws Mail can not start without its data volume (%s)."), 
1309                                 prefs_common.data_root);
1310                         g_free(mount_path);
1311                         gnome_vfs_volume_unref(vol);
1312                         exit_claws(mainwin);
1313                         exit(1);
1314                 }
1315                 g_free(mount_path);
1316                 gnome_vfs_volume_unref(vol);
1317                 g_signal_connect(G_OBJECT(volmon), 
1318                                 "volume-mounted", G_CALLBACK(main_vol_mount_cb), mainwin);
1319                 g_signal_connect(G_OBJECT(volmon), 
1320                                 "volume-unmounted", G_CALLBACK(main_vol_unmount_cb), mainwin);
1321         }
1322 #endif
1323
1324 #ifdef HAVE_STARTUP_NOTIFICATION
1325         startup_notification_complete(FALSE);
1326 #endif
1327 #ifdef HAVE_LIBSM
1328         sc_session_manager_connect(mainwin);
1329 #endif
1330         folder_item_update_thaw();
1331         gtk_clist_thaw(GTK_CLIST(mainwin->folderview->ctree));
1332         main_window_cursor_normal(mainwin);
1333
1334         if (!cmd.target && prefs_common.goto_last_folder_on_startup &&
1335             folder_find_item_from_identifier(prefs_common.last_opened_folder) != NULL &&
1336             !claws_crashed()) {
1337                 cmd.target = prefs_common.last_opened_folder;
1338         }
1339
1340         if (cmd.receive_all && !cmd.target) {
1341                 start_done = FALSE;
1342                 g_timeout_add(1000, defer_check_all, GINT_TO_POINTER(FALSE));
1343         } else if (prefs_common.chk_on_startup && !cmd.target) {
1344                 start_done = FALSE;
1345                 g_timeout_add(1000, defer_check_all, GINT_TO_POINTER(TRUE));
1346         } else if (cmd.receive && !cmd.target) {
1347                 start_done = FALSE;
1348                 g_timeout_add(1000, defer_check, NULL);
1349         } else {
1350                 gtk_widget_grab_focus(folderview->ctree);
1351         }
1352
1353         if (cmd.compose) {
1354                 open_compose_new(cmd.compose_mailto, cmd.attach_files);
1355         }
1356         if (cmd.attach_files) {
1357                 ptr_array_free_strings(cmd.attach_files);
1358                 g_ptr_array_free(cmd.attach_files, TRUE);
1359                 cmd.attach_files = NULL;
1360         }
1361         if (cmd.subscribe) {
1362                 folder_subscribe(cmd.subscribe_uri);
1363         }
1364
1365         if (cmd.send) {
1366                 send_queue();
1367         }
1368         
1369         if (cmd.target) {
1370                 start_done = FALSE;
1371                 g_timeout_add(500, defer_jump, (gpointer)cmd.target);
1372         }
1373
1374         prefs_destroy_cache();
1375         
1376         compose_reopen_exit_drafts();
1377
1378         if (start_done) {
1379                 sc_starting = FALSE;
1380                 main_window_set_menu_sensitive(mainwin);
1381                 toolbar_main_set_sensitive(mainwin);
1382         }
1383         END_TIMING();
1384
1385         gtk_main();
1386
1387 #ifdef MAEMO
1388         osso_deinitialize(osso_context);
1389 #endif
1390 #ifdef G_OS_WIN32
1391         win32_close_log();
1392 #endif
1393         exit_claws(mainwin);
1394
1395         return 0;
1396 }
1397
1398 static void save_all_caches(FolderItem *item, gpointer data)
1399 {
1400         if (!item->cache) {
1401                 return;
1402         }
1403
1404         if (item->opened) {
1405                 folder_item_close(item);
1406         }
1407
1408         folder_item_free_cache(item, TRUE);
1409 }
1410
1411 static void exit_claws(MainWindow *mainwin)
1412 {
1413         gchar *filename;
1414
1415         sc_exiting = TRUE;
1416
1417         debug_print("shutting down\n");
1418         inc_autocheck_timer_remove();
1419
1420         if (prefs_common.clean_on_exit && !emergency_exit) {
1421                 main_window_empty_trash(mainwin, prefs_common.ask_on_clean);
1422         }
1423
1424         /* save prefs for opened folder */
1425         if(mainwin->folderview->opened) {
1426                 FolderItem *item;
1427
1428                 item = gtk_ctree_node_get_row_data(GTK_CTREE(mainwin->folderview->ctree), mainwin->folderview->opened);
1429                 summary_save_prefs_to_folderitem(mainwin->folderview->summaryview, item);
1430                 prefs_common.last_opened_folder = folder_item_get_identifier(item);
1431         }
1432
1433         /* save all state before exiting */
1434         folder_func_to_all_folders(save_all_caches, NULL);
1435         folder_write_list();
1436
1437         main_window_get_size(mainwin);
1438         main_window_get_position(mainwin);
1439
1440         prefs_common_write_config();
1441         account_write_config_all();
1442         addressbook_export_to_file();
1443
1444         filename = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, MENU_RC, NULL);
1445         gtk_accel_map_save(filename);
1446         g_free(filename);
1447
1448         /* delete temporary files */
1449         remove_all_files(get_tmp_dir());
1450         remove_all_files(get_mime_tmp_dir());
1451
1452         close_log_file(LOG_PROTOCOL);
1453         close_log_file(LOG_DEBUG_FILTERING);
1454
1455 #ifdef HAVE_LIBETPAN
1456         imap_main_done();
1457         nntp_main_done();
1458 #endif
1459         /* delete crashfile */
1460         if (!cmd.crash)
1461                 g_unlink(get_crashfile_name());
1462
1463         lock_socket_remove();
1464
1465 #ifdef HAVE_LIBSM
1466         if (mainwin->smc_conn)
1467                 SmcCloseConnection ((SmcConn)mainwin->smc_conn, 0, NULL);
1468         mainwin->smc_conn = NULL;
1469 #endif
1470
1471         main_window_destroy_all();
1472         
1473         plugin_unload_all("GTK2");
1474
1475         prefs_toolbar_done();
1476
1477         addressbook_destroy();
1478
1479         prefs_themes_done();
1480         prefs_fonts_done();
1481         prefs_ext_prog_done();
1482         prefs_wrapping_done();
1483         prefs_compose_writing_done();
1484         prefs_msg_colors_done();
1485         prefs_image_viewer_done();
1486         image_viewer_done();
1487         prefs_quote_done();
1488         prefs_summaries_done();
1489         prefs_message_done();
1490         prefs_other_done();
1491         prefs_receive_done();
1492         prefs_logging_done();
1493         prefs_send_done();
1494         tags_write_tags();
1495 #ifdef USE_ASPELL       
1496         prefs_spelling_done();
1497         gtkaspell_checkers_quit();
1498 #endif
1499         plugin_unload_all("Common");
1500         claws_done();
1501 }
1502
1503 static void parse_cmd_opt(int argc, char *argv[])
1504 {
1505         gint i;
1506
1507         for (i = 1; i < argc; i++) {
1508                 if (!strncmp(argv[i], "--receive-all", 13)) {
1509                         cmd.receive_all = TRUE;
1510                 } else if (!strncmp(argv[i], "--receive", 9)) {
1511                         cmd.receive = TRUE;
1512                 } else if (!strncmp(argv[i], "--compose", 9)) {
1513                         const gchar *p = argv[i + 1];
1514
1515                         cmd.compose = TRUE;
1516                         cmd.compose_mailto = NULL;
1517                         if (p && *p != '\0' && *p != '-') {
1518                                 if (!strncmp(p, "mailto:", 7)) {
1519                                         cmd.compose_mailto = p + 7;
1520                                 } else {
1521                                         cmd.compose_mailto = p;
1522                                 }
1523                                 i++;
1524                         }
1525                 } else if (!strncmp(argv[i], "--subscribe", 11)) {
1526                         const gchar *p = argv[i + 1];
1527                         if (p && *p != '\0' && *p != '-') {
1528                                 cmd.subscribe = TRUE;
1529                                 cmd.subscribe_uri = p;
1530                         }
1531                 } else if (!strncmp(argv[i], "--attach", 8)) {
1532                         const gchar *p = argv[i + 1];
1533                         gchar *file = NULL;
1534
1535                         while (p && *p != '\0' && *p != '-') {
1536                                 if (!cmd.attach_files) {
1537                                         cmd.attach_files = g_ptr_array_new();
1538                                 }
1539                                 if ((file = g_filename_from_uri(p, NULL, NULL)) != NULL) {
1540                                         if (!is_file_exist(file)) {
1541                                                 g_free(file);
1542                                                 file = NULL;
1543                                         }
1544                                 }
1545                                 if (file == NULL && *p != G_DIR_SEPARATOR) {
1546                                         file = g_strconcat(claws_get_startup_dir(),
1547                                                            G_DIR_SEPARATOR_S,
1548                                                            p, NULL);
1549                                 } else if (file == NULL) {
1550                                         file = g_strdup(p);
1551                                 }
1552                                 g_ptr_array_add(cmd.attach_files, file);
1553                                 i++;
1554                                 p = argv[i + 1];
1555                         }
1556                 } else if (!strncmp(argv[i], "--send", 6)) {
1557                         cmd.send = TRUE;
1558                 } else if (!strncmp(argv[i], "--version", 9) ||
1559                            !strncmp(argv[i], "-v", 2)) {
1560                         g_print("Claws Mail version " VERSION "\n");
1561                         exit(0);
1562                 } else if (!strncmp(argv[i], "--status-full", 13)) {
1563                         const gchar *p = argv[i + 1];
1564  
1565                         cmd.status_full = TRUE;
1566                         while (p && *p != '\0' && *p != '-') {
1567                                 if (!cmd.status_full_folders) {
1568                                         cmd.status_full_folders =
1569                                                 g_ptr_array_new();
1570                                 }
1571                                 g_ptr_array_add(cmd.status_full_folders,
1572                                                 g_strdup(p));
1573                                 i++;
1574                                 p = argv[i + 1];
1575                         }
1576                 } else if (!strncmp(argv[i], "--status", 8)) {
1577                         const gchar *p = argv[i + 1];
1578  
1579                         cmd.status = TRUE;
1580                         while (p && *p != '\0' && *p != '-') {
1581                                 if (!cmd.status_folders)
1582                                         cmd.status_folders = g_ptr_array_new();
1583                                 g_ptr_array_add(cmd.status_folders,
1584                                                 g_strdup(p));
1585                                 i++;
1586                                 p = argv[i + 1];
1587                         }
1588                 } else if (!strncmp(argv[i], "--online", 8)) {
1589                         cmd.online_mode = ONLINE_MODE_ONLINE;
1590                 } else if (!strncmp(argv[i], "--offline", 9)) {
1591                         cmd.online_mode = ONLINE_MODE_OFFLINE;
1592                 } else if (!strncmp(argv[i], "--help", 6) ||
1593                            !strncmp(argv[i], "-h", 2)) {
1594                         gchar *base = g_path_get_basename(argv[0]);
1595                         g_print(_("Usage: %s [OPTION]...\n"), base);
1596
1597                         g_print("%s\n", _("  --compose [address]    open composition window"));
1598                         g_print("%s\n", _("  --subscribe [uri]      subscribe to the given URI if possible"));
1599                         g_print("%s\n", _("  --attach file1 [file2]...\n"
1600                                   "                         open composition window with specified files\n"
1601                                   "                         attached"));
1602                         g_print("%s\n", _("  --receive              receive new messages"));
1603                         g_print("%s\n", _("  --receive-all          receive new messages of all accounts"));
1604                         g_print("%s\n", _("  --send                 send all queued messages"));
1605                         g_print("%s\n", _("  --status [folder]...   show the total number of messages"));
1606                         g_print("%s\n", _("  --status-full [folder]...\n"
1607                                           "                         show the status of each folder"));
1608                         g_print("%s\n", _("  --select folder[/msg]  jumps to the specified folder/message\n" 
1609                                           "                         folder is a folder id like 'folder/sub_folder'"));
1610                         g_print("%s\n", _("  --online               switch to online mode"));
1611                         g_print("%s\n", _("  --offline              switch to offline mode"));
1612                         g_print("%s\n", _("  --exit --quit -q       exit Claws Mail"));
1613                         g_print("%s\n", _("  --debug                debug mode"));
1614                         g_print("%s\n", _("  --help -h              display this help and exit"));
1615                         g_print("%s\n", _("  --version -v           output version information and exit"));
1616                         g_print("%s\n", _("  --config-dir           output configuration directory"));
1617                         g_print("%s\n", _("  --alternate-config-dir [dir]\n"
1618                                           "                         use specified configuration directory"));
1619
1620                         g_free(base);
1621                         exit(1);
1622                 } else if (!strncmp(argv[i], "--crash", 7)) {
1623                         cmd.crash = TRUE;
1624                         cmd.crash_params = g_strdup(argv[i + 1]);
1625                         i++;
1626                 } else if (!strncmp(argv[i], "--config-dir", sizeof "--config-dir" - 1)) {
1627                         g_print(RC_DIR "\n");
1628                         exit(0);
1629                 } else if (!strncmp(argv[i], "--alternate-config-dir", sizeof "--alternate-config-dir" - 1) && i+1 < argc) {
1630                         set_rc_dir(argv[i+1]);
1631                 } else if (!strncmp(argv[i], "--exit", 6) ||
1632                            !strncmp(argv[i], "--quit", 6) ||
1633                            !strncmp(argv[i], "-q", 2)) {
1634                         cmd.exit = TRUE;
1635                 } else if (!strncmp(argv[i], "--select", 8) && i+1 < argc) {
1636                         cmd.target = argv[i+1];
1637                 } else if (i == 1 && argc == 2) {
1638                         /* only one parameter. Do something intelligent about it */
1639                         if (strstr(argv[i], "@") && !strstr(argv[i], "://")) {
1640                                 const gchar *p = argv[i];
1641
1642                                 cmd.compose = TRUE;
1643                                 cmd.compose_mailto = NULL;
1644                                 if (p && *p != '\0' && *p != '-') {
1645                                         if (!strncmp(p, "mailto:", 7)) {
1646                                                 cmd.compose_mailto = p + 7;
1647                                         } else {
1648                                                 cmd.compose_mailto = p;
1649                                         }
1650                                 }
1651                         } else if (strstr(argv[i], "://")) {
1652                                 const gchar *p = argv[i];
1653                                 if (p && *p != '\0' && *p != '-') {
1654                                         cmd.subscribe = TRUE;
1655                                         cmd.subscribe_uri = p;
1656                                 }
1657                         } else if (!strcmp(argv[i], "--sync")) {
1658                                 /* gtk debug */
1659                         } else {
1660                                 g_print(_("Unknown option\n"));
1661                                 exit(1);
1662                         }
1663                 }
1664         }
1665
1666         if (cmd.attach_files && cmd.compose == FALSE) {
1667                 cmd.compose = TRUE;
1668                 cmd.compose_mailto = NULL;
1669         }
1670 }
1671
1672 static void initial_processing(FolderItem *item, gpointer data)
1673 {
1674         MainWindow *mainwin = (MainWindow *)data;
1675         gchar *buf;
1676
1677         g_return_if_fail(item);
1678         buf = g_strdup_printf(_("Processing (%s)..."), 
1679                               item->path 
1680                               ? item->path 
1681                               : _("top level folder"));
1682         g_free(buf);
1683
1684         
1685         if (item->prefs->enable_processing) {
1686                 folder_item_apply_processing(item);
1687         }
1688
1689         STATUSBAR_POP(mainwin);
1690 }
1691
1692 static gboolean draft_all_messages(void)
1693 {
1694         GList *compose_list = NULL;
1695         
1696         compose_clear_exit_drafts();
1697         compose_list = compose_get_compose_list();
1698         while (compose_list != NULL) {
1699                 Compose *c = (Compose*)compose_list->data;
1700                 if (!compose_draft(c, COMPOSE_DRAFT_FOR_EXIT))
1701                         return FALSE;
1702                 compose_list = compose_get_compose_list();
1703         }
1704         return TRUE;
1705 }
1706 gboolean clean_quit(gpointer data)
1707 {
1708         static gboolean firstrun = TRUE;
1709
1710         if (!firstrun) {
1711                 return FALSE;
1712         }
1713         firstrun = FALSE;
1714
1715         /*!< Good idea to have the main window stored in a 
1716          *   static variable so we can check that variable
1717          *   to see if we're really allowed to do things
1718          *   that actually the spawner is supposed to 
1719          *   do (like: sending mail, composing messages).
1720          *   Because, really, if we're the spawnee, and
1721          *   we touch GTK stuff, we're hosed. See the 
1722          *   next fixme. */
1723
1724         /* FIXME: Use something else to signal that we're
1725          * in the original spawner, and not in a spawned
1726          * child. */
1727         if (!static_mainwindow) {
1728                 return FALSE;
1729         }
1730                 
1731         draft_all_messages();
1732         emergency_exit = TRUE;
1733         exit_claws(static_mainwindow);
1734         exit(0);
1735
1736         return FALSE;
1737 }
1738
1739 void app_will_exit(GtkWidget *widget, gpointer data)
1740 {
1741         MainWindow *mainwin = data;
1742         
1743         if (sc_exiting == TRUE) {
1744                 debug_print("exit pending\n");
1745                 return;
1746         }
1747         sc_exiting = TRUE;
1748         debug_print("exiting\n");
1749         if (compose_get_compose_list()) {
1750                 if (!draft_all_messages()) {
1751                         main_window_popup(mainwin);
1752                         sc_exiting = FALSE;
1753                         return;
1754                 }
1755         }
1756
1757         if (prefs_common.warn_queued_on_exit && procmsg_have_queued_mails_fast()) {
1758                 if (alertpanel(_("Queued messages"),
1759                                _("Some unsent messages are queued. Exit now?"),
1760                                GTK_STOCK_CANCEL, GTK_STOCK_OK, NULL)
1761                     != G_ALERTALTERNATE) {
1762                         main_window_popup(mainwin);
1763                         sc_exiting = FALSE;
1764                         return;
1765                 }
1766                 manage_window_focus_in(mainwin->window, NULL, NULL);
1767         }
1768
1769         sock_cleanup();
1770 #ifdef HAVE_VALGRIND
1771         if (RUNNING_ON_VALGRIND) {
1772                 summary_clear_list(mainwin->summaryview);
1773         }
1774 #endif
1775         if (folderview_get_selected_item(mainwin->folderview))
1776                 folder_item_close(folderview_get_selected_item(mainwin->folderview));
1777         gtk_main_quit();
1778 }
1779
1780 gboolean claws_is_exiting(void)
1781 {
1782         return sc_exiting;
1783 }
1784
1785 gboolean claws_is_starting(void)
1786 {
1787         return sc_starting;
1788 }
1789
1790 /*
1791  * CLAWS: want this public so crash dialog can delete the
1792  * lock file too
1793  */
1794 gchar *claws_get_socket_name(void)
1795 {
1796         static gchar *filename = NULL;
1797         const gchar *socket_dir = NULL;
1798         
1799         if (rc_dir_is_alt())
1800                 socket_dir = get_rc_dir();
1801         else
1802                 socket_dir = g_get_tmp_dir();
1803         if (filename == NULL) {
1804                 filename = g_strdup_printf("%s%cclaws-mail-%d",
1805                                            socket_dir, G_DIR_SEPARATOR,
1806 #if HAVE_GETUID
1807                                            getuid());
1808 #else
1809                                            0);                                          
1810 #endif
1811         }
1812
1813         return filename;
1814 }
1815
1816 static gchar *get_crashfile_name(void)
1817 {
1818         static gchar *filename = NULL;
1819
1820         if (filename == NULL) {
1821                 filename = g_strdup_printf("%s%cclaws-crashed",
1822                                            get_tmp_dir(), G_DIR_SEPARATOR);
1823         }
1824
1825         return filename;
1826 }
1827
1828 static gint prohibit_duplicate_launch(void)
1829 {
1830         gint uxsock;
1831         gchar *path;
1832
1833         path = claws_get_socket_name();
1834         uxsock = fd_connect_unix(path);
1835         
1836         if (x_display == NULL)
1837                 x_display = g_strdup(g_getenv("DISPLAY"));
1838
1839         if (uxsock < 0) {
1840                 g_unlink(path);
1841                 return fd_open_unix(path);
1842         }
1843
1844         /* remote command mode */
1845
1846         debug_print("another Claws Mail instance is already running.\n");
1847
1848         if (cmd.receive_all) {
1849                 fd_write_all(uxsock, "receive_all\n", 12);
1850         } else if (cmd.receive) {
1851                 fd_write_all(uxsock, "receive\n", 8);
1852         } else if (cmd.compose && cmd.attach_files) {
1853                 gchar *str, *compose_str;
1854                 gint i;
1855
1856                 if (cmd.compose_mailto) {
1857                         compose_str = g_strdup_printf("compose_attach %s\n",
1858                                                       cmd.compose_mailto);
1859                 } else {
1860                         compose_str = g_strdup("compose_attach\n");
1861                 }
1862
1863                 fd_write_all(uxsock, compose_str, strlen(compose_str));
1864                 g_free(compose_str);
1865
1866                 for (i = 0; i < cmd.attach_files->len; i++) {
1867                         str = g_ptr_array_index(cmd.attach_files, i);
1868                         fd_write_all(uxsock, str, strlen(str));
1869                         fd_write_all(uxsock, "\n", 1);
1870                 }
1871
1872                 fd_write_all(uxsock, ".\n", 2);
1873         } else if (cmd.compose) {
1874                 gchar *compose_str;
1875
1876                 if (cmd.compose_mailto) {
1877                         compose_str = g_strdup_printf
1878                                 ("compose %s\n", cmd.compose_mailto);
1879                 } else {
1880                         compose_str = g_strdup("compose\n");
1881                 }
1882
1883                 fd_write_all(uxsock, compose_str, strlen(compose_str));
1884                 g_free(compose_str);
1885         } else if (cmd.subscribe) {
1886                 gchar *str = g_strdup_printf("subscribe %s\n", cmd.subscribe_uri);
1887                 fd_write_all(uxsock, str, strlen(str));
1888                 g_free(str);
1889         } else if (cmd.send) {
1890                 fd_write_all(uxsock, "send\n", 5);
1891         } else if (cmd.online_mode == ONLINE_MODE_ONLINE) {
1892                 fd_write(uxsock, "online\n", 6);
1893         } else if (cmd.online_mode == ONLINE_MODE_OFFLINE) {
1894                 fd_write(uxsock, "offline\n", 7);
1895         } else if (cmd.status || cmd.status_full) {
1896                 gchar buf[BUFFSIZE];
1897                 gint i;
1898                 const gchar *command;
1899                 GPtrArray *folders;
1900                 gchar *folder;
1901  
1902                 command = cmd.status_full ? "status-full\n" : "status\n";
1903                 folders = cmd.status_full ? cmd.status_full_folders :
1904                         cmd.status_folders;
1905  
1906                 fd_write_all(uxsock, command, strlen(command));
1907                 for (i = 0; folders && i < folders->len; ++i) {
1908                         folder = g_ptr_array_index(folders, i);
1909                         fd_write_all(uxsock, folder, strlen(folder));
1910                         fd_write_all(uxsock, "\n", 1);
1911                 }
1912                 fd_write_all(uxsock, ".\n", 2);
1913                 for (;;) {
1914                         fd_gets(uxsock, buf, sizeof(buf));
1915                         if (!strncmp(buf, ".\n", 2)) break;
1916                         fputs(buf, stdout);
1917                 }
1918         } else if (cmd.exit) {
1919                 fd_write_all(uxsock, "exit\n", 5);
1920         } else if (cmd.target) {
1921                 gchar *str = g_strdup_printf("select %s\n", cmd.target);
1922                 fd_write_all(uxsock, str, strlen(str));
1923                 g_free(str);
1924         } else {
1925                 gchar buf[BUFSIZ];
1926                 fd_write_all(uxsock, "get_display\n", 12);
1927                 memset(buf, 0, sizeof(buf));
1928                 fd_gets(uxsock, buf, sizeof(buf));
1929                 if (strcmp2(buf, x_display)) {
1930                         g_print("Claws Mail is already running on display %s.\n",
1931                                 buf);
1932                 } else {
1933                         fd_close(uxsock);
1934                         uxsock = fd_connect_unix(path);
1935                         fd_write_all(uxsock, "popup\n", 6);
1936                 }
1937         }
1938
1939         fd_close(uxsock);
1940         return -1;
1941 }
1942
1943 static gint lock_socket_remove(void)
1944 {
1945 #ifdef G_OS_UNIX
1946         gchar *filename;
1947
1948         if (lock_socket < 0) {
1949                 return -1;
1950         }
1951
1952         if (lock_socket_tag > 0) {
1953                 gdk_input_remove(lock_socket_tag);
1954         }
1955         fd_close(lock_socket);
1956         filename = claws_get_socket_name();
1957         g_unlink(filename);
1958 #endif
1959
1960         return 0;
1961 }
1962
1963 static GPtrArray *get_folder_item_list(gint sock)
1964 {
1965         gchar buf[BUFFSIZE];
1966         FolderItem *item;
1967         GPtrArray *folders = NULL;
1968
1969         for (;;) {
1970                 fd_gets(sock, buf, sizeof(buf));
1971                 if (!strncmp(buf, ".\n", 2)) {
1972                         break;
1973                 }
1974                 strretchomp(buf);
1975                 if (!folders) {
1976                         folders = g_ptr_array_new();
1977                 }
1978                 item = folder_find_item_from_identifier(buf);
1979                 if (item) {
1980                         g_ptr_array_add(folders, item);
1981                 } else {
1982                         g_warning("no such folder: %s\n", buf);
1983                 }
1984         }
1985
1986         return folders;
1987 }
1988
1989 static void lock_socket_input_cb(gpointer data,
1990                                  gint source,
1991                                  GdkInputCondition condition)
1992 {
1993         MainWindow *mainwin = (MainWindow *)data;
1994         gint sock;
1995         gchar buf[BUFFSIZE];
1996
1997         sock = fd_accept(source);
1998         fd_gets(sock, buf, sizeof(buf));
1999
2000         if (!strncmp(buf, "popup", 5)) {
2001                 main_window_popup(mainwin);
2002         } else if (!strncmp(buf, "get_display", 11)) {
2003                 fd_write_all(sock, x_display, strlen(x_display));
2004         } else if (!strncmp(buf, "receive_all", 11)) {
2005                 inc_all_account_mail(mainwin, FALSE,
2006                                      prefs_common.newmail_notify_manu);
2007         } else if (!strncmp(buf, "receive", 7)) {
2008                 inc_mail(mainwin, prefs_common.newmail_notify_manu);
2009         } else if (!strncmp(buf, "compose_attach", 14)) {
2010                 GPtrArray *files;
2011                 gchar *mailto;
2012
2013                 mailto = g_strdup(buf + strlen("compose_attach") + 1);
2014                 files = g_ptr_array_new();
2015                 while (fd_gets(sock, buf, sizeof(buf)) > 0) {
2016                         if (buf[0] == '.' && buf[1] == '\n') {
2017                                 break;
2018                         }
2019                         strretchomp(buf);
2020                         g_ptr_array_add(files, g_strdup(buf));
2021                 }
2022                 open_compose_new(mailto, files);
2023                 ptr_array_free_strings(files);
2024                 g_ptr_array_free(files, TRUE);
2025                 g_free(mailto);
2026         } else if (!strncmp(buf, "compose", 7)) {
2027                 open_compose_new(buf + strlen("compose") + 1, NULL);
2028         } else if (!strncmp(buf, "subscribe", 9)) {
2029                 main_window_popup(mainwin);
2030                 folder_subscribe(buf + strlen("subscribe") + 1);
2031         } else if (!strncmp(buf, "send", 4)) {
2032                 send_queue();
2033         } else if (!strncmp(buf, "online", 6)) {
2034                 main_window_toggle_work_offline(mainwin, FALSE, FALSE);
2035         } else if (!strncmp(buf, "offline", 7)) {
2036                 main_window_toggle_work_offline(mainwin, TRUE, FALSE);
2037         } else if (!strncmp(buf, "status-full", 11) ||
2038                    !strncmp(buf, "status", 6)) {
2039                 gchar *status;
2040                 GPtrArray *folders;
2041  
2042                 folders = get_folder_item_list(sock);
2043                 status = folder_get_status
2044                         (folders, !strncmp(buf, "status-full", 11));
2045                 fd_write_all(sock, status, strlen(status));
2046                 fd_write_all(sock, ".\n", 2);
2047                 g_free(status);
2048                 if (folders) g_ptr_array_free(folders, TRUE);
2049         } else if (!strncmp(buf, "select ", 7)) {
2050                 const gchar *target = buf+7;
2051                 mainwindow_jump_to(target, TRUE);
2052         } else if (!strncmp(buf, "exit", 4)) {
2053                 app_will_exit(NULL, mainwin);
2054         }
2055
2056         fd_close(sock);
2057 }
2058
2059 static void open_compose_new(const gchar *address, GPtrArray *attach_files)
2060 {
2061         gchar *addr = NULL;
2062
2063         if (address) {
2064                 Xstrdup_a(addr, address, return);
2065                 g_strstrip(addr);
2066         }
2067
2068         compose_new(NULL, addr, attach_files);
2069 }
2070
2071 static void send_queue(void)
2072 {
2073         GList *list;
2074         gchar *errstr = NULL;
2075         gboolean error = FALSE;
2076         for (list = folder_get_list(); list != NULL; list = list->next) {
2077                 Folder *folder = list->data;
2078
2079                 if (folder->queue) {
2080                         gint res = procmsg_send_queue
2081                                 (folder->queue, prefs_common.savemsg,
2082                                 &errstr);
2083
2084                         if (res) {
2085                                 folder_item_scan(folder->queue);
2086                         }
2087                         
2088                         if (res < 0)
2089                                 error = TRUE;
2090                 }
2091         }
2092         if (errstr) {
2093                 alertpanel_error_log(_("Some errors occurred "
2094                                 "while sending queued messages:\n%s"), errstr);
2095                 g_free(errstr);
2096         } else if (error) {
2097                 alertpanel_error_log("Some errors occurred "
2098                                 "while sending queued messages.");
2099         }
2100 }
2101
2102 static void quit_signal_handler(int sig)
2103 {
2104         debug_print("Quitting on signal %d\n", sig);
2105
2106         g_timeout_add(0, clean_quit, NULL);
2107 }
2108
2109 static void install_basic_sighandlers()
2110 {
2111 #ifndef G_OS_WIN32
2112         sigset_t    mask;
2113         struct sigaction act;
2114
2115         sigemptyset(&mask);
2116
2117 #ifdef SIGTERM
2118         sigaddset(&mask, SIGTERM);
2119 #endif
2120 #ifdef SIGINT
2121         sigaddset(&mask, SIGINT);
2122 #endif
2123 #ifdef SIGHUP
2124         sigaddset(&mask, SIGHUP);
2125 #endif
2126
2127         act.sa_handler = quit_signal_handler;
2128         act.sa_mask    = mask;
2129         act.sa_flags   = 0;
2130
2131 #ifdef SIGTERM
2132         sigaction(SIGTERM, &act, 0);
2133 #endif
2134 #ifdef SIGINT
2135         sigaction(SIGINT, &act, 0);
2136 #endif  
2137 #ifdef SIGHUP
2138         sigaction(SIGHUP, &act, 0);
2139 #endif  
2140
2141         sigprocmask(SIG_UNBLOCK, &mask, 0);
2142 #endif /* !G_OS_WIN32 */
2143 }
2144
2145 #ifdef MAEMO
2146 osso_context_t *get_osso_context(void)
2147 {
2148         return static_osso_context;
2149 }
2150 #endif