HostHardwareLinux.cpp@ 28345

Last change on this file since 28345 was 28315, checked in by vboxsync, 15 years ago
Main/HostHardwareLinux: fix a burn when VBOX_WITH_DBUS is not defined
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 80.4 KB

Line
1	/* $Id: HostHardwareLinux.cpp 28315 2010-04-14 16:34:00Z vboxsync $ */
2	/** @file
3	* Classes for handling hardware detection under Linux. Please feel free to
4	* expand these to work for other systems (Solaris!) or to add new ones for
5	* other systems.
6	*/
7
8	/*
9	* Copyright (C) 2008 Sun Microsystems, Inc.
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License (GPL) as published by the Free Software
15	* Foundation, in version 2 as it comes in the "COPYING" file of the
16	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20	* Clara, CA 95054 USA or visit http://www.sun.com if you need
21	* additional information or have any questions.
22	*/
23
24	#define LOG_GROUP LOG_GROUP_MAIN
25
26	/*******************************************************************************
27	* Header Files *
28	*******************************************************************************/
29
30	#include <HostHardwareLinux.h>
31
32	#include <VBox/log.h>
33	# ifdef VBOX_WITH_DBUS
34	# include <VBox/dbus.h>
35	# endif
36
37	#include <iprt/dir.h>
38	#include <iprt/env.h>
39	#include <iprt/file.h>
40	#include <iprt/mem.h>
41	#include <iprt/param.h>
42	#include <iprt/path.h>
43	#include <iprt/thread.h> /* for RTThreadSleep() */
44	#include <iprt/string.h>
45
46	#ifdef RT_OS_LINUX
47	# include <sys/types.h>
48	# include <sys/stat.h>
49	# include <unistd.h>
50	# include <fcntl.h>
51	/* bird: This is a hack to work around conflicts between these linux kernel headers
52	* and the GLIBC tcpip headers. They have different declarations of the 4
53	* standard byte order functions. */
54	// # define _LINUX_BYTEORDER_GENERIC_H
55	# define _LINUX_BYTEORDER_SWABB_H
56	# include <linux/cdrom.h>
57	# include <linux/fd.h>
58	# include <linux/major.h>
59	# include <errno.h>
60	# include <scsi/scsi.h>
61
62	# include <iprt/linux/sysfs.h>
63	#endif /* RT_OS_LINUX */
64	#include <vector>
65
66	/******************************************************************************
67	* Global Variables *
68	******************************************************************************/
69
70	#ifdef TESTCASE
71	static bool testing() { return true; }
72	static bool fNoProbe = false;
73	static bool noProbe() { return fNoProbe; }
74	static void setNoProbe(bool val) { fNoProbe = val; }
75	#else
76	static bool testing() { return false; }
77	static bool noProbe() { return false; }
78	static void setNoProbe(bool val) { (void)val; }
79	#endif
80
81	/******************************************************************************
82	* Typedefs and Defines *
83	******************************************************************************/
84
85	/** When waiting for hotplug events, we currently restart the wait after at
86	* most this many milliseconds. */
87	enum { DBUS_POLL_TIMEOUT = 2000 /* ms */ };
88
89	static int getDriveInfoFromEnv(const char pcszVar, DriveInfoList pList,
90	bool isDVD, bool *pfSuccess);
91	static int getDriveInfoFromDev(DriveInfoList *pList, bool isDVD,
92	bool *pfSuccess);
93	static int getDriveInfoFromSysfs(DriveInfoList *pList, bool isDVD,
94	bool *pfSuccess);
95	static int getUSBDeviceInfoFromSysfs(USBDeviceInfoList pList, bool pfSuccess);
96	#ifdef VBOX_WITH_DBUS
97	/* These must be extern to be usable in the RTMemAutoPtr template */
98	extern void VBoxHalShutdown (DBusConnection *pConnection);
99	extern void VBoxHalShutdownPrivate (DBusConnection *pConnection);
100	extern void VBoxDBusConnectionUnref(DBusConnection *pConnection);
101	extern void VBoxDBusConnectionCloseAndUnref(DBusConnection *pConnection);
102	extern void VBoxDBusMessageUnref(DBusMessage *pMessage);
103
104	static int halInit(RTMemAutoPtr <DBusConnection, VBoxHalShutdown> *pConnection);
105	static int halInitPrivate(RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> *pConnection);
106	static int halFindDeviceStringMatch (DBusConnection *pConnection,
107	const char pszKey, const char pszValue,
108	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage);
109	/*
110	static int halFindDeviceStringMatchVector (DBusConnection *pConnection,
111	const char *pszKey,
112	const char *pszValue,
113	std::vector<iprt::MiniString> *pMatches);
114	*/
115	static int halGetPropertyStrings (DBusConnection *pConnection,
116	const char *pszUdi, size_t cKeys,
117	const char papszKeys, char papszValues,
118	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage);
119	/*
120	static int halGetPropertyStringsVector (DBusConnection *pConnection,
121	const char *pszUdi, size_t cProps,
122	const char **papszKeys,
123	std::vector<iprt::MiniString> *pMatches,
124	bool pfMatches, bool pfSuccess);
125	*/
126	static int getUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess);
127	static int getOldUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess);
128	static int getUSBInterfacesFromHal(std::vector <iprt::MiniString> *pList,
129	const char pcszUdi, bool pfSuccess);
130	static DBusHandlerResult dbusFilterFunction (DBusConnection *pConnection,
131	DBusMessage pMessage, void pvUser);
132	#endif /* VBOX_WITH_DBUS */
133
134
135	/** Find the length of a string, ignoring trailing non-ascii or control
136	* characters */
137	static size_t strLenStripped(const char *pcsz)
138	{
139	size_t cch = 0;
140	for (size_t i = 0; pcsz[i] != '\0'; ++i)
141	if (pcsz[i] > 32 && pcsz[i] < 127)
142	cch = i;
143	return cch + 1;
144	}
145
146
147	/**
148	* Get the name of a floppy drive according to the Linux floppy driver.
149	* @returns true on success, false if the name was not available (i.e. the
150	* device was not readible, or the file name wasn't a PC floppy
151	* device)
152	* @param pcszNode the path to the device node for the device
153	* @param Number the Linux floppy driver number for the drive. Required.
154	* @param pszName where to store the name retreived
155	*/
156	static bool floppyGetName(const char *pcszNode, unsigned Number,
157	floppy_drive_name pszName)
158	{
159	AssertPtrReturn(pcszNode, false);
160	AssertPtrReturn(pszName, false);
161	AssertReturn(Number <= 7, false);
162	RTFILE File;
163	int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_NON_BLOCK);
164	if (RT_SUCCESS(rc))
165	{
166	int rcIoCtl;
167	/** @todo The next line can produce a warning, as the ioctl request
168	* field is defined as signed, but the Linux ioctl definition macros
169	* produce unsigned constants. */
170	rc = RTFileIoCtl(File, FDGETDRVTYP, pszName, 0, &rcIoCtl);
171	RTFileClose(File);
172	if (RT_SUCCESS(rc) && rcIoCtl >= 0)
173	return true;
174	}
175	return false;
176	}
177
178
179	/**
180	* Create a UDI and a description for a floppy drive based on a number and the
181	* driver's name for it. We deliberately return an ugly sequence of
182	* characters as the description rather than an English language string to
183	* avoid translation issues.
184	*
185	* @returns true if we know the device to be valid, false otherwise
186	* @param pcszName the floppy driver name for the device (optional)
187	* @param Number the number of the floppy (0 to 3 on FDC 0, 4 to 7 on
188	* FDC 1)
189	* @param pszDesc where to store the device description (optional)
190	* @param cchDesc the size of the buffer in @a pszDesc
191	* @param pszUdi where to store the device UDI (optional)
192	* @param cchUdi the size of the buffer in @a pszUdi
193	*/
194	static void floppyCreateDeviceStrings(const floppy_drive_name pcszName,
195	unsigned Number, char *pszDesc,
196	size_t cchDesc, char *pszUdi,
197	size_t cchUdi)
198	{
199	AssertPtrNullReturnVoid(pcszName);
200	AssertPtrNullReturnVoid(pszDesc);
201	AssertReturnVoid(!pszDesc \|\| cchDesc > 0);
202	AssertPtrNullReturnVoid(pszUdi);
203	AssertReturnVoid(!pszUdi \|\| cchUdi > 0);
204	AssertReturnVoid(Number <= 7);
205	if (pcszName)
206	{
207	const char *pcszSize;
208	switch(pcszName[0])
209	{
210	case 'd': case 'q': case 'h':
211	pcszSize = "5.25\"";
212	break;
213	case 'D': case 'H': case 'E': case 'u':
214	pcszSize = "3.5\"";
215	break;
216	default:
217	pcszSize = "(unknown)";
218	}
219	if (pszDesc)
220	RTStrPrintf(pszDesc, cchDesc, "%s %s K%s", pcszSize, &pcszName[1],
221	Number > 3 ? ", FDC 2" : "");
222	}
223	else
224	{
225	if (pszDesc)
226	RTStrPrintf(pszDesc, cchDesc, "FDD %d%s", (Number & 4) + 1,
227	Number > 3 ? ", FDC 2" : "");
228	}
229	if (pszUdi)
230	RTStrPrintf(pszUdi, cchUdi,
231	"/org/freedesktop/Hal/devices/platform_floppy_%u_storage",
232	Number);
233	}
234
235
236	/**
237	* Check whether a device number might correspond to a CD-ROM device according
238	* to Documentation/devices.txt in the Linux kernel source.
239	* @returns true if it might, false otherwise
240	* @param Number the device number (major and minor combination)
241	*/
242	static bool isCdromDevNum(dev_t Number)
243	{
244	int major = major(Number);
245	int minor = minor(Number);
246	if ((major == IDE0_MAJOR) && !(minor & 0x3f))
247	return true;
248	if (major == SCSI_CDROM_MAJOR)
249	return true;
250	if (major == CDU31A_CDROM_MAJOR)
251	return true;
252	if (major == GOLDSTAR_CDROM_MAJOR)
253	return true;
254	if (major == OPTICS_CDROM_MAJOR)
255	return true;
256	if (major == SANYO_CDROM_MAJOR)
257	return true;
258	if (major == MITSUMI_X_CDROM_MAJOR)
259	return true;
260	if ((major == IDE1_MAJOR) && !(minor & 0x3f))
261	return true;
262	if (major == MITSUMI_CDROM_MAJOR)
263	return true;
264	if (major == CDU535_CDROM_MAJOR)
265	return true;
266	if (major == MATSUSHITA_CDROM_MAJOR)
267	return true;
268	if (major == MATSUSHITA_CDROM2_MAJOR)
269	return true;
270	if (major == MATSUSHITA_CDROM3_MAJOR)
271	return true;
272	if (major == MATSUSHITA_CDROM4_MAJOR)
273	return true;
274	if (major == AZTECH_CDROM_MAJOR)
275	return true;
276	if (major == 30 /* CM205_CDROM_MAJOR /) / no #define for some reason */
277	return true;
278	if (major == CM206_CDROM_MAJOR)
279	return true;
280	if ((major == IDE3_MAJOR) && !(minor & 0x3f))
281	return true;
282	if (major == 46 /* Parallel port ATAPI CD-ROM /) / no #define */
283	return true;
284	if ((major == IDE4_MAJOR) && !(minor & 0x3f))
285	return true;
286	if ((major == IDE5_MAJOR) && !(minor & 0x3f))
287	return true;
288	if ((major == IDE6_MAJOR) && !(minor & 0x3f))
289	return true;
290	if ((major == IDE7_MAJOR) && !(minor & 0x3f))
291	return true;
292	if ((major == IDE8_MAJOR) && !(minor & 0x3f))
293	return true;
294	if ((major == IDE9_MAJOR) && !(minor & 0x3f))
295	return true;
296	if (major == 113 /* VIOCD_MAJOR */)
297	return true;
298	return false;
299	}
300
301
302	/**
303	* Send an SCSI INQUIRY command to a device and return selected information.
304	* @returns iprt status code
305	* @returns VERR_TRY_AGAIN if the query failed but might succeed next time
306	* @param pcszNode the full path to the device node
307	* @param pu8Type where to store the SCSI device type on success (optional)
308	* @param pchVendor where to store the vendor id string on success (optional)
309	* @param cchVendor the size of the @a pchVendor buffer
310	* @param pchModel where to store the product id string on success (optional)
311	* @param cchModel the size of the @a pchModel buffer
312	* @note check documentation on the SCSI INQUIRY command and the Linux kernel
313	* SCSI headers included above if you want to understand what is going
314	* on in this method.
315	*/
316	static int cdromDoInquiry(const char pcszNode, uint8_t pu8Type,
317	char pchVendor, size_t cchVendor, char pchModel,
318	size_t cchModel)
319	{
320	LogRelFlowFunc(("pcszNode=%s, pu8Type=%p, pchVendor=%p, cchVendor=%llu, pchModel=%p, cchModel=%llu\n",
321	pcszNode, pu8Type, pchVendor, cchVendor, pchModel,
322	cchModel));
323	AssertPtrReturn(pcszNode, VERR_INVALID_POINTER);
324	AssertPtrNullReturn(pu8Type, VERR_INVALID_POINTER);
325	AssertPtrNullReturn(pchVendor, VERR_INVALID_POINTER);
326	AssertPtrNullReturn(pchModel, VERR_INVALID_POINTER);
327
328	RTFILE hFile;
329	int rc = RTFileOpen(&hFile, pcszNode, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE \| RTFILE_O_NON_BLOCK);
330	if (RT_SUCCESS(rc))
331	{
332	int rcIoCtl = 0;
333	unsigned char u8Response[96] = { 0 };
334	struct cdrom_generic_command CdromCommandReq;
335	RT_ZERO(CdromCommandReq);
336	CdromCommandReq.cmd[0] = INQUIRY;
337	CdromCommandReq.cmd[4] = sizeof(u8Response);
338	CdromCommandReq.buffer = u8Response;
339	CdromCommandReq.buflen = sizeof(u8Response);
340	CdromCommandReq.data_direction = CGC_DATA_READ;
341	CdromCommandReq.timeout = 5000; /* ms */
342	rc = RTFileIoCtl(hFile, CDROM_SEND_PACKET, &CdromCommandReq, 0, &rcIoCtl);
343	if (RT_SUCCESS(rc) && rcIoCtl < 0)
344	rc = RTErrConvertFromErrno(-CdromCommandReq.stat);
345	RTFileClose(hFile);
346
347	if (RT_SUCCESS(rc))
348	{
349	if (pu8Type)
350	*pu8Type = u8Response[0] & 0x1f;
351	if (pchVendor)
352	RTStrPrintf(pchVendor, cchVendor, "%.8s",
353	&u8Response[8] /* vendor id string */);
354	if (pchModel)
355	RTStrPrintf(pchModel, cchModel, "%.16s",
356	&u8Response[16] /* product id string */);
357	LogRelFlowFunc(("returning success: type=%u, vendor=%.8s, product=%.16s\n",
358	u8Response[0] & 0x1f, &u8Response[8], &u8Response[16]));
359	return VINF_SUCCESS;
360	}
361	}
362	LogRelFlowFunc(("returning %Rrc\n", rc));
363	return rc;
364	}
365
366
367	/**
368	* Initialise the device strings (description and UDI) for a DVD drive based on
369	* vendor and model name strings.
370	* @param pcszVendor the vendor ID string
371	* @param pcszModel the product ID string
372	* @param pszDesc where to store the description string (optional)
373	* @param cchDesc the size of the buffer in @pszDesc
374	* @param pszUdi where to store the UDI string (optional)
375	* @param cchUdi the size of the buffer in @pszUdi
376	*/
377	/* static */
378	void dvdCreateDeviceStrings(const char pcszVendor, const char pcszModel,
379	char pszDesc, size_t cchDesc, char pszUdi,
380	size_t cchUdi)
381	{
382	AssertPtrReturnVoid(pcszVendor);
383	AssertPtrReturnVoid(pcszModel);
384	AssertPtrNullReturnVoid(pszDesc);
385	AssertReturnVoid(!pszDesc \|\| cchDesc > 0);
386	AssertPtrNullReturnVoid(pszUdi);
387	AssertReturnVoid(!pszUdi \|\| cchUdi > 0);
388	char szCleaned[128];
389	size_t cchVendor = strLenStripped(pcszVendor);
390	size_t cchModel = strLenStripped(pcszModel);
391
392	/* Create a cleaned version of the model string for the UDI string. */
393	for (unsigned i = 0; pcszModel[i] != '\0' && i < sizeof(szCleaned); ++i)
394	if ( (pcszModel[i] >= '0' && pcszModel[i] <= '9')
395	\|\| (pcszModel[i] >= 'A' && pcszModel[i] <= 'z'))
396	szCleaned[i] = pcszModel[i];
397	else
398	szCleaned[i] = '_';
399	szCleaned[RT_MIN(cchModel, sizeof(szCleaned) - 1)] = '\0';
400
401	/* Construct the description string as "Vendor Product" */
402	if (pszDesc)
403	{
404	if (cchVendor > 0)
405	RTStrPrintf(pszDesc, cchDesc, "%.*s %s", cchVendor, pcszVendor,
406	cchModel > 0 ? pcszModel : "(unknown drive model)");
407	else
408	RTStrPrintf(pszDesc, cchDesc, "%s", pcszModel);
409	}
410	/* Construct the UDI string */
411	if (pszUdi)
412	{
413	if (cchModel > 0)
414	RTStrPrintf(pszUdi, cchUdi,
415	"/org/freedesktop/Hal/devices/storage_model_%s",
416	szCleaned);
417	else
418	pszUdi[0] = '\0';
419	}
420	}
421
422
423	/**
424	* Check whether a device node points to a valid device and create a UDI and
425	* a description for it, and store the device number, if it does.
426	* @returns true if the device is valid, false otherwise
427	* @param pcszNode the path to the device node
428	* @param isDVD are we looking for a DVD device (or a floppy device)?
429	* @param pDevice where to store the device node (optional)
430	* @param pszDesc where to store the device description (optional)
431	* @param cchDesc the size of the buffer in @a pszDesc
432	* @param pszUdi where to store the device UDI (optional)
433	* @param cchUdi the size of the buffer in @a pszUdi
434	*/
435	static bool devValidateDevice(const char pcszNode, bool isDVD, dev_t pDevice,
436	char pszDesc, size_t cchDesc, char pszUdi,
437	size_t cchUdi)
438	{
439	AssertPtrReturn(pcszNode, false);
440	AssertPtrNullReturn(pDevice, false);
441	AssertPtrNullReturn(pszDesc, false);
442	AssertReturn(!pszDesc \|\| cchDesc > 0, false);
443	AssertPtrNullReturn(pszUdi, false);
444	AssertReturn(!pszUdi \|\| cchUdi > 0, false);
445	RTFSOBJINFO ObjInfo;
446	if (RT_FAILURE(RTPathQueryInfo(pcszNode, &ObjInfo, RTFSOBJATTRADD_UNIX)))
447	return false;
448	if (!RTFS_IS_DEV_BLOCK(ObjInfo.Attr.fMode))
449	return false;
450	if (pDevice)
451	*pDevice = ObjInfo.Attr.u.Unix.Device;
452	if (isDVD)
453	{
454	char szVendor[128], szModel[128];
455	uint8_t u8Type;
456	if (!isCdromDevNum(ObjInfo.Attr.u.Unix.Device))
457	return false;
458	if (RT_FAILURE(cdromDoInquiry(pcszNode, &u8Type,
459	szVendor, sizeof(szVendor),
460	szModel, sizeof(szModel))))
461	return false;
462	if (u8Type != TYPE_ROM)
463	return false;
464	dvdCreateDeviceStrings(szVendor, szModel, pszDesc, cchDesc,
465	pszUdi, cchUdi);
466	}
467	else
468	{
469	/* Floppies on Linux are legacy devices with hardcoded majors and
470	* minors */
471	unsigned Number;
472	floppy_drive_name szName;
473	if (major(ObjInfo.Attr.u.Unix.Device) != FLOPPY_MAJOR)
474	return false;
475	switch (minor(ObjInfo.Attr.u.Unix.Device))
476	{
477	case 0: case 1: case 2: case 3:
478	Number = minor(ObjInfo.Attr.u.Unix.Device);
479	break;
480	case 128: case 129: case 130: case 131:
481	Number = minor(ObjInfo.Attr.u.Unix.Device) - 128 + 4;
482	break;
483	default:
484	return false;
485	}
486	if (!floppyGetName(pcszNode, Number, szName))
487	return false;
488	floppyCreateDeviceStrings(szName, Number, pszDesc, cchDesc, pszUdi,
489	cchUdi);
490	}
491	return true;
492	}
493
494
495	int VBoxMainDriveInfo::updateDVDs ()
496	{
497	LogFlowThisFunc(("entered\n"));
498	int rc = VINF_SUCCESS;
499	bool success = false; /* Have we succeeded in finding anything yet? */
500	try
501	{
502	mDVDList.clear ();
503	/* Always allow the user to override our auto-detection using an
504	* environment variable. */
505	if (RT_SUCCESS(rc) && (!success \|\| testing()))
506	rc = getDriveInfoFromEnv ("VBOX_CDROM", &mDVDList, true /* isDVD */,
507	&success);
508	setNoProbe(false);
509	if (RT_SUCCESS(rc) && (!success \| testing()))
510	rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
511	if (RT_SUCCESS(rc) && testing())
512	{
513	setNoProbe(true);
514	rc = getDriveInfoFromSysfs(&mDVDList, true /* isDVD */, &success);
515	}
516	/* Walk through the /dev subtree if nothing else has helped. */
517	if (RT_SUCCESS(rc) && (!success \| testing()))
518	rc = getDriveInfoFromDev(&mDVDList, true /* isDVD */, &success);
519	}
520	catch(std::bad_alloc &e)
521	{
522	rc = VERR_NO_MEMORY;
523	}
524	LogFlowThisFunc(("rc=%Rrc\n", rc));
525	return rc;
526	}
527
528	int VBoxMainDriveInfo::updateFloppies ()
529	{
530	LogFlowThisFunc(("entered\n"));
531	int rc = VINF_SUCCESS;
532	bool success = false; /* Have we succeeded in finding anything yet? */
533	try
534	{
535	mFloppyList.clear ();
536	if (RT_SUCCESS(rc) && (!success \|\| testing()))
537	rc = getDriveInfoFromEnv("VBOX_FLOPPY", &mFloppyList,
538	false /* isDVD */, &success);
539	setNoProbe(false);
540	if ( RT_SUCCESS(rc) && (!success \|\| testing()))
541	rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */,
542	&success);
543	if (RT_SUCCESS(rc) && testing())
544	{
545	setNoProbe(true);
546	rc = getDriveInfoFromSysfs(&mFloppyList, false /* isDVD */, &success);
547	}
548	/* Walk through the /dev subtree if nothing else has helped. */
549	if ( RT_SUCCESS(rc) && (!success \|\| testing()))
550	rc = getDriveInfoFromDev(&mFloppyList, false /* isDVD */,
551	&success);
552	}
553	catch(std::bad_alloc &e)
554	{
555	rc = VERR_NO_MEMORY;
556	}
557	LogFlowThisFunc(("rc=%Rrc\n", rc));
558	return rc;
559	}
560
561
562	/**
563	* Extract the names of drives from an environment variable and add them to a
564	* list if they are valid.
565	* @returns iprt status code
566	* @param pcszVar the name of the environment variable. The variable
567	* value should be a list of device node names, separated
568	* by ':' characters.
569	* @param pList the list to append the drives found to
570	* @param isDVD are we looking for DVD drives or for floppies?
571	* @param pfSuccess this will be set to true if we found at least one drive
572	* and to false otherwise. Optional.
573	*/
574	/* static */
575	int getDriveInfoFromEnv(const char pcszVar, DriveInfoList pList,
576	bool isDVD, bool *pfSuccess)
577	{
578	AssertPtrReturn(pcszVar, VERR_INVALID_POINTER);
579	AssertPtrReturn(pList, VERR_INVALID_POINTER);
580	AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
581	LogFlowFunc(("pcszVar=%s, pList=%p, isDVD=%d, pfSuccess=%p\n", pcszVar,
582	pList, isDVD, pfSuccess));
583	int rc = VINF_SUCCESS;
584	bool success = false;
585	char *pszFreeMe = RTEnvDupEx(RTENV_DEFAULT, pcszVar);
586
587	try
588	{
589	const char *pcszCurrent = pszFreeMe;
590	while (pcszCurrent && *pcszCurrent != '\0')
591	{
592	const char *pcszNext = strchr(pcszCurrent, ':');
593	char szPath[RTPATH_MAX], szReal[RTPATH_MAX];
594	char szDesc[256], szUdi[256];
595	if (pcszNext)
596	RTStrPrintf(szPath, sizeof(szPath), "%.*s",
597	pcszNext - pcszCurrent - 1, pcszCurrent);
598	else
599	RTStrPrintf(szPath, sizeof(szPath), "%s", pcszCurrent);
600	if ( RT_SUCCESS(RTPathReal(szPath, szReal, sizeof(szReal)))
601	&& devValidateDevice(szReal, isDVD, NULL, szDesc,
602	sizeof(szDesc), szUdi, sizeof(szUdi)))
603	{
604	pList->push_back(DriveInfo(szReal, szUdi, szDesc));
605	success = true;
606	}
607	pcszCurrent = pcszNext ? pcszNext + 1 : NULL;
608	}
609	if (pfSuccess != NULL)
610	*pfSuccess = success;
611	}
612	catch(std::bad_alloc &e)
613	{
614	rc = VERR_NO_MEMORY;
615	}
616	RTStrFree(pszFreeMe);
617	LogFlowFunc(("rc=%Rrc, success=%d\n", rc, success));
618	return rc;
619	}
620
621
622	class sysfsBlockDev
623	{
624	public:
625	sysfsBlockDev(const char *pcszName, bool wantDVD)
626	: mpcszName(pcszName), mwantDVD(wantDVD), misConsistent(true),
627	misValid(false)
628	{
629	if (findDeviceNode())
630	{
631	if (mwantDVD)
632	validateAndInitForDVD();
633	else
634	validateAndInitForFloppy();
635	}
636	}
637	private:
638	/** The name of the subdirectory of /sys/block for this device */
639	const char *mpcszName;
640	/** Are we looking for a floppy or a DVD device? */
641	bool mwantDVD;
642	/** The device node for the device */
643	char mszNode[RTPATH_MAX];
644	/** Does the sysfs entry look like we expect it too? This is a canary
645	* for future sysfs ABI changes. */
646	bool misConsistent;
647	/** Is this entry a valid specimen of what we are looking for? */
648	bool misValid;
649	/** Human readible drive description string */
650	char mszDesc[256];
651	/** Unique identifier for the drive. Should be identical to hal's UDI for
652	* the device. May not be unique for two identical drives. */
653	char mszUdi[256];
654	private:
655	/* Private methods */
656
657	/**
658	* Fill in the device node member based on the /sys/block subdirectory.
659	* @returns boolean success value
660	*/
661	bool findDeviceNode()
662	{
663	dev_t dev = RTLinuxSysFsReadDevNumFile("block/%s/dev", mpcszName);
664	if (dev == 0)
665	{
666	misConsistent = false;
667	return false;
668	}
669	if (RTLinuxFindDevicePath(dev, RTFS_TYPE_DEV_BLOCK, mszNode,
670	sizeof(mszNode), "%s", mpcszName) < 0)
671	return false;
672	return true;
673	}
674
675	/** Check whether the sysfs block entry is valid for a DVD device and
676	* initialise the string data members for the object. We try to get all
677	* the information we need from sysfs if possible, to avoid unnecessarily
678	* poking the device, and if that fails we fall back to an SCSI INQUIRY
679	* command. */
680	void validateAndInitForDVD()
681	{
682	char szVendor[128], szModel[128];
683	ssize_t cchVendor, cchModel;
684	int64_t type = RTLinuxSysFsReadIntFile(10, "block/%s/device/type",
685	mpcszName);
686	if (type >= 0 && type != TYPE_ROM)
687	return;
688	if (type == TYPE_ROM)
689	{
690	cchVendor = RTLinuxSysFsReadStrFile(szVendor, sizeof(szVendor),
691	"block/%s/device/vendor",
692	mpcszName);
693	if (cchVendor >= 0)
694	{
695	cchModel = RTLinuxSysFsReadStrFile(szModel, sizeof(szModel),
696	"block/%s/device/model",
697	mpcszName);
698	if (cchModel >= 0)
699	{
700	misValid = true;
701	dvdCreateDeviceStrings(szVendor, szModel,
702	mszDesc, sizeof(mszDesc),
703	mszUdi, sizeof(mszUdi));
704	return;
705	}
706	}
707	}
708	if (!noProbe())
709	probeAndInitForDVD();
710	}
711
712	/** Try to find out whether a device is a DVD drive by sending it an
713	* SCSI INQUIRY command. If it is, initialise the string and validity
714	* data members for the object based on the returned data.
715	*/
716	void probeAndInitForDVD()
717	{
718	AssertReturnVoid(mszNode[0] != '\0');
719	uint8_t u8Type = 0;
720	char szVendor[128] = "";
721	char szModel[128] = "";
722	int rc = cdromDoInquiry(mszNode, &u8Type, szVendor,
723	sizeof(szVendor), szModel,
724	sizeof(szModel));
725	if (RT_SUCCESS(rc) && (u8Type == TYPE_ROM))
726	{
727	misValid = true;
728	dvdCreateDeviceStrings(szVendor, szModel, mszDesc, sizeof(mszDesc),
729	mszUdi, sizeof(mszUdi));
730	}
731	}
732
733	/** Check whether the sysfs block entry is valid for a floppy device and
734	* initialise the string data members for the object. Since we only
735	* support floppies using the basic "floppy" driver, we check the driver
736	* using the entry name and a driver-specific ioctl. */
737	void validateAndInitForFloppy()
738	{
739	bool haveName = false;
740	floppy_drive_name szName;
741	char szDriver[8];
742	if ( mpcszName[0] != 'f'
743	\|\| mpcszName[1] != 'd'
744	\|\| mpcszName[2] < '0'
745	\|\| mpcszName[2] > '7'
746	\|\| mpcszName[3] != '\0')
747	return;
748	if (!noProbe())
749	haveName = floppyGetName(mszNode, mpcszName[2] - '0', szName);
750	if (RTLinuxSysFsGetLinkDest(szDriver, sizeof(szDriver), "block/%s/%s",
751	mpcszName, "device/driver") >= 0)
752	{
753	if (RTStrCmp(szDriver, "floppy"))
754	return;
755	}
756	else if (!haveName)
757	return;
758	floppyCreateDeviceStrings(haveName ? szName : NULL,
759	mpcszName[2] - '0', mszDesc,
760	sizeof(mszDesc), mszUdi, sizeof(mszUdi));
761	misValid = true;
762	}
763
764	public:
765	bool isConsistent()
766	{
767	return misConsistent;
768	}
769	bool isValid()
770	{
771	return misValid;
772	}
773	const char *getDesc()
774	{
775	return mszDesc;
776	}
777	const char *getUdi()
778	{
779	return mszUdi;
780	}
781	const char *getNode()
782	{
783	return mszNode;
784	}
785	};
786
787	/**
788	* Helper function to query the sysfs subsystem for information about DVD
789	* drives attached to the system.
790	* @returns iprt status code
791	* @param pList where to add information about the drives detected
792	* @param isDVD are we looking for DVDs or floppies?
793	* @param pfSuccess Did we find anything?
794	*
795	* @returns IPRT status code
796	*/
797	/* static */
798	int getDriveInfoFromSysfs(DriveInfoList pList, bool isDVD, bool pfSuccess)
799	{
800	AssertPtrReturn(pList, VERR_INVALID_POINTER);
801	AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER); /* Valid or Null */
802	LogFlowFunc (("pList=%p, isDVD=%u, pfSuccess=%p\n",
803	pList, (unsigned) isDVD, pfSuccess));
804	PRTDIR pDir = NULL;
805	int rc;
806	bool fSuccess = false;
807	unsigned cFound = 0;
808
809	if (!RTPathExists("/sys"))
810	return VINF_SUCCESS;
811	rc = RTDirOpen(&pDir, "/sys/block");
812	/* This might mean that sysfs semantics have changed */
813	AssertReturn(rc != VERR_FILE_NOT_FOUND, VINF_SUCCESS);
814	fSuccess = true;
815	if (RT_SUCCESS(rc))
816	for (;;)
817	{
818	RTDIRENTRY entry;
819	rc = RTDirRead(pDir, &entry, NULL);
820	Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
821	if (RT_FAILURE(rc)) /* Including overflow and no more files */
822	break;
823	if (entry.szName[0] == '.')
824	continue;
825	sysfsBlockDev dev(entry.szName, isDVD);
826	/* This might mean that sysfs semantics have changed */
827	AssertBreakStmt(dev.isConsistent(), fSuccess = false);
828	if (!dev.isValid())
829	continue;
830	try
831	{
832	pList->push_back(DriveInfo(dev.getNode(), dev.getUdi(),
833	dev.getDesc()));
834	}
835	catch(std::bad_alloc &e)
836	{
837	rc = VERR_NO_MEMORY;
838	break;
839	}
840	++cFound;
841	}
842	RTDirClose(pDir);
843	if (rc == VERR_NO_MORE_FILES)
844	rc = VINF_SUCCESS;
845	if (RT_FAILURE(rc))
846	/* Clean up again */
847	for (unsigned i = 0; i < cFound; ++i)
848	pList->pop_back();
849	if (pfSuccess)
850	*pfSuccess = fSuccess;
851	LogFlow (("rc=%Rrc, fSuccess=%u\n", rc, (unsigned) fSuccess));
852	return rc;
853	}
854
855
856	/** Structure for holding information about a drive we have found */
857	struct deviceNodeInfo
858	{
859	/** The device number */
860	dev_t Device;
861	/** The device node path */
862	char szPath[RTPATH_MAX];
863	/** The device description */
864	char szDesc[256];
865	/** The device UDI */
866	char szUdi[256];
867	};
868
869	/** The maximum number of devices we will search for. */
870	enum { MAX_DEVICE_NODES = 8 };
871	/** An array of MAX_DEVICE_NODES devices */
872	typedef struct deviceNodeInfo deviceNodeArray[MAX_DEVICE_NODES];
873
874	/**
875	* Recursive worker function to walk the /dev tree looking for DVD or floppy
876	* devices.
877	* @returns true if we have already found MAX_DEVICE_NODES devices, false
878	* otherwise
879	* @param pszPath the path to start recursing. The function can modify
880	* this string at and after the terminating zero
881	* @param cchPath the size of the buffer (not the string!) in @a pszPath
882	* @param aDevices where to fill in information about devices that we have
883	* found
884	* @param wantDVD are we looking for DVD devices (or floppies)?
885	*/
886	static bool devFindDeviceRecursive(char *pszPath, size_t cchPath,
887	deviceNodeArray aDevices, bool wantDVD)
888	{
889	/*
890	* Check assumptions made by the code below.
891	*/
892	size_t const cchBasePath = strlen(pszPath);
893	AssertReturn(cchBasePath < RTPATH_MAX - 10U, false);
894	AssertReturn(pszPath[cchBasePath - 1] != '/', false);
895
896	PRTDIR pDir;
897	if (RT_FAILURE(RTDirOpen(&pDir, pszPath)))
898	return false;
899	for (;;)
900	{
901	RTDIRENTRY Entry;
902	RTFSOBJINFO ObjInfo;
903	int rc = RTDirRead(pDir, &Entry, NULL);
904	if (RT_FAILURE(rc))
905	break;
906	if (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
907	{
908	if (RT_FAILURE(RTPathQueryInfo(pszPath, &ObjInfo,
909	RTFSOBJATTRADD_UNIX)))
910	continue;
911	if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode))
912	continue;
913	}
914
915	if (Entry.enmType == RTDIRENTRYTYPE_SYMLINK)
916	continue;
917	pszPath[cchBasePath] = '\0';
918	if (RT_FAILURE(RTPathAppend(pszPath, cchPath, Entry.szName)))
919	break;
920
921	/* Do the matching. */
922	dev_t DevNode;
923	char szDesc[256], szUdi[256];
924	if (!devValidateDevice(pszPath, wantDVD, &DevNode, szDesc,
925	sizeof(szDesc), szUdi, sizeof(szUdi)))
926	continue;
927	unsigned i;
928	for (i = 0; i < MAX_DEVICE_NODES; ++i)
929	if (!aDevices[i].Device \|\| (aDevices[i].Device == DevNode))
930	break;
931	AssertBreak(i < MAX_DEVICE_NODES);
932	if (aDevices[i].Device)
933	continue;
934	aDevices[i].Device = DevNode;
935	RTStrPrintf(aDevices[i].szPath, sizeof(aDevices[i].szPath),
936	"%s", pszPath);
937	AssertCompile(sizeof(aDevices[i].szDesc) == sizeof(szDesc));
938	strcpy(aDevices[i].szDesc, szDesc);
939	AssertCompile(sizeof(aDevices[i].szUdi) == sizeof(szUdi));
940	strcpy(aDevices[i].szUdi, szUdi);
941	if (i == MAX_DEVICE_NODES - 1)
942	break;
943	continue;
944
945	/* Recurse into subdirectories. */
946	if ( (Entry.enmType == RTDIRENTRYTYPE_UNKNOWN)
947	&& !RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode))
948	continue;
949	if (Entry.enmType != RTDIRENTRYTYPE_DIRECTORY)
950	continue;
951	if (Entry.szName[0] == '.')
952	continue;
953
954	if (devFindDeviceRecursive(pszPath, cchPath, aDevices, wantDVD))
955	break;
956	}
957	RTDirClose(pDir);
958	return aDevices[MAX_DEVICE_NODES - 1].Device ? true : false;
959	}
960
961
962	/**
963	* Recursively walk through the /dev tree and add any DVD or floppy drives we
964	* find and can access to our list. (If we can't access them we can't check
965	* whether or not they are really DVD or floppy drives).
966	* @note this is rather slow (a couple of seconds) for DVD probing on
967	* systems with a static /dev tree, as the current code tries to open
968	* any device node with a major/minor combination that could belong to
969	* a CD-ROM device, and opening a non-existent device can take a non.
970	* negligeable time on Linux. If it is ever necessary to improve this
971	* (static /dev trees are no longer very fashionable these days, and
972	* sysfs looks like it will be with us for a while), we could further
973	* reduce the number of device nodes we open by checking whether the
974	* driver is actually loaded in /proc/devices, and by counting the
975	* of currently attached SCSI CD-ROM devices in /proc/scsi/scsi (yes,
976	* there is a race, but it is probably not important for us).
977	* @returns iprt status code
978	* @param pList the list to append the drives found to
979	* @param isDVD are we looking for DVD drives or for floppies?
980	* @param pfSuccess this will be set to true if we found at least one drive
981	* and to false otherwise. Optional.
982	*/
983	/* static */
984	int getDriveInfoFromDev(DriveInfoList pList, bool isDVD, bool pfSuccess)
985	{
986	AssertPtrReturn(pList, VERR_INVALID_POINTER);
987	AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER);
988	LogFlowFunc(("pList=%p, isDVD=%d, pfSuccess=%p\n", pList, isDVD,
989	pfSuccess));
990	int rc = VINF_SUCCESS;
991	bool success = false;
992
993	char szPath[RTPATH_MAX] = "/dev";
994	deviceNodeArray aDevices;
995	RT_ZERO(aDevices);
996	devFindDeviceRecursive(szPath, sizeof(szPath), aDevices, isDVD);
997	try
998	{
999	for (unsigned i = 0; i < MAX_DEVICE_NODES; ++i)
1000	{
1001	if (aDevices[i].Device)
1002	{
1003	pList->push_back(DriveInfo(aDevices[i].szPath,
1004	aDevices[i].szUdi, aDevices[i].szDesc));
1005	success = true;
1006	}
1007	}
1008	if (pfSuccess != NULL)
1009	*pfSuccess = success;
1010	}
1011	catch(std::bad_alloc &e)
1012	{
1013	rc = VERR_NO_MEMORY;
1014	}
1015	LogFlowFunc (("rc=%Rrc, success=%d\n", rc, success));
1016	return rc;
1017	}
1018
1019
1020	int VBoxMainUSBDeviceInfo::UpdateDevices ()
1021	{
1022	LogFlowThisFunc(("entered\n"));
1023	int rc = VINF_SUCCESS;
1024	bool success = false; /* Have we succeeded in finding anything yet? */
1025	try
1026	{
1027	bool halSuccess = false;
1028	mDeviceList.clear();
1029	#if defined(RT_OS_LINUX)
1030	#ifdef VBOX_WITH_DBUS
1031	if ( RT_SUCCESS(rc)
1032	&& RT_SUCCESS(RTDBusLoadLib())
1033	&& (!success \|\| testing()))
1034	rc = getUSBDeviceInfoFromHal(&mDeviceList, &halSuccess);
1035	/* Try the old API if the new one succeeded as only one of them will
1036	* pick up devices anyway. */
1037	if (RT_SUCCESS(rc) && halSuccess && (!success \|\| testing()))
1038	rc = getOldUSBDeviceInfoFromHal(&mDeviceList, &halSuccess);
1039	if (!success)
1040	success = halSuccess;
1041	#endif /* VBOX_WITH_DBUS defined */
1042	if ( RT_SUCCESS(rc)
1043	&& (!success \|\| testing()))
1044	rc = getUSBDeviceInfoFromSysfs(&mDeviceList, &halSuccess);
1045	#endif /* RT_OS_LINUX */
1046	}
1047	catch(std::bad_alloc &e)
1048	{
1049	rc = VERR_NO_MEMORY;
1050	}
1051	LogFlowThisFunc(("rc=%Rrc\n", rc));
1052	return rc;
1053	}
1054
1055	struct VBoxMainHotplugWaiter::Context
1056	{
1057	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1058	/** The connection to DBus */
1059	RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> mConnection;
1060	/** Semaphore which is set when a device is hotplugged and reset when
1061	* it is read. */
1062	volatile bool mTriggered;
1063	/** A flag to say that we wish to interrupt the current wait. */
1064	volatile bool mInterrupt;
1065	/** Constructor */
1066	Context() : mTriggered(false), mInterrupt(false) {}
1067	#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
1068	};
1069
1070	/* This constructor sets up a private connection to the DBus daemon, connects
1071	* to the hal service and installs a filter which sets the mTriggered flag in
1072	* the Context structure when a device (not necessarily USB) is added or
1073	* removed. */
1074	VBoxMainHotplugWaiter::VBoxMainHotplugWaiter ()
1075	{
1076	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1077	int rc = VINF_SUCCESS;
1078
1079	mContext = new Context;
1080	if (RT_SUCCESS(RTDBusLoadLib()))
1081	{
1082	for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mContext->mConnection; ++i)
1083	{
1084	rc = halInitPrivate (&mContext->mConnection);
1085	}
1086	if (!mContext->mConnection)
1087	rc = VERR_NOT_SUPPORTED;
1088	DBusMessage *pMessage;
1089	while ( RT_SUCCESS(rc)
1090	&& (pMessage = dbus_connection_pop_message (mContext->mConnection.get())) != NULL)
1091	dbus_message_unref (pMessage); /* empty the message queue. */
1092	if ( RT_SUCCESS(rc)
1093	&& !dbus_connection_add_filter (mContext->mConnection.get(),
1094	dbusFilterFunction,
1095	(void *) &mContext->mTriggered, NULL))
1096	rc = VERR_NO_MEMORY;
1097	if (RT_FAILURE(rc))
1098	mContext->mConnection.reset();
1099	}
1100	#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
1101	}
1102
1103	/* Destructor */
1104	VBoxMainHotplugWaiter::~VBoxMainHotplugWaiter ()
1105	{
1106	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1107	if (!!mContext->mConnection)
1108	dbus_connection_remove_filter (mContext->mConnection.get(), dbusFilterFunction,
1109	(void *) &mContext->mTriggered);
1110	delete mContext;
1111	#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
1112	}
1113
1114	/* Currently this is implemented using a timed out wait on our private DBus
1115	* connection. Because the connection is private we don't have to worry about
1116	* blocking other users. */
1117	int VBoxMainHotplugWaiter::Wait(RTMSINTERVAL cMillies)
1118	{
1119	int rc = VINF_SUCCESS;
1120	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1121	if (!mContext->mConnection)
1122	rc = VERR_NOT_SUPPORTED;
1123	bool connected = true;
1124	mContext->mTriggered = false;
1125	mContext->mInterrupt = false;
1126	unsigned cRealMillies;
1127	if (cMillies != RT_INDEFINITE_WAIT)
1128	cRealMillies = cMillies;
1129	else
1130	cRealMillies = DBUS_POLL_TIMEOUT;
1131	while ( RT_SUCCESS(rc) && connected && !mContext->mTriggered
1132	&& !mContext->mInterrupt)
1133	{
1134	connected = dbus_connection_read_write_dispatch (mContext->mConnection.get(),
1135	cRealMillies);
1136	if (mContext->mInterrupt)
1137	LogFlowFunc(("wait loop interrupted\n"));
1138	if (cMillies != RT_INDEFINITE_WAIT)
1139	mContext->mInterrupt = true;
1140	}
1141	if (!connected)
1142	rc = VERR_TRY_AGAIN;
1143	#else /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
1144	rc = VERR_NOT_IMPLEMENTED;
1145	#endif /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
1146	return rc;
1147	}
1148
1149	/* Set a flag to tell the Wait not to resume next time it times out. */
1150	void VBoxMainHotplugWaiter::Interrupt()
1151	{
1152	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1153	LogFlowFunc(("\n"));
1154	mContext->mInterrupt = true;
1155	#endif /* defined RT_OS_LINUX && defined VBOX_WITH_DBUS */
1156	}
1157
1158
1159	class sysfsPathHandler
1160	{
1161	/** Called on each element of the sysfs directory. Can e.g. store
1162	* interesting entries in a list. */
1163	virtual bool handle(const char *pcszNode) = 0;
1164	public:
1165	bool doHandle(const char *pcszNode)
1166	{
1167	AssertPtr(pcszNode);
1168	Assert(pcszNode[0] == '/');
1169	Assert(RTPathExists(pcszNode));
1170	return handle(pcszNode);
1171	}
1172	};
1173
1174	/**
1175	* Helper function to walk a sysfs directory for extracting information about
1176	* devices.
1177	* @returns iprt status code
1178	* @param pcszPath Sysfs directory to walk. Must exist.
1179	* @param pHandler Handler object which will be invoked on each directory
1180	* entry
1181	*
1182	* @returns IPRT status code
1183	*/
1184	/* static */
1185	int getDeviceInfoFromSysfs(const char pcszPath, sysfsPathHandler pHandler)
1186	{
1187	AssertPtrReturn(pcszPath, VERR_INVALID_POINTER);
1188	AssertPtrReturn(pHandler, VERR_INVALID_POINTER);
1189	LogFlowFunc (("pcszPath=%s, pHandler=%p\n", pcszPath, pHandler));
1190	PRTDIR pDir = NULL;
1191	int rc;
1192
1193	rc = RTDirOpen(&pDir, pcszPath);
1194	AssertRCReturn(rc, rc);
1195	while (RT_SUCCESS(rc))
1196	{
1197	RTDIRENTRY entry;
1198	char szPath[RTPATH_MAX], szAbsPath[RTPATH_MAX];
1199
1200	rc = RTDirRead(pDir, &entry, NULL);
1201	Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
1202	/* We break on "no more files" as well as on "real" errors */
1203	if (RT_FAILURE(rc))
1204	break;
1205	if (entry.szName[0] == '.')
1206	continue;
1207	if (RTStrPrintf(szPath, sizeof(szPath), "%s/%s", pcszPath,
1208	entry.szName) >= sizeof(szPath))
1209	rc = VERR_BUFFER_OVERFLOW;
1210	if (RT_FAILURE(rc))
1211	break;
1212	rc = RTPathReal(szPath, szAbsPath, sizeof(szAbsPath));
1213	AssertRCBreak(rc); /* sysfs should guarantee that this exists */
1214	if (!pHandler->doHandle(szAbsPath))
1215	break;
1216	}
1217	RTDirClose(pDir);
1218	if (rc == VERR_NO_MORE_FILES)
1219	rc = VINF_SUCCESS;
1220	LogFlow (("rc=%Rrc\n", rc));
1221	return rc;
1222	}
1223
1224
1225	/**
1226	* Tell whether a file in /sys/bus/usb/devices is a device rather than an
1227	* interface. To be used with getDeviceInfoFromSysfs().
1228	*/
1229	class matchUSBDevice : public sysfsPathHandler
1230	{
1231	USBDeviceInfoList *mList;
1232	public:
1233	matchUSBDevice(USBDeviceInfoList *pList) : mList(pList) {}
1234	private:
1235	virtual bool handle(const char *pcszNode)
1236	{
1237	const char *pcszFile = strrchr(pcszNode, '/');
1238	if (strchr(pcszFile, ':'))
1239	return true;
1240	dev_t devnum = RTLinuxSysFsReadDevNumFile("%s/dev", pcszNode);
1241	AssertReturn (devnum, true);
1242	char szDevPath[RTPATH_MAX];
1243	ssize_t cchDevPath;
1244	cchDevPath = RTLinuxFindDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
1245	szDevPath, sizeof(szDevPath),
1246	"/dev/bus/usb/%.3d/%.3d",
1247	RTLinuxSysFsReadIntFile(10, "%s/busnum", pcszNode),
1248	RTLinuxSysFsReadIntFile(10, "%s/devnum", pcszNode));
1249	if (cchDevPath < 0)
1250	return true;
1251	try
1252	{
1253	mList->push_back(USBDeviceInfo(szDevPath, pcszNode));
1254	}
1255	catch(std::bad_alloc &e)
1256	{
1257	return false;
1258	}
1259	return true;
1260	}
1261	};
1262
1263	/**
1264	* Tell whether a file in /sys/bus/usb/devices is an interface rather than a
1265	* device. To be used with getDeviceInfoFromSysfs().
1266	*/
1267	class matchUSBInterface : public sysfsPathHandler
1268	{
1269	USBDeviceInfo *mInfo;
1270	public:
1271	/** This constructor is currently used to unit test the class logic in
1272	* debug builds. Since no access is made to anything outside the class,
1273	* this shouldn't cause any slowdown worth mentioning. */
1274	matchUSBInterface(USBDeviceInfo *pInfo) : mInfo(pInfo)
1275	{
1276	Assert(isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0",
1277	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1278	Assert(!isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-1",
1279	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1280	Assert(!isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0/driver",
1281	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1282	}
1283	private:
1284	/** The logic for testing whether a sysfs address corresponds to an
1285	* interface of a device. Both must be referenced by their canonical
1286	* sysfs paths. This is not tested, as the test requires file-system
1287	* interaction. */
1288	bool isAnInterfaceOf(const char pcszIface, const char pcszDev)
1289	{
1290	size_t cchDev = strlen(pcszDev);
1291
1292	AssertPtr(pcszIface);
1293	AssertPtr(pcszDev);
1294	Assert(pcszIface[0] == '/');
1295	Assert(pcszDev[0] == '/');
1296	Assert(pcszDev[cchDev - 1] != '/');
1297	/* If this passes, pcszIface is at least cchDev long */
1298	if (strncmp(pcszIface, pcszDev, cchDev))
1299	return false;
1300	/* If this passes, pcszIface is longer than cchDev */
1301	if (pcszIface[cchDev] != '/')
1302	return false;
1303	/* In sysfs an interface is an immediate subdirectory of the device */
1304	if (strchr(pcszIface + cchDev + 1, '/'))
1305	return false;
1306	/* And it always has a colon in its name */
1307	if (!strchr(pcszIface + cchDev + 1, ':'))
1308	return false;
1309	/* And hopefully we have now elimitated everything else */
1310	return true;
1311	}
1312
1313	virtual bool handle(const char *pcszNode)
1314	{
1315	if (!isAnInterfaceOf(pcszNode, mInfo->mSysfsPath.c_str()))
1316	return true;
1317	try
1318	{
1319	mInfo->mInterfaces.push_back(pcszNode);
1320	}
1321	catch(std::bad_alloc &e)
1322	{
1323	return false;
1324	}
1325	return true;
1326	}
1327	};
1328
1329	/**
1330	* Helper function to query the sysfs subsystem for information about USB
1331	* devices attached to the system.
1332	* @returns iprt status code
1333	* @param pList where to add information about the drives detected
1334	* @param pfSuccess Did we find anything?
1335	*
1336	* @returns IPRT status code
1337	*/
1338	static int getUSBDeviceInfoFromSysfs(USBDeviceInfoList *pList,
1339	bool *pfSuccess)
1340	{
1341	AssertPtrReturn(pList, VERR_INVALID_POINTER);
1342	AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER); /* Valid or Null */
1343	LogFlowFunc (("pList=%p, pfSuccess=%p\n",
1344	pList, pfSuccess));
1345	size_t cDevices = pList->size();
1346	matchUSBDevice devHandler(pList);
1347	int rc = getDeviceInfoFromSysfs("/sys/bus/usb/devices", &devHandler);
1348	do {
1349	if (RT_FAILURE(rc))
1350	break;
1351	for (USBDeviceInfoList::iterator pInfo = pList->begin();
1352	pInfo != pList->end(); ++pInfo)
1353	{
1354	matchUSBInterface ifaceHandler(&*pInfo);
1355	rc = getDeviceInfoFromSysfs("/sys/bus/usb/devices", &ifaceHandler);
1356	if (RT_FAILURE(rc))
1357	break;
1358	}
1359	} while(0);
1360	if (RT_FAILURE(rc))
1361	/* Clean up again */
1362	while (pList->size() > cDevices)
1363	pList->pop_back();
1364	if (pfSuccess)
1365	*pfSuccess = RT_SUCCESS(rc);
1366	LogFlow (("rc=%Rrc\n", rc));
1367	return rc;
1368	}
1369
1370
1371	#if defined(RT_OS_LINUX) && defined(VBOX_WITH_DBUS)
1372	/** Wrapper class around DBusError for automatic cleanup */
1373	class autoDBusError
1374	{
1375	DBusError mError;
1376	public:
1377	autoDBusError () { dbus_error_init (&mError); }
1378	~autoDBusError ()
1379	{
1380	if (IsSet())
1381	dbus_error_free (&mError);
1382	}
1383	DBusError &get () { return mError; }
1384	bool IsSet ()
1385	{
1386	Assert((mError.name == NULL) == (mError.message == NULL));
1387	return (mError.name != NULL);
1388	}
1389	bool HasName (const char *pcszName)
1390	{
1391	Assert((mError.name == NULL) == (mError.message == NULL));
1392	return (RTStrCmp (mError.name, pcszName) == 0);
1393	}
1394	void FlowLog ()
1395	{
1396	if (IsSet ())
1397	LogFlow(("DBus error %s: %s\n", mError.name, mError.message));
1398	}
1399	};
1400
1401	/**
1402	* Helper function for setting up a connection to the DBus daemon and
1403	* registering with the hal service.
1404	*
1405	* @note If libdbus is being loaded at runtime then be sure to call
1406	* VBoxDBusCheckPresence before calling this.
1407	* @returns iprt status code
1408	* @param ppConnection where to store the connection handle
1409	*/
1410	/* static */
1411	int halInit (RTMemAutoPtr <DBusConnection, VBoxHalShutdown> *pConnection)
1412	{
1413	AssertReturn(VALID_PTR (pConnection), VERR_INVALID_POINTER);
1414	LogFlowFunc (("pConnection=%p\n", pConnection));
1415	int rc = VINF_SUCCESS;
1416	bool halSuccess = true;
1417	autoDBusError dbusError;
1418
1419	RTMemAutoPtr <DBusConnection, VBoxDBusConnectionUnref> dbusConnection;
1420	dbusConnection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbusError.get());
1421	if (!dbusConnection)
1422	halSuccess = false;
1423	if (halSuccess)
1424	{
1425	dbus_connection_set_exit_on_disconnect (dbusConnection.get(), false);
1426	halSuccess = dbus_bus_name_has_owner (dbusConnection.get(),
1427	"org.freedesktop.Hal", &dbusError.get());
1428	}
1429	if (halSuccess)
1430	{
1431	dbus_bus_add_match (dbusConnection.get(),
1432	"type='signal',"
1433	"interface='org.freedesktop.Hal.Manager',"
1434	"sender='org.freedesktop.Hal',"
1435	"path='/org/freedesktop/Hal/Manager'",
1436	&dbusError.get());
1437	halSuccess = !dbusError.IsSet();
1438	}
1439	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1440	rc = VERR_NO_MEMORY;
1441	if (halSuccess)
1442	*pConnection = dbusConnection.release();
1443	LogFlowFunc(("rc=%Rrc, (pConnection).get()=%p\n", rc, (pConnection).get()));
1444	dbusError.FlowLog();
1445	return rc;
1446	}
1447
1448	/**
1449	* Helper function for setting up a private connection to the DBus daemon and
1450	* registering with the hal service. Private connections are considered
1451	* unsociable and should not be used unnecessarily (as per the DBus API docs).
1452	*
1453	* @note If libdbus is being loaded at runtime then be sure to call
1454	* VBoxDBusCheckPresence before calling this.
1455	* @returns iprt status code
1456	* @param pConnection where to store the connection handle
1457	*/
1458	/* static */
1459	int halInitPrivate (RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> *pConnection)
1460	{
1461	AssertReturn(VALID_PTR (pConnection), VERR_INVALID_POINTER);
1462	LogFlowFunc (("pConnection=%p\n", pConnection));
1463	int rc = VINF_SUCCESS;
1464	bool halSuccess = true;
1465	autoDBusError dbusError;
1466
1467	RTMemAutoPtr <DBusConnection, VBoxDBusConnectionCloseAndUnref> dbusConnection;
1468	dbusConnection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbusError.get());
1469	if (!dbusConnection)
1470	halSuccess = false;
1471	if (halSuccess)
1472	{
1473	dbus_connection_set_exit_on_disconnect (dbusConnection.get(), false);
1474	halSuccess = dbus_bus_name_has_owner (dbusConnection.get(),
1475	"org.freedesktop.Hal", &dbusError.get());
1476	}
1477	if (halSuccess)
1478	{
1479	dbus_bus_add_match (dbusConnection.get(),
1480	"type='signal',"
1481	"interface='org.freedesktop.Hal.Manager',"
1482	"sender='org.freedesktop.Hal',"
1483	"path='/org/freedesktop/Hal/Manager'",
1484	&dbusError.get());
1485	halSuccess = !dbusError.IsSet();
1486	}
1487	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1488	rc = VERR_NO_MEMORY;
1489	if (halSuccess)
1490	*pConnection = dbusConnection.release();
1491	LogFlowFunc(("rc=%Rrc, (pConnection).get()=%p\n", rc, (pConnection).get()));
1492	dbusError.FlowLog();
1493	return rc;
1494	}
1495
1496	/**
1497	* Helper function for shutting down a connection to DBus and hal.
1498	* @param pConnection the connection handle
1499	*/
1500	/* extern */
1501	void VBoxHalShutdown (DBusConnection *pConnection)
1502	{
1503	AssertReturnVoid(VALID_PTR (pConnection));
1504	LogFlowFunc (("pConnection=%p\n", pConnection));
1505	autoDBusError dbusError;
1506
1507	dbus_bus_remove_match (pConnection,
1508	"type='signal',"
1509	"interface='org.freedesktop.Hal.Manager',"
1510	"sender='org.freedesktop.Hal',"
1511	"path='/org/freedesktop/Hal/Manager'",
1512	&dbusError.get());
1513	dbus_connection_unref (pConnection);
1514	LogFlowFunc(("returning\n"));
1515	dbusError.FlowLog();
1516	}
1517
1518	/**
1519	* Helper function for shutting down a private connection to DBus and hal.
1520	* @param pConnection the connection handle
1521	*/
1522	/* extern */
1523	void VBoxHalShutdownPrivate (DBusConnection *pConnection)
1524	{
1525	AssertReturnVoid(VALID_PTR (pConnection));
1526	LogFlowFunc (("pConnection=%p\n", pConnection));
1527	autoDBusError dbusError;
1528
1529	dbus_bus_remove_match (pConnection,
1530	"type='signal',"
1531	"interface='org.freedesktop.Hal.Manager',"
1532	"sender='org.freedesktop.Hal',"
1533	"path='/org/freedesktop/Hal/Manager'",
1534	&dbusError.get());
1535	dbus_connection_close (pConnection);
1536	dbus_connection_unref (pConnection);
1537	LogFlowFunc(("returning\n"));
1538	dbusError.FlowLog();
1539	}
1540
1541	/** Wrapper around dbus_connection_unref. We need this to use it as a real
1542	* function in auto pointers, as a function pointer won't wash here. */
1543	/* extern */
1544	void VBoxDBusConnectionUnref(DBusConnection *pConnection)
1545	{
1546	dbus_connection_unref(pConnection);
1547	}
1548
1549	/**
1550	* This function closes and unrefs a private connection to dbus. It should
1551	* only be called once no-one else is referencing the connection.
1552	*/
1553	/* extern */
1554	void VBoxDBusConnectionCloseAndUnref(DBusConnection *pConnection)
1555	{
1556	dbus_connection_close(pConnection);
1557	dbus_connection_unref(pConnection);
1558	}
1559
1560	/** Wrapper around dbus_message_unref. We need this to use it as a real
1561	* function in auto pointers, as a function pointer won't wash here. */
1562	/* extern */
1563	void VBoxDBusMessageUnref(DBusMessage *pMessage)
1564	{
1565	dbus_message_unref(pMessage);
1566	}
1567
1568	/**
1569	* Find the UDIs of hal entries that contain Key=Value property.
1570	* @returns iprt status code. If a non-fatal error occurs, we return success
1571	* but reset pMessage to NULL.
1572	* @param pConnection an initialised connection DBus
1573	* @param pszKey the property key
1574	* @param pszValue the property value
1575	* @param pMessage where to store the return DBus message. This must be
1576	* parsed to get at the UDIs. NOT optional.
1577	*/
1578	/* static */
1579	int halFindDeviceStringMatch (DBusConnection pConnection, const char pszKey,
1580	const char *pszValue,
1581	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage)
1582	{
1583	AssertReturn( VALID_PTR (pConnection) && VALID_PTR (pszKey)
1584	&& VALID_PTR (pszValue) && VALID_PTR (pMessage),
1585	VERR_INVALID_POINTER);
1586	LogFlowFunc (("pConnection=%p, pszKey=%s, pszValue=%s, pMessage=%p\n",
1587	pConnection, pszKey, pszValue, pMessage));
1588	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1589	bool halSuccess = true; /* We set this to false to abort the operation. */
1590	autoDBusError dbusError;
1591
1592	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, reply;
1593	if (halSuccess && RT_SUCCESS(rc))
1594	{
1595	message = dbus_message_new_method_call ("org.freedesktop.Hal",
1596	"/org/freedesktop/Hal/Manager",
1597	"org.freedesktop.Hal.Manager",
1598	"FindDeviceStringMatch");
1599	if (!message)
1600	rc = VERR_NO_MEMORY;
1601	}
1602	if (halSuccess && RT_SUCCESS(rc))
1603	{
1604	DBusMessageIter iterAppend;
1605	dbus_message_iter_init_append (message.get(), &iterAppend);
1606	dbus_message_iter_append_basic (&iterAppend, DBUS_TYPE_STRING, &pszKey);
1607	dbus_message_iter_append_basic (&iterAppend, DBUS_TYPE_STRING, &pszValue);
1608	reply = dbus_connection_send_with_reply_and_block (pConnection,
1609	message.get(), -1,
1610	&dbusError.get());
1611	if (!reply)
1612	halSuccess = false;
1613	}
1614	*pMessage = reply.release ();
1615	LogFlowFunc (("rc=%Rrc, pMessage.value()=%p\n", rc, (pMessage).get()));
1616	dbusError.FlowLog();
1617	return rc;
1618	}
1619
1620	/**
1621	* Find the UDIs of hal entries that contain Key=Value property and return the
1622	* result on the end of a vector of iprt::MiniString.
1623	* @returns iprt status code. If a non-fatal error occurs, we return success
1624	* but set *pfSuccess to false.
1625	* @param pConnection an initialised connection DBus
1626	* @param pszKey the property key
1627	* @param pszValue the property value
1628	* @param pMatches pointer to an array of iprt::MiniString to append the
1629	* results to. NOT optional.
1630	* @param pfSuccess will be set to true if the operation succeeds
1631	*/
1632	/* static */
1633	int halFindDeviceStringMatchVector (DBusConnection *pConnection,
1634	const char pszKey, const char pszValue,
1635	std::vector<iprt::MiniString> *pMatches,
1636	bool *pfSuccess)
1637	{
1638	AssertPtrReturn (pConnection, VERR_INVALID_POINTER);
1639	AssertPtrReturn (pszKey, VERR_INVALID_POINTER);
1640	AssertPtrReturn (pszValue, VERR_INVALID_POINTER);
1641	AssertPtrReturn (pMatches, VERR_INVALID_POINTER);
1642	AssertReturn(pfSuccess == NULL \|\| VALID_PTR (pfSuccess), VERR_INVALID_POINTER);
1643	LogFlowFunc (("pConnection=%p, pszKey=%s, pszValue=%s, pMatches=%p, pfSuccess=%p\n",
1644	pConnection, pszKey, pszValue, pMatches, pfSuccess));
1645	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1646	bool halSuccess = true; /* We set this to false to abort the operation. */
1647
1648	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, replyFind;
1649	DBusMessageIter iterFind, iterUdis;
1650
1651	if (halSuccess && RT_SUCCESS(rc))
1652	{
1653	rc = halFindDeviceStringMatch (pConnection, pszKey, pszValue,
1654	&replyFind);
1655	if (!replyFind)
1656	halSuccess = false;
1657	}
1658	if (halSuccess && RT_SUCCESS(rc))
1659	{
1660	dbus_message_iter_init (replyFind.get(), &iterFind);
1661	if (dbus_message_iter_get_arg_type (&iterFind) != DBUS_TYPE_ARRAY)
1662	halSuccess = false;
1663	}
1664	if (halSuccess && RT_SUCCESS(rc))
1665	dbus_message_iter_recurse (&iterFind, &iterUdis);
1666	for (; halSuccess && RT_SUCCESS(rc)
1667	&& dbus_message_iter_get_arg_type (&iterUdis) == DBUS_TYPE_STRING;
1668	dbus_message_iter_next(&iterUdis))
1669	{
1670	/* Now get all UDIs from the iterator */
1671	const char *pszUdi;
1672	dbus_message_iter_get_basic (&iterUdis, &pszUdi);
1673	try
1674	{
1675	pMatches->push_back(pszUdi);
1676	}
1677	catch(std::bad_alloc &e)
1678	{
1679	rc = VERR_NO_MEMORY;
1680	}
1681	}
1682	if (pfSuccess != NULL)
1683	*pfSuccess = halSuccess;
1684	LogFlow (("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1685	return rc;
1686	}
1687
1688	/**
1689	* Read a set of string properties for a device. If some of the properties are
1690	* not of type DBUS_TYPE_STRING or do not exist then a NULL pointer will be
1691	* returned for them.
1692	* @returns iprt status code. If the operation failed for non-fatal reasons
1693	* then we return success and leave pMessage untouched - reset it
1694	* before the call to detect this.
1695	* @param pConnection an initialised connection DBus
1696	* @param pszUdi the Udi of the device
1697	* @param cProps the number of property values to look up
1698	* @param papszKeys the keys of the properties to be looked up
1699	* @param papszValues where to store the values of the properties. The
1700	* strings returned will be valid until the message
1701	* returned in @a ppMessage is freed. Undefined if
1702	* the message is NULL.
1703	* @param pMessage where to store the return DBus message. The caller
1704	* is responsible for freeing this once they have
1705	* finished with the value strings. NOT optional.
1706	*/
1707	/* static */
1708	int halGetPropertyStrings (DBusConnection pConnection, const char pszUdi,
1709	size_t cProps, const char **papszKeys,
1710	char **papszValues,
1711	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage)
1712	{
1713	AssertReturn( VALID_PTR (pConnection) && VALID_PTR (pszUdi)
1714	&& VALID_PTR (papszKeys) && VALID_PTR (papszValues)
1715	&& VALID_PTR (pMessage),
1716	VERR_INVALID_POINTER);
1717	LogFlowFunc (("pConnection=%p, pszUdi=%s, cProps=%llu, papszKeys=%p, papszValues=%p, pMessage=%p\n",
1718	pConnection, pszUdi, cProps, papszKeys, papszValues, pMessage));
1719	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1720	bool halSuccess = true; /* We set this to false to abort the operation. */
1721	autoDBusError dbusError;
1722
1723	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, reply;
1724	DBusMessageIter iterGet, iterProps;
1725
1726	/* Initialise the return array to NULLs */
1727	for (size_t i = 0; i < cProps; ++i)
1728	papszValues[i] = NULL;
1729
1730	/* Send a GetAllProperties message to hald */
1731	message = dbus_message_new_method_call ("org.freedesktop.Hal", pszUdi,
1732	"org.freedesktop.Hal.Device",
1733	"GetAllProperties");
1734	if (!message)
1735	rc = VERR_NO_MEMORY;
1736	if (halSuccess && RT_SUCCESS(rc))
1737	{
1738	reply = dbus_connection_send_with_reply_and_block (pConnection,
1739	message.get(), -1,
1740	&dbusError.get());
1741	if (!reply)
1742	halSuccess = false;
1743	}
1744
1745	/* Parse the reply */
1746	if (halSuccess && RT_SUCCESS(rc))
1747	{
1748	dbus_message_iter_init (reply.get(), &iterGet);
1749	if ( dbus_message_iter_get_arg_type (&iterGet) != DBUS_TYPE_ARRAY
1750	&& dbus_message_iter_get_element_type (&iterGet) != DBUS_TYPE_DICT_ENTRY)
1751	halSuccess = false;
1752	}
1753	if (halSuccess && RT_SUCCESS(rc))
1754	dbus_message_iter_recurse (&iterGet, &iterProps);
1755	/* Go through all entries in the reply and see if any match our keys. */
1756	while ( halSuccess && RT_SUCCESS(rc)
1757	&& dbus_message_iter_get_arg_type (&iterProps)
1758	== DBUS_TYPE_DICT_ENTRY)
1759	{
1760	const char *pszKey;
1761	DBusMessageIter iterEntry, iterValue;
1762	dbus_message_iter_recurse (&iterProps, &iterEntry);
1763	dbus_message_iter_get_basic (&iterEntry, &pszKey);
1764	dbus_message_iter_next (&iterEntry);
1765	dbus_message_iter_recurse (&iterEntry, &iterValue);
1766	/* Fill in any matches. */
1767	for (size_t i = 0; i < cProps; ++i)
1768	if (strcmp (pszKey, papszKeys[i]) == 0)
1769	{
1770	if (dbus_message_iter_get_arg_type (&iterValue) == DBUS_TYPE_STRING)
1771	dbus_message_iter_get_basic (&iterValue, &papszValues[i]);
1772	}
1773	dbus_message_iter_next (&iterProps);
1774	}
1775	if (RT_SUCCESS(rc) && halSuccess)
1776	*pMessage = reply.release();
1777	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1778	rc = VERR_NO_MEMORY;
1779	LogFlowFunc (("rc=%Rrc, pMessage.value()=%p\n", rc, (pMessage).get()));
1780	dbusError.FlowLog();
1781	return rc;
1782	}
1783
1784	/**
1785	* Read a set of string properties for a device. If some properties do not
1786	* exist or are not of type DBUS_TYPE_STRING, we will still fetch the others.
1787	* @returns iprt status code. If the operation failed for non-fatal reasons
1788	* then we return success and set *pfSuccess to false.
1789	* @param pConnection an initialised connection DBus
1790	* @param pszUdi the Udi of the device
1791	* @param cProps the number of property values to look up
1792	* @param papszKeys the keys of the properties to be looked up
1793	* @param pMatches pointer to an empty array of iprt::MiniString to append the
1794	* results to. NOT optional.
1795	* @param pfMatches pointer to an array of boolean values indicating
1796	* whether the respective property is a string. If this
1797	* is not supplied then all properties must be strings
1798	* for the operation to be considered successful
1799	* @param pfSuccess will be set to true if the operation succeeds
1800	*/
1801	/* static */
1802	int halGetPropertyStringsVector (DBusConnection *pConnection,
1803	const char *pszUdi, size_t cProps,
1804	const char **papszKeys,
1805	std::vector<iprt::MiniString> *pMatches,
1806	bool pfMatches, bool pfSuccess)
1807	{
1808	AssertPtrReturn (pConnection, VERR_INVALID_POINTER);
1809	AssertPtrReturn (pszUdi, VERR_INVALID_POINTER);
1810	AssertPtrReturn (papszKeys, VERR_INVALID_POINTER);
1811	AssertPtrReturn (pMatches, VERR_INVALID_POINTER);
1812	AssertReturn((pfMatches == NULL) \|\| VALID_PTR (pfMatches), VERR_INVALID_POINTER);
1813	AssertReturn((pfSuccess == NULL) \|\| VALID_PTR (pfSuccess), VERR_INVALID_POINTER);
1814	AssertReturn(pMatches->empty(), VERR_INVALID_PARAMETER);
1815	LogFlowFunc (("pConnection=%p, pszUdi=%s, cProps=%llu, papszKeys=%p, pMatches=%p, pfMatches=%p, pfSuccess=%p\n",
1816	pConnection, pszUdi, cProps, papszKeys, pMatches, pfMatches, pfSuccess));
1817	RTMemAutoPtr <char *> values(cProps);
1818	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message;
1819	bool halSuccess = true;
1820	int rc = halGetPropertyStrings (pConnection, pszUdi, cProps, papszKeys,
1821	values.get(), &message);
1822	if (!message)
1823	halSuccess = false;
1824	for (size_t i = 0; RT_SUCCESS(rc) && halSuccess && i < cProps; ++i)
1825	{
1826	bool fMatches = values[i] != NULL;
1827	if (pfMatches != NULL)
1828	pfMatches[i] = fMatches;
1829	else
1830	halSuccess = fMatches;
1831	try
1832	{
1833	pMatches->push_back(fMatches ? values[i] : "");
1834	}
1835	catch(std::bad_alloc &e)
1836	{
1837	rc = VERR_NO_MEMORY;
1838	}
1839	}
1840	if (pfSuccess != NULL)
1841	*pfSuccess = halSuccess;
1842	if (RT_SUCCESS(rc) && halSuccess)
1843	{
1844	Assert(pMatches->size() == cProps);
1845	AssertForEach(j, size_t, 0, cProps, (pfMatches == NULL)
1846	\|\| (pfMatches[j] == true)
1847	\|\| ((pfMatches[j] == false) && (pMatches[j].size() == 0)));
1848	}
1849	LogFlowFunc (("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1850	return rc;
1851	}
1852
1853
1854	/**
1855	* Helper function to query the hal subsystem for information about USB devices
1856	* attached to the system.
1857	* @returns iprt status code
1858	* @param pList where to add information about the devices detected
1859	* @param pfSuccess will be set to true if all interactions with hal
1860	* succeeded and to false otherwise. Optional.
1861	*
1862	* @returns IPRT status code
1863	*/
1864	/* static */
1865	int getUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess)
1866	{
1867	AssertReturn(VALID_PTR (pList) && (pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
1868	VERR_INVALID_POINTER);
1869	LogFlowFunc (("pList=%p, pfSuccess=%p\n", pList, pfSuccess));
1870	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1871	bool halSuccess = true; /* We set this to false to abort the operation. */
1872	autoDBusError dbusError;
1873
1874	RTMemAutoPtr<DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
1875	RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
1876	DBusMessageIter iterFind, iterUdis;
1877
1878	/* Connect to hal */
1879	rc = halInit (&dbusConnection);
1880	if (!dbusConnection)
1881	halSuccess = false;
1882	/* Get an array of all devices in the usb_device subsystem */
1883	if (halSuccess && RT_SUCCESS(rc))
1884	{
1885	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.subsystem",
1886	"usb_device", &replyFind);
1887	if (!replyFind)
1888	halSuccess = false;
1889	}
1890	if (halSuccess && RT_SUCCESS(rc))
1891	{
1892	dbus_message_iter_init(replyFind.get(), &iterFind);
1893	if (dbus_message_iter_get_arg_type (&iterFind) != DBUS_TYPE_ARRAY)
1894	halSuccess = false;
1895	}
1896	/* Recurse down into the array and query interesting information about the
1897	* entries. */
1898	if (halSuccess && RT_SUCCESS(rc))
1899	dbus_message_iter_recurse(&iterFind, &iterUdis);
1900	for (; halSuccess && RT_SUCCESS(rc)
1901	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
1902	dbus_message_iter_next(&iterUdis))
1903	{
1904	/* Get the device node and the sysfs path for the current entry. */
1905	const char *pszUdi;
1906	dbus_message_iter_get_basic (&iterUdis, &pszUdi);
1907	static const char *papszKeys[] = { "linux.device_file", "linux.sysfs_path" };
1908	char *papszValues[RT_ELEMENTS(papszKeys)];
1909	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
1910	papszKeys, papszValues, &replyGet);
1911	const char pszDevice = papszValues[0], pszSysfsPath = papszValues[1];
1912	/* Get the interfaces. */
1913	if (!!replyGet && pszDevice && pszSysfsPath)
1914	{
1915	USBDeviceInfo info(pszDevice, pszSysfsPath);
1916	bool ifaceSuccess = true; /* If we can't get the interfaces, just
1917	* skip this one device. */
1918	rc = getUSBInterfacesFromHal(&info.mInterfaces, pszUdi, &ifaceSuccess);
1919	if (RT_SUCCESS(rc) && halSuccess && ifaceSuccess)
1920	try
1921	{
1922	pList->push_back(info);
1923	}
1924	catch(std::bad_alloc &e)
1925	{
1926	rc = VERR_NO_MEMORY;
1927	}
1928	}
1929	}
1930	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1931	rc = VERR_NO_MEMORY;
1932	if (pfSuccess != NULL)
1933	*pfSuccess = halSuccess;
1934	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1935	dbusError.FlowLog();
1936	return rc;
1937	}
1938
1939	/**
1940	* Helper function to query the hal subsystem for information about USB devices
1941	* attached to the system, using the older API.
1942	* @returns iprt status code
1943	* @param pList where to add information about the devices detected
1944	* @param pfSuccess will be set to true if all interactions with hal
1945	* succeeded and to false otherwise. Optional.
1946	*
1947	* @returns IPRT status code
1948	*/
1949	/* static */
1950	int getOldUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess)
1951	{
1952	AssertReturn(VALID_PTR (pList) && (pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
1953	VERR_INVALID_POINTER);
1954	LogFlowFunc (("pList=%p, pfSuccess=%p\n", pList, pfSuccess));
1955	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1956	bool halSuccess = true; /* We set this to false to abort the operation. */
1957	autoDBusError dbusError;
1958
1959	RTMemAutoPtr<DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
1960	RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
1961	DBusMessageIter iterFind, iterUdis;
1962
1963	/* Connect to hal */
1964	rc = halInit(&dbusConnection);
1965	if (!dbusConnection)
1966	halSuccess = false;
1967	/* Get an array of all devices in the usb_device subsystem */
1968	if (halSuccess && RT_SUCCESS(rc))
1969	{
1970	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.category",
1971	"usbraw", &replyFind);
1972	if (!replyFind)
1973	halSuccess = false;
1974	}
1975	if (halSuccess && RT_SUCCESS(rc))
1976	{
1977	dbus_message_iter_init(replyFind.get(), &iterFind);
1978	if (dbus_message_iter_get_arg_type(&iterFind) != DBUS_TYPE_ARRAY)
1979	halSuccess = false;
1980	}
1981	/* Recurse down into the array and query interesting information about the
1982	* entries. */
1983	if (halSuccess && RT_SUCCESS(rc))
1984	dbus_message_iter_recurse(&iterFind, &iterUdis);
1985	for (; halSuccess && RT_SUCCESS(rc)
1986	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
1987	dbus_message_iter_next(&iterUdis))
1988	{
1989	/* Get the device node and the sysfs path for the current entry. */
1990	const char *pszUdi;
1991	dbus_message_iter_get_basic(&iterUdis, &pszUdi);
1992	static const char *papszKeys[] = { "linux.device_file", "info.parent" };
1993	char *papszValues[RT_ELEMENTS(papszKeys)];
1994	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
1995	papszKeys, papszValues, &replyGet);
1996	const char pszDevice = papszValues[0], pszSysfsPath = papszValues[1];
1997	/* Get the interfaces. */
1998	if (!!replyGet && pszDevice && pszSysfsPath)
1999	{
2000	USBDeviceInfo info(pszDevice, pszSysfsPath);
2001	bool ifaceSuccess = false; /* If we can't get the interfaces, just
2002	* skip this one device. */
2003	rc = getUSBInterfacesFromHal(&info.mInterfaces, pszSysfsPath,
2004	&ifaceSuccess);
2005	if (RT_SUCCESS(rc) && halSuccess && ifaceSuccess)
2006	try
2007	{
2008	pList->push_back(info);
2009	}
2010	catch(std::bad_alloc &e)
2011	{
2012	rc = VERR_NO_MEMORY;
2013	}
2014	}
2015	}
2016	if (dbusError.HasName(DBUS_ERROR_NO_MEMORY))
2017	rc = VERR_NO_MEMORY;
2018	if (pfSuccess != NULL)
2019	*pfSuccess = halSuccess;
2020	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
2021	dbusError.FlowLog();
2022	return rc;
2023	}
2024
2025
2026	/**
2027	* Helper function to query the hal subsystem for information about USB devices
2028	* attached to the system.
2029	* @returns iprt status code
2030	* @param pList where to add information about the devices detected. If
2031	* certain interfaces are not found (@a pfFound is false on
2032	* return) this may contain invalid information.
2033	* @param pcszUdi the hal UDI of the device
2034	* @param pfSuccess will be set to true if the operation succeeds and to
2035	* false if it fails for non-critical reasons. Optional.
2036	*
2037	* @returns IPRT status code
2038	*/
2039	/* static */
2040	int getUSBInterfacesFromHal(std::vector<iprt::MiniString> *pList,
2041	const char pcszUdi, bool pfSuccess)
2042	{
2043	AssertReturn(VALID_PTR(pList) && VALID_PTR(pcszUdi) &&
2044	(pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
2045	VERR_INVALID_POINTER);
2046	LogFlowFunc(("pList=%p, pcszUdi=%s, pfSuccess=%p\n", pList, pcszUdi,
2047	pfSuccess));
2048	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
2049	bool halSuccess = true; /* We set this to false to abort the operation. */
2050	autoDBusError dbusError;
2051
2052	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
2053	RTMemAutoPtr <DBusConnection, VBoxHalShutdown> dbusConnection;
2054	DBusMessageIter iterFind, iterUdis;
2055
2056	rc = halInit(&dbusConnection);
2057	if (!dbusConnection)
2058	halSuccess = false;
2059	if (halSuccess && RT_SUCCESS(rc))
2060	{
2061	/* Look for children of the current UDI. */
2062	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.parent",
2063	pcszUdi, &replyFind);
2064	if (!replyFind)
2065	halSuccess = false;
2066	}
2067	if (halSuccess && RT_SUCCESS(rc))
2068	{
2069	dbus_message_iter_init(replyFind.get(), &iterFind);
2070	if (dbus_message_iter_get_arg_type(&iterFind) != DBUS_TYPE_ARRAY)
2071	halSuccess = false;
2072	}
2073	if (halSuccess && RT_SUCCESS(rc))
2074	dbus_message_iter_recurse(&iterFind, &iterUdis);
2075	for (; halSuccess && RT_SUCCESS(rc)
2076	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
2077	dbus_message_iter_next(&iterUdis))
2078	{
2079	/* Now get the sysfs path and the subsystem from the iterator */
2080	const char *pszUdi;
2081	dbus_message_iter_get_basic(&iterUdis, &pszUdi);
2082	static const char *papszKeys[] = { "linux.sysfs_path", "info.subsystem",
2083	"linux.subsystem" };
2084	char *papszValues[RT_ELEMENTS(papszKeys)];
2085	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
2086	papszKeys, papszValues, &replyGet);
2087	const char pszSysfsPath = papszValues[0], pszInfoSubsystem = papszValues[1],
2088	*pszLinuxSubsystem = papszValues[2];
2089	if (!replyGet)
2090	halSuccess = false;
2091	if (!!replyGet && pszSysfsPath == NULL)
2092	halSuccess = false;
2093	if ( halSuccess && RT_SUCCESS(rc)
2094	&& RTStrCmp (pszInfoSubsystem, "usb_device") != 0 /* Children of buses can also be devices. */
2095	&& RTStrCmp (pszLinuxSubsystem, "usb_device") != 0)
2096	try
2097	{
2098	pList->push_back(pszSysfsPath);
2099	}
2100	catch(std::bad_alloc &e)
2101	{
2102	rc = VERR_NO_MEMORY;
2103	}
2104	}
2105	if (dbusError.HasName(DBUS_ERROR_NO_MEMORY))
2106	rc = VERR_NO_MEMORY;
2107	if (pfSuccess != NULL)
2108	*pfSuccess = halSuccess;
2109	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
2110	dbusError.FlowLog();
2111	return rc;
2112	}
2113
2114	/**
2115	* When it is registered with DBus, this function will be called by
2116	* dbus_connection_read_write_dispatch each time a message is received over the
2117	* DBus connection. We check whether that message was caused by a hal device
2118	* hotplug event, and if so we set a flag. dbus_connection_read_write_dispatch
2119	* will return after calling its filter functions, and its caller should then
2120	* check the status of the flag passed to the filter function.
2121	*
2122	* @param pConnection The DBus connection we are using.
2123	* @param pMessage The DBus message which just arrived.
2124	* @param pvUser A pointer to the flag variable we are to set.
2125	*/
2126	/* static */
2127	DBusHandlerResult dbusFilterFunction(DBusConnection * /* pConnection */,
2128	DBusMessage pMessage, void pvUser)
2129	{
2130	volatile bool pTriggered = reinterpret_cast<volatile bool >(pvUser);
2131	if ( dbus_message_is_signal(pMessage, "org.freedesktop.Hal.Manager",
2132	"DeviceAdded")
2133	\|\| dbus_message_is_signal(pMessage, "org.freedesktop.Hal.Manager",
2134	"DeviceRemoved"))
2135	{
2136	*pTriggered = true;
2137	}
2138	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2139	}
2140	#endif /* RT_OS_LINUX && VBOX_WITH_DBUS */
2141

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

source: vbox/trunk/src/VBox/Main/linux/HostHardwareLinux.cpp@ 28345

Download in other formats: