- work on dbus interface

diff --git a/dbus/DBusConnection.cc b/dbus/DBusConnection.cc
index a6373541a3d2f882221b91f9bdffcf3a06df9409..49ffcba2b84796bc111c2925239e03a8c5eb1752 100644 (file)
--- a/dbus/DBusConnection.cc
+++ b/dbus/DBusConnection.cc
@@ -58,6 +58,8 @@ namespace DBus
     void
     Connection::request_name(const char* name, unsigned int flags)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        DBusError err;
        dbus_error_init(&err);
 
@@ -78,6 +80,8 @@ namespace DBus
     void
     Connection::send(Message& m)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        if (!dbus_connection_send(conn, m.get_message(), NULL))
        {
            throw FatalException();
@@ -88,6 +92,8 @@ namespace DBus
     Message
     Connection::send_with_reply_and_block(Message& m)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        DBusError err;
        dbus_error_init(&err);
 
@@ -105,6 +111,8 @@ namespace DBus
     void
     Connection::add_match(const char* rule)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        DBusError err;
        dbus_error_init(&err);
 
@@ -122,14 +130,36 @@ namespace DBus
     Connection::register_object_path(const char* path, const DBusObjectPathVTable* vtable,
                                     void* user_data)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        if (!dbus_connection_register_object_path(conn, path, vtable, user_data))
            throw FatalException();
     }
 
 
+    DBusDispatchStatus
+    Connection::get_dispatch_status()
+    {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
+       return dbus_connection_get_dispatch_status(conn);
+    }
+
+
+    DBusDispatchStatus
+    Connection::dispatch()
+    {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
+       return dbus_connection_dispatch(conn);
+    }
+
+
     unsigned long
     Connection::get_unix_userid(const Message& m)
     {
+       boost::lock_guard<boost::mutex> lock(mutex);
+
        string sender = m.get_sender();
        if (sender.empty())
        {

diff --git a/dbus/DBusConnection.h b/dbus/DBusConnection.h
index aa2b2f4cd2c8f00f18059efee3cebbba1e9843a7..a3a318767b977998eaefee57245a67e9cd22a8b6 100644 (file)
--- a/dbus/DBusConnection.h
+++ b/dbus/DBusConnection.h
@@ -26,6 +26,7 @@
 
 #include <dbus/dbus.h>
 
+#include <boost/thread.hpp>
 #include <boost/noncopyable.hpp>
 
 #include "DBusMessage.h"
@@ -49,6 +50,10 @@ namespace DBus
 
        Message send_with_reply_and_block(Message& m);
 
+       DBusDispatchStatus get_dispatch_status();
+
+       DBusDispatchStatus dispatch();
+
        void add_match(const char* rule);
 
        void register_object_path(const char* path, const DBusObjectPathVTable* vtable,
@@ -56,7 +61,12 @@ namespace DBus
 
        unsigned long get_unix_userid(const Message& m);
 
-    private:
+    protected:
+
+       // Without locking the connection manually the server sometimes does
+       // not reply to request.  Esp. the lock around dbus_watch_handle() is
+       // required.
+       boost::mutex mutex;
 
        DBusConnection* conn;
 

diff --git a/dbus/DBusServer.cc b/dbus/DBusMainLoop.cc
similarity index 75%
rename from dbus/DBusServer.cc
rename to dbus/DBusMainLoop.cc
index 50d948af244b3e97e97150151c67efc07c030fa3..86c521a5a5ba9f3282dfccaea4156f437dcd74c5 100644 (file)
--- a/dbus/DBusServer.cc
+++ b/dbus/DBusMainLoop.cc
@@ -24,31 +24,31 @@
 #include <poll.h>
 #include <time.h>
 
-#include "DBusServer.h"
+#include "DBusMainLoop.h"
 
 
 namespace DBus
 {
 
-    Server::Server(DBusBusType type)
+    MainLoop::MainLoop(DBusBusType type)
        : Connection(type), idle_timeout(-1)
     {
        if (pipe(wakeup_pipe) != 0)
            throw FatalException();
 
-       if (!dbus_connection_set_watch_functions(get_connection(), add_watch, remove_watch,
-                                                toggled_watch, this, NULL))
+       if (!dbus_connection_set_watch_functions(conn, add_watch, remove_watch, toggled_watch,
+                                                this, NULL))
            throw FatalException();
 
-       if (!dbus_connection_set_timeout_functions(get_connection(), add_timeout, remove_timeout,
+       if (!dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout,
                                                   toggled_timeout, this, NULL))
            throw FatalException();
 
-       dbus_connection_set_wakeup_main_function(get_connection(), wakeup_main, this, NULL);
+       dbus_connection_set_wakeup_main_function(conn, wakeup_main, this, NULL);
     }
 
 
-    Server::~Server()
+    MainLoop::~MainLoop()
     {
        close(wakeup_pipe[0]);
        close(wakeup_pipe[1]);
@@ -56,7 +56,7 @@ namespace DBus
 
 
     void
-    DBus::Server::run()
+    DBus::MainLoop::run()
     {
        reset_idle_count();
 
@@ -128,15 +128,18 @@ namespace DBus
                                flags |= DBUS_WATCH_WRITABLE;
 
                            if (flags != 0)
+                           {
+                               boost::lock_guard<boost::mutex> lock(mutex);
                                dbus_watch_handle(it->dbus_watch, flags);
+                           }
                        }
                    }
                }
            }
 
-           while (dbus_connection_get_dispatch_status(get_connection()) == DBUS_DISPATCH_DATA_REMAINS)
+           while (get_dispatch_status() == DBUS_DISPATCH_DATA_REMAINS)
            {
-               dbus_connection_dispatch(get_connection());
+               dispatch();
            }
 
            if (idle_timeout >= 0)
@@ -153,14 +156,14 @@ namespace DBus
 
 
     void
-    Server::set_idle_timeout(int s)
+    MainLoop::set_idle_timeout(int s)
     {
        idle_timeout = s;
     }
 
 
     void
-    Server::reset_idle_count()
+    MainLoop::reset_idle_count()
     {
        struct timespec tmp;
        clock_gettime(CLOCK_MONOTONIC, &tmp);
@@ -168,8 +171,8 @@ namespace DBus
     }
 
 
-    vector<Server::Watch>::iterator
-    Server::find_watch(DBusWatch* dbus_watch)
+    vector<MainLoop::Watch>::iterator
+    MainLoop::find_watch(DBusWatch* dbus_watch)
     {
        for (vector<Watch>::iterator it = watches.begin(); it != watches.end(); ++it)
            if (it->dbus_watch == dbus_watch)
@@ -179,8 +182,8 @@ namespace DBus
     }
 
 
-    vector<Server::Timeout>::iterator
-    Server::find_timeout(DBusTimeout* dbus_timeout)
+    vector<MainLoop::Timeout>::iterator
+    MainLoop::find_timeout(DBusTimeout* dbus_timeout)
     {
        for (vector<Timeout>::iterator it = timeouts.begin(); it != timeouts.end(); ++it)
            if (it->dbus_timeout == dbus_timeout)
@@ -191,10 +194,8 @@ namespace DBus
 
 
     dbus_bool_t
-    Server::add_watch(DBusWatch* dbus_watch, void* data)
+    MainLoop::add_watch(DBusWatch* dbus_watch, void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
        Watch tmp;
        tmp.enabled = dbus_watch_get_enabled(dbus_watch);
        tmp.fd = dbus_watch_get_unix_fd(dbus_watch);
@@ -207,6 +208,8 @@ namespace DBus
            tmp.events |= POLLOUT;
 
        tmp.dbus_watch = dbus_watch;
+
+       MainLoop* s = static_cast<MainLoop*>(data);
        s->watches.push_back(tmp);
 
        return true;
@@ -214,34 +217,32 @@ namespace DBus
 
 
     void
-    Server::remove_watch(DBusWatch* dbus_watch, void* data)
+    MainLoop::remove_watch(DBusWatch* dbus_watch, void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
+       MainLoop* s = static_cast<MainLoop*>(data);
        vector<Watch>::iterator it = s->find_watch(dbus_watch);
        s->watches.erase(it);
     }
 
 
     void
-    Server::toggled_watch(DBusWatch* dbus_watch, void* data)
+    MainLoop::toggled_watch(DBusWatch* dbus_watch, void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
+       MainLoop* s = static_cast<MainLoop*>(data);
        vector<Watch>::iterator it = s->find_watch(dbus_watch);
        it->enabled = dbus_watch_get_enabled(dbus_watch);
     }
 
 
     dbus_bool_t
-    Server::add_timeout(DBusTimeout* dbus_timeout, void* data)
+    MainLoop::add_timeout(DBusTimeout* dbus_timeout, void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
        Timeout tmp;
        tmp.enabled = dbus_timeout_get_enabled(dbus_timeout);
        tmp.interval = dbus_timeout_get_interval(dbus_timeout);
        tmp.dbus_timeout = dbus_timeout;
+
+       MainLoop* s = static_cast<MainLoop*>(data);
        s->timeouts.push_back(tmp);
 
        return true;
@@ -249,9 +250,9 @@ namespace DBus
 
 
     void
-    Server::remove_timeout(DBusTimeout* dbus_timeout, void* data)
+    MainLoop::remove_timeout(DBusTimeout* dbus_timeout, void* data)
     {
-       Server* s = static_cast<Server*>(data);
+       MainLoop* s = static_cast<MainLoop*>(data);
 
        vector<Timeout>::iterator it = s->find_timeout(dbus_timeout);
        s->timeouts.erase(it);
@@ -259,20 +260,18 @@ namespace DBus
 
 
     void
-    Server::toggled_timeout(DBusTimeout* dbus_timeout, void* data)
+    MainLoop::toggled_timeout(DBusTimeout* dbus_timeout, void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
+       MainLoop* s = static_cast<MainLoop*>(data);
        vector<Timeout>::iterator it = s->find_timeout(dbus_timeout);
        it->enabled = dbus_timeout_get_enabled(dbus_timeout);
     }
 
 
     void
-    Server::wakeup_main(void* data)
+    MainLoop::wakeup_main(void* data)
     {
-       Server* s = static_cast<Server*>(data);
-
+       MainLoop* s = static_cast<MainLoop*>(data);
        const char arbitrary = 42;
        write(s->wakeup_pipe[1], &arbitrary, 1);
     }

diff --git a/dbus/DBusServer.h b/dbus/DBusMainLoop.h
similarity index 92%
rename from dbus/DBusServer.h
rename to dbus/DBusMainLoop.h
index 31cf9fccfa6a724979eb4aaf73f623611368c820..428c063ecde1ae8073c7e83c1c3481aec919dd44 100644 (file)
--- a/dbus/DBusServer.h
+++ b/dbus/DBusMainLoop.h
@@ -20,8 +20,8 @@
  */
 
 
-#ifndef SNAPPER_DBUSSERVER_H
-#define SNAPPER_DBUSSERVER_H
+#ifndef SNAPPER_DBUSMAINLOOP_H
+#define SNAPPER_DBUSMAINLOOP_H
 
 
 #include <dbus/dbus.h>
@@ -32,12 +32,12 @@
 namespace DBus
 {
 
-    class Server : public Connection
+    class MainLoop : public Connection
     {
     public:
 
-       Server(DBusBusType type);
-       ~Server();
+       MainLoop(DBusBusType type);
+       ~MainLoop();
 
        void run();
 

diff --git a/dbus/Makefile.am b/dbus/Makefile.am
index f67887c90887f5a64d423b402fe1deb5307c492f..eb466b4e8552e5969706d4fcc0a66723053907e2 100644 (file)
--- a/dbus/Makefile.am
+++ b/dbus/Makefile.am
@@ -9,4 +9,4 @@ noinst_LTLIBRARIES = libdbus.la
 libdbus_la_SOURCES =                                   \
        DBusMessage.cc          DBusMessage.h           \
        DBusConnection.cc       DBusConnection.h        \
-       DBusServer.cc           DBusServer.h
+       DBusMainLoop.cc         DBusMainLoop.h

diff --git a/server/snapperd.cc b/server/snapperd.cc
index bf6d022ed2f343871695d59c6df28be28ae59667..399cf012349e4dee2ed47c740e854834e7eae083 100644 (file)
--- a/server/snapperd.cc
+++ b/server/snapperd.cc
@@ -39,7 +39,7 @@
 
 #include "dbus/DBusMessage.h"
 #include "dbus/DBusConnection.h"
-#include "dbus/DBusServer.h"
+#include "dbus/DBusMainLoop.h"
 
 #include "MetaSnapper.h"
 #include "Client.h"
@@ -1176,7 +1176,7 @@ unregister_func(DBusConnection* connection, void* data)
 DBusHandlerResult
 message_func1(DBusConnection* connection, DBusMessage* message, void* data)
 {
-    DBus::Server* s = static_cast<DBus::Server*>(data);
+    DBus::MainLoop* s = static_cast<DBus::MainLoop*>(data);
 
     DBus::Message msg(message, true);
 
@@ -1215,7 +1215,7 @@ message_func1(DBusConnection* connection, DBusMessage* message, void* data)
 DBusHandlerResult
 message_func2(DBusConnection* connection, DBusMessage* message, void* data)
 {
-    DBus::Server* s = static_cast<DBus::Server*>(data);
+    DBus::MainLoop* s = static_cast<DBus::MainLoop*>(data);
 
     DBus::Message msg(message, true);
 
@@ -1298,21 +1298,21 @@ main(int argc, char** argv)
 
     dbus_threads_init_default();
 
-    DBus::Server server(DBUS_BUS_SYSTEM);
+    DBus::MainLoop mainloop(DBUS_BUS_SYSTEM);
 
-    server.set_idle_timeout(30);
+    mainloop.set_idle_timeout(30);
 
     y2mil("Requesting DBus name");
 
-    server.request_name("org.opensuse.Snapper", DBUS_NAME_FLAG_REPLACE_EXISTING);
+    mainloop.request_name("org.opensuse.Snapper", DBUS_NAME_FLAG_REPLACE_EXISTING);
 
     y2mil("Listening for method calls and signals");
 
-    server.register_object_path(PATH, &dbus_vtable1, &server);
-    server.register_object_path(DBUS_PATH_DBUS, &dbus_vtable2, &server);
-    server.add_match("type='signal', interface='" DBUS_INTERFACE_DBUS "', member='NameOwnerChanged'");
+    mainloop.register_object_path(PATH, &dbus_vtable1, &mainloop);
+    mainloop.register_object_path(DBUS_PATH_DBUS, &dbus_vtable2, &mainloop);
+    mainloop.add_match("type='signal', interface='" DBUS_INTERFACE_DBUS "', member='NameOwnerChanged'");
 
-    server.run();
+    mainloop.run();
 
     y2mil("Exiting");