dbind/dbind.c

   1 #include "config.h"
   2 #include <stdio.h>
   3 #define DBUS_API_SUBJECT_TO_CHANGE
   4 #include <dbind/dbind.h>
   5 #include <dbind/dbind-any.h>
   6 #include <glib.h>
   7 #include <stdarg.h>
   8
   9 /*
  10  * FIXME: compare types - to ensure they match &
  11  *        do dynamic padding of structures etc.
  12  */
  13
  14 struct _DBindContext {
  15     DBusConnection *cnx;
  16 };
  17
  18 DBindContext *
  19 dbind_create_context (DBusBusType type, DBusError *opt_error)
  20 {
  21     DBindContext *ctx = NULL;
  22     DBusConnection *cnx;
  23     DBusError *err, real_err;
  24
  25     if (opt_error)
  26         err = opt_error;
  27     else {
  28         dbus_error_init (&real_err);
  29         err = &real_err;
  30     }
  31
  32     cnx = dbus_bus_get (DBUS_BUS_SESSION, err);
  33     if (!cnx)
  34         goto out;
  35
  36     ctx = g_new0 (DBindContext, 1);
  37     ctx->cnx = cnx;
  38
  39 out:
  40     if (err == &real_err)
  41         dbus_error_free (err);
  42
  43     return ctx;
  44 }
  45
  46 void
  47 dbind_context_free (DBindContext *ctx)
  48 {
  49     if (!ctx)
  50         return;
  51     dbus_connection_unref (ctx->cnx);
  52     g_free (ctx);
  53 }
  54
  55 dbus_bool_t
  56 dbind_context_method_call (DBindContext *ctx,
  57                            const char *bus_name,
  58                            const char *path,
  59                            const char *interface,
  60                            const char *method,
  61                            DBusError *opt_error,
  62                            const char *arg_types,
  63                            ...)
  64 {
  65     dbus_bool_t success;
  66     va_list args;
  67
  68     va_start (args, arg_types);
  69
  70     success = dbind_connection_method_call_va
  71         (ctx->cnx, bus_name, path, interface, method, opt_error, arg_types, args);
  72
  73     va_end (args);
  74
  75     return success;
  76 }
  77
  78 dbus_bool_t
  79 dbind_connection_method_call (DBusConnection *cnx,
  80                               const char *bus_name,
  81                               const char *path,
  82                               const char *interface,
  83                               const char *method,
  84                               DBusError *opt_error,
  85                               const char *arg_types,
  86                               ...)
  87 {
  88     dbus_bool_t success;
  89     va_list args;
  90
  91     va_start (args, arg_types);
  92
  93     success = dbind_connection_method_call_va
  94         (cnx, bus_name, path, interface, method, opt_error, arg_types, args);
  95
  96     va_end (args);
  97
  98     return success;
  99 }
 100
 101 static void set_reply (DBusPendingCall *pending, void *user_data)
 102 {
 103   void **replyptr = (void **)user_data;
 104
 105   *replyptr = dbus_pending_call_steal_reply (pending);
 106 }
 107
 108 static DBusMessage *
 109 send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, int timeout, DBusError *error)
 110 {
 111   DBusPendingCall *pending;
 112   DBusMessage *reply = NULL;
 113
 114   if (!dbus_connection_send_with_reply (bus, message, &pending, timeout))
 115   {
 116     return NULL;
 117   }
 118   dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
 119   while (!reply)
 120   {
 121     if (!dbus_connection_read_write_dispatch (bus, timeout)) return NULL;
 122   }
 123   return reply;
 124 }
 125
 126 dbus_bool_t
 127 dbind_connection_method_call_va (DBusConnection *cnx,
 128                                  const char *bus_name,
 129                                  const char *path,
 130                                  const char *interface,
 131                                  const char *method,
 132                                  DBusError *opt_error,
 133                                  const char *arg_types,
 134                                  va_list     args)
 135 {
 136     dbus_bool_t success = FALSE;
 137     DBusMessage *msg = NULL, *reply = NULL;
 138     DBusError *err, real_err;
 139     char *p;
 140
 141     if (opt_error)
 142         err = opt_error;
 143     else {
 144         dbus_error_init (&real_err);
 145         err = &real_err;
 146     }
 147
 148     msg = dbus_message_new_method_call (bus_name, path, interface, method);
 149     if (!msg)
 150         goto out;
 151     dbus_message_set_auto_start (msg, TRUE);
 152
 153     /* marshal */
 154     p = (char *)arg_types;
 155     {
 156         DBusMessageIter iter;
 157
 158         dbus_message_iter_init_append (msg, &iter);
 159         /* special case base-types since we need to walk the stack worse-luck */
 160         for (;*p != '\0' && *p != '=';) {
 161             int intarg;
 162             void *ptrarg;
 163             double doublearg;
 164             dbus_int64_t int64arg;
 165             void *arg = NULL;
 166
 167             switch (*p) {
 168             case DBUS_TYPE_BYTE:
 169             case DBUS_TYPE_BOOLEAN:
 170             case DBUS_TYPE_INT16:
 171             case DBUS_TYPE_UINT16:
 172             case DBUS_TYPE_INT32:
 173             case DBUS_TYPE_UINT32:
 174                 intarg = va_arg (args, int);
 175                 arg = &intarg;
 176                 break;
 177             case DBUS_TYPE_INT64:
 178             case DBUS_TYPE_UINT64:
 179                 int64arg = va_arg (args, dbus_int64_t);
 180                 arg = &int64arg;
 181                 break;
 182             case DBUS_TYPE_DOUBLE:
 183                 doublearg = va_arg (args, double);
 184                 arg = &doublearg;
 185                 break;
 186             /* ptr types */
 187             case DBUS_TYPE_STRING:
 188             case DBUS_TYPE_OBJECT_PATH:
 189             case DBUS_TYPE_SIGNATURE:
 190             case DBUS_TYPE_ARRAY:
 191             case DBUS_TYPE_DICT_ENTRY:
 192                 ptrarg = va_arg (args, void *);
 193                 arg = &ptrarg;
 194                 break;
 195             case DBUS_STRUCT_BEGIN_CHAR:
 196                 ptrarg = va_arg (args, void *);
 197                 arg = ptrarg;
 198                 break;
 199
 200             case DBUS_TYPE_VARIANT:
 201                 fprintf (stderr, "No variant support yet - very toolkit specific\n");
 202                 ptrarg = va_arg (args, void *);
 203                 arg = &ptrarg;
 204                 break;
 205             default:
 206                 fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
 207                 break;
 208             }
 209             if (arg != NULL)
 210                 dbind_any_marshal (&iter, &p, &arg);
 211             }
 212     }
 213
 214     if (!strcmp (dbus_bus_get_unique_name(cnx), dbus_message_get_destination(msg)))
 215     {
 216       /* Can't use dbus_message_send_with_reply_and_block because it will
 217        * not pass messages on to the provider side, causing deadlock */
 218       reply = send_and_allow_reentry (cnx, msg, -1, err);
 219     }
 220     else
 221     {
 222       reply = dbus_connection_send_with_reply_and_block (cnx, msg, -1, err);
 223     }
 224     if (!reply)
 225         goto out;
 226
 227     if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
 228     {
 229       char *name = dbus_message_get_error_name (reply);
 230       dbus_set_error (err, name, g_strdup (""));
 231       goto out;
 232     }
 233     /* demarshal */
 234     if (p[0] == '=' && p[1] == '>')
 235     {
 236         DBusMessageIter iter;
 237         p += 2;
 238         dbus_message_iter_init (reply, &iter);
 239         for (;*p != '\0';) {
 240             void *arg = va_arg (args, void *);
 241             dbind_any_demarshal (&iter, &p, &arg);
 242         }
 243     }
 244
 245     success = TRUE;
 246 out:
 247     if (msg)
 248         dbus_message_unref (msg);
 249
 250     if (reply)
 251         dbus_message_unref (reply);
 252
 253     if (err == &real_err)
 254         dbus_error_free (err);
 255
 256     return success;
 257 }
 258