diff -r 000000000000 -r 5a93021fdf25 dbcreator/commsdatcreator/Src/cdcprocessorwlan.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/dbcreator/commsdatcreator/Src/cdcprocessorwlan.cpp Thu Dec 17 08:55:21 2009 +0200 @@ -0,0 +1,2374 @@ +/* +* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of the class CProcessorWlan +* +*/ + + + + +// INCLUDE FILES + +#include "cdcprocessorwlan.h" +#include "cdclogger.h" +#include "cdcerrors.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace CMManager; + +// CONSTANTS + +// network modes. +_LIT16( KStrAd_hoc, "Ad-hoc" ); +_LIT16( KStrInfrastructure, "Infrastructure" ); // Default value. + +// security modes. +_LIT16( KStrWEP, "WEP" ); +_LIT16( KStr802_1x, "802.1x" ); +_LIT16( KStrWPA, "WPA" ); // WPA/WPA2 mixed mode +_LIT16( KStrWPA2, "WPA2" ); // WPA2-only mode +_LIT16( KStrOpen, "Open" ); // Default value. + +// default WLAN channel Id value +const TInt KDefaultChannelId = 0; +const TInt KMaximumChannelId = 11; + +// default port number +const TUint32 KDefaultPortNum = 0; + +// ratio between sizes of ascii and unicode characters +const TUint KAsciiUnicodeRatio = 2; + +// Length of expanded EAP type identifier +const TUint KExpandedEAPIdLength = 8; + +// Plain MSCHAPv2 EAP identifier. Needed because of special handling +const TUint8 KMschapv2TypeId[] = {0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x63}; + +// ================= MEMBER FUNCTIONS ======================= + +CEapTypeElement::~CEapTypeElement() + { + delete iEapSettings; + delete iName; + } + + +// --------------------------------------------------------- +// CProcessorWlan::NewL +// --------------------------------------------------------- +// +CProcessorWlan* CProcessorWlan::NewL( CReaderBase* aFileReader, + RCmManagerExt& aCmManager, + RPointerArray< RCmConnectionMethodExt >& aPluginArray, + RPointerArray< HBufC >& aPluginNames, + RPointerArray< HBufC >& aSecurityInfo, + RPointerArray< CEapTypeElement >& aEapSettings ) + { + CProcessorWlan* self = new ( ELeave ) CProcessorWlan( aFileReader, + aCmManager, + aPluginArray, + aPluginNames, + aSecurityInfo, + aEapSettings ); + CleanupStack::PushL( self ); + + // From base class + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------- +// CProcessorWlan::ConstructL +// --------------------------------------------------------- +// +void CProcessorWlan::ConstructL() + { + iEmptyTag = KStrEmpty.operator const TDesC16&().Alloc(); + + Reset(); // iWepData, iWpaData + } + + +// --------------------------------------------------------- +// CProcessorWlan::CProcessorWlan +// --------------------------------------------------------- +// +CProcessorWlan::CProcessorWlan( CReaderBase* aFileReader, + RCmManagerExt& aCmManager, + RPointerArray< RCmConnectionMethodExt >& aPluginArray, + RPointerArray< HBufC >& aPluginNames, + RPointerArray< HBufC >& aSecurityInfo, + RPointerArray< CEapTypeElement >& aEapSettings ) : + CProcessorBase( aFileReader, + aCmManager, + aPluginArray, + aPluginNames ), + iSecurityMode( ESecurityModeOpen ), + iEapSettings( aEapSettings ), + iIsEasyWlan( ETrue ) + { + iBearerType = KUidWlanBearerType; + iSecurityInfo = &aSecurityInfo; + iDataStart = 0; + } + + +// --------------------------------------------------------- +// CProcessorWlan::~CProcessorWlan +// --------------------------------------------------------- +// +CProcessorWlan::~CProcessorWlan() + { + delete iEmptyTag; + } + +// --------------------------------------------------------- +// CProcessorWlan::ProcessSpecialFieldsL +// --------------------------------------------------------- +// +void CProcessorWlan::ProcessSpecialFieldsL( TInt aField, HBufC* aPtrTag, TInt /*aDx*/ ) + { + switch( aField ) + { + // TDesC16 + case EWlanSSID: + { + if ( aPtrTag->CompareF( KStrEmpty ) != 0 ) + { + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + iIsEasyWlan = EFalse; + } + else + { + // Access point is Easy WLAN + iIsEasyWlan = ETrue; + } + break; + } + case EWlanIpAddr: + { + if ( aPtrTag->CompareF( KStrEmpty ) != 0 ) + { + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + } + break; + } + // TDesC16 + case EWlanIpGateway: //fall through + case EWlanIpNetMask: //fall through + { + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + break; + } + case EWlanIpNameServer1: //fall through + case EWlanIpNameServer2: //fall through + case EWlanIp6NameServer1: //fall through + case EWlanIp6NameServer2: //fall through + { + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + SetAddressFromServerL( EWlanIpNameServer1, + EWlanIpNameServer2, + EWlanIpDNSAddrFromServer, + EWlanIp6NameServer1, + EWlanIp6NameServer2, + EWlanIp6DNSAddrFromServer ); + break; + } + // TUint32 + case EWlanSecurityMode: + { + + if ( aPtrTag->CompareF( KStrWEP ) == 0 ) + { + // WEP + iPlugin.SetIntAttributeL( aField, EWlanSecModeWep ); + iSecurityMode = ESecurityModeWEP; + } + else if ( aPtrTag->CompareF( KStr802_1x ) == 0 ) + { + // 802.1x + iPlugin.SetIntAttributeL( aField, EWlanSecMode802_1x ); + iSecurityMode = ESecurityMode802; + } + else if ( aPtrTag->CompareF( KStrWPA ) == 0 ) + { + // WPA/WPA2 mixed mode + iPlugin.SetIntAttributeL( aField, EWlanSecModeWpa ); + iSecurityMode = ESecurityModeWPA; + } + else if ( aPtrTag->CompareF( KStrWPA2 ) == 0 ) + { + // WPA2 + iPlugin.SetIntAttributeL( aField, EWlanSecModeWpa2 ); + iSecurityMode = ESecurityModeWPA2; + } + else if ( aPtrTag->CompareF( KStrOpen ) == 0 ) + { + // Open network (default) + iPlugin.SetIntAttributeL( aField, EWlanSecModeOpen ); + iSecurityMode = ESecurityModeOpen; + } + else + { + iPlugin.SetIntAttributeL( aField, EWlanSecModeOpen ); + iSecurityMode = ESecurityModeOpen; + CLOG_WRITE( "! Error : Invalid Security Mode. Default:Open" ) + } + break; + } + + // TUint32 + case EWlanConnectionMode: + { + + if ( !aPtrTag->CompareF( KStrAd_hoc ) ) + { + // Ad-hoc + iPlugin.SetIntAttributeL( aField, EAdhoc ); + } + else if ( !aPtrTag->CompareF( KStrInfrastructure ) ) + { + // Infrastructure + iPlugin.SetIntAttributeL( aField, EInfra ); + } + else + { + iPlugin.SetIntAttributeL( aField, EInfra ); + CLOG_WRITE( "! Error : Invalid Network Mode. Default:Infrastructure" ) + } + break; + } + + // TUint32 + case ECmProxyPortNumber: + { + // First set proxy usage to enabled + if( !iProxyEnabled ) + { + iPlugin.SetBoolAttributeL( ECmProxyUsageEnabled, ETrue ); + iProxyEnabled = ETrue; + } + TLex16 lex( *aPtrTag ); + TUint32 tmp( 0 ); + if ( lex.Val( tmp, EDecimal ) == KErrNone ) + { + iPlugin.SetIntAttributeL( aField, tmp ); + } + else + { + //no valid data is given + iPlugin.SetIntAttributeL( aField, KDefaultPortNum ); + CLOG_WRITE( "! Error : Invalid port number. Default:0" ); + } + break; + } + // Long text. + case ECmStartPage: + { + + if ( aPtrTag->CompareF( KStrEmpty ) != 0 ) + { + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + } + break; + } + + case ECmProxyProtocolName: + { + // Do not enable proxy in this case yet + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + break; + } + + // Long text. + case ECmProxyServerName: + { + // First set proxy usage to enabled + if( !iProxyEnabled ) + { + iPlugin.SetBoolAttributeL( ECmProxyUsageEnabled, ETrue ); + iProxyEnabled = ETrue; + } + iPlugin.SetStringAttributeL( aField, *aPtrTag ); + break; + } + // Bool + case EWlanScanSSID: + { + if ( !aPtrTag->CompareF( KStrYes ) ) + { + iPlugin.SetBoolAttributeL( aField, ETrue ); + } + else if ( !aPtrTag->CompareF( KStrNo ) ) + { + iPlugin.SetBoolAttributeL( aField, EFalse ); + } + else + { + iPlugin.SetBoolAttributeL( aField, EFalse ); + CLOG_WRITE( "! Error : Invalid Scan SSID. Default:No" ) + } + break; + } + + // TUint32 + case EWlanChannelID: + { + TLex16 lex( *aPtrTag ); + TUint32 tmp( 0 ); + lex.Val( tmp, EDecimal ); + + if( tmp <= KMaximumChannelId ) + { + iPlugin.SetIntAttributeL( aField, tmp ); + } + else + { + // Default value + iPlugin.SetIntAttributeL( aField, KDefaultChannelId ); + CLOG_WRITE( "! Error : Invalid Chanel Id. Default:0" ) + } + break; + } + //WEP + case EWEPKeyInUse: + case EWEPAuthType: + case EWEPKey1Length: + case EWEPKey1Format: + case EWEPKey1Data: + case EWEPKey2Length: + case EWEPKey2Format: + case EWEPKey2Data: + case EWEPKey3Length: + case EWEPKey3Format: + case EWEPKey3Data: + case EWEPKey4Length: + case EWEPKey4Format: + case EWEPKey4Data: + { + if( iSecurityMode == ESecurityModeWEP ) + { + AddSecurityDataL( aField, aPtrTag, ETrue ); + } + } + break; + //WPA + case EWPAPresharedKey: + case EWPAKeyLength: + case EWPAListOfEAPs: + case EWPAUseOfPresharedKey: + { + if( iSecurityMode != ESecurityModeWEP && iSecurityMode != ESecurityModeOpen ) + { + AddSecurityDataL( aField, aPtrTag, EFalse ); + } + } + break; + + default: + // Check if this is EAP setting + if ( EAPSetting( aField ) ) + { + AddEAPSettingL( aField, aPtrTag ); + } + else + { + CLOG_WRITE_FORMAT( "! Warning: Unhandled setting for WLAN: %d", aField ); + } + break; + }//switch + } + + +// --------------------------------------------------------- +// CProcessorWlan::ProcessAPL +// --------------------------------------------------------- +// +void CProcessorWlan::ProcessAPL() + { + + RCmConnectionMethodExt& iPlugin = GetLastPluginL(); + + if( iIsProtected ) + { + iPlugin.SetBoolAttributeL( ECmProtected, ETrue ); + } + + // Ensure that Easy WLAN is always an open network + if( iIsEasyWlan ) + { + iSecurityMode = ESecurityModeOpen; + } + + FillSecurityInfoL(); + + // Writes into the log file. + DoLogL(); + + Reset(); // iWepData, iWpaData + } + +// --------------------------------------------------------- +// CProcessorWlan::ProcessAPL +// --------------------------------------------------------- +// +void CProcessorWlan::FillSecurityInfoL() + { + //Set Security mode settings + switch ( iSecurityMode ) + { + case ESecurityModeWEP: + if ( WEPFieldValidate() ) + { + FillSecurityInfoL( ETrue ); //WEP + } + else + { + CLOG_WRITE( "! Error : WEP settings are not valid." ) + } + break; + case ESecurityMode802: + case ESecurityModeWPA: + case ESecurityModeWPA2: + { + FillSecurityInfoL( EFalse ); //WPA + break; + } + default: + { + } + break; + } + } + +// --------------------------------------------------------- +// CProcessorWlan::ProcessAPL +// --------------------------------------------------------- +// +void CProcessorWlan::FillSecurityInfoL( TBool aIsWep ) + { + // iName has been deleted by Base. Name is retrieved from name array. + TInt lastPos = iPluginArray->Count() - 1; + HBufC* name = (*iPluginName)[ lastPos ]; + + // Name appended to the array + iSecurityInfo->Append( name->AllocL() ); + CLOG_WRITE_FORMAT( "FillSecurityInfoL %S", name ); + CLOG_WRITE_FORMAT( "FillSecurityInfoL start %d", iSecurityInfo->Count() ); + + if( aIsWep ) + { + // Security type appended to the array + iSecurityInfo->Append( KStrWEP.operator const TDesC16&().Alloc() ); + for( TInt i( 0 ); i < KWEPKeyNumOfFields; i++ ) + { + + if( iWepData[i] != NULL ) + { + CLOG_WRITE_FORMAT( "wep info %S", iWepData[i] ); + } + else + { + CLOG_WRITE( "wep info NULL" ); + } + iSecurityInfo->Append( iWepData[i] ); + } + } + else + { + // Security type appended to the array + switch ( iSecurityMode ) + { + case ESecurityMode802: + iSecurityInfo->Append( KStr802_1x.operator const TDesC16&().Alloc() ); + break; + case ESecurityModeWPA2: + iSecurityInfo->Append( KStrWPA2.operator const TDesC16&().Alloc() ); + break; + default: + iSecurityInfo->Append( KStrWPA.operator const TDesC16&().Alloc() ); + break; + } + + for( TInt i( 0 ); i < KWPAKeyNumOfFields; i++ ) + { + + if( iWpaData[i] != NULL ) + { + CLOG_WRITE_FORMAT( "wpa info %S", iWpaData[i] ); + } + else + { + CLOG_WRITE( "wep info NULL" ); + } + iSecurityInfo->Append( iWpaData[ i ] ); + } + } + + CLOG_WRITE_FORMAT( "FillSecurityInfoL end %d", iSecurityInfo->Count() ); + } + +// --------------------------------------------------------- +// CProcessorWlan::SaveSecurityInfoL +// --------------------------------------------------------- +// +void CProcessorWlan::SaveSecurityInfoL() + { + TInt i(0); + + while( i < iSecurityInfo->Count() ) + { + if( (*iSecurityInfo)[i] != NULL ) + { + CLOG_WRITE_FORMAT( "Sec Info: %S", (*iSecurityInfo)[i] ); + } + else + { + CLOG_WRITE( "Sec Info: NULL" ); + } + + i++; + } + + + i = 0; + + while( i < iSecurityInfo->Count() ) + { + CLOG_WRITE_FORMAT( "SaveSecurityInfoL %S", (*iSecurityInfo)[i] ); + + TInt id = GetPluginIdL( (*iSecurityInfo)[i] ); + if( id != KErrNotFound ) + { + i++; + SaveSecurityInfoL( i, id ); + } + else + { + CLOG_WRITE_FORMAT( "WLan IAp cannot find %S", (*iSecurityInfo)[i] ); + CLOG_WRITE( "Security save likely collapsed" ); + // Tries to look for an existing IAP. + i++; + } + } + + // EAP settings + CLOG_WRITE( "Starting EAP settings saving" ); + CMDBSession* session = CMDBSession::NewL( CMDBSession::LatestVersion() ); + CleanupStack::PushL( session ); + + // Load IAP record in order to get the service id + for ( i = 0; i < iEapSettings.Count() ; i++ ) + { + CEapTypeElement* eap = iEapSettings[i]; + // + TInt id = GetPluginIdL( eap->iName ); + + CCDIAPRecord* iapRecord = static_cast< CCDIAPRecord * > + ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) ); + + CleanupStack::PushL( iapRecord ); + + iapRecord->SetRecordId( id ); + + iapRecord->LoadL( *session ); + + TInt serviceId = iapRecord->iService; + + CleanupStack::PopAndDestroy( iapRecord ); + + TInt err = KErrNone; + TUint8 expandedEapId[] = {0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + TBuf8 cue; + + // Set-up 64-bit expanded EAP id + if ( eap->iEapSettings->iEAPType == KMschapv2TypeId[7] ) + { + // This is plain MSCHAPv2. Set vendor ID correctly + expandedEapId[1] = KMschapv2TypeId[1]; + expandedEapId[2] = KMschapv2TypeId[2]; + expandedEapId[3] = KMschapv2TypeId[3]; + } + + expandedEapId[KExpandedEAPIdLength - 1] = static_cast ( eap->iEapSettings->iEAPType ); + cue.Copy( expandedEapId, KExpandedEAPIdLength ); + + // Try loading EAP ECOM module + CLOG_WRITE_FORMAT( "Try to load EAP module: %d", expandedEapId[7]); + CEapType* eapType = 0; + TRAP( err, eapType = CEapType::NewL( cue, ELan, serviceId ) ); + // The error is caused by probably missing EAP method from the device. Ignore the error + // because same scripts can be used for devices with and without certain methods. + if( err == KErrNone ) + { + CleanupStack::PushL( eapType ); + + // Check if this type is tunneled + if ( eap->iEncapsulatingEapId != EAPSettings::EEapNone ) + { + // It is tunneled. Take the last byte of the expanded id. + eapType->SetTunnelingType( eap->iEncapsulatingEapId ); + } + CLOG_WRITE( "Calling eapType->SetConfiguration" ); + eapType->SetConfigurationL( *eap->iEapSettings ); + CLOG_WRITE( "eapType->SetConfiguration success!" ); + CleanupStack::PopAndDestroy( eapType ); + } + } + + session->Close(); + CleanupStack::PopAndDestroy( session ); + CLOG_WRITE( "Finished EAP settings saving" ); + //iEapSettings.ResetAndDestroy(); + + CLOG_WRITE_FORMAT( "SaveSecurityInfoL end %d", iSecurityInfo->Count() ); +} + +// --------------------------------------------------------- +// CProcessorWlan::SaveSecurityInfoL +// --------------------------------------------------------- +// +void CProcessorWlan::SaveSecurityInfoL( TInt& aCounter, TInt aId ) + { + if( (*iSecurityInfo)[ aCounter ]->Compare( KStrWEP ) == 0 ) + { + aCounter++; + TInt end( aCounter + KWEPKeyNumOfFields ); + + for( TInt index(0); aCounter < end; aCounter++, index++ ) + { + if( (*iSecurityInfo)[ aCounter ] != NULL ) + { + CLOG_WRITE_FORMAT( "wep info %S", (*iSecurityInfo)[ aCounter ] ); + } + else + { + CLOG_WRITE( "wep info NULL" ); + } + iWepData[ index] = (*iSecurityInfo)[ aCounter ] ; + } + SaveWEPL( aId ); + } + else + { + + // Set security mode. + if ( (*iSecurityInfo)[ aCounter ]->CompareF( KStr802_1x ) == 0 ) + { + // 802.1x + iSecurityMode = ESecurityMode802; + } + else if ( (*iSecurityInfo)[ aCounter ]->CompareF( KStrWPA2 ) == 0 ) + { + // WPA2 mode + iSecurityMode = ESecurityModeWPA2; + } + else + { + // WPA + iSecurityMode = ESecurityModeWPA; + } + + aCounter++; + TInt end( aCounter + KWPAKeyNumOfFields ); + + for( TInt index(0); aCounter < end; aCounter++, index++ ) + { + if( (*iSecurityInfo)[ aCounter ] != NULL ) + { + CLOG_WRITE_FORMAT( "wpa info %S", (*iSecurityInfo)[ aCounter ] ); + } + else + { + CLOG_WRITE( "wpa info NULL" ); + } + iWpaData[ index ] = (*iSecurityInfo)[ aCounter ] ; + } + SaveWPAL( aId ); + } + } + + + +// --------------------------------------------------------- +// WEP Security settings +// --------------------------------------------------------- + +// --------------------------------------------------------- +// CProcessorWlan::SaveWEPL +// --------------------------------------------------------- +// +void CProcessorWlan::SaveWEPL( TUint32 aIapId ) + { + CMDBSession* session = CMDBSession::NewL( CMDBSession::LatestVersion() ); + CleanupStack::PushL( session ); + // Load IAP record + CCDIAPRecord* iapRecord = static_cast< CCDIAPRecord * > + ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) ); + CleanupStack::PushL( iapRecord ); + iapRecord->SetRecordId( aIapId ); + iapRecord->LoadL( *session ); + + // Load WLAN service table + // first get WLAN table id + CMDBGenericRecord* generic = static_cast + ( CCDRecordBase::RecordFactoryL( 0 ) ); + CleanupStack::PushL( generic ); + generic->InitializeL( TPtrC( WLAN_SERVICE ), NULL ); + generic->LoadL( *session ); + TMDBElementId wlanTableId = generic->TableId(); + + CMDBField* sidField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanServiceId ) ); + + TInt service = iapRecord->iService; + // prime with service id + *sidField = (TUint32)service; + + User::LeaveIfError( generic->FindL( *session ) ); + + // Save index of key in use + TUint32 keyInUse( WEPKeyInUse() ); + CMDBField* keyInUseField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWepIndex ) ); + keyInUseField->SetL( keyInUse ); + + // Save authentication mode + TUint32 auth( WEPAuthentication() ); + CMDBField* authenticationField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanAuthMode ) ); + authenticationField->SetL( auth ); + + // Save WEP keys and key formats + if ( WEPFieldData( EWEPKey1Data )->Length() ) + { + CMDBField* wepKey1Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWepKey1 ) ); + WriteKeyL( wepKey1Field, + WEPFieldData( EWEPKey1Data ), + WEPKeyFormat( EWEPKey1Format ) ); + CMDBField* formatKey1Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanFormatKey1 ) ); + formatKey1Field->SetL( WEPKeyFormat( EWEPKey1Format ) ); + } + if ( WEPFieldData( EWEPKey2Data )->Length() ) + { + CMDBField* wepKey2Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWepKey2 ) ); + WriteKeyL( wepKey2Field, + WEPFieldData( EWEPKey2Data ), + WEPKeyFormat( EWEPKey2Format ) ); + CMDBField* formatKey2Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanFormatKey2 ) ); + formatKey2Field->SetL( WEPKeyFormat( EWEPKey2Format ) ); + } + if ( WEPFieldData( EWEPKey3Data )->Length() ) + { + CMDBField* wepKey3Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWepKey3 ) ); + WriteKeyL( wepKey3Field, + WEPFieldData( EWEPKey3Data ), + WEPKeyFormat( EWEPKey3Format ) ); + CMDBField* formatKey3Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanFormatKey3 ) ); + formatKey3Field->SetL( WEPKeyFormat( EWEPKey3Format ) ); + } + if ( WEPFieldData( EWEPKey4Data )->Length() ) + { + CMDBField* wepKey4Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWepKey4 ) ); + WriteKeyL( wepKey4Field, + WEPFieldData( EWEPKey4Data ), + WEPKeyFormat( EWEPKey4Format ) ); + CMDBField* formatKey4Field = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanFormatKey4 ) ); + formatKey4Field->SetL( WEPKeyFormat( EWEPKey4Format ) ); + } + + generic->ModifyL( *session ); + + CleanupStack::PopAndDestroy( generic ); // generic + CleanupStack::PopAndDestroy( iapRecord ); // iapRecord + CleanupStack::PopAndDestroy( session ); // session + } + + +// --------------------------------------------------------- +// CProcessorWlan::WriteKeyL +// --------------------------------------------------------- +// +void CProcessorWlan::WriteKeyL( CMDBField* aKeyField, + HBufC16* aKey, + const TInt aKeyFormat ) + { + TBuf8 key; + + //convert to 8 bit + key.Copy( aKey->Des() ); + + if ( aKeyFormat == EAscii ) + { + // Must be converted to hexa and stored as a hexa + // Ascii key is half the length of Hex + HBufC8* buf8Conv = HBufC8::NewLC( key.Length() * KAsciiUnicodeRatio ); + ConvertAsciiToHex( key, buf8Conv ); + aKeyField->SetL( buf8Conv->Des() ); + CleanupStack::PopAndDestroy( buf8Conv ); + } + else if ( VerifyHex( key ) ) + { + //already in hexa format + aKeyField->SetL( key ); + } + else + { + CLOG_WRITE( "! Error : Invalid hexadecimal format" ) + } + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPFieldData +// --------------------------------------------------------- +// +HBufC16* CProcessorWlan::WEPFieldData( TDbCreatorWEPFields aFieldId ) + { + TInt index = WEPIndex( aFieldId ); + if( iWepData[ index ] == NULL ) + { + return iEmptyTag; + } + else + { + return iWepData[ index ]; + } + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPAuthentication +// --------------------------------------------------------- +// +TInt CProcessorWlan::WEPAuthentication() + { + HBufC16* authTypeStr = WEPFieldData( EWEPAuthType ); + TInt authType ( EAuthOpen ) ; + + _LIT16( KStrOpen, "Open" ); + _LIT16( KStrShared, "Shared" ); + + if ( authTypeStr->CompareF( KStrOpen ) == 0 ) + { + //CLOG_WRITE( "Authentication type : Open" ) + } + else if ( authTypeStr->CompareF( KStrShared ) == 0 ) + { + //CLOG_WRITE( "Authentication type : Shared" ) + authType = EAuthShared; + } + else + { + //aField is either empty or invalid + authType = KErrNotFound; + } + + return authType; + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPKeyInUse +// --------------------------------------------------------- +// +TInt CProcessorWlan::WEPKeyInUse() + { + HBufC16* keyStr = WEPFieldData( EWEPKeyInUse ); + TInt key ( EKeyNumber1 ) ; + + _LIT16( KStrKey1, "key1" ); + _LIT16( KStrKey2, "key2" ); + _LIT16( KStrKey3, "key3" ); + _LIT16( KStrKey4, "key4" ); + + if ( keyStr->CompareF( KStrKey1 ) == 0 ) + { + //CLOG_WRITE( "WEP key in use : key 1" ) + } + else if ( keyStr->CompareF( KStrKey2 ) == 0 ) + { + //CLOG_WRITE( "WEP key in use : key 2" ) + key = EKeyNumber2; + } + else if ( keyStr->CompareF( KStrKey3 ) == 0 ) + { + //CLOG_WRITE( "WEP key in use : key 3" ) + key = EKeyNumber3; + } + else if ( keyStr->CompareF( KStrKey4 ) == 0 ) + { + //CLOG_WRITE( "WEP key in use : key 4" ) + key = EKeyNumber4; + } + else + { + //aField is either empty or invalid + key = KErrNotFound; + } + + return key; + } + + + +// --------------------------------------------------------- +// CProcessorWlan::WEPKeyFormat +// --------------------------------------------------------- +// +TInt CProcessorWlan::WEPKeyFormat( TDbCreatorWEPFields aFieldId ) + { + __ASSERT_ALWAYS( ( aFieldId == EWEPKey1Format || + aFieldId == EWEPKey2Format || + aFieldId == EWEPKey3Format || + aFieldId == EWEPKey4Format ), + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + HBufC16* keyFormatStr = WEPFieldData( aFieldId ); + TWEPKeyFormat keyFormat ( EAscii ) ; + + _LIT16( KStrAscii, "Ascii" ); + _LIT16( KStrHexadecimal, "Hexadecimal" ); + + if ( keyFormatStr->CompareF( KStrAscii ) == 0 ) + { + //CLOG_WRITE( "Key format : Ascii" ) + } + else if ( keyFormatStr->CompareF( KStrHexadecimal ) == 0 ) + { + //CLOG_WRITE( "Key format : Hexadecimal" ) + keyFormat = EHexadecimal; + } + else + { + CLOG_WRITE( "! Error : Invalid key format. Default:Ascii" ) + } + + return keyFormat; + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPKeyLength +// --------------------------------------------------------- +// +TWEPKeyLength CProcessorWlan::WEPKeyLength( TDbCreatorWEPFields aFieldId ) + { + __ASSERT_ALWAYS( ( aFieldId == EWEPKey1Length || + aFieldId == EWEPKey2Length || + aFieldId == EWEPKey3Length || + aFieldId == EWEPKey4Length ), + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + HBufC16* keyLengthStr = WEPFieldData( aFieldId ); + TWEPKeyLength keyLen ( E40Bits ) ; + + _LIT16( KStr64, "64" ); + _LIT16( KStr128, "128" ); + _LIT16( KStr256, "256" ); + + if ( keyLengthStr->CompareF( KStr64 ) == 0 ) + { + //CLOG_WRITE( "Key length : 64" ) + } + else if ( keyLengthStr->CompareF( KStr128 ) == 0 ) + { + //CLOG_WRITE( "Key length : 128" ) + keyLen = E104Bits; + } + else if ( keyLengthStr->CompareF( KStr256 ) == 0 ) + { + //CLOG_WRITE( "Key length : 256" ) + keyLen = E232Bits; + } + else + { + CLOG_WRITE( "! Error : Invalid key length. Default:64" ) + } + + return keyLen; + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPKeyValidLen +// --------------------------------------------------------- +// +TInt CProcessorWlan::WEPKeyValidLen(TInt aFormat , TWEPKeyLength aLen ) + { + __ASSERT_ALWAYS( aFormat == EAscii || aFormat == EHexadecimal, + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + __ASSERT_ALWAYS( aLen == E40Bits || aLen == E104Bits || aLen == E232Bits, + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + TInt len( 0 ); + + switch ( aFormat ) + { + case EAscii: + switch ( aLen ) + { + case E40Bits : len = KKeyDataLength40Bits / + KAsciiUnicodeRatio; + break; + case E104Bits : len = KKeyDataLength104Bits / + KAsciiUnicodeRatio; + break; + case E232Bits : len = KKeyDataLength232Bits / + KAsciiUnicodeRatio; + } + break; + case EHexadecimal: + switch ( aLen ) + { + case E40Bits : len = KKeyDataLength40Bits; + break; + case E104Bits : len = KKeyDataLength104Bits; + break; + case E232Bits : len = KKeyDataLength232Bits; + } + } + + return len; + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPIndex +// --------------------------------------------------------- +// +TInt CProcessorWlan::WEPIndex( TDbCreatorWEPFields aFieldId ) + { + __ASSERT_ALWAYS( aFieldId >= EWEPKeyInUse && aFieldId <= EWEPKey4Data, + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + return aFieldId - 0x1000 + iDataStart; + + ////return iWEPIndex[ aFieldId - 0x1000 ]; + } + +// --------------------------------------------------------- +// CProcessorWlan::WEPFieldValidate +// --------------------------------------------------------- +// +TBool CProcessorWlan::WEPFieldValidate() + { + TBool valid (ETrue); + + if ( ( WEPAuthentication() == KErrNotFound ) || + ( WEPKeyInUse() == KErrNotFound ) ) + { + valid = EFalse; + } + else + { + //gets the actual keylength + TInt keyLen[ KMaxNumberofKeys ] = { 0,0,0,0 }; + + keyLen[EKeyNumber1] = WEPFieldData( EWEPKey1Data )->Length(); + keyLen[EKeyNumber2] = WEPFieldData( EWEPKey2Data )->Length(); + keyLen[EKeyNumber3] = WEPFieldData( EWEPKey3Data )->Length(); + keyLen[EKeyNumber4] = WEPFieldData( EWEPKey4Data )->Length(); + + + //check validity of key1 length + TInt validLen = WEPKeyValidLen( WEPKeyFormat( EWEPKey1Format ), + WEPKeyLength( EWEPKey1Length ) ); + if ( keyLen[EKeyNumber1] && keyLen[EKeyNumber1] != validLen) + { + valid = EFalse; + CLOG_WRITE_FORMAT( "! Error : Key1 length is invalid %d", + keyLen[EKeyNumber1] ); + CLOG_WRITE_FORMAT( "ValidLen1: %d \n", validLen ); + } + else if ( keyLen[EKeyNumber2] ) + { + //check validity of key2 length + validLen = WEPKeyValidLen( WEPKeyFormat( EWEPKey2Format ), + WEPKeyLength( EWEPKey2Length ) ); + if ( keyLen[EKeyNumber2] != validLen ) + { + valid = EFalse; + CLOG_WRITE_FORMAT( "! Error : Key2 length is invalid %d", + keyLen[EKeyNumber2] ) + CLOG_WRITE_FORMAT( "ValidLen2: %d \n", validLen ); + } + else if ( keyLen[EKeyNumber3] ) + { + //check validity of key3 length + validLen = WEPKeyValidLen( WEPKeyFormat( EWEPKey3Format ), + WEPKeyLength( EWEPKey3Length ) ); + if ( keyLen[EKeyNumber3] != validLen ) + { + valid = EFalse; + CLOG_WRITE_FORMAT( "! Error : Key3 length is invalid %d", + keyLen[EKeyNumber3] ); + CLOG_WRITE_FORMAT( "ValidLen3: %d \n", validLen ); + } + else if ( keyLen[EKeyNumber4] ) + { + //check validity of key4 length + validLen = WEPKeyValidLen( WEPKeyFormat( EWEPKey4Format ), + WEPKeyLength( EWEPKey4Length ) ); + if ( keyLen[EKeyNumber4] != validLen ) + { + valid = EFalse; + CLOG_WRITE_FORMAT( "! Error : Key4 length is invalid %d", + keyLen[EKeyNumber4] ); + CLOG_WRITE_FORMAT( "ValidLen4: %d \n", validLen ); + }//if + }//else + }//else + }//else + }//else + + return valid; + } + +//---------------------------------------------------------- +// CProcessorWlan::ConvertAsciiToHex +//---------------------------------------------------------- +// +void CProcessorWlan::ConvertAsciiToHex( const TDesC8& aSource, + HBufC8*& aDest ) + { + _LIT( hex, "0123456789ABCDEF" ); + TInt size = aSource.Size(); + TPtr8 ptr = aDest->Des(); + for ( TInt ii = 0; ii < size; ii++ ) + { + TText8 ch = aSource[ii]; + ptr.Append( hex()[(ch/16)&0x0f] ); + ptr.Append( hex()[ch&0x0f] ); + } + } + +//---------------------------------------------------------- +// CWEPSecuritySettingsDlg::VerifyHex +//---------------------------------------------------------- +// +TBool CProcessorWlan::VerifyHex( const TDesC8& aHex ) + { + TBool err( ETrue ); + + for ( TInt i = 0; i < aHex.Length(); i++ ) + { + TChar c( aHex[i] ); + + if ( !c.IsHexDigit() ) + { + err = EFalse; + break; + } + } + + return err; + } + + +// --------------------------------------------------------- +// WPA Security settings +// --------------------------------------------------------- + + +// --------------------------------------------------------- +// CProcessorWlan::SaveWPAL +// --------------------------------------------------------- +// +void CProcessorWlan::SaveWPAL( TUint32 aIapId ) + { + CLOG_WRITE( "CProcessorWlan::SaveWPAL enter" ); + CMDBSession* session = CMDBSession::NewL( CMDBSession::LatestVersion() ); + CleanupStack::PushL( session ); + + // Load IAP record + CCDIAPRecord* iapRecord = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) ); + CleanupStack::PushL( iapRecord ); + iapRecord->SetRecordId( aIapId ); + iapRecord->LoadL( *session ); + + // Load WLAN service table + // first get WLAN table id + CMDBGenericRecord* generic = static_cast + ( CCDRecordBase::RecordFactoryL( 0 ) ); + CleanupStack::PushL( generic ); + + generic->InitializeL( TPtrC( WLAN_SERVICE ), NULL ); + generic->LoadL( *session ); + TMDBElementId wlanTableId = generic->TableId(); + CMDBField* sidField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanServiceId ) ); + + TInt service = iapRecord->iService; + // prime with service id + *sidField = (TUint32)service; + + User::LeaveIfError( generic->FindL( *session ) ); + + // Set WPA mode + CMDBField* enableWpaPskField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanEnableWpaPsk ) ); + + enableWpaPskField->SetL( WPAPresharedKeyInUse() ); + + CLOG_WRITE( "Wrote enableWpaPskField" ); + + // Set security mode + CMDBField* secModeField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanSecMode ) ); + secModeField->SetL( iSecurityMode ); + + CLOG_WRITE( "Wrote securityMode" ); + // Save EAP list + CMDBField* wlanEapsField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanEaps ) ); + wlanEapsField->SetL( WPAFieldData( EWPAListOfEAPs )->Des() ); + + CLOG_WRITE( "Wrote EAPList" ); + + SetExpandedEapListL( generic ); + + CLOG_WRITE( "Wrote expandedEapList" ); + + // Save PreShared Key + TBuf8 keyWPA; + //convert to 8 bit + keyWPA.Copy( WPAFieldData( EWPAPresharedKey )->Des() ); + CMDBField* wpaPskField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWpaPreSharedKey ) ); + wpaPskField->SetL( keyWPA ); + + CLOG_WRITE( "Wrote pre-shared key" ); + if ( keyWPA.Length() < 8 ) + { + CLOG_WRITE( "Error: WPA pre-shared key is less then 8 chars." ); + } + + // Check and save PreShared Key Length + TInt len( WPAKeyLength() ); + if ( len != keyWPA.Length() ) + { + CLOG_WRITE( "! Error : WPA key lengths do not match" ); + } + + CMDBField* keyLengthField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanWpaKeyLength ) ); + keyLengthField->SetL( len ); + + generic->ModifyL( *session ); + + CleanupStack::PopAndDestroy( generic ); + CleanupStack::PopAndDestroy( iapRecord ); + CleanupStack::PopAndDestroy( session ); + CLOG_WRITE( "CProcessorWlan::SaveWPAL exit" ); + } + +// --------------------------------------------------------- +// CProcessorWlan::SetExpandedEapListL +// --------------------------------------------------------- +// +void CProcessorWlan::SetExpandedEapListL( CMDBGenericRecord* generic ) + { + // Gets the text format eap list + HBufC16* eapList = WPAFieldData( EWPAListOfEAPs ); + + if ( eapList != NULL && 0 < eapList->Length() ) + { + + // Creates the expanded eap lists + HBufC8* enabledEapList = ExpandedEapListLC( eapList, ETrue ); + HBufC8* disabledEapList = ExpandedEapListLC( eapList, EFalse ); + + // Save enabled EAP list + CMDBField* wlanEnabledEapsField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanEnabledEaps ) ); + wlanEnabledEapsField->SetL( enabledEapList->Des() ); + + // Save disabled EAP list + CMDBField* wlanDisabledEapsField = static_cast*> + ( generic->GetFieldByIdL( KCDTIdWlanDisabledEaps ) ); + wlanDisabledEapsField->SetL( disabledEapList->Des() ); + + CleanupStack::PopAndDestroy( disabledEapList ); + CleanupStack::PopAndDestroy( enabledEapList ); + + } + } + +// --------------------------------------------------------- +// CProcessorWlan::ExpandedEapListLC +// --------------------------------------------------------- +// +HBufC8* CProcessorWlan::ExpandedEapListLC( HBufC16* aEapList, TBool aEnabledNeed ) + { + // The eap list has a well defined form + // so this parser supposes this concrete form like this: + // "+018,-023,+026,-021,-006" + + // Lenght of a 3 digit long signed number + const TInt sliceLength = 4; + + // Max lenght of the resulted list. + // Adding one "," then divide the lenght of a slice+1 + TInt maxLenght = ( ( aEapList->Length()+1 ) / 5 ) * 8; + + HBufC8* expandedEapList = HBufC8::NewLC( maxLenght ); + + TInt pos = 0; + while ( pos + sliceLength <= aEapList->Length() ) + { + // Getting a slice + TPtrC16 slice = aEapList->Mid( pos, sliceLength ); + + // Checks the sign + if( slice[0] == '+' ) + { + if( aEnabledNeed ) + { + AddToList( expandedEapList, slice ); + } + } + else if( slice[0] == '-' ) + { + if( !aEnabledNeed ) + { + AddToList( expandedEapList, slice ); + } + } + else + { + CLOG_WRITE_FORMAT( "! Error : Wrong Eap list format %S", aEapList ); + } + + // Step over one slice and "," e.g. "+023," + pos+=5; + + } + if( pos != aEapList->Length() + 1) + { + CLOG_WRITE_FORMAT( "! Warning : possible wrong Eap list format %S", aEapList ); + } + + return expandedEapList; + } + +// --------------------------------------------------------- +// CProcessorWlan::AddToList +// --------------------------------------------------------- +// +void CProcessorWlan::AddToList( HBufC8* aExpandedEapList, TPtrC16 aSlice ) + { + // Fills the 8 byte form with "0xFE000000000000" + TBuf8<8> expandedForm; + expandedForm.AppendFill( 0xFE, 1 ); + expandedForm.AppendFill( 0x00, 6 ); + + // Leave the "sign" + TPtrC16 number = aSlice.Mid( 1 ); + TUint8 resultByte; + TLex16 lex( number ); + + if( KErrNone == lex.Val( resultByte, EDecimal ) ) + { + expandedForm.AppendFill( resultByte, 1 ); + } + else + { + expandedForm.AppendFill( 0x00, 1 ); + CLOG_WRITE( "! Error : Unlexed Eap number. 0 is addded" ); + } + + aExpandedEapList->Des().Append( expandedForm ); + } + + +// --------------------------------------------------------- +// CProcessorWlan::WPAIndex +// --------------------------------------------------------- +// +TInt CProcessorWlan::WPAIndex( TDbCreatorWPAFields aFieldId ) + { + __ASSERT_ALWAYS( aFieldId >= EWPAPresharedKey && aFieldId <= EWPAUseOfPresharedKey, + User::Panic ( KPanicOutOfRange, KErrOutOfRange ) ); + + return aFieldId - 0x2000 + iDataStart; + } + + +// --------------------------------------------------------- +// CProcessorWlan::WPAFieldData +// --------------------------------------------------------- +// +HBufC16* CProcessorWlan::WPAFieldData( TDbCreatorWPAFields aFieldId ) + { + TInt index = WPAIndex( aFieldId ); + if( iWpaData[ index ] == NULL ) + { + return iEmptyTag; + } + else + { + return iWpaData[ index ]; + } + } + +// --------------------------------------------------------- +// CProcessorWlan::WPAPresharedKeyInUse +// --------------------------------------------------------- +// +TBool CProcessorWlan::WPAPresharedKeyInUse() + { + HBufC16* useStr = WPAFieldData( EWPAUseOfPresharedKey ); + + TBool usePSK ( EFalse ) ; + + if ( useStr->CompareF( KStrYes ) == 0 ) + { + CLOG_WRITE( "Preshared key in use" ) + usePSK = ETrue; + } + else if ( useStr->CompareF( KStrNo ) == 0 ) + { + CLOG_WRITE( "Preshared key not in use" ); + } + else + { + //aField is either empty or invalid + CLOG_WRITE( "! Error : Invalid Use WPA preshared key. Default:No" ); + } + + return usePSK; + } + +// --------------------------------------------------------- +// CProcessorWlan::WPAKeyLength +// --------------------------------------------------------- +// +TInt CProcessorWlan::WPAKeyLength() + { + HBufC16* tag = WPAFieldData( EWPAKeyLength ); + + TInt num( 0 ); + TLex parser( tag->Des() ); + + if ( parser.Val( num ) != KErrNone ) + { + CLOG_WRITE( "! Error : Invalid input : WPA key length" ); + } + + return num; + } + +// --------------------------------------------------------- +// CProcessorWlan::AddSecurityDataL +// --------------------------------------------------------- +// +void CProcessorWlan::AddSecurityDataL( TInt aField, HBufC* aPtrTag, TBool aIsWep ) + { + if( aIsWep ) + { + iWepData[ WEPIndex( (TDbCreatorWEPFields)aField ) ] = aPtrTag->AllocL(); + ////iWepData.Insert( aPtrTag->AllocL(), WEPIndex( (TDbCreatorWEPFields)aField ) ); + } + else + { + iWpaData[ WPAIndex( (TDbCreatorWPAFields)aField ) ] = aPtrTag->AllocL(); + ////iWpaData.Insert( aPtrTag->AllocL(), WPAIndex( (TDbCreatorWPAFields)aField ) ); + } + } + +// --------------------------------------------------------- +// CProcessorWlan::DoLogL +// --------------------------------------------------------- +// +void CProcessorWlan::DoLogL() + { + // Writes some data of the actual WLAN access point into the log file. + HBufC16* tmp; + RCmConnectionMethodExt& plugin = GetLastPluginL(); + + // Writes some data of the Internet acces point into the log file. + if ( iIsEasyWlan ) + { + CLOG_WRITE( "Easy WLAN Access Point created:" ) + } + else + { + CLOG_WRITE( "WLAN Access Point created:" ) + } + + CLOG_WRITE_FORMAT( "\t Connection name in array: %S ", + (*iPluginName)[ PluginCount() - 1] ); + + tmp = plugin.GetStringAttributeL( ECmName ); + if( tmp ) + { + CleanupStack::PushL( tmp ); + CLOG_WRITE_FORMAT( "\t Connection name: %S ", tmp ) + CleanupStack::PopAndDestroy( tmp ); + } + + // For the WLAN network name + tmp = plugin.GetStringAttributeL( EWlanSSID ); + if( tmp ) + { + CleanupStack::PushL( tmp ); + CLOG_WRITE_FORMAT( "\t Network name: %S", tmp ) + CleanupStack::PopAndDestroy( tmp ); + } + CLOG_WRITE( "\t \r\n" ) + } + + +// --------------------------------------------------------- +// CProcessorWlan::Reset +// --------------------------------------------------------- +// +void CProcessorWlan::Reset() + { + for( TInt i = 0; i < KWEPKeyNumOfFields; i++ ) + { + iWepData[i] = NULL; + } + for( TInt i = 0; i < KWPAKeyNumOfFields; i++ ) + { + iWpaData[i] = NULL; + } + } + +// --------------------------------------------------------- +// CProcessorWlan::EAPSetting +// --------------------------------------------------------- +// +TBool CProcessorWlan::EAPSetting( const TInt aField ) + { + // Checks if the supplied field is EAP settings and returns ETrue if it is + if ( aField > EEapParameterFirst + && aField < EEapParameterLast ) + { + return ETrue; + } + else + { + return EFalse; + } + } +// --------------------------------------------------------- +// CProcessorWlan::GetEapTypeIdFromSettingId +// --------------------------------------------------------- +// +EAPSettings::TEapType CProcessorWlan::GetEapTypeIdFromSettingId( const TInt aField ) + { + switch ( aField ) + { + case EEapGtcUsername: + case EEapGtcSessionValidityTime: + case EEapGtcEncapsulation: + { + return EAPSettings::EEapGtc; + } + case EEapTlsUsername: + case EEapTlsRealm: + case EEapTlsVerifyServerRealm: + case EEapTlsRequireClientAuth: + case EEapTlsSessionValidityTime: + case EEapTlsCipherSuites: + case EEapTlsUserCertSubjectKeyId: + case EEapTlsUserCertIssuerName: + case EEapTlsUserCertSerialNumber: + case EEapTlsCaCertSubjectKeyId: + case EEapTlsCaCertIssuerName: + case EEapTlsCaCertSerialNumber: + case EEapTlsEncapsulation: + { + return EAPSettings::EEapTls; + } + case EEapLeapUsername: + case EEapLeapPassword: + case EEapLeapSessionValidityTime: + { + return EAPSettings::EEapLeap; + } + case EEapSimUsername: + case EEapSimRealm: + case EEapSimUsePseudonyms: + case EEapSimSessionValidityTime: + case EEapSimEncapsulation: + { + return EAPSettings::EEapSim; + } + case EEapTtlsUsername: + case EEapTtlsRealm: + case EEapTtlsVerifyServerRealm: + case EEapTtlsRequireClientAuth: + case EEapTtlsSessionValidityTime: + case EEapTtlsCipherSuites: + case EEapTtlsEncapsulatedTypes: + case EEapTtlsUserCertSubjectKeyId: + case EEapTtlsUserCertIssuerName: + case EEapTtlsUserCertSerialNumber: + case EEapTtlsCaCertSubjectKeyId: + case EEapTtlsCaCertIssuerName: + case EEapTtlsCaCertSerialNumber: + { + return EAPSettings::EEapTtls; + } + case EEapAkaUsername: + case EEapAkaRealm: + case EEapAkaUsePseudonyms: + case EEapAkaSessionValidityTime: + case EEapAkaEncapsulation: + { + return EAPSettings::EEapAka; + } + case EEapPeapUsername: + case EEapPeapRealm: + case EEapPeapVerifyServerRealm: + case EEapPeapRequireClientAuth: + case EEapPeapSessionValidityTime: + case EEapPeapCipherSuites: + case EEapPeapV0Allowed: + case EEapPeapV1Allowed: + case EEapPeapV2Allowed: + case EEapPeapEncapsulatedTypes: + case EEapPeapUserCertSubjectKeyId: + case EEapPeapUserCertIssuerName: + case EEapPeapUserCertSerialNumber: + case EEapPeapCaCertSubjectKeyId: + case EEapPeapCaCertIssuerName: + case EEapPeapCaCertSerialNumber: + { + return EAPSettings::EEapPeap; + } + case EEapMschapv2Username: + case EEapMschapv2Password: + case EEapMschapv2SessionValidityTime: + case EEapMschapv2Encapsulation: + { + return EAPSettings::EEapMschapv2; + } + case EEapFastUsername: + case EEapFastRealm: + case EEapFastVerifyServerRealm: + case EEapFastRequireClientAuth: + case EEapFastSessionValidityTime: + case EEapFastCipherSuites: + case EEapFastEncapsulatedTypes: + case EEapFastAuthProvModeAllowed: + case EEapFastUnauthProvModeAllowed: + case EEapFastWarnADHPNoPAC: + case EEapFastWarnADHPNoMatchingPAC: + case EEapFastWarnNotDefaultServer: + case EEapFastUserCertSubjectKeyId: + case EEapFastUserCertIssuerName: + case EEapFastUserCertSerialNumber: + case EEapFastCaCertSubjectKeyId: + case EEapFastCaCertIssuerName: + case EEapFastCaCertSerialNumber: + { + return EAPSettings::EEapFast; + } + + case EMschapv2Username: + case EMschapv2Password: + case EMschapv2SessionValidityTime: + case EMschapv2Encapsulation: + { + return EAPSettings::EPlainMschapv2; + } + default: + { + return EAPSettings::EEapNone; + } + + } + } +// --------------------------------------------------------- +// CProcessorWlan::AddEAPSetting +// --------------------------------------------------------- +// +void CProcessorWlan::AddEAPSettingL( const TInt aField, const HBufC16* const aValue ) + { + EAPSettings::TEapType eapId = GetEapTypeIdFromSettingId( aField ); + if ( eapId == EAPSettings::EEapNone ) + { + CLOG_WRITE( "! Error : Unknown EAP method" ); + User::Leave( KErrArgument ); + } + + TInt eapIndex(0); + // Search if the EAP instance already exists in the array for this + for ( eapIndex = 0 ; eapIndex < iEapSettings.Count() ; eapIndex++ ) + { + if ( ( iEapSettings[eapIndex]->iEapSettings->iEAPType == eapId ) + && ( iEapSettings[eapIndex]->iName != NULL ) + && ( iEapSettings[eapIndex]->iName->Compare( *iName ) == 0 )) + { + // Found it + break; + } + } + + if ( eapIndex == iEapSettings.Count() ) + { + // Not found. Create new + CEapTypeElement* newEap = new (ELeave) CEapTypeElement; + CleanupStack::PushL( newEap ); + + newEap->iEapSettings = new (ELeave) EAPSettings; + + newEap->iEapSettings->iEAPType = eapId; + + newEap->iName = iName->AllocL(); + + iEapSettings.AppendL(newEap); + + CleanupStack::Pop( newEap ); + + // Set the index to the newly created EAP settings instance + eapIndex = iEapSettings.Count() - 1; + + } + switch ( aField ) + { + case EEapGtcUsername: + case EEapTlsUsername: + case EEapLeapUsername: + case EEapSimUsername: + case EEapTtlsUsername: + case EEapAkaUsername: + case EEapPeapUsername: + case EEapMschapv2Username: + case EEapFastUsername: + case EMschapv2Username: + { + iEapSettings[eapIndex]->iEapSettings->iUsernamePresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iUsername.Copy( *aValue ); + break; + } + + case EEapLeapPassword: + case EEapMschapv2Password: + case EMschapv2Password: + { + iEapSettings[eapIndex]->iEapSettings->iPasswordPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPassword.Copy( *aValue ); + break; + } + + case EEapTlsRealm: + case EEapSimRealm: + case EEapTtlsRealm: + case EEapAkaRealm: + case EEapPeapRealm: + case EEapFastRealm: + { + iEapSettings[eapIndex]->iEapSettings->iRealmPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iRealm.Copy( *aValue ); + break; + } + + case EEapGtcSessionValidityTime: + case EEapTtlsSessionValidityTime: + case EEapTlsSessionValidityTime: + case EEapSimSessionValidityTime: + case EEapLeapSessionValidityTime: + case EMschapv2SessionValidityTime: + case EEapAkaSessionValidityTime: + case EEapPeapSessionValidityTime: + case EEapMschapv2SessionValidityTime: + case EEapFastSessionValidityTime: + { + // Convert the input parameter to integer + TLex lex( *aValue ); + TUint value( 0 ); + if( lex.Val( value, EDecimal) != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid session validity time value. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + iEapSettings[eapIndex]->iEapSettings->iSessionValidityTimePresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iSessionValidityTime = value; + break; + } + + case EEapGtcEncapsulation: + case EEapTlsEncapsulation: + case EEapSimEncapsulation: + case EEapAkaEncapsulation: + case EEapMschapv2Encapsulation: + case EMschapv2Encapsulation: + { + TLex lex( *aValue ); + TUint eapTypeId( 0 ); + if( lex.Val( eapTypeId, EDecimal) != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid encapsulation value. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + iEapSettings[eapIndex]->iEncapsulatingEapId = static_cast< EAPSettings::TEapType >( eapTypeId ); + break; + } + + case EEapTlsVerifyServerRealm: + case EEapTtlsVerifyServerRealm: + case EEapPeapVerifyServerRealm: + case EEapFastVerifyServerRealm: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iVerifyServerRealmPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iVerifyServerRealm = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iVerifyServerRealmPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iVerifyServerRealm = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid VerifyServerRealm. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapTlsRequireClientAuth: + case EEapTtlsRequireClientAuth: + case EEapPeapRequireClientAuth: + case EEapFastRequireClientAuth: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iRequireClientAuthenticationPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iRequireClientAuthentication = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iRequireClientAuthenticationPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iRequireClientAuthentication = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid RequireClientAuth. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapTlsCipherSuites: + case EEapTtlsCipherSuites: + case EEapPeapCipherSuites: + case EEapFastCipherSuites: + { + TRAPD( err, FillCipherSuitesL( aValue, eapIndex ) ); + if( err != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid CipherSuites. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + break; + } + + case EEapTlsUserCertSubjectKeyId: + case EEapTtlsUserCertSubjectKeyId: + case EEapPeapUserCertSubjectKeyId: + case EEapFastUserCertSubjectKeyId: + { + TInt certIndex = FindCertificateEntryL( CertificateEntry::EUser, eapIndex ); + + TBuf key; + + TRAPD( err, ConvertSubjectKeyIdToBinaryL( aValue, key) ); + if( err != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid UserCertSubjectKeyId. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSubjectKeyID.Copy(key); + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSubjectKeyIDPresent = ETrue; + break; + } + + case EEapTlsUserCertIssuerName: + case EEapTtlsUserCertIssuerName: + case EEapPeapUserCertIssuerName: + case EEapFastUserCertIssuerName: + { + TUint certIndex = FindCertificateEntryL( CertificateEntry::EUser, eapIndex ); + + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iIssuerNamePresent= ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iIssuerName.Copy( *aValue ); + break; + } + + case EEapTlsUserCertSerialNumber: + case EEapTtlsUserCertSerialNumber: + case EEapPeapUserCertSerialNumber: + case EEapFastUserCertSerialNumber: + { + TUint certIndex = FindCertificateEntryL( CertificateEntry::EUser, eapIndex ); + + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSerialNumberPresent= ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSerialNumber.Copy( *aValue ); + break; + } + + case EEapTlsCaCertSubjectKeyId: + case EEapTtlsCaCertSubjectKeyId: + case EEapPeapCaCertSubjectKeyId: + case EEapFastCaCertSubjectKeyId: + { + TInt certIndex = FindCertificateEntryL( CertificateEntry::ECA, eapIndex ); + + TBuf key; + + TRAPD( err, ConvertSubjectKeyIdToBinaryL( aValue, key) ); + if( err != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid UserCertSubjectKeyId. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSubjectKeyID.Copy(key); + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSubjectKeyIDPresent = ETrue; + break; + } + + case EEapTlsCaCertIssuerName: + case EEapTtlsCaCertIssuerName: + case EEapPeapCaCertIssuerName: + case EEapFastCaCertIssuerName: + { + TUint certIndex = FindCertificateEntryL( CertificateEntry::ECA, eapIndex ); + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iIssuerNamePresent= ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iIssuerName.Copy( *aValue ); + + break; + } + + case EEapTlsCaCertSerialNumber: + case EEapTtlsCaCertSerialNumber: + case EEapPeapCaCertSerialNumber: + case EEapFastCaCertSerialNumber: + { + TUint certIndex = FindCertificateEntryL( CertificateEntry::ECA, eapIndex ); + iEapSettings[eapIndex]->iEapSettings->iCertificatesPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSerialNumberPresent= ETrue; + iEapSettings[eapIndex]->iEapSettings->iCertificates[certIndex].iSerialNumber.Copy( *aValue ); + break; + } + + case EEapSimUsePseudonyms: + case EEapAkaUsePseudonyms: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iUsePseudonymsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iUsePseudonyms = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iUsePseudonymsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iUsePseudonyms = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid UsePseudonyms. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + break; + } + + case EEapTtlsEncapsulatedTypes: + case EEapPeapEncapsulatedTypes: + case EEapFastEncapsulatedTypes: + { + // Lenght of a 3 digit long signed number + const TInt sliceLength = 4; + + TInt pos = 0; + while ( pos + sliceLength <= aValue->Length() ) + { + // Getting a slice + TPtrC16 slice = aValue->Mid( pos, sliceLength ); + + // Checks the sign + if( slice[0] == '+' ) + { + TLex lex( slice.Ptr() + 1 ); + TUint encapsEapId( 0 ); + + if( lex.Val( encapsEapId, EDecimal) != KErrNone ) + { + CLOG_WRITE_FORMAT( "! Error : Invalid EncapsulatedTypes. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + iEapSettings[eapIndex]->iEapSettings->iEncapsulatedEAPTypes.Append( encapsEapId ); + iEapSettings[eapIndex]->iEapSettings->iEncapsulatedEAPTypesPresent = ETrue; + } + + // Step over one slice and "," e.g. "+023," + pos+=5; + } + + break; + } + + case EEapPeapV0Allowed: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv0Allowed = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv0Allowed = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapPeapV0Allowed. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapPeapV1Allowed: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv1Allowed = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv1Allowed = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapPeapV1Allowed. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapPeapV2Allowed: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv2Allowed = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iPEAPVersionsPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iPEAPv2Allowed = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapPeapV2Allowed. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapFastAuthProvModeAllowed: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iAuthProvModeAllowedPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iAuthProvModeAllowed = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iAuthProvModeAllowedPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iAuthProvModeAllowed = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EEapFastAuthProvModeAllowed. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapFastUnauthProvModeAllowed: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iUnauthProvModeAllowedPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iUnauthProvModeAllowed = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iUnauthProvModeAllowedPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iUnauthProvModeAllowed = EFalse; + } + else + { + + CLOG_WRITE_FORMAT( "! Error : Invalid EapFastUnauthProvModeAllowed. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapFastWarnADHPNoPAC: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoPACPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoPAC = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoPACPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoPAC = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapFastWarnADHPNoPAC. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapFastWarnADHPNoMatchingPAC: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoMatchingPACPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoMatchingPAC = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoMatchingPACPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnADHPNoMatchingPAC = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapFastWarnADHPNoMatchingPAC. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + case EEapFastWarnNotDefaultServer: + { + if ( !aValue->CompareF( KStrYes ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnNotDefaultServerPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnNotDefaultServer = ETrue; + } + else if ( !aValue->CompareF( KStrNo ) ) + { + iEapSettings[eapIndex]->iEapSettings->iWarnNotDefaultServerPresent = ETrue; + iEapSettings[eapIndex]->iEapSettings->iWarnNotDefaultServer = EFalse; + } + else + { + CLOG_WRITE_FORMAT( "! Error : Invalid EapFastWarnNotDefaultServer. EapId: %d", eapId ); + User::Leave( KErrArgument ); + } + + break; + } + + default: + { + + } + } + } +// --------------------------------------------------------- +// CProcessorWlan::FillCipherSuitesL +// --------------------------------------------------------- +// +void CProcessorWlan::FillCipherSuitesL( const HBufC16* const aPtrTag, const TInt aEapIndex ) + { + if ( iEapSettings[aEapIndex] == NULL ) + { + User::Leave( KErrArgument ); + } + + iEapSettings[aEapIndex]->iEapSettings->iCipherSuites.Reset(); + iEapSettings[aEapIndex]->iEapSettings->iCipherSuitesPresent = EFalse; // init to EFalse + + TChar plus( '+' ); + + TBuf8<256> tmpBuf; + tmpBuf.Copy( *aPtrTag); + + TInt length = tmpBuf.Length(); + + for ( TInt i = 0 ; i + 3 < length ; i += 5) + { + if ( tmpBuf[i] == plus ) + { + TLex8 lex( tmpBuf.Mid( i + 1, 3) ); + TUint suite; + User::LeaveIfError( lex.Val( suite ) ); + iEapSettings[aEapIndex]->iEapSettings->iCipherSuites.Append(suite); + iEapSettings[aEapIndex]->iEapSettings->iCipherSuitesPresent = ETrue; + } + } + } + +// --------------------------------------------------------- +// CProcessorWlan::FindCertificateEntry +// --------------------------------------------------------- +// +TUint CProcessorWlan::FindCertificateEntryL( const CertificateEntry::TCertType aCertType, const TInt aEapIndex ) + { + TUint certIndex( 0 ); + for( certIndex = 0; certIndex < iEapSettings[aEapIndex]->iEapSettings->iCertificates.Count() ; certIndex++ ) + { + if( iEapSettings[aEapIndex]->iEapSettings->iCertificates[certIndex].iCertType == aCertType ) + { + // Found + break; + } + } + if( certIndex == iEapSettings[aEapIndex]->iEapSettings->iCertificates.Count() ) + { + // Not found. Create + CertificateEntry entry; + + entry.iCertType = aCertType; + + iEapSettings[aEapIndex]->iEapSettings->iCertificates.AppendL( entry ); + + certIndex = iEapSettings[aEapIndex]->iEapSettings->iCertificates.Count() - 1; + } + return certIndex; + } + +// --------------------------------------------------------- +// CProcessorWlan::ConvertSubjectKeyIdToBinary +// --------------------------------------------------------- +// +void CProcessorWlan::ConvertSubjectKeyIdToBinaryL( const HBufC16* const aSubjectKeyIdString, TDes& aBinaryKey) + { + TInt err( KErrNone ); + + // Define literals to search the subject key for possible 0X/0x beginning + _LIT(KHexIdLC, "0x"); + _LIT(KHexIdUC, "0X"); + TBuf<2> hexIdBuf; + + // The lenght of the key given as input + TInt keyLen = aSubjectKeyIdString->Length(); + + // setting the given key to the key buffer + TBuf8<256> origKey; + + origKey.Copy( *aSubjectKeyIdString ); + origKey.SetLength(keyLen); + + TLex8 tmpByte; + TUint16 byte; + + // Remove possible spaces from the beginning + origKey.TrimLeft(); + + // the key should be atleast two chars long + if (origKey.Length() >= 2) + { + // Copy the two left most characters in to the buffer + hexIdBuf.Copy(origKey.Left(2)); + + // If the first characters are 0x or 0X, then thet should be ignored + if (hexIdBuf.Compare(KHexIdLC) == 0 + || hexIdBuf.Compare(KHexIdUC) == 0) + { + // delete two characters + origKey.Delete(0, 2); + } + } + + + // looping the subject key through, removing whitespaces + for (TInt i = 0; i < KKeyIdentifierLength; i++) + { + // removing white spaces from the left side of the key + origKey.TrimLeft(); + // check that there are characters left + if (origKey.Length() >= 2) + { + // pick the two left most bytes from the key + tmpByte = origKey.Left(2); + // convert byte into binary format + err = tmpByte.Val(byte, EHex); + + // check whether conversion to decimal went ok + if (err != KErrNone) + { + // if there are problems, then leave the loop + break; + } + + // store the appended byte into the key variable + aBinaryKey.Append(byte); + // delete two characters from the left side of the character array in the buffer + origKey.Delete(0, 2); + } + else { + // leave the loop, no characters are left + break; + } + } + User::LeaveIfError( err ); + } + + +// End of File.