VBoxManageGuestCtrlListener.cpp@ 95140

Last change on this file since 95140 was 95140, checked in by vboxsync, 2 years ago
Frontends + Main: Adjust to the new rules wrt. to rc -> hrc,vrc usage. This also fixes quite a few bugs wrt shadow variables, wrong return values and output error translations / exit codes. Also see @todos added. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 17.8 KB

Line
1	/* $Id: VBoxManageGuestCtrlListener.cpp 95140 2022-05-31 09:11:39Z vboxsync $ */
2	/** @file
3	* VBoxManage - Guest control listener implementations.
4	*/
5
6	/*
7	* Copyright (C) 2013-2022 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include "VBoxManage.h"
23	#include "VBoxManageGuestCtrl.h"
24
25	#include <VBox/com/com.h>
26	#include <VBox/com/ErrorInfo.h>
27	#include <VBox/com/errorprint.h>
28
29	#include <iprt/semaphore.h>
30	#include <iprt/time.h>
31
32	#include <map>
33	#include <vector>
34
35	DECLARE_TRANSLATION_CONTEXT(GuestCtrlLsnr);
36
37
38	/** Event semaphore we're using for notification. */
39	extern RTSEMEVENT g_SemEventGuestCtrlCanceled;
40
41
42	/*
43	* GuestListenerBase
44	* GuestListenerBase
45	* GuestListenerBase
46	*/
47
48	GuestListenerBase::GuestListenerBase(void)
49	: mfVerbose(false)
50	{
51	}
52
53	GuestListenerBase::~GuestListenerBase(void)
54	{
55	}
56
57	HRESULT GuestListenerBase::init(bool fVerbose)
58	{
59	mfVerbose = fVerbose;
60	return S_OK;
61	}
62
63
64
65	/*
66	* GuestFileEventListener
67	* GuestFileEventListener
68	* GuestFileEventListener
69	*/
70
71	GuestFileEventListener::GuestFileEventListener(void)
72	{
73	}
74
75	GuestFileEventListener::~GuestFileEventListener(void)
76	{
77	}
78
79	void GuestFileEventListener::uninit(void)
80	{
81
82	}
83
84	STDMETHODIMP GuestFileEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
85	{
86	switch (aType)
87	{
88	case VBoxEventType_OnGuestFileStateChanged:
89	{
90	HRESULT hrc;
91	do
92	{
93	ComPtr<IGuestFileStateChangedEvent> pEvent = aEvent;
94	Assert(!pEvent.isNull());
95
96	ComPtr<IGuestFile> pProcess;
97	CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pProcess.asOutParam()));
98	AssertBreak(!pProcess.isNull());
99	FileStatus_T fileSts;
100	CHECK_ERROR_BREAK(pEvent, COMGETTER(Status)(&fileSts));
101	Bstr strPath;
102	CHECK_ERROR_BREAK(pProcess, COMGETTER(Filename)(strPath.asOutParam()));
103	ULONG uID;
104	CHECK_ERROR_BREAK(pProcess, COMGETTER(Id)(&uID));
105
106	RTPrintf(GuestCtrlLsnr::tr("File ID=%RU32 \"%s\" changed status to [%s]\n"),
107	uID, Utf8Str(strPath).c_str(), gctlFileStatusToText(fileSts));
108
109	} while (0);
110	break;
111	}
112
113	default:
114	AssertFailed();
115	}
116
117	return S_OK;
118	}
119
120
121	/*
122	* GuestProcessEventListener
123	* GuestProcessEventListener
124	* GuestProcessEventListener
125	*/
126
127	GuestProcessEventListener::GuestProcessEventListener(void)
128	{
129	}
130
131	GuestProcessEventListener::~GuestProcessEventListener(void)
132	{
133	}
134
135	void GuestProcessEventListener::uninit(void)
136	{
137
138	}
139
140	STDMETHODIMP GuestProcessEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
141	{
142	switch (aType)
143	{
144	case VBoxEventType_OnGuestProcessStateChanged:
145	{
146	HRESULT hrc;
147	do
148	{
149	ComPtr<IGuestProcessStateChangedEvent> pEvent = aEvent;
150	Assert(!pEvent.isNull());
151
152	ComPtr<IGuestProcess> pProcess;
153	CHECK_ERROR_BREAK(pEvent, COMGETTER(Process)(pProcess.asOutParam()));
154	AssertBreak(!pProcess.isNull());
155	ProcessStatus_T procSts;
156	CHECK_ERROR_BREAK(pEvent, COMGETTER(Status)(&procSts));
157	Bstr strPath;
158	CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam()));
159	ULONG uPID;
160	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
161
162	RTPrintf(GuestCtrlLsnr::tr("Process PID=%RU32 \"%s\" changed status to [%s]\n"),
163	uPID, Utf8Str(strPath).c_str(), gctlProcessStatusToText(procSts));
164
165	} while (0);
166	break;
167	}
168
169	default:
170	AssertFailed();
171	}
172
173	return S_OK;
174	}
175
176
177	/*
178	* GuestSessionEventListener
179	* GuestSessionEventListener
180	* GuestSessionEventListener
181	*/
182
183	GuestSessionEventListener::GuestSessionEventListener(void)
184	{
185	}
186
187	GuestSessionEventListener::~GuestSessionEventListener(void)
188	{
189	}
190
191	void GuestSessionEventListener::uninit(void)
192	{
193	GuestEventProcs::iterator itProc = mProcs.begin();
194	while (itProc != mProcs.end())
195	{
196	if (!itProc->first.isNull())
197	{
198	HRESULT hrc;
199	do
200	{
201	/* Listener unregistration. */
202	ComPtr<IEventSource> pES;
203	CHECK_ERROR_BREAK(itProc->first, COMGETTER(EventSource)(pES.asOutParam()));
204	if (!pES.isNull())
205	CHECK_ERROR_BREAK(pES, UnregisterListener(itProc->second.mListener));
206	} while (0);
207	}
208
209	++itProc;
210	}
211	mProcs.clear();
212
213	GuestEventFiles::iterator itFile = mFiles.begin();
214	while (itFile != mFiles.end())
215	{
216	if (!itFile->first.isNull())
217	{
218	HRESULT hrc;
219	do
220	{
221	/* Listener unregistration. */
222	ComPtr<IEventSource> pES;
223	CHECK_ERROR_BREAK(itFile->first, COMGETTER(EventSource)(pES.asOutParam()));
224	if (!pES.isNull())
225	CHECK_ERROR_BREAK(pES, UnregisterListener(itFile->second.mListener));
226	} while (0);
227	}
228
229	++itFile;
230	}
231	mFiles.clear();
232	}
233
234	STDMETHODIMP GuestSessionEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
235	{
236	switch (aType)
237	{
238	case VBoxEventType_OnGuestFileRegistered:
239	{
240	HRESULT hrc;
241	do
242	{
243	ComPtr<IGuestFileRegisteredEvent> pEvent = aEvent;
244	Assert(!pEvent.isNull());
245
246	ComPtr<IGuestFile> pFile;
247	CHECK_ERROR_BREAK(pEvent, COMGETTER(File)(pFile.asOutParam()));
248	AssertBreak(!pFile.isNull());
249	BOOL fRegistered;
250	CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered));
251	Bstr strPath;
252	CHECK_ERROR_BREAK(pFile, COMGETTER(Filename)(strPath.asOutParam()));
253
254	RTPrintf(GuestCtrlLsnr::tr("File \"%s\" %s\n"),
255	Utf8Str(strPath).c_str(),
256	fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
257	if (fRegistered)
258	{
259	if (mfVerbose)
260	RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
261
262	/* Register for IGuestFile events. */
263	ComObjPtr<GuestFileEventListenerImpl> pListener;
264	pListener.createObject();
265	CHECK_ERROR_BREAK(pListener, init(new GuestFileEventListener()));
266
267	ComPtr<IEventSource> es;
268	CHECK_ERROR_BREAK(pFile, COMGETTER(EventSource)(es.asOutParam()));
269	com::SafeArray<VBoxEventType_T> eventTypes;
270	eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
271	CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes),
272	true /* Active listener */));
273
274	GuestFileStats fileStats(pListener);
275	mFiles[pFile] = fileStats;
276	}
277	else
278	{
279	GuestEventFiles::iterator itFile = mFiles.find(pFile);
280	if (itFile != mFiles.end())
281	{
282	if (mfVerbose)
283	RTPrintf(GuestCtrlLsnr::tr("Unregistering file ...\n"));
284
285	if (!itFile->first.isNull())
286	{
287	/* Listener unregistration. */
288	ComPtr<IEventSource> pES;
289	CHECK_ERROR(itFile->first, COMGETTER(EventSource)(pES.asOutParam()));
290	if (!pES.isNull())
291	CHECK_ERROR(pES, UnregisterListener(itFile->second.mListener));
292	}
293
294	mFiles.erase(itFile);
295	}
296	}
297
298	} while (0);
299	break;
300	}
301
302	case VBoxEventType_OnGuestProcessRegistered:
303	{
304	HRESULT hrc;
305	do
306	{
307	ComPtr<IGuestProcessRegisteredEvent> pEvent = aEvent;
308	Assert(!pEvent.isNull());
309
310	ComPtr<IGuestProcess> pProcess;
311	CHECK_ERROR_BREAK(pEvent, COMGETTER(Process)(pProcess.asOutParam()));
312	AssertBreak(!pProcess.isNull());
313	BOOL fRegistered;
314	CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered));
315	Bstr strPath;
316	CHECK_ERROR_BREAK(pProcess, COMGETTER(ExecutablePath)(strPath.asOutParam()));
317
318	RTPrintf(GuestCtrlLsnr::tr("Process \"%s\" %s\n"),
319	Utf8Str(strPath).c_str(),
320	fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
321	if (fRegistered)
322	{
323	if (mfVerbose)
324	RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
325
326	/* Register for IGuestProcess events. */
327	ComObjPtr<GuestProcessEventListenerImpl> pListener;
328	pListener.createObject();
329	CHECK_ERROR_BREAK(pListener, init(new GuestProcessEventListener()));
330
331	ComPtr<IEventSource> es;
332	CHECK_ERROR_BREAK(pProcess, COMGETTER(EventSource)(es.asOutParam()));
333	com::SafeArray<VBoxEventType_T> eventTypes;
334	eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
335	CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes),
336	true /* Active listener */));
337
338	GuestProcStats procStats(pListener);
339	mProcs[pProcess] = procStats;
340	}
341	else
342	{
343	GuestEventProcs::iterator itProc = mProcs.find(pProcess);
344	if (itProc != mProcs.end())
345	{
346	if (mfVerbose)
347	RTPrintf(GuestCtrlLsnr::tr("Unregistering process ...\n"));
348
349	if (!itProc->first.isNull())
350	{
351	/* Listener unregistration. */
352	ComPtr<IEventSource> pES;
353	CHECK_ERROR(itProc->first, COMGETTER(EventSource)(pES.asOutParam()));
354	if (!pES.isNull())
355	CHECK_ERROR(pES, UnregisterListener(itProc->second.mListener));
356	}
357
358	mProcs.erase(itProc);
359	}
360	}
361
362	} while (0);
363	break;
364	}
365
366	case VBoxEventType_OnGuestSessionStateChanged:
367	{
368	HRESULT hrc;
369	do
370	{
371	ComPtr<IGuestSessionStateChangedEvent> pEvent = aEvent;
372	Assert(!pEvent.isNull());
373	ComPtr<IGuestSession> pSession;
374	CHECK_ERROR_BREAK(pEvent, COMGETTER(Session)(pSession.asOutParam()));
375	AssertBreak(!pSession.isNull());
376
377	GuestSessionStatus_T sessSts;
378	CHECK_ERROR_BREAK(pSession, COMGETTER(Status)(&sessSts));
379	ULONG uID;
380	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
381	Bstr strName;
382	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
383
384	RTPrintf(GuestCtrlLsnr::tr("Session ID=%RU32 \"%s\" changed status to [%s]\n"),
385	uID, Utf8Str(strName).c_str(), gctlGuestSessionStatusToText(sessSts));
386
387	} while (0);
388	break;
389	}
390
391	default:
392	AssertFailed();
393	}
394
395	return S_OK;
396	}
397
398
399	/*
400	* GuestEventListener
401	* GuestEventListener
402	* GuestEventListener
403	*/
404
405	GuestEventListener::GuestEventListener(void)
406	{
407	}
408
409	GuestEventListener::~GuestEventListener(void)
410	{
411	}
412
413	void GuestEventListener::uninit(void)
414	{
415	GuestEventSessions::iterator itSession = mSessions.begin();
416	while (itSession != mSessions.end())
417	{
418	if (!itSession->first.isNull())
419	{
420	HRESULT hrc;
421	do
422	{
423	/* Listener unregistration. */
424	ComPtr<IEventSource> pES;
425	CHECK_ERROR_BREAK(itSession->first, COMGETTER(EventSource)(pES.asOutParam()));
426	if (!pES.isNull())
427	CHECK_ERROR_BREAK(pES, UnregisterListener(itSession->second.mListener));
428
429	} while (0);
430	}
431
432	++itSession;
433	}
434	mSessions.clear();
435	}
436
437	STDMETHODIMP GuestEventListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
438	{
439	switch (aType)
440	{
441	case VBoxEventType_OnGuestSessionRegistered:
442	{
443	HRESULT hrc;
444	do
445	{
446	ComPtr<IGuestSessionRegisteredEvent> pEvent = aEvent;
447	Assert(!pEvent.isNull());
448
449	ComPtr<IGuestSession> pSession;
450	CHECK_ERROR_BREAK(pEvent, COMGETTER(Session)(pSession.asOutParam()));
451	AssertBreak(!pSession.isNull());
452	BOOL fRegistered;
453	CHECK_ERROR_BREAK(pEvent, COMGETTER(Registered)(&fRegistered));
454	Bstr strName;
455	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
456	ULONG uID;
457	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
458
459	RTPrintf(GuestCtrlLsnr::tr("Session ID=%RU32 \"%s\" %s\n"),
460	uID, Utf8Str(strName).c_str(),
461	fRegistered ? GuestCtrlLsnr::tr("registered") : GuestCtrlLsnr::tr("unregistered"));
462	if (fRegistered)
463	{
464	if (mfVerbose)
465	RTPrintf(GuestCtrlLsnr::tr("Registering ...\n"));
466
467	/* Register for IGuestSession events. */
468	ComObjPtr<GuestSessionEventListenerImpl> pListener;
469	pListener.createObject();
470	CHECK_ERROR_BREAK(pListener, init(new GuestSessionEventListener()));
471
472	ComPtr<IEventSource> es;
473	CHECK_ERROR_BREAK(pSession, COMGETTER(EventSource)(es.asOutParam()));
474	com::SafeArray<VBoxEventType_T> eventTypes;
475	eventTypes.push_back(VBoxEventType_OnGuestFileRegistered);
476	eventTypes.push_back(VBoxEventType_OnGuestProcessRegistered);
477	eventTypes.push_back(VBoxEventType_OnGuestSessionStateChanged);
478	CHECK_ERROR_BREAK(es, RegisterListener(pListener, ComSafeArrayAsInParam(eventTypes),
479	true /* Active listener */));
480
481	GuestSessionStats sessionStats(pListener);
482	mSessions[pSession] = sessionStats;
483	}
484	else
485	{
486	GuestEventSessions::iterator itSession = mSessions.find(pSession);
487	if (itSession != mSessions.end())
488	{
489	if (mfVerbose)
490	RTPrintf(GuestCtrlLsnr::tr("Unregistering ...\n"));
491
492	if (!itSession->first.isNull())
493	{
494	/* Listener unregistration. */
495	ComPtr<IEventSource> pES;
496	CHECK_ERROR_BREAK(itSession->first, COMGETTER(EventSource)(pES.asOutParam()));
497	if (!pES.isNull())
498	CHECK_ERROR_BREAK(pES, UnregisterListener(itSession->second.mListener));
499	}
500
501	mSessions.erase(itSession);
502	}
503	}
504
505	} while (0);
506	break;
507	}
508
509	default:
510	AssertFailed();
511	}
512
513	return S_OK;
514	}
515
516	/*
517	* GuestAdditionsRunlevelListener
518	* GuestAdditionsRunlevelListener
519	* GuestAdditionsRunlevelListener
520	*/
521
522	GuestAdditionsRunlevelListener::GuestAdditionsRunlevelListener(AdditionsRunLevelType_T enmRunLevel)
523	: mRunLevelTarget(enmRunLevel)
524	{
525	}
526
527	GuestAdditionsRunlevelListener::~GuestAdditionsRunlevelListener(void)
528	{
529	}
530
531	void GuestAdditionsRunlevelListener::uninit(void)
532	{
533	}
534
535	STDMETHODIMP GuestAdditionsRunlevelListener::HandleEvent(VBoxEventType_T aType, IEvent *aEvent)
536	{
537	Assert(mRunLevelTarget != AdditionsRunLevelType_None);
538
539	HRESULT hrc;
540
541	switch (aType)
542	{
543	case VBoxEventType_OnGuestAdditionsStatusChanged:
544	{
545	ComPtr<IGuestAdditionsStatusChangedEvent> pEvent = aEvent;
546	Assert(!pEvent.isNull());
547
548	AdditionsRunLevelType_T RunLevelCur = AdditionsRunLevelType_None;
549	CHECK_ERROR_BREAK(pEvent, COMGETTER(RunLevel)(&RunLevelCur));
550
551	if (mfVerbose)
552	RTPrintf(GuestCtrlLsnr::tr("Reached run level %RU32\n"), RunLevelCur);
553
554	if (RunLevelCur == mRunLevelTarget)
555	{
556	int vrc = RTSemEventSignal(g_SemEventGuestCtrlCanceled);
557	AssertRC(vrc);
558	}
559
560	break;
561	}
562
563	default:
564	AssertFailed();
565	}
566
567	return S_OK;
568	}

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

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrlListener.cpp@ 95140

Download in other formats: