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