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