Switching tables (#196)

This PR introduces the implementation of switching tables in the network
simulator, enabling more accurate simulation of switch behavior. The
main updates include:

- **Switching Table Creation and Update:** Switches now maintain a
dynamic switching table that stores MAC address to `DeviceId` (for now,
later it should be changed to interfaces) mappings. These tables are
automatically updated upon receiving packets from connected devices.

- **Packet Forwarding Logic:** Switches use the entries in their
switching tables to forward packets to the correct output interface. If
an entry isn’t found, packets are broadcast as per standard switching
protocols, if it found one but it happens that its output interface
(`DeviceId`) is the same to the input interface, the packet is dropped,
and finally, if an entry with different output interface is found, the
packet is forward to that interface.

- **Refactor of NetworkInterface Location:** The NetworkInterface
component has been moved from DataDevices to ViewDevices, this should
help to integrate interfaces logic to the forwarding packet logic.

---------

Co-authored-by: Pedro Gallino <[email protected]>
Co-authored-by: Tomás Grüner <[email protected]>

Author: 3 people

src/programs/dummy_link_program.ts

@@ -0,0 +1,97 @@
+import { ProgramInfo } from "../graphics/renderables/device_info";
+import { DeviceId } from "../types/graphs/datagraph";
+import { ViewGraph } from "../types/graphs/viewgraph";
+import { ProgramBase } from "./program_base";
+import { ViewNetworkDevice } from "../types/view-devices/vNetworkDevice";
+import { EthernetFrame } from "../packets/ethernet";
+import { sendViewPacket } from "../types/packet";
+import { EmptyPayload, IPv4Packet } from "../packets/ip";
+
+// Dummy program to test the link layer packets forwarding, like ARP Request/Response
+export class DummyLinkProgram extends ProgramBase {
+  static readonly PROGRAM_NAME = "Dummy link program";
+
+  protected dstId: DeviceId;
+
+  constructor(viewgraph: ViewGraph, srcId: DeviceId, inputs: string[]) {
+    super(viewgraph, srcId, inputs);
+    this._parseInputs(inputs);
+  }
+
+  protected _parseInputs(inputs: string[]): void {
+    if (inputs.length !== 1) {
+      console.error(
+        "DummyLinkProgram requires 1 input. " + inputs.length + " were given.",
+      );
+      return;
+    }
+    this.dstId = parseInt(inputs[0]);
+  }
+
+  protected _run() {
+    this.sendSinglePacket();
+    this.signalStop();
+  }
+
+  private sendSinglePacket() {
+    const dstDevice = this.viewgraph.getDevice(this.dstId);
+    const srcDevice = this.viewgraph.getDevice(this.srcId);
+    if (!dstDevice) {
+      console.error("Destination device not found");
+      return;
+    }
+    if (
+      !(srcDevice instanceof ViewNetworkDevice) ||
+      !(dstDevice instanceof ViewNetworkDevice)
+    ) {
+      console.log(
+        "At least one device between source and destination is not a network device",
+      );
+      return;
+    }
+    const path = this.viewgraph.getPathBetween(this.srcId, this.dstId);
+    let dstMac = dstDevice.mac;
+    if (!path) return;
+    for (const id of path.slice(1)) {
+      const device = this.viewgraph.getDevice(id);
+      // if there’s a router in the middle, first send frame to router mac
+      if (device instanceof ViewNetworkDevice) {
+        dstMac = device.mac;
+        break;
+      }
+    }
+    const payload = new IPv4Packet(
+      srcDevice.ip,
+      dstDevice.ip,
+      new EmptyPayload(),
+    );
+    const ethernetFrame = new EthernetFrame(srcDevice.mac, dstMac, payload);
+    sendViewPacket(this.viewgraph, this.srcId, ethernetFrame);
+  }
+
+  protected _stop() {
+    // nothing to do
+  }
+
+  static getProgramInfo(viewgraph: ViewGraph, srcId: DeviceId): ProgramInfo {
+    const programInfo = new ProgramInfo(this.PROGRAM_NAME);
+    programInfo.withDestinationDropdown(viewgraph, srcId);
+    return programInfo;
+  }
+
+  static getProgramName(): string {
+    return this.PROGRAM_NAME;
+  }
+
+  static getProgramDescription(): string {
+    return "Sends a dummy packet every X ms";
+  }
+
+  static getProgramInputs(): string[] {
+    return ["Delay in ms"];
+  }
+
+  static getProgramOutputs(): string[] {
+    return ["Dummy packet"];
+  }
+}

src/programs/echo_sender.ts

@@ -113,6 +113,7 @@ export class EchoServer extends ProgramBase {
   }
 
   protected _stop() {
+    console.debug("Stopping EchoServer");
     Ticker.shared.remove(this.tick, this);
   }
 

src/programs/index.ts

@@ -1,6 +1,7 @@
 import { ProgramInfo } from "../graphics/renderables/program_info";
 import { DeviceId } from "../types/graphs/datagraph";
 import { ViewGraph } from "../types/graphs/viewgraph";
+import { DummyLinkProgram } from "./dummy_link_program";
 import { EchoServer, SingleEcho } from "./echo_sender";
 import { HttpClient } from "./http_client";
 
@@ -64,7 +65,7 @@ type ProgramConstructor = new (
 // - Have a static readonly PROGRAM_NAME property
 // - Have a constructor with the signature (viewgraph, srcId, inputs)
 // - Have a getProgramInfo static method
-const programList = [SingleEcho, EchoServer, HttpClient];
+const programList = [SingleEcho, EchoServer, HttpClient, DummyLinkProgram];
 
 // Map of program name to program constructor
 const programMap = new Map<string, ProgramConstructor>(

src/types/data-devices/dDevice.ts

@@ -1,15 +1,8 @@
 import { EthernetFrame, MacAddress } from "../../packets/ethernet";
-import { DataGraph, DataNode } from "../graphs/datagraph";
-import { DeviceType } from "../view-devices/vDevice";
+import { DataGraph, DataNode, DeviceId } from "../graphs/datagraph";
+import { DeviceType, NetworkInterface } from "../view-devices/vDevice";
 import { Position } from "../common";
 
-interface NetworkInterface {
-  name: string;
-  mac: MacAddress;
-  // TODO: add IP address
-  // ip?: string;
-}
-
 export abstract class DataDevice {
   private static idCounter = 1;
 
@@ -73,5 +66,5 @@ export abstract class DataDevice {
    * Returns the id for the next device to send the packet to, or
    * null if there’s no next device to send the packet.
    * */
-  abstract receiveFrame(frame: EthernetFrame): void;
+  abstract receiveFrame(frame: EthernetFrame, senderId: DeviceId): void;
 }

src/types/data-devices/dSwitch.ts

@@ -1,14 +1,51 @@
 import { DeviceType } from "../view-devices/vDevice";
 import { DataDevice } from "./dDevice";
-import { EthernetFrame } from "../../packets/ethernet";
+import { EthernetFrame, MacAddress } from "../../packets/ethernet";
+import { DataGraph, DeviceId, SwitchDataNode } from "../graphs/datagraph";
 
 export class DataSwitch extends DataDevice {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  receiveFrame(frame: EthernetFrame): void {
-    // TODO: this is unused
+  //                      would be interface
+  switchingTable: Map<string, DeviceId> = new Map<string, DeviceId>();
+
+  constructor(graphData: SwitchDataNode, datagraph: DataGraph) {
+    super(graphData, datagraph);
+    this.switchingTable = new Map<string, number>(graphData.switchingTable);
   }
 
   getType(): DeviceType {
     return DeviceType.Switch;
   }
+
+  updateSwitchingTable(mac: MacAddress, deviceId: DeviceId): void {
+    if (!this.switchingTable.has(mac.toString())) {
+      console.debug(`Adding ${mac.toString()} to the switching table`);
+      this.switchingTable.set(mac.toString(), deviceId);
+    }
+  }
+
+  getDataNode(): SwitchDataNode {
+    return {
+      ...super.getDataNode(),
+      switchingTable: Array.from(this.switchingTable.entries()),
+      type: DeviceType.Switch,
+    };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private forwardFrame(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    frame: EthernetFrame,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    nextHopId: DeviceId, // will be the interface where to send the packet
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    senderId: DeviceId, // will be the interface where the packet came from
+  ) {
+    // TODO: this is unused
+  }
+
+  // TODO: change all related senderId features to the receiver interface
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  receiveFrame(_frame: EthernetFrame, _senderId: DeviceId): void {
+    // TODO: this is unused
+  }
 }

src/types/edge.ts

@@ -8,11 +8,6 @@ import { Packet } from "./packet";
 import { EdgeInfo } from "../graphics/renderables/edge_info";
 import { DataEdge, DeviceId } from "./graphs/datagraph";
 
-export interface EdgeEdges {
-  n1: DeviceId;
-  n2: DeviceId;
-}
-
 export class Edge extends Graphics {
   data: DataEdge;
   private startPos: Point;
@@ -66,6 +61,10 @@ export class Edge extends Graphics {
         : undefined;
   }
 
+  getData(): DataEdge {
+    return this.data;
+  }
+
   // Method to draw the line
   drawEdge(startPos: Point, endPos: Point, color: number) {
     this.clear();

src/types/graphs/datagraph.ts

@@ -34,7 +34,7 @@ interface CommonDataNode {
   // TODO: remove this
   mac: string;
   interfaces: NetworkInterfaceData[];
-  arpTable?: Map<string, string>;
+  arpTable?: [string, string][];
 }
 
 export interface NetworkInterfaceData {
@@ -48,6 +48,7 @@ export interface NetworkInterfaceData {
 }
 
 export interface SwitchDataNode extends CommonDataNode {
+  switchingTable: [string, number][];
   type: DeviceType.Switch;
 }
 
@@ -67,7 +68,7 @@ export interface RouterDataNode extends NetworkDataNode {
 export interface RoutingTableEntry {
   ip: string;
   mask: string;
-  iface: DeviceId;
+  iface: number;
   manuallyEdited?: boolean;
   deleted?: boolean;
 }
@@ -150,7 +151,6 @@ export class DataGraph {
 
     // Serialize nodes
     for (const [, device] of this.deviceGraph.getAllVertices()) {
-      device.getDataNode();
       // parse to serializable format
       const dataNode: DataNode = device.getDataNode();
       nodes.push(dataNode);
@@ -250,7 +250,7 @@ export class DataGraph {
       showWarning(ALERT_MESSAGES.NO_FREE_INTERFACES(unavailableDevices));
       return null;
     }
-    const edge = {
+    const edge: DataEdge = {
       from: { id: n1Id, iface: n1Iface },
       to: { id: n2Id, iface: n2Iface },
     };

src/types/packet.ts

@@ -184,7 +184,7 @@ export class Packet extends Graphics {
     if (!newStartDevice) {
       return;
     }
-    newStartDevice.receiveFrame(this.rawPacket);
+    newStartDevice.receiveFrame(this.rawPacket, this.currStart);
   }
 
   traverseEdge(startId: DeviceId, endId: DeviceId): void {
@@ -316,10 +316,13 @@ export class Packet extends Graphics {
   }
 }
 
+// TODO: Replace and nextHopId with the sending interface. Like this, the function
+//       can manage to send the packet to each one of the interface connection.
 export function sendViewPacket(
   viewgraph: ViewGraph,
   srcId: DeviceId,
   rawPacket: EthernetFrame,
+  nextHopId?: DeviceId,
 ) {
   const srcMac = rawPacket.source;
   const dstMac = rawPacket.destination;
@@ -353,7 +356,7 @@ export function sendViewPacket(
     return;
   }
   const packet = new Packet(viewgraph.ctx, viewgraph, rawPacket);
-  packet.traverseEdge(srcId, firstEdge.otherEnd(srcId));
+  packet.traverseEdge(srcId, nextHopId ? nextHopId : firstEdge.otherEnd(srcId));
 }
 
 export function dropPacket(

src/types/view-devices/utils.ts

@@ -33,30 +33,34 @@ export function createViewDevice(
     packetQueueSize = deviceInfo.packetQueueSize;
     timePerByte = deviceInfo.timePerByte;
   }
+  const { id, interfaces } = deviceInfo;
+
   switch (deviceInfo.type) {
     case DeviceType.Router:
       return new ViewRouter(
-        deviceInfo.id,
+        id,
         viewgraph,
         ctx,
         position,
         mac,
+        interfaces,
         ip,
         mask,
         packetQueueSize,
         timePerByte,
       );
     case DeviceType.Host:
       return new ViewHost(
-        deviceInfo.id,
+        id,
         viewgraph,
         ctx,
         position,
         mac,
+        interfaces,
         ip,
         mask,
       );
     case DeviceType.Switch:
-      return new ViewSwitch(deviceInfo.id, viewgraph, ctx, position, mac);
+      return new ViewSwitch(id, viewgraph, ctx, position, mac, interfaces);
   }
 }