[2.0.

4] Network File Systems

This allows a system to access files on another computer in a

somewhat more closely integrated fashion than FTP. A network file

system provides the illusion that disks or other devices from one

system are directly connected to other systems. There is no need to

use a special network utility to access a file on another system. Your

computer simply thinks it has some extra disk drives. These extra

"virtual" drives refer to the other system's disks. This capability is

useful for several different purposes. It lets you put large disks on

a few computers, but still give others access to the disk space. Aside

from the obvious economic benefits, this allows people working on

several computers to share common files. It makes system maintenance

and backup easier, because you don't have to worry about updating and

backing up copies on lots of different machines. A number of vendors

now offer high-performance diskless computers. These computers have no

disk drives at all. They are entirely dependent upon disks attached to

common "file servers". (See RFC's 1001 and 1002 for a description of

PC-oriented NetBIOS over TCP. In the workstation and minicomputer

area, Sun's Network File System is more likely to be used. Protocol

specifications for it are available from Sun Microsystems.)

[2.0.5] Remote Printing

This allows you to access printers on other computers as if

they were directly attached to yours. (The most commonly used protocol

is the remote lineprinter protocol from Berkeley Unix. Unfortunately,

there is no protocol document for this. However the C code is easily

obtained from Berkeley, so implementations are common.)

[2.0.6] Remote Execution

This allows you to request that a particular program be run on

a different computer. This is useful when you can do most of your work

on a small computer, but a few tasks require the resources of a larger

system. There are a number of different kinds of remote execution.

Some operate on a command by command basis. That is, you request that

a specific command or set of commands should run on some specific

computer. (More sophisticated versions will choose a system that

happens to be free.) However there are also "remote procedure call"

systems that allow a program to call a subroutine that will run on

another computer. (There are many protocols of this sort. Berkeley

Unix contains two servers to execute commands remotely: rsh and

rexec. The man pages describe the protocols that they use. The

user-contributed software with Berkeley 4.3 contains a "distributed

shell" that will distribute tasks among a set of systems, depending

upon load. Remote procedure call mechanisms have been a topic for

research for a number of years, so many organizations have

implementations of such facilities. The most widespread

commercially-supported remote procedure call protocols seem to be

Xerox's Courier and Sun's RPC. Protocol documents are available from

Xerox and Sun. There is a public implementation of Courier over TCP as

part of the user-contributed software with Berkeley 4.3. An

implementation of RPC was posted to Usenet by Sun, and also appears as

part of the user-contributed software with Berkeley 4.3.)

[2.0.7] Name Servers

In large installations, there are a number of different

collections of names that have to be managed. This includes users and

their passwords, names and network addresses for computers, and

accounts. It becomes very tedious to keep this data up to date on all

of the computers. Thus the databases are kept on a small number of

systems. Other systems access the data over the network. (RFC 822 and

823 describe the name server protocol used to keep track of host names

and Internet addresses on the Internet. This is now a required part of

any TCP/IP implementation. IEN 116 describes an older name server

protocol that is used by a few terminal servers and other products to

look up host names. Sun's Yellow Pages system is designed as a general

mechanism to handle user names, file sharing groups, and other

databases commonly used by Unix systems. It is widely available

commercially. Its protocol definition is available from Sun.)

[2.0.8] Terminal Servers

Many installations no longer connect terminals directly to

computers. Instead they connect them to terminal servers. A terminal

server is simply a small computer that only knows how to run telnet

(or some other protocol to do remote login). If your terminal is

connected to one of these, you simply type the name of a computer, and

you are connected to it. Generally it is possible to have active

connections to more than one computer at the same time. The terminal

server will have provisions to switch between connections rapidly, and

to notify you when output is waiting for another connection. (Terminal

servers use the telnet protocol, already mentioned. However any real

terminal server will also have to support name service and a number of

other protocols.)

[2.0.9] Network-Oriented Window Systems

Until recently, high- performance graphics programs had to

execute on a computer that had a bit-mapped graphics screen directly

attached to it. Network window systems allow a program to use a

display on a different computer. Full-scale network window systems

provide an interface that lets you distribute jobs to the systems that

are best suited to handle them, but still give you a single

graphically-based user interface. (The most widely-implemented window

system is X. A protocol description is available from MIT's Project

Athena. A reference implementation is publicly available from MIT. A

number of vendors are also supporting NeWS, a window system defined by

Sun. Both of these systems are designed to use TCP/IP.)

Note that some of the protocols described above were designed by Berkeley, Sun, or other organizations. Thus they are not officially part of the Internet protocol suite. However they are implemented

using TCP/IP, just as normal TCP/IP application protocols are. Since the protocol definitions are not considered proprietary, and since commercially-support implementations are widely available, it is

reasonable to think of these protocols as being effectively part of the Internet suite.

Also note that the list above is simply a sample of the sort of services available through TCP/IP. However it does contain the majority of the "major" applications. The other commonly-used protocols tend to be

specialized facilities for getting information of various kinds, such as who is logged in, the time of day, etc. However if you need a facility that is not listed here, we encourage you to look through the current edition of Internet Protocols (currently RFC 1011), which lists all of the available protocols, and also to look at some of the major TCP/IP implementations to see what various vendors have added.

[2.1.0] General description of the TCP/IP protocols

TCP/IP is a layered set of protocols. In order to understand what this means, it is useful to look at an example. A typical situation is sending mail. First, there is a protocol for mail. This defines a set of commands which one machine sends to another, e.g. commands to specify who the sender of the message is, who it is being sent to, and then the text of the message. However this protocol assumes that there is a way to communicate reliably between the two computers. Mail, like other application protocols, simply defines a set of commands and messages to be sent. It is designed to be used together with TCP and IP.

TCP is responsible for making sure that the commands get through to the other end. It keeps track of what is sent, and retransmits anything that did not get through. If any message is too large for one

datagram, e.g. the text of the mail, TCP will split it up into several datagrams, and make sure that they all arrive correctly. Since these functions are needed for many applications, they are put together into

a separate protocol, rather than being part of the specifications for sending mail. You can think of TCP as forming a library of routines that applications can use when they need reliable network

communications with another computer.

Similarly, TCP calls on the services of IP. Although the services that TCP supplies are needed by many applications, there are still some kinds of applications that don't need them. However there are some

services that every application needs. So these services are put together into IP. As with TCP,

you can think of IP as a library of routines that TCP calls on, but which is also available to applications that don't use TCP. This strategy of building several levels of protocol is called "layering". We think of the applications programs such as mail, TCP, and IP, as being separate "layers", each of which calls on the services of the layer below it. Generally, TCP/IP applications use 4 layers: an application protocol such as mail, a protocol such as TCP that provides services need by many applications IP, which provides the basic service of getting datagrams to their destination the protocols needed to manage a specific physical medium, such as Ethernet or a point to point line.

TCP/IP is based on the "catenet model". (This is described in more detail in IEN 48.) This model assumes that there are a large number of independent networks connected together by gateways. The user should be able to access computers or other resources on any of these networks. Datagrams will often pass through a dozen different networks before getting to their final destination.

The routing needed to accomplish this should be completely invisible to the user. As far as the user is concerned, all he needs to know in order to access another system is an "Internet address". This is an

address that looks like 128.6.4.194. It is actually a 32-bit number. However it is normally written as 4 decimal numbers, each representing 8 bits of the address. (The term "octet" is used by Internet documentation for such 8-bit chunks. The term "byte" is not used, because TCP/IP is supported by some computers that have byte sizes other than 8 bits.) Generally the structure of the address gives

you some information about how to get to the system. For example, 128.6 is a network number assigned by a central authority to Rutgers University. Rutgers uses the next octet to indicate which of the

campus Ethernets is involved. 128.6.4 happens to be an Ethernet used by the Computer Science Department. The last octet allows for up to 254 systems on each Ethernet. (It is 254 because 0 and 255 are not allowed, for reasons that will be discussed later.) Note that 128.6.4.194 and 128.6.5.194 would be different systems. The structure of an Internet address is described in a bit more detail later.

Of course we normally refer to systems by name, rather than by Internet address. When we specify a name, the network software looks it up in a database, and comes up with the corresponding Internet

address.