1

問題があります。クライアントとサーバーの間にTCP接続があります。クライアントが初期化すると、サーバーにメッセージが送信され、サーバーはウェルカムメッセージで応答します。

これはすべて、ローカルネットワークで正常に機能します。

だから私の問題は、async_writeとasync_readを使用することです（サーバーを非同期にする必要があるため）クライアントはサーバーにメッセージを送信し、サーバーはそれを見て応答しますが、クライアントはウェルカムメッセージを受け取りません。

それ以外の場合、サーバーを閉じると、クライアントはウェルカムメッセージを受信しました。

これが私のサーバーコードです：

main.cpp

int main()
{
  try
  {
  boost::asio::io_service io_service;

  tcp_server server(io_service, 7171);
  io_service.run();
}
 catch (std::exception& e)
{
  std::cerr << e.what() << std::endl;
}

return 0;
}

tcp_server

class tcp_server
 {
  public:
 tcp_server(boost::asio::io_service& io_service, int port) // (1)                                                                                                                                                                            
   : m_acceptor(io_service, tcp::endpoint(tcp::v4(), port))
    {
      std::cout << "Port : " << port << std::endl;
      start_accept();
    }

 private:

  void start_accept()
  {
    tcp_connection::pointer new_connection = tcp_connection::create(m_acceptor.io_service());

    m_acceptor.async_accept(new_connection->socket(),
                            boost::bind(&tcp_server::handle_accept, this, new_connection,
                    boost::asio::placeholders::error));
  }

  void handle_accept(tcp_connection::pointer new_connection, const boost::system::error_code& error) // (4)                                                                                                                                  
  {
    if (!error)
      {
        std::cout << "Get one client!" << std::endl;
        new_connection->start();
        start_accept(); // (5)                                                                                                                                                                                                               
      }
  }


  tcp::acceptor m_acceptor;
};

tcp_connection

class tcp_connection : public boost::enable_shared_from_this<tcp_connection>
{
 public:
  typedef boost::shared_ptr<tcp_connection> pointer;

  static pointer create(boost::asio::io_service& ios)
  {
    pointer new_connection(new tcp_connection(ios) );
    return new_connection;
  }

  tcp::socket& socket()
    {
      return m_socket;
    }

  void do_read() // (1)                                                                                                                                                                                                                      
  {
    boost::asio::async_read(m_socket, boost::asio::buffer(m_buffer), // (3)                                                                                                                                                                  
                            boost::bind(&tcp_connection::handle_read, shared_from_this(),
                                        boost::asio::placeholders::error)
                            );
  }


  void start()
  {
    m_message = "Welcome on the server \n";

    boost::asio::async_write(m_socket, boost::asio::buffer(m_message),
                             boost::bind(&tcp_connection::handle_write, shared_from_this(),
                                         boost::asio::placeholders::error)
                             );
  }
private:
 tcp_connection(boost::asio::io_service& io_service)
   : m_socket(io_service)
      { }

  void handle_write(const boost::system::error_code& error)
  {
    std::cout << "handle_write : "<< m_message << std::endl;
    if (!error)
      do_read(); // (2)                                                                                                                                                                                                                      
    else
      std::cout << error.message() << std::endl;
  }

  void handle_read(const boost::system::error_code& error) // (6)                                                                                                                                                                            
  {
    std::cout << "handle read" << m_buffer.data() <<std::endl;
     if (!error)
        do_read();
    else
        close();
  }

 void close() // (7)                                                                                                                                                                                                                        
  {
    m_socket.close();
  }

  tcp::socket m_socket;
  std::string m_message;
  boost::array<char, 128> m_buffer;
};

理由がわかりませんか？そして、どうすればこれを回避できますか？

4

1 に答える 1

2

async_readのマニュアルをお願いします：

この関数は、ストリームから特定のバイト数のデータを非同期的に読み取るために使用されます。関数呼び出しは常にすぐに戻ります。非同期操作は、次のいずれかの条件が満たされるまで続行されます。

  • 提供されたバッファがいっぱいです。つまり、転送されるバイト数は、バッファサイズの合計に等しくなります。
  • エラーが発生しました。

あなたの場合、ピアがソケットを閉じるまで、2つの条件のいずれも満たされません。

代わりに使用する必要がありますasync_read_some（またはasync_read_until、ただし、もう少し複雑になる可能性があります）。

于 2012-07-16T17:11:52.150 に答える