/*

* Copyright (c) 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:  Class implementation for Sdp content parser.

*

*/

#include <e32cmn.h>

#include <in_sock.h>

#include <sdpcodecstringpool.h>

#include <sdpcodecstringconstants.h>

#include <sdpdocument.h>

#include <sdpconnectionfield.h>

#include <sdpattributefield.h>

#include <sdpmediafield.h>

#include "natfwcandidate.h"

#include "natfwcredentials.h"

#include "nspcontentparser.h"

#include "nspdefs.h"

const TInt KAttributesNumber = 7;

static const TText8* const AttributeArray[ KAttributesNumber ] =

    {

    _S8("candidate"),

    _S8("remote-candidates"),

    _S8("ice-lite"),

    _S8("ice-passive"),

    _S8("ice-ufrag"),

    _S8("ice-pwd"),

    _S8("ice-mismatch")

    };

const TInt KIceAttrCandidateIndex = 0;

const TInt KIceAttrRemoteCandidatesIndex = 1;

const TInt KIceAttrLiteIndex = 2;

const TInt KIceAttrPassiveIndex = 3;

const TInt KIceAttrUfragIndex = 4;

const TInt KIceAttrPwdIndex = 5;

const TInt KIceAttrMismatchIndex = 6;

_LIT8( KAttrRtcp, "rtcp" );

_LIT8( KAttrEmpty, " " );

_LIT8( KFieldSeparator, " " );

const TInt KTypeAttrNumber = 9;

static const TText8* const CandidateTypeArray[ KTypeAttrNumber ] = 

    {

    _S8( "typ" ),

    _S8( "host" ),

    _S8( "local" ),

    _S8( "srflx" ),

    _S8( "prflx" ),

    _S8( "relay" ),

    _S8( "tcp-so" ),

    _S8( "tcp-act" ),

    _S8( "tcp-pass" )

    };

const TInt KTypeAttrIndexType = 0;

const TInt KTypeAttrIndexHost = 1;

const TInt KTypeAttrIndexLocal = 2;

const TInt KTypeAttrIndexServerReflex = 3;

const TInt KTypeAttrIndexPeerReflex = 4;

const TInt KTypeAttrIndexRelay = 5;

const TUint KRejecPort = 0;

const TInt KMaxCandidateLength = 200;       // Max for candidate creation.

const TInt KMaxLengthNumberConversion = 40; // Priority field max length.

const TInt KMaxLengthTInetAddr = 40;        // Must support IPv4/IPv6

const TInt KMaxLengthOfFQDN = 255;          // For FQDNs

const TInt KMaxLengthRtcpField = 60;        // Max for rctp attr. value

#define FINDFIELD_L( aField, aMediafield, aFieldarray ) \

    User::LeaveIfNull( aField = CNSPContentParser::FindMediaField( aMediafield, aFieldarray ) )

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

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

// CNSPContentParser::CNSPContentParser

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

//

CNSPContentParser::CNSPContentParser()

    {

    }

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

// CNSPContentParser::ConstructL

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

//

void CNSPContentParser::ConstructL()

    {

    RStringPool pool = SdpCodecStringPool::StringPoolL();

    // ICE attributes

    iCandidate = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrCandidateIndex ] ) );

    iRemoteCandidates = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrRemoteCandidatesIndex ] ) );

    iLite = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrLiteIndex ] ) );

    iPassive = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrPassiveIndex ] ) );

    iUfrag = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrUfragIndex ] ) );

    iPwd = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrPwdIndex ] ) );

    iMismatch = pool.OpenFStringL( 

            TPtrC8( AttributeArray[ KIceAttrMismatchIndex ] ) );

    // Other

    iRTCP = pool.OpenFStringL( KAttrRtcp() );    

    iUdp = pool.StringF( SdpCodecStringConstants::EProtocolUdp,

                         SdpCodecStringPool::StringTableL() );

    iTcp = pool.StringF( SdpCodecStringConstants::EProtocolTcp,

                         SdpCodecStringPool::StringTableL() );

    iIN = pool.StringF( SdpCodecStringConstants::ENetType,

                         SdpCodecStringPool::StringTableL() );

    iIPv4 = pool.StringF( SdpCodecStringConstants::EAddressTypeIP4,

                         SdpCodecStringPool::StringTableL() );

    iIPv6 = pool.StringF( SdpCodecStringConstants::EAddressType,

                         SdpCodecStringPool::StringTableL() );

    }

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

// CNSPContentParser::NewL

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

//

CNSPContentParser* CNSPContentParser::NewL()

    {

    CNSPContentParser* self = CNSPContentParser::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNSPContentParser::NewLC

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

//

CNSPContentParser* CNSPContentParser::NewLC()

    {

    CNSPContentParser* self = new( ELeave ) CNSPContentParser;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CNSPContentParser::CNSPContentParser

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

//

CNSPContentParser::~CNSPContentParser()

    {

    iCandidate.Close();

    iRemoteCandidates.Close();

    iLite.Close();

    iPassive.Close();

    iUfrag.Close();

    iPwd.Close();

    iMismatch.Close();

    iRTCP.Close();

    iUdp.Close();

    iTcp.Close();

    iIN.Close();

    iIPv4.Close();

    iIPv6.Close();

    }

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

// CNSPContentParser::IsIceSupported

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

//

TBool CNSPContentParser::IsIceSupported( CSdpDocument& aDocument ) const

    {

    RPointerArray<CSdpMediaField>& mediafields = aDocument.MediaFields();

    const TInt mediafieldcount( mediafields.Count() );

    for ( TInt index = 0; index < mediafieldcount; index++ )

        {

        RPointerArray<CSdpAttributeField>& attributes =

                mediafields[index]->AttributeFields();

        const TInt attributecount( attributes.Count() );

        for ( TInt jndex = 0; jndex < attributecount; jndex++ )

            {

            if ( iCandidate == attributes[jndex]->Attribute() )

                {

                return ETrue;

                }

            }

        }

    return EFalse;

    }

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

// CNSPContentParser::IsMismatchL

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

//

TBool CNSPContentParser::IsMismatchL( CSdpDocument& aDocument ) const

    {

    const CSdpConnectionField* connField = aDocument.ConnectionField();

    const TDesC8& address = ( connField ? connField->Address() : KNullDesC8 );

    RPointerArray<CSdpMediaField>& mediafields = aDocument.MediaFields();

    TBool mismatch( EFalse );

    const TInt mediafieldcount( mediafields.Count() );

    for ( TInt index = 0; index < mediafieldcount && !mismatch; index++ )

        {

        const TDesC8& addr = CONN_ADDR( *mediafields[index], address );

        mismatch = IsMismatchAttribute( *mediafields[index] );

        if ( !mismatch && IsMismatchL( *mediafields[index], addr ) )

            {

            AddMismatchL( *mediafields[index] );

            mismatch = ETrue;

            }

        }

    return mismatch;

    }

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

// CNSPContentParser::IsMismatchL

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

//

TBool CNSPContentParser::IsMismatchL( CSdpMediaField& aMediaField,

        const TDesC8& aAddress ) const

    {

    const TDesC8& rtpAddr = CONN_ADDR( aMediaField, aAddress );

    const TUint rtpPort = aMediaField.Port();

    RBuf8 rtcpAddr;

    rtcpAddr.CreateL( KMaxLengthOfFQDN );

    rtcpAddr.CleanupClosePushL();

    rtcpAddr = rtpAddr;

    TUint rtcpPort = rtpPort;

    TBool isRtcp = FindRTCP( aMediaField, rtcpAddr, rtcpPort );

    RPointerArray<CNATFWCandidate> remotecand;

    CleanupStack::PushL( TCleanupItem(

            CNSPContentParser::CleanupArrayItem, &remotecand ) );

	GetCandidatesL( aMediaField, remotecand );

    const TInt candidatecount( remotecand.Count() );

    TBool mismatch = ( candidatecount ? ETrue : EFalse );

    for ( TInt index = 0; index < candidatecount; index++ )

        {

        const TDesC8& addr = remotecand[index]->TransportDomainAddr();

        const TUint port = remotecand[index]->TransportDomainPort();

        if ( ( !rtpAddr.Compare( addr ) && port == rtpPort ) ||

             ( isRtcp && !rtcpAddr.Compare( addr ) && port == rtcpPort ) )

            {

            mismatch = EFalse;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &remotecand );

    CleanupStack::PopAndDestroy( &rtcpAddr );

    NSPLOG_INT( "CNSPContentParser::IsMismatchL, ret:", mismatch )

    return mismatch;

    }

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

// CNSPContentParser::IsMismatchAttribute

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

//

TBool CNSPContentParser::IsMismatchAttribute( CSdpMediaField& aMediaField ) const

    {

    RPointerArray<CSdpAttributeField>& attributes = aMediaField.AttributeFields();

    const TInt attributecount( attributes.Count() );

    for ( TInt index = 0; index < attributecount; index++ )

        {

        if ( iMismatch == attributes[index]->Attribute() )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CNSPContentParser::IsLiteAttribute

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

//

TBool CNSPContentParser::IsLiteAttribute( CSdpDocument& aDocument ) const

    {

    const RPointerArray<CSdpAttributeField>& attributes =

            aDocument.AttributeFields();

    const TInt attributecount( attributes.Count() );

    for ( TInt index = 0; index < attributecount; index++ )

        {

        if ( iLite == attributes[index]->Attribute() )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CNSPContentParser::FindRTCP

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

//

TBool CNSPContentParser::FindRTCP( CSdpMediaField& aMediaField,

        TDes8& aAddress, TUint& aPort ) const

    {

    const RPointerArray<CSdpAttributeField>& attributes =

            aMediaField.AttributeFields();

    const TInt attributecount( attributes.Count() );

    for ( TInt index = 0; index < attributecount; index++ )

        {

        if ( iRTCP == attributes[index]->Attribute() )

            {

            TLex8 lexer( attributes[index]->Value() );

            TUint port( KRejecPort );

            TRAPD( error, LexTDesC8ToTUintL( lexer.NextToken(), port ) );

            aPort = ( KErrNone == error ? port : aPort );

            if ( KErrNone == error && !lexer.Eos() )

                {

                lexer.NextToken(); // nettype, not needed

                lexer.NextToken(); // addresstype, not needed

                aAddress = lexer.NextToken();

                }

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CNSPContentParser::ModifyRTCPL

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

//

void CNSPContentParser::ModifyRTCPL( CSdpMediaField& aMediaField,

        const TDesC8& aAddress, TUint aPort ) const

    {

    TInetAddr address;

    CSdpAttributeField* attr = NULL;

    const RPointerArray<CSdpAttributeField>& attributes =

            aMediaField.AttributeFields();

    const TInt attributecount( attributes.Count() );

    for ( TInt index = 0; index < attributecount; index++ )

        {

        attr = attributes[index];

        if ( iRTCP == attr->Attribute() )

            {

            HBufC8* newattribute = HBufC8::NewLC( KMaxLengthRtcpField );

            TPtr8 ptr( newattribute->Des() );

            AppendNumToTDes8L( ptr, aPort );

            AppendTDesC8ToTDes8L( ptr, iIN.DesC() );

            InputTDesC8ToTInetAddrL( aAddress, address );

            AppendTDesC8ToTDes8L( ptr, KAfInet == address.Family() ?

                    iIPv4.DesC() : iIPv6.DesC() );

            AppendTDesC8ToTDes8L( ptr, aAddress, EFalse );

            attr->SetL( attr->Attribute(), newattribute->Des() );

            CleanupStack::PopAndDestroy( newattribute );

            break;

            }

        }

    }

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

// CNSPContentParser::AddLiteL

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

//

void CNSPContentParser::AddLiteL( CSdpDocument& aDocument ) const

    {

    CSdpAttributeField* attr = CSdpAttributeField::NewLC( iLite, KNullDesC8 );

    User::LeaveIfError( aDocument.AttributeFields().Append( attr ) );

    CleanupStack::Pop( attr );

    }

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

// CNSPContentParser::AddMismatchL

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

//

void CNSPContentParser::AddMismatchL( CSdpDocument& aMismatch,

        CSdpDocument& aMismatched ) const

    {

    CSdpMediaField* field = NULL;

    RPointerArray<CSdpMediaField>& mismatchmedia = aMismatch.MediaFields();

    RPointerArray<CSdpMediaField>& mismatchedmedia = aMismatched.MediaFields();

    const TInt mediacount( mismatchmedia.Count() );

    for ( TInt index = 0; index < mediacount; index++ )

        {

        if ( IsMismatchAttribute( *mismatchmedia[index] ) )

            {

            FINDFIELD_L( field, *mismatchmedia[index], mismatchedmedia );

            AddMismatchL( *field );

            RemoveIceContent( *mismatchmedia[index] );

            }

        }

    }

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

// CNSPContentParser::AddMismatchL

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

//

void CNSPContentParser::AddMismatchL( CSdpMediaField& aMediaField ) const

    {

    CSdpAttributeField* attr = CSdpAttributeField::NewLC( iMismatch, KNullDesC8 );

    User::LeaveIfError( aMediaField.AttributeFields().Append( attr ) );

    CleanupStack::Pop( attr );

    }

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

// CNSPContentParser::AddCandidatesL

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

//

void CNSPContentParser::AddCandidatesL( CSdpMediaField& aMediaField,

        const RPointerArray<CNATFWCandidate>& aCandidates ) const

    {

    CSdpAttributeField* attr = NULL;

    RPointerArray<CSdpAttributeField>& attributeArray =

            aMediaField.AttributeFields();

    const TInt candidatecount( aCandidates.Count() );

    for ( TInt index = 0; index < candidatecount; index++ )

        {

        TRAPD( error, attr = EncodeCandidateLineL( *aCandidates[index] ) )

        User::LeaveIfError( KErrNone == error ?

                attributeArray.Append( attr ) : error );

        }

    }

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

// CNSPContentParser::AddRemoteCandidatesL

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

//

void CNSPContentParser::AddRemoteCandidatesL( CSdpMediaField& aMediaField,

        const RPointerArray<CNATFWCandidate>& aCandidates ) const

    {

    RPointerArray<CSdpAttributeField>& attributeArray =

            aMediaField.AttributeFields();

    CSdpAttributeField* attribute = EncodeRemoteCandidatesL( aCandidates );

    CleanupStack::PushL( attribute );

    User::LeaveIfError( attributeArray.Append( attribute ) );

    CleanupStack::Pop( attribute );

    }

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

// CNSPContentParser::AddCredentialsL

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

//

void CNSPContentParser::AddCredentialsL( CSdpMediaField& aMediaField,

        const CNATFWCredentials& aCredentials ) const

    {

    RPointerArray<CSdpAttributeField>& attributeArray =

            aMediaField.AttributeFields();

    CSdpAttributeField* user = EncodeUfragL( aCredentials );

    CleanupStack::PushL( user );

    User::LeaveIfError( attributeArray.Append( user ) );

    CleanupStack::Pop( user );

    CSdpAttributeField* pwd = EncodePwdL( aCredentials );

    CleanupStack::PushL( pwd );

    User::LeaveIfError( attributeArray.Append( pwd ) );

    CleanupStack::Pop( pwd );

    }

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

// CNSPContentParser::AddCredentialsL

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

//

void CNSPContentParser::AddCredentialsL( CSdpDocument& aDocument,

        const CNATFWCredentials& aCredentials ) const

    {

    RPointerArray<CSdpAttributeField>& attributeArray =

            aDocument.AttributeFields();

    CSdpAttributeField* user = EncodeUfragL( aCredentials );

    CleanupStack::PushL( user );

    User::LeaveIfError( attributeArray.Append( user ) );

    CleanupStack::Pop( user );

    CSdpAttributeField* pwd = EncodePwdL( aCredentials );

    CleanupStack::PushL( pwd );

    User::LeaveIfError( attributeArray.Append( pwd ) );

    CleanupStack::Pop( pwd );

    }