Transcript CSC383 Lecture notes Ch 1 2 3

CSC383 Computer Networks
Dr. Allen M. Johnson, Jr.
History…
1st networks designed to share large-scale
computational power
 1st commercially available network system
was IBM’s PROFS system. (mainframes)
 Late 1960s, ARPA started investigating data
networking.

– Idea of networking computers of different
architectures
– Thought to be a crazy idea by many
… History…
In the late 1970s inexpensive
minicomputers provided time-sharing
facilities to people within a department.
 Organizations installed Local Area
Networks (LANs) to interconnect these
machines together.

…History…
ARPA chose to investigate a revolutionary
approach, known as packet switching.
 They hired people to work on network
research and contractors to turn the designs
into a working system called the ARPANET.
 This was so successful that ARPA continued
funding research into a networking
technology called internetworking.

…History
By the 1970s, internetworking was the
focus of ARPA research and the Internet
had emerged.
 ARPA continued funding research into the
1980s,
 Internet became a commercial success in
the 1990s.

Growth of Internet
The Internet has grown from an early research
prototype into a global communications system
that connects every country.
 By 1999, the Internet was growing so fast that a
new computer was added to the Internet every
second.

…Growth of Internet
…Growth of Internet
Protocols and Layering
Computer networks are complex systems
including both hardware and software.
 Designers divided the communication
problem into subparts, called layers, with the
interfaces between the layers defined by
protocols.

TCP/IP 5-layer Reference Model
TCP/IP Layered Model





physical layer corresponds to basic network hardware.
Network interface layer specifies how data is divided into
frames for transmission over a network.
Internet layer protocols specify the format of packets sent
across an internet as well as the mechanisms used to
forward packets from a computer through one or more
routers to a final destination.
Transport layer specifies how to provide reliable transfer
and the Transmission Control Protocol (TCP) software
also provides additional facilities required by higher-level
applications.
Application layer specifies how applications use the
Internet.
Probing the Internet
Simplest probing tool is the Packet InterNet
Groper, or ping.
 According to the Internet requirements
document [RFC 1122] , every TCP/IP stack
should implement such a program.

PING Command Example
penguin(101)% ping -c5 www.netbook.cs.purdue.edu PING
lucan.cs.purdue.edu (128.10.19.20) from 193.61.29.127: 56(84) bytes of data
64 bytes from lucan.cs.purdue.edu (128.10.19.20): icmp_seq=1 ttl=235
time=131 ms 64 bytes from lucan.cs.purdue.edu (128.10.19.20): icmp_seq=2
ttl=235 time=131 ms 64 bytes from lucan.cs.purdue.edu (128.10.19.20):
icmp_seq=3 ttl=235 time=131 ms 64 bytes from lucan.cs.purdue.edu
(128.10.19.20): icmp_seq=4 ttl=235 time=131 ms 64 bytes from
lucan.cs.purdue.edu (128.10.19.20): icmp_seq=5 ttl=235 time=131 ms --lucan.cs.purdue.edu ping statistics --- 5 packets transmitted, 5 received, 0%
loss, time 4008ms rtt min/avg/max/mdev = 131.394/131.742/131.978/0.317
ms penguin(102)%
• -c5 instructs ping to stop after sending five probes
• summary on the first line indicates an alternative name for the target is
lucan.cs.purdue.edu, that its IP address is 128.10.19.20, and it’s sending 56 bytes
of data in an 84-byte IP datagram.
•The next five lines are the responses received. These indicate that there are
What Good Is PING

Cons
– Little info for average user
– Not good as debug tool
» Output occurs only when computer responds
» Fails if network is congested
» PING cannot determine cause of problem
» Some companies configure systems to reject pings

Pros
– Determine which part of network is still operating
– Results help pinpoint failure quickley
Traceroute
Determine intermediate computers along
the way
 Uses same arguments as PING (remote
computers name or address)
 Shows how the hops between source and
destination.
 http://www.net.cmu.edu/cgi-bin/netops.cgi

Figure 2.6
Chapter 3 Introduction
Use of a network requires programs (and
systems) that are “network-aware.”
 Some applications are usually provided with
machines (e.g. web clients, e-mail clients,
file sharing).
 New custom applications must use the
interface (API) to the network facilities
provided by the system.
 We will look at a simple API and three
sample applications (both the client and the
server).

Network Communication
Networks are the mechanisms that transmit
data from one point to another.
 Logically, networks are (or should be)
passive, and do not understand, act on, or
modify the data being moved.
 There are two ends of a network
communication, each associated with an
application program that understands the
generation and interpretation of the data
being moved across the network.

Client-Server Computing
The two applications that communicate
using a network must locate each other.
 Typically, one application (the server) starts
and then waits for the other application (the
client) to contact it.
 This arrangement is usually called the
client-server paradigm, or just client-server
computing.
 The client must, of course, be able to locate
the server for this arrangement to work.

Addressing Internet Applications




Each network server application has a two-part address of
the form (computer,application).
The computer part of the address identifies the particular
computer on which the application is running. This can be
provided in symbolic (e.g. apollo.unomaha.edu) or
numeric (e.g. 137.48.1.12) form.
The application part of the address identifies the particular
application. It, too, can be provided symbolically or
numerically.
When transmitted on a network, the
(computer,application) address is always sent in binary.
Communication Paradigm

Most Internet applications follow this basic
sequence of operations for communication:
– The server starts first, and waits for contact
from a client.
– The client contacts the server by specifying its
location and requesting communication.
– The client and the server exchange messages.
– After they finish, the client and server each
send an end-of-file to terminate communication.

Functions are provided in the class library
on apollo to perform each of these tasks.
An Example Application Program Interface
The term “application program interface,”
or API, is used to describe the set of
operations available (in a particular
programming domain) to a programmer.
 The simplified API presented in the
textbook hides much of the complexity in
network programming, but also doesn’t
provide the richness of the usual networking
API. We will see more details in later
chapters.

Example API Overview
Operation
await_contact
make_contact
cname_to_comp
Meaning
used by server to wait for a contact
used by client to contact a server
translate a computer name to an
equivalent internal binary value
appname_to_appnum translate a program name to an
equivalent internal binary value
send
used by client or server to send data
recv
used by client or server to receive data
send_eof
used by client or server after all data
has been sent.
An Intuitive Look at the API

The application actions usually follow this
pattern:
– The server calls await_contact to wait for
contact from a client. The client calls
make_contact to establish the connection. [The
server is said to be blocked until the contact is
made.]
– Once contact is made, the applications use send
and recv to exchange data. [The protocol
dictates when each application sends or
receives.]
– Once the data exchange is complete, the client
A Trivial Example
API Definition – Data Types

There are three data types (in addition to the
usual integer, character, and real data types)
used in the API:
– appnum: a binary value used to identify an
application [this is really a port number].
– computer: a binary value used to identify a
computer [this is really an Internet Protocol
address, or IP address.]
– connection: a value used to identify one
endpoint of a connection between a client and a
server [normally this identifies a socket data
structure].
API Definition –
await_contact

A server calls await_contact to wait
for a contact from a client. The function
expects one argument of type appnum, and
returns a connection which is then used
in send, recv, and send_eof functions.
connection
await_contact
(appnum a)
API Definition – make_contact

A client calls make_contact to establish
contact with a server. The arguments
identify the computer on which the server
is running, and the application number to be
contacted. The function returns a
connection used for send, recv, and
send_eof by the client.
connection
make_contact (computer
c, appnum a)
API Definition –
appname_to_appnum

This function is used to translate from a
predefined human-readable name [character
string] to a binary application number.
Standard application names are defined in
the /etc/services file on a UNIX system. It
takes a string argument and returns the
binary application number.
appnum
appname_to_appnum
(char *name)
API Definition –
cname_to_comp

This function translates a symbolic
computer name (cname) to the equivalent
binary form (which is returned) of type
computer.
computer
cname_to_comp (char
*cname)
API Definition – send

Send arranges to transmit data (a sequence
of n bytes in a char array buf) over an
established connection c, returning the
number of bytes actually transmitted. The
last argument is always 0 in this simplified
API.
int send (connection c, char
*buf,
int n, 0)
API Definition – recv

Recv receives at most n bytes of data from
a connection c, placing it in a char array
buf, and returning the number of bytes
received and stored. Recv will return 0
only when the end of file is reached, and a
negative value when an error occurred (e.g.
recv without a valid connection).
int recv (connection c, char
*buf,
API Definition – recvln

Recvln reads one line of data (terminated
by an end of line character) from a
connection c into a char array buf; no
more than n-1 bytes will be read (allowing
one byte for string termination). Recvln
uses recv to read one byte at a time.
int recvln (connection c, char
*buf,
int n)
API Definition – send_eof

Send_eof terminates the connection c,
returning a negative number if an error
occurred.
int send_eof (connection c)
The ECHO Application



The ECHO application server merely resends each
line it receives from a client. The server is started
(from a command line) by typing the program
name and a selected application number (usually
in the range 1025 to 32767).
The client application is started by typing its
name, the name of the computer on which the
server is running, and the same application
number.
Lines are then read by the client, echoed by the
server, and displayed by the client, until an end of
An Important Observation
If you examine the code for the echo client,
you will find that it does not immediately
read another line from the keyboard after
reading data from the connection. This is
because recv only returns as much data as it
has actually read.
 The reason for this is that the underlying
network may send a group of data bytes in
several different packets. Thus the received
data may arrive in pieces with sizes
different from those used when the data was

The CHAT Application
The chat application is similar to the echo
application. Here, however, the server
displays the received data line and waits for
a response from the user on that machine,
which is then sent back to the client for
display.
 Either the user at the server machine or the
user at the client machine may terminate the
chat session by entering an end of file.
 Illustration…

The WEB Application


Our final example is a simple text-mode web
server and browser. Only two web pages are
provided by the server: “/” and “/time”. It is easy,
however, to extend this application to deliver
arbitrary pages stored as files on the server
machine.
The server and client both use the standard HTTP
protocol, and the server delivers HTML
documents with appropriate headers. Thus a
commercial web browser could be used to contact
our server.