void gcomm::AsioUdpSocket::read_handler(const asio::error_code& ec,
size_t bytes_transferred)
{
if (ec)
{
//
return;
}
if (bytes_transferred >= NetHeader::serial_size_)
{
Critical<AsioProtonet> crit(net_);
NetHeader hdr;
try
{
unserialize(&recv_buf_[0], NetHeader::serial_size_, 0, hdr);
}
catch (gu::Exception& e)
{
log_warn << "hdr unserialize failed: " << e.get_errno();
return;
}
if (NetHeader::serial_size_ + hdr.len() != bytes_transferred)
{
log_warn << "len " << hdr.len()
<< " does not match to bytes transferred"
<< bytes_transferred;
}
else
{
Datagram dg(
gu::SharedBuffer(
new gu::Buffer(&recv_buf_[0] + NetHeader::serial_size_,
&recv_buf_[0] + NetHeader::serial_size_
+ hdr.len())));
if (net_.checksum_ == true && check_cs(hdr, dg))
{
log_warn << "checksum failed, hdr: len=" << hdr.len()
<< " has_crc32=" << hdr.has_crc32()
<< " has_crc32c=" << hdr.has_crc32c()
<< " crc32=" << hdr.crc32();
}
else
{
net_.dispatch(id(), dg, ProtoUpMeta());
}
}
}
else
{
log_warn << "short read of " << bytes_transferred;
}
async_receive();
}
inline void rawsocket_connection::receive_message_body_handler(
const boost::system::error_code& error_code, size_t bytes_transferred)
{
if (error_code) {
handle_system_error(error_code);
return;
}
const auto& message_handler = get_message_handler();
assert(message_handler);
message_handler(shared_from_this(), m_message_buffer.data(), bytes_transferred);
async_receive();
}
void udp_server::handle_receive(
boost::system::error_code const& error,
std::size_t bytes_transferred) {
if (!error) {
m_socket.get_io_service().post(
boost::bind(
&udp_server::parse,
this,
std::string(m_recv_buffer.data(), bytes_transferred)));
} else {
std::cerr << error.message() << std::endl;
}
async_receive();
}
void gcomm::AsioUdpSocket::connect(const gu::URI& uri)
{
gcomm_assert(state() == S_CLOSED);
Critical<AsioProtonet> crit(net_);
asio::ip::udp::resolver resolver(net_.io_service_);
asio::ip::udp::resolver::query query(unescape_addr(uri.get_host()),
uri.get_port());
asio::ip::udp::resolver::iterator conn_i(resolver.resolve(query));
target_ep_ = conn_i->endpoint();
socket_.open(conn_i->endpoint().protocol());
socket_.set_option(asio::ip::udp::socket::reuse_address(true));
socket_.set_option(asio::ip::udp::socket::linger(true, 1));
set_fd_options(socket_);
asio::ip::udp::socket::non_blocking_io cmd(true);
socket_.io_control(cmd);
const std::string if_addr(
unescape_addr(
uri.get_option("socket.if_addr",
anyaddr(conn_i->endpoint().address()))));
asio::ip::address local_if(asio::ip::address::from_string(if_addr));
if (is_multicast(conn_i->endpoint()) == true)
{
join_group(socket_, conn_i->endpoint(), local_if);
socket_.set_option(
asio::ip::multicast::enable_loopback(
gu::from_string<bool>(uri.get_option("socket.if_loop", "false"))));
socket_.set_option(
asio::ip::multicast::hops(
gu::from_string<int>(uri.get_option("socket.mcast_ttl", "1"))));
socket_.bind(*conn_i);
}
else
{
socket_.bind(
asio::ip::udp::endpoint(
local_if,
gu::from_string<unsigned short>(uri.get_port())));
}
async_receive();
state_ = S_CONNECTED;
}
ip::udp::endpoint(ip::udp::v6(), 0), in_flags, lazy);
(void)i21;
socket1.receive(buffer(mutable_char_buffer));
socket1.receive(null_buffers());
socket1.receive(buffer(mutable_char_buffer), in_flags);
socket1.receive(null_buffers(), in_flags);
socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
socket1.receive(null_buffers(), in_flags, ec);
socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
socket1.async_receive(null_buffers(), receive_handler());
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
receive_handler());
socket1.async_receive(null_buffers(), in_flags, receive_handler());
int i22 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
(void)i22;
int i23 = socket1.async_receive(null_buffers(), lazy);
(void)i23;
int i24 = socket1.async_receive(buffer(mutable_char_buffer),
in_flags, lazy);
(void)i24;
int i25 = socket1.async_receive(null_buffers(), in_flags, lazy);
(void)i25;
ip::udp::endpoint endpoint;
socket1.receive_from(buffer(mutable_char_buffer), endpoint);
socket1.receive_from(null_buffers(), endpoint);
socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags);
socket1.receive_from(null_buffers(), endpoint, in_flags);
socket1.receive_from(buffer(mutable_char_buffer), endpoint, in_flags, ec);
udp_server::udp_server(boost::asio::io_service& io_service, int port)
: m_socket(
io_service,
boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), port)) {
async_receive();
}
socket1.receive(null_buffers());
socket1.receive(buffer(mutable_char_buffer), in_flags);
socket1.receive(mutable_buffers, in_flags);
socket1.receive(null_buffers(), in_flags);
socket1.receive(buffer(mutable_char_buffer), in_flags, ec);
socket1.receive(mutable_buffers, in_flags, ec);
socket1.receive(null_buffers(), in_flags, ec);
socket1.async_receive(buffer(mutable_char_buffer), receive_handler());
socket1.async_receive(mutable_buffers, receive_handler());
socket1.async_receive(null_buffers(), receive_handler());
socket1.async_receive(buffer(mutable_char_buffer), in_flags,
receive_handler());
socket1.async_receive(mutable_buffers, in_flags, receive_handler());
socket1.async_receive(null_buffers(), in_flags, receive_handler());
int i14 = socket1.async_receive(buffer(mutable_char_buffer), lazy);
(void)i14;
int i15 = socket1.async_receive(mutable_buffers, lazy);
(void)i15;
int i16 = socket1.async_receive(null_buffers(), lazy);
(void)i16;
int i17 = socket1.async_receive(buffer(mutable_char_buffer), in_flags,
lazy);
(void)i17;
int i18 = socket1.async_receive(mutable_buffers, in_flags, lazy);
(void)i18;
int i19 = socket1.async_receive(null_buffers(), in_flags, lazy);
(void)i19;
socket1.write_some(buffer(mutable_char_buffer));
socket1.write_some(buffer(const_char_buffer));
