Quelle  vhci_driver.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2005-2007 Takahiro Hirofuchi
 */

#include "usbip_common.h"
#include "vhci_driver.h"
#include <limits.h>
#include <netdb.h>
#include <libudev.h>
#include <dirent.h>
#include "sysfs_utils.h"

#undef  PROGNAME
#define PROGNAME "libusbip"

struct usbip_vhci_driver *vhci_driver;
struct udev *udev_context;

static struct usbip_imported_device *
imported_device_init(struct usbip_imported_device *idev, char *busid)
{
 struct udev_device *sudev;

 sudev = udev_device_new_from_subsystem_sysname(udev_context,
             "usb", busid);
 if (!sudev) {
  dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
  goto err;
 }
 read_usb_device(sudev, &idev->udev);
 udev_device_unref(sudev);

 return idev;

err:
 return NULL;
}

static int parse_status(const char *value)
{
 int ret = 0;
 char *c;

 /* skip a header line */
 c = strchr(value, '\n');
 if (!c)
  return -1;
 c++;

 while (*c != '\0') {
  int port, status, speed, devid;
  int sockfd;
  char lbusid[SYSFS_BUS_ID_SIZE];
  struct usbip_imported_device *idev;
  char hub[3];

  ret = sscanf(c, "%2s  %d %d %d %x %u %31s\n",
    hub, &port, &status, &speed,
    &devid, &sockfd, lbusid);

  if (ret < 5) {
   dbg("sscanf failed: %d", ret);
   BUG();
  }

  dbg("hub %s port %d status %d speed %d devid %x",
    hub, port, status, speed, devid);
  dbg("sockfd %u lbusid %s", sockfd, lbusid);

  /* if a device is connected, look at it */
  idev = &vhci_driver->idev[port];
  memset(idev, 0, sizeof(*idev));

  if (strncmp("hs", hub, 2) == 0)
   idev->hub = HUB_SPEED_HIGH;
  else /* strncmp("ss", hub, 2) == 0 */
   idev->hub = HUB_SPEED_SUPER;

  idev->port = port;
  idev->status = status;

  idev->devid = devid;

  idev->busnum = (devid >> 16);
  idev->devnum = (devid & 0x0000ffff);

  if (idev->status != VDEV_ST_NULL
      && idev->status != VDEV_ST_NOTASSIGNED) {
   idev = imported_device_init(idev, lbusid);
   if (!idev) {
    dbg("imported_device_init failed");
    return -1;
   }
  }

  /* go to the next line */
  c = strchr(c, '\n');
  if (!c)
   break;
  c++;
 }

 dbg("exit");

 return 0;
}

#define MAX_STATUS_NAME 18

static int refresh_imported_device_list(void)
{
 const char *attr_status;
 char status[MAX_STATUS_NAME+1] = "status";
 int i, ret;

 for (i = 0; i < vhci_driver->ncontrollers; i++) {
  if (i > 0)
   snprintf(status, sizeof(status), "status.%d", i);

  attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
           status);
  if (!attr_status) {
   err("udev_device_get_sysattr_value failed");
   return -1;
  }

  dbg("controller %d", i);

  ret = parse_status(attr_status);
  if (ret != 0)
   return ret;
 }

 return 0;
}

static int get_nports(struct udev_device *hc_device)
{
 const char *attr_nports;

 attr_nports = udev_device_get_sysattr_value(hc_device, "nports");
 if (!attr_nports) {
  err("udev_device_get_sysattr_value nports failed");
  return -1;
 }

 return (int)strtoul(attr_nports, NULL, 10);
}

static int vhci_hcd_filter(const struct dirent *dirent)
{
 return !strncmp(dirent->d_name, "vhci_hcd.", 9);
}

static int get_ncontrollers(void)
{
 struct dirent **namelist;
 struct udev_device *platform;
 int n;

 platform = udev_device_get_parent(vhci_driver->hc_device);
 if (platform == NULL)
  return -1;

 n = scandir(udev_device_get_syspath(platform), &namelist, vhci_hcd_filter, NULL);
 if (n < 0)
  err("scandir failed");
 else {
  for (int i = 0; i < n; i++)
   free(namelist[i]);
  free(namelist);
 }

 return n;
}

/*
 * Read the given port's record.
 *
 * To avoid buffer overflow we will read the entire line and
 * validate each part's size. The initial buffer is padded by 4 to
 * accommodate the 2 spaces, 1 newline and an additional character
 * which is needed to properly validate the 3rd part without it being
 * truncated to an acceptable length.
 */
static int read_record(int rhport, char *host, unsigned long host_len,
  char *port, unsigned long port_len, char *busid)
{
 int part;
 FILE *file;
 char path[PATH_MAX+1];
 char *buffer, *start, *end;
 char delim[] = {' ', ' ', '\n'};
 int max_len[] = {(int)host_len, (int)port_len, SYSFS_BUS_ID_SIZE};
 size_t buffer_len = host_len + port_len + SYSFS_BUS_ID_SIZE + 4;

 buffer = malloc(buffer_len);
 if (!buffer)
  return -1;

 snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport);

 file = fopen(path, "r");
 if (!file) {
  err("fopen");
  free(buffer);
  return -1;
 }

 if (fgets(buffer, buffer_len, file) == NULL) {
  err("fgets");
  free(buffer);
  fclose(file);
  return -1;
 }
 fclose(file);

 /* validate the length of each of the 3 parts */
 start = buffer;
 for (part = 0; part < 3; part++) {
  end = strchr(start, delim[part]);
  if (end == NULL || (end - start) > max_len[part]) {
   free(buffer);
   return -1;
  }
  start = end + 1;
 }

 if (sscanf(buffer, "%s %s %s\n", host, port, busid) != 3) {
  err("sscanf");
  free(buffer);
  return -1;
 }

 free(buffer);

 return 0;
}

/* ---------------------------------------------------------------------- */

int usbip_vhci_driver_open(void)
{
 int nports;
 struct udev_device *hc_device;

 udev_context = udev_new();
 if (!udev_context) {
  err("udev_new failed");
  return -1;
 }

 /* will be freed in usbip_driver_close() */
 hc_device =
  udev_device_new_from_subsystem_sysname(udev_context,
             USBIP_VHCI_BUS_TYPE,
             USBIP_VHCI_DEVICE_NAME);
 if (!hc_device) {
  err("udev_device_new_from_subsystem_sysname failed");
  goto err;
 }

 nports = get_nports(hc_device);
 if (nports <= 0) {
  err("no available ports");
  goto err;
 }
 dbg("available ports: %d", nports);

 vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver) +
   nports * sizeof(struct usbip_imported_device));
 if (!vhci_driver) {
  err("vhci_driver allocation failed");
  goto err;
 }

 vhci_driver->nports = nports;
 vhci_driver->hc_device = hc_device;
 vhci_driver->ncontrollers = get_ncontrollers();
 dbg("available controllers: %d", vhci_driver->ncontrollers);

 if (vhci_driver->ncontrollers <=0) {
  err("no available usb controllers");
  goto err;
 }

 if (refresh_imported_device_list())
  goto err;

 return 0;

err:
 udev_device_unref(hc_device);

 if (vhci_driver)
  free(vhci_driver);

 vhci_driver = NULL;

 udev_unref(udev_context);

 return -1;
}


void usbip_vhci_driver_close(void)
{
 if (!vhci_driver)
  return;

 udev_device_unref(vhci_driver->hc_device);

 free(vhci_driver);

 vhci_driver = NULL;

 udev_unref(udev_context);
}


int usbip_vhci_refresh_device_list(void)
{

 if (refresh_imported_device_list())
  goto err;

 return 0;
err:
 dbg("failed to refresh device list");
 return -1;
}


int usbip_vhci_get_free_port(uint32_t speed)
{
 for (int i = 0; i < vhci_driver->nports; i++) {

  switch (speed) {
  case USB_SPEED_SUPER:
   if (vhci_driver->idev[i].hub != HUB_SPEED_SUPER)
    continue;
  break;
  default:
   if (vhci_driver->idev[i].hub != HUB_SPEED_HIGH)
    continue;
  break;
  }

  if (vhci_driver->idev[i].status == VDEV_ST_NULL)
   return vhci_driver->idev[i].port;
 }

 return -1;
}

int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid,
  uint32_t speed) {
 char buff[200]; /* what size should be ? */
 char attach_attr_path[SYSFS_PATH_MAX];
 char attr_attach[] = "attach";
 const char *path;
 int ret;

 snprintf(buff, sizeof(buff), "%u %d %u %u",
   port, sockfd, devid, speed);
 dbg("writing: %s", buff);

 path = udev_device_get_syspath(vhci_driver->hc_device);
 snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s",
   path, attr_attach);
 dbg("attach attribute path: %s", attach_attr_path);

 ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff));
 if (ret < 0) {
  dbg("write_sysfs_attribute failed");
  return -1;
 }

 dbg("attached port: %d", port);

 return 0;
}

static unsigned long get_devid(uint8_t busnum, uint8_t devnum)
{
 return (busnum << 16) | devnum;
}

/* will be removed */
int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum,
  uint8_t devnum, uint32_t speed)
{
 int devid = get_devid(busnum, devnum);

 return usbip_vhci_attach_device2(port, sockfd, devid, speed);
}

int usbip_vhci_detach_device(uint8_t port)
{
 char detach_attr_path[SYSFS_PATH_MAX];
 char attr_detach[] = "detach";
 char buff[200]; /* what size should be ? */
 const char *path;
 int ret;

 snprintf(buff, sizeof(buff), "%u", port);
 dbg("writing: %s", buff);

 path = udev_device_get_syspath(vhci_driver->hc_device);
 snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s",
   path, attr_detach);
 dbg("detach attribute path: %s", detach_attr_path);

 ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff));
 if (ret < 0) {
  dbg("write_sysfs_attribute failed");
  return -1;
 }

 dbg("detached port: %d", port);

 return 0;
}

int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev)
{
 char product_name[100];
 char host[NI_MAXHOST] = "unknown host";
 char serv[NI_MAXSERV] = "unknown port";
 char remote_busid[SYSFS_BUS_ID_SIZE];
 int ret;
 int read_record_error = 0;

 if (idev->status == VDEV_ST_NULL || idev->status == VDEV_ST_NOTASSIGNED)
  return 0;

 ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv),
     remote_busid);
 if (ret) {
  err("read_record");
  read_record_error = 1;
 }

 printf("Port %02d: <%s> at %s\n", idev->port,
        usbip_status_string(idev->status),
        usbip_speed_string(idev->udev.speed));

 usbip_names_get_product(product_name, sizeof(product_name),
    idev->udev.idVendor, idev->udev.idProduct);

 printf("       %s\n",  product_name);

 if (!read_record_error) {
  printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid,
         host, serv, remote_busid);
  printf("%10s -> remote bus/dev %03d/%03d\n", " ",
         idev->busnum, idev->devnum);
 } else {
  printf("%10s -> unknown host, remote port and remote busid\n",
         idev->udev.busid);
  printf("%10s -> remote bus/dev %03d/%03d\n", " ",
         idev->busnum, idev->devnum);
 }

 return 0;
}