Transcript Part I: Introduction

Chapter 2
Application Layer
A note on the use of these ppt slides:
We’re making these slides freely available to all (faculty, students, readers).
They’re in powerpoint form so you can add, modify, and delete slides
(including this one) and slide content to suit your needs. They obviously
represent a lot of work on our part. In return for use, we only ask the
following:
 If you use these slides (e.g., in a class) in substantially unaltered form,
that you mention their source (after all, we’d like people to use our book!)
 If you post any slides in substantially unaltered form on a www site, that
you note that they are adapted from (or perhaps identical to) our slides, and
note our copyright of this material.
 This slide show has been modified by Gergana Miteva, Angela Murphy
and Sonya Nikolova
Thanks and enjoy! JFK/KWR
All material copyright 1996-2002
J.F Kurose and K.W. Ross, All Rights Reserved
Computer Networking:
A Top Down Approach
Featuring the Internet,
2nd edition.
Jim Kurose, Keith Ross
Addison-Wesley, July
2002.
2: Application Layer
1
Socket programming
Goal: learn how to build client/server application that
communicate using sockets
Two types of
client/server apps
socket
the RFC rules
 Proprietary implementation
created/owned,
OS-controlled interface
 Protocol implementation by
Two types of transport
service


unreliable datagram
reliable, byte streamoriented
an application-
into which
A process can both send
and
receive messages to/from
another process
2: Application Layer
2
Sockets
Socket: a “door” between application process
and end-to-end-transport protocol (UDP or
TCP)
controlled by
application
developer
controlled by
operating
system
process
process
socket
kernel
buffers,
variables
host or
server
internet
socket
kernel
buffers,
variables
controlled by
application
developer
controlled by
operating
system
host or
server
2: Application Layer
3
Stream jargon
 A stream is a sequence of
characters that flow into
or out of a process.
 An input stream is
attached to some input
source for the process, eg,
keyboard or socket.
 An output stream is
attached to an output
source, eg, monitor or
socket.
2: Application Layer
4
Languages and Platforms
Socket API is available for many languages on
many platforms:
 C, Java, Perl, Python,…
 Unix, Linux, Windows,…
Socket Programs written in any language and
running on any platform can communicate
with each other!
2: Application Layer
5
Transport Protocols: Review
 TCP
connection-oriented service
 guaranteed delivery
 flow control
 congestion control mechanism (message
segmentation)

 UDP
connectionless service
 no flow and no congestion control
 faster data delivery, but no guarantee

2: Application Layer
6
Decisions
 Before you write socket code, decide
Do you want a TCP-style reliable, full duplex,
connection oriented channel? Or do you want a
UDP-style, unreliable, message oriented
channel?
 Will the code you are writing be the client or
the server?

• Client: you assume that there is a process already
running on another machines that you need to connect
to.
• Server: you will just start up and wait to be
contacted
2: Application Layer
7
Socket programming with TCP
Client must contact server
 server process must first
be running
 server must have created
socket (door) that
welcomes client’s contact
Client contacts server by:
 creating client TCP socket
 specifying IP address, port
number of server process
 When client creates socket:
client TCP establishes
connection to server TCP
 When contacted by client,
server TCP creates new
socket for server process to
communicate with client
 Frees up welcoming port
 allows server to talk with
multiple clients
application viewpoint
TCP provides reliable, stream
transfer of bytes (“pipe”)
between client and server
2: Application Layer
8
Socket Programming with TCP
Client Process
Server Process
Welcoming
Socket
Three-way handshake
bytes
Client
socket
bytes
Connection
Socket
2: Application Layer
9
Socket programming with TCP
Client
Process
process
input
stream
output
stream
inFromServer
1) client reads line from
standard input (inFromUser
stream) , sends to server via
socket (outToServer
stream)
2) server reads line from socket
3) server converts line to
uppercase, sends back to
client
4) client reads, prints modified
line from socket
(inFromServer stream)
outToServer
Example client-server app:
monitor
inFromUser
keyboard
input
stream
client
TCP
clientSocket
socket
to netw ork
TCP
socket
from netw ork
2: Application Layer
10
Example: Java client (TCP)
import java.io.*;
import java.net.*;
class TCPClient {
public static void main(String argv[]) throws Exception
{
String sentence;
String modifiedSentence;
Create
input stream
Create
client socket,
connect to server
Create
output stream
attached to socket
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
Socket clientSocket = new Socket("hostname", 6789);
DataOutputStream outToServer =
new DataOutputStream(clientSocket.getOutputStream());
2: Application Layer
11
Example: Java client (TCP), cont.
Create
input stream
attached to socket
BufferedReader inFromServer =
new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
sentence = inFromUser.readLine();
Send line
to server
outToServer.writeBytes(sentence + '\n');
Read line
from server
modifiedSentence = inFromServer.readLine();
System.out.println("FROM SERVER: " + modifiedSentence);
clientSocket.close();
}
}
2: Application Layer
12
Pseudo code TCP server
Create socket (WelcomeSocket)
Bind socket to a specific port where clients can
contact you
Server listens on WelcomeSocket for client to
contact it
Loop
Accept new connection (connectSocket)
Read and Write Data Into connectSocket to
Communicate with client
Close connectSocket
End Loop
Close WelcomeSocket
2: Application Layer
13
Example: Java server (TCP)
import java.io.*;
import java.net.*;
class TCPServer {
Create
welcoming socket
at port 6789
Wait, on welcoming
socket for contact
by client
Create input
stream, attached
to socket
public static void main(String argv[]) throws Exception
{
String clientSentence;
String capitalizedSentence;
ServerSocket welcomeSocket = new ServerSocket(6789);
while(true) {
Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient =
new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
2: Application Layer
14
Example: Java server (TCP), cont
Create output
stream, attached
to socket
DataOutputStream outToClient =
new DataOutputStream(connectionSocket.getOutputStream());
Read in line
from socket
clientSentence = inFromClient.readLine();
capitalizedSentence = clientSentence.toUpperCase() + '\n';
Write out line
to socket
outToClient.writeBytes(capitalizedSentence);
}
}
}
End of while loop,
loop back and wait for
another client connection
2: Application Layer
15
Client/server socket interaction: TCP
(Java)
Server (running on hostid)
Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()
TCP
wait for incoming
connection request connection
connectionSocket =
welcomeSocket.accept()
read request from
connectionSocket
write reply to
connectionSocket
close
connectionSocket
setup
create socket,
connect to hostid, port=x
clientSocket =
Socket()
send request using
clientSocket
read reply from
clientSocket
close
clientSocket
2: Application Layer
16
Socket programming with UDP
UDP: very different mindset
than TCP
 no connection just
independent messages sent
 no handshaking
 sender explicitly attaches
IP address and port of
destination
 server must extract IP
address, port of sender
from received datagram to
know who to respond to
application viewpoint
UDP provides unreliable transfer
of groups of bytes (“datagrams”)
between client and server
UDP: transmitted data may be
received out of order, or
lost
2: Application Layer
17
Example: Java client (UDP)
input
stream
Client
process
monitor
inFromUser
keyboard
Process
Input: receives
packet (TCP
received “byte
stream”)
UDP
packet
receivePacket
packet (TCP sent
“byte stream”)
sendPacket
Output: sends
client
UDP
clientSocket
socket
to netw ork
UDP
packet
UDP
socket
f rom netw ork
2: Application Layer
18
Pseudo code UDP client
Create socket
Loop
(Send Message To Well-known port of
server)+
(Receive Message From Server)
Close Socket
2: Application Layer
19
Example: Java client (UDP)
import java.io.*;
import java.net.*;
Create
input stream
Create
client socket
Translate
hostname to IP
address using DNS
class UDPClient {
public static void main(String args[]) throws Exception
{
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("hostname");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
2: Application Layer
20
Example: Java client (UDP), cont.
Create datagram
with data-to-send,
length, IP addr, port
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
Send datagram
to server
clientSocket.send(sendPacket);
Read datagram
from server
clientSocket.receive(receivePacket);
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
String modifiedSentence =
new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
}
2: Application Layer
21
Pseudo code UDP server
Create socket
Bind socket to a specific port where clients
can contact you
Loop
(Receive UDP Message from client x)+
(Send UDP Reply to client x)*
Close Socket
2: Application Layer
22
Example: Java server (UDP)
import java.io.*;
import java.net.*;
Create
datagram socket
at port 9876
class UDPServer {
public static void main(String args[]) throws Exception
{
DatagramSocket serverSocket = new DatagramSocket(9876);
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true)
{
Create space for
received datagram
Receive
datagram
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
2: Application Layer
23
Example: Java server (UDP), cont
String sentence = new String(receivePacket.getData());
Get IP addr
port #, of
sender
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
Create datagram
to send to client
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress,
port);
Write out
datagram
to socket
serverSocket.send(sendPacket);
}
}
}
End of while loop,
loop back and wait for
another datagram
2: Application Layer
24
Client/server socket interaction: UDP
Server (running on hostid)
create socket,
port=x, for
incoming request:
serverSocket =
DatagramSocket()
read request from
serverSocket
write reply to
serverSocket
specifying client
host address,
port umber
Client
create socket,
clientSocket =
DatagramSocket()
Create, address (hostid, port=x,
send datagram request
using clientSocket
read reply from
clientSocket
close
clientSocket
2: Application Layer
25
UDP Server vs Client
 Server has a well-known port number
 Client initiates contact with the server
 Less difference between server and client
code than in TCP
Both client and server bind to a UDP socket
 Not accept for server and connect for client

 Client send to the well-known server port;
server extracts the client’s address from
the datagram it receives
2: Application Layer
26
TCP vs. UDP
 TCP
“pipe” between the two processes
 the pipe is logically connected to the destination
 reliable byte stream channel

 UDP
 no welcoming socket, no pipe
 destination address attached to bytes
 unreliable transport service
 receiving process must unravel each received
packet for packet’s information bytes
2: Application Layer
27