int initNetworkDHCP(){ int retval; if (NutRegisterDevice(&DEV_ETHER, 0, 0)) { LogMsg_P(LOG_INFO, PSTR("Registering ethernet failed.")); retval = 1; } else if (NutDhcpIfConfig(DEV_ETHER_NAME, NULL, 0)) { uint8_t initial_mac[6] = MY_MAC; if (NutDhcpIfConfig(DEV_ETHER_NAME, initial_mac, 0)) { u_long initial_ip_addr = inet_addr(MY_IP); u_long initial_ip_mask = inet_addr(MY_MASK); NutNetIfConfig(DEV_ETHER_NAME, initial_mac, initial_ip_addr, initial_ip_mask); retval = 2; } } if (NutRegisterDiscovery(INADDR_BROADCAST, 0, DISF_INITAL_ANN)) { //printf("Discover Service failed"); LogMsg_P(LOG_INFO, PSTR("Discover Service failed")); retval = 3; } else { LogMsg_P(LOG_INFO, PSTR("Ethernet Startup Message: OK")); LogMsg_P(LOG_INFO, PSTR("IP = [%d],[%d],[%d],[%d]")); default_handler = NutRegisterDiscoveryCallback(MyHandler); retval = 4; } return retval; }
bool Network_init(NH * nh) { int i = 0; for(;;) { i++; printf("Registering %s... ", DEV_ETHER_NAME); NutSleep(500); if(NutRegisterDevice(&DEV_ETHER, 0, 0) == 0) { printf("ok\n"); break; } printf("Failed, retry\n"); if ( i > 2 ) return false; } int ip_end = rand()%128+1; char ip[12]; sprintf(ip, "10.10.7.%d", ip_end); uint8_t mac[6] = {0x00, 0x06, 0x98, 0x30, 0x00, ip_end}; printf("configuring... "); NutNetIfConfig(DEV_ETHER_NAME, mac, inet_addr(ip), inet_addr(NMASK)); printf("IP: %s\n\n\n", inet_ntoa(inet_addr(ip))); NutSleep(2000); printf("ok\n"); fflush(stdout); printf("Creating Udp socket... "); if ((nh->udpSock = NutUdpCreateSocket(SNMP_PORT)) == 0) { printf("failed\n"); } printf("ok\n"); printf("Creating Udp TRAP socket... "); if ((nh->udpTrapSock = NutUdpCreateSocket(TRAP_PORT)) == 0) { printf("failed\n"); } printf("ok\n"); //allocate room for packets and values SNMP_packetPool = (snmpPacket**)malloc(PACKETPOOL_SIZE * sizeof(snmpPacket*)); for(i = 0; i < PACKETPOOL_SIZE; i++) SNMP_packetPool[i] = (snmpPacket*)malloc(sizeof(snmpPacket)); SNMP_valuePool = (uint8_t*)malloc(VALUEPOOL_SIZE * sizeof(uint8_t)); PP_ptr = 0; VP_ptr = 0; VP_reserved = 0; PP_reserved = 0; SNMP_valuePool[215] = 'G'; //DEBUG //printf("PP_ptr: %d, valuepool[0]: %d, valuepool[215]: %c\n", PP_ptr, SNMP_valuePool[0], SNMP_valuePool[215]); //DEBUG NutThreadCreate("udpReceiveThread", udpReceiveThread, nh, 1024); NutThreadCreate("udpTrapReceiveThread", udpTrapReceiveThread, nh, 756); printf("ok\n"); return true; }
static int ProtocolPortConfigure(void) { #ifdef PPP_DEV PPPDCB *dcb; /* * We are connected, configure our PPP network interface. * This will initiate the PPP configuration negotiation * and authentication with the server. */ printf("Configure network interface..."); if (NutNetIfConfig("ppp", 0, 0, 0)) { puts("failed"); return -1; } puts("done"); /* * Set name server and default route. Actually the PPP interface * should do this, but the current release doesn't. */ dcb = devPpp.dev_dcb; NutDnsConfig2(0, 0, dcb->dcb_ip_dns1, dcb->dcb_ip_dns2); NutIpRouteAdd(0, 0, dcb->dcb_remote_ip, &devPpp); /* * Display our IP settings. */ printf(" Local IP: %s\n", inet_ntoa(dcb->dcb_local_ip)); printf(" Remote IP: %s\n", inet_ntoa(dcb->dcb_remote_ip)); printf(" Primary DNS: %s\n", inet_ntoa(dcb->dcb_ip_dns1)); printf("Secondary DNS: %s\n", inet_ntoa(dcb->dcb_ip_dns2)); #else /* We use DHCP on Ethernet. */ printf("Configure network interface..."); if (NutDhcpIfConfig(DEV_ETHER_NAME, 0, 60000)) { puts("failed"); return -1; } puts("done"); #endif return 0; }
/* * Main application routine. * * Nut/OS automatically calls this entry after initialization. */ int main(void) { uint8_t my_mac[] = MY_MAC; /* * Initialize digital I/O. */ init_dio(); #ifdef DEV_ETHER /* * Register Realtek controller at address 8300 hex * and interrupt 5. */ NutRegisterDevice(&DEV_ETHER, 0x8300, 5); /* * Configure lan interface. */ if (NutDhcpIfConfig(DEV_ETHER_NAME, 0, 60000) && NutDhcpIfConfig("eth0", my_mac, 60000)) { /* * No DHCP server available. Use hard coded values. */ uint32_t ip_addr = inet_addr(MY_IP); /* ICCAVR fix. */ NutNetIfConfig("eth0", my_mac, ip_addr, inet_addr(MY_MASK)); } /* * Start another service thread to allow * two concurrent connections. */ NutThreadCreate("sback", service_thread, 0, 1384); for (;;) service(); #endif /* DEV_ETHER */ return 0; }
int initNetworkStatic(){ int returnmsg; uint8_t mac[6] = MY_MAC; uint32_t ip_addr = inet_addr(MY_IP); uint32_t ip_mask = inet_addr(MY_MASK); if (NutRegisterDevice(&DEV_ETHER, 0, 0)) { //Registering failed returnmsg = 0; } // Configure network. else if (NutNetIfConfig(DEV_ETHER_NAME, mac, ip_addr, ip_mask)) { //Configuring failed returnmsg = 1; } // Done. else { //OK returnmsg = 2; } return returnmsg; }
/*! * \brief Configure Ethernut LAN interface. * * If the EEPROM contains a valid network configuration, then it will * be used. Otherwise DHCP is queried using a hard coded MAC address * (global macro MY_MAC). If there is no DHCP server available, then * the hard coded IP settings will be used (global macros MY_IPADDR, * MY_IPMASK and MY_IPGATE). * * \param devname Symbolic name of the network device. */ int ConfigureLan(char *devname) { /* * Calling DHCP without MAC address assumes, that we have a valid * configuration in EEPROM. */ puts("configure devname"); printf("Configure %s...", devname); if (NutDhcpIfConfig(devname, NULL, 60000)) { u_char mac[6] = MY_MAC; puts("Failed to get IP from dhcp"); /* * DHCP failed. Either because the EEPROM contained no valid * MAC address or because we can't contact DHCP. We try again * with our hard coded MAC address. */ puts("hard coded MAC..."); if (NutDhcpIfConfig(devname, mac, 60000)) { u_long ip_addr = inet_addr(MY_IPADDR); u_long ip_mask = inet_addr(MY_IPMASK); u_long ip_gate = inet_addr(MY_IPGATE); /* * Network configuration failed again. Give up DHCP and * try the hard coded IP configuration. */ puts("hard coded IP..."); if (NutNetIfConfig(devname, mac, ip_addr, ip_mask)) { /* * If even this one fails, then something is completely * wrong. Return an error. */ puts("Error: No LAN device"); return -1; } if (ip_gate) { /* * Without DHCP we had to set the default gateway manually. */ puts("hard coded gate..."); if (NutIpRouteAdd(0, 0, ip_gate, &DEV_ETHER) == 0) { puts("Error: Can't set gateway"); return -1; } } } } else{ puts("Got IP from DHCP"); } /* * Display the result of our LAN configuration. */ puts("OK"); printf("MAC : %02X-%02X-%02X-%02X-%02X-%02X\n", confnet.cdn_mac[0], confnet.cdn_mac[1], confnet.cdn_mac[2], confnet.cdn_mac[3], confnet.cdn_mac[4], confnet.cdn_mac[5]); printf("IP : %s\n", inet_ntoa(confnet.cdn_ip_addr)); printf("Mask: %s\n", inet_ntoa(confnet.cdn_ip_mask)); printf("Gate: %s\n\n", inet_ntoa(confnet.cdn_gateway)); return 0; }
/* * Main application routine. * * Nut/OS automatically calls this entry after initialization. */ int main(void) { TCPSOCKET *sock; CHANNEL cd; uint32_t baud = 9600; /* * Register our devices. */ NutRegisterDevice(&DEV_UART, 0, 0); #ifndef DEV_ETHER for (;;); #else NutRegisterDevice(&DEV_ETHER, 0x8300, 5); /* * Setup the uart device. */ cd.cd_rs232 = fopen(DEV_UART_NAME, "r+b"); _ioctl(_fileno(cd.cd_rs232), UART_SETSPEED, &baud); /* * Setup the ethernet device. Try DHCP first. If this is * the first time boot with empty EEPROM and no DHCP server * was found, use hardcoded values. */ if (NutDhcpIfConfig(DEV_ETHER_NAME, 0, 60000)) { /* No valid EEPROM contents, use hard coded MAC. */ uint8_t my_mac[] = { 0x00, 0x06, 0x98, 0x20, 0x00, 0x00 }; if (NutDhcpIfConfig("eth0", my_mac, 60000)) { /* No DHCP server found, use hard coded IP address. */ uint32_t ip_addr = inet_addr("192.168.192.100"); uint32_t ip_mask = inet_addr("255.255.255.0"); NutNetIfConfig("eth0", my_mac, ip_addr, ip_mask); /* If not in a local network, we must also call NutIpRouteAdd() to configure the routing. */ } } /* * Start a RS232 receiver thread. */ NutThreadCreate("xmit", Receiver, &cd, 512); /* * Now loop endless for connections. */ cd.cd_connected = 0; for (;;) { /* * Create a socket and listen for a client. */ sock = NutTcpCreateSocket(); NutTcpAccept(sock, TCPPORT); /* * Open a stdio stream assigned to the connected socket. */ cd.cd_tcpip = _fdopen((int) sock, "r+b"); cd.cd_connected = 1; /* * Call RS232 transmit routine. On return we will be * disconnected again. */ StreamCopy(cd.cd_tcpip, cd.cd_rs232, &cd.cd_connected); /* * Close the stream. */ fclose(cd.cd_tcpip); /* * Close our socket. */ NutTcpCloseSocket(sock); } #endif return 0; }
/*! \fn Service(void *arg) * \brief HTTP service thread. * * The endless loop in this thread waits for a client connect, * processes the HTTP request and disconnects. Nut/Net doesn't * support a server backlog. If one client has established a * connection, further connect attempts will be rejected. * Typically browsers open more than one connection in order * to load images concurrently. So we run this routine by * several threads. * */ THREAD(Service, arg) { TCPSOCKET *sock; FILE *stream; uint8_t id = (uint8_t) ((uintptr_t) arg); /* * Now loop endless for connections. */ for (;;) { /* * Create a socket. */ if ((sock = NutTcpCreateSocket()) == 0) { printf("[%u] Creating socket failed\n", id); NutSleep(5000); continue; } /* * Listen on port 80. This call will block until we get a connection * from a client. */ NutTcpAccept(sock, 80); #if defined(__AVR__) printf("[%u] Connected, %u bytes free\n", id, NutHeapAvailable()); #else printf("[%u] Connected, %lu bytes free\n", id, NutHeapAvailable()); #endif /* * Wait until at least 8 kByte of free RAM is available. This will * keep the client connected in low memory situations. */ #if defined(__AVR__) while (NutHeapAvailable() < 8192) { #else while (NutHeapAvailable() < 4096) { #endif printf("[%u] Low mem\n", id); NutSleep(1000); } /* * Associate a stream with the socket so we can use standard I/O calls. */ if ((stream = _fdopen((int) ((uintptr_t) sock), "r+b")) == 0) { printf("[%u] Creating stream device failed\n", id); } else { /* * This API call saves us a lot of work. It will parse the * client's HTTP request, send any requested file from the * registered file system or handle CGI requests by calling * our registered CGI routine. */ NutHttpProcessRequest(stream); /* * Destroy the virtual stream device. */ fclose(stream); } /* * Close our socket. */ NutTcpCloseSocket(sock); printf("[%u] Disconnected\n", id); } } #endif /* DEV_ETHER */ /*! * \brief Main application routine. * * Nut/OS automatically calls this entry after initialization. */ int main(void) { uint32_t baud = 115200; uint8_t i; /* * Initialize the uart device. */ NutRegisterDevice(&DEV_DEBUG, 0, 0); freopen(DEV_DEBUG_NAME, "w", stdout); _ioctl(_fileno(stdout), UART_SETSPEED, &baud); NutSleep(200); printf("\n\nNut/OS %s HTTP Daemon...", NutVersionString()); #ifdef DEV_ETHER #ifdef NUTDEBUG NutTraceTcp(stdout, 0); NutTraceOs(stdout, 0); NutTraceHeap(stdout, 0); NutTracePPP(stdout, 0); #endif /* * Register Ethernet controller. */ if (NutRegisterDevice(&DEV_ETHER, 0, 0)) { puts("Registering device failed"); } printf("Configure %s...", DEV_ETHER_NAME); if (NutNetLoadConfig(DEV_ETHER_NAME)) { uint8_t mac[] = MY_MAC; printf("initial boot..."); #ifdef USE_DHCP if (NutDhcpIfConfig(DEV_ETHER_NAME, mac, 60000)) #endif { uint32_t ip_addr = inet_addr(MY_IPADDR); uint32_t ip_mask = inet_addr(MY_IPMASK); uint32_t ip_gate = inet_addr(MY_IPGATE); printf("No DHCP..."); if (NutNetIfConfig(DEV_ETHER_NAME, mac, ip_addr, ip_mask) == 0) { /* Without DHCP we had to set the default gateway manually.*/ if(ip_gate) { printf("hard coded gate..."); NutIpRouteAdd(0, 0, ip_gate, &DEV_ETHER); } puts("OK"); } else { puts("failed"); } } } else { #ifdef USE_DHCP if (NutDhcpIfConfig(DEV_ETHER_NAME, 0, 60000)) { puts("failed"); } else { puts("OK"); } #else if (NutNetIfConfig(DEV_ETHER_NAME, 0, 0, confnet.cdn_ip_mask)) { puts("failed"); } else { puts("OK"); } #endif } printf("%s ready\n", inet_ntoa(confnet.cdn_ip_addr)); #ifdef USE_DISCOVERY NutRegisterDiscovery((uint32_t)-1, 0, DISF_INITAL_ANN); #endif /* * Register our device for the file system. */ NutRegisterDevice(&MY_FSDEV, 0, 0); #ifdef MY_BLKDEV /* Register block device. */ printf("Registering block device '" MY_BLKDEV_NAME "'..."); if (NutRegisterDevice(&MY_BLKDEV, 0, 0)) { puts("failed"); for (;;); } puts("OK"); /* Mount partition. */ printf("Mounting block device '" MY_BLKDEV_NAME ":1/" MY_FSDEV_NAME "'..."); if (_open(MY_BLKDEV_NAME ":1/" MY_FSDEV_NAME, _O_RDWR | _O_BINARY) == -1) { puts("failed"); for (;;); } puts("OK"); #endif #ifdef MY_HTTPROOT /* Register root path. */ printf("Registering HTTP root '" MY_HTTPROOT "'..."); if (NutRegisterHttpRoot(MY_HTTPROOT)) { puts("failed"); for (;;); } puts("OK"); #endif NutRegisterCgiBinPath("cgi-bin/;user/cgi-bin/;admin/cgi-bin/"); /* * Register our CGI sample. This will be called * by http://host/cgi-bin/test.cgi?anyparams */ NutRegisterCgi("test.cgi", ShowQuery); #if defined(USE_SSI) /* * Register a cgi included by the ssi demo. This will show how dynamic * content is included in a ssi page and how the request parameters for * a site are passed down to the included cgi. */ NutRegisterCgi("ssi-demo.cgi", SSIDemoCGI); #endif /* * Register some CGI samples, which display interesting * system informations. */ NutRegisterCgi("threads.cgi", ShowThreads); NutRegisterCgi("timers.cgi", ShowTimers); NutRegisterCgi("sockets.cgi", ShowSockets); /* * Finally a CGI example to process a form. */ NutRegisterCgi("form.cgi", ShowForm); /* * Protect the cgi-bin directory with * user and password. */ NutRegisterAuth("admin", "root:root"); NutRegisterAuth("user", "user:user"); /* * Register SSI and ASP handler */ #if defined(USE_SSI) NutRegisterSsi(); #endif #if defined(USE_ASP) NutRegisterAsp(); NutRegisterAspCallback(ASPCallback); #endif /* * Start four server threads. */ for (i = 1; i <= 4; i++) { char thname[] = "httpd0"; thname[5] = '0' + i; NutThreadCreate(thname, Service, (void *) (uintptr_t) i, (HTTPD_SERVICE_STACK * NUT_THREAD_STACK_MULT) + NUT_THREAD_STACK_ADD); } #endif /* DEV_ETHER */ /* * We could do something useful here, like serving a watchdog. */ NutThreadSetPriority(254); for (;;) { NutSleep(60000); } return 0; }
/* * Main application routine. * */ int main(void) { uint32_t baud = 115200; UDPSOCKET *socket; uint32_t ip_addr; uint32_t ip_udp_echo; int rc; int error; int packet_nr; uint16_t length; /* * Initialize the uart device. */ NutRegisterDevice(&DEV_DEBUG, 0, 0); freopen(DEV_DEBUG_NAME, "w", stdout); _ioctl(_fileno(stdout), UART_SETSPEED, &baud); puts("Demo for ICMP support in UDP sockets...\r\n"); #ifdef DEV_ETHER #ifndef NUT_UDP_ICMP_SUPPORT #warning ICMP support for UDP sockets not enabled in the configurator, please enable NUT_UDP_ICMP_SUPPORT puts("ICMP support for UDP sockets not enabled in the configurator\r\n"); puts("Please enable NUT_UDP_ICMP_SUPPORT\r\n"); #endif /* * Register the network device. */ puts("Configuring Ethernet interface"); NutRegisterDevice(&DEV_ETHER, 0, 0); ip_addr = inet_addr(MY_IP); NutNetIfConfig("eth0", my_mac, ip_addr, inet_addr(MY_MASK)); NutIpRouteAdd(0, 0, inet_addr(MY_GATE), &DEV_ETHER); printf("%s ready\r\n", inet_ntoa(ip_addr)); socket = NutUdpCreateSocket(UDP_ECHO_PORT); if (socket == 0) { printf("Could not create UDP socket in port '%d'\r\n", UDP_ECHO_PORT); puts("Demo halted...\r\n"); while (1); } else { printf("Successfully created UDP socket on port '%d'\r\n", UDP_ECHO_PORT); length = UDP_BUFF_SIZE; if (NutUdpSetSockOpt(socket, SO_RCVBUF, &length, sizeof(length))) {; printf("Could not set UDP receive buffer size (%d)\r\n", length); puts("Demo halted...\r\n"); while (1); } } if (NutThreadCreate("RCV", UDPReceiver, (void*)socket, 1024) == 0) { puts("Could not start receiver thread\r\n"); puts("Demo halted...\r\n"); while (1); } else { puts("Receiver thread started\r\n"); } puts("Starting echo test (1 packet / second)\r\n"); ip_udp_echo = inet_addr(UDP_ECHO_IP); packet_nr = 0; while (1) { packet_nr ++; sprintf(send_buffer, "Packet: %d", packet_nr); rc = NutUdpSendTo(socket, ip_udp_echo, UDP_ECHO_PORT, send_buffer, length); printf("--> Sended packet: \"%s\", to %s, rc: %d\r\n", send_buffer, inet_ntoa(ip_udp_echo), rc); if (rc < 0) { uint32_t remote_ip; uint16_t remote_port; error = NutUdpError(socket, &remote_ip, &remote_port); print_udp_icmp_error(remote_ip, remote_port, error); } NutSleep(1000); } #endif /* DEV_ETHER */ return 0; }