/*

* Copyright (c) 2005-2007 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:   helper SIP related methods

*

*/

#include <e32math.h>

#include <uri8.h>

#include <uriutils.h>

#include <sip.h>

#include <sipservertransaction.h>

#include <sipclienttransaction.h>

#include <sipacceptcontactheader.h>

#include <sipcontactheader.h>

#include <sipextensionheader.h>

#include <siprequestelements.h>

#include <sipresponseelements.h>

#include <sipmessageelements.h>

#include <sipfromheader.h>

#include <sipaddress.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <sdpdocument.h>

#include <sdpcodecstringconstants.h>

#include <sdpcodecstringpool.h>

#include <escapeutils.h>

#include "muslogger.h"

#include "musavacapabilitycontext.h"

_LIT8( KMusAssertedIndentity,"P-Asserted-Identity" );

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

//

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

//

RStringF MusAvaCapabilityContext::SDPStringL( TInt aStringIndex )

    {

    return SdpCodecStringPool::StringPoolL().

        StringF( aStringIndex, SdpCodecStringPool::StringTableL() );

    }

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

// 

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

//

RStringF MusAvaCapabilityContext::SDPStringL( const TDesC8& aString )

    {

    return SdpCodecStringPool::StringPoolL().OpenFStringL( aString );

    }

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

// 

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

//

RStringF MusAvaCapabilityContext::SIPStringL( const TDesC8& aString )

    {

    return SIPStrings::Pool().OpenFStringL( aString );

    }

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

// 

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

//

void MusAvaCapabilityContext::LocalHostL( 

                                    const CSIPServerTransaction& aRequest,

                                    TPtrC8& aLocalHost,

                                    RStringF& aHostType )

    {

    RStringPool strPool = SdpCodecStringPool::StringPoolL();

    const CUri8& uri = aRequest.RequestElements()->RemoteUri();

    aLocalHost.Set( uri.Uri().Extract( EUriHost ) );

    if ( UriUtils::HostType( aLocalHost ) == UriUtils::EIPv6Host )

        {

        aHostType = strPool.StringF( SdpCodecStringConstants::EAddressType, 

                                     SdpCodecStringPool::StringTableL() );

        }

    else 

        {

        aHostType = strPool.StringF( 

                                SdpCodecStringConstants::EAddressTypeIP4, 

                                SdpCodecStringPool::StringTableL() );

        }

    }

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

// 

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

//

CUri8* MusAvaCapabilityContext::ToUriL( const TDesC8& aUri )

    {

    TUriParser8 uri;

    User::LeaveIfError( uri.Parse( aUri ) );

    return CUri8::NewL( uri );

    }

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

// 

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

//

HBufC8* MusAvaCapabilityContext::ToTextL( CSdpDocument& aSdpContent )

    {

    HBufC8* content = NULL;

    CBufFlat* encBuf = CBufFlat::NewL( KMUSAVAMaxLengthOfSDPMessage );

    CleanupStack::PushL( encBuf );

    RBufWriteStream writeStream( *encBuf, 0 );

	writeStream.PushL();

    aSdpContent.EncodeL( writeStream );

    CleanupStack::PopAndDestroy();//writeStream

    content = encBuf->Ptr( 0 ).AllocL();

    CleanupStack::PopAndDestroy( encBuf );

    return content;

    }

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

// 

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

// 

const CSIPMessageElements& MusAvaCapabilityContext::MessageElementsL( 

                                            const CSIPTransactionBase& aTrx )

    {

    const CSIPMessageElements* message = NULL;

    if ( aTrx.IsSIPClientTransaction() )

        {

        const CSIPResponseElements* response = 

            static_cast<const CSIPClientTransaction&>

                ( aTrx ).ResponseElements();

        User::LeaveIfError( !response ? KErrGeneral : KErrNone );

        message = &response->MessageElements();

        }

    else

        {

        const CSIPRequestElements* request = 

            static_cast<const CSIPServerTransaction&>( aTrx ).RequestElements();

        User::LeaveIfError( !request ? KErrGeneral : KErrNone );

        message = &request->MessageElements();

        }

    return *message;

    }

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

// 

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

// 

CSIPAcceptContactHeader* MusAvaCapabilityContext::AcceptContactHeaderLC( 

                                                            RStringF aValue )

    {

    CSIPAcceptContactHeader* header = CSIPAcceptContactHeader::NewLC();

    header->SetParamL( aValue );

    header->SetParamL( SIPStrings::StringF( SipStrConsts::EExplicit ) );

    return header;

    }

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

// 

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

// 

const CSIPAcceptContactHeader* MusAvaCapabilityContext::AcceptContactHeaderL( 

                                            const CSIPTransactionBase& aTrx )

    {

    return static_cast<const CSIPAcceptContactHeader*>

        ( Header( SIPStrings::StringF( SipStrConsts::EAcceptContactHeader ),

          MessageElementsL( aTrx ) ) );

    }

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

// 

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

// 

CSIPContactHeader* MusAvaCapabilityContext::ContactHeaderLC( 

                                                    const CUri8& aAddress, 

                                                    RStringF aValue )

    {

    CUri8* uri = CUri8::NewLC( aAddress.Uri() );

    /*

    if ( !uri->Uri().IsPresent( EUriHost ) )

        {

        uri->SetComponentL( 

        SIPStrings::StringF( SipStrConsts::ELocalHost ).DesC(), EUriHost );

        }

    */

    CSIPAddress* address = CSIPAddress::NewL( uri );

    CleanupStack::Pop( uri );

    CleanupStack::PushL( address );

    CSIPContactHeader* header = CSIPContactHeader::NewL( address );

    CleanupStack::Pop( address );

    CleanupStack::PushL( header );

    if ( aValue != SIPStrings::StringF( SipStrConsts::EEmpty ) )

        {

        TInt separator = aValue.DesC().Find( KMUSAVASemicolon );

        if ( separator < KErrNone )

            {

            header->SetParamL( aValue );

            }

        else

            {

            TPtrC8 head = aValue.DesC().Left( separator );

            TPtrC8 tail = aValue.DesC().Mid( 

                        separator + KMUSAVASemicolon().Length() );

            RStringF theHead = SIPStringL( head );

            CleanupClosePushL( theHead );

            RStringF theTail = SIPStringL( tail );

            CleanupClosePushL( theTail );

            header->SetParamL( theHead );

            header->SetParamL( theTail );

            CleanupStack::PopAndDestroy();//theTail

            CleanupStack::PopAndDestroy();//theHead

            }

        }

    return header;

    }

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

// 

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

// 

const CSIPContactHeader* MusAvaCapabilityContext::ContactHeaderL( 

                                            const CSIPTransactionBase& aTrx )

    {

    return static_cast<const CSIPContactHeader*>

        ( Header( SIPStrings::StringF( SipStrConsts::EContactHeader ), 

                  MessageElementsL( aTrx ) ) );

    }

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

// 

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

// 

CSIPExtensionHeader* MusAvaCapabilityContext::UserAgentHeaderLC( 

                                                    const TDesC8& aValue )

    {

    return CSIPExtensionHeader::NewLC( KMUSAVASIPHeaderUserAgent, aValue );

    }

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

// 

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

// 

const CSIPExtensionHeader* MusAvaCapabilityContext::UserAgentHeaderL( 

                                            const CSIPTransactionBase& aTrx )

    {

    RStringF userAgentHeaderName = SIPStringL( KMUSAVASIPHeaderUserAgent );

    CleanupClosePushL( userAgentHeaderName );

    const CSIPExtensionHeader* header = 

        static_cast<const CSIPExtensionHeader*>

        ( Header( userAgentHeaderName, MessageElementsL( aTrx ) ) );

    CleanupStack::PopAndDestroy();//userAgentHeaderName

    return header;

    }

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

// 

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

// 

CSIPExtensionHeader* MusAvaCapabilityContext::PAssertedIdentityHeaderLC( 

                                                    const TDesC8& aValue )

    {

    return CSIPExtensionHeader::NewLC( KMUSAVASIPHeaderPAssertedIdentity, 

                                    aValue );

    }

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

// 

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

// 

const CUri8& MusAvaCapabilityContext::OriginatorL( 

                                        const CSIPServerTransaction& aTrx )

    {

    const CSIPRequestElements* request = aTrx.RequestElements();

    User::LeaveIfError( !request ? KErrGeneral : KErrNone );

    const CSIPFromHeader* from = request->FromHeader();

    User::LeaveIfError( from ? KErrNone : KErrGeneral );

    return from->SIPAddress().Uri8();

    }

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

// 

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

// 

const CSIPHeaderBase* MusAvaCapabilityContext::Header( 

                                    RStringF aHeaderName,

                                    const CSIPMessageElements& aMessage )

    {

    TBool found = EFalse;

    CSIPHeaderBase* header = NULL;

    const RPointerArray<CSIPHeaderBase>& headers = aMessage.UserHeaders();

    for ( TInt i=0; i < headers.Count() && !found; i++ )

        {

        header = headers[i];

        if ( header->Name() == aHeaderName )

            {

            found = ETrue;

            }

        else

            {

            header = NULL;

            }

        }

    return header;

    }

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

// 

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

// 

const CSIPHeaderBase* MusAvaCapabilityContext::Header( 

                                    RStringF aHeaderName,

                                    const CSIPMessageElements& aMessage,

                                    TUint aIndex )

    {

    TInt found = -1;

    CSIPHeaderBase* header = NULL;

    const RPointerArray<CSIPHeaderBase>& headers = aMessage.UserHeaders();

    for ( TInt i=0; i < headers.Count() && found != aIndex; i++ )

        {

        header = headers[i];

        if ( header->Name() == aHeaderName )

            {

            found++;

            }

        else

            {

            header = NULL;

            }

        }

    return header;

    }

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

// 

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

// 

TUint MusAvaCapabilityContext::HeaderCount( 

                                    RStringF aHeaderName,

                                    const CSIPMessageElements& aMessage )

    {

    TUint found = 0;

    CSIPHeaderBase* header = NULL;

    const RPointerArray<CSIPHeaderBase>& headers = aMessage.UserHeaders();

    for ( TInt i=0; i < headers.Count(); i++ )

        {

        header = headers[i];

        if ( header->Name() == aHeaderName )

            {

            found++;

            }

        }

    return found;

    }

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

// 

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

// 

CDesCArrayFlat* MusAvaCapabilityContext::PAssertedIdentityHeaderL(

                                    const CSIPMessageElements& aMessage )

    { 

    MUS_LOG( "mus: [MUSAVA] -> MusAvaCapabilityContext::PAssertedIdentityHeaderL" )

    RStringF p = SIPStrings::Pool().OpenFStringL( KMusAssertedIndentity() );

    CleanupClosePushL( p );	

    TInt headerCount = HeaderCount( p,aMessage); 

    CDesCArrayFlat* headers = new( ELeave ) CDesCArrayFlat( 2 );

    CleanupStack::PushL( headers );

    for ( TInt i=0; i < headerCount; i++ )

        {        

        const CSIPHeaderBase* pAssertedId = 

        		MusAvaCapabilityContext::Header( p, aMessage, i );      

        if ( pAssertedId )

            {

            HBufC8* value = pAssertedId->ToTextValueLC();

            CSIPAddress* address = CSIPAddress::DecodeL( *value );

            CleanupStack::PushL( address );                 

            const TDesC8& uriInPAssertedId = address->Uri8().Uri().UriDes();

        	if ( uriInPAssertedId.Length() > 0 )

    	        {

    	        HBufC* uriBuf = 

    	            EscapeUtils::ConvertToUnicodeFromUtf8L( uriInPAssertedId );

    	        CleanupStack::PushL( uriBuf );  

    	        headers->AppendL( *uriBuf );

    	        CleanupStack::PopAndDestroy( uriBuf );

        		}

            CleanupStack::PopAndDestroy( address );

            CleanupStack::PopAndDestroy( value );

            }

        }	

    CleanupStack::Pop( headers );

    CleanupStack::PopAndDestroy( &p );

    MUS_LOG( "mus: [MUSAVA] <- MusAvaCapabilityContext::PAssertedIdentityHeaderL" )

    return headers;

    }