/** @file

* Copyright (c) 2005-2006 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:  Content Directory

 *

*/

// INCLUDE FILES

#include <fbs.h>

#include <uri8.h>

#include <pathinfo.h>

#include <sysutil.h>

#include <bautils.h>

#include <caf/caf.h>

#include <caf/manager.h>

#include "upnpsender.h"

#include "upnpcontentdirectory.h"

#include "upnperrors.h"

#include "upnpdominterface.h"

#include "upnpstring.h"

#include "upnpargument.h" 

#include "upnphttpmessagefactory.h" 

#include "upnpcons.h"

#include "upnpdevice.h"

#include "upnpfileutils.h"

#include "upnpcommonupnplits.h"

#include "upnpcontainerupdateid.h"

#include "upnpcontentdirectorydb.h"

#include "upnpfiletransfertimerobserver.h"

#include "upnperror.h"

#include "upnpcustomlog.h"

#include "upnpprotocolinfo.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpresourcesbean.h"

#include "upnpcdutils.h"

#include "upnpmetadatastorage.h"

#include "upnpautodestroyobjectlist.h"

#include "upnpautodestroyobject.h"

#include "upnpcontentdirectoryeventobserver.h"

#include "upnpfiletransferevent.h"

#include "upnpfiletransfer.h"

#include "upnpprotocolinfolocal.h"

#include "upnpxmlcontentfilter.h"

#include "upnpstatehandler.h"

#include "upnptransferuploader.h"

#include "upnpmimemapper.h"

#include "upnptransfercontroller.h"

#include "upnptransferinterface.h"

#include "upnpdlnafilter.h"

#include "upnphttpserversession.h"

#include "upnphttpserverruntime.h"

#include "upnpsettings.h"

#include "upnpdeviceimplementationbase.h"

#include "upnpsecuritymanager.h"

#include "upnpmediaserversettings.h"

// Constant definitions

using namespace UpnpPaths;

using namespace UpnpDlnaProtocolInfo;

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

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

// DestroyRPointerArray

// Defined in upnpelementfactory.cpp

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

//

void DestroyRArray( TAny* aArray );

void RPointerArrayTPtrC8( TAny* aArray )

    {

    RPointerArray<TPtrC8>* array =

            reinterpret_cast<RPointerArray<TPtrC8>*>(aArray);

    array->ResetAndDestroy( );

    }

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

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

// CUpnpContentDirectory::CUpnpContentDirectory

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

// might leave.

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

//

CUpnpContentDirectory::CUpnpContentDirectory( CUpnpDevice& aDevice,

    MUpnpThumbnailCreatorObserver* aThmbObs, MUpnpTransferInterface* aTransfer ) :

    CUpnpServiceImplementation(aDevice), iThmbObs(aThmbObs),

            iTransferHandler(aTransfer)

    {

    SetExecutedAction( EUndefinedAction );

    }

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

// CUpnpContentDirectory::~CUpnpContentDirectory

// C++ default destructor

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

//

CUpnpContentDirectory::~CUpnpContentDirectory()

    {

    delete iDownloadDir;

    delete iThumbDir;

    delete iElementdb;

    delete iTransferController;

    delete iMimeToExtMap;

    delete iContentDirectoryDb;

    iThObjectIds.Close( );

    iThumbnailCreators.ResetAndDestroy( );

    iDOMImpl.Close( );

    if ( iBitmapServerConnection == KErrNone )

        RFbsSession::Disconnect( );

    iFs.Close( );

    if ( iEcomUsed )

        {

        REComSession::FinalClose( );

        }

    delete iAutoDestroyObjects;

    delete iStateHandler;

    if ( iHttpServerSession )

        {

        iHttpServerSession->Stop();

        }

    delete iHttpServerSession;

    delete iDlnaFilter;

    delete iSecurityManager;

    }

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

// CUpnpContentDirectory::ConstructL

// Two-phased constructor.

// Initialize variables, set parent service and create XML reader.

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

//

void CUpnpContentDirectory::ConstructL( TUpnpCdSettings aSettings,

    CUpnpMetadataStorage* aMetadataStorage )

    {

    iDOMImpl.OpenL( );

    iTransferController = CUpnpTransferController::NewL( this );

    iMimeToExtMap = CUpnpMimeMapper::NewL( );

    BaseConstructL( aSettings.iDescriptionPath, KContentDirectoryType( ) );

    User::LeaveIfNull( aSettings.iDevice );

    CUpnpSecurityManager* secMan = CUpnpSecurityManager::NewInstanceFromUpnpSettingsL();

    iSecurityManager = secMan;

    iDlnaFilter = CUpnpDlnaFilter::NewL( this, secMan );

    iElementdb = CUpnpElementFactory::NewL( aSettings.iObjectsXmlPath );

    iElementdb->GetContentDirectoryReference( this );

    SetStateVariableL( KSystemUpdateID( ), KZero( ) );

    SetStateVariableL( KContainerUpdateIDs( ), UpnpCD::KEmptyString( ) );

    SetStateVariableL( KTransferIDs( ), UpnpCD::KEmptyString( ) , EFalse );

    SetStateVariableL( KSortCapsVariableName( ), KSortCapabilities( ) );

    SetStateVariableL( KSearchCapsVariableName( ), KSearchCapabilities( ) );

    // file session 

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

    iBitmapServerConnection = RFbsSession::Connect( );

    iDownloadDir = aSettings.iDownloadDir.AllocL( );

    iThumbDir = aSettings.iThumbnailDir.AllocL( );

    iContentDirectoryDb = CUpnpContentDirectoryDb::NewL( aMetadataStorage );

    iAutoDestroyObjects = CUpnpAutoDestroyObjectList::NewL( );

    iCreateThumbnails = aSettings.iCreateThumbnail;

    iMaxRequestCount = aSettings.iMaxRequestCount;

    iEventObserver = aSettings.iEventObserver;

    iStateHandler = CUpnpStateHandler::NewL( this );

    ConstructHttpL();

    }

void CUpnpContentDirectory::ConstructHttpL()

    {

    TInt iapId = CUpnpSettings::GetIapL();

    iHttpServerSession = CUpnpHttpServerSession::NewL( iapId, *this );

    iHttpServerSession->DefaultRuntime().SetCreator( *this );

    iHttpServerSession->StartL();

    }

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

// CUpnpContentDirectory::NewL

// Two-phased constructor.

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

//

CUpnpContentDirectory* CUpnpContentDirectory::NewL(

    TUpnpCdSettings aSettings, CUpnpMetadataStorage* aMetadataStorage,

    MUpnpTransferInterface* aTransfer )

    {

    CUpnpContentDirectory* cd = new (ELeave) CUpnpContentDirectory( *aSettings.iDevice,

            aSettings.iThmbObs,

            aTransfer

    );

    CleanupStack::PushL( cd );

    cd->ConstructL( aSettings, aMetadataStorage );

    CleanupStack::Pop( cd );

    return cd;

    }

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

// CUpnpContentDirectory::ActionReceivedLD

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

//

void CUpnpContentDirectory::ActionReceivedLD( CUpnpAction* aAction )

    {

    CleanupStack::PushL( aAction );

    //check security

    if ( iSecurityManager &&

            KErrNone != iSecurityManager->AuthorizeAction( aAction ) )

        {

        //server returns upnp error action failed when not authorized

        User::Leave(EActionFailed);

        }

    // in case of low disk space

    if ( !IsDbOrDiskProblemL( aAction ) )

        {

        // handle event

        TInt ret = EUpnpUndefined;

        TRAPD( err, ret = DoActionReceivedL( aAction ) );

        if ( DataBaseHasBeenRecoveredL( err ) )

            {

            TRAP( err, ret = DoActionReceivedL( aAction ) );

            if ( err == KErrCorrupt )

                {

                err = iContentDirectoryDb->RecreateDatabaseFile();

                }

            }

        else if ( err == KErrNone )

            {

            err = ret;

            }

        LOGS( "ContentDirectory ActionReceivedLD sending soon." );

        DoSendActionL( aAction, TUpnpError( err ) );

        }

    CleanupStack::PopAndDestroy( aAction );

    }

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

// CUpnpContentDirectory::DoActionReceivedL

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

//

TInt CUpnpContentDirectory::DoActionReceivedL( CUpnpAction* aAction )

    {

    // sendAndDestroy defines that after processing action must be 

    // sent and destroyed

    TUpnpErrorCode err = EUndefined;

    // Get the name, saves calls in the if-else statements

    TPtrC8 name( aAction->Name() );

    // Verify the action and do the operation(s)

    if ( name.Compare( KBrowse ) == 0 )

        {

        err = BrowseL( aAction );

        }

    else if ( name.Compare( KCreateReference ) == 0 )

        {

        err = CreateReferenceL( aAction );

        }

    else if ( name.Compare( KCreateObject ) == 0 )

        {

        LOGS( "ContentDirectory: Creating a new object" );

        err = CreateObjectL( aAction );

        }

    else if ( name.Compare( KDeleteResource ) == 0 )

        {

        err = DeleteResourceL( aAction );

        }

    else if ( name.Compare( KDestroyObject ) == 0 )

        {

        err = DestroyObjectL( aAction );

        }

    else if ( name.Compare( KExportResource ) == 0 )

        {

        err = ExportResourceL( aAction );

        }

    else if ( name.Compare( KGetSearchCapabilities ) == 0 )

        {

        err = GetSearchCapabilitiesL( aAction );

        }

    else if ( name.Compare( KGetSortCapabilities ) == 0 )

        {

        err = GetSortCapabilitiesL( aAction );

        }

    else if ( name.Compare( KGetSystemUpdateID ) == 0 )

        {

        err = GetSystemUpdateIdL( aAction );

        }

    else if ( name.Compare( KGetTransferProgress ) == 0 )

        {

        err = GetTransferProgressL( aAction );

        }

    else if ( name.Compare( KImportResource ) == 0 )

        {

        err = ImportResourceL( aAction );

        }

    else if ( name.Compare( KStopTransferResource ) == 0 )

        {

        err = StopTransferResourceL( aAction );

        }

    else

        {

        err = EInvalidAction;

        }

    return err;

    }

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

// CUpnpContentDirectory::DoActionReceivedCDL

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

//    

void CUpnpContentDirectory::HttpGetStartedSoapNotifyL( TInt /*aSessionId*/)

    {

    // not needed upnp response returned by ActionReceivedCDL

    }

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

// CUpnpContentDirectory::DoActionReceivedCDL

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

//    

void CUpnpContentDirectory::HttpPostStartedL( TInt /*aSessionId*/)

    {

    // not needed upnp response returned by ActionReceivedCDL

    }

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

// CUpnpContentDirectory::UnknownHttpEventReceivedL 

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

//

EXPORT_C void CUpnpContentDirectory::UnknownHttpEventReceivedL( CUpnpHttpMessage& aHttpMsg )

    {

    CUpnpFileTransferEvent* transferEvent =

            iTransferController->TransferL( aHttpMsg.SessionId( ) );

    if ( !transferEvent )

        {

        return;

        }

    TInt err = aHttpMsg.Error( );

    if ( err != EHttpRequestTimeout && err != EHttpInsufficientStorage )

        {

        err = EHttpOk;

        }

    HBufC* fileName16 = UpnpString::ToUnicodeL( aHttpMsg.InFilename( ) );

    CleanupStack::PushL( fileName16 );

    transferEvent->SetFilePathL( *fileName16 );

    CleanupStack::PopAndDestroy( fileName16 );

    iTransferController->HttpResponseReceivedL( aHttpMsg.SessionId( ), err );

    }

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

// CUpnpContentDirectory::IsDrmFileL 

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

//

TBool CUpnpContentDirectory::IsDrmFileL( const TDesC8& aFileName )

    {

    HBufC* tmp = UpnpCdUtils::Des8ToDesLC( aFileName );

    TBool ret = IsDrmFileL( *tmp );

    CleanupStack::PopAndDestroy( tmp );

    return ret;

    }

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

// CUpnpContentDirectory::IsDrmFileL 

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

//

TBool CUpnpContentDirectory::IsDrmFileL( const TDesC& aFileName )

    {

    if ( !BaflUtils::FileExists( iFs, aFileName ) )

        {

        return EFalse;

        }

    TBool ret = EFalse;

    TInt value=0, err;

    ContentAccess::CManager *manager = ContentAccess::CManager::NewL( );

    CleanupStack::PushL( manager );

    ContentAccess::CVirtualPath *path =

            ContentAccess::CVirtualPath::NewL( aFileName );

    CleanupStack::PushL( path );

    ContentAccess::TVirtualPathPtr virtualPath = *path;

    err = manager->GetAttribute( ContentAccess::EIsProtected, value,

        virtualPath );

    if ( err == KErrNone )

        {

        if ( value )

            {

            // delete file

            iFs.Delete( aFileName );

            ret = ETrue;

            }

        }

    CleanupStack::PopAndDestroy( 2, manager );

    return ret;

    }

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

// CUpnpContentDirectory::CreateReferenceL

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

//

TUpnpErrorCode CUpnpContentDirectory::CreateReferenceL( CUpnpAction*& aAction )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    // Get IDs from action 

    TInt conId( KErrNotFound );

    TInt objId( KErrNotFound );

    TInt err = UpnpCdUtils::StringToInteger(

        aAction->ArgumentValue( KContainerID ), &conId );

    if ( err!=KErrNone )

        {

        err=ENoContainer;

        User::Leave( ENoContainer );

        }

    err = UpnpCdUtils::StringToInteger(

        aAction->ArgumentValue( UpnpCD::KObjectID ), &objId );

    if ( err!=KErrNone )

        {

        err=ENoContainer;

        User::Leave( ENoSuchObject );

        }

    objId = iContentDirectoryDb->ReferedObjectIdL( objId );

    RXmlEngDocument conDidl;

    RXmlEngDocument objDidl;

    CleanupClosePushL( conDidl );

    CleanupClosePushL( objDidl );

    ret = iContentDirectoryDb->GetObjectL( conId, conDidl, KAsterisk8 );

    if ( ret != EUpnpOk )

        User::Leave( ENoContainer );

    ret = iContentDirectoryDb->GetObjectL( objId, objDidl, KAsterisk8 );

    if ( ret != EUpnpOk )

        User::Leave( ENoSuchObject );

    TXmlEngElement con = conDidl.DocumentElement().FirstChild().AsElement( );

    TXmlEngElement obj = objDidl.DocumentElement().FirstChild().AsElement( );

    if ( obj.Name().Compare( KItem ) != 0 )

        {

        User::Leave( ENoSuchObject );

        }

    if ( con.Name().Compare( KContainer ) != 0 )

        {

        User::Leave( ENoContainer );

        }

    if ( iContentDirectoryDb->CheckObjectRestrictionL( conId ) != EUpnpOk )

        {

        User::Leave( ERestrictedParentObject );

        }

    TInt refId;

    RXmlEngDocument refDidl = iContentDirectoryDb->PrepareDidlDocumentL( );

    CleanupClosePushL( refDidl );

    TXmlEngElement refEl = refDidl.DocumentElement().AddNewElementSameNsL( KItem( ) );

    refEl.AddNewAttributeL( KRefID( ),

        aAction->ArgumentValue( UpnpCD::KObjectID ) );

    refEl.AddNewAttributeL( KParentID( ),

        aAction->ArgumentValue( KContainerID ) );

    refEl.AddNewAttributeL( KRestricted( ), KFalseValue8( ) );

    // title

    TXmlEngElement objTitle;

    UpnpDomInterface::GetElementL( obj, objTitle, KObjTiltleColName8( ) );

    refEl.AppendChildL( objTitle.Unlink().AsElement( ) );

    // class

    TXmlEngElement objClass;

    UpnpDomInterface::GetElementL( obj, objClass, KObjClassColName8( ) );

    refEl.AppendChildL( objClass.Unlink().AsElement( ) );

    iContentDirectoryDb->InsertObjectL( refDidl, conId, &refId );

    //increase system update ID

    iStateHandler->IncreaseSystemUpdateIdL( );

    iStateHandler->IncreaseContainerUpdateIdL( (TDesC8&)aAction->ArgumentValue( KContainerID ) );

    TBuf8<KMaxIntegerLen> newid;

    newid.Num( refId );

    aAction->SetArgumentL( (TDesC8&)KNewID, newid );

    CleanupStack::PopAndDestroy( &refDidl );

    CleanupStack::PopAndDestroy( &objDidl );

    CleanupStack::PopAndDestroy( &conDidl );

    return EHttpOk;

    }

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

// CUpnpContentDirectory::BrowseL

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

//