gchar*
gkd_dbus_singleton_control (void)
{
gchar *control = NULL;
GError *error = NULL;
GVariant *control_variant;
/* If tried to aquire the service must have failed */
g_return_val_if_fail (!acquired_service, NULL);
if (!connect_to_session_bus ())
return NULL;
control_variant = g_dbus_connection_call_sync (dbus_conn,
GNOME_KEYRING_DAEMON_SERVICE,
GNOME_KEYRING_DAEMON_PATH,
GNOME_KEYRING_DAEMON_INTERFACE,
"GetControlDirectory",
NULL, NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
1000, NULL, &error);
if (error != NULL) {
if (!g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER))
g_message ("couldn't communicate with already running daemon: %s", error->message);
g_error_free (error);
return NULL;
}
g_variant_get (control_variant, "(s)", &control);
g_variant_unref (control_variant);
return control;
}
void Timed::device_mode_reached(bool act_dead, const string &new_address)
{
act_dead_mode = act_dead ;
log_debug("act_dead=%d, new_address='%s'", act_dead, new_address.c_str()) ;
#if 0
bool res = setenv("DBUS_SESSION_BUS_ADDRESS", dbus_session.c_str(), true) ;
if (res<0)
{
log_error("can't set DBUS_SESSION_BUS_ADDRESS environment: %m") ;
QDBusConnection::disconnectFromBus(session_bus_name.c_str()) ;
return ;
}
#endif
connect_to_session_bus(session_bus_address = new_address) ;
start_voland_watcher() ;
am->device_mode_detected(not act_dead) ;
am->unfreeze() ;
}
gchar*
gkd_dbus_singleton_control (void)
{
DBusError derr = DBUS_ERROR_INIT;
DBusMessage *msg, *reply;
gchar *control = NULL;
const char *path;
/* If tried to aquire the service must have failed */
g_return_val_if_fail (!acquired_service, NULL);
if (!connect_to_session_bus ())
return NULL;
msg = dbus_message_new_method_call (GNOME_KEYRING_DAEMON_SERVICE,
GNOME_KEYRING_DAEMON_PATH,
GNOME_KEYRING_DAEMON_INTERFACE,
"GetControlDirectory");
g_return_val_if_fail (msg, NULL);
dbus_message_set_auto_start (msg, FALSE);
/* Send message and get a handle for a reply */
reply = dbus_connection_send_with_reply_and_block (dbus_conn, msg, 1000, &derr);
dbus_message_unref (msg);
if (!reply) {
if (!dbus_error_has_name (&derr, "org.freedesktop.DBus.Error.NameHasNoOwner"))
g_message ("couldn't communicate with already running daemon: %s", derr.message);
dbus_error_free (&derr);
return NULL;
}
/* Get out our client path */
if (!dbus_message_get_args (reply, &derr, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID)) {
g_message ("couldn't parse response from already running daemon: %s", derr.message);
dbus_error_free (&derr);
control = NULL;
} else {
control = g_strdup (path);
}
dbus_message_unref (reply);
return control;
}
gboolean
gkd_dbus_setup (void)
{
gboolean unused;
if (!connect_to_session_bus ())
return FALSE;
/* Our singleton, and internal service API */
gkd_dbus_singleton_acquire (&unused);
/* Session stuff */
gkd_dbus_environment_init (dbus_conn);
gkd_dbus_session_init (dbus_conn);
/* Secrets API */
gkd_dbus_secrets_init (dbus_conn);
egg_cleanup_register (dbus_cleanup, NULL);
return TRUE;
}
void Timed::dsme_mode_reported(const string &mode)
{
log_notice("MODE: reported by dsme '%s'", mode.c_str()) ;
if (mode=="USER")
{
am->device_mode_detected(true) ;
am->unfreeze() ;
}
else if (mode=="ACTDEAD")
{
am->device_mode_detected(false) ;
am->unfreeze() ;
}
else
{
log_warning("MODE: machine remain frozen (mode reported by dsme: '%s')", mode.c_str()) ;
return ;
}
#if 0
if (const char *addr = getenv("DBUS_SESSION_BUS_ADDRESS"))
connect_to_session_bus(session_bus_address = addr) ;
start_voland_watcher() ;
#endif
}
gboolean
gkd_dbus_singleton_acquire (gboolean *acquired)
{
DBusError derr = DBUS_ERROR_INIT;
dbus_uint32_t res = 0;
const gchar *service = NULL;
unsigned int flags = 0;
g_assert (acquired);
if (!connect_to_session_bus ())
return FALSE;
/* First register the object */
if (!object_registered) {
if (dbus_connection_register_object_path (dbus_conn, GNOME_KEYRING_DAEMON_PATH,
&object_vtable, NULL)) {
object_registered = TRUE;
egg_cleanup_register (cleanup_singleton, NULL);
} else {
g_message ("couldn't register dbus object path");
}
}
/* Try and grab our name */
if (!acquired_asked) {
#ifdef WITH_DEBUG
service = g_getenv ("GNOME_KEYRING_TEST_SERVICE");
if (service && service[0])
flags = DBUS_NAME_FLAG_ALLOW_REPLACEMENT | DBUS_NAME_FLAG_REPLACE_EXISTING;
else
#endif
service = GNOME_KEYRING_DAEMON_SERVICE;
res = dbus_bus_request_name (dbus_conn, service, flags, &derr);
if (dbus_error_is_set (&derr)) {
g_message ("couldn't request name '%s' on session bus: %s", service, derr.message);
dbus_error_free (&derr);
return FALSE;
}
acquired_asked = TRUE;
switch (res) {
/* We acquired the service name */
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
acquired_service = TRUE;
break;
/* Another daemon is running */
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_EXISTS:
acquired_service = FALSE;
break;
default:
acquired_service = FALSE;
g_return_val_if_reached (FALSE);
break;
};
}
*acquired = acquired_service;
return TRUE;
}
gboolean
gkd_dbus_singleton_acquire (gboolean *acquired)
{
const gchar *service = NULL;
GBusNameOwnerFlags flags = G_BUS_NAME_OWNER_FLAGS_NONE;
GVariant *acquire_variant;
guint res;
GError *error = NULL;
GkdExportedDaemon *skeleton;
g_assert (acquired);
if (!connect_to_session_bus ())
return FALSE;
/* First register the object */
if (!object_registered) {
skeleton = gkd_exported_daemon_skeleton_new ();
g_signal_connect (skeleton, "handle-get-control-directory",
G_CALLBACK (handle_get_control_directory), NULL);
g_signal_connect (skeleton, "handle-get-environment",
G_CALLBACK (handle_get_environment), NULL);
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (skeleton), dbus_conn,
GNOME_KEYRING_DAEMON_PATH, &error);
if (error == NULL) {
object_registered = TRUE;
egg_cleanup_register (cleanup_singleton, skeleton);
} else {
g_message ("couldn't register dbus object path: %s", error->message);
g_clear_error (&error);
}
}
/* Try and grab our name */
if (!acquired_asked) {
#ifdef WITH_DEBUG
service = g_getenv ("GNOME_KEYRING_TEST_SERVICE");
if (service && service[0])
flags = G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE;
else
#endif
service = GNOME_KEYRING_DAEMON_SERVICE;
/* attempt to acquire the name */
acquire_variant = g_dbus_connection_call_sync (dbus_conn,
"org.freedesktop.DBus", /* bus name */
"/org/freedesktop/DBus", /* object path */
"org.freedesktop.DBus", /* interface name */
"RequestName", /* method name */
g_variant_new ("(su)",
service,
flags),
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (error != NULL) {
g_message ("couldn't request name '%s' on session bus: %s", service, error->message);
g_error_free (error);
return FALSE;
}
acquired_asked = TRUE;
g_variant_get (acquire_variant, "(u)", &res);
g_variant_unref (acquire_variant);
switch (res) {
/* We acquired the service name */
case 1: /* DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER */
case 4: /* DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER */
acquired_service = TRUE;
break;
/* Another daemon is running */
case 2: /* DBUS_REQUEST_NAME_REPLY_IN_QUEUE */
case 3: /* DBUS_REQUEST_NAME_REPLY_EXISTS */
acquired_service = FALSE;
break;
default:
acquired_service = FALSE;
g_return_val_if_reached (FALSE);
break;
};
}
*acquired = acquired_service;
return TRUE;
}
int
main (int argc, char **argv)
{
gboolean arg_version = FALSE;
gboolean arg_display_properties = FALSE;
gboolean arg_display_about = FALSE;
gboolean arg_consider_new_mail_as_read = FALSE;
gboolean arg_update = FALSE;
gboolean arg_print_summary = FALSE;
gboolean arg_unset_obsolete_configuration = FALSE;
gboolean arg_quit = FALSE;
const GOptionEntry options[] = {
{
"version",
'v',
0,
G_OPTION_ARG_NONE,
&arg_version,
N_("Show version information"),
NULL
},
{
"enable-info",
'i',
0,
G_OPTION_ARG_NONE,
&arg_enable_info,
N_("Enable informational output"),
NULL
},
{
"display-properties",
'p',
0,
G_OPTION_ARG_NONE,
&arg_display_properties,
N_("Display the properties dialog"),
NULL
},
{
"display-about",
'a',
0,
G_OPTION_ARG_NONE,
&arg_display_about,
N_("Display the about dialog"),
NULL
},
{
"consider-new-mail-as-read",
'r',
0,
G_OPTION_ARG_NONE,
&arg_consider_new_mail_as_read,
N_("Consider new mail as read"),
NULL
},
{
"update",
'u',
0,
G_OPTION_ARG_NONE,
&arg_update,
N_("Update the mail status"),
NULL
},
{
"print-summary",
's',
0,
G_OPTION_ARG_NONE,
&arg_print_summary,
N_("Print a XML mail summary"),
NULL
},
{
"unset-obsolete-configuration",
'\0',
0,
G_OPTION_ARG_NONE,
&arg_unset_obsolete_configuration,
N_("Unset obsolete GConf configuration"),
NULL
},
{
"quit",
'q',
0,
G_OPTION_ARG_NONE,
&arg_quit,
N_("Quit Mail Notification"),
NULL
},
{ NULL }
};
GOptionContext *option_context;
DBusGConnection *bus;
DBusGProxy *bus_proxy;
g_log_set_fatal_mask(NULL, G_LOG_LEVEL_CRITICAL);
g_log_set_handler(NULL, G_LOG_LEVEL_INFO, info_log_cb, NULL);
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
g_set_application_name(_("Mail Notification"));
g_thread_init(NULL);
if (! g_thread_supported())
/*
* We cannot use mn_fatal_error_dialog() because gtk_init() has
* not been called yet.
*/
g_critical(_("multi-threading is not available"));
gdk_threads_init();
GDK_THREADS_ENTER();
option_context = g_option_context_new(NULL);
g_option_context_add_main_entries(option_context, options, GETTEXT_PACKAGE);
gnome_program_init(PACKAGE,
VERSION,
LIBGNOME_MODULE,
argc,
argv,
GNOME_PARAM_HUMAN_READABLE_NAME, _("Mail Notification"),
GNOME_PROGRAM_STANDARD_PROPERTIES,
GNOME_PARAM_GOPTION_CONTEXT, option_context,
NULL);
gtk_init(&argc, &argv);
if (arg_version)
{
print_version();
goto end;
}
if (arg_unset_obsolete_configuration)
{
mn_conf_unset_obsolete();
goto end;
}
ensure_icon_path();
gtk_window_set_default_icon_name("mail-notification");
mn_stock_init();
bus = connect_to_session_bus();
bus_proxy = get_bus_proxy(bus);
if (mn_server_start(bus, bus_proxy)) /* not already running */
{
if (arg_quit)
g_message(_("Mail Notification is not running"));
else
{
mn_mailbox_init_types();
#if WITH_MBOX || WITH_MOZILLA || WITH_MH || WITH_MAILDIR || WITH_SYLPHEED
mn_vfs_mailbox_init_types();
#endif
/* mn-client-session uses sockets, we don't want to die on SIGPIPE */
signal(SIGPIPE, SIG_IGN);
if (! gnome_vfs_init())
mn_show_fatal_error_dialog(NULL, _("Unable to initialize the GnomeVFS library."));
#if !GTK_CHECK_VERSION(3,0,0)
gnome_authentication_manager_init();
#endif
/* must be called before init_gmime() */
mn_conf_init();
#if WITH_GMIME
init_gmime();
#endif
if (! notify_init(_("Mail Notification")))
mn_show_error_dialog(NULL,
_("An initialization error has occurred in Mail Notification"),
_("Unable to initialize the notification library. Message popups will not be displayed."));
/*
* Work around
* http://bugzilla.gnome.org/show_bug.cgi?id=64764:
* initialize the classes we will be using concurrently
* before any thread is created.
*/
init_classes();
mn_shell_new(bus, bus_proxy);
/* also display the properties dialog if there are no mailboxes */
if (! mn_shell->mailboxes->list)
arg_display_properties = TRUE;
if (arg_display_properties)
mn_shell_show_properties_dialog(mn_shell, 0);
if (arg_display_about)
mn_shell_show_about_dialog(mn_shell, 0);
if (arg_consider_new_mail_as_read)
report_option_ignored("--consider-new-mail-as-read");
if (arg_update)
report_option_ignored("--update");
if (arg_print_summary)
report_option_ignored("--print-summary");
/* in case no window has been displayed */
gdk_notify_startup_complete();
gtk_main();
}
}
else /* already running */
{
DBusGProxy *proxy;
GError *err = NULL;
proxy = dbus_g_proxy_new_for_name(bus,
MN_SERVER_SERVICE,
MN_SERVER_PATH,
MN_SERVER_INTERFACE);
if (arg_quit)
{
g_message(_("quitting Mail Notification"));
CALL_SERVER(org_gnome_MailNotification_quit(proxy, &err));
}
else
{
/* also display the properties dialog if there are no mailboxes */
if (! arg_display_properties)
{
gboolean has;
CALL_SERVER(org_gnome_MailNotification_has_mailboxes(proxy, &has, &err));
arg_display_properties = ! has;
}
if (arg_display_properties)
CALL_SERVER(org_gnome_MailNotification_display_properties(proxy, &err));
if (arg_display_about)
CALL_SERVER(org_gnome_MailNotification_display_about(proxy, &err));
if (arg_consider_new_mail_as_read)
{
g_message(_("considering new mail as read"));
CALL_SERVER(org_gnome_MailNotification_consider_new_mail_as_read(proxy, &err));
}
if (arg_update)
{
g_message(_("updating the mail status"));
CALL_SERVER(org_gnome_MailNotification_update(proxy, &err));
}
if (arg_print_summary)
{
char *summary;
CALL_SERVER(org_gnome_MailNotification_get_summary(proxy, &summary, &err));
g_print("%s", summary);
g_free(summary);
}
if (! (arg_display_properties
|| arg_display_about
|| arg_consider_new_mail_as_read
|| arg_update
|| arg_print_summary))
g_message(_("Mail Notification is already running"));
}
/*
* Do not unref the proxy, since it might break when the
* DBusGProxy memory management issue is fixed
* (https://bugs.freedesktop.org/show_bug.cgi?id=14030).
*/
/* no window has been displayed by this process */
gdk_notify_startup_complete();
}
end:
GDK_THREADS_LEAVE();
return 0;
}