tools/usb/usbip/libsrc/usbip_common.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2005-2007 Takahiro Hirofuchi
   4  */
   5
   6 #include <libudev.h>
   7 #include "usbip_common.h"
   8 #include "names.h"
   9
  10 #undef  PROGNAME
  11 #define PROGNAME "libusbip"
  12
  13 int usbip_use_syslog;
  14 int usbip_use_stderr;
  15 int usbip_use_debug;
  16
  17 extern struct udev *udev_context;
  18
  19 struct speed_string {
  20         int num;
  21         char *speed;
  22         char *desc;
  23 };
  24
  25 static const struct speed_string speed_strings[] = {
  26         { USB_SPEED_UNKNOWN, "unknown", "Unknown Speed"},
  27         { USB_SPEED_LOW,  "1.5", "Low Speed(1.5Mbps)"  },
  28         { USB_SPEED_FULL, "12",  "Full Speed(12Mbps)" },
  29         { USB_SPEED_HIGH, "480", "High Speed(480Mbps)" },
  30         { USB_SPEED_WIRELESS, "53.3-480", "Wireless"},
  31         { USB_SPEED_SUPER, "5000", "Super Speed(5000Mbps)" },
  32         { 0, NULL, NULL }
  33 };
  34
  35 struct portst_string {
  36         int num;
  37         char *desc;
  38 };
  39
  40 static struct portst_string portst_strings[] = {
  41         { SDEV_ST_AVAILABLE,    "Device Available" },
  42         { SDEV_ST_USED,         "Device in Use" },
  43         { SDEV_ST_ERROR,        "Device Error"},
  44         { VDEV_ST_NULL,         "Port Available"},
  45         { VDEV_ST_NOTASSIGNED,  "Port Initializing"},
  46         { VDEV_ST_USED,         "Port in Use"},
  47         { VDEV_ST_ERROR,        "Port Error"},
  48         { 0, NULL}
  49 };
  50
  51 const char *usbip_status_string(int32_t status)
  52 {
  53         for (int i = 0; portst_strings[i].desc != NULL; i++)
  54                 if (portst_strings[i].num == status)
  55                         return portst_strings[i].desc;
  56
  57         return "Unknown Status";
  58 }
  59
  60 const char *usbip_speed_string(int num)
  61 {
  62         for (int i = 0; speed_strings[i].speed != NULL; i++)
  63                 if (speed_strings[i].num == num)
  64                         return speed_strings[i].desc;
  65
  66         return "Unknown Speed";
  67 }
  68
  69 struct op_common_status_string {
  70         int num;
  71         char *desc;
  72 };
  73
  74 static struct op_common_status_string op_common_status_strings[] = {
  75         { ST_OK,        "Request Completed Successfully" },
  76         { ST_NA,        "Request Failed" },
  77         { ST_DEV_BUSY,  "Device busy (exported)" },
  78         { ST_DEV_ERR,   "Device in error state" },
  79         { ST_NODEV,     "Device not found" },
  80         { ST_ERROR,     "Unexpected response" },
  81         { 0, NULL}
  82 };
  83
  84 const char *usbip_op_common_status_string(int status)
  85 {
  86         for (int i = 0; op_common_status_strings[i].desc != NULL; i++)
  87                 if (op_common_status_strings[i].num == status)
  88                         return op_common_status_strings[i].desc;
  89
  90         return "Unknown Op Common Status";
  91 }
  92
  93 #define DBG_UDEV_INTEGER(name)\
  94         dbg("%-20s = %x", to_string(name), (int) udev->name)
  95
  96 #define DBG_UINF_INTEGER(name)\
  97         dbg("%-20s = %x", to_string(name), (int) uinf->name)
  98
  99 void dump_usb_interface(struct usbip_usb_interface *uinf)
 100 {
 101         char buff[100];
 102
 103         usbip_names_get_class(buff, sizeof(buff),
 104                         uinf->bInterfaceClass,
 105                         uinf->bInterfaceSubClass,
 106                         uinf->bInterfaceProtocol);
 107         dbg("%-20s = %s", "Interface(C/SC/P)", buff);
 108 }
 109
 110 void dump_usb_device(struct usbip_usb_device *udev)
 111 {
 112         char buff[100];
 113
 114         dbg("%-20s = %s", "path",  udev->path);
 115         dbg("%-20s = %s", "busid", udev->busid);
 116
 117         usbip_names_get_class(buff, sizeof(buff),
 118                         udev->bDeviceClass,
 119                         udev->bDeviceSubClass,
 120                         udev->bDeviceProtocol);
 121         dbg("%-20s = %s", "Device(C/SC/P)", buff);
 122
 123         DBG_UDEV_INTEGER(bcdDevice);
 124
 125         usbip_names_get_product(buff, sizeof(buff),
 126                         udev->idVendor,
 127                         udev->idProduct);
 128         dbg("%-20s = %s", "Vendor/Product", buff);
 129
 130         DBG_UDEV_INTEGER(bNumConfigurations);
 131         DBG_UDEV_INTEGER(bNumInterfaces);
 132
 133         dbg("%-20s = %s", "speed",
 134                         usbip_speed_string(udev->speed));
 135
 136         DBG_UDEV_INTEGER(busnum);
 137         DBG_UDEV_INTEGER(devnum);
 138 }
 139
 140
 141 int read_attr_value(struct udev_device *dev, const char *name,
 142                     const char *format)
 143 {
 144         const char *attr;
 145         int num = 0;
 146         int ret;
 147
 148         attr = udev_device_get_sysattr_value(dev, name);
 149         if (!attr) {
 150                 err("udev_device_get_sysattr_value failed");
 151                 goto err;
 152         }
 153
 154         /* The client chooses the device configuration
 155          * when attaching it so right after being bound
 156          * to usbip-host on the server the device will
 157          * have no configuration.
 158          * Therefore, attributes such as bConfigurationValue
 159          * and bNumInterfaces will not exist and sscanf will
 160          * fail. Check for these cases and don't treat them
 161          * as errors.
 162          */
 163
 164         ret = sscanf(attr, format, &num);
 165         if (ret < 1) {
 166                 if (strcmp(name, "bConfigurationValue") &&
 167                                 strcmp(name, "bNumInterfaces")) {
 168                         err("sscanf failed for attribute %s", name);
 169                         goto err;
 170                 }
 171         }
 172
 173 err:
 174
 175         return num;
 176 }
 177
 178
 179 int read_attr_speed(struct udev_device *dev)
 180 {
 181         const char *speed;
 182
 183         speed = udev_device_get_sysattr_value(dev, "speed");
 184         if (!speed) {
 185                 err("udev_device_get_sysattr_value failed");
 186                 goto err;
 187         }
 188
 189         for (int i = 0; speed_strings[i].speed != NULL; i++) {
 190                 if (!strcmp(speed, speed_strings[i].speed))
 191                         return speed_strings[i].num;
 192         }
 193
 194 err:
 195
 196         return USB_SPEED_UNKNOWN;
 197 }
 198
 199 #define READ_ATTR(object, type, dev, name, format)                            \
 200         do {                                                                  \
 201                 (object)->name = (type) read_attr_value(dev, to_string(name), \
 202                                                         format);              \
 203         } while (0)
 204
 205
 206 int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev)
 207 {
 208         uint32_t busnum, devnum;
 209         const char *path, *name;
 210
 211         READ_ATTR(udev, uint8_t,  sdev, bDeviceClass,           "%02x\n");
 212         READ_ATTR(udev, uint8_t,  sdev, bDeviceSubClass,        "%02x\n");
 213         READ_ATTR(udev, uint8_t,  sdev, bDeviceProtocol,        "%02x\n");
 214
 215         READ_ATTR(udev, uint16_t, sdev, idVendor,               "%04x\n");
 216         READ_ATTR(udev, uint16_t, sdev, idProduct,              "%04x\n");
 217         READ_ATTR(udev, uint16_t, sdev, bcdDevice,              "%04x\n");
 218
 219         READ_ATTR(udev, uint8_t,  sdev, bConfigurationValue,    "%02x\n");
 220         READ_ATTR(udev, uint8_t,  sdev, bNumConfigurations,     "%02x\n");
 221         READ_ATTR(udev, uint8_t,  sdev, bNumInterfaces,         "%02x\n");
 222
 223         READ_ATTR(udev, uint8_t,  sdev, devnum,                 "%d\n");
 224         udev->speed = read_attr_speed(sdev);
 225
 226         path = udev_device_get_syspath(sdev);
 227         name = udev_device_get_sysname(sdev);
 228
 229         strncpy(udev->path,  path,  SYSFS_PATH_MAX);
 230         strncpy(udev->busid, name, SYSFS_BUS_ID_SIZE);
 231
 232         sscanf(name, "%u-%u", &busnum, &devnum);
 233         udev->busnum = busnum;
 234
 235         return 0;
 236 }
 237
 238 int read_usb_interface(struct usbip_usb_device *udev, int i,
 239                        struct usbip_usb_interface *uinf)
 240 {
 241         char busid[SYSFS_BUS_ID_SIZE];
 242         int size;
 243         struct udev_device *sif;
 244
 245         size = snprintf(busid, sizeof(busid), "%s:%d.%d",
 246                         udev->busid, udev->bConfigurationValue, i);
 247         if (size < 0 || (unsigned int)size >= sizeof(busid)) {
 248                 err("busid length %i >= %lu or < 0", size,
 249                     (long unsigned)sizeof(busid));
 250                 return -1;
 251         }
 252
 253         sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
 254         if (!sif) {
 255                 err("udev_device_new_from_subsystem_sysname %s failed", busid);
 256                 return -1;
 257         }
 258
 259         READ_ATTR(uinf, uint8_t,  sif, bInterfaceClass,         "%02x\n");
 260         READ_ATTR(uinf, uint8_t,  sif, bInterfaceSubClass,      "%02x\n");
 261         READ_ATTR(uinf, uint8_t,  sif, bInterfaceProtocol,      "%02x\n");
 262
 263         return 0;
 264 }
 265
 266 int usbip_names_init(char *f)
 267 {
 268         return names_init(f);
 269 }
 270
 271 void usbip_names_free(void)
 272 {
 273         names_free();
 274 }
 275
 276 void usbip_names_get_product(char *buff, size_t size, uint16_t vendor,
 277                              uint16_t product)
 278 {
 279         const char *prod, *vend;
 280
 281         prod = names_product(vendor, product);
 282         if (!prod)
 283                 prod = "unknown product";
 284
 285
 286         vend = names_vendor(vendor);
 287         if (!vend)
 288                 vend = "unknown vendor";
 289
 290         snprintf(buff, size, "%s : %s (%04x:%04x)", vend, prod, vendor, product);
 291 }
 292
 293 void usbip_names_get_class(char *buff, size_t size, uint8_t class,
 294                            uint8_t subclass, uint8_t protocol)
 295 {
 296         const char *c, *s, *p;
 297
 298         if (class == 0 && subclass == 0 && protocol == 0) {
 299                 snprintf(buff, size, "(Defined at Interface level) (%02x/%02x/%02x)", class, subclass, protocol);
 300                 return;
 301         }
 302
 303         p = names_protocol(class, subclass, protocol);
 304         if (!p)
 305                 p = "unknown protocol";
 306
 307         s = names_subclass(class, subclass);
 308         if (!s)
 309                 s = "unknown subclass";
 310
 311         c = names_class(class);
 312         if (!c)
 313                 c = "unknown class";
 314
 315         snprintf(buff, size, "%s / %s / %s (%02x/%02x/%02x)", c, s, p, class, subclass, protocol);
 316 }