Here is the code to reproduce the issue (I've just changed boost asynchronous
TCP daytime server sample to return the specified number of bytes message
instead of daytime and put the client connection in read mode)
#include <ctime>
#include <iostream>
#include <cstdlib>
#include <string>
#include
#include
#include
#include
#include
#include
using boost::asio::ip::tcp;
std::string make_message(unsigned int message_size)
{
using namespace std;
std::string data(message_size, 'A');
return data;
}
class tcp_connection : public
boost::enable_shared_from_this
{
public:
typedef boost::shared_ptr pointer;
static pointer create(boost::asio::io_service& io_service, unsigned
int message_size)
{
return pointer(new tcp_connection(io_service, message_size));
}
tcp::socket& socket()
{
return socket_;
}
void handleMessage(const boost::system::error_code& message_error)
{
if (message_error) {
std::cout<<"Error while reading the message from
client"< _header;
unsigned int message_size_;
};
class tcp_server
{
public:
tcp_server(boost::asio::io_service& io_service, unsigned int port,
unsigned int message_size)
: acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
message_size_(message_size)
{
start_accept();
}
private:
void start_accept()
{
tcp_connection::pointer new_connection =
tcp_connection::create(acceptor_.get_io_service(),
message_size_);
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)
{
if (!error)
{
new_connection->start();
start_accept();
}
}
tcp::acceptor acceptor_;
unsigned int message_size_;
};
int main(int argc, char* argv[])
{
if (argc != 3) {
std::cerr << "Usage: server port message_size" << std::endl;
return 1;
}
unsigned int port = boost::lexical_cast<unsigned int>(argv[1]);
unsigned int message_size = boost::lexical_cast<unsigned
int>(argv[2]);
try {
boost::asio::io_service io_service;
tcp_server server(io_service, port, message_size);
io_service.run();
}
catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
For the client we can use boost synchronous TCP daytime client sample
(changed to accept port as an argument) .
#include <iostream>
#include
#include
using boost::asio::ip::tcp;
int main(int argc, char* argv[])
{
try {
if (argc != 3) {
std::cerr << "Usage: client <host> <port>" << std::endl;
return 1;
}
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query(argv[1], argv[2]);
tcp::resolver::iterator endpoint_iterator =
resolver.resolve(query);
tcp::resolver::iterator end;
tcp::socket socket(io_service);
boost::system::error_code error =
boost::asio::error::host_not_found;
while (error && endpoint_iterator != end) {
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
throw boost::system::system_error(error);
for (;;) {
boost::array buf;
boost::system::error_code error;
size_t len = socket.read_some(boost::asio::buffer(buf),
error);
if (error == boost::asio::error::eof)
break; // Connection closed cleanly by peer.
else if (error)
throw boost::system::system_error(error); // Some other
error.
std::cout.write(buf.data(), len);
}
}
catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
Here is how I ran the server and client on two different solaris hosts -
server 9081 200000
client 9081
After running the server and client, do "truss" on server which will be
showing tight polling loop as mentioned above.
--
View this message in context: http://boost.2283326.n4.nabble.com/Problem-with-asych-write-when-sending-mor...
Sent from the Boost - Users mailing list archive at Nabble.com.
