src/moonshot-server.c

   1 /* moonshot-server.c generated by valac 0.10.4, the Vala compiler
   2  * generated from moonshot-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
  12
  13 #define TYPE_MOONSHOT_SERVER (moonshot_server_get_type ())
  14 #define MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MOONSHOT_SERVER, MoonshotServer))
  15 #define MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  16 #define IS_MOONSHOT_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MOONSHOT_SERVER))
  17 #define IS_MOONSHOT_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MOONSHOT_SERVER))
  18 #define MOONSHOT_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MOONSHOT_SERVER, MoonshotServerClass))
  19
  20 typedef struct _MoonshotServer MoonshotServer;
  21 typedef struct _MoonshotServerClass MoonshotServerClass;
  22 typedef struct _MoonshotServerPrivate MoonshotServerPrivate;
  23
  24 #define TYPE_IDENTITY_MANAGER_VIEW (identity_manager_view_get_type ())
  25 #define IDENTITY_MANAGER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDENTITY_MANAGER_VIEW, IdentityManagerView))
  26 #define IDENTITY_MANAGER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDENTITY_MANAGER_VIEW, IdentityManagerViewClass))
  27 #define IS_IDENTITY_MANAGER_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDENTITY_MANAGER_VIEW))
  28 #define IS_IDENTITY_MANAGER_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDENTITY_MANAGER_VIEW))
  29 #define IDENTITY_MANAGER_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDENTITY_MANAGER_VIEW, IdentityManagerViewClass))
  30
  31 typedef struct _IdentityManagerView IdentityManagerView;
  32 typedef struct _IdentityManagerViewClass IdentityManagerViewClass;
  33 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  34 #define _g_free0(var) (var = (g_free (var), NULL))
  35
  36 #define TYPE_IDENTITY_REQUEST (identity_request_get_type ())
  37 #define IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IDENTITY_REQUEST, IdentityRequest))
  38 #define IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  39 #define IS_IDENTITY_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IDENTITY_REQUEST))
  40 #define IS_IDENTITY_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_IDENTITY_REQUEST))
  41 #define IDENTITY_REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_IDENTITY_REQUEST, IdentityRequestClass))
  42
  43 typedef struct _IdentityRequest IdentityRequest;
  44 typedef struct _IdentityRequestClass IdentityRequestClass;
  45 typedef struct _IdentityRequestPrivate IdentityRequestPrivate;
  46
  47 #define TYPE_ID_CARD (id_card_get_type ())
  48 #define ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD, IdCard))
  49 #define ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD, IdCardClass))
  50 #define IS_ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD))
  51 #define IS_ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD))
  52 #define ID_CARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD, IdCardClass))
  53
  54 typedef struct _IdCard IdCard;
  55 typedef struct _IdCardClass IdCardClass;
  56
  57 #define TYPE_TRUST_ANCHOR (trust_anchor_get_type ())
  58 #define TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRUST_ANCHOR, TrustAnchor))
  59 #define TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  60 #define IS_TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRUST_ANCHOR))
  61 #define IS_TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRUST_ANCHOR))
  62 #define TRUST_ANCHOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  63
  64 typedef struct _TrustAnchor TrustAnchor;
  65 typedef struct _TrustAnchorClass TrustAnchorClass;
  66 typedef struct _Block3Data Block3Data;
  67 typedef struct _MoonshotServerGetIdentityData MoonshotServerGetIdentityData;
  68 typedef struct _Block4Data Block4Data;
  69 typedef struct _MoonshotServerGetDefaultIdentityData MoonshotServerGetDefaultIdentityData;
  70
  71 #define TYPE_RULE (rule_get_type ())
  72 typedef struct _Rule Rule;
  73
  74 #define WEB_PROVISIONING_TYPE_PARSER (web_provisioning_parser_get_type ())
  75 #define WEB_PROVISIONING_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParser))
  76 #define WEB_PROVISIONING_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  77 #define WEB_PROVISIONING_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEB_PROVISIONING_TYPE_PARSER))
  78 #define WEB_PROVISIONING_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), WEB_PROVISIONING_TYPE_PARSER))
  79 #define WEB_PROVISIONING_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  80
  81 typedef struct _WebProvisioningParser WebProvisioningParser;
  82 typedef struct _WebProvisioningParserClass WebProvisioningParserClass;
  83 #define _web_provisioning_parser_unref0(var) ((var == NULL) ? NULL : (var = (web_provisioning_parser_unref (var), NULL)))
  84
  85 struct _MoonshotServer {
  86         GObject parent_instance;
  87         MoonshotServerPrivate * priv;
  88 };
  89
  90 struct _MoonshotServerClass {
  91         GObjectClass parent_class;
  92 };
  93
  94 struct _MoonshotServerPrivate {
  95         IdentityManagerView* main_window;
  96 };
  97
  98 typedef void (*ReturnIdentityCallback) (IdentityRequest* request, void* user_data);
  99 struct _IdentityRequest {
 100         GObject parent_instance;
 101         IdentityRequestPrivate * priv;
 102         IdCard* id_card;
 103         gboolean complete;
 104         gboolean select_default;
 105         char* nai;
 106         char* password;
 107         char* service;
 108 };
 109
 110 struct _IdentityRequestClass {
 111         GObjectClass parent_class;
 112 };
 113
 114 struct _Block3Data {
 115         int _ref_count_;
 116         MoonshotServer * self;
 117         gpointer _async_data_;
 118 };
 119
 120 struct _MoonshotServerGetIdentityData {
 121         int _state_;
 122         GAsyncResult* _res_;
 123         GSimpleAsyncResult* _async_result;
 124         MoonshotServer* self;
 125         char* nai;
 126         char* password;
 127         char* service;
 128         char* nai_out;
 129         char* password_out;
 130         char* server_certificate_hash;
 131         char* ca_certificate;
 132         char* subject_name_constraint;
 133         char* subject_alt_name_constraint;
 134         gboolean result;
 135         IdentityRequest* request;
 136         char* _tmp0_;
 137         char* _tmp1_;
 138         char* _tmp2_;
 139         char* _tmp3_;
 140         char* _tmp4_;
 141         char* _tmp5_;
 142         IdCard* id_card;
 143         char* _tmp6_;
 144         char* _tmp7_;
 145         char* _tmp8_;
 146         char* _tmp9_;
 147         char* _tmp10_;
 148         char* _tmp11_;
 149         char* _tmp12_;
 150         char* _tmp13_;
 151         char* _tmp14_;
 152         char* _tmp15_;
 153         char* _tmp16_;
 154         char* _tmp17_;
 155         Block3Data* _data3_;
 156 };
 157
 158 struct _Block4Data {
 159         int _ref_count_;
 160         MoonshotServer * self;
 161         gpointer _async_data_;
 162 };
 163
 164 struct _MoonshotServerGetDefaultIdentityData {
 165         int _state_;
 166         GAsyncResult* _res_;
 167         GSimpleAsyncResult* _async_result;
 168         MoonshotServer* self;
 169         char* nai_out;
 170         char* password_out;
 171         char* server_certificate_hash;
 172         char* ca_certificate;
 173         char* subject_name_constraint;
 174         char* subject_alt_name_constraint;
 175         gboolean result;
 176         IdentityRequest* request;
 177         char* _tmp0_;
 178         char* _tmp1_;
 179         char* _tmp2_;
 180         char* _tmp3_;
 181         char* _tmp4_;
 182         char* _tmp5_;
 183         char* _tmp6_;
 184         char* _tmp7_;
 185         char* _tmp8_;
 186         char* _tmp9_;
 187         char* _tmp10_;
 188         char* _tmp11_;
 189         char* _tmp12_;
 190         char* _tmp13_;
 191         char* _tmp14_;
 192         char* _tmp15_;
 193         char* _tmp16_;
 194         char* _tmp17_;
 195         Block4Data* _data4_;
 196 };
 197
 198 struct _Rule {
 199         char* pattern;
 200         char* always_confirm;
 201 };
 202
 203
 204 extern IdCard** web_provisioning_cards;
 205 extern gint web_provisioning_cards_length1;
 206 static gpointer moonshot_server_parent_class = NULL;
 207
 208 GType moonshot_server_get_type (void) G_GNUC_CONST;
 209 guint moonshot_server_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
 210 GType identity_manager_view_get_type (void) G_GNUC_CONST;
 211 #define MOONSHOT_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_MOONSHOT_SERVER, MoonshotServerPrivate))
 212 enum  {
 213         MOONSHOT_SERVER_DUMMY_PROPERTY
 214 };
 215 MoonshotServer* moonshot_server_new (GtkWindow* window);
 216 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window);
 217 static void moonshot_server_get_identity_data_free (gpointer _data);
 218 static void moonshot_server_get_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 219 void moonshot_server_get_identity (MoonshotServer* self, const char* nai, const char* password, const char* service, GAsyncReadyCallback _callback_, gpointer _user_data_);
 220 gboolean moonshot_server_get_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** server_certificate_hash, char** ca_certificate, char** subject_name_constraint, char** subject_alt_name_constraint);
 221 static gboolean moonshot_server_get_identity_co (MoonshotServerGetIdentityData* data);
 222 IdentityRequest* identity_request_new (IdentityManagerView* main_window, const char* nai, const char* password, const char* service);
 223 IdentityRequest* identity_request_construct (GType object_type, IdentityManagerView* main_window, const char* nai, const char* password, const char* service);
 224 GType identity_request_get_type (void) G_GNUC_CONST;
 225 void identity_request_set_callback (IdentityRequest* self, ReturnIdentityCallback cb, void* cb_target, GDestroyNotify cb_target_destroy_notify);
 226 static void _lambda4_ (IdentityRequest* IdentityRequest, Block3Data* _data3_);
 227 static void __lambda4__return_identity_callback (IdentityRequest* request, gpointer self);
 228 gboolean identity_request_execute (IdentityRequest* self);
 229 GType id_card_get_type (void) G_GNUC_CONST;
 230 const char* id_card_get_nai (IdCard* self);
 231 const char* id_card_get_password (IdCard* self);
 232 GType trust_anchor_get_type (void) G_GNUC_CONST;
 233 TrustAnchor* id_card_get_trust_anchor (IdCard* self);
 234 const char* trust_anchor_get_server_cert (TrustAnchor* self);
 235 const char* trust_anchor_get_ca_cert (TrustAnchor* self);
 236 const char* trust_anchor_get_subject (TrustAnchor* self);
 237 const char* trust_anchor_get_subject_alt (TrustAnchor* self);
 238 static Block3Data* block3_data_ref (Block3Data* _data3_);
 239 static void block3_data_unref (Block3Data* _data3_);
 240 static void moonshot_server_get_default_identity_data_free (gpointer _data);
 241 static void moonshot_server_get_default_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 242 void moonshot_server_get_default_identity (MoonshotServer* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 243 gboolean moonshot_server_get_default_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** server_certificate_hash, char** ca_certificate, char** subject_name_constraint, char** subject_alt_name_constraint);
 244 static gboolean moonshot_server_get_default_identity_co (MoonshotServerGetDefaultIdentityData* data);
 245 IdentityRequest* identity_request_new_default (IdentityManagerView* main_window);
 246 IdentityRequest* identity_request_construct_default (GType object_type, IdentityManagerView* main_window);
 247 static void _lambda5_ (IdentityRequest* IdentityRequest, Block4Data* _data4_);
 248 static void __lambda5__return_identity_callback (IdentityRequest* request, gpointer self);
 249 static Block4Data* block4_data_ref (Block4Data* _data4_);
 250 static void block4_data_unref (Block4Data* _data4_);
 251 gboolean moonshot_server_install_id_card (MoonshotServer* self, const char* display_name, const char* user_name, const char* password, const char* realm, char** rules_patterns, int rules_patterns_length1, char** rules_always_confirm, int rules_always_confirm_length1, char** services, int services_length1, const char* ca_cert, const char* subject, const char* subject_alt, const char* server_cert);
 252 IdCard* id_card_new (void);
 253 IdCard* id_card_construct (GType object_type);
 254 void id_card_set_display_name (IdCard* self, const char* value);
 255 void id_card_set_username (IdCard* self, const char* value);
 256 void id_card_set_password (IdCard* self, const char* value);
 257 void id_card_set_issuer (IdCard* self, const char* value);
 258 void id_card_set_services (IdCard* self, char** value, int value_length1);
 259 void trust_anchor_set_ca_cert (TrustAnchor* self, const char* value);
 260 void trust_anchor_set_subject (TrustAnchor* self, const char* value);
 261 void trust_anchor_set_subject_alt (TrustAnchor* self, const char* value);
 262 void trust_anchor_set_server_cert (TrustAnchor* self, const char* value);
 263 GType rule_get_type (void) G_GNUC_CONST;
 264 Rule* rule_dup (const Rule* self);
 265 void rule_free (Rule* self);
 266 void rule_copy (const Rule* self, Rule* dest);
 267 void rule_destroy (Rule* self);
 268 void id_card_set_rules (IdCard* self, Rule* value, int value_length1);
 269 static void _vala_Rule_array_free (Rule* array, gint array_length);
 270 Rule* id_card_get_rules (IdCard* self, int* result_length1);
 271 gboolean identity_manager_view_add_identity (IdentityManagerView* self, IdCard* id_card);
 272 gboolean moonshot_server_install_from_file (MoonshotServer* self, const char* file_name);
 273 WebProvisioningParser* web_provisioning_parser_new (const char* path);
 274 WebProvisioningParser* web_provisioning_parser_construct (GType object_type, const char* path);
 275 gpointer web_provisioning_parser_ref (gpointer instance);
 276 void web_provisioning_parser_unref (gpointer instance);
 277 GParamSpec* web_provisioning_param_spec_parser (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 278 void web_provisioning_value_set_parser (GValue* value, gpointer v_object);
 279 void web_provisioning_value_take_parser (GValue* value, gpointer v_object);
 280 gpointer web_provisioning_value_get_parser (const GValue* value);
 281 GType web_provisioning_parser_get_type (void) G_GNUC_CONST;
 282 void web_provisioning_parser_parse (WebProvisioningParser* self);
 283 const char* id_card_get_display_name (IdCard* self);
 284 const char* id_card_get_username (IdCard* self);
 285 const char* id_card_get_issuer (IdCard* self);
 286 char** id_card_get_services (IdCard* self, int* result_length1);
 287 static void moonshot_server_finalize (GObject* obj);
 288 static void moonshot_server_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
 289 static void _dbus_moonshot_server_get_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation);
 290 static void _dbus_moonshot_server_get_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 291 static void _dbus_moonshot_server_get_default_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation);
 292 static void _dbus_moonshot_server_get_default_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_);
 293 static void _dbus_moonshot_server_install_id_card (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation);
 294 static void _dbus_moonshot_server_install_from_file (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation);
 295 static GVariant* moonshot_server_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
 296 static gboolean moonshot_server_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
 297 static void _moonshot_server_unregister_object (gpointer user_data);
 298 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 299 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 300
 301 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_nai = {-1, "nai", "s"};
 302 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_password = {-1, "password", "s"};
 303 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_service = {-1, "service", "s"};
 304 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_nai_out = {-1, "nai_out", "s"};
 305 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_password_out = {-1, "password_out", "s"};
 306 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_server_certificate_hash = {-1, "server_certificate_hash", "s"};
 307 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_ca_certificate = {-1, "ca_certificate", "s"};
 308 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_subject_name_constraint = {-1, "subject_name_constraint", "s"};
 309 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_subject_alt_name_constraint = {-1, "subject_alt_name_constraint", "s"};
 310 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_identity_result = {-1, "result", "b"};
 311 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_get_identity_in[] = {&_moonshot_server_dbus_arg_info_get_identity_nai, &_moonshot_server_dbus_arg_info_get_identity_password, &_moonshot_server_dbus_arg_info_get_identity_service, NULL};
 312 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_get_identity_out[] = {&_moonshot_server_dbus_arg_info_get_identity_nai_out, &_moonshot_server_dbus_arg_info_get_identity_password_out, &_moonshot_server_dbus_arg_info_get_identity_server_certificate_hash, &_moonshot_server_dbus_arg_info_get_identity_ca_certificate, &_moonshot_server_dbus_arg_info_get_identity_subject_name_constraint, &_moonshot_server_dbus_arg_info_get_identity_subject_alt_name_constraint, &_moonshot_server_dbus_arg_info_get_identity_result, NULL};
 313 static const GDBusMethodInfo _moonshot_server_dbus_method_info_get_identity = {-1, "GetIdentity", (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_get_identity_in), (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_get_identity_out)};
 314 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_nai_out = {-1, "nai_out", "s"};
 315 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_password_out = {-1, "password_out", "s"};
 316 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_server_certificate_hash = {-1, "server_certificate_hash", "s"};
 317 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_ca_certificate = {-1, "ca_certificate", "s"};
 318 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_subject_name_constraint = {-1, "subject_name_constraint", "s"};
 319 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_subject_alt_name_constraint = {-1, "subject_alt_name_constraint", "s"};
 320 static const GDBusArgInfo _moonshot_server_dbus_arg_info_get_default_identity_result = {-1, "result", "b"};
 321 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_get_default_identity_in[] = {NULL};
 322 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_get_default_identity_out[] = {&_moonshot_server_dbus_arg_info_get_default_identity_nai_out, &_moonshot_server_dbus_arg_info_get_default_identity_password_out, &_moonshot_server_dbus_arg_info_get_default_identity_server_certificate_hash, &_moonshot_server_dbus_arg_info_get_default_identity_ca_certificate, &_moonshot_server_dbus_arg_info_get_default_identity_subject_name_constraint, &_moonshot_server_dbus_arg_info_get_default_identity_subject_alt_name_constraint, &_moonshot_server_dbus_arg_info_get_default_identity_result, NULL};
 323 static const GDBusMethodInfo _moonshot_server_dbus_method_info_get_default_identity = {-1, "GetDefaultIdentity", (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_get_default_identity_in), (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_get_default_identity_out)};
 324 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_display_name = {-1, "display_name", "s"};
 325 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_user_name = {-1, "user_name", "s"};
 326 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_password = {-1, "password", "s"};
 327 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_realm = {-1, "realm", "s"};
 328 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_rules_patterns = {-1, "rules_patterns", "as"};
 329 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_rules_always_confirm = {-1, "rules_always_confirm", "as"};
 330 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_services = {-1, "services", "as"};
 331 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_ca_cert = {-1, "ca_cert", "s"};
 332 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_subject = {-1, "subject", "s"};
 333 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_subject_alt = {-1, "subject_alt", "s"};
 334 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_server_cert = {-1, "server_cert", "s"};
 335 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_id_card_result = {-1, "result", "b"};
 336 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_install_id_card_in[] = {&_moonshot_server_dbus_arg_info_install_id_card_display_name, &_moonshot_server_dbus_arg_info_install_id_card_user_name, &_moonshot_server_dbus_arg_info_install_id_card_password, &_moonshot_server_dbus_arg_info_install_id_card_realm, &_moonshot_server_dbus_arg_info_install_id_card_rules_patterns, &_moonshot_server_dbus_arg_info_install_id_card_rules_always_confirm, &_moonshot_server_dbus_arg_info_install_id_card_services, &_moonshot_server_dbus_arg_info_install_id_card_ca_cert, &_moonshot_server_dbus_arg_info_install_id_card_subject, &_moonshot_server_dbus_arg_info_install_id_card_subject_alt, &_moonshot_server_dbus_arg_info_install_id_card_server_cert, NULL};
 337 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_install_id_card_out[] = {&_moonshot_server_dbus_arg_info_install_id_card_result, NULL};
 338 static const GDBusMethodInfo _moonshot_server_dbus_method_info_install_id_card = {-1, "InstallIdCard", (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_install_id_card_in), (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_install_id_card_out)};
 339 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_from_file_file_name = {-1, "file_name", "s"};
 340 static const GDBusArgInfo _moonshot_server_dbus_arg_info_install_from_file_result = {-1, "result", "b"};
 341 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_install_from_file_in[] = {&_moonshot_server_dbus_arg_info_install_from_file_file_name, NULL};
 342 static const GDBusArgInfo * const _moonshot_server_dbus_arg_info_install_from_file_out[] = {&_moonshot_server_dbus_arg_info_install_from_file_result, NULL};
 343 static const GDBusMethodInfo _moonshot_server_dbus_method_info_install_from_file = {-1, "InstallFromFile", (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_install_from_file_in), (GDBusArgInfo **) (&_moonshot_server_dbus_arg_info_install_from_file_out)};
 344 static const GDBusMethodInfo * const _moonshot_server_dbus_method_info[] = {&_moonshot_server_dbus_method_info_get_identity, &_moonshot_server_dbus_method_info_get_default_identity, &_moonshot_server_dbus_method_info_install_id_card, &_moonshot_server_dbus_method_info_install_from_file, NULL};
 345 static const GDBusSignalInfo * const _moonshot_server_dbus_signal_info[] = {NULL};
 346 static const GDBusPropertyInfo * const _moonshot_server_dbus_property_info[] = {NULL};
 347 static const GDBusInterfaceInfo _moonshot_server_dbus_interface_info = {-1, "org.janet.Moonshot", (GDBusMethodInfo **) (&_moonshot_server_dbus_method_info), (GDBusSignalInfo **) (&_moonshot_server_dbus_signal_info), (GDBusPropertyInfo **) (&_moonshot_server_dbus_property_info)};
 348 static const GDBusInterfaceVTable _moonshot_server_dbus_interface_vtable = {moonshot_server_dbus_interface_method_call, moonshot_server_dbus_interface_get_property, moonshot_server_dbus_interface_set_property};
 349
 350
 351 static gpointer _g_object_ref0 (gpointer self) {
 352         return self ? g_object_ref (self) : NULL;
 353 }
 354
 355
 356 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window) {
 357         MoonshotServer * self = NULL;
 358         IdentityManagerView* _tmp0_;
 359         g_return_val_if_fail (window != NULL, NULL);
 360         self = (MoonshotServer*) g_object_new (object_type, NULL);
 361         self->priv->main_window = (_tmp0_ = _g_object_ref0 (IDENTITY_MANAGER_VIEW (window)), _g_object_unref0 (self->priv->main_window), _tmp0_);
 362         return self;
 363 }
 364
 365
 366 MoonshotServer* moonshot_server_new (GtkWindow* window) {
 367         return moonshot_server_construct (TYPE_MOONSHOT_SERVER, window);
 368 }
 369
 370
 371 static void moonshot_server_get_identity_data_free (gpointer _data) {
 372         MoonshotServerGetIdentityData* data;
 373         data = _data;
 374         _g_free0 (data->nai);
 375         _g_free0 (data->password);
 376         _g_free0 (data->service);
 377         g_object_unref (data->self);
 378         g_slice_free (MoonshotServerGetIdentityData, data);
 379 }
 380
 381
 382 void moonshot_server_get_identity (MoonshotServer* self, const char* nai, const char* password, const char* service, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 383         MoonshotServerGetIdentityData* _data_;
 384         _data_ = g_slice_new0 (MoonshotServerGetIdentityData);
 385         _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, moonshot_server_get_identity);
 386         g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, moonshot_server_get_identity_data_free);
 387         _data_->self = g_object_ref (self);
 388         _data_->nai = g_strdup (nai);
 389         _data_->password = g_strdup (password);
 390         _data_->service = g_strdup (service);
 391         moonshot_server_get_identity_co (_data_);
 392 }
 393
 394
 395 gboolean moonshot_server_get_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** server_certificate_hash, char** ca_certificate, char** subject_name_constraint, char** subject_alt_name_constraint) {
 396         gboolean result;
 397         MoonshotServerGetIdentityData* _data_;
 398         _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 399         *nai_out = _data_->nai_out;
 400         _data_->nai_out = NULL;
 401         *password_out = _data_->password_out;
 402         _data_->password_out = NULL;
 403         *server_certificate_hash = _data_->server_certificate_hash;
 404         _data_->server_certificate_hash = NULL;
 405         *ca_certificate = _data_->ca_certificate;
 406         _data_->ca_certificate = NULL;
 407         *subject_name_constraint = _data_->subject_name_constraint;
 408         _data_->subject_name_constraint = NULL;
 409         *subject_alt_name_constraint = _data_->subject_alt_name_constraint;
 410         _data_->subject_alt_name_constraint = NULL;
 411         result = _data_->result;
 412         return result;
 413 }
 414
 415
 416 static void moonshot_server_get_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 417         MoonshotServerGetIdentityData* data;
 418         data = _user_data_;
 419         data->_res_ = _res_;
 420         moonshot_server_get_identity_co (data);
 421 }
 422
 423
 424 static void _lambda4_ (IdentityRequest* IdentityRequest, Block3Data* _data3_) {
 425         MoonshotServer * self;
 426         self = _data3_->self;
 427         g_return_if_fail (IdentityRequest != NULL);
 428         moonshot_server_get_identity_co (_data3_->_async_data_);
 429 }
 430
 431
 432 static void __lambda4__return_identity_callback (IdentityRequest* request, gpointer self) {
 433         _lambda4_ (request, self);
 434 }
 435
 436
 437 static Block3Data* block3_data_ref (Block3Data* _data3_) {
 438         g_atomic_int_inc (&_data3_->_ref_count_);
 439         return _data3_;
 440 }
 441
 442
 443 static void block3_data_unref (Block3Data* _data3_) {
 444         if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
 445                 _g_object_unref0 (_data3_->self);
 446                 g_slice_free (Block3Data, _data3_);
 447         }
 448 }
 449
 450
 451 static gboolean moonshot_server_get_identity_co (MoonshotServerGetIdentityData* data) {
 452         switch (data->_state_) {
 453                 case 0:
 454                 goto _state_0;
 455                 default:
 456                 g_assert_not_reached ();
 457                 case 1:
 458                 goto _state_1;
 459         }
 460         _state_0:
 461         data->_data3_ = g_slice_new0 (Block3Data);
 462         data->_data3_->_ref_count_ = 1;
 463         data->_data3_->self = g_object_ref (data->self);
 464         data->_data3_->_async_data_ = data;
 465         data->request = identity_request_new (data->self->priv->main_window, data->nai, data->password, data->service);
 466         identity_request_set_callback (data->request, __lambda4__return_identity_callback, block3_data_ref (data->_data3_), block3_data_unref);
 467         identity_request_execute (data->request);
 468         data->_state_ = 1;
 469         return FALSE;
 470         _state_1:
 471         ;
 472         data->nai_out = (data->_tmp0_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp0_);
 473         data->password_out = (data->_tmp1_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp1_);
 474         data->server_certificate_hash = (data->_tmp2_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp2_);
 475         data->ca_certificate = (data->_tmp3_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp3_);
 476         data->subject_name_constraint = (data->_tmp4_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp4_);
 477         data->subject_alt_name_constraint = (data->_tmp5_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp5_);
 478         data->id_card = _g_object_ref0 (data->request->id_card);
 479         if (data->id_card != NULL) {
 480                 data->nai_out = (data->_tmp6_ = g_strdup (id_card_get_nai (data->id_card)), _g_free0 (data->nai_out), data->_tmp6_);
 481                 data->password_out = (data->_tmp7_ = g_strdup (id_card_get_password (data->id_card)), _g_free0 (data->password_out), data->_tmp7_);
 482                 data->server_certificate_hash = (data->_tmp8_ = g_strdup (trust_anchor_get_server_cert (id_card_get_trust_anchor (data->id_card))), _g_free0 (data->server_certificate_hash), data->_tmp8_);
 483                 data->ca_certificate = (data->_tmp9_ = g_strdup (trust_anchor_get_ca_cert (id_card_get_trust_anchor (data->id_card))), _g_free0 (data->ca_certificate), data->_tmp9_);
 484                 data->subject_name_constraint = (data->_tmp10_ = g_strdup (trust_anchor_get_subject (id_card_get_trust_anchor (data->id_card))), _g_free0 (data->subject_name_constraint), data->_tmp10_);
 485                 data->subject_alt_name_constraint = (data->_tmp11_ = g_strdup (trust_anchor_get_subject_alt (id_card_get_trust_anchor (data->id_card))), _g_free0 (data->subject_alt_name_constraint), data->_tmp11_);
 486                 if (data->nai_out == NULL) {
 487                         data->nai_out = (data->_tmp12_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp12_);
 488                 }
 489                 if (data->password_out == NULL) {
 490                         data->password_out = (data->_tmp13_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp13_);
 491                 }
 492                 if (data->server_certificate_hash == NULL) {
 493                         data->server_certificate_hash = (data->_tmp14_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp14_);
 494                 }
 495                 if (data->ca_certificate == NULL) {
 496                         data->ca_certificate = (data->_tmp15_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp15_);
 497                 }
 498                 if (data->subject_name_constraint == NULL) {
 499                         data->subject_name_constraint = (data->_tmp16_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp16_);
 500                 }
 501                 if (data->subject_alt_name_constraint == NULL) {
 502                         data->subject_alt_name_constraint = (data->_tmp17_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp17_);
 503                 }
 504                 data->result = TRUE;
 505                 _g_object_unref0 (data->id_card);
 506                 _g_object_unref0 (data->request);
 507                 block3_data_unref (data->_data3_);
 508                 {
 509                         if (data->_state_ == 0) {
 510                                 g_simple_async_result_complete_in_idle (data->_async_result);
 511                         } else {
 512                                 g_simple_async_result_complete (data->_async_result);
 513                         }
 514                         g_object_unref (data->_async_result);
 515                         return FALSE;
 516                 }
 517         }
 518         data->result = FALSE;
 519         _g_object_unref0 (data->id_card);
 520         _g_object_unref0 (data->request);
 521         block3_data_unref (data->_data3_);
 522         {
 523                 if (data->_state_ == 0) {
 524                         g_simple_async_result_complete_in_idle (data->_async_result);
 525                 } else {
 526                         g_simple_async_result_complete (data->_async_result);
 527                 }
 528                 g_object_unref (data->_async_result);
 529                 return FALSE;
 530         }
 531         _g_object_unref0 (data->id_card);
 532         _g_object_unref0 (data->request);
 533         block3_data_unref (data->_data3_);
 534         {
 535                 if (data->_state_ == 0) {
 536                         g_simple_async_result_complete_in_idle (data->_async_result);
 537                 } else {
 538                         g_simple_async_result_complete (data->_async_result);
 539                 }
 540                 g_object_unref (data->_async_result);
 541                 return FALSE;
 542         }
 543 }
 544
 545
 546 static void moonshot_server_get_default_identity_data_free (gpointer _data) {
 547         MoonshotServerGetDefaultIdentityData* data;
 548         data = _data;
 549         g_object_unref (data->self);
 550         g_slice_free (MoonshotServerGetDefaultIdentityData, data);
 551 }
 552
 553
 554 void moonshot_server_get_default_identity (MoonshotServer* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 555         MoonshotServerGetDefaultIdentityData* _data_;
 556         _data_ = g_slice_new0 (MoonshotServerGetDefaultIdentityData);
 557         _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, moonshot_server_get_default_identity);
 558         g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, moonshot_server_get_default_identity_data_free);
 559         _data_->self = g_object_ref (self);
 560         moonshot_server_get_default_identity_co (_data_);
 561 }
 562
 563
 564 gboolean moonshot_server_get_default_identity_finish (MoonshotServer* self, GAsyncResult* _res_, char** nai_out, char** password_out, char** server_certificate_hash, char** ca_certificate, char** subject_name_constraint, char** subject_alt_name_constraint) {
 565         gboolean result;
 566         MoonshotServerGetDefaultIdentityData* _data_;
 567         _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 568         *nai_out = _data_->nai_out;
 569         _data_->nai_out = NULL;
 570         *password_out = _data_->password_out;
 571         _data_->password_out = NULL;
 572         *server_certificate_hash = _data_->server_certificate_hash;
 573         _data_->server_certificate_hash = NULL;
 574         *ca_certificate = _data_->ca_certificate;
 575         _data_->ca_certificate = NULL;
 576         *subject_name_constraint = _data_->subject_name_constraint;
 577         _data_->subject_name_constraint = NULL;
 578         *subject_alt_name_constraint = _data_->subject_alt_name_constraint;
 579         _data_->subject_alt_name_constraint = NULL;
 580         result = _data_->result;
 581         return result;
 582 }
 583
 584
 585 static void moonshot_server_get_default_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 586         MoonshotServerGetDefaultIdentityData* data;
 587         data = _user_data_;
 588         data->_res_ = _res_;
 589         moonshot_server_get_default_identity_co (data);
 590 }
 591
 592
 593 static void _lambda5_ (IdentityRequest* IdentityRequest, Block4Data* _data4_) {
 594         MoonshotServer * self;
 595         self = _data4_->self;
 596         g_return_if_fail (IdentityRequest != NULL);
 597         moonshot_server_get_default_identity_co (_data4_->_async_data_);
 598 }
 599
 600
 601 static void __lambda5__return_identity_callback (IdentityRequest* request, gpointer self) {
 602         _lambda5_ (request, self);
 603 }
 604
 605
 606 static Block4Data* block4_data_ref (Block4Data* _data4_) {
 607         g_atomic_int_inc (&_data4_->_ref_count_);
 608         return _data4_;
 609 }
 610
 611
 612 static void block4_data_unref (Block4Data* _data4_) {
 613         if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
 614                 _g_object_unref0 (_data4_->self);
 615                 g_slice_free (Block4Data, _data4_);
 616         }
 617 }
 618
 619
 620 static gboolean moonshot_server_get_default_identity_co (MoonshotServerGetDefaultIdentityData* data) {
 621         switch (data->_state_) {
 622                 case 0:
 623                 goto _state_0;
 624                 default:
 625                 g_assert_not_reached ();
 626                 case 2:
 627                 goto _state_2;
 628         }
 629         _state_0:
 630         data->_data4_ = g_slice_new0 (Block4Data);
 631         data->_data4_->_ref_count_ = 1;
 632         data->_data4_->self = g_object_ref (data->self);
 633         data->_data4_->_async_data_ = data;
 634         data->request = identity_request_new_default (data->self->priv->main_window);
 635         identity_request_set_callback (data->request, __lambda5__return_identity_callback, block4_data_ref (data->_data4_), block4_data_unref);
 636         identity_request_execute (data->request);
 637         data->_state_ = 2;
 638         return FALSE;
 639         _state_2:
 640         ;
 641         data->nai_out = (data->_tmp0_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp0_);
 642         data->password_out = (data->_tmp1_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp1_);
 643         data->server_certificate_hash = (data->_tmp2_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp2_);
 644         data->ca_certificate = (data->_tmp3_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp3_);
 645         data->subject_name_constraint = (data->_tmp4_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp4_);
 646         data->subject_alt_name_constraint = (data->_tmp5_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp5_);
 647         if (data->request->id_card != NULL) {
 648                 data->nai_out = (data->_tmp6_ = g_strdup (id_card_get_nai (data->request->id_card)), _g_free0 (data->nai_out), data->_tmp6_);
 649                 data->password_out = (data->_tmp7_ = g_strdup (id_card_get_password (data->request->id_card)), _g_free0 (data->password_out), data->_tmp7_);
 650                 data->server_certificate_hash = (data->_tmp8_ = g_strdup (trust_anchor_get_server_cert (id_card_get_trust_anchor (data->request->id_card))), _g_free0 (data->server_certificate_hash), data->_tmp8_);
 651                 data->ca_certificate = (data->_tmp9_ = g_strdup (trust_anchor_get_ca_cert (id_card_get_trust_anchor (data->request->id_card))), _g_free0 (data->ca_certificate), data->_tmp9_);
 652                 data->subject_name_constraint = (data->_tmp10_ = g_strdup (trust_anchor_get_subject (id_card_get_trust_anchor (data->request->id_card))), _g_free0 (data->subject_name_constraint), data->_tmp10_);
 653                 data->subject_alt_name_constraint = (data->_tmp11_ = g_strdup (trust_anchor_get_subject_alt (id_card_get_trust_anchor (data->request->id_card))), _g_free0 (data->subject_alt_name_constraint), data->_tmp11_);
 654                 if (data->nai_out == NULL) {
 655                         data->nai_out = (data->_tmp12_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp12_);
 656                 }
 657                 if (data->password_out == NULL) {
 658                         data->password_out = (data->_tmp13_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp13_);
 659                 }
 660                 if (data->server_certificate_hash == NULL) {
 661                         data->server_certificate_hash = (data->_tmp14_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp14_);
 662                 }
 663                 if (data->ca_certificate == NULL) {
 664                         data->ca_certificate = (data->_tmp15_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp15_);
 665                 }
 666                 if (data->subject_name_constraint == NULL) {
 667                         data->subject_name_constraint = (data->_tmp16_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp16_);
 668                 }
 669                 if (data->subject_alt_name_constraint == NULL) {
 670                         data->subject_alt_name_constraint = (data->_tmp17_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp17_);
 671                 }
 672                 data->result = TRUE;
 673                 _g_object_unref0 (data->request);
 674                 block4_data_unref (data->_data4_);
 675                 {
 676                         if (data->_state_ == 0) {
 677                                 g_simple_async_result_complete_in_idle (data->_async_result);
 678                         } else {
 679                                 g_simple_async_result_complete (data->_async_result);
 680                         }
 681                         g_object_unref (data->_async_result);
 682                         return FALSE;
 683                 }
 684         }
 685         data->result = FALSE;
 686         _g_object_unref0 (data->request);
 687         block4_data_unref (data->_data4_);
 688         {
 689                 if (data->_state_ == 0) {
 690                         g_simple_async_result_complete_in_idle (data->_async_result);
 691                 } else {
 692                         g_simple_async_result_complete (data->_async_result);
 693                 }
 694                 g_object_unref (data->_async_result);
 695                 return FALSE;
 696         }
 697         _g_object_unref0 (data->request);
 698         block4_data_unref (data->_data4_);
 699         {
 700                 if (data->_state_ == 0) {
 701                         g_simple_async_result_complete_in_idle (data->_async_result);
 702                 } else {
 703                         g_simple_async_result_complete (data->_async_result);
 704                 }
 705                 g_object_unref (data->_async_result);
 706                 return FALSE;
 707         }
 708 }
 709
 710
 711 static void _vala_Rule_array_free (Rule* array, gint array_length) {
 712         if (array != NULL) {
 713                 int i;
 714                 for (i = 0; i < array_length; i = i + 1) {
 715                         rule_destroy (&array[i]);
 716                 }
 717         }
 718         g_free (array);
 719 }
 720
 721
 722 gboolean moonshot_server_install_id_card (MoonshotServer* self, const char* display_name, const char* user_name, const char* password, const char* realm, char** rules_patterns, int rules_patterns_length1, char** rules_always_confirm, int rules_always_confirm_length1, char** services, int services_length1, const char* ca_cert, const char* subject, const char* subject_alt, const char* server_cert) {
 723         gboolean result = FALSE;
 724         IdCard* idcard;
 725         char** _tmp0_;
 726         g_return_val_if_fail (self != NULL, FALSE);
 727         g_return_val_if_fail (display_name != NULL, FALSE);
 728         g_return_val_if_fail (user_name != NULL, FALSE);
 729         g_return_val_if_fail (password != NULL, FALSE);
 730         g_return_val_if_fail (realm != NULL, FALSE);
 731         g_return_val_if_fail (ca_cert != NULL, FALSE);
 732         g_return_val_if_fail (subject != NULL, FALSE);
 733         g_return_val_if_fail (subject_alt != NULL, FALSE);
 734         g_return_val_if_fail (server_cert != NULL, FALSE);
 735         idcard = id_card_new ();
 736         id_card_set_display_name (idcard, display_name);
 737         id_card_set_username (idcard, user_name);
 738         id_card_set_password (idcard, password);
 739         id_card_set_issuer (idcard, realm);
 740         _tmp0_ = services;
 741         id_card_set_services (idcard, _tmp0_, services_length1);
 742         trust_anchor_set_ca_cert (id_card_get_trust_anchor (idcard), ca_cert);
 743         trust_anchor_set_subject (id_card_get_trust_anchor (idcard), subject);
 744         trust_anchor_set_subject_alt (id_card_get_trust_anchor (idcard), subject_alt);
 745         trust_anchor_set_server_cert (id_card_get_trust_anchor (idcard), server_cert);
 746         if (rules_patterns_length1 == rules_always_confirm_length1) {
 747                 Rule* _tmp1_;
 748                 gint _tmp1__length1;
 749                 Rule* _tmp2_;
 750                 _tmp2_ = (_tmp1_ = g_new0 (Rule, rules_patterns_length1), _tmp1__length1 = rules_patterns_length1, _tmp1_);
 751                 id_card_set_rules (idcard, _tmp2_, rules_patterns_length1);
 752                 _tmp1_ = (_vala_Rule_array_free (_tmp1_, _tmp1__length1), NULL);
 753                 {
 754                         gint i;
 755                         i = 0;
 756                         {
 757                                 gboolean _tmp3_;
 758                                 _tmp3_ = TRUE;
 759                                 while (TRUE) {
 760                                         gint _tmp4_;
 761                                         gint _tmp5_;
 762                                         char* *_tmp6_;
 763                                         char* _tmp7_;
 764                                         gint _tmp8_;
 765                                         char* *_tmp9_;
 766                                         char* _tmp10_;
 767                                         if (!_tmp3_) {
 768                                                 i++;
 769                                         }
 770                                         _tmp3_ = FALSE;
 771                                         if (!(i < _tmp4_)) {
 772                                                 break;
 773                                         }
 774                                         _tmp6_ = &id_card_get_rules (idcard, &_tmp5_)[i].pattern;
 775                                         (*_tmp6_) = (_tmp7_ = g_strdup (rules_patterns[i]), _g_free0 ((*_tmp6_)), _tmp7_);
 776                                         _tmp9_ = &id_card_get_rules (idcard, &_tmp8_)[i].always_confirm;
 777                                         (*_tmp9_) = (_tmp10_ = g_strdup (rules_always_confirm[i]), _g_free0 ((*_tmp9_)), _tmp10_);
 778                                 }
 779                         }
 780                 }
 781         }
 782         result = identity_manager_view_add_identity (self->priv->main_window, idcard);
 783         _g_object_unref0 (idcard);
 784         return result;
 785 }
 786
 787
 788 gboolean moonshot_server_install_from_file (MoonshotServer* self, const char* file_name) {
 789         gboolean result = FALSE;
 790         WebProvisioningParser* webp;
 791         gboolean _result_;
 792         g_return_val_if_fail (self != NULL, FALSE);
 793         g_return_val_if_fail (file_name != NULL, FALSE);
 794         webp = web_provisioning_parser_new (file_name);
 795         web_provisioning_parser_parse (webp);
 796         _result_ = FALSE;
 797         {
 798                 IdCard** card_collection;
 799                 int card_collection_length1;
 800                 int card_it;
 801                 card_collection = web_provisioning_cards;
 802                 card_collection_length1 = web_provisioning_cards_length1;
 803                 for (card_it = 0; card_it < web_provisioning_cards_length1; card_it = card_it + 1) {
 804                         IdCard* card;
 805                         card = _g_object_ref0 (card_collection[card_it]);
 806                         {
 807                                 gint rules_patterns_length1;
 808                                 gint _rules_patterns_size_;
 809                                 char** _tmp1_;
 810                                 char** _tmp0_ = NULL;
 811                                 char** rules_patterns;
 812                                 gint rules_always_confirm_length1;
 813                                 gint _rules_always_confirm_size_;
 814                                 char** _tmp3_;
 815                                 char** _tmp2_ = NULL;
 816                                 char** rules_always_confirm;
 817                                 gint _tmp4_;
 818                                 gint _tmp13_;
 819                                 rules_patterns = (_tmp1_ = (_tmp0_ = g_new0 (char*, 0 + 1), _tmp0_), rules_patterns_length1 = 0, _rules_patterns_size_ = rules_patterns_length1, _tmp1_);
 820                                 rules_always_confirm = (_tmp3_ = (_tmp2_ = g_new0 (char*, 0 + 1), _tmp2_), rules_always_confirm_length1 = 0, _rules_always_confirm_size_ = rules_always_confirm_length1, _tmp3_);
 821                                 if (_tmp4_ > 0) {
 822                                         gint i;
 823                                         gint _tmp5_;
 824                                         char** _tmp6_;
 825                                         gint _tmp7_;
 826                                         char** _tmp8_;
 827                                         i = 0;
 828                                         rules_patterns = (_tmp6_ = g_new0 (char*, _tmp5_ + 1), rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL), rules_patterns_length1 = _tmp5_, _rules_patterns_size_ = rules_patterns_length1, _tmp6_);
 829                                         rules_always_confirm = (_tmp8_ = g_new0 (char*, _tmp7_ + 1), rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL), rules_always_confirm_length1 = _tmp7_, _rules_always_confirm_size_ = rules_always_confirm_length1, _tmp8_);
 830                                         {
 831                                                 gint _tmp9_;
 832                                                 Rule* r_collection;
 833                                                 int r_collection_length1;
 834                                                 int r_it;
 835                                                 r_collection = id_card_get_rules (card, &_tmp9_);
 836                                                 r_collection_length1 = _tmp9_;
 837                                                 for (r_it = 0; r_it < _tmp9_; r_it = r_it + 1) {
 838                                                         Rule _tmp12_ = {0};
 839                                                         Rule r;
 840                                                         r = (rule_copy (&r_collection[r_it], &_tmp12_), _tmp12_);
 841                                                         {
 842                                                                 char* _tmp10_;
 843                                                                 char* _tmp11_;
 844                                                                 rules_patterns[i] = (_tmp10_ = g_strdup (r.pattern), _g_free0 (rules_patterns[i]), _tmp10_);
 845                                                                 rules_always_confirm[i] = (_tmp11_ = g_strdup (r.always_confirm), _g_free0 (rules_always_confirm[i]), _tmp11_);
 846                                                                 i++;
 847                                                                 rule_destroy (&r);
 848                                                         }
 849                                                 }
 850                                         }
 851                                 }
 852                                 _result_ = moonshot_server_install_id_card (self, id_card_get_display_name (card), id_card_get_username (card), id_card_get_password (card), id_card_get_issuer (card), rules_patterns, rules_patterns_length1, rules_always_confirm, rules_always_confirm_length1, id_card_get_services (card, &_tmp13_), _tmp13_, trust_anchor_get_ca_cert (id_card_get_trust_anchor (card)), trust_anchor_get_subject (id_card_get_trust_anchor (card)), trust_anchor_get_subject_alt (id_card_get_trust_anchor (card)), trust_anchor_get_server_cert (id_card_get_trust_anchor (card)));
 853                                 rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
 854                                 rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
 855                                 _g_object_unref0 (card);
 856                         }
 857                 }
 858         }
 859         result = TRUE;
 860         _web_provisioning_parser_unref0 (webp);
 861         return result;
 862 }
 863
 864
 865 static void moonshot_server_class_init (MoonshotServerClass * klass) {
 866         moonshot_server_parent_class = g_type_class_peek_parent (klass);
 867         g_type_class_add_private (klass, sizeof (MoonshotServerPrivate));
 868         G_OBJECT_CLASS (klass)->finalize = moonshot_server_finalize;
 869 }
 870
 871
 872 static void moonshot_server_instance_init (MoonshotServer * self) {
 873         self->priv = MOONSHOT_SERVER_GET_PRIVATE (self);
 874 }
 875
 876
 877 static void moonshot_server_finalize (GObject* obj) {
 878         MoonshotServer * self;
 879         self = MOONSHOT_SERVER (obj);
 880         _g_object_unref0 (self->priv->main_window);
 881         G_OBJECT_CLASS (moonshot_server_parent_class)->finalize (obj);
 882 }
 883
 884
 885 GType moonshot_server_get_type (void) {
 886         static volatile gsize moonshot_server_type_id__volatile = 0;
 887         if (g_once_init_enter (&moonshot_server_type_id__volatile)) {
 888                 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 };
 889                 GType moonshot_server_type_id;
 890                 moonshot_server_type_id = g_type_register_static (G_TYPE_OBJECT, "MoonshotServer", &g_define_type_info, 0);
 891                 g_once_init_leave (&moonshot_server_type_id__volatile, moonshot_server_type_id);
 892         }
 893         return moonshot_server_type_id__volatile;
 894 }
 895
 896
 897 static void _dbus_moonshot_server_get_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
 898         char* nai = NULL;
 899         GVariant* _tmp0_;
 900         char* password = NULL;
 901         GVariant* _tmp1_;
 902         char* service = NULL;
 903         GVariant* _tmp2_;
 904         GVariantIter _arguments_iter;
 905         g_variant_iter_init (&_arguments_iter, parameters);
 906         _tmp0_ = g_variant_iter_next_value (&_arguments_iter);
 907         nai = g_variant_dup_string (_tmp0_, NULL);
 908         g_variant_unref (_tmp0_);
 909         _tmp1_ = g_variant_iter_next_value (&_arguments_iter);
 910         password = g_variant_dup_string (_tmp1_, NULL);
 911         g_variant_unref (_tmp1_);
 912         _tmp2_ = g_variant_iter_next_value (&_arguments_iter);
 913         service = g_variant_dup_string (_tmp2_, NULL);
 914         g_variant_unref (_tmp2_);
 915         moonshot_server_get_identity (self, nai, password, service, (GAsyncReadyCallback) _dbus_moonshot_server_get_identity_ready, g_object_ref (invocation));
 916         _g_free0 (nai);
 917         _g_free0 (password);
 918         _g_free0 (service);
 919 }
 920
 921
 922 static void _dbus_moonshot_server_get_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 923         GDBusMethodInvocation * invocation;
 924         GError* error;
 925         char* nai_out = NULL;
 926         char* password_out = NULL;
 927         char* server_certificate_hash = NULL;
 928         char* ca_certificate = NULL;
 929         char* subject_name_constraint = NULL;
 930         char* subject_alt_name_constraint = NULL;
 931         gboolean result;
 932         GVariant* _reply;
 933         GVariantBuilder _reply_builder;
 934         invocation = _user_data_;
 935         error = NULL;
 936         result = moonshot_server_get_identity_finish ((MoonshotServer*) source_object, _res_, &nai_out, &password_out, &server_certificate_hash, &ca_certificate, &subject_name_constraint, &subject_alt_name_constraint);
 937         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
 938         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (nai_out));
 939         _g_free0 (nai_out);
 940         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (password_out));
 941         _g_free0 (password_out);
 942         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (server_certificate_hash));
 943         _g_free0 (server_certificate_hash);
 944         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (ca_certificate));
 945         _g_free0 (ca_certificate);
 946         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_name_constraint));
 947         _g_free0 (subject_name_constraint);
 948         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_alt_name_constraint));
 949         _g_free0 (subject_alt_name_constraint);
 950         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
 951         _reply = g_variant_builder_end (&_reply_builder);
 952         g_dbus_method_invocation_return_value (invocation, _reply);
 953         g_object_unref (invocation);
 954         g_variant_unref (_reply);
 955 }
 956
 957
 958 static void _dbus_moonshot_server_get_default_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
 959         GVariantIter _arguments_iter;
 960         g_variant_iter_init (&_arguments_iter, parameters);
 961         moonshot_server_get_default_identity (self, (GAsyncReadyCallback) _dbus_moonshot_server_get_default_identity_ready, g_object_ref (invocation));
 962 }
 963
 964
 965 static void _dbus_moonshot_server_get_default_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
 966         GDBusMethodInvocation * invocation;
 967         GError* error;
 968         char* nai_out = NULL;
 969         char* password_out = NULL;
 970         char* server_certificate_hash = NULL;
 971         char* ca_certificate = NULL;
 972         char* subject_name_constraint = NULL;
 973         char* subject_alt_name_constraint = NULL;
 974         gboolean result;
 975         GVariant* _reply;
 976         GVariantBuilder _reply_builder;
 977         invocation = _user_data_;
 978         error = NULL;
 979         result = moonshot_server_get_default_identity_finish ((MoonshotServer*) source_object, _res_, &nai_out, &password_out, &server_certificate_hash, &ca_certificate, &subject_name_constraint, &subject_alt_name_constraint);
 980         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
 981         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (nai_out));
 982         _g_free0 (nai_out);
 983         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (password_out));
 984         _g_free0 (password_out);
 985         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (server_certificate_hash));
 986         _g_free0 (server_certificate_hash);
 987         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (ca_certificate));
 988         _g_free0 (ca_certificate);
 989         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_name_constraint));
 990         _g_free0 (subject_name_constraint);
 991         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_alt_name_constraint));
 992         _g_free0 (subject_alt_name_constraint);
 993         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
 994         _reply = g_variant_builder_end (&_reply_builder);
 995         g_dbus_method_invocation_return_value (invocation, _reply);
 996         g_object_unref (invocation);
 997         g_variant_unref (_reply);
 998 }
 999
1000
1001 static void _dbus_moonshot_server_install_id_card (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1002         GError* error;
1003         char* display_name = NULL;
1004         GVariant* _tmp3_;
1005         char* user_name = NULL;
1006         GVariant* _tmp4_;
1007         char* password = NULL;
1008         GVariant* _tmp5_;
1009         char* realm = NULL;
1010         GVariant* _tmp6_;
1011         char** rules_patterns = NULL;
1012         int rules_patterns_length1;
1013         GVariant* _tmp7_;
1014         char** _tmp8_;
1015         int _tmp8__length;
1016         int _tmp8__size;
1017         int _tmp8__length1;
1018         GVariantIter _tmp9_;
1019         GVariant* _tmp10_;
1020         char** rules_always_confirm = NULL;
1021         int rules_always_confirm_length1;
1022         GVariant* _tmp11_;
1023         char** _tmp12_;
1024         int _tmp12__length;
1025         int _tmp12__size;
1026         int _tmp12__length1;
1027         GVariantIter _tmp13_;
1028         GVariant* _tmp14_;
1029         char** services = NULL;
1030         int services_length1;
1031         GVariant* _tmp15_;
1032         char** _tmp16_;
1033         int _tmp16__length;
1034         int _tmp16__size;
1035         int _tmp16__length1;
1036         GVariantIter _tmp17_;
1037         GVariant* _tmp18_;
1038         char* ca_cert = NULL;
1039         GVariant* _tmp19_;
1040         char* subject = NULL;
1041         GVariant* _tmp20_;
1042         char* subject_alt = NULL;
1043         GVariant* _tmp21_;
1044         char* server_cert = NULL;
1045         GVariant* _tmp22_;
1046         gboolean result;
1047         GVariantIter _arguments_iter;
1048         GVariant* _reply;
1049         GVariantBuilder _reply_builder;
1050         error = NULL;
1051         g_variant_iter_init (&_arguments_iter, parameters);
1052         _tmp3_ = g_variant_iter_next_value (&_arguments_iter);
1053         display_name = g_variant_dup_string (_tmp3_, NULL);
1054         g_variant_unref (_tmp3_);
1055         _tmp4_ = g_variant_iter_next_value (&_arguments_iter);
1056         user_name = g_variant_dup_string (_tmp4_, NULL);
1057         g_variant_unref (_tmp4_);
1058         _tmp5_ = g_variant_iter_next_value (&_arguments_iter);
1059         password = g_variant_dup_string (_tmp5_, NULL);
1060         g_variant_unref (_tmp5_);
1061         _tmp6_ = g_variant_iter_next_value (&_arguments_iter);
1062         realm = g_variant_dup_string (_tmp6_, NULL);
1063         g_variant_unref (_tmp6_);
1064         rules_patterns_length1 = 0;
1065         _tmp7_ = g_variant_iter_next_value (&_arguments_iter);
1066         _tmp8_ = g_new (char*, 5);
1067         _tmp8__length = 0;
1068         _tmp8__size = 4;
1069         _tmp8__length1 = 0;
1070         g_variant_iter_init (&_tmp9_, _tmp7_);
1071         for (; _tmp10_ = g_variant_iter_next_value (&_tmp9_); _tmp8__length1++) {
1072                 if (_tmp8__size == _tmp8__length) {
1073                         _tmp8__size = 2 * _tmp8__size;
1074                         _tmp8_ = g_renew (char*, _tmp8_, _tmp8__size + 1);
1075                 }
1076                 _tmp8_[_tmp8__length++] = g_variant_dup_string (_tmp10_, NULL);
1077                 g_variant_unref (_tmp10_);
1078         }
1079         rules_patterns_length1 = _tmp8__length1;
1080         _tmp8_[_tmp8__length] = NULL;
1081         rules_patterns = _tmp8_;
1082         g_variant_unref (_tmp7_);
1083         rules_always_confirm_length1 = 0;
1084         _tmp11_ = g_variant_iter_next_value (&_arguments_iter);
1085         _tmp12_ = g_new (char*, 5);
1086         _tmp12__length = 0;
1087         _tmp12__size = 4;
1088         _tmp12__length1 = 0;
1089         g_variant_iter_init (&_tmp13_, _tmp11_);
1090         for (; _tmp14_ = g_variant_iter_next_value (&_tmp13_); _tmp12__length1++) {
1091                 if (_tmp12__size == _tmp12__length) {
1092                         _tmp12__size = 2 * _tmp12__size;
1093                         _tmp12_ = g_renew (char*, _tmp12_, _tmp12__size + 1);
1094                 }
1095                 _tmp12_[_tmp12__length++] = g_variant_dup_string (_tmp14_, NULL);
1096                 g_variant_unref (_tmp14_);
1097         }
1098         rules_always_confirm_length1 = _tmp12__length1;
1099         _tmp12_[_tmp12__length] = NULL;
1100         rules_always_confirm = _tmp12_;
1101         g_variant_unref (_tmp11_);
1102         services_length1 = 0;
1103         _tmp15_ = g_variant_iter_next_value (&_arguments_iter);
1104         _tmp16_ = g_new (char*, 5);
1105         _tmp16__length = 0;
1106         _tmp16__size = 4;
1107         _tmp16__length1 = 0;
1108         g_variant_iter_init (&_tmp17_, _tmp15_);
1109         for (; _tmp18_ = g_variant_iter_next_value (&_tmp17_); _tmp16__length1++) {
1110                 if (_tmp16__size == _tmp16__length) {
1111                         _tmp16__size = 2 * _tmp16__size;
1112                         _tmp16_ = g_renew (char*, _tmp16_, _tmp16__size + 1);
1113                 }
1114                 _tmp16_[_tmp16__length++] = g_variant_dup_string (_tmp18_, NULL);
1115                 g_variant_unref (_tmp18_);
1116         }
1117         services_length1 = _tmp16__length1;
1118         _tmp16_[_tmp16__length] = NULL;
1119         services = _tmp16_;
1120         g_variant_unref (_tmp15_);
1121         _tmp19_ = g_variant_iter_next_value (&_arguments_iter);
1122         ca_cert = g_variant_dup_string (_tmp19_, NULL);
1123         g_variant_unref (_tmp19_);
1124         _tmp20_ = g_variant_iter_next_value (&_arguments_iter);
1125         subject = g_variant_dup_string (_tmp20_, NULL);
1126         g_variant_unref (_tmp20_);
1127         _tmp21_ = g_variant_iter_next_value (&_arguments_iter);
1128         subject_alt = g_variant_dup_string (_tmp21_, NULL);
1129         g_variant_unref (_tmp21_);
1130         _tmp22_ = g_variant_iter_next_value (&_arguments_iter);
1131         server_cert = g_variant_dup_string (_tmp22_, NULL);
1132         g_variant_unref (_tmp22_);
1133         result = moonshot_server_install_id_card (self, display_name, user_name, password, realm, rules_patterns, rules_patterns_length1, rules_always_confirm, rules_always_confirm_length1, services, services_length1, ca_cert, subject, subject_alt, server_cert);
1134         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1135         _g_free0 (display_name);
1136         _g_free0 (user_name);
1137         _g_free0 (password);
1138         _g_free0 (realm);
1139         rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
1140         rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
1141         services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
1142         _g_free0 (ca_cert);
1143         _g_free0 (subject);
1144         _g_free0 (subject_alt);
1145         _g_free0 (server_cert);
1146         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
1147         _reply = g_variant_builder_end (&_reply_builder);
1148         g_dbus_method_invocation_return_value (invocation, _reply);
1149 }
1150
1151
1152 static void _dbus_moonshot_server_install_from_file (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1153         GError* error;
1154         char* file_name = NULL;
1155         GVariant* _tmp23_;
1156         gboolean result;
1157         GVariantIter _arguments_iter;
1158         GVariant* _reply;
1159         GVariantBuilder _reply_builder;
1160         error = NULL;
1161         g_variant_iter_init (&_arguments_iter, parameters);
1162         _tmp23_ = g_variant_iter_next_value (&_arguments_iter);
1163         file_name = g_variant_dup_string (_tmp23_, NULL);
1164         g_variant_unref (_tmp23_);
1165         result = moonshot_server_install_from_file (self, file_name);
1166         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1167         _g_free0 (file_name);
1168         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
1169         _reply = g_variant_builder_end (&_reply_builder);
1170         g_dbus_method_invocation_return_value (invocation, _reply);
1171 }
1172
1173
1174 static void moonshot_server_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
1175         gpointer* data;
1176         gpointer object;
1177         data = user_data;
1178         object = data[0];
1179         if (strcmp (method_name, "GetIdentity") == 0) {
1180                 _dbus_moonshot_server_get_identity (object, parameters, invocation);
1181         } else if (strcmp (method_name, "GetDefaultIdentity") == 0) {
1182                 _dbus_moonshot_server_get_default_identity (object, parameters, invocation);
1183         } else if (strcmp (method_name, "InstallIdCard") == 0) {
1184                 _dbus_moonshot_server_install_id_card (object, parameters, invocation);
1185         } else if (strcmp (method_name, "InstallFromFile") == 0) {
1186                 _dbus_moonshot_server_install_from_file (object, parameters, invocation);
1187         }
1188 }
1189
1190
1191 static GVariant* moonshot_server_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
1192         gpointer* data;
1193         gpointer object;
1194         data = user_data;
1195         object = data[0];
1196         return NULL;
1197 }
1198
1199
1200 static gboolean moonshot_server_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
1201         gpointer* data;
1202         gpointer object;
1203         data = user_data;
1204         object = data[0];
1205         return FALSE;
1206 }
1207
1208
1209 guint moonshot_server_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
1210         guint result;
1211         gpointer *data;
1212         data = g_new (gpointer, 3);
1213         data[0] = g_object_ref (object);
1214         data[1] = g_object_ref (connection);
1215         data[2] = g_strdup (path);
1216         result = g_dbus_connection_register_object (connection, path, &_moonshot_server_dbus_interface_info, &_moonshot_server_dbus_interface_vtable, data, _moonshot_server_unregister_object, error);
1217         if (!result) {
1218                 return 0;
1219         }
1220         return result;
1221 }
1222
1223
1224 static void _moonshot_server_unregister_object (gpointer user_data) {
1225         gpointer* data;
1226         data = user_data;
1227         g_object_unref (data[0]);
1228         g_object_unref (data[1]);
1229         g_free (data[2]);
1230         g_free (data);
1231 }
1232
1233
1234 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1235         if ((array != NULL) && (destroy_func != NULL)) {
1236                 int i;
1237                 for (i = 0; i < array_length; i = i + 1) {
1238                         if (((gpointer*) array)[i] != NULL) {
1239                                 destroy_func (((gpointer*) array)[i]);
1240                         }
1241                 }
1242         }
1243 }
1244
1245
1246 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1247         _vala_array_destroy (array, array_length, destroy_func);
1248         g_free (array);
1249 }
1250
1251
1252
1253