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