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;
}
int main(void)
{
#ifdef NUT_OS
NutRegisterDevice(&DEV_CONSOLE, 0, 0);
freopen(DEV_CONSOLE.dev_name, "w", stdout);
#endif
puts("uHTTP form sample\nBuild " __DATE__ " " __TIME__);
#ifdef NUT_OS
NutRegisterDevice(&DEV_ETHER, 0, 0);
NutDhcpIfConfig(DEV_ETHER_NAME, NULL, 60000);
NutRegisterDevice(&devUrom, 0, 0);
#endif
StreamInit();
MediaTypeInitDefaults();
HttpRegisterRedir("", "/index.html", 301);
HttpRegisterCgiFunction("getform.cgi", CgiGetForm);
HttpRegisterCgiFunction("postform.cgi", CgiPostForm);
HttpRegisterMediaType("cgi", NULL, NULL, HttpCgiFunctionHandler);
StreamClientAccept(HttpdClientHandler, NULL);
puts("Exit");
#ifdef NUT_OS
for (;;) ;
#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;
}
void RegisterDevice()
{
printf("Registering ethernet port. \n");
if (NutRegisterDevice(&DEV_ETHER, 0, 0)) {
printf("Registering failed.");
}
else if (NutDhcpIfConfig(DEV_ETHER_NAME, NULL, 0))
{
printf("Connected");
}
printf("registering donge");
printf("Receive time from: pool.ntp.org");
timeserver = inet_addr("213.154.229.24");
}
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;
}
/*!
* \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;
}
/*
* Main application routine.
*
* Nut/OS automatically calls this entry after initialization.
*/
int main(void)
{
uint32_t baud = 115200;
/* IP of the local network in host byte order. */
uint32_t net_ip;
/* Currently scanned IP in host byte order. */
uint32_t scan_ip;
/* Currently scanned IP in network byte order. */
uint32_t dest;
/* Host portion mask in host byte order. */
uint32_t host_mask;
/* Current echo request sequence number. */
uint16_t seq = 0;
/*
* Assign stdout to the DEBUG device.
*/
NutRegisterDevice(&DEV_CONSOLE, 0, 0);
freopen(DEV_CONSOLE.dev_name, "w", stdout);
_ioctl(_fileno(stdout), UART_SETSPEED, &baud);
/*
* Print out our version information.
*/
printf("\n\nNut/OS %s\n", NutVersionString());
printf("PingNet %s " __DATE__ " " __TIME__ "\n", APP_VERSION);
/*
* Configure the network interface. It is assumed, that
* we got a valid configuration in non-volatile memory.
*
* For alternatives see
* http://www.ethernut.de/nutwiki/Network_Configuration
*/
printf("Configure %s...", DEV_ETHER_NAME);
if (NutRegisterDevice(&DEV_ETHER, 0, 0)) {
FatalError("failed");
}
if (NutDhcpIfConfig("eth0", 0, 60000)) {
FatalError("no valid network configuration");
}
printf("%s ready\n", inet_ntoa(confnet.cdn_ip_addr));
/* Some Ethernet device drivers seem to return from initialization
even if they are not fully up and running. Typically this is no
problem, because upper layers will do retries. However, in our
special case we'd lose some nodes during the first scan. So just
take a short nap to give the driver some more time. */
NutSleep(2000);
/*
* Register an ICMP callback function to inspect all incoming
* ICMP packets.
*/
if (NutRegisterIpHandler(IPPROTO_ICMP, IcmpCallback)) {
FatalError("failed to register ICMP callback");
}
/*
* Determine the host portion mask and the IP of the local
* network from our IP configuration. Note, that Nut/Net
* stores all IP address items in network byte order.
*/
host_mask = ~ntohl(confnet.cdn_ip_mask);
net_ip = ntohl(confnet.cdn_ip_addr) & ~host_mask;
/*
* Allocate a bit field to store the state of all possible
* nodes of our local network. Limit this to 2^16 (class B)
* and also reject point to point configurations.
*/
if (host_mask > 0xFFFF || host_mask < 0x0003) {
FatalError("Bad network size");
}
upnodes = calloc((host_mask + 1) / 8, 1);
if (upnodes == NULL) {
FatalError("out of memory");
}
/*
* Scan the whole network endlessly.
*/
for (;;) {
int retries = 0;
seq++;
scan_ip = net_ip;
/*
* Scan node by node.
*/
for (;;) {
int got = 0;
/* If this is not a retry, move to the next possible node
address. */
if (retries == 0) {
scan_ip++;
}
/* All nodes processed if we reached the broadcast address. */
if ((scan_ip & host_mask) == host_mask) {
break;
}
/* Send an echo request to the current IP (network byte order). */
dest = htonl(scan_ip);
printf("\r%s ", inet_ntoa(dest));
if (IcmpSendPing(dest, 1, seq, 32) == 0) {
/* Wait until our ICMP handler signals new packets. */
while (got == 0 && NutEventWait(&sign_queue, 100) == 0) {
/* Inspect all queued packets. */
while (nbuf_queue) {
NETBUF *nb;
IPHDR *ip = (IPHDR *) nbuf_queue->nb_nw.vp;
/* Check if this packet is from the currently scanned
node address. We may additionally check ID and
sequence number, but actually anything from that
interface will be just fine to mark it as up. */
got += (ip->ip_src == dest);
nb = nbuf_queue;
nbuf_queue = nb->nb_next;
NutNetBufFree(nb);
}
}
if (NODE_IS_UP(scan_ip & host_mask)) {
/* If the node has been up and is now down, then
do a few retries first to be sure that it is
really not responding anymore. */
if (got == 0) {
if (retries < 3) {
retries++;
} else {
retries = 0;
NODE_DOWN(scan_ip & host_mask);
puts("down");
}
}
}
else if (got) {
/* New node detected. */
NODE_UP(scan_ip & host_mask);
puts("up");
}
} else {
/* Failed to send out the request. */
puts("ICMP transmit error");
}
}
/* Sleep one minute before scanning the network again. */
printf("\rSleeping ");
NutSleep(60000);
}
/* Never reached, but required to suppress compiler warning. */
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;
}
