/*
* Copyright (c) 2002-2010 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: Handles APN operations
*
*/
// INCLUDE FILES
#include <cmmanager.h>
#include <cmmanagerext.h>
#include <cmconnectionmethod.h>
#include <cmconnectionmethodext.h>
#include <cmconnectionmethoddef.h>
#include <cmpluginpacketdatadef.h>
#include <cmdestination.h>
#include <cmmanagerdef.h>
#include "MSatUtils.h"
#include "CSatApnHandler.h"
#include "SatLog.h"
const TUint32 KSatCMGranularity( 5 );
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CSatApnHandler::CSatApnHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSatApnHandler::CSatApnHandler( MSatUtils& aUtils ) :
iUtils( aUtils )
{
LOG( SIMPLE,
"SATENGINE: CSatApnHandler::CSatApnHandler calling-exiting" )
}
// -----------------------------------------------------------------------------
// CSatApnHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSatApnHandler* CSatApnHandler::NewL( MSatUtils& aUtils )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::NewL calling" )
CSatApnHandler* self = new( ELeave )CSatApnHandler( aUtils );
LOG( SIMPLE, "SATENGINE: CSatApnHandler::NewL exiting" )
return self;
}
// -----------------------------------------------------------------------------
// CSatApnHandler::Destructor
// -----------------------------------------------------------------------------
//
CSatApnHandler::~CSatApnHandler()
{
LOG( SIMPLE,
"SATENGINE: CSatApnHandler::~CSatApnHandler calling" )
LOG( SIMPLE,
"SATENGINE: CSatApnHandler::~CSatApnHandler exiting" )
}
// -----------------------------------------------------------------------------
// CSatApnHandler::GetApnInfoL
// -----------------------------------------------------------------------------
//
void CSatApnHandler::GetApnInfoL(
const RSat::TAccessName& aName,
const RSat::TTextString& aUserLogin,
const RSat::TTextString& aUserPwd,
TUint32& aIapId,
TUint32& aNwId,
TBool& aApnCreated,
const RPacketContext::TProtocolType& aPdpType,
const TDesC8& aLocalAddress )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL calling" )
// First check the length of the APN
if ( !aName.Length() )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL \
aName.Length() == 0" )
User::Leave( KErrNotFound );
}
// Format APN
HBufC* formatName = FormatAPN( aName );
if ( !formatName )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL wrong APN name \
format" )
// APN was in false format, leave
User::Leave( KErrArgument );
}
CleanupStack::PushL( formatName );
// Reference params
TUint32 iapId( 0 );
TUint32 networkId( 0 );
// Find if the connection method already exists
// Initialize the flags
TBool found = EFalse;
aApnCreated = EFalse;
// Create CMManager Session
RCmManager cmManager;
cmManager.OpenLC();
// Get the Connection Method list from the open CMManager session
RArray<TUint32> array = RArray<TUint32>( KSatCMGranularity );
CleanupClosePushL( array );
cmManager.ConnectionMethodL( array );
// Go through the Connection Method list to find if there is matched one
HBufC* apnCM;
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL, \
required pdp type is %d", aPdpType )
for( TInt i = 0; ( i < array.Count() ) && !found; ++i )
{
RCmConnectionMethod cm = cmManager.ConnectionMethodL( array[i] );
CleanupClosePushL( cm );
// query the APN of the Connection Method
apnCM = cm.GetStringAttributeL( CMManager::EPacketDataAPName );
CleanupStack::PushL( apnCM );
// query the pdpType of the Connection Method
TInt pdpType = cm.GetIntAttributeL( CMManager::EPacketDataPDPType );
if ( ( pdpType == aPdpType ) && ( *apnCM == *formatName ) )
{
// Found the Connection Method, query the IapId and NwId
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL, \
Record found" )
// Get IAP Id, Network Id
networkId = cm.GetIntAttributeL( CMManager::ECmNetworkId );
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL, \
networkId %d", networkId )
iapId = cm.GetIntAttributeL( CMManager::ECmIapId );
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL, \
iapId %d", iapId )
found = ETrue;
}
CleanupStack::PopAndDestroy( apnCM );
CleanupStack::PopAndDestroy( &cm );
}
CleanupStack::PopAndDestroy( &array );
if ( !found )
{
// No Connection Method found, insert a new one
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL, \
Record Not found, insert a new one" )
TRAPD( insertError, InsertRecordL( *formatName, aUserLogin,
aUserPwd, iapId, networkId, aPdpType, aLocalAddress ) )
if ( KErrNone == insertError )
{
// Insert OK
LOG( NORMAL, "SATENGINE: CSatApnHandler::GetApnInfoL, \
new record inserted" )
aApnCreated = ETrue;
}
}
CleanupStack::PopAndDestroy( &cmManager );
CleanupStack::PopAndDestroy( formatName );
// Set return values
aIapId = iapId;
aNwId = networkId;
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetApnInfoL exiting" )
}
// -----------------------------------------------------------------------------
// CSatApnHandler::DeleteApnL
// -----------------------------------------------------------------------------
//
void CSatApnHandler::DeleteApnL( TUint32 aApnId )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::DeleteApnL calling" )
if ( aApnId )
{
// Create CMManager Session
RCmManagerExt cmManager;
cmManager.OpenLC();
// Get the connection method
RCmConnectionMethodExt cm;
cm = cmManager.ConnectionMethodL( aApnId );
CleanupClosePushL( cm );
cm.DeleteL();
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::DeleteApnL, \
delete the connection method %d", aApnId )
CleanupStack::PopAndDestroy( &cm );
CleanupStack::PopAndDestroy( &cmManager );
}
LOG( SIMPLE, "SATENGINE: CSatApnHandler::DeleteApnL exiting" )
}
// -----------------------------------------------------------------------------
// CSatApnHandler::InsertRecordL
// -----------------------------------------------------------------------------
//
void CSatApnHandler::InsertRecordL(
const TDesC& aReqApn,
const RSat::TTextString& aUserLogin,
const RSat::TTextString& aUserPwd,
TUint32& aIapId,
TUint32& aNwId,
const RPacketContext::TProtocolType aPdpType,
const TDesC8& aLocalAddress )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::InsertRecordL calling" )
LOG2( NORMAL, "SATENGINE: CSatApnHandler::InsertRecordL, apn is %S",
&aReqApn )
// Create CMManager Session
RCmManagerExt cmManager;
cmManager.OpenLC();
// Create a connection method without destination. So when we can find
// the connection method by going through the connection method list.
RCmConnectionMethodExt cm;
cm = cmManager.CreateConnectionMethodL( KUidPacketDataBearerType );
CleanupClosePushL( cm );
// This is shown in GS in Access Point list
cm.SetStringAttributeL( CMManager::ECmName, iUtils.BipApnName() );
// GPRS connection name
cm.SetStringAttributeL( CMManager::EPacketDataAPName, aReqApn );
// IPv4 or IPv6
cm.SetIntAttributeL( CMManager::EPacketDataPDPType, aPdpType );
// Set the local IP address (if any)
if ( aLocalAddress.Length() )
{
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::InsertRecordL, Local addr \
length: %i", aLocalAddress.Length() )
cm.SetString8AttributeL( CMManager::EPacketDataPDPAddress,
aLocalAddress );
}
cm.SetBoolAttributeL( CMManager::ECmWapIPSecurity, EFalse );
cm.SetIntAttributeL( CMManager::ECmWapIPWSPOption,
CMManager::ECmWapWspOptionConnectionOriented );
cm.SetBoolAttributeL( CMManager::EPacketDataDisablePlainTextAuth, EFalse );
cm.SetIntAttributeL( CMManager::ECmIFPromptForAuth, EFalse );
if ( aUserLogin != KNullDesC )
{
LOG2( NORMAL, "SATENGINE: CSatApnHandler::InsertRecordL, \
username is %S", &aUserLogin )
cm.SetStringAttributeL( CMManager::ECmIFAuthName, aUserLogin );
if ( aUserPwd != KNullDesC )
{
LOG2( NORMAL, "SATENGINE: CSatApnHandler::InsertRecordL, \
pwd is %S", &aUserPwd )
cm.SetStringAttributeL( CMManager::ECmIFAuthPass, aUserPwd );
}
}
// Update the access point ID for use later.
cm.UpdateL();
// Get IAP Id, Network Id
aNwId = cm.GetIntAttributeL( CMManager::ECmNetworkId );
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::InsertRecordL, \
Nwid is %d", aNwId )
aIapId = cm.GetIntAttributeL( CMManager::ECmIapId );
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::InsertRecordL, \
aIpId is %d", aIapId )
CleanupStack::PopAndDestroy( &cm );
CleanupStack::PopAndDestroy( &cmManager );
LOG( SIMPLE, "SATENGINE: CSatApnHandler::InsertRecordL exiting" )
}
// -----------------------------------------------------------------------------
// CSatApnHandler::FormatAPN
// -----------------------------------------------------------------------------
//
HBufC* CSatApnHandler::FormatAPN( const RSat::TAccessName&
aReqApn ) const
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN calling" )
// Length of the access point name
const TInt accessNameLength( aReqApn.Length() );
TInt index( 0 );
// Format APN coming from SIM. Remove length infos and add dots
// from the requested APN. The APN format is, for example,
// '4Some9accesspnt2fi' and after the format the formatted APN
// should be 'Some.accesspnt.fi'
HBufC* formatApnName = HBufC::New( aReqApn.MaxLength() );
if ( formatApnName )
{
TPtr formApn( formatApnName->Des() );
// Indicates is the APN format correct. Can be detected only in loops.
TBool correctFormat( ETrue );
// Loop requested APN. The first byte is always the length
for ( index = 0; index < accessNameLength && correctFormat; index++ )
{
// Next byte is the length of the next label
const TInt length( aReqApn[index] );
// Label length cannot be bigger than the length of the APN
if ( ( index + length ) > accessNameLength )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN \
( index + length ) > accessNameLength" )
correctFormat = EFalse;
}
// Append the label
for ( TInt j = 0; j < length && correctFormat; j++ )
{
index++; // move to next index
TChar next = aReqApn[index];
formApn.Append( next );
}
// Add dot to APN if not end of APN
if ( accessNameLength > index + 1 )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN \
accessNameLength > index + 1" )
formApn.Append( '.' );
}
}
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN index: %i", index )
// Check did we read all characters
if ( !correctFormat || ( index != accessNameLength ) )
{
// Format was not correct, return zero
formApn.Zero();
formApn.SetLength( 0 );
}
else
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN lower case" )
// Put characters to lower case
formApn.LowerCase();
}
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FormatAPN exiting" )
}
return formatApnName;
}
// -----------------------------------------------------------------------------
// CSatApnHandler::FindDefaultApL
// -----------------------------------------------------------------------------
//
TUint32 CSatApnHandler::FindDefaultApL(
const RPacketContext::TProtocolType& aPdpType )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FindDefaultApL calling" );
TUint32 defaultIap( 0 );
TInt pdpType( 0 );
// create CMManager Session
RCmManager cmManager;
cmManager.OpenL();
CleanupClosePushL( cmManager );
// create a network connection method
RCmConnectionMethod cm;
CleanupClosePushL( cm );
// get a default connection method
GetDefConnMethodL( cmManager, cm );
// get pdp type
pdpType = cm.GetIntAttributeL( CMManager::EPacketDataPDPType );
if ( pdpType == aPdpType )
{
// get a default iap id
defaultIap = cm.GetIntAttributeL( CMManager::ECmIapId );
LOG2( SIMPLE, "SATENGINE: CSatApnHandler::FindDefaultApL \
default iap had been found defaultIap = %d", defaultIap )
}
CleanupStack::PopAndDestroy( &cm );
CleanupStack::PopAndDestroy( &cmManager );
if ( !defaultIap )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler: default AP not found" );
User::Leave( KErrNotFound );
}
LOG( SIMPLE, "SATENGINE: CSatApnHandler::FindDefaultApL exit" )
return defaultIap;
}
// --------------------------------------------------------------------------
// CSatApnHandler::GetDefConnMethodL
// --------------------------------------------------------------------------
void CSatApnHandler::GetDefConnMethodL( RCmManager& aCmManager,
RCmConnectionMethod& aDefCm )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetDefConnMethodL calling" )
// Go through the default connection methods to find
// the one valid method
TCmDefConnValue defConn;
aCmManager.ReadDefConnL( defConn );
LOG3( SIMPLE, "SATENGINE: CSatApnHandler::\
GetDefConnMethodL DefConn type=%d, id=%d",
defConn.iType, defConn.iId )
// Default setting is a connection method
if ( ECmDefConnConnectionMethod == defConn.iType )
{
LOG( SIMPLE, "SATENGINE: CSatApnHandler::\
GetDefConnMethodL ECmDefConnConnectionMethod" )
// get a default connection method
aDefCm = aCmManager.ConnectionMethodL( defConn.iId );
}
// Default setting is a destination method
else if ( ECmDefConnDestination == defConn.iType )
{
RCmDestination defDes;
CleanupClosePushL( defDes );
LOG( SIMPLE, "SATENGINE: CSatApnHandler::\
GetDefConnMethodL ECmDefConnDestination" )
// get a default destination
defDes = aCmManager.DestinationL( defConn.iId );
// get the first default connection method from destination
aDefCm = defDes.ConnectionMethodL( 0 );
CleanupStack::PopAndDestroy( &defDes );
}
LOG( SIMPLE, "SATENGINE: CSatApnHandler::GetDefConnMethodL exit" )
}
// End of File