xref: /linux/tools/usb/usbip/libsrc/vhci_driver.c (revision 6fdcba32711044c35c0e1b094cbd8f3f0b4472c9) 
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 			if (vhci_driver->idev[i].hub != HUB_SPEED_SUPER)
342 				continue;
343 		break;
344 		default:
345 			if (vhci_driver->idev[i].hub != HUB_SPEED_HIGH)
346 				continue;
347 		break;
348 		}
349 
350 		if (vhci_driver->idev[i].status == VDEV_ST_NULL)
351 			return vhci_driver->idev[i].port;
352 	}
353 
354 	return -1;
355 }
356 
357 int usbip_vhci_attach_device2(uint8_t port, int sockfd, uint32_t devid,
358 		uint32_t speed) {
359 	char buff[200]; /* what size should be ? */
360 	char attach_attr_path[SYSFS_PATH_MAX];
361 	char attr_attach[] = "attach";
362 	const char *path;
363 	int ret;
364 
365 	snprintf(buff, sizeof(buff), "%u %d %u %u",
366 			port, sockfd, devid, speed);
367 	dbg("writing: %s", buff);
368 
369 	path = udev_device_get_syspath(vhci_driver->hc_device);
370 	snprintf(attach_attr_path, sizeof(attach_attr_path), "%s/%s",
371 		 path, attr_attach);
372 	dbg("attach attribute path: %s", attach_attr_path);
373 
374 	ret = write_sysfs_attribute(attach_attr_path, buff, strlen(buff));
375 	if (ret < 0) {
376 		dbg("write_sysfs_attribute failed");
377 		return -1;
378 	}
379 
380 	dbg("attached port: %d", port);
381 
382 	return 0;
383 }
384 
385 static unsigned long get_devid(uint8_t busnum, uint8_t devnum)
386 {
387 	return (busnum << 16) | devnum;
388 }
389 
390 /* will be removed */
391 int usbip_vhci_attach_device(uint8_t port, int sockfd, uint8_t busnum,
392 		uint8_t devnum, uint32_t speed)
393 {
394 	int devid = get_devid(busnum, devnum);
395 
396 	return usbip_vhci_attach_device2(port, sockfd, devid, speed);
397 }
398 
399 int usbip_vhci_detach_device(uint8_t port)
400 {
401 	char detach_attr_path[SYSFS_PATH_MAX];
402 	char attr_detach[] = "detach";
403 	char buff[200]; /* what size should be ? */
404 	const char *path;
405 	int ret;
406 
407 	snprintf(buff, sizeof(buff), "%u", port);
408 	dbg("writing: %s", buff);
409 
410 	path = udev_device_get_syspath(vhci_driver->hc_device);
411 	snprintf(detach_attr_path, sizeof(detach_attr_path), "%s/%s",
412 		 path, attr_detach);
413 	dbg("detach attribute path: %s", detach_attr_path);
414 
415 	ret = write_sysfs_attribute(detach_attr_path, buff, strlen(buff));
416 	if (ret < 0) {
417 		dbg("write_sysfs_attribute failed");
418 		return -1;
419 	}
420 
421 	dbg("detached port: %d", port);
422 
423 	return 0;
424 }
425 
426 int usbip_vhci_imported_device_dump(struct usbip_imported_device *idev)
427 {
428 	char product_name[100];
429 	char host[NI_MAXHOST] = "unknown host";
430 	char serv[NI_MAXSERV] = "unknown port";
431 	char remote_busid[SYSFS_BUS_ID_SIZE];
432 	int ret;
433 	int read_record_error = 0;
434 
435 	if (idev->status == VDEV_ST_NULL || idev->status == VDEV_ST_NOTASSIGNED)
436 		return 0;
437 
438 	ret = read_record(idev->port, host, sizeof(host), serv, sizeof(serv),
439 			  remote_busid);
440 	if (ret) {
441 		err("read_record");
442 		read_record_error = 1;
443 	}
444 
445 	printf("Port %02d: <%s> at %s\n", idev->port,
446 	       usbip_status_string(idev->status),
447 	       usbip_speed_string(idev->udev.speed));
448 
449 	usbip_names_get_product(product_name, sizeof(product_name),
450 				idev->udev.idVendor, idev->udev.idProduct);
451 
452 	printf("       %s\n",  product_name);
453 
454 	if (!read_record_error) {
455 		printf("%10s -> usbip://%s:%s/%s\n", idev->udev.busid,
456 		       host, serv, remote_busid);
457 		printf("%10s -> remote bus/dev %03d/%03d\n", " ",
458 		       idev->busnum, idev->devnum);
459 	} else {
460 		printf("%10s -> unknown host, remote port and remote busid\n",
461 		       idev->udev.busid);
462 		printf("%10s -> remote bus/dev %03d/%03d\n", " ",
463 		       idev->busnum, idev->devnum);
464 	}
465 
466 	return 0;
467 }
468