io.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <string_view>
 
#include <rex/assert.h>
#include <rex/memory.h>
#include <rex/kernel/types/list.h>
#include <rex/kernel/types/status.h>
#include <rex/kernel/types/thread.h>
#include <rex/string/text.h>
#include <rex/kernel/heap.h>
 
namespace rex::kernel {
 
#pragma pack(push, 4)

enum X_FILE_ATTRIBUTES : u16 {
  kXFileAttributeNone = 0x0000,
  kXFileAttributeReadOnly = 0x0001,
  kXFileAttributeHidden = 0x0002,
  kXFileAttributeSystem = 0x0004,
  kXFileAttributeDirectory = 0x0010,
  kXFileAttributeArchive = 0x0020,
  kXFileAttributeDevice = 0x0040, 
  kXFileAttributeNormal = 0x0080, 
  kXFileAttributeTemporary = 0x0100,
  kXFileAttributeCompressed = 0x0800,
  kXFileAttributeEncrypted = 0x4000,
};

struct XOVERLAPPED {
  be_u32 result;
  be_u32 length;
  be_u32 context;            
  be_u32 event;              
  be_u32 completion_routine; 
  be_u32 completion_context;
  be_u32 extended_error;
};
 
REX_STATIC_ASSERT_SIZE(XOVERLAPPED, 0x1C);

inline void XOverlappedSetResult(void* ptr, u32 value) {
  static_cast<XOVERLAPPED*>(ptr)->result.Store(value, std::memory_order_release);
}

inline u32 XOverlappedGetResult(void* ptr) {
  return static_cast<XOVERLAPPED*>(ptr)->result.Load(std::memory_order_acquire);
}
 
inline void XOverlappedSetLength(void* ptr, u32 value) {
  static_cast<XOVERLAPPED*>(ptr)->length = value;
}
 
inline u32 XOverlappedGetContext(void* ptr) {
  return static_cast<XOVERLAPPED*>(ptr)->context;
}
 
inline void XOverlappedSetContext(void* ptr, u32 value) {
  static_cast<XOVERLAPPED*>(ptr)->context = value;
}

inline X_HANDLE XOverlappedGetEvent(void* ptr) {
  return static_cast<XOVERLAPPED*>(ptr)->event;
}

inline u32 XOverlappedGetCompletionRoutine(void* ptr) {
  return static_cast<XOVERLAPPED*>(ptr)->completion_routine;
}
 
inline void XOverlappedSetExtendedError(void* ptr, u32 value) {
  static_cast<XOVERLAPPED*>(ptr)->extended_error = value;
}

struct X_ANSI_STRING {
  be_u16 length;         
  be_u16 maximum_length; 
  be_u32 pointer;        
 
  void Reset() {
    length = 0;
    maximum_length = 0;
    pointer = 0;
  }
};
REX_STATIC_ASSERT_SIZE(X_ANSI_STRING, 8);

struct X_UNICODE_STRING {
  be_u16 length;         
  be_u16 maximum_length; 
  be_u32 pointer;        
 
  void Reset() {
    length = 0;
    maximum_length = 0;
    pointer = 0;
  }
};
REX_STATIC_ASSERT_SIZE(X_UNICODE_STRING, 8);
 
struct X_IO_STATUS_BLOCK {
  union {
    BE<X_STATUS> status;
    be_u32 pointer; 
  };

  be_u32 information;
};
 
struct X_OBJECT_ATTRIBUTES {
  be_u32 root_directory; 
  be_u32 name_ptr;       
  be_u32 attributes;
};
REX_STATIC_ASSERT_SIZE(X_OBJECT_ATTRIBUTES, 0xC);
 
#pragma pack(pop)

inline constexpr u32 kObjOpenIf = 0x80;

inline constexpr u32 kFileObjectSize = 0x68;

inline constexpr u16 kFileObjectTypeId = 5;

struct XFileObject {
  be_u16 type; 
  u8 flags;
  u8 pad_03;
  be_u32 device_ptr; 
  u8 pad_08[0x14];
  be_u32 related_file; 
  u8 pad_20[4];
  be_u32 unk_24;
  u8 unk_28;
  u8 pad_29[7];
  X_LIST_ENTRY unk_list_30;
  X_DISPATCH_HEADER event;
  u8 pad_48[0x10];
  u8 unk_58;
  u8 pad_59[0xF];
};
REX_STATIC_ASSERT_SIZE(XFileObject, kFileObjectSize);

inline constexpr u32 kIOCompletionObjectSize = 0x28;

inline constexpr u32 kSymbolicLinkObjectSize = 0xC;

enum X_FILE_INFORMATION_CLASS : u8 {
  XFileDirectoryInformation = 1,
  XFileFullDirectoryInformation,
  XFileBothDirectoryInformation,
  XFileBasicInformation,
  XFileStandardInformation,
  XFileInternalInformation,
  XFileEaInformation,
  XFileAccessInformation,
  XFileNameInformation,
  XFileRenameInformation,
  XFileLinkInformation,
  XFileNamesInformation,
  XFileDispositionInformation,
  XFilePositionInformation,
  XFileFullEaInformation,
  XFileModeInformation,
  XFileAlignmentInformation,
  XFileAllInformation,
  XFileAllocationInformation,
  XFileEndOfFileInformation,
  XFileAlternateNameInformation,
  XFileStreamInformation,
  XFileMountPartitionInformation,
  XFileMountPartitionsInformation,
  XFilePipeRemoteInformation,
  XFileSectorInformation,
  XFileXctdCompressionInformation,
  XFileCompressionInformation,
  XFileObjectIdInformation,
  XFileCompletionInformation,
  XFileMoveClusterInformation,
  XFileIoPriorityInformation,
  XFileReparsePointInformation,
  XFileNetworkOpenInformation,
  XFileAttributeTagInformation,
  XFileTrackingInformation,
  XFileMaximumInformation 
};
 
#pragma pack(push, 1)
 
struct X_FILE_BASIC_INFORMATION {
  be_u64 creation_time;
  be_u64 last_access_time;
  be_u64 last_write_time;
  be_u64 change_time;
  be_u64 attributes;
};
REX_STATIC_ASSERT_SIZE(X_FILE_BASIC_INFORMATION, 0x28);

struct X_FILE_INTERNAL_INFORMATION {
  be_u64 index_number; 
};
REX_STATIC_ASSERT_SIZE(X_FILE_INTERNAL_INFORMATION, 8);
 
struct X_FILE_RENAME_INFORMATION {
  be_u32 replace_existing; 
  be_u32 root_dir_handle;  
  X_ANSI_STRING ansi_string;
};
REX_STATIC_ASSERT_SIZE(X_FILE_RENAME_INFORMATION, 16);
 
struct X_FILE_DISPOSITION_INFORMATION {
  u8 delete_file; 
};
REX_STATIC_ASSERT_SIZE(X_FILE_DISPOSITION_INFORMATION, 1);
 
struct X_FILE_POSITION_INFORMATION {
  be_u64 current_byte_offset;
};
REX_STATIC_ASSERT_SIZE(X_FILE_POSITION_INFORMATION, 8);
 
struct X_FILE_END_OF_FILE_INFORMATION {
  be_u64 end_of_file; 
};
REX_STATIC_ASSERT_SIZE(X_FILE_END_OF_FILE_INFORMATION, 8);
 
struct X_FILE_ALLOCATION_INFORMATION {
  be_u64 allocation_size; 
};
REX_STATIC_ASSERT_SIZE(X_FILE_ALLOCATION_INFORMATION, 8);

struct X_FILE_XCTD_COMPRESSION_INFORMATION {
  be_u32 unknown;
};
REX_STATIC_ASSERT_SIZE(X_FILE_XCTD_COMPRESSION_INFORMATION, 4);

struct X_FILE_COMPLETION_INFORMATION {
  be_u32 handle;
  be_u32 key;
};
REX_STATIC_ASSERT_SIZE(X_FILE_COMPLETION_INFORMATION, 8);
 
struct X_FILE_NETWORK_OPEN_INFORMATION {
  be_u64 creation_time;
  be_u64 last_access_time;
  be_u64 last_write_time;
  be_u64 change_time;
  be_u64 allocation_size; 
  be_u64 end_of_file;     
  be_u32 attributes;
  be_u32 pad;
};
REX_STATIC_ASSERT_SIZE(X_FILE_NETWORK_OPEN_INFORMATION, 56);
 
#pragma pack(pop)

enum X_FILE_FS_INFORMATION_CLASS : u8 {
  XFileFsVolumeInformation = 1, 
  XFileFsSizeInformation = 3,   
  XFileFsDeviceInformation,
  XFileFsAttributeInformation = 5, 
};

// NOLINTNEXTLINE(performance-enum-size): guest memory field width
enum X_FILE_DEVICE_TYPE : u32 {
  kFileDeviceUnknown = 0x00000022, 
  kFileDeviceEHSTOR = 0x00000046,
};
 
#pragma pack(push, 1)
 
struct X_FILE_FS_VOLUME_INFORMATION {
  be_u64 creation_time;
  be_u32 serial_number;
  be_u32 label_length; 
  u8 supports_objects;
  char label[1]; 
  u8 pad[6];
};
REX_STATIC_ASSERT_SIZE(X_FILE_FS_VOLUME_INFORMATION, 24);
 
struct X_FILE_FS_SIZE_INFORMATION {
  be_u64 total_allocation_units;
  be_u64 available_allocation_units; 
  be_u32 sectors_per_allocation_unit;
  be_u32 bytes_per_sector;
};
REX_STATIC_ASSERT_SIZE(X_FILE_FS_SIZE_INFORMATION, 24);
 
struct X_FILE_FS_ATTRIBUTE_INFORMATION {
  be_u32 attributes;
  be_i32 component_name_max_length; 
  be_u32 name_length;               
  char name[1];                     
  u8 pad[3];
};
REX_STATIC_ASSERT_SIZE(X_FILE_FS_ATTRIBUTE_INFORMATION, 16);
 
struct X_FILE_FS_DEVICE_INFORMATION {
  BE<X_FILE_DEVICE_TYPE> device_type;
  be_u32 characteristics;
};
REX_STATIC_ASSERT_SIZE(X_FILE_FS_DEVICE_INFORMATION, 8);
 
#pragma pack(pop)
 
}  // namespace rex::kernel
 
namespace rex {
namespace kernel {

inline std::string_view TranslateAnsiString(const kernel::GuestAddressSpace* memory,
                                            const X_ANSI_STRING* ansi_string) {
  if (!ansi_string || !ansi_string->length) {
    return "";
  }
  return std::string_view(memory->TranslateVirtual<const char*>(ansi_string->pointer),
                          ansi_string->length);
}

inline std::string TranslateAnsiPath(const kernel::GuestAddressSpace* memory,
                                     const X_ANSI_STRING* ansi_string) {
  return rex::string::TrimString(std::string(TranslateAnsiString(memory, ansi_string)));
}

inline std::string_view TranslateAnsiStringAddress(const kernel::GuestAddressSpace* memory,
                                                   u32 guest_address) {
  if (!guest_address) {
    return "";
  }
  return TranslateAnsiString(memory, memory->TranslateVirtual<const X_ANSI_STRING*>(guest_address));
}

inline std::u16string TranslateUnicodeString(const kernel::GuestAddressSpace* memory,
                                             const X_UNICODE_STRING* unicode_string) {
  if (!unicode_string) {
    return u"";
  }
  u16 length = unicode_string->length;
  if (!length) {
    return u"";
  }
  auto src = memory->TranslateVirtual<const be_u16*>(unicode_string->pointer);
  std::u16string result;
  result.reserve(length);
  for (u16 i = 0; i < length / 2; ++i) {
    result.push_back(src[i]);
  }
  return result;
}
 
}  // namespace kernel
}  // namespace rex