This is a port of the uIP network stack from SICS to the Nanode. It presents itself as an Arduino library.

There's an example sketch, "uiptest", which you can access from the Arduino IDE. Chose File -> Examples -> NanodeUIP -> uiptest to access it. Note that it depends on the NanodeUNIO library (available at https://github.com/sde1000/NanodeUNIO) being installed to access the MAC address chip on the back of the Nanode.

Notes on porting decisions:

clock_time_t has to be unsigned long (4 bytes) if we're going to use the output of millis() as the clock. This overflows every 50 days - acceptable.

If we only used an unsigned int (2 bytes) the time would overflow every 65s and half of this would be the maximum wait possible - some protocols demand more. The DHCP client would enter an infinite loop when its retransmission time grew beyond 32s.

We might get away with using millis()/10 as the clock if we define clock_time_t to be unsigned int. It would overflow every 10 minutes or so, allowing for a maximum wait of 5 minutes.

RAM is very valuable. The packet buffer takes up most of it (and applications should construct their data to send directly within this buffer when possible). Constant strings in the user's program also take up RAM; if your "Serial.println" is just outputting a newline, when you expect it to do something else, your program has probably outgrown the 2k RAM. If you can find the build directory, you can run avr-objdump -h on the .elf file and add up the sizes of the .data and .bss sections - if this is approaching 2k you're in trouble.

How are we going to manage memory allocation for connection state? The size is application-dependent, and I think most people are going to want at least two applications running at once (even if one of them is just the DHCP client).

uIP as distributed assumes that there's going to be a single TCP application and a single UDP application. State for each connection to these applications is allocated at compile time as a member of the uIP connection structure.

How much space is an application going to need, per connection?

TCP applications: (Note: struct psock is 20 bytes) hello-world: 70 bytes webclient: 359 bytes webserver: 128 bytes telnetd: 75 bytes smtp: 17 bytes (but implementation looks buggy!)

UDP applications: resolv: 2 bytes per-connection, plus 41 bytes per cache entry (default 4) dhcpc: 43 bytes (possibly reducible to 41 bytes)

(On further reflection, per-connection state for UDP is really pointless. I expect apps using UDP will have a single copy of their state allocated in .data and .bss - we just need to store their appcall function pointer in uIP's UDP connection structure so we can demultiplex based on destination port number.)

With no applications beyond the DHCP client, uIP currently takes about 1k of RAM. That leaves 1k for all the application state, the heap and the stack. I think it's reasonable to be able to serve three TCP connections at once by default; if we allow 150 bytes state per connection that leaves at least 512 bytes for heap and stack.

To allow for multiple applications we need to store a function pointer per connection so the uIP code can call the appropriate handler. I propose to insert this into struct uip_conn and define the UIP_APPCALL() macro to indirect through it.

How does this function pointer get into the uip_conn structure? We need to modify the code that opens a connection to put it there. Store the pointer for each listening port, and insert it into the newly-formed connection.