Simple protocol for data exchange between client and server

Question

I am looking for a way to implement a protocol in TCP to send and receive simple string messages. I have a client and server application, and when both start for the first time, I press the connect button on the client to connect to the server. A message appears in the list of servers that the client is connected, and some text appears in the list of clients saying that it is connected to the server.

This part works fine, but now I want to be able to send other lines to the server and depending on which line I send will force the server to perform a certain operation, how can I do this? The first idea that comes to mind is to use if-then instructions. I will send my code below:

Server:

private static int port = 8080; private static TcpListener listener; private static Thread thread; private void Form1_Load(object sender, EventArgs e) { listener = new TcpListener(new IPAddress(new byte[] { 10, 1, 6, 130 }), port); thread = new Thread(new ThreadStart(Listen)); thread.Start(); } private void Listen() { listener.Start(); listBox1.Invoke(new EventHandler(delegate { listBox1.Items.Add("Listening on: " + port.ToString()); })); while (true) { listBox1.Invoke(new EventHandler(delegate { listBox1.Items.Add("Waiting for connection...."); })); TcpClient client = listener.AcceptTcpClient(); Thread listenThread = new Thread(new ParameterizedThreadStart(ListenThread)); listenThread.Start(client); } } //client thread private void ListenThread(Object client) { NetworkStream netstream = ((TcpClient)client).GetStream(); listBox1.Invoke(new EventHandler(delegate { listBox1.Items.Add("Request made"); })); byte[] resMessage = Encoding.ASCII.GetBytes("Connected to Server"); netstream.Write(resMessage, 0, resMessage.Length); netstream.Flush(); } 

Customer:

  TcpClient tcpclnt; private void buttonConnect_Click(object sender, EventArgs e) { try { tcpclnt = new TcpClient(); userEventBox.Items.Add("Connecting....."); try { tcpclnt.Connect("10.1.6.130", 8080); } catch (Exception ex) { MessageBox.Show(ex.ToString()); return; } Stream stm = tcpclnt.GetStream(); byte[] bb = new byte[100]; int k = stm.Read(bb, 0, 100); string returndata = System.Text.Encoding.ASCII.GetString(bb); userEventBox.Items.Add(returndata); tabControl1.Enabled = true; //need a way for the server see this string string populateList = "Test"; ASCIIEncoding asen = new ASCIIEncoding(); byte[] ba = asen.GetBytes(populateList); stm.Write(ba, 0, ba.Length); } catch (Exception ex) { Console.WriteLine("Error..... " + ex.StackTrace); } } 

I'm pretty stuck and would be grateful for any help you could provide on this. Thanks.

Source -> C # client-server protocol / model issue

Answer 1

Once you have established a connection, the client and server must constantly monitor their NetworkStream objects for new data. When data is received, it should be added to some data buffer until you get enough to compose a complete message. After receiving the appropriate amount of data, you can try to parse the message and respond accordingly.

Essentially, you need to tweak the logic, which looks something like this:

 var data = new byte[1024]; var dataLength = 0; var dataBuffer = new MyCustomDataBuffer(); while (true) { while (stream.DataAvailable) { dataLength = stream.Read(data, 0, data.Length); dataBuffer.Append(data, dataLength); while (dataBuffer.ContainsCompleteMessage()) { dataBuffer.ProcessMessage(); } } } 

The control flow of this example is greatly simplified, but it should get this idea. I also do not provide an implementation for MyCustomDataBuffer , but writing such a class is not too difficult; all that really is is a stream of bytes.

How do we know if we have received the full message? Well, that’s the point of the protocol: establish rules that let us know these things. Consider a simple data protocol example where each message consists of two parts:

• 2 bytes of the header, which mean the total size of the message in bytes
• The arbitrary number of bytes that make up the message string

In this protocol, we know that all messages have a length of at least two bytes (the theoretical smallest allowed message is 00 02 , which is an empty string). We also know that the first two bytes of the message tell us the total size of the message, so we will know when to stop reading data.

So, to implement the ContainsCompleteMessage() method from the above code, we need:

• Make sure that the data buffer has at least 2 bytes;
• Convert these two bytes to an integer;
• And determine if there are at least as many bytes in our data buffer.

As soon as we find out that we have the correct message, and we know how big it is, all we need to do is drop the first N bytes of our data buffer (where N is the size of the message), then pull the message line from the corresponding segment message data:

 // here, 'msg' is a byte array that contains just the message data var msgString = Encoding.UTF8.GetString(msg, 2, msg.Length - 2); switch (msgString) { case "kill": KillServer(); break; // etc. } 

The protocol that I describe here will be consistent with the stated need to send short lines over the network. Summarizing it, you can send more complex objects; you just need to add additional metadata that defines the layout of the message. I leave this as an exercise for the reader.