diff -r c892c53c664e -r 9d2210c8eed2 connectivity/com.nokia.tcf/native/TCFNative/TCFClient/TCFCppApi.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/connectivity/com.nokia.tcf/native/TCFNative/TCFClient/TCFCppApi.cpp	Mon Apr 06 15:18:48 2009 -0500
@@ -0,0 +1,955 @@
+/*
+* 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: 
+*
+*/
+
+#include "stdafx.h"
+#include "TCFCppApi.h"
+#include "ServerClient.h"
+#include "ClientManager.h"
+#include "TCConstants.h"
+#include <vector>
+
+extern CClientManager* gManager;
+#ifdef _DEBUG
+extern BOOL gDoLogging;
+extern char TCDebugMsg[100];
+#define TCDEBUGOPEN() if (gDoLogging) { gManager->m_DebugLog->WaitForAccess(); }
+#define TCDEBUGLOGS(s) if (gDoLogging) { sprintf(TCDebugMsg,"%s", s); gManager->m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA1(s, a1) if (gDoLogging) { sprintf(TCDebugMsg, s, a1); gManager->m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA2(s, a1, a2) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2); gManager->m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGLOGA3(s, a1, a2, a3) if (gDoLogging) { sprintf(TCDebugMsg, s, a1, a2, a3); gManager->m_DebugLog->log(TCDebugMsg); }
+#define TCDEBUGCLOSE() if (gDoLogging) { gManager->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
+
+// for internal testing with 2.x USB TRK define this
+//#define FOR_2X_USB
+
+// client Ids connected for this C++ process
+static std::vector<long> *pcppClientIds = NULL;
+
+static long CheckClient(long id);
+static long CheckConnection(pTCFCppConnectData inConnection);
+static long CheckRealSerialSettings(pTCFCppConnectData inConnection);
+static long CheckMessageOptions(pTCFCppMessageOptions inMessageOptions);
+static long CheckMessageIds(pTCFCppMessageIds inMessageIds);
+static long CheckMessage(pTCFCppMessage inMessage);
+static void ConvertRealSerialSettingsToServer(pTCFCppConnectData inConnection, pRealSerialConnectData pData); 
+static void ConvertRealSerialSettingsToHost(pTCFCppConnectData inConnection, pRealSerialConnectData pData); 
+
+TCF_EXP long TCF_CALL TCFConnect(pTCFCppConnectData inConnection, pTCFCppMessageOptions inMessageOptions, pTCFCppMessageIds inMessageIds, long* outClientId)
+{
+	long ret = TCAPI_ERR_NONE;
+	ServerCommandData cmdrsp;
+	pServerCommandData pCmdrsp = &cmdrsp;
+
+	TCDEBUGOPEN();
+	TCDEBUGLOGS("TCFConnect\n");
+//	if (!gManager->IsServerRunning())
+//		return TCAPI_ERR_COMM_SERVER_RESPONSE_TIMEOUT;
+
+	gManager->m_Server->WaitforServerPipeAccess();
+
+	ret = CheckConnection(inConnection);
+#ifdef FOR_2X_USB
+	inMessageOptions->unWrapFormat = eTCFCppNone;
+#endif
+	if (ret == TCAPI_ERR_NONE)
+	{
+		ret = CheckMessageOptions(inMessageOptions);
+	}
+
+	if (ret == TCAPI_ERR_NONE)
+	{
+		ret = CheckMessageIds(inMessageIds);
+	}
+
+	if (ret == TCAPI_ERR_NONE)
+	{
+		if (strcmp(inConnection->connectType, "tcp") == 0)
+		{
+			char* pAddress = inConnection->tcpSettings.ipAddress;
+			char* pPort = inConnection->tcpSettings.ipPort;
+
+			pCmdrsp->command = eCmdConnect;
+			strncpy(pCmdrsp->connectSettings.connectType, inConnection->connectType, MAX_CONNECTION_TYPE);
+			strncpy(pCmdrsp->connectSettings.tcpSettings.ipAddress, pAddress, MAX_IPADDRESS_SIZE);
+			strncpy(pCmdrsp->connectSettings.tcpSettings.ipPort, pPort, MAX_PORT_SIZE);
+
+			pCmdrsp->connectSettings.retryInterval = inConnection->retryInterval;
+			pCmdrsp->connectSettings.retryTimeout = inConnection->retryTimeout;
+			strncpy(pCmdrsp->connectSettings.decodeFormat, inConnection->decodeFormat, MAX_DECODE_FORMAT);
+			pCmdrsp->clientOptions.unWrapFormat = inMessageOptions->unWrapFormat;
+			pCmdrsp->clientOptions.ostVersion = inMessageOptions->ostVersion;
+		}
+		else if (strcmp(inConnection->connectType, "virtualserial") == 0)
+		{
+			char* pComPort = inConnection->virtualSerialSettings.comPort;
+
+			pCmdrsp->command = eCmdConnect;
+			strncpy(pCmdrsp->connectSettings.connectType, inConnection->connectType, MAX_CONNECTION_TYPE);
+			strncpy(pCmdrsp->connectSettings.virtualSerialSettings.comPort, pComPort, MAX_COMPORT_SIZE);
+
+			pCmdrsp->connectSettings.retryInterval = inConnection->retryInterval;
+			pCmdrsp->connectSettings.retryTimeout = inConnection->retryTimeout;
+			strncpy(pCmdrsp->connectSettings.decodeFormat, inConnection->decodeFormat, MAX_DECODE_FORMAT);
+			pCmdrsp->clientOptions.unWrapFormat = inMessageOptions->unWrapFormat;
+			pCmdrsp->clientOptions.ostVersion = inMessageOptions->ostVersion;
+		}
+		else if (strcmp(inConnection->connectType, "serial") == 0)
+		{
+			char* pComPort = inConnection->realSerialSettings.comPort;
+
+			pCmdrsp->command = eCmdConnect;
+			strncpy(pCmdrsp->connectSettings.connectType, inConnection->connectType, MAX_CONNECTION_TYPE);
+			strncpy(pCmdrsp->connectSettings.realSerialSettings.comPort, pComPort, MAX_COMPORT_SIZE);
+
+			ConvertRealSerialSettingsToServer(inConnection, &pCmdrsp->connectSettings.realSerialSettings);
+
+			pCmdrsp->connectSettings.retryInterval = inConnection->retryInterval;
+			pCmdrsp->connectSettings.retryTimeout = inConnection->retryTimeout;
+			strncpy(pCmdrsp->connectSettings.decodeFormat, inConnection->decodeFormat, MAX_DECODE_FORMAT);
+			pCmdrsp->clientOptions.unWrapFormat = inMessageOptions->unWrapFormat;
+			pCmdrsp->clientOptions.ostVersion = inMessageOptions->ostVersion;
+		}
+		else
+		{
+			// Add other connections here
+		}
+		// send connect command
+		long id = 0;
+
+		if (ret == TCAPI_ERR_NONE)
+		{
+			gManager->m_Server->SendCommand(pCmdrsp);
+			gManager->m_Server->GetResponse(pCmdrsp);
+			if (pCmdrsp->response == eRspError)
+			{
+				ret = pCmdrsp->error;
+				TCDEBUGLOGA1("TCFConnect eCmdConnect: ret = %d\n", ret);
+			}
+			else
+			{
+				id = pCmdrsp->clientId;
+				TCDEBUGLOGA1("TCFConnect eCmdConnect: id = %d\n", id);
+			}
+		}
+		
+		// send message Ids to capture
+		if (ret == TCAPI_ERR_NONE)
+		{
+			pCmdrsp->command = eCmdSetMessageIds;
+			pCmdrsp->clientId = id;
+			pCmdrsp->number = inMessageIds->numberIds;
+			for (int i = 0; i < inMessageIds->numberIds; i++)
+			{
+				pCmdrsp->messageIds[i] = inMessageIds->messageIds[i];
+			}
+
+			gManager->m_Server->SendCommand(pCmdrsp);
+			gManager->m_Server->GetResponse(pCmdrsp);
+			if (pCmdrsp->response == eRspError)
+			{
+				ret = pCmdrsp->error;
+				TCDEBUGLOGA1("TCFConnect eCmdSetMessageIds: ret = %d\n", ret);
+			}
+			else
+			{
+				TCDEBUGLOGA1("TCFConnect eCmdSetMessageIds: ret = %d\n", ret);
+			}
+		}
+
+		// create input stream overflow temp file
+		// create input stream
+		if (ret == TCAPI_ERR_NONE)
+		{
+//			eTCPCppStreamOverflowOption overflowOption = inMessageOptions->streamOverflowOption;
+//			char* pFileName = inMessageOptions->overflowFile;
+			long streamSize = inMessageOptions->inputStreamSize;
+			CInputStream* stream = new CInputStream(NULL, streamSize, eTCPCppStreamOverflowOff, id);
+			stream->CreateStream();
+			gManager->AddInputStream(stream);
+
+			pCmdrsp->command = eCmdOpenStream;
+			pCmdrsp->clientId = id;
+			// TODO: implement message file in the future?
+			pCmdrsp->destinationOptions.destination = eDestinationInputStream;
+			pCmdrsp->destinationOptions.streamSize = streamSize;
+			pCmdrsp->destinationOptions.overFlowToFile = FALSE;//(overflowOption == eTCPCppStreamOverflowOn);
+//			if (pFileName != NULL)
+//			{
+//				strncpy(pCmdrsp->destinationOptions.destinationFile, pFileName, MAX_INPUTSTREAMPATH);
+//			}
+//			else
+			{
+				pCmdrsp->destinationOptions.destinationFile[0] = NULL;
+			}
+			gManager->m_Server->SendCommand(pCmdrsp);
+			gManager->m_Server->GetResponse(pCmdrsp);
+
+			if (pCmdrsp->response == eRspError)
+			{
+				ret = pCmdrsp->error;
+				TCDEBUGLOGA1("TCFConnect eCmdOpenStream: ret = %d\n", ret);
+			}
+			else
+			{
+				TCDEBUGLOGA1("TCFConnect eCmdOpenStream: ret = %d\n", ret);
+			}
+		}
+
+		// create error monitor
+		if (ret == TCAPI_ERR_NONE)
+		{
+			CErrorMonitor* monitor = new CErrorMonitor(id);
+			if (monitor != NULL)
+			{
+				monitor->CreateData();
+				gManager->AddErrorMonitor(monitor);
+			}
+		}
+
+		// start client capture
+		if (ret == TCAPI_ERR_NONE)
+		{
+			pCmdrsp->command = eCmdStart;
+			pCmdrsp->clientId = id;
+			gManager->m_Server->SendCommand(pCmdrsp);
+			gManager->m_Server->GetResponse(pCmdrsp);
+
+			if (pCmdrsp->response == eRspError)
+			{
+				ret = pCmdrsp->error;
+				TCDEBUGLOGA1("TCFConnect eCmdStart: ret = %d\n", ret);
+			}
+			else
+			{
+				TCDEBUGLOGA1("TCFConnect eCmdStart: ret = %d\n", ret);
+			}
+		}
+
+		if (ret == TCAPI_ERR_NONE)
+		{
+			TCDEBUGLOGA1("TCFConnect pcppClientIds: %x\n", pcppClientIds); 
+			if (pcppClientIds == NULL)
+			{
+				pcppClientIds = new std::vector<long>;
+				pcppClientIds->empty();
+			}
+			pcppClientIds->push_back(id);
+			*outClientId = id;
+			TCDEBUGLOGA1("TCFConnect pcppClientIds: size = %d\n", pcppClientIds->size());
+		}
+	}
+
+	gManager->m_Server->ReleaseServerPipeAccess();
+	TCDEBUGLOGA1("TCFConnect return ret=%d\n", ret);
+	TCDEBUGCLOSE();
+	return ret;
+}
+
+
+TCF_EXP long TCF_CALL TCFDisconnect(long inClientId)
+{
+	long ret = TCAPI_ERR_NONE;
+	ServerCommandData cmdrsp;
+	pServerCommandData pCmdrsp = &cmdrsp;
+
+	TCDEBUGOPEN();
+	TCDEBUGLOGA1("TCFDisconnect id=%d\n", inClientId);
+
+	gManager->m_Server->WaitforServerPipeAccess();
+	gManager->WaitForErrorMonitorListAccess();
+	gManager->WaitForStreamListAccess();
+
+	// check client ID
+	ret = CheckClient(inClientId);
+	TCDEBUGLOGA1("TCFDisconnect CheckClient: ret = %d\n", ret);
+	
+	// stop client
+	if (ret == TCAPI_ERR_NONE)
+	{
+		pCmdrsp->clientId = inClientId;
+		pCmdrsp->command = eCmdStop;
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+	}
+
+	// close error monitor
+	TCDEBUGLOGS("TCFDisconnect clear error monitor\n");
+	CErrorMonitor *monitor = gManager->FindErrorMonitor(inClientId);
+	if (monitor != NULL)
+	{
+		gManager->RemoveErrorMonitor(monitor);
+		delete monitor;
+	}
+
+	// close input stream
+	TCDEBUGLOGS("TCFDisconnect remove input stream\n");
+	CInputStream* inputStream = gManager->FindInputStream(inClientId);
+	if (inputStream != NULL)
+	{
+		gManager->RemoveInputStream(inputStream);
+		delete inputStream;
+	}
+
+	// send disconnect
+	TCDEBUGLOGS("TCFDisconnect send disconnect\n");
+	if (ret == TCAPI_ERR_NONE)
+	{
+		pCmdrsp->command = eCmdDisconnect;
+		pCmdrsp->clientId = inClientId;
+
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+		if (pCmdrsp->response == eRspError)
+		{
+			ret = pCmdrsp->error;
+		}
+	}
+	
+	TCDEBUGLOGS("TCFDisconnect clear erase id\n");
+	if (pcppClientIds != NULL && ret == TCAPI_ERR_NONE)
+	{
+		std::vector<long>::iterator idIter;
+		for (idIter = pcppClientIds->begin(); idIter != pcppClientIds->end(); idIter++)
+		{
+			if (*idIter == inClientId)
+			{
+				pcppClientIds->erase(idIter);
+				break;
+			}
+		}
+		if (pcppClientIds->size() == 0)
+		{
+			pcppClientIds->empty();
+			delete pcppClientIds;
+			pcppClientIds = NULL;
+		}
+	}
+
+	gManager->ReleaseStreamListAccess();
+	gManager->ReleaseErrorMonitorListAccess();
+
+	TCDEBUGLOGS("TCFDisconnect stop server\n");
+	gManager->m_Server->ReleaseServerPipeAccess();
+
+	TCDEBUGLOGA1("TCFDisconnect return ret=%d\n", ret);
+	TCDEBUGCLOSE();
+	return ret;
+}
+
+TCF_EXP long TCF_CALL TCFGetVersions(long inClientId, long& outNumberVersions, char** outVersions)
+{
+	long ret = TCAPI_ERR_FEATURE_NOT_IMPLEMENTED;
+	outNumberVersions = 0;
+
+	// check client ID
+
+	// get # versions from server
+
+	// get version[i] from server
+
+
+	return ret;
+}
+TCF_EXP long TCF_CALL TCFGetConnections(long& outNumberConnections, pTCFCppConnectData* outConnections)
+{
+	long ret = TCAPI_ERR_FEATURE_NOT_IMPLEMENTED;
+
+	outNumberConnections = 0;
+
+	return ret;
+}
+TCF_EXP long TCF_CALL TCFSendMessage(long inClientId, pTCFCppMessage inMessage, long inLength, BYTE* inData)
+{
+	long ret = TCAPI_ERR_NONE;
+	ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;
+
+#ifdef FOR_2X_USB
+	inMessage->useMyId = FALSE;
+#endif
+
+	TCDEBUGOPEN();
+	TCDEBUGLOGA1("TCFSendMessage id=%d\n", inClientId);
+
+	// check client ID
+	ret = CheckClient(inClientId);
+	TCDEBUGLOGA1("TCFSendMessage CheckClient: ret=%d\n", ret);
+
+	gManager->m_Server->WaitforServerPipeAccess();
+	// send message to server
+	if (ret == TCAPI_ERR_NONE)
+	{
+		ret = CheckMessage(inMessage);
+		if (ret == TCAPI_ERR_NONE)
+		{
+			pCmdrsp->command = eCmdSendMessage;
+			pCmdrsp->clientId = inClientId;
+			pCmdrsp->encodeOption = (inMessage->encodeFormat == eTCFCppEncodeNone) ? ENCODE_NO_FORMAT : ENCODE_FORMAT;
+			pCmdrsp->useMyId = inMessage->useMyId;
+			pCmdrsp->protocolVersion = inMessage->ostVersion;
+			pCmdrsp->myId = inMessage->myId;
+
+			gManager->m_Server->SendCommand(pCmdrsp, inLength, inData);
+			gManager->m_Server->GetResponse(pCmdrsp);
+
+			if (pCmdrsp->response == eRspError)
+			{
+				ret = pCmdrsp->error;
+				TCDEBUGLOGA1("TCFSendMessage eCmdSendMessage: ret=%d\n", ret);
+			}
+		}
+	}
+
+	gManager->m_Server->ReleaseServerPipeAccess();
+
+	TCDEBUGLOGA1("TCFSendMessage return ret=%d\n", ret);
+	TCDEBUGCLOSE();
+	return ret;
+}
+TCF_EXP long TCF_CALL TCFStart(long inClientId)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	// check client Id
+	ret = CheckClient(inClientId);
+	if (ret == TCAPI_ERR_NONE)
+	{
+		gManager->m_Server->WaitforServerPipeAccess();
+
+		ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;
+
+		pCmdrsp->command = eCmdStart;
+		pCmdrsp->clientId = inClientId;
+
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+
+		if (pCmdrsp->response == eRspError)
+		{
+			ret = pCmdrsp->error;
+		}
+		gManager->m_Server->ReleaseServerPipeAccess();
+
+	}
+
+	return ret;
+}
+
+TCF_EXP long TCF_CALL TCFStop(long inClientId)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	// check client Id
+	ret = CheckClient(inClientId);
+	if (ret == TCAPI_ERR_NONE)
+	{
+		gManager->m_Server->WaitforServerPipeAccess();
+
+		ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;
+
+		pCmdrsp->command = eCmdStop;
+		pCmdrsp->clientId = inClientId;
+
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+
+		if (pCmdrsp->response == eRspError)
+		{
+			ret = pCmdrsp->error;
+		}
+		gManager->m_Server->ReleaseServerPipeAccess();
+
+	}
+
+	return ret;
+}
+
+TCF_EXP long TCF_CALL TCFSetMessageIds(long inClientId, pTCFCppMessageIds inMessageIds)
+{
+	long ret = TCAPI_ERR_NONE;
+	ServerCommandData cmdrsp; pServerCommandData pCmdrsp = &cmdrsp;
+
+	// check client Id
+	ret = CheckClient(inClientId);
+
+	// check message ids
+	if (ret == TCAPI_ERR_NONE)
+	{
+		ret = CheckMessageIds(inMessageIds);
+	}
+
+	gManager->m_Server->WaitforServerPipeAccess();
+	// check client status
+	if (ret == TCAPI_ERR_NONE)
+	{
+		pCmdrsp->command = eCmdGetClientStatus;
+		pCmdrsp->clientId = inClientId;
+
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+
+		if (pCmdrsp->response == eRspError)
+		{
+			ret = pCmdrsp->error;
+		}
+		else
+		{
+			if (pCmdrsp->clientStatus == eStarted)
+			{
+				ret = TCAPI_ERR_ROUTING_IN_PROGRESS;
+			}
+			else if (pCmdrsp->clientStatus == eUnknownClient)
+			{
+				ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+			}
+		}
+	}
+
+	// set message ids
+	if (ret == TCAPI_ERR_NONE)
+	{
+		pCmdrsp->command = eCmdSetMessageIds;
+		pCmdrsp->clientId = inClientId;
+		pCmdrsp->number = inMessageIds->numberIds;
+		for (int i = 0; i < inMessageIds->numberIds; i++)
+		{
+			pCmdrsp->messageIds[i] = inMessageIds->messageIds[i];
+		}
+		gManager->m_Server->SendCommand(pCmdrsp);
+		gManager->m_Server->GetResponse(pCmdrsp);
+
+		if (pCmdrsp->response == eRspError)
+		{
+			ret = pCmdrsp->error;
+		}
+
+	}
+	gManager->m_Server->ReleaseServerPipeAccess();
+
+	return ret;
+}
+
+TCF_EXP long TCF_CALL TCFPollInputStream(long inClientId, long& outLength)
+{
+	long ret = TCAPI_ERR_NONE;
+	outLength = 0;
+
+	TCDEBUGOPEN();
+	TCDEBUGLOGA1("TCFPollInputStream id=%d\n", inClientId);
+
+	gManager->WaitForStreamListAccess();
+
+	// check client ID
+	ret = CheckClient(inClientId);
+	if (ret == TCAPI_ERR_NONE)
+	{
+		// get client's input stream
+		CInputStream* inputStream = gManager->FindInputStream(inClientId);
+
+		if (inputStream != NULL)
+		{
+			outLength = inputStream->GetNextMessageSize();
+		}
+		else
+		{
+			ret = TCAPI_ERR_INPUTSTREAM_CLOSED;
+		}
+	}
+
+	gManager->ReleaseStreamListAccess();
+
+	TCDEBUGLOGA2("TCFPollInputStream return ret=%d outLength=%d\n", ret, outLength);
+	TCDEBUGCLOSE();
+	return ret;
+}
+TCF_EXP long TCF_CALL TCFReadInputStream(long inClientId, pTCFCppMessage outMessage, long& inLength, BYTE* outData)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (outData == NULL || inLength <= 0)
+		return ret;
+
+	gManager->WaitForStreamListAccess();
+
+	// check client ID
+	ret = CheckClient(inClientId);
+	if (ret == TCAPI_ERR_NONE)
+	{
+		// get client's input stream
+		CInputStream* inputStream = gManager->FindInputStream(inClientId);
+
+		if (inputStream != NULL)
+		{
+			DWORD length = inputStream->GetNextMessageSize();
+			if (length > inLength) length = inLength;
+			if (length > 0)
+			{
+				inLength = length;
+				inputStream->GetNextMessage(inLength, outData);
+
+			}
+			else
+			{
+				inLength = 0;
+			}
+		}
+		else
+		{
+			ret = TCAPI_ERR_INPUTSTREAM_CLOSED;
+		}
+	}
+
+	gManager->ReleaseStreamListAccess();
+
+	return ret;
+}
+TCF_EXP BOOL TCF_CALL TCFPollError(long inClientId, int* outErrorCode, BOOL* outHasOSErrorCode, long* outOSErrorCode)
+{
+	BOOL foundError = FALSE;
+	gManager->WaitForErrorMonitorListAccess();
+
+	if (gManager->ErrorMonitorListSize() > 0)
+	{
+		CErrorMonitor* errorMonitor = gManager->FindErrorMonitor(inClientId);
+		if (errorMonitor != NULL)
+		{
+			LONG tcfError = TCAPI_ERR_NONE;
+			BOOL osErrorUsed = FALSE;
+			DWORD osError = 0;
+			BOOL found = errorMonitor->GetError(&tcfError, &osErrorUsed, &osError);
+			if (found)
+			{
+				foundError = true;
+				*outErrorCode = (int)tcfError;
+				*outHasOSErrorCode = osErrorUsed;
+				*outOSErrorCode = osError;
+			}
+		}
+	}
+	gManager->ReleaseErrorMonitorListAccess();
+
+	return foundError;
+}
+
+long CheckClient(long id)
+{
+	long ret = TCAPI_ERR_NONE;
+	BOOL found = FALSE;
+
+	if (id <= 0)
+	{
+		ret = TCAPI_ERR_INVALID_HANDLE;
+	}
+	else if (gManager->IsServerRunning() == FALSE)
+	{
+		ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+	}
+	else
+	{
+		if (pcppClientIds == NULL)
+		{
+			ret = TCAPI_ERR_MEDIA_NOT_OPEN;
+		}
+		else
+		{
+			std::vector<long>::iterator idIter;
+			for (idIter = pcppClientIds->begin(); idIter != pcppClientIds->end(); idIter++)
+			{
+				if (*idIter == id)
+				{
+					found = TRUE;
+					break;
+				}
+			}
+			if (!found)
+			{
+				ret = TCAPI_ERR_INVALID_HANDLE;
+			}
+		}
+	}
+
+	return ret;
+}
+long CheckConnection(pTCFCppConnectData inConnection)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (inConnection == NULL)
+	{
+		ret = TCAPI_ERR_MISSING_CONNECTION_SPEC;
+	} 
+	else
+	{
+		long retryI = inConnection->retryInterval;
+		long retryT = inConnection->retryTimeout;
+		if (retryI == 0 || retryT == 0 || retryI > retryT)
+			ret = TCAPI_ERR_INVALID_RETRY_PERIODS;
+	}
+	if (ret == TCAPI_ERR_NONE)
+	{
+		if (strcmp(inConnection->connectType, "tcp") == 0)
+		{
+			if (inConnection->tcpSettings.ipAddress == NULL)
+			{
+				ret = TCAPI_ERR_MISSING_MEDIA_DATA;
+			}
+			else if (inConnection->tcpSettings.ipPort == NULL)
+			{
+				ret = TCAPI_ERR_MISSING_MEDIA_DATA;
+			}
+		}
+		else if (strcmp(inConnection->connectType, "virtualserial") == 0)
+		{
+			if (inConnection->virtualSerialSettings.comPort == NULL)
+			{
+				ret = TCAPI_ERR_MISSING_MEDIA_DATA;
+			}
+		}
+		else if (strcmp(inConnection->connectType, "serial") == 0)
+		{
+			ret = CheckRealSerialSettings(inConnection);
+		}
+		else
+		{
+		}
+	}
+
+	return ret;
+}
+
+long CheckRealSerialSettings(pTCFCppConnectData inConnection)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (inConnection->realSerialSettings.comPort == NULL)
+	{
+		ret = TCAPI_ERR_MISSING_MEDIA_DATA;
+	}
+	else if (inConnection->realSerialSettings.dataBits < 4 || inConnection->realSerialSettings.dataBits > 8)
+	{
+		ret = TCAPI_ERR_COMM_INVALID_DATABITS;
+	}
+	else if (inConnection->realSerialSettings.baudRate < 110UL || inConnection->realSerialSettings.baudRate > 256000UL)
+	{
+		ret = TCAPI_ERR_MISSING_MEDIA_DATA;
+	}
+	else
+	{
+		switch(inConnection->realSerialSettings.stopBits)
+		{
+		case eTCFCppStopBits1:
+		case eTCFCppStopBits15:
+		case eTCFCppStopBits2:
+			break;
+		default:
+			ret = TCAPI_ERR_COMM_INVALID_STOPBITS;
+			break;
+		}
+
+	}
+	if (ret == TCAPI_ERR_NONE)
+	{
+		switch(inConnection->realSerialSettings.flowControl)
+		{
+		case eTCFCppFlowControlNone:
+		case eTCFCppFlowControlHW:
+		case eTCFCppFlowControlSW:
+			break;
+		default:
+			ret = TCAPI_ERR_COMM_INVALID_FLOWCONTROL;
+			break;
+		}
+	}
+	if (ret == TCAPI_ERR_NONE)
+	{
+		switch(inConnection->realSerialSettings.parity)
+		{
+		case eTCFCppParityNone:
+		case eTCFCppParityOdd:
+		case eTCFCppParityEven:
+			break;
+		default:
+			ret = TCAPI_ERR_COMM_INVALID_PARITY;
+			break;
+ 		}
+	}
+	
+	return ret;
+}
+long CheckMessageOptions(pTCFCppMessageOptions inMessageOptions)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (inMessageOptions == NULL)
+	{
+		ret = TCAPI_ERR_MISSING_MESSAGE_OPTIONS;
+	}
+	else
+	{
+		if (ret == TCAPI_ERR_NONE)
+		{
+			if (inMessageOptions->unWrapFormat != eTCFCppNone && 
+				inMessageOptions->unWrapFormat != eTCFCppDeleteHeader)
+			{
+				ret = TCAPI_ERR_INVALID_MESSAGE_UNWRAP_OPTION;
+			}
+		}
+		if (ret == TCAPI_ERR_NONE)
+		{
+			if (inMessageOptions->inputStreamSize <= 0) 
+			{
+				ret = TCAPI_ERR_INVALID_STREAM_BUFFER_SIZE;
+			}
+		}
+	}
+	return ret;
+}
+long CheckMessageIds(pTCFCppMessageIds inMessageIds)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (inMessageIds == NULL)
+	{
+		ret = TCAPI_ERR_NO_MESSAGESIDS_REGISTERED;
+	}
+	else if (inMessageIds->numberIds <= 0 || inMessageIds->messageIds == NULL)
+	{
+		ret = TCAPI_ERR_NO_MESSAGESIDS_REGISTERED;
+	}
+	else if (inMessageIds->numberIds > 256)
+	{
+		ret = TCAPI_ERR_MESSAGEID_MAXIMUM;
+	}
+
+	return ret;
+}
+long CheckMessage(pTCFCppMessage inMessage)
+{
+	long ret = TCAPI_ERR_NONE;
+
+	if (inMessage == NULL)
+		return TCAPI_ERR_MISSING_MESSAGE;
+
+	if (inMessage->useMyId)
+	{
+		if ((inMessage->encodeFormat != eTCFCppEncodeNone) && (inMessage->encodeFormat != eTCFCppEncode))
+		{
+			ret = TCAPI_ERR_INVALID_ENCODE_FORMAT;
+		}
+	}
+
+	return ret;
+}
+
+void ConvertRealSerialSettingsToServer(pTCFCppConnectData inConnection, pRealSerialConnectData pData)
+{
+	pData->baudRate = inConnection->realSerialSettings.baudRate;
+	pData->dataBits = inConnection->realSerialSettings.dataBits;
+	switch(inConnection->realSerialSettings.flowControl)
+	{
+	default:
+	case eTCFCppFlowControlNone:
+		pData->flowControl = eFlowControlNone;
+		break;
+	case eTCFCppFlowControlHW:
+		pData->flowControl = eFlowControlHW;
+		break;
+	case eTCFCppFlowControlSW:
+		pData->flowControl = eFlowControlSW;
+		break;
+	}
+	switch(inConnection->realSerialSettings.parity)
+	{
+	default:
+	case eTCFCppParityNone:
+		pData->parity = eParityNone;
+		break;
+	case eTCFCppParityOdd:
+		pData->parity = eParityOdd;
+		break;
+	case eTCFCppParityEven:
+		pData->parity = eParityEven;
+		break;
+	}
+	switch(inConnection->realSerialSettings.stopBits)
+	{
+	default:
+	case eTCFCppStopBits1:
+		pData->stopBits = eStopBits1;
+		break;
+	case eTCFCppStopBits15:
+		pData->stopBits = eStopBits15;
+		break;
+	case eTCFCppStopBits2:
+		pData->stopBits = eStopBits2;
+		break;
+	}
+}
+
+void ConvertRealSerialSettingsToHost(pTCFCppConnectData inConnection, pRealSerialConnectData pData)
+{
+	inConnection->realSerialSettings.baudRate = pData->baudRate;
+	inConnection->realSerialSettings.dataBits = pData->dataBits;
+	switch(pData->flowControl)
+	{
+	default:
+	case eFlowControlNone:
+		inConnection->realSerialSettings.flowControl = eTCFCppFlowControlNone;
+		break;
+	case eFlowControlHW:
+		inConnection->realSerialSettings.flowControl = eTCFCppFlowControlHW;
+		break;
+	case eFlowControlSW:
+		inConnection->realSerialSettings.flowControl = eTCFCppFlowControlSW;
+		break;
+	}
+
+	switch(pData->parity)
+	{
+	default:
+	case eParityNone:
+		inConnection->realSerialSettings.parity = eTCFCppParityNone;
+		break;
+	case eParityEven:
+		inConnection->realSerialSettings.parity = eTCFCppParityEven;
+		break;
+	case eParityOdd:
+		inConnection->realSerialSettings.parity = eTCFCppParityOdd;
+		break;
+	}
+
+	switch(pData->stopBits)
+	{
+	default:
+	case eStopBits1:
+		inConnection->realSerialSettings.stopBits = eTCFCppStopBits1;
+		break;
+	case eStopBits15:
+		inConnection->realSerialSettings.stopBits = eTCFCppStopBits15;
+		break;
+	case eStopBits2:
+		inConnection->realSerialSettings.stopBits = eTCFCppStopBits2;
+		break;
+	}
+}