tools/usb/usbip/src/usbip_list.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
   4  *               2005-2007 Takahiro Hirofuchi
   5  * Copyright (C) 2015-2016 Samsung Electronics
   6  *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
   7  *               Krzysztof Opasiak <k.opasiak@samsung.com>
   8  */
   9
  10 #include <sys/types.h>
  11 #include <libudev.h>
  12
  13 #include <errno.h>
  14 #include <stdbool.h>
  15 #include <stdint.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include <getopt.h>
  21 #include <netdb.h>
  22 #include <unistd.h>
  23
  24 #include <dirent.h>
  25
  26 #include <linux/usb/ch9.h>
  27
  28 #include "usbip_common.h"
  29 #include "usbip_network.h"
  30 #include "usbip.h"
  31
  32 static const char usbip_list_usage_string[] =
  33         "usbip list [-p|--parsable] <args>\n"
  34         "    -p, --parsable         Parsable list format\n"
  35         "    -r, --remote=<host>    List the exportable USB devices on <host>\n"
  36         "    -l, --local            List the local USB devices\n"
  37         "    -d, --device           List the local USB gadgets bound to usbip-vudc\n";
  38
  39 void usbip_list_usage(void)
  40 {
  41         printf("usage: %s", usbip_list_usage_string);
  42 }
  43
  44 static int get_exported_devices(char *host, int sockfd)
  45 {
  46         char product_name[100];
  47         char class_name[100];
  48         struct op_devlist_reply reply;
  49         uint16_t code = OP_REP_DEVLIST;
  50         struct usbip_usb_device udev;
  51         struct usbip_usb_interface uintf;
  52         unsigned int i;
  53         int rc, j;
  54         int status;
  55
  56         rc = usbip_net_send_op_common(sockfd, OP_REQ_DEVLIST, 0);
  57         if (rc < 0) {
  58                 dbg("usbip_net_send_op_common failed");
  59                 return -1;
  60         }
  61
  62         rc = usbip_net_recv_op_common(sockfd, &code, &status);
  63         if (rc < 0) {
  64                 err("Exported Device List Request failed - %s\n",
  65                     usbip_op_common_status_string(status));
  66                 return -1;
  67         }
  68
  69         memset(&reply, 0, sizeof(reply));
  70         rc = usbip_net_recv(sockfd, &reply, sizeof(reply));
  71         if (rc < 0) {
  72                 dbg("usbip_net_recv_op_devlist failed");
  73                 return -1;
  74         }
  75         PACK_OP_DEVLIST_REPLY(0, &reply);
  76         dbg("exportable devices: %d\n", reply.ndev);
  77
  78         if (reply.ndev == 0) {
  79                 info("no exportable devices found on %s", host);
  80                 return 0;
  81         }
  82
  83         printf("Exportable USB devices\n");
  84         printf("======================\n");
  85         printf(" - %s\n", host);
  86
  87         for (i = 0; i < reply.ndev; i++) {
  88                 memset(&udev, 0, sizeof(udev));
  89                 rc = usbip_net_recv(sockfd, &udev, sizeof(udev));
  90                 if (rc < 0) {
  91                         dbg("usbip_net_recv failed: usbip_usb_device[%d]", i);
  92                         return -1;
  93                 }
  94                 usbip_net_pack_usb_device(0, &udev);
  95
  96                 usbip_names_get_product(product_name, sizeof(product_name),
  97                                         udev.idVendor, udev.idProduct);
  98                 usbip_names_get_class(class_name, sizeof(class_name),
  99                                       udev.bDeviceClass, udev.bDeviceSubClass,
 100                                       udev.bDeviceProtocol);
 101                 printf("%11s: %s\n", udev.busid, product_name);
 102                 printf("%11s: %s\n", "", udev.path);
 103                 printf("%11s: %s\n", "", class_name);
 104
 105                 for (j = 0; j < udev.bNumInterfaces; j++) {
 106                         rc = usbip_net_recv(sockfd, &uintf, sizeof(uintf));
 107                         if (rc < 0) {
 108                                 err("usbip_net_recv failed: usbip_usb_intf[%d]",
 109                                                 j);
 110
 111                                 return -1;
 112                         }
 113                         usbip_net_pack_usb_interface(0, &uintf);
 114
 115                         usbip_names_get_class(class_name, sizeof(class_name),
 116                                         uintf.bInterfaceClass,
 117                                         uintf.bInterfaceSubClass,
 118                                         uintf.bInterfaceProtocol);
 119                         printf("%11s: %2d - %s\n", "", j, class_name);
 120                 }
 121
 122                 printf("\n");
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int list_exported_devices(char *host)
 129 {
 130         int rc;
 131         int sockfd;
 132
 133         sockfd = usbip_net_tcp_connect(host, usbip_port_string);
 134         if (sockfd < 0) {
 135                 err("could not connect to %s:%s: %s", host,
 136                     usbip_port_string, gai_strerror(sockfd));
 137                 return -1;
 138         }
 139         dbg("connected to %s:%s", host, usbip_port_string);
 140
 141         rc = get_exported_devices(host, sockfd);
 142         if (rc < 0) {
 143                 err("failed to get device list from %s", host);
 144                 return -1;
 145         }
 146
 147         close(sockfd);
 148
 149         return 0;
 150 }
 151
 152 static void print_device(const char *busid, const char *vendor,
 153                          const char *product, bool parsable)
 154 {
 155         if (parsable)
 156                 printf("busid=%s#usbid=%.4s:%.4s#", busid, vendor, product);
 157         else
 158                 printf(" - busid %s (%.4s:%.4s)\n", busid, vendor, product);
 159 }
 160
 161 static void print_product_name(char *product_name, bool parsable)
 162 {
 163         if (!parsable)
 164                 printf("   %s\n", product_name);
 165 }
 166
 167 static int list_devices(bool parsable)
 168 {
 169         struct udev *udev;
 170         struct udev_enumerate *enumerate;
 171         struct udev_list_entry *devices, *dev_list_entry;
 172         struct udev_device *dev;
 173         const char *path;
 174         const char *idVendor;
 175         const char *idProduct;
 176         const char *bConfValue;
 177         const char *bNumIntfs;
 178         const char *busid;
 179         char product_name[128];
 180         int ret = -1;
 181         const char *devpath;
 182
 183         /* Create libudev context. */
 184         udev = udev_new();
 185
 186         /* Create libudev device enumeration. */
 187         enumerate = udev_enumerate_new(udev);
 188
 189         /* Take only USB devices that are not hubs and do not have
 190          * the bInterfaceNumber attribute, i.e. are not interfaces.
 191          */
 192         udev_enumerate_add_match_subsystem(enumerate, "usb");
 193         udev_enumerate_add_nomatch_sysattr(enumerate, "bDeviceClass", "09");
 194         udev_enumerate_add_nomatch_sysattr(enumerate, "bInterfaceNumber", NULL);
 195         udev_enumerate_scan_devices(enumerate);
 196
 197         devices = udev_enumerate_get_list_entry(enumerate);
 198
 199         /* Show information about each device. */
 200         udev_list_entry_foreach(dev_list_entry, devices) {
 201                 path = udev_list_entry_get_name(dev_list_entry);
 202                 dev = udev_device_new_from_syspath(udev, path);
 203
 204                 /* Ignore devices attached to vhci_hcd */
 205                 devpath = udev_device_get_devpath(dev);
 206                 if (strstr(devpath, USBIP_VHCI_DRV_NAME)) {
 207                         dbg("Skip the device %s already attached to %s\n",
 208                             devpath, USBIP_VHCI_DRV_NAME);
 209                         continue;
 210                 }
 211
 212                 /* Get device information. */
 213                 idVendor = udev_device_get_sysattr_value(dev, "idVendor");
 214                 idProduct = udev_device_get_sysattr_value(dev, "idProduct");
 215                 bConfValue = udev_device_get_sysattr_value(dev,
 216                                 "bConfigurationValue");
 217                 bNumIntfs = udev_device_get_sysattr_value(dev,
 218                                 "bNumInterfaces");
 219                 busid = udev_device_get_sysname(dev);
 220                 if (!idVendor || !idProduct || !bConfValue || !bNumIntfs) {
 221                         err("problem getting device attributes: %s",
 222                             strerror(errno));
 223                         goto err_out;
 224                 }
 225
 226                 /* Get product name. */
 227                 usbip_names_get_product(product_name, sizeof(product_name),
 228                                         strtol(idVendor, NULL, 16),
 229                                         strtol(idProduct, NULL, 16));
 230
 231                 /* Print information. */
 232                 print_device(busid, idVendor, idProduct, parsable);
 233                 print_product_name(product_name, parsable);
 234
 235                 printf("\n");
 236
 237                 udev_device_unref(dev);
 238         }
 239
 240         ret = 0;
 241
 242 err_out:
 243         udev_enumerate_unref(enumerate);
 244         udev_unref(udev);
 245
 246         return ret;
 247 }
 248
 249 static int list_gadget_devices(bool parsable)
 250 {
 251         int ret = -1;
 252         struct udev *udev;
 253         struct udev_enumerate *enumerate;
 254         struct udev_list_entry *devices, *dev_list_entry;
 255         struct udev_device *dev;
 256         const char *path;
 257         const char *driver;
 258
 259         const struct usb_device_descriptor *d_desc;
 260         const char *descriptors;
 261         char product_name[128];
 262
 263         uint16_t idVendor;
 264         char idVendor_buf[8];
 265         uint16_t idProduct;
 266         char idProduct_buf[8];
 267         const char *busid;
 268
 269         udev = udev_new();
 270         enumerate = udev_enumerate_new(udev);
 271
 272         udev_enumerate_add_match_subsystem(enumerate, "platform");
 273
 274         udev_enumerate_scan_devices(enumerate);
 275         devices = udev_enumerate_get_list_entry(enumerate);
 276
 277         udev_list_entry_foreach(dev_list_entry, devices) {
 278                 path = udev_list_entry_get_name(dev_list_entry);
 279                 dev = udev_device_new_from_syspath(udev, path);
 280
 281                 driver = udev_device_get_driver(dev);
 282                 /* We only have mechanism to enumerate gadgets bound to vudc */
 283                 if (driver == NULL || strcmp(driver, USBIP_DEVICE_DRV_NAME))
 284                         continue;
 285
 286                 /* Get device information. */
 287                 descriptors = udev_device_get_sysattr_value(dev,
 288                                 VUDC_DEVICE_DESCR_FILE);
 289
 290                 if (!descriptors) {
 291                         err("problem getting device attributes: %s",
 292                             strerror(errno));
 293                         goto err_out;
 294                 }
 295
 296                 d_desc = (const struct usb_device_descriptor *) descriptors;
 297
 298                 idVendor = le16toh(d_desc->idVendor);
 299                 sprintf(idVendor_buf, "0x%4x", idVendor);
 300                 idProduct = le16toh(d_desc->idProduct);
 301                 sprintf(idProduct_buf, "0x%4x", idVendor);
 302                 busid = udev_device_get_sysname(dev);
 303
 304                 /* Get product name. */
 305                 usbip_names_get_product(product_name, sizeof(product_name),
 306                                         le16toh(idVendor),
 307                                         le16toh(idProduct));
 308
 309                 /* Print information. */
 310                 print_device(busid, idVendor_buf, idProduct_buf, parsable);
 311                 print_product_name(product_name, parsable);
 312
 313                 printf("\n");
 314
 315                 udev_device_unref(dev);
 316         }
 317         ret = 0;
 318
 319 err_out:
 320         udev_enumerate_unref(enumerate);
 321         udev_unref(udev);
 322
 323         return ret;
 324 }
 325
 326 int usbip_list(int argc, char *argv[])
 327 {
 328         static const struct option opts[] = {
 329                 { "parsable", no_argument,       NULL, 'p' },
 330                 { "remote",   required_argument, NULL, 'r' },
 331                 { "local",    no_argument,       NULL, 'l' },
 332                 { "device",    no_argument,       NULL, 'd' },
 333                 { NULL,       0,                 NULL,  0  }
 334         };
 335
 336         bool parsable = false;
 337         int opt;
 338         int ret = -1;
 339
 340         if (usbip_names_init(USBIDS_FILE))
 341                 err("failed to open %s", USBIDS_FILE);
 342
 343         for (;;) {
 344                 opt = getopt_long(argc, argv, "pr:ld", opts, NULL);
 345
 346                 if (opt == -1)
 347                         break;
 348
 349                 switch (opt) {
 350                 case 'p':
 351                         parsable = true;
 352                         break;
 353                 case 'r':
 354                         ret = list_exported_devices(optarg);
 355                         goto out;
 356                 case 'l':
 357                         ret = list_devices(parsable);
 358                         goto out;
 359                 case 'd':
 360                         ret = list_gadget_devices(parsable);
 361                         goto out;
 362                 default:
 363                         goto err_out;
 364                 }
 365         }
 366
 367 err_out:
 368         usbip_list_usage();
 369 out:
 370         usbip_names_free();
 371
 372         return ret;
 373 }