// 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          :  SdpOriginField.cpp

// Part of       :  SDP Codec

// Version       :  1.0

//

#include <in_sock.h>

#include <s32strm.h>

#include "SdpOriginField.h"

#include "SdpOriginFieldPtrs.h"

#include "SdpUtil.h"

#include "sdpcodecstringconstants.h"

#include "SdpCodecConstants.h"

#include "SdpCodecStringPool.h"

#include "SdpCodecErr.h"

#include "SDPCodec.pan"

#include "_sdpdefs.h"

// LOCAL CONSTANTS AND MACROS

const TUint KMaxIPDesLength = 39;

const TUint KHeaderIndex = 0;

const TUint KUserNameIndex = 1;

const TUint KSessionIdIndex = 2;

const TUint KSessionVersionIndex = 3;

const TUint KNetworkTypeIndex = 4;

const TUint KAddressTypeIndex = 5;

const TUint KAddressIndex = 6;

const TInt KTokenCount = 7;

const TInt64 KDummyValue = 1;

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

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

// CSdpOriginField::CSdpOriginField

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

// might leave.

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

//

CSdpOriginField::CSdpOriginField()

    {

    }

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

// CSdpOriginField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpOriginField::ConstructL(    

    const TDesC8& aText )

	{

    // aText should be of format:

    // o=<username> <session id> <version> <network type> 

    // <address type> <address>     

    iPool = SdpCodecStringPool::StringPoolL();

    RArray<TPtrC8> array;

    array = SdpUtil::GetElementsFromLineL( aText, KErrSdpCodecOriginField );

    CleanupClosePushL( array );

    if ( array.Count() != KTokenCount )

        {

        User::Leave( KErrSdpCodecOriginField );

        }

    // Check that the line contains valid header

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

                                          SdpCodecStringConstants::Table );

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

        {

        // Header didn't match

        User::Leave( KErrSdpCodecOriginField );

        }

    iUserName =

    	reinterpret_cast< HBufC8* >( CSdpOriginFieldPtrs::NewL( 0, 0 ) );

    // <username>   

    ParseUserNameL( array );

    // <session id> & <version>

    ParseSessionIDAndVersionL( array );

    // <network type> & <address type>

    ParseNetTypeAndAddressTypeL( array );

    // <address>

    ParseAddressL( array );

	//If address is IPv4-Mapped IPv6 , it is changed to IPv4

	TInetAddr addr;

	TBuf<KMaxAddressLength> address;

	address.Copy(iAddress);

	TInt err = addr.Input( address );

	if ( err == KErrNone )

		{

        // Valid IP address

		TBuf<KMaxIPDesLength> buf;

		addr.Output( buf );

		iAddress.Copy(buf); 

        SetIPAddressType( addr );

		}

    CleanupStack::PopAndDestroy();  // array

	__TEST_INVARIANT;

	}

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

// CSdpOriginField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpOriginField::ConstructL(

    const TDesC8& aUserName, 

    TInt64 aSessionId, 

    TInt64 aSessionVersion, 

    TInetAddr& aUnicastAddress )

	{

    iPool = SdpCodecStringPool::StringPoolL();

	__ASSERT_ALWAYS( 

                   IsValidUserName( aUserName )

				&& IsValidAddress( aUnicastAddress )

                && aSessionId >= 0 && aSessionVersion >= 0,

				User::Leave( KErrSdpCodecOriginField ) );

	iUserName = reinterpret_cast< HBufC8* >

		( CSdpOriginFieldPtrs::NewL( aSessionId, aSessionVersion ) );

	OriginFieldPtrs().SetUserNameL( aUserName );

    TBuf<KMaxIPDesLength> des;

    aUnicastAddress.Output( des );

	//if aUnicastAddress was IPv4-Mapped IPv6 address,

	// the result of Output is IPv4

	// the address is stored in IPv4 format, so the iAddressType 

	// must also be IPv4.    

    iAddress.Copy( des );

    SetIPAddressType( aUnicastAddress );

    iNetType = iPool.StringF( SdpCodecStringConstants::ENetType, 

                              SdpCodecStringConstants::Table ).Copy();

	__TEST_INVARIANT;

	}

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

// CSdpOriginField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpOriginField::ConstructL( 

    const TDesC8& aUserName, 

    TInt64 aSessionId, 

    TInt64 aSessionVersion, 

    RStringF aNetType, 

    RStringF aAddressType, 

    const TDesC8& aAddress )

    {        

    iPool = SdpCodecStringPool::StringPoolL();

    __ASSERT_ALWAYS(

               IsValidUserName( aUserName )

            && IsValidAddress( aAddress ) &&

            TypeMatchesWithFormat( aAddress, aAddressType.DesC(), iPool )

            && ( SdpUtil::IsToken( aNetType.DesC() ) )

            && ( SdpUtil::IsToken( aAddressType.DesC() ) )

            && aSessionId >= 0 && aSessionVersion >= 0,

            User::Leave( KErrSdpCodecOriginField ) );

    iUserName = reinterpret_cast< HBufC8* >

		( CSdpOriginFieldPtrs::NewL( aSessionId, aSessionVersion ) );

	OriginFieldPtrs().SetUserNameL( aUserName );	

    iNetType = aNetType.Copy();

    	TInetAddr addr;

	TBuf<KMaxAddressLength> address;

	address.Copy(aAddress);

	TInt err = addr.Input(address);

	if ( err  == KErrNone )

		{

		// Valid IP address

		TBuf< KMaxIPDesLength > buf;

		addr.Output( buf );

		iAddress.Copy( buf );		

		SetIPAddressType( addr );

		}

	else

		{

		iAddress = aAddress;

    	iAddressType = aAddressType.Copy();	

		}

    __TEST_INVARIANT;    

    }

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

// CSdpOriginField::DecodeL

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::DecodeL(    

    const TDesC8& aText )

	{

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

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpOriginField::DecodeLC

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::DecodeLC(    

    const TDesC8& aText )

	{

	CSdpOriginField* obj = new ( ELeave ) CSdpOriginField;

	CleanupStack::PushL( obj );

	obj->ConstructL(aText );

	return obj;

	}

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

// CSdpOriginField::NewL

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::NewL(    

    const TDesC8& aUserName, 

	TInt64 aSessionId, 

	TInt64 aSessionVersion, 

	TInetAddr& aAddress )

	{

	CSdpOriginField* obj = CSdpOriginField::NewLC( 

        aUserName, aSessionId, aSessionVersion, aAddress );

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpOriginField::NewLC

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::NewLC(    

    const TDesC8& aUserName, 

	TInt64 aSessionId, 

	TInt64 aSessionVersion, 

	TInetAddr& aAddress )

	{

	CSdpOriginField* obj = new ( ELeave ) CSdpOriginField;

	CleanupStack::PushL(obj);

	obj->ConstructL( aUserName, aSessionId, aSessionVersion, aAddress );

	return obj;

	}

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

// CSdpOriginField::NewL

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::NewL(

    const TDesC8& aUserName, 

	TInt64 aSessionId, 

	TInt64 aSessionVersion, 

    RStringF aNetType,

    RStringF aAddressType, 

	const TDesC8& aAddress )

    {

	CSdpOriginField* obj = CSdpOriginField::NewLC( 

        aUserName, aSessionId, aSessionVersion, aNetType, 

        aAddressType, aAddress );

	CleanupStack::Pop();

	return obj;

    }

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

// CSdpOriginField::NewLC

// Two-phased constructor

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::NewLC(

    const TDesC8& aUserName, 

	TInt64 aSessionId, 

	TInt64 aSessionVersion, 

	RStringF aNetType,

    RStringF aAddressType, 

	const TDesC8& aAddress )

    {    

    CSdpOriginField* obj = new ( ELeave ) CSdpOriginField;

	CleanupStack::PushL( obj );

	obj->ConstructL( aUserName, aSessionId, aSessionVersion, aNetType, 

                     aAddressType, aAddress );

    return obj;    

    }

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

// CSdpOriginField::~CSdpOriginField

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

//

EXPORT_C CSdpOriginField::~CSdpOriginField()

	{

	CSdpOriginFieldPtrs* tmp =

		reinterpret_cast< CSdpOriginFieldPtrs* >( iUserName );

	delete tmp;

    iNetType.Close();

    iAddressType.Close();

	}

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

// CSdpOriginField::EncodeL

// Writes attributes in proper format to the stream

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

//

EXPORT_C void CSdpOriginField::EncodeL(

    RWriteStream& aStream ) const

	{

    __TEST_INVARIANT;

    // o=<username> <session id> <version> <network type> <address type> 

    //   <address>    

    // "o="

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

                                     SdpCodecStringConstants::Table );

    aStream.WriteL( header.DesC() );

    // <username>

    aStream.WriteL( OriginFieldPtrs().UserName() );

	aStream.WriteL( KSPStr );

    // <session id>    

	aStream.WriteL( OriginFieldPtrs().SessionId() );

	aStream.WriteL( KSPStr );

    // <version>

    aStream.WriteL( OriginFieldPtrs().SessionVersion() );

	aStream.WriteL( KSPStr );

    // <network type>

    aStream.WriteL( iNetType.DesC() );

    aStream.WriteL( KSPStr );    

    // <address type>

    aStream.WriteL( iAddressType.DesC() );

    aStream.WriteL( KSPStr );

    // <address>

    aStream.WriteL( iAddress );

    // End-of-Line mark

	aStream.WriteL( KCRLFStr );

	}

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

// CSdpOriginField::CloneL

// Creates an exact copy of the origin field

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

//

EXPORT_C CSdpOriginField* CSdpOriginField::CloneL() const

	{

	__TEST_INVARIANT;

    CSdpOriginField* obj = 0;

    if ( InetAddress() )

        {

        // Clones instance with TInetAddr

        TInetAddr addr( *InetAddress() );        

        obj = CSdpOriginField::NewLC( UserName(), KDummyValue,

        							  KDummyValue, addr );

        }

    else

        {

        // Clones instance with Internet address as a standard string               

        obj = CSdpOriginField::NewLC( UserName(), KDummyValue, KDummyValue,

                                      iNetType, iAddressType,  Address() );        

        }

	// Set the real values

	obj->OriginFieldPtrs().SetSessionIdL( OriginFieldPtrs().SessionId() );

	obj->OriginFieldPtrs().SetSessionVersionL(

		OriginFieldPtrs().SessionVersion() );

	CleanupStack::Pop( obj );

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

                                                KSdpCodecPanicInternal ) );

	return obj;

	}

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

// CSdpOriginField::operator ==

// Checks if two origin fields are equal

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

//

EXPORT_C TBool CSdpOriginField::operator == (

    const CSdpOriginField& aObj) const

	{

	__TEST_INVARIANT;

    TBool equalFields = EFalse;

    // Check that username, session ID and address type match before

    // going to internet address       

    if ( ( UserName().CompareF( aObj.UserName() ) == 0 ) &&

         ( SessionId() == aObj.SessionId() ) &&

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

         ( Version() == aObj.Version() ) &&

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

        {

        if ( InetAddress() && aObj.InetAddress() )

            {            

            if ( (*InetAddress()).Match( *aObj.InetAddress() ) )

                {

                equalFields = ETrue;

                }

            }

        else if ( !InetAddress() && !aObj.InetAddress() )            

            {

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

                {

                equalFields = ETrue;

                }

            }                

        else

            {

            // These two are not the same

            }

        }   

    return equalFields;

	}

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

// CSdpOriginField::UserName

// Returns username

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

//

EXPORT_C const TDesC8& CSdpOriginField::UserName() const

    {

    __TEST_INVARIANT;

    return OriginFieldPtrs().UserName();

    }

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

// CSdpOriginField::SetUserNameL

// Sets a new username

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

//

EXPORT_C void CSdpOriginField::SetUserNameL(

    const TDesC8& aValue )

    {

    __TEST_INVARIANT;

    if ( IsValidUserName( aValue ) )

        {

        OriginFieldPtrs().SetUserNameL( aValue );

        }

    else

        {

        User::Leave( KErrSdpCodecOriginField );

        }

    }

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

// CSdpOriginField::SessionId

// Returns current session id

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

//

EXPORT_C TInt64 CSdpOriginField::SessionId() const

    {

    __TEST_INVARIANT;

    return Get63Msbs( OriginFieldPtrs().SessionId() );

    }

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

// CSdpOriginField::SetSessionId

// Sets new session ID

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

//

EXPORT_C void CSdpOriginField::SetSessionId(

	TInt64 aValue )

    {

    __TEST_INVARIANT;

    if ( aValue >= 0 )

        {

        TRAP_IGNORE( OriginFieldPtrs().SetSessionIdL( aValue ) )

        }

    }

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

// CSdpOriginField::Version

// Returns version number of the announcement

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

//

EXPORT_C TInt64 CSdpOriginField::Version() const

    {

    __TEST_INVARIANT;

    return Get63Msbs( OriginFieldPtrs().SessionVersion() );

    }

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

// CSdpOriginField::SetVersion

// Sets new version for this session's announcement

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

//

EXPORT_C void CSdpOriginField::SetVersion(