/*
* Copyright (c) 2006-2007 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: CCCHRequestStorage implementation
*
*/
// INCLUDE FILES
#include "cchlogger.h"
#include "cchserverbase.h"
#include "cchrequeststorage.h"
#include "cchconnmonhandler.h"
#include "cchservicehandler.h"
#include "cchsubsession.h"
// EXTERNAL DATA STRUCTURES
// None
// EXTERNAL FUNCTION PROTOTYPES
// None
// CONSTANTS
// None
// MACROS
// None
// LOCAL CONSTANTS AND MACROS
// None
// MODULE DATA STRUCTURES
// None
// LOCAL FUNCTION PROTOTYPES
// None
// FORWARD DECLARATIONS
// None
// ============================= LOCAL FUNCTIONS =============================
// ---------------------------------------------------------------------------
// IdentityRequestRelation
// Compare two request storage entries.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TBool IdentityRequestRelation(
const TCCHStorageEntry& aFirst,
const TCCHStorageEntry& aSecond )
{
TBool result( EFalse );
result = ( aFirst.iRequest == aSecond.iRequest &&
aFirst.iSubsession == aSecond.iSubsession );
return result;
}
// ============================ MEMBER FUNCTIONS =============================
// ---------------------------------------------------------------------------
// CCCHRequestStorage::CCCHRequestStorage
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CCCHRequestStorage::CCCHRequestStorage( CCCHServerBase& aServer ) :
iServer( aServer )
{
// No implementation required
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCCHRequestStorage* CCCHRequestStorage::NewL( CCCHServerBase& aServer )
{
CCCHRequestStorage* self = CCCHRequestStorage::NewLC( aServer );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::NewLC
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCCHRequestStorage* CCCHRequestStorage::NewLC( CCCHServerBase& aServer )
{
CCCHRequestStorage* self = new (ELeave)CCCHRequestStorage( aServer );
CleanupStack::PushL( self );
return self;
}
// Destructor
CCCHRequestStorage::~CCCHRequestStorage()
{
iRequests.Close();
iSubsessions.Close();
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::AddRequestL
// Add new request into storage.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCCHRequestStorage::AddRequestL( TCCHCommands aRequest,
const RMessage2& aMessage,
const CCCHSubsession* aSubsession )
{
CCHLOGSTRING( "CCCHRequestStorage::AddRequestL: IN" );
CCHLOGSTRING3
("CCCHRequestStorage::AddRequestL: Request = %d, Session = 0x%x",
aRequest, aSubsession );
// Create new request entry
TCCHStorageEntry* entry = new (ELeave) TCCHStorageEntry;
CleanupStack::PushL( entry );
// Set entry data
entry->iRequest = aRequest;
entry->iMessage = new (ELeave) RMessage2( aMessage );
CleanupStack::PushL( entry->iMessage );
entry->iSubsession = aSubsession;
// Check that subsession has not already made the request
if ( KErrNotFound ==
iRequests.Find( *entry, IdentityRequestRelation ) )
{
iRequests.AppendL( *entry );
switch ( aRequest )
{
case ECCHEnableService:
{
TBool connectivityCheck( EFalse );
TServiceSelection serviceSelection( aMessage.Int0(),
static_cast<TCCHSubserviceType>( aMessage.Int1() ) );
connectivityCheck =
aMessage.Int2();
TInt err = iServer.ServiceHandler().EnableService(
serviceSelection, connectivityCheck );
CompleteRequest( ECCHEnableService, aSubsession, err );
}
break;
case ECCHDisableService:
{
TServiceSelection serviceSelection( aMessage.Int0(),
static_cast<TCCHSubserviceType>( aMessage.Int1() ) );
TInt err = iServer.ServiceHandler().DisableService(
serviceSelection );
CompleteRequest( ECCHDisableService, aSubsession, err );
}
break;
case ECCHSetConnectionInfo:
{
TServiceConnectionInfo serviceConnInfo;
TPckgBuf<TServiceConnectionInfo> serviceConnInfoPckg;
aMessage.ReadL( 0, serviceConnInfoPckg );
serviceConnInfo.iServiceSelection.iServiceId = serviceConnInfoPckg().iServiceSelection.iServiceId;
serviceConnInfo.iServiceSelection.iType = serviceConnInfoPckg().iServiceSelection.iType;
serviceConnInfo.iServiceSelection.iParameter = serviceConnInfoPckg().iServiceSelection.iParameter;
serviceConnInfo.iSNAPId = serviceConnInfoPckg().iSNAPId;
serviceConnInfo.iIapId = serviceConnInfoPckg().iIapId;
serviceConnInfo.iReserved = serviceConnInfoPckg().iReserved;
if( serviceConnInfo.iServiceSelection.iParameter == ECchUsername )
{
serviceConnInfo.iUsername = serviceConnInfoPckg().iUsername;
serviceConnInfo.iUsername.ZeroTerminate();
}
if( serviceConnInfo.iServiceSelection.iParameter == ECchPassword )
{
/* : verify password will be zeroed correctly */
serviceConnInfo.iPassword = serviceConnInfoPckg().iPassword;
serviceConnInfo.iPassword.ZeroTerminate();
}
TInt err = iServer.ServiceHandler().SetConnectionInfo(
serviceConnInfo );
CompleteRequest( ECCHSetConnectionInfo, aSubsession, err );
}
break;
case ECCHGetConnectionInfo:
{
TServiceConnectionInfo serviceConnInfo;
TPckgBuf<TServiceConnectionInfo> serviceConnInfoPckg;
aMessage.ReadL( 0, serviceConnInfoPckg );
serviceConnInfo.iServiceSelection.iServiceId = serviceConnInfoPckg().iServiceSelection.iServiceId;
serviceConnInfo.iServiceSelection.iType = serviceConnInfoPckg().iServiceSelection.iType;
serviceConnInfo.iServiceSelection.iParameter = serviceConnInfoPckg().iServiceSelection.iParameter;
TInt err = iServer.ServiceHandler().GetConnectionInfo(
serviceConnInfo );
CompleteRequestL( ECCHGetConnectionInfo, aSubsession,
&serviceConnInfo, err );
}
break;
case ECCHGetServices:
{
TInt scanAllowed( KErrNone );
// if service id is greater than or equals zero then
// this is Quick service discovery request. Network scan is
// not performed.
scanAllowed = aMessage.Int0();
if ( KErrNotFound == scanAllowed )
{
ScanNetworks();
iServer.ServiceHandler().UpdateL( ETrue );
}
TRAPD( err,
iServer.ServiceHandler().GetServicesL( aMessage ) );
CompleteRequest( ECCHGetServices, aSubsession, err );
}
break;
default:
break;
}
}
else
{
// Notify request is already active
CCHLOGSTRING
( "CCCHRequestStorage::AddRequestL: Request already active!" );
iServer.PanicClient( aMessage, KErrAlreadyExists );
}
CleanupStack::Pop( entry->iMessage );
CleanupStack::PopAndDestroy( entry );
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::CompleteRequest
// Complete request and remove it from storage.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CCCHRequestStorage::CompleteRequest( TCCHCommands aRequest,
const CCCHSubsession* aSubsession,
TInt aError )
{
CCHLOGSTRING2
( "CCCHRequestStorage::CompleteRequest: error: %d", aError );
TInt error( KErrNone );
TCCHStorageEntry entry;
entry.iRequest = aRequest;
entry.iSubsession = aSubsession;
error = iRequests.Find( entry, IdentityRequestRelation );
if ( KErrNotFound != error )
{
iRequests[ error ].iMessage->Complete( aError );
DeleteRequest( error );
// If no error -> return KErrNone
error = KErrNone;
}
CCHLOGSTRING( "CCCHRequestStorage::CompleteRequest: OUT" );
return error;
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::CompleteRequestL
// Complete request and remove it from storage.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CCCHRequestStorage::CompleteRequestL( TCCHCommands aRequest,
const CCCHSubsession* aSubsession,
TAny* aParams,
TInt aError )
{
CCHLOGSTRING2
( "CCCHRequestStorage::CompleteRequestL: error: %d", aError );
TInt error( KErrNone );
TCCHStorageEntry entry;
entry.iRequest = aRequest;
entry.iSubsession = aSubsession;
error = iRequests.Find( entry, IdentityRequestRelation );
if ( KErrNotFound != error )
{
if ( ECCHGetConnectionInfo == entry.iRequest )
{
TPckgBuf<TServiceConnectionInfo> conInfo;
iRequests[ error ].iMessage->ReadL( 0, conInfo );
conInfo().iServiceSelection.iServiceId =
static_cast<TServiceConnectionInfo*>( aParams )->iServiceSelection.iServiceId;
conInfo().iServiceSelection.iType =
static_cast<TServiceConnectionInfo*>( aParams )->iServiceSelection.iType;
conInfo().iSNAPId =
static_cast<TServiceConnectionInfo*>( aParams )->iSNAPId;
conInfo().iIapId =
static_cast<TServiceConnectionInfo*>( aParams )->iIapId;
conInfo().iSNAPLocked =
static_cast<TServiceConnectionInfo*>( aParams )->iSNAPLocked;
conInfo().iPasswordSet =
static_cast<TServiceConnectionInfo*>( aParams )->iPasswordSet;
conInfo().iUsername = static_cast<TServiceConnectionInfo*>( aParams )->iUsername;
conInfo().iReserved =
static_cast<TServiceConnectionInfo*>( aParams )->iReserved;
iRequests[ error ].iMessage->WriteL( 0, conInfo );
}
iRequests[ error ].iMessage->Complete( aError );
DeleteRequest( error );
// If no error -> return KErrNone
error = KErrNone;
}
CCHLOGSTRING( "CCCHRequestStorage::CompleteRequestL: OUT" );
return error;
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::RemoveRequestsBySession
// Remove all requests by session id. (Does not complete request)
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CCCHRequestStorage::RemoveRequestsBySession(
const CCCHSubsession* aSubSession )
{
CCHLOGSTRING( "CCCHRequestStorage::RemoveRequestsBySession: IN" );
TInt error( KErrNotFound );
for ( TInt i( iRequests.Count() - 1 ); i >= 0; i-- )
{
if ( iRequests[ i ].iSubsession == aSubSession )
{
DeleteRequest( i );
error = KErrNone;
}
}
CCHLOGSTRING( "CCCHRequestStorage::RemoveRequestsBySession: OUT" );
return error;
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::NotifySubserviceStatusChangeL
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCCHRequestStorage::NotifyServiceStatesChange(
TServiceStatus aNewStatus )
{
CCHLOGSTRING( "CCCHRequestStorage::NotifyServiceStatesChange: IN" );
//deliver the status event to all subsessions
for ( TInt i = 0; i < iSubsessions.Count(); i++ )
{
iSubsessions[ i ]->ServiceEventOccured( aNewStatus );
}
CCHLOGSTRING( "CCCHRequestStorage::NotifyServiceStatesChange: OUT" );
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::DeleteRequest
// Delete message object
// Delete entry from array
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCCHRequestStorage::DeleteRequest( TInt aIndex )
{
CCHLOGSTRING( "CCCHRequestStorage::DeleteRequest: IN" );
CCHLOGSTRING2("CCCHRequestStorage::DeleteRequest: Index = %d", aIndex );
if ( iRequests.Count() > aIndex )
{
delete iRequests[ aIndex ].iMessage;
iRequests[ aIndex ].iMessage = NULL;
// Remove entry from storage
iRequests.Remove( aIndex );
}
CCHLOGSTRING( "CCCHRequestStorage::DeleteRequest: OUT" );
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::ScanNetworks
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCCHRequestStorage::ScanNetworks()
{
// ETrue indicates wlan network scan
iServer.ConnMonHandler().ScanNetworks( ETrue );
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::AddSession
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCCHRequestStorage::AddSession(
CCCHSubsession* aSubSession )
{
CCHLOGSTRING( "CCCHRequestStorage::AddSession: IN" );
if( KErrNotFound == iSubsessions.Find( aSubSession ) )
{
iSubsessions.Append( aSubSession );
}
CCHLOGSTRING( "CCCHRequestStorage::AddSession: OUT" );
}
// ---------------------------------------------------------------------------
// CCCHRequestStorage::RemoveSession
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CCCHRequestStorage::RemoveSession(
const CCCHSubsession* aSubSession )
{
CCHLOGSTRING( "CCCHRequestStorage::RemoveSession: IN" );
TInt error( KErrNotFound );
for ( TInt i = 0; i < iSubsessions.Count(); i++ )
{
if ( iSubsessions[ i ] == aSubSession )
{
iSubsessions.Remove( i );
error = KErrNone;
break;
}
}
CCHLOGSTRING( "CCCHRequestStorage::RemoveSession: OUT" );
return error;
}
// ========================== OTHER EXPORTED FUNCTIONS =======================
// End of File