diff -r a2efdd544abf -r b47902b73a93 networkprotocolmodules/privacyprotocolmodule/PrivacyProtocolModule/src/privacysession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkprotocolmodules/privacyprotocolmodule/PrivacyProtocolModule/src/privacysession.cpp Fri Jun 04 10:34:15 2010 +0100 @@ -0,0 +1,462 @@ +// Copyright (c) 2007-2009 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: +// privacyserver.cpp +// +// + +#include "lbsdevloggermacros.h" +#include "privacysession.h" +#include "privacyrequestinfo.h" +#include "privacyprotocol.h" +#include "EPos_PrivacyServerPanic.h" +#include + + +/** +Constructor. + +@param aProtocol Interface to send privacy requests to. +*/ +CPrivacySession::CPrivacySession(MPrivacyProtocol& aProtocol, + TLbsProxyApiType aApiType) : + iProtocol(aProtocol), + iApiType(aApiType) + { + LBSLOG(ELogP1, "CPrivacySession::CPrivacySession()\n"); + } + + +/** +Destructor. +*/ +CPrivacySession::~CPrivacySession() + { + LBSLOG(ELogP1, "CPrivacySession::~CPrivacySession()\n"); + } + + +/** +Called when the session is created. +*/ +void CPrivacySession::CreateL() + { + LBSLOG(ELogP1, "CPrivacySession::CreateL() Begin\n"); + Server().IncSessionCount(iApiType); + LBSLOG(ELogP1, "CPrivacySession::CreateL() End\n"); + } + + +/** +Called when a message is received for this session. + +@param aMessage The message from the client. +*/ +void CPrivacySession::ServiceL(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::ServiceL() Begin\n"); + switch (aMessage.Function()) + { + case ELbsPrivacyServerNotifyLocation: + NotifyLocationRequest(aMessage); + break; + + case ELbsPrivacyServerVerifyLocation: + VerifyLocationRequest(aMessage); + break; + + case ELbsPrivacyServerNotifyVerificationTimeout: + NotifyVerificationTimeout(aMessage); + break; + + case ELbsPrivacyServerCancelVerifyLocationRequest: + CancelVerifyLocationRequest(aMessage); + break; + + case ELbsPrivacyServerNewPrivacyRequestLocal: + case ELbsPrivacyServerNewPrivacyRequestNetwork: + NewPrivacyRequest(aMessage); + break; + + case ELbsPrivacyServerRepeatPrivacyRequestLocal: + case ELbsPrivacyServerRepeatPrivacyRequestNetwork: + RepeatPrivacyRequest(aMessage); + break; + + case ELbsPrivacyServerCompleteRequest: + CompleteRequest(aMessage); + break; + + default: + User::Leave(KErrNotSupported); + } + LBSLOG(ELogP1, "CPrivacySession::ServiceL() End\n"); + } + + +/** +Called when the session disconnects. + +@param aMessage The message from the client. +*/ +void CPrivacySession::Disconnect(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::Disconnect() Begin\n"); + iProtocol.SessionDisconnected(this); + Server().DecSessionCount(iApiType); + CSession2::Disconnect(aMessage); + LBSLOG(ELogP1, "CPrivacySession::Disconnect() End\n"); + } + + +/** +Get a reference to the server for this session. + +@return A reference to the CPrivacyServer. +*/ +CPrivacyServer& CPrivacySession::Server() + { + return *static_cast(const_cast(CSession2::Server())); + } + + +/** +Cancel a verification request. + +@param aMessage The message from the client. +*/ +void CPrivacySession::CancelVerifyLocationRequest(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::CancelVerifyLocationRequest() Begin\n"); + + CCancelPrivacyRequestInfo* cancelInfo = NULL; + TRAPD(err, cancelInfo = CCancelPrivacyRequestInfo::NewL()); + if (err != KErrNone) + { + // Error creating request info object, complete with the error and return + aMessage.Complete(err); + return; + } + + cancelInfo->SetRequestId(aMessage.Int0()); + cancelInfo->SetCancelReason(aMessage.Int1()); + + if (!IsRequestInfoValid(*cancelInfo)) + { + aMessage.Panic(KPosPrivacyPanicCategory, + EPosPrivSrvPanicRequestOverflow); + delete cancelInfo; + return; + } + + aMessage.Complete(KErrNone); + iProtocol.CancelVerifyLocationRequest(cancelInfo); + + LBSLOG(ELogP1, "CPrivacySession::CancelVerifyLocationRequest() End\n"); + } + + +/** +Submit a notification request. + +@param aMessage The message from the client. +*/ +void CPrivacySession::NotifyLocationRequest(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::NotifyLocationRequest() Begin\n"); + + TLbsNetSessionId sessionId; + iProtocol.GetNextSessionId(sessionId); + + TPckg pkgReqId(sessionId.SessionNum()); + TInt error = aMessage.Write(1,pkgReqId); + if(error != KErrNone) + { + aMessage.Complete(error); + return; + } + + // NOTE: requestInfo does not complete the message in this case + CPrivacyRequestInfo* requestInfo = NULL; + TRAPD(err, requestInfo = CPrivacyRequestInfo::NewL(aMessage)); + if (err != KErrNone) + { + // Error creating request info object, complete with the error and return + aMessage.Complete(err); + return; + } + + TLbsExternalRequestInfo2 extRequestInfo; + TPckg extRequestInfoPkg(extRequestInfo); + aMessage.Read(0,extRequestInfoPkg); + requestInfo->SetRequestInfo(extRequestInfo); + + requestInfo->SetRequestId(sessionId.SessionNum()); + + TLbsNetPosRequestPrivacy netPosRequestPrivacy; + TPckg netPosRequestPrivacyPkg(netPosRequestPrivacy); + aMessage.Read(2,netPosRequestPrivacyPkg); + requestInfo->SetRequestPrivacy(netPosRequestPrivacy); + + requestInfo->SetIsResponseRequired(EFalse); + + if (!IsRequestInfoValid(*requestInfo)) + { + aMessage.Panic(KPosPrivacyPanicCategory, + EPosPrivSrvPanicInvalidArguments); + delete requestInfo; + return; + } + + iProtocol.NotifyLocationRequest(requestInfo); + aMessage.Complete(KErrNone); + + LBSLOG(ELogP1, "CPrivacySession::NotifyLocationRequest() End\n"); + } + + +/** +Submit a notification timeout request. + +@param aMessage The message from the client. +*/ +void CPrivacySession::NotifyVerificationTimeout(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::NotifyVerificationTimeout() Begin\n"); + + // NOTE: requestInfo does not complete the message in this case + CPrivacyRequestInfo* requestInfo = NULL; + TRAPD(err, requestInfo = CPrivacyRequestInfo::NewL(aMessage)); + if (err != KErrNone) + { + // Error creating request info object, complete with the error and return + aMessage.Complete(err); + return; + } + + TLbsExternalRequestInfo2 extRequestInfo; + TPckg extRequestInfoPkg(extRequestInfo); + aMessage.Read(0,extRequestInfoPkg); + requestInfo->SetRequestInfo(extRequestInfo); + + requestInfo->SetRequestId(aMessage.Int1()); + + TLbsNetPosRequestPrivacy netPosRequestPrivacy; + TPckg netPosRequestPrivacyPkg(netPosRequestPrivacy); + aMessage.Read(2,netPosRequestPrivacyPkg); + requestInfo->SetRequestPrivacy(netPosRequestPrivacy); + + requestInfo->SetIsResponseRequired(EFalse); + + if (!IsRequestInfoValid(*requestInfo)) + { + aMessage.Panic(KPosPrivacyPanicCategory, + EPosPrivSrvPanicInvalidArguments); + delete requestInfo; + return; + } + + iProtocol.NotifyVerificationTimeout(requestInfo); + aMessage.Complete(KErrNone); + + LBSLOG(ELogP1, "CPrivacySession::NotifyVerificationTimeout() End\n"); + } + + +/** +Submit a verify location request. + +@param aMessage The message from the client. +*/ +void CPrivacySession::VerifyLocationRequest(const RMessage2& aMessage) + { + LBSLOG(ELogP1, "CPrivacySession::VerifyLocationRequest() Begin\n"); + + TLbsNetSessionId sessionId; + iProtocol.GetNextSessionId(sessionId); + + TPckg pkgReqId(sessionId.SessionNum()); + TInt error = aMessage.Write(0,pkgReqId); + if(error != KErrNone) + { + aMessage.Complete(error); + return; + } + + RSemaphore semaphore; + error = semaphore.Open(aMessage, 3, EOwnerThread); + if(error != KErrNone) + { + aMessage.Complete(error); + return; + } + semaphore.Signal(); + semaphore.Close(); + + CPrivacyRequestInfo* requestInfo = NULL; + TRAPD(err, requestInfo = CPrivacyRequestInfo::NewL(aMessage)); + if (err != KErrNone) + { + // Error creating request info object, complete with the error and return + aMessage.Complete(err); + return; + } + + requestInfo->SetRequestId(sessionId.SessionNum()); + + TLbsExternalRequestInfo2 extRequestInfo; + TPckg extRequestInfoPkg(extRequestInfo); + aMessage.Read(1,extRequestInfoPkg); + requestInfo->SetRequestInfo(extRequestInfo); + + TLbsNetPosRequestPrivacy netPosRequestPrivacy; + TPckg netPosRequestPrivacyPkg(netPosRequestPrivacy); + aMessage.Read(2,netPosRequestPrivacyPkg); + requestInfo->SetRequestPrivacy(netPosRequestPrivacy); + + requestInfo->SetIsResponseRequired(ETrue); + + if (!IsRequestInfoValid(*requestInfo)) + { + aMessage.Panic(KPosPrivacyPanicCategory, + EPosPrivSrvPanicInvalidArguments); + delete requestInfo; + return; + } + + iProtocol.VerifyLocationRequest(requestInfo); + // The message should be completed later in this case + + LBSLOG(ELogP1, "CPrivacySession::VerifyLocationRequest() End\n"); + } + +void CPrivacySession::NewPrivacyRequest(const RMessage2& aMessage) + { + TLbsNetSessionId sessionId; + iProtocol.GetNextSessionId(sessionId); + + TPckg pkgReqId(sessionId.SessionNum()); + TInt error = aMessage.Write(0,pkgReqId); + if(error != KErrNone) + { + aMessage.Complete(error); + return; + } + + RSemaphore semaphore; + error = semaphore.Open(aMessage, 3, EOwnerThread); + if(error != KErrNone) + { + aMessage.Complete(error); + return; + } + semaphore.Signal(); + semaphore.Close(); + + PrivacyRequest(aMessage, sessionId.SessionNum()); + } + +void CPrivacySession::RepeatPrivacyRequest(const RMessage2& aMessage) + { + PrivacyRequest(aMessage, aMessage.Int0()); + } + +void CPrivacySession::PrivacyRequest(const RMessage2& aMessage, TInt aRequestId) + { + CPrivacyRequestInfo* requestInfo = NULL; + TRAPD(err, requestInfo = CPrivacyRequestInfo::NewL(aMessage)); + if (err != KErrNone) + { + // Error creating request info object, complete with the error and return + aMessage.Complete(err); + return; + } + + requestInfo->SetRequestId(aRequestId); + + TLbsExternalRequestInfo2 extRequestInfo; + TPckg extRequestInfoPkg(extRequestInfo); + aMessage.Read(1,extRequestInfoPkg); + requestInfo->SetRequestInfo(extRequestInfo); + + TLbsNetPosRequestPrivacy netPosRequestPrivacy; + TPckg netPosRequestPrivacyPkg(netPosRequestPrivacy); + aMessage.Read(2,netPosRequestPrivacyPkg); + + requestInfo->SetRequestPrivacy(netPosRequestPrivacy); + + requestInfo->SetIsResponseRequired(ETrue); + requestInfo->SetIsSessionCompleteAutomatic(EFalse); + requestInfo->SetConvertResponseCode(EFalse); + + if (!IsRequestInfoValid(*requestInfo)) + { + aMessage.Complete(netPosRequestPrivacy.RequestAction()); + delete requestInfo; + return; + } + + iProtocol.PrivacyLocationRequest(requestInfo); + // The message should be completed later in this case + + } + +void CPrivacySession::CompleteRequest(const RMessage2& aMessage) + { + + TUint32 requestId(aMessage.Int0()); + TInt reason(aMessage.Int1()); + + iProtocol.CompletePrivacyRequest(requestId, reason); + + aMessage.Complete(KErrNone); + } + +/** +Validates the data values for a privacy request. + +@param aRequestInfo The request data to validate +*/ +TBool CPrivacySession::IsRequestInfoValid(const CRequestInfoBase& aRequestInfo) + { + LBSLOG(ELogP1, "CPrivacySession::IsRequestInfoValid() Begin\n"); + + TBool valid = (aRequestInfo.GetRequestId() >= 1); + + switch (aRequestInfo.Type()) + { + case CRequestInfoBase::EPrivacyRequestTypeRequest: + { + break; + } + case CRequestInfoBase::EPrivacyRequestTypeCancel: + { + const CCancelPrivacyRequestInfo& cancelInfo = + static_cast(aRequestInfo); + + valid &= (cancelInfo.CancelReason() == KErrCancel + || cancelInfo.CancelReason() == KErrTimedOut); + break; + } + default: + { + valid = EFalse; + break; + } + } + + return valid; + + LBSLOG(ELogP1, "CPrivacySession::IsRequestInfoValid() End\n"); + } +