Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005-2007 Takahiro Hirofuchi |
| 3 | */ |
| 4 | |
matt mooney | 099f79f | 2011-06-19 22:44:37 -0700 | [diff] [blame] | 5 | #include "usbip_common.h" |
| 6 | #include "vhci_driver.h" |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 7 | #include <limits.h> |
| 8 | #include <netdb.h> |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 9 | #include <libudev.h> |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 10 | #include "sysfs_utils.h" |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 11 | |
matt mooney | f2fb62b | 2011-06-19 22:44:35 -0700 | [diff] [blame] | 12 | #undef PROGNAME |
| 13 | #define PROGNAME "libusbip" |
| 14 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 15 | struct usbip_vhci_driver *vhci_driver; |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 16 | struct udev *udev_context; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 17 | |
Kurt Kanzenbach | 9db91e1 | 2013-02-22 12:13:29 +0100 | [diff] [blame] | 18 | static struct usbip_imported_device * |
| 19 | imported_device_init(struct usbip_imported_device *idev, char *busid) |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 20 | { |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 21 | struct udev_device *sudev; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 22 | |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 23 | sudev = udev_device_new_from_subsystem_sysname(udev_context, |
| 24 | "usb", busid); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 25 | if (!sudev) { |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 26 | dbg("udev_device_new_from_subsystem_sysname failed: %s", busid); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 27 | goto err; |
| 28 | } |
| 29 | read_usb_device(sudev, &idev->udev); |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 30 | udev_device_unref(sudev); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 31 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 32 | return idev; |
| 33 | |
| 34 | err: |
| 35 | return NULL; |
| 36 | } |
| 37 | |
| 38 | |
| 39 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 40 | static int parse_status(const char *value) |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 41 | { |
| 42 | int ret = 0; |
| 43 | char *c; |
| 44 | |
| 45 | |
| 46 | for (int i = 0; i < vhci_driver->nports; i++) |
matt mooney | 950a4cd | 2011-05-27 01:44:10 -0700 | [diff] [blame] | 47 | memset(&vhci_driver->idev[i], 0, sizeof(vhci_driver->idev[i])); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 48 | |
| 49 | |
| 50 | /* skip a header line */ |
Christopher Harvey | 2f5c638 | 2012-03-23 10:55:25 -0400 | [diff] [blame] | 51 | c = strchr(value, '\n'); |
| 52 | if (!c) |
| 53 | return -1; |
| 54 | c++; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 55 | |
| 56 | while (*c != '\0') { |
| 57 | int port, status, speed, devid; |
| 58 | unsigned long socket; |
| 59 | char lbusid[SYSFS_BUS_ID_SIZE]; |
| 60 | |
Alan | 2d32927 | 2013-12-11 18:32:59 +0000 | [diff] [blame] | 61 | ret = sscanf(c, "%d %d %d %x %lx %31s\n", |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 62 | &port, &status, &speed, |
| 63 | &devid, &socket, lbusid); |
| 64 | |
| 65 | if (ret < 5) { |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 66 | dbg("sscanf failed: %d", ret); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 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 | |
Kurt Kanzenbach | 9db91e1 | 2013-02-22 12:13:29 +0100 | [diff] [blame] | 87 | if (idev->status != VDEV_ST_NULL |
| 88 | && idev->status != VDEV_ST_NOTASSIGNED) { |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 89 | idev = imported_device_init(idev, lbusid); |
| 90 | if (!idev) { |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 91 | dbg("imported_device_init failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 92 | return -1; |
| 93 | } |
| 94 | } |
| 95 | } |
| 96 | |
| 97 | |
| 98 | /* go to the next line */ |
Christopher Harvey | 2f5c638 | 2012-03-23 10:55:25 -0400 | [diff] [blame] | 99 | c = strchr(c, '\n'); |
| 100 | if (!c) |
| 101 | break; |
| 102 | c++; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 103 | } |
| 104 | |
| 105 | dbg("exit"); |
| 106 | |
| 107 | return 0; |
| 108 | } |
| 109 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 110 | static int refresh_imported_device_list(void) |
| 111 | { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 112 | const char *attr_status; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 113 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 114 | attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device, |
| 115 | "status"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 116 | if (!attr_status) { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 117 | err("udev_device_get_sysattr_value failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 118 | return -1; |
| 119 | } |
| 120 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 121 | return parse_status(attr_status); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | static int get_nports(void) |
| 125 | { |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 126 | char *c; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 127 | int nports = 0; |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 128 | const char *attr_status; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 129 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 130 | attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device, |
| 131 | "status"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 132 | if (!attr_status) { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 133 | err("udev_device_get_sysattr_value failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 134 | return -1; |
| 135 | } |
| 136 | |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 137 | /* skip a header line */ |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 138 | c = strchr(attr_status, '\n'); |
Christopher Harvey | 2f5c638 | 2012-03-23 10:55:25 -0400 | [diff] [blame] | 139 | if (!c) |
| 140 | return 0; |
| 141 | c++; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 142 | |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 143 | while (*c != '\0') { |
| 144 | /* go to the next line */ |
Christopher Harvey | 2f5c638 | 2012-03-23 10:55:25 -0400 | [diff] [blame] | 145 | c = strchr(c, '\n'); |
| 146 | if (!c) |
| 147 | return nports; |
| 148 | c++; |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 149 | nports += 1; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | return nports; |
| 153 | } |
| 154 | |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 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) |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 166 | { |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 167 | int part; |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 168 | FILE *file; |
| 169 | char path[PATH_MAX+1]; |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 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; |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 178 | |
| 179 | snprintf(path, PATH_MAX, VHCI_STATE_PATH"/port%d", rhport); |
| 180 | |
| 181 | file = fopen(path, "r"); |
| 182 | if (!file) { |
| 183 | err("fopen"); |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 184 | free(buffer); |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 185 | return -1; |
| 186 | } |
| 187 | |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 188 | if (fgets(buffer, buffer_len, file) == NULL) { |
| 189 | err("fgets"); |
| 190 | free(buffer); |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 191 | fclose(file); |
| 192 | return -1; |
| 193 | } |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 194 | fclose(file); |
| 195 | |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 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 | |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 215 | return 0; |
| 216 | } |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 217 | |
| 218 | /* ---------------------------------------------------------------------- */ |
| 219 | |
| 220 | int usbip_vhci_driver_open(void) |
| 221 | { |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 222 | udev_context = udev_new(); |
| 223 | if (!udev_context) { |
| 224 | err("udev_new failed"); |
| 225 | return -1; |
| 226 | } |
| 227 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 228 | vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver)); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 229 | |
| 230 | /* will be freed in usbip_driver_close() */ |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 231 | vhci_driver->hc_device = |
| 232 | udev_device_new_from_subsystem_sysname(udev_context, |
| 233 | USBIP_VHCI_BUS_TYPE, |
| 234 | USBIP_VHCI_DRV_NAME); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 235 | if (!vhci_driver->hc_device) { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 236 | err("udev_device_new_from_subsystem_sysname failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 237 | goto err; |
| 238 | } |
| 239 | |
| 240 | vhci_driver->nports = get_nports(); |
| 241 | |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 242 | dbg("available ports: %d", vhci_driver->nports); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 243 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 244 | if (refresh_imported_device_list()) |
| 245 | goto err; |
| 246 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 247 | return 0; |
| 248 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 249 | err: |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 250 | udev_device_unref(vhci_driver->hc_device); |
| 251 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 252 | if (vhci_driver) |
| 253 | free(vhci_driver); |
| 254 | |
| 255 | vhci_driver = NULL; |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 256 | |
| 257 | udev_unref(udev_context); |
| 258 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 259 | return -1; |
| 260 | } |
| 261 | |
| 262 | |
Pawel Lebioda | 1949551 | 2014-05-14 21:28:27 +0200 | [diff] [blame] | 263 | void usbip_vhci_driver_close(void) |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 264 | { |
| 265 | if (!vhci_driver) |
| 266 | return; |
| 267 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 268 | udev_device_unref(vhci_driver->hc_device); |
| 269 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 270 | free(vhci_driver); |
| 271 | |
| 272 | vhci_driver = NULL; |
Valentina Manea | 021aed8 | 2014-03-08 14:53:26 +0200 | [diff] [blame] | 273 | |
| 274 | udev_unref(udev_context); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | |
| 278 | int usbip_vhci_refresh_device_list(void) |
| 279 | { |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 280 | |
| 281 | if (refresh_imported_device_list()) |
| 282 | goto err; |
| 283 | |
| 284 | return 0; |
| 285 | err: |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 286 | dbg("failed to refresh device list"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 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) { |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 303 | char buff[200]; /* what size should be ? */ |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 304 | char attach_attr_path[SYSFS_PATH_MAX]; |
| 305 | char attr_attach[] = "attach"; |
| 306 | const char *path; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 307 | int ret; |
| 308 | |
Masanari Iida | 5484081 | 2014-02-27 20:36:31 +0900 | [diff] [blame] | 309 | snprintf(buff, sizeof(buff), "%u %d %u %u", |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 310 | port, sockfd, devid, speed); |
| 311 | dbg("writing: %s", buff); |
| 312 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 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)); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 319 | if (ret < 0) { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 320 | dbg("write_sysfs_attribute failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 321 | return -1; |
| 322 | } |
| 323 | |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 324 | dbg("attached port: %d", port); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 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 | { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 345 | char detach_attr_path[SYSFS_PATH_MAX]; |
| 346 | char attr_detach[] = "detach"; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 347 | char buff[200]; /* what size should be ? */ |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 348 | const char *path; |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 349 | int ret; |
| 350 | |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 351 | snprintf(buff, sizeof(buff), "%u", port); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 352 | dbg("writing: %s", buff); |
| 353 | |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 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)); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 360 | if (ret < 0) { |
Valentina Manea | a744b7c | 2014-03-08 14:53:28 +0200 | [diff] [blame] | 361 | dbg("write_sysfs_attribute failed"); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 362 | return -1; |
| 363 | } |
| 364 | |
matt mooney | 25567a3 | 2011-06-19 22:44:38 -0700 | [diff] [blame] | 365 | dbg("detached port: %d", port); |
Takahiro Hirofuchi | 0945b4f | 2011-05-14 03:55:07 -0700 | [diff] [blame] | 366 | |
| 367 | return 0; |
| 368 | } |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 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 | |
Mark Asselstine | a37d70e | 2014-02-12 21:47:56 -0500 | [diff] [blame] | 382 | ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv), |
| 383 | remote_busid); |
Valentina Manea | ec2ff62 | 2014-01-07 21:05:56 +0200 | [diff] [blame] | 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 | } |