Question

我有一个关于处理程序函数中缓冲区最大大小的问题，该函数在boost :: bind方法中调用。我有一个TCP套接字客户端：

chat_client(boost::asio::io_service& io_service,
  tcp::resolver::iterator endpoint_iterator)
: io_service_(io_service),
  socket_(io_service),
  t(io_service)
{
    boost::asio::async_connect(socket_, endpoint_iterator,
           boost::bind(&chat_client::handle_connect, this,
           boost::asio::placeholders::error));
}

在chat_client类中，我创建了一种将请求写入套接字缓冲区的方法

 void set_timer(boost::posix_time::ptime time, boost::function<void(const 
      boost::system::error_code&)> handler)
 {
     t.expires_at(time);
     t.async_wait(handler);
 }
void write(const chat_message& msg)
{
     set_timer(boost::posix_time::microsec_clock::universal_time() + 
          boost::posix_time::seconds(1),
          boost::bind(&chat_client::do_write, this, msg, 
          boost::asio::placeholders::error));
     io_service_.run();
}
void do_write(chat_message msg, const boost::system::error_code& error)
{
     std::cout << "dcm" << std::endl;
     bool write_in_progress = !write_msgs_.empty();
     write_msgs_.push_back(msg);
     if (!write_in_progress)
     {
          boost::asio::async_write(socket_,
                            boost::asio::buffer(write_msgs_.front().data(),
                            write_msgs_.front().length()),
                            boost::bind(&chat_client::handle_write, this,
                            boost::asio::placeholders::error,
                            boost::asio::placeholders::bytes_transferred));
     }
}

void handle_write(const boost::system::error_code& error, size_t 
      bytes_transferred)
{
    if (!error)
    {
         write_msgs_.pop_front();
         if (!write_msgs_.empty())
         {
              boost::asio::async_write(socket_,
                             boost::asio::buffer(write_msgs_.front().data(),
                             write_msgs_.front().length()),
                             boost::bind(&chat_client::handle_write, this,
                             boost::asio::placeholders::error,
                             boost::asio::placeholders::bytes_transferred));
         }
    }
    else
    {
         do_close();
    }
}

我的请求内容打包在chat_message类的实例中。这是chat_message类：

class chat_message
{
public:
    enum { header_length = 7 };
    enum { max_body_length = 0x1FFFFF };

    chat_message()
    : body_length_(0)
    {
    }

    const char* data() const
    {
        return data_;
    }

    char* data()
    {
        return data_;
    }

    size_t length() const
    {
        return header_length + body_length_;
    }

    const char* body() const
    {
        return data_ + header_length;
    }

    char* body()
    {
        return data_ + header_length;
    }

    size_t body_length() const
    {
        return body_length_;
    }

    void body_length(size_t new_length)
    {
        body_length_ = new_length;
        if (body_length_ > max_body_length)
            body_length_ = max_body_length;
    }

    bool decode_header()
    {
        using namespace std; // For strncat and atoi.
        char header[header_length + 1] = "";
        strncat(header, data_, header_length);
        body_length_ = atoi(header);
        if (body_length_ > max_body_length)
        {
            body_length_ = 0;
            return false;
        }
        return true;
    }

    void encode_header()
    {
        using namespace std; // For sprintf and memcpy.
        char header[header_length + 1] = "";
        sprintf(header, "%4d", static_cast<int>(body_length_));
        memcpy(data_, header, header_length);
    }

private:
    char data_[header_length + max_body_length];
    size_t body_length_;
};

我的问题是当我设置max_body_length> 0xFFFFF时，write（）函数中的boost :: bind（）方法导致分段错误。因此，我怀疑boost :: bind（）方法是否具有最大的buffersize。有人可以帮我解释一下吗？谢谢

Answer 1

问题不在boost::bind()中，而在以下方面：

char data_[header_length + max_body_length];

此行可以编译，但是在访问元素时可能会崩溃。我强烈建议不要在这里使用如此大量的字符。作为保持它的一种方法，您可能会考虑动态分配。或完全从阵列中移出。 STL和BOOST库提供了许多工具来安全地处理字符串和集合。

boost :: bind函数的最大缓冲区大小

1 个答案: