Proffered Official Initial Connection Protocol
RFC 165

Document Type RFC - Unknown (May 1971; No errata)
Obsoletes RFC 143, RFC 123, RFC 145
Last updated 2013-03-02
Stream Legacy stream
Formats plain text html pdf htmlized (tools) htmlized bibtex
Stream Legacy state (None)
Consensus Boilerplate Unknown
RFC Editor Note (None)
IESG IESG state RFC 165 (Unknown)
Telechat date
Responsible AD (None)
Send notices to (None)
Network Working Group                                          J. Postel
Request for Comments: 165                                     UCLA - NMC
Obsoletes: 123, 143, 145                                    May 25, 1971
NIC: 6779

           A Preferred Official Initial Connection Protocol*

   This document specifies the their level protocol used to connect a
   user process at one site with a server process at another site.  In
   one instance, the user process will be a Telnet and the server
   process will be a Logger, but there will be other cases.

   This document describes a family of Initial Connection Protocols
   (ICP's) suitable for establishing one pair of connections between any
   user process and any server process, and further to describe the
   parameter values for connecting Telnets and Loggers.  The description
   will be at two levels, the third or user level, and the second or NCP

Third Level Description


   There is no standard notation for describing system calls, which
   initiate and close connections or cause data to be sent, so the
   following *ad hoc* notation will be used.

   Init (local = l, foreign = f, size = s)

           Causes the local Host to attempt to establish a connection
           between socket l at the local Host and socket f, with a byte
           size of s for the connection.

           l is a 32 bit local socket number,
           f is a 40 bit foreign socket number, the high-order eight
             bits of which specify the foreign Host, and
           s is an eight bit non-zero byte size.

           The sum of l and f must be odd.

   Listen (local = l, size = s)

           Causes the local Host to wait for a request for connection to
           local socket l with byte size s.  The process will be woken
           when a connection is established.  The parameters l and s are
           the same as for Init.

Postel                                                          [Page 1]
RFC 165               Initial Connection Protocol           May 25, 1971

   Send  (socket = l, data = d)

           The data named by d is sent over the connection attached to
           local socket l.  l must be a send socket attached to a
           connection.  d is the name of a data area.

   Receive (socket = l, data = d)

           The receive side counterpart to send.

   Close (socket = l)

           Any connection currently attached to local socket l is

A Family of ICP's

   Briefly, a server process at a site attaches a well-advertised send
   socket L and listens.  A user process initiates connection to L from
   its receive socket U.  The byte size for this connection is 32. The
   server process then transmits a 32-bit even number S and closes the
   connection.  The 32-bit number S and its successor, S+1, are the
   socket numbers the server will use.  The final steps are for sockets
   S and S+1 at the server site to be connected to sockets U+3 and U+2
   respectively at the user site.

   Using the notation, the server executes the following sequence:

      Listen (socket = L, size = 32)
      [Wait until a user connects]
      Send (socket = L, data = S)
      Close (socket = L)
      Init (local = S, Foreign = U+3, size Bu)
      Init (local = S+1, foreign = U+2, size Bs)

   The user executes the following:

      Init (local = U, foreign = L, size = 32)
      Receive (socket = U, data = S)
      Optional Close (socket = U)
      Listen or Init (local U+3, foreign = S, size = Bu)
      Listen or Init (local = U+2, foreign = S+1, size = Bs)

   Note that L is a send socket (odd), while S and U are receive sockets
   (even).  Where L, S, or U are used as values of local, they are 32-
   bit numbers; where they are values of foreign, they are 40-bit
   numbers.  The parameters Bs and Bu are the byte sizes to be sent by

Postel                                                          [Page 2]
RFC 165               Initial Connection Protocol           May 25, 1971

   the server and user, respectively.  If the user side declines to
   close socket U, then it must be handled automatically by the second
   level (see page 4).

   Examination of the above sequences reveals that an ICP is
   characterized by three numbers L, Bs, and Bu, and must meet the
   restrictions that

      a) L is a send socket,
      b) Bs and Bu are legal byte sizes, and
      c) For each L there is only one pair of associated byte sizes.

   This last restriction prevents two district services from being
   available through the same socket and distinguished only by the byte

Second Level Description


   The following notation will be used for the NCP Control Command used
   in ICP.

           STR (_ls_, _fs_, _s_)
                   _ls_ = local send socket
                   _fs_ = foreign receive socket
                   _s_ = byte size

           RTS (_ls_, _fs_, _l_)
                   _ls_ = local receive socket
Show full document text