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       card.rules[card.rules.length - 1].pattern = text;
 172     }
 173     else if (stack.nth_data(0) == "always-confirm" && always_confirm_handler (stack))
 174     {
 175       if (text == "true" || text == "false")
 176         card.rules[card.rules.length - 1].always_confirm = text;
 177     }
 178     /*Trust anchor*/
 179     else if (stack.nth_data(0) == "ca-cert" && ca_cert_handler (stack))
 180     {
 181       card.trust_anchor.ca_cert = text;
 182     }
 183     else if (stack.nth_data(0) == "subject" && subject_handler (stack))
 184     {
 185       card.trust_anchor.subject = text;
 186     }
 187     else if (stack.nth_data(0) == "subject-alt" && subject_alt_handler (stack))
 188     {
 189       card.trust_anchor.subject_alt = text;
 190     }
 191     else if (stack.nth_data(0) == "server-cert" && server_cert_handler (stack))
 192     {
 193       card.trust_anchor.server_cert = text;
 194     }
 195   }
 196
 197   class Parser
 198   {
 199     private MarkupParser parser;
 200     private string       text;
 201     private string       path;
 202     public Parser (string path)
 203     {
 204       text = "";
 205       this.path = path;
 206
 207       var file = File.new_for_path (path);
 208
 209       try
 210       {
 211         var dis = new DataInputStream (file.read ());
 212         string line;
 213         while ((line = dis.read_line (null)) != null)
 214           text += line;
 215       }
 216       catch (GLib.Error e)
 217       {
 218         error ("Could not retreive file size");
 219       }
 220
 221       parser = {start_element_func, null, text_element_func, null, null};
 222     }
 223
 224     public void
 225     parse ()
 226     {
 227       var ctx = new MarkupParseContext(parser, 0, null, null);
 228
 229       try
 230       {
 231         ctx.parse (text, text.length);
 232       }
 233       catch (GLib.Error e)
 234       {
 235         error ("Could not parse %s, invalid content", path);
 236       }
 237     }
 238   }
 239 }