/*

* Copyright (c) 2006 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:  Implementation of plugin base class

*

*/

#include <cmmanager.rsg>

#include <es_sock.h>    // RSocketServ, RConnection

#include <in_sock.h>    // KAfInet

#include <es_enum.h>    // TConnectionInfo

#include <StringLoader.h>

#include <AknUtils.h>

#include <data_caging_path_literals.hrh>

#include <sysutil.h> 

#include <cmmanager.h>

#include "cmmanagerimpl.h"

#include "cmdestinationimpl.h"

#include <cmpluginbaseeng.h>

#include <cmpsettingsconsts.h>

#include "cmlogger.h"

#include <cmcommonui.h>

using namespace CMManager;

using namespace CommsDat;

// EXTERNAL LINKS

// MACROS

#undef _IPV6_DISABLED

// CONSTANTS

const TInt KApMaxConnNameLength = 30;

_LIT(KFormatPostfix, "%02d");

_LIT(KFormatLargePostfix, "%d");

_LIT(KFormatNameWithPostfix, "%S(%S)" );

_LIT(KFormatNoPostfix, "%S");

const TInt KMaxPostfixLength = 5;

const TInt KEstimatedOverhead = 8192;

_LIT( KDefWapGatewayIpAddress, "0.0.0.0" );

_LIT( KLocationName, "Mobile" );

static const TCmAttribConvTable SIapConvTbl[] = 

    {

    // iAttribId, iCommsDatId, iValidFuncL, 

    // iTitleId, 

    // iMaxLength, iAttribFlags, iDefValueResId, iEditorResId, iNotUsed1, iNotUsed2

    // first element describes the min-max values, does not connects to DB!

    { ECmName, ECmIapId, NULL },

    { ECmName, KCDTIdRecordName, NULL,

        R_CMMANAGERUI_CONNECTION_NAME,

        KMaxConnNameLength, EConvNoZeroLength | EConvCompulsory, 

        0, R_TEXT_SETTING_PAGE_CONN_NAME, NULL, NULL },

    { ECmIapId, KCDTIdRecordTag, NULL },

    { 0, 0, NULL },

    };

static const TCmAttribConvTable SProxyConvTbl[] = 

    {

    // iAttribId, iCommsDatId, iValidFuncL, 

    // iTitleId, 

    // iMaxLength, iAttribFlags, iDefValueResId, iEditorResId, iNotUsed1, iNotUsed2

    { ECmProxyUsageEnabled, ECmProxyRangeMax, NULL },

    { ECmProxyUsageEnabled, KCDTIdUseProxyServer, NULL },

    { ECmProxyServerName,   KCDTIdServerName, &SetProxyServerNameL, 

        R_QTN_SET_PROXY_SERVER_ADDRESS, 

        KMaxProxyServerLength, 0, R_QTN_SET_PROXY_SERVER_ADDRESS_NONE, R_TEXT_SETTING_PAGE_PROXY_SERVER_ADDR, NULL, NULL },

    { ECmProxyProtocolName, KCDTIdProtocolName, NULL },

    { ECmProxyPortNumber,   KCDTIdPortNumber, &CheckPortNumberValidityL,

        R_QTN_SET_PROXY_PORT_NUMBER,

        KMaxProxyPortNumberLength, EConvNumber, 0, 0, NULL, NULL },

    { ECmProxyExceptions,   KCDTIdExceptions, NULL },

    { 0, 0, NULL },

    };

static const TCmAttribConvTable SChargeCardConvTbl[] =

    {

    { ECmChargeCardUsageEnabled, ECmChargeCardRangeMax, NULL },

    { ECmChargeCardAccountNumber, KCDTIdAccountNo, NULL },

    { ECmChargeCardPIN, KCDTIdPin, NULL },

    { ECmChargeCardLocalRule, KCDTIdLocalRule, NULL },

    { ECmChargeCardNatRule, KCDTIdNatRule, NULL },

    { ECmChargeCardIntlRule, KCDTIdIntlRule, NULL },

    { 0, 0, NULL },

    };

static const TCmAttribConvTable SLocationConvTbl[] =

    {

    { ECmLocationUsageEnabled, ECmLocationRangeMax, NULL },

    { ECmLocationIntlPrefixCode, KCDTIdIntlPrefixCode, NULL },

    { ECmLocationNatPrefixCode, KCDTIdNatPrefixCode, NULL },

    { ECmLocationNatCode, KCDTIdNatCode, NULL },

    { ECmLocationAreaCode, KCDTIdAreaCode, NULL },

    { ECmLocationDialOutCode, KCDTIdDialOutCode, NULL },

    { ECmLocationDisableCallWaitingCode, KCDTIdDisableCallWaitingCode, NULL },

    { ECmLocationMobile, KCDTIdMobile, NULL },

    { ECmLocationUsePulseDial, KCDTIdUsePulseDial, NULL },

    { ECmLocationWaitForDialTone, KCDTIdWaitForDialTone, NULL },

    { ECmLocationPauseAfterDialOut, KCDTIdPauseAfterDialOut, NULL },

    { 0, 0, NULL },

    };

static const TCmAttribConvTable SWapConvTbl[] = 

    {

    { ECmWapIPGatewayAddress, ECmWapRangeMax, NULL },

    { ECmWapIPGatewayAddress, KCDTIdWAPGatewayAddress, &CheckIPv4ValidityL },

    { ECmWapIPWSPOption, KCDTIdWAPWSPOption, &CheckWAPWspOptionValidityL },

    { ECmWapIPSecurity, KCDTIdWAPSecurity, NULL },

    { ECmWapIPProxyPort, KCDTIdWAPProxyPort, &CheckPortNumberValidityL },

    { ECmWapIPProxyLoginName, KCDTIdWAPProxyLoginName, NULL },

    { ECmWapIPProxyLoginPass, KCDTIdWAPProxyLoginPass, NULL },

    { 0, 0, NULL },

    };

static const TCmAttribConvTable SUiTable[] = 

    {

    { ECmName, 0, NULL,

        R_CMMANAGERUI_CONNECTION_NAME,

        KMaxConnNameLength, EConvNoZeroLength | EConvCompulsory, 0, R_TEXT_SETTING_PAGE_CONN_NAME, NULL, NULL },

    { ECmBearerSettingName, 0, NULL,

        R_PLUGIN_BASE_SET_AP_BEARER,

        0, 0, 0, 0, NULL, NULL },

    { ECmStartPage, 0, NULL,

        R_QTN_SET_STARTING_PAGE,

        KMaxStartPageLength, 0, R_QTN_SET_HOME_PAGE_NONE, R_TEXT_SETTING_PAGE_STARTING_PAGE, 

        R_START_PAGE_DEF_VALUE, NULL, NULL },

    { 0, 0, NULL,

        0, 

        0, 0, 0, NULL, NULL },

    };

/**

 * Private data of plugin base

 */

NONSHARABLE_CLASS( CCmPluginBasePrivate ) : public CBase

    {

    public:

        CCmPluginBasePrivate();

        ~CCmPluginBasePrivate();

    public:

        CCDWAPAccessPointRecord*    iWapAPRecord;

        CCDWAPIPBearerRecord*       iWapIPBearerRecord;

        CCDIAPMetadataRecord*       iMetaDataRecord;

        TNamingMethod   iNamingMethod;

        CArrayPtrFlat<TCmAttrConvArrayItem>*        iConvTblArray;

        RArray<const TCmCommonAttrConvArrayItem*>   iCommonConvTblArray;

        TInt    iLoadResult;

    };    

// ======== LOCAL FUNCTIONS ========

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

// ReadOnlyAttributeL

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

//

EXPORT_C TBool ReadOnlyAttributeL( CCmPluginBaseEng* aThis, 

                                  TUint32 aAttribute,

                                  const TAny* aValue )

    {

    User::Leave( KErrNotSupported );

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// CheckIPv4ValidityL

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

//

EXPORT_C TBool CheckIPv4ValidityL( CCmPluginBaseEng* aThis, 

                                  TUint32 aAttribute,

                                  const TAny* aValue )

    {

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// CheckIPv6ValidityL

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

//

EXPORT_C TBool CheckIPv6ValidityL( CCmPluginBaseEng* aThis, 

                                  TUint32 aAttribute,

                                  const TAny* aValue )

    {

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// CheckPortNumberValidityL

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

//

EXPORT_C TBool CheckPortNumberValidityL( CCmPluginBaseEng* aThis, 

                                        TUint32 aAttribute,

                                        const TAny* aValue )

    {

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// CheckRecordIdValidityL

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

//

EXPORT_C TBool CheckRecordIdValidityL( CCmPluginBaseEng* aThis, 

                                      TUint32 aAttribute,

                                      const TAny* aValue )

    {

    TUint32 recId = *(TUint32*)aValue;

    if( recId < 1 || recId > 254 )

        {

        CLOG_WRITE_1_PTR( aThis, "Not valid Rec id: [%d]", recId );

        User::Leave( KErrArgument );

        }

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// CheckWAPWspOptionValidityL

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

//

EXPORT_C TBool CheckWAPWspOptionValidityL( CCmPluginBaseEng* aThis, 

                                          TUint32 aAttribute,

                                          const TAny* aValue )

    {

    TUint32 wspOpt = (TUint32)aValue;

    if( wspOpt != ECmWapWspOptionConnectionless &&

        wspOpt != ECmWapWspOptionConnectionOriented )

        {

        User::Leave( KErrArgument );

        }

    (void)aThis;

    (void)aAttribute;

    (void)aValue;

    return EFalse;

    }

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

// IsUnspecifiedIPv4Address

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

//

EXPORT_C TBool IsUnspecifiedIPv4Address( const TDesC& aIpv4Address )

    {

    if( aIpv4Address.Length() == 0 ||

        !aIpv4Address.CompareF( KUnspecifiedIPv4 ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// ClassifyIPv6Address

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

//

EXPORT_C TIPv6Types ClassifyIPv6Address( const TDesC& aIpv6Address )

    {

    if( aIpv6Address.Length() == 0 ||

        !aIpv6Address.CompareF( KDynamicIpv6Address ) )

        {

        return EIPv6Unspecified;

        }

    else if( !aIpv6Address.CompareF( KKnownIp6NameServer1 ) ||

             !aIpv6Address.CompareF( KKnownIp6NameServer2 ) )

        {

        return EIPv6WellKnown;

        }

    return EIPv6UserDefined;

    }

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

// SetProxyServerNameL

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

//

EXPORT_C TBool SetProxyServerNameL( CCmPluginBaseEng* aThis, 

                                   TUint32 /*aAttribute*/, 

                                   const TAny* aValue )

    {

    const TDesC* proxyServer = (const TDesC*)aValue;

    return aThis->SetProxyServerNameL( *proxyServer );

    }

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

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

// TCmPluginInitParam::TCmPluginInitParam

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

//

TCmPluginInitParam::TCmPluginInitParam( CCmManagerImpl& aCmMgr )

    : iCmMgr( aCmMgr )

    {

    iParentDest = 0;

    iNotused1 = NULL;

    iNotused2 = NULL;

    }

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

// CCmPluginBasePrivate::CCmPluginBasePrivate

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

//

CCmPluginBasePrivate::CCmPluginBasePrivate()

    : iNamingMethod( ENamingUnique )

    , iCommonConvTblArray( KDefAttrsArrayGranSize )

    {

    }

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

// CCmPluginBasePrivate::~CCmPluginBasePrivate

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

//

CCmPluginBasePrivate::~CCmPluginBasePrivate()

    {

    delete iWapAPRecord;

    delete iWapIPBearerRecord;

    delete iMetaDataRecord;

    if ( iConvTblArray )

        {

        iConvTblArray->ResetAndDestroy();

        delete iConvTblArray;

        }

    iCommonConvTblArray.Reset();

    iCommonConvTblArray.Close();

    }

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

// CCmPluginBaseEng::CCmPluginBaseEng

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

//

EXPORT_C CCmPluginBaseEng::CCmPluginBaseEng( TCmPluginInitParam *aInitParam )

    : iCmMgr( aInitParam->iCmMgr )

    , iParentDest( aInitParam->iParentDest )

    {

    CLOG_CREATE;

    }

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

// CCmPluginBaseEng::~CCmPluginBaseEng

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

//

EXPORT_C CCmPluginBaseEng::~CCmPluginBaseEng()

    {

    Reset();

    delete iPriv;

    REComSession::DestroyedImplementation( iDtor_ID_Key );

    CLOG_CLOSE;

    }

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

// CCmPluginBaseEng::ConstructL

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

//

EXPORT_C void CCmPluginBaseEng::ConstructL()

    {

    LOGGER_ENTERFN( "CCmPluginBaseEng::ConstructL" );

    iPriv = new (ELeave) CCmPluginBasePrivate;

    // 4 for our tables + 4 for bearer specific ones.

    iPriv->iConvTblArray = new (ELeave)CArrayPtrFlat<TCmAttrConvArrayItem>( 8 );

    AddConverstionTableL( (CCDRecordBase**)&iIapRecord, 

                          NULL, SIapConvTbl );

    AddConverstionTableL( (CCDRecordBase**)&iProxyRecord, 

                          NULL, SProxyConvTbl );

    AddConverstionTableL( (CCDRecordBase**)&iChargeCardRecord, 

                          &iChargeCardEnabled, SChargeCardConvTbl );

    AddConverstionTableL( (CCDRecordBase**)&iLocationRecord, 

                          &iLocationEnabled, SLocationConvTbl );

    AddConverstionTableL( (CCDRecordBase**)&iPriv->iWapIPBearerRecord, 

                          NULL, SWapConvTbl );

    }

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

// CCmPluginBaseEng::GetIntAttributeL

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

//

EXPORT_C TUint32 

            CCmPluginBaseEng::GetIntAttributeL( const TUint32 aAttribute ) const

    {

    LOGGER_ENTERFN( "CCmPluginBaseEng::GetIntAttributeL" );

    TUint32 retVal( 0 );

    switch ( aAttribute )

        {

        case ECmBearerIcon:

            {

            retVal = 0; // bearer doesn't provide any icon

            }

            break;

        case ECmBearerAvailableIcon:            

            {

            retVal = 0; // bearer doesn't provide any icon

            }

            break;

        case ECmId: // if the CM has an IapId than the ECmId is the ECmId

        case ECmIapId:

            {

            retVal = iIapId;

            }

            break;

        case ECmWapId:

            {

            retVal = iPriv->iWapIPBearerRecord->iWAPAccessPointId;

            }

            break;

        case ECmIapServiceId:

            {

            retVal = TUint32(iIapRecord->iService);

            }

            break;

        case ECmBearerType:

            {

            retVal = iBearerType;

            }

            break;

        case ECmDefaultPriority:

            {

            retVal = KDataMobilitySelectionPolicyPriorityWildCard;

            }

            break;

        case ECmDefaultUiPriority:

            {

            retVal = KDataMobilitySelectionPolicyPriorityWildCard;

            }

            break;

        case ECmNamingMethod:

            {

            retVal = iPriv->iNamingMethod;

            }

            break;

        case ECmExtensionLevel:

            {

            retVal = KExtensionBaseLevel;

            }

            break;

        case ECmInvalidAttribute:

            {

            retVal = iInvalidAttribute;

            }

            break;

        case ECmCommsDBBearerType:

            {

            User::Leave( KErrUnknown );

            }

            break;

        case ECmSeamlessnessLevel:

            {

            retVal = iPriv->iMetaDataRecord->iSeamlessness;

            }

            break;

        case ECmElementID:

            {

            if ( !iIapRecord )

                {

                User::Leave( KErrNotReady );

                }

            retVal = (KCDMaskShowField & iIapRecord->ElementId());

            }

            break;

        case ECmLoadResult:

            {

            retVal = iPriv->iLoadResult;

            }

            break;