USBGetDevices.cpp@ 66900

Last change on this file since 66900 was 63677, checked in by vboxsync, 8 years ago
shut up gcc for complaining about readdir_r() with glibc 2.24+
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.7 KB

Line
1	/* $Id: USBGetDevices.cpp 63677 2016-09-01 09:03:39Z vboxsync $ */
2	/** @file
3	* VirtualBox Linux host USB device enumeration.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define VBOX_USB_WITH_USBFS
23	#include "USBGetDevices.h"
24
25	#include <VBox/err.h>
26	#include <VBox/usb.h>
27	#include <VBox/usblib.h>
28
29	#include <iprt/linux/sysfs.h>
30	#include <iprt/cdefs.h>
31	#include <iprt/ctype.h>
32	#include <iprt/dir.h>
33	#include <iprt/env.h>
34	#include <iprt/file.h>
35	#include <iprt/fs.h>
36	#include <iprt/log.h>
37	#include <iprt/mem.h>
38	#include <iprt/param.h>
39	#include <iprt/path.h>
40	#include <iprt/string.h>
41	#include "vector.h"
42
43	#ifdef VBOX_WITH_LINUX_COMPILER_H
44	# include <linux/compiler.h>
45	#endif
46	#include <linux/usbdevice_fs.h>
47
48	#include <sys/types.h>
49	#include <sys/stat.h>
50	#include <sys/vfs.h>
51
52	#include <dirent.h>
53	#include <dlfcn.h>
54	#include <errno.h>
55	#include <fcntl.h>
56	#include <stdio.h>
57	#include <string.h>
58	#include <unistd.h>
59
60
61	/*********************************************************************************************************************************
62	* Structures and Typedefs *
63	*********************************************************************************************************************************/
64	/** Structure describing a host USB device */
65	typedef struct USBDeviceInfo
66	{
67	/** The device node of the device. */
68	char *mDevice;
69	/** The system identifier of the device. Specific to the probing
70	* method. */
71	char *mSysfsPath;
72	/** List of interfaces as sysfs paths */
73	VECTOR_PTR(char *) mvecpszInterfaces;
74	} USBDeviceInfo;
75
76
77	/**
78	* Does some extra checks to improve the detected device state.
79	*
80	* We cannot distinguish between USED_BY_HOST_CAPTURABLE and
81	* USED_BY_GUEST, HELD_BY_PROXY all that well and it shouldn't be
82	* necessary either.
83	*
84	* We will however, distinguish between the device we have permissions
85	* to open and those we don't. This is necessary for two reasons.
86	*
87	* Firstly, because it's futile to even attempt opening a device which we
88	* don't have access to, it only serves to confuse the user. (That said,
89	* it might also be a bit confusing for the user to see that a USB device
90	* is grayed out with no further explanation, and no way of generating an
91	* error hinting at why this is the case.)
92	*
93	* Secondly and more importantly, we're racing against udevd with respect
94	* to permissions and group settings on newly plugged devices. When we
95	* detect a new device that we cannot access we will poll on it for a few
96	* seconds to give udevd time to fix it. The polling is actually triggered
97	* in the 'new device' case in the compare loop.
98	*
99	* The USBDEVICESTATE_USED_BY_HOST state is only used for this no-access
100	* case, while USBDEVICESTATE_UNSUPPORTED is only used in the 'hub' case.
101	* When it's neither of these, we set USBDEVICESTATE_UNUSED or
102	* USBDEVICESTATE_USED_BY_HOST_CAPTURABLE depending on whether there is
103	* a driver associated with any of the interfaces.
104	*
105	* All except the access check and a special idVendor == 0 precaution
106	* is handled at parse time.
107	*
108	* @returns The adjusted state.
109	* @param pDevice The device.
110	*/
111	static USBDEVICESTATE usbDeterminState(PCUSBDEVICE pDevice)
112	{
113	/*
114	* If it's already flagged as unsupported, there is nothing to do.
115	*/
116	USBDEVICESTATE enmState = pDevice->enmState;
117	if (enmState == USBDEVICESTATE_UNSUPPORTED)
118	return USBDEVICESTATE_UNSUPPORTED;
119
120	/*
121	* Root hubs and similar doesn't have any vendor id, just
122	* refuse these device.
123	*/
124	if (!pDevice->idVendor)
125	return USBDEVICESTATE_UNSUPPORTED;
126
127	/*
128	* Check if we've got access to the device, if we haven't flag
129	* it as used-by-host.
130	*/
131	#ifndef VBOX_USB_WITH_SYSFS
132	const char *pszAddress = pDevice->pszAddress;
133	#else
134	if (pDevice->pszAddress == NULL)
135	/* We can't do much with the device without an address. */
136	return USBDEVICESTATE_UNSUPPORTED;
137	const char *pszAddress = strstr(pDevice->pszAddress, "//device:");
138	pszAddress = pszAddress != NULL
139	? pszAddress + sizeof("//device:") - 1
140	: pDevice->pszAddress;
141	#endif
142	if ( access(pszAddress, R_OK \| W_OK) != 0
143	&& errno == EACCES)
144	return USBDEVICESTATE_USED_BY_HOST;
145
146	#ifdef VBOX_USB_WITH_SYSFS
147	/**
148	* @todo Check that any other essential fields are present and mark as
149	* invalid if not. Particularly to catch the case where the device was
150	* unplugged while we were reading in its properties.
151	*/
152	#endif
153
154	return enmState;
155	}
156
157
158	/**
159	* Dumps a USBDEVICE structure to the log using LogLevel 3.
160	* @param pDev The structure to log.
161	* @todo This is really common code.
162	*/
163	static void usbLogDevice(PUSBDEVICE pDev)
164	{
165	NOREF(pDev);
166	if (LogIs3Enabled())
167	{
168	Log3(("USB device:\n"));
169	Log3(("Product: %s (%x)\n", pDev->pszProduct, pDev->idProduct));
170	Log3(("Manufacturer: %s (Vendor ID %x)\n", pDev->pszManufacturer, pDev->idVendor));
171	Log3(("Serial number: %s (%llx)\n", pDev->pszSerialNumber, pDev->u64SerialHash));
172	Log3(("Device revision: %d\n", pDev->bcdDevice));
173	Log3(("Device class: %x\n", pDev->bDeviceClass));
174	Log3(("Device subclass: %x\n", pDev->bDeviceSubClass));
175	Log3(("Device protocol: %x\n", pDev->bDeviceProtocol));
176	Log3(("USB version number: %d\n", pDev->bcdUSB));
177	Log3(("Device speed: %s\n",
178	pDev->enmSpeed == USBDEVICESPEED_UNKNOWN ? "unknown"
179	: pDev->enmSpeed == USBDEVICESPEED_LOW ? "1.5 MBit/s"
180	: pDev->enmSpeed == USBDEVICESPEED_FULL ? "12 MBit/s"
181	: pDev->enmSpeed == USBDEVICESPEED_HIGH ? "480 MBit/s"
182	: pDev->enmSpeed == USBDEVICESPEED_SUPER ? "5.0 GBit/s"
183	: pDev->enmSpeed == USBDEVICESPEED_VARIABLE ? "variable"
184	: "invalid"));
185	Log3(("Number of configurations: %d\n", pDev->bNumConfigurations));
186	Log3(("Bus number: %d\n", pDev->bBus));
187	Log3(("Port number: %d\n", pDev->bPort));
188	Log3(("Device number: %d\n", pDev->bDevNum));
189	Log3(("Device state: %s\n",
190	pDev->enmState == USBDEVICESTATE_UNSUPPORTED ? "unsupported"
191	: pDev->enmState == USBDEVICESTATE_USED_BY_HOST ? "in use by host"
192	: pDev->enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE ? "in use by host, possibly capturable"
193	: pDev->enmState == USBDEVICESTATE_UNUSED ? "not in use"
194	: pDev->enmState == USBDEVICESTATE_HELD_BY_PROXY ? "held by proxy"
195	: pDev->enmState == USBDEVICESTATE_USED_BY_GUEST ? "used by guest"
196	: "invalid"));
197	Log3(("OS device address: %s\n", pDev->pszAddress));
198	}
199	}
200
201
202	#ifdef VBOX_USB_WITH_USBFS
203
204	/**
205	* "reads" the number suffix.
206	*
207	* It's more like validating it and skipping the necessary number of chars.
208	*/
209	static int usbfsReadSkipSuffix(char **ppszNext)
210	{
211	char pszNext = ppszNext;
212	if (!RT_C_IS_SPACE(pszNext) && pszNext)
213	{
214	/* skip unit */
215	if (pszNext[0] == 'm' && pszNext[1] == 's')
216	pszNext += 2;
217	else if (pszNext[0] == 'm' && pszNext[1] == 'A')
218	pszNext += 2;
219
220	/* skip parenthesis */
221	if (*pszNext == '(')
222	{
223	pszNext = strchr(pszNext, ')');
224	if (!pszNext++)
225	{
226	AssertMsgFailed(("ppszNext=%s\n", ppszNext));
227	return VERR_PARSE_ERROR;
228	}
229	}
230
231	/* blank or end of the line. */
232	if (!RT_C_IS_SPACE(pszNext) && pszNext)
233	{
234	AssertMsgFailed(("pszNext=%s\n", pszNext));
235	return VERR_PARSE_ERROR;
236	}
237
238	/* it's ok. */
239	*ppszNext = pszNext;
240	}
241
242	return VINF_SUCCESS;
243	}
244
245
246	/**
247	* Reads a USB number returning the number and the position of the next character to parse.
248	*/
249	static int usbfsReadNum(const char pszValue, unsigned uBase, uint32_t u32Mask, void pvNum, char **ppszNext)
250	{
251	/*
252	* Initialize return value to zero and strip leading spaces.
253	*/
254	switch (u32Mask)
255	{
256	case 0xff: (uint8_t )pvNum = 0; break;
257	case 0xffff: (uint16_t )pvNum = 0; break;
258	case 0xffffffff: (uint32_t )pvNum = 0; break;
259	}
260	pszValue = RTStrStripL(pszValue);
261	if (*pszValue)
262	{
263	/*
264	* Try convert the number.
265	*/
266	char *pszNext;
267	uint32_t u32 = 0;
268	RTStrToUInt32Ex(pszValue, &pszNext, uBase, &u32);
269	if (pszNext == pszValue)
270	{
271	AssertMsgFailed(("pszValue=%d\n", pszValue));
272	return VERR_NO_DATA;
273	}
274
275	/*
276	* Check the range.
277	*/
278	if (u32 & ~u32Mask)
279	{
280	AssertMsgFailed(("pszValue=%d u32=%#x lMask=%#x\n", pszValue, u32, u32Mask));
281	return VERR_OUT_OF_RANGE;
282	}
283
284	int rc = usbfsReadSkipSuffix(&pszNext);
285	if (RT_FAILURE(rc))
286	return rc;
287
288	*ppszNext = pszNext;
289
290	/*
291	* Set the value.
292	*/
293	switch (u32Mask)
294	{
295	case 0xff: (uint8_t )pvNum = (uint8_t)u32; break;
296	case 0xffff: (uint16_t )pvNum = (uint16_t)u32; break;
297	case 0xffffffff: (uint32_t )pvNum = (uint32_t)u32; break;
298	}
299	}
300	return VINF_SUCCESS;
301	}
302
303
304	static int usbfsRead8(const char pszValue, unsigned uBase, uint8_t pu8, char **ppszNext)
305	{
306	return usbfsReadNum(pszValue, uBase, 0xff, pu8, ppszNext);
307	}
308
309
310	static int usbfsRead16(const char pszValue, unsigned uBase, uint16_t pu16, char **ppszNext)
311	{
312	return usbfsReadNum(pszValue, uBase, 0xffff, pu16, ppszNext);
313	}
314
315
316	/**
317	* Reads a USB BCD number returning the number and the position of the next character to parse.
318	* The returned number contains the integer part in the high byte and the decimal part in the low byte.
319	*/
320	static int usbfsReadBCD(const char pszValue, unsigned uBase, uint16_t pu16, char **ppszNext)
321	{
322	/*
323	* Initialize return value to zero and strip leading spaces.
324	*/
325	*pu16 = 0;
326	pszValue = RTStrStripL(pszValue);
327	if (*pszValue)
328	{
329	/*
330	* Try convert the number.
331	*/
332	/* integer part */
333	char *pszNext;
334	uint32_t u32Int = 0;
335	RTStrToUInt32Ex(pszValue, &pszNext, uBase, &u32Int);
336	if (pszNext == pszValue)
337	{
338	AssertMsgFailed(("pszValue=%s\n", pszValue));
339	return VERR_NO_DATA;
340	}
341	if (u32Int & ~0xff)
342	{
343	AssertMsgFailed(("pszValue=%s u32Int=%#x (int)\n", pszValue, u32Int));
344	return VERR_OUT_OF_RANGE;
345	}
346
347	/* skip dot and read decimal part */
348	if (*pszNext != '.')
349	{
350	AssertMsgFailed(("pszValue=%s pszNext=%s (int)\n", pszValue, pszNext));
351	return VERR_PARSE_ERROR;
352	}
353	char *pszValue2 = RTStrStripL(pszNext + 1);
354	uint32_t u32Dec = 0;
355	RTStrToUInt32Ex(pszValue2, &pszNext, uBase, &u32Dec);
356	if (pszNext == pszValue)
357	{
358	AssertMsgFailed(("pszValue=%s\n", pszValue));
359	return VERR_NO_DATA;
360	}
361	if (u32Dec & ~0xff)
362	{
363	AssertMsgFailed(("pszValue=%s u32Dec=%#x\n", pszValue, u32Dec));
364	return VERR_OUT_OF_RANGE;
365	}
366
367	/*
368	* Validate and skip stuff following the number.
369	*/
370	int rc = usbfsReadSkipSuffix(&pszNext);
371	if (RT_FAILURE(rc))
372	return rc;
373	*ppszNext = pszNext;
374
375	/*
376	* Set the value.
377	*/
378	*pu16 = (uint16_t)((u32Int << 8) \| (uint16_t)u32Dec);
379	}
380	return VINF_SUCCESS;
381	}
382
383
384	/**
385	* Reads a string, i.e. allocates memory and copies it.
386	*
387	* We assume that a string is Utf8 and if that's not the case
388	* (pre-2.6.32-kernels used Latin-1, but so few devices return non-ASCII that
389	* this usually goes unnoticed) then we mercilessly force it to be so.
390	*/
391	static int usbfsReadStr(const char pszValue, const char *ppsz)
392	{
393	char *psz;
394
395	if (*ppsz)
396	RTStrFree((char )ppsz);
397	psz = RTStrDup(pszValue);
398	if (psz)
399	{
400	USBLibPurgeEncoding(psz);
401	*ppsz = psz;
402	return VINF_SUCCESS;
403	}
404	return VERR_NO_MEMORY;
405	}
406
407
408	/**
409	* Skips the current property.
410	*/
411	static char usbfsReadSkip(char pszValue)
412	{
413	char *psz = strchr(pszValue, '=');
414	if (psz)
415	psz = strchr(psz + 1, '=');
416	if (!psz)
417	return strchr(pszValue, '\0');
418	while (psz > pszValue && !RT_C_IS_SPACE(psz[-1]))
419	psz--;
420	Assert(psz > pszValue);
421	return psz;
422	}
423
424
425	/**
426	* Determine the USB speed.
427	*/
428	static int usbfsReadSpeed(const char pszValue, USBDEVICESPEED pSpd, char **ppszNext)
429	{
430	pszValue = RTStrStripL(pszValue);
431	/* verified with Linux 2.4.0 ... Linux 2.6.25 */
432	if (!strncmp(pszValue, RT_STR_TUPLE("1.5")))
433	*pSpd = USBDEVICESPEED_LOW;
434	else if (!strncmp(pszValue, RT_STR_TUPLE("12 ")))
435	*pSpd = USBDEVICESPEED_FULL;
436	else if (!strncmp(pszValue, RT_STR_TUPLE("480")))
437	*pSpd = USBDEVICESPEED_HIGH;
438	else if (!strncmp(pszValue, RT_STR_TUPLE("5000")))
439	*pSpd = USBDEVICESPEED_SUPER;
440	else
441	*pSpd = USBDEVICESPEED_UNKNOWN;
442	while (pszValue[0] != '\0' && !RT_C_IS_SPACE(pszValue[0]))
443	pszValue++;
444	ppszNext = (char )pszValue;
445	return VINF_SUCCESS;
446	}
447
448
449	/**
450	* Compare a prefix and returns pointer to the char following it if it matches.
451	*/
452	static char usbfsPrefix(char psz, const char *pszPref, size_t cchPref)
453	{
454	if (strncmp(psz, pszPref, cchPref))
455	return NULL;
456	return psz + cchPref;
457	}
458
459
460	/** Just a worker for USBProxyServiceLinux::getDevices that avoids some code duplication. */
461	static int usbfsAddDeviceToChain(PUSBDEVICE pDev, PUSBDEVICE ppFirst, PUSBDEVICE pppNext, const char pszUsbfsRoot,
462	bool fUnsupportedDevicesToo, int rc)
463	{
464	/* usbDeterminState requires the address. */
465	PUSBDEVICE pDevNew = (PUSBDEVICE)RTMemDup(pDev, sizeof(*pDev));
466	if (pDevNew)
467	{
468	RTStrAPrintf((char **)&pDevNew->pszAddress, "%s/%03d/%03d", pszUsbfsRoot, pDevNew->bBus, pDevNew->bDevNum);
469	if (pDevNew->pszAddress)
470	{
471	pDevNew->enmState = usbDeterminState(pDevNew);
472	if (pDevNew->enmState != USBDEVICESTATE_UNSUPPORTED \|\| fUnsupportedDevicesToo)
473	{
474	if (*pppNext)
475	**pppNext = pDevNew;
476	else
477	*ppFirst = pDevNew;
478	*pppNext = &pDevNew->pNext;
479	}
480	else
481	deviceFree(pDevNew);
482	}
483	else
484	{
485	deviceFree(pDevNew);
486	rc = VERR_NO_MEMORY;
487	}
488	}
489	else
490	{
491	rc = VERR_NO_MEMORY;
492	deviceFreeMembers(pDev);
493	}
494
495	return rc;
496	}
497
498
499	static int usbfsOpenDevicesFile(const char pszUsbfsRoot, FILE *ppFile)
500	{
501	char *pszPath;
502	FILE *pFile;
503	RTStrAPrintf(&pszPath, "%s/devices", pszUsbfsRoot);
504	if (!pszPath)
505	return VERR_NO_MEMORY;
506	pFile = fopen(pszPath, "r");
507	RTStrFree(pszPath);
508	if (!pFile)
509	return RTErrConvertFromErrno(errno);
510	*ppFile = pFile;
511	return VINF_SUCCESS;
512	}
513
514
515	/**
516	* USBProxyService::getDevices() implementation for usbfs.
517	*
518	* The @a fUnsupportedDevicesToo flag tells the function to return information
519	* about unsupported devices as well. This is used as a sanity test to check
520	* that a devices file is really what we expect.
521	*/
522	static PUSBDEVICE usbfsGetDevices(const char *pszUsbfsRoot, bool fUnsupportedDevicesToo)
523	{
524	PUSBDEVICE pFirst = NULL;
525	FILE *pFile = NULL;
526	int rc;
527	rc = usbfsOpenDevicesFile(pszUsbfsRoot, &pFile);
528	if (RT_SUCCESS(rc))
529	{
530	PUSBDEVICE *ppNext = NULL;
531	int cHits = 0;
532	char szLine[1024];
533	USBDEVICE Dev;
534	RT_ZERO(Dev);
535	Dev.enmState = USBDEVICESTATE_UNUSED;
536
537	/* Set close on exit and hope no one is racing us. */
538	rc = fcntl(fileno(pFile), F_SETFD, FD_CLOEXEC) >= 0
539	? VINF_SUCCESS
540	: RTErrConvertFromErrno(errno);
541	while ( RT_SUCCESS(rc)
542	&& fgets(szLine, sizeof(szLine), pFile))
543	{
544	char *psz;
545	char *pszValue;
546
547	/* validate and remove the trailing newline. */
548	psz = strchr(szLine, '\0');
549	if (psz[-1] != '\n' && !feof(pFile))
550	{
551	AssertMsgFailed(("Line too long. (cch=%d)\n", strlen(szLine)));
552	continue;
553	}
554
555	/* strip */
556	psz = RTStrStrip(szLine);
557	if (!*psz)
558	continue;
559
560	/*
561	* Interpret the line.
562	* (Ordered by normal occurrence.)
563	*/
564	char ch = psz[0];
565	if (psz[1] != ':')
566	continue;
567	psz = RTStrStripL(psz + 3);
568	#define PREFIX(str) ( (pszValue = usbfsPrefix(psz, str, sizeof(str) - 1)) != NULL )
569	switch (ch)
570	{
571	/*
572	* T: Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=ddd MxCh=dd
573	* \| \| \| \| \| \| \| \| \|__MaxChildren
574	* \| \| \| \| \| \| \| \|__Device Speed in Mbps
575	* \| \| \| \| \| \| \|__DeviceNumber
576	* \| \| \| \| \| \|__Count of devices at this level
577	* \| \| \| \| \|__Connector/Port on Parent for this device
578	* \| \| \| \|__Parent DeviceNumber
579	* \| \| \|__Level in topology for this bus
580	* \| \|__Bus number
581	* \|__Topology info tag
582	*/
583	case 'T':
584	/* add */
585	AssertMsg(cHits >= 3 \|\| cHits == 0, ("cHits=%d\n", cHits));
586	if (cHits >= 3)
587	rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
588	else
589	deviceFreeMembers(&Dev);
590
591	/* Reset device state */
592	RT_ZERO(Dev);
593	Dev.enmState = USBDEVICESTATE_UNUSED;
594	cHits = 1;
595
596	/* parse the line. */
597	while (*psz && RT_SUCCESS(rc))
598	{
599	if (PREFIX("Bus="))
600	rc = usbfsRead8(pszValue, 10, &Dev.bBus, &psz);
601	else if (PREFIX("Port="))
602	rc = usbfsRead8(pszValue, 10, &Dev.bPort, &psz);
603	else if (PREFIX("Spd="))
604	rc = usbfsReadSpeed(pszValue, &Dev.enmSpeed, &psz);
605	else if (PREFIX("Dev#="))
606	rc = usbfsRead8(pszValue, 10, &Dev.bDevNum, &psz);
607	else
608	psz = usbfsReadSkip(psz);
609	psz = RTStrStripL(psz);
610	}
611	break;
612
613	/*
614	* Bandwidth info:
615	* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd
616	* \| \| \| \|__Number of isochronous requests
617	* \| \| \|__Number of interrupt requests
618	* \| \|__Total Bandwidth allocated to this bus
619	* \|__Bandwidth info tag
620	*/
621	case 'B':
622	break;
623
624	/*
625	* D: Ver=x.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd
626	* \| \| \| \| \| \| \|__NumberConfigurations
627	* \| \| \| \| \| \|__MaxPacketSize of Default Endpoint
628	* \| \| \| \| \|__DeviceProtocol
629	* \| \| \| \|__DeviceSubClass
630	* \| \| \|__DeviceClass
631	* \| \|__Device USB version
632	* \|__Device info tag #1
633	*/
634	case 'D':
635	while (*psz && RT_SUCCESS(rc))
636	{
637	if (PREFIX("Ver="))
638	rc = usbfsReadBCD(pszValue, 16, &Dev.bcdUSB, &psz);
639	else if (PREFIX("Cls="))
640	{
641	rc = usbfsRead8(pszValue, 16, &Dev.bDeviceClass, &psz);
642	if (RT_SUCCESS(rc) && Dev.bDeviceClass == 9 /* HUB */)
643	Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
644	}
645	else if (PREFIX("Sub="))
646	rc = usbfsRead8(pszValue, 16, &Dev.bDeviceSubClass, &psz);
647	else if (PREFIX("Prot="))
648	rc = usbfsRead8(pszValue, 16, &Dev.bDeviceProtocol, &psz);
649	//else if (PREFIX("MxPS="))
650	// rc = usbRead16(pszValue, 10, &Dev.wMaxPacketSize, &psz);
651	else if (PREFIX("#Cfgs="))
652	rc = usbfsRead8(pszValue, 10, &Dev.bNumConfigurations, &psz);
653	else
654	psz = usbfsReadSkip(psz);
655	psz = RTStrStripL(psz);
656	}
657	cHits++;
658	break;
659
660	/*
661	* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx
662	* \| \| \| \|__Product revision number
663	* \| \| \|__Product ID code
664	* \| \|__Vendor ID code
665	* \|__Device info tag #2
666	*/
667	case 'P':
668	while (*psz && RT_SUCCESS(rc))
669	{
670	if (PREFIX("Vendor="))
671	rc = usbfsRead16(pszValue, 16, &Dev.idVendor, &psz);
672	else if (PREFIX("ProdID="))
673	rc = usbfsRead16(pszValue, 16, &Dev.idProduct, &psz);
674	else if (PREFIX("Rev="))
675	rc = usbfsReadBCD(pszValue, 16, &Dev.bcdDevice, &psz);
676	else
677	psz = usbfsReadSkip(psz);
678	psz = RTStrStripL(psz);
679	}
680	cHits++;
681	break;
682
683	/*
684	* String.
685	*/
686	case 'S':
687	if (PREFIX("Manufacturer="))
688	rc = usbfsReadStr(pszValue, &Dev.pszManufacturer);
689	else if (PREFIX("Product="))
690	rc = usbfsReadStr(pszValue, &Dev.pszProduct);
691	else if (PREFIX("SerialNumber="))
692	{
693	rc = usbfsReadStr(pszValue, &Dev.pszSerialNumber);
694	if (RT_SUCCESS(rc))
695	Dev.u64SerialHash = USBLibHashSerial(pszValue);
696	}
697	break;
698
699	/*
700	* C:* #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA
701	* \| \| \| \| \| \|__MaxPower in mA
702	* \| \| \| \| \|__Attributes
703	* \| \| \| \|__ConfiguratioNumber
704	* \| \| \|__NumberOfInterfaces
705	* \| \|__ "*" indicates the active configuration (others are " ")
706	* \|__Config info tag
707	*/
708	case 'C':
709	break;
710
711	/*
712	* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=ssss
713	* \| \| \| \| \| \| \| \|__Driver name
714	* \| \| \| \| \| \| \| or "(none)"
715	* \| \| \| \| \| \| \|__InterfaceProtocol
716	* \| \| \| \| \| \|__InterfaceSubClass
717	* \| \| \| \| \|__InterfaceClass
718	* \| \| \| \|__NumberOfEndpoints
719	* \| \| \|__AlternateSettingNumber
720	* \| \|__InterfaceNumber
721	* \|__Interface info tag
722	*/
723	case 'I':
724	{
725	/* Check for thing we don't support. */
726	while (*psz && RT_SUCCESS(rc))
727	{
728	if (PREFIX("Driver="))
729	{
730	const char *pszDriver = NULL;
731	rc = usbfsReadStr(pszValue, &pszDriver);
732	if ( !pszDriver
733	\|\| !*pszDriver
734	\|\| !strcmp(pszDriver, "(none)")
735	\|\| !strcmp(pszDriver, "(no driver)"))
736	/* no driver */;
737	else if (!strcmp(pszDriver, "hub"))
738	Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
739	else if (Dev.enmState == USBDEVICESTATE_UNUSED)
740	Dev.enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
741	RTStrFree((char *)pszDriver);
742	break; /* last attrib */
743	}
744	else if (PREFIX("Cls="))
745	{
746	uint8_t bInterfaceClass;
747	rc = usbfsRead8(pszValue, 16, &bInterfaceClass, &psz);
748	if (RT_SUCCESS(rc) && bInterfaceClass == 9 /* HUB */)
749	Dev.enmState = USBDEVICESTATE_UNSUPPORTED;
750	}
751	else
752	psz = usbfsReadSkip(psz);
753	psz = RTStrStripL(psz);
754	}
755	break;
756	}
757
758
759	/*
760	* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=dddms
761	* \| \| \| \| \|__Interval (max) between transfers
762	* \| \| \| \|__EndpointMaxPacketSize
763	* \| \| \|__Attributes(EndpointType)
764	* \| \|__EndpointAddress(I=In,O=Out)
765	* \|__Endpoint info tag
766	*/
767	case 'E':
768	break;
769
770	}
771	#undef PREFIX
772	} /* parse loop */
773	fclose(pFile);
774
775	/*
776	* Add the current entry.
777	*/
778	AssertMsg(cHits >= 3 \|\| cHits == 0, ("cHits=%d\n", cHits));
779	if (cHits >= 3)
780	rc = usbfsAddDeviceToChain(&Dev, &pFirst, &ppNext, pszUsbfsRoot, fUnsupportedDevicesToo, rc);
781
782	/*
783	* Success?
784	*/
785	if (RT_FAILURE(rc))
786	{
787	while (pFirst)
788	{
789	PUSBDEVICE pFree = pFirst;
790	pFirst = pFirst->pNext;
791	deviceFree(pFree);
792	}
793	}
794	}
795	if (RT_FAILURE(rc))
796	LogFlow(("USBProxyServiceLinux::getDevices: rc=%Rrc\n", rc));
797	return pFirst;
798	}
799
800	#endif /* VBOX_USB_WITH_USBFS */
801	#ifdef VBOX_USB_WITH_SYSFS
802
803	static void usbsysfsCleanupDevInfo(USBDeviceInfo *pSelf)
804	{
805	RTStrFree(pSelf->mDevice);
806	RTStrFree(pSelf->mSysfsPath);
807	pSelf->mDevice = pSelf->mSysfsPath = NULL;
808	VEC_CLEANUP_PTR(&pSelf->mvecpszInterfaces);
809	}
810
811
812	static int usbsysfsInitDevInfo(USBDeviceInfo pSelf, const char aDevice, const char *aSystemID)
813	{
814	pSelf->mDevice = aDevice ? RTStrDup(aDevice) : NULL;
815	pSelf->mSysfsPath = aSystemID ? RTStrDup(aSystemID) : NULL;
816	VEC_INIT_PTR(&pSelf->mvecpszInterfaces, char *, RTStrFree);
817	if ((aDevice && !pSelf->mDevice) \|\| (aSystemID && ! pSelf->mSysfsPath))
818	{
819	usbsysfsCleanupDevInfo(pSelf);
820	return 0;
821	}
822	return 1;
823	}
824
825	# define USBDEVICE_MAJOR 189
826
827	/**
828	* Calculate the bus (a.k.a root hub) number of a USB device from it's sysfs
829	* path.
830	*
831	* sysfs nodes representing root hubs have file names of the form
832	* usb<n>, where n is the bus number; other devices start with that number.
833	* See [http://www.linux-usb.org/FAQ.html#i6] and
834	* [http://www.kernel.org/doc/Documentation/usb/proc_usb_info.txt] for
835	* equivalent information about usbfs.
836	*
837	* @returns a bus number greater than 0 on success or 0 on failure.
838	*/
839	static unsigned usbsysfsGetBusFromPath(const char *pszPath)
840	{
841	const char *pszFile = strrchr(pszPath, '/');
842	if (!pszFile)
843	return 0;
844	unsigned bus = RTStrToUInt32(pszFile + 1);
845	if ( !bus
846	&& pszFile[1] == 'u' && pszFile[2] == 's' && pszFile[3] == 'b')
847	bus = RTStrToUInt32(pszFile + 4);
848	return bus;
849	}
850
851
852	/**
853	* Calculate the device number of a USB device.
854	*
855	* See drivers/usb/core/hub.c:usb_new_device as of Linux 2.6.20.
856	*/
857	static dev_t usbsysfsMakeDevNum(unsigned bus, unsigned device)
858	{
859	AssertReturn(bus > 0, 0);
860	AssertReturn(((device - 1) & ~127) == 0, 0);
861	AssertReturn(device > 0, 0);
862	return makedev(USBDEVICE_MAJOR, ((bus - 1) << 7) + device - 1);
863	}
864
865
866	/**
867	* If a file @a pszNode from /sys/bus/usb/devices is a device rather than an
868	* interface add an element for the device to @a pvecDevInfo.
869	*/
870	static int usbsysfsAddIfDevice(const char pszDevicesRoot, const char pszNode, VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo)
871	{
872	const char *pszFile = strrchr(pszNode, '/');
873	if (!pszFile)
874	return VERR_INVALID_PARAMETER;
875	if (strchr(pszFile, ':'))
876	return VINF_SUCCESS;
877
878	unsigned bus = usbsysfsGetBusFromPath(pszNode);
879	if (!bus)
880	return VINF_SUCCESS;
881
882	int64_t device;
883	int rc = RTLinuxSysFsReadIntFile(10, &device, "%s/devnum", pszNode);
884	if (RT_FAILURE(rc))
885	return VINF_SUCCESS;
886
887	dev_t devnum = usbsysfsMakeDevNum(bus, (int)device);
888	if (!devnum)
889	return VINF_SUCCESS;
890
891	char szDevPath[RTPATH_MAX];
892	rc = RTLinuxCheckDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
893	szDevPath, sizeof(szDevPath),
894	"%s/%.3d/%.3d",
895	pszDevicesRoot, bus, device);
896	if (RT_FAILURE(rc))
897	return VINF_SUCCESS;
898
899	USBDeviceInfo info;
900	if (usbsysfsInitDevInfo(&info, szDevPath, pszNode))
901	{
902	rc = VEC_PUSH_BACK_OBJ(pvecDevInfo, USBDeviceInfo, &info);
903	if (RT_SUCCESS(rc))
904	return VINF_SUCCESS;
905	}
906	usbsysfsCleanupDevInfo(&info);
907	return VERR_NO_MEMORY;
908	}
909
910
911	/**
912	* The logic for testing whether a sysfs address corresponds to an interface of
913	* a device.
914	*
915	* Both must be referenced by their canonical sysfs paths. This is not tested,
916	* as the test requires file-system interaction.
917	*/
918	static bool usbsysfsMuiIsAnInterfaceOf(const char pszIface, const char pszDev)
919	{
920	size_t cchDev = strlen(pszDev);
921
922	AssertPtr(pszIface);
923	AssertPtr(pszDev);
924	Assert(pszIface[0] == '/');
925	Assert(pszDev[0] == '/');
926	Assert(pszDev[cchDev - 1] != '/');
927
928	/* If this passes, pszIface is at least cchDev long */
929	if (strncmp(pszIface, pszDev, cchDev))
930	return false;
931
932	/* If this passes, pszIface is longer than cchDev */
933	if (pszIface[cchDev] != '/')
934	return false;
935
936	/* In sysfs an interface is an immediate subdirectory of the device */
937	if (strchr(pszIface + cchDev + 1, '/'))
938	return false;
939
940	/* And it always has a colon in its name */
941	if (!strchr(pszIface + cchDev + 1, ':'))
942	return false;
943
944	/* And hopefully we have now elimitated everything else */
945	return true;
946	}
947
948
949	# ifdef DEBUG
950	# ifdef __cplusplus
951	/** Unit test the logic in muiIsAnInterfaceOf in debug builds. */
952	class testIsAnInterfaceOf
953	{
954	public:
955	testIsAnInterfaceOf()
956	{
957	Assert(usbsysfsMuiIsAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0",
958	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
959	Assert(!usbsysfsMuiIsAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-1",
960	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
961	Assert(!usbsysfsMuiIsAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0/driver",
962	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
963	}
964	};
965	static testIsAnInterfaceOf testIsAnInterfaceOfInst;
966	# endif /* __cplusplus */
967	# endif /* DEBUG */
968
969
970	/**
971	* Tell whether a file in /sys/bus/usb/devices is an interface rather than a
972	* device.
973	*/
974	static int usbsysfsAddIfInterfaceOf(const char pszNode, USBDeviceInfo pInfo)
975	{
976	if (!usbsysfsMuiIsAnInterfaceOf(pszNode, pInfo->mSysfsPath))
977	return VINF_SUCCESS;
978
979	char pszDup = (char )RTStrDup(pszNode);
980	if (pszDup)
981	{
982	int rc = VEC_PUSH_BACK_PTR(&pInfo->mvecpszInterfaces, char *, pszDup);
983	if (RT_SUCCESS(rc))
984	return VINF_SUCCESS;
985	RTStrFree(pszDup);
986	}
987	return VERR_NO_MEMORY;
988	}
989
990
991	/**
992	* Helper for usbsysfsReadFilePaths().
993	*
994	* Adds the entries from the open directory @a pDir to the vector @a pvecpchDevs
995	* using either the full path or the realpath() and skipping hidden files and
996	* files on which realpath() fails.
997	*/
998	static int usbsysfsReadFilePathsFromDir(const char pszPath, DIR pDir, VECTOR_PTR(char ) pvecpchDevs)
999	{
1000	struct dirent entry, *pResult;
1001	int err, rc;
1002
1003	#if RT_GNUC_PREREQ(4, 6)
1004	# pragma GCC diagnostic push
1005	# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1006	#endif
1007	for (err = readdir_r(pDir, &entry, &pResult); pResult;
1008	err = readdir_r(pDir, &entry, &pResult))
1009	#if RT_GNUC_PREREQ(4, 6)
1010	# pragma GCC diagnostic pop
1011	#endif
1012	{
1013	char szPath[RTPATH_MAX + 1];
1014	char szRealPath[RTPATH_MAX + 1];
1015	if (entry.d_name[0] == '.')
1016	continue;
1017	if (snprintf(szPath, sizeof(szPath), "%s/%s", pszPath, entry.d_name) < 0)
1018	return RTErrConvertFromErrno(errno); /** @todo r=bird: snprintf isn't document to set errno. Also, wouldn't it be better to continue on errors? Finally, you don't need to copy pszPath each time... */
1019	if (!realpath(szPath, szRealPath))
1020	return RTErrConvertFromErrno(errno);
1021	char *pszPathCopy = RTStrDup(szRealPath);
1022	if (!pszPathCopy)
1023	return VERR_NO_MEMORY;
1024	if (RT_FAILURE(rc = VEC_PUSH_BACK_PTR(pvecpchDevs, char *, pszPathCopy)))
1025	return rc;
1026	}
1027	return RTErrConvertFromErrno(err);
1028	}
1029
1030
1031	/**
1032	* Dump the names of a directory's entries into a vector of char pointers.
1033	*
1034	* @returns zero on success or (positive) posix error value.
1035	* @param pszPath the path to dump.
1036	* @param pvecpchDevs an empty vector of char pointers - must be cleaned up
1037	* by the caller even on failure.
1038	* @param withRealPath whether to canonicalise the filename with realpath
1039	*/
1040	static int usbsysfsReadFilePaths(const char pszPath, VECTOR_PTR(char ) *pvecpchDevs)
1041	{
1042	AssertPtrReturn(pvecpchDevs, EINVAL);
1043	AssertReturn(VEC_SIZE_PTR(pvecpchDevs) == 0, EINVAL);
1044	AssertPtrReturn(pszPath, EINVAL);
1045
1046	DIR *pDir = opendir(pszPath);
1047	if (!pDir)
1048	return RTErrConvertFromErrno(errno);
1049	int rc = usbsysfsReadFilePathsFromDir(pszPath, pDir, pvecpchDevs);
1050	if (closedir(pDir) < 0 && RT_SUCCESS(rc))
1051	rc = RTErrConvertFromErrno(errno);
1052	return rc;
1053	}
1054
1055
1056	/**
1057	* Logic for USBSysfsEnumerateHostDevices.
1058	*
1059	* @param pvecDevInfo vector of device information structures to add device
1060	* information to
1061	* @param pvecpchDevs empty scratch vector which will be freed by the caller,
1062	* to simplify exit logic
1063	*/
1064	static int usbsysfsEnumerateHostDevicesWorker(const char *pszDevicesRoot,
1065	VECTOR_OBJ(USBDeviceInfo) *pvecDevInfo,
1066	VECTOR_PTR(char ) pvecpchDevs)
1067	{
1068
1069	AssertPtrReturn(pvecDevInfo, VERR_INVALID_POINTER);
1070	LogFlowFunc (("pvecDevInfo=%p\n", pvecDevInfo));
1071
1072	int rc = usbsysfsReadFilePaths("/sys/bus/usb/devices", pvecpchDevs);
1073	if (RT_FAILURE(rc))
1074	return rc;
1075
1076	char **ppszEntry;
1077	VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
1078	{
1079	rc = usbsysfsAddIfDevice(pszDevicesRoot, *ppszEntry, pvecDevInfo);
1080	if (RT_FAILURE(rc))
1081	return rc;
1082	}
1083
1084	USBDeviceInfo *pInfo;
1085	VEC_FOR_EACH(pvecDevInfo, USBDeviceInfo, pInfo)
1086	VEC_FOR_EACH(pvecpchDevs, char *, ppszEntry)
1087	{
1088	rc = usbsysfsAddIfInterfaceOf(*ppszEntry, pInfo);
1089	if (RT_FAILURE(rc))
1090	return rc;
1091	}
1092	return VINF_SUCCESS;
1093	}
1094
1095
1096	static int usbsysfsEnumerateHostDevices(const char pszDevicesRoot, VECTOR_OBJ(USBDeviceInfo) pvecDevInfo)
1097	{
1098	VECTOR_PTR(char *) vecpchDevs;
1099
1100	AssertReturn(VEC_SIZE_OBJ(pvecDevInfo) == 0, VERR_INVALID_PARAMETER);
1101	LogFlowFunc(("entered\n"));
1102	VEC_INIT_PTR(&vecpchDevs, char *, RTStrFree);
1103	int rc = usbsysfsEnumerateHostDevicesWorker(pszDevicesRoot, pvecDevInfo, &vecpchDevs);
1104	VEC_CLEANUP_PTR(&vecpchDevs);
1105	LogFlowFunc(("rc=%Rrc\n", rc));
1106	return rc;
1107	}
1108
1109
1110	/**
1111	* Helper function for extracting the port number on the parent device from
1112	* the sysfs path value.
1113	*
1114	* The sysfs path is a chain of elements separated by forward slashes, and for
1115	* USB devices, the last element in the chain takes the form
1116	* <port>-<port>.[...].<port>[:<config>.<interface>]
1117	* where the first <port> is the port number on the root hub, and the following
1118	* (optional) ones are the port numbers on any other hubs between the device
1119	* and the root hub. The last part (:<config.interface>) is only present for
1120	* interfaces, not for devices. This API should only be called for devices.
1121	* For compatibility with usbfs, which enumerates from zero up, we subtract one
1122	* from the port number.
1123	*
1124	* For root hubs, the last element in the chain takes the form
1125	* usb<hub number>
1126	* and usbfs always returns port number zero.
1127	*
1128	* @returns VBox status code. pu8Port is set on success.
1129	* @param pszPath The sysfs path to parse.
1130	* @param pu8Port Where to store the port number.
1131	*/
1132	static int usbsysfsGetPortFromStr(const char pszPath, uint8_t pu8Port)
1133	{
1134	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
1135	AssertPtrReturn(pu8Port, VERR_INVALID_POINTER);
1136
1137	/*
1138	* This should not be possible until we get PCs with USB as their primary bus.
1139	* Note: We don't assert this, as we don't expect the caller to validate the
1140	* sysfs path.
1141	*/
1142	const char *pszLastComp = strrchr(pszPath, '/');
1143	if (!pszLastComp)
1144	{
1145	Log(("usbGetPortFromSysfsPath(%s): failed [1]\n", pszPath));
1146	return VERR_INVALID_PARAMETER;
1147	}
1148	pszLastComp++; /* skip the slash */
1149
1150	/*
1151	* This API should not be called for interfaces, so the last component
1152	* of the path should not contain a colon. We do assert this, as it
1153	* might indicate a caller bug.
1154	*/
1155	AssertMsgReturn(strchr(pszLastComp, ':') == NULL, ("%s\n", pszPath), VERR_INVALID_PARAMETER);
1156
1157	/*
1158	* Look for the start of the last number.
1159	*/
1160	const char *pchDash = strrchr(pszLastComp, '-');
1161	const char *pchDot = strrchr(pszLastComp, '.');
1162	if (!pchDash && !pchDot)
1163	{
1164	/* No -/. so it must be a root hub. Check that it's usb<something>. */
1165	if (strncmp(pszLastComp, RT_STR_TUPLE("usb")) != 0)
1166	{
1167	Log(("usbGetPortFromSysfsPath(%s): failed [2]\n", pszPath));
1168	return VERR_INVALID_PARAMETER;
1169	}
1170	return VERR_NOT_SUPPORTED;
1171	}
1172
1173	const char *pszLastPort = pchDot != NULL
1174	? pchDot + 1
1175	: pchDash + 1;
1176	int rc = RTStrToUInt8Full(pszLastPort, 10, pu8Port);
1177	if (rc != VINF_SUCCESS)
1178	{
1179	Log(("usbGetPortFromSysfsPath(%s): failed [3], rc=%Rrc\n", pszPath, rc));
1180	return VERR_INVALID_PARAMETER;
1181	}
1182	if (*pu8Port == 0)
1183	{
1184	Log(("usbGetPortFromSysfsPath(%s): failed [4]\n", pszPath));
1185	return VERR_INVALID_PARAMETER;
1186	}
1187
1188	/* usbfs compatibility, 0-based port number. */
1189	pu8Port = (uint8_t)(pu8Port - 1);
1190	return VINF_SUCCESS;
1191	}
1192
1193
1194	/**
1195	* Converts a sysfs BCD value into a uint16_t.
1196	*
1197	* In contrast to usbReadBCD() this function can handle BCD values without
1198	* a decimal separator. This is necessary for parsing bcdDevice.
1199	*
1200	* @param pszBuf Pointer to the string buffer.
1201	* @param pu15 Pointer to the return value.
1202	* @returns IPRT status code.
1203	*/
1204	static int usbsysfsConvertStrToBCD(const char pszBuf, uint16_t pu16)
1205	{
1206	char *pszNext;
1207	int32_t i32;
1208
1209	pszBuf = RTStrStripL(pszBuf);
1210	int rc = RTStrToInt32Ex(pszBuf, &pszNext, 16, &i32);
1211	if ( RT_FAILURE(rc)
1212	\|\| rc == VWRN_NUMBER_TOO_BIG
1213	\|\| i32 < 0)
1214	return VERR_NUMBER_TOO_BIG;
1215	if (*pszNext == '.')
1216	{
1217	if (i32 > 255)
1218	return VERR_NUMBER_TOO_BIG;
1219	int32_t i32Lo;
1220	rc = RTStrToInt32Ex(pszNext+1, &pszNext, 16, &i32Lo);
1221	if ( RT_FAILURE(rc)
1222	\|\| rc == VWRN_NUMBER_TOO_BIG
1223	\|\| i32Lo > 255
1224	\|\| i32Lo < 0)
1225	return VERR_NUMBER_TOO_BIG;
1226	i32 = (i32 << 8) \| i32Lo;
1227	}
1228	if ( i32 > 65535
1229	\|\| (pszNext != '\0' && pszNext != ' '))
1230	return VERR_NUMBER_TOO_BIG;
1231
1232	*pu16 = (uint16_t)i32;
1233	return VINF_SUCCESS;
1234	}
1235
1236
1237	/**
1238	* Returns the byte value for the given device property or sets the given default if an
1239	* error occurs while obtaining it.
1240	*
1241	* @returns uint8_t value of the given property.
1242	* @param uBase The base of the number in the sysfs property.
1243	* @param bDef The default to set on error.
1244	* @param pszFormat The format string for the property.
1245	* @param ... Arguments for the format string.
1246	*/
1247	static uint8_t usbsysfsReadDevicePropertyU8Def(unsigned uBase, uint8_t bDef, const char *pszFormat, ...)
1248	{
1249	int64_t i64Tmp = 0;
1250
1251	va_list va;
1252	va_start(va, pszFormat);
1253	int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
1254	va_end(va);
1255	if (RT_SUCCESS(rc))
1256	return (uint8_t)i64Tmp;
1257	else
1258	return bDef;
1259	}
1260
1261
1262	/**
1263	* Returns the uint16_t value for the given device property or sets the given default if an
1264	* error occurs while obtaining it.
1265	*
1266	* @returns uint16_t value of the given property.
1267	* @param uBase The base of the number in the sysfs property.
1268	* @param u16Def The default to set on error.
1269	* @param pszFormat The format string for the property.
1270	* @param ... Arguments for the format string.
1271	*/
1272	static uint16_t usbsysfsReadDevicePropertyU16Def(unsigned uBase, uint16_t u16Def, const char *pszFormat, ...)
1273	{
1274	int64_t i64Tmp = 0;
1275
1276	va_list va;
1277	va_start(va, pszFormat);
1278	int rc = RTLinuxSysFsReadIntFileV(uBase, &i64Tmp, pszFormat, va);
1279	va_end(va);
1280	if (RT_SUCCESS(rc))
1281	return (uint16_t)i64Tmp;
1282	else
1283	return u16Def;
1284	}
1285
1286
1287	static void usbsysfsFillInDevice(USBDEVICE pDev, USBDeviceInfo pInfo)
1288	{
1289	int rc;
1290	const char *pszSysfsPath = pInfo->mSysfsPath;
1291
1292	/* Fill in the simple fields */
1293	pDev->enmState = USBDEVICESTATE_UNUSED;
1294	pDev->bBus = (uint8_t)usbsysfsGetBusFromPath(pszSysfsPath);
1295	pDev->bDeviceClass = usbsysfsReadDevicePropertyU8Def(16, 0, "%s/bDeviceClass", pszSysfsPath);
1296	pDev->bDeviceSubClass = usbsysfsReadDevicePropertyU8Def(16, 0, "%s/bDeviceSubClass", pszSysfsPath);
1297	pDev->bDeviceProtocol = usbsysfsReadDevicePropertyU8Def(16, 0, "%s/bDeviceProtocol", pszSysfsPath);
1298	pDev->bNumConfigurations = usbsysfsReadDevicePropertyU8Def(10, 0, "%s/bNumConfigurations", pszSysfsPath);
1299	pDev->idVendor = usbsysfsReadDevicePropertyU16Def(16, 0, "%s/idVendor", pszSysfsPath);
1300	pDev->idProduct = usbsysfsReadDevicePropertyU16Def(16, 0, "%s/idProduct", pszSysfsPath);
1301	pDev->bDevNum = usbsysfsReadDevicePropertyU8Def(10, 0, "%s/devnum", pszSysfsPath);
1302
1303	/* Now deal with the non-numeric bits. */
1304	char szBuf[1024]; /* Should be larger than anything a sane device
1305	* will need, and insane devices can be unsupported
1306	* until further notice. */
1307	size_t cchRead;
1308
1309	/* For simplicity, we just do strcmps on the next one. */
1310	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/speed", pszSysfsPath);
1311	if (RT_FAILURE(rc) \|\| cchRead == sizeof(szBuf))
1312	pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
1313	else
1314	pDev->enmSpeed = !strcmp(szBuf, "1.5") ? USBDEVICESPEED_LOW
1315	: !strcmp(szBuf, "12") ? USBDEVICESPEED_FULL
1316	: !strcmp(szBuf, "480") ? USBDEVICESPEED_HIGH
1317	: !strcmp(szBuf, "5000") ? USBDEVICESPEED_SUPER
1318	: USBDEVICESPEED_UNKNOWN;
1319
1320	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/version", pszSysfsPath);
1321	if (RT_FAILURE(rc) \|\| cchRead == sizeof(szBuf))
1322	pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
1323	else
1324	{
1325	rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdUSB);
1326	if (RT_FAILURE(rc))
1327	{
1328	pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
1329	pDev->bcdUSB = UINT16_MAX;
1330	}
1331	}
1332
1333	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/bcdDevice", pszSysfsPath);
1334	if (RT_FAILURE(rc) \|\| cchRead == sizeof(szBuf))
1335	pDev->bcdDevice = UINT16_MAX;
1336	else
1337	{
1338	rc = usbsysfsConvertStrToBCD(szBuf, &pDev->bcdDevice);
1339	if (RT_FAILURE(rc))
1340	pDev->bcdDevice = UINT16_MAX;
1341	}
1342
1343	/* Now do things that need string duplication */
1344	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/product", pszSysfsPath);
1345	if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
1346	{
1347	USBLibPurgeEncoding(szBuf);
1348	pDev->pszProduct = RTStrDup(szBuf);
1349	}
1350
1351	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/serial", pszSysfsPath);
1352	if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
1353	{
1354	USBLibPurgeEncoding(szBuf);
1355	pDev->pszSerialNumber = RTStrDup(szBuf);
1356	pDev->u64SerialHash = USBLibHashSerial(szBuf);
1357	}
1358
1359	rc = RTLinuxSysFsReadStrFile(szBuf, sizeof(szBuf), &cchRead, "%s/manufacturer", pszSysfsPath);
1360	if (RT_SUCCESS(rc) && cchRead < sizeof(szBuf))
1361	{
1362	USBLibPurgeEncoding(szBuf);
1363	pDev->pszManufacturer = RTStrDup(szBuf);
1364	}
1365
1366	/* Work out the port number */
1367	if (RT_FAILURE(usbsysfsGetPortFromStr(pszSysfsPath, &pDev->bPort)))
1368	pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
1369
1370	/* Check the interfaces to see if we can support the device. */
1371	char **ppszIf;
1372	VEC_FOR_EACH(&pInfo->mvecpszInterfaces, char *, ppszIf)
1373	{
1374	rc = RTLinuxSysFsGetLinkDest(szBuf, sizeof(szBuf), NULL, "%s/driver", *ppszIf);
1375	if (RT_SUCCESS(rc) && pDev->enmState != USBDEVICESTATE_UNSUPPORTED)
1376	pDev->enmState = (strcmp(szBuf, "hub") == 0)
1377	? USBDEVICESTATE_UNSUPPORTED
1378	: USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
1379	if (usbsysfsReadDevicePropertyU8Def(16, 9 /* bDev /, "%s/bInterfaceClass", ppszIf) == 9 /* hub */)
1380	pDev->enmState = USBDEVICESTATE_UNSUPPORTED;
1381	}
1382
1383	/* We use a double slash as a separator in the pszAddress field. This is
1384	* alright as the two paths can't contain a slash due to the way we build
1385	* them. */
1386	char *pszAddress = NULL;
1387	RTStrAPrintf(&pszAddress, "sysfs:%s//device:%s", pszSysfsPath, pInfo->mDevice);
1388	pDev->pszAddress = pszAddress;
1389	pDev->pszBackend = RTStrDup("host");
1390
1391	/* Work out from the data collected whether we can support this device. */
1392	pDev->enmState = usbDeterminState(pDev);
1393	usbLogDevice(pDev);
1394	}
1395
1396
1397	/**
1398	* USBProxyService::getDevices() implementation for sysfs.
1399	*/
1400	static PUSBDEVICE usbsysfsGetDevices(const char *pszDevicesRoot, bool fUnsupportedDevicesToo)
1401	{
1402	/* Add each of the devices found to the chain. */
1403	PUSBDEVICE pFirst = NULL;
1404	PUSBDEVICE pLast = NULL;
1405	VECTOR_OBJ(USBDeviceInfo) vecDevInfo;
1406	USBDeviceInfo *pInfo;
1407	int rc;
1408
1409	VEC_INIT_OBJ(&vecDevInfo, USBDeviceInfo, usbsysfsCleanupDevInfo);
1410	rc = usbsysfsEnumerateHostDevices(pszDevicesRoot, &vecDevInfo);
1411	if (RT_FAILURE(rc))
1412	return NULL;
1413	VEC_FOR_EACH(&vecDevInfo, USBDeviceInfo, pInfo)
1414	{
1415	USBDEVICE pDev = (USBDEVICE )RTMemAllocZ(sizeof(USBDEVICE));
1416	if (!pDev)
1417	rc = VERR_NO_MEMORY;
1418	if (RT_SUCCESS(rc))
1419	usbsysfsFillInDevice(pDev, pInfo);
1420	if ( RT_SUCCESS(rc)
1421	&& ( pDev->enmState != USBDEVICESTATE_UNSUPPORTED
1422	\|\| fUnsupportedDevicesToo)
1423	&& pDev->pszAddress != NULL
1424	)
1425	{
1426	if (pLast != NULL)
1427	{
1428	pLast->pNext = pDev;
1429	pLast = pLast->pNext;
1430	}
1431	else
1432	pFirst = pLast = pDev;
1433	}
1434	else
1435	deviceFree(pDev);
1436	if (RT_FAILURE(rc))
1437	break;
1438	}
1439	if (RT_FAILURE(rc))
1440	deviceListFree(&pFirst);
1441
1442	VEC_CLEANUP_OBJ(&vecDevInfo);
1443	return pFirst;
1444	}
1445
1446	#endif /* VBOX_USB_WITH_SYSFS */
1447	#ifdef UNIT_TEST
1448
1449	/* Set up mock functions for USBProxyLinuxCheckDeviceRoot - here dlsym and close
1450	* for the inotify presence check. */
1451	static int testInotifyInitGood(void) { return 0; }
1452	static int testInotifyInitBad(void) { return -1; }
1453	static bool s_fHaveInotifyLibC = true;
1454	static bool s_fHaveInotifyKernel = true;
1455
1456	static void testDLSym(void handle, const char *symbol)
1457	{
1458	RT_NOREF(handle, symbol);
1459	Assert(handle == RTLD_DEFAULT);
1460	Assert(!RTStrCmp(symbol, "inotify_init"));
1461	if (!s_fHaveInotifyLibC)
1462	return NULL;
1463	if (s_fHaveInotifyKernel)
1464	return (void *)(uintptr_t)testInotifyInitGood;
1465	return (void *)(uintptr_t)testInotifyInitBad;
1466	}
1467
1468	void TestUSBSetInotifyAvailable(bool fHaveInotifyLibC, bool fHaveInotifyKernel)
1469	{
1470	s_fHaveInotifyLibC = fHaveInotifyLibC;
1471	s_fHaveInotifyKernel = fHaveInotifyKernel;
1472	}
1473	# define dlsym testDLSym
1474	# define close(a) do {} while (0)
1475
1476	#endif /* UNIT_TEST */
1477
1478	/**
1479	* Is inotify available and working on this system?
1480	*
1481	* This is a requirement for using USB with sysfs
1482	*/
1483	static bool usbsysfsInotifyAvailable(void)
1484	{
1485	int (*inotify_init)(void);
1486
1487	(void *)(&inotify_init) = dlsym(RTLD_DEFAULT, "inotify_init");
1488	if (!inotify_init)
1489	return false;
1490	int fd = inotify_init();
1491	if (fd == -1)
1492	return false;
1493	close(fd);
1494	return true;
1495	}
1496
1497	#ifdef UNIT_TEST
1498
1499	# undef dlsym
1500	# undef close
1501
1502	/** Unit test list of usbfs addresses of connected devices. */
1503	static const char **g_papszUsbfsDeviceAddresses = NULL;
1504
1505	static PUSBDEVICE testGetUsbfsDevices(const char *pszUsbfsRoot, bool fUnsupportedDevicesToo)
1506	{
1507	RT_NOREF(pszUsbfsRoot, fUnsupportedDevicesToo);
1508	const char **psz;
1509	PUSBDEVICE pList = NULL, pTail = NULL;
1510	for (psz = g_papszUsbfsDeviceAddresses; psz && *psz; ++psz)
1511	{
1512	PUSBDEVICE pNext = (PUSBDEVICE)RTMemAllocZ(sizeof(USBDEVICE));
1513	if (pNext)
1514	pNext->pszAddress = RTStrDup(*psz);
1515	if (!pNext \|\| !pNext->pszAddress)
1516	{
1517	if (pNext)
1518	RTMemFree(pNext);
1519	deviceListFree(&pList);
1520	return NULL;
1521	}
1522	if (pTail)
1523	pTail->pNext = pNext;
1524	else
1525	pList = pNext;
1526	pTail = pNext;
1527	}
1528	return pList;
1529	}
1530	# define usbfsGetDevices testGetUsbfsDevices
1531
1532	/**
1533	* Specify the list of devices that will appear to be available through
1534	* usbfs during unit testing (of USBProxyLinuxGetDevices)
1535	* @param pacszDeviceAddresses NULL terminated array of usbfs device addresses
1536	*/
1537	void TestUSBSetAvailableUsbfsDevices(const char **papszDeviceAddresses)
1538	{
1539	g_papszUsbfsDeviceAddresses = papszDeviceAddresses;
1540	}
1541
1542	/** Unit test list of files reported as accessible by access(3). We only do
1543	* accessible or not accessible. */
1544	static const char **g_papszAccessibleFiles = NULL;
1545
1546	static int testAccess(const char *pszPath, int mode)
1547	{
1548	RT_NOREF(mode);
1549	const char **psz;
1550	for (psz = g_papszAccessibleFiles; psz && *psz; ++psz)
1551	if (!RTStrCmp(pszPath, *psz))
1552	return 0;
1553	return -1;
1554	}
1555	# define access testAccess
1556
1557
1558	/**
1559	* Specify the list of files that access will report as accessible (at present
1560	* we only do accessible or not accessible) during unit testing (of
1561	* USBProxyLinuxGetDevices)
1562	* @param papszAccessibleFiles NULL terminated array of file paths to be
1563	* reported accessible
1564	*/
1565	void TestUSBSetAccessibleFiles(const char **papszAccessibleFiles)
1566	{
1567	g_papszAccessibleFiles = papszAccessibleFiles;
1568	}
1569
1570
1571	/** The path we pretend the usbfs root is located at, or NULL. */
1572	const char *s_pszTestUsbfsRoot;
1573	/** Should usbfs be accessible to the current user? */
1574	bool s_fTestUsbfsAccessible;
1575	/** The path we pretend the device node tree root is located at, or NULL. */
1576	const char *s_pszTestDevicesRoot;
1577	/** Should the device node tree be accessible to the current user? */
1578	bool s_fTestDevicesAccessible;
1579	/** The result of the usbfs/inotify-specific init */
1580	int s_rcTestMethodInitResult;
1581	/** The value of the VBOX_USB environment variable. */
1582	const char *s_pszTestEnvUsb;
1583	/** The value of the VBOX_USB_ROOT environment variable. */
1584	const char *s_pszTestEnvUsbRoot;
1585
1586
1587	/** Select which access methods will be available to the @a init method
1588	* during unit testing, and (hack!) what return code it will see from
1589	* the access method-specific initialisation. */
1590	void TestUSBSetupInit(const char *pszUsbfsRoot, bool fUsbfsAccessible,
1591	const char *pszDevicesRoot, bool fDevicesAccessible,
1592	int rcMethodInitResult)
1593	{
1594	s_pszTestUsbfsRoot = pszUsbfsRoot;
1595	s_fTestUsbfsAccessible = fUsbfsAccessible;
1596	s_pszTestDevicesRoot = pszDevicesRoot;
1597	s_fTestDevicesAccessible = fDevicesAccessible;
1598	s_rcTestMethodInitResult = rcMethodInitResult;
1599	}
1600
1601
1602	/** Specify the environment that the @a init method will see during unit
1603	* testing. */
1604	void TestUSBSetEnv(const char pszEnvUsb, const char pszEnvUsbRoot)
1605	{
1606	s_pszTestEnvUsb = pszEnvUsb;
1607	s_pszTestEnvUsbRoot = pszEnvUsbRoot;
1608	}
1609
1610	/* For testing we redefine anything that accesses the outside world to
1611	* return test values. */
1612	# define RTEnvGet(a) \
1613	( !RTStrCmp(a, "VBOX_USB") ? s_pszTestEnvUsb \
1614	: !RTStrCmp(a, "VBOX_USB_ROOT") ? s_pszTestEnvUsbRoot \
1615	: NULL)
1616	# define USBProxyLinuxCheckDeviceRoot(pszPath, fUseNodes) \
1617	( ((fUseNodes) && s_fTestDevicesAccessible \
1618	&& !RTStrCmp(pszPath, s_pszTestDevicesRoot)) \
1619	\|\| (!(fUseNodes) && s_fTestUsbfsAccessible \
1620	&& !RTStrCmp(pszPath, s_pszTestUsbfsRoot)))
1621	# define RTDirExists(pszDir) \
1622	( (pszDir) \
1623	&& ( !RTStrCmp(pszDir, s_pszTestDevicesRoot) \
1624	\|\| !RTStrCmp(pszDir, s_pszTestUsbfsRoot)))
1625	# define RTFileExists(pszFile) \
1626	( (pszFile) \
1627	&& s_pszTestUsbfsRoot \
1628	&& !RTStrNCmp(pszFile, s_pszTestUsbfsRoot, strlen(s_pszTestUsbfsRoot)) \
1629	&& !RTStrCmp(pszFile + strlen(s_pszTestUsbfsRoot), "/devices"))
1630
1631	#endif /* UNIT_TEST */
1632
1633	/**
1634	* Use USBFS-like or sysfs/device node-like access method?
1635	*
1636	* Selects the access method that will be used to access USB devices based on
1637	* what is available on the host and what if anything the user has specified
1638	* in the environment.
1639	*
1640	* @returns iprt status value
1641	* @param pfUsingUsbfsDevices on success this will be set to true if
1642	* the prefered access method is USBFS-like and to
1643	* false if it is sysfs/device node-like
1644	* @param ppszDevicesRoot on success the root of the tree of USBFS-like
1645	* device nodes will be stored here
1646	*/
1647	int USBProxyLinuxChooseMethod(bool pfUsingUsbfsDevices, const char *ppszDevicesRoot)
1648	{
1649	/*
1650	* We have two methods available for getting host USB device data - using
1651	* USBFS and using sysfs. The default choice is sysfs; if that is not
1652	* available we fall back to USBFS.
1653	* In the event of both failing, an appropriate error will be returned.
1654	* The user may also specify a method and root using the VBOX_USB and
1655	* VBOX_USB_ROOT environment variables. In this case we don't check
1656	* the root they provide for validity.
1657	*/
1658	bool fUsbfsChosen = false;
1659	bool fSysfsChosen = false;
1660	const char *pszUsbFromEnv = RTEnvGet("VBOX_USB");
1661	const char *pszUsbRoot = NULL;
1662	if (pszUsbFromEnv)
1663	{
1664	bool fValidVBoxUSB = true;
1665
1666	pszUsbRoot = RTEnvGet("VBOX_USB_ROOT");
1667	if (!RTStrICmp(pszUsbFromEnv, "USBFS"))
1668	{
1669	LogRel(("Default USB access method set to \"usbfs\" from environment\n"));
1670	fUsbfsChosen = true;
1671	}
1672	else if (!RTStrICmp(pszUsbFromEnv, "SYSFS"))
1673	{
1674	LogRel(("Default USB method set to \"sysfs\" from environment\n"));
1675	fSysfsChosen = true;
1676	}
1677	else
1678	{
1679	LogRel(("Invalid VBOX_USB environment variable setting \"%s\"\n", pszUsbFromEnv));
1680	fValidVBoxUSB = false;
1681	pszUsbFromEnv = NULL;
1682	}
1683	if (!fValidVBoxUSB && pszUsbRoot)
1684	pszUsbRoot = NULL;
1685	}
1686	if (!pszUsbRoot)
1687	{
1688	if ( !fUsbfsChosen
1689	&& USBProxyLinuxCheckDeviceRoot("/dev/vboxusb", true))
1690	{
1691	fSysfsChosen = true;
1692	pszUsbRoot = "/dev/vboxusb";
1693	}
1694	else if ( !fSysfsChosen
1695	&& USBProxyLinuxCheckDeviceRoot("/proc/bus/usb", false))
1696	{
1697	fUsbfsChosen = true;
1698	pszUsbRoot = "/proc/bus/usb";
1699	}
1700	}
1701	else if (!USBProxyLinuxCheckDeviceRoot(pszUsbRoot, fSysfsChosen))
1702	pszUsbRoot = NULL;
1703	if (pszUsbRoot)
1704	{
1705	*pfUsingUsbfsDevices = fUsbfsChosen;
1706	*ppszDevicesRoot = pszUsbRoot;
1707	return VINF_SUCCESS;
1708	}
1709	/* else */
1710	return pszUsbFromEnv ? VERR_NOT_FOUND
1711	: RTDirExists("/dev/vboxusb") ? VERR_VUSB_USB_DEVICE_PERMISSION
1712	: RTFileExists("/proc/bus/usb/devices") ? VERR_VUSB_USBFS_PERMISSION
1713	: VERR_NOT_FOUND;
1714	}
1715
1716	#ifdef UNIT_TEST
1717	# undef RTEnvGet
1718	# undef USBProxyLinuxCheckDeviceRoot
1719	# undef RTDirExists
1720	# undef RTFileExists
1721	#endif
1722
1723	/**
1724	* Check whether a USB device tree root is usable.
1725	*
1726	* @param pszRoot the path to the root of the device tree
1727	* @param fIsDeviceNodes whether this is a device node (or usbfs) tree
1728	* @note returns a pointer into a static array so it will stay valid
1729	*/
1730	bool USBProxyLinuxCheckDeviceRoot(const char *pszRoot, bool fIsDeviceNodes)
1731	{
1732	bool fOK = false;
1733	if (!fIsDeviceNodes) /* usbfs */
1734	{
1735	#ifdef VBOX_USB_WITH_USBFS
1736	if (!access(pszRoot, R_OK \| X_OK))
1737	{
1738	fOK = true;
1739	PUSBDEVICE pDevices = usbfsGetDevices(pszRoot, true);
1740	if (pDevices)
1741	{
1742	PUSBDEVICE pDevice;
1743	for (pDevice = pDevices; pDevice && fOK; pDevice = pDevice->pNext)
1744	if (access(pDevice->pszAddress, R_OK \| W_OK))
1745	fOK = false;
1746	deviceListFree(&pDevices);
1747	}
1748	}
1749	#endif
1750	}
1751	#ifdef VBOX_USB_WITH_SYSFS
1752	/* device nodes */
1753	else if (usbsysfsInotifyAvailable() && !access(pszRoot, R_OK \| X_OK))
1754	fOK = true;
1755	#endif
1756	return fOK;
1757	}
1758
1759	#ifdef UNIT_TEST
1760	# undef usbfsGetDevices
1761	# undef access
1762	#endif
1763
1764	/**
1765	* Get the list of USB devices supported by the system.
1766	*
1767	* Result should be freed using #deviceFree or something equivalent.
1768	*
1769	* @param pszDevicesRoot the path to the root of the device tree
1770	* @param fUseSysfs whether to use sysfs (or usbfs) for enumeration
1771	*/
1772	PUSBDEVICE USBProxyLinuxGetDevices(const char *pszDevicesRoot, bool fUseSysfs)
1773	{
1774	if (!fUseSysfs)
1775	{
1776	#ifdef VBOX_USB_WITH_USBFS
1777	return usbfsGetDevices(pszDevicesRoot, false);
1778	#else
1779	return NULL;
1780	#endif
1781	}
1782
1783	#ifdef VBOX_USB_WITH_SYSFS
1784	return usbsysfsGetDevices(pszDevicesRoot, false);
1785	#else
1786	return NULL;
1787	#endif
1788	}
1789

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/linux/USBGetDevices.cpp@ 66900

Download in other formats: