diff -r c892c53c664e -r 9d2210c8eed2 connectivity/com.nokia.tcf/native/TCFNative/TCFServer/ServerManager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivity/com.nokia.tcf/native/TCFNative/TCFServer/ServerManager.cpp	Mon Apr 06 15:18:48 2009 -0500
@@ -0,0 +1,1192 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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: 
+*
+*/
+// ServerManager.cpp: implementation of the CServerManager class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "stdafx.h"
+#include "ServerManager.h"
+#include "ConnectionImpl.h"
+#include "resource.h"
+
+
+#ifdef _DEBUG
+extern BOOL gDoLogging;
+#endif
+
+#define LOG_SERVERMANAGER
+#if defined(LOG_SERVERMANAGER) && defined(_DEBUG)
+extern char TCDebugMsg[];
+#define TCDEBUGOPEN() if (gDoLogging) { m_DebugLog->WaitForAccess(); }
+#define TCDEBUGLOGS(s) if (gDoLogging) { sprintf(TCDebugMsg,"%s", s); m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA1(s, a1) if (gDoLogging) { sprintf(TCDebugMsg, s, a1); m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA2(s, a1, a2) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2); m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA3(s, a1, a2, a3) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2, a3); m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGCLOSE() if (gDoLogging) { m_DebugLog->ReleaseAccess(); }
+#else
+#define TCDEBUGOPEN()
+#define TCDEBUGLOGS(s)
+#define TCDEBUGLOGA1(s, a1)
+#define TCDEBUGLOGA2(s, a1, a2)
+#define TCDEBUGLOGA3(s, a1, a2, a3)
+#define TCDEBUGCLOSE()
+#endif
+
+extern char* gServerLocation;
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+CServerManager::CServerManager()
+{
+	m_DebugLog = NULL;
+	m_Server = NULL;
+	m_ConnectionList = NULL;
+	m_ClientList = NULL;
+	m_NextClientId = 0;
+	m_NextConnectionId = 0;
+	m_Version[0] = NULL;
+	m_ExeLocation = NULL;
+	m_ProtocolList = NULL;
+	m_CommList = NULL;
+
+}
+CServerManager::CServerManager(const char* exeLocation)
+{
+#ifdef _DEBUG
+	if (gDoLogging)
+		m_DebugLog = new TCDebugLog("TCF_ServerLog", ::GetCurrentProcessId());
+	else
+		m_DebugLog = NULL;
+#else
+	m_DebugLog = NULL;
+#endif
+	TCDEBUGOPEN();
+	TCDEBUGLOGS("CServerManager::CServerManager\n");
+
+	m_Server = new CServerCommand();
+
+	m_ConnectionList = new ConnectionList();
+	m_ConnectionList->clear();
+
+	m_ClientList = new ClientList();
+	m_ClientList->clear();
+
+	m_NextClientId = ::GetCurrentProcessId() * 100;
+	m_NextConnectionId = (::GetCurrentProcessId() * 100) + 100;
+
+	int ret = ::LoadString(::GetModuleHandle(NULL), IDS_VERSION, m_Version, MAX_VERSION_STRING);
+	TCDEBUGLOGA1(" version=%s\n", m_Version);
+
+	TCDEBUGLOGA1(" exeLocation=%s\n", exeLocation);
+	m_ExeLocation = new char[MAX_EXEPATHNAME];
+	m_ExeLocation[0] = '\0';
+	strcpy(m_ExeLocation, exeLocation);
+	TCDEBUGLOGA1(" m_ExeLocation=%s\n", m_ExeLocation);
+
+	m_ProtocolList = new ProtocolRegistry();
+	m_ProtocolList->clear();
+
+	m_CommList = new CommRegistry();
+	m_CommList->clear();
+
+	TCDEBUGCLOSE();
+}
+
+CServerManager::~CServerManager()
+{
+	TCDEBUGOPEN();
+	TCDEBUGLOGS("CServerManager::~CServerManager\n");
+
+	if (m_Server)
+		delete m_Server;
+
+	if (m_ConnectionList)
+	{
+		m_ConnectionList->clear();
+		delete m_ConnectionList;
+	}
+
+	if (m_ClientList)
+	{
+		m_ClientList->clear();
+		delete m_ClientList;
+	}
+
+	if (m_ExeLocation)
+		delete[] m_ExeLocation;
+
+	if (m_ProtocolList)
+	{
+		m_ProtocolList->clear();
+		delete m_ProtocolList;
+	}
+
+	if (m_CommList)
+	{
+		m_CommList->clear();
+		delete m_CommList;
+	}
+
+	TCDEBUGCLOSE();
+
+	if (m_DebugLog)
+		delete m_DebugLog;
+
+}
+void CServerManager::CommandThread()
+{
+	TCDEBUGOPEN();
+	TCDEBUGLOGS("CServerManager::CommandThread\n");
+	TCDEBUGCLOSE();
+	
+	bool done = false;
+	eServerCommand command = eCmdNone;
+	ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;
+	pServerMessageData pMsg = new ServerMessageData();
+
+	TCDEBUGOPEN();
+	RegisterAllProtocols();
+	RegisterAllComms();
+	TCDEBUGCLOSE();
+
+	while(!done)
+	{
+		while(!m_Server->GetCommand(pCmdrsp, pMsg))
+		{
+			Sleep(1);
+		}
+		command = pCmdrsp->command;
+
+		switch(command)
+		{
+		case eCmdConnect:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdConnect\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				BOOL connCreated = FALSE;
+				CConnectionImpl* conn = (CConnectionImpl*)FindConnection(&pCmdrsp->connectSettings);
+				if (conn == NULL)
+				{
+					// create new one
+					DWORD connId = m_NextConnectionId;
+					conn = new CConnectionImpl(pCmdrsp->connectSettings, connId);
+
+					TCDEBUGOPEN();
+					const char* commPath = FindCommPath(pCmdrsp->connectSettings.connectType);
+					TCDEBUGCLOSE();
+					TCDEBUGOPEN();
+					const char* protPath = FindProtocolPath(pCmdrsp->connectSettings.decodeFormat);
+					TCDEBUGCLOSE();
+
+					if (protPath == NULL || commPath == NULL)
+					{
+						ret = TCAPI_ERR_UNKNOWN_MEDIA_TYPE;
+					}
+					else
+					{
+						if (conn->CreateCommProtocols(commPath, protPath))
+						{
+							connCreated = TRUE;
+						}
+						else
+						{
+							ret = TCAPI_ERR_UNKNOWN_MEDIA_TYPE;
+						}
+					}
+				}
+				if (ret == TCAPI_ERR_NONE && (conn->IsDisconnected() || conn->IsRetryTimedOut()))
+				{
+					ret = conn->DoConnect();
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					DWORD id = m_NextClientId++;
+					// create client
+					CClient* client = new CClient(conn, pCmdrsp->clientOptions, id);
+					// add client to connection's list
+					conn->AddClient(client);
+					// add client to total list
+					m_ClientList->push_back(client);
+					// add connection to connection list
+					if (connCreated)
+						m_ConnectionList->push_back(conn);
+
+					m_NextConnectionId++;
+					pCmdrsp->response = eRspOK;
+					pCmdrsp->clientId = id;
+					m_Server->SendResponse(pCmdrsp);
+				}
+				else
+				{
+					if (conn->m_OsError > 0)
+						pCmdrsp->osError = conn->m_OsError;
+					else
+						pCmdrsp->osError = 0;
+					if (connCreated)
+						delete conn;
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+					m_Server->SendResponse(pCmdrsp);
+				}
+			}
+			break;
+		case eCmdDisconnect:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdDisconnect\n");
+	TCDEBUGCLOSE();
+				DWORD id = pCmdrsp->clientId;
+				// find this client in our list
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get the connection for this client
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					// pause the processing so we can delete the client 
+					conn->PauseProcessing();
+					// stop processing this client
+					client->Stop();
+					// remove client from registry
+					conn->RemoveClientFromRegistry(client);
+					// remove from connections client list
+					conn->RemoveClient(client);
+					// remove from total client list
+					RemoveClient(client);
+					// delete client
+					delete client;
+					// no more clients on this connection, disconnect this connection
+					if (conn->GetNumberClients() == 0)
+					{
+						conn->ExitProcessing();
+						conn->DoDisconnect();
+						RemoveConnection(conn);
+						delete conn;
+					}
+					else
+					{
+						conn->RestartProcessing();
+					}
+				}
+				pCmdrsp->response = eRspOK;
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdSetMessageIds:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdSetMessageIds\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				bool restart = false;
+				// find client
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsProcessingContinuing())
+					{
+						conn->PauseProcessing();
+						restart = true;
+					}
+					if (conn->IsDisconnected())
+					{
+						ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+					}
+					else if (conn->IsRetryInProgress())
+					{
+						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;
+					}
+					else if (conn->IsRetryTimedOut())
+					{
+						ret = TCAPI_ERR_COMM_TIMEOUT;
+					}
+
+					if (ret == TCAPI_ERR_NONE)
+					{
+						// add client to connection's registry
+						conn->AddClientToRegistry(client, pCmdrsp->number, pCmdrsp->messageIds);
+					}
+					if (restart)
+						conn->RestartProcessing();
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdGetNumberConnections:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdGetNumberConnections\n");
+	TCDEBUGCLOSE();
+				long num = m_ConnectionList->size();
+				pCmdrsp->response = eRspOK;
+				pCmdrsp->numConnections = num;
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdGetConnectionType:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdGetConnectionType\n");
+	TCDEBUGCLOSE();
+				long index = pCmdrsp->index;
+				CConnectionImpl* pConn = (CConnectionImpl*)FindConnection(index);
+				if (pConn != NULL)
+				{
+					pCmdrsp->response = eRspOK;
+					strncpy(pCmdrsp->connectSettings.connectType, pConn->m_ConnectSettings->connectType, MAX_CONNECTION_TYPE);
+//					pCmdrsp->connectSettings.connectType = pConn->m_ConnectSettings->connectType;
+					m_Server->SendResponse(pCmdrsp);
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = TCAPI_ERR_MISSING_CONNECTION_SPEC;
+					m_Server->SendResponse(pCmdrsp);
+				}
+			}
+			break;
+		case eCmdOpenStream:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdOpenStream\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				// find client
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsDisconnected())
+					{
+						ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+					}
+					else if (conn->IsRetryInProgress())
+					{
+						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;
+					}
+					else if (conn->IsRetryTimedOut())
+					{
+						ret = TCAPI_ERR_COMM_TIMEOUT;
+					}
+
+					if (ret == TCAPI_ERR_NONE)
+					{
+						bool restart = false;
+						if (conn->IsProcessingContinuing())
+						{
+							restart = true;
+							conn->PauseProcessing();
+						}
+						client->OpenStream(&pCmdrsp->destinationOptions);
+						if (restart)
+							conn->RestartProcessing();
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdCloseStream:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdCloseStream\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				bool restart = false;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsConnected())
+					{
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (conn->IsProcessingContinuing())
+							{
+								conn->PauseProcessing();
+								restart = true;
+							}
+						}
+						client->CloseStream();
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (restart)
+								conn->RestartProcessing();
+						}
+
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdOpenMessageFile:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdOpenMessageFile\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				// find client
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsDisconnected())
+					{
+						ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+					}
+					else if (conn->IsRetryInProgress())
+					{
+						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;
+					}
+					else if (conn->IsRetryTimedOut())
+					{
+						ret = TCAPI_ERR_COMM_TIMEOUT;
+					}
+
+					if (ret == TCAPI_ERR_NONE)
+					{
+						bool restart = false;
+						if (conn->IsProcessingContinuing())
+						{
+							restart = true;
+							conn->PauseProcessing();
+						}
+						client->OpenMessageFile(&pCmdrsp->destinationOptions);
+						if (restart)
+							conn->RestartProcessing();
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdCloseMessageFile:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdCloseMessageFile\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				bool restart = false;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsConnected())
+					{
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (conn->IsProcessingContinuing())
+							{
+								conn->PauseProcessing();
+								restart = true;
+							}
+						}
+						client->CloseMessageFile();
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (restart)
+								conn->RestartProcessing();
+						}
+
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdClearMessageFile:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdClearMessageFile\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				bool restart = false;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsConnected())
+					{
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (conn->IsProcessingContinuing())
+							{
+								conn->PauseProcessing();
+								restart = true;
+							}
+						}
+						client->ClearMessageFile();
+						if (restart)
+							conn->RestartProcessing();
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdStart:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdStart\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					conn->PauseProcessing();
+					if (conn->IsDisconnected())
+					{
+						ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+					}
+					else if (conn->IsRetryInProgress())
+					{
+						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;
+					}
+					else if (conn->IsRetryTimedOut())
+					{
+						ret = TCAPI_ERR_COMM_TIMEOUT;
+					}
+
+					if (ret == TCAPI_ERR_NONE)
+					{
+						client->Start();
+						conn->RestartProcessing();
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdStop:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdStop\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				bool restart = false;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					// get connection
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsConnected())
+					{
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (conn->IsProcessingContinuing())
+							{
+								restart = true;
+								conn->PauseProcessing();
+							}
+						}
+						client->Stop();
+						if (!conn->IsRetryTimedOut() && !conn->IsRetryInProgress())
+						{
+							if (restart)
+								conn->RestartProcessing();
+						}
+
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdStop done\n");
+	TCDEBUGCLOSE();
+			}
+			break;
+		case eCmdSendMessage:
+			{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdSendMessage\n");
+	TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				DWORD osErr = 0;
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsDisconnected())
+					{
+						ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+					}
+					else if (conn->IsRetryInProgress())
+					{
+						ret = TCAPI_ERR_COMM_RETRY_IN_PROGRESS;
+					}
+					else if (conn->IsRetryTimedOut())
+					{
+						ret = TCAPI_ERR_COMM_TIMEOUT;
+					}
+
+					if (ret == TCAPI_ERR_NONE)
+					{
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdSendMessage DoSendMessage\n");
+	TCDEBUGCLOSE();
+						ret = conn->DoSendMessage(pCmdrsp->encodeOption, pCmdrsp->protocolVersion, pCmdrsp->useMyId, pCmdrsp->myId, pMsg->length, pMsg->message);
+//						ret = conn->DoSendMessage(pMsg->length, pMsg->message);
+						if (ret != TCAPI_ERR_NONE)
+							osErr = conn->m_OsError;
+	TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdSendMessage DoSendMessage done\n");
+	TCDEBUGCLOSE();
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+//	TCDEBUGOPEN();
+//				TCDEBUGLOGS(" eCmdSendMessage OK\n");
+//	TCDEBUGCLOSE();
+					pCmdrsp->response = eRspOK;
+				}
+				else
+				{
+//	TCDEBUGOPEN();
+//				TCDEBUGLOGS(" eCmdSendMessage ERROR\n");
+//	TCDEBUGCLOSE();
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+					if (osErr > 0)
+						pCmdrsp->osError = osErr;
+					else
+						pCmdrsp->osError = 0;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdExit:
+			{
+				TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdExit\n");
+				TCDEBUGCLOSE();
+				DoShutdown();
+				done = true;
+			}
+			break;
+		case eCmdGetNumberVersions:
+			{
+				TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdGetNumberVersions\n");
+				TCDEBUGCLOSE();
+
+				long ret = TCAPI_ERR_NONE;
+				long numberVersions = 1; // 1 for server
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				if (client)
+				{
+					CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+					if (conn->IsConnected())
+					{
+						if (conn->HasVersion())
+							numberVersions++;
+					}
+				}
+				if (ret == TCAPI_ERR_NONE)
+				{
+					pCmdrsp->response = eRspOK;
+					pCmdrsp->number = numberVersions;
+				}
+				else
+				{
+					pCmdrsp->response = eRspError;
+					pCmdrsp->error = ret;
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdGetVersion:
+			{
+				TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdGetVersion\n");
+				TCDEBUGCLOSE();
+				// index = 1 ==> TCFServer version
+				// index = 2 ==> Connection version if it exists
+				long ret = TCAPI_ERR_NONE;
+				long index = pCmdrsp->index;
+				pCmdrsp->response = eRspOK;
+				pCmdrsp->version[0] = NULL;
+				if (index == 1)
+				{
+					pCmdrsp->response = eRspOK;
+					strncpy(pCmdrsp->version, m_Version, MAX_VERSION_STRING);
+				}
+				else if (index == 2)
+				{
+					DWORD id = pCmdrsp->clientId;
+					CClient* client = FindClient(id);
+					if (client)
+					{
+						CConnectionImpl* conn = (CConnectionImpl*)client->GetConnection();
+						if (conn->IsConnected())
+						{
+							pCmdrsp->response = eRspOK;
+							if (conn->HasVersion())
+							{
+								conn->GetVersion(pCmdrsp->version);
+							}
+						}
+						else
+						{
+							pCmdrsp->response = eRspError;
+							pCmdrsp->error = TCAPI_ERR_MEDIA_NOT_OPEN;
+						}
+					}
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		case eCmdGetClientStatus:
+			{
+				TCDEBUGOPEN();
+				TCDEBUGLOGS(" eCmdGetClientStatus\n");
+				TCDEBUGCLOSE();
+				long ret = TCAPI_ERR_NONE;
+				DWORD id = pCmdrsp->clientId;
+				CClient* client = FindClient(id);
+				pCmdrsp->response = eRspOK;
+				pCmdrsp->clientStatus = eUnknownClient;
+				if (client)
+				{
+					if (client->IsStarted())
+					{
+						pCmdrsp->clientStatus = eStarted;
+					}
+					else
+					{
+						pCmdrsp->clientStatus = eStopped;
+					}
+				}
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		default:
+			{
+				TCDEBUGOPEN();
+				TCDEBUGLOGA1(" unknown command = %d\n", command);
+				TCDEBUGCLOSE();
+				pCmdrsp->response = eRspOK;//eRspError;
+				pCmdrsp->error = TCAPI_ERR_FEATURE_NOT_IMPLEMENTED;
+				m_Server->SendResponse(pCmdrsp);
+			}
+			break;
+		}
+	}
+
+	pCmdrsp->response = eRspExitted;
+	m_Server->SendResponse(&cmdrsp);
+
+	if (pMsg)
+		delete pMsg;
+
+	TCDEBUGOPEN();
+	TCDEBUGLOGS("CServerManager::CommandThread exitting\n");
+	TCDEBUGCLOSE();
+}
+
+CConnection* CServerManager::FindConnection(pConnectData pConData)
+{
+	TCDEBUGLOGS("CServerManager::FindConnection1\n");
+	CConnection* connection = NULL;
+
+	if (m_ConnectionList->size() != 0)
+	{
+		ConnectionList::iterator pConn;
+		for (pConn = m_ConnectionList->begin(); pConn != m_ConnectionList->end(); pConn++)
+		{
+			if ((*pConn)->IsEqual(pConData))
+			{
+				connection = *pConn;
+				break;
+			}
+		}
+	}
+
+	TCDEBUGLOGA1("CServerManager::FindConnection1 connection=%x\n", connection);
+	return connection;
+
+}
+CConnection* CServerManager::FindConnection(long index)
+{
+	TCDEBUGLOGS("CServerManager::FindConnection2\n");
+	CConnection* connection = NULL;
+
+	if (m_ConnectionList->size() >= index)
+	{
+		connection = m_ConnectionList->at(index);
+	}
+
+	TCDEBUGLOGA1("CServerManager::FindConnection2 connection=%x\n", connection);
+	return connection;
+}
+CClient* CServerManager::FindClient(DWORD id)
+{
+	CClient* found = NULL;
+
+	if (m_ClientList->size() != 0)
+	{
+		ClientList::iterator iter;
+		for (iter = m_ClientList->begin(); iter != m_ClientList->end(); iter++)
+		{
+			if ((*iter)->GetClientId() == id)
+			{
+				found = *iter;
+				break;
+			}
+		}
+	}
+	return found;
+}
+
+BOOL CServerManager::RemoveClient(CClient* client)
+{
+	BOOL found = FALSE;
+
+	if (m_ClientList->size() != 0)
+	{
+		ClientList::iterator iter;
+		for (iter = m_ClientList->begin(); iter != m_ClientList->end(); iter++)
+		{
+			if ((*iter)->GetClientId() == client->GetClientId())
+			{
+				m_ClientList->erase(iter);
+				found = TRUE;
+				break;
+			}
+		}
+	}
+	return found;
+}
+
+BOOL CServerManager::RemoveConnection(CConnection* conn)
+{
+	BOOL found = FALSE;
+
+	if (m_ConnectionList->size() != 0)
+	{
+		ConnectionList::iterator iter;
+		for (iter = m_ConnectionList->begin(); iter != m_ConnectionList->end(); iter++)
+		{
+			if ((*iter)->GetConnectionId() == conn->GetConnectionId())
+			{
+				m_ConnectionList->erase(iter);
+				found = TRUE;
+				break;
+			}
+		}
+	}
+	return found;
+}
+
+void CServerManager::DoShutdown()
+{
+	// for each connection
+	// stop processing on that connection
+	// disconnect that connection
+	if (m_ConnectionList->size() != 0)
+	{
+		ConnectionList::iterator pConn;
+		for (pConn = m_ConnectionList->begin(); pConn != m_ConnectionList->end(); pConn++)
+		{
+			(*pConn)->ExitProcessing();
+			(*pConn)->DoDisconnect();
+			delete (*pConn);
+		}
+	}
+}
+void CServerManager::RegisterAllComms()
+{
+	TCDEBUGLOGS("CServerManager::RegisterAllComms\n");
+
+	m_CommList->clear();
+	if (m_ExeLocation && (m_ExeLocation[0] != '\0'))
+	{
+		char* searchPath = new char[MAX_EXEPATHNAME];
+		char* loadPath = new char[MAX_EXEPATHNAME];
+		strncpy(searchPath, m_ExeLocation, MAX_EXEPATHNAME);
+		sprintf(searchPath, "%s%c*", searchPath, PATH_DELIMITER);
+
+		TCDEBUGLOGA1("CServerManager::RegisterAllComms searchPath=%s\n", searchPath);
+		
+		WIN32_FIND_DATA fileData;
+
+		HANDLE sh = ::FindFirstFile(searchPath, &fileData);
+		if (sh != INVALID_HANDLE_VALUE)
+		{
+			BOOL done = FALSE;
+			while (!done)
+			{
+				TCDEBUGLOGA1("CServerManager::RegisterAllComms file=%s\n", fileData.cFileName);
+				if (strncmp(fileData.cFileName, COMMDLL_BASENAME, strlen(COMMDLL_BASENAME)) == 0)
+				{
+					sprintf(loadPath, "%s%c%s", m_ExeLocation, PATH_DELIMITER, fileData.cFileName);
+					TCDEBUGLOGA1("CServerManager::RegisterAllComms loadPath=%s\n", loadPath);
+
+					HINSTANCE hLib = ::LoadLibrary(loadPath);
+					TCDEBUGLOGA1("CServerManager::RegisterAllComms hLib=%x\n", hLib);
+
+					if (hLib)
+					{
+						TCDEBUGLOGS("CServerManager::RegisterAllComms - library loaded\n");
+
+						COMMREGISTER lpFn = (COMMREGISTER)::GetProcAddress(hLib, COMMREGISTER_FNNAME);
+						TCDEBUGLOGA1("CServerManager::RegisterAllComms lpFn=%x\n", lpFn);
+
+						if (lpFn)
+						{
+							TCDEBUGLOGS("CServerManager::RegisterAllComms - function found\n");
+							const char* pType = lpFn();
+							if (pType)
+							{
+								TCDEBUGLOGA1("CServerManager::RegisterAllComms pType=%s\n", pType);
+								CCommRegistryItem* pComm = new CCommRegistryItem();
+								strcpy(pComm->m_CommLibrary, loadPath);
+								strcpy(pComm->m_CommType, pType);
+								m_CommList->push_back(pComm);
+							}
+						}
+						::FreeLibrary(hLib);
+					}
+				}
+				BOOL fNext = ::FindNextFile(sh, &fileData);
+				if (fNext == FALSE)
+					done = TRUE;
+			}
+			::FindClose(sh);
+		}
+		delete[] searchPath;
+		delete[] loadPath;
+	}
+	TCDEBUGLOGS("CServerManager::RegisterAllComms\n");
+}
+
+void CServerManager::RegisterAllProtocols()
+{
+	TCDEBUGLOGS("CServerManager::RegisterAllProtocols\n");
+
+	m_ProtocolList->clear();
+	if (m_ExeLocation && (m_ExeLocation[0] != '\0'))
+	{
+		char* searchPath = new char[MAX_EXEPATHNAME];
+		char* loadPath = new char[MAX_EXEPATHNAME];
+		strncpy(searchPath, m_ExeLocation, MAX_EXEPATHNAME);
+		sprintf(searchPath, "%s%c*", searchPath, PATH_DELIMITER);
+
+		TCDEBUGLOGA1("CServerManager::RegisterAllProtocols searchPath=%s\n", searchPath);
+		
+		WIN32_FIND_DATA fileData;
+
+		HANDLE sh = ::FindFirstFile(searchPath, &fileData);
+		BOOL done = FALSE;
+
+		if (sh != INVALID_HANDLE_VALUE)
+		{
+			BOOL done = FALSE;
+			while (!done)
+			{
+				TCDEBUGLOGA1("CServerManager::RegisterAllProtocols file=%s\n", fileData.cFileName);
+				if (strncmp(fileData.cFileName, PROTOCOLDLL_BASENAME, strlen(PROTOCOLDLL_BASENAME)) == 0)
+				{
+					sprintf(loadPath, "%s%c%s", m_ExeLocation, PATH_DELIMITER, fileData.cFileName);
+					TCDEBUGLOGA1("CServerManager::RegisterAllProtocols loadPath=%s\n", loadPath);
+
+					HINSTANCE hLib = ::LoadLibrary(loadPath);
+					TCDEBUGLOGA1("CServerManager::RegisterAllProtocols hLib=%x\n", hLib);
+
+					if (hLib)
+					{
+						TCDEBUGLOGS("CServerManager::RegisterAllProtocols - library loaded\n");
+
+						PROTOCOLREGISTER lpFn = (PROTOCOLREGISTER)::GetProcAddress(hLib, PROTOCOLREGISTER_FNNAME);
+						TCDEBUGLOGA1("CServerManager::RegisterAllProtocols lpFn=%x\n", lpFn);
+
+						if (lpFn)
+						{
+							TCDEBUGLOGS("CServerManager::RegisterAllProtocols - function found\n");
+							const char* pType = lpFn();
+							if (pType)
+							{
+								TCDEBUGLOGA1("CServerManager::RegisterAllProtocols pType=%s\n", pType);
+								CProtocolRegistryItem* pProt = new CProtocolRegistryItem();
+								strcpy(pProt->m_ProtocolLibrary, loadPath);
+								strcpy(pProt->m_ProtocolType, pType);
+								m_ProtocolList->push_back(pProt);
+							}
+						}
+						::FreeLibrary(hLib);
+					}
+				}
+				BOOL fNext = ::FindNextFile(sh, &fileData);
+				if (fNext == FALSE)
+					done = TRUE;
+			}
+			::FindClose(sh);
+		}
+		delete[] searchPath;
+		delete[] loadPath;
+	}
+	TCDEBUGLOGS("CServerManager::RegisterAllProtocols\n");
+}
+
+void CServerManager::UnRegisterAllComms()
+{
+}
+
+void CServerManager::UnRegisterAllProtocols()
+{
+}
+
+const char* CServerManager::FindProtocolPath(char* protocolType)
+{
+	char* path = NULL;
+
+	TCDEBUGLOGS("CServerManager::FindProtocolPath\n");
+	if (m_ProtocolList->size() != 0)
+	{
+		ProtocolRegistry::iterator iter;
+		for (iter = m_ProtocolList->begin(); iter != m_ProtocolList->end(); iter++)
+		{
+			if (strcmp((*iter)->m_ProtocolType, protocolType) == 0)
+			{
+				path = (*iter)->m_ProtocolLibrary;
+				break;
+			}
+		}
+	}
+
+	TCDEBUGLOGA1("CServerManager::FindProtocolPath path=%s\n", path);
+	return path;
+}
+
+const char* CServerManager::FindCommPath(char* commType)
+{
+	char* path = NULL;
+
+	TCDEBUGLOGS("CServerManager::FindCommPath\n");
+	if (m_CommList->size() != 0)
+	{
+		CommRegistry::iterator iter;
+		for (iter = m_CommList->begin(); iter != m_CommList->end(); iter++)
+		{
+			if (strcmp((*iter)->m_CommType, commType) == 0)
+			{
+				path = (*iter)->m_CommLibrary;
+				break;
+			}
+		}
+	}
+
+	TCDEBUGLOGA1("CServerManager::FindCommPath path=%s\n", path);
+	return path;
+}
+