--- /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 <f32file.h>
+#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