VBoxManageGuestCtrl.cpp@ 60756

Last change on this file since 60756 was 60491, checked in by vboxsync, 9 years ago
FE/VBoxManage/VBoxManageGuestCtrl.cpp: Fixed broken verbose output, as specifying --verbose (or -v) only one time did not have an effect anymore, rendering the whole command useless.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 159.7 KB

Line
1	/* $Id: VBoxManageGuestCtrl.cpp 60491 2016-04-14 12:08:53Z vboxsync $ */
2	/** @file
3	* VBoxManage - Implementation of guestcontrol command.
4	*/
5
6	/*
7	* Copyright (C) 2010-2016 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] [--no-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] [--no-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;
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	int vrc = RTEXITCODE_SUCCESS;
1162	switch (enmStatus)
1163	{
1164	case ProcessStatus_TerminatedNormally:
1165	if (uExitCode == 0)
1166	return RTEXITCODE_SUCCESS;
1167	if (!fReturnExitCodes)
1168	return EXITCODEEXEC_CODE;
1169	if (uExitCode <= EXITCODEEXEC_MAPPED_RANGE)
1170	return (RTEXITCODE) (uExitCode + EXITCODEEXEC_MAPPED_DISPLACEMENT);
1171	return EXITCODEEXEC_MAPPED_BIG;
1172
1173	case ProcessStatus_TerminatedAbnormally:
1174	return EXITCODEEXEC_TERM_ABEND;
1175	case ProcessStatus_TerminatedSignal:
1176	return EXITCODEEXEC_TERM_SIGNAL;
1177
1178	#if 0 /* see caller! */
1179	case ProcessStatus_TimedOutKilled:
1180	return EXITCODEEXEC_TIMEOUT;
1181	case ProcessStatus_Down:
1182	return EXITCODEEXEC_DOWN; /* Service/OS is stopping, process was killed. */
1183	case ProcessStatus_Error:
1184	return EXITCODEEXEC_FAILED;
1185
1186	/* The following is probably for detached? */
1187	case ProcessStatus_Starting:
1188	return RTEXITCODE_SUCCESS;
1189	case ProcessStatus_Started:
1190	return RTEXITCODE_SUCCESS;
1191	case ProcessStatus_Paused:
1192	return RTEXITCODE_SUCCESS;
1193	case ProcessStatus_Terminating:
1194	return RTEXITCODE_SUCCESS; /** @todo ???? */
1195	#endif
1196
1197	default:
1198	AssertMsgFailed(("Unknown exit status (%u/%u) from guest process returned!\n", enmStatus, uExitCode));
1199	return RTEXITCODE_FAILURE;
1200	}
1201	}
1202
1203
1204	/**
1205	* Pumps guest output to the host.
1206	*
1207	* @return IPRT status code.
1208	* @param pProcess Pointer to appropriate process object.
1209	* @param hVfsIosDst Where to write the data.
1210	* @param uHandle Handle where to read the data from.
1211	* @param cMsTimeout Timeout (in ms) to wait for the operation to
1212	* complete.
1213	*/
1214	static int gctlRunPumpOutput(IProcess *pProcess, RTVFSIOSTREAM hVfsIosDst, ULONG uHandle, RTMSINTERVAL cMsTimeout)
1215	{
1216	AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
1217	Assert(hVfsIosDst != NIL_RTVFSIOSTREAM);
1218
1219	int vrc;
1220
1221	SafeArray<BYTE> aOutputData;
1222	HRESULT hrc = pProcess->Read(uHandle, _64K, RT_MAX(cMsTimeout, 1), ComSafeArrayAsOutParam(aOutputData));
1223	if (SUCCEEDED(hrc))
1224	{
1225	size_t cbOutputData = aOutputData.size();
1226	if (cbOutputData == 0)
1227	vrc = VINF_SUCCESS;
1228	else
1229	{
1230	BYTE const *pbBuf = aOutputData.raw();
1231	AssertPtr(pbBuf);
1232
1233	vrc = RTVfsIoStrmWrite(hVfsIosDst, pbBuf, cbOutputData, true /fBlocking/, NULL);
1234	if (RT_FAILURE(vrc))
1235	RTMsgError("Unable to write output, rc=%Rrc\n", vrc);
1236	}
1237	}
1238	else
1239	vrc = gctlPrintError(pProcess, COM_IIDOF(IProcess));
1240	return vrc;
1241	}
1242
1243
1244	/**
1245	* Configures a host handle for pumping guest bits.
1246	*
1247	* @returns true if enabled and we successfully configured it.
1248	* @param fEnabled Whether pumping this pipe is configured.
1249	* @param enmHandle The IPRT standard handle designation.
1250	* @param pszName The name for user messages.
1251	* @param enmTransformation The transformation to apply.
1252	* @param phVfsIos Where to return the resulting I/O stream handle.
1253	*/
1254	static bool gctlRunSetupHandle(bool fEnabled, RTHANDLESTD enmHandle, const char *pszName,
1255	kStreamTransform enmTransformation, PRTVFSIOSTREAM phVfsIos)
1256	{
1257	if (fEnabled)
1258	{
1259	int vrc = RTVfsIoStrmFromStdHandle(enmHandle, 0, true /fLeaveOpen/, phVfsIos);
1260	if (RT_SUCCESS(vrc))
1261	{
1262	if (enmTransformation != kStreamTransform_None)
1263	{
1264	RTMsgWarning("Unsupported %s line ending conversion", pszName);
1265	/** @todo Implement dos2unix and unix2dos stream filters. */
1266	}
1267	return true;
1268	}
1269	RTMsgWarning("Error getting %s handle: %Rrc", pszName, vrc);
1270	}
1271	return false;
1272	}
1273
1274
1275	/**
1276	* Returns the remaining time (in ms) based on the start time and a set
1277	* timeout value. Returns RT_INDEFINITE_WAIT if no timeout was specified.
1278	*
1279	* @return RTMSINTERVAL Time left (in ms).
1280	* @param u64StartMs Start time (in ms).
1281	* @param cMsTimeout Timeout value (in ms).
1282	*/
1283	static RTMSINTERVAL gctlRunGetRemainingTime(uint64_t u64StartMs, RTMSINTERVAL cMsTimeout)
1284	{
1285	if (!cMsTimeout \|\| cMsTimeout == RT_INDEFINITE_WAIT) /* If no timeout specified, wait forever. */
1286	return RT_INDEFINITE_WAIT;
1287
1288	uint64_t u64ElapsedMs = RTTimeMilliTS() - u64StartMs;
1289	if (u64ElapsedMs >= cMsTimeout)
1290	return 0;
1291
1292	return cMsTimeout - (RTMSINTERVAL)u64ElapsedMs;
1293	}
1294
1295	/**
1296	* Common handler for the 'run' and 'start' commands.
1297	*
1298	* @returns Command exit code.
1299	* @param pCtx Guest session context.
1300	* @param argc The argument count.
1301	* @param argv The argument vector for this command.
1302	* @param fRunCmd Set if it's 'run' clear if 'start'.
1303	* @param fHelp The help flag for the command.
1304	*/
1305	static RTEXITCODE gctlHandleRunCommon(PGCTLCMDCTX pCtx, int argc, char **argv, bool fRunCmd, uint32_t fHelp)
1306	{
1307	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
1308
1309	/*
1310	* Parse arguments.
1311	*/
1312	enum kGstCtrlRunOpt
1313	{
1314	kGstCtrlRunOpt_IgnoreOrphanedProcesses = 1000,
1315	kGstCtrlRunOpt_NoProfile,
1316	kGstCtrlRunOpt_Dos2Unix,
1317	kGstCtrlRunOpt_Unix2Dos,
1318	kGstCtrlRunOpt_WaitForStdOut,
1319	kGstCtrlRunOpt_NoWaitForStdOut,
1320	kGstCtrlRunOpt_WaitForStdErr,
1321	kGstCtrlRunOpt_NoWaitForStdErr
1322	};
1323	static const RTGETOPTDEF s_aOptions[] =
1324	{
1325	GCTLCMD_COMMON_OPTION_DEFS()
1326	{ "--putenv", 'E', RTGETOPT_REQ_STRING },
1327	{ "--exe", 'e', RTGETOPT_REQ_STRING },
1328	{ "--timeout", 't', RTGETOPT_REQ_UINT32 },
1329	{ "--unquoted-args", 'u', RTGETOPT_REQ_NOTHING },
1330	{ "--ignore-operhaned-processes", kGstCtrlRunOpt_IgnoreOrphanedProcesses, RTGETOPT_REQ_NOTHING },
1331	{ "--no-profile", kGstCtrlRunOpt_NoProfile, RTGETOPT_REQ_NOTHING },
1332	/* run only: 6 - options */
1333	{ "--dos2unix", kGstCtrlRunOpt_Dos2Unix, RTGETOPT_REQ_NOTHING },
1334	{ "--unix2dos", kGstCtrlRunOpt_Unix2Dos, RTGETOPT_REQ_NOTHING },
1335	{ "--no-wait-stdout", kGstCtrlRunOpt_NoWaitForStdOut, RTGETOPT_REQ_NOTHING },
1336	{ "--wait-stdout", kGstCtrlRunOpt_WaitForStdOut, RTGETOPT_REQ_NOTHING },
1337	{ "--no-wait-stderr", kGstCtrlRunOpt_NoWaitForStdErr, RTGETOPT_REQ_NOTHING },
1338	{ "--wait-stderr", kGstCtrlRunOpt_WaitForStdErr, RTGETOPT_REQ_NOTHING },
1339	};
1340
1341	/** @todo stdin handling. */
1342
1343	int ch;
1344	RTGETOPTUNION ValueUnion;
1345	RTGETOPTSTATE GetState;
1346	size_t cOptions =
1347	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions) - (fRunCmd ? 0 : 6),
1348	1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1349
1350	com::SafeArray<ProcessCreateFlag_T> aCreateFlags;
1351	com::SafeArray<ProcessWaitForFlag_T> aWaitFlags;
1352	com::SafeArray<IN_BSTR> aArgs;
1353	com::SafeArray<IN_BSTR> aEnv;
1354	const char * pszImage = NULL;
1355	bool fWaitForStdOut = fRunCmd;
1356	bool fWaitForStdErr = fRunCmd;
1357	RTVFSIOSTREAM hVfsStdOut = NIL_RTVFSIOSTREAM;
1358	RTVFSIOSTREAM hVfsStdErr = NIL_RTVFSIOSTREAM;
1359	enum kStreamTransform enmStdOutTransform = kStreamTransform_None;
1360	enum kStreamTransform enmStdErrTransform = kStreamTransform_None;
1361	RTMSINTERVAL cMsTimeout = 0;
1362
1363	try
1364	{
1365	/* Wait for process start in any case. This is useful for scripting VBoxManage
1366	* when relying on its overall exit code. */
1367	aWaitFlags.push_back(ProcessWaitForFlag_Start);
1368
1369	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
1370	{
1371	/* For options that require an argument, ValueUnion has received the value. */
1372	switch (ch)
1373	{
1374	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
1375
1376	case 'E':
1377	if ( ValueUnion.psz[0] == '\0'
1378	\|\| ValueUnion.psz[0] == '=')
1379	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN,
1380	"Invalid argument variable[=value]: '%s'", ValueUnion.psz);
1381	aEnv.push_back(Bstr(ValueUnion.psz).raw());
1382	break;
1383
1384	case kGstCtrlRunOpt_IgnoreOrphanedProcesses:
1385	aCreateFlags.push_back(ProcessCreateFlag_IgnoreOrphanedProcesses);
1386	break;
1387
1388	case kGstCtrlRunOpt_NoProfile:
1389	aCreateFlags.push_back(ProcessCreateFlag_NoProfile);
1390	break;
1391
1392	case 'e':
1393	pszImage = ValueUnion.psz;
1394	break;
1395
1396	case 'u':
1397	aCreateFlags.push_back(ProcessCreateFlag_UnquotedArguments);
1398	break;
1399
1400	/** @todo Add a hidden flag. */
1401
1402	case 't': /* Timeout */
1403	cMsTimeout = ValueUnion.u32;
1404	break;
1405
1406	/* run only options: */
1407	case kGstCtrlRunOpt_Dos2Unix:
1408	Assert(fRunCmd);
1409	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Dos2Unix;
1410	break;
1411	case kGstCtrlRunOpt_Unix2Dos:
1412	Assert(fRunCmd);
1413	enmStdErrTransform = enmStdOutTransform = kStreamTransform_Unix2Dos;
1414	break;
1415
1416	case kGstCtrlRunOpt_WaitForStdOut:
1417	Assert(fRunCmd);
1418	fWaitForStdOut = true;
1419	break;
1420	case kGstCtrlRunOpt_NoWaitForStdOut:
1421	Assert(fRunCmd);
1422	fWaitForStdOut = false;
1423	break;
1424
1425	case kGstCtrlRunOpt_WaitForStdErr:
1426	Assert(fRunCmd);
1427	fWaitForStdErr = true;
1428	break;
1429	case kGstCtrlRunOpt_NoWaitForStdErr:
1430	Assert(fRunCmd);
1431	fWaitForStdErr = false;
1432	break;
1433
1434	case VINF_GETOPT_NOT_OPTION:
1435	aArgs.push_back(Bstr(ValueUnion.psz).raw());
1436	if (!pszImage)
1437	{
1438	Assert(aArgs.size() == 1);
1439	pszImage = ValueUnion.psz;
1440	}
1441	break;
1442
1443	default:
1444	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, ch, &ValueUnion);
1445
1446	} /* switch */
1447	} /* while RTGetOpt */
1448
1449	/* Must have something to execute. */
1450	if (!pszImage \|\| !*pszImage)
1451	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RUN, "No executable specified!");
1452
1453	/*
1454	* Finalize process creation and wait flags and input/output streams.
1455	*/
1456	if (!fRunCmd)
1457	{
1458	aCreateFlags.push_back(ProcessCreateFlag_WaitForProcessStartOnly);
1459	Assert(!fWaitForStdOut);
1460	Assert(!fWaitForStdErr);
1461	}
1462	else
1463	{
1464	aWaitFlags.push_back(ProcessWaitForFlag_Terminate);
1465	fWaitForStdOut = gctlRunSetupHandle(fWaitForStdOut, RTHANDLESTD_OUTPUT, "stdout", enmStdOutTransform, &hVfsStdOut);
1466	if (fWaitForStdOut)
1467	{
1468	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdOut);
1469	aWaitFlags.push_back(ProcessWaitForFlag_StdOut);
1470	}
1471	fWaitForStdErr = gctlRunSetupHandle(fWaitForStdErr, RTHANDLESTD_ERROR, "stderr", enmStdErrTransform, &hVfsStdErr);
1472	if (fWaitForStdErr)
1473	{
1474	aCreateFlags.push_back(ProcessCreateFlag_WaitForStdErr);
1475	aWaitFlags.push_back(ProcessWaitForFlag_StdErr);
1476	}
1477	}
1478	}
1479	catch (std::bad_alloc &)
1480	{
1481	return RTMsgErrorExit(RTEXITCODE_FAILURE, "VERR_NO_MEMORY\n");
1482	}
1483
1484	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
1485	if (rcExit != RTEXITCODE_SUCCESS)
1486	return rcExit;
1487
1488	HRESULT rc;
1489
1490	try
1491	{
1492	do
1493	{
1494	/* Get current time stamp to later calculate rest of timeout left. */
1495	uint64_t msStart = RTTimeMilliTS();
1496
1497	/*
1498	* Create the process.
1499	*/
1500	if (pCtx->cVerbose)
1501	{
1502	if (cMsTimeout == 0)
1503	RTPrintf("Starting guest process ...\n");
1504	else
1505	RTPrintf("Starting guest process (within %ums)\n", cMsTimeout);
1506	}
1507	ComPtr<IGuestProcess> pProcess;
1508	CHECK_ERROR_BREAK(pCtx->pGuestSession, ProcessCreate(Bstr(pszImage).raw(),
1509	ComSafeArrayAsInParam(aArgs),
1510	ComSafeArrayAsInParam(aEnv),
1511	ComSafeArrayAsInParam(aCreateFlags),
1512	gctlRunGetRemainingTime(msStart, cMsTimeout),
1513	pProcess.asOutParam()));
1514
1515	/*
1516	* Explicitly wait for the guest process to be in a started state.
1517	*/
1518	com::SafeArray<ProcessWaitForFlag_T> aWaitStartFlags;
1519	aWaitStartFlags.push_back(ProcessWaitForFlag_Start);
1520	ProcessWaitResult_T waitResult;
1521	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitStartFlags),
1522	gctlRunGetRemainingTime(msStart, cMsTimeout), &waitResult));
1523
1524	ULONG uPID = 0;
1525	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
1526	if (fRunCmd && pCtx->cVerbose)
1527	RTPrintf("Process '%s' (PID %RU32) started\n", pszImage, uPID);
1528	else if (!fRunCmd && pCtx->cVerbose)
1529	{
1530	/* Just print plain PID to make it easier for scripts
1531	* invoking VBoxManage. */
1532	RTPrintf("[%RU32 - Session %RU32]\n", uPID, pCtx->uSessionID);
1533	}
1534
1535	/*
1536	* Wait for process to exit/start...
1537	*/
1538	RTMSINTERVAL cMsTimeLeft = 1; /* Will be calculated. */
1539	bool fReadStdOut = false;
1540	bool fReadStdErr = false;
1541	bool fCompleted = false;
1542	bool fCompletedStartCmd = false;
1543	int vrc = VINF_SUCCESS;
1544
1545	while ( !fCompleted
1546	&& cMsTimeLeft > 0)
1547	{
1548	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1549	CHECK_ERROR_BREAK(pProcess, WaitForArray(ComSafeArrayAsInParam(aWaitFlags),
1550	RT_MIN(500 /ms/, RT_MAX(cMsTimeLeft, 1 /ms/)),
1551	&waitResult));
1552	switch (waitResult)
1553	{
1554	case ProcessWaitResult_Start:
1555	fCompletedStartCmd = fCompleted = !fRunCmd; /* Only wait for startup if the 'start' command. */
1556	break;
1557	case ProcessWaitResult_StdOut:
1558	fReadStdOut = true;
1559	break;
1560	case ProcessWaitResult_StdErr:
1561	fReadStdErr = true;
1562	break;
1563	case ProcessWaitResult_Terminate:
1564	if (pCtx->cVerbose)
1565	RTPrintf("Process terminated\n");
1566	/* Process terminated, we're done. */
1567	fCompleted = true;
1568	break;
1569	case ProcessWaitResult_WaitFlagNotSupported:
1570	/* The guest does not support waiting for stdout/err, so
1571	* yield to reduce the CPU load due to busy waiting. */
1572	RTThreadYield();
1573	fReadStdOut = fReadStdErr = true;
1574	break;
1575	case ProcessWaitResult_Timeout:
1576	{
1577	/** @todo It is really unclear whether we will get stuck with the timeout
1578	* result here if the guest side times out the process and fails to
1579	* kill the process... To be on the save side, double the IPC and
1580	* check the process status every time we time out. */
1581	ProcessStatus_T enmProcStatus;
1582	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&enmProcStatus));
1583	if ( enmProcStatus == ProcessStatus_TimedOutKilled
1584	\|\| enmProcStatus == ProcessStatus_TimedOutAbnormally)
1585	fCompleted = true;
1586	fReadStdOut = fReadStdErr = true;
1587	break;
1588	}
1589	case ProcessWaitResult_Status:
1590	/* ignore. */
1591	break;
1592	case ProcessWaitResult_Error:
1593	/* waitFor is dead in the water, I think, so better leave the loop. */
1594	vrc = VERR_CALLBACK_RETURN;
1595	break;
1596
1597	case ProcessWaitResult_StdIn: AssertFailed(); /* did ask for this! */ break;
1598	case ProcessWaitResult_None: AssertFailed(); /* used. */ break;
1599	default: AssertFailed(); /* huh? */ break;
1600	}
1601
1602	if (g_fGuestCtrlCanceled)
1603	break;
1604
1605	/*
1606	* Pump output as needed.
1607	*/
1608	if (fReadStdOut)
1609	{
1610	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1611	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdOut, 1 /* StdOut */, cMsTimeLeft);
1612	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1613	vrc = vrc2;
1614	fReadStdOut = false;
1615	}
1616	if (fReadStdErr)
1617	{
1618	cMsTimeLeft = gctlRunGetRemainingTime(msStart, cMsTimeout);
1619	int vrc2 = gctlRunPumpOutput(pProcess, hVfsStdErr, 2 /* StdErr */, cMsTimeLeft);
1620	if (RT_FAILURE(vrc2) && RT_SUCCESS(vrc))
1621	vrc = vrc2;
1622	fReadStdErr = false;
1623	}
1624	if ( RT_FAILURE(vrc)
1625	\|\| g_fGuestCtrlCanceled)
1626	break;
1627
1628	/*
1629	* Process events before looping.
1630	*/
1631	NativeEventQueue::getMainEventQueue()->processEventQueue(0);
1632	} /* while */
1633
1634	/*
1635	* Report status back to the user.
1636	*/
1637	if (g_fGuestCtrlCanceled)
1638	{
1639	if (pCtx->cVerbose)
1640	RTPrintf("Process execution aborted!\n");
1641	rcExit = EXITCODEEXEC_CANCELED;
1642	}
1643	else if (fCompletedStartCmd)
1644	{
1645	if (pCtx->cVerbose)
1646	RTPrintf("Process successfully started!\n");
1647	rcExit = RTEXITCODE_SUCCESS;
1648	}
1649	else if (fCompleted)
1650	{
1651	ProcessStatus_T procStatus;
1652	CHECK_ERROR_BREAK(pProcess, COMGETTER(Status)(&procStatus));
1653	if ( procStatus == ProcessStatus_TerminatedNormally
1654	\|\| procStatus == ProcessStatus_TerminatedAbnormally
1655	\|\| procStatus == ProcessStatus_TerminatedSignal)
1656	{
1657	LONG lExitCode;
1658	CHECK_ERROR_BREAK(pProcess, COMGETTER(ExitCode)(&lExitCode));
1659	if (pCtx->cVerbose)
1660	RTPrintf("Exit code=%u (Status=%u [%s])\n",
1661	lExitCode, procStatus, gctlProcessStatusToText(procStatus));
1662
1663	rcExit = gctlRunCalculateExitCode(procStatus, lExitCode, true /fReturnExitCodes/);
1664	}
1665	else if ( procStatus == ProcessStatus_TimedOutKilled
1666	\|\| procStatus == ProcessStatus_TimedOutAbnormally)
1667	{
1668	if (pCtx->cVerbose)
1669	RTPrintf("Process timed out (guest side) and %s\n",
1670	procStatus == ProcessStatus_TimedOutAbnormally
1671	? "failed to terminate so far" : "was terminated");
1672	rcExit = EXITCODEEXEC_TIMEOUT;
1673	}
1674	else
1675	{
1676	if (pCtx->cVerbose)
1677	RTPrintf("Process now is in status [%s] (unexpected)\n", gctlProcessStatusToText(procStatus));
1678	rcExit = RTEXITCODE_FAILURE;
1679	}
1680	}
1681	else if (RT_FAILURE_NP(vrc))
1682	{
1683	if (pCtx->cVerbose)
1684	RTPrintf("Process monitor loop quit with vrc=%Rrc\n", vrc);
1685	rcExit = RTEXITCODE_FAILURE;
1686	}
1687	else
1688	{
1689	if (pCtx->cVerbose)
1690	RTPrintf("Process monitor loop timed out\n");
1691	rcExit = EXITCODEEXEC_TIMEOUT;
1692	}
1693
1694	} while (0);
1695	}
1696	catch (std::bad_alloc)
1697	{
1698	rc = E_OUTOFMEMORY;
1699	}
1700
1701	/*
1702	* Decide what to do with the guest session.
1703	*
1704	* If it's the 'start' command where detach the guest process after
1705	* starting, don't close the guest session it is part of, except on
1706	* failure or ctrl-c.
1707	*
1708	* For the 'run' command the guest process quits with us.
1709	*/
1710	if (!fRunCmd && SUCCEEDED(rc) && !g_fGuestCtrlCanceled)
1711	pCtx->fDetachGuestSession = true;
1712
1713	/* Make sure we return failure on failure. */
1714	if (FAILED(rc) && rcExit == RTEXITCODE_SUCCESS)
1715	rcExit = RTEXITCODE_FAILURE;
1716	return rcExit;
1717	}
1718
1719
1720	static DECLCALLBACK(RTEXITCODE) gctlHandleRun(PGCTLCMDCTX pCtx, int argc, char **argv)
1721	{
1722	return gctlHandleRunCommon(pCtx, argc, argv, true /fRunCmd/, USAGE_GSTCTRL_RUN);
1723	}
1724
1725
1726	static DECLCALLBACK(RTEXITCODE) gctlHandleStart(PGCTLCMDCTX pCtx, int argc, char **argv)
1727	{
1728	return gctlHandleRunCommon(pCtx, argc, argv, false /fRunCmd/, USAGE_GSTCTRL_START);
1729	}
1730
1731
1732	/** bird: This is just a code conversion tool, flags are better defined by
1733	* the preprocessor, in general. But the code was using obsoleted
1734	* main flags for internal purposes (in a uint32_t) without passing them
1735	* along, or it seemed that way. Enum means compiler checks types. */
1736	enum gctlCopyFlags
1737	{
1738	kGctlCopyFlags_None = 0,
1739	kGctlCopyFlags_Recursive = RT_BIT(1),
1740	kGctlCopyFlags_FollowLinks = RT_BIT(2)
1741	};
1742
1743
1744	/**
1745	* Creates a copy context structure which then can be used with various
1746	* guest control copy functions. Needs to be free'd with gctlCopyContextFree().
1747	*
1748	* @return IPRT status code.
1749	* @param pCtx Pointer to command context.
1750	* @param fDryRun Flag indicating if we want to run a dry run only.
1751	* @param fHostToGuest Flag indicating if we want to copy from host to guest
1752	* or vice versa.
1753	* @param strSessionName Session name (only for identification purposes).
1754	* @param ppContext Pointer which receives the allocated copy context.
1755	*/
1756	static int gctlCopyContextCreate(PGCTLCMDCTX pCtx, bool fDryRun, bool fHostToGuest,
1757	const Utf8Str &strSessionName,
1758	PCOPYCONTEXT *ppContext)
1759	{
1760	AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1761
1762	int vrc = VINF_SUCCESS;
1763	try
1764	{
1765	PCOPYCONTEXT pContext = new COPYCONTEXT();
1766
1767	pContext->pCmdCtx = pCtx;
1768	pContext->fDryRun = fDryRun;
1769	pContext->fHostToGuest = fHostToGuest;
1770
1771	*ppContext = pContext;
1772	}
1773	catch (std::bad_alloc)
1774	{
1775	vrc = VERR_NO_MEMORY;
1776	}
1777
1778	return vrc;
1779	}
1780
1781	/**
1782	* Frees are previously allocated copy context structure.
1783	*
1784	* @param pContext Pointer to copy context to free.
1785	*/
1786	static void gctlCopyContextFree(PCOPYCONTEXT pContext)
1787	{
1788	if (pContext)
1789	delete pContext;
1790	}
1791
1792	/**
1793	* Translates a source path to a destination path (can be both sides,
1794	* either host or guest). The source root is needed to determine the start
1795	* of the relative source path which also needs to present in the destination
1796	* path.
1797	*
1798	* @return IPRT status code.
1799	* @param pszSourceRoot Source root path. No trailing directory slash!
1800	* @param pszSource Actual source to transform. Must begin with
1801	* the source root path!
1802	* @param pszDest Destination path.
1803	* @param ppszTranslated Pointer to the allocated, translated destination
1804	* path. Must be free'd with RTStrFree().
1805	*/
1806	static int gctlCopyTranslatePath(const char pszSourceRoot, const char pszSource,
1807	const char pszDest, char *ppszTranslated)
1808	{
1809	AssertPtrReturn(pszSourceRoot, VERR_INVALID_POINTER);
1810	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
1811	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
1812	AssertPtrReturn(ppszTranslated, VERR_INVALID_POINTER);
1813	#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} */
1814	AssertReturn(RTPathStartsWith(pszSource, pszSourceRoot), VERR_INVALID_PARAMETER);
1815	#endif
1816
1817	/* Construct the relative dest destination path by "subtracting" the
1818	* source from the source root, e.g.
1819	*
1820	* source root path = "e:\foo\", source = "e:\foo\bar"
1821	* dest = "d:\baz\"
1822	* translated = "d:\baz\bar\"
1823	*/
1824	char szTranslated[RTPATH_MAX];
1825	size_t srcOff = strlen(pszSourceRoot);
1826	AssertReturn(srcOff, VERR_INVALID_PARAMETER);
1827
1828	char *pszDestPath = RTStrDup(pszDest);
1829	AssertPtrReturn(pszDestPath, VERR_NO_MEMORY);
1830
1831	int vrc;
1832	if (!RTPathFilename(pszDestPath))
1833	{
1834	vrc = RTPathJoin(szTranslated, sizeof(szTranslated),
1835	pszDestPath, &pszSource[srcOff]);
1836	}
1837	else
1838	{
1839	char *pszDestFileName = RTStrDup(RTPathFilename(pszDestPath));
1840	if (pszDestFileName)
1841	{
1842	RTPathStripFilename(pszDestPath);
1843	vrc = RTPathJoin(szTranslated, sizeof(szTranslated),
1844	pszDestPath, pszDestFileName);
1845	RTStrFree(pszDestFileName);
1846	}
1847	else
1848	vrc = VERR_NO_MEMORY;
1849	}
1850	RTStrFree(pszDestPath);
1851
1852	if (RT_SUCCESS(vrc))
1853	{
1854	*ppszTranslated = RTStrDup(szTranslated);
1855	#if 0
1856	RTPrintf("Root: %s, Source: %s, Dest: %s, Translated: %s\n",
1857	pszSourceRoot, pszSource, pszDest, *ppszTranslated);
1858	#endif
1859	}
1860	return vrc;
1861	}
1862
1863	#ifdef DEBUG_andy
1864	static int tstTranslatePath()
1865	{
1866	RTAssertSetMayPanic(false /* Do not freak out, please. */);
1867
1868	static struct
1869	{
1870	const char *pszSourceRoot;
1871	const char *pszSource;
1872	const char *pszDest;
1873	const char *pszTranslated;
1874	int iResult;
1875	} aTests[] =
1876	{
1877	/* Invalid stuff. */
1878	{ NULL, NULL, NULL, NULL, VERR_INVALID_POINTER },
1879	#ifdef RT_OS_WINDOWS
1880	/* Windows paths. */
1881	{ "c:\\foo", "c:\\foo\\bar.txt", "c:\\test", "c:\\test\\bar.txt", VINF_SUCCESS },
1882	{ "c:\\foo", "c:\\foo\\baz\\bar.txt", "c:\\test", "c:\\test\\baz\\bar.txt", VINF_SUCCESS },
1883	#else /* RT_OS_WINDOWS */
1884	{ "/home/test/foo", "/home/test/foo/bar.txt", "/opt/test", "/opt/test/bar.txt", VINF_SUCCESS },
1885	{ "/home/test/foo", "/home/test/foo/baz/bar.txt", "/opt/test", "/opt/test/baz/bar.txt", VINF_SUCCESS },
1886	#endif /* !RT_OS_WINDOWS */
1887	/* Mixed paths*/
1888	/** @todo */
1889	{ NULL }
1890	};
1891
1892	size_t iTest = 0;
1893	for (iTest; iTest < RT_ELEMENTS(aTests); iTest++)
1894	{
1895	RTPrintf("=> Test %d\n", iTest);
1896	RTPrintf("\tSourceRoot=%s, Source=%s, Dest=%s\n",
1897	aTests[iTest].pszSourceRoot, aTests[iTest].pszSource, aTests[iTest].pszDest);
1898
1899	char *pszTranslated = NULL;
1900	int iResult = gctlCopyTranslatePath(aTests[iTest].pszSourceRoot, aTests[iTest].pszSource,
1901	aTests[iTest].pszDest, &pszTranslated);
1902	if (iResult != aTests[iTest].iResult)
1903	{
1904	RTPrintf("\tReturned %Rrc, expected %Rrc\n",
1905	iResult, aTests[iTest].iResult);
1906	}
1907	else if ( pszTranslated
1908	&& strcmp(pszTranslated, aTests[iTest].pszTranslated))
1909	{
1910	RTPrintf("\tReturned translated path %s, expected %s\n",
1911	pszTranslated, aTests[iTest].pszTranslated);
1912	}
1913
1914	if (pszTranslated)
1915	{
1916	RTPrintf("\tTranslated=%s\n", pszTranslated);
1917	RTStrFree(pszTranslated);
1918	}
1919	}
1920
1921	return VINF_SUCCESS; /* @todo */
1922	}
1923	#endif
1924
1925	/**
1926	* Creates a directory on the destination, based on the current copy
1927	* context.
1928	*
1929	* @return IPRT status code.
1930	* @param pContext Pointer to current copy control context.
1931	* @param pszDir Directory to create.
1932	*/
1933	static int gctlCopyDirCreate(PCOPYCONTEXT pContext, const char *pszDir)
1934	{
1935	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
1936	AssertPtrReturn(pszDir, VERR_INVALID_POINTER);
1937
1938	bool fDirExists;
1939	int vrc = gctlCopyDirExists(pContext, pContext->fHostToGuest, pszDir, &fDirExists);
1940	if ( RT_SUCCESS(vrc)
1941	&& fDirExists)
1942	{
1943	if (pContext->pCmdCtx->cVerbose)
1944	RTPrintf("Directory \"%s\" already exists\n", pszDir);
1945	return VINF_SUCCESS;
1946	}
1947
1948	/* If querying for a directory existence fails there's no point of even trying
1949	* to create such a directory. */
1950	if (RT_FAILURE(vrc))
1951	return vrc;
1952
1953	if (pContext->pCmdCtx->cVerbose)
1954	RTPrintf("Creating directory \"%s\" ...\n", pszDir);
1955
1956	if (pContext->fDryRun)
1957	return VINF_SUCCESS;
1958
1959	if (pContext->fHostToGuest) /* We want to create directories on the guest. */
1960	{
1961	SafeArray<DirectoryCreateFlag_T> dirCreateFlags;
1962	dirCreateFlags.push_back(DirectoryCreateFlag_Parents);
1963	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryCreate(Bstr(pszDir).raw(),
1964	0700, ComSafeArrayAsInParam(dirCreateFlags));
1965	if (FAILED(rc))
1966	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
1967	}
1968	else /* ... or on the host. */
1969	{
1970	vrc = RTDirCreateFullPath(pszDir, 0700);
1971	if (vrc == VERR_ALREADY_EXISTS)
1972	vrc = VINF_SUCCESS;
1973	}
1974	return vrc;
1975	}
1976
1977	/**
1978	* Checks whether a specific host/guest directory exists.
1979	*
1980	* @return IPRT status code.
1981	* @param pContext Pointer to current copy control context.
1982	* @param fOnGuest true if directory needs to be checked on the guest
1983	* or false if on the host.
1984	* @param pszDir Actual directory to check.
1985	* @param fExists Pointer which receives the result if the
1986	* given directory exists or not.
1987	*/
1988	static int gctlCopyDirExists(PCOPYCONTEXT pContext, bool fOnGuest,
1989	const char pszDir, bool fExists)
1990	{
1991	AssertPtrReturn(pContext, false);
1992	AssertPtrReturn(pszDir, false);
1993	AssertPtrReturn(fExists, false);
1994
1995	int vrc = VINF_SUCCESS;
1996	if (fOnGuest)
1997	{
1998	BOOL fDirExists = FALSE;
1999	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryExists(Bstr(pszDir).raw(), FALSE /followSymlinks/, &fDirExists);
2000	if (SUCCEEDED(rc))
2001	*fExists = fDirExists != FALSE;
2002	else
2003	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2004	}
2005	else
2006	*fExists = RTDirExists(pszDir);
2007	return vrc;
2008	}
2009
2010	/**
2011	* Checks whether a specific directory exists on the destination, based
2012	* on the current copy context.
2013	*
2014	* @return IPRT status code.
2015	* @param pContext Pointer to current copy control context.
2016	* @param pszDir Actual directory to check.
2017	* @param fExists Pointer which receives the result if the
2018	* given directory exists or not.
2019	*/
2020	static int gctlCopyDirExistsOnDest(PCOPYCONTEXT pContext, const char *pszDir,
2021	bool *fExists)
2022	{
2023	return gctlCopyDirExists(pContext, pContext->fHostToGuest,
2024	pszDir, fExists);
2025	}
2026
2027	/**
2028	* Checks whether a specific directory exists on the source, based
2029	* on the current copy context.
2030	*
2031	* @return IPRT status code.
2032	* @param pContext Pointer to current copy control context.
2033	* @param pszDir Actual directory to check.
2034	* @param fExists Pointer which receives the result if the
2035	* given directory exists or not.
2036	*/
2037	static int gctlCopyDirExistsOnSource(PCOPYCONTEXT pContext, const char *pszDir,
2038	bool *fExists)
2039	{
2040	return gctlCopyDirExists(pContext, !pContext->fHostToGuest,
2041	pszDir, fExists);
2042	}
2043
2044	/**
2045	* Checks whether a specific host/guest file exists.
2046	*
2047	* @return IPRT status code.
2048	* @param pContext Pointer to current copy control context.
2049	* @param bGuest true if file needs to be checked on the guest
2050	* or false if on the host.
2051	* @param pszFile Actual file to check.
2052	* @param fExists Pointer which receives the result if the
2053	* given file exists or not.
2054	*/
2055	static int gctlCopyFileExists(PCOPYCONTEXT pContext, bool bOnGuest,
2056	const char pszFile, bool fExists)
2057	{
2058	AssertPtrReturn(pContext, false);
2059	AssertPtrReturn(pszFile, false);
2060	AssertPtrReturn(fExists, false);
2061
2062	int vrc = VINF_SUCCESS;
2063	if (bOnGuest)
2064	{
2065	BOOL fFileExists = FALSE;
2066	HRESULT rc = pContext->pCmdCtx->pGuestSession->FileExists(Bstr(pszFile).raw(), FALSE /followSymlinks/, &fFileExists);
2067	if (SUCCEEDED(rc))
2068	*fExists = fFileExists != FALSE;
2069	else
2070	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2071	}
2072	else
2073	*fExists = RTFileExists(pszFile);
2074	return vrc;
2075	}
2076
2077	/**
2078	* Checks whether a specific file exists on the destination, based on the
2079	* current copy context.
2080	*
2081	* @return IPRT status code.
2082	* @param pContext Pointer to current copy control context.
2083	* @param pszFile Actual file to check.
2084	* @param fExists Pointer which receives the result if the
2085	* given file exists or not.
2086	*/
2087	static int gctlCopyFileExistsOnDest(PCOPYCONTEXT pContext, const char *pszFile,
2088	bool *fExists)
2089	{
2090	return gctlCopyFileExists(pContext, pContext->fHostToGuest,
2091	pszFile, fExists);
2092	}
2093
2094	/**
2095	* Checks whether a specific file exists on the source, based on the
2096	* current copy context.
2097	*
2098	* @return IPRT status code.
2099	* @param pContext Pointer to current copy control context.
2100	* @param pszFile Actual file to check.
2101	* @param fExists Pointer which receives the result if the
2102	* given file exists or not.
2103	*/
2104	static int gctlCopyFileExistsOnSource(PCOPYCONTEXT pContext, const char *pszFile,
2105	bool *fExists)
2106	{
2107	return gctlCopyFileExists(pContext, !pContext->fHostToGuest,
2108	pszFile, fExists);
2109	}
2110
2111	/**
2112	* Copies a source file to the destination.
2113	*
2114	* @return IPRT status code.
2115	* @param pContext Pointer to current copy control context.
2116	* @param pszFileSource Source file to copy to the destination.
2117	* @param pszFileDest Name of copied file on the destination.
2118	* @param enmFlags Copy flags. No supported at the moment and
2119	* needs to be set to 0.
2120	*/
2121	static int gctlCopyFileToDest(PCOPYCONTEXT pContext, const char *pszFileSource,
2122	const char *pszFileDest, gctlCopyFlags enmFlags)
2123	{
2124	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2125	AssertPtrReturn(pszFileSource, VERR_INVALID_POINTER);
2126	AssertPtrReturn(pszFileDest, VERR_INVALID_POINTER);
2127	AssertReturn(enmFlags == kGctlCopyFlags_None, VERR_INVALID_PARAMETER); /* No flags supported yet. */
2128
2129	if (pContext->pCmdCtx->cVerbose)
2130	RTPrintf("Copying \"%s\" to \"%s\" ...\n", pszFileSource, pszFileDest);
2131
2132	if (pContext->fDryRun)
2133	return VINF_SUCCESS;
2134
2135	int vrc = VINF_SUCCESS;
2136	ComPtr<IProgress> pProgress;
2137	HRESULT rc;
2138	if (pContext->fHostToGuest)
2139	{
2140	SafeArray<FileCopyFlag_T> copyFlags;
2141	rc = pContext->pCmdCtx->pGuestSession->FileCopyToGuest(Bstr(pszFileSource).raw(), Bstr(pszFileDest).raw(),
2142	ComSafeArrayAsInParam(copyFlags),
2143	pProgress.asOutParam());
2144	}
2145	else
2146	{
2147	SafeArray<FileCopyFlag_T> copyFlags;
2148	rc = pContext->pCmdCtx->pGuestSession->FileCopyFromGuest(Bstr(pszFileSource).raw(), Bstr(pszFileDest).raw(),
2149	ComSafeArrayAsInParam(copyFlags),
2150	pProgress.asOutParam());
2151	}
2152
2153	if (FAILED(rc))
2154	{
2155	vrc = gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2156	}
2157	else
2158	{
2159	if (pContext->pCmdCtx->cVerbose)
2160	rc = showProgress(pProgress);
2161	else
2162	rc = pProgress->WaitForCompletion(-1 /* No timeout */);
2163	if (SUCCEEDED(rc))
2164	CHECK_PROGRESS_ERROR(pProgress, ("File copy failed"));
2165	vrc = gctlPrintProgressError(pProgress);
2166	}
2167
2168	return vrc;
2169	}
2170
2171	/**
2172	* Copys a directory (tree) from host to the guest.
2173	*
2174	* @return IPRT status code.
2175	* @param pContext Pointer to current copy control context.
2176	* @param pszSource Source directory on the host to copy to the guest.
2177	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2178	* @param pszDest Destination directory on the guest.
2179	* @param enmFlags Copy flags, such as recursive copying.
2180	* @param pszSubDir Current sub directory to handle. Needs to NULL and only
2181	* is needed for recursion.
2182	*/
2183	static int gctlCopyDirToGuest(PCOPYCONTEXT pContext,
2184	const char pszSource, const char pszFilter,
2185	const char *pszDest, enum gctlCopyFlags enmFlags,
2186	const char pszSubDir / For recursion. */)
2187	{
2188	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2189	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2190	/* Filter is optional. */
2191	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
2192	/* Sub directory is optional. */
2193
2194	/*
2195	* Construct current path.
2196	*/
2197	char szCurDir[RTPATH_MAX];
2198	int vrc = RTStrCopy(szCurDir, sizeof(szCurDir), pszSource);
2199	if (RT_SUCCESS(vrc) && pszSubDir)
2200	vrc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
2201
2202	if (pContext->pCmdCtx->cVerbose)
2203	RTPrintf("Processing host directory: %s\n", szCurDir);
2204
2205	/* Flag indicating whether the current directory was created on the
2206	* target or not. */
2207	bool fDirCreated = false;
2208
2209	/*
2210	* Open directory without a filter - RTDirOpenFiltered unfortunately
2211	* cannot handle sub directories so we have to do the filtering ourselves.
2212	*/
2213	PRTDIR pDir = NULL;
2214	if (RT_SUCCESS(vrc))
2215	{
2216	vrc = RTDirOpen(&pDir, szCurDir);
2217	if (RT_FAILURE(vrc))
2218	pDir = NULL;
2219	}
2220	if (RT_SUCCESS(vrc))
2221	{
2222	/*
2223	* Enumerate the directory tree.
2224	*/
2225	while (RT_SUCCESS(vrc))
2226	{
2227	RTDIRENTRY DirEntry;
2228	vrc = RTDirRead(pDir, &DirEntry, NULL);
2229	if (RT_FAILURE(vrc))
2230	{
2231	if (vrc == VERR_NO_MORE_FILES)
2232	vrc = VINF_SUCCESS;
2233	break;
2234	}
2235	/** @todo r=bird: This ain't gonna work on most UNIX file systems because
2236	* enmType is RTDIRENTRYTYPE_UNKNOWN. This is clearly documented in
2237	* RTDIRENTRY::enmType. For trunk, RTDirQueryUnknownType can be used. */
2238	switch (DirEntry.enmType)
2239	{
2240	case RTDIRENTRYTYPE_DIRECTORY:
2241	{
2242	/* Skip "." and ".." entries. */
2243	if ( !strcmp(DirEntry.szName, ".")
2244	\|\| !strcmp(DirEntry.szName, ".."))
2245	break;
2246
2247	if (pContext->pCmdCtx->cVerbose)
2248	RTPrintf("Directory: %s\n", DirEntry.szName);
2249
2250	if (enmFlags & kGctlCopyFlags_Recursive)
2251	{
2252	char *pszNewSub = NULL;
2253	if (pszSubDir)
2254	pszNewSub = RTPathJoinA(pszSubDir, DirEntry.szName);
2255	else
2256	{
2257	pszNewSub = RTStrDup(DirEntry.szName);
2258	RTPathStripTrailingSlash(pszNewSub);
2259	}
2260
2261	if (pszNewSub)
2262	{
2263	vrc = gctlCopyDirToGuest(pContext,
2264	pszSource, pszFilter,
2265	pszDest, enmFlags, pszNewSub);
2266	RTStrFree(pszNewSub);
2267	}
2268	else
2269	vrc = VERR_NO_MEMORY;
2270	}
2271	break;
2272	}
2273
2274	case RTDIRENTRYTYPE_SYMLINK:
2275	if ( (enmFlags & kGctlCopyFlags_Recursive)
2276	&& (enmFlags & kGctlCopyFlags_FollowLinks))
2277	{
2278	/* Fall through to next case is intentional. */
2279	}
2280	else
2281	break;
2282
2283	case RTDIRENTRYTYPE_FILE:
2284	{
2285	if ( pszFilter
2286	&& !RTStrSimplePatternMatch(pszFilter, DirEntry.szName))
2287	{
2288	break; /* Filter does not match. */
2289	}
2290
2291	if (pContext->pCmdCtx->cVerbose)
2292	RTPrintf("File: %s\n", DirEntry.szName);
2293
2294	if (!fDirCreated)
2295	{
2296	char *pszDestDir;
2297	vrc = gctlCopyTranslatePath(pszSource, szCurDir,
2298	pszDest, &pszDestDir);
2299	if (RT_SUCCESS(vrc))
2300	{
2301	vrc = gctlCopyDirCreate(pContext, pszDestDir);
2302	RTStrFree(pszDestDir);
2303
2304	fDirCreated = true;
2305	}
2306	}
2307
2308	if (RT_SUCCESS(vrc))
2309	{
2310	char *pszFileSource = RTPathJoinA(szCurDir, DirEntry.szName);
2311	if (pszFileSource)
2312	{
2313	char *pszFileDest;
2314	vrc = gctlCopyTranslatePath(pszSource, pszFileSource,
2315	pszDest, &pszFileDest);
2316	if (RT_SUCCESS(vrc))
2317	{
2318	vrc = gctlCopyFileToDest(pContext, pszFileSource,
2319	pszFileDest, kGctlCopyFlags_None);
2320	RTStrFree(pszFileDest);
2321	}
2322	RTStrFree(pszFileSource);
2323	}
2324	}
2325	break;
2326	}
2327
2328	default:
2329	break;
2330	}
2331	if (RT_FAILURE(vrc))
2332	break;
2333	}
2334
2335	RTDirClose(pDir);
2336	}
2337	return vrc;
2338	}
2339
2340	/**
2341	* Copys a directory (tree) from guest to the host.
2342	*
2343	* @return IPRT status code.
2344	* @param pContext Pointer to current copy control context.
2345	* @param pszSource Source directory on the guest to copy to the host.
2346	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2347	* @param pszDest Destination directory on the host.
2348	* @param enmFlags Copy flags, such as recursive copying.
2349	* @param pszSubDir Current sub directory to handle. Needs to NULL and only
2350	* is needed for recursion.
2351	*/
2352	static int gctlCopyDirToHost(PCOPYCONTEXT pContext,
2353	const char pszSource, const char pszFilter,
2354	const char *pszDest, gctlCopyFlags enmFlags,
2355	const char pszSubDir / For recursion. */)
2356	{
2357	AssertPtrReturn(pContext, VERR_INVALID_POINTER);
2358	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2359	/* Filter is optional. */
2360	AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
2361	/* Sub directory is optional. */
2362
2363	/*
2364	* Construct current path.
2365	*/
2366	char szCurDir[RTPATH_MAX];
2367	int vrc = RTStrCopy(szCurDir, sizeof(szCurDir), pszSource);
2368	if (RT_SUCCESS(vrc) && pszSubDir)
2369	vrc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
2370
2371	if (RT_FAILURE(vrc))
2372	return vrc;
2373
2374	if (pContext->pCmdCtx->cVerbose)
2375	RTPrintf("Processing guest directory: %s\n", szCurDir);
2376
2377	/* Flag indicating whether the current directory was created on the
2378	* target or not. */
2379	bool fDirCreated = false;
2380	SafeArray<DirectoryOpenFlag_T> dirOpenFlags; /* No flags supported yet. */
2381	ComPtr<IGuestDirectory> pDirectory;
2382	HRESULT rc = pContext->pCmdCtx->pGuestSession->DirectoryOpen(Bstr(szCurDir).raw(), Bstr(pszFilter).raw(),
2383	ComSafeArrayAsInParam(dirOpenFlags),
2384	pDirectory.asOutParam());
2385	if (FAILED(rc))
2386	return gctlPrintError(pContext->pCmdCtx->pGuestSession, COM_IIDOF(IGuestSession));
2387	ComPtr<IFsObjInfo> dirEntry;
2388	while (true)
2389	{
2390	rc = pDirectory->Read(dirEntry.asOutParam());
2391	if (FAILED(rc))
2392	break;
2393
2394	FsObjType_T enmType;
2395	dirEntry->COMGETTER(Type)(&enmType);
2396
2397	Bstr strName;
2398	dirEntry->COMGETTER(Name)(strName.asOutParam());
2399
2400	switch (enmType)
2401	{
2402	case FsObjType_Directory:
2403	{
2404	Assert(!strName.isEmpty());
2405
2406	/* Skip "." and ".." entries. */
2407	if ( !strName.compare(Bstr("."))
2408	\|\| !strName.compare(Bstr("..")))
2409	break;
2410
2411	if (pContext->pCmdCtx->cVerbose)
2412	{
2413	Utf8Str strDir(strName);
2414	RTPrintf("Directory: %s\n", strDir.c_str());
2415	}
2416
2417	if (enmFlags & kGctlCopyFlags_Recursive)
2418	{
2419	Utf8Str strDir(strName);
2420	char *pszNewSub = NULL;
2421	if (pszSubDir)
2422	pszNewSub = RTPathJoinA(pszSubDir, strDir.c_str());
2423	else
2424	{
2425	pszNewSub = RTStrDup(strDir.c_str());
2426	RTPathStripTrailingSlash(pszNewSub);
2427	}
2428	if (pszNewSub)
2429	{
2430	vrc = gctlCopyDirToHost(pContext,
2431	pszSource, pszFilter,
2432	pszDest, enmFlags, pszNewSub);
2433	RTStrFree(pszNewSub);
2434	}
2435	else
2436	vrc = VERR_NO_MEMORY;
2437	}
2438	break;
2439	}
2440
2441	case FsObjType_Symlink:
2442	if ( (enmFlags & kGctlCopyFlags_Recursive)
2443	&& (enmFlags & kGctlCopyFlags_FollowLinks))
2444	{
2445	/* Fall through to next case is intentional. */
2446	}
2447	else
2448	break;
2449
2450	case FsObjType_File:
2451	{
2452	Assert(!strName.isEmpty());
2453
2454	Utf8Str strFile(strName);
2455	if ( pszFilter
2456	&& !RTStrSimplePatternMatch(pszFilter, strFile.c_str()))
2457	{
2458	break; /* Filter does not match. */
2459	}
2460
2461	if (pContext->pCmdCtx->cVerbose)
2462	RTPrintf("File: %s\n", strFile.c_str());
2463
2464	if (!fDirCreated)
2465	{
2466	char *pszDestDir;
2467	vrc = gctlCopyTranslatePath(pszSource, szCurDir,
2468	pszDest, &pszDestDir);
2469	if (RT_SUCCESS(vrc))
2470	{
2471	vrc = gctlCopyDirCreate(pContext, pszDestDir);
2472	RTStrFree(pszDestDir);
2473
2474	fDirCreated = true;
2475	}
2476	}
2477
2478	if (RT_SUCCESS(vrc))
2479	{
2480	char *pszFileSource = RTPathJoinA(szCurDir, strFile.c_str());
2481	if (pszFileSource)
2482	{
2483	char *pszFileDest;
2484	vrc = gctlCopyTranslatePath(pszSource, pszFileSource,
2485	pszDest, &pszFileDest);
2486	if (RT_SUCCESS(vrc))
2487	{
2488	vrc = gctlCopyFileToDest(pContext, pszFileSource,
2489	pszFileDest, kGctlCopyFlags_None);
2490	RTStrFree(pszFileDest);
2491	}
2492	RTStrFree(pszFileSource);
2493	}
2494	else
2495	vrc = VERR_NO_MEMORY;
2496	}
2497	break;
2498	}
2499
2500	default:
2501	RTPrintf("Warning: Directory entry of type %ld not handled, skipping ...\n",
2502	enmType);
2503	break;
2504	}
2505
2506	if (RT_FAILURE(vrc))
2507	break;
2508	}
2509
2510	if (RT_UNLIKELY(FAILED(rc)))
2511	{
2512	switch (rc)
2513	{
2514	case E_ABORT: /* No more directory entries left to process. */
2515	break;
2516
2517	case VBOX_E_FILE_ERROR: /* Current entry cannot be accessed to
2518	to missing rights. */
2519	{
2520	RTPrintf("Warning: Cannot access \"%s\", skipping ...\n",
2521	szCurDir);
2522	break;
2523	}
2524
2525	default:
2526	vrc = gctlPrintError(pDirectory, COM_IIDOF(IGuestDirectory));
2527	break;
2528	}
2529	}
2530
2531	HRESULT rc2 = pDirectory->Close();
2532	if (FAILED(rc2))
2533	{
2534	int vrc2 = gctlPrintError(pDirectory, COM_IIDOF(IGuestDirectory));
2535	if (RT_SUCCESS(vrc))
2536	vrc = vrc2;
2537	}
2538	else if (SUCCEEDED(rc))
2539	rc = rc2;
2540
2541	return vrc;
2542	}
2543
2544	/**
2545	* Copys a directory (tree) to the destination, based on the current copy
2546	* context.
2547	*
2548	* @return IPRT status code.
2549	* @param pContext Pointer to current copy control context.
2550	* @param pszSource Source directory to copy to the destination.
2551	* @param pszFilter DOS-style wildcard filter (?, *). Optional.
2552	* @param pszDest Destination directory where to copy in the source
2553	* source directory.
2554	* @param enmFlags Copy flags, such as recursive copying.
2555	*/
2556	static int gctlCopyDirToDest(PCOPYCONTEXT pContext,
2557	const char pszSource, const char pszFilter,
2558	const char *pszDest, enum gctlCopyFlags enmFlags)
2559	{
2560	if (pContext->fHostToGuest)
2561	return gctlCopyDirToGuest(pContext, pszSource, pszFilter,
2562	pszDest, enmFlags, NULL /* Sub directory, only for recursion. */);
2563	return gctlCopyDirToHost(pContext, pszSource, pszFilter,
2564	pszDest, enmFlags, NULL /* Sub directory, only for recursion. */);
2565	}
2566
2567	/**
2568	* Creates a source root by stripping file names or filters of the specified source.
2569	*
2570	* @return IPRT status code.
2571	* @param pszSource Source to create source root for.
2572	* @param ppszSourceRoot Pointer that receives the allocated source root. Needs
2573	* to be free'd with gctlCopyFreeSourceRoot().
2574	*/
2575	static int gctlCopyCreateSourceRoot(const char pszSource, char *ppszSourceRoot)
2576	{
2577	AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
2578	AssertPtrReturn(ppszSourceRoot, VERR_INVALID_POINTER);
2579
2580	char *pszNewRoot = RTStrDup(pszSource);
2581	if (!pszNewRoot)
2582	return VERR_NO_MEMORY;
2583
2584	size_t lenRoot = strlen(pszNewRoot);
2585	if ( lenRoot
2586	&& ( pszNewRoot[lenRoot - 1] == '/'
2587	\|\| pszNewRoot[lenRoot - 1] == '\\')
2588	)
2589	{
2590	pszNewRoot[lenRoot - 1] = '\0';
2591	}
2592
2593	if ( lenRoot > 1
2594	&& ( pszNewRoot[lenRoot - 2] == '/'
2595	\|\| pszNewRoot[lenRoot - 2] == '\\')
2596	)
2597	{
2598	pszNewRoot[lenRoot - 2] = '\0';
2599	}
2600
2601	if (!lenRoot)
2602	{
2603	/* If there's anything (like a file name or a filter),
2604	* strip it! */
2605	RTPathStripFilename(pszNewRoot);
2606	}
2607
2608	*ppszSourceRoot = pszNewRoot;
2609
2610	return VINF_SUCCESS;
2611	}
2612
2613	/**
2614	* Frees a previously allocated source root.
2615	*
2616	* @return IPRT status code.
2617	* @param pszSourceRoot Source root to free.
2618	*/
2619	static void gctlCopyFreeSourceRoot(char *pszSourceRoot)
2620	{
2621	RTStrFree(pszSourceRoot);
2622	}
2623
2624	static RTEXITCODE gctlHandleCopy(PGCTLCMDCTX pCtx, int argc, char **argv, bool fHostToGuest)
2625	{
2626	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2627
2628	/** @todo r=bird: This command isn't very unix friendly in general. mkdir
2629	* is much better (partly because it is much simpler of course). The main
2630	* arguments against this is that (1) all but two options conflicts with
2631	* what 'man cp' tells me on a GNU/Linux system, (2) wildchar matching is
2632	* done windows CMD style (though not in a 100% compatible way), and (3)
2633	* that only one source is allowed - efficiently sabotaging default
2634	* wildcard expansion by a unix shell. The best solution here would be
2635	* two different variant, one windowsy (xcopy) and one unixy (gnu cp). */
2636
2637	/*
2638	* IGuest::CopyToGuest is kept as simple as possible to let the developer choose
2639	* what and how to implement the file enumeration/recursive lookup, like VBoxManage
2640	* does in here.
2641	*/
2642	enum GETOPTDEF_COPY
2643	{
2644	GETOPTDEF_COPY_DRYRUN = 1000,
2645	GETOPTDEF_COPY_FOLLOW,
2646	GETOPTDEF_COPY_TARGETDIR
2647	};
2648	static const RTGETOPTDEF s_aOptions[] =
2649	{
2650	GCTLCMD_COMMON_OPTION_DEFS()
2651	{ "--dryrun", GETOPTDEF_COPY_DRYRUN, RTGETOPT_REQ_NOTHING },
2652	{ "--follow", GETOPTDEF_COPY_FOLLOW, RTGETOPT_REQ_NOTHING },
2653	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
2654	{ "--target-directory", GETOPTDEF_COPY_TARGETDIR, RTGETOPT_REQ_STRING }
2655	};
2656
2657	int ch;
2658	RTGETOPTUNION ValueUnion;
2659	RTGETOPTSTATE GetState;
2660	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2661
2662	Utf8Str strSource;
2663	const char *pszDst = NULL;
2664	enum gctlCopyFlags enmFlags = kGctlCopyFlags_None;
2665	bool fCopyRecursive = false;
2666	bool fDryRun = false;
2667	uint32_t uUsage = fHostToGuest ? USAGE_GSTCTRL_COPYTO : USAGE_GSTCTRL_COPYFROM;
2668
2669	SOURCEVEC vecSources;
2670
2671	int vrc = VINF_SUCCESS;
2672	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2673	{
2674	/* For options that require an argument, ValueUnion has received the value. */
2675	switch (ch)
2676	{
2677	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2678
2679	case GETOPTDEF_COPY_DRYRUN:
2680	fDryRun = true;
2681	break;
2682
2683	case GETOPTDEF_COPY_FOLLOW:
2684	enmFlags = (enum gctlCopyFlags)((uint32_t)enmFlags \| kGctlCopyFlags_FollowLinks);
2685	break;
2686
2687	case 'R': /* Recursive processing */
2688	enmFlags = (enum gctlCopyFlags)((uint32_t)enmFlags \| kGctlCopyFlags_Recursive);
2689	break;
2690
2691	case GETOPTDEF_COPY_TARGETDIR:
2692	pszDst = ValueUnion.psz;
2693	break;
2694
2695	case VINF_GETOPT_NOT_OPTION:
2696	/* Last argument and no destination specified with
2697	* --target-directory yet? Then use the current
2698	* (= last) argument as destination. */
2699	if ( pCtx->pArg->argc == GetState.iNext
2700	&& pszDst == NULL)
2701	pszDst = ValueUnion.psz;
2702	else
2703	{
2704	try
2705	{ /* Save the source directory. */
2706	vecSources.push_back(SOURCEFILEENTRY(ValueUnion.psz));
2707	}
2708	catch (std::bad_alloc &)
2709	{
2710	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
2711	}
2712	}
2713	break;
2714
2715	default:
2716	return errorGetOptEx(USAGE_GUESTCONTROL, uUsage, ch, &ValueUnion);
2717	}
2718	}
2719
2720	if (!vecSources.size())
2721	return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No source(s) specified!");
2722
2723	if (pszDst == NULL)
2724	return errorSyntaxEx(USAGE_GUESTCONTROL, uUsage, "No destination specified!");
2725
2726	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
2727	if (rcExit != RTEXITCODE_SUCCESS)
2728	return rcExit;
2729
2730	/*
2731	* Done parsing arguments, do some more preparations.
2732	*/
2733	if (pCtx->cVerbose)
2734	{
2735	if (fHostToGuest)
2736	RTPrintf("Copying from host to guest ...\n");
2737	else
2738	RTPrintf("Copying from guest to host ...\n");
2739	if (fDryRun)
2740	RTPrintf("Dry run - no files copied!\n");
2741	}
2742
2743	/* Create the copy context -- it contains all information
2744	* the routines need to know when handling the actual copying. */
2745	PCOPYCONTEXT pContext = NULL;
2746	vrc = gctlCopyContextCreate(pCtx, fDryRun, fHostToGuest,
2747	fHostToGuest
2748	? "VBoxManage Guest Control - Copy to guest"
2749	: "VBoxManage Guest Control - Copy from guest", &pContext);
2750	if (RT_FAILURE(vrc))
2751	{
2752	RTMsgError("Unable to create copy context, rc=%Rrc\n", vrc);
2753	return RTEXITCODE_FAILURE;
2754	}
2755
2756	/** @todo r=bird: RTPathFilename and RTPathStripFilename won't work
2757	* correctly on non-windows hosts when the guest is from the DOS world (Windows,
2758	* OS/2, DOS). The host doesn't know about DOS slashes, only UNIX slashes and
2759	* will get the wrong idea if some dilligent user does:
2760	*
2761	* copyto myfile.txt 'C:\guestfile.txt'
2762	* or
2763	* copyto myfile.txt 'D:guestfile.txt'
2764	*
2765	* @bugref{6344}
2766	*/
2767	if (!RTPathFilename(pszDst))
2768	{
2769	vrc = gctlCopyDirCreate(pContext, pszDst);
2770	}
2771	else
2772	{
2773	/* We assume we got a file name as destination -- so strip
2774	* the actual file name and make sure the appropriate
2775	* directories get created. */
2776	char *pszDstDir = RTStrDup(pszDst);
2777	AssertPtr(pszDstDir);
2778	RTPathStripFilename(pszDstDir);
2779	vrc = gctlCopyDirCreate(pContext, pszDstDir);
2780	RTStrFree(pszDstDir);
2781	}
2782
2783	if (RT_SUCCESS(vrc))
2784	{
2785	/*
2786	* Here starts the actual fun!
2787	* Handle all given sources one by one.
2788	*/
2789	for (unsigned long s = 0; s < vecSources.size(); s++)
2790	{
2791	char *pszSource = RTStrDup(vecSources[s].GetSource());
2792	AssertPtrBreakStmt(pszSource, vrc = VERR_NO_MEMORY);
2793	const char *pszFilter = vecSources[s].GetFilter();
2794	if (!strlen(pszFilter))
2795	pszFilter = NULL; /* If empty filter then there's no filter :-) */
2796
2797	char *pszSourceRoot;
2798	vrc = gctlCopyCreateSourceRoot(pszSource, &pszSourceRoot);
2799	if (RT_FAILURE(vrc))
2800	{
2801	RTMsgError("Unable to create source root, rc=%Rrc\n", vrc);
2802	break;
2803	}
2804
2805	if (pCtx->cVerbose)
2806	RTPrintf("Source: %s\n", pszSource);
2807
2808	/** @todo Files with filter?? */
2809	bool fSourceIsFile = false;
2810	bool fSourceExists;
2811
2812	size_t cchSource = strlen(pszSource);
2813	if ( cchSource > 1
2814	&& RTPATH_IS_SLASH(pszSource[cchSource - 1]))
2815	{
2816	if (pszFilter) /* Directory with filter (so use source root w/o the actual filter). */
2817	vrc = gctlCopyDirExistsOnSource(pContext, pszSourceRoot, &fSourceExists);
2818	else /* Regular directory without filter. */
2819	vrc = gctlCopyDirExistsOnSource(pContext, pszSource, &fSourceExists);
2820
2821	if (fSourceExists)
2822	{
2823	/* Strip trailing slash from our source element so that other functions
2824	* can use this stuff properly (like RTPathStartsWith). */
2825	RTPathStripTrailingSlash(pszSource);
2826	}
2827	}
2828	else
2829	{
2830	vrc = gctlCopyFileExistsOnSource(pContext, pszSource, &fSourceExists);
2831	if ( RT_SUCCESS(vrc)
2832	&& fSourceExists)
2833	{
2834	fSourceIsFile = true;
2835	}
2836	}
2837
2838	if ( RT_SUCCESS(vrc)
2839	&& fSourceExists)
2840	{
2841	if (fSourceIsFile)
2842	{
2843	/* Single file. */
2844	char *pszDstFile;
2845	vrc = gctlCopyTranslatePath(pszSourceRoot, pszSource, pszDst, &pszDstFile);
2846	if (RT_SUCCESS(vrc))
2847	{
2848	vrc = gctlCopyFileToDest(pContext, pszSource, pszDstFile, kGctlCopyFlags_None);
2849	RTStrFree(pszDstFile);
2850	}
2851	else
2852	RTMsgError("Unable to translate path for \"%s\", rc=%Rrc\n", pszSource, vrc);
2853	}
2854	else
2855	{
2856	/* Directory (with filter?). */
2857	vrc = gctlCopyDirToDest(pContext, pszSource, pszFilter, pszDst, enmFlags);
2858	}
2859	}
2860
2861	gctlCopyFreeSourceRoot(pszSourceRoot);
2862
2863	if ( RT_SUCCESS(vrc)
2864	&& !fSourceExists)
2865	{
2866	RTMsgError("Warning: Source \"%s\" does not exist, skipping!\n",
2867	pszSource);
2868	RTStrFree(pszSource);
2869	continue;
2870	}
2871	else if (RT_FAILURE(vrc))
2872	{
2873	RTMsgError("Error processing \"%s\", rc=%Rrc\n",
2874	pszSource, vrc);
2875	RTStrFree(pszSource);
2876	break;
2877	}
2878
2879	RTStrFree(pszSource);
2880	}
2881	}
2882
2883	gctlCopyContextFree(pContext);
2884
2885	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
2886	}
2887
2888	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyFrom(PGCTLCMDCTX pCtx, int argc, char **argv)
2889	{
2890	return gctlHandleCopy(pCtx, argc, argv, false /* Guest to host */);
2891	}
2892
2893	static DECLCALLBACK(RTEXITCODE) gctlHandleCopyTo(PGCTLCMDCTX pCtx, int argc, char **argv)
2894	{
2895	return gctlHandleCopy(pCtx, argc, argv, true /* Host to guest */);
2896	}
2897
2898	static DECLCALLBACK(RTEXITCODE) handleCtrtMkDir(PGCTLCMDCTX pCtx, int argc, char **argv)
2899	{
2900	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2901
2902	static const RTGETOPTDEF s_aOptions[] =
2903	{
2904	GCTLCMD_COMMON_OPTION_DEFS()
2905	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
2906	{ "--parents", 'P', RTGETOPT_REQ_NOTHING }
2907	};
2908
2909	int ch;
2910	RTGETOPTUNION ValueUnion;
2911	RTGETOPTSTATE GetState;
2912	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
2913
2914	SafeArray<DirectoryCreateFlag_T> dirCreateFlags;
2915	uint32_t fDirMode = 0; /* Default mode. */
2916	uint32_t cDirsCreated = 0;
2917	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2918
2919	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
2920	{
2921	/* For options that require an argument, ValueUnion has received the value. */
2922	switch (ch)
2923	{
2924	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
2925
2926	case 'm': /* Mode */
2927	fDirMode = ValueUnion.u32;
2928	break;
2929
2930	case 'P': /* Create parents */
2931	dirCreateFlags.push_back(DirectoryCreateFlag_Parents);
2932	break;
2933
2934	case VINF_GETOPT_NOT_OPTION:
2935	if (cDirsCreated == 0)
2936	{
2937	/*
2938	* First non-option - no more options now.
2939	*/
2940	rcExit = gctlCtxPostOptionParsingInit(pCtx);
2941	if (rcExit != RTEXITCODE_SUCCESS)
2942	return rcExit;
2943	if (pCtx->cVerbose)
2944	RTPrintf("Creating %RU32 directories...\n", argc - GetState.iNext + 1);
2945	}
2946	if (g_fGuestCtrlCanceled)
2947	return RTMsgErrorExit(RTEXITCODE_FAILURE, "mkdir was interrupted by Ctrl-C (%u left)\n",
2948	argc - GetState.iNext + 1);
2949
2950	/*
2951	* Create the specified directory.
2952	*
2953	* On failure we'll change the exit status to failure and
2954	* continue with the next directory that needs creating. We do
2955	* this because we only create new things, and because this is
2956	* how /bin/mkdir works on unix.
2957	*/
2958	cDirsCreated++;
2959	if (pCtx->cVerbose)
2960	RTPrintf("Creating directory \"%s\" ...\n", ValueUnion.psz);
2961	try
2962	{
2963	HRESULT rc;
2964	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreate(Bstr(ValueUnion.psz).raw(),
2965	fDirMode, ComSafeArrayAsInParam(dirCreateFlags)));
2966	if (FAILED(rc))
2967	rcExit = RTEXITCODE_FAILURE;
2968	}
2969	catch (std::bad_alloc &)
2970	{
2971	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
2972	}
2973	break;
2974
2975	default:
2976	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, ch, &ValueUnion);
2977	}
2978	}
2979
2980	if (!cDirsCreated)
2981	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKDIR, "No directory to create specified!");
2982	return rcExit;
2983	}
2984
2985
2986	static DECLCALLBACK(RTEXITCODE) gctlHandleRmDir(PGCTLCMDCTX pCtx, int argc, char **argv)
2987	{
2988	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
2989
2990	static const RTGETOPTDEF s_aOptions[] =
2991	{
2992	GCTLCMD_COMMON_OPTION_DEFS()
2993	{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
2994	};
2995
2996	int ch;
2997	RTGETOPTUNION ValueUnion;
2998	RTGETOPTSTATE GetState;
2999	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3000
3001	bool fRecursive = false;
3002	uint32_t cDirRemoved = 0;
3003	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
3004
3005	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3006	{
3007	/* For options that require an argument, ValueUnion has received the value. */
3008	switch (ch)
3009	{
3010	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3011
3012	case 'R':
3013	fRecursive = true;
3014	break;
3015
3016	case VINF_GETOPT_NOT_OPTION:
3017	{
3018	if (cDirRemoved == 0)
3019	{
3020	/*
3021	* First non-option - no more options now.
3022	*/
3023	rcExit = gctlCtxPostOptionParsingInit(pCtx);
3024	if (rcExit != RTEXITCODE_SUCCESS)
3025	return rcExit;
3026	if (pCtx->cVerbose)
3027	RTPrintf("Removing %RU32 directorie%ss...\n", argc - GetState.iNext + 1, fRecursive ? "trees" : "");
3028	}
3029	if (g_fGuestCtrlCanceled)
3030	return RTMsgErrorExit(RTEXITCODE_FAILURE, "rmdir was interrupted by Ctrl-C (%u left)\n",
3031	argc - GetState.iNext + 1);
3032
3033	cDirRemoved++;
3034	HRESULT rc;
3035	if (!fRecursive)
3036	{
3037	/*
3038	* Remove exactly one directory.
3039	*/
3040	if (pCtx->cVerbose)
3041	RTPrintf("Removing directory \"%s\" ...\n", ValueUnion.psz);
3042	try
3043	{
3044	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemove(Bstr(ValueUnion.psz).raw()));
3045	}
3046	catch (std::bad_alloc &)
3047	{
3048	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
3049	}
3050	}
3051	else
3052	{
3053	/*
3054	* Remove the directory and anything under it, that means files
3055	* and everything. This is in the tradition of the Windows NT
3056	* CMD.EXE "rmdir /s" operation, a tradition which jpsoft's TCC
3057	* strongly warns against (and half-ways questions the sense of).
3058	*/
3059	if (pCtx->cVerbose)
3060	RTPrintf("Recursively removing directory \"%s\" ...\n", ValueUnion.psz);
3061	try
3062	{
3063	/** @todo Make flags configurable. */
3064	com::SafeArray<DirectoryRemoveRecFlag_T> aRemRecFlags;
3065	aRemRecFlags.push_back(DirectoryRemoveRecFlag_ContentAndDir);
3066
3067	ComPtr<IProgress> ptrProgress;
3068	CHECK_ERROR(pCtx->pGuestSession, DirectoryRemoveRecursive(Bstr(ValueUnion.psz).raw(),
3069	ComSafeArrayAsInParam(aRemRecFlags),
3070	ptrProgress.asOutParam()));
3071	if (SUCCEEDED(rc))
3072	{
3073	if (pCtx->cVerbose)
3074	rc = showProgress(ptrProgress);
3075	else
3076	rc = ptrProgress->WaitForCompletion(-1 /* indefinitely */);
3077	if (SUCCEEDED(rc))
3078	CHECK_PROGRESS_ERROR(ptrProgress, ("Directory deletion failed"));
3079	ptrProgress.setNull();
3080	}
3081	}
3082	catch (std::bad_alloc &)
3083	{
3084	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory during recursive rmdir\n");
3085	}
3086	}
3087
3088	/*
3089	* This command returns immediately on failure since it's destructive in nature.
3090	*/
3091	if (FAILED(rc))
3092	return RTEXITCODE_FAILURE;
3093	break;
3094	}
3095
3096	default:
3097	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, ch, &ValueUnion);
3098	}
3099	}
3100
3101	if (!cDirRemoved)
3102	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RMDIR, "No directory to remove specified!");
3103	return rcExit;
3104	}
3105
3106	static DECLCALLBACK(RTEXITCODE) gctlHandleRm(PGCTLCMDCTX pCtx, int argc, char **argv)
3107	{
3108	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3109
3110	static const RTGETOPTDEF s_aOptions[] =
3111	{
3112	GCTLCMD_COMMON_OPTION_DEFS()
3113	{ "--force", 'f', RTGETOPT_REQ_NOTHING, },
3114	};
3115
3116	int ch;
3117	RTGETOPTUNION ValueUnion;
3118	RTGETOPTSTATE GetState;
3119	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3120
3121	uint32_t cFilesDeleted = 0;
3122	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
3123	bool fForce = true;
3124
3125	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3126	{
3127	/* For options that require an argument, ValueUnion has received the value. */
3128	switch (ch)
3129	{
3130	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3131
3132	case VINF_GETOPT_NOT_OPTION:
3133	if (cFilesDeleted == 0)
3134	{
3135	/*
3136	* First non-option - no more options now.
3137	*/
3138	rcExit = gctlCtxPostOptionParsingInit(pCtx);
3139	if (rcExit != RTEXITCODE_SUCCESS)
3140	return rcExit;
3141	if (pCtx->cVerbose)
3142	RTPrintf("Removing %RU32 file(s)...\n", argc - GetState.iNext + 1);
3143	}
3144	if (g_fGuestCtrlCanceled)
3145	return RTMsgErrorExit(RTEXITCODE_FAILURE, "rm was interrupted by Ctrl-C (%u left)\n",
3146	argc - GetState.iNext + 1);
3147
3148	/*
3149	* Remove the specified file.
3150	*
3151	* On failure we will by default stop, however, the force option will
3152	* by unix traditions force us to ignore errors and continue.
3153	*/
3154	cFilesDeleted++;
3155	if (pCtx->cVerbose)
3156	RTPrintf("Removing file \"%s\" ...\n", ValueUnion.psz);
3157	try
3158	{
3159	/** @todo How does IGuestSession::FsObjRemove work with read-only files? Do we
3160	* need to do some chmod or whatever to better emulate the --force flag? */
3161	HRESULT rc;
3162	CHECK_ERROR(pCtx->pGuestSession, FsObjRemove(Bstr(ValueUnion.psz).raw()));
3163	if (FAILED(rc) && !fForce)
3164	return RTEXITCODE_FAILURE;
3165	}
3166	catch (std::bad_alloc &)
3167	{
3168	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory\n");
3169	}
3170	break;
3171
3172	default:
3173	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, ch, &ValueUnion);
3174	}
3175	}
3176
3177	if (!cFilesDeleted && !fForce)
3178	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_RM, "No file to remove specified!");
3179	return rcExit;
3180	}
3181
3182	static DECLCALLBACK(RTEXITCODE) gctlHandleMv(PGCTLCMDCTX pCtx, int argc, char **argv)
3183	{
3184	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3185
3186	static const RTGETOPTDEF s_aOptions[] =
3187	{
3188	GCTLCMD_COMMON_OPTION_DEFS()
3189	};
3190
3191	int ch;
3192	RTGETOPTUNION ValueUnion;
3193	RTGETOPTSTATE GetState;
3194	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3195
3196	int vrc = VINF_SUCCESS;
3197
3198	bool fDryrun = false;
3199	std::vector< Utf8Str > vecSources;
3200	const char *pszDst = NULL;
3201	com::SafeArray<FsObjRenameFlag_T> aRenameFlags;
3202
3203	try
3204	{
3205	/** @todo Make flags configurable. */
3206	aRenameFlags.push_back(FsObjRenameFlag_NoReplace);
3207
3208	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3209	&& RT_SUCCESS(vrc))
3210	{
3211	/* For options that require an argument, ValueUnion has received the value. */
3212	switch (ch)
3213	{
3214	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3215
3216	/** @todo Implement a --dryrun command. */
3217	/** @todo Implement rename flags. */
3218
3219	case VINF_GETOPT_NOT_OPTION:
3220	vecSources.push_back(Utf8Str(ValueUnion.psz));
3221	pszDst = ValueUnion.psz;
3222	break;
3223
3224	default:
3225	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV, ch, &ValueUnion);
3226	}
3227	}
3228	}
3229	catch (std::bad_alloc)
3230	{
3231	vrc = VERR_NO_MEMORY;
3232	}
3233
3234	if (RT_FAILURE(vrc))
3235	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to initialize, rc=%Rrc\n", vrc);
3236
3237	size_t cSources = vecSources.size();
3238	if (!cSources)
3239	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV,
3240	"No source(s) to move specified!");
3241	if (cSources < 2)
3242	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MV,
3243	"No destination specified!");
3244
3245	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3246	if (rcExit != RTEXITCODE_SUCCESS)
3247	return rcExit;
3248
3249	/* Delete last element, which now is the destination. */
3250	vecSources.pop_back();
3251	cSources = vecSources.size();
3252
3253	HRESULT rc = S_OK;
3254
3255	if (cSources > 1)
3256	{
3257	BOOL fExists = FALSE;
3258	rc = pCtx->pGuestSession->DirectoryExists(Bstr(pszDst).raw(), FALSE /followSymlinks/, &fExists);
3259	if (FAILED(rc) \|\| !fExists)
3260	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Destination must be a directory when specifying multiple sources\n");
3261	}
3262
3263	/*
3264	* Rename (move) the entries.
3265	*/
3266	if (pCtx->cVerbose)
3267	RTPrintf("Renaming %RU32 %s ...\n", cSources, cSources > 1 ? "entries" : "entry");
3268
3269	std::vector< Utf8Str >::iterator it = vecSources.begin();
3270	while ( (it != vecSources.end())
3271	&& !g_fGuestCtrlCanceled)
3272	{
3273	Utf8Str strCurSource = (*it);
3274
3275	ComPtr<IGuestFsObjInfo> pFsObjInfo;
3276	FsObjType_T enmObjType;
3277	rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(strCurSource).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
3278	if (SUCCEEDED(rc))
3279	rc = pFsObjInfo->COMGETTER(Type)(&enmObjType);
3280	if (FAILED(rc))
3281	{
3282	if (pCtx->cVerbose)
3283	RTPrintf("Warning: Cannot stat for element \"%s\": No such element\n",
3284	strCurSource.c_str());
3285	++it;
3286	continue; /* Skip. */
3287	}
3288
3289	if (pCtx->cVerbose)
3290	RTPrintf("Renaming %s \"%s\" to \"%s\" ...\n",
3291	enmObjType == FsObjType_Directory ? "directory" : "file",
3292	strCurSource.c_str(), pszDst);
3293
3294	if (!fDryrun)
3295	{
3296	if (enmObjType == FsObjType_Directory)
3297	{
3298	CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(),
3299	Bstr(pszDst).raw(),
3300	ComSafeArrayAsInParam(aRenameFlags)));
3301
3302	/* Break here, since it makes no sense to rename mroe than one source to
3303	* the same directory. */
3304	/** @todo r=bird: You are being kind of windowsy (or just DOSish) about the 'sense' part here,
3305	* while being totaly buggy about the behavior. 'VBoxGuest guestcontrol ren dir1 dir2 dstdir' will
3306	* stop after 'dir1' and SILENTLY ignore dir2. If you tried this on Windows, you'd see an error
3307	* being displayed. If you 'man mv' on a nearby unixy system, you'd see that they've made perfect
3308	* sense out of any situation with more than one source. */
3309	it = vecSources.end();
3310	break;
3311	}
3312	else
3313	CHECK_ERROR_BREAK(pCtx->pGuestSession, FsObjRename(Bstr(strCurSource).raw(),
3314	Bstr(pszDst).raw(),
3315	ComSafeArrayAsInParam(aRenameFlags)));
3316	}
3317
3318	++it;
3319	}
3320
3321	if ( (it != vecSources.end())
3322	&& pCtx->cVerbose)
3323	{
3324	RTPrintf("Warning: Not all sources were renamed\n");
3325	}
3326
3327	return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
3328	}
3329
3330	static DECLCALLBACK(RTEXITCODE) gctlHandleMkTemp(PGCTLCMDCTX pCtx, int argc, char **argv)
3331	{
3332	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3333
3334	static const RTGETOPTDEF s_aOptions[] =
3335	{
3336	GCTLCMD_COMMON_OPTION_DEFS()
3337	{ "--mode", 'm', RTGETOPT_REQ_UINT32 },
3338	{ "--directory", 'D', RTGETOPT_REQ_NOTHING },
3339	{ "--secure", 's', RTGETOPT_REQ_NOTHING },
3340	{ "--tmpdir", 't', RTGETOPT_REQ_STRING }
3341	};
3342
3343	int ch;
3344	RTGETOPTUNION ValueUnion;
3345	RTGETOPTSTATE GetState;
3346	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3347
3348	Utf8Str strTemplate;
3349	uint32_t fMode = 0; /* Default mode. */
3350	bool fDirectory = false;
3351	bool fSecure = false;
3352	Utf8Str strTempDir;
3353
3354	DESTDIRMAP mapDirs;
3355
3356	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3357	{
3358	/* For options that require an argument, ValueUnion has received the value. */
3359	switch (ch)
3360	{
3361	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3362
3363	case 'm': /* Mode */
3364	fMode = ValueUnion.u32;
3365	break;
3366
3367	case 'D': /* Create directory */
3368	fDirectory = true;
3369	break;
3370
3371	case 's': /* Secure */
3372	fSecure = true;
3373	break;
3374
3375	case 't': /* Temp directory */
3376	strTempDir = ValueUnion.psz;
3377	break;
3378
3379	case VINF_GETOPT_NOT_OPTION:
3380	{
3381	if (strTemplate.isEmpty())
3382	strTemplate = ValueUnion.psz;
3383	else
3384	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3385	"More than one template specified!\n");
3386	break;
3387	}
3388
3389	default:
3390	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP, ch, &ValueUnion);
3391	}
3392	}
3393
3394	if (strTemplate.isEmpty())
3395	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3396	"No template specified!");
3397
3398	if (!fDirectory)
3399	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_MKTEMP,
3400	"Creating temporary files is currently not supported!");
3401
3402	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3403	if (rcExit != RTEXITCODE_SUCCESS)
3404	return rcExit;
3405
3406	/*
3407	* Create the directories.
3408	*/
3409	if (pCtx->cVerbose)
3410	{
3411	if (fDirectory && !strTempDir.isEmpty())
3412	RTPrintf("Creating temporary directory from template '%s' in directory '%s' ...\n",
3413	strTemplate.c_str(), strTempDir.c_str());
3414	else if (fDirectory)
3415	RTPrintf("Creating temporary directory from template '%s' in default temporary directory ...\n",
3416	strTemplate.c_str());
3417	else if (!fDirectory && !strTempDir.isEmpty())
3418	RTPrintf("Creating temporary file from template '%s' in directory '%s' ...\n",
3419	strTemplate.c_str(), strTempDir.c_str());
3420	else if (!fDirectory)
3421	RTPrintf("Creating temporary file from template '%s' in default temporary directory ...\n",
3422	strTemplate.c_str());
3423	}
3424
3425	HRESULT rc = S_OK;
3426	if (fDirectory)
3427	{
3428	Bstr directory;
3429	CHECK_ERROR(pCtx->pGuestSession, DirectoryCreateTemp(Bstr(strTemplate).raw(),
3430	fMode, Bstr(strTempDir).raw(),
3431	fSecure,
3432	directory.asOutParam()));
3433	if (SUCCEEDED(rc))
3434	RTPrintf("Directory name: %ls\n", directory.raw());
3435	}
3436	else
3437	{
3438	// else - temporary file not yet implemented
3439	/** @todo implement temporary file creation (we fend it off above, no
3440	* worries). */
3441	rc = E_FAIL;
3442	}
3443
3444	return FAILED(rc) ? RTEXITCODE_FAILURE : RTEXITCODE_SUCCESS;
3445	}
3446
3447	static DECLCALLBACK(RTEXITCODE) gctlHandleStat(PGCTLCMDCTX pCtx, int argc, char **argv)
3448	{
3449	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3450
3451	static const RTGETOPTDEF s_aOptions[] =
3452	{
3453	GCTLCMD_COMMON_OPTION_DEFS()
3454	{ "--dereference", 'L', RTGETOPT_REQ_NOTHING },
3455	{ "--file-system", 'f', RTGETOPT_REQ_NOTHING },
3456	{ "--format", 'c', RTGETOPT_REQ_STRING },
3457	{ "--terse", 't', RTGETOPT_REQ_NOTHING }
3458	};
3459
3460	int ch;
3461	RTGETOPTUNION ValueUnion;
3462	RTGETOPTSTATE GetState;
3463	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3464
3465	DESTDIRMAP mapObjs;
3466
3467	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3468	{
3469	/* For options that require an argument, ValueUnion has received the value. */
3470	switch (ch)
3471	{
3472	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3473
3474	case 'L': /* Dereference */
3475	case 'f': /* File-system */
3476	case 'c': /* Format */
3477	case 't': /* Terse */
3478	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT,
3479	"Command \"%s\" not implemented yet!", ValueUnion.psz);
3480
3481	case VINF_GETOPT_NOT_OPTION:
3482	mapObjs[ValueUnion.psz]; /* Add element to check to map. */
3483	break;
3484
3485	default:
3486	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT, ch, &ValueUnion);
3487	}
3488	}
3489
3490	size_t cObjs = mapObjs.size();
3491	if (!cObjs)
3492	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_STAT,
3493	"No element(s) to check specified!");
3494
3495	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3496	if (rcExit != RTEXITCODE_SUCCESS)
3497	return rcExit;
3498
3499	HRESULT rc;
3500
3501	/*
3502	* Doing the checks.
3503	*/
3504	DESTDIRMAPITER it = mapObjs.begin();
3505	while (it != mapObjs.end())
3506	{
3507	if (pCtx->cVerbose)
3508	RTPrintf("Checking for element \"%s\" ...\n", it->first.c_str());
3509
3510	ComPtr<IGuestFsObjInfo> pFsObjInfo;
3511	rc = pCtx->pGuestSession->FsObjQueryInfo(Bstr(it->first).raw(), FALSE /followSymlinks/, pFsObjInfo.asOutParam());
3512	if (FAILED(rc))
3513	{
3514	/* If there's at least one element which does not exist on the guest,
3515	* drop out with exitcode 1. */
3516	if (pCtx->cVerbose)
3517	RTPrintf("Cannot stat for element \"%s\": No such element\n",
3518	it->first.c_str());
3519	rcExit = RTEXITCODE_FAILURE;
3520	}
3521	else
3522	{
3523	FsObjType_T objType;
3524	pFsObjInfo->COMGETTER(Type)(&objType); /** @todo What about error checking? */
3525	switch (objType)
3526	{
3527	case FsObjType_File:
3528	RTPrintf("Element \"%s\" found: Is a file\n", it->first.c_str());
3529	break;
3530
3531	case FsObjType_Directory:
3532	RTPrintf("Element \"%s\" found: Is a directory\n", it->first.c_str());
3533	break;
3534
3535	case FsObjType_Symlink:
3536	RTPrintf("Element \"%s\" found: Is a symlink\n", it->first.c_str());
3537	break;
3538
3539	default:
3540	RTPrintf("Element \"%s\" found, type unknown (%ld)\n", it->first.c_str(), objType);
3541	break;
3542	}
3543
3544	/** @todo: Show more information about this element. */
3545	}
3546
3547	++it;
3548	}
3549
3550	return rcExit;
3551	}
3552
3553	static DECLCALLBACK(RTEXITCODE) gctlHandleUpdateAdditions(PGCTLCMDCTX pCtx, int argc, char **argv)
3554	{
3555	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3556
3557	/*
3558	* Check the syntax. We can deduce the correct syntax from the number of
3559	* arguments.
3560	*/
3561	Utf8Str strSource;
3562	com::SafeArray<IN_BSTR> aArgs;
3563	bool fWaitStartOnly = false;
3564
3565	static const RTGETOPTDEF s_aOptions[] =
3566	{
3567	GCTLCMD_COMMON_OPTION_DEFS()
3568	{ "--source", 's', RTGETOPT_REQ_STRING },
3569	{ "--wait-start", 'w', RTGETOPT_REQ_NOTHING }
3570	};
3571
3572	int ch;
3573	RTGETOPTUNION ValueUnion;
3574	RTGETOPTSTATE GetState;
3575	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3576
3577	int vrc = VINF_SUCCESS;
3578	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3579	&& RT_SUCCESS(vrc))
3580	{
3581	switch (ch)
3582	{
3583	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3584
3585	case 's':
3586	strSource = ValueUnion.psz;
3587	break;
3588
3589	case 'w':
3590	fWaitStartOnly = true;
3591	break;
3592
3593	case VINF_GETOPT_NOT_OPTION:
3594	if (aArgs.size() == 0 && strSource.isEmpty())
3595	strSource = ValueUnion.psz;
3596	else
3597	aArgs.push_back(Bstr(ValueUnion.psz).raw());
3598	break;
3599
3600	default:
3601	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion);
3602	}
3603	}
3604
3605	if (pCtx->cVerbose)
3606	RTPrintf("Updating Guest Additions ...\n");
3607
3608	HRESULT rc = S_OK;
3609	while (strSource.isEmpty())
3610	{
3611	ComPtr<ISystemProperties> pProperties;
3612	CHECK_ERROR_BREAK(pCtx->pArg->virtualBox, COMGETTER(SystemProperties)(pProperties.asOutParam()));
3613	Bstr strISO;
3614	CHECK_ERROR_BREAK(pProperties, COMGETTER(DefaultAdditionsISO)(strISO.asOutParam()));
3615	strSource = strISO;
3616	break;
3617	}
3618
3619	/* Determine source if not set yet. */
3620	if (strSource.isEmpty())
3621	{
3622	RTMsgError("No Guest Additions source found or specified, aborting\n");
3623	vrc = VERR_FILE_NOT_FOUND;
3624	}
3625	else if (!RTFileExists(strSource.c_str()))
3626	{
3627	RTMsgError("Source \"%s\" does not exist!\n", strSource.c_str());
3628	vrc = VERR_FILE_NOT_FOUND;
3629	}
3630
3631	if (RT_SUCCESS(vrc))
3632	{
3633	if (pCtx->cVerbose)
3634	RTPrintf("Using source: %s\n", strSource.c_str());
3635
3636
3637	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3638	if (rcExit != RTEXITCODE_SUCCESS)
3639	return rcExit;
3640
3641
3642	com::SafeArray<AdditionsUpdateFlag_T> aUpdateFlags;
3643	if (fWaitStartOnly)
3644	{
3645	aUpdateFlags.push_back(AdditionsUpdateFlag_WaitForUpdateStartOnly);
3646	if (pCtx->cVerbose)
3647	RTPrintf("Preparing and waiting for Guest Additions installer to start ...\n");
3648	}
3649
3650	ComPtr<IProgress> pProgress;
3651	CHECK_ERROR(pCtx->pGuest, UpdateGuestAdditions(Bstr(strSource).raw(),
3652	ComSafeArrayAsInParam(aArgs),
3653	/* Wait for whole update process to complete. */
3654	ComSafeArrayAsInParam(aUpdateFlags),
3655	pProgress.asOutParam()));
3656	if (FAILED(rc))
3657	vrc = gctlPrintError(pCtx->pGuest, COM_IIDOF(IGuest));
3658	else
3659	{
3660	if (pCtx->cVerbose)
3661	rc = showProgress(pProgress);
3662	else
3663	rc = pProgress->WaitForCompletion(-1 /* No timeout */);
3664
3665	if (SUCCEEDED(rc))
3666	CHECK_PROGRESS_ERROR(pProgress, ("Guest additions update failed"));
3667	vrc = gctlPrintProgressError(pProgress);
3668	if ( RT_SUCCESS(vrc)
3669	&& pCtx->cVerbose)
3670	{
3671	RTPrintf("Guest Additions update successful\n");
3672	}
3673	}
3674	}
3675
3676	return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
3677	}
3678
3679	static DECLCALLBACK(RTEXITCODE) gctlHandleList(PGCTLCMDCTX pCtx, int argc, char **argv)
3680	{
3681	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3682
3683	static const RTGETOPTDEF s_aOptions[] =
3684	{
3685	GCTLCMD_COMMON_OPTION_DEFS()
3686	};
3687
3688	int ch;
3689	RTGETOPTUNION ValueUnion;
3690	RTGETOPTSTATE GetState;
3691	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3692
3693	bool fSeenListArg = false;
3694	bool fListAll = false;
3695	bool fListSessions = false;
3696	bool fListProcesses = false;
3697	bool fListFiles = false;
3698
3699	int vrc = VINF_SUCCESS;
3700	while ( (ch = RTGetOpt(&GetState, &ValueUnion))
3701	&& RT_SUCCESS(vrc))
3702	{
3703	switch (ch)
3704	{
3705	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3706
3707	case VINF_GETOPT_NOT_OPTION:
3708	if ( !RTStrICmp(ValueUnion.psz, "sessions")
3709	\|\| !RTStrICmp(ValueUnion.psz, "sess"))
3710	fListSessions = true;
3711	else if ( !RTStrICmp(ValueUnion.psz, "processes")
3712	\|\| !RTStrICmp(ValueUnion.psz, "procs"))
3713	fListSessions = fListProcesses = true; /* Showing processes implies showing sessions. */
3714	else if (!RTStrICmp(ValueUnion.psz, "files"))
3715	fListSessions = fListFiles = true; /* Showing files implies showing sessions. */
3716	else if (!RTStrICmp(ValueUnion.psz, "all"))
3717	fListAll = true;
3718	else
3719	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST,
3720	"Unknown list: '%s'", ValueUnion.psz);
3721	fSeenListArg = true;
3722	break;
3723
3724	default:
3725	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_UPDATEGA, ch, &ValueUnion);
3726	}
3727	}
3728
3729	if (!fSeenListArg)
3730	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_LIST, "Missing list name");
3731	Assert(fListAll \|\| fListSessions);
3732
3733	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3734	if (rcExit != RTEXITCODE_SUCCESS)
3735	return rcExit;
3736
3737
3738	/** @todo Do we need a machine-readable output here as well? */
3739
3740	HRESULT rc;
3741	size_t cTotalProcs = 0;
3742	size_t cTotalFiles = 0;
3743
3744	SafeIfaceArray <IGuestSession> collSessions;
3745	CHECK_ERROR(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3746	if (SUCCEEDED(rc))
3747	{
3748	size_t const cSessions = collSessions.size();
3749	if (cSessions)
3750	{
3751	RTPrintf("Active guest sessions:\n");
3752
3753	/** @todo Make this output a bit prettier. No time now. */
3754
3755	for (size_t i = 0; i < cSessions; i++)
3756	{
3757	ComPtr<IGuestSession> pCurSession = collSessions[i];
3758	if (!pCurSession.isNull())
3759	{
3760	do
3761	{
3762	ULONG uID;
3763	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Id)(&uID));
3764	Bstr strName;
3765	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Name)(strName.asOutParam()));
3766	Bstr strUser;
3767	CHECK_ERROR_BREAK(pCurSession, COMGETTER(User)(strUser.asOutParam()));
3768	GuestSessionStatus_T sessionStatus;
3769	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Status)(&sessionStatus));
3770	RTPrintf("\n\tSession #%-3zu ID=%-3RU32 User=%-16ls Status=[%s] Name=%ls",
3771	i, uID, strUser.raw(), gctlGuestSessionStatusToText(sessionStatus), strName.raw());
3772	} while (0);
3773
3774	if ( fListAll
3775	\|\| fListProcesses)
3776	{
3777	SafeIfaceArray <IGuestProcess> collProcesses;
3778	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcesses)));
3779	for (size_t a = 0; a < collProcesses.size(); a++)
3780	{
3781	ComPtr<IGuestProcess> pCurProcess = collProcesses[a];
3782	if (!pCurProcess.isNull())
3783	{
3784	do
3785	{
3786	ULONG uPID;
3787	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(PID)(&uPID));
3788	Bstr strExecPath;
3789	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(ExecutablePath)(strExecPath.asOutParam()));
3790	ProcessStatus_T procStatus;
3791	CHECK_ERROR_BREAK(pCurProcess, COMGETTER(Status)(&procStatus));
3792
3793	RTPrintf("\n\t\tProcess #%-03zu PID=%-6RU32 Status=[%s] Command=%ls",
3794	a, uPID, gctlProcessStatusToText(procStatus), strExecPath.raw());
3795	} while (0);
3796	}
3797	}
3798
3799	cTotalProcs += collProcesses.size();
3800	}
3801
3802	if ( fListAll
3803	\|\| fListFiles)
3804	{
3805	SafeIfaceArray <IGuestFile> collFiles;
3806	CHECK_ERROR_BREAK(pCurSession, COMGETTER(Files)(ComSafeArrayAsOutParam(collFiles)));
3807	for (size_t a = 0; a < collFiles.size(); a++)
3808	{
3809	ComPtr<IGuestFile> pCurFile = collFiles[a];
3810	if (!pCurFile.isNull())
3811	{
3812	do
3813	{
3814	ULONG idFile;
3815	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Id)(&idFile));
3816	Bstr strName;
3817	CHECK_ERROR_BREAK(pCurFile, COMGETTER(FileName)(strName.asOutParam()));
3818	FileStatus_T fileStatus;
3819	CHECK_ERROR_BREAK(pCurFile, COMGETTER(Status)(&fileStatus));
3820
3821	RTPrintf("\n\t\tFile #%-03zu ID=%-6RU32 Status=[%s] Name=%ls",
3822	a, idFile, gctlFileStatusToText(fileStatus), strName.raw());
3823	} while (0);
3824	}
3825	}
3826
3827	cTotalFiles += collFiles.size();
3828	}
3829	}
3830	}
3831
3832	RTPrintf("\n\nTotal guest sessions: %zu\n", collSessions.size());
3833	if (fListAll \|\| fListProcesses)
3834	RTPrintf("Total guest processes: %zu\n", cTotalProcs);
3835	if (fListAll \|\| fListFiles)
3836	RTPrintf("Total guest files: %zu\n", cTotalFiles);
3837	}
3838	else
3839	RTPrintf("No active guest sessions found\n");
3840	}
3841
3842	if (FAILED(rc))
3843	rcExit = RTEXITCODE_FAILURE;
3844
3845	return rcExit;
3846	}
3847
3848	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseProcess(PGCTLCMDCTX pCtx, int argc, char **argv)
3849	{
3850	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
3851
3852	static const RTGETOPTDEF s_aOptions[] =
3853	{
3854	GCTLCMD_COMMON_OPTION_DEFS()
3855	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
3856	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
3857	};
3858
3859	int ch;
3860	RTGETOPTUNION ValueUnion;
3861	RTGETOPTSTATE GetState;
3862	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
3863
3864	std::vector < uint32_t > vecPID;
3865	ULONG ulSessionID = UINT32_MAX;
3866	Utf8Str strSessionName;
3867
3868	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
3869	{
3870	/* For options that require an argument, ValueUnion has received the value. */
3871	switch (ch)
3872	{
3873	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
3874
3875	case 'n': /* Session name (or pattern) */
3876	strSessionName = ValueUnion.psz;
3877	break;
3878
3879	case 'i': /* Session ID */
3880	ulSessionID = ValueUnion.u32;
3881	break;
3882
3883	case VINF_GETOPT_NOT_OPTION:
3884	{
3885	/* Treat every else specified as a PID to kill. */
3886	uint32_t uPid;
3887	int rc = RTStrToUInt32Ex(ValueUnion.psz, NULL, 0, &uPid);
3888	if ( RT_SUCCESS(rc)
3889	&& rc != VWRN_TRAILING_CHARS
3890	&& rc != VWRN_NUMBER_TOO_BIG
3891	&& rc != VWRN_NEGATIVE_UNSIGNED)
3892	{
3893	if (uPid != 0)
3894	{
3895	try
3896	{
3897	vecPID.push_back(uPid);
3898	}
3899	catch (std::bad_alloc &)
3900	{
3901	return RTMsgErrorExit(RTEXITCODE_FAILURE, "Out of memory");
3902	}
3903	}
3904	else
3905	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "Invalid PID value: 0");
3906	}
3907	else
3908	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3909	"Error parsing PID value: %Rrc", rc);
3910	break;
3911	}
3912
3913	default:
3914	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, ch, &ValueUnion);
3915	}
3916	}
3917
3918	if (vecPID.empty())
3919	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3920	"At least one PID must be specified to kill!");
3921
3922	if ( strSessionName.isEmpty()
3923	&& ulSessionID == UINT32_MAX)
3924	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS, "No session ID specified!");
3925
3926	if ( strSessionName.isNotEmpty()
3927	&& ulSessionID != UINT32_MAX)
3928	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSEPROCESS,
3929	"Either session ID or name (pattern) must be specified");
3930
3931	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
3932	if (rcExit != RTEXITCODE_SUCCESS)
3933	return rcExit;
3934
3935	HRESULT rc = S_OK;
3936
3937	ComPtr<IGuestSession> pSession;
3938	ComPtr<IGuestProcess> pProcess;
3939	do
3940	{
3941	uint32_t uProcsTerminated = 0;
3942	bool fSessionFound = false;
3943
3944	SafeIfaceArray <IGuestSession> collSessions;
3945	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
3946	size_t cSessions = collSessions.size();
3947
3948	uint32_t uSessionsHandled = 0;
3949	for (size_t i = 0; i < cSessions; i++)
3950	{
3951	pSession = collSessions[i];
3952	Assert(!pSession.isNull());
3953
3954	ULONG uID; /* Session ID */
3955	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
3956	Bstr strName;
3957	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
3958	Utf8Str strNameUtf8(strName); /* Session name */
3959	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
3960	{
3961	fSessionFound = uID == ulSessionID;
3962	}
3963	else /* ... or by naming pattern. */
3964	{
3965	if (RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()))
3966	fSessionFound = true;
3967	}
3968
3969	if (fSessionFound)
3970	{
3971	AssertStmt(!pSession.isNull(), break);
3972	uSessionsHandled++;
3973
3974	SafeIfaceArray <IGuestProcess> collProcs;
3975	CHECK_ERROR_BREAK(pSession, COMGETTER(Processes)(ComSafeArrayAsOutParam(collProcs)));
3976
3977	size_t cProcs = collProcs.size();
3978	for (size_t p = 0; p < cProcs; p++)
3979	{
3980	pProcess = collProcs[p];
3981	Assert(!pProcess.isNull());
3982
3983	ULONG uPID; /* Process ID */
3984	CHECK_ERROR_BREAK(pProcess, COMGETTER(PID)(&uPID));
3985
3986	bool fProcFound = false;
3987	for (size_t a = 0; a < vecPID.size(); a++) /* Slow, but works. */
3988	{
3989	fProcFound = vecPID[a] == uPID;
3990	if (fProcFound)
3991	break;
3992	}
3993
3994	if (fProcFound)
3995	{
3996	if (pCtx->cVerbose)
3997	RTPrintf("Terminating process (PID %RU32) (session ID %RU32) ...\n",
3998	uPID, uID);
3999	CHECK_ERROR_BREAK(pProcess, Terminate());
4000	uProcsTerminated++;
4001	}
4002	else
4003	{
4004	if (ulSessionID != UINT32_MAX)
4005	RTPrintf("No matching process(es) for session ID %RU32 found\n",
4006	ulSessionID);
4007	}
4008
4009	pProcess.setNull();
4010	}
4011
4012	pSession.setNull();
4013	}
4014	}
4015
4016	if (!uSessionsHandled)
4017	RTPrintf("No matching session(s) found\n");
4018
4019	if (uProcsTerminated)
4020	RTPrintf("%RU32 %s terminated\n",
4021	uProcsTerminated, uProcsTerminated == 1 ? "process" : "processes");
4022
4023	} while (0);
4024
4025	pProcess.setNull();
4026	pSession.setNull();
4027
4028	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4029	}
4030
4031
4032	static DECLCALLBACK(RTEXITCODE) gctlHandleCloseSession(PGCTLCMDCTX pCtx, int argc, char **argv)
4033	{
4034	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
4035
4036	enum GETOPTDEF_SESSIONCLOSE
4037	{
4038	GETOPTDEF_SESSIONCLOSE_ALL = 2000
4039	};
4040	static const RTGETOPTDEF s_aOptions[] =
4041	{
4042	GCTLCMD_COMMON_OPTION_DEFS()
4043	{ "--all", GETOPTDEF_SESSIONCLOSE_ALL, RTGETOPT_REQ_NOTHING },
4044	{ "--session-id", 'i', RTGETOPT_REQ_UINT32 },
4045	{ "--session-name", 'n', RTGETOPT_REQ_STRING }
4046	};
4047
4048	int ch;
4049	RTGETOPTUNION ValueUnion;
4050	RTGETOPTSTATE GetState;
4051	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
4052
4053	ULONG ulSessionID = UINT32_MAX;
4054	Utf8Str strSessionName;
4055
4056	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4057	{
4058	/* For options that require an argument, ValueUnion has received the value. */
4059	switch (ch)
4060	{
4061	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
4062
4063	case 'n': /* Session name pattern */
4064	strSessionName = ValueUnion.psz;
4065	break;
4066
4067	case 'i': /* Session ID */
4068	ulSessionID = ValueUnion.u32;
4069	break;
4070
4071	case GETOPTDEF_SESSIONCLOSE_ALL:
4072	strSessionName = "*";
4073	break;
4074
4075	case VINF_GETOPT_NOT_OPTION:
4076	/** @todo Supply a CSV list of IDs or patterns to close?
4077	* break; */
4078	default:
4079	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION, ch, &ValueUnion);
4080	}
4081	}
4082
4083	if ( strSessionName.isEmpty()
4084	&& ulSessionID == UINT32_MAX)
4085	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION,
4086	"No session ID specified!");
4087
4088	if ( !strSessionName.isEmpty()
4089	&& ulSessionID != UINT32_MAX)
4090	return errorSyntaxEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_CLOSESESSION,
4091	"Either session ID or name (pattern) must be specified");
4092
4093	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
4094	if (rcExit != RTEXITCODE_SUCCESS)
4095	return rcExit;
4096
4097	HRESULT rc = S_OK;
4098
4099	do
4100	{
4101	bool fSessionFound = false;
4102	size_t cSessionsHandled = 0;
4103
4104	SafeIfaceArray <IGuestSession> collSessions;
4105	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(Sessions)(ComSafeArrayAsOutParam(collSessions)));
4106	size_t cSessions = collSessions.size();
4107
4108	for (size_t i = 0; i < cSessions; i++)
4109	{
4110	ComPtr<IGuestSession> pSession = collSessions[i];
4111	Assert(!pSession.isNull());
4112
4113	ULONG uID; /* Session ID */
4114	CHECK_ERROR_BREAK(pSession, COMGETTER(Id)(&uID));
4115	Bstr strName;
4116	CHECK_ERROR_BREAK(pSession, COMGETTER(Name)(strName.asOutParam()));
4117	Utf8Str strNameUtf8(strName); /* Session name */
4118
4119	if (strSessionName.isEmpty()) /* Search by ID. Slow lookup. */
4120	{
4121	fSessionFound = uID == ulSessionID;
4122	}
4123	else /* ... or by naming pattern. */
4124	{
4125	if (RTStrSimplePatternMatch(strSessionName.c_str(), strNameUtf8.c_str()))
4126	fSessionFound = true;
4127	}
4128
4129	if (fSessionFound)
4130	{
4131	cSessionsHandled++;
4132
4133	Assert(!pSession.isNull());
4134	if (pCtx->cVerbose)
4135	RTPrintf("Closing guest session ID=#%RU32 \"%s\" ...\n",
4136	uID, strNameUtf8.c_str());
4137	CHECK_ERROR_BREAK(pSession, Close());
4138	if (pCtx->cVerbose)
4139	RTPrintf("Guest session successfully closed\n");
4140
4141	pSession.setNull();
4142	}
4143	}
4144
4145	if (!cSessionsHandled)
4146	{
4147	RTPrintf("No guest session(s) found\n");
4148	rc = E_ABORT; /* To set exit code accordingly. */
4149	}
4150
4151	} while (0);
4152
4153	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4154	}
4155
4156
4157	static DECLCALLBACK(RTEXITCODE) gctlHandleWatch(PGCTLCMDCTX pCtx, int argc, char **argv)
4158	{
4159	AssertPtrReturn(pCtx, RTEXITCODE_FAILURE);
4160
4161	/*
4162	* Parse arguments.
4163	*/
4164	static const RTGETOPTDEF s_aOptions[] =
4165	{
4166	GCTLCMD_COMMON_OPTION_DEFS()
4167	};
4168
4169	int ch;
4170	RTGETOPTUNION ValueUnion;
4171	RTGETOPTSTATE GetState;
4172	RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
4173
4174	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4175	{
4176	/* For options that require an argument, ValueUnion has received the value. */
4177	switch (ch)
4178	{
4179	GCTLCMD_COMMON_OPTION_CASES(pCtx, ch, &ValueUnion);
4180
4181	case VINF_GETOPT_NOT_OPTION:
4182	default:
4183	return errorGetOptEx(USAGE_GUESTCONTROL, USAGE_GSTCTRL_WATCH, ch, &ValueUnion);
4184	}
4185	}
4186
4187	/** @todo Specify categories to watch for. */
4188	/** @todo Specify a --timeout for waiting only for a certain amount of time? */
4189
4190	RTEXITCODE rcExit = gctlCtxPostOptionParsingInit(pCtx);
4191	if (rcExit != RTEXITCODE_SUCCESS)
4192	return rcExit;
4193
4194	HRESULT rc;
4195
4196	try
4197	{
4198	ComObjPtr<GuestEventListenerImpl> pGuestListener;
4199	do
4200	{
4201	/* Listener creation. */
4202	pGuestListener.createObject();
4203	pGuestListener->init(new GuestEventListener());
4204
4205	/* Register for IGuest events. */
4206	ComPtr<IEventSource> es;
4207	CHECK_ERROR_BREAK(pCtx->pGuest, COMGETTER(EventSource)(es.asOutParam()));
4208	com::SafeArray<VBoxEventType_T> eventTypes;
4209	eventTypes.push_back(VBoxEventType_OnGuestSessionRegistered);
4210	/** @todo Also register for VBoxEventType_OnGuestUserStateChanged on demand? */
4211	CHECK_ERROR_BREAK(es, RegisterListener(pGuestListener, ComSafeArrayAsInParam(eventTypes),
4212	true /* Active listener */));
4213	/* Note: All other guest control events have to be registered
4214	* as their corresponding objects appear. */
4215
4216	} while (0);
4217
4218	if (pCtx->cVerbose)
4219	RTPrintf("Waiting for events ...\n");
4220
4221	while (!g_fGuestCtrlCanceled)
4222	{
4223	/** @todo Timeout handling (see above)? */
4224	RTThreadSleep(10);
4225	}
4226
4227	if (pCtx->cVerbose)
4228	RTPrintf("Signal caught, exiting ...\n");
4229
4230	if (!pGuestListener.isNull())
4231	{
4232	/* Guest callback unregistration. */
4233	ComPtr<IEventSource> pES;
4234	CHECK_ERROR(pCtx->pGuest, COMGETTER(EventSource)(pES.asOutParam()));
4235	if (!pES.isNull())
4236	CHECK_ERROR(pES, UnregisterListener(pGuestListener));
4237	pGuestListener.setNull();
4238	}
4239	}
4240	catch (std::bad_alloc &)
4241	{
4242	rc = E_OUTOFMEMORY;
4243	}
4244
4245	return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
4246	}
4247
4248	/**
4249	* Access the guest control store.
4250	*
4251	* @returns program exit code.
4252	* @note see the command line API description for parameters
4253	*/
4254	RTEXITCODE handleGuestControl(HandlerArg *pArg)
4255	{
4256	AssertPtr(pArg);
4257
4258	#ifdef DEBUG_andy_disabled
4259	if (RT_FAILURE(tstTranslatePath()))
4260	return RTEXITCODE_FAILURE;
4261	#endif
4262
4263	/*
4264	* Command definitions.
4265	*/
4266	static const GCTLCMDDEF s_aCmdDefs[] =
4267	{
4268	{ "run", gctlHandleRun, USAGE_GSTCTRL_RUN, 0, },
4269	{ "start", gctlHandleStart, USAGE_GSTCTRL_START, 0, },
4270	{ "copyfrom", gctlHandleCopyFrom, USAGE_GSTCTRL_COPYFROM, 0, },
4271	{ "copyto", gctlHandleCopyTo, USAGE_GSTCTRL_COPYTO, 0, },
4272
4273	{ "mkdir", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4274	{ "md", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4275	{ "createdirectory", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4276	{ "createdir", handleCtrtMkDir, USAGE_GSTCTRL_MKDIR, 0, },
4277
4278	{ "rmdir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4279	{ "removedir", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4280	{ "removedirectory", gctlHandleRmDir, USAGE_GSTCTRL_RMDIR, 0, },
4281
4282	{ "rm", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4283	{ "removefile", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4284	{ "erase", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4285	{ "del", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4286	{ "delete", gctlHandleRm, USAGE_GSTCTRL_RM, 0, },
4287
4288	{ "mv", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4289	{ "move", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4290	{ "ren", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4291	{ "rename", gctlHandleMv, USAGE_GSTCTRL_MV, 0, },
4292
4293	{ "mktemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4294	{ "createtemp", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4295	{ "createtemporary", gctlHandleMkTemp, USAGE_GSTCTRL_MKTEMP, 0, },
4296
4297	{ "stat", gctlHandleStat, USAGE_GSTCTRL_STAT, 0, },
4298
4299	{ "closeprocess", gctlHandleCloseProcess, USAGE_GSTCTRL_CLOSEPROCESS, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4300	{ "closesession", gctlHandleCloseSession, USAGE_GSTCTRL_CLOSESESSION, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4301	{ "list", gctlHandleList, USAGE_GSTCTRL_LIST, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4302	{ "watch", gctlHandleWatch, USAGE_GSTCTRL_WATCH, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4303
4304	{"updateguestadditions",gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4305	{ "updateadditions", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4306	{ "updatega", gctlHandleUpdateAdditions, USAGE_GSTCTRL_UPDATEGA, GCTLCMDCTX_F_SESSION_ANONYMOUS \| GCTLCMDCTX_F_NO_SIGNAL_HANDLER, },
4307	};
4308
4309	/*
4310	* VBoxManage guestcontrol [common-options] <VM> [common-options] <sub-command> ...
4311	*
4312	* Parse common options and VM name until we find a sub-command. Allowing
4313	* the user to put the user and password related options before the
4314	* sub-command makes it easier to edit the command line when doing several
4315	* operations with the same guest user account. (Accidentally, it also
4316	* makes the syntax diagram shorter and easier to read.)
4317	*/
4318	GCTLCMDCTX CmdCtx;
4319	RTEXITCODE rcExit = gctrCmdCtxInit(&CmdCtx, pArg);
4320	if (rcExit == RTEXITCODE_SUCCESS)
4321	{
4322	static const RTGETOPTDEF s_CommonOptions[] = { GCTLCMD_COMMON_OPTION_DEFS() };
4323
4324	int ch;
4325	RTGETOPTUNION ValueUnion;
4326	RTGETOPTSTATE GetState;
4327	RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_CommonOptions, RT_ELEMENTS(s_CommonOptions), 0, 0 /* No sorting! */);
4328
4329	while ((ch = RTGetOpt(&GetState, &ValueUnion)) != 0)
4330	{
4331	switch (ch)
4332	{
4333	GCTLCMD_COMMON_OPTION_CASES(&CmdCtx, ch, &ValueUnion);
4334
4335	case VINF_GETOPT_NOT_OPTION:
4336	/* First comes the VM name or UUID. */
4337	if (!CmdCtx.pszVmNameOrUuid)
4338	CmdCtx.pszVmNameOrUuid = ValueUnion.psz;
4339	/*
4340	* The sub-command is next. Look it up and invoke it.
4341	* Note! Currently no warnings about user/password options (like we'll do later on)
4342	* for GCTLCMDCTX_F_SESSION_ANONYMOUS commands. No reason to be too pedantic.
4343	*/
4344	else
4345	{
4346	const char *pszCmd = ValueUnion.psz;
4347	uint32_t iCmd;
4348	for (iCmd = 0; iCmd < RT_ELEMENTS(s_aCmdDefs); iCmd++)
4349	if (strcmp(s_aCmdDefs[iCmd].pszName, pszCmd) == 0)
4350	{
4351	CmdCtx.pCmdDef = &s_aCmdDefs[iCmd];
4352
4353	rcExit = s_aCmdDefs[iCmd].pfnHandler(&CmdCtx, pArg->argc - GetState.iNext + 1,
4354	&pArg->argv[GetState.iNext - 1]);
4355
4356	gctlCtxTerm(&CmdCtx);
4357	return rcExit;
4358	}
4359	return errorSyntax(USAGE_GUESTCONTROL, "Unknown sub-command: '%s'", pszCmd);
4360	}
4361	break;
4362
4363	default:
4364	return errorGetOpt(USAGE_GUESTCONTROL, ch, &ValueUnion);
4365	}
4366	}
4367	if (CmdCtx.pszVmNameOrUuid)
4368	rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing sub-command");
4369	else
4370	rcExit = errorSyntax(USAGE_GUESTCONTROL, "Missing VM name and sub-command");
4371	}
4372	return rcExit;
4373	}
4374	#endif /* !VBOX_ONLY_DOCS */
4375

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

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

Download in other formats: