| /* |
| * Copyright (C) 2005-2007 Takahiro Hirofuchi |
| */ |
| |
| #include "usbip_common.h" |
| #include "vhci_driver.h" |
| #include <limits.h> |
| #include <netdb.h> |
| #include <libudev.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; |
| |
| |
| for (int i = 0; i < vhci_driver->nports; i++) |
| memset(&vhci_driver->idev[i], 0, sizeof(vhci_driver->idev[i])); |
| |
| |
| /* skip a header line */ |
| c = strchr(value, '\n'); |
| if (!c) |
| return -1; |
| c++; |
| |
| while (*c != '\0') { |
| int port, status, speed, devid; |
| unsigned long socket; |
| char lbusid[SYSFS_BUS_ID_SIZE]; |
| |
| ret = sscanf(c, "%d %d %d %x %lx %31s\n", |
| &port, &status, &speed, |
| &devid, &socket, lbusid); |
| |
| if (ret < 5) { |
| dbg("sscanf failed: %d", ret); |
| BUG(); |
| } |
| |
| dbg("port %d status %d speed %d devid %x", |
| port, status, speed, devid); |
| dbg("socket %lx lbusid %s", socket, lbusid); |
| |
| |
| /* if a device is connected, look at it */ |
| { |
| struct usbip_imported_device *idev = &vhci_driver->idev[port]; |
| |
| 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; |
| } |
| |
| static int refresh_imported_device_list(void) |
| { |
| const char *attr_status; |
| |
| attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device, |
| "status"); |
| if (!attr_status) { |
| err("udev_device_get_sysattr_value failed"); |
| return -1; |
| } |
| |
| return parse_status(attr_status); |
| } |
| |
| static int get_nports(void) |
| { |
| const char *attr_nports; |
| |
| attr_nports = udev_device_get_sysattr_value(vhci_driver->hc_device, "nports"); |
| if (!attr_nports) { |
| err("udev_device_get_sysattr_value nports failed"); |
| return -1; |
| } |
| |
| return (int)strtoul(attr_nports, NULL, 10); |
| } |
| |
| /* |
| * 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) |
| { |
| udev_context = udev_new(); |
| if (!udev_context) { |
| err("udev_new failed"); |
| return -1; |
| } |
| |
| vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver)); |
| |
| /* will be freed in usbip_driver_close() */ |
| vhci_driver->hc_device = |
| udev_device_new_from_subsystem_sysname(udev_context, |
| USBIP_VHCI_BUS_TYPE, |
| USBIP_VHCI_DRV_NAME); |
| if (!vhci_driver->hc_device) { |
| err("udev_device_new_from_subsystem_sysname failed"); |
| goto err; |
| } |
| |
| vhci_driver->nports = get_nports(); |
| dbg("available ports: %d", vhci_driver->nports); |
| |
| if (vhci_driver->nports <= 0) { |
| err("no available ports"); |
| goto err; |
| } else if (vhci_driver->nports > MAXNPORT) { |
| err("port number exceeds %d", MAXNPORT); |
| goto err; |
| } |
| |
| if (refresh_imported_device_list()) |
| goto err; |
| |
| return 0; |
| |
| err: |
| udev_device_unref(vhci_driver->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(void) |
| { |
| for (int i = 0; i < vhci_driver->nports; i++) { |
| if (vhci_driver->idev[i].status == VDEV_ST_NULL) |
| return i; |
| } |
| |
| 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; |
| } |