3rd Edition: Chapter 2
Application Layer
2-*
Chapter 2
Application Layer
Computer Networking: A Top Down Approach
7th edition
Jim Kurose, Keith Ross
Pearson/Addison Wesley
April 2016
Application Layer
*
Application Layer
2-*
Chapter 2: outline
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 applications
2.7 Video streaming and content distribution networks
Application Layer
*
Application Layer
2-*
Chapter 2: application layer
our goals:
conceptual, implementation aspects of network application protocols
transport-layer service models
client-server paradigm
peer-to-peer paradigm
content distribution networks
learn about protocols by examining popular application-level protocols
HTTP
FTP
SMTP / POP3 / IMAP
DNS
creating network applications
socket API
Application Layer
*
Application Layer
2-*
Some network apps
e-mail
web
text messaging
remote login
P2P file sharing
multi-user network games
streaming stored video (YouTube, Hulu, Netflix)
voice over IP (e.g., Skype)
real-time video conferencing
social networking
search
…
…
Application Layer
*
Application Layer
2-*
Creating a network app
write programs that:
run on (different) end systems
communicate over network
e.g., web server software communicates with browser software
no need to write software for network-core devices
network-core devices do not run user applications
applications on end systemsallows for rapid app development, propagation
application
transport
network
data link
physical
application
transport
network
data link
physical
application
transport
network
data link
physical
Application Layer
*
Application Layer
2-*
Application architectures
possible structure of applications:
client-server
peer-to-peer (P2P)
hybrid of client-server and P2P
Application Layer
*
Application Layer
2-*
Client-server architecture
server:
always-on host
permanent IP address
data centers for scaling
clients:
communicate with server
may be intermittently connected
may have dynamic IP addresses
do not communicate directly with each other
client/server
Application Layer
*
Application Layer
2-*
P2P architecture
no always-on server
arbitrary end systems directly communicate
peers request service from other peers, provide service in return to other peers
self scalability – new peers bring new service capacity, as well as new service demands
peers are intermittently connected and change IP addresses
complex management
peer-peer
Application Layer
Advantages: self-scalability, cost-effectiveness
Challenges: security, performance, reliability, incentives, ISPs
*
Hybrid of client-server and P2P
Skype
voice-over-IP P2P application
centralized server: finding address of remote party
client-client connection: direct (not through server)
Instant messaging
chatting between two users is P2P
centralized service: client presence detection/location
user registers its IP address with central server when it comes online
user contacts central server to find IP addresses of buddies
Application2-*
Application Layer
2-*
Processes communicating
process: program running within a host
within same host, two processes communicate usinginter-process communication (defined by OS)
processes in different hosts communicate by exchanging messages
client process: process that initiates communication
server process: process that waits to be contacted
aside: applications with P2P architectures have client processes & server processes
clients, servers
Application Layer
*
Application Layer
2-*
Sockets
process sends/receives messages to/from its socket
socket analogous to door
sending process shoves message out door
sending process relies on transport infrastructure on other side of door to deliver message to socket at receiving process
Internet
controlled
by OS
controlled by
app developer
transport
application
physical
link
network
process
transport
application
physical
link
network
process
socket
API: (1) choice of transport protocol; (2) ability to fix a few parameters (more onthis later)
Application Layer
*
Application Layer
2-*
Addressing processes
to receive messages, processmust have identifier
host device has unique 32-bit IP address
Q: doesIP address of host on which process runs suffice for identifying the process?
identifier includes both IP address and port numbers associated with process on host.
example port numbers:
HTTP server: 80
mail server: 25
to send HTTP message to gaia.cs.umass.edu web server:
IP address: 128.119.245.12
port number: 80
more shortly…
A: no, many processes can be running on same host
Application Layer
Port number: 16-bit unsigned integer
*
Application Layer
2-*
App-layer protocol defines
types of messages exchanged,
e.g., request, response
message syntax:
what fields in messages & how fields are delineated
message semantics
meaning of information in fields
rules for when and how processes send & respond to messages
open protocols:
defined in RFCs
allows for interoperability
e.g., HTTP, SMTP
proprietary protocols:
e.g., Skype
Application Layer
Application vs app layer protocol
*
Application Layer
2-*
What transport service does an app need?
data loss
some apps (e.g., file transfer, web transactions) require 100% reliable data transfer
other apps (e.g., audio) can tolerate some loss
timing
some apps (e.g., Internet telephony, interactive games) require low delay to be “effective”
throughput
some apps (e.g., multimedia) require minimum amount of throughput to be “effective”
other apps (“elastic apps”) make use of whatever throughput they get
security
encryption, data integrity, …
Application Layer
*
Application Layer
2-*
Transport service requirements: common apps
application
file transfer
e-mail
Web documents
real-time audio/video
stored audio/video
interactive games
text messaging
data loss
no loss
no loss
no loss
loss-tolerant
loss-tolerant
loss-tolerant
no loss
throughput
elastic
elastic
elastic
audio: 5kbps-1Mbps
video:10kbps-5Mbps
same as above
few kbps up
elastic
time sensitive
no
no
no
yes, 100’s ms
yes, few secs
yes, 100’s ms
yes and no
Application Layer
*
Application Layer
2-*
Internet transport protocols services
TCP service:
connection-oriented: setup required between client and server processes
reliable transport between sending and receiving process
flow control: sender won’t overwhelm receiver
congestion control: throttle sender when network overloaded
does not provide: timing, minimum throughput guarantee, security
UDP service:
unreliable data transfer between sending and receiving process
does not provide: reliability, flow control, congestion control, timing, throughput guarantee, security, or connection setup,
Q: why bother?Why is there a UDP?
Application Layer
*
Application Layer
2-*
Internet apps:application, transport protocols
application
e-mail
remote terminal access
Web
file transfer
streaming multimedia
Internet telephony
application
layer protocol
SMTP [RFC 2821]
Telnet [RFC 854]
HTTP [RFC 2616]
FTP [RFC 959]
HTTP (e.g., YouTube),
RTP [RFC 1889]
SIP, RTP, proprietary
(e.g., Skype)
underlying
transport protocol
TCP
TCP
TCP
TCP
TCP or UDP
TCP or UDP
Application Layer
*
Securing TCP
TCP & UDP
no encryption
cleartext passwds sent into socket traverse Internetin cleartext
SSL
provides encrypted TCP connection
data integrity
end-point authentication
SSL is at app layer
apps use SSL libraries, that “talk” to TCP
SSL socket API
cleartext passwords sent into socket traverse Internetencrypted
see Chapter 8
Application Layer
2-*
Application Layer
Socket programming
Socket API
introduced in BSD4.1 UNIX, 1981
A socket is explicitly created, used, released by apps
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 an
application process can both send and
receive messages to/from another application process
Goal: learn how to build client/server application that communicate using sockets
Application2-*
socket
Socket
Socket Family
PF_INET denotes the Internet family
PF_UNIX denotes communication on the same host
PF_PACKET denotes direct access to the network interface (i.e., it bypasses the TCP/IP protocol stack)
Socket Type
SOCK_STREAM is used to denote a byte stream
SOCK_DGRAM is an alternative that denotes a message oriented service, such as that provided by UDP
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
PF_PACKET, SOCK_RAW equivalent to PF_INET, SOCK_PACKET but the 2nd one is obsolete
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); or ETH_P_IP, ETH_P_IPV6, ETH_P_ARP, …
PF vs AF: Stevens and Bj always use AF
PF_UNIX: communication on the same machine. TYPE = SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET (message oriented that preserves the order)
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
controlled by
application
developer
controlled by
operating
system
client or
server
controlled by
application
developer
controlled by
operating
system
client or
server
internet
Application2-*
TCP with
buffers,
variables
socket
process
TCP with
buffers,
variables
socket
process
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-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
Application2-*
application viewpoint
Client
process
client TCP socket
Stream jargon
stream is a sequence of bytes that flow into or out of a process.
input stream is attached to some input source for the process, e.g., keyboard or socket.
output stream is attached to an output source, e.g., monitor or socket.
Application2-*
TCP Client/Server Socket Interaction
Application2-*
Creating a Socket
int sockfd = socket(socket_family, type, protocol);
The socket number returned is the socket descriptor for the newly created socket
int sockfd = socket (PF_INET, SOCK_STREAM, 0);
int sockfd = socket (PF_INET, SOCK_DGRAM, 0);
The combination of PF_INET and SOCK_STREAM implies TCP
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
PF vs. AF: Stevens, beej always use AF
Client-Server Model with TCP
Server
Passive open
Prepares to accept connection, does not actually establish a connection
Server invokes
int bind (int socket, struct sockaddr *address, int addr_len)
int listen (int socket, int backlog)
int accept (int socket, struct sockaddr *address, int *addr_len)
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Client-Server Model with TCP
Bind
Binds the newly created socket to the specified address i.e. the network address of the local participant (the server)
Address is a data structure which combines IP and port
Listen
Defines how many connections can be pending on the specified socket
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Client-Server Model with TCP
Accept
Carries out the passive open
Blocking operation
Does not return until a remote participant has established a connection
When it does, it returns a new socket that corresponds to the new established connection and the address argument contains the remote participant’s address
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Client-Server Model with TCP
Client
Application performs active open
It says who it wants to communicate with
Client invokes
int connect (int socket, struct sockaddr *address, int addr_len)
Connect
Does not return until TCP has successfully established a connection at which application is free to begin sending data
Address contains remote machine’s address
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Client-Server Model with TCP
In practice
The client usually specifies only remote participant’s address and let’s the system fill in the local information
Whereas a server usually listens for messages on a well-known port
A client does not care which port it uses for itself, the OS simply selects an unused one
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Client-Server Model with TCP
Once a connection is established, the application process invokes two operations
int send (int socket, char *msg, int msg_len,
int flags)
int recv (int socket, char *buff, int buff_len,
int flags)
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Return #bytes written/read
Example Application: Client
#include
#include
#include
#include
#include
#define SERVER_PORT 5432
#define MAX_LINE 256
int main(int argc, char * argv[])
{
FILE *fp;
struct hostent *hp;
struct sockaddr_in sin;
char *host;
char buf[MAX_LINE];
int s;
int len;
if (argc==2) {
host = argv[1];
}
else {
fprintf(stderr, “usage: simplex-talk host
”);
exit(1);
}
Application2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Example Application: Client
/* translate host name into peer’s IP address */
hp = gethostbyname(host);
if (!hp) {
fprintf(stderr, “simplex-talk: unknown host: %s
”, host);
exit(1);
}
/* build address data structure */
bzero((char *)&sin, sizeof(sin));
sin.sin_family = AF_INET;
bcopy(hp->h_addr, (char *)&sin.sin_addr, hp->h_length);
sin.sin_port = htons(SERVER_PORT);
/* active open */
if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {perror(“simplex-talk: socket”);exit(1);}if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) {perror(“simplex-talk: connect”);close(s);exit(1);}/* main loop: get and send lines of text */while (fgets(buf, sizeof(buf), stdin)) {len = strlen(buf) + 1;send(s, buf, len, 0);}}Translate name into remote host’s IPConstruct remote address data structureCreate socketConnectRead from standard input, send to server over socketApplication2-*The University of Adelaide, School of Computer Science*Chapter 2 — Instructions: Language of the Computer*buf[MAX_LINE-1] = ’ ’;Example Application: Server#include
#include
#include
#include
#include
#define SERVER_PORT 5432
#define MAX_PENDING 5
#define MAX_LINE 256
int main()
{
struct sockaddr_in sin;
char buf[MAX_LINE];
int len;
int s, new_s;
/* build address data structure */
bzero((char *)&sin, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(SERVER_PORT);
/* setup passive open */
if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {perror(“simplex-talk: socket”);exit(1);}Construct local address data structureCreate socketApplication2-*The University of Adelaide, School of Computer Science*Chapter 2 — Instructions: Language of the Computer*Example Application: Serverif ((bind(s, (struct sockaddr *)&sin, sizeof(sin))) < 0) {perror(“simplex-talk: bind”);exit(1);}listen(s, MAX_PENDING);/* wait for connection, then receive and print text */while(1) {if ((new_s = accept(s, (struct sockaddr *)&sin, &len)) < 0) {perror(“simplex-talk: accept”);exit(1);}while (len = recv(new_s, buf, sizeof(buf), 0))fputs(buf, stdout);close(new_s);}}Bind to local addressSet max number of pending connectionsAccept a connection, return new socketReceive from remote client over socket, print to standard outputApplication2-*The University of Adelaide, School of Computer Science*Chapter 2 — Instructions: Language of the Computer*Application Layer2-*Socket programming with UDPUDP: no “connection” between client & serverno handshaking before sending datasender explicitly attaches IP destination address and port # to each packetrcvr extracts sender IP address and port# from received packetUDP: transmitted data may be lost or received out-of-orderApplication viewpoint:UDP provides unreliable transfer of groups of bytes (“datagrams”)between client and serverApplication LayerUDP OverviewClient gets ready (socket)Server gets ready (socket, bind)Data transferClient sendto – server recvfrom!Server sendto – client recvfrom! int sendto (int socket, char *msg, int msg_len,int flags, const struct sockaddr *dest_addr, socklen_t dest_len)int recvfrom (int socket, char *buff, int buff_len,int flags, const struct sockaddr *src_addr, socklen_t src_len)Client closes its socket (close)Server keeps waiting for other dataApplication2-*UDPP Client/Server Socket InteractionApplication2-*Application Layer2-*Chapter 2: outline2.1 principles of network applications2.2 Web and HTTP2.3 FTP 2.4 electronic mailSMTP, POP3, IMAP2.5 DNS2.6 P2P applications2.7 Video streaming and content distribution networksApplication Layer*Application Layer2-*Web and HTTPFirst, a review…web page consists of objectsobject can be HTML file, JPEG image, Java applet, audio file,…web page consists of base HTML-file which includes several referenced objectseach object is addressable by a URL, e.g.,www.someschool.edu/someDept/pic.gifhost namepath nameApplication Layer*Application Layer2-*HTTP overviewHTTP: hypertext transfer protocolWeb’s application layer protocolclient/server modelclient: browser that requests, receives, (using HTTP protocol) and “displays” Web objects server: Web server sends (using HTTP protocol) objects in response to requestsPC runningFirefox browserserver runningApache Webserveriphone runningSafari browserHTTP requestHTTP responseHTTP requestHTTP responseApplication Layer*Application Layer2-*HTTP overview (continued)uses TCP:client initiates TCP connection (creates socket) to server,port 80server accepts TCP connection from clientHTTP messages (application-layer protocol messages) exchanged between browser (HTTP client) and Web server (HTTP server)TCP connection closedHTTP is “stateless”server maintains no information about past client requestsprotocols that maintain “state” are complex!past history (state) must be maintainedif server/client crashes, their views of “state” may be inconsistent, must be reconciledasideApplication LayerSimple Service Discovery Protocol uses HTTP over UDP (HTTPU)*Application Layer2-*HTTP connectionsnon-persistent HTTPat most one object sent over TCP connectionconnection then closeddownloading multiple objects required multiple connectionspersistent HTTPmultiple objects can be sent over single TCP connection between client, serverApplication Layer*Application Layer2-*Non-persistent HTTPsuppose user enters URL:1a. HTTP client initiates TCP connection to HTTP server (process) at www.someSchool.edu on port 802. HTTP client sends HTTP request message (containing URL) into TCP connection socket. Message indicates that client wants object someDepartment/home.index1b. HTTP server at host www.someSchool.edu waiting for TCP connection at port 80.“accepts” connection, notifying client3. HTTP server receives request message, forms response message containing requested object, and sends message into its sockettime(contains text, references to 10 jpeg images)www.someSchool.edu/someDepartment/home.indexApplication Layer*Application Layer2-*Non-persistent HTTP (cont.)5. HTTP client receives response message containing html file, displays html.Parsing html file, finds 10 referenced jpegobjects6. Steps 1-5 repeated for each of 10 jpeg objects4. HTTP server closes TCP connection. timeApplication Layer*Application Layer2-*Non-persistent HTTP: response timeRTT (definition): time for a small packet to travel from client to server and backHTTP response time:one RTT to initiate TCP connectionone RTT for HTTP request and first few bytes of HTTP response to returnfile transmission timenon-persistent HTTP response time =2RTT+ file transmissiontimetime to transmit fileinitiate TCPconnectionRTTrequestfileRTTfilereceivedtimetimeApplication Layer2RTT + dtran + 10(2RTT + dtran)2RTT + dtran + 2RTT + 10dtran2RTT + dtran + 10RTT + 10 dtran2RTT + dtran + RTT+ 10dtran*Application Layer2-*Persistent HTTPnon-persistent HTTP issues:requires 2 RTTs per objectOS overhead for each TCP connectionallocate TCP buffersinitialize TCP variablesbrowsers often open parallel TCP connections to fetch referenced objectspersistentHTTP:server leaves connection open after sending responsesubsequent HTTP messagesbetween same client/server sent over open connectionclient sends requests as soon as it encounters a referenced objectas little as one RTT for all the referenced objectsApplication Layer*Benefits of Persistent HTTPReduced response timeCPU time saved in routers and hostsNetwork congestion is reducedHTTP requests and responses can be pipelined on a connectionAs little as one RTT for all the referenced objectsApplication2-*Issues with Persistent Connections?How long to keep a TCP connection open?TCP connections require memoryMany TCP connections can overload serverServer timeouts and closes connectionsIf disk is the bottleneck, persistent HTTP may perform worse than non-persistent HTTP (see paper).Application2-*Issues with Pipelining?Some browsers do not implement pipeliningIE, Safari: NOOpera, Chrome: YesFirefox: YES but OFF by defaultReasons?Old servers may not implement itHead-of-line blockingApplication2-*Wiki, based on a 2009 reference*SPDY – An Enhancement to HTTP/1.1Proposed by GoogleDeployed and used by Google, Facebook, Twitter, etc.4 key design featuresMultiplexed streamsRequest prioritizationServer pushHeader compressionApplication2-*Placement in network stack**SPDY: An experimental protocol for a faster web, http://www.chromium.org/spdy/spdy-whitepaperWiki, based on a 2009 reference,11-50% speedup, average ~40%*How speedy is SPDY?*Application2-**How speedy is SPDY?, Wang et al., NSDI 2014Icwnd = initial congestion window size (typically 3, google servers use 32)*Application Layer2-*HTTP request messagetwo types of HTTP messages: request, responseHTTP request message:ASCII (human-readable format)request line(GET, POST, HEAD commands)header linescarriage return, line feed at startof line indicatesend of header linesGET /index.html HTTP/1.1r
Host: www-net.cs.umass.edur
User-Agent: Firefox/3.6.10r
Accept: text/html,application/xhtml+xmlr
Accept-Language: en-us,en;q=0.5r
Accept-Encoding: gzip,deflater
Accept-Charset: ISO-8859-1,utf-8;q=0.7r
Keep-Alive: 115r
Connection: keep-aliver
r
carriage return characterline-feed characterApplication Layer*Application Layer2-*HTTP request message: general formatrequestlineheaderlinesbodymethodspspcrlfversionURLentity bodycrlfvalueheader field namecrlfvalueheader field name~~~~crlf~~~~Application Layer*Application Layer2-*Uploading form inputPOST method:web page often includes form inputinput is uploaded to server in entity bodyURL method:uses GET methodinput is uploaded in URL field of request line:www.somesite.com/animalsearch?monkeys&bananaApplication Layer*Application Layer2-*Method typesHTTP/1.0:GETPOSTHEADasks server to leave requested object out of responseHTTP/1.1:GET, POST, HEADPUTuploads file in entity body to path specified in URL fieldDELETEdeletes file specified in the URL fieldApplication Layer*Application Layer2-*HTTP response messagestatus line(protocolstatus codestatus phrase)header linesdata, e.g., requestedHTML fileHTTP/1.1 200 OKr
Date: Sun, 26 Sep 2010 20:09:20 GMTr
Server: Apache/2.0.52 (CentOS)r
Last-Modified: Tue, 30 Oct 2007 17:00:02 GMTr
ETag: “17dc6-a5c-bf716880″r
Accept-Ranges: bytesr
Content-Length: 2652r
Keep-Alive: timeout=10, max=100r
Connection: Keep-Aliver
Content-Type: text/html; charset=ISO-8859-1r
r
data data data data data … Application Layer*Application Layer2-*HTTP response status codes200 OKrequest succeeded, requested object later in this msg301 Moved Permanentlyrequested object moved, new location specified later in this msg (Location:)400 Bad Requestrequest msg not understood by server404 Not Foundrequested document not found on this server505 HTTP Version Not Supportedstatus code appears in 1st line in server-to-client response message.some sample codes:Application Layer*Application Layer2-*Trying out HTTP (client side) for yourself1. Telnet to your favorite Web server:opens TCP connection to port 80(default HTTP server port) at cis.poly.edu.anything typed in sent to port 80 at cis.poly.edutelnet cis.poly.edu 802. type in a GET HTTP request:GET /~ross/ HTTP/1.1Host: cis.poly.eduby typing this in (hit carriagereturn twice), you sendthis minimal (but complete) GET request to HTTP server3. look at response message sent by HTTP server!(or use Wireshark to look at captured HTTP request/response)Application Layer*Application Layer2-*User-server state: cookiesmany Web sites use cookiesfour components:1) cookie header line of HTTP response message2) cookie header line in next HTTP request message3) cookie file kept on user’s host, managed by user’s browser4) back-end database at Web siteexample:Susan always access Internet from PCvisits specific e-commerce site for first timewhen initial HTTP request arrives at site, site creates: unique IDentry in backend database for IDApplication Layer*Application Layer2-*Cookies: keeping “state” (cont.)clientservercookie fileone week later:backenddatabaseusual http response msgusual http response msgaccessusual http request msgcookie: 1678cookie-specificactionebay 8734createentryusual http request msgAmazon servercreates ID1678 for userebay 8734amazon 1678usual http response set-cookie: 1678 usual http request msgcookie: 1678cookie-specificactionaccessebay 8734amazon 1678Application Layer*Application Layer2-*Cookies (continued)what cookies can be used for:authorizationshopping cartsrecommendationsuser session state (Web e-mail)cookies and privacy:cookies permit sites to learn a lot about youyou may supply name and e-mail to sitesasidehow to keep “state”:protocol endpoints: maintain state at sender/receiver over multiple transactionscookies: http messages carry stateApplication LayerCookies: IE, Windows 7: C:Users
Firefox: Options -> Privacy
Chrome: Settings -> Advanced Settings -> Privacy
*
Application Layer
2-*
Web caches (proxy server)
user sets browser: Web accesses via cache
browser sends all HTTP requests to cache
object in cache: cache returns object
else cache requests object from origin server, then returns object to client
goal: satisfy client request without involving origin server
client
proxy
server
client
origin
server
origin
server
HTTP request
HTTP response
HTTP request
HTTP request
HTTP response
HTTP response
Application Layer
*
Application Layer
2-*
More about Web caching
cache acts as both client and server
server for original requesting client
client to origin server
typically cache is installed by ISP (university, company, residential ISP)
why Web caching?
reduce response time for client request
reduce traffic on an institution’s access link
Internet dense with caches: enables “poor” content providers to effectively deliver content
Application Layer
*
Application Layer
2-*
Caching example:
origin
servers
public
Internet
institutional
network
1 Gbps LAN
1.54 Mbps
access link
assumptions:
avg object size: 100K bits
avg request rate from browsers to origin servers:15/sec
avg data rate to browsers: 1.50 Mbps
RTT from institutional link to any origin server: 2 sec
access link rate: 1.54 Mbps
consequences:
LAN utilization: 0.15%
access link utilization = 97%
total delay = Internet delay + access delay + LAN delay
=2 sec + minutes + usecs
problem!
Utilization = Traffic intensity
Application Layer
*
Application Layer
2-*
assumptions:
avg object size: 100K bits
avg request rate from browsers to origin servers:15/sec
avg data rate to browsers: 1.50 Mbps
RTT from institutional link to any origin server: 2 sec
access link rate: 1.54 Mbps
consequences:
LAN utilization:0.15%
access link
Reviews
There are no reviews yet.