How to Build a Chat Server Based on an IOCP Framework

• Download source files - 30.9 KB

Introduction

This is my first article ever and all feedback is appreciated.

A while ago, I needed a server framework that used I/O completion ports and I did not find any solutions that fit my need. Those that I found were either too complex or not designed for reusability. Therefore I started to make my own, and this is the result. All classes are fully commented with doxygen comments.

The Framework

The server framework is basically just two classes, and those are described below.

DtServerSocket

DtServerSocket handles the listen socket, keeps track of all clients, contains the IO Completion function and a maintenance function.

class DtServerSocket
{
protected:
	SOCKET		m_sdListen;  	/// Socket used to listen
	DWORD		m_dwPort;	    /// Port that we listen on
	size_t		m_nClients;  	/// Number of loaded clients
	size_t		m_nMaxClients;	/// Maximum number of clients that we may have
	DWORD		m_dwServerFull;	/// When the server got full
	typedef vector< DtServerSocketClient* > CLIENTS;
	CLIENTS		m_paClients;

	DtCriticalSection m_cs;

public:
	DtServerSocket(void);
	~DtServerSocket(void);

	/// Load a client, the only thing you have to do is to derive this method
	/// @param pClient should return a pointer to a DtServerSocketClient derived class
	/// @param nId A id that identifies the client
	virtual void LoadClient(DtServerSocketClient** pClient, int& nId) = 0;

	/// @param dwListenPort The port that we should wait for connections on
	/// @param nClients Number of initial clients
	/// @param nMaxClients Total number of clients that the server could have
	/// @returns 0 if success or system error code
	DWORD StartServer(DWORD dwListenPort, int nClients, int nMaxClients);

	/// Stops the server.
	void StopServer(void);

	/// Checks how long the clients have been connected
	/// You should run this function in your main loop
	virtual void Maintenance();

	/// IoCompletion of the client threads calls this method
	static void CALLBACK DoneIO(DWORD dwErrorCode,
		DWORD dwNumberOfBytesTransferred,
		LPOVERLAPPED lpOverlapped);

	/// Override this one to give the server a name. Great for debugging purposes
	virtual const char* GetServerName() { return "A server"; };

	/// Override this one to get log printings
	virtual void OnWriteLog(int nPrio, int nClientId, const char* pszCategory,
                 const char* pszString) const {};
	void WriteLog(int nPrio, int nClientId, const char* pszCategory,
	             const char* pszString, ...) const;
};

We derive a class called CChatServerSocket from DtServerSocket and override two functions:

/// This function is used to load a new client that is derived from DtServerSocketClient
virtual void LoadClient(Datatal::DtServerSocketClient** pClient, int& nId);

/// Useful for diagnostics if we run different servers in the same .exe
const char* GetServerName() { return "ChatServer"; };

DtServerSocketClient

DtServerSocketClient contains all I/O functions for each client that have been accepted by DtServerSocket.

Sending Data

To handle output buffering, we have implemented a first-in/first-out linked list to enqueue all outgoing data:

/// Container for our outbuffers
struct Outbuffer
{
    char* pBuffer;
    DWORD dwSize;
    Outbuffer* pNext;
};
/// Linked list with all our outbuffers
struct OutbufferList
{
    Outbuffer* pFirst;
    Outbuffer* pLast;
    OutbufferList()
    {
        pFirst = NULL;
        pLast = NULL;
    }
    void Append(char* pBuffer, DWORD dwSize)
    {
        if (!pBuffer || !dwSize) throw std::invalid_argument
            ("pBuffer and nSize cannot be NULL");

        Outbuffer* pNewNode = new Outbuffer;
        pNewNode->pBuffer = pBuffer;
        pNewNode->pNext = NULL;
        pNewNode->dwSize = dwSize;

        if (pLast)
            pLast->pNext = pNewNode;
        else
            pFirst = pNewNode;

        pLast = pNewNode;
    }
    void RemoveFirst()
    {
        if (!pFirst) throw std::out_of_range("pFirst is NULL");
        Outbuffer* pOld = pFirst;
        pFirst = pFirst->pNext;
        if (pOld == pLast) pLast = NULL;
        delete[] pOld->pBuffer;
        delete pOld;
    }
};

When we send data, it is simply added to the list and a WriteOperation is invoked:

/// Enqueue stuff to our outgoing buffer
bool Datatal::DtServerSocketClient::Send(char* data, int nSize)
{
	//Lock outbuffer
	m_CritWrite.Lock();
	m_lOutBuffers.Append(data, (DWORD)nSize);
	m_CritWrite.Unlock();
	WriteLog(Datatal::LP_NORMAL, GetClientId(), "Send", 
                      "Appending new outbuffer, size: %d", nSize);

	//Trigger that we got a write operation
	WriteOperation();
	return true;
}

ChatServer

The chatserver class implementation:

DtServerSocket -> CChatServerSocket

DtServerSocketClient -> ChatProtocol -> CChatServerClient

Designing the Protocol

The first thing that we have to do is create a protocol that will be used to send data back and forth between client/server. The protocol is implemented as a struct (data container), an enum (function codes) and finally another enum for the status codes..

<STX><USHORT><DWORD><CHAR><databuffer><ETX>

Here is everything translated into code:

/// In this enum, we define the different transaction codes..
enum TRANS_CODES
{
  TC_LOGIN,            /// want to login
  TC_LIST_CHANNELS,    /// List all channels
  TC_LIST_USERS,       /// list all users / users on a specific channel
  TC_SEND_MESSAGE,     /// Set a message to a channel/user
  TC_SEND_MESSAGE_OUT  /// Outgoing message, (sent to client)
};

/// Status codes.
enum TRANS_STATUS
{
  TS_OK,        /// Everything went ok
  TS_NO_DATA,   /// Everything went ok, but we got no data
  TS_INVALID,   /// Invalid transaction
  TS_ERROR,     /// Something went wrong, presumably invalid data.
  TS_NO_ACCESS, /// The user do not have the required credentials
  TS_EXCEPTION  /// Something unexpected happened.
};

/// Packet Structure - The heart of the protocol.
struct Packet
{
  USHORT  nFunctionCode;      /// functioncode
  DWORD   dwDataSize;         /// size of the data stored in pData
  char    Status;             /// statuscode. 0 = ok;
  char*   pData;              /// Buffer
  DWORD   dwBufferSize;       /// maxsize of pData (allocated size)
  ~Packet()   { if (pData) delete[] pData;  };
  Packet()
  {
    pData = NULL;
    nFunctionCode = 0;
    dwDataSize = 0;
    dwBufferSize = 0;
    Status = 0;
  };
  Packet(int FunctionCode)
  {
    pData = NULL;
    nFunctionCode = FunctionCode;
    dwDataSize = 0;
    dwBufferSize = 0;
    Status = 0;
  };
};

Implementing CChatServer

We create a class called CChatServer, derive it from DtServerSocket, and implement the LoadClient function:

void CChatServerSocket::LoadClient(Datatal::DtServerSocketClient** pClient, 
                                   int nId)
{
  CChatServerClient* pNewClient = new CChatServerClient;
  if (pNewClient)
  {
    // You may call whatever you want to init the server client
  } 
  else
  {
    char szLog[128];
    sprintf(szLog, "Failed to load hvd client %d", nId);
    throw Datatal::DtServerException(-1, "LoadClient", szLog);

  }// if (pNewClient)

  *pClient = pNewClient;
}

Since we do not want to do any extra initial operations on the clients, we just create them and pass them back to the base class.

Next Thing is to Create a ChatProtocol, and a Class that Implements the Protocol

The ChatProtocol will be used both in the server and the client application. The Protocol struct and the enums are placed in this class along with some static functions that help us to pack the data buffer into the packet. ChatProtocol is derived from DtServerSocketClient and implement functions that translate our packets into plain char buffers and then passes/retrieve them to/from DtServerSocketClient.

Create ChatServerSocketClient Class and Implement the Logic in It

Normally, I handle all data using CMarkup, a nice XML class from http://www.firstobject.com/, but in this example, the data is separated with 0x04 and I use strtok to unpack everything. The class is derived from ChatProtocol and we will implement all logic in it.

Functions Implemented in the chatserver

• Users cannot do anything unless they have logged in.
• All users will continue to be logged in until the client connection is closed.
• While logged in, they can send messages to everyone or someone particular.
• Users can retrieve a list of all logged in users.

Summary

That's it! I will not describe the server any further, just take a look in the code. A fully functional client has been uploaded in a separate project.

References

The server framework is based on the IOCP example made by Ben Eleizer, although it's quite heavily modified. If you want more details about IOCP, read that article.

Another good article about IOCP by Microsoft can be found here.

The client can be found at this link.

History

• 2003-08-08: First version
• 2003-08-19: Article updated

License

This article has no explicit license attached to it, but may contain usage terms in the article text or the download files themselves. If in doubt, please contact the author via the discussion board below. A list of licenses authors might use can be found here.