src/moonshot-provisioning-common.vala

   1 namespace WebProvisioning
   2 {
   3   IdCard card;
   4   IdCard[] cards;
   5
   6   bool
   7   check_stack (SList<string> stack, string[] reference)
   8   {
   9     if (stack.length () < reference.length)
  10       return false;
  11
  12     for (int i = 0; i<reference.length; i++)
  13     {
  14       if (stack.nth_data(i) != reference[i])
  15         return false;
  16     }
  17
  18     return true;
  19   }
  20
  21   bool
  22   always_confirm_handler (SList<string> stack)
  23   {
  24     string[] always_confirm_path = {"always-confirm", "rule", "selection-rules", "identity", "identities"};
  25
  26     return check_stack (stack, always_confirm_path);
  27   }
  28
  29   bool
  30   pattern_handler (SList<string> stack)
  31   {
  32     string[] pattern_path = {"pattern", "rule", "selection-rules", "identity", "identities"};
  33
  34     return check_stack (stack, pattern_path);
  35   }
  36
  37   bool
  38   server_cert_handler (SList<string> stack)
  39   {
  40     string[] server_cert_path = {"server-cert", "trust-anchor", "identity", "identities"};
  41
  42     return check_stack (stack, server_cert_path);
  43   }
  44
  45   bool
  46   subject_alt_handler (SList<string> stack)
  47   {
  48     string[] subject_alt_path = {"subject-alt", "trust-anchor", "identity", "identities"};
  49
  50     return check_stack (stack, subject_alt_path);
  51   }
  52
  53   bool
  54   subject_handler (SList<string> stack)
  55   {
  56     string[] subject_path = {"subject", "trust-anchor", "identity", "identities"};
  57
  58     return check_stack (stack, subject_path);
  59   }
  60
  61   bool
  62   ca_cert_handler (SList<string> stack)
  63   {
  64     string[] ca_path = {"ca-cert", "trust-anchor", "identity", "identities"};
  65
  66     return check_stack (stack, ca_path);
  67   }
  68
  69   bool
  70   realm_handler (SList<string> stack)
  71   {
  72     string[] realm_path = {"realm", "identity", "identities"};
  73
  74     return check_stack (stack, realm_path);
  75   }
  76
  77   bool
  78   password_handler (SList<string> stack)
  79   {
  80     string[] password_path = {"password", "identity", "identities"};
  81
  82     return check_stack (stack, password_path);
  83   }
  84
  85   bool
  86   user_handler (SList<string> stack)
  87   {
  88     string[] user_path = {"user", "identity", "identities"};
  89
  90     return check_stack (stack, user_path);
  91   }
  92
  93   bool
  94   display_name_handler (SList<string> stack)
  95   {
  96     string[] display_name_path = {"display-name", "identity", "identities"};
  97
  98     return check_stack (stack, display_name_path);
  99   }
 100
 101   public void
 102   start_element_func (MarkupParseContext context,
 103                       string element_name,
 104                       string[] attribute_names,
 105                       string[] attribute_values) throws MarkupError
 106   {
 107     if (element_name == "identity")
 108     {
 109       IdCard[] tmp_cards = cards;
 110
 111       cards = new IdCard[tmp_cards.length + 1];
 112       for (int i=0; i<tmp_cards.length; i++)
 113       {
 114         cards[i] = tmp_cards[i];
 115       }
 116       card = new IdCard();
 117       cards[tmp_cards.length] = card;
 118     }
 119     else if (element_name == "rule")
 120     {
 121       Rule[] tmp_rules = card.rules;
 122       card.rules = new Rule[tmp_rules.length + 1];
 123       for (int i=0; i<tmp_rules.length; i++)
 124       {
 125         card.rules[i] = tmp_rules[i];
 126       }
 127
 128       card.rules[tmp_rules.length] = Rule();
 129     }
 130   }
 131
 132   public void
 133   text_element_func (MarkupParseContext context,
 134                      string             text,
 135                      size_t             text_len) throws MarkupError
 136   {
 137     unowned SList<string> stack = context.get_element_stack ();
 138
 139     if (text_len < 1)
 140       return;
 141
 142     if (stack.nth_data(0) == "display-name" && display_name_handler (stack))
 143     {
 144       card.display_name = text;
 145     }
 146     else if (stack.nth_data(0) == "user" && user_handler (stack))
 147     {
 148       card.username = text;
 149     }
 150     else if (stack.nth_data(0) == "password" && password_handler (stack))
 151     {
 152       card.password = text;
 153     }
 154     else if (stack.nth_data(0) == "realm" && realm_handler (stack))
 155     {
 156       card.issuer = text;
 157     }
 158     else if (stack.nth_data(0) == "service")
 159     {
 160       string[] services = card.services;
 161       card.services = new string[services.length + 1];
 162       for (int i = 0; i<services.length; i++)
 163       {
 164         card.services[i] = services[i];
 165       }
 166       card.services[services.length] = text;
 167     }
 168     /* Rules */
 169     else if (stack.nth_data(0) == "pattern" && pattern_handler (stack))
 170     {
 171       /* use temp index to workaround valac bug */
 172       int index = card.rules.length - 1;
 173       card.rules[index].pattern = text;
 174     }
 175     else if (stack.nth_data(0) == "always-confirm" && always_confirm_handler (stack))
 176     {
 177       if (text == "true" || text == "false") {
 178         /* use temp index to workaround valac bug */
 179         int index = card.rules.length - 1;
 180         card.rules[index].always_confirm = text;
 181       }
 182     }
 183     /*Trust anchor*/
 184     else if (stack.nth_data(0) == "ca-cert" && ca_cert_handler (stack))
 185     {
 186       card.trust_anchor.ca_cert = text;
 187     }
 188     else if (stack.nth_data(0) == "subject" && subject_handler (stack))
 189     {
 190       card.trust_anchor.subject = text;
 191     }
 192     else if (stack.nth_data(0) == "subject-alt" && subject_alt_handler (stack))
 193     {
 194       card.trust_anchor.subject_alt = text;
 195     }
 196     else if (stack.nth_data(0) == "server-cert" && server_cert_handler (stack))
 197     {
 198       card.trust_anchor.server_cert = text;
 199     }
 200   }
 201
 202   class Parser
 203   {
 204     private MarkupParser parser;
 205     private string       text;
 206     private string       path;
 207     public Parser (string path)
 208     {
 209       text = "";
 210       this.path = path;
 211
 212       var file = File.new_for_path (path);
 213
 214       try
 215       {
 216         var dis = new DataInputStream (file.read ());
 217         string line;
 218         while ((line = dis.read_line (null)) != null)
 219           text += line;
 220       }
 221       catch (GLib.Error e)
 222       {
 223         error ("Could not retreive file size");
 224       }
 225
 226       parser = {start_element_func, null, text_element_func, null, null};
 227     }
 228
 229     public void
 230     parse ()
 231     {
 232       var ctx = new MarkupParseContext(parser, 0, null, null);
 233
 234       try
 235       {
 236         ctx.parse (text, text.length);
 237       }
 238       catch (GLib.Error e)
 239       {
 240         error ("Could not parse %s, invalid content", path);
 241       }
 242     }
 243   }
 244 }