1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2005-2007 Takahiro Hirofuchi 4 */ 5 6 #include "usbip_common.h" 7 #include "vhci_driver.h" 8 #include <limits.h> 9 #include <netdb.h> 10 #include <libudev.h> 11 #include <dirent.h> 12 #include "sysfs_utils.h" 13 14 #undef PROGNAME 15 #define PROGNAME "libusbip" 16 17 struct usbip_vhci_driver *vhci_driver; 18 struct udev *udev_context; 19 20 static struct usbip_imported_device * 21 imported_device_init(struct usbip_imported_device *idev, char *busid) 22 { 23 struct udev_device *sudev; 24 25 sudev = udev_device_new_from_subsystem_sysname(udev_context, 26 "usb", busid); 27 if (!sudev) { 28 dbg("udev_device_new_from_subsystem_sysname failed: %s", busid); 29 goto err; 30 } 31 read_usb_device(sudev, &idev->udev); 32 udev_device_unref(sudev); 33 34 return idev; 35 36 err: 37 return NULL; 38 } 39 40 static int parse_status(const char *value) 41 { 42 int ret = 0; 43 char *c; 44 45 /* skip a header line */ 46 c = strchr(value, '\n'); 47 if (!c) 48 return -1; 49 c++; 50 51 while (*c != '\0') { 52 int port, status, speed, devid; 53 int sockfd; 54 char lbusid[SYSFS_BUS_ID_SIZE]; 55 struct usbip_imported_device *idev; 56 char hub[3]; 57 58 ret = sscanf(c, "%2s %d %d %d %x %u %31s\n", 59 hub, &port, &status, &speed, 60 &devid, &sockfd, lbusid); 61 62 if (ret < 5) { 63 dbg("sscanf failed: %d", ret); 64 BUG(); 65 } 66 67 dbg("hub %s port %d status %d speed %d devid %x", 68 hub, port, status, speed, devid); 69 dbg("sockfd %u lbusid %s", sockfd, lbusid); 70 71 /* if a device is connected, look at it */ 72 idev = &vhci_driver->idev[port]; 73 memset(idev, 0, sizeof(*idev)); 74 75 if (strncmp("hs", hub, 2) == 0) 76 idev->hub = HUB_SPEED_HIGH; 77 else /* strncmp("ss", hub, 2) == 0 */ 78 idev->hub = HUB_SPEED_SUPER; 79 80 idev->port = port; 81 idev->status = status; 82 83 idev->devid = devid; 84 85 idev->busnum = (devid >> 16); 86 idev->devnum = (devid & 0x0000ffff); 87 88 if (idev->status != VDEV_ST_NULL 89 && idev->status != VDEV_ST_NOTASSIGNED) { 90 idev = imported_device_init(idev, lbusid); 91 if (!idev) { 92 dbg("imported_device_init failed"); 93 return -1; 94 } 95 } 96 97 /* go to the next line */ 98 c = strchr(c, '\n'); 99 if (!c) 100 break; 101 c++; 102 } 103 104 dbg("exit"); 105 106 return 0; 107 } 108 109 #define MAX_STATUS_NAME 18 110 111 static int refresh_imported_device_list(void) 112 { 113 const char *attr_status; 114 char status[MAX_STATUS_NAME+1] = "status"; 115 int i, ret; 116 117 for (i = 0; i < vhci_driver->ncontrollers; i++) { 118 if (i > 0) 119 snprintf(status, sizeof(status), "status.%d", i); 120 121 attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device, 122 status); 123 if (!attr_status) { 124 err("udev_device_get_sysattr_value failed"); 125 return -1; 126 } 127 128 dbg("controller %d", i); 129 130 ret = parse_status(attr_status); 131 if (ret != 0) 132 return ret; 133 } 134 135 return 0; 136 } 137 138 static int get_nports(struct udev_device *hc_device) 139 { 140 const char *attr_nports; 141 142 attr_nports = udev_device_get_sysattr_value(hc_device, "nports"); 143 if (!attr_nports) { 144 err("udev_device_get_sysattr_value nports failed"); 145 return -1; 146 } 147 148 return (int)strtoul(attr_nports, NULL, 10); 149 } 150 151 static int vhci_hcd_filter(const struct dirent *dirent) 152 { 153 return !strncmp(dirent->d_name, "vhci_hcd.", 9); 154 } 155 156 static int get_ncontrollers(void) 157 { 158 struct dirent **namelist; 159 struct udev_device *platform; 160 int n; 161 162 platform = udev_device_get_parent(vhci_driver->hc_device); 163 if (platform == NULL) 164 return -1; 165 166 n = scandir(udev_device_get_syspath(platform), &namelist, vhci_hcd_filter, NULL); 167 if (n < 0) 168 err("scandir failed"); 169 else { 170 for (int i = 0; i < n; i++) 171 free(namelist[i]); 172 free(namelist); 173 } 174 175 return n; 176 } 177 178 /* 179 * Read the given port's record. 180 * 181 * To avoid buffer overflow we will read the entire line and 182 * validate each part's size. The initial buffer is padded by 4 to 183 * accommodate the 2 spaces, 1 newline and an additional character 184 * which is needed to properly validate the 3rd part without it being 185 * truncated to an acceptable length. 186 */ 187 static int read_record(int rhport, char *host, unsigned long host_len, 188 char *port, unsigned long port_len, char *busid) 189 { 190 int part; 191 FILE *file; 192 char path[PATH_MAX+1]; 193 char *buffer, *start, *end; 194 char delim[] = {' ', ' ', '\n'}; 195 int max_len[] = {(int)host_len, (int)port_len, SYSFS_BUS_ID_SIZE}; 196 size_t buffer_len = host_len + port_len + SYSFS_BUS_ID_SIZE + 4; 197 198 buffer = malloc(buffer_len); 199 if (!buffer) 200 return -1; 201 202 snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport); 203 204 file = fopen(path, "r"); 205 if (!file) { 206 err("fopen"); 207 free(buffer); 208 return -1; 209 } 210 211 if (fgets(buffer, buffer_len, file) == NULL) { 212 err("fgets"); 213 free(buffer); 214 fclose(file); 215 return -1; 216 } 217 fclose(file); 218 219 /* validate the length of each of the 3 parts */ 220 start = buffer; 221 for (part = 0; part < 3; part++) { 222 end = strchr(start, delim[part]); 223 if (end == NULL || (end - start) > max_len[part]) { 224 free(buffer); 225 return -1; 226 } 227 start = end + 1; 228 } 229 230 if (sscanf(buffer, "%s %s %s\n", host, port, busid) != 3) { 231 err("sscanf"); 232 free(buffer); 233 return -1; 234 } 235 236 free(buffer); 237 238 return 0; 239 } 240 241 /* ---------------------------------------------------------------------- */ 242 243 int usbip_vhci_driver_open(void) 244 { 245 int nports; 246 struct udev_device *hc_device; 247 248 udev_context = udev_new(); 249 if (!udev_context) { 250 err("udev_new failed"); 251 return -1; 252 } 253 254 /* will be freed in usbip_driver_close() */ 255 hc_device = 256 udev_device_new_from_subsystem_sysname(udev_context, 257 USBIP_VHCI_BUS_TYPE, 258 USBIP_VHCI_DEVICE_NAME); 259 if (!hc_device) { 260 err("udev_device_new_from_subsystem_sysname failed"); 261 goto err; 262 } 263 264 nports = get_nports(hc_device); 265 if (nports <= 0) { 266 err("no available ports"); 267 goto err; 268 } 269 dbg("available ports: %d", nports); 270 271 vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver) + 272 nports * sizeof(struct usbip_imported_device)); 273 if (!vhci_driver) { 274 err("vhci_driver allocation failed"); 275 goto err; 276 } 277 278 vhci_driver->nports = nports; 279 vhci_driver->hc_device = hc_device; 280 vhci_driver->ncontrollers = get_ncontrollers(); 281 dbg("available controllers: %d", vhci_driver->ncontrollers); 282 283 if (vhci_driver->ncontrollers <=0) { 284 err("no available usb controllers"); 285 goto err; 286 } 287 288 if (refresh_imported_device_list()) 289 goto err; 290 291 return 0; 292 293 err: 294 udev_device_unref(hc_device); 295 296 if (vhci_driver) 297 free(vhci_driver); 298 299 vhci_driver = NULL; 300 301 udev_unref(udev_context); 302 303 return -1; 304 } 305 306 307 void usbip_vhci_driver_close(void) 308 { 309 if (!vhci_driver) 310 return; 311 312 udev_device_unref(vhci_driver->hc_device); 313 314 free(vhci_driver); 315 316 vhci_driver = NULL; 317 318 udev_unref(udev_context); 319 } 320 321 322 int usbip_vhci_refresh_device_list(void) 323 { 324 325 if (refresh_imported_device_list()) 326 goto err; 327 328 return 0; 329 err: 330 dbg("failed to refresh device list"); 331 return -1; 332 } 333 334 335 int usbip_vhci_get_free_port(uint32_t speed) 336 { 337 for (int i = 0; i < vhci_driver->nports; i++) { 338 339 switch (speed) { 340 case USB_SPEED_SUPER: 341 case USB_SPEED_SUPER_PLUS: 342 if (vhci_driver->idev[i].hub != HUB_SPEED_SUPER) 343 continue; 344 break; 345 default: 346 if (vhci_driver->idev[i].hub != HUB_SPEED_HIGH) 347 continue; 348 break; 349 } 350 351 if (vhci_driver->idev[i].status == VDEV_ST_NULL) 352 return vhci_driver->idev[i].port; 353 } 354 355 return -1; 356 } 357 358 int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid, 359 uint32_t speed) { 360 char buff[200]; /* what size should be ? */ 361 char attach_attr_path[SYSFS_PATH_MAX]; 362 char attr_attach[] = "attach"; 363 const char *path; 364 int ret; 365 366 snprintf(buff, sizeof(buff), "%u %d %u %u", 367 port, sockfd, devid, speed); 368 dbg("writing: %s", buff); 369 370 path = udev_device_get_syspath(vhci_driver->hc_device); 371 snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s", 372 path, attr_attach); 373 dbg("attach attribute path: %s", attach_attr_path); 374 375 ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff)); 376 if (ret < 0) { 377 dbg("write_sysfs_attribute failed"); 378 return -1; 379 } 380 381 dbg("attached port: %d", port); 382 383 return 0; 384 } 385 386 static unsigned long get_devid(uint8_t busnum, uint8_t devnum) 387 { 388 return (busnum << 16) | devnum; 389 } 390 391 /* will be removed */ 392 int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum, 393 uint8_t devnum, uint32_t speed) 394 { 395 int devid = get_devid(busnum, devnum); 396 397 return usbip_vhci_attach_device2(port, sockfd, devid, speed); 398 } 399 400 int usbip_vhci_detach_device(uint8_t port) 401 { 402 char detach_attr_path[SYSFS_PATH_MAX]; 403 char attr_detach[] = "detach"; 404 char buff[200]; /* what size should be ? */ 405 const char *path; 406 int ret; 407 408 snprintf(buff, sizeof(buff), "%u", port); 409 dbg("writing: %s", buff); 410 411 path = udev_device_get_syspath(vhci_driver->hc_device); 412 snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s", 413 path, attr_detach); 414 dbg("detach attribute path: %s", detach_attr_path); 415 416 ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff)); 417 if (ret < 0) { 418 dbg("write_sysfs_attribute failed"); 419 return -1; 420 } 421 422 dbg("detached port: %d", port); 423 424 return 0; 425 } 426 427 int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev) 428 { 429 char product_name[100]; 430 char host[NI_MAXHOST] = "unknown host"; 431 char serv[NI_MAXSERV] = "unknown port"; 432 char remote_busid[SYSFS_BUS_ID_SIZE]; 433 int ret; 434 int read_record_error = 0; 435 436 if (idev->status == VDEV_ST_NULL || idev->status == VDEV_ST_NOTASSIGNED) 437 return 0; 438 439 ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv), 440 remote_busid); 441 if (ret) { 442 err("read_record"); 443 read_record_error = 1; 444 } 445 446 printf("Port %02d: <%s> at %s\n", idev->port, 447 usbip_status_string(idev->status), 448 usbip_speed_string(idev->udev.speed)); 449 450 usbip_names_get_product(product_name, sizeof(product_name), 451 idev->udev.idVendor, idev->udev.idProduct); 452 453 printf(" %s\n", product_name); 454 455 if (!read_record_error) { 456 printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid, 457 host, serv, remote_busid); 458 printf("%10s -> remote bus/dev %03d/%03d\n", " ", 459 idev->busnum, idev->devnum); 460 } else { 461 printf("%10s -> unknown host, remote port and remote busid\n", 462 idev->udev.busid); 463 printf("%10s -> remote bus/dev %03d/%03d\n", " ", 464 idev->busnum, idev->devnum); 465 } 466 467 return 0; 468 } 469