HRESULT RTIP_SOCKETS_Driver::LoadAdapterConfiguration( UINT32 interfaceIndex, SOCK_NetworkConfiguration* config )
{
NATIVE_PROFILE_PAL_NETWORK();
if(interfaceIndex >= NETWORK_INTERFACE_COUNT)
{
return CLR_E_INVALID_PARAMETER;
}
memcpy(config, &g_NetworkConfig.NetworkInterfaces[interfaceIndex], sizeof(g_NetworkConfig.NetworkInterfaces[interfaceIndex]));
if(config->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP)
{
IFACE_INFO info;
if(SOCK_SOCKET_ERROR != xn_interface_info(g_RTIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber, &info ))
{
config->ipaddr = *(UINT32*)info.my_ip_address;
config->subnetmask = *(UINT32*)info.ip_mask;
config->gateway = *(UINT32*)info.gateways[0];
config->dnsServer1 = *(UINT32*)info.dns_servers[0];
config->dnsServer2 = *(UINT32*)info.dns_servers[1];
}
else
{
config->ipaddr = 0;
config->subnetmask = 0;
config->gateway = 0;
}
}
return S_OK;
}
int RTIP_SOCKETS_Driver::GetAddrInfo( const char* nodename,
char* servname,
const SOCK_addrinfo* hints,
SOCK_addrinfo** res )
{
if(res == NULL || nodename == NULL)
{
set_errno(EINVAL);
return SOCK_SOCKET_ERROR;
}
*res = NULL;
PFHOSTENT pHost = NULL;
struct hostentext localHost;
if(nodename[0] == '\0')
{
IFACE_INFO info;
if(SOCK_SOCKET_ERROR != xn_interface_info(g_RTIP_SOCKETS_Driver.m_interfaces[0].m_interfaceNumber, &info ))
{
memset(&localHost, 0, sizeof(localHost));
localHost.ip_addr.s_un.S_addr = *(UINT32*)info.my_ip_address;
pHost = &localHost;
}
}
else
{
// this method will be called to get both IP address from name and name from IP address, so nodename
// can either be "www.xxx.com" or "xxx.xxx.xxx.xxx". Therefore we will need to first get the IP bytes
// gethostbyname will do this for either name or IP format, then we will need to get the name
// by calling gethostbyaddr to get the host name.
// first call is to get the IP bytes from string version (name or IP)
pHost = gethostbyname((RTP_PFCHAR)nodename);
// second call to get the host name
if(pHost != NULL)
{
pHost = gethostbyaddr((RTP_PFCHAR)&pHost->ip_addr.s_un.S_addr, sizeof(UINT32), PF_INET);
if(!pHost)
{
DEBUG_HANDLE_SOCKET_ERROR( "gethostbyaddr", FALSE );
}
}
else
{
DEBUG_HANDLE_SOCKET_ERROR( "gethostbyname", FALSE );
}
}
if(pHost)
{
SOCK_addrinfo* pAddrInfo = (SOCK_addrinfo*) private_malloc(sizeof(SOCK_addrinfo));
if(pAddrInfo)
{
memset(pAddrInfo, 0, sizeof(SOCK_addrinfo));
pAddrInfo->ai_family = RTP_NET_AF_INET;
SOCK_sockaddr_in *pSockaddr = (SOCK_sockaddr_in*) private_malloc(sizeof(SOCK_sockaddr_in));
if(pSockaddr)
{
memset(pSockaddr, 0, sizeof(SOCK_sockaddr_in));
pSockaddr->sin_addr.S_un.S_addr = pHost->ip_addr.s_un.S_addr;
pSockaddr->sin_family = RTP_NET_AF_INET;
pAddrInfo->ai_addr = (SOCK_sockaddr*)pSockaddr;
pAddrInfo->ai_addrlen = sizeof(SOCK_sockaddr_in);
}
if(pHost->sz_name != NULL)
{
int len = hal_strlen_s(pHost->sz_name);
if(len > 0)
{
int buffer_size = sizeof(char) * len + 1;
pAddrInfo->ai_canonname = (char*) private_malloc(buffer_size);
if(pAddrInfo->ai_canonname)
{
hal_strcpy_s(pAddrInfo->ai_canonname, buffer_size, pHost->sz_name);
}
}
}
*res = pAddrInfo;
}
}
return (*res == NULL? SOCK_SOCKET_ERROR: 0);
}
BOOL RTIP_SOCKETS_Driver::Initialize()
{
NATIVE_PROFILE_PAL_NETWORK();
IFACE_INFO info;
memset(g_RTIP_SOCKETS_Driver.m_interfaces, 0, sizeof(g_RTIP_SOCKETS_Driver.m_interfaces));
/* Initialize the network stack */
if (rtp_net_init() != 0)
{
DEBUG_HANDLE_SOCKET_ERROR("rtp_net_init", TRUE);
return FALSE;
}
#if defined(NETWORK_USE_LOOPBACK)
// Bind and Open the loopback driver
g_LOOPBACK_Driver.Bind();
if (g_LOOPBACK_Driver.Open() == SOCK_SOCKET_ERROR)
{
DEBUG_HANDLE_SOCKET_ERROR("loopback init", FALSE);
}
#endif
for(int i=0; i<g_NetworkConfig.NetworkInterfaceCount; i++)
{
int interfaceNumber;
SOCK_NetworkConfiguration *pNetCfg = &g_NetworkConfig.NetworkInterfaces[i];
Network_Interface_Bind(i);
interfaceNumber = Network_Interface_Open(i);
if (interfaceNumber == SOCK_SOCKET_ERROR)
{
DEBUG_HANDLE_SOCKET_ERROR("Network init", FALSE);
debug_printf("SocketError: %d\n", xn_getlasterror());
continue;
}
g_RTIP_SOCKETS_Driver.m_interfaces[i].m_interfaceNumber = interfaceNumber;
UpdateAdapterConfiguration(i, SOCK_NETWORKCONFIGURATION_UPDATE_DHCP | SOCK_NETWORKCONFIGURATION_UPDATE_DNS, pNetCfg);
// default debugger interface
if(0 == i)
{
// add multicast addresses to the routing table
UINT32 mcast1 = SOCK_htonl(SOCK_DISCOVERY_MULTICAST_IPADDR);
UINT32 mcast2 = SOCK_htonl(SOCK_DISCOVERY_MULTICAST_IPADDR_SND);
UINT32 mask = SOCK_htonl(SOCK_MAKE_IP_ADDR(255,255,255,255));
if(SOCK_SOCKET_ERROR == xn_rt_add((RTP_PFCUINT8)&mcast1, (RTP_PFUINT8)&mask, (RTP_PFUINT8)0, RT_USEIFACEMETRIC, interfaceNumber, RT_INF))
{
DEBUG_HANDLE_SOCKET_ERROR("Multicast xn_rt_add (recv)", FALSE);
}
if(SOCK_SOCKET_ERROR == xn_rt_add((RTP_PFCUINT8)&mcast2, (RTP_PFUINT8)&mask, (RTP_PFUINT8)0, RT_USEIFACEMETRIC, interfaceNumber, RT_INF))
{
DEBUG_HANDLE_SOCKET_ERROR("Multicast xn_rt_add (send)", FALSE);
}
/* JRT - TBD call xn_ip_set_option */
default_mcast_iface = interfaceNumber;
xn_interface_info(interfaceNumber, &info );
debug_printf( "ip address from interface info: %d.%d.%d.%d\r\n", (UINT32)info.my_ip_address[0],
(UINT32)info.my_ip_address[1],
(UINT32)info.my_ip_address[2],
(UINT32)info.my_ip_address[3] );
debug_printf( "mac addrress from interface info: %x.%x.%x.%x.%x.%x\r\n", (UINT32)info.my_ethernet_address[0],
(UINT32)info.my_ethernet_address[1],
(UINT32)info.my_ethernet_address[2],
(UINT32)info.my_ethernet_address[3],
(UINT32)info.my_ethernet_address[4],
(UINT32)info.my_ethernet_address[5] );
}
}
return TRUE;
}
/**This method is called when the RTIP DHCP client receives an IP
* configuration from the DHCP server.
*
* It sets IP address, subnet mask and default gateway according to
* offer from DHCP server.
*/
void RTIPDHCPClient::dhcpNewIPCallback(int ifaceno)
{
IFACE_INFO ifinfo;
RTIPDHCPClient *me =
static_cast<RTIPDHCPClient*>(RTIPDHCPClient::getInstance());
if ( me->minterfaceno != ifaceno)
{
return;
}
if (!me->menabled)
{
me->mpipstackconfigurator->refreshIPConfig(); //Due to timing, rtip might set the ip address, when we dont want it
//this will reset to previous configuration
return;
}
xn_interface_info(me->minterfaceno, &ifinfo);
IPAddress ipaddress(ifinfo.my_ip_address);
me->mipaddress = ipaddress;
IPAddress subnetmask(ifinfo.ip_mask);
me->msubnetmask = subnetmask;
//Default gateway from dhcp server?:
if(me->msession.params.router_option && me->msession.params.router_option_len > 0)
{
IPAddress defaultgateway(reinterpret_cast<unsigned char*>(me->msession.params.router_option)); //Use first gateway
me->mdefaultgateway = defaultgateway;
}
else
{
me->mdefaultgateway = IPAddress(0,0,0,0);
}
if(me->msession.params.dns_server && me->msession.params.dns_server_len > 0)
{
IPAddress primarydns(reinterpret_cast<unsigned char*>(me->msession.params.dns_server));
me->mprimarydns = primarydns;
if(me->msession.params.dns_server_len > 4)
{
IPAddress secondarydns(reinterpret_cast<unsigned char*>(me->msession.params.dns_server)+4);
me->msecondarydns = secondarydns;
}
else
{
me->msecondarydns = IPAddress(0,0,0,0);
}
}
else
{
me->mprimarydns = IPAddress(0,0,0,0);
me->msecondarydns = IPAddress(0,0,0,0);
}
me->mgotlease = true;
me->gotNewLease();
}
