void handler::async_read() {
auto self(shared_from_this());
m_socket.async_read_some(boost::asio::buffer(m_buffer),
std::bind(&handler::handle_read, self,
std::placeholders::_1,
std::placeholders::_2));
}
void start()
{
socket_.async_read_some(boost::asio::buffer(data_),
boost::bind(&session::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
void startRead()
{
checkNotReading(true);
reading = true;
readBuff.ensure_write_space(MAX_READ_BYTES_ONCE);
socket.async_read_some(boost::asio::buffer(readBuff.wt_ptr(), readBuff.writeable_bytes()),
boost::bind(&TcpConnection::handleRead, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
}
void run_socket_io(boost::asio::ip::tcp::socket& socket)
{
std::array<char, 1024> read_buffer;
std::array<char, 1024> write_buffer;
socket.async_read_some(boost::asio::buffer(write_buffer, 1024),
[&write_buffer](const boost::system::error_code& ec, std::size_t length)
{
if (!ec)
std::cout.write(write_buffer.data(), length);
});
while (std::cin.getline(read_buffer.data(), 1024))
{
socket.send(
boost::asio::buffer(read_buffer, std::strlen(read_buffer.data())));
}
}
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();
}
inline void connection::handle_read(const boost::system::error_code& e,
std::size_t bytes_transferred) {
if (!e) {
boost::tribool result;
boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
*request_, buffer_.data(), buffer_.data() + bytes_transferred);
if (result) {
try {
request_handler_.handle_request(*request_, reply_);
} catch (webserver::reply rep) {
reply_ = rep;
}
std::cerr << reply_.content << std::endl;
boost::asio::async_write(socket_, reply_.to_buffers(),
strand_.wrap(
boost::bind(&connection::handle_write, shared_from_this(),
boost::asio::placeholders::error)));
} else if (!result) {
reply_ = reply::stock_reply(reply::bad_request);
boost::asio::async_write(socket_, reply_.to_buffers(),
strand_.wrap(
boost::bind(&connection::handle_write, shared_from_this(),
boost::asio::placeholders::error)));
} else {
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
}
// If an error occurs then no new asynchronous operations are started. This
// means that all shared_ptr references to the connection object will
// disappear and the object will be destroyed automatically after this
// handler returns. The connection class's destructor closes the socket.
}
void async_read() {
socket_.async_read_some(boost::asio::buffer(buffer_read_.bytes, MAX_BUFFER_SIZE),
boost::bind( &session::handle_read, shared_from_this(),
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
size_t recv(Func handler,
ARGS&...args)
{
return s_opt.async_read_some(boost::asio::buffer(args...), handler);
}
inline void connection::start() {
socket_.async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection::handle_read, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
}
/**
* Вызывается всякий раз, когда данные получены.
*/
static void handleRead(
ba::ip::tcp::socket& readFrom,
ba::ip::tcp::socket& writeTo,
char* readBuffer,
size_t bytes,
const boost::system::error_code& e
) {
#ifdef _DEBUG
const std::string data( readBuffer, readBuffer + bytes );
std::cout << data << std::endl;
#endif
// отправляем полученные данные "другой стороне"
writeTo.send( ba::buffer( readBuffer, bytes ) );
// читаем ещё данные с "этой стороны"
readFrom.async_read_some(
ba::buffer( readBuffer, 1024 ),
boost::bind(
handleRead,
boost::ref( readFrom ),
boost::ref( writeTo),
readBuffer,
ba::placeholders::bytes_transferred,
ba::placeholders::error
) );
}
