VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageGuestCtrl.cpp@ 99775

Last change on this file since 99775 was 99775, checked in by vboxsync, 2 years 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: 147.6 KB
Line 
1/* $Id: VBoxManageGuestCtrl.cpp 99775 2023-05-12 12:21:58Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of guestcontrol command.
4 */
5
6/*
7 * Copyright (C) 2010-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
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include "VBoxManage.h"
33#include "VBoxManageGuestCtrl.h"
34
35#include <VBox/com/array.h>
36#include <VBox/com/com.h>
37#include <VBox/com/ErrorInfo.h>
38#include <VBox/com/errorprint.h>
39#include <VBox/com/listeners.h>
40#include <VBox/com/NativeEventQueue.h>
41#include <VBox/com/string.h>
42#include <VBox/com/VirtualBox.h>
43
44#include <VBox/err.h>
45#include <VBox/log.h>
46
47#include <iprt/asm.h>
48#include <iprt/dir.h>
49#include <iprt/file.h>
50#include <iprt/getopt.h>
51#include <iprt/list.h>
52#include <iprt/path.h>
53#include <iprt/process.h> /* For RTProcSelf(). */
54#include <iprt/semaphore.h>
55#include <iprt/thread.h>
56#include <iprt/vfs.h>
57
58#include <iprt/cpp/path.h>
59
60#include <map>
61#include <vector>
62
63#ifdef USE_XPCOM_QUEUE
64# include <sys/select.h>
65# include <errno.h>
66#endif
67
68#include <signal.h>
69
70#ifdef RT_OS_DARWIN
71# include <CoreFoundation/CFRunLoop.h>
72#endif
73
74using namespace com;
75
76
77/*********************************************************************************************************************************
78 * Defined Constants And Macros *
79*********************************************************************************************************************************/
80
81#define GCTLCMD_COMMON_OPT_USER 999 /**< The --username option number. */
82#define GCTLCMD_COMMON_OPT_PASSWORD 998 /**< The --password option number. */
83#define GCTLCMD_COMMON_OPT_PASSWORD_FILE 997 /**< The --password-file option number. */
84#define GCTLCMD_COMMON_OPT_DOMAIN 996 /**< The --domain option number. */
85/** Common option definitions. */
86#define GCTLCMD_COMMON_OPTION_DEFS() \
87 { "--user", GCTLCMD_COMMON_OPT_USER, RTGETOPT_REQ_STRING }, \
88 { "--username", GCTLCMD_COMMON_OPT_USER, RTGETOPT_REQ_STRING }, \
89 { "--passwordfile", GCTLCMD_COMMON_OPT_PASSWORD_FILE, RTGETOPT_REQ_STRING }, \
90 { "--password", GCTLCMD_COMMON_OPT_PASSWORD, RTGETOPT_REQ_STRING }, \
91 { "--domain", GCTLCMD_COMMON_OPT_DOMAIN, RTGETOPT_REQ_STRING }, \
92 { "--quiet", 'q', RTGETOPT_REQ_NOTHING }, \
93 { "--verbose", 'v', RTGETOPT_REQ_NOTHING },
94
95/** Handles common options in the typical option parsing switch. */
96#define GCTLCMD_COMMON_OPTION_CASES(a_pCtx, a_ch, a_pValueUnion) \
97 case 'v': \
98 case 'q': \
99 case GCTLCMD_COMMON_OPT_USER: \
100 case GCTLCMD_COMMON_OPT_DOMAIN: \
101 case GCTLCMD_COMMON_OPT_PASSWORD: \
102 case GCTLCMD_COMMON_OPT_PASSWORD_FILE: \
103 { \
104 RTEXITCODE rcExitCommon = gctlCtxSetOption(a_pCtx, a_ch, a_pValueUnion); \
105 if (RT_UNLIKELY(rcExitCommon != RTEXITCODE_SUCCESS)) \
106 return rcExitCommon; \
107 } break
108
109
110/*********************************************************************************************************************************
111* Global Variables *
112*********************************************************************************************************************************/
113/** Set by the signal handler when current guest control
114 * action shall be aborted. */
115static volatile bool g_fGuestCtrlCanceled = false;
116/** Event semaphore used for wait notifications.
117 * Also being used for the listener implementations in VBoxManageGuestCtrlListener.cpp. */
118 RTSEMEVENT g_SemEventGuestCtrlCanceled = NIL_RTSEMEVENT;
119
120
121/*********************************************************************************************************************************
122* Structures and Typedefs *
123*********************************************************************************************************************************/
124/**
125 * Listener declarations.
126 */
127VBOX_LISTENER_DECLARE(GuestFileEventListenerImpl)
128VBOX_LISTENER_DECLARE(GuestProcessEventListenerImpl)
129VBOX_LISTENER_DECLARE(GuestSessionEventListenerImpl)
130VBOX_LISTENER_DECLARE(GuestEventListenerImpl)
131VBOX_LISTENER_DECLARE(GuestAdditionsRunlevelListener)
132
133/**
134 * Definition of a guestcontrol command, with handler and various flags.
135 */
136typedef struct GCTLCMDDEF
137{
138 /** The command name. */
139 const char *pszName;
140
141 /**
142 * Actual command handler callback.
143 *
144 * @param pCtx Pointer to command context to use.
145 */
146 DECLR3CALLBACKMEMBER(RTEXITCODE, pfnHandler, (struct GCTLCMDCTX *pCtx, int argc, char **argv));
147
148 /** The sub-command scope flags. */
149 uint64_t fSubcommandScope;
150 /** Command context flags (GCTLCMDCTX_F_XXX). */
151 uint32_t fCmdCtx;
152} GCTLCMD;
153/** Pointer to a const guest control command definition. */
154typedef GCTLCMDDEF const *PCGCTLCMDDEF;
155
156/** @name GCTLCMDCTX_F_XXX - Command context flags.
157 * @{
158 */
159/** No flags set. */
160#define GCTLCMDCTX_F_NONE 0
161/** Don't install a signal handler (CTRL+C trap). */
162#define GCTLCMDCTX_F_NO_SIGNAL_HANDLER RT_BIT(0)
163/** No guest session needed. */
164#define GCTLCMDCTX_F_SESSION_ANONYMOUS RT_BIT(1)
165/** @} */
166
167/**
168 * Context for handling a specific command.
169 */
170typedef struct GCTLCMDCTX
171{
172 HandlerArg *pArg;
173
174 /** Pointer to the command definition. */
175 PCGCTLCMDDEF pCmdDef;
176 /** The VM name or UUID. */
177 const char *pszVmNameOrUuid;
178
179 /** Whether we've done the post option parsing init already. */
180 bool fPostOptionParsingInited;
181 /** Whether we've locked the VM session. */
182 bool fLockedVmSession;
183 /** Whether to detach (@c true) or close the session. */
184 bool fDetachGuestSession;
185 /** Set if we've installed the signal handler. */
186 bool fInstalledSignalHandler;
187 /** The verbosity level. */
188 uint32_t cVerbose;
189 /** User name. */
190 Utf8Str strUsername;
191 /** Password. */
192 Utf8Str strPassword;
193 /** Domain. */
194 Utf8Str strDomain;
195 /** Pointer to the IGuest interface. */
196 ComPtr<IGuest> pGuest;
197 /** Pointer to the to be used guest session. */
198 ComPtr<IGuestSession> pGuestSession;
199 /** The guest session ID. */
200 ULONG uSessionID;
201
202} GCTLCMDCTX, *PGCTLCMDCTX;
203
204
205/**
206 * An entry for an element which needs to be copied/created to/on the guest.
207 */
208typedef struct DESTFILEENTRY
209{
210 DESTFILEENTRY(Utf8Str strFilename) : mFilename(strFilename) {}
211 Utf8Str mFilename;
212} DESTFILEENTRY, *PDESTFILEENTRY;
213/*
214 * Map for holding destination entries, whereas the key is the destination
215 * directory and the mapped value is a vector holding all elements for this directory.
216 */
217typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> > DESTDIRMAP, *PDESTDIRMAP;
218typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> >::iterator DESTDIRMAPITER, *PDESTDIRMAPITER;
219
220
221enum kStreamTransform
222{
223 kStreamTransform_None = 0,
224 kStreamTransform_Dos2Unix,
225 kStreamTransform_Unix2Dos
226};
227
228
229DECLARE_TRANSLATION_CONTEXT(GuestCtrl);
230
231
232#ifdef RT_OS_WINDOWS
233static BOOL WINAPI gctlSignalHandler(DWORD dwCtrlType) RT_NOTHROW_DEF
234{
235 bool fEventHandled = FALSE;
236 switch (dwCtrlType)
237 {
238 /* User pressed CTRL+C or CTRL+BREAK or an external event was sent
239 * via GenerateConsoleCtrlEvent(). */
240 case CTRL_BREAK_EVENT:
241 case CTRL_CLOSE_EVENT:
242 case CTRL_C_EVENT:
243 ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true);
244 RTSemEventSignal(g_SemEventGuestCtrlCanceled);
245 fEventHandled = TRUE;
246 break;
247 default:
248 break;
249 /** @todo Add other events here. */
250 }
251
252 return fEventHandled;
253}
254#else /* !RT_OS_WINDOWS */
255/**
256 * Signal handler that sets g_fGuestCtrlCanceled.
257 *
258 * This can be executed on any thread in the process, on Windows it may even be
259 * a thread dedicated to delivering this signal. Don't do anything
260 * unnecessary here.
261 */
262static void gctlSignalHandler(int iSignal) RT_NOTHROW_DEF
263{
264 RT_NOREF(iSignal);
265 ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true);
266 RTSemEventSignal(g_SemEventGuestCtrlCanceled);
267}
268#endif
269
270
271/**
272 * Installs a custom signal handler to get notified
273 * whenever the user wants to intercept the program.
274 *
275 * @todo Make this handler available for all VBoxManage modules?
276 */
277static int gctlSignalHandlerInstall(void)
278{
279 g_fGuestCtrlCanceled = false;
280
281 int vrc = VINF_SUCCESS;
282#ifdef RT_OS_WINDOWS
283 if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)gctlSignalHandler, TRUE /* Add handler */))
284 {
285 vrc = RTErrConvertFromWin32(GetLastError());
286 RTMsgError(GuestCtrl::tr("Unable to install console control handler, vrc=%Rrc\n"), vrc);
287 }
288#else
289 signal(SIGINT, gctlSignalHandler);
290 signal(SIGTERM, gctlSignalHandler);
291# ifdef SIGBREAK
292 signal(SIGBREAK, gctlSignalHandler);
293# endif
294#endif
295
296 if (RT_SUCCESS(vrc))
297 vrc = RTSemEventCreate(&g_SemEventGuestCtrlCanceled);
298
299 return vrc;
300}
301
302
303/**
304 * Uninstalls a previously installed signal handler.
305 */
306static int gctlSignalHandlerUninstall(void)
307{
308 int vrc = VINF_SUCCESS;
309#ifdef RT_OS_WINDOWS
310 if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
311 {
312 vrc = RTErrConvertFromWin32(GetLastError());
313 RTMsgError(GuestCtrl::tr("Unable to uninstall console control handler, vrc=%Rrc\n"), vrc);
314 }
315#else
316 signal(SIGINT, SIG_DFL);
317 signal(SIGTERM, SIG_DFL);
318# ifdef SIGBREAK
319 signal(SIGBREAK, SIG_DFL);
320# endif
321#endif
322
323 if (g_SemEventGuestCtrlCanceled != NIL_RTSEMEVENT)
324 {
325 RTSemEventDestroy(g_SemEventGuestCtrlCanceled);
326 g_SemEventGuestCtrlCanceled = NIL_RTSEMEVENT;
327 }
328 return vrc;
329}
330
331
332/**
333 * Translates a process status to a human readable string.
334 *
335 * @sa GuestProcess::i_statusToString()
336 */
337const char *gctlProcessStatusToText(ProcessStatus_T enmStatus)
338{
339 switch (enmStatus)
340 {
341 case ProcessStatus_Starting:
342 return GuestCtrl::tr("starting");
343 case ProcessStatus_Started:
344 return GuestCtrl::tr("started");
345 case ProcessStatus_Paused:
346 return GuestCtrl::tr("paused");
347 case ProcessStatus_Terminating:
348 return GuestCtrl::tr("terminating");
349 case ProcessStatus_TerminatedNormally:
350 return GuestCtrl::tr("successfully terminated");
351 case ProcessStatus_TerminatedSignal:
352 return GuestCtrl::tr("terminated by signal");
353 case ProcessStatus_TerminatedAbnormally:
354 return GuestCtrl::tr("abnormally aborted");
355 case ProcessStatus_TimedOutKilled:
356 return GuestCtrl::tr("timed out");
357 case ProcessStatus_TimedOutAbnormally:
358 return GuestCtrl::tr("timed out, hanging");
359 case ProcessStatus_Down:
360 return GuestCtrl::tr("killed");
361 case ProcessStatus_Error:
362 return GuestCtrl::tr("error");
363 default:
364 break;
365 }
366 return GuestCtrl::tr("unknown");
367}
368
369/**
370 * Translates a guest process wait result to a human readable string.
371 */
372static const char *gctlProcessWaitResultToText(ProcessWaitResult_T enmWaitResult)
373{
374 switch (enmWaitResult)
375 {
376 case ProcessWaitResult_Start:
377 return GuestCtrl::tr("started");
378 case ProcessWaitResult_Terminate:
379 return GuestCtrl::tr("terminated");
380 case ProcessWaitResult_Status:
381 return GuestCtrl::tr("status changed");
382 case ProcessWaitResult_Error:
383 return GuestCtrl::tr("error");
384 case ProcessWaitResult_Timeout:
385 return GuestCtrl::tr("timed out");
386 case ProcessWaitResult_StdIn:
387 return GuestCtrl::tr("stdin ready");
388 case ProcessWaitResult_StdOut:
389 return GuestCtrl::tr("data on stdout");
390 case ProcessWaitResult_StdErr:
391 return GuestCtrl::tr("data on stderr");
392 case ProcessWaitResult_WaitFlagNotSupported:
393 return GuestCtrl::tr("waiting flag not supported");
394 default:
395 break;
396 }
397 return GuestCtrl::tr("unknown");
398}
399
400/**
401 * Translates a guest session status to a human readable string.
402 */
403const char *gctlGuestSessionStatusToText(GuestSessionStatus_T enmStatus)
404{
405 switch (enmStatus)
406 {
407 case GuestSessionStatus_Starting:
408 return GuestCtrl::tr("starting");
409 case GuestSessionStatus_Started:
410 return GuestCtrl::tr("started");
411 case GuestSessionStatus_Terminating:
412 return GuestCtrl::tr("terminating");
413 case GuestSessionStatus_Terminated:
414 return GuestCtrl::tr("terminated");
415 case GuestSessionStatus_TimedOutKilled:
416 return GuestCtrl::tr("timed out");
417 case GuestSessionStatus_TimedOutAbnormally:
418 return GuestCtrl::tr("timed out, hanging");
419 case GuestSessionStatus_Down:
420 return GuestCtrl::tr("killed");
421 case GuestSessionStatus_Error:
422 return GuestCtrl::tr("error");
423 default:
424 break;
425 }
426 return GuestCtrl::tr("unknown");
427}
428
429/**
430 * Translates a guest file status to a human readable string.
431 */
432const char *gctlFileStatusToText(FileStatus_T enmStatus)
433{
434 switch (enmStatus)
435 {
436 case FileStatus_Opening:
437 return GuestCtrl::tr("opening");
438 case FileStatus_Open:
439 return GuestCtrl::tr("open");
440 case FileStatus_Closing:
441 return GuestCtrl::tr("closing");
442 case FileStatus_Closed:
443 return GuestCtrl::tr("closed");
444 case FileStatus_Down:
445 return GuestCtrl::tr("killed");
446 case FileStatus_Error:
447 return GuestCtrl::tr("error");
448 default:
449 break;
450 }
451 return GuestCtrl::tr("unknown");
452}
453
454/**
455 * Translates a file system objec type to a string.
456 */
457static const char *gctlFsObjTypeToName(FsObjType_T enmType)
458{
459 switch (enmType)
460 {
461 case FsObjType_Unknown: return GuestCtrl::tr("unknown");
462 case FsObjType_Fifo: return GuestCtrl::tr("fifo");
463 case FsObjType_DevChar: return GuestCtrl::tr("char-device");
464 case FsObjType_Directory: return GuestCtrl::tr("directory");
465 case FsObjType_DevBlock: return GuestCtrl::tr("block-device");
466 case FsObjType_File: return GuestCtrl::tr("file");
467 case FsObjType_Symlink: return GuestCtrl::tr("symlink");
468 case FsObjType_Socket: return GuestCtrl::tr("socket");
469 case FsObjType_WhiteOut: return GuestCtrl::tr("white-out");
470#ifdef VBOX_WITH_XPCOM_CPP_ENUM_HACK
471 case FsObjType_32BitHack: break;
472#endif
473 }
474 return GuestCtrl::tr("unknown");
475}
476
477static int gctlPrintError(com::ErrorInfo &errorInfo)
478{
479 if ( errorInfo.isFullAvailable()
480 || errorInfo.isBasicAvailable())
481 {
482 /* If we got a VBOX_E_IPRT error we handle the error in a more gentle way
483 * because it contains more accurate info about what went wrong. */
484 if (errorInfo.getResultCode() == VBOX_E_IPRT_ERROR)
485 RTMsgError("%ls.", errorInfo.getText().raw());
486 else
487 {
488 RTMsgError(GuestCtrl::tr("Error details:"));
489 GluePrintErrorInfo(errorInfo);
490 }
491 return VERR_GENERAL_FAILURE; /** @todo */
492 }
493 AssertMsgFailedReturn((GuestCtrl::tr("Object has indicated no error (%Rhrc)!?\n"), errorInfo.getResultCode()),
494 VERR_INVALID_PARAMETER);
495}
496
497static int gctlPrintError(IUnknown *pObj, const GUID &aIID)
498{
499 com::ErrorInfo ErrInfo(pObj, aIID);
500 return gctlPrintError(ErrInfo);
501}
502
503static int gctlPrintProgressError(ComPtr<IProgress> pProgress)
504{
505 int vrc = VINF_SUCCESS;
506 HRESULT hrc;
507
508 do
509 {
510 BOOL fCanceled;
511 CHECK_ERROR_BREAK(pProgress, COMGETTER(Canceled)(&fCanceled));
512 if (!fCanceled)
513 {
514 LONG rcProc;
515 CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&rcProc));
516 if (FAILED(rcProc))
517 {
518 com::ProgressErrorInfo ErrInfo(pProgress);
519 vrc = gctlPrintError(ErrInfo);
520 }
521 }
522
523 } while(0);
524
525 AssertMsgStmt(SUCCEEDED(hrc), (GuestCtrl::tr("Could not lookup progress information\n")), vrc = VERR_COM_UNEXPECTED);
526
527 return vrc;
528}
529
530
531
532/*
533 *
534 *
535 * Guest Control Command Context
536 * Guest Control Command Context
537 * Guest Control Command Context
538 * Guest Control Command Context
539 *
540 *
541 *
542 */
543
544
545/**
546 * Initializes a guest control command context structure.
547 *
548 * @returns RTEXITCODE_SUCCESS on success, RTEXITCODE_FAILURE on failure (after
549 * informing the user of course).
550 * @param pCtx The command context to init.
551 * @param pArg The handle argument package.
552 */
553static RTEXITCODE gctrCmdCtxInit(PGCTLCMDCTX pCtx, HandlerArg *pArg)
554{
555 pCtx->pArg = pArg;
556 pCtx->pCmdDef = NULL;
557 pCtx->pszVmNameOrUuid = NULL;
558 pCtx->fPostOptionParsingInited = false;
559 pCtx->fLockedVmSession = false;
560 pCtx->fDetachGuestSession = false;
561 pCtx->fInstalledSignalHandler = false;
562 pCtx->cVerbose = 0;
563 pCtx->strUsername.setNull();
564 pCtx->strPassword.setNull();
565 pCtx->strDomain.setNull();
566 pCtx->pGuest.setNull();
567 pCtx->pGuestSession.setNull();
568 pCtx->uSessionID = 0;
569
570 /*
571 * The user name defaults to the host one, if we can get at it.
572 */
573 char szUser[1024];
574 int vrc = RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), NULL);
575 if ( RT_SUCCESS(vrc)
576 && RTStrIsValidEncoding(szUser)) /* paranoia was required on posix at some point, not needed any more! */
577 {
578 try
579 {
580 pCtx->strUsername = szUser;
581 }
582 catch (std::bad_alloc &)
583 {
584 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory"));
585 }
586 }
587 /* else: ignore this failure. */
588
589 return RTEXITCODE_SUCCESS;
590}
591
592
593/**
594 * Worker for GCTLCMD_COMMON_OPTION_CASES.
595 *
596 * @returns RTEXITCODE_SUCCESS if the option was handled successfully. If not,
597 * an error message is printed and an appropriate failure exit code is
598 * returned.
599 * @param pCtx The guest control command context.
600 * @param ch The option char or ordinal.
601 * @param pValueUnion The option value union.
602 */
603static RTEXITCODE gctlCtxSetOption(PGCTLCMDCTX pCtx, int ch, PRTGETOPTUNION pValueUnion)
604{
605 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
606 switch (ch)
607 {
608 case GCTLCMD_COMMON_OPT_USER: /* User name */
609 if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
610 pCtx->strUsername = pValueUnion->psz;
611 else
612 RTMsgWarning(GuestCtrl::tr("The --username|-u option is ignored by '%s'"), pCtx->pCmdDef->pszName);
613 break;
614
615 case GCTLCMD_COMMON_OPT_PASSWORD: /* Password */
616 if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
617 {
618 if (pCtx->strPassword.isNotEmpty())
619 RTMsgWarning(GuestCtrl::tr("Password is given more than once."));
620 pCtx->strPassword = pValueUnion->psz;
621 }
622 else
623 RTMsgWarning(GuestCtrl::tr("The --password option is ignored by '%s'"), pCtx->pCmdDef->pszName);
624 break;
625
626 case GCTLCMD_COMMON_OPT_PASSWORD_FILE: /* Password file */
627 if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
628 rcExit = readPasswordFile(pValueUnion->psz, &pCtx->strPassword);
629 else
630 RTMsgWarning(GuestCtrl::tr("The --password-file|-p option is ignored by '%s'"), pCtx->pCmdDef->pszName);
631 break;
632
633 case GCTLCMD_COMMON_OPT_DOMAIN: /* domain */
634 if (!pCtx->pCmdDef || !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
635 pCtx->strDomain = pValueUnion->psz;
636 else
637 RTMsgWarning(GuestCtrl::tr("The --domain option is ignored by '%s'"), pCtx->pCmdDef->pszName);
638 break;
639
640 case 'v': /* --verbose */
641 pCtx->cVerbose++;
642 break;
643
644 case 'q': /* --quiet */
645 if (pCtx->cVerbose)
646 pCtx->cVerbose--;
647 break;
648
649 default:
650 AssertFatalMsgFailed(("ch=%d (%c)\n", ch, ch));
651 }
652 return rcExit;
653}
654
655
656/**
657 * Initializes the VM for IGuest operation.
658 *
659 * This opens a shared session to a running VM and gets hold of IGuest.
660 *
661 * @returns RTEXITCODE_SUCCESS on success. RTEXITCODE_FAILURE and user message
662 * on failure.
663 * @param pCtx The guest control command context.
664 * GCTLCMDCTX::pGuest will be set on success.
665 */
666static RTEXITCODE gctlCtxInitVmSession(PGCTLCMDCTX pCtx)
667{
668 HRESULT hrc;
669 AssertPtr(pCtx);
670 AssertPtr(pCtx->pArg);
671
672 /*
673 * Find the VM and check if it's running.
674 */
675 ComPtr<IMachine> machine;
676 CHECK_ERROR(pCtx->pArg->virtualBox, FindMachine(Bstr(pCtx->pszVmNameOrUuid).raw(), machine.asOutParam()));
677 if (SUCCEEDED(hrc))
678 {
679 MachineState_T enmMachineState;
680 CHECK_ERROR(machine, COMGETTER(State)(&enmMachineState));
681 if ( SUCCEEDED(hrc)
682 && enmMachineState == MachineState_Running)
683 {
684 /*
685 * It's running. So, open a session to it and get the IGuest interface.
686 */
687 CHECK_ERROR(machine, LockMachine(pCtx->pArg->session, LockType_Shared));
688 if (SUCCEEDED(hrc))
689 {
690 pCtx->fLockedVmSession = true;
691 ComPtr<IConsole> ptrConsole;
692 CHECK_ERROR(pCtx->pArg->session, COMGETTER(Console)(ptrConsole.asOutParam()));
693 if (SUCCEEDED(hrc))
694 {
695 if (ptrConsole.isNotNull())
696 {
697 CHECK_ERROR(ptrConsole, COMGETTER(Guest)(pCtx->pGuest.asOutParam()));
698 if (SUCCEEDED(hrc))
699 return RTEXITCODE_SUCCESS;
700 }
701 else
702 RTMsgError(GuestCtrl::tr("Failed to get a IConsole pointer for the machine. Is it still running?\n"));
703 }
704 }
705 }
706 else if (SUCCEEDED(hrc))
707 RTMsgError(GuestCtrl::tr("Machine \"%s\" is not running (currently %s)!\n"),
708 pCtx->pszVmNameOrUuid, machineStateToName(enmMachineState, false));
709 }
710 return RTEXITCODE_FAILURE;
711}
712
713
714/**
715 * Creates a guest session with the VM.
716 *
717 * @retval RTEXITCODE_SUCCESS on success.
718 * @retval RTEXITCODE_FAILURE and user message on failure.
719 * @param pCtx The guest control command context.
720 * GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID
721 * will be set.
722 */
723static RTEXITCODE gctlCtxInitGuestSession(PGCTLCMDCTX pCtx)
724{
725 HRESULT hrc;
726 AssertPtr(pCtx);
727 Assert(!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS));
728 Assert(pCtx->pGuest.isNotNull());
729
730 /*
731 * Build up a reasonable guest session name. Useful for identifying
732 * a specific session when listing / searching for them.
733 */
734 char *pszSessionName;
735 if (RTStrAPrintf(&pszSessionName,
736 GuestCtrl::tr("[%RU32] VBoxManage Guest Control [%s] - %s"),
737 RTProcSelf(), pCtx->pszVmNameOrUuid, pCtx->pCmdDef->pszName) < 0)
738 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("No enough memory for session name"));
739
740 /*
741 * Create a guest session.
742 */
743 if (pCtx->cVerbose)
744 RTPrintf(GuestCtrl::tr("Creating guest session as user '%s'...\n"), pCtx->strUsername.c_str());
745 try
746 {
747 CHECK_ERROR(pCtx->pGuest, CreateSession(Bstr(pCtx->strUsername).raw(),
748 Bstr(pCtx->strPassword).raw(),
749 Bstr(pCtx->strDomain).raw(),
750 Bstr(pszSessionName).raw(),
751 pCtx->pGuestSession.asOutParam()));
752 }
753 catch (std::bad_alloc &)
754 {
755 RTMsgError(GuestCtrl::tr("Out of memory setting up IGuest::CreateSession call"));
756 hrc = E_OUTOFMEMORY;
757 }
758 if (SUCCEEDED(hrc))
759 {
760 /*
761 * Wait for guest session to start.
762 */
763 if (pCtx->cVerbose)
764 RTPrintf(GuestCtrl::tr("Waiting for guest session to start...\n"));
765 GuestSessionWaitResult_T enmWaitResult = GuestSessionWaitResult_None; /* Shut up MSC */
766 try
767 {
768 com::SafeArray<GuestSessionWaitForFlag_T> aSessionWaitFlags;
769 aSessionWaitFlags.push_back(GuestSessionWaitForFlag_Start);
770 CHECK_ERROR(pCtx->pGuestSession, WaitForArray(ComSafeArrayAsInParam(aSessionWaitFlags),
771 /** @todo Make session handling timeouts configurable. */
772 30 * 1000, &enmWaitResult));
773 }
774 catch (std::bad_alloc &)
775 {
776 RTMsgError(GuestCtrl::tr("Out of memory setting up IGuestSession::WaitForArray call"));
777 hrc = E_OUTOFMEMORY;
778 }
779 if (SUCCEEDED(hrc))
780 {
781 /* The WaitFlagNotSupported result may happen with GAs older than 4.3. */
782 if ( enmWaitResult == GuestSessionWaitResult_Start
783 || enmWaitResult == GuestSessionWaitResult_WaitFlagNotSupported)
784 {
785 /*
786 * Get the session ID and we're ready to rumble.
787 */
788 CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Id)(&pCtx->uSessionID));
789 if (SUCCEEDED(hrc))
790 {
791 if (pCtx->cVerbose)
792 RTPrintf(GuestCtrl::tr("Successfully started guest session (ID %RU32)\n"), pCtx->uSessionID);
793 RTStrFree(pszSessionName);
794 return RTEXITCODE_SUCCESS;
795 }
796 }
797 else
798 {
799 GuestSessionStatus_T enmSessionStatus;
800 CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Status)(&enmSessionStatus));
801 RTMsgError(GuestCtrl::tr("Error starting guest session (current status is: %s)\n"),
802 SUCCEEDED(hrc) ? gctlGuestSessionStatusToText(enmSessionStatus) : GuestCtrl::tr("<unknown>"));
803 }
804 }
805 }
806
807 RTStrFree(pszSessionName);
808 return RTEXITCODE_FAILURE;
809}
810
811
812/**
813 * Completes the guest control context initialization after parsing arguments.
814 *
815 * Will validate common arguments, open a VM session, and if requested open a
816 * guest session and install the CTRL-C signal handler.
817 *
818 * It is good to validate all the options and arguments you can before making
819 * this call. However, the VM session, IGuest and IGuestSession interfaces are
820 * not availabe till after this call, so take care.
821 *
822 * @retval RTEXITCODE_SUCCESS on success.
823 * @retval RTEXITCODE_FAILURE and user message on failure.
824 * @param pCtx The guest control command context.
825 * GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID
826 * will be set.
827 * @remarks Can safely be called multiple times, will only do work once.
828 */
829static RTEXITCODE gctlCtxPostOptionParsingInit(PGCTLCMDCTX pCtx)
830{
831 if (pCtx->fPostOptionParsingInited)
832 return RTEXITCODE_SUCCESS;
833
834 /*
835 * Check that the user name isn't empty when we need it.
836 */
837 RTEXITCODE rcExit;
838 if ( (pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)
839 || pCtx->strUsername.isNotEmpty())
840 {
841 /*
842 * Open the VM session and if required, a guest session.
843 */
844 rcExit = gctlCtxInitVmSession(pCtx);
845 if ( rcExit == RTEXITCODE_SUCCESS
846 && !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
847 rcExit = gctlCtxInitGuestSession(pCtx);
848 if (rcExit == RTEXITCODE_SUCCESS)
849 {
850 /*
851 * Install signal handler if requested (errors are ignored).
852 */
853 if (!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_NO_SIGNAL_HANDLER))
854 {
855 int vrc = gctlSignalHandlerInstall();
856 pCtx->fInstalledSignalHandler = RT_SUCCESS(vrc);
857 }
858 }
859 }
860 else
861 rcExit = errorSyntax(GuestCtrl::tr("No user name specified!"));
862
863 pCtx->fPostOptionParsingInited = rcExit == RTEXITCODE_SUCCESS;
864 return rcExit;
865}
866
867
868/**
869 * Cleans up the context when the command returns.
870 *
871 * This will close any open guest session, unless the DETACH flag is set.
872 * It will also close any VM session that may be been established. Any signal
873 * handlers we've installed will also be removed.
874 *
875 * Un-initializes the VM after guest control usage.
876 * @param pCmdCtx Pointer to command context.
877 */
878static void gctlCtxTerm(PGCTLCMDCTX pCtx)
879{
880 HRESULT hrc;
881 AssertPtr(pCtx);
882
883 /*
884 * Uninstall signal handler.
885 */
886 if (pCtx->fInstalledSignalHandler)
887 {
888 gctlSignalHandlerUninstall();
889 pCtx->fInstalledSignalHandler = false;
890 }
891
892 /*
893 * Close, or at least release, the guest session.
894 */
895 if (pCtx->pGuestSession.isNotNull())
896 {
897 if ( !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)
898 && !pCtx->fDetachGuestSession)
899 {
900 if (pCtx->cVerbose)
901 RTPrintf(GuestCtrl::tr("Closing guest session ...\n"));
902
903 CHECK_ERROR(pCtx->pGuestSession, Close());
904 }
905 else if ( pCtx->fDetachGuestSession
906 && pCtx->cVerbose)
907 RTPrintf(GuestCtrl::tr("Guest session detached\n"));
908
909 pCtx->pGuestSession.setNull();
910 }
911
912 /*
913 * Close the VM session.
914 */
915 if (pCtx->fLockedVmSession)
916 {
917 Assert(pCtx->pArg->session.isNotNull());
918 CHECK_ERROR(pCtx->pArg->session, UnlockMachine());
919 pCtx->fLockedVmSession = false;
920 }
921}
922
923
924
925
926
927/*
928 *
929 *
930 * Guest Control Command Handling.
931 * Guest Control Command Handling.
932 * Guest Control Command Handling.
933 * Guest Control Command Handling.
934 * Guest Control Command Handling.
935 *
936 *
937 */
938
939
940/** @name EXITCODEEXEC_XXX - Special run exit codes.
941 *
942 * Special exit codes for returning errors/information of a started guest
943 * process to the command line VBoxManage was started from. Useful for e.g.
944 * scripting.
945 *
946 * ASSUMING that all platforms have at least 7-bits for the exit code we can do
947 * the following mapping:
948 * - Guest exit code 0 is mapped to 0 on the host.
949 * - Guest exit codes 1 thru 93 (0x5d) are displaced by 32, so that 1
950 * becomes 33 (0x21) on the host and 93 becomes 125 (0x7d) on the host.
951 * - Guest exit codes 94 (0x5e) and above are mapped to 126 (0x5e).
952 *
953 * We ASSUME that all VBoxManage status codes are in the range 0 thru 32.
954 *
955 * @note These are frozen as of 4.1.0.
956 * @note The guest exit code mappings was introduced with 5.0 and the 'run'
957 * command, they are/was not supported by 'exec'.
958 * @sa gctlRunCalculateExitCode
959 */
960/** Process exited normally but with an exit code <> 0. */
961#define EXITCODEEXEC_CODE ((RTEXITCODE)16)
962#define EXITCODEEXEC_FAILED ((RTEXITCODE)17)
963#define EXITCODEEXEC_TERM_SIGNAL ((RTEXITCODE)18)
964#define EXITCODEEXEC_TERM_ABEND ((RTEXITCODE)19)
965#define EXITCODEEXEC_TIMEOUT ((RTEXITCODE)20)
966#define EXITCODEEXEC_DOWN ((RTEXITCODE)21)
967/** Execution was interrupt by user (ctrl-c). */
968#define EXITCODEEXEC_CANCELED ((RTEXITCODE)22)
969/** The first mapped guest (non-zero) exit code. */
970#define EXITCODEEXEC_MAPPED_FIRST 33
971/** The last mapped guest (non-zero) exit code value (inclusive). */
972#define EXITCODEEXEC_MAPPED_LAST 125
973/** The number of exit codes from EXITCODEEXEC_MAPPED_FIRST to
974 * EXITCODEEXEC_MAPPED_LAST. This is also the highest guest exit code number
975 * we're able to map. */
976#define EXITCODEEXEC_MAPPED_RANGE (93)
977/** The guest exit code displacement value. */
978#define EXITCODEEXEC_MAPPED_DISPLACEMENT 32
979/** The guest exit code was too big to be mapped. */
980#define EXITCODEEXEC_MAPPED_BIG ((RTEXITCODE)126)
981/** @} */
982
983/**
984 * Calculates the exit code of VBoxManage.
985 *
986 * @returns The exit code to return.
987 * @param enmStatus The guest process status.
988 * @param uExitCode The associated guest process exit code (where
989 * applicable).
990 * @param fReturnExitCodes Set if we're to use the 32-126 range for guest
991 * exit codes.
992 */
993static RTEXITCODE gctlRunCalculateExitCode(ProcessStatus_T enmStatus, ULONG uExitCode, bool fReturnExitCodes)
994{
995 switch (enmStatus)
996 {
997 case ProcessStatus_TerminatedNormally:
998 if (uExitCode == 0)
999 return RTEXITCODE_SUCCESS;
1000 if (!fReturnExitCodes)
1001 return EXITCODEEXEC_CODE;
1002 if (uExitCode <= EXITCODEEXEC_MAPPED_RANGE)
1003 return (RTEXITCODE) (uExitCode + EXITCODEEXEC_MAPPED_DISPLACEMENT);
1004 return EXITCODEEXEC_MAPPED_BIG;
1005
1006 case ProcessStatus_TerminatedAbnormally:
1007 return EXITCODEEXEC_TERM_ABEND;
1008 case ProcessStatus_TerminatedSignal:
1009 return EXITCODEEXEC_TERM_SIGNAL;
1010
1011#if 0 /* see caller! */
1012 case ProcessStatus_TimedOutKilled:
1013 return EXITCODEEXEC_TIMEOUT;
1014 case ProcessStatus_Down:
1015 return EXITCODEEXEC_DOWN; /* Service/OS is stopping, process was killed. */
1016 case ProcessStatus_Error:
1017 return EXITCODEEXEC_FAILED;
1018
1019 /* The following is probably for detached? */
1020 case ProcessStatus_Starting:
1021 return RTEXITCODE_SUCCESS;
1022 case ProcessStatus_Started:
1023 return RTEXITCODE_SUCCESS;
1024 case ProcessStatus_Paused:
1025 return RTEXITCODE_SUCCESS;
1026 case ProcessStatus_Terminating:
1027 return RTEXITCODE_SUCCESS; /** @todo ???? */
1028#endif
1029
1030 default:
1031 AssertMsgFailed(("Unknown exit status (%u/%u) from guest process returned!\n", enmStatus, uExitCode));
1032 return RTEXITCODE_FAILURE;
1033 }
1034}
1035
1036
1037/**
1038 * Pumps guest output to the host.
1039 *
1040 * @return IPRT status code.
1041 * @param pProcess Pointer to appropriate process object.
1042 * @param hVfsIosDst Where to write the data. Can be the bit bucket or a (valid [std]) handle.
1043 * @param uHandle Handle where to read the data from.
1044 * @param cMsTimeout Timeout (in ms) to wait for the operation to
1045 * complete.
1046 */
1047static int gctlRunPumpOutput(IProcess *pProcess, RTVFSIOSTREAM hVfsIosDst, ULONG uHandle, RTMSINTERVAL cMsTimeout)
1048{
1049 AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1050 Assert(hVfsIosDst != NIL_RTVFSIOSTREAM);
1051
1052 int vrc;
1053
1054 SafeArray<BYTE> aOutputData;
1055 HRESULT hrc = pProcess->Read(uHandle, _64K, RT_MAX(cMsTimeout, 1), ComSafeArrayAsOutParam(aOutputData));
1056 if (SUCCEEDED(hrc))
1057 {
1058 size_t cbOutputData = aOutputData.size();
1059 if (cbOutputData == 0)
1060 vrc = VINF_SUCCESS;
1061 else
1062 {
1063 BYTE const *pbBuf = aOutputData.raw();
1064 AssertPtr(pbBuf);
1065
1066 vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /*fBlocking*/, NULL);
1067 if (RT_FAILURE(vrc))
1068 RTMsgError(GuestCtrl::tr("Unable to write output, vrc=%Rrc\n"), vrc);
1069 }
1070 }
1071 else
1072 vrc = gctlPrintError(pProcess, COM_IIDOF(IProcess));
1073 return vrc;
1074}
1075
1076
1077/**
1078 * Configures a host handle for pumping guest bits.
1079 *
1080 * @returns true if enabled and we successfully configured it.
1081 * @param fEnabled Whether pumping this pipe is configured to std handles,
1082 * or going to the bit bucket instead.
1083 * @param enmHandle The IPRT standard handle designation.
1084 * @param pszName The name for user messages.
1085 * @param enmTransformation The transformation to apply.
1086 * @param phVfsIos Where to return the resulting I/O stream handle.
1087 */
1088static bool gctlRunSetupHandle(bool fEnabled, RTHANDLESTD enmHandle, const char *pszName,
1089 kStreamTransform enmTransformation, PRTVFSIOSTREAM phVfsIos)
1090{
1091 if (fEnabled)
1092 {
1093 int vrc = RTVfsIoStrmFromStdHandle(enmHandle, 0, true /*fLeaveOpen*/, phVfsIos);
1094 if (RT_SUCCESS(vrc))
1095 {
1096 if (enmTransformation != kStreamTransform_None)
1097 {
1098 RTMsgWarning(GuestCtrl::tr("Unsupported %s line ending conversion"), pszName);
1099 /** @todo Implement dos2unix and unix2dos stream filters. */
1100 }
1101 return true;
1102 }
1103 RTMsgWarning(GuestCtrl::tr("Error getting %s handle: %Rrc"), pszName, vrc);
1104 }
1105 else /* If disabled, all goes to / gets fed to/from the bit bucket. */
1106 {
1107 RTFILE hFile;
1108 int vrc = RTFileOpenBitBucket(&hFile, enmHandle == RTHANDLESTD_INPUT ? RTFILE_O_READ : RTFILE_O_WRITE);
1109 if (RT_SUCCESS(vrc))
1110 {
1111 vrc = RTVfsIoStrmFromRTFile(hFile, 0 /* fOpen */, false /* fLeaveOpen */, phVfsIos);
1112 if (RT_SUCCESS(vrc))
1113 return true;
1114 }
1115 }
1116
1117 return false;
1118}
1119
1120
1121/**
1122 * Returns the remaining time (in ms) based on the start time and a set
1123 * timeout value. Returns RT_INDEFINITE_WAIT if no timeout was specified.
1124 *
1125 * @return RTMSINTERVAL Time left (in ms).
1126 * @param u64StartMs Start time (in ms).
1127 * @param cMsTimeout Timeout value (in ms).
1128 */
1129static RTMSINTERVAL gctlRunGetRemainingTime(uint64_t u64StartMs, RTMSINTERVAL cMsTimeout)
1130{
1131 if (!cMsTimeout || cMsTimeout == RT_INDEFINITE_WAIT) /* If no timeout specified, wait forever. */
1132 return RT_INDEFINITE_WAIT;
1133
1134 uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
1135 if (u64ElapsedMs >= cMsTimeout)
1136 return 0;
1137
1138 return cMsTimeout - (RTMSINTERVAL)u64ElapsedMs;
1139}
1140
1141/**
1142 * Common handler for the 'run' and 'start' commands.
1143 *
1144 * @returns Command exit code.
1145 * @param pCtx Guest session context.
1146 * @param argc The argument count.
1147 * @param argv The argument vector for this command.
1148 * @param fRunCmd Set if it's 'run' clear if 'start'.
1149 */
1150static RTEXITCODE gctlHandleRunCommon(PGCTLCMDCTX pCtx, int argc, char **argv, bool fRunCmd)
1151{
1152 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1153
1154 /*
1155 * Parse arguments.
1156 */
1157 enum kGstCtrlRunOpt
1158 {
1159 kGstCtrlRunOpt_IgnoreOrphanedProcesses = 1000,
1160 kGstCtrlRunOpt_NoProfile, /** @todo Deprecated and will be removed soon; use kGstCtrlRunOpt_Profile instead, if needed. */
1161 kGstCtrlRunOpt_Profile,
1162 kGstCtrlRunOpt_Dos2Unix,
1163 kGstCtrlRunOpt_Unix2Dos,
1164 kGstCtrlRunOpt_WaitForStdOut,
1165 kGstCtrlRunOpt_NoWaitForStdOut,
1166 kGstCtrlRunOpt_WaitForStdErr,
1167 kGstCtrlRunOpt_NoWaitForStdErr
1168 };
1169 static const RTGETOPTDEF s_aOptions[] =
1170 {
1171 GCTLCMD_COMMON_OPTION_DEFS()
1172 { "--arg0", '0', RTGETOPT_REQ_STRING },
1173 { "--cwd", 'C', RTGETOPT_REQ_STRING },
1174 { "--putenv", 'E', RTGETOPT_REQ_STRING },
1175 { "--exe", 'e', RTGETOPT_REQ_STRING },
1176 { "--timeout", 't', RTGETOPT_REQ_UINT32 },
1177 { "--unquoted-args", 'u', RTGETOPT_REQ_NOTHING },
1178 { "--ignore-operhaned-processes", kGstCtrlRunOpt_IgnoreOrphanedProcesses, RTGETOPT_REQ_NOTHING },
1179 { "--no-profile", kGstCtrlRunOpt_NoProfile, RTGETOPT_REQ_NOTHING }, /** @todo Deprecated. */
1180 { "--profile", kGstCtrlRunOpt_Profile, RTGETOPT_REQ_NOTHING },
1181 /* run only: 6 - options */
1182 { "--dos2unix", kGstCtrlRunOpt_Dos2Unix, RTGETOPT_REQ_NOTHING },
1183 { "--unix2dos", kGstCtrlRunOpt_Unix2Dos, RTGETOPT_REQ_NOTHING },
1184 { "--no-wait-stdout", kGstCtrlRunOpt_NoWaitForStdOut, RTGETOPT_REQ_NOTHING },
1185 { "--wait-stdout", kGstCtrlRunOpt_WaitForStdOut, RTGETOPT_REQ_NOTHING },
1186 { "--no-wait-stderr", kGstCtrlRunOpt_NoWaitForStdErr, RTGETOPT_REQ_NOTHING },
1187 { "--wait-stderr", kGstCtrlRunOpt_WaitForStdErr, RTGETOPT_REQ_NOTHING },
1188 };
1189
1190 /** @todo stdin handling. */
1191
1192 int ch;
1193 RTGETOPTUNION ValueUnion;
1194 RTGETOPTSTATE GetState;
1195 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions) - (fRunCmd ? 0 : 6),
1196 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1197 AssertRC(vrc);
1198
1199 com::SafeArray<ProcessCreateFlag_T> aCreateFlags;
1200 com::SafeArray<ProcessWaitForFlag_T> aWaitFlags;
1201 com::SafeArray<IN_BSTR> aArgs;
1202 com::SafeArray<IN_BSTR> aEnv;
1203 const char * pszImage = NULL;
1204 const char * pszArg0 = NULL; /* Argument 0 to use. pszImage will be used if not specified. */
1205 const char * pszCwd = NULL;
1206 bool fWaitForStdOut = fRunCmd;
1207 bool fWaitForStdErr = fRunCmd;
1208 RTVFSIOSTREAM hVfsStdOut = NIL_RTVFSIOSTREAM;
1209 RTVFSIOSTREAM hVfsStdErr = NIL_RTVFSIOSTREAM;
1210 enum kStreamTransform enmStdOutTransform = kStreamTransform_None;
1211 enum kStreamTransform enmStdErrTransform = kStreamTransform_None;
1212 RTMSINTERVAL cMsTimeout = 0;
1213
1214 try
1215 {
1216 /* Wait for process start in any case. This is useful for scripting VBoxManage
1217 * when relying on its overall exit code. */
1218 aWaitFlags.push_back(ProcessWaitForFlag_Start);
1219
1220 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1221 {
1222 /* For options that require an argument, ValueUnion has received the value. */
1223 switch (ch)
1224 {
1225 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1226
1227 case 'E':
1228 if ( ValueUnion.psz[0] == '\0'
1229 || ValueUnion.psz[0] == '=')
1230 return errorSyntax(GuestCtrl::tr("Invalid argument variable[=value]: '%s'"), ValueUnion.psz);
1231 aEnv.push_back(Bstr(ValueUnion.psz).raw());
1232 break;
1233
1234 case kGstCtrlRunOpt_IgnoreOrphanedProcesses:
1235 aCreateFlags.push_back(ProcessCreateFlag_IgnoreOrphanedProcesses);
1236 break;
1237
1238 case kGstCtrlRunOpt_NoProfile:
1239 /** @todo Deprecated, will be removed. */
1240 RTPrintf(GuestCtrl::tr("Warning: Deprecated option \"--no-profile\" specified\n"));
1241 break;
1242
1243 case kGstCtrlRunOpt_Profile:
1244 aCreateFlags.push_back(ProcessCreateFlag_Profile);
1245 break;
1246
1247 case '0':
1248 pszArg0 = ValueUnion.psz;
1249 break;
1250
1251 case 'C':
1252 pszCwd = ValueUnion.psz;
1253 break;
1254
1255 case 'e':
1256 pszImage = ValueUnion.psz;
1257 break;
1258
1259 case 'u':
1260 aCreateFlags.push_back(ProcessCreateFlag_UnquotedArguments);
1261 break;
1262
1263 /** @todo Add a hidden flag. */
1264
1265 case 't': /* Timeout */
1266 cMsTimeout = ValueUnion.u32;
1267 break;
1268
1269 /* run only options: */
1270 case kGstCtrlRunOpt_Dos2Unix:
1271 Assert(fRunCmd);
1272 enmStdErrTransform = enmStdOutTransform = kStreamTransform_Dos2Unix;
1273 break;
1274 case kGstCtrlRunOpt_Unix2Dos:
1275 Assert(fRunCmd);
1276 enmStdErrTransform = enmStdOutTransform = kStreamTransform_Unix2Dos;
1277 break;
1278
1279 case kGstCtrlRunOpt_WaitForStdOut:
1280 Assert(fRunCmd);
1281 fWaitForStdOut = true;
1282 break;
1283 case kGstCtrlRunOpt_NoWaitForStdOut:
1284 Assert(fRunCmd);
1285 fWaitForStdOut = false;
1286 break;
1287
1288 case kGstCtrlRunOpt_WaitForStdErr:
1289 Assert(fRunCmd);
1290 fWaitForStdErr = true;
1291 break;
1292 case kGstCtrlRunOpt_NoWaitForStdErr:
1293 Assert(fRunCmd);
1294 fWaitForStdErr = false;
1295 break;
1296
1297 case VINF_GETOPT_NOT_OPTION:
1298 /* VINF_GETOPT_NOT_OPTION comes after all options have been specified;
1299 * so if pszImage still is zero at this stage, we use the first non-option found
1300 * as the image being executed. */
1301 if (!pszImage)
1302 pszImage = ValueUnion.psz;
1303 else /* Add anything else to the arguments vector. */
1304 aArgs.push_back(Bstr(ValueUnion.psz).raw());
1305 break;
1306
1307 default:
1308 return errorGetOpt(ch, &ValueUnion);
1309
1310 } /* switch */
1311 } /* while RTGetOpt */
1312
1313 /* Must have something to execute. */
1314 if (!pszImage || !*pszImage)
1315 return errorSyntax(GuestCtrl::tr("No executable specified!"));
1316
1317 /* Set the arg0 argument (descending precedence):
1318 * - If an argument 0 is explicitly specified (via "--arg0"), use this as argument 0.
1319 * - When an image is specified explicitly (via "--exe <image>"), use <image> as argument 0.
1320 * Note: This is (and ever was) the default behavior users expect, so don't change this! */
1321 if (pszArg0)
1322 aArgs.push_front(Bstr(pszArg0).raw());
1323 else
1324 aArgs.push_front(Bstr(pszImage).raw());
1325
1326 if (pCtx->cVerbose) /* Print the final execution parameters in verbose mode. */
1327 {
1328 RTPrintf(GuestCtrl::tr("Executing:\n Image : %s\n"), pszImage);
1329 for (size_t i = 0; i < aArgs.size(); i++)
1330 RTPrintf(GuestCtrl::tr(" arg[%d]: %ls\n"), i, aArgs[i]);
1331 }
1332 /* No altering of aArgs and/or pszImage after this point! */
1333
1334 /*
1335 * Finalize process creation and wait flags and input/output streams.
1336 */
1337 if (!fRunCmd)
1338 {
1339 aCreateFlags.push_back(ProcessCreateFlag_WaitForProcessStartOnly);
1340 Assert(!fWaitForStdOut);
1341 Assert(!fWaitForStdErr);
1342 }
1343 else
1344 {
1345 aWaitFlags.push_back(ProcessWaitForFlag_Terminate);
1346 fWaitForStdOut = gctlRunSetupHandle(fWaitForStdOut, RTHANDLESTD_OUTPUT, "stdout", enmStdOutTransform, &hVfsStdOut);
1347 if (fWaitForStdOut)
1348 {
1349 aCreateFlags.push_back(ProcessCreateFlag_WaitForStdOut);
1350 aWaitFlags.push_back(ProcessWaitForFlag_StdOut);
1351 }
1352 fWaitForStdErr = gctlRunSetupHandle(fWaitForStdErr, RTHANDLESTD_ERROR, "stderr", enmStdErrTransform, &hVfsStdErr);
1353 if (fWaitForStdErr)
1354 {
1355 aCreateFlags.push_back(ProcessCreateFlag_WaitForStdErr);
1356 aWaitFlags.push_back(ProcessWaitForFlag_StdErr);
1357 }
1358 }
1359 }
1360 catch (std::bad_alloc &)
1361 {
1362 return RTMsgErrorExit(RTEXITCODE_FAILURE, "VERR_NO_MEMORY\n");
1363 }
1364
1365 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1366 if (rcExit != RTEXITCODE_SUCCESS)
1367 return rcExit;
1368
1369 HRESULT hrc;
1370
1371 try
1372 {
1373 do
1374 {
1375 /* Get current time stamp to later calculate rest of timeout left. */
1376 uint64_t msStart = RTTimeMilliTS();
1377
1378 /*
1379 * Create the process.
1380 */
1381 if (pCtx->cVerbose)
1382 {
1383 if (cMsTimeout == 0)
1384 RTPrintf(GuestCtrl::tr("Starting guest process ...\n"));
1385 else
1386 RTPrintf(GuestCtrl::tr("Starting guest process (within %ums)\n"), cMsTimeout);
1387 }
1388 ComPtr<IGuestProcess> pProcess;
1389 CHECK_ERROR_BREAK(pCtx->pGuestSession, ProcessCreate(Bstr(pszImage).raw(),
1390 ComSafeArrayAsInParam(aArgs),
1391 Bstr(pszCwd).raw(),
1392 ComSafeArrayAsInParam(aEnv),
1393 ComSafeArrayAsInParam(aCreateFlags),
1394 gctlRunGetRemainingTime(msStart, cMsTimeout),
1395 pProcess.asOutParam()));
1396
1397 /*
1398 * Explicitly wait for the guest process to be in a started state.
1399 */
1400 com::SafeArray<ProcessWaitForFlag_T> aWaitStartFlags;
1401 aWaitStartFlags.push_back(ProcessWaitForFlag_Start);
1402 ProcessWaitResult_T waitResult;
1403 CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitStartFlags),
1404 gctlRunGetRemainingTime(msStart, cMsTimeout), &waitResult));
1405
1406 ULONG uPID = 0;
1407 CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
1408 if (fRunCmd && pCtx->cVerbose)
1409 RTPrintf(GuestCtrl::tr("Process '%s' (PID %RU32) started\n"), pszImage, uPID);
1410 else if (!fRunCmd && pCtx->cVerbose)
1411 {
1412 /* Just print plain PID to make it easier for scripts
1413 * invoking VBoxManage. */
1414 RTPrintf(GuestCtrl::tr("[%RU32 - Session %RU32]\n"), uPID, pCtx->uSessionID);
1415 }
1416
1417 /*
1418 * Wait for process to exit/start...
1419 */
1420 RTMSINTERVAL cMsTimeLeft = 1; /* Will be calculated. */
1421 bool fReadStdOut = false;
1422 bool fReadStdErr = false;
1423 bool fCompleted = false;
1424 bool fCompletedStartCmd = false;
1425
1426 vrc = VINF_SUCCESS;
1427 while ( !fCompleted
1428 && cMsTimeLeft > 0)
1429 {
1430 cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1431 CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitFlags),
1432 RT_MIN(500 /*ms*/, RT_MAX(cMsTimeLeft, 1 /*ms*/)),
1433 &waitResult));
1434 if (pCtx->cVerbose)
1435 RTPrintf(GuestCtrl::tr("Wait result is '%s' (%d)\n"), gctlProcessWaitResultToText(waitResult), waitResult);
1436 switch (waitResult)
1437 {
1438 case ProcessWaitResult_Start: /** @todo you always wait for 'start', */
1439 fCompletedStartCmd = fCompleted = !fRunCmd; /* Only wait for startup if the 'start' command. */
1440 if (!fCompleted && aWaitFlags[0] == ProcessWaitForFlag_Start)
1441 aWaitFlags[0] = ProcessWaitForFlag_Terminate;
1442 break;
1443 case ProcessWaitResult_StdOut:
1444 fReadStdOut = true;
1445 break;
1446 case ProcessWaitResult_StdErr:
1447 fReadStdErr = true;
1448 break;
1449 case ProcessWaitResult_Terminate:
1450 if (pCtx->cVerbose)
1451 RTPrintf(GuestCtrl::tr("Process terminated\n"));
1452 /* Process terminated, we're done. */
1453 fCompleted = true;
1454 break;
1455 case ProcessWaitResult_WaitFlagNotSupported:
1456 /* The guest does not support waiting for stdout/err, so
1457 * yield to reduce the CPU load due to busy waiting. */
1458 RTThreadYield();
1459 fReadStdOut = fReadStdErr = true;
1460 /* Note: In case the user specified explicitly not wanting to wait for stdout / stderr,
1461 * the configured VFS handle goes to / will be fed from the bit bucket. */
1462 break;
1463 case ProcessWaitResult_Timeout:
1464 {
1465 /** @todo It is really unclear whether we will get stuck with the timeout
1466 * result here if the guest side times out the process and fails to
1467 * kill the process... To be on the save side, double the IPC and
1468 * check the process status every time we time out. */
1469 ProcessStatus_T enmProcStatus;
1470 CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&enmProcStatus));
1471 if ( enmProcStatus == ProcessStatus_TimedOutKilled
1472 || enmProcStatus == ProcessStatus_TimedOutAbnormally)
1473 fCompleted = true;
1474 fReadStdOut = fReadStdErr = true;
1475 break;
1476 }
1477 case ProcessWaitResult_Status:
1478 /* ignore. */
1479 break;
1480 case ProcessWaitResult_Error:
1481 /* waitFor is dead in the water, I think, so better leave the loop. */
1482 vrc = VERR_CALLBACK_RETURN;
1483 break;
1484
1485 case ProcessWaitResult_StdIn: AssertFailed(); /* did ask for this! */ break;
1486 case ProcessWaitResult_None: AssertFailed(); /* used. */ break;
1487 default: AssertFailed(); /* huh? */ break;
1488 }
1489
1490 if (g_fGuestCtrlCanceled)
1491 break;
1492
1493 /*
1494 * Pump output as needed.
1495 */
1496 if (fReadStdOut)
1497 {
1498 cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1499 int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdOut, 1 /* StdOut */, cMsTimeLeft);
1500 if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1501 vrc = vrc2;
1502 fReadStdOut = false;
1503 }
1504 if (fReadStdErr)
1505 {
1506 cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1507 int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdErr, 2 /* StdErr */, cMsTimeLeft);
1508 if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1509 vrc = vrc2;
1510 fReadStdErr = false;
1511 }
1512 if ( RT_FAILURE(vrc)
1513 || g_fGuestCtrlCanceled)
1514 break;
1515
1516 /*
1517 * Process events before looping.
1518 */
1519 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
1520 } /* while */
1521
1522 /*
1523 * Report status back to the user.
1524 */
1525 if (g_fGuestCtrlCanceled)
1526 {
1527 if (pCtx->cVerbose)
1528 RTPrintf(GuestCtrl::tr("Process execution aborted!\n"));
1529 rcExit = EXITCODEEXEC_CANCELED;
1530 }
1531 else if (fCompletedStartCmd)
1532 {
1533 if (pCtx->cVerbose)
1534 RTPrintf(GuestCtrl::tr("Process successfully started!\n"));
1535 rcExit = RTEXITCODE_SUCCESS;
1536 }
1537 else if (fCompleted)
1538 {
1539 ProcessStatus_T procStatus;
1540 CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&procStatus));
1541 if ( procStatus == ProcessStatus_TerminatedNormally
1542 || procStatus == ProcessStatus_TerminatedAbnormally
1543 || procStatus == ProcessStatus_TerminatedSignal)
1544 {
1545 LONG lExitCode;
1546 CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode));
1547 if (pCtx->cVerbose)
1548 RTPrintf(GuestCtrl::tr("Exit code=%u (Status=%u [%s])\n"),
1549 lExitCode, procStatus, gctlProcessStatusToText(procStatus));
1550
1551 rcExit = gctlRunCalculateExitCode(procStatus, lExitCode, true /*fReturnExitCodes*/);
1552 }
1553 else if ( procStatus == ProcessStatus_TimedOutKilled
1554 || procStatus == ProcessStatus_TimedOutAbnormally)
1555 {
1556 if (pCtx->cVerbose)
1557 RTPrintf(GuestCtrl::tr("Process timed out (guest side) and %s\n"),
1558 procStatus == ProcessStatus_TimedOutAbnormally
1559 ? GuestCtrl::tr("failed to terminate so far") : GuestCtrl::tr("was terminated"));
1560 rcExit = EXITCODEEXEC_TIMEOUT;
1561 }
1562 else
1563 {
1564 if (pCtx->cVerbose)
1565 RTPrintf(GuestCtrl::tr("Process now is in status [%s] (unexpected)\n"),
1566 gctlProcessStatusToText(procStatus));
1567 rcExit = RTEXITCODE_FAILURE;
1568 }
1569 }
1570 else if (RT_FAILURE_NP(vrc))
1571 {
1572 if (pCtx->cVerbose)
1573 RTPrintf(GuestCtrl::tr("Process monitor loop quit with vrc=%Rrc\n"), vrc);
1574 rcExit = RTEXITCODE_FAILURE;
1575 }
1576 else
1577 {
1578 if (pCtx->cVerbose)
1579 RTPrintf(GuestCtrl::tr("Process monitor loop timed out\n"));
1580 rcExit = EXITCODEEXEC_TIMEOUT;
1581 }
1582
1583 } while (0);
1584 }
1585 catch (std::bad_alloc &)
1586 {
1587 hrc = E_OUTOFMEMORY;
1588 }
1589
1590 /*
1591 * Decide what to do with the guest session.
1592 *
1593 * If it's the 'start' command where detach the guest process after
1594 * starting, don't close the guest session it is part of, except on
1595 * failure or ctrl-c.
1596 *
1597 * For the 'run' command the guest process quits with us.
1598 */
1599 if (!fRunCmd && SUCCEEDED(hrc) && !g_fGuestCtrlCanceled)
1600 pCtx->fDetachGuestSession = true;
1601
1602 /* Make sure we return failure on failure. */
1603 if (FAILED(hrc) && rcExit == RTEXITCODE_SUCCESS)
1604 rcExit = RTEXITCODE_FAILURE;
1605 return rcExit;
1606}
1607
1608
1609static DECLCALLBACK(RTEXITCODE) gctlHandleRun(PGCTLCMDCTX pCtx, int argc, char **argv)
1610{
1611 return gctlHandleRunCommon(pCtx, argc, argv, true /*fRunCmd*/);
1612}
1613
1614
1615static DECLCALLBACK(RTEXITCODE) gctlHandleStart(PGCTLCMDCTX pCtx, int argc, char **argv)
1616{
1617 return gctlHandleRunCommon(pCtx, argc, argv, false /*fRunCmd*/);
1618}
1619
1620
1621static RTEXITCODE gctlHandleCopy(PGCTLCMDCTX pCtx, int argc, char **argv, bool fHostToGuest)
1622{
1623 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1624
1625 /*
1626 * IGuest::CopyToGuest is kept as simple as possible to let the developer choose
1627 * what and how to implement the file enumeration/recursive lookup, like VBoxManage
1628 * does in here.
1629 */
1630 static const RTGETOPTDEF s_aOptions[] =
1631 {
1632 GCTLCMD_COMMON_OPTION_DEFS()
1633 { "--follow", 'L', RTGETOPT_REQ_NOTHING }, /* Kept for backwards-compatibility (VBox < 7.0). */
1634 { "--dereference", 'L', RTGETOPT_REQ_NOTHING },
1635 { "--no-replace", 'n', RTGETOPT_REQ_NOTHING }, /* like "-n" via cp. */
1636 { "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1637 { "--target-directory", 't', RTGETOPT_REQ_STRING },
1638 { "--update", 'u', RTGETOPT_REQ_NOTHING } /* like "-u" via cp. */
1639 };
1640
1641 int ch;
1642 RTGETOPTUNION ValueUnion;
1643 RTGETOPTSTATE GetState;
1644 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1645
1646 bool fDstMustBeDir = false;
1647 const char *pszDst = NULL;
1648 bool fFollow = false;
1649 bool fRecursive = false;
1650 bool fUpdate = false; /* Whether to copy the file only if it's newer than the target. */
1651 bool fNoReplace = false; /* Only copy the file if it does not exist yet. */
1652
1653 int vrc = VINF_SUCCESS;
1654 while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
1655 && ch != VINF_GETOPT_NOT_OPTION)
1656 {
1657 /* For options that require an argument, ValueUnion has received the value. */
1658 switch (ch)
1659 {
1660 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1661
1662 case 'L':
1663 if (!RTStrICmp(ValueUnion.pDef->pszLong, "--follow"))
1664 RTMsgWarning("--follow is deprecated; use --dereference instead.");
1665 fFollow = true;
1666 break;
1667
1668 case 'n':
1669 fNoReplace = true;
1670 break;
1671
1672 case 'R':
1673 fRecursive = true;
1674 break;
1675
1676 case 't':
1677 pszDst = ValueUnion.psz;
1678 fDstMustBeDir = true;
1679 break;
1680
1681 case 'u':
1682 fUpdate = true;
1683 break;
1684
1685 default:
1686 return errorGetOpt(ch, &ValueUnion);
1687 }
1688 }
1689
1690 char **papszSources = RTGetOptNonOptionArrayPtr(&GetState);
1691 size_t cSources = &argv[argc] - papszSources;
1692
1693 if (!cSources)
1694 return errorSyntax(GuestCtrl::tr("No sources specified!"));
1695
1696 /* Unless a --target-directory is given, the last argument is the destination, so
1697 bump it from the source list. */
1698 if (pszDst == NULL && cSources >= 2)
1699 pszDst = papszSources[--cSources];
1700
1701 if (pszDst == NULL)
1702 return errorSyntax(GuestCtrl::tr("No destination specified!"));
1703
1704 char szAbsDst[RTPATH_MAX];
1705 if (!fHostToGuest)
1706 {
1707 vrc = RTPathAbs(pszDst, szAbsDst, sizeof(szAbsDst));
1708 if (RT_SUCCESS(vrc))
1709 pszDst = szAbsDst;
1710 else
1711 return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbs failed on '%s': %Rrc"), pszDst, vrc);
1712 }
1713
1714 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1715 if (rcExit != RTEXITCODE_SUCCESS)
1716 return rcExit;
1717
1718 /*
1719 * Done parsing arguments, do some more preparations.
1720 */
1721 if (pCtx->cVerbose)
1722 {
1723 if (fHostToGuest)
1724 RTPrintf(GuestCtrl::tr("Copying from host to guest ...\n"));
1725 else
1726 RTPrintf(GuestCtrl::tr("Copying from guest to host ...\n"));
1727 }
1728
1729 HRESULT hrc = S_OK;
1730
1731 com::SafeArray<IN_BSTR> aSources;
1732 com::SafeArray<IN_BSTR> aFilters; /** @todo Populate those? For now we use caller-based globbing. */
1733 com::SafeArray<IN_BSTR> aCopyFlags;
1734
1735 size_t iSrc = 0;
1736 for (; iSrc < cSources; iSrc++)
1737 {
1738 aSources.push_back(Bstr(papszSources[iSrc]).raw());
1739 aFilters.push_back(Bstr("").raw()); /* Empty for now. See @todo above. */
1740
1741 /* Compile the comma-separated list of flags.
1742 * Certain flags are only available for specific file system objects, e.g. directories. */
1743 bool fIsDir = false;
1744 if (fHostToGuest)
1745 {
1746 RTFSOBJINFO ObjInfo;
1747 vrc = RTPathQueryInfo(papszSources[iSrc], &ObjInfo, RTFSOBJATTRADD_NOTHING);
1748 if (RT_SUCCESS(vrc))
1749 fIsDir = RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode);
1750
1751 if (RT_FAILURE(vrc))
1752 break;
1753 }
1754 else /* Guest to host. */
1755 {
1756 ComPtr<IGuestFsObjInfo> pFsObjInfo;
1757 hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(papszSources[iSrc]).raw(), RT_BOOL(fFollow) /* fFollowSymlinks */,
1758 pFsObjInfo.asOutParam());
1759 if (SUCCEEDED(hrc))
1760 {
1761 FsObjType_T enmObjType;
1762 CHECK_ERROR(pFsObjInfo,COMGETTER(Type)(&enmObjType));
1763 if (SUCCEEDED(hrc))
1764 {
1765 /* Take action according to source file. */
1766 fIsDir = enmObjType == FsObjType_Directory;
1767 }
1768 }
1769
1770 if (FAILED(hrc))
1771 {
1772 vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession));
1773 break;
1774 }
1775 }
1776
1777 if (pCtx->cVerbose)
1778 RTPrintf(GuestCtrl::tr("Source '%s' is a %s\n"), papszSources[iSrc], fIsDir ? "directory" : "file");
1779
1780 Utf8Str strCopyFlags;
1781 if (fRecursive && fIsDir) /* Only available for directories. Just ignore otherwise. */
1782 strCopyFlags += "Recursive,";
1783 if (fFollow)
1784 strCopyFlags += "FollowLinks,";
1785 if (fUpdate) /* Only copy source files which are newer than the destination file. */
1786 strCopyFlags += "Update,";
1787 if (fNoReplace) /* Do not overwrite files. */
1788 strCopyFlags += "NoReplace,";
1789 else if (!fNoReplace && fIsDir)
1790 strCopyFlags += "CopyIntoExisting,"; /* Only copy into existing directories if "--no-replace" isn't specified. */
1791 aCopyFlags.push_back(Bstr(strCopyFlags).raw());
1792 }
1793
1794 if (RT_FAILURE(vrc))
1795 return RTMsgErrorExitFailure(GuestCtrl::tr("Error looking file system information for source '%s', vrc=%Rrc"),
1796 papszSources[iSrc], vrc);
1797
1798 ComPtr<IProgress> pProgress;
1799 if (fHostToGuest)
1800 {
1801 hrc = pCtx->pGuestSession->CopyToGuest(ComSafeArrayAsInParam(aSources),
1802 ComSafeArrayAsInParam(aFilters), ComSafeArrayAsInParam(aCopyFlags),
1803 Bstr(pszDst).raw(), pProgress.asOutParam());
1804 }
1805 else /* Guest to host. */
1806 {
1807 hrc = pCtx->pGuestSession->CopyFromGuest(ComSafeArrayAsInParam(aSources),
1808 ComSafeArrayAsInParam(aFilters), ComSafeArrayAsInParam(aCopyFlags),
1809 Bstr(pszDst).raw(), pProgress.asOutParam());
1810 }
1811
1812 if (FAILED(hrc))
1813 {
1814 vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession));
1815 }
1816 else if (pProgress.isNotNull())
1817 {
1818 if (pCtx->cVerbose)
1819 hrc = showProgress(pProgress);
1820 else
1821 hrc = pProgress->WaitForCompletion(-1 /* No timeout */);
1822 if (SUCCEEDED(hrc))
1823 CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("File copy failed")));
1824 vrc = gctlPrintProgressError(pProgress);
1825 }
1826
1827 if (RT_FAILURE(vrc))
1828 rcExit = RTEXITCODE_FAILURE;
1829
1830 return rcExit;
1831}
1832
1833static DECLCALLBACK(RTEXITCODE) gctlHandleCopyFrom(PGCTLCMDCTX pCtx, int argc, char **argv)
1834{
1835 return gctlHandleCopy(pCtx, argc, argv, false /* Guest to host */);
1836}
1837
1838static DECLCALLBACK(RTEXITCODE) gctlHandleCopyTo(PGCTLCMDCTX pCtx, int argc, char **argv)
1839{
1840 return gctlHandleCopy(pCtx, argc, argv, true /* Host to guest */);
1841}
1842
1843static DECLCALLBACK(RTEXITCODE) gctrlHandleMkDir(PGCTLCMDCTX pCtx, int argc, char **argv)
1844{
1845 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1846
1847 static const RTGETOPTDEF s_aOptions[] =
1848 {
1849 GCTLCMD_COMMON_OPTION_DEFS()
1850 { "--mode", 'm', RTGETOPT_REQ_UINT32 },
1851 { "--parents", 'P', RTGETOPT_REQ_NOTHING }
1852 };
1853
1854 int ch;
1855 RTGETOPTUNION ValueUnion;
1856 RTGETOPTSTATE GetState;
1857 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1858
1859 SafeArray<DirectoryCreateFlag_T> aDirCreateFlags;
1860 uint32_t fDirMode = 0; /* Default mode. */
1861 uint32_t cDirsCreated = 0;
1862 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1863
1864 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1865 {
1866 /* For options that require an argument, ValueUnion has received the value. */
1867 switch (ch)
1868 {
1869 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1870
1871 case 'm': /* Mode */
1872 fDirMode = ValueUnion.u32;
1873 break;
1874
1875 case 'P': /* Create parents */
1876 aDirCreateFlags.push_back(DirectoryCreateFlag_Parents);
1877 break;
1878
1879 case VINF_GETOPT_NOT_OPTION:
1880 if (cDirsCreated == 0)
1881 {
1882 /*
1883 * First non-option - no more options now.
1884 */
1885 rcExit = gctlCtxPostOptionParsingInit(pCtx);
1886 if (rcExit != RTEXITCODE_SUCCESS)
1887 return rcExit;
1888 if (pCtx->cVerbose)
1889 RTPrintf(GuestCtrl::tr("Creating %RU32 directories...\n", "", argc - GetState.iNext + 1),
1890 argc - GetState.iNext + 1);
1891 }
1892 if (g_fGuestCtrlCanceled)
1893 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("mkdir was interrupted by Ctrl-C (%u left)\n"),
1894 argc - GetState.iNext + 1);
1895
1896 /*
1897 * Create the specified directory.
1898 *
1899 * On failure we'll change the exit status to failure and
1900 * continue with the next directory that needs creating. We do
1901 * this because we only create new things, and because this is
1902 * how /bin/mkdir works on unix.
1903 */
1904 cDirsCreated++;
1905 if (pCtx->cVerbose)
1906 RTPrintf(GuestCtrl::tr("Creating directory \"%s\" ...\n"), ValueUnion.psz);
1907 try
1908 {
1909 HRESULT hrc;
1910 CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(),
1911 fDirMode, ComSafeArrayAsInParam(aDirCreateFlags)));
1912 if (FAILED(hrc))
1913 rcExit = RTEXITCODE_FAILURE;
1914 }
1915 catch (std::bad_alloc &)
1916 {
1917 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
1918 }
1919 break;
1920
1921 default:
1922 return errorGetOpt(ch, &ValueUnion);
1923 }
1924 }
1925
1926 if (!cDirsCreated)
1927 return errorSyntax(GuestCtrl::tr("No directory to create specified!"));
1928 return rcExit;
1929}
1930
1931
1932static DECLCALLBACK(RTEXITCODE) gctlHandleRmDir(PGCTLCMDCTX pCtx, int argc, char **argv)
1933{
1934 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1935
1936 static const RTGETOPTDEF s_aOptions[] =
1937 {
1938 GCTLCMD_COMMON_OPTION_DEFS()
1939 { "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1940 };
1941
1942 int ch;
1943 RTGETOPTUNION ValueUnion;
1944 RTGETOPTSTATE GetState;
1945 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1946
1947 bool fRecursive = false;
1948 uint32_t cDirRemoved = 0;
1949 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1950
1951 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1952 {
1953 /* For options that require an argument, ValueUnion has received the value. */
1954 switch (ch)
1955 {
1956 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1957
1958 case 'R':
1959 fRecursive = true;
1960 break;
1961
1962 case VINF_GETOPT_NOT_OPTION:
1963 {
1964 if (cDirRemoved == 0)
1965 {
1966 /*
1967 * First non-option - no more options now.
1968 */
1969 rcExit = gctlCtxPostOptionParsingInit(pCtx);
1970 if (rcExit != RTEXITCODE_SUCCESS)
1971 return rcExit;
1972 if (pCtx->cVerbose)
1973 {
1974 if (fRecursive)
1975 RTPrintf(GuestCtrl::tr("Removing %RU32 directory tree(s)...\n", "", argc - GetState.iNext + 1),
1976 argc - GetState.iNext + 1);
1977 else
1978 RTPrintf(GuestCtrl::tr("Removing %RU32 directorie(s)...\n", "", argc - GetState.iNext + 1),
1979 argc - GetState.iNext + 1);
1980 }
1981 }
1982 if (g_fGuestCtrlCanceled)
1983 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rmdir was interrupted by Ctrl-C (%u left)\n"),
1984 argc - GetState.iNext + 1);
1985
1986 cDirRemoved++;
1987 HRESULT hrc;
1988 if (!fRecursive)
1989 {
1990 /*
1991 * Remove exactly one directory.
1992 */
1993 if (pCtx->cVerbose)
1994 RTPrintf(GuestCtrl::tr("Removing directory \"%s\" ...\n"), ValueUnion.psz);
1995 try
1996 {
1997 CHECK_ERROR(pCtx->pGuestSession, DirectoryRemove(Bstr(ValueUnion.psz).raw()));
1998 }
1999 catch (std::bad_alloc &)
2000 {
2001 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
2002 }
2003 }
2004 else
2005 {
2006 /*
2007 * Remove the directory and anything under it, that means files
2008 * and everything. This is in the tradition of the Windows NT
2009 * CMD.EXE "rmdir /s" operation, a tradition which jpsoft's TCC
2010 * strongly warns against (and half-ways questions the sense of).
2011 */
2012 if (pCtx->cVerbose)
2013 RTPrintf(GuestCtrl::tr("Recursively removing directory \"%s\" ...\n"), ValueUnion.psz);
2014 try
2015 {
2016 /** @todo Make flags configurable. */
2017 com::SafeArray<DirectoryRemoveRecFlag_T> aRemRecFlags;
2018 aRemRecFlags.push_back(DirectoryRemoveRecFlag_ContentAndDir);
2019
2020 ComPtr<IProgress> ptrProgress;
2021 CHECK_ERROR(pCtx->pGuestSession, DirectoryRemoveRecursive(Bstr(ValueUnion.psz).raw(),
2022 ComSafeArrayAsInParam(aRemRecFlags),
2023 ptrProgress.asOutParam()));
2024 if (SUCCEEDED(hrc))
2025 {
2026 if (pCtx->cVerbose)
2027 hrc = showProgress(ptrProgress);
2028 else
2029 hrc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
2030 if (SUCCEEDED(hrc))
2031 CHECK_PROGRESS_ERROR(ptrProgress, (GuestCtrl::tr("Directory deletion failed")));
2032 ptrProgress.setNull();
2033 }
2034 }
2035 catch (std::bad_alloc &)
2036 {
2037 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory during recursive rmdir\n"));
2038 }
2039 }
2040
2041 /*
2042 * This command returns immediately on failure since it's destructive in nature.
2043 */
2044 if (FAILED(hrc))
2045 return RTEXITCODE_FAILURE;
2046 break;
2047 }
2048
2049 default:
2050 return errorGetOpt(ch, &ValueUnion);
2051 }
2052 }
2053
2054 if (!cDirRemoved)
2055 return errorSyntax(GuestCtrl::tr("No directory to remove specified!"));
2056 return rcExit;
2057}
2058
2059static DECLCALLBACK(RTEXITCODE) gctlHandleRm(PGCTLCMDCTX pCtx, int argc, char **argv)
2060{
2061 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2062
2063 static const RTGETOPTDEF s_aOptions[] =
2064 {
2065 GCTLCMD_COMMON_OPTION_DEFS()
2066 { "--force", 'f', RTGETOPT_REQ_NOTHING, },
2067 };
2068
2069 int ch;
2070 RTGETOPTUNION ValueUnion;
2071 RTGETOPTSTATE GetState;
2072 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2073
2074 uint32_t cFilesDeleted = 0;
2075 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2076 bool fForce = true;
2077
2078 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2079 {
2080 /* For options that require an argument, ValueUnion has received the value. */
2081 switch (ch)
2082 {
2083 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2084
2085 case VINF_GETOPT_NOT_OPTION:
2086 if (cFilesDeleted == 0)
2087 {
2088 /*
2089 * First non-option - no more options now.
2090 */
2091 rcExit = gctlCtxPostOptionParsingInit(pCtx);
2092 if (rcExit != RTEXITCODE_SUCCESS)
2093 return rcExit;
2094 if (pCtx->cVerbose)
2095 RTPrintf(GuestCtrl::tr("Removing %RU32 file(s)...\n", "", argc - GetState.iNext + 1),
2096 argc - GetState.iNext + 1);
2097 }
2098 if (g_fGuestCtrlCanceled)
2099 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rm was interrupted by Ctrl-C (%u left)\n"),
2100 argc - GetState.iNext + 1);
2101
2102 /*
2103 * Remove the specified file.
2104 *
2105 * On failure we will by default stop, however, the force option will
2106 * by unix traditions force us to ignore errors and continue.
2107 */
2108 cFilesDeleted++;
2109 if (pCtx->cVerbose)
2110 RTPrintf(GuestCtrl::tr("Removing file \"%s\" ...\n", ValueUnion.psz));
2111 try
2112 {
2113 /** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we
2114 * need to do some chmod or whatever to better emulate the --force flag? */
2115 HRESULT hrc;
2116 CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw()));
2117 if (FAILED(hrc) && !fForce)
2118 return RTEXITCODE_FAILURE;
2119 }
2120 catch (std::bad_alloc &)
2121 {
2122 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
2123 }
2124 break;
2125
2126 default:
2127 return errorGetOpt(ch, &ValueUnion);
2128 }
2129 }
2130
2131 if (!cFilesDeleted && !fForce)
2132 return errorSyntax(GuestCtrl::tr("No file to remove specified!"));
2133 return rcExit;
2134}
2135
2136static DECLCALLBACK(RTEXITCODE) gctlHandleMv(PGCTLCMDCTX pCtx, int argc, char **argv)
2137{
2138 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2139
2140 static const RTGETOPTDEF s_aOptions[] =
2141 {
2142 GCTLCMD_COMMON_OPTION_DEFS()
2143/** @todo Missing --force/-f flag. */
2144 };
2145
2146 int ch;
2147 RTGETOPTUNION ValueUnion;
2148 RTGETOPTSTATE GetState;
2149 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2150
2151 int vrc = VINF_SUCCESS;
2152
2153 bool fDryrun = false;
2154 std::vector< Utf8Str > vecSources;
2155 const char *pszDst = NULL;
2156 com::SafeArray<FsObjRenameFlag_T> aRenameFlags;
2157
2158 try
2159 {
2160 /** @todo Make flags configurable. */
2161 aRenameFlags.push_back(FsObjRenameFlag_NoReplace);
2162
2163 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
2164 && RT_SUCCESS(vrc))
2165 {
2166 /* For options that require an argument, ValueUnion has received the value. */
2167 switch (ch)
2168 {
2169 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2170
2171 /** @todo Implement a --dryrun command. */
2172 /** @todo Implement rename flags. */
2173
2174 case VINF_GETOPT_NOT_OPTION:
2175 vecSources.push_back(Utf8Str(ValueUnion.psz));
2176 pszDst = ValueUnion.psz;
2177 break;
2178
2179 default:
2180 return errorGetOpt(ch, &ValueUnion);
2181 }
2182 }
2183 }
2184 catch (std::bad_alloc &)
2185 {
2186 vrc = VERR_NO_MEMORY;
2187 }
2188
2189 if (RT_FAILURE(vrc))
2190 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Failed to initialize, vrc=%Rrc\n"), vrc);
2191
2192 size_t cSources = vecSources.size();
2193 if (!cSources)
2194 return errorSyntax(GuestCtrl::tr("No source(s) to move specified!"));
2195 if (cSources < 2)
2196 return errorSyntax(GuestCtrl::tr("No destination specified!"));
2197
2198 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2199 if (rcExit != RTEXITCODE_SUCCESS)
2200 return rcExit;
2201
2202 /* Delete last element, which now is the destination. */
2203 vecSources.pop_back();
2204 cSources = vecSources.size();
2205
2206 HRESULT hrc = S_OK;
2207
2208 /* Destination must be a directory when specifying multiple sources. */
2209 if (cSources > 1)
2210 {
2211 ComPtr<IGuestFsObjInfo> pFsObjInfo;
2212 hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszDst).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
2213 if (FAILED(hrc))
2214 {
2215 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Destination does not exist\n"));
2216 }
2217 else
2218 {
2219 FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
2220 hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
2221 if (SUCCEEDED(hrc))
2222 {
2223 if (enmObjType != FsObjType_Directory)
2224 return RTMsgErrorExit(RTEXITCODE_FAILURE,
2225 GuestCtrl::tr("Destination must be a directory when specifying multiple sources\n"));
2226 }
2227 else
2228 return RTMsgErrorExit(RTEXITCODE_FAILURE,
2229 GuestCtrl::tr("Unable to determine destination type: %Rhrc\n"),
2230 hrc);
2231 }
2232 }
2233
2234 /*
2235 * Rename (move) the entries.
2236 */
2237 if (pCtx->cVerbose)
2238 RTPrintf(GuestCtrl::tr("Renaming %RU32 %s ...\n"), cSources,
2239 cSources > 1 ? GuestCtrl::tr("sources", "", cSources) : GuestCtrl::tr("source"));
2240
2241 std::vector< Utf8Str >::iterator it = vecSources.begin();
2242 while ( it != vecSources.end()
2243 && !g_fGuestCtrlCanceled)
2244 {
2245 Utf8Str strSrcCur = (*it);
2246
2247 ComPtr<IGuestFsObjInfo> pFsObjInfo;
2248 FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
2249 hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strSrcCur).raw(), FALSE /*followSymlinks*/, pFsObjInfo.asOutParam());
2250 if (SUCCEEDED(hrc))
2251 hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
2252 if (FAILED(hrc))
2253 {
2254 RTPrintf(GuestCtrl::tr("Cannot stat \"%s\": No such file or directory\n"), strSrcCur.c_str());
2255 ++it;
2256 continue; /* Skip. */
2257 }
2258
2259 char *pszDstCur = NULL;
2260
2261 if (cSources > 1)
2262 {
2263 pszDstCur = RTPathJoinA(pszDst, RTPathFilename(strSrcCur.c_str()));
2264 }
2265 else
2266 pszDstCur = RTStrDup(pszDst);
2267
2268 AssertPtrBreakStmt(pszDstCur, VERR_NO_MEMORY);
2269
2270 if (pCtx->cVerbose)
2271 RTPrintf(GuestCtrl::tr("Renaming %s \"%s\" to \"%s\" ...\n"),
2272 enmObjType == FsObjType_Directory ? GuestCtrl::tr("directory", "object") : GuestCtrl::tr("file","object"),
2273 strSrcCur.c_str(), pszDstCur);
2274
2275 if (!fDryrun)
2276 {
2277 CHECK_ERROR(pCtx->pGuestSession, FsObjRename(Bstr(strSrcCur).raw(),
2278 Bstr(pszDstCur).raw(),
2279 ComSafeArrayAsInParam(aRenameFlags)));
2280 /* Keep going with next item in case of errors. */
2281 }
2282
2283 RTStrFree(pszDstCur);
2284
2285 ++it;
2286 }
2287
2288 if ( (it != vecSources.end())
2289 && pCtx->cVerbose)
2290 {
2291 RTPrintf(GuestCtrl::tr("Warning: Not all sources were renamed\n"));
2292 }
2293
2294 return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
2295}
2296
2297static DECLCALLBACK(RTEXITCODE) gctlHandleMkTemp(PGCTLCMDCTX pCtx, int argc, char **argv)
2298{
2299 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2300
2301 static const RTGETOPTDEF s_aOptions[] =
2302 {
2303 GCTLCMD_COMMON_OPTION_DEFS()
2304 { "--mode", 'm', RTGETOPT_REQ_UINT32 },
2305 { "--directory", 'D', RTGETOPT_REQ_NOTHING },
2306 { "--secure", 's', RTGETOPT_REQ_NOTHING },
2307 { "--tmpdir", 't', RTGETOPT_REQ_STRING }
2308 };
2309
2310 int ch;
2311 RTGETOPTUNION ValueUnion;
2312 RTGETOPTSTATE GetState;
2313 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2314
2315 Utf8Str strTemplate;
2316 uint32_t fMode = 0; /* Default mode. */
2317 bool fDirectory = false;
2318 bool fSecure = false;
2319 Utf8Str strTempDir;
2320
2321 DESTDIRMAP mapDirs;
2322
2323 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2324 {
2325 /* For options that require an argument, ValueUnion has received the value. */
2326 switch (ch)
2327 {
2328 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2329
2330 case 'm': /* Mode */
2331 fMode = ValueUnion.u32;
2332 break;
2333
2334 case 'D': /* Create directory */
2335 fDirectory = true;
2336 break;
2337
2338 case 's': /* Secure */
2339 fSecure = true;
2340 break;
2341
2342 case 't': /* Temp directory */
2343 strTempDir = ValueUnion.psz;
2344 break;
2345
2346 case VINF_GETOPT_NOT_OPTION:
2347 if (strTemplate.isEmpty())
2348 strTemplate = ValueUnion.psz;
2349 else
2350 return errorSyntax(GuestCtrl::tr("More than one template specified!\n"));
2351 break;
2352
2353 default:
2354 return errorGetOpt(ch, &ValueUnion);
2355 }
2356 }
2357
2358 if (strTemplate.isEmpty())
2359 return errorSyntax(GuestCtrl::tr("No template specified!"));
2360
2361#ifndef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
2362 if (!fDirectory)
2363 return errorSyntax(GuestCtrl::tr("Creating temporary files is currently not supported!"));
2364#endif
2365
2366 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2367 if (rcExit != RTEXITCODE_SUCCESS)
2368 return rcExit;
2369
2370 /*
2371 * Create the directories.
2372 */
2373 if (pCtx->cVerbose)
2374 {
2375 if (fDirectory && !strTempDir.isEmpty())
2376 RTPrintf(GuestCtrl::tr("Creating temporary directory from template '%s' in directory '%s' ...\n"),
2377 strTemplate.c_str(), strTempDir.c_str());
2378 else if (fDirectory)
2379 RTPrintf(GuestCtrl::tr("Creating temporary directory from template '%s' in default temporary directory ...\n"),
2380 strTemplate.c_str());
2381 else if (!fDirectory && !strTempDir.isEmpty())
2382 RTPrintf(GuestCtrl::tr("Creating temporary file from template '%s' in directory '%s' ...\n"),
2383 strTemplate.c_str(), strTempDir.c_str());
2384 else if (!fDirectory)
2385 RTPrintf(GuestCtrl::tr("Creating temporary file from template '%s' in default temporary directory ...\n"),
2386 strTemplate.c_str());
2387 }
2388
2389 HRESULT hrc = S_OK;
2390 if (fDirectory)
2391 {
2392 Bstr bstrDirectory;
2393 CHECK_ERROR(pCtx->pGuestSession, DirectoryCreateTemp(Bstr(strTemplate).raw(),
2394 fMode, Bstr(strTempDir).raw(),
2395 fSecure,
2396 bstrDirectory.asOutParam()));
2397 if (SUCCEEDED(hrc))
2398 RTPrintf(GuestCtrl::tr("Directory name: %ls\n"), bstrDirectory.raw());
2399 }
2400 else
2401 {
2402 // else - temporary file not yet implemented
2403 /** @todo implement temporary file creation (we fend it off above, no
2404 * worries). */
2405 hrc = E_FAIL;
2406 }
2407
2408 return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
2409}
2410
2411static DECLCALLBACK(RTEXITCODE) gctlHandleFsInfo(PGCTLCMDCTX pCtx, int argc, char **argv)
2412{
2413 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2414
2415 /*
2416 * Parse arguments.
2417 */
2418 enum GCTLCMD_FSINFO_OPT
2419 {
2420 GCTLCMD_FSINFO_OPT_TOTAL = 1000
2421 };
2422
2423 static const RTGETOPTDEF s_aOptions[] =
2424 {
2425 GCTLCMD_COMMON_OPTION_DEFS()
2426 { "--human-readable", 'h', RTGETOPT_REQ_NOTHING },
2427 { "--total", GCTLCMD_FSINFO_OPT_TOTAL, RTGETOPT_REQ_NOTHING }
2428 };
2429
2430 int ch;
2431 RTGETOPTUNION ValueUnion;
2432 RTGETOPTSTATE GetState;
2433 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2434
2435 bool fHumanReadable = false;
2436 bool fShowTotal = false;
2437
2438 while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
2439 && ch != VINF_GETOPT_NOT_OPTION)
2440 {
2441 /* For options that require an argument, ValueUnion has received the value. */
2442 switch (ch)
2443 {
2444 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2445
2446 case 'h':
2447 fHumanReadable = true;
2448 break;
2449
2450 case GCTLCMD_FSINFO_OPT_TOTAL:
2451 fShowTotal = true;
2452 break;
2453
2454 default:
2455 return errorGetOpt(ch, &ValueUnion);
2456 }
2457 }
2458
2459 if (ch != VINF_GETOPT_NOT_OPTION)
2460 return errorSyntax(GuestCtrl::tr("No path specified to query information for!"));
2461
2462 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2463 if (rcExit != RTEXITCODE_SUCCESS)
2464 return rcExit;
2465
2466 /* Stay within 80 characters width by default. */
2467 unsigned const cwFileSys = 10;
2468 /* When displaying human-readable sizes, we need less space for a column. */
2469 unsigned const cwSize = fHumanReadable ? 10 : 14;
2470 unsigned const cwSizeTotal = cwSize;
2471 unsigned const cwSizeUsed = cwSize;
2472 unsigned const cwSizeAvail = cwSize;
2473 unsigned const cwUsePercent = 6;
2474 unsigned const cwPathSpacing = 3; /* Spacing between last value and actual path. */
2475
2476 RTPrintf("%-*s%*s%*s%*s%*s%*s%s\n",
2477 cwFileSys, GuestCtrl::tr("Filesystem"),
2478 cwSizeTotal, GuestCtrl::tr("Total"), cwSizeUsed, GuestCtrl::tr("Used"), cwSizeAvail, GuestCtrl::tr("Avail"),
2479 cwUsePercent, GuestCtrl::tr("Use%"),
2480 cwPathSpacing, "",
2481 GuestCtrl::tr("Path"));
2482
2483 uint64_t cbTotalSize = 0;
2484 uint64_t cbTotalFree = 0;
2485
2486 while (ch == VINF_GETOPT_NOT_OPTION)
2487 {
2488 ComPtr<IGuestFsInfo> pFsInfo;
2489 HRESULT hrc;
2490 CHECK_ERROR(pCtx->pGuestSession, FsQueryInfo(Bstr(ValueUnion.psz).raw(), pFsInfo.asOutParam()));
2491 if (FAILED(hrc))
2492 {
2493 rcExit = RTEXITCODE_FAILURE;
2494 }
2495 else
2496 {
2497 Bstr bstr;
2498 CHECK_ERROR2I(pFsInfo, COMGETTER(Type)(bstr.asOutParam()));
2499 /** @todo Add label and mount point once we return this. */
2500 LONG64 cbTotal, cbFree;
2501 CHECK_ERROR2I(pFsInfo, COMGETTER(TotalSize)(&cbTotal));
2502 CHECK_ERROR2I(pFsInfo, COMGETTER(FreeSize)(&cbFree));
2503 uint8_t const uPercentUsed = (cbTotal - cbFree) * 100 / cbTotal;
2504 if (fHumanReadable)
2505 {
2506 RTPrintf("%-*ls%*Rhcb%*Rhcb%*Rhcb%*RU8%%%*s%s",
2507 cwFileSys, bstr.raw(), /* Filesystem */
2508 cwSizeTotal, cbTotal, /* Total */
2509 cwSizeUsed, cbTotal - cbFree, /* Used */
2510 cwSizeAvail, cbFree, /* Available */
2511 cwUsePercent - 1 /* For percent sign */, uPercentUsed, /* Percent */
2512 cwPathSpacing, "",
2513 ValueUnion.psz); /* Path */
2514 }
2515 else
2516 {
2517 RTPrintf("%-*ls%*RU64%*RU64%*RU64%*RU8%%%*s%s",
2518 cwFileSys, bstr.raw(), /* Filesystem */
2519 cwSizeTotal, cbTotal, /* Total */
2520 cwSizeUsed, cbTotal - cbFree, /* Used */
2521 cwSizeAvail, cbFree, /* Available */
2522 cwUsePercent - 1 /* For percent sign */, uPercentUsed, /* Percent */
2523 cwPathSpacing, "",
2524 ValueUnion.psz); /* Path */
2525 }
2526
2527 if (fShowTotal)
2528 {
2529 cbTotalSize += cbTotal;
2530 cbTotalFree += cbFree;
2531 }
2532 RTPrintf("\n");
2533 }
2534
2535 /* Next path. */
2536 ch = RTGetOpt(&GetState, &ValueUnion);
2537 }
2538
2539 if (fShowTotal)
2540 {
2541 uint8_t const uPercentUsed = (cbTotalSize - cbTotalFree) * 100 / cbTotalSize;
2542
2543 if (fHumanReadable)
2544 {
2545 RTPrintf("%-*s%*Rhcb%*Rhcb%*Rhcb%*RU8%%%*s%s",
2546 cwFileSys, "total",
2547 cwSizeTotal, cbTotalSize, /* Total */
2548 cwSizeUsed, cbTotalSize - cbTotalFree, /* Used */
2549 cwSizeAvail, cbTotalFree, /* Available */
2550 cwUsePercent - 1 /* For percent sign */, uPercentUsed, /* Percent */
2551 cwPathSpacing, "",
2552 "-"); /* Path */
2553 }
2554 else
2555 {
2556 RTPrintf("%-*s%*RU64%*RU64%*RU64%*RU8%%%*s%s",
2557 cwFileSys, "total", /* Filesystem */
2558 cwSizeTotal, cbTotalSize, /* Total */
2559 cwSizeUsed, cbTotalSize - cbTotalFree, /* Used */
2560 cwSizeAvail, cbTotalFree, /* Available */
2561 cwUsePercent - 1 /* For percent sign */, uPercentUsed, /* Percent */
2562 cwPathSpacing, "",
2563 "-"); /* Path */
2564 }
2565 RTPrintf("\n");
2566 }
2567
2568 return rcExit;
2569}
2570
2571static DECLCALLBACK(RTEXITCODE) gctlHandleStat(PGCTLCMDCTX pCtx, int argc, char **argv)
2572{
2573 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2574
2575 static const RTGETOPTDEF s_aOptions[] =
2576 {
2577 GCTLCMD_COMMON_OPTION_DEFS()
2578 { "--dereference", 'L', RTGETOPT_REQ_NOTHING },
2579 { "--file-system", 'f', RTGETOPT_REQ_NOTHING },
2580 { "--format", 'c', RTGETOPT_REQ_STRING },
2581 { "--terse", 't', RTGETOPT_REQ_NOTHING }
2582 };
2583
2584 int ch;
2585 RTGETOPTUNION ValueUnion;
2586 RTGETOPTSTATE GetState;
2587 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2588
2589 while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
2590 && ch != VINF_GETOPT_NOT_OPTION)
2591 {
2592 /* For options that require an argument, ValueUnion has received the value. */
2593 switch (ch)
2594 {
2595 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2596
2597 case 'L': /* Dereference */
2598 case 'f': /* File-system */
2599 case 'c': /* Format */
2600 case 't': /* Terse */
2601 return errorSyntax(GuestCtrl::tr("Command \"%s\" not implemented yet!"), ValueUnion.psz);
2602
2603 default:
2604 return errorGetOpt(ch, &ValueUnion);
2605 }
2606 }
2607
2608 if (ch != VINF_GETOPT_NOT_OPTION)
2609 return errorSyntax(GuestCtrl::tr("Nothing to stat!"));
2610
2611 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2612 if (rcExit != RTEXITCODE_SUCCESS)
2613 return rcExit;
2614
2615
2616 /*
2617 * Do the file stat'ing.
2618 */
2619 while (ch == VINF_GETOPT_NOT_OPTION)
2620 {
2621 if (pCtx->cVerbose)
2622 RTPrintf(GuestCtrl::tr("Checking for element \"%s\" ...\n"), ValueUnion.psz);
2623
2624 ComPtr<IGuestFsObjInfo> pFsObjInfo;
2625 HRESULT hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(ValueUnion.psz).raw(), FALSE /*followSymlinks*/,
2626 pFsObjInfo.asOutParam());
2627 if (FAILED(hrc))
2628 {
2629 /** @todo r=bird: There might be other reasons why we end up here than
2630 * non-existing "element" (object or file, please, nobody calls it elements). */
2631 if (pCtx->cVerbose)
2632 RTPrintf(GuestCtrl::tr("Failed to stat '%s': No such file\n"), ValueUnion.psz);
2633 rcExit = RTEXITCODE_FAILURE;
2634 }
2635 else
2636 {
2637 RTPrintf(GuestCtrl::tr(" File: '%s'\n"), ValueUnion.psz); /** @todo escape this name. */
2638
2639 FsObjType_T enmType = FsObjType_Unknown;
2640 CHECK_ERROR2I(pFsObjInfo, COMGETTER(Type)(&enmType));
2641 LONG64 cbObject = 0;
2642 CHECK_ERROR2I(pFsObjInfo, COMGETTER(ObjectSize)(&cbObject));
2643 LONG64 cbAllocated = 0;
2644 CHECK_ERROR2I(pFsObjInfo, COMGETTER(AllocatedSize)(&cbAllocated));
2645 LONG uid = 0;
2646 CHECK_ERROR2I(pFsObjInfo, COMGETTER(UID)(&uid));
2647 LONG gid = 0;
2648 CHECK_ERROR2I(pFsObjInfo, COMGETTER(GID)(&gid));
2649 Bstr bstrUsername;
2650 CHECK_ERROR2I(pFsObjInfo, COMGETTER(UserName)(bstrUsername.asOutParam()));
2651 Bstr bstrGroupName;
2652 CHECK_ERROR2I(pFsObjInfo, COMGETTER(GroupName)(bstrGroupName.asOutParam()));
2653 Bstr bstrAttribs;
2654 CHECK_ERROR2I(pFsObjInfo, COMGETTER(FileAttributes)(bstrAttribs.asOutParam()));
2655 LONG64 idNode = 0;
2656 CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeId)(&idNode));
2657 ULONG uDevNode = 0;
2658 CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeIdDevice)(&uDevNode));
2659 ULONG uDeviceNo = 0;
2660 CHECK_ERROR2I(pFsObjInfo, COMGETTER(DeviceNumber)(&uDeviceNo));
2661 ULONG cHardLinks = 1;
2662 CHECK_ERROR2I(pFsObjInfo, COMGETTER(HardLinks)(&cHardLinks));
2663 LONG64 nsBirthTime = 0;
2664 CHECK_ERROR2I(pFsObjInfo, COMGETTER(BirthTime)(&nsBirthTime));
2665 LONG64 nsChangeTime = 0;
2666 CHECK_ERROR2I(pFsObjInfo, COMGETTER(ChangeTime)(&nsChangeTime));
2667 LONG64 nsModificationTime = 0;
2668 CHECK_ERROR2I(pFsObjInfo, COMGETTER(ModificationTime)(&nsModificationTime));
2669 LONG64 nsAccessTime = 0;
2670 CHECK_ERROR2I(pFsObjInfo, COMGETTER(AccessTime)(&nsAccessTime));
2671
2672 RTPrintf(GuestCtrl::tr(" Size: %-17RU64 Alloc: %-19RU64 Type: %s\n"),
2673 cbObject, cbAllocated, gctlFsObjTypeToName(enmType));
2674 RTPrintf(GuestCtrl::tr("Device: %#-17RX32 INode: %-18RU64 Links: %u\n"), uDevNode, idNode, cHardLinks);
2675
2676 Utf8Str strAttrib(bstrAttribs);
2677 char *pszMode = strAttrib.mutableRaw();
2678 char *pszAttribs = strchr(pszMode, ' ');
2679 if (pszAttribs)
2680 do *pszAttribs++ = '\0';
2681 while (*pszAttribs == ' ');
2682 else
2683 pszAttribs = strchr(pszMode, '\0');
2684 if (uDeviceNo != 0)
2685 RTPrintf(GuestCtrl::tr(" Mode: %-16s Attrib: %-17s Dev ID: %#RX32\n"), pszMode, pszAttribs, uDeviceNo);
2686 else
2687 RTPrintf(GuestCtrl::tr(" Mode: %-16s Attrib: %s\n"), pszMode, pszAttribs);
2688
2689 RTPrintf(GuestCtrl::tr(" Owner: %4d/%-12ls Group: %4d/%ls\n"), uid, bstrUsername.raw(), gid, bstrGroupName.raw());
2690
2691 RTTIMESPEC TimeSpec;
2692 char szTmp[RTTIME_STR_LEN];
2693 RTPrintf(GuestCtrl::tr(" Birth: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsBirthTime),
2694 szTmp, sizeof(szTmp)));
2695 RTPrintf(GuestCtrl::tr("Change: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsChangeTime),
2696 szTmp, sizeof(szTmp)));
2697 RTPrintf(GuestCtrl::tr("Modify: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsModificationTime),
2698 szTmp, sizeof(szTmp)));
2699 RTPrintf(GuestCtrl::tr("Access: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsAccessTime),
2700 szTmp, sizeof(szTmp)));
2701
2702 /* Skiping: Generation ID - only the ISO9660 VFS sets this. FreeBSD user flags. */
2703 }
2704
2705 /* Next file. */
2706 ch = RTGetOpt(&GetState, &ValueUnion);
2707 }
2708
2709 return rcExit;
2710}
2711
2712/**
2713 * Waits for a Guest Additions run level being reached.
2714 *
2715 * @returns VBox status code.
2716 * Returns VERR_CANCELLED if waiting for cancelled due to signal handling, e.g. when CTRL+C or some sort was pressed.
2717 * @param pCtx The guest control command context.
2718 * @param enmRunLevel Run level to wait for.
2719 * @param cMsTimeout Timeout (in ms) for waiting.
2720 */
2721static int gctlWaitForRunLevel(PGCTLCMDCTX pCtx, AdditionsRunLevelType_T enmRunLevel, RTMSINTERVAL cMsTimeout)
2722{
2723 int vrc = VINF_SUCCESS; /* Shut up MSVC. */
2724
2725 try
2726 {
2727 HRESULT hrc = S_OK;
2728 /** Whether we need to actually wait for the run level or if we already reached it. */
2729 bool fWait = false;
2730
2731 /* Install an event handler first to catch any runlevel changes. */
2732 ComObjPtr<GuestAdditionsRunlevelListenerImpl> pGuestListener;
2733 do
2734 {
2735 /* Listener creation. */
2736 pGuestListener.createObject();
2737 pGuestListener->init(new GuestAdditionsRunlevelListener(enmRunLevel));
2738
2739 /* Register for IGuest events. */
2740 ComPtr<IEventSource> es;
2741 CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
2742 com::SafeArray<VBoxEventType_T> eventTypes;
2743 eventTypes.push_back(VBoxEventType_OnGuestAdditionsStatusChanged);
2744 CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
2745 true /* Active listener */));
2746
2747 AdditionsRunLevelType_T enmRunLevelCur = AdditionsRunLevelType_None;
2748 CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(AdditionsRunLevel)(&enmRunLevelCur));
2749 fWait = enmRunLevelCur != enmRunLevel;
2750
2751 if (pCtx->cVerbose)
2752 RTPrintf(GuestCtrl::tr("Current run level is %RU32\n"), enmRunLevelCur);
2753
2754 } while (0);
2755
2756 if (fWait)
2757 {
2758 if (pCtx->cVerbose)
2759 RTPrintf(GuestCtrl::tr("Waiting for run level %RU32 ...\n"), enmRunLevel);
2760
2761 RTMSINTERVAL tsStart = RTTimeMilliTS();
2762 while (RTTimeMilliTS() - tsStart < cMsTimeout)
2763 {
2764 /* Wait for the global signal semaphore getting signalled. */
2765 vrc = RTSemEventWait(g_SemEventGuestCtrlCanceled, 100 /* ms */);
2766 if (RT_FAILURE(vrc))
2767 {
2768 if (vrc == VERR_TIMEOUT)
2769 continue;
2770 else
2771 {
2772 RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
2773 break;
2774 }
2775 }
2776 else if (pCtx->cVerbose)
2777 {
2778 RTPrintf(GuestCtrl::tr("Run level %RU32 reached\n"), enmRunLevel);
2779 break;
2780 }
2781
2782 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
2783 }
2784
2785 if ( vrc == VERR_TIMEOUT
2786 && pCtx->cVerbose)
2787 RTPrintf(GuestCtrl::tr("Run level %RU32 not reached within time\n"), enmRunLevel);
2788 }
2789
2790 if (!pGuestListener.isNull())
2791 {
2792 /* Guest callback unregistration. */
2793 ComPtr<IEventSource> pES;
2794 CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
2795 if (!pES.isNull())
2796 CHECK_ERROR(pES, UnregisterListener(pGuestListener));
2797 pGuestListener.setNull();
2798 }
2799
2800 if (g_fGuestCtrlCanceled)
2801 vrc = VERR_CANCELLED;
2802 }
2803 catch (std::bad_alloc &)
2804 {
2805 vrc = VERR_NO_MEMORY;
2806 }
2807
2808 return vrc;
2809}
2810
2811static DECLCALLBACK(RTEXITCODE) gctlHandleUpdateAdditions(PGCTLCMDCTX pCtx, int argc, char **argv)
2812{
2813 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2814
2815 /** Timeout to wait for the whole updating procedure to complete. */
2816 uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
2817 /** Source path to .ISO Guest Additions file to use. */
2818 Utf8Str strSource;
2819 com::SafeArray<IN_BSTR> aArgs;
2820 /** Whether to reboot the guest automatically when the update process has finished successfully. */
2821 bool fRebootOnFinish = false;
2822 /** Whether to only wait for getting the update process started instead of waiting until it finishes. */
2823 bool fWaitStartOnly = false;
2824 /** Whether to wait for the VM being ready to start the update. Needs Guest Additions facility reporting. */
2825 bool fWaitReady = false;
2826 /** Whether to verify if the Guest Additions were successfully updated on the guest. */
2827 bool fVerify = false;
2828
2829 /*
2830 * Parse arguments.
2831 */
2832 enum KGSTCTRLUPDATEADDITIONSOPT
2833 {
2834 KGSTCTRLUPDATEADDITIONSOPT_REBOOT = 1000,
2835 KGSTCTRLUPDATEADDITIONSOPT_SOURCE,
2836 KGSTCTRLUPDATEADDITIONSOPT_TIMEOUT,
2837 KGSTCTRLUPDATEADDITIONSOPT_VERIFY,
2838 KGSTCTRLUPDATEADDITIONSOPT_WAITREADY,
2839 KGSTCTRLUPDATEADDITIONSOPT_WAITSTART
2840 };
2841
2842 static const RTGETOPTDEF s_aOptions[] =
2843 {
2844 GCTLCMD_COMMON_OPTION_DEFS()
2845 { "--reboot", KGSTCTRLUPDATEADDITIONSOPT_REBOOT, RTGETOPT_REQ_NOTHING },
2846 { "--source", KGSTCTRLUPDATEADDITIONSOPT_SOURCE, RTGETOPT_REQ_STRING },
2847 { "--timeout", KGSTCTRLUPDATEADDITIONSOPT_TIMEOUT, RTGETOPT_REQ_UINT32 },
2848 { "--verify", KGSTCTRLUPDATEADDITIONSOPT_VERIFY, RTGETOPT_REQ_NOTHING },
2849 { "--wait-ready", KGSTCTRLUPDATEADDITIONSOPT_WAITREADY, RTGETOPT_REQ_NOTHING },
2850 { "--wait-start", KGSTCTRLUPDATEADDITIONSOPT_WAITSTART, RTGETOPT_REQ_NOTHING }
2851 };
2852
2853 int ch;
2854 RTGETOPTUNION ValueUnion;
2855 RTGETOPTSTATE GetState;
2856 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2857
2858 int vrc = VINF_SUCCESS;
2859 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
2860 && RT_SUCCESS(vrc))
2861 {
2862 switch (ch)
2863 {
2864 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2865
2866 case KGSTCTRLUPDATEADDITIONSOPT_REBOOT:
2867 fRebootOnFinish = true;
2868 break;
2869
2870 case KGSTCTRLUPDATEADDITIONSOPT_SOURCE:
2871 vrc = RTPathAbsCxx(strSource, ValueUnion.psz);
2872 if (RT_FAILURE(vrc))
2873 return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbsCxx failed on '%s': %Rrc"), ValueUnion.psz, vrc);
2874 break;
2875
2876 case KGSTCTRLUPDATEADDITIONSOPT_WAITSTART:
2877 fWaitStartOnly = true;
2878 break;
2879
2880 case KGSTCTRLUPDATEADDITIONSOPT_WAITREADY:
2881 fWaitReady = true;
2882 break;
2883
2884 case KGSTCTRLUPDATEADDITIONSOPT_VERIFY:
2885 fVerify = true;
2886 fRebootOnFinish = true; /* Verification needs a mandatory reboot after successful update. */
2887 break;
2888
2889 case VINF_GETOPT_NOT_OPTION:
2890 if (aArgs.size() == 0 && strSource.isEmpty())
2891 strSource = ValueUnion.psz;
2892 else
2893 aArgs.push_back(Bstr(ValueUnion.psz).raw());
2894 break;
2895
2896 default:
2897 return errorGetOpt(ch, &ValueUnion);
2898 }
2899 }
2900
2901 if (pCtx->cVerbose)
2902 RTPrintf(GuestCtrl::tr("Updating Guest Additions ...\n"));
2903
2904 HRESULT hrc = S_OK;
2905 while (strSource.isEmpty())
2906 {
2907 ComPtr<ISystemProperties> pProperties;
2908 CHECK_ERROR_BREAK(pCtx->pArg->virtualBox, COMGETTER(SystemProperties)(pProperties.asOutParam()));
2909 Bstr strISO;
2910 CHECK_ERROR_BREAK(pProperties, COMGETTER(DefaultAdditionsISO)(strISO.asOutParam()));
2911 strSource = strISO;
2912 break;
2913 }
2914
2915 /* Determine source if not set yet. */
2916 if (strSource.isEmpty())
2917 {
2918 RTMsgError(GuestCtrl::tr("No Guest Additions source found or specified, aborting\n"));
2919 vrc = VERR_FILE_NOT_FOUND;
2920 }
2921 else if (!RTFileExists(strSource.c_str()))
2922 {
2923 RTMsgError(GuestCtrl::tr("Source \"%s\" does not exist!\n"), strSource.c_str());
2924 vrc = VERR_FILE_NOT_FOUND;
2925 }
2926
2927
2928
2929#if 0
2930 ComPtr<IGuest> guest;
2931 HRESULT hrc = pConsole->COMGETTER(Guest)(guest.asOutParam());
2932 if (SUCCEEDED(hrc) && !guest.isNull())
2933 {
2934 SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", GuestCtrl::tr("OS type:"));
2935
2936 AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
2937 hrc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
2938 if (SUCCEEDED(hrc))
2939 SHOW_ULONG_VALUE("GuestAdditionsRunLevel", GuestCtrl::tr("Additions run level:"), (ULONG)guestRunLevel, "");
2940
2941 Bstr guestString;
2942 hrc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
2943 if ( SUCCEEDED(hrc)
2944 && !guestString.isEmpty())
2945 {
2946 ULONG uRevision;
2947 hrc = guest->COMGETTER(AdditionsRevision)(&uRevision);
2948 if (FAILED(hrc))
2949 uRevision = 0;
2950 RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
2951 SHOW_UTF8_STRING("GuestAdditionsVersion", GuestCtrl::tr("Additions version:"), szValue);
2952 }
2953 }
2954#endif
2955
2956 if (RT_SUCCESS(vrc))
2957 {
2958 if (pCtx->cVerbose)
2959 RTPrintf(GuestCtrl::tr("Using source: %s\n"), strSource.c_str());
2960
2961 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2962 if (rcExit != RTEXITCODE_SUCCESS)
2963 return rcExit;
2964
2965 if (fWaitReady)
2966 {
2967 if (pCtx->cVerbose)
2968 RTPrintf(GuestCtrl::tr("Waiting for current Guest Additions inside VM getting ready for updating ...\n"));
2969
2970 const uint64_t uTsStart = RTTimeMilliTS();
2971 vrc = gctlWaitForRunLevel(pCtx, AdditionsRunLevelType_Userland, cMsTimeout);
2972 if (RT_SUCCESS(vrc))
2973 cMsTimeout = cMsTimeout != RT_INDEFINITE_WAIT ? cMsTimeout - (RTTimeMilliTS() - uTsStart) : cMsTimeout;
2974 }
2975
2976 if (RT_SUCCESS(vrc))
2977 {
2978 /* Get current Guest Additions version / revision. */
2979 Bstr strGstVerCur;
2980 ULONG uGstRevCur = 0;
2981 hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerCur.asOutParam());
2982 if ( SUCCEEDED(hrc)
2983 && !strGstVerCur.isEmpty())
2984 {
2985 hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevCur);
2986 if (SUCCEEDED(hrc))
2987 {
2988 if (pCtx->cVerbose)
2989 RTPrintf(GuestCtrl::tr("Guest Additions %lsr%RU64 currently installed, waiting for Guest Additions installer to start ...\n"),
2990 strGstVerCur.raw(), uGstRevCur);
2991 }
2992 }
2993
2994 com::SafeArray<AdditionsUpdateFlag_T> aUpdateFlags;
2995 if (fWaitStartOnly)
2996 aUpdateFlags.push_back(AdditionsUpdateFlag_WaitForUpdateStartOnly);
2997
2998 ComPtr<IProgress> pProgress;
2999 CHECK_ERROR(pCtx->pGuest, UpdateGuestAdditions(Bstr(strSource).raw(),
3000 ComSafeArrayAsInParam(aArgs),
3001 ComSafeArrayAsInParam(aUpdateFlags),
3002 pProgress.asOutParam()));
3003 if (FAILED(hrc))
3004 vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3005 else
3006 {
3007 if (pCtx->cVerbose)
3008 hrc = showProgress(pProgress);
3009 else
3010 hrc = pProgress->WaitForCompletion((int32_t)cMsTimeout);
3011
3012 if (SUCCEEDED(hrc))
3013 CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("Guest Additions update failed")));
3014 vrc = gctlPrintProgressError(pProgress);
3015 if (RT_SUCCESS(vrc))
3016 {
3017 if (pCtx->cVerbose)
3018 RTPrintf(GuestCtrl::tr("Guest Additions update successful.\n"));
3019
3020 if (fRebootOnFinish)
3021 {
3022 if (pCtx->cVerbose)
3023 RTPrintf(GuestCtrl::tr("Rebooting guest ...\n"));
3024 com::SafeArray<GuestShutdownFlag_T> aShutdownFlags;
3025 aShutdownFlags.push_back(GuestShutdownFlag_Reboot);
3026 CHECK_ERROR(pCtx->pGuest, Shutdown(ComSafeArrayAsInParam(aShutdownFlags)));
3027 if (FAILED(hrc))
3028 {
3029 if (hrc == VBOX_E_NOT_SUPPORTED)
3030 {
3031 RTPrintf(GuestCtrl::tr("Current installed Guest Additions don't support automatic rebooting. "
3032 "Please reboot manually.\n"));
3033 vrc = VERR_NOT_SUPPORTED;
3034 }
3035 else
3036 vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3037 }
3038 else
3039 {
3040 if (fWaitReady)
3041 {
3042 if (pCtx->cVerbose)
3043 RTPrintf(GuestCtrl::tr("Waiting for new Guest Additions inside VM getting ready ...\n"));
3044
3045 vrc = gctlWaitForRunLevel(pCtx, AdditionsRunLevelType_Userland, cMsTimeout);
3046 if (RT_SUCCESS(vrc))
3047 {
3048 if (fVerify)
3049 {
3050 if (pCtx->cVerbose)
3051 RTPrintf(GuestCtrl::tr("Verifying Guest Additions update ...\n"));
3052
3053 /* Get new Guest Additions version / revision. */
3054 Bstr strGstVerNew;
3055 ULONG uGstRevNew = 0;
3056 hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerNew.asOutParam());
3057 if ( SUCCEEDED(hrc)
3058 && !strGstVerNew.isEmpty())
3059 {
3060 hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevNew);
3061 if (FAILED(hrc))
3062 uGstRevNew = 0;
3063 }
3064
3065 /** @todo Do more verification here. */
3066 vrc = uGstRevNew > uGstRevCur ? VINF_SUCCESS : VERR_NO_CHANGE;
3067
3068 if (pCtx->cVerbose)
3069 {
3070 RTPrintf(GuestCtrl::tr("Old Guest Additions: %ls%RU64\n"), strGstVerCur.raw(),
3071 uGstRevCur);
3072 RTPrintf(GuestCtrl::tr("New Guest Additions: %ls%RU64\n"), strGstVerNew.raw(),
3073 uGstRevNew);
3074
3075 if (RT_FAILURE(vrc))
3076 {
3077 RTPrintf(GuestCtrl::tr("\nError updating Guest Additions, please check guest installer log\n"));
3078 }
3079 else
3080 {
3081 if (uGstRevNew < uGstRevCur)
3082 RTPrintf(GuestCtrl::tr("\nWARNING: Guest Additions were downgraded\n"));
3083 }
3084 }
3085 }
3086 }
3087 }
3088 else if (pCtx->cVerbose)
3089 RTPrintf(GuestCtrl::tr("The guest needs to be restarted in order to make use of the updated Guest Additions.\n"));
3090 }
3091 }
3092 }
3093 }
3094 }
3095 }
3096
3097 return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3098}
3099
3100/**
3101 * Returns a Guest Additions run level from a string.
3102 *
3103 * @returns Run level if found, or AdditionsRunLevelType_None if not found / invalid.
3104 * @param pcszStr String to return run level for.
3105 */
3106static AdditionsRunLevelType_T gctlGetRunLevelFromStr(const char *pcszStr)
3107{
3108 AssertPtrReturn(pcszStr, AdditionsRunLevelType_None);
3109
3110 if (RTStrICmp(pcszStr, "system") == 0) return AdditionsRunLevelType_System;
3111 else if (RTStrICmp(pcszStr, "userland") == 0) return AdditionsRunLevelType_Userland;
3112 else if (RTStrICmp(pcszStr, "desktop") == 0) return AdditionsRunLevelType_Desktop;
3113
3114 return AdditionsRunLevelType_None;
3115}
3116
3117static DECLCALLBACK(RTEXITCODE) gctlHandleWaitRunLevel(PGCTLCMDCTX pCtx, int argc, char **argv)
3118{
3119 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3120
3121 /** Timeout to wait for run level being reached.
3122 * By default we wait until it's reached. */
3123 uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
3124
3125 /*
3126 * Parse arguments.
3127 */
3128 enum KGSTCTRLWAITRUNLEVELOPT
3129 {
3130 KGSTCTRLWAITRUNLEVELOPT_TIMEOUT = 1000
3131 };
3132
3133 static const RTGETOPTDEF s_aOptions[] =
3134 {
3135 GCTLCMD_COMMON_OPTION_DEFS()
3136 { "--timeout", KGSTCTRLWAITRUNLEVELOPT_TIMEOUT, RTGETOPT_REQ_UINT32 }
3137 };
3138
3139 int ch;
3140 RTGETOPTUNION ValueUnion;
3141 RTGETOPTSTATE GetState;
3142 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3143
3144 AdditionsRunLevelType_T enmRunLevel = AdditionsRunLevelType_None;
3145
3146 int vrc = VINF_SUCCESS;
3147 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3148 && RT_SUCCESS(vrc))
3149 {
3150 switch (ch)
3151 {
3152 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3153
3154 case KGSTCTRLWAITRUNLEVELOPT_TIMEOUT:
3155 cMsTimeout = ValueUnion.u32;
3156 break;
3157
3158 case VINF_GETOPT_NOT_OPTION:
3159 {
3160 enmRunLevel = gctlGetRunLevelFromStr(ValueUnion.psz);
3161 if (enmRunLevel == AdditionsRunLevelType_None)
3162 return errorSyntax(GuestCtrl::tr("Invalid run level specified. Valid values are: system, userland, desktop"));
3163 break;
3164 }
3165
3166 default:
3167 return errorGetOpt(ch, &ValueUnion);
3168 }
3169 }
3170
3171 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3172 if (rcExit != RTEXITCODE_SUCCESS)
3173 return rcExit;
3174
3175 if (enmRunLevel == AdditionsRunLevelType_None)
3176 return errorSyntax(GuestCtrl::tr("Missing run level to wait for"));
3177
3178 vrc = gctlWaitForRunLevel(pCtx, enmRunLevel, cMsTimeout);
3179
3180 return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3181}
3182
3183static DECLCALLBACK(RTEXITCODE) gctlHandleList(PGCTLCMDCTX pCtx, int argc, char **argv)
3184{
3185 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3186
3187 static const RTGETOPTDEF s_aOptions[] =
3188 {
3189 GCTLCMD_COMMON_OPTION_DEFS()
3190 };
3191
3192 int ch;
3193 RTGETOPTUNION ValueUnion;
3194 RTGETOPTSTATE GetState;
3195 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3196
3197 bool fSeenListArg = false;
3198 bool fListAll = false;
3199 bool fListSessions = false;
3200 bool fListProcesses = false;
3201 bool fListFiles = false;
3202
3203 int vrc = VINF_SUCCESS;
3204 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3205 && RT_SUCCESS(vrc))
3206 {
3207 switch (ch)
3208 {
3209 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3210
3211 case VINF_GETOPT_NOT_OPTION:
3212 if ( !RTStrICmp(ValueUnion.psz, "sessions")
3213 || !RTStrICmp(ValueUnion.psz, "sess"))
3214 fListSessions = true;
3215 else if ( !RTStrICmp(ValueUnion.psz, "processes")
3216 || !RTStrICmp(ValueUnion.psz, "procs"))
3217 fListSessions = fListProcesses = true; /* Showing processes implies showing sessions. */
3218 else if (!RTStrICmp(ValueUnion.psz, "files"))
3219 fListSessions = fListFiles = true; /* Showing files implies showing sessions. */
3220 else if (!RTStrICmp(ValueUnion.psz, "all"))
3221 fListAll = true;
3222 else
3223 return errorSyntax(GuestCtrl::tr("Unknown list: '%s'"), ValueUnion.psz);
3224 fSeenListArg = true;
3225 break;
3226
3227 default:
3228 return errorGetOpt(ch, &ValueUnion);
3229 }
3230 }
3231
3232 if (!fSeenListArg)
3233 return errorSyntax(GuestCtrl::tr("Missing list name"));
3234 Assert(fListAll || fListSessions);
3235
3236 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3237 if (rcExit != RTEXITCODE_SUCCESS)
3238 return rcExit;
3239
3240
3241 /** @todo Do we need a machine-readable output here as well? */
3242
3243 HRESULT hrc;
3244 size_t cTotalProcs = 0;
3245 size_t cTotalFiles = 0;
3246
3247 SafeIfaceArray <IGuestSession> collSessions;
3248 CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3249 if (SUCCEEDED(hrc))
3250 {
3251 size_t const cSessions = collSessions.size();
3252 if (cSessions)
3253 {
3254 RTPrintf(GuestCtrl::tr("Active guest sessions:\n"));
3255
3256 /** @todo Make this output a bit prettier. No time now. */
3257
3258 for (size_t i = 0; i < cSessions; i++)
3259 {
3260 ComPtr<IGuestSession> pCurSession = collSessions[i];
3261 if (!pCurSession.isNull())
3262 {
3263 do
3264 {
3265 ULONG uID;
3266 CHECK_ERROR_BREAK(pCurSession, COMGETTER(Id)(&uID));
3267 Bstr strName;
3268 CHECK_ERROR_BREAK(pCurSession, COMGETTER(Name)(strName.asOutParam()));
3269 Bstr strUser;
3270 CHECK_ERROR_BREAK(pCurSession, COMGETTER(User)(strUser.asOutParam()));
3271 GuestSessionStatus_T sessionStatus;
3272 CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus));
3273 RTPrintf(GuestCtrl::tr("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls"),
3274 i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw());
3275 } while (0);
3276
3277 if ( fListAll
3278 || fListProcesses)
3279 {
3280 SafeIfaceArray <IGuestProcess> collProcesses;
3281 CHECK_ERROR_BREAK(pCurSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcesses)));
3282 for (size_t a = 0; a < collProcesses.size(); a++)
3283 {
3284 ComPtr<IGuestProcess> pCurProcess = collProcesses[a];
3285 if (!pCurProcess.isNull())
3286 {
3287 do
3288 {
3289 ULONG uPID;
3290 CHECK_ERROR_BREAK(pCurProcess, COMGETTER(PID)(&uPID));
3291 Bstr strExecPath;
3292 CHECK_ERROR_BREAK(pCurProcess, COMGETTER(ExecutablePath)(strExecPath.asOutParam()));
3293 ProcessStatus_T procStatus;
3294 CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus));
3295
3296 RTPrintf(GuestCtrl::tr("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls"),
3297 a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw());
3298 } while (0);
3299 }
3300 }
3301
3302 cTotalProcs += collProcesses.size();
3303 }
3304
3305 if ( fListAll
3306 || fListFiles)
3307 {
3308 SafeIfaceArray <IGuestFile> collFiles;
3309 CHECK_ERROR_BREAK(pCurSession, COMGETTER(Files)(ComSafeArrayAsOutParam(collFiles)));
3310 for (size_t a = 0; a < collFiles.size(); a++)
3311 {
3312 ComPtr<IGuestFile> pCurFile = collFiles[a];
3313 if (!pCurFile.isNull())
3314 {
3315 do
3316 {
3317 ULONG idFile;
3318 CHECK_ERROR_BREAK(pCurFile, COMGETTER(Id)(&idFile));
3319 Bstr strName;
3320 CHECK_ERROR_BREAK(pCurFile, COMGETTER(Filename)(strName.asOutParam()));
3321 FileStatus_T fileStatus;
3322 CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus));
3323
3324 RTPrintf(GuestCtrl::tr("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls"),
3325 a, idFile, gctlFileStatusToText(fileStatus), strName.raw());
3326 } while (0);
3327 }
3328 }
3329
3330 cTotalFiles += collFiles.size();
3331 }
3332 }
3333 }
3334
3335 RTPrintf(GuestCtrl::tr("\n\nTotal guest sessions: %zu\n"), collSessions.size());
3336 if (fListAll || fListProcesses)
3337 RTPrintf(GuestCtrl::tr("Total guest processes: %zu\n"), cTotalProcs);
3338 if (fListAll || fListFiles)
3339 RTPrintf(GuestCtrl::tr("Total guest files: %zu\n"), cTotalFiles);
3340 }
3341 else
3342 RTPrintf(GuestCtrl::tr("No active guest sessions found\n"));
3343 }
3344
3345 if (FAILED(hrc)) /** @todo yeah, right... Only the last error? */
3346 rcExit = RTEXITCODE_FAILURE;
3347
3348 return rcExit;
3349}
3350
3351static DECLCALLBACK(RTEXITCODE) gctlHandleCloseProcess(PGCTLCMDCTX pCtx, int argc, char **argv)
3352{
3353 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3354
3355 static const RTGETOPTDEF s_aOptions[] =
3356 {
3357 GCTLCMD_COMMON_OPTION_DEFS()
3358 { "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3359 { "--session-name", 'n', RTGETOPT_REQ_STRING }
3360 };
3361
3362 int ch;
3363 RTGETOPTUNION ValueUnion;
3364 RTGETOPTSTATE GetState;
3365 int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3366 AssertRCReturn(vrc, RTEXITCODE_FAILURE);
3367
3368 std::vector < uint32_t > vecPID;
3369 ULONG idSession = UINT32_MAX;
3370 Utf8Str strSessionName;
3371
3372 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3373 {
3374 /* For options that require an argument, ValueUnion has received the value. */
3375 switch (ch)
3376 {
3377 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3378
3379 case 'n': /* Session name (or pattern) */
3380 strSessionName = ValueUnion.psz;
3381 break;
3382
3383 case 'i': /* Session ID */
3384 idSession = ValueUnion.u32;
3385 break;
3386
3387 case VINF_GETOPT_NOT_OPTION:
3388 {
3389 /* Treat every else specified as a PID to kill. */
3390 uint32_t uPid;
3391 vrc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
3392 if ( RT_SUCCESS(vrc)
3393 && vrc != VWRN_TRAILING_CHARS
3394 && vrc != VWRN_NUMBER_TOO_BIG
3395 && vrc != VWRN_NEGATIVE_UNSIGNED)
3396 {
3397 if (uPid != 0)
3398 {
3399 try
3400 {
3401 vecPID.push_back(uPid);
3402 }
3403 catch (std::bad_alloc &)
3404 {
3405 return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory"));
3406 }
3407 }
3408 else
3409 return errorSyntax(GuestCtrl::tr("Invalid PID value: 0"));
3410 }
3411 else
3412 return errorSyntax(GuestCtrl::tr("Error parsing PID value: %Rrc"), vrc);
3413 break;
3414 }
3415
3416 default:
3417 return errorGetOpt(ch, &ValueUnion);
3418 }
3419 }
3420
3421 if (vecPID.empty())
3422 return errorSyntax(GuestCtrl::tr("At least one PID must be specified to kill!"));
3423
3424 if ( strSessionName.isEmpty()
3425 && idSession == UINT32_MAX)
3426 return errorSyntax(GuestCtrl::tr("No session ID specified!"));
3427
3428 if ( strSessionName.isNotEmpty()
3429 && idSession != UINT32_MAX)
3430 return errorSyntax(GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
3431
3432 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3433 if (rcExit != RTEXITCODE_SUCCESS)
3434 return rcExit;
3435
3436 HRESULT hrc = S_OK;
3437
3438 ComPtr<IGuestSession> pSession;
3439 ComPtr<IGuestProcess> pProcess;
3440 do
3441 {
3442 uint32_t uProcsTerminated = 0;
3443
3444 SafeIfaceArray <IGuestSession> collSessions;
3445 CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3446 size_t cSessions = collSessions.size();
3447
3448 uint32_t cSessionsHandled = 0;
3449 for (size_t i = 0; i < cSessions; i++)
3450 {
3451 pSession = collSessions[i];
3452 Assert(!pSession.isNull());
3453
3454 ULONG uID; /* Session ID */
3455 CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3456 Bstr strName;
3457 CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3458 Utf8Str strNameUtf8(strName); /* Session name */
3459
3460 bool fSessionFound;
3461 if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3462 fSessionFound = uID == idSession;
3463 else /* ... or by naming pattern. */
3464 fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str());
3465 if (fSessionFound)
3466 {
3467 AssertStmt(!pSession.isNull(), break);
3468 cSessionsHandled++;
3469
3470 SafeIfaceArray <IGuestProcess> collProcs;
3471 CHECK_ERROR_BREAK(pSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcs)));
3472
3473 size_t cProcs = collProcs.size();
3474 for (size_t p = 0; p < cProcs; p++)
3475 {
3476 pProcess = collProcs[p];
3477 Assert(!pProcess.isNull());
3478
3479 ULONG uPID; /* Process ID */
3480 CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
3481
3482 bool fProcFound = false;
3483 for (size_t a = 0; a < vecPID.size(); a++) /* Slow, but works. */
3484 {
3485 fProcFound = vecPID[a] == uPID;
3486 if (fProcFound)
3487 break;
3488 }
3489
3490 if (fProcFound)
3491 {
3492 if (pCtx->cVerbose)
3493 RTPrintf(GuestCtrl::tr("Terminating process (PID %RU32) (session ID %RU32) ...\n"),
3494 uPID, uID);
3495 CHECK_ERROR_BREAK(pProcess, Terminate());
3496 uProcsTerminated++;
3497 }
3498 else
3499 {
3500 if (idSession != UINT32_MAX)
3501 RTPrintf(GuestCtrl::tr("No matching process(es) for session ID %RU32 found\n"),
3502 idSession);
3503 }
3504
3505 pProcess.setNull();
3506 }
3507
3508 pSession.setNull();
3509 }
3510 }
3511
3512 if (!cSessionsHandled)
3513 RTPrintf(GuestCtrl::tr("No matching session(s) found\n"));
3514
3515 if (uProcsTerminated)
3516 RTPrintf(GuestCtrl::tr("%RU32 process(es) terminated\n", "", uProcsTerminated), uProcsTerminated);
3517
3518 } while (0);
3519
3520 pProcess.setNull();
3521 pSession.setNull();
3522
3523 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3524}
3525
3526
3527static DECLCALLBACK(RTEXITCODE) gctlHandleCloseSession(PGCTLCMDCTX pCtx, int argc, char **argv)
3528{
3529 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3530
3531 enum GETOPTDEF_SESSIONCLOSE
3532 {
3533 GETOPTDEF_SESSIONCLOSE_ALL = 2000
3534 };
3535 static const RTGETOPTDEF s_aOptions[] =
3536 {
3537 GCTLCMD_COMMON_OPTION_DEFS()
3538 { "--all", GETOPTDEF_SESSIONCLOSE_ALL, RTGETOPT_REQ_NOTHING },
3539 { "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3540 { "--session-name", 'n', RTGETOPT_REQ_STRING }
3541 };
3542
3543 int ch;
3544 RTGETOPTUNION ValueUnion;
3545 RTGETOPTSTATE GetState;
3546 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3547
3548 ULONG idSession = UINT32_MAX;
3549 Utf8Str strSessionName;
3550
3551 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3552 {
3553 /* For options that require an argument, ValueUnion has received the value. */
3554 switch (ch)
3555 {
3556 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3557
3558 case 'n': /* Session name pattern */
3559 strSessionName = ValueUnion.psz;
3560 break;
3561
3562 case 'i': /* Session ID */
3563 idSession = ValueUnion.u32;
3564 break;
3565
3566 case GETOPTDEF_SESSIONCLOSE_ALL:
3567 strSessionName = "*";
3568 break;
3569
3570 case VINF_GETOPT_NOT_OPTION:
3571 /** @todo Supply a CSV list of IDs or patterns to close?
3572 * break; */
3573 default:
3574 return errorGetOpt(ch, &ValueUnion);
3575 }
3576 }
3577
3578 if ( strSessionName.isEmpty()
3579 && idSession == UINT32_MAX)
3580 return errorSyntax(GuestCtrl::tr("No session ID specified!"));
3581
3582 if ( !strSessionName.isEmpty()
3583 && idSession != UINT32_MAX)
3584 return errorSyntax(GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
3585
3586 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3587 if (rcExit != RTEXITCODE_SUCCESS)
3588 return rcExit;
3589
3590 HRESULT hrc = S_OK;
3591
3592 do
3593 {
3594 size_t cSessionsHandled = 0;
3595
3596 SafeIfaceArray <IGuestSession> collSessions;
3597 CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3598 size_t cSessions = collSessions.size();
3599
3600 for (size_t i = 0; i < cSessions; i++)
3601 {
3602 ComPtr<IGuestSession> pSession = collSessions[i];
3603 Assert(!pSession.isNull());
3604
3605 ULONG uID; /* Session ID */
3606 CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3607 Bstr strName;
3608 CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3609 Utf8Str strNameUtf8(strName); /* Session name */
3610
3611 bool fSessionFound;
3612 if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3613 fSessionFound = uID == idSession;
3614 else /* ... or by naming pattern. */
3615 fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str());
3616 if (fSessionFound)
3617 {
3618 cSessionsHandled++;
3619
3620 Assert(!pSession.isNull());
3621 if (pCtx->cVerbose)
3622 RTPrintf(GuestCtrl::tr("Closing guest session ID=#%RU32 \"%s\" ...\n"),
3623 uID, strNameUtf8.c_str());
3624 CHECK_ERROR_BREAK(pSession, Close());
3625 if (pCtx->cVerbose)
3626 RTPrintf(GuestCtrl::tr("Guest session successfully closed\n"));
3627
3628 pSession.setNull();
3629 }
3630 }
3631
3632 if (!cSessionsHandled)
3633 {
3634 RTPrintf(GuestCtrl::tr("No guest session(s) found\n"));
3635 hrc = E_ABORT; /* To set exit code accordingly. */
3636 }
3637
3638 } while (0);
3639
3640 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3641}
3642
3643
3644static DECLCALLBACK(RTEXITCODE) gctlHandleWatch(PGCTLCMDCTX pCtx, int argc, char **argv)
3645{
3646 AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3647
3648 /*
3649 * Parse arguments.
3650 */
3651 static const RTGETOPTDEF s_aOptions[] =
3652 {
3653 GCTLCMD_COMMON_OPTION_DEFS()
3654 { "--timeout", 't', RTGETOPT_REQ_UINT32 }
3655 };
3656
3657 uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
3658
3659 int ch;
3660 RTGETOPTUNION ValueUnion;
3661 RTGETOPTSTATE GetState;
3662 RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3663
3664 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3665 {
3666 /* For options that require an argument, ValueUnion has received the value. */
3667 switch (ch)
3668 {
3669 GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3670
3671 case 't': /* Timeout */
3672 cMsTimeout = ValueUnion.u32;
3673 break;
3674
3675 case VINF_GETOPT_NOT_OPTION:
3676 default:
3677 return errorGetOpt(ch, &ValueUnion);
3678 }
3679 }
3680
3681 /** @todo Specify categories to watch for. */
3682
3683 RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3684 if (rcExit != RTEXITCODE_SUCCESS)
3685 return rcExit;
3686
3687 HRESULT hrc;
3688
3689 try
3690 {
3691 ComObjPtr<GuestEventListenerImpl> pGuestListener;
3692 do
3693 {
3694 /* Listener creation. */
3695 pGuestListener.createObject();
3696 pGuestListener->init(new GuestEventListener());
3697
3698 /* Register for IGuest events. */
3699 ComPtr<IEventSource> es;
3700 CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
3701 com::SafeArray<VBoxEventType_T> eventTypes;
3702 eventTypes.push_back(VBoxEventType_OnGuestSessionRegistered);
3703 /** @todo Also register for VBoxEventType_OnGuestUserStateChanged on demand? */
3704 CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
3705 true /* Active listener */));
3706 /* Note: All other guest control events have to be registered
3707 * as their corresponding objects appear. */
3708
3709 } while (0);
3710
3711 if (pCtx->cVerbose)
3712 RTPrintf(GuestCtrl::tr("Waiting for events ...\n"));
3713
3714 RTMSINTERVAL tsStart = RTTimeMilliTS();
3715 while (RTTimeMilliTS() - tsStart < cMsTimeout)
3716 {
3717 /* Wait for the global signal semaphore getting signalled. */
3718 int vrc = RTSemEventWait(g_SemEventGuestCtrlCanceled, 100 /* ms */);
3719 if (RT_FAILURE(vrc))
3720 {
3721 if (vrc != VERR_TIMEOUT)
3722 {
3723 RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
3724 break;
3725 }
3726 }
3727 else
3728 break;
3729
3730 /* We need to process the event queue, otherwise our registered listeners won't get any events. */
3731 NativeEventQueue::getMainEventQueue()->processEventQueue(0);
3732 }
3733
3734 if (!pGuestListener.isNull())
3735 {
3736 /* Guest callback unregistration. */
3737 ComPtr<IEventSource> pES;
3738 CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
3739 if (!pES.isNull())
3740 CHECK_ERROR(pES, UnregisterListener(pGuestListener));
3741 pGuestListener.setNull();
3742 }
3743 }
3744 catch (std::bad_alloc &)
3745 {
3746 hrc = E_OUTOFMEMORY;
3747 }
3748
3749 return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3750}
3751
3752/**
3753 * Access the guest control store.
3754 *
3755 * @returns program exit code.
3756 * @note see the command line API description for parameters
3757 */
3758RTEXITCODE handleGuestControl(HandlerArg *pArg)
3759{
3760 AssertPtr(pArg);
3761
3762 /*
3763 * Command definitions.
3764 */
3765 static const GCTLCMDDEF s_aCmdDefs[] =
3766 {
3767 { "run", gctlHandleRun, HELP_SCOPE_GUESTCONTROL_RUN, 0 },
3768 { "start", gctlHandleStart, HELP_SCOPE_GUESTCONTROL_START, 0 },
3769 { "copyfrom", gctlHandleCopyFrom, HELP_SCOPE_GUESTCONTROL_COPYFROM, 0 },
3770 { "copyto", gctlHandleCopyTo, HELP_SCOPE_GUESTCONTROL_COPYTO, 0 },
3771
3772 { "mkdir", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3773 { "md", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3774 { "createdirectory", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3775 { "createdir", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3776
3777 { "rmdir", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3778 { "removedir", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3779 { "removedirectory", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3780
3781 { "rm", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3782 { "removefile", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3783 { "erase", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3784 { "del", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3785 { "delete", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3786
3787 { "mv", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3788 { "move", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3789 { "ren", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3790 { "rename", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3791
3792 { "mktemp", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3793 { "createtemp", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3794 { "createtemporary", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3795
3796 { "df", gctlHandleFsInfo, HELP_SCOPE_GUESTCONTROL_FSINFO, 0 },
3797 { "fsinfo", gctlHandleFsInfo, HELP_SCOPE_GUESTCONTROL_FSINFO, 0 },
3798
3799 { "stat", gctlHandleStat, HELP_SCOPE_GUESTCONTROL_STAT, 0 },
3800
3801 { "closeprocess", gctlHandleCloseProcess, HELP_SCOPE_GUESTCONTROL_CLOSEPROCESS, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3802 { "closesession", gctlHandleCloseSession, HELP_SCOPE_GUESTCONTROL_CLOSESESSION, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3803 { "list", gctlHandleList, HELP_SCOPE_GUESTCONTROL_LIST, GCTLCMDCTX_F_SESSION_ANONYMOUS | GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3804 { "watch", gctlHandleWatch, HELP_SCOPE_GUESTCONTROL_WATCH, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3805
3806 {"updateguestadditions",gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3807 { "updateadditions", gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3808 { "updatega", gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3809
3810 { "waitrunlevel", gctlHandleWaitRunLevel, HELP_SCOPE_GUESTCONTROL_WAITRUNLEVEL, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3811 { "waitforrunlevel", gctlHandleWaitRunLevel, HELP_SCOPE_GUESTCONTROL_WAITRUNLEVEL, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3812 };
3813
3814 /*
3815 * VBoxManage guestcontrol [common-options] <VM> [common-options] <sub-command> ...
3816 *
3817 * Parse common options and VM name until we find a sub-command. Allowing
3818 * the user to put the user and password related options before the
3819 * sub-command makes it easier to edit the command line when doing several
3820 * operations with the same guest user account. (Accidentally, it also
3821 * makes the syntax diagram shorter and easier to read.)
3822 */
3823 GCTLCMDCTX CmdCtx;
3824 RTEXITCODE rcExit = gctrCmdCtxInit(&CmdCtx, pArg);
3825 if (rcExit == RTEXITCODE_SUCCESS)
3826 {
3827 static const RTGETOPTDEF s_CommonOptions[] = { GCTLCMD_COMMON_OPTION_DEFS() };
3828
3829 int ch;
3830 RTGETOPTUNION ValueUnion;
3831 RTGETOPTSTATE GetState;
3832 RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0, 0 /* No sorting! */);
3833
3834 while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3835 {
3836 switch (ch)
3837 {
3838 GCTLCMD_COMMON_OPTION_CASES(&CmdCtx, ch, &ValueUnion);
3839
3840 case VINF_GETOPT_NOT_OPTION:
3841 /* First comes the VM name or UUID. */
3842 if (!CmdCtx.pszVmNameOrUuid)
3843 CmdCtx.pszVmNameOrUuid = ValueUnion.psz;
3844 /*
3845 * The sub-command is next. Look it up and invoke it.
3846 * Note! Currently no warnings about user/password options (like we'll do later on)
3847 * for GCTLCMDCTX_F_SESSION_ANONYMOUS commands. No reason to be too pedantic.
3848 */
3849 else
3850 {
3851 const char *pszCmd = ValueUnion.psz;
3852 uint32_t iCmd;
3853 for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
3854 if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
3855 {
3856 CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
3857
3858 setCurrentSubcommand(s_aCmdDefs[iCmd].fSubcommandScope);
3859 rcExit = s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
3860 &pArg->argv[GetState.iNext - 1]);
3861
3862 gctlCtxTerm(&CmdCtx);
3863 return rcExit;
3864 }
3865 return errorSyntax(GuestCtrl::tr("Unknown sub-command: '%s'"), pszCmd);
3866 }
3867 break;
3868
3869 default:
3870 return errorGetOpt(ch, &ValueUnion);
3871 }
3872 }
3873 if (CmdCtx.pszVmNameOrUuid)
3874 rcExit = errorSyntax(GuestCtrl::tr("Missing sub-command"));
3875 else
3876 rcExit = errorSyntax(GuestCtrl::tr("Missing VM name and sub-command"));
3877 }
3878 return rcExit;
3879}
Note: See TracBrowser for help on using the repository browser.

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