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