mirror of
https://github.com/aaru-dps/aaruremote.git
synced 2025-12-16 11:14:35 +00:00
396 lines
11 KiB
C
396 lines
11 KiB
C
/*
|
|
* This file is part of the Aaru Remote Server.
|
|
* Copyright (c) 2019-2021 Natalia Portillo.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, version 3.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#ifdef HAS_UDEV
|
|
#include <libudev.h>
|
|
#endif
|
|
|
|
#include "../aaruremote.h"
|
|
#include "linux.h"
|
|
|
|
void *DeviceOpen(const char *device_path)
|
|
{
|
|
DeviceContext *ctx;
|
|
|
|
char *real_device_path = realpath(device_path, NULL);
|
|
if(real_device_path != NULL)
|
|
{
|
|
device_path = real_device_path;
|
|
}
|
|
|
|
ctx = malloc(sizeof(DeviceContext));
|
|
|
|
if(!ctx)
|
|
{
|
|
free(real_device_path);
|
|
return NULL;
|
|
}
|
|
|
|
memset(ctx, 0, sizeof(DeviceContext));
|
|
|
|
ctx->fd = open(device_path, O_RDWR | O_NONBLOCK | O_CREAT);
|
|
|
|
if((ctx->fd < 0) && (errno == EACCES || errno == EROFS)) { ctx->fd = open(device_path, O_RDONLY | O_NONBLOCK); }
|
|
|
|
if(ctx->fd <= 0)
|
|
{
|
|
free(real_device_path);
|
|
free(ctx);
|
|
return NULL;
|
|
}
|
|
|
|
strncpy(ctx->device_path, device_path, 4096);
|
|
|
|
free(real_device_path);
|
|
|
|
return ctx;
|
|
}
|
|
|
|
void DeviceClose(void *device_ctx)
|
|
{
|
|
DeviceContext *ctx = device_ctx;
|
|
|
|
if(!ctx) return;
|
|
|
|
close(ctx->fd);
|
|
|
|
free(ctx);
|
|
}
|
|
|
|
int32_t GetDeviceType(void *device_ctx)
|
|
{
|
|
DeviceContext *ctx = device_ctx;
|
|
|
|
if(!ctx) return -1;
|
|
|
|
#ifdef HAS_UDEV
|
|
struct udev *udev;
|
|
struct udev_device *udev_device;
|
|
const char *tmp_string;
|
|
char *chrptr;
|
|
int32_t device_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
|
|
|
|
udev = udev_new();
|
|
|
|
if(!udev) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
|
|
|
|
chrptr = strrchr(ctx->device_path, '/');
|
|
if(chrptr == 0) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
|
|
|
|
chrptr++;
|
|
if(chrptr == 0) return AARUREMOTE_DEVICE_TYPE_UNKNOWN;
|
|
|
|
udev_device = udev_device_new_from_subsystem_sysname(udev, "block", chrptr);
|
|
if(udev_device)
|
|
{
|
|
tmp_string = udev_device_get_property_value(udev_device, "ID_BUS");
|
|
if(tmp_string)
|
|
{
|
|
if(strncmp(tmp_string, "ata", 3) == 0)
|
|
{
|
|
device_type = AARUREMOTE_DEVICE_TYPE_ATA;
|
|
|
|
free((void *)tmp_string);
|
|
tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE");
|
|
|
|
if(tmp_string)
|
|
{
|
|
// TODO: ATAPI removable non optical disks
|
|
if(strncmp(tmp_string, "cd", 2) == 0) { device_type = AARUREMOTE_DEVICE_TYPE_ATAPI; }
|
|
|
|
free((void *)tmp_string);
|
|
}
|
|
}
|
|
else if(strncmp(tmp_string, "mmc", 3) == 0)
|
|
{
|
|
free((void *)tmp_string);
|
|
tmp_string = malloc(1024);
|
|
|
|
device_type = AARUREMOTE_DEVICE_TYPE_MMC;
|
|
|
|
if(tmp_string)
|
|
{
|
|
memset((void *)tmp_string, 0, 1024);
|
|
snprintf((char *)tmp_string, 1024, "/sys/block/%s/device/scr", chrptr);
|
|
|
|
if(access(tmp_string, R_OK) == 0) device_type = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL;
|
|
|
|
free((void *)tmp_string);
|
|
}
|
|
}
|
|
else if(strncmp(tmp_string, "scsi", 4) == 0 || strncmp(tmp_string, "ieee1394", 8) == 0 ||
|
|
strncmp(tmp_string, "usb", 3) == 0)
|
|
{
|
|
free((void *)tmp_string);
|
|
tmp_string = udev_device_get_property_value(udev_device, "ID_TYPE");
|
|
|
|
if(tmp_string)
|
|
{
|
|
if(strncmp(tmp_string, "cd", 2) == 0 || strncmp(tmp_string, "disk", 4) == 0 ||
|
|
strncmp(tmp_string, "optical", 7) == 0)
|
|
device_type = AARUREMOTE_DEVICE_TYPE_SCSI;
|
|
|
|
free((void *)tmp_string);
|
|
}
|
|
}
|
|
else if(strncmp(tmp_string, "nvme", 4) == 0)
|
|
{
|
|
free((void *)tmp_string);
|
|
device_type = AARUREMOTE_DEVICE_TYPE_NVME;
|
|
}
|
|
}
|
|
}
|
|
|
|
udev_unref(udev);
|
|
|
|
return device_type;
|
|
#else
|
|
int32_t dev_type = AARUREMOTE_DEVICE_TYPE_UNKNOWN;
|
|
const char *dev_name;
|
|
const char *sysfs_path;
|
|
char *dev_path;
|
|
char *dev_path2;
|
|
char *host_no;
|
|
char *scsi_path;
|
|
char *iscsi_path;
|
|
char *spi_path;
|
|
char *fc_path;
|
|
char *sas_path;
|
|
int ret;
|
|
char *chrptr;
|
|
char *sysfs_path_scr;
|
|
FILE *file;
|
|
size_t len = 4096;
|
|
|
|
if(strlen(ctx->device_path) <= 5) return dev_type;
|
|
|
|
if(strstr(ctx->device_path, "nvme")) return AARUREMOTE_DEVICE_TYPE_NVME;
|
|
|
|
dev_name = ctx->device_path + 5;
|
|
|
|
if(strstr(ctx->device_path, "mmcblk"))
|
|
{
|
|
dev_type = AARUREMOTE_DEVICE_TYPE_MMC;
|
|
|
|
sysfs_path_scr = malloc(len);
|
|
|
|
if(sysfs_path_scr)
|
|
{
|
|
snprintf(sysfs_path_scr, len, "/sys/block/%s/device/scr", dev_name);
|
|
|
|
if(access(sysfs_path_scr, F_OK) == 0) dev_type = AARUREMOTE_DEVICE_TYPE_SECURE_DIGITAL;
|
|
|
|
free(sysfs_path_scr);
|
|
}
|
|
|
|
return dev_type;
|
|
}
|
|
|
|
sysfs_path = malloc(len);
|
|
dev_path = malloc(len);
|
|
host_no = malloc(len);
|
|
scsi_path = malloc(len);
|
|
iscsi_path = malloc(len);
|
|
spi_path = malloc(len);
|
|
fc_path = malloc(len);
|
|
sas_path = malloc(len);
|
|
|
|
if(!sysfs_path || !dev_path || !host_no || !scsi_path || !iscsi_path || !spi_path || !fc_path || !sas_path)
|
|
{
|
|
free((void *)sysfs_path);
|
|
free((void *)dev_path);
|
|
free((void *)host_no);
|
|
free((void *)iscsi_path);
|
|
free((void *)scsi_path);
|
|
free((void *)spi_path);
|
|
free((void *)fc_path);
|
|
free((void *)sas_path);
|
|
return dev_type;
|
|
}
|
|
|
|
memset((void *)sysfs_path, 0, len);
|
|
memset((void *)dev_path, 0, len);
|
|
memset((void *)host_no, 0, len);
|
|
memset((void *)iscsi_path, 0, len);
|
|
memset((void *)scsi_path, 0, len);
|
|
memset((void *)spi_path, 0, len);
|
|
memset((void *)fc_path, 0, len);
|
|
memset((void *)sas_path, 0, len);
|
|
|
|
snprintf((char *)sysfs_path, len, "%s/%s/device", PATH_SYS_DEVBLOCK, dev_name);
|
|
|
|
ret = readlink(sysfs_path, dev_path, len);
|
|
|
|
if(ret <= 0)
|
|
{
|
|
free((void *)sysfs_path);
|
|
free((void *)dev_path);
|
|
free((void *)host_no);
|
|
free((void *)iscsi_path);
|
|
free((void *)scsi_path);
|
|
free((void *)spi_path);
|
|
free((void *)fc_path);
|
|
free((void *)sas_path);
|
|
return dev_type;
|
|
}
|
|
|
|
dev_path2 = strrchr(dev_path, '/');
|
|
if(dev_path2)
|
|
{
|
|
++dev_path2;
|
|
}
|
|
else
|
|
{
|
|
dev_path2 = dev_path;
|
|
}
|
|
|
|
chrptr = strchr(dev_path2, '.');
|
|
|
|
if(!chrptr)
|
|
{
|
|
chrptr = strchr(dev_path2, ':');
|
|
}
|
|
|
|
if(!chrptr)
|
|
{
|
|
free((void *)sysfs_path);
|
|
free((void *)dev_path);
|
|
free((void *)host_no);
|
|
free((void *)iscsi_path);
|
|
free((void *)scsi_path);
|
|
free((void *)spi_path);
|
|
free((void *)fc_path);
|
|
free((void *)sas_path);
|
|
return dev_type;
|
|
}
|
|
|
|
memcpy((void*)host_no, dev_path2, (chrptr - dev_path2));
|
|
|
|
snprintf(spi_path, len, "/sys/class/spi_host/host%s", host_no);
|
|
snprintf(fc_path, len, "/sys/class/fc_host/host%s", host_no);
|
|
snprintf(sas_path, len, "/sys/class/sas_host/host%s", host_no);
|
|
snprintf(iscsi_path, len, "/sys/class/iscsi_host/host%s", host_no);
|
|
snprintf(scsi_path, len, "/sys/class/scsi_host/host%s", host_no);
|
|
|
|
if(access(spi_path, F_OK) == 0 || access(fc_path, F_OK) == 0 || access(sas_path, F_OK) == 0 ||
|
|
access(iscsi_path, F_OK) == 0)
|
|
dev_type = AARUREMOTE_DEVICE_TYPE_SCSI;
|
|
else if(access(scsi_path, F_OK) == 0)
|
|
{
|
|
dev_type = AARUREMOTE_DEVICE_TYPE_SCSI;
|
|
memset(scsi_path, 0, len);
|
|
snprintf(scsi_path, len, "/sys/class/scsi_host/host%s/proc_name", host_no);
|
|
if(access(scsi_path, F_OK) == 0)
|
|
{
|
|
file = fopen(scsi_path, "r");
|
|
if(file)
|
|
{
|
|
memset(scsi_path, 0, len);
|
|
ret = getline(&scsi_path, &len, file);
|
|
|
|
len = 4096;
|
|
|
|
fclose(file);
|
|
|
|
if(ret > 0)
|
|
{
|
|
if(strncmp(scsi_path, "ata", 3) == 0 || strncmp(scsi_path, "sata", 4) == 0 ||
|
|
strncmp(scsi_path, "ahci", 4) == 0)
|
|
{
|
|
dev_type = AARUREMOTE_DEVICE_TYPE_ATA;
|
|
memset(scsi_path, 0, len);
|
|
snprintf(scsi_path, len, "%s/%s/removable", PATH_SYS_DEVBLOCK, dev_name);
|
|
|
|
file = fopen(scsi_path, "r");
|
|
if(file)
|
|
{
|
|
ret = (size_t)fread(scsi_path, 1, 1, file);
|
|
if(ret == 1)
|
|
{
|
|
if(scsi_path[0] == '1') dev_type = AARUREMOTE_DEVICE_TYPE_ATAPI;
|
|
}
|
|
fclose(file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
free((void *)sysfs_path);
|
|
free((void *)dev_path);
|
|
free((void *)host_no);
|
|
free((void *)iscsi_path);
|
|
free((void *)scsi_path);
|
|
free((void *)spi_path);
|
|
free((void *)fc_path);
|
|
free((void *)sas_path);
|
|
|
|
return dev_type;
|
|
#endif
|
|
}
|
|
|
|
int32_t ReOpen(void *device_ctx, uint32_t *closeFailed)
|
|
{
|
|
DeviceContext *ctx = device_ctx;
|
|
int ret;
|
|
*closeFailed = 0;
|
|
|
|
if(!ctx) return -1;
|
|
|
|
ret = close(ctx->fd);
|
|
|
|
if(ret < 0)
|
|
{
|
|
*closeFailed = 1;
|
|
return errno;
|
|
}
|
|
|
|
ctx->fd = open(ctx->device_path, O_RDWR | O_NONBLOCK | O_CREAT);
|
|
|
|
if((ctx->fd < 0) && (errno == EACCES || errno == EROFS)) ctx->fd = open(ctx->device_path, O_RDONLY | O_NONBLOCK);
|
|
|
|
return ctx->fd <= 0 ? errno : 0;
|
|
}
|
|
|
|
int32_t OsRead(void *device_ctx, char *buffer, uint64_t offset, uint32_t length, uint32_t *duration)
|
|
{
|
|
DeviceContext *ctx = device_ctx;
|
|
ssize_t ret;
|
|
*duration = 0;
|
|
off_t pos;
|
|
|
|
if(!ctx) return -1;
|
|
|
|
// TODO: Timing
|
|
pos = lseek(ctx->fd, (off_t)offset, SEEK_SET);
|
|
|
|
if(pos < 0) return errno;
|
|
|
|
// TODO: Timing
|
|
ret = read(ctx->fd, (void *)buffer, (size_t)length);
|
|
|
|
return ret < 0 ? errno : 0;
|
|
} |