1 /*

     2  * Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies). 

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:   Wlan Adapter

    15  *

    16  */

    17 

    18 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    19 #include <commsdat_partner.h>

    20 #endif

    21 #include "NSmlWLanAdapter.h"

    22 #include "NSmlWlanSettings.h"

    23 #include "nsmldebug.h"

    24 #include <commdb.h>

    25 #include <utf.h>

    26 #include <cdbstore.h>

    27 #include <cdbcols.h>

    28 #include <EapType.h>

    29 #include <nsmldmuri.h>

    30 #include <EapExpandedType.h>

    31 #include <EapGeneralSettings.h>

    32 

    33 #ifndef __WINS__

    34 // This lowers the unnecessary compiler warning (armv5) to remark.

    35 // "Warning:  #174-D: expression has no effect..." is caused by 

    36 // DBG_ARGS8 macro in no-debug builds.

    37 #pragma diag_remark 174

    38 #endif

    39 

    40 const TInt KMaxBuf = 255;

    41 //-----------------------------------------------------------------------------

    42 // CNSmlWLanAdapter* CNSmlWLanAdapter::NewL( )

    43 //-----------------------------------------------------------------------------

    44 CNSmlWLanAdapter* CNSmlWLanAdapter::NewL(MSmlDmCallback* aDmCallback,

    45         CCommsDatabase& aDatabase)

    46     {

    47     _DBG_FILE("CNSmlWLanAdapter::NewL(): begin");

    48 

    49     CNSmlWLanAdapter* self = NewLC(aDmCallback, aDatabase);

    50     CleanupStack::Pop(self);

    51 

    52     _DBG_FILE("CNSmlWLanAdapter::NewL(): end");

    53     return self;

    54     }

    55 

    56 //-----------------------------------------------------------------------------

    57 // CNSmlWLanAdapter* CNSmlWLanAdapter::NewLC( )

    58 //-----------------------------------------------------------------------------

    59 CNSmlWLanAdapter* CNSmlWLanAdapter::NewLC(MSmlDmCallback* aDmCallback,

    60         CCommsDatabase& aDatabase)

    61     {

    62     _DBG_FILE("CNSmlWLanAdapter::NewLC(): begin");

    63 

    64     CNSmlWLanAdapter* self = new (ELeave) CNSmlWLanAdapter(aDmCallback,

    65             aDatabase);

    66     CleanupStack::PushL(self);

    67 

    68     self->iCallBack = aDmCallback;

    69     self->ConstructL(aDatabase);

    70 

    71     _DBG_FILE("CNSmlWLanAdapter::NewLC(): end");

    72     return self;

    73     }

    74 

    75 //-----------------------------------------------------------------------------

    76 // void CNSmlWLanAdapter::ConstructL( )

    77 // Second phase constructor

    78 //-----------------------------------------------------------------------------

    79 void CNSmlWLanAdapter::ConstructL(CCommsDatabase& aDatabase)

    80     {

    81     _DBG_FILE("CNSmlWLanAdapter::ConstructL(): begin");

    82 

    83     iWlanSettings = CWlanSettings::NewL(aDatabase);

    84     iBuffer = new (ELeave) CArrayFixFlat<TNSmlWepKeyBufferElement> (

    85             KNSmlWepKeyGranularity);

    86     iSettings = new (ELeave) TWlanSettings;

    87     iEAPSettings = new (ELeave) EAPSettings;

    88 

    89     _DBG_FILE("CNSmlWLanAdapter::ConstructL(): end");

    90     }

    91 

    92 //-----------------------------------------------------------------------------

    93 // CNSmlWLanAdapter::CNSmlWLanAdapter( )

    94 // Constructor

    95 //-----------------------------------------------------------------------------

    96 CNSmlWLanAdapter::CNSmlWLanAdapter(TAny* aEcomArguments,

    97         CCommsDatabase& aDatabase) :

    98     CSmlDmAdapter(aEcomArguments), iDatabase(aDatabase)

    99     {

   100     _DBG_FILE("CNSmlWLanAdapter::CNSmlWLanAdapter(): begin");

   101     _DBG_FILE("CNSmlWLanAdapter::CNSmlWLanAdapter(): end");

   102     }

   103 

   104 //-----------------------------------------------------------------------------

   105 // CNSmlWLanAdapter::~CNSmlWLanAdapter( )

   106 // Destructor

   107 //-----------------------------------------------------------------------------

   108 CNSmlWLanAdapter::~CNSmlWLanAdapter()

   109     {

   110     _DBG_FILE("CNSmlWLanAdapter::~CNSmlWLanAdapter(): begin");

   111 

   112     if (iBuffer)

   113         {

   114 

   115         for (TInt index = 0; index < iBuffer->Count(); index++)

   116             {

   117             delete iBuffer->At(index).iUri;

   118             delete iBuffer->At(index).iData;

   119 

   120             iBuffer->Delete(index);

   121             }

   122 

   123         iBuffer->Reset();

   124         delete iBuffer;

   125 

   126         }

   127     delete iWlanSettings;

   128     delete iSettings;

   129 

   130     TRAP_IGNORE(DeleteEAPStructL());

   131 

   132     for (TInt i = 0; i < iEAPBuffer.Count(); i++)

   133         {

   134         iEAPBuffer[i]->iStatusRefArray.Close();

   135         iEAPBuffer[i]->iEAPSettings->iEnabledEncapsulatedEAPExpandedTypes.Close();

   136         iEAPBuffer[i]->iEAPSettings->iDisabledEncapsulatedEAPExpandedTypes.Close();

   137         iEAPBuffer[i]->iEAPSettings->iCipherSuites.Close();

   138         delete iEAPBuffer[i]->iEAPSettings;

   139         iEAPBuffer[i]->iEAPSettings = NULL;

   140         }

   141     iEAPBuffer.ResetAndDestroy();

   142 

   143     TInt count = iSecondaryBuffer.Count();

   144     for (TInt index = 0; index < count; index++)

   145         {

   146         delete iSecondaryBuffer[index];

   147         }

   148 

   149     iSecondaryBuffer.Reset();

   150 

   151     _DBG_FILE("CNSmlWLanAdapter::~CNSmlWLanAdapter(): end");

   152     }

   153 

   154 //-----------------------------------------------------------------------------

   155 // CNSmlWLanAdapter* CNSmlWLanAdapter::DDFVersionL( CBufBase& aDDFVersion )

   156 //-----------------------------------------------------------------------------

   157 void CNSmlWLanAdapter::DDFVersionL(CBufBase& aDDFVersion)

   158     {

   159     _DBG_FILE("CNSmlWLanAdapter::DDFVersionL(): begin");

   160 

   161     aDDFVersion.InsertL(0, KNSmlWLanAdapterDDFversion);

   162 

   163     _DBG_FILE("CNSmlWLanAdapter::DDFVersionL(): end");

   164     }

   165 

   166 //-----------------------------------------------------------------------------

   167 // CNSmlWLanAdapter* CNSmlWLanAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

   168 //-----------------------------------------------------------------------------

   169 void CNSmlWLanAdapter::DDFStructureL(MSmlDmDDFObject& aDDF)

   170     {

   171     _DBG_FILE("CNSmlWLanAdapter::DDFStructureL(): begin");

   172 

   173     TSmlDmAccessTypes *aclTypes = new (ELeave) TSmlDmAccessTypes();

   174     CleanupStack::PushL(aclTypes);

   175     //

   176     // Set Get as acceptable operations

   177     //

   178     aclTypes->SetGet();

   179     aclTypes->SetAdd(); // 041208 Added

   180     aclTypes->SetDelete();

   181     aclTypes->SetReplace();

   182 

   183     TSmlDmAccessTypes accessTypesAll;

   184     accessTypesAll.SetGet();

   185     accessTypesAll.SetDelete();

   186     accessTypesAll.SetAdd();

   187     accessTypesAll.SetReplace();

   188 

   189     TSmlDmAccessTypes accessTypesNoDelete;

   190     accessTypesNoDelete.SetGet();

   191     accessTypesNoDelete.SetAdd();

   192     accessTypesNoDelete.SetReplace();

   193 

   194     TSmlDmAccessTypes accessTypesGetAdd;

   195     accessTypesGetAdd.SetGet();

   196     accessTypesGetAdd.SetAdd();

   197 

   198     TSmlDmAccessTypes accessTypesGetAddDel;

   199     accessTypesGetAddDel.SetGet();

   200     accessTypesGetAddDel.SetAdd();

   201     accessTypesGetAddDel.SetDelete();

   202     //WLAN

   203     MSmlDmDDFObject& rootNode = aDDF.AddChildObjectL(KNSmlWLanNodeName);

   204     FillNodeInfoL(rootNode, accessTypesGetAdd, MSmlDmDDFObject::EZeroOrOne,

   205             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);

   206 

   207     //WLAN/<x>

   208     MSmlDmDDFObject& wlanNode = rootNode.AddChildObjectGroupL();

   209     FillNodeInfoL(wlanNode, accessTypesGetAddDel, MSmlDmDDFObject::EOne,

   210             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);

   211 

   212     //WLAN/<x>/SSID

   213     MSmlDmDDFObject& ssid = wlanNode.AddChildObjectL(KNSmlWLanSsid);

   214     FillNodeInfoL(ssid, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,

   215             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   216 

   217     //WLAN/<x>/UsedSSID

   218     MSmlDmDDFObject& usedSsid = wlanNode.AddChildObjectL(KNSmlWLanUsedSsid);

   219     FillNodeInfoL(usedSsid, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,

   220             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   221 

   222     //WLAN/<x>/SSIDHidden

   223     MSmlDmDDFObject& ssidHidden = wlanNode.AddChildObjectL(

   224             KNSmlWLanSsidHidden);

   225     FillNodeInfoL(ssidHidden, accessTypesNoDelete,

   226             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   227             MSmlDmDDFObject::EBool, KNSmlEmpty);

   228 

   229     //WLAN/<x>/NetworkMode

   230     MSmlDmDDFObject& networkMode = wlanNode.AddChildObjectL(

   231             KNSmlWLanNetworkMode);

   232     FillNodeInfoL(networkMode, accessTypesNoDelete,

   233             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   234             MSmlDmDDFObject::EChr, KNSmlEmpty);

   235 

   236     //WLAN/<x>/SecurityMode

   237     MSmlDmDDFObject& securityMode = wlanNode.AddChildObjectL(

   238             KNSmlWLanSecurityMode);

   239     FillNodeInfoL(securityMode, accessTypesNoDelete,

   240             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   241             MSmlDmDDFObject::EChr, KNSmlEmpty);

   242 

   243     //WLAN/<x>/UseWPAPSK

   244     MSmlDmDDFObject& useWPAPSK = wlanNode.AddChildObjectL(KNSmlWLanUseWPAPSK);

   245     FillNodeInfoL(useWPAPSK, accessTypesNoDelete,

   246             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   247             MSmlDmDDFObject::EBool, KNSmlEmpty);

   248 

   249     //WLAN/<x>/WPAPreSharedKey

   250     MSmlDmDDFObject& wpaPreSharedKey = wlanNode.AddChildObjectL(

   251             KNSmlWLanWpaPreSharedKey);

   252     FillNodeInfoL(wpaPreSharedKey, accessTypesNoDelete,

   253             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   254             MSmlDmDDFObject::EBin, KNSmlEmpty);

   255 

   256     //WLAN/<x>/WLANEAPList

   257     MSmlDmDDFObject& wlanEapList = wlanNode.AddChildObjectL(KNSmlWLanEapList);

   258     FillNodeInfoL(wlanEapList, accessTypesNoDelete,

   259             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   260             MSmlDmDDFObject::EChr, KNSmlEmpty);

   261 

   262     //WLAN/<x>/WEPKeyIndex

   263     MSmlDmDDFObject& wepKeyIndex =

   264             wlanNode.AddChildObjectL(KNSmlWLanWepIndex);

   265     FillNodeInfoL(wepKeyIndex, accessTypesNoDelete,

   266             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   267             MSmlDmDDFObject::EInt, KNSmlEmpty);

   268 

   269     //WLAN/<x>/WEPAuthMode

   270     MSmlDmDDFObject& wlanWepAuthMode = wlanNode.AddChildObjectL(

   271             KNSmlWLanAuthMode);

   272     FillNodeInfoL(wlanWepAuthMode, accessTypesNoDelete,

   273             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   274             MSmlDmDDFObject::EInt, KNSmlEmpty);

   275 

   276     //WLAN/<x>/WEPKey/

   277     MSmlDmDDFObject& wepKeyRoot = wlanNode.AddChildObjectL(KNSmlWLanWepKey);

   278     FillNodeInfoL(wepKeyRoot, accessTypesNoDelete,

   279             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   280             MSmlDmDDFObject::ENode, KNSmlEmpty);

   281 

   282     //WLAN/<x>/WEPKey/<x>

   283     MSmlDmDDFObject& wepKey = wepKeyRoot.AddChildObjectGroupL();

   284     FillNodeInfoL(wepKey, accessTypesGetAdd, MSmlDmDDFObject::EOneOrN,

   285             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);

   286 

   287     //WLAN/<x>/WEPKey/<x>/WEPKeyID

   288     MSmlDmDDFObject& wepKeyId = wepKey.AddChildObjectL(KNSmlWLanWepKeyId);

   289     FillNodeInfoL(wepKeyId, accessTypesNoDelete, MSmlDmDDFObject::EOne,

   290             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt, KNSmlEmpty);

   291 

   292     //WLAN/<x>/WEPKey/<x>/Data

   293     MSmlDmDDFObject& data = wepKey.AddChildObjectL(KNSmlWLanWepKeyData);

   294     FillNodeInfoL(data, accessTypesNoDelete, MSmlDmDDFObject::EOne,

   295             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EBin, KNSmlEmpty);

   296 

   297     //WLAN/<x>/SecondarySSID/

   298     MSmlDmDDFObject& secondarySSidRoot = wlanNode.AddChildObjectL(

   299             KNSmlWLanSecSsid);

   300     FillNodeInfoL(secondarySSidRoot, accessTypesGetAdd,

   301             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   302             MSmlDmDDFObject::ENode, KNSmlEmpty);

   303 

   304     //WLAN/<x>/SecondarySSID/<x>

   305     MSmlDmDDFObject& secondarySSid = secondarySSidRoot.AddChildObjectGroupL();

   306     FillNodeInfoL(secondarySSid, accessTypesGetAddDel,

   307             MSmlDmDDFObject::EOneOrN, MSmlDmDDFObject::EDynamic,

   308             MSmlDmDDFObject::ENode, KNSmlEmpty);

   309 

   310     //WLAN/<x>/SecondarySSID/<x>/SSID

   311     MSmlDmDDFObject& secSsidId = secondarySSid.AddChildObjectL(KNSmlWLanSsid);

   312     FillNodeInfoL(secSsidId, accessTypesNoDelete, MSmlDmDDFObject::EOne,

   313             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   314 

   315     //WLAN/<x>/SecondarySSID/<x>/UsedSSID

   316     MSmlDmDDFObject& secUsedSsidId = secondarySSid.AddChildObjectL(

   317             KNSmlWLanUsedSsid);

   318     FillNodeInfoL(secUsedSsidId, accessTypesNoDelete,

   319             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   320             MSmlDmDDFObject::EChr, KNSmlEmpty);

   321 

   322     //WLAN/<x>/EAP/

   323     MSmlDmDDFObject& eapRoot = wlanNode.AddChildObjectL(KNSmlWLanEap);

   324     FillNodeInfoL(eapRoot, accessTypesGetAdd, MSmlDmDDFObject::EZeroOrOne,

   325             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);

   326 

   327     //WLAN/<x>/EAP/<x>

   328     MSmlDmDDFObject& eap = eapRoot.AddChildObjectGroupL();

   329     FillNodeInfoL(eap, accessTypesGetAdd, MSmlDmDDFObject::EOneOrN,

   330             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode, KNSmlEmpty);

   331 

   332     //WLAN/<x>/EAP/<x>/EAPType

   333     MSmlDmDDFObject& eapType = eap.AddChildObjectL(KNSmlWLanEapType);

   334     FillNodeInfoL(eapType, accessTypesNoDelete, MSmlDmDDFObject::EOne,

   335             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   336 

   337     //WLAN/<x>/EAP/<x>/Username

   338     MSmlDmDDFObject& eapUsername = eap.AddChildObjectL(KNSmlWLanUsername);

   339     FillNodeInfoL(eapUsername, accessTypesNoDelete,

   340             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   341             MSmlDmDDFObject::EChr, KNSmlEmpty);

   342 

   343     //WLAN/<x>/EAP/<x>/Password

   344     MSmlDmDDFObject& eapPassword = eap.AddChildObjectL(KNSmlWLanPassword);

   345     FillNodeInfoL(eapPassword, accessTypesNoDelete,

   346             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   347             MSmlDmDDFObject::EChr, KNSmlEmpty);

   348 

   349     //WLAN/<x>/EAP/<x>/Realm

   350     MSmlDmDDFObject& eapRealm = eap.AddChildObjectL(KNSmlWLanRealm);

   351     FillNodeInfoL(eapRealm, accessTypesNoDelete, MSmlDmDDFObject::EZeroOrOne,

   352             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   353 

   354     //WLAN/<x>/EAP/<x>/UsePseudonym

   355     MSmlDmDDFObject& eapPseudo = eap.AddChildObjectL(KNSmlWLanUsePseudonym);

   356     FillNodeInfoL(eapPseudo, accessTypesNoDelete,

   357             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   358             MSmlDmDDFObject::EBool, KNSmlEmpty);

   359 

   360     //WLAN/<x>/EAP/<x>/Encapsulation

   361     // Encapsulation is not supported using this parameter. It is done

   362     // with */EAP/EAPIdxxx-yyy/* where xxx is the encapsulated and yyy the encapsulating method.

   363     /*MSmlDmDDFObject& eapEncapsulation = eap.AddChildObjectL( KNSmlWLanEncapsulation );

   364      FillNodeInfoL( eapEncapsulation,

   365      accessTypesNoDelete,

   366      MSmlDmDDFObject::EZeroOrOne,

   367      MSmlDmDDFObject::EDynamic,

   368      MSmlDmDDFObject::EChr,

   369      KNSmlEmpty );                           */

   370 

   371     //WLAN/<x>/EAP/<x>/VerifyCertRealm

   372     MSmlDmDDFObject& eapVerifyCertRealm = eap.AddChildObjectL(

   373             KNSmlWLanVerifyCertRealm);

   374     FillNodeInfoL(eapVerifyCertRealm, accessTypesNoDelete,

   375             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   376             MSmlDmDDFObject::EBool, KNSmlEmpty);

   377 

   378     //WLAN/<x>/EAP/<x>/RequireClientAuthentication

   379     MSmlDmDDFObject& eapRequireClientAuthentication = eap.AddChildObjectL(

   380             KNSmlWLanRequireClientAuthentication);

   381     FillNodeInfoL(eapRequireClientAuthentication, accessTypesNoDelete,

   382             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   383             MSmlDmDDFObject::EBool, KNSmlEmpty);

   384 

   385     //WLAN/<x>/EAP/<x>/SessionValidityTime

   386     MSmlDmDDFObject& eapSessionValidityTime = eap.AddChildObjectL(

   387             KNSmlWLanSessionValidityTime);

   388     FillNodeInfoL(eapSessionValidityTime, accessTypesNoDelete,

   389             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   390             MSmlDmDDFObject::EChr, KNSmlEmpty);

   391 

   392     //WLAN/<x>/EAP/<x>/CipherSuite

   393     MSmlDmDDFObject& eapCipherSuite = eap.AddChildObjectL(

   394             KNSmlWLanCipherSuite);

   395     FillNodeInfoL(eapCipherSuite, accessTypesNoDelete,

   396             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   397             MSmlDmDDFObject::EChr, KNSmlEmpty);

   398 

   399     //WLAN/<x>/EAP/<x>/AllowPEAPv0

   400     MSmlDmDDFObject& eapAllowPEAPv0 = eap.AddChildObjectL(

   401             KNSmlWLanAllowPEAPv0);

   402     FillNodeInfoL(eapAllowPEAPv0, accessTypesNoDelete,

   403             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   404             MSmlDmDDFObject::EBool, KNSmlEmpty);

   405 

   406     //WLAN/<x>/EAP/<x>/AllowPEAPv1

   407     MSmlDmDDFObject& eapAllowPEAPv1 = eap.AddChildObjectL(

   408             KNSmlWLanAllowPEAPv1);

   409     FillNodeInfoL(eapAllowPEAPv1, accessTypesNoDelete,

   410             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   411             MSmlDmDDFObject::EBool, KNSmlEmpty);

   412 

   413     //WLAN/<x>/EAP/<x>/AllowPEAPv2

   414     MSmlDmDDFObject& eapAllowPEAPv2 = eap.AddChildObjectL(

   415             KNSmlWLanAllowPEAPv2);

   416     FillNodeInfoL(eapAllowPEAPv2, accessTypesNoDelete,

   417             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   418             MSmlDmDDFObject::EBool, KNSmlEmpty);

   419 

   420 #ifdef FF_WLAN_EXTENSIONS 

   421 

   422     //WLAN/<x>/EAP/<x>/AuthProvModeAllowed

   423     MSmlDmDDFObject& authProvMode = eap.AddChildObjectL( KNSmlWLanAuthProvMode );

   424     FillNodeInfoL( authProvMode,

   425             accessTypesNoDelete,

   426             MSmlDmDDFObject::EZeroOrOne,

   427             MSmlDmDDFObject::EDynamic,

   428             MSmlDmDDFObject::EBool,

   429             KNSmlEmpty );

   430 

   431     //WLAN/<x>/EAP/<x>/UnauthProvModeAllowed

   432     MSmlDmDDFObject& unauthProvMode = eap.AddChildObjectL( KNSmlWLanUnauthProvMode );

   433     FillNodeInfoL( unauthProvMode,

   434             accessTypesNoDelete,

   435             MSmlDmDDFObject::EZeroOrOne,

   436             MSmlDmDDFObject::EDynamic,

   437             MSmlDmDDFObject::EBool,

   438             KNSmlEmpty );

   439 

   440     //WLAN/<x>/EAP/<x>/PACGroupReference

   441     MSmlDmDDFObject& pacGroupRef = eap.AddChildObjectL( KNSmlWLanPACGroupRef );

   442     FillNodeInfoL( pacGroupRef,

   443             accessTypesNoDelete,

   444             MSmlDmDDFObject::EZeroOrOne,

   445             MSmlDmDDFObject::EDynamic,

   446             MSmlDmDDFObject::EChr,

   447             KNSmlEmpty );

   448 

   449     //WLAN/<x>/EAP/<x>/WarnADHPNoPAC

   450     MSmlDmDDFObject& warnADHPNoPAC = eap.AddChildObjectL( KNSmlWLanWarnADHPNoPAC );

   451     FillNodeInfoL( warnADHPNoPAC,

   452             accessTypesNoDelete,

   453             MSmlDmDDFObject::EZeroOrOne,

   454             MSmlDmDDFObject::EDynamic,

   455             MSmlDmDDFObject::EBool,

   456             KNSmlEmpty );

   457 

   458     //WLAN/<x>/EAP/<x>/WarnADHPNoMatchingPAC

   459     MSmlDmDDFObject& warnADHPNoMatchingPAC = eap.AddChildObjectL( KNSmlWLanWarnADHPNoMatchPAC );

   460     FillNodeInfoL( warnADHPNoMatchingPAC,

   461             accessTypesNoDelete,

   462             MSmlDmDDFObject::EZeroOrOne,

   463             MSmlDmDDFObject::EDynamic,

   464             MSmlDmDDFObject::EBool,

   465             KNSmlEmpty );

   466 

   467     //WLAN/<x>/EAP/<x>/WarnNotDefaultServer

   468     MSmlDmDDFObject& warnNoDefServ = eap.AddChildObjectL( KNSmlWLanWarnNotDefaultSrv );

   469     FillNodeInfoL( warnNoDefServ,

   470             accessTypesNoDelete,

   471             MSmlDmDDFObject::EZeroOrOne,

   472             MSmlDmDDFObject::EDynamic,

   473             MSmlDmDDFObject::EBool,

   474             KNSmlEmpty );

   475 

   476 #endif           

   477 

   478     //WLAN/<x>/EAP/<x>/Certificate

   479     MSmlDmDDFObject& eapCertificateRoot = eap.AddChildObjectL(

   480             KNSmlWLanCertificate);

   481     FillNodeInfoL(eapCertificateRoot, accessTypesGetAdd,

   482             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   483             MSmlDmDDFObject::ENode, KNSmlEmpty);

   484 

   485     //WLAN/<x>/EAP/<x>/Certificate/<x>

   486     MSmlDmDDFObject& eapCertificate =

   487             eapCertificateRoot.AddChildObjectGroupL();

   488     FillNodeInfoL(eapCertificate, accessTypesGetAdd,

   489             MSmlDmDDFObject::EOneOrMore, MSmlDmDDFObject::EDynamic,

   490             MSmlDmDDFObject::ENode, KNSmlEmpty);

   491 

   492     //WLAN/<x>/EAP/<x>/Certificate/<x>/IssuerName

   493     MSmlDmDDFObject& eapIssuerName = eapCertificate.AddChildObjectL(

   494             KNSmlWLanIssuerName);

   495     FillNodeInfoL(eapIssuerName, accessTypesNoDelete,

   496             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   497             MSmlDmDDFObject::EChr, KNSmlEmpty);

   498 

   499     //WLAN/<x>/EAP/<x>/Certificate/<x>/SubjectName

   500     MSmlDmDDFObject& eapSubjectName = eapCertificate.AddChildObjectL(

   501             KNSmlWLanSubjectName);

   502     FillNodeInfoL(eapSubjectName, accessTypesNoDelete,

   503             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   504             MSmlDmDDFObject::EChr, KNSmlEmpty);

   505 

   506     //WLAN/<x>/EAP/<x>/Certificate/<x>/CertType

   507     MSmlDmDDFObject& eapCertType = eapCertificate.AddChildObjectL(

   508             KNSmlWLanCertType);

   509     FillNodeInfoL(eapCertType, accessTypesNoDelete, MSmlDmDDFObject::EOne,

   510             MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr, KNSmlEmpty);

   511 

   512     //WLAN/<x>/EAP/<x>/Certificate/<x>/SerialNumber

   513     MSmlDmDDFObject& eapSerialNumber = eapCertificate.AddChildObjectL(

   514             KNSmlWLanSerialNumber);

   515     FillNodeInfoL(eapSerialNumber, accessTypesNoDelete,

   516             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   517             MSmlDmDDFObject::EChr, KNSmlEmpty);

   518 

   519     //WLAN/<x>/EAP/<x>/Certificate/<x>/SubjectKeyId

   520     MSmlDmDDFObject& eapSubjectKeyId = eapCertificate.AddChildObjectL(

   521             KNSmlWLanSubjectKeyId);

   522     FillNodeInfoL(eapSubjectKeyId, accessTypesNoDelete,

   523             MSmlDmDDFObject::EOne, MSmlDmDDFObject::EDynamic,

   524             MSmlDmDDFObject::EChr, KNSmlEmpty);

   525 

   526     //WLAN/<x>/EAP/<x>/Certificate/<x>/Fingerprint

   527     MSmlDmDDFObject& eapFingerprint = eapCertificate.AddChildObjectL(

   528             KNSmlWLanFingerprint);

   529     FillNodeInfoL(eapFingerprint, accessTypesNoDelete,

   530             MSmlDmDDFObject::EZeroOrOne, MSmlDmDDFObject::EDynamic,

   531             MSmlDmDDFObject::EChr, KNSmlEmpty);

   532 

   533     CleanupStack::PopAndDestroy(); //aclTypes

   534 

   535     _DBG_FILE("CNSmlWLanAdapter::DDFStructureL(): end");

   536     }

   537 

   538 //-----------------------------------------------------------------------------

   539 // CNSmlWLanAdapter* CNSmlWLanAdapter::AddLeafObjectL( const TDesC& aURI,const 

   540 // TDesC& aParentLUID, const TDesC8& aObject, const TDesC& aType, 

   541 // const TInt aStatusRef )

   542 //-----------------------------------------------------------------------------

   543 void CNSmlWLanAdapter::AddLeafObjectL(const TDesC8& aURI,

   544         const TDesC8& aParentLUID, const TDesC8& aObject,

   545         const TDesC8& /*aType*/, const TInt aStatusRef)

   546     {

   547     DBG_ARGS8(_S8("CNSmlWLanAdapter::AddLeafObjectL - <%S> <%S> <%S>"),

   548             &aURI, &aParentLUID, &aObject);

   549 

   550     TInt uriSegs = NumOfUriSegs(aURI);

   551     TInt luid = GetIdFromLuid(aParentLUID);

   552     TInt err(KErrNone);

   553     TPtrC8 lastUriSeg = GetLastUriSeg(aURI);

   554 

   555     TInt eapIndex(0);

   556 

   557     TInt eapId = GetEAPIdFromUri(aURI);

   558     if (eapId == KErrNotFound)

   559         {

   560         _DBG_FILE("CNSmlWLanAdapter::AddLeafObjectL(): Non-EAP setting.");

   561         if (luid == KErrNotFound)

   562             {

   563             return;

   564             }

   565         err = iWlanSettings->GetWlanSettings(luid, *iSettings);

   566         }

   567     else

   568         {

   569         _DBG_FILE("CNSmlWLanAdapter::AddLeafObjectL(): EAP setting.");

   570         TInt encapsEapId = GetEncapsEAPIdFromUri(aURI);

   571         if (encapsEapId == KErrNotFound)

   572             {

   573             _DBG_FILE(

   574                     "CNSmlWLanAdapter::AddLeafObjectL(): Does not have encapsulation id xx-xx.");

   575             encapsEapId = EEapNone;

   576             }

   577         // append it to the appropriate list ('+' enabled, '-' disabled)

   578         _LIT8(KPadding, "\xFE\0\0\0\0\0\0");

   579         _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");

   580         const TInt KPlainMsChapV2ImplUid = 99;

   581 

   582         TBuf8<KExpandedEapIdLength> cmpbuf;

   583         if (eapId == KPlainMsChapV2ImplUid)

   584             {

   585             cmpbuf.Append(KMsChapV2Padding);

   586             }

   587         else

   588             {

   589             cmpbuf.Append(KPadding);

   590             }

   591         cmpbuf.Append(eapId);

   592         TEapExpandedType expandedTypecmbuf(cmpbuf);

   593 

   594         TBuf8<KExpandedEapIdLength> encapscmpbuf;

   595         if (encapsEapId == KPlainMsChapV2ImplUid)

   596             {

   597             encapscmpbuf.Append(KMsChapV2Padding);

   598             }

   599         else

   600             {

   601             encapscmpbuf.Append(KPadding);

   602             }

   603         encapscmpbuf.Append(encapsEapId);

   604         TEapExpandedType expandedTypeencapscmbuf(encapscmpbuf);

   605 

   606         TInt i(0);

   607         // This is EAP addition. Check if the buffer for this EAP already exists

   608         for (i = 0; i < iEAPBuffer.Count(); i++)

   609             {

   610             if ((expandedTypecmbuf.Compare(

   611                     iEAPBuffer[i]->iEAPSettings->iEAPExpandedType) == 0)

   612                     && (expandedTypeencapscmbuf.Compare(

   613                             iEAPBuffer[i]->iEncapsulatingExpandedEapId) == 0))

   614                 {

   615                 // The correct buffer was found.     			

   616                 _DBG_FILE(

   617                         "CNSmlWLanAdapter::AddLeafObjectL(): Found existing buffer.");

   618                 eapIndex = i;

   619                 break;

   620                 }

   621             }

   622         if (i == iEAPBuffer.Count())

   623             {

   624             DBG_ARGS8(

   625                     _S8(

   626                             "CNSmlWLanAdapter::AddLeafObjectL(): No buffer found. Create new: <%d>-<%d>"),

   627                     eapId, encapsEapId);

   628             // Buffer was not found. Create new.

   629             TInt WLANServiceId = GetServiceIdFromUriL(aURI);

   630 

   631             if (WLANServiceId == KErrNotFound)

   632                 {

   633                 _DBG_FILE(

   634                         "CNSmlWLanAdapter::AddLeafObjectL(): Could not find WLAN service ID from URI.");

   635                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

   636                 return;

   637                 }

   638 

   639             TNSmlEAPBufferElement* buffer =

   640                     new (ELeave) TNSmlEAPBufferElement;

   641             CleanupStack::PushL(buffer);

   642 

   643             buffer->iEAPSettings = new (ELeave) EAPSettings;

   644             CleanupStack::PushL(buffer->iEAPSettings);

   645 

   646             // append it to the appropriate list ('+' enabled, '-' disabled)

   647             _LIT8(KPadding, "\xFE\0\0\0\0\0\0");

   648             _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");

   649             const TInt KPlainMsChapV2ImplUid = 99;

   650 

   651             TBuf8<KExpandedEapIdLength> tempbuf;

   652             if (eapId == KPlainMsChapV2ImplUid)

   653                 {

   654                 tempbuf.Append(KMsChapV2Padding);

   655                 }

   656             else

   657                 {

   658                 tempbuf.Append(KPadding);

   659                 }

   660             tempbuf.Append(eapId);

   661 

   662             buffer->iEAPSettings->iEAPExpandedType = tempbuf;

   663             buffer->iWLANServiceId = WLANServiceId;

   664             TBuf8<KExpandedEapIdLength> encapsTempbuf;

   665             if (encapsEapId == KPlainMsChapV2ImplUid)

   666                 {

   667                 encapsTempbuf.Append(KMsChapV2Padding);

   668                 }

   669             else

   670                 {

   671                 encapsTempbuf.Append(KPadding);

   672                 }

   673             encapsTempbuf.Append(encapsEapId);

   674 

   675             buffer->iEncapsulatingExpandedEapId = encapsTempbuf;

   676             iEAPBuffer.AppendL(buffer);

   677 

   678             CleanupStack::Pop(buffer->iEAPSettings);

   679             CleanupStack::Pop(buffer);

   680 

   681             eapIndex = iEAPBuffer.Count() - 1;

   682             }

   683         }

   684     if (err != KErrNone)

   685         {

   686         DBG_ARGS(_S16("CNSmlWLanAdapter::AddLeafObjectL - ErrorCode <%D>"),

   687                 err);

   688         iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

   689         return;

   690         }

   691 

   692     else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/WEPKey/*/*"))

   693             != KErrNotFound && uriSegs == 9)

   694         {

   695         TInt wepKeyId = GetWepKeyIdFromLuid(aParentLUID);

   696 

   697         if (wepKeyId != KErrNotFound)

   698             {

   699             if (lastUriSeg.Match(KNSmlWLanWepKeyData) != KErrNotFound)

   700                 {

   701                 switch (wepKeyId)

   702                     {

   703                     case 1:

   704                         iSettings->WepKey1 = aObject;

   705                         break;

   706                     case 2:

   707                         iSettings->WepKey2 = aObject;

   708                         break;

   709                     case 3:

   710                         iSettings->WepKey3 = aObject;

   711                         break;

   712                     case 4:

   713                         iSettings->WepKey4 = aObject;

   714                         break;

   715                     default:

   716                         iCallBack->SetStatusL(aStatusRef,

   717                                 CSmlDmAdapter::ENotFound);

   718                         return;

   719                     }

   720                 }

   721             else if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)

   722                 {

   723                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);

   724                 return;

   725                 }

   726             else

   727                 {

   728                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

   729                 return;

   730                 }

   731             }

   732 

   733         else

   734             {

   735             TInt index = -1;

   736 

   737             for (TInt i = 0; i < iBuffer->Count(); i++)

   738                 {

   739                 if (aURI.Find(iBuffer->At(i).iUri->Des()) != KErrNotFound)

   740                     {

   741                     index = i;

   742                     break;

   743                     }

   744                 }

   745             if (index < 0)

   746                 {

   747                 wepKeyId = GetWepKeyIdFromUri(aURI);

   748 

   749                 TBuf8<80> addLUID; // AP/<x>/NapDef/<x>/WLAN/<x>/WEPKey/WKIdnnn

   750                 addLUID.AppendNum(wepKeyId);

   751                 addLUID.AppendNumFixedWidth(luid, EDecimal, 3);

   752 

   753                 DBG_ARGS8(

   754                         _S8(

   755                                 "WLanAdapter::AddleafObject - mapping uri: <%S> to luid: <%S>"),

   756                         &aURI, &addLUID);

   757                 DBG_ARGS8(_S8("Parametrit - <%S> <%S>"), &aURI, &addLUID);

   758                 iCallBack->SetMappingL(aURI, addLUID);

   759                 if (lastUriSeg.Match(KNSmlWLanWepKeyData) != KErrNotFound)

   760                     {

   761                     switch (wepKeyId)

   762                         {

   763                         case 1:

   764                             iSettings->WepKey1 = aObject;

   765                             break;

   766                         case 2:

   767                             iSettings->WepKey2 = aObject;

   768                             break;

   769                         case 3:

   770                             iSettings->WepKey3 = aObject;

   771                             break;

   772                         case 4:

   773                             iSettings->WepKey4 = aObject;

   774                             break;

   775                         default:

   776                             iCallBack->SetStatusL(aStatusRef,

   777                                     CSmlDmAdapter::ENotFound);

   778                             return;

   779                         }

   780                     }

   781                 else if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)

   782                     {

   783                     iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);

   784                     return;

   785                     }

   786                 else

   787                     {

   788                     iCallBack->SetStatusL(aStatusRef,

   789                             CSmlDmAdapter::ENotFound);

   790                     return;

   791                     }

   792                 }

   793             else

   794                 {

   795                 //Add WepKeyId and execute buffer

   796                 if (lastUriSeg.Match(KNSmlWLanWepKeyId) != KErrNotFound)

   797                     {

   798                     iBuffer->At(index).iWepKeyId = DesToInt(aObject);

   799                     iBuffer->At(index).iIdStatusRef = aStatusRef;

   800 

   801                     //                  ExecuteBufferL( ); (JPLA-6M29NR caused error in WEPkey Data if buffer is executed here)

   802                     return;

   803                     }

   804 

   805                 else if (lastUriSeg.Match(KNSmlWLanWepKeyData)

   806                         != KErrNotFound)

   807                     {

   808                     iBuffer->At(index).iData = aObject.AllocLC();

   809                     iBuffer->At(index).iDataSet = ETrue;

   810                     CleanupStack::Pop(); //iBuffer->At(index).iData

   811                     iBuffer->At(index).iDataStatusRef = aStatusRef;

   812                     return;

   813                     }

   814                 else

   815                     {

   816                     iCallBack->SetStatusL(aStatusRef,

   817                             CSmlDmAdapter::ENotFound);

   818                     return;

   819                     }

   820                 }

   821             }

   822         }

   823 

   824     else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/*")) != KErrNotFound

   825             && uriSegs == 7)

   826         {

   827         if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)

   828             {

   829             TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(

   830                     iSettings->SSID, aObject);

   831             DBG_ARGS(_S16("WLanAdapter::ssid convert: <%D>"), returnValue);

   832             if (returnValue != KErrNone)

   833                 {

   834                 // setting the default value to the network name

   835                 iSettings->SSID = TPtrC(KNSmlWLanDefaultSSID);

   836                 DBG_ARGS(

   837                         _S16(

   838                                 "CNSmlWLanAdapter::AddLeafObjectL SSID - ErrorCode <%D>"),

   839                         returnValue);

   840                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   841                 return;

   842                 }

   843             }

   844 

   845         else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)

   846             {

   847             TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(

   848                     iSettings->UsedSSID, aObject);

   849             DBG_ARGS(_S16("WLanAdapter::usedSsid convert: <%D>"), returnValue);

   850             }

   851 

   852         else if (lastUriSeg.Compare(KNSmlWLanSsidHidden) == 0)

   853             {

   854             if (aObject.MatchF(_L8("True")) != KErrNotFound)

   855                 {

   856                 iSettings->ScanSSID = 1;

   857                 }

   858             else

   859                 {

   860                 iSettings->ScanSSID = 0;

   861                 }

   862             }

   863 

   864         else if (lastUriSeg.Compare(KNSmlWLanNetworkMode) == 0)

   865             {

   866             if (aObject.MatchF(_L8("ADHOC")) != KErrNotFound)

   867                 {

   868                 iSettings->ConnectionMode = EAdhoc;

   869                 }

   870 

   871             else if (aObject.MatchF(_L8("Infrastructure")) != KErrNotFound)

   872                 {

   873                 iSettings->ConnectionMode = EInfrastructure;

   874                 }

   875             else

   876                 {

   877                 iCallBack->SetStatusL(aStatusRef,

   878                         CSmlDmAdapter::EInvalidObject);

   879                 return;

   880                 }

   881             }

   882 

   883         else if (lastUriSeg.Compare(KNSmlWLanSecurityMode) == 0)

   884             {

   885             if (aObject.MatchF(_L8("NONE")) != KErrNotFound)

   886                 {

   887                 iSettings->SecurityMode = EAllowUnsecure;

   888                 }

   889             else if (aObject.MatchF(_L8("WEP")) != KErrNotFound)

   890                 {

   891                 iSettings->SecurityMode = EWep;

   892                 }

   893             else if (aObject.MatchF(_L8("8021X")) != KErrNotFound)

   894                 {

   895                 iSettings->SecurityMode = EWlan8021x;

   896                 }

   897             else if (aObject.MatchF(_L8("WPA")) != KErrNotFound)

   898                 {

   899                 iSettings->SecurityMode = EWpa;

   900                 }

   901             else if (aObject.MatchF(_L8("WPA2")) != KErrNotFound)

   902                 {

   903                 iSettings->SecurityMode = EWpa2;

   904                 }

   905             else

   906                 {

   907                 iCallBack->SetStatusL(aStatusRef,

   908                         CSmlDmAdapter::EInvalidObject);

   909                 return;

   910                 }

   911             }

   912 

   913         else if (lastUriSeg.Compare(KNSmlWLanUseWPAPSK) == 0)

   914             {

   915             if (aObject.MatchF(_L8("True")) != KErrNotFound)

   916                 {

   917                 iSettings->UseWPAPSK = 1;

   918                 }

   919             else

   920                 {

   921                 iSettings->UseWPAPSK = 0;

   922                 }

   923             }

   924 

   925         else if (lastUriSeg.Compare(KNSmlWLanWpaPreSharedKey) == 0)

   926             {

   927             if (aObject.Length() > KMaxPSKLength)

   928                 {

   929                 iCallBack->SetStatusL(aStatusRef,

   930                         CSmlDmAdapter::ETooLargeObject);

   931                 return;

   932                 }

   933             /*else if(aObject.Length() < KMinPSKLength)

   934              {

   935              iCallBack->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );

   936              return;

   937              }*/

   938             else

   939                 {

   940                 iSettings->WPAPreSharedKey = aObject;

   941                 }

   942             }

   943 

   944         else if (lastUriSeg.Compare(KNSmlWLanEapList) == 0)

   945             {

   946             TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(

   947                     iSettings->EapList, aObject);

   948             DBG_ARGS(_S16("WLanAdapter::EapList convert: <%D>"), returnValue);

   949             }

   950 

   951         else if (lastUriSeg.Compare(KNSmlWLanAuthMode) == 0)

   952             {

   953             if (aObject.MatchF(_L8("1")) != KErrNotFound)

   954                 {

   955                 iSettings->AuthMode = EShared;

   956                 }

   957             else

   958                 {

   959                 iSettings->AuthMode = EOpen;

   960                 }

   961             }

   962 

   963         else if (lastUriSeg.Compare(KNSmlWLanWepIndex) == 0)

   964             {

   965             TInt32 actualIndex = DesToInt(aObject);

   966             if (actualIndex < 4 && actualIndex >= 0)

   967                 {

   968                 iSettings->WepIndex = actualIndex;

   969                 }

   970             else

   971                 {

   972                 if (actualIndex > 3)

   973                     {

   974                     iCallBack->SetStatusL(aStatusRef,

   975                             CSmlDmAdapter::ETooLargeObject);

   976                     }

   977                 else

   978                     {

   979                     iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);

   980                     }

   981                 return;

   982                 }

   983             }

   984 

   985         else

   986             {

   987             iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

   988             return;

   989             }

   990         }

   991 

   992     else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/SecondarySSID/*/*"))

   993             != KErrNotFound && uriSegs == 9)

   994         {

   995         TSecondarySSID ssid;

   996         ssid.Id = 0;

   997         TUint32 id = GetSecSSIDFromUriL(aURI);

   998         RArray<TSecondarySSID> secondaryList;

   999         CleanupClosePushL(secondaryList);

  1000         iWlanSettings->GetSecondarySSIDListL(luid, secondaryList);

  1001         TInt count = secondaryList.Count();

  1002         for (TInt i = 0; i < count; i++)

  1003             {

  1004             if (id == secondaryList[i].Id)

  1005                 {

  1006                 ssid = secondaryList[i];

  1007                 break;

  1008                 }

  1009             }

  1010         CleanupStack::PopAndDestroy(&secondaryList);

  1011         if (ssid.Id == 0)

  1012             {

  1013 

  1014             _DBG_FILE("CNSmlWLanAdapter::Coming to check buffer ");

  1015 

  1016             //Check if its buffered here - Divya

  1017             TInt index = -1;

  1018 

  1019             for (TInt i = 0; i < iSecondaryBuffer.Count(); i++)

  1020                 {

  1021                 if (aURI.Find(iSecondaryBuffer[i]->iUri->Des())

  1022                         != KErrNotFound)

  1023                     {

  1024                     index = i;

  1025                     _DBG_FILE("CNSmlWLanAdapter::one indexis matched :-)");

  1026                     break;

  1027                     }

  1028                 }

  1029             if (index < 0)

  1030                 {

  1031                 _DBG_FILE("CNSmlWLanAdapter::one indexis matched :-)");

  1032                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

  1033                 return;

  1034                 }

  1035             else

  1036                 {

  1037                 DBG_ARGS8(

  1038                         _S8(

  1039                                 "CWlanadaptes::Execute Buffer - copying in buffer instead of giving 404 uri: object id  : <%S>"),

  1040                         &aObject);

  1041 

  1042                 if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)

  1043                     {

  1044                     if (aObject.Length() <= KMaxTextLength)

  1045                         {

  1046                         iSecondaryBuffer[index]->ScannedId.Copy(aObject);

  1047                         }

  1048                     else

  1049                         {

  1050                         _DBG_FILE(

  1051                                 "CNSmlWLanAdapter::AddLeafObject - SecondarySSID too long");

  1052                         iCallBack->SetStatusL(aStatusRef,

  1053                                 CSmlDmAdapter::EError);

  1054                         return;

  1055                         }

  1056 

  1057                     }

  1058                 else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)

  1059                     {

  1060                     iSecondaryBuffer[index]->UsedId.Copy(aObject);

  1061                     }

  1062 

  1063                 }

  1064 

  1065             }

  1066 

  1067         else

  1068             {

  1069 

  1070             if (lastUriSeg.Compare(KNSmlWLanSsid) == 0)

  1071                 {

  1072                 ssid.ScannedId.Copy(aObject);

  1073                 }

  1074             else if (lastUriSeg.Compare(KNSmlWLanUsedSsid) == 0)

  1075                 {

  1076                 ssid.UsedId.Copy(aObject);

  1077                 }

  1078             TInt retval = iWlanSettings->WriteSecondarySSIDL(luid, ssid,

  1079                     EFalse);

  1080             if (retval == KErrNone)

  1081                 {

  1082                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EOk);

  1083                 }

  1084             else

  1085                 {

  1086                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);

  1087                 }

  1088             }

  1089         }

  1090     else if (aURI.Match(_L8("AP/*/NAPDef/*/WLAN/*/EAP/*/*")) != KErrNotFound

  1091             && uriSegs == 9)

  1092         {

  1093         DBG_ARGS8(_S8("CNSmlWLanAdapter::AddLeafObjectL - EAP index: <%d>"),

  1094                 eapIndex);

  1095 

  1096         if (lastUriSeg.Compare(KNSmlWLanEapType) == 0)

  1097             {

  1098             TInt eapid = GetEAPIdFromUri(aURI);

  1099             // append it to the appropriate list ('+' enabled, '-' disabled)

  1100             _LIT8(KPadding, "\xFE\0\0\0\0\0\0");

  1101             _LIT8(KMsChapV2Padding, "\xFE\xFF\xFF\xFF\0\0\0");

  1102             const TInt KPlainMsChapV2ImplUid = 99;

  1103             TBuf8<KExpandedEapIdLength> tempbuf;

  1104             if (eapid == KPlainMsChapV2ImplUid)

  1105                 {

  1106                 tempbuf.Append(KMsChapV2Padding);

  1107                 }

  1108             else

  1109                 {

  1110                 tempbuf.Append(KPadding);

  1111                 }

  1112             tempbuf.Append(eapid);

  1113             // Get EAP ID from URI instead of the value because the server gives the value

  1114             // incorrectly as the textual representation of the EAP method instead of the IANA number.            

  1115             iEAPBuffer[eapIndex]->iEAPSettings->iEAPExpandedType = tempbuf;

  1116             }

  1117         else if (lastUriSeg.Compare(KNSmlWLanUsername) == 0)

  1118             {

  1119             TInt retval = CnvUtfConverter::ConvertToUnicodeFromUtf8(

  1120                     iEAPBuffer[eapIndex]->iEAPSettings->iUsername, aObject);

  1121             if (retval == KErrNone)

  1122                 {

  1123                 iEAPBuffer[eapIndex]->iEAPSettings->iUsernamePresent = ETrue;

  1124                 }

  1125             else

  1126                 {

  1127                 iEAPBuffer[eapIndex]->iEAPSettings->iUsername.Zero();

  1128                 DBG_ARGS(

  1129                         _S16(

  1130                                 "CNSmlWLanAdapter::AddLeafObjectL EAP username - ErrorCode <%D>"),

  1131                         retval);

  1132                 iCallBack->SetStatusL(aStatusRef, CSmlDmAdapter::EError);

  1133                 return;

  1134                 }