#if defined(__cplusplus) || defined(c_plusplus)
extern "C"
{
#endif
#include <stdio.h>

#ifdef SSCS_WIN32_PLAT_F
#include <windows.h>
#include <sscs_ipc.h>
#endif

#include "sscs_cache.h"

/* Starts a session with the cache and returns a handle to the cache.
 * Parametrs:
 * 		secretStoreID
 *			(IN) Points to SecretStoreID structure.
 *
 * Return Values:
 *		returns a pointer to SecretStoreHandle structure.
 */
void* sscs_CacheOpenSecretStore
(
	void 		*secretStoreID,
        uint32_t        ssFlags,
	void		*reserved

)
{
    SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
    SSCS_LINUX_SS_HANDLE_T *platHandle = NULL;
    int32_t retVal = 0;

    ssHandle = (SSCS_SECRETSTORE_HANDLE_T *)malloc(sizeof(SSCS_SECRETSTORE_HANDLE_T));
    if(NULL == ssHandle)
    {
        return NULL;
    }

    platHandle = (SSCS_LINUX_SS_HANDLE_T *)malloc(sizeof(SSCS_LINUX_SS_HANDLE_T));
    if(NULL == platHandle)
    {
        free(ssHandle);
	return NULL;
    }
    memset(ssHandle,0,sizeof(SSCS_SECRETSTORE_HANDLE_T));
    memset(platHandle,0,sizeof(SSCS_LINUX_SS_HANDLE_T));

    ssHandle->platHandle = platHandle;
	
    retVal = ipc_OpenSecretStore(secretStoreID,ssHandle);
    if(retVal)
    {
        free(platHandle);
        free(ssHandle);
        return NULL;
    }

    return ssHandle;
}

/* Closes the secretstore and destroys the SecretStore context for that 
 * application.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 * 
 * Return Values
 *
 */
int32_t sscs_CacheCloseSecretStore
(
	void 		*ssHandle,
	uint32_t	ssFlags,
	void		*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    if(ssHandleCopy->platHandle)
    {
        retVal = ipc_CloseSecretStore(ssHandleCopy, ssFlags);
        free(ssHandleCopy->platHandle);
    }
	
    if(ssHandleCopy)
        free(ssHandleCopy);

    return retVal;
}

/* Removes all application defined keychains from the store. It also removes 
 * secrets stored in system defined keychains.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *
 * Return Values:
 */
int32_t sscs_CacheRemoveSecretStore
(
	void 			*ssHandle,
        uint32_t	        ssFlags,
	void			*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_RemoveSecretStore(ssHandleCopy);

    return retVal;
}

/* Enumerates key chain ids available in the store.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *
 *		kcIDList
 *			(OUT) Points to the key chain id enumeration structure. Points to 
 *			KeyChainIDList structure.
 *
 *		bytesRequired
 *			(OUT) Specifies the buffer requirement if it is not possible 
 * 			to copy KeyChain IDs in the buffer passed by the application.
 *
 * Return Values:
 *
 */
int32_t sscs_CacheEnumerateKeychainIDs
(
	void 			*ssHandle,
        uint32_t                ssFlags,
        SSCS_SRCH_KEY_T         *searchKey,
	SSCS_KEYCHAIN_ID_LIST_T *kcIDList,
	void			*reserved
)
{
	int32_t retVal = 0;
	SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

	retVal = ipc_EnumerateKeychainIDs(ssHandleCopy,kcIDList);
	
	return retVal;
}

/* Creates a new keychain in the store.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		ssFlags
 *			(IN) Can be a combination of follwing flags:
 *  			SSCS_HIDDEN_LOCAL_KEY_CHAIN_F	
 *				SSCS_SESSION_KEY_CHAIN_F		
 *				SSCS_LOCAL_KEY_CHAIN_F			
 *				SSCS_REMOTE_KEY_CHAIN_F			
 *				SSCS_LOCAL_REMOTE_CHAIN_F		
 *				SSCS_RESERVED1_KEY_CHAIN_F		
 *				SSCS_RESERVED2_KEY_CHAIN_F	
 *		keychainID
 *			(IN) Specifies the unique keychain ID within the secretstore.
 *
 */
int32_t sscs_CacheAddKeychain 
(
	void 					*ssHandle,
	uint32_t				ssFlags,
	SSCS_KEYCHAIN_ID_T			*keychainID,
	void					*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_AddKeychain(ssHandleCopy,ssFlags,keychainID);
	
    return retVal;
}


/* Removes the specified keychain from the store.
 *
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		keychainID
 *			(IN) Specifies the unique keychain ID within the secretstore.
 *
 * Return Values:
 */
int32_t sscs_CacheRemoveKeychain 
(
	void 					*ssHandle,
        uint32_t	   		        ssFlags,
	SSCS_KEYCHAIN_ID_T   			*keyChainID,
	void					*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;
	
    retVal = ipc_RemoveKeychain(ssHandleCopy,keyChainID);
	
    return retVal;
}

/* Enumerates secret ids in a given keychain.
 *
 * Parameters:
 * 		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		keyChainID
 *			(IN) handle obtained during sscs_CacheOpenKeychain.
 *
 *
 *		secretIDList
 *			(OUT) Points to the secret id enumeration structure. Points to 
 *			SecretIDList structure.
 *
 *		bytesRequired
 *			(OUT) Specifies the buffer requirement if it is not possible 
 * 			to copy Secret IDs in the buffer passed by the application.
 * Return Values:
 */
int32_t sscs_CacheEnumerateSecretIDs
(
	void 			*ssHandle,
        uint32_t	           ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
        SSCS_SRCH_KEY_T         *searchKey,
	SSCS_SECRET_ID_LIST_T	*secretIDList,
	void			*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_EnumerateSecretIDs(ssHandleCopy,keyChainID,secretIDList);
	
    return retVal;
}


/* Reads Secret value for a given Secret ID in a given keychain.
 *
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *		secretID
 *			(IN) Specifies the unique secret ID within the keychain. This data is 
 *			encoded in SSCS_SECRET_ID_T.
 *
 *		secretData
 *			(IN/OUT) Specifies the information of the secret stored w.r.t the secretID. 
 *			Points to a SSCS_SECRET_T structure.
 *
 *		epPassword
 *			(IN) Points to an optional field to pass in the Enhanced Protection Password 
 *			for reading a secret.When the password is not present, you can pass in a NULL.
 *
 *		bytesRequired
 *			(OUT) Specifies the buffer requirement if it is not possible 
 * 			to copy Secret data in the buffer passed by the application.

 *
 * Return Values :
 */
int32_t sscs_CacheReadSecret 
(
	void 				*ssHandle,
    uint32_t		     ssFlags,
	SSCS_KEYCHAIN_ID_T	*keychainID,
	SSCS_SECRET_ID_T    *secretID,
	SSCS_SECRET_T		*secretData,
	SSCS_PASSWORD_T		*epPassword,
	uint32_t			*bytesRequired,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_ReadSecret(ssHandleCopy,keychainID,secretID,secretData,epPassword,bytesRequired);
	
    return retVal;
}


/* Writes Secret value for a given Secret ID in a given keychain.
 * 
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		ssFlags
 *			(IN) ...
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *		secretID
 *			(IN) Specifies the unique secret ID within the keychain. 			This data is 
 *			encoded in SSCS_SECRET_ID_T.
 *
 *		secretData
 *			(IN) Specifies the information of the secret stored w.r.t the secretID. 
 *			Points to a SSCS_SECRET_T structure.
 *
 *
 *		epPassword
 *			(IN) Points to an optional field to pass in the Enhanced Protection Password 
 *			for reading a secret.When the password is not present, you can pass in a NULL.
 *
 *
 *
 * Return Values:
 */
int sscs_CacheWriteSecret 
(
	void 			*ssHandle,
	uint32_t		ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_SECRET_ID_T	*secretID,
	SSCS_SECRET_T		*secretData,
	SSCS_PASSWORD_T		*epPassword,
	void			*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_WriteSecret(ssHandleCopy,ssFlags,keyChainID,secretID,secretData,epPassword, reserved);

    return retVal;
}


/* Removes Secret for a given Secret ID in a given keychain.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *		secretID
 *			(IN) Specifies the unique secret ID within the keychain. 			This data is 
 *			encoded in SSCS_SECRET_ID_T.
 *
 *
 *		epPassword
 *			(IN) Points to an optional field to pass in the Enhanced Protection Password 
 *			for reading a secret.When the password is not present, you can pass in a NULL.
 *
 * Return Values:
 */
int32_t sscs_CacheRemoveSecret 
(
	void 			*ssHandle,
        uint32_t	           ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_SECRET_ID_T	*secredID,
	SSCS_PASSWORD_T 	*epPassword,
        void                    *reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;
	
    retVal = ipc_RemoveSecret(ssHandleCopy,keyChainID,secredID,epPassword);
	
    return retVal;
}

/* Returns statistical information regarding the SecretStore and its  Keychains.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context with respect to the instance of open cache in it. 
 *
 *
 *		ssInfo
 *			(OUT) This structure contains the statistical information regarding the 
 *			SecretStore and its  Keychains. 
 *
 * Return Values:
 */
int32_t sscs_CacheGetSecretStoreInfo 
(
	void 					*ssHandle,
        uint32_t           ssFlags,
	SSCS_SECRETSTORE_INFO_T *ssInfo, 
	void					*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_GetSecretStoreInfo(ssHandleCopy,ssInfo);

    return retVal;
}

/* Retrieves the statistical information regarding the target Keychain.
 *
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context with respect to the instance of open cache in it. 
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *
 *		kcInfo
 *			(OUT) This structure contains the statistical information regarding the  
 *			Keychain. 
 *
 *
 * Return Values:
 */
int32_t sscs_CacheGetKeychainInfo 
(
	void 			*ssHandle,
        uint32_t           ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_KEYCHAIN_INFO_T   	*kcInfo,    
	void			*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_GetKeychainInfo(ssHandleCopy,keyChainID,kcInfo);

    return retVal;
}

/* This call locks that cache to prevent access until the MasterPassword is 
 * supplied.
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context with respect to the instance of open cache in it. 
 *
 * Return Values :
 */
int32_t sscs_LockCache 
(
	void 					*ssHandle,
        uint32_t           ssFlags,
	void					*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_LockCache(ssHandleCopy);

    return retVal;
}

/* This unlocks previously locked cache using the MasterPassword  
 *
 * Parameters:
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context with respect to the instance of open cache in it. 
 *      masterPassword
 *
 * Return Values :
 */
int32_t sscs_UnlockCache 
(
	void 				*ssHandle,
        uint32_t           ssFlags,
	SSCS_PASSCODE_T		*passcode,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_UnlockCache(ssHandle,passcode);

    return retVal;
}

int32_t sscs_SetMasterPasscode
(
    void *ssHandle,
    SSCS_PASSCODE_T *passcode,
    void *reserved
)
{
    int32_t retVal = 0;
    retVal = ipc_SetMasterPasscode(ssHandle,passcode);
    return retVal;
}

int32_t sscs_SetMasterPassword
(
    void *ssHandle,
    SSCS_PASSWORD_T *password,
    SSCS_HINT_T *hint,
    void *reserved
)
{
    int32_t retVal = 0;
    retVal = ipc_SetMasterPassword(ssHandle,password,hint);
    return retVal;
}

//#if 0
/* Writes A key-value for a given Secret ID in a given keychain.
 * 
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		ssFlags
 *			(IN) ...
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *		secretID
 *			(IN) Specifies the unique secret ID within the keychain. 			This data is 
 *			encoded in SSCS_SECRET_ID_T.
 *
 *		secretData
 *			(IN) Specifies the information of the secret stored w.r.t the secretID. 
 *			Points to a SSCS_SECRET_T structure.
 *
 *
 *		epPassword
 *			(IN) Points to an optional field to pass in the Enhanced Protection Password 
 *			for reading a secret.When the password is not present, you can pass in a NULL.
 *
 *
 *
 * Return Values:
 */
int sscs_CacheWriteKey 
(
	void 				*ssHandle,
	uint32_t			 ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_SECRET_ID_T	*secretID,
    SS_UTF8_T           *key,
    uint32_t             keyLen,
    uint8_t             *val,
    int32_t              valLen,
	SSCS_PASSWORD_T		*epPassword,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_WriteKey(ssHandleCopy,ssFlags,keyChainID,secretID,key,keyLen,val,valLen,epPassword, reserved);

    return retVal;
}



int sscs_CacheWriteBinaryKey 
(
	void 				*ssHandle,
	uint32_t			 ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_SECRET_ID_T	*secretID,
    SS_UTF8_T           *key,
    uint32_t             keyLen,
    uint8_t             *val,
    uint32_t            valLen,
	SSCS_PASSWORD_T		*epPassword,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_WriteBinaryKey(ssHandleCopy,ssFlags,keyChainID,secretID,key,keyLen,val,valLen,epPassword, reserved);

    return retVal;
}


/* Reads Secret value for a given Secret ID in a given keychain.
 *
 * Parameters: 
 *		ssHandle
 *			(IN) Handle returned by sscs_CacheOpenSecretStore function. This will have 
 *			context information regarding the SecretStore.
 *
 *		keyChainID
 *			(IN) KeyChainID where the specified SecretID stored.
 *
 *		secretID
 *			(IN) Specifies the unique secret ID within the keychain. This data is 
 *			encoded in SSCS_SECRET_ID_T.
 *
 *		secretData
 *			(IN/OUT) Specifies the information of the secret stored w.r.t the secretID. 
 *			Points to a SSCS_SECRET_T structure.
 *
 *		epPassword
 *			(IN) Points to an optional field to pass in the Enhanced Protection Password 
 *			for reading a secret.When the password is not present, you can pass in a NULL.
 *
 *		bytesRequired
 *			(OUT) Specifies the buffer requirement if it is not possible 
 * 			to copy Secret data in the buffer passed by the application.

 *
 * Return Values :
 */
int32_t sscs_CacheReadKey 
(
	void 				*ssHandle,
    uint32_t	         ssFlags,
	SSCS_KEYCHAIN_ID_T	*keychainID,
	SSCS_SECRET_ID_T    *secretID,
    SS_UTF8_T           *key,
    uint32_t             keyLen,
    uint8_t             *val,
    uint32_t            *valLen,
	SSCS_PASSWORD_T		*epPassword,
	uint32_t			*bytesRequired,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_ReadKey(ssHandleCopy,keychainID,secretID,key,keyLen,val,valLen,epPassword,bytesRequired);

    return retVal;
}

int32_t sscs_CacheReadBinaryKey 
(
	void 				*ssHandle,
    uint32_t	         ssFlags,
	SSCS_KEYCHAIN_ID_T	*keychainID,
	SSCS_SECRET_ID_T    *secretID,
    SS_UTF8_T           *key,
    uint32_t             keyLen,
    uint8_t             *val,
    uint32_t            *valLen,
	SSCS_PASSWORD_T		*epPassword,
	uint32_t			*bytesRequired,
	void				*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_ReadBinaryKey(ssHandleCopy,keychainID,secretID,key,keyLen,val,valLen,epPassword,bytesRequired);

    return retVal;
}

int sscs_IsSecretPersistent 
(
	void 			*ssHandle,
	uint32_t		ssFlags,
	SSCS_KEYCHAIN_ID_T	*keyChainID,
	SSCS_SECRET_ID_T	*secretID,
	void			*reserved
)
{
    int32_t retVal = 0;
    SSCS_SECRETSTORE_HANDLE_T *ssHandleCopy = (SSCS_SECRETSTORE_HANDLE_T *)ssHandle;

    retVal = ipc_IsSecretPersistent(ssHandleCopy,ssFlags,keyChainID,secretID,reserved);

    return retVal;
}

//#endif

#if defined(__cplusplus) || defined(c_plusplus)
}
#endif