TCP ancestry (was re: is IETF is being shunned...)

[Craig Partridge <[e-mail]>]

> I wonder what percentage of TCP/IP stacks are still based on the BBN
reference implementation Rob Gurwitz wrote for BSD.

I would say "few or none".  On the other hand, if you'd asked how many
modern TCP/IP stacks were "influenced by" Rob's implementation,  I'd say
most.

For those who are curious, a quick history. Much is by memory as searching
the web I see partial histories -- much of the messy aspects are politely
ignored -- but I probably also get some bits wrong here.  And this
conversation, if it persists, should migrate to the internet-history list
(I'm replying here because some newer TCP experts in IETF may be interested
in the background):

In the 1970s, there were several TCP implementations and they were debugged
together in TCP bakeoffs that helped shape the TCP spec.  (Infamously,
implementing the checksum proved hard and the TCP spec contains the
description used by the team deemed to have implemented it best). The UNIX
implementation was done at BBN, if I remember correctly, by Jack Haverty.

(D)ARPA was hunting for a research operating system to succeed TENEX. Unix
was the obvious choice except it (a) lacked virtual memory and (b) lacked
networking.  So ARPA funded Berkeley to put VM into Unix and funded BBN to
enhance Haverty's Unix TCP for virtual memory and integrate it with the
Berkeley UNIX.   Rob Gurwitz did the BBN TCP work -- which required
substantial effort (e.g. Rob had to invent a way to create packet buffers
in a VM system and developed mbufs -- and much of how we think about
network buffering is influenced by Rob's decisions; Rob also redid the code
to work with software interrupts).  The resulting BSD updated Unix with
virtual memory and Rob's TCP code became 4.1BSD.

Bill Joy did not like the BBN TCP implementation.  I've heard many stories
about Bill's motivation but never seen/heard anything from Bill, so I'll
stick to two obvious dislikes you can infer from his code: (1) the BBN TCP
used /dev/tcp and ioctls and Bill felt the API was ugly and so he created
sockets; and (2) the BBN TCP used a state table on the inbound side (packet
type x socket state -> routine to give packet to) while Bill preferred a
flat (large) IP input routine.  So Bill rewrote the BBN TCP into his
preferred form -- having read the two versions, my sense is Bill wrote his
own code for much of it, but sought to stay bug-for-bug compatible with the
BBN 4.1 TCP.  He also retained mbufs and the basic software interrupt
architecture.  (I still remember c. 1989 when a TCP bug appeared in BSD,
the BSD folks made a point of saying it was in the BBN 4.1 code).  This was
released as 4.1c and then 4.2BSD.

Bill's rewrite caused pain.  The BBN TCP had been improved for the expected
4.2BSD release (the BSD release tape left out the improved BBN TCP) and
Bill's rewrite of 4.1's TCP effectively was a step backwards in TCP
maturity.  ARPA was not happy that BSD had spent money duplicating
(superceded) BBN work. There were moments when it appeared ARPA might try
to force BSD back to using BBN code.  That did not happen (my personal
sense -- sockets was so clearly an API win, that it carried the day) and
the result is that the reference TCP/IP in the 1980s, from which many TCPs
are derived, was descended from Bill's BSD implementation.

So Rob's code influenced the reference BSD implementation in the 1980s, but
the BSD implementation was (sorta) distinct and that's the one that carried
down to today.

Craig (who worked with the BBN code briefly c. 1985 and ran the BBN BSD
networking code project for DARPA from 1986 to 1991 or so)

-- 
*****
Craig Partridge's email account for professional society activities and
mailing lists.