VBoxManageGuestCtrl.cpp@ 107699

Last change on this file since 107699 was 107434, checked in by vboxsync, 2 months ago
VBoxManage/VBoxManageGuestCtrl.cpp: Fixed a warning found by Parfait. jiraref:VBP-1424
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 149.0 KB

Line
1	/* $Id: VBoxManageGuestCtrl.cpp 107434 2025-01-06 17:41:07Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of guestcontrol command.
4	*/
5
6	/*
7	* Copyright (C) 2010-2024 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
74	using 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. */
115	static 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	*/
127	VBOX_LISTENER_DECLARE(GuestFileEventListenerImpl)
128	VBOX_LISTENER_DECLARE(GuestProcessEventListenerImpl)
129	VBOX_LISTENER_DECLARE(GuestSessionEventListenerImpl)
130	VBOX_LISTENER_DECLARE(GuestEventListenerImpl)
131	VBOX_LISTENER_DECLARE(GuestAdditionsRunlevelListener)
132
133	/**
134	* Definition of a guestcontrol command, with handler and various flags.
135	*/
136	typedef 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. */
154	typedef 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	*/
170	typedef 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	*/
208	typedef 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	*/
217	typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> > DESTDIRMAP, *PDESTDIRMAP;
218	typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> >::iterator DESTDIRMAPITER, *PDESTDIRMAPITER;
219
220
221	enum kStreamTransform
222	{
223	kStreamTransform_None = 0,
224	kStreamTransform_Dos2Unix,
225	kStreamTransform_Unix2Dos
226	};
227
228
229	DECLARE_TRANSLATION_CONTEXT(GuestCtrl);
230
231
232	#ifdef RT_OS_WINDOWS
233	static 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	*/
262	static 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	*/
277	static 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	*/
306	static 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	*/
337	const 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	*/
372	static 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	*/
403	const 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	*/
432	const 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	*/
457	static 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
477	static 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
497	static int gctlPrintError(IUnknown *pObj, const GUID &aIID)
498	{
499	com::ErrorInfo ErrInfo(pObj, aIID);
500	return gctlPrintError(ErrInfo);
501	}
502
503	static 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	*/
553	static 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	*/
603	static 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	*/
666	static 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	*/
723	static 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	*/
829	static 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	*/
878	static 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	if (pCtx->pGuestSession.isNotNull())
904	CHECK_ERROR(pCtx->pGuestSession, Close());
905
906	if (pCtx->cVerbose > 4)
907	{
908	SafeIfaceArray <IGuestSession> collSessions;
909	CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
910	RTPrintf(GuestCtrl::tr("Now %zu guest sessions registered\n"), collSessions.size());
911	}
912	}
913	else if ( pCtx->fDetachGuestSession
914	&& pCtx->cVerbose)
915	RTPrintf(GuestCtrl::tr("Guest session detached\n"));
916
917	pCtx->pGuestSession.setNull();
918	}
919
920	/*
921	* Close the VM session.
922	*/
923	if (pCtx->fLockedVmSession)
924	{
925	Assert(pCtx->pArg->session.isNotNull());
926	CHECK_ERROR(pCtx->pArg->session, UnlockMachine());
927	pCtx->fLockedVmSession = false;
928	}
929	}
930
931
932
933
934
935	/*
936	*
937	*
938	* Guest Control Command Handling.
939	* Guest Control Command Handling.
940	* Guest Control Command Handling.
941	* Guest Control Command Handling.
942	* Guest Control Command Handling.
943	*
944	*
945	*/
946
947
948	/** @name EXITCODEEXEC_XXX - Special run exit codes.
949	*
950	* Special exit codes for returning errors/information of a started guest
951	* process to the command line VBoxManage was started from. Useful for e.g.
952	* scripting.
953	*
954	* ASSUMING that all platforms have at least 7-bits for the exit code we can do
955	* the following mapping:
956	* - Guest exit code 0 is mapped to 0 on the host.
957	* - Guest exit codes 1 thru 93 (0x5d) are displaced by 32, so that 1
958	* becomes 33 (0x21) on the host and 93 becomes 125 (0x7d) on the host.
959	* - Guest exit codes 94 (0x5e) and above are mapped to 126 (0x5e).
960	*
961	* We ASSUME that all VBoxManage status codes are in the range 0 thru 32.
962	*
963	* @note These are frozen as of 4.1.0.
964	* @note The guest exit code mappings was introduced with 5.0 and the 'run'
965	* command, they are/was not supported by 'exec'.
966	* @sa gctlRunCalculateExitCode
967	*/
968	/** Process exited normally but with an exit code <> 0. */
969	#define EXITCODEEXEC_CODE ((RTEXITCODE)16)
970	#define EXITCODEEXEC_FAILED ((RTEXITCODE)17)
971	#define EXITCODEEXEC_TERM_SIGNAL ((RTEXITCODE)18)
972	#define EXITCODEEXEC_TERM_ABEND ((RTEXITCODE)19)
973	#define EXITCODEEXEC_TIMEOUT ((RTEXITCODE)20)
974	#define EXITCODEEXEC_DOWN ((RTEXITCODE)21)
975	/** Execution was interrupt by user (ctrl-c). */
976	#define EXITCODEEXEC_CANCELED ((RTEXITCODE)22)
977	/** The first mapped guest (non-zero) exit code. */
978	#define EXITCODEEXEC_MAPPED_FIRST 33
979	/** The last mapped guest (non-zero) exit code value (inclusive). */
980	#define EXITCODEEXEC_MAPPED_LAST 125
981	/** The number of exit codes from EXITCODEEXEC_MAPPED_FIRST to
982	* EXITCODEEXEC_MAPPED_LAST. This is also the highest guest exit code number
983	* we're able to map. */
984	#define EXITCODEEXEC_MAPPED_RANGE (93)
985	/** The guest exit code displacement value. */
986	#define EXITCODEEXEC_MAPPED_DISPLACEMENT 32
987	/** The guest exit code was too big to be mapped. */
988	#define EXITCODEEXEC_MAPPED_BIG ((RTEXITCODE)126)
989	/** @} */
990
991	/**
992	* Calculates the exit code of VBoxManage.
993	*
994	* @returns The exit code to return.
995	* @param enmStatus The guest process status.
996	* @param uExitCode The associated guest process exit code (where
997	* applicable).
998	* @param fReturnExitCodes Set if we're to use the 32-126 range for guest
999	* exit codes.
1000	*/
1001	static RTEXITCODE gctlRunCalculateExitCode(ProcessStatus_T enmStatus, ULONG uExitCode, bool fReturnExitCodes)
1002	{
1003	switch (enmStatus)
1004	{
1005	case ProcessStatus_TerminatedNormally:
1006	if (uExitCode == 0)
1007	return RTEXITCODE_SUCCESS;
1008	if (!fReturnExitCodes)
1009	return EXITCODEEXEC_CODE;
1010	if (uExitCode <= EXITCODEEXEC_MAPPED_RANGE)
1011	return (RTEXITCODE) (uExitCode + EXITCODEEXEC_MAPPED_DISPLACEMENT);
1012	return EXITCODEEXEC_MAPPED_BIG;
1013
1014	case ProcessStatus_TerminatedAbnormally:
1015	return EXITCODEEXEC_TERM_ABEND;
1016	case ProcessStatus_TerminatedSignal:
1017	return EXITCODEEXEC_TERM_SIGNAL;
1018
1019	#if 0 /* see caller! */
1020	case ProcessStatus_TimedOutKilled:
1021	return EXITCODEEXEC_TIMEOUT;
1022	case ProcessStatus_Down:
1023	return EXITCODEEXEC_DOWN; /* Service/OS is stopping, process was killed. */
1024	case ProcessStatus_Error:
1025	return EXITCODEEXEC_FAILED;
1026
1027	/* The following is probably for detached? */
1028	case ProcessStatus_Starting:
1029	return RTEXITCODE_SUCCESS;
1030	case ProcessStatus_Started:
1031	return RTEXITCODE_SUCCESS;
1032	case ProcessStatus_Paused:
1033	return RTEXITCODE_SUCCESS;
1034	case ProcessStatus_Terminating:
1035	return RTEXITCODE_SUCCESS; /** @todo ???? */
1036	#endif
1037
1038	default:
1039	AssertMsgFailed(("Unknown exit status (%u/%u) from guest process returned!\n", enmStatus, uExitCode));
1040	return RTEXITCODE_FAILURE;
1041	}
1042	}
1043
1044
1045	/**
1046	* Pumps guest output to the host.
1047	*
1048	* @return IPRT status code.
1049	* @param pProcess Pointer to appropriate process object.
1050	* @param hVfsIosDst Where to write the data. Can be the bit bucket or a (valid [std]) handle.
1051	* @param uHandle Handle where to read the data from.
1052	* @param cMsTimeout Timeout (in ms) to wait for the operation to
1053	* complete.
1054	*/
1055	static int gctlRunPumpOutput(IProcess *pProcess, RTVFSIOSTREAM hVfsIosDst, ULONG uHandle, RTMSINTERVAL cMsTimeout)
1056	{
1057	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1058	Assert(hVfsIosDst != NIL_RTVFSIOSTREAM);
1059
1060	int vrc;
1061
1062	SafeArray<BYTE> aOutputData;
1063	HRESULT hrc = pProcess->Read(uHandle, _64K, RT_MAX(cMsTimeout, 1), ComSafeArrayAsOutParam(aOutputData));
1064	if (SUCCEEDED(hrc))
1065	{
1066	size_t cbOutputData = aOutputData.size();
1067	if (cbOutputData == 0)
1068	vrc = VINF_SUCCESS;
1069	else
1070	{
1071	BYTE const *pbBuf = aOutputData.raw();
1072	AssertPtr(pbBuf);
1073
1074	vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /fBlocking/, NULL);
1075	if (RT_FAILURE(vrc))
1076	RTMsgError(GuestCtrl::tr("Unable to write output, vrc=%Rrc\n"), vrc);
1077	}
1078	}
1079	else
1080	vrc = gctlPrintError(pProcess, COM_IIDOF(IProcess));
1081	return vrc;
1082	}
1083
1084
1085	/**
1086	* Configures a host handle for pumping guest bits.
1087	*
1088	* @returns true if enabled and we successfully configured it.
1089	* @param fEnabled Whether pumping this pipe is configured to std handles,
1090	* or going to the bit bucket instead.
1091	* @param enmHandle The IPRT standard handle designation.
1092	* @param pszName The name for user messages.
1093	* @param enmTransformation The transformation to apply.
1094	* @param phVfsIos Where to return the resulting I/O stream handle.
1095	*/
1096	static bool gctlRunSetupHandle(bool fEnabled, RTHANDLESTD enmHandle, const char *pszName,
1097	kStreamTransform enmTransformation, PRTVFSIOSTREAM phVfsIos)
1098	{
1099	if (fEnabled)
1100	{
1101	int vrc = RTVfsIoStrmFromStdHandle(enmHandle, 0, true /fLeaveOpen/, phVfsIos);
1102	if (RT_SUCCESS(vrc))
1103	{
1104	if (enmTransformation != kStreamTransform_None)
1105	{
1106	RTMsgWarning(GuestCtrl::tr("Unsupported %s line ending conversion"), pszName);
1107	/** @todo Implement dos2unix and unix2dos stream filters. */
1108	}
1109	return true;
1110	}
1111	RTMsgWarning(GuestCtrl::tr("Error getting %s handle: %Rrc"), pszName, vrc);
1112	}
1113	else /* If disabled, all goes to / gets fed to/from the bit bucket. */
1114	{
1115	RTFILE hFile;
1116	int vrc = RTFileOpenBitBucket(&hFile, enmHandle == RTHANDLESTD_INPUT ? RTFILE_O_READ : RTFILE_O_WRITE);
1117	if (RT_SUCCESS(vrc))
1118	{
1119	vrc = RTVfsIoStrmFromRTFile(hFile, 0 /* fOpen /, false / fLeaveOpen */, phVfsIos);
1120	if (RT_SUCCESS(vrc))
1121	return true;
1122	}
1123	}
1124
1125	return false;
1126	}
1127
1128
1129	/**
1130	* Returns the remaining time (in ms) based on the start time and a set
1131	* timeout value. Returns RT_INDEFINITE_WAIT if no timeout was specified.
1132	*
1133	* @return RTMSINTERVAL Time left (in ms).
1134	* @param u64StartMs Start time (in ms).
1135	* @param cMsTimeout Timeout value (in ms).
1136	*/
1137	static RTMSINTERVAL gctlRunGetRemainingTime(uint64_t u64StartMs, RTMSINTERVAL cMsTimeout)
1138	{
1139	if (!cMsTimeout \|\| cMsTimeout == RT_INDEFINITE_WAIT) /* If no timeout specified, wait forever. */
1140	return RT_INDEFINITE_WAIT;
1141
1142	uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
1143	if (u64ElapsedMs >= cMsTimeout)
1144	return 0;
1145
1146	return cMsTimeout - (RTMSINTERVAL)u64ElapsedMs;
1147	}
1148
1149	/**
1150	* Common handler for the 'run' and 'start' commands.
1151	*
1152	* @returns Command exit code.
1153	* @param pCtx Guest session context.
1154	* @param argc The argument count.
1155	* @param argv The argument vector for this command.
1156	* @param fRunCmd Set if it's 'run' clear if 'start'.
1157	*/
1158	static RTEXITCODE gctlHandleRunCommon(PGCTLCMDCTX pCtx, int argc, char **argv, bool fRunCmd)
1159	{
1160	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1161
1162	/*
1163	* Parse arguments.
1164	*/
1165	enum kGstCtrlRunOpt
1166	{
1167	kGstCtrlRunOpt_IgnoreOrphanedProcesses = 1000,
1168	kGstCtrlRunOpt_NoProfile, /** @todo Deprecated and will be removed soon; use kGstCtrlRunOpt_Profile instead, if needed. */
1169	kGstCtrlRunOpt_Profile,
1170	kGstCtrlRunOpt_Dos2Unix,
1171	kGstCtrlRunOpt_Unix2Dos,
1172	kGstCtrlRunOpt_WaitForStdOut,
1173	kGstCtrlRunOpt_NoWaitForStdOut,
1174	kGstCtrlRunOpt_WaitForStdErr,
1175	kGstCtrlRunOpt_NoWaitForStdErr
1176	};
1177	static const RTGETOPTDEF s_aOptions[] =
1178	{
1179	GCTLCMD_COMMON_OPTION_DEFS()
1180	{ "--arg0", '0', RTGETOPT_REQ_STRING },
1181	{ "--cwd", 'C', RTGETOPT_REQ_STRING },
1182	{ "--putenv", 'E', RTGETOPT_REQ_STRING },
1183	{ "--exe", 'e', RTGETOPT_REQ_STRING },
1184	{ "--timeout", 't', RTGETOPT_REQ_UINT32 },
1185	{ "--unquoted-args", 'u', RTGETOPT_REQ_NOTHING },
1186	{ "--ignore-orphaned-processes", kGstCtrlRunOpt_IgnoreOrphanedProcesses, RTGETOPT_REQ_NOTHING },
1187	{ "--no-profile", kGstCtrlRunOpt_NoProfile, RTGETOPT_REQ_NOTHING }, /** @todo Deprecated. */
1188	{ "--profile", kGstCtrlRunOpt_Profile, RTGETOPT_REQ_NOTHING },
1189	/* run only: 6 - options */
1190	{ "--dos2unix", kGstCtrlRunOpt_Dos2Unix, RTGETOPT_REQ_NOTHING },
1191	{ "--unix2dos", kGstCtrlRunOpt_Unix2Dos, RTGETOPT_REQ_NOTHING },
1192	{ "--no-wait-stdout", kGstCtrlRunOpt_NoWaitForStdOut, RTGETOPT_REQ_NOTHING },
1193	{ "--wait-stdout", kGstCtrlRunOpt_WaitForStdOut, RTGETOPT_REQ_NOTHING },
1194	{ "--no-wait-stderr", kGstCtrlRunOpt_NoWaitForStdErr, RTGETOPT_REQ_NOTHING },
1195	{ "--wait-stderr", kGstCtrlRunOpt_WaitForStdErr, RTGETOPT_REQ_NOTHING },
1196	};
1197
1198	/** @todo stdin handling. */
1199
1200	int ch;
1201	RTGETOPTUNION ValueUnion;
1202	RTGETOPTSTATE GetState;
1203	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions) - (fRunCmd ? 0 : 6),
1204	1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1205	AssertRC(vrc);
1206
1207	com::SafeArray<ProcessCreateFlag_T> aCreateFlags;
1208	com::SafeArray<ProcessWaitForFlag_T> aWaitFlags;
1209	com::SafeArray<IN_BSTR> aArgs;
1210	com::SafeArray<IN_BSTR> aEnv;
1211	const char * pszImage = NULL;
1212	const char * pszArg0 = NULL; /* Argument 0 to use. pszImage will be used if not specified. */
1213	const char * pszCwd = NULL;
1214	bool fWaitForStdOut = fRunCmd;
1215	bool fWaitForStdErr = fRunCmd;
1216	RTVFSIOSTREAM hVfsStdOut = NIL_RTVFSIOSTREAM;
1217	RTVFSIOSTREAM hVfsStdErr = NIL_RTVFSIOSTREAM;
1218	enum kStreamTransform enmStdOutTransform = kStreamTransform_None;
1219	enum kStreamTransform enmStdErrTransform = kStreamTransform_None;
1220	RTMSINTERVAL cMsTimeout = 0;
1221
1222	try
1223	{
1224	/* Wait for process start in any case. This is useful for scripting VBoxManage
1225	* when relying on its overall exit code. */
1226	aWaitFlags.push_back(ProcessWaitForFlag_Start);
1227
1228	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1229	{
1230	/* For options that require an argument, ValueUnion has received the value. */
1231	switch (ch)
1232	{
1233	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1234
1235	case 'E':
1236	if ( ValueUnion.psz[0] == '\0'
1237	\|\| ValueUnion.psz[0] == '=')
1238	return errorSyntax(GuestCtrl::tr("Invalid argument variable[=value]: '%s'"), ValueUnion.psz);
1239	aEnv.push_back(Bstr(ValueUnion.psz).raw());
1240	break;
1241
1242	case kGstCtrlRunOpt_IgnoreOrphanedProcesses:
1243	aCreateFlags.push_back(ProcessCreateFlag_IgnoreOrphanedProcesses);
1244	break;
1245
1246	case kGstCtrlRunOpt_NoProfile:
1247	/** @todo Deprecated, will be removed. */
1248	RTPrintf(GuestCtrl::tr("Warning: Deprecated option \"--no-profile\" specified\n"));
1249	break;
1250
1251	case kGstCtrlRunOpt_Profile:
1252	aCreateFlags.push_back(ProcessCreateFlag_Profile);
1253	break;
1254
1255	case '0':
1256	pszArg0 = ValueUnion.psz;
1257	break;
1258
1259	case 'C':
1260	pszCwd = ValueUnion.psz;
1261	break;
1262
1263	case 'e':
1264	pszImage = ValueUnion.psz;
1265	break;
1266
1267	case 'u':
1268	aCreateFlags.push_back(ProcessCreateFlag_UnquotedArguments);
1269	break;
1270
1271	/** @todo Add a hidden flag. */
1272
1273	case 't': /* Timeout */
1274	cMsTimeout = ValueUnion.u32;
1275	break;
1276
1277	/* run only options: */
1278	case kGstCtrlRunOpt_Dos2Unix:
1279	Assert(fRunCmd);
1280	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Dos2Unix;
1281	break;
1282	case kGstCtrlRunOpt_Unix2Dos:
1283	Assert(fRunCmd);
1284	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Unix2Dos;
1285	break;
1286
1287	case kGstCtrlRunOpt_WaitForStdOut:
1288	Assert(fRunCmd);
1289	fWaitForStdOut = true;
1290	break;
1291	case kGstCtrlRunOpt_NoWaitForStdOut:
1292	Assert(fRunCmd);
1293	fWaitForStdOut = false;
1294	break;
1295
1296	case kGstCtrlRunOpt_WaitForStdErr:
1297	Assert(fRunCmd);
1298	fWaitForStdErr = true;
1299	break;
1300	case kGstCtrlRunOpt_NoWaitForStdErr:
1301	Assert(fRunCmd);
1302	fWaitForStdErr = false;
1303	break;
1304
1305	case VINF_GETOPT_NOT_OPTION:
1306	/* VINF_GETOPT_NOT_OPTION comes after all options have been specified;
1307	* so if pszImage still is zero at this stage, we use the first non-option found
1308	* as the image being executed. */
1309	if (!pszImage)
1310	pszImage = ValueUnion.psz;
1311	else /* Add anything else to the arguments vector. */
1312	aArgs.push_back(Bstr(ValueUnion.psz).raw());
1313	break;
1314
1315	default:
1316	return errorGetOpt(ch, &ValueUnion);
1317
1318	} /* switch */
1319	} /* while RTGetOpt */
1320
1321	/* Must have something to execute. */
1322	if (!pszImage \|\| !*pszImage)
1323	return errorSyntax(GuestCtrl::tr("No executable specified!"));
1324
1325	/* Set the arg0 argument (descending precedence):
1326	* - If an argument 0 is explicitly specified (via "--arg0"), use this as argument 0.
1327	* - When an image is specified explicitly (via "--exe <image>"), use <image> as argument 0.
1328	* Note: This is (and ever was) the default behavior users expect, so don't change this! */
1329	if (pszArg0)
1330	aArgs.push_front(Bstr(pszArg0).raw());
1331	else
1332	aArgs.push_front(Bstr(pszImage).raw());
1333
1334	if (pCtx->cVerbose) /* Print the final execution parameters in verbose mode. */
1335	{
1336	RTPrintf(GuestCtrl::tr("Executing:\n Image : %s\n"), pszImage);
1337	for (size_t i = 0; i < aArgs.size(); i++)
1338	RTPrintf(GuestCtrl::tr(" arg[%d]: %ls\n"), i, aArgs[i]);
1339	}
1340	/* No altering of aArgs and/or pszImage after this point! */
1341
1342	/*
1343	* Finalize process creation and wait flags and input/output streams.
1344	*/
1345	if (!fRunCmd)
1346	{
1347	aCreateFlags.push_back(ProcessCreateFlag_WaitForProcessStartOnly);
1348	Assert(!fWaitForStdOut);
1349	Assert(!fWaitForStdErr);
1350	}
1351	else
1352	{
1353	aWaitFlags.push_back(ProcessWaitForFlag_Terminate);
1354	if (gctlRunSetupHandle(fWaitForStdOut, RTHANDLESTD_OUTPUT, "stdout", enmStdOutTransform, &hVfsStdOut))
1355	{
1356	if (fWaitForStdOut)
1357	{
1358	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdOut);
1359	aWaitFlags.push_back(ProcessWaitForFlag_StdOut);
1360	}
1361	}
1362	else /* Failed to set up handle, disable. */
1363	fWaitForStdOut = false;
1364
1365	if (gctlRunSetupHandle(fWaitForStdErr, RTHANDLESTD_ERROR, "stderr", enmStdErrTransform, &hVfsStdErr))
1366	{
1367	if (fWaitForStdErr)
1368	{
1369	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdErr);
1370	aWaitFlags.push_back(ProcessWaitForFlag_StdErr);
1371	}
1372	}
1373	else /* Failed to set up handle, disable. */
1374	fWaitForStdErr = false;
1375	}
1376	}
1377	catch (std::bad_alloc &)
1378	{
1379	return RTMsgErrorExit(RTEXITCODE_FAILURE, "VERR_NO_MEMORY\n");
1380	}
1381
1382	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1383	if (rcExit != RTEXITCODE_SUCCESS)
1384	return rcExit;
1385
1386	HRESULT hrc;
1387
1388	try
1389	{
1390	do
1391	{
1392	/* Get current time stamp to later calculate rest of timeout left. */
1393	uint64_t msStart = RTTimeMilliTS();
1394
1395	/*
1396	* Create the process.
1397	*/
1398	if (pCtx->cVerbose)
1399	{
1400	if (cMsTimeout == 0)
1401	RTPrintf(GuestCtrl::tr("Starting guest process ...\n"));
1402	else
1403	RTPrintf(GuestCtrl::tr("Starting guest process (within %ums)\n"), cMsTimeout);
1404	}
1405	ComPtr<IGuestProcess> pProcess;
1406	CHECK_ERROR_BREAK(pCtx->pGuestSession, ProcessCreate(Bstr(pszImage).raw(),
1407	ComSafeArrayAsInParam(aArgs),
1408	Bstr(pszCwd).raw(),
1409	ComSafeArrayAsInParam(aEnv),
1410	ComSafeArrayAsInParam(aCreateFlags),
1411	gctlRunGetRemainingTime(msStart, cMsTimeout),
1412	pProcess.asOutParam()));
1413
1414	/*
1415	* Explicitly wait for the guest process to be in a started state.
1416	*/
1417	com::SafeArray<ProcessWaitForFlag_T> aWaitStartFlags;
1418	aWaitStartFlags.push_back(ProcessWaitForFlag_Start);
1419	ProcessWaitResult_T waitResult;
1420	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitStartFlags),
1421	gctlRunGetRemainingTime(msStart, cMsTimeout), &waitResult));
1422
1423	ULONG uPID = 0;
1424	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
1425	if (fRunCmd && pCtx->cVerbose)
1426	RTPrintf(GuestCtrl::tr("Process '%s' (PID %RU32) started\n"), pszImage, uPID);
1427	else if (!fRunCmd && pCtx->cVerbose)
1428	{
1429	/* Just print plain PID to make it easier for scripts
1430	* invoking VBoxManage. */
1431	RTPrintf(GuestCtrl::tr("[%RU32 - Session %RU32]\n"), uPID, pCtx->uSessionID);
1432	}
1433
1434	/*
1435	* Wait for process to exit/start...
1436	*/
1437	RTMSINTERVAL cMsTimeLeft = 1; /* Will be calculated. */
1438	bool fReadStdOut = false;
1439	bool fReadStdErr = false;
1440	bool fCompleted = false;
1441	bool fCompletedStartCmd = false;
1442
1443	vrc = VINF_SUCCESS;
1444	while ( !fCompleted
1445	&& cMsTimeLeft > 0)
1446	{
1447	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1448	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitFlags),
1449	RT_MIN(500 /ms/, RT_MAX(cMsTimeLeft, 1 /ms/)),
1450	&waitResult));
1451	if (pCtx->cVerbose)
1452	RTPrintf(GuestCtrl::tr("Wait result is '%s' (%d)\n"), gctlProcessWaitResultToText(waitResult), waitResult);
1453	switch (waitResult)
1454	{
1455	case ProcessWaitResult_Start: /** @todo you always wait for 'start', */
1456	fCompletedStartCmd = fCompleted = !fRunCmd; /* Only wait for startup if the 'start' command. */
1457	if (!fCompleted && aWaitFlags[0] == ProcessWaitForFlag_Start)
1458	aWaitFlags[0] = ProcessWaitForFlag_Terminate;
1459	break;
1460	case ProcessWaitResult_StdOut:
1461	fReadStdOut = true;
1462	break;
1463	case ProcessWaitResult_StdErr:
1464	fReadStdErr = true;
1465	break;
1466	case ProcessWaitResult_Terminate:
1467	if (pCtx->cVerbose)
1468	RTPrintf(GuestCtrl::tr("Process terminated\n"));
1469	/* Process terminated, we're done. */
1470	fCompleted = true;
1471	break;
1472	case ProcessWaitResult_WaitFlagNotSupported:
1473	/* The guest does not support waiting for stdout/err, so
1474	* yield to reduce the CPU load due to busy waiting. */
1475	RTThreadYield();
1476	fReadStdOut = fReadStdErr = true;
1477	/* Note: In case the user specified explicitly not wanting to wait for stdout / stderr,
1478	* the configured VFS handle goes to / will be fed from the bit bucket. */
1479	break;
1480	case ProcessWaitResult_Timeout:
1481	{
1482	/** @todo It is really unclear whether we will get stuck with the timeout
1483	* result here if the guest side times out the process and fails to
1484	* kill the process... To be on the save side, double the IPC and
1485	* check the process status every time we time out. */
1486	ProcessStatus_T enmProcStatus;
1487	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&enmProcStatus));
1488	if ( enmProcStatus == ProcessStatus_TimedOutKilled
1489	\|\| enmProcStatus == ProcessStatus_TimedOutAbnormally)
1490	fCompleted = true;
1491	fReadStdOut = fReadStdErr = true;
1492	break;
1493	}
1494	case ProcessWaitResult_Status:
1495	/* ignore. */
1496	break;
1497	case ProcessWaitResult_Error:
1498	/* waitFor is dead in the water, I think, so better leave the loop. */
1499	vrc = VERR_CALLBACK_RETURN;
1500	break;
1501
1502	case ProcessWaitResult_StdIn: AssertFailed(); /* did ask for this! */ break;
1503	case ProcessWaitResult_None: AssertFailed(); /* used. */ break;
1504	default: AssertFailed(); /* huh? */ break;
1505	}
1506
1507	if (g_fGuestCtrlCanceled)
1508	break;
1509
1510	/*
1511	* Pump output as needed.
1512	*/
1513	if (fReadStdOut)
1514	{
1515	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1516	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdOut, 1 /* StdOut */, cMsTimeLeft);
1517	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1518	vrc = vrc2;
1519	fReadStdOut = false;
1520	}
1521	if (fReadStdErr)
1522	{
1523	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1524	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdErr, 2 /* StdErr */, cMsTimeLeft);
1525	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1526	vrc = vrc2;
1527	fReadStdErr = false;
1528	}
1529	if ( RT_FAILURE(vrc)
1530	\|\| g_fGuestCtrlCanceled)
1531	break;
1532
1533	/*
1534	* Process events before looping.
1535	*/
1536	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
1537	} /* while */
1538
1539	/*
1540	* Report status back to the user.
1541	*/
1542	if (g_fGuestCtrlCanceled)
1543	{
1544	if (pCtx->cVerbose)
1545	RTPrintf(GuestCtrl::tr("Process execution aborted!\n"));
1546	rcExit = EXITCODEEXEC_CANCELED;
1547	}
1548	else if (fCompletedStartCmd)
1549	{
1550	if (pCtx->cVerbose)
1551	RTPrintf(GuestCtrl::tr("Process successfully started!\n"));
1552	rcExit = RTEXITCODE_SUCCESS;
1553	}
1554	else if (fCompleted)
1555	{
1556	ProcessStatus_T procStatus;
1557	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&procStatus));
1558	if ( procStatus == ProcessStatus_TerminatedNormally
1559	\|\| procStatus == ProcessStatus_TerminatedAbnormally
1560	\|\| procStatus == ProcessStatus_TerminatedSignal)
1561	{
1562	LONG lExitCode;
1563	CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode));
1564	if (pCtx->cVerbose)
1565	RTPrintf(GuestCtrl::tr("Exit code=%u (Status=%u [%s])\n"),
1566	lExitCode, procStatus, gctlProcessStatusToText(procStatus));
1567
1568	rcExit = gctlRunCalculateExitCode(procStatus, lExitCode, true /fReturnExitCodes/);
1569	}
1570	else if ( procStatus == ProcessStatus_TimedOutKilled
1571	\|\| procStatus == ProcessStatus_TimedOutAbnormally)
1572	{
1573	if (pCtx->cVerbose)
1574	RTPrintf(GuestCtrl::tr("Process timed out (guest side) and %s\n"),
1575	procStatus == ProcessStatus_TimedOutAbnormally
1576	? GuestCtrl::tr("failed to terminate so far") : GuestCtrl::tr("was terminated"));
1577	rcExit = EXITCODEEXEC_TIMEOUT;
1578	}
1579	else
1580	{
1581	if (pCtx->cVerbose)
1582	RTPrintf(GuestCtrl::tr("Process now is in status [%s] (unexpected)\n"),
1583	gctlProcessStatusToText(procStatus));
1584	rcExit = RTEXITCODE_FAILURE;
1585	}
1586	}
1587	else if (RT_FAILURE_NP(vrc))
1588	{
1589	if (pCtx->cVerbose)
1590	RTPrintf(GuestCtrl::tr("Process monitor loop quit with vrc=%Rrc\n"), vrc);
1591	rcExit = RTEXITCODE_FAILURE;
1592	}
1593	else
1594	{
1595	if (pCtx->cVerbose)
1596	RTPrintf(GuestCtrl::tr("Process monitor loop timed out\n"));
1597	rcExit = EXITCODEEXEC_TIMEOUT;
1598	}
1599
1600	} while (0);
1601	}
1602	catch (std::bad_alloc &)
1603	{
1604	hrc = E_OUTOFMEMORY;
1605	}
1606
1607	/*
1608	* Decide what to do with the guest session.
1609	*
1610	* If it's the 'start' command where detach the guest process after
1611	* starting, don't close the guest session it is part of, except on
1612	* failure or ctrl-c.
1613	*
1614	* For the 'run' command the guest process quits with us.
1615	*/
1616	if (!fRunCmd && SUCCEEDED(hrc) && !g_fGuestCtrlCanceled)
1617	pCtx->fDetachGuestSession = true;
1618
1619	/* Make sure we return failure on failure. */
1620	if (FAILED(hrc) && rcExit == RTEXITCODE_SUCCESS)
1621	rcExit = RTEXITCODE_FAILURE;
1622	return rcExit;
1623	}
1624
1625
1626	static DECLCALLBACK(RTEXITCODE) gctlHandleRun(PGCTLCMDCTX pCtx, int argc, char **argv)
1627	{
1628	return gctlHandleRunCommon(pCtx, argc, argv, true /fRunCmd/);
1629	}
1630
1631
1632	static DECLCALLBACK(RTEXITCODE) gctlHandleStart(PGCTLCMDCTX pCtx, int argc, char **argv)
1633	{
1634	return gctlHandleRunCommon(pCtx, argc, argv, false /fRunCmd/);
1635	}
1636
1637
1638	static RTEXITCODE gctlHandleCopy(PGCTLCMDCTX pCtx, int argc, char **argv, bool fHostToGuest)
1639	{
1640	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1641
1642	/*
1643	* IGuest::CopyToGuest is kept as simple as possible to let the developer choose
1644	* what and how to implement the file enumeration/recursive lookup, like VBoxManage
1645	* does in here.
1646	*/
1647	static const RTGETOPTDEF s_aOptions[] =
1648	{
1649	GCTLCMD_COMMON_OPTION_DEFS()
1650	{ "--follow", 'L', RTGETOPT_REQ_NOTHING }, /* Kept for backwards-compatibility (VBox < 7.0). */
1651	{ "--dereference", 'L', RTGETOPT_REQ_NOTHING },
1652	{ "--no-replace", 'n', RTGETOPT_REQ_NOTHING }, /* like "-n" via cp. */
1653	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1654	{ "--target-directory", 't', RTGETOPT_REQ_STRING },
1655	{ "--update", 'u', RTGETOPT_REQ_NOTHING } /* like "-u" via cp. */
1656	};
1657
1658	int ch;
1659	RTGETOPTUNION ValueUnion;
1660	RTGETOPTSTATE GetState;
1661	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1662
1663	bool fDstMustBeDir = false;
1664	const char *pszDst = NULL;
1665	bool fFollow = false;
1666	bool fRecursive = false;
1667	bool fUpdate = false; /* Whether to copy the file only if it's newer than the target. */
1668	bool fNoReplace = false; /* Only copy the file if it does not exist yet. */
1669
1670	int vrc = VINF_SUCCESS;
1671	while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
1672	&& ch != VINF_GETOPT_NOT_OPTION)
1673	{
1674	/* For options that require an argument, ValueUnion has received the value. */
1675	switch (ch)
1676	{
1677	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1678
1679	case 'L':
1680	if (!RTStrICmp(ValueUnion.pDef->pszLong, "--follow"))
1681	RTMsgWarning("--follow is deprecated; use --dereference instead.");
1682	fFollow = true;
1683	break;
1684
1685	case 'n':
1686	fNoReplace = true;
1687	break;
1688
1689	case 'R':
1690	fRecursive = true;
1691	break;
1692
1693	case 't':
1694	pszDst = ValueUnion.psz;
1695	fDstMustBeDir = true;
1696	break;
1697
1698	case 'u':
1699	fUpdate = true;
1700	break;
1701
1702	default:
1703	return errorGetOpt(ch, &ValueUnion);
1704	}
1705	}
1706
1707	char **papszSources = RTGetOptNonOptionArrayPtr(&GetState);
1708	size_t cSources = &argv[argc] - papszSources;
1709
1710	if (!cSources)
1711	return errorSyntax(GuestCtrl::tr("No sources specified!"));
1712
1713	/* Unless a --target-directory is given, the last argument is the destination, so
1714	bump it from the source list. */
1715	if (pszDst == NULL && cSources >= 2)
1716	pszDst = papszSources[--cSources];
1717
1718	if (pszDst == NULL)
1719	return errorSyntax(GuestCtrl::tr("No destination specified!"));
1720
1721	char szAbsDst[RTPATH_MAX];
1722	if (!fHostToGuest)
1723	{
1724	vrc = RTPathAbs(pszDst, szAbsDst, sizeof(szAbsDst));
1725	if (RT_SUCCESS(vrc))
1726	pszDst = szAbsDst;
1727	else
1728	return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbs failed on '%s': %Rrc"), pszDst, vrc);
1729	}
1730
1731	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1732	if (rcExit != RTEXITCODE_SUCCESS)
1733	return rcExit;
1734
1735	/*
1736	* Done parsing arguments, do some more preparations.
1737	*/
1738	if (pCtx->cVerbose)
1739	{
1740	if (fHostToGuest)
1741	RTPrintf(GuestCtrl::tr("Copying from host to guest ...\n"));
1742	else
1743	RTPrintf(GuestCtrl::tr("Copying from guest to host ...\n"));
1744	}
1745
1746	HRESULT hrc = S_OK;
1747
1748	com::SafeArray<IN_BSTR> aSources;
1749	com::SafeArray<IN_BSTR> aFilters; /** @todo Populate those? For now we use caller-based globbing. */
1750	com::SafeArray<IN_BSTR> aCopyFlags;
1751
1752	size_t iSrc = 0;
1753	for (; iSrc < cSources; iSrc++)
1754	{
1755	aSources.push_back(Bstr(papszSources[iSrc]).raw());
1756	aFilters.push_back(Bstr("").raw()); /* Empty for now. See @todo above. */
1757
1758	/* Compile the comma-separated list of flags.
1759	* Certain flags are only available for specific file system objects, e.g. directories. */
1760	bool fIsDir = false;
1761	if (fHostToGuest)
1762	{
1763	RTFSOBJINFO ObjInfo;
1764	vrc = RTPathQueryInfo(papszSources[iSrc], &ObjInfo, RTFSOBJATTRADD_NOTHING);
1765	if (RT_SUCCESS(vrc))
1766	fIsDir = RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode);
1767
1768	if (RT_FAILURE(vrc))
1769	break;
1770	}
1771	else /* Guest to host. */
1772	{
1773	ComPtr<IGuestFsObjInfo> pFsObjInfo;
1774	hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(papszSources[iSrc]).raw(), RT_BOOL(fFollow) /* fFollowSymlinks */,
1775	pFsObjInfo.asOutParam());
1776	if (SUCCEEDED(hrc))
1777	{
1778	FsObjType_T enmObjType;
1779	CHECK_ERROR(pFsObjInfo,COMGETTER(Type)(&enmObjType));
1780	if (SUCCEEDED(hrc))
1781	{
1782	/* Take action according to source file. */
1783	fIsDir = enmObjType == FsObjType_Directory;
1784	}
1785	}
1786
1787	if (FAILED(hrc))
1788	{
1789	vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession));
1790	break;
1791	}
1792	}
1793
1794	if (pCtx->cVerbose)
1795	RTPrintf(GuestCtrl::tr("Source '%s' is a %s\n"), papszSources[iSrc], fIsDir ? "directory" : "file");
1796
1797	Utf8Str strCopyFlags;
1798	if (fRecursive && fIsDir) /* Only available for directories. Just ignore otherwise. */
1799	strCopyFlags += "Recursive,";
1800	if (fFollow)
1801	strCopyFlags += "FollowLinks,";
1802	if (fUpdate) /* Only copy source files which are newer than the destination file. */
1803	strCopyFlags += "Update,";
1804	if (fNoReplace) /* Do not overwrite files. */
1805	strCopyFlags += "NoReplace,";
1806	else if (fIsDir)
1807	strCopyFlags += "CopyIntoExisting,"; /* Only copy into existing directories if "--no-replace" isn't specified. */
1808	aCopyFlags.push_back(Bstr(strCopyFlags).raw());
1809	}
1810
1811	if (RT_FAILURE(vrc))
1812	return RTMsgErrorExitFailure(GuestCtrl::tr("Error looking file system information for source '%s', vrc=%Rrc"),
1813	papszSources[iSrc], vrc);
1814
1815	ComPtr<IProgress> pProgress;
1816	if (fHostToGuest)
1817	{
1818	hrc = pCtx->pGuestSession->CopyToGuest(ComSafeArrayAsInParam(aSources),
1819	ComSafeArrayAsInParam(aFilters), ComSafeArrayAsInParam(aCopyFlags),
1820	Bstr(pszDst).raw(), pProgress.asOutParam());
1821	}
1822	else /* Guest to host. */
1823	{
1824	hrc = pCtx->pGuestSession->CopyFromGuest(ComSafeArrayAsInParam(aSources),
1825	ComSafeArrayAsInParam(aFilters), ComSafeArrayAsInParam(aCopyFlags),
1826	Bstr(pszDst).raw(), pProgress.asOutParam());
1827	}
1828
1829	if (FAILED(hrc))
1830	{
1831	vrc = gctlPrintError(pCtx->pGuestSession, COM_IIDOF(IGuestSession));
1832	}
1833	else if (pProgress.isNotNull())
1834	{
1835	if (pCtx->cVerbose)
1836	hrc = showProgress(pProgress);
1837	else
1838	hrc = pProgress->WaitForCompletion(-1 /* No timeout */);
1839	if (SUCCEEDED(hrc))
1840	CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("File copy failed")));
1841	vrc = gctlPrintProgressError(pProgress);
1842	}
1843
1844	if (RT_FAILURE(vrc))
1845	rcExit = RTEXITCODE_FAILURE;
1846
1847	return rcExit;
1848	}
1849
1850	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyFrom(PGCTLCMDCTX pCtx, int argc, char **argv)
1851	{
1852	return gctlHandleCopy(pCtx, argc, argv, false /* Guest to host */);
1853	}
1854
1855	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyTo(PGCTLCMDCTX pCtx, int argc, char **argv)
1856	{
1857	return gctlHandleCopy(pCtx, argc, argv, true /* Host to guest */);
1858	}
1859
1860	static DECLCALLBACK(RTEXITCODE) gctrlHandleMkDir(PGCTLCMDCTX pCtx, int argc, char **argv)
1861	{
1862	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1863
1864	static const RTGETOPTDEF s_aOptions[] =
1865	{
1866	GCTLCMD_COMMON_OPTION_DEFS()
1867	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
1868	{ "--parents", 'P', RTGETOPT_REQ_NOTHING }
1869	};
1870
1871	int ch;
1872	RTGETOPTUNION ValueUnion;
1873	RTGETOPTSTATE GetState;
1874	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1875
1876	SafeArray<DirectoryCreateFlag_T> aDirCreateFlags;
1877	uint32_t fDirMode = 0; /* Default mode. */
1878	uint32_t cDirsCreated = 0;
1879	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1880
1881	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1882	{
1883	/* For options that require an argument, ValueUnion has received the value. */
1884	switch (ch)
1885	{
1886	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1887
1888	case 'm': /* Mode */
1889	fDirMode = ValueUnion.u32;
1890	break;
1891
1892	case 'P': /* Create parents */
1893	aDirCreateFlags.push_back(DirectoryCreateFlag_Parents);
1894	break;
1895
1896	case VINF_GETOPT_NOT_OPTION:
1897	if (cDirsCreated == 0)
1898	{
1899	/*
1900	* First non-option - no more options now.
1901	*/
1902	rcExit = gctlCtxPostOptionParsingInit(pCtx);
1903	if (rcExit != RTEXITCODE_SUCCESS)
1904	return rcExit;
1905	if (pCtx->cVerbose)
1906	RTPrintf(GuestCtrl::tr("Creating %RU32 directories...\n"), argc - GetState.iNext + 1);
1907	}
1908	if (g_fGuestCtrlCanceled)
1909	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("mkdir was interrupted by Ctrl-C (%u left)\n"),
1910	argc - GetState.iNext + 1);
1911
1912	/*
1913	* Create the specified directory.
1914	*
1915	* On failure we'll change the exit status to failure and
1916	* continue with the next directory that needs creating. We do
1917	* this because we only create new things, and because this is
1918	* how /bin/mkdir works on unix.
1919	*/
1920	cDirsCreated++;
1921	if (pCtx->cVerbose)
1922	RTPrintf(GuestCtrl::tr("Creating directory \"%s\" ...\n"), ValueUnion.psz);
1923	try
1924	{
1925	HRESULT hrc;
1926	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(),
1927	fDirMode, ComSafeArrayAsInParam(aDirCreateFlags)));
1928	if (FAILED(hrc))
1929	rcExit = RTEXITCODE_FAILURE;
1930	}
1931	catch (std::bad_alloc &)
1932	{
1933	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
1934	}
1935	break;
1936
1937	default:
1938	return errorGetOpt(ch, &ValueUnion);
1939	}
1940	}
1941
1942	if (!cDirsCreated)
1943	return errorSyntax(GuestCtrl::tr("No directory to create specified!"));
1944	return rcExit;
1945	}
1946
1947
1948	static DECLCALLBACK(RTEXITCODE) gctlHandleRmDir(PGCTLCMDCTX pCtx, int argc, char **argv)
1949	{
1950	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1951
1952	static const RTGETOPTDEF s_aOptions[] =
1953	{
1954	GCTLCMD_COMMON_OPTION_DEFS()
1955	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1956	};
1957
1958	int ch;
1959	RTGETOPTUNION ValueUnion;
1960	RTGETOPTSTATE GetState;
1961	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1962
1963	bool fRecursive = false;
1964	uint32_t cDirRemoved = 0;
1965	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1966
1967	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1968	{
1969	/* For options that require an argument, ValueUnion has received the value. */
1970	switch (ch)
1971	{
1972	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1973
1974	case 'R':
1975	fRecursive = true;
1976	break;
1977
1978	case VINF_GETOPT_NOT_OPTION:
1979	{
1980	if (cDirRemoved == 0)
1981	{
1982	/*
1983	* First non-option - no more options now.
1984	*/
1985	rcExit = gctlCtxPostOptionParsingInit(pCtx);
1986	if (rcExit != RTEXITCODE_SUCCESS)
1987	return rcExit;
1988	if (pCtx->cVerbose)
1989	{
1990	if (fRecursive)
1991	RTPrintf(GuestCtrl::tr("Removing %RU32 directory tree(s)...\n"), argc - GetState.iNext + 1);
1992	else
1993	RTPrintf(GuestCtrl::tr("Removing %RU32 directorie(s)...\n"), argc - GetState.iNext + 1);
1994	}
1995	}
1996	if (g_fGuestCtrlCanceled)
1997	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rmdir was interrupted by Ctrl-C (%u left)\n"),
1998	argc - GetState.iNext + 1);
1999
2000	cDirRemoved++;
2001	HRESULT hrc;
2002	if (!fRecursive)
2003	{
2004	/*
2005	* Remove exactly one directory.
2006	*/
2007	if (pCtx->cVerbose)
2008	RTPrintf(GuestCtrl::tr("Removing directory \"%s\" ...\n"), ValueUnion.psz);
2009	try
2010	{
2011	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemove(Bstr(ValueUnion.psz).raw()));
2012	}
2013	catch (std::bad_alloc &)
2014	{
2015	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
2016	}
2017	}
2018	else
2019	{
2020	/*
2021	* Remove the directory and anything under it, that means files
2022	* and everything. This is in the tradition of the Windows NT
2023	* CMD.EXE "rmdir /s" operation, a tradition which jpsoft's TCC
2024	* strongly warns against (and half-ways questions the sense of).
2025	*/
2026	if (pCtx->cVerbose)
2027	RTPrintf(GuestCtrl::tr("Recursively removing directory \"%s\" ...\n"), ValueUnion.psz);
2028	try
2029	{
2030	/** @todo Make flags configurable. */
2031	com::SafeArray<DirectoryRemoveRecFlag_T> aRemRecFlags;
2032	aRemRecFlags.push_back(DirectoryRemoveRecFlag_ContentAndDir);
2033
2034	ComPtr<IProgress> ptrProgress;
2035	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemoveRecursive(Bstr(ValueUnion.psz).raw(),
2036	ComSafeArrayAsInParam(aRemRecFlags),
2037	ptrProgress.asOutParam()));
2038	if (SUCCEEDED(hrc))
2039	{
2040	if (pCtx->cVerbose)
2041	hrc = showProgress(ptrProgress);
2042	else
2043	hrc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
2044	if (SUCCEEDED(hrc))
2045	CHECK_PROGRESS_ERROR(ptrProgress, (GuestCtrl::tr("Directory deletion failed")));
2046	ptrProgress.setNull();
2047	}
2048	}
2049	catch (std::bad_alloc &)
2050	{
2051	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory during recursive rmdir\n"));
2052	}
2053	}
2054
2055	/*
2056	* This command returns immediately on failure since it's destructive in nature.
2057	*/
2058	if (FAILED(hrc))
2059	return RTEXITCODE_FAILURE;
2060	break;
2061	}
2062
2063	default:
2064	return errorGetOpt(ch, &ValueUnion);
2065	}
2066	}
2067
2068	if (!cDirRemoved)
2069	return errorSyntax(GuestCtrl::tr("No directory to remove specified!"));
2070	return rcExit;
2071	}
2072
2073	static DECLCALLBACK(RTEXITCODE) gctlHandleRm(PGCTLCMDCTX pCtx, int argc, char **argv)
2074	{
2075	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2076
2077	static const RTGETOPTDEF s_aOptions[] =
2078	{
2079	GCTLCMD_COMMON_OPTION_DEFS()
2080	{ "--force", 'f', RTGETOPT_REQ_NOTHING, },
2081	};
2082
2083	int ch;
2084	RTGETOPTUNION ValueUnion;
2085	RTGETOPTSTATE GetState;
2086	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2087
2088	uint32_t cFilesDeleted = 0;
2089	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2090	bool fForce = true;
2091
2092	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2093	{
2094	/* For options that require an argument, ValueUnion has received the value. */
2095	switch (ch)
2096	{
2097	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2098
2099	case VINF_GETOPT_NOT_OPTION:
2100	if (cFilesDeleted == 0)
2101	{
2102	/*
2103	* First non-option - no more options now.
2104	*/
2105	rcExit = gctlCtxPostOptionParsingInit(pCtx);
2106	if (rcExit != RTEXITCODE_SUCCESS)
2107	return rcExit;
2108	if (pCtx->cVerbose)
2109	RTPrintf(GuestCtrl::tr("Removing %RU32 file(s)...\n"), argc - GetState.iNext + 1);
2110	}
2111	if (g_fGuestCtrlCanceled)
2112	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("rm was interrupted by Ctrl-C (%u left)\n"),
2113	argc - GetState.iNext + 1);
2114
2115	/*
2116	* Remove the specified file.
2117	*
2118	* On failure we will by default stop, however, the force option will
2119	* by unix traditions force us to ignore errors and continue.
2120	*/
2121	cFilesDeleted++;
2122	if (pCtx->cVerbose)
2123	RTPrintf(GuestCtrl::tr("Removing file \"%s\" ...\n"), ValueUnion.psz);
2124	try
2125	{
2126	/** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we
2127	* need to do some chmod or whatever to better emulate the --force flag? */
2128	HRESULT hrc;
2129	CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw()));
2130	if (FAILED(hrc) && !fForce)
2131	return RTEXITCODE_FAILURE;
2132	}
2133	catch (std::bad_alloc &)
2134	{
2135	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory\n"));
2136	}
2137	break;
2138
2139	default:
2140	return errorGetOpt(ch, &ValueUnion);
2141	}
2142	}
2143
2144	if (!cFilesDeleted && !fForce)
2145	return errorSyntax(GuestCtrl::tr("No file to remove specified!"));
2146	return rcExit;
2147	}
2148
2149	static DECLCALLBACK(RTEXITCODE) gctlHandleMv(PGCTLCMDCTX pCtx, int argc, char **argv)
2150	{
2151	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2152
2153	static const RTGETOPTDEF s_aOptions[] =
2154	{
2155	GCTLCMD_COMMON_OPTION_DEFS()
2156	/** @todo Missing --force/-f flag. */
2157	};
2158
2159	int ch;
2160	RTGETOPTUNION ValueUnion;
2161	RTGETOPTSTATE GetState;
2162	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2163
2164	int vrc = VINF_SUCCESS;
2165
2166	bool fDryrun = false;
2167	std::vector< Utf8Str > vecSources;
2168	const char *pszDst = NULL;
2169	com::SafeArray<FsObjRenameFlag_T> aRenameFlags;
2170
2171	try
2172	{
2173	/** @todo Make flags configurable. */
2174	aRenameFlags.push_back(FsObjRenameFlag_NoReplace);
2175
2176	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
2177	&& RT_SUCCESS(vrc))
2178	{
2179	/* For options that require an argument, ValueUnion has received the value. */
2180	switch (ch)
2181	{
2182	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2183
2184	/** @todo Implement a --dryrun command. */
2185	/** @todo Implement rename flags. */
2186
2187	case VINF_GETOPT_NOT_OPTION:
2188	vecSources.push_back(Utf8Str(ValueUnion.psz));
2189	pszDst = ValueUnion.psz;
2190	break;
2191
2192	default:
2193	return errorGetOpt(ch, &ValueUnion);
2194	}
2195	}
2196	}
2197	catch (std::bad_alloc &)
2198	{
2199	vrc = VERR_NO_MEMORY;
2200	}
2201
2202	if (RT_FAILURE(vrc))
2203	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Failed to initialize, vrc=%Rrc\n"), vrc);
2204
2205	size_t cSources = vecSources.size();
2206	if (!cSources)
2207	return errorSyntax(GuestCtrl::tr("No source(s) to move specified!"));
2208	if (cSources < 2)
2209	return errorSyntax(GuestCtrl::tr("No destination specified!"));
2210
2211	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2212	if (rcExit != RTEXITCODE_SUCCESS)
2213	return rcExit;
2214
2215	/* Delete last element, which now is the destination. */
2216	vecSources.pop_back();
2217	cSources = vecSources.size();
2218
2219	HRESULT hrc = S_OK;
2220
2221	/* Destination must be a directory when specifying multiple sources. */
2222	if (cSources > 1)
2223	{
2224	ComPtr<IGuestFsObjInfo> pFsObjInfo;
2225	hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(pszDst).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
2226	if (FAILED(hrc))
2227	{
2228	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Destination does not exist\n"));
2229	}
2230	else
2231	{
2232	FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
2233	hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
2234	if (SUCCEEDED(hrc))
2235	{
2236	if (enmObjType != FsObjType_Directory)
2237	return RTMsgErrorExit(RTEXITCODE_FAILURE,
2238	GuestCtrl::tr("Destination must be a directory when specifying multiple sources\n"));
2239	}
2240	else
2241	return RTMsgErrorExit(RTEXITCODE_FAILURE,
2242	GuestCtrl::tr("Unable to determine destination type: %Rhrc\n"),
2243	hrc);
2244	}
2245	}
2246
2247	/*
2248	* Rename (move) the entries.
2249	*/
2250	if (pCtx->cVerbose)
2251	RTPrintf(GuestCtrl::tr("Renaming %RU32 %s ...\n"), cSources,
2252	cSources > 1 ? GuestCtrl::tr("sources", "", cSources) : GuestCtrl::tr("source"));
2253
2254	std::vector< Utf8Str >::iterator it = vecSources.begin();
2255	while ( it != vecSources.end()
2256	&& !g_fGuestCtrlCanceled)
2257	{
2258	Utf8Str strSrcCur = (*it);
2259
2260	ComPtr<IGuestFsObjInfo> pFsObjInfo;
2261	FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
2262	hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strSrcCur).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
2263	if (SUCCEEDED(hrc))
2264	hrc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
2265	if (FAILED(hrc))
2266	{
2267	RTPrintf(GuestCtrl::tr("Cannot stat \"%s\": No such file or directory\n"), strSrcCur.c_str());
2268	++it;
2269	continue; /* Skip. */
2270	}
2271
2272	char *pszDstCur = NULL;
2273
2274	if (cSources > 1)
2275	{
2276	pszDstCur = RTPathJoinA(pszDst, RTPathFilename(strSrcCur.c_str()));
2277	}
2278	else
2279	pszDstCur = RTStrDup(pszDst);
2280
2281	AssertPtrBreakStmt(pszDstCur, hrc = E_OUTOFMEMORY);
2282
2283	if (pCtx->cVerbose)
2284	RTPrintf(GuestCtrl::tr("Renaming %s \"%s\" to \"%s\" ...\n"),
2285	enmObjType == FsObjType_Directory ? GuestCtrl::tr("directory", "object") : GuestCtrl::tr("file","object"),
2286	strSrcCur.c_str(), pszDstCur);
2287
2288	if (!fDryrun)
2289	{
2290	CHECK_ERROR(pCtx->pGuestSession, FsObjRename(Bstr(strSrcCur).raw(),
2291	Bstr(pszDstCur).raw(),
2292	ComSafeArrayAsInParam(aRenameFlags)));
2293	/* Keep going with next item in case of errors. */
2294	}
2295
2296	RTStrFree(pszDstCur);
2297
2298	++it;
2299	}
2300
2301	if ( (it != vecSources.end())
2302	&& pCtx->cVerbose)
2303	{
2304	RTPrintf(GuestCtrl::tr("Warning: Not all sources were renamed\n"));
2305	}
2306
2307	return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
2308	}
2309
2310	static DECLCALLBACK(RTEXITCODE) gctlHandleMkTemp(PGCTLCMDCTX pCtx, int argc, char **argv)
2311	{
2312	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2313
2314	static const RTGETOPTDEF s_aOptions[] =
2315	{
2316	GCTLCMD_COMMON_OPTION_DEFS()
2317	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
2318	{ "--directory", 'D', RTGETOPT_REQ_NOTHING },
2319	{ "--secure", 's', RTGETOPT_REQ_NOTHING },
2320	{ "--tmpdir", 't', RTGETOPT_REQ_STRING }
2321	};
2322
2323	int ch;
2324	RTGETOPTUNION ValueUnion;
2325	RTGETOPTSTATE GetState;
2326	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2327
2328	Utf8Str strTemplate;
2329	uint32_t fMode = 0; /* Default mode. */
2330	bool fDirectory = false;
2331	bool fSecure = false;
2332	Utf8Str strTempDir;
2333
2334	DESTDIRMAP mapDirs;
2335
2336	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2337	{
2338	/* For options that require an argument, ValueUnion has received the value. */
2339	switch (ch)
2340	{
2341	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2342
2343	case 'm': /* Mode */
2344	fMode = ValueUnion.u32;
2345	break;
2346
2347	case 'D': /* Create directory */
2348	fDirectory = true;
2349	break;
2350
2351	case 's': /* Secure */
2352	fSecure = true;
2353	break;
2354
2355	case 't': /* Temp directory */
2356	strTempDir = ValueUnion.psz;
2357	break;
2358
2359	case VINF_GETOPT_NOT_OPTION:
2360	if (strTemplate.isEmpty())
2361	strTemplate = ValueUnion.psz;
2362	else
2363	return errorSyntax(GuestCtrl::tr("More than one template specified!\n"));
2364	break;
2365
2366	default:
2367	return errorGetOpt(ch, &ValueUnion);
2368	}
2369	}
2370
2371	if (strTemplate.isEmpty())
2372	return errorSyntax(GuestCtrl::tr("No template specified!"));
2373
2374	#ifndef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
2375	if (!fDirectory)
2376	return errorSyntax(GuestCtrl::tr("Creating temporary files is currently not supported!"));
2377	#endif
2378
2379	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2380	if (rcExit != RTEXITCODE_SUCCESS)
2381	return rcExit;
2382
2383	/*
2384	* Create the directories.
2385	*/
2386	if (pCtx->cVerbose)
2387	{
2388	if (!strTempDir.isEmpty())
2389	RTPrintf(GuestCtrl::tr("Creating temporary %s from template '%s' in directory '%s' ...\n"),
2390	fDirectory ? GuestCtrl::tr("directory") : GuestCtrl::tr("file"), strTemplate.c_str(), strTempDir.c_str());
2391	else
2392	RTPrintf(GuestCtrl::tr("Creating temporary %s from template '%s' in default temporary directory ...\n"),
2393	fDirectory ? GuestCtrl::tr("directory") : GuestCtrl::tr("file"), strTemplate.c_str());
2394	}
2395
2396	HRESULT hrc = S_OK;
2397	if (fDirectory)
2398	{
2399	Bstr bstrDirectory;
2400	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreateTemp(Bstr(strTemplate).raw(),
2401	fMode, Bstr(strTempDir).raw(),
2402	fSecure,
2403	bstrDirectory.asOutParam()));
2404	if (SUCCEEDED(hrc))
2405	RTPrintf(GuestCtrl::tr("Directory name: %ls\n"), bstrDirectory.raw());
2406	}
2407	else
2408	{
2409	// else - temporary file not yet implemented
2410	/** @todo implement temporary file creation (we fend it off above, no
2411	* worries). */
2412	hrc = E_FAIL;
2413	}
2414
2415	return FAILED(hrc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
2416	}
2417
2418	static DECLCALLBACK(RTEXITCODE) gctlHandleMount(PGCTLCMDCTX pCtx, int argc, char **argv)
2419	{
2420	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2421
2422	static const RTGETOPTDEF s_aOptions[] =
2423	{
2424	GCTLCMD_COMMON_OPTION_DEFS()
2425	};
2426
2427	int ch;
2428	RTGETOPTUNION ValueUnion;
2429	RTGETOPTSTATE GetState;
2430	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2431
2432	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2433	{
2434	/* For options that require an argument, ValueUnion has received the value. */
2435	switch (ch)
2436	{
2437	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2438
2439	default:
2440	return errorGetOpt(ch, &ValueUnion);
2441	}
2442	}
2443
2444	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2445	if (rcExit != RTEXITCODE_SUCCESS)
2446	return rcExit;
2447
2448	HRESULT hrc = S_OK;
2449
2450	com::SafeArray<BSTR> mountPoints;
2451	CHECK_ERROR_RET(pCtx->pGuestSession, COMGETTER(MountPoints)(ComSafeArrayAsOutParam(mountPoints)), RTEXITCODE_FAILURE);
2452
2453	for (size_t i = 0; i < mountPoints.size(); ++i)
2454	RTPrintf("%ls\n", mountPoints[i]);
2455
2456	if (pCtx->cVerbose)
2457	RTPrintf("Found %zu mount points\n", mountPoints.size());
2458
2459	return RTEXITCODE_SUCCESS;
2460	}
2461
2462	static DECLCALLBACK(RTEXITCODE) gctlHandleFsInfo(PGCTLCMDCTX pCtx, int argc, char **argv)
2463	{
2464	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2465
2466	/*
2467	* Parse arguments.
2468	*/
2469	enum GCTLCMD_FSINFO_OPT
2470	{
2471	GCTLCMD_FSINFO_OPT_TOTAL = 1000
2472	};
2473
2474	static const RTGETOPTDEF s_aOptions[] =
2475	{
2476	GCTLCMD_COMMON_OPTION_DEFS()
2477	{ "--human-readable", 'h', RTGETOPT_REQ_NOTHING },
2478	{ "--total", GCTLCMD_FSINFO_OPT_TOTAL, RTGETOPT_REQ_NOTHING }
2479	};
2480
2481	int ch;
2482	RTGETOPTUNION ValueUnion;
2483	RTGETOPTSTATE GetState;
2484	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2485
2486	bool fHumanReadable = false;
2487	bool fShowTotal = false;
2488
2489	while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
2490	&& ch != VINF_GETOPT_NOT_OPTION)
2491	{
2492	/* For options that require an argument, ValueUnion has received the value. */
2493	switch (ch)
2494	{
2495	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2496
2497	case 'h':
2498	fHumanReadable = true;
2499	break;
2500
2501	case GCTLCMD_FSINFO_OPT_TOTAL:
2502	fShowTotal = true;
2503	break;
2504
2505	default:
2506	return errorGetOpt(ch, &ValueUnion);
2507	}
2508	}
2509
2510	if (ch != VINF_GETOPT_NOT_OPTION)
2511	return errorSyntax(GuestCtrl::tr("No path specified to query information for!"));
2512
2513	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2514	if (rcExit != RTEXITCODE_SUCCESS)
2515	return rcExit;
2516
2517	/* Stay within 80 characters width by default. */
2518	unsigned const cwFileSys = 10;
2519	/* When displaying human-readable sizes, we need less space for a column. */
2520	unsigned const cwSize = fHumanReadable ? 10 : 14;
2521	unsigned const cwSizeTotal = cwSize;
2522	unsigned const cwSizeUsed = cwSize;
2523	unsigned const cwSizeAvail = cwSize;
2524	unsigned const cwUsePercent = 6;
2525	unsigned const cwPathSpacing = 3; /* Spacing between last value and actual path. */
2526
2527	RTPrintf("%-s%s%s%s%s%s%s\n",
2528	cwFileSys, GuestCtrl::tr("Filesystem"),
2529	cwSizeTotal, GuestCtrl::tr("Total"), cwSizeUsed, GuestCtrl::tr("Used"), cwSizeAvail, GuestCtrl::tr("Avail"),
2530	cwUsePercent, GuestCtrl::tr("Use%"),
2531	cwPathSpacing, "",
2532	GuestCtrl::tr("Path"));
2533
2534	uint64_t cbTotalSize = 0;
2535	uint64_t cbTotalFree = 0;
2536
2537	while (ch == VINF_GETOPT_NOT_OPTION)
2538	{
2539	ComPtr<IGuestFsInfo> pFsInfo;
2540	HRESULT hrc;
2541	CHECK_ERROR(pCtx->pGuestSession, FsQueryInfo(Bstr(ValueUnion.psz).raw(), pFsInfo.asOutParam()));
2542	if (FAILED(hrc))
2543	{
2544	rcExit = RTEXITCODE_FAILURE;
2545	}
2546	else
2547	{
2548	Bstr bstr;
2549	CHECK_ERROR2I(pFsInfo, COMGETTER(Type)(bstr.asOutParam()));
2550	/** @todo Add label and mount point once we return this. */
2551	LONG64 cbTotal, cbFree;
2552	CHECK_ERROR2I(pFsInfo, COMGETTER(TotalSize)(&cbTotal));
2553	CHECK_ERROR2I(pFsInfo, COMGETTER(FreeSize)(&cbFree));
2554	uint8_t const uPercentUsed = (cbTotal - cbFree) * 100 / cbTotal;
2555	if (fHumanReadable)
2556	{
2557	RTPrintf("%-ls%Rhcb%Rhcb%Rhcb%RU8%%%s%s",
2558	cwFileSys, bstr.raw(), /* Filesystem */
2559	cwSizeTotal, cbTotal, /* Total */
2560	cwSizeUsed, cbTotal - cbFree, /* Used */
2561	cwSizeAvail, cbFree, /* Available */
2562	cwUsePercent - 1 /* For percent sign /, uPercentUsed, / Percent */
2563	cwPathSpacing, "",
2564	ValueUnion.psz); /* Path */
2565	}
2566	else
2567	{
2568	RTPrintf("%-ls%RU64%RU64%RU64%RU8%%%s%s",
2569	cwFileSys, bstr.raw(), /* Filesystem */
2570	cwSizeTotal, cbTotal, /* Total */
2571	cwSizeUsed, cbTotal - cbFree, /* Used */
2572	cwSizeAvail, cbFree, /* Available */
2573	cwUsePercent - 1 /* For percent sign /, uPercentUsed, / Percent */
2574	cwPathSpacing, "",
2575	ValueUnion.psz); /* Path */
2576	}
2577
2578	if (fShowTotal)
2579	{
2580	cbTotalSize += cbTotal;
2581	cbTotalFree += cbFree;
2582	}
2583	RTPrintf("\n");
2584	}
2585
2586	/* Next path. */
2587	ch = RTGetOpt(&GetState, &ValueUnion);
2588	}
2589
2590	if (fShowTotal)
2591	{
2592	uint8_t const uPercentUsed = (cbTotalSize - cbTotalFree) * 100 / cbTotalSize;
2593
2594	if (fHumanReadable)
2595	{
2596	RTPrintf("%-s%Rhcb%Rhcb%Rhcb%RU8%%%s%s",
2597	cwFileSys, "total",
2598	cwSizeTotal, cbTotalSize, /* Total */
2599	cwSizeUsed, cbTotalSize - cbTotalFree, /* Used */
2600	cwSizeAvail, cbTotalFree, /* Available */
2601	cwUsePercent - 1 /* For percent sign /, uPercentUsed, / Percent */
2602	cwPathSpacing, "",
2603	"-"); /* Path */
2604	}
2605	else
2606	{
2607	RTPrintf("%-s%RU64%RU64%RU64%RU8%%%s%s",
2608	cwFileSys, "total", /* Filesystem */
2609	cwSizeTotal, cbTotalSize, /* Total */
2610	cwSizeUsed, cbTotalSize - cbTotalFree, /* Used */
2611	cwSizeAvail, cbTotalFree, /* Available */
2612	cwUsePercent - 1 /* For percent sign /, uPercentUsed, / Percent */
2613	cwPathSpacing, "",
2614	"-"); /* Path */
2615	}
2616	RTPrintf("\n");
2617	}
2618
2619	return rcExit;
2620	}
2621
2622	static DECLCALLBACK(RTEXITCODE) gctlHandleStat(PGCTLCMDCTX pCtx, int argc, char **argv)
2623	{
2624	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2625
2626	static const RTGETOPTDEF s_aOptions[] =
2627	{
2628	GCTLCMD_COMMON_OPTION_DEFS()
2629	{ "--dereference", 'L', RTGETOPT_REQ_NOTHING },
2630	{ "--file-system", 'f', RTGETOPT_REQ_NOTHING },
2631	{ "--format", 'c', RTGETOPT_REQ_STRING },
2632	{ "--terse", 't', RTGETOPT_REQ_NOTHING }
2633	};
2634
2635	int ch;
2636	RTGETOPTUNION ValueUnion;
2637	RTGETOPTSTATE GetState;
2638	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2639
2640	while ( (ch = RTGetOpt(&GetState, &ValueUnion)) != 0
2641	&& ch != VINF_GETOPT_NOT_OPTION)
2642	{
2643	/* For options that require an argument, ValueUnion has received the value. */
2644	switch (ch)
2645	{
2646	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2647
2648	case 'L': /* Dereference */
2649	case 'f': /* File-system */
2650	case 'c': /* Format */
2651	case 't': /* Terse */
2652	return errorSyntax(GuestCtrl::tr("Command \"%s\" not implemented yet!"), ValueUnion.psz);
2653
2654	default:
2655	return errorGetOpt(ch, &ValueUnion);
2656	}
2657	}
2658
2659	if (ch != VINF_GETOPT_NOT_OPTION)
2660	return errorSyntax(GuestCtrl::tr("Nothing to stat!"));
2661
2662	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2663	if (rcExit != RTEXITCODE_SUCCESS)
2664	return rcExit;
2665
2666
2667	/*
2668	* Do the file stat'ing.
2669	*/
2670	while (ch == VINF_GETOPT_NOT_OPTION)
2671	{
2672	if (pCtx->cVerbose)
2673	RTPrintf(GuestCtrl::tr("Checking for element \"%s\" ...\n"), ValueUnion.psz);
2674
2675	ComPtr<IGuestFsObjInfo> pFsObjInfo;
2676	HRESULT hrc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(ValueUnion.psz).raw(), FALSE /followSymlinks/,
2677	pFsObjInfo.asOutParam());
2678	if (FAILED(hrc))
2679	{
2680	/** @todo r=bird: There might be other reasons why we end up here than
2681	* non-existing "element" (object or file, please, nobody calls it elements). */
2682	if (pCtx->cVerbose)
2683	RTPrintf(GuestCtrl::tr("Failed to stat '%s': No such file\n"), ValueUnion.psz);
2684	rcExit = RTEXITCODE_FAILURE;
2685	}
2686	else
2687	{
2688	RTPrintf(GuestCtrl::tr(" File: '%s'\n"), ValueUnion.psz); /** @todo escape this name. */
2689
2690	FsObjType_T enmType = FsObjType_Unknown;
2691	CHECK_ERROR2I(pFsObjInfo, COMGETTER(Type)(&enmType));
2692	LONG64 cbObject = 0;
2693	CHECK_ERROR2I(pFsObjInfo, COMGETTER(ObjectSize)(&cbObject));
2694	LONG64 cbAllocated = 0;
2695	CHECK_ERROR2I(pFsObjInfo, COMGETTER(AllocatedSize)(&cbAllocated));
2696	LONG uid = 0;
2697	CHECK_ERROR2I(pFsObjInfo, COMGETTER(UID)(&uid));
2698	LONG gid = 0;
2699	CHECK_ERROR2I(pFsObjInfo, COMGETTER(GID)(&gid));
2700	Bstr bstrUsername;
2701	CHECK_ERROR2I(pFsObjInfo, COMGETTER(UserName)(bstrUsername.asOutParam()));
2702	Bstr bstrGroupName;
2703	CHECK_ERROR2I(pFsObjInfo, COMGETTER(GroupName)(bstrGroupName.asOutParam()));
2704	Bstr bstrAttribs;
2705	CHECK_ERROR2I(pFsObjInfo, COMGETTER(FileAttributes)(bstrAttribs.asOutParam()));
2706	LONG64 idNode = 0;
2707	CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeId)(&idNode));
2708	ULONG uDevNode = 0;
2709	CHECK_ERROR2I(pFsObjInfo, COMGETTER(NodeIdDevice)(&uDevNode));
2710	ULONG uDeviceNo = 0;
2711	CHECK_ERROR2I(pFsObjInfo, COMGETTER(DeviceNumber)(&uDeviceNo));
2712	ULONG cHardLinks = 1;
2713	CHECK_ERROR2I(pFsObjInfo, COMGETTER(HardLinks)(&cHardLinks));
2714	LONG64 nsBirthTime = 0;
2715	CHECK_ERROR2I(pFsObjInfo, COMGETTER(BirthTime)(&nsBirthTime));
2716	LONG64 nsChangeTime = 0;
2717	CHECK_ERROR2I(pFsObjInfo, COMGETTER(ChangeTime)(&nsChangeTime));
2718	LONG64 nsModificationTime = 0;
2719	CHECK_ERROR2I(pFsObjInfo, COMGETTER(ModificationTime)(&nsModificationTime));
2720	LONG64 nsAccessTime = 0;
2721	CHECK_ERROR2I(pFsObjInfo, COMGETTER(AccessTime)(&nsAccessTime));
2722
2723	RTPrintf(GuestCtrl::tr(" Size: %-17RU64 Alloc: %-19RU64 Type: %s\n"),
2724	cbObject, cbAllocated, gctlFsObjTypeToName(enmType));
2725	RTPrintf(GuestCtrl::tr("Device: %#-17RX32 INode: %-18RU64 Links: %u\n"), uDevNode, idNode, cHardLinks);
2726
2727	Utf8Str strAttrib(bstrAttribs);
2728	char *pszMode = strAttrib.mutableRaw();
2729	char *pszAttribs = strchr(pszMode, ' ');
2730	if (pszAttribs)
2731	do *pszAttribs++ = '\0';
2732	while (*pszAttribs == ' ');
2733	else
2734	pszAttribs = strchr(pszMode, '\0');
2735	if (uDeviceNo != 0)
2736	RTPrintf(GuestCtrl::tr(" Mode: %-16s Attrib: %-17s Dev ID: %#RX32\n"), pszMode, pszAttribs, uDeviceNo);
2737	else
2738	RTPrintf(GuestCtrl::tr(" Mode: %-16s Attrib: %s\n"), pszMode, pszAttribs);
2739
2740	RTPrintf(GuestCtrl::tr(" Owner: %4d/%-12ls Group: %4d/%ls\n"), uid, bstrUsername.raw(), gid, bstrGroupName.raw());
2741
2742	RTTIMESPEC TimeSpec;
2743	char szTmp[RTTIME_STR_LEN];
2744	RTPrintf(GuestCtrl::tr(" Birth: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsBirthTime),
2745	szTmp, sizeof(szTmp)));
2746	RTPrintf(GuestCtrl::tr("Change: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsChangeTime),
2747	szTmp, sizeof(szTmp)));
2748	RTPrintf(GuestCtrl::tr("Modify: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsModificationTime),
2749	szTmp, sizeof(szTmp)));
2750	RTPrintf(GuestCtrl::tr("Access: %s\n"), RTTimeSpecToString(RTTimeSpecSetNano(&TimeSpec, nsAccessTime),
2751	szTmp, sizeof(szTmp)));
2752
2753	/* Skiping: Generation ID - only the ISO9660 VFS sets this. FreeBSD user flags. */
2754	}
2755
2756	/* Next file. */
2757	ch = RTGetOpt(&GetState, &ValueUnion);
2758	}
2759
2760	return rcExit;
2761	}
2762
2763	/**
2764	* Waits for a Guest Additions run level being reached.
2765	*
2766	* @returns VBox status code.
2767	* Returns VERR_CANCELLED if waiting for cancelled due to signal handling, e.g. when CTRL+C or some sort was pressed.
2768	* @param pCtx The guest control command context.
2769	* @param enmRunLevel Run level to wait for.
2770	* @param cMsTimeout Timeout (in ms) for waiting.
2771	*/
2772	static int gctlWaitForRunLevel(PGCTLCMDCTX pCtx, AdditionsRunLevelType_T enmRunLevel, RTMSINTERVAL cMsTimeout)
2773	{
2774	int vrc = VINF_SUCCESS; /* Shut up MSVC. */
2775
2776	try
2777	{
2778	HRESULT hrc = S_OK;
2779	/** Whether we need to actually wait for the run level or if we already reached it. */
2780	bool fWait = false;
2781
2782	/* Install an event handler first to catch any runlevel changes. */
2783	ComObjPtr<GuestAdditionsRunlevelListenerImpl> pGuestListener;
2784	do
2785	{
2786	/* Listener creation. */
2787	pGuestListener.createObject();
2788	pGuestListener->init(new GuestAdditionsRunlevelListener(enmRunLevel));
2789
2790	/* Register for IGuest events. */
2791	ComPtr<IEventSource> es;
2792	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
2793	com::SafeArray<VBoxEventType_T> eventTypes;
2794	eventTypes.push_back(VBoxEventType_OnGuestAdditionsStatusChanged);
2795	CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
2796	true /* Active listener */));
2797
2798	AdditionsRunLevelType_T enmRunLevelCur = AdditionsRunLevelType_None;
2799	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(AdditionsRunLevel)(&enmRunLevelCur));
2800	fWait = enmRunLevelCur != enmRunLevel;
2801
2802	if (pCtx->cVerbose)
2803	RTPrintf(GuestCtrl::tr("Current run level is %RU32\n"), enmRunLevelCur);
2804
2805	} while (0);
2806
2807	if (fWait)
2808	{
2809	if (pCtx->cVerbose)
2810	RTPrintf(GuestCtrl::tr("Waiting for run level %RU32 ...\n"), enmRunLevel);
2811
2812	RTMSINTERVAL tsStart = RTTimeMilliTS();
2813	while (RTTimeMilliTS() - tsStart < cMsTimeout)
2814	{
2815	/* Wait for the global signal semaphore getting signalled. */
2816	vrc = RTSemEventWait(g_SemEventGuestCtrlCanceled, 100 /* ms */);
2817	if (RT_FAILURE(vrc))
2818	{
2819	if (vrc == VERR_TIMEOUT)
2820	continue;
2821	else
2822	{
2823	RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
2824	break;
2825	}
2826	}
2827	else if (pCtx->cVerbose)
2828	{
2829	RTPrintf(GuestCtrl::tr("Run level %RU32 reached\n"), enmRunLevel);
2830	break;
2831	}
2832
2833	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
2834	}
2835
2836	if ( vrc == VERR_TIMEOUT
2837	&& pCtx->cVerbose)
2838	RTPrintf(GuestCtrl::tr("Run level %RU32 not reached within time\n"), enmRunLevel);
2839	}
2840
2841	if (!pGuestListener.isNull())
2842	{
2843	/* Guest callback unregistration. */
2844	ComPtr<IEventSource> pES;
2845	CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
2846	if (!pES.isNull())
2847	CHECK_ERROR(pES, UnregisterListener(pGuestListener));
2848	pGuestListener.setNull();
2849	}
2850
2851	if (g_fGuestCtrlCanceled)
2852	vrc = VERR_CANCELLED;
2853	}
2854	catch (std::bad_alloc &)
2855	{
2856	vrc = VERR_NO_MEMORY;
2857	}
2858
2859	return vrc;
2860	}
2861
2862	static DECLCALLBACK(RTEXITCODE) gctlHandleUpdateAdditions(PGCTLCMDCTX pCtx, int argc, char **argv)
2863	{
2864	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2865
2866	/** Timeout to wait for the whole updating procedure to complete. */
2867	uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
2868	/** Source path to .ISO Guest Additions file to use. */
2869	Utf8Str strSource;
2870	com::SafeArray<IN_BSTR> aArgs;
2871	/** Whether to reboot the guest automatically when the update process has finished successfully. */
2872	bool fRebootOnFinish = false;
2873	/** Whether to only wait for getting the update process started instead of waiting until it finishes. */
2874	bool fWaitStartOnly = false;
2875	/** Whether to wait for the VM being ready to start the update. Needs Guest Additions facility reporting. */
2876	bool fWaitReady = false;
2877	/** Whether to verify if the Guest Additions were successfully updated on the guest. */
2878	bool fVerify = false;
2879
2880	/*
2881	* Parse arguments.
2882	*/
2883	enum KGSTCTRLUPDATEADDITIONSOPT
2884	{
2885	KGSTCTRLUPDATEADDITIONSOPT_REBOOT = 1000,
2886	KGSTCTRLUPDATEADDITIONSOPT_SOURCE,
2887	KGSTCTRLUPDATEADDITIONSOPT_TIMEOUT,
2888	KGSTCTRLUPDATEADDITIONSOPT_VERIFY,
2889	KGSTCTRLUPDATEADDITIONSOPT_WAITREADY,
2890	KGSTCTRLUPDATEADDITIONSOPT_WAITSTART
2891	};
2892
2893	static const RTGETOPTDEF s_aOptions[] =
2894	{
2895	GCTLCMD_COMMON_OPTION_DEFS()
2896	{ "--reboot", KGSTCTRLUPDATEADDITIONSOPT_REBOOT, RTGETOPT_REQ_NOTHING },
2897	{ "--source", KGSTCTRLUPDATEADDITIONSOPT_SOURCE, RTGETOPT_REQ_STRING },
2898	{ "--timeout", KGSTCTRLUPDATEADDITIONSOPT_TIMEOUT, RTGETOPT_REQ_UINT32 },
2899	{ "--verify", KGSTCTRLUPDATEADDITIONSOPT_VERIFY, RTGETOPT_REQ_NOTHING },
2900	{ "--wait-ready", KGSTCTRLUPDATEADDITIONSOPT_WAITREADY, RTGETOPT_REQ_NOTHING },
2901	{ "--wait-start", KGSTCTRLUPDATEADDITIONSOPT_WAITSTART, RTGETOPT_REQ_NOTHING }
2902	};
2903
2904	int ch;
2905	RTGETOPTUNION ValueUnion;
2906	RTGETOPTSTATE GetState;
2907	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2908
2909	int vrc = VINF_SUCCESS;
2910	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
2911	&& RT_SUCCESS(vrc))
2912	{
2913	switch (ch)
2914	{
2915	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2916
2917	case KGSTCTRLUPDATEADDITIONSOPT_REBOOT:
2918	fRebootOnFinish = true;
2919	break;
2920
2921	case KGSTCTRLUPDATEADDITIONSOPT_SOURCE:
2922	vrc = RTPathAbsCxx(strSource, ValueUnion.psz);
2923	if (RT_FAILURE(vrc))
2924	return RTMsgErrorExitFailure(GuestCtrl::tr("RTPathAbsCxx failed on '%s': %Rrc"), ValueUnion.psz, vrc);
2925	break;
2926
2927	case KGSTCTRLUPDATEADDITIONSOPT_WAITSTART:
2928	fWaitStartOnly = true;
2929	break;
2930
2931	case KGSTCTRLUPDATEADDITIONSOPT_WAITREADY:
2932	fWaitReady = true;
2933	break;
2934
2935	case KGSTCTRLUPDATEADDITIONSOPT_VERIFY:
2936	fVerify = true;
2937	fRebootOnFinish = true; /* Verification needs a mandatory reboot after successful update. */
2938	break;
2939
2940	case VINF_GETOPT_NOT_OPTION:
2941	if (aArgs.size() == 0 && strSource.isEmpty())
2942	strSource = ValueUnion.psz;
2943	else
2944	aArgs.push_back(Bstr(ValueUnion.psz).raw());
2945	break;
2946
2947	default:
2948	return errorGetOpt(ch, &ValueUnion);
2949	}
2950	}
2951
2952	if (pCtx->cVerbose)
2953	RTPrintf(GuestCtrl::tr("Updating Guest Additions ...\n"));
2954
2955	HRESULT hrc = S_OK;
2956	while (strSource.isEmpty())
2957	{
2958	ComPtr<ISystemProperties> pProperties;
2959	CHECK_ERROR_BREAK(pCtx->pArg->virtualBox, COMGETTER(SystemProperties)(pProperties.asOutParam()));
2960	Bstr strISO;
2961	CHECK_ERROR_BREAK(pProperties, COMGETTER(DefaultAdditionsISO)(strISO.asOutParam()));
2962	strSource = strISO;
2963	break;
2964	}
2965
2966	/* Determine source if not set yet. */
2967	if (strSource.isEmpty())
2968	{
2969	RTMsgError(GuestCtrl::tr("No Guest Additions source found or specified, aborting\n"));
2970	vrc = VERR_FILE_NOT_FOUND;
2971	}
2972	else if (!RTFileExists(strSource.c_str()))
2973	{
2974	RTMsgError(GuestCtrl::tr("Source \"%s\" does not exist!\n"), strSource.c_str());
2975	vrc = VERR_FILE_NOT_FOUND;
2976	}
2977
2978
2979
2980	#if 0
2981	ComPtr<IGuest> guest;
2982	HRESULT hrc = pConsole->COMGETTER(Guest)(guest.asOutParam());
2983	if (SUCCEEDED(hrc) && !guest.isNull())
2984	{
2985	SHOW_STRING_PROP_NOT_EMPTY(guest, OSTypeId, "GuestOSType", GuestCtrl::tr("OS type:"));
2986
2987	AdditionsRunLevelType_T guestRunLevel; /** @todo Add a runlevel-to-string (e.g. 0 = "None") method? */
2988	hrc = guest->COMGETTER(AdditionsRunLevel)(&guestRunLevel);
2989	if (SUCCEEDED(hrc))
2990	SHOW_ULONG_VALUE("GuestAdditionsRunLevel", GuestCtrl::tr("Additions run level:"), (ULONG)guestRunLevel, "");
2991
2992	Bstr guestString;
2993	hrc = guest->COMGETTER(AdditionsVersion)(guestString.asOutParam());
2994	if ( SUCCEEDED(hrc)
2995	&& !guestString.isEmpty())
2996	{
2997	ULONG uRevision;
2998	hrc = guest->COMGETTER(AdditionsRevision)(&uRevision);
2999	if (FAILED(hrc))
3000	uRevision = 0;
3001	RTStrPrintf(szValue, sizeof(szValue), "%ls r%u", guestString.raw(), uRevision);
3002	SHOW_UTF8_STRING("GuestAdditionsVersion", GuestCtrl::tr("Additions version:"), szValue);
3003	}
3004	}
3005	#endif
3006
3007	if (RT_SUCCESS(vrc))
3008	{
3009	if (pCtx->cVerbose)
3010	RTPrintf(GuestCtrl::tr("Using source: %s\n"), strSource.c_str());
3011
3012	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3013	if (rcExit != RTEXITCODE_SUCCESS)
3014	return rcExit;
3015
3016	if (fWaitReady)
3017	{
3018	if (pCtx->cVerbose)
3019	RTPrintf(GuestCtrl::tr("Waiting for current Guest Additions inside VM getting ready for updating ...\n"));
3020
3021	const uint64_t uTsStart = RTTimeMilliTS();
3022	vrc = gctlWaitForRunLevel(pCtx, AdditionsRunLevelType_Userland, cMsTimeout);
3023	if (RT_SUCCESS(vrc))
3024	cMsTimeout = cMsTimeout != RT_INDEFINITE_WAIT ? cMsTimeout - (RTTimeMilliTS() - uTsStart) : cMsTimeout;
3025	}
3026
3027	if (RT_SUCCESS(vrc))
3028	{
3029	/* Get current Guest Additions version / revision. */
3030	Bstr strGstVerCur;
3031	ULONG uGstRevCur = 0;
3032	hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerCur.asOutParam());
3033	if ( SUCCEEDED(hrc)
3034	&& !strGstVerCur.isEmpty())
3035	{
3036	hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevCur);
3037	if (SUCCEEDED(hrc))
3038	{
3039	if (pCtx->cVerbose)
3040	RTPrintf(GuestCtrl::tr("Guest Additions %lsr%RU64 currently installed, waiting for Guest Additions installer to start ...\n"),
3041	strGstVerCur.raw(), uGstRevCur);
3042	}
3043	}
3044
3045	com::SafeArray<AdditionsUpdateFlag_T> aUpdateFlags;
3046	if (fWaitStartOnly)
3047	aUpdateFlags.push_back(AdditionsUpdateFlag_WaitForUpdateStartOnly);
3048
3049	ComPtr<IProgress> pProgress;
3050	CHECK_ERROR(pCtx->pGuest, UpdateGuestAdditions(Bstr(strSource).raw(),
3051	ComSafeArrayAsInParam(aArgs),
3052	ComSafeArrayAsInParam(aUpdateFlags),
3053	pProgress.asOutParam()));
3054	if (FAILED(hrc))
3055	vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3056	else
3057	{
3058	if (pCtx->cVerbose)
3059	hrc = showProgress(pProgress);
3060	else
3061	hrc = pProgress->WaitForCompletion((int32_t)cMsTimeout);
3062
3063	if (SUCCEEDED(hrc))
3064	CHECK_PROGRESS_ERROR(pProgress, (GuestCtrl::tr("Guest Additions update failed")));
3065	vrc = gctlPrintProgressError(pProgress);
3066	if (RT_SUCCESS(vrc))
3067	{
3068	if (pCtx->cVerbose)
3069	RTPrintf(GuestCtrl::tr("Guest Additions update successful.\n"));
3070
3071	if (fRebootOnFinish)
3072	{
3073	if (pCtx->cVerbose)
3074	RTPrintf(GuestCtrl::tr("Rebooting guest ...\n"));
3075	com::SafeArray<GuestShutdownFlag_T> aShutdownFlags;
3076	aShutdownFlags.push_back(GuestShutdownFlag_Reboot);
3077	CHECK_ERROR(pCtx->pGuest, Shutdown(ComSafeArrayAsInParam(aShutdownFlags)));
3078	if (FAILED(hrc))
3079	{
3080	if (hrc == VBOX_E_NOT_SUPPORTED)
3081	{
3082	RTPrintf(GuestCtrl::tr("Current installed Guest Additions don't support automatic rebooting. "
3083	"Please reboot manually.\n"));
3084	vrc = VERR_NOT_SUPPORTED;
3085	}
3086	else
3087	vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3088	}
3089	else
3090	{
3091	if (fWaitReady)
3092	{
3093	if (pCtx->cVerbose)
3094	RTPrintf(GuestCtrl::tr("Waiting for new Guest Additions inside VM getting ready ...\n"));
3095
3096	vrc = gctlWaitForRunLevel(pCtx, AdditionsRunLevelType_Userland, cMsTimeout);
3097	if (RT_SUCCESS(vrc))
3098	{
3099	if (fVerify)
3100	{
3101	if (pCtx->cVerbose)
3102	RTPrintf(GuestCtrl::tr("Verifying Guest Additions update ...\n"));
3103
3104	/* Get new Guest Additions version / revision. */
3105	Bstr strGstVerNew;
3106	ULONG uGstRevNew = 0;
3107	hrc = pCtx->pGuest->COMGETTER(AdditionsVersion)(strGstVerNew.asOutParam());
3108	if ( SUCCEEDED(hrc)
3109	&& !strGstVerNew.isEmpty())
3110	{
3111	hrc = pCtx->pGuest->COMGETTER(AdditionsRevision)(&uGstRevNew);
3112	if (FAILED(hrc))
3113	uGstRevNew = 0;
3114	}
3115
3116	/** @todo Do more verification here. */
3117	vrc = uGstRevNew > uGstRevCur ? VINF_SUCCESS : VERR_NO_CHANGE;
3118
3119	if (pCtx->cVerbose)
3120	{
3121	RTPrintf(GuestCtrl::tr("Old Guest Additions: %ls%RU64\n"), strGstVerCur.raw(),
3122	uGstRevCur);
3123	RTPrintf(GuestCtrl::tr("New Guest Additions: %ls%RU64\n"), strGstVerNew.raw(),
3124	uGstRevNew);
3125
3126	if (RT_FAILURE(vrc))
3127	{
3128	RTPrintf(GuestCtrl::tr("\nError updating Guest Additions, please check guest installer log\n"));
3129	}
3130	else
3131	{
3132	if (uGstRevNew < uGstRevCur)
3133	RTPrintf(GuestCtrl::tr("\nWARNING: Guest Additions were downgraded\n"));
3134	}
3135	}
3136	}
3137	}
3138	}
3139	else if (pCtx->cVerbose)
3140	RTPrintf(GuestCtrl::tr("The guest needs to be restarted in order to make use of the updated Guest Additions.\n"));
3141	}
3142	}
3143	}
3144	}
3145	}
3146	}
3147
3148	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3149	}
3150
3151	/**
3152	* Returns a Guest Additions run level from a string.
3153	*
3154	* @returns Run level if found, or AdditionsRunLevelType_None if not found / invalid.
3155	* @param pcszStr String to return run level for.
3156	*/
3157	static AdditionsRunLevelType_T gctlGetRunLevelFromStr(const char *pcszStr)
3158	{
3159	AssertPtrReturn(pcszStr, AdditionsRunLevelType_None);
3160
3161	if (RTStrICmp(pcszStr, "system") == 0) return AdditionsRunLevelType_System;
3162	else if (RTStrICmp(pcszStr, "userland") == 0) return AdditionsRunLevelType_Userland;
3163	else if (RTStrICmp(pcszStr, "desktop") == 0) return AdditionsRunLevelType_Desktop;
3164
3165	return AdditionsRunLevelType_None;
3166	}
3167
3168	static DECLCALLBACK(RTEXITCODE) gctlHandleWaitRunLevel(PGCTLCMDCTX pCtx, int argc, char **argv)
3169	{
3170	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3171
3172	/** Timeout to wait for run level being reached.
3173	* By default we wait until it's reached. */
3174	uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
3175
3176	/*
3177	* Parse arguments.
3178	*/
3179	enum KGSTCTRLWAITRUNLEVELOPT
3180	{
3181	KGSTCTRLWAITRUNLEVELOPT_TIMEOUT = 1000
3182	};
3183
3184	static const RTGETOPTDEF s_aOptions[] =
3185	{
3186	GCTLCMD_COMMON_OPTION_DEFS()
3187	{ "--timeout", KGSTCTRLWAITRUNLEVELOPT_TIMEOUT, RTGETOPT_REQ_UINT32 }
3188	};
3189
3190	int ch;
3191	RTGETOPTUNION ValueUnion;
3192	RTGETOPTSTATE GetState;
3193	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3194
3195	AdditionsRunLevelType_T enmRunLevel = AdditionsRunLevelType_None;
3196
3197	int vrc = VINF_SUCCESS;
3198	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3199	&& RT_SUCCESS(vrc))
3200	{
3201	switch (ch)
3202	{
3203	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3204
3205	case KGSTCTRLWAITRUNLEVELOPT_TIMEOUT:
3206	cMsTimeout = ValueUnion.u32;
3207	break;
3208
3209	case VINF_GETOPT_NOT_OPTION:
3210	{
3211	enmRunLevel = gctlGetRunLevelFromStr(ValueUnion.psz);
3212	if (enmRunLevel == AdditionsRunLevelType_None)
3213	return errorSyntax(GuestCtrl::tr("Invalid run level specified. Valid values are: system, userland, desktop"));
3214	break;
3215	}
3216
3217	default:
3218	return errorGetOpt(ch, &ValueUnion);
3219	}
3220	}
3221
3222	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3223	if (rcExit != RTEXITCODE_SUCCESS)
3224	return rcExit;
3225
3226	if (enmRunLevel == AdditionsRunLevelType_None)
3227	return errorSyntax(GuestCtrl::tr("Missing run level to wait for"));
3228
3229	vrc = gctlWaitForRunLevel(pCtx, enmRunLevel, cMsTimeout);
3230
3231	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3232	}
3233
3234	static DECLCALLBACK(RTEXITCODE) gctlHandleList(PGCTLCMDCTX pCtx, int argc, char **argv)
3235	{
3236	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3237
3238	static const RTGETOPTDEF s_aOptions[] =
3239	{
3240	GCTLCMD_COMMON_OPTION_DEFS()
3241	};
3242
3243	int ch;
3244	RTGETOPTUNION ValueUnion;
3245	RTGETOPTSTATE GetState;
3246	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3247
3248	bool fSeenListArg = false;
3249	bool fListAll = false;
3250	bool fListSessions = false;
3251	bool fListProcesses = false;
3252	bool fListFiles = false;
3253
3254	int vrc = VINF_SUCCESS;
3255	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3256	&& RT_SUCCESS(vrc))
3257	{
3258	switch (ch)
3259	{
3260	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3261
3262	case VINF_GETOPT_NOT_OPTION:
3263	if ( !RTStrICmp(ValueUnion.psz, "sessions")
3264	\|\| !RTStrICmp(ValueUnion.psz, "sess"))
3265	fListSessions = true;
3266	else if ( !RTStrICmp(ValueUnion.psz, "processes")
3267	\|\| !RTStrICmp(ValueUnion.psz, "procs"))
3268	fListSessions = fListProcesses = true; /* Showing processes implies showing sessions. */
3269	else if (!RTStrICmp(ValueUnion.psz, "files"))
3270	fListSessions = fListFiles = true; /* Showing files implies showing sessions. */
3271	else if (!RTStrICmp(ValueUnion.psz, "all"))
3272	fListAll = true;
3273	else
3274	return errorSyntax(GuestCtrl::tr("Unknown list: '%s'"), ValueUnion.psz);
3275	fSeenListArg = true;
3276	break;
3277
3278	default:
3279	return errorGetOpt(ch, &ValueUnion);
3280	}
3281	}
3282
3283	if (!fSeenListArg)
3284	return errorSyntax(GuestCtrl::tr("Missing list name"));
3285	Assert(fListAll \|\| fListSessions);
3286
3287	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3288	if (rcExit != RTEXITCODE_SUCCESS)
3289	return rcExit;
3290
3291
3292	/** @todo Do we need a machine-readable output here as well? */
3293
3294	HRESULT hrc;
3295	size_t cTotalProcs = 0;
3296	size_t cTotalFiles = 0;
3297
3298	SafeIfaceArray <IGuestSession> collSessions;
3299	CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3300	if (SUCCEEDED(hrc))
3301	{
3302	size_t const cSessions = collSessions.size();
3303	if (cSessions)
3304	{
3305	RTPrintf(GuestCtrl::tr("Active guest sessions:\n"));
3306
3307	/** @todo Make this output a bit prettier. No time now. */
3308
3309	for (size_t i = 0; i < cSessions; i++)
3310	{
3311	ComPtr<IGuestSession> pCurSession = collSessions[i];
3312	if (!pCurSession.isNull())
3313	{
3314	do
3315	{
3316	ULONG uID;
3317	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Id)(&uID));
3318	Bstr strName;
3319	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Name)(strName.asOutParam()));
3320	Bstr strUser;
3321	CHECK_ERROR_BREAK(pCurSession, COMGETTER(User)(strUser.asOutParam()));
3322	GuestSessionStatus_T sessionStatus;
3323	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus));
3324	RTPrintf(GuestCtrl::tr("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls"),
3325	i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw());
3326	} while (0);
3327
3328	if ( fListAll
3329	\|\| fListProcesses)
3330	{
3331	SafeIfaceArray <IGuestProcess> collProcesses;
3332	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcesses)));
3333	for (size_t a = 0; a < collProcesses.size(); a++)
3334	{
3335	ComPtr<IGuestProcess> pCurProcess = collProcesses[a];
3336	if (!pCurProcess.isNull())
3337	{
3338	do
3339	{
3340	ULONG uPID;
3341	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(PID)(&uPID));
3342	Bstr strExecPath;
3343	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(ExecutablePath)(strExecPath.asOutParam()));
3344	ProcessStatus_T procStatus;
3345	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus));
3346
3347	RTPrintf(GuestCtrl::tr("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls"),
3348	a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw());
3349	} while (0);
3350	}
3351	}
3352
3353	cTotalProcs += collProcesses.size();
3354	}
3355
3356	if ( fListAll
3357	\|\| fListFiles)
3358	{
3359	SafeIfaceArray <IGuestFile> collFiles;
3360	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Files)(ComSafeArrayAsOutParam(collFiles)));
3361	for (size_t a = 0; a < collFiles.size(); a++)
3362	{
3363	ComPtr<IGuestFile> pCurFile = collFiles[a];
3364	if (!pCurFile.isNull())
3365	{
3366	do
3367	{
3368	ULONG idFile;
3369	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Id)(&idFile));
3370	Bstr strName;
3371	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Filename)(strName.asOutParam()));
3372	FileStatus_T fileStatus;
3373	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus));
3374
3375	RTPrintf(GuestCtrl::tr("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls"),
3376	a, idFile, gctlFileStatusToText(fileStatus), strName.raw());
3377	} while (0);
3378	}
3379	}
3380
3381	cTotalFiles += collFiles.size();
3382	}
3383	}
3384	}
3385
3386	RTPrintf(GuestCtrl::tr("\n\nTotal guest sessions: %zu\n"), collSessions.size());
3387	if (fListAll \|\| fListProcesses)
3388	RTPrintf(GuestCtrl::tr("Total guest processes: %zu\n"), cTotalProcs);
3389	if (fListAll \|\| fListFiles)
3390	RTPrintf(GuestCtrl::tr("Total guest files: %zu\n"), cTotalFiles);
3391	}
3392	else
3393	RTPrintf(GuestCtrl::tr("No active guest sessions found\n"));
3394	}
3395
3396	if (FAILED(hrc)) /** @todo yeah, right... Only the last error? */
3397	rcExit = RTEXITCODE_FAILURE;
3398
3399	return rcExit;
3400	}
3401
3402	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseProcess(PGCTLCMDCTX pCtx, int argc, char **argv)
3403	{
3404	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3405
3406	static const RTGETOPTDEF s_aOptions[] =
3407	{
3408	GCTLCMD_COMMON_OPTION_DEFS()
3409	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3410	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
3411	};
3412
3413	int ch;
3414	RTGETOPTUNION ValueUnion;
3415	RTGETOPTSTATE GetState;
3416	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3417	AssertRCReturn(vrc, RTEXITCODE_FAILURE);
3418
3419	std::vector < uint32_t > vecPID;
3420	ULONG idSession = UINT32_MAX;
3421	Utf8Str strSessionName;
3422
3423	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3424	{
3425	/* For options that require an argument, ValueUnion has received the value. */
3426	switch (ch)
3427	{
3428	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3429
3430	case 'n': /* Session name (or pattern) */
3431	strSessionName = ValueUnion.psz;
3432	break;
3433
3434	case 'i': /* Session ID */
3435	idSession = ValueUnion.u32;
3436	break;
3437
3438	case VINF_GETOPT_NOT_OPTION:
3439	{
3440	/* Treat every else specified as a PID to kill. */
3441	uint32_t uPid;
3442	vrc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
3443	if ( RT_SUCCESS(vrc)
3444	&& vrc != VWRN_TRAILING_CHARS
3445	&& vrc != VWRN_NUMBER_TOO_BIG
3446	&& vrc != VWRN_NEGATIVE_UNSIGNED)
3447	{
3448	if (uPid != 0)
3449	{
3450	try
3451	{
3452	vecPID.push_back(uPid);
3453	}
3454	catch (std::bad_alloc &)
3455	{
3456	return RTMsgErrorExit(RTEXITCODE_FAILURE, GuestCtrl::tr("Out of memory"));
3457	}
3458	}
3459	else
3460	return errorSyntax(GuestCtrl::tr("Invalid PID value: 0"));
3461	}
3462	else
3463	return errorSyntax(GuestCtrl::tr("Error parsing PID value: %Rrc"), vrc);
3464	break;
3465	}
3466
3467	default:
3468	return errorGetOpt(ch, &ValueUnion);
3469	}
3470	}
3471
3472	if (vecPID.empty())
3473	return errorSyntax(GuestCtrl::tr("At least one PID must be specified to kill!"));
3474
3475	if ( strSessionName.isEmpty()
3476	&& idSession == UINT32_MAX)
3477	return errorSyntax(GuestCtrl::tr("No session ID specified!"));
3478
3479	if ( strSessionName.isNotEmpty()
3480	&& idSession != UINT32_MAX)
3481	return errorSyntax(GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
3482
3483	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3484	if (rcExit != RTEXITCODE_SUCCESS)
3485	return rcExit;
3486
3487	HRESULT hrc = S_OK;
3488
3489	ComPtr<IGuestSession> pSession;
3490	ComPtr<IGuestProcess> pProcess;
3491	do
3492	{
3493	uint32_t uProcsTerminated = 0;
3494
3495	SafeIfaceArray <IGuestSession> collSessions;
3496	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3497	size_t cSessions = collSessions.size();
3498
3499	uint32_t cSessionsHandled = 0;
3500	for (size_t i = 0; i < cSessions; i++)
3501	{
3502	pSession = collSessions[i];
3503	Assert(!pSession.isNull());
3504
3505	ULONG uID; /* Session ID */
3506	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3507	Bstr strName;
3508	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3509	Utf8Str strNameUtf8(strName); /* Session name */
3510
3511	bool fSessionFound;
3512	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3513	fSessionFound = uID == idSession;
3514	else /* ... or by naming pattern. */
3515	fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str());
3516	if (fSessionFound)
3517	{
3518	AssertStmt(!pSession.isNull(), break);
3519	cSessionsHandled++;
3520
3521	SafeIfaceArray <IGuestProcess> collProcs;
3522	CHECK_ERROR_BREAK(pSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcs)));
3523
3524	size_t cProcs = collProcs.size();
3525	for (size_t p = 0; p < cProcs; p++)
3526	{
3527	pProcess = collProcs[p];
3528	Assert(!pProcess.isNull());
3529
3530	ULONG uPID; /* Process ID */
3531	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
3532
3533	bool fProcFound = false;
3534	for (size_t a = 0; a < vecPID.size(); a++) /* Slow, but works. */
3535	{
3536	fProcFound = vecPID[a] == uPID;
3537	if (fProcFound)
3538	break;
3539	}
3540
3541	if (fProcFound)
3542	{
3543	if (pCtx->cVerbose)
3544	RTPrintf(GuestCtrl::tr("Terminating process (PID %RU32) (session ID %RU32) ...\n"),
3545	uPID, uID);
3546	CHECK_ERROR_BREAK(pProcess, Terminate());
3547	uProcsTerminated++;
3548	}
3549	else
3550	{
3551	if (idSession != UINT32_MAX)
3552	RTPrintf(GuestCtrl::tr("No matching process(es) for session ID %RU32 found\n"),
3553	idSession);
3554	}
3555
3556	pProcess.setNull();
3557	}
3558
3559	pSession.setNull();
3560	}
3561	}
3562
3563	if (!cSessionsHandled)
3564	RTPrintf(GuestCtrl::tr("No matching session(s) found\n"));
3565
3566	if (uProcsTerminated)
3567	RTPrintf(GuestCtrl::tr("%RU32 process(es) terminated\n", "", uProcsTerminated), uProcsTerminated);
3568
3569	} while (0);
3570
3571	pProcess.setNull();
3572	pSession.setNull();
3573
3574	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3575	}
3576
3577
3578	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseSession(PGCTLCMDCTX pCtx, int argc, char **argv)
3579	{
3580	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3581
3582	enum GETOPTDEF_SESSIONCLOSE
3583	{
3584	GETOPTDEF_SESSIONCLOSE_ALL = 2000
3585	};
3586	static const RTGETOPTDEF s_aOptions[] =
3587	{
3588	GCTLCMD_COMMON_OPTION_DEFS()
3589	{ "--all", GETOPTDEF_SESSIONCLOSE_ALL, RTGETOPT_REQ_NOTHING },
3590	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3591	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
3592	};
3593
3594	int ch;
3595	RTGETOPTUNION ValueUnion;
3596	RTGETOPTSTATE GetState;
3597	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3598
3599	ULONG idSession = UINT32_MAX;
3600	Utf8Str strSessionName;
3601
3602	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3603	{
3604	/* For options that require an argument, ValueUnion has received the value. */
3605	switch (ch)
3606	{
3607	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3608
3609	case 'n': /* Session name pattern */
3610	strSessionName = ValueUnion.psz;
3611	break;
3612
3613	case 'i': /* Session ID */
3614	idSession = ValueUnion.u32;
3615	break;
3616
3617	case GETOPTDEF_SESSIONCLOSE_ALL:
3618	strSessionName = "*";
3619	break;
3620
3621	case VINF_GETOPT_NOT_OPTION:
3622	/** @todo Supply a CSV list of IDs or patterns to close?
3623	* break; */
3624	default:
3625	return errorGetOpt(ch, &ValueUnion);
3626	}
3627	}
3628
3629	if ( strSessionName.isEmpty()
3630	&& idSession == UINT32_MAX)
3631	return errorSyntax(GuestCtrl::tr("No session ID specified!"));
3632
3633	if ( !strSessionName.isEmpty()
3634	&& idSession != UINT32_MAX)
3635	return errorSyntax(GuestCtrl::tr("Either session ID or name (pattern) must be specified"));
3636
3637	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3638	if (rcExit != RTEXITCODE_SUCCESS)
3639	return rcExit;
3640
3641	HRESULT hrc = S_OK;
3642
3643	do
3644	{
3645	size_t cSessionsHandled = 0;
3646
3647	SafeIfaceArray <IGuestSession> collSessions;
3648	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3649	size_t cSessions = collSessions.size();
3650
3651	for (size_t i = 0; i < cSessions; i++)
3652	{
3653	ComPtr<IGuestSession> pSession = collSessions[i];
3654	Assert(!pSession.isNull());
3655
3656	ULONG uID; /* Session ID */
3657	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3658	Bstr strName;
3659	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3660	Utf8Str strNameUtf8(strName); /* Session name */
3661
3662	bool fSessionFound;
3663	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3664	fSessionFound = uID == idSession;
3665	else /* ... or by naming pattern. */
3666	fSessionFound = RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str());
3667	if (fSessionFound)
3668	{
3669	cSessionsHandled++;
3670
3671	Assert(!pSession.isNull());
3672	if (pCtx->cVerbose)
3673	RTPrintf(GuestCtrl::tr("Closing guest session ID=#%RU32 \"%s\" ...\n"),
3674	uID, strNameUtf8.c_str());
3675	CHECK_ERROR_BREAK(pSession, Close());
3676	if (pCtx->cVerbose)
3677	RTPrintf(GuestCtrl::tr("Guest session successfully closed\n"));
3678
3679	pSession.setNull();
3680	}
3681	}
3682
3683	if (!cSessionsHandled)
3684	{
3685	RTPrintf(GuestCtrl::tr("No guest session(s) found\n"));
3686	hrc = E_ABORT; /* To set exit code accordingly. */
3687	}
3688
3689	} while (0);
3690
3691	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3692	}
3693
3694
3695	static DECLCALLBACK(RTEXITCODE) gctlHandleWatch(PGCTLCMDCTX pCtx, int argc, char **argv)
3696	{
3697	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3698
3699	/*
3700	* Parse arguments.
3701	*/
3702	static const RTGETOPTDEF s_aOptions[] =
3703	{
3704	GCTLCMD_COMMON_OPTION_DEFS()
3705	{ "--timeout", 't', RTGETOPT_REQ_UINT32 }
3706	};
3707
3708	uint32_t cMsTimeout = RT_INDEFINITE_WAIT;
3709
3710	int ch;
3711	RTGETOPTUNION ValueUnion;
3712	RTGETOPTSTATE GetState;
3713	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3714
3715	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3716	{
3717	/* For options that require an argument, ValueUnion has received the value. */
3718	switch (ch)
3719	{
3720	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3721
3722	case 't': /* Timeout */
3723	cMsTimeout = ValueUnion.u32;
3724	break;
3725
3726	case VINF_GETOPT_NOT_OPTION:
3727	default:
3728	return errorGetOpt(ch, &ValueUnion);
3729	}
3730	}
3731
3732	/** @todo Specify categories to watch for. */
3733
3734	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3735	if (rcExit != RTEXITCODE_SUCCESS)
3736	return rcExit;
3737
3738	HRESULT hrc;
3739
3740	try
3741	{
3742	ComObjPtr<GuestEventListenerImpl> pGuestListener;
3743	do
3744	{
3745	/* Listener creation. */
3746	pGuestListener.createObject();
3747	pGuestListener->init(new GuestEventListener());
3748
3749	/* Register for IGuest events. */
3750	ComPtr<IEventSource> es;
3751	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
3752	com::SafeArray<VBoxEventType_T> eventTypes;
3753	eventTypes.push_back(VBoxEventType_OnGuestSessionRegistered);
3754	/** @todo Also register for VBoxEventType_OnGuestUserStateChanged on demand? */
3755	CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
3756	true /* Active listener */));
3757	/* Note: All other guest control events have to be registered
3758	* as their corresponding objects appear. */
3759
3760	} while (0);
3761
3762	if (pCtx->cVerbose)
3763	RTPrintf(GuestCtrl::tr("Waiting for events ...\n"));
3764
3765	RTMSINTERVAL tsStart = RTTimeMilliTS();
3766	while (RTTimeMilliTS() - tsStart < cMsTimeout)
3767	{
3768	/* Wait for the global signal semaphore getting signalled. */
3769	int vrc = RTSemEventWait(g_SemEventGuestCtrlCanceled, 100 /* ms */);
3770	if (RT_FAILURE(vrc))
3771	{
3772	if (vrc != VERR_TIMEOUT)
3773	{
3774	RTPrintf(GuestCtrl::tr("Waiting failed with %Rrc\n"), vrc);
3775	break;
3776	}
3777	}
3778	else
3779	break;
3780
3781	/* We need to process the event queue, otherwise our registered listeners won't get any events. */
3782	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
3783	}
3784
3785	if (!pGuestListener.isNull())
3786	{
3787	/* Guest callback unregistration. */
3788	ComPtr<IEventSource> pES;
3789	CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
3790	if (!pES.isNull())
3791	CHECK_ERROR(pES, UnregisterListener(pGuestListener));
3792	pGuestListener.setNull();
3793	}
3794	}
3795	catch (std::bad_alloc &)
3796	{
3797	hrc = E_OUTOFMEMORY;
3798	}
3799
3800	return SUCCEEDED(hrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3801	}
3802
3803	/**
3804	* Access the guest control store.
3805	*
3806	* @returns program exit code.
3807	* @note see the command line API description for parameters
3808	*/
3809	RTEXITCODE handleGuestControl(HandlerArg *pArg)
3810	{
3811	AssertPtr(pArg);
3812
3813	/*
3814	* Command definitions.
3815	*/
3816	static const GCTLCMDDEF s_aCmdDefs[] =
3817	{
3818	{ "run", gctlHandleRun, HELP_SCOPE_GUESTCONTROL_RUN, 0 },
3819	{ "start", gctlHandleStart, HELP_SCOPE_GUESTCONTROL_START, 0 },
3820	{ "copyfrom", gctlHandleCopyFrom, HELP_SCOPE_GUESTCONTROL_COPYFROM, 0 },
3821	{ "copyto", gctlHandleCopyTo, HELP_SCOPE_GUESTCONTROL_COPYTO, 0 },
3822
3823	{ "mkdir", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3824	{ "md", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3825	{ "createdirectory", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3826	{ "createdir", gctrlHandleMkDir, HELP_SCOPE_GUESTCONTROL_MKDIR, 0 },
3827
3828	{ "rmdir", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3829	{ "removedir", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3830	{ "removedirectory", gctlHandleRmDir, HELP_SCOPE_GUESTCONTROL_RMDIR, 0 },
3831
3832	{ "rm", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3833	{ "removefile", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3834	{ "erase", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3835	{ "del", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3836	{ "delete", gctlHandleRm, HELP_SCOPE_GUESTCONTROL_RM, 0 },
3837
3838	{ "mv", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3839	{ "move", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3840	{ "ren", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3841	{ "rename", gctlHandleMv, HELP_SCOPE_GUESTCONTROL_MV, 0 },
3842
3843	{ "mktemp", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3844	{ "createtemp", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3845	{ "createtemporary", gctlHandleMkTemp, HELP_SCOPE_GUESTCONTROL_MKTEMP, 0 },
3846
3847	{ "mount", gctlHandleMount, HELP_SCOPE_GUESTCONTROL_MOUNT, 0 },
3848
3849	{ "df", gctlHandleFsInfo, HELP_SCOPE_GUESTCONTROL_FSINFO, 0 },
3850	{ "fsinfo", gctlHandleFsInfo, HELP_SCOPE_GUESTCONTROL_FSINFO, 0 },
3851
3852	{ "stat", gctlHandleStat, HELP_SCOPE_GUESTCONTROL_STAT, 0 },
3853
3854	{ "closeprocess", gctlHandleCloseProcess, HELP_SCOPE_GUESTCONTROL_CLOSEPROCESS, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3855	{ "closesession", gctlHandleCloseSession, HELP_SCOPE_GUESTCONTROL_CLOSESESSION, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3856	{ "list", gctlHandleList, HELP_SCOPE_GUESTCONTROL_LIST, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER },
3857	{ "watch", gctlHandleWatch, HELP_SCOPE_GUESTCONTROL_WATCH, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3858
3859	{"updateguestadditions",gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3860	{ "updateadditions", gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3861	{ "updatega", gctlHandleUpdateAdditions, HELP_SCOPE_GUESTCONTROL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3862
3863	{ "waitrunlevel", gctlHandleWaitRunLevel, HELP_SCOPE_GUESTCONTROL_WAITRUNLEVEL, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3864	{ "waitforrunlevel", gctlHandleWaitRunLevel, HELP_SCOPE_GUESTCONTROL_WAITRUNLEVEL, GCTLCMDCTX_F_SESSION_ANONYMOUS },
3865	};
3866
3867	/*
3868	* VBoxManage guestcontrol [common-options] <VM> [common-options] <sub-command> ...
3869	*
3870	* Parse common options and VM name until we find a sub-command. Allowing
3871	* the user to put the user and password related options before the
3872	* sub-command makes it easier to edit the command line when doing several
3873	* operations with the same guest user account. (Accidentally, it also
3874	* makes the syntax diagram shorter and easier to read.)
3875	*/
3876	GCTLCMDCTX CmdCtx;
3877	RTEXITCODE rcExit = gctrCmdCtxInit(&CmdCtx, pArg);
3878	if (rcExit == RTEXITCODE_SUCCESS)
3879	{
3880	static const RTGETOPTDEF s_CommonOptions[] = { GCTLCMD_COMMON_OPTION_DEFS() };
3881
3882	int ch;
3883	RTGETOPTUNION ValueUnion;
3884	RTGETOPTSTATE GetState;
3885	RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0, 0 /* No sorting! */);
3886
3887	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3888	{
3889	switch (ch)
3890	{
3891	GCTLCMD_COMMON_OPTION_CASES(&CmdCtx, ch, &ValueUnion);
3892
3893	case VINF_GETOPT_NOT_OPTION:
3894	/* First comes the VM name or UUID. */
3895	if (!CmdCtx.pszVmNameOrUuid)
3896	CmdCtx.pszVmNameOrUuid = ValueUnion.psz;
3897	/*
3898	* The sub-command is next. Look it up and invoke it.
3899	* Note! Currently no warnings about user/password options (like we'll do later on)
3900	* for GCTLCMDCTX_F_SESSION_ANONYMOUS commands. No reason to be too pedantic.
3901	*/
3902	else
3903	{
3904	const char *pszCmd = ValueUnion.psz;
3905	uint32_t iCmd;
3906	for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
3907	if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
3908	{
3909	CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
3910
3911	setCurrentSubcommand(s_aCmdDefs[iCmd].fSubcommandScope);
3912	rcExit = s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
3913	&pArg->argv[GetState.iNext - 1]);
3914
3915	gctlCtxTerm(&CmdCtx);
3916	return rcExit;
3917	}
3918	return errorSyntax(GuestCtrl::tr("Unknown sub-command: '%s'"), pszCmd);
3919	}
3920	break;
3921
3922	default:
3923	return errorGetOpt(ch, &ValueUnion);
3924	}
3925	}
3926	if (CmdCtx.pszVmNameOrUuid)
3927	rcExit = errorSyntax(GuestCtrl::tr("Missing sub-command"));
3928	else
3929	rcExit = errorSyntax(GuestCtrl::tr("Missing VM name and sub-command"));
3930	}
3931	return rcExit;
3932	}

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

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

Download in other formats: