/*

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  server implementation

*

*/

// INCLUDE FILES

#include    "DcfRepSrv.h"

#include    "DcfRepSrvSes.h"

#include    "DcfRepCommon.h"

#include    "Pair.h"

#include    "FileScan.h"

#include    <e32std.h>

#include    <e32base.h>

#include    <f32file.h>

#include    <caf/data.h>

#include    <caf/content.h>

#include    <Oma2Agent.h> // oma2agent

#include    "oma2dcf.h"

#include    "Oma1Dcf.h"

#include    "drmlog.h"

#include <starterclient.h>

#ifdef RD_MULTIPLE_DRIVE

#include    <driveinfo.h>

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

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

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

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

_LIT(KSqlDeleteAll , "delete from dcf");

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

// MACROS

// LOCAL CONSTANTS AND MACROS

#ifdef RD_MULTIPLE_DRIVE

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

#endif

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

LOCAL_C TInt CreateDataBase(RFs& aFs);

#ifndef RD_MULTIPLE_DRIVE

LOCAL_C TParse DataFile();

#else // RD_MULTIPLE_DRIVE

LOCAL_C TParse DataFile( RFs& aFs );

#endif

LOCAL_C void CreateTablesL(RDbDatabase& aDatabase);

LOCAL_C TInt CreateDataBasePath(RFs& aFs);

// FORWARD DECLARATIONS

//#define _DRM_TESTING

//#define _MEM_HEAP_USAGE

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

#ifdef _DRM_TESTING

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

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

LOCAL_C void CreateLogL();

LOCAL_C void WriteL( const TDesC8& aText );

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

LOCAL_C void WriteCurrentTimeL();

#ifdef _MEM_HEAP_USAGE

LOCAL_C void WriteHeapAllocL();

#endif //_MEM_HEAP_USAGE

#endif //_DRM_TESTING

// -----------------------------------------------------------------------------

// Testing stuff

// -----------------------------------------------------------------------------

//

#ifdef _DRM_TESTING

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

    {

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

    WriteFileL( text , aFs , KLogFile );

    }

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

    {

    RFile file;

    TInt size;

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

    CleanupClosePushL( file );

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

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

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

    }

LOCAL_C void CreateLogL()

    {

    RFs fs;

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

    CleanupClosePushL(fs);

    RFile file;

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

    file.Close();

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

    }

LOCAL_C void WriteL( const TDesC8& aText )

    {

    RFs fs;

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

    CleanupClosePushL(fs);

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

    TPtr8 textptr(text->Des() );

    textptr.Append( aText );

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

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

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

    WriteCurrentTimeL();

#ifdef _MEM_HEAP_USAGE

    WriteHeapAllocL();

#endif //_MEM_HEAP_USAGE

    }

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

    {

    _LIT8(KErr,": %d");

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

    TBuf8<20> num;

    TPtr8 textptr(text->Des());

    textptr.Append(aText);

    num.Format(KErr(),aErr);

    textptr.Append(num);

    WriteL(textptr);

    CleanupStack::PopAndDestroy(text);

    }

LOCAL_C void WriteCurrentTimeL()

    {

    RFs fs;

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

    CleanupClosePushL(fs);

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

    TPtr8 textptr(text->Des() );

    // Date and Time display

    TTime time;

    time.HomeTime();

    TBuf<256> dateString;

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

    time.FormatL(dateString,KDate);

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

    textptr.Append( dateString );

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

    time.FormatL(dateString,KTime);

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

    textptr.Append( dateString );

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

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

    WriteLogL(textptr , fs);

    CleanupStack::PopAndDestroy(text);

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

    }

#ifdef _MEM_HEAP_USAGE

LOCAL_C void WriteHeapAllocL()

    {

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

    TBuf8<256> string;

    TInt size = 0;

    RFs fs;

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

    CleanupClosePushL(fs);

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

    string.Format(KHeapUsage(),size);

    WriteLogL(string , fs);

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

    }

#endif //_MEM_HEAP_USAGE

#endif //_DRM_TESTING

// -----------------------------------------------------------------------------

// DataFile

// Return TParse which contain database file name

// -----------------------------------------------------------------------------

//

#ifdef RD_MULTIPLE_DRIVE

LOCAL_C TParse DataFile( RFs& aFs )

#else

LOCAL_C TParse DataFile()

#endif

    {

#ifdef _DRM_TESTING

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

#endif

    TParse p;

#ifndef RD_MULTIPLE_DRIVE

    p.Set(KDbFileLocation,NULL,NULL);

#else //RD_MULTIPLE_DRIVE

    TInt driveNumber( -1 );

    TChar driveLetter;

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

    aFs.DriveToChar( driveNumber, driveLetter );

    TFileName dbFile;

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

    p.Set(dbFile,NULL,NULL);

#endif

    return p;

    }

// -----------------------------------------------------------------------------

// CreateTablesL

// Create table through database session

// -----------------------------------------------------------------------------

//

LOCAL_C void CreateTablesL(RDbDatabase& aDatabase)

    {

#ifdef _DRM_TESTING

    WriteL(_L8("CreateTablesL"));

#endif

    CDbColSet* columns = CDbColSet::NewLC();

    //filename columns

    TDbCol filename(KColFilename,EDbColLongText16);

    filename.iAttributes = TDbCol::ENotNull;

    columns->AddL(filename);

    //position columns

    TDbCol position(KColPosition,EDbColUint16);

    position.iAttributes = TDbCol::ENotNull;

    columns->AddL(position);

    //content id columns

    TDbCol cid(KColCid,EDbColLongText16);

    cid.iAttributes = TDbCol::ENotNull;

    columns->AddL(cid);

    //content group id columns

    TDbCol group(KColGroupId,EDbColLongText16);

    columns->AddL(group);

    //transaction id columns

    TDbCol ttid(KColTtid,EDbColText16,KTtidLen);

    columns->AddL(ttid);

    aDatabase.CreateTable( KTable,*columns);

    CleanupStack::PopAndDestroy(columns); //columns

    }

// -----------------------------------------------------------------------------

// CreateDataBasePath

// Create database with client side database access

// -----------------------------------------------------------------------------

//

LOCAL_C TInt CreateDataBasePath(RFs& aFs)

    {

#ifdef _DRM_TESTING

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

#endif

    TInt err = 0;

#ifndef RD_MULTIPLE_DRIVE

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

#else //RD_MULTIPLE_DRIVE

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

#endif

    return err;

    }

// -----------------------------------------------------------------------------

// CreateDataBase

// Create database with client side database access

// -----------------------------------------------------------------------------

//

LOCAL_C TInt CreateDataBase(RFs& aFs)

    {

#ifdef _DRM_TESTING

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

#endif

    RDbNamedDatabase database;

    TInt err = 0;

    TFileName file;

#ifndef RD_MULTIPLE_DRIVE

    file = DataFile().FullName();

#else // RD_MULTIPLE_DRIVE

    file = DataFile( aFs ).FullName();

#endif

    if (!err)

        {

#ifdef _DRM_TESTING

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

#endif

        err = CreateDataBasePath(aFs);

        err = database.Create(aFs,file);

        if (!err)

            {

#ifdef _DRM_TESTING

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

#endif

            TRAP( err , CreateTablesL(database) );

#ifdef _DRM_TESTING

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

#endif

            }

        database.Close();

        }

    return err;

    }

// -----------------------------------------------------------------------------

// From8To16

// transfer buf from 8 bit to 16 bit

// -----------------------------------------------------------------------------

//

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

    {

#ifdef _DRM_TESTING

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

#endif

    TInt err = KErrNone;

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

    if ( a16 )

        {

        TPtr ptr( a16->Des() );

        ptr.SetLength( a8.Length() );

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

            {

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

            }

        }

    else err = KErrNoMemory;

    return err;

    }

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

// -----------------------------------------------------------------------------

// CDcfRepSrv::CDcfRepSrv

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

// might leave.

// -----------------------------------------------------------------------------

//

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

    iScan(NULL),

    iCidList(NULL),

    iPairList(NULL),

    iState(EStateIdle),

    iArmed( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CDcfRepSrv::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CDcfRepSrv::ConstructL()

    {

#ifdef _DRM_TESTING

    CreateLogL();

    WriteL(_L8("ConstructL"));

#endif

    StartL(KDcfRepSrvName);

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

    iScan = CFileScan::NewL(iFs);

    OpenDatabaseL();

    User::RenameThread(KDcfRepSrvName);

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

    iProcWatcher->StartWatching();

    iArmed = ETrue;

    }

// -----------------------------------------------------------------------------

// CDcfRepSrv::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDcfRepSrv* CDcfRepSrv::NewLC()

    {

    CDcfRepSrv* self = new( ELeave ) CDcfRepSrv;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CDcfRepSrv::~CDcfRepSrv()

    {

#ifdef _DRM_TESTING

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

#endif

    delete iScan;

    CleanScanInternal();

    CleanDatabase();

    iFs.Close();

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

        {

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

            {

            iMessageList[i]->Complete(KErrCancel);

            }

        }

    iMessageList.ResetAndDestroy();

    iMessageList.Close();

    }

// -----------------------------------------------------------------------------

// CDcfRepSrv::NewSessionL

// Called when a client requires a new instance.

// -----------------------------------------------------------------------------

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

    const RMessage2& /*aMessage*/ ) const

    {

#ifdef _DRM_TESTING

    WriteL(_L8("NewSessionL"));

#endif

    // check we're the right version

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

                KDcfRepMinorVersionNumber,

                KDcfRepBuildVersionNumber),

            aVersion))

        {

        User::Leave(KErrNotSupported);

        }

    // make new session

    return CDcfRepSrvSes::NewL();

    }

// -----------------------------------------------------------------------------

// Startup().

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

// the cleanup stack and active scheduler.

// Returns: TInt: Symbian OS error code.

// -----------------------------------------------------------------------------

//

TInt CDcfRepSrv::Startup( void )

    {

    TInt err = 0;

    TBool clientIsWaiting = EFalse;

    RSemaphore semaphore;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (cleanupStack == NULL)

        {

        PanicServer(ECreateTrapCleanup);

        }

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

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

        {

        clientIsWaiting = ETrue;

        }

    TRAP(err, StartupL());

    // release client side waiting

    if (clientIsWaiting)

        {

        semaphore.Signal();

        semaphore.Close();

        }

    if (err != KErrNone)

        {

        PanicServer(ESrvCreateServer);

        }

    delete cleanupStack;

    cleanupStack = NULL;

    return KErrNone;

    }

// -----------------------------------------------------------------------------