aaru-dps/aaruremote
1
0
Fork 0
mirror of https://github.com/aaru-dps/aaruremote.git synced 2025-12-16 19:24:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename more macros.

Browse Source
This commit is contained in:
Natalia Portillo
2020-03-01 05:50:46 +00:00
parent d4891dc781
commit 6b224c60a3
18 changed files with 328 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
aaruremote.h
View File

@@ -33,107 +33,107 @@
#include <sys/socket.h> #include <sys/socket.h>
#endif #endif
#define DICMOTE_NAME "DiscImageChef Remote Server" #define AARUREMOTE_NAME "DiscImageChef Remote Server"
#define DICMOTE_VERSION "0.99" #define AARUREMOTE_VERSION "0.99"
#define DICMOTE_PORT 6666 #define AARUREMOTE_PORT 6666
#define DICMOTE_REMOTE_ID 0x52434944 // "DICR" #define AARUREMOTE_REMOTE_ID 0x52434944 // "DICR"
#define DICMOTE_PACKET_ID 0x544B4350 // "PCKT" #define AARUREMOTE_PACKET_ID 0x544B4350 // "PCKT"
#define DICMOTE_PACKET_VERSION 1 #define AARUREMOTE_PACKET_VERSION 1
#define DICMOTE_PACKET_TYPE_NOP -1 #define AARUREMOTE_PACKET_TYPE_NOP -1
#define DICMOTE_PACKET_TYPE_HELLO 1 #define AARUREMOTE_PACKET_TYPE_HELLO 1
#define DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES 2 #define AARUREMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES 2
#define DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES 3 #define AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES 3
#define DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE 4 #define AARUREMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE 4
#define DICMOTE_PACKET_TYPE_COMMAND_SCSI 5 #define AARUREMOTE_PACKET_TYPE_COMMAND_SCSI 5
#define DICMOTE_PACKET_TYPE_RESPONSE_SCSI 6 #define AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI 6
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7 #define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8 #define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28 9 #define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28 9
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28 10 #define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28 10
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48 11 #define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48 11
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48 12 #define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48 12
#define DICMOTE_PACKET_TYPE_COMMAND_SDHCI 13 #define AARUREMOTE_PACKET_TYPE_COMMAND_SDHCI 13
#define DICMOTE_PACKET_TYPE_RESPONSE_SDHCI 14 #define AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI 14
#define DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15 #define AARUREMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15
#define DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE 16 #define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE 16
#define DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS 17 #define AARUREMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS 17
#define DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS 18 #define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS 18
#define DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA 19 #define AARUREMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA 19
#define DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA 20 #define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA 20
#define DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA 21 #define AARUREMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA 21
#define DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA 22 #define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA 22
#define DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA 23 #define AARUREMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA 23
#define DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA 24 #define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA 24
#define DICMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE 25 #define AARUREMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE 25
#define DICMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT 26 #define AARUREMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT 26
#define DICMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT 27 #define AARUREMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT 27
#define DICMOTE_PROTOCOL_MAX 1 #define AARUREMOTE_PROTOCOL_MAX 1
#define DICMOTE_PACKET_NOP_REASON_OOO 0 #define AARUREMOTE_PACKET_NOP_REASON_OOO 0
#define DICMOTE_PACKET_NOP_REASON_NOT_IMPLEMENTED 1 #define AARUREMOTE_PACKET_NOP_REASON_NOT_IMPLEMENTED 1
#define DICMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED 2 #define AARUREMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED 2
#define DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES 3 #define AARUREMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES 3
#define DICMOTE_PACKET_NOP_REASON_OPEN_OK 4 #define AARUREMOTE_PACKET_NOP_REASON_OPEN_OK 4
#define DICMOTE_PACKET_NOP_REASON_OPEN_ERROR 5 #define AARUREMOTE_PACKET_NOP_REASON_OPEN_ERROR 5
#define DICMOTE_DEVICE_TYPE_UNKNOWN -1 #define AARUREMOTE_DEVICE_TYPE_UNKNOWN -1
#define DICMOTE_DEVICE_TYPE_ATA 1 #define AARUREMOTE_DEVICE_TYPE_ATA 1
#define DICMOTE_DEVICE_TYPE_ATAPI 2 #define AARUREMOTE_DEVICE_TYPE_ATAPI 2
#define DICMOTE_DEVICE_TYPE_SCSI 3 #define AARUREMOTE_DEVICE_TYPE_SCSI 3
#define DICMOTE_DEVICE_TYPE_SECURE_DIGITAL 4 #define AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL 4
#define DICMOTE_DEVICE_TYPE_MMC 5 #define AARUREMOTE_DEVICE_TYPE_MMC 5
#define DICMOTE_DEVICE_TYPE_NVME 6 #define AARUREMOTE_DEVICE_TYPE_NVME 6
#define DICMOTE_SCSI_DIRECTION_UNSPECIFIED -1 #define AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED -1
#define DICMOTE_SCSI_DIRECTION_NONE 0 #define AARUREMOTE_SCSI_DIRECTION_NONE 0
#define DICMOTE_SCSI_DIRECTION_OUT 1 #define AARUREMOTE_SCSI_DIRECTION_OUT 1
#define DICMOTE_SCSI_DIRECTION_IN 2 #define AARUREMOTE_SCSI_DIRECTION_IN 2
#define DICMOTE_SCSI_DIRECTION_INOUT 3 #define AARUREMOTE_SCSI_DIRECTION_INOUT 3
#define DICMOTE_ATA_PROTOCOL_HARD_RESET 0 #define AARUREMOTE_ATA_PROTOCOL_HARD_RESET 0
#define DICMOTE_ATA_PROTOCOL_SOFT_RESET 1 #define AARUREMOTE_ATA_PROTOCOL_SOFT_RESET 1
#define DICMOTE_ATA_PROTOCOL_NO_DATA 3 #define AARUREMOTE_ATA_PROTOCOL_NO_DATA 3
#define DICMOTE_ATA_PROTOCOL_PIO_IN 4 #define AARUREMOTE_ATA_PROTOCOL_PIO_IN 4
#define DICMOTE_ATA_PROTOCOL_PIO_OUT 5 #define AARUREMOTE_ATA_PROTOCOL_PIO_OUT 5
#define DICMOTE_ATA_PROTOCOL_DMA 6 #define AARUREMOTE_ATA_PROTOCOL_DMA 6
#define DICMOTE_ATA_PROTOCOL_DMA_QUEUED 7 #define AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED 7
#define DICMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC 8 #define AARUREMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC 8
#define DICMOTE_ATA_PROTOCOL_DEVICE_RESET 9 #define AARUREMOTE_ATA_PROTOCOL_DEVICE_RESET 9
#define DICMOTE_ATA_PROTOCOL_UDMA_IN 10 #define AARUREMOTE_ATA_PROTOCOL_UDMA_IN 10
#define DICMOTE_ATA_PROTOCOL_UDMA_OUT 11 #define AARUREMOTE_ATA_PROTOCOL_UDMA_OUT 11
#define DICMOTE_ATA_PROTOCOL_FPDMA 12 #define AARUREMOTE_ATA_PROTOCOL_FPDMA 12
#define DICMOTE_ATA_PROTOCOL_RETURN_RESPONSE 15 #define AARUREMOTE_ATA_PROTOCOL_RETURN_RESPONSE 15
#define DICMOTE_ATA_TRANSFER_REGISTER_NONE 0 #define AARUREMOTE_ATA_TRANSFER_REGISTER_NONE 0
#define DICMOTE_ATA_TRANSFER_REGISTER_FEATURE 1 #define AARUREMOTE_ATA_TRANSFER_REGISTER_FEATURE 1
#define DICMOTE_ATA_TRANSFER_REGISTER_SECTOR_COUNT 2 #define AARUREMOTE_ATA_TRANSFER_REGISTER_SECTOR_COUNT 2
#define DICMOTE_ATA_TRANSFER_REGISTER_SPTSIU 3 #define AARUREMOTE_ATA_TRANSFER_REGISTER_SPTSIU 3
#define DICMOTE_MMC_RESPONSE_PRESENT (1 << 0) #define AARUREMOTE_MMC_RESPONSE_PRESENT (1 << 0)
#define DICMOTE_MMC_RESPONSE_136 (1 << 1) #define AARUREMOTE_MMC_RESPONSE_136 (1 << 1)
#define DICMOTE_MMC_RESPONSE_CRC (1 << 2) #define AARUREMOTE_MMC_RESPONSE_CRC (1 << 2)
#define DICMOTE_MMC_RESPONSE_BUSY (1 << 3) #define AARUREMOTE_MMC_RESPONSE_BUSY (1 << 3)
#define DICMOTE_MMC_RESPONSE_OPCODE (1 << 4) #define AARUREMOTE_MMC_RESPONSE_OPCODE (1 << 4)
#define DICMOTE_MMC_COMMAND_MASK (3 << 5) #define AARUREMOTE_MMC_COMMAND_MASK (3 << 5)
#define DICMOTE_MMC_COMMAND_AC (0 << 5) #define AARUREMOTE_MMC_COMMAND_AC (0 << 5)
#define DICMOTE_MMC_COMMAND_ADTC (1 << 5) #define AARUREMOTE_MMC_COMMAND_ADTC (1 << 5)
#define DICMOTE_MMC_COMMAND_BC (2 << 5) #define AARUREMOTE_MMC_COMMAND_BC (2 << 5)
#define DICMOTE_MMC_COMMAND_BCR (3 << 5) #define AARUREMOTE_MMC_COMMAND_BCR (3 << 5)
#define DICMOTE_MMC_RESPONSE_SPI_S1 (1 << 7) #define AARUREMOTE_MMC_RESPONSE_SPI_S1 (1 << 7)
#define DICMOTE_MMC_RESPONSE_SPI_S2 (1 << 8) #define AARUREMOTE_MMC_RESPONSE_SPI_S2 (1 << 8)
#define DICMOTE_MMC_RESPONSE_SPI_B4 (1 << 9) #define AARUREMOTE_MMC_RESPONSE_SPI_B4 (1 << 9)
#define DICMOTE_MMC_RESPONSE_SPI_BUSY (1 << 10) #define AARUREMOTE_MMC_RESPONSE_SPI_BUSY (1 << 10)
#define DICMOTE_MMC_RESPONSE_NONE (0) #define AARUREMOTE_MMC_RESPONSE_NONE (0)
#define DICMOTE_MMC_RESPONSE_R1 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE #define AARUREMOTE_MMC_RESPONSE_R1 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE
#define DICMOTE_MMC_RESPONSE_R1B \ #define AARUREMOTE_MMC_RESPONSE_R1B \
DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE | DICMOTE_MMC_RESPONSE_BUSY AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE | AARUREMOTE_MMC_RESPONSE_BUSY
#define DICMOTE_MMC_RESPONSE_R2 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_136 | DICMOTE_MMC_RESPONSE_CRC #define AARUREMOTE_MMC_RESPONSE_R2 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_136 | AARUREMOTE_MMC_RESPONSE_CRC
#define DICMOTE_MMC_RESPONSE_R3 DICMOTE_MMC_RESPONSE_PRESENT #define AARUREMOTE_MMC_RESPONSE_R3 AARUREMOTE_MMC_RESPONSE_PRESENT
#define DICMOTE_MMC_RESPONSE_R4 DICMOTE_MMC_RESPONSE_PRESENT #define AARUREMOTE_MMC_RESPONSE_R4 AARUREMOTE_MMC_RESPONSE_PRESENT
#define DICMOTE_MMC_RESPONSE_R5 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE #define AARUREMOTE_MMC_RESPONSE_R5 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE
#define DICMOTE_MMC_RESPONSE_R6 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE #define AARUREMOTE_MMC_RESPONSE_R6 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE
#define DICMOTE_MMC_RESPONSE_R7 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE #define AARUREMOTE_MMC_RESPONSE_R7 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE
#define DICMOTE_MMC_RESPONSE_SPI_R1 DICMOTE_MMC_RESPONSE_SPI_S1 #define AARUREMOTE_MMC_RESPONSE_SPI_R1 AARUREMOTE_MMC_RESPONSE_SPI_S1
#define DICMOTE_MMC_RESPONSE_SPI_R1B DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_BUSY #define AARUREMOTE_MMC_RESPONSE_SPI_R1B AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_BUSY
#define DICMOTE_MMC_RESPONSE_SPI_R2 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_S2 #define AARUREMOTE_MMC_RESPONSE_SPI_R2 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_S2
#define DICMOTE_MMC_RESPONSE_SPI_R3 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 #define AARUREMOTE_MMC_RESPONSE_SPI_R3 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4
#define DICMOTE_MMC_RESPONSE_SPI_R4 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 #define AARUREMOTE_MMC_RESPONSE_SPI_R4 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4
#define DICMOTE_MMC_RESPONSE_SPI_R5 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_S2 #define AARUREMOTE_MMC_RESPONSE_SPI_R5 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_S2
#define DICMOTE_MMC_RESPONSE_SPI_R7 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 #define AARUREMOTE_MMC_RESPONSE_SPI_R7 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4
#pragma pack(push, 1) #pragma pack(push, 1)

2
device.c
View File

@@ -52,7 +52,7 @@ int32_t GetDeviceType(void* device_ctx)
#elif defined(WIN32) #elif defined(WIN32)
return Win32GetDeviceType(device_ctx); return Win32GetDeviceType(device_ctx);
#else #else
return DICMOTE_DEVICE_TYPE_UNKNOWN; return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
#endif #endif
} }

40
linux/ata.c
View File

@@ -23,17 +23,17 @@ int32_t AtaProtocolToScsiDirection(uint8_t protocol)
{ {
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC: case AARUREMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC:
case DICMOTE_ATA_PROTOCOL_DEVICE_RESET: case AARUREMOTE_ATA_PROTOCOL_DEVICE_RESET:
case DICMOTE_ATA_PROTOCOL_HARD_RESET: case AARUREMOTE_ATA_PROTOCOL_HARD_RESET:
case DICMOTE_ATA_PROTOCOL_NO_DATA: case AARUREMOTE_ATA_PROTOCOL_NO_DATA:
case DICMOTE_ATA_PROTOCOL_SOFT_RESET: case AARUREMOTE_ATA_PROTOCOL_SOFT_RESET:
case DICMOTE_ATA_PROTOCOL_RETURN_RESPONSE: return DICMOTE_SCSI_DIRECTION_NONE; case AARUREMOTE_ATA_PROTOCOL_RETURN_RESPONSE: return AARUREMOTE_SCSI_DIRECTION_NONE;
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: return DICMOTE_SCSI_DIRECTION_IN; case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: return AARUREMOTE_SCSI_DIRECTION_IN;
case DICMOTE_ATA_PROTOCOL_PIO_OUT: case AARUREMOTE_ATA_PROTOCOL_PIO_OUT:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: return DICMOTE_SCSI_DIRECTION_OUT; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: return AARUREMOTE_SCSI_DIRECTION_OUT;
default: return DICMOTE_SCSI_DIRECTION_UNSPECIFIED; default: return AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED;
} }
} }
@@ -62,12 +62,12 @@ int32_t LinuxSendAtaChsCommand(void* device_ctx,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != AARUREMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != AARUREMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break;
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }
@@ -137,12 +137,12 @@ int32_t LinuxSendAtaLba28Command(void* device_ctx,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != AARUREMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != AARUREMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break;
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }
@@ -215,12 +215,12 @@ int32_t LinuxSendAtaLba48Command(void* device_ctx,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
cdb[1] |= 0x01; cdb[1] |= 0x01;
if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != AARUREMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != AARUREMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break;
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }

36
linux/device.c
View File

@@ -75,17 +75,17 @@ int32_t LinuxGetDeviceType(void* device_ctx)
struct udev_device* udev_device; struct udev_device* udev_device;
const char* tmp_string; const char* tmp_string;
char* chrptr; char* chrptr;
int32_t device_type = DICMOTE_DEVICE_TYPE_UNKNOWN; int32_t device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
udev = udev_new(); udev = udev_new();
if(!udev) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(!udev) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
chrptr = strrchr(ctx->device_path, '/'); chrptr = strrchr(ctx->device_path, '/');
if(chrptr == 0) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(chrptr == 0) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
chrptr++; chrptr++;
if(chrptr == 0) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(chrptr == 0) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
udev_device = udev_device_new_from_subsystem_sysname(udev, "block", chrptr); udev_device = udev_device_new_from_subsystem_sysname(udev, "block", chrptr);
if(udev_device) if(udev_device)
@@ -95,7 +95,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
{ {
if(strncmp(tmp_string, "ata", 3) == 0) if(strncmp(tmp_string, "ata", 3) == 0)
{ {
device_type = DICMOTE_DEVICE_TYPE_ATA; device_type = AARUREMOTE_DEVICE_TYPE_ATA;
free((void*)tmp_string); free((void*)tmp_string);
tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE"); tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE");
@@ -103,7 +103,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
if(tmp_string) if(tmp_string)
{ {
// TODO: ATAPI removable non optical disks // TODO: ATAPI removable non optical disks
if(strncmp(tmp_string, "cd", 2) == 0) { device_type = DICMOTE_DEVICE_TYPE_ATAPI; } if(strncmp(tmp_string, "cd", 2) == 0) { device_type = AARUREMOTE_DEVICE_TYPE_ATAPI; }
free((void*)tmp_string); free((void*)tmp_string);
} }
@@ -113,14 +113,14 @@ int32_t LinuxGetDeviceType(void* device_ctx)
free((void*)tmp_string); free((void*)tmp_string);
tmp_string = malloc(1024); tmp_string = malloc(1024);
device_type = DICMOTE_DEVICE_TYPE_MMC; device_type = AARUREMOTE_DEVICE_TYPE_MMC;
if(tmp_string) if(tmp_string)
{ {
memset((void*)tmp_string, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmp_string, 1024, "/sys/block/%s/device/scr", chrptr); snprintf((char*)tmp_string, 1024, "/sys/block/%s/device/scr", chrptr);
if(access(tmp_string, R_OK) == 0) device_type = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL; if(access(tmp_string, R_OK) == 0) device_type = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL;
free((void*)tmp_string); free((void*)tmp_string);
} }
@@ -134,7 +134,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
if(tmp_string) if(tmp_string)
{ {
if(strncmp(tmp_string, "cd", 2) == 0 || strncmp(tmp_string, "disk", 4) == 0) if(strncmp(tmp_string, "cd", 2) == 0 || strncmp(tmp_string, "disk", 4) == 0)
{ device_type = DICMOTE_DEVICE_TYPE_SCSI; } { device_type = AARUREMOTE_DEVICE_TYPE_SCSI; }
free((void*)tmp_string); free((void*)tmp_string);
} }
@@ -142,7 +142,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
else if(strncmp(tmp_string, "nvme", 4) == 0) else if(strncmp(tmp_string, "nvme", 4) == 0)
{ {
free((void*)tmp_string); free((void*)tmp_string);
device_type = DICMOTE_DEVICE_TYPE_NVME; device_type = AARUREMOTE_DEVICE_TYPE_NVME;
} }
} }
} }
@@ -151,7 +151,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
return device_type; return device_type;
#else #else
int32_t dev_type = DICMOTE_DEVICE_TYPE_UNKNOWN; int32_t dev_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
const char* dev_name; const char* dev_name;
const char* sysfs_path; const char* sysfs_path;
char* dev_path; char* dev_path;
@@ -169,13 +169,13 @@ int32_t LinuxGetDeviceType(void* device_ctx)
if(strlen(ctx->device_path) <= 5) return dev_type; if(strlen(ctx->device_path) <= 5) return dev_type;
if(strstr(ctx->device_path, "nvme")) return DICMOTE_DEVICE_TYPE_NVME; if(strstr(ctx->device_path, "nvme")) return AARUREMOTE_DEVICE_TYPE_NVME;
dev_name = ctx->device_path + 5; dev_name = ctx->device_path + 5;
if(strstr(ctx->device_path, "mmcblk")) if(strstr(ctx->device_path, "mmcblk"))
{ {
dev_type = DICMOTE_DEVICE_TYPE_MMC; dev_type = AARUREMOTE_DEVICE_TYPE_MMC;
sysfs_path_scr = malloc(len); sysfs_path_scr = malloc(len);
@@ -183,7 +183,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
{ {
snprintf(sysfs_path_scr, len, "/sys/block/%s/device/scr", dev_name); snprintf(sysfs_path_scr, len, "/sys/block/%s/device/scr", dev_name);
if(access(sysfs_path_scr, F_OK) == 0) dev_type = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL; if(access(sysfs_path_scr, F_OK) == 0) dev_type = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL;
free(sysfs_path_scr); free(sysfs_path_scr);
} }
@@ -264,10 +264,10 @@ int32_t LinuxGetDeviceType(void* device_ctx)
if(access(spi_path, F_OK) == 0 || access(fc_path, F_OK) == 0 || access(sas_path, F_OK) == 0 || if(access(spi_path, F_OK) == 0 || access(fc_path, F_OK) == 0 || access(sas_path, F_OK) == 0 ||
access(iscsi_path, F_OK) == 0) access(iscsi_path, F_OK) == 0)
dev_type = DICMOTE_DEVICE_TYPE_SCSI; dev_type = AARUREMOTE_DEVICE_TYPE_SCSI;
else if(access(scsi_path, F_OK) == 0) else if(access(scsi_path, F_OK) == 0)
{ {
dev_type = DICMOTE_DEVICE_TYPE_SCSI; dev_type = AARUREMOTE_DEVICE_TYPE_SCSI;
memset(scsi_path, 0, len); memset(scsi_path, 0, len);
snprintf(scsi_path, len, "/sys/class/scsi_host/host%s/proc_name", host_no); snprintf(scsi_path, len, "/sys/class/scsi_host/host%s/proc_name", host_no);
if(access(scsi_path, F_OK) == 0) if(access(scsi_path, F_OK) == 0)
@@ -287,7 +287,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
if(strncmp(scsi_path, "ata", 3) == 0 || strncmp(scsi_path, "sata", 4) == 0 || if(strncmp(scsi_path, "ata", 3) == 0 || strncmp(scsi_path, "sata", 4) == 0 ||
strncmp(scsi_path, "ahci", 4) == 0) strncmp(scsi_path, "ahci", 4) == 0)
{ {
dev_type = DICMOTE_DEVICE_TYPE_ATA; dev_type = AARUREMOTE_DEVICE_TYPE_ATA;
memset(scsi_path, 0, len); memset(scsi_path, 0, len);
snprintf(scsi_path, len, "%s/%s/removable", PATH_SYS_DEVBLOCK, dev_name); snprintf(scsi_path, len, "%s/%s/removable", PATH_SYS_DEVBLOCK, dev_name);
@@ -297,7 +297,7 @@ int32_t LinuxGetDeviceType(void* device_ctx)
ret = (size_t)fread(scsi_path, 1, 1, file); ret = (size_t)fread(scsi_path, 1, 1, file);
if(ret == 1) if(ret == 1)
{ {
if(scsi_path[0] == '1') dev_type = DICMOTE_DEVICE_TYPE_ATAPI; if(scsi_path[0] == '1') dev_type = AARUREMOTE_DEVICE_TYPE_ATAPI;
} }
fclose(file); fclose(file);
} }

12
linux/list_devices.c
View File

@@ -143,12 +143,12 @@ DeviceInfoList* LinuxListDevices()
switch(GetDeviceType(tmp_string)) switch(GetDeviceType(tmp_string))
{ {
case DICMOTE_DEVICE_TYPE_ATA: strncpy(list_next->this.bus, "ATA", 256); break; case AARUREMOTE_DEVICE_TYPE_ATA: strncpy(list_next->this.bus, "ATA", 256); break;
case DICMOTE_DEVICE_TYPE_ATAPI: strncpy(list_next->this.bus, "ATAPI", 256); break; case AARUREMOTE_DEVICE_TYPE_ATAPI: strncpy(list_next->this.bus, "ATAPI", 256); break;
case DICMOTE_DEVICE_TYPE_MMC: case AARUREMOTE_DEVICE_TYPE_MMC:
case DICMOTE_DEVICE_TYPE_SECURE_DIGITAL: strncpy(list_next->this.bus, "MMC/SD", 256); break; case AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL: strncpy(list_next->this.bus, "MMC/SD", 256); break;
case DICMOTE_DEVICE_TYPE_NVME: strncpy(list_next->this.bus, "NVMe", 256); break; case AARUREMOTE_DEVICE_TYPE_NVME: strncpy(list_next->this.bus, "NVMe", 256); break;
case DICMOTE_DEVICE_TYPE_SCSI: case AARUREMOTE_DEVICE_TYPE_SCSI:
memset((void*)tmp_string, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmp_string, 1024, "%s/%s/device", PATH_SYS_DEVBLOCK, dirent->d_name); snprintf((char*)tmp_string, 1024, "%s/%s/device", PATH_SYS_DEVBLOCK, dirent->d_name);
line_str = malloc(1024); line_str = malloc(1024);

10
linux/scsi.c
View File

@@ -50,11 +50,11 @@ int32_t LinuxSendScsiCommand(void* device_ctx,
switch(direction) switch(direction)
{ {
case DICMOTE_SCSI_DIRECTION_IN: dir = SG_DXFER_FROM_DEV; break; case AARUREMOTE_SCSI_DIRECTION_IN: dir = SG_DXFER_FROM_DEV; break;
case DICMOTE_SCSI_DIRECTION_OUT: dir = SG_DXFER_TO_DEV; break; case AARUREMOTE_SCSI_DIRECTION_OUT: dir = SG_DXFER_TO_DEV; break;
case DICMOTE_SCSI_DIRECTION_INOUT: case AARUREMOTE_SCSI_DIRECTION_INOUT:
case DICMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SG_DXFER_TO_FROM_DEV; break; case AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SG_DXFER_TO_FROM_DEV; break;
case DICMOTE_SCSI_DIRECTION_NONE: case AARUREMOTE_SCSI_DIRECTION_NONE:
default: dir = SG_DXFER_NONE; break; default: dir = SG_DXFER_NONE; break;
} }

2
main.c
View File

@@ -28,7 +28,7 @@ int main()
Initialize(); Initialize();
printf("Aaru Remote Server %s\n", DICMOTE_VERSION); printf("Aaru Remote Server %s\n", AARUREMOTE_VERSION);
printf("Copyright (C) 2019-2020 Natalia Portillo\n"); printf("Copyright (C) 2019-2020 Natalia Portillo\n");
pkt_server_hello = GetHello(); pkt_server_hello = GetHello();

14
unix/hello.c
View File

@@ -37,14 +37,14 @@ DicPacketHello* GetHello()
memset(pkt_server_hello, 0, sizeof(DicPacketHello)); memset(pkt_server_hello, 0, sizeof(DicPacketHello));
pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello));
pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO;
strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME));
strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION));
pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX;
strncpy(pkt_server_hello->sysname, utsname.sysname, 255); strncpy(pkt_server_hello->sysname, utsname.sysname, 255);
strncpy(pkt_server_hello->release, utsname.release, 255); strncpy(pkt_server_hello->release, utsname.release, 255);
strncpy(pkt_server_hello->machine, utsname.machine, 255); strncpy(pkt_server_hello->machine, utsname.machine, 255);

2
unix/network.c
View File

@@ -44,7 +44,7 @@ int PrintNetworkAddresses()
if(ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) if(ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET)
{ {
inet_ntop(AF_INET, &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr, ipv4_address, INET_ADDRSTRLEN); inet_ntop(AF_INET, &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr, ipv4_address, INET_ADDRSTRLEN);
printf("%s port %d\n", ipv4_address, DICMOTE_PORT); printf("%s port %d\n", ipv4_address, AARUREMOTE_PORT);
} }
ifa = ifa->ifa_next; ifa = ifa->ifa_next;

14
wii/hello.c
View File

@@ -33,14 +33,14 @@ DicPacketHello* GetHello()
memset(pkt_server_hello, 0, sizeof(DicPacketHello)); memset(pkt_server_hello, 0, sizeof(DicPacketHello));
pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello));
pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO;
strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME));
strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION));
pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX;
snprintf(pkt_server_hello->sysname, 255, "Nintendo Wii IOS %d", IOS_GetVersion()); snprintf(pkt_server_hello->sysname, 255, "Nintendo Wii IOS %d", IOS_GetVersion());
snprintf(pkt_server_hello->release, 255, "%d", IOS_GetRevision()); snprintf(pkt_server_hello->release, 255, "%d", IOS_GetRevision());
strncpy(pkt_server_hello->machine, "ppc", 255); strncpy(pkt_server_hello->machine, "ppc", 255);

2
wii/network.c
View File

@@ -34,7 +34,7 @@ int PrintNetworkAddresses()
if(ret < 0) return -1; if(ret < 0) return -1;
printf("Available addresses:\n"); printf("Available addresses:\n");
printf("%s port %d\n", localip, DICMOTE_PORT); printf("%s port %d\n", localip, AARUREMOTE_PORT);
return 0; return 0;
} }

60
win32/ata.c
View File

@@ -78,20 +78,20 @@ int32_t Win32SendAtaChsCommand(void* device_ctx,
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break;
case DICMOTE_ATA_PROTOCOL_PIO_OUT: case AARUREMOTE_ATA_PROTOCOL_PIO_OUT:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break;
} }
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_DMA: case AARUREMOTE_ATA_PROTOCOL_DMA:
case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case DICMOTE_ATA_PROTOCOL_FPDMA: case AARUREMOTE_ATA_PROTOCOL_FPDMA:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break;
} }
// Unknown if needed // Unknown if needed
@@ -188,20 +188,20 @@ int32_t Win32SendAtaLba28Command(void* device_ctx,
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break;
case DICMOTE_ATA_PROTOCOL_PIO_OUT: case AARUREMOTE_ATA_PROTOCOL_PIO_OUT:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break;
} }
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_DMA: case AARUREMOTE_ATA_PROTOCOL_DMA:
case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case DICMOTE_ATA_PROTOCOL_FPDMA: case AARUREMOTE_ATA_PROTOCOL_FPDMA:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break;
} }
// Unknown if needed // Unknown if needed
@@ -303,20 +303,20 @@ int32_t Win32SendAtaLba48Command(void* device_ctx,
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_PIO_IN: case AARUREMOTE_ATA_PROTOCOL_PIO_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break;
case DICMOTE_ATA_PROTOCOL_PIO_OUT: case AARUREMOTE_ATA_PROTOCOL_PIO_OUT:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break;
} }
switch(protocol) switch(protocol)
{ {
case DICMOTE_ATA_PROTOCOL_DMA: case AARUREMOTE_ATA_PROTOCOL_DMA:
case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED:
case DICMOTE_ATA_PROTOCOL_FPDMA: case AARUREMOTE_ATA_PROTOCOL_FPDMA:
case DICMOTE_ATA_PROTOCOL_UDMA_IN: case AARUREMOTE_ATA_PROTOCOL_UDMA_IN:
case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break;
} }
apte->AtaFlags |= ATA_FLAGS_48BIT_COMMAND; apte->AtaFlags |= ATA_FLAGS_48BIT_COMMAND;

32
win32/device.c
View File

@@ -77,7 +77,7 @@ int32_t Win32GetDeviceType(void* device_ctx)
buf = malloc(1000); buf = malloc(1000);
if(!buf) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(!buf) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
query.PropertyId = StorageDeviceProperty; query.PropertyId = StorageDeviceProperty;
query.QueryType = PropertyStandardQuery; query.QueryType = PropertyStandardQuery;
@@ -92,27 +92,27 @@ int32_t Win32GetDeviceType(void* device_ctx)
if(!ret && error != 0) if(!ret && error != 0)
{ {
free(buf); free(buf);
return DICMOTE_DEVICE_TYPE_UNKNOWN; return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
} }
descriptor = (PSTORAGE_DEVICE_DESCRIPTOR)buf; descriptor = (PSTORAGE_DEVICE_DESCRIPTOR)buf;
switch(descriptor->BusType) switch(descriptor->BusType)
{ {
case 1: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 1: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 2: returned = DICMOTE_DEVICE_TYPE_ATAPI; break; case 2: returned = AARUREMOTE_DEVICE_TYPE_ATAPI; break;
case 3: returned = DICMOTE_DEVICE_TYPE_ATA; break; case 3: returned = AARUREMOTE_DEVICE_TYPE_ATA; break;
case 4: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 4: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 5: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 5: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 6: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 6: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 7: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 7: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 9: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 9: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 0xA: returned = DICMOTE_DEVICE_TYPE_SCSI; break; case 0xA: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break;
case 0xB: returned = DICMOTE_DEVICE_TYPE_ATA; break; case 0xB: returned = AARUREMOTE_DEVICE_TYPE_ATA; break;
case 0xC: returned = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL; break; case 0xC: returned = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL; break;
case 0xD: returned = DICMOTE_DEVICE_TYPE_MMC; break; case 0xD: returned = AARUREMOTE_DEVICE_TYPE_MMC; break;
case 0x11: returned = DICMOTE_DEVICE_TYPE_NVME; break; case 0x11: returned = AARUREMOTE_DEVICE_TYPE_NVME; break;
default: returned = DICMOTE_DEVICE_TYPE_UNKNOWN; break; default: returned = AARUREMOTE_DEVICE_TYPE_UNKNOWN; break;
} }
free(buf); free(buf);

14
win32/hello.c
View File

@@ -63,14 +63,14 @@ DicPacketHello* GetHello()
memset(pkt_server_hello, 0, sizeof(DicPacketHello)); memset(pkt_server_hello, 0, sizeof(DicPacketHello));
pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello));
pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO;
strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME));
strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION));
pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

2
win32/network.c
View File

@@ -61,7 +61,7 @@ int PrintNetworkAddresses()
while(pUnicast != NULL) while(pUnicast != NULL)
{ {
printf( printf(
"%s port %d\n", inet_ntoa(((struct sockaddr_in*)pUnicast->Address.lpSockaddr)->sin_addr), DICMOTE_PORT); "%s port %d\n", inet_ntoa(((struct sockaddr_in*)pUnicast->Address.lpSockaddr)->sin_addr), AARUREMOTE_PORT);
pUnicast = pUnicast->Next; pUnicast = pUnicast->Next;
} }

10
win32/scsi.c
View File

@@ -69,11 +69,11 @@ int32_t Win32SendScsiCommand(void* device_ctx,
switch(direction) switch(direction)
{ {
case DICMOTE_SCSI_DIRECTION_IN: dir = SCSI_IOCTL_DATA_IN; break; case AARUREMOTE_SCSI_DIRECTION_IN: dir = SCSI_IOCTL_DATA_IN; break;
case DICMOTE_SCSI_DIRECTION_OUT: dir = SCSI_IOCTL_DATA_OUT; break; case AARUREMOTE_SCSI_DIRECTION_OUT: dir = SCSI_IOCTL_DATA_OUT; break;
case DICMOTE_SCSI_DIRECTION_INOUT: case AARUREMOTE_SCSI_DIRECTION_INOUT:
case DICMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SCSI_IOCTL_DATA_BIDIRECTIONAL; break; case AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SCSI_IOCTL_DATA_BIDIRECTIONAL; break;
case DICMOTE_SCSI_DIRECTION_NONE: case AARUREMOTE_SCSI_DIRECTION_NONE:
default: dir = SCSI_IOCTL_DATA_UNSPECIFIED; break; default: dir = SCSI_IOCTL_DATA_UNSPECIFIED; break;
} }

24
win32/sdhci.c
View File

@@ -71,22 +71,22 @@ int32_t Win32SendSdhciCommand(void* device_ctx,
cmd_descriptor->Cmd = command; cmd_descriptor->Cmd = command;
cmd_descriptor->CmdClass = application ? SDCC_APP_CMD : SDCC_STANDARD; cmd_descriptor->CmdClass = application ? SDCC_APP_CMD : SDCC_STANDARD;
cmd_descriptor->TransferDirection = write ? SDTD_WRITE : SDTD_READ; cmd_descriptor->TransferDirection = write ? SDTD_WRITE : SDTD_READ;
cmd_descriptor->TransferType = (flags & DICMOTE_MMC_COMMAND_ADTC) ? SDTT_SINGLE_BLOCK : SDTT_CMD_ONLY; cmd_descriptor->TransferType = (flags & AARUREMOTE_MMC_COMMAND_ADTC) ? SDTT_SINGLE_BLOCK : SDTT_CMD_ONLY;
cmd_descriptor->ResponseType = 0; cmd_descriptor->ResponseType = 0;
if((flags & DICMOTE_MMC_RESPONSE_R1) || (flags & DICMOTE_MMC_RESPONSE_SPI_R1)) if((flags & AARUREMOTE_MMC_RESPONSE_R1) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R1))
cmd_descriptor->ResponseType = SDRT_1; cmd_descriptor->ResponseType = SDRT_1;
if((flags & DICMOTE_MMC_RESPONSE_R1B) || (flags & DICMOTE_MMC_RESPONSE_SPI_R1B)) if((flags & AARUREMOTE_MMC_RESPONSE_R1B) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R1B))
cmd_descriptor->ResponseType = SDRT_1B; cmd_descriptor->ResponseType = SDRT_1B;
if((flags & DICMOTE_MMC_RESPONSE_R2) || (flags & DICMOTE_MMC_RESPONSE_SPI_R2)) if((flags & AARUREMOTE_MMC_RESPONSE_R2) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R2))
cmd_descriptor->ResponseType = SDRT_2; cmd_descriptor->ResponseType = SDRT_2;
if((flags & DICMOTE_MMC_RESPONSE_R3) || (flags & DICMOTE_MMC_RESPONSE_SPI_R3)) if((flags & AARUREMOTE_MMC_RESPONSE_R3) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R3))
cmd_descriptor->ResponseType = SDRT_3; cmd_descriptor->ResponseType = SDRT_3;
if((flags & DICMOTE_MMC_RESPONSE_R4) || (flags & DICMOTE_MMC_RESPONSE_SPI_R4)) if((flags & AARUREMOTE_MMC_RESPONSE_R4) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R4))
cmd_descriptor->ResponseType = SDRT_4; cmd_descriptor->ResponseType = SDRT_4;
if((flags & DICMOTE_MMC_RESPONSE_R5) || (flags & DICMOTE_MMC_RESPONSE_SPI_R5)) if((flags & AARUREMOTE_MMC_RESPONSE_R5) || (flags & AARUREMOTE_MMC_RESPONSE_SPI_R5))
cmd_descriptor->ResponseType = SDRT_5; cmd_descriptor->ResponseType = SDRT_5;
if((flags & DICMOTE_MMC_RESPONSE_R6)) cmd_descriptor->ResponseType = SDRT_6; if((flags & AARUREMOTE_MMC_RESPONSE_R6)) cmd_descriptor->ResponseType = SDRT_6;
QueryPerformanceFrequency(&frequency); QueryPerformanceFrequency(&frequency);
QueryPerformanceCounter(&start); QueryPerformanceCounter(&start);
@@ -152,7 +152,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx,
9, 9,
0, 0,
0, 0,
DICMOTE_MMC_RESPONSE_SPI_R2 | DICMOTE_MMC_RESPONSE_R2 | DICMOTE_MMC_COMMAND_AC, AARUREMOTE_MMC_RESPONSE_SPI_R2 | AARUREMOTE_MMC_RESPONSE_R2 | AARUREMOTE_MMC_COMMAND_AC,
0, 0,
16, 16,
1, 1,
@@ -177,7 +177,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx,
10, 10,
0, 0,
0, 0,
DICMOTE_MMC_RESPONSE_SPI_R2 | DICMOTE_MMC_RESPONSE_R2 | DICMOTE_MMC_COMMAND_AC, AARUREMOTE_MMC_RESPONSE_SPI_R2 | AARUREMOTE_MMC_RESPONSE_R2 | AARUREMOTE_MMC_COMMAND_AC,
0, 0,
16, 16,
1, 1,
@@ -202,7 +202,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx,
10, 10,
0, 0,
0, 0,
DICMOTE_MMC_RESPONSE_SPI_R1 | DICMOTE_MMC_RESPONSE_R1 | DICMOTE_MMC_COMMAND_ADTC, AARUREMOTE_MMC_RESPONSE_SPI_R1 | AARUREMOTE_MMC_RESPONSE_R1 | AARUREMOTE_MMC_COMMAND_ADTC,
0, 0,
8, 8,
1, 1,
@@ -227,7 +227,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx,
*scr_len > 0 ? 41 : 1, *scr_len > 0 ? 41 : 1,
0, 0,
0, 0,
DICMOTE_MMC_RESPONSE_SPI_R1 | DICMOTE_MMC_RESPONSE_R1 | DICMOTE_MMC_COMMAND_ADTC, AARUREMOTE_MMC_RESPONSE_SPI_R1 | AARUREMOTE_MMC_RESPONSE_R1 | AARUREMOTE_MMC_COMMAND_ADTC,
0, 0,
4, 4,
1, 1,

178
worker.c
View File

@@ -96,7 +96,7 @@ void* WorkingLoop(void* arguments)
serv_addr.sin_family = AF_INET; serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(DICMOTE_PORT); serv_addr.sin_port = htons(AARUREMOTE_PORT);
if(NetBind(net_ctx, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) if(NetBind(net_ctx, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
{ {
@@ -125,11 +125,11 @@ void* WorkingLoop(void* arguments)
memset(pkt_nop, 0, sizeof(DicPacketNop)); memset(pkt_nop, 0, sizeof(DicPacketNop));
pkt_nop->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_nop->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_nop->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_nop->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_nop->hdr.len = htole32(sizeof(DicPacketNop)); pkt_nop->hdr.len = htole32(sizeof(DicPacketNop));
pkt_nop->hdr.version = DICMOTE_PACKET_VERSION; pkt_nop->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_nop->hdr.packet_type = DICMOTE_PACKET_TYPE_NOP; pkt_nop->hdr.packet_type = AARUREMOTE_PACKET_TYPE_NOP;
for(;;) for(;;)
{ {
@@ -179,7 +179,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
if(pkt_hdr->remote_id != htole32(DICMOTE_REMOTE_ID) || pkt_hdr->packet_id != htole32(DICMOTE_PACKET_ID)) if(pkt_hdr->remote_id != htole32(AARUREMOTE_REMOTE_ID) || pkt_hdr->packet_id != htole32(AARUREMOTE_PACKET_ID))
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
free(pkt_hdr); free(pkt_hdr);
@@ -187,7 +187,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
if(pkt_hdr->version != DICMOTE_PACKET_VERSION) if(pkt_hdr->version != AARUREMOTE_PACKET_VERSION)
{ {
printf("Unrecognized packet version, closing connection...\n"); printf("Unrecognized packet version, closing connection...\n");
free(pkt_hdr); free(pkt_hdr);
@@ -195,7 +195,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
if(pkt_hdr->packet_type != DICMOTE_PACKET_TYPE_HELLO) if(pkt_hdr->packet_type != AARUREMOTE_PACKET_TYPE_HELLO)
{ {
printf("Expecting hello packet type, received type %d, closing connection...\n", pkt_hdr->packet_type); printf("Expecting hello packet type, received type %d, closing connection...\n", pkt_hdr->packet_type);
free(pkt_hdr); free(pkt_hdr);
@@ -272,7 +272,7 @@ void* WorkingLoop(void* arguments)
break; break;
} }
if(pkt_hdr->remote_id != htole32(DICMOTE_REMOTE_ID) || pkt_hdr->packet_id != htole32(DICMOTE_PACKET_ID)) if(pkt_hdr->remote_id != htole32(AARUREMOTE_REMOTE_ID) || pkt_hdr->packet_id != htole32(AARUREMOTE_PACKET_ID))
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
NetClose(cli_ctx); NetClose(cli_ctx);
@@ -280,7 +280,7 @@ void* WorkingLoop(void* arguments)
break; break;
} }
if(pkt_hdr->version != DICMOTE_PACKET_VERSION) if(pkt_hdr->version != AARUREMOTE_PACKET_VERSION)
{ {
printf("Unrecognized packet version, skipping...\n"); printf("Unrecognized packet version, skipping...\n");
skip_next_hdr = 1; skip_next_hdr = 1;
@@ -289,15 +289,15 @@ void* WorkingLoop(void* arguments)
switch(pkt_hdr->packet_type) switch(pkt_hdr->packet_type)
{ {
case DICMOTE_PACKET_TYPE_HELLO: case AARUREMOTE_PACKET_TYPE_HELLO:
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_OOO;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Received hello packet out of order, skipping...", 256); strncpy(pkt_nop->reason, "Received hello packet out of order, skipping...", 256);
NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES: case AARUREMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES:
device_info_list = ListDevices(); device_info_list = ListDevices();
// Packet only contains header so, dummy // Packet only contains header so, dummy
@@ -316,7 +316,7 @@ void* WorkingLoop(void* arguments)
if(!device_info_list) if(!device_info_list)
{ {
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES; pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Could not get device list, continuing...", 256); strncpy(pkt_nop->reason, "Could not get device list, continuing...", 256);
NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop));
@@ -334,10 +334,10 @@ void* WorkingLoop(void* arguments)
free(pkt_res_devinfo); free(pkt_res_devinfo);
pkt_res_devinfo = (DicPacketResListDevs*)in_buf; pkt_res_devinfo = (DicPacketResListDevs*)in_buf;
pkt_res_devinfo->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_devinfo->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_devinfo->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_devinfo->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_devinfo->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_devinfo->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_devinfo->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES; pkt_res_devinfo->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES;
// Save list start // Save list start
in_buf = (char*)device_info_list; in_buf = (char*)device_info_list;
@@ -356,25 +356,25 @@ void* WorkingLoop(void* arguments)
NetWrite(cli_ctx, pkt_res_devinfo, le32toh(pkt_res_devinfo->hdr.len)); NetWrite(cli_ctx, pkt_res_devinfo, le32toh(pkt_res_devinfo->hdr.len));
free(pkt_res_devinfo); free(pkt_res_devinfo);
continue; continue;
case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS:
case DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES: case AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES:
case DICMOTE_PACKET_TYPE_RESPONSE_SCSI: case AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS: case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28: case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48: case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48:
case DICMOTE_PACKET_TYPE_RESPONSE_SDHCI: case AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE: case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA: case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA: case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA: case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA:
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_OOO;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
strncpy(pkt_nop->reason, "Received response packet?! You should certainly not do that...", 256); strncpy(pkt_nop->reason, "Received response packet?! You should certainly not do that...", 256);
NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop));
printf("%s...\n", pkt_nop->reason); printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE: case AARUREMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE:
pkt_dev_open = malloc(le32toh(pkt_hdr->len)); pkt_dev_open = malloc(le32toh(pkt_hdr->len));
if(!pkt_dev_open) if(!pkt_dev_open)
@@ -390,14 +390,14 @@ void* WorkingLoop(void* arguments)
device_ctx = DeviceOpen(pkt_dev_open->device_path); device_ctx = DeviceOpen(pkt_dev_open->device_path);
pkt_nop->reason_code = pkt_nop->reason_code =
device_ctx == NULL ? DICMOTE_PACKET_NOP_REASON_OPEN_ERROR : DICMOTE_PACKET_NOP_REASON_OPEN_OK; device_ctx == NULL ? AARUREMOTE_PACKET_NOP_REASON_OPEN_ERROR : AARUREMOTE_PACKET_NOP_REASON_OPEN_OK;
pkt_nop->error_no = errno; pkt_nop->error_no = errno;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop));
free(pkt_dev_open); free(pkt_dev_open);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE: case AARUREMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -425,16 +425,16 @@ void* WorkingLoop(void* arguments)
memset(pkt_dev_type, 0, sizeof(DicPacketResGetDeviceType)); memset(pkt_dev_type, 0, sizeof(DicPacketResGetDeviceType));
pkt_dev_type->hdr.len = htole32(sizeof(DicPacketResGetDeviceType)); pkt_dev_type->hdr.len = htole32(sizeof(DicPacketResGetDeviceType));
pkt_dev_type->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE; pkt_dev_type->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE;
pkt_dev_type->hdr.version = DICMOTE_PACKET_VERSION; pkt_dev_type->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_dev_type->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_dev_type->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_dev_type->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_dev_type->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_dev_type->device_type = htole32(GetDeviceType(device_ctx)); pkt_dev_type->device_type = htole32(GetDeviceType(device_ctx));
NetWrite(cli_ctx, pkt_dev_type, sizeof(DicPacketResGetDeviceType)); NetWrite(cli_ctx, pkt_dev_type, sizeof(DicPacketResGetDeviceType));
free(pkt_dev_type); free(pkt_dev_type);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_SCSI: case AARUREMOTE_PACKET_TYPE_COMMAND_SCSI:
// Packet contains data after // Packet contains data after
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -495,10 +495,10 @@ void* WorkingLoop(void* arguments)
if(buffer) memcpy(out_buf + sizeof(DicPacketResScsi) + sense_len, buffer, pkt_cmd_scsi->buf_len); if(buffer) memcpy(out_buf + sizeof(DicPacketResScsi) + sense_len, buffer, pkt_cmd_scsi->buf_len);
pkt_res_scsi->hdr.len = htole32(sizeof(DicPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len); pkt_res_scsi->hdr.len = htole32(sizeof(DicPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len);
pkt_res_scsi->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SCSI; pkt_res_scsi->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI;
pkt_res_scsi->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_scsi->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_scsi->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_scsi->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_scsi->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_scsi->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_scsi->sense_len = htole32(sense_len); pkt_res_scsi->sense_len = htole32(sense_len);
pkt_res_scsi->buf_len = pkt_cmd_scsi->buf_len; pkt_res_scsi->buf_len = pkt_cmd_scsi->buf_len;
@@ -511,7 +511,7 @@ void* WorkingLoop(void* arguments)
free(pkt_res_scsi); free(pkt_res_scsi);
if(sense_buf) free(sense_buf); if(sense_buf) free(sense_buf);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS: case AARUREMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -536,10 +536,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters)); memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_sdhci_registers->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_sdhci_registers->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_sdhci_registers->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_sdhci_registers->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_sdhci_registers->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_sdhci_registers->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS; pkt_res_sdhci_registers->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS;
pkt_res_sdhci_registers->hdr.len = htole32(sizeof(DicPacketResGetSdhciRegisters)); pkt_res_sdhci_registers->hdr.len = htole32(sizeof(DicPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_ctx, pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_ctx,
&csd, &csd,
@@ -590,7 +590,7 @@ void* WorkingLoop(void* arguments)
NetWrite(cli_ctx, pkt_res_sdhci_registers, le32toh(pkt_res_sdhci_registers->hdr.len)); NetWrite(cli_ctx, pkt_res_sdhci_registers, le32toh(pkt_res_sdhci_registers->hdr.len));
free(pkt_res_sdhci_registers); free(pkt_res_sdhci_registers);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA: case AARUREMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -615,10 +615,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData)); memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData));
pkt_res_usb->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_usb->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_usb->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_usb->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_usb->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_usb->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_usb->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA; pkt_res_usb->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA;
pkt_res_usb->hdr.len = htole32(sizeof(DicPacketResGetUsbData)); pkt_res_usb->hdr.len = htole32(sizeof(DicPacketResGetUsbData));
pkt_res_usb->is_usb = GetUsbData(device_ctx, pkt_res_usb->is_usb = GetUsbData(device_ctx,
&pkt_res_usb->desc_len, &pkt_res_usb->desc_len,
@@ -636,7 +636,7 @@ void* WorkingLoop(void* arguments)
NetWrite(cli_ctx, pkt_res_usb, le32toh(pkt_res_usb->hdr.len)); NetWrite(cli_ctx, pkt_res_usb, le32toh(pkt_res_usb->hdr.len));
free(pkt_res_usb); free(pkt_res_usb);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA: case AARUREMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -661,10 +661,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData)); memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData));
pkt_res_firewire->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_firewire->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_firewire->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_firewire->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_firewire->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_firewire->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_firewire->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA; pkt_res_firewire->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA;
pkt_res_firewire->hdr.len = htole32(sizeof(DicPacketResGetFireWireData)); pkt_res_firewire->hdr.len = htole32(sizeof(DicPacketResGetFireWireData));
pkt_res_firewire->is_firewire = GetFireWireData(device_ctx, pkt_res_firewire->is_firewire = GetFireWireData(device_ctx,
&pkt_res_firewire->id_model, &pkt_res_firewire->id_model,
@@ -678,7 +678,7 @@ void* WorkingLoop(void* arguments)
NetWrite(cli_ctx, pkt_res_firewire, le32toh(pkt_res_firewire->hdr.len)); NetWrite(cli_ctx, pkt_res_firewire, le32toh(pkt_res_firewire->hdr.len));
free(pkt_res_firewire); free(pkt_res_firewire);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA: case AARUREMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -703,10 +703,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData)); memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData));
pkt_res_pcmcia->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_pcmcia->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_pcmcia->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_pcmcia->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_pcmcia->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_pcmcia->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_pcmcia->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA; pkt_res_pcmcia->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA;
pkt_res_pcmcia->hdr.len = htole32(sizeof(DicPacketResGetPcmciaData)); pkt_res_pcmcia->hdr.len = htole32(sizeof(DicPacketResGetPcmciaData));
pkt_res_pcmcia->is_pcmcia = pkt_res_pcmcia->is_pcmcia =
GetPcmciaData(device_ctx, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis); GetPcmciaData(device_ctx, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis);
@@ -716,7 +716,7 @@ void* WorkingLoop(void* arguments)
NetWrite(cli_ctx, pkt_res_pcmcia, le32toh(pkt_res_pcmcia->hdr.len)); NetWrite(cli_ctx, pkt_res_pcmcia, le32toh(pkt_res_pcmcia->hdr.len));
free(pkt_res_pcmcia); free(pkt_res_pcmcia);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS: case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_CHS:
// Packet contains data after // Packet contains data after
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -773,10 +773,10 @@ void* WorkingLoop(void* arguments)
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaChs), buffer, htole32(pkt_cmd_ata_chs->buf_len)); if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaChs), buffer, htole32(pkt_cmd_ata_chs->buf_len));
pkt_res_ata_chs->hdr.len = htole32(sizeof(DicPacketResAtaChs) + htole32(pkt_cmd_ata_chs->buf_len)); pkt_res_ata_chs->hdr.len = htole32(sizeof(DicPacketResAtaChs) + htole32(pkt_cmd_ata_chs->buf_len));
pkt_res_ata_chs->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS; pkt_res_ata_chs->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS;
pkt_res_ata_chs->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_chs->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_ata_chs->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_ata_chs->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_ata_chs->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_ata_chs->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_ata_chs->registers = ata_chs_error_regs; pkt_res_ata_chs->registers = ata_chs_error_regs;
pkt_res_ata_chs->buf_len = pkt_cmd_ata_chs->buf_len; pkt_res_ata_chs->buf_len = pkt_cmd_ata_chs->buf_len;
@@ -788,7 +788,7 @@ void* WorkingLoop(void* arguments)
free(pkt_cmd_ata_chs); free(pkt_cmd_ata_chs);
free(pkt_res_ata_chs); free(pkt_res_ata_chs);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28: case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28:
// Packet contains data after // Packet contains data after
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -846,10 +846,10 @@ void* WorkingLoop(void* arguments)
pkt_res_ata_lba28->hdr.len = pkt_res_ata_lba28->hdr.len =
htole32(sizeof(DicPacketResAtaLba28) + le32toh(pkt_cmd_ata_lba28->buf_len)); htole32(sizeof(DicPacketResAtaLba28) + le32toh(pkt_cmd_ata_lba28->buf_len));
pkt_res_ata_lba28->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28; pkt_res_ata_lba28->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28;
pkt_res_ata_lba28->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_lba28->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_ata_lba28->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_ata_lba28->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_ata_lba28->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_ata_lba28->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_ata_lba28->registers = ata_lba28_error_regs; pkt_res_ata_lba28->registers = ata_lba28_error_regs;
pkt_res_ata_lba28->buf_len = pkt_cmd_ata_lba28->buf_len; pkt_res_ata_lba28->buf_len = pkt_cmd_ata_lba28->buf_len;
@@ -861,7 +861,7 @@ void* WorkingLoop(void* arguments)
free(pkt_cmd_ata_lba28); free(pkt_cmd_ata_lba28);
free(pkt_res_ata_lba28); free(pkt_res_ata_lba28);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48: case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48:
// Packet contains data after // Packet contains data after
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -924,10 +924,10 @@ void* WorkingLoop(void* arguments)
pkt_res_ata_lba48->hdr.len = pkt_res_ata_lba48->hdr.len =
htole32(sizeof(DicPacketResAtaLba48) + le32toh(pkt_cmd_ata_lba48->buf_len)); htole32(sizeof(DicPacketResAtaLba48) + le32toh(pkt_cmd_ata_lba48->buf_len));
pkt_res_ata_lba48->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48; pkt_res_ata_lba48->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48;
pkt_res_ata_lba48->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_lba48->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_ata_lba48->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_ata_lba48->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_ata_lba48->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_ata_lba48->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
// Swapping // Swapping
ata_lba48_error_regs.lba_high = htole16(ata_lba48_error_regs.lba_high); ata_lba48_error_regs.lba_high = htole16(ata_lba48_error_regs.lba_high);
@@ -945,7 +945,7 @@ void* WorkingLoop(void* arguments)
free(pkt_cmd_ata_lba48); free(pkt_cmd_ata_lba48);
free(pkt_res_ata_lba48); free(pkt_res_ata_lba48);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_SDHCI: case AARUREMOTE_PACKET_TYPE_COMMAND_SDHCI:
// Packet contains data after // Packet contains data after
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -1001,10 +1001,10 @@ void* WorkingLoop(void* arguments)
if(buffer) memcpy(out_buf + sizeof(DicPacketResSdhci), buffer, le32toh(pkt_cmd_sdhci->buf_len)); if(buffer) memcpy(out_buf + sizeof(DicPacketResSdhci), buffer, le32toh(pkt_cmd_sdhci->buf_len));
pkt_res_sdhci->hdr.len = htole32(sizeof(DicPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len)); pkt_res_sdhci->hdr.len = htole32(sizeof(DicPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
pkt_res_sdhci->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SDHCI; pkt_res_sdhci->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI;
pkt_res_sdhci->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_sdhci->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_sdhci->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_sdhci->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_sdhci->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_sdhci->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
sdhci_response[0] = htole32(sdhci_response[0]); sdhci_response[0] = htole32(sdhci_response[0]);
sdhci_response[1] = htole32(sdhci_response[1]); sdhci_response[1] = htole32(sdhci_response[1]);
@@ -1021,12 +1021,12 @@ void* WorkingLoop(void* arguments)
free(pkt_cmd_sdhci); free(pkt_cmd_sdhci);
free(pkt_res_sdhci); free(pkt_res_sdhci);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE: case AARUREMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE:
DeviceClose(device_ctx); DeviceClose(device_ctx);
device_ctx = NULL; device_ctx = NULL;
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT: case AARUREMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(le32toh(pkt_hdr->len)); in_buf = malloc(le32toh(pkt_hdr->len));
@@ -1051,10 +1051,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_am_i_root, 0, sizeof(DicPacketResAmIRoot)); memset(pkt_res_am_i_root, 0, sizeof(DicPacketResAmIRoot));
pkt_res_am_i_root->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); pkt_res_am_i_root->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_am_i_root->hdr.packet_id = htole32(DICMOTE_PACKET_ID); pkt_res_am_i_root->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
pkt_res_am_i_root->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_am_i_root->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_res_am_i_root->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT; pkt_res_am_i_root->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT;
pkt_res_am_i_root->hdr.len = htole32(sizeof(DicPacketResAmIRoot)); pkt_res_am_i_root->hdr.len = htole32(sizeof(DicPacketResAmIRoot));
pkt_res_am_i_root->am_i_root = AmIRoot(); pkt_res_am_i_root->am_i_root = AmIRoot();
@@ -1062,7 +1062,7 @@ void* WorkingLoop(void* arguments)
free(pkt_res_am_i_root); free(pkt_res_am_i_root);
continue; continue;
default: default:
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED; pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
snprintf(pkt_nop->reason, snprintf(pkt_nop->reason,
256, 256,