使用套接字通过 Tcp/IP 发送消息 [英] Sending Message Over Tcp/IP using Sockets

问题描述

我试图在客户端/服务器之间发送数据，数据看起来像

I am trying to send data between a client/Server, the data looks like

typedef Struct Message 
  { int id;
    int message_length;
     char* message_str;
    }message;

我试图在客户端和服务器之间Write和Read这条消息，不断更新这个结构中的元素.我听说 Writev 可以解决问题.我想发送一个向服务器发送消息，然后服务器取出元素并将这些元素用作条件来执行正确的方法?

I am trying to Write and Read this message between a client and server constantly updating the elements in this struct. I have heard Writev may do the trick. i want to send a message to the server and then the server pulls out the elements and uses those elements as conditionals to execute the proper method?

推荐答案

假设您想自己进行序列化而不是使用 Google Protocol Buffers 或某些库来处理它，我建议您编写一对函数，例如这个:

Assuming you want to do the serialization yourself and not use Google Protocol Buffers or some library to handle it for you, I'd suggest writing a pair of functions like this:

// Serializes (msg) into a flat array of bytes, and returns the number of bytes written
// Note that (outBuf) must be big enough to hold any Message you might have, or there will
// be a buffer overrun!  Modifying this function to check for that problem and
// error out instead is left as an exercise for the reader.
int SerializeMessage(const struct Message & msg, char * outBuf)
{
   char * outPtr = outBuf;

   int32_t sendID = htonl(msg.id);   // htonl will make sure it gets sent in big-endian form
   memcpy(outPtr, &sendID, sizeof(sendID));
   outPtr += sizeof(sendID);

   int32_t sendLen = htonl(msg.message_length);
   memcpy(outPtr, &sendLen, sizeof(sendLen));
   outPtr += sizeof(sendLen);

   memcpy(outPtr, msg.message_str, msg.message_length);  // I'm assuming message_length=strlen(message_str)+1 here
   outPtr += msg.message_length;

   return (outPtr-outBuf);
}

// Deserializes a flat array of bytes back into a Message object.  Returns 0 on success, or -1 on failure.
int DeserializeMessage(const char * inBuf, int numBytes, struct Message & msg)
{
   const char * inPtr = inBuf;

   if (numBytes < sizeof(int32_t)) return -1;  // buffer was too short!
   int32_t recvID = ntohl(*((int32_t *)inPtr));
   inPtr += sizeof(int32_t);
   numBytes -= sizeof(int32_t);
   msg.id = recvID;

   if (numBytes < sizeof(int32_t)) return -1;   // buffer was too short!
   int32_t recvLen = ntohl(*((int32_t *)inPtr));
   inPtr += sizeof(int32_t);
   numBytes -= sizeof(int32_t);
   msg.message_length = recvLen;       if (msg.message_length > 1024) return -1;  /* Sanity check, just in case something got munged we don't want to allocate a giant array */

   msg.message_str = new char[msg.message_length];
   memcpy(msg.message_str, inPtr, numBytes);
   return 0;
}

使用这些函数，您现在可以将 Message 转换为简单的字符数组，然后随意返回.所以现在您要做的就是通过 TCP 连接发送字符数组，在远端接收它，然后将数组反序列化回那里的 Message 结构.

With these functions, you are now able to convert a Message into a simple char-array and back at will. So now all you have to do is send the char-array over the TCP connection, receive it at the far end, and then Deserialize the array back into a Message struct there.

与此有关的一个问题是您的字符数组将是可变长度的(由于存在长度不同的字符串)，因此您的接收器将需要一些简单的方法来了解在调用 DeserializeMessage 之前要接收多少字节() 在数组上.

One wrinkle with this is that your char arrays will be variable-length (due to the presence of a string which can be different lengths), so your receiver will need some easy way to know how many bytes to receive before calling DeserializeMessage() on the array.

一种简单的处理方法是在发送字符数组之前始终先发送一个 4 字节整数.4 字节整数应始终是即将到来的数组的大小，以字节为单位.(确保在发送之前先通过 htonl() 将整数转换为 big-endian，然后在使用前通过 htonl() 在接收方将其转换回 native-endian).

An easy way to handle that is to always send a 4-byte integer first, before sending the char-array. The 4-byte integer should always be the size of the upcoming array, in bytes. (Be sure to convert the integer to big-endian first, via htonl(), before sending it, and convert it back to native-endian on the receiver via htonl() before using it).

这篇关于使用套接字通过 Tcp/IP 发送消息的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！