/*
* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: EAP-session inside EAP-server.
*
*/
/*
* %version: 32 %
*/
#define __REFERENCE_CAPABILITY_NAMES__
#define __INCLUDE_CAPABILITY_NAMES__
#include "EapSession.h"
#include "EapServerStrings.h"
#include "EapServer.h"
#include "EapServerProcessHandler.h"
#include "EapServerClientDef.h"
#include "abs_eap_am_tools.h"
#include "EapTraceSymbian.h"
#include "eap_automatic_variable.h"
/*
CEapSession
*/
const TInt KMaxMessageLength = 1000000;
// -----------------------------------------------------------------------------------------
// construct/destruct
CEapSession::CEapSession()
: iReceiveActive(EFalse)
, iEapProcessHandler(0)
, iTools(0)
{
EAP_TRACE_DEBUG_SYMBIAN((_L("CEapSession::CEapSession(): this=0x%08x"),
this));
EAP_TRACE_RETURN_STRING_SYMBIAN(_L("returns: CEapSession::CEapSession()"));
}
// -----------------------------------------------------------------------------------------
void CEapSession::ConstructL(CEapServer& /* aServer */, abs_eap_am_tools_c * const tools)
{
EAP_TRACE_DEBUG(
tools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ConstructL(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(tools, "returns: CEapSession::ConstructL()");
iTools = tools;
iEapProcessHandler = CEapServerProcessHandler::NewL();
iEapProcessHandler->ConstructL(this, iTools);
CActiveScheduler::Add(iEapProcessHandler);
}
// -----------------------------------------------------------------------------------------
CEapSession::~CEapSession()
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::~CEapSession(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::~CEapSession()");
// cancel any receive
CancelReceive();
if (iEapProcessHandler != 0)
{
delete iEapProcessHandler;
iEapProcessHandler = 0;
}
// decrement session count, so server may terminate if no longer needed
Server()->DecrementSessions();
}
// -----------------------------------------------------------------------------------------
CEapServer* CEapSession::Server() const
/**
Return the EAP-server.
This deliberately hides the ugly casts around the code.
*/
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::Server(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::Server()");
return const_cast<CEapServer*>(static_cast<const CEapServer*>(CSession2::Server()));
}
// -----------------------------------------------------------------------------------------
void CEapSession::CheckCapabilityL(
const RMessage2& aMessage,
const TBool aMustHaveCapabilityWhenTrue,
const TCapability aCapability,
const char *aDiagnostic)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::CheckCapabilityL(): this=0x%08x: aMessage.Function()=%d=%s\n"),
this,
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function())));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::CheckCapabilityL()");
if (aMustHaveCapabilityWhenTrue != aMessage.HasCapability(aCapability, aDiagnostic))
{
// Capability check failed.
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("ERROR: CEapSession::CheckCapability(): aMessage.Function()=%d=%s, failed capability check: %d=%s, %s\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function()),
aCapability,
CapabilityNames[aCapability],
aDiagnostic));
Server()->PanicClient(EBadRequest);
User::Leave(EBadRequest);
}
else
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::CheckCapability(): aMessage.Function()=%d=%s, OK capability check: %d=%s\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function()),
aCapability,
CapabilityNames[aCapability]));
}
}
// -----------------------------------------------------------------------------------------
// service dispatcher - from CSharableSession
void CEapSession::ServiceL(const RMessage2& aMessage)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("-start--------------------------------------------------------------------\n")));
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): this=0x%08x: starts, aMessage.Function()=%d=%s\n"),
this,
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function())));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::ServiceL()");
{
#if 0
// Add this later.
CheckCapabilityL(
aMessage,
ETrue,
ECapabilityNetworkControl,
"EAP-SERVER: Missing ECapabilityNetworkControl");
#endif
CheckCapabilityL(
aMessage,
ETrue,
ECapabilityReadDeviceData,
"EAP-SERVER: Missing ECapabilityReadDeviceData");
CheckCapabilityL(
aMessage,
ETrue,
ECapabilityWriteDeviceData,
"EAP-SERVER: Missing ECapabilityWriteDeviceData");
}
if (aMessage.Function() == EEapIfCancelReceive)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): aMessage.Function()=%d=%s, calls CancelReceive()\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function())));
CancelReceive();
return;
}
// length of passed descriptor (1st parameter passed from client)
TInt deslen = aMessage.GetDesLength(0);
if (deslen > KMaxMessageLength)
{
Server()->PanicClient(EBadRequest);
return;
}
// Passed data will be saved in this descriptor.
RBuf8 buffer;
// Max length set to the value of "deslen", but current length is zero
buffer.CreateL(deslen);
// Do the right cleanup if anything subsequently goes wrong
buffer.CleanupClosePushL();
// Copy the client's descriptor data into our buffer.
aMessage.ReadL(0,buffer,0);
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): calls buffer.Length()\n")));
TUint aLength = buffer.Length();
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): calls buffer.Ptr(): aLength=%d\n"),
aLength));
const void * aData = buffer.Ptr();
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): aData=0x%08x, aLength=%d\n"),
aData,
aLength));
EAP_TRACE_DATA_DEBUG(
iTools,
EAP_TRACE_FLAGS_NEVER,
(EAPL("CEapSession::ServiceL()"),
aData,
aLength));
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): switch aMessage.Function()=%d=%s, iEapProcessHandler=0x%08x\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function()),
iEapProcessHandler));
switch (aMessage.Function())
{
case EEapCoreIfNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapCoreIfNew\n")));
ReceiveAll();
iEapProcessHandler->SaveMessage(EEapCoreIfNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapPluginNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapPluginNew\n")));
iEapProcessHandler->SaveMessage(EEapPluginNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapSettingsNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapSettingsNew\n")));
iEapProcessHandler->SaveMessage(EEapSettingsNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapPacStoreNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapPacStoreNew\n")));
iEapProcessHandler->SaveMessage(EEapPacStoreNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EWapiCoreIfNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EWapiCoreIfNew\n")));
ReceiveAll();
iEapProcessHandler->SaveMessage(EWapiCoreIfNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EWapiSettingsNew:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EWapiSettingsNew\n")));
ReceiveAll();
iEapProcessHandler->SaveMessage(EWapiSettingsNew, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapCoreProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapCoreProcessData\n")));
// Read message
iEapProcessHandler->SaveMessage(EEapCoreProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapPluginProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapPluginProcessData\n")));
iEapProcessHandler->SaveMessage(EEapPluginProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapSettingsProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapSettingsProcessData\n")));
iEapProcessHandler->SaveMessage(EEapSettingsProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapPacStoreProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapPacStoreProcessData\n")));
iEapProcessHandler->SaveMessage(EEapPacStoreProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EWapiCoreProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EWapiCoreProcessData\n")));
iEapProcessHandler->SaveMessage(EWapiCoreProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EWapiSettingsProcessData:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EWapiSettingsProcessData\n")));
iEapProcessHandler->SaveMessage(EWapiSettingsProcessData, aData, aLength);
aMessage.Complete(KErrNone);
break;
case EEapIfReqReceive: // TAny& aBuffer - async
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapIfReqReceive\n")));
__ASSERT_DEBUG(!iReceiveActive, Server()->PanicClient(EReceiveReceiveAlreadyActive));
// remember receive request
iReceiveMessage = aMessage;
iReceiveActive=ETrue;
iEapProcessHandler->Activate();
break;
case EEapIfCancelReceive:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): EEapIfCancelReceive\n")));
CancelReceive();
break;
default:
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("ERROR: CEapSession::ServiceL(): unknown aMessage.Function()=%d=%s, calls Server()->PanicClient()\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function())));
Server()->PanicClient(EBadRequest);
};
CleanupStack::PopAndDestroy(&buffer);
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ServiceL(): ends aMessage.Function()=%d=%s\n"),
aMessage.Function(),
EapServerStrings::GetEapRequestsString(aMessage.Function())));
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("-end----------------------------------------------------------------------\n")));
}
// -----------------------------------------------------------------------------------------
void CEapSession::ReceiveAll()
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::ReceiveAll(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::ReceiveAll()");
}
// -----------------------------------------------------------------------------------------
void CEapSession::Receive(RMessage2& aBuffer)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::Receive(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::Receive()");
__ASSERT_DEBUG(!iReceiveActive,Server()->PanicClient(EReceiveReceiveAlreadyActive));
// remember receive request
iReceiveMessage = aBuffer;
iReceiveActive=ETrue;
}
// -----------------------------------------------------------------------------------------
void CEapSession::CancelReceive()
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::CancelReceive(): this=0x%08x\n"),
this));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::CancelReceive()");
if (!iReceiveActive)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::CancelReceive(): No receive active\n")));
return;
}
iReceiveMessage.Complete(KErrCancel);
iReceiveActive=EFalse;
}
// -----------------------------------------------------------------------------------------
TBool CEapSession::GetReceiveActive()
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::GetReceiveActive(): this=0x%08x: iReceiveActive=%d\n"),
this,
iReceiveActive));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::GetReceiveActive()");
return iReceiveActive;
}
// -----------------------------------------------------------------------------------------
eap_status_e CEapSession::SendData(EapMessageBuffer * const message)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::SendData(): this=0x%08x: message->GetRequestType()=%d=%s, message->GetData()->Length()=%d\n"),
this,
message->GetRequestType(),
EapServerStrings::GetEapRequestsString(message->GetRequestType()),
message->GetData()->Length()));
EAP_TRACE_RETURN_STRING(iTools, "returns: CEapSession::SendData()");
if (!iReceiveActive)
{
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::SendData(): No receive active\n")));
return EAP_STATUS_RETURN(iTools, iTools->convert_am_error_to_eapol_error(KErrCancel));
}
TInt error(KErrNone);
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::SendData(): calls iReceiveMessage.Write()\n")));
error = iReceiveMessage.Write(0, message->GetData()->Des());
EAP_TRACE_DEBUG(
iTools,
TRACE_FLAGS_DEFAULT,
(EAPL("CEapSession::SendData(): calls iReceiveMessage.Complete(): Write() error=%d\n"),
error));
iReceiveMessage.Complete(KErrNone);
iReceiveActive=EFalse;
return EAP_STATUS_RETURN(iTools, iTools->convert_am_error_to_eapol_error(error));
}
// -----------------------------------------------------------------------------------------
// end