Esempio n. 1
0
static void tcpip_init_done(void* arg) {
    current_task->name = "[tcpipd]";
    current_task->description = "TCP/IP Stack daemon";
    current_task->priority = TASK_PRIO_MIN;


#if DEBUG
    kprintf(LOG "[%d] tcpip: initialized in %d MS\n", sys_getpid(), (uintptr_t) (timer_getms() - (uintptr_t) arg));
#else
    (void) arg;
#endif



    struct netif* lo = netif_find("lo0");
    if(likely(lo)) {
        netif_set_up(lo);
        netif_set_default(lo);
    } else
        kprintf(WARN "netif: Loopback interface not found\n");




    ip_addr_t dns[2];
    IP4_ADDR(&dns[0], 8, 8, 8, 8);
    IP4_ADDR(&dns[1], 8, 8, 4, 4);

    dns_setserver(0, &dns[0]);
    dns_setserver(1, &dns[1]);
}
Esempio n. 2
0
/**
 * Change IP configuration settings disabling the dhcp client
 * @param local_ip   Static ip configuration
 * @param gateway    Static gateway configuration
 * @param subnet     Static Subnet mask
 * @param dns1       Static DNS server 1
 * @param dns2       Static DNS server 2
 */
bool WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1, IPAddress dns2)
{

    if(!WiFi.enableSTA(true)) {
        return false;
    }
    esp_wifi_start();

    tcpip_adapter_ip_info_t info;
    info.ip.addr = static_cast<uint32_t>(local_ip);
    info.gw.addr = static_cast<uint32_t>(gateway);
    info.netmask.addr = static_cast<uint32_t>(subnet);

    tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
    if(tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &info) == ESP_OK) {
        _useStaticIp = true;
    } else {
        return false;
    }
    ip_addr_t d;

    if(dns1 != (uint32_t)0x00000000) {
        // Set DNS1-Server
        d.u_addr.ip4.addr = static_cast<uint32_t>(dns1);
        dns_setserver(0, &d);
    }

    if(dns2 != (uint32_t)0x00000000) {
        // Set DNS2-Server
        d.u_addr.ip4.addr = static_cast<uint32_t>(dns2);
        dns_setserver(1, &d);
    }

    return true;
}
Esempio n. 3
0
/**
 * Change IP configuration settings disabling the dhcp client
 * @param local_ip   Static ip configuration
 * @param gateway    Static gateway configuration
 * @param subnet     Static Subnet mask
 * @param dns1       Static DNS server 1
 * @param dns2       Static DNS server 2
 */
bool ESP8266WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1, IPAddress dns2) {

    if(!WiFi.enableSTA(true)) {
        return false;
    }

    struct ip_info info;
    info.ip.addr = static_cast<uint32_t>(local_ip);
    info.gw.addr = static_cast<uint32_t>(gateway);
    info.netmask.addr = static_cast<uint32_t>(subnet);

    wifi_station_dhcpc_stop();
    if(wifi_set_ip_info(STATION_IF, &info)) {
        _useStaticIp = true;
    } else {
        return false;
    }
    ip_addr_t d;

    if(dns1 != (uint32_t)0x00000000) {
        // Set DNS1-Server
        d.addr = static_cast<uint32_t>(dns1);
        dns_setserver(0, &d);
    }

    if(dns2 != (uint32_t)0x00000000) {
        // Set DNS2-Server
        d.addr = static_cast<uint32_t>(dns2);
        dns_setserver(1, &d);
    }

    return true;
}
Esempio n. 4
0
static nsapi_error_t mbed_lwip_add_dns_server(nsapi_stack_t *stack, nsapi_addr_t addr)
{
    // Shift all dns servers down to give precedence to new server
    for (int i = DNS_MAX_SERVERS-1; i > 0; i--) {
        dns_setserver(i, dns_getserver(i-1));
    }

    ip_addr_t ip_addr;
    if (!convert_mbed_addr_to_lwip(&ip_addr, &addr)) {
        return NSAPI_ERROR_PARAMETER;
    }

    dns_setserver(0, &ip_addr);
    return 0;
}
Esempio n. 5
0
void add_dns_addr(struct netif *lwip_netif)
{
    const ip_addr_t *ip_addr = mbed_lwip_get_ip_addr(true, lwip_netif);
    if (ip_addr) {
        if (IP_IS_V6(ip_addr)) {
            const ip_addr_t *dns_ip_addr;
            bool dns_addr_exists = false;

            for (char numdns = 0; numdns < DNS_MAX_SERVERS; numdns++) {
                dns_ip_addr = dns_getserver(numdns);
                if (!ip_addr_isany(dns_ip_addr)) {
                    dns_addr_exists = true;
                    break;
                }
            }

            if (!dns_addr_exists) {
                /* 2001:4860:4860::8888 google */
                ip_addr_t ipv6_dns_addr = IPADDR6_INIT(
                                              PP_HTONL(0x20014860UL),
                                              PP_HTONL(0x48600000UL),
                                              PP_HTONL(0x00000000UL),
                                              PP_HTONL(0x00008888UL));
                dns_setserver(0, &ipv6_dns_addr);
            }
        }
    }
}
Esempio n. 6
0
STATIC mp_obj_t ppp_ifconfig(size_t n_args, const mp_obj_t *args) {
    ppp_if_obj_t *self = MP_OBJ_TO_PTR(args[0]);
    ip_addr_t dns;
    if (n_args == 1) {
        // get
        if (self->pcb != NULL) {
            dns = dns_getserver(0);
            struct netif *pppif = ppp_netif(self->pcb);
            mp_obj_t tuple[4] = {
                netutils_format_ipv4_addr((uint8_t*)&pppif->ip_addr, NETUTILS_BIG),
                netutils_format_ipv4_addr((uint8_t*)&pppif->gw, NETUTILS_BIG),
                netutils_format_ipv4_addr((uint8_t*)&pppif->netmask, NETUTILS_BIG),
                netutils_format_ipv4_addr((uint8_t*)&dns, NETUTILS_BIG),
            };
            return mp_obj_new_tuple(4, tuple);
        } else {
            mp_obj_t tuple[4] = { mp_const_none, mp_const_none, mp_const_none, mp_const_none };
            return mp_obj_new_tuple(4, tuple);
        }
    } else {
        mp_obj_t *items;
        mp_obj_get_array_fixed_n(args[1], 4, &items);
        netutils_parse_ipv4_addr(items[3], (uint8_t*)&dns.u_addr.ip4, NETUTILS_BIG);
        dns_setserver(0, &dns);
        return mp_const_none;
    }
}
Esempio n. 7
0
void set_dns(char* dns_server)
{
	struct in_addr addr;

	if ((dns_server != RT_NULL) && inet_aton(dns_server, &addr)) {
		dns_setserver(0, (struct ip_addr *)&addr);
	}
}
Esempio n. 8
0
void set_dns(char* dns_server)
{
    struct ip_addr addr;

    if ((dns_server != NULL) && ipaddr_aton(dns_server, &addr))
    {
        dns_setserver(0, &addr);
    }
}
Esempio n. 9
0
void set_dns(char* dns_server)
{
    ip_addr_t *addr;

    if ((dns_server != RT_NULL) && ipaddr_aton(dns_server, addr))
    {
        dns_setserver(0, addr);
    }
}
Esempio n. 10
0
static void add_dns_addr_to_dns_list_index(const u8_t addr_type, const u8_t index)
{
#if LWIP_IPV6
    if (addr_type == IPADDR_TYPE_V6) {
        /* 2001:4860:4860::8888 google */
        ip_addr_t ipv6_dns_addr = IPADDR6_INIT(
                                      PP_HTONL(0x20014860UL),
                                      PP_HTONL(0x48600000UL),
                                      PP_HTONL(0x00000000UL),
                                      PP_HTONL(0x00008888UL));
        dns_setserver(index, &ipv6_dns_addr);
    }
#endif
#if LWIP_IPV4
    if (addr_type == IPADDR_TYPE_V4) {
        /* 8.8.8.8 google */
        ip_addr_t ipv4_dns_addr = IPADDR4_INIT(0x08080808);
        dns_setserver(index, &ipv4_dns_addr);
    }
#endif
}
Esempio n. 11
0
static void
ppp_status_cb(void *ctx, int err, void *arg)
{
    switch (err) {
    case PPPERR_NONE:
        CYG_TEST_INFO("PPP link up");
        // Setup DNS server
        {
            struct ppp_addrs *addrs = (struct ppp_addrs *) arg;
            dns_setserver(2, &addrs->dns1);
        }

        if (test_state == TEST_PPP_INIT_WAIT)
            test_state = TEST_PPP_UP;
        break;
    case PPPERR_PARAM:
        CYG_TEST_INFO("Invalid parameter");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_OPEN:
        CYG_TEST_INFO("Unable to open PPP session");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_DEVICE:
        CYG_TEST_INFO("Invalid I/O device for PPP");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_ALLOC:
        CYG_TEST_INFO("Unable to allocate resources");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_USER:
        CYG_TEST_INFO("User interrupt");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_CONNECT:
        CYG_TEST_INFO("Connection lost");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_AUTHFAIL:
        CYG_TEST_INFO("Failed authentication challenge");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    case PPPERR_PROTOCOL:
        CYG_TEST_INFO("Failed to meet protocol");
        test_state = TEST_PPP_CLOSE_WAIT;
        break;
    }
}
Esempio n. 12
0
mp_obj_t mod_network_nic_ifconfig(struct netif *netif, size_t n_args, const mp_obj_t *args) {
    if (n_args == 0) {
        // Get IP addresses
        const ip_addr_t *dns = dns_getserver(0);
        mp_obj_t tuple[4] = {
            netutils_format_ipv4_addr((uint8_t*)&netif->ip_addr, NETUTILS_BIG),
            netutils_format_ipv4_addr((uint8_t*)&netif->netmask, NETUTILS_BIG),
            netutils_format_ipv4_addr((uint8_t*)&netif->gw, NETUTILS_BIG),
            netutils_format_ipv4_addr((uint8_t*)dns, NETUTILS_BIG),
        };
        return mp_obj_new_tuple(4, tuple);
    } else if (args[0] == MP_OBJ_NEW_QSTR(MP_QSTR_dhcp)) {
        // Start the DHCP client
        if (dhcp_supplied_address(netif)) {
            dhcp_renew(netif);
        } else {
            dhcp_stop(netif);
            dhcp_start(netif);
        }

        // Wait for DHCP to get IP address
        uint32_t start = mp_hal_ticks_ms();
        while (!dhcp_supplied_address(netif)) {
            if (mp_hal_ticks_ms() - start > 10000) {
                mp_raise_msg(&mp_type_OSError, "timeout waiting for DHCP to get IP address");
            }
            mp_hal_delay_ms(100);
        }

        return mp_const_none;
    } else {
        // Release and stop any existing DHCP
        dhcp_release(netif);
        dhcp_stop(netif);
        // Set static IP addresses
        mp_obj_t *items;
        mp_obj_get_array_fixed_n(args[0], 4, &items);
        netutils_parse_ipv4_addr(items[0], (uint8_t*)&netif->ip_addr, NETUTILS_BIG);
        netutils_parse_ipv4_addr(items[1], (uint8_t*)&netif->netmask, NETUTILS_BIG);
        netutils_parse_ipv4_addr(items[2], (uint8_t*)&netif->gw, NETUTILS_BIG);
        ip_addr_t dns;
        netutils_parse_ipv4_addr(items[3], (uint8_t*)&dns, NETUTILS_BIG);
        dns_setserver(0, &dns);
        return mp_const_none;
    }
}
Esempio n. 13
0
void ESP8266WiFiClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns)
{
    struct ip_info info;
    info.ip.addr = static_cast<uint32_t>(local_ip);
    info.gw.addr = static_cast<uint32_t>(gateway);
    info.netmask.addr = static_cast<uint32_t>(subnet);

    wifi_station_dhcpc_stop();
    wifi_set_ip_info(STATION_IF, &info);

    // Set DNS-Server
    ip_addr_t d;
    d.addr = static_cast<uint32_t>(dns);
    dns_setserver(0,&d);

    _useStaticIp = true;
}
Esempio n. 14
0
/**
* @brief Init_lwIP initialize the LwIP
*/
void Init_lwIP(void)
{
	struct ip_addr ipaddr;
	struct ip_addr netmask;
	struct ip_addr gw;
	struct ip_addr dnsserver;
	long *cfg_ip=(long *)wireless_ip;
	//  sys_init();	 
	/* Initializes the dynamic memory heap defined by MEM_SIZE.*/
	mem_init();
	/* Initializes the memory pools defined by MEMP_NUM_x.*/
	memp_init();	
	pbuf_init();	
	netif_init();
	printf("TCP/IP initializing...\n");
	if(*cfg_ip==0){//no ip addr,use DHCP
		/* 启用DHCP服务器 */
		ipaddr.addr = 0;
		netmask.addr = 0;
		gw.addr = 0;
		printf("using dhcp!\n");
		netif_add(&netif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &ethernet_input);
		netif_set_default(&netif);
		netif_set_up(&netif);
		dhcp_start(&netif);
	}
	else{
		printf("using static ip!\n");
		/* 启用静态IP */
		IP4_ADDR(&ipaddr,wireless_ip[0], wireless_ip[1],
		wireless_ip[2], wireless_ip[3]);
		IP4_ADDR(&netmask, wireless_mask[0], wireless_mask[1], 
						wireless_mask[2], wireless_mask[3]);
		IP4_ADDR(&gw, wireless_gw[0], wireless_gw[1],
					wireless_gw[2], wireless_gw[3]);
		IP4_ADDR(&dnsserver, wireless_dns[0], wireless_dns[1],
					wireless_dns[2], wireless_dns[3]);
		dns_init();
		dns_setserver(0, &dnsserver);//set dns server addr	
		netif_add(&netif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &ethernet_input);
		netif_set_default(&netif);
		netif_set_up(&netif);
	}
	timerbase_config();
	printf("TCP/IP initialized.\n");
}
Esempio n. 15
0
// Lua: s = net.dns.setdnsserver(ip_addr, [index])
static int net_setdnsserver( lua_State* L ) {
  size_t l;
  u32_t ip32;

  const char *server = luaL_checklstring( L, 1, &l );
  if (l>16 || server == NULL || (ip32 = ipaddr_addr(server)) == IPADDR_NONE || ip32 == IPADDR_ANY)
    return luaL_error( L, "invalid dns server ip" );

  int numdns = luaL_optint(L, 2, 0);
  if (numdns >= DNS_MAX_SERVERS)
    return luaL_error( L, "server index out of range [0-%d]", DNS_MAX_SERVERS - 1);

  ip_addr_t ipaddr;
  ip4_addr_set_u32(&ipaddr, ip32);
  dns_setserver(numdns,&ipaddr);

  return 0;
}
Esempio n. 16
0
STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self) {
    ip_addr_t ipconfig[4];
    ipconfig[0].addr = 0;
    ipconfig[1].addr = 0;
    ipconfig[2].addr = 0;
    ipconfig[3].addr = 0;
    netif_add(&self->netif, &ipconfig[0], &ipconfig[1], &ipconfig[2], self, wiznet5k_netif_init, ethernet_input);
    self->netif.name[0] = 'e';
    self->netif.name[1] = '0';
    netif_set_default(&self->netif);
    dns_setserver(0, &ipconfig[3]);
    dhcp_set_struct(&self->netif, &self->dhcp_struct);
    // Setting NETIF_FLAG_UP then clearing it is a workaround for dhcp_start and the
    // LWIP_DHCP_CHECK_LINK_UP option, so that the DHCP client schedules itself to
    // automatically start when the interface later goes up.
    self->netif.flags |= NETIF_FLAG_UP;
    dhcp_start(&self->netif);
    self->netif.flags &= ~NETIF_FLAG_UP;
}
Esempio n. 17
0
int dnsclient_main(int argc, FAR char *argv[])
#endif
{
	struct hostent *shost = NULL;
	ip_addr_t dns_addr;

	if (argc < 2) {
		show_usage(argv[0]);
		return 0;
	}

	if (argc == 3 && argv[2] != NULL) {
		printf("dnsclient : dns_add_nameserver : %s\n", argv[2]);
		IP_SET_TYPE_VAL(dns_addr, IPADDR_TYPE_V4);
#ifdef CONFIG_NET_IPv6
		dns_addr.u_addr.ip4.addr = inet_addr(argv[2]);
#else
		dns_addr.addr = inet_addr(argv[2]);
#endif /* CONFIG_NET_IPv6 */
		dns_setserver(0, &dns_addr);
	}

	memset(hostname, 0x00, DNS_NAME_MAXSIZE);

	if (strlen(argv[1]) > DNS_NAME_MAXSIZE) {
		printf("dnsclient : length of hostname has to lower than %d\n", DNS_NAME_MAXSIZE);
		return -1;
	}

	strncpy(hostname, argv[1], DNS_NAME_MAXSIZE);
	printf("\nHostname : %s [len %d]\n", hostname, strlen(hostname));

	if ((shost = gethostbyname(hostname)) == NULL || shost->h_addr_list == NULL) {
		printf("dnsclient : failed to resolve host's IP address, shost %p\n", shost);
		return -1;
	} else {
		printf("DNS results\n");
		printf("IP Address : %s\n", ip_ntoa((ip_addr_t *)shost->h_addr_list[0]));
	}

	return 0;
}
Esempio n. 18
0
int ethApplyIPConfig(void) {
	t_ip_info ip_info;
	struct ip_addr ipaddr, netmask, gw, dns, dns_curr;
	int result;

	if((result = ps2ip_getconfig("sm0", &ip_info)) >= 0) {
		IP4_ADDR(&ipaddr, ps2_ip[0], ps2_ip[1], ps2_ip[2], ps2_ip[3]);
		IP4_ADDR(&netmask, ps2_netmask[0], ps2_netmask[1], ps2_netmask[2], ps2_netmask[3]);
		IP4_ADDR(&gw, ps2_gateway[0], ps2_gateway[1], ps2_gateway[2], ps2_gateway[3]);
		IP4_ADDR(&dns, ps2_dns[0], ps2_dns[1], ps2_dns[2], ps2_dns[3]);
		dns_curr = dns_getserver(0);

		//Check if it's the same. Otherwise, apply the new configuration.
		if((ps2_ip_use_dhcp != ip_info.dhcp_enabled) || (!ps2_ip_use_dhcp &&
			(!ip_addr_cmp(&ipaddr, (struct ip_addr*)&ip_info.ipaddr)	||
			!ip_addr_cmp(&netmask, (struct ip_addr*)&ip_info.netmask)	||
			!ip_addr_cmp(&gw, (struct ip_addr*)&ip_info.gw)			||
			!ip_addr_cmp(&dns, &dns_curr)))) {
				if(ps2_ip_use_dhcp){
					IP4_ADDR((struct ip_addr*)&ip_info.ipaddr, 169, 254, 0, 1);
					IP4_ADDR((struct ip_addr*)&ip_info.netmask, 255, 255, 0, 0);
					IP4_ADDR((struct ip_addr*)&ip_info.gw, 0, 0, 0, 0);
					IP4_ADDR(&dns, 0, 0, 0, 0);

					ip_info.dhcp_enabled = 1;
				}else{
					ip_addr_set((struct ip_addr*)&ip_info.ipaddr, &ipaddr);
					ip_addr_set((struct ip_addr*)&ip_info.netmask, &netmask);
					ip_addr_set((struct ip_addr*)&ip_info.gw, &gw);

					ip_info.dhcp_enabled = 0;
				}

				dns_setserver(0, &dns);
				result = ps2ip_setconfig(&ip_info);
		}else result = 0;
	}

	return result;
}
Esempio n. 19
0
static int tcpecho_netsetup()
{
  /* If this task is excecutated as an NSH built-in function, then the
   * network has already been configured by NSH's start-up logic.
   */

#ifndef CONFIG_NSH_BUILTIN_APPS
  struct in_addr addr;
#if defined(CONFIG_EXAMPLES_TCPECHO_DHCPC) || defined(CONFIG_EXAMPLES_TCPECHO_NOMAC)
  uint8_t mac[IFHWADDRLEN];
#endif
#ifdef CONFIG_EXAMPLES_TCPECHO_DHCPC
  struct dhcpc_state ds;
  void *handle;
#endif

/* Many embedded network interfaces must have a software assigned MAC */

#ifdef CONFIG_EXAMPLES_TCPECHO_NOMAC
  mac[0] = 0x00;
  mac[1] = 0xe0;
  mac[2] = 0xde;
  mac[3] = 0xad;
  mac[4] = 0xbe;
  mac[5] = 0xef;
  netlib_setmacaddr("eth0", mac);
#endif

  /* Set up our host address */

#ifdef CONFIG_EXAMPLES_TCPECHO_DHCPC
  addr.s_addr = 0;
#else
  addr.s_addr = HTONL(CONFIG_EXAMPLES_TCPECHO_IPADDR);
#endif
  netlib_sethostaddr("eth0", &addr);

  /* Set up the default router address */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_TCPECHO_DRIPADDR);
  netlib_setdraddr("eth0", &addr);

  /* Setup the subnet mask */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_TCPECHO_NETMASK);
  netlib_setnetmask("eth0", &addr);

#ifdef CONFIG_EXAMPLES_TCPECHO_DHCPC
  /* Set up the resolver */

  dns_bind();

  /* Get the MAC address of the NIC */

  netlib_getmacaddr("eth0", mac);

  /* Set up the DHCPC modules */

  handle = dhcpc_open(&mac, IFHWADDRLEN);

  /* Get an IP address.  Note:  there is no logic here for renewing the address in this
   * example.  The address should be renewed in ds.lease_time/2 seconds.
   */

  if (!handle)
    {
      return ERROR;
    }

  if (dhcpc_request(handle, &ds) != OK)
    {
      return ERROR;
    }

  netlib_sethostaddr("eth1", &ds.ipaddr);

  if (ds.netmask.s_addr != 0)
    {
      netlib_setnetmask("eth0", &ds.netmask);
    }

  if (ds.default_router.s_addr != 0)
    {
      netlib_setdraddr("eth0", &ds.default_router);
    }

  if (ds.dnsaddr.s_addr != 0)
    {
      dns_setserver(&ds.dnsaddr);
    }

  dhcpc_close(handle);
  printf("IP: %s\n", inet_ntoa(ds.ipaddr));

#endif /* CONFIG_EXAMPLES_TCPECHO_DHCPC */
#endif /* CONFIG_NSH_BUILTIN_APPS */

  return OK;
}
Esempio n. 20
0
 void MTD_FLASHMEM NSLookup::setDNSServer(uint32_t num, IPAddress server)
 {
     ip_addr_t a = server.get_ip_addr_t();
     dns_setserver(num, &a);
 }
void cbIP_initPanInterfaceStatic(
	
    char* hostname, 
    const cbIP_IPv4Settings * const IPv4Settings, 
    const cbIP_IPv6Settings * const IPv6Settings, 
    cbIP_interfaceSettings const * const ifConfig, 
    cbIP_statusIndication callback, 
    void* callbackArg)
{
    struct ip_addr ipaddr;
    struct ip_addr netmask;
    struct ip_addr gw;
    struct ip_addr dns0;
    struct ip_addr dns1;
    struct ip6_addr ip6addr;

	MBED_ASSERT(callback != NULL && hostname != NULL && IPv4Settings != NULL && ifConfig != NULL);

    gw.addr = IPv4Settings->gateway.value;
    ipaddr.addr = IPv4Settings->address.value;
    netmask.addr = IPv4Settings->netmask.value;
    dns0.addr = IPv4Settings->dns0.value;
    dns1.addr = IPv4Settings->dns1.value;

    memcpy(&ip6addr, &IPv6Settings->linklocal.value, sizeof(ip6addr));

    memcpy(&panIf.ifConfig, ifConfig, sizeof(panIf.ifConfig));
    panIf.statusCallback = callback;
    panIf.callbackArg = callbackArg;
    netif_add(&panIf.hInterface, &ipaddr, &netmask, &gw, &panIf, cb_netif_init, ethernet_input);
    panIf.hInterface.hostname = hostname;

    panIf.hInterface.ip6_autoconfig_enabled = 0;
    if ((ip6addr.addr[0] == 0) && (ip6addr.addr[1] == 0) &&
        (ip6addr.addr[2] == 0) && (ip6addr.addr[3] == 0)) {
        netif_create_ip6_linklocal_address(&panIf.hInterface, 1);
    } else {
        memcpy(&panIf.hInterface.ip6_addr[0], &ip6addr, sizeof(ip6addr));
    }
    netif_ip6_addr_set_state((&panIf.hInterface), 0, IP6_ADDR_TENTATIVE);

    dns_setserver(0, &dns0);
    dns_setserver(1, &dns1);

    LWIP_PRINT("Using static ip addresses\n");
    LWIP_PRINT("IP address: %d.%d.%d.%d\n",
               ip4_addr1(&ipaddr), ip4_addr2(&ipaddr),
               ip4_addr3(&ipaddr), ip4_addr4(&ipaddr));
    LWIP_PRINT("Netmask:    %d.%d.%d.%d\n",
               ip4_addr1(&netmask), ip4_addr2(&netmask),
               ip4_addr3(&netmask), ip4_addr4(&netmask));
    LWIP_PRINT("Gateway:    %d.%d.%d.%d\n",
               ip4_addr1(&gw), ip4_addr2(&gw),
               ip4_addr3(&gw), ip4_addr4(&gw));
    LWIP_PRINT("Primary dns:    %d.%d.%d.%d\n",
               ip4_addr1(&dns0), ip4_addr2(&dns0),
               ip4_addr3(&dns0), ip4_addr4(&dns0));
    LWIP_PRINT("Secondary dns:    %d.%d.%d.%d\n",
               ip4_addr1(&dns1), ip4_addr2(&dns1),
               ip4_addr3(&dns1), ip4_addr4(&dns1));

    panIf.statusCallback = callback;
    panIf.hInterface.state = &panIf;
    netif_set_status_callback(&panIf.hInterface, netif_status_callback);
    netif_set_up(&panIf.hInterface);

    cb_uint32 result;
    result = cbBTPAN_registerDataCallback(&_panCallBack);
    MBED_ASSERT(result == cbBTPAN_RESULT_OK);
}
Esempio n. 22
0
/****************************************************************************
 * Name: dhcpc_request
 ****************************************************************************/
static int dhcpc_request(void *handle, struct dhcpc_state *presult)
{
	if (!handle) {
		ndbg("ERROR : handle must not be null\n");
		return -100;
	}

	if (!presult) {
		ndbg("ERROR : presult must not be null\n");
		return -100;
	}

	struct dhcpc_state_s *pdhcpc = (struct dhcpc_state_s *)handle;
	g_pResult = presult;
	struct in_addr oldaddr;
	struct in_addr newaddr;
	uint8_t msgtype;
	int retries = 0, result = 0;
	char *intf;
#define CNT_MAX_DISCOVER 5
#define CNT_MAX_REQUEST 5
	/* Save the currently assigned IP address (should be INADDR_ANY) */
	oldaddr.s_addr = 0;

	intf = pdhcpc->nic;
	int ret = netlib_get_ipv4addr(intf, &oldaddr);
	if (ret == -1) {
		printf("Set IPv4 fail\n");
	}

	/* Loop until we receive the lease (or an error occurs) */
	/* Set the IP address to INADDR_ANY. */
	newaddr.s_addr = INADDR_ANY;
	if (netlib_set_ipv4addr(intf, &newaddr) == ERROR) {
		ndbg("netlib_set_ipv4addr failed\n");
	}

	/* Loop sending DISCOVER until we receive an OFFER from a DHCP
	 * server.  We will lock on to the first OFFER and decline any
	 * subsequent offers (which will happen if there are more than one
	 * DHCP servers on the network.
	 */
	g_dhcpc_state = STATE_INITIAL;
	do {
		/* Get the DHCPOFFER response */
		if (++retries > CNT_MAX_DISCOVER) {	/* reach max try */
			return -2;
		}

		ndbg("Send Discover Packet\n");
		result = dhcpc_sendmsg(pdhcpc, g_pResult, DHCPDISCOVER);
		usleep(100000);
		if (result < 0) {
			if (get_errno() == EAGAIN) {
				continue;
			}
			ndbg("sendDiscover Error\n");
			return -1;
		}

		ndbg("Waiting Offer...(%d)\n", pdhcpc->sockfd);
		result = recv(pdhcpc->sockfd, &pdhcpc->packet, sizeof(struct dhcp_msg), 0);
		ndbg("Received...(%d)\n", result);

		if (result <= 0) {
			ndbg("receive fail\n");
			continue;
		}
		msgtype = dhcpc_parsemsg(pdhcpc, result, presult);
		if (msgtype == DHCPOFFER) {
			/* Save the servid from the presult so that it is not clobbered
			 * by a new OFFER.
			 */
			ndbg("Received OFFER from %08x\n", ntohl(presult->serverid.s_addr));
			pdhcpc->ipaddr.s_addr = presult->ipaddr.s_addr;
			pdhcpc->serverid.s_addr = presult->serverid.s_addr;

			/* Temporarily use the address offered by the server and break
			 * out of the loop.
			 */

			ret = netlib_set_ipv4addr(intf, &presult->ipaddr);
			if (ret == -1) {
				ndbg("Set IPv4 fail\n");
			}
			g_dhcpc_state = STATE_HAVE_OFFER;
			break;
		} else {
			ndbg("Received AnotherData %d %x\n", result, msgtype);
		}
	} while (g_dhcpc_state == STATE_INITIAL);

	/* Loop sending the REQUEST up to three times (if there is no response) */
	retries = 0;

	/* Send the REQUEST message to obtain the lease that was offered to us. */
	ndbg("Send REQUEST\n");

	do {
		if (retries++ > CNT_MAX_REQUEST)
			break;

		ndbg("Send Request Packet\n");

		result = dhcpc_sendmsg(pdhcpc, g_pResult, DHCPREQUEST);
		if (result < 0) {
			ndbg("thread_sendRequest Error\n");
			return -3;
		}
		usleep(100000);
		/* Get the ACK/NAK response to the REQUEST (or timeout) */
		ndbg("Waiting Ack...\n");
		result = recv(pdhcpc->sockfd, &pdhcpc->packet, sizeof(struct dhcp_msg), 0);
		ndbg("Received...(%d)\n", result);

		if (result <= 0) {
			ndbg("recv request error(%d)(%d)\n", result, errno);
			continue;
		}

		/* Parse the response */
		ndbg("Data Received\n");

		msgtype = dhcpc_parsemsg(pdhcpc, result, presult);

		/* The ACK response means that the server has accepted our request
		 * and we have the lease.
		 */

		if (msgtype == DHCPACK) {
			ndbg("Received ACK\n");
			g_dhcpc_state = STATE_HAVE_LEASE;

		}

		/* NAK means the server has refused our request.  Break out of
		 * this loop with state == STATE_HAVE_OFFER and send DISCOVER again
		 */

		else if (msgtype == DHCPNAK) {
			ndbg("Received NAK\n");
			break;
		}

		/* If we get any OFFERs from other servers, then decline them now
		 * and continue waiting for the ACK from the server that we
		 * requested from.
		 */

		else if (msgtype == DHCPOFFER) {
			/* If we get OFFERs from same dhcp server, do not send DECLINE */
			if (pdhcpc->serverid.s_addr == presult->serverid.s_addr) {
				ndbg("Received duplicated OFFER from %08x\n", ntohl(presult->serverid.s_addr));
			} else {
				ndbg("Received another OFFER from %08x, send DECLINE\n", ntohl(presult->serverid.s_addr));
				result = dhcpc_sendmsg(pdhcpc, presult, DHCPDECLINE);
				if (result <= 0) {
					ndbg("recv request error(%d)(%d)\n", result, errno);
				}
			}
		}

		/* Otherwise, it is something that we do not recognize */

		else {
			ndbg("Ignoring msgtype=%d %d\n", msgtype, result);
		}
		usleep(100000L);

		/* An error has occurred.  If this was a timeout error (meaning
		 * that nothing was received on this socket for a long period of time).
		 * Then break out and send the DISCOVER command again (at most
		 * 3 times).
		 */
	} while (g_dhcpc_state == STATE_HAVE_OFFER);

	ndbg("Got IP address %d.%d.%d.%d\n", (presult->ipaddr.s_addr) & 0xff, (presult->ipaddr.s_addr >> 8) & 0xff, (presult->ipaddr.s_addr >> 16) & 0xff, (presult->ipaddr.s_addr >> 24) & 0xff);
	ndbg("Got netmask %d.%d.%d.%d\n", (presult->netmask.s_addr) & 0xff, (presult->netmask.s_addr >> 8) & 0xff, (presult->netmask.s_addr >> 16) & 0xff, (presult->netmask.s_addr >> 24) & 0xff);
	ndbg("Got DNS server %d.%d.%d.%d\n", (presult->dnsaddr.s_addr) & 0xff, (presult->dnsaddr.s_addr >> 8) & 0xff, (presult->dnsaddr.s_addr >> 16) & 0xff, (presult->dnsaddr.s_addr >> 24) & 0xff);
	ndbg("Got default router %d.%d.%d.%d\n", (presult->default_router.s_addr) & 0xff, (presult->default_router.s_addr >> 8) & 0xff, (presult->default_router.s_addr >> 16) & 0xff, (presult->default_router.s_addr >> 24) & 0xff);
	ndbg("Lease expires in %d seconds\n", presult->lease_time);

#if defined CONFIG_NET_LWIP    // this is temporal fix. it should be modified later
    ip_addr_t dns_addr;
    IP_SET_TYPE_VAL(dns_addr, IPADDR_TYPE_V4);
#ifdef CONFIG_NET_IPv6
    dns_addr.u_addr.ip4.addr = presult->dnsaddr.s_addr;
#else
    dns_addr.addr = presult->dnsaddr.s_addr;
#endif
    dns_setserver(0, &dns_addr);
#endif /*  CONFIG_NET_LWIP */

#if defined(CONFIG_NETDB_DNSCLIENT) && defined(CONFIG_NETDB_DNSSERVER_BY_DHCP)
	struct sockaddr_in dns;
	if (presult->dnsaddr.s_addr != 0) {
		ndbg("Set DNS IP address via dns_add_nameserver\n");
		dns.sin_addr.s_addr = presult->dnsaddr.s_addr;
		dns.sin_family = AF_INET;
		dns.sin_port  = htons(DNS_DEFAULT_PORT);
		dns_add_nameserver((FAR struct sockaddr *)&dns, sizeof(struct sockaddr_in));
	}
#endif

	return OK;
}
Esempio n. 23
0
/******************************************************************************
 * FunctionName : espconn_dns_setserver
 * Description  : Initialize one of the DNS servers.
 * Parameters   : numdns -- the index of the DNS server to set must
 * 				  be < DNS_MAX_SERVERS = 2
 * 			      dnsserver -- IP address of the DNS server to set
 *  Returns     : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
espconn_dns_setserver(u8_t numdns, ip_addr_t *dnsserver)
{
	dns_setserver(numdns,dnsserver);
}
Esempio n. 24
0
int main(int argc, char *argv[])
{
	int c;
	int keep_alive;
	int non_local;
	struct netif *netif;
	int dns_count;
	char *str;
	char *endptr;
	int mtu;
	int fd_in;
	int fd_out;
	ip4_addr_t ipaddr;
	ip4_addr_t netmask;
	ip4_addr_t gateway;
	ip4_addr_t dns;
	struct event_base *base;
	char *pcap_file;
	struct conn_info *local;
	struct conn_info *remote;
	struct conn_info *socks;
	struct conn_info *info;

	ip_addr_set_zero(&ipaddr);
	ip_addr_set_zero(&netmask);
	ip_addr_set_zero(&gateway);

	local = remote = socks = NULL;
	dns_count = 0;
	keep_alive = 0;
	fd_in = 0;
	fd_out = 1;
	mtu = 0;
	pcap_file = NULL;
	non_local = 0;

	signal(SIGPIPE, SIG_IGN);

	base = event_base_new();
	lwip_init();
	libevent_timeouts_init(base);

	if ((str = getenv("INTERNAL_IP4_ADDRESS")))
		ip4addr_aton(str, &ipaddr);

	if ((str = getenv("INTERNAL_IP4_MTU")))
		mtu = strtoul(str, NULL, 0);

	if ((str = getenv("VPNFD")))
		fd_in = fd_out = strtoul(str, NULL, 0);

	if ((str = getenv("CISCO_DEF_DOMAIN"))) {
		endptr = str;
		while ((str = tokenize(endptr, ", ", &endptr)))
			host_add_search(str);
	}

	if ((str = getenv("INTERNAL_IP4_DNS")))	{
		endptr = str;
		while ((str = tokenize(endptr, ", ", &endptr))) {
			ip4addr_aton(str, &dns);
			dns_setserver(dns_count++, &dns);
			free(str);
		}
	}

	while ((c = getopt(argc, argv, "L:D:R:k:m:s:d:i:n:G:p:gh")) != -1) {

		switch (c) {
		case 'L':
			info = parse_conn_info(optarg, 4);
			if (!info)
				print_usage(argv[0]);

			info->next = local;
			local = info;
			break;
		case 'D':
			info = parse_conn_info(optarg, 2);
			if (!info)
				print_usage(argv[0]);

			info->next = socks;
			socks = info;
			break;
		case 'R':
			info = parse_conn_info(optarg, 4);
			if (!info)
				print_usage(argv[0]);

			info->next = remote;
			remote = info;
			break;
		case 'k':
			keep_alive = strtoul(optarg, &endptr, 0);
			if (*endptr)
				print_usage(argv[0]);
			keep_alive *= 1000;
			break;
		case 'm':
			mtu = strtoul(optarg, &endptr, 0);
			if (*endptr)
				print_usage(argv[0]);
			break;
		case 's':
			while ((str = tokenize(optarg, ", ", &optarg)))
				host_add_search(str);
			break;
		case 'd':
			while ((str = tokenize(optarg, ", ", &optarg))) {
				ip4addr_aton(str, &dns);
				dns_setserver(dns_count++, &dns);
				free(str);
			}
			break;
		case 'i':
			ip4addr_aton(optarg, &ipaddr);
			break;
		case 'n':
			ip4addr_aton(optarg, &netmask);
			break;
		case 'G':
			ip4addr_aton(optarg, &gateway);
			break;
#ifdef USE_PCAP
		case 'p':
			pcap_file = strdup(optarg);
			break;
#endif
		case 'g':
			non_local = 1;
			break;
		default:
			print_usage(argv[0]);
		}
	}

	while (local) {
		info = local;
		str = info->bind && info->bind[0] ? info->bind : NULL;
		if (!non_local)
			str = str ? : "localhost";

		if (forward_local(base, str, info->bind_port,
			info->host, info->host_port, keep_alive) < 0)
			return -1;

		local = info->next;
		free_conn_info(info);
	}

	while (socks) {
		info = socks;
		str = info->bind && info->bind[0] ? info->bind : NULL;
		if (!non_local)
			str = str ? : "localhost";
		if (socks_listen(base, str, info->bind_port, keep_alive) < 0)
			return -1;
		socks = socks->next;
		free_conn_info(info);
	}

	while (remote) {
		info = remote;
		if (forward_remote(base, info->bind_port, info->host,
					info->host_port, keep_alive) < 0)
			return -1;
		remote = info->next;
		free_conn_info(info);
	}

	netif = tunif_add(base, fd_in, fd_out, pcap_file);

	netif_set_ipaddr(netif, &ipaddr);
	netif_set_netmask(netif, &netmask);
	netif_set_gw(netif, &gateway);
	if (mtu)
		netif->mtu = mtu;
	netif_set_up(netif);

	event_base_dispatch(base);

	return 0;
}
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;

}
Esempio n. 26
0
int uip_main(int argc, char *argv[])
{
  struct in_addr addr;
#if defined(CONFIG_EXAMPLES_UIP_DHCPC) || defined(CONFIG_EXAMPLES_UIP_NOMAC)
  uint8_t mac[IFHWADDRLEN];
#endif
#ifdef CONFIG_EXAMPLES_UIP_DHCPC
  void *handle;
#endif

/* Many embedded network interfaces must have a software assigned MAC */

#ifdef CONFIG_EXAMPLES_UIP_NOMAC
  mac[0] = 0x00;
  mac[1] = 0xe0;
  mac[2] = 0xde;
  mac[3] = 0xad;
  mac[4] = 0xbe;
  mac[5] = 0xef;
  uip_setmacaddr("eth0", mac);
#endif

  /* Set up our host address */

#ifdef CONFIG_EXAMPLES_UIP_DHCPC
  addr.s_addr = 0;
#else
  addr.s_addr = HTONL(CONFIG_EXAMPLES_UIP_IPADDR);
#endif
  uip_sethostaddr("eth0", &addr);

  /* Set up the default router address */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_UIP_DRIPADDR);
  uip_setdraddr("eth0", &addr);

  /* Setup the subnet mask */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_UIP_NETMASK);
  uip_setnetmask("eth0", &addr);

#ifdef CONFIG_EXAMPLES_UIP_DHCPC
  /* Set up the resolver */

  dns_bind();

  /* Get the MAC address of the NIC */

  uip_getmacaddr("eth0", mac);

  /* Set up the DHCPC modules */

  handle = dhcpc_open(&mac, IFHWADDRLEN);

  /* Get an IP address.  Note:  there is no logic here for renewing the address in this
   * example.  The address should be renewed in ds.lease_time/2 seconds.
   */

  printf("Getting IP address\n");
  if (handle)
    {
        struct dhcpc_state ds;
        (void)dhcpc_request(handle, &ds);
        uip_sethostaddr("eth1", &ds.ipaddr);

        if (ds.netmask.s_addr != 0)
          {
            uip_setnetmask("eth0", &ds.netmask);
          }

        if (ds.default_router.s_addr != 0)
          {
            uip_setdraddr("eth0", &ds.default_router);
          }

        if (ds.dnsaddr.s_addr != 0)
          {
            dns_setserver(&ds.dnsaddr);
          }

        dhcpc_close(handle);
        printf("IP: %s\n", inet_ntoa(ds.ipaddr));
    }
#endif

#ifdef CONFIG_NET_TCP
  printf("Starting webserver\n");
  httpd_init();
  cgi_register();
  httpd_listen();
#endif

  while (1)
    {
      sleep(3);
      printf("uip_main: Still running\n");
#if CONFIG_NFILE_DESCRIPTORS > 0
      fflush(stdout);
#endif
    }

  return 0;
}
Esempio n. 27
0
int discover_main(int argc, char *argv[])
{
  /* If this task is excecutated as an NSH built-in function, then the
   * network has already been configured by NSH's start-up logic.
   */

#ifndef CONFIG_NSH_BUILTIN_APPS
  struct in_addr addr;
#if defined(CONFIG_EXAMPLES_DISCOVER_DHCPC) || defined(CONFIG_EXAMPLES_DISCOVER_NOMAC)
  uint8_t mac[IFHWADDRLEN];
#endif
#ifdef CONFIG_EXAMPLES_DISCOVER_DHCPC
  void *handle;
#endif

/* Many embedded network interfaces must have a software assigned MAC */

#ifdef CONFIG_EXAMPLES_DISCOVER_NOMAC
  mac[0] = 0x00;
  mac[1] = 0xe0;
  mac[2] = 0xde;
  mac[3] = 0xad;
  mac[4] = 0xbe;
  mac[5] = 0xef;
  uip_setmacaddr("eth0", mac);
#endif

  /* Set up our host address */

#ifdef CONFIG_EXAMPLES_DISCOVER_DHCPC
  addr.s_addr = 0;
#else
  addr.s_addr = HTONL(CONFIG_EXAMPLES_DISCOVER_IPADDR);
#endif
  uip_sethostaddr("eth0", &addr);

  /* Set up the default router address */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_DISCOVER_DRIPADDR);
  uip_setdraddr("eth0", &addr);

  /* Setup the subnet mask */

  addr.s_addr = HTONL(CONFIG_EXAMPLES_DISCOVER_NETMASK);
  uip_setnetmask("eth0", &addr);

#ifdef CONFIG_EXAMPLES_DISCOVER_DHCPC
  /* Set up the resolver */

  dns_bind();

  /* Get the MAC address of the NIC */

  uip_getmacaddr("eth0", mac);

  /* Set up the DHCPC modules */

  handle = dhcpc_open(&mac, IFHWADDRLEN);

  /* Get an IP address.  Note:  there is no logic here for renewing the address in this
   * example.  The address should be renewed in ds.lease_time/2 seconds.
   */

  printf("Getting IP address\n");
  if (handle)
    {
      struct dhcpc_state ds;
      (void)dhcpc_request(handle, &ds);
      uip_sethostaddr("eth1", &ds.ipaddr);

      if (ds.netmask.s_addr != 0)
        {
          uip_setnetmask("eth0", &ds.netmask);
        }

      if (ds.default_router.s_addr != 0)
        {
          uip_setdraddr("eth0", &ds.default_router);
        }

      if (ds.dnsaddr.s_addr != 0)
        {
          dns_setserver(&ds.dnsaddr);
        }

      dhcpc_close(handle);
      printf("IP: %s\n", inet_ntoa(ds.ipaddr));
    }

#endif /* CONFIG_EXAMPLES_DISCOVER_DHCPC */
#endif /* CONFIG_NSH_BUILTIN_APPS */

  if (discover_start(NULL) < 0)
    {
      ndbg("Could not start discover daemon.\n");
      return ERROR;
    }

  return OK;
}
Esempio n. 28
0
void tls_netif_dns_setserver(u8 numdns, ip_addr_t *dnsserver)
{
    dns_setserver(numdns, dnsserver);
}
Esempio n. 29
0
/**
 * Change IP configuration settings disabling the dhcp client
 * @param local_ip   Static ip configuration
 * @param gateway    Static gateway configuration
 * @param subnet     Static Subnet mask
 * @param dns1       Static DNS server 1
 * @param dns2       Static DNS server 2
 */
bool ESP8266WiFiSTAClass::config(IPAddress local_ip, IPAddress arg1, IPAddress arg2, IPAddress arg3, IPAddress dns2) {

  if(!WiFi.enableSTA(true)) {
      return false;
  }

  //ESP argument order is: ip, gateway, subnet, dns1
  //Arduino arg order is:  ip, dns, gateway, subnet.

  //first, check whether dhcp should be used, which is when ip == 0 && gateway == 0 && subnet == 0.
  bool espOrderUseDHCP = (local_ip == 0U && arg1 == 0U && arg2 == 0U);
  bool arduinoOrderUseDHCP = (local_ip == 0U && arg2 == 0U && arg3 == 0U);
  if (espOrderUseDHCP || arduinoOrderUseDHCP) {
      _useStaticIp = false;
      wifi_station_dhcpc_start();
      return true;
  }

  //To allow compatibility, check first octet of 3rd arg. If 255, interpret as ESP order, otherwise Arduino order.
  IPAddress gateway = arg1;
  IPAddress subnet = arg2;
  IPAddress dns1 = arg3;

  if(subnet[0] != 255)
  {
    //octet is not 255 => interpret as Arduino order
    gateway = arg2;
    subnet = arg3[0] == 0 ? IPAddress(255,255,255,0) : arg3; //arg order is arduino and 4th arg not given => assign it arduino default
    dns1 = arg1;
  }

  // check whether all is IPv4 (or gateway not set)
  if (!(local_ip.isV4() && subnet.isV4() && (!gateway.isSet() || gateway.isV4()))) {
    return false;
  }

  //ip and gateway must be in the same subnet
  if((local_ip.v4() & subnet.v4()) != (gateway.v4() & subnet.v4())) {
    return false;
  }

  struct ip_info info;
  info.ip.addr = local_ip.v4();
  info.gw.addr = gateway.v4();
  info.netmask.addr = subnet.v4();

  wifi_station_dhcpc_stop();
  if(wifi_set_ip_info(STATION_IF, &info)) {
      _useStaticIp = true;
  } else {
      return false;
  }

  if(dns1.isSet()) {
      // Set DNS1-Server
      dns_setserver(0, dns1);
  }

  if(dns2.isSet()) {
      // Set DNS2-Server
      dns_setserver(1, dns2);
  }

  return true;
}
Esempio n. 30
0
/*********************************************************************************************************
** 函数名称: __tshellIfconfig
** 功能描述: 系统命令 "ifconfig"
** 输 入  : iArgC         参数个数
**           ppcArgV       参数表
** 输 出  : 0
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT  __tshellIfconfig (INT  iArgC, PCHAR  *ppcArgV)
{
    struct netif    *netif;
    struct in_addr   inaddr;
    ip_addr_t        ipaddr;

    if (iArgC == 1) {
        LWIP_NETIF_LOCK();
        __netIfShowAll();                                               /*  打印所有网口信息            */
        LWIP_NETIF_UNLOCK();
        return  (ERROR_NONE);
    
    } else if (iArgC == 2) {
        LWIP_NETIF_LOCK();
        __netIfShow(ppcArgV[1], LW_NULL);                               /*  打印指定网口信息            */
        LWIP_NETIF_UNLOCK();
        return  (ERROR_NONE);
    }

    /*
     *  网络设置
     */
    if (iArgC >= 4) {
        if (lib_strcmp(ppcArgV[1], "dns") == 0) {
            /*
             *  指定 DNS 设置
             */
            INT     iDnsIndex = 0;
            sscanf(ppcArgV[2], "%d", &iDnsIndex);
            if (iDnsIndex >= DNS_MAX_SERVERS) {
                fprintf(stderr, "argments error!\n");
                return  (-ERROR_TSHELL_EPARAM);
            }
            if (inet_aton(ppcArgV[3], &inaddr) == 0) {                  /*  获得 IP 地址                */
                fprintf(stderr, "address error.\n");
                return  (-ERROR_TSHELL_EPARAM);
            }
            ipaddr.addr = inaddr.s_addr;
            dns_setserver((u8_t)iDnsIndex, &ipaddr);                    /*  设置 DNS                    */
        } else {
            /*
             *  指定网络接口设置
             */
            INT     iIndex;
            netif = netif_find(ppcArgV[1]);                             /*  查询网络接口                */
            if (netif == LW_NULL) {
                fprintf(stderr, "can not find net interface.\n");
                return  (-ERROR_TSHELL_EPARAM);
            }
            for (iIndex = 2; iIndex < (iArgC - 1); iIndex += 2) {       /*  连续设置参数                */
                if (inet_aton(ppcArgV[iIndex + 1], &inaddr) == 0) {     /*  获得 IP 地址                */
                    fprintf(stderr, "address error.\n");
                    return  (-ERROR_TSHELL_EPARAM);
                }
                ipaddr.addr = inaddr.s_addr;
                __netIfSet(netif, ppcArgV[iIndex], ipaddr);             /*  设置网络接口                */
            }
        }
    }

    return  (ERROR_NONE);
}