Switch ও ARP — MAC address কে কোথায় পাঠাব জানা

লক্ষ্য: example-section-এর T0–T4-scenario executable — table-evolution নিজের-চোখে, নিজের-engine-এ।

#!/usr/bin/env python3
"""arp_sim.py — একটা LAN-এ switch-learning + ARP-এর miniature simulation।"""

class Host:
    def __init__(self, name, ip, mac, port):
        self.name, self.ip, self.mac, self.port = name, ip, mac, port
        self.cache = {}                       # ip -> mac

    def want_send(self, net, dst_ip, payload):
        """Gateway-decision + (দরকার হলে) ARP — event yield করে।"""
        if net.is_local(dst_ip):
            target_ip = dst_ip
        else:
            target_ip = net.gateway_ip        # off-subnet → gateway
        if target_ip not in self.cache:
            print(f"[{self.name}] ARP? {target_ip} এর MAC জানি না")
            yield from net.arp_exchange(self, target_ip)
        dst_mac = self.cache[target_ip]
        yield ("frame", self, dst_mac, payload)

class Switch:
    def __init__(self):
        self.table = {}                       # mac -> port
        self.hosts_by_port = {}

    def learn(self, mac, port):
        if self.table.get(mac) != port:
            self.table[mac] = port
            print(f"  switch learns {mac} -> p{port}")

    def forward(self, frame):
        _, src_host, dst_mac, _ = frame
        self.learn(src_host.mac, src_host.port)
        out = self.table.get(dst_mac)
        if out is None:
            ports = [p for p in self.hosts_by_port if p != src_host.port]
            action = f"FLOOD {ports}"
        else:
            action = f"FORWARD p{out}"
        print(f"  switch: {src_host.name} -> {dst_mac[:8]}… : {action}")

class Network:
    def __init__(self, cidr, gateway_ip):
        self.prefix = cidr
        self.gateway_ip = gateway_ip
        self.switch = Switch()
        self.hosts = []

    def add(self, host):
        self.hosts.append(host)
        self.switch.hosts_by_port[host.port] = host

    def is_local(self, ip):
        return ip.rsplit(".", 1)[0] == self.prefix

    def arp_exchange(self, asker, target_ip):
        print(f"[{asker.name}] ARP who-has {target_ip}? (broadcast)")
        self.switch.learn(asker.mac, asker.port)
        for h in self.hosts:                  # broadcast: সবাই শোনে
            h.cache.setdefault(asker.ip, asker.mac)
        target = next(h for h in self.hosts if h.ip == target_ip)
        asker.cache[target_ip] = target.mac
        print(f"[{target.name}] ARP reply {target_ip} is-at {target.mac}")
        yield ("arp", asker, target.mac, None)

net = Network("192.168.1", gateway_ip="192.168.1.1")
laptop = Host("laptop", "192.168.1.20", "a4:5e:60:d2:1f:83", 1)
tv     = Host("tv",     "192.168.1.30", "3c:22:fb:09:aa:71", 2)
gw     = Host("gw",     "192.168.1.1",  "b8:27:eb:44:9c:10", 4)
for h in (laptop, tv, gw): net.add(h)
net.switch.hosts_by_port[3] = None              # খালি port p3

print("== T1: laptop → gateway ping ==")
for ev in laptop.want_send(net, "192.168.1.1", "ICMP echo"):
    if ev[0] == "frame": net.switch.forward(ev)

print("== T2: laptop → internet (off-subnet, via gw) ==")
for ev in laptop.want_send(net, "93.184.216.34", "HTTP GET"):
    if ev[0] == "frame":
        print(f"  frame dst-MAC={ev[2]} (gw! not the server)")
        net.switch.forward(ev)

print("== final switch table ==")
for m, p in sorted(net.switch.table.items()):
    print(f"  p{p}: {m}")

প্রত্যাশিত output (সংক্ষেপে):

== T1 ==
[laptop] ARP? 192.168.1.1 এর MAC জানি না
[laptop] ARP who-has 192.168.1.1? (broadcast)
[gw] ARP reply 192.168.1.1 is-at b8:27:eb:44:9c:10
  switch learns a4:5e:60:d2:1f:83 -> p1
  switch: laptop -> b8:27:eb… : FORWARD p4
== T2 ==
  frame dst-MAC=b8:27:eb:44:9c:10 (gw! not the server)
  switch: laptop -> b8:27:eb… : FORWARD p4
== final switch table ==
  p1: a4:5e:60:d2:1f:83
  p4: b8:27:eb:44:9c:10

T2-র সেই print-line-ই লেসনের heart: internet-bound frame-ও L2-তে শুধু gateway-কে চেনে।

নিজে বাড়ান:

1. Aging-timer: timestamp+300 s expire → forced-re-flood
2. Attacker-host fake-gratuitous-announce → cache-poison-animation
3. Duplicate-MAC-migration: নতুন-port overwrite + flap-log