/** @file

 * Copyright (c) 2005-2009 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:  CUpnpDlnaFilter implementation.

 *

 */

// INCLUDES

#include <bautils.h> 

#include "upnpdlnafilter.h"

#include "upnpstring.h"

#include "upnpcons.h"

#include "upnpcontentdirectorydatafinder.h"

#include "upnphttpmessage.h"

#include "upnpdlnaprotocolinfo.h"

#include "upnpfileutils.h"

#include "upnpsecuritymanager.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include "upnphttpfilereceivetransaction.h"

#include "upnphttpdataservetransaction.h"

#include "upnpdlnafilterheaders.h"

#include "upnpcommonupnplits.h"

#include "upnpdlnacorelation.h"

// CONSTANTS

_LIT8( KDlnaFilter, "DLNA");

_LIT8( KIpPortPlaceholder8, "___.___.___.___:_____" );

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

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

// CUpnpDlnaFilter::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpDlnaFilter* CUpnpDlnaFilter::NewL(

    MUpnpContentDirectoryDataFinder* aFinder,

    CUpnpSecurityManager* aSecurityManager )

    {

    CUpnpDlnaFilter* self =

            CUpnpDlnaFilter::NewLC( aFinder, aSecurityManager );

    CleanupStack::Pop( self );

    return self;

    }

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

//  CUpnpDlnaFilter::NewTransactionL

//

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

//

EXPORT_C void CUpnpDlnaFilter::NewTransactionL( const TDesC8& aMethod, const TDesC8& aUri, 

    const TInetAddr& aSender, CUpnpHttpServerTransaction*& aResultTrans )

    {

    if ( aMethod == KHttpPost() )

        {

        aResultTrans = CUpnpHttpFileReceiveTransaction::NewL( *this, aSender, aUri );

        }

    else

        {

        aResultTrans = CUpnpHttpDataServeTransaction::NewL( *this, aSender, aUri );

        }

    }

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

// CUpnpDlnaFilter::NewLC

// Two-phased constructor.

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

//

EXPORT_C CUpnpDlnaFilter* CUpnpDlnaFilter::NewLC(

    MUpnpContentDirectoryDataFinder* aFinder,

    CUpnpSecurityManager* aSecurityManager )

    {

    CUpnpDlnaFilter* self = new (ELeave) CUpnpDlnaFilter( aFinder,

        aSecurityManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpDlnaFilter::CUpnpDlnaFilter

// C++ default constructor.

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

//

CUpnpDlnaFilter::CUpnpDlnaFilter( MUpnpContentDirectoryDataFinder* aFinder,

    CUpnpSecurityManager* aSecurityManager ) :

    iCdDataFinder( aFinder ), iSecurityManager( aSecurityManager )

    {

    }

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

// CUpnpDlnaFilter::~CUpnpDlnaFilter

// C++ default destructor.

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

//

CUpnpDlnaFilter::~CUpnpDlnaFilter()

    {

    iFs.Close();

    delete iProtocolInfo;

    }

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

// CUpnpDlnaFilter::ConstructL

// EPOC default constructor for performing 2nd stage construction.

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

//

void CUpnpDlnaFilter::ConstructL()

    {

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

    User::LeaveIfNull(iCdDataFinder);

    }

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

// CUpnpDlnaFilter::SecurityManager

// 

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

//

CUpnpSecurityManager* CUpnpDlnaFilter::SecurityManager()

    {

    return iSecurityManager;

    }

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

// CUpnpDlnaFilter::CheckImportUriL

// Checks if specified URI exists in database and returns object id for

//      given URI or KErrNotFound if URI is no registered in database.

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

//

TInt CUpnpDlnaFilter::CheckImportUriL( TDesC8& aImportUri )

    {

    TInt lastPosOfSlash = aImportUri.LocateReverse( '/' );

    if ( lastPosOfSlash < 0 )

        {

        return KErrGeneral;

        }

    HBufC8* path = aImportUri.AllocLC();

    TInt result = KErrNone;

    result = iCdDataFinder->CheckImportUriL( path->Des() );

    CleanupStack::PopAndDestroy( path );

    return result;

    }

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

// CUpnpDlnaFilter::Get3rdFieldFromCdL

// Find protocolInfo by contentUri (Not by importUri) and extract 3rd field,

//      using ContentDirectory.

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

//

HBufC8* CUpnpDlnaFilter::ThirdFieldFromCdL( const TDesC8& aContentUri )

    {

    HBufC8* result = NULL;

    CUpnpDlnaProtocolInfo* protocolInfo = ProtocolInfoL( aContentUri );

    CleanupStack::PushL(protocolInfo);

    if ( protocolInfo )

        {

        TPtrC8 thirdField = protocolInfo->ThirdField();

        if ( thirdField != KNullDesC8() )

            {

            result = thirdField.AllocL();

            }

        }

    CleanupStack::PopAndDestroy(protocolInfo);

    return result;

    }

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

// CUpnpDlnaFilter::ProtocolInfoL

// 

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

//

CUpnpDlnaProtocolInfo* CUpnpDlnaFilter::ProtocolInfoL( const TDesC8& aContentUri )

    {

    //  "http:/:/" prefix is added to content path to provide backward 

    // compatibility with old testing tools

    HBufC8* fullContentUri = HBufC8::NewL( UpnpHTTP::KHTTPUrl().Length()

            + KIpPortPlaceholder8().Length() + aContentUri.Length() );

    CleanupStack::PushL( fullContentUri );

    fullContentUri->Des().Append( UpnpHTTP::KHTTPUrl );

    fullContentUri->Des().Append( KIpPortPlaceholder8 );

    fullContentUri->Des().Append( aContentUri );

    CUpnpDlnaProtocolInfo* protocolInfo = NULL;

    if ( iCdDataFinder->GetProtocolInfoL( *fullContentUri, protocolInfo ) != KErrNone )

        {

        delete protocolInfo;

        protocolInfo = NULL;

        }

    CleanupStack::PopAndDestroy( fullContentUri );

    return protocolInfo;

    }

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

// CUpnpDlnaFilter::GetMediaFileNameL

// Gets name of file with content for given object's id.

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

//

void CUpnpDlnaFilter::GetMediaFileNameL( TInt aObjectId, TPtr& aFileName )

    {

    if ( aObjectId <= KErrNone )

        {

        return;

        }

    iCdDataFinder->GetTitleForUriL( aObjectId, aFileName );

    }

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

// CUpnpDlnaFilter::FindSharedFolderDBL

// Find a folder shared from DB (ContentDirectory).

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

//

TInt CUpnpDlnaFilter::FindSharedFolderDBL( const TDesC8& aUrlPath,

    const TDesC8& aFileName, HBufC8*& aSystemPath )

    {

    HBufC* unicodeSharedFolder = NULL;

    TInt result = KErrNone;

    HBufC16* urlPathUnicode = UpnpString::ToUnicodeL( aUrlPath );

    CleanupStack::PushL( urlPathUnicode );

    HBufC16* fileNameUnicode = UpnpString::ToUnicodeL( aFileName );

    CleanupStack::PushL( fileNameUnicode );

    result = iCdDataFinder->FindSharedFolderL( *urlPathUnicode,

        *fileNameUnicode, unicodeSharedFolder );

    if ( unicodeSharedFolder )

        {

        CleanupStack::PushL( unicodeSharedFolder );

        HBufC8* sharedFolder =

                UpnpString::FromUnicodeL( *unicodeSharedFolder );

        CleanupStack::PopAndDestroy( unicodeSharedFolder );

        aSystemPath = sharedFolder;

        }

    CleanupStack::PopAndDestroy( fileNameUnicode );

    CleanupStack::PopAndDestroy( urlPathUnicode );

    return result;

    }

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

//  CUpnpDlnaFilter::CheckDLNAPostCorrelationsL

//

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

//

TInt CUpnpDlnaFilter::CheckDLNAPostCorrelationsL( CUpnpHttpFileReceiveTransaction& aTransaction )

    {

    HBufC8* decodedContentURI = DecodeContentUriLC(aTransaction.SenderUri());

    TBool streamingSupport = 0;

    TBool interactiveSupport = 0;

    CUpnpDlnaProtocolInfo* protocolInfo = NULL;

    TRAPD( error, protocolInfo =

            iCdDataFinder->GetProtocolInfoByImportUriL( *decodedContentURI ) );

    CleanupStack::PopAndDestroy( decodedContentURI );

    if ( error )

        {

        if ( error == ERestrictedObject || error == ERestrictedParentObject )

            {

            return -EHttpForbidden;

            }

        else if ( error == ENoSuchObject )

            {

            return -EHttpNotFound;

            }

        else

            {

            return -EHttpBadRequest;

            }

        }

    CleanupStack::PushL( protocolInfo );

    if ( protocolInfo->FourthField().Find( KDlnaFilter ) == KErrNotFound )

        {

        aTransaction.FilterHeaders().RemoveHeaderL( UpnpDLNA::KHdrTransferMode );

        CleanupStack::PopAndDestroy( protocolInfo );

        return KErrNone;

        }

    else

        {

        streamingSupport = protocolInfo->DlnaFlag(

            UpnpDlnaProtocolInfo::TM_S_FLAG );

        interactiveSupport = protocolInfo->DlnaFlag(

            UpnpDlnaProtocolInfo::TM_I_FLAG );

        CleanupStack::PopAndDestroy( protocolInfo );

        }

    TDesC8& transferMode = aTransaction.FilterHeaders().QueryHeader(

                           UpnpDLNA::KHdrTransferMode );

    if ( transferMode.Length() > 0 )

        {

        if ( (transferMode.CompareC( UpnpDLNA::KTransferModeStreaming ) == 0

                && !streamingSupport) || (transferMode.CompareC(

            UpnpDLNA::KTransferModeInteractive ) == 0 && !interactiveSupport) )

            {

            return -EHttpNotAcceptable;

            }

        if ( transferMode.CompareC( UpnpDLNA::KTransferModeStreaming ) != 0

                && transferMode.CompareC( UpnpDLNA::KTransferModeInteractive )

                        != 0 && transferMode.CompareC(

            UpnpDLNA::KTransferModeBackground ) != 0 )

            {

            return -EHttpBadRequest;

            }

        }

    return KErrNone;

    }

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

//  CUpnpDlnaFilter::CheckDLNACorrelations

//

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

//

TInt CUpnpDlnaFilter::CheckDLNACorrelationsL( CUpnpHttpDataServeTransaction& aTransaction )

    {

    HBufC8* decodedContentURI = DecodeContentUriLC(aTransaction.SenderUri());

    delete iProtocolInfo;

    iProtocolInfo = NULL;

    iProtocolInfo = ProtocolInfoL( *decodedContentURI );

    CleanupStack::PopAndDestroy( decodedContentURI );    

    TPtrC8 fourthField( KNullDesC8 );

    if ( iProtocolInfo )

        {

        fourthField.Set( iProtocolInfo->FourthField() );

        }

    if ( fourthField.Find( KDlnaFilter ) == KErrNotFound )

        {

        aTransaction.FilterHeaders().RemoveHeaderL( UpnpDLNA::KHdrTransferMode );

        return KErrNone;

        }

    TUpnpDlnaCorelation dlnaCorelation;

    dlnaCorelation.iFourthField.Set( fourthField );

    TInt corelationError = CheckCorelationL( aTransaction, dlnaCorelation );

    if ( corelationError != KErrNone )

        {

        return corelationError;

        }

    corelationError = CheckTransferModeL( aTransaction, dlnaCorelation );

    if ( corelationError != KErrNone )

        {

        return corelationError;

        }    

    return KErrNone;

    }

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

// CUpnpHttpServer::CheckCorelationL

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

//    

TInt CUpnpDlnaFilter::CheckCorelationL(  CUpnpHttpDataServeTransaction& aTransaction,

                                         TUpnpDlnaCorelation& aDlnaCorelation )

    {

    //-------------Checking DLNA correlations, response with HTTPerror if some problem occurs

    aDlnaCorelation.iStreamingSupport = EFalse;

    aDlnaCorelation.iInteractiveSupport = EFalse;

    aDlnaCorelation.iBackgrondSupport = EFalse;

    aDlnaCorelation.iGetContentFeaturesExist = EFalse;

    aDlnaCorelation.iGetContentFeaturesIsOK = ETrue;

    /* We can only check for getcontentFeaturesExist if we have cdDataFinder 

     * ( protocolInfo is not null )*/

    if ( iProtocolInfo )

        {

        aDlnaCorelation.iBackgrondSupport = 1;

        aDlnaCorelation.iStreamingSupport = iProtocolInfo->DlnaFlag(

            UpnpDlnaProtocolInfo::TM_S_FLAG );

        aDlnaCorelation.iInteractiveSupport = iProtocolInfo->DlnaFlag(

            UpnpDlnaProtocolInfo::TM_I_FLAG );

        if( aTransaction.QueryRequestHeader( UpnpDLNA::KHdrGetcontentFeatures() ) != KNullDesC8() )

            {

            aDlnaCorelation.iGetContentFeaturesExist = ETrue;

            }

        if( aDlnaCorelation.iGetContentFeaturesExist )

            {

            TDesC8& cntHeaderValue = aTransaction.QueryRequestHeader(

                                 UpnpDLNA::KHdrGetcontentFeatures() );

            if ( cntHeaderValue != UpnpDLNA::KHdrGetcontentFeaturesValue() )

                {

                aDlnaCorelation.iGetContentFeaturesIsOK = EFalse;

                }

            }

        }

    // DLNA v0.75, 7.3.31.1 checking Operations Parameter    

    if (

		/* We don't support timeSeek and playSpeed at the moment, so according to 

		 * point 7.4.71.1 (ver 1.5 rev 0.96)*/

            aDlnaCorelation.iGetContentFeaturesIsOK &&

		((	(aTransaction.QueryRequestHeader( UpnpDLNA::KHdrTimeSeekRange ) != KNullDesC8()

			|| aTransaction.QueryRequestHeader( UpnpDLNA::KHdrPlaySpeed )!= KNullDesC8()) 

			&&

			// 7.4.71.2 - range takes precedence

			aTransaction.QueryRequestHeader( UpnpHTTP::KHdrRange ) == KNullDesC8()	)

		||

		// or if request mode is Streaming and

		(	aTransaction.QueryRequestHeader( UpnpDLNA::KHdrTransferMode ). CompareC(

			UpnpDLNA::KTransferModeStreaming ) == 0 

			&& 

			(

			/* if we have no protocolInfo (because for example there is 

			no cdDataFinder )*/

			!iProtocolInfo ||

			// Streaming is not supported for this content type

			iProtocolInfo -> DlnaFlag(UpnpDlnaProtocolInfo::TM_S_FLAG ) == EFalse)	)) 

		)

        {

        // we respond with 406 error code - Not Acceptable.

        return -EHttpNotAcceptable;

        }

    // Append contentFeatures.dlna.org

    if ( aDlnaCorelation.iGetContentFeaturesExist )

        {

        if ( aDlnaCorelation.iFourthField.Length() > 0 )

            {

            aTransaction.FilterHeaders().AddHeaderL( UpnpDLNA::KHdrContentFeatures,

                                                     aDlnaCorelation.iFourthField );

            }

        }

    return KErrNone;    

    }        

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

// CUpnpHttpServer::CheckTransferMode

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

//        

TInt CUpnpDlnaFilter::CheckTransferModeL( CUpnpHttpDataServeTransaction& aTransaction,

                                         TUpnpDlnaCorelation& aDlnaCorelation )

    {

     TDesC8& transferMode = aTransaction.QueryRequestHeader( UpnpDLNA::KHdrTransferMode );

    // Check if requested transfer mode is handled

    if (

    // if client requested for transfer is not empty

    (transferMode.Length() > 0 && (

    // and if client requested for transfer is different than Background, Streaming or Interactive mode, reply with 400 error

            (transferMode.CompareC( UpnpDLNA::KTransferModeStreaming ) != 0

                    && transferMode.CompareC(

                        UpnpDLNA::KTransferModeInteractive ) != 0

                    && transferMode.CompareC(

                        UpnpDLNA::KTransferModeBackground ) != 0) ||

            // If Background or Interactive mode was requested, check if request doesn;t contain forbidden headers

                    ((transferMode.CompareC(

                        UpnpDLNA::KTransferModeBackground ) == 0

                            || transferMode.CompareC(

                                UpnpDLNA::KTransferModeInteractive ) == 0)

                            && (aTransaction.QueryRequestHeader(

                                UpnpDLNA::KHdrTimeSeekRange ) != KNullDesC8()

                                    || aTransaction.QueryRequestHeader(

                                        UpnpDLNA::KHdrPlaySpeed )

                                            != KNullDesC8()

                                    || aTransaction.QueryRequestHeader(

                                        UpnpDLNA::KHdrRealTimeInfo )

                                            != KNullDesC8())))) || (

        aTransaction.QueryRequestHeader( UpnpHTTP::KHdrRange ) == KNullDesC8()

                && transferMode.Length() == 0 && (aTransaction.QueryRequestHeader(

            UpnpDLNA::KHdrTimeSeekRange ) != KNullDesC8()

                || aTransaction.QueryRequestHeader( UpnpDLNA::KHdrPlaySpeed )

                        != KNullDesC8() || aTransaction.QueryRequestHeader(

            UpnpDLNA::KHdrRealTimeInfo ) != KNullDesC8()))

                || !aDlnaCorelation.iGetContentFeaturesIsOK

        )

            {

            return -EHttpBadRequest ;

            }

    return AppendCorelationHeadersL( aTransaction, aDlnaCorelation, transferMode );    

    }    

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

// CUpnpHttpServer::AppendCorelationHeaders

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

//        

TInt CUpnpDlnaFilter::AppendCorelationHeadersL( CUpnpHttpDataServeTransaction& aTransaction,

                             TUpnpDlnaCorelation& aDlnaCorelation, TDesC8& aTransferMode )

    {

    if ( aTransferMode.Length() > 0 && ((aTransferMode.CompareC(

        UpnpDLNA::KTransferModeStreaming ) == 0 && !aDlnaCorelation.iStreamingSupport)