/** @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:  CUpnpSsdpServer

*

*/

// INCLUDE FILES

#include <in_sock.h>

#include <upnpsettings.h>

#include "upnpssdpserver.h"

#include "upnpcons.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include "upnplist.h"

using namespace UpnpSSDP;

using namespace UpnpString;

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

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

// CUpnpSsdpServer::CUpnpSsdpServer

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

// might leave.

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

//

CUpnpSsdpServer::CUpnpSsdpServer( MUpnpSsdpServerObserver* aSsdpServerObserver,

                          RSocketServ* aSocketServ,

                          TInt aListeningPort,

                          CUpnpSsdpServer* aMasterServer )

   : CUpnpUdpServer( aSocketServ, this, aListeningPort )

    {

    iMasterServer=aMasterServer;

    iSsdpServerObserver = aSsdpServerObserver;

    }

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

// CUpnpSsdpServer::CUpnpSsdpServer

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

// might leave.

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

//

CUpnpSsdpServer::CUpnpSsdpServer( MUpnpSsdpServerObserver* aSsdpServerObserver,

                          RSocketServ* aSocketServ,

                          TInt aListeningPort )

        : CUpnpUdpServer( aSocketServ, this, aListeningPort )

    {

    iMasterServer = NULL;

    iSsdpServerObserver = aSsdpServerObserver;

    }

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

// CUpnpSsdpServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpSsdpServer::ConstructL()

    {

    UdpConstructL();    

    iServerDescription =  CUpnpSettings::GetServerHeaderL();    

    }

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

// CUpnpSsdpServer::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpSsdpServer* CUpnpSsdpServer::NewL( MUpnpSsdpServerObserver*

                                                         aSsdpServerObserver,

                                         RSocketServ* aSocketServ,

                                         TInt aListeningPort )

    {

    CUpnpSsdpServer* self = new (ELeave) CUpnpSsdpServer( aSsdpServerObserver,

                                                  aSocketServ,

                                                  aListeningPort );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CUpnpSsdpServer::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpSsdpServer* CUpnpSsdpServer::NewL( MUpnpSsdpServerObserver* 

                                                        aSsdpServerObserver,

                                         RSocketServ* aSocketServ,

                                         TInt aListeningPort,

                                         CUpnpSsdpServer* aMasterServer )

    {

    CUpnpSsdpServer* self = new (ELeave) CUpnpSsdpServer( aSsdpServerObserver,

                                                  aSocketServ,

                                                  aListeningPort,

                                                  aMasterServer );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor

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

// 

EXPORT_C CUpnpSsdpServer::~CUpnpSsdpServer()

    {

    delete iServerDescription;

    }

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

// CUpnpSsdpServer::MessageFromMulticastL

// Message from multicast.

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

//

void CUpnpSsdpServer::MessageFromMulticastL( CUpnpSsdpMessage* aMessage )

    {

    UdpMessageReceivedL( aMessage );

    }

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

// CUpnpSsdpServer::UdpMessageReceivedL

// UDP message received.

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

//

void CUpnpSsdpServer::UdpMessageReceivedL( CUdpMessage* aMessage )

    {

    if ( !aMessage )

        {

        return;

        }

    CUpnpSsdpMessage* message = ( CUpnpSsdpMessage* ) aMessage;

       // Unless it's response, check if HOST header has explicitly specified port number - 1900

       // If not, then add this port

       if ( !message->IsSsdpResponse() )

           {

           TPtrC8 host = message->GetHeaderValue( KHdrHost );

           // : Not found so port is not specified

           if( host.Find( UpnpString::KColon() ) == KErrNotFound )

            {

            TBuf8<KMaxIntegerLength> defaultPort;

               defaultPort.Num( KMulticastPort );

               HBufC8* newHost = HBufC8::NewLC( host.Length() +

                                       UpnpString::KColon().Length() +

                                       defaultPort.Length() );

               newHost->Des().Zero();

               newHost->Des().Append( host );

               newHost->Des().Append( UpnpString::KColon() );

               newHost->Des().Append( defaultPort );

               message->AddHostL( *newHost );

               CleanupStack::PopAndDestroy(newHost);

            }

           }

    if ( iMasterServer )

        {

        iMasterServer->MessageFromMulticastL( message );

        }

    else

        {

        if ( message->IsSsdpMSearch() )

            {

            LOGS( "SSDP *** Search received");

            ResponseL( message );

            // add additional notification to upper-layer 

            // used for detection IP address change

            iSsdpServerObserver->SsdpEventL( message );

            }

        else if (message->IsSsdpNotify())

            {

            LOGS( "SSDP *** Notify received");

            iSsdpServerObserver->SsdpEventL( message );

            }

        else if (message->IsSsdpResponse())

            {

            LOGS( "SSDP *** Response received");

            iSsdpServerObserver->SsdpEventL( message );

            }

        else

            {

            LOGS( "SSDP *** UNKNOWN MESSAGE RECEIVED");

            }

        }

    }

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

// CUpnpSsdpServer::StartL

// Start.

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

//

EXPORT_C void CUpnpSsdpServer::StartL()

    {

    LOGS( "SSDP *** StartL");

    OpenL();    

    }

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

// CUpnpSsdpServer::StopL

// Stop.

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

//

EXPORT_C void CUpnpSsdpServer::Stop()

    {

    LOGS( "SSDP *** Stop");

    Close();

    }

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

// CUpnpSsdpServer::AdvertiseAliveL

// 

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

//

EXPORT_C void CUpnpSsdpServer::AdvertiseAliveL( CUpnpDeviceLibraryElement& aDev )

    {

    LOGS( "SSDP *** AdvertiseAliveL");

    // advertise this device

    SingleDeviceAdvertiseAliveL( aDev );

    SingleDeviceAdvertiseAliveL( aDev );

    }

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

// CUpnpSsdpServer::AdvertiseByebyeL

// 

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

//

EXPORT_C void CUpnpSsdpServer::AdvertiseByebyeL( CUpnpDeviceLibraryElement& aDev )

    {

    SingleDeviceAdvertiseByebyeL( aDev );

    }

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

// CUpnpSsdpServer::SearchL

// 

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

//

EXPORT_C void CUpnpSsdpServer::SearchL( TDesC8& aTarget )

    {

    SearchL(aTarget, (TDesC8&)UpnpSSDP::KDefaultResponseDelay());

    }

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

// CUpnpSsdpServer::SearchL

// 

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

//

EXPORT_C void CUpnpSsdpServer::SearchL( TDesC8& aTarget, TDesC8& aMaximumWaitTime )

    {

    CUpnpSsdpMessage* msg = RUpnpSsdpMessageFactory::SearchL( aTarget );

    CleanupStack::PushL( msg );

    msg->AddMxL(aMaximumWaitTime);

    HBufC8* str = HBufC8::NewLC( KMaxSsdpMessageLength );

    HBufC8* msgStr = ( ( CUpnpSsdpMessage* ) msg )->ToStringL();

    CleanupStack::PushL( msgStr );

    str->Des().Append( *msgStr );

    CleanupStack::PopAndDestroy( msgStr );

    TInetAddr addr( KDefaultMulticastAddress, KDefaultMulticastPort );

    SendL( *str, addr );

    CleanupStack::PopAndDestroy( str );

    CleanupStack::PopAndDestroy( msg );

    }

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

// CUpnpSsdpServer::SendAdvertiseAliveL

//

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

//

void CUpnpSsdpServer::SendAdvertiseAliveL( TDesC8& aNt, TDesC8& aUsn, TDesC8& aLoc )

    {

    TInetAddr addr( KDefaultMulticastAddress, KDefaultMulticastPort );

    CUpnpSsdpMessage* msg = RUpnpSsdpMessageFactory::AdvertiseAliveL( 

                                            aLoc, aNt, aUsn, *iServerDescription);

    CleanupStack::PushL( msg );

    HBufC8* str = msg->ToStringL();

    CleanupStack::PushL( str );

    SendL( *str, addr );

    CleanupStack::PopAndDestroy( str );

    str=NULL;

    CleanupStack::PopAndDestroy( msg );

    msg=NULL;    

    }

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

// CUpnpSsdpServer::SendAdvertiseByebyeL

//

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

//

void CUpnpSsdpServer::SendAdvertiseByebyeL( TDesC8& aNt, TDesC8& aUsn )

    {

    TInetAddr addr( KDefaultMulticastAddress, KDefaultMulticastPort );

    CUpnpSsdpMessage* msg = RUpnpSsdpMessageFactory::AdvertiseByebyeL( aNt, aUsn );

    CleanupStack::PushL( msg );

    HBufC8* str = msg->ToStringL();

    CleanupStack::PushL( str );    

    SendL( *str, addr );

    CleanupStack::PopAndDestroy( str );

    str=NULL;

    CleanupStack::PopAndDestroy( msg );

    msg=NULL;

    }

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

// CUpnpSsdpServer::SendResponseL

//

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

//

void CUpnpSsdpServer::SendResponseL( TInetAddr& aDest, 

                                 TDesC8& aSt, 

                                 TDesC8& aUsn, 

                                 TDesC8& aLoc )

    {

    CUpnpSsdpMessage* msg = RUpnpSsdpMessageFactory::ResponseL( 

                                        aSt, aUsn, aLoc, *iServerDescription );

    CleanupStack::PushL( msg );

    HBufC8* str = msg->ToStringL();

    CleanupStack::PushL( str );

    SendL( *str, aDest );

    CleanupStack::PopAndDestroy( str );

    str=NULL;

    CleanupStack::PopAndDestroy( msg );

    msg=NULL;    

    }

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

// CUpnpSsdpServer::SingleDeviceAdvertiseAliveL

//

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

//

void CUpnpSsdpServer::SingleDeviceAdvertiseAliveL( CUpnpDeviceLibraryElement& aDev )

    {

    HBufC8* nt=NULL;

    HBufC8* usn=NULL;

    HBufC8* loc=NULL;

    loc=HBufC8::NewLC( aDev.DescriptionUrl().Length() );

    loc->Des().Zero();

    loc->Des().Append( aDev.DescriptionUrl() );

    CDesC8Array* services = &aDev.ServiceList();

    if ( aDev.IsRootDevice() )

        {

        nt = HBufC8::NewLC( KUPnPRootDevice().Length() );

        nt->Des().Zero();

        nt->Des().Append( KUPnPRootDevice() );

        usn = HBufC8::NewLC( KUPnPUuid().Length()

            + aDev.UUID().Length()

            + KDblColon().Length()

            + KUPnPRootDevice().Length() );

        usn->Des().Zero();

        usn->Des().Append( KUPnPUuid() );

        usn->Des().Append( aDev.UUID() );

        usn->Des().Append( KDblColon() );

        usn->Des().Append( KUPnPRootDevice() );

        SendAdvertiseAliveL( *nt, *usn, *loc );

        CleanupStack::PopAndDestroy( usn );

        usn = NULL;

        CleanupStack::PopAndDestroy( nt );

        nt = NULL;

        }

    nt=HBufC8::NewLC( KUPnPUuid().Length() + aDev.UUID().Length() );

    nt->Des().Zero();

    nt->Des().Append( KUPnPUuid() );

    nt->Des().Append( aDev.UUID() );

    usn=HBufC8::NewLC( KUPnPUuid().Length() + aDev.UUID().Length() );

    usn->Des().Zero();

    usn->Des().Append( KUPnPUuid() );

    usn->Des().Append( aDev.UUID() );

    SendAdvertiseAliveL( *nt, *usn, *loc );

    CleanupStack::PopAndDestroy( usn );

    usn = NULL;

    CleanupStack::PopAndDestroy( nt );

    nt = NULL;

    nt = HBufC8::NewLC( aDev.DeviceType().Length() );

    nt->Des().Zero();

    nt->Des().Append( aDev.DeviceType() );

    usn = HBufC8::NewLC( KUPnPUuid().Length()

        + aDev.UUID().Length()

        + KDblColon().Length()

        + aDev.DeviceType().Length() );

    usn->Des().Zero();

    usn->Des().Append( KUPnPUuid() );

    usn->Des().Append( aDev.UUID() );

    usn->Des().Append( KDblColon() );

    usn->Des().Append( aDev.DeviceType() );

    SendAdvertiseAliveL( *nt, *usn, *loc );

    CleanupStack::PopAndDestroy( usn );

    usn = NULL;

    CleanupStack::PopAndDestroy( nt );

    nt = NULL;

    if(!services)

        {

        return;

        }

    TInt NumOfServices = services->Count();

    TInt i = 0;

    for( i = 0; i < NumOfServices; i++ )

        {

        nt = HBufC8::NewLC( KUPnPServiceSchema().Length()

            + (*services)[i].Length() );

        nt->Des().Zero();

        nt->Des().Append( KUPnPServiceSchema() );

        nt->Des().Append( (*services)[i] );

        usn=HBufC8::NewLC( KUPnPUuid().Length()

            + aDev.UUID().Length()

            + KDblColon().Length()

            + KUPnPServiceSchema().Length()

            + (*services)[i].Length() );

        usn->Des().Zero();

        usn->Des().Append( KUPnPUuid() );

        usn->Des().Append( aDev.UUID() );

        usn->Des().Append( KDblColon() );

        usn->Des().Append( KUPnPServiceSchema() );

        usn->Des().Append( (*services)[i] );

        SendAdvertiseAliveL( *nt, *usn, *loc );

        CleanupStack::PopAndDestroy( usn );

        usn = NULL;

        CleanupStack::PopAndDestroy( nt );

        nt = NULL;

        }

    CleanupStack::PopAndDestroy( loc );

    loc = NULL;

    }

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

// CUpnpSsdpServer::SingleDeviceAdvertiseByebyeL

//

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

//

void CUpnpSsdpServer::SingleDeviceAdvertiseByebyeL(CUpnpDeviceLibraryElement& aDev)

    {

    HBufC8* nt=NULL;

    HBufC8* usn=NULL;

    CDesC8Array* services = &aDev.ServiceList();

    if (aDev.IsRootDevice())

        {

        nt=HBufC8::NewLC(KUPnPRootDevice().Length());

        nt->Des().Copy(KUPnPRootDevice());

        usn=HBufC8::NewLC(KUPnPUuid().Length()

            +aDev.UUID().Length()

            +UpnpString::KDblColon().Length()

            +KUPnPRootDevice().Length());

        usn->Des().Zero();

        usn->Des().Append(KUPnPUuid());

        usn->Des().Append(aDev.UUID());

        usn->Des().Append(UpnpString::KDblColon());

        usn->Des().Append(KUPnPRootDevice());

        SendAdvertiseByebyeL(*nt, *usn);

        CleanupStack::PopAndDestroy(usn);