/*

* Copyright (c) 2002-2008 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:  Settings item for SIP settings, handles also the saving of

*                settings item. 

*

*/

// INCLUDE FILES

#include <wpsipadapter.rsg>

#include <charconv.h>

#include <sipprofile.h>

#include <sipprofiletypeinfo.h>

#include <sipmanagedprofileregistry.h>

#include <sipprofileregistry.h>

#include <sipmanagedprofile.h>

#include <in_sock.h>                // TInetAddr, TSockAddr

#include <sip.h>

#include <WPAdapterUtil.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "CWPSIPItem.h"

#include "CSIPProfileRegistryObserver.h"

#include "CWPSIPAdapter.h"

#include "wpsipadapterdebug.h"

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmmanagerdef.h>

#include <escapeutils.h>

// CONSTANTS

const TInt KMaxCharsInTUint32     = 10;

const TInt KMaxProviderNameLength = 100;

_LIT8( KPTypeIMS,           "IMS" ); // w9010.txt

_LIT8( KImsPlugInName,      "ims" ); // SIP Profile Plugin name

_LIT8( KPTypeNokiapreR5Ims, "NokiapreR5Ims" ); // for backward compatibility

_LIT8( KPTypeIETF,          "IETF" ); // w9010.txt

_LIT8( KColon,              ":" );

_LIT8( KTransport,          ";transport=" ); // IETF RFC 3261

_LIT8( KSip,                "sip:" ); // IETF RFC 3261

_LIT8( KLr,                 ";lr" ); // IETF RFC 3261

_LIT8( KOpenParenthesis,    "(" );

_LIT8( KClosedParenthesis,  ")" );

_LIT8( KSips,               "sips:" ); // IETF RFC 3261

_LIT8( KEscaped,            "%" );

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

// CWPSIPItem::NewL

//

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

//

CWPSIPItem* CWPSIPItem::NewL()

    {

    CWPSIPItem* self = new ( ELeave ) CWPSIPItem();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWPSIPItem::CWPSIPItem

//

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

//

CWPSIPItem::CWPSIPItem()

    {

    }

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

// CWPSIPItem::~CWPSIPItem

//

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

//

CWPSIPItem::~CWPSIPItem()

    {

    DBG_PRINT( "CWPSIPItem::~CWPSIPItem - begin" );

    delete iProviderId;

    delete iName;

    delete iAppRef;

    delete iAOR;

    delete iProtocolForOutboundConnection;

    delete iNapDefName;

    delete iOutboundAddr;

    delete iPortNumberForOutboundConnection;

    delete iAuthenticationTypeForOutbound;

    delete iUsernameForOutbound;

    delete iPasswordForOutbound;

    delete iRealmForOutbound;

    delete iRegistrarAddr;

    delete iAuthenticationTypeForRegistrar;

    delete iUsernameForRegistrar;

    delete iPasswordForRegistrar;

    delete iRealmForRegistrar;

    delete iSavedProfileId;

    delete iToAppRef;

    delete iNetwork;

    DBG_PRINT( "CWPSIPItem::~CWPSIPItem - end" );

    }

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

// CWPSIPSAPItem::ConstructL

//

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

//

void CWPSIPItem::ConstructL()

    { 

    DBG_PRINT( "CWPSIPItem::ConstructL - begin" );

    iProviderId                               = HBufC8::NewL( 0 );

    iName                                     = HBufC::NewL( 0 );

    iAppRef                                   = HBufC8::NewL( 0 );

    iAOR                                      = HBufC8::NewL( 0 );

    iProtocolForOutboundConnection            = HBufC8::NewL( 0 );

    iNapDefName                               = HBufC8::NewL( 0 );

    iSignalCompressionEnabled                 = EFalse;

    iSecurityNegotiationEnabled               = EFalse;

    iLooseRoutingForOutboundConnectionEnabled = EFalse;

    iOutboundAddr                             = HBufC8::NewL( 0 );

    iPortNumberForOutboundConnection          = HBufC8::NewL( 0 );

    iAuthenticationTypeForOutbound            = HBufC8::NewL( 0 );

    iUsernameForOutbound                      = HBufC8::NewL( 0 );

    iPasswordForOutbound                      = HBufC8::NewL( 0 );

    iRealmForOutbound                         = HBufC8::NewL( 0 );

    iRegistrarAddr                            = HBufC8::NewL( 0 );

    iAuthenticationTypeForRegistrar           = HBufC8::NewL( 0 );

    iUsernameForRegistrar                     = HBufC8::NewL( 0 );

    iPasswordForRegistrar                     = HBufC8::NewL( 0 );

    iRealmForRegistrar                        = HBufC8::NewL( 0 );

    iNapDef                                   = NULL;

    iSetAsDefault                             = EFalse;

    iSavedProfileId                           = HBufC8::NewL( 0 );

    iProfileId                                = 0;

    iProfileLockEnabled                       = EFalse;

    iToAppRef                                 = HBufC8::NewL( 0 );

    iNetwork                                  = HBufC::NewL( 0 );

    iSnapId                                   = KErrNotFound;

    SetSigQos( 40 );

    DBG_PRINT( "CWPSIPItem::ConstructL - end" );

    }

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

// CWPSIPItem::SetProfileTypeL

//

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

//

void CWPSIPItem::SetProfileTypeL( const TDesC8& aPTYPE )

    {

    HBufC8* tmpProfileType = aPTYPE.AllocL();

    CleanupStack::PushL( tmpProfileType ); // CS:1

    // Map the profile type name used in message to SIP stack internal type.

    if ( ( ( tmpProfileType->Compare( KPTypeIMS() ) ) == 0 ) ||

        ( tmpProfileType->Compare( KPTypeNokiapreR5Ims ) == 0 ) )

        {

        iSIPProfileTypeInfo.iSIPProfileClass = TSIPProfileTypeInfo::EIms;

        iSIPProfileTypeInfo.iSIPProfileName.Insert( 0, KImsPlugInName() );

        }

    else if ( ( tmpProfileType->Compare( KPTypeIETF() ) ) == 0 )

        {

        iSIPProfileTypeInfo.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;

        iSIPProfileTypeInfo.iSIPProfileName.Insert( 0,tmpProfileType->Des() );

        }

    else

        {

        iSIPProfileTypeInfo.iSIPProfileClass = TSIPProfileTypeInfo::EOther;

        iSIPProfileTypeInfo.iSIPProfileName.Insert( 0,tmpProfileType->Des() );

        }

    CleanupStack::PopAndDestroy( tmpProfileType ); // CS:0

    }

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

// CWPSIPItem::SetAppRefL

//

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

//

void CWPSIPItem::SetAppRefL( const TDesC8& aAPPREF )

    {

    HBufC8* temp = aAPPREF.AllocL();

    delete iAppRef;

    iAppRef = NULL;

    iAppRef = temp;

    }

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

// CWPSIPItem::SetAORL

//

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

//

void CWPSIPItem::SetAORL( const TDesC8& aPUID )

    {

    HBufC8* temp( NULL );

    if ( KErrNotFound == aPUID.Find( KEscaped() ) )

        {

        temp = EscapeUtils::EscapeEncodeL( aPUID,

            EscapeUtils::EEscapeNormal );

        }

    else

        {

        temp = aPUID.AllocL();

        }

    delete iAOR;

    iAOR = NULL;

    // If the PUID starts with sip: or sips:

    if ( KErrNone == temp->Find( KSip() ) ||

         KErrNone == temp->Find( KSips() ) )

        {

        iAOR = temp;

        }

    else

        {

        CleanupStack::PushL( temp ); // CS: 1

        iAOR = HBufC8::NewL( KSip().Length() + temp->Length() );

        iAOR->Des().Copy( KSip() );

        iAOR->Des().Append( *temp );

        CleanupStack::PopAndDestroy( temp );  // CS: 0

        }

    }

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

// CWPSIPItem::SetNameL

//

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

//

void CWPSIPItem::SetNameL( const TDesC& aNAME )

    {

    HBufC* temp = aNAME.AllocL();

    delete iName;

    iName = NULL;

    iName = temp;

    }

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

// CWPSIPItem::SetProviderIdL

//

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

//

void CWPSIPItem::SetProviderIdL( const TDesC8& aPROVIDERID )

    {

    HBufC8* temp = aPROVIDERID.AllocL();

    delete iProviderId;

    iProviderId = NULL;

    iProviderId = temp;

    }

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

// CWPSIPItem::SetProtocolForOutboundConnectionL

//

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

//

void CWPSIPItem::SetProtocolForOutboundConnectionL( const TDesC8& aAPROTOCOL )

    {

    HBufC8* temp = aAPROTOCOL.AllocL();

    delete iProtocolForOutboundConnection;

    iProtocolForOutboundConnection = NULL;

    iProtocolForOutboundConnection = temp;

    }

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

// CWPSIPItem::SetNapDefNameL

//

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

//

void CWPSIPItem::SetNapDefNameL( const TDesC8& aTONAPID )

    {

    HBufC8* temp = aTONAPID.AllocL();

    delete iNapDefName;

    iNapDefName = NULL;

    iNapDefName = temp;

    }

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

// CWPSIPItem::SetSignalCompressionEnabled

//

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

//

void CWPSIPItem::SetSignalCompressionEnabled( TBool aEnabled )

    {

    iSignalCompressionEnabled = aEnabled;

    }

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

// CWPSIPItem::SetSecurityNegotiationEnabled

//

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

//

void CWPSIPItem::SetSecurityNegotiationEnabled( TBool aEnabled )

    {

    iSecurityNegotiationEnabled = aEnabled;

    }

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

// CWPSIPItem::SetLooseRoutingForOutboundConnectionEnabled

//

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

//

void CWPSIPItem::SetLooseRoutingForOutboundConnectionEnabled( TBool aEnabled )

    {

    iLooseRoutingForOutboundConnectionEnabled = aEnabled;

    }

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

// CWPSIPItem::SetProfileLockEnabled

//

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

//

void CWPSIPItem::SetProfileLockEnabled( TBool aEnabled )

    {

    iProfileLockEnabled = aEnabled;

    }

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

// CWPSIPItem::SetOutboundAddrL

//

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

//

void CWPSIPItem::SetOutboundAddrL( const TDesC8& aOutboundAddr )

    {

    // If the parameter is empty, do not add prefix.

    if ( !aOutboundAddr.Length() )

        {

        return;

        }

    delete iOutboundAddr;

    iOutboundAddr = NULL;

    // Check if the address starts with sip: or sips:

    if ( KErrNone == aOutboundAddr.Find( KSip() ) ||

         KErrNone == aOutboundAddr.Find( KSips() ) )

        {

        iOutboundAddr = aOutboundAddr.AllocL();

        }

    else

        {

        iOutboundAddr = HBufC8::NewL( KSip().Length() + 

            aOutboundAddr.Length() );

        iOutboundAddr->Des().Copy( KSip() );

        iOutboundAddr->Des().Append( aOutboundAddr );

        }

    }

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

// CWPSIPItem::SetPortNumberForOutboundConnectionL

//

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

//

void CWPSIPItem::SetPortNumberForOutboundConnectionL( const TDesC8& aPORT )

    {

    HBufC8* temp = aPORT.AllocL();

    delete iPortNumberForOutboundConnection;

    iPortNumberForOutboundConnection = NULL;

    iPortNumberForOutboundConnection = temp;

    }

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

// CWPSIPItem::SetAuthenticationTypeForOutboundL

//

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

//

void CWPSIPItem::SetAuthenticationTypeForOutboundL( const TDesC8& aAAUTHTYPE )

    {

    HBufC8* temp = aAAUTHTYPE.AllocL();

    delete iAuthenticationTypeForOutbound;

    iAuthenticationTypeForOutbound = NULL;

    iAuthenticationTypeForOutbound = temp;

    }

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

// CWPSIPItem::SetUsernameForOutboundL

//

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

//

void CWPSIPItem::SetUsernameForOutboundL( const TDesC8& aAAUTHNAME )

    {

    HBufC8* temp( NULL );

    if ( KErrNotFound == aAAUTHNAME.Find( KEscaped() ) )

        {

        temp = EscapeUtils::EscapeEncodeL( aAAUTHNAME,

            EscapeUtils::EEscapeNormal );

        }

    else

        {

        temp = aAAUTHNAME.AllocL();

        }

    delete iUsernameForOutbound;

    iUsernameForOutbound = NULL;

    iUsernameForOutbound = temp;

    }

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

// CWPSIPItem::SetPasswordForOutboundL

//

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

//

void CWPSIPItem::SetPasswordForOutboundL( const TDesC8& aAAUTHSECRET )

    {

    HBufC8* temp = aAAUTHSECRET.AllocL();

    delete iPasswordForOutbound;

    iPasswordForOutbound = NULL;

    iPasswordForOutbound = temp;

    }

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

// CWPSIPItem::SetRealmForOutboundL

//

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

//

void CWPSIPItem::SetRealmForOutboundL( const TDesC8& aAAUTHDATA )

    {

    HBufC8* temp = aAAUTHDATA.AllocL();

    delete iRealmForOutbound;

    iRealmForOutbound = NULL;

    iRealmForOutbound = temp;

    }

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

// CWPSIPItem::SetRegistrarAddrL

//

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

//

void CWPSIPItem::SetRegistrarAddrL( const TDesC8& aRegistrarAddr )

    {

    // If the paremeter is empty, do not add prefix.

    if ( !aRegistrarAddr.Length() )

        {

        return;

        }

    delete iRegistrarAddr;

    iRegistrarAddr = NULL;

    // Check if the address starts with sip: or sips:

    if ( KErrNone == aRegistrarAddr.Find( KSip() ) ||

         KErrNone == aRegistrarAddr.Find( KSips() ) )

        {

        iRegistrarAddr = aRegistrarAddr.AllocL();

        }

    else

        {

        iRegistrarAddr = HBufC8::NewL( KSip().Length() + 

            aRegistrarAddr.Length() );

        iRegistrarAddr->Des().Copy( KSip() );

        iRegistrarAddr->Des().Append( aRegistrarAddr );

        }

    }

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

// CWPSIPItem::SetAuthenticationTypeForRegistrarL

//

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

//

void CWPSIPItem::SetAuthenticationTypeForRegistrarL( const TDesC8& 

    aAAUTHTYPE )

    {

    HBufC8* temp = aAAUTHTYPE.AllocL();

    delete iAuthenticationTypeForRegistrar;

    iAuthenticationTypeForRegistrar = NULL;

    iAuthenticationTypeForRegistrar = temp;

    }

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

// CWPSIPItem::SetUsernameForRegistrarL

//

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

//

void CWPSIPItem::SetUsernameForRegistrarL( const TDesC8& aAAUTHNAME )

    {

    HBufC8* temp( NULL );

    if ( KErrNotFound == aAAUTHNAME.Find( KEscaped() ) )

        {

        temp = EscapeUtils::EscapeEncodeL( aAAUTHNAME,

            EscapeUtils::EEscapeNormal );

        }

    else

        {

        temp = aAAUTHNAME.AllocL();

        }

    delete iUsernameForRegistrar;

    iUsernameForRegistrar = NULL;

    iUsernameForRegistrar = temp;

    }

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

// CWPSIPItem::SetPasswordForRegistrarL

//

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

//

void CWPSIPItem::SetPasswordForRegistrarL( const TDesC8& aAAUTHSECRET )

    {

    HBufC8* temp = aAAUTHSECRET.AllocL();

    delete iPasswordForRegistrar;

    iPasswordForRegistrar = NULL;

    iPasswordForRegistrar = temp;

    }

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

// CWPSIPItem::SetRealmForRegistrarL

//

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

//

void CWPSIPItem::SetRealmForRegistrarL( const TDesC8& aAAUTHDATA )

    {

    HBufC8* temp = aAAUTHDATA.AllocL();

    delete iRealmForRegistrar;

    iRealmForRegistrar = NULL;

    iRealmForRegistrar = temp;

    }

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