abrt_dbus: preparatory patch for C++ -> c conversion

Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>

3 files changed, 73 insertions, 51 deletions

diff --git a/lib/utils/abrt_dbus.cpp b/lib/utils/abrt_dbus.cpp
index 4319d103..6bc155e3 100644
--- a/lib/utils/abrt_dbus.cpp
+++ b/lib/utils/abrt_dbus.cpp
@@ -171,7 +171,7 @@ void store_string(DBusMessageIter* iter, const char* val)
 //    val = db;
 //    return dbus_message_iter_next(iter);
 //}
-int load_int32(DBusMessageIter* iter, int32_t& val)
+int load_int32(DBusMessageIter* iter, int32_t *val)
 {
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_INT32)
@@ -179,10 +179,10 @@ int load_int32(DBusMessageIter* iter, int32_t& val)
         error_msg("%s expected in dbus message, but not found ('%c')", "int32", type);
         return -1;
     }
-    dbus_message_iter_get_basic(iter, &val);
+    dbus_message_iter_get_basic(iter, val);
     return dbus_message_iter_next(iter);
 }
-int load_uint32(DBusMessageIter* iter, uint32_t& val)
+int load_uint32(DBusMessageIter* iter, uint32_t *val)
 {
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_UINT32)
@@ -190,10 +190,10 @@ int load_uint32(DBusMessageIter* iter, uint32_t& val)
         error_msg("%s expected in dbus message, but not found ('%c')", "uint32", type);
         return -1;
     }
-    dbus_message_iter_get_basic(iter, &val);
+    dbus_message_iter_get_basic(iter, val);
     return dbus_message_iter_next(iter);
 }
-int load_int64(DBusMessageIter* iter, int64_t& val)
+int load_int64(DBusMessageIter* iter, int64_t *val)
 {
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_INT64)
@@ -201,10 +201,10 @@ int load_int64(DBusMessageIter* iter, int64_t& val)
         error_msg("%s expected in dbus message, but not found ('%c')", "int64", type);
         return -1;
     }
-    dbus_message_iter_get_basic(iter, &val);
+    dbus_message_iter_get_basic(iter, val);
     return dbus_message_iter_next(iter);
 }
-int load_uint64(DBusMessageIter* iter, uint64_t& val)
+int load_uint64(DBusMessageIter* iter, uint64_t *val)
 {
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_UINT64)
@@ -212,10 +212,10 @@ int load_uint64(DBusMessageIter* iter, uint64_t& val)
         error_msg("%s expected in dbus message, but not found ('%c')", "uint64", type);
         return -1;
     }
-    dbus_message_iter_get_basic(iter, &val);
+    dbus_message_iter_get_basic(iter, val);
     return dbus_message_iter_next(iter);
 }
-int load_charp(DBusMessageIter* iter, const char*& val)
+int load_charp(DBusMessageIter* iter, const char** val)
 {
     int type = dbus_message_iter_get_arg_type(iter);
     if (type != DBUS_TYPE_STRING)
@@ -223,8 +223,8 @@ int load_charp(DBusMessageIter* iter, const char*& val)
         error_msg("%s expected in dbus message, but not found ('%c')", "string", type);
         return -1;
     }
-    dbus_message_iter_get_basic(iter, &val);
-//log("load_charp:'%s'", val);
+    dbus_message_iter_get_basic(iter, val);
+//log("load_charp:'%s'", *val);
     return dbus_message_iter_next(iter);
 }
 
@@ -238,12 +238,12 @@ static gboolean handle_dbus_fd(GIOChannel *gio, GIOCondition condition, gpointer
 {
     DBusWatch *watch = (DBusWatch*)data;
 
-    VERB3 log("%s(gio, condition:%x [bits:IN/PRI/OUT/ERR/HUP...], data)", __func__, int(condition));
+    VERB3 log("%s(gio, condition:%x [bits:IN/PRI/OUT/ERR/HUP...], data)", __func__, (int)condition);
 
     /* Notify the D-Bus library when a previously-added watch
      * is ready for reading or writing, or has an exception such as a hangup.
      */
-    int glib_flags = int(condition);
+    int glib_flags = (int)condition;
     int dbus_flags = 0;
     if (glib_flags & G_IO_IN)  dbus_flags |= DBUS_WATCH_READABLE;
     if (glib_flags & G_IO_OUT) dbus_flags |= DBUS_WATCH_WRITABLE;
@@ -265,12 +265,12 @@ static gboolean handle_dbus_fd(GIOChannel *gio, GIOCondition condition, gpointer
     return TRUE; /* "glib, do not remove this event source!" */
 }
 
-struct watch_app_info_t
+typedef struct watch_app_info_t
 {
     GIOChannel *channel;
     guint event_source_id;
     bool watch_enabled;
-};
+} watch_app_info_t;
 /* Callback: "dbus_watch_get_enabled() may return a different value than it did before" */
 static void toggled_watch(DBusWatch *watch, void* data)
 {
@@ -287,7 +287,7 @@ static void toggled_watch(DBusWatch *watch, void* data)
             if (dbus_flags & DBUS_WATCH_READABLE) glib_flags |= G_IO_IN;
             if (dbus_flags & DBUS_WATCH_WRITABLE) glib_flags |= G_IO_OUT;
             VERB3 log(" adding watch to glib main loop. dbus_flags:%x glib_flags:%x", dbus_flags, glib_flags);
-            app_info->event_source_id = g_io_add_watch(app_info->channel, GIOCondition(glib_flags), handle_dbus_fd, watch);
+            app_info->event_source_id = g_io_add_watch(app_info->channel, (GIOCondition)glib_flags, handle_dbus_fd, watch);
         }
         /* else: it was already enabled */
     } else {
diff --git a/lib/utils/abrt_dbus.h b/lib/utils/abrt_dbus.h
index 58a8d912..cdc963ca 100644
--- a/lib/utils/abrt_dbus.h
+++ b/lib/utils/abrt_dbus.h
@@ -16,14 +16,17 @@
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
-#ifndef ABRT_UTIL_DBUS_H
-#define ABRT_UTIL_DBUS_H
+#ifndef ABRT_DBUS_H
+#define ABRT_DBUS_H
 
 #include <dbus/dbus.h>
-#include <map>
-#include <vector>
 #include "abrtlib.h"
 
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 extern DBusConnection* g_dbus_conn;
 
 /*
@@ -41,7 +44,7 @@ extern DBusConnection* g_dbus_conn;
  * - client which does not receive signals (only makes calls and emits signals):
  *  conn = dbus_bus_get(DBUS_BUS_SYSTEM/SESSION, &err);
  *  // needed only if you need to use async dbus calls (not shown below):
- *  attach_dbus_conn_to_glib_main_loop(conn);
+ *  attach_dbus_conn_to_glib_main_loop(conn, NULL, NULL);
  *  // syncronous method call:
  *  msg = dbus_message_new_method_call("some.serv", "/path/on/serv", "optional.iface.on.serv", "method_name");
  *  reply = dbus_connection_send_with_reply_and_block(conn, msg, timeout, &err);
@@ -53,7 +56,7 @@ extern DBusConnection* g_dbus_conn;
  *
  * - client which receives and processes signals:
  *  conn = dbus_bus_get(DBUS_BUS_SYSTEM/SESSION, &err);
- *  attach_dbus_conn_to_glib_main_loop(conn);
+ *  attach_dbus_conn_to_glib_main_loop(conn, NULL, NULL);
  *  dbus_connection_add_filter(conn, handle_message, NULL, NULL)
  *  dbus_bus_add_match(system_conn, "type='signal',...", &err);
  *  // signal is a dbus message which looks like this:
@@ -65,16 +68,14 @@ extern DBusConnection* g_dbus_conn;
  */
 void attach_dbus_conn_to_glib_main_loop(DBusConnection* conn,
     /* NULL if you are just a client */
-    const char* object_path_to_register = NULL,
+    const char* object_path_to_register,
     /* makes sense only if you use object_path_to_register: */
-    DBusHandlerResult (*message_received_func)(DBusConnection *conn, DBusMessage *msg, void* data) = NULL
+    DBusHandlerResult (*message_received_func)(DBusConnection *conn, DBusMessage *msg, void* data)
 );
 
-
 /*
  * Helpers for building DBus messages
  */
-
 //void store_bool(DBusMessageIter* iter, bool val);
 void store_int32(DBusMessageIter* iter, int32_t val);
 void store_uint32(DBusMessageIter* iter, uint32_t val);
@@ -82,6 +83,42 @@ void store_int64(DBusMessageIter* iter, int64_t val);
 void store_uint64(DBusMessageIter* iter, uint64_t val);
 void store_string(DBusMessageIter* iter, const char* val);
 
+/*
+ * Helpers for parsing DBus messages
+ */
+enum {
+    ABRT_DBUS_ERROR = -1,
+    ABRT_DBUS_LAST_FIELD = 0,
+    ABRT_DBUS_MORE_FIELDS = 1,
+    /* note that dbus_message_iter_next() returns FALSE on last field
+     * and TRUE if there are more fields.
+     * It maps exactly on the above constants. */
+};
+/* Checks type, loads data, advances to the next arg.
+ * Returns TRUE if next arg exists.
+ */
+//int load_bool(DBusMessageIter* iter, bool& val);
+int load_int32(DBusMessageIter* iter, int32_t *val);
+int load_uint32(DBusMessageIter* iter, uint32_t *val);
+int load_int64(DBusMessageIter* iter, int64_t *val);
+int load_uint64(DBusMessageIter* iter, uint64_t *val);
+int load_charp(DBusMessageIter* iter, const char **val);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* C++ style stuff */
+#ifdef __cplusplus
+
+#include <map>
+#include <vector>
+
+/*
+ * Helpers for building DBus messages
+ */
+
 //static inline void store_val(DBusMessageIter* iter, bool val)               { store_bool(iter, val); }
 static inline void store_val(DBusMessageIter* iter, int32_t val)            { store_int32(iter, val); }
 static inline void store_val(DBusMessageIter* iter, uint32_t val)           { store_uint32(iter, val); }
@@ -168,33 +205,16 @@ static inline void store_val(DBusMessageIter* iter, const std::map<K,V>& val)  {
  * Helpers for parsing DBus messages
  */
 
-enum {
-    ABRT_DBUS_ERROR = -1,
-    ABRT_DBUS_LAST_FIELD = 0,
-    ABRT_DBUS_MORE_FIELDS = 1,
-    /* note that dbus_message_iter_next() returns FALSE on last field
-     * and TRUE if there are more fields.
-     * It maps exactly on the above constants. */
-};
-/* Checks type, loads data, advances to the next arg.
- * Returns TRUE if next arg exists.
- */
-//int load_bool(DBusMessageIter* iter, bool& val);
-int load_int32(DBusMessageIter* iter, int32_t &val);
-int load_uint32(DBusMessageIter* iter, uint32_t &val);
-int load_int64(DBusMessageIter* iter, int64_t &val);
-int load_uint64(DBusMessageIter* iter, uint64_t &val);
-int load_charp(DBusMessageIter* iter, const char*& val);
-//static inline int load_val(DBusMessageIter* iter, bool &val)        { return load_bool(iter, val); }
-static inline int load_val(DBusMessageIter* iter, int32_t &val)     { return load_int32(iter, val); }
-static inline int load_val(DBusMessageIter* iter, uint32_t &val)    { return load_uint32(iter, val); }
-static inline int load_val(DBusMessageIter* iter, int64_t &val)     { return load_int64(iter, val); }
-static inline int load_val(DBusMessageIter* iter, uint64_t &val)    { return load_uint64(iter, val); }
-static inline int load_val(DBusMessageIter* iter, const char*& val) { return load_charp(iter, val); }
+//static inline int load_val(DBusMessageIter* iter, bool &val)        { return load_bool(iter, &val); }
+static inline int load_val(DBusMessageIter* iter, int32_t &val)     { return load_int32(iter, &val); }
+static inline int load_val(DBusMessageIter* iter, uint32_t &val)    { return load_uint32(iter, &val); }
+static inline int load_val(DBusMessageIter* iter, int64_t &val)     { return load_int64(iter, &val); }
+static inline int load_val(DBusMessageIter* iter, uint64_t &val)    { return load_uint64(iter, &val); }
+static inline int load_val(DBusMessageIter* iter, const char*& val) { return load_charp(iter, &val); }
 static inline int load_val(DBusMessageIter* iter, std::string& val)
 {
     const char* str;
-    int r = load_charp(iter, str);
+    int r = load_charp(iter, &str);
     val = str;
     return r;
 }
@@ -299,4 +319,6 @@ static inline int load_val(DBusMessageIter* iter, std::vector<E>& val) { return
 template<typename K, typename V>
 static inline int load_val(DBusMessageIter* iter, std::map<K,V>& val)  { return load_map(iter, val); }
 
+#endif /* __cplusplus */
+
 #endif
diff --git a/src/applet/Applet.cpp b/src/applet/Applet.cpp
index 7529e854..b83c3d2c 100644
--- a/src/applet/Applet.cpp
+++ b/src/applet/Applet.cpp
@@ -242,7 +242,7 @@ int main(int argc, char** argv)
     dbus_error_init(&err);
     DBusConnection* system_conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
     die_if_dbus_error(system_conn == NULL, &err, "Can't connect to system dbus");
-    attach_dbus_conn_to_glib_main_loop(system_conn);
+    attach_dbus_conn_to_glib_main_loop(system_conn, NULL, NULL);
     if (!dbus_connection_add_filter(system_conn, handle_message, NULL, NULL))
         error_msg_and_die("Can't add dbus filter");
     /* which messages do we want to be fed to handle_message()? */