FCL/sf/mw/drm: comparison omadrm/drmengine/keystorage/src/DrmStdKeyStorage.cpp

equal deleted inserted replaced

-:79d62d1d7957
+:493788a4a8a4
 #include <x509cert.h>
 #include <etelmm.h>
 #include <mmtsy_names.h>
 #ifdef RD_MULTIPLE_DRIVE
-#include <DriveInfo.h>
+#include <driveinfo.h>
 #endif
 #include "DrmKeyStorage.h"
 #include "DrmStdKeyStorage.h"
 RFileLogger::HexDump(KLogDir, KLogName, \
 EFileLoggingModeAppend, _S(""), _S(""), \
 buffer.Ptr(), buffer.Length());
 #else
 #define LOG(string)
 #define LOGHEX(buffer)
 #endif
 #pragma message("Compiling DRM Std KeyStorage..")
 LOCAL_C void DoUnloadPhoneModule( TAny* aAny );
 LOCAL_C void WriteFileL(RFs& aFs, const TDesC& aName, const TDesC8& aData)
 {
 RFile file;
 User::LeaveIfError(file.Replace(aFs, aName, EFileWrite));
 User::LeaveIfError(file.Write(aData));
 file.Close();
 }
 LOCAL_C void ReadFileL(RFs& aFs, const TDesC& aName, HBufC8*& aContent)
 {
 RFile file;
 TInt size = 0;
 User::LeaveIfError(file.Open(aFs, aName, EFileRead));
 CleanupClosePushL(file);
 User::LeaveIfError(file.Size(size));
 aContent = HBufC8::NewLC(size);
 TPtr8 ptr(aContent->Des());
 RInteger OS2IPL(
 const TDesC8& aOctetStream)
 {
 RInteger r;
 TInt i;
 r = RInteger::NewL(0);
 for (i = 0; i < aOctetStream.Length(); i++)
 {
 r *= 256;
 r += aOctetStream[i];
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage* CDrmStdKeyStorage::NewL
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C CDrmStdKeyStorage* CDrmStdKeyStorage::NewL(RLibrary aLibrary)
 {
 CDrmStdKeyStorage* self = new (ELeave) CDrmStdKeyStorage(aLibrary);
 return self;
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::CDrmStdKeyStorage
 //
 // -----------------------------------------------------------------------------
 //
 CDrmStdKeyStorage::CDrmStdKeyStorage(RLibrary aLibrary):
 iFileMan(NULL),
 iRootSelected(EFalse),
 iKey(NULL),
 iImei(NULL),
 {
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::ConstructL
 //
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::ConstructL()
 {
 LOG(_L("CDrmStdKeyStorage::ConstructL ->"));
 User::LeaveIfError(iFs.Connect());
 iFileMan = CFileMan::NewL(iFs);
 #ifdef __DRM_OMA2
-	SelectDefaultRootL();
+SelectDefaultRootL();
 #endif
 iDeviceSpecificKey.Copy(KDefaultKey);
 LOG(_L("CDrmStdKeyStorage::ConstructL <-"));
 }
 // -----------------------------------------------------------------------------
 // MDrmKeyStorage::~MDrmKeyStorage
 //
 // -----------------------------------------------------------------------------
 //
 MDrmKeyStorage::~MDrmKeyStorage()
 {
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::~CDrmStdKeyStorage
 //
 // -----------------------------------------------------------------------------
 //
 CDrmStdKeyStorage::~CDrmStdKeyStorage()
 {
 LOG(_L("CDrmStdKeyStorage::~CDrmStdKeyStorage <-"));
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::ModulusSize
 //
 // -----------------------------------------------------------------------------
 //
 TInt CDrmStdKeyStorage::ModulusSize()
 {
 LOG(_L("CDrmStdKeyStorage::ModulusSize ->"));
 if(iKey == NULL)
 return iKey->N().BitCount();
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::SelectTrustedRootL
 //
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::SelectTrustedRootL(
 const TDesC8& aRootKeyHash)
 {
 TFileName fileName;
 TEntry entry;
 TInt i;
 LOG(_L("CDrmStdKeyStorage::SelectTrustedRootL ->"));
 LOG(aRootKeyHash);
 if (aRootKeyHash.Length() != 0)
 {
 #ifndef RD_MULTIPLE_DRIVE
 fileName.Copy(KKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 TFileName tempPath;
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
-	iFs.DriveToChar( driveNumber, driveLetter );
+iFs.DriveToChar( driveNumber, driveLetter );
-	tempPath.Format( KKeyStoragePath, (TUint)driveLetter );
+tempPath.Format( KKeyStoragePath, (TUint)driveLetter );
 fileName.Copy(tempPath);
 #endif
 for (i = 0; i < SHA1_HASH; i++)
 {
 fileName.AppendNumFixedWidth(aRootKeyHash[i], EHex, 2);
 }
 fileName.Append('\\');
 if (iFs.Entry(fileName, entry) != KErrNone)
 {
 #ifndef RD_MULTIPLE_DRIVE
 fileName.Copy(KRomKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
-	    iFs.DriveToChar( driveNumber, driveLetter );
+iFs.DriveToChar( driveNumber, driveLetter );
-	    tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );
+tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );
 fileName.Copy(tempPath);
 #endif
 for (i = 0; i < SHA1_HASH; i++)
 {
 fileName.AppendNumFixedWidth(aRootKeyHash[i], EHex, 2);
 }
 fileName.Append('\\');
 User::LeaveIfError(iFs.Entry(fileName, entry));
 }
 User::LeaveIfError(iFs.SetSessionPath(fileName));
 InitializeKeyL();
 CheckRootForCmlaL();
 iRootSelected = ETrue;
 }
 else
 {
 SelectDefaultRootL();
 }
 LOG(_L("CDrmStdKeyStorage::SelectTrustedRootL <-"));
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::SelectDefaultRootL
 //
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::SelectDefaultRootL()
 {
 CDir* dir = NULL;
 TFileName dirName;
 TBool found = EFalse;
 LOG(_L("CDrmStdKeyStorage::SelectDefaultRootL ->"));
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.GetDir(KKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 TFileName tempPath;
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KKeyStoragePath, (TUint)driveLetter );
 if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
 __UHEAP_MARK;
 LOG(_L("  Checking keys on C:"));
 CleanupStack::PushL(dir);
 if (dir->Count() >= 1)
 {
 #ifndef RD_MULTIPLE_DRIVE
 dirName.Copy(KKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 dirName.Copy(tempPath);
 #endif
 dirName.Append((*dir)[0].iName);
 dirName.Append('\\');
 User::LeaveIfError(iFs.SetSessionPath(dirName));
 found = ETrue;
 }
 CleanupStack::PopAndDestroy(dir);
 __UHEAP_MARKEND;
 }
 #ifndef RD_MULTIPLE_DRIVE
 if (!found && iFs.GetDir(KRomKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );
 if (!found && iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
-	LOG(_L("  Checking keys on Z:"));
+LOG(_L("  Checking keys on Z:"));
 CleanupStack::PushL(dir);
 if (dir->Count() < 1)
 {
 User::Leave(KErrGeneral);
 }
 #ifndef RD_MULTIPLE_DRIVE
 dirName.Copy(KRomKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 dirName.Copy(tempPath);
 #endif
 dirName.Append((*dir)[0].iName);
 dirName.Append('\\');
 User::LeaveIfError(iFs.SetSessionPath(dirName));
 CleanupStack::PopAndDestroy(dir);
 found = ETrue;
 }
 if (!found)
 {
 User::Leave(KErrGeneral);
 }
 InitializeKeyL();
 CheckRootForCmlaL();
 iRootSelected = ETrue;
 LOG(_L("CDrmStdKeyStorage::SelectDefaultRootL <-"));
 }
 TBool CDrmStdKeyStorage::SelectedRootIsCmla()
 {
 return iRootIsCmla;
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::GetTrustedRootsL
 //
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::GetTrustedRootsL(
 RPointerArray<HBufC8>& aRootList)
 {
 CDir* dir = NULL;
 TInt i;
 TInt j;
 TBuf8<SHA1_HASH> hash;
 TEntry entry;
 TUint8 c;
 TInt r = KErrNone;
 LOG(_L("CDrmStdKeyStorage::GetTrustedRootsL ->"));
 aRootList.ResetAndDestroy();
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.GetDir(KKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 TFileName tempPath;
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KKeyStoragePath, (TUint)driveLetter );
 if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
 LOG(_L("  Getting roots on C:"));
 CleanupStack::PushL(dir);
 for (i = 0; i < dir->Count(); i++)
 aRootList.Append(hash.AllocL());
 }
 }
 CleanupStack::PopAndDestroy(dir);
 }
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.GetDir(KRomKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );
 if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
 LOG(_L("  Getting roots on Z:"));
 CleanupStack::PushL(dir);
 for (i = 0; i < dir->Count(); i++)
 LOG(_L("CDrmStdKeyStorage::GetTrustedRootsL <-"));
 }
 // -----------------------------------------------------------------------------
 // DrmStdKeyStorage::GetCertificateChainL
 //
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::GetCertificateChainL(
 RPointerArray<HBufC8>& aCertChain)
 {
 TFileName fileName;
 TInt i;
 CDir* dir = NULL;
 HBufC8* cert = NULL;
 LOG(_L("CDrmStdKeyStorage::GetCertificateChainL ->"));
 if (!iRootSelected)
 {
 User::Leave(KErrGeneral);
 }
 HBufC8* publicKey = NULL;
 CX509Certificate* cert = NULL;
 CSHA1* hasher = NULL;
 TBuf8<SHA1_HASH> publicKeyHash;
 TFileName fileName;
 LOG(_L("CDrmStdKeyStorage::ImportDataL ->"));
 n = aCertificateChain.Count();
 cert = CX509Certificate::NewLC(aCertificateChain[n - 1]);
 publicKey = cert->DataElementEncoding(
 CX509Certificate::ESubjectPublicKeyInfo)->AllocL();
 CleanupStack::PushL(publicKey);
 hasher = CSHA1::NewL();
 CleanupStack::PushL(hasher);
 hasher->Update(*publicKey);
 publicKeyHash.Copy(hasher->Final());
 #ifndef RD_MULTIPLE_DRIVE
 fileName.Copy(KKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 TFileName keyStorageDir;
 keyStorageDir.Format( KKeyStoragePath, (TUint)driveLetter );
 fileName.Copy(keyStorageDir);
 #endif
 for (i = 0; i < SHA1_HASH; i++)
 {
 fileName.AppendNumFixedWidth(publicKeyHash[i], EHex, 2);
 }
 fileName.Append('\\');
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::GetDeviceSpecificKeyL(
 TBuf8<KDeviceSpecificKeyLength>& aKey)
 {
 HBufC8* key = NULL;
 TInt n;
 CSHA1* hasher = NULL;
 TBuf8<SHA1_HASH> hash;
 if (iDeviceSpecificKey.Compare(KDefaultKey) == 0)
 {
 GetImeiL();
 HBufC8* buf = HBufC8::NewLC( iImei->Size() + sizeof(VID_DEFAULT) );
 TPtr8 ptr( buf->Des() );
 ptr.Copy( *iImei );
 ptr.Append(VID_DEFAULT);
 {
 iDeviceSpecificKey.Append(0);
 n--;
 }
 }
 aKey.Copy(iDeviceSpecificKey);
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::InitializeKeyL
 {
 RInteger result;
 RInteger input;
 HBufC8* output;
 TInt keyLength = KKeyLength;
 LOG(_L("CDrmStdKeyStorage::ModularExponentiateWithKeyL ->"));
 input = OS2IPL(aInput);
 CleanupClosePushL(input);
 result = TInteger::ModularExponentiateL(input,iKey->D(), iKey->N());
 CleanupClosePushL(result);
 {
 CDir* dir = NULL;
 HBufC8* buffer = NULL;
 HBufC* name = NULL;
 CX509Certificate* cert = NULL;
 LOG(_L("CDrmStdKeyStorage::CheckRootForCmlaL ->"));
 __UHEAP_MARK;
 iFs.GetDir(KSingingCertPattern, KEntryAttNormal, ESortByName, dir);
 CleanupStack::PushL(dir);
 ReadFileL(iFs, (*dir)[dir->Count() - 1].iName, buffer);
 }
 CleanupStack::PopAndDestroy(4); // name, cert, buffer, dir
 LOG(_L("CDrmStdKeyStorage::CheckRootForCmlaL <-"));
 __UHEAP_MARKEND;
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::GetRdbSerialNumberL
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::GetRdbSerialNumberL(
 TBuf8<KRdbSerialNumberLength>& aSerialNumber)
 {
 HBufC8* buffer = NULL;
 TUint att;
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.Att(KSerialNumberFile, att) != KErrNone)
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 TFileName serialNoFile;
 serialNoFile.Format( KSerialNumberFile, (TUint)driveLetter );
 if (iFs.Att(serialNoFile, att) != KErrNone)
 #endif
 {
 GenerateNewRdbSerialNumberL();
 }
 #ifndef RD_MULTIPLE_DRIVE
 ReadFileL(iFs, KSerialNumberFile, buffer);
 #else //RD_MULTIPLE_DRIVE
 ReadFileL(iFs, serialNoFile, buffer);
 #endif
 aSerialNumber.Copy(*buffer);
 delete buffer;
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::GenerateNewRdbSerialNumberL
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::GenerateNewRdbSerialNumberL()
 {
 TBuf8<KRdbSerialNumberLength> serialNumber;
 TPtr8 random( const_cast<TUint8*>(serialNumber.Ptr()),
 KRdbSerialNumberLength,
 KRdbSerialNumberLength );
 RandomDataGetL(random,KRdbSerialNumberLength);
 #ifndef RD_MULTIPLE_DRIVE
 WriteFileL(iFs, KSerialNumberFile, random);
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 TFileName serialNoFile;
 serialNoFile.Format( KSerialNumberFile, (TUint)driveLetter );
 WriteFileL(iFs, serialNoFile, random);
 #endif
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::UdtEncryptL
 // -----------------------------------------------------------------------------
 //
 HBufC8* CDrmStdKeyStorage::UdtEncryptL(
 CX509Certificate* cert = NULL;
 CRSAPublicKey* key = NULL;
 TX509KeyFactory factory;
 CRSAPKCS1v15Encryptor* encryptor = NULL;
 TPtr8 result(const_cast<TUint8*>(output->Ptr()), 0, 256);
 #ifndef RD_MULTIPLE_DRIVE
 ReadFileL(iFs, KUdtCertFileName, buffer);
 #else //RD_MULTIPLE_DRIVE
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 TFileName udtCertFile;
 udtCertFile.Format( KUdtCertFileName, (TUint)driveLetter );
 ReadFileL(iFs, udtCertFile, buffer);
 #endif
 CleanupStack::PushL(buffer);
 cert = CX509Certificate::NewL(*buffer);
 CleanupStack::PushL(cert);
 key = factory.RSAPublicKeyL(cert->PublicKey().KeyData());
 CleanupStack::PushL(key);
 encryptor = CRSAPKCS1v15Encryptor::NewLC(*key);
 encryptor->EncryptL(aInput, result);
 CleanupStack::PopAndDestroy(4); // encryptor, key, cert, buffer
 CleanupStack::Pop();// output
 iFs.SessionPath( path );
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.GetDir(KKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 TFileName tempPath;
 TInt driveNumber( -1 );
 TChar driveLetter;
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KKeyStoragePath, (TUint)driveLetter );
 if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
 CleanupStack::PushL(dir);
 for(i = 0; i < dir->Count(); i++)
 {
 if ((*dir)[i].IsDir())
 {
 #ifndef RD_MULTIPLE_DRIVE
 dirName.Copy(KKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 dirName.Copy(tempPath);
 #endif
 dirName.Append((*dir)[i].iName);
 dirName.Append('\\');
 User::LeaveIfError(iFs.SetSessionPath(dirName));
 User::LeaveIfError(iFs.GetDir(KSingingCertPattern, KEntryAttNormal, ESortByName, rootCerts));
 CleanupStack::PushL(rootCerts);
 CleanupStack::PopAndDestroy(); // rootCerts
 }
 }
 CleanupStack::PopAndDestroy(dir);
 }
 #ifndef RD_MULTIPLE_DRIVE
 if (iFs.GetDir(KRomKeyStoragePath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #else //RD_MULTIPLE_DRIVE
 DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );
 iFs.DriveToChar( driveNumber, driveLetter );
 tempPath.Format( KRomKeyStoragePath, (TUint)driveLetter );
 if (iFs.GetDir(tempPath, KEntryAttDir, ESortByName, dir) == KErrNone)
 #endif
 {
 CleanupStack::PushL(dir);
 for(i = 0; i < dir->Count(); i++)
 {
 if ((*dir)[i].IsDir())
 {
 #ifndef RD_MULTIPLE_DRIVE
 dirName.Copy(KRomKeyStoragePath);
 #else //RD_MULTIPLE_DRIVE
 dirName.Copy(tempPath);
 #endif
 dirName.Append((*dir)[i].iName);
 dirName.Append('\\');
 User::LeaveIfError(iFs.SetSessionPath(dirName));
 User::LeaveIfError(iFs.GetDir(KSingingCertPattern, KEntryAttNormal, ESortByName, rootCerts));
 CleanupStack::PushL(rootCerts);
 }
 CleanupStack::PopAndDestroy(dir);
 }
 iFs.SetSessionPath( path );
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::GetIMEIL
 // -----------------------------------------------------------------------------
 //
 const TDesC& CDrmStdKeyStorage::GetImeiL()
 {
 return *iImei;
 }
 #if (defined __WINS__ || defined WINSCW)
 // Default IMEI used for emulator
 _LIT( KDefaultSerialNumber, "123456789123456789" );
 iImei = KDefaultSerialNumber().AllocL();
 return *iImei;
 #else
 TInt error( KErrNone );
 TInt count( 0 );
 TInt count2( 0 );
 TUint32 caps( 0 );
 TBool found (EFalse);
 RTelServer etelServer;
 RMobilePhone phone;
 TUint KMaxImeiTries = 5;
 for ( TUint8 i = 0; i < KMaxImeiTries; ++i )
 {
 error = etelServer.Connect();
 if ( error )
 {
 User::After( TTimeIntervalMicroSeconds32( KWaitingTime ) );
 }
 else
 {
 break;
 }
 }
 User::LeaveIfError( error );
 CleanupClosePushL( etelServer );
 User::LeaveIfError( etelServer.LoadPhoneModule( KMmTsyModuleName ) );
 TUnloadModule unload;
 unload.iServer = &etelServer;
 unload.iName = &KMmTsyModuleName;
 TCleanupItem item( DoUnloadPhoneModule, &unload );
 CleanupStack::PushL( item );
 User::LeaveIfError( etelServer.EnumeratePhones( count ) );
 for ( count2 = 0; count2 < count && !found; ++count2 )
 {
 RTelServer::TPhoneInfo phoneInfo;
 User::LeaveIfError( etelServer.GetTsyName( count2, phoneInfo.iName ) );
 if ( phoneInfo.iName.CompareF(KMmTsyModuleName()) == 0 )
 {
 User::LeaveIfError( etelServer.GetPhoneInfo( count2, phoneInfo ) );
 User::LeaveIfError( phone.Open( etelServer, phoneInfo.iName ) );
 CleanupClosePushL( phone );
 found = ETrue;
 if ( !found )
 {
 // Not found.
 User::Leave( KErrNotFound );
 }
 User::LeaveIfError( phone.GetIdentityCaps( caps ) );
 if (!( caps & RMobilePhone::KCapsGetSerialNumber ))
 {
 User::Leave( KErrNotFound );
 }
 RMobilePhone::TMobilePhoneIdentityV1 id;
 TRequestStatus status;
 phone.GetPhoneId( status, id );
 User::WaitForRequest( status );
 User::LeaveIfError( status.Int() );
 iImei = id.iSerialNumber.AllocL();
 CleanupStack::PopAndDestroy( 3 ); // phone, item, etelServer
 HBufC8* buf = HBufC8::NewL( iImei->Size() );
 TPtr8 ptr( buf->Des() );
 ptr.Copy( *iImei );
 LOG(_L("IMEI:"));
 LOGHEX(ptr);
 delete buf;
 return *iImei;
 #endif /* __WINS__ , WINSCW */
 }
 // -----------------------------------------------------------------------------
 // CDrmStdKeyStorage::RandomDataGetL
 // -----------------------------------------------------------------------------
 //
 void CDrmStdKeyStorage::RandomDataGetL( TDes8& aData, const TInt aLength )
 {
 if ( aLength <= 0 )
 {
 User::Leave(KErrArgument);

changeset 23	493788a4a8a4
parent 0	95b198f216e5
child 25	04da681812a9