using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Collections.Specialized;
using System.Collections;

using Novell.CASA.MiCasa.Communication;
using Novell.CASA.MiCasa.Common;

namespace Novell.CASA
{
	/// <summary>
	/// Summary description for NativeCalls.
	/// </summary>
	public class NativeCalls
	{
		private static SSCS_KEYCHAIN_ID_T	DefaultKeychainID = null;		
		private static int SSCS_CRED_TYPE_BASIC_F  = 1;
		private static int USERNAME_LEN = 256;
		private static int PASSWORD_LEN = 128;

		public NativeCalls()
		{
			//
			// TODO: Add constructor logic here
			//
			if (DefaultKeychainID == null)
			{
				DefaultKeychainID = new SSCS_KEYCHAIN_ID_T();		
			}
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_PASSWORD_T
		{
			public uint			pwordType;
			public uint			pwordLen;		// * enhanced protection len & pword to set
//			[MarshalAs(UnmanagedType.LPStr, SizeConst = 128)]
                        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
			public string		pword;			// * should be passed in # of chars
		} ;

                [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
                public class SSCS_PASSCODE_T
                {
                    public uint passcodeType;
                    public IntPtr passcodeHandle;    
                }

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_KEYCHAIN_ID_T
		{
			public int		len;		
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
			public string	keychainID;
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SH_SECRET_ID_T
		{
			public int  	type;				// The shared secret type i.e. SS_App  or  SS_CredSet
			public int  	len;				// except that it excludes the header and is not escaped.
			[MarshalAs(UnmanagedType.ByValTStr , SizeConst = 512)]
			public string	name;				// The shared secret name. This is the same as the identifier 
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SECRET_STORE_ID_T
		{
			public int				len;						// * max id len in bytes
			[MarshalAs(UnmanagedType.LPStr, SizeConst = 512)]
			public string			id;							// * should be passed in # of chars
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SECRET_ID_T
		{
			public int		len;						// * max id len in bytes
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
			public string	id; 						// * should be passed in # of chars
		};

				[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
					public class SSCS_HINT_T
				{
					ulong		hintLen;		
					[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
					string		hint;	//* should be passed in # of chars
				};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_EXT_T
		{
			public int			extID; 		// defined to identify the extension 
			public int			version;	// defined as the version of the specified extension
			public IntPtr		ext;		// points to the actual extension
		} ;
		/*
				[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
					public class SSCS_SECRETSTORE_INF_T
				{
					uint 	numKeyChains;
					uint	enumBufsize; 
				};
		*/
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SRCH_KEY_T
		{
			public uint		srchKeyLen;	
			[MarshalAs(UnmanagedType.LPStr, SizeConst = 128)]
			public string	srchKey; //[NSSCS_MAX_SRCH_KEY_LEN];	//* should be passed in # of chars
		} ;

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SECRET_ID_LIST_T
		{
			public uint			enumHandle;
			public uint			returnedIDs;
			public IntPtr		secretIDList; //* an array of secretID structures						
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SH_SECRET_ID_LIST_T
		{
			public uint			enumHandle;
			public uint			returnedIDs;			
			public IntPtr		secretIDList; //* an array of secretID structures						
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_CONTEXT_T
		{
			public int								version;
			public int								flags;
			public SSCS_SECRET_ID_T					ssid;
			public UInt64							ssHandle;			
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_READEXT_T
		{
			public uint		statFlags;		//* OUT - return flags on the secret
			public uint		crtStamp;		//* OUT - secret creation time stamp
			public uint		latStamp;		//* OUT - last accessed time stamp (optional)
			public uint		lmtStamp;		//* OUT - last modified time stamp
		};

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_SECRETSTORE_INFO_T
		{
			public UInt32 statFlags;
			public UInt32 secretCount;
			public UInt32 lockCount;
			public UInt32 enumBufLen;
			public UInt32 hidSecCount;
			public UInt32 clientVersion;
			public UInt32 serverVersion;
			public UInt32 serverCryptoStrength;
			public UInt32 clientCryptoStrength;
			public UInt32 unlockTStamp;
			public UInt32 admnDNLen;
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 516)]
			public string admnDN; //[NSSS_MAX_DN_LEN];
			public UInt32 hintLen;
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
			public string hint; //[NSSS_MAX_MP_PWORD_HINT_LEN]];
		};

/*
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_BASIC_CREDENTIAL
		{
			public uint			unFlags;
			public uint			unLen;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
			public string		username;			
			public uint		pwordLen;
			[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
			public string		password;			
		}
*/
		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
			public class SSCS_BASIC_CREDENTIAL_UTF8
		{
			public uint			unFlags;
			public uint			unLen;
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
			public byte[]		username;			
			public uint			pwordLen;
			[MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
			public byte[]		password;			
		}

		// * The following functions will be exposed as exported API:
		// **************************************************************
		// * These function calls will utilize the Support Functions for 
		// * populating or extracting data from a Shared Secret.
		// **************************************************************

		private const string NDK_LIBRARY = "micasa";

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASARemoveCredential
			(			
			[In]		uint	 				ssFlags, 				// IN
			[In]		SSCS_SECRET_ID_T		appSecretID, 
			[In]		SSCS_SECRET_ID_T		sharedSecretID, 					
			[In, Out]	SSCS_EXT_T				ext
			);



		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAGetCredential
			(			
			[In]		uint	 				ssFlags, 				// IN
			[In]		SSCS_SECRET_ID_T		appSecretID, 
			[In]		SSCS_SECRET_ID_T		sharedSecretID, 						 
			int									credentialType,			// IN
			[In, Out]	IntPtr					pCredential,		
			[In, Out]	SSCS_EXT_T				ext
			);


		[DllImport(NDK_LIBRARY)]
		public static extern int miCASASetCredential
			(			
			[In]		uint	 				ssFlags, 				// IN
			[In]		SSCS_SECRET_ID_T		appSecretID, 
			[In]		SSCS_SECRET_ID_T		sharedSecretID, 						 
			int									credentialType,			// IN
			[In]		IntPtr					credential,			
			[In, Out]	SSCS_EXT_T				ext
			);
                [DllImport(NDK_LIBRARY)]
                public static extern int miCASASetMasterPasscode
                (
                    [In] uint            ssFlags,
                    [In] SSCS_PASSCODE_T passcode,
                    [In] SSCS_EXT_T      ext
                );

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAIsSecretPersistent
		(			
 		    [In] uint ssFlags,
 		    [In] SSCS_SECRET_ID_T secretID, 
		    [In, Out] SSCS_EXT_T ext
		);
		
		[DllImport(NDK_LIBRARY)]
		public static extern IntPtr miCASAOpenSecretStoreCache
			(
			[In, Out] SSCS_SECRET_STORE_ID_T	ssid,
			ulong					 			ssFlags, 
			[In, Out] SSCS_EXT_T				ext
			);

		
		[DllImport(NDK_LIBRARY)]
		public static extern int miCASACloseSecretStoreCache 
			(
			[In]		IntPtr				context,
			[In]		uint				ssFlags, 
			[In, Out]	SSCS_EXT_T			ext
			);


		[DllImport(NDK_LIBRARY) ]
		public static extern int miCASAReadSecret
			(							
			[In]				IntPtr				context,
			[In]				SSCS_KEYCHAIN_ID_T	keyChainID, 
			[In]				uint				ssFlags, 
			[In]				IntPtr				secretHandle, 
			[In]				SSCS_SH_SECRET_ID_T	sharedSecretID, 
			[In]				SSCS_PASSWORD_T		epPassword, 
			[In, Out]			SSCS_READEXT_T		readData, 
			[In, Out]			SSCS_EXT_T			ext
			);


		// TODO: check the order of these paramters
		[DllImport(NDK_LIBRARY)]
		public static extern int miCASARemoveSecret
			(
			[In]		IntPtr					context,
			[In]		SSCS_KEYCHAIN_ID_T		keyChainID, 
			[In]		uint					ssFlags, 			
			[In]		SSCS_SH_SECRET_ID_T		sharedSecretID, 
			[In]		SSCS_PASSWORD_T			epPassword, 
			[In, Out]	SSCS_EXT_T				ext
			);


		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAWriteSecret
			(
			[In]		IntPtr					context,
			[In]		SSCS_KEYCHAIN_ID_T		keyChainID, 
			[In]		uint					ssFlags, 
			[In]		IntPtr					secretHandle, 
			[In]		SSCS_SH_SECRET_ID_T		sharedSecretID, 
			[In]		SSCS_PASSWORD_T			epPassword, 
			[In]		SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAGetStoreInformation 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 
			[In, Out]	SSCS_SECRETSTORE_INFO_T	ssInfo,
			[In, Out]	SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAEnumerateSecretIDs 
			(
			[In]		IntPtr						context,			
			[In]		SSCS_KEYCHAIN_ID_T			keyChainID, 
			[In]		uint						ssFlags, 
			[In]		SSCS_SRCH_KEY_T				searchKey, 
			[In, Out]	SSCS_SH_SECRET_ID_LIST_T	secretIDList, 
			[In, Out]	SSCS_EXT_T					ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAEnumerateKeyChainIDs 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 			
			[In]		SSCS_SRCH_KEY_T			searchKey, 
			[In, Out]	SSCS_SECRET_ID_LIST_T	kcIDList, 
			[In, Out]	SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASARemoveSecretStore 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 
			[In, Out]	SSCS_EXT_T				ext
			);
		
		[DllImport(NDK_LIBRARY)]
		public static extern int miCASASetMasterPassword 
					(
					[In]		uint					ssFlags, 
					[In]		SSCS_PASSWORD_T			password, 
					[In]		SSCS_HINT_T				hint, 
					[In, Out]	SSCS_EXT_T				ext
					);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAUnlockSecrets 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 
			[In]		SSCS_PASSWORD_T			password, 
			[In, Out]	SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASALockStore
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 
			[In, Out]	SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAUnlockStore
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags, 
			[In]		SSCS_PASSWORD_T			password, 
			[In, Out]	SSCS_EXT_T				ext
			);


		[DllImport(NDK_LIBRARY)]
		public static extern int miCASARemoveKeyChain 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags,
			[In]		SSCS_KEYCHAIN_ID_T		keyChainID, 
			[In, Out]	SSCS_EXT_T				ext
			);

		[DllImport(NDK_LIBRARY)]
		public static extern int miCASAAddKeyChain 
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags,
			[In]		SSCS_KEYCHAIN_ID_T		keyChainID, 
			[In, Out]	SSCS_EXT_T				ext
			);

		//**************************************************************
		//* Support Functions for processing (populating or extracting) 
		//* data components from a Shared Secret
		//**************************************************************
		[DllImport(NDK_LIBRARY)]
		public static extern IntPtr miCASA_CreateSHSHandle();
		
		[DllImport(NDK_LIBRARY)]
		public static extern int miCASA_DestroySHSHandle(
			[In] IntPtr secretHandle);
			

		[DllImport(NDK_LIBRARY, CharSet=CharSet.None) ]
		public static extern int miCASA_GetNextSHSEntry
			(
			[In]		int 			restart,		//* in (set to 1 to begin from head of list)
			[In]		IntPtr  		secretHandle,	//* in 
			[In, Out]	ref uint		keyLen,			//* out	
			IntPtr		theKey,
			[In, Out]	ref uint 		valLen,			//* out				
			IntPtr		theValue
			);
		

		[DllImport(NDK_LIBRARY, CharSet=CharSet.None)]
		public static extern int miCASA_AddSHSEntry
			(
			[In]		IntPtr  		secretHandle,	//* in]
			[MarshalAs(UnmanagedType.LPStr)]
			string			key,						//* in  /wchar
			[In]		uint			valueLenBytes,	// in bytes
			[MarshalAs(UnmanagedType.LPStr)]
			string			val							//* in /uchar			
			);

		[DllImport(NDK_LIBRARY, CharSet=CharSet.None)]
		public static extern int miCASAWriteKey
			(
			[In]		IntPtr					context,
			[In]		uint					ssFlags,
			[In]		SSCS_KEYCHAIN_ID_T		keyChainID, 
			[In]		SSCS_SH_SECRET_ID_T		sharedSecretID, 
			[MarshalAs(UnmanagedType.LPStr)]
						string					key,				//* in  /wchar
			[In]		uint					keyLenBytes,		// in bytes
			[MarshalAs(UnmanagedType.LPStr)]
						string					val,				//* in /uchar			
			[In]		uint					valueLenBytes,	// in bytes
			[In]		SSCS_PASSWORD_T			password, 
			[In, Out]	SSCS_EXT_T				ext				
			);
		
		[DllImport(NDK_LIBRARY)]
		public static extern int miCASA_RemoveSHSEntry
			(
			[In]		IntPtr  		secretHandle,	//* in 
			[MarshalAs(UnmanagedType.LPStr)]
			string			key,						//* out  /uchar
			uint			valueLenBytes,				// in bytes
			[MarshalAs(UnmanagedType.LPStr)]
			string			val							//* out /uchar
			);



		// Methods start here
		internal IntPtr openSecretStore(string sSecretStoreName)
		{			
			SSCS_SECRET_STORE_ID_T SSid = new SSCS_SECRET_STORE_ID_T();			
			SSid.id = sSecretStoreName;
			SSid.len = sSecretStoreName.Length;

			SSCS_EXT_T ext = new SSCS_EXT_T();
			try
			{
				IntPtr hSC = miCASAOpenSecretStoreCache( SSid, 0, ext);
				return hSC;
			}
			catch (Exception)
			{
				return IntPtr.Zero;
			}
		}

		internal Secret getSecret(
			IntPtr pHsc,
			string sKeyChainID,
			uint   iFlags,
			string sSharedSecretID,
			int	iSecretType,
			string sEPPassword)
						
		{						
			// setup structures
			SSCS_KEYCHAIN_ID_T		keyChainID = new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID = sKeyChainID;

			SSCS_SH_SECRET_ID_T		sharedSecretID = new SSCS_SH_SECRET_ID_T();
			sharedSecretID.name = sSharedSecretID;
			
			SSCS_PASSWORD_T			epPassword = new SSCS_PASSWORD_T();
			SSCS_READEXT_T			readData = new SSCS_READEXT_T();
			SSCS_EXT_T				ext	=new SSCS_EXT_T();

			// get SecretHandle
			IntPtr pSecretHandle	= miCASA_CreateSHSHandle();
			
			// setup keychainid
			keyChainID.len = sKeyChainID.Length + 1;
			
			// setup sharedSecretID			
			sharedSecretID.len = sSharedSecretID.Length + 1;
			sharedSecretID.type = iSecretType;   // TODO: type APP(1), CRED(2), or Binary(4)
	
			epPassword.pwordType = 1;			// TODO: ep or master password based on flags
			if (sEPPassword != null)
			{
				epPassword.pword = sEPPassword;
				epPassword.pwordLen = (uint)sEPPassword.Length;
			}
			else
				epPassword.pwordLen = 0;
											
			int rcode = miCASAReadSecret(
				pHsc,
				keyChainID,
				iFlags,				
				pSecretHandle,
				sharedSecretID,
				epPassword,
				readData,
				ext);
			
			
			// create new secret
			Secret temp = new Secret(pHsc, sKeyChainID, iFlags, pSecretHandle, sSharedSecretID, sharedSecretID.type, sEPPassword);
			temp.setTimeStamps(readData.crtStamp, readData.lmtStamp, readData.latStamp);
			

			// if read was sucessful, read key value pairs
			if (rcode == 0)
				loadKeyValuePairs(temp);
			//			else
			//				throw new Exception();

			return temp;
		}

		internal void loadKeyValuePairs(Secret secret)
		{
			int rcode=0;
			int iStart = 1;
			IntPtr theKey = Marshal.AllocHGlobal(60416);
			IntPtr theValue = Marshal.AllocHGlobal(60416);
			String sKey;
			String sValue;

			while (true)
			{			
				uint iKeyLen = 60416;						
				uint iValueLen = 60416;

				sKey = "";
				sValue = "";
				
				rcode = miCASA_GetNextSHSEntry(
					iStart,
					secret.m_secretHandle,
					ref iKeyLen,
					theKey, //sKey,
					ref iValueLen,
					theValue // sValue
					);


				if (rcode != 0) 
					break;
				else
				{                          
					if (iKeyLen > 1)
						sKey = Marshal.PtrToStringAnsi(theKey, (int)iKeyLen - 1);

					if (iValueLen > 1)
						sValue = Marshal.PtrToStringAnsi(theValue, (int)iValueLen -1);
									
					secret.setKeyValuePair(sKey, sValue);
					iStart = 0;
				}
			
			}	
			Marshal.FreeHGlobal(theKey);
			Marshal.FreeHGlobal(theValue);		
		}

		internal static int removeKeyValue(
			IntPtr pSecretHandle, 
			string sKey, 
			string sValue,	
			uint ctxFlags)
		{

			if ((sKey == null) || (sValue == null))
				return 0;

			int rcode = miCASA_RemoveSHSEntry(
				pSecretHandle,
				sKey,
				(uint)(sValue.Length + 1) * 2,
				sValue);

			return rcode;
		}

/*
		internal int setSecret(
			IntPtr pHsc,    
			string sKeyChainID, 
			uint   iFlags, 	
			Secret secret, 
			int		iSecretType)
		{			
			int rcode;


			if (iSecretType == Secret.SS_BINARY)
			{
				rcode = miCASA_AddSHSEntry(
					secret.m_secretHandle,
					"SS_Binary",
					(uint)secret.getBinaryValue().Length,
					secret.getBinaryValue().ToString());				
			}
			else
			{
				NameValueCollection nvc = secret.getKeyValueCollection();			
				if (nvc != null)
				{
					for (int i=0; i<nvc.Count; i++)
					{

						String sKey = nvc.GetKey(i);
						String sValue = nvc.Get(sKey);			// = new StringBuilder();								

						if (sKey.Length > 0) 
						{
							// first write out all key/value pairs				
							rcode = miCASA_AddSHSEntry(
								secret.m_secretHandle,
								sKey,							//sKey,		
								(uint)(sValue.Length+1) * 2,
								sValue);						//sValue);  						
						}

					}
				}
			}

			// now call miCASAWriteSecret
			SSCS_KEYCHAIN_ID_T		keyChainID = new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID = sKeyChainID;

			SSCS_SH_SECRET_ID_T		sharedSecretID = new SSCS_SH_SECRET_ID_T();
			SSCS_PASSWORD_T			epPassword = new SSCS_PASSWORD_T();			
			SSCS_EXT_T				ext	=new SSCS_EXT_T();
			ext.extID = 0;
			ext.version = 0;
			

			// setup keychainid
			keyChainID.len = sKeyChainID.Length + 1;

			String tempStr = secret.getID();
            sharedSecretID.name = tempStr;
			sharedSecretID.len = tempStr.Length + 1;	
			sharedSecretID.type = iSecretType;				// TODO: type APP(1), CRED(2), or Binary(4)

			if (secret.getEnhancedProtectionPassword() != null)
			{
				epPassword.pword = secret.getEnhancedProtectionPassword();
				epPassword.pwordLen = (uint)secret.getEnhancedProtectionPassword().Length + 1;
				epPassword.pwordType = 0;
			}
			else
			{
				epPassword = null;
			}
			
			ext.ext = Marshal.AllocHGlobal(10);
			try 
			{
				rcode = miCASAWriteSecret(
					pHsc,
					keyChainID,
					iFlags,
					secret.m_secretHandle,
					sharedSecretID,
					epPassword,
					ext);		
			}
			catch (Exception)
			{
				//Console.WriteLine(e.ToString());
				rcode = -803;
			}
		
			Marshal.FreeHGlobal(ext.ext);
			return rcode;
		}
*/

                internal bool KeyInNewList(NameValueCollection nvc, string key)
                {

                    Console.WriteLine("Checking for " + key );
                    if (nvc != null)
                    {
                        for (int i = 0; i < nvc.Count; i++)
                        {
                            string sKey = nvc.GetKey(i);
                            if( key == sKey )
                                return true;
                        }
                    }
                    Console.WriteLine("key = " + key + " is not present in nvc");
                    return false;
                } 


		internal int setSecret(
			IntPtr pHsc,    
			string sKeyChainID, 
			uint   iFlags, 	
			Secret secret, 
			int		iSecretType)
		{			

			int rcode = 0;
			
			// now call miCASAWriteSecret
			SSCS_KEYCHAIN_ID_T		keyChainID = new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID = sKeyChainID;

			SSCS_SH_SECRET_ID_T		sharedSecretID = new SSCS_SH_SECRET_ID_T();
			SSCS_PASSWORD_T			epPassword = new SSCS_PASSWORD_T();			
			SSCS_EXT_T				ext	=new SSCS_EXT_T();
			ext.extID = 0;
			ext.version = 0;
			

			// setup keychainid
			keyChainID.len = sKeyChainID.Length + 1;

			String tempStr = secret.getID();
			sharedSecretID.name = tempStr;
			sharedSecretID.len = (tempStr.Length + 1) * 2;	
			sharedSecretID.type = iSecretType;				// TODO: type APP(1), CRED(2), or Binary(4)

			if (secret.getEnhancedProtectionPassword() != null)
			{
				epPassword.pword = secret.getEnhancedProtectionPassword();
				epPassword.pwordLen = (uint)secret.getEnhancedProtectionPassword().Length + 1;
				epPassword.pwordType = 0;
			}
			else
			{
				epPassword = null;
			}
			
			ext.ext = Marshal.AllocHGlobal(10);


			if (iSecretType == Secret.SS_BINARY)
			{
				rcode = miCASA_AddSHSEntry(
					secret.m_secretHandle,
					"SS_Binary",
					(uint)secret.getBinaryValue().Length,
					secret.getBinaryValue().ToString());				
			}
			else
			{
				NameValueCollection nvc = secret.getKeyValueCollection();			
				if (nvc != null)
				{
					for (int i=0; i<nvc.Count; i++)
					{

                                                rcode = 0;
						String sKey = nvc.GetKey(i);
						String sValue = nvc.Get(sKey);			// = new StringBuilder();								

						if (sKey.Length > 0) 
						{
							try 
							{																
								object o = MiCasaRequestReply.Send(MiCasaRequestReply.VERB_WRITE_KEY,
									sKeyChainID,
									secret.getID(),
									sKey,
									sValue);

								/*
								rcode = miCASAWriteKey(
									pHsc,
									iFlags,
									keyChainID,
									sharedSecretID,
									sKey,
									(uint) (sKey.Length+1) * 2,
									sValue,
									(uint) (sValue.Length+1) * 2,
									epPassword,
									ext);
								*/
							}
							catch (Exception e)
							{								
								rcode = -803;
							}
						}
					}

                                        if( 0 == rcode )
                                        {
                                        try
                                        {

                                            ArrayList keyList = (ArrayList)MiCasaRequestReply.Send(MiCasaRequestReply.VERB_GET_KEY_LIST,sKeyChainID,secret.getID(),null,null);

                                            if( null != keyList )
                                            {
                                                IEnumerator etor = keyList.GetEnumerator();
                                                while( etor.MoveNext() )
                                                {
                                                    string key = (string)etor.Current;
                                                    if(KeyInNewList(nvc,key) == false)
                                                    {
                                                        MiCasaRequestReply.Send(MiCasaRequestReply.VERB_REMOVE_KEY,sKeyChainID,secret.getID(),key, null );           
                                                    }
                                                    
                                                }
                                            }
                                        }
                                        catch(Exception e)
                                        {
                                            rcode = -803;
                                            Console.WriteLine(e.ToString());
                                        }
                                        }
				}
			}

			Marshal.FreeHGlobal(ext.ext);
			return rcode;
		}


		internal int RemoveSecret(
			IntPtr context,
			uint ssFlags,
			string sKeyChainID,
			string sEPPassword,
			string sSecretID,
			int iSecretType)
		{
			int rcode = 0;

			SSCS_KEYCHAIN_ID_T keyChainID = new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID = sKeyChainID;
			keyChainID.len = sKeyChainID.Length + 1;

			SSCS_PASSWORD_T epPassword = new SSCS_PASSWORD_T();
			epPassword.pword = sEPPassword;
			epPassword.pwordLen = (uint)sEPPassword.Length + 1;
			epPassword.pwordType = 0;  // todo set type

			SSCS_SH_SECRET_ID_T secretID = new SSCS_SH_SECRET_ID_T();
            secretID.name = sSecretID;

			secretID.len = sSecretID.Length + 1;
			secretID.type = iSecretType;

			SSCS_EXT_T ext = new SSCS_EXT_T();

			// make the call
			rcode = miCASARemoveSecret(
				context,
				keyChainID,
				ssFlags,				
				secretID,
				epPassword,
				ext);
			

			return rcode;

		}

		internal StringCollection EnumerateSecretIDs(
			IntPtr context,
			uint ssFlags,
			string sKeyChainID,
			string sSearchKey)
		{


			// setup structures
			SSCS_KEYCHAIN_ID_T keyChainID		= new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID = sKeyChainID;

			SSCS_SRCH_KEY_T	searchKey			= new SSCS_SRCH_KEY_T();
			SSCS_SH_SECRET_ID_LIST_T  idList	= new SSCS_SH_SECRET_ID_LIST_T();
			SSCS_EXT_T ext						= new SSCS_EXT_T();

			int numIDS = 100;
			StringCollection sc = null;

			// setup keychainid
			keyChainID.len = sKeyChainID.Length + 1;

			searchKey.srchKey = sSearchKey;
			searchKey.srchKeyLen = (uint)sSearchKey.Length;
						
			idList.returnedIDs = (uint)numIDS;

			SSCS_SH_SECRET_ID_T secretId = new SSCS_SH_SECRET_ID_T();
//			secretId.name = new char[512];
			
			StringBuilder buffer3 = new StringBuilder( "content", 512 ); 
			buffer3.Append( (char)0 );
			buffer3.Append( '*', buffer3.Capacity - 8 );
			String tempStr = buffer3.ToString();
			idList.secretIDList = Marshal.AllocHGlobal(numIDS * Marshal.SizeOf(secretId));
			
						
			// make the call
			int rcode = miCASAEnumerateSecretIDs(
				context,				
				keyChainID,
				ssFlags,
				searchKey,
				idList,
				ext);

			if (idList.returnedIDs > 0)
			{					
				sc = new StringCollection();
				
				if (idList.returnedIDs != 100)
				{
					// enumerate returned list
					for (int i=0; i<idList.returnedIDs; i++)
					{			
						IntPtr temp = new IntPtr(idList.secretIDList.ToInt32() + (i * Marshal.SizeOf(secretId)));
						secretId = (SSCS_SH_SECRET_ID_T)Marshal.PtrToStructure(temp, typeof(SSCS_SH_SECRET_ID_T));

//						String st = new String(secretId.name,0,secretId.len - 1);
						String st = secretId.name;
						sc.Add(st);
					}
				}			
			}			

			Marshal.FreeHGlobal(idList.secretIDList);
			return sc;
		}

		public void AddKeyChain(
			IntPtr context,
			uint ssFlags,
			string sKeyChainID)
		{
			SSCS_KEYCHAIN_ID_T keyChainID		= new SSCS_KEYCHAIN_ID_T();
			keyChainID.keychainID				= sKeyChainID;
			keyChainID.len = sKeyChainID.Length + 1;
			
			SSCS_EXT_T ext						= new SSCS_EXT_T();
			int rcode = miCASAAddKeyChain(context, ssFlags, keyChainID, ext);
		}


		public static BasicCredential GetCredential(
			uint ssFlags,
			string sAppSecretID,
			string sSharedSecretID,
			uint unFlag)

		{
			int rcode;
			BasicCredential bc = null;

			SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
			appSecretID.id = sAppSecretID;
			appSecretID.len = sAppSecretID.Length;

			SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
			if (sSharedSecretID != null)
			{
				sharedID.len = sSharedSecretID.Length;
				sharedID.id = sSharedSecretID;

			}

			SSCS_BASIC_CREDENTIAL_UTF8 credential = new SSCS_BASIC_CREDENTIAL_UTF8();
			credential.unFlags = unFlag;
			
			// alloc some memory
			IntPtr pCredential = Marshal.AllocHGlobal(Marshal.SizeOf(credential));			
			Marshal.StructureToPtr(credential, pCredential, false);
			
			rcode = miCASAGetCredential(
				ssFlags,
				appSecretID,
				sharedID,
				0,
				pCredential,
				new SSCS_EXT_T()
				);
             

			if (rcode == 0)
			{
				Marshal.PtrToStructure(pCredential, credential);
				string sUsername = GetStringFromUTF8(credential.username, (int)credential.unLen - 1);
				string sPassword = GetStringFromUTF8(credential.password, (int)credential.pwordLen - 1);
				
				bc = new BasicCredential(sUsername, sPassword);
				Marshal.FreeHGlobal(pCredential);
				return bc;
			}
			else
			{
				Marshal.FreeHGlobal(pCredential);
				throw new miCasaException(rcode);
			}
						
		}


		public static void SetCredential(
			uint ssFlags,
			string sAppSecretID,
			string sSharedSecretID,
			uint unFlag,
			string sUsername,
			string sPassword)
		{
			int rcode;

			SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
			appSecretID.id = sAppSecretID;
			appSecretID.len = sAppSecretID.Length;

			SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
			if (sSharedSecretID != null)
			{
				sharedID.len = sSharedSecretID.Length;
				sharedID.id = sSharedSecretID;
			}

			SSCS_BASIC_CREDENTIAL_UTF8 credential = new SSCS_BASIC_CREDENTIAL_UTF8();
			credential.unFlags = unFlag;									

			credential.unLen = GetUTF8ByteCount(sUsername);
            credential.username = GetUTF8FromString(sUsername, USERNAME_LEN);

			credential.pwordLen = GetUTF8ByteCount(sPassword);
			credential.password = GetUTF8FromString(sPassword, PASSWORD_LEN);

			IntPtr pCredential = Marshal.AllocHGlobal(Marshal.SizeOf(credential));

			Marshal.StructureToPtr(credential, pCredential, true);
				
			rcode = miCASASetCredential
				(ssFlags,
				appSecretID,
				sharedID,
				SSCS_CRED_TYPE_BASIC_F,
				pCredential,
				new SSCS_EXT_T()
				);

			if (rcode != 0)
			{
				throw new miCasaException(rcode);
			}
		}
	

		public static void RemoveCredential(
			uint ssFlags,
			string sAppSecretID,
			string sSharedSecretID)
	
		{
			int rcode;			
			SSCS_SECRET_ID_T appSecretID = new SSCS_SECRET_ID_T();
			appSecretID.id = sAppSecretID;
			appSecretID.len = sAppSecretID.Length;

			SSCS_SECRET_ID_T sharedID = new SSCS_SECRET_ID_T();
			if (sSharedSecretID != null)
			{
				sharedID.len = sSharedSecretID.Length;
				sharedID.id = sSharedSecretID;
			}
						
			rcode = miCASARemoveCredential(ssFlags, appSecretID, sharedID, new SSCS_EXT_T());

			if (rcode != 0)
			{
				throw new miCasaException(rcode);
			}
			
		}

		public static int SetMasterPasscode(
			uint ssFlags,
                        string passcodeStr)
		{
                    int rcode = -1;			
                    try
                    {
                        SSCS_PASSCODE_T passcode = new SSCS_PASSCODE_T();
                        SSCS_PASSWORD_T passwd = new SSCS_PASSWORD_T();

                        passwd.pwordType = 1;
/* UTF8 ??
                        passwd.pword = GetUTF8FromString(passcodeStr,PASSWORD_LEN);
                        passwd.pwordLen = GetUTF8ByteCount(passcodeStr);
*/
                        passwd.pword = passcodeStr;
                        passwd.pwordLen = (uint)passcodeStr.Length;


                        passcode.passcodeType = 1;
                        IntPtr temp = Marshal.AllocHGlobal(Marshal.SizeOf(passwd));
                        Marshal.StructureToPtr(passwd, temp, false);
                        passcode.passcodeHandle = temp;
 
                        rcode = miCASASetMasterPasscode(ssFlags, 
                                                        passcode, 
                                                        new SSCS_EXT_T());
                    }
                    catch(Exception e)
                    {
                        //Console.WriteLine(e.ToString());
                    }
                    return rcode;
                }
		public static int SetMasterPassword(
			uint ssFlags,
                        string mPasswd)
		{
                    int rcode = -1;			
                    try
                    {
                        SSCS_PASSWORD_T passwd = new SSCS_PASSWORD_T();

                        passwd.pwordType = 1;
                        passwd.pword = mPasswd;
                        passwd.pwordLen = (uint)mPasswd.Length;

 
                        rcode = miCASASetMasterPassword(ssFlags, 
                                                        passwd, 
                                                        null,
                                                        new SSCS_EXT_T());
                    }
                    catch(Exception e)
                    {
                        //Console.WriteLine(e.ToString());
                    }
                    return rcode;
                }

                public static bool IsSecretPersistent(uint ssFlags, string id)
                {
                    int rcode;
                    SSCS_SECRET_ID_T secretID = new SSCS_SECRET_ID_T();
                    if(ssFlags == 0)
                    {
                        secretID.len = id.Length;
                        secretID.id = id;
                        rcode = miCASAIsSecretPersistent(ssFlags,
                                                         secretID,
                                                         new SSCS_EXT_T());
                    }
                    else
                    {
                        rcode = miCASAIsSecretPersistent(ssFlags,
                                                         null,
                                                         new SSCS_EXT_T());
                    }
                    if(rcode == 1)
                        return true;
                    else
                        return false;
                }

			
		private static string GetStringFromUTF8(byte[] utf8Bytes, int numBytes)
		{
			if (numBytes > 0)
			{
				Decoder utfDec = System.Text.Encoding.UTF8.GetDecoder();
				int charCount = utfDec.GetCharCount(utf8Bytes, 0, numBytes);
				char[] chars = new char[charCount];
				int len = utfDec.GetChars(utf8Bytes, 0, numBytes, chars, 0);

				string text = new string(chars);
				text = text.Trim();
				return text;
			}
			else
				return "";
		}

		private static uint GetUTF8ByteCount(string str)
		{
			uint byteCount = (uint)System.Text.Encoding.UTF8.GetEncoder().GetByteCount(str.ToCharArray(), 0, str.Length, true);
			return byteCount;
		}

		private static byte[] GetUTF8FromString(string str, int arrayLength)
		{
			// NOTE: Must return a padded array of arrayLength
			Encoder utfEnc = System.Text.Encoding.UTF8.GetEncoder();						
			byte[] utf8Bytes = new byte[arrayLength];
			int len = utfEnc.GetBytes(str.ToCharArray(), 0, str.Length, utf8Bytes, 0, true);
			return utf8Bytes;
		}
		internal int RemoveKey(
			string sKeyChainID, 
                        string secretID,
                        string keyID)
		{			

			int rcode = 0;
			
			if (keyID.Length > 0) 
			{
     		            try 
			    {																
		 	    object o = MiCasaRequestReply.Send(
                                    MiCasaRequestReply.VERB_REMOVE_KEY,
 				    sKeyChainID, secretID, keyID, null);
 			    }
  			    catch (Exception e)
                            {
			        rcode = -803;
    			    }
			}
                        return rcode;
                }

                internal ArrayList GetKeyList(
                               string sKeyChainID,
                               string secretID)
                {
                    ArrayList keyList = null;
                    try
                    {
 	                keyList = (ArrayList) MiCasaRequestReply.Send(
                                    MiCasaRequestReply.VERB_GET_KEY_LIST,
 				    sKeyChainID, secretID,null,null);
                        return keyList;
#if false

                        if( null != keyList )
                        {
                            IEnumerator etor = keyList.GetEnumerator();
                            while( etor.MoveNext() )
                            {
                                Console.WriteLine("Key = " + etor.Current);
                            }
                        }
#endif

                    }
                    catch(Exception e)
                    {
                        Console.WriteLine(e.ToString());
                        keyList = null;
                    }
                    return keyList;
                }                


		internal string ReadKey(
			string sKeyChainID, 
                        string secretID,
                        string keyID)
		{			

			int rcode = 0;
                        string value = null;			

			if (keyID.Length > 0) 
			{
     		            try 
			    {																
		 	    value = (String)MiCasaRequestReply.Send(
                                    MiCasaRequestReply.VERB_REMOVE_KEY,
 				    sKeyChainID, secretID, keyID, null);
 			    }
  			    catch (Exception e)
                            {
//			        rcode = -803;
                                Console.WriteLine(e.ToString());
    			    }
			}
                        return value;
                }
	}
}