X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=src%2Fmoonshot-identities-manager.vala;h=182f2d6faa2e5b7b0f3a872dc16464a03ac15106;hb=c64066e0fd6838caafba7cac51b00ea2980a717e;hp=ab44ad5e0b07276b0d6e661b8649ee38e55356eb;hpb=1a4d573b18bf223879bc52bb6e72db014de93687;p=moonshot-ui.git

diff --git a/src/moonshot-identities-manager.vala b/src/moonshot-identities-manager.vala
index ab44ad5..182f2d6 100644
--- a/src/moonshot-identities-manager.vala
+++ b/src/moonshot-identities-manager.vala
@@ -1,86 +1,277 @@
-class IdentitiesManager : Object {
+/*
+ * Copyright (c) 2011-2014, JANET(UK)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of JANET(UK) nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+*/
+using Gee;
 
-    public SList<IdCard> id_card_list;
+public class Password {
+#if GNOME_KEYRING
+    private unowned string _password;
+    public string password {
+        get {
+            return _password;
+        }
+        set {
+            if (_password != null) {
+                GnomeKeyring.memory_free((void *)_password);
+                _password = null;
+            }
+            if (value != null)
+                _password = GnomeKeyring.memory_strdup(value); 
+        }
+    }
+#else
+    public string password { get; set; default = null; }
+#endif
 
-    private const string FILE_NAME = "identities.txt";
+    public Password(string in_password) {
+        password = in_password;
+    }
 
-    public IdentitiesManager ()
-    {
-        var key_file = new KeyFile ();
+    ~Password() {
+        password = null;
+    }
+}
 
-        var path = get_data_dir ();
-        var filename = Path.build_filename (path, FILE_NAME);
+public class PasswordHashTable : Object {
+    private HashTable<string, Password> password_table;
 
-        try
-        {
-            key_file.load_from_file (filename, KeyFileFlags.NONE);
+    private static string ComputeHashKey(IdCard card, IIdentityCardStore store) {
+        return "%s_store_%d".printf( card.display_name, store.get_store_type() );
+    }
+
+    public void CachePassword(IdCard card, IIdentityCardStore store) {
+        password_table.replace(ComputeHashKey(card, store), new Password(card.password));
+    }
+
+    public void RemovePassword(IdCard card, IIdentityCardStore store) {
+        password_table.remove(ComputeHashKey(card, store));
+    }
+    public void RetrievePassword(IdCard card, IIdentityCardStore store) {
+        weak Password password = password_table.lookup(ComputeHashKey(card, store));
+        if (password != null) {
+            card.password = password.password;
         }
-        catch (Error e)
-        {
-            stdout.printf("Error: %s\n", e.message);
+    }
+    public PasswordHashTable() {
+        password_table = new HashTable<string, Password>(GLib.str_hash, GLib.str_equal);
+    }
+}
+
+public class IdentityManagerModel : Object {
+    private const string FILE_NAME = "identities.txt";
+    private PasswordHashTable password_table;
+    private IIdentityCardStore store;
+    public LinkedList<IdCard>  get_card_list() {
+        var identities = store.get_card_list();
+        identities.sort((a, b) => {
+                IdCard id_a = (IdCard )a;
+                IdCard id_b = (IdCard )b;
+                if (id_a.IsNoIdentity() && !id_b.IsNoIdentity()) {
+                    return -1;
+                } else if (id_b.IsNoIdentity() && !id_a.IsNoIdentity()) {
+                    return 1;
+                }
+                return strcmp(id_a.display_name, id_b.display_name);
+            });
+        if (identities.is_empty || !identities[0].IsNoIdentity())
+            identities.insert(0, IdCard.NewNoIdentity());
+        foreach (IdCard id_card in identities) {
+            if (!id_card.store_password) {
+                password_table.RetrievePassword(id_card, store);
+            }
         }
+        return identities;
+    }
+    public signal void card_list_changed();
 
-        var identities_uris = key_file.get_groups ();
-        foreach (string identity in identities_uris)
+    /* This method finds a valid display name */
+    public bool display_name_is_valid(string name,
+                                      out string? candidate)
+    {
+        if (&candidate != null)
+            candidate = null;
+        foreach (IdCard id_card in this.store.get_card_list())
         {
-            try
+            if (id_card.display_name == name)
             {
-                IdCard id_card = new IdCard ();
-
-                id_card.issuer = key_file.get_string (identity, "Issuer");
-                id_card.username = key_file.get_string (identity, "Username");
-                id_card.password = key_file.get_string (identity, "Password");
-                id_card.services = key_file.get_string_list (identity, "Services");
-                id_card.display_name = key_file.get_string (identity, "DisplayName");
-                id_card.pixbuf = find_icon ("avatar-default", 48);
+                if (&candidate != null)
+                {
+                    for (int i = 0; i < 1000; i++)
+                    {
+                        string tmp = "%s %d".printf(name, i);
+                        if (display_name_is_valid(tmp, null))
+                        {
+                            candidate = tmp;
+                            break;
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+        return true;
+    }
 
-                id_card_list.prepend (id_card);
+    private bool remove_duplicates(IdCard card)
+    {
+        bool duplicate_found = false;
+        bool found = false;
+        do {
+            var cards = this.store.get_card_list();
+            found = false;
+            foreach (IdCard id_card in cards) {
+                if ((card != id_card) && (id_card.nai == card.nai)) {
+                    stdout.printf("removing duplicate id for '%s'\n", card.nai);
+                    remove_card_internal(id_card);
+                    found = duplicate_found = true;
+                    break;
+                }
             }
-            catch (Error e)
-            {
-                stdout.printf ("Error:  %s\n", e.message);
+        } while (found);
+        return duplicate_found;
+    }
+
+    public IdCard? find_id_card(string nai, bool force_flat_file_store) {
+        IdCard? retval = null;
+        IIdentityCardStore.StoreType saved_store_type = get_store_type();
+        if (force_flat_file_store)
+            set_store_type(IIdentityCardStore.StoreType.FLAT_FILE);
+
+        foreach (IdCard id in get_card_list()) {
+            if (id.nai == nai) {
+                retval = id;
+                break;
             }
         }
+        set_store_type(saved_store_type);
+        if (force_flat_file_store && 
+            (saved_store_type != IIdentityCardStore.StoreType.FLAT_FILE))
+            card_list_changed();
+        return retval;
     }
 
-    public void store_id_cards ()
-    {
-        var key_file = new KeyFile ();
+    public void add_card(IdCard card, bool force_flat_file_store) {
+        if (card.temporary)
+            return;
 
-        foreach (IdCard id_card in this.id_card_list)
+        string candidate;
+        IIdentityCardStore.StoreType saved_store_type = get_store_type();
+
+        if (force_flat_file_store)
+            set_store_type(IIdentityCardStore.StoreType.FLAT_FILE);
+
+        remove_duplicates(card);
+
+        if (!display_name_is_valid(card.display_name, out candidate))
         {
-            key_file.set_string (id_card.display_name, "Issuer", id_card.issuer);
-            key_file.set_string (id_card.display_name, "DisplayName", id_card.display_name);
-            key_file.set_string (id_card.display_name, "Username", id_card.username);
-            key_file.set_string (id_card.display_name, "Password", id_card.password ?? "");
-            key_file.set_string_list (id_card.display_name, "Services", id_card.services);
+            card.display_name = candidate;
         }
 
-        var text = key_file.to_data (null);
+        if (!card.store_password)
+            password_table.CachePassword(card, store);
+        store.add_card(card);
+        set_store_type(saved_store_type);
+        card_list_changed();
+    }
 
-        try
-        {
-            var path = get_data_dir ();
-            var filename = Path.build_filename (path, FILE_NAME);
-            FileUtils.set_contents (filename, text, -1);
+    public IdCard update_card(IdCard card) {
+        IdCard retval;
+        if (card.temporary) {
+            retval = card;
+            return retval;
         }
-        catch (Error e)
-        {
-            stdout.printf ("Error:  %s\n", e.message);
+            
+        if (!card.store_password)
+            password_table.CachePassword(card, store);
+        else
+            password_table.RemovePassword(card, store);
+        retval = store.update_card(card);
+        card_list_changed();
+        return retval;
+    }
+
+    private bool remove_card_internal(IdCard card) {
+        if (card.temporary)
+            return false;
+        password_table.RemovePassword(card, store);
+        return store.remove_card(card);
+    }
+
+    public bool remove_card(IdCard card) {
+        if (remove_card_internal(card)) {
+            card_list_changed();
+            return true;
         }
+        return false;
     }
 
-    private string get_data_dir()
-    {
-        string path;
+    public void set_store_type(IIdentityCardStore.StoreType type) {
+        if ((store != null) && (store.get_store_type() == type))
+            return;
+        switch (type) {
+            #if GNOME_KEYRING
+        case IIdentityCardStore.StoreType.KEYRING:
+            store = new KeyringStore();
+            break;
+            #endif
+        case IIdentityCardStore.StoreType.FLAT_FILE:
+        default:
+            store = new LocalFlatFileStore();
+            break;
+        }
+    }
 
-        path = Path.build_filename (Environment.get_user_data_dir (),
-                                    Config.PACKAGE_TARNAME);
-        if (!FileUtils.test (path, FileTest.EXISTS))
-        {
-            DirUtils.create (path, 0700);
+    public IIdentityCardStore.StoreType get_store_type() {
+        return store.get_store_type();
+    }
+
+    public bool HasNonTrivialIdentities() {
+        foreach (IdCard card in this.store.get_card_list()) {
+            // The 'NoIdentity' card is non-trivial if it has services or rules.
+            // All other cards are automatically non-trivial.
+            if ((!card.IsNoIdentity()) || 
+                (card.services.length > 0) ||
+                (card.rules.length > 0)) {
+                return true;
+            }
         }
+        return false;
+    }
+
+
+    private IdentityManagerApp parent;
 
-        return path;
+    public IdentityManagerModel(IdentityManagerApp parent_app, IIdentityCardStore.StoreType store_type) {
+        parent = parent_app;
+        password_table = new PasswordHashTable();
+        set_store_type(store_type);
     }
 }