aaru-dps/aaruremote
1
0
Fork 0
mirror of https://github.com/aaru-dps/aaruremote.git synced 2026-07-08 17:56:38 +00:00
Code Issues 10 Packages Projects Releases Wiki Activity

Add device listing and idle action handling

Browse Source 
- Introduced PrintDeviceList function to display connected devices in a formatted table.
- Added idle action definitions for listing devices and exiting.
- Implemented PlatformResetIdleInput and PlatformGetIdleAction functions for handling user input in idle state.
- Enhanced network handling with NetPoll function for non-blocking socket operations.
- Updated WorkingLoop to incorporate idle actions and device listing functionality.
- Refactored code for consistency and readability, including pointer formatting and function signatures.
This commit is contained in:
Natalia Portillo
2026-04-10 10:38:38 +01:00
parent 735b43db42
commit 5b773ed236
9 changed files with 355 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
aaruremote.h
View File

@@ -543,9 +543,14 @@ typedef struct
uint8_t write;
} MmcSingleCommand;
#define AARUREMOTE_IDLE_ACTION_NONE 0
#define AARUREMOTE_IDLE_ACTION_LIST_DEVICES 1
#define AARUREMOTE_IDLE_ACTION_EXIT 2
DeviceInfoList* ListDevices();
void FreeDeviceInfoList(DeviceInfoList* start);
uint16_t DeviceInfoListCount(DeviceInfoList* start);
void PrintDeviceList();
void* DeviceOpen(const char* device_path);
void DeviceClose(void* device_ctx);
int32_t GetDeviceType(void* device_ctx);
@@ -649,8 +654,11 @@ void* NetAccept(void* net_ctx, struct sockaddr* addr, socklen_t* addr
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);
int32_t NetPoll(void* net_ctx, uint32_t timeout_ms);
void Initialize();
void PlatformLoop(AaruPacketHello* pkt_server_hello);
void PlatformResetIdleInput();
uint8_t PlatformGetIdleAction();
void* WorkingLoop(void* arguments);
uint8_t AmIRoot();
int32_t ReOpen(void* device_ctx, uint32_t* closeFailed);

53
list_devices.c
View File

@@ -15,6 +15,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdlib.h>
#ifdef _WIN32
@@ -27,9 +28,9 @@
#include "aaruremote.h"
void FreeDeviceInfoList(DeviceInfoList* start)
void FreeDeviceInfoList(DeviceInfoList *start)
{
DeviceInfoList* current;
DeviceInfoList *current;
while(start)
{
@@ -39,10 +40,10 @@ void FreeDeviceInfoList(DeviceInfoList* start)
}
}
uint16_t DeviceInfoListCount(DeviceInfoList* start)
uint16_t DeviceInfoListCount(DeviceInfoList *start)
{
uint16_t count = 0;
DeviceInfoList* current;
DeviceInfoList *current;
while(start)
{
@@ -52,4 +53,48 @@ uint16_t DeviceInfoListCount(DeviceInfoList* start)
}
return count;
}
void PrintDeviceList()
{
DeviceInfoList *current;
DeviceInfoList *start;
uint16_t count;
uint16_t i = 1;
start = ListDevices();
if(!start)
{
printf("Could not get device list.\n");
return;
}
count = DeviceInfoListCount(start);
printf("Detected %u device(s):\n", count);
printf("+----+--------------------------+------------------+--------------------------+----------------------+-----"
"---------+-----------+\n");
printf("| # | Path | Vendor | Model | Serial | Bus "
" | Supported |\n");
printf("+----+--------------------------+------------------+--------------------------+----------------------+-----"
"---------+-----------+\n");
current = start;
while(current)
{
printf("| %-2u | %-24.24s | %-16.16s | %-24.24s | %-20.20s | %-12.12s | %-9.9s |\n", i,
current->this.path[0] ? current->this.path : "(unknown)",
current->this.vendor[0] ? current->this.vendor : "(unknown)",
current->this.model[0] ? current->this.model : "(unknown)",
current->this.serial[0] ? current->this.serial : "(unknown)",
current->this.bus[0] ? current->this.bus : "(unknown)", current->this.supported ? "yes" : "no");
current = current->next;
i++;
}
printf("+----+--------------------------+------------------+--------------------------+----------------------+-----"
"---------+-----------+\n");
FreeDeviceInfoList(start);
}

18
unix/network.c
View File

@@ -20,6 +20,7 @@
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/select.h>
#include <unistd.h>
#include "../aaruremote.h"
@@ -148,6 +149,23 @@ int32_t NetWrite(void *net_ctx, const void *buf, int32_t size)
return write(ctx->fd, buf, size);
}
int32_t NetPoll(void *net_ctx, uint32_t timeout_ms)
{
fd_set readfds;
struct timeval timeout;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
FD_ZERO(&readfds);
FD_SET(ctx->fd, &readfds);
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
return select(ctx->fd + 1, &readfds, NULL, NULL, &timeout);
}
int32_t NetClose(void *net_ctx)
{
int ret;

42
unix/unix.c
View File

@@ -15,15 +15,55 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
#include "../aaruremote.h"
static struct termios original_termios;
static uint8_t terminal_configured = 0;
static void RestoreTerminalMode()
{
if(terminal_configured) tcsetattr(STDIN_FILENO, TCSANOW, &original_termios);
}
void Initialize()
{
// Do nothing
struct termios current_termios;
if(!isatty(STDIN_FILENO)) return;
if(tcgetattr(STDIN_FILENO, &original_termios)) return;
current_termios = original_termios;
current_termios.c_lflag &= ~(ICANON | ECHO);
current_termios.c_cc[VMIN] = 0;
current_termios.c_cc[VTIME] = 0;
if(!tcsetattr(STDIN_FILENO, TCSANOW, &current_termios))
{
terminal_configured = 1;
atexit(RestoreTerminalMode);
}
}
void PlatformLoop(AaruPacketHello *pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformResetIdleInput()
{
if(terminal_configured) tcflush(STDIN_FILENO, TCIFLUSH);
}
uint8_t PlatformGetIdleAction()
{
char key;
if(!terminal_configured) return AARUREMOTE_IDLE_ACTION_NONE;
if(read(STDIN_FILENO, &key, 1) <= 0) return AARUREMOTE_IDLE_ACTION_NONE;
if(key == 'd' || key == 'D') return AARUREMOTE_IDLE_ACTION_LIST_DEVICES;
return AARUREMOTE_IDLE_ACTION_NONE;
}
uint8_t AmIRoot() { return geteuid() == 0; }

17
wii/network.c
View File

@@ -132,6 +132,23 @@ int32_t NetWrite(void *net_ctx, const void *buf, int32_t size)
return net_write(ctx->fd, buf, size);
}
int32_t NetPoll(void *net_ctx, uint32_t timeout_ms)
{
fd_set readfds;
struct timeval timeout;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
FD_ZERO(&readfds);
FD_SET(ctx->fd, &readfds);
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
return net_select(ctx->fd + 1, &readfds, NULL, NULL, &timeout);
}
int32_t NetClose(void *net_ctx)
{
int ret;

27
wii/wii.c
View File

@@ -42,26 +42,21 @@ void Initialize()
if(rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
}
void PlatformLoop(AaruPacketHello *pkt_server_hello)
void PlatformLoop(AaruPacketHello *pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformResetIdleInput() {}
uint8_t PlatformGetIdleAction()
{
static lwp_t worker = (lwp_t)NULL;
int buttonsDown;
LWP_CreateThread(&worker, /* thread handle */
WorkingLoop, /* code */
pkt_server_hello, /* arg pointer for thread */
NULL, /* stack base */
16 * 1024, /* stack size */
50 /* thread priority */);
int buttonsDown;
while(true)
{
VIDEO_WaitVSync();
WPAD_ScanPads();
WPAD_ScanPads();
buttonsDown = WPAD_ButtonsDown(0);
buttonsDown = WPAD_ButtonsDown(0);
if(buttonsDown & WPAD_BUTTON_HOME) return AARUREMOTE_IDLE_ACTION_EXIT;
if(buttonsDown & WPAD_BUTTON_A) return AARUREMOTE_IDLE_ACTION_LIST_DEVICES;
if(buttonsDown & WPAD_BUTTON_HOME) { return; }
}
return AARUREMOTE_IDLE_ACTION_NONE;
}
uint8_t AmIRoot() { return 1; }

60
win32/network.c
View File

@@ -15,15 +15,15 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <winsock2.h>
#include <windows.h>
#include <winsock2.h>
#include <iphlpapi.h>
#include <stdio.h>
#include <stdlib.h>
#include "win32.h"
#include "../aaruremote.h"
#include "win32.h"
int PrintNetworkAddresses()
{
@@ -35,7 +35,7 @@ int PrintNetworkAddresses()
PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
ULONG outBufLen = 32768;
pAddresses = (IP_ADAPTER_ADDRESSES*)HeapAlloc(GetProcessHeap(), 0, outBufLen);
pAddresses = (IP_ADAPTER_ADDRESSES *)HeapAlloc(GetProcessHeap(), 0, outBufLen);
if(pAddresses == NULL)
{
@@ -62,8 +62,7 @@ int PrintNetworkAddresses()
while(pUnicast != NULL)
{
printf("%s port %d\n",
inet_ntoa(((struct sockaddr_in*)pUnicast->Address.lpSockaddr)->sin_addr),
printf("%s port %d\n", inet_ntoa(((struct sockaddr_in *)pUnicast->Address.lpSockaddr)->sin_addr),
AARUREMOTE_PORT);
pUnicast = pUnicast->Next;
}
@@ -76,13 +75,13 @@ int PrintNetworkAddresses()
return 0;
}
char* PrintIpv4Address(struct in_addr addr) { return inet_ntoa(addr); }
char *PrintIpv4Address(struct in_addr addr) { return inet_ntoa(addr); }
void* NetSocket(uint32_t domain, uint32_t type, uint32_t protocol)
void *NetSocket(uint32_t domain, uint32_t type, uint32_t protocol)
{
WSADATA ws;
int ret;
NetworkContext* ctx;
NetworkContext *ctx;
ret = WSAStartup(MAKEWORD(2, 0), &ws);
@@ -108,28 +107,28 @@ void* NetSocket(uint32_t domain, uint32_t type, uint32_t protocol)
return ctx;
}
int32_t NetBind(void* net_ctx, struct sockaddr* addr, socklen_t addrlen)
int32_t NetBind(void *net_ctx, struct sockaddr *addr, socklen_t addrlen)
{
NetworkContext* ctx = net_ctx;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
return bind(ctx->socket, addr, addrlen);
}
int32_t NetListen(void* net_ctx, uint32_t backlog)
int32_t NetListen(void *net_ctx, uint32_t backlog)
{
NetworkContext* ctx = net_ctx;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
return listen(ctx->socket, backlog);
}
void* NetAccept(void* net_ctx, struct sockaddr* addr, socklen_t* addrlen)
void *NetAccept(void *net_ctx, struct sockaddr *addr, socklen_t *addrlen)
{
NetworkContext* ctx = net_ctx;
NetworkContext* cli_ctx;
NetworkContext *ctx = net_ctx;
NetworkContext *cli_ctx;
if(!ctx) return NULL;
@@ -148,10 +147,10 @@ void* NetAccept(void* net_ctx, struct sockaddr* addr, socklen_t* addrlen)
return cli_ctx;
}
int32_t NetRecv(void* net_ctx, void* buf, int32_t len, uint32_t flags)
int32_t NetRecv(void *net_ctx, void *buf, int32_t len, uint32_t flags)
{
NetworkContext* ctx = net_ctx;
char* charbuf = buf;
NetworkContext *ctx = net_ctx;
char *charbuf = buf;
int32_t got_once;
int32_t got_total = 0;
@@ -171,19 +170,36 @@ int32_t NetRecv(void* net_ctx, void* buf, int32_t len, uint32_t flags)
return got_total;
}
int32_t NetWrite(void* net_ctx, const void* buf, int32_t size)
int32_t NetWrite(void *net_ctx, const void *buf, int32_t size)
{
NetworkContext* ctx = net_ctx;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
return send(ctx->socket, buf, size, 0);
}
int32_t NetClose(void* net_ctx)
int32_t NetPoll(void *net_ctx, uint32_t timeout_ms)
{
fd_set readfds;
struct timeval timeout;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;
FD_ZERO(&readfds);
FD_SET(ctx->socket, &readfds);
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
return select(0, &readfds, NULL, NULL, &timeout);
}
int32_t NetClose(void *net_ctx)
{
int ret;
NetworkContext* ctx = net_ctx;
NetworkContext *ctx = net_ctx;
if(!ctx) return -1;

25
win32/win32.c
View File

@@ -15,6 +15,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <conio.h>
#include <windows.h>
#include "win32.h"
@@ -26,7 +27,25 @@ void Initialize()
// Do nothing
}
void PlatformLoop(AaruPacketHello* pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformLoop(AaruPacketHello *pkt_server_hello) { WorkingLoop(pkt_server_hello); }
void PlatformResetIdleInput()
{
while(_kbhit()) _getch();
}
uint8_t PlatformGetIdleAction()
{
int key;
if(!_kbhit()) return AARUREMOTE_IDLE_ACTION_NONE;
key = _getch();
if(key == 'd' || key == 'D') return AARUREMOTE_IDLE_ACTION_LIST_DEVICES;
return AARUREMOTE_IDLE_ACTION_NONE;
}
uint8_t AmIRoot()
{
@@ -34,8 +53,8 @@ uint8_t AmIRoot()
SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
PSID AdministratorsGroup;
b = AllocateAndInitializeSid(
&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdministratorsGroup);
b = AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0,
0, &AdministratorsGroup);
if(b)
{

322
worker.c
View File

@@ -22,8 +22,8 @@
#ifdef _WIN32
#define ssize_t int
#include <winsock2.h>
#include <windows.h>
#include <winsock2.h>
#include "win32/win32.h"
#else
@@ -33,62 +33,62 @@
#include "aaruremote.h"
#include "endian.h"
void* WorkingLoop(void* arguments)
void *WorkingLoop(void *arguments)
{
AtaErrorRegistersChs ata_chs_error_regs;
AtaErrorRegistersLba28 ata_lba28_error_regs;
AtaErrorRegistersLba48 ata_lba48_error_regs;
char* buffer;
char* cdb_buf;
char* cid;
char* csd;
char* in_buf;
char* ocr;
char* out_buf;
char* scr;
char* sense_buf;
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;
AaruPacketMultiCmdSdhci* pkt_cmd_multi_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;
AaruPacketMultiResSdhci* pkt_res_multi_sdhci;
AaruPacketCmdOsRead* pkt_cmd_osread;
AaruPacketResOsRead* pkt_res_osread;
char *buffer;
char *cdb_buf;
char *cid;
char *csd;
char *in_buf;
char *ocr;
char *out_buf;
char *scr;
char *sense_buf;
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;
AaruPacketMultiCmdSdhci *pkt_cmd_multi_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;
AaruPacketMultiResSdhci *pkt_res_multi_sdhci;
AaruPacketCmdOsRead *pkt_cmd_osread;
AaruPacketResOsRead *pkt_res_osread;
int skip_next_hdr;
int ret;
socklen_t cli_len;
ssize_t recv_size;
struct DeviceInfoList* device_info_list;
struct DeviceInfoList *device_info_list;
struct sockaddr_in cli_addr, serv_addr;
uint32_t duration;
uint32_t sdhci_response[4];
uint32_t sense;
uint32_t sense_len;
uint32_t n;
void* device_ctx = NULL;
void* net_ctx = NULL;
void* cli_ctx = NULL;
void *device_ctx = NULL;
void *net_ctx = NULL;
void *cli_ctx = NULL;
long off;
MmcSingleCommand* multi_sdhci_commands;
MmcSingleCommand *multi_sdhci_commands;
if(!arguments)
{
@@ -96,7 +96,7 @@ void* WorkingLoop(void* arguments)
return NULL;
}
pkt_server_hello = (AaruPacketHello*)arguments;
pkt_server_hello = (AaruPacketHello *)arguments;
printf("Opening socket.\n");
net_ctx = NetSocket(AF_INET, SOCK_STREAM, 0);
@@ -110,7 +110,7 @@ void* WorkingLoop(void* arguments)
serv_addr.sin_addr.s_addr = INADDR_ANY;
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)
{
printf("Error %d binding socket.\n", errno);
NetClose(net_ctx);
@@ -145,11 +145,46 @@ void* WorkingLoop(void* arguments)
for(;;)
{
PlatformResetIdleInput();
printf("\n");
printf("Waiting for a client...\n");
for(;;)
{
switch(PlatformGetIdleAction())
{
case AARUREMOTE_IDLE_ACTION_LIST_DEVICES:
PrintDeviceList();
printf("\n");
printf("Waiting for a client...\n");
break;
case AARUREMOTE_IDLE_ACTION_EXIT:
free(pkt_nop);
NetClose(net_ctx);
return NULL;
default:
break;
}
ret = NetPoll(net_ctx, 100);
#ifndef _WIN32
if(ret < 0 && errno == EINTR) continue;
#endif
if(ret < 0)
{
printf("Error %d waiting for incoming connection.\n", errno);
free(pkt_nop);
NetClose(net_ctx);
return NULL;
}
if(ret > 0) break;
}
cli_len = sizeof(cli_addr);
cli_ctx = NetAccept(net_ctx, (struct sockaddr*)&cli_addr, &cli_len);
cli_ctx = NetAccept(net_ctx, (struct sockaddr *)&cli_addr, &cli_len);
if(!cli_ctx)
{
@@ -239,9 +274,7 @@ void* WorkingLoop(void* arguments)
}
printf("Client application: %s %s\n", pkt_client_hello->application, pkt_client_hello->version);
printf("Client operating system: %s %s (%s)\n",
pkt_client_hello->sysname,
pkt_client_hello->release,
printf("Client operating system: %s %s (%s)\n", pkt_client_hello->sysname, pkt_client_hello->release,
pkt_client_hello->machine);
printf("Client maximum protocol: %d\n", pkt_client_hello->max_protocol);
@@ -344,10 +377,10 @@ void* WorkingLoop(void* arguments)
n = sizeof(AaruPacketResListDevs) + le16toh(pkt_res_devinfo->devices) * sizeof(DeviceInfo);
in_buf = malloc(n);
((AaruPacketResListDevs*)in_buf)->hdr.len = htole32(n);
((AaruPacketResListDevs*)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 = (AaruPacketResListDevs*)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);
@@ -355,17 +388,17 @@ void* WorkingLoop(void* arguments)
pkt_res_devinfo->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES;
// Save list start
in_buf = (char*)device_info_list;
in_buf = (char *)device_info_list;
off = sizeof(AaruPacketResListDevs);
while(device_info_list)
{
memcpy(((char*)pkt_res_devinfo) + off, &device_info_list->this, sizeof(DeviceInfo));
memcpy(((char *)pkt_res_devinfo) + off, &device_info_list->this, sizeof(DeviceInfo));
device_info_list = device_info_list->next;
off += sizeof(DeviceInfo);
}
device_info_list = (struct DeviceInfoList*)in_buf;
device_info_list = (struct DeviceInfoList *)in_buf;
FreeDeviceInfoList(device_info_list);
NetWrite(cli_ctx, pkt_res_devinfo, le32toh(pkt_res_devinfo->hdr.len));
@@ -463,7 +496,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_scsi = (AaruPacketCmdScsi*)in_buf;
pkt_cmd_scsi = (AaruPacketCmdScsi *)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header
@@ -478,8 +511,7 @@ void* WorkingLoop(void* arguments)
if(le32toh(pkt_cmd_scsi->buf_len) > 0)
{
buffer = malloc(le32toh(pkt_cmd_scsi->buf_len));
memcpy(buffer,
in_buf + le32toh(pkt_cmd_scsi->cdb_len) + sizeof(AaruPacketCmdScsi),
memcpy(buffer, in_buf + le32toh(pkt_cmd_scsi->cdb_len) + sizeof(AaruPacketCmdScsi),
le32toh(pkt_cmd_scsi->buf_len));
}
else
@@ -488,17 +520,9 @@ void* WorkingLoop(void* arguments)
// Swap buf_len
pkt_cmd_scsi->buf_len = le32toh(pkt_cmd_scsi->buf_len);
ret = SendScsiCommand(device_ctx,
cdb_buf,
buffer,
&sense_buf,
le32toh(pkt_cmd_scsi->timeout),
le32toh(pkt_cmd_scsi->direction),
&duration,
&sense,
le32toh(pkt_cmd_scsi->cdb_len),
&pkt_cmd_scsi->buf_len,
&sense_len);
ret = SendScsiCommand(device_ctx, cdb_buf, buffer, &sense_buf, le32toh(pkt_cmd_scsi->timeout),
le32toh(pkt_cmd_scsi->direction), &duration, &sense,
le32toh(pkt_cmd_scsi->cdb_len), &pkt_cmd_scsi->buf_len, &sense_len);
// Swap buf_len back
pkt_cmd_scsi->buf_len = htole32(pkt_cmd_scsi->buf_len);
@@ -514,7 +538,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_scsi = (AaruPacketResScsi*)out_buf;
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, le32toh(pkt_cmd_scsi->buf_len));
@@ -569,15 +593,10 @@ void* WorkingLoop(void* arguments)
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(AaruPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_ctx,
&csd,
&cid,
&ocr,
&scr,
&pkt_res_sdhci_registers->csd_len,
&pkt_res_sdhci_registers->cid_len,
&pkt_res_sdhci_registers->ocr_len,
&pkt_res_sdhci_registers->scr_len);
pkt_res_sdhci_registers->is_sdhci =
GetSdhciRegisters(device_ctx, &csd, &cid, &ocr, &scr, &pkt_res_sdhci_registers->csd_len,
&pkt_res_sdhci_registers->cid_len, &pkt_res_sdhci_registers->ocr_len,
&pkt_res_sdhci_registers->scr_len);
if(pkt_res_sdhci_registers->csd_len > 0 && csd != NULL)
{
@@ -648,14 +667,9 @@ void* WorkingLoop(void* arguments)
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(AaruPacketResGetUsbData));
pkt_res_usb->is_usb = GetUsbData(device_ctx,
&pkt_res_usb->desc_len,
pkt_res_usb->descriptors,
&pkt_res_usb->id_vendor,
&pkt_res_usb->id_product,
pkt_res_usb->manufacturer,
pkt_res_usb->product,
pkt_res_usb->serial);
pkt_res_usb->is_usb = GetUsbData(
device_ctx, &pkt_res_usb->desc_len, pkt_res_usb->descriptors, &pkt_res_usb->id_vendor,
&pkt_res_usb->id_product, pkt_res_usb->manufacturer, pkt_res_usb->product, pkt_res_usb->serial);
// Swap parameters
pkt_res_usb->desc_len = htole32(pkt_res_usb->desc_len);
@@ -694,12 +708,9 @@ void* WorkingLoop(void* arguments)
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(AaruPacketResGetFireWireData));
pkt_res_firewire->is_firewire = GetFireWireData(device_ctx,
&pkt_res_firewire->id_model,
&pkt_res_firewire->id_vendor,
&pkt_res_firewire->guid,
pkt_res_firewire->vendor,
pkt_res_firewire->model);
pkt_res_firewire->is_firewire =
GetFireWireData(device_ctx, &pkt_res_firewire->id_model, &pkt_res_firewire->id_vendor,
&pkt_res_firewire->guid, pkt_res_firewire->vendor, pkt_res_firewire->model);
// TODO: Need to swap IDs?
@@ -758,11 +769,12 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_chs = (AaruPacketCmdAtaChs*)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(AaruPacketCmdAtaChs);
if(le32toh(pkt_cmd_ata_chs->buf_len) > 0)
buffer = in_buf + sizeof(AaruPacketCmdAtaChs);
else
buffer = NULL;
@@ -772,17 +784,10 @@ void* WorkingLoop(void* arguments)
duration = 0;
sense = 1;
ret = SendAtaChsCommand(device_ctx,
pkt_cmd_ata_chs->registers,
&ata_chs_error_regs,
pkt_cmd_ata_chs->protocol,
pkt_cmd_ata_chs->transfer_register,
buffer,
le32toh(pkt_cmd_ata_chs->timeout),
pkt_cmd_ata_chs->transfer_blocks,
&duration,
&sense,
&pkt_cmd_ata_chs->buf_len);
ret = SendAtaChsCommand(device_ctx, pkt_cmd_ata_chs->registers, &ata_chs_error_regs,
pkt_cmd_ata_chs->protocol, pkt_cmd_ata_chs->transfer_register, buffer,
le32toh(pkt_cmd_ata_chs->timeout), pkt_cmd_ata_chs->transfer_blocks,
&duration, &sense, &pkt_cmd_ata_chs->buf_len);
out_buf = malloc(sizeof(AaruPacketResAtaChs) + pkt_cmd_ata_chs->buf_len);
@@ -797,7 +802,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_chs = (AaruPacketResAtaChs*)out_buf;
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(AaruPacketResAtaChs) + htole32(pkt_cmd_ata_chs->buf_len));
@@ -830,11 +835,12 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba28 = (AaruPacketCmdAtaLba28*)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(AaruPacketCmdAtaLba28);
if(le32toh(pkt_cmd_ata_lba28->buf_len) > 0)
buffer = in_buf + sizeof(AaruPacketCmdAtaLba28);
else
buffer = NULL;
@@ -844,17 +850,10 @@ void* WorkingLoop(void* arguments)
duration = 0;
sense = 1;
ret = SendAtaLba28Command(device_ctx,
pkt_cmd_ata_lba28->registers,
&ata_lba28_error_regs,
pkt_cmd_ata_lba28->protocol,
pkt_cmd_ata_lba28->transfer_register,
buffer,
le32toh(pkt_cmd_ata_lba28->timeout),
pkt_cmd_ata_lba28->transfer_blocks,
&duration,
&sense,
&pkt_cmd_ata_lba28->buf_len);
ret = SendAtaLba28Command(device_ctx, pkt_cmd_ata_lba28->registers, &ata_lba28_error_regs,
pkt_cmd_ata_lba28->protocol, pkt_cmd_ata_lba28->transfer_register, buffer,
le32toh(pkt_cmd_ata_lba28->timeout), pkt_cmd_ata_lba28->transfer_blocks,
&duration, &sense, &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);
@@ -868,7 +867,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_lba28 = (AaruPacketResAtaLba28*)out_buf;
pkt_res_ata_lba28 = (AaruPacketResAtaLba28 *)out_buf;
if(buffer)
memcpy(out_buf + sizeof(AaruPacketResAtaLba28), buffer, le32toh(pkt_cmd_ata_lba28->buf_len));
@@ -903,11 +902,12 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba48 = (AaruPacketCmdAtaLba48*)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(AaruPacketCmdAtaLba48);
if(le32toh(pkt_cmd_ata_lba48->buf_len) > 0)
buffer = in_buf + sizeof(AaruPacketCmdAtaLba48);
else
buffer = NULL;
@@ -919,17 +919,10 @@ void* WorkingLoop(void* arguments)
duration = 0;
sense = 1;
ret = SendAtaLba48Command(device_ctx,
pkt_cmd_ata_lba48->registers,
&ata_lba48_error_regs,
pkt_cmd_ata_lba48->protocol,
pkt_cmd_ata_lba48->transfer_register,
buffer,
le32toh(pkt_cmd_ata_lba48->timeout),
pkt_cmd_ata_lba48->transfer_blocks,
&duration,
&sense,
&pkt_cmd_ata_lba48->buf_len);
ret = SendAtaLba48Command(device_ctx, pkt_cmd_ata_lba48->registers, &ata_lba48_error_regs,
pkt_cmd_ata_lba48->protocol, pkt_cmd_ata_lba48->transfer_register, buffer,
le32toh(pkt_cmd_ata_lba48->timeout), pkt_cmd_ata_lba48->transfer_blocks,
&duration, &sense, &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);
@@ -943,7 +936,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_ata_lba48 = (AaruPacketResAtaLba48*)out_buf;
pkt_res_ata_lba48 = (AaruPacketResAtaLba48 *)out_buf;
if(buffer)
memcpy(out_buf + sizeof(AaruPacketResAtaLba48), buffer, le32toh(pkt_cmd_ata_lba48->buf_len));
@@ -981,32 +974,25 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_sdhci = (AaruPacketCmdSdhci*)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->command.buf_len) > 0) buffer = in_buf + sizeof(AaruPacketCmdSdhci);
if(le32toh(pkt_cmd_sdhci->command.buf_len) > 0)
buffer = in_buf + sizeof(AaruPacketCmdSdhci);
else
buffer = NULL;
memset((char*)&sdhci_response, 0, sizeof(uint32_t) * 4);
memset((char *)&sdhci_response, 0, sizeof(uint32_t) * 4);
duration = 0;
sense = 1;
ret = SendSdhciCommand(device_ctx,
pkt_cmd_sdhci->command.command,
pkt_cmd_sdhci->command.write,
pkt_cmd_sdhci->command.application,
le32toh(pkt_cmd_sdhci->command.flags),
le32toh(pkt_cmd_sdhci->command.argument),
le32toh(pkt_cmd_sdhci->command.block_size),
le32toh(pkt_cmd_sdhci->command.blocks),
buffer,
le32toh(pkt_cmd_sdhci->command.buf_len),
le32toh(pkt_cmd_sdhci->command.timeout),
(uint32_t*)&sdhci_response,
&duration,
&sense);
ret = SendSdhciCommand(
device_ctx, pkt_cmd_sdhci->command.command, pkt_cmd_sdhci->command.write,
pkt_cmd_sdhci->command.application, le32toh(pkt_cmd_sdhci->command.flags),
le32toh(pkt_cmd_sdhci->command.argument), le32toh(pkt_cmd_sdhci->command.block_size),
le32toh(pkt_cmd_sdhci->command.blocks), buffer, le32toh(pkt_cmd_sdhci->command.buf_len),
le32toh(pkt_cmd_sdhci->command.timeout), (uint32_t *)&sdhci_response, &duration, &sense);
out_buf = malloc(sizeof(AaruPacketResSdhci) + le32toh(pkt_cmd_sdhci->command.buf_len));
@@ -1019,7 +1005,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_sdhci = (AaruPacketResSdhci*)out_buf;
pkt_res_sdhci = (AaruPacketResSdhci *)out_buf;
if(buffer)
memcpy(out_buf + sizeof(AaruPacketResSdhci), buffer, le32toh(pkt_cmd_sdhci->command.buf_len));
@@ -1035,7 +1021,7 @@ void* WorkingLoop(void* arguments)
sdhci_response[2] = htole32(sdhci_response[2]);
sdhci_response[3] = htole32(sdhci_response[3]);
memcpy((char*)&pkt_res_sdhci->res.response, (char*)&sdhci_response, sizeof(uint32_t) * 4);
memcpy((char *)&pkt_res_sdhci->res.response, (char *)&sdhci_response, sizeof(uint32_t) * 4);
pkt_res_sdhci->res.buf_len = pkt_cmd_sdhci->command.buf_len;
pkt_res_sdhci->res.duration = htole32(duration);
pkt_res_sdhci->res.sense = htole32(sense);
@@ -1098,7 +1084,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_multi_sdhci = (AaruPacketMultiCmdSdhci*)in_buf;
pkt_cmd_multi_sdhci = (AaruPacketMultiCmdSdhci *)in_buf;
pkt_cmd_multi_sdhci->cmd_count = le64toh(pkt_cmd_multi_sdhci->cmd_count);
@@ -1133,12 +1119,12 @@ void* WorkingLoop(void* arguments)
for(n = 0; n < pkt_cmd_multi_sdhci->cmd_count; n++)
{
multi_sdhci_commands[n].buffer = (char*)pkt_cmd_multi_sdhci + off;
multi_sdhci_commands[n].buffer = (char *)pkt_cmd_multi_sdhci + off;
off += multi_sdhci_commands[n].buf_len;
}
ret = SendMultiSdhciCommand(
device_ctx, pkt_cmd_multi_sdhci->cmd_count, multi_sdhci_commands, &duration, &sense);
ret = SendMultiSdhciCommand(device_ctx, pkt_cmd_multi_sdhci->cmd_count, multi_sdhci_commands,
&duration, &sense);
off =
(long)(sizeof(AaruPacketMultiResSdhci) + sizeof(AaruResSdhci) * pkt_cmd_multi_sdhci->cmd_count);
@@ -1157,7 +1143,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_multi_sdhci = (AaruPacketMultiResSdhci*)out_buf;
pkt_res_multi_sdhci = (AaruPacketMultiResSdhci *)out_buf;
pkt_res_multi_sdhci->hdr.len = htole32(off);
pkt_res_multi_sdhci->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_MULTI_SDHCI;
@@ -1214,7 +1200,8 @@ void* WorkingLoop(void* arguments)
pkt_nop->error_no = htole32(ret);
// Error on close
if(sense != 0) pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_CLOSE_ERROR;
if(sense != 0)
pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_CLOSE_ERROR;
else
pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_OPEN_ERROR;
}
@@ -1242,7 +1229,7 @@ void* WorkingLoop(void* arguments)
NetRecv(cli_ctx, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_osread = (AaruPacketCmdOsRead*)in_buf;
pkt_cmd_osread = (AaruPacketCmdOsRead *)in_buf;
buffer = malloc(le32toh(pkt_cmd_osread->length));
@@ -1257,10 +1244,7 @@ void* WorkingLoop(void* arguments)
memset(buffer, 0, le32toh(pkt_cmd_osread->length));
ret = OsRead(device_ctx,
buffer,
le64toh(pkt_cmd_osread->offset),
le32toh(pkt_cmd_osread->length),
ret = OsRead(device_ctx, buffer, le64toh(pkt_cmd_osread->offset), le32toh(pkt_cmd_osread->length),
&duration);
out_buf = malloc(sizeof(AaruPacketResOsRead) + le32toh(pkt_cmd_osread->length));
@@ -1275,7 +1259,7 @@ void* WorkingLoop(void* arguments)
continue;
}
pkt_res_osread = (AaruPacketResOsRead*)out_buf;
pkt_res_osread = (AaruPacketResOsRead *)out_buf;
pkt_res_osread->hdr.len = htole32(sizeof(AaruPacketResOsRead) + le32toh(pkt_cmd_osread->length));
pkt_res_osread->hdr.packet_type = AARUREMOTE_PACKET_TYPE_RESPONSE_OSREAD;
@@ -1297,14 +1281,10 @@ void* WorkingLoop(void* arguments)
pkt_nop->reason_code = AARUREMOTE_PACKET_NOP_REASON_NOT_RECOGNIZED;
memset(&pkt_nop->reason, 0, 256);
#ifdef _WIN32
sprintf_s(pkt_nop->reason,
256,
"Received unrecognized packet with type %d, skipping...",
sprintf_s(pkt_nop->reason, 256, "Received unrecognized packet with type %d, skipping...",
pkt_hdr->packet_type);
#else
snprintf(pkt_nop->reason,
256,
"Received unrecognized packet with type %d, skipping...",
snprintf(pkt_nop->reason, 256, "Received unrecognized packet with type %d, skipping...",
pkt_hdr->packet_type);
#endif
NetWrite(cli_ctx, pkt_nop, sizeof(AaruPacketNop));