blob: f1b38e866dd7ea48012def1ca8d695deaaea0efb [file] [log] [blame]
/*
* Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
* 2005-2007 Takahiro Hirofuchi
* Copyright (C) 2015-2016 Samsung Electronics
* Igor Kotrasinski <i.kotrasinsk@samsung.com>
* Krzysztof Opasiak <k.opasiak@samsung.com>
*
* 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, either version 2 of the License, or
* (at your option) any later version.
*
* 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 <sys/types.h>
#include <libudev.h>
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <netdb.h>
#include <unistd.h>
#include <dirent.h>
#include <linux/usb/ch9.h>
#include "usbip_common.h"
#include "usbip_network.h"
#include "usbip.h"
static const char usbip_list_usage_string[] =
"usbip list [-p|--parsable] <args>\n"
" -p, --parsable Parsable list format\n"
" -r, --remote=<host> List the exportable USB devices on <host>\n"
" -l, --local List the local USB devices\n";
void usbip_list_usage(void)
{
printf("usage: %s", usbip_list_usage_string);
}
static int get_exported_devices(char *host, int sockfd)
{
char product_name[100];
char class_name[100];
struct op_devlist_reply reply;
uint16_t code = OP_REP_DEVLIST;
struct usbip_usb_device udev;
struct usbip_usb_interface uintf;
unsigned int i;
int rc, j;
rc = usbip_net_send_op_common(sockfd, OP_REQ_DEVLIST, 0);
if (rc < 0) {
dbg("usbip_net_send_op_common failed");
return -1;
}
rc = usbip_net_recv_op_common(sockfd, &code);
if (rc < 0) {
dbg("usbip_net_recv_op_common failed");
return -1;
}
memset(&reply, 0, sizeof(reply));
rc = usbip_net_recv(sockfd, &reply, sizeof(reply));
if (rc < 0) {
dbg("usbip_net_recv_op_devlist failed");
return -1;
}
PACK_OP_DEVLIST_REPLY(0, &reply);
dbg("exportable devices: %d\n", reply.ndev);
if (reply.ndev == 0) {
info("no exportable devices found on %s", host);
return 0;
}
printf("Exportable USB devices\n");
printf("======================\n");
printf(" - %s\n", host);
for (i = 0; i < reply.ndev; i++) {
memset(&udev, 0, sizeof(udev));
rc = usbip_net_recv(sockfd, &udev, sizeof(udev));
if (rc < 0) {
dbg("usbip_net_recv failed: usbip_usb_device[%d]", i);
return -1;
}
usbip_net_pack_usb_device(0, &udev);
usbip_names_get_product(product_name, sizeof(product_name),
udev.idVendor, udev.idProduct);
usbip_names_get_class(class_name, sizeof(class_name),
udev.bDeviceClass, udev.bDeviceSubClass,
udev.bDeviceProtocol);
printf("%11s: %s\n", udev.busid, product_name);
printf("%11s: %s\n", "", udev.path);
printf("%11s: %s\n", "", class_name);
for (j = 0; j < udev.bNumInterfaces; j++) {
rc = usbip_net_recv(sockfd, &uintf, sizeof(uintf));
if (rc < 0) {
err("usbip_net_recv failed: usbip_usb_intf[%d]",
j);
return -1;
}
usbip_net_pack_usb_interface(0, &uintf);
usbip_names_get_class(class_name, sizeof(class_name),
uintf.bInterfaceClass,
uintf.bInterfaceSubClass,
uintf.bInterfaceProtocol);
printf("%11s: %2d - %s\n", "", j, class_name);
}
printf("\n");
}
return 0;
}
static int list_exported_devices(char *host)
{
int rc;
int sockfd;
sockfd = usbip_net_tcp_connect(host, usbip_port_string);
if (sockfd < 0) {
err("could not connect to %s:%s: %s", host,
usbip_port_string, gai_strerror(sockfd));
return -1;
}
dbg("connected to %s:%s", host, usbip_port_string);
rc = get_exported_devices(host, sockfd);
if (rc < 0) {
err("failed to get device list from %s", host);
return -1;
}
close(sockfd);
return 0;
}
static void print_device(const char *busid, const char *vendor,
const char *product, bool parsable)
{
if (parsable)
printf("busid=%s#usbid=%.4s:%.4s#", busid, vendor, product);
else
printf(" - busid %s (%.4s:%.4s)\n", busid, vendor, product);
}
static void print_product_name(char *product_name, bool parsable)
{
if (!parsable)
printf(" %s\n", product_name);
}
static int list_devices(bool parsable)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
const char *path;
const char *idVendor;
const char *idProduct;
const char *bConfValue;
const char *bNumIntfs;
const char *busid;
char product_name[128];
int ret = -1;
/* Create libudev context. */
udev = udev_new();
/* Create libudev device enumeration. */
enumerate = udev_enumerate_new(udev);
/* Take only USB devices that are not hubs and do not have
* the bInterfaceNumber attribute, i.e. are not interfaces.
*/
udev_enumerate_add_match_subsystem(enumerate, "usb");
udev_enumerate_add_nomatch_sysattr(enumerate, "bDeviceClass", "09");
udev_enumerate_add_nomatch_sysattr(enumerate, "bInterfaceNumber", NULL);
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
/* Show information about each device. */
udev_list_entry_foreach(dev_list_entry, devices) {
path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, path);
/* Get device information. */
idVendor = udev_device_get_sysattr_value(dev, "idVendor");
idProduct = udev_device_get_sysattr_value(dev, "idProduct");
bConfValue = udev_device_get_sysattr_value(dev,
"bConfigurationValue");
bNumIntfs = udev_device_get_sysattr_value(dev,
"bNumInterfaces");
busid = udev_device_get_sysname(dev);
if (!idVendor || !idProduct || !bConfValue || !bNumIntfs) {
err("problem getting device attributes: %s",
strerror(errno));
goto err_out;
}
/* Get product name. */
usbip_names_get_product(product_name, sizeof(product_name),
strtol(idVendor, NULL, 16),
strtol(idProduct, NULL, 16));
/* Print information. */
print_device(busid, idVendor, idProduct, parsable);
print_product_name(product_name, parsable);
printf("\n");
udev_device_unref(dev);
}
ret = 0;
err_out:
udev_enumerate_unref(enumerate);
udev_unref(udev);
return ret;
}
static int list_gadget_devices(bool parsable)
{
int ret = -1;
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
const char *path;
const char *driver;
const struct usb_device_descriptor *d_desc;
const char *descriptors;
char product_name[128];
uint16_t idVendor;
char idVendor_buf[8];
uint16_t idProduct;
char idProduct_buf[8];
const char *busid;
udev = udev_new();
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "platform");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, path);
driver = udev_device_get_driver(dev);
/* We only have mechanism to enumerate gadgets bound to vudc */
if (driver == NULL || strcmp(driver, USBIP_DEVICE_DRV_NAME))
continue;
/* Get device information. */
descriptors = udev_device_get_sysattr_value(dev,
VUDC_DEVICE_DESCR_FILE);
if (!descriptors) {
err("problem getting device attributes: %s",
strerror(errno));
goto err_out;
}
d_desc = (const struct usb_device_descriptor *) descriptors;
idVendor = le16toh(d_desc->idVendor);
sprintf(idVendor_buf, "0x%4x", idVendor);
idProduct = le16toh(d_desc->idProduct);
sprintf(idProduct_buf, "0x%4x", idVendor);
busid = udev_device_get_sysname(dev);
/* Get product name. */
usbip_names_get_product(product_name, sizeof(product_name),
le16toh(idVendor),
le16toh(idProduct));
/* Print information. */
print_device(busid, idVendor_buf, idProduct_buf, parsable);
print_product_name(product_name, parsable);
printf("\n");
udev_device_unref(dev);
}
ret = 0;
err_out:
udev_enumerate_unref(enumerate);
udev_unref(udev);
return ret;
}
int usbip_list(int argc, char *argv[])
{
static const struct option opts[] = {
{ "parsable", no_argument, NULL, 'p' },
{ "remote", required_argument, NULL, 'r' },
{ "local", no_argument, NULL, 'l' },
{ "device", no_argument, NULL, 'd' },
{ NULL, 0, NULL, 0 }
};
bool parsable = false;
int opt;
int ret = -1;
if (usbip_names_init(USBIDS_FILE))
err("failed to open %s", USBIDS_FILE);
for (;;) {
opt = getopt_long(argc, argv, "pr:ld", opts, NULL);
if (opt == -1)
break;
switch (opt) {
case 'p':
parsable = true;
break;
case 'r':
ret = list_exported_devices(optarg);
goto out;
case 'l':
ret = list_devices(parsable);
goto out;
case 'd':
ret = list_gadget_devices(parsable);
goto out;
default:
goto err_out;
}
}
err_out:
usbip_list_usage();
out:
usbip_names_free();
return ret;
}