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;
}
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");
}
void
dns_test(cyg_addrword_t p)
{
struct in_addr addr;
struct hostent *hent;
char dn[256];
CYG_TEST_INIT();
init_all_network_interfaces();
CYG_TEST_INFO("Connecting to DNS at " _DNS_IP);
inet_aton(_DNS_IP, &addr);
CYG_TEST_CHECK(cyg_dns_res_init(&addr) == 0, "Failed to initialize resolver");
setdomainname(NULL,0);
/* Expect _LOOKUP_IP as the answer. This is a CNAME lookup */
inet_aton(_LOOKUP_IP, &addr);
hent = gethostbyname(_LOOKUP_FQDN);
if (hent != NULL) {
diag_printf("PASS:<%s is %s>\n", hent->h_name, inet_ntoa(*(struct in_addr *)hent->h_addr));
if (0 != memcmp((void*)&addr, (void*)(hent->h_addr), sizeof(struct in_addr))) {
diag_printf("FAIL:<expected " _LOOKUP_FQDN " to be " _LOOKUP_IP ">\n");
}
} else {
diag_printf("FAIL:<Asked for " _LOOKUP_FQDN ". No answer: %s>\n", hstrerror(h_errno));
}
/* Reverse lookup the _LOOKUP_IP addres, expect _LOOKUP_FQDN
as the answer. */
hent = gethostbyaddr((char *)&addr, sizeof(struct in_addr), AF_INET);
if (hent != NULL) {
diag_printf("PASS:<%s is %s>\n", hent->h_name, inet_ntoa(*(struct in_addr *)hent->h_addr));
if (0 != strcmp(_LOOKUP_FQDN, hent->h_name)) {
diag_printf("FAIL:<expected " _LOOKUP_IP " to be " _LOOKUP_FQDN ">\n");
}
} else {
diag_printf("FAIL:<Asked for " _LOOKUP_IP ". No answer: %s>\n", hstrerror(h_errno));
}
/* This does not require a DNS lookup. Just turn the value into
binary */
hent = gethostbyname(_LOOKUP_IP);
if (hent != NULL) {
diag_printf("PASS:<%s is %s>\n", hent->h_name, inet_ntoa(*(struct in_addr *)hent->h_addr));
} else {
diag_printf("FAIL:<Asked for " _LOOKUP_IP ". No answer: %s>\n", hstrerror(h_errno));
}
/* Reverse lookup an address this is not in the server. Expect a
NULL back */
inet_aton(_LOOKUP_IP_BAD, &addr);
hent = gethostbyaddr((char *)&addr, sizeof(struct in_addr), AF_INET);
if (hent != NULL) {
diag_printf("FAIL:<%s is %s>\n", hent->h_name, inet_ntoa(*(struct in_addr *)hent->h_addr));
} else {
diag_printf("PASS:<Asked for bad IP " _LOOKUP_IP_BAD ". No answer: %s>\n", hstrerror(h_errno));
}
/* Setup a domainname. We not don't have to use fully qualified
domain names */
setdomainname(_LOOKUP_DOMAINNAME, sizeof(_LOOKUP_DOMAINNAME));
getdomainname(dn, sizeof(dn));
diag_printf("INFO:<Domainname is now %s>\n", dn);
/* Make sure FQDN still work */
hent = gethostbyname(_LOOKUP_FQDN);
if (hent != NULL) {
diag_printf("PASS:<%s is %s>\n", hent->h_name, inet_ntoa(*(struct in_addr *)hent->h_addr));
} else {
diag_printf("FAIL:<Asked for " _LOOKUP_FQDN ". No answer: %s>\n", hstrerror(h_errno));
}
/* Now just the hostname */
hent = gethostbyname(_LOOKUP_HOSTNAME);
if (hent != NULL) {
diag_printf("PASS:<%s is %s>\n", _LOOKUP_HOSTNAME, inet_ntoa(*(struct in_addr *)hent->h_addr));
} else {
diag_printf("FAIL:<Asked for " _LOOKUP_HOSTNAME ". No answer: %s>\n", hstrerror(h_errno));
}
CYG_TEST_FINISH("dns1 test completed");
}
