void NetConfigureAll::execute()
{
bool needDefaultRoute = true;
for (const auto& interface : mNetwork.getInterfaces()) {
if (interface.getType() == InterfaceConfigType::LOOPBACK) {
NetworkInterface(interface.getHostIf(), 0).up();
} else if (interface.getType() == InterfaceConfigType::VETH_BRIDGED) {
NetworkInterface networkInterface(interface.getZoneIf(), 0);
Attrs attrs;
if (interface.getMTU() > 0) {
attrs.push_back(Attr{AttrName::MTU, std::to_string(interface.getMTU())});
}
if (!interface.getMACAddress().empty()) {
attrs.push_back(Attr{AttrName::MAC, interface.getMACAddress()});
}
if (interface.getTxLength() > 0) {
attrs.push_back(Attr{AttrName::TXQLEN, std::to_string(interface.getTxLength())});
}
networkInterface.setAttrs(attrs);
networkInterface.up();
// TODO: add container routing config to network configration
// NOTE: temporary - calc gw as a first IP in the network
InetAddr gw;
for (const auto& addr : interface.getAddrList()) {
networkInterface.addInetAddr(addr);
// NOTE: prefix 31 is used only for p2p (RFC3021)
if (gw.prefix == 0 && addr.type == InetAddrType::IPV4 && addr.prefix < 31) {
gw = addr;
unsigned mask = ((1 << addr.prefix) - 1) << (32 - addr.prefix);
unsigned net = ntohl(gw.getAddr<in_addr>().s_addr) & mask;
gw.getAddr<in_addr>().s_addr = htonl(net + 1);
}
}
if (needDefaultRoute && gw.prefix > 0) {
needDefaultRoute = false;
gw.prefix = 0;
networkInterface.addRoute(Route{
gw, //dst - gateway
InetAddr(), //src - not specified (prefix=0)
0,
"",
RoutingTable::UNSPEC
});
}
}
}
}
int TcpServer::init(const char *ip, int port, ConnectionHandlerFactory *factory)
{
if (_ioLoop.init() < 0) {
return -1;
}
if (_acceptor.init(InetAddr(ip, port), &_ioLoop) < 0) {
return -1;
}
if (!factory) {
return -1;
}
_acceptor.setNewConnectionListener(this);
_factory = factory;
return 0;
}
void SocketConnector::run (void)
{
started();
while (!terminationRequested()) {
TCPSocket * const pSocket = dynamic_cast<TCPSocket * const> (_pServerSocket->accept());
if (!pSocket) {
if (!terminationRequested()) {
checkAndLogMsg ("SocketConnector::run", Logger::L_MildError,
"accept() on ServerSocket failed with error %d\n",
_pServerSocket->error());
setTerminatingResultCode (-1);
}
break;
}
pSocket->bufferingMode (0);
ConnectorAdapter * const pConnectorAdapter = ConnectorAdapter::ConnectorAdapterFactory (pSocket);
Connection * const pConnection = new Connection (pConnectorAdapter, this);
_mConnectionsTable.lock();
pConnection->lock();
Connection * const pOldConnection = _connectionsTable.put (generateUInt64Key (InetAddr (pSocket->getRemoteHostAddr(), pSocket->getRemotePort())), pConnection);
_mConnectionsTable.unlock();
if (pOldConnection) {
// There was already a connection from this node to the remote node - close that one
checkAndLogMsg ("SocketConnector::run", Logger::L_Info,
"replaced an old SocketConnection to <%s:%hu> in status %hu with a new one\n",
pConnection->getRemoteProxyInetAddr()->getIPAsString(), pConnection->getRemoteProxyInetAddr()->getPort(),
pOldConnection->getStatus());
delete pOldConnection;
}
else {
checkAndLogMsg ("SocketConnector::run", Logger::L_Info,
"accepted a new SocketConnection from <%s:%hu>\n",
pConnection->getRemoteProxyInetAddr()->getIPAsString(),
pConnection->getRemoteProxyInetAddr()->getPort());
}
pConnection->startMessageHandler();
pConnection->unlock();
}
checkAndLogMsg ("SocketConnector::run", Logger::L_Info,
"SocketConnector terminated; termination code is %d\n", getTerminatingResultCode());
Connector::_pConnectionManager->deregisterConnector (_connectorType);
terminating();
delete this;
}
int
bindport(ACE_HANDLE handle, ACE_UINT32 ip_addr, int address_family) {
InetAddr addr = InetAddr((u_short)0, ip_addr);
return OS::bind(handle, (sockaddr*)addr.getAddr(), addr.getSize());
}
void SocketImplBSD::getOption(const vpr::SocketOptions::Types option,
struct vpr::SocketOptions::Data& data) const
{
int opt_name, opt_level, status;
#if defined(VPR_OS_IRIX) || defined(VPR_OS_HPUX)
int opt_size;
#else
socklen_t opt_size;
#endif
union sockopt_data opt_data;
opt_name = opt_level = -1;
switch ( option )
{
// Socket-level options.
case vpr::SocketOptions::Linger:
opt_level = SOL_SOCKET;
opt_name = SO_LINGER;
opt_size = sizeof(opt_data.linger_val);
break;
case vpr::SocketOptions::ReuseAddr:
opt_level = SOL_SOCKET;
opt_name = SO_REUSEADDR;
opt_size = sizeof(opt_data.enabled);
break;
case vpr::SocketOptions::KeepAlive:
opt_level = SOL_SOCKET;
opt_name = SO_KEEPALIVE;
opt_size = sizeof(opt_data.enabled);
break;
case vpr::SocketOptions::RecvBufferSize:
opt_level = SOL_SOCKET;
opt_name = SO_RCVBUF;
opt_size = sizeof(opt_data.size);
break;
case vpr::SocketOptions::SendBufferSize:
opt_level = SOL_SOCKET;
opt_name = SO_SNDBUF;
opt_size = sizeof(opt_data.size);
break;
case vpr::SocketOptions::Broadcast:
opt_level = SOL_SOCKET;
opt_name = SO_BROADCAST;
opt_size = sizeof(opt_data.enabled);
break;
// IP-level options.
case vpr::SocketOptions::IpTimeToLive:
opt_level = IPPROTO_IP;
opt_name = IP_TTL;
opt_size = sizeof(opt_data.size);
break;
case vpr::SocketOptions::IpTypeOfService:
opt_level = IPPROTO_IP;
opt_name = IP_TOS;
opt_size = sizeof(opt_data.size);
break;
case vpr::SocketOptions::AddMember:
opt_level = IPPROTO_IP;
opt_name = IP_ADD_MEMBERSHIP;
opt_size = sizeof(opt_data.mcast_req);
break;
case vpr::SocketOptions::DropMember:
opt_level = IPPROTO_IP;
opt_name = IP_DROP_MEMBERSHIP;
opt_size = sizeof(opt_data.mcast_req);
break;
case vpr::SocketOptions::McastInterface:
opt_level = IPPROTO_IP;
opt_name = IP_MULTICAST_IF;
opt_size = sizeof(opt_data.mcast_if);
break;
case vpr::SocketOptions::McastTimeToLive:
opt_level = IPPROTO_IP;
opt_name = IP_MULTICAST_TTL;
opt_size = sizeof(opt_data.mcast_ttl);
break;
case vpr::SocketOptions::McastLoopback:
opt_level = IPPROTO_IP;
opt_name = IP_MULTICAST_LOOP;
opt_size = sizeof(opt_data.mcast_loop);
break;
// TCP-level options.
case vpr::SocketOptions::NoDelay:
opt_level = IPPROTO_TCP;
opt_name = TCP_NODELAY;
opt_size = sizeof(opt_data.enabled);
break;
case vpr::SocketOptions::MaxSegment:
opt_level = IPPROTO_TCP;
opt_name = TCP_MAXSEG;
opt_size = sizeof(opt_data.size);
break;
// BSD specific
case vpr::SocketOptions::Error:
opt_level = SOL_SOCKET;
opt_name = SO_ERROR;
opt_size = sizeof(opt_data.error);
}
status = getsockopt(mHandle->mFdesc, opt_level, opt_name,
(void*) &opt_data, &opt_size);
if ( status == 0 )
{
// This extracts the information from the union passed to getsockopt(2)
// and puts it in our friendly vpr::SocketOptions::Data object. This
// code depends on the type of that object being a union!
switch ( option )
{
case vpr::SocketOptions::Linger:
data.linger.enabled = (opt_data.linger_val.l_onoff != 0 ? true
: false);
data.linger.seconds = opt_data.linger_val.l_linger;
break;
case vpr::SocketOptions::ReuseAddr:
data.reuse_addr = (opt_data.enabled != 0 ? true : false);
break;
case vpr::SocketOptions::KeepAlive:
data.keep_alive = (opt_data.enabled != 0 ? true : false);
break;
case vpr::SocketOptions::RecvBufferSize:
data.recv_buffer_size = opt_data.size;
break;
case vpr::SocketOptions::SendBufferSize:
data.send_buffer_size = opt_data.size;
break;
case vpr::SocketOptions::IpTimeToLive:
data.ip_ttl = opt_data.size;
break;
case vpr::SocketOptions::IpTypeOfService:
switch ( opt_data.size )
{
case IPTOS_LOWDELAY:
data.type_of_service = vpr::SocketOptions::LowDelay;
break;
case IPTOS_THROUGHPUT:
data.type_of_service = vpr::SocketOptions::Throughput;
break;
case IPTOS_RELIABILITY:
data.type_of_service = vpr::SocketOptions::Reliability;
break;
#ifdef IPTOS_LOWCOST
case IPTOS_LOWCOST:
data.type_of_service = vpr::SocketOptions::LowCost;
break;
#endif
}
break;
case vpr::SocketOptions::McastInterface:
data.mcast_if = InetAddr();
data.mcast_if.setAddress(opt_data.mcast_if.s_addr, 0);
break;
case vpr::SocketOptions::McastTimeToLive:
data.mcast_ttl = opt_data.mcast_ttl;
break;
case vpr::SocketOptions::McastLoopback:
data.mcast_loopback = opt_data.mcast_loop;
break;
case vpr::SocketOptions::NoDelay:
data.no_delay = (opt_data.enabled != 0 ? true : false);
break;
case vpr::SocketOptions::Broadcast:
data.broadcast = (opt_data.enabled != 0 ? true : false);
break;
case vpr::SocketOptions::MaxSegment:
data.max_segment = opt_data.size;
break;
case vpr::SocketOptions::AddMember:
case vpr::SocketOptions::DropMember:
/** Do nothing */
break;
case vpr::SocketOptions::Error:
data.error = opt_data.error;
break;
}
}
else
{
std::ostringstream msg_stream;
msg_stream << "[vpr::SocketImplBSD::getOption()] ERROR: Could not get "
<< "socket option for socket " << mHandle->getName() << ": "
<< strerror(errno);
throw SocketException(msg_stream.str(), VPR_LOCATION);
}
}
sockaddr_in* addr = new sockaddr_in;
memset(addr, 0, sizeof(*addr));
addr->sin_family = AF_INET;
addr->sin_port = htons(port);
hostent* hp = SocketBase::GetHostByName(host.c_str());
if (hp == 0)
{
DEBUG_SOCKET("failed to get host by name in connect")
return false;
}
char* ip = InetNtoA(*(struct in_addr*)*hp->h_addr_list);
addr->sin_addr.s_addr = InetAddr(ip);
int err = 0;
bool success = SocketBase::Connect(sock_,reinterpret_cast<struct sockaddr*>(addr),
sizeof(*addr),timeout,err);
if (!success)
{
DEBUG_SOCKET("failed to connect to " << host << ":" << port)
eMessage_ = SocketBase::GetErrorMessage(err);
}
return success;
}
bool