VirtualBox

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

Last change on this file since 103068 was 99775, checked in by vboxsync, 15 months ago

*: Mark functions as static if not used outside of a given compilation unit. Enables the compiler to optimize inlining, reduces the symbol tables, exposes unused functions and in some rare cases exposes mismtaches between function declarations and definitions, but most importantly reduces the number of parfait reports for the extern-function-no-forward-declaration category. This should not result in any functional changes, bugref:3409

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 56.3 KB
Line 
1/* $Id: VBoxHeadless.cpp 99775 2023-05-12 12:21:58Z vboxsync $ */
2/** @file
3 * VBoxHeadless - The VirtualBox Headless frontend for running VMs on servers.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#include <VBox/com/com.h>
29#include <VBox/com/string.h>
30#include <VBox/com/array.h>
31#include <VBox/com/Guid.h>
32#include <VBox/com/ErrorInfo.h>
33#include <VBox/com/errorprint.h>
34#include <VBox/com/NativeEventQueue.h>
35
36#include <VBox/com/VirtualBox.h>
37#include <VBox/com/listeners.h>
38
39using namespace com;
40
41#define LOG_GROUP LOG_GROUP_GUI
42
43#include <VBox/log.h>
44#include <VBox/version.h>
45#include <iprt/buildconfig.h>
46#include <iprt/ctype.h>
47#include <iprt/initterm.h>
48#include <iprt/message.h>
49#include <iprt/semaphore.h>
50#include <iprt/path.h>
51#include <iprt/stream.h>
52#include <iprt/ldr.h>
53#include <iprt/getopt.h>
54#include <iprt/env.h>
55#include <iprt/errcore.h>
56#include <iprt/thread.h>
57#include <VBoxVideo.h>
58
59#ifdef VBOX_WITH_RECORDING
60# include <cstdlib>
61# include <iprt/process.h>
62#endif
63
64#if defined(RT_OS_LINUX) || defined(RT_OS_DARWIN) || defined(RT_OS_SOLARIS)
65# include <cerrno>
66#endif
67
68#ifdef RT_OS_DARWIN
69# include <iprt/asm.h>
70# include <dlfcn.h>
71# include <sys/mman.h>
72#endif
73
74#if !defined(RT_OS_WINDOWS)
75# include <signal.h>
76# include <unistd.h>
77# include <sys/uio.h>
78#endif
79
80#include "PasswordInput.h"
81
82////////////////////////////////////////////////////////////////////////////////
83
84#define LogError(m,rc) \
85 do { \
86 Log(("VBoxHeadless: ERROR: " m " [rc=0x%08X]\n", rc)); \
87 RTPrintf("%s\n", m); \
88 } while (0)
89
90////////////////////////////////////////////////////////////////////////////////
91
92/* global weak references (for event handlers) */
93static IConsole *gConsole = NULL;
94static NativeEventQueue *gEventQ = NULL;
95/** Inidcates whether gEventQ can safely be used or not. */
96static volatile bool g_fEventQueueSafe = false;
97
98/* keep this handy for messages */
99static com::Utf8Str g_strVMName;
100static com::Utf8Str g_strVMUUID;
101
102/** flag whether frontend should terminate */
103static volatile bool g_fTerminateFE = false;
104
105////////////////////////////////////////////////////////////////////////////////
106
107/**
108 * Handler for VirtualBoxClient events.
109 */
110class VirtualBoxClientEventListener
111{
112public:
113 VirtualBoxClientEventListener()
114 {
115 }
116
117 virtual ~VirtualBoxClientEventListener()
118 {
119 }
120
121 HRESULT init()
122 {
123 return S_OK;
124 }
125
126 void uninit()
127 {
128 }
129
130 STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
131 {
132 switch (aType)
133 {
134 case VBoxEventType_OnVBoxSVCAvailabilityChanged:
135 {
136 ComPtr<IVBoxSVCAvailabilityChangedEvent> pVSACEv = aEvent;
137 Assert(pVSACEv);
138 BOOL fAvailable = FALSE;
139 pVSACEv->COMGETTER(Available)(&fAvailable);
140 if (!fAvailable)
141 {
142 LogRel(("VBoxHeadless: VBoxSVC became unavailable, exiting.\n"));
143 RTPrintf("VBoxSVC became unavailable, exiting.\n");
144 /* Terminate the VM as cleanly as possible given that VBoxSVC
145 * is no longer present. */
146 g_fTerminateFE = true;
147 gEventQ->interruptEventQueueProcessing();
148 }
149 break;
150 }
151 default:
152 AssertFailed();
153 }
154
155 return S_OK;
156 }
157
158private:
159};
160
161/**
162 * Handler for machine events.
163 */
164class ConsoleEventListener
165{
166public:
167 ConsoleEventListener() :
168 mLastVRDEPort(-1),
169 m_fIgnorePowerOffEvents(false),
170 m_fNoLoggedInUsers(true)
171 {
172 }
173
174 virtual ~ConsoleEventListener()
175 {
176 }
177
178 HRESULT init()
179 {
180 return S_OK;
181 }
182
183 void uninit()
184 {
185 }
186
187 STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
188 {
189 switch (aType)
190 {
191 case VBoxEventType_OnMouseCapabilityChanged:
192 {
193
194 ComPtr<IMouseCapabilityChangedEvent> mccev = aEvent;
195 Assert(!mccev.isNull());
196
197 BOOL fSupportsAbsolute = false;
198 mccev->COMGETTER(SupportsAbsolute)(&fSupportsAbsolute);
199
200 /* Emit absolute mouse event to actually enable the host mouse cursor. */
201 if (fSupportsAbsolute && gConsole)
202 {
203 ComPtr<IMouse> mouse;
204 gConsole->COMGETTER(Mouse)(mouse.asOutParam());
205 if (mouse)
206 {
207 mouse->PutMouseEventAbsolute(-1, -1, 0, 0 /* Horizontal wheel */, 0);
208 }
209 }
210 break;
211 }
212 case VBoxEventType_OnStateChanged:
213 {
214 ComPtr<IStateChangedEvent> scev = aEvent;
215 Assert(scev);
216
217 MachineState_T machineState;
218 scev->COMGETTER(State)(&machineState);
219
220 /* Terminate any event wait operation if the machine has been
221 * PoweredDown/Saved/Aborted. */
222 if (machineState < MachineState_Running && !m_fIgnorePowerOffEvents)
223 {
224 g_fTerminateFE = true;
225 gEventQ->interruptEventQueueProcessing();
226 }
227
228 break;
229 }
230 case VBoxEventType_OnVRDEServerInfoChanged:
231 {
232 ComPtr<IVRDEServerInfoChangedEvent> rdicev = aEvent;
233 Assert(rdicev);
234
235 if (gConsole)
236 {
237 ComPtr<IVRDEServerInfo> info;
238 gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
239 if (info)
240 {
241 LONG port;
242 info->COMGETTER(Port)(&port);
243 if (port != mLastVRDEPort)
244 {
245 if (port == -1)
246 RTPrintf("VRDE server is inactive.\n");
247 else if (port == 0)
248 RTPrintf("VRDE server failed to start.\n");
249 else
250 RTPrintf("VRDE server is listening on port %d.\n", port);
251
252 mLastVRDEPort = port;
253 }
254 }
255 }
256 break;
257 }
258 case VBoxEventType_OnCanShowWindow:
259 {
260 ComPtr<ICanShowWindowEvent> cswev = aEvent;
261 Assert(cswev);
262 cswev->AddVeto(NULL);
263 break;
264 }
265 case VBoxEventType_OnShowWindow:
266 {
267 ComPtr<IShowWindowEvent> swev = aEvent;
268 Assert(swev);
269 /* Ignore the event, WinId is either still zero or some other listener assigned it. */
270 NOREF(swev); /* swev->COMSETTER(WinId)(0); */
271 break;
272 }
273 case VBoxEventType_OnGuestPropertyChanged:
274 {
275 ComPtr<IGuestPropertyChangedEvent> pChangedEvent = aEvent;
276 Assert(pChangedEvent);
277
278 HRESULT hrc;
279
280 ComPtr <IMachine> pMachine;
281 if (gConsole)
282 {
283 hrc = gConsole->COMGETTER(Machine)(pMachine.asOutParam());
284 if (FAILED(hrc) || !pMachine)
285 hrc = VBOX_E_OBJECT_NOT_FOUND;
286 }
287 else
288 hrc = VBOX_E_INVALID_VM_STATE;
289
290 if (SUCCEEDED(hrc))
291 {
292 Bstr strKey;
293 hrc = pChangedEvent->COMGETTER(Name)(strKey.asOutParam());
294 AssertComRC(hrc);
295
296 Bstr strValue;
297 hrc = pChangedEvent->COMGETTER(Value)(strValue.asOutParam());
298 AssertComRC(hrc);
299
300 Utf8Str utf8Key = strKey;
301 Utf8Str utf8Value = strValue;
302 LogRelFlow(("Guest property \"%s\" has been changed to \"%s\"\n",
303 utf8Key.c_str(), utf8Value.c_str()));
304
305 if (utf8Key.equals("/VirtualBox/GuestInfo/OS/NoLoggedInUsers"))
306 {
307 LogRelFlow(("Guest indicates that there %s logged in users\n",
308 utf8Value.equals("true") ? "are no" : "are"));
309
310 /* Check if this is our machine and the "disconnect on logout feature" is enabled. */
311 BOOL fProcessDisconnectOnGuestLogout = FALSE;
312
313 /* Does the machine handle VRDP disconnects? */
314 Bstr strDiscon;
315 hrc = pMachine->GetExtraData(Bstr("VRDP/DisconnectOnGuestLogout").raw(),
316 strDiscon.asOutParam());
317 if (SUCCEEDED(hrc))
318 {
319 Utf8Str utf8Discon = strDiscon;
320 fProcessDisconnectOnGuestLogout = utf8Discon.equals("1")
321 ? TRUE : FALSE;
322 }
323
324 LogRelFlow(("VRDE: hrc=%Rhrc: Host %s disconnecting clients (current host state known: %s)\n",
325 hrc, fProcessDisconnectOnGuestLogout ? "will handle" : "does not handle",
326 m_fNoLoggedInUsers ? "No users logged in" : "Users logged in"));
327
328 if (fProcessDisconnectOnGuestLogout)
329 {
330 bool fDropConnection = false;
331 if (!m_fNoLoggedInUsers) /* Only if the property really changes. */
332 {
333 if ( utf8Value == "true"
334 /* Guest property got deleted due to reset,
335 * so it has no value anymore. */
336 || utf8Value.isEmpty())
337 {
338 m_fNoLoggedInUsers = true;
339 fDropConnection = true;
340 }
341 }
342 else if (utf8Value == "false")
343 m_fNoLoggedInUsers = false;
344 /* Guest property got deleted due to reset,
345 * take the shortcut without touching the m_fNoLoggedInUsers
346 * state. */
347 else if (utf8Value.isEmpty())
348 fDropConnection = true;
349
350 LogRelFlow(("VRDE: szNoLoggedInUsers=%s, m_fNoLoggedInUsers=%RTbool, fDropConnection=%RTbool\n",
351 utf8Value.c_str(), m_fNoLoggedInUsers, fDropConnection));
352
353 if (fDropConnection)
354 {
355 /* If there is a connection, drop it. */
356 ComPtr<IVRDEServerInfo> info;
357 hrc = gConsole->COMGETTER(VRDEServerInfo)(info.asOutParam());
358 if (SUCCEEDED(hrc) && info)
359 {
360 ULONG cClients = 0;
361 hrc = info->COMGETTER(NumberOfClients)(&cClients);
362
363 LogRelFlow(("VRDE: connected clients=%RU32\n", cClients));
364 if (SUCCEEDED(hrc) && cClients > 0)
365 {
366 ComPtr <IVRDEServer> vrdeServer;
367 hrc = pMachine->COMGETTER(VRDEServer)(vrdeServer.asOutParam());
368 if (SUCCEEDED(hrc) && vrdeServer)
369 {
370 LogRel(("VRDE: the guest user has logged out, disconnecting remote clients.\n"));
371 hrc = vrdeServer->COMSETTER(Enabled)(FALSE);
372 AssertComRC(hrc);
373 HRESULT hrc2 = vrdeServer->COMSETTER(Enabled)(TRUE);
374 if (SUCCEEDED(hrc))
375 hrc = hrc2;
376 }
377 }
378 }
379 }
380 }
381 }
382
383 if (FAILED(hrc))
384 LogRelFlow(("VRDE: returned error=%Rhrc\n", hrc));
385 }
386
387 break;
388 }
389
390 default:
391 AssertFailed();
392 }
393 return S_OK;
394 }
395
396 void ignorePowerOffEvents(bool fIgnore)
397 {
398 m_fIgnorePowerOffEvents = fIgnore;
399 }
400
401private:
402
403 long mLastVRDEPort;
404 bool m_fIgnorePowerOffEvents;
405 bool m_fNoLoggedInUsers;
406};
407
408typedef ListenerImpl<VirtualBoxClientEventListener> VirtualBoxClientEventListenerImpl;
409typedef ListenerImpl<ConsoleEventListener> ConsoleEventListenerImpl;
410
411VBOX_LISTENER_DECLARE(VirtualBoxClientEventListenerImpl)
412VBOX_LISTENER_DECLARE(ConsoleEventListenerImpl)
413
414#if !defined(RT_OS_WINDOWS)
415
416/** Signals we handle. */
417static int const g_aiSigs[] = { SIGHUP, SIGINT, SIGTERM, SIGUSR1 };
418
419/** The signal handler. */
420static void HandleSignal(int sig)
421{
422# if 1
423 struct iovec aSegs[8];
424 int cSegs = 0;
425 aSegs[cSegs++].iov_base = (char *)"VBoxHeadless: signal ";
426 aSegs[cSegs++].iov_base = (char *)strsignal(sig);
427 const char *pszThread = RTThreadSelfName();
428 if (pszThread)
429 {
430 aSegs[cSegs++].iov_base = (char *)"(on thread ";
431 aSegs[cSegs++].iov_base = (char *)pszThread;
432 aSegs[cSegs++].iov_base = (char *)")\n";
433 }
434 else
435 aSegs[cSegs++].iov_base = (char *)"\n";
436 for (int i = 0; i < cSegs; i++)
437 aSegs[i].iov_len = strlen((const char *)aSegs[i].iov_base);
438 ssize_t ignored = writev(2, aSegs, cSegs); RT_NOREF_PV(ignored);
439# else
440 LogRel(("VBoxHeadless: received signal %d\n", sig)); /** @todo r=bird: This is not at all safe. */
441# endif
442 g_fTerminateFE = true;
443}
444
445# ifdef RT_OS_DARWIN
446
447/* For debugging. */
448uint32_t GetSignalMask(void)
449{
450 /* For some totally messed up reason, the xnu sigprocmask actually returns
451 the signal mask of the calling thread rather than the process one
452 (p_sigmask), so can call sigprocmask just as well as pthread_sigmask here. */
453 sigset_t Sigs;
454 RT_ZERO(Sigs);
455 sigprocmask(SIG_UNBLOCK, NULL, &Sigs);
456 RTMsgInfo("debug: thread %s mask: %.*Rhxs\n", RTThreadSelfName(), sizeof(Sigs), &Sigs);
457 for (int i = 0; i < 32; i++)
458 if (sigismember(&Sigs, i)) RTMsgInfo("debug: sig %2d blocked: %s\n", i, strsignal(i));
459 return *(uint32_t const *)&Sigs;
460}
461
462/**
463 * Blocks or unblocks the signals we handle.
464 *
465 * @note Only for darwin does fProcess make a difference, all others always
466 * work on the calling thread regardless of the flag value.
467 */
468static void SetSignalMask(bool fBlock, bool fProcess)
469{
470 sigset_t Sigs;
471 sigemptyset(&Sigs);
472 for (unsigned i = 0; i < RT_ELEMENTS(g_aiSigs); i++)
473 sigaddset(&Sigs, g_aiSigs[i]);
474 if (fProcess)
475 {
476 if (sigprocmask(fBlock ? SIG_BLOCK : SIG_UNBLOCK, &Sigs, NULL) != 0)
477 RTMsgError("sigprocmask failed: %d", errno);
478 }
479 else
480 {
481 if (pthread_sigmask(fBlock ? SIG_BLOCK : SIG_UNBLOCK, &Sigs, NULL) != 0)
482 RTMsgError("pthread_sigmask failed: %d", errno);
483 }
484}
485
486/**
487 * @callback_method_impl{FNRTTHREAD, Signal wait thread}
488 */
489static DECLCALLBACK(int) SigThreadProc(RTTHREAD hThreadSelf, void *pvUser)
490{
491 RT_NOREF(hThreadSelf, pvUser);
492
493 /* The signals to wait for: */
494 sigset_t SigSetWait;
495 sigemptyset(&SigSetWait);
496 for (unsigned i = 0; i < RT_ELEMENTS(g_aiSigs); i++)
497 sigaddset(&SigSetWait, g_aiSigs[i]);
498
499 /* The wait + processing loop: */
500 for (;;)
501 {
502 int iSignal = -1;
503 if (sigwait(&SigSetWait, &iSignal) == 0)
504 {
505 LogRel(("VBoxHeadless: Caught signal: %s\n", strsignal(iSignal)));
506 RTMsgInfo("");
507 RTMsgInfo("Caught signal: %s", strsignal(iSignal));
508 g_fTerminateFE = true;
509 }
510
511 if (g_fTerminateFE && g_fEventQueueSafe && gEventQ != NULL)
512 gEventQ->interruptEventQueueProcessing();
513 }
514}
515
516/** The handle to the signal wait thread. */
517static RTTHREAD g_hSigThread = NIL_RTTHREAD;
518
519# endif /* RT_OS_DARWIN */
520
521static void SetUpSignalHandlers(void)
522{
523 signal(SIGPIPE, SIG_IGN);
524 signal(SIGTTOU, SIG_IGN);
525
526 /* Don't touch SIGUSR2 as IPRT could be using it for RTThreadPoke(). */
527 for (unsigned i = 0; i < RT_ELEMENTS(g_aiSigs); i++)
528 {
529 struct sigaction sa;
530 RT_ZERO(sa);
531 sa.sa_handler = HandleSignal;
532 if (sigaction(g_aiSigs[i], &sa, NULL) != 0)
533 RTMsgError("sigaction failed for signal #%u: %d", g_aiSigs[i], errno);
534 }
535
536# if defined(RT_OS_DARWIN)
537 /*
538 * On darwin processEventQueue() does not return with VERR_INTERRUPTED or
539 * similar if a signal arrives while we're waiting for events. So, in
540 * order to respond promptly to signals after they arrives, we use a
541 * dedicated thread for fielding the signals and poking the event queue
542 * after each signal.
543 *
544 * We block the signals for all threads (this is fine as the p_sigmask
545 * isn't actually used for anything at all and wont prevent signal
546 * delivery). The signal thread should have them blocked as well, as it
547 * uses sigwait to do the waiting (better than sigsuspend, as we can safely
548 * LogRel the signal this way).
549 */
550 if (g_hSigThread == NIL_RTTHREAD)
551 {
552 SetSignalMask(true /*fBlock */, true /*fProcess*/);
553 int vrc = RTThreadCreate(&g_hSigThread, SigThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, 0, "SigWait");
554 if (RT_FAILURE(vrc))
555 {
556 RTMsgError("Failed to create signal waiter thread: %Rrc", vrc);
557 SetSignalMask(false /*fBlock */, false /*fProcess*/);
558 }
559 }
560# endif
561}
562
563#endif /* !RT_OS_WINDOWS */
564
565////////////////////////////////////////////////////////////////////////////////
566
567static void show_usage()
568{
569 RTPrintf("Usage:\n"
570 " -s, -startvm, --startvm <name|uuid> Start given VM (required argument)\n"
571 " -v, -vrde, --vrde on|off|config Enable or disable the VRDE server\n"
572 " or don't change the setting (default)\n"
573 " -e, -vrdeproperty, --vrdeproperty <name=[value]> Set a VRDE property:\n"
574 " \"TCP/Ports\" - comma-separated list of\n"
575 " ports the VRDE server can bind to; dash\n"
576 " between two port numbers specifies range\n"
577 " \"TCP/Address\" - interface IP the VRDE\n"
578 " server will bind to\n"
579 " --settingspw <pw> Specify the VirtualBox settings password\n"
580 " --settingspwfile <file> Specify a file containing the\n"
581 " VirtualBox settings password\n"
582 " --password <file>|- Specify the VM password. Either file containing\n"
583 " the VM password or \"-\" to read it from console\n"
584 " --password-id <id> Specify the password id for the VM password\n"
585 " -start-paused, --start-paused Start the VM in paused state\n"
586#ifdef VBOX_WITH_RECORDING
587 " -c, -record, --record Record the VM screen output to a file\n"
588 " -w, --videowidth Video frame width when recording\n"
589 " -h, --videoheight Video frame height when recording\n"
590 " -r, --videobitrate Recording bit rate when recording\n"
591 " -f, --filename File name when recording. The codec used\n"
592 " will be chosen based on file extension\n"
593#endif
594 "\n");
595}
596
597#ifdef VBOX_WITH_RECORDING
598/**
599 * Parse the environment for variables which can influence the VIDEOREC settings.
600 * purely for backwards compatibility.
601 * @param pulFrameWidth may be updated with a desired frame width
602 * @param pulFrameHeight may be updated with a desired frame height
603 * @param pulBitRate may be updated with a desired bit rate
604 * @param ppszFilename may be updated with a desired file name
605 */
606static void parse_environ(uint32_t *pulFrameWidth, uint32_t *pulFrameHeight,
607 uint32_t *pulBitRate, const char **ppszFilename)
608{
609 const char *pszEnvTemp;
610/** @todo r=bird: This isn't up to scratch. The life time of an RTEnvGet
611 * return value is only up to the next RTEnv*, *getenv, *putenv,
612 * setenv call in _any_ process in the system and the it has known and
613 * documented code page issues.
614 *
615 * Use RTEnvGetEx instead! */
616 if ((pszEnvTemp = RTEnvGet("VBOX_RECORDWIDTH")) != 0)
617 {
618 errno = 0;
619 unsigned long ulFrameWidth = strtoul(pszEnvTemp, 0, 10);
620 if (errno != 0)
621 LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDWIDTH environment variable", 0);
622 else
623 *pulFrameWidth = ulFrameWidth;
624 }
625 if ((pszEnvTemp = RTEnvGet("VBOX_RECORDHEIGHT")) != 0)
626 {
627 errno = 0;
628 unsigned long ulFrameHeight = strtoul(pszEnvTemp, 0, 10);
629 if (errno != 0)
630 LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDHEIGHT environment variable", 0);
631 else
632 *pulFrameHeight = ulFrameHeight;
633 }
634 if ((pszEnvTemp = RTEnvGet("VBOX_RECORDBITRATE")) != 0)
635 {
636 errno = 0;
637 unsigned long ulBitRate = strtoul(pszEnvTemp, 0, 10);
638 if (errno != 0)
639 LogError("VBoxHeadless: ERROR: invalid VBOX_RECORDBITRATE environment variable", 0);
640 else
641 *pulBitRate = ulBitRate;
642 }
643 if ((pszEnvTemp = RTEnvGet("VBOX_RECORDFILE")) != 0)
644 *ppszFilename = pszEnvTemp;
645}
646#endif /* VBOX_WITH_RECORDING defined */
647
648
649#ifdef RT_OS_WINDOWS
650
651#define MAIN_WND_CLASS L"VirtualBox Headless Interface"
652
653HINSTANCE g_hInstance = NULL;
654HWND g_hWindow = NULL;
655RTSEMEVENT g_hCanQuit;
656
657static DECLCALLBACK(int) windowsMessageMonitor(RTTHREAD ThreadSelf, void *pvUser);
658static int createWindow();
659static LRESULT CALLBACK WinMainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
660static void destroyWindow();
661
662
663static DECLCALLBACK(int)
664windowsMessageMonitor(RTTHREAD ThreadSelf, void *pvUser)
665{
666 RT_NOREF(ThreadSelf, pvUser);
667 int rc;
668
669 rc = createWindow();
670 if (RT_FAILURE(rc))
671 return rc;
672
673 RTSemEventCreate(&g_hCanQuit);
674
675 MSG msg;
676 BOOL b;
677 while ((b = ::GetMessage(&msg, 0, 0, 0)) > 0)
678 {
679 ::TranslateMessage(&msg);
680 ::DispatchMessage(&msg);
681 }
682
683 if (b < 0)
684 LogRel(("VBoxHeadless: GetMessage failed\n"));
685
686 destroyWindow();
687 return VINF_SUCCESS;
688}
689
690
691static int
692createWindow()
693{
694 /* program instance handle */
695 g_hInstance = (HINSTANCE)::GetModuleHandle(NULL);
696 if (g_hInstance == NULL)
697 {
698 LogRel(("VBoxHeadless: failed to obtain module handle\n"));
699 return VERR_GENERAL_FAILURE;
700 }
701
702 /* window class */
703 WNDCLASS wc;
704 RT_ZERO(wc);
705
706 wc.style = CS_NOCLOSE;
707 wc.lpfnWndProc = WinMainWndProc;
708 wc.hInstance = g_hInstance;
709 wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1);
710 wc.lpszClassName = MAIN_WND_CLASS;
711
712 ATOM atomWindowClass = ::RegisterClass(&wc);
713 if (atomWindowClass == 0)
714 {
715 LogRel(("VBoxHeadless: failed to register window class\n"));
716 return VERR_GENERAL_FAILURE;
717 }
718
719 /* secret window, secret garden */
720 g_hWindow = ::CreateWindowEx(0, MAIN_WND_CLASS, MAIN_WND_CLASS, 0,
721 0, 0, 1, 1, NULL, NULL, g_hInstance, NULL);
722 if (g_hWindow == NULL)
723 {
724 LogRel(("VBoxHeadless: failed to create window\n"));
725 return VERR_GENERAL_FAILURE;
726 }
727
728 return VINF_SUCCESS;
729}
730
731
732static void
733destroyWindow()
734{
735 if (g_hWindow == NULL)
736 return;
737
738 ::DestroyWindow(g_hWindow);
739 g_hWindow = NULL;
740
741 if (g_hInstance == NULL)
742 return;
743
744 ::UnregisterClass(MAIN_WND_CLASS, g_hInstance);
745 g_hInstance = NULL;
746}
747
748
749static LRESULT CALLBACK
750WinMainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
751{
752 int rc;
753
754 LRESULT lResult = 0;
755 switch (msg)
756 {
757 case WM_QUERYENDSESSION:
758 LogRel(("VBoxHeadless: WM_QUERYENDSESSION:%s%s%s%s (0x%08lx)\n",
759 lParam == 0 ? " shutdown" : "",
760 lParam & ENDSESSION_CRITICAL ? " critical" : "",
761 lParam & ENDSESSION_LOGOFF ? " logoff" : "",
762 lParam & ENDSESSION_CLOSEAPP ? " close" : "",
763 (unsigned long)lParam));
764
765 /* do not block windows session termination */
766 lResult = TRUE;
767 break;
768
769 case WM_ENDSESSION:
770 lResult = 0;
771 LogRel(("WM_ENDSESSION:%s%s%s%s%s (%s/0x%08lx)\n",
772 lParam == 0 ? " shutdown" : "",
773 lParam & ENDSESSION_CRITICAL ? " critical" : "",
774 lParam & ENDSESSION_LOGOFF ? " logoff" : "",
775 lParam & ENDSESSION_CLOSEAPP ? " close" : "",
776 wParam == FALSE ? " cancelled" : "",
777 wParam ? "TRUE" : "FALSE",
778 (unsigned long)lParam));
779 if (wParam == FALSE)
780 break;
781
782 /* tell the user what we are doing */
783 ::ShutdownBlockReasonCreate(hwnd,
784 com::BstrFmt("%s saving state",
785 g_strVMName.c_str()).raw());
786
787 /* tell the VM to save state/power off */
788 g_fTerminateFE = true;
789 if (g_fEventQueueSafe && gEventQ != NULL)
790 gEventQ->interruptEventQueueProcessing();
791
792 if (g_hCanQuit != NIL_RTSEMEVENT)
793 {
794 LogRel(("VBoxHeadless: WM_ENDSESSION: waiting for VM termination...\n"));
795
796 rc = RTSemEventWait(g_hCanQuit, RT_INDEFINITE_WAIT);
797 if (RT_SUCCESS(rc))
798 LogRel(("VBoxHeadless: WM_ENDSESSION: done\n"));
799 else
800 LogRel(("VBoxHeadless: WM_ENDSESSION: failed to wait for VM termination: %Rrc\n", rc));
801 }
802 else
803 {
804 LogRel(("VBoxHeadless: WM_ENDSESSION: cannot wait for VM termination\n"));
805 }
806 break;
807
808 default:
809 lResult = ::DefWindowProc(hwnd, msg, wParam, lParam);
810 break;
811 }
812 return lResult;
813}
814
815
816static const char * const g_apszCtrlEventNames[] =
817{
818 "CTRL_C_EVENT",
819 "CTRL_BREAK_EVENT",
820 "CTRL_CLOSE_EVENT",
821 /* reserved, not used */
822 "<console control event 3>",
823 "<console control event 4>",
824 /* not sent to processes that load gdi32.dll or user32.dll */
825 "CTRL_LOGOFF_EVENT",
826 "CTRL_SHUTDOWN_EVENT",
827};
828
829
830BOOL WINAPI
831ConsoleCtrlHandler(DWORD dwCtrlType) RT_NOTHROW_DEF
832{
833 const char *pszSigName;
834 char szNameBuf[48];
835 if (dwCtrlType < RT_ELEMENTS(g_apszCtrlEventNames))
836 pszSigName = g_apszCtrlEventNames[dwCtrlType];
837 else
838 {
839 /* should not happen, but be prepared */
840 RTStrPrintf(szNameBuf, sizeof(szNameBuf), "<console control event %u>", dwCtrlType);
841 pszSigName = szNameBuf;
842 }
843
844 LogRel(("VBoxHeadless: got %s\n", pszSigName));
845 RTMsgInfo("Got %s", pszSigName);
846 RTMsgInfo("");
847
848 /* tell the VM to save state/power off */
849 g_fTerminateFE = true;
850 if (g_fEventQueueSafe && gEventQ != NULL)
851 gEventQ->interruptEventQueueProcessing();
852
853 /*
854 * We don't need to wait for Ctrl-C / Ctrl-Break, but we must wait
855 * for Close, or we will be killed before the VM is saved.
856 */
857 if (g_hCanQuit != NIL_RTSEMEVENT)
858 {
859 LogRel(("VBoxHeadless: waiting for VM termination...\n"));
860
861 int rc = RTSemEventWait(g_hCanQuit, RT_INDEFINITE_WAIT);
862 if (RT_FAILURE(rc))
863 LogRel(("VBoxHeadless: Failed to wait for VM termination: %Rrc\n", rc));
864 }
865
866 /* tell the system we handled it */
867 LogRel(("VBoxHeadless: ConsoleCtrlHandler: return\n"));
868 return TRUE;
869}
870#endif /* RT_OS_WINDOWS */
871
872
873/*
874 * Simplified version of showProgress() borrowed from VBoxManage.
875 * Note that machine power up/down operations are not cancelable, so
876 * we don't bother checking for signals.
877 */
878static HRESULT
879showProgress(const ComPtr<IProgress> &progress)
880{
881 BOOL fCompleted = FALSE;
882 ULONG ulLastPercent = 0;
883 ULONG ulCurrentPercent = 0;
884 HRESULT hrc;
885
886 com::Bstr bstrDescription;
887 hrc = progress->COMGETTER(Description(bstrDescription.asOutParam()));
888 if (FAILED(hrc))
889 {
890 RTStrmPrintf(g_pStdErr, "Failed to get progress description: %Rhrc\n", hrc);
891 return hrc;
892 }
893
894 RTStrmPrintf(g_pStdErr, "%ls: ", bstrDescription.raw());
895 RTStrmFlush(g_pStdErr);
896
897 hrc = progress->COMGETTER(Completed(&fCompleted));
898 while (SUCCEEDED(hrc))
899 {
900 progress->COMGETTER(Percent(&ulCurrentPercent));
901
902 /* did we cross a 10% mark? */
903 if (ulCurrentPercent / 10 > ulLastPercent / 10)
904 {
905 /* make sure to also print out missed steps */
906 for (ULONG curVal = (ulLastPercent / 10) * 10 + 10; curVal <= (ulCurrentPercent / 10) * 10; curVal += 10)
907 {
908 if (curVal < 100)
909 {
910 RTStrmPrintf(g_pStdErr, "%u%%...", curVal);
911 RTStrmFlush(g_pStdErr);
912 }
913 }
914 ulLastPercent = (ulCurrentPercent / 10) * 10;
915 }
916
917 if (fCompleted)
918 break;
919
920 gEventQ->processEventQueue(500);
921 hrc = progress->COMGETTER(Completed(&fCompleted));
922 }
923
924 /* complete the line. */
925 LONG iRc = E_FAIL;
926 hrc = progress->COMGETTER(ResultCode)(&iRc);
927 if (SUCCEEDED(hrc))
928 {
929 if (SUCCEEDED(iRc))
930 RTStrmPrintf(g_pStdErr, "100%%\n");
931#if 0
932 else if (g_fCanceled)
933 RTStrmPrintf(g_pStdErr, "CANCELED\n");
934#endif
935 else
936 {
937 RTStrmPrintf(g_pStdErr, "\n");
938 RTStrmPrintf(g_pStdErr, "Operation failed: %Rhrc\n", iRc);
939 }
940 hrc = iRc;
941 }
942 else
943 {
944 RTStrmPrintf(g_pStdErr, "\n");
945 RTStrmPrintf(g_pStdErr, "Failed to obtain operation result: %Rhrc\n", hrc);
946 }
947 RTStrmFlush(g_pStdErr);
948 return hrc;
949}
950
951
952/**
953 * Entry point.
954 */
955extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
956{
957 RT_NOREF(envp);
958 const char *vrdePort = NULL;
959 const char *vrdeAddress = NULL;
960 const char *vrdeEnabled = NULL;
961 unsigned cVRDEProperties = 0;
962 const char *apszVRDEProperties[16];
963 unsigned fPaused = 0;
964#ifdef VBOX_WITH_RECORDING
965 bool fRecordEnabled = false;
966 uint32_t ulRecordVideoWidth = 800;
967 uint32_t ulRecordVideoHeight = 600;
968 uint32_t ulRecordVideoRate = 300000;
969 char szRecordFilename[RTPATH_MAX];
970 const char *pszRecordFilenameTemplate = "VBox-%d.webm"; /* .webm container by default. */
971#endif /* VBOX_WITH_RECORDING */
972#ifdef RT_OS_WINDOWS
973 ATL::CComModule _Module; /* Required internally by ATL (constructor records instance in global variable). */
974#endif
975
976 LogFlow(("VBoxHeadless STARTED.\n"));
977 RTPrintf(VBOX_PRODUCT " Headless Interface " VBOX_VERSION_STRING "\n"
978 "Copyright (C) 2008-" VBOX_C_YEAR " " VBOX_VENDOR "\n\n");
979
980#ifdef VBOX_WITH_RECORDING
981 /* Parse the environment */
982 parse_environ(&ulRecordVideoWidth, &ulRecordVideoHeight, &ulRecordVideoRate, &pszRecordFilenameTemplate);
983#endif
984
985 enum eHeadlessOptions
986 {
987 OPT_SETTINGSPW = 0x100,
988 OPT_SETTINGSPW_FILE,
989 OPT_COMMENT,
990 OPT_PAUSED,
991 OPT_VMPW,
992 OPT_VMPWID
993 };
994
995 static const RTGETOPTDEF s_aOptions[] =
996 {
997 { "-startvm", 's', RTGETOPT_REQ_STRING },
998 { "--startvm", 's', RTGETOPT_REQ_STRING },
999 { "-vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1000 { "--vrdpport", 'p', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1001 { "-vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1002 { "--vrdpaddress", 'a', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1003 { "-vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1004 { "--vrdp", 'v', RTGETOPT_REQ_STRING }, /* VRDE: deprecated. */
1005 { "-vrde", 'v', RTGETOPT_REQ_STRING },
1006 { "--vrde", 'v', RTGETOPT_REQ_STRING },
1007 { "-vrdeproperty", 'e', RTGETOPT_REQ_STRING },
1008 { "--vrdeproperty", 'e', RTGETOPT_REQ_STRING },
1009 { "--settingspw", OPT_SETTINGSPW, RTGETOPT_REQ_STRING },
1010 { "--settingspwfile", OPT_SETTINGSPW_FILE, RTGETOPT_REQ_STRING },
1011 { "--password", OPT_VMPW, RTGETOPT_REQ_STRING },
1012 { "--password-id", OPT_VMPWID, RTGETOPT_REQ_STRING },
1013#ifdef VBOX_WITH_RECORDING
1014 { "-record", 'c', 0 },
1015 { "--record", 'c', 0 },
1016 { "--videowidth", 'w', RTGETOPT_REQ_UINT32 },
1017 { "--videoheight", 'h', RTGETOPT_REQ_UINT32 }, /* great choice of short option! */
1018 { "--videorate", 'r', RTGETOPT_REQ_UINT32 },
1019 { "--filename", 'f', RTGETOPT_REQ_STRING },
1020#endif /* VBOX_WITH_RECORDING defined */
1021 { "-comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
1022 { "--comment", OPT_COMMENT, RTGETOPT_REQ_STRING },
1023 { "-start-paused", OPT_PAUSED, 0 },
1024 { "--start-paused", OPT_PAUSED, 0 }
1025 };
1026
1027 const char *pcszNameOrUUID = NULL;
1028
1029 // parse the command line
1030 int ch;
1031 const char *pcszSettingsPw = NULL;
1032 const char *pcszSettingsPwFile = NULL;
1033 const char *pcszVmPassword = NULL;
1034 const char *pcszVmPasswordId = NULL;
1035 RTGETOPTUNION ValueUnion;
1036 RTGETOPTSTATE GetState;
1037 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
1038 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1039 {
1040 switch(ch)
1041 {
1042 case 's':
1043 pcszNameOrUUID = ValueUnion.psz;
1044 break;
1045 case 'p':
1046 RTPrintf("Warning: '-p' or '-vrdpport' are deprecated. Use '-e \"TCP/Ports=%s\"'\n", ValueUnion.psz);
1047 vrdePort = ValueUnion.psz;
1048 break;
1049 case 'a':
1050 RTPrintf("Warning: '-a' or '-vrdpaddress' are deprecated. Use '-e \"TCP/Address=%s\"'\n", ValueUnion.psz);
1051 vrdeAddress = ValueUnion.psz;
1052 break;
1053 case 'v':
1054 vrdeEnabled = ValueUnion.psz;
1055 break;
1056 case 'e':
1057 if (cVRDEProperties < RT_ELEMENTS(apszVRDEProperties))
1058 apszVRDEProperties[cVRDEProperties++] = ValueUnion.psz;
1059 else
1060 RTPrintf("Warning: too many VRDE properties. Ignored: '%s'\n", ValueUnion.psz);
1061 break;
1062 case OPT_SETTINGSPW:
1063 pcszSettingsPw = ValueUnion.psz;
1064 break;
1065 case OPT_SETTINGSPW_FILE:
1066 pcszSettingsPwFile = ValueUnion.psz;
1067 break;
1068 case OPT_VMPW:
1069 pcszVmPassword = ValueUnion.psz;
1070 break;
1071 case OPT_VMPWID:
1072 pcszVmPasswordId = ValueUnion.psz;
1073 break;
1074 case OPT_PAUSED:
1075 fPaused = true;
1076 break;
1077#ifdef VBOX_WITH_RECORDING
1078 case 'c':
1079 fRecordEnabled = true;
1080 break;
1081 case 'w':
1082 ulRecordVideoWidth = ValueUnion.u32;
1083 break;
1084 case 'r':
1085 ulRecordVideoRate = ValueUnion.u32;
1086 break;
1087 case 'f':
1088 pszRecordFilenameTemplate = ValueUnion.psz;
1089 break;
1090#endif /* VBOX_WITH_RECORDING defined */
1091 case 'h':
1092#ifdef VBOX_WITH_RECORDING
1093 if ((GetState.pDef->fFlags & RTGETOPT_REQ_MASK) != RTGETOPT_REQ_NOTHING)
1094 {
1095 ulRecordVideoHeight = ValueUnion.u32;
1096 break;
1097 }
1098#endif
1099 show_usage();
1100 return 0;
1101 case OPT_COMMENT:
1102 /* nothing to do */
1103 break;
1104 case 'V':
1105 RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
1106 return 0;
1107 default:
1108 ch = RTGetOptPrintError(ch, &ValueUnion);
1109 show_usage();
1110 return ch;
1111 }
1112 }
1113
1114#ifdef VBOX_WITH_RECORDING
1115 if (ulRecordVideoWidth < 512 || ulRecordVideoWidth > 2048 || ulRecordVideoWidth % 2)
1116 {
1117 LogError("VBoxHeadless: ERROR: please specify an even video frame width between 512 and 2048", 0);
1118 return 1;
1119 }
1120 if (ulRecordVideoHeight < 384 || ulRecordVideoHeight > 1536 || ulRecordVideoHeight % 2)
1121 {
1122 LogError("VBoxHeadless: ERROR: please specify an even video frame height between 384 and 1536", 0);
1123 return 1;
1124 }
1125 if (ulRecordVideoRate < 300000 || ulRecordVideoRate > 1000000)
1126 {
1127 LogError("VBoxHeadless: ERROR: please specify an even video bitrate between 300000 and 1000000", 0);
1128 return 1;
1129 }
1130 /* Make sure we only have %d or %u (or none) in the file name specified */
1131 char *pcPercent = (char*)strchr(pszRecordFilenameTemplate, '%');
1132 if (pcPercent != 0 && *(pcPercent + 1) != 'd' && *(pcPercent + 1) != 'u')
1133 {
1134 LogError("VBoxHeadless: ERROR: Only %%d and %%u are allowed in the recording file name.", -1);
1135 return 1;
1136 }
1137 /* And no more than one % in the name */
1138 if (pcPercent != 0 && strchr(pcPercent + 1, '%') != 0)
1139 {
1140 LogError("VBoxHeadless: ERROR: Only one format modifier is allowed in the recording file name.", -1);
1141 return 1;
1142 }
1143 RTStrPrintf(&szRecordFilename[0], RTPATH_MAX, pszRecordFilenameTemplate, RTProcSelf());
1144#endif /* defined VBOX_WITH_RECORDING */
1145
1146 if (!pcszNameOrUUID)
1147 {
1148 show_usage();
1149 return 1;
1150 }
1151
1152 HRESULT hrc;
1153 int vrc;
1154
1155 hrc = com::Initialize();
1156#ifdef VBOX_WITH_XPCOM
1157 if (hrc == NS_ERROR_FILE_ACCESS_DENIED)
1158 {
1159 char szHome[RTPATH_MAX] = "";
1160 com::GetVBoxUserHomeDirectory(szHome, sizeof(szHome));
1161 RTPrintf("Failed to initialize COM because the global settings directory '%s' is not accessible!", szHome);
1162 return 1;
1163 }
1164#endif
1165 if (FAILED(hrc))
1166 {
1167 RTPrintf("VBoxHeadless: ERROR: failed to initialize COM!\n");
1168 return 1;
1169 }
1170
1171 ComPtr<IVirtualBoxClient> pVirtualBoxClient;
1172 ComPtr<IVirtualBox> virtualBox;
1173 ComPtr<ISession> session;
1174 ComPtr<IMachine> machine;
1175 bool fSessionOpened = false;
1176 ComPtr<IEventListener> vboxClientListener;
1177 ComPtr<IEventListener> vboxListener;
1178 ComObjPtr<ConsoleEventListenerImpl> consoleListener;
1179
1180 do
1181 {
1182 hrc = pVirtualBoxClient.createInprocObject(CLSID_VirtualBoxClient);
1183 if (FAILED(hrc))
1184 {
1185 RTPrintf("VBoxHeadless: ERROR: failed to create the VirtualBoxClient object!\n");
1186 com::ErrorInfo info;
1187 if (!info.isFullAvailable() && !info.isBasicAvailable())
1188 {
1189 com::GluePrintRCMessage(hrc);
1190 RTPrintf("Most likely, the VirtualBox COM server is not running or failed to start.\n");
1191 }
1192 else
1193 GluePrintErrorInfo(info);
1194 break;
1195 }
1196
1197 hrc = pVirtualBoxClient->COMGETTER(VirtualBox)(virtualBox.asOutParam());
1198 if (FAILED(hrc))
1199 {
1200 RTPrintf("Failed to get VirtualBox object (rc=%Rhrc)!\n", hrc);
1201 break;
1202 }
1203 hrc = pVirtualBoxClient->COMGETTER(Session)(session.asOutParam());
1204 if (FAILED(hrc))
1205 {
1206 RTPrintf("Failed to get session object (rc=%Rhrc)!\n", hrc);
1207 break;
1208 }
1209
1210 if (pcszSettingsPw)
1211 {
1212 CHECK_ERROR(virtualBox, SetSettingsSecret(Bstr(pcszSettingsPw).raw()));
1213 if (FAILED(hrc))
1214 break;
1215 }
1216 else if (pcszSettingsPwFile)
1217 {
1218 int rcExit = settingsPasswordFile(virtualBox, pcszSettingsPwFile);
1219 if (rcExit != RTEXITCODE_SUCCESS)
1220 break;
1221 }
1222
1223 ComPtr<IMachine> m;
1224
1225 hrc = virtualBox->FindMachine(Bstr(pcszNameOrUUID).raw(), m.asOutParam());
1226 if (FAILED(hrc))
1227 {
1228 LogError("Invalid machine name or UUID!\n", hrc);
1229 break;
1230 }
1231
1232 /* add VM password if required */
1233 if (pcszVmPassword && pcszVmPasswordId)
1234 {
1235 com::Utf8Str strPassword;
1236 if (!RTStrCmp(pcszVmPassword, "-"))
1237 {
1238 /* Get password from console. */
1239 RTEXITCODE rcExit = readPasswordFromConsole(&strPassword, "Enter the password:");
1240 if (rcExit == RTEXITCODE_FAILURE)
1241 break;
1242 }
1243 else
1244 {
1245 RTEXITCODE rcExit = readPasswordFile(pcszVmPassword, &strPassword);
1246 if (rcExit != RTEXITCODE_SUCCESS)
1247 break;
1248 }
1249 CHECK_ERROR_BREAK(m, AddEncryptionPassword(Bstr(pcszVmPasswordId).raw(),
1250 Bstr(strPassword).raw()));
1251 }
1252 Bstr bstrVMId;
1253 hrc = m->COMGETTER(Id)(bstrVMId.asOutParam());
1254 AssertComRC(hrc);
1255 if (FAILED(hrc))
1256 break;
1257 g_strVMUUID = bstrVMId;
1258
1259 Bstr bstrVMName;
1260 hrc = m->COMGETTER(Name)(bstrVMName.asOutParam());
1261 AssertComRC(hrc);
1262 if (FAILED(hrc))
1263 break;
1264 g_strVMName = bstrVMName;
1265
1266 Log(("VBoxHeadless: Opening a session with machine (id={%s})...\n",
1267 g_strVMUUID.c_str()));
1268
1269 // set session name
1270 CHECK_ERROR_BREAK(session, COMSETTER(Name)(Bstr("headless").raw()));
1271 // open a session
1272 CHECK_ERROR_BREAK(m, LockMachine(session, LockType_VM));
1273 fSessionOpened = true;
1274
1275 /* get the console */
1276 ComPtr<IConsole> console;
1277 CHECK_ERROR_BREAK(session, COMGETTER(Console)(console.asOutParam()));
1278
1279 /* get the mutable machine */
1280 CHECK_ERROR_BREAK(console, COMGETTER(Machine)(machine.asOutParam()));
1281
1282 ComPtr<IDisplay> display;
1283 CHECK_ERROR_BREAK(console, COMGETTER(Display)(display.asOutParam()));
1284
1285#ifdef VBOX_WITH_RECORDING
1286 if (fRecordEnabled)
1287 {
1288 ComPtr<IRecordingSettings> recordingSettings;
1289 CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
1290 CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(TRUE));
1291
1292 SafeIfaceArray <IRecordingScreenSettings> saRecordScreenScreens;
1293 CHECK_ERROR_BREAK(recordingSettings, COMGETTER(Screens)(ComSafeArrayAsOutParam(saRecordScreenScreens)));
1294
1295 /* Note: For now all screens have the same configuration. */
1296 for (size_t i = 0; i < saRecordScreenScreens.size(); ++i)
1297 {
1298 CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Enabled)(TRUE));
1299 CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(Filename)(Bstr(szRecordFilename).raw()));
1300 CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoWidth)(ulRecordVideoWidth));
1301 CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoHeight)(ulRecordVideoHeight));
1302 CHECK_ERROR_BREAK(saRecordScreenScreens[i], COMSETTER(VideoRate)(ulRecordVideoRate));
1303 }
1304 }
1305#endif /* defined(VBOX_WITH_RECORDING) */
1306
1307#if 0
1308 /* get the machine debugger (isn't necessarily available) */
1309 ComPtr <IMachineDebugger> machineDebugger;
1310 console->COMGETTER(Debugger)(machineDebugger.asOutParam());
1311 if (machineDebugger)
1312 Log(("Machine debugger available!\n"));
1313#endif
1314
1315 /* initialize global references */
1316 gConsole = console;
1317 gEventQ = com::NativeEventQueue::getMainEventQueue();
1318 g_fEventQueueSafe = true;
1319
1320 /* VirtualBoxClient events registration. */
1321 {
1322 ComPtr<IEventSource> pES;
1323 CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1324 ComObjPtr<VirtualBoxClientEventListenerImpl> listener;
1325 listener.createObject();
1326 listener->init(new VirtualBoxClientEventListener());
1327 vboxClientListener = listener;
1328 com::SafeArray<VBoxEventType_T> eventTypes;
1329 eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
1330 CHECK_ERROR(pES, RegisterListener(vboxClientListener, ComSafeArrayAsInParam(eventTypes), true));
1331 }
1332
1333 /* Console events registration. */
1334 {
1335 ComPtr<IEventSource> es;
1336 CHECK_ERROR(console, COMGETTER(EventSource)(es.asOutParam()));
1337 consoleListener.createObject();
1338 consoleListener->init(new ConsoleEventListener());
1339 com::SafeArray<VBoxEventType_T> eventTypes;
1340 eventTypes.push_back(VBoxEventType_OnMouseCapabilityChanged);
1341 eventTypes.push_back(VBoxEventType_OnStateChanged);
1342 eventTypes.push_back(VBoxEventType_OnVRDEServerInfoChanged);
1343 eventTypes.push_back(VBoxEventType_OnCanShowWindow);
1344 eventTypes.push_back(VBoxEventType_OnShowWindow);
1345 eventTypes.push_back(VBoxEventType_OnGuestPropertyChanged);
1346 CHECK_ERROR(es, RegisterListener(consoleListener, ComSafeArrayAsInParam(eventTypes), true));
1347 }
1348
1349 /* Default is to use the VM setting for the VRDE server. */
1350 enum VRDEOption
1351 {
1352 VRDEOption_Config,
1353 VRDEOption_Off,
1354 VRDEOption_On
1355 };
1356 VRDEOption enmVRDEOption = VRDEOption_Config;
1357 BOOL fVRDEEnabled;
1358 ComPtr <IVRDEServer> vrdeServer;
1359 CHECK_ERROR_BREAK(machine, COMGETTER(VRDEServer)(vrdeServer.asOutParam()));
1360 CHECK_ERROR_BREAK(vrdeServer, COMGETTER(Enabled)(&fVRDEEnabled));
1361
1362 if (vrdeEnabled != NULL)
1363 {
1364 /* -vrde on|off|config */
1365 if (!strcmp(vrdeEnabled, "off") || !strcmp(vrdeEnabled, "disable"))
1366 enmVRDEOption = VRDEOption_Off;
1367 else if (!strcmp(vrdeEnabled, "on") || !strcmp(vrdeEnabled, "enable"))
1368 enmVRDEOption = VRDEOption_On;
1369 else if (strcmp(vrdeEnabled, "config"))
1370 {
1371 RTPrintf("-vrde requires an argument (on|off|config)\n");
1372 break;
1373 }
1374 }
1375
1376 Log(("VBoxHeadless: enmVRDE %d, fVRDEEnabled %d\n", enmVRDEOption, fVRDEEnabled));
1377
1378 if (enmVRDEOption != VRDEOption_Off)
1379 {
1380 /* Set other specified options. */
1381
1382 /* set VRDE port if requested by the user */
1383 if (vrdePort != NULL)
1384 {
1385 Bstr bstr = vrdePort;
1386 CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Ports").raw(), bstr.raw()));
1387 }
1388 /* set VRDE address if requested by the user */
1389 if (vrdeAddress != NULL)
1390 {
1391 CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(Bstr("TCP/Address").raw(), Bstr(vrdeAddress).raw()));
1392 }
1393
1394 /* Set VRDE properties. */
1395 if (cVRDEProperties > 0)
1396 {
1397 for (unsigned i = 0; i < cVRDEProperties; i++)
1398 {
1399 /* Split 'name=value' and feed the parts to SetVRDEProperty. */
1400 const char *pszDelimiter = strchr(apszVRDEProperties[i], '=');
1401 if (pszDelimiter)
1402 {
1403 Bstr bstrName(apszVRDEProperties[i], pszDelimiter - apszVRDEProperties[i]);
1404 Bstr bstrValue(pszDelimiter + 1);
1405 CHECK_ERROR_BREAK(vrdeServer, SetVRDEProperty(bstrName.raw(), bstrValue.raw()));
1406 }
1407 else
1408 {
1409 RTPrintf("Error: Invalid VRDE property '%s'\n", apszVRDEProperties[i]);
1410 hrc = E_INVALIDARG;
1411 break;
1412 }
1413 }
1414 if (FAILED(hrc))
1415 break;
1416 }
1417
1418 }
1419
1420 if (enmVRDEOption == VRDEOption_On)
1421 {
1422 /* enable VRDE server (only if currently disabled) */
1423 if (!fVRDEEnabled)
1424 {
1425 CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(TRUE));
1426 }
1427 }
1428 else if (enmVRDEOption == VRDEOption_Off)
1429 {
1430 /* disable VRDE server (only if currently enabled */
1431 if (fVRDEEnabled)
1432 {
1433 CHECK_ERROR_BREAK(vrdeServer, COMSETTER(Enabled)(FALSE));
1434 }
1435 }
1436
1437 /* Disable the host clipboard before powering up */
1438 console->COMSETTER(UseHostClipboard)(false);
1439
1440 Log(("VBoxHeadless: Powering up the machine...\n"));
1441
1442
1443 /**
1444 * @todo We should probably install handlers earlier so that
1445 * we can undo any temporary settings we do above in case of
1446 * an early signal and use RAII to ensure proper cleanup.
1447 */
1448#if !defined(RT_OS_WINDOWS)
1449 ::SetUpSignalHandlers();
1450#else
1451 /*
1452 * Register windows console signal handler to react to Ctrl-C,
1453 * Ctrl-Break, Close, non-interactive session termination.
1454 */
1455 ::SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
1456#endif
1457
1458
1459 ComPtr <IProgress> progress;
1460 if (!fPaused)
1461 CHECK_ERROR_BREAK(console, PowerUp(progress.asOutParam()));
1462 else
1463 CHECK_ERROR_BREAK(console, PowerUpPaused(progress.asOutParam()));
1464
1465 hrc = showProgress(progress);
1466 if (FAILED(hrc))
1467 {
1468 com::ProgressErrorInfo info(progress);
1469 if (info.isBasicAvailable())
1470 {
1471 RTPrintf("Error: failed to start machine. Error message: %ls\n", info.getText().raw());
1472 }
1473 else
1474 {
1475 RTPrintf("Error: failed to start machine. No error message available!\n");
1476 }
1477 break;
1478 }
1479
1480#ifdef RT_OS_WINDOWS
1481 /*
1482 * Spawn windows message pump to monitor session events.
1483 */
1484 RTTHREAD hThrMsg;
1485 vrc = RTThreadCreate(&hThrMsg,
1486 windowsMessageMonitor, NULL,
1487 0, /* :cbStack */
1488 RTTHREADTYPE_MSG_PUMP, 0,
1489 "MSG");
1490 if (RT_FAILURE(vrc)) /* not fatal */
1491 LogRel(("VBoxHeadless: failed to start windows message monitor: %Rrc\n", vrc));
1492#endif /* RT_OS_WINDOWS */
1493
1494
1495 /*
1496 * Pump vbox events forever
1497 */
1498 LogRel(("VBoxHeadless: starting event loop\n"));
1499 for (;;)
1500 {
1501 if (g_fTerminateFE)
1502 {
1503 LogRel(("VBoxHeadless: processEventQueue: termination requested\n"));
1504 break;
1505 }
1506
1507 vrc = gEventQ->processEventQueue(RT_INDEFINITE_WAIT);
1508
1509 /*
1510 * interruptEventQueueProcessing from another thread is
1511 * reported as VERR_INTERRUPTED, so check the flag first.
1512 */
1513 if (g_fTerminateFE)
1514 {
1515 LogRel(("VBoxHeadless: processEventQueue: %Rrc, termination requested\n", vrc));
1516 break;
1517 }
1518
1519 if (RT_FAILURE(vrc))
1520 {
1521 LogRel(("VBoxHeadless: processEventQueue: %Rrc\n", vrc));
1522 RTMsgError("event loop: %Rrc", vrc);
1523 break;
1524 }
1525 }
1526
1527 Log(("VBoxHeadless: event loop has terminated...\n"));
1528
1529#ifdef VBOX_WITH_RECORDING
1530 if (fRecordEnabled)
1531 {
1532 if (!machine.isNull())
1533 {
1534 ComPtr<IRecordingSettings> recordingSettings;
1535 CHECK_ERROR_BREAK(machine, COMGETTER(RecordingSettings)(recordingSettings.asOutParam()));
1536 CHECK_ERROR_BREAK(recordingSettings, COMSETTER(Enabled)(FALSE));
1537 }
1538 }
1539#endif /* VBOX_WITH_RECORDING */
1540
1541 /* we don't have to disable VRDE here because we don't save the settings of the VM */
1542 }
1543 while (0);
1544
1545 /*
1546 * Get the machine state.
1547 */
1548 MachineState_T machineState = MachineState_Aborted;
1549 if (!machine.isNull())
1550 {
1551 hrc = machine->COMGETTER(State)(&machineState);
1552 if (SUCCEEDED(hrc))
1553 Log(("machine state = %RU32\n", machineState));
1554 else
1555 Log(("IMachine::getState: %Rhrc\n", hrc));
1556 }
1557 else
1558 {
1559 Log(("machine == NULL\n"));
1560 }
1561
1562 /*
1563 * Turn off the VM if it's running
1564 */
1565 if ( gConsole
1566 && ( machineState == MachineState_Running
1567 || machineState == MachineState_Teleporting
1568 || machineState == MachineState_LiveSnapshotting
1569 /** @todo power off paused VMs too? */
1570 )
1571 )
1572 do
1573 {
1574 consoleListener->getWrapped()->ignorePowerOffEvents(true);
1575
1576 ComPtr<IProgress> pProgress;
1577 if (!machine.isNull())
1578 CHECK_ERROR_BREAK(machine, SaveState(pProgress.asOutParam()));
1579 else
1580 CHECK_ERROR_BREAK(gConsole, PowerDown(pProgress.asOutParam()));
1581
1582 hrc = showProgress(pProgress);
1583 if (FAILED(hrc))
1584 {
1585 com::ErrorInfo info;
1586 if (!info.isFullAvailable() && !info.isBasicAvailable())
1587 com::GluePrintRCMessage(hrc);
1588 else
1589 com::GluePrintErrorInfo(info);
1590 break;
1591 }
1592 } while (0);
1593
1594 /* No point in trying to post dummy messages to the event queue now. */
1595 g_fEventQueueSafe = false;
1596
1597 /* VirtualBox callback unregistration. */
1598 if (vboxListener)
1599 {
1600 ComPtr<IEventSource> es;
1601 CHECK_ERROR(virtualBox, COMGETTER(EventSource)(es.asOutParam()));
1602 if (!es.isNull())
1603 CHECK_ERROR(es, UnregisterListener(vboxListener));
1604 vboxListener.setNull();
1605 }
1606
1607 /* Console callback unregistration. */
1608 if (consoleListener)
1609 {
1610 ComPtr<IEventSource> es;
1611 CHECK_ERROR(gConsole, COMGETTER(EventSource)(es.asOutParam()));
1612 if (!es.isNull())
1613 CHECK_ERROR(es, UnregisterListener(consoleListener));
1614 consoleListener.setNull();
1615 }
1616
1617 /* VirtualBoxClient callback unregistration. */
1618 if (vboxClientListener)
1619 {
1620 ComPtr<IEventSource> pES;
1621 CHECK_ERROR(pVirtualBoxClient, COMGETTER(EventSource)(pES.asOutParam()));
1622 if (!pES.isNull())
1623 CHECK_ERROR(pES, UnregisterListener(vboxClientListener));
1624 vboxClientListener.setNull();
1625 }
1626
1627 /* No more access to the 'console' object, which will be uninitialized by the next session->Close call. */
1628 gConsole = NULL;
1629
1630 if (fSessionOpened)
1631 {
1632 /*
1633 * Close the session. This will also uninitialize the console and
1634 * unregister the callback we've registered before.
1635 */
1636 Log(("VBoxHeadless: Closing the session...\n"));
1637 session->UnlockMachine();
1638 }
1639
1640 /* Must be before com::Shutdown */
1641 session.setNull();
1642 virtualBox.setNull();
1643 pVirtualBoxClient.setNull();
1644 machine.setNull();
1645
1646 com::Shutdown();
1647
1648#ifdef RT_OS_WINDOWS
1649 /* tell the session monitor it can ack WM_ENDSESSION */
1650 if (g_hCanQuit != NIL_RTSEMEVENT)
1651 {
1652 RTSemEventSignal(g_hCanQuit);
1653 }
1654
1655 /* tell the session monitor to quit */
1656 if (g_hWindow != NULL)
1657 {
1658 ::PostMessage(g_hWindow, WM_QUIT, 0, 0);
1659 }
1660#endif
1661
1662 LogRel(("VBoxHeadless: exiting\n"));
1663 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1664}
1665
1666
1667#ifndef VBOX_WITH_HARDENING
1668/**
1669 * Main entry point.
1670 */
1671int main(int argc, char **argv, char **envp)
1672{
1673 int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_TRY_SUPLIB);
1674 if (RT_SUCCESS(rc))
1675 return TrustedMain(argc, argv, envp);
1676 RTPrintf("VBoxHeadless: Runtime initialization failed: %Rrc - %Rrf\n", rc, rc);
1677 return RTEXITCODE_FAILURE;
1678}
1679#endif /* !VBOX_WITH_HARDENING */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
ContactPrivacy policyTerms of Use