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 gint 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", "i"};
 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 #line 8 "moonshot-server.vala"
 357 MoonshotServer* moonshot_server_construct (GType object_type, GtkWindow* window) {
 358 #line 359 "moonshot-server.c"
 359         MoonshotServer * self = NULL;
 360         IdentityManagerView* _tmp0_;
 361 #line 8 "moonshot-server.vala"
 362         g_return_val_if_fail (window != NULL, NULL);
 363 #line 8 "moonshot-server.vala"
 364         self = (MoonshotServer*) g_object_new (object_type, NULL);
 365 #line 10 "moonshot-server.vala"
 366         self->priv->main_window = (_tmp0_ = _g_object_ref0 (IDENTITY_MANAGER_VIEW (window)), _g_object_unref0 (self->priv->main_window), _tmp0_);
 367 #line 368 "moonshot-server.c"
 368         return self;
 369 }
 370
 371
 372 #line 8 "moonshot-server.vala"
 373 MoonshotServer* moonshot_server_new (GtkWindow* window) {
 374 #line 8 "moonshot-server.vala"
 375         return moonshot_server_construct (TYPE_MOONSHOT_SERVER, window);
 376 #line 377 "moonshot-server.c"
 377 }
 378
 379
 380 static void moonshot_server_get_identity_data_free (gpointer _data) {
 381         MoonshotServerGetIdentityData* data;
 382         data = _data;
 383         _g_free0 (data->nai);
 384         _g_free0 (data->password);
 385         _g_free0 (data->service);
 386         g_object_unref (data->self);
 387         g_slice_free (MoonshotServerGetIdentityData, data);
 388 }
 389
 390
 391 void moonshot_server_get_identity (MoonshotServer* self, const char* nai, const char* password, const char* service, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 392         MoonshotServerGetIdentityData* _data_;
 393         _data_ = g_slice_new0 (MoonshotServerGetIdentityData);
 394         _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, moonshot_server_get_identity);
 395         g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, moonshot_server_get_identity_data_free);
 396         _data_->self = g_object_ref (self);
 397         _data_->nai = g_strdup (nai);
 398         _data_->password = g_strdup (password);
 399         _data_->service = g_strdup (service);
 400         moonshot_server_get_identity_co (_data_);
 401 }
 402
 403
 404 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) {
 405         gboolean result;
 406         MoonshotServerGetIdentityData* _data_;
 407         _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 408         *nai_out = _data_->nai_out;
 409         _data_->nai_out = NULL;
 410         *password_out = _data_->password_out;
 411         _data_->password_out = NULL;
 412         *server_certificate_hash = _data_->server_certificate_hash;
 413         _data_->server_certificate_hash = NULL;
 414         *ca_certificate = _data_->ca_certificate;
 415         _data_->ca_certificate = NULL;
 416         *subject_name_constraint = _data_->subject_name_constraint;
 417         _data_->subject_name_constraint = NULL;
 418         *subject_alt_name_constraint = _data_->subject_alt_name_constraint;
 419         _data_->subject_alt_name_constraint = NULL;
 420         result = _data_->result;
 421         return result;
 422 }
 423
 424
 425 static void moonshot_server_get_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 426         MoonshotServerGetIdentityData* data;
 427         data = _user_data_;
 428         data->_res_ = _res_;
 429         moonshot_server_get_identity_co (data);
 430 }
 431
 432
 433 #line 27 "moonshot-server.vala"
 434 static void _lambda4_ (IdentityRequest* IdentityRequest, Block3Data* _data3_) {
 435 #line 436 "moonshot-server.c"
 436         MoonshotServer * self;
 437         self = _data3_->self;
 438 #line 27 "moonshot-server.vala"
 439         g_return_if_fail (IdentityRequest != NULL);
 440 #line 27 "moonshot-server.vala"
 441         moonshot_server_get_identity_co (_data3_->_async_data_);
 442 #line 443 "moonshot-server.c"
 443 }
 444
 445
 446 #line 27 "moonshot-server.vala"
 447 static void __lambda4__return_identity_callback (IdentityRequest* request, gpointer self) {
 448 #line 449 "moonshot-server.c"
 449         _lambda4_ (request, self);
 450 }
 451
 452
 453 static Block3Data* block3_data_ref (Block3Data* _data3_) {
 454         g_atomic_int_inc (&_data3_->_ref_count_);
 455         return _data3_;
 456 }
 457
 458
 459 static void block3_data_unref (Block3Data* _data3_) {
 460         if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
 461                 _g_object_unref0 (_data3_->self);
 462                 g_slice_free (Block3Data, _data3_);
 463         }
 464 }
 465
 466
 467 static gboolean moonshot_server_get_identity_co (MoonshotServerGetIdentityData* data) {
 468         switch (data->_state_) {
 469                 case 0:
 470                 goto _state_0;
 471                 default:
 472                 g_assert_not_reached ();
 473                 case 1:
 474                 goto _state_1;
 475         }
 476         _state_0:
 477         data->_data3_ = g_slice_new0 (Block3Data);
 478         data->_data3_->_ref_count_ = 1;
 479         data->_data3_->self = g_object_ref (data->self);
 480         data->_data3_->_async_data_ = data;
 481         data->request = identity_request_new (data->self->priv->main_window, data->nai, data->password, data->service);
 482 #line 27 "moonshot-server.vala"
 483         identity_request_set_callback (data->request, __lambda4__return_identity_callback, block3_data_ref (data->_data3_), block3_data_unref);
 484 #line 28 "moonshot-server.vala"
 485         identity_request_execute (data->request);
 486 #line 487 "moonshot-server.c"
 487         data->_state_ = 1;
 488         return FALSE;
 489         _state_1:
 490         ;
 491 #line 31 "moonshot-server.vala"
 492         data->nai_out = (data->_tmp0_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp0_);
 493 #line 32 "moonshot-server.vala"
 494         data->password_out = (data->_tmp1_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp1_);
 495 #line 33 "moonshot-server.vala"
 496         data->server_certificate_hash = (data->_tmp2_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp2_);
 497 #line 34 "moonshot-server.vala"
 498         data->ca_certificate = (data->_tmp3_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp3_);
 499 #line 35 "moonshot-server.vala"
 500         data->subject_name_constraint = (data->_tmp4_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp4_);
 501 #line 36 "moonshot-server.vala"
 502         data->subject_alt_name_constraint = (data->_tmp5_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp5_);
 503 #line 504 "moonshot-server.c"
 504         data->id_card = _g_object_ref0 (data->request->id_card);
 505 #line 40 "moonshot-server.vala"
 506         if (data->id_card != NULL) {
 507 #line 41 "moonshot-server.vala"
 508                 data->nai_out = (data->_tmp6_ = g_strdup (id_card_get_nai (data->id_card)), _g_free0 (data->nai_out), data->_tmp6_);
 509 #line 42 "moonshot-server.vala"
 510                 data->password_out = (data->_tmp7_ = g_strdup (id_card_get_password (data->id_card)), _g_free0 (data->password_out), data->_tmp7_);
 511 #line 44 "moonshot-server.vala"
 512                 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_);
 513 #line 45 "moonshot-server.vala"
 514                 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_);
 515 #line 46 "moonshot-server.vala"
 516                 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_);
 517 #line 47 "moonshot-server.vala"
 518                 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_);
 519 #line 49 "moonshot-server.vala"
 520                 if (data->nai_out == NULL) {
 521 #line 50 "moonshot-server.vala"
 522                         data->nai_out = (data->_tmp12_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp12_);
 523 #line 524 "moonshot-server.c"
 524                 }
 525 #line 51 "moonshot-server.vala"
 526                 if (data->password_out == NULL) {
 527 #line 52 "moonshot-server.vala"
 528                         data->password_out = (data->_tmp13_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp13_);
 529 #line 530 "moonshot-server.c"
 530                 }
 531 #line 53 "moonshot-server.vala"
 532                 if (data->server_certificate_hash == NULL) {
 533 #line 54 "moonshot-server.vala"
 534                         data->server_certificate_hash = (data->_tmp14_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp14_);
 535 #line 536 "moonshot-server.c"
 536                 }
 537 #line 55 "moonshot-server.vala"
 538                 if (data->ca_certificate == NULL) {
 539 #line 56 "moonshot-server.vala"
 540                         data->ca_certificate = (data->_tmp15_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp15_);
 541 #line 542 "moonshot-server.c"
 542                 }
 543 #line 57 "moonshot-server.vala"
 544                 if (data->subject_name_constraint == NULL) {
 545 #line 58 "moonshot-server.vala"
 546                         data->subject_name_constraint = (data->_tmp16_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp16_);
 547 #line 548 "moonshot-server.c"
 548                 }
 549 #line 59 "moonshot-server.vala"
 550                 if (data->subject_alt_name_constraint == NULL) {
 551 #line 60 "moonshot-server.vala"
 552                         data->subject_alt_name_constraint = (data->_tmp17_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp17_);
 553 #line 554 "moonshot-server.c"
 554                 }
 555                 data->result = TRUE;
 556                 _g_object_unref0 (data->id_card);
 557                 _g_object_unref0 (data->request);
 558                 block3_data_unref (data->_data3_);
 559                 {
 560                         if (data->_state_ == 0) {
 561                                 g_simple_async_result_complete_in_idle (data->_async_result);
 562                         } else {
 563                                 g_simple_async_result_complete (data->_async_result);
 564                         }
 565                         g_object_unref (data->_async_result);
 566                         return FALSE;
 567                 }
 568         }
 569         data->result = FALSE;
 570         _g_object_unref0 (data->id_card);
 571         _g_object_unref0 (data->request);
 572         block3_data_unref (data->_data3_);
 573         {
 574                 if (data->_state_ == 0) {
 575                         g_simple_async_result_complete_in_idle (data->_async_result);
 576                 } else {
 577                         g_simple_async_result_complete (data->_async_result);
 578                 }
 579                 g_object_unref (data->_async_result);
 580                 return FALSE;
 581         }
 582         _g_object_unref0 (data->id_card);
 583         _g_object_unref0 (data->request);
 584         block3_data_unref (data->_data3_);
 585         {
 586                 if (data->_state_ == 0) {
 587                         g_simple_async_result_complete_in_idle (data->_async_result);
 588                 } else {
 589                         g_simple_async_result_complete (data->_async_result);
 590                 }
 591                 g_object_unref (data->_async_result);
 592                 return FALSE;
 593         }
 594 }
 595
 596
 597 static void moonshot_server_get_default_identity_data_free (gpointer _data) {
 598         MoonshotServerGetDefaultIdentityData* data;
 599         data = _data;
 600         g_object_unref (data->self);
 601         g_slice_free (MoonshotServerGetDefaultIdentityData, data);
 602 }
 603
 604
 605 void moonshot_server_get_default_identity (MoonshotServer* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 606         MoonshotServerGetDefaultIdentityData* _data_;
 607         _data_ = g_slice_new0 (MoonshotServerGetDefaultIdentityData);
 608         _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, moonshot_server_get_default_identity);
 609         g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, moonshot_server_get_default_identity_data_free);
 610         _data_->self = g_object_ref (self);
 611         moonshot_server_get_default_identity_co (_data_);
 612 }
 613
 614
 615 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) {
 616         gboolean result;
 617         MoonshotServerGetDefaultIdentityData* _data_;
 618         _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 619         *nai_out = _data_->nai_out;
 620         _data_->nai_out = NULL;
 621         *password_out = _data_->password_out;
 622         _data_->password_out = NULL;
 623         *server_certificate_hash = _data_->server_certificate_hash;
 624         _data_->server_certificate_hash = NULL;
 625         *ca_certificate = _data_->ca_certificate;
 626         _data_->ca_certificate = NULL;
 627         *subject_name_constraint = _data_->subject_name_constraint;
 628         _data_->subject_name_constraint = NULL;
 629         *subject_alt_name_constraint = _data_->subject_alt_name_constraint;
 630         _data_->subject_alt_name_constraint = NULL;
 631         result = _data_->result;
 632         return result;
 633 }
 634
 635
 636 static void moonshot_server_get_default_identity_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 637         MoonshotServerGetDefaultIdentityData* data;
 638         data = _user_data_;
 639         data->_res_ = _res_;
 640         moonshot_server_get_default_identity_co (data);
 641 }
 642
 643
 644 #line 76 "moonshot-server.vala"
 645 static void _lambda5_ (IdentityRequest* IdentityRequest, Block4Data* _data4_) {
 646 #line 647 "moonshot-server.c"
 647         MoonshotServer * self;
 648         self = _data4_->self;
 649 #line 76 "moonshot-server.vala"
 650         g_return_if_fail (IdentityRequest != NULL);
 651 #line 76 "moonshot-server.vala"
 652         moonshot_server_get_default_identity_co (_data4_->_async_data_);
 653 #line 654 "moonshot-server.c"
 654 }
 655
 656
 657 #line 76 "moonshot-server.vala"
 658 static void __lambda5__return_identity_callback (IdentityRequest* request, gpointer self) {
 659 #line 660 "moonshot-server.c"
 660         _lambda5_ (request, self);
 661 }
 662
 663
 664 static Block4Data* block4_data_ref (Block4Data* _data4_) {
 665         g_atomic_int_inc (&_data4_->_ref_count_);
 666         return _data4_;
 667 }
 668
 669
 670 static void block4_data_unref (Block4Data* _data4_) {
 671         if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
 672                 _g_object_unref0 (_data4_->self);
 673                 g_slice_free (Block4Data, _data4_);
 674         }
 675 }
 676
 677
 678 static gboolean moonshot_server_get_default_identity_co (MoonshotServerGetDefaultIdentityData* data) {
 679         switch (data->_state_) {
 680                 case 0:
 681                 goto _state_0;
 682                 default:
 683                 g_assert_not_reached ();
 684                 case 2:
 685                 goto _state_2;
 686         }
 687         _state_0:
 688         data->_data4_ = g_slice_new0 (Block4Data);
 689         data->_data4_->_ref_count_ = 1;
 690         data->_data4_->self = g_object_ref (data->self);
 691         data->_data4_->_async_data_ = data;
 692         data->request = identity_request_new_default (data->self->priv->main_window);
 693 #line 76 "moonshot-server.vala"
 694         identity_request_set_callback (data->request, __lambda5__return_identity_callback, block4_data_ref (data->_data4_), block4_data_unref);
 695 #line 77 "moonshot-server.vala"
 696         identity_request_execute (data->request);
 697 #line 698 "moonshot-server.c"
 698         data->_state_ = 2;
 699         return FALSE;
 700         _state_2:
 701         ;
 702 #line 80 "moonshot-server.vala"
 703         data->nai_out = (data->_tmp0_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp0_);
 704 #line 81 "moonshot-server.vala"
 705         data->password_out = (data->_tmp1_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp1_);
 706 #line 82 "moonshot-server.vala"
 707         data->server_certificate_hash = (data->_tmp2_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp2_);
 708 #line 83 "moonshot-server.vala"
 709         data->ca_certificate = (data->_tmp3_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp3_);
 710 #line 84 "moonshot-server.vala"
 711         data->subject_name_constraint = (data->_tmp4_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp4_);
 712 #line 85 "moonshot-server.vala"
 713         data->subject_alt_name_constraint = (data->_tmp5_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp5_);
 714 #line 87 "moonshot-server.vala"
 715         if (data->request->id_card != NULL) {
 716 #line 89 "moonshot-server.vala"
 717                 data->nai_out = (data->_tmp6_ = g_strdup (id_card_get_nai (data->request->id_card)), _g_free0 (data->nai_out), data->_tmp6_);
 718 #line 90 "moonshot-server.vala"
 719                 data->password_out = (data->_tmp7_ = g_strdup (id_card_get_password (data->request->id_card)), _g_free0 (data->password_out), data->_tmp7_);
 720 #line 92 "moonshot-server.vala"
 721                 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_);
 722 #line 93 "moonshot-server.vala"
 723                 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_);
 724 #line 94 "moonshot-server.vala"
 725                 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_);
 726 #line 95 "moonshot-server.vala"
 727                 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_);
 728 #line 97 "moonshot-server.vala"
 729                 if (data->nai_out == NULL) {
 730 #line 98 "moonshot-server.vala"
 731                         data->nai_out = (data->_tmp12_ = g_strdup (""), _g_free0 (data->nai_out), data->_tmp12_);
 732 #line 733 "moonshot-server.c"
 733                 }
 734 #line 99 "moonshot-server.vala"
 735                 if (data->password_out == NULL) {
 736 #line 100 "moonshot-server.vala"
 737                         data->password_out = (data->_tmp13_ = g_strdup (""), _g_free0 (data->password_out), data->_tmp13_);
 738 #line 739 "moonshot-server.c"
 739                 }
 740 #line 101 "moonshot-server.vala"
 741                 if (data->server_certificate_hash == NULL) {
 742 #line 102 "moonshot-server.vala"
 743                         data->server_certificate_hash = (data->_tmp14_ = g_strdup (""), _g_free0 (data->server_certificate_hash), data->_tmp14_);
 744 #line 745 "moonshot-server.c"
 745                 }
 746 #line 103 "moonshot-server.vala"
 747                 if (data->ca_certificate == NULL) {
 748 #line 104 "moonshot-server.vala"
 749                         data->ca_certificate = (data->_tmp15_ = g_strdup (""), _g_free0 (data->ca_certificate), data->_tmp15_);
 750 #line 751 "moonshot-server.c"
 751                 }
 752 #line 105 "moonshot-server.vala"
 753                 if (data->subject_name_constraint == NULL) {
 754 #line 106 "moonshot-server.vala"
 755                         data->subject_name_constraint = (data->_tmp16_ = g_strdup (""), _g_free0 (data->subject_name_constraint), data->_tmp16_);
 756 #line 757 "moonshot-server.c"
 757                 }
 758 #line 107 "moonshot-server.vala"
 759                 if (data->subject_alt_name_constraint == NULL) {
 760 #line 108 "moonshot-server.vala"
 761                         data->subject_alt_name_constraint = (data->_tmp17_ = g_strdup (""), _g_free0 (data->subject_alt_name_constraint), data->_tmp17_);
 762 #line 763 "moonshot-server.c"
 763                 }
 764                 data->result = TRUE;
 765                 _g_object_unref0 (data->request);
 766                 block4_data_unref (data->_data4_);
 767                 {
 768                         if (data->_state_ == 0) {
 769                                 g_simple_async_result_complete_in_idle (data->_async_result);
 770                         } else {
 771                                 g_simple_async_result_complete (data->_async_result);
 772                         }
 773                         g_object_unref (data->_async_result);
 774                         return FALSE;
 775                 }
 776         }
 777         data->result = FALSE;
 778         _g_object_unref0 (data->request);
 779         block4_data_unref (data->_data4_);
 780         {
 781                 if (data->_state_ == 0) {
 782                         g_simple_async_result_complete_in_idle (data->_async_result);
 783                 } else {
 784                         g_simple_async_result_complete (data->_async_result);
 785                 }
 786                 g_object_unref (data->_async_result);
 787                 return FALSE;
 788         }
 789         _g_object_unref0 (data->request);
 790         block4_data_unref (data->_data4_);
 791         {
 792                 if (data->_state_ == 0) {
 793                         g_simple_async_result_complete_in_idle (data->_async_result);
 794                 } else {
 795                         g_simple_async_result_complete (data->_async_result);
 796                 }
 797                 g_object_unref (data->_async_result);
 798                 return FALSE;
 799         }
 800 }
 801
 802
 803 static void _vala_Rule_array_free (Rule* array, gint array_length) {
 804         if (array != NULL) {
 805                 int i;
 806                 for (i = 0; i < array_length; i = i + 1) {
 807                         rule_destroy (&array[i]);
 808                 }
 809         }
 810         g_free (array);
 811 }
 812
 813
 814 #line 116 "moonshot-server.vala"
 815 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) {
 816 #line 817 "moonshot-server.c"
 817         gboolean result = FALSE;
 818         IdCard* idcard;
 819         char** _tmp0_;
 820 #line 116 "moonshot-server.vala"
 821         g_return_val_if_fail (self != NULL, FALSE);
 822 #line 116 "moonshot-server.vala"
 823         g_return_val_if_fail (display_name != NULL, FALSE);
 824 #line 116 "moonshot-server.vala"
 825         g_return_val_if_fail (user_name != NULL, FALSE);
 826 #line 128 "moonshot-server.vala"
 827         idcard = id_card_new ();
 828 #line 130 "moonshot-server.vala"
 829         id_card_set_display_name (idcard, display_name);
 830 #line 131 "moonshot-server.vala"
 831         id_card_set_username (idcard, user_name);
 832 #line 132 "moonshot-server.vala"
 833         id_card_set_password (idcard, password);
 834 #line 133 "moonshot-server.vala"
 835         id_card_set_issuer (idcard, realm);
 836 #line 134 "moonshot-server.vala"
 837         _tmp0_ = services;
 838 #line 134 "moonshot-server.vala"
 839         id_card_set_services (idcard, _tmp0_, services_length1);
 840 #line 135 "moonshot-server.vala"
 841         trust_anchor_set_ca_cert (id_card_get_trust_anchor (idcard), ca_cert);
 842 #line 136 "moonshot-server.vala"
 843         trust_anchor_set_subject (id_card_get_trust_anchor (idcard), subject);
 844 #line 137 "moonshot-server.vala"
 845         trust_anchor_set_subject_alt (id_card_get_trust_anchor (idcard), subject_alt);
 846 #line 138 "moonshot-server.vala"
 847         trust_anchor_set_server_cert (id_card_get_trust_anchor (idcard), server_cert);
 848 #line 140 "moonshot-server.vala"
 849         if (rules_patterns_length1 == rules_always_confirm_length1) {
 850 #line 851 "moonshot-server.c"
 851                 Rule* _tmp1_;
 852                 gint _tmp1__length1;
 853                 Rule* _tmp2_;
 854 #line 142 "moonshot-server.vala"
 855                 _tmp2_ = (_tmp1_ = g_new0 (Rule, rules_patterns_length1), _tmp1__length1 = rules_patterns_length1, _tmp1_);
 856 #line 142 "moonshot-server.vala"
 857                 id_card_set_rules (idcard, _tmp2_, rules_patterns_length1);
 858 #line 859 "moonshot-server.c"
 859                 _tmp1_ = (_vala_Rule_array_free (_tmp1_, _tmp1__length1), NULL);
 860                 {
 861                         gint i;
 862 #line 144 "moonshot-server.vala"
 863                         i = 0;
 864 #line 865 "moonshot-server.c"
 865                         {
 866                                 gboolean _tmp3_;
 867 #line 144 "moonshot-server.vala"
 868                                 _tmp3_ = TRUE;
 869 #line 144 "moonshot-server.vala"
 870                                 while (TRUE) {
 871 #line 872 "moonshot-server.c"
 872                                         gint _tmp4_;
 873                                         gint _tmp5_;
 874                                         char* *_tmp6_;
 875                                         char* _tmp7_;
 876                                         gint _tmp8_;
 877                                         char* *_tmp9_;
 878                                         char* _tmp10_;
 879 #line 144 "moonshot-server.vala"
 880                                         if (!_tmp3_) {
 881 #line 144 "moonshot-server.vala"
 882                                                 i++;
 883 #line 884 "moonshot-server.c"
 884                                         }
 885 #line 144 "moonshot-server.vala"
 886                                         _tmp3_ = FALSE;
 887 #line 144 "moonshot-server.vala"
 888                                         if (!(i < _tmp4_)) {
 889 #line 144 "moonshot-server.vala"
 890                                                 break;
 891 #line 892 "moonshot-server.c"
 892                                         }
 893 #line 146 "moonshot-server.vala"
 894                                         _tmp6_ = &id_card_get_rules (idcard, &_tmp5_)[i].pattern;
 895 #line 146 "moonshot-server.vala"
 896                                         (*_tmp6_) = (_tmp7_ = g_strdup (rules_patterns[i]), _g_free0 ((*_tmp6_)), _tmp7_);
 897 #line 147 "moonshot-server.vala"
 898                                         _tmp9_ = &id_card_get_rules (idcard, &_tmp8_)[i].always_confirm;
 899 #line 147 "moonshot-server.vala"
 900                                         (*_tmp9_) = (_tmp10_ = g_strdup (rules_always_confirm[i]), _g_free0 ((*_tmp9_)), _tmp10_);
 901 #line 902 "moonshot-server.c"
 902                                 }
 903                         }
 904                 }
 905         }
 906         result = identity_manager_view_add_identity (self->priv->main_window, idcard);
 907         _g_object_unref0 (idcard);
 908 #line 151 "moonshot-server.vala"
 909         return result;
 910 #line 911 "moonshot-server.c"
 911 }
 912
 913
 914 #line 155 "moonshot-server.vala"
 915 gint moonshot_server_install_from_file (MoonshotServer* self, const char* file_name) {
 916 #line 917 "moonshot-server.c"
 917         gint result = 0;
 918         WebProvisioningParser* webp;
 919         gboolean _result_;
 920         gint installed_cards;
 921 #line 155 "moonshot-server.vala"
 922         g_return_val_if_fail (self != NULL, 0);
 923 #line 155 "moonshot-server.vala"
 924         g_return_val_if_fail (file_name != NULL, 0);
 925 #line 157 "moonshot-server.vala"
 926         webp = web_provisioning_parser_new (file_name);
 927 #line 159 "moonshot-server.vala"
 928         web_provisioning_parser_parse (webp);
 929 #line 160 "moonshot-server.vala"
 930         _result_ = FALSE;
 931 #line 161 "moonshot-server.vala"
 932         installed_cards = 0;
 933 #line 934 "moonshot-server.c"
 934         {
 935                 IdCard** card_collection;
 936                 int card_collection_length1;
 937                 int card_it;
 938 #line 162 "moonshot-server.vala"
 939                 card_collection = web_provisioning_cards;
 940 #line 941 "moonshot-server.c"
 941                 card_collection_length1 = web_provisioning_cards_length1;
 942                 for (card_it = 0; card_it < web_provisioning_cards_length1; card_it = card_it + 1) {
 943                         IdCard* card;
 944                         card = _g_object_ref0 (card_collection[card_it]);
 945                         {
 946                                 gint rules_patterns_length1;
 947                                 gint _rules_patterns_size_;
 948                                 char** _tmp1_;
 949                                 char** _tmp0_ = NULL;
 950                                 char** rules_patterns;
 951                                 gint rules_always_confirm_length1;
 952                                 gint _rules_always_confirm_size_;
 953                                 char** _tmp3_;
 954                                 char** _tmp2_ = NULL;
 955                                 char** rules_always_confirm;
 956                                 gint _tmp4_;
 957                                 gint _tmp13_;
 958                                 rules_patterns = (_tmp1_ = (_tmp0_ = g_new0 (char*, 0 + 1), _tmp0_), rules_patterns_length1 = 0, _rules_patterns_size_ = rules_patterns_length1, _tmp1_);
 959                                 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_);
 960 #line 167 "moonshot-server.vala"
 961                                 if (_tmp4_ > 0) {
 962 #line 963 "moonshot-server.c"
 963                                         gint i;
 964                                         gint _tmp5_;
 965                                         char** _tmp6_;
 966                                         gint _tmp7_;
 967                                         char** _tmp8_;
 968 #line 169 "moonshot-server.vala"
 969                                         i = 0;
 970 #line 170 "moonshot-server.vala"
 971                                         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_);
 972 #line 171 "moonshot-server.vala"
 973                                         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_);
 974 #line 975 "moonshot-server.c"
 975                                         {
 976                                                 gint _tmp9_;
 977                                                 Rule* r_collection;
 978                                                 int r_collection_length1;
 979                                                 int r_it;
 980 #line 172 "moonshot-server.vala"
 981                                                 r_collection = id_card_get_rules (card, &_tmp9_);
 982 #line 983 "moonshot-server.c"
 983                                                 r_collection_length1 = _tmp9_;
 984                                                 for (r_it = 0; r_it < _tmp9_; r_it = r_it + 1) {
 985                                                         Rule _tmp12_ = {0};
 986                                                         Rule r;
 987                                                         r = (rule_copy (&r_collection[r_it], &_tmp12_), _tmp12_);
 988                                                         {
 989                                                                 char* _tmp10_;
 990                                                                 char* _tmp11_;
 991 #line 174 "moonshot-server.vala"
 992                                                                 rules_patterns[i] = (_tmp10_ = g_strdup (r.pattern), _g_free0 (rules_patterns[i]), _tmp10_);
 993 #line 175 "moonshot-server.vala"
 994                                                                 rules_always_confirm[i] = (_tmp11_ = g_strdup (r.always_confirm), _g_free0 (rules_always_confirm[i]), _tmp11_);
 995 #line 176 "moonshot-server.vala"
 996                                                                 i++;
 997 #line 998 "moonshot-server.c"
 998                                                                 rule_destroy (&r);
 999                                                         }
1000                                                 }
1001                                         }
1002                                 }
1003 #line 180 "moonshot-server.vala"
1004                                 _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)));
1005 #line 191 "moonshot-server.vala"
1006                                 if (_result_) {
1007 #line 192 "moonshot-server.vala"
1008                                         installed_cards++;
1009 #line 1010 "moonshot-server.c"
1010                                 }
1011                                 rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
1012                                 rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
1013                                 _g_object_unref0 (card);
1014                         }
1015                 }
1016         }
1017         result = installed_cards;
1018         _web_provisioning_parser_unref0 (webp);
1019 #line 195 "moonshot-server.vala"
1020         return result;
1021 #line 1022 "moonshot-server.c"
1022 }
1023
1024
1025 static void moonshot_server_class_init (MoonshotServerClass * klass) {
1026         moonshot_server_parent_class = g_type_class_peek_parent (klass);
1027         g_type_class_add_private (klass, sizeof (MoonshotServerPrivate));
1028         G_OBJECT_CLASS (klass)->finalize = moonshot_server_finalize;
1029 }
1030
1031
1032 static void moonshot_server_instance_init (MoonshotServer * self) {
1033         self->priv = MOONSHOT_SERVER_GET_PRIVATE (self);
1034 }
1035
1036
1037 static void moonshot_server_finalize (GObject* obj) {
1038         MoonshotServer * self;
1039         self = MOONSHOT_SERVER (obj);
1040         _g_object_unref0 (self->priv->main_window);
1041         G_OBJECT_CLASS (moonshot_server_parent_class)->finalize (obj);
1042 }
1043
1044
1045 GType moonshot_server_get_type (void) {
1046         static volatile gsize moonshot_server_type_id__volatile = 0;
1047         if (g_once_init_enter (&moonshot_server_type_id__volatile)) {
1048                 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 };
1049                 GType moonshot_server_type_id;
1050                 moonshot_server_type_id = g_type_register_static (G_TYPE_OBJECT, "MoonshotServer", &g_define_type_info, 0);
1051                 g_once_init_leave (&moonshot_server_type_id__volatile, moonshot_server_type_id);
1052         }
1053         return moonshot_server_type_id__volatile;
1054 }
1055
1056
1057 static void _dbus_moonshot_server_get_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1058         char* nai = NULL;
1059         GVariant* _tmp0_;
1060         char* password = NULL;
1061         GVariant* _tmp1_;
1062         char* service = NULL;
1063         GVariant* _tmp2_;
1064         GVariantIter _arguments_iter;
1065         g_variant_iter_init (&_arguments_iter, parameters);
1066         _tmp0_ = g_variant_iter_next_value (&_arguments_iter);
1067         nai = g_variant_dup_string (_tmp0_, NULL);
1068         g_variant_unref (_tmp0_);
1069         _tmp1_ = g_variant_iter_next_value (&_arguments_iter);
1070         password = g_variant_dup_string (_tmp1_, NULL);
1071         g_variant_unref (_tmp1_);
1072         _tmp2_ = g_variant_iter_next_value (&_arguments_iter);
1073         service = g_variant_dup_string (_tmp2_, NULL);
1074         g_variant_unref (_tmp2_);
1075         moonshot_server_get_identity (self, nai, password, service, (GAsyncReadyCallback) _dbus_moonshot_server_get_identity_ready, g_object_ref (invocation));
1076         _g_free0 (nai);
1077         _g_free0 (password);
1078         _g_free0 (service);
1079 }
1080
1081
1082 static void _dbus_moonshot_server_get_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
1083         GDBusMethodInvocation * invocation;
1084         GError* error;
1085         char* nai_out = NULL;
1086         char* password_out = NULL;
1087         char* server_certificate_hash = NULL;
1088         char* ca_certificate = NULL;
1089         char* subject_name_constraint = NULL;
1090         char* subject_alt_name_constraint = NULL;
1091         gboolean result;
1092         GVariant* _reply;
1093         GVariantBuilder _reply_builder;
1094         invocation = _user_data_;
1095         error = NULL;
1096         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);
1097         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1098         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (nai_out));
1099         _g_free0 (nai_out);
1100         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (password_out));
1101         _g_free0 (password_out);
1102         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (server_certificate_hash));
1103         _g_free0 (server_certificate_hash);
1104         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (ca_certificate));
1105         _g_free0 (ca_certificate);
1106         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_name_constraint));
1107         _g_free0 (subject_name_constraint);
1108         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_alt_name_constraint));
1109         _g_free0 (subject_alt_name_constraint);
1110         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
1111         _reply = g_variant_builder_end (&_reply_builder);
1112         g_dbus_method_invocation_return_value (invocation, _reply);
1113         g_object_unref (invocation);
1114         g_variant_unref (_reply);
1115 }
1116
1117
1118 static void _dbus_moonshot_server_get_default_identity (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1119         GVariantIter _arguments_iter;
1120         g_variant_iter_init (&_arguments_iter, parameters);
1121         moonshot_server_get_default_identity (self, (GAsyncReadyCallback) _dbus_moonshot_server_get_default_identity_ready, g_object_ref (invocation));
1122 }
1123
1124
1125 static void _dbus_moonshot_server_get_default_identity_ready (GObject * source_object, GAsyncResult * _res_, gpointer * _user_data_) {
1126         GDBusMethodInvocation * invocation;
1127         GError* error;
1128         char* nai_out = NULL;
1129         char* password_out = NULL;
1130         char* server_certificate_hash = NULL;
1131         char* ca_certificate = NULL;
1132         char* subject_name_constraint = NULL;
1133         char* subject_alt_name_constraint = NULL;
1134         gboolean result;
1135         GVariant* _reply;
1136         GVariantBuilder _reply_builder;
1137         invocation = _user_data_;
1138         error = NULL;
1139         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);
1140         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1141         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (nai_out));
1142         _g_free0 (nai_out);
1143         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (password_out));
1144         _g_free0 (password_out);
1145         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (server_certificate_hash));
1146         _g_free0 (server_certificate_hash);
1147         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (ca_certificate));
1148         _g_free0 (ca_certificate);
1149         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_name_constraint));
1150         _g_free0 (subject_name_constraint);
1151         g_variant_builder_add_value (&_reply_builder, g_variant_new_string (subject_alt_name_constraint));
1152         _g_free0 (subject_alt_name_constraint);
1153         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
1154         _reply = g_variant_builder_end (&_reply_builder);
1155         g_dbus_method_invocation_return_value (invocation, _reply);
1156         g_object_unref (invocation);
1157         g_variant_unref (_reply);
1158 }
1159
1160
1161 static void _dbus_moonshot_server_install_id_card (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1162         GError* error;
1163         char* display_name = NULL;
1164         GVariant* _tmp3_;
1165         char* user_name = NULL;
1166         GVariant* _tmp4_;
1167         char* password = NULL;
1168         GVariant* _tmp5_;
1169         char* realm = NULL;
1170         GVariant* _tmp6_;
1171         char** rules_patterns = NULL;
1172         int rules_patterns_length1;
1173         GVariant* _tmp7_;
1174         char** _tmp8_;
1175         int _tmp8__length;
1176         int _tmp8__size;
1177         int _tmp8__length1;
1178         GVariantIter _tmp9_;
1179         GVariant* _tmp10_;
1180         char** rules_always_confirm = NULL;
1181         int rules_always_confirm_length1;
1182         GVariant* _tmp11_;
1183         char** _tmp12_;
1184         int _tmp12__length;
1185         int _tmp12__size;
1186         int _tmp12__length1;
1187         GVariantIter _tmp13_;
1188         GVariant* _tmp14_;
1189         char** services = NULL;
1190         int services_length1;
1191         GVariant* _tmp15_;
1192         char** _tmp16_;
1193         int _tmp16__length;
1194         int _tmp16__size;
1195         int _tmp16__length1;
1196         GVariantIter _tmp17_;
1197         GVariant* _tmp18_;
1198         char* ca_cert = NULL;
1199         GVariant* _tmp19_;
1200         char* subject = NULL;
1201         GVariant* _tmp20_;
1202         char* subject_alt = NULL;
1203         GVariant* _tmp21_;
1204         char* server_cert = NULL;
1205         GVariant* _tmp22_;
1206         gboolean result;
1207         GVariantIter _arguments_iter;
1208         GVariant* _reply;
1209         GVariantBuilder _reply_builder;
1210         error = NULL;
1211         g_variant_iter_init (&_arguments_iter, parameters);
1212         _tmp3_ = g_variant_iter_next_value (&_arguments_iter);
1213         display_name = g_variant_dup_string (_tmp3_, NULL);
1214         g_variant_unref (_tmp3_);
1215         _tmp4_ = g_variant_iter_next_value (&_arguments_iter);
1216         user_name = g_variant_dup_string (_tmp4_, NULL);
1217         g_variant_unref (_tmp4_);
1218         _tmp5_ = g_variant_iter_next_value (&_arguments_iter);
1219         password = g_variant_dup_string (_tmp5_, NULL);
1220         g_variant_unref (_tmp5_);
1221         _tmp6_ = g_variant_iter_next_value (&_arguments_iter);
1222         realm = g_variant_dup_string (_tmp6_, NULL);
1223         g_variant_unref (_tmp6_);
1224         rules_patterns_length1 = 0;
1225         _tmp7_ = g_variant_iter_next_value (&_arguments_iter);
1226         _tmp8_ = g_new (char*, 5);
1227         _tmp8__length = 0;
1228         _tmp8__size = 4;
1229         _tmp8__length1 = 0;
1230         g_variant_iter_init (&_tmp9_, _tmp7_);
1231         for (; _tmp10_ = g_variant_iter_next_value (&_tmp9_); _tmp8__length1++) {
1232                 if (_tmp8__size == _tmp8__length) {
1233                         _tmp8__size = 2 * _tmp8__size;
1234                         _tmp8_ = g_renew (char*, _tmp8_, _tmp8__size + 1);
1235                 }
1236                 _tmp8_[_tmp8__length++] = g_variant_dup_string (_tmp10_, NULL);
1237                 g_variant_unref (_tmp10_);
1238         }
1239         rules_patterns_length1 = _tmp8__length1;
1240         _tmp8_[_tmp8__length] = NULL;
1241         rules_patterns = _tmp8_;
1242         g_variant_unref (_tmp7_);
1243         rules_always_confirm_length1 = 0;
1244         _tmp11_ = g_variant_iter_next_value (&_arguments_iter);
1245         _tmp12_ = g_new (char*, 5);
1246         _tmp12__length = 0;
1247         _tmp12__size = 4;
1248         _tmp12__length1 = 0;
1249         g_variant_iter_init (&_tmp13_, _tmp11_);
1250         for (; _tmp14_ = g_variant_iter_next_value (&_tmp13_); _tmp12__length1++) {
1251                 if (_tmp12__size == _tmp12__length) {
1252                         _tmp12__size = 2 * _tmp12__size;
1253                         _tmp12_ = g_renew (char*, _tmp12_, _tmp12__size + 1);
1254                 }
1255                 _tmp12_[_tmp12__length++] = g_variant_dup_string (_tmp14_, NULL);
1256                 g_variant_unref (_tmp14_);
1257         }
1258         rules_always_confirm_length1 = _tmp12__length1;
1259         _tmp12_[_tmp12__length] = NULL;
1260         rules_always_confirm = _tmp12_;
1261         g_variant_unref (_tmp11_);
1262         services_length1 = 0;
1263         _tmp15_ = g_variant_iter_next_value (&_arguments_iter);
1264         _tmp16_ = g_new (char*, 5);
1265         _tmp16__length = 0;
1266         _tmp16__size = 4;
1267         _tmp16__length1 = 0;
1268         g_variant_iter_init (&_tmp17_, _tmp15_);
1269         for (; _tmp18_ = g_variant_iter_next_value (&_tmp17_); _tmp16__length1++) {
1270                 if (_tmp16__size == _tmp16__length) {
1271                         _tmp16__size = 2 * _tmp16__size;
1272                         _tmp16_ = g_renew (char*, _tmp16_, _tmp16__size + 1);
1273                 }
1274                 _tmp16_[_tmp16__length++] = g_variant_dup_string (_tmp18_, NULL);
1275                 g_variant_unref (_tmp18_);
1276         }
1277         services_length1 = _tmp16__length1;
1278         _tmp16_[_tmp16__length] = NULL;
1279         services = _tmp16_;
1280         g_variant_unref (_tmp15_);
1281         _tmp19_ = g_variant_iter_next_value (&_arguments_iter);
1282         ca_cert = g_variant_dup_string (_tmp19_, NULL);
1283         g_variant_unref (_tmp19_);
1284         _tmp20_ = g_variant_iter_next_value (&_arguments_iter);
1285         subject = g_variant_dup_string (_tmp20_, NULL);
1286         g_variant_unref (_tmp20_);
1287         _tmp21_ = g_variant_iter_next_value (&_arguments_iter);
1288         subject_alt = g_variant_dup_string (_tmp21_, NULL);
1289         g_variant_unref (_tmp21_);
1290         _tmp22_ = g_variant_iter_next_value (&_arguments_iter);
1291         server_cert = g_variant_dup_string (_tmp22_, NULL);
1292         g_variant_unref (_tmp22_);
1293         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);
1294         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1295         _g_free0 (display_name);
1296         _g_free0 (user_name);
1297         _g_free0 (password);
1298         _g_free0 (realm);
1299         rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
1300         rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
1301         services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
1302         _g_free0 (ca_cert);
1303         _g_free0 (subject);
1304         _g_free0 (subject_alt);
1305         _g_free0 (server_cert);
1306         g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
1307         _reply = g_variant_builder_end (&_reply_builder);
1308         g_dbus_method_invocation_return_value (invocation, _reply);
1309 }
1310
1311
1312 static void _dbus_moonshot_server_install_from_file (MoonshotServer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
1313         GError* error;
1314         char* file_name = NULL;
1315         GVariant* _tmp23_;
1316         gint result;
1317         GVariantIter _arguments_iter;
1318         GVariant* _reply;
1319         GVariantBuilder _reply_builder;
1320         error = NULL;
1321         g_variant_iter_init (&_arguments_iter, parameters);
1322         _tmp23_ = g_variant_iter_next_value (&_arguments_iter);
1323         file_name = g_variant_dup_string (_tmp23_, NULL);
1324         g_variant_unref (_tmp23_);
1325         result = moonshot_server_install_from_file (self, file_name);
1326         g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
1327         _g_free0 (file_name);
1328         g_variant_builder_add_value (&_reply_builder, g_variant_new_int32 (result));
1329         _reply = g_variant_builder_end (&_reply_builder);
1330         g_dbus_method_invocation_return_value (invocation, _reply);
1331 }
1332
1333
1334 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) {
1335         gpointer* data;
1336         gpointer object;
1337         data = user_data;
1338         object = data[0];
1339         if (strcmp (method_name, "GetIdentity") == 0) {
1340                 _dbus_moonshot_server_get_identity (object, parameters, invocation);
1341         } else if (strcmp (method_name, "GetDefaultIdentity") == 0) {
1342                 _dbus_moonshot_server_get_default_identity (object, parameters, invocation);
1343         } else if (strcmp (method_name, "InstallIdCard") == 0) {
1344                 _dbus_moonshot_server_install_id_card (object, parameters, invocation);
1345         } else if (strcmp (method_name, "InstallFromFile") == 0) {
1346                 _dbus_moonshot_server_install_from_file (object, parameters, invocation);
1347         }
1348 }
1349
1350
1351 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) {
1352         gpointer* data;
1353         gpointer object;
1354         data = user_data;
1355         object = data[0];
1356         return NULL;
1357 }
1358
1359
1360 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) {
1361         gpointer* data;
1362         gpointer object;
1363         data = user_data;
1364         object = data[0];
1365         return FALSE;
1366 }
1367
1368
1369 guint moonshot_server_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
1370         guint result;
1371         gpointer *data;
1372         data = g_new (gpointer, 3);
1373         data[0] = g_object_ref (object);
1374         data[1] = g_object_ref (connection);
1375         data[2] = g_strdup (path);
1376         result = g_dbus_connection_register_object (connection, path, &_moonshot_server_dbus_interface_info, &_moonshot_server_dbus_interface_vtable, data, _moonshot_server_unregister_object, error);
1377         if (!result) {
1378                 return 0;
1379         }
1380         return result;
1381 }
1382
1383
1384 static void _moonshot_server_unregister_object (gpointer user_data) {
1385         gpointer* data;
1386         data = user_data;
1387         g_object_unref (data[0]);
1388         g_object_unref (data[1]);
1389         g_free (data[2]);
1390         g_free (data);
1391 }
1392
1393
1394 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1395         if ((array != NULL) && (destroy_func != NULL)) {
1396                 int i;
1397                 for (i = 0; i < array_length; i = i + 1) {
1398                         if (((gpointer*) array)[i] != NULL) {
1399                                 destroy_func (((gpointer*) array)[i]);
1400                         }
1401                 }
1402         }
1403 }
1404
1405
1406 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1407         _vala_array_destroy (array, array_length, destroy_func);
1408         g_free (array);
1409 }
1410
1411
1412
1413