HRESULT LWIP_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)
{
struct netif *pNetIf;
if (pNetIf = netif_find_interface(g_LWIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber))
{
config->ipaddr = pNetIf->ip_addr.addr;
config->subnetmask = pNetIf->netmask.addr;
config->gateway = pNetIf->gw.addr;
#if LWIP_DNS
config->dnsServer1 = dns_getserver(0).addr;
config->dnsServer2 = dns_getserver(1).addr;
#endif
}
else
{
config->ipaddr = 0;
config->subnetmask = 0;
config->gateway = 0;
}
}
return S_OK;
}
BOOL LWIP_SOCKETS_Driver::Initialize()
{
NATIVE_PROFILE_PAL_NETWORK();
struct netif *pNetIf;
int i;
/* Initialize the raw lwIP stack and the tcp_tmr completion */
lwip_init();
#if defined(NETWORK_USE_LOOPBACK)
/* Bind and Open the loopback driver */
g_LOOPBACK_LWIP_Driver.Bind();
g_LOOPBACK_LWIP_Driver.Open();
#endif
for(i=0; i<g_NetworkConfig.NetworkInterfaceCount; i++)
{
int interfaceNumber;
SOCK_NetworkConfiguration *pNetCfg = &g_NetworkConfig.NetworkInterfaces[i];
/* Bind and Open the Ethernet driver */
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", errno);
continue;
}
g_LWIP_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)
{
pNetIf = netif_find_interface(interfaceNumber);
if (pNetIf)
{
UINT8* addr = (UINT8*)&pNetIf->ip_addr.addr;
lcd_printf( "\f\n\n\n\n\n\n\nip address: %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3] );
debug_printf( "ip address from interface info: %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3] );
}
}
}
return TRUE;
}
void LWIP_SOCKETS_Driver::TcpipInitDone(void* arg)
{
struct netif *pNetIf;
for (int i = 0; i<g_NetworkConfig.NetworkInterfaceCount; i++)
{
int interfaceNumber;
SOCK_NetworkConfiguration *pNetCfg = &g_NetworkConfig.NetworkInterfaces[i];
/* Bind and Open the Ethernet driver */
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", errno);
continue;
}
g_LWIP_SOCKETS_Driver.m_interfaces[i].m_interfaceNumber = interfaceNumber;
UpdateAdapterConfiguration(i, SOCK_NETWORKCONFIGURATION_UPDATE_DHCP | SOCK_NETWORKCONFIGURATION_UPDATE_DNS, pNetCfg);
pNetIf = netif_find_interface(interfaceNumber);
if (pNetIf)
{
netif_set_link_callback(pNetIf, Link_callback);
if (netif_is_link_up(pNetIf))
Link_callback(pNetIf);
netif_set_status_callback(pNetIf, Status_callback);
if (netif_is_up(pNetIf))
Status_callback(pNetIf);
// default debugger interface
if (0 == i)
{
UINT8* addr = (UINT8*)&pNetIf->ip_addr.addr;
lcd_printf("\f\n\n\n\n\n\n\nip address: %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
debug_printf("ip address from interface info: %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
}
}
}
}
int LWIP_SOCKETS_Driver::Select( int nfds, SOCK_fd_set* readfds, SOCK_fd_set* writefds, SOCK_fd_set* exceptfds, const SOCK_timeval* timeout )
{
NATIVE_PROFILE_PAL_NETWORK();
int ret = 0;
fd_set read;
fd_set write;
fd_set excpt;
fd_set* pR = (readfds != NULL) ? &read : NULL;
fd_set* pW = (writefds != NULL) ? &write : NULL;
fd_set* pE = (exceptfds != NULL) ? &excpt : NULL;
// If the network goes down then we should alert any pending socket actions
if(exceptfds != NULL && exceptfds->fd_count > 0)
{
struct netif *pNetIf = netif_find_interface(g_LWIP_SOCKETS_Driver.m_interfaces[0].m_interfaceNumber);
if(pNetIf != NULL)
{
if(!netif_is_up(pNetIf))
{
if(readfds != NULL) readfds->fd_count = 0;
if(writefds != NULL) writefds->fd_count = 0;
errno = ENETDOWN;
return exceptfds->fd_count;
}
}
}
MARSHAL_SOCK_FDSET_TO_FDSET(readfds , pR);
MARSHAL_SOCK_FDSET_TO_FDSET(writefds , pW);
MARSHAL_SOCK_FDSET_TO_FDSET(exceptfds, pE);
ret = lwip_select(MEMP_NUM_NETCONN, pR, pW, pE, (struct timeval *)timeout);
MARSHAL_FDSET_TO_SOCK_FDSET(readfds , pR);
MARSHAL_FDSET_TO_SOCK_FDSET(writefds , pW);
MARSHAL_FDSET_TO_SOCK_FDSET(exceptfds, pE);
return ret;
}
HRESULT LWIP_SOCKETS_Driver::UpdateAdapterConfiguration( UINT32 interfaceIndex, UINT32 updateFlags, SOCK_NetworkConfiguration* config )
{
NATIVE_PROFILE_PAL_NETWORK();
if(interfaceIndex >= NETWORK_INTERFACE_COUNT)
{
return CLR_E_INVALID_PARAMETER;
}
BOOL fEnableDhcp = (0 != (config->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP));
BOOL fDynamicDns = (0 != (config->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DYNAMIC_DNS));
BOOL fDhcpStarted;
struct netif *pNetIf = netif_find_interface(g_LWIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber);
if (NULL == pNetIf)
{
return CLR_E_FAIL;
}
fDhcpStarted = (0 != (pNetIf->flags & NETIF_FLAG_DHCP));
#if LWIP_DNS
// when using DHCP do not use the static settings
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DNS))
{
if(!fDynamicDns && (config->dnsServer1 != 0 || config->dnsServer2 != 0))
{
// user defined DNS addresses
if(config->dnsServer1 != 0)
{
u8_t idx = 0;
dns_setserver(idx, (struct ip_addr *)&config->dnsServer1);
}
if(config->dnsServer2 != 0)
{
u8_t idx = 1;
dns_setserver(idx, (struct ip_addr *)&config->dnsServer2);
}
}
}
#endif
#if LWIP_DHCP
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP))
{
if(fEnableDhcp)
{
if(!fDhcpStarted)
{
if(ERR_OK != dhcp_start(pNetIf))
{
return CLR_E_FAIL;
}
}
}
else
{
if(fDhcpStarted)
{
dhcp_stop(pNetIf);
}
netif_set_addr(pNetIf, (struct ip_addr *) &config->ipaddr, (struct ip_addr *)&config->subnetmask, (struct ip_addr *)&config->gateway);
Network_PostEvent( NETWORK_EVENT_TYPE_ADDRESS_CHANGED, 0 );
}
}
if(fEnableDhcp && fDhcpStarted)
{
// Try Renew before release since renewing after release will fail
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP_RENEW))
{
//netifapi_netif_common(pNetIf, NULL, dhcp_renew);
dhcp_renew(pNetIf);
}
else if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP_RELEASE))
{
//netifapi_netif_common(pNetIf, NULL, dhcp_release);
dhcp_release(pNetIf);
}
}
#endif
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_MAC))
{
int len = __min(config->macAddressLen, sizeof(pNetIf->hwaddr));
memcpy(pNetIf->hwaddr, config->macAddressBuffer, len);
pNetIf->hwaddr_len = len;
// mac address requires stack re-init
Network_Interface_Close(interfaceIndex);
g_LWIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber = Network_Interface_Open(interfaceIndex);
}
return S_OK;
}
int LWIP_SOCKETS_Driver::GetAddrInfo(const char* nodename, char* servname, const SOCK_addrinfo* hints, SOCK_addrinfo** res)
{
#if LWIP_DNS
NATIVE_PROFILE_PAL_NETWORK();
SOCK_addrinfo *ai;
SOCK_sockaddr_in *sa = NULL;
int total_size = sizeof(SOCK_addrinfo) + sizeof(SOCK_sockaddr_in);
struct addrinfo *lwipAddrinfo = NULL;
if(res == NULL) return -1;
*res = NULL;
// if the nodename == "" then return the IP address of this device
if(nodename[0] == 0 && servname == NULL)
{
struct netif *pNetIf = netif_find_interface(g_LWIP_SOCKETS_Driver.m_interfaces[0].m_interfaceNumber);
if(pNetIf == NULL) return -1;
ai = (SOCK_addrinfo*)mem_malloc(total_size);
if (ai == NULL)
{
return -1;
}
memset(ai, 0, total_size);
sa = (SOCK_sockaddr_in*)((u8_t*)ai + sizeof(SOCK_addrinfo));
/* set up sockaddr */
sa->sin_addr.S_un.S_addr = pNetIf->ip_addr.addr;
sa->sin_family = AF_INET;
sa->sin_port = 0;
/* set up addrinfo */
ai->ai_family = AF_INET;
if (hints != NULL)
{
/* copy socktype & protocol from hints if specified */
ai->ai_socktype = hints->ai_socktype;
ai->ai_protocol = hints->ai_protocol;
}
ai->ai_addrlen = sizeof(SOCK_sockaddr_in);
ai->ai_addr = (SOCK_sockaddr*)sa;
*res = ai;
return 0;
}
int err = lwip_getaddrinfo(nodename, servname, (addrinfo*)hints, &lwipAddrinfo);
if(err == 0)
{
///
/// Marshal addrinfo data
///
struct sockaddr_in* lwip_sockaddr_in;
ai = (SOCK_addrinfo*)mem_malloc(total_size);
if (ai == NULL)
{
lwip_freeaddrinfo(lwipAddrinfo);
return -1;
}
memset(ai, 0, total_size);
lwip_sockaddr_in = ((struct sockaddr_in*)lwipAddrinfo->ai_addr);
sa = (SOCK_sockaddr_in*)((u8_t*)ai + sizeof(SOCK_addrinfo));
/* set up sockaddr */
sa->sin_addr.S_un.S_addr = lwip_sockaddr_in->sin_addr.s_addr;
sa->sin_family = lwip_sockaddr_in->sin_family;
sa->sin_port = lwip_sockaddr_in->sin_port;
/* set up addrinfo */
ai->ai_family = lwipAddrinfo->ai_family;
if (hints != NULL)
{
/* copy socktype & protocol from hints if specified */
ai->ai_socktype = hints->ai_socktype;
ai->ai_protocol = hints->ai_protocol;
}
ai->ai_addrlen = sizeof(SOCK_sockaddr_in);
ai->ai_addr = (SOCK_sockaddr*)sa;
*res = ai;
// free marshalled addrinfo
lwip_freeaddrinfo(lwipAddrinfo);
}
else
{
err = -1;
}
return err;
#else
return -1;
#endif
}
