diff -r f5050f1da672 -r 04becd199f91 javamanager/javaregistry/client/src/writeablejavaregistryentry.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javamanager/javaregistry/client/src/writeablejavaregistryentry.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,530 @@ +/* +* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: writeablejavaregistryentry implementation +* +*/ + + +// INCLUDES + +#include + +#include "javacommonutils.h" +#include "javaregistryentry.h" +#include "javastoragenames.h" +#include "javasymbianoslayer.h" +#include "javauid.h" +#include "logger.h" +#include "midpauthenticationmodule.h" +#include "writeablejavaregistryentry.h" +#include "writeablejavaregistrypackageentry.h" + +using namespace Java; +using namespace Java::Manager::Registry; +using namespace java::storage; +using namespace java::util; +using namespace std; + +// ============================ MEMBER FUNCTIONS ============================= + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::CWriteableJavaRegistryEntry +// --------------------------------------------------------------------------- +// +CWriteableJavaRegistryEntry::CWriteableJavaRegistryEntry +(JavaStorageApplicationEntry_t& aEntry, TJavaRegistryEntryType aType) : + iEntry(aEntry), iType(aType) +{ +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::~CWriteableJavaRegistryEntry +// --------------------------------------------------------------------------- +// +EXPORT_C CWriteableJavaRegistryEntry::~CWriteableJavaRegistryEntry() +{ + iAttributes.ResetAndDestroy(); + iCertificates.ResetAndDestroy(); + + if (iName) + { + delete iName; + iName = NULL; + } + + if (iDrmContentId) + { + delete iDrmContentId; + iDrmContentId = NULL; + } +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::Uid +// --------------------------------------------------------------------------- +// +EXPORT_C TUid CWriteableJavaRegistryEntry::Uid() const +{ + JELOG2(EJavaStorage); + TUid uid; + wstring value; + EntryAttributeValue(iEntry, ID, value); + if (value.size() > 0) + { + java::util::Uid omjUid(value); + TInt err = uidToTUid(omjUid, uid); + if (KErrNone != err) + { + ELOG1(EJavaStorage, "Uid to TUid conversion failed: %d", err); + uid = TUid::Null(); + } + } + else + { + uid = TUid::Null(); + } + return uid; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::Name +// --------------------------------------------------------------------------- +// +EXPORT_C const TDesC& CWriteableJavaRegistryEntry::Name() const +{ + JELOG2(EJavaStorage); + + if (!iName) + { + wstring value = L""; + + if (EMidp2MidletSuite == iType) + { + EntryAttributeValue(iEntry, PACKAGE_NAME, value); + } + else // Application + { + EntryAttributeValue(iEntry, NAME, value); + } + + if (value.size() > 0) + { + iName = wstringToBuf(value); + } + else + { + return KNullDesC; + } + } + return *iName; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::Type +// --------------------------------------------------------------------------- +// +EXPORT_C Java::TJavaRegistryEntryType CWriteableJavaRegistryEntry:: +Type() const +{ + return iType; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::Drive +// --------------------------------------------------------------------------- +// +EXPORT_C TDriveNumber CWriteableJavaRegistryEntry::Drive() const +{ + JELOG2(EJavaStorage); + + wstring value = L""; + + if (EMidp2MidletSuite == iType) + { + EntryAttributeValue(iEntry, ROOT_PATH, value); + } + else // Application + { + EntryAttributeValue(iEntry, PACKAGE_ID, value); + + java::util::Uid suiteUid(value); + JavaStorageApplicationEntry_t suiteEntry; + + StorageEntry(suiteUid, APPLICATION_PACKAGE_TABLE, suiteEntry); + EntryAttributeValue(suiteEntry, ROOT_PATH, value); + + suiteEntry.clear(); + } + + // Original implementation returns EDriveC in a case of failure. + TInt driveNumber = EDriveC; + + if (value.size() > 0) + { + wstring::size_type start = 0; + wstring::size_type end = 1; + + char* driveLetter = 0; + + try + { + driveLetter = JavaCommonUtils::wstringToUtf8( + value.substr(start, end)); + + TInt err = RFs::CharToDrive(driveLetter[0], driveNumber); + + if (KErrNone != err) + { + WLOG2(EJavaStorage, + "Drive number conversion fault: %d. Letter: %c", + err, driveLetter[0]); + } + + delete[] driveLetter; + } + catch (ExceptionBase& e) + { + ELOG1WSTR( + EJavaStorage, + "Drive letter UTF-8 conversion failed for string: %s", + value.substr(start, end)); + } + } + + return (TDriveNumber) driveNumber; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::NumberOfCertificateChains +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CWriteableJavaRegistryEntry::NumberOfCertificateChains() const +{ + JELOG2(EJavaStorage); + + if (iCertificates.Count() == 0) + { + PopulateCertChains(); + } + + return iCertificates.Count(); +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::CertificateChain +// --------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CWriteableJavaRegistryEntry:: +CertificateChain(TInt aIndex) const +{ + JELOG2(EJavaStorage); + + if (iCertificates.Count() == 0) + { + PopulateCertChains(); + } + + if (aIndex < 0 || iCertificates.Count() <= aIndex) + { + return KNullDesC8; + } + return *(iCertificates[aIndex]); +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::DrmContentId +// --------------------------------------------------------------------------- +// +EXPORT_C const TDesC& CWriteableJavaRegistryEntry::DrmContentId() const +{ + JELOG2(EJavaStorage); + + if (!iDrmContentId) + { + wstring value = L""; + + if (EMidp2MidletSuite == iType) + { + EntryAttributeValue(iEntry, CONTENT_ID, value); + } + else // Application + { + EntryAttributeValue(iEntry, PACKAGE_ID, value); + java::util::Uid suiteUid(value); + JavaStorageApplicationEntry_t suiteEntry; + + StorageEntry(suiteUid, APPLICATION_PACKAGE_TABLE, suiteEntry); + EntryAttributeValue(suiteEntry, CONTENT_ID, value); + suiteEntry.clear(); + } + + if (value.size() > 0) + { + iDrmContentId = wstringToBuf(value); + } + else + { + return KNullDesC; + } + } + return *iDrmContentId; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::AttributeL +// --------------------------------------------------------------------------- +// +EXPORT_C const MJavaAttribute* CWriteableJavaRegistryEntry:: +AttributeL(const TDesC& aName) const +{ + JELOG2(EJavaStorage); + + if (0 == aName.Size()) + { + ELOG(EJavaStorage, "Empty attribute name"); + User::Leave(KErrArgument); + } + + // If attributes are not already read. These are manifest attributes + // and they are not updated unless application suite is re-installed. + if (iAttributes.Count() == 0) + { + AttributesL(); + } + + CJavaAttribute* regAttr = NULL; + + for (TInt i = 0; i < iAttributes.Count(); i++) + { + if (0 == (iAttributes[i])->Name().Compare(aName)) + { + regAttr = CJavaAttribute::NewL((iAttributes[i])->Name(), + (iAttributes[i])->Value(), + (iAttributes[i])->Trusted()); + break; + } + } + return regAttr; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::AttributesL +// --------------------------------------------------------------------------- +// +EXPORT_C const RPointerArray& +CWriteableJavaRegistryEntry::AttributesL() const +{ + JELOG2(EJavaStorage); + + // If attributes are already read. These are manifest attributes and they + // are not updated unless application suite is reinstalled. + if (iAttributes.Count() > 0) + { + + return iAttributes; + } + + wstring value = L""; + JavaStorageApplicationList_t attributeList; + + if (EMidp2MidletSuite == iType) + { + EntryAttributeValue(iEntry, ID, value); + } + else // Application + { + // Get suiteID where application belongs to. + EntryAttributeValue(iEntry, PACKAGE_ID, value); + } + + ReadAttributesL(value, attributeList); + + if (attributeList.size() != 0) + { + // Populate attributes + JavaStorageApplicationList_t::const_iterator attrIter; + JavaStorageEntry attr; + CJavaAttribute* regAttr = NULL; + + wstring attrName = L""; + wstring attrValue = L""; + wstring attrTrusted = L""; + + for (attrIter = attributeList.begin(); + attrIter != attributeList.end(); + ++attrIter) + { + EntryAttributeValue((*attrIter), NAME, attrName); + EntryAttributeValue((*attrIter), VALUE, attrValue); + EntryAttributeValue((*attrIter), TRUSTED, attrTrusted); + + if (attrValue.size() > 0 && attrName.size() > 0) + { + auto_ptr nameBuf(wstringToBuf(attrName)); + auto_ptr valueBuf(wstringToBuf(attrValue)); + + TBool trusted = EFalse; + if (attrTrusted == L"1") + { + trusted = ETrue; + } + + regAttr = CJavaAttribute::NewL( + nameBuf->Des(), valueBuf->Des(), trusted); + + iAttributes.Append(regAttr); + + nameBuf.reset(0); + valueBuf.reset(0); + attrName.clear(); + attrValue.clear(); + attrTrusted.clear(); + } + // else CJavaAttribute cannot be constructed with empty values. + // Using same logic it does not exists if value is not set. + } + } + return iAttributes; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::ConstructL +// --------------------------------------------------------------------------- +// +EXPORT_C void CWriteableJavaRegistryEntry:: +ConstructL(Java::TJavaRegistryEntryType aType) +{ + JELOG2(EJavaStorage); + iType = aType; +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::ReadAttributesL +// --------------------------------------------------------------------------- +// +void CWriteableJavaRegistryEntry::ReadAttributesL(const wstring& aUid, + JavaStorageApplicationList_t& aAttributes) const +{ + JavaStorageApplicationEntry_t searchQuery; + JavaStorageEntry attr; + + attr.setEntry(ID, aUid); + searchQuery.insert(attr); + + try + { + auto_ptr js(JavaStorage::createInstance()); + js->open(); + js->search(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, searchQuery, aAttributes); + js->close(); + js.reset(0); + searchQuery.clear(); + } + catch (JavaStorageException& aJse) + { + ELOG1(EJavaStorage, "Attributes read failed: %d", aJse.mStatus); + User::Leave(aJse.mStatus); + } +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::EntryAttributeValue +// --------------------------------------------------------------------------- +// +void CWriteableJavaRegistryEntry::EntryAttributeValue( + const JavaStorageApplicationEntry_t& aEntry, + const wstring& aName, + wstring& aValue) const +{ + JavaStorageEntry attr; + attr.setEntry(aName, L""); + JavaStorageApplicationEntry_t::const_iterator finder = aEntry.find(attr); + + if (finder != aEntry.end()) + { + aValue = (*finder).entryValue(); + } + else + { + LOG(EJavaStorage, EInfo, "Entry attribute value not found"); + aValue = L""; + } +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::StorageEntry +// --------------------------------------------------------------------------- +// +void CWriteableJavaRegistryEntry::StorageEntry( + const java::util::Uid& aUid, + const string& aTableName, + JavaStorageApplicationEntry_t& aStorageEntry) const +{ + try + { + auto_ptr js(JavaStorage::createInstance()); + js->open(); + js->read(aTableName, aUid, aStorageEntry); + js->close(); + js.reset(0); + } + catch (JavaStorageException& jse) + { + ELOG1(EJavaStorage, "Read failed: %s ", + jse.toString().c_str()); + } +} + +// --------------------------------------------------------------------------- +// CWriteableJavaRegistryEntry::PopulateCertChains +// --------------------------------------------------------------------------- +// +void CWriteableJavaRegistryEntry::PopulateCertChains() const +{ + auto_ptrauthModule( + java::security::MIDPAuthenticationModule::createInstance()); + + wstring value = L""; + + if (EMidp2MidletSuite == iType) + { + EntryAttributeValue(iEntry, ID, value); + } + else // Application + { + EntryAttributeValue(iEntry, PACKAGE_ID, value); + } + + java::util::Uid suiteUid(value); + std::list chains; + + authModule->getCertChains(suiteUid, chains); + + list::const_iterator iter; + + for (iter = chains.begin(); iter != chains.end(); ++iter) + { + if ((*iter).size() > 0) + { + string decoded = JavaCommonUtils::base64decode((*iter)); + + HBufC8* decodedBuf = HBufC8::New(decoded.size()); + TPtr8 decodedBufPtr(decodedBuf->Des()); + decodedBufPtr.Append( + ((const TUint8*)decoded.c_str()), decoded.size()); + iCertificates.Append(decodedBuf); + } + } + chains.clear(); +}