CASA/c_micasad/cache/Secret.cs

/***********************************************************************
 * 
 *  Copyright (C) 2005-2006 Novell, Inc. All Rights Reserved.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; version 2.1
 *  of the License.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, Novell, Inc.
 * 
 *  To contact Novell about this file by physical or electronic mail, 
 *  you may find current contact information at www.novell.com.
 * 
 ***********************************************************************/


using System;
using System.Text;
using System.Collections;

using Novell.CASA.MiCasa.Common;

namespace sscs.cache
{
    class Secret : ISecret
    {
        private string secretID;
        //private byte[] data;
        string         ePasswd ; // TBD
     
        DateTime        createdTime;
        public DateTime CreatedTime
        {
            get
            {
                return createdTime;
            }
            set
            {
                createdTime = value;
            }
        }

        DateTime        accessedTime;
        public DateTime AccessedTime
        {
            get
            {
                return accessedTime;
            }
            set
            {
                accessedTime = value;
            }
        }

        DateTime        modifiedTime;
        public DateTime ModifiedTime
        {
            get
            {
                return modifiedTime;
            }
            set
            {
                modifiedTime = value;
            }
        }


        private Hashtable htKeyValues = new Hashtable();
        internal Secret()
        {
        }
        
        internal Secret(string secretID)
        {
            this.secretID = secretID;
        }
    
        internal Secret(string secretID, byte[] data)
        {
            this.secretID = secretID;
            //this.data = data;

            // parse the data
            ParseDataBuffer(data);

        }
    
        internal Secret(string secretID, byte[] data, string ePasswd)
        {
            this.secretID = secretID;            
            this.ePasswd = ePasswd;           
            ParseDataBuffer(data);
        }

        internal void ParseDataBuffer(byte[] data)
        {

            if (data != null)
            {
                UTF8Encoding dec = new UTF8Encoding();
                string theData = dec.GetString(data);

                char[] theChars = new char[2];
                theChars[0] = '\n';
                theChars[1] = '\0';
                String[] keyValues = theData.Split(theChars);

                char delimiter = '=';
                foreach (string keyValue in keyValues)
                {
                    int iLocation = keyValue.IndexOf(delimiter);
                    if (iLocation > 0)
                    {
                        String key = keyValue.Substring(0, iLocation);
                        String value = keyValue.Substring(iLocation + 1);

                        if (key != null && value != null)
                            this.SetKeyValue(key, value);
                    }
                }
            }
        }

        internal void SetEpasswd(string value)
        {
            ePasswd = value;
        }

        internal string GetEpasswd()
        {
            return ePasswd;
        }

        public void SetValue(byte[] data)
        {
            this.ModifiedTime = DateTime.Now;
            ParseDataBuffer(data);
        }
    
        public void SetKey(String newkey)
        {
            //Validation TBD
            this.secretID =  newkey;
        }
        
        //Get methods
        public byte[] GetValue(String key)
        {
            //validation TBD
            //if (data == null)
            {
                StringBuilder sb = new StringBuilder();

                IDictionaryEnumerator etor = (IDictionaryEnumerator)this.htKeyValues.GetEnumerator();
                while(etor.MoveNext())
                {
                    string sKey = (string)etor.Key;                    
                    KeyValue kv = (KeyValue)this.htKeyValues[sKey];                                

                    sb.Append(kv.Key);
                    sb.Append("=");
					if (kv.GetValueType() ==(KeyValue.VALUE_TYPE_BINARY))
						sb.Append("BINARY - Do not change");
					else
						sb.Append(kv.GetValue());
                    sb.Append('\n');
                }
                //sb.Append('\0');    
        
                UTF8Encoding enc = new UTF8Encoding();
                this.AccessedTime = DateTime.Now;
                return (enc.GetBytes(sb.ToString()));                
            }
            //else
            //    return data;
        }
        public byte[] GetValue()
        {
            //validation TBD
            this.AccessedTime = DateTime.Now;
            return GetValue(null);
        }
    
        public string GetKey()
        {
            return secretID;
        }

        public void SetKeyValue(string key, string value)
        {
            KeyValue kv;
            if (htKeyValues.Contains(key))
            {
                kv = (KeyValue)htKeyValues[key];
                kv.SetValue(value);
            }
            else
            {
                kv = new KeyValue(key, value);
                htKeyValues.Add(key, kv);
            }
            this.ModifiedTime = DateTime.Now;
        }

		public void SetKeyValue(string key, byte[] baValue)
		{
			KeyValue kv;
			if (htKeyValues.Contains(key))
			{
				kv = (KeyValue)htKeyValues[key];
				kv.SetValue(baValue);
			}
			else
			{
				kv = new KeyValue(key, baValue);
				htKeyValues.Add(key, kv);
			}
			this.ModifiedTime = DateTime.Now;
		}

        public KeyValue GetKeyValue(string key)
        {
            this.AccessedTime = DateTime.Now;
            if (htKeyValues.Contains(key))
            {
                KeyValue kv = (KeyValue)htKeyValues[key];
                return kv;
            }
            else
                return null;
        }

		internal void RemoveAllKeyValuePairs(KeyChain kc)
		{
			if (htKeyValues != null)
			{
                IDictionaryEnumerator enumer = htKeyValues.GetEnumerator();
				while (enumer.MoveNext())
				{
					String key = (String)enumer.Key;
					RemoveKeyValue(kc, key);
                    // refresh enumerator
                    enumer = htKeyValues.GetEnumerator();
				}
			}
		}

        public void RemoveKeyValue(KeyChain kc, string key)
        {			
            if (htKeyValues.Contains(key))
            {
				// remove all reverse links first
				RemoveReverseLinkedKeys(kc, key);								
                htKeyValues.Remove(key);
            }
        }

		private void RemoveReverseLinkedKeys(KeyChain kc, string keyId)
		{
			Hashtable linkedKeys = GetLinkedKeys(keyId);
			if (kc != null && linkedKeys != null)
			{
				IDictionaryEnumerator lkis = linkedKeys.GetEnumerator();
				while (lkis.MoveNext())
				{
					LinkedKeyInfo lki = (LinkedKeyInfo)lkis.Value;
					
					// look up reverse linked key
					Secret secret = kc.GetSecret(lki.GetLinkedSecretID());
					if (secret != null)
					{	
						// look up linked key
						KeyValue kv = secret.GetKeyValue(lki.GetLinkedKeyID());
						kv.RemoveLink(secretID + ":" + keyId);
					}
				}
			}
		}

        public DateTime GetKeyValueCreatedTime(string key)
        {
            if (htKeyValues.Contains(key))
            {
                KeyValue kv = (KeyValue)htKeyValues[key];
                return kv.CreatedTime;
            }
            else
                return (new DateTime(0));
        }

		public Hashtable GetLinkedKeys(string keyId)
		{
			if (htKeyValues.Contains(keyId))
			{
				KeyValue kv = (KeyValue)htKeyValues[keyId];
				return kv.GetLinkedKeys();
			}
			else 
				return null;

		}

        public DateTime GetKeyValueModifiedTime(string key)
        {
            if (htKeyValues.Contains(key))
            {
                KeyValue kv = (KeyValue)htKeyValues[key];
                return kv.ModifiedTime;
            }
            else
                return (new DateTime(0));
        }


        public void MergeSecret(SecretStore store, Secret newSecret)
        {			

            IDictionaryEnumerator etor = (IDictionaryEnumerator)newSecret.htKeyValues.GetEnumerator();
            while(etor.MoveNext())
            {
                string sKey = (string)etor.Key;

                // TODO:  When we sync, we should consider modified time as well
                KeyValue newKV = (KeyValue)newSecret.htKeyValues[sKey];
                this.SetKeyValue(newKV.Key, newKV.GetValue());
            }
            etor = (IDictionaryEnumerator)newSecret.htKeyValues.GetEnumerator();
            while(etor.MoveNext())
            {
                string sKey = (string)etor.Key;
                if(!htKeyValues.Contains(sKey))
                    this.RemoveKeyValue(store.GetKeyChainDefault(), sKey);
            }
        }

        public ArrayList GetKeyList()
        {
            IDictionaryEnumerator etor = (IDictionaryEnumerator)this.htKeyValues.GetEnumerator();
            ArrayList list = new ArrayList();
            if( null == etor )
            {
                return null;
            }
            while(etor.MoveNext())
            {
                 string key = (string)etor.Key;
                 list.Add(key);
            }
            return list;
        }

	internal IDictionaryEnumerator GetKeyValueEnumerator()
        {
            if( htKeyValues != null)
                return htKeyValues.GetEnumerator();
            else
                return null;
        } 
    
		public string ToXML()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append("<SECRET>");

            sb.Append("<ID>");
            sb.Append(secretID);
            sb.Append("</ID>");

            sb.Append("<DATA>");
            // enum the htKeyValues list
            //IDictionaryEnumerator ienum = htKeyValues.GetEnumerator();
            ICollection coll = htKeyValues.Values;

            IDictionaryEnumerator ienum = (IDictionaryEnumerator)coll.GetEnumerator();


            KeyValue kv = (KeyValue)ienum.Current;
            while (kv != null)
            {
                sb.Append(kv.ToXML());
                if (ienum.MoveNext())
                    kv = (KeyValue)ienum.Value;
                else
                    kv = null;
            }
            sb.Append("</DATA>");
            sb.Append("</SECRET>");

            return sb.ToString();
        }
    }
}