VBoxHeadless.cpp@ 58156

Last change on this file since 58156 was 55867, checked in by vboxsync, 10 years ago
VBoxHeadless: do not enable the VRDP server automatically, use the VM setting instead. User manual update.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 45.1 KB

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

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

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

Download in other formats: