diff --git a/src/XDON-OG-RXDK/BKND.png b/src/XDON-OG-RXDK/BKND.png new file mode 100644 index 0000000..6dfe976 Binary files /dev/null and b/src/XDON-OG-RXDK/BKND.png differ diff --git a/src/XDON-OG-RXDK/Media/Copy Assets Here.txt b/src/XDON-OG-RXDK/Media/Copy Assets Here.txt new file mode 100644 index 0000000..e69de29 diff --git a/src/XDON-OG-RXDK/TitleImage.xbx b/src/XDON-OG-RXDK/TitleImage.xbx new file mode 100644 index 0000000..9f430da Binary files /dev/null and b/src/XDON-OG-RXDK/TitleImage.xbx differ diff --git a/src/XDON-OG-RXDK/XDON-OG-RXDK.sln b/src/XDON-OG-RXDK/XDON-OG-RXDK.sln new file mode 100644 index 0000000..5967785 --- /dev/null +++ b/src/XDON-OG-RXDK/XDON-OG-RXDK.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.12.35527.113 d17.12 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "XDON-RXDK", "XDON-RXDK.vcxproj", "{C441800D-77AC-4CB9-AACE-657EFED4A6E9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x86 = Debug|x86 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C441800D-77AC-4CB9-AACE-657EFED4A6E9}.Debug|x86.ActiveCfg = Debug|Win32 + {C441800D-77AC-4CB9-AACE-657EFED4A6E9}.Debug|x86.Build.0 = Debug|Win32 + {C441800D-77AC-4CB9-AACE-657EFED4A6E9}.Release|x86.ActiveCfg = Release|Win32 + {C441800D-77AC-4CB9-AACE-657EFED4A6E9}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/src/XDON-OG-RXDK/XDON-RXDK.vcxproj b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj new file mode 100644 index 0000000..c3c8a08 --- /dev/null +++ b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj @@ -0,0 +1,177 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + + + + + 16.0 + Win32Proj + {c441800d-77ac-4cb9-aace-657efed4a6e9} + XDON_RXDK + 10.0 + XDON-OG-RXDK + + + + Application + true + v142 + NotSet + + + Application + false + v142 + true + NotSet + + + + + + + + + + + + + + + $(RXDK_LIBS)include + $(RXDK_LIBS)include + + + $(CommonExcludePath);$(VC_ExecutablePath_x86);$(RXDK_LIBS)lib + $(RXDK_LIBS)lib + $(RXDK_LIBS)lib + $(ProjectDir)$(Configuration)\ + false + + + $(RXDK_LIBS)include + $(RXDK_LIBS)include + + + $(CommonExcludePath);$(VC_ExecutablePath_x86);$(RXDK_LIBS)lib + $(RXDK_LIBS)lib + $(RXDK_LIBS)lib + $(ProjectDir)$(Configuration)\ + false + + + + Level3 + false + XBOX;_XBOX;_DEBUG;%(PreprocessorDefinitions) + false + NotUsing + + + false + false + MultiThreaded + /Zc:sizedDealloc- /wd5040 /Zc:threadSafeInit- %(AdditionalOptions) + false + false + stdcpp17 + StreamingSIMDExtensions + Fast + + + Console + true + libcmtd.lib;libcpmtd.lib;xperf.lib;xbdm.lib;xapilibd.lib;d3d8d.lib;d3dx8d.lib;xgraphicsd.lib;dsoundd.lib;xnetd.lib;xboxkrnl.lib + true + + + + + true + false + false + + + Creating Xbox Image... + "$(RXDK_LIBS)bin\patchSubsystem.exe" -i="$(OutDir)$(TargetFileName)" -s=0x000E +"$(RXDK_LIBS)bin\imagebld.exe" /in:"$(OutDir)$(TargetFileName)" /out:"$(OutDir)$(TargetName).xbe" /nologo /stack:65536 /debug /nolibwarn /insertfile:"$(ProjectDir)BKND.png,BKND.png,R" /titleimage:"$(ProjectDir)TitleImage.xbx" /testid:"0x58444F4E" /testname:"XDON" +MKDIR "$(OutDir)Build\$(ProjectName)" +COPY /Y "$(OutDir)$(TargetName).xbe" "$(OutDir)Build\$(ProjectName)\default.xbe" +XCOPY /I /E /S /Y /F "$(ProjectDir)Media\*" "$(OutDir)Build\$(ProjectName)" +MKDIR "$(OutDir)XISO" +"$(RXDK_LIBS)bin\xdvdfs.exe" pack "$(OutDir)Build\$(ProjectName)" "$(OutDir)XISO\$(ProjectName).iso" + + + + + Level3 + true + true + false + XBOX;_XBOX;NDEBUG;%(PreprocessorDefinitions) + false + NotUsing + + + false + Sync + MultiThreaded + /arch:SSE %(AdditionalOptions) + false + stdcpp17 + StreamingSIMDExtensions + + + Console + true + true + true + xboxkrnl.lib;libcmt.lib;xapilib.lib;d3d8.lib;d3dx8.lib + true + + + + + true + false + false + + + Creating Xbox Image... + "$(RXDK_LIBS)bin\patchSubsystem.exe" -i="$(OutDir)$(TargetFileName)" -s=0x000E +"$(RXDK_LIBS)bin\imagebld.exe" /in:"$(OutDir)$(TargetFileName)" /out:"$(OutDir)$(TargetName).xbe" /nologo /stack:65536 /debug /nolibwarn +MKDIR "$(OutDir)Build\$(ProjectName)" +COPY /Y "$(OutDir)$(TargetName).xbe" "$(OutDir)Build\$(ProjectName)\default.xbe" +XCOPY /I /E /S /Y /F "$(ProjectDir)Media\*" "$(OutDir)Build\$(ProjectName)" +MKDIR "$(OutDir)XISO" +"$(RXDK_LIBS)bin\xdvdfs.exe" pack "$(OutDir)Build\$(ProjectName)" "$(OutDir)XISO\$(ProjectName).iso" + + + + + + + + This project requires Team Resurgent's XDK Libs installed on this computer. Search for them on http://www.theusualplaces.co.uk. + + + + \ No newline at end of file diff --git a/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.filters b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.filters new file mode 100644 index 0000000..6ba593f --- /dev/null +++ b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.filters @@ -0,0 +1,41 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + {fd94aff1-7048-4168-966a-088e42b11ed6} + + + + + Source Files + + + Source Files + + + + + Media + + + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.user b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/src/XDON-OG-RXDK/XDON-RXDK.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/src/XDON-OG-RXDK/XDON.cpp b/src/XDON-OG-RXDK/XDON.cpp new file mode 100644 index 0000000..07425ba --- /dev/null +++ b/src/XDON-OG-RXDK/XDON.cpp @@ -0,0 +1,1336 @@ +// Copyright © Eaton Works 2025. All rights reserved. +// License: https://github.com/EatonZ/XDON/blob/main/LICENSE + +#include "stdafx.h" +#include "XDON.h" + +#pragma region + +LPDIRECT3DDEVICE8 pd3dDevice; +LPDIRECT3DVERTEXBUFFER8 pVB; +LPDIRECT3DTEXTURE8 pTexture; +//Order must match DEVICE_INDEX_INTERNAL. +DEVICE_INFO devices[] = +{ + { "\\Device\\Harddisk0\\partition0", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\Harddisk1\\partition0", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_0", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_1", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_2", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_3", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_4", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_5", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_6", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\MU_7", INVALID_HANDLE_VALUE, NULL }, + { "\\Device\\CdRom0", INVALID_HANDLE_VALUE, NULL } +}; +BOOLEAN mountedMUs[] = +{ + { FALSE }, + { FALSE }, + { FALSE }, + { FALSE }, + { FALSE }, + { FALSE }, + { FALSE }, + { FALSE } +}; +const DWORD physicalMemoryAttributes = MAKE_XALLOC_ATTRIBUTES( + 0, //ObjectType + FALSE, //HeapTracksAttributes + FALSE, //MustSucceed + FALSE, //FixedSize + eXALLOCAllocatorId_GameMin, //AllocatorID + XALLOC_PHYSICAL_ALIGNMENT_4K, //Alignment + XALLOC_MEMPROTECT_READWRITE, //MemoryProtect + FALSE, //ZeroInitialize + XALLOC_MEMTYPE_PHYSICAL //MemoryType +); +const DWORD heapMemoryAttributes = MAKE_XALLOC_ATTRIBUTES( + 0, //ObjectType + FALSE, //HeapTracksAttributes + FALSE, //MustSucceed + FALSE, //FixedSize + eXALLOCAllocatorId_GameMin, //AllocatorID + XALLOC_ALIGNMENT_16, //Alignment + XALLOC_MEMPROTECT_READWRITE, //MemoryProtect + FALSE, //ZeroInitialize + XALLOC_MEMTYPE_HEAP //MemoryType +); +LPVOID sockDestroyBuffer = NULL; +#ifdef _DEBUG +BYTE verbositySetting = PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS | PRINT_VERBOSITY_FLAG_REQUESTS; +#else +BYTE verbositySetting = PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS; +#endif +//The reboot doesn't need to be done after writing to memory units because they will all be dismounted on exit. +BOOLEAN writeTookPlaceOnHDD = FALSE; + +#pragma endregion Defs + +#pragma region + +VOID Print(PRINT_VERBOSITY_FLAG Verbosity, const PCHAR Format, ...) +{ + if ((Verbosity & verbositySetting) != Verbosity) return; + + CHAR formatStr[200]; + va_list args; + va_start(args, Format); + vsprintf(formatStr, Format, args); + va_end(args); + + BOOLEAN am; + SYSTEMTIME time; + GetLocalTime(&time); + if (time.wHour > 12) + { + time.wHour = time.wHour - 12; + am = FALSE; + } + else if (time.wHour == 12) am = FALSE; + else + { + time.wHour = time.wHour == 0 ? 12 : time.wHour; + am = TRUE; + } + + DbgPrint("[%d/%d/%d %02d:%02d:%02d %s] %s\n", time.wMonth, time.wDay, time.wYear, time.wHour, time.wMinute, time.wSecond, am ? "AM" : "PM", formatStr); +} + +VOID FreeSocketThreadParam(PSOCKET_THREAD_PARAM ThreadParam) +{ + if (ThreadParam->Memories.RequestMemory != NULL) XMemFree(ThreadParam->Memories.RequestMemory, physicalMemoryAttributes); + if (ThreadParam->Memories.ResponseMemory != NULL) XMemFree(ThreadParam->Memories.ResponseMemory, physicalMemoryAttributes); + if (ThreadParam->Memories.ScratchMemory != NULL) XMemFree(ThreadParam->Memories.ScratchMemory, physicalMemoryAttributes); + XMemFree(ThreadParam, heapMemoryAttributes); +} + +PSOCKET_THREAD_PARAM CreateSocketThreadParam(SOCKET ClientSocket) +{ + PSOCKET_THREAD_PARAM socketThreadParam = (PSOCKET_THREAD_PARAM)XMemAlloc(sizeof(SOCKET_THREAD_PARAM), heapMemoryAttributes); + if (socketThreadParam == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to allocate memory for thread param."); + return NULL; + } + socketThreadParam->Memories.RequestMemory = XMemAlloc(REQUEST_MEMORY_SIZE, physicalMemoryAttributes); + if (socketThreadParam->Memories.RequestMemory == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to allocate request memory of size %d: %d", REQUEST_MEMORY_SIZE, GetLastError()); + FreeSocketThreadParam(socketThreadParam); + return NULL; + } + socketThreadParam->Memories.ResponseMemory = XMemAlloc(RESPONSE_MEMORY_SIZE, physicalMemoryAttributes); + if (socketThreadParam->Memories.ResponseMemory == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to allocate response memory of size %d: %d", RESPONSE_MEMORY_SIZE, GetLastError()); + FreeSocketThreadParam(socketThreadParam); + return NULL; + } + socketThreadParam->Memories.ScratchMemory = XMemAlloc(SCRATCH_MEMORY_SIZE, physicalMemoryAttributes); + if (socketThreadParam->Memories.ScratchMemory == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to allocate scratch memory of size %d: %d", SCRATCH_MEMORY_SIZE, GetLastError()); + FreeSocketThreadParam(socketThreadParam); + return NULL; + } + socketThreadParam->ClientSocket = ClientSocket; + return socketThreadParam; +} + +VOID MemSet(PVOID Dest, INT c, SIZE_T Count) +{ + memset(Dest, c, Count); +} + +VOID MemZero(PVOID Dest, SIZE_T Count) +{ + MemSet(Dest, 0, Count); +} + +VOID MemCpy(PVOID Dest, const PVOID Src, SIZE_T Count) +{ + memcpy(Dest, Src, Count); +} + +BOOLEAN MemIsEmpty(const PVOID Memory, SIZE_T Size) +{ + PBYTE ptr = (PBYTE)Memory; + while (Size > 0) + { + if (((SIZE_T)ptr & 7) == 0 && Size >= 8) + { + if (*(PULONGLONG)ptr != 0) return FALSE; + ptr += 8; + Size -= 8; + } + else + { + while (Size > 0) + { + if (*ptr != 0) return FALSE; + ptr++; + Size--; + //If Memory is unaligned to start, this helps get back on the fast track. + if (((SIZE_T)ptr & 7) == 0) break; + } + } + } + return TRUE; +} + +HANDLE OpenDisk(const PSZ Path, BOOLEAN ReadOnly) +{ + ANSI_STRING str; + RtlInitAnsiString(&str, Path); + + OBJECT_ATTRIBUTES oa; + InitializeObjectAttributes(&oa, &str, OBJ_CASE_INSENSITIVE, NULL, NULL); + + HANDLE handle; + IO_STATUS_BLOCK iosb; + //For disks, NtOpenFile must be used (CreateFile doesn't work). + NTSTATUS status = NtOpenFile(&handle, GENERIC_READ | (ReadOnly ? 0 : GENERIC_WRITE) | SYNCHRONIZE, &oa, &iosb, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SYNCHRONOUS_IO_NONALERT); + if (!NT_SUCCESS(status)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "OpenDisk (%s) failed: 0x%08X", Path, status); + return INVALID_HANDLE_VALUE; + } + else return handle; +} + +BOOLEAN GetDiskGeometry(HANDLE Handle, PDISK_GEOMETRY Geometry, BOOLEAN CDROM) +{ + IO_STATUS_BLOCK iosb; + NTSTATUS status = NtDeviceIoControlFile(Handle, NULL, NULL, NULL, &iosb, CDROM ? IOCTL_CDROM_GET_DRIVE_GEOMETRY : IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, Geometry, sizeof(DISK_GEOMETRY)); + if (!NT_SUCCESS(status)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "GetDiskGeometry failed: 0x%08X", status); + return FALSE; + } + else return TRUE; +} + +NTSTATUS ReadWriteDisk(DEVICE_INDEX_EXTERNAL ExternalDeviceIndex, LONGLONG Offset, ULONG Length, PVOID Buffer, BOOLEAN Write) +{ + //No need to validate the handle here; NtRead/WriteFile will return STATUS_INVALID_HANDLE (0xC0000008) if the client has specified a device index that is not connected. + + DEVICE_INDEX_INTERNAL internalDeviceIndex = (DEVICE_INDEX_INTERNAL)ExternalDeviceIndex; + IO_STATUS_BLOCK iosb; + LARGE_INTEGER offset; + offset.QuadPart = Offset; + NTSTATUS status = STATUS_SUCCESS; + + DWORD waitResult = WaitForSingleObject(devices[internalDeviceIndex].Mutex, INFINITE); + assert(waitResult == WAIT_OBJECT_0); + if (waitResult != WAIT_OBJECT_0) return devices[internalDeviceIndex].Mutex == NULL ? STATUS_INVALID_HANDLE : STATUS_UNSUCCESSFUL; + + if (Write) + { + status = NtWriteFile(devices[internalDeviceIndex].Handle, NULL, NULL, NULL, &iosb, Buffer, Length, &offset); + if (!NT_SUCCESS(status)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "WriteDisk (Offset=0x%016I64X, Length=0x%08X) failed: 0x%08X", offset.QuadPart, Length, status); + } + else + { + status = NtReadFile(devices[internalDeviceIndex].Handle, NULL, NULL, NULL, &iosb, Buffer, Length, &offset); + if (!NT_SUCCESS(status)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReadDisk (Offset=0x%016I64X, Length=0x%08X) failed: 0x%08X", offset.QuadPart, Length, status); + } + BOOL result = ReleaseMutex(devices[internalDeviceIndex].Mutex); + assert(result); + return status; +} + +VOID CheckMU(PHANDLE Handle, PBOOLEAN Availability, PDISK_GEOMETRY Geometry) +{ + *Availability = FALSE; + + if (*Handle == INVALID_HANDLE_VALUE) return; + + //Getting disk geometry is enough to determine whether a valid device is connected. + *Availability = GetDiskGeometry(*Handle, Geometry, FALSE); + if (!*Availability) + { + NtClose(*Handle); + *Handle = INVALID_HANDLE_VALUE; + } +} + +VOID Identify(PXDON_COMMAND_IDENTIFY_RESPONSE Response) +{ + MemZero(Response, sizeof(XDON_COMMAND_IDENTIFY_RESPONSE)); + + Response->XDONVersion = XDON_VERSION; + MemCpy(&Response->XboxVersion, XboxKrnlVersion, sizeof(XBOX_KRNL_VERSION)); + MemCpy(&Response->XboxHardwareInfo, XboxHardwareInfo, sizeof(XBOX_HARDWARE_INFO)); + + Response->MaxIOLength = MAX_IO_LENGTH; +} + +VOID GetDevices(PXDON_COMMAND_GET_DEVICES_RESPONSE Response) +{ + MemZero(Response, sizeof(XDON_COMMAND_GET_DEVICES_RESPONSE)); + + for (BYTE i = 0; i < ARRAYSIZE(devices); i++) + { + //Set up the mutexes. These prevent an issue where IO operations are ongoing and GetDevices is called. When that happens, the handles will be closed and result in errors. + if (devices[i].Mutex == NULL) + { + devices[i].Mutex = CreateMutex(NULL, TRUE, NULL); + assert(devices[i].Mutex != NULL); + //Fail will be checked for in ReadWriteDisk. + } + else + { + DWORD waitResult = WaitForSingleObject(devices[i].Mutex, INFINITE); + assert(waitResult == WAIT_OBJECT_0); + } + } + + OBJECT_STRING muName; + CHAR muNameBuffer[13]; + muName.Length = 0; + muName.MaximumLength = sizeof(muNameBuffer); + muName.Buffer = muNameBuffer; + for (BYTE i = 0; i < ARRAYSIZE(mountedMUs); i += 2) + { + //Refresh view of memory units. MU_CreateDeviceObject is used over XMountMU because XMountMU creates a title directory structure via XapiMapLetterToDirectory (don't want that). + if (mountedMUs[i]) + { + MU_CloseDeviceObject(i / 2, XDEVICE_TOP_SLOT); + mountedMUs[i] = FALSE; + } + mountedMUs[i] = NT_SUCCESS(MU_CreateDeviceObject(i / 2, XDEVICE_TOP_SLOT, &muName)); + + if (mountedMUs[i + 1]) + { + MU_CloseDeviceObject(i / 2, XDEVICE_BOTTOM_SLOT); + mountedMUs[i + 1] = FALSE; + } + mountedMUs[i + 1] = NT_SUCCESS(MU_CreateDeviceObject(i / 2, XDEVICE_BOTTOM_SLOT, &muName)); + } + + for (BYTE i = 0; i < ARRAYSIZE(devices); i++) + { + //Close any existing handles. + if (devices[i].Handle != INVALID_HANDLE_VALUE) + { + NtClose(devices[i].Handle); + devices[i].Handle = INVALID_HANDLE_VALUE; + } + + //Open fresh, new handles. + devices[i].Handle = OpenDisk(devices[i].Path, i == DEVICE_INDEX_INTERNAL_CDROM0); + } + + HANDLE handle = devices[DEVICE_INDEX_INTERNAL_HARDDISK0_PARTITION0].Handle; + if (handle != INVALID_HANDLE_VALUE) + { + Response->AvailableDevices.Harddisk0 = GetDiskGeometry(handle, &Response->Harddisk0Geometry, FALSE); + if (Response->AvailableDevices.Harddisk0) + { + ATA_PASS_THROUGH ataPT; + MemZero(&ataPT.IdeReg, sizeof(ataPT.IdeReg)); + ataPT.IdeReg.bCommandReg = IDE_COMMAND_IDENTIFY_DEVICE; + ataPT.DataBufferSize = sizeof(Response->Harddisk0Info); + ataPT.DataBuffer = &Response->Harddisk0Info; + + IO_STATUS_BLOCK iosb; + NTSTATUS status = NtDeviceIoControlFile(handle, NULL, NULL, NULL, &iosb, IOCTL_IDE_PASS_THROUGH, &ataPT, sizeof(ataPT), &ataPT, sizeof(ataPT)); + if (NT_SUCCESS(status)) Response->Harddisk0InfoAvailable = TRUE; + else Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to get Harddisk0 info: 0x%08X", status); + } + else + { + NtClose(handle); + devices[DEVICE_INDEX_INTERNAL_HARDDISK0_PARTITION0].Handle = INVALID_HANDLE_VALUE; + } + } + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Harddisk0 available: %s", Response->AvailableDevices.Harddisk0 ? "YES" : "NO"); + + handle = devices[DEVICE_INDEX_INTERNAL_HARDDISK1_PARTITION0].Handle; + if (handle != INVALID_HANDLE_VALUE) + { + Response->AvailableDevices.Harddisk1 = GetDiskGeometry(handle, &Response->Harddisk1Geometry, FALSE); + if (Response->AvailableDevices.Harddisk1) + { + ATA_PASS_THROUGH ataPT; + MemZero(&ataPT.IdeReg, sizeof(ataPT.IdeReg)); + ataPT.IdeReg.bCommandReg = IDE_COMMAND_IDENTIFY_DEVICE; + ataPT.DataBufferSize = sizeof(Response->Harddisk1Info); + ataPT.DataBuffer = &Response->Harddisk1Info; + + IO_STATUS_BLOCK iosb; + NTSTATUS status = NtDeviceIoControlFile(handle, NULL, NULL, NULL, &iosb, IOCTL_IDE_PASS_THROUGH, &ataPT, sizeof(ataPT), &ataPT, sizeof(ataPT)); + if (NT_SUCCESS(status)) Response->Harddisk1InfoAvailable = TRUE; + else Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Failed to get Harddisk1 info: 0x%08X", status); + } + else + { + NtClose(handle); + devices[DEVICE_INDEX_INTERNAL_HARDDISK1_PARTITION0].Handle = INVALID_HANDLE_VALUE; + } + } + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Harddisk1 available: %s", Response->AvailableDevices.Harddisk1 ? "YES" : "NO"); + + BOOLEAN availability; + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU0].Handle, &availability, &Response->Mu0Geometry); + Response->AvailableDevices.Mu0 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu0 available: %s", Response->AvailableDevices.Mu0 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU1].Handle, &availability, &Response->Mu1Geometry); + Response->AvailableDevices.Mu1 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu1 available: %s", Response->AvailableDevices.Mu1 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU2].Handle, &availability, &Response->Mu2Geometry); + Response->AvailableDevices.Mu2 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu2 available: %s", Response->AvailableDevices.Mu2 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU3].Handle, &availability, &Response->Mu3Geometry); + Response->AvailableDevices.Mu3 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu3 available: %s", Response->AvailableDevices.Mu3 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU4].Handle, &availability, &Response->Mu4Geometry); + Response->AvailableDevices.Mu4 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu4 available: %s", Response->AvailableDevices.Mu4 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU5].Handle, &availability, &Response->Mu5Geometry); + Response->AvailableDevices.Mu5 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu5 available: %s", Response->AvailableDevices.Mu5 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU6].Handle, &availability, &Response->Mu6Geometry); + Response->AvailableDevices.Mu6 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu6 available: %s", Response->AvailableDevices.Mu6 ? "YES" : "NO"); + + CheckMU(&devices[DEVICE_INDEX_INTERNAL_MU7].Handle, &availability, &Response->Mu7Geometry); + Response->AvailableDevices.Mu7 = availability; + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Mu7 available: %s", Response->AvailableDevices.Mu7 ? "YES" : "NO"); + + handle = devices[DEVICE_INDEX_INTERNAL_CDROM0].Handle; + if (handle != INVALID_HANDLE_VALUE) + { + Response->AvailableDevices.CdRom0 = GetDiskGeometry(handle, &Response->CdRom0Geometry, TRUE); + //SCSIOP_INQUIRY doesn't seem to work on OG Xbox (STATUS_INVALID_DEVICE_REQUEST), so there is no additional info to get like on Xbox 360. + if (!Response->AvailableDevices.CdRom0) + { + NtClose(handle); + devices[DEVICE_INDEX_INTERNAL_CDROM0].Handle = INVALID_HANDLE_VALUE; + } + } + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "CdRom0 available: %s", Response->AvailableDevices.CdRom0 ? "YES" : "NO"); + + for (BYTE i = 0; i < ARRAYSIZE(devices); i++) + { + if (devices[i].Mutex != NULL) + { + BOOL result = ReleaseMutex(devices[i].Mutex); + assert(result); + } + } +} + +VOID HalWriteSMCLEDStates(ULONG LEDStates) +{ + HalWriteSMBusByte(SMC_SLAVE_ADDRESS, SMC_COMMAND_LED_STATES, LEDStates); + HalWriteSMBusByte(SMC_SLAVE_ADDRESS, SMC_COMMAND_LED_OVERRIDE, SMC_LED_OVERRIDE_USE_REQUESTED_LED_STATES); +} + +#pragma endregion Utilities + +#pragma region + +VOID InitDisplay() +{ + //Big thanks to EqUiNoX for helping with this display code. + + HANDLE handle = XGetSectionHandle("BKND.png"); + if (handle == INVALID_HANDLE_VALUE) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "InitDisplay: No BKND.png section. Did you rename it?"); + return; + } + + DWORD imgSize = XGetSectionSize(handle); + assert(imgSize != 0); + PVOID img = XLoadSectionByHandle(handle); + assert(img != NULL); + + UINT width = 640; + UINT height = 480; + DWORD flags = 0; + DWORD videoFlags = XGetVideoFlags(); + if ((videoFlags & XC_VIDEO_FLAGS_HDTV_1080i) == XC_VIDEO_FLAGS_HDTV_1080i) + { + flags = D3DPRESENTFLAG_INTERLACED | D3DPRESENTFLAG_WIDESCREEN; + width = 1920; + height = 1080; + } + else if ((videoFlags & XC_VIDEO_FLAGS_HDTV_720p) == XC_VIDEO_FLAGS_HDTV_720p) + { + flags = D3DPRESENTFLAG_PROGRESSIVE | D3DPRESENTFLAG_WIDESCREEN; + width = 1280; + height = 720; + } + else if ((videoFlags & XC_VIDEO_FLAGS_HDTV_480p) == XC_VIDEO_FLAGS_HDTV_480p) flags = D3DPRESENTFLAG_PROGRESSIVE; + + D3DPRESENT_PARAMETERS d3dpp; + MemZero(&d3dpp, sizeof(d3dpp)); + d3dpp.BackBufferWidth = width; + d3dpp.BackBufferHeight = height; + d3dpp.BackBufferFormat = D3DFMT_LIN_R5G6B5; //D3DFMT_LIN_X8R8G8B8 will not work for 1080i (D3DXCreateTextureFromFileInMemory fails). D3DFMT_LIN_R5G6B5 is an acceptable fallback given what is being displayed. + d3dpp.Flags = flags; + d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE_OR_IMMEDIATE; + + HRESULT hr = Direct3DCreate8(D3D_SDK_VERSION)->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &pd3dDevice); + assert(!FAILED(hr)); + + hr = D3DXCreateTextureFromFileInMemory(pd3dDevice, img, imgSize, &pTexture); + assert(!FAILED(hr)); + + D3DXMATRIX matProj; + D3DXMatrixIdentity(&matProj); + hr = pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj); + assert(!FAILED(hr)); + + D3DXMATRIX matView; + D3DXMatrixIdentity(&matView); + hr = pd3dDevice->SetTransform(D3DTS_VIEW, &matView); + assert(!FAILED(hr)); + + D3DXMATRIX matWorld; + D3DXMatrixIdentity(&matWorld); + hr = pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld); + assert(!FAILED(hr)); + + VERTEX vertices[] = + { + { -1.0f, 1.0f, 0.0f, 0.0f, 0.0f }, + { 1.0f, 1.0f, 0.0f, 1.0f, 0.0f }, + { -1.0f, -1.0f, 0.0f, 0.0f, 1.0f }, + { 1.0f, 1.0f, 0.0f, 1.0f, 0.0f }, + { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f }, + { -1.0f, -1.0f, 0.0f, 0.0f, 1.0f } + }; + hr = pd3dDevice->CreateVertexBuffer(sizeof(vertices), 0, 0, 0, &pVB); + assert(!FAILED(hr)); + + PVERTEX pVertices; + hr = pVB->Lock(0, 0, (PBYTE*)&pVertices, 0); + assert(!FAILED(hr)); + memcpy(pVertices, vertices, sizeof(vertices)); + + hr = pVB->Unlock(); + assert(!FAILED(hr)); + + //On OG Xbox, we can get away with doing all this just once (no render loop). + if (pTexture == NULL) + { + //Display a red screen if the image failed to load (usually a memory issue) to encourage people to report it so it can be investigated. + hr = pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB(255, 0, 0), 1.0f, 0); + assert(!FAILED(hr)); + } + else + { + hr = pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); + assert(!FAILED(hr)); + hr = pd3dDevice->BeginScene(); + assert(!FAILED(hr)); + hr = pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); + assert(!FAILED(hr)); + hr = pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR); + assert(!FAILED(hr)); + hr = pd3dDevice->SetStreamSource(0, pVB, sizeof(VERTEX)); + assert(!FAILED(hr)); + hr = pd3dDevice->SetVertexShader(D3DFVF_XYZ | D3DFVF_TEX1); + assert(!FAILED(hr)); + hr = pd3dDevice->SetTexture(0, pTexture); + assert(!FAILED(hr)); + hr = pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2); + assert(!FAILED(hr)); + } + hr = pd3dDevice->Present(NULL, NULL, NULL, NULL); + assert(!FAILED(hr)); +} + +VOID UILoop() +{ + InitDisplay(); + + HANDLE controllers[] = + { + { INVALID_HANDLE_VALUE }, + { INVALID_HANDLE_VALUE }, + { INVALID_HANDLE_VALUE }, + { INVALID_HANDLE_VALUE } + }; + while (TRUE) + { + DWORD insertions; + DWORD removals; + if (XGetDeviceChanges(XDEVICE_TYPE_GAMEPAD, &insertions, &removals)) + { + for (BYTE i = 0; i < XGetPortCount(); i++) + { + DWORD mask = 1 << i; + if ((removals & mask) == mask) + { + if (controllers[i] != INVALID_HANDLE_VALUE) + { + XInputClose(controllers[i]); + controllers[i] = INVALID_HANDLE_VALUE; + } + } + if ((insertions & mask) == mask) controllers[i] = XInputOpen(XDEVICE_TYPE_GAMEPAD, i, XDEVICE_NO_SLOT, NULL); + } + } + + XINPUT_STATE state; + for (BYTE i = 0; i < XGetPortCount(); i++) + { + if (controllers[i] == INVALID_HANDLE_VALUE) continue; + + MemZero(&state, sizeof(state)); + if (XInputGetState(controllers[i], &state) == ERROR_SUCCESS) + { + if (state.Gamepad.bAnalogButtons[XINPUT_GAMEPAD_B] > XINPUT_GAMEPAD_MAX_CROSSTALK) + { + //Skeleton Key is a new device that came out in 2025 to make it easier for people to mod their Xboxes. They requested a cold reboot every time. + #ifdef _SKELETONKEY + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Cold rebooting."); + HalReturnToFirmware(HalRebootRoutine); + #else + if (writeTookPlaceOnHDD) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Cold rebooting since a disk write happened."); + HalReturnToFirmware(HalRebootRoutine); + } + else + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Rebooting to dashboard."); + LD_LAUNCH_DASHBOARD ld; + MemZero(&ld, sizeof(ld)); + ld.dwReason = XLD_LAUNCH_DASHBOARD_MAIN_MENU; + XLaunchNewImage(NULL, (PLAUNCH_DATA)&ld); + } + #endif + return; + } + } + } + } +} + +#pragma endregion Display / UI + +#pragma region + +BOOLEAN SockSetOptions(SOCKET Socket, BOOLEAN Reuse, BOOLEAN SetInsecure, BOOLEAN AllowBroadcast, INT SetTimeouts) +{ + INT setting; + + if (Reuse) + { + setting = 1; + if (setsockopt(Socket, SOL_SOCKET, SO_REUSEADDR, (const PCHAR)&setting, sizeof(setting)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockSetOptions (%X): setsockopt (SO_REUSEADDR) failed: %d", Socket, WSAGetLastError()); + return FALSE; + } + } + + //On OG Xbox, requires linkage with xonline.lib, else WSAENOPROTOOPT. When linking with xnet.lib, use XNET_STARTUP_BYPASS_SECURITY with XNetStartup instead. + if (SetInsecure) + { + setting = 1; + if (setsockopt(Socket, SOL_SOCKET, SO_INSECURE, (const PCHAR)&setting, sizeof(setting)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockSetOptions (%X): setsockopt (SO_INSECURE) failed: %d", Socket, WSAGetLastError()); + return FALSE; + } + } + + if (AllowBroadcast) + { + setting = 1; + if (setsockopt(Socket, SOL_SOCKET, SO_BROADCAST, (const PCHAR)&setting, sizeof(setting)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockSetOptions (%X): setsockopt (SO_BROADCAST) failed: %d", Socket, WSAGetLastError()); + return FALSE; + } + } + + if (SetTimeouts >= 0) + { + setting = SetTimeouts; + if (setsockopt(Socket, SOL_SOCKET, SO_SNDTIMEO, (const PCHAR)&setting, sizeof(setting)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockSetOptions (%X): setsockopt (SO_SNDTIMEO) failed: %d", Socket, WSAGetLastError()); + return FALSE; + } + + if (setsockopt(Socket, SOL_SOCKET, SO_RCVTIMEO, (const PCHAR)&setting, sizeof(setting)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockSetOptions (%X): setsockopt (SO_RCVTIMEO) failed: %d", Socket, WSAGetLastError()); + return FALSE; + } + } + + return TRUE; +} + +//Data2 is optional. +BOOLEAN SockSend(SOCKET Socket, const PVOID Data1, INT Data1Length, const PVOID Data2, INT Data2Length, const PSOCKADDR_IN To, INT ToLen) +{ + WSABUF wsaBufs[2]; + wsaBufs[0].len = Data1Length; + wsaBufs[0].buf = (PCHAR)Data1; + wsaBufs[1].len = Data2Length; + wsaBufs[1].buf = (PCHAR)Data2; + + //UDP packets larger than this won't be received. + if (To != NULL && Data1Length + Data2Length > 1472) Print(PRINT_VERBOSITY_FLAG_SOCK_SEND_RECV, "SockSend (%X): Large UDP send detected (%d). This likely won't be received by clients.", Socket, Data1Length + Data2Length); + + INT wsaBufCount = Data2 == NULL ? 1 : 2; + INT wsaBufIndex = 0; + DWORD dataSentTotal = 0; + while (wsaBufCount > 0) + { + DWORD dataSent; + INT err = WSASendTo(Socket, wsaBufs + wsaBufIndex, wsaBufCount, &dataSent, 0, (const sockaddr*)To, ToLen, NULL, NULL); + if (err == SOCKET_ERROR) return FALSE; + else dataSentTotal += dataSent; + Print(PRINT_VERBOSITY_FLAG_SOCK_SEND_RECV, "SockSend (%X): %d/%d (%d chunk)", Socket, dataSentTotal, Data1Length + Data2Length, dataSent); + while (dataSent > 0) + { + DWORD dataSentFromBuf = min(dataSent, wsaBufs[wsaBufIndex].len); + wsaBufs[wsaBufIndex].len -= dataSentFromBuf; + if (wsaBufs[wsaBufIndex].len == 0) + { + wsaBufCount--; + wsaBufIndex++; + } + else wsaBufs[wsaBufIndex].buf += dataSentFromBuf; + dataSent -= dataSentFromBuf; + } + } + return TRUE; +} + +BOOLEAN SockReceive(SOCKET Socket, PVOID DataOut, INT DataLength, PSOCKADDR_IN FromOut, PINT FromLenOut) +{ + INT totalRecv = 0; + INT dataOutOffset = 0; + while (totalRecv < DataLength) + { + INT recvLen = DataLength - totalRecv; + recvLen = recvfrom(Socket, (PCHAR)DataOut + dataOutOffset, recvLen, 0, (sockaddr*)FromOut, FromLenOut); + if (recvLen == SOCKET_ERROR) return FALSE; + if (recvLen == 0) + { + WSASetLastError(WSAECONNRESET); + return FALSE; + } + dataOutOffset += recvLen; + totalRecv += recvLen; + Print(PRINT_VERBOSITY_FLAG_SOCK_SEND_RECV, "SockReceive (%X): %d/%d (%d chunk)", Socket, totalRecv, DataLength, recvLen); + } + return totalRecv == DataLength; +} + +VOID SockDestroy(SOCKET Socket) +{ + if (shutdown(Socket, SD_SEND) == SOCKET_ERROR) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockDestroy (%X): shutdown failed: %d", Socket, WSAGetLastError()); + INT result = recv(Socket, (PCHAR)sockDestroyBuffer, SOCKET_BUFFER_SIZE, 0); + while (result != NO_ERROR && result != SOCKET_ERROR) result = recv(Socket, (PCHAR)sockDestroyBuffer, SOCKET_BUFFER_SIZE, 0); + if (closesocket(Socket) == SOCKET_ERROR) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SockDestroy (%X): closesocket failed: %d", Socket, WSAGetLastError()); +} + +#pragma endregion Sockets + +#pragma region + +BOOLEAN InitNetwork() +{ + XNetStartupParams xnsp; + MemZero(&xnsp, sizeof(xnsp)); + xnsp.cfgSizeOfStruct = sizeof(xnsp); + xnsp.cfgFlags = XNET_STARTUP_BYPASS_SECURITY; //Equivalent to setsockopt with SO_INSECURE. + xnsp.cfgSockDefaultRecvBufsizeInK = SOCKET_BUFFER_SIZE / 0x400; //Equivalent to setsockopt with SO_RCVBUF. + xnsp.cfgSockDefaultSendBufsizeInK = SOCKET_BUFFER_SIZE / 0x400; //Equivalent to setsockopt with SO_SNDBUF. + INT result = XNetStartup(&xnsp); + if (result != NO_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "InitNetwork: XNetStartup failed: %d", result); + return FALSE; + } + + WSADATA wsaData; + result = WSAStartup(WINSOCK_VERSION, &wsaData); + if (result != NO_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "InitNetwork: WSAStartup failed: %d", result); + XNetCleanup(); + return FALSE; + } + + return TRUE; +} + +VOID FulfillRequest(PSOCKET_THREAD_PARAM ThreadParam, const PSOCKADDR_IN To, INT ToLen, XDON_COMMAND CommandID) +{ + XDON_COMMAND_RESPONSE_FRAME frame; + frame.Identifier = RESPONSE_FRAME_IDENTIFIER; + frame.Version = PROTOCOL_VERSION; + frame.ConsoleType = CONSOLE_TYPE; + switch (CommandID) + { + case XDON_COMMAND_IDENTIFY: + { + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_IDENTIFY.", ThreadParam->ClientSocket); + XDON_COMMAND_IDENTIFY_RESPONSE response; + Identify(&response); + frame.StatusCode = STATUS_SUCCESS; + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), &response, sizeof(response), To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_GET_DEVICES: + { + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_GET_DEVICES.", ThreadParam->ClientSocket); + XDON_COMMAND_GET_DEVICES_RESPONSE response; + GetDevices(&response); + frame.StatusCode = STATUS_SUCCESS; + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), &response, sizeof(response), To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_READ: + { + PXDON_COMMAND_READ_REQUEST request = (PXDON_COMMAND_READ_REQUEST)ThreadParam->Memories.RequestMemory; + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_READ (DeviceIndex=%d, Offset=0x%016I64X, Length=0x%08X, CompressResponseData=%d).", ThreadParam->ClientSocket, request->DeviceIndex, request->Offset, request->Length, request->CompressResponseData); + PXDON_COMMAND_READ_RESPONSE response = (PXDON_COMMAND_READ_RESPONSE)ThreadParam->Memories.ResponseMemory; + + frame.StatusCode = ReadWriteDisk((DEVICE_INDEX_EXTERNAL)request->DeviceIndex, request->Offset, request->Length, request->CompressResponseData ? ThreadParam->Memories.ScratchMemory : response->Data, FALSE); + + INT responseDataLength = 0; + if (NT_SUCCESS(frame.StatusCode)) + { + response->DataLength = MemIsEmpty(request->CompressResponseData ? ThreadParam->Memories.ScratchMemory : response->Data, request->Length) ? 0 : request->Length; + response->UncompressedDataLength = response->DataLength; + if (response->DataLength == 0) Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): MemIsEmpty=TRUE", ThreadParam->ClientSocket); + else if (request->CompressResponseData) + { + //The LZ4 code won't compile on OG right now. + frame.StatusCode = STATUS_NOT_SUPPORTED; + } + responseDataLength = frame.StatusCode == STATUS_NOT_SUPPORTED ? 0 : sizeof(XDON_COMMAND_READ_RESPONSE) + response->DataLength; + } + else Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): No response to send due to error.", ThreadParam->ClientSocket); + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), responseDataLength == 0 ? NULL : response, responseDataLength, To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_WRITE: + { + PXDON_COMMAND_WRITE_REQUEST request = (PXDON_COMMAND_WRITE_REQUEST)ThreadParam->Memories.RequestMemory; + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_WRITE (DeviceIndex=%d, Offset=0x%016I64X, DataLength=0x%08X, DataIsCompressed=%d).", ThreadParam->ClientSocket, request->DeviceIndex, request->Offset, request->DataLength, request->DataIsCompressed); + + if (request->DataIsCompressed) + { + //The LZ4 code won't compile on OG right now. + frame.StatusCode = STATUS_NOT_SUPPORTED; + } + else frame.StatusCode = ReadWriteDisk((DEVICE_INDEX_EXTERNAL)request->DeviceIndex, request->Offset, request->DataLength, request->Data, TRUE); + + writeTookPlaceOnHDD = NT_SUCCESS(frame.StatusCode) && ((DEVICE_INDEX_EXTERNAL)request->DeviceIndex == DEVICE_INDEX_EXTERNAL_HARDDISK0 || (DEVICE_INDEX_EXTERNAL)request->DeviceIndex == DEVICE_INDEX_EXTERNAL_HARDDISK1); + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), NULL, 0, To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response frame: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_WRITE_SAME: + { + PXDON_COMMAND_WRITE_SAME_REQUEST request = (PXDON_COMMAND_WRITE_SAME_REQUEST)ThreadParam->Memories.RequestMemory; + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_WRITE_SAME (DeviceIndex=%d, Offset=0x%016I64X, Length=0x%08X, Value=0x%02X).", ThreadParam->ClientSocket, request->DeviceIndex, request->Offset, request->Length, request->Value); + + MemSet(ThreadParam->Memories.ScratchMemory, request->Value, request->Length); + frame.StatusCode = ReadWriteDisk((DEVICE_INDEX_EXTERNAL)request->DeviceIndex, request->Offset, request->Length, ThreadParam->Memories.ScratchMemory, TRUE); + + writeTookPlaceOnHDD = NT_SUCCESS(frame.StatusCode) && ((DEVICE_INDEX_EXTERNAL)request->DeviceIndex == DEVICE_INDEX_EXTERNAL_HARDDISK0 || (DEVICE_INDEX_EXTERNAL)request->DeviceIndex == DEVICE_INDEX_EXTERNAL_HARDDISK1); + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), NULL, 0, To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response frame: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_ATA_CUSTOM_COMMAND: + { + PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST request = (PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST)ThreadParam->Memories.RequestMemory; + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_ATA_CUSTOM_COMMAND (Registers=%02X %02X %02X %02X %02X %02X %02X %02X, DataInOutSize=0x%08X).", ThreadParam->ClientSocket, request->Registers.bFeaturesReg, request->Registers.bSectorCountReg, request->Registers.bSectorNumberReg, request->Registers.bCylLowReg, request->Registers.bCylHighReg, request->Registers.bDriveHeadReg, request->Registers.bCommandReg, request->Registers.bHostSendsData, request->DataInOutSize); + BOOLEAN dataOut = request->Registers.bHostSendsData; + PXDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE response = (PXDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE)ThreadParam->Memories.ResponseMemory; + + ATA_PASS_THROUGH ataPT; + MemCpy(&ataPT.IdeReg, &request->Registers, sizeof(request->Registers)); + ataPT.DataBufferSize = request->DataInOutSize; + ataPT.DataBuffer = dataOut ? request->DataOut : response->DataIn; + + IO_STATUS_BLOCK iosb; + frame.StatusCode = NtDeviceIoControlFile(devices[DEVICE_INDEX_INTERNAL_HARDDISK0_PARTITION0].Handle, NULL, NULL, NULL, &iosb, IOCTL_IDE_PASS_THROUGH, &ataPT, sizeof(ataPT), &ataPT, sizeof(ataPT)); + + INT responseDataLength = 0; + if (NT_SUCCESS(frame.StatusCode)) + { + MemCpy(&response->Registers, &ataPT.IdeReg, sizeof(ataPT.IdeReg)); + responseDataLength = sizeof(XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE) + (dataOut ? 0 : request->DataInOutSize); + } + else Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): No response to send due to error.", ThreadParam->ClientSocket); + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), responseDataLength == 0 ? NULL : response, responseDataLength, To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + break; + } + case XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE: + { + PXDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST request = (PXDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST)ThreadParam->Memories.RequestMemory; + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Fulfilling XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE.", ThreadParam->ClientSocket); + frame.StatusCode = STATUS_SUCCESS; + + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), NULL, 0, To, ToLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "FulfillRequest (%X): Failed to send response: %d", ThreadParam->ClientSocket, WSAGetLastError()); + + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "FulfillRequest (%X): Executing routine %d right now.", ThreadParam->ClientSocket, request->Routine); + //Let's use max to determine whether to shutdown. There is no other valid use for it so we can use it to keep the command the same as the Xbox 360 version. + if ((FIRMWARE_REENTRY)request->Routine == HalMaximumRoutine) HalInitiateShutdown(); + else HalReturnToFirmware((FIRMWARE_REENTRY)request->Routine); + + break; + } + } +} + +NTSTATUS ReceiveAndValidateRequest(PSOCKET_THREAD_PARAM ThreadParam, PSOCKADDR_IN FromOut, PINT FromLenOut, PXDON_COMMAND CommandIDOut) +{ + //First, read the frame. + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): Awaiting frame...", ThreadParam->ClientSocket); + XDON_COMMAND_REQUEST_FRAME frame; + if (!SockReceive(ThreadParam->ClientSocket, &frame, sizeof(frame), FromOut, FromLenOut)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Request frame not received: %d", ThreadParam->ClientSocket, WSAGetLastError()); + return STATUS_UNSUCCESSFUL; + } + else + { + if (frame.Identifier != REQUEST_FRAME_IDENTIFIER) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Non-XDON data received; ignoring.", ThreadParam->ClientSocket); + return STATUS_NOT_SUPPORTED; + } + if (frame.Version != PROTOCOL_VERSION) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Protocol version mismatch (received=%d, supported=%d).", ThreadParam->ClientSocket, frame.Version, PROTOCOL_VERSION); + return STATUS_NOT_SUPPORTED; + } + else *CommandIDOut = (XDON_COMMAND)frame.CommandID; + } + + if (FromOut != NULL && frame.CommandID != XDON_COMMAND_IDENTIFY) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Only XDON_COMMAND_IDENTIFY can be handled over UDP.", ThreadParam->ClientSocket); + return STATUS_NOT_SUPPORTED; + } + + INT requestSize; + switch (frame.CommandID) + { + case XDON_COMMAND_IDENTIFY: + { + requestSize = 0; //sizeof(XDON_COMMAND_IDENTIFY_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_IDENTIFY frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_GET_DEVICES: + { + requestSize = 0; //sizeof(XDON_COMMAND_GET_DEVICES_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_GET_DEVICES frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_READ: + { + requestSize = sizeof(XDON_COMMAND_READ_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_READ frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_WRITE: + { + requestSize = sizeof(XDON_COMMAND_WRITE_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_WRITE frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_WRITE_SAME: + { + requestSize = sizeof(XDON_COMMAND_WRITE_SAME_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_WRITE_SAME frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_ATA_CUSTOM_COMMAND: + { + requestSize = sizeof(XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_ATA_CUSTOM_COMMAND frame received.", ThreadParam->ClientSocket); + break; + } + case XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE: + { + requestSize = sizeof(XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST); + Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE frame received.", ThreadParam->ClientSocket); + break; + } + default: + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Frame received, but command ID %d not recognized.", ThreadParam->ClientSocket, frame.CommandID); + return STATUS_INVALID_PARAMETER; + } + } + + if (requestSize > 0) + { + //Second, read the request (the part after the frame). + if (!SockReceive(ThreadParam->ClientSocket, ThreadParam->Memories.RequestMemory, requestSize, FromOut, FromLenOut)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Request not received: %d", ThreadParam->ClientSocket, WSAGetLastError()); + return STATUS_UNSUCCESSFUL; + } + else Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): Request received.", ThreadParam->ClientSocket); + } + else Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): No request to receive.", ThreadParam->ClientSocket); + + //Third, validate the request and read any variable-length request data. + switch (frame.CommandID) + { + case XDON_COMMAND_IDENTIFY: + case XDON_COMMAND_GET_DEVICES: goto successExit; + case XDON_COMMAND_READ: + { + PXDON_COMMAND_READ_REQUEST readRequest = (PXDON_COMMAND_READ_REQUEST)ThreadParam->Memories.RequestMemory; + //Let NtReadFile do the offset check. + if (readRequest->DeviceIndex >= DEVICE_INDEX_EXTERNAL_MAX || readRequest->Length == 0 || readRequest->Length > MAX_IO_LENGTH) goto validationFailExit; + else goto successExit; + } + case XDON_COMMAND_WRITE: + { + PXDON_COMMAND_WRITE_REQUEST writeRequest = (PXDON_COMMAND_WRITE_REQUEST)ThreadParam->Memories.RequestMemory; + //Let NtWriteFile do the offset check. + if (writeRequest->DeviceIndex >= DEVICE_INDEX_EXTERNAL_MAX || writeRequest->DataLength == 0 || writeRequest->DataLength > (writeRequest->DataIsCompressed ? (UINT)MAX_COMPRESSION_LENGTH : MAX_IO_LENGTH)) goto validationFailExit; + else + { + if (!SockReceive(ThreadParam->ClientSocket, ((PXDON_COMMAND_WRITE_REQUEST)ThreadParam->Memories.RequestMemory)->Data, writeRequest->DataLength, FromOut, FromLenOut)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Request data not received: %d", ThreadParam->ClientSocket, WSAGetLastError()); + return STATUS_UNSUCCESSFUL; + } + + goto successExit; + } + } + case XDON_COMMAND_WRITE_SAME: + { + PXDON_COMMAND_WRITE_SAME_REQUEST writeSameRequest = (PXDON_COMMAND_WRITE_SAME_REQUEST)ThreadParam->Memories.RequestMemory; + //Let NtWriteFile do the offset check. + if (writeSameRequest->DeviceIndex >= DEVICE_INDEX_EXTERNAL_MAX || writeSameRequest->Length == 0 || writeSameRequest->Length > MAX_IO_LENGTH) goto validationFailExit; + else goto successExit; + } + case XDON_COMMAND_ATA_CUSTOM_COMMAND: + { + PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST ataCustomCommandRequest = (PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST)ThreadParam->Memories.RequestMemory; + if (ataCustomCommandRequest->DataInOutSize > MAX_IO_LENGTH) goto validationFailExit; + if (ataCustomCommandRequest->Registers.bHostSendsData && ataCustomCommandRequest->DataInOutSize > 0) + { + if (!SockReceive(ThreadParam->ClientSocket, ((PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST)ThreadParam->Memories.RequestMemory)->DataOut, ataCustomCommandRequest->DataInOutSize, FromOut, FromLenOut)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Request data not received: %d", ThreadParam->ClientSocket, WSAGetLastError()); + return STATUS_UNSUCCESSFUL; + } + } + goto successExit; + } + case XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE: goto successExit; //Let HalReturnToFirmware do the routine check. + default: goto validationFailExit; + } + + validationFailExit: + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ReceiveAndValidateRequest (%X): Request failed validation.", ThreadParam->ClientSocket); + return STATUS_INVALID_PARAMETER; + + successExit: + if (requestSize > 0) Print(PRINT_VERBOSITY_FLAG_REQUESTS, "ReceiveAndValidateRequest (%X): Request passed validation.", ThreadParam->ClientSocket); + return STATUS_SUCCESS; +} + +VOID TCPSocketThread(PSOCKET_THREAD_PARAM ThreadParam) +{ + while (TRUE) + { + XDON_COMMAND commandID = XDON_COMMAND_UNKNOWN; + NTSTATUS status = ReceiveAndValidateRequest(ThreadParam, NULL, NULL, &commandID); + if (!NT_SUCCESS(status)) + { + //If validation failed due to a network error, do not send anything because it's pointless. + if (WSAGetLastError() == NO_ERROR) + { + XDON_COMMAND_RESPONSE_FRAME frame; + frame.Identifier = RESPONSE_FRAME_IDENTIFIER; + frame.Version = PROTOCOL_VERSION; + frame.ConsoleType = CONSOLE_TYPE; + frame.StatusCode = status; + if (!SockSend(ThreadParam->ClientSocket, &frame, sizeof(frame), NULL, 0, NULL, 0)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SocketThread (TCP/%X): Failed to send validation failure response frame: %d", ThreadParam->ClientSocket, WSAGetLastError()); + } + } + else FulfillRequest(ThreadParam, NULL, 0, commandID); + if (WSAGetLastError() == WSAECONNRESET) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SocketThread (TCP/%X): Connection reset by peer; exiting.", ThreadParam->ClientSocket); + SockDestroy(ThreadParam->ClientSocket); + break; + } + } + + FreeSocketThreadParam(ThreadParam); + + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "SocketThread (TCP/%X): Thread is exiting.", ThreadParam->ClientSocket); +} + +VOID ServerMain() +{ + sockDestroyBuffer = XMemAlloc(SOCKET_BUFFER_SIZE, heapMemoryAttributes); + if (sockDestroyBuffer == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: Failed to allocate memory for socket destroy buffer."); + return; + } + + SOCKET serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + if (serverSocket == INVALID_SOCKET) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: socket failed: %d", WSAGetLastError()); + return; + } + + if (!SockSetOptions(serverSocket, TRUE, FALSE, FALSE, -1)) return; + + SOCKADDR_IN serverEndpoint; + MemZero(&serverEndpoint, sizeof(serverEndpoint)); + serverEndpoint.sin_family = AF_INET; + serverEndpoint.sin_port = htons(PC_COMMUNICATION_PORT); + serverEndpoint.sin_addr.s_addr = INADDR_ANY; + if (bind(serverSocket, (const sockaddr*)&serverEndpoint, sizeof(serverEndpoint)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: bind failed: %d", WSAGetLastError()); + return; + } + + if (listen(serverSocket, SOMAXCONN) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: listen failed: %d", WSAGetLastError()); + return; + } + + //Also set up identification answering socket. + SOCKET idServerSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (idServerSocket == INVALID_SOCKET) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: socket failed: %d", WSAGetLastError()); + return; + } + + if (!SockSetOptions(idServerSocket, TRUE, FALSE, TRUE, -1)) return; + + if (bind(idServerSocket, (const sockaddr*)&serverEndpoint, sizeof(serverEndpoint)) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: bind failed: %d", WSAGetLastError()); + return; + } + + HANDLE uiLoopThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)UILoop, NULL, 0, NULL); + if (uiLoopThread == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: CreateThread (UILoop) failed: %d", GetLastError()); + return; + } + CloseHandle(uiLoopThread); + + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: ***READY***"); + + fd_set rfds; + while (TRUE) + { + FD_ZERO(&rfds); + FD_SET(serverSocket, &rfds); + FD_SET(idServerSocket, &rfds); + + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: Awaiting a new TCP client or UDP packet..."); + if (select(0, &rfds, NULL, NULL, NULL) == SOCKET_ERROR) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain: select failed: %d; starting over.", WSAGetLastError()); + continue; + } + else if (FD_ISSET(serverSocket, &rfds)) + { + SOCKET clientSocket = accept(serverSocket, NULL, NULL); + if (clientSocket != INVALID_SOCKET) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): TCP client connected!"); + if (SockSetOptions(clientSocket, FALSE, FALSE, FALSE, SOCKET_TIMEOUT)) + { + PSOCKET_THREAD_PARAM socketThreadParam = CreateSocketThreadParam(clientSocket); + if (socketThreadParam == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): Failed to allocate memory; starting over."); + SockDestroy(clientSocket); + } + else + { + HANDLE thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TCPSocketThread, socketThreadParam, 0, NULL); + if (thread == NULL) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): CreateThread (SocketThread) failed: %d; starting over.", GetLastError()); + SockDestroy(clientSocket); + } + else + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): Thread started to handle socket %X; starting over.", clientSocket); + //Priority needs to be bumped up or else performance will be really bad! + SetThreadPriority(thread, THREAD_PRIORITY_ABOVE_NORMAL); + CloseHandle(thread); + } + } + } + else + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): Socket options problem with the client; starting over."); + SockDestroy(clientSocket); + } + } + else Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (TCP): accept failed: %d", WSAGetLastError()); + } + else if (FD_ISSET(idServerSocket, &rfds)) + { + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (UDP): Handling a UDP packet."); + //Reset the error for a fresh start in case something failed before. + WSASetLastError(NO_ERROR); + SOCKADDR_IN from; + INT fromLen = sizeof(from); + XDON_COMMAND commandID = XDON_COMMAND_UNKNOWN; + SOCKET_THREAD_PARAM socketThreadParam; + //Don't need to set Memories because this is only used for XDON_COMMAND_IDENTIFY, which does not need those allocations. + socketThreadParam.ClientSocket = idServerSocket; + NTSTATUS status = ReceiveAndValidateRequest(&socketThreadParam, &from, &fromLen, &commandID); + if (!NT_SUCCESS(status)) + { + XDON_COMMAND_RESPONSE_FRAME frame; + frame.Identifier = RESPONSE_FRAME_IDENTIFIER; + frame.Version = PROTOCOL_VERSION; + frame.ConsoleType = CONSOLE_TYPE; + frame.StatusCode = status; + if (!SockSend(idServerSocket, &frame, sizeof(frame), NULL, 0, &from, fromLen)) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (UDP): Failed to send validation failure response frame: %d", WSAGetLastError()); + } + else FulfillRequest(&socketThreadParam, &from, fromLen, commandID); + if (WSAGetLastError() != NO_ERROR) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "ServerMain (UDP): Connection problem detected with the UDP send."); + } + } +} + +#pragma endregion Network + +VOID __cdecl main() +{ + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "XDON - Xbox Disk Over Network"); + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Created by Eaton"); + #ifdef _DEBUG + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Version: %d Debug, built: %s %s", XDON_VERSION, __DATE__, __TIME__); + #else + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Version: %d Release, built: %s %s", XDON_VERSION, __DATE__, __TIME__); + #endif + + XDEVICE_PREALLOC_TYPE deviceTypes[] = + { + { XDEVICE_TYPE_MEMORY_UNIT, XGetPortCount() * 2 }, + { XDEVICE_TYPE_GAMEPAD, XGetPortCount() } + }; + XInitDevices(ARRAYSIZE(deviceTypes), deviceTypes); + + //Disable the Auto-Off feature to avoid unintended shutdowns. The next title will reinitialize it, so we don't have to change it back on exit. + XapiAutoPowerDownGlobals.fAutoPowerDown = FALSE; + + if (!InitNetwork()) + { + HalWriteSMCLEDStates(SMC_LED_STATES_RED_STATE0 | SMC_LED_STATES_RED_STATE2); + goto failExit; + } + + DWORD linkStatus = XNetGetEthernetLinkStatus(); + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "XNetGetEthernetLinkStatus: %d", linkStatus); + if (linkStatus == 0) + { + HalWriteSMCLEDStates(SMC_LED_STATES_GREEN_STATE0 | SMC_LED_STATES_GREEN_STATE2); + goto failExit; + } + else if ((linkStatus & XNET_ETHERNET_LINK_10MBPS) == XNET_ETHERNET_LINK_10MBPS) Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "Slow ethernet link detected."); + + XNADDR localAddr; + DWORD status = XNetGetTitleXnAddr(&localAddr); + while (status == XNET_GET_XNADDR_PENDING) + { + Sleep(100); + status = XNetGetTitleXnAddr(&localAddr); + } + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "XNetGetTitleXnAddr: %d", status); + if ((status & XNET_GET_XNADDR_NONE) == XNET_GET_XNADDR_NONE || (status & XNET_GET_XNADDR_TROUBLESHOOT) == XNET_GET_XNADDR_TROUBLESHOOT) + { + HalWriteSMCLEDStates(SMC_LED_STATES_GREEN_STATE0 | SMC_LED_STATES_GREEN_STATE2); + goto failExit; + } + Print(PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS, "IP Address: %d.%d.%d.%d", localAddr.ina.S_un.S_un_b.s_b1, localAddr.ina.S_un.S_un_b.s_b2, localAddr.ina.S_un.S_un_b.s_b3, localAddr.ina.S_un.S_un_b.s_b4); + + //Get devices at the start to set everything up for potential cases where the GetDevices command is not sent first by clients. + XDON_COMMAND_GET_DEVICES_RESPONSE tmp; + GetDevices(&tmp); + + ServerMain(); + + //ServerMain loops forever, so if we get here, it has failed and we cannot continue. + HalWriteSMCLEDStates(SMC_LED_STATES_RED_STATE0 | SMC_LED_STATES_RED_STATE2); + failExit: + Sleep(3000); + //The Original Xbox doesn't like returns from main, so get out this way. + #ifdef _SKELETONKEY + HalReturnToFirmware(HalRebootRoutine); + #else + LD_LAUNCH_DASHBOARD ld; + MemZero(&ld, sizeof(ld)); + ld.dwReason = XLD_LAUNCH_DASHBOARD_MAIN_MENU; + XLaunchNewImage(NULL, (PLAUNCH_DATA)&ld); + #endif +} \ No newline at end of file diff --git a/src/XDON-OG-RXDK/XDON.h b/src/XDON-OG-RXDK/XDON.h new file mode 100644 index 0000000..6cbf6b0 --- /dev/null +++ b/src/XDON-OG-RXDK/XDON.h @@ -0,0 +1,278 @@ +// Copyright © Eaton Works 2025. All rights reserved. +// License: https://github.com/EatonZ/XDON/blob/main/LICENSE + +#pragma once + +#pragma region + +//3 memory buffers get allocated at startup. +//The 0x1000 is to account for request and response structs before any variable-length data. Frames are not part of this. +#define MAX_IO_LENGTH 1048576 //When doing a single IO operation, 1 MB has proven to be the sweet spot. If you want to go higher, you can change this, but it won't be any faster. +#define MAX_COMPRESSION_LENGTH MAX_IO_LENGTH //The LZ4 code won't compile on OG right now. +#define REQUEST_MEMORY_SIZE MAX_COMPRESSION_LENGTH + 0x1000 //Used to read the request and any variable-length request data. +#define RESPONSE_MEMORY_SIZE MAX_COMPRESSION_LENGTH + 0x1000 //Used to prepare responses with variable-length response data. +#define SCRATCH_MEMORY_SIZE MAX_IO_LENGTH //Used for anything. + +#define CONSOLE_TYPE 0 //0=OG Xbox +#define PC_COMMUNICATION_PORT 1000 //Why port 1000? Look here: https://i.imgur.com/ElBjYm7.png +#define SOCKET_BUFFER_SIZE 0x4000 //Currently the Xbox default. Not really any benefit to changing based on our testing. +#define SOCKET_TIMEOUT 0 //Timeout for TCP SO_SNDTIMEO and SO_RCVTIMEO. +#define REQUEST_FRAME_IDENTIFIER 0x58444F4E52455155 //XDONREQU +#define RESPONSE_FRAME_IDENTIFIER 0x58444F4E52455350 //XDONRESP +#define PROTOCOL_VERSION 1 //Increase when a breaking change is made to the protocol. +#define XDON_VERSION 1 //Keep this in sync with XBE Version. + +//Must keep in sync with XDON clients. +#define XDON_COMMAND_REQUEST_FRAME_SIZE 0xA +#define XDON_COMMAND_RESPONSE_FRAME_SIZE 0xE +#define XDON_COMMAND_IDENTIFY_RESPONSE_SIZE 0x15 +#define XDON_COMMAND_GET_DEVICES_RESPONSE_SIZE 0x50C +#define XDON_COMMAND_READ_REQUEST_SIZE 0xE +#define XDON_COMMAND_READ_RESPONSE_SIZE 8 +#define XDON_COMMAND_WRITE_REQUEST_SIZE 0xE +#define XDON_COMMAND_WRITE_SAME_REQUEST_SIZE 0xE +#define XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST_SIZE 0xC +#define XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE_SIZE 8 +#define XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST_SIZE 1 + +#pragma endregion Defs + +#pragma region + +typedef enum _PRINT_VERBOSITY_FLAG { + PRINT_VERBOSITY_FLAG_ESSENTIAL_AND_ERRORS = 1, //Print essential messages about XDON operation the user will want to see. + PRINT_VERBOSITY_FLAG_REQUESTS = 2, //Print informational messages from FulfillRequest and ReceiveAndValidateRequest. A little noisy. + PRINT_VERBOSITY_FLAG_SOCK_SEND_RECV = 4 //Enable printing in SockSend and SockReceive. Very noisy! +} PRINT_VERBOSITY_FLAG, *PPRINT_VERBOSITY_FLAG; + +typedef enum _XDON_COMMAND { + XDON_COMMAND_UNKNOWN = 0, + XDON_COMMAND_IDENTIFY = 1, + XDON_COMMAND_GET_DEVICES = 2, + XDON_COMMAND_READ = 3, + XDON_COMMAND_WRITE = 4, + XDON_COMMAND_WRITE_SAME = 5, + XDON_COMMAND_ATA_CUSTOM_COMMAND = 6, + XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE = 7, + XDON_COMMAND_MAX = 8 +} XDON_COMMAND, *PXDON_COMMAND; + +//For internal use. +typedef enum _DEVICE_INDEX_INTERNAL { + DEVICE_INDEX_INTERNAL_HARDDISK0_PARTITION0 = 0, + DEVICE_INDEX_INTERNAL_HARDDISK1_PARTITION0 = 1, + DEVICE_INDEX_INTERNAL_MU0 = 2, + DEVICE_INDEX_INTERNAL_MU1 = 3, + DEVICE_INDEX_INTERNAL_MU2 = 4, + DEVICE_INDEX_INTERNAL_MU3 = 5, + DEVICE_INDEX_INTERNAL_MU4 = 6, + DEVICE_INDEX_INTERNAL_MU5 = 7, + DEVICE_INDEX_INTERNAL_MU6 = 8, + DEVICE_INDEX_INTERNAL_MU7 = 9, + DEVICE_INDEX_INTERNAL_CDROM0 = 10, + DEVICE_INDEX_INTERNAL_MAX = 11 +} DEVICE_INDEX_INTERNAL, *PDEVICE_INDEX_INTERNAL; + +//For use in clients. +typedef enum _DEVICE_INDEX_EXTERNAL { + DEVICE_INDEX_EXTERNAL_HARDDISK0 = 0, + DEVICE_INDEX_EXTERNAL_HARDDISK1 = 1, + DEVICE_INDEX_EXTERNAL_MU0 = 2, + DEVICE_INDEX_EXTERNAL_MU1 = 3, + DEVICE_INDEX_EXTERNAL_MU2 = 4, + DEVICE_INDEX_EXTERNAL_MU3 = 5, + DEVICE_INDEX_EXTERNAL_MU4 = 6, + DEVICE_INDEX_EXTERNAL_MU5 = 7, + DEVICE_INDEX_EXTERNAL_MU6 = 8, + DEVICE_INDEX_EXTERNAL_MU7 = 9, + DEVICE_INDEX_EXTERNAL_CDROM0 = 10, + DEVICE_INDEX_EXTERNAL_MAX = 11 +} DEVICE_INDEX_EXTERNAL, *PDEVICE_INDEX_EXTERNAL; + +#pragma endregion Enums + +#pragma region + +typedef struct _VERTEX { + FLOAT x, y, z; + FLOAT uvx, uvy; +} VERTEX, *PVERTEX; + +typedef struct _DEVICE_INFO { + CHAR Path[29]; + HANDLE Handle; + HANDLE Mutex; +} DEVICE_INFO, *PDEVICE_INFO; + +typedef struct _MEMORY_INFO { + LPVOID RequestMemory; + LPVOID ResponseMemory; + LPVOID ScratchMemory; +} MEMORY_INFO, *PMEMORY_INFO; + +typedef struct _SOCKET_THREAD_PARAM { + MEMORY_INFO Memories; + SOCKET ClientSocket; +} SOCKET_THREAD_PARAM, *PSOCKET_THREAD_PARAM; + +//Pack to make the smallest network packets possible, and easy parsing for clients. +#pragma pack(push, 1) + +//Disable warning about 0-length arrays. +#pragma warning(push) +#pragma warning(disable:4200) + +typedef struct _XDON_COMMAND_REQUEST_FRAME { + UINT64 Identifier; //REQUEST_FRAME_IDENTIFIER + BYTE Version; //PROTOCOL_VERSION + BYTE CommandID; +} XDON_COMMAND_REQUEST_FRAME, *PXDON_COMMAND_REQUEST_FRAME; + +typedef struct _XDON_COMMAND_RESPONSE_FRAME { + UINT64 Identifier; //RESPONSE_FRAME_IDENTIFIER + BYTE Version; //PROTOCOL_VERSION + BYTE ConsoleType; //CONSOLE_TYPE + NTSTATUS StatusCode; //https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/596a1078-e883-4972-9bbc-49e60bebca55 +} XDON_COMMAND_RESPONSE_FRAME, *PXDON_COMMAND_RESPONSE_FRAME; + +/*typedef struct _XDON_COMMAND_IDENTIFY_REQUEST { +} XDON_COMMAND_IDENTIFY_REQUEST, *PXDON_COMMAND_IDENTIFY_REQUEST;*/ + +typedef struct _XDON_COMMAND_IDENTIFY_RESPONSE { + BYTE XDONVersion; + XBOX_KRNL_VERSION XboxVersion; + XBOX_HARDWARE_INFO XboxHardwareInfo; + UINT MaxIOLength; +} XDON_COMMAND_IDENTIFY_RESPONSE, *PXDON_COMMAND_IDENTIFY_RESPONSE; + +/*typedef struct _XDON_COMMAND_GET_DEVICES_REQUEST { +} XDON_COMMAND_GET_DEVICES_REQUEST, *PXDON_COMMAND_GET_DEVICES_REQUEST;*/ + +typedef struct _XDON_COMMAND_GET_DEVICES_RESPONSE { + struct { + //The internal IDE HDD. + //Raw access to the entire device can be achieved through: Harddisk0\\partition0 + BOOLEAN Harddisk0 : 1; + + //The internal IDE HDD (Cerbios secondary HDD) that takes the place of the disc drive. + //Raw access to the entire device can be achieved through: Harddisk1\\partition0 + BOOLEAN Harddisk1 : 1; + + //The memory units are the Xbox-branded (or third-party) ones that plug into controllers. + BOOLEAN Mu0 : 1; + BOOLEAN Mu1 : 1; + BOOLEAN Mu2 : 1; + BOOLEAN Mu3 : 1; + BOOLEAN Mu4 : 1; + BOOLEAN Mu5 : 1; + BOOLEAN Mu6 : 1; + BOOLEAN Mu7 : 1; + + //The disc drive that game discs go in. Also supports other CDs. + //Raw access to the entire disc can be achieved through: CdRom0 + BOOLEAN CdRom0 : 1; + } AvailableDevices; + + DISK_GEOMETRY Harddisk0Geometry; + DISK_GEOMETRY Harddisk1Geometry; + DISK_GEOMETRY Mu0Geometry; + DISK_GEOMETRY Mu1Geometry; + DISK_GEOMETRY Mu2Geometry; + DISK_GEOMETRY Mu3Geometry; + DISK_GEOMETRY Mu4Geometry; + DISK_GEOMETRY Mu5Geometry; + DISK_GEOMETRY Mu6Geometry; + DISK_GEOMETRY Mu7Geometry; + DISK_GEOMETRY CdRom0Geometry; + + BOOLEAN Harddisk0InfoAvailable; + IDENTIFY_DEVICE_DATA Harddisk0Info; + + BOOLEAN Harddisk1InfoAvailable; + IDENTIFY_DEVICE_DATA Harddisk1Info; +} XDON_COMMAND_GET_DEVICES_RESPONSE, *PXDON_COMMAND_GET_DEVICES_RESPONSE; + +typedef struct _XDON_COMMAND_READ_REQUEST { + BYTE DeviceIndex; + INT64 Offset; + UINT Length; + BOOLEAN CompressResponseData; //Compression is LZ4, a very fast algorithm that brings noticeable benefits to network transfers. +} XDON_COMMAND_READ_REQUEST, *PXDON_COMMAND_READ_REQUEST; + +typedef struct _XDON_COMMAND_READ_RESPONSE { + UINT DataLength; //If 0 and NT_SUCCESS(Frame.StatusCode), a performance-saving measure was done because the data is empty (all bytes have a value of 0). + UINT UncompressedDataLength; + BYTE Data[0]; +} XDON_COMMAND_READ_RESPONSE, *PXDON_COMMAND_READ_RESPONSE; + +typedef struct _XDON_COMMAND_WRITE_REQUEST { + BYTE DeviceIndex; + INT64 Offset; + UINT DataLength; + BOOLEAN DataIsCompressed; + BYTE Data[0]; +} XDON_COMMAND_WRITE_REQUEST, *PXDON_COMMAND_WRITE_REQUEST; + +/*typedef struct _XDON_COMMAND_WRITE_RESPONSE { +} XDON_COMMAND_WRITE_RESPONSE, *PXDON_COMMAND_WRITE_RESPONSE;*/ + +//Write Same is a performant function for when you want to write a lot of the same data, like when you want to wipe a drive with a zero-pass. XDON will create a buffer of size Length filled with Value internally so no data needs to be sent. +typedef struct _XDON_COMMAND_WRITE_SAME_REQUEST { + BYTE DeviceIndex; + INT64 Offset; + UINT Length; + BYTE Value; +} XDON_COMMAND_WRITE_SAME_REQUEST, *PXDON_COMMAND_WRITE_SAME_REQUEST; + +/*typedef struct _XDON_COMMAND_WRITE_SAME_RESPONSE { +} XDON_COMMAND_WRITE_SAME_RESPONSE, *PXDON_COMMAND_WRITE_SAME_RESPONSE;*/ + +//Only for the internal SATA HDD. +typedef struct _XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST { + IDEREGS Registers; + UINT DataInOutSize; + BYTE DataOut[0]; +} XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST, *PXDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST; + +typedef struct _XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE { + IDEREGS Registers; + BYTE DataIn[0]; +} XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE, *PXDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE; + +typedef struct _XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST { + BYTE Routine; +} XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST, *PXDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST; + +/*typedef struct _XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_RESPONSE { +} XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_RESPONSE, *PXDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_RESPONSE;*/ + +#pragma warning(pop) + +#pragma pack(pop) + +//Fix for "the size of an array must be greater than zero" IntelliSense error. +#ifdef __INTELLISENSE__ +#define C_ASSERT(e) +#endif + +//These ensure the structs are the correct sizes that XDON clients are coded to accept. +//"error C2118: negative subscript" means there is a mismatch that needs fixing! +C_ASSERT(sizeof(XDON_COMMAND_REQUEST_FRAME) == XDON_COMMAND_REQUEST_FRAME_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_RESPONSE_FRAME) == XDON_COMMAND_RESPONSE_FRAME_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_IDENTIFY_RESPONSE) == XDON_COMMAND_IDENTIFY_RESPONSE_SIZE); +//Anything larger than 1472 won't work over UDP. +C_ASSERT(sizeof(XDON_COMMAND_IDENTIFY_RESPONSE) < 1472); +C_ASSERT(sizeof(XDON_COMMAND_GET_DEVICES_RESPONSE) == XDON_COMMAND_GET_DEVICES_RESPONSE_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_READ_REQUEST) == XDON_COMMAND_READ_REQUEST_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_READ_RESPONSE) == XDON_COMMAND_READ_RESPONSE_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_WRITE_REQUEST) == XDON_COMMAND_WRITE_REQUEST_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_WRITE_SAME_REQUEST) == XDON_COMMAND_WRITE_SAME_REQUEST_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST) == XDON_COMMAND_ATA_CUSTOM_COMMAND_REQUEST_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE) == XDON_COMMAND_ATA_CUSTOM_COMMAND_RESPONSE_SIZE); +C_ASSERT(sizeof(XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST) == XDON_COMMAND_REBOOT_SHUTDOWN_CONSOLE_REQUEST_SIZE); + +//These must be aligned for the kernel to accept them. +C_ASSERT((offsetof(XDON_COMMAND_READ_RESPONSE, Data) & FILE_WORD_ALIGNMENT) == 0); +C_ASSERT((offsetof(XDON_COMMAND_WRITE_REQUEST, Data) & FILE_WORD_ALIGNMENT) == 0); + +#pragma endregion Structs \ No newline at end of file diff --git a/src/XDON-OG-RXDK/XboxExports.h b/src/XDON-OG-RXDK/XboxExports.h new file mode 100644 index 0000000..37f019c --- /dev/null +++ b/src/XDON-OG-RXDK/XboxExports.h @@ -0,0 +1,807 @@ +// Copyright © Eaton Works 2025. All rights reserved. +// License: https://github.com/EatonZ/XDON/blob/main/LICENSE + +#pragma once + +#pragma region + +#define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0])) + +#define NTKERNELAPI +#define NTHALAPI NTKERNELAPI + +#define FILE_WORD_ALIGNMENT 1 + +typedef LONG NTSTATUS; +#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0) +#define STATUS_SUCCESS (0x00000000) +#define STATUS_UNSUCCESSFUL (0xC0000001) +#define STATUS_NOT_SUPPORTED (0xC00000BB) +#define STATUS_INVALID_PARAMETER (0xC000000D) + +#define SO_INSECURE 0x4001 +#define OBJ_CASE_INSENSITIVE 0x40 +#define FILE_SYNCHRONOUS_IO_NONALERT 0x20 +#define InitializeObjectAttributes( p, n, a, r, s ) { (p)->RootDirectory = (r); (p)->Attributes = (a); (p)->ObjectName = (PANSI_STRING)(n); } + +#define IOCTL_DISK_GET_DRIVE_GEOMETRY 0x70000 +#define IOCTL_CDROM_GET_DRIVE_GEOMETRY 0x2404C +#define IOCTL_IDE_PASS_THROUGH 0x4D028 + +#define IDE_COMMAND_IDENTIFY_DEVICE ((UCHAR)0xEC) + +#define SMC_SLAVE_ADDRESS 0x20 + +#define SMC_COMMAND_LED_OVERRIDE 0x07 +#define SMC_COMMAND_LED_STATES 0x08 + +//Use with SMC_COMMAND_LED_OVERRIDE +#define SMC_LED_OVERRIDE_DEFAULT 0x00 +#define SMC_LED_OVERRIDE_USE_REQUESTED_LED_STATES 0x01 + +//Use with SMC_COMMAND_LED_STATES +#define SMC_LED_STATES_GREEN_STATE0 0x01 +#define SMC_LED_STATES_GREEN_STATE1 0x02 +#define SMC_LED_STATES_GREEN_STATE2 0x04 +#define SMC_LED_STATES_GREEN_STATE3 0x08 +#define SMC_LED_STATES_RED_STATE0 0x10 +#define SMC_LED_STATES_RED_STATE1 0x20 +#define SMC_LED_STATES_RED_STATE2 0x40 +#define SMC_LED_STATES_RED_STATE3 0x80 + +#define HalWriteSMBusByte(SlaveAddress, CommandCode, DataValue) HalWriteSMBusValue(SlaveAddress, CommandCode, FALSE, DataValue) + +#pragma endregion Defs + +#pragma region + +typedef enum _FIRMWARE_REENTRY { + HalHaltRoutine = 0, + HalRebootRoutine = 1, + HalQuickRebootRoutine = 2, + HalKdRebootRoutine = 3, + HalFatalErrorRebootRoutine = 4, + HalMaximumRoutine = 5 +} FIRMWARE_REENTRY, *PFIRMWARE_REENTRY; + +typedef enum _MEDIA_TYPE { + Unknown = 0, + //Only these 2 are used in the OG kernel. + RemovableMedia = 0xB, //ODD + FixedMedia = 0xC //HDD & MU +} MEDIA_TYPE, *PMEDIA_TYPE; + +#pragma endregion Enums + +#pragma region + +typedef struct _XBOX_KRNL_VERSION { + USHORT Major; + USHORT Minor; + USHORT Build; + USHORT Qfe; +} XBOX_KRNL_VERSION, *PXBOX_KRNL_VERSION; + +typedef struct _XBOX_HARDWARE_INFO { + ULONG Flags; + UCHAR GpuRevision; + UCHAR McpRevision; + UCHAR reserved[2]; +} XBOX_HARDWARE_INFO, *PXBOX_HARDWARE_INFO; + +typedef struct _STRING { + USHORT Length; + USHORT MaximumLength; + PCHAR Buffer; +} STRING, *PSTRING, ANSI_STRING, *PANSI_STRING, OBJECT_STRING, *POBJECT_STRING; + +typedef struct _OBJECT_ATTRIBUTES { + HANDLE RootDirectory; + PANSI_STRING ObjectName; + ULONG Attributes; +} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES; + +typedef struct _IO_STATUS_BLOCK { + union { + NTSTATUS Status; + PVOID Pointer; + }; + ULONG_PTR Information; +} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; + +typedef VOID (NTAPI *PIO_APC_ROUTINE)( + IN PVOID ApcContext, + IN PIO_STATUS_BLOCK IoStatusBlock, + IN ULONG Reserved +); + +typedef struct _DISK_GEOMETRY { + LARGE_INTEGER Cylinders; + MEDIA_TYPE MediaType; + ULONG TracksPerCylinder; + ULONG SectorsPerTrack; + ULONG BytesPerSector; +} DISK_GEOMETRY, *PDISK_GEOMETRY; + +typedef struct _IDEREGS { + UCHAR bFeaturesReg; + UCHAR bSectorCountReg; + UCHAR bSectorNumberReg; + UCHAR bCylLowReg; + UCHAR bCylHighReg; + UCHAR bDriveHeadReg; + UCHAR bCommandReg; + UCHAR bHostSendsData; //Different than on Windows, which is named bReserved. On Xbox, set to TRUE for a data out command, and FALSE for data in. Not actually sent to the disk. +} IDEREGS, *PIDEREGS; + +//C:\Program Files (x86)\Windows Kits\10\Include\10.0.26100.0\km\ata.h +#pragma pack(push, 1) +typedef struct _IDENTIFY_DEVICE_DATA { + + struct { + USHORT Reserved1 : 1; + USHORT Retired3 : 1; + USHORT ResponseIncomplete : 1; + USHORT Retired2 : 3; + USHORT FixedDevice : 1; // obsolete + USHORT RemovableMedia : 1; // obsolete + USHORT Retired1 : 7; + USHORT DeviceType : 1; + } GeneralConfiguration; // word 0 + + USHORT NumCylinders; // word 1, obsolete + USHORT SpecificConfiguration; // word 2 + USHORT NumHeads; // word 3, obsolete + USHORT Retired1[2]; + USHORT NumSectorsPerTrack; // word 6, obsolete + USHORT VendorUnique1[3]; + UCHAR SerialNumber[20]; // word 10-19 + USHORT Retired2[2]; + USHORT Obsolete1; + UCHAR FirmwareRevision[8]; // word 23-26 + UCHAR ModelNumber[40]; // word 27-46 + UCHAR MaximumBlockTransfer; // word 47. 01h-10h = Maximum number of sectors that shall be transferred per interrupt on READ/WRITE MULTIPLE commands + UCHAR VendorUnique2; + + struct { + USHORT FeatureSupported : 1; + USHORT Reserved : 15; + }TrustedComputing; // word 48 + + struct { + UCHAR CurrentLongPhysicalSectorAlignment : 2; + UCHAR ReservedByte49 : 6; + + UCHAR DmaSupported : 1; + UCHAR LbaSupported : 1; // Shall be set to one to indicate that LBA is supported. + UCHAR IordyDisable : 1; + UCHAR IordySupported : 1; + UCHAR Reserved1 : 1; // Reserved for the IDENTIFY PACKET DEVICE command + UCHAR StandybyTimerSupport : 1; + UCHAR Reserved2 : 2; // Reserved for the IDENTIFY PACKET DEVICE command + + USHORT ReservedWord50; + }Capabilities; // word 49-50 + + USHORT ObsoleteWords51[2]; + + USHORT TranslationFieldsValid : 3; // word 53, bit 0 - Obsolete; bit 1 - words 70:64 valid; bit 2; word 88 valid + USHORT Reserved3 : 5; + USHORT FreeFallControlSensitivity : 8; + + USHORT NumberOfCurrentCylinders; // word 54, obsolete + USHORT NumberOfCurrentHeads; // word 55, obsolete + USHORT CurrentSectorsPerTrack; // word 56, obsolete + ULONG CurrentSectorCapacity; // word 57, word 58, obsolete + + UCHAR CurrentMultiSectorSetting; // word 59 + UCHAR MultiSectorSettingValid : 1; + UCHAR ReservedByte59 : 3; + UCHAR SanitizeFeatureSupported : 1; + UCHAR CryptoScrambleExtCommandSupported : 1; + UCHAR OverwriteExtCommandSupported : 1; + UCHAR BlockEraseExtCommandSupported : 1; + + ULONG UserAddressableSectors; // word 60-61, for 28-bit commands + + USHORT ObsoleteWord62; + + USHORT MultiWordDMASupport : 8; // word 63 + USHORT MultiWordDMAActive : 8; + + USHORT AdvancedPIOModes : 8; // word 64. bit 0:1 - PIO mode supported + USHORT ReservedByte64 : 8; + + USHORT MinimumMWXferCycleTime; // word 65 + USHORT RecommendedMWXferCycleTime; // word 66 + USHORT MinimumPIOCycleTime; // word 67 + USHORT MinimumPIOCycleTimeIORDY; // word 68 + + struct { + USHORT ZonedCapabilities : 2; + USHORT NonVolatileWriteCache : 1; // All write cache is non-volatile + USHORT ExtendedUserAddressableSectorsSupported : 1; + USHORT DeviceEncryptsAllUserData : 1; + USHORT ReadZeroAfterTrimSupported : 1; + USHORT Optional28BitCommandsSupported : 1; + USHORT IEEE1667 : 1; // Reserved for IEEE 1667 + USHORT DownloadMicrocodeDmaSupported : 1; + USHORT SetMaxSetPasswordUnlockDmaSupported : 1; + USHORT WriteBufferDmaSupported : 1; + USHORT ReadBufferDmaSupported : 1; + USHORT DeviceConfigIdentifySetDmaSupported : 1; // obsolete + USHORT LPSAERCSupported : 1; // Long Physical Sector Alignment Error Reporting Control is supported. + USHORT DeterministicReadAfterTrimSupported : 1; + USHORT CFastSpecSupported : 1; + }AdditionalSupported; // word 69 + + USHORT ReservedWords70[5]; // word 70 - reserved + // word 71:74 - Reserved for the IDENTIFY PACKET DEVICE command + + //Word 75 + USHORT QueueDepth : 5; // Maximum queue depth - 1 + USHORT ReservedWord75 : 11; + + struct { + // Word 76 + USHORT Reserved0 : 1; // shall be set to 0 + USHORT SataGen1 : 1; // Supports SATA Gen1 Signaling Speed (1.5Gb/s) + USHORT SataGen2 : 1; // Supports SATA Gen2 Signaling Speed (3.0Gb/s) + USHORT SataGen3 : 1; // Supports SATA Gen3 Signaling Speed (6.0Gb/s) + + USHORT Reserved1 : 4; + + USHORT NCQ : 1; // Supports the NCQ feature set + USHORT HIPM : 1; // Supports HIPM + USHORT PhyEvents : 1; // Supports the SATA Phy Event Counters log + USHORT NcqUnload : 1; // Supports Unload while NCQ commands are outstanding + + USHORT NcqPriority : 1; // Supports NCQ priority information + USHORT HostAutoPS : 1; // Supports Host Automatic Partial to Slumber transitions + USHORT DeviceAutoPS : 1; // Supports Device Automatic Partial to Slumber transitions + USHORT ReadLogDMA : 1; // Supports READ LOG DMA EXT as equivalent to READ LOG EXT + + // Word 77 + USHORT Reserved2 : 1; // shall be set to 0 + USHORT CurrentSpeed : 3; // Coded value indicating current negotiated Serial ATA signal speed + + USHORT NcqStreaming : 1; // Supports NCQ Streaming + USHORT NcqQueueMgmt : 1; // Supports NCQ Queue Management Command + USHORT NcqReceiveSend : 1; // Supports RECEIVE FPDMA QUEUED and SEND FPDMA QUEUED commands + USHORT DEVSLPtoReducedPwrState : 1; + + USHORT Reserved3 : 8; + }SerialAtaCapabilities; + + // Word 78 + struct { + USHORT Reserved0 : 1; //shall be set to 0 + USHORT NonZeroOffsets:1; // Device supports non-zero buffer offsets in DMA Setup FIS + USHORT DmaSetupAutoActivate:1; // Device supports DMA Setup auto-activation + USHORT DIPM : 1; // Device supports DIPM + + USHORT InOrderData : 1; // Device supports in-order data delivery + USHORT HardwareFeatureControl:1; // Hardware Feature Control is supported + USHORT SoftwareSettingsPreservation:1; // Device supports Software Settings Preservation + USHORT NCQAutosense:1; // Supports NCQ Autosense + + USHORT DEVSLP :1; // Device supports link power state - device sleep + USHORT HybridInformation :1; // Device supports Hybrid Information Feature (If the device does not support NCQ (word 76 bit 8 is 0), then this bit shall be cleared to 0.) + + USHORT Reserved1 : 6; + }SerialAtaFeaturesSupported; + + // Word 79 + struct { + USHORT Reserved0 : 1; // shall be set to 0 + USHORT NonZeroOffsets:1; // Non-zero buffer offsets in DMA Setup FIS enabled + USHORT DmaSetupAutoActivate:1; // DMA Setup auto-activation optimization enabled + USHORT DIPM : 1; // DIPM enabled + + USHORT InOrderData : 1; // In-order data delivery enabled + USHORT HardwareFeatureControl:1; // Hardware Feature Control is enabled + USHORT SoftwareSettingsPreservation:1; // Software Settings Preservation enabled + USHORT DeviceAutoPS : 1; // Device Automatic Partial to Slumber transitions enabled + + USHORT DEVSLP :1; // link power state - device sleep is enabled + USHORT HybridInformation :1; // Hybrid Information Feature is enabled + + USHORT Reserved1 : 6; + }SerialAtaFeaturesEnabled; + + USHORT MajorRevision; // word 80. bit 5 - supports ATA5; bit 6 - supports ATA6; bit 7 - supports ATA7; bit 8 - supports ATA8-ACS; bit 9 - supports ACS-2; + USHORT MinorRevision; // word 81. T13 minior version number + + struct { + + // + // Word 82 + // + USHORT SmartCommands : 1; // The SMART feature set is supported + USHORT SecurityMode : 1; // The Security feature set is supported + USHORT RemovableMediaFeature : 1; // obsolete + USHORT PowerManagement : 1; // shall be set to 1 + USHORT Reserved1 : 1; // PACKET feature set, set to 0 indicates not supported for ATA devices (only support for ATAPI devices) + USHORT WriteCache : 1; // The volatile write cache is supported + USHORT LookAhead : 1; // Read look-ahead is supported + USHORT ReleaseInterrupt : 1; // obsolete + USHORT ServiceInterrupt : 1; // obsolete + USHORT DeviceReset : 1; // Shall be cleared to zero to indicate that the DEVICE RESET command is not supported + USHORT HostProtectedArea : 1; // obsolete + USHORT Obsolete1 : 1; + USHORT WriteBuffer : 1; // The WRITE BUFFER command is supported + USHORT ReadBuffer : 1; // The READ BUFFER command is supported + USHORT Nop : 1; // The NOP command is supported + USHORT Obsolete2 : 1; + + // + // Word 83 + // + USHORT DownloadMicrocode : 1; // The DOWNLOAD MICROCODE command is supported + USHORT DmaQueued : 1; // obsolete + USHORT Cfa : 1; // The CFA feature set is supported + USHORT AdvancedPm : 1; // The APM feature set is supported + USHORT Msn : 1; // obsolete + USHORT PowerUpInStandby : 1; // The PUIS feature set is supported + USHORT ManualPowerUp : 1; // SET FEATURES subcommand is required to spin-up after power-up + USHORT Reserved2 : 1; + USHORT SetMax : 1; // obsolete + USHORT Acoustics : 1; // obsolete + USHORT BigLba : 1; // The 48-bit Address feature set is supported + USHORT DeviceConfigOverlay : 1; // obsolete + USHORT FlushCache : 1; // Shall be set to one to indicate that the mandatory FLUSH CACHE command is supported + USHORT FlushCacheExt : 1; // The FLUSH CACHE EXT command is supported + USHORT WordValid83 : 2; // shall be 01b + + + // + // Word 84 + // + USHORT SmartErrorLog : 1; // SMART error logging is supported + USHORT SmartSelfTest : 1; // The SMART self-test is supported + USHORT MediaSerialNumber : 1; // Media serial number is supported + USHORT MediaCardPassThrough : 1; // obsolete + USHORT StreamingFeature : 1; // The Streaming feature set is supported + USHORT GpLogging : 1; // The GPL feature set is supported + USHORT WriteFua : 1; // The WRITE DMA FUA EXT and WRITE MULTIPLE FUA EXT commands are supported + USHORT WriteQueuedFua : 1; // obsolete + USHORT WWN64Bit : 1; // The 64-bit World wide name is supported + USHORT URGReadStream : 1; // obsolete + USHORT URGWriteStream : 1; // obsolete + USHORT ReservedForTechReport : 2; + USHORT IdleWithUnloadFeature : 1; // The IDLE IMMEDIATE command with UNLOAD feature is supported + USHORT WordValid : 2; // shall be 01b + + }CommandSetSupport; + + struct { + + // + // Word 85 + // + USHORT SmartCommands : 1; // The SMART feature set is enabled + USHORT SecurityMode : 1; // The Security feature set is enabled + USHORT RemovableMediaFeature : 1; // obsolete + USHORT PowerManagement : 1; // Shall be set to one to indicate that the mandatory Power Management feature set is supported + USHORT Reserved1 : 1; // Shall be cleared to zero to indicate that the PACKET feature set is not supported + USHORT WriteCache : 1; // The volatile write cache is enabled + USHORT LookAhead : 1; // Read look-ahead is enabled + USHORT ReleaseInterrupt : 1; // The release interrupt is enabled + USHORT ServiceInterrupt : 1; // The SERVICE interrupt is enabled + USHORT DeviceReset : 1; // Shall be cleared to zero to indicate that the DEVICE RESET command is not supported + USHORT HostProtectedArea : 1; // obsolete + USHORT Obsolete1 : 1; + USHORT WriteBuffer : 1; // The WRITE BUFFER command is supported + USHORT ReadBuffer : 1; // The READ BUFFER command is supported + USHORT Nop : 1; // The NOP command is supported + USHORT Obsolete2 : 1; + + // + // Word 86 + // + USHORT DownloadMicrocode : 1; // The DOWNLOAD MICROCODE command is supported + USHORT DmaQueued : 1; // obsolete + USHORT Cfa : 1; // The CFA feature set is supported + USHORT AdvancedPm : 1; // The APM feature set is enabled + USHORT Msn : 1; // obsolete + USHORT PowerUpInStandby : 1; // The PUIS feature set is enabled + USHORT ManualPowerUp : 1; // SET FEATURES subcommand is required to spin-up after power-up + USHORT Reserved2 : 1; + USHORT SetMax : 1; // obsolete + USHORT Acoustics : 1; // obsolete + USHORT BigLba : 1; // The 48-bit Address features set is supported + USHORT DeviceConfigOverlay : 1; // obsolete + USHORT FlushCache : 1; // FLUSH CACHE command supported + USHORT FlushCacheExt : 1; // FLUSH CACHE EXT command supported + USHORT Resrved3 : 1; + USHORT Words119_120Valid : 1; // Words 119..120 are valid + + // + // Word 87 + // + USHORT SmartErrorLog : 1; // SMART error logging is supported + USHORT SmartSelfTest : 1; // SMART self-test supported + USHORT MediaSerialNumber : 1; // Media serial number is valid + USHORT MediaCardPassThrough : 1; // obsolete + USHORT StreamingFeature : 1; // obsolete + USHORT GpLogging : 1; // The GPL feature set is supported + USHORT WriteFua : 1; // The WRITE DMA FUA EXT and WRITE MULTIPLE FUA EXT commands are supported + USHORT WriteQueuedFua : 1; // obsolete + USHORT WWN64Bit : 1; // The 64-bit World wide name is supported + USHORT URGReadStream : 1; // obsolete + USHORT URGWriteStream : 1; // obsolete + USHORT ReservedForTechReport : 2; + USHORT IdleWithUnloadFeature : 1; // The IDLE IMMEDIATE command with UNLOAD FEATURE is supported + USHORT Reserved4 : 2; // bit 14 shall be set to 1; bit 15 shall be cleared to 0 + + }CommandSetActive; + + USHORT UltraDMASupport : 8; // word 88. bit 0 - UDMA mode 0 is supported ... bit 6 - UDMA mode 6 and below are supported + USHORT UltraDMAActive : 8; // word 88. bit 8 - UDMA mode 0 is selected ... bit 14 - UDMA mode 6 is selected + + struct { // word 89 + USHORT TimeRequired : 15; + USHORT ExtendedTimeReported : 1; + } NormalSecurityEraseUnit; + + struct { // word 90 + USHORT TimeRequired : 15; + USHORT ExtendedTimeReported : 1; + } EnhancedSecurityEraseUnit; + + USHORT CurrentAPMLevel : 8; // word 91 + USHORT ReservedWord91 : 8; + + USHORT MasterPasswordID; // word 92. Master Password Identifier + + USHORT HardwareResetResult; // word 93 + + USHORT CurrentAcousticValue : 8; // word 94. obsolete + USHORT RecommendedAcousticValue : 8; + + USHORT StreamMinRequestSize; // word 95 + USHORT StreamingTransferTimeDMA; // word 96 + USHORT StreamingAccessLatencyDMAPIO; // word 97 + ULONG StreamingPerfGranularity; // word 98, 99 + + ULONG Max48BitLBA[2]; // word 100-103 + + USHORT StreamingTransferTime; // word 104. Streaming Transfer Time - PIO + + USHORT DsmCap; // word 105 + + struct { + USHORT LogicalSectorsPerPhysicalSector : 4; // n power of 2: logical sectors per physical sector + USHORT Reserved0 : 8; + USHORT LogicalSectorLongerThan256Words : 1; + USHORT MultipleLogicalSectorsPerPhysicalSector : 1; + USHORT Reserved1 : 2; // bit 14 - shall be set to 1; bit 15 - shall be clear to 0 + } PhysicalLogicalSectorSize; // word 106 + + USHORT InterSeekDelay; //word 107. Inter-seek delay for ISO 7779 standard acoustic testing + USHORT WorldWideName[4]; //words 108-111 + USHORT ReservedForWorldWideName128[4]; //words 112-115 + USHORT ReservedForTlcTechnicalReport; //word 116 + USHORT WordsPerLogicalSector[2]; //words 117-118 Logical sector size (DWord) + + struct { + USHORT ReservedForDrqTechnicalReport : 1; + USHORT WriteReadVerify : 1; // The Write-Read-Verify feature set is supported + USHORT WriteUncorrectableExt : 1; // The WRITE UNCORRECTABLE EXT command is supported + USHORT ReadWriteLogDmaExt : 1; // The READ LOG DMA EXT and WRITE LOG DMA EXT commands are supported + USHORT DownloadMicrocodeMode3 : 1; // Download Microcode mode 3 is supported + USHORT FreefallControl : 1; // The Free-fall Control feature set is supported + USHORT SenseDataReporting : 1; // Sense Data Reporting feature set is supported + USHORT ExtendedPowerConditions : 1; // Extended Power Conditions feature set is supported + USHORT Reserved0 : 6; + USHORT WordValid : 2; // shall be 01b + }CommandSetSupportExt; //word 119 + + struct { + USHORT ReservedForDrqTechnicalReport : 1; + USHORT WriteReadVerify : 1; // The Write-Read-Verify feature set is enabled + USHORT WriteUncorrectableExt : 1; // The WRITE UNCORRECTABLE EXT command is supported + USHORT ReadWriteLogDmaExt : 1; // The READ LOG DMA EXT and WRITE LOG DMA EXT commands are supported + USHORT DownloadMicrocodeMode3 : 1; // Download Microcode mode 3 is supported + USHORT FreefallControl : 1; // The Free-fall Control feature set is enabled + USHORT SenseDataReporting : 1; // Sense Data Reporting feature set is enabled + USHORT ExtendedPowerConditions : 1; // Extended Power Conditions feature set is enabled + USHORT Reserved0 : 6; + USHORT Reserved1 : 2; // bit 14 - shall be set to 1; bit 15 - shall be clear to 0 + }CommandSetActiveExt; //word 120 + + USHORT ReservedForExpandedSupportandActive[6]; + + USHORT MsnSupport : 2; //word 127. obsolete + USHORT ReservedWord127 : 14; + + struct { //word 128 + USHORT SecuritySupported : 1; + USHORT SecurityEnabled : 1; + USHORT SecurityLocked : 1; + USHORT SecurityFrozen : 1; + USHORT SecurityCountExpired : 1; + USHORT EnhancedSecurityEraseSupported : 1; + USHORT Reserved0 : 2; + USHORT SecurityLevel : 1; // Master Password Capability: 0 = High, 1 = Maximum + USHORT Reserved1 : 7; + } SecurityStatus; + + USHORT ReservedWord129[31]; //word 129...159. Vendor specific + + struct { //word 160 + USHORT MaximumCurrentInMA : 12; + USHORT CfaPowerMode1Disabled : 1; + USHORT CfaPowerMode1Required : 1; + USHORT Reserved0 : 1; + USHORT Word160Supported : 1; + } CfaPowerMode1; + + USHORT ReservedForCfaWord161[7]; //Words 161-167 + + USHORT NominalFormFactor : 4; //Word 168 + USHORT ReservedWord168 : 12; + + struct { //Word 169 + USHORT SupportsTrim : 1; + USHORT Reserved0 : 15; + } DataSetManagementFeature; + + USHORT AdditionalProductID[4]; //Words 170-173 + + USHORT ReservedForCfaWord174[2]; //Words 174-175 + + USHORT CurrentMediaSerialNumber[30]; //Words 176-205 + + struct { //Word 206 + USHORT Supported : 1; // The SCT Command Transport is supported + USHORT Reserved0 : 1; // obsolete + USHORT WriteSameSuported : 1; // The SCT Write Same command is supported + USHORT ErrorRecoveryControlSupported : 1; // The SCT Error Recovery Control command is supported + USHORT FeatureControlSuported : 1; // The SCT Feature Control command is supported + USHORT DataTablesSuported : 1; // The SCT Data Tables command is supported + USHORT Reserved1 : 6; + USHORT VendorSpecific : 4; + } SCTCommandTransport; + + USHORT ReservedWord207[2]; //Words 207-208 + + struct { //Word 209 + USHORT AlignmentOfLogicalWithinPhysical: 14; + USHORT Word209Supported: 1; // shall be set to 1 + USHORT Reserved0: 1; // shall be cleared to 0 + } BlockAlignment; + + USHORT WriteReadVerifySectorCountMode3Only[2]; //Words 210-211 + USHORT WriteReadVerifySectorCountMode2Only[2]; //Words 212-213 + + struct { + USHORT NVCachePowerModeEnabled: 1; + USHORT Reserved0: 3; + USHORT NVCacheFeatureSetEnabled: 1; + USHORT Reserved1: 3; + USHORT NVCachePowerModeVersion: 4; + USHORT NVCacheFeatureSetVersion: 4; + } NVCacheCapabilities; //Word 214. obsolete + USHORT NVCacheSizeLSW; //Word 215. obsolete + USHORT NVCacheSizeMSW; //Word 216. obsolete + + USHORT NominalMediaRotationRate; //Word 217; value 0001h means non-rotating media. + + USHORT ReservedWord218; //Word 218 + + struct { + UCHAR NVCacheEstimatedTimeToSpinUpInSeconds; + UCHAR Reserved; + } NVCacheOptions; //Word 219. obsolete + + USHORT WriteReadVerifySectorCountMode : 8; //Word 220. Write-Read-Verify feature set current mode + USHORT ReservedWord220 : 8; + + USHORT ReservedWord221; //Word 221 + + struct { //Word 222 Transport major version number + USHORT MajorVersion : 12; // 0000h or FFFFh = device does not report version + USHORT TransportType : 4; + } TransportMajorVersion; + + USHORT TransportMinorVersion; // Word 223 + + USHORT ReservedWord224[6]; // Word 224...229 + + ULONG ExtendedNumberOfUserAddressableSectors[2]; // Words 230...233 Extended Number of User Addressable Sectors + + USHORT MinBlocksPerDownloadMicrocodeMode03; // Word 234 Minimum number of 512-byte data blocks per Download Microcode mode 03h operation + USHORT MaxBlocksPerDownloadMicrocodeMode03; // Word 235 Maximum number of 512-byte data blocks per Download Microcode mode 03h operation + + USHORT ReservedWord236[19]; // Word 236...254 + + USHORT Signature : 8; //Word 255 + USHORT CheckSum : 8; + +} IDENTIFY_DEVICE_DATA, *PIDENTIFY_DEVICE_DATA; +#pragma pack(pop) + +typedef struct _ATA_PASS_THROUGH { + IDEREGS IdeReg; + ULONG DataBufferSize; + PVOID DataBuffer; +} ATA_PASS_THROUGH, *PATA_PASS_THROUGH; + +typedef VOID (*PKDEFERRED_ROUTINE)( + IN struct _KDPC *Dpc, + IN PVOID DeferredContext, + IN PVOID SystemArgument1, + IN PVOID SystemArgument2 +); + +typedef struct _KDPC { + SHORT Type; + BOOLEAN Inserted; + UCHAR Padding; + LIST_ENTRY DpcListEntry; + PKDEFERRED_ROUTINE DeferredRoutine; + PVOID DeferredContext; + PVOID SystemArgument1; + PVOID SystemArgument2; +} KDPC, *PKDPC; + +typedef struct _DISPATCHER_HEADER { + UCHAR Type; + UCHAR Absolute; + UCHAR Size; + UCHAR Inserted; + LONG SignalState; + LIST_ENTRY WaitListHead; +} DISPATCHER_HEADER, *PDISPATCHER_HEADER; + +typedef struct _KTIMER { + DISPATCHER_HEADER Header; + ULARGE_INTEGER DueTime; + LIST_ENTRY TimerListEntry; + PKDPC Dpc; + LONG Period; +} KTIMER, *PKTIMER; + +typedef struct _XAPI_AUTOPOWERDOWN_GLOBAL { + KDPC AutoPowerDownDpc; + KTIMER AutoPowerDownTimer; + BOOL fAutoPowerDown; + BOOL fReadWriteFailure; + #ifdef _DEBUG + LARGE_INTEGER liTimeOut; + #endif +} XAPI_AUTOPOWERDOWN_GLOBAL, *PXAPI_AUTOPOWERDOWN_GLOBAL; + +#pragma endregion Structs + +#pragma region + +EXTERN_C +{ + extern PXBOX_KRNL_VERSION XboxKrnlVersion; + extern PXBOX_HARDWARE_INFO XboxHardwareInfo; + extern XAPI_AUTOPOWERDOWN_GLOBAL XapiAutoPowerDownGlobals; + + NTSTATUS + NTAPI + MU_CreateDeviceObject( + IN ULONG Port, + IN ULONG Slot, + IN POBJECT_STRING DeviceName + ); + + VOID + NTAPI + MU_CloseDeviceObject( + IN ULONG Port, + IN ULONG Slot + ); + + INT vsprintf(CHAR* Dest, const CHAR* Format, va_list Args); + + ULONG + __cdecl + DbgPrint( + IN const CHAR* Format, + IN ... + ); + + DECLSPEC_NORETURN + NTHALAPI + VOID + NTAPI + HalReturnToFirmware( + IN FIRMWARE_REENTRY Routine + ); + + NTHALAPI + VOID + NTAPI + HalInitiateShutdown( + VOID + ); + + NTHALAPI + NTSTATUS + NTAPI + HalWriteSMBusValue( + IN UCHAR SlaveAddress, + IN UCHAR CommandCode, + IN BOOLEAN WriteWordValue, + IN ULONG DataValue + ); + + NTSYSAPI + VOID + NTAPI + RtlInitAnsiString( + OUT PANSI_STRING DestinationString, + IN PSZ SourceString OPTIONAL + ); + + NTSYSCALLAPI + NTSTATUS + NTAPI + NtOpenFile( + OUT PHANDLE FileHandle, + IN ACCESS_MASK DesiredAccess, + IN POBJECT_ATTRIBUTES ObjectAttributes, + OUT PIO_STATUS_BLOCK IoStatusBlock, + IN ULONG ShareAccess, + IN ULONG OpenOptions + ); + + NTSYSCALLAPI + NTSTATUS + NTAPI + NtReadFile( + IN HANDLE FileHandle, + IN HANDLE Event OPTIONAL, + IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, + IN PVOID ApcContext OPTIONAL, + OUT PIO_STATUS_BLOCK IoStatusBlock, + OUT PVOID Buffer, + IN ULONG Length, + IN PLARGE_INTEGER ByteOffset OPTIONAL + ); + + NTSYSCALLAPI + NTSTATUS + NTAPI + NtWriteFile( + IN HANDLE FileHandle, + IN HANDLE Event OPTIONAL, + IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, + IN PVOID ApcContext OPTIONAL, + OUT PIO_STATUS_BLOCK IoStatusBlock, + IN PVOID Buffer, + IN ULONG Length, + IN PLARGE_INTEGER ByteOffset OPTIONAL + ); + + NTSYSCALLAPI + NTSTATUS + NTAPI + NtDeviceIoControlFile( + IN HANDLE FileHandle, + IN HANDLE Event OPTIONAL, + IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, + IN PVOID ApcContext OPTIONAL, + OUT PIO_STATUS_BLOCK IoStatusBlock, + IN ULONG IoControlCode, + IN PVOID InputBuffer OPTIONAL, + IN ULONG InputBufferLength, + OUT PVOID OutputBuffer OPTIONAL, + IN ULONG OutputBufferLength + ); + + NTSYSCALLAPI + NTSTATUS + NTAPI + NtClose( + IN HANDLE Handle + ); +} + +#pragma endregion External Procedures \ No newline at end of file diff --git a/src/XDON-OG-RXDK/stdafx.cpp b/src/XDON-OG-RXDK/stdafx.cpp new file mode 100644 index 0000000..1b4f613 --- /dev/null +++ b/src/XDON-OG-RXDK/stdafx.cpp @@ -0,0 +1,4 @@ +// Copyright © Eaton Works 2025. All rights reserved. +// License: https://github.com/EatonZ/XDON/blob/main/LICENSE + +#include "stdafx.h" \ No newline at end of file diff --git a/src/XDON-OG-RXDK/stdafx.h b/src/XDON-OG-RXDK/stdafx.h new file mode 100644 index 0000000..c7de713 --- /dev/null +++ b/src/XDON-OG-RXDK/stdafx.h @@ -0,0 +1,9 @@ +// Copyright © Eaton Works 2025. All rights reserved. +// License: https://github.com/EatonZ/XDON/blob/main/LICENSE + +#pragma once + +#include +#include +#include +#include "XboxExports.h" \ No newline at end of file