// Copyright (c) 2003-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:

// Name          : SdpConnectionField.cpp

// Part of       : SDP Codec

// Version       : 1.0

//

#include <in_sock.h>

#include <s32strm.h>

#include <stringpool.h>

#include "SdpConnectionField.h"

#include "sdpcodecstringconstants.h"

#include "SdpCodecConstants.h"

#include "SdpCodecStringPool.h"

#include "SdpUtil.h"

#include "SdpCodecErr.h"

#include "SDPCodec.pan"

#include "_sdpdefs.h"

#include "uriutils.h"

// LOCAL CONSTANTS

const TInt KHeaderIndex = 0;

const TInt KNetworkTypeIndex = 1;

const TInt KAddressTypeIndex = 2;

const TInt KAddressIndex = 3;

const TInt KTokenCount = 4;

const TInt KMaxAddressLength = 256;

const TUint KMaxIPDesLength = 39;

_LIT16(KWildAddr, "0.0.0.0");

_LIT16(KWildAddrIPv6, "::");

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

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

// CSdpConnectionField::CSdpConnectionField

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

// might leave.

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

//

CSdpConnectionField::CSdpConnectionField() :

    iTTL( KErrNotFound ),

    iNumOfAddress( KDefaultNumOfAddress )

	{

	}

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

// CSdpConnectionField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpConnectionField::ConstructL(

    const TDesC8& aText )

	{

    // aText should be in format

    // c=<network type> <address type> <connection address>

    iPool = SdpCodecStringPool::StringPoolL();

    RArray<TPtrC8> array =

        SdpUtil::GetElementsFromLineL( aText, KErrSdpCodecConnectionField );

    CleanupClosePushL( array );

    if ( array.Count() != KTokenCount )

        {

        User::Leave( KErrSdpCodecConnectionField );

        }

    RStringF origHeader =  iPool.StringF( SdpCodecStringConstants::EConnection,

                                          SdpCodecStringConstants::Table );

    if ( origHeader.DesC().CompareF( array[KHeaderIndex] ) != 0 )

        {

        // Header didn't match

        User::Leave( KErrSdpCodecConnectionField );

        }

    // <network type>

    CopyNetTypeL( array[KNetworkTypeIndex] );

    // <address type>

    CopyAddressTypeL( array[KAddressTypeIndex] );

    // <address>

    CopyAddressL( array[KAddressIndex], iPool );

    CleanupStack::PopAndDestroy();  // array

	}

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

// CSdpConnectionField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpConnectionField::ConstructL(

    const TInetAddr& aAddress,

    TInt aTTL,

    TUint aNumOfAddress )

	{

    __ASSERT_ALWAYS( IsValidAddress(aAddress, aTTL, aNumOfAddress) == KErrNone,

                     User::Leave( KErrSdpCodecConnectionField ) );

    iPool = SdpCodecStringPool::StringPoolL();

    TBuf<KMaxIPDesLength> addr;

    //If aAddress is IPv4-Mapped IPv6,the result of Output is IPv4

    aAddress.Output( addr );

    // Copy address

    iAddress = HBufC8::NewL( addr.Length() );

    iAddress->Des().Copy( addr );

    // TTL

    iTTL = aTTL;

    // Num of addresses

    iNumOfAddress = aNumOfAddress;

    // Network type

    iNetType = iPool.StringF( SdpCodecStringConstants::ENetType,

                              SdpCodecStringConstants::Table ).Copy();

    // Address type

	if ( UriUtils::HostType( addr ) == UriUtils::EIPv4Host )

		{

		//addresstype for IPv4

			iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressTypeIP4,

                                      SdpCodecStringConstants::Table ).Copy();

			}

	else if ( UriUtils::HostType( addr ) == UriUtils::EIPv6Host )

			{

			//addresstype IPv6

			iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressType,

                                      SdpCodecStringConstants::Table ).Copy();

			}

	else

		{

		User::Leave(KErrArgument);

		}

	__TEST_INVARIANT;

	}

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

// CSdpConnectionField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpConnectionField::ConstructL(

    RStringF aNetType,

	RStringF aAddressType,

	const TDesC8& aAddress )

    {

    iPool = SdpCodecStringPool::StringPoolL();

    // Network type

    CopyNetTypeL( aNetType.DesC() );

    // Address type

    CopyAddressTypeL( aAddressType.DesC() );

    // Address + TTL + numOfAddress

    CopyAddressL( aAddress, aNetType.Pool() );

    }

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

// CSdpConnectionField::DecodeL

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::DecodeL(

    const TDesC8& aText )

	{

	CSdpConnectionField* obj = CSdpConnectionField::DecodeLC( aText );

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpConnectionField::DecodeLC

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::DecodeLC(

    const TDesC8& aText )

	{

	CSdpConnectionField* obj = new ( ELeave ) CSdpConnectionField;

	CleanupStack::PushL( obj );

	obj->ConstructL( aText );

	return obj;

	}

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

// CSdpConnectionField::NewL

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::NewL(

    const TInetAddr& aAddress,

    TInt aTTL,

    TUint aNumOfAddress )

	{

	CSdpConnectionField* obj = CSdpConnectionField::NewLC(

        aAddress, aTTL, aNumOfAddress );

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpConnectionField::NewLC

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::NewLC(

    const TInetAddr& aAddress,

    TInt aTTL,

    TUint aNumOfAddress )

	{

	CSdpConnectionField* obj = new ( ELeave ) CSdpConnectionField;

	CleanupStack::PushL( obj );

	obj->ConstructL( aAddress, aTTL, aNumOfAddress );

	return obj;

	}

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

// CSdpConnectionField::NewL

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::NewL(

    RStringF aNetType,

    RStringF aAddressType,

    const TDesC8& aAddress )

    {

    CSdpConnectionField* obj = CSdpConnectionField::NewLC(

        aNetType, aAddressType, aAddress );

	CleanupStack::Pop();

	return obj;

    }

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

// CSdpConnectionField::NewLC

// Two-phased constructor

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::NewLC(

    RStringF aNetType,

    RStringF aAddressType,

    const TDesC8& aAddress )

    {

    CSdpConnectionField* obj = new ( ELeave ) CSdpConnectionField;

	CleanupStack::PushL( obj );

	obj->ConstructL( aNetType, aAddressType, aAddress );

	return obj;

    }

// Destructor

EXPORT_C CSdpConnectionField::~CSdpConnectionField()

	{

    delete iAddress;

    iNetType.Close();

    iAddressType.Close();

	}

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

// CSdpConnectionField::EncodeL

// Writes attributes in proper format to the stream

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

//

EXPORT_C void CSdpConnectionField::EncodeL(

    RWriteStream& aStream ) const

	{

	__TEST_INVARIANT;

    TBuf8<20> number;  // Is enough for addr as well

    // c=<network type> <address type> <connection address>

    RStringF header = iPool.StringF( SdpCodecStringConstants::EConnection,

                                     SdpCodecStringConstants::Table );

    aStream.WriteL( header.DesC() );

    // Network type

    aStream.WriteL( iNetType.DesC() );

    aStream.WriteL( KSPStr );

    // Address type

    aStream.WriteL( iAddressType.DesC() );

    aStream.WriteL( KSPStr );

    // Connection address

    aStream.WriteL( *iAddress );

    if ( iTTL != KErrNotFound )

        {

        number.Zero();

        number.Append( KSlashStr );

        number.AppendFormat( _L8("%d"), iTTL );

        aStream.WriteL( number );

        }

    if ( iNumOfAddress > 1 )

        {

        number.Zero();

        number.Append( KSlashStr );

        number.AppendFormat( _L8("%u"), iNumOfAddress );

        aStream.WriteL( number );

        }

     // End-of-Line mark

	aStream.WriteL( KCRLFStr );

	}

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

// CSdpConnectionField::CloneL

// Clones an exact copy of this object

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

//

EXPORT_C CSdpConnectionField* CSdpConnectionField::CloneL() const

	{

	__TEST_INVARIANT;

	CSdpConnectionField* obj = NULL;

    const TInetAddr* addr = InetAddress();

    if ( addr )

        {

        // Could be anything

        obj = CSdpConnectionField::NewL( *addr, iTTL, iNumOfAddress );

        }

    else

        {

        // Unicast FQDN address

        obj = CSdpConnectionField::NewL( iNetType, iAddressType, *iAddress );

        }

	__ASSERT_DEBUG( *this == *obj, User::Panic(

                                   KSdpCodecPanicCat, KSdpCodecPanicInternal));

	return obj;

	}

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

// CSdpConnectionField::operator==

// Checks if two origin fields are equal

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

//

EXPORT_C TBool CSdpConnectionField::operator== (

    const CSdpConnectionField& aObj ) const

	{

	__TEST_INVARIANT;

    TBool equal( EFalse );

    if ( (*iAddress).CompareF( aObj.Address() ) == 0 &&

         NetType() == aObj.NetType() &&

         AddressType() == aObj.AddressType() &&

         TTLValue() == aObj.TTLValue() &&

         NumOfAddress() == aObj.NumOfAddress() )

        {

        // All attributes match, two fields are equal

        equal = ETrue;

        }

	return equal;

	}

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

// CSdpConnectionField::NetType

// Returns network type

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

//

EXPORT_C RStringF CSdpConnectionField::NetType() const

	{

	__TEST_INVARIANT;

	return iNetType;

	}

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

// CSdpConnectionField::AddressType

// Returns address type

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

//

EXPORT_C RStringF CSdpConnectionField::AddressType() const

	{

	__TEST_INVARIANT;

	return iAddressType;

	}

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

// CSdpConnectionField::InetAddress

// Returns address in TInetAddr format if possible

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

//

EXPORT_C const TInetAddr* CSdpConnectionField::InetAddress() const

	{

	__TEST_INVARIANT;

    TInetAddr* addr = NULL;

    TBuf<KMaxAddressLength> addr16;

    addr16.Copy( iAddress->Des() );

    TInt err = iInetAddress.Input( addr16 );

    if ( err == KErrNone )

        {

        addr = &iInetAddress;

        }

	return addr;

	}

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

// CSdpConnectionField::Address

// Returns address in TDesC8 format

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

//

EXPORT_C const TDesC8& CSdpConnectionField::Address() const

    {

    return *iAddress;

    }

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

// CSdpConnectionField::SetInetAddressL

// Sets address from TInetAddr

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

//

EXPORT_C void CSdpConnectionField::SetInetAddressL(

    const TInetAddr& aAddress,

    TInt aTTL,

    TUint aNumOfAddress )

	{

	__TEST_INVARIANT;

    if ( IsValidAddress( aAddress, aTTL, aNumOfAddress ) == KErrNone )

        {

        TBuf<KMaxAddressLength> addr16;

       	//If aAddress IPv4-Mapped IPv6, result of Output IPv4

         aAddress.Output( addr16 );

        HBufC8* tempBuf = HBufC8::NewL( addr16.Length() );

        tempBuf->Des().Copy( addr16 );

        SdpUtil::SetDefaultNetTypeAndAddrType(

            iPool, aAddress, iNetType, iAddressType );

        if(aAddress.Address() && aAddress.IsV4Mapped())

			{

			iAddressType.Close();

			iAddressType = iPool.StringF( SdpCodecStringConstants::EAddressTypeIP4,

                                      SdpCodecStringConstants::Table ).Copy();

			}

        // Set address

        delete iAddress;

        iAddress = tempBuf;

        // Set attributes for address

        iTTL = aTTL;

        iNumOfAddress = aNumOfAddress;

        }

    else

        {

        User::Leave( KErrSdpCodecConnectionField );

        }

	__TEST_INVARIANT;

	}

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

// CSdpConnectionField::SetAddressL

// Sets new address and types, leaves on error

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

//

EXPORT_C void CSdpConnectionField::SetAddressL(

    RStringF aNetType,

    RStringF aAddressType,

    const TDesC8& aAddress )

    {

    __TEST_INVARIANT;

    TInt err( KErrNone );

    RStringF netTypeBackup = iNetType.Copy();

    RStringF addressTypeBackup = iAddressType.Copy();

    CleanupClosePushL( netTypeBackup );

    CleanupClosePushL( addressTypeBackup );

    TRAP( err, CopyNetTypeL( aNetType.DesC() ) );

    if ( !err )

        {

        // Netowrk type changed successfully

        TRAP( err, CopyAddressTypeL( aAddressType.DesC() ) );

        if ( !err )

            {

            // Address type & network type changed successfully

            TRAP( err, CopyAddressL( aAddress, iAddressType.Pool() ) );

            if ( err )

                {

                // Place back old netType & address

                iNetType.Close();

                iNetType = netTypeBackup.Copy();

                iAddressType.Close();

                iAddressType = addressTypeBackup.Copy();

                User::LeaveIfError( err );

                }

            // Everything changed succesfully

            }

        else

            {

            // Place back old netType

            iNetType.Close();

            iNetType = netTypeBackup.Copy();

            User::LeaveIfError( err );

            }

        }

    else

        {

        User::LeaveIfError( err );

        }

    CleanupStack::PopAndDestroy( 2 );   // netTypeBackup, addressTypeBackup

    }

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

// CSdpConnectionField::TTLValue