1 /*

     2 * Copyright (c) 2002-2009 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:  server implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include    "DcfRepSrv.h"

    21 #include    "DcfRepSrvSes.h"

    22 #include    "DcfRepCommon.h"

    23 #include    "Pair.h"

    24 #include    "FileScan.h"

    25 #include    <e32std.h>

    26 #include    <e32base.h>

    27 #include    <f32file.h>

    28 #include    <caf/data.h>

    29 #include    <caf/content.h>

    30 #include    <Oma2Agent.h> // oma2agent

    31 #include    "Oma2Dcf.h"

    32 #include    "Oma1Dcf.h"

    33 #include    "drmlog.h"

    34 #include <starterclient.h>

    35 

    36 #ifdef RD_MULTIPLE_DRIVE

    37 #include    <DriveInfo.h>

    38 #endif

    39 

    40 // EXTERNAL DATA STRUCTURES

    41 // EXTERNAL FUNCTION PROTOTYPES

    42 // CONSTANTS

    43 _LIT(KSqlUpdate1 , "select filename,position,cid,group,ttid from dcf where filename = '");

    44 _LIT(KSqlUpdate2 , "' and position = ");

    45 _LIT(KSqlInsert , "select filename,position,cid,group,ttid from dcf");

    46 _LIT(KSqlDeleteAll , "delete from dcf");

    47 _LIT(KGroupIdReplacement, "cid:group@localhost");

    48 // MACROS

    49 // LOCAL CONSTANTS AND MACROS

    50 

    51 #ifdef RD_MULTIPLE_DRIVE

    52 _LIT( KDbFileLoc, "%c:\\system\\data\\DcfRepDb" );

    53 #endif

    54 

    55 // MODULE DATA STRUCTURES

    56 // LOCAL FUNCTION PROTOTYPES

    57 LOCAL_C TInt CreateDataBase(RFs& aFs);

    58 

    59 #ifndef RD_MULTIPLE_DRIVE

    60 LOCAL_C TParse DataFile();

    61 #else // RD_MULTIPLE_DRIVE

    62 LOCAL_C TParse DataFile( RFs& aFs );

    63 #endif

    64 

    65 LOCAL_C void CreateTablesL(RDbDatabase& aDatabase);

    66 LOCAL_C TInt CreateDataBasePath(RFs& aFs);

    67 // FORWARD DECLARATIONS

    68 

    69 //#define _DRM_TESTING

    70 //#define _MEM_HEAP_USAGE

    71 

    72 // ============================ LOCAL FUNCTIONS ===============================

    73 #ifdef _DRM_TESTING

    74 LOCAL_C void WriteLogL( const TDesC8& text , RFs &aFs );

    75 LOCAL_C void WriteFileL( const TDesC8& text , RFs &aFs , const TDesC& aName );

    76 LOCAL_C void CreateLogL();

    77 LOCAL_C void WriteL( const TDesC8& aText );

    78 LOCAL_C void WriteL( const TDesC8& aText , TInt aErr );

    79 LOCAL_C void WriteCurrentTimeL();

    80 

    81 #ifdef _MEM_HEAP_USAGE

    82 LOCAL_C void WriteHeapAllocL();

    83 #endif //_MEM_HEAP_USAGE

    84 

    85 #endif //_DRM_TESTING

    86 

    87 // -----------------------------------------------------------------------------

    88 // Testing stuff

    89 // -----------------------------------------------------------------------------

    90 //

    91 #ifdef _DRM_TESTING

    92 LOCAL_C void WriteLogL( const TDesC8& text , RFs &aFs )

    93     {

    94     _LIT( KLogFile , "c:\\CDcfRepSrv.txt" );

    95     WriteFileL( text , aFs , KLogFile );

    96     }

    97 

    98 LOCAL_C void WriteFileL( const TDesC8& text , RFs &aFs , const TDesC& aName )

    99     {

   100     RFile file;

   101     TInt size;

   102     User::LeaveIfError( file.Open( aFs, aName , EFileWrite ) );

   103     CleanupClosePushL( file );

   104     User::LeaveIfError( file.Size( size ) );

   105     User::LeaveIfError( file.Write( size, text ) );

   106     CleanupStack::PopAndDestroy(&file); //file

   107     }

   108 

   109 LOCAL_C void CreateLogL()

   110     {

   111     RFs fs;

   112     User::LeaveIfError(fs.Connect());

   113     CleanupClosePushL(fs);

   114     RFile file;

   115     User::LeaveIfError( file.Replace( fs , _L("c:\\CDcfRepSrv.txt") , EFileWrite ) );

   116     file.Close();

   117     CleanupStack::PopAndDestroy(&fs); //fs

   118     }

   119 

   120 LOCAL_C void WriteL( const TDesC8& aText )

   121     {

   122     RFs fs;

   123     User::LeaveIfError( fs.Connect() );

   124     CleanupClosePushL(fs);

   125     HBufC8* text = HBufC8::NewLC(1000);

   126     TPtr8 textptr(text->Des() );

   127     textptr.Append( aText );

   128     textptr.Append( _L8("\r\n") );

   129     WriteLogL(textptr , fs);

   130     CleanupStack::PopAndDestroy(text);

   131     CleanupStack::PopAndDestroy(&fs); //fs

   132     WriteCurrentTimeL();

   133 #ifdef _MEM_HEAP_USAGE

   134     WriteHeapAllocL();

   135 #endif //_MEM_HEAP_USAGE

   136     }

   137 

   138 LOCAL_C void WriteL( const TDesC8& aText , TInt aErr )

   139     {

   140     _LIT8(KErr,": %d");

   141     HBufC8* text = HBufC8::NewLC(1000+20);

   142     TBuf8<20> num;

   143     TPtr8 textptr(text->Des());

   144     textptr.Append(aText);

   145     num.Format(KErr(),aErr);

   146     textptr.Append(num);

   147     WriteL(textptr);

   148     CleanupStack::PopAndDestroy(text);

   149     }

   150 

   151 LOCAL_C void WriteCurrentTimeL()

   152     {

   153     RFs fs;

   154     User::LeaveIfError( fs.Connect() );

   155     CleanupClosePushL(fs);

   156     HBufC8* text = HBufC8::NewLC(100);

   157     TPtr8 textptr(text->Des() );

   158     // Date and Time display

   159     TTime time;

   160     time.HomeTime();

   161     TBuf<256> dateString;

   162     _LIT(KDate,"%*E%*D%X%*N%*Y %1 %2 '%3");

   163     time.FormatL(dateString,KDate);

   164     textptr.Append(_L( "\r\n\t\tData:\t" ) );

   165     textptr.Append( dateString );

   166     _LIT(KTime,"%-B%:0%J%:1%T%:2%S%:3%+B");

   167     time.FormatL(dateString,KTime);

   168     textptr.Append(_L( "\r\n\t\tTime:\t" ) );

   169     textptr.Append( dateString );

   170     textptr.Append(_L( "\r\n" ) );

   171     textptr.Append(_L( "\r\n" ) );

   172     WriteLogL(textptr , fs);

   173     CleanupStack::PopAndDestroy(text);

   174     CleanupStack::PopAndDestroy(&fs); //fs

   175     }

   176 

   177 #ifdef _MEM_HEAP_USAGE

   178 LOCAL_C void WriteHeapAllocL()

   179     {

   180     _LIT8(KHeapUsage,"\r\n***** Heap cells allocated: %d *****\r\n");

   181     TBuf8<256> string;

   182     TInt size = 0;

   183     RFs fs;

   184     User::LeaveIfError( fs.Connect() );

   185     CleanupClosePushL(fs);

   186     User::Heap().AllocSize(size);

   187     string.Format(KHeapUsage(),size);

   188     WriteLogL(string , fs);

   189     CleanupStack::PopAndDestroy(&fs); //fs

   190     }

   191 #endif //_MEM_HEAP_USAGE

   192 

   193 

   194 #endif //_DRM_TESTING

   195 

   196 // -----------------------------------------------------------------------------

   197 // DataFile

   198 // Return TParse which contain database file name

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

   200 //

   201 #ifdef RD_MULTIPLE_DRIVE

   202 LOCAL_C TParse DataFile( RFs& aFs )

   203 #else

   204 LOCAL_C TParse DataFile()

   205 #endif

   206     {

   207 #ifdef _DRM_TESTING

   208     TRAP_IGNORE( WriteL(_L8("DataFile")) ); 

   209 #endif

   210 

   211     TParse p;

   212 

   213 #ifndef RD_MULTIPLE_DRIVE

   214 

   215     p.Set(KDbFileLocation,NULL,NULL);

   216 

   217 #else //RD_MULTIPLE_DRIVE

   218 

   219     TInt driveNumber( -1 );

   220     TChar driveLetter;

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

   222 

   223     aFs.DriveToChar( driveNumber, driveLetter );

   224 

   225     TFileName dbFile;

   226     dbFile.Format( KDbFileLoc, (TUint)driveLetter );

   227 

   228     p.Set(dbFile,NULL,NULL);

   229 

   230 #endif

   231 

   232     return p;

   233     }

   234 

   235 

   236 // -----------------------------------------------------------------------------

   237 // CreateTablesL

   238 // Create table through database session

   239 // -----------------------------------------------------------------------------

   240 //

   241 LOCAL_C void CreateTablesL(RDbDatabase& aDatabase)

   242     {

   243 #ifdef _DRM_TESTING

   244     WriteL(_L8("CreateTablesL"));

   245 #endif

   246 

   247     CDbColSet* columns = CDbColSet::NewLC();

   248 

   249     //filename columns

   250     TDbCol filename(KColFilename,EDbColLongText16);

   251     filename.iAttributes = TDbCol::ENotNull;

   252     columns->AddL(filename);

   253 

   254     //position columns

   255     TDbCol position(KColPosition,EDbColUint16);

   256     position.iAttributes = TDbCol::ENotNull;

   257     columns->AddL(position);

   258 

   259     //content id columns

   260     TDbCol cid(KColCid,EDbColLongText16);

   261     cid.iAttributes = TDbCol::ENotNull;

   262     columns->AddL(cid);

   263 

   264     //content group id columns

   265     TDbCol group(KColGroupId,EDbColLongText16);

   266     columns->AddL(group);

   267 

   268     //transaction id columns

   269     TDbCol ttid(KColTtid,EDbColText16,KTtidLen);

   270     columns->AddL(ttid);

   271 

   272     aDatabase.CreateTable( KTable,*columns);

   273     CleanupStack::PopAndDestroy(columns); //columns

   274 

   275     }

   276 

   277 // -----------------------------------------------------------------------------

   278 // CreateDataBasePath

   279 // Create database with client side database access

   280 // -----------------------------------------------------------------------------

   281 //

   282 LOCAL_C TInt CreateDataBasePath(RFs& aFs)

   283     {

   284 #ifdef _DRM_TESTING

   285     TRAPD(r,WriteL(_L8("CreateDataBasePath")));

   286 #endif

   287 

   288     TInt err = 0;

   289 

   290 #ifndef RD_MULTIPLE_DRIVE

   291 

   292     err = aFs.MkDirAll( DataFile(). DriveAndPath() );

   293 

   294 #else //RD_MULTIPLE_DRIVE

   295 

   296     err = aFs.MkDirAll( DataFile( aFs ). DriveAndPath() );

   297 

   298 #endif

   299 

   300     return err;

   301     }

   302 

   303 // -----------------------------------------------------------------------------

   304 // CreateDataBase

   305 // Create database with client side database access

   306 // -----------------------------------------------------------------------------

   307 //

   308 LOCAL_C TInt CreateDataBase(RFs& aFs)

   309     {

   310 #ifdef _DRM_TESTING

   311     TRAPD(r,WriteL(_L8("CreateDataBase")));

   312 #endif

   313 

   314     RDbNamedDatabase database;

   315     TInt err = 0;

   316     TFileName file;

   317 

   318 #ifndef RD_MULTIPLE_DRIVE

   319 

   320     file = DataFile().FullName();

   321 

   322 

   323 #else // RD_MULTIPLE_DRIVE

   324 

   325     file = DataFile( aFs ).FullName();

   326 

   327 #endif

   328 

   329     if (!err)

   330         {

   331 #ifdef _DRM_TESTING

   332         TRAP(r,WriteL(_L8("CreateDataBase->DataFile"),err));

   333 #endif

   334         err = CreateDataBasePath(aFs);

   335 

   336         err = database.Create(aFs,file);

   337         if (!err)

   338             {

   339 #ifdef _DRM_TESTING

   340             TRAP(r,WriteL(_L8("CreateDataBase->database.Create"),err));

   341 #endif

   342             TRAP( err , CreateTablesL(database) );

   343 #ifdef _DRM_TESTING

   344             TRAP(r,WriteL(_L8("CreateDataBase->CreateTablesL"),err));

   345 #endif

   346             }

   347         database.Close();

   348         }

   349     return err;

   350     }

   351 

   352 // -----------------------------------------------------------------------------

   353 // From8To16

   354 // transfer buf from 8 bit to 16 bit

   355 // -----------------------------------------------------------------------------

   356 //

   357 LOCAL_C TInt From8To16( const TDesC8& a8 , HBufC16*& a16 )

   358     {

   359 #ifdef _DRM_TESTING

   360     TRAPD(r,WriteL(_L8("From8To16")));

   361 #endif

   362 

   363     TInt err = KErrNone;

   364     a16 = HBufC::NewMax( a8.Length() );

   365     if ( a16 )

   366         {

   367         TPtr ptr( a16->Des() );

   368         ptr.SetLength( a8.Length() );

   369         for (TInt i = 0 ; i<a8.Length() ; i++ )

   370             {

   371             ptr[i] = ( unsigned char ) a8[i];

   372             }

   373         }

   374     else err = KErrNoMemory;

   375     return err;

   376     }

   377 

   378 // ============================ MEMBER FUNCTIONS ===============================

   379 

   380 // -----------------------------------------------------------------------------

   381 // CDcfRepSrv::CDcfRepSrv

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

   383 // might leave.

   384 // -----------------------------------------------------------------------------

   385 //

   386 CDcfRepSrv::CDcfRepSrv():CServer2( EPriorityStandard ),

   387     iScan(NULL),

   388     iCidList(NULL),

   389     iPairList(NULL),

   390     iState(EStateIdle),

   391     iArmed( EFalse )

   392     {

   393 

   394     }

   395 

   396 // -----------------------------------------------------------------------------

   397 // CDcfRepSrv::ConstructL

   398 // Symbian 2nd phase constructor can leave.

   399 // -----------------------------------------------------------------------------

   400 //

   401 void CDcfRepSrv::ConstructL()

   402     {

   403 #ifdef _DRM_TESTING

   404     CreateLogL();

   405     WriteL(_L8("ConstructL"));

   406 #endif

   407     StartL(KDcfRepSrvName);

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

   409     iScan = CFileScan::NewL(iFs);

   410     OpenDatabaseL();

   411 

   412     User::RenameThread(KDcfRepSrvName);

   413 

   414     iProcWatcher = CProcWatcher::NewL( *this, _L( "*RightsServer*" ), _L( "RightsServer" ) );

   415     iProcWatcher->StartWatching();

   416     iArmed = ETrue;

   417     }

   418 

   419 

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

   421 // CDcfRepSrv::NewLC

   422 // Two-phased constructor.

   423 // -----------------------------------------------------------------------------

   424 //

   425 CDcfRepSrv* CDcfRepSrv::NewLC()

   426     {

   427     CDcfRepSrv* self = new( ELeave ) CDcfRepSrv;

   428     CleanupStack::PushL( self );

   429     self->ConstructL();

   430     return self;

   431     }

   432 

   433 

   434 // Destructor

   435 CDcfRepSrv::~CDcfRepSrv()

   436     {

   437 #ifdef _DRM_TESTING

   438     TRAPD(r,WriteL(_L8("~CDcfRepSrv")));

   439 #endif

   440 

   441     delete iScan;

   442     CleanScanInternal();

   443     CleanDatabase();

   444     iFs.Close();

   445     for (TInt i = 0 ; i < iMessageList.Count() ; i++ )

   446         {

   447         if ( iMessageList[i]!=NULL && !(iMessageList[i]->IsNull()) )

   448             {

   449             iMessageList[i]->Complete(KErrCancel);

   450             }

   451 

   452         }

   453     iMessageList.ResetAndDestroy();

   454     iMessageList.Close();

   455     }

   456 

   457 // -----------------------------------------------------------------------------

   458 // CDcfRepSrv::NewSessionL

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

   460 // -----------------------------------------------------------------------------

   461 CSession2* CDcfRepSrv::NewSessionL(const TVersion &aVersion,

   462     const RMessage2& /*aMessage*/ ) const

   463     {

   464 #ifdef _DRM_TESTING

   465     WriteL(_L8("NewSessionL"));

   466 #endif

   467     // check we're the right version

   468     if (!User::QueryVersionSupported(TVersion(KDcfRepMajorVersionNumber,

   469                 KDcfRepMinorVersionNumber,

   470                 KDcfRepBuildVersionNumber),

   471             aVersion))

   472         {

   473         User::Leave(KErrNotSupported);

   474         }

   475 

   476     // make new session

   477     return CDcfRepSrvSes::NewL();

   478     }

   479 

   480 

   481 // -----------------------------------------------------------------------------

   482 // Startup().

   483 // This function starts the actual DCF Repository server after initializing

   484 // the cleanup stack and active scheduler.

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

   486 // -----------------------------------------------------------------------------

   487 //

   488 

   489 TInt CDcfRepSrv::Startup( void )

   490     {

   491     TInt err = 0;

   492     TBool clientIsWaiting = EFalse;

   493     RSemaphore semaphore;

   494 

   495     CTrapCleanup* cleanupStack = CTrapCleanup::New();

   496 

   497     if (cleanupStack == NULL)

   498         {

   499         PanicServer(ECreateTrapCleanup);

   500         }

   501 

   502     // check if the client wants to be signaled that we are ready

   503     if ( semaphore.OpenGlobal(KDcfRepSemaphoreName) == KErrNone )

   504         {

   505         clientIsWaiting = ETrue;

   506         }

   507 

   508     TRAP(err, StartupL());

   509 

   510     // release client side waiting

   511     if (clientIsWaiting)

   512         {

   513         semaphore.Signal();

   514         semaphore.Close();

   515         }

   516 

   517     if (err != KErrNone)

   518         {

   519         PanicServer(ESrvCreateServer);

   520         }

   521 

   522     delete cleanupStack;

   523     cleanupStack = NULL;

   524     return KErrNone;

   525     }

   526 

   527 

   528 // -----------------------------------------------------------------------------

   529 // StartupL().

   530 // This function starts the actual DCF Repository after initializing scheduler

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

   532 //

   533 

   534 void CDcfRepSrv::StartupL()

   535     {

   536     // Construct active scheduler

   537     CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;

   538     CleanupStack::PushL(activeScheduler) ;

   539 

   540     // Install active scheduler

   541     // We don't need to check whether an active scheduler is already installed

   542     // as this is a new thread, so there won't be one

   543     CActiveScheduler::Install(activeScheduler);

   544 

   545     // Construct our server

   546     CDcfRepSrv::NewLC();

   547 

   548     // Start handling requests

   549     CActiveScheduler::Start();

   550 

   551     CleanupStack::PopAndDestroy(2);    //  activeScheduler and anonymous CDcfRepSrv

   552     }

   553 

   554 void CDcfRepSrv::PanicServer(TDcfRepSrvPanic aPanic)

   555     {

   556 #ifdef _DRM_TESTING

   557     TRAPD(r,WriteL(_L8("PanicServer")));

   558     r =  0;

   559 #endif

   560 

   561     User::Panic(KDcfRepSrv, aPanic);

   562     }

   563 

   564 

   565 // -----------------------------------------------------------------------------

   566 // AddFileL()

   567 // The function will add a file info into database

   568 // -----------------------------------------------------------------------------

   569 //

   570 void CDcfRepSrv::AddFileL( const TDesC& aFile )

   571     {

   572 #ifdef _DRM_TESTING

   573     WriteL(_L8("AddFileL"));

   574 #endif

   575 

   576     TInt err = 0;

   577     TInt state = iState;

   578     TBool flag = EFalse;

   579 

   580     // to process the file as doing scanning fully for file system

   581     iState = EStateFullScan;

   582     err = ProcessFile(aFile , flag);

   583     // change the state back

   584     iState = state;

   585     User::LeaveIfError(err);

   586     if ( flag == ENoDcf )

   587         {

   588         User::Leave(KErrNotSupported);

   589         }

   590     else if (flag == EOma2Dcf)

   591         {

   592         AddDomainRoL(aFile);

   593         }

   594     }

   595 

   596 // -----------------------------------------------------------------------------

   597 // AddDomainRoL()

   598 // The function will add a file info into database

   599 // -----------------------------------------------------------------------------

   600 //

   601 void CDcfRepSrv::AddDomainRoL( const TDesC& aFile )

   602     {

   603 #ifdef _DRM_TESTING

   604     WriteL(_L8("AddDomainRoL"));

   605 #endif

   606 

   607     __UHEAP_MARK;

   608     RFile file;

   609     TPtr8 ptr(NULL,0,0);

   610     CContent* content =NULL;

   611     User::LeaveIfError(file.Open(iFs, aFile, EFileShareReadersOrWriters | EFileWrite ) );

   612     CleanupClosePushL(file);

   613     content = CContent::NewL(file);

   614     CleanupStack::PushL(content);

   615     User::LeaveIfError(content->AgentSpecificCommand(EEmbedDomainRo,

   616             KNullDesC8, ptr ));

   617     CleanupStack::PopAndDestroy(2); // content, file

   618     __UHEAP_MARKEND;

   619     }

   620 

   621 

   622 // -----------------------------------------------------------------------------

   623 // OpenDatabaseL()

   624 // The function will open database

   625 // -----------------------------------------------------------------------------

   626 //

   627 void CDcfRepSrv::OpenDatabaseL()

   628     {

   629 #ifdef _DRM_TESTING

   630     WriteL(_L8("OpenDatabaseL"));

   631 #endif

   632 

   633 

   634     TInt err = CreateDataBase(iFs);

   635     if ( err==KErrAlreadyExists )

   636         {

   637         err = KErrNone;

   638         }

   639 

   640     User::LeaveIfError(iDbs.Connect());

   641 

   642 #ifndef RD_MULTIPLE_DRIVE

   643 

   644     User::LeaveIfError(iDb.Open(iDbs,DataFile().FullName()));

   645 

   646 #else // RD_MULTIPLE_DRIVE

   647 

   648     User::LeaveIfError(iDb.Open(iDbs,DataFile(iFs).FullName()));

   649 

   650 #endif

   651     }

   652 

   653 

   654 // -----------------------------------------------------------------------------

   655 // CleanTableL()

   656 // The function will empty the talbe

   657 // -----------------------------------------------------------------------------

   658 //

   659 void CDcfRepSrv::CleanTableL()

   660     {

   661 #ifdef _DRM_TESTING

   662     WriteL(_L8("CleanTableL"));

   663 #endif

   664 

   665     User::LeaveIfError(iDb.Execute(KSqlDeleteAll()));

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // ProcessFile()

   670 // This function check if the file is DRM protected and add it into database.

   671 // -----------------------------------------------------------------------------

   672 //

   673 TInt CDcfRepSrv::ProcessFile(const TDesC& aFile , TInt& aType)

   674     {

   675 #ifdef _DRM_TESTING

   676     TRAPD(r,WriteL(_L8("ProcessFile")));

   677 #endif

   678 

   679     TInt err = 0;

   680     aType = ENoDcf;

   681 

   682     TRAP(err , CheckFileL(aFile , aType));

   683     if (aType)

   684         {

   685         TRAP(err , StoreFileL(aFile,aType));

   686         }

   687     return err;

   688     }

   689 

   690 // -----------------------------------------------------------------------------

   691 // CheckFileL()

   692 // check if it is target file

   693 // -----------------------------------------------------------------------------

   694 //

   695 void CDcfRepSrv::CheckFileL(const TDesC& aFile , TInt& aType)

   696     {

   697 #ifdef _DRM_TESTING

   698     WriteL(_L8("CheckFileL"));

   699 #endif

   700 

   701     RFile f;

   702     TInt pos = 0;

   703     TBuf8<256> buf;

   704 

   705     switch(iState)

   706         {

   707         case EStateFullScan:

   708         case EStateScan:

   709                 {

   710                 User::LeaveIfError(f.Open(iFs,aFile,EFileRead|EFileShareReadersOrWriters));

   711                 CleanupClosePushL(f);

   712                 User::LeaveIfError(f.Seek(ESeekStart,pos));

   713                 User::LeaveIfError(f.Read(0,buf));

   714                 CleanupStack::PopAndDestroy(&f);

   715                 if (COma1Dcf::IsValidDcf(buf))

   716                     {

   717                     aType = EOma1Dcf;

   718                     }

   719 #ifdef __DRM_OMA2

   720                 else if (COma2Dcf::IsValidDcf(buf))

   721                     {

   722                     aType = EOma2Dcf;

   723                     }

   724 #endif

   725                 else

   726                     {

   727                     aType = ENoDcf;

   728                     }

   729 

   730                 }

   731             break;

   732         case EStateSetTtid:

   733                 {

   734                 TParse p;

   735                 User::LeaveIfError(p.Set(aFile,NULL,NULL));

   736                 if ( !p.Ext().Compare( KOma2DcfExtension ) ||

   737                     !p.Ext().Compare( KOma2DcfExtensionAudio ) ||

   738                     !p.Ext().Compare( KOma2DcfExtensionVideo ) )

   739                     {

   740                     User::LeaveIfError(f.Open(iFs,aFile,EFileRead|EFileShareReadersOrWriters));

   741                     CleanupClosePushL(f);

   742                     User::LeaveIfError(f.Seek(ESeekStart,pos));

   743                     User::LeaveIfError(f.Read(0,buf));

   744                     CleanupStack::PopAndDestroy(&f);

   745                     if (COma1Dcf::IsValidDcf(buf))

   746                         {

   747                         aType = EOma1Dcf;

   748                         }

   749 #ifdef __DRM_OMA2

   750                     else if (COma2Dcf::IsValidDcf(buf))

   751                         {

   752                         aType = EOma2Dcf;

   753                         }

   754 #endif

   755                     else

   756                         {

   757                         aType = ENoDcf;

   758                         }

   759                     }

   760                 }

   761             break;

   762         default:

   763             ;

   764         }

   765     }

   766 

   767 // -----------------------------------------------------------------------------

   768 // StoreFile()

   769 // save file info into database

   770 // -----------------------------------------------------------------------------

   771 //

   772 void CDcfRepSrv::StoreFileL(const TDesC& aFile , TInt aType)

   773     {

   774 #ifdef _DRM_TESTING

   775     WriteL(_L8("StoreFileL"));

   776 #endif

   777 

   778     RFile f;

   779     User::LeaveIfError(f.Open(iFs,aFile,EFileRead|EFileShareReadersOrWriters));

   780     CleanupClosePushL(f);

   781     TInt i = 0;

   782     TInt setTtid = -1;

   783     HBufC16* cid = NULL;

   784     HBufC16* ttid = NULL;

   785     HBufC16* group = NULL;

   786 

   787     if (aType == EOma1Dcf)

   788         {

   789         COma1Dcf* d = COma1Dcf::NewL(f);

   790         CleanupStack::PushL(d);

   791         User::LeaveIfError( From8To16( *(d->iContentID) , cid ) );

   792         CleanupStack::PopAndDestroy(d);

   793         CleanupStack::PushL(cid);

   794         ttid = HBufC::NewMaxLC(16);

   795         *ttid = KNullDesC16;

   796         UpdateDatabaseL(aFile , KStartPosition , *cid , KNullDesC() , *ttid);

   797         if (iCidList)

   798             {

   799             for (i = 0; i<iCidList->Count(); i++)

   800                 {

   801                 HBufC* temp = NULL;

   802                 User::LeaveIfError( From8To16(*((*iCidList)[i]) , temp ) );

   803                 CleanupStack::PushL(temp);

   804                 if (!temp->Compare(*cid))

   805                     {

   806                     delete (*iCidList)[i];

   807                     iCidList->Remove(i);

   808                     CleanupStack::PopAndDestroy(temp);

   809                     break;

   810                     }

   811                 CleanupStack::PopAndDestroy(temp); //temp

   812                 }

   813             if (iCidList->Count()<=0)

   814                 {

   815                 CompleteScanning(KErrNone);

   816                 }

   817             }

   818         CleanupStack::PopAndDestroy(2); //cid,ttid

   819         }

   820     else if (aType == EOma2Dcf)

   821         {

   822         COma2Dcf* d = COma2Dcf::NewL(f);

   823         CleanupStack::PushL(d);

   824 

   825         // Set group ID and content ID for this entry

   826         if (d->iGroupId)

   827             {

   828             User::LeaveIfError( From8To16( *(d->iGroupId) , group ) );

   829 

   830             // replace the content ID for this entry with a placeholder to prevent

   831             // that the file is listed wrongly under the group ID

   832             cid = KGroupIdReplacement().AllocL();

   833             }

   834         else

   835             {

   836             User::LeaveIfError( From8To16( *(d->iContentID) , cid ) );

   837             group = HBufC::NewMaxL(16);

   838             *group = KNullDesC16;

   839             }

   840         CleanupStack::PushL(cid);

   841         CleanupStack::PushL(group);

   842 

   843         if (iState == EStateSetTtid)

   844             {

   845             for (i = 0; iPairList && i<iPairList->Count() && !ttid; i++)

   846                 {

   847                 HBufC* temp = NULL;

   848                 User::LeaveIfError( From8To16(*((*iPairList)[i]->iCid) , temp ) );

   849                 CleanupStack::PushL(temp);

   850                 if (!temp->Compare(*cid))

   851                     {

   852                     User::LeaveIfError( From8To16(*((*iPairList)[i]->iTtid) , ttid ) );

   853 

   854                     // EFileWrite is needed for this case

   855                     // So we cannot do it here. we must close the file

   856                     setTtid = i;

   857                     }

   858                 CleanupStack::PopAndDestroy(temp); //temp

   859                 }

   860             }

   861         if (!ttid)

   862             {

   863             if (d->iTransactionTracking)

   864                 {

   865                 User::LeaveIfError( From8To16( *(d->iTransactionTracking) , ttid ) );

   866                 }

   867             else

   868                 {

   869                 ttid = HBufC::NewMaxL(16);

   870                 *ttid = KNullDesC16;

   871                 }

   872             }

   873         CleanupStack::PushL(ttid);

   874 

   875         UpdateDatabaseL(aFile , KStartPosition , *cid , *group , *ttid);

   876         if (iCidList)

   877             {

   878             for (i = 0; i<iCidList->Count(); i++)

   879                 {

   880                 HBufC* temp = NULL;

   881                 User::LeaveIfError( From8To16(*((*iCidList)[i]) , temp ) );

   882                 CleanupStack::PushL(temp);

   883                 if (!temp->Compare(*cid))

   884                     {

   885                     delete (*iCidList)[i];

   886                     iCidList->Remove(i);

   887                     CleanupStack::PopAndDestroy(temp);

   888                     break;

   889                     }

   890                 CleanupStack::PopAndDestroy(temp); //temp

   891                 }

   892             if (iCidList->Count()<=0)

   893                 {

   894                 CompleteScanning(KErrNone);

   895                 }

   896             }

   897         CleanupStack::PopAndDestroy(4); // group,ttid,cid,d

   898         }

   899 

   900     CleanupStack::PopAndDestroy(&f); // f

   901 

   902     if (setTtid>=0)

   903         {

   904         ResetTtidL( aFile , *((*iPairList)[setTtid]->iTtid));

   905         }

   906     }

   907 

   908 // -----------------------------------------------------------------------------

   909 // ResetTtidL()

   910 // save new ttid into file

   911 // -----------------------------------------------------------------------------

   912 //

   913 void CDcfRepSrv::ResetTtidL(

   914     const TDesC& aFile,

   915     const TDesC8& aTtid

   916     )

   917     {

   918 #ifdef _DRM_TESTING

   919     WriteL(_L8("ResetTtidL"));

   920 #endif

   921 

   922     RFile f;

   923     User::LeaveIfError(f.Open(iFs,aFile, EFileWrite|EFileShareReadersOrWriters ));

   924     CleanupClosePushL(f);

   925     COma2Dcf* d = COma2Dcf::NewL(f);

   926     CleanupStack::PushL(d);

   927     ResetTtidL(d,aTtid);

   928     CleanupStack::PopAndDestroy(2); // f,d

   929     }

   930 

   931 // -----------------------------------------------------------------------------

   932 // ResetTtidL()

   933 // save new ttid into file

   934 // -----------------------------------------------------------------------------

   935 //

   936 void CDcfRepSrv::ResetTtidL(

   937     COma2Dcf* aDcf,

   938     const TDesC8& aTtid

   939     )

   940     {

   941 #ifdef _DRM_TESTING

   942     WriteL(_L8("ResetTtidL"));

   943 #endif

   944 

   945     aDcf->SetTransactionIdL(aTtid);

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // UpdateDatabaseL()

   950 // save info into database

   951 // -----------------------------------------------------------------------------

   952 //

   953 void CDcfRepSrv::UpdateDatabaseL(

   954     const TDesC& aFile,

   955     TInt aPos,

   956     const TDesC& aCid ,

   957     const TDesC& aGroupId ,

   958     const TDesC& aTtid)

   959     {

   960 #ifdef _DRM_TESTING

   961     WriteL(_L8("UpdateDatabaseL"));

   962 #endif

   963 

   964     HBufC* sql = NULL;

   965     TPtr ptr(NULL,0,0);

   966     TBuf<4> num;

   967     sql = HBufC::NewMaxLC(aFile.Length()+200);

   968     ptr.Set(sql->Des());

   969     ptr.SetLength(0);

   970     ptr.Append(KSqlUpdate1);

   971     ptr.Append(aFile);

   972     ptr.Append(KSqlUpdate2);

   973     num.Num(aPos);

   974     ptr.Append(num);

   975 

   976     iView.Close();

   977 

   978     User::LeaveIfError(

   979         iView.Prepare(

   980             iDb,TDbQuery(ptr),

   981             TDbWindow::EUnlimited,

   982             RDbView::EUpdatable

   983             )

   984         );

   985     User::LeaveIfError(iView.EvaluateAll());

   986     if (iView.FirstL())

   987         {

   988         iView.UpdateL();

   989         iView.SetColL(KOrdCid,aCid);

   990         iView.SetColL(KOrdGroupId,aGroupId);

   991         iView.SetColL(KOrdTtid,aTtid);

   992         iView.PutL();

   993         }

   994     else

   995         {

   996         iView.Reset();

   997         iView.Close();

   998         iView.Prepare(

   999             iDb,TDbQuery(KSqlInsert),

  1000             TDbWindow::EUnlimited,

  1001             RDbView::EInsertOnly

  1002             );

  1003         iView.InsertL();

  1004         iView.SetColL(KOrdFilename,aFile);

  1005         iView.SetColL(KOrdPosition,aPos);

  1006         iView.SetColL(KOrdCid,aCid);

  1007         iView.SetColL(KOrdGroupId,aGroupId);

  1008         iView.SetColL(KOrdTtid,aTtid);

  1009         iView.PutL();

  1010         }

  1011     iView.Reset();

  1012     iView.Close();

  1013     CleanupStack::PopAndDestroy(sql); //sql

  1014     }

  1015 

  1016 // -----------------------------------------------------------------------------

  1017 // State()

  1018 // This function returns the state of the Server

  1019 // -----------------------------------------------------------------------------

  1020 //

  1021 TInt CDcfRepSrv::State() const

  1022     {

  1023 #ifdef _DRM_TESTING

  1024     TRAPD(r,WriteL(_L8("State")));

  1025 #endif

  1026 

  1027     return iState;

  1028     }

  1029 

  1030 // -----------------------------------------------------------------------------

  1031 // SetState()

  1032 // This function set the state of the Server

  1033 // -----------------------------------------------------------------------------

  1034 //

  1035 void CDcfRepSrv::SetState(TServerState aMode)

  1036     {

  1037 #ifdef _DRM_TESTING

  1038     TRAPD(r,WriteL(_L8("SetState")));

  1039 #endif

  1040 

  1041     iState = aMode;

  1042     }

  1043 

  1044 

  1045 // -----------------------------------------------------------------------------

  1046 // CompleteScanning().

  1047 // This function complete request from client

  1048 // -----------------------------------------------------------------------------

  1049 //

  1050 void CDcfRepSrv::CompleteScanning(TInt aRet)

  1051     {

  1052 #ifdef _DRM_TESTING

  1053     TRAPD(r,WriteL(_L8("CompleteScanning")));

  1054 #endif

  1055 

  1056     for (TInt i = 0 ; i<iMessageList.Count() ; i++ )

  1057         {

  1058         if ( iMessageList[i] && !(iMessageList[i]->IsNull()) )

  1059             {

  1060             iMessageList[i]->Complete(aRet);

  1061             }

  1062         }

  1063     iMessageList.ResetAndDestroy();

  1064 

  1065     CleanScanInternal();

  1066     iState = EStateIdle;

  1067     }

  1068 

  1069 // -----------------------------------------------------------------------------

  1070 // SetMessage().

  1071 // This function save the incomplete message to server

  1072 // -----------------------------------------------------------------------------

  1073 //

  1074 RMessage2* CDcfRepSrv::SetMessageL(const RMessage2& aMessage)

  1075     {

  1076 #ifdef _DRM_TESTING

  1077     WriteL(_L8("SetMessageL"));

  1078 #endif

  1079     RMessage2* m = NULL;

  1080     m = new (ELeave) RMessage2(aMessage);

  1081     iMessageList.AppendL(m);

  1082     return m;

  1083     }

  1084 

  1085 

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

  1087 // RemoveMessage().

  1088 // This function to remove the imcomplete message from server if it is still there

  1089 // when session is deleted

  1090 // -----------------------------------------------------------------------------

  1091 //

  1092 void CDcfRepSrv::RemoveMessageL( const RMessage2* aMessage )

  1093     {

  1094     for (TInt i = 0 ; i<iMessageList.Count() ; i++ )

  1095         {

  1096         if ( iMessageList[i] == aMessage )

  1097             {

  1098             delete iMessageList[i];

  1099             iMessageList[i] = NULL;

  1100             iMessageList.Remove( i );

  1101             return;

  1102             }

  1103         }

  1104     return;

  1105     };

  1106 

  1107 

  1108 // -----------------------------------------------------------------------------

  1109 // SetCidList().

  1110 // This function set content ID List

  1111 // -----------------------------------------------------------------------------

  1112 //

  1113 void CDcfRepSrv::SetCidList(RPointerArray<HBufC8>*& aList)

  1114     {

  1115 #ifdef _DRM_TESTING

  1116     TRAPD(r,WriteL(_L8("SetCidList")));

  1117 #endif

  1118 

  1119     if (iCidList)

  1120         {

  1121         iCidList->ResetAndDestroy();

  1122         iCidList->Close();

  1123         delete iCidList;

  1124         }

  1125     iCidList = aList;

  1126     }

  1127 

  1128 // -----------------------------------------------------------------------------

  1129 // SetPairList().

  1130 // This function set list of pairs for content ID and transation ID

  1131 // -----------------------------------------------------------------------------

  1132 //

  1133 void CDcfRepSrv::SetPairList(RPointerArray<CPair>*& aList)

  1134     {