HostHardwareLinux.cpp@ 28349

Last change on this file since 28349 was 28349, checked in by vboxsync, 15 years ago
Main/HostHardwareLinux: generalised the VBoxMainHotplugWaiter class to allow for runtime implementation selection
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 80.9 KB

Line
1	/* $Id: HostHardwareLinux.cpp 28349 2010-04-15 09:18:31Z 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.215389.xyz. 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	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1056	class hotplugDBusImpl : public VBoxMainHotplugWaiterImpl
1057	{
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
1066	public:
1067	/** Test whether this implementation can be used on the current system */
1068	static bool HalAvailable(void)
1069	{
1070	RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
1071
1072	/* Try to open a test connection to hal */
1073	if (RT_SUCCESS(RTDBusLoadLib()) && RT_SUCCESS(halInit (&dbusConnection)))
1074	return !!dbusConnection;
1075	return false;
1076	}
1077
1078	/** Constructor */
1079	hotplugDBusImpl (void);
1080	virtual ~hotplugDBusImpl (void);
1081	/** @copydoc VBoxMainHotplugWaiter::Wait */
1082	virtual int Wait (RTMSINTERVAL cMillies);
1083	/** @copydoc VBoxMainHotplugWaiter::Interrupt */
1084	virtual void Interrupt (void);
1085	};
1086
1087	/* This constructor sets up a private connection to the DBus daemon, connects
1088	* to the hal service and installs a filter which sets the mTriggered flag in
1089	* the Context structure when a device (not necessarily USB) is added or
1090	* removed. */
1091	hotplugDBusImpl::hotplugDBusImpl (void) : mTriggered(false), mInterrupt(false)
1092	{
1093	int rc = VINF_SUCCESS;
1094
1095	if (RT_SUCCESS(RTDBusLoadLib()))
1096	{
1097	for (unsigned i = 0; RT_SUCCESS(rc) && i < 5 && !mConnection; ++i)
1098	{
1099	rc = halInitPrivate (&mConnection);
1100	}
1101	if (!mConnection)
1102	rc = VERR_NOT_SUPPORTED;
1103	DBusMessage *pMessage;
1104	while ( RT_SUCCESS(rc)
1105	&& (pMessage = dbus_connection_pop_message (mConnection.get())) != NULL)
1106	dbus_message_unref (pMessage); /* empty the message queue. */
1107	if ( RT_SUCCESS(rc)
1108	&& !dbus_connection_add_filter (mConnection.get(),
1109	dbusFilterFunction,
1110	(void *) &mTriggered, NULL))
1111	rc = VERR_NO_MEMORY;
1112	if (RT_FAILURE(rc))
1113	mConnection.reset();
1114	}
1115	}
1116
1117	/* Destructor */
1118	hotplugDBusImpl::~hotplugDBusImpl ()
1119	{
1120	if (!!mConnection)
1121	dbus_connection_remove_filter (mConnection.get(), dbusFilterFunction,
1122	(void *) &mTriggered);
1123	}
1124
1125	/* Currently this is implemented using a timed out wait on our private DBus
1126	* connection. Because the connection is private we don't have to worry about
1127	* blocking other users. */
1128	int hotplugDBusImpl::Wait(RTMSINTERVAL cMillies)
1129	{
1130	int rc = VINF_SUCCESS;
1131	if (!mConnection)
1132	rc = VERR_NOT_SUPPORTED;
1133	bool connected = true;
1134	mTriggered = false;
1135	mInterrupt = false;
1136	unsigned cRealMillies;
1137	if (cMillies != RT_INDEFINITE_WAIT)
1138	cRealMillies = cMillies;
1139	else
1140	cRealMillies = DBUS_POLL_TIMEOUT;
1141	while ( RT_SUCCESS(rc) && connected && !mTriggered
1142	&& !mInterrupt)
1143	{
1144	connected = dbus_connection_read_write_dispatch (mConnection.get(),
1145	cRealMillies);
1146	if (mInterrupt)
1147	LogFlowFunc(("wait loop interrupted\n"));
1148	if (cMillies != RT_INDEFINITE_WAIT)
1149	mInterrupt = true;
1150	}
1151	if (!connected)
1152	rc = VERR_TRY_AGAIN;
1153	return rc;
1154	}
1155
1156	/* Set a flag to tell the Wait not to resume next time it times out. */
1157	void hotplugDBusImpl::Interrupt()
1158	{
1159	LogFlowFunc(("\n"));
1160	mInterrupt = true;
1161	}
1162	#endif /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
1163
1164	class hotplugNullImpl : public VBoxMainHotplugWaiterImpl
1165	{
1166	public:
1167	hotplugNullImpl (void) {}
1168	virtual ~hotplugNullImpl (void) {}
1169	/** @copydoc VBoxMainHotplugWaiter::Wait */
1170	virtual int Wait (RTMSINTERVAL)
1171	{
1172	return VERR_NOT_SUPPORTED;
1173	}
1174	/** @copydoc VBoxMainHotplugWaiter::Interrupt */
1175	virtual void Interrupt (void) {}
1176	};
1177
1178	VBoxMainHotplugWaiter::VBoxMainHotplugWaiter(void)
1179	{
1180	#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
1181	if (hotplugDBusImpl::HalAvailable())
1182	{
1183	mImpl = new hotplugDBusImpl;
1184	return;
1185	}
1186	#endif /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
1187	mImpl = new hotplugNullImpl;
1188	}
1189
1190	class sysfsPathHandler
1191	{
1192	/** Called on each element of the sysfs directory. Can e.g. store
1193	* interesting entries in a list. */
1194	virtual bool handle(const char *pcszNode) = 0;
1195	public:
1196	bool doHandle(const char *pcszNode)
1197	{
1198	AssertPtr(pcszNode);
1199	Assert(pcszNode[0] == '/');
1200	Assert(RTPathExists(pcszNode));
1201	return handle(pcszNode);
1202	}
1203	};
1204
1205	/**
1206	* Helper function to walk a sysfs directory for extracting information about
1207	* devices.
1208	* @returns iprt status code
1209	* @param pcszPath Sysfs directory to walk. Must exist.
1210	* @param pHandler Handler object which will be invoked on each directory
1211	* entry
1212	*
1213	* @returns IPRT status code
1214	*/
1215	/* static */
1216	int getDeviceInfoFromSysfs(const char pcszPath, sysfsPathHandler pHandler)
1217	{
1218	AssertPtrReturn(pcszPath, VERR_INVALID_POINTER);
1219	AssertPtrReturn(pHandler, VERR_INVALID_POINTER);
1220	LogFlowFunc (("pcszPath=%s, pHandler=%p\n", pcszPath, pHandler));
1221	PRTDIR pDir = NULL;
1222	int rc;
1223
1224	rc = RTDirOpen(&pDir, pcszPath);
1225	AssertRCReturn(rc, rc);
1226	while (RT_SUCCESS(rc))
1227	{
1228	RTDIRENTRY entry;
1229	char szPath[RTPATH_MAX], szAbsPath[RTPATH_MAX];
1230
1231	rc = RTDirRead(pDir, &entry, NULL);
1232	Assert(rc != VERR_BUFFER_OVERFLOW); /* Should never happen... */
1233	/* We break on "no more files" as well as on "real" errors */
1234	if (RT_FAILURE(rc))
1235	break;
1236	if (entry.szName[0] == '.')
1237	continue;
1238	if (RTStrPrintf(szPath, sizeof(szPath), "%s/%s", pcszPath,
1239	entry.szName) >= sizeof(szPath))
1240	rc = VERR_BUFFER_OVERFLOW;
1241	if (RT_FAILURE(rc))
1242	break;
1243	rc = RTPathReal(szPath, szAbsPath, sizeof(szAbsPath));
1244	AssertRCBreak(rc); /* sysfs should guarantee that this exists */
1245	if (!pHandler->doHandle(szAbsPath))
1246	break;
1247	}
1248	RTDirClose(pDir);
1249	if (rc == VERR_NO_MORE_FILES)
1250	rc = VINF_SUCCESS;
1251	LogFlow (("rc=%Rrc\n", rc));
1252	return rc;
1253	}
1254
1255
1256	/**
1257	* Tell whether a file in /sys/bus/usb/devices is a device rather than an
1258	* interface. To be used with getDeviceInfoFromSysfs().
1259	*/
1260	class matchUSBDevice : public sysfsPathHandler
1261	{
1262	USBDeviceInfoList *mList;
1263	public:
1264	matchUSBDevice(USBDeviceInfoList *pList) : mList(pList) {}
1265	private:
1266	virtual bool handle(const char *pcszNode)
1267	{
1268	const char *pcszFile = strrchr(pcszNode, '/');
1269	if (strchr(pcszFile, ':'))
1270	return true;
1271	dev_t devnum = RTLinuxSysFsReadDevNumFile("%s/dev", pcszNode);
1272	AssertReturn (devnum, true);
1273	char szDevPath[RTPATH_MAX];
1274	ssize_t cchDevPath;
1275	cchDevPath = RTLinuxFindDevicePath(devnum, RTFS_TYPE_DEV_CHAR,
1276	szDevPath, sizeof(szDevPath),
1277	"/dev/bus/usb/%.3d/%.3d",
1278	RTLinuxSysFsReadIntFile(10, "%s/busnum", pcszNode),
1279	RTLinuxSysFsReadIntFile(10, "%s/devnum", pcszNode));
1280	if (cchDevPath < 0)
1281	return true;
1282	try
1283	{
1284	mList->push_back(USBDeviceInfo(szDevPath, pcszNode));
1285	}
1286	catch(std::bad_alloc &e)
1287	{
1288	return false;
1289	}
1290	return true;
1291	}
1292	};
1293
1294	/**
1295	* Tell whether a file in /sys/bus/usb/devices is an interface rather than a
1296	* device. To be used with getDeviceInfoFromSysfs().
1297	*/
1298	class matchUSBInterface : public sysfsPathHandler
1299	{
1300	USBDeviceInfo *mInfo;
1301	public:
1302	/** This constructor is currently used to unit test the class logic in
1303	* debug builds. Since no access is made to anything outside the class,
1304	* this shouldn't cause any slowdown worth mentioning. */
1305	matchUSBInterface(USBDeviceInfo *pInfo) : mInfo(pInfo)
1306	{
1307	Assert(isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0",
1308	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1309	Assert(!isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-1",
1310	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1311	Assert(!isAnInterfaceOf("/sys/devices/pci0000:00/0000:00:1a.0/usb3/3-0:1.0/driver",
1312	"/sys/devices/pci0000:00/0000:00:1a.0/usb3"));
1313	}
1314	private:
1315	/** The logic for testing whether a sysfs address corresponds to an
1316	* interface of a device. Both must be referenced by their canonical
1317	* sysfs paths. This is not tested, as the test requires file-system
1318	* interaction. */
1319	bool isAnInterfaceOf(const char pcszIface, const char pcszDev)
1320	{
1321	size_t cchDev = strlen(pcszDev);
1322
1323	AssertPtr(pcszIface);
1324	AssertPtr(pcszDev);
1325	Assert(pcszIface[0] == '/');
1326	Assert(pcszDev[0] == '/');
1327	Assert(pcszDev[cchDev - 1] != '/');
1328	/* If this passes, pcszIface is at least cchDev long */
1329	if (strncmp(pcszIface, pcszDev, cchDev))
1330	return false;
1331	/* If this passes, pcszIface is longer than cchDev */
1332	if (pcszIface[cchDev] != '/')
1333	return false;
1334	/* In sysfs an interface is an immediate subdirectory of the device */
1335	if (strchr(pcszIface + cchDev + 1, '/'))
1336	return false;
1337	/* And it always has a colon in its name */
1338	if (!strchr(pcszIface + cchDev + 1, ':'))
1339	return false;
1340	/* And hopefully we have now elimitated everything else */
1341	return true;
1342	}
1343
1344	virtual bool handle(const char *pcszNode)
1345	{
1346	if (!isAnInterfaceOf(pcszNode, mInfo->mSysfsPath.c_str()))
1347	return true;
1348	try
1349	{
1350	mInfo->mInterfaces.push_back(pcszNode);
1351	}
1352	catch(std::bad_alloc &e)
1353	{
1354	return false;
1355	}
1356	return true;
1357	}
1358	};
1359
1360	/**
1361	* Helper function to query the sysfs subsystem for information about USB
1362	* devices attached to the system.
1363	* @returns iprt status code
1364	* @param pList where to add information about the drives detected
1365	* @param pfSuccess Did we find anything?
1366	*
1367	* @returns IPRT status code
1368	*/
1369	static int getUSBDeviceInfoFromSysfs(USBDeviceInfoList *pList,
1370	bool *pfSuccess)
1371	{
1372	AssertPtrReturn(pList, VERR_INVALID_POINTER);
1373	AssertPtrNullReturn(pfSuccess, VERR_INVALID_POINTER); /* Valid or Null */
1374	LogFlowFunc (("pList=%p, pfSuccess=%p\n",
1375	pList, pfSuccess));
1376	size_t cDevices = pList->size();
1377	matchUSBDevice devHandler(pList);
1378	int rc = getDeviceInfoFromSysfs("/sys/bus/usb/devices", &devHandler);
1379	do {
1380	if (RT_FAILURE(rc))
1381	break;
1382	for (USBDeviceInfoList::iterator pInfo = pList->begin();
1383	pInfo != pList->end(); ++pInfo)
1384	{
1385	matchUSBInterface ifaceHandler(&*pInfo);
1386	rc = getDeviceInfoFromSysfs("/sys/bus/usb/devices", &ifaceHandler);
1387	if (RT_FAILURE(rc))
1388	break;
1389	}
1390	} while(0);
1391	if (RT_FAILURE(rc))
1392	/* Clean up again */
1393	while (pList->size() > cDevices)
1394	pList->pop_back();
1395	if (pfSuccess)
1396	*pfSuccess = RT_SUCCESS(rc);
1397	LogFlow (("rc=%Rrc\n", rc));
1398	return rc;
1399	}
1400
1401
1402	#if defined(RT_OS_LINUX) && defined(VBOX_WITH_DBUS)
1403	/** Wrapper class around DBusError for automatic cleanup */
1404	class autoDBusError
1405	{
1406	DBusError mError;
1407	public:
1408	autoDBusError () { dbus_error_init (&mError); }
1409	~autoDBusError ()
1410	{
1411	if (IsSet())
1412	dbus_error_free (&mError);
1413	}
1414	DBusError &get () { return mError; }
1415	bool IsSet ()
1416	{
1417	Assert((mError.name == NULL) == (mError.message == NULL));
1418	return (mError.name != NULL);
1419	}
1420	bool HasName (const char *pcszName)
1421	{
1422	Assert((mError.name == NULL) == (mError.message == NULL));
1423	return (RTStrCmp (mError.name, pcszName) == 0);
1424	}
1425	void FlowLog ()
1426	{
1427	if (IsSet ())
1428	LogFlow(("DBus error %s: %s\n", mError.name, mError.message));
1429	}
1430	};
1431
1432	/**
1433	* Helper function for setting up a connection to the DBus daemon and
1434	* registering with the hal service.
1435	*
1436	* @note If libdbus is being loaded at runtime then be sure to call
1437	* VBoxDBusCheckPresence before calling this.
1438	* @returns iprt status code
1439	* @param ppConnection where to store the connection handle
1440	*/
1441	/* static */
1442	int halInit (RTMemAutoPtr <DBusConnection, VBoxHalShutdown> *pConnection)
1443	{
1444	AssertReturn(VALID_PTR (pConnection), VERR_INVALID_POINTER);
1445	LogFlowFunc (("pConnection=%p\n", pConnection));
1446	int rc = VINF_SUCCESS;
1447	bool halSuccess = true;
1448	autoDBusError dbusError;
1449
1450	RTMemAutoPtr <DBusConnection, VBoxDBusConnectionUnref> dbusConnection;
1451	dbusConnection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbusError.get());
1452	if (!dbusConnection)
1453	halSuccess = false;
1454	if (halSuccess)
1455	{
1456	dbus_connection_set_exit_on_disconnect (dbusConnection.get(), false);
1457	halSuccess = dbus_bus_name_has_owner (dbusConnection.get(),
1458	"org.freedesktop.Hal", &dbusError.get());
1459	}
1460	if (halSuccess)
1461	{
1462	dbus_bus_add_match (dbusConnection.get(),
1463	"type='signal',"
1464	"interface='org.freedesktop.Hal.Manager',"
1465	"sender='org.freedesktop.Hal',"
1466	"path='/org/freedesktop/Hal/Manager'",
1467	&dbusError.get());
1468	halSuccess = !dbusError.IsSet();
1469	}
1470	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1471	rc = VERR_NO_MEMORY;
1472	if (halSuccess)
1473	*pConnection = dbusConnection.release();
1474	LogFlowFunc(("rc=%Rrc, (pConnection).get()=%p\n", rc, (pConnection).get()));
1475	dbusError.FlowLog();
1476	return rc;
1477	}
1478
1479	/**
1480	* Helper function for setting up a private connection to the DBus daemon and
1481	* registering with the hal service. Private connections are considered
1482	* unsociable and should not be used unnecessarily (as per the DBus API docs).
1483	*
1484	* @note If libdbus is being loaded at runtime then be sure to call
1485	* VBoxDBusCheckPresence before calling this.
1486	* @returns iprt status code
1487	* @param pConnection where to store the connection handle
1488	*/
1489	/* static */
1490	int halInitPrivate (RTMemAutoPtr <DBusConnection, VBoxHalShutdownPrivate> *pConnection)
1491	{
1492	AssertReturn(VALID_PTR (pConnection), VERR_INVALID_POINTER);
1493	LogFlowFunc (("pConnection=%p\n", pConnection));
1494	int rc = VINF_SUCCESS;
1495	bool halSuccess = true;
1496	autoDBusError dbusError;
1497
1498	RTMemAutoPtr <DBusConnection, VBoxDBusConnectionCloseAndUnref> dbusConnection;
1499	dbusConnection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbusError.get());
1500	if (!dbusConnection)
1501	halSuccess = false;
1502	if (halSuccess)
1503	{
1504	dbus_connection_set_exit_on_disconnect (dbusConnection.get(), false);
1505	halSuccess = dbus_bus_name_has_owner (dbusConnection.get(),
1506	"org.freedesktop.Hal", &dbusError.get());
1507	}
1508	if (halSuccess)
1509	{
1510	dbus_bus_add_match (dbusConnection.get(),
1511	"type='signal',"
1512	"interface='org.freedesktop.Hal.Manager',"
1513	"sender='org.freedesktop.Hal',"
1514	"path='/org/freedesktop/Hal/Manager'",
1515	&dbusError.get());
1516	halSuccess = !dbusError.IsSet();
1517	}
1518	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1519	rc = VERR_NO_MEMORY;
1520	if (halSuccess)
1521	*pConnection = dbusConnection.release();
1522	LogFlowFunc(("rc=%Rrc, (pConnection).get()=%p\n", rc, (pConnection).get()));
1523	dbusError.FlowLog();
1524	return rc;
1525	}
1526
1527	/**
1528	* Helper function for shutting down a connection to DBus and hal.
1529	* @param pConnection the connection handle
1530	*/
1531	/* extern */
1532	void VBoxHalShutdown (DBusConnection *pConnection)
1533	{
1534	AssertReturnVoid(VALID_PTR (pConnection));
1535	LogFlowFunc (("pConnection=%p\n", pConnection));
1536	autoDBusError dbusError;
1537
1538	dbus_bus_remove_match (pConnection,
1539	"type='signal',"
1540	"interface='org.freedesktop.Hal.Manager',"
1541	"sender='org.freedesktop.Hal',"
1542	"path='/org/freedesktop/Hal/Manager'",
1543	&dbusError.get());
1544	dbus_connection_unref (pConnection);
1545	LogFlowFunc(("returning\n"));
1546	dbusError.FlowLog();
1547	}
1548
1549	/**
1550	* Helper function for shutting down a private connection to DBus and hal.
1551	* @param pConnection the connection handle
1552	*/
1553	/* extern */
1554	void VBoxHalShutdownPrivate (DBusConnection *pConnection)
1555	{
1556	AssertReturnVoid(VALID_PTR (pConnection));
1557	LogFlowFunc (("pConnection=%p\n", pConnection));
1558	autoDBusError dbusError;
1559
1560	dbus_bus_remove_match (pConnection,
1561	"type='signal',"
1562	"interface='org.freedesktop.Hal.Manager',"
1563	"sender='org.freedesktop.Hal',"
1564	"path='/org/freedesktop/Hal/Manager'",
1565	&dbusError.get());
1566	dbus_connection_close (pConnection);
1567	dbus_connection_unref (pConnection);
1568	LogFlowFunc(("returning\n"));
1569	dbusError.FlowLog();
1570	}
1571
1572	/** Wrapper around dbus_connection_unref. We need this to use it as a real
1573	* function in auto pointers, as a function pointer won't wash here. */
1574	/* extern */
1575	void VBoxDBusConnectionUnref(DBusConnection *pConnection)
1576	{
1577	dbus_connection_unref(pConnection);
1578	}
1579
1580	/**
1581	* This function closes and unrefs a private connection to dbus. It should
1582	* only be called once no-one else is referencing the connection.
1583	*/
1584	/* extern */
1585	void VBoxDBusConnectionCloseAndUnref(DBusConnection *pConnection)
1586	{
1587	dbus_connection_close(pConnection);
1588	dbus_connection_unref(pConnection);
1589	}
1590
1591	/** Wrapper around dbus_message_unref. We need this to use it as a real
1592	* function in auto pointers, as a function pointer won't wash here. */
1593	/* extern */
1594	void VBoxDBusMessageUnref(DBusMessage *pMessage)
1595	{
1596	dbus_message_unref(pMessage);
1597	}
1598
1599	/**
1600	* Find the UDIs of hal entries that contain Key=Value property.
1601	* @returns iprt status code. If a non-fatal error occurs, we return success
1602	* but reset pMessage to NULL.
1603	* @param pConnection an initialised connection DBus
1604	* @param pszKey the property key
1605	* @param pszValue the property value
1606	* @param pMessage where to store the return DBus message. This must be
1607	* parsed to get at the UDIs. NOT optional.
1608	*/
1609	/* static */
1610	int halFindDeviceStringMatch (DBusConnection pConnection, const char pszKey,
1611	const char *pszValue,
1612	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage)
1613	{
1614	AssertReturn( VALID_PTR (pConnection) && VALID_PTR (pszKey)
1615	&& VALID_PTR (pszValue) && VALID_PTR (pMessage),
1616	VERR_INVALID_POINTER);
1617	LogFlowFunc (("pConnection=%p, pszKey=%s, pszValue=%s, pMessage=%p\n",
1618	pConnection, pszKey, pszValue, pMessage));
1619	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1620	bool halSuccess = true; /* We set this to false to abort the operation. */
1621	autoDBusError dbusError;
1622
1623	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, reply;
1624	if (halSuccess && RT_SUCCESS(rc))
1625	{
1626	message = dbus_message_new_method_call ("org.freedesktop.Hal",
1627	"/org/freedesktop/Hal/Manager",
1628	"org.freedesktop.Hal.Manager",
1629	"FindDeviceStringMatch");
1630	if (!message)
1631	rc = VERR_NO_MEMORY;
1632	}
1633	if (halSuccess && RT_SUCCESS(rc))
1634	{
1635	DBusMessageIter iterAppend;
1636	dbus_message_iter_init_append (message.get(), &iterAppend);
1637	dbus_message_iter_append_basic (&iterAppend, DBUS_TYPE_STRING, &pszKey);
1638	dbus_message_iter_append_basic (&iterAppend, DBUS_TYPE_STRING, &pszValue);
1639	reply = dbus_connection_send_with_reply_and_block (pConnection,
1640	message.get(), -1,
1641	&dbusError.get());
1642	if (!reply)
1643	halSuccess = false;
1644	}
1645	*pMessage = reply.release ();
1646	LogFlowFunc (("rc=%Rrc, pMessage.value()=%p\n", rc, (pMessage).get()));
1647	dbusError.FlowLog();
1648	return rc;
1649	}
1650
1651	/**
1652	* Find the UDIs of hal entries that contain Key=Value property and return the
1653	* result on the end of a vector of iprt::MiniString.
1654	* @returns iprt status code. If a non-fatal error occurs, we return success
1655	* but set *pfSuccess to false.
1656	* @param pConnection an initialised connection DBus
1657	* @param pszKey the property key
1658	* @param pszValue the property value
1659	* @param pMatches pointer to an array of iprt::MiniString to append the
1660	* results to. NOT optional.
1661	* @param pfSuccess will be set to true if the operation succeeds
1662	*/
1663	/* static */
1664	int halFindDeviceStringMatchVector (DBusConnection *pConnection,
1665	const char pszKey, const char pszValue,
1666	std::vector<iprt::MiniString> *pMatches,
1667	bool *pfSuccess)
1668	{
1669	AssertPtrReturn (pConnection, VERR_INVALID_POINTER);
1670	AssertPtrReturn (pszKey, VERR_INVALID_POINTER);
1671	AssertPtrReturn (pszValue, VERR_INVALID_POINTER);
1672	AssertPtrReturn (pMatches, VERR_INVALID_POINTER);
1673	AssertReturn(pfSuccess == NULL \|\| VALID_PTR (pfSuccess), VERR_INVALID_POINTER);
1674	LogFlowFunc (("pConnection=%p, pszKey=%s, pszValue=%s, pMatches=%p, pfSuccess=%p\n",
1675	pConnection, pszKey, pszValue, pMatches, pfSuccess));
1676	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1677	bool halSuccess = true; /* We set this to false to abort the operation. */
1678
1679	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, replyFind;
1680	DBusMessageIter iterFind, iterUdis;
1681
1682	if (halSuccess && RT_SUCCESS(rc))
1683	{
1684	rc = halFindDeviceStringMatch (pConnection, pszKey, pszValue,
1685	&replyFind);
1686	if (!replyFind)
1687	halSuccess = false;
1688	}
1689	if (halSuccess && RT_SUCCESS(rc))
1690	{
1691	dbus_message_iter_init (replyFind.get(), &iterFind);
1692	if (dbus_message_iter_get_arg_type (&iterFind) != DBUS_TYPE_ARRAY)
1693	halSuccess = false;
1694	}
1695	if (halSuccess && RT_SUCCESS(rc))
1696	dbus_message_iter_recurse (&iterFind, &iterUdis);
1697	for (; halSuccess && RT_SUCCESS(rc)
1698	&& dbus_message_iter_get_arg_type (&iterUdis) == DBUS_TYPE_STRING;
1699	dbus_message_iter_next(&iterUdis))
1700	{
1701	/* Now get all UDIs from the iterator */
1702	const char *pszUdi;
1703	dbus_message_iter_get_basic (&iterUdis, &pszUdi);
1704	try
1705	{
1706	pMatches->push_back(pszUdi);
1707	}
1708	catch(std::bad_alloc &e)
1709	{
1710	rc = VERR_NO_MEMORY;
1711	}
1712	}
1713	if (pfSuccess != NULL)
1714	*pfSuccess = halSuccess;
1715	LogFlow (("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1716	return rc;
1717	}
1718
1719	/**
1720	* Read a set of string properties for a device. If some of the properties are
1721	* not of type DBUS_TYPE_STRING or do not exist then a NULL pointer will be
1722	* returned for them.
1723	* @returns iprt status code. If the operation failed for non-fatal reasons
1724	* then we return success and leave pMessage untouched - reset it
1725	* before the call to detect this.
1726	* @param pConnection an initialised connection DBus
1727	* @param pszUdi the Udi of the device
1728	* @param cProps the number of property values to look up
1729	* @param papszKeys the keys of the properties to be looked up
1730	* @param papszValues where to store the values of the properties. The
1731	* strings returned will be valid until the message
1732	* returned in @a ppMessage is freed. Undefined if
1733	* the message is NULL.
1734	* @param pMessage where to store the return DBus message. The caller
1735	* is responsible for freeing this once they have
1736	* finished with the value strings. NOT optional.
1737	*/
1738	/* static */
1739	int halGetPropertyStrings (DBusConnection pConnection, const char pszUdi,
1740	size_t cProps, const char **papszKeys,
1741	char **papszValues,
1742	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> *pMessage)
1743	{
1744	AssertReturn( VALID_PTR (pConnection) && VALID_PTR (pszUdi)
1745	&& VALID_PTR (papszKeys) && VALID_PTR (papszValues)
1746	&& VALID_PTR (pMessage),
1747	VERR_INVALID_POINTER);
1748	LogFlowFunc (("pConnection=%p, pszUdi=%s, cProps=%llu, papszKeys=%p, papszValues=%p, pMessage=%p\n",
1749	pConnection, pszUdi, cProps, papszKeys, papszValues, pMessage));
1750	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1751	bool halSuccess = true; /* We set this to false to abort the operation. */
1752	autoDBusError dbusError;
1753
1754	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, reply;
1755	DBusMessageIter iterGet, iterProps;
1756
1757	/* Initialise the return array to NULLs */
1758	for (size_t i = 0; i < cProps; ++i)
1759	papszValues[i] = NULL;
1760
1761	/* Send a GetAllProperties message to hald */
1762	message = dbus_message_new_method_call ("org.freedesktop.Hal", pszUdi,
1763	"org.freedesktop.Hal.Device",
1764	"GetAllProperties");
1765	if (!message)
1766	rc = VERR_NO_MEMORY;
1767	if (halSuccess && RT_SUCCESS(rc))
1768	{
1769	reply = dbus_connection_send_with_reply_and_block (pConnection,
1770	message.get(), -1,
1771	&dbusError.get());
1772	if (!reply)
1773	halSuccess = false;
1774	}
1775
1776	/* Parse the reply */
1777	if (halSuccess && RT_SUCCESS(rc))
1778	{
1779	dbus_message_iter_init (reply.get(), &iterGet);
1780	if ( dbus_message_iter_get_arg_type (&iterGet) != DBUS_TYPE_ARRAY
1781	&& dbus_message_iter_get_element_type (&iterGet) != DBUS_TYPE_DICT_ENTRY)
1782	halSuccess = false;
1783	}
1784	if (halSuccess && RT_SUCCESS(rc))
1785	dbus_message_iter_recurse (&iterGet, &iterProps);
1786	/* Go through all entries in the reply and see if any match our keys. */
1787	while ( halSuccess && RT_SUCCESS(rc)
1788	&& dbus_message_iter_get_arg_type (&iterProps)
1789	== DBUS_TYPE_DICT_ENTRY)
1790	{
1791	const char *pszKey;
1792	DBusMessageIter iterEntry, iterValue;
1793	dbus_message_iter_recurse (&iterProps, &iterEntry);
1794	dbus_message_iter_get_basic (&iterEntry, &pszKey);
1795	dbus_message_iter_next (&iterEntry);
1796	dbus_message_iter_recurse (&iterEntry, &iterValue);
1797	/* Fill in any matches. */
1798	for (size_t i = 0; i < cProps; ++i)
1799	if (strcmp (pszKey, papszKeys[i]) == 0)
1800	{
1801	if (dbus_message_iter_get_arg_type (&iterValue) == DBUS_TYPE_STRING)
1802	dbus_message_iter_get_basic (&iterValue, &papszValues[i]);
1803	}
1804	dbus_message_iter_next (&iterProps);
1805	}
1806	if (RT_SUCCESS(rc) && halSuccess)
1807	*pMessage = reply.release();
1808	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1809	rc = VERR_NO_MEMORY;
1810	LogFlowFunc (("rc=%Rrc, pMessage.value()=%p\n", rc, (pMessage).get()));
1811	dbusError.FlowLog();
1812	return rc;
1813	}
1814
1815	/**
1816	* Read a set of string properties for a device. If some properties do not
1817	* exist or are not of type DBUS_TYPE_STRING, we will still fetch the others.
1818	* @returns iprt status code. If the operation failed for non-fatal reasons
1819	* then we return success and set *pfSuccess to false.
1820	* @param pConnection an initialised connection DBus
1821	* @param pszUdi the Udi of the device
1822	* @param cProps the number of property values to look up
1823	* @param papszKeys the keys of the properties to be looked up
1824	* @param pMatches pointer to an empty array of iprt::MiniString to append the
1825	* results to. NOT optional.
1826	* @param pfMatches pointer to an array of boolean values indicating
1827	* whether the respective property is a string. If this
1828	* is not supplied then all properties must be strings
1829	* for the operation to be considered successful
1830	* @param pfSuccess will be set to true if the operation succeeds
1831	*/
1832	/* static */
1833	int halGetPropertyStringsVector (DBusConnection *pConnection,
1834	const char *pszUdi, size_t cProps,
1835	const char **papszKeys,
1836	std::vector<iprt::MiniString> *pMatches,
1837	bool pfMatches, bool pfSuccess)
1838	{
1839	AssertPtrReturn (pConnection, VERR_INVALID_POINTER);
1840	AssertPtrReturn (pszUdi, VERR_INVALID_POINTER);
1841	AssertPtrReturn (papszKeys, VERR_INVALID_POINTER);
1842	AssertPtrReturn (pMatches, VERR_INVALID_POINTER);
1843	AssertReturn((pfMatches == NULL) \|\| VALID_PTR (pfMatches), VERR_INVALID_POINTER);
1844	AssertReturn((pfSuccess == NULL) \|\| VALID_PTR (pfSuccess), VERR_INVALID_POINTER);
1845	AssertReturn(pMatches->empty(), VERR_INVALID_PARAMETER);
1846	LogFlowFunc (("pConnection=%p, pszUdi=%s, cProps=%llu, papszKeys=%p, pMatches=%p, pfMatches=%p, pfSuccess=%p\n",
1847	pConnection, pszUdi, cProps, papszKeys, pMatches, pfMatches, pfSuccess));
1848	RTMemAutoPtr <char *> values(cProps);
1849	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message;
1850	bool halSuccess = true;
1851	int rc = halGetPropertyStrings (pConnection, pszUdi, cProps, papszKeys,
1852	values.get(), &message);
1853	if (!message)
1854	halSuccess = false;
1855	for (size_t i = 0; RT_SUCCESS(rc) && halSuccess && i < cProps; ++i)
1856	{
1857	bool fMatches = values[i] != NULL;
1858	if (pfMatches != NULL)
1859	pfMatches[i] = fMatches;
1860	else
1861	halSuccess = fMatches;
1862	try
1863	{
1864	pMatches->push_back(fMatches ? values[i] : "");
1865	}
1866	catch(std::bad_alloc &e)
1867	{
1868	rc = VERR_NO_MEMORY;
1869	}
1870	}
1871	if (pfSuccess != NULL)
1872	*pfSuccess = halSuccess;
1873	if (RT_SUCCESS(rc) && halSuccess)
1874	{
1875	Assert(pMatches->size() == cProps);
1876	AssertForEach(j, size_t, 0, cProps, (pfMatches == NULL)
1877	\|\| (pfMatches[j] == true)
1878	\|\| ((pfMatches[j] == false) && (pMatches[j].size() == 0)));
1879	}
1880	LogFlowFunc (("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1881	return rc;
1882	}
1883
1884
1885	/**
1886	* Helper function to query the hal subsystem for information about USB devices
1887	* attached to the system.
1888	* @returns iprt status code
1889	* @param pList where to add information about the devices detected
1890	* @param pfSuccess will be set to true if all interactions with hal
1891	* succeeded and to false otherwise. Optional.
1892	*
1893	* @returns IPRT status code
1894	*/
1895	/* static */
1896	int getUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess)
1897	{
1898	AssertReturn(VALID_PTR (pList) && (pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
1899	VERR_INVALID_POINTER);
1900	LogFlowFunc (("pList=%p, pfSuccess=%p\n", pList, pfSuccess));
1901	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1902	bool halSuccess = true; /* We set this to false to abort the operation. */
1903	autoDBusError dbusError;
1904
1905	RTMemAutoPtr<DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
1906	RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
1907	DBusMessageIter iterFind, iterUdis;
1908
1909	/* Connect to hal */
1910	rc = halInit (&dbusConnection);
1911	if (!dbusConnection)
1912	halSuccess = false;
1913	/* Get an array of all devices in the usb_device subsystem */
1914	if (halSuccess && RT_SUCCESS(rc))
1915	{
1916	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.subsystem",
1917	"usb_device", &replyFind);
1918	if (!replyFind)
1919	halSuccess = false;
1920	}
1921	if (halSuccess && RT_SUCCESS(rc))
1922	{
1923	dbus_message_iter_init(replyFind.get(), &iterFind);
1924	if (dbus_message_iter_get_arg_type (&iterFind) != DBUS_TYPE_ARRAY)
1925	halSuccess = false;
1926	}
1927	/* Recurse down into the array and query interesting information about the
1928	* entries. */
1929	if (halSuccess && RT_SUCCESS(rc))
1930	dbus_message_iter_recurse(&iterFind, &iterUdis);
1931	for (; halSuccess && RT_SUCCESS(rc)
1932	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
1933	dbus_message_iter_next(&iterUdis))
1934	{
1935	/* Get the device node and the sysfs path for the current entry. */
1936	const char *pszUdi;
1937	dbus_message_iter_get_basic (&iterUdis, &pszUdi);
1938	static const char *papszKeys[] = { "linux.device_file", "linux.sysfs_path" };
1939	char *papszValues[RT_ELEMENTS(papszKeys)];
1940	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
1941	papszKeys, papszValues, &replyGet);
1942	const char pszDevice = papszValues[0], pszSysfsPath = papszValues[1];
1943	/* Get the interfaces. */
1944	if (!!replyGet && pszDevice && pszSysfsPath)
1945	{
1946	USBDeviceInfo info(pszDevice, pszSysfsPath);
1947	bool ifaceSuccess = true; /* If we can't get the interfaces, just
1948	* skip this one device. */
1949	rc = getUSBInterfacesFromHal(&info.mInterfaces, pszUdi, &ifaceSuccess);
1950	if (RT_SUCCESS(rc) && halSuccess && ifaceSuccess)
1951	try
1952	{
1953	pList->push_back(info);
1954	}
1955	catch(std::bad_alloc &e)
1956	{
1957	rc = VERR_NO_MEMORY;
1958	}
1959	}
1960	}
1961	if (dbusError.HasName (DBUS_ERROR_NO_MEMORY))
1962	rc = VERR_NO_MEMORY;
1963	if (pfSuccess != NULL)
1964	*pfSuccess = halSuccess;
1965	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
1966	dbusError.FlowLog();
1967	return rc;
1968	}
1969
1970	/**
1971	* Helper function to query the hal subsystem for information about USB devices
1972	* attached to the system, using the older API.
1973	* @returns iprt status code
1974	* @param pList where to add information about the devices detected
1975	* @param pfSuccess will be set to true if all interactions with hal
1976	* succeeded and to false otherwise. Optional.
1977	*
1978	* @returns IPRT status code
1979	*/
1980	/* static */
1981	int getOldUSBDeviceInfoFromHal(USBDeviceInfoList pList, bool pfSuccess)
1982	{
1983	AssertReturn(VALID_PTR (pList) && (pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
1984	VERR_INVALID_POINTER);
1985	LogFlowFunc (("pList=%p, pfSuccess=%p\n", pList, pfSuccess));
1986	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
1987	bool halSuccess = true; /* We set this to false to abort the operation. */
1988	autoDBusError dbusError;
1989
1990	RTMemAutoPtr<DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
1991	RTMemAutoPtr<DBusConnection, VBoxHalShutdown> dbusConnection;
1992	DBusMessageIter iterFind, iterUdis;
1993
1994	/* Connect to hal */
1995	rc = halInit(&dbusConnection);
1996	if (!dbusConnection)
1997	halSuccess = false;
1998	/* Get an array of all devices in the usb_device subsystem */
1999	if (halSuccess && RT_SUCCESS(rc))
2000	{
2001	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.category",
2002	"usbraw", &replyFind);
2003	if (!replyFind)
2004	halSuccess = false;
2005	}
2006	if (halSuccess && RT_SUCCESS(rc))
2007	{
2008	dbus_message_iter_init(replyFind.get(), &iterFind);
2009	if (dbus_message_iter_get_arg_type(&iterFind) != DBUS_TYPE_ARRAY)
2010	halSuccess = false;
2011	}
2012	/* Recurse down into the array and query interesting information about the
2013	* entries. */
2014	if (halSuccess && RT_SUCCESS(rc))
2015	dbus_message_iter_recurse(&iterFind, &iterUdis);
2016	for (; halSuccess && RT_SUCCESS(rc)
2017	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
2018	dbus_message_iter_next(&iterUdis))
2019	{
2020	/* Get the device node and the sysfs path for the current entry. */
2021	const char *pszUdi;
2022	dbus_message_iter_get_basic(&iterUdis, &pszUdi);
2023	static const char *papszKeys[] = { "linux.device_file", "info.parent" };
2024	char *papszValues[RT_ELEMENTS(papszKeys)];
2025	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
2026	papszKeys, papszValues, &replyGet);
2027	const char pszDevice = papszValues[0], pszSysfsPath = papszValues[1];
2028	/* Get the interfaces. */
2029	if (!!replyGet && pszDevice && pszSysfsPath)
2030	{
2031	USBDeviceInfo info(pszDevice, pszSysfsPath);
2032	bool ifaceSuccess = false; /* If we can't get the interfaces, just
2033	* skip this one device. */
2034	rc = getUSBInterfacesFromHal(&info.mInterfaces, pszSysfsPath,
2035	&ifaceSuccess);
2036	if (RT_SUCCESS(rc) && halSuccess && ifaceSuccess)
2037	try
2038	{
2039	pList->push_back(info);
2040	}
2041	catch(std::bad_alloc &e)
2042	{
2043	rc = VERR_NO_MEMORY;
2044	}
2045	}
2046	}
2047	if (dbusError.HasName(DBUS_ERROR_NO_MEMORY))
2048	rc = VERR_NO_MEMORY;
2049	if (pfSuccess != NULL)
2050	*pfSuccess = halSuccess;
2051	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
2052	dbusError.FlowLog();
2053	return rc;
2054	}
2055
2056
2057	/**
2058	* Helper function to query the hal subsystem for information about USB devices
2059	* attached to the system.
2060	* @returns iprt status code
2061	* @param pList where to add information about the devices detected. If
2062	* certain interfaces are not found (@a pfFound is false on
2063	* return) this may contain invalid information.
2064	* @param pcszUdi the hal UDI of the device
2065	* @param pfSuccess will be set to true if the operation succeeds and to
2066	* false if it fails for non-critical reasons. Optional.
2067	*
2068	* @returns IPRT status code
2069	*/
2070	/* static */
2071	int getUSBInterfacesFromHal(std::vector<iprt::MiniString> *pList,
2072	const char pcszUdi, bool pfSuccess)
2073	{
2074	AssertReturn(VALID_PTR(pList) && VALID_PTR(pcszUdi) &&
2075	(pfSuccess == NULL \|\| VALID_PTR (pfSuccess)),
2076	VERR_INVALID_POINTER);
2077	LogFlowFunc(("pList=%p, pcszUdi=%s, pfSuccess=%p\n", pList, pcszUdi,
2078	pfSuccess));
2079	int rc = VINF_SUCCESS; /* We set this to failure on fatal errors. */
2080	bool halSuccess = true; /* We set this to false to abort the operation. */
2081	autoDBusError dbusError;
2082
2083	RTMemAutoPtr <DBusMessage, VBoxDBusMessageUnref> message, replyFind, replyGet;
2084	RTMemAutoPtr <DBusConnection, VBoxHalShutdown> dbusConnection;
2085	DBusMessageIter iterFind, iterUdis;
2086
2087	rc = halInit(&dbusConnection);
2088	if (!dbusConnection)
2089	halSuccess = false;
2090	if (halSuccess && RT_SUCCESS(rc))
2091	{
2092	/* Look for children of the current UDI. */
2093	rc = halFindDeviceStringMatch(dbusConnection.get(), "info.parent",
2094	pcszUdi, &replyFind);
2095	if (!replyFind)
2096	halSuccess = false;
2097	}
2098	if (halSuccess && RT_SUCCESS(rc))
2099	{
2100	dbus_message_iter_init(replyFind.get(), &iterFind);
2101	if (dbus_message_iter_get_arg_type(&iterFind) != DBUS_TYPE_ARRAY)
2102	halSuccess = false;
2103	}
2104	if (halSuccess && RT_SUCCESS(rc))
2105	dbus_message_iter_recurse(&iterFind, &iterUdis);
2106	for (; halSuccess && RT_SUCCESS(rc)
2107	&& dbus_message_iter_get_arg_type(&iterUdis) == DBUS_TYPE_STRING;
2108	dbus_message_iter_next(&iterUdis))
2109	{
2110	/* Now get the sysfs path and the subsystem from the iterator */
2111	const char *pszUdi;
2112	dbus_message_iter_get_basic(&iterUdis, &pszUdi);
2113	static const char *papszKeys[] = { "linux.sysfs_path", "info.subsystem",
2114	"linux.subsystem" };
2115	char *papszValues[RT_ELEMENTS(papszKeys)];
2116	rc = halGetPropertyStrings(dbusConnection.get(), pszUdi, RT_ELEMENTS(papszKeys),
2117	papszKeys, papszValues, &replyGet);
2118	const char pszSysfsPath = papszValues[0], pszInfoSubsystem = papszValues[1],
2119	*pszLinuxSubsystem = papszValues[2];
2120	if (!replyGet)
2121	halSuccess = false;
2122	if (!!replyGet && pszSysfsPath == NULL)
2123	halSuccess = false;
2124	if ( halSuccess && RT_SUCCESS(rc)
2125	&& RTStrCmp (pszInfoSubsystem, "usb_device") != 0 /* Children of buses can also be devices. */
2126	&& RTStrCmp (pszLinuxSubsystem, "usb_device") != 0)
2127	try
2128	{
2129	pList->push_back(pszSysfsPath);
2130	}
2131	catch(std::bad_alloc &e)
2132	{
2133	rc = VERR_NO_MEMORY;
2134	}
2135	}
2136	if (dbusError.HasName(DBUS_ERROR_NO_MEMORY))
2137	rc = VERR_NO_MEMORY;
2138	if (pfSuccess != NULL)
2139	*pfSuccess = halSuccess;
2140	LogFlow(("rc=%Rrc, halSuccess=%d\n", rc, halSuccess));
2141	dbusError.FlowLog();
2142	return rc;
2143	}
2144
2145	/**
2146	* When it is registered with DBus, this function will be called by
2147	* dbus_connection_read_write_dispatch each time a message is received over the
2148	* DBus connection. We check whether that message was caused by a hal device
2149	* hotplug event, and if so we set a flag. dbus_connection_read_write_dispatch
2150	* will return after calling its filter functions, and its caller should then
2151	* check the status of the flag passed to the filter function.
2152	*
2153	* @param pConnection The DBus connection we are using.
2154	* @param pMessage The DBus message which just arrived.
2155	* @param pvUser A pointer to the flag variable we are to set.
2156	*/
2157	/* static */
2158	DBusHandlerResult dbusFilterFunction(DBusConnection * /* pConnection */,
2159	DBusMessage pMessage, void pvUser)
2160	{
2161	volatile bool pTriggered = reinterpret_cast<volatile bool >(pvUser);
2162	if ( dbus_message_is_signal(pMessage, "org.freedesktop.Hal.Manager",
2163	"DeviceAdded")
2164	\|\| dbus_message_is_signal(pMessage, "org.freedesktop.Hal.Manager",
2165	"DeviceRemoved"))
2166	{
2167	*pTriggered = true;
2168	}
2169	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2170	}
2171	#endif /* RT_OS_LINUX && VBOX_WITH_DBUS */
2172

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

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

Download in other formats: