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



// INCLUDE FILES
#include <e32base.h>
#include <uri8.h> 
#include "upnpsubscriberlibraryelement.h"
#include "upnpgenamessage.h"
#include "upnpstring.h"
#include "upnpcommonupnplits.h"
#include "upnpcommonstructs.h"

// CONSTANTS
_LIT8(KCallbackPrefix, "<http://");


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

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::CUpnpSubscriberLibraryElement
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CUpnpSubscriberLibraryElement::CUpnpSubscriberLibraryElement( 
                                    MUpnpTimeoutElementParent& aParent)
                : CUpnpTimeoutElement(aParent)
{

}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::ConstructL()
{
    BaseConstructL();
    iSid = HBufC8::NewL(0);
    iCallbackPath = HBufC8::NewL(0);
    iTimeout = HBufC8::NewL(0);
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CUpnpSubscriberLibraryElement* CUpnpSubscriberLibraryElement::NewL(
                                    MUpnpTimeoutElementParent& aParent )
{
    CUpnpSubscriberLibraryElement* self = new (ELeave) 
                                        CUpnpSubscriberLibraryElement(aParent);
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    
    return self;
}

// Destructor
CUpnpSubscriberLibraryElement::~CUpnpSubscriberLibraryElement()
{
    delete iSid;
    delete iCallbackPath;
    delete iTimeout;
    
    Cancel();
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::Sid
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TDesC8& CUpnpSubscriberLibraryElement::Sid()
{
    return *iSid;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::CallbackAddress
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInetAddr& CUpnpSubscriberLibraryElement::CallbackAddress()
{
    return iCallbackAddress;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::CallbackPath
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TDesC8& CUpnpSubscriberLibraryElement::CallbackPath()
{
    return *iCallbackPath;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::Seq
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUint32 CUpnpSubscriberLibraryElement::Seq() const
{
    return iSeq;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::Timeout
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TDesC8& CUpnpSubscriberLibraryElement::Timeout()
{
    return *iTimeout;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::AddSubscriberL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpSubscriberLibraryElement::AddSubscriberL( 
                                CUpnpGenaMessage* aMessage)
    {
    if (aMessage == NULL)
        {
        return EUndefined;
        }
    
    // Errors: Missing or invalid CALLBACK
    if (aMessage->Callback().Compare(KNoHeader) == 0)
        {   
        return EPreconditionFailed;
        }
    
    // Errors: Invalid NT
    if (aMessage->Nt().Compare(UpnpGENA::KDefaultNt) != 0)
        {
        return EPreconditionFailed;
        }
    
    TPtrC8 temp;
    TPtrC8 sid(KNullDesC8);
    TPtrC8 timeout;
    
    // only 1 address allowed with this method
    temp.Set( aMessage->Callback() );
    if ( temp.Find( KCallbackPrefix ) != KErrNotFound 
         && temp.Length() < KUrlMaxLength )
        {
        temp.Set( temp.Mid( temp.Find( KLessThan8 ) + 1 ) );
        if ( temp.Find( KGreaterThan8 )  != KErrNotFound )
            {
            temp.Set( temp.Left( temp.Find( KGreaterThan8 ) ) );
            }
        else
            {
            return EPreconditionFailed;
            }
        }
    else
        {
        return EPreconditionFailed;
        }


    TPtrC8 callbackIp;
    TPtrC8 callbackPort;
    TPtrC8 callbackPath;
    
    TUriParser8 uriParser;
    if ( !uriParser.Parse(temp) )
        {
        callbackIp.Set( uriParser.Extract( EUriHost ) );
        if ( callbackIp == KNullDesC8() )
		    	{
		    	return EPreconditionFailed;	
		    	}	
        callbackPort.Set( uriParser.Extract( EUriPort ) );
        if ( callbackPort == KNullDesC8() )
            {
            callbackPort.Set(KDefaultHostPort);            
            }        
        callbackPath.Set( uriParser.Extract( EUriPath ) );       
        }
    else
        {
        // invalid callback
        return EPreconditionFailed;
        }
    
    temp.Set(aMessage->Timeout());
    
    if (temp.Find(KTimeoutPrefix) != KErrNotFound)
        {
        timeout.Set( temp.Mid( temp.Find( KTimeoutPrefix) + 
                        KTimeoutPrefix().Length() ) );
        }
    else
        {
        // timeout according to DLNA recommendation: 300 seconds
        timeout.Set(KDefaultTimeout);
        }
    
    AddInfoL(sid,
             callbackIp,
             callbackPort,
             callbackPath,
             timeout);
             
    return EHttpOk;
    }

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::RenewSubscriberL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUpnpErrorCode CUpnpSubscriberLibraryElement::RenewSubscriberL(
                                CUpnpGenaMessage* aMessage )
{
    TPtrC8 temp;
    // Errors: Incompatible headers (SID already found)
    
    if (aMessage == NULL)
    {
        return EUndefined;
    }
    
    if (aMessage->Nt().Compare(KNoHeader) != 0)
    {
        return EBadRequest;
    }
    else if (aMessage->Callback().Compare(KNoHeader) != 0)
    {
        return EBadRequest;
    }
    else
    {
    }
    
    TPtrC8 timeout;
    temp.Set(aMessage->Timeout());
    
    if (temp.Find(KTimeoutPrefix) != KErrNotFound)
    {
        timeout.Set( temp.Mid( temp.Find(KTimeoutPrefix) + 
                        KTimeoutPrefix().Length() ) );
    }
    else
    {
        // timeout according to DLNA recommendation: 300 seconds
        timeout.Set(KDefaultTimeout);
    }
    
    SetTimeoutL(timeout);
    
    return EHttpOk;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::AddInfoL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::AddInfoL( const TDesC8& aSid,  
                                                       const TDesC8& aCallbackIp, 
                                                       const TDesC8& aCallbackPort, 
                                                       const TDesC8& aCallbackPath, 
                                                       const TDesC8& aTimeout)
{
    // Adding subscriber information

    SetSidL(aSid);
    SetCallbackAddress(aCallbackIp, aCallbackPort);
    SetCallbackPathL(aCallbackPath);
    SetTimeoutL(aTimeout);
    SetSeq(0);
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetSidL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetSidL(const TDesC8& aSid)
{
    delete iSid;
    iSid = NULL;
    iSid = aSid.AllocL();
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetCallbackAddress
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetCallbackAddress(const TDesC8& aIp, 
                                                            const TDesC8& aPort)
{
    CUpnpHttpMessage::AddrInput(iCallbackAddress, aIp);
    
    TLex8 lex(aPort);
    TInt port;
    lex.Val(port);
    
    iCallbackAddress.SetPort(port);
    iCallbackAddress.SetFamily(KAfInet);
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetCallbackPathL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetCallbackPathL( const TDesC8& aCallbackPath)
{
    delete iCallbackPath;
    iCallbackPath = NULL;
    iCallbackPath = aCallbackPath.AllocL();
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetSeq
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetSeq(TUint32 aSeq)
{
    iSeq = aSeq;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::IncreaseSeq
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::IncreaseSeq()
{
    if (iSeq < KMaxSeq)
    {
        iSeq++;
    }
    else
    {
        iSeq = KMinSeq;
    }
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetSessId
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetSessId(TInt aSessId)
{
    iSessId = aSessId;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SessId
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CUpnpSubscriberLibraryElement::SessId()
{
    return iSessId;
}

// -----------------------------------------------------------------------------
// CUpnpSubscriberLibraryElement::SetTimeoutL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CUpnpSubscriberLibraryElement::SetTimeoutL(const TDesC8& /*aTimeout*/)
{
    


        // 7.2.22.1 UPnP devices must send events to all properly subscribed 
        // UPnP control points.  
        // The device must enforce a subscription TIMEOUT value of 5 minutes.
    SetTimeout( KDefaultTimeoutValue );
    SetRenew(CUpnpTimeoutElement::EOnce);
    
    // set text-formed timeout
    delete iTimeout;
    iTimeout = NULL;
    iTimeout = KDefaultTimeout().AllocL();

}

//  End of File