void
SerialPort::on_async_receive_some(const boost::system::error_code& ec,
size_t bytes_transferred) {
if (!ec) {
utils::Logger::Instance().Debug(FUNCTION_NAME);
if (bytes_transferred > 0) {
std::lock_guard<std::mutex>lk(recv_buffer_mutex_);
auto it = incoming_buffer_.begin();
for (; it < incoming_buffer_.begin() + bytes_transferred; it++)
recv_buffer_.push_back(*it);
recv_buffer_has_data_ = recv_buffer_.size() > 0;
}
async_read_some();
} else {
utils::Logger::Instance().Debug("%s\t - ERROR: %s",
FUNCTION_NAME_CSTR, ec.message().c_str());
if (bytes_transferred > 0) {
std::lock_guard<std::mutex>lk(recv_buffer_mutex_);
auto it = incoming_buffer_.begin();
for (; it < incoming_buffer_.begin() + bytes_transferred; it++)
recv_buffer_.push_back(*it);
recv_buffer_has_data_ = recv_buffer_.size() > 0;
}
}
}
void Socket::ReadData() {
if (buffer_.Free() < 1) {
BB_ERROR_LOG("socket[%d] read buffer is full????", GetId());
Close();
return;
}
auto self = shared_from_this();
async_read_some(boost::asio::buffer(buffer_.Tail(), buffer_.Free()),
[this, self](const boost::system::error_code& ec, std::size_t rd) {
if (ec) {
BB_ERROR_LOG("socket[%d] read data ec:%s", GetId(), ec.message().c_str());
Close();
return;
}
buffer_.Skip(rd, bamboo::buffer::SkipType::WRITE);
auto& handler = GetReadHandler();
if (handler) {
std::size_t read = handler(buffer_.Head(), buffer_.Size());
buffer_.Skip(read, bamboo::buffer::SkipType::READ);
} else {
buffer_.Skip(rd, bamboo::buffer::SkipType::READ);
}
ReadData();
});
}
bool
SerialPort::open(const std::string com_port_name, uint32_t baud_rate) {
boost::system::error_code ec;
if (serial_port_.get() == NULL)
return false;
serial_port_->open(com_port_name, ec);
if (ec) {
return false;
}
serial_port_->set_option(boost::asio::serial_port::baud_rate(baud_rate));
serial_port_->set_option(boost::asio::serial_port::character_size(8));
serial_port_->set_option(boost::asio::serial_port::parity(
boost::asio::serial_port_base::parity::none));
serial_port_->set_option(boost::asio::serial_port::stop_bits(
boost::asio::serial_port_base::stop_bits::one));
serial_port_->set_option(boost::asio::serial_port::flow_control(
boost::asio::serial_port_base::flow_control::none));
async_read_some();
return true;
}
void open(protocol_type const& p, error_code& ec);
void close(error_code& ec);
endpoint_type local_endpoint(error_code& ec) const;
endpoint_type remote_endpoint(error_code& ec) const;
void bind(endpoint_type const& endpoint, error_code& ec);
std::size_t available(error_code& ec) const;
int type() const;
template <class Mutable_Buffers>
std::size_t read_some(Mutable_Buffers const& buffers, error_code& ec)
{ TORRENT_SOCKTYPE_FORWARD_RET(read_some(buffers, ec), 0) }
template <class Mutable_Buffers, class Handler>
void async_read_some(Mutable_Buffers const& buffers, Handler const& handler)
{ TORRENT_SOCKTYPE_FORWARD(async_read_some(buffers, handler)) }
template <class Const_Buffers>
std::size_t write_some(Const_Buffers const& buffers, error_code& ec)
{ TORRENT_SOCKTYPE_FORWARD_RET(write_some(buffers, ec), 0) }
template <class Const_Buffers, class Handler>
void async_write_some(Const_Buffers const& buffers, Handler const& handler)
{ TORRENT_SOCKTYPE_FORWARD(async_write_some(buffers, handler)) }
template <class Handler>
void async_connect(endpoint_type const& endpoint, Handler const& handler)
{ TORRENT_SOCKTYPE_FORWARD(async_connect(endpoint, handler)) }
#ifndef BOOST_NO_EXCEPTIONS
template <class IO_Control_Command>
void HttpProxy::handle_async(
boost::system::error_code const & ec,
Size const & bytes_transferred)
{
LOG_SECTION();
LOG_DEBUG("[handle_async] (id = %u, status = %s, ec = %s, bytes_transferred = %s)"
%id_ % state_str[state_] % ec.message() % bytes_transferred.to_string());
if (watch_state_ == broken) {
on_finish();
delete this;
return;
}
if (ec) {
if (state_ == receiving_request_head) {
error_code ec1;
response_.clear_data();
bool block = !get_non_block(ec1);
if (block)
set_non_block(true, ec1);
boost::asio::read(*this, response_.data(), boost::asio::transfer_at_least(4096), ec1);
if (block)
set_non_block(false, ec1);
LOG_DATA(framework::logger::Debug, ("receiving_request_head", response_.data().data()));
}
on_error(ec);
switch (state_) {
case receiving_request_head:
case transferring_request_data:
case sending_response_head:
case transferring_response_data:
on_finish();
state_ = exiting;
if (watch_state_ == watching) {
error_code ec1;
HttpSocket::cancel(ec1);
} else {
delete this;
}
break;
case local_processing:
if (is_local() && !response_.head().content_length.is_initialized() && bytes_transferred.is_size_t()) {
response_.head().content_length.reset(bytes_transferred.get_size_t());
}
case preparing:
case connectting:
case sending_request_head:
case receiving_response_head:
state_ = sending_response_head;
response_error(ec, boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
default:
assert(0);
break;
}
return;
}
switch (state_) {
case stopped:
state_ = receiving_request_head;
response_.head() = HttpResponseHead();
async_read(request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case receiving_request_head:
state_ = preparing;
if (watch_state_ == watch_stopped
&& request_.head().content_length.get_value_or(0) == 0) {
watch_state_ = watching;
async_read_some(boost::asio::null_buffers(),
boost::bind(&HttpProxy::handle_watch, this, _1));
}
on_receive_request_head(
request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case preparing:
if (bytes_transferred.get_bool()) {
if (!http_to_server_)
http_to_server_ = new HttpSocket(get_io_service());
state_ = connectting;
http_to_server_->async_connect(request_.head().host.get(),
boost::bind(&HttpProxy::handle_async, this, _1, Size()));
} else {
state_ = transferring_request_data;
transfer_request_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
}
break;
case connectting:
state_ = sending_request_head;
http_to_server_->async_write(request_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case sending_request_head:
state_ = transferring_request_data;
transfer_request_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case transferring_request_data:
if (is_local()) {
on_receive_request_data(transfer_buf_);
transfer_buf_.consume(transfer_buf_.size());
}
state_ = local_processing;
if (watch_state_ == watch_stopped) {
watch_state_ = watching;
async_read_some(boost::asio::null_buffers(),
boost::bind(&HttpProxy::handle_watch, this, _1));
}
response_.head().connection = request_.head().connection;
local_process(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case local_processing:
if (is_local()) {
state_ = receiving_response_head;
on_receive_response_head(response_.head());
if (!response_.head().content_length.is_initialized()) {
if (bytes_transferred.is_size_t())
response_.head().content_length.reset(bytes_transferred.get_size_t());
else
response_.head().connection.reset(http_field::Connection());
}
if (!response_.head().connection.is_initialized()) {
response_.head().connection.reset(http_field::Connection());
}
handle_async(ec, Size());
} else {
state_ = receiving_response_head;
http_to_server_->async_read(response_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
}
break;
case receiving_response_head:
if (!is_local()) {
on_receive_response_head(response_.head());
if (!response_.head().connection.is_initialized()) {
response_.head().connection.reset(http_field::Connection());
}
if (response_.head().err_msg.empty())
response_.head().err_msg = "OK";
}
state_ = sending_response_head;
async_write(response_.head(),
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case sending_response_head:
state_ = transferring_response_data;
transfer_response_data(
boost::bind(&HttpProxy::handle_async, this, _1, _2));
break;
case transferring_response_data:
on_finish();
if (!response_.head().connection
|| response_.head().connection.get() == http_field::Connection::close) {
state_ = exiting;
if (watch_state_ != watching) {
delete this;
} else {
error_code ec;
shutdown(boost::asio::socket_base::shutdown_send, ec);
boost::asio::ip::tcp::socket::cancel(ec);
}
} else {
state_ = stopped;
if (watch_state_ != watching) {
// restart
watch_state_ = watch_stopped;
handle_async(ec, Size());
} else {
error_code ec;
boost::asio::ip::tcp::socket::cancel(ec);
}
}
break;
default:
assert(0);
break;
}
}
int i23 = socket1.async_write_some(const_buffers, lazy);
(void)i23;
int i24 = socket1.async_write_some(null_buffers(), lazy);
(void)i24;
socket1.read_some(buffer(mutable_char_buffer));
socket1.read_some(mutable_buffers);
socket1.read_some(null_buffers());
socket1.read_some(buffer(mutable_char_buffer), ec);
socket1.read_some(mutable_buffers, ec);
socket1.read_some(null_buffers(), ec);
socket1.async_read_some(buffer(mutable_char_buffer), read_some_handler());
socket1.async_read_some(mutable_buffers, read_some_handler());
socket1.async_read_some(null_buffers(), read_some_handler());
int i25 = socket1.async_read_some(buffer(mutable_char_buffer), lazy);
(void)i25;
int i26 = socket1.async_read_some(mutable_buffers, lazy);
(void)i26;
int i27 = socket1.async_read_some(null_buffers(), lazy);
(void)i27;
}
catch (std::exception&)
{
}
}
} // namespace ip_tcp_socket_compile
//------------------------------------------------------------------------------
