From 26b954fdc659419bb061f4b662913f744dea369e Mon Sep 17 00:00:00 2001 From: TheLastRar Date: Sat, 6 Mar 2021 20:27:51 +0000 Subject: [PATCH] DEV9: Add code for reading packets --- pcsx2/CMakeLists.txt | 22 + pcsx2/DEV9/PacketReader/EthernetFrame.cpp | 61 +++ pcsx2/DEV9/PacketReader/EthernetFrame.h | 55 +++ pcsx2/DEV9/PacketReader/IP/IP_Address.h | 31 ++ pcsx2/DEV9/PacketReader/IP/IP_Options.cpp | 66 +++ pcsx2/DEV9/PacketReader/IP/IP_Options.h | 80 ++++ pcsx2/DEV9/PacketReader/IP/IP_Packet.cpp | 308 ++++++++++++ pcsx2/DEV9/PacketReader/IP/IP_Packet.h | 140 ++++++ pcsx2/DEV9/PacketReader/IP/IP_Payload.h | 67 +++ .../PacketReader/IP/UDP/DHCP/DHCP_Options.cpp | 437 ++++++++++++++++++ .../PacketReader/IP/UDP/DHCP/DHCP_Options.h | 320 +++++++++++++ .../PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp | 223 +++++++++ .../PacketReader/IP/UDP/DHCP/DHCP_Packet.h | 55 +++ .../PacketReader/IP/UDP/DNS/DNS_Classes.cpp | 145 ++++++ .../PacketReader/IP/UDP/DNS/DNS_Classes.h | 60 +++ .../DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h | 43 ++ .../PacketReader/IP/UDP/DNS/DNS_Packet.cpp | 194 ++++++++ .../DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h | 81 ++++ pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.cpp | 130 ++++++ pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.h | 51 ++ pcsx2/DEV9/PacketReader/NetLib.cpp | 75 +++ pcsx2/DEV9/PacketReader/NetLib.h | 31 ++ pcsx2/DEV9/PacketReader/Payload.h | 58 +++ pcsx2/windows/VCprojects/pcsx2.vcxproj | 22 + .../windows/VCprojects/pcsx2.vcxproj.filters | 81 ++++ 25 files changed, 2836 insertions(+) create mode 100644 pcsx2/DEV9/PacketReader/EthernetFrame.cpp create mode 100644 pcsx2/DEV9/PacketReader/EthernetFrame.h create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Address.h create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Options.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Options.h create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Packet.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Packet.h create mode 100644 pcsx2/DEV9/PacketReader/IP/IP_Payload.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.cpp create mode 100644 pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.h create mode 100644 pcsx2/DEV9/PacketReader/NetLib.cpp create mode 100644 pcsx2/DEV9/PacketReader/NetLib.h create mode 100644 pcsx2/DEV9/PacketReader/Payload.h diff --git a/pcsx2/CMakeLists.txt b/pcsx2/CMakeLists.txt index da112fd9d4..44fbed8ab4 100644 --- a/pcsx2/CMakeLists.txt +++ b/pcsx2/CMakeLists.txt @@ -327,6 +327,15 @@ set(pcsx2DEV9Sources DEV9/ATA/ATA_State.cpp DEV9/ATA/ATA_Transfer.cpp DEV9/ATA/HddCreate.cpp + DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.cpp + DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp + DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.cpp + DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.cpp + DEV9/PacketReader/IP/UDP/UDP_Packet.cpp + DEV9/PacketReader/IP/IP_Options.cpp + DEV9/PacketReader/IP/IP_Packet.cpp + DEV9/PacketReader/EthernetFrame.cpp + DEV9/PacketReader/NetLib.cpp DEV9/smap.cpp DEV9/DEV9.cpp DEV9/flash.cpp @@ -343,6 +352,19 @@ set(pcsx2DEV9Headers DEV9/ATA/HddCreate.h DEV9/DEV9.h DEV9/net.h + DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.h + DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.h + DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.h + DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h + DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h + DEV9/PacketReader/IP/UDP/UDP_Packet.h + DEV9/PacketReader/IP/IP_Address.h + DEV9/PacketReader/IP/IP_Options.h + DEV9/PacketReader/IP/IP_Packet.h + DEV9/PacketReader/IP/IP_Payload.h + DEV9/PacketReader/EthernetFrame.h + DEV9/PacketReader/NetLib.h + DEV9/PacketReader/Payload.h DEV9/pcap_io.h DEV9/SimpleQueue.h DEV9/smap.h diff --git a/pcsx2/DEV9/PacketReader/EthernetFrame.cpp b/pcsx2/DEV9/PacketReader/EthernetFrame.cpp new file mode 100644 index 0000000000..6e13680b35 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/EthernetFrame.cpp @@ -0,0 +1,61 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "EthernetFrame.h" +#include "NetLib.h" + +namespace PacketReader +{ + EthernetFrame::EthernetFrame(Payload* data) + : payload{data} + { + } + EthernetFrame::EthernetFrame(NetPacket* pkt) + { + int offset = 0; + NetLib::ReadByteArray((u8*)pkt->buffer, &offset, 6, destinationMAC); + NetLib::ReadByteArray((u8*)pkt->buffer, &offset, 6, sourceMAC); + + headerLength = 14; //(6+6+2) + + //Note: we don't have to worry about the Ethernet Frame CRC as it is not included in the packet + + NetLib::ReadUInt16((u8*)pkt->buffer, &offset, &protocol); + + //Note: We don't support tagged frames + + payload = std::make_unique((u8*)&pkt->buffer[offset], pkt->size - headerLength); + } + + Payload* EthernetFrame::GetPayload() + { + return payload.get(); + } + + void EthernetFrame::WritePacket(NetPacket* pkt) + { + int counter = 0; + + pkt->size = headerLength + payload->GetLength(); + NetLib::WriteByteArray((u8*)pkt->buffer, &counter, 6, destinationMAC); + NetLib::WriteByteArray((u8*)pkt->buffer, &counter, 6, sourceMAC); + // + NetLib::WriteUInt16((u8*)pkt->buffer, &counter, protocol); + // + payload->WriteBytes((u8*)pkt->buffer, &counter); + } +} // namespace PacketReader diff --git a/pcsx2/DEV9/PacketReader/EthernetFrame.h b/pcsx2/DEV9/PacketReader/EthernetFrame.h new file mode 100644 index 0000000000..d8958fadaa --- /dev/null +++ b/pcsx2/DEV9/PacketReader/EthernetFrame.h @@ -0,0 +1,55 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +#include "../net.h" +#include "Payload.h" + +namespace PacketReader +{ + enum struct EtherType : u16 + { + null = 0x0000, + IPv4 = 0x0800, + ARP = 0x0806, + //Tags extend the ether header length + VlanQTag = 0x8100, + VlanServiceQTag = 0x88A8, + VlanDoubleQTag = 0x9100 + }; + + class EthernetFrame + { + public: + u8 destinationMAC[6] = {0}; + u8 sourceMAC[6] = {0}; + + u16 protocol = 0; + int headerLength = 14; + //Length + private: + std::unique_ptr payload; + + public: + //Takes ownership of payload + EthernetFrame(Payload* data); + EthernetFrame(NetPacket* pkt); + + Payload* GetPayload(); + + void WritePacket(NetPacket* pkt); + }; +} // namespace PacketReader diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Address.h b/pcsx2/DEV9/PacketReader/IP/IP_Address.h new file mode 100644 index 0000000000..b920043774 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Address.h @@ -0,0 +1,31 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader::IP +{ + struct IP_Address + { + union + { + u8 bytes[4]; + u32 integer; + }; + + bool operator==(const IP_Address& other) const { return this->integer == other.integer; } + bool operator!=(const IP_Address& other) const { return this->integer != other.integer; } + }; +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Options.cpp b/pcsx2/DEV9/PacketReader/IP/IP_Options.cpp new file mode 100644 index 0000000000..9bcc474188 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Options.cpp @@ -0,0 +1,66 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "IP_Options.h" +#include "../NetLib.h" + +namespace PacketReader::IP +{ + bool IPOption::IsCopyOnFragment() + { + return ((GetCode() & (1 << 0x7)) != 0); + } + u8 IPOption::GetClass() + { + return (GetCode() >> 5) & 0x3; + } + u8 IPOption::GetNumber() + { + return GetCode() & 0x1F; + } + + IPopUnk::IPopUnk(u8* data, int offset) + { + NetLib::ReadByte08(data, &offset, &code); + NetLib::ReadByte08(data, &offset, &length); + + value.resize(length - 2); + NetLib::ReadByteArray(data, &offset, length - 2, &value[0]); + } + void IPopUnk::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, code); + NetLib::WriteByte08(buffer, offset, length); + NetLib::WriteByteArray(buffer, offset, length - 2, &value[0]); + } + + IPopRouterAlert::IPopRouterAlert(u16 parValue) + : value{parValue} + { + } + IPopRouterAlert::IPopRouterAlert(u8* data, int offset) + { + offset += 2; + NetLib::ReadUInt16(data, &offset, &value); + } + void IPopRouterAlert::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength()); + NetLib::WriteUInt16(buffer, offset, value); + } +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Options.h b/pcsx2/DEV9/PacketReader/IP/IP_Options.h new file mode 100644 index 0000000000..0c078d776f --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Options.h @@ -0,0 +1,80 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader::IP +{ + class BaseOption + { + public: + virtual u8 GetLength() = 0; + virtual u8 GetCode() = 0; + virtual void WriteBytes(u8* buffer, int* offset) = 0; + + virtual ~BaseOption() {} + }; + + class IPOption : public BaseOption + { + public: + bool IsCopyOnFragment(); + u8 GetClass(); //0 = control, 2 = debugging and measurement + u8 GetNumber(); + }; + + class IPopUnk : public IPOption + { + u8 length; + u8 code; + std::vector value; + + public: + IPopUnk(u8* data, int offset); + + virtual u8 GetLength() { return length; } + virtual u8 GetCode() { return code; } + + void WriteBytes(u8* buffer, int* offset); + }; + + class IPopNOP : public IPOption + { + public: + virtual u8 GetLength() { return 1; } + virtual u8 GetCode() { return 1; } + + virtual void WriteBytes(u8* buffer, int* offset) + { + buffer[*offset] = GetCode(); + (*offset)++; + } + }; + + class IPopRouterAlert : public IPOption + { + //Should the router intercept packet? + public: + u16 value; + + IPopRouterAlert(u16 parValue); + IPopRouterAlert(u8* data, int offset); + + virtual u8 GetLength() { return 4; } + virtual u8 GetCode() { return 148; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Packet.cpp b/pcsx2/DEV9/PacketReader/IP/IP_Packet.cpp new file mode 100644 index 0000000000..65a2724337 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Packet.cpp @@ -0,0 +1,308 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "IP_Packet.h" +#include "../NetLib.h" + +namespace PacketReader::IP +{ + u8 IP_Packet::GetDscpValue() + { + return (dscp >> 2) & 0x3F; + } + void IP_Packet::GetDscpValue(u8 value) + { + dscp = (dscp & ~(0x3F << 2)) | ((value & 0x3F) << 2); + } + + u8 IP_Packet::GetDscpECN() + { + return dscp & 0x3; + } + void IP_Packet::SetDscpECN(u8 value) + { + dscp = (dscp & ~0x3) | (value & 0x3); + } + + bool IP_Packet::GetDoNotFragment() + { + return (fragmentFlags1 & (1 << 6)) != 0; + } + void IP_Packet::SetDoNotFragment(bool value) + { + fragmentFlags1 = (fragmentFlags1 & ~(0x1 << 6)) | ((value & 0x1) << 6); + } + + bool IP_Packet::GetMoreFragments() + { + return (fragmentFlags1 & (1 << 5)) != 0; + } + void IP_Packet::SetMoreFragments(bool value) + { + fragmentFlags1 = (fragmentFlags1 & ~(0x1 << 5)) | ((value & 0x1) << 5); + } + + u16 IP_Packet::GetFragmentOffset() + { + int x = 0; + u8 fF1masked = fragmentFlags1 & 0x1F; + u8 data[2] = {fF1masked, fragmentFlags2}; + u16 offset; + NetLib::ReadUInt16(data, &x, &offset); + return offset; + } + + IP_Packet::IP_Packet(IP_Payload* data) + : protocol{data->GetProtocol()} + , payload{data} + { + } + + IP_Packet::IP_Packet(u8* buffer, int bufferSize, bool fromICMP) + { + int offset = 0; + + //Bits 0-31 + u8 v_hl; + NetLib::ReadByte08(buffer, &offset, &v_hl); + headerLength = ((v_hl & 0xF) << 2); + NetLib::ReadByte08(buffer, &offset, &dscp); + + u16 length; + NetLib::ReadUInt16(buffer, &offset, &length); + if (length > bufferSize) + { + if (!fromICMP) + Console.Error("DEV9: IP_Packet: Unexpected Length"); + length = (u16)bufferSize; + } + + //Bits 32-63 + NetLib::ReadUInt16(buffer, &offset, &id); //Send packets with unique IDs + NetLib::ReadByte08(buffer, &offset, &fragmentFlags1); + NetLib::ReadByte08(buffer, &offset, &fragmentFlags2); + + //Bits 64-95 + NetLib::ReadByte08(buffer, &offset, &timeToLive); + NetLib::ReadByte08(buffer, &offset, &protocol); + NetLib::ReadUInt16(buffer, &offset, &checksum); + + //Bits 96-127 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&sourceIP); + //Bits 128-159 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&destinationIP); + + //Bits 160+ + if (headerLength > 20) //IP options (if any) + { + bool opReadFin = false; + do + { + u8 opKind = buffer[offset]; + u8 opLen = buffer[offset + 1]; + switch (opKind) + { + case 0: + opReadFin = true; + break; + case 1: + options.push_back(new IPopNOP()); + offset += 1; + continue; + case 148: + options.push_back(new IPopRouterAlert(buffer, offset)); + break; + default: + Console.Error("DEV9: IP_Packet: Got Unknown IP Option %d with len %d", opKind, opLen); + options.push_back(new IPopUnk(buffer, offset)); + break; + } + offset += opLen; + if (offset == headerLength) + opReadFin = true; + } while (opReadFin == false); + } + offset = headerLength; + + payload = std::make_unique(&buffer[offset], length - offset, protocol); + } + + IP_Payload* IP_Packet::GetPayload() + { + return payload.get(); + } + + int IP_Packet::GetLength() + { + ReComputeHeaderLen(); + return headerLength + payload->GetLength(); + } + + void IP_Packet::WriteBytes(u8* buffer, int* offset) + { + int startOff = *offset; + CalculateChecksum(); //ReComputeHeaderLen called in CalculateChecksum + payload->CalculateChecksum(sourceIP, destinationIP); + + NetLib::WriteByte08(buffer, offset, (_verHi + (headerLength >> 2))); + NetLib::WriteByte08(buffer, offset, dscp); //DSCP/ECN + NetLib::WriteUInt16(buffer, offset, GetLength()); + + NetLib::WriteUInt16(buffer, offset, id); + NetLib::WriteByte08(buffer, offset, fragmentFlags1); + NetLib::WriteByte08(buffer, offset, fragmentFlags2); + + NetLib::WriteByte08(buffer, offset, timeToLive); + NetLib::WriteByte08(buffer, offset, protocol); + NetLib::WriteUInt16(buffer, offset, checksum); //header csum + + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&sourceIP); + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&destinationIP); + + //options + for (size_t i = 0; i < options.size(); i++) + options[i]->WriteBytes(buffer, offset); + + //Zero alignment bytes + if (*offset != startOff + headerLength) + memset(&buffer[*offset], 0, startOff + headerLength - *offset); + + *offset = startOff + headerLength; + + payload->WriteBytes(buffer, offset); + } + + void IP_Packet::ReComputeHeaderLen() + { + int opOffset = 20; + for (size_t i = 0; i < options.size(); i++) + opOffset += options[i]->GetLength(); + + opOffset += opOffset % 4; //needs to be a whole number of 32bits + headerLength = opOffset; + } + + void IP_Packet::CalculateChecksum() + { + //if (!(i == 5)) //checksum field is 10-11th byte (5th short), which is skipped + ReComputeHeaderLen(); + u8* headerSegment = new u8[headerLength]; + int counter = 0; + NetLib::WriteByte08(headerSegment, &counter, (_verHi + (headerLength >> 2))); + NetLib::WriteByte08(headerSegment, &counter, dscp); //DSCP/ECN + NetLib::WriteUInt16(headerSegment, &counter, GetLength()); + + NetLib::WriteUInt16(headerSegment, &counter, id); + NetLib::WriteByte08(headerSegment, &counter, fragmentFlags1); + NetLib::WriteByte08(headerSegment, &counter, fragmentFlags2); + + NetLib::WriteByte08(headerSegment, &counter, timeToLive); + NetLib::WriteByte08(headerSegment, &counter, protocol); + NetLib::WriteUInt16(headerSegment, &counter, 0); //header csum + + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&sourceIP); + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&destinationIP); + + //options + for (size_t i = 0; i < options.size(); i++) + options[i]->WriteBytes(headerSegment, &counter); + + //Zero alignment bytes + if (counter != headerLength) + memset(&headerSegment[counter], 0, headerLength - counter); + + counter = headerLength; + + checksum = InternetChecksum(headerSegment, headerLength); + delete[] headerSegment; + } + bool IP_Packet::VerifyChecksum() + { + ReComputeHeaderLen(); + u8* headerSegment = new u8[headerLength]; + int counter = 0; + NetLib::WriteByte08(headerSegment, &counter, (_verHi + (headerLength >> 2))); + NetLib::WriteByte08(headerSegment, &counter, dscp); //DSCP/ECN + NetLib::WriteUInt16(headerSegment, &counter, GetLength()); + + NetLib::WriteUInt16(headerSegment, &counter, id); + NetLib::WriteByte08(headerSegment, &counter, fragmentFlags1); + NetLib::WriteByte08(headerSegment, &counter, fragmentFlags2); + + NetLib::WriteByte08(headerSegment, &counter, timeToLive); + NetLib::WriteByte08(headerSegment, &counter, protocol); + NetLib::WriteUInt16(headerSegment, &counter, checksum); //header csum + + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&sourceIP); + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&destinationIP); + + //options + for (size_t i = 0; i < options.size(); i++) + options[i]->WriteBytes(headerSegment, &counter); + + //Zero alignment bytes + if (counter != headerLength) + memset(&headerSegment[counter], 0, headerLength - counter); + + counter = headerLength; + + u16 csumCal = InternetChecksum(headerSegment, headerLength); + delete[] headerSegment; + + return (csumCal == 0); + } + + IP_Packet::~IP_Packet() + { + for (size_t i = 0; i < options.size(); i++) + delete options[i]; + } + + u16 IP_Packet::InternetChecksum(u8* buffer, int length) + { + //source http://stackoverflow.com/a/2201090 + + int i = 0; + u32 sum = 0; + while (length > 1) + { + sum += ((u32)(buffer[i]) << 8) | ((u32)(buffer[i + 1]) & 0xFF); + if ((sum & 0xFFFF0000) > 0) + { + sum &= 0xFFFF; + sum += 1; + } + + i += 2; + length -= 2; + } + + if (length > 0) + { + sum += (u32)(buffer[i] << 8); + + if ((sum & 0xFFFF0000) > 0) + { + sum = sum & 0xFFFF; + sum += 1; + } + } + sum = ~sum; + sum = sum & 0xFFFF; + return (u16)sum; + } +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Packet.h b/pcsx2/DEV9/PacketReader/IP/IP_Packet.h new file mode 100644 index 0000000000..47f3f1f70a --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Packet.h @@ -0,0 +1,140 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include + +#include "../Payload.h" +#include "IP_Address.h" +#include "IP_Options.h" +#include "IP_Payload.h" + +namespace PacketReader::IP +{ + enum struct IP_Type : u8 + { + ICMP = 0x01, + IGMP = 0x02, + TCP = 0x06, + UDP = 0x11 + }; + + class IP_Packet : public Payload + { + private: + const u8 _verHi = 4 << 4; + int headerLength = 20; + + u8 dscp = 0; + //Flags + + //u16 length; + + u16 id = 0; //used during reassembly fragmented packets + private: + u8 fragmentFlags1 = 0; + u8 fragmentFlags2 = 0; + //Fragment Flags + public: + u8 timeToLive = 0; + u8 protocol; + + private: + u16 checksum; + + public: + IP_Address sourceIP{0}; + IP_Address destinationIP{0}; + std::vector options; + + private: + std::unique_ptr payload; + + public: + //DSCP/TOS Flags + + /* Upper 3 Bits + * DSCP Class is equal to TOS precedence + * DSCP vs TOS + * Default (xxx000), Low Effort (xxx010) + * 0 = Routine Class 0 + * Assured Forwarding (xxx000, xxx010, xxx100, xxx110) + * 1 = Priority Class 1 + * 2 = Immediate Class 2 + * 3 = Flash Class 3 + * 4 = Flash Override Class 4 + * Expedited Forwarding (xxx110, xxx100) + * 5 = Critical Class 5 + * Not Defined (xxx000) + * 6 = Internetwork Control Class 6 + * 7 = Network Control Class 7 + * + * Lower 3 Bits + * In TOS, defined as follows + * bit 0: Reliability + * bit 1: Throughput + * bit 2: Low Delay + * In DSCP, defined as following (bits 1-2) + * Class 0, Low Effort, 1 + * Class 1-4, Assured Forwarding drop probability, Low = 1, Mid = 2, High = 3 + * Class 5, Expedited Forwarding, 3 + * bit0: Set to zero + */ + u8 GetDscpValue(); + void GetDscpValue(u8 value); + + /* 2 bits + * In TOS, defined as follows + * Bit 0: Unused + * Bit 1: Low Cost + * In DSCP, defined as follows + * 0 = ECN not supported + * 1,2 ECN Supported + * 3 = Congestion Encountered + */ + u8 GetDscpECN(); + void SetDscpECN(u8 value); + + //Fragment Flags + //bit 0, reserverd + + bool GetDoNotFragment(); + void SetDoNotFragment(bool value); + + bool GetMoreFragments(); + void SetMoreFragments(bool value); + + //Untested + u16 GetFragmentOffset(); + + //Takes ownership of payload + IP_Packet(IP_Payload* data); + IP_Packet(u8* buffer, int bufferSize, bool fromICMP = false); + + IP_Payload* GetPayload(); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + + bool VerifyChecksum(); + static u16 InternetChecksum(u8* buffer, int length); + + ~IP_Packet(); + + private: + void ReComputeHeaderLen(); + void CalculateChecksum(); + }; +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/IP_Payload.h b/pcsx2/DEV9/PacketReader/IP/IP_Payload.h new file mode 100644 index 0000000000..393d3d6b89 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/IP_Payload.h @@ -0,0 +1,67 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader::IP +{ + class IP_Payload + { + public: //Nedd GetProtocol + virtual int GetLength() = 0; + virtual void WriteBytes(u8* buffer, int* offset) = 0; + virtual u8 GetProtocol() = 0; + virtual bool VerifyChecksum(IP_Address srcIP, IP_Address dstIP) { return false; } + virtual void CalculateChecksum(IP_Address srcIP, IP_Address dstIP) {} + virtual ~IP_Payload() {} + }; + + //Pointer to bytes not owned by class + class IP_PayloadPtr : public IP_Payload + { + public: + u8* data; + + private: + int length; + u8 protocol; + + public: + IP_PayloadPtr(u8* ptr, int len, u8 prot) + { + data = ptr; + length = len; + protocol = prot; + } + virtual int GetLength() + { + return length; + } + virtual void WriteBytes(u8* buffer, int* offset) + { + //If buffer & data point to the same location + //Then no copy is needed + if (data == buffer) + return; + + memcpy(buffer, data, length); + *offset += length; + } + virtual u8 GetProtocol() + { + return protocol; + } + }; +} // namespace PacketReader::IP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.cpp b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.cpp new file mode 100644 index 0000000000..91b37237d0 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.cpp @@ -0,0 +1,437 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "DHCP_Options.h" +#include "../../../NetLib.h" + +namespace PacketReader::IP::UDP::DHCP +{ + DHCPopSubnet::DHCPopSubnet(IP_Address mask) + : subnetMask{mask} + { + } + DHCPopSubnet::DHCPopSubnet(u8* data, int offset) + { + offset += 2; + NetLib::ReadByteArray(data, &offset, 4, (u8*)&subnetMask); + } + void DHCPopSubnet::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&subnetMask); + } + + DHCPopRouter::DHCPopRouter(const std::vector& routerIPs) + : routers{routerIPs} + { + } + DHCPopRouter::DHCPopRouter(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + + routers = {(IP_Address*)&data[offset], (IP_Address*)&data[offset + len]}; + //offset += len; + } + void DHCPopRouter::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, routers.size() * 4, (u8*)&routers[0]); + } + + DHCPopDNS::DHCPopDNS(const std::vector& dnsIPs) + : dnsServers{dnsIPs} + { + } + DHCPopDNS::DHCPopDNS(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + + dnsServers = {(IP_Address*)&data[offset], (IP_Address*)&data[offset + len]}; + //offset += len; + } + void DHCPopDNS::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, dnsServers.size() * 4, (u8*)&dnsServers[0]); + } + + DHCPopHostName::DHCPopHostName(std::string name) + { + if (name.size() > 255) + { + Console.Error("DEV9: DHCPopHostName: Name too long"); + hostName = name.substr(0, 255); + } + else + hostName = name; + } + DHCPopHostName::DHCPopHostName(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + hostName = std::string((char*)&data[offset], len); + //offset += len; + } + void DHCPopHostName::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, hostName.size(), (u8*)hostName.c_str()); + } + + DHCPopDnsName::DHCPopDnsName(std::string name) + { + if (name.size() > 255) + { + Console.Error("DEV9: DHCPopDnsName: Name too long"); + domainName = name.substr(0, 255); + } + else + domainName = name; + } + DHCPopDnsName::DHCPopDnsName(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + domainName = std::string((char*)&data[offset], len); + //offset += len; + } + void DHCPopDnsName::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, domainName.size(), (u8*)domainName.c_str()); + } + + DHCPopBCIP::DHCPopBCIP(IP_Address data) + : broadcastIP{data} + { + } + DHCPopBCIP::DHCPopBCIP(u8* data, int offset) + { + offset += 2; + NetLib::ReadByteArray(data, &offset, 4, (u8*)&broadcastIP); + } + void DHCPopBCIP::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&broadcastIP); + } + + bool DHCPopNBIOSType::GetHNode() + { + return ((type & (1 << 3)) != 0); + } + void DHCPopNBIOSType::SetHNode(bool value) + { + if (value) + { + type |= (1 << 3); + } + else + { + type &= ~(1 << 3); + } + } + bool DHCPopNBIOSType::GetMNode() + { + return ((type & (1 << 2)) != 0); + } + void DHCPopNBIOSType::SetMNode(bool value) + { + if (value) + { + type |= (1 << 2); + } + else + { + type &= ~(1 << 2); + } + } + bool DHCPopNBIOSType::GetPNode() + { + return ((type & (1 << 1)) != 0); + } + void DHCPopNBIOSType::SetPNode(bool value) + { + if (value) + { + type |= (1 << 1); + } + else + { + type &= ~(1 << 1); + } + } + bool DHCPopNBIOSType::GetBNode() + { + return ((type & 1) != 0); + } + void DHCPopNBIOSType::SetBNode(bool value) + { + if (value) + { + type |= 1; + } + else + { + type &= ~1; + } + } + // + DHCPopNBIOSType::DHCPopNBIOSType(u8* data, int offset) + { + offset += 2; + NetLib::ReadByte08(data, &offset, &type); + } + void DHCPopNBIOSType::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByte08(buffer, offset, type); + } + + DHCPopREQIP::DHCPopREQIP(IP_Address data) + : requestedIP{data} + { + } + DHCPopREQIP::DHCPopREQIP(u8* data, int offset) + { + offset += 2; + NetLib::ReadByteArray(data, &offset, 4, (u8*)&requestedIP); + } + void DHCPopREQIP::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&requestedIP); + } + + DHCPopIPLT::DHCPopIPLT(u32 LeaseTime) + : ipLeaseTime{LeaseTime} + { + } + DHCPopIPLT::DHCPopIPLT(u8* data, int offset) + { + offset += 2; + NetLib::ReadUInt32(data, &offset, &ipLeaseTime); + } + void DHCPopIPLT::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteUInt32(buffer, offset, ipLeaseTime); + } + + DHCPopMSG::DHCPopMSG(u8 msg) + : message{msg} + { + } + DHCPopMSG::DHCPopMSG(u8* data, int offset) + { + offset += 2; + NetLib::ReadByte08(data, &offset, &message); + } + void DHCPopMSG::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByte08(buffer, offset, message); + } + + DHCPopSERVIP::DHCPopSERVIP(IP_Address data) + : serverIP{data} + { + } + DHCPopSERVIP::DHCPopSERVIP(u8* data, int offset) + { + offset += 2; + NetLib::ReadByteArray(data, &offset, 4, (u8*)&serverIP); + } + void DHCPopSERVIP::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&serverIP); + } + + DHCPopREQLIST::DHCPopREQLIST(const std::vector& requestList) + : requests{requestList} + { + } + DHCPopREQLIST::DHCPopREQLIST(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + + requests = {&data[offset], &data[offset + len]}; + //offset += len; + } + void DHCPopREQLIST::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, requests.size(), &requests[0]); + } + + DHCPopMSGStr::DHCPopMSGStr(std::string msg) + { + if (msg.size() > 255) + { + Console.Error("DEV9: DHCPopMSGStr: String too long"); + message = msg.substr(0, 255); + } + else + message = msg; + } + DHCPopMSGStr::DHCPopMSGStr(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + message = std::string((char*)&data[offset], len); + //offset += len; + } + void DHCPopMSGStr::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, message.size(), (u8*)message.c_str()); + } + + DHCPopMMSGS::DHCPopMMSGS(u16 mms) + : maxMessageSize{mms} + { + } + DHCPopMMSGS::DHCPopMMSGS(u8* data, int offset) + { + offset += 2; + NetLib::ReadUInt16(data, &offset, &maxMessageSize); + } + void DHCPopMMSGS::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteUInt16(buffer, offset, maxMessageSize); + } + + DHCPopT1::DHCPopT1(u32 t1) + : ipRenewalTimeT1{t1} + { + } + DHCPopT1::DHCPopT1(u8* data, int offset) + { + offset += 2; + NetLib::ReadUInt32(data, &offset, &ipRenewalTimeT1); + } + void DHCPopT1::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteUInt32(buffer, offset, ipRenewalTimeT1); + } + + DHCPopT2::DHCPopT2(u32 t2) + : ipRebindingTimeT2{t2} + { + } + DHCPopT2::DHCPopT2(u8* data, int offset) + { + offset += 2; + NetLib::ReadUInt32(data, &offset, &ipRebindingTimeT2); + } + void DHCPopT2::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteUInt32(buffer, offset, ipRebindingTimeT2); + } + + DHCPopClassID::DHCPopClassID(std::string id) + { + if (id.size() > 255) + { + Console.Error("DEV9: DHCPopClassID: Class ID too long"); + classID = id.substr(0, 255); + } + else + classID = id; + } + DHCPopClassID::DHCPopClassID(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + classID = std::string((char*)&data[offset], len); + //offset += len; + } + void DHCPopClassID::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, classID.size(), (u8*)classID.c_str()); + } + + DHCPopClientID::DHCPopClientID(const std::vector& value) + : clientID{value} + { + } + DHCPopClientID::DHCPopClientID(u8* data, int offset) + { + offset += 1; + u8 len; + NetLib::ReadByte08(data, &offset, &len); + + clientID = {&data[offset], &data[offset + len]}; + //offset += len; + } + void DHCPopClientID::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteByte08(buffer, offset, GetCode()); + NetLib::WriteByte08(buffer, offset, GetLength() - 2); + + NetLib::WriteByteArray(buffer, offset, clientID.size(), &clientID[0]); + } + +} // namespace PacketReader::IP::UDP::DHCP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.h b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.h new file mode 100644 index 0000000000..2a730bda48 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Options.h @@ -0,0 +1,320 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include +#include + +#include "../../IP_Packet.h" +#include "../../IP_Options.h" + +namespace PacketReader::IP::UDP::DHCP +{ + //Unlike IPOptions, DCHP length field does not count the option header + //GetLength(), howver, includes the option header + class DHCPopNOP : public BaseOption + { + virtual u8 GetLength() { return 1; } + virtual u8 GetCode() { return 0; } + + virtual void WriteBytes(u8* buffer, int* offset) + { + buffer[*offset] = GetCode(); + (*offset)++; + } + }; + + class DHCPopSubnet : public BaseOption + { + public: + IP_Address subnetMask{0}; + + DHCPopSubnet(IP_Address mask); + DHCPopSubnet(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 1; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopRouter : public BaseOption //can be longer then 1 address + { + public: + std::vector routers; + DHCPopRouter(const std::vector& routerIPs); + DHCPopRouter(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + 4 * routers.size(); } + virtual u8 GetCode() { return 3; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopDNS : public BaseOption //can be longer then 1 address + { + public: + std::vector dnsServers; + DHCPopDNS(const std::vector& dnsIPs); + DHCPopDNS(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + 4 * dnsServers.size(); } + virtual u8 GetCode() { return 6; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopHostName : public BaseOption + { + public: + //ASCII encoding + std::string hostName; + + DHCPopHostName(std::string name); + DHCPopHostName(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + hostName.size(); } + virtual u8 GetCode() { return 12; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopDnsName : public BaseOption + { + public: + //ASCII encoding + std::string domainName; + + DHCPopDnsName(std::string name); + DHCPopDnsName(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + domainName.size(); } + virtual u8 GetCode() { return 15; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopBCIP : public BaseOption //The IP to send broadcasts to + { + public: + IP_Address broadcastIP{0}; + + DHCPopBCIP(IP_Address data); + DHCPopBCIP(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 28; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + //What even sent this? + class DHCPopNBIOSType : public BaseOption + { + private: + u8 type = 0; + + public: + //Getters/Setters + bool GetHNode(); + void SetHNode(bool value); + + bool GetMNode(); + void SetMNode(bool value); + + bool GetPNode(); + void SetPNode(bool value); + + bool GetBNode(); + void SetBNode(bool value); + + DHCPopNBIOSType(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 3; } + virtual u8 GetCode() { return 46; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopREQIP : public BaseOption //The IP to send broadcasts to + { + public: + IP_Address requestedIP{0}; + + DHCPopREQIP(IP_Address data); + DHCPopREQIP(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 50; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopIPLT : public BaseOption + { + public: + u32 ipLeaseTime; + + DHCPopIPLT(u32 LeaseTime); + DHCPopIPLT(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 51; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopMSG : public BaseOption + { + public: + u8 message; + DHCPopMSG(u8 msg); + DHCPopMSG(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 3; } + virtual u8 GetCode() { return 53; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopSERVIP : public BaseOption //DHCP server ip + { + public: + IP_Address serverIP{0}; + + DHCPopSERVIP(IP_Address data); + DHCPopSERVIP(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 54; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopREQLIST : public BaseOption + { + public: + std::vector requests; + + DHCPopREQLIST(const std::vector& requestList); + DHCPopREQLIST(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + requests.size(); } + virtual u8 GetCode() { return 55; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopMSGStr : public BaseOption + { + public: + //ASCII encoding + std::string message; + + DHCPopMSGStr(std::string msg); + DHCPopMSGStr(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + message.size(); } + virtual u8 GetCode() { return 56; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopMMSGS : public BaseOption + { + public: + u16 maxMessageSize; + + DHCPopMMSGS(u16 mms); + DHCPopMMSGS(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 4; } + virtual u8 GetCode() { return 57; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopT1 : public BaseOption + { + public: + u32 ipRenewalTimeT1; + + DHCPopT1(u32 t1); + DHCPopT1(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 58; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopT2 : public BaseOption + { + public: + u32 ipRebindingTimeT2; + + DHCPopT2(u32 t2); + DHCPopT2(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 6; } + virtual u8 GetCode() { return 59; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopClassID : public BaseOption + { + public: + //ASCII encoding + std::string classID; + + DHCPopClassID(std::string id); + DHCPopClassID(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + classID.size(); } + virtual u8 GetCode() { return 60; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopClientID final : public BaseOption + { + public: + std::vector clientID; + + DHCPopClientID(const std::vector& value); + DHCPopClientID(u8* data, int offset); //Offset will include Kind and Len + + virtual u8 GetLength() { return 2 + clientID.size(); } + virtual u8 GetCode() { return 61; } + + virtual void WriteBytes(u8* buffer, int* offset); + }; + + class DHCPopEND : public BaseOption + { + public: + DHCPopEND() {} + + virtual u8 GetLength() { return 1; } + virtual u8 GetCode() { return 255; } + + virtual void WriteBytes(u8* buffer, int* offset) + { + buffer[*offset] = GetCode(); + (*offset)++; + } + }; +} // namespace PacketReader::IP::UDP::DHCP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp new file mode 100644 index 0000000000..cbbac9b0d0 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.cpp @@ -0,0 +1,223 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" +#include "DHCP_Packet.h" +#include "../../../NetLib.h" + +namespace PacketReader::IP::UDP::DHCP +{ + DHCP_Packet::DHCP_Packet(u8* buffer, int bufferSize) + { + int offset = 0; + //Bits 0-31 //Bytes 0-3 + NetLib::ReadByte08(buffer, &offset, &op); + NetLib::ReadByte08(buffer, &offset, &hardwareType); + NetLib::ReadByte08(buffer, &offset, &hardwareAddressLength); + NetLib::ReadByte08(buffer, &offset, &hops); + + //Bits 32-63 //Bytes 4-7 + NetLib::ReadUInt32(buffer, &offset, &transactionID); + + //Bits 64-95 //Bytes 8-11 + NetLib::ReadUInt16(buffer, &offset, &seconds); + NetLib::ReadUInt16(buffer, &offset, &flags); + + //Bits 96-127 //Bytes 12-15 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&clientIP); + + //Bits 128-159 //Bytes 16-19 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&yourIP); + + //Bits 160-191 //Bytes 20-23 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&serverIP); + + //Bits 192-223 //Bytes 24-27 + NetLib::ReadByteArray(buffer, &offset, 4, (u8*)&gatewayIP); + + //Bits 192+ //Bytes 28-43 + NetLib::ReadByteArray(buffer, &offset, 16, clientHardwareAddress); + + //Bytes 44-235 + //Assume BOOTP unused + offset += 192; + + //Bytes 236-239 + NetLib::ReadUInt32(buffer, &offset, &magicCookie); + bool opReadFin = false; + + do + { + u8 opKind = buffer[offset]; + if (opKind == 255) + { + options.push_back(new DHCPopEND()); + opReadFin = true; + offset += 1; + continue; + } + if ((offset + 1) >= bufferSize) + { + Console.Error("DEV9: DHCP_Packet: Unexpected end of packet"); + options.push_back(new DHCPopEND()); + opReadFin = true; + continue; + } + u8 opLen = buffer[offset + 1]; + switch (opKind) + { + case 0: + options.push_back(new DHCPopNOP()); + offset += 1; + continue; + case 1: + options.push_back(new DHCPopSubnet(buffer, offset)); + break; + case 3: + options.push_back(new DHCPopRouter(buffer, offset)); + break; + case 6: + options.push_back(new DHCPopDNS(buffer, offset)); + break; + case 12: + options.push_back(new DHCPopHostName(buffer, offset)); + break; + case 15: + options.push_back(new DHCPopDnsName(buffer, offset)); + break; + case 28: + options.push_back(new DHCPopBCIP(buffer, offset)); + break; + case 46: + //Do we actually care about this? + options.push_back(new DHCPopNBIOSType(buffer, offset)); + break; + case 50: + options.push_back(new DHCPopREQIP(buffer, offset)); + break; + case 51: + options.push_back(new DHCPopIPLT(buffer, offset)); + break; + case 53: + options.push_back(new DHCPopMSG(buffer, offset)); + break; + case 54: + options.push_back(new DHCPopSERVIP(buffer, offset)); + break; + case 55: + options.push_back(new DHCPopREQLIST(buffer, offset)); + break; + case 56: + options.push_back(new DHCPopMSGStr(buffer, offset)); + break; + case 57: + options.push_back(new DHCPopMMSGS(buffer, offset)); + break; + case 58: + options.push_back(new DHCPopT1(buffer, offset)); + break; + case 59: + options.push_back(new DHCPopT2(buffer, offset)); + break; + case 60: + options.push_back(new DHCPopClassID(buffer, offset)); + break; + case 61: + //Do we actully care about this? + options.push_back(new DHCPopClientID(buffer, offset)); + break; + default: + Console.Error("DEV9: DHCP_Packet: Got Unknown Option %d with len %d", opKind, opLen); + break; + } + offset += opLen + 2; + if (offset >= bufferSize) + { + Console.Error("DEV9: DHCP_Packet: Unexpected end of packet"); + options.push_back(new DHCPopNOP()); + opReadFin = true; + } + } while (opReadFin == false); + } + + int DHCP_Packet::GetLength() + { + return maxLenth - (8 + 20); + } + + void DHCP_Packet::WriteBytes(u8* buffer, int* offset) + { + int start = *offset; + NetLib::WriteByte08(buffer, offset, op); + NetLib::WriteByte08(buffer, offset, hardwareType); + NetLib::WriteByte08(buffer, offset, hardwareAddressLength); + NetLib::WriteByte08(buffer, offset, hops); + + NetLib::WriteUInt32(buffer, offset, transactionID); + + NetLib::WriteUInt16(buffer, offset, seconds); + NetLib::WriteUInt16(buffer, offset, flags); + + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&clientIP); + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&yourIP); + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&serverIP); + NetLib::WriteByteArray(buffer, offset, 4, (u8*)&gatewayIP); + + NetLib::WriteByteArray(buffer, offset, 16, clientHardwareAddress); + //empty bytes + memset(buffer + *offset, 0, 64 + 128); + *offset += 64 + 128; + + NetLib::WriteUInt32(buffer, offset, magicCookie); + + int len = 240; + for (size_t i = 0; i < options.size(); i++) + { + if (len + options[i]->GetLength() < maxLenth) + { + len += options[i]->GetLength(); + options[i]->WriteBytes(buffer, offset); + } + else + { + Console.Error("DEV9: DHCP_Packet: Oversized DHCP packet not handled"); + //We need space for DHCP End + if (len == maxLenth) + { + i -= 1; + int pastLength = options[i]->GetLength(); + len -= pastLength; + *offset -= pastLength; + } + + DHCPopEND end; + end.WriteBytes(buffer, offset); + break; + } + } + + int end = start + GetLength(); + int delta = end - *offset; + + memset(&buffer[*offset], 0, delta); + *offset = start + GetLength(); + } + + DHCP_Packet::~DHCP_Packet() + { + for (size_t i = 0; i < options.size(); i++) + delete options[i]; + } +} // namespace PacketReader::IP::UDP::DHCP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.h b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.h new file mode 100644 index 0000000000..aeb6186333 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DHCP/DHCP_Packet.h @@ -0,0 +1,55 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include + +#include "DHCP_Options.h" +#include "../../IP_Packet.h" + +namespace PacketReader::IP::UDP::DHCP +{ + class DHCP_Packet : public Payload + { + public: + u8 op; + u8 hardwareType; + u8 hardwareAddressLength; + u8 hops; + u32 transactionID; //xid + u16 seconds; + u16 flags; + IP_Address clientIP{0}; + IP_Address yourIP{0}; + IP_Address serverIP{0}; + IP_Address gatewayIP{0}; + u8 clientHardwareAddress[16]{0}; //always 16 bytes, regardless of HardwareAddressLength + //192 bytes of padding + u32 magicCookie; + //Assumes ownership of ptrs assigned to it + std::vector options; + + //used by GetLength & WriteBytes + int maxLenth = 576; + + DHCP_Packet() {} + DHCP_Packet(u8* buffer, int bufferSize); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + + virtual ~DHCP_Packet(); + }; +} // namespace PacketReader::IP::UDP::DHCP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.cpp b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.cpp new file mode 100644 index 0000000000..233809e6d7 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.cpp @@ -0,0 +1,145 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "DNS_Classes.h" +#include "../../../NetLib.h" + +namespace PacketReader::IP::UDP::DNS +{ + DNS_QuestionEntry::DNS_QuestionEntry(const std::string& qName, u16 qType, u16 qClass) + : name{qName} + , entryType{qType} + , entryClass{qClass} + { + } + DNS_QuestionEntry::DNS_QuestionEntry(u8* buffer, int* offset) + { + ReadDNS_String(buffer, offset, &name); + NetLib::ReadUInt16(buffer, offset, &entryType); + NetLib::ReadUInt16(buffer, offset, &entryClass); + } + + void DNS_QuestionEntry::ReadDNS_String(u8* buffer, int* offset, std::string* value) + { + *value = ""; + + while (buffer[*offset] != 0) + { + int len = buffer[*offset]; + + if (len >= 192) + { + //len instead contains a pointer to the rest of the string + u8 addrB[2]; + NetLib::ReadByteArray(buffer, offset, 2, addrB); + + addrB[0] &= ~0xC0; + u16 addr; + int tmp = 0; + NetLib::ReadUInt16(addrB, &tmp, &addr); + tmp = addr; + std::string o; + ReadDNS_String(buffer, &tmp, &o); + *value += o; + //Ends with the pointer, no null char + return; + } + else + { + *offset += 1; + *value += std::string((char*)&buffer[*offset], len); + *offset += len; + + if (buffer[*offset] != 0) + *value += "."; + } + } + //null char + *offset += 1; + } + void DNS_QuestionEntry::WriteDNS_String(u8* buffer, int* offset, std::string value) + { + int segmentLength = 0; + int segmentStart = 0; + for (size_t i = 0; i < value.size(); i++) + { + if (value[i] == '.') + { + if (segmentLength == 0) + continue; + + NetLib::WriteByte08(buffer, offset, segmentLength); + NetLib::WriteByteArray(buffer, offset, segmentLength, (u8*)&value.c_str()[segmentStart]); + segmentLength = 0; + segmentStart = i + 1; + } + else + segmentLength++; + continue; + } + if (segmentLength != 0) + { + NetLib::WriteByte08(buffer, offset, segmentLength); + NetLib::WriteByteArray(buffer, offset, segmentLength, (u8*)&value.c_str()[segmentStart]); + } + //null char + NetLib::WriteByte08(buffer, offset, 0); + } + + int DNS_QuestionEntry::GetLength() + { + return 1 + name.size() + 1 + 4; + } + + void DNS_QuestionEntry::WriteBytes(u8* buffer, int* offset) + { + WriteDNS_String(buffer, offset, name); + NetLib::WriteUInt16(buffer, offset, entryType); + NetLib::WriteUInt16(buffer, offset, entryClass); + } + + DNS_ResponseEntry::DNS_ResponseEntry(const std::string& rName, u16 rType, u16 rClass, const std::vector& rData, u32 rTTL) + : DNS_QuestionEntry(rName, rType, rClass) + , timeToLive{rTTL} + , data{rData} + { + } + + DNS_ResponseEntry::DNS_ResponseEntry(u8* buffer, int* offset) + : DNS_QuestionEntry(buffer, offset) + { + u16 dataLen; + NetLib::ReadUInt32(buffer, offset, &timeToLive); + NetLib::ReadUInt16(buffer, offset, &dataLen); + + data = {&buffer[*offset], &buffer[*offset + dataLen]}; + *offset += dataLen; + } + + int DNS_ResponseEntry::GetLength() + { + return DNS_QuestionEntry::GetLength() + 4 + 2 + data.size(); + } + + void DNS_ResponseEntry::WriteBytes(u8* buffer, int* offset) + { + DNS_QuestionEntry::WriteBytes(buffer, offset); + NetLib::WriteUInt32(buffer, offset, timeToLive); + NetLib::WriteUInt16(buffer, offset, data.size()); + NetLib::WriteByteArray(buffer, offset, data.size(), &data[0]); + } +} // namespace PacketReader::IP::UDP::DNS diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.h b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.h new file mode 100644 index 0000000000..7a80999666 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Classes.h @@ -0,0 +1,60 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include +#include + +namespace PacketReader::IP::UDP::DNS +{ + class DNS_QuestionEntry + { + public: + std::string name; + u16 entryType; + u16 entryClass; + + DNS_QuestionEntry(const std::string& qName, u16 qType, u16 qClass); + DNS_QuestionEntry(u8* buffer, int* offset); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + + virtual ~DNS_QuestionEntry(){}; + + private: + void ReadDNS_String(u8* buffer, int* offset, std::string* value); + void WriteDNS_String(u8* buffer, int* offset, std::string value); + }; + + class DNS_ResponseEntry : public DNS_QuestionEntry + { + public: + u32 timeToLive; + std::vector data; + + DNS_ResponseEntry(const std::string& rName, u16 rType, u16 rClass, const std::vector& rData, u32 rTTL); + DNS_ResponseEntry(u8* buffer, int* offset); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + + virtual ~DNS_ResponseEntry(){}; + + private: + void ReadDNSString(u8* buffer, int* offset, std::string* value); + void WriteDNSString(u8* buffer, int* offset, std::string value); + }; +} // namespace PacketReader::IP::UDP::DNS \ No newline at end of file diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h new file mode 100644 index 0000000000..717751f376 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Enums.h @@ -0,0 +1,43 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader::IP::UDP +{ + enum struct DNS_OPCode : u8 + { + Query = 0, + IQuery = 1, + Status = 2, + Reserved = 3, + Notify = 4, + Update = 5 + }; + enum struct DNS_RCode : u8 + { + NoError = 0, + FormatError = 1, + ServerFailure = 2, + NameError = 3, + NotImplemented = 4, + Refused = 5, + YXDomain = 6, + YXRRSet = 7, + NXRRSet = 8, + NotAuth = 9, + NotZone = 10, + }; +} // namespace PacketReader::IP::UDP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.cpp b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.cpp new file mode 100644 index 0000000000..9c82ff37e5 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.cpp @@ -0,0 +1,194 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "DNS_Packet.h" +#include "../../../NetLib.h" + +namespace PacketReader::IP::UDP::DNS +{ + bool DNS_Packet::GetQR() + { + return (flags1 & (1 << 7)) != 0; + } + void DNS_Packet::SetQR(bool value) + { + flags1 = (flags1 & ~(0x1 << 7)) | ((value & 0x1) << 7); + } + + u8 DNS_Packet::GetOpCode() + { + return (flags1 >> 3) & 0xF; + } + void DNS_Packet::SetOpCode(u8 value) + { + flags1 = (flags1 & ~(0xF << 3)) | ((value & 0xF) << 3); + } + + bool DNS_Packet::GetAA() + { + return (flags1 & (1 << 2)) != 0; + } + void DNS_Packet::SetAA(bool value) + { + flags1 = (flags1 & ~(0x1 << 2)) | ((value & 0x1) << 2); + } + + bool DNS_Packet::GetTC() + { + return (flags1 & (1 << 1)) != 0; + } + void DNS_Packet::SetTC(bool value) + { + flags1 = (flags1 & ~(0x1 << 1)) | ((value & 0x1) << 1); + } + + bool DNS_Packet::GetRD() + { + return (flags1 & 1) != 0; + } + void DNS_Packet::SetRD(bool value) + { + flags1 = (flags1 & ~0x1) | (value & 0x1); + } + + bool DNS_Packet::GetRA() + { + return (flags2 & (1 << 7)) != 0; + } + void DNS_Packet::SetRA(bool value) + { + flags2 = (flags2 & ~(0x1 << 7)) | ((value & 0x1) << 7); + } + + u8 DNS_Packet::GetZ0() + { + return (flags2 & (1 << 6)) != 0; + } + void DNS_Packet::SetZ0(u8 value) + { + flags1 = (flags2 & ~(0x1 << 6)) | ((value & 0x1) << 6); + } + + bool DNS_Packet::GetAD() + { + return (flags2 & (1 << 5)) != 0; + } + void DNS_Packet::SetAD(bool value) + { + flags2 = (flags2 & ~(0x1 << 5)) | ((value & 0x1) << 5); + } + + bool DNS_Packet::GetCD() + { + return (flags2 & (1 << 4)) != 0; + } + void DNS_Packet::SetCD(bool value) + { + flags2 = (flags2 & ~(0x1 << 4)) | ((value & 0x1) << 4); + } + + u8 DNS_Packet::GetRCode() + { + return flags2 & 0xF; + } + void DNS_Packet::SetRCode(u8 value) + { + flags2 = (flags2 & ~(0xF << 3)) | ((value & 0xF) << 3); + } + + DNS_Packet::DNS_Packet(u8* buffer, int bufferSize) + { + int offset = 0; + //Bits 0-31 //Bytes 0-3 + NetLib::ReadUInt16(buffer, &offset, &id); + NetLib::ReadByte08(buffer, &offset, &flags1); + NetLib::ReadByte08(buffer, &offset, &flags2); + //Bits 32-63 //Bytes 4-7 + u16 qCount; + u16 aCount; + u16 auCount; + u16 adCount; + NetLib::ReadUInt16(buffer, &offset, &qCount); + NetLib::ReadUInt16(buffer, &offset, &aCount); + //Bits 64-95 //Bytes 8-11 + NetLib::ReadUInt16(buffer, &offset, &auCount); + NetLib::ReadUInt16(buffer, &offset, &adCount); + //Bits 96+ //Bytes 8+ + for (int i = 0; i < qCount; i++) + { + DNS_QuestionEntry entry(buffer, &offset); + questions.push_back(entry); + } + for (int i = 0; i < aCount; i++) + { + DNS_ResponseEntry entry(buffer, &offset); + answers.push_back(entry); + } + for (int i = 0; i < auCount; i++) + { + DNS_ResponseEntry entry(buffer, &offset); + authorities.push_back(entry); + } + for (int i = 0; i < adCount; i++) + { + DNS_ResponseEntry entry(buffer, &offset); + additional.push_back(entry); + } + } + + int DNS_Packet::GetLength() + { + int length = 2 * 2 + 4 * 2; + + for (size_t i = 0; i < questions.size(); i++) + length += questions[i].GetLength(); + + for (size_t i = 0; i < answers.size(); i++) + length += answers[i].GetLength(); + + for (size_t i = 0; i < authorities.size(); i++) + length += authorities[i].GetLength(); + + for (size_t i = 0; i < additional.size(); i++) + length += additional[i].GetLength(); + + return length; + } + + void DNS_Packet::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteUInt16(buffer, offset, id); + NetLib::WriteByte08(buffer, offset, flags1); + NetLib::WriteByte08(buffer, offset, flags2); + NetLib::WriteUInt16(buffer, offset, questions.size()); + NetLib::WriteUInt16(buffer, offset, answers.size()); + NetLib::WriteUInt16(buffer, offset, authorities.size()); + NetLib::WriteUInt16(buffer, offset, additional.size()); + + for (size_t i = 0; i < questions.size(); i++) + questions[i].WriteBytes(buffer, offset); + + for (size_t i = 0; i < answers.size(); i++) + answers[i].WriteBytes(buffer, offset); + + for (size_t i = 0; i < authorities.size(); i++) + authorities[i].WriteBytes(buffer, offset); + + for (size_t i = 0; i < additional.size(); i++) + additional[i].WriteBytes(buffer, offset); + } +} // namespace PacketReader::IP::UDP::DNS diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h new file mode 100644 index 0000000000..8e150f4423 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/DNS/DNS_Packet.h @@ -0,0 +1,81 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include + +#include "DNS_Classes.h" +#include "DNS_Enums.h" +#include "../../../Payload.h" + +namespace PacketReader::IP::UDP::DNS +{ + class DNS_Packet : public Payload + { + public: + u16 id = 0; + + private: + u8 flags1 = 0; + u8 flags2 = 0; + + //QuestionCount + //AnswerCount + //Authorities + //Additional + + public: + std::vector questions; + std::vector answers; + std::vector authorities; + std::vector additional; + + bool GetQR(); + void SetQR(bool value); + + u8 GetOpCode(); + void SetOpCode(u8 value); + + bool GetAA(); + void SetAA(bool value); + + bool GetTC(); + void SetTC(bool value); + + bool GetRD(); + void SetRD(bool value); + + bool GetRA(); + void SetRA(bool value); + + u8 GetZ0(); + void SetZ0(u8 value); + + bool GetAD(); + void SetAD(bool value); + + bool GetCD(); + void SetCD(bool value); + + u8 GetRCode(); + void SetRCode(u8 value); + + DNS_Packet() {} + DNS_Packet(u8* buffer, int bufferSize); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + }; +} // namespace PacketReader::IP::UDP::DNS \ No newline at end of file diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.cpp b/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.cpp new file mode 100644 index 0000000000..e7cde8327e --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.cpp @@ -0,0 +1,130 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "UDP_Packet.h" +#include "../../NetLib.h" + +namespace PacketReader::IP::UDP +{ + UDP_Packet::UDP_Packet(Payload* data) + : payload{data} + { + } + UDP_Packet::UDP_Packet(u8* buffer, int bufferSize) + { + int offset = 0; + //Bits 0-31 + NetLib::ReadUInt16(buffer, &offset, &sourcePort); + NetLib::ReadUInt16(buffer, &offset, &destinationPort); + + //Bits 32-63 + u16 length; + NetLib::ReadUInt16(buffer, &offset, &length); //includes header length + NetLib::ReadUInt16(buffer, &offset, &checksum); + + if (length > bufferSize) + { + Console.Error("DEV9: UDP_Packet: Unexpected Length"); + length = (u16)bufferSize; + } + + //Bits 64+ + payload = std::make_unique(&buffer[offset], length - offset); + //AllDone + } + + Payload* UDP_Packet::GetPayload() + { + return payload.get(); + } + + int UDP_Packet::GetLength() + { + return headerLength + payload->GetLength(); + } + + void UDP_Packet::WriteBytes(u8* buffer, int* offset) + { + NetLib::WriteUInt16(buffer, offset, sourcePort); + NetLib::WriteUInt16(buffer, offset, destinationPort); + NetLib::WriteUInt16(buffer, offset, GetLength()); + NetLib::WriteUInt16(buffer, offset, checksum); + + payload->WriteBytes(buffer, offset); + } + + u8 UDP_Packet::GetProtocol() + { + return (u8)protocol; + } + + void UDP_Packet::CalculateChecksum(IP_Address srcIP, IP_Address dstIP) + { + int pHeaderLen = (12) + headerLength + payload->GetLength(); + if ((pHeaderLen & 1) != 0) + pHeaderLen += 1; + + u8* headerSegment = new u8[pHeaderLen]; + int counter = 0; + + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&srcIP); + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&dstIP); + NetLib::WriteByte08(headerSegment, &counter, 0); + NetLib::WriteByte08(headerSegment, &counter, (u8)protocol); + NetLib::WriteUInt16(headerSegment, &counter, GetLength()); + + //Pseudo Header added + //Rest of data is normal Header+data (with zerored checksum feild) + checksum = 0; + WriteBytes(headerSegment, &counter); + + //Zero alignment byte + if (counter != pHeaderLen) + NetLib::WriteByte08(headerSegment, &counter, 0); + + checksum = IP_Packet::InternetChecksum(headerSegment, pHeaderLen); + delete[] headerSegment; + } + bool UDP_Packet::VerifyChecksum(IP_Address srcIP, IP_Address dstIP) + { + int pHeaderLen = (12) + headerLength + payload->GetLength(); + if ((pHeaderLen & 1) != 0) + pHeaderLen += 1; + + u8* headerSegment = new u8[pHeaderLen]; + int counter = 0; + + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&srcIP); + NetLib::WriteByteArray(headerSegment, &counter, 4, (u8*)&dstIP); + NetLib::WriteByte08(headerSegment, &counter, 0); + NetLib::WriteByte08(headerSegment, &counter, (u8)protocol); + NetLib::WriteUInt16(headerSegment, &counter, GetLength()); + + //Pseudo Header added + //Rest of data is normal Header+data + WriteBytes(headerSegment, &counter); + + //Zero alignment byte + if (counter != pHeaderLen) + NetLib::WriteByte08(headerSegment, &counter, 0); + + u16 csumCal = IP_Packet::InternetChecksum(headerSegment, pHeaderLen); + delete[] headerSegment; + + return (csumCal == 0); + } +} // namespace PacketReader::IP::UDP diff --git a/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.h b/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.h new file mode 100644 index 0000000000..e67f9f7602 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/IP/UDP/UDP_Packet.h @@ -0,0 +1,51 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once +#include "../IP_Packet.h" + +namespace PacketReader::IP::UDP +{ + class UDP_Packet : public IP_Payload + { + public: + u16 sourcePort; + u16 destinationPort; + + private: + //u16 length; + u16 checksum; + + const static int headerLength = 8; + const static IP_Type protocol = IP_Type::UDP; + + std::unique_ptr payload; + + public: + //Takes ownership of payload + UDP_Packet(Payload* data); + UDP_Packet(u8* buffer, int bufferSize); + + Payload* GetPayload(); + + virtual int GetLength(); + virtual void WriteBytes(u8* buffer, int* offset); + + virtual u8 GetProtocol(); + + virtual bool VerifyChecksum(IP_Address srcIP, IP_Address dstIP); + virtual void CalculateChecksum(IP_Address srcIP, IP_Address dstIP); + }; +} // namespace PacketReader::IP::UDP diff --git a/pcsx2/DEV9/PacketReader/NetLib.cpp b/pcsx2/DEV9/PacketReader/NetLib.cpp new file mode 100644 index 0000000000..ab9d664967 --- /dev/null +++ b/pcsx2/DEV9/PacketReader/NetLib.cpp @@ -0,0 +1,75 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#include "PrecompiledHeader.h" + +#include "NetLib.h" + +#ifdef _WIN32 +#include "winsock.h" +#else +#include +#endif + +namespace PacketReader::NetLib +{ + void WriteByte08(u8* data, int* index, u8 value) + { + data[*index] = value; + *index += sizeof(u8); + } + void WriteUInt16(u8* data, int* index, u16 value) + { + *(u16*)&data[*index] = htons(value); + *index += sizeof(u16); + } + void WriteUInt32(u8* data, int* index, u32 value) + { + *(u32*)&data[*index] = htonl(value); + *index += sizeof(u32); + } + + //Special + void WriteByteArray(u8* data, int* index, int length, u8* value) + { + memcpy(&data[*index], value, length); + *index += length; + } + + + //Read + void ReadByte08(u8* data, int* index, u8* value) + { + *value = data[*index]; + *index += sizeof(u8); + } + void ReadUInt16(u8* data, int* index, u16* value) + { + *value = ntohs(*(u16*)&data[*index]); + *index += sizeof(u16); + } + void ReadUInt32(u8* data, int* index, u32* value) + { + *value = ntohl(*(u32*)&data[*index]); + *index += sizeof(u32); + } + + //Special + void ReadByteArray(u8* data, int* index, int length, u8* value) + { + memcpy(value, &data[*index], length); + *index += length; + } +} // namespace PacketReader::NetLib diff --git a/pcsx2/DEV9/PacketReader/NetLib.h b/pcsx2/DEV9/PacketReader/NetLib.h new file mode 100644 index 0000000000..2f29ef6d3a --- /dev/null +++ b/pcsx2/DEV9/PacketReader/NetLib.h @@ -0,0 +1,31 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader::NetLib +{ + void WriteByte08(u8* data, int* index, u8 value); + void WriteUInt16(u8* data, int* index, u16 value); + void WriteUInt32(u8* data, int* index, u32 value); + + void WriteByteArray(u8* data, int* index, int length, u8* value); + + void ReadByte08(u8* data, int* index, u8* value); + void ReadUInt16(u8* data, int* index, u16* value); + void ReadUInt32(u8* data, int* index, u32* value); + + void ReadByteArray(u8* data, int* index, int length, u8* value); +} // namespace PacketReader::NetLib diff --git a/pcsx2/DEV9/PacketReader/Payload.h b/pcsx2/DEV9/PacketReader/Payload.h new file mode 100644 index 0000000000..33bb4f366b --- /dev/null +++ b/pcsx2/DEV9/PacketReader/Payload.h @@ -0,0 +1,58 @@ +/* PCSX2 - PS2 Emulator for PCs + * Copyright (C) 2002-2021 PCSX2 Dev Team + * + * PCSX2 is free software: you can redistribute it and/or modify it under the terms + * of the GNU Lesser General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with PCSX2. + * If not, see . + */ + +#pragma once + +namespace PacketReader +{ + class Payload + { + public: + virtual int GetLength() = 0; + virtual void WriteBytes(u8* buffer, int* offset) = 0; + virtual ~Payload() {} + }; + + //Pointer to bytes not owned by class + class PayloadPtr : public Payload + { + public: + u8* data; + + private: + int length; + + public: + PayloadPtr(u8* ptr, int len) + { + data = ptr; + length = len; + } + virtual int GetLength() + { + return length; + } + virtual void WriteBytes(u8* buffer, int* offset) + { + //If buffer & data point to the same location + //Then no copy is needed + if (data == buffer) + return; + + memcpy(buffer, data, length); + *offset += length; + } + }; +} // namespace PacketReader diff --git a/pcsx2/windows/VCprojects/pcsx2.vcxproj b/pcsx2/windows/VCprojects/pcsx2.vcxproj index 636516b172..7ec9ca74d7 100644 --- a/pcsx2/windows/VCprojects/pcsx2.vcxproj +++ b/pcsx2/windows/VCprojects/pcsx2.vcxproj @@ -286,6 +286,15 @@ + + + + + + + + + @@ -649,6 +658,19 @@ + + + + + + + + + + + + + diff --git a/pcsx2/windows/VCprojects/pcsx2.vcxproj.filters b/pcsx2/windows/VCprojects/pcsx2.vcxproj.filters index a5c4b9b71f..dcd53c890d 100644 --- a/pcsx2/windows/VCprojects/pcsx2.vcxproj.filters +++ b/pcsx2/windows/VCprojects/pcsx2.vcxproj.filters @@ -178,6 +178,21 @@ {9e9b52d7-7b1c-44b2-82d8-1e0d8085e7e0} + + {57c4be94-9a2c-469b-9b02-b3b324857fc5} + + + {a0723e13-c839-464d-8cfa-6c440ae03537} + + + {db2fc75d-6552-4991-9155-885abd8796e4} + + + {d426ae2b-9ad6-473d-adba-57b7bdac87db} + + + {229bf045-e378-4ec5-bdf8-43938762511e} + {df9de75c-2272-4f73-b2a0-4f9f492ba1e9} @@ -1090,6 +1105,33 @@ System\Ps2\DEV9 + + System\Ps2\DEV9\PacketReader\IP\UDP\DHCP + + + System\Ps2\DEV9\PacketReader\IP\UDP\DHCP + + + System\Ps2\DEV9\PacketReader\IP\UDP\DNS + + + System\Ps2\DEV9\PacketReader\IP\UDP\DNS + + + System\Ps2\DEV9\PacketReader\IP\UDP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader + + + System\Ps2\DEV9\PacketReader + System\Ps2\DEV9 @@ -1848,6 +1890,45 @@ System\Ps2\DEV9 + + System\Ps2\DEV9\PacketReader\IP\UDP\DHCP + + + System\Ps2\DEV9\PacketReader\IP\UDP\DHCP + + + System\Ps2\DEV9\PacketReader\IP\UDP\DNS + + + System\Ps2\DEV9\PacketReader\IP\UDP\DNS + + + System\Ps2\DEV9\PacketReader\IP\UDP\DNS + + + System\Ps2\DEV9\PacketReader\IP\UDP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader\IP + + + System\Ps2\DEV9\PacketReader + + + System\Ps2\DEV9\PacketReader + + + System\Ps2\DEV9\PacketReader + System\Ps2\DEV9