1 /*

     2 * Copyright (c) 2009-2010 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:

    15 *        Implementation of WLAN Plugin interface implementation

    16 *        for WLAN Bearer

    17 *

    18 */

    19 

    20 

    21 #include <ecom/ecom.h>      // For REComSession

    22 #include <wlancontainer.h>

    23 #include <wlanmgmtcommon.h>

    24 #include <cmpluginwlandef.h>

    25 #include <cmcommonconstants.h>

    26 #include <featmgr.h>

    27 #include <EapGeneralSettings.h>

    28 

    29 #include "datamobilitycommsdattypes.h"

    30 #include "cmpluginwlan.h"

    31 #include "cmwlancoveragecheck.h"

    32 #include "cmmanagerdef.h"

    33 

    34 #include "OstTraceDefinitions.h"

    35 #ifdef OST_TRACE_COMPILER_IN_USE

    36 #include "cmpluginwlanTraces.h"

    37 #endif

    38 

    39 using namespace CMManager;

    40 

    41 enum TWlanWepKeyFormat

    42     {

    43     EWlanWepKeyFormatAscii = 0,

    44     EWlanWepKeyFormatHex

    45     };

    46 

    47 // default values for fields...

    48 // CONSTANTS

    49 _LIT( KEmpty, "");

    50 

    51 const TBool KDefIpAddrFromServer = ETrue;

    52 const TBool KDefIpDnsAddrFromServer = ETrue;

    53 const TBool KDefIp6DnsAddrFromServer = ETrue;

    54 

    55 const TInt KWlanServiceRecordIndex = 0;

    56 

    57 const TInt KWlanLastSocketActivityTimeout = -1;

    58 const TInt KWlanLastSessionClosedTimeout = 1;

    59 const TInt KWlanLastSocketClosedTimeout = -1;

    60 

    61 /// Modem bearer names for WLAN connection methods.

    62 _LIT( KModemBearerWLAN, "WLANBearer" );

    63 

    64 _LIT( KWlanBearerName, "WLANBearer" );

    65 _LIT( KWlanBearerAgent, "wlanagt.agt" );

    66 _LIT( KWlanBearerNif, "wlannif" );

    67 

    68 _LIT( KWlanLDDName, "not used" );

    69 _LIT( KWlanPDDName, "not used" );

    70 

    71 

    72 // --------------------------------------------------------------------------

    73 // CCmPluginWlan::NewL

    74 // --------------------------------------------------------------------------

    75 //

    76 CCmPluginWlan* CCmPluginWlan::NewL( TCmPluginInitParam* aInitParam )

    77     {

    78     OstTraceFunctionEntry0( CCMPLUGINWLAN_NEWL_ENTRY );

    79 

    80     CCmPluginWlan* self = new( ELeave ) CCmPluginWlan( aInitParam );

    81     CleanupStack::PushL( self );

    82     self->ConstructL();

    83     CleanupStack::Pop( self );

    84 

    85     OstTraceFunctionExit0( CCMPLUGINWLAN_NEWL_EXIT );

    86     return self;

    87     }

    88 

    89 // --------------------------------------------------------------------------

    90 // CCmPluginWlan::~CCmPluginWlan

    91 // --------------------------------------------------------------------------

    92 //

    93 CCmPluginWlan::~CCmPluginWlan()

    94     {

    95     OstTraceFunctionEntry0( CCMPLUGINWLAN_CCMPLUGINWLAN_ENTRY );

    96 

    97     ResetBearerRecords();

    98 

    99     OstTraceFunctionExit0( CCMPLUGINWLAN_CCMPLUGINWLAN_EXIT );

   100     }

   101 

   102 // --------------------------------------------------------------------------

   103 // CCmPluginWlan::CreateInstanceL

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

   105 //

   106 CCmPluginBaseEng* CCmPluginWlan::CreateInstanceL( TCmPluginInitParam& aInitParam ) const

   107     {

   108     OstTraceFunctionEntry0( CCMPLUGINWLAN_CREATEINSTANCEL_ENTRY );

   109 

   110     CCmPluginWlan* self = new( ELeave ) CCmPluginWlan( &aInitParam );

   111     CleanupStack::PushL( self );

   112     self->ConstructL();

   113     CleanupStack::Pop( self );

   114 

   115     OstTraceFunctionExit0( CCMPLUGINWLAN_CREATEINSTANCEL_EXIT );

   116     return self;

   117     }

   118 

   119 // --------------------------------------------------------------------------

   120 // CCmPluginWlan::CCmPluginWlan

   121 // --------------------------------------------------------------------------

   122 //

   123 CCmPluginWlan::CCmPluginWlan( TCmPluginInitParam* aInitParam )

   124         :

   125         CCmPluginBaseEng( aInitParam )

   126     {

   127     OstTraceFunctionEntry0( DUP1_CCMPLUGINWLAN_CCMPLUGINWLAN_ENTRY );

   128 

   129     iBearerType = KUidWlanBearerType;

   130     iWlanServiceRecord = NULL;

   131     iWlanTableId = 0;

   132     iWAPISupported = EFalse;

   133     iBearerPriorityTableId = 0;

   134 

   135     OstTraceFunctionExit0( DUP1_CCMPLUGINWLAN_CCMPLUGINWLAN_EXIT );

   136     }

   137 

   138 // --------------------------------------------------------------------------

   139 // CCmPluginWlan::ConstructL

   140 // --------------------------------------------------------------------------

   141 //

   142 void CCmPluginWlan::ConstructL()

   143     {

   144     OstTraceFunctionEntry0( CCMPLUGINWLAN_CONSTRUCTL_ENTRY );

   145 

   146     // Feature Manager is initialized by the CmmServer, so no need to do it here.

   147 

   148     if ( ! FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

   149         {

   150         User::Leave( KErrNotSupported );

   151         }

   152 

   153     CCmPluginBaseEng::ConstructL();

   154 

   155     // Get bearer priority table ID.

   156     TRAP_IGNORE( iBearerPriorityTableId =

   157             CCDGlobalBearerTypePriorizationRecord::TableIdL( iSession ) );

   158 

   159     if ( !iBearerPriorityTableId )

   160         {

   161         iBearerPriorityTableId =

   162                 CCDGlobalBearerTypePriorizationRecord::CreateTableL( iSession );

   163         }

   164 

   165     TMDBElementId tableId( 0 );

   166 

   167     TRAP_IGNORE( tableId = CCDWlanDeviceSettingsRecord::TableIdL( iSession ) );

   168     if ( !tableId )

   169         {

   170         CCDWlanDeviceSettingsRecord::CreateTableL( iSession );

   171         }

   172 

   173     // Get WLAN table ID.

   174     TRAP_IGNORE( iWlanTableId = CCDWlanServiceRecord::TableIdL( iSession ) );

   175     if ( !iWlanTableId )

   176         {

   177         iWlanTableId = CCDWlanServiceRecord::CreateTableL( iSession );

   178         }

   179 

   180     TRAP_IGNORE( tableId = CCDWLANSecSSIDTable::TableIdL( iSession ) );

   181     if ( !tableId )

   182         {

   183         CCDWLANSecSSIDTable::CreateTableL( iSession );

   184         }

   185 

   186     TRAP_IGNORE( tableId = CCDDestNWTable::TableIdL( iSession ) );

   187     if ( !tableId )

   188         {

   189         CCDDestNWTable::CreateTableL( iSession );

   190         }

   191 

   192     iWAPISupported = FeatureManager::FeatureSupported( KFeatureIdFfWlanWapi );

   193 

   194     OstTraceFunctionExit0( CCMPLUGINWLAN_CONSTRUCTL_EXIT );

   195     }

   196 

   197 // ---------------------------------------------------------------------------

   198 // CCmPluginWlan::ServiceRecord()

   199 // ---------------------------------------------------------------------------

   200 //

   201 CCDLANServiceRecord& CCmPluginWlan::ServiceRecord() const

   202     {

   203     return *static_cast<CCDLANServiceRecord*>( iServiceRecord );

   204     }

   205 

   206 // ---------------------------------------------------------------------------

   207 // CCmPluginWlan::ServiceRecordId

   208 // ---------------------------------------------------------------------------

   209 //

   210 TUint32 CCmPluginWlan::ServiceRecordId() const

   211     {

   212     OstTraceFunctionEntry0( CCMPLUGINWLAN_SERVICERECORDID_ENTRY );

   213 

   214     return ServiceRecord().RecordId();

   215     }

   216 

   217 // ---------------------------------------------------------------------------

   218 // CCmPluginWlan::ServiceRecordIdLC

   219 // ---------------------------------------------------------------------------

   220 //

   221 void CCmPluginWlan::ServiceRecordNameLC( HBufC* &aName )

   222     {

   223     OstTraceFunctionEntry0( CCMPLUGINWLAN_SERVICERECORDNAMELC_ENTRY );

   224 

   225     aName = TPtrC( KCDTypeNameLANService ).AllocLC();

   226 

   227     OstTraceFunctionExit0( CCMPLUGINWLAN_SERVICERECORDNAMELC_EXIT );

   228     }

   229 

   230 // ---------------------------------------------------------------------------

   231 // CCmPluginWlan::BearerRecordIdL()

   232 // ---------------------------------------------------------------------------

   233 //

   234 void CCmPluginWlan::BearerRecordIdL( TUint32& aRecordId )

   235     {

   236     OstTraceFunctionEntry0( CCMPLUGINWLAN_BEARERRECORDIDL_ENTRY );

   237 

   238     CCDLANBearerRecord* lanBearerRecord = static_cast<CCDLANBearerRecord*>

   239                         (CCDRecordBase::RecordFactoryL( KCDTIdLANBearerRecord ));

   240     CleanupStack::PushL( lanBearerRecord );

   241 

   242     lanBearerRecord->iRecordName.SetL( TPtrC( KModemBearerWLAN ) );

   243     if ( !lanBearerRecord->FindL( iSession ) )

   244         { // bearer not found -> create dummy values

   245         lanBearerRecord->SetRecordId( KCDNewRecordRequest );

   246         lanBearerRecord->iBearerAgent = KWlanBearerAgent;

   247         lanBearerRecord->iRecordName = KWlanBearerName;

   248         lanBearerRecord->iLanBearerNifName = KWlanBearerNif;

   249         lanBearerRecord->iLanBearerLddName = KWlanLDDName;

   250         lanBearerRecord->iLanBearerPddName = KWlanPDDName;

   251         lanBearerRecord->iLastSocketActivityTimeout =

   252                                         (TUint32)KWlanLastSocketActivityTimeout;

   253         lanBearerRecord->iLastSessionClosedTimeout =

   254                                         (TUint32)KWlanLastSessionClosedTimeout;

   255         lanBearerRecord->iLastSocketClosedTimeout =

   256                                         (TUint32)KWlanLastSocketClosedTimeout;

   257 

   258         lanBearerRecord->StoreL( iSession );

   259         }

   260 

   261     aRecordId = lanBearerRecord->RecordId();

   262 

   263     CleanupStack::PopAndDestroy( lanBearerRecord );

   264 

   265     OstTraceFunctionExit0( CCMPLUGINWLAN_BEARERRECORDIDL_EXIT );

   266     }

   267 

   268 // ---------------------------------------------------------------------------

   269 // CCmPluginWlan::BearerRecordNameLC()

   270 // ---------------------------------------------------------------------------

   271 //

   272 void CCmPluginWlan::BearerRecordNameLC( HBufC* &aBearerName )

   273     {

   274     OstTraceFunctionEntry0( CCMPLUGINWLAN_BEARERRECORDNAMELC_ENTRY );

   275 

   276     aBearerName = TPtrC( KCDTypeNameLANBearer ).AllocLC();

   277 

   278     OstTraceFunctionExit0( CCMPLUGINWLAN_BEARERRECORDNAMELC_EXIT );

   279     }

   280 

   281 // --------------------------------------------------------------------------

   282 // CCmPluginWlan::GetBearerIntAttributeL

   283 // --------------------------------------------------------------------------

   284 //

   285 TUint32 CCmPluginWlan::GetBearerIntAttributeL(

   286         TUint32 aAttribute,

   287         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   288         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   289     {

   290     OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERINTATTRIBUTEL_ENTRY );

   291 

   292     TUint32 retVal( 0 );

   293 

   294     CCDLANServiceRecord* serviceRecord =

   295             static_cast<CCDLANServiceRecord*>(

   296                     aGenRecordArray[KServiceRecordIndex] );

   297 

   298     CCDWlanServiceRecord* wlanServiceRecord =

   299             static_cast<CCDWlanServiceRecord*>(

   300                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   301 

   302     switch ( aAttribute )

   303         {

   304         case ECmInvalidAttribute:

   305             {

   306             // This attribute has been deprecated since Symbian^4.

   307             User::Leave( KErrNotSupported );

   308             }

   309             break;

   310         case ECmExtensionLevel:

   311             {

   312             // This is extension from LAN plugin

   313             retVal = KExtensionBaseLevel + 1;

   314             }

   315             break;

   316         case ECmCommsDBBearerType:

   317             {

   318             retVal = KCommDbBearerWLAN;

   319             }

   320             break;

   321         case ECmDefaultUiPriority:

   322             {

   323             retVal = GetDefPriorityL( aAttribute );

   324             }

   325             break;

   326         case ECmDefaultPriority:

   327             {

   328             retVal = GetDefPriorityL( aAttribute );

   329             }

   330             break;

   331         case EWlanServiceId:

   332             {

   333             retVal = wlanServiceRecord->iWlanServiceId;

   334             }

   335             break;

   336         case EWlanConnectionMode:

   337             {

   338             retVal = wlanServiceRecord->iWlanConnMode;

   339             }

   340             break;

   341         case EWlanSecurityMode:

   342             {

   343             retVal = wlanServiceRecord->iWlanSecMode;

   344             }

   345             break;

   346         case EWlanAuthenticationMode:

   347             {

   348             retVal = wlanServiceRecord->iWlanAuthMode;

   349             }

   350             break;

   351         case EWlanChannelID:

   352             {

   353             retVal = wlanServiceRecord->iWlanChannelID;

   354             }

   355             break;

   356         case EWlanServiceExtensionTableRecordId:

   357             {

   358             retVal = serviceRecord->iServiceExtensionTableRecordId;

   359             }

   360             break;

   361         case EWlanWepKeyIndex:

   362             {

   363             retVal = wlanServiceRecord->iWlanWepIndex;

   364             }

   365             break;

   366         case EWlanWapiPskFormat:

   367             {

   368             retVal = wlanServiceRecord->iWlanFormatKey1;

   369             }

   370             break;

   371         default:

   372             {

   373             User::Leave( KErrNotSupported );

   374             }

   375             break;

   376         }

   377 

   378     OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERINTATTRIBUTEL_EXIT );

   379     return retVal;

   380     }

   381 

   382 // --------------------------------------------------------------------------

   383 // CCmPluginWlan::GetBearerBoolAttributeL

   384 // --------------------------------------------------------------------------

   385 //

   386 TBool CCmPluginWlan::GetBearerBoolAttributeL(

   387         TUint32 aAttribute,

   388         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   389         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   390     {

   391     OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERBOOLATTRIBUTEL_ENTRY );

   392 

   393     TBool retVal( EFalse );

   394 

   395     CCDWlanServiceRecord* wlanServiceRecord =

   396             static_cast<CCDWlanServiceRecord*>(

   397                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   398 

   399     CCDLANServiceRecord* serviceRecord =

   400             static_cast<CCDLANServiceRecord*>(

   401                     aGenRecordArray[KServiceRecordIndex] );

   402 

   403     switch ( aAttribute )

   404         {

   405         case ECmCoverage:

   406             {

   407 #ifndef __WINS__

   408             retVal = CheckNetworkCoverageL();

   409 #else

   410             retVal = ETrue;

   411 #endif

   412             }

   413             break;

   414         case ECmDestination:

   415             {

   416             retVal = EFalse;

   417             }

   418             break;

   419         case ECmBearerHasUi:

   420             {

   421             retVal = ETrue;

   422             }

   423             break;

   424         case ECmIPv6Supported:

   425             {

   426             retVal = FeatureManager::FeatureSupported( KFeatureIdIPv6 );

   427             }

   428             break;

   429         case EWlanScanSSID:

   430             {

   431             retVal = wlanServiceRecord->iWlanScanSSID;

   432             }

   433             break;

   434         case EWlanAllowSSIDRoaming:

   435             {

   436             retVal = wlanServiceRecord->iWlanAllowSSIDRoaming;

   437             }

   438             break;

   439         case ECmIPAddFromServer:

   440         case EWlanIpAddrFromServer:

   441             {

   442             retVal = serviceRecord->iIpAddrFromServer;

   443             }

   444             break;

   445         case ECmIPDNSAddrFromServer:

   446         case EWlanIpDNSAddrFromServer:

   447             {

   448             retVal = serviceRecord->iIpDnsAddrFromServer;

   449             }

   450             break;

   451         case ECmIP6DNSAddrFromServer:

   452         case EWlanIp6DNSAddrFromServer:

   453             {

   454             retVal = serviceRecord->iIp6DnsAddrFromServer;

   455             }

   456             break;

   457         case EWlanEnableWpaPsk:

   458             {

   459             retVal = static_cast<TBool>( wlanServiceRecord->iWlanEnableWpaPsk );

   460             }

   461             break;

   462         case EWlan802_1xAllowUnencrypted:

   463             {

   464             retVal = static_cast<TBool>( wlanServiceRecord->iWlanWpaKeyLength );//TODO, change typecast to if-else structure?

   465             }

   466             break;

   467         default:

   468             {

   469             User::Leave( KErrNotSupported );

   470             break;

   471             }

   472         }

   473 

   474     OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERBOOLATTRIBUTEL_EXIT );

   475     return retVal;

   476     }

   477 

   478 // --------------------------------------------------------------------------

   479 // CCmPluginWlan::GetBearerStringAttributeL

   480 // --------------------------------------------------------------------------

   481 //

   482 HBufC* CCmPluginWlan::GetBearerStringAttributeL(

   483         TUint32 aAttribute,

   484         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   485         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   486     {

   487     OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERSTRINGATTRIBUTEL_ENTRY );

   488 

   489     HBufC* retVal = NULL;

   490 

   491     CCDWlanServiceRecord* wlanServiceRecord =

   492             static_cast<CCDWlanServiceRecord*>(

   493                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   494 

   495     CCDLANServiceRecord* serviceRecord =

   496             static_cast<CCDLANServiceRecord*>(

   497                     aGenRecordArray[KServiceRecordIndex] );

   498 

   499     switch ( aAttribute )

   500         {

   501         case ECmIFNetworks:

   502         case EWlanIfNetworks:

   503             {

   504             if ( !serviceRecord->iIfNetworks.IsNull() )

   505                 {

   506                 retVal = ( serviceRecord->iIfNetworks.GetL() ).AllocL();

   507                 }

   508             }

   509             break;

   510         case ECmIPNetmask:

   511         case EWlanIpNetMask:

   512             {

   513             if ( !serviceRecord->iIpNetmask.IsNull() )

   514                 {

   515                 retVal = ( serviceRecord->iIpNetmask.GetL() ).AllocL();

   516                 }

   517             }

   518             break;

   519         case ECmIPGateway:

   520         case EWlanIpGateway:

   521             {

   522             if ( !serviceRecord->iIpGateway.IsNull() )

   523                 {

   524                 retVal = ( serviceRecord->iIpGateway.GetL() ).AllocL();

   525                 }

   526             }

   527             break;

   528         case ECmIPAddress:

   529         case EWlanIpAddr:

   530             {

   531             if ( !serviceRecord->iIpAddr.IsNull() )

   532                 {

   533                 retVal = ( serviceRecord->iIpAddr.GetL() ).AllocL();

   534                 }

   535             }

   536             break;

   537         case ECmIPNameServer1:

   538         case EWlanIpNameServer1:

   539             {

   540             if ( !serviceRecord->iIpNameServer1.IsNull() )

   541                 {

   542                 retVal = ( serviceRecord->iIpNameServer1.GetL() ).AllocL();

   543                 }

   544             }

   545             break;

   546         case ECmIPNameServer2:

   547         case EWlanIpNameServer2:

   548             {

   549             if ( !serviceRecord->iIpNameServer2.IsNull() )

   550                 {

   551                 retVal = ( serviceRecord->iIpNameServer2.GetL() ).AllocL();

   552                 }

   553             }

   554             break;

   555         case ECmIP6NameServer1:

   556         case EWlanIp6NameServer1:

   557             {

   558             if ( !serviceRecord->iIp6NameServer1.IsNull() )

   559                 {

   560                 retVal = ( serviceRecord->iIp6NameServer1.GetL() ).AllocL();

   561                 }

   562             }

   563             break;

   564         case ECmIP6NameServer2:

   565         case EWlanIp6NameServer2:

   566             {

   567             if ( !serviceRecord->iIp6NameServer2.IsNull() )

   568                 {

   569                 retVal = ( serviceRecord->iIp6NameServer2.GetL() ).AllocL();

   570                 }

   571             }

   572             break;

   573         case ECmIPAddrLeaseValidFrom:

   574         case EWlanIpAddrLeaseValidFrom:

   575             {

   576             if ( !serviceRecord->iIpAddrLeaseValidFrom.IsNull() )

   577                 {

   578                 retVal = ( serviceRecord->iIpAddrLeaseValidFrom.GetL() ).AllocL();

   579                 }

   580             }

   581             break;

   582         case ECmIPAddrLeaseValidTo:

   583         case EWlanIpAddrLeaseValidTo:

   584             {

   585             if ( !serviceRecord->iIpAddrLeaseValidTo.IsNull() )

   586                 {

   587                 retVal = ( serviceRecord->iIpAddrLeaseValidTo.GetL() ).AllocL();

   588                 }

   589             }

   590             break;

   591         case ECmConfigDaemonManagerName:

   592         case EWlanConfigDaemonManagerName:

   593             {

   594             if ( !serviceRecord->iConfigDaemonManagerName.IsNull() )

   595                 {

   596                 retVal = ( serviceRecord->iConfigDaemonManagerName.GetL() ).AllocL();

   597                 }

   598             }

   599             break;

   600         case ECmConfigDaemonName:

   601         case EWlanConfigDaemonName:

   602             {

   603             if ( !serviceRecord->iConfigDaemonName.IsNull() )

   604                 {

   605                 retVal = ( serviceRecord->iConfigDaemonName.GetL() ).AllocL();

   606                 }

   607             }

   608             break;

   609         case EWlanServiceExtensionTableName:

   610             {

   611             if ( !serviceRecord->iServiceExtensionTableName.IsNull() )

   612                 {

   613                 retVal = ( serviceRecord->iServiceExtensionTableName.GetL() ).AllocL();

   614                 }

   615             }

   616             break;

   617         case EWlanSSID:

   618             {

   619             if ( !wlanServiceRecord->iWLanSSID.IsNull() )

   620                 {

   621                 retVal = ( wlanServiceRecord->iWLanSSID.GetL() ).AllocL();

   622                 }

   623             }

   624             break;

   625         case EWlanUsedSSID:

   626             {

   627             if ( !wlanServiceRecord->iWLanUsedSSID.IsNull() )

   628                 {

   629                 retVal = ( wlanServiceRecord->iWLanUsedSSID.GetL() ).AllocL();

   630                 }

   631             }

   632             break;

   633         default:

   634             {

   635             User::Leave( KErrNotSupported );

   636             }

   637             break;

   638         }

   639 

   640     OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERSTRINGATTRIBUTEL_EXIT );

   641     return retVal;

   642     }

   643 

   644 // --------------------------------------------------------------------------

   645 // CCmPluginWlan::GetBearerString8AttributeL

   646 // --------------------------------------------------------------------------

   647 //

   648 HBufC8* CCmPluginWlan::GetBearerString8AttributeL(

   649         TUint32 aAttribute,

   650         RPointerArray<CommsDat::CCDRecordBase>& /*aGenRecordArray*/,

   651         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   652     {

   653     OstTraceFunctionEntry0( CCMPLUGINWLAN_GETBEARERSTRING8ATTRIBUTEL_ENTRY );

   654 

   655     HBufC8* retVal( NULL );

   656 

   657     CCDWlanServiceRecord* wlanServiceRecord =

   658             static_cast<CCDWlanServiceRecord*>(

   659                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   660 

   661     switch ( aAttribute )

   662         {

   663         case EWlanWpaPreSharedKey:

   664             {

   665             if ( !wlanServiceRecord->iWLanWpaPreSharedKey.IsNull() )

   666                 {

   667                 retVal = ( wlanServiceRecord->iWLanWpaPreSharedKey.GetL() ).AllocL();

   668                 }

   669             }

   670             break;

   671         case EWlanWepKey1InHex:

   672             {

   673             if ( !wlanServiceRecord->iWlanFormatKey1.IsNull() &&

   674                     !wlanServiceRecord->iWLanWepKey1.IsNull() )

   675                 {

   676                 if ( wlanServiceRecord->iWlanFormatKey1 == EWlanWepKeyFormatAscii )

   677                     {

   678                     // Format is ascii.

   679                     retVal = ConvertAsciiToHexL( wlanServiceRecord->iWLanWepKey1.GetL() );

   680                     }

   681                 else

   682                     {

   683                     // Format is hex.

   684                     retVal = ( wlanServiceRecord->iWLanWepKey1.GetL() ).AllocL();

   685                     }

   686                 }

   687             }

   688             break;

   689         case EWlanWepKey2InHex:

   690             {

   691             if ( !wlanServiceRecord->iWlanFormatKey2.IsNull() &&

   692                     !wlanServiceRecord->iWLanWepKey2.IsNull() )

   693                 {

   694                 if ( wlanServiceRecord->iWlanFormatKey2 == EWlanWepKeyFormatAscii )

   695                     {

   696                     // Format is ascii.

   697                     retVal = ConvertAsciiToHexL( wlanServiceRecord->iWLanWepKey2.GetL() );

   698                     }

   699                 else

   700                     {

   701                     // Format is hex.

   702                     retVal = ( wlanServiceRecord->iWLanWepKey2.GetL() ).AllocL();

   703                     }

   704                 }

   705             }

   706             break;

   707         case EWlanWepKey3InHex:

   708             {

   709             if ( !wlanServiceRecord->iWlanFormatKey3.IsNull() &&

   710                     !wlanServiceRecord->iWLanWepKey3.IsNull() )

   711                 {

   712                 if ( wlanServiceRecord->iWlanFormatKey3 == EWlanWepKeyFormatAscii )

   713                     {

   714                     // Format is ascii.

   715                     retVal = ConvertAsciiToHexL( wlanServiceRecord->iWLanWepKey3.GetL() );

   716                     }

   717                 else

   718                     {

   719                     // Format is hex.

   720                     retVal = ( wlanServiceRecord->iWLanWepKey3.GetL() ).AllocL();

   721                     }

   722                 }

   723             }

   724             break;

   725         case EWlanWepKey4InHex:

   726             {

   727             if ( !wlanServiceRecord->iWlanFormatKey4.IsNull() &&

   728                     !wlanServiceRecord->iWLanWepKey4.IsNull() )

   729                 {

   730                 if ( wlanServiceRecord->iWlanFormatKey4 == EWlanWepKeyFormatAscii )

   731                     {

   732                     // Format is ascii.

   733                     retVal = ConvertAsciiToHexL( wlanServiceRecord->iWLanWepKey4.GetL() );

   734                     }

   735                 else

   736                     {

   737                     // Format is hex.

   738                     retVal = ( wlanServiceRecord->iWLanWepKey4.GetL() ).AllocL();

   739                     }

   740                 }

   741             }

   742             break;

   743         case EWlanWepKey1InAscii:

   744             {

   745             if ( !wlanServiceRecord->iWlanFormatKey1.IsNull() &&

   746                     !wlanServiceRecord->iWLanWepKey1.IsNull() )

   747                 {

   748                 if ( wlanServiceRecord->iWlanFormatKey1 == EWlanWepKeyFormatAscii )

   749                     {

   750                     // Format is ascii.

   751                     retVal = ( wlanServiceRecord->iWLanWepKey1.GetL() ).AllocL();

   752                     }

   753                 else

   754                     {

   755                     // Format is hex.

   756                     retVal = ConvertHexToAsciiL( wlanServiceRecord->iWLanWepKey1.GetL() );

   757                     }

   758                 }

   759             }

   760             break;

   761         case EWlanWepKey2InAscii:

   762             {

   763             if ( !wlanServiceRecord->iWlanFormatKey2.IsNull() &&

   764                     !wlanServiceRecord->iWLanWepKey2.IsNull() )

   765                 {

   766                 if ( wlanServiceRecord->iWlanFormatKey2 == EWlanWepKeyFormatAscii )

   767                     {

   768                     // Format is ascii.

   769                     retVal = ( wlanServiceRecord->iWLanWepKey2.GetL() ).AllocL();

   770                     }

   771                 else

   772                     {

   773                     // Format is hex.

   774                     retVal = ConvertHexToAsciiL( wlanServiceRecord->iWLanWepKey2.GetL() );

   775                     }

   776                 }

   777             }

   778             break;

   779         case EWlanWepKey3InAscii:

   780             {

   781             if ( !wlanServiceRecord->iWlanFormatKey3.IsNull() &&

   782                     !wlanServiceRecord->iWLanWepKey3.IsNull() )

   783                 {

   784                 if ( wlanServiceRecord->iWlanFormatKey3 == EWlanWepKeyFormatAscii )

   785                     {

   786                     // Format is ascii.

   787                     retVal = ( wlanServiceRecord->iWLanWepKey3.GetL() ).AllocL();

   788                     }

   789                 else

   790                     {

   791                     // Format is hex.

   792                     retVal = ConvertHexToAsciiL( wlanServiceRecord->iWLanWepKey3.GetL() );

   793                     }

   794                 }

   795             }

   796             break;

   797         case EWlanWepKey4InAscii:

   798             {

   799             if ( !wlanServiceRecord->iWlanFormatKey4.IsNull() &&

   800                     !wlanServiceRecord->iWLanWepKey4.IsNull() )

   801                 {

   802                 if ( wlanServiceRecord->iWlanFormatKey4 == EWlanWepKeyFormatAscii )

   803                     {

   804                     // Format is ascii.

   805                     retVal = ( wlanServiceRecord->iWLanWepKey4.GetL() ).AllocL();

   806                     }

   807                 else

   808                     {

   809                     // Format is hex.

   810                     retVal = ConvertHexToAsciiL( wlanServiceRecord->iWLanWepKey4.GetL() );

   811                     }

   812                 }

   813             }

   814             break;

   815         case EWlanWapiPsk:

   816             {

   817             if ( !wlanServiceRecord->iWLanWpaPreSharedKey.IsNull() )

   818                 {

   819                 retVal = ( wlanServiceRecord->iWLanWpaPreSharedKey.GetL() ).AllocL();

   820                 }

   821             }

   822             break;

   823 

   824         default:

   825             {

   826             User::Leave( KErrNotSupported );

   827             }

   828             break;

   829         }

   830 

   831     OstTraceFunctionExit0( CCMPLUGINWLAN_GETBEARERSTRING8ATTRIBUTEL_EXIT );

   832     return retVal;

   833     }

   834 

   835 // --------------------------------------------------------------------------

   836 // CCmPluginWlan::SetBearerIntAttributeL

   837 // --------------------------------------------------------------------------

   838 //

   839 void CCmPluginWlan::SetBearerIntAttributeL(

   840         TUint32 aAttribute,

   841         TUint32 aValue,

   842         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   843         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   844     {

   845     OstTraceFunctionEntry0( CCMPLUGINWLAN_SETBEARERINTATTRIBUTEL_ENTRY );

   846 

   847     CCDLANServiceRecord* serviceRecord =

   848             static_cast<CCDLANServiceRecord*>(

   849                     aGenRecordArray[KServiceRecordIndex] );

   850 

   851     CCDWlanServiceRecord* wlanServiceRecord =

   852             static_cast<CCDWlanServiceRecord*>(

   853                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   854 

   855     switch ( aAttribute )

   856         {

   857         case ECmExtensionLevel:

   858         case ECmCommsDBBearerType:

   859         case ECmDefaultUiPriority:

   860         case ECmDefaultPriority:

   861             {

   862             User::Leave( KErrArgument );

   863             }

   864             break;

   865         case EWlanServiceId:

   866             {

   867             wlanServiceRecord->iWlanServiceId.SetL( aValue );

   868             }

   869             break;

   870         case EWlanConnectionMode:

   871             {

   872             wlanServiceRecord->iWlanConnMode.SetL( aValue );

   873             }

   874             break;

   875         case EWlanSecurityMode:

   876             {

   877             CheckSecurityAttributeValidityL( aAttribute, aValue );

   878             wlanServiceRecord->iWlanSecMode.SetL( aValue );

   879             // When setting security mode, also reset authentication mode to open.

   880             wlanServiceRecord->iWlanAuthMode.SetL( CMManager::EWlanAuthModeOpen );

   881             if ( aValue == EWlanSecMode802_1x )

   882                 {

   883                 // By default, do not allow unencrypted mode for 802.1x (Korea).

   884                 wlanServiceRecord->iWlanWpaKeyLength.SetL( 0 );

   885                 }

   886             }

   887             break;

   888         case EWlanAuthenticationMode:

   889             {

   890             CheckSecurityAttributeValidityL( aAttribute, aValue );

   891             wlanServiceRecord->iWlanAuthMode.SetL( aValue );

   892             }

   893             break;

   894         case EWlanChannelID:

   895             {

   896             wlanServiceRecord->iWlanChannelID.SetL( aValue );

   897             }

   898             break;

   899         case EWlanServiceExtensionTableRecordId:

   900             {

   901             serviceRecord->iServiceExtensionTableRecordId.SetL( aValue );

   902             }

   903             break;

   904         case EWlanWepKeyIndex:

   905             {

   906             CheckSecurityAttributeValidityL( aAttribute, aValue );

   907             wlanServiceRecord->iWlanWepIndex.SetL( aValue );

   908             }

   909             break;

   910         case EWlanWapiPskFormat:

   911             {

   912             CheckSecurityAttributeValidityL( aAttribute, aValue );

   913             wlanServiceRecord->iWlanFormatKey1.SetL( aValue );

   914             }

   915             break;

   916         default:

   917             {

   918             User::Leave( KErrNotSupported );

   919             }

   920             break;

   921         }

   922 

   923     OstTraceFunctionExit0( CCMPLUGINWLAN_SETBEARERINTATTRIBUTEL_EXIT );

   924     }

   925 

   926 // --------------------------------------------------------------------------

   927 // CCmPluginWlan::SetBearerBoolAttributeL

   928 // --------------------------------------------------------------------------

   929 //

   930 void CCmPluginWlan::SetBearerBoolAttributeL(

   931         TUint32 aAttribute,

   932         TBool aValue,

   933         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

   934         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

   935     {

   936     OstTraceFunctionEntry0( CCMPLUGINWLAN_SETBEARERBOOLATTRIBUTEL_ENTRY );

   937 

   938     CCDWlanServiceRecord* wlanServiceRecord =

   939             static_cast<CCDWlanServiceRecord*>(

   940                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

   941 

   942     CCDLANServiceRecord* serviceRecord =

   943             static_cast<CCDLANServiceRecord*>(

   944                     aGenRecordArray[KServiceRecordIndex] );

   945 

   946     switch ( aAttribute )

   947         {

   948         case EWlanScanSSID:

   949             {

   950             wlanServiceRecord->iWlanScanSSID.SetL( aValue );

   951             }

   952             break;

   953         case EWlanAllowSSIDRoaming:

   954             {

   955             wlanServiceRecord->iWlanAllowSSIDRoaming.SetL( aValue );

   956             }

   957             break;

   958         case ECmIPAddFromServer:

   959         case EWlanIpAddrFromServer:

   960             {

   961             serviceRecord->iIpAddrFromServer.SetL( aValue );

   962             }

   963             break;

   964         case ECmIPDNSAddrFromServer:

   965         case EWlanIpDNSAddrFromServer:

   966             {

   967             serviceRecord->iIpDnsAddrFromServer.SetL( aValue );

   968             }

   969             break;

   970         case ECmIP6DNSAddrFromServer:

   971         case EWlanIp6DNSAddrFromServer:

   972             {

   973             serviceRecord->iIp6DnsAddrFromServer.SetL( aValue );

   974             }

   975             break;

   976         case EWlanEnableWpaPsk:

   977             {

   978             wlanServiceRecord->iWlanEnableWpaPsk.SetL( static_cast<TUint>( aValue ) );

   979             }

   980             break;

   981         case EWlan802_1xAllowUnencrypted:

   982             {

   983             wlanServiceRecord->iWlanWpaKeyLength.SetL( static_cast<TUint>( aValue ) );

   984             }

   985             break;

   986         default:

   987             {

   988             User::Leave( KErrNotSupported );

   989             }

   990             break;

   991         }

   992 

   993     OstTraceFunctionExit0( CCMPLUGINWLAN_SETBEARERBOOLATTRIBUTEL_EXIT );

   994     }

   995 

   996 // --------------------------------------------------------------------------

   997 // CCmPluginWlan::SetBearerStringAttributeL

   998 // --------------------------------------------------------------------------

   999 //

  1000 void CCmPluginWlan::SetBearerStringAttributeL(

  1001         TUint32 aAttribute,

  1002         const TDesC16& aValue,

  1003         RPointerArray<CommsDat::CCDRecordBase>& aGenRecordArray,

  1004         RPointerArray<CommsDat::CCDRecordBase>& aBearerSpecRecordArray )

  1005     {

  1006     OstTraceFunctionEntry0( CCMPLUGINWLAN_SETBEARERSTRINGATTRIBUTEL_ENTRY );

  1007 

  1008     CCDWlanServiceRecord* wlanServiceRecord =

  1009             static_cast<CCDWlanServiceRecord*>(

  1010                     aBearerSpecRecordArray[KWlanServiceRecordIndex] );

  1011 

  1012     CCDLANServiceRecord* serviceRecord =

  1013             static_cast<CCDLANServiceRecord*>(

  1014                     aGenRecordArray[KServiceRecordIndex] );

  1015 

  1016     switch ( aAttribute )

  1017         {

  1018         case ECmIFNetworks:

  1019         case EWlanIfNetworks:

  1020             {

  1021             serviceRecord->iIfNetworks.SetL( aValue );

  1022             }

  1023             break;

  1024         case ECmIPNetmask:

  1025         case EWlanIpNetMask:

  1026             {

  1027             serviceRecord->iIpNetmask.SetL( aValue );

  1028             }

  1029             break;

  1030         case ECmIPGateway:

  1031         case EWlanIpGateway:

  1032             {

  1033             serviceRecord->iIpGateway.SetL( aValue );

  1034             }

  1035             break;

  1036         case ECmIPAddress:

  1037         case EWlanIpAddr:

  1038             {

  1039             if ( ( aValue.Compare( KUnspecifiedIPv4 ) == 0 ) ||

  1040                     ( aValue.Compare( KNullDesC ) == 0 ) )

  1041                 {

  1042                 // If unspecified or NULL address is set dynamic

  1043                 // IP must be enabled.

  1044                 SetBearerBoolAttributeL( EWlanIpAddrFromServer,

  1045                                          ETrue,

  1046                                          aGenRecordArray,

  1047                                          aBearerSpecRecordArray );

  1048                 }

  1049             else

  1050                 {

  1051                 // If valid address is set dynamic IP is disabled.

  1052                 SetBearerBoolAttributeL( EWlanIpAddrFromServer,

  1053                                          EFalse,

  1054                                          aGenRecordArray,

  1055                                          aBearerSpecRecordArray );

  1056                 }

  1057             serviceRecord->iIpAddr.SetL( aValue );

  1058             }

  1059             break;

  1060         case ECmIPNameServer1:

  1061         case EWlanIpNameServer1:

  1062             {

  1063             serviceRecord->iIpNameServer1.SetL( aValue );

  1064             }

  1065             break;

  1066         case ECmIPNameServer2:

  1067         case EWlanIpNameServer2:

  1068             {

  1069             serviceRecord->iIpNameServer2.SetL( aValue );

  1070             }

  1071             break;

  1072         case ECmIP6NameServer1:

  1073         case EWlanIp6NameServer1:

  1074             {

  1075             serviceRecord->iIp6NameServer1.SetL( aValue );

  1076             }

  1077             break;

  1078         case ECmIP6NameServer2:

  1079         case EWlanIp6NameServer2:

  1080             {

  1081             serviceRecord->iIp6NameServer2.SetL( aValue );

  1082             }

  1083             break;

  1084         case ECmIPAddrLeaseValidFrom:

  1085         case EWlanIpAddrLeaseValidFrom:

  1086             {

  1087             serviceRecord->iIpAddrLeaseValidFrom.SetL( aValue );

  1088             }

  1089             break;

  1090         case ECmIPAddrLeaseValidTo:

  1091         case EWlanIpAddrLeaseValidTo:

  1092             {

  1093             serviceRecord->iIpAddrLeaseValidTo.SetL( aValue );

  1094             }

  1095             break;

  1096         case ECmConfigDaemonManagerName:

  1097         case EWlanConfigDaemonManagerName:

  1098             {

  1099             serviceRecord->iConfigDaemonManagerName.SetL( aValue );

  1100             }

  1101             break;

  1102         case ECmConfigDaemonName:

  1103         case EWlanConfigDaemonName:

  1104             {

  1105             serviceRecord->iConfigDaemonName.SetL( aValue );

  1106             }

  1107             break;

  1108         case EWlanServiceExtensionTableName:

  1109             {

  1110             serviceRecord->iServiceExtensionTableName.SetL( aValue );

  1111             }

  1112             break;

  1113         case EWlanSSID:

  1114             {

  1115             wlanServiceRecord->iWLanSSID.SetL( aValue );

  1116             }

  1117             break;

  1118         case EWlanUsedSSID:

  1119             {

  1120             wlanServiceRecord->iWLanUsedSSID.SetL( aValue );

  1121             }

  1122             break;

  1123         default:

  1124             {

  1125             User::Leave( KErrNotSupported );

  1126             }

  1127             break;

  1128         }

  1129 

  1130     OstTraceFunctionExit0( CCMPLUGINWLAN_SETBEARERSTRINGATTRIBUTEL_EXIT );

  1131     }

  1132 

  1133 // --------------------------------------------------------------------------

  1134 // CCmPluginWlan::SetBearerString8AttributeL