void SetNullIP(const char *pcInterface)
{
struct bootp wlan_bootp_data;
int j = 0;
char ipadd[16];
char netmask[16] = "0.0.0.0";
char gateway[16];
char broadcast[16] = "255.255.255.255";
unsigned long ulIP = 0;
httpIP2String(ulIP, ipadd);
strcpy(gateway, ipadd);
DownInterface(pcInterface);
diag_printf("IP is %s, NetMask is %s, Gateway is %s,Broadcast is %s\n",ipadd,netmask,gateway,broadcast);
build_bootp_record(&wlan_bootp_data, pcInterface,
ipadd, netmask,broadcast,gateway,gateway);
show_bootp(pcInterface, &wlan_bootp_data);
if (!init_net(pcInterface, &wlan_bootp_data))
{
diag_printf("failed for %s\n",pcInterface);
}
for(;j<5;j++)
init_loopback_interface(0);
}
void init_all_network_interfaces(void)
{
cyg_bool_t use_bootp;
cyg_bool_t setup_network = false;
in_addr_t local_ip_addr = 0;
in_addr_t broadcast_addr = 0;
in_addr_t server_addr = 0;
in_addr_t gateway_addr = 0;
in_addr_t network_mask = 0;
char server_str[16];
char network_str[16];
char gateway_str[16];
char broadcast_str[16];
char ip_addr_str[16];
int i;
int net_up = false;
static volatile int in_init_all_network_interfaces = 0;
cyg_scheduler_lock();
while ( in_init_all_network_interfaces ) {
// Another thread is doing this...
cyg_scheduler_unlock();
cyg_thread_delay( 10 );
cyg_scheduler_lock();
}
in_init_all_network_interfaces = 1;
cyg_scheduler_unlock();
#ifdef CYGHWR_NET_DRIVER_ETH0
// Fetch values from saved config data, if available
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootn", &setup_network,
CYGNUM_FLASH_CFG_OP_CONFIG_BOOL);
if (setup_network)
{
// Set defaults as appropriate
use_bootp = true;
// Fetch values from saved config data, if available
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp", &use_bootp,
CYGNUM_FLASH_CFG_OP_CONFIG_BOOL);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp_localip_addr", &local_ip_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp_localip_mask", &network_mask,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp_mygateway_addr", &gateway_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp_ubroadcast_addr",
&broadcast_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_bootp_serverip_addr", &server_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
if (use_bootp)
{
// Perform a complete initialization, using BOOTP/DHCP
eth0_up = true;
//#ifdef CYGHWR_NET_DRIVER_ETH0_DHCP
eth0_dhcpstate = 0; // Says that initialization is external to dhcp
if (do_dhcp(eth0_name, ð0_bootp_data, ð0_dhcpstate,
ð0_lease))
//#else
//#ifdef CYGPKG_NET_DHCP
// eth0_dhcpstate = DHCPSTATE_BOOTP_FALLBACK;
// so the dhcp machine does no harm if called
//#endif
// if (do_bootp(eth0_name, ð0_bootp_data))
//#endif
{
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP_SHOW
show_bootp(eth0_name, ð0_bootp_data);
#endif
} else {
printf("BOOTP/DHCP failed on eth0\n");
eth0_up = false;
}
}
else
{
eth0_up = true;
strncpy(ip_addr_str,
inet_ntoa(*(struct in_addr *) &local_ip_addr), 16);
strncpy(broadcast_str,
inet_ntoa(*(struct in_addr *) &broadcast_addr), 16);
strncpy(gateway_str, inet_ntoa(*(struct in_addr *) &gateway_addr),
16);
strncpy(network_str, inet_ntoa(*(struct in_addr *) &network_mask),
16);
strncpy(server_str, inet_ntoa(*(struct in_addr *) &server_addr),
16);
/* load flash configuration parameters */
build_bootp_record(ð0_bootp_data, eth0_name, ip_addr_str,
network_str, broadcast_str, gateway_str,
server_str);
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP_SHOW
show_bootp(eth0_name, ð0_bootp_data);
#endif
}
}
#endif
#ifdef CYGHWR_NET_DRIVER_ETH1
setup_network = false;
// Fetch values from saved config data, if available
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootn", &setup_network,
CYGNUM_FLASH_CFG_OP_CONFIG_BOOL);
if (setup_network)
{
// Set defaults as appropriate
use_bootp = true;
// Fetch values from saved config data, if available
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp", &use_bootp,
CYGNUM_FLASH_CFG_OP_CONFIG_BOOL);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp_localip_addr", &local_ip_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp_localip_mask", &network_mask,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp_mygateway_addr", &gateway_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp_ubroadcast_addr",
&broadcast_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_c_bootp_serverip_addr", &server_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
if (use_bootp)
{
// Perform a complete initialization, using BOOTP/DHCP
eth1_up = true;
//#ifdef CYGHWR_NET_DRIVER_ETH1_DHCP
eth1_dhcpstate = 0; // Says that initialization is external to dhcp
if (do_dhcp(eth1_name, ð1_bootp_data, ð1_dhcpstate,
ð1_lease))
//#else
//#ifdef CYGPKG_NET_DHCP
// eth0_dhcpstate = DHCPSTATE_BOOTP_FALLBACK;
// so the dhcp machine does no harm if called
//#endif
// if (do_bootp(eth1_name, ð1_bootp_data))
//#endif
{
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP_SHOW
show_bootp(eth1_name, ð1_bootp_data);
#endif
} else {
printf("BOOTP/DHCP failed on eth1\n");
eth1_up = false;
}
}
else
{
eth1_up = true;
strncpy(ip_addr_str,
inet_ntoa(*(struct in_addr *) &local_ip_addr), 16);
strncpy(broadcast_str,
inet_ntoa(*(struct in_addr *) &broadcast_addr), 16);
strncpy(gateway_str, inet_ntoa(*(struct in_addr *) &gateway_addr),
16);
strncpy(network_str, inet_ntoa(*(struct in_addr *) &network_mask),
16);
strncpy(server_str, inet_ntoa(*(struct in_addr *) &server_addr),
16);
/* load flash configuration parameters */
build_bootp_record(ð1_bootp_data, eth1_name, ip_addr_str,
network_str, broadcast_str, gateway_str,
server_str);
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP_SHOW
show_bootp(eth1_name, ð1_bootp_data);
#endif
}
}
#endif
#ifdef CYGHWR_NET_DRIVER_ETH0
if (eth0_up) {
if (!init_net(eth0_name, ð0_bootp_data)) {
printf("Network initialization failed for eth0\n");
eth0_up = false;
}
#ifdef CYGHWR_NET_DRIVER_ETH0_IPV6_PREFIX
if (!init_net_IPv6(eth0_name, ð0_bootp_data,
string(CYGHWR_NET_DRIVER_ETH0_IPV6_PREFIX))) {
diag_printf("Static IPv6 network initialization failed for eth0\n");
eth0_up = false; // ???
}
#endif
if (eth0_up)
{
unsigned int length = 4;
struct in_addr temp;
diag_printf("\nIP: %s", inet_ntoa(eth0_bootp_data.bp_yiaddr));
get_bootp_option(ð0_bootp_data, TAG_SUBNET_MASK,
(void *)&temp, &length);
diag_printf("/%s", inet_ntoa(temp));
get_bootp_option(ð0_bootp_data, TAG_GATEWAY,
(void *)&temp, &length);
// diag_printf(", Gateway: %s\n", inet_ntoa(eth0_bootp_data.bp_giaddr));
diag_printf(", Gateway: %s\n", inet_ntoa(temp));
diag_printf("Server: %s", inet_ntoa(eth0_bootp_data.bp_siaddr));
net_up = true;
}
}
#endif
#ifdef CYGHWR_NET_DRIVER_ETH1
if (eth1_up) {
if (!init_net(eth1_name, ð1_bootp_data)) {
printf("Network initialization failed for eth1\n");
eth1_up = false;
}
#ifdef CYGHWR_NET_DRIVER_ETH1_IPV6_PREFIX
if (!init_net_IPv6(eth1_name, ð1_bootp_data,
string(CYGHWR_NET_DRIVER_ETH1_IPV6_PREFIX))) {
diag_printf("Static IPv6 network initialization failed for eth1\n");
eth1_up = false; // ???
}
#endif
if (eth1_up)
{
unsigned int length = 4;
struct in_addr temp;
diag_printf("\nIP: %s", inet_ntoa(eth1_bootp_data.bp_yiaddr));
get_bootp_option(ð1_bootp_data, TAG_SUBNET_MASK,
(void *)&temp, &length);
diag_printf("/%s", inet_ntoa(temp));
get_bootp_option(ð1_bootp_data, TAG_GATEWAY,
(void *)&temp, &length);
// diag_printf(", Gateway: %s\n", inet_ntoa(eth1_bootp_data.bp_giaddr));
diag_printf(", Gateway: %s\n", inet_ntoa(temp));
diag_printf("Server: %s", inet_ntoa(eth1_bootp_data.bp_siaddr));
net_up = true;
}
}
#endif
#ifdef CYGPKG_NET_NLOOP
#if 0 < CYGPKG_NET_NLOOP
// Create a local IP Address for each of the DSP's */
for (i = 0; i < CYGPKG_NET_NLOOP; ++i)
init_loopback_interface(i);
#endif
#endif
#ifdef CYGOPT_NET_DHCP_DHCP_THREAD
dhcp_start_dhcp_mgt_thread();
#endif
#ifdef CYGOPT_NET_IPV6_ROUTING_THREAD
ipv6_start_routing_thread();
#endif
#ifdef CYGPKG_NS_DNS_BUILD
if (net_up)
{
struct in_addr dns_addr = {0};
int len;
char *dns_domainname;
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_dns_ip", &dns_addr,
CYGNUM_FLASH_CFG_OP_CONFIG_IP);
cyg_dns_res_init(&dns_addr);
CYGACC_CALL_IF_FLASH_CFG_OP(CYGNUM_CALL_IF_FLASH_CFG_GET,
"app_dns_domain_name",
&dns_domainname,
CYGNUM_FLASH_CFG_OP_CONFIG_STRING);
len = strlen(dns_domainname);
setdomainname(dns_domainname,len);
diag_printf(", DNS server IP: %s",
inet_ntoa(*(struct in_addr *)&dns_addr));
}
#endif
if (!net_up)
{
diag_printf("Network Disabled");
}
diag_printf("\n\n");
}
BOOL SetIP(enum SET_IP_STATE_E *pIPState)
{
enum SET_IP_STATE_E ipState;
BOOL bOK = TRUE;
int i;
BOOL bEnable[2];
if (pIPState == NULL)
pIPState = &ipState;
bEnable[0] = g_ConfigParam.abAsNetEnable[0];
bEnable[1] = g_ConfigParam.abAsNetEnable[1];
#ifndef WLAN
if (!bEnable[0] && !bEnable[1]) bEnable[0] = TRUE;
#else
if (!bEnable[0] && !bEnable[1]) bEnable[1] = TRUE;
#endif
for (i = sizeof(g_apcNetworkInterface) / sizeof(const char *) - 1; i >= 0; i--)
{
const char *pcInterface;
if (!bEnable[i]) continue;
pcInterface = g_apcNetworkInterface[i];
if (g_ConfigParam.aucIPAssignedWay[i] == IP_ASSIGNMENT_MANUALLY)
{
struct bootp wlan_bootp_data;
int j = 0;
char ipadd[16];
char netmask[16];
char gateway[16];
char broadcast[16];
httpIP2String(g_ConfigParam.ulAsIPAddress[i],ipadd);
httpIP2String(g_ConfigParam.ulAsNetmask[i],netmask);
httpIP2String(g_ConfigParam.ulAsGateway[i],gateway);
httpIP2String((~g_ConfigParam.ulAsNetmask[i])|g_ConfigParam.ulAsIPAddress[i],broadcast);
*pIPState = SET_IP__STATIC_IP_TRYING;
DownInterface(pcInterface);
diag_printf("IP is %s, NetMask is %s, Gateway is %s,Broadcast is %s\n",ipadd,netmask,gateway,broadcast);
build_bootp_record(&wlan_bootp_data, pcInterface,
ipadd, netmask,broadcast,gateway,gateway);
show_bootp(pcInterface, &wlan_bootp_data);
if (!init_net(pcInterface, &wlan_bootp_data))
{
*pIPState = SET_IP__STATIC_IP_FAILED;
diag_printf("failed for %s\n",pcInterface);
}
else
*pIPState = SET_IP__STATIC_IP_OK;
/* Set DNS server */
if (g_ConfigParam.aulAsDNS[0] != 0)
{
struct in_addr dns_server;
dns_server.s_addr = (g_ConfigParam.aulAsDNS[0]);
cyg_dns_res_init(&dns_server);
}
for(;j<5;j++)
init_loopback_interface(0);
}
else
{
#ifndef WLAN
//WRRunDHCPClient(pcInterface, TRUE);
#else
int j = 0;
*pIPState = SET_IP__DHCP_TRYING;
DownInterface(pcInterface);
diag_printf("Set IP by dhcp\n");
g_WebCamState.bDHCP_Finished = FALSE;
init_all_network_interfaces();
for(;j<5;j++)
init_loopback_interface(0);
if (wlan0_dhcpstate != DHCPSTATE_BOOTP_FALLBACK
&& wlan0_dhcpstate != DHCPSTATE_BOUND)
{
bOK = FALSE;
SetRandomIP("wlan0");
*pIPState = SET_IP__DHCP_FAILED;
}
else
*pIPState = SET_IP__DHCP_OK;
g_WebCamState.bDHCP_Finished = TRUE;
#endif
}
}
/*display the ip address*/
{
unsigned long ulIP;
GetPubIPInfo(&ulIP, NULL, NULL, NULL);
diag_printf("******************ip Address====%x\n", ulIP);
if (bOK)
{
if (g_ConfigParam.ucWlanOperationMode == 1) /* Disable suspend in Ad-hoc mode */
g_netIsSuspendAllowed = FALSE;
else
g_netIsSuspendAllowed = TRUE;
}
diag_printf("bOK=%d\n", bOK);
if (!bOK)
return FALSE;
else
OnSetIP();
}
return TRUE;
}
//
// Initialize network interface[s] using BOOTP/DHCP
//
void
init_all_network_interfaces(void)
{
static volatile int in_init_all_network_interfaces = 0;
#ifdef CYGPKG_IO_PCMCIA
cyg_netdevtab_entry_t *t;
#endif // CYGPKG_IO_PCMCIA
#ifdef CYGOPT_NET_IPV6_ROUTING_THREAD
int rs_wait = 40;
#endif
cyg_scheduler_lock();
while ( in_init_all_network_interfaces ) {
// Another thread is doing this...
cyg_scheduler_unlock();
cyg_thread_delay( 10 );
cyg_scheduler_lock();
}
in_init_all_network_interfaces = 1;
cyg_scheduler_unlock();
#ifdef CYGHWR_NET_DRIVER_ETH0
if ( ! eth0_up ) { // Make this call idempotent
#ifdef CYGPKG_IO_PCMCIA
if ((t = eth_drv_netdev("eth0")) != (cyg_netdevtab_entry_t *)NULL) {
int tries = 0;
while (t->status != CYG_NETDEVTAB_STATUS_AVAIL) {
if (tries == 0) {
diag_printf("... Waiting for PCMCIA device 'eth0'\n");
}
if (++tries == 5) {
diag_printf("... Giving up on PCMCIA device 'eth0'\n");
goto bail_eth0;
}
cyg_thread_delay(100);
}
}
#endif // CYGPKG_IO_PCMCIA
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP
// Perform a complete initialization, using BOOTP/DHCP
eth0_up = true;
#ifdef CYGHWR_NET_DRIVER_ETH0_DHCP
eth0_dhcpstate = 0; // Says that initialization is external to dhcp
if (do_dhcp(eth0_name, ð0_bootp_data, ð0_dhcpstate, ð0_lease))
#else
#ifdef CYGPKG_NET_DHCP
eth0_dhcpstate = DHCPSTATE_BOOTP_FALLBACK;
// so the dhcp machine does no harm if called
#endif
if (do_bootp(eth0_name, ð0_bootp_data))
#endif
{
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP_SHOW
show_bootp(eth0_name, ð0_bootp_data);
#endif
} else {
diag_printf("BOOTP/DHCP failed on eth0\n");
eth0_up = false;
}
#elif defined(CYGHWR_NET_DRIVER_ETH0_ADDRS_IP)
eth0_up = true;
build_bootp_record(ð0_bootp_data,
eth0_name,
string(CYGHWR_NET_DRIVER_ETH0_ADDRS_IP),
string(CYGHWR_NET_DRIVER_ETH0_ADDRS_NETMASK),
string(CYGHWR_NET_DRIVER_ETH0_ADDRS_BROADCAST),
string(CYGHWR_NET_DRIVER_ETH0_ADDRS_GATEWAY),
string(CYGHWR_NET_DRIVER_ETH0_ADDRS_SERVER));
show_bootp(eth0_name, ð0_bootp_data);
#endif
#ifdef CYGPKG_IO_PCMCIA
bail_eth0:
#endif
}
#endif // CYGHWR_NET_DRIVER_ETH0
#ifdef CYGHWR_NET_DRIVER_ETH1
if ( ! eth1_up ) { // Make this call idempotent
#ifdef CYGPKG_IO_PCMCIA
if ((t = eth_drv_netdev("eth1")) != (cyg_netdevtab_entry_t *)NULL) {
int tries = 0;
while (t->status != CYG_NETDEVTAB_STATUS_AVAIL) {
if (tries == 0) {
diag_printf("... Waiting for PCMCIA device 'eth1'\n");
}
if (++tries == 5) {
diag_printf("... Giving up on PCMCIA device 'eth1'\n");
goto bail_eth1;
}
cyg_thread_delay(100);
}
}
#endif // CYGPKG_IO_PCMCIA
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP
// Perform a complete initialization, using BOOTP/DHCP
eth1_up = true;
#ifdef CYGHWR_NET_DRIVER_ETH1_DHCP
eth1_dhcpstate = 0; // Says that initialization is external to dhcp
if (do_dhcp(eth1_name, ð1_bootp_data, ð1_dhcpstate, ð1_lease))
#else
#ifdef CYGPKG_NET_DHCP
eth1_dhcpstate = DHCPSTATE_BOOTP_FALLBACK;
// so the dhcp machine does no harm if called
#endif
if (do_bootp(eth1_name, ð1_bootp_data))
#endif
{
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP_SHOW
show_bootp(eth1_name, ð1_bootp_data);
#endif
} else {
diag_printf("BOOTP/DHCP failed on eth1\n");
eth1_up = false;
}
#elif defined(CYGHWR_NET_DRIVER_ETH1_ADDRS_IP)
eth1_up = true;
build_bootp_record(ð1_bootp_data,
eth1_name,
string(CYGHWR_NET_DRIVER_ETH1_ADDRS_IP),
string(CYGHWR_NET_DRIVER_ETH1_ADDRS_NETMASK),
string(CYGHWR_NET_DRIVER_ETH1_ADDRS_BROADCAST),
string(CYGHWR_NET_DRIVER_ETH1_ADDRS_GATEWAY),
string(CYGHWR_NET_DRIVER_ETH1_ADDRS_SERVER));
show_bootp(eth1_name, ð1_bootp_data);
#endif
#ifdef CYGPKG_IO_PCMCIA
bail_eth1:
#endif
}
#endif // CYGHWR_NET_DRIVER_ETH1
#ifdef CYGHWR_NET_DRIVER_ETH0
#ifndef CYGHWR_NET_DRIVER_ETH0_MANUAL
if (eth0_up) {
if (!init_net(eth0_name, ð0_bootp_data)) {
diag_printf("Network initialization failed for eth0\n");
eth0_up = false;
}
#ifdef CYGHWR_NET_DRIVER_ETH0_IPV6_PREFIX
if (!init_net_IPv6(eth0_name, ð0_bootp_data,
string(CYGHWR_NET_DRIVER_ETH0_IPV6_PREFIX))) {
diag_printf("Static IPv6 network initialization failed for eth0\n");
eth0_up = false; // ???
}
#endif
}
#endif
#endif
#ifdef CYGHWR_NET_DRIVER_ETH1
#ifndef CYGHWR_NET_DRIVER_ETH1_MANUAL
if (eth1_up) {
if (!init_net(eth1_name, ð1_bootp_data)) {
diag_printf("Network initialization failed for eth1\n");
eth1_up = false;
}
#ifdef CYGHWR_NET_DRIVER_ETH1_IPV6_PREFIX
if (!init_net_IPv6(eth1_name, ð1_bootp_data,
string(CYGHWR_NET_DRIVER_ETH1_IPV6_PREFIX))) {
diag_printf("Static IPv6 network initialization failed for eth1\n");
eth1_up = false; // ???
}
#endif
}
#endif
#endif
#ifdef CYGPKG_NET_NLOOP
#if 0 < CYGPKG_NET_NLOOP
{
static int loop_init = 0;
int i;
if ( 0 == loop_init++ )
for ( i = 0; i < CYGPKG_NET_NLOOP; i++ )
init_loopback_interface( i );
}
#endif
#endif
#ifdef CYGOPT_NET_DHCP_DHCP_THREAD
dhcp_start_dhcp_mgt_thread();
#endif
#ifdef CYGOPT_NET_IPV6_ROUTING_THREAD
ipv6_start_routing_thread();
// Wait for router solicit process to happen.
while (rs_wait-- && !cyg_net_get_ipv6_advrouter(NULL)) {
cyg_thread_delay(10);
}
if (rs_wait == 0 ) {
diag_printf("No router solicit received\n");
} else {
// Give Duplicate Address Detection time to work
cyg_thread_delay(200);
}
#endif
#ifdef CYGDAT_NS_DNS_DEFAULT_SERVER
cyg_dns_res_start(string(CYGDAT_NS_DNS_DEFAULT_SERVER));
#endif
#ifdef CYGDAT_NS_DNS_DOMAINNAME_NAME
#define _NAME string(CYGDAT_NS_DNS_DOMAINNAME_NAME)
{
const char buf[] = _NAME;
int len = strlen(_NAME);
setdomainname(buf,len);
}
#endif
// Open the monitor to other threads.
in_init_all_network_interfaces = 0;
}
