Functonal webserver with supporting code changes. WIP COMMIT
authorPaul Pearce <pearce@eecs.berkeley.edu>
Fri, 19 Feb 2010 19:19:44 +0000 (14:19 -0500)
committerKevin Klues <klueska@ros-dev.(none)>
Wed, 24 Mar 2010 19:07:52 +0000 (12:07 -0700)
This commit includes a functional webserver (that serves 1 page)
along with all the required code changes to support it.

This commit BREAKS remote system calls on x86, as well as the
ne2k driver.

This is meant to be a checkpoint on the path before merging into
master.

21 files changed:
kern/arch/i386/ne2k.c
kern/arch/i386/nic_common.c
kern/arch/i386/nic_common.h
kern/arch/i386/rl8168.c
kern/arch/i386/rl8168.h
kern/include/ros/syscall.h
kern/src/Makefrag
kern/src/kfs.c
kern/src/manager.c
kern/src/syscall.c
user/apps/parlib/httpserver.c [new file with mode: 0644]
user/apps/parlib/lock_test.c [new file with mode: 0644]
user/apps/parlib/ping.c [deleted file]
user/lwip/Makefrag
user/lwip/core/sys_arch.c
user/lwip/include/lwip/lwipopts.h
user/lwip/include/netif/ethernetif.h
user/lwip/netif/ethernetif.c
user/parlib/inc/parlib.h
user/parlib/src/i386/newlib_backend.c
user/parlib/src/syscall.c

index ea6d2fd..6757174 100644 (file)
@@ -390,6 +390,7 @@ void ne2k_handle_rx_packet() {
                extern char* packet_buffer;
                extern char* packet_buffer_orig;
 
+#if 0
                if (packet_waiting) return;
                
                // So ugly I want to cry
@@ -403,7 +404,7 @@ void ne2k_handle_rx_packet() {
                packet_buffer_pos = 0;
                
                packet_waiting = 1;
-                                               
+#endif                         
                return;
        }
        
index aa525a6..6fa5433 100644 (file)
 uint8_t eth_up = 0; 
 
 // Hacky stuff for syscall hack. Go away.
-int packet_waiting;
-int packet_buffer_size;
-char *CT(MAX_FRAME_SIZE - PACKET_HEADER_SIZE) packet_buffer;
-char *CT(MAX_FRAME_SIZE) packet_buffer_orig;
-int packet_buffer_pos = 0;
+uint32_t packet_buffer_count = 0;
+char* packet_buffer[PACKET_BUFFER_SIZE];
+uint32_t packet_buffer_sizes[PACKET_BUFFER_SIZE];
+uint32_t packet_buffer_head = 0;
+uint32_t packet_buffer_tail = 0;
+spinlock_t packet_buffer_lock = SPINLOCK_INITIALIZER;
+
 
 char* (*packet_wrap)(const char *CT(len) data, size_t len);
 int (*send_frame)(const char *CT(len) data, size_t len);
index 4fba183..79e7cdd 100644 (file)
@@ -20,6 +20,8 @@
 // v----- Evil line ------v
 // Hacky stuff for syscalls go away.
 
+#define PACKET_BUFFER_SIZE 1024
+
 struct ETH_Header
 {
        char dest_mac[6];
index dc94139..00c6bb0 100644 (file)
@@ -95,11 +95,12 @@ uint32_t rx_des_cur = 0;
 uint32_t tx_des_cur = 0;
 
 extern int eth_up;
-extern int packet_waiting;
-extern int packet_buffer_size;
-extern char *CT(MAX_FRAME_SIZE - PACKET_HEADER_SIZE) packet_buffer;
-extern char *CT(MAX_FRAME_SIZE) packet_buffer_orig;
-extern int packet_buffer_pos;
+extern uint32_t packet_buffer_count;
+extern char* packet_buffer[PACKET_BUFFER_SIZE];
+extern uint32_t packet_buffer_sizes[PACKET_BUFFER_SIZE];
+extern uint32_t packet_buffer_head;
+extern uint32_t packet_buffer_tail;
+spinlock_t packet_buffer_lock;
 
 extern char *CT(PACKET_HEADER_SIZE + len) (*packet_wrap)(const char *CT(len) data, size_t len);
 extern int (*send_frame)(const char *CT(len) data, size_t len);
@@ -355,7 +356,7 @@ void rl8168_setup_interrupts() {
 // We need to evaluate this routine in terms of concurrency.
 // We also need to figure out whats up with different core interrupts
 void rl8168_interrupt_handler(trapframe_t *tf, void* data) {
-       
+
        rl8168_interrupt_debug("\nNic interrupt on core %u!\n", lapic_get_id());
                                
        // Read the offending interrupt(s)
@@ -423,6 +424,7 @@ void rl8168_interrupt_handler(trapframe_t *tf, void* data) {
        // In the event that we got really unlucky and more data arrived after we set 
        //  set the bit last, try one more check
        rl8168_handle_rx_packet();
+
        return;
 }
 
@@ -517,46 +519,28 @@ void rl8168_handle_rx_packet() {
                
        } while (!(current_command & DES_LS_MASK));
        
-       // Hack for UDP syscall hack. 
-       // This is a quick hack to let us deal with where to put packets coming in. This is not concurrency friendly
-       // In the event that we get 2 incoming frames for our syscall test (shouldnt happen)
-       // We cant process more until another packet comes in. This is ugly, but this code goes away as soon as we integrate a real stack.
-       // This keys off the source port, fix it for dest port. 
-       // Also this may access packet regions that are wrong. If someone addresses empty packet for our interface
-       // and the bits that happened to be in memory before are the right port, this will trigger. this is bad
-       // but since syscalls are a hack for only 1 machine connected, we dont care for now.
-       
-       if ((current_command & DES_PAM_MASK) && (*((uint16_t*)(rx_buffer + 36)) == 0x9bad)) {
-               
-               if (packet_waiting) return;
-               
-               // So ugly I want to cry
-               packet_buffer_size = *((uint16_t*)(rx_buffer + 38)); 
-               packet_buffer_size = (((uint16_t)packet_buffer_size & 0xff00) >> 8) |  (((uint16_t)packet_buffer_size & 0x00ff) << 8);          
-               packet_buffer_size = packet_buffer_size - 8;
 
-               packet_buffer = rx_buffer + PACKET_HEADER_SIZE;
+       spin_lock(&packet_buffer_lock);
 
-               packet_buffer_orig = rx_buffer;
-               packet_buffer_pos = 0;
-               
-               packet_waiting = 1;
-               
-               rl8168_process_frame(rx_buffer, frame_size, current_command);
-               
-               rx_des_cur = rx_des_loop_cur;
-               
+       if (packet_buffer_count >= PACKET_BUFFER_SIZE) {
+               printk("WARNING: DROPPING PACKET!\n");
+               spin_unlock(&packet_buffer_lock);
+               kfree(rx_buffer);
                return;
        }
-       
-       // END HACKY STUFF
-       
-       // Chew on the frame data. Command bits should be the same for all frags.
-       rl8168_process_frame(rx_buffer, frame_size, current_command);
 
+       packet_buffer[packet_buffer_tail] = rx_buffer;
+       packet_buffer_sizes[packet_buffer_tail] = frame_size;
+               
+       packet_buffer_tail = (packet_buffer_tail + 1) % PACKET_BUFFER_SIZE;
+       packet_buffer_count = packet_buffer_count + 1;
+
+       spin_unlock(&packet_buffer_lock);
+                               
        rx_des_cur = rx_des_loop_cur;
-       
-       kfree(rx_buffer);
+                               
+       // Chew on the frame data. Command bits should be the same for all frags.
+       rl8168_process_frame(rx_buffer, frame_size, current_command);
        
        return;
 }
index 79e90d5..f5222a6 100644 (file)
@@ -6,8 +6,8 @@
 #include <pmap.h>
 #include <arch/nic_common.h>
 
-#define rl8168_debug(...)  //cprintf(__VA_ARGS__)  
-#define rl8168_interrupt_debug(...) cprintf(__VA_ARGS__)  
+#define rl8168_debug(...) // cprintf(__VA_ARGS__)  
+#define rl8168_interrupt_debug(...) //cprintf(__VA_ARGS__)  
 #define rl8168_frame_debug(...)  //cprintf(__VA_ARGS__)  
 
 #define NE2K_IRQ_CPU           5
index 809db14..b5b0447 100644 (file)
@@ -38,7 +38,8 @@
 #define SYS_eth_read                           27
 #define SYS_eth_write                          28
 #define SYS_eth_get_mac_addr                   29
-#define SYS_frontend                           30
+#define SYS_eth_recv_check                     30
+#define SYS_frontend                           31
 
 #define SYS_read                               100
 #define SYS_write                              101
index 1d22091..42d707d 100644 (file)
@@ -61,8 +61,10 @@ KERN_APPFILES += \
                  $(USER_APPS_PARLIB_DIR)/channel_test_server \
                  $(USER_APPS_PARLIB_DIR)/hello \
                  $(USER_APPS_PARLIB_DIR)/mhello \
-                 $(USER_APPS_PARLIB_DIR)/ping \
-                 $(USER_APPS_PARLIB_DIR)/manycore_test
+                 $(USER_APPS_PARLIB_DIR)/httpserver \
+                 $(USER_APPS_PARLIB_DIR)/manycore_test \
+                 $(USER_APPS_PARLIB_DIR)/lock_test 
+               
 endif
 
 KERN_LDFLAGS   := $(KERN_LDFLAGS) -L$(OBJDIR)/$(KERN_DIR) \
index 204f950..08e09b9 100644 (file)
@@ -43,8 +43,9 @@ DECL_PROG(parlib_channel_test_client);
 DECL_PROG(parlib_channel_test_server);
 DECL_PROG(parlib_hello);
 DECL_PROG(parlib_mhello);
-DECL_PROG(parlib_ping);
+DECL_PROG(parlib_httpserver);
 DECL_PROG(parlib_manycore_test);
+DECL_PROG(parlib_lock_test);
 #endif
 
 struct kfs_entry kfs[MAX_KFS_FILES] = {
@@ -63,8 +64,9 @@ struct kfs_entry kfs[MAX_KFS_FILES] = {
        KFS_ENTRY(parlib_channel_test_server)
        KFS_ENTRY(parlib_hello)
        KFS_ENTRY(parlib_mhello)
-       KFS_ENTRY(parlib_ping)
+       KFS_ENTRY(parlib_httpserver)
        KFS_ENTRY(parlib_manycore_test)
+       KFS_ENTRY(parlib_lock_test)
 #endif
 };
 
index f77602b..78876c1 100644 (file)
@@ -256,7 +256,8 @@ void manager_pearce()
 
        if (progress == 0) {
                progress++;
-               envs[0] = kfs_proc_create(kfs_lookup_path("parlib_ping"));
+               envs[0] = kfs_proc_create(kfs_lookup_path("parlib_httpserver"));
+               //envs[0] = kfs_proc_create(kfs_lookup_path("parlib_lock_test"));
                __proc_set_state(envs[0], PROC_RUNNABLE_S);
                proc_run(envs[0]);
        }
index ed56c6f..7108a3e 100644 (file)
@@ -563,37 +563,44 @@ static ssize_t sys_serial_write(env_t* e, const char *DANGEROUS buf, size_t len)
 
 #ifdef __NETWORK__
 // This is not a syscall we want. Its hacky. Here just for syscall stuff until get a stack.
-static ssize_t sys_eth_read(env_t* e, char *DANGEROUS buf, size_t len)
+static ssize_t sys_eth_read(env_t* e, char *DANGEROUS buf)
 {
        extern int eth_up;
 
+        extern uint32_t packet_buffer_count;
+        extern char* packet_buffer[PACKET_BUFFER_SIZE];
+        extern uint32_t packet_buffer_sizes[PACKET_BUFFER_SIZE];
+        extern uint32_t packet_buffer_head;
+        extern uint32_t packet_buffer_tail;
+        extern spinlock_t packet_buffer_lock;
+
        if (eth_up) {
-               extern int packet_waiting;
-               extern int packet_buffer_size;
-               extern char*CT(packet_buffer_size) packet_buffer;
-               extern char*CT(MAX_FRAME_SIZE) packet_buffer_orig;
-               extern int packet_buffer_pos;
 
-               if (len == 0)
-                       return 0;
+               uint32_t len;
+               char *ptr;
 
-               char *CT(len) _buf = user_mem_assert(e, buf,len, PTE_U);
+               spin_lock(&packet_buffer_lock);
 
-               if (packet_waiting == 0)
+               if (packet_buffer_count == 0) {
+                       spin_unlock(&packet_buffer_lock);
                        return 0;
+               }
 
-               int read_len = ((packet_buffer_pos + len) > packet_buffer_size) ? packet_buffer_size - packet_buffer_pos : len;
+               ptr = packet_buffer[packet_buffer_head];
+               len = packet_buffer_sizes[packet_buffer_head];
 
-               memcpy(_buf, packet_buffer + packet_buffer_pos, read_len);
+               packet_buffer_count = packet_buffer_count - 1;
+               packet_buffer_head = (packet_buffer_head + 1) % PACKET_BUFFER_SIZE;
 
-               packet_buffer_pos = packet_buffer_pos + read_len;
+               spin_unlock(&packet_buffer_lock);
 
-               if (packet_buffer_pos == packet_buffer_size) {
-                       kfree(packet_buffer_orig);
-                       packet_waiting = 0;
-               }
+               char* _buf = user_mem_assert(e, buf, len, PTE_U);
+
+               memcpy(_buf, ptr, len);
 
-               return read_len;
+               kfree(ptr);
+
+               return len;
        }
        else
                return -EINVAL;
@@ -646,7 +653,6 @@ static ssize_t sys_eth_write(env_t* e, const char *DANGEROUS buf, size_t len)
                return -EINVAL;
 }
 
-
 static ssize_t sys_eth_get_mac_addr(env_t* e, char *DANGEROUS buf) {
        
        extern int eth_up;
@@ -661,6 +667,18 @@ static ssize_t sys_eth_get_mac_addr(env_t* e, char *DANGEROUS buf) {
                return -EINVAL;
 }
 
+
+static int sys_eth_recv_check(env_t* e) {
+
+       extern uint32_t packet_buffer_count;
+       
+       if (packet_buffer_count != 0) {
+               return 1;
+       }
+       else
+               return 0;
+}
+
 #endif // Network
 
 /* sys_frontend_syscall_from_user(): called directly from dispatch table. */
@@ -715,6 +733,7 @@ intreg_t syscall(struct proc *p, uintreg_t syscallno, uintreg_t a1,
                [SYS_eth_read] = (syscall_t)sys_eth_read,
                [SYS_eth_write] = (syscall_t)sys_eth_write,
                [SYS_eth_get_mac_addr] = (syscall_t)sys_eth_get_mac_addr,
+               [SYS_eth_recv_check] = (syscall_t)sys_eth_recv_check,
        #endif
        #ifdef __sparc_v8__
                [SYS_frontend] = (syscall_t)frontend_syscall_from_user,
diff --git a/user/apps/parlib/httpserver.c b/user/apps/parlib/httpserver.c
new file mode 100644 (file)
index 0000000..6632b41
--- /dev/null
@@ -0,0 +1,134 @@
+#include "lwip/opt.h"
+#include "lwip/arch.h"
+#include "lwip/api.h"
+
+#include "lwip/mem.h"
+#include "lwip/raw.h"
+#include "lwip/icmp.h"
+#include "lwip/netif.h"
+#include "lwip/dhcp.h"
+#include "lwip/sys.h"
+#include "lwip/sockets.h"
+#include "lwip/inet.h"
+#include "lwip/inet_chksum.h"
+#include <lwip/tcpip.h>
+#include <netif/ethernetif.h>
+
+
+#if LWIP_NETCONN
+
+const static char http_html_hdr[] = "HTTP/1.1 200 OK\r\nContent-type: text/html\r\n\r\n";
+const static char http_index_html[] = "<html><head><title>It's ROS baby!</title></head><body><h1>Welcome to our ROS webserver!</h1><p>(Please don't root us)<pre>\n             .-.  .-.\n             |  \\/  |\n            /,   ,_  `'-.\n          .-|\\   /`\\     '. \n        .'  0/   | 0\\  \\_  `\".  \n     .-'  _,/    '--'.'|#''---'\n      `--'  |       /   \\#\n            |      /     \\#\n            \\     ;|\\    .\\#\n            |' ' //  \\   ::\\# \n            \\   /`    \\   ':\\#\n             `\"`       \\..   \\#\n                        \\::.  \\#\n                         \\::   \\#\n                          \\'  .:\\#\n                           \\  :::\\#\n                            \\  '::\\#\n                             \\     \\#\n                              \\:.   \\#\n                               \\::   \\#\n                                \\'   .\\#\n                             jgs \\   ::\\#\n                                  \\      \n</pre></body></html>";
+
+struct ip_addr ipaddr, netmask, gw;
+struct netif netif;
+
+int http_server();
+
+void network_init()
+{
+        printf("Starting up network stack....\n");
+
+        IP4_ADDR(&gw, 0,0,0,0);
+        IP4_ADDR(&ipaddr, 0,0,0,0);
+        IP4_ADDR(&netmask, 0,0,0,0);
+
+        netif.name[0] = 'P';
+        netif.name[1] = 'J';
+
+        tcpip_init(NULL, NULL);
+
+        netif_add(&netif, &ipaddr, &netmask, &gw, NULL, ethernetif_init, tcpip_input);
+
+        netif_set_default(&netif);
+
+        dhcp_start(&netif);
+
+        printf("Done...\n");
+
+}
+
+
+int main(int argc, char** argv) {
+
+        static struct ip_addr ping_addr;
+
+        IP4_ADDR(&ping_addr, 192,168,0,3);
+
+        network_init();
+
+       printf("Starting http server\n");
+
+       http_server();
+
+        return 0;
+
+}
+
+
+
+void http_server_serve(struct netconn *conn) {
+  struct netbuf *inbuf;
+  char *buf;
+  u16_t buflen;
+
+  /* Read the data from the port, blocking if nothing yet there. 
+   We assume the request (the part we care about) is in one netbuf */
+  inbuf = netconn_recv(conn);
+  
+  if (netconn_err(conn) == ERR_OK) {
+    netbuf_data(inbuf, (void**)&buf, &buflen);
+    
+    /* Is this an HTTP GET command? (only check the first 5 chars, since
+    there are other formats for GET, and we're keeping it very simple )*/
+    if (buflen>=5 &&
+        buf[0]=='G' &&
+        buf[1]=='E' &&
+        buf[2]=='T' &&
+        buf[3]==' ' &&
+        buf[4]=='/' ) {
+      
+      /* Send the HTML header 
+             * subtract 1 from the size, since we dont send the \0 in the string
+             * NETCONN_NOCOPY: our data is const static, so no need to copy it
+       */
+      netconn_write(conn, http_html_hdr, sizeof(http_html_hdr)-1, NETCONN_NOCOPY);
+      
+      /* Send our HTML page */
+      netconn_write(conn, http_index_html, sizeof(http_index_html)-1, NETCONN_NOCOPY);
+    }
+  }
+
+  /* Close the connection (server closes in HTTP) */
+  netconn_close(conn);
+  /* Delete the buffer (netconn_recv gives us ownership,
+   so we have to make sure to deallocate the buffer) */
+  netbuf_delete(inbuf);
+}
+
+int http_server() {
+  struct netconn *conn, *newconn;
+
+  /* Create a new TCP connection handle */
+  conn = netconn_new(NETCONN_TCP);
+  LWIP_ERROR("http_server: invalid conn", (conn != NULL), return -1;);
+
+  /* Bind to port 80 (HTTP) with default IP address */
+  netconn_bind(conn, NULL, 9999);
+
+  /* Put the connection into LISTEN state */
+  netconn_listen(conn);
+
+  while(1) {
+       
+    newconn = netconn_accept(conn);
+
+    http_server_serve(newconn);
+
+    netconn_delete(newconn);
+
+  }
+  return 0;
+}
+
+#endif /* LWIP_NETCONN*/
diff --git a/user/apps/parlib/lock_test.c b/user/apps/parlib/lock_test.c
new file mode 100644 (file)
index 0000000..1933d47
--- /dev/null
@@ -0,0 +1,68 @@
+#include <parlib.h>
+#include <ros/mman.h>
+#include <ros/resource.h>
+#include <stdio.h>
+#include <hart.h>
+
+#include <pthread.h>
+
+pthread_mutex_t lock;
+
+// ghetto udelay, put in a lib somewhere and export the tsc freq
+#include <arch/arch.h>
+void udelay(uint64_t usec, uint64_t tsc_freq)
+{
+       uint64_t start, end, now;
+
+       start = read_tsc();
+    end = start + (tsc_freq * usec) / 1000000;
+       if (end == 0) printf("This is terribly wrong \n");
+       do {
+        cpu_relax();
+        now = read_tsc();
+       } while (now < end || (now > start && end < start));
+       return;
+}
+
+__thread int temp;
+
+void startup(void *arg)
+{
+        uint32_t vcoreid = hart_self();
+        temp = 0xcafebabe;
+       while(1)
+       {
+               pthread_mutex_lock(&lock);
+               printf("Hello from hart_entry in vcore %d with temp addr %p and temp %p\n",
+                               vcoreid, &temp, temp);
+               pthread_mutex_unlock(&lock);
+       }
+}
+
+
+int main(int argc, char** argv)
+{
+       uint32_t vcoreid;
+       error_t retval;
+
+        pthread_mutex_init(&lock, NULL);
+
+       if ((vcoreid = hart_self())) {
+               printf("Should never see me! (from vcore %d)\n", vcoreid);
+       } else { // core 0
+               temp = 0xdeadbeef;
+               printf("Hello from vcore %d with temp addr = %p and temp = %p\n",
+                      vcoreid, &temp, temp);
+               printf("Multi-Goodbye, world, from PID: %d!\n", sys_getpid());
+
+               extern void *hart_startup_arg;
+               extern void (*hart_startup)();
+               hart_startup_arg = NULL;
+               hart_startup = startup;         
+               retval = hart_request(6);
+
+       }
+       printf("Vcore %d Done!\n", vcoreid);
+       while (1);
+       return 0;
+}
diff --git a/user/apps/parlib/ping.c b/user/apps/parlib/ping.c
deleted file mode 100644 (file)
index e58b7e9..0000000
+++ /dev/null
@@ -1,371 +0,0 @@
-/**
- * @file
- * Ping sender module
- *
- */
-
-/*
- * Redistribution and use in source and binary forms, with or without modification, 
- * are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission. 
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
- * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
- * OF SUCH DAMAGE.
- *
- * This file is part of the lwIP TCP/IP stack.
- * 
- */
-
-/** 
- * This is an example of a "ping" sender (with raw API and socket API).
- * It can be used as a start point to maintain opened a network connection, or
- * like a network "watchdog" for your device.
- *
- */
-
-#include <stdio.h>
-
-#include "lwip/opt.h"
-
-#if LWIP_RAW && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */
-
-#include "lwip/mem.h"
-#include "lwip/raw.h"
-#include "lwip/icmp.h"
-#include "lwip/netif.h"
-#include "lwip/dhcp.h"
-#include "lwip/sys.h"
-#include "lwip/sockets.h"
-#include "lwip/inet.h"
-#include "lwip/inet_chksum.h"
-#include <lwip/tcpip.h>
-#include <netif/ethernetif.h>
-
-/**
- * PING_DEBUG: Enable debugging for PING.
- */
-#ifndef PING_DEBUG
-#define PING_DEBUG     LWIP_DBG_ON
-#endif
-
-/** ping target - should be a "struct ip_addr" */
-#ifndef PING_TARGET
-#define PING_TARGET   (netif_default?netif_default->gw:ip_addr_any)
-#endif
-
-/** ping receive timeout - in milliseconds */
-#ifndef PING_RCV_TIMEO
-#define PING_RCV_TIMEO 1000
-#endif
-
-/** ping delay - in milliseconds */
-#ifndef PING_DELAY
-#define PING_DELAY     1000
-#endif
-
-/** ping identifier - must fit on a u16_t */
-#ifndef PING_ID
-#define PING_ID        0xAFAF
-#endif
-
-/** ping additional data size to include in the packet */
-#ifndef PING_DATA_SIZE
-#define PING_DATA_SIZE 32
-#endif
-
-/** ping result action - no default action */
-#ifndef PING_RESULT
-#define PING_RESULT(ping_ok)
-#endif
-
-/* ping variables */
-static u16_t ping_seq_num;
-static u32_t ping_time;
-
-#if NO_SYS
-/* port-defined functions used for timer execution */
-void sys_msleep(u32_t ms);
-u32_t sys_now();
-#endif /* NO_SYS */
-
-void ping_init(void);
-
-/** Prepare a echo ICMP request */
-static void
-ping_prepare_echo( struct icmp_echo_hdr *iecho, u16_t len)
-{
-  int i;
-
-  ICMPH_TYPE_SET(iecho,ICMP_ECHO);
-  ICMPH_CODE_SET(iecho, 0);
-  iecho->chksum = 0;
-  iecho->id     = PING_ID;
-  iecho->seqno  = htons(++ping_seq_num);
-  iecho->chksum = inet_chksum(iecho, len);
-
-  /* fill the additional data buffer with some data */
-  for(i = 0; i < PING_DATA_SIZE; i++) {
-    ((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = i;
-  }
-}
-
-#if LWIP_SOCKET
-
-/* Network interface variables */
-struct ip_addr ipaddr, netmask, gw;
-struct netif netif;
-/* Set network address variables */
-
-void network_init()
-{
-        printf("Starting up network stack....\n");
-
-        IP4_ADDR(&gw, 0,0,0,0);
-        IP4_ADDR(&ipaddr, 0,0,0,0);
-        IP4_ADDR(&netmask, 0,0,0,0);
-
-       netif.name[0] = 'P';
-       netif.name[1] = 'J';
-
-        tcpip_init(NULL, NULL);
-
-        netif_add(&netif, &ipaddr, &netmask, &gw, NULL, ethernetif_init, tcpip_input);
-        /* ethhw_init() is user-defined */
-        /* use ip_input instead of ethernet_input for non-ethernet hardware */
-        /* (this function is assigned to netif.input and should be called by the hardware driver) */
-
-        netif_set_default(&netif);
-
-       dhcp_start(&netif);
-        
-       printf("Done...\n");
-
-}
-
-
-int main(int argc, char** argv) {
-
-       printf("Starting the ping nightmare....\n");
-
-       int s;
-
-       static struct ip_addr ping_addr;
-       
-       IP4_ADDR(&ping_addr, 192,168,0,3);
-
-       network_init();
-
-       if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
-               return -1;
-       }
-
-       ping_init();
-       
-       printf("DONE STARTING PING. SPINNING\n");
-
-       while(1);
-
-       return 0;
-
-}
-
-
-/* Ping using the socket ip */
-static err_t
-ping_send(int s, struct ip_addr *addr)
-{
-  int err;
-  struct icmp_echo_hdr *iecho;
-  struct sockaddr_in to;
-  size_t ping_size = sizeof(struct icmp_echo_hdr) + PING_DATA_SIZE;
-
-  if (!(iecho = mem_malloc(ping_size))) {
-    return ERR_MEM;
-  }
-
-  ping_prepare_echo(iecho, ping_size);
-
-  to.sin_len = sizeof(to);
-  to.sin_family = AF_INET;
-  to.sin_addr.s_addr = addr->addr;
-
-  err = lwip_sendto(s, iecho, ping_size, 0, (struct sockaddr*)&to, sizeof(to));
-
-  mem_free(iecho);
-
-  return (err ? ERR_OK : ERR_VAL);
-}
-
-static void
-ping_recv(int s)
-{
-  char buf[64];
-  int fromlen, len;
-  struct sockaddr_in from;
-  struct ip_hdr *iphdr;
-  struct icmp_echo_hdr *iecho;
-
-  while((len = lwip_recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr*)&from, (socklen_t*)&fromlen)) > 0) {
-    if (len >= (sizeof(struct ip_hdr)+sizeof(struct icmp_echo_hdr))) {
-      LWIP_DEBUGF( PING_DEBUG, ("ping: recv "));
-      ip_addr_debug_print(PING_DEBUG, (struct ip_addr *)&(from.sin_addr));
-      LWIP_DEBUGF( PING_DEBUG, (" %lu ms\n", (sys_now()-ping_time)));
-
-      iphdr = (struct ip_hdr *)buf;
-      iecho = (struct icmp_echo_hdr *)(buf+(IPH_HL(iphdr) * 4));
-      if ((iecho->id == PING_ID) && (iecho->seqno == htons(ping_seq_num))) {
-        /* do some ping result processing */
-        PING_RESULT((ICMPH_TYPE(iecho) == ICMP_ER));
-        return;
-      } else {
-        LWIP_DEBUGF( PING_DEBUG, ("ping: drop\n"));
-      }
-    }
-  }
-
-  if (len == 0) {
-    LWIP_DEBUGF( PING_DEBUG, ("ping: recv - %lu ms - timeout\n", (sys_now()-ping_time)));
-  }
-
-  /* do some ping result processing */
-  PING_RESULT(0);
-}
-
-static void
-ping_thread(void *arg)
-{
-  int s;
-  int timeout = PING_RCV_TIMEO;
-  struct ip_addr ping_target;
-
-  LWIP_UNUSED_ARG(arg);
-
-  if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
-    return;
-  }
-
-  lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
-
-  while (1) {
-    ping_target = PING_TARGET;
-
-    if (ping_send(s, &ping_target) == ERR_OK) {
-      LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
-      ip_addr_debug_print(PING_DEBUG, &ping_target);
-      LWIP_DEBUGF( PING_DEBUG, ("\n"));
-
-      ping_time = sys_now();
-      ping_recv(s);
-    } else {
-      LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
-      ip_addr_debug_print(PING_DEBUG, &ping_target);
-      LWIP_DEBUGF( PING_DEBUG, (" - error\n"));
-    }
-    sys_msleep(PING_DELAY);
-  }
-}
-
-#else /* LWIP_SOCKET */
-
-/* Ping using the raw ip */
-static u8_t
-ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p, struct ip_addr *addr)
-{
-  struct icmp_echo_hdr *iecho;
-
-  if (pbuf_header( p, -PBUF_IP_HLEN)==0) {
-    iecho = p->payload;
-
-    if ((iecho->id == PING_ID) && (iecho->seqno == htons(ping_seq_num))) {
-      LWIP_DEBUGF( PING_DEBUG, ("ping: recv "));
-      ip_addr_debug_print(PING_DEBUG, addr);
-      LWIP_DEBUGF( PING_DEBUG, (" %lu ms\n", (sys_now()-ping_time)));
-
-      /* do some ping result processing */
-      PING_RESULT(1);
-    }
-  }
-
-  return 1; /* eat the event */
-}
-
-static void
-ping_send(struct raw_pcb *raw, struct ip_addr *addr)
-{
-  struct pbuf *p;
-  struct icmp_echo_hdr *iecho;
-  size_t ping_size = sizeof(struct icmp_echo_hdr) + PING_DATA_SIZE;
-
-  if (!(p = pbuf_alloc(PBUF_IP, ping_size, PBUF_RAM))) {
-    return;
-  }
-  if ((p->len == p->tot_len) && (p->next == NULL)) {
-    iecho = p->payload;
-
-    ping_prepare_echo(iecho, ping_size);
-
-    raw_sendto(raw, p, addr);
-    ping_time = sys_now();
-  }
-  pbuf_free(p);
-}
-
-static void
-ping_timeout(void *arg)
-{
-  struct raw_pcb *pcb = (struct raw_pcb*)arg;
-  struct ip_addr ping_target = PING_TARGET;
-  
-  LWIP_ASSERT("ping_timeout: no pcb given!", pcb != NULL);
-
-  LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
-  ip_addr_debug_print(PING_DEBUG, &ping_target);
-  LWIP_DEBUGF( PING_DEBUG, ("\n"));
-
-  ping_send(pcb, &ping_target);
-
-  sys_timeout(PING_DELAY, ping_timeout, pcb);
-}
-
-static void
-ping_raw_init(void)
-{
-  struct raw_pcb *pcb;
-
-  if (!(pcb = raw_new(IP_PROTO_ICMP))) {
-    return;
-  }
-
-  raw_recv(pcb, ping_recv, NULL);
-  raw_bind(pcb, IP_ADDR_ANY);
-  sys_timeout(PING_DELAY, ping_timeout, pcb);
-}
-
-#endif /* LWIP_SOCKET */
-
-void
-ping_init(void)
-{
-#if LWIP_SOCKET
-  sys_thread_new("ping_thread", ping_thread, NULL, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
-#else /* LWIP_SOCKET */
-  ping_raw_init();
-#endif /* LWIP_SOCKET */
-}
-
-#endif /* LWIP_RAW && LWIP_ICMP */
index a8f1453..2b0f838 100644 (file)
@@ -14,6 +14,8 @@ USER_LWIP_SRC_SRCFILES        := $(USER_LWIP_SRC_DIR)/api/api_msg.c \
                           $(USER_LWIP_SRC_DIR)/api/netdb.c \
                           $(USER_LWIP_SRC_DIR)/api/sockets.c \
                           $(USER_LWIP_SRC_DIR)/api/tcpip.c \
+                          $(USER_LWIP_SRC_DIR)/netif/etharp.c \
+                          $(USER_LWIP_SRC_DIR)/netif/ethernetif.c \
                           $(USER_LWIP_SRC_DIR)/core/dhcp.c \
                           $(USER_LWIP_SRC_DIR)/core/init.c \
                           $(USER_LWIP_SRC_DIR)/core/sys_arch.c \
@@ -33,9 +35,7 @@ USER_LWIP_SRC_SRCFILES        := $(USER_LWIP_SRC_DIR)/api/api_msg.c \
                           $(USER_LWIP_SRC_DIR)/core/ipv4/ip.c  \
                           $(USER_LWIP_SRC_DIR)/core/ipv4/ip_addr.c \
                           $(USER_LWIP_SRC_DIR)/core/ipv4/ip_frag.c \
-                          $(USER_LWIP_SRC_DIR)/core/ipv4/inet_chksum.c \
-                          $(USER_LWIP_SRC_DIR)/netif/etharp.c \
-                          $(USER_LWIP_SRC_DIR)/netif/ethernetif.c
+                          $(USER_LWIP_SRC_DIR)/core/ipv4/inet_chksum.c 
                                                        
 USER_LWIP_SRC_OBJFILES := $(patsubst $(USER_LWIP_SRC_DIR)/%.c, \
                           $(OBJDIR)/$(USER_LWIP_DIR)/%.o,  \
index 727c254..b120363 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+t * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
  * All rights reserved. 
  * 
  * Redistribution and use in source and binary forms, with or without modification, 
@@ -35,6 +35,7 @@
 #include "lwip/sys.h"
 #include "lwip/opt.h"
 #include "lwip/stats.h"
+#include "netif/ethernetif.h"
 
 #include <pthread.h>
 #include <arch/arch.h>
@@ -54,6 +55,21 @@ typedef struct sys_hart_startup {
 
 } sys_hart_startup_t;
 
+
+void  sys_recv_thread(void) {
+
+       while(1) {
+
+               if (sys_eth_recv_check() == 1) {
+
+                       extern struct netif* registered_netif;
+
+                       ethernetif_input(registered_netif);
+               }
+       }
+
+}
+
 // HACK
 void sys_init(void) {
        sys_debug("In sys_init\n");
@@ -62,7 +78,13 @@ void sys_init(void) {
        
        protection_status = 0;
 
-       printf("Register callback\n");
+       extern void (*hart_startup)();
+       extern void *hart_startup_arg;
+
+        hart_startup = sys_recv_thread;
+        hart_startup_arg = NULL;
+
+        hart_request(1);
 }
 
 // HACK
@@ -111,7 +133,7 @@ void sys_sem_free(sys_sem_t sem) {
 // OK
 void sys_sem_signal(sys_sem_t sem) {
 
-       sys_debug("In sys_sem_signal\n");
+       sys_debug("In sys_sem_signal. Signal on %x\n", sem);
 
        pthread_mutex_lock(&(sem->lock));
 
@@ -125,7 +147,7 @@ void sys_sem_signal(sys_sem_t sem) {
 // OK
 u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout) {
 
-       sys_debug("In sys_arch_sem_wait\n");
+       sys_debug("In sys_arch_sem_wait. Wait on sem\n");
 
        uint32_t start = sys_now();
        uint32_t current = 0;
@@ -160,10 +182,10 @@ sys_mbox_t sys_mbox_new(int size) {
 
        sys_debug("In sys_mbox_new\n");
 
-
-       // HACK:
-       if (size == 0)
+       if (size == 0) {
+               printf("DANGER. BAD MBOX SIZE\n");
                size = 20;
+       }
 
        sys_mbox_t new_box = (sys_mbox_t)malloc(sizeof(struct sys_mbox) + size * sizeof(char*));
 
@@ -185,7 +207,6 @@ void sys_mbox_free(sys_mbox_t mbox) {
 
        sys_debug("In sys_mbox_new\n");
 
-       
        // Should we aquire the lock here?
        if (mbox->count != 0) {
                printf("LWIP Stack errror. Bad.\n");
@@ -203,7 +224,7 @@ void sys_mbox_free(sys_mbox_t mbox) {
 // HACK
 void sys_mbox_post(sys_mbox_t mbox, void *msg) {
 
-       sys_debug("In sys_mbox_post\n");
+       sys_debug("In sys_mbox_post. Post on %x\n", mbox);
 
        pthread_mutex_lock(&(mbox->lock));
 
@@ -227,7 +248,7 @@ void sys_mbox_post(sys_mbox_t mbox, void *msg) {
 // HACK
 err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) {
 
-       sys_debug("In sys_mbox_trypost\n");
+       sys_debug("In sys_mbox_trypost. Post on %x\n", mbox);
 
        pthread_mutex_lock(&(mbox->lock));
 
@@ -238,7 +259,6 @@ err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) {
                return ERR_MEM;
        }
 
-
        mbox->buf[(mbox->first + mbox->count) % mbox->size] = msg;
        mbox->count = mbox->count + 1;
 
@@ -250,7 +270,7 @@ err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) {
 // HACK
 u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) {
 
-       sys_debug("In sys_arch_mbox_fetch\n");
+       sys_debug("In sys_arch_mbox_fetch. Fetch on mbox %x\n", mbox);
 
        uint32_t start = sys_now();
        uint32_t current = 0;
@@ -270,11 +290,12 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) {
                 hart_relax();
 
                 pthread_mutex_lock(&(mbox->lock));
+
         }
 
        *msg = mbox->buf[mbox->first];
 
-       mbox->first = (mbox->first + 1) % (mbox->size);
+       mbox->first = (mbox->first + 1) % mbox->size;
 
         mbox->count = mbox->count - 1;
 
@@ -286,7 +307,7 @@ u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) {
 // HACK
 u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg) {
 
-       sys_debug("In sys_arch_mbox_tryfetch\n");
+       sys_debug("In sys_arch_mbox_tryfetch. Fetch on %x\n", &mbox);
 
        pthread_mutex_lock(&(mbox->lock));
 
index b75260e..dbbf195 100644 (file)
@@ -5,16 +5,22 @@
 #define LWIP_TCP 1
 #define SYS_LIGHTWEIGHT_PROT 1
 #define LWIP_DHCP 1
+#define LWIP_ICMP 1
 
 #define TCP_SND_BUF 1096
-//#define MEMP_NUM_TCP_SEG 32
-#define ETHARP_DEBUG LWIP_DBG_ON
-#define NETIF_DEBUG LWIP_DBG_ON
-#define PBUF_DEBUG LWIP_DBG_ON
-#define INET_DEBUG LWIP_DBG_ON
-#define IP_DEBUG LWIP_DBG_ON
-#define RAW_DEBUG LWIP_DBG_ON
-#define UDP_DEBUG LWIP_DBG_ON
 
-#define LWIP_DEBUG 1
+#define TCPIP_MBOX_SIZE 4096
+#define DEFAULT_RAW_RECVMBOX_SIZE 4096
+#define DEFAULT_UDP_RECVMBOX_SIZE 4096
+#define DEFAULT_TCP_RECVMBOX_SIZE 4096
+#define DEFAULT_ACCEPTMBOX_SIZE 4096
+
+//#define ETHARP_DEBUG LWIP_DBG_ON
+//#define NETIF_DEBUG LWIP_DBG_ON
+//#define PBUF_DEBUG LWIP_DBG_ON
+//#define INET_DEBUG LWIP_DBG_ON
+//#define IP_DEBUG LWIP_DBG_ON
+//#define RAW_DEBUG LWIP_DBG_ON
+//#define UDP_DEBUG LWIP_DBG_ON
+
+//#define LWIP_DEBUG 1
index 1910c63..2bbdfe1 100644 (file)
@@ -15,8 +15,6 @@
 #include "netif/etharp.h"
 #include "netif/ppp_oe.h"
 
-
-
 static void
 low_level_init(struct netif *netif);
 
@@ -25,7 +23,7 @@ low_level_output(struct netif *netif, struct pbuf *p);
 
 static struct pbuf *low_level_input(struct netif *netif);
 
-static void
+void
 ethernetif_input(struct netif *netif);
 
 err_t
index bbd6122..d3c7b48 100644 (file)
 #define IFNAME0 'e'
 #define IFNAME1 'n'
 
+#define eth_debug(...) //printf(__VA_ARGS__)
+
 struct ethernetif {
   struct eth_addr *ethaddr;
   /* Add whatever per-interface state that is needed here. */
 };
 
+struct netif* registered_netif;
+
 /**
  * In this function, the hardware should be initialized.
  * Called from ethernetif_init().
@@ -34,19 +38,23 @@ struct ethernetif {
 static void
 low_level_init(struct netif *netif)
 {
-        struct ethernetif *ethernetif = netif->state;
+       eth_debug("In low_level_init\n");
 
-        /* set MAC hardware address length */
-        netif->hwaddr_len = ETHARP_HWADDR_LEN;
+       struct ethernetif *ethernetif = netif->state;
 
-        /* set MAC hardware address */
+       /* set MAC hardware address length */
+       netif->hwaddr_len = ETHARP_HWADDR_LEN;
+
+       /* set MAC hardware address */
        sys_eth_get_mac_addr(&(netif->hwaddr));
-        /* maximum transfer unit */
-        netif->mtu = 1500;
+       /* maximum transfer unit */
+       netif->mtu = 1500;
  
-        /* device capabilities */
-        /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
-        netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
+       /* device capabilities */
+       /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
+       netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
+
+       // Done
 }
 
 
@@ -74,6 +82,8 @@ low_level_init(struct netif *netif)
 static err_t
 low_level_output(struct netif *netif, struct pbuf *p)
 {
+       eth_debug("In low_level_output\n");
+
         struct ethernetif *ethernetif = netif->state;
         struct pbuf *q;
 
@@ -131,49 +141,59 @@ low_level_output(struct netif *netif, struct pbuf *p)
  *         NULL on memory error
  */
 static struct pbuf *low_level_input(struct netif *netif) {
-        struct ethernetif *ethernetif = netif->state;
-        struct pbuf *p, *q;
-        u16_t len;
 
-        /* Obtain the size of the packet and put it into the "len"
-           variable. */
-       // len = ;
+       eth_debug("In low_level_input\n");
+
+       struct ethernetif *ethernetif = netif->state;
+       struct pbuf *p, *q;
+       u16_t len;
+
+       char buf[4096];
+       memset(buf, 0x00, 4096);
+       char *buf_ptr = buf;
+
+       len = sys_eth_read(buf);
+
+       if (len == 0)
+               return NULL;
 
        #if ETH_PAD_SIZE
-        len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
+               len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
        #endif
 
-        /* We allocate a pbuf chain of pbufs from the pool. */
-        p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
+       /* We allocate a pbuf chain of pbufs from the pool. */
+       p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
  
-        if (p != NULL) {
+       if (p != NULL) {
 
-       #if ETH_PAD_SIZE
-          pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
-       #endif
+               #if ETH_PAD_SIZE
+                       pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
+               #endif
 
-          /* We iterate over the pbuf chain until we have read the entire
-           * packet into the pbuf. */
-          for(q = p; q != NULL; q = q->next) {
-            /* Read enough bytes to fill this pbuf in the chain. The
-             * available data in the pbuf is given by the q->len
-             * variable. */
-           // read data into(q->payload, q->len);
-          }
-        //  acknowledge that packet has been read();
+               /* We iterate over the pbuf chain until we have read the entire
+                * packet into the pbuf. */
+          
+               for(q = p; q != NULL; q = q->next) {
+                       /* Read enough bytes to fill this pbuf in the chain. The
+                        * available data in the pbuf is given by the q->len
+                       * variable. */
+                       // read data into(q->payload, q->len);
+                       memcpy(q->payload, buf_ptr, q->len);
+                       buf_ptr += q->len;
+               }
 
-       #if ETH_PAD_SIZE
-          pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
-       #endif
+               #if ETH_PAD_SIZE
+                       pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
+               #endif
 
-          LINK_STATS_INC(link.recv);
-        } else {
-          //drop packet();
-          LINK_STATS_INC(link.memerr);
-          LINK_STATS_INC(link.drop);
-        }
+               LINK_STATS_INC(link.recv);
+       } else {
+               //drop packet();
+               LINK_STATS_INC(link.memerr);
+               LINK_STATS_INC(link.drop);
+       }
 
-        return p;  
+       return p;
 }
 
 /**
@@ -185,44 +205,32 @@ static struct pbuf *low_level_input(struct netif *netif) {
  *
  * @param netif the lwip network interface structure for this ethernetif
  */
-static void
+void
 ethernetif_input(struct netif *netif)
 {
-  struct ethernetif *ethernetif;
-  struct eth_hdr *ethhdr;
-  struct pbuf *p;
-
-  ethernetif = netif->state;
-
-  /* move received packet into a new pbuf */
-  p = low_level_input(netif);
-  /* no packet could be read, silently ignore this */
-  if (p == NULL) return;
-  /* points to packet payload, which starts with an Ethernet header */
-  ethhdr = p->payload;
-
-  switch (htons(ethhdr->type)) {
-  /* IP or ARP packet? */
-  case ETHTYPE_IP:
-  case ETHTYPE_ARP:
-#if PPPOE_SUPPORT
-  /* PPPoE packet? */
-  case ETHTYPE_PPPOEDISC:
-  case ETHTYPE_PPPOE:
-#endif /* PPPOE_SUPPORT */
-    /* full packet send to tcpip_thread to process */
-    if (netif->input(p, netif)!=ERR_OK)
-     { LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
-       pbuf_free(p);
-       p = NULL;
-     }
-    break;
-
-  default:
-    pbuf_free(p);
-    p = NULL;
-    break;
-  }
+       eth_debug("In ethernetif_input\n");
+
+       struct ethernetif *ethernetif;
+       struct eth_hdr *ethhdr;
+       struct pbuf *p;
+
+       ethernetif = netif->state;
+
+       /* move received packet into a new pbuf */
+       p = low_level_input(netif);
+  
+       /* no packet could be read, silently ignore this */
+       if (p == NULL) return;
+
+       /* points to packet payload, which starts with an Ethernet header */
+       ethhdr = p->payload;
+
+       /* full packet send to tcpip_thread to process */
+       if (netif->input(p, netif)!=ERR_OK) { 
+               LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
+               pbuf_free(p);
+               p = NULL;
+       }
 }
 
 /**
@@ -240,42 +248,49 @@ ethernetif_input(struct netif *netif)
 err_t
 ethernetif_init(struct netif *netif)
 {
-  struct ethernetif *ethernetif;
+       eth_debug("In ethernetif_init\n");
 
-  LWIP_ASSERT("netif != NULL", (netif != NULL));
+       struct ethernetif *ethernetif;
+
+       LWIP_ASSERT("netif != NULL", (netif != NULL));
     
-  ethernetif = mem_malloc(sizeof(struct ethernetif));
-  if (ethernetif == NULL) {
-    LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
-    return ERR_MEM;
-  }
-
-#if LWIP_NETIF_HOSTNAME
-  /* Initialize interface hostname */
-  netif->hostname = "lwip";
-#endif /* LWIP_NETIF_HOSTNAME */
-
-  /*
-   * Initialize the snmp variables and counters inside the struct netif.
-   * The last argument should be replaced with your link speed, in units
-   * of bits per second.
-   */
-       NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
-
-  netif->state = ethernetif;
-  netif->name[0] = IFNAME0;
-  netif->name[1] = IFNAME1;
-  /* We directly use etharp_output() here to save a function call.
-   * You can instead declare your own function an call etharp_output()
-   * from it if you have to do some checks before sending (e.g. if link
-   * is available...) */
-  netif->output = etharp_output;
-  netif->linkoutput = low_level_output;
-
-  ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
+       ethernetif = mem_malloc(sizeof(struct ethernetif));
+       if (ethernetif == NULL) {
+               LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_init: out of memory\n"));
+               return ERR_MEM;
+       }
+
+       #if LWIP_NETIF_HOSTNAME
+       /* Initialize interface hostname */
+       netif->hostname = "lwip";
+       #endif /* LWIP_NETIF_HOSTNAME */
+
+       /*
+        * Initialize the snmp variables and counters inside the struct netif.
+        * The last argument should be replaced with your link speed, in units
+        * of bits per second.
+        */
+
+       NETIF_INIT_SNMP(netif, snmp_ifType_ethernet_csmacd, 100000000);
+
+       netif->state = ethernetif;
+       netif->name[0] = IFNAME0;
+       netif->name[1] = IFNAME1;
   
-  /* initialize the hardware */
-  low_level_init(netif);
+       /* We directly use etharp_output() here to save a function call.
+        * You can instead declare your own function an call etharp_output()
+        * from it if you have to do some checks before sending (e.g. if link
+        * is available...) */
+
+       netif->output = etharp_output;
+       netif->linkoutput = low_level_output;
+
+       ethernetif->ethaddr = (struct eth_addr *)&(netif->hwaddr[0]);
+  
+       /* initialize the hardware */
+       low_level_init(netif);
+
+       registered_netif = netif;
 
-  return ERR_OK;
+       return ERR_OK;
 }
index e252fe3..b7a83e9 100644 (file)
@@ -37,8 +37,9 @@ uint16_t    sys_cgetc(void);
 ssize_t     sys_serial_write(void* buf, size_t len); 
 ssize_t     sys_serial_read(void* buf, size_t len);
 ssize_t     sys_eth_write(void *COUNT(len) buf, size_t len); 
-ssize_t     sys_eth_read(void *COUNT(len) buf, size_t len);
+ssize_t     sys_eth_read(void *COUNT(len) buf);
 ssize_t     sys_eth_get_mac_addr(void* buf);
+int         sys_eth_recv_check();
 ssize_t     sys_run_binary(void* binary_buf, size_t len,
                            char arg[PROCINFO_MAX_ARGV_SIZE], size_t num_colors);
 int         sys_getpid(void);
index 552baff..a6f2ba9 100644 (file)
@@ -398,7 +398,9 @@ int read_from_channel(char * buf, int len, int peek)
        int total_read = 0;
 
        #ifdef __NETWORK__
-               int just_read = sys_eth_read(buf, len);
+               printf("PAUL BROKE ME FIX SYS ETH READ\n");
+               int just_read = 0;
+               //int just_read = sys_eth_read(buf, len);
        #else
                int just_read = sys_serial_read(buf, len);
        #endif
@@ -411,7 +413,8 @@ int read_from_channel(char * buf, int len, int peek)
        while (total_read != len) {
                
                #ifdef __NETWORK__
-                       just_read = sys_eth_read(buf + total_read, len - total_read);
+                       printf("PAUL BROKE ME. FIX SYS ETH READ\n");
+                       //just_read = sys_eth_read(buf + total_read, len - total_read);
                #else
                        just_read = sys_serial_read(buf + total_read, len - total_read);
                #endif
index 431d93d..cc51adc 100644 (file)
@@ -75,18 +75,19 @@ ssize_t sys_eth_write(void* buf, size_t len)
 }
 
 //Read a buffer via ethernet
-ssize_t sys_eth_read(void* buf, size_t len
+ssize_t sys_eth_read(void* buf) 
 {
-       if (len == 0)
-               return 0;
-               
-       return syscall(SYS_eth_read, (intreg_t)buf, len, 0, 0, 0);
+       return syscall(SYS_eth_read, (intreg_t)buf, 0, 0, 0, 0);
 }
 
 ssize_t sys_eth_get_mac_addr(void* buf) {
        return syscall(SYS_eth_get_mac_addr, (intreg_t)buf, 0, 0, 0, 0);
 }
 
+int sys_eth_recv_check() {
+       return syscall(SYS_eth_recv_check, 0, 0, 0, 0, 0);
+}
+
 /* Request resources from the kernel.  Flags in ros/resource.h. */
 ssize_t sys_resource_req(int type, size_t amount, uint32_t flags)
 {