VBoxHeadless.cpp@ 60813

Last change on this file since 60813 was 60759, checked in by vboxsync, 9 years ago
Frontends: various cleanups, mostly ATL related, remove code for no longer existing API method
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 46.2 KB

Line
1	/* $Id: VBoxHeadless.cpp 60759 2016-04-29 11:19:23Z vboxsync $ */
2	/** @file
3	* VBoxHeadless - The VirtualBox Headless frontend for running VMs on servers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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	#include <VBox/com/com.h>
19	#include <VBox/com/string.h>
20	#include <VBox/com/array.h>
21	#include <VBox/com/Guid.h>
22	#include <VBox/com/ErrorInfo.h>
23	#include <VBox/com/errorprint.h>
24	#include <VBox/com/NativeEventQueue.h>
25
26	#include <VBox/com/VirtualBox.h>
27	#include <VBox/com/listeners.h>
28
29	using namespace com;
30
31	#define LOG_GROUP LOG_GROUP_GUI
32
33	#include <VBox/log.h>
34	#include <VBox/version.h>
35	#include <iprt/buildconfig.h>
36	#include <iprt/ctype.h>
37	#include <iprt/initterm.h>
38	#include <iprt/stream.h>
39	#include <iprt/ldr.h>
40	#include <iprt/getopt.h>
41	#include <iprt/env.h>
42	#include <VBox/err.h>
43	#include <VBox/VBoxVideo.h>
44
45	#ifdef VBOX_WITH_VPX
46	# include <cstdlib>
47	# include <cerrno>
48	# include <iprt/process.h>
49	#endif
50
51	#ifdef RT_OS_DARWIN
52	# include <iprt/asm.h>
53	# include <dlfcn.h>
54	# include <sys/mman.h>
55	#endif
56
57	//#define VBOX_WITH_SAVESTATE_ON_SIGNAL
58	#ifdef VBOX_WITH_SAVESTATE_ON_SIGNAL
59	#include <signal.h>
60	#endif
61
62	////////////////////////////////////////////////////////////////////////////////
63
64	#define LogError(m,rc) \
65	do { \
66	Log(("VBoxHeadless: ERROR: " m " [rc=0x%08X]\n", rc)); \
67	RTPrintf("%s\n", m); \
68	} while (0)
69
70	////////////////////////////////////////////////////////////////////////////////
71
72	/* global weak references (for event handlers) */
73	static IConsole *gConsole = NULL;
74	static NativeEventQueue *gEventQ = NULL;
75
76	/* flag whether frontend should terminate */
77	static volatile bool g_fTerminateFE = false;
78
79	////////////////////////////////////////////////////////////////////////////////
80
81	/**
82	* Handler for VirtualBoxClient events.
83	*/
84	class VirtualBoxClientEventListener
85	{
86	public:
87	VirtualBoxClientEventListener()
88	{
89	}
90
91	virtual ~VirtualBoxClientEventListener()
92	{
93	}
94
95	HRESULT init()
96	{
97	return S_OK;
98	}
99
100	void uninit()
101	{
102	}
103
104	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
105	{
106	switch (aType)
107	{
108	case VBoxEventType_OnVBoxSVCAvailabilityChanged:
109	{
110	ComPtr<IVBoxSVCAvailabilityChangedEvent> pVSACEv = aEvent;
111	Assert(pVSACEv);
112	BOOL fAvailable = FALSE;
113	pVSACEv->COMGETTER(Available)(&fAvailable);
114	if (!fAvailable)
115	{
116	LogRel(("VBoxHeadless: VBoxSVC became unavailable, exiting.\n"));
117	RTPrintf("VBoxSVC became unavailable, exiting.\n");
118	/* Terminate the VM as cleanly as possible given that VBoxSVC
119	* is no longer present. */
120	g_fTerminateFE = true;
121	gEventQ->interruptEventQueueProcessing();
122	}
123	break;
124	}
125	default:
126	AssertFailed();
127	}
128
129	return S_OK;
130	}
131
132	private:
133	};
134
135	/**
136	* Handler for machine events.
137	*/
138	class ConsoleEventListener
139	{
140	public:
141	ConsoleEventListener() :
142	mLastVRDEPort(-1),
143	m_fIgnorePowerOffEvents(false),
144	m_fNoLoggedInUsers(true)
145	{
146	}
147
148	virtual ~ConsoleEventListener()
149	{
150	}
151
152	HRESULT init()
153	{
154	return S_OK;
155	}
156
157	void uninit()
158	{
159	}
160
161	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
162	{
163	switch (aType)
164	{
165	case VBoxEventType_OnMouseCapabilityChanged:
166	{
167
168	ComPtr<IMouseCapabilityChangedEvent> mccev = aEvent;
169	Assert(!mccev.isNull());
170
171	BOOL fSupportsAbsolute = false;
172	mccev->COMGETTER(SupportsAbsolute)(&fSupportsAbsolute);
173
174	/* Emit absolute mouse event to actually enable the host mouse cursor. */
175	if (fSupportsAbsolute && gConsole)
176	{
177	ComPtr<IMouse> mouse;
178	gConsole->COMGETTER(Mouse)(mouse.asOutParam());
179	if (mouse)
180	{
181	mouse->PutMouseEventAbsolute(-1, -1, 0, 0 /* Horizontal wheel */, 0);
182	}
183	}
184	break;
185	}
186	case VBoxEventType_OnStateChanged:
187	{
188	ComPtr<IStateChangedEvent> scev = aEvent;
189	Assert(scev);
190
191	MachineState_T machineState;
192	scev->COMGETTER(State)(&machineState);
193
194	/* Terminate any event wait operation if the machine has been
195	* PoweredDown/Saved/Aborted. */
196	if (machineState < MachineState_Running && !m_fIgnorePowerOffEvents)
197	{
198	g_fTerminateFE = true;
199	gEventQ->interruptEventQueueProcessing();
200	}
201
202	break;
203	}
204	case VBoxEventType_OnVRDEServerInfoChanged:
205	{
206	ComPtr<IVRDEServerInfoChangedEvent> rdicev = aEvent;
207	Assert(rdicev);
208
209	if (gConsole)
210	{
211	ComPtr<IVRDEServerInfo> info;
212	gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
213	if (info)
214	{
215	LONG port;
216	info->COMGETTER(Port)(&port);
217	if (port != mLastVRDEPort)
218	{
219	if (port == -1)
220	RTPrintf("VRDE server is inactive.\n");
221	else if (port == 0)
222	RTPrintf("VRDE server failed to start.\n");
223	else
224	RTPrintf("VRDE server is listening on port %d.\n", port);
225
226	mLastVRDEPort = port;
227	}
228	}
229	}
230	break;
231	}
232	case VBoxEventType_OnCanShowWindow:
233	{
234	ComPtr<ICanShowWindowEvent> cswev = aEvent;
235	Assert(cswev);
236	cswev->AddVeto(NULL);
237	break;
238	}
239	case VBoxEventType_OnShowWindow:
240	{
241	ComPtr<IShowWindowEvent> swev = aEvent;
242	Assert(swev);
243	/* Ignore the event, WinId is either still zero or some other listener assigned it. */
244	NOREF(swev); /* swev->COMSETTER(WinId)(0); */
245	break;
246	}
247	case VBoxEventType_OnGuestPropertyChanged:
248	{
249	ComPtr<IGuestPropertyChangedEvent> pChangedEvent = aEvent;
250	Assert(pChangedEvent);
251
252	HRESULT hrc;
253
254	ComPtr <IMachine> pMachine;
255	if (gConsole)
256	{
257	hrc = gConsole->COMGETTER(Machine)(pMachine.asOutParam());
258	if (FAILED(hrc) \|\| !pMachine)
259	hrc = VBOX_E_OBJECT_NOT_FOUND;
260	}
261	else
262	hrc = VBOX_E_INVALID_VM_STATE;
263
264	if (SUCCEEDED(hrc))
265	{
266	Bstr strKey;
267	hrc = pChangedEvent->COMGETTER(Name)(strKey.asOutParam());
268	AssertComRC(hrc);
269
270	Bstr strValue;
271	hrc = pChangedEvent->COMGETTER(Value)(strValue.asOutParam());
272	AssertComRC(hrc);
273
274	Utf8Str utf8Key = strKey;
275	Utf8Str utf8Value = strValue;
276	LogRelFlow(("Guest property \"%s\" has been changed to \"%s\"\n",
277	utf8Key.c_str(), utf8Value.c_str()));
278
279	if (utf8Key.equals("/VirtualBox/GuestInfo/OS/NoLoggedInUsers"))
280	{
281	LogRelFlow(("Guest indicates that there %s logged in users\n",
282	utf8Value.equals("true") ? "are no" : "are"));
283
284	/* Check if this is our machine and the "disconnect on logout feature" is enabled. */
285	BOOL fProcessDisconnectOnGuestLogout = FALSE;
286
287	/* Does the machine handle VRDP disconnects? */
288	Bstr strDiscon;
289	hrc = pMachine->GetExtraData(Bstr("VRDP/DisconnectOnGuestLogout").raw(),
290	strDiscon.asOutParam());
291	if (SUCCEEDED(hrc))
292	{
293	Utf8Str utf8Discon = strDiscon;
294	fProcessDisconnectOnGuestLogout = utf8Discon.equals("1")
295	? TRUE : FALSE;
296	}
297
298	LogRelFlow(("VRDE: hrc=%Rhrc: Host %s disconnecting clients (current host state known: %s)\n",
299	hrc, fProcessDisconnectOnGuestLogout ? "will handle" : "does not handle",
300	m_fNoLoggedInUsers ? "No users logged in" : "Users logged in"));
301
302	if (fProcessDisconnectOnGuestLogout)
303	{
304	bool fDropConnection = false;
305	if (!m_fNoLoggedInUsers) /* Only if the property really changes. */
306	{
307	if ( utf8Value == "true"
308	/* Guest property got deleted due to reset,
309	* so it has no value anymore. */
310	\|\| utf8Value.isEmpty())
311	{
312	m_fNoLoggedInUsers = true;
313	fDropConnection = true;
314	}
315	}
316	else if (utf8Value == "false")
317	m_fNoLoggedInUsers = false;
318	/* Guest property got deleted due to reset,
319	* take the shortcut without touching the m_fNoLoggedInUsers
320	* state. */
321	else if (utf8Value.isEmpty())
322	fDropConnection = true;
323
324	LogRelFlow(("VRDE: szNoLoggedInUsers=%s, m_fNoLoggedInUsers=%RTbool, fDropConnection=%RTbool\n",
325	utf8Value.c_str(), m_fNoLoggedInUsers, fDropConnection));
326
327	if (fDropConnection)
328	{
329	/* If there is a connection, drop it. */
330	ComPtr<IVRDEServerInfo> info;
331	hrc = gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
332	if (SUCCEEDED(hrc) && info)
333	{
334	ULONG cClients = 0;
335	hrc = info->COMGETTER(NumberOfClients)(&cClients);
336
337	LogRelFlow(("VRDE: connected clients=%RU32\n", cClients));
338	if (SUCCEEDED(hrc) && cClients > 0)
339	{
340	ComPtr <IVRDEServer> vrdeServer;
341	hrc = pMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
342	if (SUCCEEDED(hrc) && vrdeServer)
343	{
344	LogRel(("VRDE: the guest user has logged out, disconnecting remote clients.\n"));
345	hrc = vrdeServer->COMSETTER(Enabled)(FALSE);
346	AssertComRC(hrc);
347	HRESULT hrc2 = vrdeServer->COMSETTER(Enabled)(TRUE);
348	if (SUCCEEDED(hrc))
349	hrc = hrc2;
350	}
351	}
352	}
353	}
354	}
355	}
356
357	if (FAILED(hrc))
358	LogRelFlow(("VRDE: returned error=%Rhrc\n", hrc));
359	}
360
361	break;
362	}
363
364	default:
365	AssertFailed();
366	}
367	return S_OK;
368	}
369
370	void ignorePowerOffEvents(bool fIgnore)
371	{
372	m_fIgnorePowerOffEvents = fIgnore;
373	}
374
375	private:
376
377	long mLastVRDEPort;
378	bool m_fIgnorePowerOffEvents;
379	bool m_fNoLoggedInUsers;
380	};
381
382	typedef ListenerImpl<VirtualBoxClientEventListener> VirtualBoxClientEventListenerImpl;
383	typedef ListenerImpl<ConsoleEventListener> ConsoleEventListenerImpl;
384
385	VBOX_LISTENER_DECLARE(VirtualBoxClientEventListenerImpl)
386	VBOX_LISTENER_DECLARE(ConsoleEventListenerImpl)
387
388	#ifdef VBOX_WITH_SAVESTATE_ON_SIGNAL
389	static void SaveState(int sig)
390	{
391	ComPtr <IProgress> progress = NULL;
392
393	/** @todo Deal with nested signals, multithreaded signal dispatching (esp. on windows),
394	* and multiple signals (both SIGINT and SIGTERM in some order).
395	* Consider processing the signal request asynchronously since there are lots of things
396	* which aren't safe (like RTPrintf and printf IIRC) in a signal context. */
397
398	RTPrintf("Signal received, saving state.\n");
399
400	HRESULT rc = gConsole->SaveState(progress.asOutParam());
401	if (FAILED(rc))
402	{
403	RTPrintf("Error saving state! rc = 0x%x\n", rc);
404	return;
405	}
406	Assert(progress);
407	LONG cPercent = 0;
408
409	RTPrintf("0%%");
410	RTStrmFlush(g_pStdOut);
411	for (;;)
412	{
413	BOOL fCompleted = false;
414	rc = progress->COMGETTER(Completed)(&fCompleted);
415	if (FAILED(rc) \|\| fCompleted)
416	break;
417	ULONG cPercentNow;
418	rc = progress->COMGETTER(Percent)(&cPercentNow);
419	if (FAILED(rc))
420	break;
421	if ((cPercentNow / 10) != (cPercent / 10))
422	{
423	cPercent = cPercentNow;
424	RTPrintf("...%d%%", cPercentNow);
425	RTStrmFlush(g_pStdOut);
426	}
427
428	/* wait */
429	rc = progress->WaitForCompletion(100);
430	}
431
432	HRESULT lrc;
433	rc = progress->COMGETTER(ResultCode)(&lrc);
434	if (FAILED(rc))
435	lrc = ~0;
436	if (!lrc)
437	{
438	RTPrintf(" -- Saved the state successfully.\n");
439	RTThreadYield();
440	}
441	else
442	RTPrintf("-- Error saving state, lrc=%d (%#x)\n", lrc, lrc);
443
444	}
445	#endif /* VBOX_WITH_SAVESTATE_ON_SIGNAL */
446
447	////////////////////////////////////////////////////////////////////////////////
448
449	static void show_usage()
450	{
451	RTPrintf("Usage:\n"
452	" -s, -startvm, --startvm <name\|uuid> Start given VM (required argument)\n"
453	" -v, -vrde, --vrde on\|off\|config Enable or disable the VRDE server\n"
454	" or don't change the setting (default)\n"
455	" -e, -vrdeproperty, --vrdeproperty <name=[value]> Set a VRDE property:\n"
456	" \"TCP/Ports\" - comma-separated list of\n"
457	" ports the VRDE server can bind to; dash\n"
458	" between two port numbers specifies range\n"
459	" \"TCP/Address\" - interface IP the VRDE\n"
460	" server will bind to\n"
461	" --settingspw <pw> Specify the settings password\n"
462	" --settingspwfile <file> Specify a file containing the\n"
463	" settings password\n"
464	" -start-paused, --start-paused Start the VM in paused state\n"
465	#ifdef VBOX_WITH_VPX
466	" -c, -capture, --capture Record the VM screen output to a file\n"
467	" -w, --width Frame width when recording\n"
468	" -h, --height Frame height when recording\n"
469	" -r, --bitrate Recording bit rate when recording\n"
470	" -f, --filename File name when recording. The codec used\n"
471	" will be chosen based on file extension\n"
472	#endif
473	"\n");
474	}
475
476	#ifdef VBOX_WITH_VPX
477	/**
478	* Parse the environment for variables which can influence the VIDEOREC settings.
479	* purely for backwards compatibility.
480	* @param pulFrameWidth may be updated with a desired frame width
481	* @param pulFrameHeight may be updated with a desired frame height
482	* @param pulBitRate may be updated with a desired bit rate
483	* @param ppszFileName may be updated with a desired file name
484	*/
485	static void parse_environ(unsigned long pulFrameWidth, unsigned long pulFrameHeight,
486	unsigned long pulBitRate, const char *ppszFileName)
487	{
488	const char *pszEnvTemp;
489	/** @todo r=bird: This isn't up to scratch. The life time of an RTEnvGet
490	* return value is only up to the next RTEnv, getenv, *putenv,
491	* setenv call in _any_ process in the system and the it has known and
492	* documented code page issues.
493	*
494	* Use RTEnvGetEx instead! */
495	if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREWIDTH")) != 0)
496	{
497	errno = 0;
498	unsigned long ulFrameWidth = strtoul(pszEnvTemp, 0, 10);
499	if (errno != 0)
500	LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREWIDTH environment variable", 0);
501	else
502	*pulFrameWidth = ulFrameWidth;
503	}
504	if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREHEIGHT")) != 0)
505	{
506	errno = 0;
507	unsigned long ulFrameHeight = strtoul(pszEnvTemp, 0, 10);
508	if (errno != 0)
509	LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREHEIGHT environment variable", 0);
510	else
511	*pulFrameHeight = ulFrameHeight;
512	}
513	if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREBITRATE")) != 0)
514	{
515	errno = 0;
516	unsigned long ulBitRate = strtoul(pszEnvTemp, 0, 10);
517	if (errno != 0)
518	LogError("VBoxHeadless: ERROR: invalid VBOX_CAPTUREBITRATE environment variable", 0);
519	else
520	*pulBitRate = ulBitRate;
521	}
522	if ((pszEnvTemp = RTEnvGet("VBOX_CAPTUREFILE")) != 0)
523	*ppszFileName = pszEnvTemp;
524	}
525	#endif /* VBOX_WITH_VPX defined */
526
527	static RTEXITCODE readPasswordFile(const char pszFilename, com::Utf8Str pPasswd)
528	{
529	size_t cbFile;
530	char szPasswd[512];
531	int vrc = VINF_SUCCESS;
532	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
533	bool fStdIn = !strcmp(pszFilename, "stdin");
534	PRTSTREAM pStrm;
535	if (!fStdIn)
536	vrc = RTStrmOpen(pszFilename, "r", &pStrm);
537	else
538	pStrm = g_pStdIn;
539	if (RT_SUCCESS(vrc))
540	{
541	vrc = RTStrmReadEx(pStrm, szPasswd, sizeof(szPasswd)-1, &cbFile);
542	if (RT_SUCCESS(vrc))
543	{
544	if (cbFile >= sizeof(szPasswd)-1)
545	{
546	RTPrintf("Provided password in file '%s' is too long\n", pszFilename);
547	rcExit = RTEXITCODE_FAILURE;
548	}
549	else
550	{
551	unsigned i;
552	for (i = 0; i < cbFile && !RT_C_IS_CNTRL(szPasswd[i]); i++)
553	;
554	szPasswd[i] = '\0';
555	*pPasswd = szPasswd;
556	}
557	}
558	else
559	{
560	RTPrintf("Cannot read password from file '%s': %Rrc\n", pszFilename, vrc);
561	rcExit = RTEXITCODE_FAILURE;
562	}
563	if (!fStdIn)
564	RTStrmClose(pStrm);
565	}
566	else
567	{
568	RTPrintf("Cannot open password file '%s' (%Rrc)\n", pszFilename, vrc);
569	rcExit = RTEXITCODE_FAILURE;
570	}
571
572	return rcExit;
573	}
574
575	static RTEXITCODE settingsPasswordFile(ComPtr<IVirtualBox> virtualBox, const char *pszFilename)
576	{
577	com::Utf8Str passwd;
578	RTEXITCODE rcExit = readPasswordFile(pszFilename, &passwd);
579	if (rcExit == RTEXITCODE_SUCCESS)
580	{
581	int rc;
582	CHECK_ERROR(virtualBox, SetSettingsSecret(com::Bstr(passwd).raw()));
583	if (FAILED(rc))
584	rcExit = RTEXITCODE_FAILURE;
585	}
586
587	return rcExit;
588	}
589
590	#ifdef RT_OS_WINDOWS
591	// Required for ATL
592	static ATL::CComModule _Module;
593	#endif
594
595	#ifdef RT_OS_DARWIN
596	/**
597	* Mac OS X: Really ugly hack to bypass a set-uid check in AppKit.
598	*
599	* This will modify the issetugid() function to always return zero. This must
600	* be done _before_ AppKit is initialized, otherwise it will refuse to play ball
601	* with us as it distrusts set-uid processes since Snow Leopard. We, however,
602	* have carefully dropped all root privileges at this point and there should be
603	* no reason for any security concern here.
604	*/
605	static void hideSetUidRootFromAppKit()
606	{
607	/* Find issetguid() and make it always return 0 by modifying the code: */
608	void *pvAddr = dlsym(RTLD_DEFAULT, "issetugid");
609	int rc = mprotect((void *)((uintptr_t)pvAddr & ~(uintptr_t)0xfff), 0x2000, PROT_WRITE \| PROT_READ \| PROT_EXEC);
610	if (!rc)
611	ASMAtomicWriteU32((volatile uint32_t )pvAddr, 0xccc3c031); / xor eax, eax; ret; int3 */
612	}
613	#endif /* RT_OS_DARWIN */
614
615	/**
616	* Entry point.
617	*/
618	extern "C" DECLEXPORT(int) TrustedMain(int argc, char argv, char envp)
619	{
620	const char *vrdePort = NULL;
621	const char *vrdeAddress = NULL;
622	const char *vrdeEnabled = NULL;
623	unsigned cVRDEProperties = 0;
624	const char *aVRDEProperties[16];
625	unsigned fRawR0 = ~0U;
626	unsigned fRawR3 = ~0U;
627	unsigned fPATM = ~0U;
628	unsigned fCSAM = ~0U;
629	unsigned fPaused = 0;
630	#ifdef VBOX_WITH_VPX
631	bool fVideoRec = 0;
632	unsigned long ulFrameWidth = 800;
633	unsigned long ulFrameHeight = 600;
634	unsigned long ulBitRate = 300000; /** @todo r=bird: The COM type ULONG isn't unsigned long, it's 32-bit unsigned int. */
635	char szMpegFile[RTPATH_MAX];
636	const char *pszFileNameParam = "VBox-%d.vob";
637	#endif /* VBOX_WITH_VPX */
638
639	LogFlow(("VBoxHeadless STARTED.\n"));
640	RTPrintf(VBOX_PRODUCT " Headless Interface " VBOX_VERSION_STRING "\n"
641	"(C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
642	"All rights reserved.\n\n");
643
644	#ifdef VBOX_WITH_VPX
645	/* Parse the environment */
646	parse_environ(&ulFrameWidth, &ulFrameHeight, &ulBitRate, &pszFileNameParam);
647	#endif
648
649	enum eHeadlessOptions
650	{
651	OPT_RAW_R0 = 0x100,
652	OPT_NO_RAW_R0,
653	OPT_RAW_R3,
654	OPT_NO_RAW_R3,
655	OPT_PATM,
656	OPT_NO_PATM,
657	OPT_CSAM,
658	OPT_NO_CSAM,
659	OPT_SETTINGSPW,
660	OPT_SETTINGSPW_FILE,
661	OPT_COMMENT,
662	OPT_PAUSED
663	};
664
665	static const RTGETOPTDEF s_aOptions[] =
666	{
667	{ "-startvm", 's', RTGETOPT_REQ_STRING },
668	{ "--startvm", 's', RTGETOPT_REQ_STRING },
669	{ "-vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
670	{ "--vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
671	{ "-vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
672	{ "--vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
673	{ "-vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
674	{ "--vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
675	{ "-vrde", 'v', RTGETOPT_REQ_STRING },
676	{ "--vrde", 'v', RTGETOPT_REQ_STRING },
677	{ "-vrdeproperty", 'e', RTGETOPT_REQ_STRING },
678	{ "--vrdeproperty", 'e', RTGETOPT_REQ_STRING },
679	{ "-rawr0", OPT_RAW_R0, 0 },
680	{ "--rawr0", OPT_RAW_R0, 0 },
681	{ "-norawr0", OPT_NO_RAW_R0, 0 },
682	{ "--norawr0", OPT_NO_RAW_R0, 0 },
683	{ "-rawr3", OPT_RAW_R3, 0 },
684	{ "--rawr3", OPT_RAW_R3, 0 },
685	{ "-norawr3", OPT_NO_RAW_R3, 0 },
686	{ "--norawr3", OPT_NO_RAW_R3, 0 },
687	{ "-patm", OPT_PATM, 0 },
688	{ "--patm", OPT_PATM, 0 },
689	{ "-nopatm", OPT_NO_PATM, 0 },
690	{ "--nopatm", OPT_NO_PATM, 0 },
691	{ "-csam", OPT_CSAM, 0 },
692	{ "--csam", OPT_CSAM, 0 },
693	{ "-nocsam", OPT_NO_CSAM, 0 },
694	{ "--nocsam", OPT_NO_CSAM, 0 },
695	{ "--settingspw", OPT_SETTINGSPW, RTGETOPT_REQ_STRING },
696	{ "--settingspwfile", OPT_SETTINGSPW_FILE, RTGETOPT_REQ_STRING },
697	#ifdef VBOX_WITH_VPX
698	{ "-capture", 'c', 0 },
699	{ "--capture", 'c', 0 },
700	{ "--width", 'w', RTGETOPT_REQ_UINT32 },
701	{ "--height", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
702	{ "--bitrate", 'r', RTGETOPT_REQ_UINT32 },
703	{ "--filename", 'f', RTGETOPT_REQ_STRING },
704	#endif /* VBOX_WITH_VPX defined */
705	{ "-comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
706	{ "--comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
707	{ "-start-paused", OPT_PAUSED, 0 },
708	{ "--start-paused", OPT_PAUSED, 0 }
709	};
710
711	const char *pcszNameOrUUID = NULL;
712
713	#ifdef RT_OS_DARWIN
714	hideSetUidRootFromAppKit();
715	#endif
716
717	// parse the command line
718	int ch;
719	const char *pcszSettingsPw = NULL;
720	const char *pcszSettingsPwFile = NULL;
721	RTGETOPTUNION ValueUnion;
722	RTGETOPTSTATE GetState;
723	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
724	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
725	{
726	switch(ch)
727	{
728	case 's':
729	pcszNameOrUUID = ValueUnion.psz;
730	break;
731	case 'p':
732	RTPrintf("Warning: '-p' or '-vrdpport' are deprecated. Use '-e \"TCP/Ports=%s\"'\n", ValueUnion.psz);
733	vrdePort = ValueUnion.psz;
734	break;
735	case 'a':
736	RTPrintf("Warning: '-a' or '-vrdpaddress' are deprecated. Use '-e \"TCP/Address=%s\"'\n", ValueUnion.psz);
737	vrdeAddress = ValueUnion.psz;
738	break;
739	case 'v':
740	vrdeEnabled = ValueUnion.psz;
741	break;
742	case 'e':
743	if (cVRDEProperties < RT_ELEMENTS(aVRDEProperties))
744	aVRDEProperties[cVRDEProperties++] = ValueUnion.psz;
745	else
746	RTPrintf("Warning: too many VRDE properties. Ignored: '%s'\n", ValueUnion.psz);
747	break;
748	case OPT_RAW_R0:
749	fRawR0 = true;
750	break;
751	case OPT_NO_RAW_R0:
752	fRawR0 = false;
753	break;
754	case OPT_RAW_R3:
755	fRawR3 = true;
756	break;
757	case OPT_NO_RAW_R3:
758	fRawR3 = false;
759	break;
760	case OPT_PATM:
761	fPATM = true;
762	break;
763	case OPT_NO_PATM:
764	fPATM = false;
765	break;
766	case OPT_CSAM:
767	fCSAM = true;
768	break;
769	case OPT_NO_CSAM:
770	fCSAM = false;
771	break;
772	case OPT_SETTINGSPW:
773	pcszSettingsPw = ValueUnion.psz;
774	break;
775	case OPT_SETTINGSPW_FILE:
776	pcszSettingsPwFile = ValueUnion.psz;
777	break;
778	case OPT_PAUSED:
779	fPaused = true;
780	break;
781	#ifdef VBOX_WITH_VPX
782	case 'c':
783	fVideoRec = true;
784	break;
785	case 'w':
786	ulFrameWidth = ValueUnion.u32;
787	break;
788	case 'r':
789	ulBitRate = ValueUnion.u32;
790	break;
791	case 'f':
792	pszFileNameParam = ValueUnion.psz;
793	break;
794	#endif /* VBOX_WITH_VPX defined */
795	case 'h':
796	#ifdef VBOX_WITH_VPX
797	if ((GetState.pDef->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
798	{
799	ulFrameHeight = ValueUnion.u32;
800	break;
801	}
802	#endif
803	show_usage();
804	return 0;
805	case OPT_COMMENT:
806	/* nothing to do */
807	break;
808	case 'V':
809	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
810	return 0;
811	default:
812	ch = RTGetOptPrintError(ch, &ValueUnion);
813	show_usage();
814	return ch;
815	}
816	}
817
818	#ifdef VBOX_WITH_VPX
819	if (ulFrameWidth < 512 \|\| ulFrameWidth > 2048 \|\| ulFrameWidth % 2)
820	{
821	LogError("VBoxHeadless: ERROR: please specify an even frame width between 512 and 2048", 0);
822	return 1;
823	}
824	if (ulFrameHeight < 384 \|\| ulFrameHeight > 1536 \|\| ulFrameHeight % 2)
825	{
826	LogError("VBoxHeadless: ERROR: please specify an even frame height between 384 and 1536", 0);
827	return 1;
828	}
829	if (ulBitRate < 300000 \|\| ulBitRate > 1000000)
830	{
831	LogError("VBoxHeadless: ERROR: please specify an even bitrate between 300000 and 1000000", 0);
832	return 1;
833	}
834	/* Make sure we only have %d or %u (or none) in the file name specified */
835	char pcPercent = (char)strchr(pszFileNameParam, '%');
836	if (pcPercent != 0 && (pcPercent + 1) != 'd' && (pcPercent + 1) != 'u')
837	{
838	LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the capture file name.", -1);
839	return 1;
840	}
841	/* And no more than one % in the name */
842	if (pcPercent != 0 && strchr(pcPercent + 1, '%') != 0)
843	{
844	LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the capture file name.", -1);
845	return 1;
846	}
847	RTStrPrintf(&szMpegFile[0], RTPATH_MAX, pszFileNameParam, RTProcSelf());
848	#endif /* defined VBOX_WITH_VPX */
849
850	if (!pcszNameOrUUID)
851	{
852	show_usage();
853	return 1;
854	}
855
856	HRESULT rc;
857
858	rc = com::Initialize();
859	#ifdef VBOX_WITH_XPCOM
860	if (rc == NS_ERROR_FILE_ACCESS_DENIED)
861	{
862	char szHome[RTPATH_MAX] = "";
863	com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
864	RTPrintf("Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
865	return 1;
866	}
867	#endif
868	if (FAILED(rc))
869	{
870	RTPrintf("VBoxHeadless: ERROR: failed to initialize COM!\n");
871	return 1;
872	}
873
874	ComPtr<IVirtualBoxClient> pVirtualBoxClient;
875	ComPtr<IVirtualBox> virtualBox;
876	ComPtr<ISession> session;
877	ComPtr<IMachine> machine;
878	bool fSessionOpened = false;
879	ComPtr<IEventListener> vboxClientListener;
880	ComPtr<IEventListener> vboxListener;
881	ComObjPtr<ConsoleEventListenerImpl> consoleListener;
882
883	do
884	{
885	rc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
886	if (FAILED(rc))
887	{
888	RTPrintf("VBoxHeadless: ERROR: failed to create the VirtualBoxClient object!\n");
889	com::ErrorInfo info;
890	if (!info.isFullAvailable() && !info.isBasicAvailable())
891	{
892	com::GluePrintRCMessage(rc);
893	RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
894	}
895	else
896	GluePrintErrorInfo(info);
897	break;
898	}
899
900	rc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
901	if (FAILED(rc))
902	{
903	RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", rc);
904	break;
905	}
906	rc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
907	if (FAILED(rc))
908	{
909	RTPrintf("Failed to get session object (rc=%Rhrc)!\n", rc);
910	break;
911	}
912
913	if (pcszSettingsPw)
914	{
915	CHECK_ERROR(virtualBox, SetSettingsSecret(Bstr(pcszSettingsPw).raw()));
916	if (FAILED(rc))
917	break;
918	}
919	else if (pcszSettingsPwFile)
920	{
921	int rcExit = settingsPasswordFile(virtualBox, pcszSettingsPwFile);
922	if (rcExit != RTEXITCODE_SUCCESS)
923	break;
924	}
925
926	ComPtr<IMachine> m;
927
928	rc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
929	if (FAILED(rc))
930	{
931	LogError("Invalid machine name or UUID!\n", rc);
932	break;
933	}
934	Bstr id;
935	m->COMGETTER(Id)(id.asOutParam());
936	AssertComRC(rc);
937	if (FAILED(rc))
938	break;
939
940	Log(("VBoxHeadless: Opening a session with machine (id={%s})...\n",
941	Utf8Str(id).c_str()));
942
943	// set session name
944	CHECK_ERROR_BREAK(session, COMSETTER(Name)(Bstr("headless").raw()));
945	// open a session
946	CHECK_ERROR_BREAK(m, LockMachine(session, LockType_VM));
947	fSessionOpened = true;
948
949	/* get the console */
950	ComPtr<IConsole> console;
951	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
952
953	/* get the mutable machine */
954	CHECK_ERROR_BREAK(console, COMGETTER(Machine)(machine.asOutParam()));
955
956	ComPtr<IDisplay> display;
957	CHECK_ERROR_BREAK(console, COMGETTER(Display)(display.asOutParam()));
958
959	#ifdef VBOX_WITH_VPX
960	if (fVideoRec)
961	{
962	CHECK_ERROR_BREAK(machine, COMSETTER(VideoCaptureFile)(Bstr(szMpegFile).raw()));
963	CHECK_ERROR_BREAK(machine, COMSETTER(VideoCaptureWidth)(ulFrameWidth));
964	CHECK_ERROR_BREAK(machine, COMSETTER(VideoCaptureHeight)(ulFrameHeight));
965	CHECK_ERROR_BREAK(machine, COMSETTER(VideoCaptureRate)(ulBitRate));
966	CHECK_ERROR_BREAK(machine, COMSETTER(VideoCaptureEnabled)(TRUE));
967	}
968	#endif /* defined(VBOX_WITH_VPX) */
969
970	/* get the machine debugger (isn't necessarily available) */
971	ComPtr <IMachineDebugger> machineDebugger;
972	console->COMGETTER(Debugger)(machineDebugger.asOutParam());
973	if (machineDebugger)
974	{
975	Log(("Machine debugger available!\n"));
976	}
977
978	if (fRawR0 != ~0U)
979	{
980	if (!machineDebugger)
981	{
982	RTPrintf("Error: No debugger object; -%srawr0 cannot be executed!\n", fRawR0 ? "" : "no");
983	break;
984	}
985	machineDebugger->COMSETTER(RecompileSupervisor)(!fRawR0);
986	}
987	if (fRawR3 != ~0U)
988	{
989	if (!machineDebugger)
990	{
991	RTPrintf("Error: No debugger object; -%srawr3 cannot be executed!\n", fRawR3 ? "" : "no");
992	break;
993	}
994	machineDebugger->COMSETTER(RecompileUser)(!fRawR3);
995	}
996	if (fPATM != ~0U)
997	{
998	if (!machineDebugger)
999	{
1000	RTPrintf("Error: No debugger object; -%spatm cannot be executed!\n", fPATM ? "" : "no");
1001	break;
1002	}
1003	machineDebugger->COMSETTER(PATMEnabled)(fPATM);
1004	}
1005	if (fCSAM != ~0U)
1006	{
1007	if (!machineDebugger)
1008	{
1009	RTPrintf("Error: No debugger object; -%scsam cannot be executed!\n", fCSAM ? "" : "no");
1010	break;
1011	}
1012	machineDebugger->COMSETTER(CSAMEnabled)(fCSAM);
1013	}
1014
1015	/* initialize global references */
1016	gConsole = console;
1017	gEventQ = com::NativeEventQueue::getMainEventQueue();
1018
1019	/* VirtualBoxClient events registration. */
1020	{
1021	ComPtr<IEventSource> pES;
1022	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1023	ComObjPtr<VirtualBoxClientEventListenerImpl> listener;
1024	listener.createObject();
1025	listener->init(new VirtualBoxClientEventListener());
1026	vboxClientListener = listener;
1027	com::SafeArray<VBoxEventType_T> eventTypes;
1028	eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
1029	CHECK_ERROR(pES, RegisterListener(vboxClientListener, ComSafeArrayAsInParam(eventTypes), true));
1030	}
1031
1032	/* Console events registration. */
1033	{
1034	ComPtr<IEventSource> es;
1035	CHECK_ERROR(console, COMGETTER(EventSource)(es.asOutParam()));
1036	consoleListener.createObject();
1037	consoleListener->init(new ConsoleEventListener());
1038	com::SafeArray<VBoxEventType_T> eventTypes;
1039	eventTypes.push_back(VBoxEventType_OnMouseCapabilityChanged);
1040	eventTypes.push_back(VBoxEventType_OnStateChanged);
1041	eventTypes.push_back(VBoxEventType_OnVRDEServerInfoChanged);
1042	eventTypes.push_back(VBoxEventType_OnCanShowWindow);
1043	eventTypes.push_back(VBoxEventType_OnShowWindow);
1044	eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged);
1045	CHECK_ERROR(es, RegisterListener(consoleListener, ComSafeArrayAsInParam(eventTypes), true));
1046	}
1047
1048	/* Default is to use the VM setting for the VRDE server. */
1049	enum VRDEOption
1050	{
1051	VRDEOption_Config,
1052	VRDEOption_Off,
1053	VRDEOption_On
1054	};
1055	VRDEOption enmVRDEOption = VRDEOption_Config;
1056	BOOL fVRDEEnabled;
1057	ComPtr <IVRDEServer> vrdeServer;
1058	CHECK_ERROR_BREAK(machine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
1059	CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&fVRDEEnabled));
1060
1061	if (vrdeEnabled != NULL)
1062	{
1063	/* -vrde on\|off\|config */
1064	if (!strcmp(vrdeEnabled, "off") \|\| !strcmp(vrdeEnabled, "disable"))
1065	enmVRDEOption = VRDEOption_Off;
1066	else if (!strcmp(vrdeEnabled, "on") \|\| !strcmp(vrdeEnabled, "enable"))
1067	enmVRDEOption = VRDEOption_On;
1068	else if (strcmp(vrdeEnabled, "config"))
1069	{
1070	RTPrintf("-vrde requires an argument (on\|off\|config)\n");
1071	break;
1072	}
1073	}
1074
1075	Log(("VBoxHeadless: enmVRDE %d, fVRDEEnabled %d\n", enmVRDEOption, fVRDEEnabled));
1076
1077	if (enmVRDEOption != VRDEOption_Off)
1078	{
1079	/* Set other specified options. */
1080
1081	/* set VRDE port if requested by the user */
1082	if (vrdePort != NULL)
1083	{
1084	Bstr bstr = vrdePort;
1085	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.raw()));
1086	}
1087	/* set VRDE address if requested by the user */
1088	if (vrdeAddress != NULL)
1089	{
1090	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(vrdeAddress).raw()));
1091	}
1092
1093	/* Set VRDE properties. */
1094	if (cVRDEProperties > 0)
1095	{
1096	for (unsigned i = 0; i < cVRDEProperties; i++)
1097	{
1098	/* Parse 'name=value' */
1099	char *pszProperty = RTStrDup(aVRDEProperties[i]);
1100	if (pszProperty)
1101	{
1102	char *pDelimiter = strchr(pszProperty, '=');
1103	if (pDelimiter)
1104	{
1105	*pDelimiter = '\0';
1106
1107	Bstr bstrName = pszProperty;
1108	Bstr bstrValue = &pDelimiter[1];
1109	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
1110	}
1111	else
1112	{
1113	RTPrintf("Error: Invalid VRDE property '%s'\n", aVRDEProperties[i]);
1114	RTStrFree(pszProperty);
1115	rc = E_INVALIDARG;
1116	break;
1117	}
1118	RTStrFree(pszProperty);
1119	}
1120	else
1121	{
1122	RTPrintf("Error: Failed to allocate memory for VRDE property '%s'\n", aVRDEProperties[i]);
1123	rc = E_OUTOFMEMORY;
1124	break;
1125	}
1126	}
1127	if (FAILED(rc))
1128	break;
1129	}
1130
1131	}
1132
1133	if (enmVRDEOption == VRDEOption_On)
1134	{
1135	/* enable VRDE server (only if currently disabled) */
1136	if (!fVRDEEnabled)
1137	{
1138	CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(TRUE));
1139	}
1140	}
1141	else if (enmVRDEOption == VRDEOption_Off)
1142	{
1143	/* disable VRDE server (only if currently enabled */
1144	if (fVRDEEnabled)
1145	{
1146	CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(FALSE));
1147	}
1148	}
1149
1150	/* Disable the host clipboard before powering up */
1151	console->COMSETTER(UseHostClipboard)(false);
1152
1153	Log(("VBoxHeadless: Powering up the machine...\n"));
1154
1155	ComPtr <IProgress> progress;
1156	if (!fPaused)
1157	CHECK_ERROR_BREAK(console, PowerUp(progress.asOutParam()));
1158	else
1159	CHECK_ERROR_BREAK(console, PowerUpPaused(progress.asOutParam()));
1160
1161	/*
1162	* Wait for the result because there can be errors.
1163	*
1164	* It's vital to process events while waiting (teleportation deadlocks),
1165	* so we'll poll for the completion instead of waiting on it.
1166	*/
1167	for (;;)
1168	{
1169	BOOL fCompleted;
1170	rc = progress->COMGETTER(Completed)(&fCompleted);
1171	if (FAILED(rc) \|\| fCompleted)
1172	break;
1173
1174	/* Process pending events, then wait for new ones. Note, this
1175	* processes NULL events signalling event loop termination. */
1176	gEventQ->processEventQueue(0);
1177	if (!g_fTerminateFE)
1178	gEventQ->processEventQueue(500);
1179	}
1180
1181	if (SUCCEEDED(progress->WaitForCompletion(-1)))
1182	{
1183	/* Figure out if the operation completed with a failed status
1184	* and print the error message. Terminate immediately, and let
1185	* the cleanup code take care of potentially pending events. */
1186	LONG progressRc;
1187	progress->COMGETTER(ResultCode)(&progressRc);
1188	rc = progressRc;
1189	if (FAILED(rc))
1190	{
1191	com::ProgressErrorInfo info(progress);
1192	if (info.isBasicAvailable())
1193	{
1194	RTPrintf("Error: failed to start machine. Error message: %ls\n", info.getText().raw());
1195	}
1196	else
1197	{
1198	RTPrintf("Error: failed to start machine. No error message available!\n");
1199	}
1200	break;
1201	}
1202	}
1203
1204	#ifdef VBOX_WITH_SAVESTATE_ON_SIGNAL
1205	signal(SIGINT, SaveState);
1206	signal(SIGTERM, SaveState);
1207	#endif
1208
1209	Log(("VBoxHeadless: Waiting for PowerDown...\n"));
1210
1211	while ( !g_fTerminateFE
1212	&& RT_SUCCESS(gEventQ->processEventQueue(RT_INDEFINITE_WAIT)))
1213	/* nothing */ ;
1214
1215	Log(("VBoxHeadless: event loop has terminated...\n"));
1216
1217	#ifdef VBOX_WITH_VPX
1218	if (fVideoRec)
1219	{
1220	if (!machine.isNull())
1221	machine->COMSETTER(VideoCaptureEnabled)(FALSE);
1222	}
1223	#endif /* defined(VBOX_WITH_VPX) */
1224
1225	/* we don't have to disable VRDE here because we don't save the settings of the VM */
1226	}
1227	while (0);
1228
1229	/*
1230	* Get the machine state.
1231	*/
1232	MachineState_T machineState = MachineState_Aborted;
1233	if (!machine.isNull())
1234	machine->COMGETTER(State)(&machineState);
1235
1236	/*
1237	* Turn off the VM if it's running
1238	*/
1239	if ( gConsole
1240	&& ( machineState == MachineState_Running
1241	\|\| machineState == MachineState_Teleporting
1242	\|\| machineState == MachineState_LiveSnapshotting
1243	/** @todo power off paused VMs too? */
1244	)
1245	)
1246	do
1247	{
1248	consoleListener->getWrapped()->ignorePowerOffEvents(true);
1249	ComPtr<IProgress> pProgress;
1250	CHECK_ERROR_BREAK(gConsole, PowerDown(pProgress.asOutParam()));
1251	CHECK_ERROR_BREAK(pProgress, WaitForCompletion(-1));
1252	BOOL completed;
1253	CHECK_ERROR_BREAK(pProgress, COMGETTER(Completed)(&completed));
1254	ASSERT(completed);
1255	LONG hrc;
1256	CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&hrc));
1257	if (FAILED(hrc))
1258	{
1259	RTPrintf("VBoxHeadless: ERROR: Failed to power down VM!");
1260	com::ErrorInfo info;
1261	if (!info.isFullAvailable() && !info.isBasicAvailable())
1262	com::GluePrintRCMessage(hrc);
1263	else
1264	GluePrintErrorInfo(info);
1265	break;
1266	}
1267	} while (0);
1268
1269	/* VirtualBox callback unregistration. */
1270	if (vboxListener)
1271	{
1272	ComPtr<IEventSource> es;
1273	CHECK_ERROR(virtualBox, COMGETTER(EventSource)(es.asOutParam()));
1274	if (!es.isNull())
1275	CHECK_ERROR(es, UnregisterListener(vboxListener));
1276	vboxListener.setNull();
1277	}
1278
1279	/* Console callback unregistration. */
1280	if (consoleListener)
1281	{
1282	ComPtr<IEventSource> es;
1283	CHECK_ERROR(gConsole, COMGETTER(EventSource)(es.asOutParam()));
1284	if (!es.isNull())
1285	CHECK_ERROR(es, UnregisterListener(consoleListener));
1286	consoleListener.setNull();
1287	}
1288
1289	/* VirtualBoxClient callback unregistration. */
1290	if (vboxClientListener)
1291	{
1292	ComPtr<IEventSource> pES;
1293	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1294	if (!pES.isNull())
1295	CHECK_ERROR(pES, UnregisterListener(vboxClientListener));
1296	vboxClientListener.setNull();
1297	}
1298
1299	/* No more access to the 'console' object, which will be uninitialized by the next session->Close call. */
1300	gConsole = NULL;
1301
1302	if (fSessionOpened)
1303	{
1304	/*
1305	* Close the session. This will also uninitialize the console and
1306	* unregister the callback we've registered before.
1307	*/
1308	Log(("VBoxHeadless: Closing the session...\n"));
1309	session->UnlockMachine();
1310	}
1311
1312	/* Must be before com::Shutdown */
1313	session.setNull();
1314	virtualBox.setNull();
1315	pVirtualBoxClient.setNull();
1316	machine.setNull();
1317
1318	com::Shutdown();
1319
1320	LogFlow(("VBoxHeadless FINISHED.\n"));
1321
1322	return FAILED(rc) ? 1 : 0;
1323	}
1324
1325
1326	#ifndef VBOX_WITH_HARDENING
1327	/**
1328	* Main entry point.
1329	*/
1330	int main(int argc, char argv, char envp)
1331	{
1332	// initialize VBox Runtime
1333	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
1334	if (RT_FAILURE(rc))
1335	{
1336	RTPrintf("VBoxHeadless: Runtime Error:\n"
1337	" %Rrc -- %Rrf\n", rc, rc);
1338	switch (rc)
1339	{
1340	case VERR_VM_DRIVER_NOT_INSTALLED:
1341	RTPrintf("Cannot access the kernel driver. Make sure the kernel module has been \n"
1342	"loaded successfully. Aborting ...\n");
1343	break;
1344	default:
1345	break;
1346	}
1347	return 1;
1348	}
1349
1350	return TrustedMain(argc, argv, envp);
1351	}
1352	#endif /* !VBOX_WITH_HARDENING */

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

source: vbox/trunk/src/VBox/Frontends/VBoxHeadless/VBoxHeadless.cpp@ 60813

Download in other formats: