How do I prefix the length of message in TCP/IP

[manzoor]

I'm sending messages over TCP/IP, I need to prefix message length in a char array and then send it. How do I do it?

Also can you please provide an example of how to extract it at the another end. And if possible, please explain.

I'm using C++ and Winsock.

[cyberfish]

What have you done?

[Zlatko]

Hello.

This should get you started.

/* Assuming that the length of your messages fits into a short */

void writer(void)
{
	/* Determine message and length (len) of message */
	/*
	...
	*/

	/* Encode len into network byte order */
	short netLen = htons(len);
	/* put indvidual bytes of len into the write buffer */
	*pBuffer++ = char(netLen >> 8); // most significant byte will be written first 
	*pBuffer++ = char(netLen & 0xFF); // least significant second

	/* fill up rest of buffer */
	/* 
	... 
	*/
	
	/* write to socket len + 2 */
}

void reader(void)
{
	char buffer[128];

	/* read from socket 2 bytes into buffer and do the reverse of what the writer did */
	short netLen = short(buffer[0]) << 8; // extract the most significant byte
	netLen |= buffer[1]; // add in the least significant byte
	short len = ntohs(netLen); // translate from network byte order to local machine order

	/* ret from socket len bytes */

}

[manzoor]

Can you please explain why you are using the bit shift operator and the ANDing it with 0xFF?

How does it works?

[Zlatko]

The ANDing with 0xFF is not actually necessary, it's just my habit. I'll show you another way to do it too, and you can choose based on your style.

The netLen is a short, so it takes up 2 bytes, but your transmission buffer is accessed by byte because it is usually a char* or unsigned char*. My preference is to take apart the netLen and stuff the parts into the transmission buffer byte-by-byte.

If netLen is (in hex) 0x1234, you need to take the byte 0x12 and put it into the buffer. You can get the byte by shifting netLen right 8 bits and putting it into the buffer. To get the byte 0x34, you could just cast it as a char and place the result into the buffer. The cast will chop off the high byte of 0x12. In my sample code, I zero out the high byte before the cast. I guess that's a waste of time.


The other way to do it is cast the char* buffer as a short* for the netLen assignment. For example:

char* buffer = some_memory;
*((short*)buffer) = netLen;
buffer += 2;