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 //------------------------------------------------------------------------------