src/moonshot-provisioning-common.c

   1 /* moonshot-provisioning-common.c generated by valac 0.10.4, the Vala compiler
   2  * generated from moonshot-provisioning-common.vala, do not modify */
   3
   4
   5 #include <glib.h>
   6 #include <glib-object.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <gio/gio.h>
  10 #include <gobject/gvaluecollector.h>
  11
  12
  13 #define TYPE_ID_CARD (id_card_get_type ())
  14 #define ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD, IdCard))
  15 #define ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD, IdCardClass))
  16 #define IS_ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD))
  17 #define IS_ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD))
  18 #define ID_CARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD, IdCardClass))
  19
  20 typedef struct _IdCard IdCard;
  21 typedef struct _IdCardClass IdCardClass;
  22 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  23
  24 #define TYPE_RULE (rule_get_type ())
  25 typedef struct _Rule Rule;
  26 #define _g_free0(var) (var = (g_free (var), NULL))
  27
  28 #define TYPE_TRUST_ANCHOR (trust_anchor_get_type ())
  29 #define TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRUST_ANCHOR, TrustAnchor))
  30 #define TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  31 #define IS_TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRUST_ANCHOR))
  32 #define IS_TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRUST_ANCHOR))
  33 #define TRUST_ANCHOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  34
  35 typedef struct _TrustAnchor TrustAnchor;
  36 typedef struct _TrustAnchorClass TrustAnchorClass;
  37
  38 #define WEB_PROVISIONING_TYPE_PARSER (web_provisioning_parser_get_type ())
  39 #define WEB_PROVISIONING_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParser))
  40 #define WEB_PROVISIONING_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  41 #define WEB_PROVISIONING_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEB_PROVISIONING_TYPE_PARSER))
  42 #define WEB_PROVISIONING_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), WEB_PROVISIONING_TYPE_PARSER))
  43 #define WEB_PROVISIONING_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  44
  45 typedef struct _WebProvisioningParser WebProvisioningParser;
  46 typedef struct _WebProvisioningParserClass WebProvisioningParserClass;
  47 typedef struct _WebProvisioningParserPrivate WebProvisioningParserPrivate;
  48 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  49 #define _g_markup_parse_context_free0(var) ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL)))
  50 typedef struct _WebProvisioningParamSpecParser WebProvisioningParamSpecParser;
  51
  52 struct _Rule {
  53         char* pattern;
  54         char* always_confirm;
  55 };
  56
  57 struct _WebProvisioningParser {
  58         GTypeInstance parent_instance;
  59         volatile int ref_count;
  60         WebProvisioningParserPrivate * priv;
  61 };
  62
  63 struct _WebProvisioningParserClass {
  64         GTypeClass parent_class;
  65         void (*finalize) (WebProvisioningParser *self);
  66 };
  67
  68 struct _WebProvisioningParserPrivate {
  69         GMarkupParser parser;
  70         char* text;
  71         char* path;
  72 };
  73
  74 struct _WebProvisioningParamSpecParser {
  75         GParamSpec parent_instance;
  76 };
  77
  78
  79 extern IdCard* web_provisioning_card;
  80 IdCard* web_provisioning_card = NULL;
  81 extern IdCard** web_provisioning_cards;
  82 extern gint web_provisioning_cards_length1;
  83 IdCard** web_provisioning_cards = NULL;
  84 gint web_provisioning_cards_length1 = 0;
  85 static gint _web_provisioning_cards_size_ = 0;
  86 static gpointer web_provisioning_parser_parent_class = NULL;
  87
  88 GType id_card_get_type (void) G_GNUC_CONST;
  89 gboolean web_provisioning_check_stack (GSList* stack, char** reference, int reference_length1);
  90 gboolean web_provisioning_always_confirm_handler (GSList* stack);
  91 gboolean web_provisioning_pattern_handler (GSList* stack);
  92 gboolean web_provisioning_server_cert_handler (GSList* stack);
  93 gboolean web_provisioning_subject_alt_handler (GSList* stack);
  94 gboolean web_provisioning_subject_handler (GSList* stack);
  95 gboolean web_provisioning_ca_cert_handler (GSList* stack);
  96 gboolean web_provisioning_realm_handler (GSList* stack);
  97 gboolean web_provisioning_password_handler (GSList* stack);
  98 gboolean web_provisioning_user_handler (GSList* stack);
  99 gboolean web_provisioning_display_name_handler (GSList* stack);
 100 void web_provisioning_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, GError** error);
 101 static IdCard** _vala_array_dup4 (IdCard** self, int length);
 102 IdCard* id_card_new (void);
 103 IdCard* id_card_construct (GType object_type);
 104 GType rule_get_type (void) G_GNUC_CONST;
 105 Rule* rule_dup (const Rule* self);
 106 void rule_free (Rule* self);
 107 void rule_copy (const Rule* self, Rule* dest);
 108 void rule_destroy (Rule* self);
 109 Rule* id_card_get_rules (IdCard* self, int* result_length1);
 110 static Rule* _vala_array_dup5 (Rule* self, int length);
 111 void id_card_set_rules (IdCard* self, Rule* value, int value_length1);
 112 static void _vala_Rule_array_free (Rule* array, gint array_length);
 113 void web_provisioning_text_element_func (GMarkupParseContext* context, const char* text, gsize text_len, GError** error);
 114 void id_card_set_display_name (IdCard* self, const char* value);
 115 void id_card_set_username (IdCard* self, const char* value);
 116 void id_card_set_password (IdCard* self, const char* value);
 117 void id_card_set_issuer (IdCard* self, const char* value);
 118 char** id_card_get_services (IdCard* self, int* result_length1);
 119 static char** _vala_array_dup6 (char** self, int length);
 120 void id_card_set_services (IdCard* self, char** value, int value_length1);
 121 GType trust_anchor_get_type (void) G_GNUC_CONST;
 122 TrustAnchor* id_card_get_trust_anchor (IdCard* self);
 123 void trust_anchor_set_ca_cert (TrustAnchor* self, const char* value);
 124 void trust_anchor_set_subject (TrustAnchor* self, const char* value);
 125 void trust_anchor_set_subject_alt (TrustAnchor* self, const char* value);
 126 void trust_anchor_set_server_cert (TrustAnchor* self, const char* value);
 127 gpointer web_provisioning_parser_ref (gpointer instance);
 128 void web_provisioning_parser_unref (gpointer instance);
 129 GParamSpec* web_provisioning_param_spec_parser (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 130 void web_provisioning_value_set_parser (GValue* value, gpointer v_object);
 131 void web_provisioning_value_take_parser (GValue* value, gpointer v_object);
 132 gpointer web_provisioning_value_get_parser (const GValue* value);
 133 GType web_provisioning_parser_get_type (void) G_GNUC_CONST;
 134 #define WEB_PROVISIONING_PARSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserPrivate))
 135 enum  {
 136         WEB_PROVISIONING_PARSER_DUMMY_PROPERTY
 137 };
 138 WebProvisioningParser* web_provisioning_parser_new (const char* path);
 139 WebProvisioningParser* web_provisioning_parser_construct (GType object_type, const char* path);
 140 static void _web_provisioning_start_element_func_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self, GError** error);
 141 static void _web_provisioning_text_element_func_gmarkup_parser_text_func (GMarkupParseContext* context, const char* text, gsize text_len, gpointer self, GError** error);
 142 void web_provisioning_parser_parse (WebProvisioningParser* self);
 143 static void web_provisioning_parser_finalize (WebProvisioningParser* obj);
 144 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 145 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 146 static gint _vala_array_length (gpointer array);
 147 static int _vala_strcmp0 (const char * str1, const char * str2);
 148
 149
 150
 151 #line 6 "moonshot-provisioning-common.vala"
 152 gboolean web_provisioning_check_stack (GSList* stack, char** reference, int reference_length1) {
 153 #line 154 "moonshot-provisioning-common.c"
 154         gboolean result = FALSE;
 155 #line 9 "moonshot-provisioning-common.vala"
 156         if (g_slist_length (stack) < reference_length1) {
 157 #line 158 "moonshot-provisioning-common.c"
 158                 result = FALSE;
 159 #line 10 "moonshot-provisioning-common.vala"
 160                 return result;
 161 #line 162 "moonshot-provisioning-common.c"
 162         }
 163         {
 164                 gint i;
 165 #line 12 "moonshot-provisioning-common.vala"
 166                 i = 0;
 167 #line 168 "moonshot-provisioning-common.c"
 168                 {
 169                         gboolean _tmp0_;
 170 #line 12 "moonshot-provisioning-common.vala"
 171                         _tmp0_ = TRUE;
 172 #line 12 "moonshot-provisioning-common.vala"
 173                         while (TRUE) {
 174 #line 12 "moonshot-provisioning-common.vala"
 175                                 if (!_tmp0_) {
 176 #line 12 "moonshot-provisioning-common.vala"
 177                                         i++;
 178 #line 179 "moonshot-provisioning-common.c"
 179                                 }
 180 #line 12 "moonshot-provisioning-common.vala"
 181                                 _tmp0_ = FALSE;
 182 #line 12 "moonshot-provisioning-common.vala"
 183                                 if (!(i < reference_length1)) {
 184 #line 12 "moonshot-provisioning-common.vala"
 185                                         break;
 186 #line 187 "moonshot-provisioning-common.c"
 187                                 }
 188 #line 14 "moonshot-provisioning-common.vala"
 189                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) i), reference[i]) != 0) {
 190 #line 191 "moonshot-provisioning-common.c"
 191                                         result = FALSE;
 192 #line 15 "moonshot-provisioning-common.vala"
 193                                         return result;
 194 #line 195 "moonshot-provisioning-common.c"
 195                                 }
 196                         }
 197                 }
 198         }
 199         result = TRUE;
 200 #line 18 "moonshot-provisioning-common.vala"
 201         return result;
 202 #line 203 "moonshot-provisioning-common.c"
 203 }
 204
 205
 206 #line 21 "moonshot-provisioning-common.vala"
 207 gboolean web_provisioning_always_confirm_handler (GSList* stack) {
 208 #line 209 "moonshot-provisioning-common.c"
 209         gboolean result = FALSE;
 210         gint always_confirm_path_length1;
 211         gint _always_confirm_path_size_;
 212         char** _tmp1_;
 213         char** _tmp0_ = NULL;
 214         char** always_confirm_path;
 215         always_confirm_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 5 + 1), _tmp0_[0] = g_strdup ("always-confirm"), _tmp0_[1] = g_strdup ("rule"), _tmp0_[2] = g_strdup ("selection-rules"), _tmp0_[3] = g_strdup ("identity"), _tmp0_[4] = g_strdup ("identities"), _tmp0_), always_confirm_path_length1 = 5, _always_confirm_path_size_ = always_confirm_path_length1, _tmp1_);
 216         result = web_provisioning_check_stack (stack, always_confirm_path, always_confirm_path_length1);
 217         always_confirm_path = (_vala_array_free (always_confirm_path, always_confirm_path_length1, (GDestroyNotify) g_free), NULL);
 218 #line 26 "moonshot-provisioning-common.vala"
 219         return result;
 220 #line 221 "moonshot-provisioning-common.c"
 221 }
 222
 223
 224 #line 29 "moonshot-provisioning-common.vala"
 225 gboolean web_provisioning_pattern_handler (GSList* stack) {
 226 #line 227 "moonshot-provisioning-common.c"
 227         gboolean result = FALSE;
 228         gint pattern_path_length1;
 229         gint _pattern_path_size_;
 230         char** _tmp1_;
 231         char** _tmp0_ = NULL;
 232         char** pattern_path;
 233         pattern_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 5 + 1), _tmp0_[0] = g_strdup ("pattern"), _tmp0_[1] = g_strdup ("rule"), _tmp0_[2] = g_strdup ("selection-rules"), _tmp0_[3] = g_strdup ("identity"), _tmp0_[4] = g_strdup ("identities"), _tmp0_), pattern_path_length1 = 5, _pattern_path_size_ = pattern_path_length1, _tmp1_);
 234         result = web_provisioning_check_stack (stack, pattern_path, pattern_path_length1);
 235         pattern_path = (_vala_array_free (pattern_path, pattern_path_length1, (GDestroyNotify) g_free), NULL);
 236 #line 34 "moonshot-provisioning-common.vala"
 237         return result;
 238 #line 239 "moonshot-provisioning-common.c"
 239 }
 240
 241
 242 #line 37 "moonshot-provisioning-common.vala"
 243 gboolean web_provisioning_server_cert_handler (GSList* stack) {
 244 #line 245 "moonshot-provisioning-common.c"
 245         gboolean result = FALSE;
 246         gint server_cert_path_length1;
 247         gint _server_cert_path_size_;
 248         char** _tmp1_;
 249         char** _tmp0_ = NULL;
 250         char** server_cert_path;
 251         server_cert_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("server-cert"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), server_cert_path_length1 = 4, _server_cert_path_size_ = server_cert_path_length1, _tmp1_);
 252         result = web_provisioning_check_stack (stack, server_cert_path, server_cert_path_length1);
 253         server_cert_path = (_vala_array_free (server_cert_path, server_cert_path_length1, (GDestroyNotify) g_free), NULL);
 254 #line 42 "moonshot-provisioning-common.vala"
 255         return result;
 256 #line 257 "moonshot-provisioning-common.c"
 257 }
 258
 259
 260 #line 45 "moonshot-provisioning-common.vala"
 261 gboolean web_provisioning_subject_alt_handler (GSList* stack) {
 262 #line 263 "moonshot-provisioning-common.c"
 263         gboolean result = FALSE;
 264         gint subject_alt_path_length1;
 265         gint _subject_alt_path_size_;
 266         char** _tmp1_;
 267         char** _tmp0_ = NULL;
 268         char** subject_alt_path;
 269         subject_alt_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("subject-alt"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), subject_alt_path_length1 = 4, _subject_alt_path_size_ = subject_alt_path_length1, _tmp1_);
 270         result = web_provisioning_check_stack (stack, subject_alt_path, subject_alt_path_length1);
 271         subject_alt_path = (_vala_array_free (subject_alt_path, subject_alt_path_length1, (GDestroyNotify) g_free), NULL);
 272 #line 50 "moonshot-provisioning-common.vala"
 273         return result;
 274 #line 275 "moonshot-provisioning-common.c"
 275 }
 276
 277
 278 #line 53 "moonshot-provisioning-common.vala"
 279 gboolean web_provisioning_subject_handler (GSList* stack) {
 280 #line 281 "moonshot-provisioning-common.c"
 281         gboolean result = FALSE;
 282         gint subject_path_length1;
 283         gint _subject_path_size_;
 284         char** _tmp1_;
 285         char** _tmp0_ = NULL;
 286         char** subject_path;
 287         subject_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("subject"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), subject_path_length1 = 4, _subject_path_size_ = subject_path_length1, _tmp1_);
 288         result = web_provisioning_check_stack (stack, subject_path, subject_path_length1);
 289         subject_path = (_vala_array_free (subject_path, subject_path_length1, (GDestroyNotify) g_free), NULL);
 290 #line 58 "moonshot-provisioning-common.vala"
 291         return result;
 292 #line 293 "moonshot-provisioning-common.c"
 293 }
 294
 295
 296 #line 61 "moonshot-provisioning-common.vala"
 297 gboolean web_provisioning_ca_cert_handler (GSList* stack) {
 298 #line 299 "moonshot-provisioning-common.c"
 299         gboolean result = FALSE;
 300         gint ca_path_length1;
 301         gint _ca_path_size_;
 302         char** _tmp1_;
 303         char** _tmp0_ = NULL;
 304         char** ca_path;
 305         ca_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("ca-cert"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), ca_path_length1 = 4, _ca_path_size_ = ca_path_length1, _tmp1_);
 306         result = web_provisioning_check_stack (stack, ca_path, ca_path_length1);
 307         ca_path = (_vala_array_free (ca_path, ca_path_length1, (GDestroyNotify) g_free), NULL);
 308 #line 66 "moonshot-provisioning-common.vala"
 309         return result;
 310 #line 311 "moonshot-provisioning-common.c"
 311 }
 312
 313
 314 #line 69 "moonshot-provisioning-common.vala"
 315 gboolean web_provisioning_realm_handler (GSList* stack) {
 316 #line 317 "moonshot-provisioning-common.c"
 317         gboolean result = FALSE;
 318         gint realm_path_length1;
 319         gint _realm_path_size_;
 320         char** _tmp1_;
 321         char** _tmp0_ = NULL;
 322         char** realm_path;
 323         realm_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("realm"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), realm_path_length1 = 3, _realm_path_size_ = realm_path_length1, _tmp1_);
 324         result = web_provisioning_check_stack (stack, realm_path, realm_path_length1);
 325         realm_path = (_vala_array_free (realm_path, realm_path_length1, (GDestroyNotify) g_free), NULL);
 326 #line 74 "moonshot-provisioning-common.vala"
 327         return result;
 328 #line 329 "moonshot-provisioning-common.c"
 329 }
 330
 331
 332 #line 77 "moonshot-provisioning-common.vala"
 333 gboolean web_provisioning_password_handler (GSList* stack) {
 334 #line 335 "moonshot-provisioning-common.c"
 335         gboolean result = FALSE;
 336         gint password_path_length1;
 337         gint _password_path_size_;
 338         char** _tmp1_;
 339         char** _tmp0_ = NULL;
 340         char** password_path;
 341         password_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("password"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), password_path_length1 = 3, _password_path_size_ = password_path_length1, _tmp1_);
 342         result = web_provisioning_check_stack (stack, password_path, password_path_length1);
 343         password_path = (_vala_array_free (password_path, password_path_length1, (GDestroyNotify) g_free), NULL);
 344 #line 82 "moonshot-provisioning-common.vala"
 345         return result;
 346 #line 347 "moonshot-provisioning-common.c"
 347 }
 348
 349
 350 #line 85 "moonshot-provisioning-common.vala"
 351 gboolean web_provisioning_user_handler (GSList* stack) {
 352 #line 353 "moonshot-provisioning-common.c"
 353         gboolean result = FALSE;
 354         gint user_path_length1;
 355         gint _user_path_size_;
 356         char** _tmp1_;
 357         char** _tmp0_ = NULL;
 358         char** user_path;
 359         user_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("user"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), user_path_length1 = 3, _user_path_size_ = user_path_length1, _tmp1_);
 360         result = web_provisioning_check_stack (stack, user_path, user_path_length1);
 361         user_path = (_vala_array_free (user_path, user_path_length1, (GDestroyNotify) g_free), NULL);
 362 #line 90 "moonshot-provisioning-common.vala"
 363         return result;
 364 #line 365 "moonshot-provisioning-common.c"
 365 }
 366
 367
 368 #line 93 "moonshot-provisioning-common.vala"
 369 gboolean web_provisioning_display_name_handler (GSList* stack) {
 370 #line 371 "moonshot-provisioning-common.c"
 371         gboolean result = FALSE;
 372         gint display_name_path_length1;
 373         gint _display_name_path_size_;
 374         char** _tmp1_;
 375         char** _tmp0_ = NULL;
 376         char** display_name_path;
 377         display_name_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("display-name"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), display_name_path_length1 = 3, _display_name_path_size_ = display_name_path_length1, _tmp1_);
 378         result = web_provisioning_check_stack (stack, display_name_path, display_name_path_length1);
 379         display_name_path = (_vala_array_free (display_name_path, display_name_path_length1, (GDestroyNotify) g_free), NULL);
 380 #line 98 "moonshot-provisioning-common.vala"
 381         return result;
 382 #line 383 "moonshot-provisioning-common.c"
 383 }
 384
 385
 386 static gpointer _g_object_ref0 (gpointer self) {
 387         return self ? g_object_ref (self) : NULL;
 388 }
 389
 390
 391 static IdCard** _vala_array_dup4 (IdCard** self, int length) {
 392         IdCard** result;
 393         int i;
 394         result = g_new0 (IdCard*, length + 1);
 395         for (i = 0; i < length; i++) {
 396                 result[i] = _g_object_ref0 (self[i]);
 397         }
 398         return result;
 399 }
 400
 401
 402 static Rule* _vala_array_dup5 (Rule* self, int length) {
 403         Rule* result;
 404         int i;
 405         Rule _tmp0_ = {0};
 406         result = g_new0 (Rule, length);
 407         for (i = 0; i < length; i++) {
 408                 result[i] = (rule_copy (&self[i], &_tmp0_), _tmp0_);
 409         }
 410         return result;
 411 }
 412
 413
 414 static void _vala_Rule_array_free (Rule* array, gint array_length) {
 415         if (array != NULL) {
 416                 int i;
 417                 for (i = 0; i < array_length; i = i + 1) {
 418                         rule_destroy (&array[i]);
 419                 }
 420         }
 421         g_free (array);
 422 }
 423
 424
 425 #line 101 "moonshot-provisioning-common.vala"
 426 void web_provisioning_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, GError** error) {
 427 #line 101 "moonshot-provisioning-common.vala"
 428         g_return_if_fail (context != NULL);
 429 #line 101 "moonshot-provisioning-common.vala"
 430         g_return_if_fail (element_name != NULL);
 431 #line 107 "moonshot-provisioning-common.vala"
 432         if (_vala_strcmp0 (element_name, "identity") == 0) {
 433 #line 434 "moonshot-provisioning-common.c"
 434                 gint tmp_cards_length1;
 435                 gint _tmp_cards_size_;
 436                 IdCard** _tmp1_;
 437                 IdCard** _tmp0_;
 438                 IdCard** tmp_cards;
 439                 IdCard** _tmp2_;
 440                 IdCard* _tmp5_;
 441                 IdCard* _tmp6_;
 442                 tmp_cards = (_tmp1_ = (_tmp0_ = web_provisioning_cards, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup4 (_tmp0_, web_provisioning_cards_length1)), tmp_cards_length1 = web_provisioning_cards_length1, _tmp_cards_size_ = tmp_cards_length1, _tmp1_);
 443 #line 111 "moonshot-provisioning-common.vala"
 444                 web_provisioning_cards = (_tmp2_ = g_new0 (IdCard*, (tmp_cards_length1 + 1) + 1), web_provisioning_cards = (_vala_array_free (web_provisioning_cards, web_provisioning_cards_length1, (GDestroyNotify) g_object_unref), NULL), web_provisioning_cards_length1 = tmp_cards_length1 + 1, _web_provisioning_cards_size_ = web_provisioning_cards_length1, _tmp2_);
 445 #line 446 "moonshot-provisioning-common.c"
 446                 {
 447                         gint i;
 448 #line 112 "moonshot-provisioning-common.vala"
 449                         i = 0;
 450 #line 451 "moonshot-provisioning-common.c"
 451                         {
 452                                 gboolean _tmp3_;
 453 #line 112 "moonshot-provisioning-common.vala"
 454                                 _tmp3_ = TRUE;
 455 #line 112 "moonshot-provisioning-common.vala"
 456                                 while (TRUE) {
 457 #line 458 "moonshot-provisioning-common.c"
 458                                         IdCard* _tmp4_;
 459 #line 112 "moonshot-provisioning-common.vala"
 460                                         if (!_tmp3_) {
 461 #line 112 "moonshot-provisioning-common.vala"
 462                                                 i++;
 463 #line 464 "moonshot-provisioning-common.c"
 464                                         }
 465 #line 112 "moonshot-provisioning-common.vala"
 466                                         _tmp3_ = FALSE;
 467 #line 112 "moonshot-provisioning-common.vala"
 468                                         if (!(i < tmp_cards_length1)) {
 469 #line 112 "moonshot-provisioning-common.vala"
 470                                                 break;
 471 #line 472 "moonshot-provisioning-common.c"
 472                                         }
 473 #line 114 "moonshot-provisioning-common.vala"
 474                                         web_provisioning_cards[i] = (_tmp4_ = _g_object_ref0 (tmp_cards[i]), _g_object_unref0 (web_provisioning_cards[i]), _tmp4_);
 475 #line 476 "moonshot-provisioning-common.c"
 476                                 }
 477                         }
 478                 }
 479 #line 116 "moonshot-provisioning-common.vala"
 480                 web_provisioning_card = (_tmp5_ = id_card_new (), _g_object_unref0 (web_provisioning_card), _tmp5_);
 481 #line 117 "moonshot-provisioning-common.vala"
 482                 web_provisioning_cards[tmp_cards_length1] = (_tmp6_ = _g_object_ref0 (web_provisioning_card), _g_object_unref0 (web_provisioning_cards[tmp_cards_length1]), _tmp6_);
 483 #line 484 "moonshot-provisioning-common.c"
 484                 tmp_cards = (_vala_array_free (tmp_cards, tmp_cards_length1, (GDestroyNotify) g_object_unref), NULL);
 485         } else {
 486 #line 119 "moonshot-provisioning-common.vala"
 487                 if (_vala_strcmp0 (element_name, "rule") == 0) {
 488 #line 489 "moonshot-provisioning-common.c"
 489                         gint tmp_rules_length1;
 490                         gint _tmp_rules_size_;
 491                         Rule* _tmp9_;
 492                         gint _tmp7_;
 493                         Rule* _tmp8_;
 494                         Rule* tmp_rules;
 495                         Rule* _tmp10_;
 496                         gint _tmp10__length1;
 497                         Rule* _tmp11_;
 498                         gint _tmp18_;
 499                         Rule _tmp19_ = {0};
 500                         gint _tmp20_;
 501                         Rule *_tmp21_;
 502                         Rule _tmp22_;
 503                         tmp_rules = (_tmp9_ = (_tmp8_ = id_card_get_rules (web_provisioning_card, &_tmp7_), (_tmp8_ == NULL) ? ((gpointer) _tmp8_) : _vala_array_dup5 (_tmp8_, _tmp7_)), tmp_rules_length1 = _tmp7_, _tmp_rules_size_ = tmp_rules_length1, _tmp9_);
 504 #line 122 "moonshot-provisioning-common.vala"
 505                         _tmp11_ = (_tmp10_ = g_new0 (Rule, tmp_rules_length1 + 1), _tmp10__length1 = tmp_rules_length1 + 1, _tmp10_);
 506 #line 122 "moonshot-provisioning-common.vala"
 507                         id_card_set_rules (web_provisioning_card, _tmp11_, tmp_rules_length1 + 1);
 508 #line 509 "moonshot-provisioning-common.c"
 509                         _tmp10_ = (_vala_Rule_array_free (_tmp10_, _tmp10__length1), NULL);
 510                         {
 511                                 gint i;
 512 #line 123 "moonshot-provisioning-common.vala"
 513                                 i = 0;
 514 #line 515 "moonshot-provisioning-common.c"
 515                                 {
 516                                         gboolean _tmp12_;
 517 #line 123 "moonshot-provisioning-common.vala"
 518                                         _tmp12_ = TRUE;
 519 #line 123 "moonshot-provisioning-common.vala"
 520                                         while (TRUE) {
 521 #line 522 "moonshot-provisioning-common.c"
 522                                                 gint _tmp13_;
 523                                                 Rule _tmp14_ = {0};
 524                                                 gint _tmp15_;
 525                                                 Rule *_tmp16_;
 526                                                 Rule _tmp17_;
 527 #line 123 "moonshot-provisioning-common.vala"
 528                                                 if (!_tmp12_) {
 529 #line 123 "moonshot-provisioning-common.vala"
 530                                                         i++;
 531 #line 532 "moonshot-provisioning-common.c"
 532                                                 }
 533 #line 123 "moonshot-provisioning-common.vala"
 534                                                 _tmp12_ = FALSE;
 535 #line 123 "moonshot-provisioning-common.vala"
 536                                                 if (!(i < tmp_rules_length1)) {
 537 #line 123 "moonshot-provisioning-common.vala"
 538                                                         break;
 539 #line 540 "moonshot-provisioning-common.c"
 540                                                 }
 541 #line 125 "moonshot-provisioning-common.vala"
 542                                                 _tmp16_ = &id_card_get_rules (web_provisioning_card, &_tmp15_)[i];
 543 #line 125 "moonshot-provisioning-common.vala"
 544                                                 (*_tmp16_) = (_tmp17_ = (rule_copy (&tmp_rules[i], &_tmp14_), _tmp14_), rule_destroy (&(*_tmp16_)), _tmp17_);
 545 #line 546 "moonshot-provisioning-common.c"
 546                                         }
 547                                 }
 548                         }
 549 #line 128 "moonshot-provisioning-common.vala"
 550                         _tmp21_ = &id_card_get_rules (web_provisioning_card, &_tmp20_)[tmp_rules_length1];
 551 #line 128 "moonshot-provisioning-common.vala"
 552                         (*_tmp21_) = (_tmp22_ = (memset (&_tmp19_, 0, sizeof (Rule)), _tmp19_), rule_destroy (&(*_tmp21_)), _tmp22_);
 553 #line 554 "moonshot-provisioning-common.c"
 554                         tmp_rules = (_vala_Rule_array_free (tmp_rules, tmp_rules_length1), NULL);
 555                 }
 556         }
 557 }
 558
 559
 560 static char** _vala_array_dup6 (char** self, int length) {
 561         char** result;
 562         int i;
 563         result = g_new0 (char*, length + 1);
 564         for (i = 0; i < length; i++) {
 565                 result[i] = g_strdup (self[i]);
 566         }
 567         return result;
 568 }
 569
 570
 571 #line 132 "moonshot-provisioning-common.vala"
 572 void web_provisioning_text_element_func (GMarkupParseContext* context, const char* text, gsize text_len, GError** error) {
 573 #line 574 "moonshot-provisioning-common.c"
 574         GSList* stack;
 575         gboolean _tmp0_ = FALSE;
 576 #line 132 "moonshot-provisioning-common.vala"
 577         g_return_if_fail (context != NULL);
 578 #line 132 "moonshot-provisioning-common.vala"
 579         g_return_if_fail (text != NULL);
 580 #line 137 "moonshot-provisioning-common.vala"
 581         stack = g_markup_parse_context_get_element_stack (context);
 582 #line 139 "moonshot-provisioning-common.vala"
 583         if (text_len < 1) {
 584 #line 140 "moonshot-provisioning-common.vala"
 585                 return;
 586 #line 587 "moonshot-provisioning-common.c"
 587         }
 588 #line 142 "moonshot-provisioning-common.vala"
 589         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "display-name") == 0) {
 590 #line 142 "moonshot-provisioning-common.vala"
 591                 _tmp0_ = web_provisioning_display_name_handler (stack);
 592 #line 593 "moonshot-provisioning-common.c"
 593         } else {
 594 #line 142 "moonshot-provisioning-common.vala"
 595                 _tmp0_ = FALSE;
 596 #line 597 "moonshot-provisioning-common.c"
 597         }
 598 #line 142 "moonshot-provisioning-common.vala"
 599         if (_tmp0_) {
 600 #line 144 "moonshot-provisioning-common.vala"
 601                 id_card_set_display_name (web_provisioning_card, text);
 602 #line 603 "moonshot-provisioning-common.c"
 603         } else {
 604                 gboolean _tmp1_ = FALSE;
 605 #line 146 "moonshot-provisioning-common.vala"
 606                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "user") == 0) {
 607 #line 146 "moonshot-provisioning-common.vala"
 608                         _tmp1_ = web_provisioning_user_handler (stack);
 609 #line 610 "moonshot-provisioning-common.c"
 610                 } else {
 611 #line 146 "moonshot-provisioning-common.vala"
 612                         _tmp1_ = FALSE;
 613 #line 614 "moonshot-provisioning-common.c"
 614                 }
 615 #line 146 "moonshot-provisioning-common.vala"
 616                 if (_tmp1_) {
 617 #line 148 "moonshot-provisioning-common.vala"
 618                         id_card_set_username (web_provisioning_card, text);
 619 #line 620 "moonshot-provisioning-common.c"
 620                 } else {
 621                         gboolean _tmp2_ = FALSE;
 622 #line 150 "moonshot-provisioning-common.vala"
 623                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "password") == 0) {
 624 #line 150 "moonshot-provisioning-common.vala"
 625                                 _tmp2_ = web_provisioning_password_handler (stack);
 626 #line 627 "moonshot-provisioning-common.c"
 627                         } else {
 628 #line 150 "moonshot-provisioning-common.vala"
 629                                 _tmp2_ = FALSE;
 630 #line 631 "moonshot-provisioning-common.c"
 631                         }
 632 #line 150 "moonshot-provisioning-common.vala"
 633                         if (_tmp2_) {
 634 #line 152 "moonshot-provisioning-common.vala"
 635                                 id_card_set_password (web_provisioning_card, text);
 636 #line 637 "moonshot-provisioning-common.c"
 637                         } else {
 638                                 gboolean _tmp3_ = FALSE;
 639 #line 154 "moonshot-provisioning-common.vala"
 640                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "realm") == 0) {
 641 #line 154 "moonshot-provisioning-common.vala"
 642                                         _tmp3_ = web_provisioning_realm_handler (stack);
 643 #line 644 "moonshot-provisioning-common.c"
 644                                 } else {
 645 #line 154 "moonshot-provisioning-common.vala"
 646                                         _tmp3_ = FALSE;
 647 #line 648 "moonshot-provisioning-common.c"
 648                                 }
 649 #line 154 "moonshot-provisioning-common.vala"
 650                                 if (_tmp3_) {
 651 #line 156 "moonshot-provisioning-common.vala"
 652                                         id_card_set_issuer (web_provisioning_card, text);
 653 #line 654 "moonshot-provisioning-common.c"
 654                                 } else {
 655 #line 158 "moonshot-provisioning-common.vala"
 656                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "service") == 0) {
 657 #line 658 "moonshot-provisioning-common.c"
 658                                                 gint services_length1;
 659                                                 gint _services_size_;
 660                                                 char** _tmp6_;
 661                                                 gint _tmp4_;
 662                                                 char** _tmp5_;
 663                                                 char** services;
 664                                                 char** _tmp7_;
 665                                                 gint _tmp7__length1;
 666                                                 char** _tmp8_;
 667                                                 gint _tmp14_;
 668                                                 gint _tmp15_;
 669                                                 char* *_tmp16_;
 670                                                 char* _tmp17_;
 671                                                 services = (_tmp6_ = (_tmp5_ = id_card_get_services (web_provisioning_card, &_tmp4_), (_tmp5_ == NULL) ? ((gpointer) _tmp5_) : _vala_array_dup6 (_tmp5_, _tmp4_)), services_length1 = _tmp4_, _services_size_ = services_length1, _tmp6_);
 672 #line 161 "moonshot-provisioning-common.vala"
 673                                                 _tmp8_ = (_tmp7_ = g_new0 (char*, (services_length1 + 1) + 1), _tmp7__length1 = services_length1 + 1, _tmp7_);
 674 #line 161 "moonshot-provisioning-common.vala"
 675                                                 id_card_set_services (web_provisioning_card, _tmp8_, services_length1 + 1);
 676 #line 677 "moonshot-provisioning-common.c"
 677                                                 _tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
 678                                                 {
 679                                                         gint i;
 680 #line 162 "moonshot-provisioning-common.vala"
 681                                                         i = 0;
 682 #line 683 "moonshot-provisioning-common.c"
 683                                                         {
 684                                                                 gboolean _tmp9_;
 685 #line 162 "moonshot-provisioning-common.vala"
 686                                                                 _tmp9_ = TRUE;
 687 #line 162 "moonshot-provisioning-common.vala"
 688                                                                 while (TRUE) {
 689 #line 690 "moonshot-provisioning-common.c"
 690                                                                         gint _tmp10_;
 691                                                                         gint _tmp11_;
 692                                                                         char* *_tmp12_;
 693                                                                         char* _tmp13_;
 694 #line 162 "moonshot-provisioning-common.vala"
 695                                                                         if (!_tmp9_) {
 696 #line 162 "moonshot-provisioning-common.vala"
 697                                                                                 i++;
 698 #line 699 "moonshot-provisioning-common.c"
 699                                                                         }
 700 #line 162 "moonshot-provisioning-common.vala"
 701                                                                         _tmp9_ = FALSE;
 702 #line 162 "moonshot-provisioning-common.vala"
 703                                                                         if (!(i < services_length1)) {
 704 #line 162 "moonshot-provisioning-common.vala"
 705                                                                                 break;
 706 #line 707 "moonshot-provisioning-common.c"
 707                                                                         }
 708 #line 164 "moonshot-provisioning-common.vala"
 709                                                                         _tmp12_ = &id_card_get_services (web_provisioning_card, &_tmp11_)[i];
 710 #line 164 "moonshot-provisioning-common.vala"
 711                                                                         (*_tmp12_) = (_tmp13_ = g_strdup (services[i]), _g_free0 ((*_tmp12_)), _tmp13_);
 712 #line 713 "moonshot-provisioning-common.c"
 713                                                                 }
 714                                                         }
 715                                                 }
 716 #line 166 "moonshot-provisioning-common.vala"
 717                                                 _tmp16_ = &id_card_get_services (web_provisioning_card, &_tmp15_)[services_length1];
 718 #line 166 "moonshot-provisioning-common.vala"
 719                                                 (*_tmp16_) = (_tmp17_ = g_strdup (text), _g_free0 ((*_tmp16_)), _tmp17_);
 720 #line 721 "moonshot-provisioning-common.c"
 721                                                 services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
 722                                         } else {
 723                                                 gboolean _tmp18_ = FALSE;
 724 #line 169 "moonshot-provisioning-common.vala"
 725                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "pattern") == 0) {
 726 #line 169 "moonshot-provisioning-common.vala"
 727                                                         _tmp18_ = web_provisioning_pattern_handler (stack);
 728 #line 729 "moonshot-provisioning-common.c"
 729                                                 } else {
 730 #line 169 "moonshot-provisioning-common.vala"
 731                                                         _tmp18_ = FALSE;
 732 #line 733 "moonshot-provisioning-common.c"
 733                                                 }
 734 #line 169 "moonshot-provisioning-common.vala"
 735                                                 if (_tmp18_) {
 736 #line 737 "moonshot-provisioning-common.c"
 737                                                         gint _tmp19_;
 738                                                         gint _tmp20_;
 739                                                         char* *_tmp21_;
 740                                                         char* _tmp22_;
 741 #line 171 "moonshot-provisioning-common.vala"
 742                                                         _tmp21_ = &id_card_get_rules (web_provisioning_card, &_tmp19_)[_tmp20_ - 1].pattern;
 743 #line 171 "moonshot-provisioning-common.vala"
 744                                                         (*_tmp21_) = (_tmp22_ = g_strdup (text), _g_free0 ((*_tmp21_)), _tmp22_);
 745 #line 746 "moonshot-provisioning-common.c"
 746                                                 } else {
 747                                                         gboolean _tmp23_ = FALSE;
 748 #line 173 "moonshot-provisioning-common.vala"
 749                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "always-confirm") == 0) {
 750 #line 173 "moonshot-provisioning-common.vala"
 751                                                                 _tmp23_ = web_provisioning_always_confirm_handler (stack);
 752 #line 753 "moonshot-provisioning-common.c"
 753                                                         } else {
 754 #line 173 "moonshot-provisioning-common.vala"
 755                                                                 _tmp23_ = FALSE;
 756 #line 757 "moonshot-provisioning-common.c"
 757                                                         }
 758 #line 173 "moonshot-provisioning-common.vala"
 759                                                         if (_tmp23_) {
 760 #line 761 "moonshot-provisioning-common.c"
 761                                                                 gboolean _tmp24_ = FALSE;
 762 #line 175 "moonshot-provisioning-common.vala"
 763                                                                 if (_vala_strcmp0 (text, "true") == 0) {
 764 #line 175 "moonshot-provisioning-common.vala"
 765                                                                         _tmp24_ = TRUE;
 766 #line 767 "moonshot-provisioning-common.c"
 767                                                                 } else {
 768 #line 175 "moonshot-provisioning-common.vala"
 769                                                                         _tmp24_ = _vala_strcmp0 (text, "false") == 0;
 770 #line 771 "moonshot-provisioning-common.c"
 771                                                                 }
 772 #line 175 "moonshot-provisioning-common.vala"
 773                                                                 if (_tmp24_) {
 774 #line 775 "moonshot-provisioning-common.c"
 775                                                                         gint _tmp25_;
 776                                                                         gint _tmp26_;
 777                                                                         char* *_tmp27_;
 778                                                                         char* _tmp28_;
 779 #line 176 "moonshot-provisioning-common.vala"
 780                                                                         _tmp27_ = &id_card_get_rules (web_provisioning_card, &_tmp25_)[_tmp26_ - 1].always_confirm;
 781 #line 176 "moonshot-provisioning-common.vala"
 782                                                                         (*_tmp27_) = (_tmp28_ = g_strdup (text), _g_free0 ((*_tmp27_)), _tmp28_);
 783 #line 784 "moonshot-provisioning-common.c"
 784                                                                 }
 785                                                         } else {
 786                                                                 gboolean _tmp29_ = FALSE;
 787 #line 179 "moonshot-provisioning-common.vala"
 788                                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "ca-cert") == 0) {
 789 #line 179 "moonshot-provisioning-common.vala"
 790                                                                         _tmp29_ = web_provisioning_ca_cert_handler (stack);
 791 #line 792 "moonshot-provisioning-common.c"
 792                                                                 } else {
 793 #line 179 "moonshot-provisioning-common.vala"
 794                                                                         _tmp29_ = FALSE;
 795 #line 796 "moonshot-provisioning-common.c"
 796                                                                 }
 797 #line 179 "moonshot-provisioning-common.vala"
 798                                                                 if (_tmp29_) {
 799 #line 181 "moonshot-provisioning-common.vala"
 800                                                                         trust_anchor_set_ca_cert (id_card_get_trust_anchor (web_provisioning_card), text);
 801 #line 802 "moonshot-provisioning-common.c"
 802                                                                 } else {
 803                                                                         gboolean _tmp30_ = FALSE;
 804 #line 183 "moonshot-provisioning-common.vala"
 805                                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "subject") == 0) {
 806 #line 183 "moonshot-provisioning-common.vala"
 807                                                                                 _tmp30_ = web_provisioning_subject_handler (stack);
 808 #line 809 "moonshot-provisioning-common.c"
 809                                                                         } else {
 810 #line 183 "moonshot-provisioning-common.vala"
 811                                                                                 _tmp30_ = FALSE;
 812 #line 813 "moonshot-provisioning-common.c"
 813                                                                         }
 814 #line 183 "moonshot-provisioning-common.vala"
 815                                                                         if (_tmp30_) {
 816 #line 185 "moonshot-provisioning-common.vala"
 817                                                                                 trust_anchor_set_subject (id_card_get_trust_anchor (web_provisioning_card), text);
 818 #line 819 "moonshot-provisioning-common.c"
 819                                                                         } else {
 820                                                                                 gboolean _tmp31_ = FALSE;
 821 #line 187 "moonshot-provisioning-common.vala"
 822                                                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "subject-alt") == 0) {
 823 #line 187 "moonshot-provisioning-common.vala"
 824                                                                                         _tmp31_ = web_provisioning_subject_alt_handler (stack);
 825 #line 826 "moonshot-provisioning-common.c"
 826                                                                                 } else {
 827 #line 187 "moonshot-provisioning-common.vala"
 828                                                                                         _tmp31_ = FALSE;
 829 #line 830 "moonshot-provisioning-common.c"
 830                                                                                 }
 831 #line 187 "moonshot-provisioning-common.vala"
 832                                                                                 if (_tmp31_) {
 833 #line 189 "moonshot-provisioning-common.vala"
 834                                                                                         trust_anchor_set_subject_alt (id_card_get_trust_anchor (web_provisioning_card), text);
 835 #line 836 "moonshot-provisioning-common.c"
 836                                                                                 } else {
 837                                                                                         gboolean _tmp32_ = FALSE;
 838 #line 191 "moonshot-provisioning-common.vala"
 839                                                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "server-cert") == 0) {
 840 #line 191 "moonshot-provisioning-common.vala"
 841                                                                                                 _tmp32_ = web_provisioning_server_cert_handler (stack);
 842 #line 843 "moonshot-provisioning-common.c"
 843                                                                                         } else {
 844 #line 191 "moonshot-provisioning-common.vala"
 845                                                                                                 _tmp32_ = FALSE;
 846 #line 847 "moonshot-provisioning-common.c"
 847                                                                                         }
 848 #line 191 "moonshot-provisioning-common.vala"
 849                                                                                         if (_tmp32_) {
 850 #line 193 "moonshot-provisioning-common.vala"
 851                                                                                                 trust_anchor_set_server_cert (id_card_get_trust_anchor (web_provisioning_card), text);
 852 #line 853 "moonshot-provisioning-common.c"
 853                                                                                         }
 854                                                                                 }
 855                                                                         }
 856                                                                 }
 857                                                         }
 858                                                 }
 859                                         }
 860                                 }
 861                         }
 862                 }
 863         }
 864 }
 865
 866
 867 #line 101 "moonshot-provisioning-common.vala"
 868 static void _web_provisioning_start_element_func_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self, GError** error) {
 869 #line 870 "moonshot-provisioning-common.c"
 870         web_provisioning_start_element_func (context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values), error);
 871 }
 872
 873
 874 #line 132 "moonshot-provisioning-common.vala"
 875 static void _web_provisioning_text_element_func_gmarkup_parser_text_func (GMarkupParseContext* context, const char* text, gsize text_len, gpointer self, GError** error) {
 876 #line 877 "moonshot-provisioning-common.c"
 877         web_provisioning_text_element_func (context, text, text_len, error);
 878 }
 879
 880
 881 #line 202 "moonshot-provisioning-common.vala"
 882 WebProvisioningParser* web_provisioning_parser_construct (GType object_type, const char* path) {
 883 #line 884 "moonshot-provisioning-common.c"
 884         WebProvisioningParser* self = (WebProvisioningParser*) g_type_create_instance (object_type);
 885         char* _tmp0_;
 886         char* _tmp1_;
 887         GFile* file;
 888         GMarkupParser _tmp8_ = {0};
 889         GError * _inner_error_ = NULL;
 890 #line 202 "moonshot-provisioning-common.vala"
 891         g_return_val_if_fail (path != NULL, NULL);
 892 #line 204 "moonshot-provisioning-common.vala"
 893         self->priv->text = (_tmp0_ = g_strdup (""), _g_free0 (self->priv->text), _tmp0_);
 894 #line 205 "moonshot-provisioning-common.vala"
 895         self->priv->path = (_tmp1_ = g_strdup (path), _g_free0 (self->priv->path), _tmp1_);
 896 #line 207 "moonshot-provisioning-common.vala"
 897         file = g_file_new_for_path (path);
 898 #line 899 "moonshot-provisioning-common.c"
 899         {
 900                 GFileInputStream* _tmp2_;
 901                 GFileInputStream* _tmp3_;
 902                 GDataInputStream* _tmp4_;
 903                 GDataInputStream* dis;
 904                 char* line;
 905 #line 211 "moonshot-provisioning-common.vala"
 906                 _tmp2_ = g_file_read (file, NULL, &_inner_error_);
 907 #line 908 "moonshot-provisioning-common.c"
 908                 if (_inner_error_ != NULL) {
 909                         goto __catch5_g_error;
 910                 }
 911 #line 211 "moonshot-provisioning-common.vala"
 912                 dis = (_tmp4_ = g_data_input_stream_new ((GInputStream*) (_tmp3_ = _tmp2_)), _g_object_unref0 (_tmp3_), _tmp4_);
 913 #line 914 "moonshot-provisioning-common.c"
 914                 line = NULL;
 915 #line 213 "moonshot-provisioning-common.vala"
 916                 while (TRUE) {
 917 #line 918 "moonshot-provisioning-common.c"
 918                         char* _tmp5_;
 919                         char* _tmp6_;
 920                         char* _tmp7_;
 921 #line 213 "moonshot-provisioning-common.vala"
 922                         _tmp5_ = g_data_input_stream_read_line (dis, NULL, NULL, &_inner_error_);
 923 #line 924 "moonshot-provisioning-common.c"
 924                         if (_inner_error_ != NULL) {
 925                                 _g_free0 (line);
 926                                 _g_object_unref0 (dis);
 927                                 goto __catch5_g_error;
 928                         }
 929 #line 213 "moonshot-provisioning-common.vala"
 930                         if (!((line = (_tmp6_ = _tmp5_, _g_free0 (line), _tmp6_)) != NULL)) {
 931 #line 213 "moonshot-provisioning-common.vala"
 932                                 break;
 933 #line 934 "moonshot-provisioning-common.c"
 934                         }
 935 #line 214 "moonshot-provisioning-common.vala"
 936                         self->priv->text = (_tmp7_ = g_strconcat (self->priv->text, line, NULL), _g_free0 (self->priv->text), _tmp7_);
 937 #line 938 "moonshot-provisioning-common.c"
 938                 }
 939                 _g_free0 (line);
 940                 _g_object_unref0 (dis);
 941         }
 942         goto __finally5;
 943         __catch5_g_error:
 944         {
 945                 GError * e;
 946                 e = _inner_error_;
 947                 _inner_error_ = NULL;
 948                 {
 949 #line 218 "moonshot-provisioning-common.vala"
 950                         g_error ("moonshot-provisioning-common.vala:218: Could not retreive file size");
 951 #line 952 "moonshot-provisioning-common.c"
 952                         _g_error_free0 (e);
 953                 }
 954         }
 955         __finally5:
 956         if (_inner_error_ != NULL) {
 957                 _g_object_unref0 (file);
 958                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 959                 g_clear_error (&_inner_error_);
 960                 return NULL;
 961         }
 962 #line 221 "moonshot-provisioning-common.vala"
 963         self->priv->parser = (_tmp8_.start_element = _web_provisioning_start_element_func_gmarkup_parser_start_element_func, _tmp8_.end_element = NULL, _tmp8_.text = _web_provisioning_text_element_func_gmarkup_parser_text_func, _tmp8_.passthrough = NULL, _tmp8_.error = NULL, _tmp8_);
 964 #line 965 "moonshot-provisioning-common.c"
 965         _g_object_unref0 (file);
 966         return self;
 967 }
 968
 969
 970 #line 202 "moonshot-provisioning-common.vala"
 971 WebProvisioningParser* web_provisioning_parser_new (const char* path) {
 972 #line 202 "moonshot-provisioning-common.vala"
 973         return web_provisioning_parser_construct (WEB_PROVISIONING_TYPE_PARSER, path);
 974 #line 975 "moonshot-provisioning-common.c"
 975 }
 976
 977
 978 static glong string_get_length (const char* self) {
 979         glong result;
 980         g_return_val_if_fail (self != NULL, 0L);
 981         result = g_utf8_strlen (self, (gssize) (-1));
 982 #line 1194 "glib-2.0.vapi"
 983         return result;
 984 #line 985 "moonshot-provisioning-common.c"
 985 }
 986
 987
 988 #line 224 "moonshot-provisioning-common.vala"
 989 void web_provisioning_parser_parse (WebProvisioningParser* self) {
 990 #line 991 "moonshot-provisioning-common.c"
 991         GMarkupParseContext* ctx;
 992         GError * _inner_error_ = NULL;
 993 #line 224 "moonshot-provisioning-common.vala"
 994         g_return_if_fail (self != NULL);
 995 #line 227 "moonshot-provisioning-common.vala"
 996         ctx = g_markup_parse_context_new (&self->priv->parser, 0, NULL, NULL);
 997 #line 998 "moonshot-provisioning-common.c"
 998         {
 999 #line 231 "moonshot-provisioning-common.vala"
1000                 g_markup_parse_context_parse (ctx, self->priv->text, (gssize) string_get_length (self->priv->text), &_inner_error_);
1001 #line 1002 "moonshot-provisioning-common.c"
1002                 if (_inner_error_ != NULL) {
1003                         goto __catch6_g_error;
1004                 }
1005         }
1006         goto __finally6;
1007         __catch6_g_error:
1008         {
1009                 GError * e;
1010                 e = _inner_error_;
1011                 _inner_error_ = NULL;
1012                 {
1013 #line 235 "moonshot-provisioning-common.vala"
1014                         g_error ("moonshot-provisioning-common.vala:235: Could not parse %s, invalid con" \
1015 "tent", self->priv->path);
1016 #line 1016 "moonshot-provisioning-common.c"
1017                         _g_error_free0 (e);
1018                 }
1019         }
1020         __finally6:
1021         if (_inner_error_ != NULL) {
1022                 _g_markup_parse_context_free0 (ctx);
1023                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
1024                 g_clear_error (&_inner_error_);
1025                 return;
1026         }
1027         _g_markup_parse_context_free0 (ctx);
1028 }
1029
1030
1031 static void web_provisioning_value_parser_init (GValue* value) {
1032         value->data[0].v_pointer = NULL;
1033 }
1034
1035
1036 static void web_provisioning_value_parser_free_value (GValue* value) {
1037         if (value->data[0].v_pointer) {
1038                 web_provisioning_parser_unref (value->data[0].v_pointer);
1039         }
1040 }
1041
1042
1043 static void web_provisioning_value_parser_copy_value (const GValue* src_value, GValue* dest_value) {
1044         if (src_value->data[0].v_pointer) {
1045                 dest_value->data[0].v_pointer = web_provisioning_parser_ref (src_value->data[0].v_pointer);
1046         } else {
1047                 dest_value->data[0].v_pointer = NULL;
1048         }
1049 }
1050
1051
1052 static gpointer web_provisioning_value_parser_peek_pointer (const GValue* value) {
1053         return value->data[0].v_pointer;
1054 }
1055
1056
1057 static gchar* web_provisioning_value_parser_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1058         if (collect_values[0].v_pointer) {
1059                 WebProvisioningParser* object;
1060                 object = collect_values[0].v_pointer;
1061                 if (object->parent_instance.g_class == NULL) {
1062                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1063                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1064                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1065                 }
1066                 value->data[0].v_pointer = web_provisioning_parser_ref (object);
1067         } else {
1068                 value->data[0].v_pointer = NULL;
1069         }
1070         return NULL;
1071 }
1072
1073
1074 static gchar* web_provisioning_value_parser_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1075         WebProvisioningParser** object_p;
1076         object_p = collect_values[0].v_pointer;
1077         if (!object_p) {
1078                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1079         }
1080         if (!value->data[0].v_pointer) {
1081                 *object_p = NULL;
1082         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1083                 *object_p = value->data[0].v_pointer;
1084         } else {
1085                 *object_p = web_provisioning_parser_ref (value->data[0].v_pointer);
1086         }
1087         return NULL;
1088 }
1089
1090
1091 GParamSpec* web_provisioning_param_spec_parser (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
1092         WebProvisioningParamSpecParser* spec;
1093         g_return_val_if_fail (g_type_is_a (object_type, WEB_PROVISIONING_TYPE_PARSER), NULL);
1094         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1095         G_PARAM_SPEC (spec)->value_type = object_type;
1096         return G_PARAM_SPEC (spec);
1097 }
1098
1099
1100 gpointer web_provisioning_value_get_parser (const GValue* value) {
1101         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER), NULL);
1102         return value->data[0].v_pointer;
1103 }
1104
1105
1106 void web_provisioning_value_set_parser (GValue* value, gpointer v_object) {
1107         WebProvisioningParser* old;
1108         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER));
1109         old = value->data[0].v_pointer;
1110         if (v_object) {
1111                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, WEB_PROVISIONING_TYPE_PARSER));
1112                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1113                 value->data[0].v_pointer = v_object;
1114                 web_provisioning_parser_ref (value->data[0].v_pointer);
1115         } else {
1116                 value->data[0].v_pointer = NULL;
1117         }
1118         if (old) {
1119                 web_provisioning_parser_unref (old);
1120         }
1121 }
1122
1123
1124 void web_provisioning_value_take_parser (GValue* value, gpointer v_object) {
1125         WebProvisioningParser* old;
1126         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER));
1127         old = value->data[0].v_pointer;
1128         if (v_object) {
1129                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, WEB_PROVISIONING_TYPE_PARSER));
1130                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1131                 value->data[0].v_pointer = v_object;
1132         } else {
1133                 value->data[0].v_pointer = NULL;
1134         }
1135         if (old) {
1136                 web_provisioning_parser_unref (old);
1137         }
1138 }
1139
1140
1141 static void web_provisioning_parser_class_init (WebProvisioningParserClass * klass) {
1142         web_provisioning_parser_parent_class = g_type_class_peek_parent (klass);
1143         WEB_PROVISIONING_PARSER_CLASS (klass)->finalize = web_provisioning_parser_finalize;
1144         g_type_class_add_private (klass, sizeof (WebProvisioningParserPrivate));
1145 }
1146
1147
1148 static void web_provisioning_parser_instance_init (WebProvisioningParser * self) {
1149         self->priv = WEB_PROVISIONING_PARSER_GET_PRIVATE (self);
1150         self->ref_count = 1;
1151 }
1152
1153
1154 static void web_provisioning_parser_finalize (WebProvisioningParser* obj) {
1155         WebProvisioningParser * self;
1156         self = WEB_PROVISIONING_PARSER (obj);
1157         _g_free0 (self->priv->text);
1158         _g_free0 (self->priv->path);
1159 }
1160
1161
1162 GType web_provisioning_parser_get_type (void) {
1163         static volatile gsize web_provisioning_parser_type_id__volatile = 0;
1164         if (g_once_init_enter (&web_provisioning_parser_type_id__volatile)) {
1165                 static const GTypeValueTable g_define_type_value_table = { web_provisioning_value_parser_init, web_provisioning_value_parser_free_value, web_provisioning_value_parser_copy_value, web_provisioning_value_parser_peek_pointer, "p", web_provisioning_value_parser_collect_value, "p", web_provisioning_value_parser_lcopy_value };
1166                 static const GTypeInfo g_define_type_info = { sizeof (WebProvisioningParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) web_provisioning_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (WebProvisioningParser), 0, (GInstanceInitFunc) web_provisioning_parser_instance_init, &g_define_type_value_table };
1167                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
1168                 GType web_provisioning_parser_type_id;
1169                 web_provisioning_parser_type_id = g_type_register_fundamental (g_type_fundamental_next (), "WebProvisioningParser", &g_define_type_info, &g_define_type_fundamental_info, 0);
1170                 g_once_init_leave (&web_provisioning_parser_type_id__volatile, web_provisioning_parser_type_id);
1171         }
1172         return web_provisioning_parser_type_id__volatile;
1173 }
1174
1175
1176 gpointer web_provisioning_parser_ref (gpointer instance) {
1177         WebProvisioningParser* self;
1178         self = instance;
1179         g_atomic_int_inc (&self->ref_count);
1180         return instance;
1181 }
1182
1183
1184 void web_provisioning_parser_unref (gpointer instance) {
1185         WebProvisioningParser* self;
1186         self = instance;
1187         if (g_atomic_int_dec_and_test (&self->ref_count)) {
1188                 WEB_PROVISIONING_PARSER_GET_CLASS (self)->finalize (self);
1189                 g_type_free_instance ((GTypeInstance *) self);
1190         }
1191 }
1192
1193
1194 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1195         if ((array != NULL) && (destroy_func != NULL)) {
1196                 int i;
1197                 for (i = 0; i < array_length; i = i + 1) {
1198                         if (((gpointer*) array)[i] != NULL) {
1199                                 destroy_func (((gpointer*) array)[i]);
1200                         }
1201                 }
1202         }
1203 }
1204
1205
1206 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1207         _vala_array_destroy (array, array_length, destroy_func);
1208         g_free (array);
1209 }
1210
1211
1212 static gint _vala_array_length (gpointer array) {
1213         int length;
1214         length = 0;
1215         if (array) {
1216                 while (((gpointer*) array)[length]) {
1217                         length++;
1218                 }
1219         }
1220         return length;
1221 }
1222
1223
1224 static int _vala_strcmp0 (const char * str1, const char * str2) {
1225         if (str1 == NULL) {
1226                 return -(str1 != str2);
1227         }
1228         if (str2 == NULL) {
1229                 return str1 != str2;
1230         }
1231         return strcmp (str1, str2);
1232 }
1233
1234
1235
1236