Routers, Switches and Gateways

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func toNumber(ip string) uint32 {
	var n uint32
	for _, part := range strings.Split(ip, ".") {
		b, _ := strconv.Atoi(part)
		n = n<<8 | uint32(b)
	}
	return n
}

type route struct {
	block   string // destination block, like "10.8.0.0/16"
	nextHop string // where to send matching packets
}

// The router's table. Order doesn't matter: the most specific match wins.
var table = []route{
	{"0.0.0.0/0", "via ISP 203.0.113.1 (default route)"},
	{"192.168.1.0/24", "direct on lan0 (the switch delivers it)"},
	{"10.8.0.0/16", "via vpn0 to the office"},
	{"10.8.5.0/24", "via 10.8.0.1 (office B's router)"},
}

// lookup finds every route whose block contains ip and picks the longest prefix.
func lookup(ip string) (route, int) {
	best, bestBits, matches := route{}, -1, 0
	for _, r := range table {
		network, bitsStr, _ := strings.Cut(r.block, "/")
		bits, _ := strconv.Atoi(bitsStr)
		mask := uint32(0)
		if bits > 0 {
			mask = ^uint32(0) << (32 - bits)
		}
		if toNumber(ip)&mask == toNumber(network)&mask {
			matches++
			if bits > bestBits {
				best, bestBits = r, bits
			}
		}
	}
	return best, matches
}

func main() {
	for _, ip := range []string{"192.168.1.20", "10.8.5.7", "10.8.9.1", "8.8.8.8"} {
		r, n := lookup(ip)
		fmt.Printf("%-13s %d matching, uses %-15s -> %s\n", ip, n, r.block, r.nextHop)
	}

	fmt.Println("TTL: a packet caught between two misconfigured routers")
	ttl, at := 3, "A"
	for hop := 1; ; hop++ {
		ttl-- // every router takes one off before forwarding
		if ttl == 0 {
			fmt.Printf("hop %d: router %s, TTL 1 -> 0, dropped; \"time exceeded\" sent back\n", hop, at)
			break
		}
		next := map[string]string{"A": "B", "B": "A"}[at] // each thinks the other is the way
		fmt.Printf("hop %d: router %s, TTL %d -> %d, forwards to %s\n", hop, at, ttl+1, ttl, next)
		at = next
	}
}

const toNumber = (ip) => ip.split(".").reduce((n, part) => ((n << 8) | Number(part)) >>> 0, 0);

// The router's table: [destination block, next hop]. Order doesn't matter: the most specific match wins.
const table = [
  ["0.0.0.0/0", "via ISP 203.0.113.1 (default route)"],
  ["192.168.1.0/24", "direct on lan0 (the switch delivers it)"],
  ["10.8.0.0/16", "via vpn0 to the office"],
  ["10.8.5.0/24", "via 10.8.0.1 (office B's router)"],
];

// lookup finds every route whose block contains ip and picks the longest prefix.
function lookup(ip) {
  let best = null;
  let bestBits = -1;
  let matches = 0;
  for (const route of table) {
    const [network, bitsStr] = route[0].split("/");
    const bits = Number(bitsStr);
    const mask = bits === 0 ? 0 : (~0 << (32 - bits)) >>> 0;
    if (((toNumber(ip) & mask) >>> 0) === ((toNumber(network) & mask) >>> 0)) {
      matches++;
      if (bits > bestBits) [best, bestBits] = [route, bits];
    }
  }
  return [best, matches];
}

for (const ip of ["192.168.1.20", "10.8.5.7", "10.8.9.1", "8.8.8.8"]) {
  const [[block, nextHop], n] = lookup(ip);
  console.log(`${ip.padEnd(13)} ${n} matching, uses ${block.padEnd(15)} -> ${nextHop}`);
}

console.log("TTL: a packet caught between two misconfigured routers");
let ttl = 3;
let at = "A";
for (let hop = 1; ; hop++) {
  ttl--; // every router takes one off before forwarding
  if (ttl === 0) {
    console.log(`hop ${hop}: router ${at}, TTL 1 -> 0, dropped; "time exceeded" sent back`);
    break;
  }
  const next = { A: "B", B: "A" }[at]; // each thinks the other is the way
  console.log(`hop ${hop}: router ${at}, TTL ${ttl + 1} -> ${ttl}, forwards to ${next}`);
  at = next;
}

fn to_number(ip: &str) -> u32 {
    ip.split('.').fold(0, |n, part| n << 8 | part.parse::<u32>().unwrap())
}

// The router's table: (destination block, next hop). Order doesn't matter: the most specific match wins.
const TABLE: [(&str, &str); 4] = [
    ("0.0.0.0/0", "via ISP 203.0.113.1 (default route)"),
    ("192.168.1.0/24", "direct on lan0 (the switch delivers it)"),
    ("10.8.0.0/16", "via vpn0 to the office"),
    ("10.8.5.0/24", "via 10.8.0.1 (office B's router)"),
];

// Finds every route whose block contains ip and picks the longest prefix.
fn lookup(ip: &str) -> ((&'static str, &'static str), usize) {
    let mut best = TABLE[0];
    let mut best_bits: i32 = -1;
    let mut matches = 0;
    for route in TABLE {
        let (network, bits) = route.0.split_once('/').unwrap();
        let bits: u32 = bits.parse().unwrap();
        let mask = if bits == 0 { 0 } else { u32::MAX << (32 - bits) };
        if to_number(ip) & mask == to_number(network) & mask {
            matches += 1;
            if bits as i32 > best_bits {
                best = route;
                best_bits = bits as i32;
            }
        }
    }
    (best, matches)
}

fn main() {
    for ip in ["192.168.1.20", "10.8.5.7", "10.8.9.1", "8.8.8.8"] {
        let ((block, next_hop), n) = lookup(ip);
        println!("{:<13} {} matching, uses {:<15} -> {}", ip, n, block, next_hop);
    }

    println!("TTL: a packet caught between two misconfigured routers");
    let (mut ttl, mut at) = (3, "A");
    for hop in 1.. {
        ttl -= 1; // every router takes one off before forwarding
        if ttl == 0 {
            println!("hop {hop}: router {at}, TTL 1 -> 0, dropped; \"time exceeded\" sent back");
            break;
        }
        let next = if at == "A" { "B" } else { "A" }; // each thinks the other is the way
        println!("hop {hop}: router {at}, TTL {} -> {ttl}, forwards to {next}", ttl + 1);
        at = next;
    }
}

def to_number(ip):
    n = 0
    for part in ip.split("."):
        n = (n << 8) | int(part)
    return n


# The router's table: (destination block, next hop). Order doesn't matter: the most specific match wins.
TABLE = [
    ("0.0.0.0/0", "via ISP 203.0.113.1 (default route)"),
    ("192.168.1.0/24", "direct on lan0 (the switch delivers it)"),
    ("10.8.0.0/16", "via vpn0 to the office"),
    ("10.8.5.0/24", "via 10.8.0.1 (office B's router)"),
]


def lookup(ip):
    """Finds every route whose block contains ip and picks the longest prefix."""
    best, best_bits, matches = None, -1, 0
    for block, next_hop in TABLE:
        network, bits = block.split("/")
        bits = int(bits)
        mask = (0xFFFFFFFF << (32 - bits)) & 0xFFFFFFFF
        if to_number(ip) & mask == to_number(network) & mask:
            matches += 1
            if bits > best_bits:
                best, best_bits = (block, next_hop), bits
    return best, matches


for ip in ["192.168.1.20", "10.8.5.7", "10.8.9.1", "8.8.8.8"]:
    (block, next_hop), n = lookup(ip)
    print(f"{ip:<13} {n} matching, uses {block:<15} -> {next_hop}")

print("TTL: a packet caught between two misconfigured routers")
ttl, at, hop = 3, "A", 0
while True:
    hop += 1
    ttl -= 1  # every router takes one off before forwarding
    if ttl == 0:
        print(f'hop {hop}: router {at}, TTL 1 -> 0, dropped; "time exceeded" sent back')
        break
    nxt = {"A": "B", "B": "A"}[at]  # each thinks the other is the way
    print(f"hop {hop}: router {at}, TTL {ttl + 1} -> {ttl}, forwards to {nxt}")
    at = nxt

public class Main {
    static long toNumber(String ip) {
        long n = 0;
        for (String part : ip.split("\\.")) n = (n << 8) | Integer.parseInt(part);
        return n;
    }

    // The router's table: {destination block, next hop}. Order doesn't matter: the most specific match wins.
    static final String[][] TABLE = {
        {"0.0.0.0/0", "via ISP 203.0.113.1 (default route)"},
        {"192.168.1.0/24", "direct on lan0 (the switch delivers it)"},
        {"10.8.0.0/16", "via vpn0 to the office"},
        {"10.8.5.0/24", "via 10.8.0.1 (office B's router)"},
    };

    // lookup finds every route whose block contains ip and picks the longest prefix.
    static Object[] lookup(String ip) {
        String[] best = null;
        int bestBits = -1, matches = 0;
        for (String[] route : TABLE) {
            String[] nb = route[0].split("/");
            int bits = Integer.parseInt(nb[1]);
            long mask = (0xFFFFFFFFL << (32 - bits)) & 0xFFFFFFFFL;
            if ((toNumber(ip) & mask) == (toNumber(nb[0]) & mask)) {
                matches++;
                if (bits > bestBits) { best = route; bestBits = bits; }
            }
        }
        return new Object[] {best, matches};
    }

    public static void main(String[] args) {
        for (String ip : new String[] {"192.168.1.20", "10.8.5.7", "10.8.9.1", "8.8.8.8"}) {
            Object[] r = lookup(ip);
            String[] route = (String[]) r[0];
            System.out.printf("%-13s %d matching, uses %-15s -> %s%n", ip, r[1], route[0], route[1]);
        }

        System.out.println("TTL: a packet caught between two misconfigured routers");
        int ttl = 3;
        String at = "A";
        for (int hop = 1; ; hop++) {
            ttl--; // every router takes one off before forwarding
            if (ttl == 0) {
                System.out.printf("hop %d: router %s, TTL 1 -> 0, dropped; \"time exceeded\" sent back%n", hop, at);
                break;
            }
            String next = at.equals("A") ? "B" : "A"; // each thinks the other is the way
            System.out.printf("hop %d: router %s, TTL %d -> %d, forwards to %s%n", hop, at, ttl + 1, ttl, next);
            at = next;
        }
    }
}