Summer of Code - Implementing support for IPv6

Project Title: Implementing support for IPv6
Summary: Redesign the TCP/IP stack implementation in gPXE to provide support for IPv6
Mentoring Organization: Etherboot

gPXE uses uIP to implement its TCP/IP stack. uIP is an implementation of the TCP/IP stack which uses a fraction of the resources used by a full fledged TCP/IP implementation.

The project is to implement support for IPv6. uIP (in its current avatar) tightly integrates the TCP and IP layers in order to save code size. As a result, it is not easy to replace IPv4 with any other network layer protocol in uIP. This project aims to re-design the TCP/IP stack of gPXE in order to facilitate IPv6 implementation.

uIP strays away from the conventional API of the TCP/IP stack so that it can cut down on resources. Instead, it implements its own API where the application is implemented as a function call uip_tcp_appcall(). Every time an event occurs (new data received, re-transmit request, etc.) uIP calls the application and testers resolve which event fired the call. At the other end of the stack, the network driver calls uip_input() (when new data arrives) and uip_periodic() (at regular intervals of time) which trigger off the TCP/IP state machine (uip_process()) in uIP.

In the current architecture, refer http://www.cse.iitb.ac.in/nikhilr/etherboot/tcpip-arch.jpg , a wrapper insulates applications above and network devices below from the uIP API. It provides applications above the TCP/IP stack with an API defined by /include/gpxe/tcp.h. It gives the network devices below an API defined by /include/gpxe/netdevice.h to use the network layer protocol.

The current architecture has problems and limitations (taken from the discussion lists):

• uIP was designed for embedded systems and 8-bit micro-controllers. As a result, data representation and arithmetic operations do not utilize the resources offered by the 32-bit architectures.
• The lack of modularity in uIP makes it difficult to implement a new protocol like IPv6 instead of IPv4.
• The current method of invocation imposes restrictions (unnecessarily) on the TCP-based protocol handlers.

A solution to overcome these limitations would be to re-design the TCP/IP stack implementation (essentially replacing the uIP module) keeping to the specifications defined in the gPXE API (refer http://www.cse.iitb.ac.in/nikhilr/etherboot/proposed-arch.jpg). It is necessary to define a clean interface between the transport layer and network layer in order to implement a new protocol like IPv6. The event based model can be replaced but this requires further investigation.

I propose applying the following algorithm to solve the problem (start off with IPv4 and TCP - we will look at other protocols once the interface is more clearly defined):

Step 0: Investigate the working of uIP
Step 1: Define bare necessary requirements of transport layer and network layer
Step 2: Define the interface between these layers based on the requirements
Step 3: Implement the TCP, IP modules using the interface
Step 4: Test implementation; Re-implement if necessary
Step 5: Increase requirements if necessary and go back to step 2
Step 6: Investigate minimum requirements to support IPv6
Step 7: Extend interface/requirements if necessary and go back to step 2
Step 8: Implement IPv6
Step 9: If time permits, implement stretch goals

Step 10: Investigate UDP implementation in Etherboot-5.4 and earlier
Step 11: Extend interface/requirements if necessary and perform steps 2 - 5
Step 12: Implement UDP support
Step 13: Investigate various features that can be added to IPv6
Step 14: Perform steps 7 - 8

The final deliverables for the project are:

1. A clean, well-defined interface between the transport-layer and network-layer. The interface would be generic enough to allow any transport layer protocol to interact with any network layer protocol
2. Re-design and implementation of the TCP/IP stack using the proposed interface (which fits within the gPXE API)
3. Minimal support for IPv6

The stretch goals for the project are:

1. Extension of the gPXE API to include UDP
2. An implementation of UDP/IP (within the extended gPXE API)
3. Support for additional features in IPv6

I have created a timeline for this project using Google Calendar which is available on the following links:

XML
ICAL

Please contact me at nikhilcrao@gmail.com if other formats (or plain text) are more preferable.

I am a 21 year old Computer Science and Engineering graduate [just graduated last week! :) ] from the Indian Institute of Technology, Bombay (IIT Bombay). I am headed to the University of Michigan, Ann Arbor for my graduate studies in the EECS department. My area of interest is computer architecture and distributed systems. Last summer, I was an Extreme Blue Intern ( www.ibm.com/extremeblue) with the Deep Computing group at IBM, Bangalore. The summer before that, I worked with the Center for Formal Verification and Design of Software (CFDVS) at IIT Bombay. This summer, I want to work with Etherboot and the Summer of Code project sponsored by Google!

I have been involved in C/C++ development since high school (for the last 6 years). I have also programmed micro-controllers and micro-processors using assembly and have taught this to my juniors as well. I have been involved in many projects in the past - ranging from small/medium sized course projects to large scale projects like 'A novel de-synchronization technique' and 'BlueStreak middleware for HPC application development' which I implemented in my senior year thesis and in my internship respectively. While I have never been involved in an open source project (yet!), I am enthusiastic about this project and I am confident I can deliver results to your satisfaction.

My exposure to Etherboot and the concept of network booting is recent. In the last week, I have studied the Etherboot manual twice and have gone through the source code once to understand the twisted process of network booting. I am dedicated, passionate and hardworking, and I feel I am well suited to take on and complete this project.

I believe in quality over quantity and I will be sending applications only to Etherboot for this summer of code.

My resume is available at the following link:

PDF

Please let me know if other formats are preferable. My preferred method of contact is by e-mail. The e-mail IDs I check most regularly are nikhilcrao@gmail.com and nikhilr@cse.iitb.ac.in.