Asynchronous full-duplex connection class

CInOutConnection is a class that encapsulates Client/Server connection node. It works in asynchronous full-duplex mode. After initialization it creates four threads: receiving, sending, working and service threads. First two are obvious, working thread waits for a message to be posted into input queue and then processes it and service thread could break connection on inactivity timeout or could be used for performing idle periodic tasks.

For keeping input and output queues in multithreaded environment I created CMessageQueue, which is simply wrapper under class from STL. The main difference is that before inserting or removing messages from the queue one should call CMessageQueue::BlockQueue() and then CMessageQueue::UnBlockQueue() in order to get exclusive access to the queue. For single message it could be done via CMessageQueue::GetFirstMessage() or CMessageQueue::AddSingleMessage() functions. To determine if there are messages in the queue one should call CMessageQueue::IsQueueFull().

Class termination.

To initiate connection termination, function CInOutConnection::SetTerminate() should be called. To check if its time to terminate, application could call CInOutConnection::Terminate() function.

Message exchange.

To be independent of network providers class exposes two virtual functions: cioReceiveMessage(int* Error, int* length) and cioSendMessage(void* msg, int msg_size). They need to be overwritten in derived class for work with specific network providers. Depending on result of these functions network connection could be considered as broken and shutdown could be initiated.

After message was successfully received it will be stick into input queue. Working thread, that checks for messages in input queue will be triggered automatically and will extract message from queue for processing. Currently there are three ways of message processing:

1. Application can register callback function within the class and this function will be called for every incoming message. Callback function is defined like this: typedef void (InOutCallbackFunc)(void* param), where param is pointer to this of the CInOutConnection class.

2. Application can register callback window within the class. In case of message arrival WN_COMMAND message will be sent to window. LParam in this case will be set to CInOutConnection::this and WParam will point to user-registered message Id.

3. If there is no callback function and callback window registered, CInOutConnection::ProcessCurrentMessage(void* msg, DWORD length) will be called. Application can overwrite this function or CInOutConnection::ProcessMessage() to gain specific functionality for message processing.

Message exchange protocol.

CinOutConnection class provides basic functionality for message exchange protocol support. On receiving stage several functions are called to ensure, that incoming message is not garbage and has some useful information:).

They are:

		virtual int GetHeaderLength();
		virtual BOOL IsCorrectHeader(char* header);
		virtual int GetMessageSizeFromHeader(char* header);

Message receiving works as follows:

Receive function calls GetHeaderLength() first to know the length of the initial packet of data (header). Then it passes received header to IsCorrectHeader() and GetMessageSizeFromHeader() respectively to find out, if message is valid one and to find out the size of the actual message. Then it tries to receive message of the length, returned by GetMessageSizeFromHeader() function.

Function PrepareMessageToSend(void* msg, DWORD length, DWORD& len) is used for preparation on message to be sent. It can add header to the message, convert it to uuencode format or perfom any action, needed by application.

Thread behavior could be controlled by overriding InitXXXThread(), XXXThreadTerminated(), OnXXXThreadError() and OnXXXThreadIdle() functions.

CInOutConnection::OnServiceTimer() could be used to perform background periodical tasks. It is called every second from Service Thread. (Be aware of using shared resources!).

CTcpIpConnection class.

CtcpIpConnection is class derived from CinOutConnection, modified to work with Win32 TCP/IP networking. You need couple of connected sockets (one for receiving and one for transmission) to initialize class. CioReceiveMessage and cioSendMessage adjusted to work properly with sockets, as well as ResetConnection() and SetTerminate() functions.

Node creation from application point of view:

To create connected node, following tasks should be performed:

1. Derive class from CinOutConnection to implement specific network provider functionality and message transmission format. (You can use CtcpIpConnection for TCP/IP Windows sockets).

2. Initialize connection. (for CtcpIpConnection: Get couple of connected sockets and call InitConnection function)

3. !!! Thread, that initialized CinOutConnection creation, must wait for it to finish on threads exit. In other words this thread MUST call WaitForTermination() class function on its exit.

Download source

Article updated on June 21 1998
Article moved from Internet section on January 26 1999