Always-on server (fixed IP)
       ^v
+------+------+
| Client 1    |
| Client 2    |  (intermittent connection, dynamic IP possible)
| Client 3    |
+-------------+

Peer1 <-----> Peer2
  ^v            ^v
Peer3 <-----> Peer4

Every peer is both a client and a server

+--------------+                    +--------------+
| Application  |                    | Application  |
|  Process     |                    |  Process     |
|      |       |                    |      |       |
|  Socket(door)|                    |  Socket(door)|
+------+-------+                    +------+-------+
| Transport    |                    | Transport    |
|      |       |  <-- Internet -->  |      |       |
|   ...        |                    |   ...        |
+--------------+                    +--------------+
  Client                             Server

Web page structure:
  +-- Base HTML file
  +-- JPEG image (referenced object)
  +-- JavaScript file
  +-- CSS stylesheet
  +-- Video file

Each object is identified by a single URL.

http://www.example.com/path/page.html
 --+--  ------+------  -----+-------
Protocol   Host name      Path name

HTTP communication process:
  1. Client initiates TCP connection to server port 80 (or 443)
  2. TCP connection established (3-way handshake)
  3. HTTP messages exchanged
  4. TCP connection closed

Requesting a page with base HTML + 10 images:

1. TCP setup -> base HTML request/response -> TCP close
2. TCP setup -> image 1 request/response -> TCP close
3. TCP setup -> image 2 request/response -> TCP close
...
11. TCP setup -> image 10 request/response -> TCP close

-> 11 TCP connections required!

RTT (Round-Trip Time): The time for a packet to travel from client
                        to server and back

Time for one object request:

  Client           Server
     |-- SYN -------->|
     |<- SYN+ACK ----|   <- 1 RTT (TCP connection setup)
     |-- GET -------->|
     |<- File transfer|   <- 1 RTT + file transfer time
     |                |

  Total time = 2 RTT + file transfer time

Persistent connection:

1. TCP connection setup                  <- 1 RTT
2. Base HTML request/response            <- 1 RTT
3. Image 1 request/response (same conn)  <- 1 RTT
4. Image 2 request/response (same conn)  <- 1 RTT
...

-> TCP connection is reused, reducing overhead

Without pipelining:          With pipelining:
  Request 1 -->              Request 1 -->
  <-- Response 1             Request 2 -->
  Request 2 -->              Request 3 -->
  <-- Response 2             <-- Response 1
  Request 3 -->              <-- Response 2
  <-- Response 3             <-- Response 3

  Total: 3 RTTs              Total: approx. 1 RTT

GET /somedir/page.html HTTP/1.1
Host: www.example.com
Connection: close
User-Agent: Mozilla/5.0
Accept-Language: ko-KR

+----------------------------------------+
| Request line                           |
|   Method SP URL SP Version CR LF       |
+----------------------------------------+
| Header lines                           |
|   Header-field: value CR LF            |
|   Header-field: value CR LF            |
|   ...                                  |
|   CR LF (blank line = end of headers)  |
+----------------------------------------+
| Entity body                            |
|   Used with POST method                |
+----------------------------------------+

HTTP/1.1 200 OK
Connection: close
Date: Thu, 19 Mar 2026 12:00:00 GMT
Server: Apache/2.4
Content-Length: 6821
Content-Type: text/html

(data...)

1. Set-Cookie header in HTTP response messages
2. Cookie header in HTTP request messages
3. Cookie file stored on the client (browser)
4. Back-end database on the website

First visit:
  Client                    Server
     |-- GET /index.html -->|
     |                       | Generate cookie ID 1678
     |<-- Set-Cookie: 1678 --|
     |                       | Store record for 1678 in DB
     |  Browser saves cookie |

Return visit:
     |-- GET /cart           |
     |   Cookie: 1678 --->   |
     |                       | Look up 1678 in DB
     |<-- Personalized resp -|

Client --> Proxy server --> Origin server
                |
           Cache storage

1. Client sends request to proxy server
2. Does the proxy have the object in cache?
   +-- YES -> Return cached object to client
   +-- NO  -> Request from origin server -> Cache response -> Return to client

Example: Institution network -> Internet access link (15 Mbps) -> Internet

Request rate: 15 requests/sec, average object size: 1 Mbit
Total request traffic: 15 Mbps

Access link utilization = 15/15 = 100% -> Queuing delay explodes!

Solution 1: Upgrade access link (100 Mbps) -> High cost
Solution 2: Install web cache (assuming 40% hit rate)
  -> Access link traffic = 15 * 0.6 = 9 Mbps
  -> Utilization = 9/15 = 60% -> Delay reduced!

Initial request:
  Proxy -- GET /fruit.gif -----------> Server
  Proxy <-- 200 OK                --  Server
              Last-Modified: Wed, 9 Mar 2026

Cache validation (Conditional GET):
  Proxy -- GET /fruit.gif -----------> Server
             If-Modified-Since:
             Wed, 9 Mar 2026

  Case 1: Not modified
  Proxy <-- 304 Not Modified --------- Server
              (No object body! Bandwidth saved)

  Case 2: Modified
  Proxy <-- 200 OK ------------------- Server
              (New object body included)

HTTP/1.0 (1996):
  - Non-persistent connections
  - GET, POST, HEAD

HTTP/1.1 (1997):
  - Persistent connections (default)
  - Pipelining
  - Host header required
  - PUT, DELETE added

HTTP/2 (2015):
  - Binary framing
  - Multiplexing (parallel requests/responses over a single connection)
  - Header compression
  - Server push

HTTP/3 (2022):
  - Based on QUIC protocol (UDP)
  - Solves HOL blocking
  - Faster connection setup

HTTP Key Summary:
  +-- TCP-based, stateless protocol
  +-- Request-response model
  +-- Non-persistent/persistent connections (persistent is default since HTTP/1.1)
  +-- State management via cookies
  +-- Web cache (proxy) reduces delay and saves bandwidth
  +-- Conditional GET validates cache freshness