diff -r 000000000000 -r dfb7c4ff071f serialserver/c32serialserver/SCOMM/CS_MAN.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/serialserver/c32serialserver/SCOMM/CS_MAN.CPP Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,265 @@ +// Copyright (c) 1997-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: +// + + +/** @file + * + * Implements CPortManager and various small functions + */ + +#include "CS_STD.H" +#include +#include "C32LOG.H" + +LOCAL_C void CloseCObject(TAny* aCObject) +/** + * Utility func for cleanup stack - clean up a CObject + * + * @param aObj pointer to object to be closed + */ + { + ((CObject*)aCObject)->Close(); + } + + +// +// implementation of CPortManager +// + +CPort* CPortManager::GetPortL(const TDesC& aName, TUint aPort, CSerial* aSerial, + TUint aMode, TUint aRole, CCommSession* aSession) +/** + * Return a port matching a given name for a given mode. + * If the port already exists, increments the count on this CObject. + * + * @param aName name of the port + * @param aPort port number + * @param aSerial pointer to the CSerial object + * @param aMode mode; Exclusive, Shared or Preemptable + * @param aRole role; DTE or DCE + * @param aSession handle to the clients session + * @return CPort* pointer to the CPort object + * + * @leave Leave This function may leave + */ + { + CPort* p = NULL; + TInt handle = 0; + TFullName dummy; + TInt res = iPorts->FindByFullName(handle, aName, dummy); + switch (res) + { + case KErrNotFound: + { + (void)aSerial->Open(); // CObject->Open() always returns KErrNone so its safe to ignore return value + TCleanupItem serialClose(CloseCObject, aSerial); + CleanupStack::PushL(serialClose); + // And create a port from it. + p = aSerial->NewPortL(aPort); + TCleanupItem portClose(CloseCObject, p); + CleanupStack::PushL(portClose); + p->iExtra = new(ELeave) CPort::CExtra(); + p->DoOpenL(aSession,(TInternalCommAccess)aMode,(TCommRole)aRole,ETrue); + p->iPortManager = this; + iPorts->AddL(p); + p->SetOwner(aSerial); + C32LOG2(KC32Player, _L8("CPortManager::GetPortL() New Port - AccessCount: %d"), p->AccessCount()); + CleanupStack::Pop(2); // portClose, serialClose + break; + } + case KErrNone: + // find the port, attempt to open it as shared or take possession, and increment + // object usage count. + p = (CPort*)iPorts->At(handle); + p->DoOpenL(aSession, (TInternalCommAccess)aMode,(TCommRole)aRole,EFalse); + (void)p->Open(); // CObject->Open() always returns KErrNone so its safe to ignore return value + C32LOG2(KC32Player, _L8("CPortManager::GetPortL() Existing Port - AccessCount: %d"), p->AccessCount()); + break; + default: + User::Leave(res); + } + return p; + } + + +CPortManager* CPortManager::NewL() +/** + * Locate and initialise all loadable port modules + * + * @return an newly created CPortManager object + * @leave Leave This function may leave + */ + { + CPortManager* p = new (ELeave) CPortManager(); + CleanupStack::PushL(p); + p->ConstructL(); + CleanupStack::Pop(); + return p; + } + +CPortManager::~CPortManager() + { + iContainer->Remove(iProviders); + iContainer->Remove(iPorts); + delete iContainer; + } + +void CPortManager::ConstructL() +/** + * construct and init the children + */ + { + iContainer = CObjectConIx::NewL(); + iPorts = iContainer->CreateL(); + iProviders = iContainer->CreateL(); + } + + +LOCAL_C void CloseLibrary(TAny* aLib) +/** + * Close a library from the cleanup stack + * + * @param aLib pointer to the library to close + */ + { + ((RLibrary*)aLib)->Close(); + } + + + +CSerial* CPortManager::GetSerialL(const TDesC& aName) +/** + * Find a previously loaded CSY by name and return its factory + * + * @param aName name of the port + * @return CSerial* pointer to the serial object + * @leave Leave This function may leave + */ + { + TInt handle = 0; + TName matching; + (void)User::LeaveIfError(iProviders->FindByName(handle, aName, matching)); + return (CSerial*)iProviders->At(handle); + } + + +CSerial* CPortManager::LoadCommModuleL(const TDesC& aFileName) +/** + * Load a comms module on user request or increments the ref count for the module. + * This function loads the CSY + * specified in aFileName, and if found calls the first ordinal on it. + * The CSY instantiates itself and returns the pointer to the CSerial + * object implemented in the CSY. If everything goes OK then this + * pointer will be returned to the callee which then takes ownedship of it. + * + * @param aFileName name of the new CSY module to load (i.e. ECUART.CSY) + * @return CSerial* pointer to the new CSerial object + * @leave Leave This function may leave + */ + { + C32LOG2(KC32Player,_L("CPortManager::LoadCommModuleL(), Comms Module Name : %S"), &aFileName); + RLibrary lib; + TInt r=lib.Load(aFileName); + if (r!=KErrNone) + User::Leave(r); + + TCleanupItem libClose(CloseLibrary,&lib); + CleanupStack::PushL(libClose); + + // Check the Uid2 [unicode] + if(lib.Type()[1]!=TUid::Uid(KUidUnicodeCommServerModuleV02)) + User::Leave(KErrBadLibraryEntryPoint); + + TSerialNewL libEntry=(TSerialNewL)lib.Lookup(1); + if (libEntry==NULL) + User::Leave(KErrBadLibraryEntryPoint); + + CSerial* s = NULL; + s = (*libEntry)(); // libEntry may leave. + User::LeaveIfNull(s); // libEntry may also return null + + CleanupStack::PushL(TCleanupItem(CloseCObject,s)); + s->ConstructL(lib); // Once lib is transferred it's handle is nulified because + // deleting s will cause the reference to be closed + + TRAPD(ret, iProviders->AddL(s)); + + switch (ret) + { + case KErrAlreadyExists: + { + // The CSY is already loaded since we already have a handle to + // its CSerial factory, so just increase the refcount on the factory. + TInt fHand = 0; + TName dummy; + iProviders->FindByName(fHand, s->Name(), dummy); // Can't be an error + CSerial* s2 = (CSerial*)iProviders->At(fHand); + s->Close(); // Should delete s and the library reference will be closed + s2->Open(); + s = s2; + } + break; + case KErrNone: + // success! + break; + default: + User::Leave(ret); + break; + } + + CleanupStack::Pop(2); // s and library reference are now in safe hands + + return s; + } + + +TInt CPortManager::PortInfo(const TPortName& aName, TSerialInfo& aSerial) +/** + * get info on a specified port. + * + * @param aName name of the port + * @param aSerial serial info will be written here + * @return TInt error code + */ + { + C32LOG2(KC32Player,_L("CPortManager::PortInfo() by Port Name : %S"), &aName); + TInt handle = 0; + TName matching; + TInt res = iProviders->FindByName(handle,aName,matching); + if(res == KErrNotFound) // INC052021 + { + TFileName fname; + TInt index = iProviders->Count(); + while(index>0) + { + index--; + CSerial* actual = (CSerial*)iProviders->operator[](index); + actual->ModuleName(fname); + if(fname == aName) + { + actual->Info(aSerial); + return KErrNone; + } + } + } + if (res != KErrNone) + return res; + CSerial* s = (CSerial*)(iProviders->At(handle)); + s->Info(aSerial); + return KErrNone; + } + + +// EOF - CS_MAN.CPP