程序代写代做代考 Java FTP case study database cache dns data structure 3rd Edition: Chapter 2
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 systems allows 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
Application 2-*
Application Layer
2-*
Processes communicating
process: program running within a host
within same host, two processes communicate using inter-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 on this later)
Application Layer
*
Application Layer
2-*
Addressing processes
to receive messages, process must have identifier
host device has unique 32-bit IP address
Q: does IP 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 Internet in 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 Internet encrypted
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
Application 2-*
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
Application 2-*
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
Application 2-*
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.
Application 2-*
TCP Client/Server Socket Interaction
Application 2-*
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
Application 2-*
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)
Application 2-*
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
Application 2-*
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
Application 2-*
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
Application 2-*
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
Application 2-*
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)
Application 2-*
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);
}
Application 2-*
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 IP
Construct remote address data structure
Create socket
Connect
Read from standard input, send to server over socket
Application 2-*
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 structure
Create socket
Application 2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Example Application: Server
if ((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 address
Set max number of pending connections
Accept a connection, return new socket
Receive from remote client over socket, print to standard output
Application 2-*
The University of Adelaide, School of Computer Science
*
Chapter 2 — Instructions: Language of the Computer
*
Application Layer
2-*
Socket programming with UDP
UDP: no “connection” between client & server
no handshaking before sending data
sender explicitly attaches IP destination address and port # to each packet
rcvr extracts sender IP address and port# from received packet
UDP: transmitted data may be lost or received out-of-order
Application viewpoint:
UDP provides unreliable transfer of groups of bytes (“datagrams”) between client and server
Application Layer
UDP Overview
Client gets ready (socket)
Server gets ready (socket, bind)
Data transfer
Client 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 data
Application 2-*
UDPP Client/Server Socket Interaction
Application 2-*
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-*
Web and HTTP
First, a review…
web page consists of objects
object can be HTML file, JPEG image, Java applet, audio file,…
web page consists of base HTML-file which includes several referenced objects
each object is addressable by a URL, e.g.,
www.someschool.edu/someDept/pic.gif
host name
path name
Application Layer
*
Application Layer
2-*
HTTP overview
HTTP: hypertext transfer protocol
Web’s application layer protocol
client/server model
client: browser that requests, receives, (using HTTP protocol) and “displays” Web objects
server: Web server sends (using HTTP protocol) objects in response to requests
PC running
Firefox browser
server
running
Apache Web
server
iphone running
Safari browser
HTTP request
HTTP response
HTTP request
HTTP response
Application Layer
*
Application Layer
2-*
HTTP overview (continued)
uses TCP:
client initiates TCP connection (creates socket) to server, port 80
server accepts TCP connection from client
HTTP messages (application-layer protocol messages) exchanged between browser (HTTP client) and Web server (HTTP server)
TCP connection closed
HTTP is “stateless”
server maintains no information about past client requests
protocols that maintain “state” are complex!
past history (state) must be maintained
if server/client crashes, their views of “state” may be inconsistent, must be reconciled
aside
Application Layer
Simple Service Discovery Protocol uses HTTP over UDP (HTTPU)
*
Application Layer
2-*
HTTP connections
non-persistent HTTP
at most one object sent over TCP connection
connection then closed
downloading multiple objects required multiple connections
persistent HTTP
multiple objects can be sent over single TCP connection between client, server
Application Layer
*
Application Layer
2-*
Non-persistent HTTP
suppose user enters URL:
1a. HTTP client initiates TCP connection to HTTP server (process) at www.someSchool.edu on port 80
2. HTTP client sends HTTP request message (containing URL) into TCP connection socket. Message indicates that client wants object someDepartment/home.index
1b. HTTP server at host www.someSchool.edu waiting for TCP connection at port 80. “accepts” connection, notifying client
3. HTTP server receives request message, forms response message containing requested object, and sends message into its socket
time
(contains text,
references to 10
jpeg images)
www.someSchool.edu/someDepartment/home.index
Application Layer
*
Application Layer
2-*
Non-persistent HTTP (cont.)
5. HTTP client receives response message containing html file, displays html. Parsing html file, finds 10 referenced jpeg objects
6. Steps 1-5 repeated for each of 10 jpeg objects
4. HTTP server closes TCP connection.
time
Application Layer
*
Application Layer
2-*
Non-persistent HTTP: response time
RTT (definition): time for a small packet to travel from client to server and back
HTTP response time:
one RTT to initiate TCP connection
one RTT for HTTP request and first few bytes of HTTP response to return
file transmission time
non-persistent HTTP response time =
2RTT+ file transmission time
time to
transmit
file
initiate TCP
connection
RTT
request
file
RTT
file
received
time
time
Application Layer
2RTT + dtran + 10(2RTT + dtran)
2RTT + dtran + 2RTT + 10dtran
2RTT + dtran + 10RTT + 10 dtran
2RTT + dtran + RTT+ 10dtran
*
Application Layer
2-*
Persistent HTTP
non-persistent HTTP issues:
requires 2 RTTs per object
OS overhead for each TCP connection
allocate TCP buffers
initialize TCP variables
browsers often open parallel TCP connections to fetch referenced objects
persistent HTTP:
server leaves connection open after sending response
subsequent HTTP messages between same client/server sent over open connection
client sends requests as soon as it encounters a referenced object
as little as one RTT for all the referenced objects
Application Layer
*
Benefits of Persistent HTTP
Reduced response time
CPU time saved in routers and hosts
Network congestion is reduced
HTTP requests and responses can be pipelined on a connection
As little as one RTT for all the referenced objects
Application 2-*
Issues with Persistent Connections?
How long to keep a TCP connection open?
TCP connections require memory
Many TCP connections can overload server
Server timeouts and closes connections
If disk is the bottleneck, persistent HTTP may perform worse than non-persistent HTTP (see paper).
Application 2-*
Issues with Pipelining?
Some browsers do not implement pipelining
IE, Safari: NO
Opera, Chrome: Yes
Firefox: YES but OFF by default
Reasons?
Old servers may not implement it
Head-of-line blocking
Application 2-*
Wiki, based on a 2009 reference
*
SPDY – An Enhancement to HTTP/1.1
Proposed by Google
Deployed and used by Google, Facebook, Twitter, etc.
4 key design features
Multiplexed streams
Request prioritization
Server push
Header compression
Application 2-*
Placement in network stack*
*SPDY: An experimental protocol for a faster web, http://www.chromium.org/spdy/spdy-whitepaper
Wiki, based on a 2009 reference,
11-50% speedup, average ~40%
*
How speedy is SPDY?*
Application 2-*
*How speedy is SPDY?, Wang et al., NSDI 2014
Icwnd = initial congestion window size (typically 3, google servers use 32)
*
Application Layer
2-*
HTTP request message
two types of HTTP messages: request, response
HTTP request message:
ASCII (human-readable format)
request line
(GET, POST,
HEAD commands)
header
lines
carriage return,
line feed at start
of line indicates
end of header lines
GET /index.html HTTP/1.1
Host: www-net.cs.umass.edu
User-Agent: Firefox/3.6.10
Accept: text/html,application/xhtml+xml
Accept-Language: en-us,en;q=0.5
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7
Keep-Alive: 115
Connection: keep-alive
carriage return character
line-feed character
Application Layer
*
Application Layer
2-*
HTTP request message: general format
request
line
header
lines
body
method
sp
sp
cr
lf
version
URL
entity body
cr
lf
value
header field name
cr
lf
value
header field name
~
~
~
~
cr
lf
~
~
~
~
Application Layer
*
Application Layer
2-*
Uploading form input
POST method:
web page often includes form input
input is uploaded to server in entity body
URL method:
uses GET method
input is uploaded in URL field of request line:
www.somesite.com/animalsearch?monkeys&banana
Application Layer
*
Application Layer
2-*
Method types
HTTP/1.0:
GET
POST
HEAD
asks server to leave requested object out of response
HTTP/1.1:
GET, POST, HEAD
PUT
uploads file in entity body to path specified in URL field
DELETE
deletes file specified in the URL field
Application Layer
*
Application Layer
2-*
HTTP response message
status line
(protocol
status code
status phrase)
header
lines
data, e.g.,
requested
HTML file
HTTP/1.1 200 OK
Date: Sun, 26 Sep 2010 20:09:20 GMT
Server: Apache/2.0.52 (CentOS)
Last-Modified: Tue, 30 Oct 2007 17:00:02 GMT
ETag: "17dc6-a5c-bf716880"
Accept-Ranges: bytes
Content-Length: 2652
Keep-Alive: timeout=10, max=100
Connection: Keep-Alive
Content-Type: text/html; charset=ISO-8859-1
data data data data data ...
Application Layer
*
Application Layer
2-*
HTTP response status codes
200 OK
request succeeded, requested object later in this msg
301 Moved Permanently
requested object moved, new location specified later in this msg (Location:)
400 Bad Request
request msg not understood by server
404 Not Found
requested document not found on this server
505 HTTP Version Not Supported
status code appears in 1st line in server-to-client response message.
some sample codes:
Application Layer
*
Application Layer
2-*
Trying out HTTP (client side) for yourself
1. 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.edu
telnet cis.poly.edu 80
2. type in a GET HTTP request:
GET /~ross/ HTTP/1.1
Host: cis.poly.edu
by typing this in (hit carriage
return twice), you send
this minimal (but complete)
GET request to HTTP server
3. look at response message sent by HTTP server!
(or use Wireshark to look at captured HTTP request/response)
Application Layer
*
Application Layer
2-*
User-server state: cookies
many Web sites use cookies
four components:
1) cookie header line of HTTP response message
2) cookie header line in next HTTP request message
3) cookie file kept on user’s host, managed by user’s browser
4) back-end database at Web site
example:
Susan always access Internet from PC
visits specific e-commerce site for first time
when initial HTTP request arrives at site, site creates:
unique ID
entry in backend database for ID
Application Layer
*
Application Layer
2-*
Cookies: keeping “state” (cont.)
client
server
cookie file
one week later:
backend
database
usual http response msg
usual http response msg
access
usual http request msg
cookie: 1678
cookie-
specific
action
ebay 8734
create
entry
usual http request msg
Amazon server
creates ID
1678 for user
ebay 8734
amazon 1678
usual http response
set-cookie: 1678
usual http request msg
cookie: 1678
cookie-
specific
action
access
ebay 8734
amazon 1678
Application Layer
*
Application Layer
2-*
Cookies (continued)
what cookies can be used for:
authorization
shopping carts
recommendations
user session state (Web e-mail)
cookies and privacy:
cookies permit sites to learn a lot about you
you may supply name and e-mail to sites
aside
how to keep “state”:
protocol endpoints: maintain state at sender/receiver over multiple transactions
cookies: http messages carry state
Application Layer
Cookies:
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
