Understanding the Domain Name System (DNS) hierarchy is fundamental to grasping how the Internet translates human-friendly domain names into IP addresses. DNS is organized as a distributed, hierarchical database, structured in layers that enable efficient, scalable name resolution. At the top of this hierarchy are the root name servers, which serve as the ultimate authority for all DNS lookups. These root servers know where to direct queries for any top-level domain (TLD), such as .com, .org, or country-specific TLDs like .uk. Below the root servers are the TLD name servers, each responsible for a specific domain extension. These servers maintain information about the authoritative name servers for domains registered under their TLD. Finally, authoritative name servers are responsible for storing DNS records for specific domains, such as example.com, and provide definitive answers about those domains' resource records.

When a DNS resolver needs to obtain the IP address for a domain, it can use either a recursive or iterative query process. In a recursive query, the DNS resolver takes full responsibility for resolving the query, contacting each server in the hierarchy on behalf of the client until it finds the answer. In contrast, with an iterative query, each server returns the best answer it knows—often a referral to another server—leaving it up to the resolver to continue the process.

Pseudo code for a recursive DNS query:

function resolve(domain):
    if local_cache.contains(domain):
        return local_cache[domain]
    else:
        response = query(root_server, domain)
        if response.is_answer():
            return response.answer
        else:
            return resolve(response.referred_server, domain)

Pseudo code for an iterative DNS query:

function resolve(domain):
    current_server = root_server
    while True:
        response = query(current_server, domain)
        if response.is_answer():
            return response.answer
        elif response.has_referral():
            current_server = response.referred_server
        else:
            return null

DNS zone files are crucial to the operation of authoritative name servers. A zone file is a text file that contains mappings between domain names and IP addresses, as well as other resource records such as mail exchangers and name servers. The process of delegation allows a parent zone to assign authority for a subdomain to another name server, which is then responsible for maintaining its own zone file. This delegation is accomplished through NS (Name Server) records in the parent zone, pointing to the authoritative servers for the child zone.

At the heart of every DNS zone file is the Start of Authority (SOA) record. The SOA record defines key administrative information about the zone, including the primary authoritative name server, the email address of the zone administrator, the zone serial number (used for versioning), and timers that control zone transfers and caching. Delegation and the correct configuration of SOA records are essential for a reliable and efficient DNS hierarchy.

The process of DNS zone delegation and lookup can be represented in pseudo code as follows:

function lookup(domain):
    zone = find_parent_zone(domain)
    if zone.delegates_to(domain):
        child_zone = zone.get_delegated_zone(domain)
        return lookup_in_zone(child_zone, domain)
    else:
        return lookup_in_zone(zone, domain)

function lookup_in_zone(zone, domain):
    if zone.has_record(domain):
        return zone.get_record(domain)
    else:
        return null