MAC Addresses and ARP

package main

import (
	"fmt"
	"strings"
)

// The devices on this LAN: IP address -> the MAC address burned into their network card.
var lan = map[string]string{
	"192.168.1.1":  "3c:22:fb:00:00:01", // the router (gateway to everything else)
	"192.168.1.10": "3c:22:fb:00:00:10", // our laptop
	"192.168.1.20": "3c:22:fb:00:00:20", // a printer
}

const gateway = "192.168.1.1"

// The laptop's ARP cache: IPs it has already asked about, in the order it learned them.
var cache [][2]string

// sameLAN: for a /24 network, the first three numbers must match.
func sameLAN(ip string) bool {
	return ip[:strings.LastIndex(ip, ".")] == "192.168.1"
}

// arp finds the MAC for an IP on this LAN: from the cache, or by asking everyone.
func arp(ip string) (mac string, how string) {
	for _, c := range cache {
		if c[0] == ip {
			return c[1], "ARP cache hit"
		}
	}
	how = fmt.Sprintf("ARP \"who has %s?\"", ip) // broadcast to every device on the LAN
	mac, ok := lan[ip]                           // only the owner answers
	if !ok {
		return "", how + " -> no answer"
	}
	cache = append(cache, [2]string{ip, mac})
	return mac, how + " -> " + mac
}

func send(dst string) {
	nextHop, where := dst, "local"
	if !sameLAN(dst) {
		nextHop, where = gateway, "not local, next hop is gateway "+gateway
	}
	mac, how := arp(nextHop)
	if mac == "" {
		fmt.Printf("send to %s: %s; %s: host unreachable\n", dst, where, how)
		return
	}
	fmt.Printf("send to %s: %s; %s; frame to %s (IP still %s)\n", dst, where, how, mac, dst)
}

func main() {
	send("192.168.1.20")
	send("192.168.1.20")
	send("8.8.8.8")
	send("192.168.1.99")
	parts := []string{}
	for _, c := range cache {
		parts = append(parts, c[0]+"="+c[1])
	}
	fmt.Println("arp cache:", strings.Join(parts, ", "))
}

// The devices on this LAN: IP address -> the MAC address burned into their network card.
const lan = {
  "192.168.1.1": "3c:22:fb:00:00:01", // the router (gateway to everything else)
  "192.168.1.10": "3c:22:fb:00:00:10", // our laptop
  "192.168.1.20": "3c:22:fb:00:00:20", // a printer
};
const GATEWAY = "192.168.1.1";

// The laptop's ARP cache: IPs it has already asked about, in the order it learned them.
const cache = new Map();

// sameLAN: for a /24 network, the first three numbers must match.
const sameLAN = (ip) => ip.slice(0, ip.lastIndexOf(".")) === "192.168.1";

// arp finds the MAC for an IP on this LAN: from the cache, or by asking everyone.
function arp(ip) {
  if (cache.has(ip)) return [cache.get(ip), "ARP cache hit"];
  const how = `ARP "who has ${ip}?"`; // broadcast to every device on the LAN
  const mac = lan[ip]; // only the owner answers
  if (!mac) return ["", `${how} -> no answer`];
  cache.set(ip, mac);
  return [mac, `${how} -> ${mac}`];
}

function send(dst) {
  const local = sameLAN(dst);
  const nextHop = local ? dst : GATEWAY;
  const where = local ? "local" : `not local, next hop is gateway ${GATEWAY}`;
  const [mac, how] = arp(nextHop);
  if (!mac) return console.log(`send to ${dst}: ${where}; ${how}: host unreachable`);
  console.log(`send to ${dst}: ${where}; ${how}; frame to ${mac} (IP still ${dst})`);
}

send("192.168.1.20");
send("192.168.1.20");
send("8.8.8.8");
send("192.168.1.99");
console.log(`arp cache: ${[...cache].map(([ip, mac]) => `${ip}=${mac}`).join(", ")}`);

use std::collections::HashMap;

const GATEWAY: &str = "192.168.1.1";

struct Laptop {
    // The devices on this LAN: IP address -> the MAC address burned into their network card.
    lan: HashMap<&'static str, &'static str>,
    // The ARP cache: IPs already asked about, in the order they were learned.
    cache: Vec<(String, String)>,
}

// same_lan: for a /24 network, the first three numbers must match.
fn same_lan(ip: &str) -> bool {
    ip.rsplit_once('.').unwrap().0 == "192.168.1"
}

impl Laptop {
    // arp finds the MAC for an IP on this LAN: from the cache, or by asking everyone.
    fn arp(&mut self, ip: &str) -> (String, String) {
        if let Some((_, mac)) = self.cache.iter().find(|(i, _)| i == ip) {
            return (mac.clone(), "ARP cache hit".into());
        }
        let how = format!("ARP \"who has {ip}?\""); // broadcast to every device on the LAN
        match self.lan.get(ip) {
            None => (String::new(), format!("{how} -> no answer")),
            Some(mac) => {
                self.cache.push((ip.to_string(), mac.to_string())); // only the owner answers
                (mac.to_string(), format!("{how} -> {mac}"))
            }
        }
    }

    fn send(&mut self, dst: &str) {
        let local = same_lan(dst);
        let next_hop = if local { dst } else { GATEWAY };
        let where_ = if local { "local".to_string() } else { format!("not local, next hop is gateway {GATEWAY}") };
        let (mac, how) = self.arp(next_hop);
        if mac.is_empty() {
            println!("send to {dst}: {where_}; {how}: host unreachable");
        } else {
            println!("send to {dst}: {where_}; {how}; frame to {mac} (IP still {dst})");
        }
    }
}

fn main() {
    let mut laptop = Laptop {
        lan: HashMap::from([
            ("192.168.1.1", "3c:22:fb:00:00:01"),  // the router (gateway to everything else)
            ("192.168.1.10", "3c:22:fb:00:00:10"), // our laptop
            ("192.168.1.20", "3c:22:fb:00:00:20"), // a printer
        ]),
        cache: vec![],
    };
    laptop.send("192.168.1.20");
    laptop.send("192.168.1.20");
    laptop.send("8.8.8.8");
    laptop.send("192.168.1.99");
    let parts: Vec<String> = laptop.cache.iter().map(|(ip, mac)| format!("{ip}={mac}")).collect();
    println!("arp cache: {}", parts.join(", "));
}

# The devices on this LAN: IP address -> the MAC address burned into their network card.
LAN = {
    "192.168.1.1": "3c:22:fb:00:00:01",  # the router (gateway to everything else)
    "192.168.1.10": "3c:22:fb:00:00:10",  # our laptop
    "192.168.1.20": "3c:22:fb:00:00:20",  # a printer
}
GATEWAY = "192.168.1.1"

# The laptop's ARP cache: IPs it has already asked about, in the order it learned them.
cache = {}


def same_lan(ip):
    """For a /24 network, the first three numbers must match."""
    return ip.rsplit(".", 1)[0] == "192.168.1"


def arp(ip):
    """Finds the MAC for an IP on this LAN: from the cache, or by asking everyone."""
    if ip in cache:
        return cache[ip], "ARP cache hit"
    how = f'ARP "who has {ip}?"'  # broadcast to every device on the LAN
    mac = LAN.get(ip)  # only the owner answers
    if mac is None:
        return "", f"{how} -> no answer"
    cache[ip] = mac
    return mac, f"{how} -> {mac}"


def send(dst):
    local = same_lan(dst)
    next_hop = dst if local else GATEWAY
    where = "local" if local else f"not local, next hop is gateway {GATEWAY}"
    mac, how = arp(next_hop)
    if not mac:
        print(f"send to {dst}: {where}; {how}: host unreachable")
        return
    print(f"send to {dst}: {where}; {how}; frame to {mac} (IP still {dst})")


send("192.168.1.20")
send("192.168.1.20")
send("8.8.8.8")
send("192.168.1.99")
print("arp cache:", ", ".join(f"{ip}={mac}" for ip, mac in cache.items()))

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    // The devices on this LAN: IP address -> the MAC address burned into their network card.
    static final Map<String, String> LAN = Map.of(
        "192.168.1.1", "3c:22:fb:00:00:01", // the router (gateway to everything else)
        "192.168.1.10", "3c:22:fb:00:00:10", // our laptop
        "192.168.1.20", "3c:22:fb:00:00:20"); // a printer
    static final String GATEWAY = "192.168.1.1";

    // The laptop's ARP cache: IPs it has already asked about, in the order it learned them.
    static final Map<String, String> CACHE = new LinkedHashMap<>();

    // sameLAN: for a /24 network, the first three numbers must match.
    static boolean sameLAN(String ip) {
        return ip.substring(0, ip.lastIndexOf('.')).equals("192.168.1");
    }

    // arp finds the MAC for an IP on this LAN: from the cache, or by asking everyone.
    static String[] arp(String ip) {
        if (CACHE.containsKey(ip)) return new String[] {CACHE.get(ip), "ARP cache hit"};
        String how = "ARP \"who has " + ip + "?\""; // broadcast to every device on the LAN
        String mac = LAN.get(ip); // only the owner answers
        if (mac == null) return new String[] {"", how + " -> no answer"};
        CACHE.put(ip, mac);
        return new String[] {mac, how + " -> " + mac};
    }

    static void send(String dst) {
        boolean local = sameLAN(dst);
        String nextHop = local ? dst : GATEWAY;
        String where = local ? "local" : "not local, next hop is gateway " + GATEWAY;
        String[] r = arp(nextHop);
        if (r[0].isEmpty()) System.out.printf("send to %s: %s; %s: host unreachable%n", dst, where, r[1]);
        else System.out.printf("send to %s: %s; %s; frame to %s (IP still %s)%n", dst, where, r[1], r[0], dst);
    }

    public static void main(String[] args) {
        send("192.168.1.20");
        send("192.168.1.20");
        send("8.8.8.8");
        send("192.168.1.99");
        System.out.println("arp cache: " + CACHE.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.joining(", ")));
    }
}