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