601 lines
19 KiB
C++
601 lines
19 KiB
C++
/***********************************************************************
|
|
*
|
|
* 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<stdio.h>
|
|
#include <kapp.h>
|
|
#include <kcmdlineargs.h>
|
|
#include<kwallet.h>
|
|
#include <dcopclient.h>
|
|
|
|
|
|
using namespace KWallet;
|
|
|
|
#include "kwallets_rw.h"
|
|
#include "kwallets_rw.moc"
|
|
//#include "mytest.h"
|
|
|
|
|
|
// char *applName="dcopifacedemo";
|
|
char *applName="casaconsole";
|
|
QStringList walletList;
|
|
|
|
DCOPDemoWidget *win = new DCOPDemoWidget();
|
|
|
|
DCOPDemoWidget::DCOPDemoWidget()
|
|
{
|
|
|
|
int ret = 0;
|
|
kapp->dcopClient()->isRegistered() ;
|
|
if (!ret)
|
|
{
|
|
if(kapp->dcopClient()->registerAs( "casaconsole" ).isEmpty())
|
|
{
|
|
kapp->startKdeinit();
|
|
kapp->dcopClient()->isRegistered() ;
|
|
if (!ret)
|
|
{
|
|
if (kapp->dcopClient()->registerAs( "casaconsole" ).isEmpty())
|
|
{
|
|
printf("Cannot setup DCOP communication. Start kdeinit manually\n");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if ( !kapp->dcopClient()->isRegistered() ) {
|
|
kapp->dcopClient()->registerAs( "casaconsole" );
|
|
}
|
|
*/
|
|
}
|
|
|
|
DCOPDemoWidget::~DCOPDemoWidget()
|
|
{
|
|
|
|
for ( QStringList::Iterator walletIter = walletList.begin(); walletIter != walletList.end(); ++walletIter )
|
|
{
|
|
QString walletName = (*walletIter);
|
|
Wallet::disconnectApplication(walletName,applName);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int DCOPDemoWidget::ReadKey(Wallet *wallet,QString key, QByteArray *secretVal)
|
|
{
|
|
|
|
// Read the secret from the entry
|
|
QByteArray value;
|
|
//printf("kwallet: Read Key entered\n");
|
|
|
|
if (wallet->readEntry(key, value)==0)
|
|
{
|
|
|
|
if (value)
|
|
{
|
|
|
|
*secretVal = value;
|
|
QDataStream convert(*secretVal, IO_ReadOnly);
|
|
|
|
|
|
if (wallet->entryType(key) == 1 )
|
|
{
|
|
|
|
//Commented by Austin
|
|
/* // Convert the ByteArray to QString
|
|
QString passwd;
|
|
printf("In read Entry Convert Final before success\n");
|
|
convert >> passwd;
|
|
printf("In read Entry Convert Final success\n");
|
|
*/
|
|
|
|
} else if (wallet->entryType(key) == 3)
|
|
{
|
|
|
|
// If the entry is of type "map"
|
|
// Convert the ByteArray to QMap
|
|
QMap<QString,QString> mapSecret;
|
|
convert >> mapSecret;
|
|
|
|
// Iterate through each map entry.
|
|
QMap<QString,QString>::Iterator mapIter;
|
|
QString tempSecret = QString::fromLatin1("");
|
|
|
|
for ( mapIter = mapSecret.begin(); mapIter != mapSecret.end(); ++mapIter )
|
|
{
|
|
// This logic has to be improved
|
|
tempSecret.append(mapIter.key().latin1());
|
|
tempSecret.append(":");
|
|
tempSecret.append(mapIter.data().latin1());
|
|
|
|
if ((++mapIter) != mapSecret.end())
|
|
tempSecret.append(";");
|
|
|
|
--mapIter;
|
|
}
|
|
|
|
// Convert the QString to QByteArray
|
|
QDataStream stream(*secretVal, IO_WriteOnly);
|
|
stream << tempSecret ;
|
|
|
|
}
|
|
|
|
} else
|
|
{
|
|
//printf("Could not read the entry..inner IF\n");
|
|
return -1;
|
|
}
|
|
|
|
} else
|
|
{
|
|
//printf("Could not read the entry Inside wallet->readkey\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
extern "C"
|
|
{
|
|
static struct EnumSecretList *tempEnumSecrets = NULL;
|
|
|
|
//void MyTest(struct EnumSecretList *enumWalletSecrets)
|
|
void Aggregate(struct EnumSecretList *enumWalletSecrets)
|
|
{
|
|
|
|
//printf("inside natiove agg");
|
|
int retVal = 0;
|
|
tempEnumSecrets = NULL;
|
|
retVal = win->ReadAllWalletSecrets(&tempEnumSecrets);
|
|
|
|
struct EnumSecretList *iter = tempEnumSecrets;
|
|
//struct EnumSecretList *head = tempEnumSecrets;
|
|
/*
|
|
if (iter == NULL)
|
|
{
|
|
|
|
printf("Native has given NULLLL\n");
|
|
enumWalletSecrets = NULL;
|
|
return;
|
|
}
|
|
*/
|
|
while (iter != NULL)
|
|
{
|
|
|
|
/*
|
|
printf("\n\n**Wallet Name : %s\n",iter->walletName);
|
|
printf("\t**Folder Name : %s\n",iter->folderName);
|
|
printf("\t\t**Secret Type : %d\n",iter->entryType);
|
|
printf("\t\t\t**Secret Value : %s\n",iter->secretVal);
|
|
*/
|
|
|
|
enumWalletSecrets->walletName = iter->walletName;
|
|
enumWalletSecrets->folderName = iter->folderName;
|
|
enumWalletSecrets->secretVal = iter->secretVal;
|
|
enumWalletSecrets->entryType = iter->entryType;
|
|
enumWalletSecrets->next = iter->next;
|
|
|
|
iter = iter->next;
|
|
if (iter != NULL)
|
|
{
|
|
enumWalletSecrets = enumWalletSecrets->next ;
|
|
}
|
|
else
|
|
{
|
|
enumWalletSecrets = NULL;
|
|
}
|
|
|
|
}
|
|
/*
|
|
// Free the list
|
|
struct EnumSecretList *temp;
|
|
while (head != NULL)
|
|
{
|
|
free(head->walletName);
|
|
free(head->folderName);
|
|
free(head->secretVal);
|
|
//free(head->entryType);
|
|
temp = head->next;
|
|
free(head);
|
|
head = temp;
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
int RemoveEntry(char *name, char *foldername, char *keyname)
|
|
{
|
|
DCOPDemoWidget kw;
|
|
return(kw.RemoveEntry(name,foldername,keyname));
|
|
}
|
|
int SetEntry(char *name, char *foldername, int entryType, char *keyname, char *value, int valueLen )
|
|
{
|
|
DCOPDemoWidget kw;
|
|
//printf("kwallet : In Set Entry\n");
|
|
return(kw.SetEntry(name,foldername,entryType,keyname,value,valueLen));
|
|
}
|
|
int SetMapEntry(char *name, char *foldername, char *keyname, char **value, int eleCount )
|
|
{
|
|
DCOPDemoWidget kw;
|
|
//printf("kwallet: SetMapEntry\n");
|
|
return(kw.SetMap(name,foldername,keyname,value,eleCount));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void FreeList()
|
|
{
|
|
|
|
struct EnumSecretList *head = tempEnumSecrets;
|
|
|
|
// Free the list
|
|
struct EnumSecretList *temp;
|
|
while (head != NULL)
|
|
{
|
|
free(head->walletName);
|
|
free(head->folderName);
|
|
free(head->secretVal);
|
|
//free(head->entryType);
|
|
temp = head->next;
|
|
free(head);
|
|
head = temp;
|
|
}
|
|
tempEnumSecrets = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int DCOPDemoWidget::ReadAllWalletSecrets(struct EnumSecretList **enumWalletSecrets)
|
|
{
|
|
|
|
walletList = Wallet::walletList();
|
|
for ( QStringList::Iterator walletIter = walletList.begin(); walletIter != walletList.end(); ++walletIter )
|
|
{
|
|
QString walletName = (*walletIter);
|
|
// printf("The wallet name is %s\n",(*walletIter).latin1());
|
|
|
|
|
|
// Open the wallet
|
|
Wallet *wallet = NULL;
|
|
wallet = Wallet::openWallet(walletName,0,Wallet::Synchronous);
|
|
|
|
if (wallet == NULL)
|
|
{
|
|
//printf("Could not open the wallet\n");
|
|
return -1;
|
|
}
|
|
|
|
// Get the folder list of the wallet
|
|
QStringList folderList = wallet->folderList();
|
|
|
|
for ( QStringList::Iterator folderIter = folderList.begin(); folderIter != folderList.end(); ++folderIter)
|
|
{
|
|
|
|
// printf("\t%s\n",(*folderIter).latin1());
|
|
QString folderName = (*folderIter);
|
|
|
|
// Set the current folder
|
|
if (!(wallet->setFolder(folderName)))
|
|
{
|
|
//printf("Could not set the folder\n");
|
|
return -1;
|
|
}
|
|
|
|
// Get the list of entries in the folder
|
|
QStringList entryList = wallet->entryList();
|
|
|
|
for ( QStringList::Iterator entryIter = entryList.begin(); entryIter != entryList.end(); ++entryIter)
|
|
{
|
|
//printf("Entry Name : \t\t%s\n",(*entryIter).latin1());
|
|
|
|
// Read the secret from the entry
|
|
QString key = (*entryIter);
|
|
|
|
QByteArray *secretVal = new QByteArray();
|
|
if (ReadKey(wallet,key,secretVal) != 0)
|
|
{
|
|
//printf("Could not read \"%s\"\n",key.latin1());
|
|
break;
|
|
//FIXME
|
|
}
|
|
|
|
struct EnumSecretList *tempWalletSecrets = (struct EnumSecretList*)malloc(sizeof(struct EnumSecretList));
|
|
|
|
if (tempWalletSecrets == NULL) {
|
|
//printf("Memory Allocation failure\n");
|
|
return -1;
|
|
}
|
|
|
|
tempWalletSecrets->walletName = (char*)malloc(512);
|
|
|
|
if (tempWalletSecrets->walletName == NULL)
|
|
{
|
|
//printf("Memory Allocation failure\n");
|
|
return -1;
|
|
}
|
|
|
|
//printf("Wallet Name is %s\n",walletName.latin1());
|
|
strcpy(tempWalletSecrets->walletName, walletName.latin1());
|
|
tempWalletSecrets->folderName = (char*)malloc(512);
|
|
|
|
if (tempWalletSecrets->folderName == NULL)
|
|
{
|
|
//printf("Memory Allocation failure\n");
|
|
return -1;
|
|
}
|
|
|
|
// printf("Folder Name is %s\n",folderName.latin1());
|
|
|
|
strcpy(tempWalletSecrets->folderName, folderName.latin1());
|
|
tempWalletSecrets->entryType = wallet->entryType(key);
|
|
// printf("EntryType is %d\n",wallet->entryType(key));
|
|
|
|
|
|
if (*enumWalletSecrets == NULL)
|
|
{
|
|
*enumWalletSecrets = tempWalletSecrets;
|
|
}
|
|
else
|
|
{
|
|
struct EnumSecretList *iter;
|
|
for(iter=*enumWalletSecrets; iter->next!=NULL; iter=iter->next);
|
|
iter->next = tempWalletSecrets;
|
|
}
|
|
|
|
tempWalletSecrets->next = NULL;
|
|
|
|
|
|
|
|
//Commented by Austin
|
|
QDataStream convert(*secretVal, IO_ReadOnly);
|
|
QString passwd;
|
|
convert >> passwd;
|
|
//QString passwd(*secretVal);
|
|
//printf("kwallet : ReadAll key %s value %s \n",key.latin1(), passwd.latin1());
|
|
tempWalletSecrets->secretVal = (char*)malloc(512);
|
|
|
|
if (tempWalletSecrets->secretVal == NULL)
|
|
{
|
|
//printf("Memory Allocation failure\n");
|
|
return -1;
|
|
}
|
|
|
|
strcpy(tempWalletSecrets->secretVal,key.latin1());
|
|
//printf("After strcpy - 1 - key is %s\n",key.latin1());
|
|
strcat(tempWalletSecrets->secretVal,"=");
|
|
//printf("After strcat = \n");
|
|
if(passwd)
|
|
{
|
|
//printf("Passwd is %s\n",passwd.latin1());
|
|
strcat(tempWalletSecrets->secretVal,passwd.latin1());
|
|
}
|
|
|
|
// Free memory
|
|
free(secretVal);
|
|
// printf("After free\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// Print all the secrets
|
|
/*
|
|
struct EnumSecretList *iter = *enumWalletSecrets;
|
|
while (iter != NULL)
|
|
{
|
|
printf("\n\nWallet Name : %s\n",iter->walletName);
|
|
printf("\tFolder Name : %s\n",iter->folderName);
|
|
printf("\t\tSecret Type : %d\n",iter->entryType);
|
|
printf("\t\t\t Secret Value : %s\n",iter->secretVal);
|
|
iter = iter->next;
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
int DCOPDemoWidget::SetEntry(char *name, char *foldername, int entryType, char *keyname, char *value, int valueLen )
|
|
{
|
|
|
|
QString qWalletName(name);
|
|
QString qKey(keyname);
|
|
QString qFolderName(foldername);
|
|
|
|
QString &refQKey = qKey;
|
|
|
|
// Open the wallet
|
|
Wallet *wallet = NULL;
|
|
wallet = Wallet::openWallet(qWalletName,0,Wallet::Synchronous);
|
|
if (wallet == NULL)
|
|
{
|
|
//printf("Could not open the wallet %s \n", qWalletName.latin1());
|
|
return KWALLET_RESULT_CANNOT_OPEN_WALLET;
|
|
}
|
|
if (wallet->setFolder(qFolderName) == false)
|
|
{
|
|
//printf("Could not open the folder %s \n", qFolderName.latin1());
|
|
return KWALLET_RESULT_CANNOT_OPEN_FOLDER;
|
|
}
|
|
QString unicodeValue = tr(value);
|
|
// Read the secret from the entry
|
|
//QByteArray secretVal(valueLen *2 );
|
|
|
|
QByteArray secretVal;
|
|
QDataStream ds(secretVal, IO_WriteOnly);
|
|
ds << unicodeValue;
|
|
|
|
/*for(int i=0; i< valueLen; i++)
|
|
{
|
|
secretVal[i] = 0;
|
|
secretVal[i+1] = value[i];
|
|
}
|
|
*/
|
|
//secretVal[valueLen] = '\0';
|
|
|
|
// secretVal.fill('a');
|
|
//secretVal.setRawData(value,valueLen);
|
|
QByteArray &refSecretVal = secretVal;
|
|
|
|
//QDataStream convert( secretVal, IO_WriteOnly );
|
|
//convert.readBytes( value, (uint)valueLen);
|
|
// Wallet::EntryType MyEntryType = 3;
|
|
if (wallet->entryType(qKey) != 3)
|
|
{
|
|
//printf("kwallet : SetEntry : Before setting Entry key %s value = %s EntryType =%d \n" , qKey.latin1() , value, entryType );
|
|
if (wallet->writeEntry(refQKey, refSecretVal , (Wallet::EntryType) entryType ) != 0)
|
|
{
|
|
return KWALLET_RESULT_CANNOT_WRITE_ENTRY;
|
|
}
|
|
}
|
|
// Free memory
|
|
wallet->sync();
|
|
return KWALLET_RESULT_OK;
|
|
}
|
|
|
|
|
|
int DCOPDemoWidget::SetMap(char *name, char *foldername, char *keyname, char **value, int numOfKeys )
|
|
{
|
|
QString qWalletName(name);
|
|
QString qKey(keyname);
|
|
QString qFolderName(foldername);
|
|
//printf("kwallet : SetMap : Wallet %s Folder %s Key =%s\n", name, foldername, keyname);
|
|
|
|
|
|
// Open the wallet
|
|
Wallet *wallet = NULL;
|
|
wallet = Wallet::openWallet(qWalletName,0,Wallet::Synchronous);
|
|
if (wallet == NULL)
|
|
{
|
|
//printf("Could not open the wallet\n");
|
|
return KWALLET_RESULT_CANNOT_OPEN_WALLET;
|
|
}
|
|
|
|
|
|
if (wallet->hasFolder(qFolderName) == false)
|
|
{
|
|
if(wallet->createFolder(qFolderName) == false)
|
|
{
|
|
return KWALLET_RESULT_CANNOT_CREATE_FOLDER;
|
|
}
|
|
}
|
|
|
|
if (wallet->setFolder(qFolderName) == false)
|
|
{
|
|
return KWALLET_RESULT_CANNOT_OPEN_FOLDER;
|
|
}
|
|
|
|
QMap<QString,QString> mapSecret;
|
|
for (int i=0; i < numOfKeys * 2; i+=2)
|
|
{
|
|
QString mapelekey((char *)value[i]);
|
|
QString mapelevalue((char *)value[i+1]);
|
|
mapSecret.insert(mapelekey,mapelevalue);
|
|
}
|
|
if (wallet->writeMap(qKey,mapSecret) != 0 )
|
|
{
|
|
return KWALLET_RESULT_CANNOT_WRITE_ENTRY;
|
|
}
|
|
wallet->sync();
|
|
return KWALLET_RESULT_OK;
|
|
}
|
|
|
|
|
|
|
|
int DCOPDemoWidget::RemoveEntry(char *name, char *foldername, char *keyname )
|
|
{
|
|
|
|
QString qWalletName(name);
|
|
QString qKey(keyname);
|
|
QString qFolderName(foldername);
|
|
//printf("In DCOPDemoWidget:RemoveEntry\n");
|
|
//printf("In DCOPDemoWidget:False %d\n",false);
|
|
//printf("In DCOPDemoWidget:False %d\n",FALSE);
|
|
|
|
// Open the wallet
|
|
Wallet *wallet = NULL;
|
|
wallet = Wallet::openWallet(qWalletName,0,Wallet::Synchronous);
|
|
if (wallet == NULL)
|
|
{
|
|
//printf("Could not open the wallet %s \n", qWalletName.latin1());
|
|
return KWALLET_RESULT_CANNOT_OPEN_WALLET;
|
|
}
|
|
if (wallet->setFolder(qFolderName) == false)
|
|
{
|
|
//printf("Could not set the folder %s \n", qFolderName.latin1());
|
|
return KWALLET_RESULT_CANNOT_OPEN_FOLDER;
|
|
}
|
|
if (wallet->removeEntry(qKey) != 0)
|
|
{
|
|
//printf("Could not remove Entry %s \n", qKey.latin1());
|
|
return KWALLET_RESULT_CANNOT_REMOVE_ENTRY;
|
|
}
|
|
wallet->sync();
|
|
//printf("In DCOPDemoWidget:RemoveEntry Exit\n");
|
|
return KWALLET_RESULT_OK;
|
|
}
|
|
|