--- /dev/null
+lib_LTLIBRARIES = libdbind.la
+
+INCLUDES = \
+ -DG_LOG_DOMAIN=\"dbind\" \
+ -I$(top_srcdir) \
+ $(WARN_CFLAGS) \
+ $(DBUS_CFLAGS) \
+ $(GLIB_CFLAGS)
+
+libdbindinclude_HEADERS = \
+ dbind-any.h \
+ dbind.h
+libdbindincludedir=$(includedir)/dbind-0.1
+
+libdbind_la_SOURCES = \
+ dbind.c \
+ dbind-any.c
+libdbind_la_LIBADD = $(DBUS_LIBS) $(GLIB_LIBS)
+
+TESTS = dbtest
+
+check_PROGRAMS = dbtest
+dbtest_SOURCES = dbtest.c
+dbtest_LDFLAGS = libdbind.la
\ No newline at end of file
--- /dev/null
+/* type driven marshalling */
+#include "config.h"
+#include "dbind-config.h"
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <stdio.h>
+#include <glib.h>
+#include "dbind-any.h"
+
+#undef DEBUG
+
+/* Align a value upward to a boundary, expressed as a number of bytes.
+ E.g. align to an 8-byte boundary with argument of 8. */
+
+/*
+ * (this + boundary - 1)
+ * &
+ * ~(boundary - 1)
+ */
+
+#define ALIGN_VALUE(this, boundary) \
+ (( ((gulong)(this)) + (((gulong)(boundary)) -1)) & (~(((gulong)(boundary))-1)))
+
+#define ALIGN_ADDRESS(this, boundary) \
+ ((gpointer)ALIGN_VALUE(this, boundary))
+
+#define PTR_PLUS(ptr, offset) \
+ ((gpointer) (((guchar *)(ptr)) + (offset)))
+
+unsigned int dbind_find_c_alignment_r (char **type);
+unsigned int dbind_find_c_alignment (char *type);
+
+static void
+warn_braces ()
+{
+ fprintf (stderr, "Error: dbus flags structures & dicts with braces rather than "
+ " an explicit type member of 'struct'\n");
+}
+
+/* gather immediate allocation information for this type */
+size_t dbind_gather_alloc_info_r (char **type)
+{
+ char t = **type;
+ (*type)++;
+ if (t == DBUS_TYPE_ARRAY) {
+ switch (**type) {
+ case DBUS_STRUCT_BEGIN_CHAR:
+ while (**type != DBUS_STRUCT_END_CHAR && **type != '\0') (*type)++;
+ if (**type != '\0') (*type)++;
+ break;
+ case '\0':
+ break;
+ default:
+ (*type)++;
+ break;
+ }
+ }
+
+ switch (t) {
+ case DBUS_TYPE_BYTE:
+ return sizeof (char);
+ case DBUS_TYPE_BOOLEAN:
+ return sizeof (dbus_bool_t);
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ return sizeof (dbus_int16_t);
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ return sizeof (dbus_int32_t);
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ return sizeof (dbus_int64_t);
+ case DBUS_TYPE_DOUBLE:
+ return sizeof (double);
+ /* ptr types */
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ case DBUS_TYPE_ARRAY:
+ return sizeof (void *);
+ case DBUS_STRUCT_BEGIN_CHAR: {
+ int sum = 0, stralign;
+
+ stralign = dbind_find_c_alignment (*type - 1);
+
+ while (**type != DBUS_STRUCT_END_CHAR) {
+ sum = ALIGN_VALUE (sum, dbind_find_c_alignment (*type));
+ sum += dbind_gather_alloc_info_r (type);
+ }
+ sum = ALIGN_VALUE (sum, stralign);
+
+ g_assert (**type == DBUS_STRUCT_END_CHAR);
+ (*type)++;
+
+ return sum;
+ }
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ warn_braces ();
+ default:
+ return 0;
+ }
+}
+
+size_t dbind_gather_alloc_info (char *type)
+{
+ return dbind_gather_alloc_info_r (&type);
+}
+
+unsigned int
+dbind_find_c_alignment_r (char **type)
+{
+ unsigned int retval = 1;
+
+ char t = **type;
+ (*type)++;
+
+#ifdef DEBUG
+ fprintf (stderr, "\tfind align for %c (0x%x)\n", t, t);
+#endif
+
+ switch (t) {
+ case DBUS_TYPE_BYTE:
+ return DBIND_ALIGNOF_CHAR;
+ case DBUS_TYPE_BOOLEAN:
+ return DBIND_ALIGNOF_DBUS_BOOL_T;
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ return DBIND_ALIGNOF_DBUS_INT16_T;
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ return DBIND_ALIGNOF_DBUS_INT32_T;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ return DBIND_ALIGNOF_DBUS_INT64_T;
+ case DBUS_TYPE_DOUBLE:
+ return DBIND_ALIGNOF_DOUBLE;
+ /* ptr types */
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ case DBUS_TYPE_ARRAY:
+ return DBIND_ALIGNOF_DBIND_POINTER;
+ case DBUS_STRUCT_BEGIN_CHAR:
+#if DBIND_ALIGNOF_DBIND_STRUCT > 1
+ retval = MAX (retval, DBIND_ALIGNOF_DBIND_STRUCT);
+#endif
+ while (**type != DBUS_STRUCT_END_CHAR) {
+ int elem_align = dbind_find_c_alignment_r (type);
+ retval = MAX (retval, elem_align);
+ }
+ (*type)++;
+ return retval;
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ warn_braces ();
+ return DBIND_ALIGNOF_DBIND_POINTER;
+ case '\0':
+ g_assert_not_reached();
+ break;
+ default:
+ return 1;
+ }
+}
+
+unsigned int
+dbind_find_c_alignment (char *type)
+{
+ return dbind_find_c_alignment_r (&type);
+}
+
+#define DBIND_POD_CASES \
+ DBUS_TYPE_BYTE: \
+ case DBUS_TYPE_INT16: \
+ case DBUS_TYPE_UINT16: \
+ case DBUS_TYPE_INT32: \
+ case DBUS_TYPE_UINT32: \
+ case DBUS_TYPE_BOOLEAN: \
+ case DBUS_TYPE_INT64: \
+ case DBUS_TYPE_UINT64: \
+ case DBUS_TYPE_DOUBLE
+
+void
+dbind_any_marshal (DBusMessageIter *iter,
+ char **type,
+ void **data)
+{
+ size_t len;
+
+#ifdef DEBUG
+ fprintf (stderr, "any marshal '%c' to %p\n", **type, *data);
+#endif
+
+ switch (**type) {
+ case DBIND_POD_CASES:
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ len = dbind_gather_alloc_info (*type);
+ dbus_message_iter_append_basic (iter, **type, *data);
+ *data = ((guchar *)*data) + len;
+ (*type)++;
+ break;
+ case DBUS_TYPE_ARRAY: {
+ int i;
+ GArray *vals = **(void ***)data;
+ size_t elem_size, elem_align;
+ DBusMessageIter sub;
+ char *saved_child_type, *child_type_string;
+
+ (*type)++;
+ saved_child_type = *type;
+
+ elem_size = dbind_gather_alloc_info (*type);
+ elem_align = dbind_find_c_alignment_r (type);
+
+ /* wow this part of the API sucks too ... */
+ child_type_string = g_strndup (saved_child_type, *type - saved_child_type);
+/* fprintf (stderr, "array child type '%s'\n", child_type_string); */
+ dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
+ child_type_string, &sub);
+ for (i = 0; i < vals->len; i++) {
+ void *ptr = vals->data + elem_size * i;
+ *type = saved_child_type; /* rewind type info */
+ ptr = ALIGN_ADDRESS (ptr, elem_align);
+ dbind_any_marshal (&sub, type, &ptr);
+ }
+
+ dbus_message_iter_close_container (iter, &sub);
+ g_free (child_type_string);
+ break;
+ }
+ case DBUS_STRUCT_BEGIN_CHAR: {
+ gconstpointer data0 = *data;
+ int offset = 0, stralign;
+ DBusMessageIter sub;
+
+ stralign = dbind_find_c_alignment (*type);
+
+ (*type)++;
+
+ dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &sub);
+
+ offset = 0 ;
+ while (**type != DBUS_STRUCT_END_CHAR) {
+ char *subt = *type;
+ offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+ *data = PTR_PLUS (data0, offset);
+ dbind_any_marshal (&sub, type, data);
+ offset += dbind_gather_alloc_info (subt);
+ }
+
+ offset = ALIGN_VALUE (offset, stralign);
+ *data = PTR_PLUS (data0, offset);
+
+ dbus_message_iter_close_container (iter, &sub);
+
+ g_assert (**type == DBUS_STRUCT_END_CHAR);
+ (*type)++;
+
+ break;
+ }
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ warn_braces ();
+ break;
+ }
+}
+
+void
+dbind_any_demarshal (DBusMessageIter *iter,
+ char **type,
+ void **data)
+{
+ size_t len;
+
+#ifdef DEBUG
+ fprintf (stderr, "any demarshal '%c' to %p\n", **type, *data);
+#endif
+
+ switch (**type) {
+ case DBIND_POD_CASES:
+ len = dbind_gather_alloc_info (*type);
+ dbus_message_iter_get_basic (iter, *data);
+ *data = ((guchar *)*data) + len;
+ (*type)++;
+ break;
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ len = dbind_gather_alloc_info (*type);
+ dbus_message_iter_get_basic (iter, *data);
+#ifdef DEBUG
+ fprintf (stderr, "dup string '%s' (%p)\n", **(void ***)data, **(void ***)data);
+#endif
+ **(void ***)data = g_strdup (**(void ***)data);
+ *data = ((guchar *)*data) + len;
+ (*type)++;
+ break;
+ case DBUS_TYPE_ARRAY: {
+ GArray *vals;
+ DBusMessageIter child;
+ size_t elem_size, elem_align;
+ char *stored_child_type;
+ int i;
+
+ (*type)++;
+ stored_child_type = *type;
+
+ elem_size = dbind_gather_alloc_info (*type);
+ elem_align = dbind_find_c_alignment_r (type);
+ vals = g_array_new (FALSE, FALSE, elem_size);
+ (**(void ***)data) = vals;
+ *data = ((guchar *)*data) + sizeof (void *);
+
+ i = 0;
+ dbus_message_iter_recurse (iter, &child);
+ while (dbus_message_iter_get_arg_type (&child) != DBUS_TYPE_INVALID) {
+ void *ptr;
+ char *subt = stored_child_type;
+ g_array_set_size (vals, i + 1);
+ ptr = vals->data + elem_size * i;
+ ptr = ALIGN_ADDRESS (ptr, elem_align);
+ dbind_any_demarshal (&child, &subt, &ptr);
+ i++;
+ };
+ break;
+ }
+ case DBUS_STRUCT_BEGIN_CHAR: {
+ gconstpointer data0 = *data;
+ int offset = 0, stralign;
+ DBusMessageIter child;
+
+ stralign = dbind_find_c_alignment (*type);
+
+ (*type)++;
+
+ dbus_message_iter_recurse (iter, &child);
+
+ while (**type != DBUS_STRUCT_END_CHAR) {
+ char *subt = *type;
+ offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+ *data = PTR_PLUS (data0, offset);
+ dbind_any_demarshal (&child, type, data);
+ offset += dbind_gather_alloc_info (subt);
+ }
+
+ offset = ALIGN_VALUE (offset, stralign);
+ *data = PTR_PLUS (data0, offset);
+
+ g_assert (**type == DBUS_STRUCT_END_CHAR);
+ (*type)++;
+
+ break;
+ }
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ warn_braces ();
+ break;
+ }
+ dbus_message_iter_next (iter);
+}
+
+static void
+dbind_any_free_r (char **type, void **data)
+{
+ size_t len;
+
+#ifdef DEBUG
+ fprintf (stderr, "any free '%c' to %p\n", **type, *data);
+#endif
+
+ switch (**type) {
+ case DBIND_POD_CASES:
+ *data = ((guchar *)*data) + dbind_gather_alloc_info (*type);
+ (*type)++;
+ break;
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+#ifdef DEBUG
+ fprintf (stderr, "string free %p\n", **(void ***)data);
+#endif
+ g_free (**(void ***)data);
+ *data = ((guchar *)*data) + dbind_gather_alloc_info (*type);
+ (*type)++;
+ break;
+ case DBUS_TYPE_ARRAY: {
+ int i;
+ GArray *vals = **(void ***)data;
+ size_t elem_size, elem_align;
+ char *saved_child_type, *child_type_string;
+
+ (*type)++;
+ saved_child_type = *type;
+
+ elem_size = dbind_gather_alloc_info (*type);
+ elem_align = dbind_find_c_alignment_r (type);
+
+ for (i = 0; i < vals->len; i++) {
+ void *ptr = vals->data + elem_size * i;
+ *type = saved_child_type; /* rewind type info */
+ ptr = ALIGN_ADDRESS (ptr, elem_align);
+ dbind_any_free_r (type, &ptr);
+ }
+ g_array_free (vals, TRUE);
+ break;
+ }
+ case DBUS_STRUCT_BEGIN_CHAR: {
+ gconstpointer data0 = *data;
+ int offset = 0, stralign;
+
+ stralign = dbind_find_c_alignment (*type);
+ (*type)++;
+
+ offset = 0 ;
+ while (**type != DBUS_STRUCT_END_CHAR) {
+ char *subt = *type;
+ offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+ *data = PTR_PLUS (data0, offset);
+ dbind_any_free_r (type, data);
+ offset += dbind_gather_alloc_info (subt);
+ }
+
+ offset = ALIGN_VALUE (offset, stralign);
+ *data = PTR_PLUS (data0, offset);
+
+ g_assert (**type == DBUS_STRUCT_END_CHAR);
+ (*type)++;
+
+ break;
+ }
+ case DBUS_TYPE_STRUCT:
+ case DBUS_TYPE_DICT_ENTRY:
+ warn_braces ();
+ break;
+ }
+}
+
+/* nice deep free ... */
+void
+dbind_any_free (char *type,
+ void *ptr)
+{
+ dbind_any_free_r (&type, &ptr);
+}
+
+/* should this be the default normalization ? */
+void
+dbind_any_free_ptr (char *type, void *ptr)
+{
+ dbind_any_free (type, &ptr);
+}
--- /dev/null
+#ifndef _DBIND_ANY_H_
+#define _DBIND_ANY_H_
+
+#include <dbus/dbus.h>
+
+size_t dbind_gather_alloc_info (char *type);
+void dbind_any_marshal (DBusMessageIter *iter,
+ char **type,
+ void **val);
+void dbind_any_demarshal (DBusMessageIter *iter,
+ char **type,
+ void **val);
+void dbind_any_free (char *type,
+ void *ptr_to_ptr);
+void dbind_any_free_ptr (char *type,
+ void *ptr);
+
+#endif /* _DBIND_ANY_H_ */
--- /dev/null
+#include "config.h"
+#include <stdio.h>
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbind/dbind.h>
+#include <dbind/dbind-any.h>
+#include <glib.h>
+#include <stdarg.h>
+
+/*
+ * FIXME: compare types - to ensure they match &
+ * do dynamic padding of structures etc.
+ */
+
+struct _DBindContext {
+ DBusConnection *cnx;
+};
+
+DBindContext *
+dbind_create_context (DBusBusType type, DBusError *opt_error)
+{
+ DBindContext *ctx = NULL;
+ DBusConnection *cnx;
+ DBusError *err, real_err;
+
+ if (opt_error)
+ err = opt_error;
+ else {
+ dbus_error_init (&real_err);
+ err = &real_err;
+ }
+
+ cnx = dbus_bus_get (DBUS_BUS_SESSION, err);
+ if (!cnx)
+ goto out;
+
+ ctx = g_new0 (DBindContext, 1);
+ ctx->cnx = cnx;
+
+out:
+ if (err == &real_err)
+ dbus_error_free (err);
+
+ return ctx;
+}
+
+void
+dbind_context_free (DBindContext *ctx)
+{
+ if (!ctx)
+ return;
+ dbus_connection_unref (ctx->cnx);
+ g_free (ctx);
+}
+
+dbus_bool_t
+dbind_context_method_call (DBindContext *ctx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ ...)
+{
+ dbus_bool_t success;
+ va_list args;
+
+ va_start (args, arg_types);
+
+ success = dbind_connection_method_call_va
+ (ctx->cnx, bus_name, path, interface, method, opt_error, arg_types, args);
+
+ va_end (args);
+
+ return success;
+}
+
+dbus_bool_t
+dbind_connection_method_call (DBusConnection *cnx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ ...)
+{
+ dbus_bool_t success;
+ va_list args;
+
+ va_start (args, arg_types);
+
+ success = dbind_connection_method_call_va
+ (cnx, bus_name, path, interface, method, opt_error, arg_types, args);
+
+ va_end (args);
+
+ return success;
+}
+
+dbus_bool_t
+dbind_connection_method_call_va (DBusConnection *cnx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ va_list args)
+{
+ dbus_bool_t success = FALSE;
+ DBusMessage *msg = NULL, *reply = NULL;
+ DBusError *err, real_err;
+ char *p;
+
+ if (opt_error)
+ err = opt_error;
+ else {
+ dbus_error_init (&real_err);
+ err = &real_err;
+ }
+
+ msg = dbus_message_new_method_call (bus_name, path, interface, method);
+ if (!msg)
+ goto out;
+ dbus_message_set_auto_start (msg, TRUE);
+
+ /* marshal */
+ p = (char *)arg_types;
+ {
+ DBusMessageIter iter;
+
+ dbus_message_iter_init_append (msg, &iter);
+ /* special case base-types since we need to walk the stack worse-luck */
+ for (;*p != '\0' && *p != '=';) {
+ int intarg;
+ void *ptrarg;
+ double doublearg;
+ dbus_int64_t int64arg;
+ void *arg = NULL;
+
+ switch (*p) {
+ case DBUS_TYPE_BYTE:
+ case DBUS_TYPE_BOOLEAN:
+ case DBUS_TYPE_INT16:
+ case DBUS_TYPE_UINT16:
+ case DBUS_TYPE_INT32:
+ case DBUS_TYPE_UINT32:
+ intarg = va_arg (args, int);
+ arg = &intarg;
+ break;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ int64arg = va_arg (args, dbus_int64_t);
+ arg = &int64arg;
+ break;
+ case DBUS_TYPE_DOUBLE:
+ doublearg = va_arg (args, double);
+ arg = &doublearg;
+ break;
+ /* ptr types */
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ case DBUS_TYPE_SIGNATURE:
+ case DBUS_TYPE_ARRAY:
+ case DBUS_STRUCT_BEGIN_CHAR:
+ case DBUS_TYPE_DICT_ENTRY:
+ ptrarg = va_arg (args, void *);
+ arg = &ptrarg;
+ break;
+
+ case DBUS_TYPE_VARIANT:
+ fprintf (stderr, "No variant support yet - very toolkit specific\n");
+ ptrarg = va_arg (args, void *);
+ arg = &ptrarg;
+ break;
+ default:
+ fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
+ break;
+ }
+ if (arg != NULL)
+ dbind_any_marshal (&iter, &p, &arg);
+ }
+ }
+
+ reply = dbus_connection_send_with_reply_and_block (cnx, msg, -1, err);
+ if (!reply)
+ goto out;
+
+ /* demarshal */
+ if (p[0] == '=' && p[1] == '>')
+ {
+ DBusMessageIter iter;
+ p += 2;
+ dbus_message_iter_init (reply, &iter);
+ for (;*p != '\0';) {
+ void *arg = va_arg (args, void *);
+ dbind_any_demarshal (&iter, &p, &arg);
+ }
+ }
+
+ success = TRUE;
+out:
+ if (msg)
+ dbus_message_unref (msg);
+
+ if (reply)
+ dbus_message_unref (reply);
+
+ if (err == &real_err)
+ dbus_error_free (err);
+
+ return success;
+}
+
--- /dev/null
+#ifndef _DBIND_H_
+#define _DBIND_H_
+
+
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbus/dbus.h>
+
+typedef struct _DBindContext DBindContext;
+
+DBindContext *dbind_create_context (DBusBusType type, DBusError *opt_error);
+void dbind_context_free (DBindContext *ctx);
+dbus_bool_t dbind_context_method_call (DBindContext *ctx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ ...);
+
+/* dbus connection variants */
+dbus_bool_t dbind_connection_method_call (DBusConnection *cnx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ ...);
+dbus_bool_t dbind_connection_method_call_va (DBusConnection *cnx,
+ const char *bus_name,
+ const char *path,
+ const char *interface,
+ const char *method,
+ DBusError *opt_error,
+ const char *arg_types,
+ va_list args);
+
+#endif /* _DBIND_H_ */
--- /dev/null
+#include <stdio.h>
+#include <glib.h>
+#include <string.h>
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbind/dbind.h>
+#include <dbind/dbind-any.h>
+
+/* Wow! dbus is unpleasant to use */
+
+#define DESKICE_PATH "/Novell/ICEDesktop/Daemon"
+#define DESKICE_NAMESPACE "Novell.ICEDesktop.Daemon"
+
+void marshal (DBusMessage *msg, char *type, void *ptr)
+{
+ DBusMessageIter iter;
+
+ dbus_message_iter_init_append (msg, &iter);
+ dbind_any_marshal (&iter, &type, &ptr);
+}
+
+void demarshal (DBusMessage *msg, char *type, void *ptr)
+{
+ DBusMessageIter iter;
+
+ if (!dbus_message_iter_init (msg, &iter))
+ fprintf (stderr, "no data in msg\n");
+ else
+ dbind_any_demarshal (&iter, &type, &ptr);
+}
+
+#if 0
+dbus_bool_t dbus_message_marshal (DBusMessage *msg,
+ char **marshalled_data_p,
+ int *len_p);
+
+void dump_msg (DBusMessage *msg)
+{
+ char *data = NULL;
+ int len, i, j;
+
+ dbus_message_marshal (msg, &data, &len);
+ for (i = 0; i < (len+15)/16; i++) {
+ fprintf (stderr, "%4.d | ", i * 16);
+ for (j = 0; j < 16; j++) {
+ unsigned char c = (i*16+j <= len) ? data[i*16+j] : 0;
+ fprintf (stderr, "0x%.2x ", c);
+ }
+ fprintf (stderr, " | ");
+ for (j = 0; j < 16; j++) {
+ char c = (i*16+j <= len) ? data[i*16+j] : '\0';
+ fprintf (stderr, "%c", g_ascii_isprint (c) ? c : '.');
+ }
+ }
+}
+#endif
+
+void test_simple ()
+{
+ dbus_int32_t v1, v2;
+ DBusMessage *msg;
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ v1 = 42;
+ marshal (msg, "i", &v1);
+ demarshal (msg, "i", &v2);
+ g_assert (v2 == 42);
+ g_assert (v1 == v2);
+
+ dbind_any_free ("i", &v2); /* nop */
+ dbus_message_unref (msg);
+
+ fprintf (stderr, "simple ok\n");
+}
+
+void test_array ()
+{
+ GArray *a1, *a2;
+ DBusMessage *msg;
+
+ /* pod types */
+ a1 = g_array_new (FALSE, FALSE, sizeof (dbus_int32_t));
+ g_array_set_size (a1, 4);
+ g_array_index (a1, dbus_int32_t, 0) = 42;
+ g_array_index (a1, dbus_int32_t, 1) = 17;
+ g_array_index (a1, dbus_int32_t, 2) = 26;
+ g_array_index (a1, dbus_int32_t, 3) = 38;
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ marshal (msg, "ai", &a1);
+ demarshal (msg, "ai", &a2);
+
+ g_assert (a2 != NULL);
+ g_assert (a2->len == 4);
+ g_assert (g_array_index (a2, dbus_int32_t, 0) == 42);
+ g_assert (g_array_index (a2, dbus_int32_t, 1) == 17);
+ g_assert (g_array_index (a2, dbus_int32_t, 2) == 26);
+ g_assert (g_array_index (a2, dbus_int32_t, 3) == 38);
+ g_array_free (a1, TRUE);
+
+ dbind_any_free ("ai", &a2);
+ dbus_message_unref (msg);
+
+ fprintf (stderr, "array ok\n");
+}
+
+/* this taught me that the struct type is a mis-nomer,
+ it is generated by brackets */
+void test_struct_native ()
+{
+ DBusMessage *msg;
+ DBusMessageIter iter, arr, str;
+
+ /* manually create ar(ss) */
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+
+ dbus_message_iter_init_append (msg, &iter);
+
+ dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ss)", &arr);
+ {
+ char *foo;
+ dbus_message_iter_open_container (&arr, DBUS_TYPE_STRUCT, NULL, &str);
+
+ foo = "foo";
+ dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
+ foo = "baa";
+ dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
+
+ dbus_message_iter_close_container (&arr, &str);
+ }
+ dbus_message_iter_close_container (&iter, &arr);
+
+ fprintf (stderr, "native struct marshalling ok\n");
+
+ dbus_message_unref (msg);
+}
+
+
+void test_struct_simple ()
+{
+ typedef struct {
+ char *foo;
+ char *baa;
+ char *baz;
+ } FooBaa;
+ GArray *a1 = NULL, *a2 = NULL;
+ DBusMessage *msg;
+
+ a1 = g_array_new (FALSE, FALSE, sizeof (FooBaa));
+ g_array_set_size (a1, 2);
+ g_array_index (a1, FooBaa, 0).foo = "foo";
+ g_array_index (a1, FooBaa, 0).baa = "baa";
+ g_array_index (a1, FooBaa, 0).baz = "baz";
+ g_array_index (a1, FooBaa, 1).foo = "Foo";
+ g_array_index (a1, FooBaa, 1).baa = "baA";
+ g_array_index (a1, FooBaa, 1).baz = "BaZ";
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ marshal (msg, "a(sss)", &a1);
+ demarshal (msg, "a(sss)", &a2);
+
+ g_assert (a2 != NULL);
+ g_assert (a2 != a1);
+ g_assert (a2->len == 2);
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 0).foo, "foo"));
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baa, "baa"));
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baz, "baz"));
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 1).foo, "Foo"));
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baa, "baA"));
+ g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baz, "BaZ"));
+
+ fprintf (stderr, "simple struct ok\n");
+
+ dbind_any_free ("a(sss)", &a2);
+ dbus_message_unref (msg);
+}
+
+void test_struct_complex ()
+{
+ typedef struct {
+ dbus_int32_t x, y;
+ } Point;
+ typedef struct {
+ unsigned char pad1;
+ double val;
+ Point tl, br;
+ char pad2;
+ char *name;
+ } Complex;
+#define TYPEOF_POINT \
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+ DBUS_TYPE_INT32_AS_STRING \
+ DBUS_TYPE_INT32_AS_STRING \
+ DBUS_STRUCT_END_CHAR_AS_STRING
+#define TYPEOF_COMPLEX \
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_DOUBLE_AS_STRING \
+ TYPEOF_POINT \
+ TYPEOF_POINT \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_TYPE_STRING_AS_STRING \
+ DBUS_STRUCT_END_CHAR_AS_STRING
+
+
+ DBusMessage *msg;
+ Complex c1, c2;
+
+ memset (&c1, 0, sizeof (c1));
+ memset (&c2, 0, sizeof (c2));
+
+ c1.pad1 = 2;
+ c1.val = 0.1327569;
+ c1.tl.x = 1;
+ c1.tl.y = 17;
+ c1.br.x = 2587;
+ c1.br.y = -1;
+ c1.pad2 = 1;
+ c1.name = "stroustrup";
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ marshal (msg, TYPEOF_COMPLEX, &c1);
+ demarshal (msg, TYPEOF_COMPLEX, &c2);
+
+ g_assert (c2.pad1 == 2);
+ g_assert (c2.val == c1.val);
+ g_assert (c2.val != 0);
+ g_assert (c2.tl.x == 1);
+ g_assert (c2.tl.y == 17);
+ g_assert (c2.br.x == 2587);
+ g_assert (c2.br.y == -1);
+ g_assert (c2.pad2 == 1);
+ g_assert (!strcmp (c1.name, "stroustrup"));
+
+ fprintf (stderr, "complex struct ok\n");
+
+ dbind_any_free (TYPEOF_COMPLEX, &c2);
+ dbus_message_unref (msg);
+}
+
+void test_struct_with_array ()
+{
+ typedef struct {
+ GArray *vals;
+ unsigned char pad1;
+ } ArrayStruct;
+#define TYPEOF_ARRAYSTRUCT \
+ DBUS_TYPE_ARRAY_AS_STRING \
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+ DBUS_TYPE_ARRAY_AS_STRING \
+ DBUS_TYPE_UINT32_AS_STRING \
+ DBUS_TYPE_BYTE_AS_STRING \
+ DBUS_STRUCT_END_CHAR_AS_STRING
+
+
+ DBusMessage *msg;
+ GArray *a1, *a2;
+ ArrayStruct *p, *q;
+
+
+ a1 = g_array_new (FALSE, FALSE, sizeof (ArrayStruct));
+ g_array_set_size (a1, 2);
+ p = &g_array_index (a1, ArrayStruct, 0);
+ p[0].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
+ g_array_set_size (p[0].vals, 2);
+ g_array_index (p[0].vals, dbus_uint32_t, 0) = 1;
+ g_array_index (p[0].vals, dbus_uint32_t, 1) = 1000;
+ p[0].pad1 = 2;
+ p[1].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
+ g_array_set_size (p[1].vals, 2);
+ g_array_index (p[1].vals, dbus_uint32_t, 0) = 1000000;
+ g_array_index (p[1].vals, dbus_uint32_t, 1) = 1000000000;
+ p[1].pad1 = 8;
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ marshal (msg, TYPEOF_ARRAYSTRUCT, &a1);
+ demarshal (msg, TYPEOF_ARRAYSTRUCT, &a2);
+
+ q = &g_array_index (a2, ArrayStruct, 0);
+ g_assert (p[0].pad1 == 2);
+ g_assert (g_array_index (p[1].vals, dbus_uint32_t, 1) == 1000000000);
+
+ fprintf (stderr, "struct with array ok\n");
+
+ dbind_any_free (TYPEOF_ARRAYSTRUCT, &a2);
+ dbus_message_unref (msg);
+ g_array_free (p[0].vals, TRUE);
+ g_array_free (p[1].vals, TRUE);
+}
+
+void test_twovals ()
+{
+ typedef struct {
+ dbus_int32_t v1;
+ dbus_int32_t v2;
+ } TwoVal;
+#define TYPEOF_TWOVAL \
+ DBUS_TYPE_INT32_AS_STRING \
+ DBUS_TYPE_INT32_AS_STRING \
+
+ DBusMessage *msg;
+ DBusMessageIter iter;
+ TwoVal i, o;
+ char *type_twoval = TYPEOF_TWOVAL;
+ char *type;
+ void *ptr;
+
+ msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+ i.v1 = 42;
+ i.v2 = 1764;
+ dbus_message_iter_init_append (msg, &iter);
+ type = type_twoval;
+ ptr = &i;
+ dbind_any_marshal (&iter, &type, &ptr);
+ dbind_any_marshal (&iter, &type, &ptr);
+ dbus_message_iter_init (msg, &iter);
+ type = type_twoval;
+ ptr = &o;
+ dbind_any_demarshal (&iter, &type, &ptr);
+ dbind_any_demarshal (&iter, &type, &ptr);
+ g_assert (o.v1 == 42);
+ g_assert (o.v2 == 1764);
+ g_assert (i.v1 == o.v1);
+ g_assert (i.v2 == o.v2);
+
+ dbind_any_free ("ii", &o); /* nop */
+ dbus_message_unref (msg);
+
+ fprintf (stderr, "two-val ok\n");
+}
+
+void test_marshalling ()
+{
+ test_simple ();
+ test_array ();
+ test_struct_native ();
+ test_struct_simple ();
+ test_struct_complex ();
+ test_struct_with_array ();
+ test_twovals ();
+
+ fprintf (stderr, "Marshalling ok\n");
+}
+
+void test_teamspaces (DBindContext *ctx)
+{
+ GArray *spaces;
+ DBusError error;
+ int i;
+ typedef struct {
+ char *name;
+ char *id;
+ char *url;
+ } TeamSpace;
+
+ dbus_error_init (&error);
+ if (!dbind_context_method_call (ctx, NULL, DESKICE_PATH, DESKICE_NAMESPACE,
+ "GetTeamList", &error,
+ "=>a(sss)", &spaces)) {
+ fprintf (stderr, "Error getting team spaces %s: %s\n",
+ error.name, error.message);
+ dbus_error_free (&error);
+ return;
+ }
+
+ if (!spaces) {
+ fprintf (stderr, "no teamspaces\n");
+ return;
+ }
+ fprintf (stderr, "%d teamspace(s)\n", spaces->len);
+ for (i = 0; i < spaces->len; i++) {
+ TeamSpace *space = &g_array_index (spaces, TeamSpace, i);
+ fprintf (stderr, "\t%d: %s, %s, %s\n", i, space->name, space->id, space->url);
+ }
+
+ dbind_any_free_ptr ("a(sss)", spaces);
+}
+
+extern dbind_find_c_alignment (char *type);
+
+void test_helpers ()
+{
+ dbind_find_c_alignment ("(sss)");
+ dbind_find_c_alignment ("a(sss)");
+ dbind_find_c_alignment ("(s(s)yd(d)s)");
+ fprintf (stderr, "helpers passed\n");
+}
+
+int main (int argc, char **argv)
+{
+ DBindContext *ctx;
+
+ ctx = dbind_create_context (DBUS_BUS_SESSION, NULL);
+ if (!ctx)
+ return 1;
+
+ test_helpers ();
+ test_marshalling ();
+ test_teamspaces (ctx);
+
+ dbind_context_free (ctx);
+
+ return 0;
+}
projects / platform / core / uifw / at-spi2-atk.git / commitdiff