c64
/
pi1541
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move ARP and TFTP to their own namespaces

This commit is contained in:
Sijmen 2020-12-27 22:17:36 +01:00
parent fc39c7a99f
commit 9638a0dc3d
Signed by: vijfhoek
GPG Key ID: DAF7821E067D9C48
7 changed files with 516 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main.cpp
View File

@ -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);

95
src/net-arp.cpp
View File

@ -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
Ipv4ArpPacket Ipv4ArpPacket::Deserialize(const uint8_t* buffer)
{
// Static
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

35
src/net-arp.h
View File

@ -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

170
src/net-tftp.cpp
View File

@ -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
static FIL outFile;
static bool shouldReboot = false;
static uint32_t currentBlockNumber = -1;
static std::unique_ptr<TftpPacket> handleTftpWriteRequest(const uint8_t* data)
namespace Net::Tftp
{
// 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(uint16_t opcode) :
//
// TftpWriteReadRequestPacket
//
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++] = opcode;
buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
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() : TftpPacket(TFTP_OP_ERROR) {}
TftpErrorPacket::TftpErrorPacket(uint16_t errorCode, std::string message) :
TftpPacket(TFTP_OP_ERROR), errorCode(errorCode), message(message)
{}
//
// TftpErrorPacket
//
TftpErrorPacket::TftpErrorPacket() : TftpPacket(Opcode::Error) {}
TftpErrorPacket::TftpErrorPacket(uint16_t errorCode, std::string 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++] = opcode;
buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
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() :
TftpPacket(TFTP_OP_ACKNOWLEDGEMENT)
{}
//
// TftpAcknowledgementPacket
//
TftpAcknowledgementPacket::TftpAcknowledgementPacket() :
TftpPacket(Opcode::Acknowledgement)
{}
TftpAcknowledgementPacket::TftpAcknowledgementPacket(uint16_t blockNumber) :
TftpPacket(TFTP_OP_ACKNOWLEDGEMENT), blockNumber(blockNumber)
{}
TftpAcknowledgementPacket::TftpAcknowledgementPacket(uint16_t 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++] = opcode;
buffer[i++] = static_cast<uint16_t>(opcode) >> 8;
buffer[i++] = static_cast<uint16_t>(opcode);
buffer[i++] = blockNumber >> 8;
buffer[i++] = blockNumber;
return i;
}
}
//
// TftpDataPacket
//
TftpDataPacket::TftpDataPacket() : opcode(TFTP_OP_DATA) {}
//
// TftpDataPacket
//
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

65
src/net-tftp.h
View File

@ -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
{
TFTP_OP_READ_REQUEST = 1,
TFTP_OP_WRITE_REQUEST = 2,
TFTP_OP_DATA = 3,
TFTP_OP_ACKNOWLEDGEMENT = 4,
TFTP_OP_ERROR = 5,
};
enum class Opcode : uint16_t
{
ReadRequest = 1,
WriteRequest = 2,
Data = 3,
Acknowledgement = 4,
Error = 5,
};
struct TftpPacket
{
uint16_t opcode;
struct TftpPacket
{
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
{
uint16_t opcode;
struct TftpDataPacket : public TftpPacket
{
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

74
src/net.cpp
View File

@ -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;

25
src/net.h
View File

@ -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;