diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/src/cpacketservicesdispatcher.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/src/cpacketservicesdispatcher.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2765 @@ +// Copyright (c) 2008-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: +// + +#include "cpacketservicesdispatcher.h" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include "ctsydispatcherpanic.h" +#include "tdispatcherholder.h" +#include + +CPacketServicesDispatcher::CPacketServicesDispatcher( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + : iLtsyFactoryV1(aLtsyFactory), + iMessageManagerCallback(aMessageManagerCallback), + iRequestAsyncOneShot(aRequestAsyncOneShot) + { + } // CPacketServicesDispatcher::CPacketServicesDispatcher + + +CPacketServicesDispatcher::~CPacketServicesDispatcher() + { + } // CPacketServicesDispatcher::~CPacketServicesDispatcher + + +CPacketServicesDispatcher* CPacketServicesDispatcher::NewLC( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CPacketServicesDispatcher* self = + new (ELeave) CPacketServicesDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } // CPacketServicesDispatcher::NewLC + + +CPacketServicesDispatcher* CPacketServicesDispatcher::NewL( + MLtsyDispatchFactoryV1& aLtsyFactory, + MmMessageManagerCallback& aMessageManagerCallback, + CRequestQueueOneShot& aRequestAsyncOneShot) + { + TSYLOGENTRYEXIT; + CPacketServicesDispatcher* self = + CPacketServicesDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot); + CleanupStack::Pop (self); + return self; + } // CPacketServicesDispatcher::NewL + + +void CPacketServicesDispatcher::ConstructL() +/** + * Second phase constructor. + */ + { + TSYLOGENTRYEXIT; + + // Get the Licensee LTSY interfaces related to PacketServices functionality + // from the factory + + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId)) + { + TAny* packetAttachInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesPacketAttach::KLtsyDispatchPacketServicesPacketAttachApiId, + packetAttachInterface); + iLtsyDispatchPacketServicesPacketAttach = + static_cast(packetAttachInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesPacketAttach, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId)) + { + TAny* getPacketAttachModeInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetPacketAttachMode::KLtsyDispatchPacketServicesGetPacketAttachModeApiId, + getPacketAttachModeInterface); + iLtsyDispatchPacketServicesGetPacketAttachMode = + static_cast(getPacketAttachModeInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetPacketAttachMode, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus::KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId)) + { + TAny* getPacketNetworkRegistrationStatusInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus::KLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatusApiId, + getPacketNetworkRegistrationStatusInterface); + iLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus = + static_cast(getPacketNetworkRegistrationStatusInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId)) + { + TAny* packetDetachInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesPacketDetach::KLtsyDispatchPacketServicesPacketDetachApiId, + packetDetachInterface); + iLtsyDispatchPacketServicesPacketDetach = + static_cast(packetDetachInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesPacketDetach, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId)) + { + TAny* setPdpContextConfigInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetPdpContextConfig::KLtsyDispatchPacketServicesSetPdpContextConfigApiId, + setPdpContextConfigInterface); + iLtsyDispatchPacketServicesSetPdpContextConfig = + static_cast(setPdpContextConfigInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetPdpContextConfig, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId)) + { + TAny* modifyActivePdpContextInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesModifyActivePdpContext::KLtsyDispatchPacketServicesModifyActivePdpContextApiId, + modifyActivePdpContextInterface); + iLtsyDispatchPacketServicesModifyActivePdpContext = + static_cast(modifyActivePdpContextInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesModifyActivePdpContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId)) + { + TAny* initialisePdpContextInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesInitialisePdpContext::KLtsyDispatchPacketServicesInitialisePdpContextApiId, + initialisePdpContextInterface); + iLtsyDispatchPacketServicesInitialisePdpContext = + static_cast(initialisePdpContextInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesInitialisePdpContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId)) + { + TAny* deletePdpContextInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesDeletePdpContext::KLtsyDispatchPacketServicesDeletePdpContextApiId, + deletePdpContextInterface); + iLtsyDispatchPacketServicesDeletePdpContext = + static_cast(deletePdpContextInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesDeletePdpContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId)) + { + TAny* setPacketAttachModeInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetPacketAttachMode::KLtsyDispatchPacketServicesSetPacketAttachModeApiId, + setPacketAttachModeInterface); + iLtsyDispatchPacketServicesSetPacketAttachMode = + static_cast(setPacketAttachModeInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetPacketAttachMode, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesNotifyPacketStatusChange::KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId)) + { + TAny* notifyPacketStatusChangeInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesNotifyPacketStatusChange::KLtsyDispatchPacketServicesNotifyPacketStatusChangeApiId, + notifyPacketStatusChangeInterface); + iLtsyDispatchPacketServicesNotifyPacketStatusChange = + static_cast(notifyPacketStatusChangeInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesNotifyPacketStatusChange, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId)) + { + TAny* setDefaultPdpContextParamsInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams::KLtsyDispatchPacketServicesSetDefaultPdpContextGprsParamsApiId, + setDefaultPdpContextParamsInterface); + iLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams = + static_cast(setDefaultPdpContextParamsInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params::KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId)) + { + TAny* setDefaultPdpContextParamsInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params::KLtsyDispatchPacketServicesSetDefaultPdpContextR99R4ParamsApiId, + setDefaultPdpContextParamsInterface); + iLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params = + static_cast(setDefaultPdpContextParamsInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId)) + { + TAny* activatePdpContextInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesActivatePdpContext::KLtsyDispatchPacketServicesActivatePdpContextApiId, + activatePdpContextInterface); + iLtsyDispatchPacketServicesActivatePdpContext = + static_cast(activatePdpContextInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesActivatePdpContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId)) + { + TAny* setPdpContextQosInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetPdpContextQosGprs::KLtsyDispatchPacketServicesSetPdpContextQosGprsApiId, + setPdpContextQosInterface); + iLtsyDispatchPacketServicesSetPdpContextQosGprs = + static_cast(setPdpContextQosInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetPdpContextQosGprs, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetPdpContextQosR99R4::KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId)) + { + TAny* setPdpContextQosInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetPdpContextQosR99R4::KLtsyDispatchPacketServicesSetPdpContextQosR99R4ApiId, + setPdpContextQosInterface); + iLtsyDispatchPacketServicesSetPdpContextQosR99R4 = + static_cast(setPdpContextQosInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetPdpContextQosR99R4, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if (iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesSetPdpContextQosR5::KLtsyDispatchPacketServicesSetPdpContextQosR5ApiId)) + { + TAny* setPdpContextQosInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesSetPdpContextQosR5::KLtsyDispatchPacketServicesSetPdpContextQosR5ApiId, + setPdpContextQosInterface); + iLtsyDispatchPacketServicesSetPdpContextQosR5 = + static_cast(setPdpContextQosInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesSetPdpContextQosR5, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest::KLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequestApiId)) + { + TAny* rejectNetworkInitiatedContextActivationRequestInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest::KLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequestApiId, + rejectNetworkInitiatedContextActivationRequestInterface); + iLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest = + static_cast(rejectNetworkInitiatedContextActivationRequestInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId)) + { + TAny* deactivatePdpContextInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesDeactivatePdpContext::KLtsyDispatchPacketServicesDeactivatePdpContextApiId, + deactivatePdpContextInterface); + iLtsyDispatchPacketServicesDeactivatePdpContext = + static_cast(deactivatePdpContextInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesDeactivatePdpContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesAddPacketFilter::KLtsyDispatchPacketServicesAddPacketFilterApiId)) + { + TAny* addPacketFilterInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesAddPacketFilter::KLtsyDispatchPacketServicesAddPacketFilterApiId, + addPacketFilterInterface); + iLtsyDispatchPacketServicesAddPacketFilter = + static_cast(addPacketFilterInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesAddPacketFilter, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId)) + { + TAny* addGetStatusInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetStatus::KLtsyDispatchPacketServicesGetStatusApiId, + addGetStatusInterface); + iLtsyDispatchPacketServicesGetStatus = + static_cast(addGetStatusInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetStatus, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId)) + { + TAny* getStaticCapabilitiesInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetStaticCapabilities::KLtsyDispatchPacketServicesGetStaticCapabilitiesApiId, + getStaticCapabilitiesInterface); + iLtsyDispatchPacketServicesGetStaticCapabilities = + static_cast(getStaticCapabilitiesInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetStaticCapabilities, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId)) + { + TAny* getMaxNoMonitoredServiceListsInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists::KLtsyDispatchPacketServicesGetMaxNoMonitoredServiceListsApiId, + getMaxNoMonitoredServiceListsInterface); + iLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists = + static_cast(getMaxNoMonitoredServiceListsInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId)) + { + TAny* getMaxNoActiveServicesInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetMaxNoActiveServices::KLtsyDispatchPacketServicesGetMaxNoActiveServicesApiId, + getMaxNoActiveServicesInterface); + iLtsyDispatchPacketServicesGetMaxNoActiveServices = + static_cast(getMaxNoActiveServicesInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetMaxNoActiveServices, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus::KLtsyDispatchPacketServicesGetMbmsNetworkServiceStatusApiId)) + { + TAny* getMbmsNetworkServiceStatus = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus::KLtsyDispatchPacketServicesGetMbmsNetworkServiceStatusApiId, + getMbmsNetworkServiceStatus); + iLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus = + static_cast(getMbmsNetworkServiceStatus); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesInitialiseMbmsContext::KLtsyDispatchPacketServicesInitialiseMbmsContextApiId)) + { + TAny* initialiseMbmsContext = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesInitialiseMbmsContext::KLtsyDispatchPacketServicesInitialiseMbmsContextApiId, + initialiseMbmsContext); + iLtsyDispatchPacketServicesInitialiseMbmsContext = + static_cast(initialiseMbmsContext); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesInitialiseMbmsContext, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList::KLtsyDispatchPacketServicesUpdateMbmsMonitorServiceListApiId)) + { + TAny* updateMbmsMonitorServiceList = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList::KLtsyDispatchPacketServicesUpdateMbmsMonitorServiceListApiId, + updateMbmsMonitorServiceList); + iLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList = + static_cast(updateMbmsMonitorServiceList); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesUpdateMbmsSessionList::KLtsyDispatchPacketServicesUpdateMbmsSessionListApiId)) + { + TAny* updateMbmsSessionList = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesUpdateMbmsSessionList::KLtsyDispatchPacketServicesUpdateMbmsSessionListApiId, + updateMbmsSessionList); + iLtsyDispatchPacketServicesUpdateMbmsSessionList = + static_cast(updateMbmsSessionList); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesUpdateMbmsSessionList, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPacketServicesFuncUnitId, MLtsyDispatchPacketServicesRemovePacketFilter::KLtsyDispatchPacketServicesRemovePacketFilterApiId)) + { + TAny* removePacketFilterInterface = NULL; + iLtsyFactoryV1.GetDispatchHandler( + MLtsyDispatchPacketServicesRemovePacketFilter::KLtsyDispatchPacketServicesRemovePacketFilterApiId, + removePacketFilterInterface); + iLtsyDispatchPacketServicesRemovePacketFilter = + static_cast(removePacketFilterInterface); + __ASSERT_DEBUG(iLtsyDispatchPacketServicesRemovePacketFilter, CtsyDispatcherPanic(EInvalidNullPtr)); + } + + } // CPacketServicesDispatcher::ConstructL + +void CPacketServicesDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder) +/** + * Set the dispatcher holder. + * + * @param aDispatcherHolder Reference to dispatcher holder. + */ + { + TSYLOGENTRYEXIT; + + iDispatcherHolder = &aDispatcherHolder; + } // CPacketServicesDispatcher::SetDispatcherHolder + +TInt CPacketServicesDispatcher::DispatchPacketAttachL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketService::Attach() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + if (iLtsyDispatchPacketServicesPacketAttach) + { + ret = iLtsyDispatchPacketServicesPacketAttach->HandlePacketAttachReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchPacketAttachL + +TInt CPacketServicesDispatcher::DispatchGetPacketAttachModeL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketGetAttachMode + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle method in Licensee LTSY + if (iLtsyDispatchPacketServicesGetPacketAttachMode) + { + + // Indicator to whether this call made during the open call + TBool initPhase; + aDataPackage->UnPackData(initPhase); + + if (!initPhase) + { + ret = iLtsyDispatchPacketServicesGetPacketAttachMode->HandleGetPacketAttachModeReqL(); + } + } + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetPacketAttachModeL + +TInt CPacketServicesDispatcher::DispatchGetPacketNetworkRegistrationStatusL() +/** + * Pass EPacketGetNtwkRegStatus request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + if (iLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus) + { + ret = iLtsyDispatchPacketServicesGetPacketNetworkRegistrationStatus->HandleGetPacketNetworkRegistrationStatusReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetPacketNetworkRegistrationStatusL + +TInt CPacketServicesDispatcher::DispatchPacketDetachL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketService::Detach() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Unpack data for this request inside the if statement if required, + if (iLtsyDispatchPacketServicesPacketDetach) + { + ret = iLtsyDispatchPacketServicesPacketDetach->HandlePacketDetachReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchPacketDetachL + +TInt CPacketServicesDispatcher::DispatchSetPdpContextConfigL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextSetConfig + * and pass request on to Licensee LTSY. + * + * The following function uses a PCO buffer: + * The purpose of the protocol configuration options (PCO) is to transfer external network protocol options + * associated with a PDP context activation, and transfer additional (protocol) data + * (e.g. configuration parameters, error codes or messages/events) associated with an external protocol + * or an application. + * The protocol configuration options (PCO) is a type 4 information element with a minimum length of 3 + * octets and a maximum length of 253 octets + * In order to generate the PCO buffer a TTlvStruct object is being used. The TTlvStruct wraps the buffers + * inserted to the PCO and identifies the buffers with given IDs. + * + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesSetPdpContextConfig) + { + TInfoName* contextId = NULL; + TPacketDataConfigBase* generalConfig = NULL; + + aDataPackage->UnPackData(&generalConfig, &contextId); + + __ASSERT_DEBUG(generalConfig, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(contextId, CtsyDispatcherPanic(EInvalidNullPtr)); + + switch(generalConfig->ExtensionId()) + { + case TPacketDataConfigBase::KConfigGPRS: + { + RPacketContext::TContextConfigGPRS* configGPRS = static_cast(generalConfig); + + // Protocol Config Option handling + RPacketContext::TMiscProtocolBuffer pcoBuffer; + pcoBuffer.Zero(); + TPtr8 pcoPtr (const_cast (pcoBuffer.Ptr()), RPacketContext::KMiscProtocolBufferLength); + + TTlvStruct tlv(pcoPtr,0); + + TBuf8 usernameAndPasswordBuffer(KMaxUserAndPassLength); + + // Generates the username, password and requestID buffer as described in 3GPP specification 3G TS 24.008 + ConvertUsernameAndPasswordToPCOBuffer(configGPRS->iProtocolConfigOption.iAuthInfo.iUsername, configGPRS->iProtocolConfigOption.iAuthInfo.iPassword, configGPRS->iProtocolConfigOption.iId, usernameAndPasswordBuffer); + + TPtr8 usernameAndPasswordParamDataPtr(const_cast(usernameAndPasswordBuffer.Ptr()), + usernameAndPasswordBuffer.Length(), usernameAndPasswordBuffer.Length()); + + TBuf8 primaryAndSecondaryDNSBuffer(KPrimaryAndSecondaryDNSLength + 1); + + // Generates the primary and secondary DNS buffers as described in 3GPP specification 3G TS 24.008 + ConvertDNSToPCOBuffer(configGPRS->iProtocolConfigOption.iDnsAddresses.iPrimaryDns, configGPRS->iProtocolConfigOption.iDnsAddresses.iSecondaryDns, configGPRS->iProtocolConfigOption.iId+1, primaryAndSecondaryDNSBuffer); + + // Setting the configurations buffers + TPtr8 primaryAndSecondaryDNSParamDataPtr(const_cast(primaryAndSecondaryDNSBuffer.Ptr()), + primaryAndSecondaryDNSBuffer.Length(), primaryAndSecondaryDNSBuffer.Length()); + + // Set up the TTlvStruct to include the pco details + RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID); + RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID); + + if (tlv.AppendItemL(usenameAndPasswordID, usernameAndPasswordParamDataPtr) != KErrOverflow) + { + if (tlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr) != KErrOverflow) + { + pcoBuffer.SetLength(primaryAndSecondaryDNSParamDataPtr.Length() + usernameAndPasswordParamDataPtr.Length() + 2 * KIDLength); + pcoBuffer.Append(configGPRS->iProtocolConfigOption.iMiscBuffer); + ret = iLtsyDispatchPacketServicesSetPdpContextConfig->HandleSetPdpContextConfigReqL(*contextId, configGPRS->iAccessPointName, + configGPRS->iPdpType, configGPRS->iPdpAddress, pcoBuffer); + } + else + { + ret = KErrNotSupported; + } + } + else + { + ret = KErrNotSupported; + } + } + break; + case TPacketDataConfigBase::KConfigRel99Rel4: + { + RPacketContext::TContextConfigR99_R4* contextConfigR99R4 = static_cast(generalConfig); + + // Protocol Config Option handling + RPacketContext::TMiscProtocolBuffer pcoBuffer; + pcoBuffer.Zero(); + TPtr8 pcoPtr (const_cast (pcoBuffer.Ptr()), RPacketContext::KMiscProtocolBufferLength); + + TTlvStruct tlv(pcoPtr,0); + + TBuf8 usernameAndPasswordBuffer(KMaxUserAndPassLength); + + // Generates the username, password and requestID buffer as described in 3GPP specification 3G TS 24.008 + ConvertUsernameAndPasswordToPCOBuffer(contextConfigR99R4->iProtocolConfigOption.iAuthInfo.iUsername, contextConfigR99R4->iProtocolConfigOption.iAuthInfo.iPassword, contextConfigR99R4->iProtocolConfigOption.iId, usernameAndPasswordBuffer); + + TPtr8 usernameAndPasswordParamDataPtr(const_cast(usernameAndPasswordBuffer.Ptr()), + usernameAndPasswordBuffer.Length(), usernameAndPasswordBuffer.Length()); + + TBuf8 primaryAndSecondaryDNSBuffer(KPrimaryAndSecondaryDNSLength + 1); + + // Generates the primary and secondary DNS buffers as described in 3GPP specification 3G TS 24.008 + ConvertDNSToPCOBuffer(contextConfigR99R4->iProtocolConfigOption.iDnsAddresses.iPrimaryDns, contextConfigR99R4->iProtocolConfigOption.iDnsAddresses.iSecondaryDns, contextConfigR99R4->iProtocolConfigOption.iId+1, primaryAndSecondaryDNSBuffer); + + // Setting the configurations buffers + TPtr8 primaryAndSecondaryDNSParamDataPtr(const_cast(primaryAndSecondaryDNSBuffer.Ptr()), + primaryAndSecondaryDNSBuffer.Length(), primaryAndSecondaryDNSBuffer.Length()); + + // Set up the TTlvStruct to include the pco details + RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID); + RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID); + + if (tlv.AppendItemL(usenameAndPasswordID, usernameAndPasswordParamDataPtr) != KErrOverflow) + { + if (tlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr) != KErrOverflow) + { + pcoBuffer.SetLength(primaryAndSecondaryDNSParamDataPtr.Length() + usernameAndPasswordParamDataPtr.Length() + 2 * KIDLength); + pcoBuffer.Append(contextConfigR99R4->iProtocolConfigOption.iMiscBuffer); + ret = iLtsyDispatchPacketServicesSetPdpContextConfig->HandleSetPdpContextConfigReqL(*contextId, contextConfigR99R4->iAccessPointName, + contextConfigR99R4->iPdpType, contextConfigR99R4->iPdpAddress, pcoBuffer); + } + else + { + ret = KErrNotSupported; + } + } + else + { + ret = KErrNotSupported; + } + } + break; + case TPacketDataConfigBase::KConfigRel5: + { + RPacketContext::TContextConfig_R5* contextConfigR95 = static_cast(generalConfig); + + // Protocol Config Option handling + RPacketContext::TMiscProtocolBuffer pcoBuffer; + pcoBuffer.Zero(); + TPtr8 pcoPtr (const_cast (pcoBuffer.Ptr()), RPacketContext::KMiscProtocolBufferLength); + + TTlvStruct tlv(pcoPtr,0); + + TBuf8 usernameAndPasswordBuffer(KMaxUserAndPassLength); + + // Generates the username, password and requestID buffer as described in 3GPP specification 3G TS 24.008 + ConvertUsernameAndPasswordToPCOBuffer(contextConfigR95->iProtocolConfigOption.iAuthInfo.iUsername, contextConfigR95->iProtocolConfigOption.iAuthInfo.iPassword, contextConfigR95->iProtocolConfigOption.iId, usernameAndPasswordBuffer); + + TPtr8 usernameAndPasswordParamDataPtr(const_cast(usernameAndPasswordBuffer.Ptr()), + usernameAndPasswordBuffer.Length(), usernameAndPasswordBuffer.Length()); + + TBuf8 primaryAndSecondaryDNSBuffer(KPrimaryAndSecondaryDNSLength + 1); + + // Generates the primary and secondary DNS buffers as described in 3GPP specification 3G TS 24.008 + ConvertDNSToPCOBuffer(contextConfigR95->iProtocolConfigOption.iDnsAddresses.iPrimaryDns, contextConfigR95->iProtocolConfigOption.iDnsAddresses.iSecondaryDns, contextConfigR95->iProtocolConfigOption.iId+1, primaryAndSecondaryDNSBuffer); + + // Setting the configurations buffers + TPtr8 primaryAndSecondaryDNSParamDataPtr(const_cast(primaryAndSecondaryDNSBuffer.Ptr()), + primaryAndSecondaryDNSBuffer.Length(), primaryAndSecondaryDNSBuffer.Length()); + + // Set up the TTlvStruct to include the pco details + RPacketContext::TPcoId primaryAndSecondaryDNSID(KPrimaryAndSecondaryDNSID); + RPacketContext::TPcoId usenameAndPasswordID(KUsenamePasswordDNSID); + + if (tlv.AppendItemL(usenameAndPasswordID, usernameAndPasswordParamDataPtr) != KErrOverflow) + { + if (tlv.AppendItemL(primaryAndSecondaryDNSID, primaryAndSecondaryDNSParamDataPtr) != KErrOverflow) + { + pcoBuffer.SetLength(primaryAndSecondaryDNSParamDataPtr.Length() + usernameAndPasswordParamDataPtr.Length() + 2 * KIDLength); + pcoBuffer.Append(contextConfigR95->iProtocolConfigOption.iMiscBuffer); + ret = iLtsyDispatchPacketServicesSetPdpContextConfig->HandleSetPdpContextConfigReqL(*contextId, contextConfigR95->iAccessPointName, contextConfigR95->iPdpType, contextConfigR95->iPdpAddress, pcoBuffer); + } + else + { + ret = KErrNotSupported; + } + } + else + { + ret = KErrNotSupported; + } + } + break; + default: + ret = KErrNotSupported; + break; + } + } + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchSetPdpContextConfigL + +TInt CPacketServicesDispatcher::DispatchModifyActivePdpContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextModifyActiveContext + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchPacketServicesModifyActivePdpContext) + { + TInfoName* contextName = NULL; + aDataPackage->UnPackData( &contextName ); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesModifyActivePdpContext->HandleModifyActivePdpContextReqL(*contextName); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchModifyActivePdpContextL + +TInt CPacketServicesDispatcher::DispatchInitialisePdpContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextInitialiseContext + * and pass request on to Licensee LTSY. + * + * @param aDataPackage Package primary and secondary context names + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::InitialiseContext() + * + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesInitialisePdpContext) + { + + TInfoName* contextName = NULL; + TInfoName* hostCID = NULL; + + aDataPackage->UnPackData( &contextName, &hostCID ); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(hostCID, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (hostCID->Length() == 0) // this is not a secondary context request + { + ret = iLtsyDispatchPacketServicesInitialisePdpContext->HandleInitialisePdpContextReqL(*contextName, KEmptyInfoName); + } + else // secondary context request also needs primary context name + { + ret = iLtsyDispatchPacketServicesInitialisePdpContext->HandleInitialisePdpContextReqL(*hostCID, *contextName); + } + + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchInitialisePdpContextL + +TInt CPacketServicesDispatcher::DispatchDeletePdpContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextDelete + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::Delete() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchPacketServicesDeletePdpContext) + { + // Unpack the deleted context name. + TInfoName* contextName = NULL; + aDataPackage->UnPackData(&contextName); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesDeletePdpContext->HandleDeletePdpContextReqL(*contextName); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchDeletePdpContextL + +TInt CPacketServicesDispatcher::DispatchSetPacketAttachModeL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketSetAttachMode + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchPacketServicesSetPacketAttachMode) + { + RPacketService::TAttachMode attachMode; + aDataPackage->UnPackData(attachMode); + + ret = iLtsyDispatchPacketServicesSetPacketAttachMode->HandleSetPacketAttachModeReqL(attachMode); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchSetPacketAttachModeL + +TInt CPacketServicesDispatcher::DispatchGetStatusL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + if (iLtsyDispatchPacketServicesGetStatus) + { + ret = iLtsyDispatchPacketServicesGetStatus->HandleGetStatusReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetStatusL + + +TInt CPacketServicesDispatcher::DispatchSetDefaultPdpContextParamsL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketSetDefaultContextParams + * and pass request on to Licensee LTSY. + * + * @param aDataPackage Packaged configuration parameters, either GPRS or R99 + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TPacketDataConfigBase* arg1 = NULL; + aDataPackage->UnPackData( &arg1 ); + + __ASSERT_DEBUG(arg1, CtsyDispatcherPanic(EInvalidNullPtr)); + + switch(arg1->ExtensionId()) + { + case TPacketDataConfigBase::KConfigGPRS: + { + if(iLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams) + { + const RPacketContext::TContextConfigGPRS& contextConfigGprs = *static_cast(arg1); + ret = iLtsyDispatchPacketServicesSetDefaultPdpContextGprsParams->HandleSetDefaultPdpContextGprsParamsReqL(contextConfigGprs); + } + } + break; + + case TPacketDataConfigBase::KConfigRel99Rel4: + { + if(iLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params) + { + const RPacketContext::TContextConfigR99_R4& contextConfigR99R4 = *static_cast(arg1); + ret = iLtsyDispatchPacketServicesSetDefaultPdpContextR99R4Params->HandleSetDefaultPdpContextR99R4ParamsReqL(contextConfigR99R4); + } + } + break; + + case TPacketDataConfigBase::KConfigRel5: + case TPacketDataConfigBase::KConfigCDMA: + default: + break; + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchSetDefaultPdpContextParamsL + +TInt CPacketServicesDispatcher::DispatchActivatePdpContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextActivate + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::Activate() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesActivatePdpContext) + { + // Unpack the activated context name. + TInfoName* contextName = NULL; + aDataPackage->UnPackData(&contextName); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesActivatePdpContext->HandleActivatePdpContextReqL(*contextName); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchActivatePdpContextL + +TInt CPacketServicesDispatcher::DispatchSetPdpContextQosL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketQoSSetProfileParams + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketQoS::SetProfileParameters() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + TContextParams* contextParams = NULL; + TDes8** qosProfile = NULL; + + aDataPackage->UnPackData(&contextParams, &qosProfile); + + __ASSERT_DEBUG(contextParams, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(qosProfile, CtsyDispatcherPanic(EInvalidNullPtr)); + + TPckg& profilePckg = *static_cast*>(*qosProfile); + + TPacketDataConfigBase& profile = profilePckg(); + + // Get what client has requested + switch(profile.ExtensionId()) + { + case TPacketDataConfigBase::KConfigGPRS: + { + if(iLtsyDispatchPacketServicesSetPdpContextQosGprs) + { + TPckg& gprsProfilePckg = *static_cast*>(*qosProfile); + RPacketQoS::TQoSGPRSRequested& gprsProfile = gprsProfilePckg(); + ret = iLtsyDispatchPacketServicesSetPdpContextQosGprs->HandleSetPdpContextQosGprsReqL(contextParams->iContextName, gprsProfile); + } + } + break; + case TPacketDataConfigBase::KConfigRel99Rel4: + { + if(iLtsyDispatchPacketServicesSetPdpContextQosR99R4) + { + TPckg& r99r4ProfilePckg = *static_cast*>(*qosProfile); + RPacketQoS::TQoSR99_R4Requested& r99r4Profile = r99r4ProfilePckg(); + ret = iLtsyDispatchPacketServicesSetPdpContextQosR99R4->HandleSetPdpContextQosR99R4ReqL(contextParams->iContextName, r99r4Profile); + } + } + break; + case TPacketDataConfigBase::KConfigRel5: + { + if(iLtsyDispatchPacketServicesSetPdpContextQosR5) + { + TPckg& r5ProfilePckg = *static_cast*>(*qosProfile); + RPacketQoS::TQoSR5Requested& r5Profile = r5ProfilePckg(); + ret = iLtsyDispatchPacketServicesSetPdpContextQosR5->HandleSetPdpContextQosR5ReqL(contextParams->iContextName, r5Profile); + } + } + break; + default: + ret = KErrNotSupported; + break; + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchSetPdpContextQosL + +TInt CPacketServicesDispatcher::DispatchRejectNetworkInitiatedContextActivationRequestL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketService::RejectActivationRequest() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + if (iLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest) + { + ret = iLtsyDispatchPacketServicesRejectNetworkInitiatedContextActivationRequest->HandleRejectNetworkInitiatedContextActivationRequestReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchRejectNetworkInitiatedContextActivationRequestL + +TInt CPacketServicesDispatcher::DispatchDeactivatePdpContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextDeactivate + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::Deactivate() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesDeactivatePdpContext) + { + TInfoName* contextName = NULL; + aDataPackage->UnPackData( &contextName ); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesDeactivatePdpContext->HandleDeactivatePdpContextReqL(*contextName); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchDeactivatePdpContextL + +TInt CPacketServicesDispatcher::DispatchAddPacketFilterL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextAddPacketFilter + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::AddPacketFilter() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchPacketServicesAddPacketFilter) + { + TInfoName* secondaryContext = NULL; + CArrayFixFlat* contextFilterArray = NULL; + + aDataPackage->UnPackData( &secondaryContext, &contextFilterArray); + __ASSERT_DEBUG(secondaryContext, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(contextFilterArray, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesAddPacketFilter->HandleAddPacketFilterSyncL(*secondaryContext, *contextFilterArray); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchAddPacketFilterL + +TInt CPacketServicesDispatcher::DispatchRemovePacketFilterL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextRemovePacketFilter + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + * + * @see RPacketContext::RemovePacketFilter() + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + if (iLtsyDispatchPacketServicesRemovePacketFilter) + { + TInfoName* secondaryContext = NULL; + TInt* filterId = NULL; + + aDataPackage->UnPackData( &secondaryContext, &filterId); + __ASSERT_DEBUG(secondaryContext, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(filterId, CtsyDispatcherPanic(EInvalidNullPtr)); + ret = iLtsyDispatchPacketServicesRemovePacketFilter->HandleRemovePacketFilterSyncL(*secondaryContext, *filterId); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchAddPacketFilterL + +TInt CPacketServicesDispatcher::DispatchGetStaticCapabilitiesL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesGetStaticCapabilities) + { + ret = iLtsyDispatchPacketServicesGetStaticCapabilities->HandleGetStaticCapabilitiesReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetStaticCapabilitiesL + +TInt CPacketServicesDispatcher::DispatchGetMaxNoMonitoredServiceListsL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists) + { + ret = iLtsyDispatchPacketServicesGetMaxNoMonitoredServiceLists->HandleGetMaxNoMonitoredServiceListsReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetMaxNoMonitoredServiceListsL + +TInt CPacketServicesDispatcher::DispatchGetMaxNoActiveServicesL() +/** + * Pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesGetMaxNoActiveServices) + { + ret = iLtsyDispatchPacketServicesGetMaxNoActiveServices->HandleGetMaxNoActiveServicesReqL(); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetMaxNoActiveServicesL + +TInt CPacketServicesDispatcher::DispatchInitialiseMbmsContextL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to ECtsyPacketMbmsInitialiseContextReq + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesInitialiseMbmsContext) + { + + TInfoName* contextName = NULL; + aDataPackage->UnPackData(&contextName); + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesInitialiseMbmsContext->HandleInitialiseMbmsContextReqL(*contextName); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchInitialiseMbmsContextL + +TInt CPacketServicesDispatcher::DispatchGetMbmsNetworkServiceStatusL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketGetMbmsNetworkServiceStatus + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus) + { + TBool attemptAttach; + aDataPackage->UnPackData(attemptAttach); + + ret = iLtsyDispatchPacketServicesGetMbmsNetworkServiceStatus->HandleGetMbmsNetworkServiceStatusReqL(attemptAttach); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchGetMbmsNetworkServiceStatusL + + +TInt CPacketServicesDispatcher::DispatchUpdateMbmsMonitorServiceListL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketUpdateMbmsMonitorServiceList + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList) + { + TMmMbmsMonitorServiceListParams* mbmsMonitorServiceListParams = NULL; + + aDataPackage->UnPackData(&mbmsMonitorServiceListParams); + __ASSERT_DEBUG(mbmsMonitorServiceListParams, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(mbmsMonitorServiceListParams->iServiceList, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(mbmsMonitorServiceListParams->iListOfChanges, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesUpdateMbmsMonitorServiceList->HandleUpdateMbmsMonitorServiceListsReqL( mbmsMonitorServiceListParams->iActionType, + *(mbmsMonitorServiceListParams->iServiceList), + *(mbmsMonitorServiceListParams->iListOfChanges)); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchUpdateMbmsMonitorServiceListL + +TInt CPacketServicesDispatcher::DispatchUpdateMbmsSessionListL(const CMmDataPackage* aDataPackage) +/** + * Unpack data related to EPacketContextUpdateMbmsSessionList + * and pass request on to Licensee LTSY. + * + * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if + * the Licensee LTSY does not support this request. + */ + { + TSYLOGENTRYEXIT; + TInt ret = KErrNotSupported; + + __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr)); + + // Call Handle... method in Licensee LTSY + if (iLtsyDispatchPacketServicesUpdateMbmsSessionList) + { + + TInfoName* contextName = NULL; + TMmMbmsActiveServiceListParams* mbmsActiveServiceListParams = NULL; + aDataPackage->UnPackData(&contextName, &mbmsActiveServiceListParams); + + __ASSERT_DEBUG(contextName, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(mbmsActiveServiceListParams, CtsyDispatcherPanic(EInvalidNullPtr)); + __ASSERT_DEBUG(mbmsActiveServiceListParams->iServiceList, CtsyDispatcherPanic(EInvalidNullPtr)); + + ret = iLtsyDispatchPacketServicesUpdateMbmsSessionList->HandleUpdateMbmsSessionListReqL(*contextName, + mbmsActiveServiceListParams->iActionType, + mbmsActiveServiceListParams->iChangedItem, + mbmsActiveServiceListParams->iServiceList->iSessionIdList); + } + + return TSYLOGSETEXITERR(ret); + } // CPacketServicesDispatcher::DispatchUpdateMbmsSessionListL + +// +// Callback handlers follow +// + +void CPacketServicesDispatcher::CallbackNotifyPacketAttachModeChange(TInt aError, RPacketService::TPreferredBearer aBearer) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketAttachModeChangeInd() + * + * @param aError The error code. + * @param aBearer The new bearer. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aBearer=%d"), aError, aBearer); + + // Pack the data to return to the Common TSY + CMmPacketDataPackage dataPackage; + dataPackage.PackData(&aBearer); + iMessageManagerCallback.Complete(EPacketNotifyAttachModeChange, &dataPackage, aError); + } // CPacketServicesDispatcher::CallbackNotifyPacketAttachModeChange + +void CPacketServicesDispatcher::CallbackNotifyQosProfileChange(TInt aError, const TDesC& aContextName, + const RPacketQoS::TQoSGPRSNegotiated& aQoSGPRSNegotiated) +/** + * Callback function to be used by the Licensee LTSY to notify change in the GPRS QoS profile (IPCEPacketQoSNotifyProfileChanged). + * + * @param aError The error code. + * @param aContextName context name to be returned to the CTSY Dispatcher. + * @param aQoSGPRSNegotiated context negotiated GPRS QOS profile to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + CMmPacketDataPackage dataPackage; + + RPacketQoS::TQoSR99_R4Negotiated tempR99_R4Negotiated; + TInt ret = EtelPcktR97NegToEtelPcktR99R4NegQoS(aQoSGPRSNegotiated, tempR99_R4Negotiated); + RPacketQoS::TQoSR5Negotiated tempR5Negotiated; + ret = EtelPcktR99R4NegToEtelPcktR5NegQoS(tempR99_R4Negotiated, tempR5Negotiated); + dataPackage.SetProfileChanged( + const_cast(&aQoSGPRSNegotiated), + const_cast(&tempR99_R4Negotiated), + const_cast(&tempR5Negotiated)); + + //CTSY unpacks as a TInfoName thus safe. + dataPackage.PackData(const_cast(&aContextName)); + iMessageManagerCallback.Complete(EPacketQoSNotifyProfileChanged, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyQosProfileChangedGPRS + +void CPacketServicesDispatcher::CallbackNotifyQosProfileChange(TInt aError, + const TDesC& aContextName, const RPacketQoS::TQoSR99_R4Negotiated& aQoSR99_R4Negotiated) +/** + * Callback function to be used by the Licensee LTSY to notify change in the R99R4 QoS profile (IPCEPacketQoSNotifyProfileChanged). + * + * @param aError The error code. + * @param aContextName context name to be returned to the CTSY Dispatcher. + * @param aQoSR99_R4Negotiated context negotiated R99 QOS profile to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + RPacketQoS::TQoSGPRSNegotiated tempGPRSNegotiated; + TInt ret = EtelPcktR99R4NegToEtelPcktR97NegQoS(aQoSR99_R4Negotiated, tempGPRSNegotiated); + + RPacketQoS::TQoSR5Negotiated tempR5Negotiated; + ret = EtelPcktR99R4NegToEtelPcktR5NegQoS(aQoSR99_R4Negotiated, tempR5Negotiated); + + CMmPacketDataPackage dataPackage; + dataPackage.SetProfileChanged( + const_cast(&tempGPRSNegotiated), + const_cast(&aQoSR99_R4Negotiated), + const_cast(&tempR5Negotiated)); + + //CTSY unpacks as a TInfoName thus safe. + dataPackage.PackData(const_cast(&aContextName)); + iMessageManagerCallback.Complete(EPacketQoSNotifyProfileChanged, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyQosProfileChangedR99 + +void CPacketServicesDispatcher::CallbackNotifyQosProfileChange(TInt aError, + const TDesC& aContextName, const RPacketQoS::TQoSR5Negotiated& aQoSR5Negotiated) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyQosProfileChangedInd() + * + * @param aError The error code. + * @param aContextName Context name to be returned to the CTSY Dispatcher. + * @param aQoSR5Negotiated Context negotiated R5 QOS profile to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + const RPacketQoS::TQoSR99_R4Negotiated* tempR99_R4Negotiated = &aQoSR5Negotiated; + + RPacketQoS::TQoSGPRSNegotiated tempGPRSNegotiated; + EtelPcktR99R4NegToEtelPcktR97NegQoS(*tempR99_R4Negotiated, tempGPRSNegotiated); + + CMmPacketDataPackage dataPackage; + + dataPackage.SetProfileChanged( + const_cast(&tempGPRSNegotiated), + const_cast(tempR99_R4Negotiated), + const_cast(&aQoSR5Negotiated)); + + //CTSY unpacks as a TInfoName thus safe. + dataPackage.PackData(const_cast(&aContextName)); + iMessageManagerCallback.Complete(EPacketQoSNotifyProfileChanged, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyQosProfileChangedR5 + +void CPacketServicesDispatcher::CallbackNotifyRatTransferCapsChange(TInt aError, TDynamicTransferCapsFlags aCaps) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyRatTransferCapsChangeInd() + * + * @param aError The error code. + * @param aCaps The capabilities flag. + * + * @see RPacketService::NotifyDynamicCapsChange() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aCaps=%d"), aError, aCaps); + + // Pack the data to return to the Common TSY + CMmPacketDataPackage dataPackage; + dataPackage.PackData(&aCaps); + iMessageManagerCallback.Complete(EPacketNotifyTransferCapsIPC, &dataPackage, aError); + } // CPacketServicesDispatcher::CallbackNotifyRatTransferCapsChange + +void CPacketServicesDispatcher::CallbackNotifyPacketMsClassChange(TInt aError, RPacketService::TMSClass aMSClass) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketMsClassChangeInd() + * + * @param aError The error code. + * @param aMSClass MS class to be returned to the CTSY. + * + * @see RPacketService::NotifyMSClassChange() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMSClass=%d"), aError, aMSClass); + CMmDataPackage dataPackage; + dataPackage.PackData(&aMSClass); + iMessageManagerCallback.Complete(EPacketNotifyMSClassChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPacketMsClassChange + +void CPacketServicesDispatcher::CallbackNotifyPacketDynamicCapsChange(TInt aError, TBool aGprsIsSupportedOnCell, TBool aCsServicesIsSupportedOnCell) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketDynamicCapsChangeInd() + * + * @param aError The error code. + * @param aGprsIsSupportedOnCell indication whether GPRS is supported and should be returned to the CTSY Dispatcher. + * @param aCsServicesIsSupportedOnCell indication whether CS services are supported and should be returned to the CTSY Dispatcher. + * + * @see RPacketService::NotifyDynamicCapsChange() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aGprsIsSupportedOnCell=%d, aCsServicesIsSupportedOnCell=%d"), aError, aGprsIsSupportedOnCell, aCsServicesIsSupportedOnCell); + CMmDataPackage dataPackage; + dataPackage.PackData(&aGprsIsSupportedOnCell, &aCsServicesIsSupportedOnCell); + iMessageManagerCallback.Complete(EPacketNotifyDynamicCapsChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPacketDynamicCapsChange + +void CPacketServicesDispatcher::CallbackNotifyPdpContextAdded(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPdpContextAddedInd() + * + * @param aError The error code. + * @param aContextName PDP context name to be returned. + * + * @see RPacketService::NotifyContextAdded() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &aError); + iMessageManagerCallback.Complete(EPacketNotifyContextAdded, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPdpContextAdded + +void CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest(TInt aError, + const RPacketContext::TContextConfigGPRS& aContextConfigGPRS) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd() + * + * @param aError The error code. + * @param aContextConfigGPRS The GPRS context configuration to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aPdpType=%d"), aError, aContextConfigGPRS.iPdpType); + + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast (&aContextConfigGPRS)); + iMessageManagerCallback.Complete(EPacketNotifyContextActivationRequested, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest + +void CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest(TInt aError, + const RPacketContext::TContextConfigR99_R4& aContextConfigR99_R4) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd() + * + * @param aError The error code. + * @param aContextConfigR99_R4 The release 99 or release 4 context configuration to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aPdpType=%d"), aError, aContextConfigR99_R4.iPdpType); + + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast (&aContextConfigR99_R4)); + iMessageManagerCallback.Complete(EPacketNotifyContextActivationRequested, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest + +void CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest(TInt aError, + const RPacketContext::TContextConfig_R5& aContextConfig_R5) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyNetworkInitiatedContextActivationRequestInd() + * + * @param aError The error code. + * @param aContextConfig_R5 The release 5 context configuration to be returned to the CTSY Dispatcher. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aPdpType=%d"), aError, aContextConfig_R5.iPdpType); + + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast (&aContextConfig_R5)); + iMessageManagerCallback.Complete(EPacketNotifyContextActivationRequested, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyNetworkInitiatedContextActivationRequest + + +void CPacketServicesDispatcher::CallbackNotifyPdpContextConfigChanged(TInt aError, + const TDesC& aContextName, const TDesC8& aAccessPointName, + const TDesC8& aPdpAddress, TUint aPdpCompression, const TDesC8& aPcoBuffer) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPdpContextConfigChangedInd() + * + * @param aError The error code. + * + * @param aContextName The name of the context which the change in configuration refers to. + * + * @param aAccessPointName The name of the access point. This should be a descriptor of maximum length + * RPacketContext::KGSNNameLength such as a RPacketContext::TGSNAddress + * + * @param aPdpAddress The protocol address. This should be a descriptor of maximum length + * RPacketContext::KMaxPDPAddressLength such as a RPacketContext::TProtocolAddress + * + * @param aPdpCompression The PDP compression level. + * + * @param aPcoBuffer The PCO buffer. This should be a descriptor of maximum length + * RPacketContext::KMiscProtocolBufferLength such as a RPacketContext::TMiscProtocolBuffer. + * + * @see RPacketContext::NotifyConfigChanged() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aPdpCompression=%d"), aError, &aContextName, aPdpCompression); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aAccessPointName.Length() <= RPacketContext::KGSNNameLength, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aPdpAddress.Length() <= RPacketContext::KMaxPDPAddressLength, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aPcoBuffer.Length() >= KHeaderGap + KIPv4Len + KLengthLocation + KMinPCOSize, CtsyDispatcherPanic(EBadLength)); + + RPacketContext::TContextConfigGPRS contextConfig; + + // Decode the PCO buffer and set the profile + DecodePCO(aPcoBuffer, contextConfig.iProtocolConfigOption.iAuthInfo.iUsername, + contextConfig.iProtocolConfigOption.iAuthInfo.iPassword, + contextConfig.iProtocolConfigOption.iDnsAddresses.iPrimaryDns, + contextConfig.iProtocolConfigOption.iDnsAddresses.iSecondaryDns, + contextConfig.iProtocolConfigOption.iMiscBuffer); + + // Re-constuct the profile + contextConfig.iAccessPointName.Copy(aAccessPointName.Left(RPacketContext::KGSNNameLength)); + contextConfig.iPdpAddress.Copy(aPdpAddress.Left(RPacketContext::KMaxPDPAddressLength)); + contextConfig.iPdpCompression = aPdpCompression; + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmPacketDataPackage dataPackage; + dataPackage.PackData(&contextName, &contextConfig); + iMessageManagerCallback.Complete(EPacketContextNotifyConfigChanged, &dataPackage, aError); + } // CPacketServicesDispatcher::CallbackNotifyPdpContextConfigChanged + +void CPacketServicesDispatcher::CallbackNotifyPdpContextStatusChange(TInt aError, const TDesC& aContextName, const TContextMisc& aContextMisc) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPdpContextStatusChangeInd() + * + * @param aError The error code to be returned. + * @param aContextName context name. + * @param aContextMisc context miscellaneous information + * + * @see TContextMisc. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, const_cast(&aContextMisc)); + iMessageManagerCallback.Complete(EPacketContextNotifyStatusChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPdpContextStatusChange + +void CPacketServicesDispatcher::CallbackNotifyPdpContextConnectionSpeedChange(TInt aError, const TDesC& aContextName, TUint aConnectionSpeed) +/** + * Callback function to be used by the Licensee LTSY to notify context connection speed change (IPC EPacketContextNotifyConnectionSpeedChange). + * + * @param aError The error code to be returned. + * @param aContextName context name. + * @param aConnectionSpeed context connection speed in bits per second. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aConnectionSpeed=%d"), aError, &aContextName, aConnectionSpeed); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &aConnectionSpeed); + iMessageManagerCallback.Complete(EPacketContextNotifyConnectionSpeedChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPdpContextConnectionSpeedChange + +void CPacketServicesDispatcher::CallbackNotifyPacketNetworkRegistrationStatus(TInt aError, const RPacketService::TRegistrationStatus aRegistrationStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyPacketNetworkRegistrationStatusInd() + * + * + * @param aError The error code. + * @param aRegistrationStatus network registration status. + * + * @see RPacketService::NotifyChangeOfNtwkRegStatus() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aRegistrationStatus=%d"), aError, aRegistrationStatus); + + CMmDataPackage dataPackage; + dataPackage.PackData(const_cast(&aRegistrationStatus)); + iMessageManagerCallback.Complete(EPacketNotifyChangeOfNtwkRegStatus, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyPacketNetworkRegistrationStatus + + +void CPacketServicesDispatcher::CallbackNotifyMbmsContextConfigChanged(TInt aError, const TDesC& aContextName, const RPacketMbmsContext::TContextConfigMbmsV1& aContextConfigMbms) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyMbmsContextConfigChangedInd() + * + * + * @param aError The error code to be returned. + * @param aContextName The context name. + * @param aContextConfigMbms The context configuration data. + * + * @see RPacketMbmsContext::NotifyConfigChanged() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, sId=%d, mcc=%d, mnc=%d, ab=%d, sp=%d, sm=%d, sf=%d"), + aError, + &aContextName, + aContextConfigMbms.iTmgi.GetServiceId(), + aContextConfigMbms.iTmgi.GetMCC(), + aContextConfigMbms.iTmgi.GetMNC(), + aContextConfigMbms.iMbmsAccessBearer, + aContextConfigMbms.iMbmsServicePriority, + aContextConfigMbms.iMbmsServiceMode, + aContextConfigMbms.iMbmsSessionFlag); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &const_cast(aContextConfigMbms)); + iMessageManagerCallback.Complete(ECtsyPacketMbmsContextNotifyConfigChanged, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyMbmsContextConfigChanged + +void CPacketServicesDispatcher::CallbackPacketAttach(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesPacketAttachComp() + * + * @param aError The error code. + * + * @see RPacketService::Attach() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + iMessageManagerCallback.Complete(EPacketAttach, aError); + } // CPacketServicesDispatcher::CallbackPacketAttach + +void CPacketServicesDispatcher::CallbackGetPacketAttachMode(TInt aError, RPacketService::TAttachMode aAttachMode) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketAttachModeComp() + * + * @param aError The error code. + * @param aAttachMode The packet attach mode. + * + * @see RPacketService::GetAttachMode() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aAttachMode=%d"), aError, aAttachMode); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aAttachMode); + + iMessageManagerCallback.Complete(EPacketGetAttachMode, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetPacketAttachMode + +void CPacketServicesDispatcher::CallbackGetPacketNetworkRegistrationStatus(TInt aError, + RPacketService::TRegistrationStatus aRegistrationStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesGetPacketNetworkRegistrationStatusComp() + * + * @param aError The error code to be returned to the CTSY Dispatcher. + * @param aRegistrationStatus The current network registration status. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aRegistrationStatus=%d"), aError, aRegistrationStatus); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aRegistrationStatus); + + iMessageManagerCallback.Complete(EPacketGetNtwkRegStatus, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetPacketNetworkRegistrationStatus + +void CPacketServicesDispatcher::CallbackPacketDetach(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesPacketDetachComp() + * + * @param aError The error code. + * + * @see RPacketService::Detach() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + iMessageManagerCallback.Complete(EPacketDetach, aError); + + } // CPacketServicesDispatcher::CallbackPacketDetach + +void CPacketServicesDispatcher::CallbackSetPdpContextConfig(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextConfigComp() + * + * @param aError The error code. + * @param callbackContextId the context name, the maximum length of the descriptor should not exceed KMaxInfoName. + * + * @see RPacketContext::SetConfig() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName); + + iMessageManagerCallback.Complete(EPacketContextSetConfig, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackSetPdpContextConfig + +void CPacketServicesDispatcher::CallbackModifyActivePdpContext(TInt aError, const TDesC& aContextName, TInt8 aRejectionCode) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesModifyActivePdpContextComp() + * + * @param aError The error code. + * @param aContextName The context name which has been modified. + * @param aRejectionCode The reason code for any failure of modification. + * + * @see RPacketContext::ModifyActiveContext() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aRejectionCode=%d"), aError, &aContextName, aRejectionCode); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + typedef TBuf8<1> TRejectionCode; + TRejectionCode rejectionCode; + rejectionCode.Append(aRejectionCode); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName); + + dataPackage.PackData(&contextName, &rejectionCode); + + iMessageManagerCallback.Complete(EPacketContextModifyActiveContext, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackModifyActivePdpContext + +void CPacketServicesDispatcher::CallbackInitialisePdpContext(TInt aError, const TDesC& aContextName, const TDesC& aChannelId) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesInitialisePdpContextComp() + * + * @param aError The error code. + * @param aContextName The name of the current context, the descriptor should be TBuf<10> + * @param aChannelId The current channelId descriptor, the descriptor should be a TName + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aChannelId=%S"), aError, &aContextName, &aChannelId); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aChannelId.Length() <= KMaxName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &const_cast(aChannelId)); + + iMessageManagerCallback.Complete(EPacketContextInitialiseContext, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackInitialisePdpContext + +void CPacketServicesDispatcher::CallbackDeletePdpContext(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesDeletePdpContextComp() + * + * @param aError The error code. + * @param aContextName The context name. + * + * @see RPacketContext::Delete() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName); + + iMessageManagerCallback.Complete(EPacketContextDelete, &dataPackage, aError); + } // CPacketServicesDispatcher::CallbackDeletePdpContext + +void CPacketServicesDispatcher::CallbackSetPacketAttachMode(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesSetPacketAttachModeComp() + * + * @param aError The error code. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + iMessageManagerCallback.Complete(EPacketSetAttachMode, aError); + + } // CPacketServicesDispatcher::CallbackSetPacketAttachMode + +void CPacketServicesDispatcher::CallbackSetDefaultPdpContextParams(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesSetDefaultPdpContextParamsComp() + * + * @param aError The error code. + * + * @see RPacketContext::SetDefaultContextParams() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EPacketSetDefaultContextParams, aError); + } // CPacketServicesDispatcher::CallbackSetDefaultPdpContextParams + +void CPacketServicesDispatcher::CallbackActivatePdpContext(TInt aError, + const TDesC& aContextName, + const TDesC8& aAccessPointName, + RPacketContext::TProtocolType aPdpType) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesActivatePdpContextComp() + * + * @param aError KErrNone on success, or another error code indicating the error otherwise. + * @param aContextName The name of the context that has been activated. + * @param aAccessPointName The name of the access point that has been activated. + * This should be a descriptor of maximum length RPacketContext::KGSNNameLength such as RPacketContext::TGSNAddress + * @param aPdpType The protocol used to connect to the packet data gateway. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aAccessPointName=%S, aPdpType=%d"), aError, &aContextName, &aAccessPointName, aPdpType); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aAccessPointName.Length() <= RPacketContext::KGSNNameLength, CtsyDispatcherPanic(EBadLength)); + + RPacketContext::TContextConfigGPRS contextConfig; + contextConfig.iAccessPointName.Copy(aAccessPointName); + contextConfig.iPdpType = aPdpType; + const RPacketContext::TContextConfigGPRS* contextConfigPtr = &contextConfig; + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &contextConfigPtr); + + iMessageManagerCallback.Complete(EPacketContextActivate, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackActivatePdpContext + +void CPacketServicesDispatcher::CallbackSetPdpContextQos(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesSetPdpContextQosComp() + * + * @param aError The error code. + * @param aContextName The context's name, the maximum length of the descriptor should not exceed KMaxInfoName. + * + * @see RPacketContext::SetProfileParameters() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + //CTSY unpacks as a TInfoName so safe to pack the TDesC& here. + dataPackage.PackData(const_cast(&aContextName)); + + iMessageManagerCallback.Complete(EPacketQoSSetProfileParams, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackSetPdpContextQos + +void CPacketServicesDispatcher::CallbackRejectNetworkInitiatedContextActivationRequest(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesRejectNetworkInitiatedContextActivationRequestComp() + * + * @param aError The error code. + * + * @see RPacketContext::RejectActivationRequest() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + iMessageManagerCallback.Complete(EPacketRejectActivationRequest, aError); + + } // CPacketServicesDispatcher::CallbackRejectNetworkInitiatedContextActivationRequest + +void CPacketServicesDispatcher::CallbackDeactivatePdpContext(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesDeactivatePdpContextComp() + * + * @param aError The error code. + * @param aContextName The context name that has been deactivated, + * The maximum length of the descriptor should not exceed KMaxInfoName. + * + * @see RPacketContext::Deactivate() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName); + + iMessageManagerCallback.Complete(EPacketContextDeactivate, &dataPackage, aError); + } // CPacketServicesDispatcher::CallbackDeactivatePdpContext + +void CPacketServicesDispatcher::CallbackGetStatus(TInt aError, RPacketService::TStatus aPacketStatus, TBool aIsResumed) +/** + * Callback function to be used by the request to complete the packet status. + * + * @param aError The error code. + * @param aPacketStatus The packet status as returned from LTSY + * @param aIsResumed Flag indicating whether packet service has been resumed from suspended state. + * + * @see RPacketService::GetStatus() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aPacketStatus=%d, aIsResumed=%d"), aError, aPacketStatus, aIsResumed); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + + dataPackage.PackData(&aPacketStatus, &aIsResumed); + + iMessageManagerCallback.Complete(EPacketNotifyStatusChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetStatus + + +void CPacketServicesDispatcher::CallbackGetStaticCapabilities(TInt aError, TUint aStaticCapabilities) +/** + * Callback function to be used by the request to complete the packet static capabilities. + * CCtsyDispatcherCallback::CallbackPacketServicesGetStaticCapabilitiesComp() + * + * @param aError The error code. + * @param aStaticCapabilities A bit field containing the static capabilities to be returned to the CTSY. + * This can be created from a bit-wise OR (|) of values from RPacketService::TStaticMiscCaps. + * + * @see RPacketService::TStaticMiscCaps + * @see RPacketService::GetStaticCaps() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aStaticCapabilities=%d"), aError, aStaticCapabilities); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + + dataPackage.PackData(&aStaticCapabilities); + + iMessageManagerCallback.Complete(EPacketGetStaticCaps, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetStaticCapabilities + +void CPacketServicesDispatcher::CallbackGetMaxNoMonitoredServiceLists(TInt aError, TInt aMaxNoMonitoredServiceLists) +/** + * Callback function to be used by the request to complete the maximum number of monitored service lists + * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoMonitoredServiceListsComp() + * + * @param aError The error code. + * @param aMaxNoMonitoredServiceLists The maximum number of monitored service lists. + * + * @see RPacketService::EnumerateMbmsMonitorServiceList() + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMaxNoMonitoredServiceLists=%d"), aError, aMaxNoMonitoredServiceLists); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + + dataPackage.PackData(&aMaxNoMonitoredServiceLists); + + iMessageManagerCallback.Complete(EPacketEnumerateMbmsMonitorServiceList, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetMaxNoMonitoredServiceLists + +void CPacketServicesDispatcher::CallbackGetMaxNoActiveServices(TInt aError, TInt aMaxNoActiveServices) +/** + * Callback function to be used by the request to complete the maximum number of active services. + * CCtsyDispatcherCallback::CallbackPacketServicesGetMaxNoActiveServicesComp() + * + * @param aError The error code. + * @param aMaxNoActiveServices The maximum number of active services allowed (hence the maximum number of contexts allowed). + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMaxNoActiveServices=%d"), aError, aMaxNoActiveServices); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + + dataPackage.PackData(&aMaxNoActiveServices); + + iMessageManagerCallback.Complete(EPacketEnumerateMbmsActiveServiceList, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetMaxNoActiveServices + +void CPacketServicesDispatcher::CallbackInitialiseMbmsContext(TInt aError, const TDesC& aContextName, const TDesC& aChannelId) +/** + * Callback function to be used by the request to complete the maximum number of active services. + * CCtsyDispatcherCallback::CallbackPacketServicesInitialiseMbmsContextComp() + * + * @param aError The error code. + * @param aContextName The name of the current context, the descriptor should be a maximum length of KMaxInfoName. + * @param aChannelId The current channelId descriptor, the descriptor should be a maximum length of KMaxName. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, aChannelId=%S"), aError, &aContextName, &aChannelId); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + __ASSERT_DEBUG(aChannelId.Length() <= KMaxName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + RPacketContext::TDataChannelV2 dataChannelV2; + dataChannelV2.iChannelId = aChannelId.Left(KMaxName); + dataChannelV2.iPort = aContextName.Left(KMaxInfoName); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName,&dataChannelV2); + + iMessageManagerCallback.Complete(ECtsyPacketMbmsInitialiseContextComp, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackInitialiseMbmsContext + +void CPacketServicesDispatcher::CallbackGetMbmsNetworkServiceStatus(TInt aError, TMbmsNetworkServiceStatus aMbmsNetworkServiceStatus) +/** + * Callback function to be used by the request to complete the MBMS network service status. + * CCtsyDispatcherCallback::CallbackPacketServicesGetMbmsNetworkServiceStatusComp() + * + * @param aError The error code. + * @param aMbmsNetworkServiceStatus The network service status. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMbmsNetworkServiceStatus=%d"), aError, aMbmsNetworkServiceStatus); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aMbmsNetworkServiceStatus); + + iMessageManagerCallback.Complete(EPacketGetMbmsNetworkServiceStatus, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackGetMbmsNetworkServiceStatus + +void CPacketServicesDispatcher::CallbackNotifyMbmsNetworkServiceStatusChange(TInt aError, TMbmsNetworkServiceStatus aMbmsNetworkServiceStatus) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyMbmsNetworkServiceStatusChangeInd() + * + * @param aError The error code. + * @param aMbmsNetworkServiceStatus The network service status. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aMbmsNetworkServiceStatus=%d"), aError, aMbmsNetworkServiceStatus); + + // Pack the data to return to the Common TSY + CMmDataPackage dataPackage; + dataPackage.PackData(&aMbmsNetworkServiceStatus); + + iMessageManagerCallback.Complete(EPacketNotifyMbmsNetworkServiceStatusChange, &dataPackage, aError); + + } // CPacketServicesDispatcher::CallbackNotifyMbmsNetworkServiceStatusChange + + +void CPacketServicesDispatcher::CallbackUpdateMbmsMonitorServiceList(TInt aError) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsMonitorServiceListComp() + * + * @param aError The error code. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError); + + iMessageManagerCallback.Complete(EPacketUpdateMbmsMonitorServiceList, KErrNone); + + (void)aError; // Suppress compiler warning about unused argument in UREL + } // CPacketServicesDispatcher::CallbackUpdateMbmsMonitorServiceList + +void CPacketServicesDispatcher::CallbackUpdateMbmsMonitorServiceList(TInt aError, const RArray& aFailedServiceIds) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsMonitorServiceListComp() + * + * @param aFailedServiceIds A list containing the service Id which cannot be updated via the action (e.g. Id of + * a service that could not be added) + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aFailedServiceIds.Count()=%d"), aError, aFailedServiceIds.Count()); + + CPcktMbmsMonitoredServiceList* list = NULL; + + //if the list creation leaves then list will be NULL, which the CTSY can handle. + TRAPD(err,list = CreateServiceListL(aFailedServiceIds)); + __ASSERT_DEBUG(err == KErrNone, CtsyDispatcherPanic(ELeaveTrapped)); + + CMmDataPackage dataPackage; + + if(err == KErrNone) + { + //no real problem packing if list is NULL, mainly so err does not cause a UREL build warning as its not used. + dataPackage.PackData(list); + } + + iMessageManagerCallback.Complete(EPacketUpdateMbmsMonitorServiceList, &dataPackage, KErrMbmsImpreciseServiceEntries); + + (void)aError; // Suppress compiler warning about unused argument in UREL + delete list; + list = NULL; + } // CPacketServicesDispatcher::CallbackUpdateMbmsMonitorServiceList + +void CPacketServicesDispatcher::CallbackNotifyMbmsServiceAvailabilityChange(TInt aError, const RArray& aAvailableServiceIds) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyMbmsServiceAvailabilityChangeInd() + * + * @param aError The error code. + * @param aAvailableServiceIds The list of Service Ids which are currently available. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aAvailableServiceIds.Count()=%d"), aError, aAvailableServiceIds.Count()); + + if(aError == KErrNone) + { + CPcktMbmsMonitoredServiceList* list = NULL; + + //if the list creation leaves then list will be NULL, which the CTSY can handle. + TRAPD(err,list = CreateServiceListL(aAvailableServiceIds)); + + CMmDataPackage dataPackage; + dataPackage.PackData(list); + + iMessageManagerCallback.Complete(EPacketNotifyMbmsServiceAvailabilityChange, &dataPackage, err); + + delete list; + list = NULL; + + } + else + { + CMmDataPackage dataPackage; + iMessageManagerCallback.Complete(EPacketNotifyMbmsServiceAvailabilityChange, &dataPackage, aError); + } + + } //CPacketServicesDispatcher::CallbackNotifyMbmsServiceAvailabilityChange + +void CPacketServicesDispatcher::CallbackUpdateMbmsSessionList(TInt aError, const TDesC& aContextName) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesUpdateMbmsSessionListComp() + * + * @param aError The error code. + * @param aContextName The name of the MBMS context, the descriptor should be a maximum length of KMaxInfoName. + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S"), aError, &aContextName); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName); + + iMessageManagerCallback.Complete(EPacketContextUpdateMbmsSessionList, &dataPackage, aError); + } //CPacketServicesDispatcher::CallbackUpdateMbmsSessionList + +void CPacketServicesDispatcher::CallbackNotifyConnectionInfoChange(TInt aError, const TDesC& aContextName, const RPacketContext::TConnectionInfoV1& aConnectionInfo) +/** + * Callback function to be used by the request to complete + * CCtsyDispatcherCallback::CallbackPacketServicesNotifyConnectionInfoChangeInd() + * + * @param aError The error code to be returned. + * @param aContextName The context name, the maximum length of the descriptor should not exceed KMaxInfoName. + * @param aConnectionInfo The details of the connection, including HSDPA Category and HSUPA Category + */ + { + TSYLOGENTRYEXITARGS(_L8("aError=%d, aContextName=%S, iHSDPACategory=%d, iHSUPACategory=%d"), + aError, &aContextName, aConnectionInfo.iHSDPACategory, aConnectionInfo.iHSUPACategory); + + __ASSERT_DEBUG(aContextName.Length() <= KMaxInfoName, CtsyDispatcherPanic(EBadLength)); + + //CTSY unpacks as a TInfoName* so we have to copy the TDesC& here to be safe. + TInfoName contextName(aContextName.Left(KMaxInfoName)); + + CMmDataPackage dataPackage; + dataPackage.PackData(&contextName, &const_cast(aConnectionInfo)); + + iMessageManagerCallback.Complete(EPacketContextNotifyConnectionInfoChange, &dataPackage, aError); + } + +void CPacketServicesDispatcher::CallbackSync(CRequestQueueOneShot::TIpcDataPackage& aIpcDataPackage) +/** + * Part of the MDispatcherCallback interface. Used to complete requests handled + * synchronously by the Licensee LTSY asynchronously back to the Common TSY. + * + * @param aIpcDataPackage Package encapsulating the request. + * + * @see MDispatcherCallback::CallbackSync + */ + { + TSYLOGENTRYEXIT; + + switch (aIpcDataPackage.iIpc) + { + + default: + LOG(_L8("WARNING: CPacketServicesDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc); + __ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc)); + break; + } // switch (aIpcDataPackage.iIpc) + + } // CPacketServicesDispatcher::CallbackSync + +/** +* Perform conversion from R99 negotiated QoS to R97 negotiated QoS according to 3GPP 24.008-750 +* +* @param aQoSR99_R4Negotiated - Etel R99_R4 negotiated QoS +* @param aQoSGPRSNegotiated - Etel GPRS negotiated QoS +* @return Etel error code +**/ +TInt CPacketServicesDispatcher::EtelPcktR99R4NegToEtelPcktR97NegQoS(const RPacketQoS::TQoSR99_R4Negotiated& aQoSR99_R4Negotiated, + RPacketQoS::TQoSGPRSNegotiated& aQoSGPRSNegotiated) + { + + RPacketQoS::TQoSGPRSRequested generatedGPRSQoS; + + /* Traffic class/handling priority to delay */ + if ((aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassConversational) || (aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassStreaming)) + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EDelayClass1; + } + else if ((aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassInteractive) && (aQoSR99_R4Negotiated.iTrafficHandlingPriority == RPacketQoS::ETrafficPriority1)) + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EDelayClass1; + } + else if ((aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassInteractive) && (aQoSR99_R4Negotiated.iTrafficHandlingPriority == RPacketQoS::ETrafficPriority2)) + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EDelayClass2; + } + else if ((aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassInteractive) && (aQoSR99_R4Negotiated.iTrafficHandlingPriority == RPacketQoS::ETrafficPriority3)) + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EDelayClass3; + } + else if (aQoSR99_R4Negotiated.iTrafficClass == RPacketQoS::ETrafficClassBackground) + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EDelayClass4; + } + else + { + aQoSGPRSNegotiated.iDelay = RPacketQoS::EUnspecifiedDelayClass; + } + + /* Error Ratio/max BER to reliability */ + if (aQoSR99_R4Negotiated.iSDUErrorRatio == RPacketQoS::ESDUErrorRatioOnePerHundredThousand) // Assumption this means < 0.00001 + { + aQoSGPRSNegotiated.iReliability = RPacketQoS::EReliabilityClass2; + } + else if (aQoSR99_R4Negotiated.iSDUErrorRatio == RPacketQoS::ESDUErrorRatioOnePerTenThousand) // Assumption x between 0.00001 and 0.0005 best representation ESDUErrorRatioOnePerTenThousand + { + aQoSGPRSNegotiated.iReliability = RPacketQoS::EReliabilityClass3; + } + else if ((aQoSR99_R4Negotiated.iSDUErrorRatio == RPacketQoS::ESDUErrorRatioOnePerThousand) && (aQoSR99_R4Negotiated.iBER == RPacketQoS::EBEROnePerHundredThousand)) // Assumption > 0.0005 SDU & <= 0.0002 BER + { + aQoSGPRSNegotiated.iReliability = RPacketQoS::EReliabilityClass4; + } + else if ((aQoSR99_R4Negotiated.iSDUErrorRatio == RPacketQoS::ESDUErrorRatioOnePerThousand) && (aQoSR99_R4Negotiated.iBER == RPacketQoS::EBEROnePerThousand)) // Assumption > 0.0005 & > 0.0002 BER + { + aQoSGPRSNegotiated.iReliability = RPacketQoS::EReliabilityClass5; + } + else + { + aQoSGPRSNegotiated.iReliability = RPacketQoS::EUnspecifiedReliabilityClass; + } + + /* Max rate to peak throughput, using maximum between uplink and downlink */ + TInt tempMaxBitRate = Max(aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate, aQoSR99_R4Negotiated.iMaxRate.iUplinkRate); + + if (tempMaxBitRate < 16) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput1000; + } + else if ((tempMaxBitRate >= 16) && (tempMaxBitRate < 32)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput2000; + } + else if ((tempMaxBitRate >= 32) && (tempMaxBitRate < 64)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput4000; + } + else if ((tempMaxBitRate >= 64) && (tempMaxBitRate < 128)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput8000; + } + else if ((tempMaxBitRate >= 128) && (tempMaxBitRate < 256)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput16000; + } + else if ((tempMaxBitRate >= 256) && (tempMaxBitRate < 512)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput32000; + } + else if ((tempMaxBitRate >= 512) && (tempMaxBitRate < 1024)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput64000; + } + else if ((tempMaxBitRate >= 1024) && (tempMaxBitRate < 2048)) + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput128000; + } + else + { + aQoSGPRSNegotiated.iPeakThroughput = RPacketQoS::EPeakThroughput256000; + } + + /* Traffic handling priority to precedence */ + switch (aQoSR99_R4Negotiated.iTrafficHandlingPriority) + { + case RPacketQoS::ETrafficPriority1: + aQoSGPRSNegotiated.iPrecedence = RPacketQoS::EPriorityHighPrecedence; + break; + case RPacketQoS::ETrafficPriority2: + aQoSGPRSNegotiated.iPrecedence = RPacketQoS::EPriorityMediumPrecedence; + break; + case RPacketQoS::ETrafficPriority3: + aQoSGPRSNegotiated.iPrecedence = RPacketQoS::EPriorityLowPrecedence; + break; + default: + aQoSGPRSNegotiated.iPrecedence = RPacketQoS::EUnspecifiedPrecedence; + break; + } + + /* Mean throughput always at best effort */ + aQoSGPRSNegotiated.iMeanThroughput = RPacketQoS::EMeanThroughputBestEffort; + + /* Delivery order to reordering required */ + if (aQoSR99_R4Negotiated.iDeliveryOrderReqd == RPacketQoS::EDeliveryOrderRequired) + { + /* Not clear what corresponding value to set */ + } + else if (aQoSR99_R4Negotiated.iDeliveryOrderReqd == RPacketQoS::EDeliveryOrderNotRequired) + { + /* Not clear what corresponding value to set */ + } + else + { + /* Not clear what corresponding value to set */ + } + + return KErrNone; + } + +/* +* Perform conversion from R97 negotiated QoS to R99 negotiated QoS according to 3GPP 24.008-750 +* +* @param aQoSGPRSNegotiated - Etel GPRS negotiated QoS +* @param aQoSR99_R4Negotiated - Etel R99_R4 negotiated QoS +* +* @return Etel error code +*/ +TInt CPacketServicesDispatcher::EtelPcktR97NegToEtelPcktR99R4NegQoS(const RPacketQoS::TQoSGPRSNegotiated& aQoSGPRSNegotiated, + RPacketQoS::TQoSR99_R4Negotiated& aQoSR99_R4Negotiated) + { + + RPacketQoS::TQoSGPRSRequested generatedGPRSQoS; + + /* Traffic class/handling delay to traffic*/ + if ((aQoSGPRSNegotiated.iDelay == RPacketQoS::EDelayClass1) || (aQoSGPRSNegotiated.iDelay == RPacketQoS::EDelayClass2) || (aQoSGPRSNegotiated.iDelay == RPacketQoS::EDelayClass3)) + { + aQoSR99_R4Negotiated.iTrafficClass = RPacketQoS::ETrafficClassInteractive; + } + else if (aQoSGPRSNegotiated.iDelay == RPacketQoS::EDelayClass4) + { + aQoSR99_R4Negotiated.iTrafficClass = RPacketQoS::ETrafficClassBackground; + } + else + { + aQoSR99_R4Negotiated.iTrafficClass = RPacketQoS::ETrafficClassUnspecified; + } + + /* Traffic handling priority class/traffic handling priority*/ + switch (aQoSGPRSNegotiated.iDelay) + { + case RPacketQoS::EDelayClass1: + aQoSR99_R4Negotiated.iTrafficHandlingPriority = RPacketQoS::ETrafficPriority1; + break; + case RPacketQoS::EDelayClass2: + aQoSR99_R4Negotiated.iTrafficHandlingPriority = RPacketQoS::ETrafficPriority2; + break; + case RPacketQoS::EDelayClass3: + aQoSR99_R4Negotiated.iTrafficHandlingPriority = RPacketQoS::ETrafficPriority3; + break; + default: + aQoSR99_R4Negotiated.iTrafficHandlingPriority = RPacketQoS::ETrafficPriorityUnspecified; + break; + } + + /* Reliability calss to SDU error ratio*/ + if ((aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass1) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass2)) + { + aQoSR99_R4Negotiated.iSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerHundredThousand; + } + else if (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass3) + { + aQoSR99_R4Negotiated.iSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerTenThousand; + } + else if ((aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass4) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass5)) + { + aQoSR99_R4Negotiated.iSDUErrorRatio = RPacketQoS::ESDUErrorRatioOnePerThousand; + } + else + { + aQoSR99_R4Negotiated.iSDUErrorRatio = RPacketQoS::ESDUErrorRatioUnspecified; + } + + + /* Reliability calss to Residual bit error ratio*/ + if ((aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass1) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass2) + || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass3) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass4)) + { + aQoSR99_R4Negotiated.iBER = RPacketQoS::EBEROnePerHundredThousand; + } + else if (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass5) + { + aQoSR99_R4Negotiated.iBER = RPacketQoS::EBERFourPerThousand; + } + else + { + aQoSR99_R4Negotiated.iBER = RPacketQoS::EBERUnspecified; + } + + /* Reliability class to delivery of erroneous SDUs*/ + if ((aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass1) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass2) + || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass3) || (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass4)) + { + aQoSR99_R4Negotiated.iDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryNotRequired; + } + else if (aQoSGPRSNegotiated.iReliability == RPacketQoS::EReliabilityClass5) + { + aQoSR99_R4Negotiated.iDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryRequired; + } + else + { + aQoSR99_R4Negotiated.iDeliverErroneousSDU = RPacketQoS::EErroneousSDUDeliveryUnspecified; + } + + /* Peak throughput class to Max bitrate*/ + switch (aQoSGPRSNegotiated.iPeakThroughput) + { + case RPacketQoS::EPeakThroughput1000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 8; + break; + case RPacketQoS::EPeakThroughput2000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 16; + break; + case RPacketQoS::EPeakThroughput4000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 32; + break; + case RPacketQoS::EPeakThroughput8000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 64; + break; + case RPacketQoS::EPeakThroughput16000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 128; + break; + case RPacketQoS::EPeakThroughput32000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 256; + break; + case RPacketQoS::EPeakThroughput64000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 512; + break; + case RPacketQoS::EPeakThroughput128000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 1024; + break; + case RPacketQoS::EPeakThroughput256000: + aQoSR99_R4Negotiated.iMaxRate.iDownlinkRate = 2048; + break; + case RPacketQoS::EUnspecifiedPeakThroughput: + default: + break; + } + + /*Precendence class to allocation/retention priority*/ + if (aQoSGPRSNegotiated.iPrecedence == RPacketQoS::EPriorityHighPrecedence) + { + /**/ + } + else if (aQoSGPRSNegotiated.iPrecedence == RPacketQoS::EPriorityMediumPrecedence) + { + /**/ + } + else if (aQoSGPRSNegotiated.iPrecedence == RPacketQoS::EPriorityMediumPrecedence) + { + /**/ + } + else + { + /**/ + } + + return KErrNone; + } + +/* +* Perform conversion from R99 negotiated QoS to R5 negotiated QoS according to 3GPP 24.008-750 +* +* @param aQoSR99_R4Negotiated - Etel R99_R4 negotiated QoS +* @param aQoSR5Negotiated - Etel R5 negotiated QoS +* +* @return Etel error code +*/ +TInt CPacketServicesDispatcher::EtelPcktR99R4NegToEtelPcktR5NegQoS(const RPacketQoS::TQoSR99_R4Negotiated& aQoSR99_R4Negotiated, + RPacketQoS::TQoSR5Negotiated& aQoSR5Negotiated) + { + aQoSR5Negotiated.iTrafficClass = aQoSR99_R4Negotiated.iTrafficClass; + aQoSR5Negotiated.iDeliveryOrderReqd = aQoSR99_R4Negotiated.iDeliveryOrderReqd; //< Negotiated value for sequential SDU delivery + aQoSR5Negotiated.iDeliverErroneousSDU = aQoSR99_R4Negotiated.iDeliverErroneousSDU; //< Negotiated value for erroneous SDU delivery + aQoSR5Negotiated.iMaxSDUSize = aQoSR99_R4Negotiated.iMaxSDUSize; //< Negotiated maximum SDU size (in octets) + aQoSR5Negotiated.iMaxRate = aQoSR99_R4Negotiated.iMaxRate; //< Negotiated maximum bit rates on the uplink and downlink + aQoSR5Negotiated.iBER = aQoSR99_R4Negotiated.iBER; //< Negotiated target BER + aQoSR5Negotiated.iSDUErrorRatio = aQoSR99_R4Negotiated.iSDUErrorRatio; //< Negotiated target SDU error ratio + aQoSR5Negotiated.iTrafficHandlingPriority = aQoSR99_R4Negotiated.iTrafficHandlingPriority; //< Negotiated traffic handling priority + aQoSR5Negotiated.iTransferDelay = aQoSR99_R4Negotiated.iTransferDelay; //< Negotiated transfer delay (in milliseconds) + aQoSR5Negotiated.iGuaranteedRate = aQoSR99_R4Negotiated.iGuaranteedRate; + + return KErrNone; + } + +void CPacketServicesDispatcher::ConvertDNSToPCOBuffer + (const TDes8& aPrimaryDNS, const TDes8& aSecondaryDNS, const TUint8 aRequestID, TDes8& aFormatPcoBufferAddr) + { + + // Handle Primary DNS address + TInetAddr netPrimaryDNS; + TBuf<32> netPrimaryDNSConv; + netPrimaryDNSConv.Copy(aPrimaryDNS); + // coverity[check_return] + netPrimaryDNS.Input(netPrimaryDNSConv); + TUint32 primDNSaddr = netPrimaryDNS.Address(); + + // Handle Secondary DNS address + TInetAddr netSecondaryDNS; + TBuf<32> netSecondaryDNSConv; + netSecondaryDNSConv.Copy(aSecondaryDNS); + // coverity[check_return] + netSecondaryDNS.Input(netSecondaryDNSConv); + TUint32 secondaryDNSaddr = netSecondaryDNS.Address(); + + aFormatPcoBufferAddr[0] = KPrimaryAndSecondaryDNSLength; // Length + aFormatPcoBufferAddr[1] = KIPCRequestCode; // IPC PRequest Code + aFormatPcoBufferAddr[2] = aRequestID; // Request ID (CHAP challenge) + aFormatPcoBufferAddr[3] = KPacketLengthMSB; // Packet length MSB (always zero) + aFormatPcoBufferAddr[4] = KPrimaryAndSecondaryDNSLength; // Packet length LSB + aFormatPcoBufferAddr[5] = KIndicatePrimaryAddress; // Indicate Primary address + aFormatPcoBufferAddr[6] = KDnsAddressLength; // Length of address (inc header) + aFormatPcoBufferAddr[7] = (primDNSaddr >> 24) & 0xff; // Primary DNS + aFormatPcoBufferAddr[8] = (primDNSaddr >> 16) & 0xff; // Primary DNS + aFormatPcoBufferAddr[9] = (primDNSaddr >> 8) & 0xff; // Primary DNS + aFormatPcoBufferAddr[10] = primDNSaddr & 0xff; // Primary DNS + aFormatPcoBufferAddr[11] = KIndicateSecondaryAddress; // Indicate Secondary address + aFormatPcoBufferAddr[12] = KDnsAddressLength; // Length of address (inc header) + aFormatPcoBufferAddr[13] = (secondaryDNSaddr >> 24) & 0xff; // Secondary DNS + aFormatPcoBufferAddr[14] = (secondaryDNSaddr >> 16) & 0xff; // Secondary DNS + aFormatPcoBufferAddr[15] = (secondaryDNSaddr >> 8) & 0xff; // Secondary DNS + aFormatPcoBufferAddr[16] = secondaryDNSaddr & 0xff; // Secondary DNS + aFormatPcoBufferAddr.SetLength(KPrimaryAndSecondaryDNSLength + 1); + } + +void CPacketServicesDispatcher::ConvertUsernameAndPasswordToPCOBuffer(const TDes8& aUsername, const TDes8& aPassword, TUint8 aRequestID, TDes8& aFormatedBuffer) + { + TInt usernameLen = aUsername.Length(); + TInt passwordLen = aPassword.Length(); + TInt dataLen = usernameLen + passwordLen + KPasswordUsernameHeaderLength; + TInt i = 0; + + aFormatedBuffer[i++] = dataLen; // Length + aFormatedBuffer[i++] = KIPCRequestCode; // IPC PRequest Code + aFormatedBuffer[i++] = aRequestID; // Request ID (CHAP challenge) + aFormatedBuffer[i++] = KPacketLengthMSB; // Packet length MSB (always zero) + aFormatedBuffer[i++] = dataLen; // Packet length LSB + aFormatedBuffer[i++] = usernameLen; // Length of username + aFormatedBuffer.SetLength(i); + aFormatedBuffer.Append(aUsername); // Username + aFormatedBuffer.SetLength(i + usernameLen + 1); + aFormatedBuffer[i + usernameLen] = passwordLen; // Length of password + aFormatedBuffer.Append(aPassword); // Password + } + +void CPacketServicesDispatcher::DecodePCO(const RPacketContext::TMiscProtocolBuffer& aPcoBuffer, RPacketContext::TAuthData& aUsername, RPacketContext::TAuthData& aPassword, RPacketContext::TProtocolAddress& aPrimaryDNS, RPacketContext::TProtocolAddress& aSecondaryDNS, RPacketContext::TMiscProtocolBuffer& aMiscBuffer) + { + TUint currIndex = KHeaderGap; + + // Skip Headers + TUint usernameLen = aPcoBuffer[currIndex++]; + + // Get the username + aUsername = aPcoBuffer.Mid(currIndex, usernameLen); + currIndex += usernameLen; + + TUint passwordLen = aPcoBuffer[currIndex++]; + aPassword = aPcoBuffer.Mid(currIndex, passwordLen); + + currIndex += passwordLen; + currIndex += KHeaderGap; + + // Skip primary DNS length + currIndex += 2; + + // Get the primary DNS + TUint32 uintDnsAddr = 0; + uintDnsAddr = aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + + TInetAddr dnsInetAddr; + dnsInetAddr.SetAddress(uintDnsAddr); + TBuf<32> netPrimaryDNSAddrLogOutput; + dnsInetAddr.Output(netPrimaryDNSAddrLogOutput); + aPrimaryDNS.Copy(netPrimaryDNSAddrLogOutput); + + // Skip the Secondary indicator + currIndex += 2; + + uintDnsAddr = 0; + uintDnsAddr = aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + uintDnsAddr <<= 8; + uintDnsAddr |= aPcoBuffer[currIndex++]; + + dnsInetAddr.SetAddress(uintDnsAddr); + TBuf<32> netSecondaryDNSAddrLogOutput; + dnsInetAddr.Output(netSecondaryDNSAddrLogOutput); + aSecondaryDNS.Copy(netSecondaryDNSAddrLogOutput); + + aMiscBuffer = aPcoBuffer.Mid(currIndex); + } + +CPcktMbmsMonitoredServiceList* CPacketServicesDispatcher::CreateServiceListL(const RArray& aServiceIds) const + { + CPcktMbmsMonitoredServiceList* updateMbmsMonitorServiceList = CPcktMbmsMonitoredServiceList::NewL(); + CleanupStack::PushL(updateMbmsMonitorServiceList); + + const TInt serviceIdCount = aServiceIds.Count(); + RPacketService::TMbmsServiceAvailabilityV1 entry; + + for(TInt i = 0; i < serviceIdCount; ++i) + { + entry.iTmgi.SetServiceId(aServiceIds[i]); + updateMbmsMonitorServiceList->AddEntryL(entry); + } + + CleanupStack::Pop(updateMbmsMonitorServiceList); + return updateMbmsMonitorServiceList; + } + +