1 /*

     2 * Copyright (c) 2004 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:  Datatype for Rights Constraint

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <s32file.h>

    22 #include <s32std.h>

    23 #include <caf/caf.h>

    24 

    25 #include "DRMContextDB.h"

    26 #include "DRMRIContext.h"

    27 #include "DRMDomainContext.h"

    28 

    29 

    30 // EXTERNAL DATA STRUCTURES

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES  

    33 

    34 // CONSTANTS

    35 

    36 // MACROS

    37 

    38 // LOCAL CONSTANTS AND MACROS

    39 

    40 // MODULE DATA STRUCTURES

    41 

    42 // LOCAL FUNCTION PROTOTYPES

    43 

    44 // FORWARD DECLARATIONS

    45 

    46 // ============================= LOCAL FUNCTIONS ===============================

    47 // ============================ MEMBER FUNCTIONS ===============================

    48 

    49 // -----------------------------------------------------------------------------

    50 // CDRMContextDB::NewLC

    51 // -----------------------------------------------------------------------------

    52 //

    53 CDRMContextDB* CDRMContextDB::NewLC( const TFileName& aRightsIssuerContextFile, 

    54                                      const TFileName& aDomainContextFile,

    55                                      RFs& aFileServer )

    56     {

    57     CDRMContextDB* self = new( ELeave ) CDRMContextDB( aFileServer );

    58     CleanupStack::PushL( self );

    59     self->ConstructL( aRightsIssuerContextFile, 

    60                       aDomainContextFile );

    61 

    62     return self;    

    63     };

    64     

    65 // -----------------------------------------------------------------------------

    66 // CDRMContextDB::NewL

    67 // -----------------------------------------------------------------------------

    68 //

    69 CDRMContextDB* CDRMContextDB::NewL( const TFileName& aRightsIssuerContextFile, 

    70                                     const TFileName& aDomainContextFile,

    71                                     RFs& aFileServer )

    72     {

    73     CDRMContextDB* self = NewLC( aRightsIssuerContextFile, 

    74                                  aDomainContextFile,  

    75                                  aFileServer );

    76     CleanupStack::Pop();	

    77     

    78     return self;    

    79     };

    80                                  

    81 // -----------------------------------------------------------------------------

    82 // CDRMContextDB::OpenLC

    83 // -----------------------------------------------------------------------------

    84 //

    85 CDRMContextDB* CDRMContextDB::OpenLC( const TFileName& aRightsIssuerContextFile, 

    86                                       const TFileName& aDomainContextFile,

    87                                       RFs& aFileServer )

    88     {

    89     CDRMContextDB* self = new( ELeave ) CDRMContextDB( aFileServer );

    90     CleanupStack::PushL( self );    

    91     self->ConstructL( aRightsIssuerContextFile, 

    92                       aDomainContextFile );

    93     

    94     return self;

    95     };    

    96     

    97 // -----------------------------------------------------------------------------

    98 // CDRMContextDB::OpenL

    99 // -----------------------------------------------------------------------------

   100 //

   101 CDRMContextDB* CDRMContextDB::OpenL( const TFileName& aRightsIssuerContextFile, 

   102                                      const TFileName& aDomainContextFile,

   103                                      RFs& aFileServer )

   104     {

   105     CDRMContextDB* self = OpenLC( aRightsIssuerContextFile, 

   106                                   aDomainContextFile,  

   107                                   aFileServer );

   108     CleanupStack::Pop();

   109     

   110     return self;    

   111     };    

   112     

   113 // -----------------------------------------------------------------------------

   114 // Destructor

   115 // -----------------------------------------------------------------------------

   116 // 

   117 CDRMContextDB::~CDRMContextDB()

   118     {

   119     // Permanent File Store

   120     if( iDomainStore )

   121         {

   122         delete iDomainStore;

   123         iDomainStore = NULL;

   124         }

   125         

   126     // Permanent File Store

   127     if( iRightsIssuerStore )

   128         {

   129         delete iRightsIssuerStore;

   130         iRightsIssuerStore = NULL;

   131         }

   132         

   133     // index array    

   134     iDomainArray.Close();

   135     

   136     // index array

   137     iRightsIssuerArray.Close();

   138     }; 

   139       

   140     

   141 // -----------------------------------------------------------------------------

   142 // CDRMContextDB::StoreDomainContextL

   143 // -----------------------------------------------------------------------------

   144 //

   145 void CDRMContextDB::StoreDomainContextL( const CDRMDomainContext& aContext )

   146     {

   147     TStreamId rootId;

   148     RStoreWriteStream stream;

   149     RStoreWriteStream rootStream;

   150     CDRMContextDB::TContextIndex searchData;

   151     TInt index;

   152     

   153     // Copy the domain id to the 

   154     searchData.iContextID.Copy( aContext.DomainID() );

   155     

   156     // get the id from the array if it doesn't exist, error

   157     index = iDomainArray.Find( searchData, TContextIndex::Match );    

   158     

   159     if( index == KErrNotFound )

   160         {

   161         TStreamId sid;

   162         // Create a new stream to the store:

   163         sid = stream.CreateLC( *iDomainStore );    

   164         

   165         searchData.iStreamID = sid.Value();

   166         

   167         // Externalize the domain data

   168         aContext.ExternalizeL( stream );

   169         stream.CommitL();

   170         

   171         // add the id to the array

   172         iDomainArray.Append( searchData );

   173         

   174         // Get the stream id of the root

   175         rootId = iDomainStore->Root();  

   176         

   177         // Open the root stream

   178         rootStream.ReplaceLC( *iDomainStore, rootId );

   179         

   180         // Store the changed index

   181         StoreDomainIndexL( rootStream );    

   182         rootStream.CommitL(); 

   183         

   184         // Commit the store

   185         iDomainStore->CommitL();                      

   186         

   187         CleanupStack::PopAndDestroy();  // root stream

   188         CleanupStack::PopAndDestroy();  // stream       

   189         }

   190     else

   191         {

   192         // open an existing one

   193         TStreamId sid( iDomainArray[ index ].iStreamID );

   194         

   195         // Replace the existing stream

   196         stream.ReplaceLC( *iDomainStore, sid );

   197     

   198         // Externalize the permission data

   199         aContext.ExternalizeL( stream );

   200     

   201         // Required by the ReplaceLC

   202         stream.CommitL();

   203 

   204         // Commit the store    

   205         iDomainStore->CommitL();

   206     

   207         CleanupStack::PopAndDestroy(); // stream    

   208         }

   209         

   210     iDomainStore->CompactL();

   211     iDomainStore->CommitL();

   212     };    

   213     

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

   215 // CDRMContextDB::FetchDomainContextL

   216 // -----------------------------------------------------------------------------

   217 //

   218 void CDRMContextDB::FetchDomainContextL( CDRMDomainContext& aContext ) const

   219     {   

   220     RStoreReadStream stream;

   221     TUint32 index = 0;

   222 

   223     TContextIndex searchData;

   224     

   225     // Copy the domain id to the search data

   226     searchData.iContextID.Copy( aContext.DomainID() );

   227     

   228     // get the id from the array if it doesn't exist, error

   229     User::LeaveIfError( index = iDomainArray.Find( searchData, 

   230                                                    TContextIndex::Match ) );

   231 

   232     TStreamId sid( iDomainArray[ index ].iStreamID );

   233     // Open the root stream

   234     

   235     stream.OpenLC( *iDomainStore, sid );

   236 

   237     // Read the common id

   238     aContext.InternalizeL( stream );

   239     

   240     // Close the stream

   241     CleanupStack::PopAndDestroy();        

   242     };

   243     

   244 // -----------------------------------------------------------------------------

   245 // CDRMContextDB::FetchDomainContextL 

   246 // For getting with the current id

   247 // -----------------------------------------------------------------------------

   248 //

   249 void CDRMContextDB::FetchDomainContextL( CDRMDomainContext& aContext, 

   250                                          const TInt32& aStream ) const

   251     {

   252     RStoreReadStream stream;

   253     TStreamId sid( aStream );

   254        

   255     stream.OpenLC( *iDomainStore, sid );

   256 

   257     // Read the common id

   258     aContext.InternalizeL( stream );

   259     

   260     // Close the stream

   261     CleanupStack::PopAndDestroy();        

   262     };    

   263     

   264 // -----------------------------------------------------------------------------

   265 // CDRMContextDB::DeleteDomainContextL

   266 // -----------------------------------------------------------------------------

   267 //

   268 void CDRMContextDB::DeleteDomainContextL( const TDesC8& aDomainID )

   269     {

   270     TStreamId rootId;

   271     TInt index = 0;

   272     RStoreWriteStream rootStream;

   273 

   274     TContextIndex searchData;

   275     

   276     // Copy the domain id to the search data

   277     // The last three digits presents the Domain generation

   278     searchData.iContextID.Copy( aDomainID.Mid(0, aDomainID.Length() - 3 ) );

   279     

   280     // get the id from the array if it doesn't exist, error

   281     index = iDomainArray.Find( searchData, TContextIndex::Match ); 

   282     

   283     User::LeaveIfError( index = iDomainArray.Find( searchData, 

   284                                                    TContextIndex::Match ) );

   285 

   286     TStreamId sid( iDomainArray[ index ].iStreamID );

   287 

   288     // Delete the stream from the store

   289     iDomainStore->DeleteL( sid );

   290             

   291     iDomainArray.Remove( index );       

   292     

   293     

   294     // Get the stream id of the root

   295     rootId = iDomainStore->Root();

   296     

   297     // Open the root stream

   298     rootStream.ReplaceLC( *iDomainStore, rootId );

   299         

   300     // Store the changed index

   301     StoreDomainIndexL( rootStream );    

   302     rootStream.CommitL();

   303 

   304     // Commit the store

   305     iDomainStore->CommitL();

   306     

   307     CleanupStack::PopAndDestroy();  // root stream

   308     

   309     // Compact and commit the changes

   310     iDomainStore->CompactL();

   311     iDomainStore->CommitL();        

   312     };

   313  

   314 // -----------------------------------------------------------------------------

   315 // CDRMContextDB::StoreRightsIssuerContextL

   316 // -----------------------------------------------------------------------------

   317 //

   318 void CDRMContextDB::StoreRightsIssuerContextL( const CDRMRIContext& aContext )

   319     {

   320     TStreamId rootId;

   321     RStoreWriteStream stream;

   322     RStoreWriteStream rootStream;

   323     TContextIndex searchData;

   324     TInt index;

   325     

   326     // Copy the domain id to the 

   327     searchData.iContextID.Copy( aContext.RIID() );

   328     

   329     // get the id from the array if it doesn't exist, error

   330     index = iRightsIssuerArray.Find( searchData, TContextIndex::Match );    

   331     

   332     if( index == KErrNotFound )

   333         {

   334         TStreamId sid;

   335         // Create a new stream to the store:

   336         sid = stream.CreateLC( *iRightsIssuerStore );    

   337         

   338         searchData.iStreamID = sid.Value();

   339         

   340         // Externalize the domain data

   341         aContext.ExternalizeL( stream );

   342         stream.CommitL();

   343         

   344         // add the id to the array

   345         iRightsIssuerArray.Append( searchData );

   346         

   347         // Get the stream id of the root

   348         rootId = iRightsIssuerStore->Root();  

   349         

   350         // Open the root stream

   351         rootStream.ReplaceLC( *iRightsIssuerStore, rootId );

   352         

   353         // Store the changed index

   354         StoreRightsIssuerIndexL( rootStream );    

   355         rootStream.CommitL(); 

   356         

   357         // Commit the store

   358         iRightsIssuerStore->CommitL();                      

   359         

   360         CleanupStack::PopAndDestroy();  // root stream

   361         CleanupStack::PopAndDestroy();  // stream       

   362         }

   363     else

   364         {

   365         // open an existing one

   366         TStreamId sid( iRightsIssuerArray[ index ].iStreamID );

   367         

   368         // Replace the existing stream

   369         stream.ReplaceLC( *iRightsIssuerStore, sid );

   370     

   371         // Externalize the permission data

   372         aContext.ExternalizeL( stream );

   373     

   374         // Required by the ReplaceLC

   375         stream.CommitL();

   376 

   377         // Commit the store    

   378         iRightsIssuerStore->CommitL();

   379     

   380         CleanupStack::PopAndDestroy(); // stream    

   381         }

   382         

   383     iRightsIssuerStore->CompactL();

   384     iRightsIssuerStore->CommitL();

   385     };    

   386     

   387 // -----------------------------------------------------------------------------

   388 // CDRMContextDB::FetchRightsIssuerContextL

   389 // -----------------------------------------------------------------------------

   390 //

   391 void CDRMContextDB::FetchRightsIssuerContextL( CDRMRIContext& aContext ) const

   392     {   

   393     RStoreReadStream stream;

   394     TUint32 index = 0;

   395 

   396     TContextIndex searchData;

   397     

   398     // Copy the domain id to the search data

   399     searchData.iContextID.Copy( aContext.RIID() );

   400     

   401     // get the id from the array if it doesn't exist, error

   402     User::LeaveIfError( index = iRightsIssuerArray.Find( searchData, 

   403                                                    TContextIndex::Match ) );

   404 

   405     TStreamId sid( iRightsIssuerArray[ index ].iStreamID );

   406     // Open the root stream

   407     

   408     stream.OpenLC( *iRightsIssuerStore, sid );

   409 

   410     // Read the common id

   411     aContext.InternalizeL( stream );

   412     

   413     // Close the stream

   414     CleanupStack::PopAndDestroy();        

   415     };

   416 

   417 // -----------------------------------------------------------------------------

   418 // CDRMContextDB::FetchRightsIssuerContextL 

   419 // For getting with the current id

   420 // -----------------------------------------------------------------------------

   421 //

   422 void CDRMContextDB::FetchRightsIssuerContextL( CDRMRIContext& aContext, 

   423                                                const TInt32& aStream ) const

   424     {

   425     RStoreReadStream stream;

   426     TStreamId sid( aStream );

   427        

   428     stream.OpenLC( *iRightsIssuerStore, sid );

   429 

   430     // Read the common id

   431     aContext.InternalizeL( stream );

   432     

   433     // Close the stream

   434     CleanupStack::PopAndDestroy();        

   435     };

   436 

   437 

   438 // -----------------------------------------------------------------------------

   439 // CDRMContextDB::FetchAllRightsIssuerContextsL

   440 // For getting with the current id

   441 // -----------------------------------------------------------------------------

   442 //

   443 void CDRMContextDB::FetchAllRightsIssuerContextsL( RPointerArray<CDRMRIContext>& aContexts) const

   444     {

   445     CDRMRIContext* context = NULL;

   446 

   447     // No RI contexts to retrieve

   448     if ( iRightsIssuerArray.Count() == 0) 

   449         {

   450         return;

   451         }

   452     

   453     for( TInt count = 0; count < iRightsIssuerArray.Count(); count++ )

   454         {

   455         context = CDRMRIContext::NewLC();

   456         FetchRightsIssuerContextL( *context, iRightsIssuerArray[ count ].iStreamID );

   457         aContexts.AppendL( context );

   458         CleanupStack::Pop( context );    

   459         }    

   460     }

   461 

   462 // -----------------------------------------------------------------------------

   463 // CDRMContextDB::UpdateRightsIssuerContextL

   464 // -----------------------------------------------------------------------------

   465 //

   466 void CDRMContextDB::UpdateRightsIssuerContextL( const CDRMRIContext& aContext )

   467     {

   468     TStreamId rootId;

   469     TInt index = 0;

   470     RStoreWriteStream stream;    

   471     CDRMRIContext* context = NULL;

   472     

   473     TContextIndex searchData;

   474     

   475     // Copy the domain id to the search data

   476     searchData.iContextID.Copy( aContext.RIID() );

   477     

   478     // get the id from the array if it doesn't exist, error

   479     User::LeaveIfError( index = iRightsIssuerArray.Find( searchData, 

   480                                                    TContextIndex::Match ) );

   481 

   482     TStreamId sid( iRightsIssuerArray[ index ].iStreamID );

   483     

   484     // Read the old context:    

   485     context = CDRMRIContext::NewLC();

   486     FetchRightsIssuerContextL( *context, iRightsIssuerArray[ index ].iStreamID );

   487     

   488     // update only the metering status:    

   489     context->SetMeteringStatus( aContext.IsMeteringAllowed() );

   490     

   491     // Replace the existing stream

   492     stream.ReplaceLC( *iRightsIssuerStore, sid );

   493     

   494     // Externalize the permission data

   495     context->ExternalizeL( stream );

   496      

   497     // Required by the ReplaceLC

   498     stream.CommitL();   

   499     

   500     // Commit the store    

   501     iRightsIssuerStore->CommitL();

   502     

   503     CleanupStack::PopAndDestroy(); // stream

   504     CleanupStack::PopAndDestroy(context);        

   505     

   506     

   507     // Compact and commit the changes

   508     iRightsIssuerStore->CompactL();

   509     iRightsIssuerStore->CommitL();        

   510     };

   511 

   512 

   513     

   514 // -----------------------------------------------------------------------------

   515 // CDRMContextDB::DeleteRightsIssuerContextL

   516 // -----------------------------------------------------------------------------

   517 //

   518 void CDRMContextDB::DeleteRightsIssuerContextL( const TDesC8& aStream )

   519     {

   520     TStreamId rootId;

   521     TInt index = 0;

   522     RStoreWriteStream rootStream;

   523 

   524     TContextIndex searchData;

   525     

   526     // Copy the domain id to the search data

   527     searchData.iContextID.Copy( aStream );

   528     

   529     // get the id from the array if it doesn't exist, error

   530     User::LeaveIfError( index = iRightsIssuerArray.Find( searchData, 

   531                                                    TContextIndex::Match ) );

   532 

   533     TStreamId sid( iRightsIssuerArray[ index ].iStreamID );

   534 

   535     // Delete the stream from the store

   536     iRightsIssuerStore->DeleteL( sid );

   537             

   538     iRightsIssuerArray.Remove( index );       

   539     

   540     

   541     // Get the stream id of the root

   542     rootId = iRightsIssuerStore->Root();

   543     

   544     // Open the root stream

   545     rootStream.ReplaceLC( *iRightsIssuerStore, rootId );

   546         

   547     // Store the changed index

   548     StoreDomainIndexL( rootStream );    

   549     rootStream.CommitL();

   550 

   551     // Commit the store

   552     iRightsIssuerStore->CommitL();

   553     

   554     CleanupStack::PopAndDestroy();  // root stream

   555     

   556     // Compact and commit the changes

   557     iRightsIssuerStore->CompactL();

   558     iRightsIssuerStore->CommitL();        

   559     }; 

   560                            

   561 // -----------------------------------------------------------------------------

   562 // CDRMContextDB::WhiteListURLExistsL

   563 // -----------------------------------------------------------------------------

   564 //

   565 TBool CDRMContextDB::WhiteListURLExistsL( const TDesC8& aRightsIssuerURL )

   566     {

   567     CDRMRIContext* context = NULL;

   568     TBool retVal = EFalse;

   569 

   570     if ( iRightsIssuerArray.Count() == 0) 

   571         {

   572         return retVal;

   573         }

   574     

   575     context = CDRMRIContext::NewLC();

   576     

   577     for( TInt count = 0; count < iRightsIssuerArray.Count(); count++ )

   578         {

   579         FetchRightsIssuerContextL( *context, iRightsIssuerArray[ count ].iStreamID );

   580         if( context->WhiteListURLExistsL( aRightsIssuerURL ) )

   581             {

   582             retVal = ETrue;

   583             count = iRightsIssuerArray.Count();           

   584             }

   585         }

   586     CleanupStack::PopAndDestroy(); // context       

   587     return retVal;    

   588     };    

   589 

   590 // -----------------------------------------------------------------------------

   591 // CDRMContextDB::DeleteExpiredDomainContextsL

   592 // -----------------------------------------------------------------------------

   593 //

   594 void CDRMContextDB::DeleteExpiredDomainContextsL( const TTime& aTime )

   595     {  

   596     CDRMDomainContext* context = NULL;    

   597     TStreamId rootId;

   598     RStoreWriteStream rootStream;

   599 

   600     // Check if there is anything to go through

   601     if ( iDomainArray.Count() == 0) 

   602         {

   603         return;

   604         }

   605       

   606     context = CDRMDomainContext::NewLC();

   607         

   608     // Delete all permissions from the store which have expired    

   609     for( TInt i = 0; i < iDomainArray.Count();)

   610         {

   611         FetchDomainContextL( *context, iDomainArray[i].iStreamID );

   612         

   613         if( context->ExpiryTime() < aTime && context->ExpiryTime() != Time::NullTTime() )

   614             {

   615             iDomainStore->DeleteL( TStreamId( iDomainArray[i].iStreamID ) );

   616             iDomainArray.Remove(i);

   617             }

   618         else 

   619             {

   620             i++; // increment the counter for the next run       

   621             }   

   622         }

   623         

   624     CleanupStack::PopAndDestroy();  // context

   625     

   626     // Get the stream id of the root

   627     rootId = iDomainStore->Root();

   628     

   629     // Open the root stream

   630     rootStream.ReplaceLC( *iDomainStore, rootId );

   631         

   632     // Store the changed index

   633     StoreDomainIndexL( rootStream );    

   634     rootStream.CommitL();

   635 

   636     // Commit the store

   637     iDomainStore->CommitL();

   638     

   639     CleanupStack::PopAndDestroy();  // root stream

   640     

   641     // Compact and Commit the store

   642     iDomainStore->CompactL();

   643     iDomainStore->CommitL();          

   644     };

   645 

   646 // -----------------------------------------------------------------------------

   647 // CDRMContextDB::DeleteExpiredRightsIssuerContextsL

   648 // -----------------------------------------------------------------------------

   649 //

   650 void CDRMContextDB::DeleteExpiredRightsIssuerContextsL( const TTime& aTime )

   651     {

   652     CDRMRIContext* context = NULL;    

   653     TStreamId rootId;

   654     RStoreWriteStream rootStream;

   655 

   656     // Check if there is anything to go through

   657     if ( iRightsIssuerArray.Count() == 0) 

   658         {

   659         return;

   660         }

   661         

   662     context = CDRMRIContext::NewLC(); 

   663            

   664     // Delete all permissions from the store which have expired    

   665     for( TInt i = 0; i < iRightsIssuerArray.Count();)

   666         {

   667         FetchRightsIssuerContextL( *context, iRightsIssuerArray[i].iStreamID );

   668         

   669         if( context->ExpiryTime() < aTime && context->ExpiryTime() != Time::NullTTime() )

   670             {

   671             iRightsIssuerStore->DeleteL( TStreamId( iRightsIssuerArray[i].iStreamID ) );

   672             iRightsIssuerArray.Remove(i);

   673             }

   674         else

   675             {

   676             i++; // increment the counter for the next run                 

   677             }       

   678         }

   679         

   680     CleanupStack::PopAndDestroy();  // context 

   681     

   682     // Get the stream id of the root

   683     rootId = iRightsIssuerStore->Root();

   684     

   685     // Open the root stream

   686     rootStream.ReplaceLC( *iRightsIssuerStore, rootId );

   687         

   688     // Store the changed index

   689     StoreRightsIssuerIndexL( rootStream );    

   690     rootStream.CommitL();

   691 

   692     // Commit the store

   693     iRightsIssuerStore->CommitL();

   694     

   695     CleanupStack::PopAndDestroy();  // root stream

   696     

   697     // Compact and Commit the store

   698     iRightsIssuerStore->CompactL();

   699     iRightsIssuerStore->CommitL();           

   700     };

   701 

   702 // -----------------------------------------------------------------------------

   703 // CDRMContextDB::CreateAndInitializeRIStoreL

   704 // -----------------------------------------------------------------------------

   705 //

   706 void CDRMContextDB::CreateAndInitializeRIStoreL( const TFileName& aRightsIssuerStore )

   707     {

   708     TStreamId rootId;  

   709     RStoreWriteStream rootStream;

   710         

   711     // Create and initialize the permanent file store

   712     iRightsIssuerStore = CPermanentFileStore::ReplaceL( iFileServer, 

   713                                                         aRightsIssuerStore,

   714                                                         EFileRead|EFileWrite );                                          

   715     iRightsIssuerStore->SetTypeL( KPermanentFileStoreLayoutUid );

   716     iRightsIssuerStore->CommitL(); 

   717     

   718     // Create the root stream:                                                   

   719     rootId = rootStream.CreateLC( *iRightsIssuerStore );

   720          

   721     // Create the index

   722     // Commit the previous changes 

   723     StoreRightsIssuerIndexL( rootStream );

   724     rootStream.CommitL();

   725     

   726     iRightsIssuerStore->SetRootL( rootId );

   727     iRightsIssuerStore->CommitL();  

   728     

   729     // Commit the changes to the store as well

   730     CleanupStack::PopAndDestroy(); // rootStream

   731     

   732     iRightsIssuerStore->CompactL();

   733     iRightsIssuerStore->CommitL();

   734     };

   735 

   736 

   737 // -----------------------------------------------------------------------------

   738 // CDRMContextDB::CreateAndInitializeDomainStoreL

   739 // -----------------------------------------------------------------------------

   740 //

   741 void CDRMContextDB::CreateAndInitializeDomainStoreL( const TFileName& aDomainStore )

   742     {

   743     TStreamId rootId;  

   744     RStoreWriteStream rootStream;

   745         

   746     // Create and initialize the permanent file store

   747     iDomainStore = CPermanentFileStore::ReplaceL( iFileServer, 

   748                                                         aDomainStore,

   749                                                         EFileRead|EFileWrite );                                          

   750     iDomainStore->SetTypeL( KPermanentFileStoreLayoutUid );

   751     iDomainStore->CommitL(); 

   752     

   753     // Create the root stream:                                                   

   754     rootId = rootStream.CreateLC( *iDomainStore );

   755                                                

   756     // Create the index

   757     // Commit the previous changes 

   758     StoreDomainIndexL( rootStream );

   759     rootStream.CommitL();

   760     

   761     iDomainStore->SetRootL( rootId );   

   762     iDomainStore->CommitL();    

   763         

   764     // Commit the changes to the store as well

   765     CleanupStack::PopAndDestroy(); // rootStream 

   766     

   767     iDomainStore->CompactL();

   768     iDomainStore->CommitL();       

   769     };

   770 

   771 // -----------------------------------------------------------------------------

   772 // CDRMContextDB::StoreRightsIssuerIndexL

   773 // -----------------------------------------------------------------------------

   774 //

   775 void CDRMContextDB::StoreRightsIssuerIndexL( RWriteStream& aStream ) const

   776     {

   777     // Write the array size and possibly the array to the stream

   778     aStream.WriteInt32L( iRightsIssuerArray.Count() );

   779              

   780     for( TInt count = 0; count < iRightsIssuerArray.Count(); count++ )

   781         {

   782         aStream << iRightsIssuerArray[ count ].iContextID;

   783         aStream.WriteUint32L( iRightsIssuerArray[ count ].iStreamID );

   784         }

   785     };

   786 

   787 // -----------------------------------------------------------------------------

   788 // CDRMContextDB::StoreDomainIndexL

   789 // -----------------------------------------------------------------------------

   790 //

   791 void CDRMContextDB::StoreDomainIndexL( RWriteStream& aStream ) const

   792     {

   793     // Write the array size and possibly the array to the stream

   794     aStream.WriteInt32L( iDomainArray.Count() );

   795     

   796     for( TInt count = 0; count < iDomainArray.Count(); count++ )

   797         {

   798         aStream << iDomainArray[ count ].iContextID;

   799         aStream.WriteUint32L( iDomainArray[ count ].iStreamID );

   800         }

   801     };

   802     

   803 // -----------------------------------------------------------------------------

   804 // CDRMContextDB::FetchRightsIssuerIndexL

   805 // -----------------------------------------------------------------------------

   806 //

   807 void CDRMContextDB::FetchRightsIssuerIndexL()

   808     {

   809     TStreamId rootId;

   810     RStoreReadStream stream;

   811     TInt count = 0;

   812     TContextIndex index;

   813  

   814     // Get the stream id of the root

   815     rootId = iRightsIssuerStore->Root();

   816     

   817     // Open the root stream

   818     stream.OpenLC( *iRightsIssuerStore, rootId );

   819     

   820     // read the count of the array:

   821     iRightsIssuerArray.Reset();

   822     

   823     count = stream.ReadInt32L();

   824     

   825     for( ; count > 0; count-- )

   826         {

   827         stream >> index.iContextID;

   828         index.iStreamID = stream.ReadInt32L();

   829         iRightsIssuerArray.Append( index );

   830         }

   831      

   832     // Close the stream

   833     CleanupStack::PopAndDestroy();    

   834     };

   835     

   836 // -----------------------------------------------------------------------------

   837 // CDRMContextDB::FetchDomainIndexL

   838 // -----------------------------------------------------------------------------

   839 //

   840 void CDRMContextDB::FetchDomainIndexL()

   841     {

   842     TStreamId rootId;

   843     RStoreReadStream stream;

   844     TInt count = 0;

   845     TContextIndex index;

   846  

   847     // Get the stream id of the root

   848     rootId = iDomainStore->Root();

   849     

   850     // Open the root stream

   851     stream.OpenLC( *iDomainStore, rootId );

   852     

   853     // read the count of the array:

   854     iDomainArray.Reset();

   855     

   856     count = stream.ReadInt32L();

   857     

   858     for( ; count > 0; count-- )

   859         {

   860         stream >> index.iContextID;

   861         index.iStreamID = stream.ReadInt32L();

   862         iDomainArray.Append( index );

   863         }

   864      

   865     // Close the stream

   866     CleanupStack::PopAndDestroy();    

   867     };

   868 

   869 // -----------------------------------------------------------------------------

   870 // CDRMContextDB::DeleteAllL

   871 // -----------------------------------------------------------------------------

   872 //

   873 void CDRMContextDB::DeleteAllL( const TFileName& aRightsIssuerContextFile, 

   874                                 const TFileName& aDomainContextFile )

   875     {

   876     delete iRightsIssuerStore;

   877     iRightsIssuerStore = NULL;

   878     iRightsIssuerArray.Reset();

   879     CreateAndInitializeRIStoreL( aRightsIssuerContextFile );

   880  

   881     delete iDomainStore;

   882     iDomainStore = NULL;

   883     iDomainArray.Reset();

   884     CreateAndInitializeDomainStoreL( aDomainContextFile );

   885     }

   886 

   887 // -----------------------------------------------------------------------------

   888 // Default Constructor - First phase.

   889 // Can be used by itself to generate an empty object

   890 // -----------------------------------------------------------------------------

   891 //

   892 CDRMContextDB::CDRMContextDB( RFs& aFileServer ) :

   893     iFileServer( aFileServer )

   894     {

   895     };

   896 

   897 // -----------------------------------------------------------------------------

   898 // 2nd phase Constructor

   899 // -----------------------------------------------------------------------------

   900 //

   901 void CDRMContextDB::ConstructL( const TFileName& aRightsIssuerContextFile, 

   902                                 const TFileName& aDomainContextFile )

   903     {

   904     TInt error = KErrNone;

   905     

   906     // Open the file store

   907     TRAP( error, iRightsIssuerStore = CPermanentFileStore::OpenL( iFileServer, 

   908                                                       aRightsIssuerContextFile, 

   909                                                       EFileRead|EFileWrite ) );

   910     if( error == KErrNotFound )

   911         {

   912         CreateAndInitializeRIStoreL( aRightsIssuerContextFile );

   913         }

   914     else 

   915         {   

   916         User::LeaveIfError( error );

   917         

   918         // Get the index

   919         FetchRightsIssuerIndexL();       

   920         }    

   921     

   922     

   923     // Open the file store

   924     TRAP( error, iDomainStore = CPermanentFileStore::OpenL( iFileServer, 

   925                                                       aDomainContextFile, 

   926                                                       EFileRead|EFileWrite ) );

   927     if( error == KErrNotFound ) 

   928         {

   929         CreateAndInitializeDomainStoreL( aDomainContextFile );

   930         }

   931     else 

   932         {   

   933         User::LeaveIfError( error );

   934         

   935         // Get the index

   936         FetchDomainIndexL();       

   937         

   938         }

   939     };

   940             

   941 // End of File