VirtualBox

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

Last change on this file since 78363 was 76553, checked in by vboxsync, 6 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette