virtual void send(raw_data& data) {
bool write_in_progress = !buffer_write_queue_.empty();
buffer_write_queue_.push_back(data);
if (!write_in_progress) {
socket_.async_write_some(
boost::asio::buffer(buffer_write_queue_.front().bytes, buffer_write_queue_.front().length),
boost::bind(&session::handle_write, shared_from_this(),
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
}
void handle_write(const boost::system::error_code& error, std::size_t bytes_transferred) {
if (!error) {
buffer_write_queue_.pop_front();
if (!buffer_write_queue_.empty()) {
socket_.async_write_some(
boost::asio::buffer(buffer_write_queue_.front().bytes, buffer_write_queue_.front().length),
boost::bind(&session::handle_write, shared_from_this(),
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
}
else {
std::cout << "error in writing data" << std::endl;
this->onError();
}
}
void AsyncLoopSocket(boost::function<TaskState()> doWork, boost::asio::ip::tcp::socket& sock, bool isRead)
{
if (sock.get_io_service().stopped())
{
return;
}
TaskState st = doWork();
if (st == TASK_WORKING)
{
if (isRead)
{
sock.async_read_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
isRead));
}
else
{
sock.async_write_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
isRead));
}
return;
}
// Work is over. stop any outstanding events.
// NOTE: this isn't 100% reliable, and there may be events that linger in the queue.
// The next time we reset() and run() the io_service, these events will be processed,
// and io_service::stopped() will return false, because we've just done reset() and run().
// The state management (SSHSession::State) is our first step in controlling this, and we
// may need to implement our own cancel mechanism
//
// this io_service feature poses an additional problem - by spreading the implementation
// responsibility across multiple classes, we create scenarios where io_service's queue
// may contain outstanding events referring to objects that were, in the meantime, destroyed.
// this is why we're favouring, for now, the use of AsyncLoopTimer, where we can use an
// io_service for each timer, and destroy it right after being used. this makes sure we
// process no "zombie" outstanding events.
sock.get_io_service().stop();
}
auto send(Func handler, ARGS&...args)
{
return s_opt.async_write_some(boost::asio::buffer(args...), handler);
}