VirtualBox

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

Last change on this file since 54939 was 51618, checked in by vboxsync, 11 years ago

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