diff -r 000000000000 -r 32704c33136d ncdengine/engine/accesspointmanager/src/catalogsaccesspointmanagerimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/engine/accesspointmanager/src/catalogsaccesspointmanagerimpl.cpp Tue Jan 26 12:06:03 2010 +0200 @@ -0,0 +1,1687 @@ +/* +* 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 +#include +#include +#include + +#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& 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* 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& 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& 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& nsDetails = csDetail->Details(); + + if (nsDetails.Count() > 0) + { + MNcdConfigurationProtocolDetail* uriDetail = nsDetails[0]; + const RPointerArray& 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& 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& 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& subCatalogDetails = + bundleDetail->Details(); + if (subCatalogDetails.Count() > 0) + { + MNcdConfigurationProtocolDetail* scDetail = subCatalogDetails[0]; + const RPointerArray& 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* aCreatedAps ) + { + DLTRACEIN(("Creating access points from client configuration")); + const RPointerArray& 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& 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(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 ); + } + } +