iokit.cpp@ 6290

Last change on this file since 6290 was 5999, checked in by vboxsync, 17 years ago
The Giant CDDL Dual-License Header Change.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 46.3 KB

Line
1	/* $Id: iokit.cpp 5999 2007-12-07 15:05:06Z vboxsync $ */
2	/** @file
3	* Main - Darwin IOKit Routines.
4	*
5	* Because IOKit makes use of COM like interfaces, it does not mix very
6	* well with COM/XPCOM and must therefore be isolated from it using a
7	* simpler C interface.
8	*/
9
10	/*
11	* Copyright (C) 2006-2007 innotek GmbH
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP LOG_GROUP_MAIN
27
28	#include <mach/mach.h>
29	#include <Carbon/Carbon.h>
30	#include <IOKit/IOKitLib.h>
31	#include <IOKit/storage/IOStorageDeviceCharacteristics.h>
32	#include <IOKit/scsi-commands/SCSITaskLib.h>
33	#include <mach/mach_error.h>
34	#ifdef VBOX_WITH_USB
35	# include <IOKit/usb/IOUSBLib.h>
36	# include <IOKit/IOCFPlugIn.h>
37	#endif
38
39	#include <VBox/log.h>
40	#include <VBox/err.h>
41	#include <iprt/mem.h>
42	#include <iprt/string.h>
43	#include <iprt/process.h>
44	#include <iprt/assert.h>
45	#include <iprt/thread.h>
46
47	#include "iokit.h"
48
49
50	/*******************************************************************************
51	* Defined Constants And Macros *
52	*******************************************************************************/
53	/** An attempt at catching reference leaks. */
54	#define MY_CHECK_CREFS(cRefs) do { AssertMsg(cRefs < 25, ("%ld\n", cRefs)); NOREF(cRefs); } while (0)
55
56	/** Contains the pid of the current client. If 0, the kernel is the current client. */
57	#define VBOXUSB_CLIENT_KEY "VBoxUSB-Client"
58	/** Contains the pid of the filter owner (i.e. the VBoxSVC pid). */
59	#define VBOXUSB_OWNER_KEY "VBoxUSB-Owner"
60	/** The VBoxUSBDevice class name. */
61	#define VBOXUSBDEVICE_CLASS_NAME "org_virtualbox_VBoxUSBDevice"
62
63
64	/*******************************************************************************
65	* Global Variables *
66	*******************************************************************************/
67	/** The IO Master Port. */
68	static mach_port_t g_MasterPort = NULL;
69
70
71	/**
72	* Lazily opens the master port.
73	*
74	* @returns true if the port is open, false on failure (very unlikely).
75	*/
76	static bool darwinOpenMasterPort(void)
77	{
78	if (!g_MasterPort)
79	{
80	kern_return_t krc = IOMasterPort(MACH_PORT_NULL, &g_MasterPort);
81	AssertReturn(krc == KERN_SUCCESS, false);
82	}
83	return true;
84	}
85
86
87	#ifdef VBOX_WITH_USB
88
89	/**
90	* Gets an unsigned 8-bit integer value.
91	*
92	* @returns Success indicator (true/false).
93	* @param DictRef The dictionary.
94	* @param KeyStrRef The key name.
95	* @param pu8 Where to store the key value.
96	*/
97	static bool darwinDictGetU8(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint8_t *pu8)
98	{
99	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
100	if (ValRef)
101	{
102	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt8Type, pu8))
103	return true;
104	}
105	*pu8 = 0;
106	return false;
107	}
108
109
110	/**
111	* Gets an unsigned 16-bit integer value.
112	*
113	* @returns Success indicator (true/false).
114	* @param DictRef The dictionary.
115	* @param KeyStrRef The key name.
116	* @param pu16 Where to store the key value.
117	*/
118	static bool darwinDictGetU16(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint16_t *pu16)
119	{
120	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
121	if (ValRef)
122	{
123	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt16Type, pu16))
124	return true;
125	}
126	*pu16 = 0;
127	return false;
128	}
129
130
131	/**
132	* Gets an unsigned 32-bit integer value.
133	*
134	* @returns Success indicator (true/false).
135	* @param DictRef The dictionary.
136	* @param KeyStrRef The key name.
137	* @param pu32 Where to store the key value.
138	*/
139	static bool darwinDictGetU32(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint32_t *pu32)
140	{
141	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
142	if (ValRef)
143	{
144	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt32Type, pu32))
145	return true;
146	}
147	*pu32 = 0;
148	return false;
149	}
150
151
152	/**
153	* Gets an unsigned 64-bit integer value.
154	*
155	* @returns Success indicator (true/false).
156	* @param DictRef The dictionary.
157	* @param KeyStrRef The key name.
158	* @param pu64 Where to store the key value.
159	*/
160	static bool darwinDictGetU64(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint64_t *pu64)
161	{
162	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
163	if (ValRef)
164	{
165	if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt64Type, pu64))
166	return true;
167	}
168	*pu64 = 0;
169	return false;
170	}
171
172
173	/**
174	* Gets a RTPROCESS value.
175	*
176	* @returns Success indicator (true/false).
177	* @param DictRef The dictionary.
178	* @param KeyStrRef The key name.
179	* @param pProcess Where to store the key value.
180	*/
181	static bool darwinDictGetProccess(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, PRTPROCESS pProcess)
182	{
183	switch (sizeof(*pProcess))
184	{
185	case sizeof(uint16_t): return darwinDictGetU16(DictRef, KeyStrRef, (uint16_t *)pProcess);
186	case sizeof(uint32_t): return darwinDictGetU32(DictRef, KeyStrRef, (uint32_t *)pProcess);
187	case sizeof(uint64_t): return darwinDictGetU64(DictRef, KeyStrRef, (uint64_t *)pProcess);
188	default:
189	AssertMsgFailedReturn(("%d\n", sizeof(*pProcess)), false);
190	}
191	}
192
193
194	/**
195	* Gets string value, converted to UTF-8 and put in a IPRT string buffer.
196	*
197	* @returns Success indicator (true/false).
198	* @param DictRef The dictionary.
199	* @param KeyStrRef The key name.
200	* @param ppsz Where to store the key value. Free with RTStrFree. Set to NULL on failure.
201	*/
202	static bool darwinDictGetString(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, char **ppsz)
203	{
204	CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef);
205	if (ValRef)
206	{
207	char szBuf[512];
208	if (CFStringGetCString((CFStringRef)ValRef, szBuf, sizeof(szBuf), kCFStringEncodingUTF8))
209	{
210	*ppsz = RTStrDup(RTStrStrip(szBuf));
211	if (*ppsz)
212	return true;
213	}
214	}
215	*ppsz = NULL;
216	return false;
217	}
218
219
220	#if 1 /* dumping disabled */
221	# define DARWIN_IOKIT_LOG(a) Log(a)
222	# define DARWIN_IOKIT_LOG_FLUSH() do {} while (0)
223	# define DARWIN_IOKIT_DUMP_OBJ(o) do {} while (0)
224	#else
225	# if 0
226	# include <iprt/stream.h>
227	# define DARWIN_IOKIT_LOG(a) RTPrintf a
228	# define DARWIN_IOKIT_LOG_FLUSH() RTStrmFlush(g_pStdOut)
229	# else
230	# define DARWIN_IOKIT_LOG(a) RTLogPrintf a
231	# define DARWIN_IOKIT_LOG(a) RTLogFlush()
232	# endif
233	# define DARWIN_IOKIT_DUMP_OBJ(o) darwinDumpObj(o)
234
235	/**
236	* Callback for dumping a dictionary key.
237	*
238	* @param pvKey The key name.
239	* @param pvValue The key value
240	* @param pvUser The recursion depth.
241	*/
242	static void darwinDumpDictCallback(const void pvKey, const void pvValue, void *pvUser)
243	{
244	/* display the key name. */
245	char pszKey = (char )RTMemTmpAlloc(1024);
246	if (!CFStringGetCString((CFStringRef)pvKey, pszKey, 1024, kCFStringEncodingUTF8))
247	strcpy(pszKey, "CFStringGetCString failure");
248	DARWIN_IOKIT_LOG(("%+*s%s", (int)(uintptr_t)pvUser, "", pszKey));
249	RTMemTmpFree(pszKey);
250
251	/* display the value type */
252	CFTypeID Type = CFGetTypeID(pvValue);
253	DARWIN_IOKIT_LOG((" [%d-", Type));
254
255	/* display the value */
256	if (Type == CFDictionaryGetTypeID())
257	{
258	DARWIN_IOKIT_LOG(("dictionary] =\n"
259	"%-*s{\n", (int)(uintptr_t)pvUser, ""));
260	CFDictionaryApplyFunction((CFDictionaryRef)pvValue, darwinDumpDictCallback, (void *)((uintptr_t)pvUser + 4));
261	DARWIN_IOKIT_LOG(("%-*s}\n", (int)(uintptr_t)pvUser, ""));
262	}
263	else if (Type == CFNumberGetTypeID())
264	{
265	union
266	{
267	SInt8 s8;
268	SInt16 s16;
269	SInt32 s32;
270	SInt64 s64;
271	Float32 rf32;
272	Float64 rd64;
273	char ch;
274	short s;
275	int i;
276	long l;
277	long long ll;
278	float rf;
279	double rd;
280	CFIndex iCF;
281	} u;
282	memset(&u, 0, sizeof(u));
283	CFNumberType NumType = CFNumberGetType((CFNumberRef)pvValue);
284	if (CFNumberGetValue((CFNumberRef)pvValue, NumType, &u))
285	{
286	switch (CFNumberGetType((CFNumberRef)pvValue))
287	{
288	case kCFNumberSInt8Type: DARWIN_IOKIT_LOG(("SInt8] = %RI8 (%#RX8)\n", NumType, u.s8, u.s8)); break;
289	case kCFNumberSInt16Type: DARWIN_IOKIT_LOG(("SInt16] = %RI16 (%#RX16)\n", NumType, u.s16, u.s16)); break;
290	case kCFNumberSInt32Type: DARWIN_IOKIT_LOG(("SInt32] = %RI32 (%#RX32)\n", NumType, u.s32, u.s32)); break;
291	case kCFNumberSInt64Type: DARWIN_IOKIT_LOG(("SInt64] = %RI64 (%#RX64)\n", NumType, u.s64, u.s64)); break;
292	case kCFNumberFloat32Type: DARWIN_IOKIT_LOG(("float32] = %#lx\n", NumType, u.l)); break;
293	case kCFNumberFloat64Type: DARWIN_IOKIT_LOG(("float64] = %#llx\n", NumType, u.ll)); break;
294	case kCFNumberFloatType: DARWIN_IOKIT_LOG(("float] = %#lx\n", NumType, u.l)); break;
295	case kCFNumberDoubleType: DARWIN_IOKIT_LOG(("double] = %#llx\n", NumType, u.ll)); break;
296	case kCFNumberCharType: DARWIN_IOKIT_LOG(("char] = %hhd (%hhx)\n", NumType, u.ch, u.ch)); break;
297	case kCFNumberShortType: DARWIN_IOKIT_LOG(("short] = %hd (%hx)\n", NumType, u.s, u.s)); break;
298	case kCFNumberIntType: DARWIN_IOKIT_LOG(("int] = %d (%#x)\n", NumType, u.i, u.i)); break;
299	case kCFNumberLongType: DARWIN_IOKIT_LOG(("long] = %ld (%#lx)\n", NumType, u.l, u.l)); break;
300	case kCFNumberLongLongType: DARWIN_IOKIT_LOG(("long long] = %lld (%#llx)\n", NumType, u.ll, u.ll)); break;
301	case kCFNumberCFIndexType: DARWIN_IOKIT_LOG(("CFIndex] = %lld (%#llx)\n", NumType, (long long)u.iCF, (long long)u.iCF)); break;
302	break;
303	default: DARWIN_IOKIT_LOG(("%d?] = %lld (%llx)\n", NumType, u.ll, u.ll)); break;
304	}
305	}
306	else
307	DARWIN_IOKIT_LOG(("number] = CFNumberGetValue failed\n"));
308	}
309	else if (Type == CFBooleanGetTypeID())
310	DARWIN_IOKIT_LOG(("boolean] = %RTbool\n", CFBooleanGetValue((CFBooleanRef)pvValue)));
311	else if (Type == CFStringGetTypeID())
312	{
313	DARWIN_IOKIT_LOG(("string] = "));
314	char pszValue = (char )RTMemTmpAlloc(16*_1K);
315	if (!CFStringGetCString((CFStringRef)pvValue, pszValue, 16*_1K, kCFStringEncodingUTF8))
316	strcpy(pszValue, "CFStringGetCString failure");
317	DARWIN_IOKIT_LOG(("\"%s\"\n", pszValue));
318	RTMemTmpFree(pszValue);
319	}
320	else
321	DARWIN_IOKIT_LOG(("??] = %p\n", pvValue));
322	}
323
324
325	/**
326	* Dumps a dictionary to the log.
327	*
328	* @param DictRef The dictionary to dump.
329	*/
330	static void darwinDumpDict(CFMutableDictionaryRef DictRef, unsigned cIndents)
331	{
332	CFDictionaryApplyFunction(DictRef, darwinDumpDictCallback, (void *)(uintptr_t)cIndents);
333	DARWIN_IOKIT_LOG_FLUSH();
334	}
335
336
337	/**
338	* Dumps an I/O kit registry object and all it children.
339	* @param Object The object to dump.
340	* @param cIndents The number of indents to use.
341	*/
342	static void darwinDumpObjInt(io_object_t Object, unsigned cIndents)
343	{
344	static io_string_t s_szPath;
345	kern_return_t krc = IORegistryEntryGetPath(Object, kIOServicePlane, s_szPath);
346	if (krc != KERN_SUCCESS)
347	strcpy(s_szPath, "IORegistryEntryGetPath failed");
348	DARWIN_IOKIT_LOG(("Dumping %p - %s:\n", (const void *)Object, s_szPath));
349
350	CFMutableDictionaryRef PropsRef = 0;
351	krc = IORegistryEntryCreateCFProperties(Object, &PropsRef, kCFAllocatorDefault, kNilOptions);
352	if (krc == KERN_SUCCESS)
353	{
354	darwinDumpDict(PropsRef, cIndents + 4);
355	CFRelease(PropsRef);
356	}
357
358	/*
359	* Children.
360	*/
361	io_iterator_t Children;
362	krc = IORegistryEntryGetChildIterator(Object, kIOServicePlane, &Children);
363	if (krc == KERN_SUCCESS)
364	{
365	io_object_t Child;
366	while ((Child = IOIteratorNext(Children)))
367	{
368	darwinDumpObjInt(Child, cIndents + 4);
369	IOObjectRelease(Child);
370	}
371	IOObjectRelease(Children);
372	}
373	else
374	DARWIN_IOKIT_LOG(("IORegistryEntryGetChildIterator -> %#x\n", krc));
375	}
376
377	/**
378	* Dumps an I/O kit registry object and all it children.
379	* @param Object The object to dump.
380	*/
381	static void darwinDumpObj(io_object_t Object)
382	{
383	darwinDumpObjInt(Object, 0);
384	}
385
386	#endif
387
388
389	/**
390	* Notification data created by DarwinSubscribeUSBNotifications, used by
391	* the callbacks and finally freed by DarwinUnsubscribeUSBNotifications.
392	*/
393	typedef struct DARWINUSBNOTIFY
394	{
395	/** The notification port.
396	* It's shared between the notification callbacks. */
397	IONotificationPortRef NotifyPort;
398	/** The run loop source for NotifyPort. */
399	CFRunLoopSourceRef NotifyRLSrc;
400	/** The attach notification iterator. */
401	io_iterator_t AttachIterator;
402	/** The 2nd attach notification iterator. */
403	io_iterator_t AttachIterator2;
404	/** The detach notificaiton iterator. */
405	io_iterator_t DetachIterator;
406	} DARWINUSBNOTIFY, *PDARWINUSBNOTIFY;
407
408
409	/**
410	* Run thru an interrator.
411	*
412	* The docs says this is necessary to start getting notifications,
413	* so this function is called in the callbacks and right after
414	* registering the notification.
415	*
416	* @param pIterator The iterator reference.
417	*/
418	static void darwinDrainIterator(io_iterator_t pIterator)
419	{
420	io_object_t Object;
421	while ((Object = IOIteratorNext(pIterator)))
422	{
423	DARWIN_IOKIT_DUMP_OBJ(Object);
424	IOObjectRelease(Object);
425	}
426	}
427
428
429	/**
430	* Callback for the 1st attach notification.
431	*
432	* @param pvNotify Our data.
433	* @param NotifyIterator The notification iterator.
434	*/
435	static void darwinUSBAttachNotification1(void *pvNotify, io_iterator_t NotifyIterator)
436	{
437	DARWIN_IOKIT_LOG(("USB Attach Notification1\n"));
438	NOREF(pvNotify); //PDARWINUSBNOTIFY pNotify = (PDARWINUSBNOTIFY)pvNotify;
439	darwinDrainIterator(NotifyIterator);
440	}
441
442
443	/**
444	* Callback for the 2nd attach notification.
445	*
446	* @param pvNotify Our data.
447	* @param NotifyIterator The notification iterator.
448	*/
449	static void darwinUSBAttachNotification2(void *pvNotify, io_iterator_t NotifyIterator)
450	{
451	DARWIN_IOKIT_LOG(("USB Attach Notification2\n"));
452	NOREF(pvNotify); //PDARWINUSBNOTIFY pNotify = (PDARWINUSBNOTIFY)pvNotify;
453	darwinDrainIterator(NotifyIterator);
454	}
455
456
457	/**
458	* Callback for the detach notifications.
459	*
460	* @param pvNotify Our data.
461	* @param NotifyIterator The notification iterator.
462	*/
463	static void darwinUSBDetachNotification(void *pvNotify, io_iterator_t NotifyIterator)
464	{
465	DARWIN_IOKIT_LOG(("USB Detach Notification\n"));
466	NOREF(pvNotify); //PDARWINUSBNOTIFY pNotify = (PDARWINUSBNOTIFY)pvNotify;
467	darwinDrainIterator(NotifyIterator);
468	}
469
470
471	/**
472	* Subscribes the run loop to USB notification events relevant to
473	* device attach/detach.
474	*
475	* The source mode for these events is defined as VBOX_IOKIT_MODE_STRING
476	* so that the caller can listen to events from this mode only and
477	* re-evalutate the list of attached devices whenever an event arrives.
478	*
479	* @returns opaque for passing to the unsubscribe function. If NULL
480	* something unexpectedly failed during subscription.
481	*/
482	void *DarwinSubscribeUSBNotifications(void)
483	{
484	AssertReturn(darwinOpenMasterPort(), NULL);
485
486	PDARWINUSBNOTIFY pNotify = (PDARWINUSBNOTIFY)RTMemAllocZ(sizeof(*pNotify));
487	AssertReturn(pNotify, NULL);
488
489	/*
490	* Create the notification port, bake it into a runloop source which we
491	* then add to our run loop.
492	*/
493	pNotify->NotifyPort = IONotificationPortCreate(g_MasterPort);
494	Assert(pNotify->NotifyPort);
495	if (pNotify->NotifyPort)
496	{
497	pNotify->NotifyRLSrc = IONotificationPortGetRunLoopSource(pNotify->NotifyPort);
498	Assert(pNotify->NotifyRLSrc);
499	if (pNotify->NotifyRLSrc)
500	{
501	CFRunLoopAddSource(CFRunLoopGetCurrent(), pNotify->NotifyRLSrc, CFSTR(VBOX_IOKIT_MODE_STRING));
502
503	/*
504	* Create the notifcation callbacks.
505	*/
506	kern_return_t rc = IOServiceAddMatchingNotification(pNotify->NotifyPort,
507	kIOPublishNotification,
508	IOServiceMatching(kIOUSBDeviceClassName),
509	darwinUSBAttachNotification1,
510	pNotify,
511	&pNotify->AttachIterator);
512	if (rc == KERN_SUCCESS)
513	{
514	darwinDrainIterator(pNotify->AttachIterator);
515	rc = IOServiceAddMatchingNotification(pNotify->NotifyPort,
516	kIOMatchedNotification,
517	IOServiceMatching(kIOUSBDeviceClassName),
518	darwinUSBAttachNotification2,
519	pNotify,
520	&pNotify->AttachIterator2);
521	if (rc == KERN_SUCCESS)
522	{
523	darwinDrainIterator(pNotify->AttachIterator2);
524	rc = IOServiceAddMatchingNotification(pNotify->NotifyPort,
525	kIOTerminatedNotification,
526	IOServiceMatching(kIOUSBDeviceClassName),
527	darwinUSBDetachNotification,
528	pNotify,
529	&pNotify->DetachIterator);
530	{
531	darwinDrainIterator(pNotify->DetachIterator);
532	return pNotify;
533	}
534	IOObjectRelease(pNotify->AttachIterator2);
535	}
536	IOObjectRelease(pNotify->AttachIterator);
537	}
538	CFRunLoopRemoveSource(CFRunLoopGetCurrent(), pNotify->NotifyRLSrc, CFSTR(VBOX_IOKIT_MODE_STRING));
539	}
540	IONotificationPortDestroy(pNotify->NotifyPort);
541	}
542
543	RTMemFree(pNotify);
544	return NULL;
545	}
546
547
548	/**
549	* Unsubscribe the run loop from USB notification subscribed to
550	* by DarwinSubscribeUSBNotifications.
551	*
552	* @param pvOpaque The return value from DarwinSubscribeUSBNotifications.
553	*/
554	void DarwinUnsubscribeUSBNotifications(void *pvOpaque)
555	{
556	PDARWINUSBNOTIFY pNotify = (PDARWINUSBNOTIFY)pvOpaque;
557	if (!pNotify)
558	return;
559
560	IOObjectRelease(pNotify->AttachIterator);
561	pNotify->AttachIterator = NULL;
562	IOObjectRelease(pNotify->AttachIterator2);
563	pNotify->AttachIterator2 = NULL;
564	IOObjectRelease(pNotify->DetachIterator);
565	pNotify->DetachIterator = NULL;
566
567	CFRunLoopRemoveSource(CFRunLoopGetCurrent(), pNotify->NotifyRLSrc, CFSTR(VBOX_IOKIT_MODE_STRING));
568	IONotificationPortDestroy(pNotify->NotifyPort);
569	pNotify->NotifyRLSrc = NULL;
570	pNotify->NotifyPort = NULL;
571
572	RTMemFree(pNotify);
573	}
574
575
576	/**
577	* Decends recursivly into a IORegistry tree locating the first object of a given class.
578	*
579	* The search is performed depth first.
580	*
581	* @returns Object reference if found, NULL if not.
582	* @param Object The current tree root.
583	* @param pszClass The name of the class we're looking for.
584	* @param pszNameBuf A scratch buffer for query the class name in to avoid
585	* wasting 128 bytes on an io_name_t object for every recursion.
586	*/
587	static io_object_t darwinFindObjectByClass(io_object_t Object, const char *pszClass, io_name_t pszNameBuf)
588	{
589	io_iterator_t Children;
590	kern_return_t krc = IORegistryEntryGetChildIterator(Object, kIOServicePlane, &Children);
591	if (krc != KERN_SUCCESS)
592	return NULL;
593	io_object_t Child;
594	while ((Child = IOIteratorNext(Children)))
595	{
596	krc = IOObjectGetClass(Child, pszNameBuf);
597	if ( krc == KERN_SUCCESS
598	&& !strcmp(pszNameBuf, pszClass))
599	break;
600
601	io_object_t GrandChild = darwinFindObjectByClass(Child, pszClass, pszNameBuf);
602	IOObjectRelease(Child);
603	if (GrandChild)
604	{
605	Child = GrandChild;
606	break;
607	}
608	}
609	IOObjectRelease(Children);
610	return Child;
611	}
612
613
614	/**
615	* Decends recursivly into IOUSBMassStorageClass tree to check whether
616	* the MSD is mounted or not.
617	*
618	* The current heuristic is to look for the IOMedia class.
619	*
620	* @returns true if mounted, false if not.
621	* @param MSDObj The IOUSBMassStorageClass object.
622	* @param pszNameBuf A scratch buffer for query the class name in to avoid
623	* wasting 128 bytes on an io_name_t object for every recursion.
624	*/
625	static bool darwinIsMassStorageInterfaceInUse(io_object_t MSDObj, io_name_t pszNameBuf)
626	{
627	io_object_t MediaObj = darwinFindObjectByClass(MSDObj, "IOMedia", pszNameBuf);
628	if (MediaObj)
629	{
630	/* more checks? */
631	IOObjectRelease(MediaObj);
632	return true;
633	}
634	return false;
635	}
636
637
638	/**
639	* Worker function for DarwinGetUSBDevices() that tries to figure out
640	* what state the device is in.
641	*
642	* This is mostly a matter of distinguishing between devices that nobody
643	* uses, devices that can be seized and devices that cannot be grabbed.
644	*
645	* @param pCur The USB device data.
646	* @param USBDevice The USB device object.
647	* @param PropsRef The USB device properties.
648	*/
649	static void darwinDeterminUSBDeviceState(PUSBDEVICE pCur, io_object_t USBDevice, CFMutableDictionaryRef PropsRef)
650	{
651	/*
652	* Iterate the interfaces (among the children of the IOUSBDevice object).
653	*/
654	io_iterator_t Interfaces;
655	kern_return_t krc = IORegistryEntryGetChildIterator(USBDevice, kIOServicePlane, &Interfaces);
656	if (krc != KERN_SUCCESS)
657	return;
658
659	RTPROCESS Owner = NIL_RTPROCESS;
660	RTPROCESS Client = NIL_RTPROCESS;
661	bool fUserClientOnly = true;
662	bool fConfigured = false;
663	bool fInUse = false;
664	bool fSeizable = true;
665	io_object_t Interface;
666	while ((Interface = IOIteratorNext(Interfaces)))
667	{
668	io_name_t szName;
669	krc = IOObjectGetClass(Interface, szName);
670	if ( krc == KERN_SUCCESS
671	&& !strcmp(szName, "IOUSBInterface"))
672	{
673	fConfigured = true;
674
675	/*
676	* Iterate the interface children looking for stuff other than
677	* IOUSBUserClientInit objects.
678	*/
679	io_iterator_t Children1;
680	krc = IORegistryEntryGetChildIterator(Interface, kIOServicePlane, &Children1);
681	if (krc == KERN_SUCCESS)
682	{
683	io_object_t Child1;
684	while ((Child1 = IOIteratorNext(Children1)))
685	{
686	krc = IOObjectGetClass(Child1, szName);
687	if ( krc == KERN_SUCCESS
688	&& strcmp(szName, "IOUSBUserClientInit"))
689	{
690	fUserClientOnly = false;
691
692	if (!strcmp(szName, "IOUSBMassStorageClass"))
693	{
694	/* Only permit capturing MSDs that aren't mounted, at least
695	until the GUI starts poping up warnings about data loss
696	and such when capturing a busy device. */
697	fSeizable = false;
698	fInUse \|= darwinIsMassStorageInterfaceInUse(Child1, szName);
699	}
700	else if (!strcmp(szName, "IOUSBHIDDriver")
701	\|\| !strcmp(szName, "AppleHIDMouse")
702	/** @todo more? */)
703	{
704	/* For now, just assume that all HID devices are inaccessible
705	because of the greedy HID service. */
706	fSeizable = false;
707	fInUse = true;
708	}
709	else
710	fInUse = true;
711	}
712	IOObjectRelease(Child1);
713	}
714	IOObjectRelease(Children1);
715	}
716	}
717	/*
718	* Not an interface, could it be VBoxUSBDevice?
719	* If it is, get the owner and client properties.
720	*/
721	else if ( krc == KERN_SUCCESS
722	&& !strcmp(szName, VBOXUSBDEVICE_CLASS_NAME))
723	{
724	CFMutableDictionaryRef PropsRef = 0;
725	krc = IORegistryEntryCreateCFProperties(Interface, &PropsRef, kCFAllocatorDefault, kNilOptions);
726	if (krc == KERN_SUCCESS)
727	{
728	darwinDictGetProccess(PropsRef, CFSTR(VBOXUSB_OWNER_KEY), &Owner);
729	darwinDictGetProccess(PropsRef, CFSTR(VBOXUSB_CLIENT_KEY), &Client);
730	CFRelease(PropsRef);
731	}
732	}
733
734	IOObjectRelease(Interface);
735	}
736	IOObjectRelease(Interfaces);
737
738	/*
739	* Calc the status.
740	*/
741	if ( Owner != NIL_RTPROCESS
742	&& !Owner)
743	{
744	if (Owner == RTProcSelf())
745	pCur->enmState = Client == NIL_RTPROCESS \|\| !Client
746	? USBDEVICESTATE_HELD_BY_PROXY
747	: USBDEVICESTATE_USED_BY_GUEST;
748	else
749	pCur->enmState = USBDEVICESTATE_USED_BY_HOST;
750	}
751	else if (fUserClientOnly)
752	/** @todo how to detect other user client?!? - Look for IOUSBUserClient! */
753	pCur->enmState = !fConfigured
754	? USBDEVICESTATE_UNUSED
755	: USBDEVICESTATE_USED_BY_HOST_CAPTURABLE;
756	else if (!fInUse)
757	pCur->enmState = USBDEVICESTATE_UNUSED;
758	else
759	pCur->enmState = fSeizable
760	? USBDEVICESTATE_USED_BY_HOST_CAPTURABLE
761	: USBDEVICESTATE_USED_BY_HOST;
762	}
763
764
765	/**
766	* Enumerate the USB devices returning a FIFO of them.
767	*
768	* @returns Pointer to the head.
769	* USBProxyService::freeDevice is expected to free each of the list elements.
770	*/
771	PUSBDEVICE DarwinGetUSBDevices(void)
772	{
773	AssertReturn(darwinOpenMasterPort(), NULL);
774	//DARWIN_IOKIT_LOG(("DarwinGetUSBDevices\n"));
775
776	/*
777	* Create a matching dictionary for searching for USB Devices in the IOKit.
778	*/
779	CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName);
780	AssertReturn(RefMatchingDict, NULL);
781
782	/*
783	* Perform the search and get a collection of USB Device back.
784	*/
785	io_iterator_t USBDevices = NULL;
786	IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
787	AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
788	RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
789
790	/*
791	* Enumerate the USB Devices.
792	*/
793	PUSBDEVICE pHead = NULL;
794	PUSBDEVICE pTail = NULL;
795	unsigned i = 0;
796	io_object_t USBDevice;
797	while ((USBDevice = IOIteratorNext(USBDevices)) != 0)
798	{
799	//DARWIN_IOKIT_DUMP_OBJ(USBDevice);
800
801	/*
802	* Query the device properties from the registry.
803	*
804	* We could alternatively use the device and such, but that will be
805	* slower and we would have to resort to the registry for the three
806	* string anyway.
807	*/
808	CFMutableDictionaryRef PropsRef = 0;
809	kern_return_t krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions);
810	if (krc == KERN_SUCCESS)
811	{
812	bool fOk = false;
813	PUSBDEVICE pCur = (PUSBDEVICE)RTMemAllocZ(sizeof(*pCur));
814	do /* loop for breaking out of on failure. */
815	{
816	AssertBreak(pCur,);
817
818	/*
819	* Mandatory
820	*/
821	pCur->bcdUSB = 0; /* we've no idea. */
822	pCur->enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE; /* just a default, we'll try harder in a bit. */
823
824	AssertBreak(darwinDictGetU8(PropsRef, CFSTR(kUSBDeviceClass), &pCur->bDeviceClass),);
825	/* skip hubs */
826	if (pCur->bDeviceClass == 0x09 /* hub, find a define! */)
827	break;
828	AssertBreak(darwinDictGetU8(PropsRef, CFSTR(kUSBDeviceSubClass), &pCur->bDeviceSubClass),);
829	AssertBreak(darwinDictGetU8(PropsRef, CFSTR(kUSBDeviceProtocol), &pCur->bDeviceProtocol),);
830	AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBVendorID), &pCur->idVendor),);
831	AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBProductID), &pCur->idProduct),);
832	AssertBreak(darwinDictGetU16(PropsRef, CFSTR(kUSBDeviceReleaseNumber), &pCur->bcdDevice),);
833	uint32_t u32LocationId;
834	AssertBreak(darwinDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32LocationId),);
835	uint64_t u64SessionId;
836	AssertBreak(darwinDictGetU64(PropsRef, CFSTR("sessionID"), &u64SessionId),);
837	char szAddress[64];
838	RTStrPrintf(szAddress, sizeof(szAddress), "p=0x%04RX16;v=0x%04RX16;s=0x%016RX64;l=0x%08RX32",
839	pCur->idProduct, pCur->idVendor, u64SessionId, u32LocationId);
840	pCur->pszAddress = RTStrDup(szAddress);
841	AssertBreak(pCur->pszAddress,);
842
843	/*
844	* Optional.
845	* There are some nameless device in the iMac, apply names to them.
846	*/
847	darwinDictGetString(PropsRef, CFSTR("USB Vendor Name"), (char **)&pCur->pszManufacturer);
848	if ( !pCur->pszManufacturer
849	&& pCur->idVendor == kIOUSBVendorIDAppleComputer)
850	pCur->pszManufacturer = RTStrDup("Apple Computer, Inc.");
851	darwinDictGetString(PropsRef, CFSTR("USB Product Name"), (char **)&pCur->pszProduct);
852	if ( !pCur->pszProduct
853	&& pCur->bDeviceClass == 224 /* Wireless */
854	&& pCur->bDeviceSubClass == 1 /* Radio Frequency */
855	&& pCur->bDeviceProtocol == 1 /* Bluetooth */)
856	pCur->pszProduct = RTStrDup("Bluetooth");
857	darwinDictGetString(PropsRef, CFSTR("USB Serial Number"), (char **)&pCur->pszSerialNumber);
858
859	#if 0 /* leave the remainder as zero for now. */
860	/*
861	* Create a plugin interface for the service and query its USB Device interface.
862	*/
863	SInt32 Score = 0;
864	IOCFPlugInInterface **ppPlugInInterface = NULL;
865	rc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
866	kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
867	if (rc == kIOReturnSuccess)
868	{
869	IOUSBDeviceInterface245 **ppUSBDevI = NULL;
870	HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
871	CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
872	(LPVOID *)&ppUSBDevI);
873	rc = IODestroyPlugInInterface(ppPlugInInterface); Assert(rc == kIOReturnSuccess);
874	ppPlugInInterface = NULL;
875	if (hrc == S_OK)
876	{
877	/** @todo enumerate configurations and interfaces if we actually need them. */
878	//IOReturn (GetNumberOfConfigurations)(void self, UInt8 *numConfig);
879	//IOReturn (GetConfigurationDescriptorPtr)(void self, UInt8 configIndex, IOUSBConfigurationDescriptorPtr *desc);
880	//IOReturn (CreateInterfaceIterator)(void self, IOUSBFindInterfaceRequest req, io_iterator_t iter);
881	}
882	long cReft = (*ppUSBDeviceInterface)->Release(ppUSBDeviceInterface); MY_CHECK_CREFS(cRefs);
883	}
884	#endif
885	/*
886	* Try determin the state.
887	*/
888	darwinDeterminUSBDeviceState(pCur, USBDevice, PropsRef);
889
890	/*
891	* We're good. Link the device.
892	*/
893	pCur->pPrev = pTail;
894	if (pTail)
895	pTail = pTail->pNext = pCur;
896	else
897	pTail = pHead = pCur;
898	fOk = true;
899	} while (0);
900
901	/* cleanup on failure / skipped device. */
902	if (!fOk && pCur)
903	DarwinFreeUSBDeviceFromIOKit(pCur);
904
905	CFRelease(PropsRef);
906	}
907	else
908	AssertMsgFailed(("krc=%#x\n", krc));
909
910	IOObjectRelease(USBDevice);
911	i++;
912	}
913
914	IOObjectRelease(USBDevices);
915	//DARWIN_IOKIT_LOG_FLUSH();
916
917	/*
918	* Some post processing. There are a couple of things we have to
919	* make 100% sure about, and that is that the (Apple) keyboard
920	* and mouse most likely to be in use by the user aren't available
921	* for capturing. If there is no Apple mouse or keyboard we'll
922	* take the first one from another vendor.
923	*/
924	/* As it turns out, the HID service will take all keyboards and mice
925	and we're not currently able to seize them. */
926	PUSBDEVICE pMouse = NULL;
927	PUSBDEVICE pKeyboard = NULL;
928	for (PUSBDEVICE pCur = pHead; pCur; pCur = pCur->pNext)
929	if (pCur->idVendor == kIOUSBVendorIDAppleComputer)
930	{
931	/*
932	* This test is a bit rough, should check device class/protocol but
933	* we don't have interface info yet so that might be a bit tricky.
934	*/
935	if ( ( !pKeyboard
936	\|\| pKeyboard->idVendor != kIOUSBVendorIDAppleComputer)
937	&& pCur->pszProduct
938	&& strstr(pCur->pszProduct, " Keyboard"))
939	pKeyboard = pCur;
940	else if ( ( !pMouse
941	\|\| pMouse->idVendor != kIOUSBVendorIDAppleComputer)
942	&& pCur->pszProduct
943	&& strstr(pCur->pszProduct, " Mouse")
944	)
945	pMouse = pCur;
946	}
947	else if (!pKeyboard \|\| !pMouse)
948	{
949	if ( pCur->bDeviceClass == 3 /* HID */
950	&& pCur->bDeviceProtocol == 1 /* Keyboard */)
951	pKeyboard = pCur;
952	else if ( pCur->bDeviceClass == 3 /* HID */
953	&& pCur->bDeviceProtocol == 2 /* Mouse */)
954	pMouse = pCur;
955	/** @todo examin interfaces */
956	}
957
958	if (pKeyboard)
959	pKeyboard->enmState = USBDEVICESTATE_USED_BY_HOST;
960	if (pMouse)
961	pMouse->enmState = USBDEVICESTATE_USED_BY_HOST;
962
963	return pHead;
964	}
965
966
967	/**
968	* Triggers re-enumeration of a device.
969	*
970	* @returns VBox status code.
971	* @param pCur The USBDEVICE structure for the device.
972	*/
973	int DarwinReEnumerateUSBDevice(PCUSBDEVICE pCur)
974	{
975	int vrc;
976	const char *pszAddress = pCur->pszAddress;
977	AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
978	AssertReturn(darwinOpenMasterPort(), VERR_GENERAL_FAILURE);
979
980	/*
981	* This code is a short version of the Open method in USBProxyDevice-darwin.cpp stuff.
982	* Fixes made to this code probably applies there too!
983	*/
984
985	CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName);
986	AssertReturn(RefMatchingDict, NULL);
987
988	uint64_t u64SessionId = 0;
989	uint32_t u32LocationId = 0;
990	const char *psz = pszAddress;
991	do
992	{
993	const char chValue = *psz;
994	AssertReleaseReturn(psz[1] == '=', VERR_INTERNAL_ERROR);
995	uint64_t u64Value;
996	int rc = RTStrToUInt64Ex(psz + 2, (char **)&psz, 0, &u64Value);
997	AssertReleaseRCReturn(rc, rc);
998	AssertReleaseReturn(!psz \|\| psz == ';', rc);
999	switch (chValue)
1000	{
1001	case 'l':
1002	u32LocationId = (uint32_t)u64Value;
1003	break;
1004	case 's':
1005	u64SessionId = u64Value;
1006	break;
1007	case 'p':
1008	case 'v':
1009	{
1010	#if 0 /* Guess what, this doesn't 'ing work either! */
1011	SInt32 i32 = (int16_t)u64Value;
1012	CFNumberRef Num = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &i32);
1013	AssertBreak(Num,);
1014	CFDictionarySetValue(RefMatchingDict, chValue == 'p' ? CFSTR(kUSBProductID) : CFSTR(kUSBVendorID), Num);
1015	CFRelease(Num);
1016	#endif
1017	break;
1018	}
1019	default:
1020	AssertReleaseMsgFailedReturn(("chValue=%#x\n", chValue), VERR_INTERNAL_ERROR);
1021	}
1022	if (*psz == ';')
1023	psz++;
1024	} while (*psz);
1025
1026	io_iterator_t USBDevices = NULL;
1027	IOReturn irc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &USBDevices);
1028	AssertMsgReturn(irc == kIOReturnSuccess, ("irc=%#x\n", irc), NULL);
1029	RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
1030
1031	unsigned cMatches = 0;
1032	io_object_t USBDevice;
1033	while ((USBDevice = IOIteratorNext(USBDevices)))
1034	{
1035	cMatches++;
1036	CFMutableDictionaryRef PropsRef = 0;
1037	kern_return_t krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions);
1038	if (krc == KERN_SUCCESS)
1039	{
1040	uint64_t u64CurSessionId;
1041	uint32_t u32CurLocationId;
1042	if ( ( !u64SessionId
1043	\|\| ( darwinDictGetU64(PropsRef, CFSTR("sessionID"), &u64CurSessionId)
1044	&& u64CurSessionId == u64SessionId))
1045	&& ( !u32LocationId
1046	\|\| ( darwinDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32CurLocationId)
1047	&& u32CurLocationId == u32LocationId))
1048	)
1049	{
1050	CFRelease(PropsRef);
1051	break;
1052	}
1053	CFRelease(PropsRef);
1054	}
1055	IOObjectRelease(USBDevice);
1056	}
1057	IOObjectRelease(USBDevices);
1058	USBDevices = NULL;
1059	if (!USBDevice)
1060	{
1061	LogRel(("USB: Device '%s' not found (%d pid+vid matches)\n", pszAddress, cMatches));
1062	IOObjectRelease(USBDevices);
1063	return VERR_VUSB_DEVICE_NAME_NOT_FOUND;
1064	}
1065
1066	/*
1067	* Create a plugin interface for the device and query its IOUSBDeviceInterface.
1068	*/
1069	SInt32 Score = 0;
1070	IOCFPlugInInterface **ppPlugInInterface = NULL;
1071	irc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID,
1072	kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score);
1073	if (irc == kIOReturnSuccess)
1074	{
1075	IOUSBDeviceInterface245 **ppDevI = NULL;
1076	HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
1077	CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245),
1078	(LPVOID *)&ppDevI);
1079	irc = IODestroyPlugInInterface(ppPlugInInterface); Assert(irc == kIOReturnSuccess);
1080	ppPlugInInterface = NULL;
1081	if (hrc == S_OK)
1082	{
1083	/*
1084	* Try open the device for exclusive access.
1085	*/
1086	irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
1087	if (irc == kIOReturnExclusiveAccess)
1088	{
1089	RTThreadSleep(20);
1090	irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI);
1091	}
1092	if (irc == kIOReturnSuccess)
1093	{
1094	/*
1095	* Re-enumerate the device and bail out.
1096	*/
1097	irc = (*ppDevI)->USBDeviceReEnumerate(ppDevI, 0);
1098	if (irc != kIOReturnSuccess)
1099	{
1100	LogRel(("USB: Failed to open device '%s', plug-in creation failed with irc=%#x.\n", pszAddress, irc));
1101	vrc = RTErrConvertFromDarwinIO(irc);
1102	}
1103
1104	(*ppDevI)->USBDeviceClose(ppDevI);
1105	}
1106	else if (irc == kIOReturnExclusiveAccess)
1107	{
1108	LogRel(("USB: Device '%s' is being used by another process\n", pszAddress));
1109	vrc = VERR_SHARING_VIOLATION;
1110	}
1111	else
1112	{
1113	LogRel(("USB: Failed to open device '%s', irc=%#x.\n", pszAddress, irc));
1114	vrc = VERR_OPEN_FAILED;
1115	}
1116	}
1117	else
1118	{
1119	LogRel(("USB: Failed to create plugin interface for device '%s', hrc=%#x.\n", pszAddress, hrc));
1120	vrc = VERR_OPEN_FAILED;
1121	}
1122
1123	(*ppDevI)->Release(ppDevI);
1124	}
1125	else
1126	{
1127	LogRel(("USB: Failed to open device '%s', plug-in creation failed with irc=%#x.\n", pszAddress, irc));
1128	vrc = RTErrConvertFromDarwinIO(irc);
1129	}
1130
1131	return vrc;
1132	}
1133
1134	#endif /* VBOX_WITH_USB */
1135
1136
1137	/**
1138	* Enumerate the DVD drives returning a FIFO of device name strings.
1139	*
1140	* @returns Pointer to the head.
1141	* The caller is responsible for calling RTMemFree() on each of the nodes.
1142	*/
1143	PDARWINDVD DarwinGetDVDDrives(void)
1144	{
1145	AssertReturn(darwinOpenMasterPort(), NULL);
1146
1147	/*
1148	* Create a matching dictionary for searching for DVD services in the IOKit.
1149	*
1150	* [If I understand this correctly, plain CDROMs doesn't show up as
1151	* IODVDServices. Too keep things simple, we will only support DVDs
1152	* until somebody complains about it and we get hardware to test it on.
1153	* (Unless I'm much mistaken, there aren't any (orignal) intel macs with
1154	* plain cdroms.)]
1155	*/
1156	CFMutableDictionaryRef RefMatchingDict = IOServiceMatching("IODVDServices");
1157	AssertReturn(RefMatchingDict, NULL);
1158
1159	/*
1160	* Perform the search and get a collection of DVD services.
1161	*/
1162	io_iterator_t DVDServices = NULL;
1163	IOReturn rc = IOServiceGetMatchingServices(g_MasterPort, RefMatchingDict, &DVDServices);
1164	AssertMsgReturn(rc == kIOReturnSuccess, ("rc=%d\n", rc), NULL);
1165	RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */
1166
1167	/*
1168	* Enumerate the DVD services.
1169	* (This enumeration must be identical to the one performed in DrvHostBase.cpp.)
1170	*/
1171	PDARWINDVD pHead = NULL;
1172	PDARWINDVD pTail = NULL;
1173	unsigned i = 0;
1174	io_object_t DVDService;
1175	while ((DVDService = IOIteratorNext(DVDServices)) != 0)
1176	{
1177	/*
1178	* Get the properties we use to identify the DVD drive.
1179	*
1180	* While there is a (weird 12 byte) GUID, it isn't persistent
1181	* accross boots. So, we have to use a combination of the
1182	* vendor name and product name properties with an optional
1183	* sequence number for identification.
1184	*/
1185	CFMutableDictionaryRef PropsRef = 0;
1186	kern_return_t krc = IORegistryEntryCreateCFProperties(DVDService, &PropsRef, kCFAllocatorDefault, kNilOptions);
1187	if (krc == KERN_SUCCESS)
1188	{
1189	/* Get the Device Characteristics dictionary. */
1190	CFDictionaryRef DevCharRef = (CFDictionaryRef)CFDictionaryGetValue(PropsRef, CFSTR(kIOPropertyDeviceCharacteristicsKey));
1191	if (DevCharRef)
1192	{
1193	/* The vendor name. */
1194	char szVendor[128];
1195	char *pszVendor = &szVendor[0];
1196	CFTypeRef ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyVendorNameKey));
1197	if ( ValueRef
1198	&& CFGetTypeID(ValueRef) == CFStringGetTypeID()
1199	&& CFStringGetCString((CFStringRef)ValueRef, szVendor, sizeof(szVendor), kCFStringEncodingUTF8))
1200	pszVendor = RTStrStrip(szVendor);
1201	else
1202	*pszVendor = '\0';
1203
1204	/* The product name. */
1205	char szProduct[128];
1206	char *pszProduct = &szProduct[0];
1207	ValueRef = CFDictionaryGetValue(DevCharRef, CFSTR(kIOPropertyProductNameKey));
1208	if ( ValueRef
1209	&& CFGetTypeID(ValueRef) == CFStringGetTypeID()
1210	&& CFStringGetCString((CFStringRef)ValueRef, szProduct, sizeof(szProduct), kCFStringEncodingUTF8))
1211	pszProduct = RTStrStrip(szProduct);
1212	else
1213	*pszProduct = '\0';
1214
1215	/* Construct the name and check for duplicates. */
1216	char szName[256 + 32];
1217	if (pszVendor \|\| pszProduct)
1218	{
1219	if (pszVendor && pszProduct)
1220	RTStrPrintf(szName, sizeof(szName), "%s %s", pszVendor, pszProduct);
1221	else
1222	strcpy(szName, *pszVendor ? pszVendor : pszProduct);
1223
1224	for (PDARWINDVD pCur = pHead; pCur; pCur = pCur->pNext)
1225	{
1226	if (!strcmp(szName, pCur->szName))
1227	{
1228	if (pszVendor && pszProduct)
1229	RTStrPrintf(szName, sizeof(szName), "%s %s (#%u)", pszVendor, pszProduct, i);
1230	else
1231	RTStrPrintf(szName, sizeof(szName), "%s %s (#%u)", *pszVendor ? pszVendor : pszProduct, i);
1232	break;
1233	}
1234	}
1235	}
1236	else
1237	RTStrPrintf(szName, sizeof(szName), "(#%u)", i);
1238
1239	/* Create the device. */
1240	size_t cbName = strlen(szName) + 1;
1241	PDARWINDVD pNew = (PDARWINDVD)RTMemAlloc(RT_OFFSETOF(DARWINDVD, szName[cbName]));
1242	if (pNew)
1243	{
1244	pNew->pNext = NULL;
1245	memcpy(pNew->szName, szName, cbName);
1246	if (pTail)
1247	pTail = pTail->pNext = pNew;
1248	else
1249	pTail = pHead = pNew;
1250	}
1251	}
1252	CFRelease(PropsRef);
1253	}
1254	else
1255	AssertMsgFailed(("krc=%#x\n", krc));
1256
1257	IOObjectRelease(DVDService);
1258	i++;
1259	}
1260
1261	IOObjectRelease(DVDServices);
1262
1263	return pHead;
1264	}
1265

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

source: vbox/trunk/src/VBox/Main/darwin/iokit.cpp@ 6290

Download in other formats: