DNS: Names to Addresses

package main

import (
	"fmt"
	"strings"
)

// What each name server knows. Root and TLD servers only know who to ask next;
// the authoritative server for a domain knows its actual records.
var root = map[string]string{"com": "a.gtld-servers.net"}
var tld = map[string]string{"codingfoding.com": "ns1.cfdns.net"}
var zone = map[string][2]string{ // name -> {type, value}
	"codingfoding.com":     {"A", "203.0.113.80"},
	"www.codingfoding.com": {"CNAME", "codingfoding.com"},
	"api.codingfoding.com": {"A", "203.0.113.81"},
}

const answerTTL = 300 // seconds an answer may be cached
const nsTTL = 172800  // seconds "who serves this domain" may be cached (2 days)

type entry struct {
	value   string
	expires int
}

// The resolver's cache: answers, and delegations (which server to ask for a domain).
var answers = map[string]entry{}
var delegations = map[string]entry{}

// resolve looks a name up at time `now`, and returns the answer and who it had to ask.
func resolve(name string, now int) (string, []string, string) {
	note := ""
	if e, ok := answers[name]; ok {
		if now < e.expires {
			return e.value, nil, ""
		}
		note = "cache entry expired"
	}
	labels := strings.Split(name, ".")
	domain := strings.Join(labels[len(labels)-2:], ".") // codingfoding.com
	var asked []string
	ns, ok := delegations[domain]
	if !ok || now >= ns.expires {
		// Start at the top: root says who runs ".com", and that server says who runs the domain.
		asked = append(asked, "root", root[labels[len(labels)-1]])
		ns = entry{tld[domain], now + nsTTL}
		delegations[domain] = ns
	}
	asked = append(asked, ns.value)
	rec, found := zone[name]
	switch {
	case !found:
		return "NXDOMAIN", asked, note
	case rec[0] == "CNAME":
		ip, more, _ := resolve(rec[1], now) // the real address is under another name
		answers[name] = entry{ip, now + answerTTL}
		return ip, append(asked, more...), "CNAME " + rec[1]
	}
	answers[name] = entry{rec[1], now + answerTTL}
	return rec[1], asked, note
}

func lookup(name string, now int) {
	ip, asked, note := resolve(name, now)
	who := "nobody (cache)"
	if len(asked) > 0 {
		who = strings.Join(asked, ", ")
	}
	if note != "" {
		who += " (" + note + ")"
	}
	fmt.Printf("%-21s -> %-13s asked: %s\n", name, ip, who)
}

func main() {
	lookup("codingfoding.com", 0)
	lookup("codingfoding.com", 5)
	lookup("www.codingfoding.com", 10)
	lookup("nope.codingfoding.com", 20)
	fmt.Println("... 301 s later ...")
	lookup("codingfoding.com", 301)
}

// What each name server knows. Root and TLD servers only know who to ask next;
// the authoritative server for a domain knows its actual records.
const root = { com: "a.gtld-servers.net" };
const tld = { "codingfoding.com": "ns1.cfdns.net" };
const zone = {
  // name -> [type, value]
  "codingfoding.com": ["A", "203.0.113.80"],
  "www.codingfoding.com": ["CNAME", "codingfoding.com"],
  "api.codingfoding.com": ["A", "203.0.113.81"],
};

const ANSWER_TTL = 300; // seconds an answer may be cached
const NS_TTL = 172800; // seconds "who serves this domain" may be cached (2 days)

// The resolver's cache: answers, and delegations (which server to ask for a domain).
const answers = new Map();
const delegations = new Map();

// resolve looks a name up at time `now`, and returns the answer and who it had to ask.
function resolve(name, now) {
  let note = "";
  const cached = answers.get(name);
  if (cached) {
    if (now < cached.expires) return [cached.value, [], ""];
    note = "cache entry expired";
  }
  const labels = name.split(".");
  const domain = labels.slice(-2).join("."); // codingfoding.com
  const asked = [];
  let ns = delegations.get(domain);
  if (!ns || now >= ns.expires) {
    // Start at the top: root says who runs ".com", and that server says who runs the domain.
    asked.push("root", root[labels.at(-1)]);
    ns = { value: tld[domain], expires: now + NS_TTL };
    delegations.set(domain, ns);
  }
  asked.push(ns.value);
  const rec = zone[name];
  if (!rec) return ["NXDOMAIN", asked, note];
  if (rec[0] === "CNAME") {
    const [ip, more] = resolve(rec[1], now); // the real address is under another name
    answers.set(name, { value: ip, expires: now + ANSWER_TTL });
    return [ip, [...asked, ...more], `CNAME ${rec[1]}`];
  }
  answers.set(name, { value: rec[1], expires: now + ANSWER_TTL });
  return [rec[1], asked, note];
}

function lookup(name, now) {
  const [ip, asked, note] = resolve(name, now);
  let who = asked.length ? asked.join(", ") : "nobody (cache)";
  if (note) who += ` (${note})`;
  console.log(`${name.padEnd(21)} -> ${ip.padEnd(13)} asked: ${who}`);
}

lookup("codingfoding.com", 0);
lookup("codingfoding.com", 5);
lookup("www.codingfoding.com", 10);
lookup("nope.codingfoding.com", 20);
console.log("... 301 s later ...");
lookup("codingfoding.com", 301);

use std::collections::HashMap;

const ANSWER_TTL: u32 = 300; // seconds an answer may be cached
const NS_TTL: u32 = 172800; // seconds "who serves this domain" may be cached (2 days)

struct Resolver {
    // What each name server knows. Root and TLD servers only know who to ask next;
    // the authoritative server for a domain knows its actual records.
    root: HashMap<&'static str, &'static str>,
    tld: HashMap<&'static str, &'static str>,
    zone: HashMap<&'static str, (&'static str, &'static str)>, // name -> (type, value)
    // The cache: answers, and delegations (which server to ask for a domain): value, expires.
    answers: HashMap<String, (String, u32)>,
    delegations: HashMap<String, (String, u32)>,
}

impl Resolver {
    // Looks a name up at time `now`, and returns the answer and who it had to ask.
    fn resolve(&mut self, name: &str, now: u32) -> (String, Vec<String>, String) {
        let mut note = String::new();
        if let Some((value, expires)) = self.answers.get(name) {
            if now < *expires {
                return (value.clone(), vec![], String::new());
            }
            note = "cache entry expired".into();
        }
        let labels: Vec<&str> = name.split('.').collect();
        let domain = labels[labels.len() - 2..].join("."); // codingfoding.com
        let mut asked = vec![];
        let fresh = matches!(self.delegations.get(&domain), Some((_, exp)) if now < *exp);
        if !fresh {
            // Start at the top: root says who runs ".com", and that server says who runs the domain.
            asked.push("root".to_string());
            asked.push(self.root[labels[labels.len() - 1]].to_string());
            let ns = self.tld[domain.as_str()].to_string();
            self.delegations.insert(domain.clone(), (ns, now + NS_TTL));
        }
        asked.push(self.delegations[&domain].0.clone());
        match self.zone.get(name).copied() {
            None => ("NXDOMAIN".into(), asked, note),
            Some(("CNAME", target)) => {
                let (ip, more, _) = self.resolve(target, now); // the real address is under another name
                self.answers.insert(name.into(), (ip.clone(), now + ANSWER_TTL));
                asked.extend(more);
                (ip, asked, format!("CNAME {target}"))
            }
            Some((_, ip)) => {
                self.answers.insert(name.into(), (ip.into(), now + ANSWER_TTL));
                (ip.into(), asked, note)
            }
        }
    }

    fn lookup(&mut self, name: &str, now: u32) {
        let (ip, asked, note) = self.resolve(name, now);
        let mut who = if asked.is_empty() { "nobody (cache)".to_string() } else { asked.join(", ") };
        if !note.is_empty() {
            who += &format!(" ({note})");
        }
        println!("{:<21} -> {:<13} asked: {}", name, ip, who);
    }
}

fn main() {
    let mut r = Resolver {
        root: HashMap::from([("com", "a.gtld-servers.net")]),
        tld: HashMap::from([("codingfoding.com", "ns1.cfdns.net")]),
        zone: HashMap::from([
            ("codingfoding.com", ("A", "203.0.113.80")),
            ("www.codingfoding.com", ("CNAME", "codingfoding.com")),
            ("api.codingfoding.com", ("A", "203.0.113.81")),
        ]),
        answers: HashMap::new(),
        delegations: HashMap::new(),
    };
    r.lookup("codingfoding.com", 0);
    r.lookup("codingfoding.com", 5);
    r.lookup("www.codingfoding.com", 10);
    r.lookup("nope.codingfoding.com", 20);
    println!("... 301 s later ...");
    r.lookup("codingfoding.com", 301);
}

# What each name server knows. Root and TLD servers only know who to ask next;
# the authoritative server for a domain knows its actual records.
ROOT = {"com": "a.gtld-servers.net"}
TLD = {"codingfoding.com": "ns1.cfdns.net"}
ZONE = {  # name -> (type, value)
    "codingfoding.com": ("A", "203.0.113.80"),
    "www.codingfoding.com": ("CNAME", "codingfoding.com"),
    "api.codingfoding.com": ("A", "203.0.113.81"),
}

ANSWER_TTL = 300  # seconds an answer may be cached
NS_TTL = 172800  # seconds "who serves this domain" may be cached (2 days)

# The resolver's cache: answers, and delegations (which server to ask for a domain).
answers = {}
delegations = {}


def resolve(name, now):
    """Looks a name up at time `now`, and returns the answer and who it had to ask."""
    note = ""
    if name in answers:
        value, expires = answers[name]
        if now < expires:
            return value, [], ""
        note = "cache entry expired"
    labels = name.split(".")
    domain = ".".join(labels[-2:])  # codingfoding.com
    asked = []
    ns = delegations.get(domain)
    if ns is None or now >= ns[1]:
        # Start at the top: root says who runs ".com", and that server says who runs the domain.
        asked += ["root", ROOT[labels[-1]]]
        ns = (TLD[domain], now + NS_TTL)
        delegations[domain] = ns
    asked.append(ns[0])
    rec = ZONE.get(name)
    if rec is None:
        return "NXDOMAIN", asked, note
    if rec[0] == "CNAME":
        ip, more, _ = resolve(rec[1], now)  # the real address is under another name
        answers[name] = (ip, now + ANSWER_TTL)
        return ip, asked + more, f"CNAME {rec[1]}"
    answers[name] = (rec[1], now + ANSWER_TTL)
    return rec[1], asked, note


def lookup(name, now):
    ip, asked, note = resolve(name, now)
    who = ", ".join(asked) if asked else "nobody (cache)"
    if note:
        who += f" ({note})"
    print(f"{name:<21} -> {ip:<13} asked: {who}")


lookup("codingfoding.com", 0)
lookup("codingfoding.com", 5)
lookup("www.codingfoding.com", 10)
lookup("nope.codingfoding.com", 20)
print("... 301 s later ...")
lookup("codingfoding.com", 301)

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // What each name server knows. Root and TLD servers only know who to ask next;
    // the authoritative server for a domain knows its actual records.
    static final Map<String, String> ROOT = Map.of("com", "a.gtld-servers.net");
    static final Map<String, String> TLD = Map.of("codingfoding.com", "ns1.cfdns.net");
    static final Map<String, String[]> ZONE = Map.of( // name -> {type, value}
        "codingfoding.com", new String[] {"A", "203.0.113.80"},
        "www.codingfoding.com", new String[] {"CNAME", "codingfoding.com"},
        "api.codingfoding.com", new String[] {"A", "203.0.113.81"});

    static final int ANSWER_TTL = 300; // seconds an answer may be cached
    static final int NS_TTL = 172800; // seconds "who serves this domain" may be cached (2 days)

    record Entry(String value, int expires) {}
    record Result(String ip, List<String> asked, String note) {}

    // The resolver's cache: answers, and delegations (which server to ask for a domain).
    static final Map<String, Entry> ANSWERS = new HashMap<>();
    static final Map<String, Entry> DELEGATIONS = new HashMap<>();

    // resolve looks a name up at time `now`, and returns the answer and who it had to ask.
    static Result resolve(String name, int now) {
        String note = "";
        Entry cached = ANSWERS.get(name);
        if (cached != null) {
            if (now < cached.expires()) return new Result(cached.value(), List.of(), "");
            note = "cache entry expired";
        }
        String[] labels = name.split("\\.");
        String domain = labels[labels.length - 2] + "." + labels[labels.length - 1]; // codingfoding.com
        List<String> asked = new ArrayList<>();
        Entry ns = DELEGATIONS.get(domain);
        if (ns == null || now >= ns.expires()) {
            // Start at the top: root says who runs ".com", and that server says who runs the domain.
            asked.add("root");
            asked.add(ROOT.get(labels[labels.length - 1]));
            ns = new Entry(TLD.get(domain), now + NS_TTL);
            DELEGATIONS.put(domain, ns);
        }
        asked.add(ns.value());
        String[] rec = ZONE.get(name);
        if (rec == null) return new Result("NXDOMAIN", asked, note);
        if (rec[0].equals("CNAME")) {
            Result real = resolve(rec[1], now); // the real address is under another name
            ANSWERS.put(name, new Entry(real.ip(), now + ANSWER_TTL));
            asked.addAll(real.asked());
            return new Result(real.ip(), asked, "CNAME " + rec[1]);
        }
        ANSWERS.put(name, new Entry(rec[1], now + ANSWER_TTL));
        return new Result(rec[1], asked, note);
    }

    static void lookup(String name, int now) {
        Result r = resolve(name, now);
        String who = r.asked().isEmpty() ? "nobody (cache)" : String.join(", ", r.asked());
        if (!r.note().isEmpty()) who += " (" + r.note() + ")";
        System.out.printf("%-21s -> %-13s asked: %s%n", name, r.ip(), who);
    }

    public static void main(String[] args) {
        lookup("codingfoding.com", 0);
        lookup("codingfoding.com", 5);
        lookup("www.codingfoding.com", 10);
        lookup("nope.codingfoding.com", 20);
        System.out.println("... 301 s later ...");
        lookup("codingfoding.com", 301);
    }
}