void CTcWatcherSession::ConstructL( CTcWatcherServer* aServer )
{
#ifndef __IPC_V2_PRESENT__
CreateL( *aServer );
#endif
iWatcherServer = aServer;
iWatcherServer->SessionAdded();
}
void CAppConfig::ConstructL() {
User::LeaveIfError(iFsSession.Connect());
TFileName configFile(KConfigFile);
TFileName folder(BaflUtils::DriveAndPathFromFullName(configFile));
if (!BaflUtils::FolderExists(iFsSession, folder)) {
User::LeaveIfError(iFsSession.MkDirAll(folder));
}
// attempt to open DB
TRAPD(error, OpenL(configFile));
// if it fails, create and open again
if (error != KErrNone) {
Close();
CreateL(configFile);
OpenL(configFile);
}
CheckConfigTableL();
CheckAutosaveTableL();
}
void CStringParser::ConstructL(TInt aBufferSize)
{
LOGTEXT(_L8("[Ltsy] Starting CStringParser::ConstructL()"));
CreateL(aBufferSize);
}
EXPORT_C TInt CSenLogger::CreateL(TInt aChannel, TInt aLevel, const TDesC& aLogDir, const TDesC& aLogFileName)
{
return CreateL( aChannel, aLevel, aLogDir, aLogFileName, EFileLoggingModeOverwrite );
}
// ---------------------------------------------------------------------------
// CDevCertKeyStoreServer::CompleteKeyExportL()
// ---------------------------------------------------------------------------
//
void CDevCertKeyStoreServer::CompleteKeyExportL()
{
ASSERT(iKeyData);
ASSERT(iExportBuf.Ptr());
CDevTokenKeyInfo::EKeyAlgorithm keyAlgorithm = iKeyInfo->Algorithm();
RStoreReadStream privStream;
iKeyDataManager->OpenPrivateDataStreamLC(*iKeyData, privStream);
CASN1EncSequence* encoded = NULL;
switch(keyAlgorithm)
{
case (CDevTokenKeyInfo::ERSA):
{
RStoreReadStream pubStream;
iKeyDataManager->OpenPublicDataStreamLC(*iKeyData, pubStream);
CRSAPublicKey* publicKey = NULL;
CreateL(pubStream, publicKey);
ASSERT(publicKey);
CleanupStack::PushL(publicKey);
CRSAPrivateKey* privateKey = NULL;
CreateL(privStream, privateKey);
ASSERT(privateKey);
CleanupStack::PushL(privateKey);
encoded = TASN1EncPKCS8::EncodeL(*(static_cast<CRSAPrivateKeyCRT*>(privateKey)), *publicKey, iKeyInfo->PKCS8AttributeSet());
CleanupStack::PopAndDestroy(3, &pubStream); // privateKey, publicKey, pubStream
}
break;
case (CDevTokenKeyInfo::EDSA):
{
CDSAPrivateKey* privateKey = NULL;
CreateL(privStream, privateKey);
ASSERT(privateKey);
CleanupStack::PushL(privateKey);
encoded = TASN1EncPKCS8::EncodeL(*privateKey, iKeyInfo->PKCS8AttributeSet());
CleanupStack::PopAndDestroy(privateKey);
}
break;
case (CDevTokenKeyInfo::EInvalidAlgorithm):
default:
User::Leave(KErrKeyAlgorithm);
break;
}
// common to all algorithms
ASSERT(encoded);
CleanupStack::PushL(encoded);
if (encoded->LengthDER() > static_cast<TUint>(iExportBuf.MaxLength()))
{
User::Leave(KErrOverflow);
}
TUint pos=0;
encoded->WriteDERL(iExportBuf, pos);
// WriteDERL does not set the length of the buffer, we do it ourselves
iExportBuf.SetLength(encoded->LengthDER());
CleanupStack::PopAndDestroy(encoded);
CleanupStack::PopAndDestroy(&privStream);
RunError(KErrNone);
}
// ---------------------------------------------------------------------------
// CDevCertKeyStoreServer::ExportPublicL()
// ---------------------------------------------------------------------------
//
void CDevCertKeyStoreServer::ExportPublicL(TInt aObjectId,
TDes8& aOut)
{
const CDevCertKeyData* keyData = iKeyDataManager->Lookup(aObjectId);
if (!keyData)
{
User::Leave(KErrNotFound);
}
CDevTokenKeyInfo* keyInfo = iKeyDataManager->ReadKeyInfoLC(*keyData);
RStoreReadStream stream;
iKeyDataManager->OpenPublicDataStreamLC(*keyData, stream);
CDevTokenKeyInfo::EKeyAlgorithm keyAlgorithm = keyInfo->Algorithm();
switch(keyAlgorithm)
{
case (CDevTokenKeyInfo::ERSA):
{
CRSAPublicKey* publicKey = NULL;
CreateL(stream, publicKey);
ASSERT(publicKey);
CleanupStack::PushL(publicKey);
TX509RSAKeyEncoder encoder(*publicKey, ESHA1);
CASN1EncBase* encoded = encoder.EncodeKeyLC();
if (encoded->LengthDER() > static_cast<TUint>(aOut.MaxLength()))
{
User::Leave(KErrOverflow);
}
// Get the Public key DER encoding
TUint pos=0;
encoded->WriteDERL(aOut, pos);
// WriteDERL does not set the length of the buffer, we do it ourselves
aOut.SetLength(encoded->LengthDER());
CleanupStack::PopAndDestroy(2, publicKey);
}
break;
case (CDevTokenKeyInfo::EDSA):
{
CDSAPublicKey* publicKey = NULL;
CreateL(stream, publicKey);
ASSERT(publicKey);
CleanupStack::PushL(publicKey);
TX509DSAKeyEncoder encoder(*publicKey, ESHA1);
CASN1EncBase* encoded = encoder.EncodeKeyLC();
if (encoded->LengthDER() > static_cast<TUint>(aOut.MaxLength()))
{
User::Leave(KErrOverflow);
}
// Get the Public key DER encoding
TUint pos=0;
encoded->WriteDERL(aOut, pos);
// WriteDERL does not set the length of the buffer, we do it ourselves
aOut.SetLength(encoded->LengthDER());
CleanupStack::PopAndDestroy(2, publicKey);
}
break;
case (CDevTokenKeyInfo::EDH):
default:
User::Leave(KErrKeyAlgorithm);
break;
}
CleanupStack::PopAndDestroy(2, keyInfo); //stream, keyinfo
}
