From 965e2c893488164c6b36ec1942e762bb42e7fb61 Mon Sep 17 00:00:00 2001 From: Denys Vlasenko Date: Thu, 17 Sep 2009 00:54:45 +0200 Subject: remove C++ dbus glue in src/CLI; fix a bug in --report Several kb of code removed. The nly remaining use of C++ glue is desktop applet. Signed-off-by: Denys Vlasenko --- lib/Utils/Makefile.am | 1 + lib/Utils/abrt_dbus.cpp | 112 ++++++++++++++++++++++++ lib/Utils/abrt_dbus.h | 226 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 339 insertions(+) create mode 100644 lib/Utils/abrt_dbus.cpp create mode 100644 lib/Utils/abrt_dbus.h (limited to 'lib') diff --git a/lib/Utils/Makefile.am b/lib/Utils/Makefile.am index b662ae9a..cef82d9d 100644 --- a/lib/Utils/Makefile.am +++ b/lib/Utils/Makefile.am @@ -9,6 +9,7 @@ libABRTUtils_la_SOURCES = \ DebugDump.h DebugDump.cpp \ DBusClientProxy.h DBusClientProxy.cpp \ CommLayerInner.h CommLayerInner.cpp \ + abrt_dbus.h abrt_dbus.cpp \ Plugin.h Plugin.cpp \ Polkit.h Polkit.cpp \ Action.h Database.h Reporter.h Analyzer.h \ diff --git a/lib/Utils/abrt_dbus.cpp b/lib/Utils/abrt_dbus.cpp new file mode 100644 index 00000000..3d868b9d --- /dev/null +++ b/lib/Utils/abrt_dbus.cpp @@ -0,0 +1,112 @@ +#include +#include "abrtlib.h" +#include "abrt_dbus.h" + +DBusConnection* g_dbus_conn; + +/* + * Helpers for building DBus messages + */ + +//void store_bool(DBusMessageIter* iter, bool val) +//{ +// dbus_bool_t db = val; +// if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &db)) +// die_out_of_memory(); +//} +void store_int32(DBusMessageIter* iter, int32_t val) +{ + if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT32, &val)) + die_out_of_memory(); +} +void store_uint32(DBusMessageIter* iter, uint32_t val) +{ + if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &val)) + die_out_of_memory(); +} +void store_int64(DBusMessageIter* iter, int64_t val) +{ + if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT64, &val)) + die_out_of_memory(); +} +void store_uint64(DBusMessageIter* iter, uint64_t val) +{ + if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT64, &val)) + die_out_of_memory(); +} +void store_string(DBusMessageIter* iter, const char* val) +{ + if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &val)) + die_out_of_memory(); +} + +/* + * Helpers for parsing DBus messages + */ + +//int load_bool(DBusMessageIter* iter, bool& val) +//{ +// int type = dbus_message_iter_get_arg_type(iter); +// if (type != DBUS_TYPE_BOOLEAN) +// error_msg_and_die("%s expected in dbus message, but not found ('%c')", "bool", type); +// dbus_bool_t db; +// dbus_message_iter_get_basic(iter, &db); +// val = db; +// return dbus_message_iter_next(iter); +//} +int load_int32(DBusMessageIter* iter, int32_t& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_INT32) + { + error_msg("%s expected in dbus message, but not found ('%c')", "int32", type); + return -1; + } + dbus_message_iter_get_basic(iter, &val); + return dbus_message_iter_next(iter); +} +int load_uint32(DBusMessageIter* iter, uint32_t& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_UINT32) + { + error_msg("%s expected in dbus message, but not found ('%c')", "uint32", type); + return -1; + } + dbus_message_iter_get_basic(iter, &val); + return dbus_message_iter_next(iter); +} +int load_int64(DBusMessageIter* iter, int64_t& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_INT64) + { + error_msg("%s expected in dbus message, but not found ('%c')", "int64", type); + return -1; + } + dbus_message_iter_get_basic(iter, &val); + return dbus_message_iter_next(iter); +} +int load_uint64(DBusMessageIter* iter, uint64_t& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_UINT64) + { + error_msg("%s expected in dbus message, but not found ('%c')", "uint64", type); + return -1; + } + dbus_message_iter_get_basic(iter, &val); + return dbus_message_iter_next(iter); +} +int load_charp(DBusMessageIter* iter, const char*& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_STRING) + { + 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); + return dbus_message_iter_next(iter); +} diff --git a/lib/Utils/abrt_dbus.h b/lib/Utils/abrt_dbus.h new file mode 100644 index 00000000..e2bf9fbf --- /dev/null +++ b/lib/Utils/abrt_dbus.h @@ -0,0 +1,226 @@ +#include +#include +#include +#include "abrtlib.h" + +extern DBusConnection* g_dbus_conn; + +/* + * 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); +void store_int64(DBusMessageIter* iter, int64_t val); +void store_uint64(DBusMessageIter* iter, uint64_t val); +void store_string(DBusMessageIter* iter, const char* val); + +//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); } +static inline void store_val(DBusMessageIter* iter, int64_t val) { store_int64(iter, val); } +static inline void store_val(DBusMessageIter* iter, uint64_t val) { store_uint64(iter, val); } +static inline void store_val(DBusMessageIter* iter, const char* val) { store_string(iter, val); } +static inline void store_val(DBusMessageIter* iter, const std::string& val) { store_string(iter, val.c_str()); } + +/* Templates for vector and map */ +template struct abrt_dbus_type {}; +//template <> struct abrt_dbus_type { static const char* csig() { return "b"; } }; +template <> struct abrt_dbus_type { static const char* csig() { return "i"; } static std::string sig(); }; +template <> struct abrt_dbus_type { static const char* csig() { return "u"; } static std::string sig(); }; +template <> struct abrt_dbus_type { static const char* csig() { return "x"; } static std::string sig(); }; +template <> struct abrt_dbus_type { static const char* csig() { return "t"; } static std::string sig(); }; +template <> struct abrt_dbus_type { static const char* csig() { return "s"; } static std::string sig(); }; +#define ABRT_DBUS_SIG(T) (abrt_dbus_type::csig() ? abrt_dbus_type::csig() : abrt_dbus_type::sig().c_str()) +template +struct abrt_dbus_type< std::vector > { + static const char* csig() { return NULL; } + static std::string sig() { return ssprintf("a%s", ABRT_DBUS_SIG(E)); } +}; +template +struct abrt_dbus_type< std::map > { + static const char* csig() { return NULL; } + static std::string sig() { return ssprintf("a{%s%s}", ABRT_DBUS_SIG(K), ABRT_DBUS_SIG(V)); } +}; + +template +static void store_vector(DBusMessageIter* iter, const std::vector& val) +{ + DBusMessageIter sub_iter; + if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, ABRT_DBUS_SIG(E), &sub_iter)) + die_out_of_memory(); + + typename std::vector::const_iterator vit = val.begin(); + for (; vit != val.end(); ++vit) + { + store_val(&sub_iter, *vit); + } + + if (!dbus_message_iter_close_container(iter, &sub_iter)) + die_out_of_memory(); +} +/* +template<> +static void store_vector(DBus::MessageIter &iter, const std::vector& val) +{ + if we use such vector, MUST add specialized code here (see in dbus-c++ source) +} +*/ +template +static void store_map(DBusMessageIter* iter, const std::map& val) +{ + DBusMessageIter sub_iter; + if (!dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, + ssprintf("{%s%s}", ABRT_DBUS_SIG(K), ABRT_DBUS_SIG(V)).c_str(), + &sub_iter)) + die_out_of_memory(); + + typename std::map::const_iterator mit = val.begin(); + for (; mit != val.end(); ++mit) + { + DBusMessageIter sub_sub_iter; + if (!dbus_message_iter_open_container(&sub_iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub_sub_iter)) + die_out_of_memory(); + store_val(&sub_sub_iter, mit->first); + store_val(&sub_sub_iter, mit->second); + if (!dbus_message_iter_close_container(&sub_iter, &sub_sub_iter)) + die_out_of_memory(); + } + + if (!dbus_message_iter_close_container(iter, &sub_iter)) + die_out_of_memory(); +} + +template +static inline void store_val(DBusMessageIter* iter, const std::vector& val) { store_vector(iter, val); } +template +static inline void store_val(DBusMessageIter* iter, const std::map& val) { store_map(iter, val); } + + +/* + * Helpers for parsing DBus messages + */ + +enum { + ABRT_DBUS_ERROR = -1, + ABRT_DBUS_LAST_FIELD = 0, + ABRT_DBUS_MORE_FIELDS = 1, +}; +/* 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, std::string& val) +{ + const char* str; + int r = load_charp(iter, str); + val = str; + return r; +} + +/* Templates for vector and map */ +template +static int load_vector(DBusMessageIter* iter, std::vector& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_ARRAY) + { + error_msg("array expected in dbus message, but not found ('%c')", type); + return -1; + } + + DBusMessageIter sub_iter; + dbus_message_iter_recurse(iter, &sub_iter); + + int r; +//int cnt = 0; + //type = dbus_message_iter_get_arg_type(&sub_iter); + /* here "type" is the element's type, and it will be checked by load_val */ + // if (type != DBUS_TYPE_INVALID) - not needed? + do { + E elem; +//cnt++; + r = load_val(&sub_iter, elem); + if (r < 0) + return r; + val.push_back(elem); + } while (r == ABRT_DBUS_MORE_FIELDS); +//log("%s: %d elems", __func__, cnt); + + return dbus_message_iter_next(iter); +} +/* +template<> +static int load_vector(DBusMessageIter* iter, std::vector& val) +{ + if we use such vector, MUST add specialized code here (see in dbus-c++ source) +} +*/ +template +static int load_map(DBusMessageIter* iter, std::map& val) +{ + int type = dbus_message_iter_get_arg_type(iter); + if (type != DBUS_TYPE_ARRAY) + { + error_msg("array expected in dbus message, but not found ('%c')", type); + return -1; + } + + DBusMessageIter sub_iter; + dbus_message_iter_recurse(iter, &sub_iter); + + bool next_exists; + int r; +//int cnt = 0; + do { + type = dbus_message_iter_get_arg_type(&sub_iter); + if (type != DBUS_TYPE_DICT_ENTRY) + { + error_msg("sub_iter type is not DBUS_TYPE_DICT_ENTRY (%c)!", type); + return -1; + } + + DBusMessageIter sub_sub_iter; + dbus_message_iter_recurse(&sub_iter, &sub_sub_iter); + + K key; + r = load_val(&sub_sub_iter, key); + if (r != ABRT_DBUS_MORE_FIELDS) + { + if (r == ABRT_DBUS_LAST_FIELD) + error_msg("malformed map element in dbus message"); + return -1; + } + V value; + r = load_val(&sub_sub_iter, value); + if (r != ABRT_DBUS_LAST_FIELD) + { + if (r == ABRT_DBUS_MORE_FIELDS) + error_msg("malformed map element in dbus message"); + return -1; + } + val[key] = value; +//cnt++; + next_exists = dbus_message_iter_next(&sub_iter); + } while (next_exists); +//log("%s: %d elems", __func__, cnt); + + return dbus_message_iter_next(iter); +} + +template +static inline int load_val(DBusMessageIter* iter, std::vector& val) { return load_vector(iter, val); } +template +static inline int load_val(DBusMessageIter* iter, std::map& val) { return load_map(iter, val); } -- cgit