major source structure and module name changes

test/dev_test/enumerate.c

@@ -0,0 +1,189 @@
+/***********************************************************************
+ * 
+ *  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 "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;
+        SSCS_SECRET_T mySecret;
+        SSCS_PASSWORD_T epPassword = {0,0,""};
+        uint32_t bytesRequired = 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
+	{
+                mySecret.data = (char *)malloc(MAX_SECRET_VAL_LEN);
+                assert(mySecret.data);
+		printf("Enumerating 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++ )
+                {
+                    SSCS_SECRET_ID_T secId;
+                    strcpy(secId.id,secretIDList.secIDList[i].id);
+                    secId.len = strlen(secretIDList.secIDList[i].id)+1;
+                    mySecret.len = MAX_SECRET_VAL_LEN;
+                    memset(mySecret.data,0,MAX_SECRET_VAL_LEN);
+
+                    retVal = sscs_CacheReadSecret(ssHandle, ssFlags, keychainID,&secId, &mySecret, &epPassword, &bytesRequired, NULL);
+                    if(retVal != 0)
+                    {
+                        printf("sscs_CacheReadSecret failed: %d\n",retVal);
+                    }
+                    else
+                    {
+                        printf("Read secretID - %s\n",secretIDList.secIDList[i].id);
+                        printf("SecretVal is : \n%s\n",mySecret.data);
+                    }
+                }
+                free(secretIDList.secIDList);
+                free(mySecret.data);
+	}
+        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");
+    
+        enumerateIDs(ssHandle,0,NULL);
+        enumerateIDs(ssHandle, 1,&mykeychainID);
+
+        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;
+}

test/dev_test/makefile

@@ -0,0 +1,8 @@
+all: sample enumerate
+sample:
+	gcc -g -o sample -I../../include/ -L../../lib/lux/dbg/ -lmicasa ./sample.c
+enumerate:
+	gcc -g -o enumerate -I../../include enumerate.c -L../../lib/lux/dbg/ -lmicasacache
+clean:
+	rm ./sample
+	rm ./enumerate