[[!meta copyright="Copyright © 2008, 2009, 2017 Free Software Foundation,
Inc."]]

[[!meta license="""[[!toggle id="license" text="GFDL 1.2+"]][[!toggleable
id="license" text="Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no Invariant
Sections, no Front-Cover Texts, and no Back-Cover Texts.  A copy of the license
is included in the section entitled
[[GNU Free Documentation License|/fdl]]."]]"""]]

[[!meta title="Hurdish TCP/IP Stack"]]

The Hurd presently uses a [[TCP/IP_stack|hurd/translator/pfinet]] based on code from an old Linux version.
This works, but lacks some rather important features (like PPP/PPPoE), and the
design is not hurdish at all.  Recently lwip, which is an userspace tcp/ip library,
was ported to the Hurd.  If you are only using an ethernet connection, then it is possible to use
lwip as a complete replacement for pfinet.  However, lwip uses the netdde device
drivers for wireless chips, which are old drivers from an old version of linux. To use
lwip for a wifi connection on more modern hardware, one would also need modern
device drivers to access the internet.  The promising approach to this is using
a rump kernel.  This is essentially the New Driver Framework google summer of
code project idea.  Hopefully, one day soon the Hurd project will completely replace pfinit
with lwip.

A true hurdish network stack will use a set of [[hurd/translator]] processes,
each implementing a different protocol layer. This way not only the
implementation gets more modular, but also the network stack can be used way
more flexibly. Rather than just having the standard socket interface, plus some
lower-level hooks for special needs, there are explicit (perhaps
filesystem-based) interfaces at all the individual levels; special application
can just directly access the desired layer. All kinds of packet filtering,
routing, tunneling etc. can be easily achieved by stacking components in the
desired constellation.

Implementing a complete modular network stack is not feasible as a GSoC
project, though. Instead, the task is to take some existing user space TCP/IP
implementation, and make it run as a single Hurd server for now, so it can be
used in place of the existing pfinet. The idea is to split it up into
individual layers later. The initial implementation, and the choice of a TCP/IP
stack, should be done with this in mind -- it needs to be modular enough to
make such a split later on feasible.

This is [[!GNU_Savannah_task 5469]].

Possible mentors: youpi

Exercise: You could try making some improvement to the existing pfinet
implementation; or you could work towards running some existing userspace
TCP/IP stack on Hurd. (As a normal program for now, not a proper Hurd server
yet.)