src/moonshot-dbus-server.c

   1 /* moonshot-dbus-server.c generated by valac 0.10.4, the Vala compiler
   2  * generated from moonshot-dbus-server.vala, do not modify */
   3
   4
   5 #include <glib.h>
   6 #include <glib-object.h>
   7 #include <gtk/gtk.h>
   8 #include <gio/gio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <dbus/dbus.h>
  12 #include <dbus/dbus-glib.h>
  13 #include <dbus/dbus-glib-lowlevel.h>
  14
  15
  16 #define TYPE_MOONSHOT_SERVER (moonshot_server_get_type ())
  17 #define MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MOONSHOT_SERVER, MoonshotServer))
  18 #define MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  19 #define IS_MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MOONSHOT_SERVER))
  20 #define IS_MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MOONSHOT_SERVER))
  21 #define MOONSHOT_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  22
  23 typedef struct _MoonshotServer MoonshotServer;
  24 typedef struct _MoonshotServerClass MoonshotServerClass;
  25 typedef struct _MoonshotServerPrivate MoonshotServerPrivate;
  26
  27 #define TYPE_MAIN_WINDOW (main_window_get_type ())
  28 #define MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MAIN_WINDOW, MainWindow))
  29 #define MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MAIN_WINDOW, MainWindowClass))
  30 #define IS_MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MAIN_WINDOW))
  31 #define IS_MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MAIN_WINDOW))
  32 #define MAIN_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MAIN_WINDOW, MainWindowClass))
  33
  34 typedef struct _MainWindow MainWindow;
  35 typedef struct _MainWindowClass MainWindowClass;
  36 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  37 #define _g_free0(var) (var = (g_free (var), NULL))
  38
  39 #define TYPE_IDENTITY_REQUEST (identity_request_get_type ())
  40 #define IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDENTITY_REQUEST, IdentityRequest))
  41 #define IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  42 #define IS_IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDENTITY_REQUEST))
  43 #define IS_IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDENTITY_REQUEST))
  44 #define IDENTITY_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  45
  46 typedef struct _IdentityRequest IdentityRequest;
  47 typedef struct _IdentityRequestClass IdentityRequestClass;
  48 typedef struct _IdentityRequestPrivate IdentityRequestPrivate;
  49
  50 #define TYPE_ID_CARD (id_card_get_type ())
  51 #define ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD, IdCard))
  52 #define ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD, IdCardClass))
  53 #define IS_ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD))
  54 #define IS_ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD))
  55 #define ID_CARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD, IdCardClass))
  56
  57 typedef struct _IdCard IdCard;
  58 typedef struct _IdCardClass IdCardClass;
  59 typedef struct _Block2Data Block2Data;
  60 typedef struct _MoonshotServerGetIdentityData MoonshotServerGetIdentityData;
  61 typedef struct _DBusObjectVTable _DBusObjectVTable;
  62
  63 struct _MoonshotServer {
  64         GObject parent_instance;
  65         MoonshotServerPrivate * priv;
  66 };
  67
  68 struct _MoonshotServerClass {
  69         GObjectClass parent_class;
  70 };
  71
  72 struct _MoonshotServerPrivate {
  73         MainWindow* main_window;
  74 };
  75
  76 typedef void (*ReturnIdentityCallback) (IdentityRequest* request, void* user_data);
  77 struct _IdentityRequest {
  78         GObject parent_instance;
  79         IdentityRequestPrivate * priv;
  80         IdCard* id_card;
  81         gboolean complete;
  82 };
  83
  84 struct _IdentityRequestClass {
  85         GObjectClass parent_class;
  86 };
  87
  88 struct _Block2Data {
  89         int _ref_count_;
  90         MoonshotServer * self;
  91         gpointer _async_data_;
  92 };
  93
  94 struct _MoonshotServerGetIdentityData {
  95         int _state_;
  96         GAsyncResult* _res_;
  97         GSimpleAsyncResult* _async_result;
  98         MoonshotServer* self;
  99         char* nai;
 100         char* password;
 101         char* service;
 102         char* nai_out;
 103         char* password_out;
 104         char* certificate_out;
 105         gboolean result;
 106         gboolean has_service;
 107         IdentityRequest* request;
 108         char* _tmp0_;
 109         char* _tmp1_;
 110         char* _tmp2_;
 111         IdCard* id_card;
 112         gint _tmp3_;
 113         char** id_card_service_collection;
 114         int id_card_service_collection_length1;
 115         int id_card_service_it;
 116         char* id_card_service;
 117         char* _tmp4_;
 118         char* _tmp5_;
 119         char* _tmp6_;
 120         Block2Data* _data2_;
 121 };
 122
 123 struct _DBusObjectVTable {
 124         void (*register_object) (DBusConnection*, const char*, void*);
 125 };
 126
 127
 128 static gpointer moonshot_server_parent_class = NULL;
 129
 130 GType moonshot_server_get_type (void) G_GNUC_CONST;
 131 GType main_window_get_type (void) G_GNUC_CONST;
 132 #define MOONSHOT_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_MOONSHOT_SERVER, MoonshotServerPrivate))
 133 enum  {
 134         MOONSHOT_SERVER_DUMMY_PROPERTY
 135 };
 136 MoonshotServer* moonshot_server_new (GtkWindow* window);
 137 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window);
 138 static void moonshot_server_get_identity_data_free (gpointer _data);
 139 static void moonshot_server_get_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 140 void moonshot_server_get_identity (MoonshotServer* self, const char* nai, const char* password, const char* service, GAsyncReadyCallback _callback_, gpointer _user_data_);
 141 gboolean moonshot_server_get_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** certificate_out);
 142 static gboolean moonshot_server_get_identity_co (MoonshotServerGetIdentityData* data);
 143 IdentityRequest* identity_request_new (MainWindow* main_window, const char* nai, const char* password, const char* certificate);
 144 IdentityRequest* identity_request_construct (GType object_type, MainWindow* main_window, const char* nai, const char* password, const char* certificate);
 145 GType identity_request_get_type (void) G_GNUC_CONST;
 146 void identity_request_set_callback (IdentityRequest* self, ReturnIdentityCallback cb, void* cb_target, GDestroyNotify cb_target_destroy_notify);
 147 static void _lambda1_ (IdentityRequest* IdentityRequest, Block2Data* _data2_);
 148 static void __lambda1__return_identity_callback (IdentityRequest* request, gpointer self);
 149 gboolean identity_request_execute (IdentityRequest* self);
 150 GType id_card_get_type (void) G_GNUC_CONST;
 151 char** id_card_get_services (IdCard* self, int* result_length1);
 152 const char* id_card_get_nai (IdCard* self);
 153 const char* id_card_get_password (IdCard* self);
 154 static Block2Data* block2_data_ref (Block2Data* _data2_);
 155 static void block2_data_unref (Block2Data* _data2_);
 156 static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 157 static void _vala_dbus_unregister_object (gpointer connection, GObject* object);
 158 void moonshot_server_dbus_register_object (DBusConnection* connection, const char* path, void* object);
 159 void _moonshot_server_dbus_unregister (DBusConnection* connection, void* _user_data_);
 160 DBusHandlerResult moonshot_server_dbus_message (DBusConnection* connection, DBusMessage* message, void* object);
 161 static DBusHandlerResult _dbus_moonshot_server_introspect (MoonshotServer* self, DBusConnection* connection, DBusMessage* message);
 162 static DBusHandlerResult _dbus_moonshot_server_property_get_all (MoonshotServer* self, DBusConnection* connection, DBusMessage* message);
 163 static DBusHandlerResult _dbus_moonshot_server_get_identity (MoonshotServer* self, DBusConnection* connection, DBusMessage* message);
 164 static void _dbus_moonshot_server_get_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 165 static void moonshot_server_finalize (GObject* obj);
 166 static int _vala_strcmp0 (const char * str1, const char * str2);
 167
 168 static const DBusObjectPathVTable _moonshot_server_dbus_path_vtable = {_moonshot_server_dbus_unregister, moonshot_server_dbus_message};
 169 static const _DBusObjectVTable _moonshot_server_dbus_vtable = {moonshot_server_dbus_register_object};
 170
 171
 172 static gpointer _g_object_ref0 (gpointer self) {
 173         return self ? g_object_ref (self) : NULL;
 174 }
 175
 176
 177 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window) {
 178         MoonshotServer * self = NULL;
 179         MainWindow* _tmp0_;
 180         g_return_val_if_fail (window != NULL, NULL);
 181         self = (MoonshotServer*) g_object_new (object_type, NULL);
 182         self->priv->main_window = (_tmp0_ = _g_object_ref0 (MAIN_WINDOW (window)), _g_object_unref0 (self->priv->main_window), _tmp0_);
 183         return self;
 184 }
 185
 186
 187 MoonshotServer* moonshot_server_new (GtkWindow* window) {
 188         return moonshot_server_construct (TYPE_MOONSHOT_SERVER, window);
 189 }
 190
 191
 192 static void moonshot_server_get_identity_data_free (gpointer _data) {
 193         MoonshotServerGetIdentityData* data;
 194         data = _data;
 195         _g_free0 (data->nai);
 196         _g_free0 (data->password);
 197         _g_free0 (data->service);
 198         g_object_unref (data->self);
 199         g_slice_free (MoonshotServerGetIdentityData, data);
 200 }
 201
 202
 203 void moonshot_server_get_identity (MoonshotServer* self, const char* nai, const char* password, const char* service, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 204         MoonshotServerGetIdentityData* _data_;
 205         _data_ = g_slice_new0 (MoonshotServerGetIdentityData);
 206         _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, moonshot_server_get_identity);
 207         g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, moonshot_server_get_identity_data_free);
 208         _data_->self = g_object_ref (self);
 209         _data_->nai = g_strdup (nai);
 210         _data_->password = g_strdup (password);
 211         _data_->service = g_strdup (service);
 212         moonshot_server_get_identity_co (_data_);
 213 }
 214
 215
 216 gboolean moonshot_server_get_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** certificate_out) {
 217         gboolean result;
 218         MoonshotServerGetIdentityData* _data_;
 219         _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 220         *nai_out = _data_->nai_out;
 221         _data_->nai_out = NULL;
 222         *password_out = _data_->password_out;
 223         _data_->password_out = NULL;
 224         *certificate_out = _data_->certificate_out;
 225         _data_->certificate_out = NULL;
 226         result = _data_->result;
 227         return result;
 228 }
 229
 230
 231 static void moonshot_server_get_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 232         MoonshotServerGetIdentityData* data;
 233         data = _user_data_;
 234         data->_res_ = _res_;
 235         moonshot_server_get_identity_co (data);
 236 }
 237
 238
 239 /**
 240      * This is the function used by the GSS mechanism to get the NAI,
 241      * password and certificate of the ID card for the specificated service.
 242      *
 243      * The function will block until the user choose the ID card.
 244      *
 245      * @param nai NAI of the ID Card (optional)
 246      * @param password Password of the ID Card (optional)
 247      * @param service Service application request an ID Card for
 248      * @param nai_out NAI stored in the ID Card
 249      * @param password_out Password stored in the ID Card
 250      * @param certificate Certificate stored in th ID Card
 251      *
 252      * @return true if the user choose a correct ID card for that service,
 253      *         false otherwise.
 254      */
 255 static void _lambda1_ (IdentityRequest* IdentityRequest, Block2Data* _data2_) {
 256         MoonshotServer * self;
 257         self = _data2_->self;
 258         g_return_if_fail (IdentityRequest != NULL);
 259         moonshot_server_get_identity_co (_data2_->_async_data_);
 260 }
 261
 262
 263 static void __lambda1__return_identity_callback (IdentityRequest* request, gpointer self) {
 264         _lambda1_ (request, self);
 265 }
 266
 267
 268 static Block2Data* block2_data_ref (Block2Data* _data2_) {
 269         g_atomic_int_inc (&_data2_->_ref_count_);
 270         return _data2_;
 271 }
 272
 273
 274 static void block2_data_unref (Block2Data* _data2_) {
 275         if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
 276                 _g_object_unref0 (_data2_->self);
 277                 g_slice_free (Block2Data, _data2_);
 278         }
 279 }
 280
 281
 282 static gboolean moonshot_server_get_identity_co (MoonshotServerGetIdentityData* data) {
 283         switch (data->_state_) {
 284                 case 0:
 285                 goto _state_0;
 286                 default:
 287                 g_assert_not_reached ();
 288                 case 1:
 289                 goto _state_1;
 290         }
 291         _state_0:
 292         data->_data2_ = g_slice_new0 (Block2Data);
 293         data->_data2_->_ref_count_ = 1;
 294         data->_data2_->self = g_object_ref (data->self);
 295         data->_data2_->_async_data_ = data;
 296         data->has_service = FALSE;
 297         data->request = identity_request_new (data->self->priv->main_window, data->nai, data->password, data->service);
 298         identity_request_set_callback (data->request, __lambda1__return_identity_callback, block2_data_ref (data->_data2_), block2_data_unref);
 299         identity_request_execute (data->request);
 300         data->_state_ = 1;
 301         return FALSE;
 302         _state_1:
 303         ;
 304         data->nai_out = (data->_tmp0_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp0_);
 305         data->password_out = (data->_tmp1_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp1_);
 306         data->certificate_out = (data->_tmp2_ = g_strdup (""), _g_free0 (data->certificate_out), data->_tmp2_);
 307         data->id_card = _g_object_ref0 (data->request->id_card);
 308         if (data->id_card != NULL) {
 309                 {
 310                         data->id_card_service_collection = id_card_get_services (data->id_card, &data->_tmp3_);
 311                         data->id_card_service_collection_length1 = data->_tmp3_;
 312                         for (data->id_card_service_it = 0; data->id_card_service_it < data->_tmp3_; data->id_card_service_it = data->id_card_service_it + 1) {
 313                                 data->id_card_service = g_strdup (data->id_card_service_collection[data->id_card_service_it]);
 314                                 {
 315                                         if (_vala_strcmp0 (data->id_card_service, data->service) == 0) {
 316                                                 data->has_service = TRUE;
 317                                         }
 318                                         _g_free0 (data->id_card_service);
 319                                 }
 320                         }
 321                 }
 322                 if (data->has_service) {
 323                         data->nai_out = (data->_tmp4_ = g_strdup (id_card_get_nai (data->id_card)), _g_free0 (data->nai_out), data->_tmp4_);
 324                         data->password_out = (data->_tmp5_ = g_strdup (id_card_get_password (data->id_card)), _g_free0 (data->password_out), data->_tmp5_);
 325                         data->certificate_out = (data->_tmp6_ = g_strdup ("certificate"), _g_free0 (data->certificate_out), data->_tmp6_);
 326                         data->result = TRUE;
 327                         _g_object_unref0 (data->id_card);
 328                         _g_object_unref0 (data->request);
 329                         block2_data_unref (data->_data2_);
 330                         {
 331                                 if (data->_state_ == 0) {
 332                                         g_simple_async_result_complete_in_idle (data->_async_result);
 333                                 } else {
 334                                         g_simple_async_result_complete (data->_async_result);
 335                                 }
 336                                 g_object_unref (data->_async_result);
 337                                 return FALSE;
 338                         }
 339                 }
 340         }
 341         data->result = FALSE;
 342         _g_object_unref0 (data->id_card);
 343         _g_object_unref0 (data->request);
 344         block2_data_unref (data->_data2_);
 345         {
 346                 if (data->_state_ == 0) {
 347                         g_simple_async_result_complete_in_idle (data->_async_result);
 348                 } else {
 349                         g_simple_async_result_complete (data->_async_result);
 350                 }
 351                 g_object_unref (data->_async_result);
 352                 return FALSE;
 353         }
 354         _g_object_unref0 (data->id_card);
 355         _g_object_unref0 (data->request);
 356         block2_data_unref (data->_data2_);
 357         {
 358                 if (data->_state_ == 0) {
 359                         g_simple_async_result_complete_in_idle (data->_async_result);
 360                 } else {
 361                         g_simple_async_result_complete (data->_async_result);
 362                 }
 363                 g_object_unref (data->_async_result);
 364                 return FALSE;
 365         }
 366 }
 367
 368
 369 static void _vala_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 370         const _DBusObjectVTable * vtable;
 371         vtable = g_type_get_qdata (G_TYPE_FROM_INSTANCE (object), g_quark_from_static_string ("DBusObjectVTable"));
 372         if (vtable) {
 373                 vtable->register_object (connection, path, object);
 374         } else {
 375                 g_warning ("Object does not implement any D-Bus interface");
 376         }
 377 }
 378
 379
 380 static void _vala_dbus_unregister_object (gpointer connection, GObject* object) {
 381         char* path;
 382         path = g_object_steal_data ((GObject*) object, "dbus_object_path");
 383         dbus_connection_unregister_object_path (connection, path);
 384         g_free (path);
 385 }
 386
 387
 388 void _moonshot_server_dbus_unregister (DBusConnection* connection, void* _user_data_) {
 389 }
 390
 391
 392 static DBusHandlerResult _dbus_moonshot_server_introspect (MoonshotServer* self, DBusConnection* connection, DBusMessage* message) {
 393         DBusMessage* reply;
 394         DBusMessageIter iter;
 395         GString* xml_data;
 396         char** children;
 397         int i;
 398         reply = dbus_message_new_method_return (message);
 399         dbus_message_iter_init_append (reply, &iter);
 400         xml_data = g_string_new ("<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n");
 401         g_string_append (xml_data, "<node>\n<interface name=\"org.freedesktop.DBus.Introspectable\">\n  <method name=\"Introspect\">\n    <arg name=\"data\" direction=\"out\" type=\"s\"/>\n  </method>\n</interface>\n<interface name=\"org.freedesktop.DBus.Properties\">\n  <method name=\"Get\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"out\" type=\"v\"/>\n  </method>\n  <method name=\"Set\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"propname\" direction=\"in\" type=\"s\"/>\n    <arg name=\"value\" direction=\"in\" type=\"v\"/>\n  </method>\n  <method name=\"GetAll\">\n    <arg name=\"interface\" direction=\"in\" type=\"s\"/>\n    <arg name=\"props\" direction=\"out\" type=\"a{sv}\"/>\n  </method>\n</interface>\n<interface name=\"org.janet.Moonshot\">\n  <method name=\"GetIdentity\">\n    <arg name=\"nai\" type=\"s\" direction=\"in\"/>\n    <arg name=\"password\" type=\"s\" direction=\"in\"/>\n    <arg name=\"service\" type=\"s\" direction=\"in\"/>\n    <arg name=\"nai_out\" type=\"s\" direction=\"out\"/>\n    <arg name=\"password_out\" type=\"s\" direction=\"out\"/>\n    <arg name=\"certificate_out\" type=\"s\" direction=\"out\"/>\n    <arg name=\"result\" type=\"b\" direction=\"out\"/>\n  </method>\n</interface>\n");
 402         dbus_connection_list_registered (connection, g_object_get_data ((GObject *) self, "dbus_object_path"), &children);
 403         for (i = 0; children[i]; i++) {
 404                 g_string_append_printf (xml_data, "<node name=\"%s\"/>\n", children[i]);
 405         }
 406         dbus_free_string_array (children);
 407         g_string_append (xml_data, "</node>\n");
 408         dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &xml_data->str);
 409         g_string_free (xml_data, TRUE);
 410         if (reply) {
 411                 dbus_connection_send (connection, reply, NULL);
 412                 dbus_message_unref (reply);
 413                 return DBUS_HANDLER_RESULT_HANDLED;
 414         } else {
 415                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 416         }
 417 }
 418
 419
 420 static DBusHandlerResult _dbus_moonshot_server_property_get_all (MoonshotServer* self, DBusConnection* connection, DBusMessage* message) {
 421         DBusMessage* reply;
 422         DBusMessageIter iter, reply_iter, subiter;
 423         char* interface_name;
 424         const char* _tmp0_;
 425         if (strcmp (dbus_message_get_signature (message), "s")) {
 426                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 427         }
 428         dbus_message_iter_init (message, &iter);
 429         reply = dbus_message_new_method_return (message);
 430         dbus_message_iter_init_append (reply, &reply_iter);
 431         dbus_message_iter_get_basic (&iter, &_tmp0_);
 432         dbus_message_iter_next (&iter);
 433         interface_name = g_strdup (_tmp0_);
 434         if (strcmp (interface_name, "org.janet.Moonshot") == 0) {
 435                 dbus_message_iter_open_container (&reply_iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);
 436                 dbus_message_iter_close_container (&reply_iter, &subiter);
 437         } else {
 438                 dbus_message_unref (reply);
 439                 reply = NULL;
 440         }
 441         g_free (interface_name);
 442         if (reply) {
 443                 dbus_connection_send (connection, reply, NULL);
 444                 dbus_message_unref (reply);
 445                 return DBUS_HANDLER_RESULT_HANDLED;
 446         } else {
 447                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 448         }
 449 }
 450
 451
 452 static DBusHandlerResult _dbus_moonshot_server_get_identity (MoonshotServer* self, DBusConnection* connection, DBusMessage* message) {
 453         DBusMessageIter iter;
 454         char* nai = NULL;
 455         const char* _tmp1_;
 456         char* password = NULL;
 457         const char* _tmp2_;
 458         char* service = NULL;
 459         const char* _tmp3_;
 460         gpointer * _user_data_;
 461         if (strcmp (dbus_message_get_signature (message), "sss")) {
 462                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 463         }
 464         dbus_message_iter_init (message, &iter);
 465         dbus_message_iter_get_basic (&iter, &_tmp1_);
 466         dbus_message_iter_next (&iter);
 467         nai = g_strdup (_tmp1_);
 468         dbus_message_iter_get_basic (&iter, &_tmp2_);
 469         dbus_message_iter_next (&iter);
 470         password = g_strdup (_tmp2_);
 471         dbus_message_iter_get_basic (&iter, &_tmp3_);
 472         dbus_message_iter_next (&iter);
 473         service = g_strdup (_tmp3_);
 474         _user_data_ = g_new0 (gpointer, 2);
 475         _user_data_[0] = dbus_connection_ref (connection);
 476         _user_data_[1] = dbus_message_ref (message);
 477         moonshot_server_get_identity (self, nai, password, service, (GAsyncReadyCallback) _dbus_moonshot_server_get_identity_ready, _user_data_);
 478         _g_free0 (nai);
 479         _g_free0 (password);
 480         _g_free0 (service);
 481         return DBUS_HANDLER_RESULT_HANDLED;
 482 }
 483
 484
 485 static void _dbus_moonshot_server_get_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 486         DBusConnection * connection;
 487         DBusMessage * message;
 488         DBusMessageIter iter;
 489         GError* error;
 490         char* nai_out = NULL;
 491         char* password_out = NULL;
 492         char* certificate_out = NULL;
 493         gboolean result;
 494         DBusMessage* reply;
 495         const char* _tmp4_;
 496         const char* _tmp5_;
 497         const char* _tmp6_;
 498         dbus_bool_t _tmp7_;
 499         connection = _user_data_[0];
 500         message = _user_data_[1];
 501         error = NULL;
 502         result = moonshot_server_get_identity_finish ((MoonshotServer*) source_object, _res_, &nai_out, &password_out, &certificate_out);
 503         reply = dbus_message_new_method_return (message);
 504         dbus_message_iter_init_append (reply, &iter);
 505         _tmp4_ = nai_out;
 506         dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &_tmp4_);
 507         _g_free0 (nai_out);
 508         _tmp5_ = password_out;
 509         dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &_tmp5_);
 510         _g_free0 (password_out);
 511         _tmp6_ = certificate_out;
 512         dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &_tmp6_);
 513         _g_free0 (certificate_out);
 514         _tmp7_ = result;
 515         dbus_message_iter_append_basic (&iter, DBUS_TYPE_BOOLEAN, &_tmp7_);
 516         dbus_connection_send (connection, reply, NULL);
 517         dbus_message_unref (reply);
 518         dbus_connection_unref (connection);
 519         dbus_message_unref (message);
 520         g_free (_user_data_);
 521 }
 522
 523
 524 DBusHandlerResult moonshot_server_dbus_message (DBusConnection* connection, DBusMessage* message, void* object) {
 525         DBusHandlerResult result;
 526         result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 527         if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
 528                 result = _dbus_moonshot_server_introspect (object, connection, message);
 529         } else if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Properties", "GetAll")) {
 530                 result = _dbus_moonshot_server_property_get_all (object, connection, message);
 531         } else if (dbus_message_is_method_call (message, "org.janet.Moonshot", "GetIdentity")) {
 532                 result = _dbus_moonshot_server_get_identity (object, connection, message);
 533         }
 534         if (result == DBUS_HANDLER_RESULT_HANDLED) {
 535                 return result;
 536         } else {
 537                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 538         }
 539 }
 540
 541
 542 void moonshot_server_dbus_register_object (DBusConnection* connection, const char* path, void* object) {
 543         if (!g_object_get_data (object, "dbus_object_path")) {
 544                 g_object_set_data (object, "dbus_object_path", g_strdup (path));
 545                 dbus_connection_register_object_path (connection, path, &_moonshot_server_dbus_path_vtable, object);
 546                 g_object_weak_ref (object, _vala_dbus_unregister_object, connection);
 547         }
 548 }
 549
 550
 551 static void moonshot_server_class_init (MoonshotServerClass * klass) {
 552         moonshot_server_parent_class = g_type_class_peek_parent (klass);
 553         g_type_class_add_private (klass, sizeof (MoonshotServerPrivate));
 554         G_OBJECT_CLASS (klass)->finalize = moonshot_server_finalize;
 555         g_type_set_qdata (TYPE_MOONSHOT_SERVER, g_quark_from_static_string ("DBusObjectVTable"), (void*) (&_moonshot_server_dbus_vtable));
 556 }
 557
 558
 559 static void moonshot_server_instance_init (MoonshotServer * self) {
 560         self->priv = MOONSHOT_SERVER_GET_PRIVATE (self);
 561 }
 562
 563
 564 static void moonshot_server_finalize (GObject* obj) {
 565         MoonshotServer * self;
 566         self = MOONSHOT_SERVER (obj);
 567         _g_object_unref0 (self->priv->main_window);
 568         G_OBJECT_CLASS (moonshot_server_parent_class)->finalize (obj);
 569 }
 570
 571
 572 GType moonshot_server_get_type (void) {
 573         static volatile gsize moonshot_server_type_id__volatile = 0;
 574         if (g_once_init_enter (&moonshot_server_type_id__volatile)) {
 575                 static const GTypeInfo g_define_type_info = { sizeof (MoonshotServerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) moonshot_server_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (MoonshotServer), 0, (GInstanceInitFunc) moonshot_server_instance_init, NULL };
 576                 GType moonshot_server_type_id;
 577                 moonshot_server_type_id = g_type_register_static (G_TYPE_OBJECT, "MoonshotServer", &g_define_type_info, 0);
 578                 g_once_init_leave (&moonshot_server_type_id__volatile, moonshot_server_type_id);
 579         }
 580         return moonshot_server_type_id__volatile;
 581 }
 582
 583
 584 static int _vala_strcmp0 (const char * str1, const char * str2) {
 585         if (str1 == NULL) {
 586                 return -(str1 != str2);
 587         }
 588         if (str2 == NULL) {
 589                 return str1 != str2;
 590         }
 591         return strcmp (str1, str2);
 592 }
 593
 594
 595
 596