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 70 #define DBG_UDEV_INTEGER(name)\ 71 dbg("%-20s = %x", to_string(name), (int) udev->name) 72 73 #define DBG_UINF_INTEGER(name)\ 74 dbg("%-20s = %x", to_string(name), (int) uinf->name) 75 76 void dump_usb_interface(struct usbip_usb_interface *uinf) 77 { 78 char buff[100]; 79 80 usbip_names_get_class(buff, sizeof(buff), 81 uinf->bInterfaceClass, 82 uinf->bInterfaceSubClass, 83 uinf->bInterfaceProtocol); 84 dbg("%-20s = %s", "Interface(C/SC/P)", buff); 85 } 86 87 void dump_usb_device(struct usbip_usb_device *udev) 88 { 89 char buff[100]; 90 91 dbg("%-20s = %s", "path", udev->path); 92 dbg("%-20s = %s", "busid", udev->busid); 93 94 usbip_names_get_class(buff, sizeof(buff), 95 udev->bDeviceClass, 96 udev->bDeviceSubClass, 97 udev->bDeviceProtocol); 98 dbg("%-20s = %s", "Device(C/SC/P)", buff); 99 100 DBG_UDEV_INTEGER(bcdDevice); 101 102 usbip_names_get_product(buff, sizeof(buff), 103 udev->idVendor, 104 udev->idProduct); 105 dbg("%-20s = %s", "Vendor/Product", buff); 106 107 DBG_UDEV_INTEGER(bNumConfigurations); 108 DBG_UDEV_INTEGER(bNumInterfaces); 109 110 dbg("%-20s = %s", "speed", 111 usbip_speed_string(udev->speed)); 112 113 DBG_UDEV_INTEGER(busnum); 114 DBG_UDEV_INTEGER(devnum); 115 } 116 117 118 int read_attr_value(struct udev_device *dev, const char *name, 119 const char *format) 120 { 121 const char *attr; 122 int num = 0; 123 int ret; 124 125 attr = udev_device_get_sysattr_value(dev, name); 126 if (!attr) { 127 err("udev_device_get_sysattr_value failed"); 128 goto err; 129 } 130 131 /* The client chooses the device configuration 132 * when attaching it so right after being bound 133 * to usbip-host on the server the device will 134 * have no configuration. 135 * Therefore, attributes such as bConfigurationValue 136 * and bNumInterfaces will not exist and sscanf will 137 * fail. Check for these cases and don't treat them 138 * as errors. 139 */ 140 141 ret = sscanf(attr, format, &num); 142 if (ret < 1) { 143 if (strcmp(name, "bConfigurationValue") && 144 strcmp(name, "bNumInterfaces")) { 145 err("sscanf failed for attribute %s", name); 146 goto err; 147 } 148 } 149 150 err: 151 152 return num; 153 } 154 155 156 int read_attr_speed(struct udev_device *dev) 157 { 158 const char *speed; 159 160 speed = udev_device_get_sysattr_value(dev, "speed"); 161 if (!speed) { 162 err("udev_device_get_sysattr_value failed"); 163 goto err; 164 } 165 166 for (int i = 0; speed_strings[i].speed != NULL; i++) { 167 if (!strcmp(speed, speed_strings[i].speed)) 168 return speed_strings[i].num; 169 } 170 171 err: 172 173 return USB_SPEED_UNKNOWN; 174 } 175 176 #define READ_ATTR(object, type, dev, name, format) \ 177 do { \ 178 (object)->name = (type) read_attr_value(dev, to_string(name), \ 179 format); \ 180 } while (0) 181 182 183 int read_usb_device(struct udev_device *sdev, struct usbip_usb_device *udev) 184 { 185 uint32_t busnum, devnum; 186 const char *path, *name; 187 188 READ_ATTR(udev, uint8_t, sdev, bDeviceClass, "%02x\n"); 189 READ_ATTR(udev, uint8_t, sdev, bDeviceSubClass, "%02x\n"); 190 READ_ATTR(udev, uint8_t, sdev, bDeviceProtocol, "%02x\n"); 191 192 READ_ATTR(udev, uint16_t, sdev, idVendor, "%04x\n"); 193 READ_ATTR(udev, uint16_t, sdev, idProduct, "%04x\n"); 194 READ_ATTR(udev, uint16_t, sdev, bcdDevice, "%04x\n"); 195 196 READ_ATTR(udev, uint8_t, sdev, bConfigurationValue, "%02x\n"); 197 READ_ATTR(udev, uint8_t, sdev, bNumConfigurations, "%02x\n"); 198 READ_ATTR(udev, uint8_t, sdev, bNumInterfaces, "%02x\n"); 199 200 READ_ATTR(udev, uint8_t, sdev, devnum, "%d\n"); 201 udev->speed = read_attr_speed(sdev); 202 203 path = udev_device_get_syspath(sdev); 204 name = udev_device_get_sysname(sdev); 205 206 strncpy(udev->path, path, SYSFS_PATH_MAX); 207 strncpy(udev->busid, name, SYSFS_BUS_ID_SIZE); 208 209 sscanf(name, "%u-%u", &busnum, &devnum); 210 udev->busnum = busnum; 211 212 return 0; 213 } 214 215 int read_usb_interface(struct usbip_usb_device *udev, int i, 216 struct usbip_usb_interface *uinf) 217 { 218 char busid[SYSFS_BUS_ID_SIZE]; 219 int size; 220 struct udev_device *sif; 221 222 size = snprintf(busid, sizeof(busid), "%s:%d.%d", 223 udev->busid, udev->bConfigurationValue, i); 224 if (size < 0 || (unsigned int)size >= sizeof(busid)) { 225 err("busid length %i >= %lu or < 0", size, 226 (long unsigned)sizeof(busid)); 227 return -1; 228 } 229 230 sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid); 231 if (!sif) { 232 err("udev_device_new_from_subsystem_sysname %s failed", busid); 233 return -1; 234 } 235 236 READ_ATTR(uinf, uint8_t, sif, bInterfaceClass, "%02x\n"); 237 READ_ATTR(uinf, uint8_t, sif, bInterfaceSubClass, "%02x\n"); 238 READ_ATTR(uinf, uint8_t, sif, bInterfaceProtocol, "%02x\n"); 239 240 return 0; 241 } 242 243 int usbip_names_init(char *f) 244 { 245 return names_init(f); 246 } 247 248 void usbip_names_free(void) 249 { 250 names_free(); 251 } 252 253 void usbip_names_get_product(char *buff, size_t size, uint16_t vendor, 254 uint16_t product) 255 { 256 const char *prod, *vend; 257 258 prod = names_product(vendor, product); 259 if (!prod) 260 prod = "unknown product"; 261 262 263 vend = names_vendor(vendor); 264 if (!vend) 265 vend = "unknown vendor"; 266 267 snprintf(buff, size, "%s : %s (%04x:%04x)", vend, prod, vendor, product); 268 } 269 270 void usbip_names_get_class(char *buff, size_t size, uint8_t class, 271 uint8_t subclass, uint8_t protocol) 272 { 273 const char *c, *s, *p; 274 275 if (class == 0 && subclass == 0 && protocol == 0) { 276 snprintf(buff, size, "(Defined at Interface level) (%02x/%02x/%02x)", class, subclass, protocol); 277 return; 278 } 279 280 p = names_protocol(class, subclass, protocol); 281 if (!p) 282 p = "unknown protocol"; 283 284 s = names_subclass(class, subclass); 285 if (!s) 286 s = "unknown subclass"; 287 288 c = names_class(class); 289 if (!c) 290 c = "unknown class"; 291 292 snprintf(buff, size, "%s / %s / %s (%02x/%02x/%02x)", c, s, p, class, subclass, protocol); 293 } 294