VBoxHeadless.cpp@ 91515

Last change on this file since 91515 was 91515, checked in by vboxsync, 3 years ago
VBoxHeadless: bugref:9790 - Don't use builtin_return_address(1) in the debug message. Newer compilers are unhappy about anything but the immediate caller (i.e. non-zero arguments).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.6 KB

Line
1	/* $Id: VBoxHeadless.cpp 91515 2021-10-01 13:53:39Z vboxsync $ */
2	/** @file
3	* VBoxHeadless - The VirtualBox Headless frontend for running VMs on servers.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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/message.h>
39	#include <iprt/semaphore.h>
40	#include <iprt/path.h>
41	#include <iprt/stream.h>
42	#include <iprt/ldr.h>
43	#include <iprt/getopt.h>
44	#include <iprt/env.h>
45	#include <VBox/err.h>
46	#include <VBoxVideo.h>
47
48	#ifdef VBOX_WITH_RECORDING
49	# include <cstdlib>
50	# include <cerrno>
51	# include <iprt/process.h>
52	#endif
53
54	#ifdef RT_OS_DARWIN
55	# include <iprt/asm.h>
56	# include <dlfcn.h>
57	# include <sys/mman.h>
58	#endif
59
60	#if !defined(RT_OS_WINDOWS)
61	#include <signal.h>
62	static void HandleSignal(int sig);
63	#endif
64
65	#include "PasswordInput.h"
66
67	////////////////////////////////////////////////////////////////////////////////
68
69	#define LogError(m,rc) \
70	do { \
71	Log(("VBoxHeadless: ERROR: " m " [rc=0x%08X]\n", rc)); \
72	RTPrintf("%s\n", m); \
73	} while (0)
74
75	////////////////////////////////////////////////////////////////////////////////
76
77	/* global weak references (for event handlers) */
78	static IConsole *gConsole = NULL;
79	static NativeEventQueue *gEventQ = NULL;
80
81	/* keep this handy for messages */
82	static com::Utf8Str g_strVMName;
83	static com::Utf8Str g_strVMUUID;
84
85	/* flag whether frontend should terminate */
86	static volatile bool g_fTerminateFE = false;
87
88	////////////////////////////////////////////////////////////////////////////////
89
90	/**
91	* Handler for VirtualBoxClient events.
92	*/
93	class VirtualBoxClientEventListener
94	{
95	public:
96	VirtualBoxClientEventListener()
97	{
98	}
99
100	virtual ~VirtualBoxClientEventListener()
101	{
102	}
103
104	HRESULT init()
105	{
106	return S_OK;
107	}
108
109	void uninit()
110	{
111	}
112
113	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
114	{
115	switch (aType)
116	{
117	case VBoxEventType_OnVBoxSVCAvailabilityChanged:
118	{
119	ComPtr<IVBoxSVCAvailabilityChangedEvent> pVSACEv = aEvent;
120	Assert(pVSACEv);
121	BOOL fAvailable = FALSE;
122	pVSACEv->COMGETTER(Available)(&fAvailable);
123	if (!fAvailable)
124	{
125	LogRel(("VBoxHeadless: VBoxSVC became unavailable, exiting.\n"));
126	RTPrintf("VBoxSVC became unavailable, exiting.\n");
127	/* Terminate the VM as cleanly as possible given that VBoxSVC
128	* is no longer present. */
129	g_fTerminateFE = true;
130	gEventQ->interruptEventQueueProcessing();
131	}
132	break;
133	}
134	default:
135	AssertFailed();
136	}
137
138	return S_OK;
139	}
140
141	private:
142	};
143
144	/**
145	* Handler for machine events.
146	*/
147	class ConsoleEventListener
148	{
149	public:
150	ConsoleEventListener() :
151	mLastVRDEPort(-1),
152	m_fIgnorePowerOffEvents(false),
153	m_fNoLoggedInUsers(true)
154	{
155	}
156
157	virtual ~ConsoleEventListener()
158	{
159	}
160
161	HRESULT init()
162	{
163	return S_OK;
164	}
165
166	void uninit()
167	{
168	}
169
170	STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
171	{
172	switch (aType)
173	{
174	case VBoxEventType_OnMouseCapabilityChanged:
175	{
176
177	ComPtr<IMouseCapabilityChangedEvent> mccev = aEvent;
178	Assert(!mccev.isNull());
179
180	BOOL fSupportsAbsolute = false;
181	mccev->COMGETTER(SupportsAbsolute)(&fSupportsAbsolute);
182
183	/* Emit absolute mouse event to actually enable the host mouse cursor. */
184	if (fSupportsAbsolute && gConsole)
185	{
186	ComPtr<IMouse> mouse;
187	gConsole->COMGETTER(Mouse)(mouse.asOutParam());
188	if (mouse)
189	{
190	mouse->PutMouseEventAbsolute(-1, -1, 0, 0 /* Horizontal wheel */, 0);
191	}
192	}
193	break;
194	}
195	case VBoxEventType_OnStateChanged:
196	{
197	ComPtr<IStateChangedEvent> scev = aEvent;
198	Assert(scev);
199
200	MachineState_T machineState;
201	scev->COMGETTER(State)(&machineState);
202
203	/* Terminate any event wait operation if the machine has been
204	* PoweredDown/Saved/Aborted. */
205	if (machineState < MachineState_Running && !m_fIgnorePowerOffEvents)
206	{
207	g_fTerminateFE = true;
208	gEventQ->interruptEventQueueProcessing();
209	}
210
211	break;
212	}
213	case VBoxEventType_OnVRDEServerInfoChanged:
214	{
215	ComPtr<IVRDEServerInfoChangedEvent> rdicev = aEvent;
216	Assert(rdicev);
217
218	if (gConsole)
219	{
220	ComPtr<IVRDEServerInfo> info;
221	gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
222	if (info)
223	{
224	LONG port;
225	info->COMGETTER(Port)(&port);
226	if (port != mLastVRDEPort)
227	{
228	if (port == -1)
229	RTPrintf("VRDE server is inactive.\n");
230	else if (port == 0)
231	RTPrintf("VRDE server failed to start.\n");
232	else
233	RTPrintf("VRDE server is listening on port %d.\n", port);
234
235	mLastVRDEPort = port;
236	}
237	}
238	}
239	break;
240	}
241	case VBoxEventType_OnCanShowWindow:
242	{
243	ComPtr<ICanShowWindowEvent> cswev = aEvent;
244	Assert(cswev);
245	cswev->AddVeto(NULL);
246	break;
247	}
248	case VBoxEventType_OnShowWindow:
249	{
250	ComPtr<IShowWindowEvent> swev = aEvent;
251	Assert(swev);
252	/* Ignore the event, WinId is either still zero or some other listener assigned it. */
253	NOREF(swev); /* swev->COMSETTER(WinId)(0); */
254	break;
255	}
256	case VBoxEventType_OnGuestPropertyChanged:
257	{
258	ComPtr<IGuestPropertyChangedEvent> pChangedEvent = aEvent;
259	Assert(pChangedEvent);
260
261	HRESULT hrc;
262
263	ComPtr <IMachine> pMachine;
264	if (gConsole)
265	{
266	hrc = gConsole->COMGETTER(Machine)(pMachine.asOutParam());
267	if (FAILED(hrc) \|\| !pMachine)
268	hrc = VBOX_E_OBJECT_NOT_FOUND;
269	}
270	else
271	hrc = VBOX_E_INVALID_VM_STATE;
272
273	if (SUCCEEDED(hrc))
274	{
275	Bstr strKey;
276	hrc = pChangedEvent->COMGETTER(Name)(strKey.asOutParam());
277	AssertComRC(hrc);
278
279	Bstr strValue;
280	hrc = pChangedEvent->COMGETTER(Value)(strValue.asOutParam());
281	AssertComRC(hrc);
282
283	Utf8Str utf8Key = strKey;
284	Utf8Str utf8Value = strValue;
285	LogRelFlow(("Guest property \"%s\" has been changed to \"%s\"\n",
286	utf8Key.c_str(), utf8Value.c_str()));
287
288	if (utf8Key.equals("/VirtualBox/GuestInfo/OS/NoLoggedInUsers"))
289	{
290	LogRelFlow(("Guest indicates that there %s logged in users\n",
291	utf8Value.equals("true") ? "are no" : "are"));
292
293	/* Check if this is our machine and the "disconnect on logout feature" is enabled. */
294	BOOL fProcessDisconnectOnGuestLogout = FALSE;
295
296	/* Does the machine handle VRDP disconnects? */
297	Bstr strDiscon;
298	hrc = pMachine->GetExtraData(Bstr("VRDP/DisconnectOnGuestLogout").raw(),
299	strDiscon.asOutParam());
300	if (SUCCEEDED(hrc))
301	{
302	Utf8Str utf8Discon = strDiscon;
303	fProcessDisconnectOnGuestLogout = utf8Discon.equals("1")
304	? TRUE : FALSE;
305	}
306
307	LogRelFlow(("VRDE: hrc=%Rhrc: Host %s disconnecting clients (current host state known: %s)\n",
308	hrc, fProcessDisconnectOnGuestLogout ? "will handle" : "does not handle",
309	m_fNoLoggedInUsers ? "No users logged in" : "Users logged in"));
310
311	if (fProcessDisconnectOnGuestLogout)
312	{
313	bool fDropConnection = false;
314	if (!m_fNoLoggedInUsers) /* Only if the property really changes. */
315	{
316	if ( utf8Value == "true"
317	/* Guest property got deleted due to reset,
318	* so it has no value anymore. */
319	\|\| utf8Value.isEmpty())
320	{
321	m_fNoLoggedInUsers = true;
322	fDropConnection = true;
323	}
324	}
325	else if (utf8Value == "false")
326	m_fNoLoggedInUsers = false;
327	/* Guest property got deleted due to reset,
328	* take the shortcut without touching the m_fNoLoggedInUsers
329	* state. */
330	else if (utf8Value.isEmpty())
331	fDropConnection = true;
332
333	LogRelFlow(("VRDE: szNoLoggedInUsers=%s, m_fNoLoggedInUsers=%RTbool, fDropConnection=%RTbool\n",
334	utf8Value.c_str(), m_fNoLoggedInUsers, fDropConnection));
335
336	if (fDropConnection)
337	{
338	/* If there is a connection, drop it. */
339	ComPtr<IVRDEServerInfo> info;
340	hrc = gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
341	if (SUCCEEDED(hrc) && info)
342	{
343	ULONG cClients = 0;
344	hrc = info->COMGETTER(NumberOfClients)(&cClients);
345
346	LogRelFlow(("VRDE: connected clients=%RU32\n", cClients));
347	if (SUCCEEDED(hrc) && cClients > 0)
348	{
349	ComPtr <IVRDEServer> vrdeServer;
350	hrc = pMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
351	if (SUCCEEDED(hrc) && vrdeServer)
352	{
353	LogRel(("VRDE: the guest user has logged out, disconnecting remote clients.\n"));
354	hrc = vrdeServer->COMSETTER(Enabled)(FALSE);
355	AssertComRC(hrc);
356	HRESULT hrc2 = vrdeServer->COMSETTER(Enabled)(TRUE);
357	if (SUCCEEDED(hrc))
358	hrc = hrc2;
359	}
360	}
361	}
362	}
363	}
364	}
365
366	if (FAILED(hrc))
367	LogRelFlow(("VRDE: returned error=%Rhrc\n", hrc));
368	}
369
370	break;
371	}
372
373	default:
374	AssertFailed();
375	}
376	return S_OK;
377	}
378
379	void ignorePowerOffEvents(bool fIgnore)
380	{
381	m_fIgnorePowerOffEvents = fIgnore;
382	}
383
384	private:
385
386	long mLastVRDEPort;
387	bool m_fIgnorePowerOffEvents;
388	bool m_fNoLoggedInUsers;
389	};
390
391	typedef ListenerImpl<VirtualBoxClientEventListener> VirtualBoxClientEventListenerImpl;
392	typedef ListenerImpl<ConsoleEventListener> ConsoleEventListenerImpl;
393
394	VBOX_LISTENER_DECLARE(VirtualBoxClientEventListenerImpl)
395	VBOX_LISTENER_DECLARE(ConsoleEventListenerImpl)
396
397	#if !defined(RT_OS_WINDOWS)
398	static void
399	HandleSignal(int sig)
400	{
401	RT_NOREF(sig);
402	LogRel(("VBoxHeadless: received singal %d\n", sig));
403	g_fTerminateFE = true;
404	}
405	#endif /* !RT_OS_WINDOWS */
406
407	////////////////////////////////////////////////////////////////////////////////
408
409	static void show_usage()
410	{
411	RTPrintf("Usage:\n"
412	" -s, -startvm, --startvm <name\|uuid> Start given VM (required argument)\n"
413	" -v, -vrde, --vrde on\|off\|config Enable or disable the VRDE server\n"
414	" or don't change the setting (default)\n"
415	" -e, -vrdeproperty, --vrdeproperty <name=[value]> Set a VRDE property:\n"
416	" \"TCP/Ports\" - comma-separated list of\n"
417	" ports the VRDE server can bind to; dash\n"
418	" between two port numbers specifies range\n"
419	" \"TCP/Address\" - interface IP the VRDE\n"
420	" server will bind to\n"
421	" --settingspw <pw> Specify the settings password\n"
422	" --settingspwfile <file> Specify a file containing the\n"
423	" settings password\n"
424	" -start-paused, --start-paused Start the VM in paused state\n"
425	#ifdef VBOX_WITH_RECORDING
426	" -c, -record, --record Record the VM screen output to a file\n"
427	" -w, --videowidth Video frame width when recording\n"
428	" -h, --videoheight Video frame height when recording\n"
429	" -r, --videobitrate Recording bit rate when recording\n"
430	" -f, --filename File name when recording. The codec used\n"
431	" will be chosen based on file extension\n"
432	#endif
433	"\n");
434	}
435
436	#ifdef VBOX_WITH_RECORDING
437	/**
438	* Parse the environment for variables which can influence the VIDEOREC settings.
439	* purely for backwards compatibility.
440	* @param pulFrameWidth may be updated with a desired frame width
441	* @param pulFrameHeight may be updated with a desired frame height
442	* @param pulBitRate may be updated with a desired bit rate
443	* @param ppszFilename may be updated with a desired file name
444	*/
445	static void parse_environ(uint32_t pulFrameWidth, uint32_t pulFrameHeight,
446	uint32_t pulBitRate, const char *ppszFilename)
447	{
448	const char *pszEnvTemp;
449	/** @todo r=bird: This isn't up to scratch. The life time of an RTEnvGet
450	* return value is only up to the next RTEnv, getenv, *putenv,
451	* setenv call in _any_ process in the system and the it has known and
452	* documented code page issues.
453	*
454	* Use RTEnvGetEx instead! */
455	if ((pszEnvTemp = RTEnvGet("VBOX_RECORDWIDTH")) != 0)
456	{
457	errno = 0;
458	unsigned long ulFrameWidth = strtoul(pszEnvTemp, 0, 10);
459	if (errno != 0)
460	LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDWIDTH environment variable", 0);
461	else
462	*pulFrameWidth = ulFrameWidth;
463	}
464	if ((pszEnvTemp = RTEnvGet("VBOX_RECORDHEIGHT")) != 0)
465	{
466	errno = 0;
467	unsigned long ulFrameHeight = strtoul(pszEnvTemp, 0, 10);
468	if (errno != 0)
469	LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDHEIGHT environment variable", 0);
470	else
471	*pulFrameHeight = ulFrameHeight;
472	}
473	if ((pszEnvTemp = RTEnvGet("VBOX_RECORDBITRATE")) != 0)
474	{
475	errno = 0;
476	unsigned long ulBitRate = strtoul(pszEnvTemp, 0, 10);
477	if (errno != 0)
478	LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDBITRATE environment variable", 0);
479	else
480	*pulBitRate = ulBitRate;
481	}
482	if ((pszEnvTemp = RTEnvGet("VBOX_RECORDFILE")) != 0)
483	*ppszFilename = pszEnvTemp;
484	}
485	#endif /* VBOX_WITH_RECORDING defined */
486
487	#ifdef RT_OS_DARWIN
488
489	# include <unistd.h>
490	# include <stdio.h>
491	# include <dlfcn.h>
492	# include <iprt/formats/mach-o.h>
493
494	/**
495	* Override this one to try hide the fact that we're setuid to root
496	* orginially.
497	*/
498	int issetugid_for_AppKit(void)
499	{
500	Dl_info Info = {0};
501	char szMsg[512];
502	size_t cchMsg;
503	const void * uCaller = __builtin_return_address(0);
504	if (dladdr(uCaller, &Info))
505	cchMsg = snprintf(szMsg, sizeof(szMsg), "DEBUG: issetugid_for_AppKit was called by %p %s::%s+%p\n",
506	uCaller, Info.dli_fname, Info.dli_sname, (void *)((uintptr_t)uCaller - (uintptr_t)Info.dli_saddr));
507	else
508	cchMsg = snprintf(szMsg, sizeof(szMsg), "DEBUG: issetugid_for_AppKit was called by %p\n", uCaller);
509	write(2, szMsg, cchMsg);
510	return 0;
511	}
512
513	static bool patchExtSym(mach_header_64_t pHdr, const char pszSymbol, uintptr_t uNewValue)
514	{
515	/*
516	* First do some basic header checks and the scan the load
517	* commands for the symbol table info.
518	*/
519	AssertLogRelMsgReturn(pHdr->magic == (ARCH_BITS == 64 ? MH_MAGIC_64 : MH_MAGIC),
520	("%p: magic=%#x\n", pHdr, pHdr->magic), false);
521	uint32_t const cCmds = pHdr->ncmds;
522	uint32_t const cbCmds = pHdr->sizeofcmds;
523	AssertLogRelMsgReturn(cCmds < 16384 && cbCmds < _2M, ("%p: ncmds=%u sizeofcmds=%u\n", pHdr, cCmds, cbCmds), false);
524
525	/*
526	* First command pass: Locate the symbol table and dynamic symbol table info
527	* commands, also calc the slide (load addr - link addr).
528	*/
529	dysymtab_command_t const *pDySymTab = NULL;
530	symtab_command_t const *pSymTab = NULL;
531	segment_command_64_t const *pFirstSeg = NULL;
532	uintptr_t offSlide = 0;
533	uint32_t offCmd = 0;
534	for (uint32_t iCmd = 0; iCmd < cCmds; iCmd++)
535	{
536	AssertLogRelMsgReturn(offCmd + sizeof(load_command_t) <= cbCmds,
537	("%p: iCmd=%u offCmd=%#x cbCmds=%#x\n", pHdr, iCmd, offCmd, cbCmds), false);
538	load_command_t const * const pCmd = (load_command_t const *)((uintptr_t)(pHdr + 1) + offCmd);
539	uint32_t const cbCurCmd = pCmd->cmdsize;
540	AssertLogRelMsgReturn(offCmd + cbCurCmd <= cbCmds && cbCurCmd <= cbCmds,
541	("%p: iCmd=%u offCmd=%#x cbCurCmd=%#x cbCmds=%#x\n", pHdr, iCmd, offCmd, cbCurCmd, cbCmds), false);
542	offCmd += cbCurCmd;
543
544	if (pCmd->cmd == LC_SYMTAB)
545	{
546	AssertLogRelMsgReturn(!pSymTab, ("%p: pSymTab=%p pCmd=%p\n", pHdr, pSymTab, pCmd), false);
547	pSymTab = (symtab_command_t const *)pCmd;
548	AssertLogRelMsgReturn(cbCurCmd == sizeof(*pSymTab), ("%p: pSymTab=%p cbCurCmd=%#x\n", pHdr, pCmd, cbCurCmd), false);
549
550	}
551	else if (pCmd->cmd == LC_DYSYMTAB)
552	{
553	AssertLogRelMsgReturn(!pDySymTab, ("%p: pDySymTab=%p pCmd=%p\n", pHdr, pDySymTab, pCmd), false);
554	pDySymTab = (dysymtab_command_t const *)pCmd;
555	AssertLogRelMsgReturn(cbCurCmd == sizeof(*pDySymTab), ("%p: pDySymTab=%p cbCurCmd=%#x\n", pHdr, pCmd, cbCurCmd),
556	false);
557	}
558	else if (pCmd->cmd == LC_SEGMENT_64 && !pFirstSeg) /* ASSUMES the first seg is the one with the header and stuff. */
559	{
560	/* Note! the fileoff and vmaddr seems to be modified. */
561	pFirstSeg = (segment_command_64_t const *)pCmd;
562	AssertLogRelMsgReturn(cbCurCmd >= sizeof(*pFirstSeg), ("%p: iCmd=%u cbCurCmd=%#x\n", pHdr, iCmd, cbCurCmd), false);
563	AssertLogRelMsgReturn(/pFirstSeg->fileoff == 0 && / pFirstSeg->vmsize >= sizeof(*pHdr) + cbCmds,
564	("%p: iCmd=%u fileoff=%llx vmsize=%#llx cbCmds=%#x name=%.16s\n",
565	pHdr, iCmd, pFirstSeg->fileoff, pFirstSeg->vmsize, cbCmds, pFirstSeg->segname), false);
566	offSlide = (uintptr_t)pHdr - pFirstSeg->vmaddr;
567	}
568	}
569	AssertLogRelMsgReturn(pSymTab, ("%p: no LC_SYMTAB\n", pHdr), false);
570	AssertLogRelMsgReturn(pDySymTab, ("%p: no LC_DYSYMTAB\n", pHdr), false);
571	AssertLogRelMsgReturn(pFirstSeg, ("%p: no LC_SEGMENT_64\n", pHdr), false);
572
573	/*
574	* Second command pass: Locate the memory locations of the symbol table, string
575	* table and the indirect symbol table by checking LC_SEGMENT_xx.
576	*/
577	macho_nlist_64_t const *paSymbols = NULL;
578	uint32_t const offSymbols = pSymTab->symoff;
579	uint32_t const cSymbols = pSymTab->nsyms;
580	AssertLogRelMsgReturn(cSymbols > 0 && offSymbols >= sizeof(pHdr) + cbCmds,
581	("%p: cSymbols=%#x offSymbols=%#x\n", pHdr, cSymbols, offSymbols), false);
582
583	const char *pchStrTab = NULL;
584	uint32_t const offStrTab = pSymTab->stroff;
585	uint32_t const cbStrTab = pSymTab->strsize;
586	AssertLogRelMsgReturn(cbStrTab > 0 && offStrTab >= sizeof(pHdr) + cbCmds,
587	("%p: cbStrTab=%#x offStrTab=%#x\n", pHdr, cbStrTab, offStrTab), false);
588
589	uint32_t const *paidxIndirSymbols = NULL;
590	uint32_t const offIndirSymbols = pDySymTab->indirectsymboff;
591	uint32_t const cIndirSymbols = pDySymTab->nindirectsymb;
592	AssertLogRelMsgReturn(cIndirSymbols > 0 && offIndirSymbols >= sizeof(pHdr) + cbCmds,
593	("%p: cIndirSymbols=%#x offIndirSymbols=%#x\n", pHdr, cIndirSymbols, offIndirSymbols), false);
594
595	offCmd = 0;
596	for (uint32_t iCmd = 0; iCmd < cCmds; iCmd++)
597	{
598	load_command_t const * const pCmd = (load_command_t const *)((uintptr_t)(pHdr + 1) + offCmd);
599	uint32_t const cbCurCmd = pCmd->cmdsize;
600	AssertLogRelMsgReturn(offCmd + cbCurCmd <= cbCmds && cbCurCmd <= cbCmds,
601	("%p: iCmd=%u offCmd=%#x cbCurCmd=%#x cbCmds=%#x\n", pHdr, iCmd, offCmd, cbCurCmd, cbCmds), false);
602	offCmd += cbCurCmd;
603
604	if (pCmd->cmd == LC_SEGMENT_64)
605	{
606	segment_command_64_t const pSeg = (segment_command_64_t const )pCmd;
607	AssertLogRelMsgReturn(cbCurCmd >= sizeof(*pSeg), ("%p: iCmd=%u cbCurCmd=%#x\n", pHdr, iCmd, cbCurCmd), false);
608	uintptr_t const uPtrSeg = pSeg->vmaddr + offSlide;
609	uint64_t const cbSeg = pSeg->vmsize;
610	uint64_t const offFile = pSeg->fileoff;
611
612	uint64_t offSeg = offSymbols - offFile;
613	if (offSeg < cbSeg)
614	{
615	AssertLogRelMsgReturn(!paSymbols, ("%p: paSymbols=%p uPtrSeg=%p off=%#llx\n", pHdr, paSymbols, uPtrSeg, offSeg),
616	false);
617	AssertLogRelMsgReturn(offSeg + cSymbols * sizeof(paSymbols[0]) <= cbSeg,
618	("%p: offSeg=%#llx cSymbols=%#x cbSeg=%llx\n", pHdr, offSeg, cSymbols, cbSeg), false);
619	paSymbols = (macho_nlist_64_t const *)(uPtrSeg + offSeg);
620	}
621
622	offSeg = offStrTab - offFile;
623	if (offSeg < cbSeg)
624	{
625	AssertLogRelMsgReturn(!pchStrTab, ("%p: paSymbols=%p uPtrSeg=%p\n", pHdr, pchStrTab, uPtrSeg), false);
626	AssertLogRelMsgReturn(offSeg + cbStrTab <= cbSeg,
627	("%p: offSeg=%#llx cbStrTab=%#x cbSeg=%llx\n", pHdr, offSeg, cbStrTab, cbSeg), false);
628	pchStrTab = (const char *)(uPtrSeg + offSeg);
629	}
630
631	offSeg = offIndirSymbols - offFile;
632	if (offSeg < cbSeg)
633	{
634	AssertLogRelMsgReturn(!paidxIndirSymbols,
635	("%p: paidxIndirSymbols=%p uPtrSeg=%p\n", pHdr, paidxIndirSymbols, uPtrSeg), false);
636	AssertLogRelMsgReturn(offSeg + cIndirSymbols * sizeof(paidxIndirSymbols[0]) <= cbSeg,
637	("%p: offSeg=%#llx cIndirSymbols=%#x cbSeg=%llx\n", pHdr, offSeg, cIndirSymbols, cbSeg),
638	false);
639	paidxIndirSymbols = (uint32_t const *)(uPtrSeg + offSeg);
640	}
641	}
642	}
643
644	AssertLogRelMsgReturn(paSymbols, ("%p: offSymbols=%#x\n", pHdr, offSymbols), false);
645	AssertLogRelMsgReturn(pchStrTab, ("%p: offStrTab=%#x\n", pHdr, offStrTab), false);
646	AssertLogRelMsgReturn(paidxIndirSymbols, ("%p: offIndirSymbols=%#x\n", pHdr, offIndirSymbols), false);
647
648	/*
649	* Third command pass: Process sections of types S_NON_LAZY_SYMBOL_POINTERS
650	* and S_LAZY_SYMBOL_POINTERS
651	*/
652	bool fFound = false;
653	offCmd = 0;
654	for (uint32_t iCmd = 0; iCmd < cCmds; iCmd++)
655	{
656	load_command_t const * const pCmd = (load_command_t const *)((uintptr_t)(pHdr + 1) + offCmd);
657	uint32_t const cbCurCmd = pCmd->cmdsize;
658	AssertLogRelMsgReturn(offCmd + cbCurCmd <= cbCmds && cbCurCmd <= cbCmds,
659	("%p: iCmd=%u offCmd=%#x cbCurCmd=%#x cbCmds=%#x\n", pHdr, iCmd, offCmd, cbCurCmd, cbCmds), false);
660	offCmd += cbCurCmd;
661	if (pCmd->cmd == LC_SEGMENT_64)
662	{
663	segment_command_64_t const pSeg = (segment_command_64_t const )pCmd;
664	AssertLogRelMsgReturn(cbCurCmd >= sizeof(*pSeg), ("%p: iCmd=%u cbCurCmd=%#x\n", pHdr, iCmd, cbCurCmd), false);
665	uint64_t const uSegAddr = pSeg->vmaddr;
666	uint64_t const cbSeg = pSeg->vmsize;
667
668	uint32_t const cSections = pSeg->nsects;
669	section_64_t const * const paSections = (section_64_t const *)(pSeg + 1);
670	AssertLogRelMsgReturn(cSections < _256K && sizeof(pSeg) + cSections sizeof(paSections[0]) <= cbCurCmd,
671	("%p: iCmd=%u cSections=%#x cbCurCmd=%#x\n", pHdr, iCmd, cSections, cbCurCmd), false);
672	for (uint32_t iSection = 0; iSection < cSections; iSection++)
673	{
674	if ( paSections[iSection].flags == S_NON_LAZY_SYMBOL_POINTERS
675	\|\| paSections[iSection].flags == S_LAZY_SYMBOL_POINTERS)
676	{
677	uint32_t const idxIndirBase = paSections[iSection].reserved1;
678	uint32_t const cEntries = paSections[iSection].size / sizeof(uintptr_t);
679	AssertLogRelMsgReturn(idxIndirBase <= cIndirSymbols && idxIndirBase + cEntries <= cIndirSymbols,
680	("%p: idxIndirBase=%#x cEntries=%#x cIndirSymbols=%#x\n",
681	pHdr, idxIndirBase, cEntries, cIndirSymbols), false);
682	uint64_t const uSecAddr = paSections[iSection].addr;
683	uint64_t const offInSeg = uSecAddr - uSegAddr;
684	AssertLogRelMsgReturn(offInSeg < cbSeg && offInSeg + cEntries * sizeof(uintptr_t) <= cbSeg,
685	("%p: offInSeg=%#llx cEntries=%#x cbSeg=%#llx\n", pHdr, offInSeg, cEntries, cbSeg),
686	false);
687	uintptr_t pauPtrs = (uintptr_t )(uSecAddr + offSlide);
688	for (uint32_t iEntry = 0; iEntry < cEntries; iEntry++)
689	{
690	uint32_t const idxSym = paidxIndirSymbols[idxIndirBase + iEntry];
691	if (idxSym < cSymbols)
692	{
693	macho_nlist_64_t const * const pSym = &paSymbols[idxSym];
694	const char * const pszName = pSym->n_un.n_strx < cbStrTab
695	? &pchStrTab[pSym->n_un.n_strx] : "!invalid symtab offset!";
696	if (strcmp(pszName, pszSymbol) == 0)
697	{
698	pauPtrs[iEntry] = uNewValue;
699	fFound = true;
700	break;
701	}
702	}
703	else
704	AssertMsg(idxSym == INDIRECT_SYMBOL_LOCAL \|\| idxSym == INDIRECT_SYMBOL_ABS, ("%#x\n", idxSym));
705	}
706	}
707	}
708	}
709	}
710	AssertLogRel(fFound);
711	return fFound;
712	}
713
714	/**
715	* Mac OS X: Really ugly hack to bypass a set-uid check in AppKit.
716	*
717	* This will modify the issetugid() function to always return zero. This must
718	* be done _before_ AppKit is initialized, otherwise it will refuse to play ball
719	* with us as it distrusts set-uid processes since Snow Leopard. We, however,
720	* have carefully dropped all root privileges at this point and there should be
721	* no reason for any security concern here.
722	*/
723	static void hideSetUidRootFromAppKit()
724	{
725	void *pvAddr;
726	/* Find issetguid() and make it always return 0 by modifying the code: */
727	# if 0
728	pvAddr = dlsym(RTLD_DEFAULT, "issetugid");
729	int rc = mprotect((void *)((uintptr_t)pvAddr & ~(uintptr_t)0xfff), 0x2000, PROT_WRITE \| PROT_READ \| PROT_EXEC);
730	if (!rc)
731	ASMAtomicWriteU32((volatile uint32_t )pvAddr, 0xccc3c031); / xor eax, eax; ret; int3 */
732	else
733	# endif
734	{
735	/* Failing that, find AppKit and patch its import table: */
736	void *pvAppKit = dlopen("/System/Library/Frameworks/AppKit.framework/AppKit", RTLD_NOLOAD);
737	pvAddr = dlsym(pvAppKit, "NSApplicationMain");
738	Dl_info Info = {0};
739	if ( dladdr(pvAddr, &Info)
740	&& Info.dli_fbase != NULL)
741	{
742	if (!patchExtSym((mach_header_64_t *)Info.dli_fbase, "_issetugid", (uintptr_t)&issetugid_for_AppKit))
743	write(2, RT_STR_TUPLE("WARNING: Failed to patch issetugid in AppKit! (patchExtSym)\n"));
744	# ifdef DEBUG
745	else
746	write(2, RT_STR_TUPLE("INFO: Successfully patched _issetugid import for AppKit!\n"));
747	# endif
748	}
749	else
750	write(2, RT_STR_TUPLE("WARNING: Failed to patch issetugid in AppKit! (dladdr)\n"));
751	}
752
753	}
754
755	#endif /* RT_OS_DARWIN */
756
757
758	#ifdef RT_OS_WINDOWS
759
760	#define MAIN_WND_CLASS L"VirtualBox Headless Interface"
761
762	HINSTANCE g_hInstance = NULL;
763	HWND g_hWindow = NULL;
764	RTSEMEVENT g_hCanQuit;
765
766	static DECLCALLBACK(int) windowsMessageMonitor(RTTHREAD ThreadSelf, void *pvUser);
767	static int createWindow();
768	static LRESULT CALLBACK WinMainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
769	static void destroyWindow();
770
771
772	static DECLCALLBACK(int)
773	windowsMessageMonitor(RTTHREAD ThreadSelf, void *pvUser)
774	{
775	RT_NOREF(ThreadSelf, pvUser);
776	int rc;
777
778	rc = createWindow();
779	if (RT_FAILURE(rc))
780	return rc;
781
782	RTSemEventCreate(&g_hCanQuit);
783
784	MSG msg;
785	BOOL b;
786	while ((b = ::GetMessage(&msg, 0, 0, 0)) > 0)
787	{
788	::TranslateMessage(&msg);
789	::DispatchMessage(&msg);
790	}
791
792	if (b < 0)
793	LogRel(("VBoxHeadless: GetMessage failed\n"));
794	LogRel(("VBoxHeadless: stopping windows message loop\n"));
795
796	destroyWindow();
797	return VINF_SUCCESS;
798	}
799
800
801	static int
802	createWindow()
803	{
804	/* program instance handle */
805	g_hInstance = (HINSTANCE)::GetModuleHandle(NULL);
806	if (g_hInstance == NULL)
807	{
808	LogRel(("VBoxHeadless: failed to obtain module handle\n"));
809	return VERR_GENERAL_FAILURE;
810	}
811
812	/* window class */
813	WNDCLASS wc;
814	RT_ZERO(wc);
815
816	wc.style = CS_NOCLOSE;
817	wc.lpfnWndProc = WinMainWndProc;
818	wc.hInstance = g_hInstance;
819	wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
820	wc.lpszClassName = MAIN_WND_CLASS;
821
822	ATOM atomWindowClass = ::RegisterClass(&wc);
823	if (atomWindowClass == 0)
824	{
825	LogRel(("VBoxHeadless: failed to register window class\n"));
826	return VERR_GENERAL_FAILURE;
827	}
828
829	/* secret window, secret garden */
830	g_hWindow = ::CreateWindowEx(0, MAIN_WND_CLASS, MAIN_WND_CLASS, 0,
831	0, 0, 1, 1, NULL, NULL, g_hInstance, NULL);
832	if (g_hWindow == NULL)
833	{
834	LogRel(("VBoxHeadless: failed to create window\n"));
835	return VERR_GENERAL_FAILURE;
836	}
837
838	return VINF_SUCCESS;
839	}
840
841
842	static void
843	destroyWindow()
844	{
845	if (g_hWindow == NULL)
846	return;
847
848	::DestroyWindow(g_hWindow);
849	g_hWindow = NULL;
850
851	if (g_hInstance == NULL)
852	return;
853
854	::UnregisterClass(MAIN_WND_CLASS, g_hInstance);
855	g_hInstance = NULL;
856	}
857
858
859	static LRESULT CALLBACK
860	WinMainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
861	{
862	int rc;
863
864	LRESULT lResult = 0;
865	switch (msg)
866	{
867	case WM_QUERYENDSESSION:
868	LogRel(("VBoxHeadless: WM_QUERYENDSESSION:%s%s%s%s (0x%08lx)\n",
869	lParam == 0 ? " shutdown" : "",
870	lParam & ENDSESSION_CRITICAL ? " critical" : "",
871	lParam & ENDSESSION_LOGOFF ? " logoff" : "",
872	lParam & ENDSESSION_CLOSEAPP ? " close" : "",
873	(unsigned long)lParam));
874
875	/* do not block windows session termination */
876	lResult = TRUE;
877	break;
878
879	case WM_ENDSESSION:
880	lResult = 0;
881	LogRel(("WM_ENDSESSION:%s%s%s%s%s (%s/0x%08lx)\n",
882	lParam == 0 ? " shutdown" : "",
883	lParam & ENDSESSION_CRITICAL ? " critical" : "",
884	lParam & ENDSESSION_LOGOFF ? " logoff" : "",
885	lParam & ENDSESSION_CLOSEAPP ? " close" : "",
886	wParam == FALSE ? " cancelled" : "",
887	wParam ? "TRUE" : "FALSE",
888	(unsigned long)lParam));
889	if (wParam == FALSE)
890	break;
891
892	/* tell the user what we are doing */
893	::ShutdownBlockReasonCreate(hwnd,
894	com::BstrFmt("%s saving state",
895	g_strVMName.c_str()).raw());
896
897	/* tell the VM to save state/power off */
898	g_fTerminateFE = true;
899	gEventQ->interruptEventQueueProcessing();
900
901	if (g_hCanQuit != NIL_RTSEMEVENT)
902	{
903	LogRel(("VBoxHeadless: WM_ENDSESSION: waiting for VM termination...\n"));
904
905	rc = RTSemEventWait(g_hCanQuit, RT_INDEFINITE_WAIT);
906	if (RT_SUCCESS(rc))
907	LogRel(("VBoxHeadless: WM_ENDSESSION: done\n"));
908	else
909	LogRel(("VBoxHeadless: WM_ENDSESSION: failed to wait for VM termination: %Rrc\n", rc));
910	}
911	else
912	{
913	LogRel(("VBoxHeadless: WM_ENDSESSION: cannot wait for VM termination\n"));
914	}
915	break;
916
917	default:
918	lResult = ::DefWindowProc(hwnd, msg, wParam, lParam);
919	break;
920	}
921	return lResult;
922	}
923
924
925	static const char * const ctrl_event_names[] = {
926	"CTRL_C_EVENT",
927	"CTRL_BREAK_EVENT",
928	"CTRL_CLOSE_EVENT",
929	/* reserved, not used */
930	"<console control event 3>",
931	"<console control event 4>",
932	/* not sent to processes that load gdi32.dll or user32.dll */
933	"CTRL_LOGOFF_EVENT",
934	"CTRL_SHUTDOWN_EVENT",
935	};
936
937
938	BOOL WINAPI
939	ConsoleCtrlHandler(DWORD dwCtrlType) RT_NOTHROW_DEF
940	{
941	const char *signame;
942	char namebuf[48];
943	int rc;
944
945	if (dwCtrlType < RT_ELEMENTS(ctrl_event_names))
946	signame = ctrl_event_names[dwCtrlType];
947	else
948	{
949	/* should not happen, but be prepared */
950	RTStrPrintf(namebuf, sizeof(namebuf),
951	"<console control event %lu>", (unsigned long)dwCtrlType);
952	signame = namebuf;
953	}
954	LogRel(("VBoxHeadless: got %s\n", signame));
955	RTMsgInfo("Got %s\n", signame);
956	RTMsgInfo("");
957
958	/* tell the VM to save state/power off */
959	g_fTerminateFE = true;
960	gEventQ->interruptEventQueueProcessing();
961
962	/*
963	* We don't need to wait for Ctrl-C / Ctrl-Break, but we must wait
964	* for Close, or we will be killed before the VM is saved.
965	*/
966	if (g_hCanQuit != NIL_RTSEMEVENT)
967	{
968	LogRel(("VBoxHeadless: waiting for VM termination...\n"));
969
970	rc = RTSemEventWait(g_hCanQuit, RT_INDEFINITE_WAIT);
971	if (RT_FAILURE(rc))
972	LogRel(("VBoxHeadless: Failed to wait for VM termination: %Rrc\n", rc));
973	}
974
975	/* tell the system we handled it */
976	LogRel(("VBoxHeadless: ConsoleCtrlHandler: return\n"));
977	return TRUE;
978	}
979	#endif /* RT_OS_WINDOWS */
980
981
982	/*
983	* Simplified version of showProgress() borrowed from VBoxManage.
984	* Note that machine power up/down operations are not cancelable, so
985	* we don't bother checking for signals.
986	*/
987	HRESULT
988	showProgress(const ComPtr<IProgress> &progress)
989	{
990	BOOL fCompleted = FALSE;
991	ULONG ulLastPercent = 0;
992	ULONG ulCurrentPercent = 0;
993	HRESULT hrc;
994
995	com::Bstr bstrDescription;
996	hrc = progress->COMGETTER(Description(bstrDescription.asOutParam()));
997	if (FAILED(hrc))
998	{
999	RTStrmPrintf(g_pStdErr, "Failed to get progress description: %Rhrc\n", hrc);
1000	return hrc;
1001	}
1002
1003	RTStrmPrintf(g_pStdErr, "%ls: ", bstrDescription.raw());
1004	RTStrmFlush(g_pStdErr);
1005
1006	hrc = progress->COMGETTER(Completed(&fCompleted));
1007	while (SUCCEEDED(hrc))
1008	{
1009	progress->COMGETTER(Percent(&ulCurrentPercent));
1010
1011	/* did we cross a 10% mark? */
1012	if (ulCurrentPercent / 10 > ulLastPercent / 10)
1013	{
1014	/* make sure to also print out missed steps */
1015	for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10)
1016	{
1017	if (curVal < 100)
1018	{
1019	RTStrmPrintf(g_pStdErr, "%u%%...", curVal);
1020	RTStrmFlush(g_pStdErr);
1021	}
1022	}
1023	ulLastPercent = (ulCurrentPercent / 10) * 10;
1024	}
1025
1026	if (fCompleted)
1027	break;
1028
1029	gEventQ->processEventQueue(500);
1030	hrc = progress->COMGETTER(Completed(&fCompleted));
1031	}
1032
1033	/* complete the line. */
1034	LONG iRc = E_FAIL;
1035	hrc = progress->COMGETTER(ResultCode)(&iRc);
1036	if (SUCCEEDED(hrc))
1037	{
1038	if (SUCCEEDED(iRc))
1039	RTStrmPrintf(g_pStdErr, "100%%\n");
1040	#if 0
1041	else if (g_fCanceled)
1042	RTStrmPrintf(g_pStdErr, "CANCELED\n");
1043	#endif
1044	else
1045	{
1046	RTStrmPrintf(g_pStdErr, "\n");
1047	RTStrmPrintf(g_pStdErr, "Operation failed: %Rhrc\n", iRc);
1048	}
1049	hrc = iRc;
1050	}
1051	else
1052	{
1053	RTStrmPrintf(g_pStdErr, "\n");
1054	RTStrmPrintf(g_pStdErr, "Failed to obtain operation result: %Rhrc\n", hrc);
1055	}
1056	RTStrmFlush(g_pStdErr);
1057	return hrc;
1058	}
1059
1060
1061	/**
1062	* Entry point.
1063	*/
1064	extern "C" DECLEXPORT(int) TrustedMain(int argc, char argv, char envp)
1065	{
1066	RT_NOREF(envp);
1067	const char *vrdePort = NULL;
1068	const char *vrdeAddress = NULL;
1069	const char *vrdeEnabled = NULL;
1070	unsigned cVRDEProperties = 0;
1071	const char *aVRDEProperties[16];
1072	unsigned fRawR0 = ~0U;
1073	unsigned fRawR3 = ~0U;
1074	unsigned fPATM = ~0U;
1075	unsigned fCSAM = ~0U;
1076	unsigned fPaused = 0;
1077	#ifdef VBOX_WITH_RECORDING
1078	bool fRecordEnabled = false;
1079	uint32_t ulRecordVideoWidth = 800;
1080	uint32_t ulRecordVideoHeight = 600;
1081	uint32_t ulRecordVideoRate = 300000;
1082	char szRecordFilename[RTPATH_MAX];
1083	const char pszRecordFilenameTemplate = "VBox-%d.webm"; / .webm container by default. */
1084	#endif /* VBOX_WITH_RECORDING */
1085	#ifdef RT_OS_WINDOWS
1086	ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */
1087	#endif
1088
1089	LogFlow(("VBoxHeadless STARTED.\n"));
1090	RTPrintf(VBOX_PRODUCT " Headless Interface " VBOX_VERSION_STRING "\n"
1091	"(C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
1092	"All rights reserved.\n\n");
1093
1094	#ifdef VBOX_WITH_RECORDING
1095	/* Parse the environment */
1096	parse_environ(&ulRecordVideoWidth, &ulRecordVideoHeight, &ulRecordVideoRate, &pszRecordFilenameTemplate);
1097	#endif
1098
1099	enum eHeadlessOptions
1100	{
1101	OPT_RAW_R0 = 0x100,
1102	OPT_NO_RAW_R0,
1103	OPT_RAW_R3,
1104	OPT_NO_RAW_R3,
1105	OPT_PATM,
1106	OPT_NO_PATM,
1107	OPT_CSAM,
1108	OPT_NO_CSAM,
1109	OPT_SETTINGSPW,
1110	OPT_SETTINGSPW_FILE,
1111	OPT_COMMENT,
1112	OPT_PAUSED
1113	};
1114
1115	static const RTGETOPTDEF s_aOptions[] =
1116	{
1117	{ "-startvm", 's', RTGETOPT_REQ_STRING },
1118	{ "--startvm", 's', RTGETOPT_REQ_STRING },
1119	{ "-vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1120	{ "--vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1121	{ "-vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1122	{ "--vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1123	{ "-vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1124	{ "--vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1125	{ "-vrde", 'v', RTGETOPT_REQ_STRING },
1126	{ "--vrde", 'v', RTGETOPT_REQ_STRING },
1127	{ "-vrdeproperty", 'e', RTGETOPT_REQ_STRING },
1128	{ "--vrdeproperty", 'e', RTGETOPT_REQ_STRING },
1129	{ "-rawr0", OPT_RAW_R0, 0 },
1130	{ "--rawr0", OPT_RAW_R0, 0 },
1131	{ "-norawr0", OPT_NO_RAW_R0, 0 },
1132	{ "--norawr0", OPT_NO_RAW_R0, 0 },
1133	{ "-rawr3", OPT_RAW_R3, 0 },
1134	{ "--rawr3", OPT_RAW_R3, 0 },
1135	{ "-norawr3", OPT_NO_RAW_R3, 0 },
1136	{ "--norawr3", OPT_NO_RAW_R3, 0 },
1137	{ "-patm", OPT_PATM, 0 },
1138	{ "--patm", OPT_PATM, 0 },
1139	{ "-nopatm", OPT_NO_PATM, 0 },
1140	{ "--nopatm", OPT_NO_PATM, 0 },
1141	{ "-csam", OPT_CSAM, 0 },
1142	{ "--csam", OPT_CSAM, 0 },
1143	{ "-nocsam", OPT_NO_CSAM, 0 },
1144	{ "--nocsam", OPT_NO_CSAM, 0 },
1145	{ "--settingspw", OPT_SETTINGSPW, RTGETOPT_REQ_STRING },
1146	{ "--settingspwfile", OPT_SETTINGSPW_FILE, RTGETOPT_REQ_STRING },
1147	#ifdef VBOX_WITH_RECORDING
1148	{ "-record", 'c', 0 },
1149	{ "--record", 'c', 0 },
1150	{ "--videowidth", 'w', RTGETOPT_REQ_UINT32 },
1151	{ "--videoheight", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
1152	{ "--videorate", 'r', RTGETOPT_REQ_UINT32 },
1153	{ "--filename", 'f', RTGETOPT_REQ_STRING },
1154	#endif /* VBOX_WITH_RECORDING defined */
1155	{ "-comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
1156	{ "--comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
1157	{ "-start-paused", OPT_PAUSED, 0 },
1158	{ "--start-paused", OPT_PAUSED, 0 }
1159	};
1160
1161	const char *pcszNameOrUUID = NULL;
1162
1163	#ifdef RT_OS_DARWIN
1164	hideSetUidRootFromAppKit();
1165	#endif
1166
1167	// parse the command line
1168	int ch;
1169	const char *pcszSettingsPw = NULL;
1170	const char *pcszSettingsPwFile = NULL;
1171	RTGETOPTUNION ValueUnion;
1172	RTGETOPTSTATE GetState;
1173	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
1174	while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1175	{
1176	switch(ch)
1177	{
1178	case 's':
1179	pcszNameOrUUID = ValueUnion.psz;
1180	break;
1181	case 'p':
1182	RTPrintf("Warning: '-p' or '-vrdpport' are deprecated. Use '-e \"TCP/Ports=%s\"'\n", ValueUnion.psz);
1183	vrdePort = ValueUnion.psz;
1184	break;
1185	case 'a':
1186	RTPrintf("Warning: '-a' or '-vrdpaddress' are deprecated. Use '-e \"TCP/Address=%s\"'\n", ValueUnion.psz);
1187	vrdeAddress = ValueUnion.psz;
1188	break;
1189	case 'v':
1190	vrdeEnabled = ValueUnion.psz;
1191	break;
1192	case 'e':
1193	if (cVRDEProperties < RT_ELEMENTS(aVRDEProperties))
1194	aVRDEProperties[cVRDEProperties++] = ValueUnion.psz;
1195	else
1196	RTPrintf("Warning: too many VRDE properties. Ignored: '%s'\n", ValueUnion.psz);
1197	break;
1198	case OPT_RAW_R0:
1199	fRawR0 = true;
1200	break;
1201	case OPT_NO_RAW_R0:
1202	fRawR0 = false;
1203	break;
1204	case OPT_RAW_R3:
1205	fRawR3 = true;
1206	break;
1207	case OPT_NO_RAW_R3:
1208	fRawR3 = false;
1209	break;
1210	case OPT_PATM:
1211	fPATM = true;
1212	break;
1213	case OPT_NO_PATM:
1214	fPATM = false;
1215	break;
1216	case OPT_CSAM:
1217	fCSAM = true;
1218	break;
1219	case OPT_NO_CSAM:
1220	fCSAM = false;
1221	break;
1222	case OPT_SETTINGSPW:
1223	pcszSettingsPw = ValueUnion.psz;
1224	break;
1225	case OPT_SETTINGSPW_FILE:
1226	pcszSettingsPwFile = ValueUnion.psz;
1227	break;
1228	case OPT_PAUSED:
1229	fPaused = true;
1230	break;
1231	#ifdef VBOX_WITH_RECORDING
1232	case 'c':
1233	fRecordEnabled = true;
1234	break;
1235	case 'w':
1236	ulRecordVideoWidth = ValueUnion.u32;
1237	break;
1238	case 'r':
1239	ulRecordVideoRate = ValueUnion.u32;
1240	break;
1241	case 'f':
1242	pszRecordFilenameTemplate = ValueUnion.psz;
1243	break;
1244	#endif /* VBOX_WITH_RECORDING defined */
1245	case 'h':
1246	#ifdef VBOX_WITH_RECORDING
1247	if ((GetState.pDef->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
1248	{
1249	ulRecordVideoHeight = ValueUnion.u32;
1250	break;
1251	}
1252	#endif
1253	show_usage();
1254	return 0;
1255	case OPT_COMMENT:
1256	/* nothing to do */
1257	break;
1258	case 'V':
1259	RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1260	return 0;
1261	default:
1262	ch = RTGetOptPrintError(ch, &ValueUnion);
1263	show_usage();
1264	return ch;
1265	}
1266	}
1267
1268	#ifdef VBOX_WITH_RECORDING
1269	if (ulRecordVideoWidth < 512 \|\| ulRecordVideoWidth > 2048 \|\| ulRecordVideoWidth % 2)
1270	{
1271	LogError("VBoxHeadless: ERROR: please specify an even video frame width between 512 and 2048", 0);
1272	return 1;
1273	}
1274	if (ulRecordVideoHeight < 384 \|\| ulRecordVideoHeight > 1536 \|\| ulRecordVideoHeight % 2)
1275	{
1276	LogError("VBoxHeadless: ERROR: please specify an even video frame height between 384 and 1536", 0);
1277	return 1;
1278	}
1279	if (ulRecordVideoRate < 300000 \|\| ulRecordVideoRate > 1000000)
1280	{
1281	LogError("VBoxHeadless: ERROR: please specify an even video bitrate between 300000 and 1000000", 0);
1282	return 1;
1283	}
1284	/* Make sure we only have %d or %u (or none) in the file name specified */
1285	char pcPercent = (char)strchr(pszRecordFilenameTemplate, '%');
1286	if (pcPercent != 0 && (pcPercent + 1) != 'd' && (pcPercent + 1) != 'u')
1287	{
1288	LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the recording file name.", -1);
1289	return 1;
1290	}
1291	/* And no more than one % in the name */
1292	if (pcPercent != 0 && strchr(pcPercent + 1, '%') != 0)
1293	{
1294	LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the recording file name.", -1);
1295	return 1;
1296	}
1297	RTStrPrintf(&szRecordFilename[0], RTPATH_MAX, pszRecordFilenameTemplate, RTProcSelf());
1298	#endif /* defined VBOX_WITH_RECORDING */
1299
1300	if (!pcszNameOrUUID)
1301	{
1302	show_usage();
1303	return 1;
1304	}
1305
1306	HRESULT rc;
1307	int irc;
1308
1309	rc = com::Initialize();
1310	#ifdef VBOX_WITH_XPCOM
1311	if (rc == NS_ERROR_FILE_ACCESS_DENIED)
1312	{
1313	char szHome[RTPATH_MAX] = "";
1314	com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
1315	RTPrintf("Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
1316	return 1;
1317	}
1318	#endif
1319	if (FAILED(rc))
1320	{
1321	RTPrintf("VBoxHeadless: ERROR: failed to initialize COM!\n");
1322	return 1;
1323	}
1324
1325	ComPtr<IVirtualBoxClient> pVirtualBoxClient;
1326	ComPtr<IVirtualBox> virtualBox;
1327	ComPtr<ISession> session;
1328	ComPtr<IMachine> machine;
1329	bool fSessionOpened = false;
1330	ComPtr<IEventListener> vboxClientListener;
1331	ComPtr<IEventListener> vboxListener;
1332	ComObjPtr<ConsoleEventListenerImpl> consoleListener;
1333
1334	do
1335	{
1336	rc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
1337	if (FAILED(rc))
1338	{
1339	RTPrintf("VBoxHeadless: ERROR: failed to create the VirtualBoxClient object!\n");
1340	com::ErrorInfo info;
1341	if (!info.isFullAvailable() && !info.isBasicAvailable())
1342	{
1343	com::GluePrintRCMessage(rc);
1344	RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
1345	}
1346	else
1347	GluePrintErrorInfo(info);
1348	break;
1349	}
1350
1351	rc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
1352	if (FAILED(rc))
1353	{
1354	RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", rc);
1355	break;
1356	}
1357	rc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
1358	if (FAILED(rc))
1359	{
1360	RTPrintf("Failed to get session object (rc=%Rhrc)!\n", rc);
1361	break;
1362	}
1363
1364	if (pcszSettingsPw)
1365	{
1366	CHECK_ERROR(virtualBox, SetSettingsSecret(Bstr(pcszSettingsPw).raw()));
1367	if (FAILED(rc))
1368	break;
1369	}
1370	else if (pcszSettingsPwFile)
1371	{
1372	int rcExit = settingsPasswordFile(virtualBox, pcszSettingsPwFile);
1373	if (rcExit != RTEXITCODE_SUCCESS)
1374	break;
1375	}
1376
1377	ComPtr<IMachine> m;
1378
1379	rc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
1380	if (FAILED(rc))
1381	{
1382	LogError("Invalid machine name or UUID!\n", rc);
1383	break;
1384	}
1385
1386	Bstr bstrVMId;
1387	rc = m->COMGETTER(Id)(bstrVMId.asOutParam());
1388	AssertComRC(rc);
1389	if (FAILED(rc))
1390	break;
1391	g_strVMUUID = bstrVMId;
1392
1393	Bstr bstrVMName;
1394	rc = m->COMGETTER(Name)(bstrVMName.asOutParam());
1395	AssertComRC(rc);
1396	if (FAILED(rc))
1397	break;
1398	g_strVMName = bstrVMName;
1399
1400	Log(("VBoxHeadless: Opening a session with machine (id={%s})...\n",
1401	g_strVMUUID.c_str()));
1402
1403	// set session name
1404	CHECK_ERROR_BREAK(session, COMSETTER(Name)(Bstr("headless").raw()));
1405	// open a session
1406	CHECK_ERROR_BREAK(m, LockMachine(session, LockType_VM));
1407	fSessionOpened = true;
1408
1409	/* get the console */
1410	ComPtr<IConsole> console;
1411	CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
1412
1413	/* get the mutable machine */
1414	CHECK_ERROR_BREAK(console, COMGETTER(Machine)(machine.asOutParam()));
1415
1416	ComPtr<IDisplay> display;
1417	CHECK_ERROR_BREAK(console, COMGETTER(Display)(display.asOutParam()));
1418
1419	#ifdef VBOX_WITH_RECORDING
1420	if (fRecordEnabled)
1421	{
1422	ComPtr<IRecordingSettings> recordingSettings;
1423	CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
1424	CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(TRUE));
1425
1426	SafeIfaceArray <IRecordingScreenSettings> saRecordScreenScreens;
1427	CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
1428
1429	/* Note: For now all screens have the same configuration. */
1430	for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
1431	{
1432	CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(TRUE));
1433	CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Filename)(Bstr(szRecordFilename).raw()));
1434	CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoWidth)(ulRecordVideoWidth));
1435	CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoHeight)(ulRecordVideoHeight));
1436	CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoRate)(ulRecordVideoRate));
1437	}
1438	}
1439	#endif /* defined(VBOX_WITH_RECORDING) */
1440
1441	/* get the machine debugger (isn't necessarily available) */
1442	ComPtr <IMachineDebugger> machineDebugger;
1443	console->COMGETTER(Debugger)(machineDebugger.asOutParam());
1444	if (machineDebugger)
1445	{
1446	Log(("Machine debugger available!\n"));
1447	}
1448
1449	if (fRawR0 != ~0U)
1450	{
1451	if (!machineDebugger)
1452	{
1453	RTPrintf("Error: No debugger object; -%srawr0 cannot be executed!\n", fRawR0 ? "" : "no");
1454	break;
1455	}
1456	machineDebugger->COMSETTER(RecompileSupervisor)(!fRawR0);
1457	}
1458	if (fRawR3 != ~0U)
1459	{
1460	if (!machineDebugger)
1461	{
1462	RTPrintf("Error: No debugger object; -%srawr3 cannot be executed!\n", fRawR3 ? "" : "no");
1463	break;
1464	}
1465	machineDebugger->COMSETTER(RecompileUser)(!fRawR3);
1466	}
1467	if (fPATM != ~0U)
1468	{
1469	if (!machineDebugger)
1470	{
1471	RTPrintf("Error: No debugger object; -%spatm cannot be executed!\n", fPATM ? "" : "no");
1472	break;
1473	}
1474	machineDebugger->COMSETTER(PATMEnabled)(fPATM);
1475	}
1476	if (fCSAM != ~0U)
1477	{
1478	if (!machineDebugger)
1479	{
1480	RTPrintf("Error: No debugger object; -%scsam cannot be executed!\n", fCSAM ? "" : "no");
1481	break;
1482	}
1483	machineDebugger->COMSETTER(CSAMEnabled)(fCSAM);
1484	}
1485
1486	/* initialize global references */
1487	gConsole = console;
1488	gEventQ = com::NativeEventQueue::getMainEventQueue();
1489
1490	/* VirtualBoxClient events registration. */
1491	{
1492	ComPtr<IEventSource> pES;
1493	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1494	ComObjPtr<VirtualBoxClientEventListenerImpl> listener;
1495	listener.createObject();
1496	listener->init(new VirtualBoxClientEventListener());
1497	vboxClientListener = listener;
1498	com::SafeArray<VBoxEventType_T> eventTypes;
1499	eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
1500	CHECK_ERROR(pES, RegisterListener(vboxClientListener, ComSafeArrayAsInParam(eventTypes), true));
1501	}
1502
1503	/* Console events registration. */
1504	{
1505	ComPtr<IEventSource> es;
1506	CHECK_ERROR(console, COMGETTER(EventSource)(es.asOutParam()));
1507	consoleListener.createObject();
1508	consoleListener->init(new ConsoleEventListener());
1509	com::SafeArray<VBoxEventType_T> eventTypes;
1510	eventTypes.push_back(VBoxEventType_OnMouseCapabilityChanged);
1511	eventTypes.push_back(VBoxEventType_OnStateChanged);
1512	eventTypes.push_back(VBoxEventType_OnVRDEServerInfoChanged);
1513	eventTypes.push_back(VBoxEventType_OnCanShowWindow);
1514	eventTypes.push_back(VBoxEventType_OnShowWindow);
1515	eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged);
1516	CHECK_ERROR(es, RegisterListener(consoleListener, ComSafeArrayAsInParam(eventTypes), true));
1517	}
1518
1519	/* Default is to use the VM setting for the VRDE server. */
1520	enum VRDEOption
1521	{
1522	VRDEOption_Config,
1523	VRDEOption_Off,
1524	VRDEOption_On
1525	};
1526	VRDEOption enmVRDEOption = VRDEOption_Config;
1527	BOOL fVRDEEnabled;
1528	ComPtr <IVRDEServer> vrdeServer;
1529	CHECK_ERROR_BREAK(machine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
1530	CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&fVRDEEnabled));
1531
1532	if (vrdeEnabled != NULL)
1533	{
1534	/* -vrde on\|off\|config */
1535	if (!strcmp(vrdeEnabled, "off") \|\| !strcmp(vrdeEnabled, "disable"))
1536	enmVRDEOption = VRDEOption_Off;
1537	else if (!strcmp(vrdeEnabled, "on") \|\| !strcmp(vrdeEnabled, "enable"))
1538	enmVRDEOption = VRDEOption_On;
1539	else if (strcmp(vrdeEnabled, "config"))
1540	{
1541	RTPrintf("-vrde requires an argument (on\|off\|config)\n");
1542	break;
1543	}
1544	}
1545
1546	Log(("VBoxHeadless: enmVRDE %d, fVRDEEnabled %d\n", enmVRDEOption, fVRDEEnabled));
1547
1548	if (enmVRDEOption != VRDEOption_Off)
1549	{
1550	/* Set other specified options. */
1551
1552	/* set VRDE port if requested by the user */
1553	if (vrdePort != NULL)
1554	{
1555	Bstr bstr = vrdePort;
1556	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.raw()));
1557	}
1558	/* set VRDE address if requested by the user */
1559	if (vrdeAddress != NULL)
1560	{
1561	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(vrdeAddress).raw()));
1562	}
1563
1564	/* Set VRDE properties. */
1565	if (cVRDEProperties > 0)
1566	{
1567	for (unsigned i = 0; i < cVRDEProperties; i++)
1568	{
1569	/* Parse 'name=value' */
1570	char *pszProperty = RTStrDup(aVRDEProperties[i]);
1571	if (pszProperty)
1572	{
1573	char *pDelimiter = strchr(pszProperty, '=');
1574	if (pDelimiter)
1575	{
1576	*pDelimiter = '\0';
1577
1578	Bstr bstrName = pszProperty;
1579	Bstr bstrValue = &pDelimiter[1];
1580	CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
1581	}
1582	else
1583	{
1584	RTPrintf("Error: Invalid VRDE property '%s'\n", aVRDEProperties[i]);
1585	RTStrFree(pszProperty);
1586	rc = E_INVALIDARG;
1587	break;
1588	}
1589	RTStrFree(pszProperty);
1590	}
1591	else
1592	{
1593	RTPrintf("Error: Failed to allocate memory for VRDE property '%s'\n", aVRDEProperties[i]);
1594	rc = E_OUTOFMEMORY;
1595	break;
1596	}
1597	}
1598	if (FAILED(rc))
1599	break;
1600	}
1601
1602	}
1603
1604	if (enmVRDEOption == VRDEOption_On)
1605	{
1606	/* enable VRDE server (only if currently disabled) */
1607	if (!fVRDEEnabled)
1608	{
1609	CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(TRUE));
1610	}
1611	}
1612	else if (enmVRDEOption == VRDEOption_Off)
1613	{
1614	/* disable VRDE server (only if currently enabled */
1615	if (fVRDEEnabled)
1616	{
1617	CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(FALSE));
1618	}
1619	}
1620
1621	/* Disable the host clipboard before powering up */
1622	console->COMSETTER(UseHostClipboard)(false);
1623
1624	Log(("VBoxHeadless: Powering up the machine...\n"));
1625
1626
1627	/**
1628	* @todo We should probably install handlers earlier so that
1629	* we can undo any temporary settings we do above in case of
1630	* an early signal and use RAII to ensure proper cleanup.
1631	*/
1632	#if !defined(RT_OS_WINDOWS)
1633	signal(SIGPIPE, SIG_IGN);
1634	signal(SIGTTOU, SIG_IGN);
1635
1636	struct sigaction sa;
1637	RT_ZERO(sa);
1638	sa.sa_handler = HandleSignal;
1639	sigaction(SIGHUP, &sa, NULL);
1640	sigaction(SIGINT, &sa, NULL);
1641	sigaction(SIGTERM, &sa, NULL);
1642	sigaction(SIGUSR1, &sa, NULL);
1643	sigaction(SIGUSR2, &sa, NULL);
1644	#else /* RT_OS_WINDOWS */
1645	/*
1646	* Register windows console signal handler to react to Ctrl-C,
1647	* Ctrl-Break, Close, non-interactive session termination.
1648	*/
1649	::SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
1650	#endif
1651
1652
1653	ComPtr <IProgress> progress;
1654	if (!fPaused)
1655	CHECK_ERROR_BREAK(console, PowerUp(progress.asOutParam()));
1656	else
1657	CHECK_ERROR_BREAK(console, PowerUpPaused(progress.asOutParam()));
1658
1659	rc = showProgress(progress);
1660	if (FAILED(rc))
1661	{
1662	com::ProgressErrorInfo info(progress);
1663	if (info.isBasicAvailable())
1664	{
1665	RTPrintf("Error: failed to start machine. Error message: %ls\n", info.getText().raw());
1666	}
1667	else
1668	{
1669	RTPrintf("Error: failed to start machine. No error message available!\n");
1670	}
1671	break;
1672	}
1673
1674	#ifdef RT_OS_WINDOWS
1675	/*
1676	* Spawn windows message pump to monitor session events.
1677	*/
1678	RTTHREAD hThrMsg;
1679	irc = RTThreadCreate(&hThrMsg,
1680	windowsMessageMonitor, NULL,
1681	0, /* :cbStack */
1682	RTTHREADTYPE_MSG_PUMP, 0,
1683	"MSG");
1684	if (RT_FAILURE(irc)) /* not fatal */
1685	LogRel(("VBoxHeadless: failed to start windows message monitor: %Rrc\n", irc));
1686	#endif /* RT_OS_WINDOWS */
1687
1688
1689	/*
1690	* Pump vbox events forever
1691	*/
1692	LogRel(("VBoxHeadless: starting event loop\n"));
1693	for (;;)
1694	{
1695	irc = gEventQ->processEventQueue(RT_INDEFINITE_WAIT);
1696
1697	/*
1698	* interruptEventQueueProcessing from another thread is
1699	* reported as VERR_INTERRUPTED, so check the flag first.
1700	*/
1701	if (g_fTerminateFE)
1702	{
1703	LogRel(("VBoxHeadless: processEventQueue: %Rrc, termination requested\n", irc));
1704	break;
1705	}
1706
1707	if (RT_FAILURE(irc))
1708	{
1709	LogRel(("VBoxHeadless: processEventQueue: %Rrc\n", irc));
1710	RTMsgError("event loop: %Rrc", irc);
1711	break;
1712	}
1713	}
1714
1715	Log(("VBoxHeadless: event loop has terminated...\n"));
1716
1717	#ifdef VBOX_WITH_RECORDING
1718	if (fRecordEnabled)
1719	{
1720	if (!machine.isNull())
1721	{
1722	ComPtr<IRecordingSettings> recordingSettings;
1723	CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
1724	CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(FALSE));
1725	}
1726	}
1727	#endif /* VBOX_WITH_RECORDING */
1728
1729	/* we don't have to disable VRDE here because we don't save the settings of the VM */
1730	}
1731	while (0);
1732
1733	/*
1734	* Get the machine state.
1735	*/
1736	MachineState_T machineState = MachineState_Aborted;
1737	if (!machine.isNull())
1738	{
1739	rc = machine->COMGETTER(State)(&machineState);
1740	if (SUCCEEDED(rc))
1741	Log(("machine state = %RU32\n", machineState));
1742	else
1743	Log(("IMachine::getState: %Rhrc\n", rc));
1744	}
1745	else
1746	{
1747	Log(("machine == NULL\n"));
1748	}
1749
1750	/*
1751	* Turn off the VM if it's running
1752	*/
1753	if ( gConsole
1754	&& ( machineState == MachineState_Running
1755	\|\| machineState == MachineState_Teleporting
1756	\|\| machineState == MachineState_LiveSnapshotting
1757	/** @todo power off paused VMs too? */
1758	)
1759	)
1760	do
1761	{
1762	consoleListener->getWrapped()->ignorePowerOffEvents(true);
1763
1764	ComPtr<IProgress> pProgress;
1765	if (!machine.isNull())
1766	CHECK_ERROR_BREAK(machine, SaveState(pProgress.asOutParam()));
1767	else
1768	CHECK_ERROR_BREAK(gConsole, PowerDown(pProgress.asOutParam()));
1769
1770	rc = showProgress(pProgress);
1771	if (FAILED(rc))
1772	{
1773	com::ErrorInfo info;
1774	if (!info.isFullAvailable() && !info.isBasicAvailable())
1775	com::GluePrintRCMessage(rc);
1776	else
1777	com::GluePrintErrorInfo(info);
1778	break;
1779	}
1780	} while (0);
1781
1782	/* VirtualBox callback unregistration. */
1783	if (vboxListener)
1784	{
1785	ComPtr<IEventSource> es;
1786	CHECK_ERROR(virtualBox, COMGETTER(EventSource)(es.asOutParam()));
1787	if (!es.isNull())
1788	CHECK_ERROR(es, UnregisterListener(vboxListener));
1789	vboxListener.setNull();
1790	}
1791
1792	/* Console callback unregistration. */
1793	if (consoleListener)
1794	{
1795	ComPtr<IEventSource> es;
1796	CHECK_ERROR(gConsole, COMGETTER(EventSource)(es.asOutParam()));
1797	if (!es.isNull())
1798	CHECK_ERROR(es, UnregisterListener(consoleListener));
1799	consoleListener.setNull();
1800	}
1801
1802	/* VirtualBoxClient callback unregistration. */
1803	if (vboxClientListener)
1804	{
1805	ComPtr<IEventSource> pES;
1806	CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1807	if (!pES.isNull())
1808	CHECK_ERROR(pES, UnregisterListener(vboxClientListener));
1809	vboxClientListener.setNull();
1810	}
1811
1812	/* No more access to the 'console' object, which will be uninitialized by the next session->Close call. */
1813	gConsole = NULL;
1814
1815	if (fSessionOpened)
1816	{
1817	/*
1818	* Close the session. This will also uninitialize the console and
1819	* unregister the callback we've registered before.
1820	*/
1821	Log(("VBoxHeadless: Closing the session...\n"));
1822	session->UnlockMachine();
1823	}
1824
1825	/* Must be before com::Shutdown */
1826	session.setNull();
1827	virtualBox.setNull();
1828	pVirtualBoxClient.setNull();
1829	machine.setNull();
1830
1831	com::Shutdown();
1832
1833	#ifdef RT_OS_WINDOWS
1834	/* tell the session monitor it can ack WM_ENDSESSION */
1835	if (g_hCanQuit != NIL_RTSEMEVENT)
1836	{
1837	RTSemEventSignal(g_hCanQuit);
1838	}
1839
1840	/* tell the session monitor to quit */
1841	if (g_hWindow != NULL)
1842	{
1843	::PostMessage(g_hWindow, WM_QUIT, 0, 0);
1844	}
1845	#endif
1846
1847	LogRel(("VBoxHeadless: exiting\n"));
1848	return FAILED(rc) ? 1 : 0;
1849	}
1850
1851
1852	#ifndef VBOX_WITH_HARDENING
1853	/**
1854	* Main entry point.
1855	*/
1856	int main(int argc, char argv, char envp)
1857	{
1858	// initialize VBox Runtime
1859	int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
1860	if (RT_FAILURE(rc))
1861	{
1862	RTPrintf("VBoxHeadless: Runtime Error:\n"
1863	" %Rrc -- %Rrf\n", rc, rc);
1864	switch (rc)
1865	{
1866	case VERR_VM_DRIVER_NOT_INSTALLED:
1867	RTPrintf("Cannot access the kernel driver. Make sure the kernel module has been \n"
1868	"loaded successfully. Aborting ...\n");
1869	break;
1870	default:
1871	break;
1872	}
1873	return 1;
1874	}
1875
1876	return TrustedMain(argc, argv, envp);
1877	}
1878	#endif /* !VBOX_WITH_HARDENING */

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

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

Download in other formats: