diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/tsrc/stubs/src/esock_stubs.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommscontroller/tsrc/stubs/src/esock_stubs.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,552 @@ +/* +* Copyright (c) 2003-2004 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 +#include +#include +//#include "SOCKMES.H" +#include "ConnPref.h" +//#include "ss_log.h" +#include +#include + +using Meta::STypeId; + +//////////////////////////////////////////////////////////////////////////////// +// Socket Address +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C TSockAddr::TSockAddr() + : TBuf8() +/** Default constructor initialises the address to be zero-filled. */ + { + SetLength(KMaxSockAddrSize); + SetFamily(KAFUnspec); + } + +EXPORT_C TSockAddr::TSockAddr(TUint aFamily) +/** +Constructs the address with the family member data specified. + +@released. +@param aFamily, Address family of address object. +*/ + : TBuf8() +/** Constructs the address with the family member data specified. + +@param aFamily Address family Id. */ + { + SetLength(KMaxSockAddrSize); + SetFamily(aFamily); + } + +EXPORT_C TUint TSockAddr::Family() const +/** Gets the address family and thereby the type of address. The family may be +used to effect 'down-casting'. + +@return Address family Id. */ + { + return BasePtr()->iFamily; + } + +EXPORT_C void TSockAddr::SetFamily(TUint aFamily) +/** Sets the address family of an address. + +@param aFamily Address family Id. */ + { + BasePtr()->iFamily = aFamily; + } + +EXPORT_C void TSockAddr::SetPort(TUint aPort) +// +// Set Generic Port +// +/** Sets the address port of an address. + +@param aPort New port value for address */ + { + BasePtr()->iPort = aPort; + } + +EXPORT_C TUint TSockAddr::Port() const +// +// Get Generic Port +// +/** Gets the port value. + +@return Port value */ + { + return BasePtr()->iPort; + } + +EXPORT_C TBool TSockAddr::CmpPort(const TSockAddr &anAddr) const +/** +Compare two ports. + +Compares ports in two addresses + +@param anAddr, socket address. +@return ETrue if the ports match and EFalse if they do not +*/ + { + return (BasePtr()->iFamily==anAddr.BasePtr()->iFamily) + && (BasePtr()->iPort==anAddr.BasePtr()->iPort); + } + +EXPORT_C void TSockAddr::SetUserLen(TInt aLen) +// +// Set descriptor length to actual length of +// subclass. +// +/** Sets the length of data it appends after the base class' data. This function +is mainly intended for use in derived classes. + +@param aLen New length for appended data. */ + { + SetLength(aLen+Align4(sizeof(SSockAddr))); + } + +EXPORT_C TInt TSockAddr::GetUserLen() +// +// Get length of user part of TSockAddr +// +/** Gets the number of bytes a derived class has set beyond the SSockAddr part +of the address. This function is mainly intended for use in derived classes. + +@return User length */ + { + return Length()-Align4(sizeof(SSockAddr)); + } + +//////////////////////////////////////////////////////////////////////////////// +// RConnection +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C RConnection::RConnection() + : iNewISPId(0) //lint -esym(1401, RConnection::iReserved) // no BC issue as ctor not inlined +/** Empty constructor. */ + { + } + +EXPORT_C RConnection::~RConnection() +/** Empty destructor. */ + { + } + +//////////////////////////////////////////////////////////////////////////////// +// RSocketServ +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C RSocketServ::RSocketServ() +/** +Default Constructor +*/ + { + } + +//////////////////////////////////////////////////////////////////////////////// +// RSocket +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C RSocket::RSocket() +/** +Default Constructor +*/ + { + } + +EXPORT_C TInt RSocket::SetOpt(TUint /*anOptionName*/,TUint /*anOptionLevel*/,const TDesC8& /*anOption*/ /*=TPtrC(NULL,0)*/) +/** Sets a socket option. The socket server has options which are generic to all +sockets and protocols may add specific options. + +Options available for all protocols can be set with anOptionLevel set to KSOLSocket. +See individual protocol notes for other socket options. + +@param anOptionName An integer constant which identifies an option. +@param anOptionLevel An integer constant which identifies level of an option: +i.e. an option level groups related options together. +@param anOption Option value packaged in a descriptor. +@return KErrNone if successful, otherwise another of the system-wide error +codes. + +@capability Dependent on the type of operation so deferred to PRT. See documentation +of constant values used in aOptionName and aOptionLevel for more information */ + { +// return SendReceive(ESoSetOpt,TIpcArgs(anOptionName,&anOption,anOptionLevel)); + return KErrNone; + } + +EXPORT_C TInt RSocket::SetOpt(TUint anOptionName,TUint anOptionLevel,TInt anOption) +/** Sets a socket option. The socket server has options which are generic to all +sockets and protocols may add specific options. + +Options available for all protocols can be set with anOptionLevel set to KSOLSocket. +See individual protocol notes for other socket options. + +@param anOptionName An integer constant which identifies an option. +@param anOptionLevel An integer constant which identifies level of an option: +i.e. an option level groups related options together. +@param anOption Option value as an integer. +@return KErrNone if successful, otherwise another of the system-wide error +codes. + +@capability Dependent on the type of operation so deferred to PRT. See documentation +of constant values used in aOptionName and aOptionLevel for more information */ + { + + TPtr8 optionDes((TUint8*)&anOption,sizeof(TInt),sizeof(TInt)); + return SetOpt(anOptionName,anOptionLevel,optionDes); + } + +EXPORT_C void RSocket::LocalName(TSockAddr &/*anAddr*/) +/** Gets the local address of a bound socket. + +The local address is set either by calling Bind(), or is automatically set +when Connect() is called. + +If a socket is created through Accept() then a socket will inherit the port +of its parent unless otherwise specified by a protocol's behaviour. + +Depending on a protocol implementation, additional information may be gained +through this call. + +@param anAddr Local address which is filled in on return. */ + { +// SendReceive(ESoGetLocalName,TIpcArgs(&anAddr)); + } + +EXPORT_C TUint RSocket::LocalPort() +/** Gets the local port number of a bound socket. + +Getting the local port is similar to getting the local name. + +@see LocalName() for a description. +@return The local port of a socket. */ + { + TSockAddr addr; + LocalName(addr); + return addr.Port(); + } + +//////////////////////////////////////////////////////////////////////////////// +// TNotificationEventBuf +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C TNotificationEventBuf::TNotificationEventBuf() + { + SetLength(this->MaxLength()); + FillZ(); + } + +EXPORT_C TNotificationEventBuf::~TNotificationEventBuf() + { + } + +EXPORT_C TUint32 TNotificationEventBuf::Id() const +/** Provides the sub-type Id of the event + +@return sub-type id +*/ + { + return *((TUint32*)(Ptr() + sizeof(TUint32))); + } + +//////////////////////////////////////////////////////////////////////////////// +// RSubConParameterBundle +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C RSubConParameterBundle::RSubConParameterBundle() + : iBundle(NULL) +/** Empty sub-connection parameter bundle constructor +*/ + { + } + +EXPORT_C void RSubConParameterBundle::Close() +/** Close the parameter bundle handle +*/ + { + if (iBundle) + { + iBundle->Close(); + iBundle = NULL; + } + } + +EXPORT_C void RSubConParameterBundle::AddFamilyL(CSubConParameterFamily* aFamily) +/** Add a sub-connection parameter family to the bundle. + +@param aFamily Family to be added (bundle takes ownership) +@exception leaves with KErrNoMemory in out of memory conditions +*/ + { + User::LeaveIfError(CheckBundle()); + iBundle->AddFamilyL(aFamily); + } + +TInt RSubConParameterBundle::CheckBundle() const +/** Check to see if the handle has a heap object. If it hasn't, it creates one + +@return KErrNone if successful, otherwise a system wide error +*/ + { + if (!iBundle) + { + TRAPD(ret, iBundle = CSubConParameterBundle::NewL()); + return ret; + } + return KErrNone; + } + +//////////////////////////////////////////////////////////////////////////////// +// CSubConParameterBundle +//////////////////////////////////////////////////////////////////////////////// + +CSubConParameterBundle::CSubConParameterBundle() +/** Empty sub-connection generic parameter bundle constructor +*/ + { + } + +EXPORT_C CSubConParameterBundle::~CSubConParameterBundle() +/** Sub-connection parameter bundle destructor, clear up the families +*/ + { + iFamilies.ResetAndDestroy(); + } + +EXPORT_C CSubConParameterBundle* CSubConParameterBundle::NewL() +/** Creates a new instance of a sub-connection parameter bundle (heap object) + Can be used directly as a CObject or via the RSubConParameterBundle handle. + +@return newly created instance of a sub-connection parameter bundle +@exception leaves with KErrNoMemory in out of memory conditions +*/ + { + return new (ELeave) CSubConParameterBundle(); + } + +EXPORT_C void CSubConParameterBundle::AddFamilyL(CSubConParameterFamily* aFamily) +/** Add a sub-connection parameter family to the bundle. + +@param aFamily Family to be added (bundle takes ownership) +@exception leaves with KErrNoMemory in out of memory conditions +*/ + { + iFamilies.AppendL(aFamily); + } + +//////////////////////////////////////////////////////////////////////////////// +// CSubConParameterFamily +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C CSubConParameterFamily* CSubConParameterFamily::NewL(RSubConParameterBundle& aBundle, TUint32 aFamilyId) +/** Creates a new sub-connection parameter set family. This class is used as a container for a number of parameter + sets (generic and extension) that make up a family. It is a specific instantiatable class and therefore creates + an instance of CSubConParameterFamily without using ECOM. + +@param aBundle Family container (bundle) that this family is to be added to +@param aFamilyId identifier for the specific family type, currently only 2, QoS (KSubConQoSFamily) and Authorisation (KSubConAuthorisationFamily), are defined. +@return a pointer to a sub-connection parameter family if successful, otherwise leaves with system error code. +*/ + { + CSubConParameterFamily* family = new (ELeave) CSubConParameterFamily(aFamilyId); + CleanupStack::PushL(family); + family->ConstructL(aBundle); + CleanupStack::Pop(family); + return family; + } + +CSubConParameterFamily::CSubConParameterFamily(TUint32 aFamilyId) + : iFamilyId(aFamilyId) +/** Empty sub-connection parameter family constructor + +@param aFamilyId Identity of the family +*/ + { + } + +void CSubConParameterFamily::ConstructL(RSubConParameterBundle& aBundle) +/** Set up the sub-connection family with empty sets + +@param aBundle Bundle (container) the family is to be added to +@exception leaves with KErrNoMemory in out of memory conditions +*/ + { + iGenericSets.AppendL(NULL); + iGenericSets.AppendL(NULL); + iGenericSets.AppendL(NULL); + aBundle.AddFamilyL(this); + } + +EXPORT_C CSubConParameterFamily::~CSubConParameterFamily() +/** Sub-connection parameter family destructor. It cleans up the arrays deleting all + the paarmeter sets it ownes +*/ + { + iGenericSets.ResetAndDestroy(); + iExtensionSets[ERequested].ResetAndDestroy(); + iExtensionSets[EAcceptable].ResetAndDestroy(); + iExtensionSets[EGranted].ResetAndDestroy(); + } + +EXPORT_C void CSubConParameterFamily::AddExtensionSetL(CSubConExtensionParameterSet& aExtensionSet, TParameterSetType aType) +/** +Adds an extension parameter set to a sub-connection parameter set family. + +@param aExtensionSet Extension Parameter Set to be added to the family (family takes ownership) +@param aType The type of the set (requested, acceptable or granted) +@exception leaves with KErrNoMemory in out of memeory conditions. +*/ + { + iExtensionSets[aType].AppendL(&aExtensionSet); + } + + +EXPORT_C CSubConParameterSet* CSubConParameterSet::NewL(const STypeId& aTypeId) +/** Creates a new sub-connection parameter set using ECOM to load the DLL plugin + that implements the set. + +@param aTypeId Id of the class (Composed of Uid of the implementation and an integer sub-type +@return a generic pointer to a specific parameter set if successful, otherwise leaves with system error code. +*/ + { + return static_cast(Meta::SMetaDataECom::NewInstanceL(aTypeId)); + } + +CSubConParameterSet::~CSubConParameterSet() +/** Empty (virtual) sub-connection parameter set destructor +*/ + { + } + +CSubConParameterSet::CSubConParameterSet() +/** Empty sub-connection parameter set constructor +*/ + { + } + + +//////////////////////////////////////////////////////////////////////////////// +// Meta::RMetaDataContainerBase +//////////////////////////////////////////////////////////////////////////////// + + +EXPORT_C Meta::RMetaDataContainerBase::RMetaDataContainerBase() +/** + * Constructor + */ + { + } + + +//////////////////////////////////////////////////////////////////////////////// +// Meta::SMetaDataECom +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C Meta::SMetaDataECom::SMetaDataECom() +/** + * Protected and explicit constructor + */ + { + iDestroyUid.iUid = 0; + } + +EXPORT_C Meta::SMetaDataECom::~SMetaDataECom() +/** + * Destructor + */ + { + if ( iDestroyUid.iUid ) + { + REComSession::DestroyedImplementation(iDestroyUid); + } + } + +EXPORT_C SMetaDataECom* Meta::SMetaDataECom::NewInstanceL(const STypeId& aTypeId) +/** + * Static, instantiates a meta object based on its Type ID. + */ + { +/* + TUid destroyUid; + SMetaDataECom* obj = reinterpret_cast(REComSession::CreateImplementationL(aTypeId.iUid, destroyUid, (TAny*)aTypeId.iType)); + obj->iDestroyUid = destroyUid; +*/ + SMetaDataECom* obj = reinterpret_cast(REComSession::CreateImplementationL(aTypeId.iUid, (TInt32)0 )); + return obj; + } + +EXPORT_C SMetaDataECom* Meta::SMetaDataECom::LoadL(TPtrC8& aDes) +/** + * Static, encapsulates instantiation and loading of a content of a meta object + * from data contained in a descriptor. + * This function must be provided by all meta objects that will be used as a parameter + * to TMetaPtr<> template. + */ + { + STypeId typeId; + Mem::Copy(&typeId.iUid, aDes.Ptr(), sizeof(TUid)); + aDes.Set(aDes.Ptr()+sizeof(TUint32),aDes.Length()-sizeof(TUint32)); //update pointer (uid) + Mem::Copy(&typeId.iType, aDes.Ptr(), sizeof(TInt32)); + aDes.Set(aDes.Ptr()+sizeof(TUint32),aDes.Length()-sizeof(TUint32)); //update pointer (type) + + SMetaDataECom* mtd = NewInstanceL(typeId); + return mtd; + } + +//////////////////////////////////////////////////////////////////////////////// +// Meta::SMetaData +//////////////////////////////////////////////////////////////////////////////// + +EXPORT_C Meta::SMetaData::SMetaData() +/** + * Protected and explicit constructor + */ + { + } + +EXPORT_C Meta::SMetaData::~SMetaData() +/** + * Virtual destructor + */ + { + } + +CSubConExtensionParameterSet::~CSubConExtensionParameterSet() + { + + } + +CSubConExtensionParameterSet::CSubConExtensionParameterSet() + { + + } + +Meta::SVDataTableEntry const* CSubConQosR99ParamSet::GetVDataTable() const + { + return NULL; + } + +TUint8* CSubConQosR99ParamSet::GetAttribPtr(const TInt /*aOffset*/) const + { + return NULL; + } +