CASA/c_test/unx_cachetst/sscs_unxcachetst.c

#include "sscs_cache.h"
#include <wchar.h>
#include <assert.h>

#define MAX_ID_LIST_BUF 4*1024
#define MAX_SECRET_VAL_LEN 1024
#define MAX_RETURNED_IDS 10

void enumerateIDs(SSCS_SECRETSTORE_HANDLE_T *ssHandle,int type,
                  SSCS_KEYCHAIN_ID_T *keychainID)
{
	SSCS_KEYCHAIN_ID_LIST_T kcIDList;
	SSCS_SECRET_ID_LIST_T secretIDList;
        uint32_t ssFlags = 0;
	int retVal,i=0;
	
	if(type == 0) //keychains
	{
		printf("Enumerate keychains\n----------------------\n");
		kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
                       sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
                assert(kcIDList.keyChainIDList);

                kcIDList.returnedIDs = MAX_RETURNED_IDS;
		retVal = sscs_CacheEnumerateKeychainIDs(ssHandle, ssFlags,NULL, &kcIDList,NULL);
		if(retVal != 0)
		{
			printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
		}

                for( i = 0 ; i < kcIDList.returnedIDs; i++ )
                {
		    printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
                }

		free(kcIDList.keyChainIDList);
	}
	else //secrets
	{
		printf("Enumerate secrets\n-----------------\n");
		secretIDList.secIDList = (SSCS_SECRET_ID_T*)malloc(
                     sizeof(SSCS_SECRET_ID_T)* MAX_RETURNED_IDS);
                assert(secretIDList.secIDList);

                secretIDList.returnedIDs = MAX_RETURNED_IDS;
		retVal = sscs_CacheEnumerateSecretIDs(ssHandle, ssFlags, keychainID, NULL, &secretIDList, NULL);
		if(retVal != 0)
		{
			printf("sscs_CacheEnumerateSecretIDs failed: %d\n",retVal);
		}

                for( i = 0 ; i < secretIDList.returnedIDs; i++ )
                {
                    printf("%s\n",secretIDList.secIDList[i].id);
                }

                free(secretIDList.secIDList);

	}
        printf("---------------------------------\n");
}


int main(int argc, char** argv)
{
        int n = 0,z=0;
	SSCS_SECRETSTORE_T secID;
	SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
	uint32_t bytesRequired;
        wchar_t *testssName;
        unsigned char testssNameUTF[1024];
        wchar_t *testkcId;
        unsigned char testkcIdUTF[1024];
        wchar_t *testsecretId;
        unsigned char testsecretIdUTF[1024];
        wchar_t **wptr = NULL;

	uint32_t ssFlags = 0;
	int retVal = 0;
	int i;
	SSCS_SECRET_T mySecret;
	SSCS_PASSWORD_T epPassword = {0,0,""};
        SSCS_SECRET_ID_T mySecretID;
        SSCS_KEYCHAIN_ID_T mykeychainID;
        SSCS_KEYCHAIN_ID_T newkeychainID;

        memset(&mykeychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
        testkcId = (wchar_t*)malloc(1024*sizeof(wchar_t));
        assert(testkcId);

//All this required when we have some real wchars :-)
        wcscpy(testkcId,L"SSCS_SESSION_KEY_CHAIN_ID");
        wptr = &testkcId;
        mykeychainID.len = wcsrtombs(testkcIdUTF,wptr,1024,NULL);
        mykeychainID.len+=1;
        memcpy(mykeychainID.keychainID,testkcIdUTF,mykeychainID.len);       

        memset(&mySecretID,0,sizeof(mySecretID));
        testsecretId = (wchar_t*)malloc(1024*sizeof(wchar_t));
        assert(testsecretId);
        wcscpy(testsecretId,L"MySecret");

        wptr = &testsecretId;
        mySecretID.len = wcsrtombs(testsecretIdUTF,wptr,1024,NULL);
        mySecretID.len +=1;
        memcpy(mySecretID.id,testsecretIdUTF,mySecretID.len);

	mySecret.len = MAX_SECRET_VAL_LEN;
	mySecret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
        assert(mySecret.data);

	secID.version = 0x00040000;
        testssName = (wchar_t*)malloc(1024*sizeof(wchar_t));
        assert(testssName);
        wcscpy(testssName,L"SecretStoreName");
        wptr = &testssName;
        n = wcsrtombs(testssNameUTF,wptr,1024,NULL);
        memcpy(secID.ssName,testssNameUTF,n);

	
        ssHandle = sscs_CacheOpenSecretStore(&secID,ssFlags, NULL);
        if(!ssHandle)
        {
                printf("sscs_CacheOpenSecretStore failed\n");
        }
        else
                printf("sscs_CacheOpenSecretStore succesful\n");
    
        ssFlags |= SSCS_SESSION_KEY_CHAIN_F;

        retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&mykeychainID,NULL);
        if(retVal != 0)
        {
                printf("sscs_CacheAddKeychain failed: %d\n",retVal);
        }
        else
                printf("sscs_CacheAddKeychain succesfully added - %s\n",mykeychainID.keychainID);

        enumerateIDs(ssHandle,0,NULL);
	//Add Secret
	mySecret.len = 4;
	memcpy(mySecret.data,"Test",4);

	retVal = sscs_CacheWriteSecret(ssHandle, ssFlags, &mykeychainID,
                 &mySecretID, &mySecret,&epPassword ,NULL); 
	if(retVal != 0)
	{
		printf("sscs_CacheWriteSecret failed: %d\n",retVal);
	}
	else
		printf("sscs_CacheWriteSecret added to ID - %s\n", mySecretID.id);

        mySecret.len = MAX_SECRET_VAL_LEN;
        memset(mySecret.data,0,MAX_SECRET_VAL_LEN);

        retVal = sscs_CacheReadSecret(ssHandle, ssFlags, &mykeychainID,&mySecretID, &mySecret, &epPassword, &bytesRequired, NULL);
        if(retVal != 0)
        {
                printf("sscs_CacheReadSecret failed: %d\n",retVal);
        }
        else
        {
                printf("sscs_CacheReadSecret- read ID - %s\n",mySecretID.id);
                printf("SecretVal is %s\n",mySecret.data);
        }
//        free(mySecret.data);


        enumerateIDs(ssHandle, 1,&mykeychainID);
        printf("Removing Secret...\n");
        retVal = sscs_CacheRemoveSecret(ssHandle,ssFlags, &mykeychainID,
                 &mySecretID,
                 &epPassword, NULL);
        if(retVal != 0)
        {
                printf("sscs_CacheRemoveSecret failed: %d\n",retVal);
        }
        else
                printf("sscs_CacheRemoveSecret removed id - %S\n",mySecretID.id)
;

        enumerateIDs(ssHandle, 1,&mykeychainID);

        //remove keychain

        printf("Removing Keychain...\n");
        retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &mykeychainID, NULL)
;
        if(retVal != 0)
        {
                printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
        }
        else
                printf("sscs_CacheRemoveKeychain removed keychain - %s\n",mykeychainID.keychainID);

	enumerateIDs(ssHandle,0,NULL);

        retVal = sscs_CacheCloseSecretStore(ssHandle,ssFlags, NULL);
        if(retVal != 0)
        {
                printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
        }
        else
                printf("sscs_CacheCloseSecretStore success: %d\n",retVal);

        free(testkcId);
        free(testsecretId);
        free(mySecret.data);
        free(testssName);

	printf("Completed testing\n");
	return 0;
}