diff --git a/aaruremote.h b/aaruremote.h index b6ef031..545e6d6 100644 --- a/aaruremote.h +++ b/aaruremote.h @@ -33,107 +33,107 @@ #include #endif -#define DICMOTE_NAME "DiscImageChef Remote Server" -#define DICMOTE_VERSION "0.99" -#define DICMOTE_PORT 6666 -#define DICMOTE_REMOTE_ID 0x52434944 // "DICR" -#define DICMOTE_PACKET_ID 0x544B4350 // "PCKT" -#define DICMOTE_PACKET_VERSION 1 -#define DICMOTE_PACKET_TYPE_NOP -1 -#define DICMOTE_PACKET_TYPE_HELLO 1 -#define DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES 2 -#define DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES 3 -#define DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE 4 -#define DICMOTE_PACKET_TYPE_COMMAND_SCSI 5 -#define DICMOTE_PACKET_TYPE_RESPONSE_SCSI 6 -#define DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7 -#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8 -#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28 9 -#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28 10 -#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48 11 -#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48 12 -#define DICMOTE_PACKET_TYPE_COMMAND_SDHCI 13 -#define DICMOTE_PACKET_TYPE_RESPONSE_SDHCI 14 -#define DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15 -#define DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE 16 -#define DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS 17 -#define DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS 18 -#define DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA 19 -#define DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA 20 -#define DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA 21 -#define DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA 22 -#define DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA 23 -#define DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA 24 -#define DICMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE 25 -#define DICMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT 26 -#define DICMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT 27 -#define DICMOTE_PROTOCOL_MAX 1 -#define DICMOTE_PACKET_NOP_REASON_OOO 0 -#define DICMOTE_PACKET_NOP_REASON_NOT_IMPLEMENTED 1 -#define DICMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED 2 -#define DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES 3 -#define DICMOTE_PACKET_NOP_REASON_OPEN_OK 4 -#define DICMOTE_PACKET_NOP_REASON_OPEN_ERROR 5 -#define DICMOTE_DEVICE_TYPE_UNKNOWN -1 -#define DICMOTE_DEVICE_TYPE_ATA 1 -#define DICMOTE_DEVICE_TYPE_ATAPI 2 -#define DICMOTE_DEVICE_TYPE_SCSI 3 -#define DICMOTE_DEVICE_TYPE_SECURE_DIGITAL 4 -#define DICMOTE_DEVICE_TYPE_MMC 5 -#define DICMOTE_DEVICE_TYPE_NVME 6 -#define DICMOTE_SCSI_DIRECTION_UNSPECIFIED -1 -#define DICMOTE_SCSI_DIRECTION_NONE 0 -#define DICMOTE_SCSI_DIRECTION_OUT 1 -#define DICMOTE_SCSI_DIRECTION_IN 2 -#define DICMOTE_SCSI_DIRECTION_INOUT 3 -#define DICMOTE_ATA_PROTOCOL_HARD_RESET 0 -#define DICMOTE_ATA_PROTOCOL_SOFT_RESET 1 -#define DICMOTE_ATA_PROTOCOL_NO_DATA 3 -#define DICMOTE_ATA_PROTOCOL_PIO_IN 4 -#define DICMOTE_ATA_PROTOCOL_PIO_OUT 5 -#define DICMOTE_ATA_PROTOCOL_DMA 6 -#define DICMOTE_ATA_PROTOCOL_DMA_QUEUED 7 -#define DICMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC 8 -#define DICMOTE_ATA_PROTOCOL_DEVICE_RESET 9 -#define DICMOTE_ATA_PROTOCOL_UDMA_IN 10 -#define DICMOTE_ATA_PROTOCOL_UDMA_OUT 11 -#define DICMOTE_ATA_PROTOCOL_FPDMA 12 -#define DICMOTE_ATA_PROTOCOL_RETURN_RESPONSE 15 -#define DICMOTE_ATA_TRANSFER_REGISTER_NONE 0 -#define DICMOTE_ATA_TRANSFER_REGISTER_FEATURE 1 -#define DICMOTE_ATA_TRANSFER_REGISTER_SECTOR_COUNT 2 -#define DICMOTE_ATA_TRANSFER_REGISTER_SPTSIU 3 -#define DICMOTE_MMC_RESPONSE_PRESENT (1 << 0) -#define DICMOTE_MMC_RESPONSE_136 (1 << 1) -#define DICMOTE_MMC_RESPONSE_CRC (1 << 2) -#define DICMOTE_MMC_RESPONSE_BUSY (1 << 3) -#define DICMOTE_MMC_RESPONSE_OPCODE (1 << 4) -#define DICMOTE_MMC_COMMAND_MASK (3 << 5) -#define DICMOTE_MMC_COMMAND_AC (0 << 5) -#define DICMOTE_MMC_COMMAND_ADTC (1 << 5) -#define DICMOTE_MMC_COMMAND_BC (2 << 5) -#define DICMOTE_MMC_COMMAND_BCR (3 << 5) -#define DICMOTE_MMC_RESPONSE_SPI_S1 (1 << 7) -#define DICMOTE_MMC_RESPONSE_SPI_S2 (1 << 8) -#define DICMOTE_MMC_RESPONSE_SPI_B4 (1 << 9) -#define DICMOTE_MMC_RESPONSE_SPI_BUSY (1 << 10) -#define DICMOTE_MMC_RESPONSE_NONE (0) -#define DICMOTE_MMC_RESPONSE_R1 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE -#define DICMOTE_MMC_RESPONSE_R1B \ - DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE | DICMOTE_MMC_RESPONSE_BUSY -#define DICMOTE_MMC_RESPONSE_R2 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_136 | DICMOTE_MMC_RESPONSE_CRC -#define DICMOTE_MMC_RESPONSE_R3 DICMOTE_MMC_RESPONSE_PRESENT -#define DICMOTE_MMC_RESPONSE_R4 DICMOTE_MMC_RESPONSE_PRESENT -#define DICMOTE_MMC_RESPONSE_R5 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE -#define DICMOTE_MMC_RESPONSE_R6 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE -#define DICMOTE_MMC_RESPONSE_R7 DICMOTE_MMC_RESPONSE_PRESENT | DICMOTE_MMC_RESPONSE_CRC | DICMOTE_MMC_RESPONSE_OPCODE -#define DICMOTE_MMC_RESPONSE_SPI_R1 DICMOTE_MMC_RESPONSE_SPI_S1 -#define DICMOTE_MMC_RESPONSE_SPI_R1B DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_BUSY -#define DICMOTE_MMC_RESPONSE_SPI_R2 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_S2 -#define DICMOTE_MMC_RESPONSE_SPI_R3 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 -#define DICMOTE_MMC_RESPONSE_SPI_R4 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 -#define DICMOTE_MMC_RESPONSE_SPI_R5 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_S2 -#define DICMOTE_MMC_RESPONSE_SPI_R7 DICMOTE_MMC_RESPONSE_SPI_S1 | DICMOTE_MMC_RESPONSE_SPI_B4 +#define AARUREMOTE_NAME "DiscImageChef Remote Server" +#define AARUREMOTE_VERSION "0.99" +#define AARUREMOTE_PORT 6666 +#define AARUREMOTE_REMOTE_ID 0x52434944 // "DICR" +#define AARUREMOTE_PACKET_ID 0x544B4350 // "PCKT" +#define AARUREMOTE_PACKET_VERSION 1 +#define AARUREMOTE_PACKET_TYPE_NOP -1 +#define AARUREMOTE_PACKET_TYPE_HELLO 1 +#define AARUREMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES 2 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES 3 +#define AARUREMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE 4 +#define AARUREMOTE_PACKET_TYPE_COMMAND_SCSI 5 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI 6 +#define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8 +#define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28 9 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28 10 +#define AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48 11 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48 12 +#define AARUREMOTE_PACKET_TYPE_COMMAND_SDHCI 13 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI 14 +#define AARUREMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE 16 +#define AARUREMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS 17 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS 18 +#define AARUREMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA 19 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA 20 +#define AARUREMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA 21 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA 22 +#define AARUREMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA 23 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA 24 +#define AARUREMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE 25 +#define AARUREMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT 26 +#define AARUREMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT 27 +#define AARUREMOTE_PROTOCOL_MAX 1 +#define AARUREMOTE_PACKET_NOP_REASON_OOO 0 +#define AARUREMOTE_PACKET_NOP_REASON_NOT_IMPLEMENTED 1 +#define AARUREMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED 2 +#define AARUREMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES 3 +#define AARUREMOTE_PACKET_NOP_REASON_OPEN_OK 4 +#define AARUREMOTE_PACKET_NOP_REASON_OPEN_ERROR 5 +#define AARUREMOTE_DEVICE_TYPE_UNKNOWN -1 +#define AARUREMOTE_DEVICE_TYPE_ATA 1 +#define AARUREMOTE_DEVICE_TYPE_ATAPI 2 +#define AARUREMOTE_DEVICE_TYPE_SCSI 3 +#define AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL 4 +#define AARUREMOTE_DEVICE_TYPE_MMC 5 +#define AARUREMOTE_DEVICE_TYPE_NVME 6 +#define AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED -1 +#define AARUREMOTE_SCSI_DIRECTION_NONE 0 +#define AARUREMOTE_SCSI_DIRECTION_OUT 1 +#define AARUREMOTE_SCSI_DIRECTION_IN 2 +#define AARUREMOTE_SCSI_DIRECTION_INOUT 3 +#define AARUREMOTE_ATA_PROTOCOL_HARD_RESET 0 +#define AARUREMOTE_ATA_PROTOCOL_SOFT_RESET 1 +#define AARUREMOTE_ATA_PROTOCOL_NO_DATA 3 +#define AARUREMOTE_ATA_PROTOCOL_PIO_IN 4 +#define AARUREMOTE_ATA_PROTOCOL_PIO_OUT 5 +#define AARUREMOTE_ATA_PROTOCOL_DMA 6 +#define AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED 7 +#define AARUREMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC 8 +#define AARUREMOTE_ATA_PROTOCOL_DEVICE_RESET 9 +#define AARUREMOTE_ATA_PROTOCOL_UDMA_IN 10 +#define AARUREMOTE_ATA_PROTOCOL_UDMA_OUT 11 +#define AARUREMOTE_ATA_PROTOCOL_FPDMA 12 +#define AARUREMOTE_ATA_PROTOCOL_RETURN_RESPONSE 15 +#define AARUREMOTE_ATA_TRANSFER_REGISTER_NONE 0 +#define AARUREMOTE_ATA_TRANSFER_REGISTER_FEATURE 1 +#define AARUREMOTE_ATA_TRANSFER_REGISTER_SECTOR_COUNT 2 +#define AARUREMOTE_ATA_TRANSFER_REGISTER_SPTSIU 3 +#define AARUREMOTE_MMC_RESPONSE_PRESENT (1 << 0) +#define AARUREMOTE_MMC_RESPONSE_136 (1 << 1) +#define AARUREMOTE_MMC_RESPONSE_CRC (1 << 2) +#define AARUREMOTE_MMC_RESPONSE_BUSY (1 << 3) +#define AARUREMOTE_MMC_RESPONSE_OPCODE (1 << 4) +#define AARUREMOTE_MMC_COMMAND_MASK (3 << 5) +#define AARUREMOTE_MMC_COMMAND_AC (0 << 5) +#define AARUREMOTE_MMC_COMMAND_ADTC (1 << 5) +#define AARUREMOTE_MMC_COMMAND_BC (2 << 5) +#define AARUREMOTE_MMC_COMMAND_BCR (3 << 5) +#define AARUREMOTE_MMC_RESPONSE_SPI_S1 (1 << 7) +#define AARUREMOTE_MMC_RESPONSE_SPI_S2 (1 << 8) +#define AARUREMOTE_MMC_RESPONSE_SPI_B4 (1 << 9) +#define AARUREMOTE_MMC_RESPONSE_SPI_BUSY (1 << 10) +#define AARUREMOTE_MMC_RESPONSE_NONE (0) +#define AARUREMOTE_MMC_RESPONSE_R1 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE +#define AARUREMOTE_MMC_RESPONSE_R1B \ + AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE | AARUREMOTE_MMC_RESPONSE_BUSY +#define AARUREMOTE_MMC_RESPONSE_R2 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_136 | AARUREMOTE_MMC_RESPONSE_CRC +#define AARUREMOTE_MMC_RESPONSE_R3 AARUREMOTE_MMC_RESPONSE_PRESENT +#define AARUREMOTE_MMC_RESPONSE_R4 AARUREMOTE_MMC_RESPONSE_PRESENT +#define AARUREMOTE_MMC_RESPONSE_R5 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE +#define AARUREMOTE_MMC_RESPONSE_R6 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE +#define AARUREMOTE_MMC_RESPONSE_R7 AARUREMOTE_MMC_RESPONSE_PRESENT | AARUREMOTE_MMC_RESPONSE_CRC | AARUREMOTE_MMC_RESPONSE_OPCODE +#define AARUREMOTE_MMC_RESPONSE_SPI_R1 AARUREMOTE_MMC_RESPONSE_SPI_S1 +#define AARUREMOTE_MMC_RESPONSE_SPI_R1B AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_BUSY +#define AARUREMOTE_MMC_RESPONSE_SPI_R2 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_S2 +#define AARUREMOTE_MMC_RESPONSE_SPI_R3 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4 +#define AARUREMOTE_MMC_RESPONSE_SPI_R4 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4 +#define AARUREMOTE_MMC_RESPONSE_SPI_R5 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_S2 +#define AARUREMOTE_MMC_RESPONSE_SPI_R7 AARUREMOTE_MMC_RESPONSE_SPI_S1 | AARUREMOTE_MMC_RESPONSE_SPI_B4 #pragma pack(push, 1) diff --git a/device.c b/device.c index f324634..f12419e 100644 --- a/device.c +++ b/device.c @@ -52,7 +52,7 @@ int32_t GetDeviceType(void* device_ctx) #elif defined(WIN32) return Win32GetDeviceType(device_ctx); #else - return DICMOTE_DEVICE_TYPE_UNKNOWN; + return AARUREMOTE_DEVICE_TYPE_UNKNOWN; #endif } diff --git a/linux/ata.c b/linux/ata.c index 85568f4..cf953e5 100644 --- a/linux/ata.c +++ b/linux/ata.c @@ -23,17 +23,17 @@ int32_t AtaProtocolToScsiDirection(uint8_t protocol) { switch(protocol) { - case DICMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC: - case DICMOTE_ATA_PROTOCOL_DEVICE_RESET: - case DICMOTE_ATA_PROTOCOL_HARD_RESET: - case DICMOTE_ATA_PROTOCOL_NO_DATA: - case DICMOTE_ATA_PROTOCOL_SOFT_RESET: - case DICMOTE_ATA_PROTOCOL_RETURN_RESPONSE: return DICMOTE_SCSI_DIRECTION_NONE; - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: return DICMOTE_SCSI_DIRECTION_IN; - case DICMOTE_ATA_PROTOCOL_PIO_OUT: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: return DICMOTE_SCSI_DIRECTION_OUT; - default: return DICMOTE_SCSI_DIRECTION_UNSPECIFIED; + case AARUREMOTE_ATA_PROTOCOL_DEVICE_DIAGNOSTIC: + case AARUREMOTE_ATA_PROTOCOL_DEVICE_RESET: + case AARUREMOTE_ATA_PROTOCOL_HARD_RESET: + case AARUREMOTE_ATA_PROTOCOL_NO_DATA: + case AARUREMOTE_ATA_PROTOCOL_SOFT_RESET: + case AARUREMOTE_ATA_PROTOCOL_RETURN_RESPONSE: return AARUREMOTE_SCSI_DIRECTION_NONE; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: return AARUREMOTE_SCSI_DIRECTION_IN; + case AARUREMOTE_ATA_PROTOCOL_PIO_OUT: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: return AARUREMOTE_SCSI_DIRECTION_OUT; + default: return AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED; } } @@ -62,12 +62,12 @@ int32_t LinuxSendAtaChsCommand(void* device_ctx, cdb[0] = 0x85; 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) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; default: cdb[2] = 0x00; break; } @@ -137,12 +137,12 @@ int32_t LinuxSendAtaLba28Command(void* device_ctx, cdb[0] = 0x85; 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) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; default: cdb[2] = 0x00; break; } @@ -215,12 +215,12 @@ int32_t LinuxSendAtaLba48Command(void* device_ctx, cdb[0] = 0x85; cdb[1] = (protocol << 1) & 0x1E; 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) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: cdb[2] = 0x08; break; default: cdb[2] = 0x00; break; } diff --git a/linux/device.c b/linux/device.c index ecb6e8f..effcc2a 100644 --- a/linux/device.c +++ b/linux/device.c @@ -75,17 +75,17 @@ int32_t LinuxGetDeviceType(void* device_ctx) struct udev_device* udev_device; const char* tmp_string; char* chrptr; - int32_t device_type = DICMOTE_DEVICE_TYPE_UNKNOWN; + int32_t device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN; udev = udev_new(); - if(!udev) return DICMOTE_DEVICE_TYPE_UNKNOWN; + if(!udev) return AARUREMOTE_DEVICE_TYPE_UNKNOWN; chrptr = strrchr(ctx->device_path, '/'); - if(chrptr == 0) return DICMOTE_DEVICE_TYPE_UNKNOWN; + if(chrptr == 0) return AARUREMOTE_DEVICE_TYPE_UNKNOWN; 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); if(udev_device) @@ -95,7 +95,7 @@ int32_t LinuxGetDeviceType(void* device_ctx) { if(strncmp(tmp_string, "ata", 3) == 0) { - device_type = DICMOTE_DEVICE_TYPE_ATA; + device_type = AARUREMOTE_DEVICE_TYPE_ATA; free((void*)tmp_string); tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE"); @@ -103,7 +103,7 @@ int32_t LinuxGetDeviceType(void* device_ctx) if(tmp_string) { // 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); } @@ -113,14 +113,14 @@ int32_t LinuxGetDeviceType(void* device_ctx) free((void*)tmp_string); tmp_string = malloc(1024); - device_type = DICMOTE_DEVICE_TYPE_MMC; + device_type = AARUREMOTE_DEVICE_TYPE_MMC; if(tmp_string) { memset((void*)tmp_string, 0, 1024); 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); } @@ -134,7 +134,7 @@ int32_t LinuxGetDeviceType(void* device_ctx) if(tmp_string) { 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); } @@ -142,7 +142,7 @@ int32_t LinuxGetDeviceType(void* device_ctx) else if(strncmp(tmp_string, "nvme", 4) == 0) { 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; #else - int32_t dev_type = DICMOTE_DEVICE_TYPE_UNKNOWN; + int32_t dev_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN; const char* dev_name; const char* sysfs_path; char* dev_path; @@ -169,13 +169,13 @@ int32_t LinuxGetDeviceType(void* device_ctx) 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; if(strstr(ctx->device_path, "mmcblk")) { - dev_type = DICMOTE_DEVICE_TYPE_MMC; + dev_type = AARUREMOTE_DEVICE_TYPE_MMC; 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); - 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); } @@ -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 || 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) { - dev_type = DICMOTE_DEVICE_TYPE_SCSI; + dev_type = AARUREMOTE_DEVICE_TYPE_SCSI; memset(scsi_path, 0, len); snprintf(scsi_path, len, "/sys/class/scsi_host/host%s/proc_name", host_no); 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 || strncmp(scsi_path, "ahci", 4) == 0) { - dev_type = DICMOTE_DEVICE_TYPE_ATA; + dev_type = AARUREMOTE_DEVICE_TYPE_ATA; memset(scsi_path, 0, len); 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); 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); } diff --git a/linux/list_devices.c b/linux/list_devices.c index 52cba67..b4978c2 100644 --- a/linux/list_devices.c +++ b/linux/list_devices.c @@ -143,12 +143,12 @@ DeviceInfoList* LinuxListDevices() switch(GetDeviceType(tmp_string)) { - case DICMOTE_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 DICMOTE_DEVICE_TYPE_MMC: - case DICMOTE_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 DICMOTE_DEVICE_TYPE_SCSI: + case AARUREMOTE_DEVICE_TYPE_ATA: strncpy(list_next->this.bus, "ATA", 256); break; + case AARUREMOTE_DEVICE_TYPE_ATAPI: strncpy(list_next->this.bus, "ATAPI", 256); break; + case AARUREMOTE_DEVICE_TYPE_MMC: + case AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL: strncpy(list_next->this.bus, "MMC/SD", 256); break; + case AARUREMOTE_DEVICE_TYPE_NVME: strncpy(list_next->this.bus, "NVMe", 256); break; + case AARUREMOTE_DEVICE_TYPE_SCSI: memset((void*)tmp_string, 0, 1024); snprintf((char*)tmp_string, 1024, "%s/%s/device", PATH_SYS_DEVBLOCK, dirent->d_name); line_str = malloc(1024); diff --git a/linux/scsi.c b/linux/scsi.c index e907f91..bd74ce9 100644 --- a/linux/scsi.c +++ b/linux/scsi.c @@ -50,11 +50,11 @@ int32_t LinuxSendScsiCommand(void* device_ctx, switch(direction) { - case DICMOTE_SCSI_DIRECTION_IN: dir = SG_DXFER_FROM_DEV; break; - case DICMOTE_SCSI_DIRECTION_OUT: dir = SG_DXFER_TO_DEV; break; - case DICMOTE_SCSI_DIRECTION_INOUT: - case DICMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SG_DXFER_TO_FROM_DEV; break; - case DICMOTE_SCSI_DIRECTION_NONE: + case AARUREMOTE_SCSI_DIRECTION_IN: dir = SG_DXFER_FROM_DEV; break; + case AARUREMOTE_SCSI_DIRECTION_OUT: dir = SG_DXFER_TO_DEV; break; + case AARUREMOTE_SCSI_DIRECTION_INOUT: + case AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SG_DXFER_TO_FROM_DEV; break; + case AARUREMOTE_SCSI_DIRECTION_NONE: default: dir = SG_DXFER_NONE; break; } diff --git a/main.c b/main.c index 9442ec6..2acce05 100644 --- a/main.c +++ b/main.c @@ -28,7 +28,7 @@ int main() 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"); pkt_server_hello = GetHello(); diff --git a/unix/hello.c b/unix/hello.c index 1ddf614..c513c18 100644 --- a/unix/hello.c +++ b/unix/hello.c @@ -37,14 +37,14 @@ DicPacketHello* GetHello() memset(pkt_server_hello, 0, sizeof(DicPacketHello)); - pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); - pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; - pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; - strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); - strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); - pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; + pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO; + strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME)); + strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION)); + pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX; strncpy(pkt_server_hello->sysname, utsname.sysname, 255); strncpy(pkt_server_hello->release, utsname.release, 255); strncpy(pkt_server_hello->machine, utsname.machine, 255); diff --git a/unix/network.c b/unix/network.c index 7c986fe..5c57b74 100644 --- a/unix/network.c +++ b/unix/network.c @@ -44,7 +44,7 @@ int PrintNetworkAddresses() 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); - printf("%s port %d\n", ipv4_address, DICMOTE_PORT); + printf("%s port %d\n", ipv4_address, AARUREMOTE_PORT); } ifa = ifa->ifa_next; diff --git a/wii/hello.c b/wii/hello.c index 9efbede..0dbfddc 100644 --- a/wii/hello.c +++ b/wii/hello.c @@ -33,14 +33,14 @@ DicPacketHello* GetHello() memset(pkt_server_hello, 0, sizeof(DicPacketHello)); - pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); - pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; - pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; - strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); - strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); - pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; + pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO; + strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME)); + strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION)); + pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX; snprintf(pkt_server_hello->sysname, 255, "Nintendo Wii IOS %d", IOS_GetVersion()); snprintf(pkt_server_hello->release, 255, "%d", IOS_GetRevision()); strncpy(pkt_server_hello->machine, "ppc", 255); diff --git a/wii/network.c b/wii/network.c index 0cf9011..64f5878 100644 --- a/wii/network.c +++ b/wii/network.c @@ -34,7 +34,7 @@ int PrintNetworkAddresses() if(ret < 0) return -1; printf("Available addresses:\n"); - printf("%s port %d\n", localip, DICMOTE_PORT); + printf("%s port %d\n", localip, AARUREMOTE_PORT); return 0; } diff --git a/win32/ata.c b/win32/ata.c index f505ace..3f7ab75 100644 --- a/win32/ata.c +++ b/win32/ata.c @@ -78,20 +78,20 @@ int32_t Win32SendAtaChsCommand(void* device_ctx, switch(protocol) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; - case DICMOTE_ATA_PROTOCOL_PIO_OUT: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_OUT: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; } switch(protocol) { - case DICMOTE_ATA_PROTOCOL_DMA: - case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: - case DICMOTE_ATA_PROTOCOL_FPDMA: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; + case AARUREMOTE_ATA_PROTOCOL_DMA: + case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED: + case AARUREMOTE_ATA_PROTOCOL_FPDMA: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; } // Unknown if needed @@ -188,20 +188,20 @@ int32_t Win32SendAtaLba28Command(void* device_ctx, switch(protocol) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; - case DICMOTE_ATA_PROTOCOL_PIO_OUT: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_OUT: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; } switch(protocol) { - case DICMOTE_ATA_PROTOCOL_DMA: - case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: - case DICMOTE_ATA_PROTOCOL_FPDMA: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; + case AARUREMOTE_ATA_PROTOCOL_DMA: + case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED: + case AARUREMOTE_ATA_PROTOCOL_FPDMA: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; } // Unknown if needed @@ -303,20 +303,20 @@ int32_t Win32SendAtaLba48Command(void* device_ctx, switch(protocol) { - case DICMOTE_ATA_PROTOCOL_PIO_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; - case DICMOTE_ATA_PROTOCOL_PIO_OUT: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_DMA: apte->AtaFlags = ATA_FLAGS_DATA_IN; break; + case AARUREMOTE_ATA_PROTOCOL_PIO_OUT: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags = ATA_FLAGS_DATA_OUT; break; } switch(protocol) { - case DICMOTE_ATA_PROTOCOL_DMA: - case DICMOTE_ATA_PROTOCOL_DMA_QUEUED: - case DICMOTE_ATA_PROTOCOL_FPDMA: - case DICMOTE_ATA_PROTOCOL_UDMA_IN: - case DICMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; + case AARUREMOTE_ATA_PROTOCOL_DMA: + case AARUREMOTE_ATA_PROTOCOL_DMA_QUEUED: + case AARUREMOTE_ATA_PROTOCOL_FPDMA: + case AARUREMOTE_ATA_PROTOCOL_UDMA_IN: + case AARUREMOTE_ATA_PROTOCOL_UDMA_OUT: apte->AtaFlags |= ATA_FLAGS_USE_DMA; break; } apte->AtaFlags |= ATA_FLAGS_48BIT_COMMAND; diff --git a/win32/device.c b/win32/device.c index cf07c0b..0b82711 100644 --- a/win32/device.c +++ b/win32/device.c @@ -77,7 +77,7 @@ int32_t Win32GetDeviceType(void* device_ctx) buf = malloc(1000); - if(!buf) return DICMOTE_DEVICE_TYPE_UNKNOWN; + if(!buf) return AARUREMOTE_DEVICE_TYPE_UNKNOWN; query.PropertyId = StorageDeviceProperty; query.QueryType = PropertyStandardQuery; @@ -92,27 +92,27 @@ int32_t Win32GetDeviceType(void* device_ctx) if(!ret && error != 0) { free(buf); - return DICMOTE_DEVICE_TYPE_UNKNOWN; + return AARUREMOTE_DEVICE_TYPE_UNKNOWN; } descriptor = (PSTORAGE_DEVICE_DESCRIPTOR)buf; switch(descriptor->BusType) { - case 1: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 2: returned = DICMOTE_DEVICE_TYPE_ATAPI; break; - case 3: returned = DICMOTE_DEVICE_TYPE_ATA; break; - case 4: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 5: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 6: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 7: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 9: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 0xA: returned = DICMOTE_DEVICE_TYPE_SCSI; break; - case 0xB: returned = DICMOTE_DEVICE_TYPE_ATA; break; - case 0xC: returned = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL; break; - case 0xD: returned = DICMOTE_DEVICE_TYPE_MMC; break; - case 0x11: returned = DICMOTE_DEVICE_TYPE_NVME; break; - default: returned = DICMOTE_DEVICE_TYPE_UNKNOWN; break; + case 1: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 2: returned = AARUREMOTE_DEVICE_TYPE_ATAPI; break; + case 3: returned = AARUREMOTE_DEVICE_TYPE_ATA; break; + case 4: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 5: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 6: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 7: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 9: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 0xA: returned = AARUREMOTE_DEVICE_TYPE_SCSI; break; + case 0xB: returned = AARUREMOTE_DEVICE_TYPE_ATA; break; + case 0xC: returned = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL; break; + case 0xD: returned = AARUREMOTE_DEVICE_TYPE_MMC; break; + case 0x11: returned = AARUREMOTE_DEVICE_TYPE_NVME; break; + default: returned = AARUREMOTE_DEVICE_TYPE_UNKNOWN; break; } free(buf); diff --git a/win32/hello.c b/win32/hello.c index c06d3bb..d1d8417 100644 --- a/win32/hello.c +++ b/win32/hello.c @@ -63,14 +63,14 @@ DicPacketHello* GetHello() memset(pkt_server_hello, 0, sizeof(DicPacketHello)); - pkt_server_hello->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_server_hello->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_server_hello->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_server_hello->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello)); - pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; - pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; - strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); - strncpy(pkt_server_hello->version, DICMOTE_VERSION, sizeof(DICMOTE_VERSION)); - pkt_server_hello->max_protocol = DICMOTE_PROTOCOL_MAX; + pkt_server_hello->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_server_hello->hdr.packet_type = AARUREMOTE_PACKET_TYPE_HELLO; + strncpy(pkt_server_hello->application, AARUREMOTE_NAME, sizeof(AARUREMOTE_NAME)); + strncpy(pkt_server_hello->version, AARUREMOTE_VERSION, sizeof(AARUREMOTE_VERSION)); + pkt_server_hello->max_protocol = AARUREMOTE_PROTOCOL_MAX; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); diff --git a/win32/network.c b/win32/network.c index c51e89e..07409e1 100644 --- a/win32/network.c +++ b/win32/network.c @@ -61,7 +61,7 @@ int PrintNetworkAddresses() while(pUnicast != NULL) { 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; } diff --git a/win32/scsi.c b/win32/scsi.c index dbadc5c..8c3ce64 100644 --- a/win32/scsi.c +++ b/win32/scsi.c @@ -69,11 +69,11 @@ int32_t Win32SendScsiCommand(void* device_ctx, switch(direction) { - case DICMOTE_SCSI_DIRECTION_IN: dir = SCSI_IOCTL_DATA_IN; break; - case DICMOTE_SCSI_DIRECTION_OUT: dir = SCSI_IOCTL_DATA_OUT; break; - case DICMOTE_SCSI_DIRECTION_INOUT: - case DICMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SCSI_IOCTL_DATA_BIDIRECTIONAL; break; - case DICMOTE_SCSI_DIRECTION_NONE: + case AARUREMOTE_SCSI_DIRECTION_IN: dir = SCSI_IOCTL_DATA_IN; break; + case AARUREMOTE_SCSI_DIRECTION_OUT: dir = SCSI_IOCTL_DATA_OUT; break; + case AARUREMOTE_SCSI_DIRECTION_INOUT: + case AARUREMOTE_SCSI_DIRECTION_UNSPECIFIED: dir = SCSI_IOCTL_DATA_BIDIRECTIONAL; break; + case AARUREMOTE_SCSI_DIRECTION_NONE: default: dir = SCSI_IOCTL_DATA_UNSPECIFIED; break; } diff --git a/win32/sdhci.c b/win32/sdhci.c index cd9ff8d..c68de4d 100644 --- a/win32/sdhci.c +++ b/win32/sdhci.c @@ -71,22 +71,22 @@ int32_t Win32SendSdhciCommand(void* device_ctx, cmd_descriptor->Cmd = command; cmd_descriptor->CmdClass = application ? SDCC_APP_CMD : SDCC_STANDARD; 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; - 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; - 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; - 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; - 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; - 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; - 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; - if((flags & DICMOTE_MMC_RESPONSE_R6)) cmd_descriptor->ResponseType = SDRT_6; + if((flags & AARUREMOTE_MMC_RESPONSE_R6)) cmd_descriptor->ResponseType = SDRT_6; QueryPerformanceFrequency(&frequency); QueryPerformanceCounter(&start); @@ -152,7 +152,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx, 9, 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, 16, 1, @@ -177,7 +177,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx, 10, 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, 16, 1, @@ -202,7 +202,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx, 10, 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, 8, 1, @@ -227,7 +227,7 @@ int32_t Win32GetSdhciRegisters(void* device_ctx, *scr_len > 0 ? 41 : 1, 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, 4, 1, diff --git a/worker.c b/worker.c index a828d90..343ae6b 100644 --- a/worker.c +++ b/worker.c @@ -96,7 +96,7 @@ void* WorkingLoop(void* arguments) serv_addr.sin_family = AF_INET; 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) { @@ -125,11 +125,11 @@ void* WorkingLoop(void* arguments) memset(pkt_nop, 0, sizeof(DicPacketNop)); - pkt_nop->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_nop->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_nop->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_nop->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_nop->hdr.len = htole32(sizeof(DicPacketNop)); - pkt_nop->hdr.version = DICMOTE_PACKET_VERSION; - pkt_nop->hdr.packet_type = DICMOTE_PACKET_TYPE_NOP; + pkt_nop->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_nop->hdr.packet_type = AARUREMOTE_PACKET_TYPE_NOP; for(;;) { @@ -179,7 +179,7 @@ void* WorkingLoop(void* arguments) 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"); free(pkt_hdr); @@ -187,7 +187,7 @@ void* WorkingLoop(void* arguments) continue; } - if(pkt_hdr->version != DICMOTE_PACKET_VERSION) + if(pkt_hdr->version != AARUREMOTE_PACKET_VERSION) { printf("Unrecognized packet version, closing connection...\n"); free(pkt_hdr); @@ -195,7 +195,7 @@ void* WorkingLoop(void* arguments) 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); free(pkt_hdr); @@ -272,7 +272,7 @@ void* WorkingLoop(void* arguments) 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"); NetClose(cli_ctx); @@ -280,7 +280,7 @@ void* WorkingLoop(void* arguments) break; } - if(pkt_hdr->version != DICMOTE_PACKET_VERSION) + if(pkt_hdr->version != AARUREMOTE_PACKET_VERSION) { printf("Unrecognized packet version, skipping...\n"); skip_next_hdr = 1; @@ -289,15 +289,15 @@ void* WorkingLoop(void* arguments) switch(pkt_hdr->packet_type) { - case DICMOTE_PACKET_TYPE_HELLO: - pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; + case AARUREMOTE_PACKET_TYPE_HELLO: + pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_OOO; memset(&pkt_nop->reason, 0, 256); strncpy(pkt_nop->reason, "Received hello packet out of order, skipping...", 256); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); printf("%s...\n", pkt_nop->reason); skip_next_hdr = 1; continue; - case DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES: + case AARUREMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES: device_info_list = ListDevices(); // Packet only contains header so, dummy @@ -316,7 +316,7 @@ void* WorkingLoop(void* arguments) 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); strncpy(pkt_nop->reason, "Could not get device list, continuing...", 256); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); @@ -334,10 +334,10 @@ void* WorkingLoop(void* arguments) free(pkt_res_devinfo); pkt_res_devinfo = (DicPacketResListDevs*)in_buf; - pkt_res_devinfo->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_devinfo->hdr.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_devinfo->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_devinfo->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES; + pkt_res_devinfo->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_devinfo->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_devinfo->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_devinfo->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES; // Save list start 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)); free(pkt_res_devinfo); continue; - case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: - case DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES: - case DICMOTE_PACKET_TYPE_RESPONSE_SCSI: - case DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS: - case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28: - case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48: - case DICMOTE_PACKET_TYPE_RESPONSE_SDHCI: - case DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE: - case DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA: - case DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA: - case DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA: - pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_OOO; + case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: + case AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES: + case AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI: + case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS: + case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28: + case AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48: + case AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI: + case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE: + case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA: + case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA: + case AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA: + pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_OOO; memset(&pkt_nop->reason, 0, 256); strncpy(pkt_nop->reason, "Received response packet?! You should certainly not do that...", 256); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); printf("%s...\n", pkt_nop->reason); skip_next_hdr = 1; continue; - case DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE: + case AARUREMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE: pkt_dev_open = malloc(le32toh(pkt_hdr->len)); if(!pkt_dev_open) @@ -390,14 +390,14 @@ void* WorkingLoop(void* arguments) device_ctx = DeviceOpen(pkt_dev_open->device_path); 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; memset(&pkt_nop->reason, 0, 256); NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop)); free(pkt_dev_open); continue; - case DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE: + case AARUREMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -425,16 +425,16 @@ void* WorkingLoop(void* arguments) memset(pkt_dev_type, 0, 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.version = DICMOTE_PACKET_VERSION; - pkt_dev_type->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_dev_type->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_dev_type->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE; + pkt_dev_type->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_dev_type->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_dev_type->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_dev_type->device_type = htole32(GetDeviceType(device_ctx)); NetWrite(cli_ctx, pkt_dev_type, sizeof(DicPacketResGetDeviceType)); free(pkt_dev_type); continue; - case DICMOTE_PACKET_TYPE_COMMAND_SCSI: + case AARUREMOTE_PACKET_TYPE_COMMAND_SCSI: // Packet contains data after 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); 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.version = DICMOTE_PACKET_VERSION; - pkt_res_scsi->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_scsi->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_res_scsi->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_SCSI; + pkt_res_scsi->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_scsi->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_scsi->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); pkt_res_scsi->sense_len = htole32(sense_len); pkt_res_scsi->buf_len = pkt_cmd_scsi->buf_len; @@ -511,7 +511,7 @@ void* WorkingLoop(void* arguments) free(pkt_res_scsi); if(sense_buf) free(sense_buf); continue; - case DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS: + case AARUREMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -536,10 +536,10 @@ void* WorkingLoop(void* arguments) } memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters)); - pkt_res_sdhci_registers->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_sdhci_registers->hdr.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_sdhci_registers->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_sdhci_registers->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS; + pkt_res_sdhci_registers->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_sdhci_registers->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_sdhci_registers->hdr.version = AARUREMOTE_PACKET_VERSION; + 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->is_sdhci = GetSdhciRegisters(device_ctx, &csd, @@ -590,7 +590,7 @@ void* WorkingLoop(void* arguments) NetWrite(cli_ctx, pkt_res_sdhci_registers, le32toh(pkt_res_sdhci_registers->hdr.len)); free(pkt_res_sdhci_registers); continue; - case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA: + case AARUREMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -615,10 +615,10 @@ void* WorkingLoop(void* arguments) } memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData)); - pkt_res_usb->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_usb->hdr.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_usb->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_usb->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA; + pkt_res_usb->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_usb->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_usb->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_usb->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA; pkt_res_usb->hdr.len = htole32(sizeof(DicPacketResGetUsbData)); pkt_res_usb->is_usb = GetUsbData(device_ctx, &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)); free(pkt_res_usb); continue; - case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA: + case AARUREMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -661,10 +661,10 @@ void* WorkingLoop(void* arguments) } memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData)); - pkt_res_firewire->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_firewire->hdr.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_firewire->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_firewire->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA; + pkt_res_firewire->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_firewire->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_firewire->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_firewire->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA; pkt_res_firewire->hdr.len = htole32(sizeof(DicPacketResGetFireWireData)); pkt_res_firewire->is_firewire = GetFireWireData(device_ctx, &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)); free(pkt_res_firewire); continue; - case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA: + case AARUREMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -703,10 +703,10 @@ void* WorkingLoop(void* arguments) } memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData)); - pkt_res_pcmcia->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_pcmcia->hdr.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_pcmcia->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_pcmcia->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA; + pkt_res_pcmcia->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_pcmcia->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_pcmcia->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_pcmcia->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA; pkt_res_pcmcia->hdr.len = htole32(sizeof(DicPacketResGetPcmciaData)); pkt_res_pcmcia->is_pcmcia = 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)); free(pkt_res_pcmcia); continue; - case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS: + case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_CHS: // Packet contains data after 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)); 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.version = DICMOTE_PACKET_VERSION; - pkt_res_ata_chs->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_ata_chs->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_res_ata_chs->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_CHS; + pkt_res_ata_chs->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_ata_chs->hdr.remote_id = htole32(AARUREMOTE_REMOTE_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->buf_len = pkt_cmd_ata_chs->buf_len; @@ -788,7 +788,7 @@ void* WorkingLoop(void* arguments) free(pkt_cmd_ata_chs); free(pkt_res_ata_chs); continue; - case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28: + case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28: // Packet contains data after in_buf = malloc(le32toh(pkt_hdr->len)); @@ -846,10 +846,10 @@ void* WorkingLoop(void* arguments) pkt_res_ata_lba28->hdr.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.version = DICMOTE_PACKET_VERSION; - pkt_res_ata_lba28->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_ata_lba28->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_res_ata_lba28->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28; + pkt_res_ata_lba28->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_ata_lba28->hdr.remote_id = htole32(AARUREMOTE_REMOTE_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->buf_len = pkt_cmd_ata_lba28->buf_len; @@ -861,7 +861,7 @@ void* WorkingLoop(void* arguments) free(pkt_cmd_ata_lba28); free(pkt_res_ata_lba28); continue; - case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48: + case AARUREMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48: // Packet contains data after in_buf = malloc(le32toh(pkt_hdr->len)); @@ -924,10 +924,10 @@ void* WorkingLoop(void* arguments) pkt_res_ata_lba48->hdr.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.version = DICMOTE_PACKET_VERSION; - pkt_res_ata_lba48->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_ata_lba48->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_res_ata_lba48->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48; + pkt_res_ata_lba48->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_ata_lba48->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_ata_lba48->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); // Swapping 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_res_ata_lba48); continue; - case DICMOTE_PACKET_TYPE_COMMAND_SDHCI: + case AARUREMOTE_PACKET_TYPE_COMMAND_SDHCI: // Packet contains data after 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)); 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.version = DICMOTE_PACKET_VERSION; - pkt_res_sdhci->hdr.remote_id = htole32(DICMOTE_REMOTE_ID); - pkt_res_sdhci->hdr.packet_id = htole32(DICMOTE_PACKET_ID); + pkt_res_sdhci->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_SDHCI; + pkt_res_sdhci->hdr.version = AARUREMOTE_PACKET_VERSION; + pkt_res_sdhci->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_sdhci->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); sdhci_response[0] = htole32(sdhci_response[0]); sdhci_response[1] = htole32(sdhci_response[1]); @@ -1021,12 +1021,12 @@ void* WorkingLoop(void* arguments) free(pkt_cmd_sdhci); free(pkt_res_sdhci); continue; - case DICMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE: + case AARUREMOTE_PACKET_TYPE_COMMAND_CLOSE_DEVICE: DeviceClose(device_ctx); device_ctx = NULL; skip_next_hdr = 1; continue; - case DICMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT: + case AARUREMOTE_PACKET_TYPE_COMMAND_AM_I_ROOT: // Packet only contains header so, dummy in_buf = malloc(le32toh(pkt_hdr->len)); @@ -1051,10 +1051,10 @@ void* WorkingLoop(void* arguments) } 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.packet_id = htole32(DICMOTE_PACKET_ID); - pkt_res_am_i_root->hdr.version = DICMOTE_PACKET_VERSION; - pkt_res_am_i_root->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_AM_I_ROOT; + pkt_res_am_i_root->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID); + pkt_res_am_i_root->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID); + pkt_res_am_i_root->hdr.version = AARUREMOTE_PACKET_VERSION; + 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->am_i_root = AmIRoot(); @@ -1062,7 +1062,7 @@ void* WorkingLoop(void* arguments) free(pkt_res_am_i_root); continue; 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); snprintf(pkt_nop->reason, 256,