/*

* Copyright (c) 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:      Push transport server

*

*/

// INCLUDE FILES

// System

#include <es_sock.h>

#include <in_sock.h>

// upnp stack api's

#include <upnphttpserversession.h>

#include <upnphttpserverruntime.h>

#include <upnphttpserverobserver.h>

#include <upnphttpservertransaction.h>

#include <upnphttpservertransactioncreator.h>

#include <upnphttpmessage.h>

// dlnasrv / mediaserver api

#include <upnpitem.h>

#include "upnpdlnafilter.h"

// dlnasrv / internal api's

#include "upnpconstantdefs.h" // for upnp-specific stuff

#include "upnpitemutility.h" // for GetResElements

_LIT( KComponentLogfile, "upnppushserver.txt");

#include "upnplog.h"

#include "upnppushserver.h"

// CONSTANTS

const TUint KMaxItemResourcesCount = 8;

const TUint KMaxBufferSize = 64;

const TUint KMaxUriLength = 256;

const TInt KSlash = 47;  // '/'

const TInt KDot = 46;    // '.'

_LIT8( KHttp,                       "http://" );

_LIT8( KSeparatorcolon,             ":" );

_LIT8( KSeparatorSlash,             "/" );

// GLOBALS

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

// CUpnpPushServer::ShareL

// 

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

EXPORT_C void CUpnpPushServer::ShareL(

    TUint aHash,

    CUpnpItem& aItem )

    {

    __LOG( "PushServer::ShareL()" );

    RUPnPElementsArray resources;

    CleanupClosePushL( resources );

    UPnPItemUtility::GetResElements( aItem, resources );

    if ( resources.Count() == 0 )

    	{

        __LOG( "PushServer::ShareL() - no resources" );

        User::Leave(KErrNotFound);

    	}

    CUpnpPushServer* singleton = static_cast<CUpnpPushServer*>( Dll::Tls() );

    if ( !singleton )

        {

        // singleton must be created first

        __LOG( "PushServer::ShareL: creating singleton" );

        singleton = new (ELeave) CUpnpPushServer();

        CleanupStack::PushL( singleton );

        singleton->ConstructL();

        User::LeaveIfError( Dll::SetTls( singleton ) );

        CleanupStack::Pop( singleton );

        }

    CUpnpElement* elem = 

    (CUpnpElement*)(UPnPItemUtility::FindElementByName( 

                    aItem, KElementAlbumArtUri() ));

    if( elem )

        {

        singleton->ShareResourceL( aHash, *elem );

        aHash += 1;

        }

    for( TUint i(0); i<resources.Count(); ++i )

        {

        singleton->ShareResourceL( aHash+i, *resources[i] );

        }

    CleanupStack::PopAndDestroy( &resources );

    }

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

// CUpnpPushServer::Unshare

// 

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

EXPORT_C void CUpnpPushServer::UnshareL(

    TUint aHash )

    {

    CUpnpPushServer* singleton = static_cast<CUpnpPushServer*>( Dll::Tls() );

    if ( singleton == 0 ) return; // singleton is empty, nothing to share.

    // assume item would have max. 8 resources, call unshare for those

    for( TUint i=0; i<KMaxItemResourcesCount; ++i )

        {

        singleton->UnshareResource( aHash+i );

        }

    if ( singleton->EntryCount() == 0 )

        {

        __LOG( "PushServer::Unshare: destroying singleton" );

        Dll::FreeTls();

        delete singleton;

        }

    }

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

// CUpnpPushServer::UnshareAll

// 

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

EXPORT_C void CUpnpPushServer::UnshareAllL()

    {

    CUpnpPushServer* singleton = static_cast<CUpnpPushServer*>( Dll::Tls() );

    if ( singleton != 0 )

        {

        __LOG( "PushServer::UnshareAll: destroying singleton" );

        Dll::FreeTls();

        delete singleton;

        }

    }

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

// CUpnpPushServer::IsRunning

// 

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

EXPORT_C TBool CUpnpPushServer::IsRunning()

    {

    CUpnpPushServer* singleton = static_cast<CUpnpPushServer*>( Dll::Tls() );

    return (singleton ? ETrue : EFalse);

    }

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

// CUpnpPushServer::ShareResourceL

// 

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

void CUpnpPushServer::ShareResourceL(

    TUint aHash,

    CUpnpElement& aResource )

    {

    // catch protocol info if one exists

    const CUpnpAttribute* piAttr = UPnPItemUtility::FindAttributeByName(

        aResource, KAttributeProtocolInfo() );

    // create URI

    TBuf8<KMaxBufferSize> uri;

    TParse parse;

    TInt result = parse.Set( aResource.FilePath(), NULL, NULL );

    User::LeaveIfError(result);

    HashToUri( aHash, parse.Ext(), uri );

    aResource.SetValueL( uri );

    // add to share

    __LOG2( "PushServer::ShareResourceL %d = %S",

        aHash, &aResource.FilePath() );

    __LOG8( uri );

    TUpnpPushEntry entry(aHash, aResource.FilePath(),

						( piAttr ? piAttr->Value() : KNullDesC8 ) );

    iEntries.InsertL( aHash, entry );

    }

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

// CUpnpPushServer::UnshareResource

// 

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

void CUpnpPushServer::UnshareResource( TUint aHash )

    {

    iEntries.Remove( aHash );

    }

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

// CUpnpPushServer::EntryCount

// 

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

TInt CUpnpPushServer::EntryCount()

    {

    return iEntries.Count();

    }

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

// CUpnpPushServer::HashToUri

// 

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

void CUpnpPushServer::HashToUri( TUint aHash, const TDesC& aFileExt, 

    TDes8& aUriBuf )

    {

    TInetAddr addr;

    iHttpServer->GetAddress( addr );

    TBuf<KMaxBufferSize> ip;

    addr.Output( ip );

    aUriBuf.Append( KHttp() );  			// http://

    aUriBuf.Append( ip );            		// http://n.n.n.n

    aUriBuf.Append( KSeparatorcolon() );    // http://n.n.n.n:

    aUriBuf.AppendNum( addr.Port() ); 		// http://n.n.n.n:pppp

    aUriBuf.Append( KSeparatorSlash() );    // http://n.n.n.n:pppp/

    aUriBuf.AppendNum( aHash );       		// http://n.n.n.n:pppp/hash

    aUriBuf.Append( aFileExt );       		// http://n.n.n.n:pppp/hash.ext

    }

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

// CUpnpPushServer::HashFromUri

// 

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

TUint CUpnpPushServer::HashFromUri( const TDesC8& aUri )

    {

    TBuf16<KMaxUriLength> uri16;

    uri16.Copy( aUri );

    return HashFromUri( uri16 );

    }

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

// CUpnpPushServer::HashFromUri

// 

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

TUint CUpnpPushServer::HashFromUri( const TDesC16& aUri )

    {

    TUint hash = 0;

	TChar slash( KSlash );

    TChar dot( KDot );

    // extract the hash part

    TInt begin = aUri.LocateReverse( slash );

    if ( begin<0 ) 

    	{

    	begin = -1;

    	}

    TInt end = aUri.LocateReverse( dot );

    if ( end<0 ) 

    	{

    	end = aUri.Length();

    	}

    TPtrC16 hashPart = aUri.Mid(

        begin+1, end-begin-1 );

    // convert to a number

    TLex16 hashLex( hashPart );

    if ( hashLex.Val( hash, EDecimal ) != KErrNone )

        {

        // hashcode was not found

        hash = 0;

        }

    __LOG2( "PushServer: HashFromUri: %S -> %d", &aUri, hash );

    return hash;

    }

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

// CUpnpPushServer::CUpnpPushServer

// 

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

CUpnpPushServer::CUpnpPushServer()

    :iEntries()

    {

    __LOG( "PushServer::CUpnpPushServer()" );

    }

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

// CUpnpPushServer::ConstructL

// 

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

void CUpnpPushServer::ConstructL()

    {

    __LOG( "PushServer::ConstructL()" );

    iHttpServer = CUpnpHttpServerSession::NewL( 0, *this );

    TRAPD( err, iHttpServer->StartL( KPushServerPort ) );

    if( err )

        {

        //fixed port already in use -> start with random port

        iHttpServer->StartL();

        }

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

    iFilter = CUpnpDlnaFilter::NewL( this, NULL );

    __LOG( "PushServer::ConstructL() - end" );

    }

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

// CUpnpPushServer::CUpnpPushServer

// 

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

CUpnpPushServer::~CUpnpPushServer()

    {

    __LOG( "PushServer::~CUpnpPushServer()" );

    iEntries.Close();

    if(NULL != iHttpServer)

    	{

    	iHttpServer->Stop();

    	}

    delete iHttpServer;

    delete iFilter;

    }

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

// CUpnpPushServer::NewTransactionL

// 

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

void CUpnpPushServer::NewTransactionL(

    const TDesC8& aMethod,

    const TDesC8& aUri,

    const TInetAddr& aSender,

    CUpnpHttpServerTransaction*& aTrans )

    {

    TBuf<KMaxBufferSize> ip;

    aSender.Output(ip);

	if ( aMethod == KHttpGet() || aMethod == KHttpHead() )

	    {

        __LOG2( "PushServer: HTTP %S from=%S, launching transaction", &aMethod, 

            &ip );

        iFilter->NewTransactionL( aMethod, aUri, aSender, aTrans );

	    }

    else

        {

        // this method not supported

        __LOG2( "PushServer: unsupported request: %S from=%S", &aMethod, &ip );

        User::Leave( KErrNotSupported );

        }

    }

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

// CUpnpPushServer::HttpEventLD

// 

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

void CUpnpPushServer::HttpEventLD( CUpnpHttpMessage* aMessage )

    {

    __LOG1( "QuickShare:HttpEventLD() type=%d", aMessage->Type() );

    delete aMessage;

    }

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

// CUpnpPushServer::CheckImportUriL

// 

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

TInt CUpnpPushServer::CheckImportUriL( const TDesC8& /*aImportUri*/ )

    {

    // should never be here

    __PANIC( __FILE__, __LINE__ );

    return 0;

    }

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

// CUpnpPushServer::GetTitleForUriL

// 

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

void CUpnpPushServer::GetTitleForUriL( TInt /*aObjectId*/, TPtr& /*aValue*/ )

    {

    // should never be here

    __PANIC( __FILE__, __LINE__ );

    }

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

// CUpnpPushServer::GetProtocolInfoL

// 

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

TInt CUpnpPushServer::GetProtocolInfoL( const TDesC8& aContentUri,

    CUpnpDlnaProtocolInfo*& aProtocolInfo )

    {

    aProtocolInfo = 0;

    TInt result = KErrNotFound;

    TUpnpPushEntry* entry = iEntries.Find( HashFromUri( aContentUri ) );

    if ( entry )

        {

        aProtocolInfo = CUpnpDlnaProtocolInfo::NewL( entry->ProtocolInfo() );

        result = KErrNone;

        }

    return result;

    }

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

// CUpnpPushServer::FindSharedFolderL

// 

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

TInt CUpnpPushServer::FindSharedFolderL( const TDesC& /*aUrlPath*/,

    const TDesC& aFileName, HBufC*& aFolderPath )

    {

    aFolderPath = 0;

    TInt result = KErrNotFound;

    TUpnpPushEntry* entry = iEntries.Find( HashFromUri( aFileName ) );

    if ( entry )

        {

        aFolderPath = entry->Path().AllocL();

        result = KErrNone;

        }

    return result;

    }

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

// CUpnpPushServer::GetProtocolInfoByImportUriL

// 

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

CUpnpDlnaProtocolInfo* CUpnpPushServer::GetProtocolInfoByImportUriL( 

    const TDesC8& /*aImportUri */)

    {

    // should never be here

    __PANIC( __FILE__, __LINE__ );

    return 0;

    }