Update of "wingfield"
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.


Artifact ID: c8a1f13e35637907321007233e9482becb8fa9bc
Page Name:wingfield
Date: 2017-03-07 20:17:31
Original User: pnr
Parent: 8fe15f16cdee1a25a3a0bc58a850efb71a62c661

The BBN-Wingfield TCP/IP stack

The TCP/IP stack for V6 Unix done by Mike Wingfield at Bolt Beranek & Newman (BBN) appears to be the first TCP/IPv4 stack done for Unix. It followed on from the experimental Haverty design. The TCP/IP daemon was rewritten from scratch in C and the kernel also included support for NCP. It could only run on larger PDP-11's: the /70 and derivatives.

The Wingfield implementation is notable for its support for the "SPT" (security, precedence and user group) mechanism in the early TCP/IPv4 spec. This concept came from the Autodin II network that for a while competed with the Arpanet. This may be the only C code that documents what was intended with this feature.

The Wingfield TCP/IP implementation was later maintained by Ed Cain at DCEC and saw service past 'flag day' into the mid 80's. It's main competitor was the UNet TCP/IP implementation done by 3Com.

Source code

The source of the BBN-Wingfield TCP/IP Unix has survived in its December 1979 form. The version that participated in the March 1979 "bake-off" organized by DARPA survived as printouts. The latter have been retyped and are now also available in machine readable form. The earlier version includes driver code for the Autodin II network, in addition to support for Arpanet-style networks.

The source code can be found here in the Unix Tree and here in the Archive.

Source code for the later DCEC maintained versions has not yet been found.


Currently no emulation for this Unix version is available.


By the summer of 1978 the design and specification for TCP had progressed to version 4 and was considered more or less complete (there would be a few more changes in the run up to 'flag day'). The DoD proceeded to adopt TCP/IPv4 as its standard internetworking protocol in December 1978, but added that the Arpanet protocol should incorporate the precedence, security, and community of interest controls (often abbreviated "S/P/T" or "SPT"). For reference see IEN152. The IP protocol with support for the SPT features was sometimes referred to as "PSIP".

Hence, in late 1978, early 1979 the pressure was on to develop implementations of TCP/IPv4 for all the common hosts on the Arpanet at that time, and to make sure they interoperated as planned (see IEN69, IEN70, IEN76 and IEN77).

The Defense Communications Engineering Center (DCEC) was tasked with bringing research projects into production where appropriate and it needed a usable TCP implementation for PDP-11 Unix. The BBN-Haverty implementation looked like a reasonable start for this. Ed Cain, who was a manager at DCEC, initiated a project to build a TCP4 stack for Unix on the larger PDP11 machines with split I/D capability and more memory. BBN was awarded the contract and Mike Wingfield was tasked with implementing this.

The specification called for an implementation that could simultaneously handle NCP traffic for some user processes and TCP traffic for other user processes. In order to achieve this the starting point was the full NCP Unix kernel, extended with Rand ports and Haverty's await and capac system calls. The NCP kernel was than extended with a "raw message interface" (RMI) that allowed the sending and receiving of raw Host-IMP messages (somewhat like a TAP/TUN device in modern Linux). This kernel work was done by jsq at BBN {ask Jack who jsq was}.

Mike was a veteran of the Arpanet, for instance having designed the interface linking the SDS Sigma 7 computer at UCLA with the first IMP in 1969. He decided to follow the general structure of the Haverty design (i.e. a user space TCP daemon connecting to client programs over Rand ports). However, the TCP daemon was redesigned from the ground up, this time written in C and including support for the S/P/T features prescribed by the DoD. In order to test this, early versions of the code included an Autodin II driver as well as an Arpanet driver.

The user library was also rewritten to include support for the S/P/T features, although its API was very similar to the one that Haverty wrote (not surprising, as Mike Wingfield and Jack Haverty worked on the same corridor, sharing a computer lab and frequently discussing TCP implementation).

Mike was new to C but had some prior experience writing BCPL. As a result his code looked rather different from that of contemporary C programs: it uses camel case identifiers and some constructs that are BCPL specific (see here). Most likely Mike used the "Typesetter C" version of the C compiler, as the code uses some features that are not available in a stock V6 compiler, such as longs.

The result worked well. On a PDP-11/70 the code could push data a speed of about 10KB/s, double that of the Haverty's version on a (slower) PDP-11/40. This speed was about half of that achieved for NCP traffic, which moved at 20-25KB/s. In the March 1979 the code came up top for interoperability in an informal, tongue-in-cheek competition between the various implementations.

The code was then delivered to DCEC who further maintained and improved it. Code was added to support re-assembly of fragmented packets and next to the Rand port based interprocess communication an option was added to use shared memory to communicate between processes and this improved performance further. Last but not least the development in standards was tracked (such as the introduction of the ICMP protocol in 1981). By October 1981 the DCEC improved version of the Wingfield code was probably the first TCP implementation that would still interoperate with modern implementations.


This TCP/IP stack saw use on various Unix V6 systems in the early 80's and was instrumental in ensuring that PDP-11 hosts on the Arpanet could actually continue to operate across 'flag day' (1 January 1983). However, with the PDP-11 rapidly losing ground to the VAX and workstations as the eighties progressed it never was more than a transitional solution.

BBN and DARPA lost interest in this implementation around 1980 as they focussed on creating a new reference implementation for the new 32-bit world. This became the BBN-Gurwitz implementation, arguably the first full implementation of the "modern" TCP/IP protocols.

Further reading

The BBN-Wingfield stack is further described in: