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