/*
* 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:   Class CCatalogsAccessPointManager implementation
*
*/


#include "catalogsaccesspointmanagerimpl.h"

#include <ApUtils.h>
#include <ApSelect.h> 
#include <ApDataHandler.h>
#include <badesca.h>

#include "catalogsaccesspoint.h"
#include "catalogsaccesspointsettings.h"
#include "catalogsaccesspointmap.h"
#include "catalogsclientaccesspointdata.h"
#include "ncdstorage.h"
#include "ncdstoragemanager.h"
#include "ncdproviderdefines.h"
#include "ncdstorageitem.h"
#include "ncddatabasestorage.h"
#include "ncd_cp_detail.h"
#include "ncd_cp_clientconfiguration.h"
#include "ncdprotocolutils.h"
#include "ncdnodeidentifier.h"
#include "ncdnodeimpl.h"
#include "ncdnodelink.h"
#include "ncdproviderdefines.h"
#include "ncdnodeidentifiereditor.h"
#include "ncdsearchnodefolder.h"
#include "ncdutils.h"
#include "ncdgeneralmanager.h"
#include "catalogshttpsessionmanagerimpl.h"
#include "catalogsnetworkmanager.h"
#include "catalogsremoveaccesspointshutdownoperation.h"
#include "catalogsclientserverserver.h"

#include "catalogsdebug.h"

// literals used in client configuration protocol
_LIT(KAccessPoints, "accessPoints");
_LIT(KContentSources, "contentSources");
_LIT(KNamespace, "namespace");
_LIT(KId, "id");
_LIT(KCatalogBundle, "catalogBundle");
_LIT(KSubCatalogs, "subCatalogs");
_LIT(KDownloadAccessPoint, "downloadingAccessPoint");
_LIT(KBrowseAccessPoint, "browsingAccessPoint");
_LIT(KPurchaseAccessPoint, "purchasingAccessPoint");

// literals used for access point settings in client configuration protocol (in alphabetical order)
_LIT(KApName, "name");


_LIT(KApCdmaDisablePlainTextAuth, "EApCdmaDisablePlainTextAuth");
_LIT(KApCdmaIfAuthName, "EApCdmaIfAuthName");
_LIT(KApCdmaIfAuthPassword, "EApCdmaIfAuthPassword");
_LIT(KApCdmaIfName, "EApCdmaIfName");
_LIT(KApCdmaIfNetworks, "EApCdmaIfNetworks");
_LIT(KApCdmaIpAddr, "EApCdmaIpAddr");
_LIT(KApCdmaIpAddrFromServer, "EApCdmaIpAddrFromServer");
_LIT(KApCdmaIpDnsAddrFromServer, "EApCdmaIpDnsAddrFromServer");
_LIT(KApCdmaIpGateway, "EApCdmaIpGateway");
_LIT(KApCdmaIPNameServer1, "EApCdmaIPNameServer1");
_LIT(KApCdmaIPNameServer2, "EApCdmaIPNameServer2");
_LIT(KApCdmaIpNetMask, "EApCdmaIpNetMask");
_LIT(KApGprsAccessPointName, "EApGprsAccessPointName");
_LIT(KApGprsDisablePlainTextAuth, "EApGprsDisablePlainTextAuth");
_LIT(KApGprsIfAuthName, "EApGprsIfAuthName");
_LIT(KApGprsIfAuthPassword, "EApGprsIfAuthPassword");
_LIT(KApGprsIfName, "EApGprsIfName");
_LIT(KApGprsIfNetworks, "EApGprsIfNetworks");
_LIT(KApGprsIfParams, "EApGprsIfParams");
_LIT(KApGprsIfPromptForAuth, "EApGprsIfPromptForAuth");
_LIT(KApGprsIpAddr, "EApGprsIpAddr");
_LIT(KApGprsIpAddrFromServer, "EApGprsIpAddrFromServer");
_LIT(KApGprsIpDnsAddrFromServer, "EApGprsIpDnsAddrFromServer");
_LIT(KApGprsIpGateway, "EApGprsIpGateway");
_LIT(KApGprsIPNameServer1, "EApGprsIPNameServer1");
_LIT(KApGprsIPNameServer2, "EApGprsIPNameServer2");
_LIT(KApGprsIpNetMask, "EApGprsIpNetMask");
_LIT(KApGprsPdpAddress, "EApGprsPdpAddress");
_LIT(KApHasProxySettings, "EApHasProxySettings");
_LIT(KApIapChargecard, "EApIapChargecard");
_LIT(KApIapName, "EApIapName");
_LIT(KApIapServiceId, "EApIapServiceId");
_LIT(KApIapServiceType, "EApIapServiceType");
_LIT(KApIP6NameServer1, "EApIP6NameServer1");
_LIT(KApIP6NameServer2, "EApIP6NameServer2");
_LIT(KApIspDefaultTelNumber, "EApIspDefaultTelNumber");
_LIT(KApIspDescription, "EApIspDescription");
_LIT(KApIspDisablePlainTextAuth, "EApIspDisablePlainTextAuth");
_LIT(KApIspIfAuthName, "EApIspIfAuthName");
_LIT(KApIspIfAuthPass, "EApIspIfAuthPass");
_LIT(KApIspIfCallbackInfo, "EApIspIfCallbackInfo");
_LIT(KApIspIfName, "EApIspIfName");
_LIT(KApIspIfNetworks, "EApIspIfNetworks");
_LIT(KApIspIfParams, "EApIspIfParams");
_LIT(KApIspInitString, "EApIspInitString");
_LIT(KApIspIPAddr, "EApIspIPAddr");
_LIT(KApIspIPAddrFromServer, "EApIspIPAddrFromServer");
_LIT(KApIspIPDnsAddrFromServer, "EApIspIPDnsAddrFromServer");
_LIT(KApIspIPGateway, "EApIspIPGateway");
_LIT(KApIspIPNameServer1, "EApIspIPNameServer1");
_LIT(KApIspIPNameServer2, "EApIspIPNameServer2");
_LIT(KApIspIPNetMask, "EApIspIPNetMask");
_LIT(KApIspIspType, "EApIspIspType");
_LIT(KApIspLoginName, "EApIspLoginName");
_LIT(KApIspLoginPass, "EApIspLoginPass");
_LIT(KApIspLoginScript, "EApIspLoginScript");
_LIT(KApIspName, "EApIspName");
_LIT(KApLanBearerName, "EApLanBearerName");
_LIT(KApNetworkName, " EApNetworkName");
_LIT(KApProxyExceptions, "EApProxyExceptions");
_LIT(KApProxyLoginName, "EApProxyLoginName");
_LIT(KApProxyLoginPass, "EApProxyLoginPass");
_LIT(KApProxyPortNumber, "EApProxyPortNumber");
_LIT(KApProxyProtocolName, "EApProxyProtocolName");
_LIT(KApProxyServerAddress, "EApProxyServerAddress");
_LIT(KApProxyUseProxy, "EApProxyUseProxy");
_LIT(KApWapAccessPointName, "EApWapAccessPointName");
_LIT(KApWapCurrentBearer, "EApWapCurrentBearer");
_LIT(KApWapGatewayAddress, "EApWapGatewayAddress");
_LIT(KApWapIap, "EApWapIap");
_LIT(KApWapProxyPort, "EApWapProxyPort");
_LIT(KApWapSecurity, "EApWapSecurity");
_LIT(KApWapStartPage, "EApWapStartPage");
_LIT(KApWapWspOption, "EApWapWspOption");
_LIT(KApWlanIfAuthName, "EApWlanIfAuthName");
_LIT(KApWlanIfAuthPassword, "EApWlanIfAuthPassword");
_LIT(KApWlanIfNetworks, "EApWlanIfNetworks");
_LIT(KApWlanIpAddr, "EApWlanIpAddr");
_LIT(KApWlanIpAddrFromServer, "EApWlanIpAddrFromServer");
_LIT(KApWlanIpDnsAddrFromServer, "EApWlanIpDnsAddrFromServer");
_LIT(KApWlanIpGateway, "EApWlanIpGateway");
_LIT(KApWlanIPNameServer1, "EApWlanIPNameServer1");
_LIT(KApWlanIPNameServer2, "EApWlanIPNameServer2");
_LIT(KApWlanIpNetMask, "EApWlanIpNetMask");

_LIT(KWapWspOptionConnectionless, "EWapWspOptionConnectionless");
_LIT(KWapWspOptionConnectionOriented, "EWapWspOptionConnectionOriented");


CCatalogsAccessPointManager::CCatalogsAccessPointManager(
    CNcdGeneralManager& aGeneralManager ) :
    iGeneralManager( aGeneralManager ),
    iStorageManager( aGeneralManager.StorageManager() ), 
    iNodeManager( aGeneralManager.NodeManager() ),
    iCheckAp( ETrue )
    {
    }
    
CCatalogsAccessPointManager::~CCatalogsAccessPointManager()
    {
    DLTRACEIN((""));    

    TRAP_IGNORE( DestructL() );

    delete iClientAccessPointData;
    delete iFixedAp;
    }
    
CCatalogsAccessPointManager* CCatalogsAccessPointManager::NewL(
    CNcdGeneralManager& aGeneralManager )
    {
    CCatalogsAccessPointManager* apMan = 
        new (ELeave) CCatalogsAccessPointManager( aGeneralManager );
    CleanupStack::PushL( apMan );
    apMan->ConstructL();
    CleanupStack::Pop( apMan );
    return apMan;
    }
    
void CCatalogsAccessPointManager::ConstructL()
    {
    DLTRACEIN((""));
    CCatalogsHttpSessionManager::NetworkManagerL().AddObserverL( *this );
    }

void CCatalogsAccessPointManager::SetFixedApL(
    const RPointerArray<CNcdKeyValuePair>& aApDetails ) 
    {
    DLTRACEIN((""));
    DASSERT( !iFixedAp );
    
    // Create CCatalogsAccessPoint object and set the details to it.
    CCatalogsAccessPoint* ap = CCatalogsAccessPoint::NewLC( KNullDesC, KNullDesC );
    TInt detailCount = aApDetails.Count();
    for ( TInt i = 0; i < detailCount; i++ ) 
        {
        CNcdKeyValuePair* detail = aApDetails[ i ];
        SetApDetailL( *ap, detail->Key(), detail->Value() );
        }


    if ( !ap->Name().Length() ) 
        {
        DLERROR(("No accesspoint name given"));
        User::Leave( KErrArgument );
        }
        
    CreateAccessPointL( *ap );
    iFixedAp = ap;
    CleanupStack::Pop( ap );
    }


void CCatalogsAccessPointManager::GetFixedApL( TUint32& aAccessPointId )
    {
    DLTRACEIN((""));
    if ( iFixedAp ) 
        {
        // We need to check that the AP in Commsdb matches wanted settings
        if ( iCheckAp ) 
            {
            DLTRACE(("Checking AP"));
            // iCheckAp is set to EFalse in HandleAccessPointEventL 
            // when an AP has been raised

            // Only parameter that matters here is aAccessPointId
            AccessPointIdL( 
                KNullDesC,
                EBrowse,
                TUid(),
                aAccessPointId );
            }
        else
            {            
            aAccessPointId = iFixedAp->AccessPointId();
            DLTRACE(("AP ID: %u", aAccessPointId ));
            }
        }
    }
    

void CCatalogsAccessPointManager::ParseAccessPointDataFromClientConfL(
    const MNcdConfigurationProtocolClientConfiguration& aConfiguration,
    const TUid& /*aClientUid*/,
    TBool aIgnoreFixedAp, 
    RArray<TUint32>* aCreatedAps ) 
    {
    DLTRACEIN(("Starting to parse access point data from client configuration"));    
    
    if ( iFixedAp && !aIgnoreFixedAp ) 
        {
        DLINFO(("Fixed AP used, no need to parse AP data"));
        return;
        }
    
    for( TInt i = 0 ; i < aConfiguration.DetailCount() ; i++ )
        {
        const MNcdConfigurationProtocolDetail& detail = aConfiguration.DetailL( i );
        if (detail.Id() == KAccessPoints) 
            {
            // parse access point details
            CreateAccessPointsFromClientConfL( detail, aCreatedAps );
            }
        else if (detail.Id() == KContentSources) 
            {
            const RPointerArray<MNcdConfigurationProtocolDetail>& csDetails = detail.Details();
            for (TInt i = 0; i < csDetails.Count(); i++) 
                {
                MNcdConfigurationProtocolDetail* csDetail = csDetails[i];
                
                if (csDetail->GroupId() == KNullDesC && csDetail->Id() == KNamespace)
                    {
                    const TDesC& nameSpace = csDetail->Value();
                    const TDesC* id = NULL;
                    const RPointerArray<MNcdConfigurationProtocolContent>& nsContents = 
                        csDetail->Contents();
                    for (TInt i = 0; i < nsContents.Count(); i++) 
                        {
                        MNcdConfigurationProtocolContent* content = nsContents[i];
                        if (content->Key() == KId) 
                            {
                            id = &content->Value();
                            break;
                            }
                        }
                                        
                    const RPointerArray<MNcdConfigurationProtocolDetail>& nsDetails = csDetail->Details();                

                    if (nsDetails.Count() > 0) 
                        {
                        MNcdConfigurationProtocolDetail* uriDetail = nsDetails[0];
                        const RPointerArray<MNcdConfigurationProtocolDetail>& apDetails = uriDetail->Details();
                        
                        for (TInt i = 0; i < apDetails.Count(); i++) 
                            {
                            MNcdConfigurationProtocolDetail* apDetail = apDetails[i];
                            const TDesC& accessPointId = apDetail->Value();
                            MCatalogsAccessPointManager::TAction action;
                            TBool unknown = EFalse;
                            if (apDetail->Id() == KDownloadAccessPoint)
                                {
                                action = MCatalogsAccessPointManager::EDownload;
                                }
                            else if (apDetail->Id() == KBrowseAccessPoint) 
                                {
                                action = MCatalogsAccessPointManager::EBrowse;
                                }
                            else if (apDetail->Id() == KPurchaseAccessPoint) 
                                {
                                action = MCatalogsAccessPointManager::EPurchase;
                                }
                            else 
                                {
                                DLWARNING((_L("Unknown detail id: %S"),&apDetail->Id()));
                                unknown = ETrue;
                                }
                                
                            if (!unknown && id) 
                                {
                                MapAccessPointL(
                                    nameSpace, *id, action, accessPointId );
                                }
                            else if (!unknown) 
                                {
                                MapAccessPointL(
                                    nameSpace, action, accessPointId );
                                }
                            }
                        }
                    }
                    
                else if (csDetail->GroupId() == KCatalogBundle) 
                    {
                    const RPointerArray<MNcdConfigurationProtocolDetail>& bundleDetails =
                        csDetail->Details();
                    for (TInt i = 0; i < bundleDetails.Count(); i++) 
                        {
                        MNcdConfigurationProtocolDetail* bundleDetail = bundleDetails[i];
                        if (bundleDetail->GroupId() != KSubCatalogs) 
                            {
                            continue;
                            }
                            
                        // find the subcatalog ID
                        const TDesC* id = NULL;
                        const RPointerArray<MNcdConfigurationProtocolContent>& subCatalogContents =
                            bundleDetail->Contents();
                        for (TInt i = 0; i < subCatalogContents.Count(); i++) 
                            {
                            if (subCatalogContents[i]->Key() == KId) 
                                {
                                id = &subCatalogContents[i]->Value();
                                break;
                                }
                            }
                                
                        const TDesC& nameSpace = bundleDetail->Value();
                        const RPointerArray<MNcdConfigurationProtocolDetail>& subCatalogDetails =
                            bundleDetail->Details();
                        if (subCatalogDetails.Count() > 0) 
                            {
                            MNcdConfigurationProtocolDetail* scDetail = subCatalogDetails[0];
                            const RPointerArray<MNcdConfigurationProtocolDetail>& apDetails =
                                scDetail->Details();
                            for (TInt i = 0; i < apDetails.Count(); i++) 
                                {
                                MNcdConfigurationProtocolDetail* apDetail = apDetails[i];
                                const TDesC& accessPointId = apDetail->Value();
                                MCatalogsAccessPointManager::TAction action;
                                TBool unknown = EFalse;
                                if (apDetail->Id() == KDownloadAccessPoint) 
                                    {
                                    action = EDownload;
                                    }
                                else if (apDetail->Id() == KBrowseAccessPoint) 
                                    {
                                    action = EBrowse;
                                    }
                                else if (apDetail->Id() == KPurchaseAccessPoint) 
                                    {
                                    action = EPurchase;
                                    }
                                else 
                                    {
                                    DLWARNING((_L("Unknown detail id: %S"), &apDetail->Id()));
                                    unknown = ETrue;
                                    }
                                
                                if (!unknown && id) 
                                    {
                                    MapAccessPointL(
                                        nameSpace, *id, action, accessPointId );
                                    }
                                else if (!unknown) 
                                    {
                                    MapAccessPointL(
                                        nameSpace, action, accessPointId );
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    SaveToStorageL();
    DLTRACEOUT(("Access point data from client configuration parsed"));
    }            

    
void CCatalogsAccessPointManager::CreateAccessPointsFromClientConfL(
    const MNcdConfigurationProtocolDetail& aDetail,     
    RArray<TUint32>* aCreatedAps ) 
    {
    DLTRACEIN(("Creating access points from client configuration"));
    const RPointerArray<MNcdConfigurationProtocolDetail>& apDetails = aDetail.Details();
    TInt apCount = apDetails.Count();
    
    for (TInt i = 0; i < apCount; i++) 
        {
        MNcdConfigurationProtocolDetail* apDetail = apDetails[i];
        CCatalogsAccessPoint* ap = CCatalogsAccessPoint::NewLC(apDetail->Id(), KNullDesC);
            
        const RPointerArray<MNcdConfigurationProtocolContent>& apContents = 
            apDetail->Contents();
        TInt contentCount = apContents.Count();
        for (TInt i = 0; i < contentCount; i++) 
            {
            MNcdConfigurationProtocolContent* content = apContents[i];
            SetApDetailL( *ap, content->Key(), content->Value() );
            }
        CreateAccessPointL( ap );
        CleanupStack::Pop( ap );
        
        if ( aCreatedAps ) 
            {
            DLTRACE(("Adding accesspoint id to aCreatedAps"));
            aCreatedAps->AppendL( ap->AccessPointId() );
            }
            
        }
    DLTRACEOUT(("Access points created from client configuration"));
    }


void CCatalogsAccessPointManager::CreateAccessPointL(
    CCatalogsAccessPoint* aSettings  )
    {
    CreateAccessPointL( *aSettings );        
    
    if ( !iClientAccessPointData ) 
        {
        iClientAccessPointData = CCatalogsClientAccessPointData::NewL();        
        }        

    iClientAccessPointData->AddAccessPointL( aSettings );
    }
    
void CCatalogsAccessPointManager::CreateAccessPointL( CCatalogsAccessPoint& aSettings )
    {
    DLTRACEIN(("Creating access point"));

    // Check if comms database already have access point with suitable settings.
    TUint32 iapId = 0;        
    if( MatchInCommsDbL( aSettings, iapId ) )
        {
        DLTRACE(("Matching AP found from comms DB, access point id: %d", iapId));
        // There is no need to create own access point settings to the comms database.
        aSettings.SetAccessPointId( iapId );
        }
        
    // Create new access point to the comms database
    else
        {
        DLTRACE(_L("Mathing AP not found from comms DB, creating new one"));
        CreateApToCommsDBL( aSettings, iapId );
        aSettings.SetAccessPointId( iapId );     
        // Mark this access point for deletition at the manager's destructor.
        // Fix for [#PRECLI-1596].
        aSettings.SetCreatedByManager();
        DLTRACE(("Created access point: %d", iapId));
        }
    DLTRACEOUT(("Access point created"));
    }    
    
    
void CCatalogsAccessPointManager::MapAccessPointL(
    const TDesC& aNameSpace,
    const CCatalogsAccessPointManager::TAction& aType,
    const TDesC& aApId ) 
    {
    DLTRACEIN((_L("Namespace: %S, Action: %d, access point id: %S "),
               &aNameSpace, aType, &aApId ));

    if ( !iClientAccessPointData ) 
        {
        iClientAccessPointData = CCatalogsClientAccessPointData::NewL();
        }
        
    iClientAccessPointData->MapAccessPointL( aNameSpace, aType, aApId );
    
    DLTRACEOUT((""));
    }

    
void CCatalogsAccessPointManager::MapAccessPointL(
    const TDesC& aNameSpace,
    const TDesC& aCatalogId,
    const CCatalogsAccessPointManager::TAction& aAction,
    const TDesC& aApId ) 
    {
    DLTRACEIN((_L("Namespace: %S, CatalogId: %S, Action: %d, access point id: %S"),
               &aNameSpace, &aCatalogId, aAction, &aApId ));
    
    if ( !iClientAccessPointData ) 
        {
        iClientAccessPointData = CCatalogsClientAccessPointData::NewL();
        }
        
    iClientAccessPointData->MapAccessPointL(
        aNameSpace, aCatalogId, aAction, aApId );
    DLTRACEOUT((""));
    }

    
TInt CCatalogsAccessPointManager::AccessPointIdL(
    const TDesC& aNameSpace,
    const MCatalogsAccessPointManager::TAction& aAction,
    const TUid& aClientUid,
    TUint32& aAccessPointId ) 
    {
    DLTRACEIN((_L("Namespace: %S, Action: %d, clientUid: %d"), &aNameSpace, aAction, aClientUid.iUid));
    
    CCatalogsAccessPoint* accessPoint( NULL );
    CCatalogsClientAccessPointData* apData( NULL );
    TInt err = GetAccessPoint( accessPoint, apData );
    if ( err != KErrNone ) 
        {
        DLERROR(("Error: %d", err));
        return err;
        }

    if ( !accessPoint )
        {
        DASSERT( apData );
        accessPoint = apData->AccessPoint( aNameSpace, aAction );
        }

    return ValidateOrCreateAccessPointL( accessPoint, aAccessPointId );
    }
    

TInt CCatalogsAccessPointManager::AccessPointIdL(
    const TDesC& aNameSpace,
    const TDesC& aCatalogId,
    const MCatalogsAccessPointManager::TAction& aAction,
    const TUid& aClientUid,
    TUint32& aAccessPointId) 
    {
    DLTRACEIN((_L("Namespace: %S, CatalogId: %S, Action: %d, clientUid: %d"), &aNameSpace, &aCatalogId, aAction, aClientUid.iUid));
    CCatalogsAccessPoint* accessPoint( NULL );
    CCatalogsClientAccessPointData* apData( NULL );
    TInt err = GetAccessPoint( accessPoint, apData );
    if ( err != KErrNone ) 
        {
        DLERROR(("Error: %d", err));
        return err;
        }

    if ( !accessPoint )
        {
        DASSERT( apData );
        accessPoint = apData->AccessPointL( aNameSpace, aCatalogId, aAction );
        }

    return ValidateOrCreateAccessPointL( accessPoint, aAccessPointId );
    }


TInt CCatalogsAccessPointManager::AccessPointIdL(
    const CNcdNodeIdentifier& aNodeIdentifier,
    const MCatalogsAccessPointManager::TAction& aAction,
    const TUid& aClientUid,
    TUint32& aAccessPointId) 
    {
    DLTRACEIN((_L("Namespace: %S, NodeId: %S, Action: %d, clientUid: %d"),
               &aNodeIdentifier.NodeNameSpace(), &aNodeIdentifier.NodeId(), aAction,
               aClientUid.iUid));

    CCatalogsAccessPoint* accessPoint( NULL );
    CCatalogsClientAccessPointData* apData( NULL );
    TInt err = GetAccessPoint( accessPoint, apData );
    if ( err != KErrNone ) 
        {
        DLERROR(("Error: %d", err));
        return err;
        }

    if ( !accessPoint )
        {
        DASSERT( apData );
        accessPoint = FindAccessPointL(
            aNodeIdentifier, aAction, *apData );
        }

    return ValidateOrCreateAccessPointL( accessPoint, aAccessPointId );
    }


void CCatalogsAccessPointManager::HandleAccessPointEventL( 
    const TCatalogsConnectionMethod& /* aAp */,
    const TCatalogsAccessPointEvent& aEvent )
    {
    DLTRACEIN((""));

    if ( aEvent == ECatalogsAccessPointClosed ||
         aEvent == ECatalogsAccessPointReallyClosed ) 
        {
        DLTRACE(("Ap closed, need to check it when connecting"));
        // Connection has been closed, we want to ensure
        // that we use the correct AP settings even if
        // someone tampers with the existing AP
        iCheckAp = ETrue;
        }
    else
        {
        iCheckAp = EFalse;
        }
    }

    
CCatalogsAccessPoint* CCatalogsAccessPointManager::FindAccessPointL(
    const CNcdNodeIdentifier& aNodeIdentifier,
    const MCatalogsAccessPointManager::TAction& aAction,
    const CCatalogsClientAccessPointData& aAccessPointData ) 
    {
    DLTRACEIN((""));
    CCatalogsAccessPoint* accessPoint = NULL;
    const CNcdNodeIdentifier* nodeIdentifier = &aNodeIdentifier;
    
    if( NcdNodeIdentifierEditor::IdentifiesSearchNodeL( *nodeIdentifier ) )
        {
        // Search node, retrieve origin identifier.
        // Requesting ap for a search node so node should always exist and
        // it's safe to ask it from nodemanager.
        CNcdNode& node = iNodeManager.NodeL( *nodeIdentifier );
        //const CNcdNodeIdentifier* originIdentifier = NULL;
        if( node.ClassId() == NcdNodeClassIds::ENcdSearchItemNodeClassId )
            {
            // get the parent folder's origin identifier
            nodeIdentifier = 
                &iNodeManager.SearchFolderL( node.NodeLinkL().ParentIdentifier() )
                    .OriginIdentifierL();
            }
        else if( node.ClassId() == NcdNodeClassIds::ENcdSearchFolderNodeClassId )
            {
            nodeIdentifier =
                &(static_cast<CNcdSearchNodeFolder&>(node).OriginIdentifierL());
            }
        else
            {
            // search root or search budle, no origin identifier available
            return NULL;
            }
        }
    
    if ( nodeIdentifier->NodeId() == KNullDesC ) 
        {
        accessPoint = aAccessPointData.AccessPoint(
            nodeIdentifier->NodeNameSpace(), aAction );
        }
    else 
        {
        accessPoint = aAccessPointData.AccessPointL(
            nodeIdentifier->NodeNameSpace(), nodeIdentifier->NodeId(), aAction );
        }
        
    if ( !accessPoint &&
         nodeIdentifier->NodeNameSpace() != NcdProviderDefines::KRootNodeNameSpace &&
         !NcdNodeIdentifierEditor::IdentifiesTemporaryNodeL( *nodeIdentifier ) )
        {
        
        // Get parent identifier from child identifier.
        // NOTE: Parent is not required to exist in cache/db for this to work.
        CNcdNodeIdentifier* parentIdentifier = NcdNodeIdentifierEditor::ParentOfLC( *nodeIdentifier );
        
        if ( parentIdentifier->NodeNameSpace() == NcdProviderDefines::KRootNodeNameSpace )
            {
            // already at root node
            CleanupStack::PopAndDestroy( parentIdentifier );
            return NULL;
            }        
        // Partial fix for PRECLI-1321
        // This prevents missing parents from causing unwanted leaves
        else if ( !parentIdentifier->ContainsEmptyFields() )
            {
            accessPoint = FindAccessPointL( *parentIdentifier, aAction, aAccessPointData );
            }
        CleanupStack::PopAndDestroy( parentIdentifier );
        return accessPoint;
        }

    return accessPoint;
    }
            
    
TBool CCatalogsAccessPointManager::ValidateAccessPointL( CCatalogsAccessPoint* aAccessPoint )
    {
    DLTRACEIN((""));
#ifdef __WINS__
    // Comms database is not accessible in emulator.
    return EFalse;
#endif
    CCommsDatabase *commdb = CCommsDatabase::NewL( /*EDatabaseTypeIAP*/ );
    CleanupStack::PushL( commdb );
    CApSelect*  select;
    select = CApSelect::NewLC(
        *commdb,
        KEApIspTypeAll,
        EApBearerTypeAll,
        KEApSortUidAscending
        );
    
    CApDataHandler*     handler = CApDataHandler::NewLC( *commdb );        
    CApUtils* util = CApUtils::NewLC( *commdb );
    
    // Loop through array and try to find the right access point. 
    // After access point is found check that its parameters are still right.
    // If they aren't we have to create a new access point.
    TBool success = select->MoveToFirst();
    while (success)
        {
        TUint32 wapId = 0;
        TRAPD( err, wapId = util->WapIdFromIapIdL( aAccessPoint->AccessPointId() ) )
        if( err != KErrNone )
            {
            // AccessPoint has propably been removed from the commsdatabase.
            CleanupStack::PopAndDestroy( 4 );
            return EFalse;            
            }
        
        if( select->Uid() != wapId )
            {
            // This is not the right access point, proceed to the next one.
            success = select->MoveNext();                
            continue;
            }
        
        CApAccessPointItem* item = CApAccessPointItem::NewLC();
        handler->AccessPointDataL( select->Uid(), *item );
     
        // Check all the setting are similar in commsDb and in CCatalogsAccessPoint.
        TBool matching = MatchingSettingsL(*aAccessPoint, *item);
                   
        CleanupStack::PopAndDestroy(5);
        return matching;        
        }        
            
    // Someone has altered the access point settings.
    CleanupStack::PopAndDestroy(4);
    return EFalse;
    }

TBool CCatalogsAccessPointManager::MatchInCommsDbL( const CCatalogsAccessPointSettings& aSettings, TUint32& aId )
    {
    DLTRACEIN(_L("Checking comms DB for matching access point"));
#ifdef __WINS__
    // Comms database is not accessible in emulator.
    return EFalse;
#endif
    
    CCommsDatabase *commdb = CCommsDatabase::NewL( /*EDatabaseTypeIAP*/ );
    CleanupStack::PushL( commdb );
    CApSelect*  select;
    select = CApSelect::NewLC(
        *commdb,
        KEApIspTypeAll,
        EApBearerTypeAll,
        KEApSortUidAscending
        );
    
    CApDataHandler*     handler = CApDataHandler::NewLC( *commdb );        
    CApUtils* util = CApUtils::NewLC( *commdb );
    
    // Loop through array and check if there already exists an access poinst which settings
    // are suitable.
    TBool success = select->MoveToFirst();
    while ( success )
        {
        CApAccessPointItem* item = CApAccessPointItem::NewLC();
        DLTRACE(("Loading access point data from comms DB"));
        handler->AccessPointDataL( select->Uid(), *item );

        DLTRACE(("Access point data loaded from comms DB"));        
        TBool matching = MatchingSettingsL(aSettings, *item);
        if ( !matching ) 
            {
            success = select->MoveNext();
            CleanupStack::PopAndDestroy(); // item
            continue;
            }       
            
        // We have a match in all fields.
        aId = util->IapIdFromWapIdL( select->Uid() );            
        CleanupStack::PopAndDestroy( 5, commdb ); // item, util, handler, select, commdb
        DLTRACEOUT(("Matching AP found"));
        return ETrue;
        }        
        
    CleanupStack::PopAndDestroy( 4, commdb ); // util, handler, select, commdb
    DLTRACEOUT(("Matching AP not found"));
    return EFalse;
    }

void CCatalogsAccessPointManager::CreateApToCommsDBL( const CCatalogsAccessPoint& aSettings, TUint32& aId )
    {
    DLTRACEIN(_L("Creating AP to comms DB"));
#ifdef __WINS__
    // Comms database is not accessible in emulator.
    return;
#endif
    CCommsDatabase *commdb = CCommsDatabase::NewL( /*EDatabaseTypeIAP*/ );
    CleanupStack::PushL( commdb );
    
    CApDataHandler*     handler = CApDataHandler::NewLC( *commdb );        
    CApAccessPointItem* newAp = CApAccessPointItem::NewLC();

    newAp->SetNamesL( aSettings.Name() );
    
    // write the settings to newAp
    TInt longTextCount = aSettings.LongTextParameterCount();
    for (TInt i = 0; i < longTextCount; i++) 
        {
        TApMember key;
        TPtrC value;
        aSettings.LongTextParameter(i, key, value);
        newAp->WriteLongTextL(key, value);
        }
        
    TInt text16Count = aSettings.Text16ParameterCount();
    for (TInt i = 0; i < text16Count; i++) 
        {
        TApMember key;
        TPtrC16 value;
        aSettings.Text16Parameter(i, key, value);
        newAp->WriteTextL(key, value);
        }
        
    TInt text8Count = aSettings.Text8ParameterCount();
    for (TInt i = 0; i < text8Count; i++) 
        {
        TApMember key;
        TPtrC8 value;
        aSettings.Text8Parameter(i, key, value);
        newAp->WriteTextL(key, value);
        }
         
    TInt uintCount = aSettings.UintParameterCount();
    for (TInt i = 0; i < uintCount; i++) 
        {
        TApMember key;
        TUint32 value;
        aSettings.UintParameter(i, key, value);
        newAp->WriteUint(key, value);
        }
        
    TInt boolCount = aSettings.BoolParameterCount();
    for (TInt i = 0; i < boolCount; i++) 
        {
        TApMember key;
        TBool value;
        aSettings.BoolParameter(i, key, value);
        newAp->WriteBool(key, value);
        }            
    
    if( !newAp->SanityCheckOk() )
        {
        User::Leave( KErrArgument );
        }
        
    TUint32 wapId = 0;
    TRAPD( err, wapId = handler->CreateFromDataL( *newAp ) );
    if (err != KErrNone) 
        {
        DLERROR(("Unable to create access point to comms DB"));
        User::Leave(err);
        }

    CApUtils* util = CApUtils::NewLC( *commdb );
    aId = util->IapIdFromWapIdL( wapId );
    CleanupStack::PopAndDestroy( 4, commdb ); // commDb, handler, newAp, util
    DLTRACEOUT(("Access point created to comms DB"));
    }

HBufC16* CCatalogsAccessPointManager::ReadText16L( CApAccessPointItem* aItem, const TApMember& aApMember )
    {
    TInt length = aItem->ReadTextLengthL( aApMember );
    if( length == 0 )
        {
        return KNullDesC16().AllocL();
        }
    HBufC16* buffer = HBufC16::NewLC( length );
    TPtr16 ptr( buffer->Des());
    aItem->ReadTextL( aApMember, ptr );
    CleanupStack::Pop(); // buffer
    return buffer;
    }

HBufC8* CCatalogsAccessPointManager::ReadText8L( CApAccessPointItem* aItem, const TApMember& aApMember )
    {
    TInt length = aItem->ReadTextLengthL( aApMember );
    if( length == 0 )
        {
        return KNullDesC8().AllocL();
        }
    HBufC8* buffer = HBufC8::NewLC( length );
    TPtr8 ptr( buffer->Des());
    aItem->ReadTextL( aApMember, ptr );
    CleanupStack::Pop(); // buffer
    return buffer;
    }


void CCatalogsAccessPointManager::RemoveAccessPointsFromCommsDbL(
    TBool aAddShutdownOperation )
    {
    
    if ( !iClientAccessPointData ) 
        {
        return;
        }
    TInt apCount = iClientAccessPointData->AccessPointCount();
    
    // remove the access points from comms db
    for ( TInt i = 0; i < apCount; i++ ) 
        {      
        // remove access point only if it has been created by the manager
        // Fix for [#PRECLI-1596]
        if ( iClientAccessPointData->AccessPoint( i ).CreatedByManager() )
        	{
        	TUint32 idInCommsDb = 
        	    iClientAccessPointData->AccessPoint( i ).AccessPointId();
        	TRAPD( err, RemoveApFromCommsDatabaseL( idInCommsDb ) );
        	        	
        	if ( err != KErrNone &&
        	     err != KErrNotFound &&
        	     err != KErrNoMemory &&
        	     aAddShutdownOperation )
        	    {
        	    CCatalogsRemoveAccesspointShutdownOperation* op =
        	        CCatalogsRemoveAccesspointShutdownOperation::NewL( 
        	            iGeneralManager.FamilyId(),
        	            idInCommsDb );
        	    // takes ownership, deletes the op if adding fails
        	    CCatalogsClientServerServer::AddShutdownOperation( op );
        	    }
        	// we can ignore other errors
        	else if ( err == KErrNoMemory ) 
        	    {
        	    User::Leave( err );
        	    }
        	}     
        }
    }


void CCatalogsAccessPointManager::RemoveAccessPointsL() 
    {
    // remove from comms db
    RemoveAccessPointsFromCommsDbL( EFalse );
    
    delete iClientAccessPointData;
    iClientAccessPointData = NULL;
    }

void CCatalogsAccessPointManager::RemoveApFromCommsDatabaseL( const TUint32& aId )
    {
    DLTRACEIN(("aId: %u", aId ));
    CCommsDatabase *commdb = CCommsDatabase::NewL( EDatabaseTypeIAP );
    CleanupStack::PushL( commdb );
    CApDataHandler* dataHandler = CApDataHandler::NewLC( *commdb );
    CApUtils* util = CApUtils::NewLC( *commdb );
    TUint32 wapId = util->WapIdFromIapIdL( aId );
    dataHandler->RemoveAPL( wapId );
    
    CleanupStack::PopAndDestroy( 3, commdb ); // util, dataHandler, commdb
    }

    
void CCatalogsAccessPointManager::LoadFromStorageL() 
    {
    // delete clients access point data
    RemoveAccessPointsL();
    
    MNcdStorage& storage = iStorageManager.ProviderStorageL( 
        iGeneralManager.FamilyName() );
    MNcdDatabaseStorage& database = storage.DatabaseStorageL(
        NcdProviderDefines::KDefaultDatabaseUid);  // not sure if this the correct db

    if( !database.ItemExistsInStorageL( iGeneralManager.FamilyName(), 
        NcdProviderDefines::ENcdAccessPointManager ) )
        {
        DLTRACE( ( _L("Data: %S was not in provider storage"), 
                    &iGeneralManager.FamilyName() ) );
        User::Leave( KErrNotFound );            
        }
        
    // Get the storage item from which the access point data is loaded
    // Note: database has the ownership of the item
    MNcdStorageItem* item = database.StorageItemL(
        iGeneralManager.FamilyName(), 
        NcdProviderDefines::ENcdAccessPointManager );    
        
    // Get data from database by using CCatalogsClientAccessPointData as the target so that 
    // internalize will be called for it
    CCatalogsClientAccessPointData* data = CCatalogsClientAccessPointData::NewLC();
    item->SetDataItem(data);
    
    // Read data -> calls CCatalogsClientAccessPointData::InternalizeL
    item->ReadDataL();
    
    iClientAccessPointData = data; 
    CleanupStack::Pop(); //data
    }
    
void CCatalogsAccessPointManager::SaveToStorageL() 
    {    
    if ( !iClientAccessPointData ) 
        {
        return;
        }
    
    MNcdStorage& storage = iStorageManager.ProviderStorageL( 
        iGeneralManager.FamilyName() );
    MNcdDatabaseStorage& database = storage.DatabaseStorageL(
        NcdProviderDefines::KDefaultDatabaseUid);
    
    // Get the storage item to which the access point manager is stored
    // Note: database has the ownership of the item
    MNcdStorageItem* item = database.StorageItemL(
        iGeneralManager.FamilyName(), 
        NcdProviderDefines::ENcdAccessPointManager);
    
    item->SetDataItem( iClientAccessPointData );
    item->OpenL();
    
    // Calls ExternalizeL for this
    item->WriteDataL();
    item->SaveL();    
    }

    
TBool CCatalogsAccessPointManager::MatchingSettingsL(
    const CCatalogsAccessPointSettings& aSettings, CApAccessPointItem& aItem) 
    {
    DLTRACEIN(("Checking for matching AP settings"));

    // Check long text settings.   
    DLTRACE(("Checking long text parameters")); 
    TInt longTextCount = aSettings.LongTextParameterCount();
    for (TInt i = 0; i < longTextCount; i++) 
        {
        TApMember key;
        TPtrC value;
        DLTRACE(("Getting long text param data, i=%d", i));
        aSettings.LongTextParameter(i, key, value);
        DLTRACE(("Reading const long text from CApAccessPointItem, member=%d", key));

        const HBufC* buf = aItem.ReadConstLongTextL(key);
        DLTRACE((""));
        if (*buf != value) 
            {
            // Settings aren't correct.
            DLTRACEOUT(("Not matching settings"));
            return EFalse;
            }
        }
        
    // Check 16-bit text settings.
    DLTRACE(("Checking 16-bit text parameters")); 
    TInt text16Count = aSettings.Text16ParameterCount();
    for (TInt i = 0; i < text16Count; i++) 
        {
        TApMember key;
        TPtrC16 value;
        aSettings.Text16Parameter(i, key, value);
        DLTRACE(( _L("Key: %d, value: %S"), key, &value ));
        
        // CApDataHandler changes all of these if it needs to create a new
        // unique name for an accesspoint when it's created so we ignore
        // them when trying to find a matching AP so that we don't end
        // up creating new APs everytime we check if the correct AP
        // exists
        // See DLEB-179
        // CApAccessPointItem::SetNamesL sets these
        if ( key == EApWapAccessPointName ||
             key == EApIapName ||
             key == EApIspName || 
             key == EApNetworkName )
            {
            DLTRACE(( _L("Skipping name comparison, key: %d, value: %S"), 
                key, &value ));
            continue;
            }
        
        const HBufC16* buf = ReadText16L(&aItem, key);
        if (*buf != value) 
            {
            // Settings aren't correct.
            delete buf;
            DLTRACEOUT(("Not matching settings"));
            return EFalse;
            }
        delete buf;
        }

    // Check 8-bit text settings.
    DLTRACE(("Checking 8-bit text parameters")); 
    TInt text8Count = aSettings.Text8ParameterCount();
    for (TInt i = 0; i < text8Count; i++) 
        {
        TApMember key;
        TPtrC8 value;
        aSettings.Text8Parameter(i, key, value);
        const HBufC8* buf = ReadText8L(&aItem, key);
        if (*buf != value) 
            {
            // Settings aren't correct.
            delete buf;
            DLTRACEOUT(("Not matching settings"));
            return EFalse;
            }
        delete buf;
        }
        
    // Check uint settings.
    DLTRACE(("Checking uint parameters"));    
    TInt uintCount = aSettings.UintParameterCount();
    for (TInt i = 0; i < uintCount; i++) 
        {
        TApMember key;
        TUint32 value;
        aSettings.UintParameter(i, key, value);
        TUint32 dbValue;
        aItem.ReadUint(key, dbValue);
        if (dbValue != value) 
            {
            // Settings aren't correct.
            DLTRACEOUT(("Not matching settings"));
            return EFalse;
            }
        }
    
    // Check bool settings.
    DLTRACE(_L("Checking bool parameters"));     
    TInt boolCount = aSettings.BoolParameterCount();
    for (TInt i = 0; i < boolCount; i++) 
        {
        TApMember key;
        TBool value;
        aSettings.BoolParameter(i, key, value);
        TBool dbValue;
        aItem.ReadBool(key, dbValue);
        
        // TBools should not be compared to each other because there's no
        // guarantee that TBool contains only 0 or 1 because any non-zero
        // value is considered as true. So, we have to use ! operator
        // to limit the values to 0 and 1
        // 
        // Option B !( a && b || !a && !b )
        // Option C ( a && !b || !a && b )
        if ( !dbValue != !value ) 
            {
            // Settings aren't correct.
            DLTRACEOUT(("Not matching settings"));
            return EFalse;
            }
        }
    
    // Setting are correct.
    DLTRACEOUT(("Matching settings"));
    return ETrue;
    }
    
    
void CCatalogsAccessPointManager::SetApDetailL(
    CCatalogsAccessPoint& aAp, const TDesC& aKey, const TDesC& aValue ) 
    {
    DLTRACEIN((""));
    TBool value = EFalse;
    
    if (aKey == KApName) 
        {
        aAp.SetNameL(aValue);
        }                
    else if (aKey == KApCdmaDisablePlainTextAuth) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApCdmaDisablePlainTextAuth, value);
        }
    else if (aKey == KApCdmaIfAuthName) 
        {
        aAp.SetText16ParameterL(EApCdmaIfAuthName, aValue);
        }
    else if (aKey == KApCdmaIfAuthPassword) 
        {
        aAp.SetText16ParameterL(EApCdmaIfAuthPassword, aValue);
        }       
    else if (aKey == KApCdmaIfName) 
        {
        aAp.SetText16ParameterL(EApCdmaIfName, aValue);
        }
    else if (aKey == KApCdmaIfNetworks) 
        {
        aAp.SetText16ParameterL(EApCdmaIfNetworks, aValue);
        }
    else if (aKey == KApCdmaIpAddr) 
        {
        aAp.SetText16ParameterL(EApCdmaIpAddr, aValue);
        }
    else if (aKey == KApCdmaIpAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApCdmaIpAddrFromServer, value);
        }
    else if (aKey == KApCdmaIpDnsAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApCdmaIpDnsAddrFromServer, value);
        }
    else if (aKey == KApCdmaIpGateway) 
        {
        aAp.SetText16ParameterL(EApCdmaIpGateway, aValue);
        }
    else if (aKey == KApCdmaIPNameServer1) 
        {
        aAp.SetText16ParameterL(EApCdmaIPNameServer1, aValue);
        }
    else if (aKey == KApCdmaIPNameServer2) 
        {
        aAp.SetText16ParameterL(EApCdmaIPNameServer2, aValue);
        }            
    else if (aKey == KApCdmaIpNetMask) 
        {
        aAp.SetText16ParameterL(EApCdmaIpNetMask, aValue);
        }
    else if (aKey == KApGprsAccessPointName) 
        {
        aAp.SetLongTextParameterL(EApGprsAccessPointName, aValue);
        }
    else if (aKey == KApGprsDisablePlainTextAuth)
        {        
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApGprsDisablePlainTextAuth, value);
        }
    else if (aKey == KApGprsIfAuthName) 
        {
        aAp.SetText16ParameterL(EApGprsIfAuthName, aValue);
        }
    else if (aKey == KApGprsIfAuthPassword) 
        {
        aAp.SetText16ParameterL(EApGprsIfAuthPassword, aValue);
        }
    else if (aKey == KApGprsIfName) 
        {
        aAp.SetText16ParameterL(EApGprsIfName, aValue);
        }
    else if (aKey == KApGprsIfNetworks) 
        {
        aAp.SetText16ParameterL(EApGprsIfNetworks, aValue);
        }
    else if (aKey == KApGprsIfParams) 
        {
        aAp.SetText16ParameterL(EApGprsIfParams, aValue);
        }
    else if (aKey == KApGprsIfPromptForAuth) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApGprsIfPromptForAuth, value);
        }
    else if (aKey == KApGprsIpAddr) 
        {
        aAp.SetText16ParameterL(EApGprsIpAddr, aValue);
        }
    else if (aKey == KApGprsIpAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApGprsIpAddrFromServer, value);
        }
    else if (aKey == KApGprsIpDnsAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApGprsIpDnsAddrFromServer, value);
        }
    else if (aKey == KApGprsIpGateway) 
        {
        aAp.SetText16ParameterL(EApGprsIpGateway, aValue);
        }
    else if (aKey == KApGprsIPNameServer1) 
        {
        aAp.SetText16ParameterL(EApGprsIPNameServer1, aValue);
        }
    else if (aKey == KApGprsIPNameServer2) 
        {
        aAp.SetText16ParameterL(EApGprsIPNameServer2, aValue);
        }
    else if (aKey == KApGprsIpNetMask) 
        {
        aAp.SetText16ParameterL(EApGprsIpNetMask, aValue);
        }
    else if (aKey == KApGprsPdpAddress) 
        {
        aAp.SetText16ParameterL(EApGprsPdpAddress, aValue);
        }
    else if (aKey == KApHasProxySettings) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApHasProxySettings, value);
        }
    else if (aKey == KApIapChargecard) 
        {
        TInt value = NcdProtocolUtils::DesDecToIntL(aValue);
        aAp.SetUintParameterL(EApIapChargecard, value);
        }
    else if (aKey == KApIapName) 
        {
        aAp.SetText16ParameterL(EApIapName, aValue);
        }
    else if (aKey == KApIapServiceId) 
        {
        TInt value = NcdProtocolUtils::DesDecToIntL(aValue);
        aAp.SetUintParameterL(EApIapServiceId, value);
        }
    else if (aKey == KApIapServiceType) 
        {
        aAp.SetText16ParameterL(EApIapServiceType, aValue);
        }
    else if (aKey == KApIP6NameServer1) 
        {
        aAp.SetText16ParameterL(EApIP6NameServer1, aValue);
        }
    else if (aKey == KApIP6NameServer2) 
        {
        aAp.SetText16ParameterL(EApIP6NameServer2, aValue);
        }
    else if (aKey == KApIspDefaultTelNumber) 
        {
        aAp.SetText16ParameterL(EApIspDefaultTelNumber, aValue);
        }
    else if (aKey == KApIspDescription) 
        {
        aAp.SetText16ParameterL(EApIspDescription, aValue);
        }
    else if (aKey == KApIspDisablePlainTextAuth) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApIspDisablePlainTextAuth, value);
        }
    else if (aKey == KApIspIfAuthName) 
        {
        aAp.SetText16ParameterL(EApIspIfAuthName, aValue);
        }
    else if (aKey == KApIspIfAuthPass) 
        {
        aAp.SetText16ParameterL(EApIspIfAuthPass, aValue);
        }
    else if (aKey == KApIspIfCallbackInfo) 
        {
        const TDesC& value = aValue;
        
        // convert the descriptor to 8-bit
        HBufC8* buf8 = HBufC8::NewLC(value.Length());
        buf8->Des().Copy(value);
        aAp.SetText8ParameterL(EApIspIfCallbackInfo, *buf8);
        CleanupStack::PopAndDestroy();
        }
    else if (aKey == KApIspIfName) 
        {
        aAp.SetText16ParameterL(EApIspIfName, aValue);
        }
    else if (aKey == KApIspIfNetworks) 
        {
        aAp.SetText16ParameterL(EApIspIfNetworks, aValue);
        }
    else if (aKey == KApIspIfParams) 
        {
        aAp.SetText16ParameterL(EApIspIfParams, aValue);
        }
    else if (aKey == KApIspInitString) 
        {
        const TDesC& value = aValue;

        // convert the descriptor to 8-bit
        HBufC8* buf8 = HBufC8::NewLC(value.Length());
        buf8->Des().Copy(value);
        aAp.SetText8ParameterL(EApIspIfCallbackInfo, *buf8);
        CleanupStack::PopAndDestroy();
        }
    else if (aKey == KApIspIPAddr) 
        {
        aAp.SetText16ParameterL(EApIspIPAddr, aValue);
        }
    else if (aKey == KApIspIPAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApIspIPAddrFromServer, value);
        }
    else if (aKey == KApIspIPDnsAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApIspIPAddrFromServer, value);
        }
    else if (aKey == KApIspIPGateway) 
        {
        aAp.SetText16ParameterL(EApIspIPGateway, aValue);
        }
    else if (aKey == KApIspIPNameServer1) 
        {
        aAp.SetText16ParameterL(EApIspIPNameServer1, aValue);
        }
    else if (aKey == KApIspIPNameServer2) 
        {
        aAp.SetText16ParameterL(EApIspIPNameServer2, aValue);
        }
    else if (aKey == KApIspIPNetMask) 
        {
        aAp.SetText16ParameterL(EApIspIPNetMask, aValue);
        }
    else if (aKey == KApIspIspType) 
        {
        // 
        }
    else if (aKey == KApIspLoginName) 
        {
        aAp.SetText16ParameterL(EApIspLoginName, aValue);
        }
    else if (aKey == KApIspLoginPass) 
        {
        aAp.SetText16ParameterL(EApIspLoginPass, aValue);
        }
    else if (aKey == KApIspLoginScript) 
        {
        aAp.SetText16ParameterL(EApIspLoginScript, aValue);
        }
    else if (aKey == KApIspName) 
        {
        aAp.SetText16ParameterL(EApIspName, aValue);
        }
    else if (aKey == KApLanBearerName) 
        {
        aAp.SetText16ParameterL(EApLanBearerName, aValue);
        }
    else if (aKey == KApNetworkName) 
        {
        aAp.SetText16ParameterL(EApNetworkName, aValue);
        }
    else if (aKey == KApProxyExceptions) 
        {
        aAp.SetLongTextParameterL(EApProxyExceptions, aValue);
        }
    else if (aKey == KApProxyLoginName) 
        {
        aAp.SetText16ParameterL(EApProxyLoginName, aValue);
        }
    else if (aKey == KApProxyLoginPass) 
        {
        aAp.SetText16ParameterL(EApProxyLoginPass, aValue);
        }
    else if (aKey == KApProxyPortNumber) 
        {
        TInt value = NcdProtocolUtils::DesDecToIntL(aValue);
        aAp.SetUintParameterL(EApProxyPortNumber, value);
        }
    else if (aKey == KApProxyProtocolName) 
        {
        aAp.SetText16ParameterL(EApProxyProtocolName, aValue);
        }
    else if (aKey == KApProxyServerAddress) 
        {
        aAp.SetLongTextParameterL(EApProxyServerAddress, aValue);
        }
    else if (aKey == KApProxyUseProxy) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApProxyUseProxy, value);
        }
    else if (aKey == KApWapAccessPointName) 
        {
        aAp.SetText16ParameterL(EApWapAccessPointName, aValue);
        }
    else if (aKey == KApWapCurrentBearer) 
        {
        aAp.SetText16ParameterL(EApWapCurrentBearer, aValue);
        }
    else if (aKey == KApWapGatewayAddress) 
        {
        aAp.SetText16ParameterL(EApWapGatewayAddress, aValue);
        }
    else if (aKey == KApWapIap) 
        {
        TInt value = NcdProtocolUtils::DesDecToIntL(aValue);
        aAp.SetUintParameterL(EApWapIap, value);
        }
    else if (aKey == KApWapProxyPort) 
        {
        TInt value = NcdProtocolUtils::DesDecToIntL(aValue);
        aAp.SetUintParameterL(EApWapProxyPort, value);
        }
    else if (aKey == KApWapSecurity) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApWapSecurity, value);
        }
    else if (aKey == KApWapStartPage) 
        {
        aAp.SetLongTextParameterL(EApWapStartPage, aValue);
        }
    else if (aKey == KApWapWspOption) 
        {
        if (aValue == KWapWspOptionConnectionless) 
            {
            aAp.SetUintParameterL(EApWapWspOption, EWapWspOptionConnectionless);
            }
        else if (aValue == KWapWspOptionConnectionOriented) 
            {
            aAp.SetUintParameterL(EApWapWspOption, EWapWspOptionConnectionOriented);
            }
        else 
            {
            DLWARNING((_L("Unknown EApWapWspOption value: %S"), &aValue));
            }
        }
    else if (aKey == KApWlanIfAuthName) 
        {
        aAp.SetText16ParameterL(EApWlanIfAuthName, aValue);
        }
    else if (aKey == KApWlanIfAuthPassword) 
        {
        aAp.SetText16ParameterL(EApWlanIfAuthPassword, aValue);
        }
    else if (aKey == KApWlanIfNetworks) 
        {
        aAp.SetText16ParameterL(EApWlanIfNetworks, aValue);
        }
    else if (aKey == KApWlanIpAddr) 
        {
        aAp.SetText16ParameterL(EApWlanIpAddr, aValue);
        }
    else if (aKey == KApWlanIpAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApWlanIpAddrFromServer, value);
        }
    else if (aKey == KApWlanIpDnsAddrFromServer) 
        {
        NcdProtocolUtils::DesToBool(value, aValue);
        aAp.SetBoolParameterL(EApWlanIpDnsAddrFromServer, value);
        }
    else if (aKey == KApWlanIpGateway) 
        {
        aAp.SetText16ParameterL(EApWlanIpGateway, aValue);
        }
    else if (aKey == KApWlanIPNameServer1) 
        {
        aAp.SetText16ParameterL(EApWlanIPNameServer1, aValue);
        }
    else if (aKey == KApWlanIPNameServer2) 
        {
        aAp.SetText16ParameterL(EApWlanIPNameServer2, aValue);
        }
    else if (aKey == KApWlanIpNetMask) 
        {
        aAp.SetText16ParameterL(EApWlanIpNetMask, aValue);
        }
    else 
        {
        DLWARNING(( _L("Unknown access point detail: %S"), &aKey));
        }
    }
    

TInt CCatalogsAccessPointManager::GetAccessPoint( 
    CCatalogsAccessPoint*& aAccessPoint,
    CCatalogsClientAccessPointData*& aApData )
    {
    DLTRACEIN((""));
#ifdef __WINS__
    // Comms database is not accessible in emulator
    return KErrNotFound;
#endif

    if ( iFixedAp ) 
        {
        // Use fixed AP if it is set.
        aAccessPoint = iFixedAp;
        }    
    else  
        {        
        aApData = iClientAccessPointData;
        if ( !aApData ) 
            {
            TRAPD( err, LoadFromStorageL() );
        
            if ( err != KErrNone ) 
                {
                return err;
                }
            
            aApData = iClientAccessPointData;
            }
                
        if ( !aApData ) 
            {
            return KErrNotFound;
            }
        } 
    return KErrNone;
    }


TInt CCatalogsAccessPointManager::ValidateOrCreateAccessPointL(
    CCatalogsAccessPoint* aAccessPoint,
    TUint32& aAccessPointId )
    {
    DLTRACEIN((""));
    if ( !aAccessPoint ) 
        {
        return KErrNotFound;
        }

    // If we are using fixed AP and we don't need to check
    // the existance of the AP, we can skip validation etc.
    if ( aAccessPoint == iFixedAp && !iCheckAp ) 
        {
        aAccessPointId = aAccessPoint->AccessPointId();
        return KErrNone;
        }
    
    if ( ValidateAccessPointL( aAccessPoint ) ) 
        {
        aAccessPointId = aAccessPoint->AccessPointId();        
        }
    else 
        {
        // Somehow accesspoint settings has been altered
        // in the commsdatabase. Recreate access point.
        TUint32 id = 0;
        CreateApToCommsDBL( *aAccessPoint, id );
        aAccessPoint->SetAccessPointId( id );            
        if ( aAccessPoint != iFixedAp ) 
            {
            // If not using fixed AP, client's AP settings were altered, save them.
            SaveToStorageL();
            }
        aAccessPointId = id;        
        }
    return KErrNone;
    }

    
void CCatalogsAccessPointManager::DestructL()
    {
    DLTRACEIN((""));
    CCatalogsHttpSessionManager::NetworkManagerL().RemoveObserver( *this );
    // remove access points from comms db

    RemoveAccessPointsFromCommsDbL( ETrue );
        
    // Remove fixed ap too but only if it was created by us
    if ( iFixedAp && iFixedAp->CreatedByManager() ) 
        { 
        CCatalogsRemoveAccesspointShutdownOperation* op =
            CCatalogsRemoveAccesspointShutdownOperation::NewL( 
                iGeneralManager.FamilyId(),
                iFixedAp->AccessPointId() );
        // takes ownership, deletes the op if adding fails
        CCatalogsClientServerServer::AddShutdownOperation( op );
        }
    }

