DNS: hierarchy, recursive vs iterative resolution, caching, records

1. Which transport suits one small question and one small answer?
2. Range of well-known ports?
   Stuck? Peek at 4.1 Transport basics: process-to-process delivery, ports, sockets & multiplexing

   • Delivery: Network Layer = host-to-host; Transport Layer = process-to-process.
   • Port number = 16 bits (0–65,535): Well-known 0–1023, Registered 1024–49151, Ephemeral 49152–65535.
   • Demultiplexing: UDP uses 2-tuple (DstIP, DstPort); TCP uses 4-tuple (SrcIP, SrcPort, DstIP, DstPort).
   • UDP (Foundation) = 8-byte header, connectionless, best-effort; TCP = connection-oriented, reliable, flow + congestion controlled.

   Read lesson 4.1

3. How many bits in an IPv4 address?
   Stuck? Peek at 3.1.1 IPv4 address structure, dotted decimal, net-id vs host-id

   • IPv4 address = 32 bits = 4 octets (0–255 each), total space = 2³².
   • Split: Net-ID (left n bits) + Host-ID (right h = 32 − n bits).
   • Identifies a network interface (routers have one IP per link).

   Read lesson 3.1.1

You type www.example.com, but packets need a 32-bit IP address. A single phone book for the whole world would be too big, too busy and a single point of failure. The Domain Name System is a world-wide, distributed, cached phone book — consulted before almost every connection your laptop makes.

Your laptop asks for the address of mail.cs.iitm.ac.in. Which server would know the final answer: a server for the whole Internet, one for .in, or one run by IIT Madras?

The IIT Madras (authoritative) server. The root servers only know who handles .in; the .in servers know who handles ac.in and below; the organisation's own server holds the final record. The lookup walks down this tree.

Names form a hierarchy

Kinds of DNS servers

Recursive vs iterative resolution

• Iterative: the queried server answers with "I don't know, ask this other server" (a referral). The asker contacts each server in turn.
• Recursive: the queried server takes over the job, asks onward itself, and returns the final answer.

Typically the host → local resolver query is recursive, and the local resolver → root/TLD/authoritative queries are iterative. Both styles exchange the same number of messages in a full uncached lookup (8: 4 queries + 4 replies); they differ in who does the work.

Caching and TTL

Every server caches answers it has seen for a time given by the record's TTL (time to live, in seconds). Cached TLD and authoritative-server addresses let most lookups skip the root entirely; a cached final answer makes the lookup cost only the host-to-resolver round trip.

Resource records and transport

DNS stores resource records (name, value, type, TTL):

Putting it together

• DNS is a distributed, cached hierarchy of name servers.
• Local resolvers walk root → TLD → authoritative (iteratively) on the host's behalf.
• Records A, NS, CNAME, MX; UDP port 53; caching by TTL keeps it fast.

• DNS uses UDP port 53 for normal queries; TCP port 53 for zone transfers and long answers.
• The root does not know the final address — it only refers you to TLD servers.
• CNAME maps an alias to the canonical name, not to an address; MX names a mail server.
• Recursive vs iterative is about who chases the referrals, not about the number of messages in a full lookup.

"Root points to the shelf, TLD to the book, the authoritative server reads you the line."

With the address in hand, the browser can open a TCP connection to port 80. Next (5.3): what exactly does it send to ask for a page, what comes back, and how many round trips does a page with many images cost?

1. MCQ

   Which DNS record maps a domain to its mail server?

   1. A
   2. NS
   3. CNAME
   4. MX
2. NAT

   Cold cache, iterative: RTTs host↔local 5 ms, local↔root 50 ms, local↔TLD 25 ms, local↔authoritative 15 ms. Lookup time in ms?

   Write your answer before opening the key.

3. MSQ

   Which are true of DNS?

   1. Ordinary queries use UDP port 53.
   2. Root servers return the final IP address.
   3. Answers are cached for the record's TTL.
   4. Zone transfers use TCP.
4. MCQ

   In iterative resolution, a contacted server that does not know the answer:

   1. forwards the query itself
   2. returns a referral to another server
   3. drops the query
   4. returns an error
5. NAT

   Warm cache: the local resolver already has the final A record. RTT host↔local = 4 ms. Lookup time in ms?

   Write your answer before opening the key.

• Hierarchy: root → TLD → authoritative; local resolver works for hosts and caches.
• Recursive (server chases) vs iterative (referrals); full lookup = 8 messages.
• Lookup time = Σ RTT of servers actually contacted.
• Records: A, AAAA, NS, CNAME, MX; TTL for caching.
• Transport: UDP 53 (normal), TCP 53 (zone transfer / large).

• DNS (Domain Name System)
• domain name hierarchy
• root, TLD, authoritative, local resolver
• recursive vs iterative resolution
• caching and TTL (DNS)
• records A, AAAA, NS, CNAME, MX
• UDP port 53 (TCP 53 for zone transfers)

1. Which server holds the final record?
   Reveal answer

   The authoritative server.
2. DNS transport and port?
   Reveal answer

   UDP 53 (TCP 53 for zone transfers/large answers).
3. CNAME vs A?
   Reveal answer

   CNAME: alias → canonical name. A: name → IPv4 address.
4. Messages in a full uncached lookup?
   Reveal answer

   8.

• Lookup time = sum of the RTTs of every server actually contacted (cached steps skipped). — queries made one after another; no retransmissions.
• Message count for a full lookup through 3 servers = 8 (4 queries + 4 replies). — one root, one TLD, one authoritative server; same count recursive or iterative.