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

Support big endian architectures.

Browse Source
This commit is contained in:
Natalia Portillo
2019-10-22 00:44:39 +01:00
parent 50f911acdc
commit c6f177cc48
6 changed files with 299 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
CMakeLists.txt
View File

@@ -2,20 +2,43 @@ cmake_minimum_required(VERSION 3.0)
project(dicremote C) project(dicremote C)
include(CheckIncludeFiles) include(CheckIncludeFiles)
include(CheckLibraryExists) include(CheckLibraryExists)
include(TestBigEndian)
set(CMAKE_C_STANDARD 90) set(CMAKE_C_STANDARD 90)
set(MAIN_SOURCES main.c list_devices.c device.c scsi.c hex2bin.c usb.c ieee1394.c pcmcia.c ata.c sdhci.c worker.c) set(MAIN_SOURCES main.c list_devices.c device.c scsi.c hex2bin.c usb.c ieee1394.c pcmcia.c ata.c sdhci.c worker.c endian.h)
add_library(dicremote ${MAIN_SOURCES}) add_library(dicremote ${MAIN_SOURCES})
CHECK_INCLUDE_FILES("endian.h" HAVE_ENDIAN_H)
CHECK_INCLUDE_FILES("sys/endian.h" HAVE_SYS_ENDIAN_H)
if (HAVE_ENDIAN_H)
add_definitions(-DHAVE_ENDIAN_H)
endif ()
if (HAVE_SYS_ENDIAN_H)
add_definitions(-DHAVE_SYS_ENDIAN_H)
endif ()
if (WII) if (WII)
set(CMAKE_C_FLAGS "-mrvl -mcpu=750 -meabi -mhard-float") set(CMAKE_C_FLAGS "-mrvl -mcpu=750 -meabi -mhard-float")
add_definitions(-DGEKKO=1) add_definitions(-DGEKKO=1)
include_directories($ENV{DEVKITPRO}/libogc/include/) include_directories($ENV{DEVKITPRO}/libogc/include/)
add_definitions(-D__BYTE_ORDER=4321)
else ()
if (NOT HAVE_ENDIAN_H AND NOT HAVE_SYS_ENDIAN_H)
TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
if (IS_BIG_ENDIAN)
add_definitions(-D__BYTE_ORDER=4321)
else ()
add_definitions(-D__BYTE_ORDER=1234)
endif ()
endif ()
endif () endif ()
set(DIC_PORTS "linux;wii" CACHE STRING "List of ports to build") set(DIC_PORTS "linux;wii" CACHE STRING "List of ports to build")
foreach (PORT IN LISTS DIC_PORTS) foreach (PORT IN LISTS DIC_PORTS)
add_subdirectory(${PORT}) add_subdirectory(${PORT})
endforeach (PORT) endforeach (PORT)

1
README.md
View File

@@ -28,7 +28,6 @@ TODO
- More buffer overflow guards - More buffer overflow guards
- Support FreeBSD - Support FreeBSD
- Support Windows (Windows XP at the lowest level) - Support Windows (Windows XP at the lowest level)
- Support big-endian architectures
- Support PSP - Support PSP
- Support Wii - Support Wii
- Support Wii U - Support Wii U

103
endian.h Normal file
View File

@@ -0,0 +1,103 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
* Copyright (C) Natalia Portillo
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#ifndef DICREMOTE__ENDIAN_H_
#define DICREMOTE__ENDIAN_H_
#if HAVE_ENDIAN_H
#include <endian.h>
#elif HAVE_SYS_ENDIAN_H
#include <sys/endian.h>
#else
#define __LITTLE_ENDIAN 1234
#define __BIG_ENDIAN 4321
#ifndef __BYTE_ORDER
#define __BYTE_ORDER __LITTLE_ENDIAN
#endif
#ifndef bswap_16
#define bswap_16(x) ((uint16_t)((((uint16_t)(x)&0xff00) >> 8) | (((uint16_t)(x)&0x00ff) << 8)))
#endif /* !bswap_16 */
#ifndef bswap_32
#define bswap_32(x) \
((uint32_t)((((uint32_t)(x)&0xff000000) >> 24) | (((uint32_t)(x)&0x00ff0000) >> 8) | \
(((uint32_t)(x)&0x0000ff00) << 8) | (((uint32_t)(x)&0x000000ff) << 24)))
#endif /* !bswap_32 */
#ifndef bswap_64
#define bswap_64(x) \
((uint64_t)((((uint64_t)(x)&0xff00000000000000ULL) >> 56) | (((uint64_t)(x)&0x00ff000000000000ULL) >> 40) | \
(((uint64_t)(x)&0x0000ff0000000000ULL) >> 24) | (((uint64_t)(x)&0x000000ff00000000ULL) >> 8) | \
(((uint64_t)(x)&0x00000000ff000000ULL) << 8) | (((uint64_t)(x)&0x0000000000ff0000ULL) << 24) | \
(((uint64_t)(x)&0x000000000000ff00ULL) << 40) | (((uint64_t)(x)&0x00000000000000ffULL) << 56)))
#endif /* !bswap_64 */
#ifndef htobe16
#if __BYTE_ORDER == __BIG_ENDIAN
#define htobe16(x) (x)
#define htole16(x) bswap_16(x)
#define be16toh(x) (x)
#define le16toh(x) bswap_16(x)
#else /* __BYTE_ORDER == __BIG_ENDIAN */
#define htobe16(x) bswap_16(x)
#define htole16(x) (x)
#define be16toh(x) bswap_16(x)
#define le16toh(x) (x)
#endif /* __BYTE_ORDER == __BIG_ENDIAN */
#endif /* !htobe16 */
#ifndef htobe32
#if __BYTE_ORDER == __BIG_ENDIAN
#define htobe32(x) (x)
#define htole32(x) bswap_32(x)
#define be32toh(x) (x)
#define le32toh(x) bswap_32(x)
#else /* __BYTE_ORDER == __BIG_ENDIAN */
#define htobe32(x) bswap_32(x)
#define htole32(x) (x)
#define be32toh(x) bswap_32(x)
#define le32toh(x) (x)
#endif /* __BYTE_ORDER == __BIG_ENDIAN */
#endif /* !htobe32 */
#ifndef htobe64
#if __BYTE_ORDER == __BIG_ENDIAN
#define htobe64(x) (x)
#define htole64(x) bswap_64(x)
#define be64toh(x) (x)
#define le64toh(x) bswap_64(x)
#else /* __BYTE_ORDER == __BIG_ENDIAN */
#define htobe64(x) bswap_64(x)
#define htole64(x) (x)
#define be64toh(x) bswap_64(x)
#define le64toh(x) (x)
#endif /* __BYTE_ORDER == __BIG_ENDIAN */
#endif /* !htobe64 */
#endif
#endif // DICREMOTE__ENDIAN_H_

4
unix/hello.c
View File

@@ -37,8 +37,8 @@ DicPacketHello* GetHello()
memset(pkt_server_hello, 0, sizeof(DicPacketHello)); memset(pkt_server_hello, 0, sizeof(DicPacketHello));
pkt_server_hello->hdr.id = DICMOTE_PACKET_ID; pkt_server_hello->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_server_hello->hdr.len = sizeof(DicPacketHello); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello));
pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION;
pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO;
strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME));

9
wii/hello.c
View File

@@ -16,11 +16,12 @@
*/ */
#include "../dicmote.h" #include "../dicmote.h"
#include "../endian.h"
#include <malloc.h>
#include <gccore.h> #include <gccore.h>
#include <string.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
#include <string.h>
DicPacketHello* GetHello() DicPacketHello* GetHello()
{ {
@@ -32,8 +33,8 @@ DicPacketHello* GetHello()
memset(pkt_server_hello, 0, sizeof(DicPacketHello)); memset(pkt_server_hello, 0, sizeof(DicPacketHello));
pkt_server_hello->hdr.id = DICMOTE_PACKET_ID; pkt_server_hello->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_server_hello->hdr.len = sizeof(DicPacketHello); pkt_server_hello->hdr.len = htole32(sizeof(DicPacketHello));
pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION; pkt_server_hello->hdr.version = DICMOTE_PACKET_VERSION;
pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO; pkt_server_hello->hdr.packet_type = DICMOTE_PACKET_TYPE_HELLO;
strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME)); strncpy(pkt_server_hello->application, DICMOTE_NAME, sizeof(DICMOTE_NAME));

270
worker.c
View File

@@ -17,6 +17,7 @@
#include "dicmote.h" #include "dicmote.h"
#include <endian.h>
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -119,8 +120,8 @@ void* WorkingLoop(void* arguments)
memset(pkt_nop, 0, sizeof(DicPacketNop)); memset(pkt_nop, 0, sizeof(DicPacketNop));
pkt_nop->hdr.id = DICMOTE_PACKET_ID; pkt_nop->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_nop->hdr.len = sizeof(DicPacketNop); pkt_nop->hdr.len = htole32(sizeof(DicPacketNop));
pkt_nop->hdr.version = DICMOTE_PACKET_VERSION; pkt_nop->hdr.version = DICMOTE_PACKET_VERSION;
pkt_nop->hdr.packet_type = DICMOTE_PACKET_TYPE_NOP; pkt_nop->hdr.packet_type = DICMOTE_PACKET_TYPE_NOP;
@@ -172,7 +173,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
if(pkt_hdr->id != DICMOTE_PACKET_ID) if(pkt_hdr->id != htole64(DICMOTE_PACKET_ID))
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
free(pkt_hdr); free(pkt_hdr);
@@ -196,7 +197,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
pkt_client_hello = malloc(pkt_hdr->len); pkt_client_hello = malloc(le32toh(pkt_hdr->len));
if(!pkt_client_hello) if(!pkt_client_hello)
{ {
@@ -206,11 +207,11 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
recv_size = NetRecv(cli_sock, pkt_client_hello, pkt_hdr->len, 0); recv_size = NetRecv(cli_sock, pkt_client_hello, le32toh(pkt_hdr->len), 0);
if(recv_size != pkt_hdr->len) if(recv_size != le32toh(pkt_hdr->len))
{ {
printf("Expected %d bytes of packet, got %ld, closing connection...\n", pkt_hdr->len, recv_size); printf("Expected %d bytes of packet, got %ld, closing connection...\n", le32toh(pkt_hdr->len), recv_size);
NetClose(cli_sock); NetClose(cli_sock);
free(pkt_hdr); free(pkt_hdr);
free(pkt_client_hello); free(pkt_client_hello);
@@ -232,7 +233,7 @@ void* WorkingLoop(void* arguments)
{ {
if(skip_next_hdr) if(skip_next_hdr)
{ {
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -242,7 +243,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
skip_next_hdr = 0; skip_next_hdr = 0;
} }
@@ -265,7 +266,7 @@ void* WorkingLoop(void* arguments)
break; break;
} }
if(pkt_hdr->id != DICMOTE_PACKET_ID) if(pkt_hdr->id != htole64(DICMOTE_PACKET_ID))
{ {
printf("Received data is not a correct dicremote packet, closing connection...\n"); printf("Received data is not a correct dicremote packet, closing connection...\n");
NetClose(cli_sock); NetClose(cli_sock);
@@ -294,7 +295,7 @@ void* WorkingLoop(void* arguments)
device_info_list = ListDevices(); device_info_list = ListDevices();
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -304,7 +305,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
if(!device_info_list) if(!device_info_list)
@@ -318,16 +319,16 @@ void* WorkingLoop(void* arguments)
} }
pkt_res_devinfo = malloc(sizeof(DicPacketResListDevs)); pkt_res_devinfo = malloc(sizeof(DicPacketResListDevs));
pkt_res_devinfo->devices = DeviceInfoListCount(device_info_list); pkt_res_devinfo->devices = htole16(DeviceInfoListCount(device_info_list));
n = sizeof(DicPacketResListDevs) + pkt_res_devinfo->devices * sizeof(DeviceInfo); n = sizeof(DicPacketResListDevs) + le16toh(pkt_res_devinfo->devices) * sizeof(DeviceInfo);
in_buf = malloc(n); in_buf = malloc(n);
((DicPacketResListDevs*)in_buf)->hdr.len = n; ((DicPacketResListDevs*)in_buf)->hdr.len = htole32(n);
((DicPacketResListDevs*)in_buf)->devices = pkt_res_devinfo->devices; ((DicPacketResListDevs*)in_buf)->devices = pkt_res_devinfo->devices;
free(pkt_res_devinfo); free(pkt_res_devinfo);
pkt_res_devinfo = (DicPacketResListDevs*)in_buf; pkt_res_devinfo = (DicPacketResListDevs*)in_buf;
pkt_res_devinfo->hdr.id = DICMOTE_PACKET_ID; pkt_res_devinfo->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_devinfo->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_devinfo->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_devinfo->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES; pkt_res_devinfo->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES;
@@ -345,7 +346,7 @@ void* WorkingLoop(void* arguments)
device_info_list = (struct DeviceInfoList*)in_buf; device_info_list = (struct DeviceInfoList*)in_buf;
FreeDeviceInfoList(device_info_list); FreeDeviceInfoList(device_info_list);
NetWrite(cli_sock, pkt_res_devinfo, pkt_res_devinfo->hdr.len); NetWrite(cli_sock, pkt_res_devinfo, le32toh(pkt_res_devinfo->hdr.len));
free(pkt_res_devinfo); free(pkt_res_devinfo);
continue; continue;
case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS:
@@ -367,7 +368,7 @@ void* WorkingLoop(void* arguments)
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE: case DICMOTE_PACKET_TYPE_COMMAND_OPEN_DEVICE:
pkt_dev_open = malloc(pkt_hdr->len); pkt_dev_open = malloc(le32toh(pkt_hdr->len));
if(!pkt_dev_open) if(!pkt_dev_open)
{ {
@@ -377,7 +378,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, pkt_dev_open, pkt_hdr->len, 0); NetRecv(cli_sock, pkt_dev_open, le32toh(pkt_hdr->len), 0);
device_fd = DeviceOpen(pkt_dev_open->device_path); device_fd = DeviceOpen(pkt_dev_open->device_path);
@@ -394,7 +395,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE: case DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -404,7 +405,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
pkt_dev_type = malloc(sizeof(DicPacketResGetDeviceType)); pkt_dev_type = malloc(sizeof(DicPacketResGetDeviceType));
@@ -419,18 +420,18 @@ void* WorkingLoop(void* arguments)
memset(pkt_dev_type, 0, sizeof(DicPacketResGetDeviceType)); memset(pkt_dev_type, 0, sizeof(DicPacketResGetDeviceType));
pkt_dev_type->hdr.len = sizeof(DicPacketResGetDeviceType); pkt_dev_type->hdr.len = htole32(sizeof(DicPacketResGetDeviceType));
pkt_dev_type->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE; pkt_dev_type->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE;
pkt_dev_type->hdr.version = DICMOTE_PACKET_VERSION; pkt_dev_type->hdr.version = DICMOTE_PACKET_VERSION;
pkt_dev_type->hdr.id = DICMOTE_PACKET_ID; pkt_dev_type->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_dev_type->device_type = GetDeviceType(device_path); pkt_dev_type->device_type = htole32(GetDeviceType(device_path));
NetWrite(cli_sock, pkt_dev_type, sizeof(DicPacketResGetDeviceType)); NetWrite(cli_sock, pkt_dev_type, sizeof(DicPacketResGetDeviceType));
free(pkt_dev_type); free(pkt_dev_type);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_SCSI: case DICMOTE_PACKET_TYPE_COMMAND_SCSI:
// Packet contains data after // Packet contains data after
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -440,33 +441,40 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_scsi = (DicPacketCmdScsi*)in_buf; pkt_cmd_scsi = (DicPacketCmdScsi*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header // TODO: Check size of buffers + size of packet is not bigger than size in header
if(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(DicPacketCmdScsi);
else else
cdb_buf = NULL; cdb_buf = NULL;
if(pkt_cmd_scsi->buf_len > 0) buffer = in_buf + pkt_cmd_scsi->cdb_len + sizeof(DicPacketCmdScsi); if(le32toh(pkt_cmd_scsi->buf_len) > 0)
buffer = in_buf + le32toh(pkt_cmd_scsi->cdb_len) + sizeof(DicPacketCmdScsi);
else else
buffer = NULL; buffer = NULL;
// Swap buf_len
pkt_cmd_scsi->buf_len = le32toh(pkt_cmd_scsi->buf_len);
ret = SendScsiCommand(device_fd, ret = SendScsiCommand(device_fd,
cdb_buf, cdb_buf,
buffer, buffer,
&sense_buf, &sense_buf,
pkt_cmd_scsi->timeout, le32toh(pkt_cmd_scsi->timeout),
pkt_cmd_scsi->direction, le32toh(pkt_cmd_scsi->direction),
&duration, &duration,
&sense, &sense,
pkt_cmd_scsi->cdb_len, le32toh(pkt_cmd_scsi->cdb_len),
&pkt_cmd_scsi->buf_len, &pkt_cmd_scsi->buf_len,
&sense_len); &sense_len);
out_buf = malloc(sizeof(DicPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len); // 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));
if(!out_buf) if(!out_buf)
{ {
@@ -481,25 +489,25 @@ void* WorkingLoop(void* arguments)
if(sense_buf) memcpy(out_buf + sizeof(DicPacketResScsi), sense_buf, sense_len); 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); if(buffer) memcpy(out_buf + sizeof(DicPacketResScsi) + sense_len, buffer, pkt_cmd_scsi->buf_len);
pkt_res_scsi->hdr.len = sizeof(DicPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len; pkt_res_scsi->hdr.len = htole32(sizeof(DicPacketResScsi) + sense_len + pkt_cmd_scsi->buf_len);
pkt_res_scsi->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SCSI; pkt_res_scsi->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SCSI;
pkt_res_scsi->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_scsi->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_scsi->hdr.id = DICMOTE_PACKET_ID; pkt_res_scsi->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_scsi->sense_len = sense_len; pkt_res_scsi->sense_len = htole32(sense_len);
pkt_res_scsi->buf_len = pkt_cmd_scsi->buf_len; pkt_res_scsi->buf_len = pkt_cmd_scsi->buf_len;
pkt_res_scsi->duration = duration; pkt_res_scsi->duration = htole32(duration);
pkt_res_scsi->sense = sense; pkt_res_scsi->sense = htole32(sense);
pkt_res_scsi->error_no = ret; pkt_res_scsi->error_no = htole32(ret);
NetWrite(cli_sock, pkt_res_scsi, pkt_res_scsi->hdr.len); NetWrite(cli_sock, pkt_res_scsi, le32toh(pkt_res_scsi->hdr.len));
free(pkt_cmd_scsi); free(pkt_cmd_scsi);
free(pkt_res_scsi); free(pkt_res_scsi);
if(sense_buf) free(sense_buf); if(sense_buf) free(sense_buf);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS: case DICMOTE_PACKET_TYPE_COMMAND_GET_SDHCI_REGISTERS:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -509,7 +517,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters)); pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters));
@@ -522,10 +530,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters)); memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->hdr.id = DICMOTE_PACKET_ID; pkt_res_sdhci_registers->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_sdhci_registers->hdr.version = DICMOTE_PACKET_VERSION; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS;
pkt_res_sdhci_registers->hdr.len = sizeof(DicPacketResGetSdhciRegisters); pkt_res_sdhci_registers->hdr.len = htole32(sizeof(DicPacketResGetSdhciRegisters));
pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_path, pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_path,
&csd, &csd,
&cid, &cid,
@@ -561,17 +569,23 @@ void* WorkingLoop(void* arguments)
memcpy(pkt_res_sdhci_registers->scr, scr, pkt_res_sdhci_registers->scr_len); memcpy(pkt_res_sdhci_registers->scr, scr, pkt_res_sdhci_registers->scr_len);
} }
// Swap lengths
pkt_res_sdhci_registers->csd_len = htole32(pkt_res_sdhci_registers->csd_len);
pkt_res_sdhci_registers->cid_len = htole32(pkt_res_sdhci_registers->cid_len);
pkt_res_sdhci_registers->ocr_len = htole32(pkt_res_sdhci_registers->ocr_len);
pkt_res_sdhci_registers->scr_len = htole32(pkt_res_sdhci_registers->scr_len);
free(csd); free(csd);
free(cid); free(cid);
free(scr); free(scr);
free(ocr); free(ocr);
NetWrite(cli_sock, pkt_res_sdhci_registers, pkt_res_sdhci_registers->hdr.len); NetWrite(cli_sock, pkt_res_sdhci_registers, le32toh(pkt_res_sdhci_registers->hdr.len));
free(pkt_res_sdhci_registers); free(pkt_res_sdhci_registers);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_USB_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -581,7 +595,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
pkt_res_usb = malloc(sizeof(DicPacketResGetUsbData)); pkt_res_usb = malloc(sizeof(DicPacketResGetUsbData));
@@ -594,10 +608,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData)); memset(pkt_res_usb, 0, sizeof(DicPacketResGetUsbData));
pkt_res_usb->hdr.id = DICMOTE_PACKET_ID; pkt_res_usb->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_usb->hdr.version = DICMOTE_PACKET_VERSION; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA;
pkt_res_usb->hdr.len = sizeof(DicPacketResGetUsbData); pkt_res_usb->hdr.len = htole32(sizeof(DicPacketResGetUsbData));
pkt_res_usb->is_usb = GetUsbData(device_path, pkt_res_usb->is_usb = GetUsbData(device_path,
&pkt_res_usb->desc_len, &pkt_res_usb->desc_len,
pkt_res_usb->descriptors, pkt_res_usb->descriptors,
@@ -607,12 +621,16 @@ void* WorkingLoop(void* arguments)
pkt_res_usb->product, pkt_res_usb->product,
pkt_res_usb->serial); pkt_res_usb->serial);
NetWrite(cli_sock, pkt_res_usb, pkt_res_usb->hdr.len); // Swap parameters
pkt_res_usb->desc_len = htole32(pkt_res_usb->desc_len);
// TODO: Need to swap vendor, product?
NetWrite(cli_sock, pkt_res_usb, le32toh(pkt_res_usb->hdr.len));
free(pkt_res_usb); free(pkt_res_usb);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_FIREWIRE_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -622,7 +640,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
pkt_res_firewire = malloc(sizeof(DicPacketResGetFireWireData)); pkt_res_firewire = malloc(sizeof(DicPacketResGetFireWireData));
@@ -635,10 +653,10 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData)); memset(pkt_res_firewire, 0, sizeof(DicPacketResGetFireWireData));
pkt_res_firewire->hdr.id = DICMOTE_PACKET_ID; pkt_res_firewire->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_firewire->hdr.version = DICMOTE_PACKET_VERSION; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_FIREWIRE_DATA;
pkt_res_firewire->hdr.len = sizeof(DicPacketResGetFireWireData); pkt_res_firewire->hdr.len = htole32(sizeof(DicPacketResGetFireWireData));
pkt_res_firewire->is_firewire = GetFireWireData(device_path, pkt_res_firewire->is_firewire = GetFireWireData(device_path,
&pkt_res_firewire->id_model, &pkt_res_firewire->id_model,
&pkt_res_firewire->id_vendor, &pkt_res_firewire->id_vendor,
@@ -646,12 +664,14 @@ void* WorkingLoop(void* arguments)
pkt_res_firewire->vendor, pkt_res_firewire->vendor,
pkt_res_firewire->model); pkt_res_firewire->model);
NetWrite(cli_sock, pkt_res_firewire, pkt_res_firewire->hdr.len); // TODO: Need to swap IDs?
NetWrite(cli_sock, pkt_res_firewire, le32toh(pkt_res_firewire->hdr.len));
free(pkt_res_firewire); free(pkt_res_firewire);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA: case DICMOTE_PACKET_TYPE_COMMAND_GET_PCMCIA_DATA:
// Packet only contains header so, dummy // Packet only contains header so, dummy
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -661,7 +681,7 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
free(in_buf); free(in_buf);
pkt_res_pcmcia = malloc(sizeof(DicPacketResGetPcmciaData)); pkt_res_pcmcia = malloc(sizeof(DicPacketResGetPcmciaData));
@@ -674,19 +694,21 @@ void* WorkingLoop(void* arguments)
} }
memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData)); memset(pkt_res_pcmcia, 0, sizeof(DicPacketResGetPcmciaData));
pkt_res_pcmcia->hdr.id = DICMOTE_PACKET_ID; pkt_res_pcmcia->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_pcmcia->hdr.version = DICMOTE_PACKET_VERSION; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_PCMCIA_DATA;
pkt_res_pcmcia->hdr.len = sizeof(DicPacketResGetPcmciaData); pkt_res_pcmcia->hdr.len = htole32(sizeof(DicPacketResGetPcmciaData));
pkt_res_pcmcia->is_pcmcia = pkt_res_pcmcia->is_pcmcia =
GetPcmciaData(device_path, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis); GetPcmciaData(device_path, &pkt_res_pcmcia->cis_len, pkt_res_pcmcia->cis);
NetWrite(cli_sock, pkt_res_pcmcia, pkt_res_pcmcia->hdr.len); pkt_res_pcmcia->cis_len = htole32(pkt_res_pcmcia->cis_len);
NetWrite(cli_sock, pkt_res_pcmcia, le32toh(pkt_res_pcmcia->hdr.len));
free(pkt_res_pcmcia); free(pkt_res_pcmcia);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS: case DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS:
// Packet contains data after // Packet contains data after
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -696,18 +718,20 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_chs = (DicPacketCmdAtaChs*)in_buf; pkt_cmd_ata_chs = (DicPacketCmdAtaChs*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header // TODO: Check size of buffers + size of packet is not bigger than size in header
if(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(DicPacketCmdAtaChs);
else else
buffer = NULL; buffer = NULL;
memset(&ata_chs_error_regs, 0, sizeof(AtaErrorRegistersChs)); memset(&ata_chs_error_regs, 0, sizeof(AtaErrorRegistersChs));
pkt_cmd_ata_chs->buf_len = le32toh(pkt_cmd_ata_chs->buf_len);
duration = 0; duration = 0;
sense = 1; sense = 1;
ret = SendAtaChsCommand(device_fd, ret = SendAtaChsCommand(device_fd,
@@ -716,7 +740,7 @@ void* WorkingLoop(void* arguments)
pkt_cmd_ata_chs->protocol, pkt_cmd_ata_chs->protocol,
pkt_cmd_ata_chs->transfer_register, pkt_cmd_ata_chs->transfer_register,
buffer, buffer,
pkt_cmd_ata_chs->timeout, le32toh(pkt_cmd_ata_chs->timeout),
pkt_cmd_ata_chs->transfer_blocks, pkt_cmd_ata_chs->transfer_blocks,
&duration, &duration,
&sense, &sense,
@@ -724,6 +748,8 @@ void* WorkingLoop(void* arguments)
out_buf = malloc(sizeof(DicPacketResAtaChs) + pkt_cmd_ata_chs->buf_len); out_buf = malloc(sizeof(DicPacketResAtaChs) + pkt_cmd_ata_chs->buf_len);
pkt_cmd_ata_chs->buf_len = htole32(pkt_cmd_ata_chs->buf_len);
if(!out_buf) if(!out_buf)
{ {
printf("Fatal error %d allocating memory for packet, continuing...\n", errno); printf("Fatal error %d allocating memory for packet, continuing...\n", errno);
@@ -734,26 +760,26 @@ void* WorkingLoop(void* arguments)
} }
pkt_res_ata_chs = (DicPacketResAtaChs*)out_buf; pkt_res_ata_chs = (DicPacketResAtaChs*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaChs), buffer, pkt_cmd_ata_chs->buf_len); if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaChs), buffer, htole32(pkt_cmd_ata_chs->buf_len));
pkt_res_ata_chs->hdr.len = sizeof(DicPacketResAtaChs) + pkt_cmd_ata_chs->buf_len; pkt_res_ata_chs->hdr.len = htole32(sizeof(DicPacketResAtaChs) + htole32(pkt_cmd_ata_chs->buf_len));
pkt_res_ata_chs->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS; pkt_res_ata_chs->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS;
pkt_res_ata_chs->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_chs->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_ata_chs->hdr.id = DICMOTE_PACKET_ID; pkt_res_ata_chs->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_ata_chs->registers = ata_chs_error_regs; pkt_res_ata_chs->registers = ata_chs_error_regs;
pkt_res_ata_chs->buf_len = pkt_cmd_ata_chs->buf_len; pkt_res_ata_chs->buf_len = pkt_cmd_ata_chs->buf_len;
pkt_res_ata_chs->duration = duration; pkt_res_ata_chs->duration = htole32(duration);
pkt_res_ata_chs->sense = sense; pkt_res_ata_chs->sense = htole32(sense);
pkt_res_ata_chs->error_no = ret; pkt_res_ata_chs->error_no = htole32(ret);
NetWrite(cli_sock, pkt_res_ata_chs, pkt_res_ata_chs->hdr.len); NetWrite(cli_sock, pkt_res_ata_chs, le32toh(pkt_res_ata_chs->hdr.len));
free(pkt_cmd_ata_chs); free(pkt_cmd_ata_chs);
free(pkt_res_ata_chs); free(pkt_res_ata_chs);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28: case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28:
// Packet contains data after // Packet contains data after
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -763,18 +789,20 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba28 = (DicPacketCmdAtaLba28*)in_buf; pkt_cmd_ata_lba28 = (DicPacketCmdAtaLba28*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header // TODO: Check size of buffers + size of packet is not bigger than size in header
if(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(DicPacketCmdAtaLba28);
else else
buffer = NULL; buffer = NULL;
memset(&ata_lba28_error_regs, 0, sizeof(AtaErrorRegistersLba28)); memset(&ata_lba28_error_regs, 0, sizeof(AtaErrorRegistersLba28));
pkt_cmd_ata_lba28->buf_len = le32toh(pkt_cmd_ata_lba28->buf_len);
duration = 0; duration = 0;
sense = 1; sense = 1;
ret = SendAtaLba28Command(device_fd, ret = SendAtaLba28Command(device_fd,
@@ -783,13 +811,14 @@ void* WorkingLoop(void* arguments)
pkt_cmd_ata_lba28->protocol, pkt_cmd_ata_lba28->protocol,
pkt_cmd_ata_lba28->transfer_register, pkt_cmd_ata_lba28->transfer_register,
buffer, buffer,
pkt_cmd_ata_lba28->timeout, le32toh(pkt_cmd_ata_lba28->timeout),
pkt_cmd_ata_lba28->transfer_blocks, pkt_cmd_ata_lba28->transfer_blocks,
&duration, &duration,
&sense, &sense,
&pkt_cmd_ata_lba28->buf_len); &pkt_cmd_ata_lba28->buf_len);
out_buf = malloc(sizeof(DicPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len); out_buf = malloc(sizeof(DicPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len);
pkt_cmd_ata_lba28->buf_len = htole32(pkt_cmd_ata_lba28->buf_len);
if(!out_buf) if(!out_buf)
{ {
@@ -801,26 +830,28 @@ void* WorkingLoop(void* arguments)
} }
pkt_res_ata_lba28 = (DicPacketResAtaLba28*)out_buf; pkt_res_ata_lba28 = (DicPacketResAtaLba28*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba28), buffer, pkt_cmd_ata_lba28->buf_len); if(buffer)
memcpy(out_buf + sizeof(DicPacketResAtaLba28), buffer, le32toh(pkt_cmd_ata_lba28->buf_len));
pkt_res_ata_lba28->hdr.len = sizeof(DicPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28;
pkt_res_ata_lba28->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_lba28->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_ata_lba28->hdr.id = DICMOTE_PACKET_ID; pkt_res_ata_lba28->hdr.id = htole64(DICMOTE_PACKET_ID);
pkt_res_ata_lba28->registers = ata_lba28_error_regs; pkt_res_ata_lba28->registers = ata_lba28_error_regs;
pkt_res_ata_lba28->buf_len = pkt_cmd_ata_lba28->buf_len; pkt_res_ata_lba28->buf_len = pkt_cmd_ata_lba28->buf_len;
pkt_res_ata_lba28->duration = duration; pkt_res_ata_lba28->duration = le32toh(duration);
pkt_res_ata_lba28->sense = sense; pkt_res_ata_lba28->sense = le32toh(sense);
pkt_res_ata_lba28->error_no = ret; pkt_res_ata_lba28->error_no = le32toh(ret);
NetWrite(cli_sock, pkt_res_ata_lba28, pkt_res_ata_lba28->hdr.len); NetWrite(cli_sock, pkt_res_ata_lba28, le32toh(pkt_res_ata_lba28->hdr.len));
free(pkt_cmd_ata_lba28); free(pkt_cmd_ata_lba28);
free(pkt_res_ata_lba28); free(pkt_res_ata_lba28);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48: case DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48:
// Packet contains data after // Packet contains data after
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -830,17 +861,24 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_ata_lba48 = (DicPacketCmdAtaLba48*)in_buf; pkt_cmd_ata_lba48 = (DicPacketCmdAtaLba48*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header // TODO: Check size of buffers + size of packet is not bigger than size in header
if(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(DicPacketCmdAtaLba48);
else else
buffer = NULL; buffer = NULL;
memset(&ata_lba48_error_regs, 0, sizeof(AtaErrorRegistersLba48)); memset(&ata_lba48_error_regs, 0, sizeof(AtaErrorRegistersLba48));
pkt_cmd_ata_lba48->buf_len = le32toh(pkt_cmd_ata_lba48->buf_len);
// Swapping
pkt_cmd_ata_lba48->registers.lba_high = le16toh(pkt_cmd_ata_lba48->registers.lba_high);
pkt_cmd_ata_lba48->registers.lba_mid = le16toh(pkt_cmd_ata_lba48->registers.lba_mid);
pkt_cmd_ata_lba48->registers.lba_low = le16toh(pkt_cmd_ata_lba48->registers.lba_low);
pkt_cmd_ata_lba48->registers.sector_count = le16toh(pkt_cmd_ata_lba48->registers.sector_count);
duration = 0; duration = 0;
sense = 1; sense = 1;
@@ -850,13 +888,14 @@ void* WorkingLoop(void* arguments)
pkt_cmd_ata_lba48->protocol, pkt_cmd_ata_lba48->protocol,
pkt_cmd_ata_lba48->transfer_register, pkt_cmd_ata_lba48->transfer_register,
buffer, buffer,
pkt_cmd_ata_lba48->timeout, le32toh(pkt_cmd_ata_lba48->timeout),
pkt_cmd_ata_lba48->transfer_blocks, pkt_cmd_ata_lba48->transfer_blocks,
&duration, &duration,
&sense, &sense,
&pkt_cmd_ata_lba48->buf_len); &pkt_cmd_ata_lba48->buf_len);
out_buf = malloc(sizeof(DicPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len); out_buf = malloc(sizeof(DicPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len);
pkt_cmd_ata_lba48->buf_len = htole32(pkt_cmd_ata_lba48->buf_len);
if(!out_buf) if(!out_buf)
{ {
@@ -868,26 +907,34 @@ void* WorkingLoop(void* arguments)
} }
pkt_res_ata_lba48 = (DicPacketResAtaLba48*)out_buf; pkt_res_ata_lba48 = (DicPacketResAtaLba48*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba48), buffer, pkt_cmd_ata_lba48->buf_len); if(buffer)
memcpy(out_buf + sizeof(DicPacketResAtaLba48), buffer, le32toh(pkt_cmd_ata_lba48->buf_len));
pkt_res_ata_lba48->hdr.len = sizeof(DicPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len; 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.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48;
pkt_res_ata_lba48->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_ata_lba48->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_ata_lba48->hdr.id = DICMOTE_PACKET_ID; pkt_res_ata_lba48->hdr.id = htole64(DICMOTE_PACKET_ID);
// Swapping
ata_lba48_error_regs.lba_high = htole16(ata_lba48_error_regs.lba_high);
ata_lba48_error_regs.lba_mid = htole16(ata_lba48_error_regs.lba_mid);
ata_lba48_error_regs.lba_low = htole16(ata_lba48_error_regs.lba_low);
ata_lba48_error_regs.sector_count = htole16(ata_lba48_error_regs.sector_count);
pkt_res_ata_lba48->registers = ata_lba48_error_regs; pkt_res_ata_lba48->registers = ata_lba48_error_regs;
pkt_res_ata_lba48->buf_len = pkt_cmd_ata_lba48->buf_len; pkt_res_ata_lba48->buf_len = pkt_cmd_ata_lba48->buf_len;
pkt_res_ata_lba48->duration = duration; pkt_res_ata_lba48->duration = le32toh(duration);
pkt_res_ata_lba48->sense = sense; pkt_res_ata_lba48->sense = le32toh(sense);
pkt_res_ata_lba48->error_no = ret; pkt_res_ata_lba48->error_no = le32toh(ret);
NetWrite(cli_sock, pkt_res_ata_lba48, pkt_res_ata_lba48->hdr.len); NetWrite(cli_sock, pkt_res_ata_lba48, le32toh(pkt_res_ata_lba48->hdr.len));
free(pkt_cmd_ata_lba48); free(pkt_cmd_ata_lba48);
free(pkt_res_ata_lba48); free(pkt_res_ata_lba48);
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_SDHCI: case DICMOTE_PACKET_TYPE_COMMAND_SDHCI:
// Packet contains data after // Packet contains data after
in_buf = malloc(pkt_hdr->len); in_buf = malloc(le32toh(pkt_hdr->len));
if(!in_buf) if(!in_buf)
{ {
@@ -897,13 +944,13 @@ void* WorkingLoop(void* arguments)
continue; continue;
} }
NetRecv(cli_sock, in_buf, pkt_hdr->len, 0); NetRecv(cli_sock, in_buf, le32toh(pkt_hdr->len), 0);
pkt_cmd_sdhci = (DicPacketCmdSdhci*)in_buf; pkt_cmd_sdhci = (DicPacketCmdSdhci*)in_buf;
// TODO: Check size of buffers + size of packet is not bigger than size in header // TODO: Check size of buffers + size of packet is not bigger than size in header
if(pkt_cmd_sdhci->buf_len > 0) buffer = in_buf + sizeof(DicPacketCmdSdhci); if(le32toh(pkt_cmd_sdhci->buf_len) > 0) buffer = in_buf + sizeof(DicPacketCmdSdhci);
else else
buffer = NULL; buffer = NULL;
@@ -915,18 +962,18 @@ void* WorkingLoop(void* arguments)
pkt_cmd_sdhci->command, pkt_cmd_sdhci->command,
pkt_cmd_sdhci->write, pkt_cmd_sdhci->write,
pkt_cmd_sdhci->application, pkt_cmd_sdhci->application,
pkt_cmd_sdhci->flags, le32toh(pkt_cmd_sdhci->flags),
pkt_cmd_sdhci->argument, le32toh(pkt_cmd_sdhci->argument),
pkt_cmd_sdhci->block_size, le32toh(pkt_cmd_sdhci->block_size),
pkt_cmd_sdhci->blocks, le32toh(pkt_cmd_sdhci->blocks),
buffer, buffer,
pkt_cmd_sdhci->buf_len, le32toh(pkt_cmd_sdhci->buf_len),
pkt_cmd_sdhci->timeout, le32toh(pkt_cmd_sdhci->timeout),
(uint32_t*)&sdhci_response, (uint32_t*)&sdhci_response,
&duration, &duration,
&sense); &sense);
out_buf = malloc(sizeof(DicPacketResSdhci) + pkt_cmd_sdhci->buf_len); out_buf = malloc(sizeof(DicPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
if(!out_buf) if(!out_buf)
{ {
@@ -938,20 +985,25 @@ void* WorkingLoop(void* arguments)
} }
pkt_res_sdhci = (DicPacketResSdhci*)out_buf; pkt_res_sdhci = (DicPacketResSdhci*)out_buf;
if(buffer) memcpy(out_buf + sizeof(DicPacketResSdhci), buffer, pkt_cmd_sdhci->buf_len); if(buffer) memcpy(out_buf + sizeof(DicPacketResSdhci), buffer, le32toh(pkt_cmd_sdhci->buf_len));
pkt_res_sdhci->hdr.len = sizeof(DicPacketResSdhci) + pkt_cmd_sdhci->buf_len; pkt_res_sdhci->hdr.len = htole32(sizeof(DicPacketResSdhci) + le32toh(pkt_cmd_sdhci->buf_len));
pkt_res_sdhci->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SDHCI; pkt_res_sdhci->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_SDHCI;
pkt_res_sdhci->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_sdhci->hdr.version = DICMOTE_PACKET_VERSION;
pkt_res_sdhci->hdr.id = DICMOTE_PACKET_ID; pkt_res_sdhci->hdr.id = htole64(DICMOTE_PACKET_ID);
sdhci_response[0] = htole32(sdhci_response[0]);
sdhci_response[1] = htole32(sdhci_response[1]);
sdhci_response[2] = htole32(sdhci_response[2]);
sdhci_response[3] = htole32(sdhci_response[3]);
memcpy((char*)&pkt_res_sdhci->response, (char*)&sdhci_response, sizeof(uint32_t) * 4); memcpy((char*)&pkt_res_sdhci->response, (char*)&sdhci_response, sizeof(uint32_t) * 4);
pkt_res_sdhci->buf_len = pkt_cmd_sdhci->buf_len; pkt_res_sdhci->buf_len = pkt_cmd_sdhci->buf_len;
pkt_res_sdhci->duration = duration; pkt_res_sdhci->duration = htole32(duration);
pkt_res_sdhci->sense = sense; pkt_res_sdhci->sense = htole32(sense);
pkt_res_sdhci->error_no = ret; pkt_res_sdhci->error_no = htole32(ret);
NetWrite(cli_sock, pkt_res_sdhci, pkt_res_sdhci->hdr.len); NetWrite(cli_sock, pkt_res_sdhci, le32toh(pkt_res_sdhci->hdr.len));
free(pkt_cmd_sdhci); free(pkt_cmd_sdhci);
free(pkt_res_sdhci); free(pkt_res_sdhci);
continue; continue;