refactor: route packets according to interface in connection (#166)

This PR continues #157 by moving routing logic to use the new interface
fields. It also changes the way packets flow, making devices rewrap
packets into frames and send them with `sendRawPacket`, instead of
telling the `Packet` object where to go. This should simplify how we do
broadcasts.

Author: MegaRedHand

src/programs/echo_sender.ts

@@ -73,7 +73,7 @@ export class SingleEcho extends ProgramBase {
       }
     }
     const ethernetFrame = new EthernetFrame(srcDevice.mac, dstMac, ipPacket);
-    sendRawPacket(this.viewgraph, this.srcId, this.dstId, ethernetFrame);
+    sendRawPacket(this.viewgraph, this.srcId, ethernetFrame);
   }
 
   static getProgramInfo(viewgraph: ViewGraph, srcId: DeviceId): ProgramInfo {

src/types/devices/device.ts

@@ -22,8 +22,7 @@ import { IpAddress } from "../../packets/ip";
 import { DeviceId, RemovedNodeData } from "../graphs/datagraph";
 import { DragDeviceMove, AddEdgeMove } from "../undo-redo";
 import { Layer } from "./layer";
-import { Packet } from "../packet";
-import { MacAddress } from "../../packets/ethernet";
+import { EthernetFrame, MacAddress } from "../../packets/ethernet";
 import { GlobalContext } from "../../context";
 
 export { Layer } from "./layer";
@@ -73,8 +72,7 @@ export abstract class Device extends Container {
    * Returns the id for the next device to send the packet to, or
    * null if there’s no next device to send the packet.
    * */
-  // TODO: Might be general for all device in the future.
-  abstract receivePacket(packet: Packet): Promise<DeviceId | null>;
+  abstract receiveFrame(frame: EthernetFrame): void;
 
   constructor(
     id: DeviceId,

src/types/devices/host.ts

@@ -15,7 +15,6 @@ import {
   Program,
   RunningProgram,
 } from "../../programs";
-import { Packet } from "../packet";
 import { Texture } from "pixi.js";
 import { MacAddress } from "../../packets/ethernet";
 import { GlobalContext } from "../../context";
@@ -46,13 +45,9 @@ export class Host extends NetworkDevice {
     this.loadRunningPrograms();
   }
 
-  receiveDatagram(packet: Packet): Promise<DeviceId | null> {
-    const datagram = packet.rawPacket.payload;
-    if (!(datagram instanceof IPv4Packet)) {
-      return null;
-    }
-    if (this.ip.equals(datagram.destinationAddress)) {
-      this.handlePacket(datagram);
+  receiveDatagram(packet: IPv4Packet): Promise<DeviceId | null> {
+    if (this.ip.equals(packet.destinationAddress)) {
+      this.handlePacket(packet);
     }
     return null;
   }

src/types/devices/networkDevice.ts

@@ -5,7 +5,7 @@ import { Device } from "./device";
 import { ViewGraph } from "../graphs/viewgraph";
 import { Position } from "../common";
 import { EthernetFrame, MacAddress } from "../../packets/ethernet";
-import { Packet, sendRawPacket } from "../packet";
+import { sendRawPacket } from "../packet";
 import { EchoReply, EchoRequest } from "../../packets/icmp";
 import { GlobalContext } from "../../context";
 
@@ -28,7 +28,7 @@ export abstract class NetworkDevice extends Device {
     this.ipMask = ipMask;
   }
 
-  abstract receiveDatagram(packet: Packet): Promise<DeviceId | null>;
+  abstract receiveDatagram(packet: IPv4Packet): void;
 
   // TODO: Most probably it will be different for each type of device
   handlePacket(datagram: IPv4Packet) {
@@ -54,7 +54,7 @@ export abstract class NetworkDevice extends Device {
           const echoReply = new EchoReply(0);
           const ipPacket = new IPv4Packet(this.ip, dstDevice.ip, echoReply);
           const ethernet = new EthernetFrame(this.mac, dstMac, ipPacket);
-          sendRawPacket(this.viewgraph, this.id, dstDevice.id, ethernet);
+          sendRawPacket(this.viewgraph, this.id, ethernet);
         }
         break;
       }
@@ -63,11 +63,15 @@ export abstract class NetworkDevice extends Device {
     }
   }
 
-  async receivePacket(packet: Packet): Promise<DeviceId | null> {
-    const frame = packet.rawPacket;
-    if (this.mac.equals(frame.destination)) {
-      return this.receiveDatagram(packet);
+  receiveFrame(frame: EthernetFrame): void {
+    if (!this.mac.equals(frame.destination)) {
+      return;
+    }
+    if (!(frame.payload instanceof IPv4Packet)) {
+      console.error("Packet's type not IPv4");
+      return;
     }
-    return null;
+    const datagram = frame.payload;
+    this.receiveDatagram(datagram);
   }
 }

src/types/devices/router.ts

@@ -6,17 +6,22 @@ import { Position } from "../common";
 import { DeviceInfo, RightBar } from "../../graphics/right_bar";
 import { IpAddress, IPv4Packet } from "../../packets/ip";
 import { DeviceId, isRouter } from "../graphs/datagraph";
-import { Texture } from "pixi.js";
-import { MacAddress } from "../../packets/ethernet";
-import { Packet } from "../packet";
+import { Texture, Ticker } from "pixi.js";
+import { EthernetFrame, MacAddress } from "../../packets/ethernet";
 import { GlobalContext } from "../../context";
+import { sendRawPacket } from "../packet";
 
 export class Router extends NetworkDevice {
   static DEVICE_TEXTURE: Texture;
 
-  private packetQueueSize = 0;
+  private processingPackets = false;
+  private processingProgress = 0;
+  // Time in ms to process a single packet
+  private timePerPacket = 250;
+
+  private packetQueue: IPv4Packet[] = [];
+  // TODO: we should count this in bytes
   private maxQueueSize = 5;
-  private timePerPacket = 1000;
 
   static getTexture() {
     if (!Router.DEVICE_TEXTURE) {
@@ -55,60 +60,90 @@ export class Router extends NetworkDevice {
     return DeviceType.Router;
   }
 
-  async routePacket(datagram: IPv4Packet): Promise<DeviceId | null> {
-    const device = this.viewgraph.getDataGraph().getDevice(this.id);
-    if (!device || !isRouter(device)) {
-      return null;
+  receiveDatagram(datagram: IPv4Packet) {
+    if (this.ip.equals(datagram.destinationAddress)) {
+      this.handlePacket(datagram);
+      return;
     }
-    if (this.packetQueueSize >= this.maxQueueSize) {
+    this.addPacketToQueue(datagram);
+  }
+
+  addPacketToQueue(datagram: IPv4Packet) {
+    if (this.packetQueue.length >= this.maxQueueSize) {
       console.debug("Packet queue full, dropping packet");
-      return null;
+      return;
+    }
+    this.packetQueue.push(datagram);
+    // Start packet processor if not already running
+    if (!this.processingPackets) {
+      Ticker.shared.add(this.processPacket, this);
+      this.processingPackets = true;
+    }
+  }
+
+  processPacket(ticker: Ticker) {
+    this.processingProgress += ticker.deltaMS;
+    if (this.processingProgress < this.timePerPacket) {
+      return;
+    }
+    this.processingProgress -= this.timePerPacket;
+    const datagram = this.packetQueue.pop();
+    const devices = this.routePacket(datagram);
+
+    if (!devices || devices.length === 0) {
+      return;
+    }
+    for (const nextHopId of devices) {
+      // Wrap the datagram in a new frame
+      const nextHop = this.viewgraph.getDevice(nextHopId);
+      if (!nextHop) {
+        console.error("Next hop not found");
+        continue;
+      }
+      const newFrame = new EthernetFrame(this.mac, nextHop.mac, datagram);
+      sendRawPacket(this.viewgraph, this.id, newFrame);
+    }
+
+    // Stop processing packets if queue is empty
+    if (this.packetQueue.length === 0) {
+      Ticker.shared.remove(this.processPacket, this);
+      this.processingPackets = false;
+      this.processingProgress = 0;
+      return;
+    }
+  }
+
+  routePacket(datagram: IPv4Packet): DeviceId[] {
+    const device = this.viewgraph.getDataGraph().getDevice(this.id);
+    if (!device || !isRouter(device)) {
+      return;
     }
-    this.packetQueueSize += 1;
-    console.debug("Processing packet, queue size:", this.packetQueueSize);
-    await new Promise((resolve) => setTimeout(resolve, this.timePerPacket));
-    this.packetQueueSize -= 1;
 
     const result = device.routingTable.find((entry) => {
       if (entry.deleted) {
-        console.log("Skipping deleted entry:", entry);
+        console.debug("Skipping deleted entry:", entry);
         return false;
       }
       const ip = IpAddress.parse(entry.ip);
       const mask = IpAddress.parse(entry.mask);
-      console.log("Considering entry:", entry);
+      console.debug("Considering entry:", entry);
       return datagram.destinationAddress.isInSubnet(ip, mask);
     });
-    console.log("Result:", result);
-    return result === undefined ? null : result.iface;
-  }
 
-  async receiveDatagram(packet: Packet): Promise<DeviceId | null> {
-    const datagram = packet.rawPacket.payload;
-    if (!(datagram instanceof IPv4Packet)) {
-      return null;
+    if (!result) {
+      console.warn("No route found for", datagram.destinationAddress);
+      return [];
     }
-    if (this.ip.equals(datagram.destinationAddress)) {
-      this.handlePacket(datagram);
-      return null;
-    }
-    // a router changed forward datagram to destination, have to change current destination mac
-    const dstDevice = this.viewgraph.getDeviceByIP(datagram.destinationAddress);
-    if (!dstDevice) {
-      console.error("Destination device not found");
-      return null;
-    }
-    const path = this.viewgraph.getPathBetween(this.id, dstDevice.id);
-    let dstMac = dstDevice.mac;
-    if (!path) return null;
-    for (const id of path.slice(1)) {
-      const device = this.viewgraph.getDevice(id);
-      if (device instanceof NetworkDevice) {
-        dstMac = device.mac;
-        break;
-      }
+
+    const devices = this.viewgraph
+      .getDataGraph()
+      .getConnectionsInInterface(this.id, result.iface);
+
+    if (!devices) {
+      console.error("Current device doesn't exist!", this.id);
+      return [];
     }
-    packet.rawPacket.destination = dstMac;
-    return this.routePacket(datagram);
+
+    return devices;
   }
 }

src/types/devices/switch.ts

@@ -4,11 +4,11 @@ import SwitchImage from "../../assets/switch.svg";
 import { Position } from "../common";
 import { DeviceInfo, RightBar } from "../../graphics/right_bar";
 import { DeviceId } from "../graphs/datagraph";
-import { Packet } from "../packet";
 import { Texture } from "pixi.js";
-import { MacAddress } from "../../packets/ethernet";
+import { EthernetFrame, MacAddress } from "../../packets/ethernet";
 import { IPv4Packet } from "../../packets/ip";
 import { GlobalContext } from "../../context";
+import { sendRawPacket } from "../packet";
 
 export class Switch extends Device {
   static DEVICE_TEXTURE: Texture;
@@ -44,19 +44,31 @@ export class Switch extends Device {
     return DeviceType.Switch;
   }
 
-  receivePacket(packet: Packet): Promise<DeviceId | null> {
-    const datagram = packet.rawPacket.payload;
-    if (datagram instanceof IPv4Packet) {
-      const dstDevice = this.viewgraph.getDeviceByIP(
-        datagram.destinationAddress,
-      );
-      if (!dstDevice) {
-        console.error("Destination device not found");
-        return null;
-      }
-      const path = this.viewgraph.getPathBetween(this.id, dstDevice.id);
-      return Promise.resolve(path.length > 1 ? path[1] : null);
+  receiveFrame(frame: EthernetFrame) {
+    const datagram = frame.payload;
+    if (!(datagram instanceof IPv4Packet)) {
+      return;
     }
-    return null;
+    // TODO: this should add the sender to the switching table,
+    //       try to match the packet against it to find a receiver,
+    //       and broadcast it if no receiver is found
+    const dstDevice = this.viewgraph.getDeviceByIP(datagram.destinationAddress);
+    if (!dstDevice) {
+      console.error("Destination device not found");
+      return;
+    }
+    const path = this.viewgraph.getPathBetween(this.id, dstDevice.id);
+    if (path.length < 2) {
+      console.error("Destination device is not reachable");
+      return;
+    }
+    const nextHopId = path[1];
+    const nextHop = this.viewgraph.getDevice(nextHopId);
+    if (!nextHop) {
+      console.error("Next hop not found");
+      return;
+    }
+    const newFrame = new EthernetFrame(this.mac, nextHop.mac, datagram);
+    sendRawPacket(this.viewgraph, this.id, newFrame);
   }
 }

src/types/graphs/datagraph.ts

@@ -105,8 +105,7 @@ interface SwitchDataNode extends LinkDataNode {
 
 interface EdgeTip {
   id: DeviceId;
-  // TODO: uncomment this
-  // iface: number;
+  iface: number;
 }
 
 interface GraphEdge {
@@ -233,7 +232,10 @@ export class DataGraph {
       );
       return;
     }
-    const edge = { from: { id: n1Id }, to: { id: n2Id } };
+    const edge = {
+      from: { id: n1Id, iface: n2Id },
+      to: { id: n2Id, iface: n1Id },
+    };
     this.deviceGraph.setEdge(n1Id, n2Id, edge);
 
     console.log(
@@ -288,6 +290,26 @@ export class DataGraph {
     return this.deviceGraph.getNeighbors(id);
   }
 
+  // Get all connections of a device in a given interface
+  getConnectionsInInterface(
+    id: DeviceId,
+    iface: number,
+  ): DeviceId[] | undefined {
+    if (!this.deviceGraph.hasVertex(id)) {
+      return;
+    }
+    const connections = [];
+    for (const [neighborId, { from, to }] of this.deviceGraph.getEdges(id)) {
+      if (
+        (from.id === id && from.iface === iface) ||
+        (to.id === id && to.iface === iface)
+      ) {
+        connections.push(neighborId);
+      }
+    }
+    return connections;
+  }
+
   // Method to remove a device and all its connections
   removeDevice(id: DeviceId): RemovedNodeData | undefined {
     if (!this.deviceGraph.hasVertex(id)) {