--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omadmadapters/nsmldminternet/src/NSmlInternetAdapter.cpp Tue Aug 31 15:05:55 2010 +0300
@@ -0,0 +1,9667 @@
+/*
+ * Copyright (c) 2005 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: Internet-settings
+ *
+ */
+
+#include <commdb.h>
+#include <cdbstore.h>
+#include <cdbcols.h> // CommsDB columname defs
+#include <implementationproxy.h> // For TImplementationProxy definition
+#include <cdbpreftable.h>
+#include <etelpckt.h> // ISP enumerations
+#include <etelmm.h> // GPRS ProtocolType
+#include <nifvar.h> // CallbackType
+#include <etelqos.h> // GPRS enumeration
+#include <wappdef.h> // WAP enumeration
+#include <sysutil.h> // OOD checking
+#include <uriutils.h> // ipv4 + ipv6 checking
+#include <featmgr.h>
+#include "NSmlInternetAdapter.h"
+#include "NSmlWLanAdapter.h"
+#include "nsmldebug.h"
+#include "nsmldmtreedbclient.h"
+#include <comms-infras/commdb/protection/protectdb.h>
+#include <utf.h>
+
+#include <metadatabase.h>
+#include <cmmanagerext.h>
+#include <cmconnectionmethoddef.h>
+#include <cmconnectionmethodext.h>
+#include <cmpluginbaseeng.h>
+#include <centralrepository.h>
+#include <pdpcontextmanagerinternalcrkeys.h>
+
+const TUint KNSmlInternetAdapterImplUid = 0x101F6DE2;
+
+const TUint KIapColumn = 0x00000100;
+const TUint KLingerColumn = 0x00000200;
+const TUint KColumnMask = 0xFFFFFF00;
+const TUint KRowMask = 0x000000FF;
+
+#include <SettingEnforcementInfo.h> // VSettingEnforcementInfo
+class CNSmlWLanAdapter;
+
+_LIT( KDaemonManagerName, "NetCfgExtnDhcp" );
+_LIT( KConfigDaemonName, "!DhcpServ" );
+
+#ifndef __WINS__
+// This lowers the unnecessary compiler warning (armv5) to remark.
+// "Warning: #174-D: expression has no effect..." is caused by
+// DBG_ARGS8 macro in no-debug builds.
+#pragma diag_remark 174
+#endif
+
+const TInt KBeginTransRetryDelay = 1000000; // Delay for comms db begintransaction retry (microseconds)
+const TInt KBeginTransRetryCount = 7; // Maximum number of retries
+//-----------------------------------------------------------------------------
+// CSmlInternetAdapter* CSmlInternetAdapter::NewL( )
+//-----------------------------------------------------------------------------
+
+CNSmlInternetAdapter* CNSmlInternetAdapter::NewL(MSmlDmCallback* aDmCallback)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::NewL(): begin");
+
+ CNSmlInternetAdapter* self = NewLC(aDmCallback);
+ CleanupStack::Pop();
+
+ _DBG_FILE("CNSmlInternetAdapter::NewL(): end");
+ return self;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter* CNSmlInternetAdapter::NewLC( )
+//------------------------------------------------------------------------------
+CNSmlInternetAdapter* CNSmlInternetAdapter::NewLC(MSmlDmCallback* aDmCallback)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::NewLC(): begin");
+ CNSmlInternetAdapter* self = new (ELeave) CNSmlInternetAdapter(
+ aDmCallback);
+ CleanupStack::PushL(self);
+
+ self->iCallBack = aDmCallback;
+ self->ConstructL();
+
+ _DBG_FILE("CNSmlInternetAdapter::NewLC(): end");
+ return self;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::CNSmlInternetAdapter()
+//------------------------------------------------------------------------------
+CNSmlInternetAdapter::CNSmlInternetAdapter(TAny* aEcomArguments) :
+ CSmlDmAdapter(aEcomArguments)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::CNSmlInternetAdapter(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::CNSmlInternetAdapter(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::~CNSmlInternetAdapter(TAny* aEcomArguments)
+//------------------------------------------------------------------------------
+CNSmlInternetAdapter::~CNSmlInternetAdapter()
+ {
+ _DBG_FILE("CNSmlInternetAdapter::~CNSmlInternetAdapter(): begin");
+
+ delete iField;
+
+ delete iPrevURI;
+
+ // Command buffer cleaning if leave happend
+ if (iBuffer)
+ {
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ delete iBuffer->At(i).iMappingName;
+ delete iBuffer->At(i).iName;
+
+ ClearBuffer(iBuffer->At(iExecutionIndex).iNodeBuf);
+ delete iBuffer->At(i).iNodeBuf;
+
+ ClearBuffer(iBuffer->At(iExecutionIndex).iWlanNodeBuf);
+ delete iBuffer->At(i).iWlanNodeBuf;
+ }
+
+ iBuffer->Reset();
+ delete iBuffer;
+ }
+
+ if (iWlanSupported)
+ {
+ delete iWlanAdapter;
+ }
+
+ delete iDatabase;
+ FeatureManager::UnInitializeLib();
+ _DBG_FILE("CNSmlInternetAdapter::~CNSmlInternetAdapter(): end");
+ }
+
+//=============================================
+// CNSmlInternetAdapter::ConstructL()
+// Second phase constructor.
+//=============================================
+void CNSmlInternetAdapter::ConstructL()
+ {
+ FeatureManager::InitializeLibL();
+ iField = HBufC8::NewL(KNSmlMaxURLLength);
+
+ iPrevURI = HBufC8::NewL(KNSmlMaxURLLength);
+
+ iDatabase = CCommsDatabase::NewL();
+ // iDatabase->BeginTransaction(); //+++
+ iTransactionCommitted = ETrue;
+ i3GPPPS = EFalse;
+
+ iLeafType = EDMUnset; // Default for leaf handling
+
+ // Reset identification data
+
+ iDirection = ECommDbConnectionDirectionUnknown;
+
+ //
+ // Command buffering used for AddNode + AddLeaf
+ //
+ iBuffer = new (ELeave) CArrayFixFlat<TNSmlAPBufferElement> (
+ KNSmlAPGranularity);
+
+ // checks if Wlan feature is supported
+ iWlanSupported = FeatureManager::FeatureSupported(KFeatureIdProtocolWlan);
+
+ // WlanAdapter
+ //
+ if (iWlanSupported)
+ {
+ iWlanAdapter = CNSmlWLanAdapter::NewL(iCallBack, *iDatabase);
+ }
+
+ iNetworkId = KErrNotFound;
+ iLingerValue = NULL;
+ iLingerFlag = ETrue;
+ isAdd = EFalse;
+ }
+
+//------------------------------------------------------------------------------
+// void CNSmlInternetAdapter::DDFVersionL()
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::DDFVersionL(CBufBase& aDDFVersion)
+ {
+ aDDFVersion.InsertL(0, KNSmlInternetAdapterDDFversion);
+ }
+//------------------------------------------------------------------------------
+// void CNSmlInternetAdapter::DDFStructureL()
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::DDFStructureL(MSmlDmDDFObject& aDDF)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DDFStructureL(): begin");
+
+ //
+ // Set rest acceptable operations for data itself
+ //
+
+ TSmlDmAccessTypes aclTypesAddGetDel;
+ aclTypesAddGetDel.SetGet();
+ aclTypesAddGetDel.SetAdd();
+ aclTypesAddGetDel.SetDelete();
+
+ TSmlDmAccessTypes aclTypesAddGet;
+ aclTypesAddGet.SetGet();
+ aclTypesAddGet.SetAdd();
+
+ TSmlDmAccessTypes aclTypesNoDelete;
+ aclTypesNoDelete.SetGet();
+ aclTypesNoDelete.SetReplace();
+ aclTypesNoDelete.SetAdd();
+
+ TSmlDmAccessTypes aclTypesNoGet;
+ aclTypesNoGet.SetReplace();
+ aclTypesNoGet.SetAdd();
+ aclTypesNoGet.SetDelete();
+
+ TSmlDmAccessTypes aclTypesAddReplace;
+ aclTypesAddReplace.SetReplace();
+ aclTypesAddReplace.SetAdd();
+
+ TSmlDmAccessTypes aclTypesOnlyGet;
+ aclTypesOnlyGet.SetGet();
+
+ TSmlDmAccessTypes aclTypesAll;
+ aclTypesAll.SetGet();
+ aclTypesAll.SetReplace();
+ aclTypesAll.SetAdd();
+ aclTypesAll.SetDelete();
+
+ MSmlDmDDFObject* ddfRoot = &aDDF;
+ MSmlDmDDFObject& ddf = ddfRoot->AddChildObjectL(KNSmlDdfAP);
+
+ _LIT8(KDescription, "AP-Settings DDF description");
+ _LIT8(KDFTitle, "AP-settings title");
+
+ FillNodeInfoL(ddf, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EPermanent, MSmlDmDDFObject::ENode, KDescription);
+
+ ddf.SetDFTitleL(KDFTitle);
+ ddf.SetDefaultValueL(KNullDesC8);
+
+ MSmlDmDDFObject& nApDDF = ddf.AddChildObjectGroupL(); // For AP/<X>
+
+ FillNodeInfoL(nApDDF, aclTypesAll, MSmlDmDDFObject::EZeroOrMore,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNAPDefRootDDF = nApDDF.AddChildObjectL(KNSmlDdfNAPDef); // NAPDef
+ FillNodeInfoL(nNAPDefRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, // EZeroOrMore
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNAPDefDDF = nNAPDefRootDDF.AddChildObjectGroupL(); // For NAPDef<x>
+ FillNodeInfoL(nNAPDefDDF, aclTypesAddGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nPxRootDDF = nApDDF.AddChildObjectL(KNSmlDdfPx); // Px
+ FillNodeInfoL(nPxRootDDF, aclTypesAddGet, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nPxDDF = nPxRootDDF.AddChildObjectGroupL(); // For Px<x>
+ FillNodeInfoL(nPxDDF,
+ aclTypesAddGetDel,//aclTypesAddGet
+ MSmlDmDDFObject::EOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+ //
+ // NAPDef-node fields
+ //
+ MSmlDmDDFObject& nNameDDF = nNAPDefDDF.AddChildObjectL(KNSmlDdfNAPName); // Name
+ FillNodeInfoL(nNameDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfNAPNameDesc);
+
+ MSmlDmDDFObject& nNAPIDDDF = nNAPDefDDF.AddChildObjectL(KNSmlDdfNAPID); // NAPID
+ FillNodeInfoL(nNAPIDDDF, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfNAPIDDesc);
+
+ MSmlDmDDFObject& nNAPLingerDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfNAPLinger); // Linger
+ FillNodeInfoL(nNAPLingerDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt, KNSmlDdfNAPLingerDesc);
+
+ MSmlDmDDFObject& nNAPStartpgDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfStartpg); // Startpg
+ FillNodeInfoL(nNAPStartpgDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfStartpgDesc);
+
+ MSmlDmDDFObject& nBearerRootDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfBearer); // Bearer
+ FillNodeInfoL(nBearerRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nBearerDDF = nBearerRootDDF.AddChildObjectGroupL(); // Bearer/<x>
+ FillNodeInfoL(nBearerDDF, aclTypesAddGet, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nBearerLDDF =
+ nBearerDDF.AddChildObjectL(KNSmlDdfBearerL); // BearerL
+ FillNodeInfoL(nBearerLDDF, aclTypesAddGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfBearerLDesc);
+
+ MSmlDmDDFObject& nDirectionDDF = nBearerDDF.AddChildObjectL(
+ KNSmlDdfDirection); // Direction
+ FillNodeInfoL(nDirectionDDF, aclTypesAddGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDirectionDesc);
+
+ MSmlDmDDFObject& nNAPAddrDDF =
+ nNAPDefDDF.AddChildObjectL(KNSmlDdfNAPAddr); // NAPAddr
+ FillNodeInfoL(nNAPAddrDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfNAPAddrDesc);
+
+ MSmlDmDDFObject& nNAPAddrTyDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfNAPAddrTy); // NAPAddrTy
+ FillNodeInfoL(nNAPAddrTyDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfNAPAddrTyDesc);
+
+ MSmlDmDDFObject& nDNSAddrRootDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfDNSAddr); // DNSAddr
+ FillNodeInfoL(nDNSAddrRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nDNSAddrDDF = nDNSAddrRootDDF.AddChildObjectGroupL(); // DNSAddr/<x>
+ FillNodeInfoL(nDNSAddrDDF, aclTypesAddGet, MSmlDmDDFObject::EOneOrMore,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nDNSAddrLDDF = nDNSAddrDDF.AddChildObjectL(
+ KNSmlDdfDNSAddrL); // DNSAddrL
+ FillNodeInfoL(nDNSAddrLDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDNSAddrLDesc);
+
+ MSmlDmDDFObject& nDNSAddrTyDDF = nDNSAddrDDF.AddChildObjectL(
+ KNSmlDdfDNSAddrTy); // DNSAddrTy
+ FillNodeInfoL(nDNSAddrTyDDF, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDNSAddrTyDesc);
+
+ MSmlDmDDFObject& nDNSPriorityDDF = nDNSAddrDDF.AddChildObjectL(
+ KNSmlDdfDNSPriority); // DNSAddrPriority
+ FillNodeInfoL(nDNSPriorityDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDNSPriorityDesc);
+
+ MSmlDmDDFObject& nNAPAuthInfRootDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfNAPAuthInf); // NAPAuthInf
+ FillNodeInfoL(nNAPAuthInfRootDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNAPAuthInfDDF =
+ nNAPAuthInfRootDDF.AddChildObjectGroupL(); // NAPAuthInf/<x>
+ FillNodeInfoL(nNAPAuthInfDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nAuthNameDDF = nNAPAuthInfDDF.AddChildObjectL(
+ KNSmlDdfAuthName); // AuthName
+ FillNodeInfoL(nAuthNameDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfAuthNameDesc);
+
+ MSmlDmDDFObject& nAuthSecrDDF = nNAPAuthInfDDF.AddChildObjectL(
+ KNSmlDdfAuthSecr); // AuthSecr
+ FillNodeInfoL(nAuthSecrDDF, aclTypesAddReplace,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfAuthSecrDesc);
+
+ MSmlDmDDFObject& nDefGWDDF = nNAPDefDDF.AddChildObjectL(KNSmlDdfDefGW); // DefGW
+ FillNodeInfoL(nDefGWDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDefGWDesc);
+
+ MSmlDmDDFObject& nNetworkMaskDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfNetworkMask); // NetworkMask
+ FillNodeInfoL(nNetworkMaskDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfNetworkMaskDesc);
+
+ MSmlDmDDFObject& nUsePTxtLogDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfUsePTxtLog); // UsePTxtLog
+ FillNodeInfoL(nUsePTxtLogDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlDdfUsePTxtLogDesc);
+
+ MSmlDmDDFObject& nNetworksRootDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfNetworks); // Networks
+ FillNodeInfoL(nNetworksRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNetworksDDF = nNetworksRootDDF.AddChildObjectGroupL(); // Networks/<x>
+ FillNodeInfoL(nNetworksDDF, aclTypesAddGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNetworkNameDDF = nNetworksDDF.AddChildObjectL(
+ KNSmlDdfNetworkName); // NetworkName
+ FillNodeInfoL(nNetworkNameDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfNetworkNameDesc);
+
+ MSmlDmDDFObject& nNetworkIDDDF = nNetworksDDF.AddChildObjectL(
+ KNSmlDdfNetworkID); // NetworkID
+ FillNodeInfoL(nNetworkIDDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt,
+ KNSmlDdfNetworkIDDesc);
+
+ MSmlDmDDFObject& nPPPCompDDF =
+ nNAPDefDDF.AddChildObjectL(KNSmlDdfPPPComp); // PPPComp
+ FillNodeInfoL(nPPPCompDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EBool,
+ KNSmlDdfPPPCompDesc);
+
+ MSmlDmDDFObject& nGPRSPDPDDF =
+ nNAPDefDDF.AddChildObjectL(KNSmlDdfGPRSPDP); // GPRSPDP
+ FillNodeInfoL(nGPRSPDPDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfGPRSPDPDesc);
+
+ MSmlDmDDFObject& nIPAddrFromServerDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIPAddrFromServer); // IPAddrFromServer
+ FillNodeInfoL(nIPAddrFromServerDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlDdfIPAddrFromServerDesc);
+
+ MSmlDmDDFObject& nIPAddrDDF = nNAPDefDDF.AddChildObjectL(KNSmlDdfIPAddr); // IPAddr
+ FillNodeInfoL(nIPAddrDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfIPAddrDesc);
+
+ MSmlDmDDFObject& nDNSAddrFromServerDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfDNSAddrFromServer); // DNSAddrFromServer
+ FillNodeInfoL(nDNSAddrFromServerDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlDdfDNSAddrFromServerDesc);
+
+ MSmlDmDDFObject& nIPv6DNSAddrFromServerDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIPv6DNSAddrFromServer); // IPv6DNSAddrFromServer
+ FillNodeInfoL(nIPv6DNSAddrFromServerDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlDdfIPv6DNSAddrFromServerDesc);
+
+ MSmlDmDDFObject& nIfNetworksDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIfNetworks); // IfNetworks
+ FillNodeInfoL(nIfNetworksDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfIfNetworksDesc);
+
+ MSmlDmDDFObject& nIAPServiceDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIAPService); // IAPService
+ FillNodeInfoL(nIAPServiceDDF, aclTypesOnlyGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfIAPServiceDesc);
+
+ MSmlDmDDFObject& nIAPSeamlessnessDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIAPSeamlessness); // IAPService
+ FillNodeInfoL(nIAPSeamlessnessDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt, KNSmlDdfIAPSeamlessnessDesc);
+ MSmlDmDDFObject& nIAPMetaDataDDF = nNAPDefDDF.AddChildObjectL(
+ KNSmlDdfIAPMetaData); // IAPService
+ FillNodeInfoL(nIAPMetaDataDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt, KNSmlDdfIAPMetaDataDesc);
+
+ if (iWlanSupported)
+ {
+ iWlanAdapter->DDFStructureL(nNAPDefDDF); // Adds WLAN fields to DDF
+ }
+
+ //
+ // Px-node fields
+ //
+ MSmlDmDDFObject& nPxNameDDF = nPxDDF.AddChildObjectL(KNSmlDdfPxName); // Name
+ FillNodeInfoL(nPxNameDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlDdfPxDesc);
+
+ MSmlDmDDFObject& nPxIdDDF = nPxDDF.AddChildObjectL(KNSmlDdfPxId); // PxId
+ FillNodeInfoL(nPxIdDDF, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfPxIdDesc);
+
+ MSmlDmDDFObject& nDomainRootDDF = nPxDDF.AddChildObjectL(KNSmlDdfDomain); // Domain
+ FillNodeInfoL(nDomainRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlDdfDomainDesc);
+
+ MSmlDmDDFObject& nDomainDDF = nDomainRootDDF.AddChildObjectGroupL(); // Domain<x>
+ FillNodeInfoL(nDomainDDF, aclTypesAddGet, MSmlDmDDFObject::EOneOrMore,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nDomainLDDF =
+ nDomainDDF.AddChildObjectL(KNSmlDdfDomainL); // DomainL (Get)
+ FillNodeInfoL(nDomainLDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfDomainLDesc);
+
+ MSmlDmDDFObject& nPxPWDDF = nPxDDF.AddChildObjectL(KNSmlDdfPxPW); // PxPW
+ FillNodeInfoL(nPxPWDDF, aclTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfPxPWDesc);
+
+ MSmlDmDDFObject& nPxAddrDDF = nPxDDF.AddChildObjectL(KNSmlDdfPxAddr); // PxAddr
+ FillNodeInfoL(nPxAddrDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfPxAddrDesc);
+
+ MSmlDmDDFObject& nPortRootDDF = nPxDDF.AddChildObjectL(KNSmlDdfPort); // Port
+ FillNodeInfoL(nPortRootDDF, aclTypesAddGet, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,
+ KNSmlDdfPortDesc);
+
+ MSmlDmDDFObject& nPortDDF = nPortRootDDF.AddChildObjectGroupL(); // Port<x>
+ FillNodeInfoL(nPortDDF, aclTypesAddGet, MSmlDmDDFObject::EOneOrMore,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nPortNbrDDF = nPortDDF.AddChildObjectL(KNSmlDdfPortNbr); // PortNbr (Get)
+ FillNodeInfoL(nPortNbrDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt,
+ KNSmlDdfPortNbrDesc);
+
+ MSmlDmDDFObject& nToNAPIDRootDDF =
+ nPxDDF.AddChildObjectL(KNSmlDdfToNAPID); // ToNAPID
+ FillNodeInfoL(nToNAPIDRootDDF, aclTypesOnlyGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlDdfToNAPIDDesc);
+
+ MSmlDmDDFObject& nToNAPIDDDF = nToNAPIDRootDDF.AddChildObjectGroupL(); // ToNAPID<x>
+ FillNodeInfoL(nToNAPIDDDF, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nToNAPIDLDDF = nToNAPIDDDF.AddChildObjectL(
+ KNSmlDdfToNAPIDL); // ToNAPIDL (Get)
+ FillNodeInfoL(nToNAPIDLDDF, aclTypesOnlyGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfToNAPIDLDesc);
+
+ MSmlDmDDFObject& nPxStartpgDDF = nPxDDF.AddChildObjectL(KNSmlDdfStartpg); // Startpg
+ FillNodeInfoL(nPxStartpgDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfStartpgDesc);
+
+ MSmlDmDDFObject& nPxAuthInfRootDDF = nPxDDF.AddChildObjectL(
+ KNSmlDdfPxAuthInf); // PxAuthInf
+ FillNodeInfoL(nPxAuthInfRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nPxAuthInfDDF = nPxAuthInfRootDDF.AddChildObjectGroupL(); // PxAuthInf/<x>
+ FillNodeInfoL(nPxAuthInfDDF, aclTypesAddGet, MSmlDmDDFObject::EOneOrMore,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nPxAuthIdDDF = nPxAuthInfDDF.AddChildObjectL(
+ KNSmlDdfPxAuthId); // PxAuthId
+ FillNodeInfoL(nPxAuthIdDDF, aclTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfPxAuthIdDesc);
+
+ MSmlDmDDFObject& nPxAuthPWDDF = nPxAuthInfDDF.AddChildObjectL(
+ KNSmlDdfPxAuthPW); // PxAuthPW
+ FillNodeInfoL(nPxAuthPWDDF, aclTypesAddReplace,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlDdfPxAuthPWDesc);
+
+ MSmlDmDDFObject& nNoPxForRootDDF =
+ nPxDDF.AddChildObjectL(KNSmlDdfNoPxFor); // NoPxFor
+ FillNodeInfoL(nNoPxForRootDDF, aclTypesAddGet,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlDdfNoPxForDesc);
+
+ MSmlDmDDFObject& nNoPxForDDF = nNoPxForRootDDF.AddChildObjectGroupL(); // NoPxFor<x>
+ FillNodeInfoL(nNoPxForDDF, aclTypesAddGet, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNullDesC8);
+
+ MSmlDmDDFObject& nNoPxForLDDF = nNoPxForDDF.AddChildObjectL(
+ KNSmlDdfNoPxForL); // NoPxForL (Get)
+ FillNodeInfoL(nNoPxForLDDF, aclTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,
+ KNSmlDdfNoPxForLDesc);
+
+ _DBG_FILE("CNSmlInternetAdapter::DDFStructureL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::LingerValueL()
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::LingerValueL(const TDesC8& aObject)
+ {
+
+ TBuf<100> desObj;
+ CnvUtfConverter::ConvertToUnicodeFromUtf8(desObj, aObject);
+ TInt err(KErrNone);
+ //const TDesC& value = desObj;
+ if (!Notalpha(desObj))
+ {
+ TLex lex(desObj);
+ TUint Linger = 0;
+ TInt lingerint;
+ err = lex.Val(Linger, EDecimal);
+ if (err == KErrNone)
+ {
+ lingerint = Linger;
+ if (lingerint >= 0)
+ {
+ iLingerValue = lingerint;
+ iLingerFlag = EFalse;
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CWPAPNapdef::UdateligerValueL
+//
+// -----------------------------------------------------------------------------
+//
+TBool CNSmlInternetAdapter::Notalpha(const TDesC& aValue)
+ {
+ TBool NotAlpha = EFalse;
+ TChar character;
+ for (TInt i = 0; i < aValue.Length(); i++)
+ {
+ character = aValue[i];
+ NotAlpha = character.IsAlpha();
+ if (NotAlpha)
+ break;
+ }
+
+ return NotAlpha;
+ }
+// CNSmlInternetAdapter::AddLeafObjectL()
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::AddLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aParentLUID, const TDesC8& aObject,
+ const TDesC8& aType, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): begin");
+ DBG_ARGS8(_S8("AP:add aURI AddLeafObjectL - %S - %S"), &aURI,
+ &aParentLUID);
+ DBG_ARGS8(_S8("AP:Object %S"), &aObject);
+
+ isAdd = ETrue;
+
+ TInt parentLUID(0);
+ if (aParentLUID.Length() <= 0)
+ {
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound)
+ {
+ if (!GetProxyIdL(aURI))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return;
+ }
+ }
+ if (!iLUID)
+ iLUID = IntLUID(aParentLUID);
+ parentLUID = GetAPIdFromURIL(aURI);
+ if (parentLUID == 0)
+ {
+ if (IsAPUriFormatMatchPredefined(aURI))
+ {
+ iLUID = ConstructTreeL(aURI);
+ parentLUID = GetAPIdFromURIL(aURI);
+ }
+ }
+
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): PParentLUID set to parentLUID");
+ parentLUID = IntLUID(aParentLUID);
+ }
+ // Always buffer DNSAddr/<X>/*
+ if ((parentLUID == 0 || aURI.Find(KNSmlDdfDNSPriority) >= 0 || aURI.Find(
+ KNSmlDdfDNSAddrL) >= 0) && !iExecutingBuffer)
+ // Update as add
+ {
+ iLeafType = EDMUnset; // Default for leaf handling
+ AddLeafBufferL(aURI, aParentLUID, aObject, aType, aStatusRef);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): end");
+ return;
+ }
+
+ if (parentLUID == KNSmlIncompleteAP)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+
+ //check if Stale and add leaf buffer
+ if (parentLUID > 0 && !iExecutingBuffer)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): parentLUID > 0 && !iExecutingBuffer");
+ TUint32 apID = GetAPIdFromURIL(aURI);
+ if (!APExistsL(apID))
+ {
+ AddLeafBufferL(aURI, aParentLUID, aObject, aType, aStatusRef);
+ iStaleMapUpdate = ETrue;
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): end");
+ return;
+ }
+ }
+ TInt pushed = 0;
+ //
+ // Check which field going to be handled
+ //
+ SetField(aURI);
+ if ((iField->Compare(KNSmlDdfNAPLinger) == 0))
+ {
+ TUint32 apID = GetAPIdFromURIL(aURI);
+ if (aObject.Size() == 0)
+ {
+ DeleteLingerL(apID);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ return;
+ }
+ LingerValueL(aObject);
+
+ if (!iLingerFlag)
+ {
+ iLingerFlag = ETrue;
+ TRAPD(error, AddLingerL(apID, iLingerValue));
+ if (error == !KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ return;
+ }
+
+ //
+ // On leaf handling and add, must be checked that value not set before
+ //
+ if (iLeafType != EDMUpdate && iLeafType != EDMDelete)
+ {
+ iLeafType = EDMAdd;
+ }
+ if (iStaleMapUpdate)
+ {
+ iLeafType = EDMAdd;
+ }
+
+ TPtrC qTable = TPtrC(KNullDesC);
+ TPtrC qColumn = TPtrC(KNullDesC);
+ TPtrC qDB = TPtrC(COMMDB_ID);
+
+ if (aURI.Find(KNSmlDdfPortNbr) >= 0)
+ {
+ IsWapPort(aObject);
+ }
+ //
+ // Get Database field type
+ //
+
+ if (parentLUID > 0)
+ {
+ // Get IAP nbr for servicetype
+ TUint32 iapIDs = GetAPIdFromURIL(aURI);
+
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL(): checkluid is %d and iapId %d "),
+ parentLUID, iapIDs);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView* iapViews = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapIDs);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ TInt errorCode = iapViews->GotoFirstRecord();
+
+ // Read iapService from (IAP)
+ if (errorCode == KErrNone)
+ {
+ iapViews->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ CleanupStack::PopAndDestroy(); // iapViews
+ qTable.Set(serviceType);
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // iapViews
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): ENotFound 1 end");
+ return;
+ }
+ }
+
+ if (iWlanSupported)
+ {
+ TBool wLANfield = IsWLANfield(aURI);
+ if (wLANfield)
+ {
+ iWlanAdapter->AddLeafObjectL(aURI, aParentLUID, aObject, aType,
+ aStatusRef);
+ CleanupStack::PopAndDestroy(pushed);
+ return;
+ }
+ }
+
+ TInt fType = GetAPFieldType(aURI);
+ if (fType == EWrong) // Error if leaf not supported
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+
+ TBool fieldOK = GetAPField(qTable, qColumn);
+ if (!fieldOK) // OK if column for table not supported
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EOk end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ return;
+ }
+
+ iISPId = parentLUID;
+ if (aURI.Match(_L8("AP/*/Px/*/*")) != KErrNotFound)
+ {
+ if (iProxyId == 0)
+ iProxyId = parentLUID;
+ }
+
+ if ((fType == CNSmlInternetAdapter::EStr) || (fType
+ == CNSmlInternetAdapter::EInt && aURI.Find(KNSmlDdfGPRSPDP) >= 0)
+ || // KNSmlDdfNAPAddrTy
+ (fType == CNSmlInternetAdapter::EInt && aURI.Find(
+ KNSmlDdfNAPAddrTy) >= 0)) // KNSmlDdfNAPAddrTy
+ { // Name + NAPAddr + DNSAddr + Networks/*/Name
+
+ if (aURI.Match(_L8("AP/*/Networks/*/Name")) != KErrNotFound)
+ {
+ TUint32 checkLUID = 0;
+ TUint32 iapID1 = GetAPIdFromURIL(aURI);
+
+ // IAP-table NetworkId Update
+ CCommsDbTableView* iapUpdate = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID1);
+ TInt iapExists = iapUpdate->GotoFirstRecord();
+
+ if (iapExists == KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL, Get network id");
+ iapUpdate->ReadUintL(TPtrC(IAP_NETWORK), checkLUID);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL(): networks is %d"),
+ checkLUID);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL, IAP exists");
+ if (checkLUID > 0)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL, network id > 0");
+ //check if network exist in NETWORK TABLE
+ CCommsDbTableView* checknetView;
+ checknetView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ NETWORK), TPtrC(COMMDB_ID), checkLUID);
+ TInt error = checknetView->GotoFirstRecord();
+ if (error == KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: Network does not exist, create it");
+ AddNetworkL(checkLUID, aObject);
+ if (checkLUID > 0)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network generation ok");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL(): network id is %d"),
+ checkLUID);
+ //iapUpdate->WriteUintL(TPtrC(IAP_NETWORK),checkLUID);
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): network generation failed");
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ return;
+ }
+ }
+ // Network was found, update the name to the given name.
+ else
+ {
+ if (checknetView->UpdateRecord() == KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network found, update name");
+ checknetView->WriteTextL(TPtrC(COMMDB_NAME),
+ ConvertTo16LC(aObject));
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network name updated");
+ checknetView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ }
+ // writing failed for some reason
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): network generation failed");
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ return;
+ }
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network ok");
+ CleanupStack::PopAndDestroy(); //checknetView
+ }
+ }
+ // IAP does not exist yet, create network, network id will be updated later using checkLUID
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network does not exist, creation 2");
+ AddNetworkL(checkLUID, aObject);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL(): network id is %d"),
+ checkLUID);
+ }
+ CleanupStack::PopAndDestroy(); // iapUpdate
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network addition handled");
+
+ // IAP-table NetworkId Update
+ CCommsDbTableView* iapView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID1);
+ TInt iapFound = iapView->GotoFirstRecord();
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL: network id update begin");
+ if (iapFound == KErrNone)
+ {
+ TBool iapReLock = EFalse;
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ TBool apEnforce = EFalse;
+ TRAPD(eError,apEnforce=CheckEnforcementL())
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::AddLeafObjectL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ ((CCommsDbProtectTableView*) iapView)->UnprotectRecord();
+ iWAPRelock = ETrue;
+ }
+ }
+
+ if (IsIAPRecordLockedL(iapID1))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) iapView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+
+ if (iapView->UpdateRecord() == KErrNone)
+ {
+ iapView->WriteUintL(TPtrC(IAP_NETWORK), checkLUID);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObject(): checkLUID is %d"),
+ checkLUID);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObject, IAP_NETWORK set to checkLUID ");
+ iapView->PutRecordChanges();
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObject, iap found, set iNetworkId to checkLUID");
+ iNetworkId = checkLUID;
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ ((CCommsDbProtectTableView*) iapView)->ProtectRecord();
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID1, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,Protecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ }
+ else if (iapFound == KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObject, iap not found, set iNetworkId");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObject(): checkLUID is %d"),
+ checkLUID);
+ iNetworkId = checkLUID;
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObject, iap found");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+
+ CleanupStack::PopAndDestroy(); // iapView
+ CleanupStack::PopAndDestroy(pushed);
+
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): OK end");
+ return;
+ }
+
+ else if (((aURI.Match(_L8("AP/*/Px/*/Name")) != KErrNotFound || // ProxyName
+ aURI.Match(_L8("AP/*/Px/*/PxAddr")) != KErrNotFound || // ProxyAddr
+ aURI.Match(_L8("AP/*/Px/*/DomainL")) != KErrNotFound) // DomainL (PROXY_PROTOCOL_NAME)
+ && iLeafType == EDMUpdate)
+ || ((aURI.Match(_L8("AP/*/Px/*/PxAddr")) != KErrNotFound
+ || aURI.Match(_L8("AP/*/Px/*/DomainL"))
+ != KErrNotFound) && iLeafType == EDMAdd))
+ {
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(PROXIES), TPtrC(COMMDB_ID), iProxyId);
+ TBool proxyReLock = EFalse;
+ if (IsProxyRecordLockedL(iProxyId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): proxy record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting ProxyRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+
+ TInt errorCode = tableView->GotoFirstRecord();
+ if (errorCode == KErrNone)
+ {
+ if (tableView->UpdateRecord() == KErrNone)
+ {
+ if (aURI.Match(_L8("AP/*/Px/*/PxAddr")) != KErrNotFound)
+ {
+ tableView->WriteLongTextL(TPtrC(PROXY_SERVER_NAME),
+ ConvertTo16LC(aObject));
+ pushed++;
+ }
+ else if (aURI.Match(_L8("AP/*/Px/*/DomainL"))
+ != KErrNotFound)
+ {
+ // Accepted values are (http, https, ftp, ftps)
+ _LIT8(KProxyProtocol, "http, https, ftp, ftps");
+
+ TInt protocolFound = 0;
+ if (aObject.Length() > 0)
+ {
+ protocolFound = KProxyProtocol().Find(aObject);
+ }
+ if (protocolFound == KErrNotFound && aObject.Length()
+ > 0)
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ if (aObject.Length() == 0)
+ {
+ tableView->SetNullL(TPtrC(PROXY_PROTOCOL_NAME));
+ }
+ else
+ {
+ tableView->WriteTextL(TPtrC(PROXY_PROTOCOL_NAME),
+ ConvertTo16LC(aObject));
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ }
+ }
+ tableView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): ENotFound end");
+ return;
+ }
+ if (proxyReLock)
+ {
+ TInt reclockerr = DoProtectProxyRecordL(iProxyId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting Proxy returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = EFalse;
+ }
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EOk end");
+ return;
+ }
+
+ if (iLeafType == EDMUpdate || (iLeafType == EDMAdd && (aURI.Find(
+ KNSmlDdfNAPName) >= 0 && aURI.Find(KNSmlDdfNAPDef) >= 0)
+ || aURI.Find(KNSmlDdfNAPAddr) >= 0 || aURI.Find(
+ KNSmlDdfGPRSPDP) >= 0 || aURI.Find(KNSmlDdfDNSAddrL) >= 0
+ || aURI.Find(KNSmlDdfAuthSecr) >= 0 || aURI.Find(
+ KNSmlDdfDefGW) >= 0 || aURI.Find(KNSmlDdfNetworkMask) >= 0
+ || aURI.Find(KNSmlDdfIPAddr) >= 0 || aURI.Find(
+ KNSmlDdfNAPAddrTy) >= 0))
+ {
+ // Get IAP nbr for servicetype
+
+ TUint32 iapID2 = GetAPIdFromURIL(aURI);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView
+ * serviceView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ IAP), qDB, iapID2);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ TInt errorCode = serviceView->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ serviceView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ serviceView->ReadTextL(TPtrC(IAP_SERVICE_TYPE),
+ iProxyServiceType); // for locking
+
+ serviceView->ReadUintL(TPtrC(IAP_SERVICE), iISPId);
+
+ CleanupStack::PopAndDestroy(); // serviceView
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // serviceView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): ENotFound end");
+ return;
+ }
+ qTable.Set(serviceType);
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, qDB, iISPId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBool serviceReLock = EFalse;
+ if (IsServiceRecordLockedL(iISPId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ serviceReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+
+ if (tableView->UpdateRecord() != KErrNone)
+ {
+ //database locked
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+ if (fType == CNSmlInternetAdapter::EInt)
+ {
+ TUint32 object32;
+ if (aURI.Find(KNSmlDdfGPRSPDP) >= 0 || /* GPRSPDP handling */
+ aURI.Find(KNSmlDdfNAPAddrTy) >= 0) /* NAPAddrTy handling */
+ {
+ if (aObject.MatchF(KNSmlDmApValIpv4) != KErrNotFound)
+ {
+ object32 = RPacketContext::EPdpTypeIPv4;
+ }
+ else if (aObject.MatchF(KNSmlDmApValIpv6)
+ != KErrNotFound)
+ {
+ object32 = RPacketContext::EPdpTypeIPv6;
+ }
+ else if (aObject.MatchF(_L8("PPP")) != KErrNotFound)
+ {
+ object32 = RPacketContext::EPdpTypePPP;
+ }
+ else
+ { // NotValid value
+ tableView->CancelRecordChanges();
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+ }
+ else
+ {
+ object32 = GetIntObject8(aObject);
+ }
+
+ tableView->WriteUintL(qColumn, object32);
+ }
+ else
+ {
+ // This should be executed only when executing buffered cmds
+ if (aURI.Find(KNSmlDdfDNSAddrL) >= 0)
+ // DNS address
+ {
+ TPtrC8 parentUri = RemoveLastSeg(aURI);
+ TInt dnsPri = 0;
+ TBool found = InitializeDNSParamsFromBuffL(parentUri,
+ dnsPri);
+ UriUtils::TUriHostType dnsAddrTy =
+ UriUtils::HostType(aObject);
+
+ if (!found)
+ {
+ UriUtils::TUriHostType dnsLuidType;
+ TInt dnsLuidPriority;
+ if (LuidToDns(dnsLuidType, dnsLuidPriority,
+ parentLUID) != KErrNone)
+ {
+ if (dnsAddrTy == UriUtils::EIPv4Host)
+ {
+ iDnsIpv4Pri = (iDnsIpv4Pri % 2) + 1;
+ dnsPri = iDnsIpv4Pri;
+ }
+ else if (dnsAddrTy == UriUtils::EIPv6Host)
+ {
+ iDnsIpv6Pri = (iDnsIpv6Pri % 2) + 1;
+ dnsPri = iDnsIpv6Pri;
+ }
+ }
+ else
+ {
+ // update
+ dnsPri = dnsLuidPriority;
+ }
+
+ }
+ if (dnsPri != 0)
+ {
+ if (dnsPri == 1)
+ {
+ if (dnsAddrTy == UriUtils::EIPv4Host)
+ {
+ qColumn.Set(
+ TPtrC(SERVICE_IP_NAME_SERVER1));
+ }
+ else
+ {
+ qColumn.Set(TPtrC(
+ SERVICE_IP6_NAME_SERVER1));
+
+ }
+ }
+ else
+ {
+ if (dnsAddrTy == UriUtils::EIPv4Host)
+ {
+ qColumn.Set(
+ TPtrC(SERVICE_IP_NAME_SERVER2));
+ }
+ else
+ {
+ qColumn.Set(TPtrC(
+ SERVICE_IP6_NAME_SERVER2));
+
+ }
+ }
+ tableView->WriteTextL(qColumn, ConvertTo16LC(
+ aObject));
+ pushed++;
+ TInt dnsLuid = DnsToLuid(dnsAddrTy, dnsPri);
+ iCallBack->SetMappingL(parentUri, SetIntObjectLC(
+ dnsLuid));
+ pushed++;
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+
+ }
+
+ else
+ {
+ if ((serviceType == TPtrC(LAN_SERVICE))
+ && (iField->Compare(KNSmlDdfNAPAddr) == 0))
+ {
+ if (!IsValidIPv4AddressL(aObject))
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EInvalidObject);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EInvalidObject end");
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ return;
+ }
+
+ }
+ tableView->WriteTextL(qColumn, ConvertTo16LC(aObject));
+ pushed++;
+
+ }
+ // DNSAddrL <> 0.0.0.0 or empty =>
+ if (aURI.Find(KNSmlDdfDNSAddrL) >= 0) /* DNS serviceFlag handling */
+ {
+ if (aObject.Match(_L8("fec0:0:0:ffff::1"))
+ == KErrNotFound || aObject.Match(_L8(
+ "fec0:0:0:ffff::2")) == KErrNotFound)
+ {
+ tableView->WriteBoolL(TPtrC(
+ SERVICE_IP6_DNS_ADDR_FROM_SERVER), EFalse);
+ }
+ else
+ {
+ tableView->WriteBoolL(TPtrC(
+ SERVICE_IP6_DNS_ADDR_FROM_SERVER), ETrue);
+ }
+
+ }
+ }
+ TInt putOk = tableView->PutRecordChanges();
+ if (putOk != KErrNone)
+ {
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && putOk == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ putOk = tableView->PutRecordChanges();
+ retry--;
+ }
+ if (putOk != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ DBG_ARGS(
+ _S16(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed with Code %d"),
+ putOk);
+ return;
+ }
+ }
+ if (aURI.Find(KNSmlDdfNAPName) >= 0 && aURI.Find(
+ KNSmlDdfAuthName) <= 0) /* NAPName */
+ {
+ if (UpdateIAPnameL(iapID2, aObject) != KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ }
+ }
+ if (serviceReLock)
+ {
+ TInt reclockerr = DoProtectServiceRecordL(iISPId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ serviceReLock = EFalse;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): ENotFound end");
+ return;
+ }
+
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+
+ }
+ else if (fType == CNSmlInternetAdapter::EBool)
+ { // UseCB + UseIPSec
+ TUint32 iapID3 = GetAPIdFromURIL(aURI);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView* boolView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID3);
+ TInt errorCode = boolView->GotoFirstRecord();
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ errorCode = boolView->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ boolView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ boolView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), iProxyServiceType); // for locking
+ boolView->ReadUintL(TPtrC(IAP_SERVICE), iISPId);
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // boolView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): ENotFound end");
+ return;
+ }
+
+ CleanupStack::PopAndDestroy(); // boolView
+
+ qTable.Set(serviceType);
+ TBool ret = GetAPField(qTable, qColumn);
+ if (!ret)
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EInvalidObject);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EInvalidObject end");
+ return;
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, TPtrC(COMMDB_ID), iISPId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBool serviceReLock = EFalse;
+ if (IsServiceRecordLockedL(iISPId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ serviceReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ if (tableView->UpdateRecord() != KErrNone)
+ {
+ //database locked
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+ TBool tObject = EFalse;
+
+ if (aObject.CompareF(KNSmlDmApValTrue) == 0)
+ {
+ tObject = ETrue;
+ }
+ if (aURI.Right(10).Compare(KNSmlDdfUsePTxtLog) == 0)
+ {
+ tObject = !tObject;
+ }
+ if (qColumn.Match(TPtrC(SERVICE_IP_ADDR_FROM_SERVER))
+ != KErrNotFound)
+ {
+ if (serviceType == TPtrC(LAN_SERVICE)) // Is WLAN service
+ {
+ if (tObject)
+ {
+ tableView->WriteTextL(TPtrC(
+ SERVICE_CONFIG_DAEMON_MANAGER_NAME),
+ KDaemonManagerName);
+ tableView->WriteTextL(TPtrC(
+ SERVICE_CONFIG_DAEMON_NAME),
+ KConfigDaemonName);
+ }
+ else
+ {
+ tableView->WriteTextL(TPtrC(
+ SERVICE_CONFIG_DAEMON_MANAGER_NAME),
+ KNullDesC);
+ tableView->WriteTextL(TPtrC(
+ SERVICE_CONFIG_DAEMON_NAME), KNullDesC);
+ }
+ }
+ } // Is WLAN service
+
+ tableView->WriteBoolL(qColumn, tObject);
+ tableView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); // tableView
+ if (serviceReLock)
+ {
+ TInt reclockerr = DoProtectServiceRecordL(iISPId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting ServiceRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ serviceReLock = EFalse;
+ }
+ }
+ else
+ {
+ tableView->CancelRecordChanges();
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ else if (fType == CNSmlInternetAdapter::EInt)
+ { // UsePTxtLog + PortNbr + seamlessness and metadata
+ iObject = GetIntObject8(aObject);
+
+ if (aURI.Find(KNSmlDdfIAPSeamlessness) >= 0)
+ {
+ // TUint32 setSeam = GetIntObject8(aObject);
+ TUint32 apMetaID = GetAPIdFromURIL(aURI);
+ SetIAPSeamlessnessL(apMetaID, iObject, aStatusRef);
+ return;
+ }
+
+ else if (aURI.Find(KNSmlDdfIAPMetaData) >= 0)
+ {
+ // TUint32 setMeta = GetIntObject8(aObject);
+ TUint32 apMetaID = GetAPIdFromURIL(aURI);
+ SetIAPMetaDataL(apMetaID, iObject, aStatusRef);
+ return;
+ }
+
+ if (aURI.Find(KNSmlDdfUsePTxtLog) >= 0)
+ {
+ TUint32 iapID4 = GetAPIdFromURIL(aURI);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView* iapView4 = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID4);
+ TInt errorCode = iapView4->GotoFirstRecord();
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ errorCode = iapView4->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ iapView4->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ iapView4->ReadTextL(TPtrC(IAP_SERVICE_TYPE),
+ iProxyServiceType); // for locking
+ iapView4->ReadUintL(TPtrC(IAP_SERVICE), iISPId);
+ CleanupStack::PopAndDestroy(); // iapView4
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // iapView4
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): ENotFound end");
+ return;
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, TPtrC(COMMDB_ID), iISPId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBool serviceReLock = EFalse;
+ if (IsServiceRecordLockedL(iISPId))
+ {
+
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ serviceReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ if (tableView->UpdateRecord() != KErrNone)
+ {
+ //database locked
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+ TBool tObject = EFalse;
+ if (iObject)
+ {
+ tObject = ETrue; // <> 0
+ }
+ tableView->WriteBoolL(TPtrC(SERVICE_DISABLE_PLAIN_TEXT_AUTH),
+ tObject);
+ tableView->PutRecordChanges();
+ if (serviceReLock)
+ {
+ TInt reclockerriap = DoProtectIAPRecordL(iapID4, ETrue);
+ TInt reclockerr = DoProtectServiceRecordL(iISPId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAP returned code = %d"),
+ reclockerriap);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting ServiceRecord returned code = %d"),
+ reclockerr);
+ if ((reclockerr == KErrNone) && (reclockerriap == KErrNone))
+ serviceReLock = EFalse;
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+ else
+ {
+ tableView->CancelRecordChanges();
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ else if (aURI.Find(KNSmlDdfPortNbr) >= 0)
+ {
+ if (GetProxyIdL(aURI))
+ {
+ iProxyISP = GetAPIdFromURIL(aURI);
+
+ CCommsDbTableView* tableView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES),
+ TPtrC(COMMDB_ID), iProxyId);
+ TInt errorCode = tableView->GotoFirstRecord();
+ TBool proxyReLock = EFalse;
+ // Read all columns needed.
+ if (errorCode == KErrNone)
+ {
+ if (IsProxyRecordLockedL(iProxyId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): proxy record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting Proxy Record returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ if (tableView->UpdateRecord() != KErrNone)
+ {
+ //database locked
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Update failed end");
+ return;
+ }
+ iObject = GetIntObject8(aObject);
+
+ tableView->WriteUintL(TPtrC(PROXY_PORT_NUMBER), iObject);
+ }
+ tableView->PutRecordChanges();
+ if (proxyReLock)
+ {
+ TInt reclockerr = DoProtectProxyRecordL(iProxyId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting Proxy Record returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = EFalse;
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): PortNbr Error end");
+ return;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): PortNbr Error end");
+ return;
+ }
+
+ }
+
+ else if (fType == CNSmlInternetAdapter::EWap)
+ { // Startpg + PxAuthId + PxAuthPW (WAP-settings) (BasAuthId + BasAuthPW)
+ TUint32 iapID5 = GetAPIdFromURIL(aURI);
+ //
+ // Without iapID5 no insert possible, set on buffer
+ //
+ if (iapID5 < 1)
+ {
+ AddLeafBufferL(aURI, aParentLUID, aObject, aType, aStatusRef);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): end");
+ return;
+ }
+
+ GetAPField(qTable, qColumn);
+ if (WapAPExistsL(iapID5))
+ { // Update handled
+ TBool iapReLock = EFalse;
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ TBool apEnforce = EFalse;
+ TRAPD(eError,apEnforce=CheckEnforcementL())
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::AddLeafObjectL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+ if (IsIAPRecordLockedL(iapID5))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, EFalse);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ CCommsDbTableView* wapView;
+ TBool wapaccesspointTableLocked = EFalse;
+
+ if (qColumn == TPtrC(WAP_START_PAGE))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): record to be added WAP_START_PAGE, check for lock status");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL Get WapAccessPoint record access for ID = %d"),
+ iWapId);
+ if (IsWAPAccessPointRecordLockedL(iWapId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): wapaccesspoint record is LOCKED");
+ TInt reclockerr = DoProtectWAPAccessRecordL(iWapId,
+ EFalse);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ wapaccesspointTableLocked = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): wapaccesspoint record is not write protected");
+ }
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ WAP_ACCESS_POINT), TPtrC(COMMDB_ID), iWapId);
+ pushed++;
+ }
+ else // Other WAP-data
+ {
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ WAP_IP_BEARER), TPtrC(WAP_ACCESS_POINT_ID), iWapId);
+ pushed++;
+ }
+
+ TInt errorCode = wapView->GotoFirstRecord();
+
+ // Read all columns needed.
+ if (errorCode == KErrNone)
+ {
+ if (wapView->UpdateRecord() != KErrNone)
+ {
+ //database locked
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): Wapview Update failed end");
+ if (wapaccesspointTableLocked)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): wapaccesspoint record to be locked again ");
+ DoProtectWAPAccessRecordL(iWapId, ETrue);
+ wapaccesspointTableLocked = EFalse;
+ }
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ return;
+ }
+
+ if (qColumn == TPtrC(WAP_PROXY_PORT))
+ {
+ TBool security = EFalse; // => 9200 + 9201, ETrue 9202 + 9203
+ TUint32 object32;
+ TPtrC object16 = ConvertTo16LC(aObject);
+ pushed++;
+ if (object16.Match(KWappPort9200) != KErrNotFound)
+ {
+ object32 = KWAPP_PORT_9200; // wappdef.h
+ }
+ else if (object16.Match(KWappPort9201) != KErrNotFound)
+ {
+ object32 = KWAPP_PORT_9201;
+ }
+ else if (object16.Match(KWappPort9202) != KErrNotFound)
+ {
+ object32 = KWAPP_PORT_9202;
+ security = ETrue;
+ }
+ else if (object16.Match(KWappPort9203) != KErrNotFound)
+ {
+ object32 = KWAPP_PORT_9203;
+ security = ETrue;
+ }
+ else
+ {
+ wapView->CancelRecordChanges();
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5,
+ ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ return;
+ }
+ wapView->WriteUintL(qColumn, object32);
+ wapView->WriteBoolL(TPtrC(WAP_SECURITY), security);
+ }
+ else
+ {
+ wapView->WriteTextL(TPtrC(qColumn),
+ ConvertTo16LC(aObject));
+ pushed++;
+ }
+ }
+ wapView->PutRecordChanges();
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): wapaccesspoint record Changes DONE successfully ");
+ if (wapaccesspointTableLocked)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): wapaccesspoint record to be locked again ");
+ TInt reclockerr = DoProtectWAPAccessRecordL(iWapId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,Protecting WAPAccessRecord %d , returned code = %d"),
+ iWapId, reclockerr);
+ wapaccesspointTableLocked = EFalse;
+ }
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ CleanupStack::PopAndDestroy(pushed);
+ pushed = 0;
+ }
+ else
+ { // Insert handled
+ CCommsDbTableView* insView;
+ TInt wapInitOK = KErrCancel;
+ TBool iapReLock = EFalse;
+
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ TBool apEnforce = EFalse;
+ TRAPD(eError,apEnforce=CheckEnforcementL())
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::AddLeafObjectL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ insView = iDatabase->OpenTableLC(TPtrC(WAP_ACCESS_POINT));
+ iWapId = 0;
+ wapInitOK = insView->InsertRecord(iWapId);
+ if (wapInitOK == KErrNone)
+ {
+ iWAPAccessPoint.Zero();
+ iWapUserName.Zero();
+ iWapPassword.Zero();
+
+ if (qColumn == TPtrC(WAP_START_PAGE))
+ {
+ iWAPAccessPoint = aObject;
+ }
+ else if (qColumn == TPtrC(WAP_PROXY_LOGIN_NAME))
+ {
+ iWapUserName = aObject;
+ }
+ else if (qColumn == TPtrC(WAP_PROXY_LOGIN_PASS))
+ {
+ iWapPassword = aObject;
+ }
+
+ iWapBearer = TPtrC(WAP_IP_BEARER);
+ iWapName = FirstURISeg(aURI); // Name needed !!!
+
+ wapInitOK = InitializeWAPIAPL(insView, iIAPName);
+ if (wapInitOK == KErrNone)
+ {
+ insView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); // insView
+
+ CCommsDbTableView* updView;
+ TUint32 iWapId2 = 0;
+ iISPId = iapID5; // IAP number set
+ updView = iDatabase->OpenTableLC(TPtrC(WAP_IP_BEARER));
+ if (updView->InsertRecord(iWapId2) == KErrNone)
+ {
+ wapInitOK = InitializeWAPL(updView);
+ }
+ else
+ {
+ wapInitOK = KErrGeneral;
+ }
+ if (wapInitOK == KErrNone)
+ {
+ if (!PxExistsL(iapID5))
+ {
+
+ // Set mapping-data
+
+ TPtrC8 addURI = GetAddURISeg(aURI,
+ KNSmlDdfStartpg);
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, iapID5);
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ else if (!NAPDefExistsL(iapID5))
+ {
+
+ // Set mapping-data
+
+ TPtrC8 addURI = GetAddURISeg(aURI,
+ KNSmlDdfStartpg);
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, iapID5);
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+
+ updView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); // updView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5,
+ ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EOk end");
+ return;
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // updView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5,
+ ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ else
+ {
+ insView->CancelRecordChanges();
+ CleanupStack::PopAndDestroy(); // insView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // insView
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iapID5, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ }
+ }
+ else if (fType == CNSmlInternetAdapter::ESpec)
+ { // BearerL + NoPxForL + IAPService + Direction
+ if (aURI.Find(KNSmlDdfDirection) >= 0)
+ {
+ _LIT8(KDirection, "Outgoing");
+ if (KDirection().Find(aObject) != KErrNotFound)
+ {
+ iDirection = ECommDbConnectionDirectionOutgoing;
+ }
+ else
+ {
+ iDirection = ECommDbConnectionDirectionIncoming;
+ if (iBearer == TPtrC(OUTGOING_GPRS))
+ {
+ iBearer = TPtrC(INCOMING_GPRS);
+ }
+ }
+ }
+ else if (aURI.Find(KNSmlDdfIAPService) >= 0)
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ else if (aURI.Find(KNSmlDdfNoPxForL) >= 0) /* No proxies used field handling */
+ {
+ TBool proxyFound = GetProxyIdL(aURI);
+ if (!proxyFound)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ CleanupStack::PopAndDestroy(pushed);
+ return;
+ }
+
+ CCommsDbTableView* specView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(PROXIES), TPtrC(COMMDB_ID), iProxyId);
+ TInt errorCode = specView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBool proxyReLock = EFalse;
+ if (IsProxyRecordLockedL(iProxyId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) specView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting ProxyAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ if (specView->UpdateRecord() == KErrNone)
+ {
+ //database not locked
+ specView->WriteLongTextL(TPtrC(PROXY_EXCEPTIONS),
+ ConvertTo16LC(aObject));
+ specView->PutRecordChanges();
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ CleanupStack::PopAndDestroy(); // ConvertTo16LC
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ if (proxyReLock)
+ {
+ TInt reclockerr = DoProtectProxyRecordL(iProxyId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting ProxyAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ proxyReLock = EFalse;
+ }
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ CleanupStack::PopAndDestroy(); // specView
+
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+ else if (aURI.Find(KNSmlDdfBearerL) >= 0) /* Bearer handling */
+ {
+ if (aObject.Match(KNSmlDmApValGsmGprs) != KErrNotFound)
+ {
+ if (iDirection == ECommDbConnectionDirectionIncoming)
+ {
+ iBearer = TPtrC(INCOMING_GPRS);
+ }
+ else
+ {
+ iBearer = TPtrC(OUTGOING_GPRS);
+ }
+ }
+
+ else if (aObject.Match(KNSmlDmApVal3Gppps) != KErrNotFound)
+ {
+ i3GPPPS = ETrue;
+ if (iDirection == ECommDbConnectionDirectionIncoming)
+ {
+ iBearer = TPtrC(INCOMING_GPRS);
+ }
+ else
+ {
+ iBearer = TPtrC(OUTGOING_GPRS);
+ }
+ }
+ else if (aObject.Match(KNSmlDmApValVpn) != KErrNotFound)
+ {
+ iBearer = TPtrC(VPN_SERVICE);
+ }
+ else if ((aObject.Match(KNSmlDmApValWlan) != KErrNotFound)
+ && iWlanSupported)
+ {
+ iBearer = TPtrC(LAN_SERVICE);
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): UNKNOWN Bearer Error end");
+ return;
+ }
+ }
+ else if (aURI.Find(KNSmlDdfNAPName) >= 0)
+ {
+ iIAPName.Copy(aObject);
+ TUint32 iapID2 = GetAPIdFromURIL(aURI);
+ if (iapID2 > 0 && UpdateIAPnameL(iapID2, aObject) != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(pushed);
+ pushed = 0;
+
+ // Update CommsDB IAP + insert iBearer Table
+
+ if (IsInsertAllowedL() && iLeafType == EDMAdd && fType
+ == CNSmlInternetAdapter::ESpec) //iIAPExists
+ {
+ TInt initOK = KErrCancel;
+
+ iISPId = GetMaxIdL() + 1; // For new data
+
+ SaveIAPDataL(aURI); // Level 1 Mapping inside
+
+ CCommsDbTableView* newAPView;
+
+ newAPView = iDatabase->OpenTableLC(iBearer);
+ // 3GPPPS = OUTGOING/INCOMING_GPRS
+ if (iBearer == TPtrC(OUTGOING_GPRS) || iBearer
+ == TPtrC(INCOMING_GPRS))
+ {
+ if (newAPView->InsertRecord(iISPId) == KErrNone)
+ {
+ initOK = InitializeGPRSL(newAPView);
+ }
+ else
+ {
+ initOK = KErrGeneral;
+ }
+ }
+
+ else if (iBearer == TPtrC(VPN_SERVICE))
+ {
+ if (newAPView->InsertRecord(iISPId) == KErrNone)
+ {
+ initOK = InitializeVPNServiceL(newAPView);
+ }
+ else
+ {
+ initOK = KErrGeneral;
+ }
+ }
+ else if ((iBearer == TPtrC(LAN_SERVICE)) && iWlanSupported)
+ {
+ if (newAPView->InsertRecord(iISPId) == KErrNone)
+ {
+ initOK = InitializeLANServiceL(newAPView);
+ }
+ else
+ {
+ initOK = KErrGeneral;
+ }
+ }
+ else
+ {
+ initOK = KErrCancel;
+ }
+
+ if (initOK == KErrNone)
+ {
+ TUint32 newId = 0;
+ newAPView->PutRecordChanges();
+ newAPView->ReadUintL(TPtrC(COMMDB_ID), newId);
+
+ // To update right Id
+
+ iISPId = newId;
+
+ SaveIAPDataL(aURI);
+
+ TUint32 iapID2 = GetAPIdFromURIL(aURI);
+ UpdateIAPnameL(iapID2, iIAPName);
+ //
+ // Set mapping-data (levels 2 and 3 )
+ //
+ TPtrC8 addURI = GetAddURISeg(aURI, KNSmlDdfNAPDef);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, newId);
+
+ // Also NAPDef (level 2)
+ iCallBack->SetMappingL(addURI, addLUID);
+ DBG_ARGS8(_S8("AP:level2 URI - <%S> <%S> <%d>"), &addURI,
+ &addLUID, newId);
+
+ // Also BearerL (level 3)
+ TPtrC8 addURI2 = GetAddURISeg(aURI, KNSmlDdfBearer);
+ if (i3GPPPS)
+ {
+ newId = KNSmlAp3gpppsLowerBase + newId;
+ addLUID.Format(KFormat, newId);
+ i3GPPPS = EFalse;
+ }
+ iCallBack->SetMappingL(addURI2, addLUID);
+ DBG_ARGS8(_S8("AP:level3 URI - <%S> <%S> <%d>"), &addURI2,
+ &addLUID, newId);
+ }
+ else
+ {
+ if (initOK == KErrCancel)
+ {
+ newAPView->CancelRecordChanges();
+ }
+ CleanupStack::PopAndDestroy(newAPView);
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): EError end");
+ return;
+ }
+
+ CleanupStack::PopAndDestroy(newAPView);
+ }
+ else if (IsInsertAllowedL() && iLeafType == EDMAdd && aURI.Find(
+ KNSmlDdfBearerL) >= 0)
+
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EAlreadyExists);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): EAlreadyExists BearerL end");
+ return;
+ }
+ CleanupStack::PopAndDestroy(pushed);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddLeafObjectL(): OK end");
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType )
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::UpdateLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType,
+ const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::UpdateLeafObjectL(): begin");
+
+ DBG_ARGS8(_S8("AP:update aURI UpdateLeafObjectL - %S - %S"), &aURI,
+ &aLUID);
+ DBG_ARGS8(_S8("AP:Object %S"), &aObject);
+ if (iTransactionCommitted)
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("UpdateLeafObjectL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("UpdateLeafObjectL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ iTransactionCommitted = EFalse;
+ }
+ if ((aURI.Match(_L8("*/WLAN*")) != KErrNotFound) && iWlanSupported)
+ {
+ AddLeafBufferL(aURI, aLUID, aObject, aType, aStatusRef, ETrue);
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ _DBG_FILE("CNSmlInternetAdapter::UpdateLeafObjectL(): WLAN end");
+
+ return;
+ }
+ //
+ // No direct update allowed only update as add
+ //
+ if (aLUID.Length() > 0 && aURI.Find(KNSmlDdfNAPDef) >= 0)
+ /*( aURI.Find(KNSmlDdfBearerL) >= 0 ||
+ aURI.Find(KNSmlDdfDirection) >= 0 ||
+ aURI.Find(KNSmlDdfNAPName) >= 0 ) */
+ {
+ _DBG_FILE(
+ "Bearer | direction CNSmlInternetAdapter::UpdatelaefObject ( ): EError end");
+
+ AddLeafBufferL(aURI, aLUID, aObject, aType, aStatusRef, EFalse);
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ return;
+ }
+
+ iLeafType = EDMUpdate;
+
+ TRAP_IGNORE(AddLeafObjectL(aURI, aLUID, aObject, aType, aStatusRef));
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ //
+ // If try to update field that has value which is not default errorvalue should be returned
+ //
+ iLeafType = EDMUnset;
+
+ _DBG_FILE("CNSmlInternetAdapter::UpdateLeafObjectL(): end");
+
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::UpdateLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType )
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::UpdateLeafObjectL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/, TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::UpdateLeafObjectL(RWriteStream): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::UpdateLeafObjectL(RWriteStream): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::DeleteObjectL( const TDesC& aURI, const TDesC& aLUID,
+// const TInt aStatusRef )
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::DeleteObjectL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL( ): begin");
+ if (iTransactionCommitted)
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("DeleteObjectL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("DeleteObjectL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ iTransactionCommitted = EFalse;
+ }
+
+ if ((aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*")) != KErrNotFound)
+ && iWlanSupported)
+ {
+ iWlanAdapter->DeleteObjectL(aURI, aLUID, aStatusRef);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL( ): end");
+ return;
+ }
+
+ //
+ // Check which field going to be handled
+ //
+ SetField(aURI);
+
+ iLUID = IntLUID(aLUID);
+
+ TUint32 checkLUID = IntLUID(aLUID);
+ //
+ // Check which kind node to be deleted (Leaf delete not supported)
+ //
+ if (aURI.Match(_L8("AP/*")) != KErrNotFound && aURI.Match(_L8("AP/*/*"))
+ == KErrNotFound)
+ {
+ // Check if AP exists
+ if (!APExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): ENotFound end");
+ return;
+ }
+ if (DeleteAPL(checkLUID))
+ {
+ iPrevURI->Des().Format(KNullDesC8);
+ iPrevLUID = 0;
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EOk end");
+ return;
+ }
+ else
+ {
+ iPrevURI->Des().Format(KNullDesC8);
+ iPrevLUID = 0;
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EError end");
+ return;
+ }
+ }
+
+ if (aURI.Match(_L8("AP/*/Px/*/Startpg")) != KErrNotFound) //Key for WAP-delete
+ {
+ // Check if WAPAp exists
+ if (!WapAPExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): ENotFound end");
+ return;
+ }
+ if (DeleteWapAPL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EOk end");
+ return;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EError end");
+ return;
+ }
+ }
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/NAPDef/*/*")) == KErrNotFound)
+ {
+ // Check if NAPDef exists
+ if (!NAPDefExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): ENotFound end");
+ return;
+ }
+ if (DeleteNAPDefL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EOk end");
+ return;
+ }
+ }
+
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Px/*/*")) == KErrNotFound)
+ {
+ // Check if PX exists
+ if (!PxExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): ENotFound end");
+ return;
+ }
+ if (DeleteProxyL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL(): EOk end");
+ return;
+ }
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::DeleteObjectL( ): end");
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::FetchLeafObjectSizeL()
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::FetchLeafObjectSizeL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TDesC8& aType, TInt aResultsRef,
+ TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectSizeL(): begin");
+
+ DBG_ARGS8(_S8("AP:Fetch aURI - %S - %S"), &aURI, &aLUID);
+ CBufBase *lObject = CBufFlat::NewL(128);
+ CleanupStack::PushL(lObject);
+
+ // call to internal fetchleafobj.
+ CSmlDmAdapter::TError status = FetchLeafObjectL(aURI, aLUID, aType,
+ *lObject);
+
+ if (status == CSmlDmAdapter::EOk)
+ {
+ lObject->Compress();
+ TBuf8<8> size;
+ size.Num(lObject->Size());
+ lObject->Reset();
+ lObject->InsertL(0, size);
+ iCallBack->SetResultsL(aResultsRef, *lObject, aType);
+ }
+ iCallBack->SetStatusL(aStatusRef, status);
+
+ CleanupStack::PopAndDestroy(lObject);
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectSizeL(): end");
+
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::FetchLeafObjectL()
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::FetchLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TDesC8& aType, const TInt aResultsRef,
+ const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectL(): begin");
+
+ DBG_ARGS8(_S8("AP:Fetch aURI - %S - %S"), &aURI, &aLUID);
+ CBufBase *lObject = CBufFlat::NewL(128);
+ CleanupStack::PushL(lObject);
+
+ // Add call to internal fetchleafobj
+ CSmlDmAdapter::TError status = FetchLeafObjectL(aURI, aLUID, aType,
+ *lObject);
+ if (status == CSmlDmAdapter::EOk)
+ {
+ iCallBack->SetResultsL(aResultsRef, *lObject, aType);
+ }
+ iCallBack->SetStatusL(aStatusRef, status);
+
+ CleanupStack::PopAndDestroy(); //lObject
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectL(): end");
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CSmlDmInternetAdapter::FetchLeafObjectL()
+//------------------------------------------------------------------------------
+
+CSmlDmAdapter::TError CNSmlInternetAdapter::FetchLeafObjectL(
+ const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aType,
+ CBufBase& aObject)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectL(internal)(): begin");
+
+ TInt pushed = 0;
+ TUint32 iapID = 0;
+ TBool treeConstructed(EFalse);
+ //
+ // If no proxy no fetch allowed
+ //
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound)
+ {
+ if (!GetProxyIdL(aURI))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ if (!iLUID)
+ iLUID = IntLUID(aLUID);
+
+ iapID = GetAPIdFromURIL(aURI);
+
+ if (iapID == 0)
+ {
+ if (IsAPUriFormatMatchPredefined(aURI))
+ {
+ iLUID = ConstructTreeL(aURI);
+ iapID = GetAPIdFromURIL(aURI);
+ treeConstructed = ETrue;
+ }
+
+ }
+ // Check if values for Given LUID
+ if (!iLUID && (!IsWLANfield(aURI) || !iWlanSupported))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ //
+ // Check which field going to be handled
+ //
+ SetField(aURI);
+
+ aObject.Reset();
+
+ //Linger value
+ if ((iField->Compare(KNSmlDdfNAPLinger) == 0))
+ {
+ TInt lingerInterval;
+ TRAPD(err, GetLingerL(iapID, lingerInterval));
+ if (err == KErrNotFound)
+ {
+
+ return CSmlDmAdapter::ENotFound;
+ }
+ else if (err != KErrNone)
+ {
+
+ return CSmlDmAdapter::EError;
+
+ }
+ else
+ {
+ TBuf<10> slinger;
+ slinger.AppendNum(lingerInterval);
+
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(slinger));
+ CleanupStack::PopAndDestroy();
+ return CSmlDmAdapter::EOk;
+ }
+ }
+ TPtrC qTable = TPtrC(KNullDesC);
+ TPtrC qColumn = TPtrC(KNullDesC);
+ TPtrC qDB = TPtrC(COMMDB_ID);
+
+ if (aURI.Find(KNSmlDdfPortNbr) >= 0) // Check if WAP or PROXY port asked
+ {
+ _LIT8(KWap, "/WAP");
+ if (aURI.Find(KWap) >= 0)
+ {
+ iWapPort = ETrue;
+ }
+ else
+ {
+ iWapPort = EFalse;
+ }
+ }
+
+ if (iWlanSupported)
+ {
+ TBool wLANfield = IsWLANfield(aURI);
+ if (wLANfield)
+ {
+ //
+ // WLAN-adapter handles all WLAN fields
+ //
+ return iWlanAdapter->FetchLeafObjectL(aURI, aLUID, aType, aObject);
+ }
+ }
+
+ //
+ // Get Database field type
+ //
+ TInt fType = GetAPFieldType(aURI);
+
+ if (fType == EWrong)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EError end");
+ return CSmlDmAdapter::EError;
+ }
+ //
+ iISPId = iLUID;
+ //
+ // IAP-table search serviceType (=Bearer)
+
+ CCommsDbTableView* serviceView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ IAP), qDB, iapID);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId = 0;
+
+ TInt errorCode = serviceView->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ serviceView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ serviceView->ReadUintL(TPtrC(IAP_SERVICE), serviceId);
+ CleanupStack::PopAndDestroy(); // serviceView
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // serviceView
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+ qTable.Set(serviceType);
+
+ TBool allowed = GetAPField(qTable, qColumn);
+
+ if (!allowed)
+ {
+ if (aURI.Find(KNSmlDdfNAPAddrTy) >= 0) /* NAPAddrTy handling */
+ {
+ if (serviceType == TPtrC(OUTGOING_GPRS) || serviceType == TPtrC(
+ INCOMING_GPRS))
+ {
+ _LIT8(KApn, "APN");
+ aObject.InsertL(aObject.Size(), KApn);
+
+ }
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EOk;
+
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): FieldNot allowed");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EError;
+ }
+
+ if (fType == CNSmlInternetAdapter::EStr)
+ { // Name + NAPAddr + DNSAddrL
+ if (aURI.Match(_L8("AP/*/Networks/*/Name")) != KErrNotFound) // Networks-name
+ {
+ // TUint32 iapID8 = IntLUID(aLUID);
+
+ // IAP-table NetworkId Fetch
+ CCommsDbTableView* networkView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(
+ COMMDB_ID), iapID);
+ errorCode = networkView->GotoFirstRecord();
+ if (errorCode == KErrNone)
+ {
+ TRAPD(leavecode, networkView->ReadUintL(TPtrC(IAP_NETWORK),
+ iISPId));
+ CleanupStack::PopAndDestroy(); // networkView
+ if (leavecode != 0)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // networkView
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(NETWORK), TPtrC(COMMDB_ID), iISPId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+
+ tableView->ReadTextL(qColumn, columnValue);
+
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(columnValue));
+ pushed++;
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else if (aURI.Match(_L8("AP/*/Px/*/Name")) != KErrNotFound || // ProxyName
+ aURI.Match(_L8("AP/*/Px/*/PxAddr")) != KErrNotFound || // ProxyAddr
+ aURI.Match(_L8("AP/*/Px/*/DomainL")) != KErrNotFound) // DomainL (PROXY_PROTOCOL_NAME)
+ {
+ CCommsDbTableView* proxyView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(PROXIES), TPtrC(COMMDB_ID), iProxyId);
+
+ errorCode = proxyView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ if (aURI.Match(_L8("AP/*/Px/*/DomainL")) != KErrNotFound)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+
+ proxyView->ReadTextL(TPtrC(PROXY_PROTOCOL_NAME),
+ columnValue);
+
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(columnValue));
+ pushed++;
+ }
+
+ else if (aURI.Match(_L8("AP/*/Px/*/PxAddr")) != KErrNotFound)
+ {
+ HBufC* serverName = proxyView->ReadLongTextLC(TPtrC(
+ PROXY_SERVER_NAME));
+ pushed++;
+
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(*serverName));
+ pushed++;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // proxyView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else
+ {
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, qDB, serviceId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ if (aURI.Find(KNSmlDdfDNSPriority) >= 0) /* DNSPriority */
+ {
+ UriUtils::TUriHostType theType;
+ TInt dnsPri;
+
+ // This resets iLUID to match aLUID, which is needed in this case.
+ // Otherwise iLUID has a different value
+ if (!treeConstructed)
+ iLUID = IntLUID(aLUID);
+
+ if (LuidToDns(theType, dnsPri, iLUID) == KErrNone)
+ {
+ if (dnsPri == 1)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlFirstDNSPri);
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNSmlSecondDNSPri);
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(tableView); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else if (aURI.Find(KNSmlDdfDNSAddrTy) >= 0) /* DNSAddrTy */
+ {
+ UriUtils::TUriHostType theType;
+ TInt dnsPri;
+ // This resets iLUID to match aLUID, which is needed in this case.
+ // Otherwise iLUID has a different value
+ if (!treeConstructed)
+ iLUID = IntLUID(aLUID);
+ if (LuidToDns(theType, dnsPri, iLUID) == KErrNone)
+ {
+ if (theType == UriUtils::EIPv4Host)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDNSIp);
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDNSIp6);
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(tableView); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+ if (aURI.Find(KNSmlDdfDNSAddrL) >= 0)
+ {
+ UriUtils::TUriHostType theType;
+ TInt dnsPri;
+
+ // This resets iLUID to match aLUID, which is needed in this case.
+ // Otherwise iLUID has a different value
+ if (!treeConstructed)
+ iLUID = IntLUID(aLUID);
+ if (LuidToDns(theType, dnsPri, iLUID) == KErrNone)
+ {
+ if (dnsPri == 1)
+ {
+ if (theType == UriUtils::EIPv4Host)
+ {
+ qColumn.Set(
+ TPtrC(SERVICE_IP_NAME_SERVER1));
+ }
+ else
+ {
+ qColumn.Set(TPtrC(
+ SERVICE_IP6_NAME_SERVER1));
+
+ }
+ }
+ else
+ {
+ if (theType == UriUtils::EIPv4Host)
+ {
+ qColumn.Set(
+ TPtrC(SERVICE_IP_NAME_SERVER2));
+ }
+ else
+ {
+ qColumn.Set(TPtrC(
+ SERVICE_IP6_NAME_SERVER2));
+
+ }
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(tableView); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ TRAPD(leavecode, tableView->ReadTextL(qColumn,
+ columnValue));
+ if (leavecode != 0)
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(columnValue));
+ pushed++;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+ else if (fType == CNSmlInternetAdapter::EBool)
+ { // UseCB
+ CCommsDbTableView* boolView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, qDB, serviceId);
+
+ errorCode = boolView->GotoFirstRecord();
+
+ TBool objectBool = EFalse;
+ if (errorCode == KErrNone)
+ {
+ TRAPD(leavecode, boolView->ReadBoolL(qColumn, objectBool));
+ if (leavecode == KErrUnknown) // value is null
+ {
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // boolView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EError end");
+ return CSmlDmAdapter::EError;
+ }
+
+ if (objectBool)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValTrue);
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValFalse);
+ }
+
+ CleanupStack::PopAndDestroy(); // boolView
+ }
+ else if (fType == CNSmlInternetAdapter::EInt)
+ { // NAPId +Bearer + NAPAddrTy + PxID + PortNbr + UsePTxtLog
+ // CBTy + LnkSpeed
+
+ if (aURI.Match(_L8("AP/*/Px/*/PxID")) != KErrNotFound)
+ {
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(iISPId));
+ pushed++;
+ }
+
+ else if (aURI.Find(KNSmlDdfIAPSeamlessness) >= 0) /* Seamlessness handling */
+ {
+ TInt seam = GetIAPSeamlessnessL(iapID);
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(seam));
+ pushed++;
+ }
+ else if (aURI.Find(KNSmlDdfIAPMetaData) >= 0)
+ {
+ TInt meta = GetIAPMetaDataL(iapID);
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(meta));
+ pushed++;
+ }
+
+ else if (aURI.Match(_L8("AP/*/Networks/*/ID")) != KErrNotFound)
+ {
+
+ iISPId = IntLUID(aLUID);
+
+ CCommsDbTableView* nwidView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iISPId);
+ if (nwidView->GotoFirstRecord() == KErrNone)
+ {
+ nwidView->ReadUintL(TPtrC(IAP_NETWORK), iISPId);
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(iISPId));
+ pushed++;
+ }
+ CleanupStack::PopAndDestroy(); // nwidView
+ }
+ else if (aURI.Match(_L8("AP/*/Px/*/PortNbr")) != KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): PortNbr");
+ DBG_ARGS8(_S8("iISPId = %d "), iISPId);
+ DBG_ARGS8(_S8("proxyid = %d "), iProxyId);
+ CCommsDbTableView* portView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(PROXIES), TPtrC(COMMDB_ID), iProxyId);
+
+ errorCode = portView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): Portview opened");
+ TUint32 object32 = 0;
+
+ TRAPD(leavecode, portView->ReadUintL(qColumn, object32));
+ if (leavecode == KErrNone)
+ {
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(object32));
+ pushed++;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): db read failed");
+ CleanupStack::PopAndDestroy(); // portView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EError end");
+ return CSmlDmAdapter::EError;
+ }
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): Portview opening failed");
+ CleanupStack::PopAndDestroy(); // portView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ CleanupStack::PopAndDestroy(); // portView
+ }
+ else if (aURI.Match(_L8("AP/*/NAPID")) != KErrNotFound || aURI.Match(
+ _L8("AP/*/ToNAPIDL")) != KErrNotFound)
+ {
+ iObject = iapID;
+ TPtrC8 napidUri = FirstURISeg(aURI);
+ aObject.InsertL(aObject.Size(), napidUri);
+
+ }
+ else
+ {
+ iObject = 0;
+
+ CCommsDbTableView* colView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, qDB, serviceId);
+
+ errorCode = colView->GotoFirstRecord();
+
+ TUint32 object32 = 0;
+ if (errorCode == KErrNone)
+ {
+ if (aURI.Find(KNSmlDdfUsePTxtLog) >= 0)
+ {
+ TBool objectBool = EFalse;
+ TRAPD(leavecode, colView->ReadBoolL(qColumn, objectBool));
+ errorCode = leavecode;
+ object32 = objectBool;
+ }
+ else
+ {
+ TRAPD(leavecode, colView->ReadUintL(qColumn, object32));
+ errorCode = leavecode;
+ }
+ }
+
+ if (errorCode == KErrNone)
+ {
+
+ if (aURI.Find(KNSmlDdfNAPAddrTy) >= 0 || /* NAPAddrTy handling */
+ aURI.Find(KNSmlDdfGPRSPDP) >= 0) /* NAPAddrTy handling */
+ {
+ if (object32 == RPacketContext::EPdpTypeIPv4)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValIpv4);
+ }
+ else if (object32 == RPacketContext::EPdpTypeIPv6)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValIpv6);
+ }
+ else if (object32 == RPacketContext::EPdpTypePPP)
+ {
+ _LIT8(KPpp, "PPP");
+ aObject.InsertL(aObject.Size(), KPpp);
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNullDesC8);
+ }
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(object32));
+ pushed++;
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // colView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ CleanupStack::PopAndDestroy(); // colView
+ }
+ }
+
+ else if (fType == CNSmlInternetAdapter::EWap)
+ { // Startpg + PxAuthId + PxAuthPW + PortNbr (BasAuthId + BasAuthPW)
+ CCommsDbTableView* wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ WAP_IP_BEARER), TPtrC(WAP_IAP), iapID);
+
+ errorCode = wapView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+
+ if (qColumn == TPtrC(WAP_START_PAGE))
+ {
+ TRAPD(leavecode, wapView->ReadUintL(
+ TPtrC(WAP_ACCESS_POINT_ID), iWapId));
+ CleanupStack::PopAndDestroy(); // wapView
+ if (leavecode != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EError end");
+ return CSmlDmAdapter::EError;
+
+ }
+
+ CCommsDbTableView* wapView2 =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(
+ WAP_ACCESS_POINT), TPtrC(COMMDB_ID), iWapId);
+
+ errorCode = wapView2->GotoFirstRecord();
+ if (errorCode != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(); // wapView2
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ HBufC* tmpVal = wapView2->ReadLongTextLC(qColumn);
+
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(tmpVal->Des()));
+ CleanupStack::PopAndDestroy(); // ReadLongTextLC
+ CleanupStack::PopAndDestroy(); // wapView2
+ pushed++;
+ }
+ else
+ {
+ if (qColumn == TPtrC(WAP_PROXY_PORT))
+ {
+ TUint32 object32;
+ wapView->ReadUintL(qColumn, object32);
+ if (object32 == KWAPP_PORT_9200) // wappdef.h
+ {
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(
+ KWappPort9200));
+ }
+ else if (object32 == KWAPP_PORT_9201)
+ {
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(
+ KWappPort9201));
+ }
+ else if (object32 == KWAPP_PORT_9202)
+ {
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(
+ KWappPort9202));
+ }
+ else if (object32 == KWAPP_PORT_9203)
+ {
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(
+ KWappPort9203));
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // wapView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ pushed++;
+ }
+ else
+ {
+ wapView->ReadTextL(qColumn, columnValue);
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(columnValue));
+ pushed++;
+ }
+ CleanupStack::PopAndDestroy(); // wapView
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // wapView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ }
+ else if (fType == CNSmlInternetAdapter::ESpec)
+ {
+ // name
+ if (aURI.Find(KNSmlDdfNAPName) >= 0)
+ {
+ TUint32 iapID10 = IntLUID(aLUID);
+ /* CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(serviceType,
+ qDB,
+ serviceId);*/
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+ TRAPD(leavecode, tableView->ReadTextL(TPtrC(COMMDB_NAME),
+ columnValue));
+ if (leavecode != 0)
+ {
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+ aObject.InsertL(aObject.Size(), ConvertTo8LC(columnValue));
+ pushed++;
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EOk;
+ }
+ // BearerL + NoPxForL + IAPService
+ else if (aURI.Find(KNSmlDdfIAPService) >= 0)
+ {
+ aObject.InsertL(aObject.Size(), SetIntObjectLC(serviceId));
+ pushed++;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EOk end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EOk;
+ }
+ else if (aURI.Find(KNSmlDdfNoPxForL) >= 0) /* No proxies used handling */
+ {
+ TBool proxyFound = GetProxyIdL(aURI);
+ if (!proxyFound)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ CCommsDbTableView* exeptionView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES), TPtrC(
+ COMMDB_ID), iProxyId);
+ errorCode = exeptionView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ HBufC* proxyExceptions = exeptionView->ReadLongTextLC(TPtrC(
+ PROXY_EXCEPTIONS));
+ pushed++;
+
+ aObject.InsertL(aObject.Size(),
+ ConvertTo8LC(*proxyExceptions));
+ pushed++;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+ CleanupStack::PopAndDestroy(); // exeptionView
+
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)()(): EOk end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EOk;
+ }
+
+ if (aURI.Find(KNSmlDdfDirection) >= 0)
+ {
+ if (serviceType == TPtrC(OUTGOING_GPRS))
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValOutgoing);
+ }
+ else if (serviceType == TPtrC(INCOMING_GPRS))
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValIncoming);
+ }
+ else if (serviceType == TPtrC(LAN_SERVICE)) // Wlan ADD
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValOutgoing);
+ }
+ else if (serviceType == TPtrC(VPN_SERVICE))
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValOutgoing);
+ }
+ else
+ {
+ _LIT8(KDirectionUnk, "DirectionUnknown");
+ aObject.InsertL(aObject.Size(), KDirectionUnk);
+ }
+ }
+ else
+ {
+ if (serviceType == TPtrC(OUTGOING_GPRS) || serviceType == TPtrC(
+ INCOMING_GPRS))
+ {
+ if (i3GPPPS)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApVal3Gppps);
+ i3GPPPS = EFalse;
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValGsmGprs);
+ }
+
+ }
+
+ else if (serviceType == TPtrC(OUTGOING_GPRS) || serviceType
+ == TPtrC(INCOMING_GPRS))
+ {
+ if (i3GPPPS)
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApVal3Gppps);
+ i3GPPPS = EFalse;
+ }
+ else
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValGsmGprs);
+ }
+
+ }
+ else if (serviceType == TPtrC(VPN_SERVICE))
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValVpn);
+ }
+
+ else if ((serviceType == TPtrC(LAN_SERVICE) && iWlanSupported))
+ {
+ aObject.InsertL(aObject.Size(), KNSmlDmApValWlan);
+ }
+ else
+ {
+ _LIT8(KUnkBearer, "Unknown Bearer");
+ aObject.InsertL(aObject.Size(), KUnkBearer);
+ }
+ }
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::FetchLeafObjectL(internal)(): ENotFound end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::FetchLeafObjectL(internal)(): end");
+ CleanupStack::PopAndDestroy(pushed);
+ return CSmlDmAdapter::EOk;
+
+ }
+
+//------------------------------------------------------------------------------
+// CSmlDmAdapter::ChildURIListL()
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::ChildURIListL(const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList,
+ const TInt aResultsRef, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): begin");
+ DBG_ARGS8(_S8("AP:ChildURIListL URI - <%S> <%S>"), &aURI, &aLUID);
+
+ CBufBase* currentURISegmentList = CBufFlat::NewL(128);
+ CleanupStack::PushL(currentURISegmentList);
+
+ TUint32 checkLUID = IntLUID(aLUID);
+
+ // If this is command to proxy node we'll need to make sure that
+ // the LUID is for proxy node and not AP node.
+ // If this command comes to predefined AP node then
+ // the LUID passed is inherited from that node and is not
+ // proper proxy node.
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound)
+ {
+ TLex8 lex(aLUID);
+ TUint tempLUID;
+ if (!((lex.Val(tempLUID) == KErrNone) && (tempLUID
+ > KNSmlApProxyLowerBase)
+ && (tempLUID < KNSmlApProxyUpperBase)))
+ {
+ // Non-proxy LUID
+ checkLUID = 0;
+ }
+ }
+
+ // Fetch all data for child
+ if (!checkLUID && (!IsWLANfield(aURI) || !iWlanSupported))
+ {
+ if (aURI.Match(KNSmlDdfAP) == KErrNotFound) // Not for AP
+ {
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ return;
+ }
+ }
+
+ TUint32 apId = GetAPIdFromURIL(aURI);
+
+ if (aURI.Match(_L8("AP/*")) != KErrNotFound && !APExistsL(apId))
+ {
+ if (aLUID.Length() > 0)
+ {
+ // Stale data, remove mapping.
+ TInt ret = iCallBack->RemoveMappingL(KNSmlInternetAdapterImplUid,
+ GetDynamicAPNodeUri(aURI), ETrue);
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): AP doesn't exist: ENotFound end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*")) != KErrNotFound && aURI.Match(_L8("AP/*/*"))
+ == KErrNotFound)
+ {
+ // Check if AP exists
+ if (!APExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ return;
+ }
+ currentURISegmentList->InsertL(0, KNSmlAPnode);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): end");
+ return;
+ }
+
+ // Check that queried proxy exists
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound && !PxExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Px/*/*")) == KErrNotFound)
+ {
+ // Check if PX exists
+ if (!PxExistsL(checkLUID))
+ {
+ // Only WAP-data
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ return;
+ }
+ // List all Px
+ currentURISegmentList->InsertL(0, KNSmlPxnode);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): OK end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/NAPDef/*/*")) == KErrNotFound)
+ {
+ // Check if IAP has luid mapped
+ HBufC8* iapIdBuf = iCallBack->GetLuidAllocL(RemoveLastSeg(aURI));
+ TInt iapIdInt = GetIntObject8(iapIdBuf->Des());
+
+ delete iapIdBuf;
+ iapIdBuf = NULL;
+
+ if (iapIdInt > 0)
+ {
+ CCommsDbTableView* iapView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapIdInt);
+ TInt error = iapView->GotoFirstRecord();
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ if (error == KErrNone)
+ {
+ iapView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ }
+ CleanupStack::PopAndDestroy(iapView);
+
+ // Check if NAPDef exists
+ if (!NAPDefExistsL(checkLUID))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): ENotFound end");
+ return;
+ }
+ // List all NAPDef
+ if (IsWlanL(aURI) && iWlanSupported)
+ {
+ iWlanAdapter->ChildURIListL(aURI, aLUID,
+ aPreviousURISegmentList, aResultsRef, aStatusRef);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): WLAN end");
+ return;
+ }
+ _LIT(KGprs, "*GPRS*");
+ _LIT(K3gppps, "*3GPPPS*");
+ if (serviceType.Match(KGprs) != KErrNotFound
+ || serviceType.Match(K3gppps) != KErrNotFound)
+ {
+ currentURISegmentList->InsertL(0, KNSmlNAPDefGPRSnode);
+ }
+
+#ifdef __SYNCML_DM_LSCRIPT
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),KNSmlLoginscriptnode);
+#endif
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): end");
+ return;
+ }
+
+ if ((aURI.Match(_L8("AP/*/WLAN")) != KErrNotFound || aURI.Match(_L8(
+ "AP/*/WLAN/*")) != KErrNotFound) && iWlanSupported)
+ {
+ iWlanAdapter->ChildURIListL(aURI, aLUID, aPreviousURISegmentList,
+ aResultsRef, aStatusRef);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): WLAN end");
+ return;
+ }
+ //
+ // Get all AP numbers from IAP-table
+ //
+ if (aURI.Match(KNSmlDdfAP) != KErrNotFound)
+ {
+ TBool inDatabase = EFalse;
+
+ CCommsDbTableView* apView = iDatabase->OpenTableLC(TPtrC(IAP));
+
+ TInt errorCode = apView->GotoFirstRecord();
+
+ while (errorCode == KErrNone)
+ {
+ TUint32 lValue;
+ TBool validService = EFalse;
+ TInt lLine(0);
+ apView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ apView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ TUint32 bearerId = 0;
+ apView->ReadUintL(TPtrC(IAP_BEARER), bearerId);
+ //
+ // Skip other service types than GSM outgoing
+ //
+ if (serviceType == TPtrC(OUTGOING_GPRS) || serviceType == TPtrC(
+ INCOMING_GPRS))
+ {
+ validService = ETrue;
+ }
+
+ else if (serviceType == TPtrC(LAN_SERVICE) && bearerId > 1)
+ {
+ validService = ETrue;
+ }
+ else if (serviceType == TPtrC(VPN_SERVICE))
+ {
+ validService = ETrue;
+ }
+ else if ((serviceType == TPtrC(LAN_SERVICE)) && iWlanSupported)
+ {
+ validService = ETrue;
+ }
+
+ if (validService)
+ {
+ // Skip others
+ //
+ // Check if in aPreviousURISegmentList
+ //
+ while (!inDatabase && lLine < aPreviousURISegmentList.Count())
+ {
+ TUint32 list = GetIntObject8(aPreviousURISegmentList.At(
+ lLine).iURISegLUID);
+ if (list == lValue)
+ {
+ inDatabase = ETrue;
+ }
+ else
+ {
+ lLine++;
+ }
+ }
+
+ if (inDatabase)
+ {
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(lLine).iURISeg);
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ inDatabase = EFalse;
+ DBG_ARGS8(_S8("InList: Id = %d Name %S"), lValue,
+ &aPreviousURISegmentList.At(lLine).iURISeg);
+
+ }
+ else
+ {
+ _LIT8(Kprev, "APId");
+ TBuf8<9> addNAME(Kprev); // APIdnnn , nnn = profileid
+ addNAME.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), addNAME);
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ DBG_ARGS8(_S8("NotInList: Id = %d Name %S"), lValue,
+ &addNAME);
+
+ // KNSmlDMStart includes start text for URISeg
+ TBuf8<20> addURI; // AP/APIdnnn , nnn = profileid
+ addURI.Append(_L8("AP/APId"));
+ addURI.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, lValue);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ } // Skip
+ errorCode = apView->GotoNextRecord();
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(2); // apView, currentURISegmentList
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): AP end");
+ return;
+ }
+
+ iISPId = IntLUID(aLUID);
+
+ //
+ // Get all NAPDef numbers
+ //
+ if (aURI.Match(_L8("AP/*/NAPDef")) != KErrNotFound)
+ {
+ TBool inDatabase = EFalse;
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId;
+
+ CCommsDbTableView* napdefView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iISPId);
+
+ TInt errorCode = napdefView->GotoFirstRecord();
+
+ if (errorCode != KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): NAPDef error end");
+ CleanupStack::PopAndDestroy(2); // napdefView, currentURISegmentList
+ return;
+ }
+ else
+ {
+ napdefView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ napdefView->ReadUintL(TPtrC(IAP_SERVICE), serviceId); // ID
+ CleanupStack::PopAndDestroy(); // napdefView
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, TPtrC(COMMDB_ID), serviceId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ while (errorCode == KErrNone)
+ {
+ TUint32 lValue;
+ TInt lLine(0);
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+ //
+ // Check if in aPreviousURISegmentList
+ //
+ while (!inDatabase && lLine < aPreviousURISegmentList.Count())
+ {
+ TUint32 list = GetIntObject8(
+ aPreviousURISegmentList.At(lLine).iURISegLUID);
+ if (list == lValue)
+ {
+ inDatabase = ETrue;
+ }
+ else
+ {
+ lLine++;
+ }
+ }
+
+ if (inDatabase)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(lLine).iURISeg);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+ inDatabase = EFalse;
+ }
+ else
+ {
+ _LIT8(Kprev, "NAPId");
+ TBuf8<15> addNAME(Kprev); // APIdnnn , nnn = profileid
+ addNAME.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ _LIT8(Kprev2, "/NAPId");
+ TBuf8<80> addURI; // AP/xxx/NAPDef/NAPIdnnn , nnn = id nbr
+ addURI.Append(aURI);
+ addURI.Append(Kprev2);
+ addURI.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, lValue);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ errorCode = tableView->GotoNextRecord();
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(2); // tableView, currentURISegmentList
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): AP end");
+ return;
+ }
+
+ // Get all Px numbers
+ // Check also AP-nbr + serviceType and nbr for Proxy
+ // To get right data for AP
+ //
+ if (aURI.Match(_L8("AP/*/Px")) != KErrNotFound)
+ {
+ TBool inDatabase = EFalse;
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 ServiceIsp;
+
+ CCommsDbTableView* pxView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ IAP), TPtrC(COMMDB_ID), iISPId);
+
+ TInt errorCode = pxView->GotoFirstRecord();
+
+ if (errorCode != KErrNone)
+ {
+ CleanupStack::PopAndDestroy(2); // pxView, currentURISegmentList
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): NAPDef error end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ else
+ {
+ pxView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType); // Type
+ pxView->ReadUintL(TPtrC(IAP_SERVICE), ServiceIsp); // ID
+ CleanupStack::PopAndDestroy(); // pxView
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingTextLC(
+ TPtrC(PROXIES), TPtrC(PROXY_SERVICE_TYPE), serviceType);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ TBool proxyFound(false);
+ while (errorCode == KErrNone)
+ {
+ TUint32 lProxyIspId;
+ TUint32 lProxyId;
+ TInt lLine(0);
+ tableView->ReadUintL(TPtrC(PROXY_ISP), lProxyIspId);
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lProxyId);
+ if (lProxyIspId == ServiceIsp) // Right value ISP
+ {
+ proxyFound = true;
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lProxyId);
+ //
+ // Check if in aPreviousURISegmentList
+ //
+ while (!inDatabase && lLine < aPreviousURISegmentList.Count())
+ {
+ TUint32 list = GetIntObject8(aPreviousURISegmentList.At(
+ lLine).iURISegLUID) - KNSmlApProxyLowerBase;
+ if (list == lProxyId)
+ {
+ inDatabase = ETrue;
+ }
+ else
+ {
+ lLine++;
+ }
+ }
+
+ if (inDatabase)
+ {
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(lLine).iURISeg);
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ inDatabase = EFalse;
+ DBG_ARGS8(_S8("InList: Id = %d Name %S"), lProxyId
+ + KNSmlApProxyLowerBase,
+ &aPreviousURISegmentList.At(lLine).iURISeg);
+ }
+ else
+ {
+ _LIT8(Kprev, "PXId");
+ TBuf8<9> addNAME(Kprev); // PXIdnnn , nnn = profileid
+ addNAME.AppendNumFixedWidth(lProxyId, EDecimal, 3);
+
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), addNAME);
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ DBG_ARGS8(_S8("NotInList: Id = %d Name %S"), lProxyId,
+ &addNAME);
+ TBuf8<80> addURI; // AP/xxx/Px/PXIdnnn , nnn = id nbr
+ addURI.Append(aURI);
+ _LIT8(KPxid, "/PXId");
+ addURI.Append(KPxid);
+ addURI.AppendNumFixedWidth(lProxyId, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, KNSmlApProxyLowerBase + lProxyId); // 100000 + lProxyId
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ }
+ errorCode = tableView->GotoNextRecord();
+ }
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): AP end");
+ if (proxyFound)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ }
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(2); // tableView, currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Bearer/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Bearer/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(), (_L8(
+ "BearerL/Direction"))); // Direction
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): BearerL end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Bearer")) != KErrNotFound)
+ {
+ if (aPreviousURISegmentList.Count() > 0) // Allready mapped
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(0).iURISeg);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+ }
+ else
+ {
+ _LIT8(Kprev, "BId");
+ TBuf8<9> addNAME(Kprev); // Id
+ addNAME.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ TBuf8<80> addURI; // AP/xxx/NapDef/Bearer/BIdn , n=aLUID
+ addURI.Append(aURI);
+ _LIT8(KBid, "/BId");
+ addURI.Append(KBid);
+ addURI.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, checkLUID);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Bearer end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/DNSAddr/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/DNSAddr/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDNSAddrNode);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): DNSAddrL end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/DNSAddr")) != KErrNotFound)
+ {
+
+ TBuf<KCommsDbSvrMaxFieldLength> ServType;
+ TUint32 servId;
+
+ CCommsDbTableView* napdefView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iISPId);
+
+ TInt errorCode = napdefView->GotoFirstRecord();
+
+ if (errorCode != KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): DNSAddr error end");
+ CleanupStack::PopAndDestroy(2); // napdefView, currentURISegmentList
+ return;
+ }
+ else
+ {
+ napdefView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), ServType);
+ napdefView->ReadUintL(TPtrC(IAP_SERVICE), servId); // ID
+ CleanupStack::PopAndDestroy(napdefView); // napdefView
+ }
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ ServType, TPtrC(COMMDB_ID), servId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode != KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): DNSAddr error end");
+ CleanupStack::PopAndDestroy(2); // tableView, currentURISegmentList
+ return;
+ }
+ else
+ {
+ // Now we can read DNSAddrL values
+ TInt leavecode;
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+ TBuf8<16> addLUID;
+ TBuf8<80> addURI; // AP/xxx/NAPDef/DNSAddr/DNSx
+ _LIT8(KFormat, "%d");
+ TRAP(leavecode, tableView->ReadTextL(TPtrC(
+ SERVICE_IP_NAME_SERVER1), columnValue));
+ if ((leavecode == KErrNone) && (columnValue.Length() > 0))
+ {
+ addURI.Append(aURI);
+ addURI.Append(KNSmlDNS1);
+ _LIT8(KDns1, "DNS1");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KDns1);
+ addLUID.Format(KFormat, DnsToLuid(UriUtils::EIPv4Host, 1));
+ iCallBack->SetMappingL(addURI, addLUID);
+ addURI.Zero();
+ }
+
+ TRAP(leavecode, tableView->ReadTextL(TPtrC(
+ SERVICE_IP_NAME_SERVER2), columnValue));
+ if (leavecode == KErrNone && (columnValue.Length() > 0))
+ {
+ if (currentURISegmentList->Size() > 0)
+ {
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ }
+ addURI.Append(aURI);
+ addURI.Append(KNSmlDNS2);
+ _LIT8(KDns2, "DNS2");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KDns2);
+ addLUID.Format(KFormat, DnsToLuid(UriUtils::EIPv4Host, 2));
+ iCallBack->SetMappingL(addURI, addLUID);
+ addURI.Zero();
+ }
+
+ TRAP(leavecode, tableView->ReadTextL(TPtrC(
+ SERVICE_IP6_NAME_SERVER1), columnValue));
+ if (leavecode == KErrNone && (columnValue.Length() > 0))
+ {
+ if (currentURISegmentList->Size() > 0)
+ {
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ }
+ addURI.Append(aURI);
+ addURI.Append(KNSmlDNS3);
+ _LIT8(KDns3, "DNS3");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KDns3);
+ addLUID.Format(KFormat, DnsToLuid(UriUtils::EIPv6Host, 1));
+ iCallBack->SetMappingL(addURI, addLUID);
+ addURI.Zero();
+ }
+
+ TRAP(leavecode, tableView->ReadTextL(TPtrC(
+ SERVICE_IP6_NAME_SERVER2), columnValue));
+ if (leavecode == KErrNone && (columnValue.Length() > 0))
+ {
+ if (currentURISegmentList->Size() > 0)
+ {
+ currentURISegmentList->InsertL(
+ currentURISegmentList->Size(), KNSmlDmApValFSlash);
+ }
+ addURI.Append(aURI);
+ addURI.Append(KNSmlDNS4);
+ _LIT8(KDns4, "DNS4");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KDns4);
+ addLUID.Format(KFormat, DnsToLuid(UriUtils::EIPv6Host, 2));
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): DNSAddr end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(tableView);
+ CleanupStack::PopAndDestroy(currentURISegmentList); // currentURISegmentList
+ }
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Port/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Port/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDdfPortNbr);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Port end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Port")) != KErrNotFound)
+ {
+
+ TUint32 iapID10 = GetAPIdFromURIL(aURI);
+
+ if (WapAPExistsL(iapID10)) // WapPort
+ {
+ TBuf8<80> addURI; // AP/xxx/Px/Port/WAP
+ addURI.Append(aURI);
+ _LIT8(KWap, "/WAP");
+ addURI.Append(KWap);
+ _LIT8(KWap2, "WAP/");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KWap2);
+ }
+
+ if (PxExistsL(checkLUID)) // ProxyPort
+ {
+ TBuf8<80> addURI; // AP/xxx/Px/Port/PROXY
+ addURI.Append(aURI);
+ _LIT8(KProxy, "/PROXY");
+ addURI.Append(KProxy);
+ _LIT8(KProxy2, "PROXY/");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KProxy2);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Port end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/NAPAuthInf/*")) != KErrNotFound && aURI.Match(
+ _L8("AP/*/NAPAuthInf/*/*")) == KErrNotFound)
+ {
+ _LIT8(KAuthFields, "AuthName/AuthSecr");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KAuthFields));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NAPAuthInfL end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/NAPAuthInf")) != KErrNotFound)
+ {
+ _LIT8(Kprev, "AUId");
+ TBuf8<9> addNAME(Kprev); // Id
+ addNAME.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(), addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ TBuf8<80> addURI; // AP/xxx/NapDef/NAPAuthInf/AUIdn , n=aLUID
+ addURI.Append(aURI);
+ _LIT8(KAuid, "/AUId");
+ addURI.Append(KAuid);
+ addURI.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, checkLUID);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NAPAuthInf end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/PxAuthInf/*")) != KErrNotFound && aURI.Match(
+ _L8("AP/*/PxAuthInf/*/*")) == KErrNotFound)
+ {
+ _LIT8(KPxAuthFields, "PxAuthId/PxAuthPW");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KPxAuthFields));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NAPAuthInfL end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/PxAuthInf")) != KErrNotFound)
+ {
+ _LIT8(Kprev, "AUPxId");
+ TBuf8<11> addNAME(Kprev); // Id
+ addNAME.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(), addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ TBuf8<80> addURI; // AP/xxx/Px/PxAuthInf/AUPxIdn , n=aLUID
+ addURI.Append(aURI);
+ _LIT8(KAupxid, "/AUPxId");
+ addURI.Append(KAupxid);
+ addURI.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NAPAuthInf end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/ToNAPID/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/ToNAPID/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KNSmlDdfToNAPIDL));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ToNAPIDL end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/ToNAPID")) != KErrNotFound)
+ {
+ _LIT8(Kprev, "TId");
+ TBuf8<9> addNAME(Kprev); // Id
+ addNAME.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(), addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ TBuf8<80> addURI; // AP/xxx/NapDef/ToNAPID/TIdn , n=aLUID
+ addURI.Append(aURI);
+ _LIT8(KTid, "/TId");
+ addURI.Append(KTid);
+ addURI.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): ToNAPID end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Networks/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Networks/*/*")) == KErrNotFound)
+ {
+ _LIT8(KNameId, "Name/ID");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KNameId));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Networks end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Networks")) != KErrNotFound)
+ {
+ checkLUID = GetAPIdFromURIL(aURI);
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), checkLUID);
+
+ TInt errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ TUint32 nwLUID = 0;
+ tableView->ReadUintL(TPtrC(IAP_NETWORK), nwLUID); // Networks luid
+ if (!NetworkExistsL(nwLUID))
+ {
+ errorCode = KErrNotFound;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // tableView
+
+ if (errorCode != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ChildURIListL(): Networks error end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ return;
+ }
+
+ if (aPreviousURISegmentList.Count() > 0) // Allready mapped
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(0).iURISeg);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+ }
+ else
+ {
+ _LIT8(Kprev, "NwId");
+ TBuf8<9> addNAME(Kprev); // Id
+ addNAME.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ addNAME);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+
+ TBuf8<80> addURI; // AP/xxx/NapDef/Networks/NwIdn , n=aLUID
+ addURI.Append(aURI);
+ _LIT8(KNwid, "/NwId");
+ addURI.Append(KNwid);
+ addURI.AppendNumFixedWidth(checkLUID, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, checkLUID);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ }
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Networks end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/NoPxFor/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/NoPxFor/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KNSmlDdfNoPxForL));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NoPxFor end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/NoPxFor")) != KErrNotFound)
+ {
+ if (aPreviousURISegmentList.Count() > 0) // Allready mapped
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(0).iURISeg);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+ }
+ else
+ {
+ _LIT8(KexepPrev, "eXC");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KexepPrev);
+ }
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): NoPxFor end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Domain/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/Domain/*/*")) == KErrNotFound)
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ (KNSmlDdfDomainL));
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Domain end");
+ return;
+ }
+
+ if (aURI.Match(_L8("AP/*/Domain")) != KErrNotFound)
+ {
+ if (aPreviousURISegmentList.Count() > 0) // Allready mapped
+ {
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(0).iURISeg);
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KNSmlDmApValFSlash);
+ }
+ else
+ {
+ _LIT8(KexepPrev, "dOM");
+ currentURISegmentList->InsertL(currentURISegmentList->Size(),
+ KexepPrev);
+ }
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): Domain end");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList,
+ KNullDesC8);
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentURISegmentList, KNullDesC8);
+ _DBG_FILE("CNSmlInternetAdapter::ChildURIListL(): end");
+
+ CleanupStack::PopAndDestroy(); // currentURISegmentList
+
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::AddNodeBufferL()
+// Inserts new AP-data to database
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::AddNodeBufferL(const TDesC8& aURI,
+ const TDesC8& /*aParentLUID*/, const TInt aStatusRef,
+ const TBool aDnsUpd, const TBool aWlan)
+ {
+ TInt index = -1;
+
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ TPtrC8 parentUri = FirstURISeg(aURI);
+ if (iBuffer->At(i).iMappingName->Compare(parentUri) == 0)
+ {
+ index = i;
+ break;
+ }
+ }
+
+ if (index < 0)
+ {
+ TNSmlAPBufferElement newNode;
+ newNode.iMappingName = aURI.AllocLC();
+
+ NextAPNameL(*LastURISeg(aURI).AllocLC());
+ CleanupStack::PopAndDestroy();
+
+ newNode.iName = iIAPName.AllocLC();
+ newNode.iNodeBuf = new (ELeave) CArrayFixFlat<TNSmlAPAddElement> (
+ KNSmlAPGranularity);
+ newNode.iWlanNodeBuf
+ = new (ELeave) CArrayFixFlat<TNSmlAPAddElement> (
+ KNSmlAPGranularity);
+ newNode.iExecuted = EFalse;
+ newNode.iBearer = EFalse;
+ newNode.iDirection = EFalse;
+ newNode.iNameReceived = EFalse;
+ if (aDnsUpd)
+ {
+ newNode.iDnsUpdateBuf = ETrue;
+ }
+ else
+ {
+ newNode.iDnsUpdateBuf = EFalse;
+ }
+ newNode.iLuid = 0;
+ iBuffer->AppendL(newNode);
+ CleanupStack::Pop(2); //newNode.iMappingName,newNode.iName
+
+ index = iBuffer->Count() - 1;
+ }
+
+ if (!aDnsUpd)
+ {
+ TNSmlAPAddElement newCommand;
+ newCommand.iUri = aURI.AllocLC();
+ newCommand.iData = 0;
+ newCommand.iStatusRef = aStatusRef;
+ newCommand.iLeaf = EFalse;
+ newCommand.iDone = EFalse;
+
+ TPtrC8 parentUri = FirstURISeg(aURI);
+ newCommand.iLuid = iCallBack->GetLuidAllocL(parentUri);
+
+ if (aWlan)
+ {
+ iBuffer->At(index).iWlanNodeBuf->AppendL(newCommand);
+ }
+ else
+ {
+ iBuffer->At(index).iNodeBuf->AppendL(newCommand);
+ }
+ CleanupStack::Pop(); //newCommand.iUri
+ }
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::AddLeafBufferL()
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::AddLeafBufferL(const TDesC8& aURI,
+ const TDesC8& aParentLUID, const TDesC8& aObject,
+ const TDesC8& /*aType*/, const TInt aStatusRef, const TBool aWlan)
+ {
+ TInt index = -1;
+
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ TPtrC8 parentUri = FirstURISeg(aURI);
+ if (iBuffer->At(i).iMappingName->Compare(parentUri) == 0)
+ {
+ index = i;
+ break;
+ }
+ }
+
+ if (index < 0)
+ {
+ if (aParentLUID.Length() < 0)
+ {
+ DBG_ARGS8(_S8("AP:AddLeafBufferL URI - <%S> <%S> NOTFOUND"),
+ &aURI, &aParentLUID);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+ else
+ {
+ // this means update to DNSAddr/<X>
+ TPtrC8 apURI = FirstURISeg(aURI);
+ HBufC8* luid = iCallBack->GetLuidAllocL(apURI);
+ CleanupStack::PushL(luid);
+
+ AddNodeBufferL(apURI, luid->Des(), -2, ETrue);
+ iDnsIpv4Pri = 0;
+ iDnsIpv6Pri = 0;
+
+ CleanupStack::PopAndDestroy(luid);
+ index = 0;
+ }
+ }
+
+ TNSmlAPAddElement newCommand;
+
+ newCommand.iUri = aURI.AllocLC(); //aURI.AllocLC();
+ newCommand.iData = aObject.AllocLC();
+ newCommand.iStatusRef = aStatusRef;
+ newCommand.iLuid = aParentLUID.AllocLC();
+ newCommand.iLeaf = ETrue;
+ newCommand.iDone = EFalse;
+
+ if (aWlan)
+ {
+ iBuffer->At(index).iWlanNodeBuf->AppendL(newCommand);
+ }
+ else
+ {
+ iBuffer->At(index).iNodeBuf->AppendL(newCommand);
+ }
+
+ CleanupStack::Pop(3); //newCommand.iLastUriSeg, newCommand.iData, newCommand.iLuid
+
+ if (aURI.Find(KNSmlDdfBearerL) >= 0) // Bearer added
+ {
+ if (aObject.Match(KNSmlDmApValGsmGprs) != KErrNotFound)
+ {
+ iBuffer->At(index).iBearer = ETrue;
+ }
+
+ else if (aObject.Match(KNSmlDmApVal3Gppps) != KErrNotFound
+ || aObject.Match(KNSmlDmApValVpn) != KErrNotFound)
+ {
+ iBuffer->At(index).iBearer = ETrue;
+ }
+ if ((aObject.Match(KNSmlDmApValWlan) != KErrNotFound)
+ && iWlanSupported) // Valid Bearer
+ {
+ iBuffer->At(index).iBearer = ETrue;
+ }
+ }
+
+ if (aURI.Find(KNSmlDdfDirection) >= 0) // Direction added
+ {
+ iBuffer->At(index).iDirection = ETrue;
+ }
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*/*")) != KErrNotFound && aURI.Match(_L8(
+ "AP/*/NAPDef/*/*/*")) == KErrNotFound
+ && LastURISeg(aURI).Compare(KNSmlDdfNAPName) == 0)
+ {
+ iIAPExists = EFalse;
+ iBuffer->At(index).iNameReceived = ETrue;
+
+ delete iBuffer->At(index).iName;
+ iBuffer->At(index).iName = 0;
+
+ iBuffer->At(index).iName = aObject.AllocLC();
+ iIAPName.Copy(aObject);
+ CleanupStack::Pop();
+
+ // Check if Name and LUID match
+ TPtrC qTable = TPtrC(IAP); // Check if IAP-table free
+ TPtrC qDB = TPtrC(COMMDB_ID);
+ TPtrC8 parentUri = FirstURISeg(aURI);
+ HBufC8* luid = iCallBack->GetLuidAllocL(parentUri);
+ CleanupStack::PushL(luid);
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ qTable, qDB, IntLUID(*luid));
+
+ TInt errorCode = tableView->GotoFirstRecord();
+ if (errorCode != KErrNotFound)
+ {
+ // Check the name
+ TBuf8<KCommsDbSvrMaxFieldLength> name;
+ tableView->ReadTextL(TPtrC(COMMDB_NAME), name);
+ if (name.Compare(aObject) != 0)
+ {
+ // Not correct name
+ // Remove all mappings from AP/xxx level
+ if (isAdd)
+ {
+ TInt ret = iCallBack->RemoveMappingL(
+ KNSmlInternetAdapterImplUid, GetDynamicAPNodeUri(
+ aURI), ETrue);
+ iPrevURI->Des().Format(KNullDesC8);
+ iPrevLUID = 0;
+ }
+ else
+ {
+ iIAPExists = ETrue;
+ iLeafType = EDMUpdate;
+ }
+
+ }
+ else
+ {
+ iIAPExists = ETrue;
+ iLeafType = EDMUpdate;
+ }
+ }
+ CleanupStack::PopAndDestroy(tableView);
+ CleanupStack::PopAndDestroy(luid);
+ }
+ //
+
+ // If Bearer data + Direction + name => add is possible for AP
+ //
+ if (iBuffer->At(index).iDirection && iBuffer->At(index).iBearer
+ && iBuffer->At(index).iNameReceived && !iExecutingBuffer)
+ {
+ iBearer.Zero();
+ iDirection = ECommDbConnectionDirectionUnknown;
+ ExecuteBufferL(aURI);
+
+ }
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::AddNodeObjectL()
+// Inserts new AP-data to database
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::AddNodeObjectL(const TDesC8& aURI,
+ const TDesC8& aParentLUID, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): begin");
+
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddNodeObjectL(): aURI=<%S>, aParentLUID=<%S>"),
+ &aURI, &aParentLUID);
+
+ if (iLeafType == EDMUpdate && iExecutingBuffer)
+ {
+ // This is an update to an old IAP. All node additions return KErrAlreadyExists.
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EAlreadyExists); // EError
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): EAlreadyExists end");
+ return;
+ }
+
+ // Save LUID to local variable to be able to reset the value, if needed.
+ TBuf8<KSmlMaxURISegLen> parentLUID;
+ parentLUID.Zero();
+ parentLUID = aParentLUID;
+
+ TUint32 apId = GetAPIdFromURIL(aURI);
+
+ if (parentLUID.Length() > 0 && IntLUID(parentLUID) > 0
+ && !APExistsL(apId))
+ {
+ // AP has been deleted. Handle as new data.
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): parentLUID.Length() > 0 && !APExistsL() -> Remove mapping ");
+ TInt ret = iCallBack->RemoveMappingL(KNSmlInternetAdapterImplUid,
+ GetDynamicAPNodeUri(aURI), ETrue);
+ if (ret)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ parentLUID.Zero();
+ iPrevURI->Des().Format(KNullDesC8);
+ iPrevLUID = 0;
+ }
+
+ if (parentLUID.Length() <= 0)
+ {
+ // Check OOD before saving new
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ if (SysUtil::FFSSpaceBelowCriticalLevelL(&fs,
+ KNSmlInternetAdapterFatMinSize))
+ {
+ CleanupStack::PopAndDestroy(); // fs
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EDiskFull);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): DISK FULL end");
+ return;
+ // do not write
+ }
+ CleanupStack::PopAndDestroy(); //fs
+ }
+ //
+ // Check if AP-add
+ //
+ if ((aURI.Match(_L8("AP/*")) != KErrNotFound && aURI.Match(_L8("AP/*/*"))
+ == KErrNotFound) || (aURI.Match(_L8("AP/*/NAPDef/*"))
+ != KErrNotFound && aURI.Match(_L8("AP/*/NAPDef/*/*"))
+ == KErrNotFound) || aURI.Match(_L8("AP/*/NAPDef"))
+ != KErrNotFound || aURI.Match(_L8("AP/*/NAPDef/*/Bearer"))
+ != KErrNotFound || (aURI.Match(_L8("AP/*/NAPDef/*/Bearer/*"))
+ != KErrNotFound && aURI.Match(_L8("AP/*/NAPDef/*/Bearer/*/*"))
+ == KErrNotFound) || aURI.Match(_L8("*/WLAN*")) != KErrNotFound)
+ {
+ if ((parentLUID.Length() <= 0) && (aURI.Match(_L8("*/WLAN*"))
+ != KErrNotFound))
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse, ETrue);
+ return;
+ }
+ if (parentLUID.Length() <= 0)
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ return;
+ }
+
+ if (iTransactionCommitted && !iDatabase->InTransaction())
+ {
+
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNode object, begin commsdb transaction ");
+ TInt codeBegin = iDatabase->BeginTransaction();
+ TInt retry = KBeginTransRetryCount;
+ if (codeBegin == KErrNone)
+ {
+ iTransactionCommitted = EFalse;
+ }
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddNode object iDatabase->Begintransaction start of addobjectL return code = %d"),
+ codeBegin);
+ if (codeBegin == KErrLocked)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::Addnodeobject Database->Begintransaction has returned KErrLocked");
+ while (retry > 0 && codeBegin == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ codeBegin = iDatabase->BeginTransaction();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddNode object iDatabase->Begintransaction after 2 seconds of wait of addobjectL return code = %d"),
+ codeBegin);
+ retry--;
+ }
+
+ if (codeBegin == KErrNone)
+ {
+ iTransactionCommitted = EFalse;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNode object transaction commited is false ");
+ }
+
+ }
+
+ }
+ if ((aURI.Match(_L8("*/WLAN*")) != KErrNotFound) && iWlanSupported)
+ {
+ DBG_ARGS8(
+ _S8(
+ "To WlanAdapter::AddNodeObjectL - uri: <%S> to parentLUID: <%S>"),
+ &aURI, &parentLUID);
+ iWlanAdapter->AddNodeObjectL(aURI, parentLUID, aStatusRef);
+ return;
+ }
+
+ TInt pluid = IntLUID(parentLUID);
+
+ if (pluid < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): end");
+ return;
+ }
+ iIAPId = pluid;
+
+ TPtrC qTable = TPtrC(IAP); // Check if IAP-table free
+ TPtrC qDB = TPtrC(COMMDB_ID);
+
+ //Check if URI is /AP/*/NAPDef/* then it should be check IAP ID in DB not IAPService
+ if ((iIAPId >= 0)
+ && ((aURI.Match(_L8("AP/*/NAPDef/*")) != KErrNotFound)
+ || (aURI.Match(_L8("AP/*/NAPDef/*/Bearer/*"))
+ != KErrNotFound) || (aURI.Match(_L8("AP/*"))
+ != KErrNotFound) || (aURI.Match(_L8("AP/*/NAPDef"))
+ != KErrNotFound)))
+ {
+ //Get parent UID and check if that exist if not add
+ iIAPId = GetAPIdFromURIL(aURI);
+
+ }
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ qTable, qDB, iIAPId);
+
+ TInt errorCode = tableView->GotoFirstRecord();
+
+ CleanupStack::PopAndDestroy(tableView);
+
+ // Node allready exists => No adding possible
+ if (errorCode == KErrNone)
+ {
+ if (!iExecutingBuffer)
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EAlreadyExists); // EError
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): EAlreadyExists end");
+ }
+ return;
+ }
+ else if (iIAPId == 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): ENotFound end");
+ return;
+ }
+ else if (iIAPId > 0 && errorCode == KErrNotFound) // Stale data, needs update
+ {
+
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): stale data Add to buffer");
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ iStaleMapUpdate = ETrue;
+ return;
+ }
+
+ }
+ else if (aURI.Match(_L8("AP/*/Px/*")) != KErrNotFound && // How to check if already added
+ aURI.Match(_L8("AP/*/Px/*/*")) == KErrNotFound) // dm-tree knows last LUID
+ {
+ if (parentLUID.Length() <= 0)
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ return;
+ }
+
+ // Check if already exists on database (=> only One possible for AP)
+ if (GetProxyIdL(aURI))
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EAlreadyExists);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): EAlreadyExists end");
+ return;
+ }
+
+ TUint32 iapID = GetAPIdFromURIL(aURI);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView* iapView = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ IAP), TPtrC(COMMDB_ID), iapID);
+
+ TInt errorCode = iapView->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ iapView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), iProxyServiceType);
+ iapView->ReadUintL(TPtrC(IAP_SERVICE), iProxyISP);
+ CleanupStack::PopAndDestroy(); // iapView
+ }
+ else if (iapID > 0 && errorCode == KErrNotFound) // Stale data, needs update
+ {
+
+ CleanupStack::PopAndDestroy(); // iapViewv
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): stale data for proxy this as new AP ");
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ iStaleMapUpdate = ETrue;
+ return;
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // iapView
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): ENotFound end");
+ return;
+ }
+
+ CCommsDbTableView* proxyTable;
+
+ proxyTable = iDatabase->OpenTableLC(TPtrC(PROXIES));
+
+ TInt initOK = proxyTable->InsertRecord(iapID);
+
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && initOK != KErrNone)
+ {
+ User::After(KBeginTransRetryDelay);
+ initOK = proxyTable->InsertRecord(iapID);
+ retry--;
+ }
+
+ if (initOK == KErrNone)
+ {
+ iProxyServerName = LastURISeg(aURI); // Name from URI
+ initOK = InitializeProxyL(proxyTable);
+
+ User::After(KBeginTransRetryDelay);
+ if (initOK == KErrNone)
+ {
+ TUint32 newId = 0;
+ initOK = proxyTable->PutRecordChanges();
+
+ retry = KBeginTransRetryCount;
+ while (retry > 0 && initOK != KErrNone)
+ {
+ User::After(KBeginTransRetryDelay);
+ initOK = proxyTable->PutRecordChanges();
+ retry--;
+ }
+
+ proxyTable->ReadUintL(TPtrC(COMMDB_ID), newId);
+ //
+ // Set mapping-data
+ //
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, KNSmlApProxyLowerBase + newId); // 100000 + lProxyId
+
+ // Also added to mapping
+ iCallBack->SetMappingL(aURI, addLUID);
+ }
+ else
+ {
+ proxyTable->CancelRecordChanges();
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): EError end");
+ }
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): EError end Insert failed");
+ }
+ CleanupStack::PopAndDestroy(); // proxyTable
+
+ }
+ else if (aURI.Match(_L8("AP/*/Px/*/*")) != KErrNotFound)
+ {
+ if (parentLUID.Length() <= 0)
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): end");
+ return;
+ }
+
+ TInt pluid = IntLUID(parentLUID);
+
+ if (pluid < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): end");
+ return;
+ }
+ else
+ {
+ TUint32 apID = GetAPIdFromURIL(aURI);
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), apID);
+ TInt errorCode = tableView->GotoFirstRecord();
+ CleanupStack::PopAndDestroy(tableView);
+ if (apID > 0 && errorCode == KErrNotFound) // Stale data, needs update
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): stale data for proxy this as new AP ");
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ iStaleMapUpdate = ETrue;
+ return;
+ }
+
+ }
+ }
+
+ else if (aURI.Match(_L8("AP/*/Px")) != KErrNotFound)
+ {
+ if (parentLUID.Length() <= 0)
+ {
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ return;
+ }
+
+ TInt pluid = IntLUID(parentLUID);
+
+ if (pluid < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): end");
+ return;
+ }
+ else if (pluid == 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): EError");
+ return;
+ }
+ else
+ {
+ TUint32 apID = GetAPIdFromURIL(aURI);
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), apID);
+ TInt errorCode = tableView->GotoFirstRecord();
+ CleanupStack::PopAndDestroy(tableView);
+ if (apID > 0 && errorCode == KErrNotFound) // Stale data, needs update
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddNodeObjectL(): stale data for proxy this as new AP ");
+ AddNodeBufferL(aURI, parentLUID, aStatusRef, EFalse);
+ iStaleMapUpdate = ETrue;
+ return;
+ }
+ }
+ }
+
+ else if (aURI.Match(_L8("AP/*/Networks/*")) != KErrNotFound
+ && aURI.Match(_L8("AP/*/Networks/*/*")) == KErrNotFound)
+ {
+ iIAPId = IntLUID(parentLUID);
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ _DBG_FILE("CNSmlInternetAdapter::AddNodeObjectL(): end");
+ return;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::ExecuteCommandL
+// not supported
+//------------------------------------------------------------------------------
+
+
+void CNSmlInternetAdapter::ExecuteCommandL(const TDesC8&/* aURI*/,
+ const TDesC8& /*aLUID*/, const TDesC8& /*aArgument*/,
+ const TDesC8& /*aType*/, TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::ExecuteCommandL(): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::ExecuteCommandL ( .. RWriteStream ..)
+// not supported
+//------------------------------------------------------------------------------
+
+
+void CNSmlInternetAdapter::ExecuteCommandL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/, TInt aStatusref)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::ExecuteCommandL(): begin");
+ iCallBack->SetStatusL(aStatusref, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::CopyCommandL
+// not supported
+//------------------------------------------------------------------------------
+
+
+void CNSmlInternetAdapter::CopyCommandL(const TDesC8& /*aTargetURI*/,
+ const TDesC8& /*aTargetLUID*/, const TDesC8& /*aSourceURI*/,
+ const TDesC8& /*aSourceLUID*/, const TDesC8& /*aType*/,
+ TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::CopyCommandL(): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlInternetAdapter::CopyCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::StartAtomicL
+// not supported
+//------------------------------------------------------------------------------
+
+
+void CNSmlInternetAdapter::StartAtomicL()
+ {
+ _DBG_FILE("CNSmlInternetAdapter::StartAtomicL(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::StartAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::CommitAtomicL
+// not supported
+//------------------------------------------------------------------------------
+
+
+void CNSmlInternetAdapter::CommitAtomicL()
+ {
+ _DBG_FILE("CNSmlInternetAdapter::CommitAtomicL(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::CommitAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::RollbackAtomicL
+// not supported
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::RollbackAtomicL()
+ {
+ _DBG_FILE("CNSmlInternetAdapter::RollbackAtomicL(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::RollbackAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::StreamingSupport
+// returns EFalse
+//------------------------------------------------------------------------------
+
+TBool CNSmlInternetAdapter::StreamingSupport(TInt& /*aItemSize*/)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::StreamingSupport(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::StreamingSupport(): end");
+ return EFalse;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::StreamCommittedL
+// not used in this adapter
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::StreamCommittedL()
+ {
+ _DBG_FILE("CNSmlInternetAdapter::StreamCommittedL(): begin");
+ _DBG_FILE("CNSmlInternetAdapter::StreamCommittedL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::CompleteOutstandingCmdsL
+//
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::CompleteOutstandingCmdsL()
+ {
+
+ _DBG_FILE("CNSmlInternetAdapter::CompleteOutstandingCmdsL(): begin");
+ //
+ // Handle possible unhandled buffered nodes
+ //
+ if (!iDatabase->InTransaction())
+ {
+ _DBG_FILE("CompleteOutstandingCmds: Try first begintransaction.");
+ TInt err = iDatabase->BeginTransaction();
+ if (err == KErrLocked)
+ {
+ _DBG_FILE("CompleteOutstandingCmds: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && err == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE(
+ "CompleteOutstandingCmds: Slept 1 second. Try again");
+ err = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (err != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(err);
+ }
+ }
+ }
+ _DBG_FILE("CompleteOutstandingCmds: BeginTransaction was successful");
+
+ iDnsIpv4Pri = 0;
+ iDnsIpv6Pri = 0;
+ _LIT8(KDummy, "/Dummy");
+ for (TInt h = iBuffer->Count() - 1; h >= 0; h--) // Through buffers
+ {
+ TBuf8<80> commandURI;
+ commandURI.Append(iBuffer->At(h).iMappingName->Des());
+ commandURI.Append(KDummy); // Removed on execution
+ ExecuteBufferL(commandURI, ETrue);
+ }
+ iDnsUpdate = EFalse;
+ iDnsIpv4Pri = 0;
+ iDnsIpv6Pri = 0;
+ iBuffer->Reset();
+
+ if (iWlanSupported)
+ {
+ iWlanAdapter->CompleteOutstandingCmdsL(); // Execute possible unhandled WLAN commands
+ }
+
+ iNetworkId = KErrNotFound;
+
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ _DBG_FILE("CNSmlInternetAdapter::CompleteOutstandingCmdsL(): end");
+ }
+
+//=============================================
+// CNSmlInternetAdapter::GetAPField()
+// Match URI fieldname to
+// CommsDb table and column
+//
+//=============================================
+TBool CNSmlInternetAdapter::GetAPField(TPtrC& aTableName, TPtrC& aColumn) const
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetAPField(): Start");
+
+ TBool fRet = EFalse;
+
+ aColumn.Set(TPtrC(KNullDesC));
+
+ if (iField->Compare(KNSmlDdfAuthName) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(SERVICE_IF_AUTH_NAME));
+ }
+ else
+ {
+ return fRet;
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNAPName) == 0)
+ {
+ aColumn.Set(TPtrC(COMMDB_NAME));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfToNAPIDL) == 0)
+ {
+ aColumn.Set(TPtrC(COMMDB_ID));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNAPID) == 0)
+ {
+ aColumn.Set(TPtrC(COMMDB_ID));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPxId) == 0)
+ {
+ aColumn.Set(TPtrC(COMMDB_ID));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPxAddr) == 0)
+ {
+ aTableName.Set(TPtrC(PROXIES));
+ aColumn.Set(TPtrC(PROXY_SERVER_NAME));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNAPAddrTy) == 0) // Is valid
+ {
+ return fRet;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrL) == 0)
+ {
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfDNSPriority) == 0)
+ {
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrTy) == 0)
+ {
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNAPAddr) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(GPRS_APN)); // GPRS_PDP_ADDRESS
+ }
+ else if (aTableName == TPtrC(LAN_SERVICE)) // Wlan ADD
+ {
+ aColumn.Set(TPtrC(ISP_IP_ADDR));
+ // Leni: Should this be LAN_IP_ADDR ??
+ }
+ else
+ {
+ return fRet;
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfBearerL) == 0)
+ {
+ aTableName.Set(TPtrC(IAP));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfDirection) == 0)
+ {
+ aTableName.Set(TPtrC(IAP));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfAuthSecr) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(SERVICE_IF_AUTH_PASS));
+ }
+ else
+ {
+ return fRet; // NotValid
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPortNbr) == 0)
+ {
+ if (iWapPort)
+ {
+ aTableName.Set(TPtrC(WAP_IP_BEARER));
+ aColumn.Set(TPtrC(WAP_PROXY_PORT));
+ }
+ else
+ {
+ aTableName.Set(TPtrC(PROXIES));
+ aColumn.Set(TPtrC(PROXY_PORT_NUMBER));
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfStartpg) == 0)
+ {
+ aTableName.Set(TPtrC(WAP_ACCESS_POINT));
+ aColumn.Set(TPtrC(WAP_START_PAGE));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPxAuthId) == 0) // No KNSmlDdfBasAuthId
+ {
+ aTableName.Set(TPtrC(WAP_IP_BEARER));
+ aColumn.Set(TPtrC(WAP_PROXY_LOGIN_NAME));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPxAuthPW) == 0) // No KNSmlDdfBasAuthPW
+ {
+ aTableName.Set(TPtrC(WAP_IP_BEARER));
+ aColumn.Set(TPtrC(WAP_PROXY_LOGIN_PASS));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfUsePTxtLog) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(SERVICE_DISABLE_PLAIN_TEXT_AUTH));
+ fRet = ETrue;
+ }
+ else
+ {
+ return fRet; // NotValid
+ }
+ }
+ else if (iField->Compare(KNSmlDdfDefGW) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP_GATEWAY));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNetworkMask) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP_NETMASK));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNetworkID) == 0)
+ {
+ aColumn.Set(TPtrC(COMMDB_ID));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfPPPComp) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(GPRS_DATA_COMPRESSION));
+ }
+ else
+ {
+ return fRet; // NotValid
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfGPRSPDP) == 0)
+ {
+ if (aTableName == TPtrC(OUTGOING_GPRS) || aTableName == TPtrC(
+ INCOMING_GPRS))
+ {
+ aColumn.Set(TPtrC(GPRS_PDP_TYPE));
+ }
+ else
+ {
+ return fRet; // NotValid
+ }
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfNoPxForL) == 0)
+ {
+ aColumn.Set(TPtrC(PROXY_EXCEPTIONS));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfDomainL) == 0)
+ {
+ aColumn.Set(TPtrC(PROXY_PROTOCOL_NAME));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIPAddrFromServer) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP_ADDR_FROM_SERVER));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIPAddr) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP_ADDR));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrFromServer) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP_DNS_ADDR_FROM_SERVER));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIPv6DNSAddrFromServer) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IP6_DNS_ADDR_FROM_SERVER));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIfNetworks) == 0)
+ {
+ aColumn.Set(TPtrC(SERVICE_IF_NETWORKS));
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIAPService) == 0)
+ {
+ aColumn.Set(TPtrC(IAP_SERVICE));
+ fRet = ETrue;
+ }
+
+ else if (iField->Compare(KNSmlDdfIAPSeamlessness) == 0)
+ {
+ fRet = ETrue;
+ }
+ else if (iField->Compare(KNSmlDdfIAPMetaData) == 0)
+ {
+ fRet = ETrue;
+ }
+
+ DBG_ARGS(_S16("GetAPField: aURI - %S - %S - %S"), &aTableName,
+ &aColumn, &*iField);
+
+ _DBG_FILE("CNSmlInternetAdapter::GetAPField(): EOk");
+
+ return fRet;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::GetAPFieldType()
+// Match fieldtype to Commsdb-database
+//
+//=============================================
+CNSmlInternetAdapter::TNSmlAPFieldType CNSmlInternetAdapter::GetAPFieldType(
+ const TDesC8& aURI) const
+ {
+ if (iField->Compare(KNSmlDdfBearerL) == 0)
+ {
+ return CNSmlInternetAdapter::ESpec;
+ }
+ else if (iField->Compare(KNSmlDdfDirection) == 0)
+ {
+ return CNSmlInternetAdapter::ESpec;
+ }
+ else if (iField->Compare(KNSmlDdfBearer) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfToNAPIDL) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfNAPID) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfPxId) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfAuthName) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfNAPName) == 0 || iField->Compare(
+ KNSmlDdfPxName) == 0 || iField->Compare(KNSmlDdfNetworkName) == 0)
+ {
+ if (aURI.Match(_L8("AP/*/Px/*/Name")) != KErrNotFound || aURI.Match(
+ _L8("AP/*/Networks/*/Name")) != KErrNotFound)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else
+ {
+ return CNSmlInternetAdapter::ESpec; // For NAPName
+ }
+ }
+ else if (iField->Compare(KNSmlDdfNAPAddrTy) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfNAPAddr) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfStartpg) == 0)
+ {
+ return CNSmlInternetAdapter::EWap;
+ }
+ else if (iField->Compare(KNSmlDdfPxAuthId) == 0)
+ {
+ return CNSmlInternetAdapter::EWap;
+ }
+ else if (iField->Compare(KNSmlDdfPxAuthPW) == 0)
+ {
+ return CNSmlInternetAdapter::EWap;
+ }
+ else if (iField->Compare(KNSmlDdfPxAddr) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrFromServer) == 0)
+ {
+ return CNSmlInternetAdapter::EBool;
+ }
+ else if (iField->Compare(KNSmlDdfIPv6DNSAddrFromServer) == 0)
+ {
+ return CNSmlInternetAdapter::EBool;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrL) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfDNSAddrTy) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfDNSPriority) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfPxName) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfAuthSecr) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfPxId) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfPxPW) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfPortNbr) == 0)
+ {
+ if (iWapPort) // Different handlig for WAP and Proxy PortNbr
+ {
+ return CNSmlInternetAdapter::EWap;
+ }
+ else
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ }
+ else if (iField->Compare(KNSmlDdfUsePTxtLog) == 0)
+ {
+ return CNSmlInternetAdapter::EBool;
+ }
+ else if (iField->Compare(KNSmlDdfDefGW) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfNetworkMask) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfNetworkID) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfPPPComp) == 0)
+ {
+ return CNSmlInternetAdapter::EBool;
+ }
+ else if (iField->Compare(KNSmlDdfGPRSPDP) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfDomainL) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfNoPxForL) == 0)
+ {
+ return CNSmlInternetAdapter::ESpec;
+ }
+ else if (iField->Compare(KNSmlDdfIPAddrFromServer) == 0)
+ {
+ return CNSmlInternetAdapter::EBool;
+ }
+ else if (iField->Compare(KNSmlDdfIPAddr) == 0)
+ {
+ return EStr;
+ }
+ else if (iField->Compare(KNSmlDdfIfNetworks) == 0)
+ {
+ return CNSmlInternetAdapter::EStr;
+ }
+ else if (iField->Compare(KNSmlDdfIAPService) == 0)
+ {
+ return CNSmlInternetAdapter::ESpec;
+ }
+
+ else if (iField->Compare(KNSmlDdfIAPSeamlessness) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+ else if (iField->Compare(KNSmlDdfIAPMetaData) == 0)
+ {
+ return CNSmlInternetAdapter::EInt;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::GetAPFieldType(): Error");
+
+ return EWrong;
+ }
+
+//------------------------------------------------------------------------------
+//
+//------------------------------------------------------------------------------
+#ifndef IMPLEMENTATION_PROXY_ENTRY
+#define IMPLEMENTATION_PROXY_ENTRY(aUid, aFuncPtr) {{aUid},(aFuncPtr)}
+#endif
+
+const TImplementationProxy ImplementationTable[] =
+ {
+ IMPLEMENTATION_PROXY_ENTRY(0x101F6DE2, CNSmlInternetAdapter::NewL)
+ };
+
+//------------------------------------------------------------------------------
+// TImplementationProxy* ImplementationGroupProxy()
+//------------------------------------------------------------------------------
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(
+ TInt& aTableCount)
+ {
+ _DBG_FILE("ImplementationGroupProxy() for CNSmlInternetAdapter: begin");
+
+ aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+ _DBG_FILE("ImplementationGroupProxy() for CNSmlInternetAdapter: end");
+ return ImplementationTable;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::IntLUID()
+// Returns IntValue for aLUID
+//=============================================
+TInt CNSmlInternetAdapter::IntLUID(const TDesC8& aLUID)
+ {
+ TLex8 lex(aLUID);
+
+ if (lex.Val(iLUID) == KErrNone)
+ {
+ if ((iLUID > KNSmlApProxyUpperBase) && (iLUID
+ < KNSmlApDnsLuidUpperBase))
+ {
+ iLUID = iLUID - KNSmlApProxyUpperBase;
+ }
+ else if ((iLUID > KNSmlApProxyLowerBase) && (iLUID
+ < KNSmlApProxyUpperBase))
+ {
+ iProxyId = iLUID - KNSmlApProxyLowerBase; // Proxy
+ iLUID = iProxyId;
+ }
+ else if ((iLUID > KNSmlAp3gpppsLowerBase) && (iLUID
+ <= KNSmlApProxyLowerBase))
+ {
+ iLUID = iLUID - KNSmlAp3gpppsLowerBase;
+ i3GPPPS = ETrue;
+ }
+ else
+ {
+ iProxyId = 0;
+ }
+ return iLUID;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+//=============================================
+// CNSmlInternetAdapter::GetIntObject8()
+// Returns IntValue for aObject
+//=============================================
+TInt CNSmlInternetAdapter::GetIntObject8(const TDesC8& aObject)
+ {
+ TLex8 lex(aObject);
+
+ TInt lValue = 0;
+
+ if (lex.Val(lValue) == KErrNone)
+ {
+ return lValue;
+ }
+ else
+ {
+ return lValue;
+ }
+ }
+//=============================================
+// CNSmlInternetAdapter::SetIntObjectLC()
+// Returns IntValue for aObject
+//=============================================
+TDesC8& CNSmlInternetAdapter::SetIntObjectLC(const TInt& aObject)
+ {
+ HBufC8* buf = HBufC8::NewLC(8);
+ TPtr8 ptrBuf = buf->Des();
+
+ ptrBuf.Num(aObject);
+
+ return *buf;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::NotValidStrLenght()
+// False if datalength is valid
+//=============================================
+TBool CNSmlInternetAdapter::NotValidStrLenght(const TDesC& aSource)
+ {
+ TInt len = aSource.Length();
+ TBool theBool = EFalse;
+
+ if (len > KCommsDbSvrMaxFieldLength)
+ {
+ theBool = ETrue;
+ }
+ return theBool;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::SetField()
+// String after last '/' is returned
+//
+//=============================================
+TInt CNSmlInternetAdapter::SetField(const TDesC8& aSource)
+ {
+ if (aSource.LocateReverse('/') == KErrNotFound)
+ {
+ iField->Des().Format(aSource);
+ }
+ else
+ {
+ iField->Des().Format(aSource.Mid(aSource.LocateReverse('/') + 1));
+ }
+
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::ConvertTo8LC()
+// Converts string value to 8-bit
+//
+//=============================================
+TDesC8& CNSmlInternetAdapter::ConvertTo8LC(const TDesC& aSource)
+ {
+ HBufC8* buf = HBufC8::NewLC(aSource.Length() * 2);
+ TPtr8 bufPtr = buf->Des();
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(bufPtr, aSource);
+
+ return *buf;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::ConvertTo16LC()
+// Converts string value to 16-bit
+//
+//=============================================
+TDesC16& CNSmlInternetAdapter::ConvertTo16LC(const TDesC8& aSource)
+ {
+ HBufC16* buf16 = HBufC16::NewLC(aSource.Length());
+ TPtr bufPtr16 = buf16->Des();
+
+ CnvUtfConverter::ConvertToUnicodeFromUtf8(bufPtr16, aSource);
+
+ return *buf16;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeGPRSL()
+// Initialize GPRS-data before insert
+//
+//=============================================
+TInt CNSmlInternetAdapter::InitializeGPRSL(CCommsDbTableView* aTable)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> user;
+ TBuf<KCommsDbSvrMaxFieldLength> pass;
+
+ _LIT(Kdns6Address, "0:0:0:0:0:0:0:0");
+ _LIT(KgifNetworks, "ip");
+
+ // COMMON DATA
+ aTable->WriteBoolL(TPtrC(SERVICE_DISABLE_PLAIN_TEXT_AUTH), EFalse);
+
+ aTable->WriteTextL(TPtrC(GPRS_IF_NETWORKS), KgifNetworks);
+
+ aTable->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(iIAPName)); // Same as IAP
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+
+ aTable->WriteBoolL(TPtrC(GPRS_IF_PROMPT_FOR_AUTH), EFalse);
+ aTable->WriteTextL(TPtrC(GPRS_IF_AUTH_NAME), user);
+ aTable->WriteTextL(TPtrC(GPRS_IF_AUTH_PASS), pass);
+
+ aTable->WriteBoolL(TPtrC(GPRS_IP_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(GPRS_IP_ADDR), KNSmlEmptyIpv4Address);
+
+ aTable->WriteBoolL(TPtrC(GPRS_IP_DNS_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(GPRS_IP_NAME_SERVER1), KNSmlEmptyIpv4Address);
+ aTable->WriteTextL(TPtrC(GPRS_IP_NAME_SERVER2), KNSmlEmptyIpv4Address);
+
+ aTable->WriteBoolL(TPtrC(GPRS_IP6_DNS_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(GPRS_IP6_NAME_SERVER1), Kdns6Address);
+ aTable->WriteTextL(TPtrC(GPRS_IP6_NAME_SERVER2), Kdns6Address);
+ // GPRS DATA
+
+ aTable->WriteTextL(TPtrC(GPRS_APN), ConvertTo16LC(iIAPName)); // Same as IAP
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+
+ aTable->WriteUintL(TPtrC(GPRS_REQ_PRECEDENCE), 0);
+ aTable->WriteUintL(TPtrC(GPRS_REQ_DELAY), 0);
+ aTable->WriteUintL(TPtrC(GPRS_REQ_RELIABILITY), 0);
+ aTable->WriteUintL(TPtrC(GPRS_REQ_PEAK_THROUGHPUT), 0);
+ aTable->WriteUintL(TPtrC(GPRS_REQ_MEAN_THROUGHPUT), 0);
+ aTable->WriteUintL(TPtrC(GPRS_MIN_PRECEDENCE), 0);
+ aTable->WriteUintL(TPtrC(GPRS_MIN_DELAY), 0);
+ aTable->WriteUintL(TPtrC(GPRS_MIN_RELIABILITY), 0);
+ aTable->WriteUintL(TPtrC(GPRS_MIN_PEAK_THROUGHPUT), 0);
+ aTable->WriteUintL(TPtrC(GPRS_MIN_MEAN_THROUGHPUT), 0);
+
+ aTable->WriteUintL(TPtrC(GPRS_IF_AUTH_RETRIES), 0);
+
+ aTable->WriteBoolL(TPtrC(GPRS_DATA_COMPRESSION), EFalse);
+ aTable->WriteUintL(TPtrC(GPRS_PDP_TYPE), RPacketContext::EPdpTypeIPv4); // IPV4
+
+ aTable->WriteBoolL(TPtrC(GPRS_ENABLE_LCP_EXTENSIONS), EFalse);
+ aTable->WriteBoolL(TPtrC(GPRS_ANONYMOUS_ACCESS), EFalse);
+ aTable->WriteBoolL(TPtrC(GPRS_HEADER_COMPRESSION), EFalse);
+
+ aTable->WriteBoolL(TPtrC(GPRS_IP_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(GPRS_IP_GATEWAY), KNSmlEmptyIpv4Address);
+
+ aTable->WriteTextL(TPtrC(GPRS_IP_ADDR), KNSmlEmptyIpv4Address);
+ aTable->WriteTextL(TPtrC(GPRS_IF_PARAMS), KNullDesC);
+ aTable->WriteTextL(TPtrC(GPRS_IP_NETMASK), KNullDesC);
+
+ aTable->WriteUintL(TPtrC(GPRS_QOS_WARNING_TIMEOUT), 0xffffffff);
+
+ aTable->WriteUintL(TPtrC(GPRS_AP_TYPE), (TUint32) EIspTypeInternetAndWAP);
+
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeProxyL()
+// Initialize Proxy-data before insert
+//
+//=============================================
+TInt CNSmlInternetAdapter::InitializeProxyL(CCommsDbTableView* aTable)
+ {
+ _LIT(KprotocolName, "http"); // http, https, ftp, ftps
+ const TUint32 KPortNumber(80);
+
+ aTable->WriteUintL(TPtrC(PROXY_ISP), iProxyISP); // ISP with which these proxies are associated
+
+ aTable->WriteTextL(TPtrC(PROXY_SERVICE_TYPE), iProxyServiceType); // Type ISP/GPRS
+ aTable->WriteBoolL(TPtrC(PROXY_USE_PROXY_SERVER), ETrue);
+
+ TPtr proxyName16 = HBufC::NewLC(iProxyServerName.Length())->Des();
+ CnvUtfConverter::ConvertToUnicodeFromUtf8(proxyName16, iProxyServerName);
+
+ aTable->WriteLongTextL(TPtrC(PROXY_SERVER_NAME), proxyName16); // Name of the proxy server
+ aTable->WriteTextL(TPtrC(PROXY_PROTOCOL_NAME), KprotocolName); // also https + ftps
+
+ aTable->WriteUintL(TPtrC(PROXY_PORT_NUMBER), KPortNumber);
+
+ aTable->WriteLongTextL(TPtrC(PROXY_EXCEPTIONS), KNullDesC);
+
+ CleanupStack::PopAndDestroy(); //proxyName16
+ return KErrNone;
+ }
+
+// CNSmlInternetAdapter::IsInsertAllowedL
+// Check if possible to Add new AP
+//
+//=============================================
+TBool CNSmlInternetAdapter::IsInsertAllowedL()
+ {
+ TBool theBool = EFalse;
+ //
+ // Id + Name + Bearer needed for Insert
+ //
+ if (iIAPName.Length() > 0 && iBearer.Length() > 0 && iDirection
+ != ECommDbConnectionDirectionUnknown)
+ {
+ theBool = ETrue;
+ }
+ //
+ // Should check also if Name or iISPId in USE !!!
+ //
+ if (theBool)
+ {
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingTextLC(
+ iBearer, TPtrC(COMMDB_NAME), iIAPName);
+ TInt errorCode = tableView->GotoFirstRecord();
+
+ // Node allready exists => No adding possible
+ if (errorCode == KErrNone)
+ {
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::NODE NAME <%S> ALLREADY(): error"),
+ &iIAPName);
+ theBool = EFalse;
+ }
+ CleanupStack::PopAndDestroy(tableView);
+ }
+ return theBool;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::SaveIAPDataL
+// Saves data to IAP-table
+//
+//=============================================
+void CNSmlInternetAdapter::SaveIAPDataL(const TDesC8& aURI)
+ {
+ TInt errorCode;
+ CCommsDbTableView* tableView;
+
+ TBool apEnforce = EFalse;
+ TBool iapReLock = EFalse;
+
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ TRAPD(eError,apEnforce=CheckEnforcementL())
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::SaveIAPDataL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+ if (iIAPExists)
+ {
+ tableView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(
+ COMMDB_ID), iIAPId);
+ if (IsIAPRecordLockedL(iIAPId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt
+ reclockerr =
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+
+ errorCode = tableView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ // if enforcement is on and rec exists, it needs to be unprotected
+ if (apEnforce)
+ {
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ }
+ }
+ errorCode = tableView->UpdateRecord();
+ }
+ }
+ else
+ {
+ tableView = iDatabase->OpenTableLC(TPtrC(IAP));
+
+ errorCode = tableView->InsertRecord(iIAPId);
+ }
+
+ if (errorCode == KErrNone)
+ {
+ TUint32 modemISPId = 1; // Default
+ TBuf<KCommsDbSvrMaxFieldLength> modemBearer = TPtrC(MODEM_BEARER);
+ if (iBearer == TPtrC(LAN_SERVICE))
+ {
+ modemBearer = TPtrC(LAN_BEARER);
+ }
+ else if (iBearer == TPtrC(VPN_SERVICE))
+ {
+ modemBearer = TPtrC(VIRTUAL_BEARER);
+ }
+ else
+ {
+ modemBearer = TPtrC(MODEM_BEARER);
+ }
+
+ if (modemBearer == TPtrC(MODEM_BEARER))
+ {
+ GetModemBearerL(modemISPId);
+ }
+ else if (modemBearer == TPtrC(VIRTUAL_BEARER))
+ {
+ modemISPId = 1;
+ }
+ else if (iWlanSupported)
+ {
+ GetLanBearerL(modemISPId);
+ }
+ tableView->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(iIAPName));
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+
+ // ISP id must be written
+ tableView->WriteUintL(TPtrC(IAP_SERVICE), iISPId);
+ tableView->WriteTextL(TPtrC(IAP_SERVICE_TYPE), iBearer);
+
+ tableView->WriteUintL(TPtrC(IAP_BEARER), modemISPId);
+ tableView->WriteTextL(TPtrC(IAP_BEARER_TYPE), modemBearer);
+ if (iNetworkId != KErrNotFound)
+ {
+ tableView->WriteUintL(TPtrC(IAP_NETWORK), iNetworkId); // First name on network table
+ }
+ tableView->WriteUintL(TPtrC(IAP_NETWORK_WEIGHTING), 0);
+ tableView->WriteUintL(TPtrC(IAP_LOCATION), 2); // Minimum=2
+
+
+ errorCode = tableView->PutRecordChanges();
+ }
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ ((CCommsDbProtectTableView*) tableView)->ProtectRecord();
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(iIAPId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+
+ if (errorCode == KErrNone)
+ {
+ if (!iIAPExists)
+ {
+ TUint32 lValue;
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+
+ // Add AP
+ TPtrC8 addURI = GetAddURISeg(aURI, KNSmlDdfAP);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, lValue);
+
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ DBG_ARGS8(_S8("AP:level1 URI - <%S> <%S> <%d>"), &addURI,
+ &addLUID, lValue);
+ }
+
+ iIAPExists = ETrue;
+ }
+
+ if (apEnforce)
+ apEnforce = EFalse; // to rget rid of warnings
+
+ CleanupStack::PopAndDestroy(); // tableView
+ User::LeaveIfError(errorCode);
+ }
+
+//=============================================
+// CNSmlInternetAdapter::GetMaxIdL
+// Get max id from given bearer
+//
+//=============================================
+TUint32 CNSmlInternetAdapter::GetMaxIdL()
+ {
+ CCommsDbTableView* checkView;
+ TUint32 maxGPRS(0);
+ checkView = iDatabase->OpenTableLC(iBearer);
+ TInt errorCodem = checkView->GotoFirstRecord();
+ while (errorCodem == KErrNone)
+ {
+ TUint32 lValue;
+ checkView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+ if (lValue > maxGPRS)
+ {
+ maxGPRS = lValue;
+ }
+ errorCodem = checkView->GotoNextRecord();
+ }
+
+ CleanupStack::PopAndDestroy(); // checkView
+
+ return (maxGPRS);
+ }
+
+//=============================================
+// CNSmlInternetAdapter::GetProxyIdL
+// Get proxy id for given IAP
+//
+//=============================================
+TBool CNSmlInternetAdapter::GetProxyIdL(const TDesC8& aURI)
+ {
+ TBool proxyFound = EFalse;
+
+ CCommsDbTableView* checkView;
+
+ // Get servicetype for IAP nbr
+
+ TUint32 iapID = GetAPIdFromURIL(aURI);
+ if (iapID == 0)
+ {
+ if (IsAPUriFormatMatchPredefined(aURI))
+ {
+ iLUID = ConstructTreeL(aURI);
+ iapID = GetAPIdFromURIL(aURI);
+ }
+
+ }
+ // IAP-table search serviceType + serviceId
+ CCommsDbTableView* iapView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), iapID);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId;
+
+ TInt errorCode = iapView->GotoFirstRecord();
+
+ // Read serviceType from (IAP)
+ if (errorCode == KErrNone)
+ {
+ iapView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ iapView->ReadUintL(TPtrC(IAP_SERVICE), serviceId);
+ CleanupStack::PopAndDestroy(); // iapView
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(); // iapView
+ return proxyFound;
+ }
+
+ checkView = iDatabase->OpenViewMatchingTextLC(TPtrC(PROXIES), TPtrC(
+ PROXY_SERVICE_TYPE), serviceType);
+
+ TInt errorCodem = checkView->GotoFirstRecord();
+
+ while (errorCodem == KErrNone)
+ {
+ TUint32 lValue;
+ checkView->ReadUintL(TPtrC(PROXY_ISP), lValue);
+ if (lValue == serviceId)
+ {
+ checkView->ReadUintL(TPtrC(COMMDB_ID), iProxyId);
+ proxyFound = ETrue;
+ break;
+ }
+ errorCodem = checkView->GotoNextRecord();
+ }
+
+ CleanupStack::PopAndDestroy(); // checkView
+
+ return proxyFound;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::APExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::APExistsL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+
+ checkView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP),
+ TPtrC(COMMDB_ID), aId);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); // checkView
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::NetworkExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::NetworkExistsL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+
+ checkView = iDatabase->OpenViewMatchingUintLC(TPtrC(NETWORK), TPtrC(
+ COMMDB_ID), aId);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); // checkView
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::NetworkNameExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::NetworkNameExistsL(TUint32& aId,
+ const TDesC8& aObject)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+
+ checkView = iDatabase->OpenViewMatchingTextLC(TPtrC(NETWORK), TPtrC(
+ COMMDB_NAME), ConvertTo16LC(aObject));
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ checkView->ReadUintL(TPtrC(COMMDB_ID), aId);
+ ret = ETrue;
+ }
+
+ CleanupStack::PopAndDestroy(2); // checkView ConvertTo16LC
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::AddNetworkL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::AddNetworkL(TUint32& aId, const TDesC8& aObject)
+ {
+ TBool ret = EFalse;
+ TUint32 newId;
+ CCommsDbTableView* networkView = iDatabase->OpenTableLC(TPtrC(NETWORK));
+
+ if (networkView->InsertRecord(newId) == KErrNone)
+ {
+ networkView->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(aObject));
+ if (networkView->PutRecordChanges() == KErrNone)
+ {
+ networkView->ReadUintL(TPtrC(COMMDB_ID), aId); // New networks Id
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ }
+ CleanupStack::PopAndDestroy(); // networkView
+ DBG_ARGS8(_S8("NsmlInternetAdapter: AddNetworkL:networkId %d"), aId);
+
+ return ret;
+ }
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::NAPDefExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::NAPDefExistsL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+
+ checkView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(
+ IAP_SERVICE), aId);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ checkView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, TPtrC(COMMDB_ID), aId);
+ error = tableView->GotoFirstRecord();
+
+ if (error == KErrNone)
+ {
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+
+ CleanupStack::PopAndDestroy(); // checkView
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::PxExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::PxExistsL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* pxView;
+
+ pxView = iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES), TPtrC(
+ COMMDB_ID), aId);
+
+ TInt errorCode = pxView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); // pxView
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::WapAPExistsL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::WapAPExistsL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* wapView;
+
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_IP_BEARER), TPtrC(
+ WAP_IAP), aId);
+
+ TInt errorCode = wapView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ wapView->ReadUintL(TPtrC(WAP_ACCESS_POINT_ID), iWapId);
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy(); // wapView
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TUint32 CNSmlInternetAdapter::GetAPIdFromURIL(const TDesC8& aURI)
+// Get AP luid for given aURI
+//------------------------------------------------------------------------------
+TUint32 CNSmlInternetAdapter::GetAPIdFromURIL(const TDesC8& aURI)
+ {
+ HBufC8* apURI = HBufC8::NewLC(aURI.Length());
+
+ _DBG_FILE("CNSmlInternetAdapter::GetAPIdFromURIL(): begin");
+ DBG_ARGS8(_S8("AP:add aURI GetAPIdFromURIL - %S "), &aURI);
+ //
+ // Second slash after AP
+ //
+ TInt i = 0;
+ for (i = aURI.Find(KNSmlDdfAP) + 3; i < aURI.Length(); i++)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+ DBG_ARGS8(_S8("AP:add aURI GetAPIdFromURIL i is %d "), i);
+ if (i > 0)
+ {
+ apURI->Des().Format(aURI.Left(i));
+ }
+ //
+ // Same profile as previous
+ //
+ if (iPrevURI->Match(*apURI) != KErrNotFound)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetAPIdFromURIL(): previous uri");
+ CleanupStack::PopAndDestroy(); // apURI
+ return iPrevLUID;
+ }
+ //
+ // Fetch AP-id for URI
+ //
+ HBufC8* apLUID = iCallBack->GetLuidAllocL(*apURI);
+ CleanupStack::PushL(apLUID);
+
+ TUint32 resLUID = IntLUID(*apLUID);
+ DBG_ARGS8(_S8("AP:add aURI GetAPIdFromURIL luidallocation is %d "),
+ resLUID);
+
+ if (resLUID > 0)
+ {
+ iPrevURI->Des().Format(*apURI);
+ iPrevLUID = resLUID;
+ }
+
+ CleanupStack::PopAndDestroy(2); // apURI, apLUID
+
+ return resLUID;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::DeleteProxyL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::DeleteProxyL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* pxView;
+
+ pxView = iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES), TPtrC(
+ COMMDB_ID), aId);
+
+ TInt errorCode = pxView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ errorCode = pxView->DeleteRecord();
+ if (errorCode == KErrNone)
+ {
+ ret = ETrue;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // pxView
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::DeleteWapAPL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::DeleteWapAPL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* wapView;
+
+ TUint32 wapId = 0;
+
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ TBool apEnforce = EFalse;
+ TRAPD(eError,apEnforce=CheckEnforcementL())
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::DeleteWAPAPL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_IP_BEARER), TPtrC(
+ WAP_IAP), aId);
+
+ TInt errorCode = wapView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ wapView->ReadUintL(TPtrC(WAP_ACCESS_POINT_ID), wapId); // WapIAP id
+ errorCode = wapView->DeleteRecord();
+ if (errorCode == KErrNone)
+ {
+ ret = ETrue;
+ }
+ }
+
+ if (ret)
+ {
+ CCommsDbTableView* wapApView = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(WAP_ACCESS_POINT), TPtrC(COMMDB_ID), wapId);
+
+ errorCode = wapApView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ errorCode = wapApView->DeleteRecord();
+ if (errorCode == KErrNone)
+ {
+ ret = ETrue;
+ }
+ }
+ CleanupStack::PopAndDestroy(); // wapApView
+ }
+
+ CleanupStack::PopAndDestroy(); // wapView
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::DeleteNAPDefL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::DeleteNAPDefL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+ TBool apEnforce = EFalse;
+ TBool iapReLock = EFalse;
+
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ TRAPD( eError,apEnforce=CheckEnforcementL() )
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::DeleteNAPDefL(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+
+ checkView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(
+ IAP_SERVICE), aId);
+ if (IsIAPRecordLockedL(aId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt reclockerr =
+ ((CCommsDbProtectTableView*) checkView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ checkView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+
+ CCommsDbTableView* tableView = iDatabase->OpenViewMatchingUintLC(
+ serviceType, TPtrC(COMMDB_ID), aId);
+ error = tableView->GotoFirstRecord();
+
+ if (error == KErrNone)
+ {
+ if (FeatureManager::FeatureSupported(
+ KFeatureIdSapPolicyManagement))
+ {
+ if (apEnforce)
+ {
+ ((CCommsDbProtectTableView*) tableView)->UnprotectRecord();
+ }
+ }
+
+ error = tableView->DeleteRecord();
+ if (error == KErrNone)
+ {
+ ret = ETrue;
+ }
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+ }
+
+ CleanupStack::PopAndDestroy(); // checkView
+
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(aId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting WAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ if (apEnforce)
+ apEnforce = EFalse; // to get rid of warnings
+
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// Removes iapID and linger interval from CentralRepository
+// ---------------------------------------------------------------------------
+//
+void CNSmlInternetAdapter::DeleteLingerL(const TInt aIapId)
+ {
+ TInt err(KErrNone);
+
+ // Open repository
+ CRepository* repository = CRepository::NewLC(KCRUidPDPContextManager);
+
+ // Find if an entry for "iapId" already exists in CentRep
+ RArray<TUint32> foundKeys;
+ foundKeys.Reset();
+
+ err = repository->FindEqL(KIapColumn, // partial key
+ KColumnMask, // key mask
+ aIapId, // value
+ foundKeys); // found keys
+
+ if (err == KErrNone)
+ {
+ if (foundKeys.Count() > 0)
+ {
+ TInt arrayCount(0);
+
+ // Get number of iapId&linger entries in Centrep
+ err = repository->Get(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+
+ if (err == KErrNone)
+ {
+ TInt32 row = foundKeys[0] & KRowMask;
+
+ // Shift existing entries one position left
+ for (TInt i = row + 1; i <= arrayCount; i++)
+ {
+ TInt iapId(0);
+ TInt linger(0);
+
+ err = repository->Get((KIapColumn | i), iapId);
+
+ if (err == KErrNone)
+ {
+ err = repository->Get((KLingerColumn | i), linger);
+ }
+
+ if (err == KErrNone)
+ {
+ err = repository->Set((KIapColumn | (i - 1)), iapId);
+ }
+
+ if (err == KErrNone)
+ {
+ err = repository->Set((KLingerColumn | (i - 1)),
+ linger);
+ }
+ }
+
+ // Remove the last entry on row arrayCount
+ if (err == KErrNone)
+ {
+ TUint32 errorKey(0);
+
+ err = repository->Delete((KIapColumn | arrayCount),
+ 0xFFFFFFFF, errorKey);
+
+ if (err == KErrNone)
+ {
+ err = repository->Delete(
+ (KLingerColumn | arrayCount), 0xFFFFFFFF,
+ errorKey);
+ arrayCount--;
+ }
+ }
+
+ // Update number of iapId&linger entries in Centrep
+ err = repository->Set(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+ }
+ }
+ }
+
+ foundKeys.Close();
+ CleanupStack::PopAndDestroy(repository);
+
+ }
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::DeleteAPL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::DeleteAPL(TUint32 aId)
+ {
+ TBool ret = EFalse;
+
+ //Check MIP IAP first then go forward
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ TBool apEnforce = EFalse;
+ TBool wlanEnforce = EFalse;
+ TInt wError = KErrNone;
+ TRAP(wError, wlanEnforce = CheckWLANEnforcementL());TRAPD( eError,apEnforce=CheckEnforcementL() )
+ if( wlanEnforce)
+ {
+ UnprotectWLANAPItemL(aId);
+ }
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DeleteAPL(): EError %d , APEnforcement is %d"),
+ eError, apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+ }
+
+ if (iDatabase->InTransaction())
+ iDatabase->CommitTransaction();
+ RCmManagerExt cmManagerExt;
+ cmManagerExt.OpenL();
+ RCmConnectionMethodExt cmConMethodExt;
+ TRAPD(err, cmConMethodExt = cmManagerExt.ConnectionMethodL(aId));
+ CleanupClosePushL(cmConMethodExt);
+ if (err == KErrNone)
+ {
+ TRAPD(dError, cmConMethodExt.DeleteL());
+ if (dError == KErrNone)
+ {
+ DeleteLingerL(aId);
+ ret = ETrue;
+ }
+ }
+
+ CleanupStack::PopAndDestroy();
+ cmManagerExt.Close();
+ if (!iDatabase->InTransaction())
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("DeleteAPL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("DeleteAPL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ }
+
+ //The following code is kept under #ifndef , so that it can be removed
+ //after RD_DM_APPLICATION_LEVEL_ROAMING_SUPPORT becomes stable.
+
+ /* #ifndef RD_DM_APPLICATION_LEVEL_ROAMING_SUPPORT
+ CCommsDbTableView* checkView;
+ CCommsDbTableView* proxyView;
+
+ checkView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP),TPtrC(COMMDB_ID), aId);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ //
+ // Remove possible NAPDef-data first if ONLY IAP
+ //
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId;
+
+ checkView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ checkView->ReadUintL(TPtrC(IAP_SERVICE), serviceId);
+
+
+ CCommsDbTableView* tableView;
+ tableView= iDatabase->OpenViewMatchingUintLC(serviceType, TPtrC(COMMDB_ID), serviceId);
+ error = tableView->GotoFirstRecord();
+ if (error == KErrNone )
+ {
+ error = tableView->DeleteRecord();
+ }
+ CleanupStack::PopAndDestroy(); // tableView
+
+ //
+ // Delete Proxies for AP also
+ //
+ proxyView = iDatabase->OpenViewMatchingTextLC(TPtrC(PROXIES),
+ TPtrC(PROXY_SERVICE_TYPE),
+ serviceType);
+
+ TInt errorProxy = proxyView->GotoFirstRecord();
+
+ while (errorProxy == KErrNone)
+ {
+ TUint32 lValue;
+ proxyView->ReadUintL(TPtrC(PROXY_ISP),lValue);
+ if(lValue == serviceId)
+ {
+ proxyView->ReadUintL(TPtrC(COMMDB_ID),iProxyId);
+ DBG_ARGS8(_S8("DeleteAPL:Delete ServiceId=%d ProxyId=%d"),lValue, iProxyId);
+ error = proxyView->DeleteRecord();
+ }
+ errorProxy = proxyView->GotoNextRecord();
+ }
+
+ CleanupStack::PopAndDestroy(); // proxyView
+
+ error = checkView->DeleteRecord();
+ if( error == KErrNone )
+ {
+ ret = ETrue;
+ }
+
+ // Delete WAP also
+ if(WapAPExistsL(aId))
+ {
+ DeleteWapAPL(aId);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(); // checkView
+ #endif
+ */
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TPtrC8 CNSmlInternetAdapter::LastURISeg(const TDesC8& aURI)
+// Returns only the last uri segment
+//------------------------------------------------------------------------------
+TPtrC8 CNSmlInternetAdapter::LastURISeg(const TDesC8& aURI)
+ {
+ TInt i;
+ for (i = aURI.Length() - 1; i >= 0; i--)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+ if (i == 0)
+ {
+ return aURI;
+ }
+ else
+ {
+ return aURI.Mid(i + 1);
+ }
+ }
+
+//------------------------------------------------------------------------------
+// TPtrC8 CNSmlInternetAdapter::FirstURISeg(const TDesC8& aURI)
+// returns parent uri, i.e. removes last uri segment
+//------------------------------------------------------------------------------
+TPtrC8 CNSmlInternetAdapter::FirstURISeg(const TDesC8& aURI)
+ {
+ TInt j = 0;
+ for (TInt i = 0; i <= aURI.Length() - 1; i++)
+ {
+ if (aURI[i] == '/')
+ {
+ for (j = i + 1; j <= aURI.Length() - 1; j++)
+ {
+ if (aURI[j] == '/') // Second slash => AP/xxxx
+ break;
+ }
+ break;
+ }
+ }
+ return aURI.Left(j);
+ }
+
+//------------------------------------------------------------------------------
+// TPtrC8 CNSmlInternetAdapter::GetDynamicAPNodeUri( const TDesC8& aURI )
+// returns AP/xxx URI
+//------------------------------------------------------------------------------
+TPtrC8 CNSmlInternetAdapter::GetDynamicAPNodeUri(const TDesC8& aURI)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetDynamicAPNodeUri(): begin");
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::GetDynamicAPNodeUri() - <%S> "),
+ &aURI);
+
+ TInt i = 0;
+ for (i = aURI.Find(KNSmlDdfAP) + 3; i < aURI.Length(); i++)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::GetDynamicAPNodeUri(): end");
+
+ return aURI.Left(i);
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlInternetAdapter::ExecuteBufferL(const TDesC8& aURI)
+// Executes commands for AP after Bearer-data is set
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::ExecuteBufferL(const TDesC8& aURI,
+ const TBool aCompleting)
+ {
+ //
+ // Choose AP according to aURI
+ //
+ iExecutingBuffer = ETrue;
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ TPtrC8 parentUri = FirstURISeg(aURI);
+ if (iBuffer->At(i).iMappingName->Compare(parentUri) == 0)
+ {
+ iExecutionIndex = i;
+ break;
+ }
+ }
+
+ if ((iExecutionIndex < 0) || (iExecutionIndex >= iBuffer->Count()))
+ {
+ return;
+ }
+
+ iISPId = 0;
+ //
+ // Execute all commands for One AP NAPDef
+ //
+ if (iBuffer->At(iExecutionIndex).iDnsUpdateBuf)
+ {
+ iDnsUpdate = ETrue;
+ }
+
+ for (TInt cmd = iBuffer->At(iExecutionIndex).iNodeBuf->Count() - 1; cmd
+ >= 0; cmd--)
+ {
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+
+ if (iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iUri->Match(_L8(
+ "AP/*/Px*")) != 0)
+ {
+
+ if (!iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iLeaf)
+ {
+ addLUID.Format(KFormat, 0);
+ if (iBuffer->At(iExecutionIndex).iLuid > 0)
+ {
+ addLUID.Format(KFormat, -1); // Used for Status return
+ }
+ AddNodeObjectL(
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iUri->Des(),
+ addLUID, iBuffer->At(iExecutionIndex).iNodeBuf->At(
+ cmd).iStatusRef);
+
+ iBuffer->At(iExecutionIndex).iExecuted = ETrue;
+ }
+ else
+ {
+ if (iBuffer->At(iExecutionIndex).iDnsUpdateBuf)
+ {
+ addLUID.Zero();
+ addLUID.Append(iBuffer->At(iExecutionIndex).iNodeBuf->At(
+ cmd).iLuid->Des());
+ }
+ else
+ {
+ addLUID.Format(KFormat,
+ iBuffer->At(iExecutionIndex).iLuid);
+ if (!iBuffer->At(iExecutionIndex).iDirection || // The three values has to be set
+ !iBuffer->At(iExecutionIndex).iBearer
+ || !iBuffer->At(iExecutionIndex).iNameReceived) // before new AP set
+ {
+ addLUID.Format(KFormat, KNSmlIncompleteAP); // (-1) Used for error
+ } // Status return
+ }
+ //iIAPName = iBuffer->At(iExecutionIndex).iName->Des();
+
+ AddLeafObjectL(
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iUri->Des(),
+ addLUID,
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iData->Des(),
+ KNSmlMimeTypeTextPlain,
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iStatusRef);
+
+ if (iBuffer->At(iExecutionIndex).iLuid == 0) // After BearerL
+ iBuffer->At(iExecutionIndex).iLuid = iISPId;
+ }
+
+ TInt uidValue = IntLUID(addLUID);
+ if ((iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iUri->Des().Match(
+ _L8("AP/*/NAPDef/*/NAPAddr")) != KErrNotFound)
+ && (uidValue == KErrNone))
+ {
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iDone = EFalse;
+ }
+ else
+ {
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd).iDone = ETrue;
+ }
+
+ }
+
+ }
+ //
+ // Execute all commands for One AP Px
+ //
+ for (TInt cmd2 = 0; cmd2 < iBuffer->At(iExecutionIndex).iNodeBuf->Count(); cmd2++)
+ {
+ TBuf8<16> addLUID2;
+ _LIT8(KFormat, "%d");
+ if (!iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iDone)
+ {
+ if (!iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iLeaf)
+ {
+ addLUID2.Format(KFormat, 0);
+ if (iBuffer->At(iExecutionIndex).iLuid > 0)
+ {
+ addLUID2.Format(KFormat, -1); // Used for Status return
+ }
+ AddNodeObjectL(
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iUri->Des(),
+ addLUID2, iBuffer->At(iExecutionIndex).iNodeBuf->At(
+ cmd2).iStatusRef);
+
+ iBuffer->At(iExecutionIndex).iExecuted = ETrue;
+ }
+ else
+ {
+ addLUID2.Format(KFormat, iBuffer->At(iExecutionIndex).iLuid);
+ iIAPName = iBuffer->At(iExecutionIndex).iName->Des();
+ if (!iBuffer->At(iExecutionIndex).iDirection || // Allvalues has to be set
+ !iBuffer->At(iExecutionIndex).iBearer
+ || !iBuffer->At(iExecutionIndex).iName) // before new AP set
+ {
+ addLUID2.Format(KFormat, KNSmlIncompleteAP); // (-1) Used for error
+ } // Status return
+
+ AddLeafObjectL(
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iUri->Des(),
+ addLUID2,
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iData->Des(),
+ KNSmlMimeTypeTextPlain,
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iStatusRef);
+
+ if (iBuffer->At(iExecutionIndex).iLuid == 0) // After BearerL
+ iBuffer->At(iExecutionIndex).iLuid = iISPId;
+ }
+ } //++
+
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iDone = ETrue;
+
+ delete iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iUri;
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iUri = NULL;
+
+ if (iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iData)
+ {
+ delete iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iData;
+ iBuffer->At(iExecutionIndex).iNodeBuf->At(cmd2).iData = NULL;
+ }
+ }
+
+ // Wlan buffer execution only when called from CompleteOutstandingCmdsL (= aCompleting)
+ for (TInt i = 0; aCompleting && i
+ < iBuffer->At(iExecutionIndex).iWlanNodeBuf->Count(); ++i)
+ {
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+
+ if (!iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iLeaf)
+ {
+ addLUID.Format(KFormat, 0);
+
+ if (iBuffer->At(iExecutionIndex).iLuid > 0)
+ {
+ addLUID.Format(KFormat, iBuffer->At(iExecutionIndex).iLuid);
+ }
+
+ AddNodeObjectL(
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iUri->Des(),
+ addLUID,
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iStatusRef);
+
+ iBuffer->At(iExecutionIndex).iExecuted = ETrue;
+ }
+ else
+ {
+ addLUID.Zero();
+ addLUID.Append(
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iLuid->Des());
+
+ iIAPName = iBuffer->At(iExecutionIndex).iName->Des();
+
+ AddLeafObjectL(
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iUri->Des(),
+ addLUID,
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iData->Des(),
+ KNSmlMimeTypeTextPlain,
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iStatusRef);
+
+ if (iBuffer->At(iExecutionIndex).iLuid == 0) // After BearerL
+ {
+ iBuffer->At(iExecutionIndex).iLuid = iISPId;
+ }
+
+ }
+
+ iBuffer->At(iExecutionIndex).iWlanNodeBuf->At(i).iDone = ETrue;
+ }
+
+ //
+ // Remove data from handled AP-commands
+ //
+
+ ClearBuffer(iBuffer->At(iExecutionIndex).iNodeBuf);
+
+ if (aCompleting)
+ {
+ delete iBuffer->At(iExecutionIndex).iNodeBuf;
+
+ ClearBuffer(iBuffer->At(iExecutionIndex).iWlanNodeBuf);
+ delete iBuffer->At(iExecutionIndex).iWlanNodeBuf;
+
+ if (iBuffer->At(iExecutionIndex).iMappingName)
+ {
+ delete iBuffer->At(iExecutionIndex).iMappingName;
+ iBuffer->At(iExecutionIndex).iMappingName = NULL;
+ }
+
+ if (iBuffer->At(iExecutionIndex).iName)
+ {
+ delete iBuffer->At(iExecutionIndex).iName;
+ iBuffer->At(iExecutionIndex).iName = NULL;
+ }
+
+ iBuffer->Delete(iExecutionIndex);
+ iBuffer->Compress();
+ }
+
+ iExecutingBuffer = EFalse;
+ iStaleMapUpdate = EFalse;
+ }
+
+//------------------------------------------------------------------------------
+// TPtrC16 CNSmlInternetAdapter::GetAddURISeg(const TDesC8& aURI,const TDesC8 aName)
+// Returns uri segment until the next segment after given aName
+//------------------------------------------------------------------------------
+TPtrC8 CNSmlInternetAdapter::GetAddURISeg(const TDesC8& aURI,
+ const TDesC8& aName)
+ {
+ TInt lStrt = aURI.Find(aName);
+ if (lStrt == KErrNotFound)
+ {
+ return aURI;
+ }
+
+ lStrt += 1;
+ TInt i = 0;
+ for (i = lStrt + aName.Length(); i <= aURI.Length() - 1; i++)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+ if (i == 0)
+ {
+ return aURI;
+ }
+ else
+ {
+ return aURI.Left(i);
+ }
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeWAPAIPL()
+// Initialize WAP IAP-data before insert
+//
+//=============================================
+TInt CNSmlInternetAdapter::InitializeWAPIAPL(CCommsDbTableView* aTable,
+ const TDesC8& aName)
+ {
+ aTable->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(aName)); // Same as IAP
+
+
+ aTable->WriteTextL(TPtrC(WAP_CURRENT_BEARER), iWapBearer);
+ aTable->WriteLongTextL(TPtrC(WAP_START_PAGE), ConvertTo16LC(
+ iWAPAccessPoint));
+ CleanupStack::PopAndDestroy(2); //ConvertTo16LC
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeWAPL()
+// Initialize WAP IP Bearer-data before insert
+//
+//=============================================
+TInt CNSmlInternetAdapter::InitializeWAPL(CCommsDbTableView* aTable)
+ {
+ TUint32 wapPortNumber = 0;
+
+ aTable->WriteUintL(TPtrC(WAP_ACCESS_POINT_ID), iWapId);
+ aTable->WriteTextL(TPtrC(WAP_GATEWAY_ADDRESS), KNSmlEmptyIpv4Address);
+
+ aTable->WriteUintL(TPtrC(WAP_WSP_OPTION), EWapWspOptionConnectionOriented); // EWapWspOptionConnectionless
+ aTable->WriteBoolL(TPtrC(WAP_SECURITY), EFalse); // if 9200 => false
+
+ aTable->WriteUintL(TPtrC(WAP_IAP), iISPId);
+ aTable->WriteUintL(TPtrC(WAP_PROXY_PORT), wapPortNumber);
+
+ aTable->WriteTextL(TPtrC(WAP_PROXY_LOGIN_NAME), ConvertTo16LC(
+ iWapUserName));
+ aTable->WriteTextL(TPtrC(WAP_PROXY_LOGIN_PASS), ConvertTo16LC(
+ iWapPassword));
+
+ CleanupStack::PopAndDestroy(2); //ConvertTo16LC
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::IsWapPort()
+// Check if portnbr for proxy or wap
+//
+//=============================================
+void CNSmlInternetAdapter::IsWapPort(const TDesC8& aObject)
+ {
+ iWapPort = EFalse;
+ TInt portNbr = GetIntObject8(aObject);
+ if (portNbr >= KNSmlApWapLowerBase && portNbr <= KNSmlApWapUpperBase)
+ {
+ iWapPort = ETrue;
+ }
+ }
+
+// -------------------------------------------------------------------------------------
+// CNSmlInternetAdapter::FillNodeInfoL()
+// Fills the node info in ddf structure
+// -------------------------------------------------------------------------------------
+void CNSmlInternetAdapter::FillNodeInfoL(MSmlDmDDFObject& aNode,
+ TSmlDmAccessTypes aAccTypes, MSmlDmDDFObject::TOccurence aOccurrence,
+ MSmlDmDDFObject::TScope aScope, MSmlDmDDFObject::TDFFormat aFormat,
+ const TDesC8& aDescription)
+
+ {
+ aNode.SetAccessTypesL(aAccTypes);
+ aNode.SetOccurenceL(aOccurrence);
+ aNode.SetScopeL(aScope);
+ aNode.SetDFFormatL(aFormat);
+ if (aFormat != MSmlDmDDFObject::ENode)
+ {
+ aNode.AddDFTypeMimeTypeL(KNSmlMimeType);
+ }
+ aNode.SetDescriptionL(aDescription);
+ }
+
+//=======================================================
+// CNSmlInternetAdapter::UpdateIAPnameL()
+// Update IAP-table name add Network-table if needed
+// Add/update WAP-table name also
+//
+//=======================================================
+TInt CNSmlInternetAdapter::UpdateIAPnameL(TUint32 aId, const TDesC8& aObject)
+ {
+
+ TUint32 nwId = 0;
+ TInt ret = KErrNone;
+ TBool iapReLock = EFalse;
+
+ TBool apEnforce = EFalse;
+ TRAPD( eError,apEnforce=CheckEnforcementL() )
+ DBG_ARGS8(_S8("CNSmlInternetAdapter::UpdateIAPNAme(): EError %d , APEnforcement is %d"),eError,apEnforce);
+ if (eError == KErrNone && apEnforce)
+ {
+ DoLockIAPTablesL(EFalse);
+ iWAPRelock = ETrue;
+ }
+
+ CCommsDbTableView* iapUpdate = iDatabase->OpenViewMatchingUintLC(TPtrC(
+ IAP), TPtrC(COMMDB_ID), aId);
+ if (IsIAPRecordLockedL(aId))
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is LOCKED");
+ TInt reclockerr =
+ ((CCommsDbProtectTableView*) iapUpdate)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = ETrue;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::AddLeafObjectL(): apaccesspoint record is not write protected");
+ }
+ TInt error = iapUpdate->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::UpdateIAPName, IAP_NETWORK set");
+ TRAPD(err, iapUpdate->ReadUintL(TPtrC(IAP_NETWORK), nwId));
+
+ if (iapUpdate->UpdateRecord() == KErrNone)
+ {
+ iapUpdate->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(aObject));
+
+ if (err != KErrNone) // Network entry not yet created
+ {
+ AddNetworkL(nwId, aObject);
+ if (nwId > 0)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::UpdateIAPName, IAP_NETWORK set");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::UpdateIAPName(): networks is %d"),
+ nwId);
+ iapUpdate->WriteUintL(TPtrC(IAP_NETWORK), nwId);
+ }
+ else
+ {
+ ret = KErrGeneral;
+ }
+ }
+ iapUpdate->PutRecordChanges();
+ }
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ }
+ CleanupStack::PopAndDestroy(); // iapUpdate
+
+
+ if (WapAPExistsL(aId))
+ { // Update handled
+ CCommsDbTableView* wapView;
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_ACCESS_POINT),
+ TPtrC(COMMDB_ID), iWapId);
+ TInt errorCode = wapView->GotoFirstRecord();
+
+ // Read all columns needed.
+ if (errorCode == KErrNone)
+ {
+ if (wapView->UpdateRecord() == KErrNone)
+ {
+ wapView->WriteTextL(TPtrC(COMMDB_NAME),
+ ConvertTo16LC(aObject));
+ wapView->PutRecordChanges();
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ }
+ }
+ CleanupStack::PopAndDestroy(); // wapView
+ }
+ else
+ { // Insert handled
+ CCommsDbTableView* insView;
+ TInt wapInitOK = KErrCancel;
+
+ insView = iDatabase->OpenTableLC(TPtrC(WAP_ACCESS_POINT));
+ iWapId = 0;
+ wapInitOK = insView->InsertRecord(iWapId);
+ if (wapInitOK == KErrNone)
+ {
+ iWAPAccessPoint.Zero();
+ iWapUserName.Zero();
+ iWapPassword.Zero();
+ iWapBearer = TPtrC(WAP_IP_BEARER);
+
+ wapInitOK = InitializeWAPIAPL(insView, aObject);
+ wapInitOK = insView->PutRecordChanges();
+
+ if (wapInitOK == KErrNone)
+ {
+ CCommsDbTableView* updView;
+ TUint32 iWapId2 = 0;
+ iISPId = aId; // IAP number set
+ updView = iDatabase->OpenTableLC(TPtrC(WAP_IP_BEARER));
+ if (updView->InsertRecord(iWapId2) == KErrNone)
+ {
+ InitializeWAPL(updView);
+ updView->PutRecordChanges();
+ }
+ CleanupStack::PopAndDestroy(); // updView
+ }
+ }
+ else
+ {
+ ret = KErrGeneral;
+ }
+ CleanupStack::PopAndDestroy(); // insView
+ }
+ if (FeatureManager::FeatureSupported(KFeatureIdSapPolicyManagement))
+ {
+ if (iWAPRelock)
+ {
+ DoLockIAPTablesL(ETrue);
+ iWAPRelock = EFalse;
+ }
+ }
+ if (iapReLock)
+ {
+ TInt reclockerr = DoProtectIAPRecordL(aId, ETrue);
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::AddLeafObjectL ,UnProtecting IAPAccessRecord returned code = %d"),
+ reclockerr);
+ if (reclockerr == KErrNone)
+ iapReLock = EFalse;
+ }
+ return ret;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeVPNServiceL()
+// Initialize VPNService-data before insert
+//=============================================
+TInt CNSmlInternetAdapter::InitializeVPNServiceL(CCommsDbTableView* aTable)
+ {
+ _LIT(KdefPolicy, "Home");
+
+ aTable->WriteTextL(TPtrC(COMMDB_NAME), iIAPName); // Same as IAP
+
+ aTable->WriteTextL(TPtrC(VPN_SERVICE_POLICY), KdefPolicy);
+ aTable->WriteUintL(TPtrC(VPN_SERVICE_IAP), 1);
+ aTable->WriteUintL(TPtrC(VPN_SERVICE_NETWORKID), 1);
+
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::InitializeLANServiceL()
+// Initialize LANService-data before insert
+//=============================================
+TInt CNSmlInternetAdapter::InitializeLANServiceL(CCommsDbTableView* aTable)
+ {
+ if (!iWlanSupported)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::InitializeLANServiceL, WLAN not supported.");
+ return KErrNotSupported;
+ }
+ _LIT(KgifNetworks, "ip,ip6");
+ _LIT(Kdns6Address, "0:0:0:0:0:0:0:0");
+ _LIT(KdefaultNetmask, "255.255.255.0");
+
+ aTable->WriteTextL(TPtrC(COMMDB_NAME), ConvertTo16LC(iIAPName)); // Same as IAP
+ aTable->WriteTextL(TPtrC(LAN_IF_NETWORKS), KgifNetworks);
+ aTable->WriteBoolL(TPtrC(SERVICE_IP_ADDR_FROM_SERVER), ETrue); // DHCP by default.
+ aTable->WriteTextL(TPtrC(SERVICE_IP_ADDR), KNSmlEmptyIpv4Address);
+ aTable->WriteTextL(TPtrC(SERVICE_IP_NETMASK), KdefaultNetmask);
+ aTable->WriteBoolL(TPtrC(SERVICE_IP_DNS_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(SERVICE_IP_NAME_SERVER1), KNSmlEmptyIpv4Address);
+ aTable->WriteTextL(TPtrC(SERVICE_IP_NAME_SERVER2), KNSmlEmptyIpv4Address);
+ aTable->WriteTextL(TPtrC(SERVICE_IP_GATEWAY), KNSmlEmptyIpv4Address);
+
+ aTable->WriteBoolL(TPtrC(SERVICE_IP6_DNS_ADDR_FROM_SERVER), ETrue);
+ aTable->WriteTextL(TPtrC(SERVICE_IP6_NAME_SERVER1), Kdns6Address);
+ aTable->WriteTextL(TPtrC(SERVICE_IP6_NAME_SERVER2), Kdns6Address);
+ aTable->WriteTextL(TPtrC(SERVICE_CONFIG_DAEMON_MANAGER_NAME),
+ KDaemonManagerName);
+ aTable->WriteTextL(TPtrC(SERVICE_CONFIG_DAEMON_NAME), KConfigDaemonName);
+
+ CleanupStack::PopAndDestroy(); //ConvertTo16LC
+ return KErrNone;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::IsWLANfield()
+// Check if handled by WLAN-adapter
+//=============================================
+TBool CNSmlInternetAdapter::IsWLANfield(const TDesC8& aURI)
+ {
+ TBool ret(EFalse);
+
+ SetField(aURI);
+
+ if (KNSmlDdfNetworkID().Match(*iField) == 0) // ID not valid
+ {
+ return ret;
+ }
+ if (KNSmlDdfAP().Match(*iField) == 0) // AP not valid
+ {
+ return ret;
+ }
+ if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*")) != KErrNotFound)
+ {
+ DBG_ARGS8(_S8("AP:IsWLANfield URI - <%S> <%S> FOUND"), &aURI, iField);
+ ret = ETrue;
+ }
+
+ return ret;
+ }
+
+//=============================================
+// CNSmlInternetAdapter::IsWlanL()
+// Check if WLAN accesspoint
+//=============================================
+TBool CNSmlInternetAdapter::IsWlanL(const TDesC8& aURI)
+ {
+ TBool ret(EFalse);
+
+ if (!iWlanSupported)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::IsWlanL, WLAN not supported.");
+ return ret;
+ }
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ // Get IAP nbr for servicetype
+ TUint32 apWlan = GetAPIdFromURIL(aURI);
+
+ // IAP-table search serviceType (=Bearer)
+ CCommsDbTableView* iapViews = iDatabase->OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), apWlan);
+
+ TInt errorCode = iapViews->GotoFirstRecord();
+
+ // Read iapService from (IAP)
+ if (errorCode == KErrNone)
+ {
+ iapViews->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ if (serviceType == TPtrC(LAN_SERVICE))
+ {
+ ret = ETrue;
+ }
+ }
+ CleanupStack::PopAndDestroy(); // iapViews
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::GetLanBearerL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::GetLanBearerL(TUint32& aId)
+ {
+ TBool ret = EFalse;
+
+ if (!iWlanSupported)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetLanBearerL, WLAN not supported.");
+ return ret;
+ }
+
+ CCommsDbTableView* checkView;
+
+ HBufC* bName = HBufC::NewLC(15);
+ TPtr bNamePtr = bName->Des();
+ _LIT(KWlanBearer, "WLANBearer");
+ bNamePtr.Format(KWlanBearer);
+
+ checkView = iDatabase->OpenViewMatchingTextLC(TPtrC(LAN_BEARER), TPtrC(
+ COMMDB_NAME), bNamePtr);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ checkView->ReadUintL(TPtrC(COMMDB_ID), aId);
+ ret = ETrue;
+ }
+ else
+ {
+ aId = 1; // Default modem
+ }
+ DBG_ARGS8(_S8("CNSmlInternetAdapter:GetLanBearerL %d"), aId);
+
+ CleanupStack::PopAndDestroy(2); // checkView bName
+
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::GetModemBearerL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::GetModemBearerL(TUint32& aId)
+ {
+ TBool ret = EFalse;
+ CCommsDbTableView* checkView;
+
+ HBufC* bName = HBufC::NewLC(15);
+ TPtr bNamePtr = bName->Des();
+
+ if (iBearer == TPtrC(OUTGOING_GPRS) || iBearer == TPtrC(INCOMING_GPRS))
+ {
+ _LIT(KGprsModem, "GPRS Modem");
+ bNamePtr.Format(KGprsModem);
+ }
+
+ checkView = iDatabase->OpenViewMatchingTextLC(TPtrC(MODEM_BEARER), TPtrC(
+ COMMDB_NAME), bNamePtr);
+ TInt error = checkView->GotoFirstRecord();
+ if (error == KErrNone)
+ {
+ checkView->ReadUintL(TPtrC(COMMDB_ID), aId);
+ ret = ETrue;
+ }
+ else
+ {
+ aId = 5; // Default modem 1->5 ???
+ }
+ DBG_ARGS8(_S8("CNSmlInternetAdapter:GetModemBearerL %d"), aId);
+
+ CleanupStack::PopAndDestroy(2); // checkView bName
+
+ return ret;
+ }
+
+// ---------------------------------------------------------
+// NextAPNameL()
+// Generates new AP name.
+// ---------------------------------------------------------
+void CNSmlInternetAdapter::NextAPNameL(const TDesC8& aName)
+ {
+ // generate name candidate
+ HBufC8* nameCandidate = HBufC8::NewLC(aName.Length() + 12);
+ TPtr8 candidatePtr = nameCandidate->Des();
+
+ // loop while valid name is found
+ TBool validName;
+
+ // loop while valid name is found
+ TInt i = 0;
+ do
+ {
+ validName = ETrue;
+ candidatePtr.Format(aName);
+ if (i > 0)
+ {
+ _LIT(KLeftBrace, "(");
+ _LIT(KRightBrace, ")");
+ HBufC* buf = HBufC::NewLC(10); //10 = max length of 32bit integer
+ TPtr ptrBuf = buf->Des();
+ ptrBuf.Num(i);
+ candidatePtr.Append(KLeftBrace);
+ candidatePtr.Append(ptrBuf);
+ candidatePtr.Append(KRightBrace);
+ CleanupStack::PopAndDestroy(); //buf
+ }
+ i++;
+ if (!IsValidNameL(candidatePtr))
+ {
+ validName = EFalse;
+ }
+ }
+ while (!validName);
+
+ iIAPName = candidatePtr;
+
+ CleanupStack::PopAndDestroy(); //nameCandidate
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::IsValidNameL()
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::IsValidNameL(const TDesC8& aName)
+ {
+ TBool ret = ETrue;
+ CCommsDbTableView* nameView;
+
+ nameView = iDatabase->OpenViewMatchingTextLC(TPtrC(IAP), TPtrC(
+ COMMDB_NAME), aName);
+
+ TInt errorCode = nameView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ ret = EFalse; // If found error returned
+ }
+
+ CleanupStack::PopAndDestroy(); // nameView
+ return ret;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::InitializeDNSParamsFromBuffL(const TPtrC8 aParentUri,
+// TInt& aDnsPri )
+// Finds parameters needed in updating DNSAddrL from buffer
+//------------------------------------------------------------------------------
+TBool CNSmlInternetAdapter::InitializeDNSParamsFromBuffL(
+ const TPtrC8 aParentUri, TInt& aDnsPri)
+ {
+ TInt cmd(0);
+ TBool found(EFalse);
+
+ TNSmlAPBufferElement& thisElem = iBuffer->At(0);
+
+ // Parse URI to match
+ CBufBase* buf = CBufFlat::NewL(150);
+ CleanupStack::PushL(buf);
+ buf->InsertL(0, aParentUri);
+ buf->InsertL(buf->Size(), KNSmlDmApValFSlash);
+ buf->InsertL(buf->Size(), KNSmlDdfDNSPriority);
+ TBuf8<150> tmp;
+ buf->Read(0, tmp, buf->Size());
+
+ cmd = thisElem.iNodeBuf->Count() - 1;
+ // check if the DNSPriority is sent for DNSAddr/<x>
+ while (cmd >= 0)
+ {
+ if (thisElem.iNodeBuf->At(cmd).iUri->Match(tmp) != KErrNotFound)
+ {
+ TLex8 lex(thisElem.iNodeBuf->At(cmd).iData->Des());
+ lex.Val(aDnsPri);
+ thisElem.iNodeBuf->At(cmd).iDone = ETrue;
+ found = ETrue;
+ }
+ cmd--;
+ }
+ CleanupStack::PopAndDestroy(buf);
+ return found;
+ }
+
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::DnsToLuid(const UriUtils::TUriHostType aType,)
+// const TInt aPriority ) const
+// Encodes special luid for DNSAddr/<X>
+//------------------------------------------------------------------------------
+TInt CNSmlInternetAdapter::DnsToLuid(const UriUtils::TUriHostType aType,
+ const TInt aPriority) const
+ {
+ return KNSmlApDnsLuidUpperBase + static_cast<TInt> (aType) * 10
+ + aPriority;
+ }
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::LuidToDns(UriUtils::TUriHostType& aType,)
+// TInt& aPriority, const TInt aLuid ) const
+// Decodes DNAddr/<X> type from LUID
+//------------------------------------------------------------------------------
+TInt CNSmlInternetAdapter::LuidToDns(UriUtils::TUriHostType& aType,
+ TInt& aPriority, const TInt aLuid) const
+ {
+ TInt err = KErrNone;
+ if (aLuid < KNSmlApDnsLuidUpperBase)
+ {
+ err = KErrGeneral;
+ }
+ else
+ {
+ aPriority = (aLuid - KNSmlApDnsLuidUpperBase) % 10;
+ if ((aPriority > 0) && (aPriority < 3))
+ {
+ TInt type = (aLuid - KNSmlApDnsLuidUpperBase - aPriority) / 10;
+ if ((type >= 0) && (type < 2))
+ {
+ aType = static_cast<UriUtils::TUriHostType> (type);
+ }
+ else
+ {
+ err = KErrGeneral;
+ }
+ }
+ else
+ {
+ err = KErrGeneral;
+ }
+ }
+ return err;
+ }
+//------------------------------------------------------------------------------
+// TBool CNSmlInternetAdapter::RemoveLastSeg(const TDesC8& aURI)
+// Returns URI without its last segment
+//------------------------------------------------------------------------------
+TPtrC8 CNSmlInternetAdapter::RemoveLastSeg(const TDesC8& aURI) const
+ {
+ TInt i;
+ for (i = aURI.Length() - 1; i >= 0; i--)
+ {
+ if (aURI[i] == KNSmlDMUriSeparator)
+ {
+ break;
+ }
+ }
+ if (i > 0)
+ {
+ return aURI.Left(i);
+ }
+ else
+ {
+ return KNullDesC8();
+ }
+ }
+
+//------------------------------------------------------------------------------
+// void CNSmlInternetAdapter::ClearBuffer()
+// Deletes all dynamically allocated data from given array's each element
+// and resets the buffer.
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::ClearBuffer(
+ CArrayFixFlat<TNSmlAPAddElement>* aBuffer)
+ {
+ for (TInt i = 0; i < aBuffer->Count(); i++)
+ {
+ delete aBuffer->At(i).iUri;
+ aBuffer->At(i).iUri = NULL;
+
+ delete aBuffer->At(i).iData;
+ aBuffer->At(i).iData = NULL;
+
+ delete aBuffer->At(i).iLuid;
+ aBuffer->At(i).iLuid = NULL;
+ }
+
+ aBuffer->Reset();
+ }
+
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::IsValidIPv4AddressL(const TDesC8& aNapAddr)
+//Checks if the string is of correct IPV4 address format x.x.x.x and
+//numbers are within the range 0-255
+//returns true on sucess and false on failure.
+//----------------------------------------------------------------------
+TBool CNSmlInternetAdapter::IsValidIPv4AddressL(const TDesC8& aNapAddr)
+ {
+ TInt digitLen(0);
+ TBool ret = EFalse;
+ _LIT8(KNSmlDMV4Format, "*.*.*.*");
+
+ if (aNapAddr.Match(KNSmlDMV4Format) != KErrNotFound)
+ {
+ TInt pos = 0;
+ TInt numDots = 0;
+ TInt maxIP = 255;
+ TInt minIP = 0;
+ for (TInt i = 0; i < aNapAddr.Length(); i++)
+ {
+ digitLen++;
+ //Check if aNapAddr contain any characters other than
+ // 0 - 9 and ".", If yes return from the function.
+ if (aNapAddr[i] != KNSmlDMDot && (aNapAddr[i]
+ < KNSmlDMAsciiIntStart || aNapAddr[i]
+ > KNSmlDMAsciiIntEnd))
+ {
+ ret = EFalse;
+ break;
+ }
+ if (aNapAddr[i] == KNSmlDMDot)
+ {
+ ret = ETrue;
+ if (i > 0)
+ {
+ TInt digit;
+ TPtrC8 ptrOneDigit = aNapAddr.Mid(pos, digitLen - 1);
+ TLex8 lexint(ptrOneDigit);
+ if (lexint.Val(digit) != KErrNone || digit >= maxIP
+ || digit < minIP)
+ {
+ ret = EFalse;
+ break;
+ }
+ } // end of if i > 0
+ pos = i + 1;
+ numDots++;
+ digitLen = 0;
+ } // end of if
+ } //End of for
+ if (numDots == 3 && ret)
+ {
+ ret = ETrue;
+ }
+ else
+ {
+ ret = EFalse;
+ }
+ } // end of outer if, format check
+ return ret;
+ }
+
+TBool CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL(TUint32 aRecord)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL(): BEGIN");
+ TBool ret = EFalse;
+ CCommsDbTableView* wapView;
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL record being checked = %d"),
+ aRecord);
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_ACCESS_POINT),
+ TPtrC(COMMDB_ID), aRecord);
+
+ TInt aAccess(0);
+ if (wapView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL():wap record exists, check for access type");
+ TInt err = (((CCommsDbProtectTableView*) wapView)->GetRecordAccess(
+ aAccess));
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL , GetrecordAccess code is =%d and acess type of record = %d"),
+ err, aAccess);
+ CleanupStack::PopAndDestroy(wapView);
+ if (aAccess == RDbRowSet::EReadOnly)
+ ret = ETrue;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::IsWAPAccessPointRecordLockedL(): END");
+ return ret;
+
+ }
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::DoProtectWAPAccessRecordL(TUint32 aRecord,TBool aProtect)
+// protect or unprotect wapaccesspoint record of access point being altered
+//----------------------------------------------------------------------
+
+
+TInt CNSmlInternetAdapter::DoProtectWAPAccessRecordL(TUint32 aRecord,
+ TBool aProtect)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectWAPAccessRecordL(): BEGIN");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectWAPAccessRecordL , record and protect value =%d = %d"),
+ aRecord, aProtect);
+ TInt err = KErrNone;
+
+ CCommsDbTableView* wapView;
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(WAP_ACCESS_POINT),
+ TPtrC(COMMDB_ID), aRecord);
+ if (wapView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::DoProtectWAPAccessRecordL(): wap record exists");
+ if (!aProtect)
+ {
+ err = ((CCommsDbProtectTableView*) wapView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectWAPAccessRecordL ,error code of Unprotectrecord = %d"),
+ err);
+ }
+
+ else
+ {
+ err = ((CCommsDbProtectTableView*) wapView)->ProtectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectWAPAccessRecordL ,error code of ProtectRecord = %d"),
+ err);
+ }
+
+ CleanupStack::PopAndDestroy(wapView);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectWAPAccessRecordL(): END");
+ return err;
+ }
+
+//------------------------------------------------------------------------------
+// TUint32 CNSmlInternetAdapter::GetIAPSeamlessnessL(TUint32 aId)
+// Gets the seamlessness value from the IAPMetadata table though the cmmanager API
+//------------------------------------------------------------------------------
+
+TUint32 CNSmlInternetAdapter::GetIAPSeamlessnessL(TUint32 aId)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetIAPSeamlessnessL(): begin");
+ //Deleting iDatabase, Required since CommsDB has one view open for reading and commsdat API would
+ //return KErrLocked if this is not done
+ TBool reopenTransaction(EFalse);
+ if (iDatabase->InTransaction())
+ {
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ reopenTransaction = ETrue;
+ }
+
+ RCmManagerExt cmManagerExt;
+ cmManagerExt.OpenL();
+ RCmConnectionMethodExt cm = cmManagerExt.ConnectionMethodL(aId);
+ CleanupClosePushL(cm);
+ TUint32 smless = cm.GetIntAttributeL(CMManager::ECmSeamlessnessLevel);
+ CleanupStack::PopAndDestroy();
+ cmManagerExt.Close();
+
+ //Recreate reference to CommsDB since other tables
+ //are manipulated with Commsdb
+ if (reopenTransaction)
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("GetIAPSeamlessnessL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("GetIAPSeamlessnessL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::GetIAPSeamlessnessL(): End");
+ return smless;
+
+ }
+
+//------------------------------------------------------------------------------
+// TUint32 CNSmlInternetAdapter::GetIAPMetaDataL(TUint32 aId)
+// Gets the metadata value from the IAPMetadata table though the cmmanager API
+//--------------------------------------------------------------------------
+
+TUint32 CNSmlInternetAdapter::GetIAPMetaDataL(TUint32 aId)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::GetIAPMetaDataL(): begin");
+ //Deleting iDatabase, Required since CommsDB has one view open for reading and commsdat API would
+ //return KErrLocked if this is not done
+ TBool reopenTransaction(EFalse);
+ if (iDatabase->InTransaction())
+ {
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ reopenTransaction = ETrue;
+ }
+
+ TUint32 metadata, highlight, hidden;
+ RCmManagerExt cmManagerExt;
+
+ cmManagerExt.OpenL();
+ RCmConnectionMethodExt cm = cmManagerExt.ConnectionMethodL(aId);
+ CleanupClosePushL(cm);
+
+ TBool metaHidden = cm.GetBoolAttributeL(CMManager::ECmMetaHiddenAgent);
+ TBool metaHL = cm.GetBoolAttributeL(CMManager::ECmMetaHighlight);
+ highlight = EMetaHighlight & metaHL;
+ hidden = EMetaHiddenAgent & metaHidden;
+ metadata = highlight | hidden;
+
+ CleanupStack::PopAndDestroy();
+ cmManagerExt.Close();
+ //Recreate reference to CommsDB since other tables
+ //are manipulated with Commsdb
+ if (reopenTransaction)
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("GetIAPMetaDataL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("GetIAPMetaDataL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::GetIAPMetaDataL(): end");
+ return metadata;
+
+ }
+//------------------------------------------------------------------------------
+// void CNSmlInternetAdapter::SetIAPSeamlessnessL(TUint32 apMetaID,TUint32 aSeam,TInt aStatusRef)
+// Sets the seamlessness value to the IAPMetadata table though the cmmanager API
+//------------------------------------------------------------------------------
+void CNSmlInternetAdapter::SetIAPSeamlessnessL(TUint32 apMetaID,
+ TUint32 aSeam, TInt aStatusRef)
+ {
+
+ _DBG_FILE("CNSmlInternetAdapter::SetIAPSeamlessnessL(): begin");
+ TBool reopenTransaction(EFalse);
+ if (iDatabase->InTransaction())
+ {
+ iDatabase->CommitTransaction();
+ iTransactionCommitted = ETrue;
+ reopenTransaction = ETrue;
+ }
+
+ RCmManagerExt cmManagerExt;
+ cmManagerExt.OpenL();
+ RCmConnectionMethodExt cm;
+ TInt cmerror = KErrNone;
+ TRAP(cmerror, cm = cmManagerExt.ConnectionMethodL(apMetaID));
+ CleanupClosePushL(cm);TRAPD(sErr,cm.SetIntAttributeL( CMManager::ECmSeamlessnessLevel,aSeam ))
+ if(sErr == KErrNone)
+ {
+ cm.UpdateL();
+ iCallBack->SetStatusL(aStatusRef,CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,CSmlDmAdapter::EError);
+ }
+
+ CleanupStack::PopAndDestroy();
+
+ cmManagerExt.Close();
+ // iDatabase = CCommsDatabase::NewL();
+ if (reopenTransaction)
+ {
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("SetIAPSeamlessnessL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("SetIAPSeamlessnessL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::SetIAPSeamlessnessL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// void CNSmlInternetAdapter::SetIAPMetaDataL(TUint32 apMetaID,TUint32 aMeta,TInt aStatusRef)
+// Sets the metadata value to the IAPMetadata table though the cmmanager API
+//------------------------------------------------------------------------------
+
+void CNSmlInternetAdapter::SetIAPMetaDataL(TUint32 apMetaID, TUint32 aMeta,
+ TInt aStatusRef)
+ {
+
+ _DBG_FILE("CNSmlInternetAdapter::SetIAPMetaDataL(): begin");
+ TInt hMHLErr = KErrNone;
+ TInt hMHAErr = KErrNone;
+ if (iDatabase)
+ {
+ iDatabase->CommitTransaction();
+ // delete iDatabase;
+ }
+ RCmManagerExt cmManagerExt;
+ cmManagerExt.OpenL();
+ RCmConnectionMethodExt cm = cmManagerExt.ConnectionMethodL(apMetaID);
+ CleanupClosePushL(cm);
+
+ if (aMeta & EMetaHighlight)
+ {
+ TRAP(hMHLErr,
+ cm.SetBoolAttributeL(CMManager::ECmMetaHighlight, ETrue));
+ }
+ else
+ {
+ TRAP(hMHLErr, cm.SetBoolAttributeL(CMManager::ECmMetaHighlight,
+ EFalse));
+ }
+
+ if (aMeta & EMetaHiddenAgent)
+ {
+ TRAP(hMHAErr, cm.SetBoolAttributeL(CMManager::ECmMetaHiddenAgent,
+ ETrue));
+ }
+ else
+ {
+ TRAP(hMHAErr, cm.SetBoolAttributeL(CMManager::ECmMetaHiddenAgent,
+ EFalse));
+ }
+ if ((hMHAErr == KErrNone) && (hMHLErr == KErrNone))
+ {
+ cm.UpdateL();
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+
+ CleanupStack::PopAndDestroy();
+
+ cmManagerExt.Close();
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("SetIAPMetaDataL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("SetIAPMetaDataL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::SetIAPMetaDataL(): end");
+ }
+
+void CNSmlInternetAdapter::AddLingerL(const TInt aIapId,
+ const TInt aLingerInterval)
+ {
+ TInt err(KErrNone);
+
+ // Open repository
+ CRepository* repository = CRepository::NewLC(KCRUidPDPContextManager);
+
+ // Find if an entry for "iapId" already exists in CentRep
+ RArray<TUint32> foundKeys;
+ foundKeys.Reset();
+
+ err = repository->FindEqL(KIapColumn, // partial key
+ KColumnMask, // key mask
+ aIapId, // value
+ foundKeys); // found keys
+
+ if (err == KErrNone || err == KErrNotFound)
+ {
+ if (foundKeys.Count() == 0)
+ {
+ // Add a new entry
+ TInt arrayCount(0);
+
+ // Get number of iapId&linger entries in Centrep
+ err = repository->Get(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+
+ if (err == KErrNone)
+ {
+ arrayCount++;
+
+ err = repository->Create((KIapColumn | arrayCount), aIapId);
+
+ if (err == KErrNone)
+ {
+ err = repository->Create((KLingerColumn | arrayCount),
+ aLingerInterval);
+ }
+
+ if (err == KErrNone)
+ {
+ // Update number of iapId&linger entries in Centrep
+ err = repository->Set(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+ }
+ }
+ }
+ else
+ {
+ // Update existing entry on current row
+ TInt32 row = foundKeys[0] & KRowMask;
+
+ err = repository->Set((KLingerColumn | row), aLingerInterval);
+ }
+ }
+
+ foundKeys.Close();
+ CleanupStack::PopAndDestroy(repository);
+
+ User::LeaveIfError(err);
+ }
+
+void CNSmlInternetAdapter::UpdateLingerL(const TInt aIapId,
+ const TInt aLingerInterval)
+ {
+ TInt err(KErrNone);
+
+ // Open repository
+ CRepository* repository = CRepository::NewLC(KCRUidPDPContextManager);
+
+ // Find if an entry for "iapId" already exists in CentRep
+ RArray<TUint32> foundKeys;
+ foundKeys.Reset();
+
+ err = repository->FindEqL(KIapColumn, // partial key
+ KColumnMask, // key mask
+ aIapId, // value
+ foundKeys); // found keys
+
+ if (err == KErrNone || err == KErrNotFound)
+ {
+
+ if (foundKeys.Count() == 0)
+ {
+ // Add a new entry
+ TInt arrayCount(0);
+
+ // Get number of iapId&linger entries in Centrep
+ err = repository->Get(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+
+ if (err == KErrNone)
+ {
+ arrayCount++;
+
+ err = repository->Create((KIapColumn | arrayCount), aIapId);
+
+ if (err == KErrNone)
+ {
+ err = repository->Create((KLingerColumn | arrayCount),
+ aLingerInterval);
+ }
+
+ if (err == KErrNone)
+ {
+ // Update number of iapId&linger entries in Centrep
+ err = repository->Set(KPdpContextManagerLingerArrayCount,
+ arrayCount);
+ }
+ }
+ }
+ else
+ {
+ // Update existing entry on currebt row
+ TInt32 row = foundKeys[0] & KRowMask;
+
+ err = repository->Set((KLingerColumn | row), aLingerInterval);
+ }
+ }
+
+ foundKeys.Close();
+ CleanupStack::PopAndDestroy(repository);
+
+ User::LeaveIfError(err);
+ }
+void CNSmlInternetAdapter::GetLingerL(const TInt aIapId,
+ TInt& aLingerInterval)
+ {
+ TInt err(KErrNone);
+
+ // Open repository
+ CRepository* repository = CRepository::NewLC(KCRUidPDPContextManager);
+
+ // Find if an entry for "iapId" already exists in CentRep
+ RArray<TUint32> foundKeys;
+ foundKeys.Reset();
+
+ err = repository->FindEqL(KIapColumn, // partial key
+ KColumnMask, // key mask
+ aIapId, // value
+ foundKeys); // found keys
+
+ if (err == KErrNone)
+ {
+ if (foundKeys.Count() > 0)
+ {
+ // Find linger interval for the iap id on current row
+ TInt32 row = foundKeys[0] & KRowMask;
+
+ err = repository->Get((KLingerColumn | row), aLingerInterval);
+ }
+ }
+
+ foundKeys.Close();
+ CleanupStack::PopAndDestroy(repository);
+
+ User::LeaveIfError(err);
+ }
+
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::CheckEnforcementL()
+// If AP policy is enforced true is returned else false
+//----------------------------------------------------------------------
+TBool CNSmlInternetAdapter::CheckEnforcementL()
+ {
+ CSettingEnforcementInfo* info = CSettingEnforcementInfo::NewL();
+ CleanupStack::PushL(info);
+ TBool enforceActive(EFalse);
+ User::LeaveIfError(info->EnforcementActive(EAPEnforcement, enforceActive));
+ CleanupStack::PopAndDestroy(info);
+ return enforceActive;
+ }
+
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::CheckWLANEnforcementL()
+// If WLAN AP policy is enforced true is returned else false
+//----------------------------------------------------------------------
+TBool CNSmlInternetAdapter::CheckWLANEnforcementL()
+ {
+ CSettingEnforcementInfo* info = CSettingEnforcementInfo::NewL();
+ CleanupStack::PushL(info);
+ TBool enforceActive(EFalse);
+ User::LeaveIfError(info->EnforcementActive(EWLANEnforcement,
+ enforceActive));
+ CleanupStack::PopAndDestroy(info);
+ return enforceActive;
+ }
+
+//----------------------------------------------------------------------
+//TInt CNSmlInternetAdapter::DoProtectWAPTablesL(TBool aProtect)
+// if aProtect is true , tables are locked otherwise tables are unlocked.
+//----------------------------------------------------------------------
+
+TInt CNSmlInternetAdapter::DoProtectWAPTablesL(TBool aProtect)
+ {
+ TInt err = KErrNone;
+ CCommsDatabaseProtect* dbprotect = CCommsDatabaseProtect::NewL();
+ CleanupStack::PushL(dbprotect);
+ for (TInt i(0); i < iLockTableList.Count(); i++)
+ {
+ if (!aProtect)
+ {
+ err = dbprotect->UnProtectTable(iLockTableList[i]);
+ }
+ else
+ {
+ err = dbprotect->ProtectTable(iLockTableList[i]);
+ }
+
+ }
+ CleanupStack::PopAndDestroy(dbprotect);
+ return err;
+ }
+//----------------------------------------------------------------------
+//void CNSmlInternetAdapter::DoLockIAPTablesL(TBool aProtect)
+// if aProtect is true , tables are locked otherwise tables are unlocked.
+//----------------------------------------------------------------------
+
+void CNSmlInternetAdapter::DoLockIAPTablesL(TBool aLock)
+ {
+ TInt protError = KErrNone;
+ TInt err = KErrNone;
+ iDatabase->CommitTransaction();
+ iLockTableList.AppendL(TPtrC(WAP_ACCESS_POINT));
+ iLockTableList.AppendL(TPtrC(WAP_IP_BEARER));
+ iLockTableList.AppendL(TPtrC(IAP));
+
+ TRAP(err, protError = DoProtectWAPTablesL(aLock));
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoLockIAPTablesL(): Table protect error %d , leave error %d "),
+ protError, err);
+
+ if (protError != KErrNone) // To remove the warnings
+ {
+ protError = KErrNone;
+ }
+ TInt dberr = iDatabase->BeginTransaction();
+ if (dberr == KErrLocked)
+ {
+ _DBG_FILE("DoLockIAPTablesL: CommsDat was locked.");
+ TInt retry = KBeginTransRetryCount;
+ while (retry > 0 && dberr == KErrLocked)
+ {
+ User::After(KBeginTransRetryDelay);
+ _DBG_FILE("DoLockIAPTablesL: Slept 1 second. Try again");
+ dberr = iDatabase->BeginTransaction();
+ retry--;
+ }
+ if (dberr != KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter: BeginTransaction failed completely.");
+ User::Leave(dberr);
+ }
+ }
+ }
+//--------------------------------------------------------------------
+//TInt UnprotectWLANAPItemL(TUint32 aId)
+//Unprotect the wlan AP if only wlan enforcement is on
+//-------------------------------------------------------------------
+TInt CNSmlInternetAdapter::UnprotectWLANAPItemL(TUint32 aId)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::UnprotectWLANAPItemL(): BEGIN");
+ CCommsDbTableView* wapView;
+
+ TInt errorCode = KErrNone;
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+
+ //check if its WLAN AP being deleted
+ wapView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(COMMDB_ID),
+ aId);
+
+ errorCode = wapView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ wapView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ if (serviceType != TPtrC(LAN_SERVICE))
+ {
+ CleanupStack::PopAndDestroy(); // wapView
+ return KErrNone;
+ }
+ }
+
+ ((CCommsDbProtectTableView*) wapView)->UnprotectRecord();
+
+ CleanupStack::PopAndDestroy(); // wapView
+
+ _DBG_FILE("CNSmlInternetAdapter::UnprotectWLANAPItemL(): END");
+ return errorCode;
+ }
+
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::IsIAPRecordLockedL(TUint32 aRecord)
+//check for wap access point record lock status
+//----------------------------------------------------------------------
+
+TBool CNSmlInternetAdapter::IsIAPRecordLockedL(TUint32 aRecord)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::IsIAPRecordLockedL(): BEGIN");
+ TBool ret = EFalse;
+ CCommsDbTableView* apView;
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsIAPRecordLockedL record being checked = %d"),
+ aRecord);
+ apView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(COMMDB_ID),
+ aRecord);
+
+ TInt aAccess(0);
+ if (apView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::IsIAPRecordLockedL():wap record exists, check for access type");
+ TInt err = (((CCommsDbProtectTableView*) apView)->GetRecordAccess(
+ aAccess));
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsIAPRecordLockedL , GetrecordAccess code is =%d and acess type of record = %d"),
+ err, aAccess);
+ CleanupStack::PopAndDestroy(apView);
+ if (aAccess == RDbRowSet::EReadOnly)
+ ret = ETrue;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::IsIAPRecordLockedL(): END");
+ return ret;
+
+ }
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::DoProtectIAPRecordL(TUint32 aRecord,TBool aProtect)
+// protect or unprotect wapaccesspoint record of access point being altered
+//----------------------------------------------------------------------
+
+
+TInt CNSmlInternetAdapter::DoProtectIAPRecordL(TUint32 aRecord,
+ TBool aProtect)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectIAPRecordL(): BEGIN");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectIAPRecordL , record and protect value =%d = %d"),
+ aRecord, aProtect);
+ TInt err = KErrNone;
+
+ CCommsDbTableView* apView;
+ apView = iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(COMMDB_ID),
+ aRecord);
+ if (apView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::DoProtectIAPRecordL(): wap record exists");
+ if (!aProtect)
+ {
+ err = ((CCommsDbProtectTableView*) apView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectIAPAccessRecordL ,error code of Unprotectrecord = %d"),
+ err);
+ }
+
+ else
+ {
+ err = ((CCommsDbProtectTableView*) apView)->ProtectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectIAPRecordL ,error code of ProtectRecord = %d"),
+ err);
+ }
+
+ CleanupStack::PopAndDestroy(apView);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectIAPRecordL(): END");
+ return err;
+ }
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::IsProxyRecordLockedL(TUint32 aRecord)
+//check for proxy record lock status
+//----------------------------------------------------------------------
+
+TBool CNSmlInternetAdapter::IsProxyRecordLockedL(TUint32 aRecord)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::IsProxyRecordLockedL(): BEGIN");
+ TBool ret = EFalse;
+ CCommsDbTableView* proxyView;
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL record being checked = %d"),
+ aRecord);
+ proxyView = iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES), TPtrC(
+ COMMDB_ID), aRecord);
+
+ TInt aAccess(0);
+ if (proxyView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL():wap record exists, check for access type");
+ TInt err = (((CCommsDbProtectTableView*) proxyView)->GetRecordAccess(
+ aAccess));
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL , GetrecordAccess code is =%d and acess type of record = %d"),
+ err, aAccess);
+ CleanupStack::PopAndDestroy(proxyView);
+ if (aAccess == RDbRowSet::EReadOnly)
+ ret = ETrue;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::IsProxyRecordLockedL(): END");
+ return ret;
+
+ }
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::DoProtectProxyRecordL(TUint32 aRecord,TBool aProtect)
+// protect or unprotect proxy record of access point being altered
+//----------------------------------------------------------------------
+
+
+TInt CNSmlInternetAdapter::DoProtectProxyRecordL(TUint32 aRecord,
+ TBool aProtect)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectProxyRecordL(): BEGIN");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL , record and protect value =%d = %d"),
+ aRecord, aProtect);
+ TInt err = KErrNone;
+
+ CCommsDbTableView* proxyView;
+ proxyView = iDatabase->OpenViewMatchingUintLC(TPtrC(PROXIES), TPtrC(
+ COMMDB_ID), aRecord);
+ if (proxyView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL(): wap record exists");
+ if (!aProtect)
+ {
+ err = ((CCommsDbProtectTableView*) proxyView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL ,error code of Unprotectrecord = %d"),
+ err);
+ }
+
+ else
+ {
+ err = ((CCommsDbProtectTableView*) proxyView)->ProtectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL ,error code of ProtectRecord = %d"),
+ err);
+ }
+
+ CleanupStack::PopAndDestroy(proxyView);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectProxyRecordL(): END");
+ return err;
+ }
+
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::IsServiceRecordLockedL(TUint32 aRecord)
+//check for proxy record lock status
+//----------------------------------------------------------------------
+
+TBool CNSmlInternetAdapter::IsServiceRecordLockedL(TUint32 aRecord)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::IsProxyRecordLockedL(): BEGIN");
+ TBool ret = EFalse;
+ CCommsDbTableView* serviceView;
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL record being checked = %d"),
+ aRecord);
+ serviceView = iDatabase->OpenViewMatchingUintLC(iProxyServiceType, TPtrC(
+ COMMDB_ID), aRecord);
+
+ TInt aAccess(0);
+ if (serviceView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL():wap record exists, check for access type");
+ TInt err =
+ (((CCommsDbProtectTableView*) serviceView)->GetRecordAccess(
+ aAccess));
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::IsProxyRecordLockedL , GetrecordAccess code is =%d and acess type of record = %d"),
+ err, aAccess);
+ CleanupStack::PopAndDestroy(serviceView);
+ if (aAccess == RDbRowSet::EReadOnly)
+ ret = ETrue;
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::IsProxyRecordLockedL(): END");
+ return ret;
+
+ }
+//----------------------------------------------------------------------
+//TBool CNSmlInternetAdapter::DoProtectProxyRecordL(TUint32 aRecord,TBool aProtect)
+// protect or unprotect proxy record of access point being altered
+//----------------------------------------------------------------------
+
+
+TInt CNSmlInternetAdapter::DoProtectServiceRecordL(TUint32 aRecord,
+ TBool aProtect)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectProxyRecordL(): BEGIN");
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL , record and protect value =%d = %d"),
+ aRecord, aProtect);
+ TInt err = KErrNone;
+
+ CCommsDbTableView* serviceView;
+ serviceView = iDatabase->OpenViewMatchingUintLC(iProxyServiceType, TPtrC(
+ COMMDB_ID), aRecord);
+ if (serviceView != NULL)
+ {
+ _DBG_FILE(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL(): wap record exists");
+ if (!aProtect)
+ {
+ err
+ = ((CCommsDbProtectTableView*) serviceView)->UnprotectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL ,error code of Unprotectrecord = %d"),
+ err);
+ }
+
+ else
+ {
+ err = ((CCommsDbProtectTableView*) serviceView)->ProtectRecord();
+ DBG_ARGS8(
+ _S8(
+ "CNSmlInternetAdapter::DoProtectProxyRecordL ,error code of ProtectRecord = %d"),
+ err);
+ }
+
+ CleanupStack::PopAndDestroy(serviceView);
+ }
+
+ _DBG_FILE("CNSmlInternetAdapter::DoProtectProxyRecordL(): END");
+ return err;
+ }
+//--------------------------------------------------------------------
+//TInt CNSmlInternetAdapter::IsAPUriFormatMatchPredefined(const TDesC8 & aURI)
+//
+//-------------------------------------------------------------------
+
+
+TBool CNSmlInternetAdapter::IsAPUriFormatMatchPredefined(const TDesC8 & aURI)
+ {
+ if (aURI.Match(_L8("AP/APId*")) != KErrNotFound || aURI.Match(_L8(
+ "AP/APId*/NAPDef/NAPId*")) != KErrNotFound)
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+
+ }
+//--------------------------------------------------------------------
+//TInt CNSmlInternetAdapter::ConstructTreeL(const TDesC8& aURI)
+//
+//-------------------------------------------------------------------
+
+
+TUint32 CNSmlInternetAdapter::ConstructTreeL(const TDesC8& aURI)
+ {
+ _DBG_FILE("CNSmlInternetAdapter::ConstructTreeL(): AP begin");
+ TUint32 returnLuid = 0; // IAP doesn't exist
+
+ CCommsDbTableView* apView = iDatabase->OpenTableLC(TPtrC(IAP));
+
+ TInt errorCode = apView->GotoFirstRecord();
+
+ while (errorCode == KErrNone)
+ {
+ TUint32 lValue;
+ TBool validService = EFalse;
+ apView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ apView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), serviceType);
+ TUint32 bearerId = 0;
+ apView->ReadUintL(TPtrC(IAP_BEARER), bearerId);
+ //
+ // Skip other service types than GSM outgoing
+ //
+ if (serviceType == TPtrC(OUTGOING_GPRS) || serviceType == TPtrC(
+ INCOMING_GPRS))
+ {
+ validService = ETrue;
+ }
+
+ else if (serviceType == TPtrC(LAN_SERVICE) && bearerId > 0)
+ {
+ validService = ETrue;
+ }
+ else if (serviceType == TPtrC(VPN_SERVICE))
+ {
+ validService = ETrue;
+ }
+
+ if (validService)
+ {
+ // Skip others
+ //
+ // Check if in aPreviousURISegmentList
+ //
+ TBool skipToNextIAP = EFalse;
+ // KNSmlDMStart includes start text for URISeg
+ TBuf8<20> addAPURI; // AP/APIdnnn , nnn = profileid
+ addAPURI.Append(_L8("AP/APId"));
+ addAPURI.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, lValue);
+
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(addAPURI);
+ CleanupStack::PushL(mapInfo);
+ if (mapInfo->Length() == 0)
+ {
+ iCallBack->SetMappingL(addAPURI, addLUID);
+ if (aURI.Find(addAPURI) >= 0)
+ {
+ returnLuid = lValue;
+ iPrevLUID = lValue;
+ }
+ }
+ else
+ {
+ skipToNextIAP = ETrue;
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+
+ if (!skipToNextIAP)
+ {
+ // Add the NAPDef also
+
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId(NULL);
+
+ CCommsDbTableView* napdefView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(IAP), TPtrC(
+ COMMDB_ID), lValue);
+
+ errorCode = napdefView->GotoFirstRecord();
+ if (errorCode == KErrNone)
+ {
+ napdefView->ReadTextL(TPtrC(IAP_SERVICE_TYPE),
+ serviceType);
+ napdefView->ReadUintL(TPtrC(IAP_SERVICE), serviceId); // ID
+ }
+
+ CCommsDbTableView* tableView =
+ iDatabase->OpenViewMatchingUintLC(serviceType, TPtrC(
+ COMMDB_ID), serviceId);
+
+ errorCode = tableView->GotoFirstRecord();
+
+ while (errorCode == KErrNone)
+ {
+ TUint32 lValue;
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+ //
+ // Check if in aPreviousURISegmentList
+ //
+
+ _LIT8(Kprev, "NAPId");
+ TBuf8<15> addNAME(Kprev); // APIdnnn , nnn = profileid
+ addNAME.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ _LIT8(Kprev2, "/NAPDef/NAPId");
+ TBuf8<80> addURI; // AP/xxx/NAPDef/NAPIdnnn , nnn = id nbr
+ addURI.Append(addAPURI);
+ addURI.Append(Kprev2);
+ addURI.AppendNumFixedWidth(lValue, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, lValue);
+
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(addURI);
+ CleanupStack::PushL(mapInfo);
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI, addLUID);
+ if (aURI.Find(addURI) >= 0)
+ returnLuid = lValue;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set NAPDef Mapping ");
+
+ TBuf<KCommsDbSvrMaxFieldLength> columnValue;
+ TBuf8<16> addDNSLUID;
+ TBuf8<80> addDNSURI; // AP/xxx/NAPDef/DNSAddr/DNSx
+ _LIT8(KFormat, "%d");
+ tableView->ReadTextL(TPtrC(SERVICE_IP_NAME_SERVER1),
+ columnValue);
+
+ if ((columnValue.Length() > 0))
+ {
+ _LIT8(Kprev2, "/DNSAddr/DNS1");
+ addDNSURI.Append(addURI);
+ addDNSURI.Append(Kprev2);
+ addLUID.Format(KFormat, DnsToLuid(
+ UriUtils::EIPv4Host, 1));
+ iCallBack->SetMappingL(addDNSURI, addLUID);
+ if (aURI.Find(addDNSURI) >= 0)
+ returnLuid
+ = DnsToLuid(UriUtils::EIPv4Host, 1);
+ addDNSURI.Zero();
+ }
+
+ tableView->ReadTextL(TPtrC(SERVICE_IP_NAME_SERVER2),
+ columnValue);
+ if (columnValue.Length() > 0)
+ {
+ _LIT8(Kprev2, "/DNSAddr/DNS2");
+ addDNSURI.Append(addURI);
+ addDNSURI.Append(Kprev2);
+ addLUID.Format(KFormat, DnsToLuid(
+ UriUtils::EIPv4Host, 2));
+ iCallBack->SetMappingL(addDNSURI, addLUID);
+ if (aURI.Find(addDNSURI) >= 0)
+ returnLuid
+ = DnsToLuid(UriUtils::EIPv4Host, 2);
+ addDNSURI.Zero();
+ }
+
+ tableView->ReadTextL(TPtrC(SERVICE_IP6_NAME_SERVER1),
+ columnValue);
+ if (columnValue.Length() > 0)
+ {
+ _LIT8(Kprev2, "/DNSAddr/DNS3");
+ addDNSURI.Append(addURI);
+ addDNSURI.Append(Kprev2);
+ addLUID.Format(KFormat, DnsToLuid(
+ UriUtils::EIPv6Host, 1));
+ iCallBack->SetMappingL(addDNSURI, addLUID);
+ if (aURI.Find(addDNSURI) >= 0)
+ returnLuid
+ = DnsToLuid(UriUtils::EIPv6Host, 1);
+ addDNSURI.Zero();
+ }
+ tableView->ReadTextL(TPtrC(SERVICE_IP6_NAME_SERVER2),
+ columnValue);
+ if (columnValue.Length() > 0)
+ {
+ _LIT8(Kprev2, "/DNSAddr/DNS4");
+ addDNSURI.Append(addURI);
+ addDNSURI.Append(Kprev2);
+ addLUID.Format(KFormat, DnsToLuid(
+ UriUtils::EIPv6Host, 2));
+ iCallBack->SetMappingL(addDNSURI, addLUID);
+ if (aURI.Find(addDNSURI) >= 0)
+ returnLuid
+ = DnsToLuid(UriUtils::EIPv6Host, 2);
+ addDNSURI.Zero();
+ }
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set DNS Mapping ");
+
+ TUint32 nwID = 0;
+ napdefView->ReadUintL(TPtrC(IAP_NETWORK), nwID); // Networks luid
+
+ CCommsDbTableView* nwView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(
+ NETWORK), TPtrC(COMMDB_ID), nwID);
+
+ errorCode = nwView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ _LIT8(Kprev2, "/Networks/NwId");
+ TBuf8<80> addNwURI; // AP/xxx/NAPDef/xxx/Networks/NwIdnnn , nnn = id nbr
+ addNwURI.Append(addURI);
+ addNwURI.Append(Kprev2);
+ addNwURI.AppendNumFixedWidth(nwID, EDecimal, 3);
+ TBuf8<16> addNwLUID;
+ _LIT8(KFormat, "%d");
+ addNwLUID.Format(KFormat, nwID);
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(
+ addNwURI);
+ CleanupStack::PushL(mapInfo);
+
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addNwURI, addNwLUID);
+ if (aURI.Find(addNwURI) >= 0)
+ returnLuid = nwID;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set Networks Mapping ");
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ }
+ CleanupStack::PopAndDestroy(); // nwView
+
+ if (iWlanSupported)
+ {
+ // Check WLAN node
+ if (serviceType == TPtrC(LAN_SERVICE))
+ {
+ TUint32 wlanID = serviceId;
+ _LIT8(Kprev2, "/WLAN/WLId");
+ TBuf8<80> addWlanURI; // AP/xxx/NAPDef/xxx/WLAN/WLIdnnn , nnn = id nbr
+ addWlanURI.Append(addURI);
+ addWlanURI.Append(Kprev2);
+ addWlanURI.AppendNumFixedWidth(wlanID,
+ EDecimal, 3);
+ TBuf8<16> addWlanLUID;
+ _LIT8(KFormat, "%d");
+ addWlanLUID.Format(KFormat, wlanID);
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(
+ addWlanURI);
+ CleanupStack::PushL(mapInfo);
+
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addWlanURI,
+ addWlanLUID);
+ if (aURI.Find(addWlanURI) >= 0)
+ returnLuid = wlanID;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set WLAN Mapping ");
+
+ TBuf<KCommsDbSvrMaxFieldLength> value;
+ TBuf8<16> addWkLUID;
+ TBuf8<80> addWkURI; // AP/xxx/NAPDef/xxx/WLAN/xxx/WEPKey/WKIdn, n = id nbr
+
+ for (TInt value = 1; value <= 4; value++)
+ {
+ _LIT8(Kprev2, "/WEPKey/WKId");
+ addWkURI.Append(addWlanURI);
+ addWkURI.Append(Kprev2);
+ addWkURI.AppendNumFixedWidth(value,
+ EDecimal, 1);
+ _LIT8(KFormat, "%d");
+ addWkLUID.Format(KFormat, (1000
+ * value) + value);
+ iCallBack->SetMappingL(addWkURI,
+ addWkLUID);
+ if (aURI.Find(addWkURI) >= 0)
+ returnLuid = (1000 * value)
+ + value;
+ addWkURI.Zero();
+ }
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ }
+ }
+
+ //Check Bearer node
+
+ CCommsDbTableView* bView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(
+ NETWORK), TPtrC(COMMDB_ID), lValue);
+ errorCode = bView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ _LIT8(Kprev2, "/Bearer/BId");
+ TBuf8<80> addbURI; // AP/xxx/NAPDef/xxx/Bearer/BIdnnn , nnn = id nbr
+ addbURI.Append(addURI);
+ addbURI.Append(Kprev2);
+ addbURI.AppendNumFixedWidth(lValue, EDecimal, 3);
+ TBuf8<16> addbLUID;
+ _LIT8(KFormat, "%d");
+ addbLUID.Format(KFormat, lValue);
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(
+ addbURI);
+ CleanupStack::PushL(mapInfo);
+
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addbURI, addbLUID);
+ if (aURI.Find(addbURI) >= 0)
+ returnLuid = lValue;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set Bearer Mapping ");
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ }
+ CleanupStack::PopAndDestroy(); // bView
+
+ //Check NAPAuthInf node NAPAuthInf/AUId
+
+ CCommsDbTableView* authView =
+ iDatabase->OpenViewMatchingUintLC(TPtrC(
+ NETWORK), TPtrC(COMMDB_ID), lValue);
+
+ errorCode = authView->GotoFirstRecord();
+
+ if (errorCode == KErrNone)
+ {
+ _LIT8(Kprev2, "/Bearer/BId");
+ TBuf8<80> addauthURI; // AP/xxx/NAPDef/xxx/Bearer/BIdnnn , nnn = id nbr
+ addauthURI.Append(addURI);
+ addauthURI.Append(Kprev2);
+ addauthURI.AppendNumFixedWidth(lValue, EDecimal,
+ 3);
+ TBuf8<16> addauthLUID;
+ _LIT8(KFormat, "%d");
+ addauthLUID.Format(KFormat, lValue);
+ HBufC8* mapInfo = iCallBack->GetLuidAllocL(
+ addauthURI);
+ CleanupStack::PushL(mapInfo);
+
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addauthURI,
+ addauthLUID);
+ if (aURI.Find(addauthURI) >= 0)
+ returnLuid = lValue;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set NAPAuthInf Mapping ");
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ }
+ CleanupStack::PopAndDestroy(); // authView
+
+ //Check Proxy node
+
+ CCommsDbTableView* pxView =
+ iDatabase->OpenViewMatchingTextLC(TPtrC(
+ PROXIES), TPtrC(PROXY_SERVICE_TYPE),
+ serviceType);
+
+ errorCode = pxView->GotoFirstRecord();
+ if (errorCode == KErrNone)
+ {
+ while (errorCode == KErrNone)
+ {
+ TUint32 lProxyIspId;
+ TUint32 lProxyId;
+ pxView->ReadUintL(TPtrC(PROXY_ISP),
+ lProxyIspId);
+ if (lProxyIspId == serviceId) //ServiceIsp) // Right value ISP
+ {
+ pxView->ReadUintL(TPtrC(COMMDB_ID),
+ lProxyId);
+
+ _LIT8(Kprev2, "/Px/PXId");
+ TBuf8<80> addURI; // AP/xxx/Px/PXIdnnn , nnn = id nbr
+ addURI.Append(addAPURI);
+ addURI.Append(Kprev2);
+ addURI.AppendNumFixedWidth(lProxyId,
+ EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat,
+ KNSmlApProxyLowerBase + lProxyId); // 100000 + lProxyId
+ HBufC8* mapInfo =
+ iCallBack->GetLuidAllocL(addURI);
+ CleanupStack::PushL(mapInfo);
+
+ if (mapInfo->Length() == 0)
+ {
+ // Also added to mapping
+ iCallBack->SetMappingL(addURI,
+ addLUID);
+ if (aURI.Find(addURI) >= 0)
+ returnLuid
+ = KNSmlApProxyLowerBase
+ + lProxyId;
+ _DBG_FILE(
+ "CNSmlInternetAdapter::ConstructTreeL(): Set Proxy Mapping ");
+ _LIT8(KProxy, "/Port/PROXY");
+ TBuf8<80> addPortURI; // AP/xxx/Px/Port/PROXY
+ addPortURI.Append(addURI);
+ addPortURI.Append(KProxy);
+ TBuf8<16> addPortLUID;
+ _LIT8(KFormat, "%d");
+ addPortLUID.Format(KFormat, 1);
+ iCallBack->SetMappingL(addPortURI,
+ addPortLUID);
+ if (aURI.Find(addPortURI) >= 0)
+ returnLuid = 1;
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ }
+ errorCode = pxView->GotoNextRecord();
+ }
+ }
+ CleanupStack::PopAndDestroy();//Pxview
+ }
+ CleanupStack::PopAndDestroy(mapInfo);
+ errorCode = tableView->GotoNextRecord();
+ }
+ CleanupStack::PopAndDestroy();//tableview
+ CleanupStack::PopAndDestroy();//napdefview
+ }
+ }
+ errorCode = apView->GotoNextRecord();
+ }
+ CleanupStack::PopAndDestroy(); // apView
+ _DBG_FILE("CNSmlInternetAdapter::ConstructTreeL(): AP end");
+ return returnLuid;
+ }
+// End of File