Question

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

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

我在客户端和服务器之间尝试Write和Read此消息不断更新此结构中的元素。我听说Writev可能会做到这一点。我想送一个消息到服务器然后服务器拉出元素并使用这些元素作为条件来执行正确的方法？

Answer 1

好的，我会抓住这个。我将假设你在发送端有一个“消息”对象，你想要做的是以某种方式将它发送到另一台机器并在那里重建数据，这样你就可以对它进行一些计算。您可能不清楚的部分是如何对数据进行编码以进行通信，然后在接收端对其进行解码以恢复信息。只写一个“消息”对象中包含的字节的简单方法（即write（fd，msg，sizeof（* msg），其中“msg”是指向“message”类型的对象的指针）将不起作用，因为你最终会将一台机器的内存中的虚拟地址的值发送到不同的机器，并且在接收端你可以用它来做很多事情。所以问题是设计一种传递两个整数和一个字符的方法字符串捆绑在一起，你可以把它们带回到另一端。当然，有许多方法可以做到这一点。这是否描述了你想要做的事情？

Answer 2

假设您想自己进行序列化而不使用Google Protocol Buffers或某些库来为您处理，我建议您编写一对这样的函数：

// 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转换为简单的char-array并随意返回。所以你现在需要做的就是通过TCP连接发送char数组，在远端接收它，然后将数组反序列化为Message结构。

这样做的一个问题是你的char数组是可变长度的（由于存在一个可以是不同长度的字符串），所以你的接收器需要一些简单的方法来知道在调用DeserializeMessage之前要接收多少字节数组上的（）。

一种简单的方法是在发送char数组之前始终先发送一个4字节的整数。 4字节整数应始终是即将到来的数组的大小（以字节为单位）。（在发送之前，请务必先通过htonl（）将整数转换为big-endian，然后在使用之前通过htonl（）将其转换回接收器上的native-endian。

Answer 3

您可以通过套接字发送结构，但必须在使用boost序列化发送结构之前对它们进行序列化。

以下是示例代码：

    #include<iostream>
    #include<unistd.h>
    #include<cstring>
    #include <sstream> 

    #include <boost/archive/text_oarchive.hpp>
    #include <boost/archive/text_iarchive.hpp>

    using namespace std;

    typedef struct {
        public:
            int id;
            int message_length;
            string message_str;
        private:
        friend class boost::serialization::access; 
        template <typename Archive> 
        void serialize(Archive &ar, const unsigned int vern) 
        { 
            ar & id; 
            ar & message_length;
            ar & message_str;
        }
    } Message;

    int main()
    {
        Message newMsg;
        newMsg.id = 7;
        newMsg.message_length = 14;
        newMsg.message_str="Hi ya Whats up";

        std::stringstream strData;
        boost::archive::text_oarchive oa(strData);
        oa << newMsg;
        char *serObj = (char*) strData.str().c_str();

        cout << "Serialized Data ::: " << serObj << "Len ::: " << strlen(serObj) << "\n";
        /* Send serObj thru Sockets */


        /* recv serObj from socket & deserialize it */
        std::stringstream rcvdObj(serObj);
        Message deserObj;
        boost::archive::text_iarchive ia(rcvdObj);
        ia >> deserObj;
        cout<<"id ::: "<<deserObj.id<<"\n";
        cout<<"len ::: "<<deserObj.message_length<<"\n";
        cout<<"str ::: "<<deserObj.message_str<<"\n";
    }

你可以通过

编译程序

g ++ -o serial boost.cpp /usr/local/lib/libboost_serialization.a

你必须在你的机器上静态编译libboost_serialization.a。

保持套接字'阻塞'将是好的，你必须设计从recv缓冲区读取这些结构。

使用套接字通过Tcp / IP发送消息

3 个答案: