EmulatedUSBImpl.cpp@ 75392

Last change on this file since 75392 was 73003, checked in by vboxsync, 6 years ago
Main: Use setErrorBoth when we've got a VBox status code handy. (The COM status codes aren't too specfic and this may help us decode error messages and provide an alternative to strstr for API clients. setErrorBoth isn't new, btw.)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.5 KB

Line
1	/* $Id: EmulatedUSBImpl.cpp 73003 2018-07-09 11:09:32Z vboxsync $ */
2	/** @file
3	* Emulated USB manager implementation.
4	*/
5
6	/*
7	* Copyright (C) 2013-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#define LOG_GROUP LOG_GROUP_MAIN_EMULATEDUSB
19	#include "LoggingNew.h"
20
21	#include "EmulatedUSBImpl.h"
22	#include "ConsoleImpl.h"
23
24	#include <VBox/vmm/pdmusb.h>
25
26
27	/*
28	* Emulated USB webcam device instance.
29	*/
30	typedef std::map <Utf8Str, Utf8Str> EUSBSettingsMap;
31
32	typedef enum EUSBDEVICESTATUS
33	{
34	EUSBDEVICE_CREATED,
35	EUSBDEVICE_ATTACHING,
36	EUSBDEVICE_ATTACHED
37	} EUSBDEVICESTATUS;
38
39	class EUSBWEBCAM /* : public EUSBDEVICE */
40	{
41	private:
42	int32_t volatile mcRefs;
43
44	EmulatedUSB *mpEmulatedUSB;
45
46	RTUUID mUuid;
47	char mszUuid[RTUUID_STR_LENGTH];
48
49	Utf8Str mPath;
50	Utf8Str mSettings;
51
52	EUSBSettingsMap mDevSettings;
53	EUSBSettingsMap mDrvSettings;
54
55	void *mpvObject;
56
57	static DECLCALLBACK(int) emulatedWebcamAttach(PUVM pUVM, EUSBWEBCAM pThis, const char pszDriver);
58	static DECLCALLBACK(int) emulatedWebcamDetach(PUVM pUVM, EUSBWEBCAM *pThis);
59
60	HRESULT settingsParse(void);
61
62	~EUSBWEBCAM()
63	{
64	}
65
66	public:
67	EUSBWEBCAM()
68	:
69	mcRefs(1),
70	mpEmulatedUSB(NULL),
71	mpvObject(NULL),
72	enmStatus(EUSBDEVICE_CREATED)
73	{
74	RT_ZERO(mUuid);
75	RT_ZERO(mszUuid);
76	}
77
78	int32_t AddRef(void)
79	{
80	return ASMAtomicIncS32(&mcRefs);
81	}
82
83	void Release(void)
84	{
85	int32_t c = ASMAtomicDecS32(&mcRefs);
86	if (c == 0)
87	{
88	delete this;
89	}
90	}
91
92	HRESULT Initialize(Console *pConsole,
93	EmulatedUSB *pEmulatedUSB,
94	const com::Utf8Str *aPath,
95	const com::Utf8Str *aSettings,
96	void *pvObject);
97	HRESULT Attach(Console *pConsole,
98	PUVM pUVM,
99	const char *pszDriver);
100	HRESULT Detach(Console *pConsole,
101	PUVM pUVM);
102
103	bool HasId(const char *pszId) { return RTStrCmp(pszId, mszUuid) == 0;}
104
105	EUSBDEVICESTATUS enmStatus;
106	};
107
108	static int emulatedWebcamInsertSettings(PCFGMNODE pConfig, EUSBSettingsMap *pSettings)
109	{
110	int rc = VINF_SUCCESS;
111
112	EUSBSettingsMap::const_iterator it;
113	for (it = pSettings->begin(); it != pSettings->end(); ++it)
114	{
115	/* Convert some well known settings for backward compatibility. */
116	if ( RTStrCmp(it->first.c_str(), "MaxPayloadTransferSize") == 0
117	\|\| RTStrCmp(it->first.c_str(), "MaxFramerate") == 0)
118	{
119	uint32_t u32 = 0;
120	rc = RTStrToUInt32Full(it->second.c_str(), 10, &u32);
121	if (rc == VINF_SUCCESS)
122	{
123	rc = CFGMR3InsertInteger(pConfig, it->first.c_str(), u32);
124	}
125	else
126	{
127	if (RT_SUCCESS(rc)) /* VWRN_* */
128	{
129	rc = VERR_INVALID_PARAMETER;
130	}
131	}
132	}
133	else
134	{
135	rc = CFGMR3InsertString(pConfig, it->first.c_str(), it->second.c_str());
136	}
137
138	if (RT_FAILURE(rc))
139	{
140	break;
141	}
142	}
143
144	return rc;
145	}
146
147	/* static / DECLCALLBACK(int) EUSBWEBCAM::emulatedWebcamAttach(PUVM pUVM, EUSBWEBCAM pThis, const char *pszDriver)
148	{
149	PCFGMNODE pInstance = CFGMR3CreateTree(pUVM);
150	PCFGMNODE pConfig;
151	CFGMR3InsertNode(pInstance, "Config", &pConfig);
152	int rc = emulatedWebcamInsertSettings(pConfig, &pThis->mDevSettings);
153	if (RT_FAILURE(rc))
154	return rc;
155	PCFGMNODE pEUSB;
156	CFGMR3InsertNode(pConfig, "EmulatedUSB", &pEUSB);
157	CFGMR3InsertString(pEUSB, "Id", pThis->mszUuid);
158	CFGMR3InsertInteger(pEUSB, "pfnCallback", (uintptr_t)EmulatedUSB::i_eusbCallback);
159	CFGMR3InsertInteger(pEUSB, "pvCallback", (uintptr_t)pThis->mpEmulatedUSB);
160
161	PCFGMNODE pLunL0;
162	CFGMR3InsertNode(pInstance, "LUN#0", &pLunL0);
163	CFGMR3InsertString(pLunL0, "Driver", pszDriver);
164	CFGMR3InsertNode(pLunL0, "Config", &pConfig);
165	CFGMR3InsertString(pConfig, "DevicePath", pThis->mPath.c_str());
166	CFGMR3InsertInteger(pConfig, "Object", (uintptr_t)pThis->mpvObject);
167	rc = emulatedWebcamInsertSettings(pConfig, &pThis->mDrvSettings);
168	if (RT_FAILURE(rc))
169	return rc;
170
171	/* pInstance will be used by PDM and deallocated on error. */
172	rc = PDMR3UsbCreateEmulatedDevice(pUVM, "Webcam", pInstance, &pThis->mUuid, NULL);
173	LogRelFlowFunc(("PDMR3UsbCreateEmulatedDevice %Rrc\n", rc));
174	return rc;
175	}
176
177	/* static / DECLCALLBACK(int) EUSBWEBCAM::emulatedWebcamDetach(PUVM pUVM, EUSBWEBCAM pThis)
178	{
179	return PDMR3UsbDetachDevice(pUVM, &pThis->mUuid);
180	}
181
182	HRESULT EUSBWEBCAM::Initialize(Console *pConsole,
183	EmulatedUSB *pEmulatedUSB,
184	const com::Utf8Str *aPath,
185	const com::Utf8Str *aSettings,
186	void *pvObject)
187	{
188	HRESULT hrc = S_OK;
189
190	int vrc = RTUuidCreate(&mUuid);
191	if (RT_SUCCESS(vrc))
192	{
193	RTStrPrintf(mszUuid, sizeof(mszUuid), "%RTuuid", &mUuid);
194	hrc = mPath.assignEx(*aPath);
195	if (SUCCEEDED(hrc))
196	{
197	hrc = mSettings.assignEx(*aSettings);
198	}
199
200	if (SUCCEEDED(hrc))
201	{
202	hrc = settingsParse();
203
204	if (SUCCEEDED(hrc))
205	{
206	mpEmulatedUSB = pEmulatedUSB;
207	mpvObject = pvObject;
208	}
209	}
210	}
211
212	if (SUCCEEDED(hrc) && RT_FAILURE(vrc))
213	{
214	LogFlowThisFunc(("%Rrc\n", vrc));
215	hrc = pConsole->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, "Init emulated USB webcam (%Rrc)", vrc);
216	}
217
218	return hrc;
219	}
220
221	HRESULT EUSBWEBCAM::settingsParse(void)
222	{
223	HRESULT hr = S_OK;
224
225	/* Parse mSettings string:
226	* "[dev:\|drv:]Name1=Value1;[dev:\|drv:]Name2=Value2"
227	*/
228	char *pszSrc = mSettings.mutableRaw();
229
230	if (pszSrc)
231	{
232	while (*pszSrc)
233	{
234	/* Does the setting belong to device of driver. Default is both. */
235	bool fDev = true;
236	bool fDrv = true;
237	if (RTStrNICmp(pszSrc, RT_STR_TUPLE("drv:")) == 0)
238	{
239	pszSrc += sizeof("drv:")-1;
240	fDev = false;
241	}
242	else if (RTStrNICmp(pszSrc, RT_STR_TUPLE("dev:")) == 0)
243	{
244	pszSrc += sizeof("dev:")-1;
245	fDrv = false;
246	}
247
248	char *pszEq = RTStrStr(pszSrc, "=");
249	if (!pszEq)
250	{
251	hr = E_INVALIDARG;
252	break;
253	}
254
255	char *pszEnd = RTStrStr(pszEq, ";");
256	if (!pszEnd)
257	{
258	pszEnd = pszEq + strlen(pszEq);
259	}
260
261	*pszEq = 0;
262	char chEnd = *pszEnd;
263	*pszEnd = 0;
264
265	/* Empty strings not allowed. */
266	if (*pszSrc != 0 && pszEq[1] != 0)
267	{
268	if (fDev)
269	{
270	mDevSettings[pszSrc] = &pszEq[1];
271	}
272	if (fDrv)
273	{
274	mDrvSettings[pszSrc] = &pszEq[1];
275	}
276	}
277
278	*pszEq = '=';
279	*pszEnd = chEnd;
280
281	pszSrc = pszEnd;
282	if (*pszSrc == ';')
283	{
284	pszSrc++;
285	}
286	}
287
288	if (SUCCEEDED(hr))
289	{
290	EUSBSettingsMap::const_iterator it;
291	for (it = mDevSettings.begin(); it != mDevSettings.end(); ++it)
292	LogRelFlowFunc(("[dev:%s] = [%s]\n", it->first.c_str(), it->second.c_str()));
293	for (it = mDrvSettings.begin(); it != mDrvSettings.end(); ++it)
294	LogRelFlowFunc(("[drv:%s] = [%s]\n", it->first.c_str(), it->second.c_str()));
295	}
296	}
297
298	return hr;
299	}
300
301	HRESULT EUSBWEBCAM::Attach(Console *pConsole,
302	PUVM pUVM,
303	const char *pszDriver)
304	{
305	HRESULT hrc = S_OK;
306
307	int vrc = VMR3ReqCallWaitU(pUVM, 0 /* idDstCpu (saved state, see #6232) */,
308	(PFNRT)emulatedWebcamAttach, 3,
309	pUVM, this, pszDriver);
310
311	if (SUCCEEDED(hrc) && RT_FAILURE(vrc))
312	{
313	LogFlowThisFunc(("%Rrc\n", vrc));
314	hrc = pConsole->setErrorBoth(VBOX_E_VM_ERROR, vrc, "Attach emulated USB webcam (%Rrc)", vrc);
315	}
316
317	return hrc;
318	}
319
320	HRESULT EUSBWEBCAM::Detach(Console *pConsole,
321	PUVM pUVM)
322	{
323	HRESULT hrc = S_OK;
324
325	int vrc = VMR3ReqCallWaitU(pUVM, 0 /* idDstCpu (saved state, see #6232) */,
326	(PFNRT)emulatedWebcamDetach, 2,
327	pUVM, this);
328
329	if (SUCCEEDED(hrc) && RT_FAILURE(vrc))
330	{
331	LogFlowThisFunc(("%Rrc\n", vrc));
332	hrc = pConsole->setErrorBoth(VBOX_E_VM_ERROR, vrc, "Detach emulated USB webcam (%Rrc)", vrc);
333	}
334
335	return hrc;
336	}
337
338
339	/*
340	* EmulatedUSB implementation.
341	*/
342	DEFINE_EMPTY_CTOR_DTOR(EmulatedUSB)
343
344	HRESULT EmulatedUSB::FinalConstruct()
345	{
346	return BaseFinalConstruct();
347	}
348
349	void EmulatedUSB::FinalRelease()
350	{
351	uninit();
352
353	BaseFinalRelease();
354	}
355
356	/*
357	* Initializes the instance.
358	*
359	* @param pConsole The owner.
360	*/
361	HRESULT EmulatedUSB::init(ComObjPtr<Console> pConsole)
362	{
363	LogFlowThisFunc(("\n"));
364
365	ComAssertRet(!pConsole.isNull(), E_INVALIDARG);
366
367	/* Enclose the state transition NotReady->InInit->Ready */
368	AutoInitSpan autoInitSpan(this);
369	AssertReturn(autoInitSpan.isOk(), E_FAIL);
370
371	m.pConsole = pConsole;
372
373	/* Confirm a successful initialization */
374	autoInitSpan.setSucceeded();
375
376	return S_OK;
377	}
378
379	/*
380	* Uninitializes the instance.
381	* Called either from FinalRelease() or by the parent when it gets destroyed.
382	*/
383	void EmulatedUSB::uninit()
384	{
385	LogFlowThisFunc(("\n"));
386
387	m.pConsole.setNull();
388
389	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
390	for (WebcamsMap::iterator it = m.webcams.begin(); it != m.webcams.end(); ++it)
391	{
392	EUSBWEBCAM *p = it->second;
393	if (p)
394	{
395	it->second = NULL;
396	p->Release();
397	}
398	}
399	m.webcams.clear();
400	alock.release();
401
402	/* Enclose the state transition Ready->InUninit->NotReady */
403	AutoUninitSpan autoUninitSpan(this);
404	if (autoUninitSpan.uninitDone())
405	return;
406	}
407
408	HRESULT EmulatedUSB::getWebcams(std::vector<com::Utf8Str> &aWebcams)
409	{
410	HRESULT hrc = S_OK;
411
412	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
413
414	try
415	{
416	aWebcams.resize(m.webcams.size());
417	}
418	catch (std::bad_alloc &)
419	{
420	hrc = E_OUTOFMEMORY;
421	}
422	catch (...)
423	{
424	hrc = E_FAIL;
425	}
426
427	if (SUCCEEDED(hrc))
428	{
429	size_t i;
430	WebcamsMap::const_iterator it;
431	for (i = 0, it = m.webcams.begin(); it != m.webcams.end(); ++it)
432	aWebcams[i++] = it->first;
433	}
434
435	return hrc;
436	}
437
438	static const Utf8Str s_pathDefault(".0");
439
440	HRESULT EmulatedUSB::webcamAttach(const com::Utf8Str &aPath,
441	const com::Utf8Str &aSettings)
442	{
443	return i_webcamAttachInternal(aPath, aSettings, "HostWebcam", NULL);
444	}
445
446	HRESULT EmulatedUSB::i_webcamAttachInternal(const com::Utf8Str &aPath,
447	const com::Utf8Str &aSettings,
448	const char *pszDriver,
449	void *pvObject)
450	{
451	HRESULT hrc = S_OK;
452
453	const Utf8Str &path = aPath.isEmpty() \|\| aPath == "."? s_pathDefault: aPath;
454
455	Console::SafeVMPtr ptrVM(m.pConsole);
456	if (ptrVM.isOk())
457	{
458	EUSBWEBCAM *p = new EUSBWEBCAM();
459	if (p)
460	{
461	hrc = p->Initialize(m.pConsole, this, &path, &aSettings, pvObject);
462	if (SUCCEEDED(hrc))
463	{
464	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
465	WebcamsMap::const_iterator it = m.webcams.find(path);
466	if (it == m.webcams.end())
467	{
468	p->AddRef();
469	try
470	{
471	m.webcams[path] = p;
472	}
473	catch (std::bad_alloc &)
474	{
475	hrc = E_OUTOFMEMORY;
476	}
477	catch (...)
478	{
479	hrc = E_FAIL;
480	}
481	p->enmStatus = EUSBDEVICE_ATTACHING;
482	}
483	else
484	{
485	hrc = E_FAIL;
486	}
487	}
488
489	if (SUCCEEDED(hrc))
490	{
491	hrc = p->Attach(m.pConsole, ptrVM.rawUVM(), pszDriver);
492	}
493
494	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
495	if (SUCCEEDED(hrc))
496	{
497	p->enmStatus = EUSBDEVICE_ATTACHED;
498	}
499	else
500	{
501	if (p->enmStatus != EUSBDEVICE_CREATED)
502	{
503	m.webcams.erase(path);
504	}
505	}
506	alock.release();
507
508	p->Release();
509	}
510	else
511	{
512	hrc = E_OUTOFMEMORY;
513	}
514	}
515	else
516	{
517	hrc = VBOX_E_INVALID_VM_STATE;
518	}
519
520	return hrc;
521	}
522
523	HRESULT EmulatedUSB::webcamDetach(const com::Utf8Str &aPath)
524	{
525	return i_webcamDetachInternal(aPath);
526	}
527
528	HRESULT EmulatedUSB::i_webcamDetachInternal(const com::Utf8Str &aPath)
529	{
530	HRESULT hrc = S_OK;
531
532	const Utf8Str &path = aPath.isEmpty() \|\| aPath == "."? s_pathDefault: aPath;
533
534	Console::SafeVMPtr ptrVM(m.pConsole);
535	if (ptrVM.isOk())
536	{
537	EUSBWEBCAM *p = NULL;
538
539	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
540	WebcamsMap::iterator it = m.webcams.find(path);
541	if (it != m.webcams.end())
542	{
543	if (it->second->enmStatus == EUSBDEVICE_ATTACHED)
544	{
545	p = it->second;
546	m.webcams.erase(it);
547	}
548	}
549	alock.release();
550
551	if (p)
552	{
553	hrc = p->Detach(m.pConsole, ptrVM.rawUVM());
554	p->Release();
555	}
556	else
557	{
558	hrc = E_INVALIDARG;
559	}
560	}
561	else
562	{
563	hrc = VBOX_E_INVALID_VM_STATE;
564	}
565
566	return hrc;
567	}
568
569	/* static / DECLCALLBACK(int) EmulatedUSB::eusbCallbackEMT(EmulatedUSB pThis, char *pszId, uint32_t iEvent,
570	void *pvData, uint32_t cbData)
571	{
572	LogRelFlowFunc(("id %s event %d, data %p %d\n", pszId, iEvent, pvData, cbData));
573
574	NOREF(cbData);
575
576	int rc = VINF_SUCCESS;
577	if (iEvent == 0)
578	{
579	com::Utf8Str path;
580	HRESULT hr = pThis->webcamPathFromId(&path, pszId);
581	if (SUCCEEDED(hr))
582	{
583	hr = pThis->webcamDetach(path);
584	if (FAILED(hr))
585	{
586	rc = VERR_INVALID_STATE;
587	}
588	}
589	else
590	{
591	rc = VERR_NOT_FOUND;
592	}
593	}
594	else
595	{
596	rc = VERR_INVALID_PARAMETER;
597	}
598
599	RTMemFree(pszId);
600	RTMemFree(pvData);
601
602	LogRelFlowFunc(("rc %Rrc\n", rc));
603	return rc;
604	}
605
606	/* static / DECLCALLBACK(int) EmulatedUSB::i_eusbCallback(void pv, const char *pszId, uint32_t iEvent,
607	const void *pvData, uint32_t cbData)
608	{
609	/* Make a copy of parameters, forward to EMT and leave the callback to not hold any lock in the device. */
610	int rc = VINF_SUCCESS;
611
612	void *pvIdCopy = NULL;
613	void *pvDataCopy = NULL;
614	if (cbData > 0)
615	{
616	pvDataCopy = RTMemDup(pvData, cbData);
617	if (!pvDataCopy)
618	{
619	rc = VERR_NO_MEMORY;
620	}
621	}
622
623	if (RT_SUCCESS(rc))
624	{
625	pvIdCopy = RTMemDup(pszId, strlen(pszId) + 1);
626	if (!pvIdCopy)
627	{
628	rc = VERR_NO_MEMORY;
629	}
630	}
631
632	if (RT_SUCCESS(rc))
633	{
634	EmulatedUSB pThis = (EmulatedUSB )pv;
635	Console::SafeVMPtr ptrVM(pThis->m.pConsole);
636	if (ptrVM.isOk())
637	{
638	/* No wait. */
639	rc = VMR3ReqCallNoWaitU(ptrVM.rawUVM(), 0 /* idDstCpu */,
640	(PFNRT)EmulatedUSB::eusbCallbackEMT, 5,
641	pThis, pvIdCopy, iEvent, pvDataCopy, cbData);
642	}
643	else
644	{
645	rc = VERR_INVALID_STATE;
646	}
647	}
648
649	if (RT_FAILURE(rc))
650	{
651	RTMemFree(pvIdCopy);
652	RTMemFree(pvDataCopy);
653	}
654
655	return rc;
656	}
657
658	HRESULT EmulatedUSB::webcamPathFromId(com::Utf8Str pPath, const char pszId)
659	{
660	HRESULT hr = S_OK;
661
662	Console::SafeVMPtr ptrVM(m.pConsole);
663	if (ptrVM.isOk())
664	{
665	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
666	WebcamsMap::const_iterator it;
667	for (it = m.webcams.begin(); it != m.webcams.end(); ++it)
668	{
669	EUSBWEBCAM *p = it->second;
670	if (p->HasId(pszId))
671	{
672	*pPath = it->first;
673	break;
674	}
675	}
676
677	if (it == m.webcams.end())
678	{
679	hr = E_FAIL;
680	}
681	alock.release();
682	}
683	else
684	{
685	hr = VBOX_E_INVALID_VM_STATE;
686	}
687
688	return hr;
689	}
690
691	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-client/EmulatedUSBImpl.cpp@ 75392

Download in other formats: