endpoint basic_socket::remote_endpoint()
{
system::error_code e;
endpoint ep=remote_endpoint(e);
if(e) throw system::system_error(e);
return ep;
}
void
TCP_Client_Connection::connect(bool ssl_connect, unsigned short port, const char* ip_addr, long connect_timeout, long socket_timeout, long ssl_handshake_timeout, size_t buf_size)
{
ip::tcp::endpoint remote_endpoint(ip::address::from_string(ip_addr), port);
this->connect(ssl_connect, remote_endpoint, connect_timeout, socket_timeout, ssl_handshake_timeout, buf_size);
}
void NetworkIF_i::deleteIPCC(
::CORBA::Long remoteAddress,
::CORBA::Short remotePortNumber)
{
boost::asio::ip::address_v4 ipv4(remoteAddress);
boost::asio::ip::udp::endpoint remote_endpoint(ipv4, remotePortNumber);
IPCCByRemoteEndPointMap::iterator ipccIter = m_IPCCs.find(remote_endpoint);
if (ipccIter != m_IPCCs.end())
{
lmp_ipcc::IPCC_ptr ipcc_ptr = ipccIter->second;
if (ipcc_ptr)
{
for (IPCCAdjacencyObserverContainer::const_iterator obsIter = m_ipccAdjacencyObservers.begin();
obsIter != m_ipccAdjacencyObservers.end();
++obsIter)
{
if (*obsIter)
{
::lmp_ipcc_adjacency_observer::IPCCAdjacencyObserver_var observer = *obsIter;
observer->ipccAdjacencyRemoved(ipcc_ptr);
}
}
}
m_IPCCs.erase(ipccIter);
return;
}
throw lmp_netif::No_Such_Entity();
}
connection::connection( const stcp_socket_ptr& c, connection_delegate* d )
:my( new detail::connection_impl(*this) )
{
my->sock = c;
my->con_del = d;
my->remote_ep = remote_endpoint();
my->_read_loop_complete = fc::async( [=](){ my->read_loop(); } );
}
void connection::connect( const fc::ip::endpoint& ep )
{
try {
// TODO: do we have to worry about multiple calls to connect?
my->sock = std::make_shared<stcp_socket>();
my->sock->connect_to(ep);
my->remote_ep = remote_endpoint();
ilog( " connected to ${ep}", ("ep", ep) );
my->_read_loop_complete = fc::async( [=](){ my->read_loop(); } );
} FC_RETHROW_EXCEPTIONS( warn, "error connecting to ${ep}", ("ep",ep) );
}
lmp_ipcc::IPCC_ptr NetworkIF_i::getIPCC(
::CORBA::Long remoteAddress,
::CORBA::Short remotePortNumber)
{
boost::asio::ip::address_v4 ipv4(remoteAddress);
boost::asio::ip::udp::endpoint remote_endpoint(ipv4, remotePortNumber);
IPCCByRemoteEndPointMap::const_iterator ipccIter = m_IPCCs.find(remote_endpoint);
if (ipccIter != m_IPCCs.end())
{
return ipccIter->second;
}
throw lmp_netif::No_Such_Entity();
}
lmp_ipcc::IPCC_ptr NetworkIF_i::createIPCC(
::CORBA::Long remoteAddress,
::CORBA::Short remotePortNumber)
{
boost::asio::ip::address_v4 ipv4(remoteAddress);
boost::asio::ip::udp::endpoint remote_endpoint(ipv4, remotePortNumber);
IPCCByRemoteEndPointMap::const_iterator ipccIter = m_IPCCs.find(remote_endpoint);
if (ipccIter == m_IPCCs.end())
{
lmp::cc::IpccMsgReceiveIF* ipccPtr =
m_msgHandler.createIpcc(remote_endpoint, m_networkIfProxy, m_io_context);
if (ipccPtr)
{
lmp::cc::IpccApplicationIF* ipccApplPtr =
dynamic_cast<lmp::cc::IpccApplicationIF*>(ipccPtr);
if (ipccApplPtr)
{
lmp_ipcc::IPCC_i* servant =
new lmp_ipcc::IPCC_i(m_POA, m_node, m_networkIfProxy, *ipccApplPtr, m_ipccInDestructionFtor);
PortableServer::ObjectId *oid = m_POA->activate_object(servant); delete oid;
lmp_ipcc::IPCC_ptr ipcc = servant->_this();
// servant->_remove_ref();
ipccIter = m_IPCCs.insert(IPCCByRemoteEndPointMap::value_type(remote_endpoint, lmp_ipcc::IPCC::_duplicate(ipcc))).first;
if (ipccIter != m_IPCCs.end())
{
lmp_ipcc::IPCC_ptr ipcc_ptr = ipccIter->second;
if (ipcc_ptr)
{
for (IPCCAdjacencyObserverContainer::const_iterator obsIter = m_ipccAdjacencyObservers.begin();
obsIter != m_ipccAdjacencyObservers.end();
++obsIter)
{
if (*obsIter)
{
::lmp_ipcc_adjacency_observer::IPCCAdjacencyObserver_var observer = *obsIter;
observer->ipccAdjacencyAdded(ipcc_ptr);
}
}
}
return ipcc_ptr;
}
}
}
}
throw lmp_netif::Entity_Already_Exists();
}
void connection::parse_successor()
{
ip::tcp::endpoint successor;
std::size_t consumed;
if (link_.socket.lowest_layer().remote_endpoint().address().is_v4())
consumed = do_parse_successor<ip::address_v4>(link_.received_buffer(), successor);
else
consumed = do_parse_successor<ip::address_v6>(link_.received_buffer(), successor);
link_.consume_receive_buffer(consumed);
DLOG(INFO) << incoming_port_ << ": Got Successor: " << successor.address() << ':' << successor.port();
#if 0
if (successor.port() == remote_endpoint().port())
sim.verify_reverse_successor(node_->id(), remote_id());
#endif
node_->make_connection(successor);
}
socket1.io_control(io_control_command, ec);
bool non_blocking1 = socket1.non_blocking();
(void)non_blocking1;
socket1.non_blocking(true);
socket1.non_blocking(false, ec);
bool non_blocking2 = socket1.native_non_blocking();
(void)non_blocking2;
socket1.native_non_blocking(true);
socket1.native_non_blocking(false, ec);
ip::udp::endpoint endpoint1 = socket1.local_endpoint();
ip::udp::endpoint endpoint2 = socket1.local_endpoint(ec);
ip::udp::endpoint endpoint3 = socket1.remote_endpoint();
ip::udp::endpoint endpoint4 = socket1.remote_endpoint(ec);
socket1.shutdown(socket_base::shutdown_both);
socket1.shutdown(socket_base::shutdown_both, ec);
socket1.wait(socket_base::wait_read);
socket1.wait(socket_base::wait_write, ec);
socket1.async_wait(socket_base::wait_read, wait_handler());
int i3 = socket1.async_wait(socket_base::wait_write, lazy);
(void)i3;
// basic_datagram_socket functions.
socket1.send(buffer(mutable_char_buffer));
