Move ARP and TFTP to their own namespaces

src/main.cpp

@@ -382,14 +382,14 @@ void updateNetwork()
 	static bool announcementSent = false;
 	if (!announcementSent)
 	{
-		SendArpAnnouncement(GetMacAddress(), Ipv4Address);
+		Net::Arp::SendAnnouncement(GetMacAddress(), Ipv4Address);
 		announcementSent = true;
 	}
 
 	switch (ethernetHeader.type)
 	{
 	case ETHERTYPE_ARP:
-		HandleArpFrame(ethernetHeader, ipBuffer + offset);
+		Net::Arp::HandlePacket(ethernetHeader, ipBuffer + offset);
 		break;
 	case ETHERTYPE_IPV4:
 		HandleIpv4Packet(ethernetHeader, ipBuffer + offset, sizeof(ipBuffer) - offset);

src/net-arp.cpp

@@ -1,18 +1,24 @@
 #include "net-arp.h"
+#include "net-ethernet.h"
 
-Ipv4ArpPacket::Ipv4ArpPacket()
+#include "types.h"
-{}
+#include <uspi.h>
 
-Ipv4ArpPacket::Ipv4ArpPacket(std::uint16_t operation) :
+namespace Net::Arp
+{
+    Ipv4ArpPacket::Ipv4ArpPacket()
+    {}
+
+    Ipv4ArpPacket::Ipv4ArpPacket(std::uint16_t operation) :
         hardwareType(1), // Ethernet
         protocolType(ETHERTYPE_IPV4), // IPv4
         hardwareAddressLength(6),
         protocolAddressLength(4),
         operation(operation)
-{}
+    {}
 
-std::size_t Ipv4ArpPacket::Serialize(std::uint8_t* buffer)
+    std::size_t Ipv4ArpPacket::Serialize(std::uint8_t* buffer)
-{
+    {
         buffer[0] = hardwareType >> 8;
         buffer[1] = hardwareType;
         buffer[2] = protocolType >> 8;
@@ -37,11 +43,11 @@ std::size_t Ipv4ArpPacket::Serialize(std::uint8_t* buffer)
         buffer[27] = targetIp;
 
         return 28;
-}
+    }
 
-// Static
+    // Static
-Ipv4ArpPacket Ipv4ArpPacket::Deserialize(const uint8_t* buffer)
+    Ipv4ArpPacket Ipv4ArpPacket::Deserialize(const uint8_t* buffer)
-{
+    {
         Ipv4ArpPacket self;
 
         self.hardwareType = buffer[0] << 8 | buffer[1];
@@ -58,4 +64,71 @@ Ipv4ArpPacket Ipv4ArpPacket::Deserialize(const uint8_t* buffer)
             buffer[24] << 24 | buffer[25] << 16 | buffer[26] << 8 | buffer[27];
 
         return self;
-}
+    }
+
+    void SendPacket(
+        ArpOperation operation,
+        MacAddress targetMac,
+        MacAddress senderMac,
+        uint32_t targetIp,
+        uint32_t senderIp)
+    {
+        Ipv4ArpPacket arpPacket(operation);
+        arpPacket.targetMac = targetMac;
+        arpPacket.senderMac = senderMac;
+        arpPacket.targetIp = targetIp;
+        arpPacket.senderIp = senderIp;
+
+        EthernetFrameHeader ethernetHeader(senderMac, targetMac, ETHERTYPE_ARP);
+
+        uint8_t buffer[USPI_FRAME_BUFFER_SIZE];
+        size_t size = 0;
+        size += ethernetHeader.Serialize(buffer + size);
+        size += arpPacket.Serialize(buffer + size);
+        USPiSendFrame(buffer, size);
+    }
+
+    void SendRequest(
+        MacAddress targetMac, MacAddress senderMac, uint32_t targetIp, uint32_t senderIp)
+    {
+        SendPacket(ARP_OPERATION_REQUEST, targetMac, senderMac, targetIp, senderIp);
+    }
+
+    void SendReply(
+        MacAddress targetMac, MacAddress senderMac, uint32_t targetIp, uint32_t senderIp)
+    {
+        SendPacket(ARP_OPERATION_REPLY, targetMac, senderMac, targetIp, senderIp);
+    }
+
+    void SendAnnouncement(MacAddress mac, uint32_t ip)
+    {
+        SendReply(MacBroadcast, mac, ip, ip);
+    }
+
+    void HandlePacket(const EthernetFrameHeader ethernetHeader, uint8_t* buffer)
+    {
+        const auto macAddress = GetMacAddress();
+        const auto arpPacket = Ipv4ArpPacket::Deserialize(buffer);
+
+        if (
+            arpPacket.hardwareType == 1 &&
+            arpPacket.protocolType == ETHERTYPE_IPV4 &&
+            arpPacket.operation == ARP_OPERATION_REQUEST &&
+            arpPacket.targetIp == Ipv4Address)
+        {
+            SendReply(arpPacket.senderMac, macAddress, arpPacket.senderIp, Ipv4Address);
+        }
+
+        else if (
+            arpPacket.hardwareType == 1 &&
+            arpPacket.protocolType == ETHERTYPE_IPV4 &&
+            arpPacket.operation == ARP_OPERATION_REPLY &&
+            arpPacket.targetIp == Ipv4Address &&
+            arpPacket.targetMac == macAddress)
+        {
+            ArpTable.insert(std::make_pair(arpPacket.senderIp, arpPacket.senderMac));
+        }
+    }
+
+    std::unordered_map<std::uint32_t, MacAddress> ArpTable;
+}; // namespace Net::Arp

src/net-arp.h

@@ -1,8 +1,10 @@
 #pragma once
 #include "net.h"
 
-struct Ipv4ArpPacket
+namespace Net::Arp
 {
+	struct Ipv4ArpPacket
+	{
 		std::uint16_t hardwareType;
 		std::uint16_t protocolType;
 		std::uint8_t hardwareAddressLength;
@@ -34,4 +36,33 @@ struct Ipv4ArpPacket
 		std::size_t Serialize(std::uint8_t* buffer);
 
 		static Ipv4ArpPacket Deserialize(const uint8_t* buffer);
-};
+	};
+
+	void HandlePacket(EthernetFrameHeader header, uint8_t* buffer);
+
+	void SendPacket(
+		ArpOperation operation,
+		MacAddress targetMac,
+		MacAddress senderMac,
+		uint32_t senderIp,
+		uint32_t targetIp
+	);
+
+	void SendRequest(
+		MacAddress targetMac,
+		MacAddress senderMac,
+		uint32_t senderIp,
+		uint32_t targetIp
+	);
+
+	void SendReply(
+		MacAddress targetMac,
+		MacAddress senderMac,
+		uint32_t senderIp,
+		uint32_t targetIp
+	);
+
+	void SendAnnouncement(MacAddress mac, uint32_t ip);
+
+	extern std::unordered_map<std::uint32_t, MacAddress> ArpTable;
+}; // namespace Net::Arp

src/net-tftp.cpp

@@ -1,22 +1,25 @@
 #include <memory>
 
 #include "ff.h"
+#include "net-arp.h"
 #include "net-ethernet.h"
 #include "net-ipv4.h"
 #include "net-tftp.h"
 #include "net-udp.h"
 #include "net.h"
-#include "types.h"
 
+#include "types.h"
 #include <uspi.h>
 
-// TODO Allow multiple files open
+namespace Net::Tftp
-static FIL outFile;
-static bool shouldReboot = false;
-static uint32_t currentBlockNumber = -1;
-
-static std::unique_ptr<TftpPacket> handleTftpWriteRequest(const uint8_t* data)
 {
+	// TODO Allow multiple files open
+	static FIL outFile;
+	static bool shouldReboot = false;
+	static uint32_t currentBlockNumber = -1;
+
+	static std::unique_ptr<TftpPacket> handleTftpWriteRequest(const uint8_t* data)
+	{
 		auto packet = TftpWriteReadRequestPacket::Deserialize(data);
 
 		// TODO Implement netscii, maybe
@@ -69,10 +72,10 @@ static std::unique_ptr<TftpPacket> handleTftpWriteRequest(const uint8_t* data)
 		// TODO Return to the original working directory here
 
 		return response;
-}
+	}
 
-static std::unique_ptr<TftpPacket> handleTftpData(const uint8_t* buffer, size_t size)
+	static std::unique_ptr<TftpPacket> handleTftpData(const uint8_t* buffer, size_t size)
-{
+	{
 		TftpDataPacket packet;
 		const auto tftpSize = TftpDataPacket::Deserialize(packet, buffer, size);
 		if (size == 0)
@@ -109,23 +112,23 @@ static std::unique_ptr<TftpPacket> handleTftpData(const uint8_t* buffer, size_t
 		return std::unique_ptr<TftpAcknowledgementPacket>(
 			new TftpAcknowledgementPacket(currentBlockNumber)
 		);
-}
+	}
 
-void HandleTftpDatagram(
+	void HandleTftpDatagram(
 		const EthernetFrameHeader ethernetReqHeader,
 		const Ipv4Header ipv4ReqHeader,
 		const UdpDatagramHeader udpReqHeader,
 		const uint8_t* data
-) {
+	) {
-	const auto opcode = data[0] << 8 | data[1];
+		const auto opcode = static_cast<Opcode>(data[0] << 8 | data[1]);
 		std::unique_ptr<TftpPacket> response;
 		bool last = false;
 
-	if (opcode == TFTP_OP_WRITE_REQUEST)
+		if (opcode == Opcode::WriteRequest)
 		{
 			response = handleTftpWriteRequest(data);
 		}
-	else if (opcode == TFTP_OP_DATA)
+		else if (opcode == Opcode::Data)
 		{
 			const auto length = udpReqHeader.length - UdpDatagramHeader::SerializedLength();
 			response = handleTftpData(data, length);
@@ -151,7 +154,7 @@ void HandleTftpDatagram(
 				udpRespHeader.length + Ipv4Header::SerializedLength()
 			);
 			EthernetFrameHeader ethernetRespHeader(
-			ArpTable[ipv4RespHeader.destinationIp],
+				Net::Arp::ArpTable[ipv4RespHeader.destinationIp],
 				GetMacAddress(),
 				ETHERTYPE_IPV4
 			);
@@ -171,25 +174,25 @@ void HandleTftpDatagram(
 			extern void Reboot_Pi();
 			Reboot_Pi();
 		}
-}
+	}
 
-//
+	//
-// TftpWriteReadRequestPacket
+	// TftpWriteReadRequestPacket
-//
+	//
-TftpWriteReadRequestPacket::TftpWriteReadRequestPacket(uint16_t opcode) :
+	TftpWriteReadRequestPacket::TftpWriteReadRequestPacket(const Opcode opcode) :
 		TftpPacket(opcode)
-{}
+	{}
 
-size_t TftpWriteReadRequestPacket::SerializedLength() const
+	size_t TftpWriteReadRequestPacket::SerializedLength() const
-{
+	{
 		return TftpPacket::SerializedLength() + filename.size() + 1 + mode.size() + 1;
-}
+	}
 
-size_t TftpWriteReadRequestPacket::Serialize(uint8_t* buffer) const
+	size_t TftpWriteReadRequestPacket::Serialize(uint8_t* buffer) const
-{
+	{
 		size_t i = 0;
-	buffer[i++] = opcode >> 8;
+		buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
-	buffer[i++] = opcode;
+		buffer[i++] = static_cast<uint16_t>(opcode);
 
 		i += filename.copy(reinterpret_cast<char*>(buffer + i), filename.size());
 		buffer[i++] = 0;
@@ -198,13 +201,14 @@ size_t TftpWriteReadRequestPacket::Serialize(uint8_t* buffer) const
 		buffer[i++] = 0;
 
 		return i;
-}
+	}
 
-TftpWriteReadRequestPacket TftpWriteReadRequestPacket::Deserialize(const uint8_t* buffer)
+	TftpWriteReadRequestPacket TftpWriteReadRequestPacket::Deserialize(const uint8_t* buffer)
-{
+	{
 		size_t i = 0;
 
-	TftpWriteReadRequestPacket self(buffer[i] << 8 | buffer[i + 1]);
+		const auto opcode = static_cast<Opcode>(buffer[i] << 8 | buffer[i + 1]);
+		TftpWriteReadRequestPacket self(opcode);
 		i += 2;
 
 		self.filename = reinterpret_cast<const char*>(buffer + i);
@@ -214,26 +218,26 @@ TftpWriteReadRequestPacket TftpWriteReadRequestPacket::Deserialize(const uint8_t
 		i += self.mode.size() + 1;
 
 		return self;
-}
+	}
 
-//
+	//
-// TftpErrorPacket
+	// TftpErrorPacket
-//
+	//
-TftpErrorPacket::TftpErrorPacket() : TftpPacket(TFTP_OP_ERROR) {}
+	TftpErrorPacket::TftpErrorPacket() : TftpPacket(Opcode::Error) {}
-TftpErrorPacket::TftpErrorPacket(uint16_t errorCode, std::string message) :
+	TftpErrorPacket::TftpErrorPacket(uint16_t errorCode, std::string message) :
-	TftpPacket(TFTP_OP_ERROR), errorCode(errorCode), message(message)
+		TftpPacket(Opcode::Error), errorCode(errorCode), message(message)
-{}
+	{}
 
-size_t TftpErrorPacket::SerializedLength() const
+	size_t TftpErrorPacket::SerializedLength() const
-{
+	{
 		return TftpPacket::SerializedLength() + sizeof(errorCode) + message.size() + 1;
-}
+	}
 
-size_t TftpErrorPacket::Serialize(uint8_t* buffer) const
+	size_t TftpErrorPacket::Serialize(uint8_t* buffer) const
-{
+	{
 		size_t i = 0;
-	buffer[i++] = opcode >> 8;
+		buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
-	buffer[i++] = opcode;
+		buffer[i++] = static_cast<uint16_t>(opcode);
 		buffer[i++] = errorCode >> 8;
 		buffer[i++] = errorCode;
 
@@ -241,48 +245,64 @@ size_t TftpErrorPacket::Serialize(uint8_t* buffer) const
 		buffer[i++] = 0;
 
 		return i;
-}
+	}
 
-//
+	//
-// TftpAcknowledgementPacket
+	// TftpAcknowledgementPacket
-//
+	//
-TftpAcknowledgementPacket::TftpAcknowledgementPacket() :
+	TftpAcknowledgementPacket::TftpAcknowledgementPacket() :
-	TftpPacket(TFTP_OP_ACKNOWLEDGEMENT)
+		TftpPacket(Opcode::Acknowledgement)
-{}
+	{}
 
-TftpAcknowledgementPacket::TftpAcknowledgementPacket(uint16_t blockNumber) :
+	TftpAcknowledgementPacket::TftpAcknowledgementPacket(uint16_t blockNumber) :
-	TftpPacket(TFTP_OP_ACKNOWLEDGEMENT), blockNumber(blockNumber)
+		TftpPacket(Opcode::Acknowledgement), blockNumber(blockNumber)
-{}
+	{}
 
-size_t TftpAcknowledgementPacket::SerializedLength() const
+	size_t TftpAcknowledgementPacket::SerializedLength() const
-{
+	{
 		return TftpPacket::SerializedLength() + sizeof(blockNumber);
-}
+	}
 
-size_t TftpAcknowledgementPacket::Serialize(uint8_t* buffer) const
+	size_t TftpAcknowledgementPacket::Serialize(uint8_t* buffer) const
-{
+	{
 		size_t i = 0;
-	buffer[i++] = opcode >> 8;
+		buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
-	buffer[i++] = opcode;
+		buffer[i++] = static_cast<uint16_t>(opcode);
 		buffer[i++] = blockNumber >> 8;
 		buffer[i++] = blockNumber;
 		return i;
-}
+	}
 
-//
+	//
-// TftpDataPacket
+	// TftpDataPacket
-//
+	//
-TftpDataPacket::TftpDataPacket() : opcode(TFTP_OP_DATA) {}
+	TftpDataPacket::TftpDataPacket() : TftpPacket(Opcode::Data), blockNumber(0)
+	{}
 
-size_t TftpDataPacket::Deserialize(
+	size_t TftpDataPacket::Serialize(uint8_t* buffer) const
+	{
+		size_t i = 0;
+		buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
+		buffer[i++] = static_cast<uint16_t>(opcode);
+		buffer[i++] = blockNumber >> 8;
+		buffer[i++] = blockNumber;
+
+		std::memcpy(buffer + i, data.data(), data.size());
+		i += data.size();
+
+		return i;
+	}
+
+	size_t TftpDataPacket::Deserialize(
 		TftpDataPacket& out, const uint8_t* buffer, size_t size
-) {
+	) {
 		if (size < sizeof(opcode) + sizeof(blockNumber)) {
 			return 0;
 		}
 
-	out.opcode = buffer[0] << 8 | buffer[1];
+		out.opcode = static_cast<Opcode>(buffer[0] << 8 | buffer[1]);
 		out.blockNumber = buffer[2] << 8 | buffer[3];
 		out.data = std::vector<uint8_t>(buffer + 4, buffer + size);
 		return size;
-}
+	}
+}; // namespace Net::Tftp

src/net-tftp.h

@@ -1,43 +1,44 @@
 #pragma once
 #include <vector>
 
-const size_t TFTP_BLOCK_SIZE = 512;
+namespace Net::Tftp {
+	const size_t TFTP_BLOCK_SIZE = 512;
 
-enum TftpOperation
+	enum class Opcode : uint16_t
-{
+	{
-	TFTP_OP_READ_REQUEST = 1,
+		ReadRequest = 1,
-	TFTP_OP_WRITE_REQUEST = 2,
+		WriteRequest = 2,
-	TFTP_OP_DATA = 3,
+		Data = 3,
-	TFTP_OP_ACKNOWLEDGEMENT = 4,
+		Acknowledgement = 4,
-	TFTP_OP_ERROR = 5,
+		Error = 5,
-};
+	};
 
-struct TftpPacket
+	struct TftpPacket
-{
+	{
-	uint16_t opcode;
+		Opcode opcode;
 
-	TftpPacket(uint16_t opcode) : opcode(opcode) {}
+		TftpPacket(Opcode opcode) : opcode(opcode) {}
 
 		virtual size_t SerializedLength() const {
 			return sizeof(opcode);
 		}
 
 		virtual size_t Serialize(uint8_t* buffer) const = 0;
-};
+	};
 
-struct TftpWriteReadRequestPacket : public TftpPacket
+	struct TftpWriteReadRequestPacket : public TftpPacket
-{
+	{
 		std::string filename;
 		std::string mode;
 
-	TftpWriteReadRequestPacket(uint16_t opcode);
+		TftpWriteReadRequestPacket(const Opcode opcode);
 		size_t SerializedLength() const override;
 		size_t Serialize(uint8_t* buffer) const override;
 		static TftpWriteReadRequestPacket Deserialize(const uint8_t* buffer);
-};
+	};
 
-struct TftpErrorPacket : public TftpPacket
+	struct TftpErrorPacket : public TftpPacket
-{
+	{
 		uint16_t errorCode;
 		std::string message;
 
@@ -45,25 +46,33 @@ struct TftpErrorPacket : public TftpPacket
 		TftpErrorPacket(uint16_t errorCode, std::string message);
 		size_t SerializedLength() const override;
 		size_t Serialize(uint8_t* buffer) const override;
-};
+	};
 
-struct TftpAcknowledgementPacket : public TftpPacket
+	struct TftpAcknowledgementPacket : public TftpPacket
-{
+	{
 		uint16_t blockNumber;
 
 		TftpAcknowledgementPacket();
 		TftpAcknowledgementPacket(uint16_t blockNumber);
 		size_t SerializedLength() const override;
 		size_t Serialize(uint8_t* buffer) const override;
-};
+	};
 
-struct TftpDataPacket
+	struct TftpDataPacket : public TftpPacket
-{
+	{
-	uint16_t opcode;
 		uint16_t blockNumber;
 		std::vector<uint8_t> data;
 
 		TftpDataPacket();
+		size_t Serialize(uint8_t* buffer) const override;
 		static size_t Deserialize(
 			TftpDataPacket& out, const uint8_t* buffer, size_t length);
-};
+	};
+
+	void HandleTftpDatagram(
+		const EthernetFrameHeader ethernetReqHeader,
+		const Ipv4Header ipv4ReqHeader,
+		const UdpDatagramHeader udpReqHeader,
+		const uint8_t* buffer
+	);
+}; // namespace Net::Tftp

src/net.cpp

@@ -7,79 +7,13 @@
 #include "net-ipv4.h"
 #include "net-udp.h"
 #include "net-dhcp.h"
+#include "net-tftp.h"
 #include "net.h"
 #include "types.h"
 
 #include <uspi.h>
 #include <uspios.h>
 
-//
-// ARP
-//
-void SendArpPacket(
-	ArpOperation operation,
-	MacAddress targetMac,
-	MacAddress senderMac,
-	uint32_t targetIp,
-	uint32_t senderIp)
-{
-	Ipv4ArpPacket arpPacket(operation);
-	arpPacket.targetMac = targetMac;
-	arpPacket.senderMac = senderMac;
-	arpPacket.targetIp = targetIp;
-	arpPacket.senderIp = senderIp;
-
-	EthernetFrameHeader ethernetHeader(senderMac, targetMac, ETHERTYPE_ARP);
-
-	uint8_t buffer[USPI_FRAME_BUFFER_SIZE];
-	size_t size = 0;
-	size += ethernetHeader.Serialize(buffer + size);
-	size += arpPacket.Serialize(buffer + size);
-	USPiSendFrame(buffer, size);
-}
-
-void SendArpRequest(
-	MacAddress targetMac, MacAddress senderMac, uint32_t targetIp, uint32_t senderIp)
-{
-	SendArpPacket(ARP_OPERATION_REQUEST, targetMac, senderMac, targetIp, senderIp);
-}
-
-void SendArpReply(
-	MacAddress targetMac, MacAddress senderMac, uint32_t targetIp, uint32_t senderIp)
-{
-	SendArpPacket(ARP_OPERATION_REPLY, targetMac, senderMac, targetIp, senderIp);
-}
-
-void SendArpAnnouncement(MacAddress mac, uint32_t ip)
-{
-	SendArpReply(MacBroadcast, mac, ip, ip);
-}
-
-void HandleArpFrame(const EthernetFrameHeader ethernetHeader, uint8_t* buffer)
-{
-	const auto macAddress = GetMacAddress();
-	const auto arpPacket = Ipv4ArpPacket::Deserialize(buffer);
-
-	if (
-		arpPacket.hardwareType == 1 &&
-		arpPacket.protocolType == ETHERTYPE_IPV4 &&
-		arpPacket.operation == ARP_OPERATION_REQUEST &&
-		arpPacket.targetIp == Ipv4Address)
-	{
-		SendArpReply(arpPacket.senderMac, macAddress, arpPacket.senderIp, Ipv4Address);
-	}
-
-	else if (
-		arpPacket.hardwareType == 1 &&
-		arpPacket.protocolType == ETHERTYPE_IPV4 &&
-		arpPacket.operation == ARP_OPERATION_REPLY &&
-		arpPacket.targetIp == Ipv4Address &&
-		arpPacket.targetMac == macAddress)
-	{
-		ArpTable.insert(std::make_pair(arpPacket.senderIp, arpPacket.senderMac));
-	}
-}
-
 //
 // IPv4
 //
@@ -90,7 +24,8 @@ void HandleIpv4Packet(
 	const auto offset = Ipv4Header::SerializedLength();
 
 	// Update ARP table
-	ArpTable.insert(std::make_pair(ipv4Header.sourceIp, ethernetHeader.macSource));
+	Net::Arp::ArpTable.insert(
+		std::make_pair(ipv4Header.sourceIp, ethernetHeader.macSource));
 
 	if (ipv4Header.version != 4) return;
 	if (ipv4Header.ihl != 5) return; // Not supported
@@ -128,7 +63,7 @@ void HandleUdpDatagram(
 	}
 	else if (udpHeader.destinationPort == UDP_PORT_TFTP)
 	{
-		HandleTftpDatagram(
+		Net::Tftp::HandleTftpDatagram(
 			ethernetHeader,
 			ipv4Header,
 			udpHeader,
@@ -326,4 +261,3 @@ uint32_t Ipv4Address = 0xC0A80164;
 const MacAddress MacBroadcast{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
 bool FileUploaded = false;
-std::unordered_map<std::uint32_t, MacAddress> ArpTable;

src/net.h

@@ -27,23 +27,6 @@ struct EthernetFrameHeader;
 struct UdpDatagramHeader;
 struct Ipv4Header;
 
-//
-// ARP
-//
-void HandleArpFrame(EthernetFrameHeader header, uint8_t* buffer);
-void SendArpPacket(
-	ArpOperation operation,
-	MacAddress targetMac,
-	MacAddress senderMac,
-	uint32_t senderIp,
-	uint32_t targetIp
-);
-void SendArpRequest(
-	MacAddress targetMac, MacAddress senderMac, uint32_t senderIp, uint32_t targetIp);
-void SendArpReply(
-	MacAddress targetMac, MacAddress senderMac, uint32_t senderIp, uint32_t targetIp);
-void SendArpAnnouncement(MacAddress mac, uint32_t ip);
-
 //
 // IPv4
 //
@@ -60,13 +43,6 @@ void HandleUdpDatagram(
 	const size_t size
 );
 
-void HandleTftpDatagram(
-	const EthernetFrameHeader ethernetReqHeader,
-	const Ipv4Header ipv4ReqHeader,
-	const UdpDatagramHeader udpReqHeader,
-	const uint8_t* buffer
-);
-
 //
 // ICMP
 //
@@ -84,4 +60,3 @@ extern const MacAddress MacBroadcast;
 extern uint32_t Ipv4Address;
 
 extern bool FileUploaded;
-extern std::unordered_map<std::uint32_t, MacAddress> ArpTable;