protocols rules for communicating between two entities (e.g., a client and a server) “a protocol...
Post on 22-Dec-2015
223 views
TRANSCRIPT
Protocols
• Rules for communicating between two entities (e.g., a client and a server)
• “A protocol definition specifies how distributed system elements interact with one another in order to achieve a specified behavior, and the structure of the information exchanged during this interaction.” [Foster et. al, 2001]
Next, a short tutorial on some basic networking concepts…
Brief Network Tutorial
Physical (e.g., cables, etc.)
Data Link (e.g., Ethernet)
Network (e.g., IP)
Transport (e.g., TCP, UDP)
Application (e.g., FTP, HTTP, telnet)
Network Model
When a message is sent
• The message is packaged (encapsulated) with a header from the transport layer (e.g., TCP) and sent to the network layer
user data
TCP
Network Model
When a message is sent
• The data link layer adds a header, and the frame is sent out on the network
user data
TCPIPEthernet
An Ethernet frame
Network Model
When a message is sent
Application builds message in user memory
Message is copied to kernel and TCP/IP and Ethernet headers are added
Message is sent onto network to receiver
Message is copied to kernel and TCP/IP and Ethernet headers are stripped
Message arrives to user memory and the application is notified
You only see the communication at
THIS LEVEL
Message arrives to user memory and the application is notified
Message arrives to user memory and the application is notified
Network Model
Connectionless or connection-oriented
• If a protocol is connection-oriented then the client and server must connect before communication takes place – like a telephone call
• If a protocol is connectionless then there is no connection, just messaging – like sending a letter in the mail
Client/Server Model
•Starts first
•Waits for contact from a client
•Responds to requests
•Starts second
•Contacts a server with a request
•Waits for response from server
Server Client
Client/Server Model
Types of Servers
A server can be:
Types of Servers
Stateful
Stateless
Iterative
Concurrent
iterative stateful
concurrent stateful
iterative stateless
concurrent
stateless
Stateful Server
• Maintains some information between requests
• Requires smaller messages, since some information is kept between contacts
• May become confused if a connection terminates abnormally (if the design is not fault tolerant)
• Example: FTP
Types of Servers
Stateless Server
• Requires larger messages. That is, the message must contain all information about the request since no state information is kept.
• Example: HTTP
Types of Servers
Iterative Server
while (1) {
accept a connection (or request) from a client service the client
close the connection (if necessary)
}
Types of Servers
Concurrent Server
while (1) {
accept a connection/request from client
start a new thread to handle this client
/* the thread must close the connection! */
}
Types of Servers
Internet Addressing
• Suppose you type:
http://comp.uark.edu/~aapon
• This invokes the HTTP protocol (over TCP/IP), and the computer “comp.uark.edu” is sent a message
Addressing
Internet Addressing
http://comp.uark.edu/~aapon/
• Same as IP address 130.184.252.197
Find the home page of user aaponFind the home page of user aapon
Contact the HTTP server on the Contact the HTTP server on the computer named comp.uark.educomputer named comp.uark.edu
Addressing
Internet Addressing
• A Domain Name Server (DNS) may be called to find the IP address of comp.uark.edu
• Each IP machine is usually configured with the name of a DNS server.
• Some IP names and addresses can also be stored in /etc/hostfile
Addressing
Internet Addressing
“http” says: send the message to port 80• An IP address includes both a host
address and a port number!
• The HTTP server listens to port 80
• The HTTP server responds when a client contacts it
Addressing
Internet Addressing
You can write a server that listens to any port not already in use!
• A port number is a 16-bit integer. Ports below 1024 are reserved for system use.
• Well-known ports include FTP, Telnet, SMTP, etc.
Addressing
Socket programming
Socket API• introduced in BSD4.1 UNIX,
1981• explicitly created, used, released
by apps • client/server paradigm • two types of transport service via
socket API: – unreliable datagram – reliable, byte stream-oriented
a host-local, application-created,
OS-controlled interface (a “door”) into which
application process can both send and
receive messages to/from another
application process
socket
Goal: learn how to build client/server application that communicate using sockets
Socket-programming using TCP
Socket: a door between application process and end-end-transport protocol (UCP or TCP)
TCP service: reliable transfer of bytes from one process to another
process
TCP withbuffers,
variables
socket
controlled byapplicationdeveloper
controlled byoperating
system
host orserver
process
TCP withbuffers,
variables
socket
controlled byapplicationdeveloper
controlled byoperatingsystem
host orserver
internet
Socket programming with TCPClient 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-local 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– allows server to talk with
multiple clients– source port numbers used
to distinguish clients (more in Chap 3)
TCP provides reliable, in-order transfer of bytes (“pipe”) between client and server
application viewpoint
Client/server socket interaction: TCP
wait for incomingconnection requestconnectionSocket =welcomeSocket.accept()
create socket,port=x, forincoming request:welcomeSocket =
ServerSocket()
create socket,connect to hostid, port=xclientSocket =
Socket()
closeconnectionSocket
read reply fromclientSocket
closeclientSocket
Server (running on hostid) Client
send request usingclientSocketread request from
connectionSocket
write reply toconnectionSocket
TCP connection setup
outT
oSer
ver
to network from network
inFr
omS
erve
r
inFr
omU
ser
keyboard monitor
Process
clientSocket
inputstream
inputstream
outputstream
TCPsocket
Clientprocess
client TCP socket
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, e.g., keyboard or socket.
• An output stream is attached to an output source, e.g., monitor or socket.
Socket programming with TCP
Example client-server app: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)
Example: Java client (TCP)
import java.io.*; import java.net.*; class TCPClient {
public static void main(String argv[]) throws Exception { String sentence; String modifiedSentence;
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
Socket clientSocket = new Socket("hostname", 6789);
DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());
Createinput stream
Create client socket,
connect to server
Createoutput stream
attached to socket
Example: Java client (TCP), cont.
BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
sentence = inFromUser.readLine();
outToServer.writeBytes(sentence + '\n');
modifiedSentence = inFromServer.readLine();
System.out.println("FROM SERVER: " + modifiedSentence);
clientSocket.close(); } }
Createinput stream
attached to socket
Send lineto server
Read linefrom server
Example: Java server (TCP)import java.io.*; import java.net.*;
class TCPServer {
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()));
Createwelcoming socket
at port 6789
Wait, on welcomingsocket for contact
by client
Create inputstream, attached
to socket
Example: Java server (TCP), cont
DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
clientSentence = inFromClient.readLine();
capitalizedSentence = clientSentence.toUpperCase() + '\n';
outToClient.writeBytes(capitalizedSentence); } } }
Read in linefrom socket
Create outputstream,
attached to socket
Write out lineto socket
End of while loop,loop back and wait foranother client connection
Chapter 2: Application layer
• 2.1 Principles of network applications
• 2.2 Web and HTTP• 2.3 FTP • 2.4 Electronic Mail
– SMTP, POP3, IMAP
• 2.5 DNS
• 2.6 P2P file sharing• 2.7 Socket
programming with TCP
• 2.8 Socket programming with UDP
• 2.9 Building a Web server
Socket programming with UDP
UDP: no “connection” between client and server
• no handshaking
• sender explicitly attaches IP address and port of destination to each packet
• server must extract IP address, port of sender from received packet
UDP: transmitted data may be received out of order, or lost
application viewpoint
UDP provides unreliable transfer of groups of bytes (“datagrams”)
between client and server
Client/server socket interaction: UDP
closeclientSocket
Server (running on hostid)
read reply fromclientSocket
create socket,clientSocket = DatagramSocket()
Client
Create, address (hostid, port=x,send datagram request using clientSocket
create socket,port=x, forincoming request:serverSocket = DatagramSocket()
read request fromserverSocket
write reply toserverSocketspecifying clienthost address,port number
Example: Java client (UDP)
sendP
ack
et
to network from network
rece
iveP
ack
et
inF
rom
Use
r
keyboard monitor
Process
clientSocket
UDPpacket
inputstream
UDPpacket
UDPsocket
Output: sends packet (recallthat TCP sent “byte stream”)
Input: receives packet (recall thatTCP received “byte stream”)
Clientprocess
client UDP socket
Example: Java client (UDP)
import java.io.*; import java.net.*; 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();
Createinput stream
Create client socket
Translate hostname to IP
address using DNS
Example: Java client (UDP), cont.
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, 9876); clientSocket.send(sendPacket); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length); clientSocket.receive(receivePacket); String modifiedSentence = new String(receivePacket.getData()); System.out.println("FROM SERVER:" + modifiedSentence); clientSocket.close(); }
}
Create datagram with data-to-send,
length, IP addr, port
Send datagramto server
Read datagramfrom server
Example: Java server (UDP)
import java.io.*; import java.net.*; 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) { DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
Createdatagram socket
at port 9876
Create space forreceived datagram
Receivedatagra
m
Example: Java server (UDP), cont String sentence = new String(receivePacket.getData()); InetAddress IPAddress = receivePacket.getAddress(); int port = receivePacket.getPort(); String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes(); DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, IPAddress, port); serverSocket.send(sendPacket); } }
}
Get IP addrport #, of
sender
Write out datagramto socket
End of while loop,loop back and wait foranother datagram
Create datagramto send to client
Chapter 2: Application layer
• 2.1 Principles of network applications – app architectures– app requirements
• 2.2 Web and HTTP• 2.4 Electronic Mail
– SMTP, POP3, IMAP
• 2.5 DNS
• 2.6 P2P file sharing• 2.7 Socket
programming with TCP
• 2.8 Socket programming with UDP
• 2.9 Building a Web server
Building a simple Web server
• handles one HTTP request
• accepts the request• parses header• obtains requested file
from server’s file system• creates HTTP response
message:– header lines + file
• sends response to client
• after creating server, you can request file using a browser (e.g., IE explorer)
• see text for details
Chapter 2: Summary
• Application architectures– client-server– P2P– hybrid
• application service requirements:– reliability, bandwidth, delay
• Internet transport service model– connection-oriented, reliable: TCP– unreliable, datagrams: UDP
Our study of network apps now complete!
• specific protocols:– HTTP– FTP– SMTP, POP, IMAP– DNS
• socket programming
Chapter 2: Summary
• typical request/reply message exchange:– client requests info or service– server responds with data,
status code
• message formats:– headers: fields giving info
about data– data: info being
communicated
Most importantly: learned about protocols
• control vs. data msgs– in-band, out-of-band
• centralized vs. decentralized
• stateless vs. stateful• reliable vs. unreliable
msg transfer • “complexity at network
edge”