📨 धडा 07 — wire वरचे HTTP: लखोट्यातली चिठ्ठी

📍 तुम्ही इथे आहात: 12 पैकी धडा 07 · पुढे: lesson-08-tls

📦 या ब्रँचमध्ये काय आहे

धडे 01–07. API शाळेची request ची चिठ्ठी, TCP stream वरचे bytes म्हणून, आणि HTTP/1.1, HTTP/2 आणि HTTP/3 ने लखोट्याबद्दल काय बदलले.

net/demo.py — http: port 80 वर हाताने टाइप केलेला GET; status line आणि headers परत वाचलेले

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

API शाळेने चिठ्ठी शिकवली: method, path, headers, body, आणि कारकुनाचा शिक्का. हा धडा लखोटा उघडतो: चिठ्ठी म्हणजे फक्त ओळी तोडलेला मजकूर, TCP stream मध्ये लिहिलेला, आणि शिक्का त्याच मार्गाने परत येतो. HTTP/1.1 पुढच्या चिठ्ठीसाठी लखोटा उघडा ठेवतो (keep-alive); HTTP/2 एकाच लखोट्यात एकाच वेळी अनेक चिठ्ठ्या पाठवू देतो; HTTP/3 नोंदणीकृत टपालाऐवजी एका हुशार लाउडस्पीकरवर (QUIC) जातो, म्हणजे एक पान हरवले तरी बाकीची अडकून राहत नाहीत.

🗺️ आकृती

sequenceDiagram
  participant C as client
  participant S as server :80
  C->>S: GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n
  S->>C: HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 571\r\n\r\n<html>…

❓ काय

Request: METHOD path HTTP/1.1, header च्या ओळी, एक रिकामी ओळ, हवी तर body. Response: HTTP/1.1 status reason, headers, रिकामी ओळ, body. ओळी \r\n ने संपतात. Host आवश्यक आहे (एका पत्त्यावर अनेक sites).
Keep-alive: HTTP/1.1 connection पुन्हा वापरतो; Connection: close ते संपवतो. body कुठे थांबते ते Content-Length किंवा chunked encoding सांगते (stream ला कडा नसतात — धडा 05).
HTTP/2: binary frames, एकाच TCP connection वर multiplex केलेले अनेक streams, header compression. HTTP/3: तेच QUIC (UDP) वर, head-of-line blocking नाही, TLS आतच असल्याने जलद handshake.

🤔 का

कच्चे HTTP वाचता येणे हाच proxies, CORS, redirects, caching headers आणि "curl ने चालते पण browser मध्ये नाही" debug करण्याचा मार्ग आहे. curl -v नेमक्या याच ओळी दाखवतो; आता तुम्ही त्या वाचू शकता.

🔧 कसे (या repo मध्ये)

http() चार ओळी हाताने लिहितो, server बंद करेपर्यंत वाचतो, पहिल्या रिकाम्या ओळीवर तोडतो, आणि status line सोबत तीन headers छापतो. बारा ओळींत हा एक पूर्ण HTTP client आहे — प्रत्येक framework म्हणजे हेच, अधिक काही अपवादात्मक प्रकरणे.

🧪 करून पाहा

python3 net/demo.py http
printf 'GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n' | nc example.com 80 | head -12   # by hand, no Python
curl -sv http://example.com -o /dev/null 2>&1 | grep -E '^(>|<)'       # the same lines, from the grown-up tool
curl -sI --http2 https://example.com | head -3                          # HTTP/2 when TLS is on

✅ तपासा — तुम्हाला काय दिसायला हवे

HTTP/1.1 200 OK, एक Content-Type: text/html header, body: 571 bytes (किंवा साधारण तितके). nc अगदी त्याच ओळी दाखवतो. curl --http2 HTTP/2 200 सांगतो.

🏁 तुम्ही आत्ताच काय सिद्ध केले

HTTP म्हणजे stream वरचा मजकूर, तुम्ही library शिवाय ते बोलू शकता, आणि versions मधला फरक लखोट्यात आहे, चिठ्ठीत नाही.

⚠️ नेहमीच्या चुका

Host header विसरणे: अनेक servers 400 किंवा चुकीची site देऊन उत्तर देतात.
रिकामी ओळ विसरणे: server तुमच्या headers च्या शेवटाची कायम वाट पाहत राहतो.
HTTP/2 साठी नवा code लागतो असे गृहीत धरणे: API शाळेचा counter जसाच्या तसा आहे; proxy ते बोलतो.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: proxy कडून आलेला 502, Content-Length नसल्याने अडकलेली request, Cache-Control कडे दुर्लक्ष करणारा CDN — ओळी माहीत झाल्या की हे सगळे curl -v मध्ये वाचता येते.

⏭️ पुढे

धडा 08 — TLS आणि certificates: सील केलेला लखोटा, आणि padlock काय वचन देतो आणि काय देत नाही.

📨 Lesson 07 — HTTP on the wire: the slip in the envelope

📍 You are here: Lesson 07 of 12 · Next: lesson-08-tls

📦 What's in this branch

Lessons 01–07. The API school's request slip as bytes on a TCP stream, and what HTTP/1.1, HTTP/2 and HTTP/3 changed about the envelope.

net/demo.py — http: a GET typed by hand onto port 80; the status line and headers read back

🧒 Explain like I'm 5

The API school taught the slip: method, path, headers, body, and the clerk's stamp. This lesson opens the envelope: the slip is just text with line breaks, written into a TCP stream, and the stamp comes back the same way. HTTP/1.1 keeps the envelope open for the next slip (keep-alive); HTTP/2 lets many slips travel in one envelope at once; HTTP/3 switches from registered post to a cleverer loudspeaker (QUIC) so one lost page does not hold up the others.

🗺️ Diagram

sequenceDiagram
  participant C as client
  participant S as server :80
  C->>S: GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n
  S->>C: HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 571\r\n\r\n<html>…

❓ What

Request: METHOD path HTTP/1.1, header lines, a blank line, an optional body. Response: HTTP/1.1 status reason, headers, blank line, body. Lines end in \r\n. Host is required (many sites per address).
Keep-alive: HTTP/1.1 reuses the connection; Connection: close ends it. Content-Length or chunked encoding says where the body stops (the stream has no edges — lesson 05).
HTTP/2: binary frames, many streams multiplexed on one TCP connection, header compression. HTTP/3: the same over QUIC (UDP), no head-of-line blocking, faster handshake with TLS built in.

🤔 Why

Reading raw HTTP is how you debug proxies, CORS, redirects, caching headers and "it works with curl but not in the browser". curl -v shows exactly these lines; now you can read them.

🔧 How (in this repo)

http() writes the four lines by hand, reads until the server closes, splits on the first blank line, and prints the status line plus three headers. That is a complete HTTP client in twelve lines — every framework is this plus edge cases.

🧪 Try it

python3 net/demo.py http
printf 'GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n' | nc example.com 80 | head -12   # by hand, no Python
curl -sv http://example.com -o /dev/null 2>&1 | grep -E '^(>|<)'       # the same lines, from the grown-up tool
curl -sI --http2 https://example.com | head -3                          # HTTP/2 when TLS is on

✅ Verify — what you should see

HTTP/1.1 200 OK, a Content-Type: text/html header, body: 571 bytes (or thereabouts). nc shows identical lines. curl --http2 reports HTTP/2 200.

🏁 What you just proved

HTTP is text on a stream, you can speak it without a library, and the versions differ in the envelope, not the slip.

⚠️ Common mistakes

Forgetting the Host header: many servers answer 400 or the wrong site.
Forgetting the blank line: the server waits forever for the end of your headers.
Assuming HTTP/2 needs new code: the API school's counter is untouched; the proxy speaks it.

🏭 Why this matters in production: a 502 from a proxy, a hung request with no Content-Length, a CDN ignoring Cache-Control — all readable in curl -v once you know the lines.

⏭️ Next

Lesson 08 — TLS & certificates: the sealed envelope, and what the padlock does and does not promise.

← Previousdns Next →tls

This page is the lesson's README from the lesson-07-http-on-the-wire branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.