geos_one/CASA
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

major source structure and module name changes

Browse Source
This commit is contained in:
soochoi
2006-06-07 16:34:19 +00:00
parent 5c75241b4b
commit 1fa6f07e83
651 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

783
test/unx_testcases/cache_keychain_fns.c Normal file
View File

@@ -0,0 +1,783 @@
/***********************************************************************
*
* 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.
*
***********************************************************************/
/* This file contains all the keychain related test cases. */
#include "testcases.h"
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;
unsigned int bytesRequired = 0;
int i = 0;
int retVal = 0;
if(type == 0) //keychains
{
kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
assert(kcIDList.keyChainIDList);
//kcIDList.bufferSizeRequired = sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS;
kcIDList.returnedIDs = MAX_RETURNED_IDS;
retVal = sscs_CacheEnumerateKeychainIDs(ssHandle, ssFlags,NULL, &kcIDList,NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
}
printf("KEYCHAINLIST : \n");
for( i = 0 ; i < kcIDList.returnedIDs; i++ )
{
printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
}
free(kcIDList.keyChainIDList);
}
else //secrets
{
secretIDList.secIDList = (SSCS_SECRET_ID_T*)malloc(
sizeof(SSCS_SECRET_ID_T)* MAX_RETURNED_IDS);
assert(secretIDList.secIDList);
// secretIDList.bufferSizeRequired = sizeof(SSCS_SECRET_ID_T)* MAX_RETURNED_IDS;
secretIDList.returnedIDs = MAX_RETURNED_IDS;
retVal = sscs_CacheEnumerateSecretIDs(ssHandle, ssFlags, keychainID, NULL, &secretIDList, NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateSecretIDs failed: %d\n",retVal);
}
printf("SECRETIDLIST:\n");
for( i = 0 ; i < secretIDList.returnedIDs; i++ )
{
printf("%s\n",secretIDList.secIDList[i].id);
}
free(secretIDList.secIDList);
}
}
void TestCacheAddKeyChain_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain") +1 ;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID,ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding keychain - %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheAddKeyChain_LongKeychainId(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),LONG_WSTRING);
keychainID.len = strlen(LONG_WSTRING) + 1;
/* sscs_CacheOpenSecretStore */
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
else
{
PRINT_ERR;
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheAddKeyChain_ExistingKeychain(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
unsigned int bytesRequired = 0;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain") + 1;
/* sscs_CacheOpenSecretStore */
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding keychain %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
printf("Re-adding keychain %S\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags,NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
#define NSSCS_MAX_KEYCHAINS 10
void TestCacheAddKeyChain_MaxKeychains(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
int i = 0;
uint32_t ssFlags = 0;
// wchar_t *keychainID = L"MyKeychain";
char keychainID[256] = "";
char ch = 'a';
SSCS_KEYCHAIN_ID_T keychainIDStruct;
memset(&keychainIDStruct,0,sizeof(SSCS_KEYCHAIN_ID_T));
/* sscs_CacheOpenSecretStore */
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
for( i = 0 ; i < NSSCS_MAX_KEYCHAINS + 1 ; i++ )
{
sprintf(keychainID,"key%c",ch+i);
printf("Adding %s\n",keychainIDStruct.keychainID);
strcpy((char*)(keychainIDStruct.keychainID),keychainID);
keychainIDStruct.len = strlen(keychainID)+1;
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainIDStruct,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
}
memset(keychainID,0,sizeof(keychainID));
for( i = 0 ; i < NSSCS_MAX_KEYCHAINS + 1 ; i++ )
{
sprintf(keychainID,"key%c",ch+i);
printf("Removing %s\n",keychainIDStruct.keychainID);
strcpy((char*)(keychainIDStruct.keychainID),keychainID);
keychainIDStruct.len = strlen(keychainID)+1;
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &keychainIDStruct,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheEnumerateKeyChainIds_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
int i = 0;
uint32_t ssFlags = 0;
/* sscs_CacheOpenSecretStore */
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
assert(kcIDList.keyChainIDList);
// kcIDList.bufferSizeRequired = sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS;
kcIDList.returnedIDs = MAX_RETURNED_IDS;
retVal = sscs_CacheEnumerateKeychainIDs(ssHandle,ssFlags, NULL,&kcIDList,
NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
}
printf("KEYCHAINLIST\n");
for( i = 0 ; i < kcIDList.returnedIDs; i++ )
{
printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
}
free(kcIDList.keyChainIDList);
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheEnumerateKeyChainIds_WithoutOpen(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T cookedUpSSHandle;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int socketFd = FAKE_SOCK_FD;
int retVal = 0;
int i = 0;
uint32_t ssFlags = 0;
DECORATE
/* Passing a cookedup SSHandle */
printf("INPUT: Cookedup SSHandle\n");
cookedUpSSHandle.platformID = 1;
cookedUpSSHandle.platHandle = (int*)&socketFd;
kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
assert(kcIDList.keyChainIDList);
// kcIDList.bufferSizeRequired = sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS;
kcIDList.returnedIDs = MAX_RETURNED_IDS;
retVal = sscs_CacheEnumerateKeychainIDs(&cookedUpSSHandle,ssFlags, NULL, &kcIDList,NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
}
printf("KEYCHAINLIST\n");
for( i = 0 ; i < kcIDList.returnedIDs; i++ )
{
printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
}
free(kcIDList.keyChainIDList);
DECORATE
}
void TestCacheEnumerateKeyChainIds_LessBufferLen(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
uint32_t ssFlags = 0;
int retVal = 0;
int i = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain1");
keychainID.len = strlen("MyKeychain1")+1;
/* sscs_CacheOpenSecretStore */
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
printf("Adding keychain..%s\n",keychainID.keychainID);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
strcpy((char*)(keychainID.keychainID),"MyKeychain2");
keychainID.len = strlen("MyKeychain2")+1;
printf("Adding keychain..%s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
assert(kcIDList.keyChainIDList);
// kcIDList.bufferSizeRequired = sizeof(SSCS_KEYCHAIN_ID_T) * 1;
kcIDList.returnedIDs = 1;
retVal = sscs_CacheEnumerateKeychainIDs(ssHandle, ssFlags, NULL, &kcIDList,
NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
}
printf("KEYCHAINLIST\n");
for( i = 0 ; i < kcIDList.returnedIDs; i++ )
{
printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
}
free(kcIDList.keyChainIDList);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &keychainID, NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
strcpy((char*)(keychainID.keychainID),"MyKeychain1");
keychainID.len = strlen("MyKeychain1")+1;
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &keychainID, NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheEnumerateKeyChainIds_WithNoKeychains(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
int i = 0;
/* sscs_CacheOpenSecretStore */
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
kcIDList.keyChainIDList = (SSCS_KEYCHAIN_ID_T *)malloc(
sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS );
assert(kcIDList.keyChainIDList);
// kcIDList.bufferSizeRequired = sizeof(SSCS_KEYCHAIN_ID_T) * MAX_RETURNED_IDS;
kcIDList.returnedIDs = MAX_RETURNED_IDS;
retVal = sscs_CacheEnumerateKeychainIDs(ssHandle, ssFlags,NULL, &kcIDList,NULL);
if(retVal != 0)
{
printf("sscs_CacheEnumerateKeychainIDs failed: %d\n",retVal);
}
else
{
printf("KEYCHAINLIST\n");
for( i = 0 ; i < kcIDList.returnedIDs; i++ )
{
printf("%s\n",kcIDList.keyChainIDList[i].keychainID);
}
}
free(kcIDList.keyChainIDList);
kcIDList.keyChainIDList = NULL;
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheRemoveKeyChain_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
/* sscs_CacheOpenSecretStore */
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s \n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
printf("Removing %s\n",keychainID.keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,&keychainID);
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheRemoveKeyChain_NonExistentKeychain(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"Non-existent");
keychainID.len = strlen("Non-existent")+1;
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
printf("Removing %s\n",keychainID.keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,&keychainID);
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags,NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}
void TestCacheRemoveKeyChain_OverlappingNames(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
int retVal = 0;
uint32_t ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"Keychain1");
keychainID.len = strlen("Keychain1")+1;
/* sscs_CacheOpenSecretStore */
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s \n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
strcpy(keychainID.keychainID,"Keychain1");
keychainID.len = strlen("Keychain1")+1;
printf("Adding %s \n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
strcpy(keychainID.keychainID,"Keychain");
keychainID.len = strlen("Keychain")+1;
printf("Removing %s\n",keychainID.keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags, &keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,&keychainID);
strcpy(keychainID.keychainID,"Keychain1");
keychainID.len = strlen("Keychain1")+1;
printf("Removing %s\n",keychainID.keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,&keychainID);
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE
}

620
test/unx_testcases/cache_secret_fns.c Normal file
View File

@@ -0,0 +1,620 @@
/***********************************************************************
*
* 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.
*
***********************************************************************/
/* This file contains all the keychain related test cases. */
#include "testcases.h"
#include <assert.h>
extern void EnumerateIDs(SSCS_SECRETSTORE_HANDLE_T *ssHandle,int type,
SSCS_KEYCHAIN_ID_T *keychainID);
void TestCacheRWRmSecret_ValidAddSecret(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
SSCS_SECRET_T secret;
SSCS_PASSWORD_T epPassword = {0,0,""};
unsigned int bytesRequired = 0;
unsigned long ssFlags = 0;
int retVal = 0;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
SSCS_SECRET_ID_T secretID;
memset(&secretID,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID.id),"secret1");
secretID.len = strlen("secret1")+1;
int i = 0;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
memset(&secret,0,sizeof(secret));
secret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
assert(secret.data);
memset(secret.data,0,MAX_SECRET_VAL_LEN);
secret.len = 6;
memcpy(secret.data,"value1",secret.len);
printf("Adding secret %S with value %s\n",secretID.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
printf("Verifying the written secret's value...\n");
secret.len = MAX_SECRET_VAL_LEN;
memset(secret.data,0,MAX_SECRET_VAL_LEN);
retVal = sscs_CacheReadSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret, &epPassword,&bytesRequired, NULL);
if(retVal != 0)
{
printf("sscs_CacheReadSecret failed: %d\n",retVal);
}
printf("secret len is %d\n",secret.len);
printf("Value is ");
for(i = 0;i < secret.len; i++ )
{
printf("%c",secret.data[i]);
}
printf("\n");
free(secret.data);
secret.data = NULL;
printf("Removing %S\n",secretID.id);
retVal = sscs_CacheRemoveSecret(ssHandle,ssFlags,&keychainID,&secretID,
&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveSecret failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,1,&keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
// EnumerateIDs(ssHandle,1,&keychainID);
free(secret.data);
secret.data = NULL;
DECORATE
}
void TestCacheRWRmSecret_LongSecretID(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
SSCS_SECRET_T secret;
SSCS_PASSWORD_T epPassword = {0,0,""};
unsigned int bytesRequired = 0;
int retVal = 0;
unsigned long ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
SSCS_SECRET_ID_T secretID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
memset(&secretID,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID.id),"secret1");
secretID.len = strlen("secret1")+1;
int i = 0;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
memset(&secret,0,sizeof(secret));
secret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
assert(secret.data);
memset(secret.data,0,MAX_SECRET_VAL_LEN);
secret.len = 6;
memcpy(secret.data,"value1",secret.len);
printf("Adding secret %s with value %s\n",secretID.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
printf("Removing %s\n",secretID.id);
retVal = sscs_CacheRemoveSecret(ssHandle,ssFlags,&keychainID,&secretID,
&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveSecret failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,1,&keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
// EnumerateIDs(ssHandle,1,&keychainID);
free(secret.data);
secret.data = NULL;
DECORATE
}
void TestCacheRWSecret_ValidUpdateSecret(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
SSCS_SECRET_T secret;
SSCS_PASSWORD_T epPassword = {0,0,""};
unsigned int bytesRequired = 0;
int retVal = 0;
unsigned long ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
SSCS_SECRET_ID_T secretID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
memset(&secretID,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID.id),"secret1");
secretID.len = strlen("secret1")+1;
int i = 0;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags,NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
memset(&secret,0,sizeof(secret));
secret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
assert(secret.data);
memset(secret.data,0,MAX_SECRET_VAL_LEN);
secret.len = 6;
memcpy(secret.data,"value1",secret.len);
printf("Adding secret %s with value %s\n",secretID.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
secret.len = 9;
memcpy(secret.data,"newvalue1",secret.len);
printf("Updating secret %s with value %s\n",secretID.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
printf("Verifying the written secret's value...\n");
secret.len = MAX_SECRET_VAL_LEN;
memset(secret.data,0,MAX_SECRET_VAL_LEN);
retVal = sscs_CacheReadSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,&bytesRequired,NULL);
if(retVal != 0)
{
printf("sscs_CacheReadSecret failed: %d\n",retVal);
}
printf("secret len is %d\n",secret.len);
printf("Value is ");
for(i = 0;i < secret.len; i++ )
{
printf("%c",secret.data[i]);
}
printf("\n");
free(secret.data);
secret.data = NULL;
printf("Removing a keychain with secret..\n");
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
// EnumerateIDs(ssHandle,1,&keychainID);
free(secret.data);
secret.data = NULL;
DECORATE
}
void TestCacheRWRmSecret_NonExistentKeychain(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
SSCS_SECRET_T secret;
SSCS_PASSWORD_T epPassword = {0,0,""};
unsigned int bytesRequired = 0;
int retVal = 0;
unsigned long ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
SSCS_SECRET_ID_T secretID;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
memset(&secretID,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID.id),"secret1");
secretID.len = strlen("secret1")+1;
int i = 0;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
#if 0
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %S\n",keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
#endif
memset(&secret,0,sizeof(secret));
secret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
assert(secret.data);
memset(secret.data,0,MAX_SECRET_VAL_LEN);
secret.len = 6;
memcpy(secret.data,"value1",secret.len);
printf("Adding secret %s with value %s\n",secretID.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
printf("Verifying the written secret's value...\n");
secret.len = MAX_SECRET_VAL_LEN;
memset(secret.data,0,MAX_SECRET_VAL_LEN);
retVal = sscs_CacheReadSecret(ssHandle,ssFlags,&keychainID,&secretID,
&secret, &epPassword,&bytesRequired,NULL);
if(retVal != 0)
{
printf("sscs_CacheReadSecret failed: %d\n",retVal);
}
else
{
printf("secret len is %d\n",secret.len);
printf("Value is ");
for(i = 0;i < secret.len; i++ )
{
printf("%c",secret.data[i]);
}
printf("\n");
}
free(secret.data);
secret.data = NULL;
retVal = sscs_CacheRemoveSecret(ssHandle,ssFlags,&keychainID,&secretID,
&epPassword, NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveSecret failed: %d\n",retVal);
}
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
// EnumerateIDs(ssHandle,1,&keychainID);
free(secret.data);
secret.data = NULL;
DECORATE
}
void TestCacheRWRmSecret_OverlappingNames(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_ID_LIST_T kcIDList;
SSCS_SECRET_T secret;
SSCS_PASSWORD_T epPassword = {0,0,""};
unsigned int bytesRequired = 0;
int retVal = 0;
unsigned int ssFlags = 0;
SSCS_KEYCHAIN_ID_T keychainID;
SSCS_SECRET_ID_T secretID1;
SSCS_SECRET_ID_T secretID2;
memset(&keychainID,0,sizeof(SSCS_KEYCHAIN_ID_T));
strcpy((char*)(keychainID.keychainID),"MyKeychain");
keychainID.len = strlen("MyKeychain")+1;
memset(&secretID1,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID1.id),"secret1");
secretID1.len = strlen("secret1")+1;
memset(&secretID2,0,sizeof(SSCS_SECRET_ID_T));
strcpy((char*)(secretID2.id),"secret2");
secretID2.len = strlen("secret2")+1;
int i = 0;
DECORATE
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %s\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,0,NULL);
memset(&secret,0,sizeof(secret));
secret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
assert(secret.data);
memset(secret.data,0,MAX_SECRET_VAL_LEN);
secret.len = 6;
memcpy(secret.data,"value1",secret.len);
printf("Adding secret %S with value %s\n",secretID1.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID1,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
memcpy(secret.data,"value2",secret.len);
printf("Adding secret %s with value %s\n",secretID2.id,secret.data);
retVal = sscs_CacheWriteSecret(ssHandle,ssFlags,&keychainID,&secretID2,
&secret,&epPassword,NULL);
if(retVal != 0)
{
printf("sscs_CacheWriteSecret failed: %d\n",retVal);
}
printf("Verifying the written secrets' value...\n");
EnumerateIDs(ssHandle,1,&keychainID);
secret.len = MAX_SECRET_VAL_LEN;
memset(secret.data,0,MAX_SECRET_VAL_LEN);
retVal = sscs_CacheReadSecret(ssHandle,ssFlags,&keychainID,&secretID1,
&secret,&epPassword,&bytesRequired,NULL);
if(retVal != 0)
{
printf("sscs_CacheReadSecret failed: %d\n",retVal);
}
else
{
printf("secret len is %d\n",secret.len);
printf("Value is ");
for(i = 0;i < secret.len; i++ )
{
printf("%c",secret.data[i]);
}
printf("\n");
}
secret.len = MAX_SECRET_VAL_LEN;
memset(secret.data,0,MAX_SECRET_VAL_LEN);
retVal = sscs_CacheReadSecret(ssHandle,ssFlags, &keychainID,&secretID2,
&secret,&epPassword,&bytesRequired,NULL);
if(retVal != 0)
{
printf("sscs_CacheReadSecret failed: %d\n",retVal);
}
else
{
printf("secret len is %d\n",secret.len);
printf("Value is ");
for(i = 0;i < secret.len; i++ )
{
printf("%c",secret.data[i]);
}
printf("\n");
}
free(secret.data);
secret.data = NULL;
printf("Removing %s\n",secretID1.id);
retVal = sscs_CacheRemoveSecret(ssHandle,ssFlags,&keychainID,&secretID1,
&epPassword, NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveSecret failed: %d\n",retVal);
}
EnumerateIDs(ssHandle,1,&keychainID);
retVal = sscs_CacheRemoveKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheRemoveKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
// EnumerateIDs(ssHandle,1,&keychainID);
free(secret.data);
secret.data = NULL;
DECORATE
}

412
test/unx_testcases/cache_ss_fns.c Normal file
View File

@@ -0,0 +1,412 @@
/***********************************************************************
*
* 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.
*
***********************************************************************/
/* This file contains all the test cases for all the generic
* Cachelib functions. */
#include "testcases.h"
/* Callback for testing CacheOpenSecretStore.
*/
void TestCacheOpenSecretStore_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
uint32_t ssFlags = 0;
int32_t retVal = 0;
/* sscs_CacheOpenSecretStore_Valid */
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID,ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
/* sscs_CacheOpenSecretStore_Valid */
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheOpenSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestCacheOpenSecretStore_Invalid_Input(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
/* sscs_CacheOpenSecretStore_Invalid */
DECORATE
printf("INPUT: {0x00000000, A}\n");
secID.version = 0x00000000;
strcpy((char *)secID.ssName,"A");
ssHandle = sscs_CacheOpenSecretStore(&secID,ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
retVal = sscs_CacheCloseSecretStore(ssHandle,ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheOpenSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestCacheCloseSecretStore_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
printf("INPUT: Valid SSHandle\n");
retVal = sscs_CacheCloseSecretStore(ssHandle,ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
else
{
printf("sscs_CacheCloseSecretStore succeeded.\n");
}
DECORATE;
}
void TestCacheCloseSecretStore_CloseAfterClose(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE
printf("INPUT: {0x00040000, SecretStore}\n");
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
printf("INPUT: Valid SSHandle\n");
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags,NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
/* Closing SecretStore after a valid close.
* Cachelib must return an appropriate error and must
* not write the request to SSCS.
*/
printf("INPUT: Valid SSHandle\n");
printf("Closing SecretStore after a valid close.\n");
retVal = sscs_CacheCloseSecretStore(ssHandle,ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
DECORATE
}
void TestCacheCloseSecretStore_Invalid_Handle(void)
{
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE
/* Passing a NULL SSHandle */
printf("INPUT: Invalid SSHandle\n");
ssHandle = NULL;
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestCacheCloseSecretStore_WithoutOpen(void)
{
SSCS_SECRETSTORE_HANDLE_T ssHandle;
int32_t retVal = 0;
int socketFd = FAKE_SOCK_FD;
uint32_t ssFlags = 0;
DECORATE
/* Passing a cookedup SSHandle */
printf("INPUT: Cookedup SSHandle\n");
ssHandle.platformID = 1;
ssHandle.platHandle = (int*)&socketFd;
retVal = sscs_CacheCloseSecretStore(&ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
}
void TestCacheGetSecretStoreInfo_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_SECRETSTORE_INFO_T ssInfo;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE;
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
retVal = sscs_CacheGetSecretStoreInfo( ssHandle, ssFlags, &ssInfo, NULL);
if(retVal != 0)
{
printf("sscs_CacheGetSecretStoreInfo failed: %d\n",retVal);
}
else
{
printf("ssInfo.numKeychains :%d\n",ssInfo.numKeyChains);
printf("ssInfo.enumBufsize :%d\n",ssInfo.enumBufsize);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestCacheGetKeychainInfo_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
SSCS_KEYCHAIN_INFO_T kcInfo;
SSCS_KEYCHAIN_ID_T keychainID;
memset(&keychainID,0,sizeof(keychainID));
strcpy(keychainID.keychainID,"MyKeychain");
keychainID.len = strlen("MyKeychain") + 1;
uint32_t ssFlags = 0;
int32_t retVal = 0;
DECORATE;
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
ssFlags |= SSCS_LOCAL_KEY_CHAIN_F;
printf("Adding %S\n",keychainID.keychainID);
retVal = sscs_CacheAddKeychain(ssHandle,ssFlags,&keychainID,NULL);
if(retVal != 0)
{
printf("sscs_CacheAddKeychain failed: %d\n",retVal);
}
retVal = sscs_CacheGetKeychainInfo(ssHandle, ssFlags, &keychainID, &kcInfo, NULL);
if(retVal != 0)
{
printf("sscs_CacheGetKeychainInfo failed: %d\n",retVal);
}
else
{
printf("kcInfo.numSecrets:%d\n",kcInfo.numSecrets);
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestLockCache_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE;
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID, ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
retVal = sscs_LockCache(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_LockCache failed: %d\n",retVal);
}
else
{
printf("LockCache Successful\n");
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE;
}
void TestUnlockCache_Valid(void)
{
SSCS_SECRETSTORE_T secID;
SSCS_SECRETSTORE_HANDLE_T *ssHandle = NULL;
int32_t retVal = 0;
uint32_t ssFlags = 0;
DECORATE;
secID.version = 0x00040000;
strcpy((char *)secID.ssName,"SecretStore");
ssHandle = sscs_CacheOpenSecretStore(&secID,ssFlags, NULL);
if(!ssHandle)
{
printf("sscs_CacheOpenSecretStore failed\n");
}
else
{
printf("sscs_CacheOpenSecretStore succeeded\n");
}
printf("Platform ID is %d; socketID is %d\n",ssHandle->platformID,
*(int*)ssHandle->platHandle);
retVal = sscs_UnlockCache(ssHandle,ssFlags, NULL, NULL);
if(retVal != 0)
{
printf("sscs_UnlockCache failed: %d\n",retVal);
}
else
{
printf("sscs_UnlockCache Successful\n");
}
retVal = sscs_CacheCloseSecretStore(ssHandle, ssFlags, NULL);
if(retVal != 0)
{
printf("sscs_CacheCloseSecretStore failed: %d\n",retVal);
}
DECORATE;
}

6
test/unx_testcases/link.lux Normal file
View File

@@ -0,0 +1,6 @@
LINK = $(CXX) \
-o $(BINDIR)$(TARGET) \
$(OBJDIR)/*.$(O) \
-L$(LIBDIR)$(XTRA) -lmicasacache \
-L/usr/lib -lpthread -lc -lnsl \
-L. -lcunit

5
test/unx_testcases/objs.lux Normal file
View File

@@ -0,0 +1,5 @@
OBJS=\
testcases.$(O)\
cache_ss_fns.$(O)\
cache_keychain_fns.$(O)\
cache_secret_fns.$(O)

17
test/unx_testcases/target Normal file
View File

@@ -0,0 +1,17 @@
include link$(xtra).$(PLAT)
all : $(BIN_NAME)
$(BIN_NAME) : $(OBJS)
@echo Linking $@ ...
$(LINK)
@echo
#install : all

173
test/unx_testcases/testcases.c Normal file
View File

@@ -0,0 +1,173 @@
/***********************************************************************
*
* 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.
*
***********************************************************************/
#include "testcases.h"
void TestCacheOpenSecretStore_Valid(void);
void TestCacheOpenSecretStore_Invalid_Input(void);
void TestCacheCloseSecretStore_Valid(void);
void TestCacheCloseSecretStore_CloseAfterClose(void);
void TestCacheCloseSecretStore_Invalid_Handle(void);
void TestCacheCloseSecretStore_WithoutOpen(void);
void TestCacheAddKeyChain_Valid(void);
void TestCacheAddKeyChain_LongKeychainId(void);
void TestCacheAddKeyChain_ExistingKeychain(void);
void TestCacheAddKeyChain_MaxKeychains(void);
void TestCacheEnumerateKeyChainIds_Valid(void);
void TestCacheEnumerateKeyChainIds_WithoutOpen(void);
void TestCacheEnumerateKeyChainIds_LessBufferLen(void);
void TestCacheEnumerateKeyChainIds_WithNoKeychains(void);
void TestCacheRemoveKeyChain_Valid(void);
void TestCacheRemoveKeyChain_NonExistentKeychain(void);
void TestCacheRemoveKeyChain_OverlappingNames(void);
void TestCacheRWRmSecret_ValidAddSecret(void);
void TestCacheRWRmSecret_LongSecretID(void);
void TestCacheRWSecret_ValidUpdateSecret(void);
void TestCacheRWRmSecret_NonExistentKeychain(void);
void TestCacheRWRmSecret_OverlappingNames(void);
void TestCacheGetSecretStoreInfo_Valid(void);
void TestCacheGetKeychainInfo_Valid(void);
void TestLockCache_Valid(void);
void TestUnlockCache_Valid(void);
/*
*/
int main(int argc, char** argv)
{
CU_pSuite pGenericSSGroup = NULL;
CU_pSuite pKeyChainGroup = NULL;
CU_pSuite pSecretGroup = NULL;
CU_pTest pTest = NULL;
if (CU_initialize_registry())
return 1;
pGenericSSGroup = CU_add_suite("TestCacheOpenSecretStore",NULL,NULL);
if (!pGenericSSGroup)
{
CU_cleanup_registry();
return -1;
}
pTest = CU_add_test(pGenericSSGroup, "TestCacheOpenSecretStore_Valid",TestCacheOpenSecretStore_Valid);
TEST_PTEST
pTest = CU_add_test(pGenericSSGroup, "TestCacheOpenSecretStore_Invalid_Input",TestCacheOpenSecretStore_Invalid_Input);
TEST_PTEST
pGenericSSGroup = CU_add_suite("TestCacheCloseSecretStore",NULL,NULL);
if(!pGenericSSGroup)
{
CU_cleanup_registry();
return -1;
}
pTest = CU_add_test(pGenericSSGroup, "TestCacheCloseSecretStore_Valid",TestCacheCloseSecretStore_Valid);
TEST_PTEST
// pTest = CU_add_test(pGenericSSGroup, "TestCacheCloseSecretStore_WithoutOpen",TestCacheCloseSecretStore_WithoutOpen);
TEST_PTEST
pKeyChainGroup = CU_add_suite("TestCacheEnumerateKeyChainIds",NULL,NULL);
if(!pKeyChainGroup)
{
CU_cleanup_registry();
return -1;
}
pTest = CU_add_test(pKeyChainGroup,"TestCacheAddKeyChain_Valid",TestCacheAddKeyChain_Valid);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheAddKeyChain_LongKeychainId",TestCacheAddKeyChain_LongKeychainId);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheAddKeyChain_ExistingKeychain",TestCacheAddKeyChain_ExistingKeychain);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheAddKeyChain_MaxKeychains",TestCacheAddKeyChain_MaxKeychains);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheEnumerateKeyChainIds_Valid",TestCacheEnumerateKeyChainIds_Valid);
TEST_PTEST
// pTest = CU_add_test(pKeyChainGroup, "TestCacheEnumerateKeyChainIds_WithoutOpen",TestCacheEnumerateKeyChainIds_WithoutOpen);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheEnumerateKeyChainIds_WithNoKeychains",TestCacheEnumerateKeyChainIds_WithNoKeychains);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheRemoveKeyChain_Valid",TestCacheRemoveKeyChain_Valid);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheRemoveKeyChain_NonExistentKeychain",TestCacheRemoveKeyChain_NonExistentKeychain);
TEST_PTEST
pTest = CU_add_test(pKeyChainGroup, "TestCacheRemoveKeyChain_OverlappingNames",TestCacheRemoveKeyChain_OverlappingNames);
TEST_PTEST
pSecretGroup = CU_add_suite("TestCacheSecretAPIs",NULL,NULL);
if(!pGenericSSGroup)
{
CU_cleanup_registry();
return -1;
}
pTest = CU_add_test(pSecretGroup, "TestCacheRWRmSecret_ValidAddSecret",TestCacheRWRmSecret_ValidAddSecret);
TEST_PTEST
pTest = CU_add_test(pSecretGroup, "TestCacheRWSecret_ValidUpdateSecret",TestCacheRWSecret_ValidUpdateSecret);
TEST_PTEST
pTest = CU_add_test(pSecretGroup, "TestCacheRWRmSecret_NonExistentKeychain",TestCacheRWRmSecret_NonExistentKeychain);
TEST_PTEST
pTest = CU_add_test(pSecretGroup, "TestCacheRWRmSecret_OverlappingNames",TestCacheRWRmSecret_OverlappingNames);
TEST_PTEST
pTest = CU_add_test(pSecretGroup, "TestCacheRWRmSecret_LongSecretID",TestCacheRWRmSecret_LongSecretID);
TEST_PTEST
pTest = CU_add_test(pGenericSSGroup, "TestCacheGetSecretStoreInfo_Valid",TestCacheGetSecretStoreInfo_Valid);
TEST_PTEST
pTest = CU_add_test(pGenericSSGroup, "TestCacheGetKeychainInfo_Valid",TestCacheGetKeychainInfo_Valid);
TEST_PTEST
pTest = CU_add_test(pGenericSSGroup, "TestLockCache_Valid",TestLockCache_Valid);
TEST_PTEST
pTest = CU_add_test(pGenericSSGroup, "TestUnlockCache_Valid",TestUnlockCache_Valid);
TEST_PTEST
/*DANGER - Test with latest cachelib*/
// pTest = CU_add_test(pKeyChainGroup, "TestCacheEnumerateKeyChainIds_LessBufferLen",TestCacheEnumerateKeyChainIds_LessBufferLen);
TEST_PTEST
// pTest = CU_add_test(pGenericSSGroup, "TestCacheCloseSecretStore_CloseAfterClose",TestCacheCloseSecretStore_CloseAfterClose);
TEST_PTEST
// pTest = CU_add_test(pGenericSSGroup, "TestCacheCloseSecretStore_Invalid_Handle",TestCacheCloseSecretStore_Invalid_Handle);
TEST_PTEST
/* Run the tests. */
// CU_curses_run_tests();
CU_console_run_tests();
CU_cleanup_registry();
return 0;
}

48
test/unx_testcases/testcases.h Normal file
View File

@@ -0,0 +1,48 @@
/***********************************************************************
*
* 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.
*
***********************************************************************/
#ifndef _TESTCASES_H_
#define _TESTCASES_H_
#include <CUnit/Console.h>
#include <CUnit/CUnit.h>
#include "sscs_cache.h"
#include "micasa_types.h"
#include <assert.h>
#define MAX_ID_LIST_BUF 4*1024
#define MAX_SECRET_VAL_LEN 1024
#define FAKE_SOCK_FD 10
#define TEST_LESS_BUFFER_LEN 4
#define LONG_WSTRING "LongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongStringLongString"
#define MAX_RETURNED_IDS 10
#define TEST_PTEST if(!pTest) { CU_cleanup_registry(); return -1; }
#define DECORATE printf("\n****************************************************\n");
#define PRINT_ERR printf("SUCCESS when it MUST HAVE FAILED!!!!\n");
#endif