void main(int argc, char **argv) { contiki_argc = argc; contiki_argv = argv; #else /* WITH_ARGS */ void main(void) { #endif /* WITH_ARGS */ process_init(); #if 1 ethernet_config = config_read("contiki.cfg"); #else { static struct ethernet_config config = {0xDE08, "cs8900a.eth"}; uip_ipaddr_t addr; uip_ipaddr(&addr, 192,168,0,128); uip_sethostaddr(&addr); uip_ipaddr(&addr, 255,255,255,0); uip_setnetmask(&addr); uip_ipaddr(&addr, 192,168,0,1); uip_setdraddr(&addr); uip_ipaddr(&addr, 192,168,0,1); uip_nameserver_update(&addr, UIP_NAMESERVER_INFINITE_LIFETIME); ethernet_config = &config; } #endif procinit_init(); process_start((struct process *)ðernet_process, (void *)ethernet_config); autostart_start(autostart_processes); log_message("Contiki up and running ...", ""); while(1) { process_run(); etimer_request_poll(); } }
void dhcpc_configured(const struct dhcpc_state *s) { uip_sethostaddr(s->ipaddr); uip_setnetmask(s->netmask); uip_setdraddr(s->default_router); #if CFG_SUPPORT_DNS resolv_conf(s->dnsaddr); resolv_query("www.baidu.com"); #endif }
/*-----------------------------------------------------------------------------------*/ void main(void) { struct ethernet_config *ethernet_config; #if WITH_REBOOT rebootafterexit(); #endif /* WITH_REBOOT */ videomode(VIDEOMODE_80COL); process_init(); #if 1 ethernet_config = config_read("contiki.cfg"); #else { static struct ethernet_config config = {0xC0B0, "cs8900a.eth"}; uip_ipaddr_t addr; uip_ipaddr(&addr, 192,168,0,128); uip_sethostaddr(&addr); uip_ipaddr(&addr, 255,255,255,0); uip_setnetmask(&addr); uip_ipaddr(&addr, 192,168,0,1); uip_setdraddr(&addr); uip_ipaddr(&addr, 192,168,0,1); resolv_conf(&addr); ethernet_config = &config; } #endif procinit_init(); process_start((struct process *)ðernet_process, (char *)ethernet_config); autostart_start(autostart_processes); log_message("Contiki up and running ...", ""); while(1) { process_run(); etimer_request_poll(); clock_update(); } }
int sendmail_main(int argc, char *argv[]) { struct in_addr addr; #if defined(CONFIG_EXAMPLES_SENDMAIL_NOMAC) uint8_t mac[IFHWADDRLEN]; #endif void *handle; printf("sendmail: To: %s\n", g_recipient); printf("sendmail: From: %s\n", g_sender); printf("sendmail: Subject: %s\n", g_subject); printf("sendmail: Body: %s\n", g_msg_body); /* Many embedded network interfaces must have a software assigned MAC */ #ifdef CONFIG_EXAMPLES_SENDMAIL_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 */ addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_IPADDR); uip_sethostaddr("eth0", &addr); /* Set up the default router address */ addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_DRIPADDR); uip_setdraddr("eth0", &addr); /* Setup the subnet mask */ addr.s_addr = HTONL(CONFIG_EXAMPLES_SENDMAIL_NETMASK); uip_setnetmask("eth0", &addr); /* Then send the mail */ uip_ipaddr(addr.s_addr, 127, 0, 0, 1); handle = smtp_open(); if (handle) { smtp_configure(handle, g_host_name, &addr.s_addr); smtp_send(handle, g_recipient, NULL, g_sender, g_subject, g_msg_body, strlen(g_msg_body)); smtp_close(handle); } return 0; }
void Network::dhcpc_configured(uint32_t ipaddr, uint32_t ipmask, uint32_t ipgw) { memcpy(this->ipaddr, &ipaddr, 4); memcpy(this->ipmask, &ipmask, 4); memcpy(this->ipgw, &ipgw, 4); uip_sethostaddr((u16_t*)this->ipaddr); uip_setnetmask((u16_t*)this->ipmask); uip_setdraddr((u16_t*)this->ipgw); setup_servers(); }
void netif_set_addr(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask, struct ip_addr *gw) { uip_ipaddr_t hipaddr; uip_ipaddr(hipaddr, RT_LWIP_IPADDR0,RT_LWIP_IPADDR1,RT_LWIP_IPADDR2,RT_LWIP_IPADDR3); uip_sethostaddr(hipaddr); uip_ipaddr(hipaddr, RT_LWIP_GWADDR0,RT_LWIP_GWADDR1,RT_LWIP_GWADDR2,RT_LWIP_GWADDR3); uip_setdraddr(hipaddr); uip_ipaddr(hipaddr, RT_LWIP_MSKADDR0,RT_LWIP_MSKADDR1,RT_LWIP_MSKADDR2,RT_LWIP_MSKADDR3); uip_setnetmask(hipaddr); return ; }
/*---------------------------------------------------------------------------*/ void dhcpc_configured(const struct dhcpc_state *s) { uip_sethostaddr(s->ipaddr); uip_setdraddr(s->default_router); uip_setnetmask(s->netmask); // uip_udp_remove(s->conn); #ifdef TDTP_SOCKAPP tdtp_init(); #endif }
void dhcpc_configured(const struct dhcpc_state *s) { #ifdef MY_DEBUG //rprintf("IP : %d.%d.%d.%d\n", uip_ipaddr1(s->ipaddr), uip_ipaddr2(s->ipaddr), uip_ipaddr3(s->ipaddr), uip_ipaddr4(s->ipaddr)); //rprintf("NM : %d.%d.%d.%d\n", uip_ipaddr1(s->netmask), uip_ipaddr2(s->netmask), uip_ipaddr3(s->netmask), uip_ipaddr4(s->netmask)); //rprintf("GW : %d.%d.%d.%d\n", uip_ipaddr1(s->default_router), uip_ipaddr2(s->default_router), uip_ipaddr3(s->default_router), uip_ipaddr4(s->default_router)); #endif uip_sethostaddr(s->ipaddr); uip_setnetmask(s->netmask); uip_setdraddr(s->default_router); }
void dhcpc_configured(const struct dhcpc_state *s) { #ifdef XTCP_VERBOSE_DEBUG printf("dhcp: ");uip_printip4(s->ipaddr);printf("\n"); #endif #if UIP_USE_AUTOIP autoip_stop(); #endif uip_sethostaddr(s->ipaddr); uip_setdraddr(s->default_router); uip_setnetmask(s->netmask); uip_xtcp_up(); dhcp_done = 1; }
/*-----------------------------------------------------------------------------------*/ void dhcpc_configured(const struct dhcpc_state *s) { uip_sethostaddr(&s->ipaddr); uip_setnetmask(&s->netmask); uip_setdraddr(&s->default_router); #if WITH_DNS resolv_conf(&s->dnsaddr); #endif /* WITH_DNS */ set_statustext("Configured."); process_post(PROCESS_CURRENT(), PROCESS_EVENT_MSG, NULL); }
void dhcpc_configured(const struct dhcpc_state *s) { if( s->ipaddr[ 0 ] != 0 ) { uip_sethostaddr( s->ipaddr ); uip_setnetmask( s->netmask ); uip_setdraddr( s->default_router ); resolv_conf( ( u16_t* )s->dnsaddr ); elua_uip_configured = 1; } else elua_uip_conf_static(); }
static void elua_uip_conf_static() { uip_ipaddr_t ipaddr; uip_ipaddr( ipaddr, ELUA_CONF_IPADDR0, ELUA_CONF_IPADDR1, ELUA_CONF_IPADDR2, ELUA_CONF_IPADDR3 ); uip_sethostaddr( ipaddr ); uip_ipaddr( ipaddr, ELUA_CONF_NETMASK0, ELUA_CONF_NETMASK1, ELUA_CONF_NETMASK2, ELUA_CONF_NETMASK3 ); uip_setnetmask( ipaddr ); uip_ipaddr( ipaddr, ELUA_CONF_DEFGW0, ELUA_CONF_DEFGW1, ELUA_CONF_DEFGW2, ELUA_CONF_DEFGW3 ); uip_setdraddr( ipaddr ); uip_ipaddr( ipaddr, ELUA_CONF_DNS0, ELUA_CONF_DNS1, ELUA_CONF_DNS2, ELUA_CONF_DNS3 ); resolv_conf( ipaddr ); elua_uip_configured = 1; }
/*-----------------------------------------------------------------------------------*/ struct ethernet_config * CC_FASTCALL config_read(char *filename) { static struct { uip_ipaddr_t hostaddr; uip_ipaddr_t netmask; uip_ipaddr_t draddr; uip_ipaddr_t resolvaddr; struct ethernet_config ethernetcfg; } config; int file; file = cfs_open(filename, CFS_READ); if(file < 0) { log_message(filename, ": File not found"); error_exit(); } if(cfs_read(file, &config, sizeof(config)) < sizeof(config) - sizeof(config.ethernetcfg.name)) { log_message(filename, ": No config file"); error_exit(); } cfs_close(file); log_message("IP Address: ", ipaddrtoa(&config.hostaddr, uip_buf)); log_message("Subnet Mask: ", ipaddrtoa(&config.netmask, uip_buf)); log_message("Def. Router: ", ipaddrtoa(&config.draddr, uip_buf)); log_message("DNS Server: ", ipaddrtoa(&config.resolvaddr, uip_buf)); #ifndef ETHERNET log_message("Eth. Driver: ", config.ethernetcfg.name); #else /* !ETHERNET */ #define _stringize(arg) #arg #define stringize(arg) _stringize(arg) log_message("Eth. Driver: ", stringize(ETHERNET)); #undef _stringize #undef stringize #endif /* !ETHERNET */ log_message("Driver Port: $", utoa(config.ethernetcfg.addr, uip_buf, 16)); uip_sethostaddr(&config.hostaddr); uip_setnetmask(&config.netmask); uip_setdraddr(&config.draddr); #if WITH_DNS resolv_conf(&config.resolvaddr); #endif /* WITH_DNS */ return &config.ethernetcfg; }
void net_conf_uip_set(void) { uip_ipaddr_t ipaddr; uip_ipaddr(ipaddr, net_conf_ip_addr[0], net_conf_ip_addr[1], net_conf_ip_addr[2], net_conf_ip_addr[3]); uip_sethostaddr(ipaddr); uip_ipaddr(ipaddr, net_conf_gateway[0], net_conf_gateway[1], net_conf_gateway[2], net_conf_gateway[3]); uip_setdraddr(ipaddr); uip_ipaddr(ipaddr, net_conf_net_mask[0], net_conf_net_mask[1], net_conf_net_mask[2], net_conf_net_mask[3]); uip_setnetmask(ipaddr); }
void dhcpc_configured(const struct dhcpc_state *s) { uip_sethostaddr(&s->ipaddr); uip_setnetmask(&s->netmask); uip_setdraddr(&s->default_router); /* We don't call resolv_conf here, because that would drag in all the resolver code and state whether or not it's used by the sketch. Instead we pass the address of the DNS server to the DHCP status callback code provided by the sketch and allow that to initialise the resolver if desired. */ // resolv_conf(s->dnsaddr); if (uip.dhcp_status_callback!=NULL) { uip.dhcp_status_callback(DHCP_STATUS_OK, &s->dnsaddr); } }
void dhcpc_configured(const struct dhcpc_state *s) { if(s == 0) { set_eeprom_addr(); return; } ewip(s->ipaddr, EE_IP4_ADDR); uip_sethostaddr(s->ipaddr); ewip(s->default_router, EE_IP4_GATEWAY); uip_setdraddr(s->default_router); ewip(s->netmask, EE_IP4_NETMASK); uip_setnetmask(s->netmask); //resolv_conf(s->dnsaddr); uip_udp_remove(s->conn); ip_initialized(); }
s32 UIP_TASK_NetmaskSet(u32 mask) { uip_ipaddr_t ipaddr; my_netmask = mask; uip_ipaddr(ipaddr, ((mask)>>24) & 0xff, ((mask)>>16) & 0xff, ((mask)>> 8) & 0xff, ((mask)>> 0) & 0xff); uip_setnetmask(ipaddr); return 0; // no error }
/*-----------------------------------------------------------------------------------*/ void main(void) { struct ethernet_config *ethernet_config; clrscr(); bordercolor(BORDERCOLOR); bgcolor(SCREENCOLOR); process_init(); #if 1 ethernet_config = config_read("contiki.cfg"); #else { static struct ethernet_config config = {0xD500, "cs8900a.eth"}; uip_ipaddr_t addr; uip_ipaddr(&addr, 192,168,0,128); uip_sethostaddr(&addr); uip_ipaddr(&addr, 255,255,255,0); uip_setnetmask(&addr); uip_ipaddr(&addr, 192,168,0,1); uip_setdraddr(&addr); uip_ipaddr(&addr, 192,168,0,1); resolv_conf(&addr); ethernet_config = &config; } #endif procinit_init(); process_start((struct process *)ðernet_process, (char *)ethernet_config); autostart_start(autostart_processes); log_message("Contiki up and running ...", ""); while(1) { process_run(); etimer_request_poll(); } }
void zbus_stack_init (void) { uip_ipaddr_t ip; set_CONF_ZBUS_IP(&ip); uip_sethostaddr(&ip); #ifdef IPV6_SUPPORT uip_setprefixlen(CONF_ZBUS_IP6_PREFIX_LEN); #else set_CONF_ZBUS_IP4_NETMASK(&ip); uip_setnetmask(&ip); #endif }
void SerialIPStack::begin(IP_ADDR myIP, IP_ADDR subnet) { uip_ipaddr_t ipaddr; timer_set(&this->periodic_timer, CLOCK_SECOND / 4); slipdev_init(); uip_init(); uip_ipaddr(ipaddr, myIP.a, myIP.b, myIP.c, myIP.d); uip_sethostaddr(ipaddr); uip_ipaddr(ipaddr, subnet.a, subnet.b, subnet.c, subnet.d); uip_setnetmask(ipaddr); }
/*-----------------------------------------------------------------------------------*/ void dhcpc_unconfigured(const struct dhcpc_state *s) { static uip_ipaddr_t nulladdr; uip_sethostaddr(&nulladdr); uip_setnetmask(&nulladdr); uip_setdraddr(&nulladdr); #if WITH_DNS resolv_conf(&nulladdr); #endif /* WITH_DNS */ set_statustext("Unconfigured."); process_post(PROCESS_CURRENT(), PROCESS_EVENT_MSG, NULL); }
/*-----------------------------------------------------------------------------------*/ void config_read(char *filename) { int file; file = cfs_open(filename, CFS_READ); if(file < 0) { log_message(filename, ": File not found"); error_exit(); } if(cfs_read(file, &config, sizeof(config)) < sizeof(uip_ipaddr_t) * 4 + sizeof(uint16_t)) { log_message(filename, ": No config file"); error_exit(); } cfs_close(file); log_message("IP Address: ", ipaddrtoa(&config.hostaddr, uip_buf)); log_message("Subnet Mask: ", ipaddrtoa(&config.netmask, uip_buf)); log_message("Def. Router: ", ipaddrtoa(&config.draddr, uip_buf)); log_message("DNS Server: ", ipaddrtoa(&config.resolvaddr, uip_buf)); #ifdef STATIC_DRIVER #define _stringize(arg) #arg #define stringize(arg) _stringize(arg) #if WITH_SLIP log_message("SLIP Driver: ", stringize(STATIC_DRIVER)); #else /* WITH_SLIP */ log_message("Eth. Driver: ", stringize(STATIC_DRIVER)); #endif /* WITH_SLIP */ #undef _stringize #undef stringize #else /* STATIC_DRIVER */ log_message("Eth. Driver: ", config.ethernet.name); #endif /* STATIC_DRIVER */ #if !WITH_SLIP log_message("Driver Port: $", utoa(config.ethernet.addr, uip_buf, 16)); #endif /* !WITH_SLIP */ uip_sethostaddr(&config.hostaddr); uip_setnetmask(&config.netmask); uip_setdraddr(&config.draddr); #if WITH_DNS uip_nameserver_update(&config.resolvaddr, UIP_NAMESERVER_INFINITE_LIFETIME); #endif /* WITH_DNS */ }
/*---------------------------------------------------------------------------*/ int main(void) { DBGMCU_Config(DBGMCU_SLEEP | DBGMCU_STOP | DBGMCU_STANDBY, ENABLE); leds_init(); //printf("\rStarting Contiki on STM32VL Discovery...\n\r"); clock_init(); process_init(); uip_init(); uip_fw_init(); process_start(&tcpip_process, NULL); process_start(&uip_fw_process, NULL); uip_ipaddr(&hostaddr, 172, 16, 0, 3); uip_sethostaddr(&hostaddr); uip_ipaddr(&netmask, 255, 255, 0, 0); uip_setnetmask(&netmask); uip_ipaddr(&netmask, 172, 16, 0, 1); uip_setdraddr(&draddr); process_start(&etimer_process, NULL); ctimer_init(); /* Networking stack. */ NETSTACK_RADIO.init(); NETSTACK_RDC.init(); NETSTACK_MAC.init(); NETSTACK_NETWORK.init(); { rimeaddr_t rimeaddr; rimeaddr.u8[0] = 0x02; rimeaddr.u8[1] = 0x00; rimeaddr_set_node_addr(&rimeaddr); } autostart_start(autostart_processes); while (1) { process_run(); } return 0; }
void autoip_configured(uip_ipaddr_t autoip_ipaddr) { if (!dhcp_done) { uip_ipaddr_t ipaddr; #ifdef XTCP_VERBOSE_DEBUG printf("ipv4ll: "); uip_printip4(autoip_ipaddr); printf("\n"); #endif /* XTCP_VERBOSE_DEBUG */ uip_sethostaddr(autoip_ipaddr); uip_ipaddr(ipaddr, 255, 255, 0, 0); uip_setnetmask(ipaddr); uip_ipaddr(ipaddr, 0, 0, 0, 0); uip_setdraddr(ipaddr); uip_xtcp_up(); } }
/** * \brief Initialize the uIP startup settings * \param void There are no parameters needed. * \return No return values. */ void ip_init(void) { uip_ipaddr_t ip_addr, subnet; /*Init uIP Stack*/ uip_init(); /*Set IPv4 Address*/ uip_ipaddr(&ip_addr, 192, 168, 2, 2); uip_sethostaddr(&ip_addr); /*Set (IPv4) Subnet*/ uip_ipaddr(&subnet, 255, 255, 255, 0); uip_setnetmask(&subnet); }
///////////////////////////////////////////////////////////////////////////// // Called by DHCP client once it got IP addresses ///////////////////////////////////////////////////////////////////////////// void dhcpc_configured(const struct dhcpc_state *s) { // set IP settings uip_sethostaddr(s->ipaddr); uip_setnetmask(s->netmask); uip_setdraddr(s->default_router); // start services UIP_TASK_StartServices(); // print unused settings MIOS32_MIDI_SendDebugMessage("[UIP_TASK] Got DNS server %d.%d.%d.%d\n", uip_ipaddr1(s->dnsaddr), uip_ipaddr2(s->dnsaddr), uip_ipaddr3(s->dnsaddr), uip_ipaddr4(s->dnsaddr)); MIOS32_MIDI_SendDebugMessage("[UIP_TASK] Lease expires in %d hours\n", (ntohs(s->lease_time[0])*65536ul + ntohs(s->lease_time[1]))/3600); }
/*! \brief Inicia as estruturas com os dados armazenados na memória interna não-volátil */ void appInitHostIp(void) { volatile u16_t addr[2]; //Configura endereço ip local addr[0] = HTONS((((u16_t)memoryData.ipEstatico[0])<< 8) + memoryData.ipEstatico[1]); addr[1] = HTONS((((u16_t)memoryData.ipEstatico[2])<< 8) + memoryData.ipEstatico[3]); uip_sethostaddr(addr); addr[0] = HTONS((((u16_t)memoryData.netMask[0])<< 8) + memoryData.netMask[1]); addr[1] = HTONS((((u16_t)memoryData.netMask[2])<< 8) + memoryData.netMask[3]); uip_setnetmask(addr); addr[0] = memoryData.drAddr[0]; addr[1] = memoryData.drAddr[1]; uip_setdraddr(addr); }
void dhcpc_configured(const struct dhcpc_state *s) { uip_ipaddr_t addr; // byte swap the network info _ip_addr[0] = (s->ipaddr[0]); _ip_addr[1] = (s->ipaddr[0]) >> 8; _ip_addr[2] = (s->ipaddr[1]); _ip_addr[3] = (s->ipaddr[1]) >> 8; _net_mask[0] = (s->netmask[0]); _net_mask[1] = (s->netmask[0]) >> 8; _net_mask[2] = (s->netmask[1]); _net_mask[3] = (s->netmask[1]) >> 8; _gateway[0] = (s->default_router[0]); _gateway[1] = (s->default_router[0]) >> 8; _gateway[2] = (s->default_router[1]); _gateway[3] = (s->default_router[1]) >> 8; #ifdef DHCP_DEBUG eeprom_write_block (_ip_addr, &ee_ip_addr, 4); eeprom_write_block (_net_mask,&ee_net_mask,4); eeprom_write_block (_gateway, &ee_gateway, 4); #endif // re-init just in case uip_setethaddr(my_eth_addr); // set ip uip_ipaddr(&addr, _ip_addr[0], _ip_addr[1], _ip_addr[2], _ip_addr[3]); uip_sethostaddr(&addr); // set netmask uip_ipaddr(&addr,_net_mask[0], _net_mask[1], _net_mask[2], _net_mask[3]); uip_setnetmask(&addr); // set gateway uip_ipaddr(&addr,_gateway[0], _gateway[1], _gateway[2], _gateway[3]); uip_setdraddr(&addr); // code to use dhcp server lease time removed due to uint16_t overflow // issues with calculating the time. Just use 5 minutes instead. timer_set(&dhcp_timer, 5 * 60 * CLOCK_SECOND); }
/*-----------------------------------------------------------------------------------*/ int main(int argc, char **argv) { uip_ipaddr_t addr; gtk_init(&argc, &argv); process_init(); procinit_init(); uip_ipaddr(&addr, 192,168,2,2); uip_sethostaddr(&addr); uip_ipaddr(&addr, 192,168,2,1); uip_setdraddr(&addr); uip_ipaddr(&addr, 255,255,255,0); uip_setnetmask(&addr); /* program_handler_add(&netconf_dsc, "Network setup", 1); program_handler_add(&ftp_dsc, "FTP client", 1); program_handler_add(&editor_dsc, "Editor", 1); program_handler_add(&www_dsc, "Web browser", 1); program_handler_add(&processes_dsc, "Processes", 1); program_handler_add(&shell_dsc, "Command shell", 1); program_handler_add(&calc_dsc, "Calculator", 1);*/ /* program_handler_add(&email_dsc, "E-mail", 1);*/ /* program_handler_add(&irc_dsc, "IRC", 1);*/ /* program_handler_add(&vnc_dsc, "VNC client", 1);*/ /* program_handler_add(&dhcp_dsc, "DHCP client", 1);*/ uip_fw_default(&tapif); gtk_timeout_add(20, idle_callback, NULL); gtk_main(); return 0; argv = argv; argc = argc; }
/** * @brief Configure Network * @param None * @retval None */ void Network_Configuration(void) { struct uip_eth_addr mac = {{ 0xeb, 0xa0, 0x00, 0x00, 0x00, 0x00 }}; enc28j60_init(mac.addr); uip_init(); uip_arp_init(); uip_setethaddr(mac); uip_ipaddr_t ipaddr; uip_ipaddr(ipaddr, 192, 168, 0, 100); uip_sethostaddr(ipaddr); uip_ipaddr(ipaddr, 255, 255, 255, 0); uip_setnetmask(ipaddr); uip_ipaddr(ipaddr, 192, 168, 0, 1); uip_setdraddr(ipaddr); uip_listen(HTONS(4000)); }