Update of "ncpunix"
Not logged in

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

Overview

Artifact ID: 786402524d48f88ba267e6c8755174d10a0b0faf
Page Name:ncpunix
Date: 2017-03-08 11:28:01
Original User: pnr
Parent: 02a260b6054a0aea995d8a089577d8b205732731
Content

NCP Unix a.k.a. "Network Unix"

Network Unix was a V6 Unix, enhanced to be an Arpanet host. It contained a small network kernel, an NCP protocol daemon and a suite of utility programs.

Introduction

NCP Unix was developed at the University of Illinois at Urbana-Champaign (UoI/UC). Its first version was based on 5th Edition Unix and developed between December 1974 and March 1975. All Unix systems on the Arpanet in the late seventies appear to have used NCP Unix or derivatives of it (all on PDP-11's). It was maintained until the early eighties, when it was largely replaced by TCP/IP based implementations for the VAX.

The design of NCP Unix was remarkably prescient and its API still looks familiar over 40 years later. The various utilities, like FTP and Telnet would probably require only a modest porting effort to run on a modern system. Some of its internal design choices persisted into later TCP designs, some well into the eighties (e.g. kernel buffer management).

The version of the NCP Unix source code in the Archive is from 1979. Even in this evolved form, the core system was surprisingly small: the Arpanet kernel code only amounts to some 1,700 lines and the NCP daemon to some 2,200 lines of C code (excluding comments and blank lines).

Source code

The source of NCP Unix has survived in its 1979 form. The network extensions to the kernel are little changed from the 1975 version and documented in the source. However, the source was reorganized to make adding new drivers easier. The 1979 version includes a full complement of networking software, including some early email software.

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

Emulation

Currently no emulation for this Unix version is available.

History

The Center for Advanced Computation ("CAC")

After the ILLIAC I, II and III super computers were built at UoI/UC, the ILLIAC IV was to be built in California with UoI researchers getting access over the nascent Arpanet. The Center for Advanced Computation was conceived to facilitate full utilization and exploitation of the potentials of the ILLIAC IV computer by acting as a liaison facility between computer technologists and experts in the physical, life, and social sciences.

At first that meant providing Telnet access to lots of users. Under the supervision of Gary Grossman, the CAC team created the "ARPA Network Terminal System" running on a PDP11/20. Basically it provided Telnet service to lots of glass TTYs. [According to Jody Kravtitz, their PDP11/20 was the first to have two Unibus repeaters because each terminal adapter supported so few ports and they shook some bugs out of the Unibus repeaters as a consequence.] ANTS ran on the bare metal and provided its own operating system functions.

The 2nd version of ANTS was to run on the PDP11/45 with it's larger address space. It would support other features besides Telnet. While Gary single-handedly wrote the original ANTS, the 2nd iteration, ANTS Mark II had several people writing modules for it. Bugs were abundant and frustrating. At a staff meeting Gary announced that he would "never again name an operating system after a bug!" Yet, it provided the team with valuable experience.

Unix arrives at UoI

Around this time Greg Chesson arrived at the UoI/UC and helped bring the UNIX operating system to campus by convincing Professor Donald Gillies to purchase a license (some sources say that this was the first Unix license ever). The ANTS team felt this could be a good base for a mini-computer Arpanet host.

The original design was done between December 1974 and March 1975 by Gary Grossman, Steve Holmgren and Steve Bunch and each of them had a hand in the original coding. Holmgren carried through for several months thereafter, making changes and additions and bringing up the initial versions of the higher level protocols. Greg Chesson also made important contributions during this time.

Steve Holmgren recalls: There was a lot of pressure to find a mini-computer solution to Arpanet access. With Gary's previous work on ANTS I and then ANTS II he had built from bare metal - and in the case of ANTS I using paper tape - network OS level support and NCPs twice. I was privileged to do the development on the ANTS II NCP so we had quite a bit of architecture and development experience in what we needed to make an operating Arpanet host. This made structural decisions like keeping the kernel additions limited to handling data flow and providing for a swappable application level daemon to handle connection setup and tear down fairly clear almost from the outset. This was also in play at a more granular level in that Im not sure I remember even a discussion about whether we needed our on set of message primitives or could we rely on clists - so given were we were coming from with no small number of arrows in our development backs, the daemon and kernel code went together well and held up under a lot abuse.

Steve Bunch writes: The original 1975 version did not extend the UNIX APIs, it used the file I/O operations (open / close / read / write / gtty / stty) exclusively, overloading networking onto existing system calls, e.g., by including network information in the “file name”. No new system calls or kernel changes were necessary, it was all done at device driver level to avoid messing with UNIX itself. I wrote the kernel buffer management (mbuf) code, Steve Holmgren wrote the kernel read/write path of the NCP, and Gary Grossman wrote the user-level NCP daemon that did the connection protocol and managed the network interface. It was written in a very brief period (weeks), and had very few bugs. (I committed one of the worst, a memory leak caused by calling the wrong kernel buffer method to free a no-longer-needed kernel buffer). Very little besides the RFC681 Steve Holmgren wrote and a paper by Greg Chesson were ever published or documented about the original version.

And Gary Grossman adds: Steve Holmgren, Steve Bunch, and I met daily for a couple of weeks to design the protocol between the kernel part of the NCP and the NCP daemon. Then the Steves and I each went off and built our part, theirs as kernel device driver and mine as the daemon. The lack of bugginess that Steve Bunch refers to was in part due to our having as model an NCP written in a high-level (well, middle-level, anyway) language, the one for ANTS I in PEESPOL. That one had been working 24/7 for a couple of years by then.

Jody Kravitz then took over prime responsibility for the NCP and proved major cleaning and clarifying of the code. Particularly important were revisions to make it easier to use other IMP interfaces and the code for several such interfaces, including the Very Distant Host (VDH) interface.

Jody Kravitz recalls: The Network Unix ran on the PDP11/45 with it's memory management and did what ANTS Mk II wanted to do but failed at. An operating system that could run multiple user processes and swap things out as needed if available memory was a problem made it possible to focus implementing network protocols and client applications. It was a fun time.

During this period Richard Balocca was also a major contributor. Others who have had a role either in the NCP or protocol software include John McMillian, Jay Goldberg, Paul Jones, Bob Schulman, James Gast, Marsha Conley, and Karl Kelley. Steven Abraham (from UCLA) and Steve Tepper (from Rand) were important outside contributors.

Digital Technology Incorporated (DTI)

The Center for Advanced Computation was abolished as an independent administrative unit on June 30, 1978 and the NCP Unix activities spun out to a new entity, Digital Technology Incorporated.

DTI further developed the NCP Unix code base as a front end system to offload network connectivity from mainframe computers. These systems were known as "ENFE" and "INFE". More specifically, the ENFE and INFE were front ends between WWMCCS Honeywell H6000 mainframes and the Arpanet and AUTODIN II, respectively, using the purpose-designed Host to Front End Protocol (HFP).

The purpose of the ENFE (Experimental Network Front End) was to investigate whether it would be effective to offload network processing from the H6000 mainframe to an outboard minicomputer using HFP and the Arpanet protocols as implemented in Network Unix.

The INFE (Interim Network Front End) was to serve as an interim operational NFE from a WWMCCS H6000 mainframe to the AUTODIN II network using HFP and the TCP/IP suite. The INFE was termed "interim" because there was to be an NFE based on a Communications Operating System, the COS/NFE, which would provide better performance as well as DOD-level security. This system was completed, but it was shelved - as was the AUTODIN II network - in 1982.

As a result INFE became a permanent solution, connecting nodes over a dedicated Arpanet-like network called "PWIN". This remained in place until the WWMCCS system was decommissioned in the early 90's. Hence, in one form or another, the NCP Unix code was in service for nearly 20 years.

DTI was also involved with creating TCP/IP implementations for Unix, but in the end ported this work to VMS under direction from DARPA.

Legacy

NCP Unix established the paradigm that a network connection is just another byte stream, accessed via a file handle and the file primitives. To a large extent this paradigm survives to the present day. The most common usage patterns of the "BSD sockets API" today are very similar to the API popularized by NCP Unix in the mid-seventies.

One of the main Arpanet contractors, Bolt, Beranek & Newman (BBN), was quick to adopt the UoI/CAC code base. Among the enhancements were improved facilities for interprocess communication and network programming. It also became the base for BBN's experimental work on Unix TCP/IP.

This work was the basis for the reference TCP/IP implementation done at BBN for 4.1 BSD. Although the network kernel and TCP/IP stack was all new code, it used an API that is a close derivative of that of the original NCP Unix. Some of the networking utilities (FTP and Telnet) were ports from NCP Unix. This BBN reference implementation in turn became the base for the TCP/IP stack in 4.1a BSD.

Further reading

This version of NCP Unix is documented in great detail in three CAC reports from April1978:

NCP Unix was first announced in March 1975 in RFC681. This was followed later that year by a paper by Greg Chesson describing it in more detail.