1 /*

     2 * Copyright (c) 2003 - 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  DRM3 Engine manages all DRM related database operations.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32std.h>

    21 #include <e32test.h>

    22 #include <etelmm.h>

    23 #include <DrmTypes.h>

    24 #include <starterclient.h>

    25 #include <featmgr.h>

    26 

    27 #ifdef RD_MULTIPLE_DRIVE

    28 #include <DriveInfo.h>

    29 #endif

    30 

    31 #include "DRMRightsServer.h"

    32 #include "DRMRightsDb.h"

    33 #include "DRMDbSession.h"

    34 #include "DRMEngineClientServer.h"

    35 #include "DRMLog.h"

    36 #include "DRMNotifier.h"

    37 #include "DrmKeyStorage.h"

    38 #include "drmnotifierserver.h"

    39 #include "roapstorageserver.h"

    40 #include "drmnotifierclientserver.h"

    41 #include "drmroapclientserver.h"

    42 #include "DRMXOma.h"

    43 #include "DRMBackupObserver.h"

    44 #include "DRMBackup.h"

    45 #include "flogger.h"

    46 #include "drmrightsparser.h"

    47 #include "drmrights.h"

    48 #include "drmhelpercommon.h"

    49 

    50 #include  "wmdrmclientwrapper.h"

    51 

    52 

    53 

    54 #ifdef __DRM_CLOCK

    55 #include "DRMClockServer.h"

    56 #include "drmclockclientserver.h"

    57 #endif

    58 

    59 #include <utf.h>

    60 #include <DRMIndividualConstraintExtension.h>

    61 

    62 /*

    63 _LIT( KLogDir, "drm");

    64 _LIT( KLogName, "backup.log");

    65 */

    66 

    67 // EXTERNAL DATA STRUCTURES

    68 // EXTERNAL FUNCTION PROTOTYPES 

    69 // CONSTANTS

    70 LOCAL_C const TUint KMaxHeapsize = 0x7A120;

    71 

    72 _LIT8( KImsiId,"IMSI:");

    73 

    74 // MACROS

    75 #ifdef _DRM_TESTING

    76 _LIT( KDateTimeFormat, "%F%Y%M%D%H%T%S%C" );

    77 #endif

    78 

    79 // LOCAL CONSTANTS AND MACROS

    80 const TUint8 KMaxStartTries = 30;

    81 const TInt KWaitingTime = 2000000; // 2 sec

    82 _LIT( KRightsServerThread, "RightsServer" );

    83 

    84 #ifdef RD_MULTIPLE_DRIVE

    85 

    86 _LIT( KDbTempPath, "%c:\\system\\temp\\" );

    87 _LIT( KIndividualConstraintExtensionDll, "%c:\\sys\\bin\\DRMIndividualConstraintExtension.dll" );

    88 _LIT( KRightsDir, "%c:\\private\\101F51F2\\rdb\\" );

    89 _LIT( KTimedReplayCacheFile, "%c:\\private\\101F51F2\\timererc.dat" );

    90 _LIT( KPlainReplayCacheFile, "%c:\\private\\101F51F2\\plainrc.dat" );

    91 #ifdef RD_DRM_METERING

    92 _LIT( KMeteringDataBaseFile, "%c:\\private\\101F51F2\\meterdb.dat" );

    93 #endif

    94 

    95 #define USE_RO_IMPORT

    96 

    97 #ifdef USE_RO_IMPORT

    98 _LIT( KInternalImportDir, "%c:\\private\\101F51F2\\import\\" );

    99 _LIT( KUserDiskImportDir, "%c:\\import\\" ); // usually embedded MMC

   100 _LIT( KUserRemovableDiskImportDir, "%c:\\import\\" ); // usually external MMC

   101 _LIT( KDrSuffix, ".dr" );

   102 #endif

   103 

   104 #else

   105 

   106 _LIT( KRightsDir, "c:\\private\\101F51F2\\rdb\\" );

   107 _LIT( KTimedReplayCacheFile, "c:\\private\\101F51F2\\timererc.dat" );

   108 _LIT( KPlainReplayCacheFile, "c:\\private\\101F51F2\\plainrc.dat" );

   109 #ifdef RD_DRM_METERING

   110 _LIT( KMeteringDataBaseFile, "c:\\private\\101F51F2\\meterdb.dat" );

   111 #endif

   112 

   113 #define USE_RO_IMPORT

   114 

   115 #ifdef USE_RO_IMPORT

   116 _LIT( KInternalImportDir, "c:\\private\\101F51F2\\import\\" );

   117 _LIT( KUserDiskImportDir, "e:\\import\\" );

   118 _LIT( KDrSuffix, ".dr" );

   119 #endif

   120 

   121 #endif

   122 

   123 _LIT(KWmDrmClientWrapperName, "wmdrmclientwrapper.dll");

   124 

   125 // MODULE DATA STRUCTURES

   126 

   127 NONSHARABLE_STRUCT( TUnloadModule )

   128     {

   129     RTelServer* iServer;

   130     const TDesC* iName;

   131     };

   132 

   133 // LOCAL FUNCTION PROTOTYPES

   134 

   135 LOCAL_C TInt Startup( void );

   136 LOCAL_C void SignalClient();

   137 LOCAL_C TInt StartDBServer( void );

   138 

   139 #if defined( __WINS__ )

   140 #else

   141 #define DRM_USE_SERIALNUMBER_URI

   142 #include <mmtsy_names.h>

   143 #endif

   144 

   145 

   146 #ifdef DRM_USE_SERIALNUMBER_URI

   147 LOCAL_C void DoUnloadPhoneModule( TAny* aAny );

   148 #endif

   149 

   150 // #define USE_RO_IMPORT

   151 

   152 // FORWARD DECLARATIONS

   153 

   154 // ============================= LOCAL FUNCTIONS ===============================

   155 // -----------------------------------------------------------------------------

   156 // Function Startup().

   157 // This function starts the actual DRM Rights server after initializing

   158 // the cleanup stack and active scheduler.

   159 // Returns: TInt: Symbian OS error code.

   160 // -----------------------------------------------------------------------------

   161 //

   162 LOCAL_C TInt Startup( void ) 

   163     {

   164     TInt error = KErrNone;

   165     CTrapCleanup* trap = CTrapCleanup::New();

   166     CActiveScheduler* scheduler = new CActiveScheduler();

   167     

   168     if ( trap && scheduler )

   169         {

   170         CActiveScheduler::Install( scheduler );

   171     

   172         error = StartDBServer();

   173         }

   174     else

   175         {

   176         error = KErrNoMemory;

   177         }

   178 

   179     delete scheduler; 

   180     scheduler = NULL;

   181     

   182     delete trap;

   183     trap = NULL;

   184     

   185     if ( error )

   186         {

   187         // Something went wrong. Release the client (if any).

   188         SignalClient();

   189         

   190         if ( error == KErrAlreadyExists )

   191             {

   192             error = KErrNone;

   193             }

   194         }

   195        

   196     return error;

   197     }

   198 

   199 // -----------------------------------------------------------------------------

   200 // Function SignalClient().

   201 // Signal the waiting client (one of them if any exists).

   202 // -----------------------------------------------------------------------------

   203 //

   204 void SignalClient( void )

   205     {

   206     RSemaphore semaphore;

   207     if ( !semaphore.OpenGlobal( DRMEngine::KDRMSemaphore ) )

   208         {

   209         semaphore.Signal();

   210         semaphore.Close();

   211         }

   212     }

   213 

   214 // -----------------------------------------------------------------------------

   215 // Function StartDBServer().

   216 // This function starts the actual server under TRAP harness and starts

   217 // waiting for connections. This function returns only if there has been

   218 // errors during server startup or the server is stopped for some reason.

   219 // 

   220 // Returns: TInt: Symbian OS error code.

   221 // -----------------------------------------------------------------------------

   222 TInt StartDBServer( void ) 

   223     {

   224     TInt error = KErrNone;

   225     CDRMRightsServer* server = NULL;

   226     TUint8 count = 0;

   227     

   228     do

   229         {

   230         DRMLOG2( _L( "RightsServer.exe: StartDBServer: %d" ), error );

   231         

   232         ++count;

   233         

   234         TRAP( error, ( server = CDRMRightsServer::NewL() ) );

   235         

   236         if ( error ) 

   237             {

   238             User::After( TTimeIntervalMicroSeconds32(KWaitingTime) );

   239             }

   240         

   241         } while( error && ( count <= KMaxStartTries ) );

   242         

   243     if( error ) 

   244         {

   245         DRMLOG2( _L( "RightsServer.exe: CDRMRightsServer::NewL failed: %d " ), error );

   246         // Failed

   247         return error;

   248         }

   249     

   250     // Release the semaphore if necessary.

   251     SignalClient();

   252    

   253     // Start waiting for connections

   254     CActiveScheduler::Start();

   255     

   256     // Dying...

   257     // Delete CDRMRigntsServer

   258         

   259     DRMLOG( _L( "RightsServer.exe: DB server dying..." ) );

   260 

   261     delete server;

   262     

   263     return KErrNone;

   264     }

   265 

   266 #ifdef DRM_USE_SERIALNUMBER_URI

   267 // -----------------------------------------------------------------------------

   268 // Function DoUnloadPhoneModule

   269 // Unload phone module

   270 // -----------------------------------------------------------------------------

   271 //

   272 void DoUnloadPhoneModule( TAny* aAny )

   273     {

   274     __ASSERT_DEBUG( aAny, User::Invariant() );

   275     TUnloadModule* module = ( TUnloadModule* ) aAny;

   276     module->iServer->UnloadPhoneModule( *( module->iName ) );

   277     }

   278 #endif

   279 

   280 #ifdef USE_RO_IMPORT

   281 // -----------------------------------------------------------------------------

   282 // PointerArrayResetDestroyAndClose

   283 // Template method used to push RPointerArrays to the cleanup stack. Takes

   284 // care of deleting all pointers in the array.

   285 // -----------------------------------------------------------------------------

   286 //

   287 template<class S>

   288 void PointerArrayResetDestroyAndClose(TAny* aPtr)

   289     {

   290     (reinterpret_cast<RPointerArray<S>*>(aPtr))->ResetAndDestroy();

   291     (reinterpret_cast<RPointerArray<S>*>(aPtr))->Close();

   292     }

   293 #endif    

   294 

   295 // ============================ MEMBER FUNCTIONS ===============================

   296 

   297 // -----------------------------------------------------------------------------

   298 // CDRMRightsServer::NewLC

   299 // Two-phased constructor.

   300 // -----------------------------------------------------------------------------

   301 //

   302 CDRMRightsServer* CDRMRightsServer::NewL()

   303     {

   304     CDRMRightsServer* self = new( ELeave ) CDRMRightsServer();

   305     

   306     CleanupStack::PushL( self );

   307     

   308     self->ConstructL();

   309     

   310     CleanupStack::Pop( self );

   311     

   312     return self;

   313     }

   314 

   315 // -----------------------------------------------------------------------------

   316 // Destructor

   317 // -----------------------------------------------------------------------------

   318 CDRMRightsServer::~CDRMRightsServer() 

   319     {

   320     DRMLOG( _L( "CDRMRightsServer::~" ) );

   321     

   322     delete iIMEI; iIMEI = NULL;

   323     

   324     delete iIMSI; iIMSI = NULL;

   325     

   326     delete iDb; iDb = NULL;

   327     

   328     iClock.Close();

   329     iCache.Close();

   330     

   331     iMeteringDb.Close();

   332     

   333     iFs.Close();

   334     iActiveCountConstraints.ResetAndDestroy();

   335     iActiveCountConstraints.Close();

   336     

   337     delete iBackupObserver;

   338     delete iBackupHandler;    

   339     delete iActiveBackupClient;

   340     delete iDbWatcher;

   341 

   342 #if 0    

   343     // Close and delete the shared data client

   344     if( iSharedDataClient ) 

   345         {

   346         iSharedDataClient->Close();

   347         delete iSharedDataClient;

   348         iSharedDataClient = NULL;

   349         }

   350 #endif

   351 

   352     if( iNotifier )

   353         {

   354         delete iNotifier; iNotifier = NULL;

   355         }

   356         

   357     //An empty semaphore

   358     RSemaphore semaphore;

   359     }

   360 

   361 // -----------------------------------------------------------------------------

   362 // CDRMRightsServer::GetSecureTime

   363 // Fetch the time from (secure) source.

   364 // -----------------------------------------------------------------------------

   365 //

   366 TBool CDRMRightsServer::GetSecureTime( TTime& aTime ) const

   367     {

   368     DRMClock::ESecurityLevel secLevel = DRMClock::KInsecure;

   369 	

   370 	TInt timezone( 0 );

   371 	

   372     iClock.GetSecureTime( aTime, timezone, secLevel );

   373 	

   374     if( secLevel == DRMClock::KSecure )

   375         {

   376         DRMLOG( _L( "CDRMRightsServer::GetSecureTime: Time is secure\r\n" ) );

   377         return ETrue;		

   378         }	

   379         

   380     DRMLOG( _L( "CDRMRightsServer::GetSecureTime: Time is not secure\r\n" ) );    	

   381 

   382     return EFalse;

   383     }

   384 

   385 // -----------------------------------------------------------------------------

   386 // CDRMRightsServer::Notifier

   387 // Return a handle to DRM Notifier.

   388 // -----------------------------------------------------------------------------

   389 //

   390 CDRMNotifier& CDRMRightsServer::Notifier()

   391     {

   392     return *iNotifier;

   393     }

   394 

   395 // -----------------------------------------------------------------------------

   396 // CDRMRightsServer::Notifier

   397 // Return a handle to DRM Notifier.

   398 // -----------------------------------------------------------------------------

   399 //

   400 CDRMRightsDB& CDRMRightsServer::Database()

   401     {

   402     return *iDb;

   403     }

   404 

   405 RFs& CDRMRightsServer::FileServerSession()

   406     {

   407     return iFs;

   408     }

   409     

   410     

   411 RDRMReplayCache& CDRMRightsServer::ReplayCache()

   412     {

   413     return iCache;

   414     }

   415 

   416 

   417 RDrmMeteringDb& CDRMRightsServer::MeteringDatabase()

   418     {

   419     return iMeteringDb;

   420     }

   421 

   422 // -----------------------------------------------------------------------------

   423 // CDRMRightsServer::HandleNotifyL

   424 // Forward the event to the database.

   425 // -----------------------------------------------------------------------------

   426 //

   427 void CDRMRightsServer::HandleNotifyL(const TUid /*aUid*/,

   428                                      const TDesC& /*aKey*/,

   429                                      const TDesC& /*aValue*/)  

   430     {   

   431     /* XXX Backup via Publish/Subscribe

   432     __ASSERT_DEBUG( iDb, User::Invariant() );

   433     TInt value = -1;

   434     TLex16 parser( aValue );

   435 

   436     if ( aUid == KSDUidSystem )

   437         {

   438         // Check if it's a backup / restore status event

   439         if( !aKey.Compare( KBackupRestoreStatus ) )

   440             {

   441             User::LeaveIfError( parser.Val( value ) );

   442             if( value == 3 ) // Complete

   443                 {

   444                 iDb->MergeDBL();

   445                 }

   446             }

   447         // Check if it's a drm backup restore status event

   448         else if ( aUid == KSDUidSystem )

   449             {

   450             if( !aKey.Compare( KDRMBackupRestoreStatus ) )

   451                 {

   452                 User::LeaveIfError( parser.Val( value ) );

   453 

   454                 if( value == 1 ) // PrepareForBackup

   455                     {

   456                     TRAPD( error, iDb->BackupDBL( KNullDesC, 

   457                                                   KNullDesC8 ) );

   458                     // Notify that it's done

   459                     User::LeaveIfError( iSharedDataClient->AssignToTemporaryFile(

   460                                         KSDUidSystem ) );

   461                     User::LeaveIfError( iSharedDataClient->SetInt( 

   462                                         KDRMBackupRestoreStatus, 0 ) );

   463                     iSharedDataClient->Flush();

   464                     }

   465                 }

   466             }

   467         }

   468     */

   469     }

   470 

   471 // -----------------------------------------------------------------------------

   472 // CDRMRightsServer::RunErrorL

   473 // From CActive. Complete the request and restart the scheduler.

   474 // -----------------------------------------------------------------------------

   475 //

   476 TInt CDRMRightsServer::RunError( TInt aError ) 

   477     {

   478     DRMLOG2( _L( "CDRMRightsServer::RunError: %d" ), aError );

   479 

   480     // Inform the client.

   481     if ( !Message().IsNull() )

   482         {

   483         Message().Complete( aError );

   484         }

   485     

   486     // Restart the scheduler.

   487     ReStart();

   488     

   489     // Error handled.

   490     return KErrNone;

   491     }

   492 

   493 // -----------------------------------------------------------------------------

   494 // CDRMRightsServer::NewSessionL

   495 // Called when a client requires a new instance.

   496 // -----------------------------------------------------------------------------

   497 CSession2* CDRMRightsServer::NewSessionL( const TVersion& aVersion,

   498                                           const RMessage2& /*aMessage*/ ) const

   499     {

   500     DRMLOG( _L( "CDRMRightsServer::NewSessionL" ) );

   501 

   502     if ( ! User::QueryVersionSupported( TVersion( DRMEngine::KServerMajorVersion,

   503         DRMEngine::KServerMinorVersion,

   504         DRMEngine::KServerBuildVersion ), 

   505         aVersion ) ) 

   506         {

   507         // Sorry, no can do.

   508         User::Leave( KErrNotSupported );

   509         }

   510 

   511     DRMLOG( _L( "CDRMRightsServer::NewSessionL: Creating a new session" ) );

   512 

   513     return CDRMDbSession::NewL();

   514     }

   515 // -----------------------------------------------------------------------------

   516 // CDRMRightsServer::CDRMRightsServer

   517 // C++ default constructor can NOT contain any code, that

   518 // might leave.

   519 // -----------------------------------------------------------------------------

   520 //

   521 CDRMRightsServer::CDRMRightsServer() : 

   522     CServer2( EPriorityStandard ),

   523     iIMEI( NULL ),

   524     iArmed( EFalse ),    

   525     iIMSI( NULL ),

   526     iGetImsi( ETrue )

   527     {

   528     // Nothing

   529     }

   530     

   531 // -----------------------------------------------------------------------------

   532 // CDRMRightsServer::ConstructL

   533 // Symbian 2nd phase constructor can leave.

   534 // -----------------------------------------------------------------------------

   535 //

   536 void CDRMRightsServer::ConstructL() 

   537     {

   538     DRMLOG( _L( "CDRMRightsServer::ConstructL" ) );

   539 

   540     TDRMKey key;

   541     RSemaphore semaphore;

   542     RProcess currentprocess;

   543     

   544     // Ignore errors

   545     User::RenameThread( KRightsServerThread );

   546     User::LeaveIfError( iFs.Connect() );

   547     

   548 #ifndef RD_MULTIPLE_DRIVE

   549     

   550     // Ignore errors

   551     iFs.MkDirAll( KDRMDbTempPath );

   552     

   553 #else //RD_MULTIPLE_DRIVE

   554     

   555     TFileName tempPath;

   556     TFileName tempPath2;

   557     TFileName tempRemovablePath;

   558     TInt driveNumber( -1 );

   559     TChar driveLetter;

   560     TChar driveLetterRemovable;

   561     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultSystem, driveNumber );

   562 	iFs.DriveToChar( driveNumber, driveLetter );

   563 	

   564 	tempPath.Format( KDbTempPath, (TUint)driveLetter );

   565     

   566     // Ignore errors

   567     iFs.MkDirAll( tempPath );

   568     

   569 #endif

   570         

   571     DRMLOG( _L( "CDRMRightsServer::ConstructL: SharedDataClient" ) );

   572 

   573     // Create and instance of the shared data client

   574     // iSharedDataClient = new (ELeave) RSharedDataClient(this);

   575 

   576     // Connecting to the shared data server

   577     // User::LeaveIfError(iSharedDataClient->Connect());

   578 

   579     /* XXX Backup via Publish/Subscribe

   580     User::LeaveIfError(iSharedDataClient->NotifyChange(

   581         KSDUidSystem, &KBackupRestoreStatus ) );

   582     User::LeaveIfError(iSharedDataClient->NotifyChange(

   583         KSDUidSystem, &KDRMBackupRestoreStatus) );

   584     */  

   585       

   586       

   587     GetDbKeyL( key );

   588     

   589     

   590     DRMLOG( _L( "CDRMRightsServer::ConstructL: database" ) );

   591 

   592     GetIMEIL();

   593     

   594     // Create the imsi pointer array:

   595     iIMSI = CDRMPointerArray<HBufC8>::NewL();

   596     iIMSI->SetAutoCleanup(ETrue);

   597     

   598     GetIMSIL();

   599     

   600 #ifndef RD_MULTIPLE_DRIVE

   601     

   602     iDb = CDRMRightsDB::NewL( iFs, KRightsDir, key, *iIMEI );

   603     

   604 #else //RD_MULTIPLE_DRIVE

   605     

   606     tempPath.Format( KRightsDir, (TUint)driveLetter );

   607     

   608     iDb = CDRMRightsDB::NewL( iFs, tempPath, key, *iIMEI );

   609     

   610 #endif

   611         

   612     key.FillZ();

   613         

   614     DRMLOG( _L( "CDRMRightsServer::ConstructL: DB started." ) );

   615 

   616     DRMLOG( _L( "CDRMRightsServer::ConstructL: Starting Notifier ." ) );

   617         

   618     User::LeaveIfError( semaphore.CreateGlobal( KDRMEngCommonSemaphore, 0 ) );

   619     CleanupClosePushL( semaphore );

   620     

   621     StartThreadL( DRMNotifier::KServerName, StartupNotifier, semaphore );

   622     DRMLOG( _L( "CDRMRightsServer::ConstructL: Notifier thread created." ) );

   623     

   624     StartThreadL( Roap::KServerName, StartupRoapStorage, semaphore );

   625     DRMLOG( _L( "CDRMRightsServer::ConstructL: ROAP thread created." ) );

   626     

   627 #ifdef __DRM_CLOCK

   628     StartThreadL( DRMClock::KServerName, StartupClock, semaphore );

   629     DRMLOG( _L( "CDRMRightsServer::ConstructL: clock thread created." ) );

   630 #endif

   631     

   632     CleanupStack::PopAndDestroy(); // semaphore

   633     

   634     iNotifier = CDRMNotifier::NewL();

   635     

   636     iCache.Set( iFs );

   637 

   638 #ifndef RD_MULTIPLE_DRIVE

   639     

   640     iCache.InitL( KTimedReplayCacheFile, KPlainReplayCacheFile );

   641 

   642 #ifdef RD_DRM_METERING               

   643     iMeteringDb.Set( iFs );

   644     iMeteringDb.InitL( KMeteringDataBaseFile );

   645 #endif

   646     

   647 #else //RD_MULTIPLE_DRIVE

   648     

   649     tempPath.Format( KTimedReplayCacheFile, (TUint)driveLetter );

   650     tempPath2.Format( KPlainReplayCacheFile, (TUint)driveLetter );

   651     

   652     iCache.InitL( tempPath, tempPath2 );

   653     

   654 #ifdef RD_DRM_METERING               

   655     

   656     tempPath.Format( KMeteringDataBaseFile, (TUint)driveLetter );

   657     

   658     iMeteringDb.Set( iFs );

   659     iMeteringDb.InitL( tempPath );

   660 

   661 #endif

   662     

   663 #endif

   664     

   665     User::LeaveIfError( iClock.Connect() );

   666 

   667     // xoma header list creation

   668     iXOmaHeaders = new (ELeave) RPointerArray< CDRMXOma >();

   669     

   670     // p/s

   671     iBackupObserver = CDRMBackupObserver::NewL( *(const_cast<CDRMRightsServer*>(this)));

   672     iBackupObserver->Start();

   673     

   674 #ifdef USE_RO_IMPORT

   675     // Import any OMA DRM 1.0 RO in the import directory, ignore all errors (except

   676     // when checking the default removable mass storage)

   677     TInt r = KErrNone;

   678     

   679 #ifndef RD_MULTIPLE_DRIVE

   680     

   681     TRAP( r, ImportRightsObjectsL( KInternalImportDir ) );

   682     TRAP( r, ImportRightsObjectsL( KUserDiskImportDir ) );

   683     

   684 #else //RD_MULTIPLE_DRIVE

   685     

   686     tempPath.Format( KInternalImportDir, (TUint)driveLetter );

   687     

   688     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, driveNumber );

   689 	iFs.DriveToChar( driveNumber, driveLetter );

   690     

   691 	// Default mass storage is usually eMMC

   692     tempPath2.Format( KUserDiskImportDir, (TUint)driveLetter );

   693     

   694     // Find out if a removable mass storage also exists

   695     r = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, driveNumber );

   696     iFs.DriveToChar( driveNumber, driveLetterRemovable );

   697     

   698     // Import is not needed from the default removable mass storage drive if the drive 

   699     // letter of the default mass storage and the default removable mass storage are 

   700     // the same or the removable mass storage is not supported

   701     if ( ( driveLetter != driveLetterRemovable ) && ( r == KErrNone ) ) 

   702         {

   703         tempRemovablePath.Format( KUserRemovableDiskImportDir, (TUint)driveLetterRemovable );

   704         TRAP( r, ImportRightsObjectsL( tempRemovablePath ) );

   705         }

   706     

   707     TRAP( r, ImportRightsObjectsL( tempPath ) );

   708     TRAP( r, ImportRightsObjectsL( tempPath2 ) );

   709     

   710 #endif

   711     

   712 #endif

   713 

   714     // Add the server to the scheduler.

   715     StartL( DRMEngine::KServerName );

   716 

   717     // Start watching our RDB

   718     iDbWatcher = CDbWatcher::NewL( *this );

   719     iDbWatcher->StartWatching();

   720     

   721     // Start watching the helper server

   722     iProcWatcher = CProcWatcher::NewL( *this, _L( "*DcfRepSrv*" ), _L( "DcfRepSrv" ) );

   723     iProcWatcher->StartWatching();

   724     

   725     // Ready to watch

   726     iArmed = ETrue;

   727 

   728     __UHEAP_MARK;

   729     TRAP( r, FeatureManager::InitializeLibL() );

   730     if( !r && FeatureManager::FeatureSupported( KFeatureIdWindowsMediaDrm ) ) 

   731         {

   732         static const TInt KGateOrdinal = 1;

   733         RLibrary library;

   734         r = library.Load( KWmDrmClientWrapperName );

   735         if( !r )

   736             {

   737             CWmDrmClientWrapper* wrapper = NULL;

   738             TLibraryFunction function = library.Lookup( KGateOrdinal );

   739             if( function != NULL )

   740                 {

   741                 __UHEAP_MARK;

   742                 TRAP( r, wrapper = reinterpret_cast<CWmDrmClientWrapper*>( function() ) );

   743                 if( !r )

   744                     {

   745                     r = wrapper->Connect();

   746                     }

   747                 delete wrapper;

   748                 __UHEAP_MARKEND;

   749                 }

   750             }

   751         library.Close();    

   752         }

   753     FeatureManager::UnInitializeLib();

   754     __UHEAP_MARKEND;  

   755     }

   756  

   757 // -----------------------------------------------------------------------------   

   758 // CDRMRightsServer::StartThreadL

   759 // Start a new thread.

   760 // -----------------------------------------------------------------------------    

   761 void CDRMRightsServer::StartThreadL( const TDesC& aThreadName,

   762                                      TThreadFunction aFunc,

   763                                      RSemaphore& aSemaphore )

   764     {

   765     RThread thread;

   766     

   767     User::LeaveIfError( 

   768           thread.Create( aThreadName,

   769                          aFunc, 

   770                          KDefaultStackSize,

   771                          KMinHeapSize, 

   772                          KMaxHeapsize,

   773                          NULL ) );

   774     

   775     thread.Resume();

   776     

   777     aSemaphore.Wait();

   778     

   779     thread.Close();

   780     }

   781     

   782 // -----------------------------------------------------------------------------

   783 // CDRMRightsServer::GetDbKeyL

   784 // Fetches the rights database key from Wallet or uses a constant 

   785 // key if Wallet is not supported.

   786 // -----------------------------------------------------------------------------

   787 //

   788 void CDRMRightsServer::GetDbKeyL( TDRMKey& aKey  ) 

   789     {

   790     TInt r = KErrNone;

   791     

   792     DRMLOG( _L( "CDRMRightsServer::GetDbKey" ) );

   793     MDrmKeyStorage* storage = DrmKeyStorageNewL();

   794     TRAP( r, storage->GetDeviceSpecificKeyL( aKey ) );

   795     delete storage;

   796     User::LeaveIfError( r );

   797     }

   798 

   799 // -----------------------------------------------------------------------------

   800 // CDRMRightsServer::GenerateKeyL

   801 // Generates the actual key based on the given key seed.

   802 // -----------------------------------------------------------------------------

   803 //

   804 void CDRMRightsServer::GenerateKeyL( HBufC*& aKeySeed, 

   805                                     TDRMKey& aKey ) const

   806     {

   807     __ASSERT_ALWAYS( aKeySeed->Size() >= KDRMKeyLength, 

   808         User::Leave( KErrUnderflow ) );

   809     

   810     TPtrC8 key( reinterpret_cast< TUint8* >( const_cast< TUint16* >( aKeySeed->Ptr() ) ),

   811                 KDRMKeyLength );

   812     

   813     aKey = key;

   814     }

   815 

   816 

   817 // -----------------------------------------------------------------------------

   818 // CDRMRightsServer::XOmaHeaders()

   819 // return the pointer of the X-Oma headers list 

   820 // -----------------------------------------------------------------------------

   821 //

   822 RPointerArray< CDRMXOma >& CDRMRightsServer::XOmaHeaders( void )

   823 	{

   824 	return *iXOmaHeaders;

   825 	}

   826 

   827 

   828 

   829 // -----------------------------------------------------------------------------

   830 // CDRMRightsServer::GetIMEIL

   831 // -----------------------------------------------------------------------------

   832 //

   833 const TDesC& CDRMRightsServer::GetIMEIL()

   834     {

   835     if ( iIMEI )

   836         {

   837         return *iIMEI;

   838         }

   839     

   840 #ifdef DRM_USE_SERIALNUMBER_URI

   841     TInt error( KErrNone );

   842     TInt count( 0 );

   843     TInt count2( 0 );

   844     TUint32 caps( 0 );

   845     TBool found (EFalse);

   846     

   847     RTelServer etelServer;

   848     RMobilePhone phone;

   849     

   850     TUint KMaxImeiTries = 5;

   851     

   852     for ( TUint8 i = 0; i < KMaxImeiTries; ++i )

   853         {

   854         error = etelServer.Connect();

   855         if ( error )

   856             {

   857             User::After( TTimeIntervalMicroSeconds32( KWaitingTime ) );

   858             }

   859         else 

   860             {

   861             break;

   862             }

   863         }

   864     

   865     User::LeaveIfError( error );

   866     CleanupClosePushL( etelServer );

   867     

   868     User::LeaveIfError( etelServer.LoadPhoneModule( KMmTsyModuleName ) );  

   869     

   870     TUnloadModule unload;

   871     unload.iServer = &etelServer;

   872     unload.iName = &KMmTsyModuleName;

   873     

   874     TCleanupItem item( DoUnloadPhoneModule, &unload );

   875     CleanupStack::PushL( item );

   876     User::LeaveIfError( etelServer.EnumeratePhones( count ) );

   877         

   878     for ( count2 = 0; count2 < count && !found; ++count2 )

   879         {

   880         RTelServer::TPhoneInfo phoneInfo;

   881         User::LeaveIfError( etelServer.GetTsyName( count2, phoneInfo.iName ) );

   882         

   883         if ( phoneInfo.iName.CompareF(KMmTsyModuleName()) == 0 )   

   884            {

   885             User::LeaveIfError( etelServer.GetPhoneInfo( count2, phoneInfo ) );

   886             User::LeaveIfError( phone.Open( etelServer, phoneInfo.iName ) );

   887             CleanupClosePushL( phone );

   888             found = ETrue;

   889             }

   890         }

   891 

   892     if ( !found )

   893         {

   894         // Not found.

   895         User::Leave( KErrNotFound );

   896         }

   897    

   898     User::LeaveIfError( phone.GetIdentityCaps( caps ) );

   899     if ( caps & RMobilePhone::KCapsGetSerialNumber )

   900         {

   901         RMobilePhone::TMobilePhoneIdentityV1 id;

   902         TRequestStatus status;

   903     

   904         phone.GetPhoneId( status, id );

   905         

   906         User::WaitForRequest( status );

   907         

   908         User::LeaveIfError( status.Int() );

   909         

   910         iIMEI = id.iSerialNumber.AllocL();

   911         

   912         CleanupStack::PopAndDestroy( 3 ); // phone, item, etelServer

   913         

   914         HBufC8* buf = HBufC8::NewL( iIMEI->Size() );

   915         TPtr8 ptr( buf->Des() );

   916         ptr.Copy( *iIMEI );

   917         

   918         DRMLOG(_L("IMEI:"));

   919         DRMLOGHEX(ptr);

   920         delete buf;

   921     

   922         return *iIMEI;

   923         }

   924     

   925     User::Leave( KErrNotFound );

   926     

   927     // Never happens...

   928     return *iIMEI; 

   929     

   930 #else

   931     _LIT( KDefaultSerialNumber, "123456789123456789" );

   932     iIMEI = KDefaultSerialNumber().AllocL();

   933         

   934     return *iIMEI;

   935 #endif

   936     }

   937 

   938 // -----------------------------------------------------------------------------

   939 // CDRMRightsServer::GetIMSIL

   940 // -----------------------------------------------------------------------------

   941 //

   942 const CDRMPointerArray<HBufC8>& CDRMRightsServer::GetIMSIL()

   943     {

   944     

   945     if ( !iGetImsi )

   946         {

   947         return *iIMSI;

   948         }

   949 

   950 #ifndef __WINS__   

   951     TInt error( KErrNone );

   952     TInt count( 0 );

   953     TInt count2( 0 );

   954     TUint32 caps( 0 );

   955     TBool found (EFalse);

   956     HBufC8* imsi = NULL;

   957     HBufC8* imsiNumber = NULL;

   958     

   959     RTelServer etelServer;

   960     RMobilePhone phone;

   961     

   962     TUint KMaxImeiTries = 5;    

   963     for ( TUint8 i = 0; i < KMaxImeiTries; ++i )

   964         {

   965         error = etelServer.Connect();

   966         if ( error )

   967             {

   968             User::After( TTimeIntervalMicroSeconds32( KWaitingTime ) );

   969             }

   970         else 

   971             {

   972             break;

   973             }

   974         }

   975     

   976     User::LeaveIfError( error );

   977     CleanupClosePushL( etelServer );     

   978     User::LeaveIfError( etelServer.LoadPhoneModule( KMmTsyModuleName ) );  

   979     

   980     TUnloadModule unload;

   981     unload.iServer = &etelServer;

   982     unload.iName = &KMmTsyModuleName;

   983     

   984     TCleanupItem item( DoUnloadPhoneModule, &unload );

   985     CleanupStack::PushL( item );

   986     

   987     User::LeaveIfError( etelServer.EnumeratePhones( count ) );

   988         

   989     for ( count2 = 0; count2 < count && !found; ++count2 )

   990         {

   991         RTelServer::TPhoneInfo phoneInfo;

   992         User::LeaveIfError( etelServer.GetTsyName( count2, phoneInfo.iName ) );

   993         

   994         if ( phoneInfo.iName.CompareF(KMmTsyModuleName()) == 0 )   

   995            {

   996             User::LeaveIfError( etelServer.GetPhoneInfo( count2, phoneInfo ) );

   997             User::LeaveIfError( phone.Open( etelServer, phoneInfo.iName ) );

   998             CleanupClosePushL( phone );

   999             found = ETrue;

  1000             }

  1001         }

  1002 

  1003     if ( !found )

  1004         {

  1005         // Not found.

  1006         User::Leave( KErrNotFound );

  1007         }

  1008    

  1009  

  1010     User::LeaveIfError( phone.GetIdentityCaps( caps ) );

  1011 

  1012     if( caps & RMobilePhone::KCapsGetSubscriberId )

  1013         {

  1014         RMobilePhone::TMobilePhoneSubscriberId imsiId;        

  1015         TRequestStatus status;

  1016     

  1017         phone.GetSubscriberId( status, imsiId );

  1018         

  1019         User::WaitForRequest( status );

  1020         

  1021         if( ! status.Int() )

  1022             {             

  1023             imsi = HBufC8::NewMaxLC( imsiId.Length() + KImsiId().Size() );

  1024             TPtr8 imsiPtr(const_cast<TUint8*>(imsi->Ptr()), 0, imsi->Size());

  1025       

  1026             imsiNumber = CnvUtfConverter::ConvertFromUnicodeToUtf8L( imsiId );

  1027             CleanupStack::PushL( imsiNumber );

  1028             

  1029             imsiPtr.Copy( KImsiId() );

  1030             imsiPtr.Append( *imsiNumber );

  1031             CleanupStack::PopAndDestroy(); // imsiNumber

  1032             }

  1033         else

  1034             {            

  1035             imsi = NULL;

  1036             }

  1037         }

  1038     else

  1039         {         

  1040         imsi = NULL;

  1041         } 

  1042     

  1043     

  1044     // Clean up whatever is in there

  1045     iIMSI->ResetAndDestroy();

  1046     

  1047     if( imsi ) 

  1048         { 

  1049         // if we got it we wont try again             

  1050         iIMSI->AppendL( imsi );

  1051         CleanupStack::Pop(); // imsi

  1052         iGetImsi = EFalse;            

  1053         }

  1054 

  1055     // Check for possible extra IMSI individual constraints

  1056     AppendExtendedIndividualConstraintsL(&phone);

  1057     

  1058     CleanupStack::PopAndDestroy(); // phone

  1059     CleanupStack::PopAndDestroy(); // cleanup item

  1060     CleanupStack::PopAndDestroy(); // etel server

  1061 

  1062     return *iIMSI; 

  1063     

  1064 #else

  1065     HBufC8* imsi = NULL;

  1066     

  1067     if( iGetImsi ) 

  1068         {

  1069         iGetImsi = EFalse;

  1070         _LIT8( KDefaultSerialNumber, "IMSI:123456789123456789" );

  1071         imsi = KDefaultSerialNumber().AllocLC();

  1072         iIMSI->AppendL( imsi );

  1073         CleanupStack::Pop();        

  1074         AppendExtendedIndividualConstraintsL();

  1075         }

  1076 

  1077         

  1078     return *iIMSI;

  1079 #endif // __WINS__

  1080     }

  1081 

  1082 // -----------------------------------------------------------------------------   

  1083 // CDRMRightsServer::AppendExtendedIndividualConstraintsL

  1084 // If the extension DLL exists it is loaded and used to obtain additional

  1085 // valid individual constraints

  1086 // -----------------------------------------------------------------------------    

  1087 void CDRMRightsServer::AppendExtendedIndividualConstraintsL(RMobilePhone* aMobilePhone)

  1088     {    	    	

  1089     // Load the externsion DLL

  1090     RLibrary lib;

  1091     

  1092 #ifndef RD_MULTIPLE_DRIVE

  1093     

  1094     if (lib.LoadRomLibrary(KDRMIndividualConstraintExtensionDll,KNullDesC)==KErrNone)

  1095     

  1096 #else //RD_MULTIPLE_DRIVE

  1097     

  1098     TInt driveNumber( -1 );

  1099     TChar driveLetter;

  1100     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRom, driveNumber );

  1101 	iFs.DriveToChar( driveNumber, driveLetter );

  1102 	

  1103 	TFileName individualConstraindExtensionDll;

  1104 	individualConstraindExtensionDll.Format( 

  1105 	                    KIndividualConstraintExtensionDll, (TUint)driveLetter );

  1106     

  1107     if ( lib.LoadRomLibrary( individualConstraindExtensionDll, KNullDesC ) == KErrNone )

  1108     

  1109 #endif

  1110     

  1111     	{

  1112         CleanupClosePushL(lib);

  1113 

  1114         // Get first exported ordinal - factory method returning 

  1115         // MDRMIndividualConstraintExtension*

  1116         TLibraryFunction factory = lib.Lookup(1); 

  1117 

  1118         if (factory)

  1119             {

  1120             // Instantiate object

  1121             MDRMIndividualConstraintExtension* extendedConstraints = 

  1122                 reinterpret_cast<MDRMIndividualConstraintExtension*>(factory());

  1123 

  1124             if (extendedConstraints)

  1125                 {

  1126 			    CleanupStack::PushL(TCleanupItem(Release,extendedConstraints));

  1127                 extendedConstraints->AppendConstraintsL(*iIMSI,aMobilePhone);

  1128 			    CleanupStack::PopAndDestroy(extendedConstraints); //calls Release

  1129                 }

  1130             }

  1131 

  1132         // unload library

  1133         CleanupStack::PopAndDestroy(&lib); //close

  1134         }