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 structures.

Browse Source
This commit is contained in:
Natalia Portillo
2020-03-01 05:52:58 +00:00
parent a2d9f96de7
commit e1bc701311
9 changed files with 170 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
aaruremote.h
View File

@@ -145,11 +145,11 @@ typedef struct
uint8_t version;
int8_t packet_type;
char spare[2];
} DicPacketHeader;
} AaruPacketHeader;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
char application[128];
char version[64];
uint8_t max_protocol;
@@ -157,18 +157,18 @@ typedef struct
char sysname[256];
char release[256];
char machine[256];
} DicPacketHello;
} AaruPacketHello;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdListDevs;
AaruPacketHeader hdr;
} AaruPacketCmdListDevs;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint16_t devices;
} DicPacketResListDevs;
} AaruPacketResListDevs;
typedef struct
{
@@ -189,37 +189,37 @@ typedef struct DeviceInfoList
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t reason_code;
char spare[3];
char reason[256];
int32_t error_no;
} DicPacketNop;
} AaruPacketNop;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
char device_path[1024];
} DicPacketCmdOpen;
} AaruPacketCmdOpen;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t cdb_len;
uint32_t buf_len;
int32_t direction;
uint32_t timeout;
} DicPacketCmdScsi;
} AaruPacketCmdScsi;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t sense_len;
uint32_t buf_len;
uint32_t duration;
uint32_t sense;
uint32_t error_no;
} DicPacketResScsi;
} AaruPacketResScsi;
typedef struct
{
@@ -245,7 +245,7 @@ typedef struct
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaRegistersChs registers;
uint8_t protocol;
@@ -253,17 +253,17 @@ typedef struct
uint8_t transfer_blocks;
uint8_t spare;
uint32_t timeout;
} DicPacketCmdAtaChs;
} AaruPacketCmdAtaChs;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaErrorRegistersChs registers;
uint32_t duration;
uint32_t sense;
uint32_t error_no;
} DicPacketResAtaChs;
} AaruPacketResAtaChs;
typedef struct
{
@@ -289,7 +289,7 @@ typedef struct
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaRegistersLba28 registers;
uint8_t protocol;
@@ -297,17 +297,17 @@ typedef struct
uint8_t transfer_blocks;
uint8_t spare;
uint32_t timeout;
} DicPacketCmdAtaLba28;
} AaruPacketCmdAtaLba28;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaErrorRegistersLba28 registers;
uint32_t duration;
uint32_t sense;
uint32_t error_no;
} DicPacketResAtaLba28;
} AaruPacketResAtaLba28;
typedef struct
{
@@ -333,7 +333,7 @@ typedef struct
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaRegistersLba48 registers;
uint8_t protocol;
@@ -341,21 +341,21 @@ typedef struct
uint8_t transfer_blocks;
uint8_t spare;
uint32_t timeout;
} DicPacketCmdAtaLba48;
} AaruPacketCmdAtaLba48;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
AtaErrorRegistersLba48 registers;
uint32_t duration;
uint32_t sense;
uint32_t error_no;
} DicPacketResAtaLba48;
} AaruPacketResAtaLba48;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t command;
uint8_t write;
uint8_t application;
@@ -365,37 +365,37 @@ typedef struct
uint32_t blocks;
uint32_t buf_len;
uint32_t timeout;
} DicPacketCmdSdhci;
} AaruPacketCmdSdhci;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t buf_len;
uint32_t response[4];
uint32_t duration;
uint32_t sense;
uint32_t error_no;
} DicPacketResSdhci;
} AaruPacketResSdhci;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdGetDeviceType;
AaruPacketHeader hdr;
} AaruPacketCmdGetDeviceType;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
int32_t device_type;
} DicPacketResGetDeviceType;
} AaruPacketResGetDeviceType;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdGetSdhciRegisters;
AaruPacketHeader hdr;
} AaruPacketCmdGetSdhciRegisters;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t is_sdhci;
char csd[16];
char cid[16];
@@ -405,16 +405,16 @@ typedef struct
uint32_t cid_len;
uint32_t ocr_len;
uint32_t scr_len;
} DicPacketResGetSdhciRegisters;
} AaruPacketResGetSdhciRegisters;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdGetUsbData;
AaruPacketHeader hdr;
} AaruPacketCmdGetUsbData;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t is_usb;
uint16_t desc_len;
char descriptors[65536];
@@ -423,52 +423,52 @@ typedef struct
char manufacturer[256];
char product[256];
char serial[256];
} DicPacketResGetUsbData;
} AaruPacketResGetUsbData;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdGetFireWireData;
AaruPacketHeader hdr;
} AaruPacketCmdGetFireWireData;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t is_firewire;
uint32_t id_model;
uint32_t id_vendor;
uint64_t guid;
char vendor[256];
char model[256];
} DicPacketResGetFireWireData;
} AaruPacketResGetFireWireData;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdGetPcmciaData;
AaruPacketHeader hdr;
} AaruPacketCmdGetPcmciaData;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint8_t is_pcmcia;
uint16_t cis_len;
char cis[65536];
} DicPacketResGetPcmciaData;
} AaruPacketResGetPcmciaData;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdClose;
AaruPacketHeader hdr;
} AaruPacketCmdClose;
typedef struct
{
DicPacketHeader hdr;
} DicPacketCmdAmIRoot;
AaruPacketHeader hdr;
} AaruPacketCmdAmIRoot;
typedef struct
{
DicPacketHeader hdr;
AaruPacketHeader hdr;
uint32_t am_i_root;
} DicPacketResAmIRoot;
} AaruPacketResAmIRoot;
#pragma pack(pop)
@@ -562,7 +562,7 @@ int32_t SendSdhciCommand(void* device_ctx,
uint32_t* response,
uint32_t* duration,
uint32_t* sense);
DicPacketHello* GetHello();
AaruPacketHello* GetHello();
int PrintNetworkAddresses();
char* PrintIpv4Address(struct in_addr addr);
void* NetSocket(uint32_t domain, uint32_t type, uint32_t protocol);
@@ -573,7 +573,7 @@ int32_t NetRecv(void* net_ctx, void* buf, int32_t len, uint32_t flags);
int32_t NetWrite(void* net_ctx, const void* buf, int32_t size);
int32_t NetClose(void* net_ctx);
void Initialize();
void PlatformLoop(DicPacketHello* pkt_server_hello);
void PlatformLoop(AaruPacketHello* pkt_server_hello);
void* WorkingLoop(void* arguments);
uint8_t AmIRoot();
#endif

2
main.c
View File

@@ -23,7 +23,7 @@
int main()
{
DicPacketHello* pkt_server_hello;
AaruPacketHello* pkt_server_hello;
int ret;
Initialize();

10
unix/hello.c
View File

@@ -21,25 +21,25 @@
#include <string.h>
#include <sys/utsname.h>
DicPacketHello* GetHello()
AaruPacketHello* GetHello()
{
struct utsname utsname;
int ret;
DicPacketHello* pkt_server_hello;
AaruPacketHello* pkt_server_hello;
ret = uname(&utsname);
if(ret) { return 0; }
pkt_server_hello = malloc(sizeof(DicPacketHello));
pkt_server_hello = malloc(sizeof(AaruPacketHello));
if(!pkt_server_hello) { return 0; }
memset(pkt_server_hello, 0, sizeof(DicPacketHello));
memset(pkt_server_hello, 0, sizeof(AaruPacketHello));
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.len = htole32(sizeof(AaruPacketHello));
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));

2
unix/unix.c
View File

@@ -24,6 +24,6 @@ void Initialize()
// Do nothing
}
void PlatformLoop(DicPacketHello* pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformLoop(AaruPacketHello* pkt_server_hello) { WorkingLoop(pkt_server_hello); }
uint8_t AmIRoot() { return geteuid() == 0; }

10
wii/hello.c
View File

@@ -23,19 +23,19 @@
#include <stdio.h>
#include <string.h>
DicPacketHello* GetHello()
AaruPacketHello* GetHello()
{
DicPacketHello* pkt_server_hello;
AaruPacketHello* pkt_server_hello;
pkt_server_hello = malloc(sizeof(DicPacketHello));
pkt_server_hello = malloc(sizeof(AaruPacketHello));
if(!pkt_server_hello) { return 0; }
memset(pkt_server_hello, 0, sizeof(DicPacketHello));
memset(pkt_server_hello, 0, sizeof(AaruPacketHello));
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.len = htole32(sizeof(AaruPacketHello));
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));

2
wii/wii.c
View File

@@ -42,7 +42,7 @@ void Initialize()
if(rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
}
void PlatformLoop(DicPacketHello* pkt_server_hello)
void PlatformLoop(AaruPacketHello* pkt_server_hello)
{
static lwp_t worker = (lwp_t)NULL;
int buttonsDown;

10
win32/hello.c
View File

@@ -24,9 +24,9 @@
#include <string.h>
#include <windows.h>
DicPacketHello* GetHello()
AaruPacketHello* GetHello()
{
DicPacketHello* pkt_server_hello;
AaruPacketHello* pkt_server_hello;
OSVERSIONINFOEX osvi;
SYSTEM_INFO sysinfo;
UINT verSize;
@@ -57,15 +57,15 @@ DicPacketHello* GetHello()
const char* w2k16 = "Windows Server 2016";
const char* w10 = "Windows 10";
pkt_server_hello = malloc(sizeof(DicPacketHello));
pkt_server_hello = malloc(sizeof(AaruPacketHello));
if(!pkt_server_hello) return 0;
memset(pkt_server_hello, 0, sizeof(DicPacketHello));
memset(pkt_server_hello, 0, sizeof(AaruPacketHello));
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.len = htole32(sizeof(AaruPacketHello));
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));

2
win32/win32.c
View File

@@ -22,7 +22,7 @@ void Initialize()
// Do nothing
}
void PlatformLoop(DicPacketHello* pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformLoop(AaruPacketHello* pkt_server_hello) { WorkingLoop(pkt_server_hello); }
uint8_t AmIRoot()
{

184
worker.c
View File

@@ -41,28 +41,28 @@ void* WorkingLoop(void* arguments)
char* out_buf;
char* scr;
char* sense_buf;
DicPacketCmdAtaChs* pkt_cmd_ata_chs;
DicPacketCmdAtaLba28* pkt_cmd_ata_lba28;
DicPacketCmdAtaLba48* pkt_cmd_ata_lba48;
DicPacketCmdOpen* pkt_dev_open;
DicPacketCmdScsi* pkt_cmd_scsi;
DicPacketCmdSdhci* pkt_cmd_sdhci;
DicPacketHeader* pkt_hdr;
DicPacketHello* pkt_server_hello;
DicPacketHello* pkt_client_hello;
DicPacketNop* pkt_nop;
DicPacketResAmIRoot* pkt_res_am_i_root;
DicPacketResAtaChs* pkt_res_ata_chs;
DicPacketResAtaLba28* pkt_res_ata_lba28;
DicPacketResAtaLba48* pkt_res_ata_lba48;
DicPacketResGetDeviceType* pkt_dev_type;
DicPacketResGetFireWireData* pkt_res_firewire;
DicPacketResGetPcmciaData* pkt_res_pcmcia;
DicPacketResGetSdhciRegisters* pkt_res_sdhci_registers;
DicPacketResGetUsbData* pkt_res_usb;
DicPacketResListDevs* pkt_res_devinfo;
DicPacketResScsi* pkt_res_scsi;
DicPacketResSdhci* pkt_res_sdhci;
AaruPacketCmdAtaChs* pkt_cmd_ata_chs;
AaruPacketCmdAtaLba28* pkt_cmd_ata_lba28;
AaruPacketCmdAtaLba48* pkt_cmd_ata_lba48;
AaruPacketCmdOpen* pkt_dev_open;
AaruPacketCmdScsi* pkt_cmd_scsi;
AaruPacketCmdSdhci* pkt_cmd_sdhci;
AaruPacketHeader* pkt_hdr;
AaruPacketHello* pkt_server_hello;
AaruPacketHello* pkt_client_hello;
AaruPacketNop* pkt_nop;
AaruPacketResAmIRoot* pkt_res_am_i_root;
AaruPacketResAtaChs* pkt_res_ata_chs;
AaruPacketResAtaLba28* pkt_res_ata_lba28;
AaruPacketResAtaLba48* pkt_res_ata_lba48;
AaruPacketResGetDeviceType* pkt_dev_type;
AaruPacketResGetFireWireData* pkt_res_firewire;
AaruPacketResGetPcmciaData* pkt_res_pcmcia;
AaruPacketResGetSdhciRegisters* pkt_res_sdhci_registers;
AaruPacketResGetUsbData* pkt_res_usb;
AaruPacketResListDevs* pkt_res_devinfo;
AaruPacketResScsi* pkt_res_scsi;
AaruPacketResSdhci* pkt_res_sdhci;
int skip_next_hdr;
int ret;
socklen_t cli_len;
@@ -84,7 +84,7 @@ void* WorkingLoop(void* arguments)
return NULL;
}
pkt_server_hello = (DicPacketHello*)arguments;
pkt_server_hello = (AaruPacketHello*)arguments;
printf("Opening socket.\n");
net_ctx = NetSocket(AF_INET, SOCK_STREAM, 0);
@@ -114,7 +114,7 @@ void* WorkingLoop(void* arguments)
return NULL;
}
pkt_nop = malloc(sizeof(DicPacketNop));
pkt_nop = malloc(sizeof(AaruPacketNop));
if(!pkt_nop)
{
@@ -123,11 +123,11 @@ void* WorkingLoop(void* arguments)
return NULL;
}
memset(pkt_nop, 0, sizeof(DicPacketNop));
memset(pkt_nop, 0, sizeof(AaruPacketNop));
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.len = htole32(sizeof(AaruPacketNop));
pkt_nop->hdr.version = AARUREMOTE_PACKET_VERSION;
pkt_nop->hdr.packet_type = AARUREMOTE_PACKET_TYPE_NOP;
@@ -148,9 +148,9 @@ void* WorkingLoop(void* arguments)
printf("Client %s connected successfully.\n", PrintIpv4Address(cli_addr.sin_addr));
NetWrite(cli_ctx, pkt_server_hello, sizeof(DicPacketHello));
NetWrite(cli_ctx, pkt_server_hello, sizeof(AaruPacketHello));
pkt_hdr = malloc(sizeof(DicPacketHeader));
pkt_hdr = malloc(sizeof(AaruPacketHeader));
if(!pkt_hdr)
{
@@ -161,7 +161,7 @@ void* WorkingLoop(void* arguments)
return NULL;
}
recv_size = NetRecv(cli_ctx, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK);
recv_size = NetRecv(cli_ctx, pkt_hdr, sizeof(AaruPacketHeader), MSG_PEEK);
if(recv_size < 0)
{
@@ -254,7 +254,7 @@ void* WorkingLoop(void* arguments)
skip_next_hdr = 0;
}
recv_size = NetRecv(cli_ctx, pkt_hdr, sizeof(DicPacketHeader), MSG_PEEK);
recv_size = NetRecv(cli_ctx, pkt_hdr, sizeof(AaruPacketHeader), MSG_PEEK);
if(recv_size < 0)
{
@@ -293,7 +293,7 @@ void* WorkingLoop(void* arguments)
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));
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));
printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1;
continue;
@@ -319,20 +319,20 @@ void* WorkingLoop(void* arguments)
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));
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));
printf("%s...\n", pkt_nop->reason);
continue;
}
pkt_res_devinfo = malloc(sizeof(DicPacketResListDevs));
pkt_res_devinfo = malloc(sizeof(AaruPacketResListDevs));
pkt_res_devinfo->devices = htole16(DeviceInfoListCount(device_info_list));
n = sizeof(DicPacketResListDevs) + le16toh(pkt_res_devinfo->devices) * sizeof(DeviceInfo);
n = sizeof(AaruPacketResListDevs) + le16toh(pkt_res_devinfo->devices) * sizeof(DeviceInfo);
in_buf = malloc(n);
((DicPacketResListDevs*)in_buf)->hdr.len = htole32(n);
((DicPacketResListDevs*)in_buf)->devices = pkt_res_devinfo->devices;
((AaruPacketResListDevs*)in_buf)->hdr.len = htole32(n);
((AaruPacketResListDevs*)in_buf)->devices = pkt_res_devinfo->devices;
free(pkt_res_devinfo);
pkt_res_devinfo = (DicPacketResListDevs*)in_buf;
pkt_res_devinfo = (AaruPacketResListDevs*)in_buf;
pkt_res_devinfo->hdr.remote_id = htole32(AARUREMOTE_REMOTE_ID);
pkt_res_devinfo->hdr.packet_id = htole32(AARUREMOTE_PACKET_ID);
@@ -341,7 +341,7 @@ void* WorkingLoop(void* arguments)
// Save list start
in_buf = (char*)device_info_list;
long off = sizeof(DicPacketResListDevs);
long off = sizeof(AaruPacketResListDevs);
while(device_info_list)
{
@@ -370,7 +370,7 @@ void* WorkingLoop(void* arguments)
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));
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));
printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1;
continue;
@@ -393,7 +393,7 @@ void* WorkingLoop(void* arguments)
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));
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));
free(pkt_dev_open);
continue;
@@ -412,7 +412,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_dev_type = malloc(sizeof(DicPacketResGetDeviceType));
pkt_dev_type = malloc(sizeof(AaruPacketResGetDeviceType));
if(!pkt_dev_type)
{
@@ -422,16 +422,16 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_dev_type, 0, sizeof(DicPacketResGetDeviceType));
memset(pkt_dev_type, 0, sizeof(AaruPacketResGetDeviceType));
pkt_dev_type->hdr.len = htole32(sizeof(DicPacketResGetDeviceType));
pkt_dev_type->hdr.len = htole32(sizeof(AaruPacketResGetDeviceType));
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));
NetWrite(cli_ctx, pkt_dev_type, sizeof(AaruPacketResGetDeviceType));
free(pkt_dev_type);
continue;
case AARUREMOTE_PACKET_TYPE_COMMAND_SCSI:
@@ -448,16 +448,16 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_scsi = (DicPacketCmdScsi*)in_buf;
pkt_cmd_scsi = (AaruPacketCmdScsi*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
if(le32toh(pkt_cmd_scsi->cdb_len) > 0) cdb_buf = in_buf + sizeof(DicPacketCmdScsi);
if(le32toh(pkt_cmd_scsi->cdb_len) > 0) cdb_buf = in_buf + sizeof(AaruPacketCmdScsi);
else
cdb_buf = NULL;
if(le32toh(pkt_cmd_scsi->buf_len) > 0)
buffer = in_buf + le32toh(pkt_cmd_scsi->cdb_len) + sizeof(DicPacketCmdScsi);
buffer = in_buf + le32toh(pkt_cmd_scsi->cdb_len) + sizeof(AaruPacketCmdScsi);
else
buffer = NULL;
@@ -479,7 +479,7 @@ void* WorkingLoop(void* arguments)
// Swap buf_len back
pkt_cmd_scsi->buf_len = htole32(pkt_cmd_scsi->buf_len);
out_buf = malloc(sizeof(DicPacketResScsi) + sense_len + le32toh(pkt_cmd_scsi->buf_len));
out_buf = malloc(sizeof(AaruPacketResScsi) + sense_len + le32toh(pkt_cmd_scsi->buf_len));
if(!out_buf)
{
@@ -490,11 +490,11 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_scsi = (DicPacketResScsi*)out_buf;
if(sense_buf) memcpy(out_buf + sizeof(DicPacketResScsi), sense_buf, sense_len);
if(buffer) memcpy(out_buf + sizeof(DicPacketResScsi) + sense_len, buffer, pkt_cmd_scsi->buf_len);
pkt_res_scsi = (AaruPacketResScsi*)out_buf;
if(sense_buf) memcpy(out_buf + sizeof(AaruPacketResScsi), sense_buf, sense_len);
if(buffer) memcpy(out_buf + sizeof(AaruPacketResScsi) + 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(AaruPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len);
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);
@@ -526,7 +526,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters));
pkt_res_sdhci_registers = malloc(sizeof(AaruPacketResGetSdhciRegisters));
if(!pkt_res_sdhci_registers)
{
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
@@ -535,12 +535,12 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters));
memset(pkt_res_sdhci_registers, 0, sizeof(AaruPacketResGetSdhciRegisters));
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->hdr.len = htole32(sizeof(AaruPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_ctx,
&csd,
&cid,
@@ -605,7 +605,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_res_usb = malloc(sizeof(DicPacketResGetUsbData));
pkt_res_usb = malloc(sizeof(AaruPacketResGetUsbData));
if(!pkt_res_usb)
{
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
@@ -614,12 +614,12 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData));
memset(pkt_res_usb, 0, sizeof(AaruPacketResGetUsbData));
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->hdr.len = htole32(sizeof(AaruPacketResGetUsbData));
pkt_res_usb->is_usb = GetUsbData(device_ctx,
&pkt_res_usb->desc_len,
pkt_res_usb->descriptors,
@@ -651,7 +651,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_res_firewire = malloc(sizeof(DicPacketResGetFireWireData));
pkt_res_firewire = malloc(sizeof(AaruPacketResGetFireWireData));
if(!pkt_res_firewire)
{
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
@@ -660,12 +660,12 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData));
memset(pkt_res_firewire, 0, sizeof(AaruPacketResGetFireWireData));
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->hdr.len = htole32(sizeof(AaruPacketResGetFireWireData));
pkt_res_firewire->is_firewire = GetFireWireData(device_ctx,
&pkt_res_firewire->id_model,
&pkt_res_firewire->id_vendor,
@@ -693,7 +693,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_res_pcmcia = malloc(sizeof(DicPacketResGetPcmciaData));
pkt_res_pcmcia = malloc(sizeof(AaruPacketResGetPcmciaData));
if(!pkt_res_pcmcia)
{
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
@@ -702,12 +702,12 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData));
memset(pkt_res_pcmcia, 0, sizeof(AaruPacketResGetPcmciaData));
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->hdr.len = htole32(sizeof(AaruPacketResGetPcmciaData));
pkt_res_pcmcia->is_pcmcia =
GetPcmciaData(device_ctx, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis);
@@ -730,11 +730,11 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_chs = (DicPacketCmdAtaChs*)in_buf;
pkt_cmd_ata_chs = (AaruPacketCmdAtaChs*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
if(le32toh(pkt_cmd_ata_chs->buf_len) > 0) buffer = in_buf + sizeof(DicPacketCmdAtaChs);
if(le32toh(pkt_cmd_ata_chs->buf_len) > 0) buffer = in_buf + sizeof(AaruPacketCmdAtaChs);
else
buffer = NULL;
@@ -756,7 +756,7 @@ void* WorkingLoop(void* arguments)
&sense,
&pkt_cmd_ata_chs->buf_len);
out_buf = malloc(sizeof(DicPacketResAtaChs) + pkt_cmd_ata_chs->buf_len);
out_buf = malloc(sizeof(AaruPacketResAtaChs) + pkt_cmd_ata_chs->buf_len);
pkt_cmd_ata_chs->buf_len = htole32(pkt_cmd_ata_chs->buf_len);
@@ -769,10 +769,10 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_chs = (DicPacketResAtaChs*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaChs), buffer, htole32(pkt_cmd_ata_chs->buf_len));
pkt_res_ata_chs = (AaruPacketResAtaChs*)out_buf;
if(buffer) memcpy(out_buf + sizeof(AaruPacketResAtaChs), 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(AaruPacketResAtaChs) + htole32(pkt_cmd_ata_chs->buf_len));
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);
@@ -802,11 +802,11 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba28 = (DicPacketCmdAtaLba28*)in_buf;
pkt_cmd_ata_lba28 = (AaruPacketCmdAtaLba28*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
if(le32toh(pkt_cmd_ata_lba28->buf_len) > 0) buffer = in_buf + sizeof(DicPacketCmdAtaLba28);
if(le32toh(pkt_cmd_ata_lba28->buf_len) > 0) buffer = in_buf + sizeof(AaruPacketCmdAtaLba28);
else
buffer = NULL;
@@ -828,7 +828,7 @@ void* WorkingLoop(void* arguments)
&sense,
&pkt_cmd_ata_lba28->buf_len);
out_buf = malloc(sizeof(DicPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len);
out_buf = malloc(sizeof(AaruPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len);
pkt_cmd_ata_lba28->buf_len = htole32(pkt_cmd_ata_lba28->buf_len);
if(!out_buf)
@@ -840,12 +840,12 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_lba28 = (DicPacketResAtaLba28*)out_buf;
pkt_res_ata_lba28 = (AaruPacketResAtaLba28*)out_buf;
if(buffer)
memcpy(out_buf + sizeof(DicPacketResAtaLba28), buffer, le32toh(pkt_cmd_ata_lba28->buf_len));
memcpy(out_buf + sizeof(AaruPacketResAtaLba28), buffer, le32toh(pkt_cmd_ata_lba28->buf_len));
pkt_res_ata_lba28->hdr.len =
htole32(sizeof(DicPacketResAtaLba28) + le32toh(pkt_cmd_ata_lba28->buf_len));
htole32(sizeof(AaruPacketResAtaLba28) + le32toh(pkt_cmd_ata_lba28->buf_len));
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);
@@ -875,11 +875,11 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba48 = (DicPacketCmdAtaLba48*)in_buf;
pkt_cmd_ata_lba48 = (AaruPacketCmdAtaLba48*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
if(le32toh(pkt_cmd_ata_lba48->buf_len) > 0) buffer = in_buf + sizeof(DicPacketCmdAtaLba48);
if(le32toh(pkt_cmd_ata_lba48->buf_len) > 0) buffer = in_buf + sizeof(AaruPacketCmdAtaLba48);
else
buffer = NULL;
@@ -906,7 +906,7 @@ void* WorkingLoop(void* arguments)
&sense,
&pkt_cmd_ata_lba48->buf_len);
out_buf = malloc(sizeof(DicPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len);
out_buf = malloc(sizeof(AaruPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len);
pkt_cmd_ata_lba48->buf_len = htole32(pkt_cmd_ata_lba48->buf_len);
if(!out_buf)
@@ -918,12 +918,12 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_lba48 = (DicPacketResAtaLba48*)out_buf;
pkt_res_ata_lba48 = (AaruPacketResAtaLba48*)out_buf;
if(buffer)
memcpy(out_buf + sizeof(DicPacketResAtaLba48), buffer, le32toh(pkt_cmd_ata_lba48->buf_len));
memcpy(out_buf + sizeof(AaruPacketResAtaLba48), buffer, le32toh(pkt_cmd_ata_lba48->buf_len));
pkt_res_ata_lba48->hdr.len =
htole32(sizeof(DicPacketResAtaLba48) + le32toh(pkt_cmd_ata_lba48->buf_len));
htole32(sizeof(AaruPacketResAtaLba48) + le32toh(pkt_cmd_ata_lba48->buf_len));
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);
@@ -959,11 +959,11 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_sdhci = (DicPacketCmdSdhci*)in_buf;
pkt_cmd_sdhci = (AaruPacketCmdSdhci*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
if(le32toh(pkt_cmd_sdhci->buf_len) > 0) buffer = in_buf + sizeof(DicPacketCmdSdhci);
if(le32toh(pkt_cmd_sdhci->buf_len) > 0) buffer = in_buf + sizeof(AaruPacketCmdSdhci);
else
buffer = NULL;
@@ -986,7 +986,7 @@ void* WorkingLoop(void* arguments)
&duration,
&sense);
out_buf = malloc(sizeof(DicPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
out_buf = malloc(sizeof(AaruPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
if(!out_buf)
{
@@ -997,10 +997,10 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_sdhci = (DicPacketResSdhci*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResSdhci), buffer, le32toh(pkt_cmd_sdhci->buf_len));
pkt_res_sdhci = (AaruPacketResSdhci*)out_buf;
if(buffer) memcpy(out_buf + sizeof(AaruPacketResSdhci), 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(AaruPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
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);
@@ -1041,7 +1041,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf);
pkt_res_am_i_root = malloc(sizeof(DicPacketResAmIRoot));
pkt_res_am_i_root = malloc(sizeof(AaruPacketResAmIRoot));
if(!pkt_res_am_i_root)
{
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
@@ -1050,12 +1050,12 @@ void* WorkingLoop(void* arguments)
continue;
}
memset(pkt_res_am_i_root, 0, sizeof(DicPacketResAmIRoot));
memset(pkt_res_am_i_root, 0, sizeof(AaruPacketResAmIRoot));
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->hdr.len = htole32(sizeof(AaruPacketResAmIRoot));
pkt_res_am_i_root->am_i_root = AmIRoot();
NetWrite(cli_ctx, pkt_res_am_i_root, le32toh(pkt_res_am_i_root->hdr.len));
@@ -1068,7 +1068,7 @@ void* WorkingLoop(void* arguments)
256,
"Received unrecognized packet with type %d, skipping...",
pkt_hdr->packet_type);
NetWrite(cli_ctx, pkt_nop, sizeof(DicPacketNop));
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));
printf("%s...\n", pkt_nop->reason);
skip_next_hdr = 1;
continue;