--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omadmadapters/nsmldminternet/src/NSmlWLanAdapter.cpp Tue Aug 31 15:05:55 2010 +0300
@@ -0,0 +1,4379 @@
+/*
+ * Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description: Wlan Adapter
+ *
+ */
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <commsdat_partner.h>
+#endif
+#include "NSmlWLanAdapter.h"
+#include "NSmlWlanSettings.h"
+#include "nsmldebug.h"
+#include <commdb.h>
+#include <utf.h>
+#include <cdbstore.h>
+#include <cdbcols.h>
+#include <EapType.h>
+#include <nsmldmuri.h>
+#include <EapExpandedType.h>
+#include <EapGeneralSettings.h>
+
+#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 KMaxBuf = 255;
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::NewL( )
+//-----------------------------------------------------------------------------
+CNSmlWLanAdapter* CNSmlWLanAdapter::NewL(MSmlDmCallback* aDmCallback,
+ CCommsDatabase& aDatabase)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::NewL(): begin");
+
+ CNSmlWLanAdapter* self = NewLC(aDmCallback, aDatabase);
+ CleanupStack::Pop(self);
+
+ _DBG_FILE("CNSmlWLanAdapter::NewL(): end");
+ return self;
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::NewLC( )
+//-----------------------------------------------------------------------------
+CNSmlWLanAdapter* CNSmlWLanAdapter::NewLC(MSmlDmCallback* aDmCallback,
+ CCommsDatabase& aDatabase)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::NewLC(): begin");
+
+ CNSmlWLanAdapter* self = new (ELeave) CNSmlWLanAdapter(aDmCallback,
+ aDatabase);
+ CleanupStack::PushL(self);
+
+ self->iCallBack = aDmCallback;
+ self->ConstructL(aDatabase);
+
+ _DBG_FILE("CNSmlWLanAdapter::NewLC(): end");
+ return self;
+ }
+
+//-----------------------------------------------------------------------------
+// void CNSmlWLanAdapter::ConstructL( )
+// Second phase constructor
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::ConstructL(CCommsDatabase& aDatabase)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::ConstructL(): begin");
+
+ iWlanSettings = CWlanSettings::NewL(aDatabase);
+ iBuffer = new (ELeave) CArrayFixFlat<TNSmlWepKeyBufferElement> (
+ KNSmlWepKeyGranularity);
+ iSettings = new (ELeave) TWlanSettings;
+ iEAPSettings = new (ELeave) EAPSettings;
+
+ _DBG_FILE("CNSmlWLanAdapter::ConstructL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter::CNSmlWLanAdapter( )
+// Constructor
+//-----------------------------------------------------------------------------
+CNSmlWLanAdapter::CNSmlWLanAdapter(TAny* aEcomArguments,
+ CCommsDatabase& aDatabase) :
+ CSmlDmAdapter(aEcomArguments), iDatabase(aDatabase)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::CNSmlWLanAdapter(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::CNSmlWLanAdapter(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter::~CNSmlWLanAdapter( )
+// Destructor
+//-----------------------------------------------------------------------------
+CNSmlWLanAdapter::~CNSmlWLanAdapter()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::~CNSmlWLanAdapter(): begin");
+
+ if (iBuffer)
+ {
+
+ for (TInt index = 0; index < iBuffer->Count(); index++)
+ {
+ delete iBuffer->At(index).iUri;
+ delete iBuffer->At(index).iData;
+
+ iBuffer->Delete(index);
+ }
+
+ iBuffer->Reset();
+ delete iBuffer;
+
+ }
+ delete iWlanSettings;
+ delete iSettings;
+
+ TRAP_IGNORE(DeleteEAPStructL());
+
+ for (TInt i = 0; i < iEAPBuffer.Count(); i++)
+ {
+ iEAPBuffer[i]->iStatusRefArray.Close();
+ iEAPBuffer[i]->iEAPSettings->iEnabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPBuffer[i]->iEAPSettings->iDisabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPBuffer[i]->iEAPSettings->iCipherSuites.Close();
+ delete iEAPBuffer[i]->iEAPSettings;
+ iEAPBuffer[i]->iEAPSettings = NULL;
+ }
+ iEAPBuffer.ResetAndDestroy();
+
+ TInt count = iSecondaryBuffer.Count();
+ for (TInt index = 0; index < count; index++)
+ {
+ delete iSecondaryBuffer[index];
+ }
+
+ iSecondaryBuffer.Reset();
+
+ _DBG_FILE("CNSmlWLanAdapter::~CNSmlWLanAdapter(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::DDFVersionL( CBufBase& aDDFVersion )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::DDFVersionL(CBufBase& aDDFVersion)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DDFVersionL(): begin");
+
+ aDDFVersion.InsertL(0, KNSmlWLanAdapterDDFversion);
+
+ _DBG_FILE("CNSmlWLanAdapter::DDFVersionL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::DDFStructureL(MSmlDmDDFObject& aDDF)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DDFStructureL(): begin");
+
+ TSmlDmAccessTypes *aclTypes = new (ELeave) TSmlDmAccessTypes();
+ CleanupStack::PushL(aclTypes);
+ //
+ // Set Get as acceptable operations
+ //
+ aclTypes->SetGet();
+ aclTypes->SetAdd(); // 041208 Added
+ aclTypes->SetDelete();
+ aclTypes->SetReplace();
+
+ TSmlDmAccessTypes accessTypesAll;
+ accessTypesAll.SetGet();
+ accessTypesAll.SetDelete();
+ accessTypesAll.SetAdd();
+ accessTypesAll.SetReplace();
+
+ TSmlDmAccessTypes accessTypesNoDelete;
+ accessTypesNoDelete.SetGet();
+ accessTypesNoDelete.SetAdd();
+ accessTypesNoDelete.SetReplace();
+
+ TSmlDmAccessTypes accessTypesGetAdd;
+ accessTypesGetAdd.SetGet();
+ accessTypesGetAdd.SetAdd();
+
+ TSmlDmAccessTypes accessTypesGetAddDel;
+ accessTypesGetAddDel.SetGet();
+ accessTypesGetAddDel.SetAdd();
+ accessTypesGetAddDel.SetDelete();
+ //WLAN
+ MSmlDmDDFObject& rootNode = aDDF.AddChildObjectL(KNSmlWLanNodeName);
+ FillNodeInfoL(rootNode, accessTypesGetAdd, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>
+ MSmlDmDDFObject& wlanNode = rootNode.AddChildObjectGroupL();
+ FillNodeInfoL(wlanNode, accessTypesGetAddDel, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/SSID
+ MSmlDmDDFObject& ssid = wlanNode.AddChildObjectL(KNSmlWLanSsid);
+ FillNodeInfoL(ssid, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/UsedSSID
+ MSmlDmDDFObject& usedSsid = wlanNode.AddChildObjectL(KNSmlWLanUsedSsid);
+ FillNodeInfoL(usedSsid, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/SSIDHidden
+ MSmlDmDDFObject& ssidHidden = wlanNode.AddChildObjectL(
+ KNSmlWLanSsidHidden);
+ FillNodeInfoL(ssidHidden, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/NetworkMode
+ MSmlDmDDFObject& networkMode = wlanNode.AddChildObjectL(
+ KNSmlWLanNetworkMode);
+ FillNodeInfoL(networkMode, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/SecurityMode
+ MSmlDmDDFObject& securityMode = wlanNode.AddChildObjectL(
+ KNSmlWLanSecurityMode);
+ FillNodeInfoL(securityMode, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/UseWPAPSK
+ MSmlDmDDFObject& useWPAPSK = wlanNode.AddChildObjectL(KNSmlWLanUseWPAPSK);
+ FillNodeInfoL(useWPAPSK, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/WPAPreSharedKey
+ MSmlDmDDFObject& wpaPreSharedKey = wlanNode.AddChildObjectL(
+ KNSmlWLanWpaPreSharedKey);
+ FillNodeInfoL(wpaPreSharedKey, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBin, KNSmlEmpty);
+
+ //WLAN/<x>/WLANEAPList
+ MSmlDmDDFObject& wlanEapList = wlanNode.AddChildObjectL(KNSmlWLanEapList);
+ FillNodeInfoL(wlanEapList, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/WEPKeyIndex
+ MSmlDmDDFObject& wepKeyIndex =
+ wlanNode.AddChildObjectL(KNSmlWLanWepIndex);
+ FillNodeInfoL(wepKeyIndex, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt, KNSmlEmpty);
+
+ //WLAN/<x>/WEPAuthMode
+ MSmlDmDDFObject& wlanWepAuthMode = wlanNode.AddChildObjectL(
+ KNSmlWLanAuthMode);
+ FillNodeInfoL(wlanWepAuthMode, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EInt, KNSmlEmpty);
+
+ //WLAN/<x>/WEPKey/
+ MSmlDmDDFObject& wepKeyRoot = wlanNode.AddChildObjectL(KNSmlWLanWepKey);
+ FillNodeInfoL(wepKeyRoot, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/WEPKey/<x>
+ MSmlDmDDFObject& wepKey = wepKeyRoot.AddChildObjectGroupL();
+ FillNodeInfoL(wepKey, accessTypesGetAdd, MSmlDmDDFObject::EOneOrN,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/WEPKey/<x>/WEPKeyID
+ MSmlDmDDFObject& wepKeyId = wepKey.AddChildObjectL(KNSmlWLanWepKeyId);
+ FillNodeInfoL(wepKeyId, accessTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt, KNSmlEmpty);
+
+ //WLAN/<x>/WEPKey/<x>/Data
+ MSmlDmDDFObject& data = wepKey.AddChildObjectL(KNSmlWLanWepKeyData);
+ FillNodeInfoL(data, accessTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EBin, KNSmlEmpty);
+
+ //WLAN/<x>/SecondarySSID/
+ MSmlDmDDFObject& secondarySSidRoot = wlanNode.AddChildObjectL(
+ KNSmlWLanSecSsid);
+ FillNodeInfoL(secondarySSidRoot, accessTypesGetAdd,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/SecondarySSID/<x>
+ MSmlDmDDFObject& secondarySSid = secondarySSidRoot.AddChildObjectGroupL();
+ FillNodeInfoL(secondarySSid, accessTypesGetAddDel,
+ MSmlDmDDFObject::EOneOrN, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/SecondarySSID/<x>/SSID
+ MSmlDmDDFObject& secSsidId = secondarySSid.AddChildObjectL(KNSmlWLanSsid);
+ FillNodeInfoL(secSsidId, accessTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/SecondarySSID/<x>/UsedSSID
+ MSmlDmDDFObject& secUsedSsidId = secondarySSid.AddChildObjectL(
+ KNSmlWLanUsedSsid);
+ FillNodeInfoL(secUsedSsidId, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/
+ MSmlDmDDFObject& eapRoot = wlanNode.AddChildObjectL(KNSmlWLanEap);
+ FillNodeInfoL(eapRoot, accessTypesGetAdd, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>
+ MSmlDmDDFObject& eap = eapRoot.AddChildObjectGroupL();
+ FillNodeInfoL(eap, accessTypesGetAdd, MSmlDmDDFObject::EOneOrN,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/EAPType
+ MSmlDmDDFObject& eapType = eap.AddChildObjectL(KNSmlWLanEapType);
+ FillNodeInfoL(eapType, accessTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Username
+ MSmlDmDDFObject& eapUsername = eap.AddChildObjectL(KNSmlWLanUsername);
+ FillNodeInfoL(eapUsername, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Password
+ MSmlDmDDFObject& eapPassword = eap.AddChildObjectL(KNSmlWLanPassword);
+ FillNodeInfoL(eapPassword, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Realm
+ MSmlDmDDFObject& eapRealm = eap.AddChildObjectL(KNSmlWLanRealm);
+ FillNodeInfoL(eapRealm, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/UsePseudonym
+ MSmlDmDDFObject& eapPseudo = eap.AddChildObjectL(KNSmlWLanUsePseudonym);
+ FillNodeInfoL(eapPseudo, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Encapsulation
+ // Encapsulation is not supported using this parameter. It is done
+ // with */EAP/EAPIdxxx-yyy/* where xxx is the encapsulated and yyy the encapsulating method.
+ /*MSmlDmDDFObject& eapEncapsulation = eap.AddChildObjectL( KNSmlWLanEncapsulation );
+ FillNodeInfoL( eapEncapsulation,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr,
+ KNSmlEmpty ); */
+
+ //WLAN/<x>/EAP/<x>/VerifyCertRealm
+ MSmlDmDDFObject& eapVerifyCertRealm = eap.AddChildObjectL(
+ KNSmlWLanVerifyCertRealm);
+ FillNodeInfoL(eapVerifyCertRealm, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/RequireClientAuthentication
+ MSmlDmDDFObject& eapRequireClientAuthentication = eap.AddChildObjectL(
+ KNSmlWLanRequireClientAuthentication);
+ FillNodeInfoL(eapRequireClientAuthentication, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/SessionValidityTime
+ MSmlDmDDFObject& eapSessionValidityTime = eap.AddChildObjectL(
+ KNSmlWLanSessionValidityTime);
+ FillNodeInfoL(eapSessionValidityTime, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/CipherSuite
+ MSmlDmDDFObject& eapCipherSuite = eap.AddChildObjectL(
+ KNSmlWLanCipherSuite);
+ FillNodeInfoL(eapCipherSuite, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/AllowPEAPv0
+ MSmlDmDDFObject& eapAllowPEAPv0 = eap.AddChildObjectL(
+ KNSmlWLanAllowPEAPv0);
+ FillNodeInfoL(eapAllowPEAPv0, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/AllowPEAPv1
+ MSmlDmDDFObject& eapAllowPEAPv1 = eap.AddChildObjectL(
+ KNSmlWLanAllowPEAPv1);
+ FillNodeInfoL(eapAllowPEAPv1, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/AllowPEAPv2
+ MSmlDmDDFObject& eapAllowPEAPv2 = eap.AddChildObjectL(
+ KNSmlWLanAllowPEAPv2);
+ FillNodeInfoL(eapAllowPEAPv2, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool, KNSmlEmpty);
+
+#ifdef FF_WLAN_EXTENSIONS
+
+ //WLAN/<x>/EAP/<x>/AuthProvModeAllowed
+ MSmlDmDDFObject& authProvMode = eap.AddChildObjectL( KNSmlWLanAuthProvMode );
+ FillNodeInfoL( authProvMode,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/<x>/EAP/<x>/UnauthProvModeAllowed
+ MSmlDmDDFObject& unauthProvMode = eap.AddChildObjectL( KNSmlWLanUnauthProvMode );
+ FillNodeInfoL( unauthProvMode,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/<x>/EAP/<x>/PACGroupReference
+ MSmlDmDDFObject& pacGroupRef = eap.AddChildObjectL( KNSmlWLanPACGroupRef );
+ FillNodeInfoL( pacGroupRef,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr,
+ KNSmlEmpty );
+
+ //WLAN/<x>/EAP/<x>/WarnADHPNoPAC
+ MSmlDmDDFObject& warnADHPNoPAC = eap.AddChildObjectL( KNSmlWLanWarnADHPNoPAC );
+ FillNodeInfoL( warnADHPNoPAC,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/<x>/EAP/<x>/WarnADHPNoMatchingPAC
+ MSmlDmDDFObject& warnADHPNoMatchingPAC = eap.AddChildObjectL( KNSmlWLanWarnADHPNoMatchPAC );
+ FillNodeInfoL( warnADHPNoMatchingPAC,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+ //WLAN/<x>/EAP/<x>/WarnNotDefaultServer
+ MSmlDmDDFObject& warnNoDefServ = eap.AddChildObjectL( KNSmlWLanWarnNotDefaultSrv );
+ FillNodeInfoL( warnNoDefServ,
+ accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne,
+ MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EBool,
+ KNSmlEmpty );
+
+#endif
+
+ //WLAN/<x>/EAP/<x>/Certificate
+ MSmlDmDDFObject& eapCertificateRoot = eap.AddChildObjectL(
+ KNSmlWLanCertificate);
+ FillNodeInfoL(eapCertificateRoot, accessTypesGetAdd,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>
+ MSmlDmDDFObject& eapCertificate =
+ eapCertificateRoot.AddChildObjectGroupL();
+ FillNodeInfoL(eapCertificate, accessTypesGetAdd,
+ MSmlDmDDFObject::EOneOrMore, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::ENode, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/IssuerName
+ MSmlDmDDFObject& eapIssuerName = eapCertificate.AddChildObjectL(
+ KNSmlWLanIssuerName);
+ FillNodeInfoL(eapIssuerName, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/SubjectName
+ MSmlDmDDFObject& eapSubjectName = eapCertificate.AddChildObjectL(
+ KNSmlWLanSubjectName);
+ FillNodeInfoL(eapSubjectName, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/CertType
+ MSmlDmDDFObject& eapCertType = eapCertificate.AddChildObjectL(
+ KNSmlWLanCertType);
+ FillNodeInfoL(eapCertType, accessTypesNoDelete, MSmlDmDDFObject::EOne,
+ MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/SerialNumber
+ MSmlDmDDFObject& eapSerialNumber = eapCertificate.AddChildObjectL(
+ KNSmlWLanSerialNumber);
+ FillNodeInfoL(eapSerialNumber, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/SubjectKeyId
+ MSmlDmDDFObject& eapSubjectKeyId = eapCertificate.AddChildObjectL(
+ KNSmlWLanSubjectKeyId);
+ FillNodeInfoL(eapSubjectKeyId, accessTypesNoDelete,
+ MSmlDmDDFObject::EOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ //WLAN/<x>/EAP/<x>/Certificate/<x>/Fingerprint
+ MSmlDmDDFObject& eapFingerprint = eapCertificate.AddChildObjectL(
+ KNSmlWLanFingerprint);
+ FillNodeInfoL(eapFingerprint, accessTypesNoDelete,
+ MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,
+ MSmlDmDDFObject::EChr, KNSmlEmpty);
+
+ CleanupStack::PopAndDestroy(); //aclTypes
+
+ _DBG_FILE("CNSmlWLanAdapter::DDFStructureL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::AddLeafObjectL( const TDesC& aURI,const
+// TDesC& aParentLUID, const TDesC8& aObject, const TDesC& aType,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::AddLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aParentLUID, const TDesC8& aObject,
+ const TDesC8& /*aType*/, const TInt aStatusRef)
+ {
+ DBG_ARGS8(_S8("CNSmlWLanAdapter::AddLeafObjectL - <%S> <%S> <%S>"),
+ &aURI, &aParentLUID, &aObject);
+
+ TInt uriSegs = NumOfUriSegs(aURI);
+ TInt luid = GetIdFromLuid(aParentLUID);
+ TInt err(KErrNone);
+ TPtrC8 lastUriSeg = GetLastUriSeg(aURI);
+
+ TInt eapIndex(0);
+
+ TInt eapId = GetEAPIdFromUri(aURI);
+ if (eapId == KErrNotFound)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::AddLeafObjectL(): Non-EAP setting.");
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ err = iWlanSettings->GetWlanSettings(luid, *iSettings);
+ }
+ else
+ {
+ _DBG_FILE("CNSmlWLanAdapter::AddLeafObjectL(): EAP setting.");
+ TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);
+ if (encapsEapId == KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddLeafObjectL(): Does not have encapsulation id xx-xx.");
+ encapsEapId = EEapNone;
+ }
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+
+ TBuf8<KExpandedEapIdLength> cmpbuf;
+ if (eapId == KPlainMsChapV2ImplUid)
+ {
+ cmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ cmpbuf.Append(KPadding);
+ }
+ cmpbuf.Append(eapId);
+ TEapExpandedType expandedTypecmbuf(cmpbuf);
+
+ TBuf8<KExpandedEapIdLength> encapscmpbuf;
+ if (encapsEapId == KPlainMsChapV2ImplUid)
+ {
+ encapscmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ encapscmpbuf.Append(KPadding);
+ }
+ encapscmpbuf.Append(encapsEapId);
+ TEapExpandedType expandedTypeencapscmbuf(encapscmpbuf);
+
+ TInt i(0);
+ // This is EAP addition. Check if the buffer for this EAP already exists
+ for (i = 0; i < iEAPBuffer.Count(); i++)
+ {
+ if ((expandedTypecmbuf.Compare(
+ iEAPBuffer[i]->iEAPSettings->iEAPExpandedType) == 0)
+ && (expandedTypeencapscmbuf.Compare(
+ iEAPBuffer[i]->iEncapsulatingExpandedEapId) == 0))
+ {
+ // The correct buffer was found.
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddLeafObjectL(): Found existing buffer.");
+ eapIndex = i;
+ break;
+ }
+ }
+ if (i == iEAPBuffer.Count())
+ {
+ DBG_ARGS8(
+ _S8(
+ "CNSmlWLanAdapter::AddLeafObjectL(): No buffer found. Create new: <%d>-<%d>"),
+ eapId, encapsEapId);
+ // Buffer was not found. Create new.
+ TInt WLANServiceId = GetServiceIdFromUriL(aURI);
+
+ if (WLANServiceId == KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddLeafObjectL(): Could not find WLAN service ID from URI.");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+
+ TNSmlEAPBufferElement* buffer =
+ new (ELeave) TNSmlEAPBufferElement;
+ CleanupStack::PushL(buffer);
+
+ buffer->iEAPSettings = new (ELeave) EAPSettings;
+ CleanupStack::PushL(buffer->iEAPSettings);
+
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+
+ TBuf8<KExpandedEapIdLength> tempbuf;
+ if (eapId == KPlainMsChapV2ImplUid)
+ {
+ tempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ tempbuf.Append(KPadding);
+ }
+ tempbuf.Append(eapId);
+
+ buffer->iEAPSettings->iEAPExpandedType = tempbuf;
+ buffer->iWLANServiceId = WLANServiceId;
+ TBuf8<KExpandedEapIdLength> encapsTempbuf;
+ if (encapsEapId == KPlainMsChapV2ImplUid)
+ {
+ encapsTempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ encapsTempbuf.Append(KPadding);
+ }
+ encapsTempbuf.Append(encapsEapId);
+
+ buffer->iEncapsulatingExpandedEapId = encapsTempbuf;
+ iEAPBuffer.AppendL(buffer);
+
+ CleanupStack::Pop(buffer->iEAPSettings);
+ CleanupStack::Pop(buffer);
+
+ eapIndex = iEAPBuffer.Count() - 1;
+ }
+ }
+ if (err != KErrNone)
+ {
+ DBG_ARGS(_S16("CNSmlWLanAdapter::AddLeafObjectL - ErrorCode <%D>"),
+ err);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*/*"))
+ != KErrNotFound && uriSegs == 9)
+ {
+ TInt wepKeyId = GetWepKeyIdFromLuid(aParentLUID);
+
+ if (wepKeyId != KErrNotFound)
+ {
+ if (lastUriSeg.Match(KNSmlWLanWepKeyData) != KErrNotFound)
+ {
+ switch (wepKeyId)
+ {
+ case 1:
+ iSettings->WepKey1 = aObject;
+ break;
+ case 2:
+ iSettings->WepKey2 = aObject;
+ break;
+ case 3:
+ iSettings->WepKey3 = aObject;
+ break;
+ case 4:
+ iSettings->WepKey4 = aObject;
+ break;
+ default:
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+ else if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ return;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+
+ else
+ {
+ TInt index = -1;
+
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ if (aURI.Find(iBuffer->At(i).iUri->Des()) != KErrNotFound)
+ {
+ index = i;
+ break;
+ }
+ }
+ if (index < 0)
+ {
+ wepKeyId = GetWepKeyIdFromUri(aURI);
+
+ TBuf8<80> addLUID; // AP/<x>/NapDef/<x>/WLAN/<x>/WEPKey/WKIdnnn
+ addLUID.AppendNum(wepKeyId);
+ addLUID.AppendNumFixedWidth(luid, EDecimal, 3);
+
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::AddleafObject - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &addLUID);
+ DBG_ARGS8(_S8("Parametrit - <%S> <%S>"), &aURI, &addLUID);
+ iCallBack->SetMappingL(aURI, addLUID);
+ if (lastUriSeg.Match(KNSmlWLanWepKeyData) != KErrNotFound)
+ {
+ switch (wepKeyId)
+ {
+ case 1:
+ iSettings->WepKey1 = aObject;
+ break;
+ case 2:
+ iSettings->WepKey2 = aObject;
+ break;
+ case 3:
+ iSettings->WepKey3 = aObject;
+ break;
+ case 4:
+ iSettings->WepKey4 = aObject;
+ break;
+ default:
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+ else if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ return;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+ else
+ {
+ //Add WepKeyId and execute buffer
+ if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)
+ {
+ iBuffer->At(index).iWepKeyId = DesToInt(aObject);
+ iBuffer->At(index).iIdStatusRef = aStatusRef;
+
+ // ExecuteBufferL( ); (JPLA-6M29NR caused error in WEPkey Data if buffer is executed here)
+ return;
+ }
+
+ else if (lastUriSeg.Match(KNSmlWLanWepKeyData)
+ != KErrNotFound)
+ {
+ iBuffer->At(index).iData = aObject.AllocLC();
+ iBuffer->At(index).iDataSet = ETrue;
+ CleanupStack::Pop(); //iBuffer->At(index).iData
+ iBuffer->At(index).iDataStatusRef = aStatusRef;
+ return;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+ }
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/*")) != KErrNotFound
+ && uriSegs == 7)
+ {
+ if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)
+ {
+ TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iSettings->SSID, aObject);
+ DBG_ARGS(_S16("WLanAdapter::ssid convert: <%D>"), returnValue);
+ if (returnValue != KErrNone)
+ {
+ // setting the default value to the network name
+ iSettings->SSID = TPtrC(KNSmlWLanDefaultSSID);
+ DBG_ARGS(
+ _S16(
+ "CNSmlWLanAdapter::AddLeafObjectL SSID - ErrorCode <%D>"),
+ returnValue);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)
+ {
+ TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iSettings->UsedSSID, aObject);
+ DBG_ARGS(_S16("WLanAdapter::usedSsid convert: <%D>"), returnValue);
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanSsidHidden) == 0)
+ {
+ if (aObject.MatchF(_L8("True")) != KErrNotFound)
+ {
+ iSettings->ScanSSID = 1;
+ }
+ else
+ {
+ iSettings->ScanSSID = 0;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanNetworkMode) == 0)
+ {
+ if (aObject.MatchF(_L8("ADHOC")) != KErrNotFound)
+ {
+ iSettings->ConnectionMode = EAdhoc;
+ }
+
+ else if (aObject.MatchF(_L8("Infrastructure")) != KErrNotFound)
+ {
+ iSettings->ConnectionMode = EInfrastructure;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EInvalidObject);
+ return;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanSecurityMode) == 0)
+ {
+ if (aObject.MatchF(_L8("NONE")) != KErrNotFound)
+ {
+ iSettings->SecurityMode = EAllowUnsecure;
+ }
+ else if (aObject.MatchF(_L8("WEP")) != KErrNotFound)
+ {
+ iSettings->SecurityMode = EWep;
+ }
+ else if (aObject.MatchF(_L8("8021X")) != KErrNotFound)
+ {
+ iSettings->SecurityMode = EWlan8021x;
+ }
+ else if (aObject.MatchF(_L8("WPA")) != KErrNotFound)
+ {
+ iSettings->SecurityMode = EWpa;
+ }
+ else if (aObject.MatchF(_L8("WPA2")) != KErrNotFound)
+ {
+ iSettings->SecurityMode = EWpa2;
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EInvalidObject);
+ return;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUseWPAPSK) == 0)
+ {
+ if (aObject.MatchF(_L8("True")) != KErrNotFound)
+ {
+ iSettings->UseWPAPSK = 1;
+ }
+ else
+ {
+ iSettings->UseWPAPSK = 0;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWpaPreSharedKey) == 0)
+ {
+ if (aObject.Length() > KMaxPSKLength)
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ETooLargeObject);
+ return;
+ }
+ /*else if(aObject.Length() < KMinPSKLength)
+ {
+ iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );
+ return;
+ }*/
+ else
+ {
+ iSettings->WPAPreSharedKey = aObject;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanEapList) == 0)
+ {
+ TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iSettings->EapList, aObject);
+ DBG_ARGS(_S16("WLanAdapter::EapList convert: <%D>"), returnValue);
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanAuthMode) == 0)
+ {
+ if (aObject.MatchF(_L8("1")) != KErrNotFound)
+ {
+ iSettings->AuthMode = EShared;
+ }
+ else
+ {
+ iSettings->AuthMode = EOpen;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWepIndex) == 0)
+ {
+ TInt32 actualIndex = DesToInt(aObject);
+ if (actualIndex < 4 && actualIndex >= 0)
+ {
+ iSettings->WepIndex = actualIndex;
+ }
+ else
+ {
+ if (actualIndex > 3)
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::ETooLargeObject);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ return;
+ }
+ }
+
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*/*"))
+ != KErrNotFound && uriSegs == 9)
+ {
+ TSecondarySSID ssid;
+ ssid.Id = 0;
+ TUint32 id = GetSecSSIDFromUriL(aURI);
+ RArray<TSecondarySSID> secondaryList;
+ CleanupClosePushL(secondaryList);
+ iWlanSettings->GetSecondarySSIDListL(luid, secondaryList);
+ TInt count = secondaryList.Count();
+ for (TInt i = 0; i < count; i++)
+ {
+ if (id == secondaryList[i].Id)
+ {
+ ssid = secondaryList[i];
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy(&secondaryList);
+ if (ssid.Id == 0)
+ {
+
+ _DBG_FILE("CNSmlWLanAdapter::Coming to check buffer ");
+
+ //Check if its buffered here - Divya
+ TInt index = -1;
+
+ for (TInt i = 0; i < iSecondaryBuffer.Count(); i++)
+ {
+ if (aURI.Find(iSecondaryBuffer[i]->iUri->Des())
+ != KErrNotFound)
+ {
+ index = i;
+ _DBG_FILE("CNSmlWLanAdapter::one indexis matched :-)");
+ break;
+ }
+ }
+ if (index < 0)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::one indexis matched :-)");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+ else
+ {
+ DBG_ARGS8(
+ _S8(
+ "CWlanadaptes::Execute Buffer - copying in buffer instead of giving 404 uri: object id : <%S>"),
+ &aObject);
+
+ if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)
+ {
+ if (aObject.Length() <= KMaxTextLength)
+ {
+ iSecondaryBuffer[index]->ScannedId.Copy(aObject);
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddLeafObject - SecondarySSID too long");
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EError);
+ return;
+ }
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)
+ {
+ iSecondaryBuffer[index]->UsedId.Copy(aObject);
+ }
+
+ }
+
+ }
+
+ else
+ {
+
+ if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)
+ {
+ ssid.ScannedId.Copy(aObject);
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)
+ {
+ ssid.UsedId.Copy(aObject);
+ }
+ TInt retval = iWlanSettings->WriteSecondarySSIDL(luid, ssid,
+ EFalse);
+ if (retval == KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ }
+ }
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/*")) != KErrNotFound
+ && uriSegs == 9)
+ {
+ DBG_ARGS8(_S8("CNSmlWLanAdapter::AddLeafObjectL - EAP index: <%d>"),
+ eapIndex);
+
+ if (lastUriSeg.Compare(KNSmlWLanEapType) == 0)
+ {
+ TInt eapid = GetEAPIdFromUri(aURI);
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+ TBuf8<KExpandedEapIdLength> tempbuf;
+ if (eapid == KPlainMsChapV2ImplUid)
+ {
+ tempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ tempbuf.Append(KPadding);
+ }
+ tempbuf.Append(eapid);
+ // Get EAP ID from URI instead of the value because the server gives the value
+ // incorrectly as the textual representation of the EAP method instead of the IANA number.
+ iEAPBuffer[eapIndex]->iEAPSettings->iEAPExpandedType = tempbuf;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsername) == 0)
+ {
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsername, aObject);
+ if (retval == KErrNone)
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsernamePresent = ETrue;
+ }
+ else
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsername.Zero();
+ DBG_ARGS(
+ _S16(
+ "CNSmlWLanAdapter::AddLeafObjectL EAP username - ErrorCode <%D>"),
+ retval);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanPassword) == 0)
+ {
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iEAPBuffer[eapIndex]->iEAPSettings->iPassword, aObject);
+ if (retval == KErrNone)
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iPasswordPresent = ETrue;
+ }
+ else
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iPassword.Zero();
+ DBG_ARGS(
+ _S16(
+ "CNSmlWLanAdapter::AddLeafObjectL EAP password - ErrorCode <%D>"),
+ retval);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanRealm) == 0)
+ {
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ iEAPBuffer[eapIndex]->iEAPSettings->iRealm, aObject);
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iRealmPresent = ETrue;
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsePseudonym) == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsePseudonyms = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsePseudonyms = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iUsePseudonymsPresent = ETrue;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanEncapsulation) == 0)
+ {
+ TBuf8<KExpandedEAPIdLength> dummy;
+ //ConvertEAPStringToIds( aObject, dummy, iEAPBuffer[eapIndex]->iEncapsulatingExpandedEapId );
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanVerifyCertRealm) == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iVerifyServerRealm
+ = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iVerifyServerRealm
+ = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iVerifyServerRealmPresent
+ = ETrue;
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanRequireClientAuthentication)
+ == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iRequireClientAuthentication
+ = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iRequireClientAuthentication
+ = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iRequireClientAuthenticationPresent
+ = ETrue;
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSessionValidityTime) == 0)
+ {
+ TLex8 lex(aObject);
+ TUint newVal;
+ TInt sesValErr = lex.Val(newVal);
+ // Check whether the conversion went ok
+ if (sesValErr == KErrNone)
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iSessionValidityTime
+ = newVal;
+ iEAPBuffer[eapIndex]->iEAPSettings->iSessionValidityTimePresent
+ = ETrue;
+ }
+ else
+ {
+ // there were errors, let's leave the function and update status
+ DBG_ARGS(
+ _S16(
+ "CNSmlWLanAdapter::AddLeafObjectL SessionValidityTime - ErrorCode <%D>"),
+ sesValErr);
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EInvalidObject);
+ return;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanCipherSuite) == 0)
+ {
+ FillCipherSuitesL(aObject, eapIndex);
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv0) == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv0Allowed = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv0Allowed = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPVersionsPresent = ETrue;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv1) == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv1Allowed = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv1Allowed = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPVersionsPresent = ETrue;
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv2) == 0)
+ {
+ if ((aObject == KTrue) || (aObject == KTtrue))
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv2Allowed = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPv2Allowed = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iPEAPVersionsPresent = ETrue;
+ }
+
+#ifdef FF_WLAN_EXTENSIONS
+ else if (lastUriSeg.Compare(KNSmlWLanAuthProvMode) == 0)
+ {
+ if ( (aObject == KTrue) || (aObject == KTtrue) )
+ iEAPBuffer[eapIndex]->iEAPSettings->iAuthProvModeAllowed = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iAuthProvModeAllowed = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iAuthProvModeAllowedPresent = ETrue;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUnauthProvMode) == 0)
+ {
+ if ( (aObject == KTrue) || (aObject == KTtrue) )
+ iEAPBuffer[eapIndex]->iEAPSettings->iUnauthProvModeAllowed = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iUnauthProvModeAllowed = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iUnauthProvModeAllowedPresent = ETrue;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanPACGroupRef) == 0)
+ {
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8( iEAPBuffer[eapIndex]->iEAPSettings->iPACGroupReference, aObject );
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iPACGroupReferencePresent = ETrue;
+
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnADHPNoPAC) == 0)
+ {
+ if ( (aObject == KTrue) || (aObject == KTtrue) )
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoPAC = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoPAC = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoPACPresent = ETrue;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnADHPNoMatchPAC) == 0)
+ {
+ if ( (aObject == KTrue) || (aObject == KTtrue) )
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoMatchingPAC = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoMatchingPAC = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnADHPNoMatchingPACPresent = ETrue;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnNotDefaultSrv) == 0)
+ {
+ if ( (aObject == KTrue) || (aObject == KTtrue) )
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnNotDefaultServer = ETrue;
+ else
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnNotDefaultServer = EFalse;
+
+ iEAPBuffer[eapIndex]->iEAPSettings->iWarnNotDefaultServerPresent = ETrue;
+ }
+
+#endif
+
+ // Save the status reference
+ iEAPBuffer[eapIndex]->iStatusRefArray.AppendL(aStatusRef);
+ return;
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*/*"))
+ != KErrNotFound && uriSegs == 11)
+ {
+ TPtrC8 ptr = NSmlDmURI::ParentURI(aURI);
+
+ TBuf<KGeneralStringMaxLength> certBuffer;
+
+ // Get the LUID from ptr2
+ HBufC8* certLuid = iCallBack->GetLuidAllocL(ptr);
+
+ TInt certIndex = GetIdFromLuid(*certLuid);
+
+ delete certLuid;
+
+ DBG_ARGS8(
+ _S8(
+ "CNSmlWLanAdapter::AddLeafObjectL - cert index: <%d>, cert count: <%d>"),
+ certIndex,
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates.Count());
+
+ if (iEAPBuffer[eapIndex]->iEAPSettings->iCertificates.Count() - 1
+ < certIndex)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddLeafObject - Certificate buffer does not exist. Create it.");
+ // The certificate buffer does not exist. Create a new one
+ EapCertificateEntry *entry = new (ELeave) EapCertificateEntry;
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates.Append(entry);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificatesPresent = ETrue;
+
+ certIndex
+ = iEAPBuffer[eapIndex]->iEAPSettings->iCertificates.Count()
+ - 1;
+
+ TBuf8<2> newLuid;
+ newLuid.Num(certIndex);
+
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::AddLeafObjectL - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &newLuid);
+ iCallBack->SetMappingL(aURI, newLuid);
+ }
+
+ if (lastUriSeg.Compare(KNSmlWLanIssuerName) == 0)
+ {
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ certBuffer, aObject);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetIssuerName(
+ certBuffer);
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetIssuerNamePresent();
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSubjectName) == 0)
+ {
+ certBuffer.FillZ();
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ certBuffer, aObject);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSubjectName(
+ certBuffer);
+
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSubjectNamePresent();
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanCertType) == 0)
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetCertType(
+ (EapCertificateEntry::TCertType) DesToInt(aObject));
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSerialNumber) == 0)
+ {
+ certBuffer.FillZ();
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ certBuffer, aObject);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSerialNumber(
+ certBuffer);
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSerialNumberPresent();
+
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSubjectKeyId) == 0)
+ {
+
+ // Define literals to search the subject key for possible 0X/0x beginning
+ _LIT(KHexIdLC, "0x");
+ _LIT(KHexIdUC, "0X");
+ TBuf<2> hexIdBuf;
+ // The lenght of the key given as input
+ TInt keyLen = aObject.Length();
+
+ // setting the given key to the key buffer
+ TBuf8<KNsmlSubjectKeyIdLength> origKey = aObject;
+ origKey.SetLength(keyLen);
+ TBuf8<KIdentifierLength> key;
+ TLex8 tmpByte;
+ TUint16 byte;
+
+ // Remove possible spaces from the beginning
+ origKey.TrimLeft();
+
+ // the key should be atleast two chars long
+ if (origKey.Length() >= 2)
+ {
+ // Copy the two left most characters in to the buffer
+ hexIdBuf.Copy(origKey.Left(2));
+
+ // If the first characters are 0x or 0X, then thet should be ignored
+ if (hexIdBuf.Compare(KHexIdLC) == 0 || hexIdBuf.Compare(
+ KHexIdUC) == 0)
+ {
+ // delete two characters
+ origKey.Delete(0, 2);
+ }
+ }
+
+ // looping the subject key through, removing whitespaces
+ for (TInt i = 0; i < keyLen; i++)
+ {
+ // removing white spaces from the left side of the key
+ origKey.TrimLeft();
+ // check that there are characters left
+ if (origKey.Length() >= 2)
+ {
+ // pick the two left most bytes from the key
+ tmpByte = origKey.Left(2);
+ // convert byte into binary format
+ err = tmpByte.Val(byte, EHex);
+
+ // check whether conversion to decimal went ok
+ if (err != KErrNone)
+ {
+ // if there are problems, then leave the loop
+ break;
+ }
+
+ // store the appended byte into the key variable
+ key.Append(byte);
+ // delete two characters from the left side of the character array in the buffer
+ origKey.Delete(0, 2);
+ }
+ else if (origKey.Length() == 1)
+ {
+ // pick the left most byte from the key
+ tmpByte = origKey.Left(1);
+ // convert byte into binary format
+ err = tmpByte.Val(byte, EHex);
+
+ // check whether conversion to decimal went ok
+ if (err != KErrNone)
+ {
+ // if there are problems, then leave the loop
+ break;
+ }
+
+ // store the appended byte into the key variable
+ key.Append(byte);
+ // delete two characters from the left side of the character array in the buffer
+ origKey.Delete(0, 1);
+ }
+ else
+ {
+ // leave the loop, no characters are left
+ break;
+ }
+ }
+ // store key value only if no errors occurred
+ if (err == KErrNone)
+ {
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSubjectKeyId(
+ key);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetSubjectKeyIdPresent();
+ }
+ else
+ {
+ // there were errors, let's leave the function and update status
+ DBG_ARGS(_S16(
+ "CNSmlWLanAdapter::AddLeafObjectL - ErrorCode <%D>"),
+ err);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanFingerprint) == 0)
+ {
+ certBuffer.FillZ();
+ TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(
+ certBuffer, aObject);
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetThumbprint(
+ certBuffer);
+ if (retval == KErrNone)
+ iEAPBuffer[eapIndex]->iEAPSettings->iCertificates[certIndex]->SetThumbprintPresent();
+ }
+ // Save the status reference
+ iEAPBuffer[eapIndex]->iStatusRefArray.AppendL(aStatusRef);
+
+ return;
+ }
+
+ if (eapId == KErrNotFound)
+ {
+ err = iWlanSettings->WriteWlanSettings(*iSettings);
+ }
+
+ if (err != KErrNone)
+ {
+ DBG_ARGS(_S16("CNSmlWLanAdapter::AddLeafObjectL - ErrorCode <%D>"),
+ err);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+
+ _DBG_FILE("CNSmlWLanAdapter::AddLeafObjectL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::UpdateLeafObjectL( const TDesC& aURI,
+// const TDesC& aLUID, const TDesC8& aObject, const TDesC& aType,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::UpdateLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType,
+ const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::UpdateLeafObjectL(): begin");
+ DBG_ARGS8(_S8("WLanAdapter::UpdateLeafObjectL - <%S> <%S> <%S>"), &aURI,
+ &aLUID, &aObject);
+
+ AddLeafObjectL(aURI, aLUID, aObject, aType, aStatusRef);
+
+ _DBG_FILE("CNSmlWLanAdapter::UpdateLeafObjectL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::UpdateLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType )
+//------------------------------------------------------------------------------
+
+void CNSmlWLanAdapter::UpdateLeafObjectL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/, TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::UpdateLeafObjectL(): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlWLanAdapter::UpdateLeafObjectL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::DeleteObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::DeleteObjectL(const TDesC8& aURI, const TDesC8& aLUID,
+ const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DeleteObjectL(): begin");
+ CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound;
+
+ if (aLUID.Length() == 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+
+ _DBG_FILE("CNSmlWLanAdapter::DeleteObjectL(): end");
+ return;
+ }
+
+ TInt luid = GetIdFromLuid(aLUID);
+
+ if ((NumOfUriSegs(aURI) < 6) || (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 6))
+ {
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ TInt ret = iWlanSettings->DeleteWlanSettings(luid);
+
+ if (ret == KErrNone)
+ {
+ status = CSmlDmAdapter::EOk;
+ }
+ else
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 7)
+ {
+ // Individual WLAN settings cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 8)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL(): matching SecondarySSID/*");
+ //Check if the secondary SSID is present , if so delete that
+ TUint32 secid = GetSecSSIDFromUriL(aURI);
+ TInt retvalue(KErrNone);
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL() before call to DeleteOneSecondarySSIDL ");
+ TRAPD(ssidError, retvalue = iWlanSettings->DeleteOneSecondarySSIDL(
+ luid, secid));
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL() After call to DeleteOneSecondarySSIDL ");
+ DBG_ARGS8(_S8(
+ "TRAP ERROR ssidError : Id = %d and retvalue eror = %d"),
+ ssidError, retvalue);
+
+ if (ssidError == KErrNone)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DeleteObjectL() SSID trap KERRONONE");
+ if (retvalue == KErrNone)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL() retvalue also KERRONONE, so its deleted");
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (retvalue == KErrNotFound)
+ {
+ status = CSmlDmAdapter::ENotFound;
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL() retvalue KErrNotFound :-(");
+ }
+
+ else
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::DeleteObjectL() retvalue some error :-(");
+ status = CSmlDmAdapter::EError;
+ }
+
+ }
+ else
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DeleteObjectL() trap error :-( ");
+ status = CSmlDmAdapter::EError;
+ }
+
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 7)
+ {
+ // Individual WLAN settings cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 8)
+ {
+ // Individual WEP keys cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*/Data"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 9)
+ {
+ // Individual WEP keys cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 8)
+ {
+ // Individual EAP settings cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 9)
+ {
+ // Individual EAP settings cannot be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 10)
+ {
+ // Individual certificates are not allowed to be deleted and this case should never happen
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 11)
+ {
+ // Individual certificate fields are not allowed to be deleted and this case should never happen.
+ // These are deleted through WLAN parent nodes.
+ status = CSmlDmAdapter::EError;
+ }
+
+ iCallBack->SetStatusL(aStatusRef, status);
+
+ _DBG_FILE("CNSmlWLanAdapter::DeleteObjectL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::FetchLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aType,
+// const TInt aResultsRef, const TInt aStatusRef )
+// not used.
+//-----------------------------------------------------------------------------
+
+void CNSmlWLanAdapter::FetchLeafObjectSizeL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, const TDesC8& /*aType*/,
+ TInt /*aResultsRef*/, TInt /*aStatusRef*/)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectSizeL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectSizeL(): end");
+ return;
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::FetchLeafObjectL( const TDesC8& aURI,
+// const TDesC8& aLUID, const TDesC8& aType,
+// const TInt aResultsRef, const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::FetchLeafObjectL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, const TDesC8& /*aType*/,
+ const TInt /*aResultsRef*/, const TInt /*aStatusRef*/)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): end");
+
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::FetchLeafObjectL( const TDesC& aURI,
+// const TDesC& aLUID, const TDesC& aType,
+// const TInt aResultsRef, const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+CSmlDmAdapter::TError CNSmlWLanAdapter::FetchLeafObjectL(const TDesC8& aURI,
+ const TDesC8& aLUID, const TDesC8& aType, CBufBase& aObject)
+ {
+
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): begin");
+ DBG_ARGS8(_S8("WLanAdapter::FetchLeafObjectL - <%S> <%S> <%S>"), &aURI,
+ &aLUID, &aType);
+
+ if (aLUID.Length() == 0)
+ {
+
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): ENotFound");
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound;
+
+ // This luid is the service table id (Found from EAP node and parents)
+ TInt luid;
+ if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) != KErrNotFound)
+ {
+ luid = GetServiceIdFromUriL(aURI);
+ }
+ else
+ {
+ // The luid supplied is ok
+ luid = GetIdFromLuid(aLUID);
+ }
+
+ TPtrC8 lastUriSeg = GetLastUriSeg(aURI);
+
+ if (luid == KErrNotFound)
+ {
+ return CSmlDmAdapter::ENotFound;;
+ }
+
+ TInt err = iWlanSettings->GetWlanSettings(luid, *iSettings);
+
+ if (err == KErrNotFound)
+ {
+
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): ENotFound");
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)
+ {
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ != KErrNotFound)
+ {
+ RArray<TSecondarySSID> secondarySSIDs;
+ CleanupClosePushL(secondarySSIDs);
+ iWlanSettings->GetSecondarySSIDListL(luid, secondarySSIDs);
+ TSecondarySSID ssid;
+ ssid.Id = 0;
+ TUint32 id = GetSecSSIDFromUriL(aURI);
+ TInt count = secondarySSIDs.Count();
+ for (TInt i = 0; i < count; i++)
+ {
+ if (id == secondarySSIDs[i].Id)
+ {
+ ssid = secondarySSIDs[i];
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy(&secondarySSIDs);
+ if (ssid.Id == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+ }
+ else
+ {
+ HBufC* data = ssid.ScannedId.AllocLC();
+ HBufC8* data8 = HBufC8::NewLC(data->Size());
+ TPtr8 dataPtr8 = data8->Des();
+ //FFS
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(dataPtr8,
+ data->Des());
+
+ aObject.InsertL(0, dataPtr8);
+ status = CSmlDmAdapter::EOk;
+
+ CleanupStack::PopAndDestroy(2); //data, data8
+ }
+ }
+ else
+ {
+
+ HBufC* data = iSettings->SSID.AllocLC();
+ HBufC8* data8 = HBufC8::NewLC(data->Size());
+ TPtr8 dataPtr8 = data8->Des();
+ //FFS
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(dataPtr8, data->Des());
+
+ aObject.InsertL(0, dataPtr8);
+ status = CSmlDmAdapter::EOk;
+
+ CleanupStack::PopAndDestroy(2); //data, data8
+
+ }
+
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)
+ {
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ != KErrNotFound)
+ {
+ RArray<TSecondarySSID> secondarySSIDs;
+ CleanupClosePushL(secondarySSIDs);
+ iWlanSettings->GetSecondarySSIDListL(luid, secondarySSIDs);
+ TSecondarySSID ssid;
+ ssid.Id = 0;
+ TUint32 id = GetSecSSIDFromUriL(aURI);
+ TInt count = secondarySSIDs.Count();
+ for (TInt i = 0; i < count; i++)
+ {
+ if (id == secondarySSIDs[i].Id)
+ {
+ ssid = secondarySSIDs[i];
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy(&secondarySSIDs);
+ if (ssid.Id == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+ }
+ else
+ {
+ HBufC* data = ssid.UsedId.AllocLC();
+ HBufC8* data8 = HBufC8::NewLC(data->Size());
+ TPtr8 dataPtr8 = data8->Des();
+ //FFS
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(dataPtr8,
+ data->Des());
+
+ aObject.InsertL(0, dataPtr8);
+ status = CSmlDmAdapter::EOk;
+
+ CleanupStack::PopAndDestroy(2); //data, data8
+ }
+ }
+ else
+ {
+
+ HBufC* data = iSettings->UsedSSID.AllocLC();
+ HBufC8* data8 = HBufC8::NewLC(data->Size());
+ TPtr8 dataPtr8 = data8->Des();
+ //FFS
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(dataPtr8, data->Des());
+
+ aObject.InsertL(0, dataPtr8);
+ status = CSmlDmAdapter::EOk;
+
+ CleanupStack::PopAndDestroy(2); //data, data8
+
+ }
+
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanSsidHidden) == 0)
+ {
+ if (iSettings->ScanSSID == 1)
+ {
+ aObject.InsertL(0, _L8("True"));
+ }
+ else
+ {
+ aObject.InsertL(0, _L8("False"));
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanNetworkMode) == 0)
+ {
+ status = CSmlDmAdapter::EOk;
+
+ switch (iSettings->ConnectionMode)
+ {
+ case 0:
+ aObject.InsertL(0, KNSmlWLanAdHoc8);
+ break;
+ case 1:
+ aObject.InsertL(0, KNSmlWLanInfrastructure8);
+ break;
+ default:
+ status = CSmlDmAdapter::ENotFound;
+ break;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSecurityMode) == 0)
+ {
+ status = CSmlDmAdapter::EOk;
+
+ switch (iSettings->SecurityMode)
+ {
+ case EAllowUnsecure:
+ aObject.InsertL(0, KNSmlWLanAllowUnsecure8);
+ break;
+ case EWep:
+ aObject.InsertL(0, KNSmlWLanWep8);
+ break;
+ case EWlan8021x:
+ aObject.InsertL(0, KNSmlWLan8021x8);
+ break;
+ case EWpa:
+ aObject.InsertL(0, KNSmlWLanWpa8);
+ break;
+ case EWpa2:
+ aObject.InsertL(0, KNSmlWLanWpa28);
+ break;
+ default:
+ status = CSmlDmAdapter::ENotFound;
+ break;
+ }
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWpaPreSharedKey) == 0)
+ {
+ aObject.InsertL(0, iSettings->WPAPreSharedKey);
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUseWPAPSK) == 0)
+ {
+ if (iSettings->UseWPAPSK == 1)
+ {
+ aObject.InsertL(0, _L8("True"));
+ }
+ else
+ {
+ aObject.InsertL(0, _L8("False"));
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWepIndex) == 0)
+ {
+ HBufC8* data = IntToDes8LC(iSettings->WepIndex);
+ aObject.InsertL(0, data->Des());
+
+ CleanupStack::PopAndDestroy(data); //data
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanEapList) == 0)
+ {
+ HBufC* data = iSettings->EapList.AllocLC();
+ HBufC8* data8 = HBufC8::NewLC(data->Size());
+ TPtr8 dataPtr8 = data8->Des();
+ //FFS
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(dataPtr8, data->Des());
+
+ aObject.InsertL(0, dataPtr8);
+ status = CSmlDmAdapter::EOk;
+
+ CleanupStack::PopAndDestroy(2); //data, data8
+
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanAuthMode) == 0)
+ {
+ HBufC8* data = IntToDes8LC(iSettings->AuthMode);
+ aObject.InsertL(0, data->Des());
+
+ CleanupStack::PopAndDestroy(data); //data
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWepKeyData) == 0)
+ {
+ TInt wepKeyIndex = GetWepKeyIdFromLuid(aLUID);
+ if (wepKeyIndex == KErrNotFound)
+ {
+ wepKeyIndex = GetWepKeyIdFromUri(aURI);
+ TBuf8<80> addLUID; // AP/<x>/NapDef/<x>/WLAN/<x>/WEPKey/WKIdnnn
+ addLUID.AppendNum(wepKeyIndex);
+ addLUID.AppendNumFixedWidth(luid, EDecimal, 3);
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::Fetchleaf object, set mapping uri: <%S> to luid: <%S>"),
+ &aURI, &addLUID);
+ DBG_ARGS8(_S8("Parametrit - <%S> <%S>"), &aURI, &addLUID);
+ iCallBack->SetMappingL(aURI, addLUID);
+
+ }
+ status = CSmlDmAdapter::EOk;
+ switch (wepKeyIndex)
+ {
+ case 1:
+ aObject.InsertL(0, iSettings->WepKey1);
+ break;
+ case 2:
+ aObject.InsertL(0, iSettings->WepKey2);
+ break;
+ case 3:
+ aObject.InsertL(0, iSettings->WepKey3);
+ break;
+ case 4:
+ aObject.InsertL(0, iSettings->WepKey4);
+ break;
+ default:
+ status = CSmlDmAdapter::EError;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanWepKeyId) == 0)
+ {
+ TInt wepKeyIndex = GetWepKeyIdFromLuid(aLUID);
+ if (wepKeyIndex == KErrNotFound)
+ {
+ wepKeyIndex = GetWepKeyIdFromUri(aURI);
+ TBuf8<80> addLUID; // AP/<x>/NapDef/<x>/WLAN/<x>/WEPKey/WKIdnnn
+ addLUID.AppendNum(wepKeyIndex);
+ addLUID.AppendNumFixedWidth(luid, EDecimal, 3);
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::Fetchleaf object, set mapping uri: <%S> to luid: <%S>"),
+ &aURI, &addLUID);
+ DBG_ARGS8(_S8("Parametrit - <%S> <%S>"), &aURI, &addLUID);
+ iCallBack->SetMappingL(aURI, addLUID);
+ }
+ if (wepKeyIndex > 0)
+ {
+ HBufC8* data = IntToDes8LC(wepKeyIndex);
+ aObject.InsertL(0, data->Des());
+ CleanupStack::PopAndDestroy(data); //data
+ status = CSmlDmAdapter::EOk;
+ }
+ else
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) != KErrNotFound)
+ {
+ TInt eapId = GetEAPIdFromUri(aURI);
+
+ // Check if the id contains encapsulating type as well
+ TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);
+ if (encapsEapId == KErrNotFound)
+ {
+ encapsEapId = EEapNone;
+ }
+
+ ResetEAPStructL();
+ TEapExpandedType expandedTypecmbuf;
+ TEapExpandedType expandedTypeencapscmbuf;
+
+ GetExpandedType(eapId, encapsEapId, expandedTypecmbuf,
+ expandedTypeencapscmbuf);
+ TInt err = iWlanSettings->GetEAPSettings(luid, expandedTypecmbuf,
+ expandedTypeencapscmbuf, *iEAPSettings);
+
+ if (err != KErrNone || iEAPSettings == NULL)
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanEapType) == 0)
+ {
+ aObject.InsertL(0, *IntToDes8LC(eapId));
+ CleanupStack::PopAndDestroy(); // IntToDes8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsername) == 0)
+ {
+ if (iEAPSettings->iUsernamePresent)
+ {
+ DesToBufferL(aObject, iEAPSettings->iUsername);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanPassword) == 0)
+ {
+ if (iEAPSettings->iPasswordPresent)
+ {
+ DesToBufferL(aObject, iEAPSettings->iPassword);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanRealm) == 0)
+ {
+ if (iEAPSettings->iRealmPresent)
+ {
+ DesToBufferL(aObject, iEAPSettings->iRealm);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanUsePseudonym) == 0)
+ {
+ if (iEAPSettings->iUsePseudonymsPresent
+ && iEAPSettings->iUsePseudonyms)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanEncapsulation) == 0)
+ {
+ if (encapsEapId == EEapPeap)
+ {
+ aObject.InsertL(0, KEAPPEAP);
+ }
+ else if (encapsEapId == EEapTtls)
+ {
+ aObject.InsertL(0, KEAPTTLS);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanVerifyCertRealm) == 0)
+ {
+ if (iEAPSettings->iVerifyServerRealmPresent
+ && iEAPSettings->iVerifyServerRealm)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanRequireClientAuthentication)
+ == 0)
+ {
+ if (iEAPSettings->iRequireClientAuthenticationPresent
+ && iEAPSettings->iRequireClientAuthentication)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSessionValidityTime) == 0)
+ {
+ if (iEAPSettings->iSessionValidityTimePresent)
+ {
+ aObject.InsertL(0, *IntToDes8LC(
+ (TInt) iEAPSettings->iSessionValidityTime));
+ CleanupStack::PopAndDestroy(); // IntToDes8LC
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanCipherSuite) == 0)
+ {
+ FillCipherSuiteBufferL(aObject);
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv0) == 0)
+ {
+ if (iEAPSettings->iPEAPVersionsPresent
+ && iEAPSettings->iPEAPv0Allowed)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv1) == 0)
+ {
+ if (iEAPSettings->iPEAPVersionsPresent
+ && iEAPSettings->iPEAPv1Allowed)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanAllowPEAPv2) == 0)
+ {
+ if (iEAPSettings->iPEAPVersionsPresent
+ && iEAPSettings->iPEAPv2Allowed)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+#ifdef FF_WLAN_EXTENSIONS
+ else if (lastUriSeg.Compare(KNSmlWLanAuthProvMode) == 0)
+ {
+ if (iEAPSettings->iAuthProvModeAllowedPresent && iEAPSettings->iAuthProvModeAllowed)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanUnauthProvMode) == 0)
+ {
+ if (iEAPSettings->iUnauthProvModeAllowedPresent && iEAPSettings->iUnauthProvModeAllowed)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanPACGroupRef) == 0)
+ {
+ if (iEAPSettings->iPACGroupReferencePresent)
+ {
+ DesToBufferL(aObject, iEAPSettings->iPACGroupReference);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnADHPNoPAC) == 0)
+ {
+ if (iEAPSettings->iWarnADHPNoPACPresent && iEAPSettings->iWarnADHPNoPAC)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnADHPNoMatchPAC) == 0)
+ {
+ if (iEAPSettings->iWarnADHPNoMatchingPACPresent && iEAPSettings->iWarnADHPNoMatchingPAC)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+ else if (lastUriSeg.Compare(KNSmlWLanWarnNotDefaultSrv) == 0)
+ {
+ if (iEAPSettings->iWarnNotDefaultServerPresent && iEAPSettings->iWarnNotDefaultServer)
+ {
+ aObject.InsertL(0, KTrue);
+ }
+ else
+ {
+ aObject.InsertL(0, KFalse);
+ }
+ status = CSmlDmAdapter::EOk;
+ }
+
+#endif
+
+ else if (lastUriSeg.Compare(KNSmlWLanIssuerName) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetIssuerNamePresent())
+ {
+ aObject.InsertL(0,
+ ConvertTo8LC(*(iEAPSettings->iCertificates[certId
+ - 1]->GetIssuerName())));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSubjectName) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetSubjectNamePresent())
+ {
+ aObject.InsertL(0,
+ ConvertTo8LC(*(iEAPSettings->iCertificates[certId
+ - 1]->GetSubjectName())));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanCertType) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ aObject.InsertL(
+ 0,
+ *IntToDes8LC(
+ iEAPSettings->iCertificates[certId - 1]->GetCertType()));
+ CleanupStack::PopAndDestroy(); // IntToDes8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSerialNumber) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetSerialNumberPresent())
+ {
+ aObject.InsertL(0,
+ ConvertTo8LC(*(iEAPSettings->iCertificates[certId
+ - 1]->GetSerialNumber())));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSubjectKeyId) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetSubjectKeyIdPresent())
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::FetchLeafObject - Fetch subject key.");
+ // check the lenght of the given subjectKeyId, if it is longer that 20, then we
+ // update the status with error and will not go through the key
+ if ((iEAPSettings->iCertificates[certId - 1]->GetSubjectKeyId().Length())
+ > KKeyIdentifierLength)
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ else
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::FetchLeafObject - key is under max lenght");
+ TBuf8<KKeyIdentifierLength>
+ binKey = iEAPSettings->iCertificates[certId
+ - 1]->GetSubjectKeyId();
+ TBuf8<2> idBuf;
+ TBuf8<KKeyIdentifierLength * 2> key;
+ TUint8 byte;
+
+ // hexadecimal representation
+ _LIT8(KFormat, "%02x");
+
+ // looping the subject key through
+ for (TInt i = 0; i < binKey.Length(); i++)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::FetchLeafObject - Loop the key through.");
+ // pick the next value from the buffer
+ byte = binKey[i];
+ // convert the value into hexadecimal format
+ idBuf.Format(KFormat, byte);
+ // store the hexa value into the key variable
+ key.Append(idBuf);
+ }
+ // Copy the key to the aObject variable
+ aObject.InsertL(0, key);
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanFingerprint) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetThumbprintPresent())
+ {
+ aObject.InsertL(0,
+ ConvertTo8LC(*(iEAPSettings->iCertificates[certId
+ - 1]->GetThumbprint())));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ else if (lastUriSeg.Compare(KNSmlWLanSerialNumber) == 0)
+ {
+ status = CSmlDmAdapter::ENotFound;
+
+ TInt certId = GetCertificateIdFromUri(aURI);
+
+ if (iEAPSettings->iCertificatesPresent
+ && iEAPSettings->iCertificates.Count() >= certId
+ && certId != KErrNotFound)
+ {
+ if (iEAPSettings->iCertificates[certId - 1]->GetSerialNumberPresent())
+ {
+ aObject.InsertL(0,
+ ConvertTo8LC(*(iEAPSettings->iCertificates[certId
+ - 1]->GetSerialNumber())));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ status = CSmlDmAdapter::EOk;
+ }
+ }
+ }
+ }
+
+ DBG_ARGS(_S16("CNSmlWLanAdapter::FetchLeafObjectL - Status <%D>"), status);
+ _DBG_FILE("CNSmlWLanAdapter::FetchLeafObjectL(): end");
+ return status;
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::ChildURIListL( const TDesC& aURI,
+// const TDesC& aLUID, const CArrayFix<TNSmlDmMappingInfo>& aPreviousURISegmentList,
+// const TInt aResultsRef, const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::ChildURIListL(const TDesC8& aURI, const TDesC8& aLUID,
+ const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList,
+ const TInt aResultsRef, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): begin");
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL - <%S> <%S>"), &aURI, &aLUID);
+ CBufBase* currentUriSegmentList = CBufFlat::NewL(128);
+ CleanupStack::PushL(currentUriSegmentList);
+
+ TInt uriSegs = NumOfUriSegs(aURI);
+ TInt luid = GetIdFromLuid(aLUID);
+
+ //AP/<x>/NAPDef/<x>/
+ if (aURI.Match(_L8("AP/*/NAPDef/*")) != KErrNotFound && uriSegs == 4)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->NAPDef - <%S> <%S>"),
+ &aURI, &aLUID);
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ currentUriSegmentList->InsertL(0, KNSmlNAPDefWlanNode);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ else
+ {
+ currentUriSegmentList->InsertL(0, KNSmlNAPDefWlanNode);
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLan);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+
+ //AP/<x>/NAPDef/<x>/WLAN
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN")) != KErrNotFound && uriSegs
+ == 5)
+ {
+ if (aPreviousURISegmentList.Count() > 0)
+ {
+ HBufC8 *uriSeg = HBufC8::NewLC(KNSmlMaxURISegLen);
+ TPtr8 uriSegPtr = uriSeg->Des();
+ uriSegPtr = aPreviousURISegmentList.At(0).iURISeg;
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ uriSegPtr);
+ CleanupStack::PopAndDestroy(uriSeg); //uriSeg
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ else
+ {
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlWLanAdapter::ChildURIListL(): status: Not found");
+ }
+ else
+ {
+ _LIT8(Kprev, "WLId");
+ TBuf8<9> addNAME(Kprev); // WLId
+ addNAME.AppendNumFixedWidth(luid, EDecimal, 3);
+
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ addNAME);
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ _L8("/"));
+
+ TBuf8<80> addURI; // AP/<x>/NapDef/<x>/WLAN/WLIdnnn , n=aLUID
+ addURI.Append(aURI);
+ addURI.Append(_L8("/WLId"));
+ addURI.AppendNumFixedWidth(luid, EDecimal, 3);
+
+ TBuf8<16> addLUID;
+ _LIT8(KFormat, "%d");
+ addLUID.Format(KFormat, luid);
+
+ // Also added to mapping
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::ChildURIListL - mapping uri: <%S> to luid: <%S>"),
+ &addURI, &addLUID);
+ DBG_ARGS8(_S8("Parameters - <%S> <%S>"), &aURI, &aLUID);
+ iCallBack->SetMappingL(addURI, addLUID);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ }
+
+ //AP/<x>/NAPDef/<x>/WLAN/<x>
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*")) != KErrNotFound
+ && uriSegs == 6)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->NAPDef - <%S> <%S>"),
+ &aURI, &aLUID);
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLanListOfLeafs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/WEPKey
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey")) != KErrNotFound
+ && uriSegs == 7)
+ {
+ DBG_ARGS8(_S8(
+ "WLanAdapter::ChildURIListL->WEPKey - <%S> <%S> <%D> <%D>"),
+ &aURI, &aLUID, aResultsRef, aStatusRef);
+
+ for (TInt i = 0; i < 4; i++)
+ {
+ if (aPreviousURISegmentList.Count() > i)
+ {
+ HBufC8 *uriSeg = HBufC8::NewLC(KNSmlMaxURISegLen);
+ TPtr8 uriSegPtr = uriSeg->Des();
+ uriSegPtr = aPreviousURISegmentList.At(i).iURISeg;
+
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ uriSegPtr);
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ _L8("/"));
+ CleanupStack::PopAndDestroy(); //uriSeg
+ }
+ else
+ {
+ TBuf8<25> addNAME;
+ addNAME.Append(_L8("WKId"));
+ addNAME.AppendNum(i + 1);
+ addNAME.Append(_L8("/"));
+
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ addNAME);
+ }
+ }
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+
+ //AP/<x>/NAPDef/<x>/WEPKey/<x>
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*")) != KErrNotFound
+ && uriSegs == 8)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->WEPKey/* - <%S> <%D>"),
+ &aURI, luid);
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ //wlan settings not found for aLUID
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ TInt wepKeyId = GetWepKeyIdFromLuid(aLUID);
+ if (wepKeyId == KErrNotFound)
+ {
+ wepKeyId = GetWepKeyIdFromUri(aURI);
+
+ TBuf8<80> addLUID; // AP/<x>/NapDef/<x>/WLAN/<x>/WEPKey/WKIdnnn
+ addLUID.AppendNum(wepKeyId);
+ addLUID.AppendNumFixedWidth(luid, EDecimal, 3);
+
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::ChildURIListL - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &addLUID);
+ DBG_ARGS8(_S8("Parametrit - <%S> <%S>"), &aURI, &addLUID);
+ iCallBack->SetMappingL(aURI, addLUID);
+ }
+
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLanListOfWepKeyLeafs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/SecondarySSID/
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID"))
+ != KErrNotFound && uriSegs == 7)
+ {
+ DBG_ARGS8(
+ _S8("WLanAdapter::ChildURIListL->EAP - <%S> <%S> <%D> <%D>"),
+ &aURI, &aLUID, aResultsRef, aStatusRef);
+ if (aPreviousURISegmentList.Count() > 0)
+ {
+ HBufC8 *uriSeg = HBufC8::NewLC(KNSmlMaxURISegLen);
+ TPtr8 uriSegPtr = uriSeg->Des();
+ uriSegPtr = aPreviousURISegmentList.At(0).iURISeg;
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ uriSegPtr);
+ CleanupStack::PopAndDestroy(uriSeg); //uriSeg
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ else
+ {
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE(
+ "CNSmlWLanAdapter::ChildURIListL(): status: Not found");
+ }
+ else
+ {
+ RArray<TSecondarySSID> secondarySSIDs;
+ CleanupClosePushL(secondarySSIDs);
+ iWlanSettings->GetSecondarySSIDListL(luid, secondarySSIDs);
+ TInt count = secondarySSIDs.Count();
+ _LIT8(KPrefixSSID, "SecSSID");
+ TBuf8<5> addNAME; // number
+ for (TInt i = 0; i < count; i++)
+ {
+ if (i != 0) // Don't do it in first iteration, but with all the following
+ {
+ currentUriSegmentList->InsertL(
+ currentUriSegmentList->Size(), _L8("/"));
+ }
+ currentUriSegmentList->InsertL(
+ currentUriSegmentList->Size(), KPrefixSSID);
+ addNAME.Zero();
+ addNAME.AppendNumFixedWidth(secondarySSIDs[i].Id,
+ EDecimal, 3);
+ currentUriSegmentList->InsertL(
+ currentUriSegmentList->Size(), addNAME);
+ }
+ CleanupStack::PopAndDestroy(&secondarySSIDs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ }
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/SecondarySSID/*
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ != KErrNotFound && uriSegs == 8)
+ {
+ DBG_ARGS8(_S8(
+ "WLanAdapter::ChildURIListL->SecondarySSID/* - <%S> <%D>"),
+ &aURI, luid);
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ //wlan settings not found for aLUID
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLanListOfSecondaryLeafs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/EAP
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP")) != KErrNotFound
+ && uriSegs == 7)
+ {
+ DBG_ARGS8(
+ _S8("WLanAdapter::ChildURIListL->EAP - <%S> <%S> <%D> <%D>"),
+ &aURI, &aLUID, aResultsRef, aStatusRef);
+
+ // Need to get the service id from parent node
+ luid = GetServiceIdFromUriL(aURI);
+
+ if (luid == KErrNotFound)
+ {
+ return;
+ }
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ //wlan settings not found for aLUID
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ iWlanSettings->InstalledEAPsL(*currentUriSegmentList);
+
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/EAP/<x>
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) != KErrNotFound
+ && uriSegs == 8)
+ {
+ // Need to get the service id from parent node
+ luid = GetServiceIdFromUriL(aURI);
+
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->EAP/* - <%S> <%D>"),
+ &aURI, luid);
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ //wlan settings not found for aLUID
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLanListOfEAPLeafs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/EAP/<x>/Certificate
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate"))
+ != KErrNotFound && uriSegs == 9)
+ {
+ luid = GetServiceIdFromUriL(aURI);
+
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->Certificate - <%S> <%D>"),
+ &aURI, luid);
+ if (iWlanSettings->RecordExists(luid) < 0)
+ {
+ //wlan settings not found for aLUID
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ TInt eapId = GetEAPIdFromUri(aURI);
+
+ // Check if the id contains encapsulating type as well
+ TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);
+ if (encapsEapId == KErrNotFound)
+ {
+ encapsEapId = EEapNone;
+ }
+
+ ResetEAPStructL();
+ TEapExpandedType expandedTypecmbuf;
+ TEapExpandedType expandedTypeencapscmbuf;
+
+ GetExpandedType(eapId, encapsEapId, expandedTypecmbuf,
+ expandedTypeencapscmbuf);
+
+ TInt err = iWlanSettings->GetEAPSettings(luid, expandedTypecmbuf,
+ expandedTypeencapscmbuf, *iEAPSettings);
+ if (err != KErrNone || !iEAPSettings->iCertificatesPresent)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ TInt certCount = iEAPSettings->iCertificates.Count();
+ HBufC8* pBuf = HBufC8::NewLC(KNSmlMaxURISegLen);
+ TPtr8 ptrCerts = pBuf->Des();
+ for (TInt i = 0; i < certCount; i++)
+ {
+ ptrCerts.Append(_L8("CertId"));
+ ptrCerts.AppendNumFixedWidth(i + 1, EDecimal, 3);
+ ptrCerts.Append(_L8("/"));
+ }
+
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ ptrCerts);
+ CleanupStack::PopAndDestroy(pBuf); // pBuf
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+ }
+ //AP/<x>/NAPDef/<x>/WLAN/<x>/EAP/<x>/Certificate/<x>
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*"))
+ != KErrNotFound && uriSegs == 10)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::ChildURIListL->EAP/* - <%S> <%D>"),
+ &aURI, luid);
+ TInt eapId = GetEAPIdFromUri(aURI);
+ // Check if the id contains encapsulating type as well
+ TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);
+ if (encapsEapId == KErrNotFound)
+ {
+ encapsEapId = EEapNone;
+ }
+
+ ResetEAPStructL();
+ TEapExpandedType expandedTypecmbuf;
+ TEapExpandedType expandedTypeencapscmbuf;
+
+ GetExpandedType(eapId, encapsEapId, expandedTypecmbuf,
+ expandedTypeencapscmbuf);
+
+ TInt err = iWlanSettings->GetEAPSettings(luid, expandedTypecmbuf,
+ expandedTypeencapscmbuf, *iEAPSettings);
+ if (err != KErrNone || !iEAPSettings->iCertificatesPresent)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): ENotFound end");
+ }
+ else
+ {
+ currentUriSegmentList->InsertL(currentUriSegmentList->Size(),
+ KNSmlWLanListOfCertificateLeafs);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ iCallBack->SetResultsL(aResultsRef, *currentUriSegmentList,
+ KNullDesC8);
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): status ok");
+ }
+ }
+
+ CleanupStack::PopAndDestroy(currentUriSegmentList);
+
+ _DBG_FILE("CNSmlWLanAdapter::ChildURIListL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// void CNSmlWLanAdapter::AddNodeObjectL( const TDesC& aURI, const TDesC& aParentLUID,
+// const TInt aStatusRef )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::AddNodeObjectL(const TDesC8& aURI,
+ const TDesC8& aParentLUID, const TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::AddNodeObjectL(): begin");
+ DBG_ARGS8(_S8(
+ "WLanAdapter::AddNodeObjectL - uri: <%S> to aParentLuid: <%S>"),
+ &aURI, &aParentLUID);
+
+ TInt uriSegs = NumOfUriSegs(aURI);
+ if ((aURI.Match(_L8("AP/*/NAPDef/*/WLAN")) != KErrNotFound && uriSegs
+ == 5) || (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP"))
+ != KErrNotFound && uriSegs == 7) || (aURI.Match(_L8(
+ "AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate")) != KErrNotFound
+ && uriSegs == 9))
+ {
+ iCallBack->SetMappingL(aURI, aParentLUID);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ return;
+ }
+
+ //Add new wlan settings
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 6)
+ {
+ TBuf<KCommsDbSvrMaxFieldLength> serviceType;
+ TUint32 serviceId(NULL);
+ TUint32 lValue;
+ CCommsDbTableView* napdefView = iDatabase.OpenViewMatchingUintLC(
+ TPtrC(IAP), TPtrC(COMMDB_ID), DesToInt(aParentLUID));
+ TInt 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();
+ if (errorCode == KErrNone)
+ {
+ tableView->ReadUintL(TPtrC(COMMDB_ID), lValue);
+ }
+ CleanupStack::PopAndDestroy();//tableview
+ CleanupStack::PopAndDestroy();//napdefview
+
+ iSettings->Id = 0;
+ iSettings->ServiceID = lValue;
+ iSettings->ConnectionMode = 0;
+ iSettings->SSID = TPtrC(KNSmlWLanDefaultSSID);
+ iSettings->UsedSSID = _L("");
+ iSettings->ScanSSID = 0;
+ iSettings->WepKey1 = _L8("");
+ iSettings->WepKey2 = _L8("");
+ iSettings->WepKey3 = _L8("");
+ iSettings->WepKey4 = _L8("");
+ iSettings->WepIndex = 0;
+ iSettings->SecurityMode = EAllowUnsecure;
+ iSettings->WPAPreSharedKey = _L8("");
+ iSettings->UseWPAPSK = 0;
+ iSettings->EapList = _L("");
+ iSettings->AuthMode = 0;
+
+ TInt err = iWlanSettings->WriteWlanSettings(*iSettings);
+ if (err != KErrNone)
+ {
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ return;
+ }
+
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::AddNodeObjectL - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &aParentLUID);
+ iCallBack->SetMappingL(aURI, aParentLUID);
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey")) != KErrNotFound
+ && uriSegs == 7)
+ {
+ if (iWlanSettings->RecordExists(DesToInt(aParentLUID)))
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);
+ else
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);
+ return;
+ }
+
+ //Add wep key for existing record
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*")) != KErrNotFound
+ && uriSegs == 8)
+ {
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ if (iBuffer->At(i).iUri->Match(aURI) != KErrNotFound)
+ {
+ iCallBack->SetStatusL(aStatusRef,
+ CSmlDmAdapter::EAlreadyExists);
+
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddNodeObjectL(): EAlreadyExists");
+ return;
+ }
+ }
+ DBG_ARGS8(_S8(
+ "WLanAdapter::Bufferiin - uri: <%S> to aParentLuid: <%S>"),
+ &aURI, &aParentLUID);
+
+ TNSmlWepKeyBufferElement newNode;
+ newNode.iUri = aURI.AllocLC();
+ newNode.iData = 0;
+ newNode.iWepKeyId = 0;
+ //newNode.iUseWPAPSK = 0;
+ newNode.iIdStatusRef = 0;
+ newNode.iDataStatusRef = 0;
+ newNode.iLengthStatusRef = 0;
+ newNode.iNodeStatusRef = aStatusRef;
+ newNode.iExecuted = EFalse;
+ newNode.iDataSet = EFalse;
+ newNode.iLuid = DesToInt(aParentLUID);
+ iBuffer->AppendL(newNode);
+
+ CleanupStack::Pop(); //newNode.iUri
+
+ _DBG_FILE("CNSmlWLanAdapter::AddNodeObjectL(): end");
+ return;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 8)
+ {
+ /*
+ TSecondarySSID ssid;
+ ssid.ScannedId = KNullDesC;
+ ssid.UsedId = KNullDesC;
+ TInt luid = GetIdFromLuid( aParentLUID );
+ TInt retval = iWlanSettings->WriteSecondarySSIDL(luid, ssid, ETrue);*/
+
+ TNSmlSecondarySSIDBufferElement *newSecNode =
+ new (ELeave) TNSmlSecondarySSIDBufferElement;
+ ;
+ newSecNode->iUri = aURI.AllocLC();
+ newSecNode->ScannedId = KNullDesC;
+ newSecNode->UsedId = KNullDesC;
+ newSecNode->iExecuted = EFalse;
+ newSecNode->wlanLuid = GetIdFromLuid(aParentLUID);
+ iSecondaryBuffer.AppendL(newSecNode);
+ CleanupStack::Pop(); //newNode.iUri
+ return;
+ }
+
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) != KErrNotFound
+ && NumOfUriSegs(aURI) == 8)
+ {
+ TInt eapTypeId = GetEAPIdFromUri(aURI);
+ TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);
+ if (encapsEapId == KErrNotFound)
+ {
+ encapsEapId = EEapNone;
+ }
+
+ TInt WLANServiceId = GetServiceIdFromUriL(aURI);
+
+ if (WLANServiceId == KErrNotFound)
+ {
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddNodeObjectL(): Could not find WLAN service ID from URI.");
+ User::Leave(KErrNotFound);
+ }
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+
+ TBuf8<KExpandedEapIdLength> cmpbuf;
+ if (eapTypeId == KPlainMsChapV2ImplUid)
+ {
+ cmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ cmpbuf.Append(KPadding);
+ }
+ cmpbuf.Append(eapTypeId);
+ TEapExpandedType expandedTypecmbuf(cmpbuf);
+
+ TBuf8<KExpandedEapIdLength> encapscmpbuf;
+ if (encapsEapId == KPlainMsChapV2ImplUid)
+ {
+ encapscmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ encapscmpbuf.Append(KPadding);
+ }
+ encapscmpbuf.Append(encapsEapId);
+ TEapExpandedType expandedTypeencapscmbuf(encapscmpbuf);
+
+ TInt i(0);
+ // Check if the buffer for this EAP already exists
+ for (i = 0; i < iEAPBuffer.Count(); i++)
+ {
+ if ((expandedTypecmbuf.Compare(
+ iEAPBuffer[i]->iEAPSettings->iEAPExpandedType) == 0)
+ && (expandedTypeencapscmbuf.Compare(
+ iEAPBuffer[i]->iEncapsulatingExpandedEapId) == 0))
+ {
+ // The correct buffer was found.
+ _DBG_FILE(
+ "CNSmlWLanAdapter::AddNodeObjectL(): Found existing buffer.");
+ break;
+ }
+ }
+ // buffer did not exist. Update the existing buffer
+ if (i == iEAPBuffer.Count())
+ {
+ TNSmlEAPBufferElement* buffer =
+ new (ELeave) TNSmlEAPBufferElement;
+ CleanupStack::PushL(buffer);
+
+ buffer->iEAPSettings = new (ELeave) EAPSettings;
+ CleanupStack::PushL(buffer->iEAPSettings);
+
+ TBuf8<KExpandedEapIdLength> tempbuf;
+ if (eapTypeId == KPlainMsChapV2ImplUid)
+ {
+ tempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ tempbuf.Append(KPadding);
+ }
+ tempbuf.Append(eapTypeId);
+
+ buffer->iEAPSettings->iEAPExpandedType = tempbuf;
+ buffer->iStatusRefArray.AppendL(aStatusRef);
+ buffer->iWLANServiceId = WLANServiceId;
+ ConvertEAPStringToIds(buffer->iEapTypeString,
+ buffer->iEAPSettings->iEAPExpandedType);
+ TBuf8<KExpandedEapIdLength> encapsTempbuf;
+ if (encapsEapId == KPlainMsChapV2ImplUid)
+ {
+ encapsTempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ encapsTempbuf.Append(KPadding);
+ }
+ encapsTempbuf.Append(encapsEapId);
+ buffer->iEncapsulatingExpandedEapId = encapsTempbuf;
+ if (buffer->iEncapsulatingExpandedEapId
+ != (*EapExpandedTypeNone.GetType()))
+ {
+ ConvertEAPStringToIds(buffer->iEncapsulatingString,
+ buffer->iEncapsulatingExpandedEapId);
+ }
+ iEAPBuffer.AppendL(buffer);
+
+ CleanupStack::Pop(buffer->iEAPSettings);
+ CleanupStack::Pop(buffer);
+ }
+
+ // Set the mapping luid to be the index to the iEAPBuffer
+ TBuf8<2> luid;
+ luid.Num(iEAPBuffer.Count() - 1);
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::AddNodeObjectL - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &luid);
+ iCallBack->SetMappingL(aURI, luid);
+
+ }
+ else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*"))
+ != KErrNotFound && NumOfUriSegs(aURI) == 10)
+ {
+ TPtrC8 ptr = NSmlDmURI::ParentURI(aURI);
+ TPtrC8 ptr2 = NSmlDmURI::ParentURI(ptr);
+
+ HBufC8* eapLuidBuf = iCallBack->GetLuidAllocL(ptr2);
+
+ TInt index = GetIdFromLuid(*eapLuidBuf);
+
+ delete eapLuidBuf;
+
+ EapCertificateEntry *entry = new (ELeave) EapCertificateEntry;
+ iEAPBuffer[index]->iEAPSettings->iCertificates.Append(entry);
+ iEAPBuffer[index]->iEAPSettings->iCertificatesPresent = ETrue;
+ iEAPBuffer[index]->iStatusRefArray.AppendL(aStatusRef);
+
+ TBuf8<2> luid;
+ luid.Num(iEAPBuffer[index]->iEAPSettings->iCertificates.Count() - 1);
+
+ DBG_ARGS8(
+ _S8(
+ "WLanAdapter::AddNodeObjectL - mapping uri: <%S> to luid: <%S>"),
+ &aURI, &luid);
+ iCallBack->SetMappingL(aURI, luid);
+ }
+ _DBG_FILE("CNSmlWLanAdapter::AddNodeObjectL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::ExecuteCommandL
+// not supported
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::ExecuteCommandL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, const TDesC8& /*aArgument*/,
+ const TDesC8& /*aType*/, TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::ExecuteCommandL(): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlWLanAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::ExecuteCommandL ( .. RWriteStream ..)
+// not supported
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::ExecuteCommandL(const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/, RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/, TInt aStatusref)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::ExecuteCommandL(): begin");
+ iCallBack->SetStatusL(aStatusref, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlWLanAdapter::ExecuteCommandL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::CopyCommandL
+// not supported
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::CopyCommandL(const TDesC8& /*aTargetURI*/,
+ const TDesC8& /*aTargetLUID*/, const TDesC8& /* aSourceURI*/,
+ const TDesC8& /*aSourceLUID*/, const TDesC8& /*aType*/,
+ TInt aStatusRef)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::CopyCommandL(): begin");
+ iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);
+ _DBG_FILE("CNSmlWLanAdapter::CopyCommandL(): end");
+ }
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::StartAtomicL
+// not supported
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::StartAtomicL()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::StartAtomicL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::StartAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::CommitAtomicL
+// not supported
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::CommitAtomicL()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::CommitAtomicL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::CommitAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::RollbackAtomicL
+// returns EError
+//------------------------------------------------------------------------------
+void CNSmlWLanAdapter::RollbackAtomicL()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::RollbackAtomicL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::RollbackAtomicL(): end");
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::StreamingSupport
+// returns EFalse
+//------------------------------------------------------------------------------
+
+TBool CNSmlWLanAdapter::StreamingSupport(TInt& /*aItemSize*/)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::StreamingSupport(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::StreamingSupport(): end");
+ return EFalse;
+ }
+
+//------------------------------------------------------------------------------
+// CNSmlWLanAdapter::StreamCommittedL
+// not used in this adapter
+//------------------------------------------------------------------------------
+
+void CNSmlWLanAdapter::StreamCommittedL()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::StreamCommittedL(): begin");
+ _DBG_FILE("CNSmlWLanAdapter::StreamCommittedL(): end");
+ }
+
+//-----------------------------------------------------------------------------
+// CNSmlWLanAdapter* CNSmlWLanAdapter::CompleteOutstandingCmdsL( )
+//-----------------------------------------------------------------------------
+void CNSmlWLanAdapter::CompleteOutstandingCmdsL()
+ {
+ _DBG_FILE("CNSmlWLanAdapter::CompleteOutStandingCmdsL(): begin");
+
+ ExecuteBufferL(ETrue);
+
+ _DBG_FILE("CNSmlWLanAdapter::CompleteOutStandingCmdsL(): end");
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TPtrC8 CNSmlWLanAdapter::GetLastUriSeg(const TDesC8& aURI)
+// Returns only the last uri segemnt
+// ------------------------------------------------------------------------------------------------
+TPtrC8 CNSmlWLanAdapter::GetLastUriSeg(const TDesC8& aURI)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::GetLastUriSeg(): begin");
+
+ TInt i;
+ for (i = aURI.Length() - 1; i >= 0; i--)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+
+ if (i == 0)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::GetLastUriSeg(): end");
+ return aURI;
+ }
+ else
+ {
+ _DBG_FILE("CNSmlWLanAdapter::GetLastUriSeg(): end");
+ return aURI.Mid(i + 1);
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TPtrC16 CNSmlWLanAdapter::RemoveLastURISeg(const TDesC8& aURI)
+// returns parent uri, i.e. removes last uri segment
+// ------------------------------------------------------------------------------------------------
+TPtrC8 CNSmlWLanAdapter::RemoveLastUriSeg(const TDesC8& aURI)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::RemoveLastUriSeg(): begin");
+
+ TInt i;
+ for (i = aURI.Length() - 1; i >= 0; i--)
+ {
+ if (aURI[i] == '/')
+ {
+ break;
+ }
+ }
+
+ _DBG_FILE("CNSmlWLanAdapter::RemoveLastUriSeg(): end");
+ return aURI.Left(i);
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::DesToInt( const TDesC8& aLuid )
+// Returns aLuid as integer value
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::DesToInt(const TDesC8& aLuid)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::DesToInt(): begin");
+
+ TLex8 lex(aLuid);
+ TInt value = 0;
+ lex.Val(value);
+
+ DBG_ARGS8(_S8("WLanAdapter::DesToInt() - Des: <%S> Int: <%D>"), &aLuid,
+ value);
+ _DBG_FILE("CNSmlWLanAdapter::DesToInt(): end");
+ return value;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// HBufC* CNSmlWLanAdapter::IntToDesLC(const TInt aLuid)
+// ------------------------------------------------------------------------------------------------
+HBufC* CNSmlWLanAdapter::IntToDesLC(const TInt aLuid)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::IntToDesLC(): begin");
+
+ HBufC* buf = HBufC::NewLC(10);
+ TPtr ptrBuf = buf->Des();
+ ptrBuf.Num(aLuid);
+
+ _DBG_FILE("CNSmlWLanAdapter::IntToDesLC(): end");
+ return buf;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// HBufC8* CNSmlWLanAdapter::IntToDes8LC(const TInt aLuid)
+// ------------------------------------------------------------------------------------------------
+HBufC8* CNSmlWLanAdapter::IntToDes8LC(const TInt aLuid)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::IntToDes8LC(): begin");
+
+ HBufC8* buf = HBufC8::NewLC(10);
+ TPtr8 ptrBuf = buf->Des();
+ ptrBuf.Num(aLuid);
+
+ _DBG_FILE("CNSmlWLanAdapter::IntToDes8LC(): end");
+ return buf;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::NumOfUriSegs( const TDesC8& aUri )
+// Return count of URI segments of aUri
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::NumOfUriSegs(const TDesC8& aUri)
+ {
+ _DBG_FILE("CNSmlWLanAdapter::NumOfUriSegs(): begin");
+
+ TInt count = 1;
+ for (TInt i = 0; i < aUri.Length(); i++)
+ {
+ if (aUri[i] == '/')
+ count++;
+ }
+
+ _DBG_FILE("CNSmlWLanAdapter::NumOfUriSegs(): end");
+ return count;
+ }
+
+// -------------------------------------------------------------------------------------
+// CNSmlWLanAdapter::FillNodeInfoL()
+// Fills the node info in ddf structure
+// -------------------------------------------------------------------------------------
+void CNSmlWLanAdapter::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);
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetEAPIdFromUri( const TDesC8& aUri )
+// Return WLan ID number from URI
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetEAPIdFromUri(const TDesC8& aUri)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::GetEAPIdFromUri - <%S>"), &aUri);
+
+ if (aUri.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*")) == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ TInt begin = aUri.Find(_L8("/EAPId")) + 6;
+ if (begin == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ TInt eapId = DesToInt(aUri.Mid(begin, 3));
+
+ return eapId;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetEncapsEAPIdFromUri( const TDesC8& aUri )
+// Return WLan ID number from URI
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetEncapsEAPIdFromUri(const TDesC8& aUri)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::GetEncapsEAPIdFromUri - <%S>"), &aUri);
+
+ if (aUri.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/EAPId*-*")) == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ TInt begin = aUri.Find(_L8("/EAPId")) + 9;
+ if (aUri[begin] != '-')
+ {
+ return KErrNotFound;
+ }
+ begin++;
+ TInt end = -1;
+ TInt count;
+
+ for (count = 0; count + begin < aUri.Length(); count++)
+ {
+ if (aUri[begin + count] == '/')
+ {
+ end = begin + count;
+ break;
+ }
+ else if (aUri.Length() == begin + count + 1)
+ {
+ count++;
+ end = begin + count;
+ break;
+ }
+ }
+
+ if (end > 0)
+ {
+ TInt eapId = DesToInt(aUri.Mid(begin, count));
+ return eapId;
+ }
+ return KErrNotFound;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetEAPIdFromUriL( const TDesC8& aUri )
+// Return WLan ID number from URI
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetServiceIdFromUriL(const TDesC8& aURI)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::GetServiceIdFromUriL - <%S>"), &aURI);
+
+ if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP*")) == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ TInt end = aURI.Find(_L8("/EAP")) + 4;
+
+ if (end > 0)
+ {
+
+ HBufC8* luidBuf = iCallBack->GetLuidAllocL(aURI.Left(end));
+
+ TInt serviceId = GetIdFromLuid(*luidBuf);
+
+ delete luidBuf;
+
+ return serviceId;
+ }
+ return KErrNotFound;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetSecSSIDFromUriL( const TDesC8& aUri )
+// Return WLan ID number from URI
+// ------------------------------------------------------------------------------------------------
+TUint32 CNSmlWLanAdapter::GetSecSSIDFromUriL(const TDesC8& aUri)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::GetSecSSIDFromUriL - <%S>"), &aUri);
+
+ if (aUri.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*"))
+ == KErrNotFound)
+ {
+ User::Leave(KErrNotFound);
+ }
+ _LIT8(KSSIDString, "/SecondarySSID/SecSSID");
+ TInt begin = aUri.Find(KSSIDString) + KSSIDString().Length();
+ TInt end = -1;
+ TInt count;
+
+ for (count = 0; count + begin < aUri.Length(); count++)
+ {
+ if (aUri[begin + count] == '/')
+ {
+ end = begin + count;
+ break;
+ }
+ else if (aUri.Length() == begin + count + 1)
+ {
+ count++;
+ end = begin + count;
+ break;
+ }
+ }
+
+ if (end > 0)
+ {
+ TLex8 lex(aUri.Mid(begin, count));
+ TUint32 value = 0;
+ lex.Val(value, EDecimal);
+ return value;
+ }
+ else
+ {
+ User::Leave(KErrNotFound);
+ }
+ return 0;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetEAPIdFromUri( const TDesC8& aUri )
+// Return WLan ID number from URI
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetCertificateIdFromUri(const TDesC8& aUri)
+ {
+ DBG_ARGS8(_S8("WLanAdapter::GetCertificateIdFromUri - <%S>"), &aUri);
+
+ if (aUri.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/Certificate/*"))
+ == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+ _LIT8(KCertString, "/Certificate/CertId");
+
+ TInt begin = aUri.Find(KCertString);
+ if (begin == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ begin += KCertString().Length();
+
+ TInt end = -1;
+ TInt count;
+
+ for (count = 0; count + begin < aUri.Length(); count++)
+ {
+ if (aUri[begin + count] == '/')
+ {
+ end = begin + count;
+ break;
+ }
+ else if (aUri.Length() == begin + count + 1)
+ {
+ count++;
+ end = begin + count;
+ break;
+ }
+ }
+
+ if (end > 0)
+ {
+ TInt certId = DesToInt(aUri.Mid(begin, count));
+ return certId;
+ }
+ return KErrNotFound;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetWepKeyIdFromUri( const TDesC8& aUri )
+// Returns WepKey ID number from URI
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetWepKeyIdFromUri(const TDesC8& aUri)
+ {
+ if (aUri.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*")) == KErrNotFound)
+ {
+ return KErrNotFound;
+ }
+
+ TInt begin = aUri.Find(_L8("WEPKey/WKId")) + 11;
+ TInt end = -1;
+ TInt count;
+
+ for (count = 0; count < aUri.Length() - 11; count++)
+ {
+ if (aUri[begin + count] == '/')
+ {
+ end = begin + count;
+ break;
+ }
+
+ else if (aUri.Length() == begin + count + 1)
+ {
+ count++;
+ end = begin + count;
+ break;
+ }
+ }
+
+ if (end > 0)
+ {
+ TInt wlanId = DesToInt(aUri.Mid(begin, count));
+ return wlanId;
+ }
+ return KErrNotFound;
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetWepKeyIdFromLuid( const TDesC8& aLuid )
+// Return id number of wepkey
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetWepKeyIdFromLuid(const TDesC8& aLuid)
+ {
+ TLex8 iLex(aLuid);
+
+ TInt luid;
+ if (iLex.Val(luid) == KErrNone)
+ {
+ if (luid > 1000)
+ {
+ return luid / 1000;
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// TInt CNSmlWLanAdapter::GetIdFromLuid( const TDesC& aLuid )
+// Return luid of wlan node
+// ------------------------------------------------------------------------------------------------
+TInt CNSmlWLanAdapter::GetIdFromLuid(const TDesC8& aLuid)
+ {
+ TLex8 iLex(aLuid);
+
+ TInt luid;
+ if (iLex.Val(luid) == KErrNone)
+ {
+ if (luid < 1000)
+ {
+ return luid;
+ }
+ else
+ {
+ TInt tmp = luid / 1000 * 1000; //First number of luid > 1000
+ return luid - tmp;
+ }
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+ }
+
+// ------------------------------------------------------------------------------------------------
+// void CNSmlWLanAdapter::ExecuteBufferL( TBool aFinal )
+// Executes buffered commands from iBuffer
+// ------------------------------------------------------------------------------------------------
+void CNSmlWLanAdapter::ExecuteBufferL(TBool aFinal)
+ {
+ for (TInt index = 0; index < iBuffer->Count(); index++)
+ {
+ DBG_ARGS8(_S8(
+ "WLanAdapter::ExecuteBuffer(): Buf count: <%D> index: <%D>"),
+ iBuffer->Count(), index);
+
+ if (iBuffer->At(index).iExecuted)
+ {
+ continue;
+ }
+ TInt err = 0;
+
+ TInt luid = iBuffer->At(index).iLuid;
+ TInt wepKeyId = iBuffer->At(index).iWepKeyId;
+ if (!wepKeyId && !aFinal)
+ {
+ continue;
+ }
+
+ if (wepKeyId > 4 || !wepKeyId && aFinal)
+ {
+ if (iBuffer->At(index).iDataStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iDataStatusRef,
+ CSmlDmAdapter::EError);
+ if (iBuffer->At(index).iNodeStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iNodeStatusRef,
+ CSmlDmAdapter::EError);
+ if (iBuffer->At(index).iLengthStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iLengthStatusRef,
+ CSmlDmAdapter::EError);
+
+ iBuffer->At(index).iIdStatusRef = 0;
+ iBuffer->At(index).iNodeStatusRef = 0;
+ iBuffer->At(index).iDataStatusRef = 0;
+ iBuffer->At(index).iLengthStatusRef = 0;
+ iBuffer->At(index).iExecuted = ETrue;
+
+ continue;
+ }
+
+ if (iBuffer->At(index).iDataSet && iBuffer->At(index).iWepKeyId > 0)
+ {
+ iWlanSettings->GetWlanSettings(luid, *iSettings);
+
+ switch (wepKeyId)
+ {
+ case 1:
+ iSettings->WepKey1 = iBuffer->At(index).iData->Des();
+ break;
+ case 2:
+ iSettings->WepKey2 = iBuffer->At(index).iData->Des();
+ break;
+ case 3:
+ iSettings->WepKey3 = iBuffer->At(index).iData->Des();
+ break;
+ case 4:
+ iSettings->WepKey4 = iBuffer->At(index).iData->Des();
+ break;
+ default:
+ continue;
+ }
+
+ err = iWlanSettings->WriteWlanSettings(*iSettings);
+ if (err == KErrNone)
+ {
+ iCallBack->SetStatusL(iBuffer->At(index).iDataStatusRef,
+ CSmlDmAdapter::EOk);
+ }
+ else
+ {
+ iCallBack->SetStatusL(iBuffer->At(index).iDataStatusRef,
+ CSmlDmAdapter::EError);
+ }
+
+ iBuffer->At(index).iDataStatusRef = 0;
+ }
+
+ TBuf8<5> addLUID;
+ addLUID.AppendNum(wepKeyId);
+ addLUID.AppendNumFixedWidth(luid, EDecimal, 3);
+
+ iCallBack->SetMappingL(iBuffer->At(index).iUri->Des(), addLUID);
+ if (iBuffer->At(index).iIdStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iIdStatusRef,
+ CSmlDmAdapter::EOk);
+ if (iBuffer->At(index).iNodeStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iNodeStatusRef,
+ CSmlDmAdapter::EOk);
+ if (iBuffer->At(index).iLengthStatusRef)
+ iCallBack->SetStatusL(iBuffer->At(index).iLengthStatusRef,
+ CSmlDmAdapter::EOk);
+
+ iBuffer->At(index).iIdStatusRef = 0;
+ iBuffer->At(index).iNodeStatusRef = 0;
+ iBuffer->At(index).iLengthStatusRef = 0;
+ iBuffer->At(index).iExecuted = ETrue;
+ }
+
+ //Clean executed command from buffer
+ for (TInt i = 0; i < iBuffer->Count(); i++)
+ {
+ if (iBuffer->At(i).iExecuted)
+ {
+ if (iBuffer->At(i).iUri)
+ {
+ delete iBuffer->At(i).iUri;
+ iBuffer->At(i).iUri = 0;
+ }
+ if (iBuffer->At(i).iData)
+ {
+ delete iBuffer->At(i).iData;
+ iBuffer->At(i).iData = 0;
+ }
+ iBuffer->Delete(i);
+ iBuffer->Compress();
+ }
+ }
+ // Secondary SSID Buffer
+ for (TInt index = 0; index < iSecondaryBuffer.Count(); index++)
+ {
+ DBG_ARGS8(_S8(
+ "WLanAdapter::ExecuteBuffer(): Buf count: <%D> index: <%D>"),
+ iBuffer->Count(), index);
+
+ if (iSecondaryBuffer[index]->iExecuted)
+ {
+ continue;
+ }
+
+ TSecondarySSID ssid;
+ ssid.ScannedId = iSecondaryBuffer[index]->ScannedId;
+ ssid.UsedId = iSecondaryBuffer[index]->UsedId;
+
+ DBG_ARGS8(
+ _S8(
+ "CWlanadaptes::Execute Buffer - WLAN_SEC_SSID_SCANNED_SSID uri: <%S> ad WLAN_SEC_SSID_USED_SSID : <%S>"),
+ &iSecondaryBuffer[index]->ScannedId,
+ &iSecondaryBuffer[index]->UsedId);
+
+ TInt retval = iWlanSettings->WriteSecondarySSIDL(
+ iSecondaryBuffer[index]->wlanLuid, ssid, ETrue);
+ iSecondaryBuffer[index]->iExecuted = ETrue;
+
+ }
+ TBuf<KMaxLengthOfEapList> eapList;
+ eapList.Copy(KEapAll);
+ // EAP settings
+ for (TInt i = 0; i < iEAPBuffer.Count(); i++)
+ {
+
+ // Save EAP list
+ if (iEAPBuffer[i]->iEapTypeString.Length() > 0
+ && iEAPBuffer[i]->iEncapsulatingString.Length() == 0) // AND method is not encapsulated
+ {
+
+ TBuf8<3> buf;
+ _LIT8(KFormat, "%d");
+ // pick the last byte from the array
+ buf.Format(KFormat,
+ iEAPBuffer[i]->iEapTypeString[KExpandedEapIdLength - 1]);
+ // search for the correct offset for the eap type from the KEapAll literal
+ TInt index = KEapAll().Find(buf);
+
+ const TUint8 offset = 2; //length = f "-0" string
+ // Add '+' to the correct offset, so that the eap is repsesented activated in the list
+ if (index >= offset)
+ {
+ eapList[index - offset] = KEapPlus;
+ }
+
+ }
+
+ // Check if this method has encapsulated methods
+ for (TInt j = 0; j < iEAPBuffer.Count(); j++)
+ {
+ if (iEAPBuffer[i]->iEAPSettings->iEAPExpandedType
+ == iEAPBuffer[j]->iEncapsulatingExpandedEapId)
+ {
+ // j is encapsulated inside i
+ iEAPBuffer[i]->iEAPSettings->iEnabledEncapsulatedEAPExpandedTypes.Append(
+ iEAPBuffer[j]->iEAPSettings->iEAPExpandedType);
+ iEAPBuffer[i]->iEAPSettings->iEnabledEncapsulatedEAPExpandedTypesPresent
+ = ETrue;
+ }
+ }
+
+ TRAPD(err, iWlanSettings->GetEAPInterfaceL(
+ iEAPBuffer[i]->iWLANServiceId,
+ iEAPBuffer[i]->iEncapsulatingExpandedEapId,
+ iEAPBuffer[i]->iEAPSettings->iEAPExpandedType));
+ if (err == KErrNone)
+ {
+ err = iWlanSettings->WriteEAPSettings(
+ *iEAPBuffer[i]->iEAPSettings);
+ }
+
+ MSmlDmAdapter::TError status;
+ switch (err)
+ {
+ case KErrNotFound:
+ {
+ status = CSmlDmAdapter::ENotFound;
+ break;
+ }
+ case KErrNone:
+ {
+ status = CSmlDmAdapter::EOk;
+ break;
+ }
+ default:
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ }
+
+ for (TInt j = 0; j < iEAPBuffer[i]->iStatusRefArray.Count(); j++)
+ {
+ iCallBack->SetStatusL(iEAPBuffer[i]->iStatusRefArray[j], status);
+ }
+ }
+
+ // Expanded EAP types in use. Write the eap list to the new columns.
+
+ // generate appropriate entries in the new enabled and disabled list,
+ // overwriting those values
+
+ // count the + and - signs to determine the size of enabled and
+ // disabled descriptors
+
+ TLex lex(eapList);
+ TInt numPlus = 0;
+ TInt numMinus = 0;
+ TChar ch;
+ while (!lex.Eos())
+ {
+ ch = lex.Get();
+ if (ch == '+')
+ ++numPlus;
+ else if (ch == '-')
+ ++numMinus;
+ }
+ // load general EAP settings If
+ CEapGeneralSettings* genSettings;
+ genSettings = CEapGeneralSettings::NewL(ELan, iSettings->ServiceID);
+ CleanupStack::PushL(genSettings);
+
+ // get lists of enabled/disabled EAPs for the IAP
+
+ RArray<TEapExpandedType> enabledEapMethods;
+ RArray<TEapExpandedType> disabledEapMethods;
+
+ enabledEapMethods.Reset();
+ disabledEapMethods.Reset();
+
+ lex.Assign(eapList);
+
+ while (!lex.Eos())
+ {
+ // beginning of implementation UID
+ TInt16 implUid = 0;
+
+ if (lex.Val(implUid) != KErrNone || !implUid)
+ {
+ break;
+ }
+
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+
+ if (implUid > 0)
+ {
+ TBuf8<KExpandedEapIdLength> tempbuf;
+ if (Abs(implUid) == KPlainMsChapV2ImplUid)
+ {
+ tempbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ tempbuf.Append(KPadding);
+ }
+ tempbuf.Append(Abs(implUid));
+ TEapExpandedType expandedTypebuf(tempbuf);
+ enabledEapMethods.Append(expandedTypebuf);
+ }
+
+ // swallow the delimiter (',')
+ lex.Get();
+ }
+
+ if (numPlus != NULL)
+ {
+ genSettings->SetEapMethods(enabledEapMethods, disabledEapMethods);
+ }
+
+ CleanupStack::PopAndDestroy(genSettings);
+
+ for (TInt i = 0; i < iEAPBuffer.Count(); i++)
+ {
+ iEAPBuffer[i]->iStatusRefArray.Close();
+ iEAPBuffer[i]->iEAPSettings->iEnabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPBuffer[i]->iEAPSettings->iDisabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPBuffer[i]->iEAPSettings->iCipherSuites.Close();
+ delete iEAPBuffer[i]->iEAPSettings;
+ iEAPBuffer[i]->iEAPSettings = NULL;
+ }
+ iEAPBuffer.ResetAndDestroy();
+ }
+
+//=============================================
+// CNSmlWLanAdapter::ConvertTo8LC()
+// Converts string value to 8-bit
+//
+//=============================================
+TDesC8& CNSmlWLanAdapter::ConvertTo8LC(const TDesC& aSource)
+ {
+ HBufC8* buf = HBufC8::NewLC(aSource.Length() * 2);
+ TPtr8 bufPtr = buf->Des();
+ CnvUtfConverter::ConvertFromUnicodeToUtf8(bufPtr, aSource);
+
+ return *buf;
+ }
+
+//=============================================
+// CNSmlWLanAdapter::ConvertTo16LC()
+// Converts string value to 16-bit
+//
+//=============================================
+TDesC16& CNSmlWLanAdapter::ConvertTo16LC(const TDesC8& aSource)
+ {
+ HBufC16* buf16 = HBufC16::NewLC(aSource.Length());
+ TPtr bufPtr16 = buf16->Des();
+
+ CnvUtfConverter::ConvertToUnicodeFromUtf8(bufPtr16, aSource);
+
+ return *buf16;
+ }
+
+void CNSmlWLanAdapter::ResetEAPStructL()
+ {
+ DeleteEAPStructL();
+ iEAPSettings = new (ELeave) EAPSettings;
+ }
+
+void CNSmlWLanAdapter::DeleteEAPStructL()
+ {
+ if (iEAPSettings != NULL)
+ {
+ if (iEAPSettings->iCertificatesPresent)
+ {
+ iEAPSettings->iCertificates.Reset();
+ }
+ iEAPSettings->iEnabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPSettings->iDisabledEncapsulatedEAPExpandedTypes.Close();
+ iEAPSettings->iCipherSuites.Close();
+
+ delete iEAPSettings;
+ iEAPSettings = NULL;
+ }
+ }
+
+void CNSmlWLanAdapter::DesToBufferL(CBufBase& aTo, const TDesC& aFrom)
+ {
+ aTo.InsertL(0, ConvertTo8LC(aFrom));
+ CleanupStack::PopAndDestroy(); // ConvertTo8LC
+ }
+
+void CNSmlWLanAdapter::FillCipherSuiteBufferL(CBufBase& aBuffer)
+ {
+ if (iEAPSettings == NULL || !iEAPSettings->iCipherSuitesPresent)
+ {
+ return;
+ }
+ // 0 5 10 15 20 25 30 35
+ _LIT8(KPlus, "+");
+ aBuffer.InsertL(0, KSuitesDefault);
+ TInt count = iEAPSettings->iCipherSuites.Count();
+ for (TInt i = count - 1; i >= 0; --i)
+ {
+ switch (iEAPSettings->iCipherSuites[i])
+ {
+ case RSA_3DES_SHA:
+ {
+ aBuffer.Write(0, KPlus);
+ break;
+ }
+ case DHE_RSA_3DES_SHA:
+ {
+ aBuffer.Write(5, KPlus);
+ break;
+ }
+ case DHE_DSS_3DES_SHA:
+ {
+ aBuffer.Write(10, KPlus);
+ break;
+ }
+ case RSA_AES_SHA:
+ {
+ aBuffer.Write(15, KPlus);
+ break;
+ }
+ case DHE_RSA_AES_SHA:
+ {
+ aBuffer.Write(20, KPlus);
+ break;
+ }
+ case DHE_DSS_AES_SHA:
+ {
+ aBuffer.Write(25, KPlus);
+ break;
+ }
+ case RSA_RC4_MD5:
+ {
+ aBuffer.Write(30, KPlus);
+ break;
+ }
+ case RSA_RC4_SHA:
+ {
+ aBuffer.Write(35, KPlus);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+
+ }
+ }
+
+ }
+
+void CNSmlWLanAdapter::FillCipherSuitesL(const TDesC8& aObject,
+ const TInt aLuid)
+ {
+ if (iEAPBuffer[aLuid] == NULL)
+ {
+ return;
+ }
+ iEAPBuffer[aLuid]->iEAPSettings->iCipherSuites.Reset();
+ iEAPBuffer[aLuid]->iEAPSettings->iCipherSuitesPresent = EFalse; // init to EFalse
+
+ TChar plus('+');
+
+ TInt length = aObject.Length();
+ for (TInt i = 0; i + 3 < length; i += 5)
+ {
+ if (aObject[i] == plus)
+ {
+ TLex8 lex(aObject.Mid(i + 1, 3));
+ TUint suite;
+ lex.Val(suite);
+ iEAPBuffer[aLuid]->iEAPSettings->iCipherSuites.Append(suite);
+ iEAPBuffer[aLuid]->iEAPSettings->iCipherSuitesPresent = ETrue;
+ }
+ }
+ }
+
+void CNSmlWLanAdapter::ConvertEAPStringToIds(TDes8& aEAPString,
+ TEapExpandedType& aId)
+ {
+ if (aId.Compare(*EapExpandedTypeSim.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapSimTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeAka.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapAkaTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeTtls.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapTlsTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypePeap.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapPeapTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeTtls.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapTtlsTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeLeap.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapLeapTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeMsChapv2.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapMschapv2TypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedPlainMsChapv2.GetType()) == 0)
+ {
+ aEAPString.Copy(KMschapv2TypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeGtc.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapGtcTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeFast.GetType()) == 0)
+ {
+ aEAPString.Copy(KEapFastTypeId, KExpandedEAPIdLength);
+ }
+ else if (aId.Compare(*EapExpandedTypeTtlsPap.GetType()) == 0)
+ {
+ aEAPString.Copy(KTtlspapTypeId, KExpandedEAPIdLength);
+ }
+ else
+ {
+ aEAPString.Copy(KEapNoneId, KExpandedEAPIdLength);
+ }
+
+ }
+
+void CNSmlWLanAdapter::GetExpandedType(const TInt aEapType,
+ const TInt aTunnelingType, TEapExpandedType& aExpanedId,
+ TEapExpandedType& aExpanedEncapsId)
+ {
+
+ // append it to the appropriate list ('+' enabled, '-' disabled)
+ _LIT8(KPadding, "\xFE\0\0\0\0\0\0");
+ _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");
+ const TInt KPlainMsChapV2ImplUid = 99;
+
+ TBuf8<KExpandedEapIdLength> cmpbuf;
+ if (aEapType == KPlainMsChapV2ImplUid)
+ {
+ cmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ cmpbuf.Append(KPadding);
+ }
+ cmpbuf.Append(aEapType);
+ aExpanedId = cmpbuf;
+
+ TBuf8<KExpandedEapIdLength> encapscmpbuf;
+ if (aTunnelingType == KPlainMsChapV2ImplUid)
+ {
+ encapscmpbuf.Append(KMsChapV2Padding);
+ }
+ else
+ {
+ encapscmpbuf.Append(KPadding);
+ }
+ encapscmpbuf.Append(aTunnelingType);
+ aExpanedEncapsId = encapscmpbuf;
+
+ }
+
+// end of file