VBoxManageGuestCtrl.cpp@ 70766

Last change on this file since 70766 was 69758, checked in by vboxsync, 7 years ago
VBoxManageGuestCtrl.cpp,DnDURIList.cpp: Fix RTDIRENTRYTYPE_UNKNOWN problem by using RTDirReadExA. Untested.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 160.4 KB

Line
1	/* $Id: VBoxManageGuestCtrl.cpp 69758 2017-11-19 15:23:57Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of guestcontrol command.
4	*/
5
6	/*
7	* Copyright (C) 2010-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include "VBoxManage.h"
23	#include "VBoxManageGuestCtrl.h"
24
25	#ifndef VBOX_ONLY_DOCS
26
27	#include <VBox/com/array.h>
28	#include <VBox/com/com.h>
29	#include <VBox/com/ErrorInfo.h>
30	#include <VBox/com/errorprint.h>
31	#include <VBox/com/listeners.h>
32	#include <VBox/com/NativeEventQueue.h>
33	#include <VBox/com/string.h>
34	#include <VBox/com/VirtualBox.h>
35
36	#include <VBox/err.h>
37	#include <VBox/log.h>
38
39	#include <iprt/asm.h>
40	#include <iprt/dir.h>
41	#include <iprt/file.h>
42	#include <iprt/isofs.h>
43	#include <iprt/getopt.h>
44	#include <iprt/list.h>
45	#include <iprt/path.h>
46	#include <iprt/process.h> /* For RTProcSelf(). */
47	#include <iprt/thread.h>
48	#include <iprt/vfs.h>
49
50	#include <map>
51	#include <vector>
52
53	#ifdef USE_XPCOM_QUEUE
54	# include <sys/select.h>
55	# include <errno.h>
56	#endif
57
58	#include <signal.h>
59
60	#ifdef RT_OS_DARWIN
61	# include <CoreFoundation/CFRunLoop.h>
62	#endif
63
64	using namespace com;
65
66
67	/*********************************************************************************************************************************
68	* Defined Constants And Macros *
69	*********************************************************************************************************************************/
70	#define GCTLCMD_COMMON_OPT_USER 999 /*< The --username option number. /
71	#define GCTLCMD_COMMON_OPT_PASSWORD 998 /*< The --password option number. /
72	#define GCTLCMD_COMMON_OPT_PASSWORD_FILE 997 /*< The --password-file option number. /
73	#define GCTLCMD_COMMON_OPT_DOMAIN 996 /*< The --domain option number. /
74	/** Common option definitions. */
75	#define GCTLCMD_COMMON_OPTION_DEFS() \
76	{ "--username", GCTLCMD_COMMON_OPT_USER, RTGETOPT_REQ_STRING }, \
77	{ "--passwordfile", GCTLCMD_COMMON_OPT_PASSWORD_FILE, RTGETOPT_REQ_STRING }, \
78	{ "--password", GCTLCMD_COMMON_OPT_PASSWORD, RTGETOPT_REQ_STRING }, \
79	{ "--domain", GCTLCMD_COMMON_OPT_DOMAIN, RTGETOPT_REQ_STRING }, \
80	{ "--quiet", 'q', RTGETOPT_REQ_NOTHING }, \
81	{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
82
83	/** Handles common options in the typical option parsing switch. */
84	#define GCTLCMD_COMMON_OPTION_CASES(a_pCtx, a_ch, a_pValueUnion) \
85	case 'v': \
86	case 'q': \
87	case GCTLCMD_COMMON_OPT_USER: \
88	case GCTLCMD_COMMON_OPT_DOMAIN: \
89	case GCTLCMD_COMMON_OPT_PASSWORD: \
90	case GCTLCMD_COMMON_OPT_PASSWORD_FILE: \
91	{ \
92	RTEXITCODE rcExitCommon = gctlCtxSetOption(a_pCtx, a_ch, a_pValueUnion); \
93	if (RT_UNLIKELY(rcExitCommon != RTEXITCODE_SUCCESS)) \
94	return rcExitCommon; \
95	} break
96
97
98	/*********************************************************************************************************************************
99	* Global Variables *
100	*********************************************************************************************************************************/
101	/** Set by the signal handler when current guest control
102	* action shall be aborted. */
103	static volatile bool g_fGuestCtrlCanceled = false;
104
105
106	/*********************************************************************************************************************************
107	* Structures and Typedefs *
108	*********************************************************************************************************************************/
109	/**
110	* Listener declarations.
111	*/
112	VBOX_LISTENER_DECLARE(GuestFileEventListenerImpl)
113	VBOX_LISTENER_DECLARE(GuestProcessEventListenerImpl)
114	VBOX_LISTENER_DECLARE(GuestSessionEventListenerImpl)
115	VBOX_LISTENER_DECLARE(GuestEventListenerImpl)
116
117
118	/**
119	* Definition of a guestcontrol command, with handler and various flags.
120	*/
121	typedef struct GCTLCMDDEF
122	{
123	/** The command name. */
124	const char *pszName;
125
126	/**
127	* Actual command handler callback.
128	*
129	* @param pCtx Pointer to command context to use.
130	*/
131	DECLR3CALLBACKMEMBER(RTEXITCODE, pfnHandler, (struct GCTLCMDCTX pCtx, int argc, char *argv));
132
133	/** The command usage flags. */
134	uint32_t fCmdUsage;
135	/** Command context flags (GCTLCMDCTX_F_XXX). */
136	uint32_t fCmdCtx;
137	} GCTLCMD;
138	/** Pointer to a const guest control command definition. */
139	typedef GCTLCMDDEF const *PCGCTLCMDDEF;
140
141	/** @name GCTLCMDCTX_F_XXX - Command context flags.
142	* @{
143	*/
144	/** No flags set. */
145	#define GCTLCMDCTX_F_NONE 0
146	/** Don't install a signal handler (CTRL+C trap). */
147	#define GCTLCMDCTX_F_NO_SIGNAL_HANDLER RT_BIT(0)
148	/** No guest session needed. */
149	#define GCTLCMDCTX_F_SESSION_ANONYMOUS RT_BIT(1)
150	/** @} */
151
152	/**
153	* Context for handling a specific command.
154	*/
155	typedef struct GCTLCMDCTX
156	{
157	HandlerArg *pArg;
158
159	/** Pointer to the command definition. */
160	PCGCTLCMDDEF pCmdDef;
161	/** The VM name or UUID. */
162	const char *pszVmNameOrUuid;
163
164	/** Whether we've done the post option parsing init already. */
165	bool fPostOptionParsingInited;
166	/** Whether we've locked the VM session. */
167	bool fLockedVmSession;
168	/** Whether to detach (@c true) or close the session. */
169	bool fDetachGuestSession;
170	/** Set if we've installed the signal handler. */
171	bool fInstalledSignalHandler;
172	/** The verbosity level. */
173	uint32_t cVerbose;
174	/** User name. */
175	Utf8Str strUsername;
176	/** Password. */
177	Utf8Str strPassword;
178	/** Domain. */
179	Utf8Str strDomain;
180	/** Pointer to the IGuest interface. */
181	ComPtr<IGuest> pGuest;
182	/** Pointer to the to be used guest session. */
183	ComPtr<IGuestSession> pGuestSession;
184	/** The guest session ID. */
185	ULONG uSessionID;
186
187	} GCTLCMDCTX, *PGCTLCMDCTX;
188
189
190	typedef struct COPYCONTEXT
191	{
192	COPYCONTEXT()
193	: fDryRun(false),
194	fHostToGuest(false)
195	{
196	}
197
198	PGCTLCMDCTX pCmdCtx;
199	bool fDryRun;
200	bool fHostToGuest;
201
202	} COPYCONTEXT, *PCOPYCONTEXT;
203
204	/**
205	* An entry for a source element, including an optional DOS-like wildcard (*,?).
206	*/
207	class SOURCEFILEENTRY
208	{
209	public:
210
211	SOURCEFILEENTRY(const char pszSource, const char pszFilter)
212	: mSource(pszSource),
213	mFilter(pszFilter) {}
214
215	SOURCEFILEENTRY(const char *pszSource)
216	: mSource(pszSource)
217	{
218	Parse(pszSource);
219	}
220
221	const char* GetSource() const
222	{
223	return mSource.c_str();
224	}
225
226	const char* GetFilter() const
227	{
228	return mFilter.c_str();
229	}
230
231	private:
232
233	int Parse(const char *pszPath)
234	{
235	AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
236
237	if ( !RTFileExists(pszPath)
238	&& !RTDirExists(pszPath))
239	{
240	/* No file and no directory -- maybe a filter? */
241	char *pszFilename = RTPathFilename(pszPath);
242	if ( pszFilename
243	&& strpbrk(pszFilename, "*?"))
244	{
245	/* Yep, get the actual filter part. */
246	mFilter = RTPathFilename(pszPath);
247	/* Remove the filter from actual sourcec directory name. */
248	RTPathStripFilename(mSource.mutableRaw());
249	mSource.jolt();
250	}
251	}
252
253	return VINF_SUCCESS; /** @todo */
254	}
255
256	private:
257
258	Utf8Str mSource;
259	Utf8Str mFilter;
260	};
261	typedef std::vector<SOURCEFILEENTRY> SOURCEVEC, *PSOURCEVEC;
262
263	/**
264	* An entry for an element which needs to be copied/created to/on the guest.
265	*/
266	typedef struct DESTFILEENTRY
267	{
268	DESTFILEENTRY(Utf8Str strFileName) : mFileName(strFileName) {}
269	Utf8Str mFileName;
270	} DESTFILEENTRY, *PDESTFILEENTRY;
271	/*
272	* Map for holding destination entries, whereas the key is the destination
273	* directory and the mapped value is a vector holding all elements for this directory.
274	*/
275	typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> > DESTDIRMAP, *PDESTDIRMAP;
276	typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> >::iterator DESTDIRMAPITER, *PDESTDIRMAPITER;
277
278
279	/**
280	* RTGetOpt-IDs for the guest execution control command line.
281	*/
282	enum GETOPTDEF_EXEC
283	{
284	GETOPTDEF_EXEC_IGNOREORPHANEDPROCESSES = 1000,
285	GETOPTDEF_EXEC_NO_PROFILE,
286	GETOPTDEF_EXEC_OUTPUTFORMAT,
287	GETOPTDEF_EXEC_DOS2UNIX,
288	GETOPTDEF_EXEC_UNIX2DOS,
289	GETOPTDEF_EXEC_WAITFOREXIT,
290	GETOPTDEF_EXEC_WAITFORSTDOUT,
291	GETOPTDEF_EXEC_WAITFORSTDERR
292	};
293
294	enum kStreamTransform
295	{
296	kStreamTransform_None = 0,
297	kStreamTransform_Dos2Unix,
298	kStreamTransform_Unix2Dos
299	};
300
301
302	/*********************************************************************************************************************************
303	* Internal Functions *
304	*********************************************************************************************************************************/
305	static int gctlCopyDirExists(PCOPYCONTEXT pContext, bool bGuest, const char pszDir, bool fExists);
306
307	#endif /* VBOX_ONLY_DOCS */
308
309
310
311	void usageGuestControl(PRTSTREAM pStrm, const char pcszSep1, const char pcszSep2, uint32_t uSubCmd)
312	{
313	const uint32_t fAnonSubCmds = USAGE_GSTCTRL_CLOSESESSION
314	\| USAGE_GSTCTRL_LIST
315	\| USAGE_GSTCTRL_CLOSEPROCESS
316	\| USAGE_GSTCTRL_CLOSESESSION
317	\| USAGE_GSTCTRL_UPDATEGA
318	\| USAGE_GSTCTRL_WATCH;
319
320	/* 0 1 2 3 4 5 6 7 8XXXXXXXXXX */
321	/* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
322	if (~fAnonSubCmds & uSubCmd)
323	RTStrmPrintf(pStrm,
324	"%s guestcontrol %s <uuid\|vmname> [--verbose\|-v] [--quiet\|-q]\n"
325	" [--username <name>] [--domain <domain>]\n"
326	" [--passwordfile <file> \| --password <password>]\n%s",
327	pcszSep1, pcszSep2, uSubCmd == ~0U ? "\n" : "");
328	if (uSubCmd & USAGE_GSTCTRL_RUN)
329	RTStrmPrintf(pStrm,
330	" run [common-options]\n"
331	" [--exe <path to executable>] [--timeout <msec>]\n"
332	" [-E\|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
333	" [--ignore-operhaned-processes] [--profile]\n"
334	" [--no-wait-stdout\|--wait-stdout]\n"
335	" [--no-wait-stderr\|--wait-stderr]\n"
336	" [--dos2unix] [--unix2dos]\n"
337	" -- <program/arg0> [argument1] ... [argumentN]]\n"
338	"\n");
339	if (uSubCmd & USAGE_GSTCTRL_START)
340	RTStrmPrintf(pStrm,
341	" start [common-options]\n"
342	" [--exe <path to executable>] [--timeout <msec>]\n"
343	" [-E\|--putenv <NAME>[=<VALUE>]] [--unquoted-args]\n"
344	" [--ignore-operhaned-processes] [--profile]\n"
345	" -- <program/arg0> [argument1] ... [argumentN]]\n"
346	"\n");
347	if (uSubCmd & USAGE_GSTCTRL_COPYFROM)
348	RTStrmPrintf(pStrm,
349	" copyfrom [common-options]\n"
350	" [--dryrun] [--follow] [-R\|--recursive]\n"
351	" <guest-src0> [guest-src1 [...]] <host-dst>\n"
352	"\n"
353	" copyfrom [common-options]\n"
354	" [--dryrun] [--follow] [-R\|--recursive]\n"
355	" [--target-directory <host-dst-dir>]\n"
356	" <guest-src0> [guest-src1 [...]]\n"
357	"\n");
358	if (uSubCmd & USAGE_GSTCTRL_COPYTO)
359	RTStrmPrintf(pStrm,
360	" copyto [common-options]\n"
361	" [--dryrun] [--follow] [-R\|--recursive]\n"
362	" <host-src0> [host-src1 [...]] <guest-dst>\n"
363	"\n"
364	" copyto [common-options]\n"
365	" [--dryrun] [--follow] [-R\|--recursive]\n"
366	" [--target-directory <guest-dst>]\n"
367	" <host-src0> [host-src1 [...]]\n"
368	"\n");
369	if (uSubCmd & USAGE_GSTCTRL_MKDIR)
370	RTStrmPrintf(pStrm,
371	" mkdir\|createdir[ectory] [common-options]\n"
372	" [--parents] [--mode <mode>]\n"
373	" <guest directory> [...]\n"
374	"\n");
375	if (uSubCmd & USAGE_GSTCTRL_RMDIR)
376	RTStrmPrintf(pStrm,
377	" rmdir\|removedir[ectory] [common-options]\n"
378	" [-R\|--recursive]\n"
379	" <guest directory> [...]\n"
380	"\n");
381	if (uSubCmd & USAGE_GSTCTRL_RM)
382	RTStrmPrintf(pStrm,
383	" removefile\|rm [common-options] [-f\|--force]\n"
384	" <guest file> [...]\n"
385	"\n");
386	if (uSubCmd & USAGE_GSTCTRL_MV)
387	RTStrmPrintf(pStrm,
388	" mv\|move\|ren[ame] [common-options]\n"
389	" <source> [source1 [...]] <dest>\n"
390	"\n");
391	if (uSubCmd & USAGE_GSTCTRL_MKTEMP)
392	RTStrmPrintf(pStrm,
393	" mktemp\|createtemp[orary] [common-options]\n"
394	" [--secure] [--mode <mode>] [--tmpdir <directory>]\n"
395	" <template>\n"
396	"\n");
397	if (uSubCmd & USAGE_GSTCTRL_STAT)
398	RTStrmPrintf(pStrm,
399	" stat [common-options]\n"
400	" <file> [...]\n"
401	"\n");
402
403	/*
404	* Command not requiring authentication.
405	*/
406	if (fAnonSubCmds & uSubCmd)
407	{
408	/* 0 1 2 3 4 5 6 7 8XXXXXXXXXX */
409	/* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
410	RTStrmPrintf(pStrm,
411	"%s guestcontrol %s <uuid\|vmname> [--verbose\|-v] [--quiet\|-q]\n%s",
412	pcszSep1, pcszSep2, uSubCmd == ~0U ? "\n" : "");
413	if (uSubCmd & USAGE_GSTCTRL_LIST)
414	RTStrmPrintf(pStrm,
415	" list <all\|sessions\|processes\|files> [common-opts]\n"
416	"\n");
417	if (uSubCmd & USAGE_GSTCTRL_CLOSEPROCESS)
418	RTStrmPrintf(pStrm,
419	" closeprocess [common-options]\n"
420	" < --session-id <ID>\n"
421	" \| --session-name <name or pattern>\n"
422	" <PID1> [PID1 [...]]\n"
423	"\n");
424	if (uSubCmd & USAGE_GSTCTRL_CLOSESESSION)
425	RTStrmPrintf(pStrm,
426	" closesession [common-options]\n"
427	" < --all \| --session-id <ID>\n"
428	" \| --session-name <name or pattern> >\n"
429	"\n");
430	if (uSubCmd & USAGE_GSTCTRL_UPDATEGA)
431	RTStrmPrintf(pStrm,
432	" updatega\|updateguestadditions\|updateadditions\n"
433	" [--source <guest additions .ISO>]\n"
434	" [--wait-start] [common-options]\n"
435	" [-- [<argument1>] ... [<argumentN>]]\n"
436	"\n");
437	if (uSubCmd & USAGE_GSTCTRL_WATCH)
438	RTStrmPrintf(pStrm,
439	" watch [common-options]\n"
440	"\n");
441	}
442	}
443
444	#ifndef VBOX_ONLY_DOCS
445
446
447	#ifdef RT_OS_WINDOWS
448	static BOOL WINAPI gctlSignalHandler(DWORD dwCtrlType)
449	{
450	bool fEventHandled = FALSE;
451	switch (dwCtrlType)
452	{
453	/* User pressed CTRL+C or CTRL+BREAK or an external event was sent
454	* via GenerateConsoleCtrlEvent(). */
455	case CTRL_BREAK_EVENT:
456	case CTRL_CLOSE_EVENT:
457	case CTRL_C_EVENT:
458	ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true);
459	fEventHandled = TRUE;
460	break;
461	default:
462	break;
463	/** @todo Add other events here. */
464	}
465
466	return fEventHandled;
467	}
468	#else /* !RT_OS_WINDOWS */
469	/**
470	* Signal handler that sets g_fGuestCtrlCanceled.
471	*
472	* This can be executed on any thread in the process, on Windows it may even be
473	* a thread dedicated to delivering this signal. Don't do anything
474	* unnecessary here.
475	*/
476	static void gctlSignalHandler(int iSignal)
477	{
478	NOREF(iSignal);
479	ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true);
480	}
481	#endif
482
483
484	/**
485	* Installs a custom signal handler to get notified
486	* whenever the user wants to intercept the program.
487	*
488	* @todo Make this handler available for all VBoxManage modules?
489	*/
490	static int gctlSignalHandlerInstall(void)
491	{
492	g_fGuestCtrlCanceled = false;
493
494	int rc = VINF_SUCCESS;
495	#ifdef RT_OS_WINDOWS
496	if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)gctlSignalHandler, TRUE /* Add handler */))
497	{
498	rc = RTErrConvertFromWin32(GetLastError());
499	RTMsgError("Unable to install console control handler, rc=%Rrc\n", rc);
500	}
501	#else
502	signal(SIGINT, gctlSignalHandler);
503	signal(SIGTERM, gctlSignalHandler);
504	# ifdef SIGBREAK
505	signal(SIGBREAK, gctlSignalHandler);
506	# endif
507	#endif
508	return rc;
509	}
510
511
512	/**
513	* Uninstalls a previously installed signal handler.
514	*/
515	static int gctlSignalHandlerUninstall(void)
516	{
517	int rc = VINF_SUCCESS;
518	#ifdef RT_OS_WINDOWS
519	if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
520	{
521	rc = RTErrConvertFromWin32(GetLastError());
522	RTMsgError("Unable to uninstall console control handler, rc=%Rrc\n", rc);
523	}
524	#else
525	signal(SIGINT, SIG_DFL);
526	signal(SIGTERM, SIG_DFL);
527	# ifdef SIGBREAK
528	signal(SIGBREAK, SIG_DFL);
529	# endif
530	#endif
531	return rc;
532	}
533
534
535	/**
536	* Translates a process status to a human readable string.
537	*/
538	const char *gctlProcessStatusToText(ProcessStatus_T enmStatus)
539	{
540	switch (enmStatus)
541	{
542	case ProcessStatus_Starting:
543	return "starting";
544	case ProcessStatus_Started:
545	return "started";
546	case ProcessStatus_Paused:
547	return "paused";
548	case ProcessStatus_Terminating:
549	return "terminating";
550	case ProcessStatus_TerminatedNormally:
551	return "successfully terminated";
552	case ProcessStatus_TerminatedSignal:
553	return "terminated by signal";
554	case ProcessStatus_TerminatedAbnormally:
555	return "abnormally aborted";
556	case ProcessStatus_TimedOutKilled:
557	return "timed out";
558	case ProcessStatus_TimedOutAbnormally:
559	return "timed out, hanging";
560	case ProcessStatus_Down:
561	return "killed";
562	case ProcessStatus_Error:
563	return "error";
564	default:
565	break;
566	}
567	return "unknown";
568	}
569
570	/**
571	* Translates a guest process wait result to a human readable string.
572	*/
573	const char *gctlProcessWaitResultToText(ProcessWaitResult_T enmWaitResult)
574	{
575	switch (enmWaitResult)
576	{
577	case ProcessWaitResult_Start:
578	return "started";
579	case ProcessWaitResult_Terminate:
580	return "terminated";
581	case ProcessWaitResult_Status:
582	return "status changed";
583	case ProcessWaitResult_Error:
584	return "error";
585	case ProcessWaitResult_Timeout:
586	return "timed out";
587	case ProcessWaitResult_StdIn:
588	return "stdin ready";
589	case ProcessWaitResult_StdOut:
590	return "data on stdout";
591	case ProcessWaitResult_StdErr:
592	return "data on stderr";
593	case ProcessWaitResult_WaitFlagNotSupported:
594	return "waiting flag not supported";
595	default:
596	break;
597	}
598	return "unknown";
599	}
600
601	/**
602	* Translates a guest session status to a human readable string.
603	*/
604	const char *gctlGuestSessionStatusToText(GuestSessionStatus_T enmStatus)
605	{
606	switch (enmStatus)
607	{
608	case GuestSessionStatus_Starting:
609	return "starting";
610	case GuestSessionStatus_Started:
611	return "started";
612	case GuestSessionStatus_Terminating:
613	return "terminating";
614	case GuestSessionStatus_Terminated:
615	return "terminated";
616	case GuestSessionStatus_TimedOutKilled:
617	return "timed out";
618	case GuestSessionStatus_TimedOutAbnormally:
619	return "timed out, hanging";
620	case GuestSessionStatus_Down:
621	return "killed";
622	case GuestSessionStatus_Error:
623	return "error";
624	default:
625	break;
626	}
627	return "unknown";
628	}
629
630	/**
631	* Translates a guest file status to a human readable string.
632	*/
633	const char *gctlFileStatusToText(FileStatus_T enmStatus)
634	{
635	switch (enmStatus)
636	{
637	case FileStatus_Opening:
638	return "opening";
639	case FileStatus_Open:
640	return "open";
641	case FileStatus_Closing:
642	return "closing";
643	case FileStatus_Closed:
644	return "closed";
645	case FileStatus_Down:
646	return "killed";
647	case FileStatus_Error:
648	return "error";
649	default:
650	break;
651	}
652	return "unknown";
653	}
654
655	static int gctlPrintError(com::ErrorInfo &errorInfo)
656	{
657	if ( errorInfo.isFullAvailable()
658	\|\| errorInfo.isBasicAvailable())
659	{
660	/* If we got a VBOX_E_IPRT error we handle the error in a more gentle way
661	* because it contains more accurate info about what went wrong. */
662	if (errorInfo.getResultCode() == VBOX_E_IPRT_ERROR)
663	RTMsgError("%ls.", errorInfo.getText().raw());
664	else
665	{
666	RTMsgError("Error details:");
667	GluePrintErrorInfo(errorInfo);
668	}
669	return VERR_GENERAL_FAILURE; /** @todo */
670	}
671	AssertMsgFailedReturn(("Object has indicated no error (%Rhrc)!?\n", errorInfo.getResultCode()),
672	VERR_INVALID_PARAMETER);
673	}
674
675	static int gctlPrintError(IUnknown *pObj, const GUID &aIID)
676	{
677	com::ErrorInfo ErrInfo(pObj, aIID);
678	return gctlPrintError(ErrInfo);
679	}
680
681	static int gctlPrintProgressError(ComPtr<IProgress> pProgress)
682	{
683	int vrc = VINF_SUCCESS;
684	HRESULT rc;
685
686	do
687	{
688	BOOL fCanceled;
689	CHECK_ERROR_BREAK(pProgress, COMGETTER(Canceled)(&fCanceled));
690	if (!fCanceled)
691	{
692	LONG rcProc;
693	CHECK_ERROR_BREAK(pProgress, COMGETTER(ResultCode)(&rcProc));
694	if (FAILED(rcProc))
695	{
696	com::ProgressErrorInfo ErrInfo(pProgress);
697	vrc = gctlPrintError(ErrInfo);
698	}
699	}
700
701	} while(0);
702
703	AssertMsgStmt(SUCCEEDED(rc), ("Could not lookup progress information\n"), vrc = VERR_COM_UNEXPECTED);
704
705	return vrc;
706	}
707
708
709
710	/*
711	*
712	*
713	* Guest Control Command Context
714	* Guest Control Command Context
715	* Guest Control Command Context
716	* Guest Control Command Context
717	*
718	*
719	*
720	*/
721
722
723	/**
724	* Initializes a guest control command context structure.
725	*
726	* @returns RTEXITCODE_SUCCESS on success, RTEXITCODE_FAILURE on failure (after
727	* informing the user of course).
728	* @param pCtx The command context to init.
729	* @param pArg The handle argument package.
730	*/
731	static RTEXITCODE gctrCmdCtxInit(PGCTLCMDCTX pCtx, HandlerArg *pArg)
732	{
733	RT_ZERO(*pCtx);
734	pCtx->pArg = pArg;
735
736	/*
737	* The user name defaults to the host one, if we can get at it.
738	*/
739	char szUser[1024];
740	int rc = RTProcQueryUsername(RTProcSelf(), szUser, sizeof(szUser), NULL);
741	if ( RT_SUCCESS(rc)
742	&& RTStrIsValidEncoding(szUser)) /* paranoia required on posix */
743	{
744	try
745	{
746	pCtx->strUsername = szUser;
747	}
748	catch (std::bad_alloc &)
749	{
750	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
751	}
752	}
753	/* else: ignore this failure. */
754
755	return RTEXITCODE_SUCCESS;
756	}
757
758
759	/**
760	* Worker for GCTLCMD_COMMON_OPTION_CASES.
761	*
762	* @returns RTEXITCODE_SUCCESS if the option was handled successfully. If not,
763	* an error message is printed and an appropriate failure exit code is
764	* returned.
765	* @param pCtx The guest control command context.
766	* @param ch The option char or ordinal.
767	* @param pValueUnion The option value union.
768	*/
769	static RTEXITCODE gctlCtxSetOption(PGCTLCMDCTX pCtx, int ch, PRTGETOPTUNION pValueUnion)
770	{
771	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
772	switch (ch)
773	{
774	case GCTLCMD_COMMON_OPT_USER: /* User name */
775	if (!pCtx->pCmdDef \|\| !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
776	pCtx->strUsername = pValueUnion->psz;
777	else
778	RTMsgWarning("The --username\|-u option is ignored by '%s'", pCtx->pCmdDef->pszName);
779	break;
780
781	case GCTLCMD_COMMON_OPT_PASSWORD: /* Password */
782	if (!pCtx->pCmdDef \|\| !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
783	{
784	if (pCtx->strPassword.isNotEmpty())
785	RTMsgWarning("Password is given more than once.");
786	pCtx->strPassword = pValueUnion->psz;
787	}
788	else
789	RTMsgWarning("The --password option is ignored by '%s'", pCtx->pCmdDef->pszName);
790	break;
791
792	case GCTLCMD_COMMON_OPT_PASSWORD_FILE: /* Password file */
793	if (!pCtx->pCmdDef \|\| !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
794	rcExit = readPasswordFile(pValueUnion->psz, &pCtx->strPassword);
795	else
796	RTMsgWarning("The --password-file\|-p option is ignored by '%s'", pCtx->pCmdDef->pszName);
797	break;
798
799	case GCTLCMD_COMMON_OPT_DOMAIN: /* domain */
800	if (!pCtx->pCmdDef \|\| !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
801	pCtx->strDomain = pValueUnion->psz;
802	else
803	RTMsgWarning("The --domain option is ignored by '%s'", pCtx->pCmdDef->pszName);
804	break;
805
806	case 'v': /* --verbose */
807	pCtx->cVerbose++;
808	break;
809
810	case 'q': /* --quiet */
811	if (pCtx->cVerbose)
812	pCtx->cVerbose--;
813	break;
814
815	default:
816	AssertFatalMsgFailed(("ch=%d (%c)\n", ch, ch));
817	}
818	return rcExit;
819	}
820
821
822	/**
823	* Initializes the VM for IGuest operation.
824	*
825	* This opens a shared session to a running VM and gets hold of IGuest.
826	*
827	* @returns RTEXITCODE_SUCCESS on success. RTEXITCODE_FAILURE and user message
828	* on failure.
829	* @param pCtx The guest control command context.
830	* GCTLCMDCTX::pGuest will be set on success.
831	*/
832	static RTEXITCODE gctlCtxInitVmSession(PGCTLCMDCTX pCtx)
833	{
834	HRESULT rc;
835	AssertPtr(pCtx);
836	AssertPtr(pCtx->pArg);
837
838	/*
839	* Find the VM and check if it's running.
840	*/
841	ComPtr<IMachine> machine;
842	CHECK_ERROR(pCtx->pArg->virtualBox, FindMachine(Bstr(pCtx->pszVmNameOrUuid).raw(), machine.asOutParam()));
843	if (SUCCEEDED(rc))
844	{
845	MachineState_T enmMachineState;
846	CHECK_ERROR(machine, COMGETTER(State)(&enmMachineState));
847	if ( SUCCEEDED(rc)
848	&& enmMachineState == MachineState_Running)
849	{
850	/*
851	* It's running. So, open a session to it and get the IGuest interface.
852	*/
853	CHECK_ERROR(machine, LockMachine(pCtx->pArg->session, LockType_Shared));
854	if (SUCCEEDED(rc))
855	{
856	pCtx->fLockedVmSession = true;
857	ComPtr<IConsole> ptrConsole;
858	CHECK_ERROR(pCtx->pArg->session, COMGETTER(Console)(ptrConsole.asOutParam()));
859	if (SUCCEEDED(rc))
860	{
861	if (ptrConsole.isNotNull())
862	{
863	CHECK_ERROR(ptrConsole, COMGETTER(Guest)(pCtx->pGuest.asOutParam()));
864	if (SUCCEEDED(rc))
865	return RTEXITCODE_SUCCESS;
866	}
867	else
868	RTMsgError("Failed to get a IConsole pointer for the machine. Is it still running?\n");
869	}
870	}
871	}
872	else if (SUCCEEDED(rc))
873	RTMsgError("Machine \"%s\" is not running (currently %s)!\n",
874	pCtx->pszVmNameOrUuid, machineStateToName(enmMachineState, false));
875	}
876	return RTEXITCODE_FAILURE;
877	}
878
879
880	/**
881	* Creates a guest session with the VM.
882	*
883	* @retval RTEXITCODE_SUCCESS on success.
884	* @retval RTEXITCODE_FAILURE and user message on failure.
885	* @param pCtx The guest control command context.
886	* GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID
887	* will be set.
888	*/
889	static RTEXITCODE gctlCtxInitGuestSession(PGCTLCMDCTX pCtx)
890	{
891	HRESULT rc;
892	AssertPtr(pCtx);
893	Assert(!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS));
894	Assert(pCtx->pGuest.isNotNull());
895
896	/*
897	* Build up a reasonable guest session name. Useful for identifying
898	* a specific session when listing / searching for them.
899	*/
900	char *pszSessionName;
901	if (RTStrAPrintf(&pszSessionName,
902	"[%RU32] VBoxManage Guest Control [%s] - %s",
903	RTProcSelf(), pCtx->pszVmNameOrUuid, pCtx->pCmdDef->pszName) < 0)
904	return RTMsgErrorExit(RTEXITCODE_FAILURE, "No enough memory for session name");
905
906	/*
907	* Create a guest session.
908	*/
909	if (pCtx->cVerbose)
910	RTPrintf("Creating guest session as user '%s'...\n", pCtx->strUsername.c_str());
911	try
912	{
913	CHECK_ERROR(pCtx->pGuest, CreateSession(Bstr(pCtx->strUsername).raw(),
914	Bstr(pCtx->strPassword).raw(),
915	Bstr(pCtx->strDomain).raw(),
916	Bstr(pszSessionName).raw(),
917	pCtx->pGuestSession.asOutParam()));
918	}
919	catch (std::bad_alloc &)
920	{
921	RTMsgError("Out of memory setting up IGuest::CreateSession call");
922	rc = E_OUTOFMEMORY;
923	}
924	if (SUCCEEDED(rc))
925	{
926	/*
927	* Wait for guest session to start.
928	*/
929	if (pCtx->cVerbose)
930	RTPrintf("Waiting for guest session to start...\n");
931	GuestSessionWaitResult_T enmWaitResult = GuestSessionWaitResult_None; /* Shut up MSC */
932	try
933	{
934	com::SafeArray<GuestSessionWaitForFlag_T> aSessionWaitFlags;
935	aSessionWaitFlags.push_back(GuestSessionWaitForFlag_Start);
936	CHECK_ERROR(pCtx->pGuestSession, WaitForArray(ComSafeArrayAsInParam(aSessionWaitFlags),
937	/** @todo Make session handling timeouts configurable. */
938	30 * 1000, &enmWaitResult));
939	}
940	catch (std::bad_alloc &)
941	{
942	RTMsgError("Out of memory setting up IGuestSession::WaitForArray call");
943	rc = E_OUTOFMEMORY;
944	}
945	if (SUCCEEDED(rc))
946	{
947	/* The WaitFlagNotSupported result may happen with GAs older than 4.3. */
948	if ( enmWaitResult == GuestSessionWaitResult_Start
949	\|\| enmWaitResult == GuestSessionWaitResult_WaitFlagNotSupported)
950	{
951	/*
952	* Get the session ID and we're ready to rumble.
953	*/
954	CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Id)(&pCtx->uSessionID));
955	if (SUCCEEDED(rc))
956	{
957	if (pCtx->cVerbose)
958	RTPrintf("Successfully started guest session (ID %RU32)\n", pCtx->uSessionID);
959	RTStrFree(pszSessionName);
960	return RTEXITCODE_SUCCESS;
961	}
962	}
963	else
964	{
965	GuestSessionStatus_T enmSessionStatus;
966	CHECK_ERROR(pCtx->pGuestSession, COMGETTER(Status)(&enmSessionStatus));
967	RTMsgError("Error starting guest session (current status is: %s)\n",
968	SUCCEEDED(rc) ? gctlGuestSessionStatusToText(enmSessionStatus) : "<unknown>");
969	}
970	}
971	}
972
973	RTStrFree(pszSessionName);
974	return RTEXITCODE_FAILURE;
975	}
976
977
978	/**
979	* Completes the guest control context initialization after parsing arguments.
980	*
981	* Will validate common arguments, open a VM session, and if requested open a
982	* guest session and install the CTRL-C signal handler.
983	*
984	* It is good to validate all the options and arguments you can before making
985	* this call. However, the VM session, IGuest and IGuestSession interfaces are
986	* not availabe till after this call, so take care.
987	*
988	* @retval RTEXITCODE_SUCCESS on success.
989	* @retval RTEXITCODE_FAILURE and user message on failure.
990	* @param pCtx The guest control command context.
991	* GCTCMDCTX::pGuestSession and GCTLCMDCTX::uSessionID
992	* will be set.
993	* @remarks Can safely be called multiple times, will only do work once.
994	*/
995	static RTEXITCODE gctlCtxPostOptionParsingInit(PGCTLCMDCTX pCtx)
996	{
997	if (pCtx->fPostOptionParsingInited)
998	return RTEXITCODE_SUCCESS;
999
1000	/*
1001	* Check that the user name isn't empty when we need it.
1002	*/
1003	RTEXITCODE rcExit;
1004	if ( (pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)
1005	\|\| pCtx->strUsername.isNotEmpty())
1006	{
1007	/*
1008	* Open the VM session and if required, a guest session.
1009	*/
1010	rcExit = gctlCtxInitVmSession(pCtx);
1011	if ( rcExit == RTEXITCODE_SUCCESS
1012	&& !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS))
1013	rcExit = gctlCtxInitGuestSession(pCtx);
1014	if (rcExit == RTEXITCODE_SUCCESS)
1015	{
1016	/*
1017	* Install signal handler if requested (errors are ignored).
1018	*/
1019	if (!(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_NO_SIGNAL_HANDLER))
1020	{
1021	int rc = gctlSignalHandlerInstall();
1022	pCtx->fInstalledSignalHandler = RT_SUCCESS(rc);
1023	}
1024	}
1025	}
1026	else
1027	rcExit = errorSyntaxEx(USAGE_GUESTCONTROL, pCtx->pCmdDef->fCmdUsage, "No user name specified!");
1028
1029	pCtx->fPostOptionParsingInited = rcExit == RTEXITCODE_SUCCESS;
1030	return rcExit;
1031	}
1032
1033
1034	/**
1035	* Cleans up the context when the command returns.
1036	*
1037	* This will close any open guest session, unless the DETACH flag is set.
1038	* It will also close any VM session that may be been established. Any signal
1039	* handlers we've installed will also be removed.
1040	*
1041	* Un-initializes the VM after guest control usage.
1042	* @param pCmdCtx Pointer to command context.
1043	*/
1044	static void gctlCtxTerm(PGCTLCMDCTX pCtx)
1045	{
1046	HRESULT rc;
1047	AssertPtr(pCtx);
1048
1049	/*
1050	* Uninstall signal handler.
1051	*/
1052	if (pCtx->fInstalledSignalHandler)
1053	{
1054	gctlSignalHandlerUninstall();
1055	pCtx->fInstalledSignalHandler = false;
1056	}
1057
1058	/*
1059	* Close, or at least release, the guest session.
1060	*/
1061	if (pCtx->pGuestSession.isNotNull())
1062	{
1063	if ( !(pCtx->pCmdDef->fCmdCtx & GCTLCMDCTX_F_SESSION_ANONYMOUS)
1064	&& !pCtx->fDetachGuestSession)
1065	{
1066	if (pCtx->cVerbose)
1067	RTPrintf("Closing guest session ...\n");
1068
1069	CHECK_ERROR(pCtx->pGuestSession, Close());
1070	}
1071	else if ( pCtx->fDetachGuestSession
1072	&& pCtx->cVerbose)
1073	RTPrintf("Guest session detached\n");
1074
1075	pCtx->pGuestSession.setNull();
1076	}
1077
1078	/*
1079	* Close the VM session.
1080	*/
1081	if (pCtx->fLockedVmSession)
1082	{
1083	Assert(pCtx->pArg->session.isNotNull());
1084	CHECK_ERROR(pCtx->pArg->session, UnlockMachine());
1085	pCtx->fLockedVmSession = false;
1086	}
1087	}
1088
1089
1090
1091
1092
1093	/*
1094	*
1095	*
1096	* Guest Control Command Handling.
1097	* Guest Control Command Handling.
1098	* Guest Control Command Handling.
1099	* Guest Control Command Handling.
1100	* Guest Control Command Handling.
1101	*
1102	*
1103	*/
1104
1105
1106	/** @name EXITCODEEXEC_XXX - Special run exit codes.
1107	*
1108	* Special exit codes for returning errors/information of a started guest
1109	* process to the command line VBoxManage was started from. Useful for e.g.
1110	* scripting.
1111	*
1112	* ASSUMING that all platforms have at least 7-bits for the exit code we can do
1113	* the following mapping:
1114	* - Guest exit code 0 is mapped to 0 on the host.
1115	* - Guest exit codes 1 thru 93 (0x5d) are displaced by 32, so that 1
1116	* becomes 33 (0x21) on the host and 93 becomes 125 (0x7d) on the host.
1117	* - Guest exit codes 94 (0x5e) and above are mapped to 126 (0x5e).
1118	*
1119	* We ASSUME that all VBoxManage status codes are in the range 0 thru 32.
1120	*
1121	* @note These are frozen as of 4.1.0.
1122	* @note The guest exit code mappings was introduced with 5.0 and the 'run'
1123	* command, they are/was not supported by 'exec'.
1124	* @sa gctlRunCalculateExitCode
1125	*/
1126	/** Process exited normally but with an exit code <> 0. */
1127	#define EXITCODEEXEC_CODE ((RTEXITCODE)16)
1128	#define EXITCODEEXEC_FAILED ((RTEXITCODE)17)
1129	#define EXITCODEEXEC_TERM_SIGNAL ((RTEXITCODE)18)
1130	#define EXITCODEEXEC_TERM_ABEND ((RTEXITCODE)19)
1131	#define EXITCODEEXEC_TIMEOUT ((RTEXITCODE)20)
1132	#define EXITCODEEXEC_DOWN ((RTEXITCODE)21)
1133	/** Execution was interrupt by user (ctrl-c). */
1134	#define EXITCODEEXEC_CANCELED ((RTEXITCODE)22)
1135	/** The first mapped guest (non-zero) exit code. */
1136	#define EXITCODEEXEC_MAPPED_FIRST 33
1137	/** The last mapped guest (non-zero) exit code value (inclusive). */
1138	#define EXITCODEEXEC_MAPPED_LAST 125
1139	/** The number of exit codes from EXITCODEEXEC_MAPPED_FIRST to
1140	* EXITCODEEXEC_MAPPED_LAST. This is also the highest guest exit code number
1141	* we're able to map. */
1142	#define EXITCODEEXEC_MAPPED_RANGE (93)
1143	/** The guest exit code displacement value. */
1144	#define EXITCODEEXEC_MAPPED_DISPLACEMENT 32
1145	/** The guest exit code was too big to be mapped. */
1146	#define EXITCODEEXEC_MAPPED_BIG ((RTEXITCODE)126)
1147	/** @} */
1148
1149	/**
1150	* Calculates the exit code of VBoxManage.
1151	*
1152	* @returns The exit code to return.
1153	* @param enmStatus The guest process status.
1154	* @param uExitCode The associated guest process exit code (where
1155	* applicable).
1156	* @param fReturnExitCodes Set if we're to use the 32-126 range for guest
1157	* exit codes.
1158	*/
1159	static RTEXITCODE gctlRunCalculateExitCode(ProcessStatus_T enmStatus, ULONG uExitCode, bool fReturnExitCodes)
1160	{
1161	switch (enmStatus)
1162	{
1163	case ProcessStatus_TerminatedNormally:
1164	if (uExitCode == 0)
1165	return RTEXITCODE_SUCCESS;
1166	if (!fReturnExitCodes)
1167	return EXITCODEEXEC_CODE;
1168	if (uExitCode <= EXITCODEEXEC_MAPPED_RANGE)
1169	return (RTEXITCODE) (uExitCode + EXITCODEEXEC_MAPPED_DISPLACEMENT);
1170	return EXITCODEEXEC_MAPPED_BIG;
1171
1172	case ProcessStatus_TerminatedAbnormally:
1173	return EXITCODEEXEC_TERM_ABEND;
1174	case ProcessStatus_TerminatedSignal:
1175	return EXITCODEEXEC_TERM_SIGNAL;
1176
1177	#if 0 /* see caller! */
1178	case ProcessStatus_TimedOutKilled:
1179	return EXITCODEEXEC_TIMEOUT;
1180	case ProcessStatus_Down:
1181	return EXITCODEEXEC_DOWN; /* Service/OS is stopping, process was killed. */
1182	case ProcessStatus_Error:
1183	return EXITCODEEXEC_FAILED;
1184
1185	/* The following is probably for detached? */
1186	case ProcessStatus_Starting:
1187	return RTEXITCODE_SUCCESS;
1188	case ProcessStatus_Started:
1189	return RTEXITCODE_SUCCESS;
1190	case ProcessStatus_Paused:
1191	return RTEXITCODE_SUCCESS;
1192	case ProcessStatus_Terminating:
1193	return RTEXITCODE_SUCCESS; /** @todo ???? */
1194	#endif
1195
1196	default:
1197	AssertMsgFailed(("Unknown exit status (%u/%u) from guest process returned!\n", enmStatus, uExitCode));
1198	return RTEXITCODE_FAILURE;
1199	}
1200	}
1201
1202
1203	/**
1204	* Pumps guest output to the host.
1205	*
1206	* @return IPRT status code.
1207	* @param pProcess Pointer to appropriate process object.
1208	* @param hVfsIosDst Where to write the data.
1209	* @param uHandle Handle where to read the data from.
1210	* @param cMsTimeout Timeout (in ms) to wait for the operation to
1211	* complete.
1212	*/
1213	static int gctlRunPumpOutput(IProcess *pProcess, RTVFSIOSTREAM hVfsIosDst, ULONG uHandle, RTMSINTERVAL cMsTimeout)
1214	{
1215	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1216	Assert(hVfsIosDst != NIL_RTVFSIOSTREAM);
1217
1218	int vrc;
1219
1220	SafeArray<BYTE> aOutputData;
1221	HRESULT hrc = pProcess->Read(uHandle, _64K, RT_MAX(cMsTimeout, 1), ComSafeArrayAsOutParam(aOutputData));
1222	if (SUCCEEDED(hrc))
1223	{
1224	size_t cbOutputData = aOutputData.size();
1225	if (cbOutputData == 0)
1226	vrc = VINF_SUCCESS;
1227	else
1228	{
1229	BYTE const *pbBuf = aOutputData.raw();
1230	AssertPtr(pbBuf);
1231
1232	vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /fBlocking/, NULL);
1233	if (RT_FAILURE(vrc))
1234	RTMsgError("Unable to write output, rc=%Rrc\n", vrc);
1235	}
1236	}
1237	else
1238	vrc = gctlPrintError(pProcess, COM_IIDOF(IProcess));
1239	return vrc;
1240	}
1241
1242
1243	/**
1244	* Configures a host handle for pumping guest bits.
1245	*
1246	* @returns true if enabled and we successfully configured it.
1247	* @param fEnabled Whether pumping this pipe is configured.
1248	* @param enmHandle The IPRT standard handle designation.
1249	* @param pszName The name for user messages.
1250	* @param enmTransformation The transformation to apply.
1251	* @param phVfsIos Where to return the resulting I/O stream handle.
1252	*/
1253	static bool gctlRunSetupHandle(bool fEnabled, RTHANDLESTD enmHandle, const char *pszName,
1254	kStreamTransform enmTransformation, PRTVFSIOSTREAM phVfsIos)
1255	{
1256	if (fEnabled)
1257	{
1258	int vrc = RTVfsIoStrmFromStdHandle(enmHandle, 0, true /fLeaveOpen/, phVfsIos);
1259	if (RT_SUCCESS(vrc))
1260	{
1261	if (enmTransformation != kStreamTransform_None)
1262	{
1263	RTMsgWarning("Unsupported %s line ending conversion", pszName);
1264	/** @todo Implement dos2unix and unix2dos stream filters. */
1265	}
1266	return true;
1267	}
1268	RTMsgWarning("Error getting %s handle: %Rrc", pszName, vrc);
1269	}
1270	return false;
1271	}
1272
1273
1274	/**
1275	* Returns the remaining time (in ms) based on the start time and a set
1276	* timeout value. Returns RT_INDEFINITE_WAIT if no timeout was specified.
1277	*
1278	* @return RTMSINTERVAL Time left (in ms).
1279	* @param u64StartMs Start time (in ms).
1280	* @param cMsTimeout Timeout value (in ms).
1281	*/
1282	static RTMSINTERVAL gctlRunGetRemainingTime(uint64_t u64StartMs, RTMSINTERVAL cMsTimeout)
1283	{
1284	if (!cMsTimeout \|\| cMsTimeout == RT_INDEFINITE_WAIT) /* If no timeout specified, wait forever. */
1285	return RT_INDEFINITE_WAIT;
1286
1287	uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
1288	if (u64ElapsedMs >= cMsTimeout)
1289	return 0;
1290
1291	return cMsTimeout - (RTMSINTERVAL)u64ElapsedMs;
1292	}
1293
1294	/**
1295	* Common handler for the 'run' and 'start' commands.
1296	*
1297	* @returns Command exit code.
1298	* @param pCtx Guest session context.
1299	* @param argc The argument count.
1300	* @param argv The argument vector for this command.
1301	* @param fRunCmd Set if it's 'run' clear if 'start'.
1302	* @param fHelp The help flag for the command.
1303	*/
1304	static RTEXITCODE gctlHandleRunCommon(PGCTLCMDCTX pCtx, int argc, char **argv, bool fRunCmd, uint32_t fHelp)
1305	{
1306	RT_NOREF(fHelp);
1307	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1308
1309	/*
1310	* Parse arguments.
1311	*/
1312	enum kGstCtrlRunOpt
1313	{
1314	kGstCtrlRunOpt_IgnoreOrphanedProcesses = 1000,
1315	kGstCtrlRunOpt_NoProfile, /** @todo Deprecated and will be removed soon; use kGstCtrlRunOpt_Profile instead, if needed. */
1316	kGstCtrlRunOpt_Profile,
1317	kGstCtrlRunOpt_Dos2Unix,
1318	kGstCtrlRunOpt_Unix2Dos,
1319	kGstCtrlRunOpt_WaitForStdOut,
1320	kGstCtrlRunOpt_NoWaitForStdOut,
1321	kGstCtrlRunOpt_WaitForStdErr,
1322	kGstCtrlRunOpt_NoWaitForStdErr
1323	};
1324	static const RTGETOPTDEF s_aOptions[] =
1325	{
1326	GCTLCMD_COMMON_OPTION_DEFS()
1327	{ "--putenv", 'E', RTGETOPT_REQ_STRING },
1328	{ "--exe", 'e', RTGETOPT_REQ_STRING },
1329	{ "--timeout", 't', RTGETOPT_REQ_UINT32 },
1330	{ "--unquoted-args", 'u', RTGETOPT_REQ_NOTHING },
1331	{ "--ignore-operhaned-processes", kGstCtrlRunOpt_IgnoreOrphanedProcesses, RTGETOPT_REQ_NOTHING },
1332	{ "--no-profile", kGstCtrlRunOpt_NoProfile, RTGETOPT_REQ_NOTHING }, /** @todo Deprecated. */
1333	{ "--profile", kGstCtrlRunOpt_Profile, RTGETOPT_REQ_NOTHING },
1334	/* run only: 6 - options */
1335	{ "--dos2unix", kGstCtrlRunOpt_Dos2Unix, RTGETOPT_REQ_NOTHING },
1336	{ "--unix2dos", kGstCtrlRunOpt_Unix2Dos, RTGETOPT_REQ_NOTHING },
1337	{ "--no-wait-stdout", kGstCtrlRunOpt_NoWaitForStdOut, RTGETOPT_REQ_NOTHING },
1338	{ "--wait-stdout", kGstCtrlRunOpt_WaitForStdOut, RTGETOPT_REQ_NOTHING },
1339	{ "--no-wait-stderr", kGstCtrlRunOpt_NoWaitForStdErr, RTGETOPT_REQ_NOTHING },
1340	{ "--wait-stderr", kGstCtrlRunOpt_WaitForStdErr, RTGETOPT_REQ_NOTHING },
1341	};
1342
1343	/** @todo stdin handling. */
1344
1345	int ch;
1346	RTGETOPTUNION ValueUnion;
1347	RTGETOPTSTATE GetState;
1348	int vrc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions) - (fRunCmd ? 0 : 6),
1349	1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1350	AssertRC(vrc);
1351
1352	com::SafeArray<ProcessCreateFlag_T> aCreateFlags;
1353	com::SafeArray<ProcessWaitForFlag_T> aWaitFlags;
1354	com::SafeArray<IN_BSTR> aArgs;
1355	com::SafeArray<IN_BSTR> aEnv;
1356	const char * pszImage = NULL;
1357	bool fWaitForStdOut = fRunCmd;
1358	bool fWaitForStdErr = fRunCmd;
1359	RTVFSIOSTREAM hVfsStdOut = NIL_RTVFSIOSTREAM;
1360	RTVFSIOSTREAM hVfsStdErr = NIL_RTVFSIOSTREAM;
1361	enum kStreamTransform enmStdOutTransform = kStreamTransform_None;
1362	enum kStreamTransform enmStdErrTransform = kStreamTransform_None;
1363	RTMSINTERVAL cMsTimeout = 0;
1364
1365	try
1366	{
1367	/* Wait for process start in any case. This is useful for scripting VBoxManage
1368	* when relying on its overall exit code. */
1369	aWaitFlags.push_back(ProcessWaitForFlag_Start);
1370
1371	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1372	{
1373	/* For options that require an argument, ValueUnion has received the value. */
1374	switch (ch)
1375	{
1376	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1377
1378	case 'E':
1379	if ( ValueUnion.psz[0] == '\0'
1380	\|\| ValueUnion.psz[0] == '=')
1381	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN,
1382	"Invalid argument variable[=value]: '%s'", ValueUnion.psz);
1383	aEnv.push_back(Bstr(ValueUnion.psz).raw());
1384	break;
1385
1386	case kGstCtrlRunOpt_IgnoreOrphanedProcesses:
1387	aCreateFlags.push_back(ProcessCreateFlag_IgnoreOrphanedProcesses);
1388	break;
1389
1390	case kGstCtrlRunOpt_NoProfile:
1391	/** @todo Deprecated, will be removed. */
1392	RTPrintf("Warning: Deprecated option \"--no-profile\" specified\n");
1393	break;
1394
1395	case kGstCtrlRunOpt_Profile:
1396	aCreateFlags.push_back(ProcessCreateFlag_Profile);
1397	break;
1398
1399	case 'e':
1400	pszImage = ValueUnion.psz;
1401	break;
1402
1403	case 'u':
1404	aCreateFlags.push_back(ProcessCreateFlag_UnquotedArguments);
1405	break;
1406
1407	/** @todo Add a hidden flag. */
1408
1409	case 't': /* Timeout */
1410	cMsTimeout = ValueUnion.u32;
1411	break;
1412
1413	/* run only options: */
1414	case kGstCtrlRunOpt_Dos2Unix:
1415	Assert(fRunCmd);
1416	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Dos2Unix;
1417	break;
1418	case kGstCtrlRunOpt_Unix2Dos:
1419	Assert(fRunCmd);
1420	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Unix2Dos;
1421	break;
1422
1423	case kGstCtrlRunOpt_WaitForStdOut:
1424	Assert(fRunCmd);
1425	fWaitForStdOut = true;
1426	break;
1427	case kGstCtrlRunOpt_NoWaitForStdOut:
1428	Assert(fRunCmd);
1429	fWaitForStdOut = false;
1430	break;
1431
1432	case kGstCtrlRunOpt_WaitForStdErr:
1433	Assert(fRunCmd);
1434	fWaitForStdErr = true;
1435	break;
1436	case kGstCtrlRunOpt_NoWaitForStdErr:
1437	Assert(fRunCmd);
1438	fWaitForStdErr = false;
1439	break;
1440
1441	case VINF_GETOPT_NOT_OPTION:
1442	aArgs.push_back(Bstr(ValueUnion.psz).raw());
1443	if (!pszImage)
1444	{
1445	Assert(aArgs.size() == 1);
1446	pszImage = ValueUnion.psz;
1447	}
1448	break;
1449
1450	default:
1451	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, ch, &ValueUnion);
1452
1453	} /* switch */
1454	} /* while RTGetOpt */
1455
1456	/* Must have something to execute. */
1457	if (!pszImage \|\| !*pszImage)
1458	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, "No executable specified!");
1459
1460	/*
1461	* Finalize process creation and wait flags and input/output streams.
1462	*/
1463	if (!fRunCmd)
1464	{
1465	aCreateFlags.push_back(ProcessCreateFlag_WaitForProcessStartOnly);
1466	Assert(!fWaitForStdOut);
1467	Assert(!fWaitForStdErr);
1468	}
1469	else
1470	{
1471	aWaitFlags.push_back(ProcessWaitForFlag_Terminate);
1472	fWaitForStdOut = gctlRunSetupHandle(fWaitForStdOut, RTHANDLESTD_OUTPUT, "stdout", enmStdOutTransform, &hVfsStdOut);
1473	if (fWaitForStdOut)
1474	{
1475	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdOut);
1476	aWaitFlags.push_back(ProcessWaitForFlag_StdOut);
1477	}
1478	fWaitForStdErr = gctlRunSetupHandle(fWaitForStdErr, RTHANDLESTD_ERROR, "stderr", enmStdErrTransform, &hVfsStdErr);
1479	if (fWaitForStdErr)
1480	{
1481	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdErr);
1482	aWaitFlags.push_back(ProcessWaitForFlag_StdErr);
1483	}
1484	}
1485	}
1486	catch (std::bad_alloc &)
1487	{
1488	return RTMsgErrorExit(RTEXITCODE_FAILURE, "VERR_NO_MEMORY\n");
1489	}
1490
1491	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1492	if (rcExit != RTEXITCODE_SUCCESS)
1493	return rcExit;
1494
1495	HRESULT rc;
1496
1497	try
1498	{
1499	do
1500	{
1501	/* Get current time stamp to later calculate rest of timeout left. */
1502	uint64_t msStart = RTTimeMilliTS();
1503
1504	/*
1505	* Create the process.
1506	*/
1507	if (pCtx->cVerbose)
1508	{
1509	if (cMsTimeout == 0)
1510	RTPrintf("Starting guest process ...\n");
1511	else
1512	RTPrintf("Starting guest process (within %ums)\n", cMsTimeout);
1513	}
1514	ComPtr<IGuestProcess> pProcess;
1515	CHECK_ERROR_BREAK(pCtx->pGuestSession, ProcessCreate(Bstr(pszImage).raw(),
1516	ComSafeArrayAsInParam(aArgs),
1517	ComSafeArrayAsInParam(aEnv),
1518	ComSafeArrayAsInParam(aCreateFlags),
1519	gctlRunGetRemainingTime(msStart, cMsTimeout),
1520	pProcess.asOutParam()));
1521
1522	/*
1523	* Explicitly wait for the guest process to be in a started state.
1524	*/
1525	com::SafeArray<ProcessWaitForFlag_T> aWaitStartFlags;
1526	aWaitStartFlags.push_back(ProcessWaitForFlag_Start);
1527	ProcessWaitResult_T waitResult;
1528	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitStartFlags),
1529	gctlRunGetRemainingTime(msStart, cMsTimeout), &waitResult));
1530
1531	ULONG uPID = 0;
1532	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
1533	if (fRunCmd && pCtx->cVerbose)
1534	RTPrintf("Process '%s' (PID %RU32) started\n", pszImage, uPID);
1535	else if (!fRunCmd && pCtx->cVerbose)
1536	{
1537	/* Just print plain PID to make it easier for scripts
1538	* invoking VBoxManage. */
1539	RTPrintf("[%RU32 - Session %RU32]\n", uPID, pCtx->uSessionID);
1540	}
1541
1542	/*
1543	* Wait for process to exit/start...
1544	*/
1545	RTMSINTERVAL cMsTimeLeft = 1; /* Will be calculated. */
1546	bool fReadStdOut = false;
1547	bool fReadStdErr = false;
1548	bool fCompleted = false;
1549	bool fCompletedStartCmd = false;
1550
1551	vrc = VINF_SUCCESS;
1552	while ( !fCompleted
1553	&& cMsTimeLeft > 0)
1554	{
1555	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1556	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitFlags),
1557	RT_MIN(500 /ms/, RT_MAX(cMsTimeLeft, 1 /ms/)),
1558	&waitResult));
1559	switch (waitResult)
1560	{
1561	case ProcessWaitResult_Start:
1562	fCompletedStartCmd = fCompleted = !fRunCmd; /* Only wait for startup if the 'start' command. */
1563	break;
1564	case ProcessWaitResult_StdOut:
1565	fReadStdOut = true;
1566	break;
1567	case ProcessWaitResult_StdErr:
1568	fReadStdErr = true;
1569	break;
1570	case ProcessWaitResult_Terminate:
1571	if (pCtx->cVerbose)
1572	RTPrintf("Process terminated\n");
1573	/* Process terminated, we're done. */
1574	fCompleted = true;
1575	break;
1576	case ProcessWaitResult_WaitFlagNotSupported:
1577	/* The guest does not support waiting for stdout/err, so
1578	* yield to reduce the CPU load due to busy waiting. */
1579	RTThreadYield();
1580	fReadStdOut = fReadStdErr = true;
1581	break;
1582	case ProcessWaitResult_Timeout:
1583	{
1584	/** @todo It is really unclear whether we will get stuck with the timeout
1585	* result here if the guest side times out the process and fails to
1586	* kill the process... To be on the save side, double the IPC and
1587	* check the process status every time we time out. */
1588	ProcessStatus_T enmProcStatus;
1589	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&enmProcStatus));
1590	if ( enmProcStatus == ProcessStatus_TimedOutKilled
1591	\|\| enmProcStatus == ProcessStatus_TimedOutAbnormally)
1592	fCompleted = true;
1593	fReadStdOut = fReadStdErr = true;
1594	break;
1595	}
1596	case ProcessWaitResult_Status:
1597	/* ignore. */
1598	break;
1599	case ProcessWaitResult_Error:
1600	/* waitFor is dead in the water, I think, so better leave the loop. */
1601	vrc = VERR_CALLBACK_RETURN;
1602	break;
1603
1604	case ProcessWaitResult_StdIn: AssertFailed(); /* did ask for this! */ break;
1605	case ProcessWaitResult_None: AssertFailed(); /* used. */ break;
1606	default: AssertFailed(); /* huh? */ break;
1607	}
1608
1609	if (g_fGuestCtrlCanceled)
1610	break;
1611
1612	/*
1613	* Pump output as needed.
1614	*/
1615	if (fReadStdOut)
1616	{
1617	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1618	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdOut, 1 /* StdOut */, cMsTimeLeft);
1619	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1620	vrc = vrc2;
1621	fReadStdOut = false;
1622	}
1623	if (fReadStdErr)
1624	{
1625	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1626	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdErr, 2 /* StdErr */, cMsTimeLeft);
1627	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1628	vrc = vrc2;
1629	fReadStdErr = false;
1630	}
1631	if ( RT_FAILURE(vrc)
1632	\|\| g_fGuestCtrlCanceled)
1633	break;
1634
1635	/*
1636	* Process events before looping.
1637	*/
1638	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
1639	} /* while */
1640
1641	/*
1642	* Report status back to the user.
1643	*/
1644	if (g_fGuestCtrlCanceled)
1645	{
1646	if (pCtx->cVerbose)
1647	RTPrintf("Process execution aborted!\n");
1648	rcExit = EXITCODEEXEC_CANCELED;
1649	}
1650	else if (fCompletedStartCmd)
1651	{
1652	if (pCtx->cVerbose)
1653	RTPrintf("Process successfully started!\n");
1654	rcExit = RTEXITCODE_SUCCESS;
1655	}
1656	else if (fCompleted)
1657	{
1658	ProcessStatus_T procStatus;
1659	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&procStatus));
1660	if ( procStatus == ProcessStatus_TerminatedNormally
1661	\|\| procStatus == ProcessStatus_TerminatedAbnormally
1662	\|\| procStatus == ProcessStatus_TerminatedSignal)
1663	{
1664	LONG lExitCode;
1665	CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode));
1666	if (pCtx->cVerbose)
1667	RTPrintf("Exit code=%u (Status=%u [%s])\n",
1668	lExitCode, procStatus, gctlProcessStatusToText(procStatus));
1669
1670	rcExit = gctlRunCalculateExitCode(procStatus, lExitCode, true /fReturnExitCodes/);
1671	}
1672	else if ( procStatus == ProcessStatus_TimedOutKilled
1673	\|\| procStatus == ProcessStatus_TimedOutAbnormally)
1674	{
1675	if (pCtx->cVerbose)
1676	RTPrintf("Process timed out (guest side) and %s\n",
1677	procStatus == ProcessStatus_TimedOutAbnormally
1678	? "failed to terminate so far" : "was terminated");
1679	rcExit = EXITCODEEXEC_TIMEOUT;
1680	}
1681	else
1682	{
1683	if (pCtx->cVerbose)
1684	RTPrintf("Process now is in status [%s] (unexpected)\n", gctlProcessStatusToText(procStatus));
1685	rcExit = RTEXITCODE_FAILURE;
1686	}
1687	}
1688	else if (RT_FAILURE_NP(vrc))
1689	{
1690	if (pCtx->cVerbose)
1691	RTPrintf("Process monitor loop quit with vrc=%Rrc\n", vrc);
1692	rcExit = RTEXITCODE_FAILURE;
1693	}
1694	else
1695	{
1696	if (pCtx->cVerbose)
1697	RTPrintf("Process monitor loop timed out\n");
1698	rcExit = EXITCODEEXEC_TIMEOUT;
1699	}
1700
1701	} while (0);
1702	}
1703	catch (std::bad_alloc)
1704	{
1705	rc = E_OUTOFMEMORY;
1706	}
1707
1708	/*
1709	* Decide what to do with the guest session.
1710	*
1711	* If it's the 'start' command where detach the guest process after
1712	* starting, don't close the guest session it is part of, except on
1713	* failure or ctrl-c.
1714	*
1715	* For the 'run' command the guest process quits with us.
1716	*/
1717	if (!fRunCmd && SUCCEEDED(rc) && !g_fGuestCtrlCanceled)
1718	pCtx->fDetachGuestSession = true;
1719
1720	/* Make sure we return failure on failure. */
1721	if (FAILED(rc) && rcExit == RTEXITCODE_SUCCESS)
1722	rcExit = RTEXITCODE_FAILURE;
1723	return rcExit;
1724	}
1725
1726
1727	static DECLCALLBACK(RTEXITCODE) gctlHandleRun(PGCTLCMDCTX pCtx, int argc, char **argv)
1728	{
1729	return gctlHandleRunCommon(pCtx, argc, argv, true /fRunCmd/, USAGE_GSTCTRL_RUN);
1730	}
1731
1732
1733	static DECLCALLBACK(RTEXITCODE) gctlHandleStart(PGCTLCMDCTX pCtx, int argc, char **argv)
1734	{
1735	return gctlHandleRunCommon(pCtx, argc, argv, false /fRunCmd/, USAGE_GSTCTRL_START);
1736	}
1737
1738
1739	/** bird: This is just a code conversion tool, flags are better defined by
1740	* the preprocessor, in general. But the code was using obsoleted
1741	* main flags for internal purposes (in a uint32_t) without passing them
1742	* along, or it seemed that way. Enum means compiler checks types. */
1743	enum gctlCopyFlags
1744	{
1745	kGctlCopyFlags_None = 0,
1746	kGctlCopyFlags_Recursive = RT_BIT(1),
1747	kGctlCopyFlags_FollowLinks = RT_BIT(2)
1748	};
1749
1750
1751	/**
1752	* Creates a copy context structure which then can be used with various
1753	* guest control copy functions. Needs to be free'd with gctlCopyContextFree().
1754	*
1755	* @return IPRT status code.
1756	* @param pCtx Pointer to command context.
1757	* @param fDryRun Flag indicating if we want to run a dry run only.
1758	* @param fHostToGuest Flag indicating if we want to copy from host to guest
1759	* or vice versa.
1760	* @param strSessionName Session name (only for identification purposes).
1761	* @param ppContext Pointer which receives the allocated copy context.
1762	*/
1763	static int gctlCopyContextCreate(PGCTLCMDCTX pCtx, bool fDryRun, bool fHostToGuest,
1764	const Utf8Str &strSessionName,
1765	PCOPYCONTEXT *ppContext)
1766	{
1767	RT_NOREF(strSessionName);
1768	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1769
1770	int vrc = VINF_SUCCESS;
1771	try
1772	{
1773	PCOPYCONTEXT pContext = new COPYCONTEXT();
1774
1775	pContext->pCmdCtx = pCtx;
1776	pContext->fDryRun = fDryRun;
1777	pContext->fHostToGuest = fHostToGuest;
1778
1779	*ppContext = pContext;
1780	}
1781	catch (std::bad_alloc)
1782	{
1783	vrc = VERR_NO_MEMORY;
1784	}
1785
1786	return vrc;
1787	}
1788
1789	/**
1790	* Frees are previously allocated copy context structure.
1791	*
1792	* @param pContext Pointer to copy context to free.
1793	*/
1794	static void gctlCopyContextFree(PCOPYCONTEXT pContext)
1795	{
1796	if (pContext)
1797	delete pContext;
1798	}
1799
1800	/**
1801	* Translates a source path to a destination path (can be both sides,
1802	* either host or guest). The source root is needed to determine the start
1803	* of the relative source path which also needs to present in the destination
1804	* path.
1805	*
1806	* @return IPRT status code.
1807	* @param pszSourceRoot Source root path. No trailing directory slash!
1808	* @param pszSource Actual source to transform. Must begin with
1809	* the source root path!
1810	* @param pszDest Destination path.
1811	* @param ppszTranslated Pointer to the allocated, translated destination
1812	* path. Must be free'd with RTStrFree().
1813	*/
1814	static int gctlCopyTranslatePath(const char pszSourceRoot, const char pszSource,
1815	const char pszDest, char *ppszTranslated)
1816	{
1817	AssertPtrReturn(pszSourceRoot, VERR_INVALID_POINTER);
1818	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
1819	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
1820	AssertPtrReturn(ppszTranslated, VERR_INVALID_POINTER);
1821	#if 0 /** @todo r=bird: It does not make sense to apply host path parsing semantics onto guest paths. I hope this code isn't mixing host/guest paths in the same way anywhere else... @bugref{6344} */
1822	AssertReturn(RTPathStartsWith(pszSource, pszSourceRoot), VERR_INVALID_PARAMETER);
1823	#endif
1824
1825	/* Construct the relative dest destination path by "subtracting" the
1826	* source from the source root, e.g.
1827	*
1828	* source root path = "e:\foo\", source = "e:\foo\bar"
1829	* dest = "d:\baz\"
1830	* translated = "d:\baz\bar\"
1831	*/
1832	char szTranslated[RTPATH_MAX];
1833	size_t srcOff = strlen(pszSourceRoot);
1834	AssertReturn(srcOff, VERR_INVALID_PARAMETER);
1835
1836	char *pszDestPath = RTStrDup(pszDest);
1837	AssertPtrReturn(pszDestPath, VERR_NO_MEMORY);
1838
1839	int vrc;
1840	if (!RTPathFilename(pszDestPath))
1841	{
1842	vrc = RTPathJoin(szTranslated, sizeof(szTranslated),
1843	pszDestPath, &pszSource[srcOff]);
1844	}
1845	else
1846	{
1847	char *pszDestFileName = RTStrDup(RTPathFilename(pszDestPath));
1848	if (pszDestFileName)
1849	{
1850	RTPathStripFilename(pszDestPath);
1851	vrc = RTPathJoin(szTranslated, sizeof(szTranslated),
1852	pszDestPath, pszDestFileName);
1853	RTStrFree(pszDestFileName);
1854	}
1855	else
1856	vrc = VERR_NO_MEMORY;
1857	}
1858	RTStrFree(pszDestPath);
1859
1860	if (RT_SUCCESS(vrc))
1861	{
1862	*ppszTranslated = RTStrDup(szTranslated);
1863	#if 0
1864	RTPrintf("Root: %s, Source: %s, Dest: %s, Translated: %s\n",
1865	pszSourceRoot, pszSource, pszDest, *ppszTranslated);
1866	#endif
1867	}
1868	return vrc;
1869	}
1870
1871	#ifdef DEBUG_andy_disabled
1872	static int tstTranslatePath()
1873	{
1874	RTAssertSetMayPanic(false /* Do not freak out, please. */);
1875
1876	static struct
1877	{
1878	const char *pszSourceRoot;
1879	const char *pszSource;
1880	const char *pszDest;
1881	const char *pszTranslated;
1882	int iResult;
1883	} aTests[] =
1884	{
1885	/* Invalid stuff. */
1886	{ NULL, NULL, NULL, NULL, VERR_INVALID_POINTER },
1887	#ifdef RT_OS_WINDOWS
1888	/* Windows paths. */
1889	{ "c:\\foo", "c:\\foo\\bar.txt", "c:\\test", "c:\\test\\bar.txt", VINF_SUCCESS },
1890	{ "c:\\foo", "c:\\foo\\baz\\bar.txt", "c:\\test", "c:\\test\\baz\\bar.txt", VINF_SUCCESS },
1891	#else /* RT_OS_WINDOWS */
1892	{ "/home/test/foo", "/home/test/foo/bar.txt", "/opt/test", "/opt/test/bar.txt", VINF_SUCCESS },
1893	{ "/home/test/foo", "/home/test/foo/baz/bar.txt", "/opt/test", "/opt/test/baz/bar.txt", VINF_SUCCESS },
1894	#endif /* !RT_OS_WINDOWS */
1895	/* Mixed paths*/
1896	/** @todo */
1897	{ NULL }
1898	};
1899
1900	size_t iTest = 0;
1901	for (iTest; iTest < RT_ELEMENTS(aTests); iTest++)
1902	{
1903	RTPrintf("=> Test %d\n", iTest);
1904	RTPrintf("\tSourceRoot=%s, Source=%s, Dest=%s\n",
1905	aTests[iTest].pszSourceRoot, aTests[iTest].pszSource, aTests[iTest].pszDest);
1906
1907	char *pszTranslated = NULL;
1908	int iResult = gctlCopyTranslatePath(aTests[iTest].pszSourceRoot, aTests[iTest].pszSource,
1909	aTests[iTest].pszDest, &pszTranslated);
1910	if (iResult != aTests[iTest].iResult)
1911	{
1912	RTPrintf("\tReturned %Rrc, expected %Rrc\n",
1913	iResult, aTests[iTest].iResult);
1914	}
1915	else if ( pszTranslated
1916	&& strcmp(pszTranslated, aTests[iTest].pszTranslated))
1917	{
1918	RTPrintf("\tReturned translated path %s, expected %s\n",
1919	pszTranslated, aTests[iTest].pszTranslated);
1920	}
1921
1922	if (pszTranslated)
1923	{
1924	RTPrintf("\tTranslated=%s\n", pszTranslated);
1925	RTStrFree(pszTranslated);
1926	}
1927	}
1928
1929	return VINF_SUCCESS; /** @todo */
1930	}
1931	#endif
1932
1933	/**
1934	* Creates a directory on the destination, based on the current copy
1935	* context.
1936	*
1937	* @return IPRT status code.
1938	* @param pContext Pointer to current copy control context.
1939	* @param pszDir Directory to create.
1940	*/
1941	static int gctlCopyDirCreate(PCOPYCONTEXT pContext, const char *pszDir)
1942	{
1943	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
1944	AssertPtrReturn(pszDir, VERR_INVALID_POINTER);
1945
1946	bool fDirExists;
1947	int vrc = gctlCopyDirExists(pContext, pContext->fHostToGuest, pszDir, &fDirExists);
1948	if ( RT_SUCCESS(vrc)
1949	&& fDirExists)
1950	{
1951	if (pContext->pCmdCtx->cVerbose)
1952	RTPrintf("Directory \"%s\" already exists\n", pszDir);
1953	return VINF_SUCCESS;
1954	}
1955
1956	/* If querying for a directory existence fails there's no point of even trying
1957	* to create such a directory. */
1958	if (RT_FAILURE(vrc))
1959	return vrc;
1960
1961	if (pContext->pCmdCtx->cVerbose)
1962	RTPrintf("Creating directory \"%s\" ...\n", pszDir);
1963
1964	if (pContext->fDryRun)
1965	return VINF_SUCCESS;
1966
1967	if (pContext->fHostToGuest) /* We want to create directories on the guest. */
1968	{
1969	SafeArray<DirectoryCreateFlag_T> dirCreateFlags;
1970	dirCreateFlags.push_back(DirectoryCreateFlag_Parents);
1971	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryCreate(Bstr(pszDir).raw(),
1972	0700, ComSafeArrayAsInParam(dirCreateFlags));
1973	if (FAILED(rc))
1974	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
1975	}
1976	else /* ... or on the host. */
1977	{
1978	vrc = RTDirCreateFullPath(pszDir, 0700);
1979	if (vrc == VERR_ALREADY_EXISTS)
1980	vrc = VINF_SUCCESS;
1981	}
1982	return vrc;
1983	}
1984
1985	/**
1986	* Checks whether a specific host/guest directory exists.
1987	*
1988	* @return IPRT status code.
1989	* @param pContext Pointer to current copy control context.
1990	* @param fOnGuest true if directory needs to be checked on the guest
1991	* or false if on the host.
1992	* @param pszDir Actual directory to check.
1993	* @param fExists Pointer which receives the result if the
1994	* given directory exists or not.
1995	*/
1996	static int gctlCopyDirExists(PCOPYCONTEXT pContext, bool fOnGuest,
1997	const char pszDir, bool fExists)
1998	{
1999	AssertPtrReturn(pContext, false);
2000	AssertPtrReturn(pszDir, false);
2001	AssertPtrReturn(fExists, false);
2002
2003	int vrc = VINF_SUCCESS;
2004	if (fOnGuest)
2005	{
2006	BOOL fDirExists = FALSE;
2007	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryExists(Bstr(pszDir).raw(), FALSE /followSymlinks/, &fDirExists);
2008	if (SUCCEEDED(rc))
2009	*fExists = fDirExists != FALSE;
2010	else
2011	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2012	}
2013	else
2014	*fExists = RTDirExists(pszDir);
2015	return vrc;
2016	}
2017
2018	#if 0 /* unused */
2019	/**
2020	* Checks whether a specific directory exists on the destination, based
2021	* on the current copy context.
2022	*
2023	* @return IPRT status code.
2024	* @param pContext Pointer to current copy control context.
2025	* @param pszDir Actual directory to check.
2026	* @param fExists Pointer which receives the result if the
2027	* given directory exists or not.
2028	*/
2029	static int gctlCopyDirExistsOnDest(PCOPYCONTEXT pContext, const char *pszDir,
2030	bool *fExists)
2031	{
2032	return gctlCopyDirExists(pContext, pContext->fHostToGuest,
2033	pszDir, fExists);
2034	}
2035	#endif /* unused */
2036
2037	/**
2038	* Checks whether a specific directory exists on the source, based
2039	* on the current copy context.
2040	*
2041	* @return IPRT status code.
2042	* @param pContext Pointer to current copy control context.
2043	* @param pszDir Actual directory to check.
2044	* @param fExists Pointer which receives the result if the
2045	* given directory exists or not.
2046	*/
2047	static int gctlCopyDirExistsOnSource(PCOPYCONTEXT pContext, const char *pszDir,
2048	bool *fExists)
2049	{
2050	return gctlCopyDirExists(pContext, !pContext->fHostToGuest,
2051	pszDir, fExists);
2052	}
2053
2054	/**
2055	* Checks whether a specific host/guest file exists.
2056	*
2057	* @return IPRT status code.
2058	* @param pContext Pointer to current copy control context.
2059	* @param bGuest true if file needs to be checked on the guest
2060	* or false if on the host.
2061	* @param pszFile Actual file to check.
2062	* @param fExists Pointer which receives the result if the
2063	* given file exists or not.
2064	*/
2065	static int gctlCopyFileExists(PCOPYCONTEXT pContext, bool bOnGuest,
2066	const char pszFile, bool fExists)
2067	{
2068	AssertPtrReturn(pContext, false);
2069	AssertPtrReturn(pszFile, false);
2070	AssertPtrReturn(fExists, false);
2071
2072	int vrc = VINF_SUCCESS;
2073	if (bOnGuest)
2074	{
2075	BOOL fFileExists = FALSE;
2076	HRESULT rc = pContext->pCmdCtx->pGuestSession->FileExists(Bstr(pszFile).raw(), FALSE /followSymlinks/, &fFileExists);
2077	if (SUCCEEDED(rc))
2078	*fExists = fFileExists != FALSE;
2079	else
2080	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2081	}
2082	else
2083	*fExists = RTFileExists(pszFile);
2084	return vrc;
2085	}
2086
2087	#if 0 /* unused */
2088	/**
2089	* Checks whether a specific file exists on the destination, based on the
2090	* current copy context.
2091	*
2092	* @return IPRT status code.
2093	* @param pContext Pointer to current copy control context.
2094	* @param pszFile Actual file to check.
2095	* @param fExists Pointer which receives the result if the
2096	* given file exists or not.
2097	*/
2098	static int gctlCopyFileExistsOnDest(PCOPYCONTEXT pContext, const char *pszFile,
2099	bool *fExists)
2100	{
2101	return gctlCopyFileExists(pContext, pContext->fHostToGuest,
2102	pszFile, fExists);
2103	}
2104	#endif /* unused */
2105
2106	/**
2107	* Checks whether a specific file exists on the source, based on the
2108	* current copy context.
2109	*
2110	* @return IPRT status code.
2111	* @param pContext Pointer to current copy control context.
2112	* @param pszFile Actual file to check.
2113	* @param fExists Pointer which receives the result if the
2114	* given file exists or not.
2115	*/
2116	static int gctlCopyFileExistsOnSource(PCOPYCONTEXT pContext, const char *pszFile,
2117	bool *fExists)
2118	{
2119	return gctlCopyFileExists(pContext, !pContext->fHostToGuest,
2120	pszFile, fExists);
2121	}
2122
2123	/**
2124	* Copies a source file to the destination.
2125	*
2126	* @return IPRT status code.
2127	* @param pContext Pointer to current copy control context.
2128	* @param pszFileSource Source file to copy to the destination.
2129	* @param pszFileDest Name of copied file on the destination.
2130	* @param enmFlags Copy flags. No supported at the moment and
2131	* needs to be set to 0.
2132	*/
2133	static int gctlCopyFileToDest(PCOPYCONTEXT pContext, const char *pszFileSource,
2134	const char *pszFileDest, gctlCopyFlags enmFlags)
2135	{
2136	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2137	AssertPtrReturn(pszFileSource, VERR_INVALID_POINTER);
2138	AssertPtrReturn(pszFileDest, VERR_INVALID_POINTER);
2139	AssertReturn(enmFlags == kGctlCopyFlags_None, VERR_INVALID_PARAMETER); /* No flags supported yet. */
2140
2141	if (pContext->pCmdCtx->cVerbose)
2142	RTPrintf("Copying \"%s\" to \"%s\" ...\n", pszFileSource, pszFileDest);
2143
2144	if (pContext->fDryRun)
2145	return VINF_SUCCESS;
2146
2147	int vrc = VINF_SUCCESS;
2148	ComPtr<IProgress> pProgress;
2149	HRESULT rc;
2150	if (pContext->fHostToGuest)
2151	{
2152	SafeArray<FileCopyFlag_T> copyFlags;
2153	rc = pContext->pCmdCtx->pGuestSession->FileCopyToGuest(Bstr(pszFileSource).raw(), Bstr(pszFileDest).raw(),
2154	ComSafeArrayAsInParam(copyFlags),
2155	pProgress.asOutParam());
2156	}
2157	else
2158	{
2159	SafeArray<FileCopyFlag_T> copyFlags;
2160	rc = pContext->pCmdCtx->pGuestSession->FileCopyFromGuest(Bstr(pszFileSource).raw(), Bstr(pszFileDest).raw(),
2161	ComSafeArrayAsInParam(copyFlags),
2162	pProgress.asOutParam());
2163	}
2164
2165	if (FAILED(rc))
2166	{
2167	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2168	}
2169	else
2170	{
2171	if (pContext->pCmdCtx->cVerbose)
2172	rc = showProgress(pProgress);
2173	else
2174	rc = pProgress->WaitForCompletion(-1 /* No timeout */);
2175	if (SUCCEEDED(rc))
2176	CHECK_PROGRESS_ERROR(pProgress, ("File copy failed"));
2177	vrc = gctlPrintProgressError(pProgress);
2178	}
2179
2180	return vrc;
2181	}
2182
2183	/**
2184	* Copys a directory (tree) from host to the guest.
2185	*
2186	* @return IPRT status code.
2187	* @param pContext Pointer to current copy control context.
2188	* @param pszSource Source directory on the host to copy to the guest.
2189	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2190	* @param pszDest Destination directory on the guest.
2191	* @param enmFlags Copy flags, such as recursive copying.
2192	* @param pszSubDir Current sub directory to handle. Needs to NULL and only
2193	* is needed for recursion.
2194	*/
2195	static int gctlCopyDirToGuest(PCOPYCONTEXT pContext,
2196	const char pszSource, const char pszFilter,
2197	const char *pszDest, enum gctlCopyFlags enmFlags,
2198	const char pszSubDir / For recursion. */)
2199	{
2200	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2201	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2202	/* Filter is optional. */
2203	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
2204	/* Sub directory is optional. */
2205
2206	/*
2207	* Construct current path.
2208	*/
2209	char szCurDir[RTPATH_MAX];
2210	int vrc = RTStrCopy(szCurDir, sizeof(szCurDir), pszSource);
2211	if (RT_SUCCESS(vrc) && pszSubDir)
2212	vrc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
2213
2214	if (pContext->pCmdCtx->cVerbose)
2215	RTPrintf("Processing host directory: %s\n", szCurDir);
2216
2217	/* Flag indicating whether the current directory was created on the
2218	* target or not. */
2219	bool fDirCreated = false;
2220
2221	/*
2222	* Open directory without a filter - RTDirOpenFiltered unfortunately
2223	* cannot handle sub directories so we have to do the filtering ourselves.
2224	*/
2225	if (RT_SUCCESS(vrc))
2226	{
2227	RTDIR hDir;
2228	vrc = RTDirOpen(&hDir, szCurDir);
2229	if (RT_SUCCESS(vrc))
2230	{
2231	/*
2232	* Enumerate the directory tree.
2233	*/
2234	size_t cbDirEntry = 0;
2235	PRTDIRENTRYEX pDirEntry = NULL;
2236	while (RT_SUCCESS(vrc))
2237	{
2238	vrc = RTDirReadExA(hDir, &pDirEntry, &cbDirEntry, RTFSOBJATTRADD_NOTHING, 0);
2239	if (RT_FAILURE(vrc))
2240	{
2241	if (vrc == VERR_NO_MORE_FILES)
2242	vrc = VINF_SUCCESS;
2243	break;
2244	}
2245
2246	switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
2247	{
2248	case RTFS_TYPE_DIRECTORY:
2249	{
2250	/* Skip "." and ".." entries. */
2251	if (RTDirEntryExIsStdDotLink(pDirEntry))
2252	break;
2253
2254	if (pContext->pCmdCtx->cVerbose)
2255	RTPrintf("Directory: %s\n", pDirEntry->szName);
2256
2257	if (enmFlags & kGctlCopyFlags_Recursive)
2258	{
2259	char *pszNewSub = NULL;
2260	if (pszSubDir)
2261	pszNewSub = RTPathJoinA(pszSubDir, pDirEntry->szName);
2262	else
2263	{
2264	pszNewSub = RTStrDup(pDirEntry->szName);
2265	RTPathStripTrailingSlash(pszNewSub);
2266	}
2267
2268	if (pszNewSub)
2269	{
2270	vrc = gctlCopyDirToGuest(pContext,
2271	pszSource, pszFilter,
2272	pszDest, enmFlags, pszNewSub);
2273	RTStrFree(pszNewSub);
2274	}
2275	else
2276	vrc = VERR_NO_MEMORY;
2277	}
2278	break;
2279	}
2280
2281	case RTFS_TYPE_SYMLINK:
2282	if ( (enmFlags & kGctlCopyFlags_Recursive)
2283	&& (enmFlags & kGctlCopyFlags_FollowLinks))
2284	{ /* Fall through to next case is intentional. */ }
2285	else
2286	break;
2287	RT_FALL_THRU();
2288
2289	case RTFS_TYPE_FILE:
2290	{
2291	if ( pszFilter
2292	&& !RTStrSimplePatternMatch(pszFilter, pDirEntry->szName))
2293	{
2294	break; /* Filter does not match. */
2295	}
2296
2297	if (pContext->pCmdCtx->cVerbose)
2298	RTPrintf("File: %s\n", pDirEntry->szName);
2299
2300	if (!fDirCreated)
2301	{
2302	char *pszDestDir;
2303	vrc = gctlCopyTranslatePath(pszSource, szCurDir, pszDest, &pszDestDir);
2304	if (RT_SUCCESS(vrc))
2305	{
2306	vrc = gctlCopyDirCreate(pContext, pszDestDir);
2307	RTStrFree(pszDestDir);
2308
2309	fDirCreated = true;
2310	}
2311	}
2312
2313	if (RT_SUCCESS(vrc))
2314	{
2315	char *pszFileSource = RTPathJoinA(szCurDir, pDirEntry->szName);
2316	if (pszFileSource)
2317	{
2318	char *pszFileDest;
2319	vrc = gctlCopyTranslatePath(pszSource, pszFileSource, pszDest, &pszFileDest);
2320	if (RT_SUCCESS(vrc))
2321	{
2322	vrc = gctlCopyFileToDest(pContext, pszFileSource,
2323	pszFileDest, kGctlCopyFlags_None);
2324	RTStrFree(pszFileDest);
2325	}
2326	RTStrFree(pszFileSource);
2327	}
2328	}
2329	break;
2330	}
2331
2332	default:
2333	break;
2334	}
2335	if (RT_FAILURE(vrc))
2336	break;
2337	}
2338
2339	RTDirReadExAFree(&pDirEntry, &cbDirEntry);
2340	RTDirClose(hDir);
2341	}
2342	}
2343	return vrc;
2344	}
2345
2346	/**
2347	* Copys a directory (tree) from guest to the host.
2348	*
2349	* @return IPRT status code.
2350	* @param pContext Pointer to current copy control context.
2351	* @param pszSource Source directory on the guest to copy to the host.
2352	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2353	* @param pszDest Destination directory on the host.
2354	* @param enmFlags Copy flags, such as recursive copying.
2355	* @param pszSubDir Current sub directory to handle. Needs to NULL and only
2356	* is needed for recursion.
2357	*/
2358	static int gctlCopyDirToHost(PCOPYCONTEXT pContext,
2359	const char pszSource, const char pszFilter,
2360	const char *pszDest, gctlCopyFlags enmFlags,
2361	const char pszSubDir / For recursion. */)
2362	{
2363	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2364	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2365	/* Filter is optional. */
2366	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
2367	/* Sub directory is optional. */
2368
2369	/*
2370	* Construct current path.
2371	*/
2372	char szCurDir[RTPATH_MAX];
2373	int vrc = RTStrCopy(szCurDir, sizeof(szCurDir), pszSource);
2374	if (RT_SUCCESS(vrc) && pszSubDir)
2375	vrc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
2376
2377	if (RT_FAILURE(vrc))
2378	return vrc;
2379
2380	if (pContext->pCmdCtx->cVerbose)
2381	RTPrintf("Processing guest directory: %s\n", szCurDir);
2382
2383	/* Flag indicating whether the current directory was created on the
2384	* target or not. */
2385	bool fDirCreated = false;
2386	SafeArray<DirectoryOpenFlag_T> dirOpenFlags; /* No flags supported yet. */
2387	ComPtr<IGuestDirectory> pDirectory;
2388	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryOpen(Bstr(szCurDir).raw(), Bstr(pszFilter).raw(),
2389	ComSafeArrayAsInParam(dirOpenFlags),
2390	pDirectory.asOutParam());
2391	if (FAILED(rc))
2392	return gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2393	ComPtr<IFsObjInfo> dirEntry;
2394	while (true)
2395	{
2396	rc = pDirectory->Read(dirEntry.asOutParam());
2397	if (FAILED(rc))
2398	break;
2399
2400	FsObjType_T enmType;
2401	dirEntry->COMGETTER(Type)(&enmType);
2402
2403	Bstr strName;
2404	dirEntry->COMGETTER(Name)(strName.asOutParam());
2405
2406	switch (enmType)
2407	{
2408	case FsObjType_Directory:
2409	{
2410	Assert(!strName.isEmpty());
2411
2412	/* Skip "." and ".." entries. */
2413	if ( !strName.compare(Bstr("."))
2414	\|\| !strName.compare(Bstr("..")))
2415	break;
2416
2417	if (pContext->pCmdCtx->cVerbose)
2418	{
2419	Utf8Str strDir(strName);
2420	RTPrintf("Directory: %s\n", strDir.c_str());
2421	}
2422
2423	if (enmFlags & kGctlCopyFlags_Recursive)
2424	{
2425	Utf8Str strDir(strName);
2426	char *pszNewSub = NULL;
2427	if (pszSubDir)
2428	pszNewSub = RTPathJoinA(pszSubDir, strDir.c_str());
2429	else
2430	{
2431	pszNewSub = RTStrDup(strDir.c_str());
2432	RTPathStripTrailingSlash(pszNewSub);
2433	}
2434	if (pszNewSub)
2435	{
2436	vrc = gctlCopyDirToHost(pContext,
2437	pszSource, pszFilter,
2438	pszDest, enmFlags, pszNewSub);
2439	RTStrFree(pszNewSub);
2440	}
2441	else
2442	vrc = VERR_NO_MEMORY;
2443	}
2444	break;
2445	}
2446
2447	case FsObjType_Symlink:
2448	if ( (enmFlags & kGctlCopyFlags_Recursive)
2449	&& (enmFlags & kGctlCopyFlags_FollowLinks))
2450	{
2451	/* Fall through to next case is intentional. */
2452	}
2453	else
2454	break;
2455
2456	case FsObjType_File:
2457	{
2458	Assert(!strName.isEmpty());
2459
2460	Utf8Str strFile(strName);
2461	if ( pszFilter
2462	&& !RTStrSimplePatternMatch(pszFilter, strFile.c_str()))
2463	{
2464	break; /* Filter does not match. */
2465	}
2466
2467	if (pContext->pCmdCtx->cVerbose)
2468	RTPrintf("File: %s\n", strFile.c_str());
2469
2470	if (!fDirCreated)
2471	{
2472	char *pszDestDir;
2473	vrc = gctlCopyTranslatePath(pszSource, szCurDir,
2474	pszDest, &pszDestDir);
2475	if (RT_SUCCESS(vrc))
2476	{
2477	vrc = gctlCopyDirCreate(pContext, pszDestDir);
2478	RTStrFree(pszDestDir);
2479
2480	fDirCreated = true;
2481	}
2482	}
2483
2484	if (RT_SUCCESS(vrc))
2485	{
2486	char *pszFileSource = RTPathJoinA(szCurDir, strFile.c_str());
2487	if (pszFileSource)
2488	{
2489	char *pszFileDest;
2490	vrc = gctlCopyTranslatePath(pszSource, pszFileSource,
2491	pszDest, &pszFileDest);
2492	if (RT_SUCCESS(vrc))
2493	{
2494	vrc = gctlCopyFileToDest(pContext, pszFileSource,
2495	pszFileDest, kGctlCopyFlags_None);
2496	RTStrFree(pszFileDest);
2497	}
2498	RTStrFree(pszFileSource);
2499	}
2500	else
2501	vrc = VERR_NO_MEMORY;
2502	}
2503	break;
2504	}
2505
2506	default:
2507	RTPrintf("Warning: Directory entry of type %ld not handled, skipping ...\n",
2508	enmType);
2509	break;
2510	}
2511
2512	if (RT_FAILURE(vrc))
2513	break;
2514	}
2515
2516	if (RT_UNLIKELY(FAILED(rc)))
2517	{
2518	switch (rc)
2519	{
2520	case E_ABORT: /* No more directory entries left to process. */
2521	break;
2522
2523	case VBOX_E_FILE_ERROR: /* Current entry cannot be accessed to
2524	to missing rights. */
2525	{
2526	RTPrintf("Warning: Cannot access \"%s\", skipping ...\n",
2527	szCurDir);
2528	break;
2529	}
2530
2531	default:
2532	vrc = gctlPrintError(pDirectory, COM_IIDOF(IGuestDirectory));
2533	break;
2534	}
2535	}
2536
2537	HRESULT rc2 = pDirectory->Close();
2538	if (FAILED(rc2))
2539	{
2540	int vrc2 = gctlPrintError(pDirectory, COM_IIDOF(IGuestDirectory));
2541	if (RT_SUCCESS(vrc))
2542	vrc = vrc2;
2543	}
2544	else if (SUCCEEDED(rc))
2545	rc = rc2;
2546
2547	return vrc;
2548	}
2549
2550	/**
2551	* Copys a directory (tree) to the destination, based on the current copy
2552	* context.
2553	*
2554	* @return IPRT status code.
2555	* @param pContext Pointer to current copy control context.
2556	* @param pszSource Source directory to copy to the destination.
2557	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2558	* @param pszDest Destination directory where to copy in the source
2559	* source directory.
2560	* @param enmFlags Copy flags, such as recursive copying.
2561	*/
2562	static int gctlCopyDirToDest(PCOPYCONTEXT pContext,
2563	const char pszSource, const char pszFilter,
2564	const char *pszDest, enum gctlCopyFlags enmFlags)
2565	{
2566	if (pContext->fHostToGuest)
2567	return gctlCopyDirToGuest(pContext, pszSource, pszFilter,
2568	pszDest, enmFlags, NULL /* Sub directory, only for recursion. */);
2569	return gctlCopyDirToHost(pContext, pszSource, pszFilter,
2570	pszDest, enmFlags, NULL /* Sub directory, only for recursion. */);
2571	}
2572
2573	/**
2574	* Creates a source root by stripping file names or filters of the specified source.
2575	*
2576	* @return IPRT status code.
2577	* @param pszSource Source to create source root for.
2578	* @param ppszSourceRoot Pointer that receives the allocated source root. Needs
2579	* to be free'd with gctlCopyFreeSourceRoot().
2580	*/
2581	static int gctlCopyCreateSourceRoot(const char pszSource, char *ppszSourceRoot)
2582	{
2583	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2584	AssertPtrReturn(ppszSourceRoot, VERR_INVALID_POINTER);
2585
2586	char *pszNewRoot = RTStrDup(pszSource);
2587	if (!pszNewRoot)
2588	return VERR_NO_MEMORY;
2589
2590	size_t lenRoot = strlen(pszNewRoot);
2591	if ( lenRoot
2592	&& ( pszNewRoot[lenRoot - 1] == '/'
2593	\|\| pszNewRoot[lenRoot - 1] == '\\')
2594	)
2595	{
2596	pszNewRoot[lenRoot - 1] = '\0';
2597	}
2598
2599	if ( lenRoot > 1
2600	&& ( pszNewRoot[lenRoot - 2] == '/'
2601	\|\| pszNewRoot[lenRoot - 2] == '\\')
2602	)
2603	{
2604	pszNewRoot[lenRoot - 2] = '\0';
2605	}
2606
2607	if (!lenRoot)
2608	{
2609	/* If there's anything (like a file name or a filter),
2610	* strip it! */
2611	RTPathStripFilename(pszNewRoot);
2612	}
2613
2614	*ppszSourceRoot = pszNewRoot;
2615
2616	return VINF_SUCCESS;
2617	}
2618
2619	/**
2620	* Frees a previously allocated source root.
2621	*
2622	* @return IPRT status code.
2623	* @param pszSourceRoot Source root to free.
2624	*/
2625	static void gctlCopyFreeSourceRoot(char *pszSourceRoot)
2626	{
2627	RTStrFree(pszSourceRoot);
2628	}
2629
2630	static RTEXITCODE gctlHandleCopy(PGCTLCMDCTX pCtx, int argc, char **argv, bool fHostToGuest)
2631	{
2632	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2633
2634	/** @todo r=bird: This command isn't very unix friendly in general. mkdir
2635	* is much better (partly because it is much simpler of course). The main
2636	* arguments against this is that (1) all but two options conflicts with
2637	* what 'man cp' tells me on a GNU/Linux system, (2) wildchar matching is
2638	* done windows CMD style (though not in a 100% compatible way), and (3)
2639	* that only one source is allowed - efficiently sabotaging default
2640	* wildcard expansion by a unix shell. The best solution here would be
2641	* two different variant, one windowsy (xcopy) and one unixy (gnu cp). */
2642
2643	/*
2644	* IGuest::CopyToGuest is kept as simple as possible to let the developer choose
2645	* what and how to implement the file enumeration/recursive lookup, like VBoxManage
2646	* does in here.
2647	*/
2648	enum GETOPTDEF_COPY
2649	{
2650	GETOPTDEF_COPY_DRYRUN = 1000,
2651	GETOPTDEF_COPY_FOLLOW,
2652	GETOPTDEF_COPY_TARGETDIR
2653	};
2654	static const RTGETOPTDEF s_aOptions[] =
2655	{
2656	GCTLCMD_COMMON_OPTION_DEFS()
2657	{ "--dryrun", GETOPTDEF_COPY_DRYRUN, RTGETOPT_REQ_NOTHING },
2658	{ "--follow", GETOPTDEF_COPY_FOLLOW, RTGETOPT_REQ_NOTHING },
2659	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
2660	{ "--target-directory", GETOPTDEF_COPY_TARGETDIR, RTGETOPT_REQ_STRING }
2661	};
2662
2663	int ch;
2664	RTGETOPTUNION ValueUnion;
2665	RTGETOPTSTATE GetState;
2666	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2667
2668	Utf8Str strSource;
2669	const char *pszDst = NULL;
2670	enum gctlCopyFlags enmFlags = kGctlCopyFlags_None;
2671	/bool fCopyRecursive = false; - unused /
2672	bool fDryRun = false;
2673	uint32_t uUsage = fHostToGuest ? USAGE_GSTCTRL_COPYTO : USAGE_GSTCTRL_COPYFROM;
2674
2675	SOURCEVEC vecSources;
2676
2677	int vrc = VINF_SUCCESS;
2678	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2679	{
2680	/* For options that require an argument, ValueUnion has received the value. */
2681	switch (ch)
2682	{
2683	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2684
2685	case GETOPTDEF_COPY_DRYRUN:
2686	fDryRun = true;
2687	break;
2688
2689	case GETOPTDEF_COPY_FOLLOW:
2690	enmFlags = (enum gctlCopyFlags)((uint32_t)enmFlags \| kGctlCopyFlags_FollowLinks);
2691	break;
2692
2693	case 'R': /* Recursive processing */
2694	enmFlags = (enum gctlCopyFlags)((uint32_t)enmFlags \| kGctlCopyFlags_Recursive);
2695	break;
2696
2697	case GETOPTDEF_COPY_TARGETDIR:
2698	pszDst = ValueUnion.psz;
2699	break;
2700
2701	case VINF_GETOPT_NOT_OPTION:
2702	/* Last argument and no destination specified with
2703	* --target-directory yet? Then use the current
2704	* (= last) argument as destination. */
2705	if ( pCtx->pArg->argc == GetState.iNext
2706	&& pszDst == NULL)
2707	pszDst = ValueUnion.psz;
2708	else
2709	{
2710	try
2711	{ /* Save the source directory. */
2712	vecSources.push_back(SOURCEFILEENTRY(ValueUnion.psz));
2713	}
2714	catch (std::bad_alloc &)
2715	{
2716	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
2717	}
2718	}
2719	break;
2720
2721	default:
2722	return errorGetOptEx(USAGE_GUESTCONTROL, uUsage, ch, &ValueUnion);
2723	}
2724	}
2725
2726	if (!vecSources.size())
2727	return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No source(s) specified!");
2728
2729	if (pszDst == NULL)
2730	return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No destination specified!");
2731
2732	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2733	if (rcExit != RTEXITCODE_SUCCESS)
2734	return rcExit;
2735
2736	/*
2737	* Done parsing arguments, do some more preparations.
2738	*/
2739	if (pCtx->cVerbose)
2740	{
2741	if (fHostToGuest)
2742	RTPrintf("Copying from host to guest ...\n");
2743	else
2744	RTPrintf("Copying from guest to host ...\n");
2745	if (fDryRun)
2746	RTPrintf("Dry run - no files copied!\n");
2747	}
2748
2749	/* Create the copy context -- it contains all information
2750	* the routines need to know when handling the actual copying. */
2751	PCOPYCONTEXT pContext = NULL;
2752	vrc = gctlCopyContextCreate(pCtx, fDryRun, fHostToGuest,
2753	fHostToGuest
2754	? "VBoxManage Guest Control - Copy to guest"
2755	: "VBoxManage Guest Control - Copy from guest", &pContext);
2756	if (RT_FAILURE(vrc))
2757	{
2758	RTMsgError("Unable to create copy context, rc=%Rrc\n", vrc);
2759	return RTEXITCODE_FAILURE;
2760	}
2761
2762	/** @todo r=bird: RTPathFilename and RTPathStripFilename won't work
2763	* correctly on non-windows hosts when the guest is from the DOS world (Windows,
2764	* OS/2, DOS). The host doesn't know about DOS slashes, only UNIX slashes and
2765	* will get the wrong idea if some dilligent user does:
2766	*
2767	* copyto myfile.txt 'C:\guestfile.txt'
2768	* or
2769	* copyto myfile.txt 'D:guestfile.txt'
2770	*
2771	* @bugref{6344}
2772	*/
2773	if (!RTPathFilename(pszDst))
2774	{
2775	vrc = gctlCopyDirCreate(pContext, pszDst);
2776	}
2777	else
2778	{
2779	/* We assume we got a file name as destination -- so strip
2780	* the actual file name and make sure the appropriate
2781	* directories get created. */
2782	char *pszDstDir = RTStrDup(pszDst);
2783	AssertPtr(pszDstDir);
2784	RTPathStripFilename(pszDstDir);
2785	vrc = gctlCopyDirCreate(pContext, pszDstDir);
2786	RTStrFree(pszDstDir);
2787	}
2788
2789	if (RT_SUCCESS(vrc))
2790	{
2791	/*
2792	* Here starts the actual fun!
2793	* Handle all given sources one by one.
2794	*/
2795	for (unsigned long s = 0; s < vecSources.size(); s++)
2796	{
2797	char *pszSource = RTStrDup(vecSources[s].GetSource());
2798	AssertPtrBreakStmt(pszSource, vrc = VERR_NO_MEMORY);
2799	const char *pszFilter = vecSources[s].GetFilter();
2800	if (!strlen(pszFilter))
2801	pszFilter = NULL; /* If empty filter then there's no filter :-) */
2802
2803	char *pszSourceRoot;
2804	vrc = gctlCopyCreateSourceRoot(pszSource, &pszSourceRoot);
2805	if (RT_FAILURE(vrc))
2806	{
2807	RTMsgError("Unable to create source root, rc=%Rrc\n", vrc);
2808	break;
2809	}
2810
2811	if (pCtx->cVerbose)
2812	RTPrintf("Source: %s\n", pszSource);
2813
2814	/** @todo Files with filter?? */
2815	bool fSourceIsFile = false;
2816	bool fSourceExists;
2817
2818	size_t cchSource = strlen(pszSource);
2819	if ( cchSource > 1
2820	&& RTPATH_IS_SLASH(pszSource[cchSource - 1]))
2821	{
2822	if (pszFilter) /* Directory with filter (so use source root w/o the actual filter). */
2823	vrc = gctlCopyDirExistsOnSource(pContext, pszSourceRoot, &fSourceExists);
2824	else /* Regular directory without filter. */
2825	vrc = gctlCopyDirExistsOnSource(pContext, pszSource, &fSourceExists);
2826
2827	if (fSourceExists)
2828	{
2829	/* Strip trailing slash from our source element so that other functions
2830	* can use this stuff properly (like RTPathStartsWith). */
2831	RTPathStripTrailingSlash(pszSource);
2832	}
2833	}
2834	else
2835	{
2836	vrc = gctlCopyFileExistsOnSource(pContext, pszSource, &fSourceExists);
2837	if ( RT_SUCCESS(vrc)
2838	&& fSourceExists)
2839	{
2840	fSourceIsFile = true;
2841	}
2842	}
2843
2844	if ( RT_SUCCESS(vrc)
2845	&& fSourceExists)
2846	{
2847	if (fSourceIsFile)
2848	{
2849	/* Single file. */
2850	char *pszDstFile;
2851	vrc = gctlCopyTranslatePath(pszSourceRoot, pszSource, pszDst, &pszDstFile);
2852	if (RT_SUCCESS(vrc))
2853	{
2854	vrc = gctlCopyFileToDest(pContext, pszSource, pszDstFile, kGctlCopyFlags_None);
2855	RTStrFree(pszDstFile);
2856	}
2857	else
2858	RTMsgError("Unable to translate path for \"%s\", rc=%Rrc\n", pszSource, vrc);
2859	}
2860	else
2861	{
2862	/* Directory (with filter?). */
2863	vrc = gctlCopyDirToDest(pContext, pszSource, pszFilter, pszDst, enmFlags);
2864	}
2865	}
2866
2867	gctlCopyFreeSourceRoot(pszSourceRoot);
2868
2869	if ( RT_SUCCESS(vrc)
2870	&& !fSourceExists)
2871	{
2872	RTMsgError("Warning: Source \"%s\" does not exist, skipping!\n",
2873	pszSource);
2874	RTStrFree(pszSource);
2875	continue;
2876	}
2877	else if (RT_FAILURE(vrc))
2878	{
2879	RTMsgError("Error processing \"%s\", rc=%Rrc\n",
2880	pszSource, vrc);
2881	RTStrFree(pszSource);
2882	break;
2883	}
2884
2885	RTStrFree(pszSource);
2886	}
2887	}
2888
2889	gctlCopyContextFree(pContext);
2890
2891	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2892	}
2893
2894	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyFrom(PGCTLCMDCTX pCtx, int argc, char **argv)
2895	{
2896	return gctlHandleCopy(pCtx, argc, argv, false /* Guest to host */);
2897	}
2898
2899	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyTo(PGCTLCMDCTX pCtx, int argc, char **argv)
2900	{
2901	return gctlHandleCopy(pCtx, argc, argv, true /* Host to guest */);
2902	}
2903
2904	static DECLCALLBACK(RTEXITCODE) handleCtrtMkDir(PGCTLCMDCTX pCtx, int argc, char **argv)
2905	{
2906	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2907
2908	static const RTGETOPTDEF s_aOptions[] =
2909	{
2910	GCTLCMD_COMMON_OPTION_DEFS()
2911	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
2912	{ "--parents", 'P', RTGETOPT_REQ_NOTHING }
2913	};
2914
2915	int ch;
2916	RTGETOPTUNION ValueUnion;
2917	RTGETOPTSTATE GetState;
2918	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2919
2920	SafeArray<DirectoryCreateFlag_T> dirCreateFlags;
2921	uint32_t fDirMode = 0; /* Default mode. */
2922	uint32_t cDirsCreated = 0;
2923	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2924
2925	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2926	{
2927	/* For options that require an argument, ValueUnion has received the value. */
2928	switch (ch)
2929	{
2930	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2931
2932	case 'm': /* Mode */
2933	fDirMode = ValueUnion.u32;
2934	break;
2935
2936	case 'P': /* Create parents */
2937	dirCreateFlags.push_back(DirectoryCreateFlag_Parents);
2938	break;
2939
2940	case VINF_GETOPT_NOT_OPTION:
2941	if (cDirsCreated == 0)
2942	{
2943	/*
2944	* First non-option - no more options now.
2945	*/
2946	rcExit = gctlCtxPostOptionParsingInit(pCtx);
2947	if (rcExit != RTEXITCODE_SUCCESS)
2948	return rcExit;
2949	if (pCtx->cVerbose)
2950	RTPrintf("Creating %RU32 directories...\n", argc - GetState.iNext + 1);
2951	}
2952	if (g_fGuestCtrlCanceled)
2953	return RTMsgErrorExit(RTEXITCODE_FAILURE, "mkdir was interrupted by Ctrl-C (%u left)\n",
2954	argc - GetState.iNext + 1);
2955
2956	/*
2957	* Create the specified directory.
2958	*
2959	* On failure we'll change the exit status to failure and
2960	* continue with the next directory that needs creating. We do
2961	* this because we only create new things, and because this is
2962	* how /bin/mkdir works on unix.
2963	*/
2964	cDirsCreated++;
2965	if (pCtx->cVerbose)
2966	RTPrintf("Creating directory \"%s\" ...\n", ValueUnion.psz);
2967	try
2968	{
2969	HRESULT rc;
2970	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(),
2971	fDirMode, ComSafeArrayAsInParam(dirCreateFlags)));
2972	if (FAILED(rc))
2973	rcExit = RTEXITCODE_FAILURE;
2974	}
2975	catch (std::bad_alloc &)
2976	{
2977	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
2978	}
2979	break;
2980
2981	default:
2982	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, ch, &ValueUnion);
2983	}
2984	}
2985
2986	if (!cDirsCreated)
2987	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, "No directory to create specified!");
2988	return rcExit;
2989	}
2990
2991
2992	static DECLCALLBACK(RTEXITCODE) gctlHandleRmDir(PGCTLCMDCTX pCtx, int argc, char **argv)
2993	{
2994	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2995
2996	static const RTGETOPTDEF s_aOptions[] =
2997	{
2998	GCTLCMD_COMMON_OPTION_DEFS()
2999	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
3000	};
3001
3002	int ch;
3003	RTGETOPTUNION ValueUnion;
3004	RTGETOPTSTATE GetState;
3005	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3006
3007	bool fRecursive = false;
3008	uint32_t cDirRemoved = 0;
3009	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
3010
3011	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3012	{
3013	/* For options that require an argument, ValueUnion has received the value. */
3014	switch (ch)
3015	{
3016	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3017
3018	case 'R':
3019	fRecursive = true;
3020	break;
3021
3022	case VINF_GETOPT_NOT_OPTION:
3023	{
3024	if (cDirRemoved == 0)
3025	{
3026	/*
3027	* First non-option - no more options now.
3028	*/
3029	rcExit = gctlCtxPostOptionParsingInit(pCtx);
3030	if (rcExit != RTEXITCODE_SUCCESS)
3031	return rcExit;
3032	if (pCtx->cVerbose)
3033	RTPrintf("Removing %RU32 directorie%ss...\n", argc - GetState.iNext + 1, fRecursive ? "trees" : "");
3034	}
3035	if (g_fGuestCtrlCanceled)
3036	return RTMsgErrorExit(RTEXITCODE_FAILURE, "rmdir was interrupted by Ctrl-C (%u left)\n",
3037	argc - GetState.iNext + 1);
3038
3039	cDirRemoved++;
3040	HRESULT rc;
3041	if (!fRecursive)
3042	{
3043	/*
3044	* Remove exactly one directory.
3045	*/
3046	if (pCtx->cVerbose)
3047	RTPrintf("Removing directory \"%s\" ...\n", ValueUnion.psz);
3048	try
3049	{
3050	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemove(Bstr(ValueUnion.psz).raw()));
3051	}
3052	catch (std::bad_alloc &)
3053	{
3054	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
3055	}
3056	}
3057	else
3058	{
3059	/*
3060	* Remove the directory and anything under it, that means files
3061	* and everything. This is in the tradition of the Windows NT
3062	* CMD.EXE "rmdir /s" operation, a tradition which jpsoft's TCC
3063	* strongly warns against (and half-ways questions the sense of).
3064	*/
3065	if (pCtx->cVerbose)
3066	RTPrintf("Recursively removing directory \"%s\" ...\n", ValueUnion.psz);
3067	try
3068	{
3069	/** @todo Make flags configurable. */
3070	com::SafeArray<DirectoryRemoveRecFlag_T> aRemRecFlags;
3071	aRemRecFlags.push_back(DirectoryRemoveRecFlag_ContentAndDir);
3072
3073	ComPtr<IProgress> ptrProgress;
3074	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemoveRecursive(Bstr(ValueUnion.psz).raw(),
3075	ComSafeArrayAsInParam(aRemRecFlags),
3076	ptrProgress.asOutParam()));
3077	if (SUCCEEDED(rc))
3078	{
3079	if (pCtx->cVerbose)
3080	rc = showProgress(ptrProgress);
3081	else
3082	rc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
3083	if (SUCCEEDED(rc))
3084	CHECK_PROGRESS_ERROR(ptrProgress, ("Directory deletion failed"));
3085	ptrProgress.setNull();
3086	}
3087	}
3088	catch (std::bad_alloc &)
3089	{
3090	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory during recursive rmdir\n");
3091	}
3092	}
3093
3094	/*
3095	* This command returns immediately on failure since it's destructive in nature.
3096	*/
3097	if (FAILED(rc))
3098	return RTEXITCODE_FAILURE;
3099	break;
3100	}
3101
3102	default:
3103	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, ch, &ValueUnion);
3104	}
3105	}
3106
3107	if (!cDirRemoved)
3108	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, "No directory to remove specified!");
3109	return rcExit;
3110	}
3111
3112	static DECLCALLBACK(RTEXITCODE) gctlHandleRm(PGCTLCMDCTX pCtx, int argc, char **argv)
3113	{
3114	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3115
3116	static const RTGETOPTDEF s_aOptions[] =
3117	{
3118	GCTLCMD_COMMON_OPTION_DEFS()
3119	{ "--force", 'f', RTGETOPT_REQ_NOTHING, },
3120	};
3121
3122	int ch;
3123	RTGETOPTUNION ValueUnion;
3124	RTGETOPTSTATE GetState;
3125	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3126
3127	uint32_t cFilesDeleted = 0;
3128	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
3129	bool fForce = true;
3130
3131	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3132	{
3133	/* For options that require an argument, ValueUnion has received the value. */
3134	switch (ch)
3135	{
3136	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3137
3138	case VINF_GETOPT_NOT_OPTION:
3139	if (cFilesDeleted == 0)
3140	{
3141	/*
3142	* First non-option - no more options now.
3143	*/
3144	rcExit = gctlCtxPostOptionParsingInit(pCtx);
3145	if (rcExit != RTEXITCODE_SUCCESS)
3146	return rcExit;
3147	if (pCtx->cVerbose)
3148	RTPrintf("Removing %RU32 file(s)...\n", argc - GetState.iNext + 1);
3149	}
3150	if (g_fGuestCtrlCanceled)
3151	return RTMsgErrorExit(RTEXITCODE_FAILURE, "rm was interrupted by Ctrl-C (%u left)\n",
3152	argc - GetState.iNext + 1);
3153
3154	/*
3155	* Remove the specified file.
3156	*
3157	* On failure we will by default stop, however, the force option will
3158	* by unix traditions force us to ignore errors and continue.
3159	*/
3160	cFilesDeleted++;
3161	if (pCtx->cVerbose)
3162	RTPrintf("Removing file \"%s\" ...\n", ValueUnion.psz);
3163	try
3164	{
3165	/** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we
3166	* need to do some chmod or whatever to better emulate the --force flag? */
3167	HRESULT rc;
3168	CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw()));
3169	if (FAILED(rc) && !fForce)
3170	return RTEXITCODE_FAILURE;
3171	}
3172	catch (std::bad_alloc &)
3173	{
3174	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
3175	}
3176	break;
3177
3178	default:
3179	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, ch, &ValueUnion);
3180	}
3181	}
3182
3183	if (!cFilesDeleted && !fForce)
3184	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, "No file to remove specified!");
3185	return rcExit;
3186	}
3187
3188	static DECLCALLBACK(RTEXITCODE) gctlHandleMv(PGCTLCMDCTX pCtx, int argc, char **argv)
3189	{
3190	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3191
3192	static const RTGETOPTDEF s_aOptions[] =
3193	{
3194	GCTLCMD_COMMON_OPTION_DEFS()
3195	};
3196
3197	int ch;
3198	RTGETOPTUNION ValueUnion;
3199	RTGETOPTSTATE GetState;
3200	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3201
3202	int vrc = VINF_SUCCESS;
3203
3204	bool fDryrun = false;
3205	std::vector< Utf8Str > vecSources;
3206	const char *pszDst = NULL;
3207	com::SafeArray<FsObjRenameFlag_T> aRenameFlags;
3208
3209	try
3210	{
3211	/** @todo Make flags configurable. */
3212	aRenameFlags.push_back(FsObjRenameFlag_NoReplace);
3213
3214	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3215	&& RT_SUCCESS(vrc))
3216	{
3217	/* For options that require an argument, ValueUnion has received the value. */
3218	switch (ch)
3219	{
3220	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3221
3222	/** @todo Implement a --dryrun command. */
3223	/** @todo Implement rename flags. */
3224
3225	case VINF_GETOPT_NOT_OPTION:
3226	vecSources.push_back(Utf8Str(ValueUnion.psz));
3227	pszDst = ValueUnion.psz;
3228	break;
3229
3230	default:
3231	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV, ch, &ValueUnion);
3232	}
3233	}
3234	}
3235	catch (std::bad_alloc)
3236	{
3237	vrc = VERR_NO_MEMORY;
3238	}
3239
3240	if (RT_FAILURE(vrc))
3241	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize, rc=%Rrc\n", vrc);
3242
3243	size_t cSources = vecSources.size();
3244	if (!cSources)
3245	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV,
3246	"No source(s) to move specified!");
3247	if (cSources < 2)
3248	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV,
3249	"No destination specified!");
3250
3251	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3252	if (rcExit != RTEXITCODE_SUCCESS)
3253	return rcExit;
3254
3255	/* Delete last element, which now is the destination. */
3256	vecSources.pop_back();
3257	cSources = vecSources.size();
3258
3259	HRESULT rc = S_OK;
3260
3261	if (cSources > 1)
3262	{
3263	BOOL fExists = FALSE;
3264	rc = pCtx->pGuestSession->DirectoryExists(Bstr(pszDst).raw(), FALSE /followSymlinks/, &fExists);
3265	if (FAILED(rc) \|\| !fExists)
3266	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Destination must be a directory when specifying multiple sources\n");
3267	}
3268
3269	/*
3270	* Rename (move) the entries.
3271	*/
3272	if (pCtx->cVerbose)
3273	RTPrintf("Renaming %RU32 %s ...\n", cSources, cSources > 1 ? "entries" : "entry");
3274
3275	std::vector< Utf8Str >::iterator it = vecSources.begin();
3276	while ( (it != vecSources.end())
3277	&& !g_fGuestCtrlCanceled)
3278	{
3279	Utf8Str strCurSource = (*it);
3280
3281	ComPtr<IGuestFsObjInfo> pFsObjInfo;
3282	FsObjType_T enmObjType = FsObjType_Unknown; /* Shut up MSC */
3283	rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strCurSource).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
3284	if (SUCCEEDED(rc))
3285	rc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
3286	if (FAILED(rc))
3287	{
3288	if (pCtx->cVerbose)
3289	RTPrintf("Warning: Cannot stat for element \"%s\": No such element\n",
3290	strCurSource.c_str());
3291	++it;
3292	continue; /* Skip. */
3293	}
3294
3295	if (pCtx->cVerbose)
3296	RTPrintf("Renaming %s \"%s\" to \"%s\" ...\n",
3297	enmObjType == FsObjType_Directory ? "directory" : "file",
3298	strCurSource.c_str(), pszDst);
3299
3300	if (!fDryrun)
3301	{
3302	if (enmObjType == FsObjType_Directory)
3303	{
3304	CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(),
3305	Bstr(pszDst).raw(),
3306	ComSafeArrayAsInParam(aRenameFlags)));
3307
3308	/* Break here, since it makes no sense to rename mroe than one source to
3309	* the same directory. */
3310	/** @todo r=bird: You are being kind of windowsy (or just DOSish) about the 'sense' part here,
3311	* while being totaly buggy about the behavior. 'VBoxGuest guestcontrol ren dir1 dir2 dstdir' will
3312	* stop after 'dir1' and SILENTLY ignore dir2. If you tried this on Windows, you'd see an error
3313	* being displayed. If you 'man mv' on a nearby unixy system, you'd see that they've made perfect
3314	* sense out of any situation with more than one source. */
3315	it = vecSources.end();
3316	break;
3317	}
3318	else
3319	CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(),
3320	Bstr(pszDst).raw(),
3321	ComSafeArrayAsInParam(aRenameFlags)));
3322	}
3323
3324	++it;
3325	}
3326
3327	if ( (it != vecSources.end())
3328	&& pCtx->cVerbose)
3329	{
3330	RTPrintf("Warning: Not all sources were renamed\n");
3331	}
3332
3333	return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
3334	}
3335
3336	static DECLCALLBACK(RTEXITCODE) gctlHandleMkTemp(PGCTLCMDCTX pCtx, int argc, char **argv)
3337	{
3338	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3339
3340	static const RTGETOPTDEF s_aOptions[] =
3341	{
3342	GCTLCMD_COMMON_OPTION_DEFS()
3343	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
3344	{ "--directory", 'D', RTGETOPT_REQ_NOTHING },
3345	{ "--secure", 's', RTGETOPT_REQ_NOTHING },
3346	{ "--tmpdir", 't', RTGETOPT_REQ_STRING }
3347	};
3348
3349	int ch;
3350	RTGETOPTUNION ValueUnion;
3351	RTGETOPTSTATE GetState;
3352	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3353
3354	Utf8Str strTemplate;
3355	uint32_t fMode = 0; /* Default mode. */
3356	bool fDirectory = false;
3357	bool fSecure = false;
3358	Utf8Str strTempDir;
3359
3360	DESTDIRMAP mapDirs;
3361
3362	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3363	{
3364	/* For options that require an argument, ValueUnion has received the value. */
3365	switch (ch)
3366	{
3367	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3368
3369	case 'm': /* Mode */
3370	fMode = ValueUnion.u32;
3371	break;
3372
3373	case 'D': /* Create directory */
3374	fDirectory = true;
3375	break;
3376
3377	case 's': /* Secure */
3378	fSecure = true;
3379	break;
3380
3381	case 't': /* Temp directory */
3382	strTempDir = ValueUnion.psz;
3383	break;
3384
3385	case VINF_GETOPT_NOT_OPTION:
3386	{
3387	if (strTemplate.isEmpty())
3388	strTemplate = ValueUnion.psz;
3389	else
3390	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3391	"More than one template specified!\n");
3392	break;
3393	}
3394
3395	default:
3396	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, ch, &ValueUnion);
3397	}
3398	}
3399
3400	if (strTemplate.isEmpty())
3401	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3402	"No template specified!");
3403
3404	if (!fDirectory)
3405	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3406	"Creating temporary files is currently not supported!");
3407
3408	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3409	if (rcExit != RTEXITCODE_SUCCESS)
3410	return rcExit;
3411
3412	/*
3413	* Create the directories.
3414	*/
3415	if (pCtx->cVerbose)
3416	{
3417	if (fDirectory && !strTempDir.isEmpty())
3418	RTPrintf("Creating temporary directory from template '%s' in directory '%s' ...\n",
3419	strTemplate.c_str(), strTempDir.c_str());
3420	else if (fDirectory)
3421	RTPrintf("Creating temporary directory from template '%s' in default temporary directory ...\n",
3422	strTemplate.c_str());
3423	else if (!fDirectory && !strTempDir.isEmpty())
3424	RTPrintf("Creating temporary file from template '%s' in directory '%s' ...\n",
3425	strTemplate.c_str(), strTempDir.c_str());
3426	else if (!fDirectory)
3427	RTPrintf("Creating temporary file from template '%s' in default temporary directory ...\n",
3428	strTemplate.c_str());
3429	}
3430
3431	HRESULT rc = S_OK;
3432	if (fDirectory)
3433	{
3434	Bstr directory;
3435	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreateTemp(Bstr(strTemplate).raw(),
3436	fMode, Bstr(strTempDir).raw(),
3437	fSecure,
3438	directory.asOutParam()));
3439	if (SUCCEEDED(rc))
3440	RTPrintf("Directory name: %ls\n", directory.raw());
3441	}
3442	else
3443	{
3444	// else - temporary file not yet implemented
3445	/** @todo implement temporary file creation (we fend it off above, no
3446	* worries). */
3447	rc = E_FAIL;
3448	}
3449
3450	return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
3451	}
3452
3453	static DECLCALLBACK(RTEXITCODE) gctlHandleStat(PGCTLCMDCTX pCtx, int argc, char **argv)
3454	{
3455	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3456
3457	static const RTGETOPTDEF s_aOptions[] =
3458	{
3459	GCTLCMD_COMMON_OPTION_DEFS()
3460	{ "--dereference", 'L', RTGETOPT_REQ_NOTHING },
3461	{ "--file-system", 'f', RTGETOPT_REQ_NOTHING },
3462	{ "--format", 'c', RTGETOPT_REQ_STRING },
3463	{ "--terse", 't', RTGETOPT_REQ_NOTHING }
3464	};
3465
3466	int ch;
3467	RTGETOPTUNION ValueUnion;
3468	RTGETOPTSTATE GetState;
3469	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3470
3471	DESTDIRMAP mapObjs;
3472
3473	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3474	{
3475	/* For options that require an argument, ValueUnion has received the value. */
3476	switch (ch)
3477	{
3478	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3479
3480	case 'L': /* Dereference */
3481	case 'f': /* File-system */
3482	case 'c': /* Format */
3483	case 't': /* Terse */
3484	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT,
3485	"Command \"%s\" not implemented yet!", ValueUnion.psz);
3486
3487	case VINF_GETOPT_NOT_OPTION:
3488	mapObjs[ValueUnion.psz]; /* Add element to check to map. */
3489	break;
3490
3491	default:
3492	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT, ch, &ValueUnion);
3493	}
3494	}
3495
3496	size_t cObjs = mapObjs.size();
3497	if (!cObjs)
3498	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT,
3499	"No element(s) to check specified!");
3500
3501	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3502	if (rcExit != RTEXITCODE_SUCCESS)
3503	return rcExit;
3504
3505	HRESULT rc;
3506
3507	/*
3508	* Doing the checks.
3509	*/
3510	DESTDIRMAPITER it = mapObjs.begin();
3511	while (it != mapObjs.end())
3512	{
3513	if (pCtx->cVerbose)
3514	RTPrintf("Checking for element \"%s\" ...\n", it->first.c_str());
3515
3516	ComPtr<IGuestFsObjInfo> pFsObjInfo;
3517	rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(it->first).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
3518	if (FAILED(rc))
3519	{
3520	/* If there's at least one element which does not exist on the guest,
3521	* drop out with exitcode 1. */
3522	if (pCtx->cVerbose)
3523	RTPrintf("Cannot stat for element \"%s\": No such element\n",
3524	it->first.c_str());
3525	rcExit = RTEXITCODE_FAILURE;
3526	}
3527	else
3528	{
3529	FsObjType_T objType;
3530	pFsObjInfo->COMGETTER(Type)(&objType); /** @todo What about error checking? */
3531	switch (objType)
3532	{
3533	case FsObjType_File:
3534	RTPrintf("Element \"%s\" found: Is a file\n", it->first.c_str());
3535	break;
3536
3537	case FsObjType_Directory:
3538	RTPrintf("Element \"%s\" found: Is a directory\n", it->first.c_str());
3539	break;
3540
3541	case FsObjType_Symlink:
3542	RTPrintf("Element \"%s\" found: Is a symlink\n", it->first.c_str());
3543	break;
3544
3545	default:
3546	RTPrintf("Element \"%s\" found, type unknown (%ld)\n", it->first.c_str(), objType);
3547	break;
3548	}
3549
3550	/** @todo Show more information about this element. */
3551	}
3552
3553	++it;
3554	}
3555
3556	return rcExit;
3557	}
3558
3559	static DECLCALLBACK(RTEXITCODE) gctlHandleUpdateAdditions(PGCTLCMDCTX pCtx, int argc, char **argv)
3560	{
3561	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3562
3563	/*
3564	* Check the syntax. We can deduce the correct syntax from the number of
3565	* arguments.
3566	*/
3567	Utf8Str strSource;
3568	com::SafeArray<IN_BSTR> aArgs;
3569	bool fWaitStartOnly = false;
3570
3571	static const RTGETOPTDEF s_aOptions[] =
3572	{
3573	GCTLCMD_COMMON_OPTION_DEFS()
3574	{ "--source", 's', RTGETOPT_REQ_STRING },
3575	{ "--wait-start", 'w', RTGETOPT_REQ_NOTHING }
3576	};
3577
3578	int ch;
3579	RTGETOPTUNION ValueUnion;
3580	RTGETOPTSTATE GetState;
3581	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3582
3583	int vrc = VINF_SUCCESS;
3584	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3585	&& RT_SUCCESS(vrc))
3586	{
3587	switch (ch)
3588	{
3589	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3590
3591	case 's':
3592	strSource = ValueUnion.psz;
3593	break;
3594
3595	case 'w':
3596	fWaitStartOnly = true;
3597	break;
3598
3599	case VINF_GETOPT_NOT_OPTION:
3600	if (aArgs.size() == 0 && strSource.isEmpty())
3601	strSource = ValueUnion.psz;
3602	else
3603	aArgs.push_back(Bstr(ValueUnion.psz).raw());
3604	break;
3605
3606	default:
3607	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion);
3608	}
3609	}
3610
3611	if (pCtx->cVerbose)
3612	RTPrintf("Updating Guest Additions ...\n");
3613
3614	HRESULT rc = S_OK;
3615	while (strSource.isEmpty())
3616	{
3617	ComPtr<ISystemProperties> pProperties;
3618	CHECK_ERROR_BREAK(pCtx->pArg->virtualBox, COMGETTER(SystemProperties)(pProperties.asOutParam()));
3619	Bstr strISO;
3620	CHECK_ERROR_BREAK(pProperties, COMGETTER(DefaultAdditionsISO)(strISO.asOutParam()));
3621	strSource = strISO;
3622	break;
3623	}
3624
3625	/* Determine source if not set yet. */
3626	if (strSource.isEmpty())
3627	{
3628	RTMsgError("No Guest Additions source found or specified, aborting\n");
3629	vrc = VERR_FILE_NOT_FOUND;
3630	}
3631	else if (!RTFileExists(strSource.c_str()))
3632	{
3633	RTMsgError("Source \"%s\" does not exist!\n", strSource.c_str());
3634	vrc = VERR_FILE_NOT_FOUND;
3635	}
3636
3637	if (RT_SUCCESS(vrc))
3638	{
3639	if (pCtx->cVerbose)
3640	RTPrintf("Using source: %s\n", strSource.c_str());
3641
3642
3643	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3644	if (rcExit != RTEXITCODE_SUCCESS)
3645	return rcExit;
3646
3647
3648	com::SafeArray<AdditionsUpdateFlag_T> aUpdateFlags;
3649	if (fWaitStartOnly)
3650	{
3651	aUpdateFlags.push_back(AdditionsUpdateFlag_WaitForUpdateStartOnly);
3652	if (pCtx->cVerbose)
3653	RTPrintf("Preparing and waiting for Guest Additions installer to start ...\n");
3654	}
3655
3656	ComPtr<IProgress> pProgress;
3657	CHECK_ERROR(pCtx->pGuest, UpdateGuestAdditions(Bstr(strSource).raw(),
3658	ComSafeArrayAsInParam(aArgs),
3659	/* Wait for whole update process to complete. */
3660	ComSafeArrayAsInParam(aUpdateFlags),
3661	pProgress.asOutParam()));
3662	if (FAILED(rc))
3663	vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3664	else
3665	{
3666	if (pCtx->cVerbose)
3667	rc = showProgress(pProgress);
3668	else
3669	rc = pProgress->WaitForCompletion(-1 /* No timeout */);
3670
3671	if (SUCCEEDED(rc))
3672	CHECK_PROGRESS_ERROR(pProgress, ("Guest additions update failed"));
3673	vrc = gctlPrintProgressError(pProgress);
3674	if ( RT_SUCCESS(vrc)
3675	&& pCtx->cVerbose)
3676	{
3677	RTPrintf("Guest Additions update successful\n");
3678	}
3679	}
3680	}
3681
3682	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3683	}
3684
3685	static DECLCALLBACK(RTEXITCODE) gctlHandleList(PGCTLCMDCTX pCtx, int argc, char **argv)
3686	{
3687	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3688
3689	static const RTGETOPTDEF s_aOptions[] =
3690	{
3691	GCTLCMD_COMMON_OPTION_DEFS()
3692	};
3693
3694	int ch;
3695	RTGETOPTUNION ValueUnion;
3696	RTGETOPTSTATE GetState;
3697	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3698
3699	bool fSeenListArg = false;
3700	bool fListAll = false;
3701	bool fListSessions = false;
3702	bool fListProcesses = false;
3703	bool fListFiles = false;
3704
3705	int vrc = VINF_SUCCESS;
3706	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3707	&& RT_SUCCESS(vrc))
3708	{
3709	switch (ch)
3710	{
3711	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3712
3713	case VINF_GETOPT_NOT_OPTION:
3714	if ( !RTStrICmp(ValueUnion.psz, "sessions")
3715	\|\| !RTStrICmp(ValueUnion.psz, "sess"))
3716	fListSessions = true;
3717	else if ( !RTStrICmp(ValueUnion.psz, "processes")
3718	\|\| !RTStrICmp(ValueUnion.psz, "procs"))
3719	fListSessions = fListProcesses = true; /* Showing processes implies showing sessions. */
3720	else if (!RTStrICmp(ValueUnion.psz, "files"))
3721	fListSessions = fListFiles = true; /* Showing files implies showing sessions. */
3722	else if (!RTStrICmp(ValueUnion.psz, "all"))
3723	fListAll = true;
3724	else
3725	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST,
3726	"Unknown list: '%s'", ValueUnion.psz);
3727	fSeenListArg = true;
3728	break;
3729
3730	default:
3731	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion);
3732	}
3733	}
3734
3735	if (!fSeenListArg)
3736	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST, "Missing list name");
3737	Assert(fListAll \|\| fListSessions);
3738
3739	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3740	if (rcExit != RTEXITCODE_SUCCESS)
3741	return rcExit;
3742
3743
3744	/** @todo Do we need a machine-readable output here as well? */
3745
3746	HRESULT rc;
3747	size_t cTotalProcs = 0;
3748	size_t cTotalFiles = 0;
3749
3750	SafeIfaceArray <IGuestSession> collSessions;
3751	CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3752	if (SUCCEEDED(rc))
3753	{
3754	size_t const cSessions = collSessions.size();
3755	if (cSessions)
3756	{
3757	RTPrintf("Active guest sessions:\n");
3758
3759	/** @todo Make this output a bit prettier. No time now. */
3760
3761	for (size_t i = 0; i < cSessions; i++)
3762	{
3763	ComPtr<IGuestSession> pCurSession = collSessions[i];
3764	if (!pCurSession.isNull())
3765	{
3766	do
3767	{
3768	ULONG uID;
3769	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Id)(&uID));
3770	Bstr strName;
3771	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Name)(strName.asOutParam()));
3772	Bstr strUser;
3773	CHECK_ERROR_BREAK(pCurSession, COMGETTER(User)(strUser.asOutParam()));
3774	GuestSessionStatus_T sessionStatus;
3775	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus));
3776	RTPrintf("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls",
3777	i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw());
3778	} while (0);
3779
3780	if ( fListAll
3781	\|\| fListProcesses)
3782	{
3783	SafeIfaceArray <IGuestProcess> collProcesses;
3784	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcesses)));
3785	for (size_t a = 0; a < collProcesses.size(); a++)
3786	{
3787	ComPtr<IGuestProcess> pCurProcess = collProcesses[a];
3788	if (!pCurProcess.isNull())
3789	{
3790	do
3791	{
3792	ULONG uPID;
3793	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(PID)(&uPID));
3794	Bstr strExecPath;
3795	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(ExecutablePath)(strExecPath.asOutParam()));
3796	ProcessStatus_T procStatus;
3797	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus));
3798
3799	RTPrintf("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls",
3800	a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw());
3801	} while (0);
3802	}
3803	}
3804
3805	cTotalProcs += collProcesses.size();
3806	}
3807
3808	if ( fListAll
3809	\|\| fListFiles)
3810	{
3811	SafeIfaceArray <IGuestFile> collFiles;
3812	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Files)(ComSafeArrayAsOutParam(collFiles)));
3813	for (size_t a = 0; a < collFiles.size(); a++)
3814	{
3815	ComPtr<IGuestFile> pCurFile = collFiles[a];
3816	if (!pCurFile.isNull())
3817	{
3818	do
3819	{
3820	ULONG idFile;
3821	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Id)(&idFile));
3822	Bstr strName;
3823	CHECK_ERROR_BREAK(pCurFile, COMGETTER(FileName)(strName.asOutParam()));
3824	FileStatus_T fileStatus;
3825	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus));
3826
3827	RTPrintf("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls",
3828	a, idFile, gctlFileStatusToText(fileStatus), strName.raw());
3829	} while (0);
3830	}
3831	}
3832
3833	cTotalFiles += collFiles.size();
3834	}
3835	}
3836	}
3837
3838	RTPrintf("\n\nTotal guest sessions: %zu\n", collSessions.size());
3839	if (fListAll \|\| fListProcesses)
3840	RTPrintf("Total guest processes: %zu\n", cTotalProcs);
3841	if (fListAll \|\| fListFiles)
3842	RTPrintf("Total guest files: %zu\n", cTotalFiles);
3843	}
3844	else
3845	RTPrintf("No active guest sessions found\n");
3846	}
3847
3848	if (FAILED(rc))
3849	rcExit = RTEXITCODE_FAILURE;
3850
3851	return rcExit;
3852	}
3853
3854	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseProcess(PGCTLCMDCTX pCtx, int argc, char **argv)
3855	{
3856	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3857
3858	static const RTGETOPTDEF s_aOptions[] =
3859	{
3860	GCTLCMD_COMMON_OPTION_DEFS()
3861	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3862	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
3863	};
3864
3865	int ch;
3866	RTGETOPTUNION ValueUnion;
3867	RTGETOPTSTATE GetState;
3868	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3869
3870	std::vector < uint32_t > vecPID;
3871	ULONG ulSessionID = UINT32_MAX;
3872	Utf8Str strSessionName;
3873
3874	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3875	{
3876	/* For options that require an argument, ValueUnion has received the value. */
3877	switch (ch)
3878	{
3879	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3880
3881	case 'n': /* Session name (or pattern) */
3882	strSessionName = ValueUnion.psz;
3883	break;
3884
3885	case 'i': /* Session ID */
3886	ulSessionID = ValueUnion.u32;
3887	break;
3888
3889	case VINF_GETOPT_NOT_OPTION:
3890	{
3891	/* Treat every else specified as a PID to kill. */
3892	uint32_t uPid;
3893	int rc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
3894	if ( RT_SUCCESS(rc)
3895	&& rc != VWRN_TRAILING_CHARS
3896	&& rc != VWRN_NUMBER_TOO_BIG
3897	&& rc != VWRN_NEGATIVE_UNSIGNED)
3898	{
3899	if (uPid != 0)
3900	{
3901	try
3902	{
3903	vecPID.push_back(uPid);
3904	}
3905	catch (std::bad_alloc &)
3906	{
3907	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
3908	}
3909	}
3910	else
3911	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "Invalid PID value: 0");
3912	}
3913	else
3914	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3915	"Error parsing PID value: %Rrc", rc);
3916	break;
3917	}
3918
3919	default:
3920	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, ch, &ValueUnion);
3921	}
3922	}
3923
3924	if (vecPID.empty())
3925	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3926	"At least one PID must be specified to kill!");
3927
3928	if ( strSessionName.isEmpty()
3929	&& ulSessionID == UINT32_MAX)
3930	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "No session ID specified!");
3931
3932	if ( strSessionName.isNotEmpty()
3933	&& ulSessionID != UINT32_MAX)
3934	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3935	"Either session ID or name (pattern) must be specified");
3936
3937	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3938	if (rcExit != RTEXITCODE_SUCCESS)
3939	return rcExit;
3940
3941	HRESULT rc = S_OK;
3942
3943	ComPtr<IGuestSession> pSession;
3944	ComPtr<IGuestProcess> pProcess;
3945	do
3946	{
3947	uint32_t uProcsTerminated = 0;
3948	bool fSessionFound = false;
3949
3950	SafeIfaceArray <IGuestSession> collSessions;
3951	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3952	size_t cSessions = collSessions.size();
3953
3954	uint32_t uSessionsHandled = 0;
3955	for (size_t i = 0; i < cSessions; i++)
3956	{
3957	pSession = collSessions[i];
3958	Assert(!pSession.isNull());
3959
3960	ULONG uID; /* Session ID */
3961	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3962	Bstr strName;
3963	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3964	Utf8Str strNameUtf8(strName); /* Session name */
3965	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3966	{
3967	fSessionFound = uID == ulSessionID;
3968	}
3969	else /* ... or by naming pattern. */
3970	{
3971	if (RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()))
3972	fSessionFound = true;
3973	}
3974
3975	if (fSessionFound)
3976	{
3977	AssertStmt(!pSession.isNull(), break);
3978	uSessionsHandled++;
3979
3980	SafeIfaceArray <IGuestProcess> collProcs;
3981	CHECK_ERROR_BREAK(pSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcs)));
3982
3983	size_t cProcs = collProcs.size();
3984	for (size_t p = 0; p < cProcs; p++)
3985	{
3986	pProcess = collProcs[p];
3987	Assert(!pProcess.isNull());
3988
3989	ULONG uPID; /* Process ID */
3990	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
3991
3992	bool fProcFound = false;
3993	for (size_t a = 0; a < vecPID.size(); a++) /* Slow, but works. */
3994	{
3995	fProcFound = vecPID[a] == uPID;
3996	if (fProcFound)
3997	break;
3998	}
3999
4000	if (fProcFound)
4001	{
4002	if (pCtx->cVerbose)
4003	RTPrintf("Terminating process (PID %RU32) (session ID %RU32) ...\n",
4004	uPID, uID);
4005	CHECK_ERROR_BREAK(pProcess, Terminate());
4006	uProcsTerminated++;
4007	}
4008	else
4009	{
4010	if (ulSessionID != UINT32_MAX)
4011	RTPrintf("No matching process(es) for session ID %RU32 found\n",
4012	ulSessionID);
4013	}
4014
4015	pProcess.setNull();
4016	}
4017
4018	pSession.setNull();
4019	}
4020	}
4021
4022	if (!uSessionsHandled)
4023	RTPrintf("No matching session(s) found\n");
4024
4025	if (uProcsTerminated)
4026	RTPrintf("%RU32 %s terminated\n",
4027	uProcsTerminated, uProcsTerminated == 1 ? "process" : "processes");
4028
4029	} while (0);
4030
4031	pProcess.setNull();
4032	pSession.setNull();
4033
4034	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4035	}
4036
4037
4038	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseSession(PGCTLCMDCTX pCtx, int argc, char **argv)
4039	{
4040	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
4041
4042	enum GETOPTDEF_SESSIONCLOSE
4043	{
4044	GETOPTDEF_SESSIONCLOSE_ALL = 2000
4045	};
4046	static const RTGETOPTDEF s_aOptions[] =
4047	{
4048	GCTLCMD_COMMON_OPTION_DEFS()
4049	{ "--all", GETOPTDEF_SESSIONCLOSE_ALL, RTGETOPT_REQ_NOTHING },
4050	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
4051	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
4052	};
4053
4054	int ch;
4055	RTGETOPTUNION ValueUnion;
4056	RTGETOPTSTATE GetState;
4057	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
4058
4059	ULONG ulSessionID = UINT32_MAX;
4060	Utf8Str strSessionName;
4061
4062	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4063	{
4064	/* For options that require an argument, ValueUnion has received the value. */
4065	switch (ch)
4066	{
4067	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
4068
4069	case 'n': /* Session name pattern */
4070	strSessionName = ValueUnion.psz;
4071	break;
4072
4073	case 'i': /* Session ID */
4074	ulSessionID = ValueUnion.u32;
4075	break;
4076
4077	case GETOPTDEF_SESSIONCLOSE_ALL:
4078	strSessionName = "*";
4079	break;
4080
4081	case VINF_GETOPT_NOT_OPTION:
4082	/** @todo Supply a CSV list of IDs or patterns to close?
4083	* break; */
4084	default:
4085	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION, ch, &ValueUnion);
4086	}
4087	}
4088
4089	if ( strSessionName.isEmpty()
4090	&& ulSessionID == UINT32_MAX)
4091	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION,
4092	"No session ID specified!");
4093
4094	if ( !strSessionName.isEmpty()
4095	&& ulSessionID != UINT32_MAX)
4096	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION,
4097	"Either session ID or name (pattern) must be specified");
4098
4099	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
4100	if (rcExit != RTEXITCODE_SUCCESS)
4101	return rcExit;
4102
4103	HRESULT rc = S_OK;
4104
4105	do
4106	{
4107	bool fSessionFound = false;
4108	size_t cSessionsHandled = 0;
4109
4110	SafeIfaceArray <IGuestSession> collSessions;
4111	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
4112	size_t cSessions = collSessions.size();
4113
4114	for (size_t i = 0; i < cSessions; i++)
4115	{
4116	ComPtr<IGuestSession> pSession = collSessions[i];
4117	Assert(!pSession.isNull());
4118
4119	ULONG uID; /* Session ID */
4120	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
4121	Bstr strName;
4122	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
4123	Utf8Str strNameUtf8(strName); /* Session name */
4124
4125	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
4126	{
4127	fSessionFound = uID == ulSessionID;
4128	}
4129	else /* ... or by naming pattern. */
4130	{
4131	if (RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()))
4132	fSessionFound = true;
4133	}
4134
4135	if (fSessionFound)
4136	{
4137	cSessionsHandled++;
4138
4139	Assert(!pSession.isNull());
4140	if (pCtx->cVerbose)
4141	RTPrintf("Closing guest session ID=#%RU32 \"%s\" ...\n",
4142	uID, strNameUtf8.c_str());
4143	CHECK_ERROR_BREAK(pSession, Close());
4144	if (pCtx->cVerbose)
4145	RTPrintf("Guest session successfully closed\n");
4146
4147	pSession.setNull();
4148	}
4149	}
4150
4151	if (!cSessionsHandled)
4152	{
4153	RTPrintf("No guest session(s) found\n");
4154	rc = E_ABORT; /* To set exit code accordingly. */
4155	}
4156
4157	} while (0);
4158
4159	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4160	}
4161
4162
4163	static DECLCALLBACK(RTEXITCODE) gctlHandleWatch(PGCTLCMDCTX pCtx, int argc, char **argv)
4164	{
4165	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
4166
4167	/*
4168	* Parse arguments.
4169	*/
4170	static const RTGETOPTDEF s_aOptions[] =
4171	{
4172	GCTLCMD_COMMON_OPTION_DEFS()
4173	};
4174
4175	int ch;
4176	RTGETOPTUNION ValueUnion;
4177	RTGETOPTSTATE GetState;
4178	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
4179
4180	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4181	{
4182	/* For options that require an argument, ValueUnion has received the value. */
4183	switch (ch)
4184	{
4185	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
4186
4187	case VINF_GETOPT_NOT_OPTION:
4188	default:
4189	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_WATCH, ch, &ValueUnion);
4190	}
4191	}
4192
4193	/** @todo Specify categories to watch for. */
4194	/** @todo Specify a --timeout for waiting only for a certain amount of time? */
4195
4196	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
4197	if (rcExit != RTEXITCODE_SUCCESS)
4198	return rcExit;
4199
4200	HRESULT rc;
4201
4202	try
4203	{
4204	ComObjPtr<GuestEventListenerImpl> pGuestListener;
4205	do
4206	{
4207	/* Listener creation. */
4208	pGuestListener.createObject();
4209	pGuestListener->init(new GuestEventListener());
4210
4211	/* Register for IGuest events. */
4212	ComPtr<IEventSource> es;
4213	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
4214	com::SafeArray<VBoxEventType_T> eventTypes;
4215	eventTypes.push_back(VBoxEventType_OnGuestSessionRegistered);
4216	/** @todo Also register for VBoxEventType_OnGuestUserStateChanged on demand? */
4217	CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
4218	true /* Active listener */));
4219	/* Note: All other guest control events have to be registered
4220	* as their corresponding objects appear. */
4221
4222	} while (0);
4223
4224	if (pCtx->cVerbose)
4225	RTPrintf("Waiting for events ...\n");
4226
4227	while (!g_fGuestCtrlCanceled)
4228	{
4229	/** @todo Timeout handling (see above)? */
4230	RTThreadSleep(10);
4231	}
4232
4233	if (pCtx->cVerbose)
4234	RTPrintf("Signal caught, exiting ...\n");
4235
4236	if (!pGuestListener.isNull())
4237	{
4238	/* Guest callback unregistration. */
4239	ComPtr<IEventSource> pES;
4240	CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
4241	if (!pES.isNull())
4242	CHECK_ERROR(pES, UnregisterListener(pGuestListener));
4243	pGuestListener.setNull();
4244	}
4245	}
4246	catch (std::bad_alloc &)
4247	{
4248	rc = E_OUTOFMEMORY;
4249	}
4250
4251	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4252	}
4253
4254	/**
4255	* Access the guest control store.
4256	*
4257	* @returns program exit code.
4258	* @note see the command line API description for parameters
4259	*/
4260	RTEXITCODE handleGuestControl(HandlerArg *pArg)
4261	{
4262	AssertPtr(pArg);
4263
4264	#ifdef DEBUG_andy_disabled
4265	if (RT_FAILURE(tstTranslatePath()))
4266	return RTEXITCODE_FAILURE;
4267	#endif
4268
4269	/*
4270	* Command definitions.
4271	*/
4272	static const GCTLCMDDEF s_aCmdDefs[] =
4273	{
4274	{ "run", gctlHandleRun, USAGE_GSTCTRL_RUN, 0, },
4275	{ "start", gctlHandleStart, USAGE_GSTCTRL_START, 0, },
4276	{ "copyfrom", gctlHandleCopyFrom, USAGE_GSTCTRL_COPYFROM, 0, },
4277	{ "copyto", gctlHandleCopyTo, USAGE_GSTCTRL_COPYTO, 0, },
4278
4279	{ "mkdir", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4280	{ "md", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4281	{ "createdirectory", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4282	{ "createdir", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4283
4284	{ "rmdir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4285	{ "removedir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4286	{ "removedirectory", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4287
4288	{ "rm", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4289	{ "removefile", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4290	{ "erase", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4291	{ "del", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4292	{ "delete", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4293
4294	{ "mv", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4295	{ "move", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4296	{ "ren", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4297	{ "rename", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4298
4299	{ "mktemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4300	{ "createtemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4301	{ "createtemporary", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4302
4303	{ "stat", gctlHandleStat, USAGE_GSTCTRL_STAT, 0, },
4304
4305	{ "closeprocess", gctlHandleCloseProcess, USAGE_GSTCTRL_CLOSEPROCESS, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4306	{ "closesession", gctlHandleCloseSession, USAGE_GSTCTRL_CLOSESESSION, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4307	{ "list", gctlHandleList, USAGE_GSTCTRL_LIST, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4308	{ "watch", gctlHandleWatch, USAGE_GSTCTRL_WATCH, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4309
4310	{"updateguestadditions",gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4311	{ "updateadditions", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4312	{ "updatega", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4313	};
4314
4315	/*
4316	* VBoxManage guestcontrol [common-options] <VM> [common-options] <sub-command> ...
4317	*
4318	* Parse common options and VM name until we find a sub-command. Allowing
4319	* the user to put the user and password related options before the
4320	* sub-command makes it easier to edit the command line when doing several
4321	* operations with the same guest user account. (Accidentally, it also
4322	* makes the syntax diagram shorter and easier to read.)
4323	*/
4324	GCTLCMDCTX CmdCtx;
4325	RTEXITCODE rcExit = gctrCmdCtxInit(&CmdCtx, pArg);
4326	if (rcExit == RTEXITCODE_SUCCESS)
4327	{
4328	static const RTGETOPTDEF s_CommonOptions[] = { GCTLCMD_COMMON_OPTION_DEFS() };
4329
4330	int ch;
4331	RTGETOPTUNION ValueUnion;
4332	RTGETOPTSTATE GetState;
4333	RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0, 0 /* No sorting! */);
4334
4335	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4336	{
4337	switch (ch)
4338	{
4339	GCTLCMD_COMMON_OPTION_CASES(&CmdCtx, ch, &ValueUnion);
4340
4341	case VINF_GETOPT_NOT_OPTION:
4342	/* First comes the VM name or UUID. */
4343	if (!CmdCtx.pszVmNameOrUuid)
4344	CmdCtx.pszVmNameOrUuid = ValueUnion.psz;
4345	/*
4346	* The sub-command is next. Look it up and invoke it.
4347	* Note! Currently no warnings about user/password options (like we'll do later on)
4348	* for GCTLCMDCTX_F_SESSION_ANONYMOUS commands. No reason to be too pedantic.
4349	*/
4350	else
4351	{
4352	const char *pszCmd = ValueUnion.psz;
4353	uint32_t iCmd;
4354	for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
4355	if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
4356	{
4357	CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
4358
4359	rcExit = s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
4360	&pArg->argv[GetState.iNext - 1]);
4361
4362	gctlCtxTerm(&CmdCtx);
4363	return rcExit;
4364	}
4365	return errorSyntax(USAGE_GUESTCONTROL, "Unknown sub-command: '%s'", pszCmd);
4366	}
4367	break;
4368
4369	default:
4370	return errorGetOpt(USAGE_GUESTCONTROL, ch, &ValueUnion);
4371	}
4372	}
4373	if (CmdCtx.pszVmNameOrUuid)
4374	rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing sub-command");
4375	else
4376	rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing VM name and sub-command");
4377	}
4378	return rcExit;
4379	}
4380	#endif /* !VBOX_ONLY_DOCS */
4381

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

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

Download in other formats: