HTTP

Why it exists

The web is built on a simple request-response protocol: a client (the browser) asks a server for an object, and the server sends it. HTTP (HyperText Transfer Protocol) defines the messages. It is the standard example of an application layer protocol: it uses TCP through the socket API (socket API) after the server's name has been resolved by DNS (DNS).

Prerequisites

You need sockets and TCP connections (socket API) and the name lookup (DNS).

Precise definitions

A web page consists of a base HTML file and several referenced objects (images, style sheets, scripts). Each object is addressed by a URL (uniform resource locator) such as http://www.example.com/dir/index.html: protocol, host name (resolved by DNS), optional port (default $80$ for HTTP, $443$ for HTTPS) and path.

HTTP is a client-server, request-response, stateless protocol over TCP: the server keeps no information about earlier requests of a client. (State is added by cookies, below.)

Request message (text, lines end with carriage return and line feed):

GET /index.html HTTP/1.1
Host: www.example.com
Connection: keep-alive
 

The first line is the request line: a method, the path, the HTTP version. Then header lines (Host names the web site and is mandatory in HTTP/1.1; others describe the client and what it accepts), then an empty line, then an optional body (used by POST).

Methods (quoted): GET (fetch an object), POST (send data to the server, for example form contents), HEAD (like GET but the server returns only the headers), PUT (store an object), DELETE (remove it).

Response message: a status line (version, status code, reason phrase), header lines, an empty line and the body (the object).

(The status codes are quoted; 200, 304 and 404 were produced by the test server.)

How it works

A real exchange

The client sends the request line and two header lines and an empty line; the server replies with the status line HTTP/1.1 200 OK, headers (Content-Length tells the client where the body ends, Last-Modified supports caching), an empty line and $1000$ bytes of body.

Cookies and conditional GET

Because HTTP is stateless, a server that wants to recognise a returning user sends a cookie in a Set-Cookie header of the response; the browser stores it and sends it back in a Cookie header with later requests to that site. A web cache (browser cache or proxy server) keeps copies of objects; to check whether its copy is still current it sends a conditional GET with If-Modified-Since: date. If the object has not changed the server answers 304 Not Modified with an empty body (the test server did exactly this), saving the transfer of the object.

Connections

In non-persistent HTTP (HTTP/1.0) every request/response uses a new TCP connection, closed by the server after the response. In persistent HTTP (HTTP/1.1 default) the connection stays open for further requests. With pipelining the client may send the next request before the previous response has arrived.

A real server, real clients: ten requests on a persistent connection use one TCP connection, with Connection: close ten connections; curl uses one connection for three URLs of the same server unless told to close.

Response time

The time to fetch one object with a new connection is two round trips plus the transmission time: one RTT for the TCP handshake (the client sends the request together with the third segment), and one RTT for the request to reach the server and the first bits of the response to return, plus the time $T$ to transmit the object. With $n$ embedded objects, round-trip time RTT, transmission time $T_b$ of the base file and $T_o$ of each object (they share one bottleneck link):

For a page with the base file and $10$ objects, RTT $= 100$ ms, every transmission $10$ ms: $2310$ ms (non-persistent), $710$ ms (five parallel connections), $1310$ ms (persistent) and $410$ ms (pipelined). Parallel connections save round trips but not transmission time because the bottleneck is shared; pipelining sends the requests together and removes nearly all waiting.

With a single embedded object persistence saves one RTT; with $50$ objects the pipelined page needs $810$ ms against $10\,710$ ms.

(Real browsers combine parallel connections with persistent ones, and newer versions of HTTP multiplex many requests on one connection; they are not in the syllabus line and are mentioned only as the direction of development.)

Worked examples

Cheat box

Traps and GATE patterns

Connections

HTTP uses a TCP connection obtained through the socket API (socket API, TCP basics); the host name is resolved first (DNS). The response-time arithmetic is that of performance metrics.

PYQs

Which of the following statements is/are true with
respect to the interaction of a web browser with a
web server using HTTP 1.1?

A user starts browsing a webpage hosted at a
remote server. The browser opens a single
connection to fetch the entire webpage from the
server. The webpage consists of a top-level index
page with multiple embedded image objects.
Assume that all caches (e.g., DNS cache, browser
cache) are all initially empty. The following packets
leave the user's computer in some order.

(i) HTTP GET request for the index page.
(ii) DNS request to resolve the web server's name to
its IP address.
(iii) HTTP GET request for an image object.
(iv) TCP SYN to open a connection to the web
server.

Which one of the following is the CORRECT
chronological order (earliest in time to latest) of the
packets leaving the computer?

Suppose in a web browser, you click on the www .
gate-2023 . in URL. The browser cache is empty.
The IP address for this URL is not cached in your
local host, so a DNS lookup is triggered (by the local
DNS server deployed on your local host) over the 3-
tier DNS hierarchy in an iterative mode. No resource
records are cached anywhere across all DNS servers.
Let RTT denote the round trip time between your
local host and DNS servers in the DNS hierarchy.
The round trip time between the local host and the
web server hosting www.gate-2023.in is also equal
to RTT. The HTML file associated with the URL is
small enough to have negligible transmission time
and negligible rendering time by your web browser,
which references 10 equally small objects on the
same web server.
Which of the following statements is/are CORRECT
about the minimum elapsed time between clicking
on the URL and your browser fully rendering it?

Assume that you have made a request for a web
page through your web browser to a web server.
Initially, the browser cache is empty. Further, the
browser is configured to send HTTP requests in
non-persistent mode. The web page contains text
and five very small images. The minimum number
of TCP connections required to display the web
page completely in your browser is _________.

Which of the following is/are examples of stateful
application layer protocols?
(i) HTTP
(ii) FTP
(iii) TCP
(iv) POP3

Identify the correct sequence in which the
following packets are transmitted on the network
by a host when a browser requests a webpage from
a remote server, assuming that the host has just been
restarted.

In one of the pairs of protocols given below, both the
protocols can use multiple TCP connections between
the same client and the server. Which one is that?

Consider the different activities related to email.

ml : Send an email from mail client to mail
server

m 2 : Download an email from mailbox server
to a mail client

m3 ; Checking email in a web browser

Which is the application level protocol used in each
activity?

Self-check

Revision card

References