/*

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

* 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:  WMDRM Server implementation

*

*/

#include <f32file.h>

#include <systemwarninglevels.hrh>

#include "wmdrmfileserversession.h"

#include "wmdrmfileserver.h"

#define _LOGGING_FILE L"wmdrmfileserver.txt"

// Due to TCB capability logging can not be used

// #include "flogger.h"

// #include "logfn.h"

// rights server uid

const TUint32 KRightsServer = 0x101F51F2;

_LIT( KSecureStore, "securestore" );

_LIT( KLicenseStore, "licstore" );

_LIT( KDefaultNamespace, "hds");

_LIT( KStorePathTemplate, "%c:\\sys\\private\\2000B180\\%S\\%S\\");

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

// Implmentation from securitycheckutil.cpp with some reductions

LOCAL_C TBool CheckFileName(const TFileName& aFileName, TChar aSystemDriveChar)

    {

    if (aFileName.Length() > KMaxFileName)

            {

            return EFalse;

            }

    // Check for full drive and path

    TChar drive(aFileName[0]);

    _LIT(KDriveSeparator, ":\\");

    if (!drive.IsAlpha() || aFileName.Find(KDriveSeparator) != 1)

            {

            return EFalse;

            }

    // Check for double slashes

    _LIT(KDoubleSlash, "\\\\");

    if (aFileName.Find(KDoubleSlash) != KErrNotFound)

            {

            return EFalse;

            }

    // Check for .. in the path

    _LIT(KDoubleDotPath, "..\\");

    if (aFileName.Find(KDoubleDotPath) != KErrNotFound)

            {

            return EFalse;

            }

    // Check for references to writable SwiCertstore

    _LIT(KWritableSwiCertStore, ":\\Resource\\SwiCertstore");

    TBuf<32> writableSwiCertStorePath;

    writableSwiCertStorePath.Append(aSystemDriveChar);

    writableSwiCertStorePath.Append(KWritableSwiCertStore);

    if (aFileName.FindF(writableSwiCertStorePath) != KErrNotFound)

            {

            return EFalse;

            }

    return ETrue;

    }

LOCAL_C TBool IsSubstedDriveL(RFs& aFs, const TFileName& aFileName)

    {

    TChar drvCh = aFileName[0];

    TInt drvNum;

    User::LeaveIfError(RFs::CharToDrive(drvCh, drvNum));

    TDriveInfo drvInfo;

    User::LeaveIfError(aFs.Drive(drvInfo, drvNum));

    //if the drive is subst'd return true

    if(drvInfo.iDriveAtt & KDriveAttSubsted)

        {

        return ETrue;

        }

    return EFalse;  

    }

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

// Create a safe filename which can be used under the WMDRM file server

// root by filtering all illegal characters

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

//

LOCAL_C void CreateSafeFileNameL( 

    TFileName& aTarget, 

    const TBuf<KFileNameSize>& aSource,

    RFs &aFs )

    {

    TInt i;

    TChar c;

    TBool suffix = ETrue;

    TInt driveNumber( RFs::GetSystemDrive() );

	TChar driveLetter;

    User::LeaveIfError( RFs::DriveToChar( driveNumber, driveLetter ) );

	TFileName storeRootFile;

	storeRootFile.Format( KStoreRoot, (TUint)driveLetter );

    if ( aSource.Length() + storeRootFile.Length() + 1 > aTarget.MaxLength() - aTarget.Length() )

        {

        User::Leave( KErrArgument );

        }

    aTarget.Copy( storeRootFile );

    aTarget.Append( '\\' );

	for ( i = 0 ; i < aSource.Length(); i++ )

	    {

	    c = aSource[i];

        // Change all non-alphanumeric characters to underscores,

        // except for the colon separating the file suffix

	    if ( !c.IsAlphaDigit() && !suffix )

	        {

	        c = '_';

	        }

        // Once the suffix colon has been processed, replace all non-alphanumeric characters

	    if ( suffix && c == '.' )

            {

            suffix = EFalse;

            }

	    aTarget.Append( c );

	    }

    if( IsSubstedDriveL( aFs, aTarget ) || !CheckFileName( aTarget, driveLetter ) )

        {

        User::Leave(KErrArgument);

        }

    }

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

// Extract the path components from a full filename

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

//

LOCAL_C void GetPath( const TDesC& aFilename, TPtrC& aPath )

    {

    TInt i = aFilename.Length() - 1;

    while ( i >= 0 && aFilename[i] != '\\' )

        {

        i--;

        }

    if ( aFilename[i] == '\\' )

        {

        i++;

        }

    return aPath.Set( aFilename.Left( i ) );

    }

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

// Check if system drive has <= KDRIVECCRITICALTHRESHOLD free space and in 

// that case leave with KErrDiskFull

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

//

LOCAL_C void CheckFreeSpaceL( RFs &aFs, TInt aBytesToWrite )

    {

    TVolumeInfo info;

    User::LeaveIfError( aFs.Volume( info, aFs.GetSystemDrive() ) );

    if ( info.iFree - aBytesToWrite <= KDRIVECCRITICALTHRESHOLD )

        {

        User::Leave( KErrDiskFull );

        }

    }

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

CWmDrmFileServerSession::CWmDrmFileServerSession()

	{

    //LOGFN( "CWmDrmFileServerSession::CWmDrmFileServerSession" );

	}

CWmDrmFileServerSession::~CWmDrmFileServerSession()

	{

	//LOGFN( "CWmDrmFileServerSession::~CWmDrmFileServerSession" );

    iFile.Close();

	}

TInt CWmDrmFileServerSession::OpenL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    //LOGFNR( "CWmDrmFileServerSession::OpenL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    iFile.Close();

    aMessage.ReadL( 0, fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    //LOG( path );

    r = iFile.Open( Server().Fs(), path, EFileRead | EFileWrite );

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::CreateL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    TPtrC folders( NULL, 0 );

    //LOGFNR( "CWmDrmFileServerSession::CreateL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    iFile.Close();

    aMessage.ReadL( 0, fileName );

    //LOG( fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    GetPath( path, folders ); 

    CheckFreeSpaceL( Server().Fs(), 0 );

    Server().Fs().MkDirAll( folders );

    //LOG( path );

    r = iFile.Replace( Server().Fs(), path, EFileRead | EFileWrite );

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::ReadL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    RBuf8 buf;

    TInt amountRead = 0;

    TInt pos = 0;

    //LOGFNR( "CWmDrmFileServerSession::ReadL", r );

    __UHEAP_MARK;

    if ( iFile.SubSessionHandle() == KNullHandle )

        {

        User::Leave( KErrNotReady );

        }

    buf.CreateL( aMessage.GetDesMaxLengthL( 0 ) );

    CleanupClosePushL( buf );

    iFile.Seek( ESeekStart, pos );

    r = iFile.Read( buf );

    if ( r == KErrNone )

        {

        aMessage.WriteL( 0, buf );

        amountRead = buf.Size();

        }

    aMessage.WriteL( 1, TPckg<TInt>( amountRead ) );

    //LOG2( "Read %d bytes", amountRead );

    CleanupStack::PopAndDestroy(); // buf

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::WriteL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    RBuf8 buf;

    TInt pos = 0;

    //LOGFNR( "CWmDrmFileServerSession::WriteL", r );

    __UHEAP_MARK;

    if ( iFile.SubSessionHandle() == KNullHandle )

        {

        User::Leave( KErrNotReady );

        }

    CheckFreeSpaceL( Server().Fs(), aMessage.GetDesLengthL( 0 ) );

    buf.CreateL( aMessage.GetDesLengthL( 0 ) );

    CleanupClosePushL( buf );

    aMessage.ReadL( 0, buf );

    iFile.Seek( ESeekStart, pos );

    iFile.SetSize( 0 );

    r = iFile.Write( buf );

    CleanupStack::PopAndDestroy(); // buf

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::SizeL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    //LOGFNR( "CWmDrmFileServerSession::SizeL", r );

    __UHEAP_MARK;

    if ( iFile.SubSessionHandle() == KNullHandle )

        {

        User::Leave( KErrNotReady );

        }

    r = iFile.Size( size );

    if ( r == KErrNone )

        {

        aMessage.WriteL( 0, TPckg<TInt>( size ) );

        }

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::IsOpenL( const RMessage2& /*aMessage*/ )

    {

    TInt r = KErrNone;

    //LOGFNR( "CWmDrmFileServerSession::IsOpenL", r );

    if ( iFile.SubSessionHandle() == KNullHandle )

        {

        r = KErrNotReady;

        }

    return r;

    }

TInt CWmDrmFileServerSession::CloseFileL( const RMessage2& /*aMessage*/ )

    {

    TInt r = KErrNone;

    //LOGFNR( "CWmDrmFileServerSession::CloseFileL", r );

    iFile.Close();

    return r;

    }

TInt CWmDrmFileServerSession::DeleteL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    //LOGFNR( "CWmDrmFileServerSession::DeleteL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    aMessage.ReadL( 0, fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    r = Server().Fs().Delete( path );

    //LOG( path );

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::MkDirAllL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    TUint att;

    //LOGFNR( "CWmDrmFileServerSession::MkDirAllL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    aMessage.ReadL( 0, fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    //LOG( path );

    if ( !aMessage.Int1() && ( r = Server().Fs().Att( path, att ) ) != KErrNone )

        {

        User::Leave( r );

        }

    CheckFreeSpaceL( Server().Fs(), 0 );

    r = Server().Fs().MkDirAll( path );

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::RmDirAllL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    CFileMan* fileMan;

    //LOGFNR( "CWmDrmFileServerSession::RmDirAllL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    fileMan = CFileMan::NewL( Server().Fs() );

    CleanupStack::PushL( fileMan );

    aMessage.ReadL( 0, fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    r = fileMan->RmDir( path );

    //LOG( path );

    CleanupStack::PopAndDestroy(); // fileMan

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::RmDirL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TFileName path;

    TBuf<KFileNameSize> fileName;

    //LOGFNR( "CWmDrmFileServerSession::RmDirL", r );

    __UHEAP_MARK;

    if ( aMessage.GetDesLength( 0 ) > KFileNameSize )

        {

        User::Leave( KErrArgument );

        }

    aMessage.ReadL( 0, fileName );

    CreateSafeFileNameL( path, fileName, Server().Fs() );

    r = Server().Fs().RmDir( path );

    //LOG( path );

    __UHEAP_MARKEND;

    return r;

    }

TInt CWmDrmFileServerSession::UpdateSecureTimeL( const RMessage2& aMessage )

    {

    TInt r = KErrNone;

    TTime homeTime;

    TTime utcTime;

    RThread client;

    TPckg<TTime> package( homeTime );

    TPckg<TTime> package2( utcTime );

    // Get the client:

    aMessage.ClientL( client );

    CleanupClosePushL( client );

    // Check client, if client is not the rights server, access denied:

    _LIT_SECURITY_POLICY_S0(swSidCheck2, KRightsServer);

    if( !swSidCheck2().CheckPolicy(client) )

        {

        User::Leave( KErrAccessDenied );

        }

    CleanupStack::PopAndDestroy( &client );

    aMessage.ReadL( 0, package );

    aMessage.ReadL( 1, package2 );

    // Set the secure time:

    User::LeaveIfError( User::SetUTCTimeSecure( utcTime ) );

    //User::LeaveIfError( User::SetHomeTimeSecure( homeTime ) ); 

    return r;

    }

TInt CWmDrmFileServerSession::DeleteRightsL( const RMessage2& /*aMessage*/ )

    {

    TInt r = KErrNone;

    TInt finalErr = KErrNone;

	TFileName storeRootFile;

	CFileMan* fileMan = NULL;

    //LOGFNR( "CWmDrmFileServerSession::DeleteRightsL", r );

    __UHEAP_MARK;

    fileMan = CFileMan::NewL( Server().Fs() );

    CleanupStack::PushL( fileMan );

    // Remove the stores:

    TInt driveNumber( RFs::GetSystemDrive() );

	TChar driveLetter;

    User::LeaveIfError( RFs::DriveToChar( driveNumber, driveLetter ) );

	storeRootFile.Format( KStorePathTemplate, (TUint)driveLetter, &KDefaultNamespace, &KLicenseStore );

	//r = Server().Fs().RmDir( storeRootFile );    

    r = fileMan->RmDir( storeRootFile );

    if( r < KErrNone )

        {

        finalErr = r;

        }

	storeRootFile.Format( KStorePathTemplate, (TUint)driveLetter, &KDefaultNamespace, &KSecureStore );

    //r = Server().Fs().RmDir( storeRootFile );

    r = fileMan->RmDir( storeRootFile );     

    if( !finalErr && r < KErrNone )

        {

        finalErr = r;

        }

    CleanupStack::PopAndDestroy( fileMan );    	

    __UHEAP_MARKEND;

    return finalErr;

    }

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

// Main service function. All services require DRM capability!

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

//

void CWmDrmFileServerSession::ServiceL( const RMessage2& aMessage )

	{

	TInt r = KErrNone;

	TInt trap = KErrNone;

	_LIT_SECURITY_POLICY_C1(drmCheck, ECapabilityDRM);

    RThread client;

	//LOGFNR( "CWmDrmFileServerSession::ServiceL", r );