CSCI 4550/8556 Computer Networks

1
CSCI 4550/8556Computer Networks

• Comer, Chapter 3Network Programming and
  Applications

2
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).

3
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.

4
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.

5
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.

6
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.

7
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 doesnt provide the
  richness of the usual networking API. We will
  see more details in later chapters.

8
Example API Overview
Operation Meaning await_contact used by server
to wait for a contact make_contact used by
client to contact a server cname_to_comp 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.
9
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 or
  the server terminates the connection by calling
  send_eof. The other application detects the
  termination of the communication when recv
  returns 0.

10
A Trivial Example
11
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.

12
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)

13
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)

14
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)

15
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)

16
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)

17
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,
• int n)

18
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)

19
API Definition send_eof

• Send_eof terminates the connection c, returning a
  negative number if an error occurred.
• int send_eof (connection c)

20
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 file (control-D on UNIX, or control-Z on
  Windows) is entered.
• Illustration

21
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 sent.

22
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

23
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.
• Illustration