Ejemplo n.º 1
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, &eth0_bootp_data, &eth0_dhcpstate, 
                        &eth0_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, &eth0_bootp_data))
//#endif
            {
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP_SHOW
                show_bootp(eth0_name, &eth0_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(&eth0_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, &eth0_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, &eth1_bootp_data, &eth1_dhcpstate, 
                        &eth1_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, &eth1_bootp_data))
//#endif
            {
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP_SHOW
                show_bootp(eth1_name, &eth1_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(&eth1_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, &eth1_bootp_data);
#endif
        }
    }
#endif

#ifdef CYGHWR_NET_DRIVER_ETH0
    if (eth0_up) {
        if (!init_net(eth0_name, &eth0_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, &eth0_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(&eth0_bootp_data, TAG_SUBNET_MASK, 
                             (void *)&temp, &length);
            diag_printf("/%s", inet_ntoa(temp));
            get_bootp_option(&eth0_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, &eth1_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, &eth1_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(&eth1_bootp_data, TAG_SUBNET_MASK, 
                             (void *)&temp, &length);
            diag_printf("/%s", inet_ntoa(temp));
            get_bootp_option(&eth1_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");
}
Ejemplo n.º 2
0
//
// 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, &eth0_bootp_data, &eth0_dhcpstate, &eth0_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, &eth0_bootp_data)) 
#endif
        {
#ifdef CYGHWR_NET_DRIVER_ETH0_BOOTP_SHOW
            show_bootp(eth0_name, &eth0_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(&eth0_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, &eth0_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, &eth1_bootp_data, &eth1_dhcpstate, &eth1_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, &eth1_bootp_data))
#endif
        {
#ifdef CYGHWR_NET_DRIVER_ETH1_BOOTP_SHOW
            show_bootp(eth1_name, &eth1_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(&eth1_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, &eth1_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, &eth0_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, &eth0_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, &eth1_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, &eth1_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;

}