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

General refactor.

Browse Source
This commit is contained in:
Natalia Portillo
2019-10-19 18:30:45 +01:00
parent 4e9a16f404
commit 78d23fce19
20 changed files with 905 additions and 912 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
ata.c
View File

@@ -17,33 +17,31 @@
#include "dicmote.h" #include "dicmote.h"
#include <stddef.h>
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
int32_t SendAtaChsCommand(int device_fd, int32_t SendAtaChsCommand(int device_fd,
AtaRegistersChs registers, AtaRegistersChs registers,
AtaErrorRegistersChs* errorRegisters, AtaErrorRegistersChs* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_send_ata_chs_command(device_fd, return LinuxSendAtaChsCommand(device_fd,
registers, registers,
errorRegisters, error_registers,
protocol, protocol,
transferRegister, transfer_register,
buffer, buffer,
timeout, timeout,
transferBlocks, transfer_blocks,
duration, duration,
sense, sense,
buf_len); buf_len);
@@ -54,25 +52,25 @@ int32_t SendAtaChsCommand(int device_fd,
int32_t SendAtaLba28Command(int device_fd, int32_t SendAtaLba28Command(int device_fd,
AtaRegistersLba28 registers, AtaRegistersLba28 registers,
AtaErrorRegistersLba28* errorRegisters, AtaErrorRegistersLba28* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_send_ata_lba28_command(device_fd, return LinuxSendAtaLba28Command(device_fd,
registers, registers,
errorRegisters, error_registers,
protocol, protocol,
transferRegister, transfer_register,
buffer, buffer,
timeout, timeout,
transferBlocks, transfer_blocks,
duration, duration,
sense, sense,
buf_len); buf_len);
@@ -83,25 +81,25 @@ int32_t SendAtaLba28Command(int device_fd,
int32_t SendAtaLba48Command(int device_fd, int32_t SendAtaLba48Command(int device_fd,
AtaRegistersLba48 registers, AtaRegistersLba48 registers,
AtaErrorRegistersLba48* errorRegisters, AtaErrorRegistersLba48* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_send_ata_lba48_command(device_fd, return LinuxSendAtaLba48Command(device_fd,
registers, registers,
errorRegisters, error_registers,
protocol, protocol,
transferRegister, transfer_register,
buffer, buffer,
timeout, timeout,
transferBlocks, transfer_blocks,
duration, duration,
sense, sense,
buf_len); buf_len);

12
device.c
View File

@@ -19,25 +19,25 @@
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
int DeviceOpen(const char* devicePath) int DeviceOpen(const char* device_path)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_open_device(devicePath); return LinuxOpenDevice(device_path);
#else #else
return -1; return -1;
#endif #endif
} }
int32_t GetDeviceType(const char* devicePath) int32_t GetDeviceType(const char* device_path)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_get_device_type(devicePath); return LinuxGetDeviceType(device_path);
#else #else
return DICMOTE_DEVICE_TYPE_UNKNOWN; return DICMOTE_DEVICE_TYPE_UNKNOWN;
#endif #endif
} }
int32_t GetSdhciRegisters(const char* devicePath, int32_t GetSdhciRegisters(const char* device_path,
char** csd, char** csd,
char** cid, char** cid,
char** ocr, char** ocr,
@@ -48,7 +48,7 @@ int32_t GetSdhciRegisters(const char* devicePath,
uint32_t* scr_len) uint32_t* scr_len)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_get_sdhci_registers(devicePath, csd, cid, ocr, scr, csd_len, cid_len, ocr_len, scr_len); return LinuxGetSdhciRegisters(device_path, csd, cid, ocr, scr, csd_len, cid_len, ocr_len, scr_len);
#else #else
return 0; return 0;
#endif #endif

174
dicmote.h
View File

@@ -15,8 +15,8 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef DICMOTE_H #ifndef DICREMOTE__DICMOTE_H_
#define DICMOTE_H #define DICREMOTE__DICMOTE_H_
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
@@ -35,10 +35,10 @@
#define DICMOTE_PACKET_TYPE_RESPONSE_SCSI 6 #define DICMOTE_PACKET_TYPE_RESPONSE_SCSI 6
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7 #define DICMOTE_PACKET_TYPE_COMMAND_ATA_CHS 7
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8 #define DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS 8
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA28 9 #define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_28 9
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA28 10 #define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28 10
#define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA48 11 #define DICMOTE_PACKET_TYPE_COMMAND_ATA_LBA_48 11
#define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA48 12 #define DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48 12
#define DICMOTE_PACKET_TYPE_COMMAND_SDHCI 13 #define DICMOTE_PACKET_TYPE_COMMAND_SDHCI 13
#define DICMOTE_PACKET_TYPE_RESPONSE_SDHCI 14 #define DICMOTE_PACKET_TYPE_RESPONSE_SDHCI 14
#define DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15 #define DICMOTE_PACKET_TYPE_COMMAND_GET_DEVTYPE 15
@@ -145,7 +145,7 @@ typedef struct
uint8_t reason_code; uint8_t reason_code;
char spare[3]; char spare[3];
char reason[256]; char reason[256];
int32_t errorNo; int32_t error_no;
} DicPacketNop; } DicPacketNop;
typedef struct typedef struct
@@ -175,24 +175,24 @@ typedef struct
typedef struct typedef struct
{ {
uint8_t Feature; uint8_t feature;
uint8_t SectorCount; uint8_t sector_count;
uint8_t Sector; uint8_t sector;
uint8_t CylinderLow; uint8_t cylinder_low;
uint8_t CylinderHigh; uint8_t cylinder_high;
uint8_t DeviceHead; uint8_t device_head;
uint8_t Command; uint8_t command;
} AtaRegistersChs; } AtaRegistersChs;
typedef struct typedef struct
{ {
uint8_t Status; uint8_t status;
uint8_t Error; uint8_t error;
uint8_t SectorCount; uint8_t sector_count;
uint8_t Sector; uint8_t sector;
uint8_t CylinderLow; uint8_t cylinder_low;
uint8_t CylinderHigh; uint8_t cylinder_high;
uint8_t DeviceHead; uint8_t device_head;
} AtaErrorRegistersChs; } AtaErrorRegistersChs;
typedef struct typedef struct
@@ -201,8 +201,8 @@ typedef struct
uint32_t buf_len; uint32_t buf_len;
AtaRegistersChs registers; AtaRegistersChs registers;
uint8_t protocol; uint8_t protocol;
uint8_t transferRegister; uint8_t transfer_register;
uint8_t transferBlocks; uint8_t transfer_blocks;
uint8_t spare; uint8_t spare;
uint32_t timeout; uint32_t timeout;
} DicPacketCmdAtaChs; } DicPacketCmdAtaChs;
@@ -219,24 +219,24 @@ typedef struct
typedef struct typedef struct
{ {
uint8_t Feature; uint8_t feature;
uint8_t SectorCount; uint8_t sector_count;
uint8_t LbaLow; uint8_t lba_low;
uint8_t LbaMid; uint8_t lba_mid;
uint8_t LbaHigh; uint8_t lba_high;
uint8_t DeviceHead; uint8_t device_head;
uint8_t Command; uint8_t command;
} AtaRegistersLba28; } AtaRegistersLba28;
typedef struct typedef struct
{ {
uint8_t Status; uint8_t status;
uint8_t Error; uint8_t error;
uint8_t SectorCount; uint8_t sector_count;
uint8_t LbaLow; uint8_t lba_low;
uint8_t LbaMid; uint8_t lba_mid;
uint8_t LbaHigh; uint8_t lba_high;
uint8_t DeviceHead; uint8_t device_head;
} AtaErrorRegistersLba28; } AtaErrorRegistersLba28;
typedef struct typedef struct
@@ -245,8 +245,8 @@ typedef struct
uint32_t buf_len; uint32_t buf_len;
AtaRegistersLba28 registers; AtaRegistersLba28 registers;
uint8_t protocol; uint8_t protocol;
uint8_t transferRegister; uint8_t transfer_register;
uint8_t transferBlocks; uint8_t transfer_blocks;
uint8_t spare; uint8_t spare;
uint32_t timeout; uint32_t timeout;
} DicPacketCmdAtaLba28; } DicPacketCmdAtaLba28;
@@ -263,24 +263,24 @@ typedef struct
typedef struct typedef struct
{ {
uint16_t Feature; uint16_t feature;
uint16_t SectorCount; uint16_t sector_count;
uint16_t LbaLow; uint16_t lba_low;
uint16_t LbaMid; uint16_t lba_mid;
uint16_t LbaHigh; uint16_t lba_high;
uint8_t DeviceHead; uint8_t device_head;
uint8_t Command; uint8_t command;
} AtaRegistersLba48; } AtaRegistersLba48;
typedef struct typedef struct
{ {
uint8_t Status; uint8_t status;
uint8_t Error; uint8_t error;
uint16_t SectorCount; uint16_t sector_count;
uint16_t LbaLow; uint16_t lba_low;
uint16_t LbaMid; uint16_t lba_mid;
uint16_t LbaHigh; uint16_t lba_high;
uint8_t DeviceHead; uint8_t device_head;
} AtaErrorRegistersLba48; } AtaErrorRegistersLba48;
typedef struct typedef struct
@@ -289,8 +289,8 @@ typedef struct
uint32_t buf_len; uint32_t buf_len;
AtaRegistersLba48 registers; AtaRegistersLba48 registers;
uint8_t protocol; uint8_t protocol;
uint8_t transferRegister; uint8_t transfer_register;
uint8_t transferBlocks; uint8_t transfer_blocks;
uint8_t spare; uint8_t spare;
uint32_t timeout; uint32_t timeout;
} DicPacketCmdAtaLba48; } DicPacketCmdAtaLba48;
@@ -348,7 +348,7 @@ typedef struct
typedef struct typedef struct
{ {
DicPacketHeader hdr; DicPacketHeader hdr;
uint8_t isSdhci; uint8_t is_sdhci;
char csd[16]; char csd[16];
char cid[16]; char cid[16];
char ocr[4]; char ocr[4];
@@ -367,11 +367,11 @@ typedef struct
typedef struct typedef struct
{ {
DicPacketHeader hdr; DicPacketHeader hdr;
uint8_t isUsb; uint8_t is_usb;
uint16_t descLen; uint16_t desc_len;
char descriptors[65536]; char descriptors[65536];
uint16_t idVendor; uint16_t id_vendor;
uint16_t idProduct; uint16_t id_product;
char manufacturer[256]; char manufacturer[256];
char product[256]; char product[256];
char serial[256]; char serial[256];
@@ -385,9 +385,9 @@ typedef struct
typedef struct typedef struct
{ {
DicPacketHeader hdr; DicPacketHeader hdr;
uint8_t isFireWire; uint8_t is_firewire;
uint32_t idModel; uint32_t id_model;
uint32_t idVendor; uint32_t id_vendor;
uint64_t guid; uint64_t guid;
char vendor[256]; char vendor[256];
char model[256]; char model[256];
@@ -401,7 +401,7 @@ typedef struct
typedef struct typedef struct
{ {
DicPacketHeader hdr; DicPacketHeader hdr;
uint8_t isPcmcia; uint8_t is_pcmcia;
uint16_t cis_len; uint16_t cis_len;
char cis[65536]; char cis[65536];
} DicPacketResGetPcmciaData; } DicPacketResGetPcmciaData;
@@ -411,12 +411,12 @@ typedef struct
DeviceInfoList* ListDevices(); DeviceInfoList* ListDevices();
void FreeDeviceInfoList(DeviceInfoList* start); void FreeDeviceInfoList(DeviceInfoList* start);
uint16_t DeviceInfoListCount(DeviceInfoList* start); uint16_t DeviceInfoListCount(DeviceInfoList* start);
int DeviceOpen(const char* devicePath); int DeviceOpen(const char* device_path);
int32_t GetDeviceType(const char* devicePath); int32_t GetDeviceType(const char* device_path);
int32_t SendScsiCommand(int device_fd, int32_t SendScsiCommand(int device_fd,
char* cdb, char* cdb,
char* buffer, char* buffer,
char** senseBuffer, char** sense_buffer,
uint32_t timeout, uint32_t timeout,
int32_t direction, int32_t direction,
uint32_t* duration, uint32_t* duration,
@@ -424,9 +424,9 @@ int32_t SendScsiCommand(int device_fd,
uint32_t cdb_len, uint32_t cdb_len,
uint32_t* buf_len, uint32_t* buf_len,
uint32_t* sense_len); uint32_t* sense_len);
int hexchr2bin(const char hex, char* out); int Hexchr2Bin(const char hex, char* out);
size_t hexs2bin(const char* hex, unsigned char** out); size_t Hexs2Bin(const char* hex, unsigned char** out);
int32_t GetSdhciRegisters(const char* devicePath, int32_t GetSdhciRegisters(const char* device_path,
char** csd, char** csd,
char** cid, char** cid,
char** ocr, char** ocr,
@@ -435,51 +435,51 @@ int32_t GetSdhciRegisters(const char* devicePath,
uint32_t* cid_len, uint32_t* cid_len,
uint32_t* ocr_len, uint32_t* ocr_len,
uint32_t* scr_len); uint32_t* scr_len);
uint8_t GetUsbData(const char* devicePath, uint8_t GetUsbData(const char* device_path,
uint16_t* descLen, uint16_t* desc_len,
char* descriptors, char* descriptors,
uint16_t* idVendor, uint16_t* id_vendor,
uint16_t* idProduct, uint16_t* id_product,
char* manufacturer, char* manufacturer,
char* product, char* product,
char* serial); char* serial);
uint8_t GetFireWireData(const char* devicePath, uint8_t GetFireWireData(const char* device_path,
uint32_t* idModel, uint32_t* id_model,
uint32_t* idVendor, uint32_t* id_vendor,
uint64_t* guid, uint64_t* guid,
char* vendor, char* vendor,
char* model); char* model);
uint8_t GetPcmciaData(const char* devicePath, uint16_t* cisLen, char* cis); uint8_t GetPcmciaData(const char* device_path, uint16_t* cis_len, char* cis);
int32_t SendAtaChsCommand(int device_fd, int32_t SendAtaChsCommand(int device_fd,
AtaRegistersChs registers, AtaRegistersChs registers,
AtaErrorRegistersChs* errorRegisters, AtaErrorRegistersChs* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);
int32_t SendAtaLba28Command(int device_fd, int32_t SendAtaLba28Command(int device_fd,
AtaRegistersLba28 registers, AtaRegistersLba28 registers,
AtaErrorRegistersLba28* errorRegisters, AtaErrorRegistersLba28* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);
int32_t SendAtaLba48Command(int device_fd, int32_t SendAtaLba48Command(int device_fd,
AtaRegistersLba48 registers, AtaRegistersLba48 registers,
AtaErrorRegistersLba48* errorRegisters, AtaErrorRegistersLba48* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);

9
hex2bin.c
View File

@@ -19,12 +19,11 @@
#include <stddef.h> #include <stddef.h>
#include <string.h> #include <string.h>
int hexchr2bin(const char hex, char* out) int Hexchr2Bin(const char hex, char* out)
{ {
if(out == NULL) return 0; if(out == NULL) return 0;
if(hex >= '0' && hex <= '9') if(hex >= '0' && hex <= '9') *out = hex - '0';
*out = hex - '0';
else if(hex >= 'A' && hex <= 'F') else if(hex >= 'A' && hex <= 'F')
*out = hex - 'A' + 10; *out = hex - 'A' + 10;
else if(hex >= 'a' && hex <= 'f') else if(hex >= 'a' && hex <= 'f')
@@ -35,7 +34,7 @@ int hexchr2bin(const char hex, char* out)
return 1; return 1;
} }
size_t hexs2bin(const char* hex, unsigned char** out) size_t Hexs2Bin(const char* hex, unsigned char** out)
{ {
size_t len; size_t len;
char b1; char b1;
@@ -52,7 +51,7 @@ size_t hexs2bin(const char* hex, unsigned char** out)
memset(*out, 'A', len); memset(*out, 'A', len);
for(i = 0; i < len; i++) for(i = 0; i < len; i++)
{ {
if(!hexchr2bin(hex[i * 2], &b1) || !hexchr2bin(hex[i * 2 + 1], &b2)) return 0; if(!Hexchr2Bin(hex[i * 2], &b1) || !Hexchr2Bin(hex[i * 2 + 1], &b2)) return 0;
(*out)[i] = (b1 << 4) | b2; (*out)[i] = (b1 << 4) | b2;
} }

8
ieee1394.c
View File

@@ -21,15 +21,15 @@
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
uint8_t GetFireWireData(const char* devicePath, uint8_t GetFireWireData(const char* device_path,
uint32_t* idModel, uint32_t* id_model,
uint32_t* idVendor, uint32_t* id_vendor,
uint64_t* guid, uint64_t* guid,
char* vendor, char* vendor,
char* model) char* model)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_get_ieee1394_data(devicePath, idModel, idVendor, guid, vendor, model); return LinuxGetIeee1394Data(device_path, id_model, id_vendor, guid, vendor, model);
#else #else
return 0; return 0;
#endif #endif

159
linux/ata.c
View File

@@ -17,11 +17,9 @@
#include "linux.h" #include "linux.h"
#include <scsi/sg.h>
#include <stddef.h>
#include <string.h> #include <string.h>
int32_t ata_protocol_to_scsi_direction(uint8_t protocol) int32_t AtaProtocolToScsiDirection(uint8_t protocol)
{ {
switch(protocol) switch(protocol)
{ {
@@ -39,14 +37,14 @@ int32_t ata_protocol_to_scsi_direction(uint8_t protocol)
} }
} }
int32_t linux_send_ata_chs_command(int device_fd, int32_t LinuxSendAtaChsCommand(int device_fd,
AtaRegistersChs registers, AtaRegistersChs registers,
AtaErrorRegistersChs* errorRegisters, AtaErrorRegistersChs* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
@@ -61,7 +59,7 @@ int32_t linux_send_ata_chs_command(int device_fd,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
if(transferRegister != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
@@ -70,25 +68,25 @@ int32_t linux_send_ata_chs_command(int device_fd,
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }
if(transferBlocks) cdb[2] |= 0x04; if(transfer_blocks) cdb[2] |= 0x04;
cdb[2] |= (transferRegister & 0x03); cdb[2] |= (transfer_register & 0x03);
} }
cdb[4] = registers.Feature; cdb[4] = registers.feature;
cdb[6] = registers.SectorCount; cdb[6] = registers.sector_count;
cdb[8] = registers.Sector; cdb[8] = registers.sector;
cdb[10] = registers.CylinderLow; cdb[10] = registers.cylinder_low;
cdb[12] = registers.CylinderHigh; cdb[12] = registers.cylinder_high;
cdb[13] = registers.DeviceHead; cdb[13] = registers.device_head;
cdb[14] = registers.Command; cdb[14] = registers.command;
int error = linux_send_scsi_command(device_fd, int error = LinuxSendScsiCommand(device_fd,
(char*)cdb, (char*)cdb,
buffer, buffer,
&sense_buf, &sense_buf,
timeout, timeout,
ata_protocol_to_scsi_direction(protocol), AtaProtocolToScsiDirection(protocol),
duration, duration,
sense, sense,
16, 16,
@@ -97,28 +95,28 @@ int32_t linux_send_ata_chs_command(int device_fd,
if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error; if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error;
errorRegisters->Error = sense_buf[11]; error_registers->error = sense_buf[11];
errorRegisters->SectorCount = sense_buf[13]; error_registers->sector_count = sense_buf[13];
errorRegisters->Sector = sense_buf[15]; error_registers->sector = sense_buf[15];
errorRegisters->CylinderLow = sense_buf[17]; error_registers->cylinder_low = sense_buf[17];
errorRegisters->CylinderHigh = sense_buf[19]; error_registers->cylinder_high = sense_buf[19];
errorRegisters->DeviceHead = sense_buf[20]; error_registers->device_head = sense_buf[20];
errorRegisters->Status = sense_buf[21]; error_registers->status = sense_buf[21];
*sense = errorRegisters->Error != 0 || (errorRegisters->Status & 0xA5) != 0; *sense = error_registers->error != 0 || (error_registers->status & 0xA5) != 0;
return error; return error;
} }
int32_t linux_send_ata_lba28_command(int device_fd, int32_t LinuxSendAtaLba28Command(int device_fd,
AtaRegistersLba28 registers, AtaRegistersLba28 registers,
AtaErrorRegistersLba28* errorRegisters, AtaErrorRegistersLba28* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
@@ -133,7 +131,7 @@ int32_t linux_send_ata_lba28_command(int device_fd,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
if(transferRegister != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
@@ -142,27 +140,27 @@ int32_t linux_send_ata_lba28_command(int device_fd,
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }
if(transferBlocks) cdb[2] |= 0x04; if(transfer_blocks) cdb[2] |= 0x04;
cdb[2] |= (transferRegister & 0x03); cdb[2] |= (transfer_register & 0x03);
} }
cdb[2] |= 0x20; cdb[2] |= 0x20;
cdb[4] = registers.Feature; cdb[4] = registers.feature;
cdb[6] = registers.SectorCount; cdb[6] = registers.sector_count;
cdb[8] = registers.LbaLow; cdb[8] = registers.lba_low;
cdb[10] = registers.LbaMid; cdb[10] = registers.lba_mid;
cdb[12] = registers.LbaHigh; cdb[12] = registers.lba_high;
cdb[13] = registers.DeviceHead; cdb[13] = registers.device_head;
cdb[14] = registers.Command; cdb[14] = registers.command;
int error = linux_send_scsi_command(device_fd, int error = LinuxSendScsiCommand(device_fd,
(char*)cdb, (char*)cdb,
buffer, buffer,
&sense_buf, &sense_buf,
timeout, timeout,
ata_protocol_to_scsi_direction(protocol), AtaProtocolToScsiDirection(protocol),
duration, duration,
sense, sense,
16, 16,
@@ -171,27 +169,28 @@ int32_t linux_send_ata_lba28_command(int device_fd,
if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error; if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error;
errorRegisters->Error = sense_buf[11]; error_registers->error = sense_buf[11];
errorRegisters->SectorCount = sense_buf[13]; error_registers->sector_count = sense_buf[13];
errorRegisters->LbaLow = sense_buf[15]; error_registers->lba_low = sense_buf[15];
errorRegisters->LbaMid = sense_buf[17]; error_registers->lba_mid = sense_buf[17];
errorRegisters->LbaHigh = sense_buf[19]; error_registers->lba_high = sense_buf[19];
errorRegisters->DeviceHead = sense_buf[20]; error_registers->device_head = sense_buf[20];
errorRegisters->Status = sense_buf[21]; error_registers->status = sense_buf[21];
*sense = errorRegisters->Error != 0 || (errorRegisters->Status & 0xA5) != 0; *sense = error_registers->error != 0 || (error_registers->status & 0xA5) != 0;
return error; return error;
} }
int32_t linux_send_ata_lba48_command(int device_fd,
int32_t LinuxSendAtaLba48Command(int device_fd,
AtaRegistersLba48 registers, AtaRegistersLba48 registers,
AtaErrorRegistersLba48* errorRegisters, AtaErrorRegistersLba48* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len) uint32_t* buf_len)
@@ -207,7 +206,7 @@ int32_t linux_send_ata_lba48_command(int device_fd,
cdb[0] = 0x85; cdb[0] = 0x85;
cdb[1] = (protocol << 1) & 0x1E; cdb[1] = (protocol << 1) & 0x1E;
cdb[1] |= 0x01; cdb[1] |= 0x01;
if(transferRegister != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA) if(transfer_register != DICMOTE_ATA_TRANSFER_REGISTER_NONE && protocol != DICMOTE_ATA_PROTOCOL_NO_DATA)
{ {
switch(protocol) switch(protocol)
{ {
@@ -216,32 +215,32 @@ int32_t linux_send_ata_lba48_command(int device_fd,
default: cdb[2] = 0x00; break; default: cdb[2] = 0x00; break;
} }
if(transferBlocks) cdb[2] |= 0x04; if(transfer_blocks) cdb[2] |= 0x04;
cdb[2] |= (transferRegister & 0x03); cdb[2] |= (transfer_register & 0x03);
} }
cdb[2] |= 0x20; cdb[2] |= 0x20;
cdb[3] = ((registers.Feature & 0xFF00) >> 8); cdb[3] = ((registers.feature & 0xFF00) >> 8);
cdb[4] = (registers.Feature & 0xFF); cdb[4] = (registers.feature & 0xFF);
cdb[5] = ((registers.SectorCount & 0xFF00) >> 8); cdb[5] = ((registers.sector_count & 0xFF00) >> 8);
cdb[6] = (registers.SectorCount & 0xFF); cdb[6] = (registers.sector_count & 0xFF);
cdb[7] = ((registers.LbaLow & 0xFF00) >> 8); cdb[7] = ((registers.lba_low & 0xFF00) >> 8);
cdb[8] = (registers.LbaLow & 0xFF); cdb[8] = (registers.lba_low & 0xFF);
cdb[9] = ((registers.LbaMid & 0xFF00) >> 8); cdb[9] = ((registers.lba_mid & 0xFF00) >> 8);
cdb[10] = (registers.LbaMid & 0xFF); cdb[10] = (registers.lba_mid & 0xFF);
cdb[11] = ((registers.LbaHigh & 0xFF00) >> 8); cdb[11] = ((registers.lba_high & 0xFF00) >> 8);
cdb[12] = (registers.LbaHigh & 0xFF); cdb[12] = (registers.lba_high & 0xFF);
cdb[13] = registers.DeviceHead; cdb[13] = registers.device_head;
cdb[14] = registers.Command; cdb[14] = registers.command;
int error = linux_send_scsi_command(device_fd, int error = LinuxSendScsiCommand(device_fd,
(char*)cdb, (char*)cdb,
buffer, buffer,
&sense_buf, &sense_buf,
timeout, timeout,
ata_protocol_to_scsi_direction(protocol), AtaProtocolToScsiDirection(protocol),
duration, duration,
sense, sense,
16, 16,
@@ -250,16 +249,16 @@ int32_t linux_send_ata_lba48_command(int device_fd,
if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error; if(sense_len < 22 || (sense_buf[8] != 0x09 && sense_buf[9] != 0x0C)) return error;
errorRegisters->Error = sense_buf[11]; error_registers->error = sense_buf[11];
errorRegisters->SectorCount = (uint16_t)((sense_buf[12] << 8) + sense_buf[13]); error_registers->sector_count = (uint16_t)((sense_buf[12] << 8) + sense_buf[13]);
errorRegisters->LbaLow = (uint16_t)((sense_buf[14] << 8) + sense_buf[15]); error_registers->lba_low = (uint16_t)((sense_buf[14] << 8) + sense_buf[15]);
errorRegisters->LbaMid = (uint16_t)((sense_buf[16] << 8) + sense_buf[17]); error_registers->lba_mid = (uint16_t)((sense_buf[16] << 8) + sense_buf[17]);
errorRegisters->LbaHigh = (uint16_t)((sense_buf[18] << 8) + sense_buf[19]); error_registers->lba_high = (uint16_t)((sense_buf[18] << 8) + sense_buf[19]);
errorRegisters->DeviceHead = sense_buf[20]; error_registers->device_head = sense_buf[20];
errorRegisters->Status = sense_buf[21]; error_registers->status = sense_buf[21];
*sense = errorRegisters->Error != 0 || (errorRegisters->Status & 0xA5) != 0; *sense = error_registers->error != 0 || (error_registers->status & 0xA5) != 0;
return error; return error;
} }

170
linux/device.c
View File

@@ -25,7 +25,7 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
int linux_open_device(const char* device_path) int LinuxOpenDevice(const char* device_path)
{ {
int fd; int fd;
@@ -36,19 +36,19 @@ int linux_open_device(const char* device_path)
return fd; return fd;
} }
int32_t linux_get_device_type(const char* devicePath) int32_t LinuxGetDeviceType(const char* device_path)
{ {
struct udev* udev; struct udev* udev;
struct udev_device* udev_device; struct udev_device* udev_device;
const char* tmpString; const char* tmp_string;
char* chrptr; char* chrptr;
int32_t deviceType = DICMOTE_DEVICE_TYPE_UNKNOWN; int32_t device_type = DICMOTE_DEVICE_TYPE_UNKNOWN;
udev = udev_new(); udev = udev_new();
if(!udev) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(!udev) return DICMOTE_DEVICE_TYPE_UNKNOWN;
chrptr = strrchr(devicePath, '/'); chrptr = strrchr(device_path, '/');
if(chrptr == 0) return DICMOTE_DEVICE_TYPE_UNKNOWN; if(chrptr == 0) return DICMOTE_DEVICE_TYPE_UNKNOWN;
chrptr++; chrptr++;
@@ -57,69 +57,69 @@ int32_t linux_get_device_type(const char* devicePath)
udev_device = udev_device_new_from_subsystem_sysname(udev, "block", chrptr); udev_device = udev_device_new_from_subsystem_sysname(udev, "block", chrptr);
if(udev_device) if(udev_device)
{ {
tmpString = udev_device_get_property_value(udev_device, "ID_BUS"); tmp_string = udev_device_get_property_value(udev_device, "ID_BUS");
if(tmpString) if(tmp_string)
{ {
if(strncmp(tmpString, "ata", 3) == 0) if(strncmp(tmp_string, "ata", 3) == 0)
{ {
deviceType = DICMOTE_DEVICE_TYPE_ATA; device_type = DICMOTE_DEVICE_TYPE_ATA;
free((void*)tmpString); free((void*)tmp_string);
tmpString = udev_device_get_property_value(udev_device, "ID_TYPE"); tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE");
if(tmpString) if(tmp_string)
{ {
// TODO: ATAPI removable non optical disks // TODO: ATAPI removable non optical disks
if(strncmp(tmpString, "cd", 2) == 0) { deviceType = DICMOTE_DEVICE_TYPE_ATAPI; } if(strncmp(tmp_string, "cd", 2) == 0) { device_type = DICMOTE_DEVICE_TYPE_ATAPI; }
free((void*)tmpString); free((void*)tmp_string);
} }
} }
else if(strncmp(tmpString, "mmc", 3) == 0) else if(strncmp(tmp_string, "mmc", 3) == 0)
{ {
free((void*)tmpString); free((void*)tmp_string);
tmpString = malloc(1024); tmp_string = malloc(1024);
deviceType = DICMOTE_DEVICE_TYPE_MMC; device_type = DICMOTE_DEVICE_TYPE_MMC;
if(tmpString) if(tmp_string)
{ {
memset((void*)tmpString, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmpString, 1024, "/sys/block/%s/device/scr", chrptr); snprintf((char*)tmp_string, 1024, "/sys/block/%s/device/scr", chrptr);
if(access(tmpString, R_OK) == 0) deviceType = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL; if(access(tmp_string, R_OK) == 0) device_type = DICMOTE_DEVICE_TYPE_SECURE_DIGITAL;
free((void*)tmpString); free((void*)tmp_string);
} }
} }
else if(strncmp(tmpString, "scsi", 4) == 0 || strncmp(tmpString, "ieee1394", 8) == 0 || else if(strncmp(tmp_string, "scsi", 4) == 0 || strncmp(tmp_string, "ieee1394", 8) == 0 ||
strncmp(tmpString, "usb", 3) == 0) strncmp(tmp_string, "usb", 3) == 0)
{ {
free((void*)tmpString); free((void*)tmp_string);
tmpString = udev_device_get_property_value(udev_device, "ID_TYPE"); tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE");
if(tmpString) if(tmp_string)
{ {
if(strncmp(tmpString, "cd", 2) == 0 || strncmp(tmpString, "disk", 4) == 0) if(strncmp(tmp_string, "cd", 2) == 0 || strncmp(tmp_string, "disk", 4) == 0)
{ deviceType = DICMOTE_DEVICE_TYPE_SCSI; } { device_type = DICMOTE_DEVICE_TYPE_SCSI; }
free((void*)tmpString); free((void*)tmp_string);
} }
} }
else if(strncmp(tmpString, "nvme", 4) == 0) else if(strncmp(tmp_string, "nvme", 4) == 0)
{ {
free((void*)tmpString); free((void*)tmp_string);
deviceType = DICMOTE_DEVICE_TYPE_NVME; device_type = DICMOTE_DEVICE_TYPE_NVME;
} }
} }
} }
udev_unref(udev); udev_unref(udev);
return deviceType; return device_type;
} }
int32_t linux_get_sdhci_registers(const char* devicePath, int32_t LinuxGetSdhciRegisters(const char* device_path,
char** csd, char** csd,
char** cid, char** cid,
char** ocr, char** ocr,
@@ -129,11 +129,11 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
uint32_t* ocr_len, uint32_t* ocr_len,
uint32_t* scr_len) uint32_t* scr_len)
{ {
char* tmpString; char* tmp_string;
char* sysfsPath_csd; char* sysfs_path_csd;
char* sysfsPath_cid; char* sysfs_path_cid;
char* sysfsPath_scr; char* sysfs_path_scr;
char* sysfsPath_ocr; char* sysfs_path_ocr;
size_t len; size_t len;
FILE* file; FILE* file;
*csd = NULL; *csd = NULL;
@@ -146,47 +146,47 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
*scr_len = 0; *scr_len = 0;
size_t n = 1026; size_t n = 1026;
if(strncmp(devicePath, "/dev/mmcblk", 11) != 0) return 0; if(strncmp(device_path, "/dev/mmcblk", 11) != 0) return 0;
len = strlen(devicePath) + 19; len = strlen(device_path) + 19;
sysfsPath_csd = malloc(len); sysfs_path_csd = malloc(len);
sysfsPath_cid = malloc(len); sysfs_path_cid = malloc(len);
sysfsPath_scr = malloc(len); sysfs_path_scr = malloc(len);
sysfsPath_ocr = malloc(len); sysfs_path_ocr = malloc(len);
tmpString = malloc(1024); tmp_string = malloc(1024);
if(!sysfsPath_csd || !sysfsPath_cid || !sysfsPath_scr || !sysfsPath_ocr || !tmpString) if(!sysfs_path_csd || !sysfs_path_cid || !sysfs_path_scr || !sysfs_path_ocr || !tmp_string)
{ {
free(sysfsPath_csd); free(sysfs_path_csd);
free(sysfsPath_cid); free(sysfs_path_cid);
free(sysfsPath_scr); free(sysfs_path_scr);
free(sysfsPath_ocr); free(sysfs_path_ocr);
free(tmpString); free(tmp_string);
return 0; return 0;
} }
memset(sysfsPath_csd, 0, len); memset(sysfs_path_csd, 0, len);
memset(sysfsPath_cid, 0, len); memset(sysfs_path_cid, 0, len);
memset(sysfsPath_scr, 0, len); memset(sysfs_path_scr, 0, len);
memset(sysfsPath_ocr, 0, len); memset(sysfs_path_ocr, 0, len);
memset(tmpString, 0, strlen(devicePath) - 5); memset(tmp_string, 0, strlen(device_path) - 5);
memcpy(tmpString, devicePath + 5, strlen(devicePath) - 5); memcpy(tmp_string, device_path + 5, strlen(device_path) - 5);
snprintf(sysfsPath_csd, len, "/sys/block/%s/device/csd", tmpString); snprintf(sysfs_path_csd, len, "/sys/block/%s/device/csd", tmp_string);
snprintf(sysfsPath_cid, len, "/sys/block/%s/device/cid", tmpString); snprintf(sysfs_path_cid, len, "/sys/block/%s/device/cid", tmp_string);
snprintf(sysfsPath_scr, len, "/sys/block/%s/device/scr", tmpString); snprintf(sysfs_path_scr, len, "/sys/block/%s/device/scr", tmp_string);
snprintf(sysfsPath_ocr, len, "/sys/block/%s/device/ocr", tmpString); snprintf(sysfs_path_ocr, len, "/sys/block/%s/device/ocr", tmp_string);
if(access(sysfsPath_csd, R_OK) == 0) if(access(sysfs_path_csd, R_OK) == 0)
{ {
file = fopen(sysfsPath_csd, "r"); file = fopen(sysfs_path_csd, "r");
if(file != NULL) if(file != NULL)
{ {
len = getline(&tmpString, &n, file); len = getline(&tmp_string, &n, file);
if(len > 0) if(len > 0)
{ {
*csd_len = hexs2bin(tmpString, (unsigned char**)csd); *csd_len = Hexs2Bin(tmp_string, (unsigned char**)csd);
if(*csd_len <= 0) if(*csd_len <= 0)
{ {
@@ -199,16 +199,16 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
} }
} }
if(access(sysfsPath_cid, R_OK) == 0) if(access(sysfs_path_cid, R_OK) == 0)
{ {
file = fopen(sysfsPath_cid, "r"); file = fopen(sysfs_path_cid, "r");
if(file != NULL) if(file != NULL)
{ {
len = getline(&tmpString, &n, file); len = getline(&tmp_string, &n, file);
if(len > 0) if(len > 0)
{ {
*cid_len = hexs2bin(tmpString, (unsigned char**)cid); *cid_len = Hexs2Bin(tmp_string, (unsigned char**)cid);
if(*cid_len <= 0) if(*cid_len <= 0)
{ {
@@ -221,16 +221,16 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
} }
} }
if(access(sysfsPath_scr, R_OK) == 0) if(access(sysfs_path_scr, R_OK) == 0)
{ {
file = fopen(sysfsPath_scr, "r"); file = fopen(sysfs_path_scr, "r");
if(file != NULL) if(file != NULL)
{ {
len = getline(&tmpString, &n, file); len = getline(&tmp_string, &n, file);
if(len > 0) if(len > 0)
{ {
*scr_len = hexs2bin(tmpString, (unsigned char**)scr); *scr_len = Hexs2Bin(tmp_string, (unsigned char**)scr);
if(*scr_len <= 0) if(*scr_len <= 0)
{ {
@@ -243,16 +243,16 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
} }
} }
if(access(sysfsPath_ocr, R_OK) == 0) if(access(sysfs_path_ocr, R_OK) == 0)
{ {
file = fopen(sysfsPath_ocr, "r"); file = fopen(sysfs_path_ocr, "r");
if(file != NULL) if(file != NULL)
{ {
len = getline(&tmpString, &n, file); len = getline(&tmp_string, &n, file);
if(len > 0) if(len > 0)
{ {
*ocr_len = hexs2bin(tmpString, (unsigned char**)ocr); *ocr_len = Hexs2Bin(tmp_string, (unsigned char**)ocr);
if(*ocr_len <= 0) if(*ocr_len <= 0)
{ {
@@ -265,11 +265,11 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
} }
} }
free(sysfsPath_csd); free(sysfs_path_csd);
free(sysfsPath_cid); free(sysfs_path_cid);
free(sysfsPath_scr); free(sysfs_path_scr);
free(sysfsPath_ocr); free(sysfs_path_ocr);
free(tmpString); free(tmp_string);
return csd_len != 0 || cid_len != 0 || scr_len != 0 || ocr_len != 0; return csd_len != 0 || cid_len != 0 || scr_len != 0 || ocr_len != 0;
} }

108
linux/ieee1394.c
View File

@@ -15,111 +15,109 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "linux.h"
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h> #include <unistd.h>
uint8_t linux_get_ieee1394_data(const char* devicePath, uint8_t LinuxGetIeee1394Data(const char* device_path,
uint32_t* idModel, uint32_t* id_model,
uint32_t* idVendor, uint32_t* id_vendor,
uint64_t* guid, uint64_t* guid,
char* vendor, char* vendor,
char* model) char* model)
{ {
char* devPath; char* dev_path;
char tmpPath[4096]; char tmp_path[4096];
char resolvedLink[4096]; char resolved_link[4096];
struct stat sb; struct stat sb;
ssize_t len; ssize_t len;
char* rchr; char* rchr;
int found; int found;
FILE* file; FILE* file;
*idModel = 0; *id_model = 0;
*idVendor = 0; *id_vendor = 0;
*guid = 0; *guid = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
memset(resolvedLink, 0, 4096); memset(resolved_link, 0, 4096);
if(strncmp(devicePath, "/dev/sd", 7) != 0 && strncmp(devicePath, "/dev/sr", 7) != 0 && if(strncmp(device_path, "/dev/sd", 7) != 0 && strncmp(device_path, "/dev/sr", 7) != 0 &&
strncmp(devicePath, "/dev/st", 7) != 0) strncmp(device_path, "/dev/st", 7) != 0)
return 0; return 0;
devPath = (char*)devicePath + 5; dev_path = (char*)device_path + 5;
snprintf(tmpPath, 4096, "/sys/block/%s", devPath); snprintf(tmp_path, 4096, "/sys/block/%s", dev_path);
if(stat(tmpPath, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; } if(stat(tmp_path, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; }
len = readlink(tmpPath, resolvedLink, 4096); len = readlink(tmp_path, resolved_link, 4096);
if(len == 0) return 0; if(len == 0) return 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "/sys%s", resolvedLink + 2); snprintf(tmp_path, 4096, "/sys%s", resolved_link + 2);
memcpy(resolvedLink, tmpPath, 4096); memcpy(resolved_link, tmp_path, 4096);
while(strstr(resolvedLink, "firewire") != NULL) while(strstr(resolved_link, "firewire") != NULL)
{ {
found = 1; found = 1;
rchr = strrchr(resolvedLink, '/'); rchr = strrchr(resolved_link, '/');
if(rchr == NULL) break; if(rchr == NULL) break;
*rchr = '\0'; *rchr = '\0';
if(strlen(resolvedLink) == 0) break; if(strlen(resolved_link) == 0) break;
snprintf(tmpPath, 4096, "%s/model", resolvedLink); snprintf(tmp_path, 4096, "%s/model", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/vendor", resolvedLink); snprintf(tmp_path, 4096, "%s/vendor", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/guid", resolvedLink); snprintf(tmp_path, 4096, "%s/guid", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
if(!found) continue; if(!found) continue;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/model", resolvedLink); snprintf(tmp_path, 4096, "%s/model", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fscanf(file, "%8x", idModel); fscanf(file, "%8x", id_model);
fclose(file); fclose(file);
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/vendor", resolvedLink); snprintf(tmp_path, 4096, "%s/vendor", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fscanf(file, "%8x", idVendor); fscanf(file, "%8x", id_vendor);
fclose(file); fclose(file);
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/guid", resolvedLink); snprintf(tmp_path, 4096, "%s/guid", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fscanf(file, "%16lx", guid); fscanf(file, "%16lx", guid);
@@ -127,12 +125,12 @@ uint8_t linux_get_ieee1394_data(const char* devicePath,
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/model_name", resolvedLink); snprintf(tmp_path, 4096, "%s/model_name", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fread(model, 256, 1, file); fread(model, 256, 1, file);
@@ -140,12 +138,12 @@ uint8_t linux_get_ieee1394_data(const char* devicePath,
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/vendor_name", resolvedLink); snprintf(tmp_path, 4096, "%s/vendor_name", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fread(vendor, 256, 1, file); fread(vendor, 256, 1, file);

73
linux/linux.h
View File

@@ -15,19 +15,23 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#ifndef DICREMOTE_LINUX_H #ifndef DICREMOTE_LINUX_LINUX_H_
#define DICREMOTE_LINUX_H #define DICREMOTE_LINUX_LINUX_H_
#include "../dicmote.h" #include "../dicmote.h"
#define PATH_SYS_DEVBLOCK "/sys/block" #define PATH_SYS_DEVBLOCK "/sys/block"
DeviceInfoList* linux_list_devices();
int linux_open_device(const char* device_path); DeviceInfoList* LinuxListDevices();
int32_t linux_get_device_type(const char* devicePath);
int32_t linux_send_scsi_command(int device_fd, int LinuxOpenDevice(const char* device_path);
int32_t LinuxGetDeviceType(const char* device_path);
int32_t LinuxSendScsiCommand(int device_fd,
char* cdb, char* cdb,
char* buffer, char* buffer,
char** senseBuffer, char** sense_buffer,
uint32_t timeout, uint32_t timeout,
int32_t direction, int32_t direction,
uint32_t* duration, uint32_t* duration,
@@ -35,7 +39,8 @@ int32_t linux_send_scsi_command(int device_fd,
uint32_t cdb_len, uint32_t cdb_len,
uint32_t* buf_len, uint32_t* buf_len,
uint32_t* sense_len); uint32_t* sense_len);
int32_t linux_get_sdhci_registers(const char* devicePath,
int32_t LinuxGetSdhciRegisters(const char* device_path,
char** csd, char** csd,
char** cid, char** cid,
char** ocr, char** ocr,
@@ -44,55 +49,62 @@ int32_t linux_get_sdhci_registers(const char* devicePath,
uint32_t* cid_len, uint32_t* cid_len,
uint32_t* ocr_len, uint32_t* ocr_len,
uint32_t* scr_len); uint32_t* scr_len);
uint8_t linux_get_usb_data(const char* devicePath,
uint16_t* descLen, uint8_t LinuxGetUsbData(const char* device_path,
uint16_t* desc_len,
char* descriptors, char* descriptors,
uint16_t* idVendor, uint16_t* id_vendor,
uint16_t* idProduct, uint16_t* id_product,
char* manufacturer, char* manufacturer,
char* product, char* product,
char* serial); char* serial);
uint8_t linux_get_ieee1394_data(const char* devicePath,
uint32_t* idModel, uint8_t LinuxGetIeee1394Data(const char* device_path,
uint32_t* idVendor, uint32_t* id_model,
uint32_t* id_vendor,
uint64_t* guid, uint64_t* guid,
char* vendor, char* vendor,
char* model); char* model);
uint8_t linux_get_pcmcia_data(const char* devicePath, uint16_t* cisLen, char* cis);
int32_t linux_send_ata_chs_command(int device_fd, uint8_t LinuxGetPcmciaData(const char* device_path, uint16_t* cis_len, char* cis);
int32_t LinuxSendAtaChsCommand(int device_fd,
AtaRegistersChs registers, AtaRegistersChs registers,
AtaErrorRegistersChs* errorRegisters, AtaErrorRegistersChs* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);
int32_t linux_send_ata_lba28_command(int device_fd,
int32_t LinuxSendAtaLba28Command(int device_fd,
AtaRegistersLba28 registers, AtaRegistersLba28 registers,
AtaErrorRegistersLba28* errorRegisters, AtaErrorRegistersLba28* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);
int32_t linux_send_ata_lba48_command(int device_fd,
int32_t LinuxSendAtaLba48Command(int device_fd,
AtaRegistersLba48 registers, AtaRegistersLba48 registers,
AtaErrorRegistersLba48* errorRegisters, AtaErrorRegistersLba48* error_registers,
uint8_t protocol, uint8_t protocol,
uint8_t transferRegister, uint8_t transfer_register,
char* buffer, char* buffer,
uint32_t timeout, uint32_t timeout,
uint8_t transferBlocks, uint8_t transfer_blocks,
uint32_t* duration, uint32_t* duration,
uint32_t* sense, uint32_t* sense,
uint32_t* buf_len); uint32_t* buf_len);
int32_t linux_send_sdhci_command(int device_fd,
int32_t LinuxSendSdhciCommand(int device_fd,
uint8_t command, uint8_t command,
uint8_t write, uint8_t write,
uint8_t application, uint8_t application,
@@ -105,4 +117,5 @@ int32_t linux_send_sdhci_command(int device_fd,
uint32_t* response, uint32_t* response,
uint32_t* duration, uint32_t* duration,
uint32_t* sense); uint32_t* sense);
#endif // DICREMOTE_LINUX_H
#endif // DICREMOTE_LINUX_LINUX_H_

198
linux/list_devices.c
View File

@@ -28,15 +28,15 @@
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
DeviceInfoList* linux_list_devices() DeviceInfoList* LinuxListDevices()
{ {
DIR* dir; DIR* dir;
struct dirent* dirent; struct dirent* dirent;
struct udev* udev; struct udev* udev;
int hasUdev = false, i; int has_udev = false, i;
DeviceInfoList * listStart = NULL, *listCurrent = NULL, *listNext = NULL; DeviceInfoList * list_start = NULL, *list_current = NULL, *list_next = NULL;
struct udev_device* udev_device; struct udev_device* udev_device;
const char* tmpString; const char* tmp_string;
FILE* file; FILE* file;
char* line_str; char* line_str;
size_t n, ret; size_t n, ret;
@@ -44,7 +44,7 @@ DeviceInfoList* linux_list_devices()
udev = udev_new(); udev = udev_new();
hasUdev = udev != 0; has_udev = udev != 0;
dir = opendir(PATH_SYS_DEVBLOCK); dir = opendir(PATH_SYS_DEVBLOCK);
if(!dir) return NULL; if(!dir) return NULL;
@@ -59,82 +59,82 @@ DeviceInfoList* linux_list_devices()
continue; continue;
} }
listNext = malloc(sizeof(DeviceInfoList)); list_next = malloc(sizeof(DeviceInfoList));
memset(listNext, 0, sizeof(DeviceInfoList)); memset(list_next, 0, sizeof(DeviceInfoList));
if(!listNext) if(!list_next)
{ {
closedir(dir); closedir(dir);
if(hasUdev) udev_unref(udev); if(has_udev) udev_unref(udev);
return listStart; return list_start;
} }
if(!listStart) listStart = listNext; if(!list_start) list_start = list_next;
if(listCurrent) listCurrent->next = listNext; if(list_current) list_current->next = list_next;
snprintf(listNext->this.path, 1024, "/dev/%s", dirent->d_name); snprintf(list_next->this.path, 1024, "/dev/%s", dirent->d_name);
if(hasUdev) if(has_udev)
{ {
udev_device = udev_device_new_from_subsystem_sysname(udev, "block", dirent->d_name); udev_device = udev_device_new_from_subsystem_sysname(udev, "block", dirent->d_name);
if(udev_device) if(udev_device)
{ {
tmpString = udev_device_get_property_value(udev_device, "ID_VENDOR"); tmp_string = udev_device_get_property_value(udev_device, "ID_VENDOR");
if(tmpString) if(tmp_string)
{ {
strncpy(listNext->this.vendor, tmpString, 256); strncpy(list_next->this.vendor, tmp_string, 256);
free((void*)tmpString); free((void*)tmp_string);
} }
tmpString = udev_device_get_property_value(udev_device, "ID_MODEL"); tmp_string = udev_device_get_property_value(udev_device, "ID_MODEL");
if(tmpString) if(tmp_string)
{ {
strncpy(listNext->this.model, tmpString, 256); strncpy(list_next->this.model, tmp_string, 256);
free((void*)tmpString); free((void*)tmp_string);
for(i = 0; i < 256; i++) for(i = 0; i < 256; i++)
{ {
if(listNext->this.model[i] == 0) break; if(list_next->this.model[i] == 0) break;
if(listNext->this.model[i] == '_') listNext->this.model[i] = ' '; if(list_next->this.model[i] == '_') list_next->this.model[i] = ' ';
} }
} }
tmpString = udev_device_get_property_value(udev_device, "ID_SCSI_SERIAL"); tmp_string = udev_device_get_property_value(udev_device, "ID_SCSI_SERIAL");
if(tmpString) if(tmp_string)
{ {
strncpy(listNext->this.serial, tmpString, 256); strncpy(list_next->this.serial, tmp_string, 256);
free((void*)tmpString); free((void*)tmp_string);
} }
else else
{ {
tmpString = udev_device_get_property_value(udev_device, "ID_SERIAL_SHORT"); tmp_string = udev_device_get_property_value(udev_device, "ID_SERIAL_SHORT");
if(tmpString) if(tmp_string)
{ {
strncpy(listNext->this.serial, tmpString, 256); strncpy(list_next->this.serial, tmp_string, 256);
free((void*)tmpString); free((void*)tmp_string);
} }
} }
tmpString = udev_device_get_property_value(udev_device, "ID_BUS"); tmp_string = udev_device_get_property_value(udev_device, "ID_BUS");
if(tmpString) if(tmp_string)
{ {
strncpy(listNext->this.bus, tmpString, 256); strncpy(list_next->this.bus, tmp_string, 256);
free((void*)tmpString); free((void*)tmp_string);
} }
} }
} }
tmpString = malloc(1024); tmp_string = malloc(1024);
memset((void*)tmpString, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmpString, 1024, "%s/%s/device/vendor", PATH_SYS_DEVBLOCK, dirent->d_name); snprintf((char*)tmp_string, 1024, "%s/%s/device/vendor", PATH_SYS_DEVBLOCK, dirent->d_name);
if(access(tmpString, R_OK) == 0 && strlen(listNext->this.vendor) == 0) if(access(tmp_string, R_OK) == 0 && strlen(list_next->this.vendor) == 0)
{ {
file = fopen(tmpString, "rb"); file = fopen(tmp_string, "rb");
if(file != NULL) if(file != NULL)
{ {
@@ -145,15 +145,14 @@ DeviceInfoList* linux_list_devices()
if(ret > 0 && line_str != NULL) if(ret > 0 && line_str != NULL)
{ {
strncpy(listNext->this.vendor, line_str, 256); strncpy(list_next->this.vendor, line_str, 256);
for(i = 255; i >= 0; i--) for(i = 255; i >= 0; i--)
{ {
if(listNext->this.vendor[i] == 0) if(list_next->this.vendor[i] == 0) continue;
continue;
else if(listNext->this.vendor[i] == 0x0A || listNext->this.vendor[i] == 0x0D || else if(list_next->this.vendor[i] == 0x0A || list_next->this.vendor[i] == 0x0D ||
listNext->this.vendor[i] == ' ') list_next->this.vendor[i] == ' ')
listNext->this.vendor[i] = 0; list_next->this.vendor[i] = 0;
else else
break; break;
} }
@@ -165,18 +164,18 @@ DeviceInfoList* linux_list_devices()
} }
else if(strncmp(dirent->d_name, "loop", 4) == 0) else if(strncmp(dirent->d_name, "loop", 4) == 0)
{ {
strncpy(listNext->this.vendor, "Linux", 256); strncpy(list_next->this.vendor, "Linux", 256);
} }
free((void*)tmpString); free((void*)tmp_string);
tmpString = malloc(1024); tmp_string = malloc(1024);
memset((void*)tmpString, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmpString, 1024, "%s/%s/device/model", PATH_SYS_DEVBLOCK, dirent->d_name); snprintf((char*)tmp_string, 1024, "%s/%s/device/model", PATH_SYS_DEVBLOCK, dirent->d_name);
if(access(tmpString, R_OK) == 0 && if(access(tmp_string, R_OK) == 0 &&
(strlen(listNext->this.model) == 0 || strncmp(listNext->this.bus, "ata", 3) == 0)) (strlen(list_next->this.model) == 0 || strncmp(list_next->this.bus, "ata", 3) == 0))
{ {
file = fopen(tmpString, "rb"); file = fopen(tmp_string, "rb");
if(file != NULL) if(file != NULL)
{ {
@@ -187,15 +186,14 @@ DeviceInfoList* linux_list_devices()
if(ret > 0 && line_str != NULL) if(ret > 0 && line_str != NULL)
{ {
strncpy(listNext->this.model, line_str, 256); strncpy(list_next->this.model, line_str, 256);
for(i = 255; i >= 0; i--) for(i = 255; i >= 0; i--)
{ {
if(listNext->this.model[i] == 0) if(list_next->this.model[i] == 0) continue;
continue;
else if(listNext->this.model[i] == 0x0A || listNext->this.model[i] == 0x0D || else if(list_next->this.model[i] == 0x0A || list_next->this.model[i] == 0x0D ||
listNext->this.model[i] == ' ') list_next->this.model[i] == ' ')
listNext->this.model[i] = 0; list_next->this.model[i] = 0;
else else
break; break;
} }
@@ -207,17 +205,17 @@ DeviceInfoList* linux_list_devices()
} }
else if(strncmp(dirent->d_name, "loop", 4) == 0) else if(strncmp(dirent->d_name, "loop", 4) == 0)
{ {
strncpy(listNext->this.model, "Linux", 256); strncpy(list_next->this.model, "Linux", 256);
} }
free((void*)tmpString); free((void*)tmp_string);
tmpString = malloc(1024); tmp_string = malloc(1024);
memset((void*)tmpString, 0, 1024); memset((void*)tmp_string, 0, 1024);
snprintf((char*)tmpString, 1024, "%s/%s/device/serial", PATH_SYS_DEVBLOCK, dirent->d_name); snprintf((char*)tmp_string, 1024, "%s/%s/device/serial", PATH_SYS_DEVBLOCK, dirent->d_name);
if(access(tmpString, R_OK) == 0 && (strlen(listNext->this.serial) == 0)) if(access(tmp_string, R_OK) == 0 && (strlen(list_next->this.serial) == 0))
{ {
file = fopen(tmpString, "rb"); file = fopen(tmp_string, "rb");
if(file != NULL) if(file != NULL)
{ {
@@ -228,15 +226,14 @@ DeviceInfoList* linux_list_devices()
if(ret > 0 && line_str != NULL) if(ret > 0 && line_str != NULL)
{ {
strncpy(listNext->this.serial, line_str, 256); strncpy(list_next->this.serial, line_str, 256);
for(i = 255; i >= 0; i--) for(i = 255; i >= 0; i--)
{ {
if(listNext->this.serial[i] == 0) if(list_next->this.serial[i] == 0) continue;
continue;
else if(listNext->this.serial[i] == 0x0A || listNext->this.serial[i] == 0x0D || else if(list_next->this.serial[i] == 0x0A || list_next->this.serial[i] == 0x0D ||
listNext->this.serial[i] == ' ') list_next->this.serial[i] == ' ')
listNext->this.serial[i] = 0; list_next->this.serial[i] = 0;
else else
break; break;
} }
@@ -246,64 +243,63 @@ DeviceInfoList* linux_list_devices()
fclose(file); fclose(file);
} }
} }
free((void*)tmpString); free((void*)tmp_string);
if(strlen(listNext->this.vendor) == 0 || strncmp(listNext->this.vendor, "ATA", 3) == 0) if(strlen(list_next->this.vendor) == 0 || strncmp(list_next->this.vendor, "ATA", 3) == 0)
{ {
if(strlen(listNext->this.model) > 0) if(strlen(list_next->this.model) > 0)
{ {
tmpString = malloc(256); tmp_string = malloc(256);
strncpy((void*)tmpString, listNext->this.model, 256); strncpy((void*)tmp_string, list_next->this.model, 256);
chrptr = strchr(tmpString, ' '); chrptr = strchr(tmp_string, ' ');
if(chrptr) if(chrptr)
{ {
memset(&listNext->this.vendor, 0, 256); memset(&list_next->this.vendor, 0, 256);
memset(&listNext->this.model, 0, 256); memset(&list_next->this.model, 0, 256);
strncpy(listNext->this.vendor, tmpString, chrptr - tmpString); strncpy(list_next->this.vendor, tmp_string, chrptr - tmp_string);
strncpy(listNext->this.model, chrptr + 1, 256 - (chrptr - tmpString) - 1); strncpy(list_next->this.model, chrptr + 1, 256 - (chrptr - tmp_string) - 1);
} }
free((void*)tmpString); free((void*)tmp_string);
} }
} }
// TODO: Get better device type from sysfs paths // TODO: Get better device type from sysfs paths
if(strlen(listNext->this.bus) == 0) if(strlen(list_next->this.bus) == 0)
{ {
if(strncmp(dirent->d_name, "loop", 4) == 0) if(strncmp(dirent->d_name, "loop", 4) == 0) strncpy(list_next->this.bus, "loop", 4);
strncpy(listNext->this.bus, "loop", 4);
else if(strncmp(dirent->d_name, "nvme", 4) == 0) else if(strncmp(dirent->d_name, "nvme", 4) == 0)
strncpy(listNext->this.bus, "NVMe", 4); strncpy(list_next->this.bus, "NVMe", 4);
else if(strncmp(dirent->d_name, "mmc", 3) == 0) else if(strncmp(dirent->d_name, "mmc", 3) == 0)
strncpy(listNext->this.bus, "MMC/SD", 6); strncpy(list_next->this.bus, "MMC/SD", 6);
} }
else else
{ {
for(i = 0; i < 256; i++) for(i = 0; i < 256; i++)
{ {
if(listNext->this.bus[i] == 0) break; if(list_next->this.bus[i] == 0) break;
listNext->this.bus[i] = (char)toupper(listNext->this.bus[i]); list_next->this.bus[i] = (char)toupper(list_next->this.bus[i]);
} }
} }
if(strncmp(listNext->this.bus, "ATA", 3) == 0 || strncmp(listNext->this.bus, "ATAPI", 5) == 0 || if(strncmp(list_next->this.bus, "ATA", 3) == 0 || strncmp(list_next->this.bus, "ATAPI", 5) == 0 ||
strncmp(listNext->this.bus, "SCSI", 4) == 0 || strncmp(listNext->this.bus, "USB", 3) == 0 || strncmp(list_next->this.bus, "SCSI", 4) == 0 || strncmp(list_next->this.bus, "USB", 3) == 0 ||
strncmp(listNext->this.bus, "PCMCIA", 6) == 0 || strncmp(listNext->this.bus, "FireWire", 8) == 0 || strncmp(list_next->this.bus, "PCMCIA", 6) == 0 || strncmp(list_next->this.bus, "FireWire", 8) == 0 ||
strncmp(listNext->this.bus, "MMC/SD", 6) == 0) strncmp(list_next->this.bus, "MMC/SD", 6) == 0)
listNext->this.supported = true; list_next->this.supported = true;
else else
listNext->this.supported = false; list_next->this.supported = false;
listCurrent = listNext; list_current = list_next;
dirent = readdir(dir); dirent = readdir(dir);
} }
closedir(dir); closedir(dir);
if(hasUdev) udev_unref(udev); if(has_udev) udev_unref(udev);
return listStart; return list_start;
} }

58
linux/pcmcia.c
View File

@@ -15,8 +15,6 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "linux.h"
#include <dirent.h> #include <dirent.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
@@ -24,55 +22,55 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h> #include <unistd.h>
uint8_t linux_get_pcmcia_data(const char* devicePath, uint16_t* cisLen, char* cis) uint8_t LinuxGetPcmciaData(const char* device_path, uint16_t* cis_len, char* cis)
{ {
char* devPath; char* dev_path;
char tmpPath[4096]; char tmp_path[4096];
char resolvedLink[4096]; char resolved_link[4096];
struct stat sb; struct stat sb;
ssize_t len; ssize_t len;
char* rchr; char* rchr;
FILE* file; FILE* file;
DIR* dir; DIR* dir;
struct dirent* dent; struct dirent* dent;
*cisLen = 0; *cis_len = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
memset(resolvedLink, 0, 4096); memset(resolved_link, 0, 4096);
if(strncmp(devicePath, "/dev/sd", 7) != 0 && strncmp(devicePath, "/dev/sr", 7) != 0 && if(strncmp(device_path, "/dev/sd", 7) != 0 && strncmp(device_path, "/dev/sr", 7) != 0 &&
strncmp(devicePath, "/dev/st", 7) != 0) strncmp(device_path, "/dev/st", 7) != 0)
return 0; return 0;
devPath = (char*)devicePath + 5; dev_path = (char*)device_path + 5;
snprintf(tmpPath, 4096, "/sys/block/%s", devPath); snprintf(tmp_path, 4096, "/sys/block/%s", dev_path);
if(stat(tmpPath, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; } if(stat(tmp_path, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; }
len = readlink(tmpPath, resolvedLink, 4096); len = readlink(tmp_path, resolved_link, 4096);
if(len == 0) return 0; if(len == 0) return 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "/sys%s", resolvedLink + 2); snprintf(tmp_path, 4096, "/sys%s", resolved_link + 2);
memcpy(resolvedLink, tmpPath, 4096); memcpy(resolved_link, tmp_path, 4096);
while(strstr(resolvedLink, "/sys/devices") != NULL) while(strstr(resolved_link, "/sys/devices") != NULL)
{ {
rchr = strrchr(resolvedLink, '/'); rchr = strrchr(resolved_link, '/');
if(rchr == NULL) break; if(rchr == NULL) break;
*rchr = '\0'; *rchr = '\0';
if(strlen(resolvedLink) == 0) break; if(strlen(resolved_link) == 0) break;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/pcmcia_socket", resolvedLink); snprintf(tmp_path, 4096, "%s/pcmcia_socket", resolved_link);
if(access(tmpPath, R_OK) != 0) continue; if(access(tmp_path, R_OK) != 0) continue;
dir = opendir(tmpPath); dir = opendir(tmp_path);
if(!dir) continue; if(!dir) continue;
do do
@@ -85,14 +83,14 @@ uint8_t linux_get_pcmcia_data(const char* devicePath, uint16_t* cisLen, char* ci
if(!dent) continue; if(!dent) continue;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/pcmcia_socket/%s/cis", resolvedLink, dent->d_name); snprintf(tmp_path, 4096, "%s/pcmcia_socket/%s/cis", resolved_link, dent->d_name);
if(access(tmpPath, R_OK) != 0) continue; if(access(tmp_path, R_OK) != 0) continue;
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(!file) return 0; if(!file) return 0;
*cisLen = fread(cis, 65536, 1, file); *cis_len = fread(cis, 65536, 1, file);
return 1; return 1;
} }

10
linux/scsi.c
View File

@@ -23,10 +23,10 @@
#include <string.h> #include <string.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
int32_t linux_send_scsi_command(int device_fd, int32_t LinuxSendScsiCommand(int device_fd,
char* cdb, char* cdb,
char* buffer, char* buffer,
char** senseBuffer, char** sense_buffer,
uint32_t timeout, uint32_t timeout,
int32_t direction, int32_t direction,
uint32_t* duration, uint32_t* duration,
@@ -40,9 +40,9 @@ int32_t linux_send_scsi_command(int device_fd,
*sense_len = 32; *sense_len = 32;
memset(&hdr, 0, sizeof(sg_io_hdr_t)); memset(&hdr, 0, sizeof(sg_io_hdr_t));
*senseBuffer = malloc(*sense_len); *sense_buffer = malloc(*sense_len);
if(!*senseBuffer) return -1; if(!*sense_buffer) return -1;
switch(direction) switch(direction)
{ {
@@ -61,7 +61,7 @@ int32_t linux_send_scsi_command(int device_fd,
hdr.dxfer_len = *buf_len; hdr.dxfer_len = *buf_len;
hdr.dxferp = buffer; hdr.dxferp = buffer;
hdr.cmdp = (unsigned char*)cdb; hdr.cmdp = (unsigned char*)cdb;
hdr.sbp = (unsigned char*)*senseBuffer; hdr.sbp = (unsigned char*)*sense_buffer;
hdr.timeout = timeout; hdr.timeout = timeout;
hdr.flags = SG_FLAG_DIRECT_IO; hdr.flags = SG_FLAG_DIRECT_IO;

2
linux/sdhci.c
View File

@@ -22,7 +22,7 @@
#include <string.h> #include <string.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
int32_t linux_send_sdhci_command(int device_fd, int32_t LinuxSendSdhciCommand(int device_fd,
uint8_t command, uint8_t command,
uint8_t write, uint8_t write,
uint8_t application, uint8_t application,

118
linux/usb.c
View File

@@ -23,114 +23,114 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <unistd.h> #include <unistd.h>
uint8_t linux_get_usb_data(const char* devicePath, uint8_t LinuxGetUsbData(const char* device_path,
uint16_t* descLen, uint16_t* desc_len,
char* descriptors, char* descriptors,
uint16_t* idVendor, uint16_t* id_vendor,
uint16_t* idProduct, uint16_t* id_product,
char* manufacturer, char* manufacturer,
char* product, char* product,
char* serial) char* serial)
{ {
char* devPath; char* dev_path;
char tmpPath[4096]; char tmp_path[4096];
char resolvedLink[4096]; char resolved_link[4096];
struct stat sb; struct stat sb;
ssize_t len; ssize_t len;
char* rchr; char* rchr;
int found = 1; int found = 1;
FILE* file; FILE* file;
*descLen = 0; *desc_len = 0;
*idVendor = 0; *id_vendor = 0;
*idProduct = 0; *id_product = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
memset(resolvedLink, 0, 4096); memset(resolved_link, 0, 4096);
if(strncmp(devicePath, "/dev/sd", 7) != 0 && strncmp(devicePath, "/dev/sr", 7) != 0 && if(strncmp(device_path, "/dev/sd", 7) != 0 && strncmp(device_path, "/dev/sr", 7) != 0 &&
strncmp(devicePath, "/dev/st", 7) != 0) strncmp(device_path, "/dev/st", 7) != 0)
return 0; return 0;
devPath = (char*)devicePath + 5; dev_path = (char*)device_path + 5;
snprintf(tmpPath, 4096, "/sys/block/%s", devPath); snprintf(tmp_path, 4096, "/sys/block/%s", dev_path);
if(stat(tmpPath, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; } if(stat(tmp_path, &sb) != 0 || !S_ISDIR(sb.st_mode)) { return 0; }
len = readlink(tmpPath, resolvedLink, 4096); len = readlink(tmp_path, resolved_link, 4096);
if(len == 0) return 0; if(len == 0) return 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "/sys%s", resolvedLink + 2); snprintf(tmp_path, 4096, "/sys%s", resolved_link + 2);
memcpy(resolvedLink, tmpPath, 4096); memcpy(resolved_link, tmp_path, 4096);
while(strstr(resolvedLink, "usb") != NULL) while(strstr(resolved_link, "usb") != NULL)
{ {
found = 1; found = 1;
rchr = strrchr(resolvedLink, '/'); rchr = strrchr(resolved_link, '/');
if(rchr == NULL) break; if(rchr == NULL) break;
*rchr = '\0'; *rchr = '\0';
if(strlen(resolvedLink) == 0) break; if(strlen(resolved_link) == 0) break;
snprintf(tmpPath, 4096, "%s/descriptors", resolvedLink); snprintf(tmp_path, 4096, "%s/descriptors", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/idProduct", resolvedLink); snprintf(tmp_path, 4096, "%s/idProduct", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/idVendor", resolvedLink); snprintf(tmp_path, 4096, "%s/idVendor", resolved_link);
if(access(tmpPath, R_OK) != 0) found = 0; if(access(tmp_path, R_OK) != 0) found = 0;
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
if(!found) continue; if(!found) continue;
snprintf(tmpPath, 4096, "%s/descriptors", resolvedLink); snprintf(tmp_path, 4096, "%s/descriptors", resolved_link);
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file == NULL) break; if(file == NULL) break;
*descLen = (uint16_t)fread(descriptors, 4096, 1, file); *desc_len = (uint16_t)fread(descriptors, 4096, 1, file);
fclose(file); fclose(file);
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/idProduct", resolvedLink); snprintf(tmp_path, 4096, "%s/idProduct", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fscanf(file, "%4hx", idProduct); fscanf(file, "%4hx", id_product);
fclose(file); fclose(file);
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/idVendor", resolvedLink); snprintf(tmp_path, 4096, "%s/idVendor", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fscanf(file, "%4hx", idVendor); fscanf(file, "%4hx", id_vendor);
fclose(file); fclose(file);
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/manufacturer", resolvedLink); snprintf(tmp_path, 4096, "%s/manufacturer", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fread(manufacturer, 256, 1, file); fread(manufacturer, 256, 1, file);
@@ -138,12 +138,12 @@ uint8_t linux_get_usb_data(const char* devicePath,
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/product", resolvedLink); snprintf(tmp_path, 4096, "%s/product", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fread(product, 256, 1, file); fread(product, 256, 1, file);
@@ -151,12 +151,12 @@ uint8_t linux_get_usb_data(const char* devicePath,
} }
} }
memset(tmpPath, 0, 4096); memset(tmp_path, 0, 4096);
snprintf(tmpPath, 4096, "%s/serial", resolvedLink); snprintf(tmp_path, 4096, "%s/serial", resolved_link);
if(access(tmpPath, R_OK) == 0) if(access(tmp_path, R_OK) == 0)
{ {
file = fopen(tmpPath, "r"); file = fopen(tmp_path, "r");
if(file != NULL) if(file != NULL)
{ {
fread(serial, 256, 1, file); fread(serial, 256, 1, file);
@@ -167,5 +167,5 @@ uint8_t linux_get_usb_data(const char* devicePath,
break; break;
} }
return *descLen != 0; return *desc_len != 0;
} }

3
list_devices.c
View File

@@ -21,13 +21,12 @@
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
#include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
DeviceInfoList* ListDevices() DeviceInfoList* ListDevices()
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_list_devices(); return LinuxListDevices();
#else #else
return NULL; return NULL;
#endif #endif

275
main.c
View File

@@ -29,57 +29,57 @@
int main() int main()
{ {
struct ifaddrs* ifa;
struct ifaddrs* ifa_start;
int ret;
char ipv4Address[INET_ADDRSTRLEN];
int sockfd, cli_sock;
struct sockaddr_in serv_addr, cli_addr;
socklen_t cli_len;
struct utsname utsname;
DicPacketHello * pkt_server_hello, *pkt_client_hello;
DicPacketHeader* pkt_hdr;
ssize_t recv_size;
char* in_buf;
int skip_next_hdr;
struct DeviceInfoList* deviceInfoList;
DicPacketResListDevs* deviceInfoResponsePacket;
int i;
uint64_t n;
DicPacketNop* pkt_nop;
DicPacketCmdOpen* pkt_dev_open;
int device_fd = -1;
char device_path[1024];
DicPacketResGetDeviceType* pkt_dev_type;
DicPacketCmdScsi* pkt_cmd_scsi;
char* sense_buf;
char* buffer;
char* cdb_buf;
uint32_t duration;
uint32_t sense;
uint32_t sense_len;
char* out_buf;
DicPacketResScsi* pkt_res_scsi;
DicPacketResGetSdhciRegisters* sdhciRegsResponsePacket;
char* csd;
char* cid;
char* ocr;
char* scr;
DicPacketResGetUsbData* pkt_res_usb;
DicPacketResGetFireWireData* pkt_res_firewire;
DicPacketResGetPcmciaData* pkt_res_pcmcia;
DicPacketCmdAtaChs* pkt_cmd_ata_chs;
DicPacketCmdAtaLba28* pkt_cmd_ata_lba28;
DicPacketCmdAtaLba48* pkt_cmd_ata_lba48;
DicPacketResAtaChs* pkt_res_ata_chs;
DicPacketResAtaLba28* pkt_res_ata_lba28;
DicPacketResAtaLba48* pkt_res_ata_lba48;
AtaErrorRegistersChs ata_chs_error_regs; AtaErrorRegistersChs ata_chs_error_regs;
AtaErrorRegistersLba28 ata_lba28_error_regs; AtaErrorRegistersLba28 ata_lba28_error_regs;
AtaErrorRegistersLba48 ata_lba48_error_regs; AtaErrorRegistersLba48 ata_lba48_error_regs;
char device_path[1024];
char* buffer;
char* cdb_buf;
char* cid;
char* csd;
char* in_buf;
char* ocr;
char* out_buf;
char* scr;
char* sense_buf;
char ipv4_address[INET_ADDRSTRLEN];
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; DicPacketCmdSdhci* pkt_cmd_sdhci;
DicPacketHeader* pkt_hdr;
DicPacketHello* pkt_server_hello;
DicPacketHello* pkt_client_hello;
DicPacketNop* pkt_nop;
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; DicPacketResSdhci* pkt_res_sdhci;
int device_fd = -1;
int skip_next_hdr;
int cli_sock, sock_fd;
int ret;
socklen_t cli_len;
ssize_t recv_size;
struct DeviceInfoList* device_info_list;
struct ifaddrs* ifa;
struct ifaddrs* ifa_start;
struct sockaddr_in cli_addr, serv_addr;
struct utsname utsname;
uint32_t duration;
uint32_t sdhci_response[4]; uint32_t sdhci_response[4];
uint32_t sense;
uint32_t sense_len;
uint64_t n;
printf("DiscImageChef Remote Server %s\n", DICMOTE_VERSION); printf("DiscImageChef Remote Server %s\n", DICMOTE_VERSION);
printf("Copyright (C) 2019 Natalia Portillo\n"); printf("Copyright (C) 2019 Natalia Portillo\n");
@@ -95,8 +95,8 @@ int main()
printf("Running under %s %s (%s).\n", utsname.sysname, utsname.release, utsname.machine); printf("Running under %s %s (%s).\n", utsname.sysname, utsname.release, utsname.machine);
printf("Opening socket.\n"); printf("Opening socket.\n");
sockfd = socket(AF_INET, SOCK_STREAM, 0); sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd < 0) if(sock_fd < 0)
{ {
printf("Error %d opening socket.\n", errno); printf("Error %d opening socket.\n", errno);
return 1; return 1;
@@ -106,10 +106,10 @@ int main()
serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(DICMOTE_PORT); serv_addr.sin_port = htons(DICMOTE_PORT);
if(bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) if(bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0)
{ {
printf("Error %d binding socket.\n", errno); printf("Error %d binding socket.\n", errno);
close(sockfd); close(sock_fd);
return 1; return 1;
} }
@@ -128,8 +128,8 @@ int main()
{ {
if(ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) if(ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET)
{ {
inet_ntop(AF_INET, &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr, ipv4Address, INET_ADDRSTRLEN); inet_ntop(AF_INET, &((struct sockaddr_in*)ifa->ifa_addr)->sin_addr, ipv4_address, INET_ADDRSTRLEN);
printf("%s port %d\n", ipv4Address, DICMOTE_PORT); printf("%s port %d\n", ipv4_address, DICMOTE_PORT);
} }
ifa = ifa->ifa_next; ifa = ifa->ifa_next;
@@ -137,12 +137,12 @@ int main()
freeifaddrs(ifa_start); freeifaddrs(ifa_start);
ret = listen(sockfd, 1); ret = listen(sock_fd, 1);
if(ret) if(ret)
{ {
printf("Error %d listening.\n", errno); printf("Error %d listening.\n", errno);
close(sockfd); close(sock_fd);
return 1; return 1;
} }
@@ -151,7 +151,7 @@ int main()
if(!pkt_server_hello) if(!pkt_server_hello)
{ {
printf("Fatal error %d allocating memory.\n", errno); printf("Fatal error %d allocating memory.\n", errno);
close(sockfd); close(sock_fd);
return 1; return 1;
} }
@@ -173,7 +173,7 @@ int main()
if(!pkt_nop) if(!pkt_nop)
{ {
printf("Fatal error %d allocating memory.\n", errno); printf("Fatal error %d allocating memory.\n", errno);
close(sockfd); close(sock_fd);
return 1; return 1;
} }
@@ -190,17 +190,17 @@ int main()
printf("Waiting for a client...\n"); printf("Waiting for a client...\n");
cli_len = sizeof(cli_addr); cli_len = sizeof(cli_addr);
cli_sock = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_len); cli_sock = accept(sock_fd, (struct sockaddr*)&cli_addr, &cli_len);
if(cli_sock < 0) if(cli_sock < 0)
{ {
printf("Error %d accepting incoming connection.\n", errno); printf("Error %d accepting incoming connection.\n", errno);
close(sockfd); close(sock_fd);
return 1; return 1;
} }
inet_ntop(AF_INET, &cli_addr.sin_addr, ipv4Address, INET_ADDRSTRLEN); inet_ntop(AF_INET, &cli_addr.sin_addr, ipv4_address, INET_ADDRSTRLEN);
printf("Client %s connected successfully.\n", ipv4Address); printf("Client %s connected successfully.\n", ipv4_address);
write(cli_sock, pkt_server_hello, sizeof(DicPacketHello)); write(cli_sock, pkt_server_hello, sizeof(DicPacketHello));
@@ -210,7 +210,7 @@ int main()
{ {
printf("Fatal error %d allocating memory.\n", errno); printf("Fatal error %d allocating memory.\n", errno);
close(cli_sock); close(cli_sock);
close(sockfd); close(sock_fd);
free(pkt_server_hello); free(pkt_server_hello);
return 1; return 1;
} }
@@ -352,7 +352,7 @@ int main()
skip_next_hdr = 1; skip_next_hdr = 1;
continue; continue;
case DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES: case DICMOTE_PACKET_TYPE_COMMAND_LIST_DEVICES:
deviceInfoList = 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(pkt_hdr->len);
@@ -368,7 +368,7 @@ int main()
recv(cli_sock, in_buf, pkt_hdr->len, 0); recv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
if(!deviceInfoList) if(!device_info_list)
{ {
pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES; pkt_nop->reason_code = DICMOTE_PACKET_NOP_REASON_ERROR_LIST_DEVICES;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
@@ -378,44 +378,43 @@ int main()
continue; continue;
} }
deviceInfoResponsePacket = malloc(sizeof(DicPacketResListDevs)); pkt_res_devinfo = malloc(sizeof(DicPacketResListDevs));
deviceInfoResponsePacket->devices = DeviceInfoListCount(deviceInfoList); pkt_res_devinfo->devices = DeviceInfoListCount(device_info_list);
n = sizeof(DicPacketResListDevs) + deviceInfoResponsePacket->devices * sizeof(DeviceInfo); n = sizeof(DicPacketResListDevs) + 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 = n;
((DicPacketResListDevs*)in_buf)->devices = deviceInfoResponsePacket->devices; ((DicPacketResListDevs*)in_buf)->devices = pkt_res_devinfo->devices;
free(deviceInfoResponsePacket); free(pkt_res_devinfo);
deviceInfoResponsePacket = (DicPacketResListDevs*)in_buf; pkt_res_devinfo = (DicPacketResListDevs*)in_buf;
in_buf = NULL;
deviceInfoResponsePacket->hdr.id = DICMOTE_PACKET_ID; pkt_res_devinfo->hdr.id = DICMOTE_PACKET_ID;
deviceInfoResponsePacket->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_devinfo->hdr.version = DICMOTE_PACKET_VERSION;
deviceInfoResponsePacket->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES; pkt_res_devinfo->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES;
// Save list start // Save list start
in_buf = (char*)deviceInfoList; in_buf = (char*)device_info_list;
long off = sizeof(DicPacketResListDevs); long off = sizeof(DicPacketResListDevs);
while(deviceInfoList) while(device_info_list)
{ {
memcpy(((char*)deviceInfoResponsePacket) + off, &deviceInfoList->this, sizeof(DeviceInfo)); memcpy(((char*)pkt_res_devinfo) + off, &device_info_list->this, sizeof(DeviceInfo));
deviceInfoList = deviceInfoList->next; device_info_list = device_info_list->next;
off += sizeof(DeviceInfo); off += sizeof(DeviceInfo);
} }
deviceInfoList = (struct DeviceInfoList*)in_buf; device_info_list = (struct DeviceInfoList*)in_buf;
FreeDeviceInfoList(deviceInfoList); FreeDeviceInfoList(device_info_list);
write(cli_sock, deviceInfoResponsePacket, deviceInfoResponsePacket->hdr.len); write(cli_sock, pkt_res_devinfo, pkt_res_devinfo->hdr.len);
free(deviceInfoResponsePacket); free(pkt_res_devinfo);
continue; continue;
case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS: case DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS:
case DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES: case DICMOTE_PACKET_TYPE_RESPONSE_LIST_DEVICES:
case DICMOTE_PACKET_TYPE_RESPONSE_SCSI: case DICMOTE_PACKET_TYPE_RESPONSE_SCSI:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS: case DICMOTE_PACKET_TYPE_RESPONSE_ATA_CHS:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA28: case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_28:
case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA48: case DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA_48:
case DICMOTE_PACKET_TYPE_RESPONSE_SDHCI: case DICMOTE_PACKET_TYPE_RESPONSE_SDHCI:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE: case DICMOTE_PACKET_TYPE_RESPONSE_GET_DEVTYPE:
case DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA: case DICMOTE_PACKET_TYPE_RESPONSE_GET_USB_DATA:
@@ -445,7 +444,7 @@ int main()
pkt_nop->reason_code = pkt_nop->reason_code =
device_fd == -1 ? DICMOTE_PACKET_NOP_REASON_OPEN_ERROR : DICMOTE_PACKET_NOP_REASON_OPEN_OK; device_fd == -1 ? DICMOTE_PACKET_NOP_REASON_OPEN_ERROR : DICMOTE_PACKET_NOP_REASON_OPEN_OK;
pkt_nop->errorNo = errno; pkt_nop->error_no = errno;
memset(&pkt_nop->reason, 0, 256); memset(&pkt_nop->reason, 0, 256);
write(cli_sock, pkt_nop, sizeof(DicPacketNop)); write(cli_sock, pkt_nop, sizeof(DicPacketNop));
@@ -508,13 +507,11 @@ int main()
// 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) if(pkt_cmd_scsi->cdb_len > 0) cdb_buf = in_buf + sizeof(DicPacketCmdScsi);
cdb_buf = in_buf + sizeof(DicPacketCmdScsi);
else else
cdb_buf = NULL; cdb_buf = NULL;
if(pkt_cmd_scsi->buf_len > 0) if(pkt_cmd_scsi->buf_len > 0) buffer = in_buf + pkt_cmd_scsi->cdb_len + sizeof(DicPacketCmdScsi);
buffer = in_buf + pkt_cmd_scsi->cdb_len + sizeof(DicPacketCmdScsi);
else else
buffer = NULL; buffer = NULL;
@@ -576,8 +573,8 @@ int main()
recv(cli_sock, in_buf, pkt_hdr->len, 0); recv(cli_sock, in_buf, pkt_hdr->len, 0);
free(in_buf); free(in_buf);
sdhciRegsResponsePacket = malloc(sizeof(DicPacketResGetSdhciRegisters)); pkt_res_sdhci_registers = malloc(sizeof(DicPacketResGetSdhciRegisters));
if(!sdhciRegsResponsePacket) if(!pkt_res_sdhci_registers)
{ {
printf("Fatal error %d allocating memory for packet, closing connection...\n", errno); printf("Fatal error %d allocating memory for packet, closing connection...\n", errno);
free(pkt_hdr); free(pkt_hdr);
@@ -585,44 +582,44 @@ int main()
continue; continue;
} }
memset(sdhciRegsResponsePacket, 0, sizeof(DicPacketResGetSdhciRegisters)); memset(pkt_res_sdhci_registers, 0, sizeof(DicPacketResGetSdhciRegisters));
sdhciRegsResponsePacket->hdr.id = DICMOTE_PACKET_ID; pkt_res_sdhci_registers->hdr.id = DICMOTE_PACKET_ID;
sdhciRegsResponsePacket->hdr.version = DICMOTE_PACKET_VERSION; pkt_res_sdhci_registers->hdr.version = DICMOTE_PACKET_VERSION;
sdhciRegsResponsePacket->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS; pkt_res_sdhci_registers->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_GET_SDHCI_REGISTERS;
sdhciRegsResponsePacket->hdr.len = sizeof(DicPacketResGetSdhciRegisters); pkt_res_sdhci_registers->hdr.len = sizeof(DicPacketResGetSdhciRegisters);
sdhciRegsResponsePacket->isSdhci = GetSdhciRegisters(device_path, pkt_res_sdhci_registers->is_sdhci = GetSdhciRegisters(device_path,
&csd, &csd,
&cid, &cid,
&ocr, &ocr,
&scr, &scr,
&sdhciRegsResponsePacket->csd_len, &pkt_res_sdhci_registers->csd_len,
&sdhciRegsResponsePacket->cid_len, &pkt_res_sdhci_registers->cid_len,
&sdhciRegsResponsePacket->ocr_len, &pkt_res_sdhci_registers->ocr_len,
&sdhciRegsResponsePacket->scr_len); &pkt_res_sdhci_registers->scr_len);
if(sdhciRegsResponsePacket->csd_len > 0 && csd != NULL) if(pkt_res_sdhci_registers->csd_len > 0 && csd != NULL)
{ {
if(sdhciRegsResponsePacket->csd_len > 16) sdhciRegsResponsePacket->csd_len = 16; if(pkt_res_sdhci_registers->csd_len > 16) pkt_res_sdhci_registers->csd_len = 16;
memcpy(sdhciRegsResponsePacket->csd, csd, sdhciRegsResponsePacket->csd_len); memcpy(pkt_res_sdhci_registers->csd, csd, pkt_res_sdhci_registers->csd_len);
} }
if(sdhciRegsResponsePacket->cid_len > 0 && cid != NULL) if(pkt_res_sdhci_registers->cid_len > 0 && cid != NULL)
{ {
if(sdhciRegsResponsePacket->cid_len > 16) sdhciRegsResponsePacket->cid_len = 16; if(pkt_res_sdhci_registers->cid_len > 16) pkt_res_sdhci_registers->cid_len = 16;
memcpy(sdhciRegsResponsePacket->cid, cid, sdhciRegsResponsePacket->cid_len); memcpy(pkt_res_sdhci_registers->cid, cid, pkt_res_sdhci_registers->cid_len);
} }
if(sdhciRegsResponsePacket->ocr_len > 0 && ocr != NULL) if(pkt_res_sdhci_registers->ocr_len > 0 && ocr != NULL)
{ {
if(sdhciRegsResponsePacket->ocr_len > 4) sdhciRegsResponsePacket->ocr_len = 4; if(pkt_res_sdhci_registers->ocr_len > 4) pkt_res_sdhci_registers->ocr_len = 4;
memcpy(sdhciRegsResponsePacket->ocr, ocr, sdhciRegsResponsePacket->ocr_len); memcpy(pkt_res_sdhci_registers->ocr, ocr, pkt_res_sdhci_registers->ocr_len);
} }
if(sdhciRegsResponsePacket->scr_len > 0 && scr != NULL) if(pkt_res_sdhci_registers->scr_len > 0 && scr != NULL)
{ {
if(sdhciRegsResponsePacket->scr_len > 8) sdhciRegsResponsePacket->scr_len = 8; if(pkt_res_sdhci_registers->scr_len > 8) pkt_res_sdhci_registers->scr_len = 8;
memcpy(sdhciRegsResponsePacket->scr, scr, sdhciRegsResponsePacket->scr_len); memcpy(pkt_res_sdhci_registers->scr, scr, pkt_res_sdhci_registers->scr_len);
} }
free(csd); free(csd);
@@ -630,8 +627,8 @@ int main()
free(scr); free(scr);
free(ocr); free(ocr);
write(cli_sock, sdhciRegsResponsePacket, sdhciRegsResponsePacket->hdr.len); write(cli_sock, pkt_res_sdhci_registers, pkt_res_sdhci_registers->hdr.len);
free(sdhciRegsResponsePacket); 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
@@ -662,11 +659,11 @@ int main()
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 = sizeof(DicPacketResGetUsbData);
pkt_res_usb->isUsb = GetUsbData(device_path, pkt_res_usb->is_usb = GetUsbData(device_path,
&pkt_res_usb->descLen, &pkt_res_usb->desc_len,
pkt_res_usb->descriptors, pkt_res_usb->descriptors,
&pkt_res_usb->idVendor, &pkt_res_usb->id_vendor,
&pkt_res_usb->idProduct, &pkt_res_usb->id_product,
pkt_res_usb->manufacturer, pkt_res_usb->manufacturer,
pkt_res_usb->product, pkt_res_usb->product,
pkt_res_usb->serial); pkt_res_usb->serial);
@@ -703,9 +700,9 @@ int main()
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 = sizeof(DicPacketResGetFireWireData);
pkt_res_firewire->isFireWire = GetFireWireData(device_path, pkt_res_firewire->is_firewire = GetFireWireData(device_path,
&pkt_res_firewire->idModel, &pkt_res_firewire->id_model,
&pkt_res_firewire->idVendor, &pkt_res_firewire->id_vendor,
&pkt_res_firewire->guid, &pkt_res_firewire->guid,
pkt_res_firewire->vendor, pkt_res_firewire->vendor,
pkt_res_firewire->model); pkt_res_firewire->model);
@@ -742,7 +739,7 @@ int main()
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 = sizeof(DicPacketResGetPcmciaData);
pkt_res_pcmcia->isPcmcia = 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);
write(cli_sock, pkt_res_pcmcia, pkt_res_pcmcia->hdr.len); write(cli_sock, pkt_res_pcmcia, pkt_res_pcmcia->hdr.len);
@@ -766,8 +763,7 @@ int main()
// 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) if(pkt_cmd_ata_chs->buf_len > 0) buffer = in_buf + sizeof(DicPacketCmdAtaChs);
buffer = in_buf + sizeof(DicPacketCmdAtaChs);
else else
buffer = NULL; buffer = NULL;
@@ -779,10 +775,10 @@ int main()
pkt_cmd_ata_chs->registers, pkt_cmd_ata_chs->registers,
&ata_chs_error_regs, &ata_chs_error_regs,
pkt_cmd_ata_chs->protocol, pkt_cmd_ata_chs->protocol,
pkt_cmd_ata_chs->transferRegister, pkt_cmd_ata_chs->transfer_register,
buffer, buffer,
pkt_cmd_ata_chs->timeout, pkt_cmd_ata_chs->timeout,
pkt_cmd_ata_chs->transferBlocks, pkt_cmd_ata_chs->transfer_blocks,
&duration, &duration,
&sense, &sense,
&pkt_cmd_ata_chs->buf_len); &pkt_cmd_ata_chs->buf_len);
@@ -816,7 +812,7 @@ int main()
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_LBA28: 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(pkt_hdr->len);
@@ -834,8 +830,7 @@ int main()
// 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) if(pkt_cmd_ata_lba28->buf_len > 0) buffer = in_buf + sizeof(DicPacketCmdAtaLba28);
buffer = in_buf + sizeof(DicPacketCmdAtaLba28);
else else
buffer = NULL; buffer = NULL;
@@ -847,13 +842,13 @@ int main()
pkt_cmd_ata_lba28->registers, pkt_cmd_ata_lba28->registers,
&ata_lba28_error_regs, &ata_lba28_error_regs,
pkt_cmd_ata_lba28->protocol, pkt_cmd_ata_lba28->protocol,
pkt_cmd_ata_lba28->transferRegister, pkt_cmd_ata_lba28->transfer_register,
buffer, buffer,
pkt_cmd_ata_lba28->timeout, pkt_cmd_ata_lba28->timeout,
pkt_cmd_ata_lba28->transferBlocks, pkt_cmd_ata_lba28->transfer_blocks,
&duration, &duration,
&sense, &sense,
&pkt_cmd_ata_chs->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);
@@ -870,7 +865,7 @@ int main()
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba28), buffer, pkt_cmd_ata_lba28->buf_len); if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba28), buffer, 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 = sizeof(DicPacketResAtaLba28) + pkt_cmd_ata_lba28->buf_len;
pkt_res_ata_lba28->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA28; 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 = DICMOTE_PACKET_ID;
@@ -884,7 +879,7 @@ int main()
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_LBA48: 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(pkt_hdr->len);
@@ -902,8 +897,7 @@ int main()
// 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) if(pkt_cmd_ata_lba48->buf_len > 0) buffer = in_buf + sizeof(DicPacketCmdAtaLba48);
buffer = in_buf + sizeof(DicPacketCmdAtaLba48);
else else
buffer = NULL; buffer = NULL;
@@ -915,13 +909,13 @@ int main()
pkt_cmd_ata_lba48->registers, pkt_cmd_ata_lba48->registers,
&ata_lba48_error_regs, &ata_lba48_error_regs,
pkt_cmd_ata_lba48->protocol, pkt_cmd_ata_lba48->protocol,
pkt_cmd_ata_lba48->transferRegister, pkt_cmd_ata_lba48->transfer_register,
buffer, buffer,
pkt_cmd_ata_lba48->timeout, pkt_cmd_ata_lba48->timeout,
pkt_cmd_ata_lba48->transferBlocks, pkt_cmd_ata_lba48->transfer_blocks,
&duration, &duration,
&sense, &sense,
&pkt_cmd_ata_chs->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);
@@ -938,7 +932,7 @@ int main()
if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba48), buffer, pkt_cmd_ata_lba48->buf_len); if(buffer) memcpy(out_buf + sizeof(DicPacketResAtaLba48), buffer, 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 = sizeof(DicPacketResAtaLba48) + pkt_cmd_ata_lba48->buf_len;
pkt_res_ata_lba48->hdr.packet_type = DICMOTE_PACKET_TYPE_RESPONSE_ATA_LBA48; 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 = DICMOTE_PACKET_ID;
@@ -970,8 +964,7 @@ int main()
// 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) if(pkt_cmd_sdhci->buf_len > 0) buffer = in_buf + sizeof(DicPacketCmdSdhci);
buffer = in_buf + sizeof(DicPacketCmdSdhci);
else else
buffer = NULL; buffer = NULL;

4
pcmcia.c
View File

@@ -21,10 +21,10 @@
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
uint8_t GetPcmciaData(const char* devicePath, uint16_t* cisLen, char* cis) uint8_t GetPcmciaData(const char* device_path, uint16_t* cis_len, char* cis)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_get_pcmcia_data(devicePath, cisLen, cis); return LinuxGetPcmciaData(device_path, cis_len, cis);
#else #else
return 0; return 0;
#endif #endif

6
scsi.c
View File

@@ -22,7 +22,7 @@
int32_t SendScsiCommand(int device_fd, int32_t SendScsiCommand(int device_fd,
char* cdb, char* cdb,
char* buffer, char* buffer,
char** senseBuffer, char** sense_buffer,
uint32_t timeout, uint32_t timeout,
int32_t direction, int32_t direction,
uint32_t* duration, uint32_t* duration,
@@ -32,8 +32,8 @@ int32_t SendScsiCommand(int device_fd,
uint32_t* sense_len) uint32_t* sense_len)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_send_scsi_command( return LinuxSendScsiCommand(
device_fd, cdb, buffer, senseBuffer, timeout, direction, duration, sense, cdb_len, buf_len, sense_len); device_fd, cdb, buffer, sense_buffer, timeout, direction, duration, sense, cdb_len, buf_len, sense_len);
#else #else
return -1; return -1;
#endif #endif

2
sdhci.c
View File

@@ -35,7 +35,7 @@ int32_t SendSdhciCommand(int device_fd,
uint32_t* sense) uint32_t* sense)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_send_sdhci_command(device_fd, return LinuxSendSdhciCommand(device_fd,
command, command,
write, write,
application, application,

10
usb.c
View File

@@ -21,17 +21,17 @@
#include "linux/linux.h" #include "linux/linux.h"
#endif #endif
uint8_t GetUsbData(const char* devicePath, uint8_t GetUsbData(const char* device_path,
uint16_t* descLen, uint16_t* desc_len,
char* descriptors, char* descriptors,
uint16_t* idVendor, uint16_t* id_vendor,
uint16_t* idProduct, uint16_t* id_product,
char* manufacturer, char* manufacturer,
char* product, char* product,
char* serial) char* serial)
{ {
#if defined(__linux__) && !defined(__ANDROID__) #if defined(__linux__) && !defined(__ANDROID__)
return linux_get_usb_data(devicePath, descLen, descriptors, idVendor, idProduct, manufacturer, product, serial); return LinuxGetUsbData(device_path, desc_len, descriptors, id_vendor, id_product, manufacturer, product, serial);
#else #else
return 0; return 0;
#endif #endif