VirtualBox

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

Last change on this file since 37634 was 37634, checked in by vboxsync, 13 years ago

VBoxManage/GuestCtrl: Disable copyfrom.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 64.5 KB
Line 
1/* $Id: VBoxManageGuestCtrl.cpp 37634 2011-06-24 14:26:52Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of guestcontrol command.
4 */
5
6/*
7 * Copyright (C) 2010-2011 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*******************************************************************************
20* Header Files *
21*******************************************************************************/
22#include "VBoxManage.h"
23
24#ifndef VBOX_ONLY_DOCS
25
26#include <VBox/com/com.h>
27#include <VBox/com/string.h>
28#include <VBox/com/array.h>
29#include <VBox/com/ErrorInfo.h>
30#include <VBox/com/errorprint.h>
31#include <VBox/com/VirtualBox.h>
32#include <VBox/com/EventQueue.h>
33
34#include <VBox/err.h>
35#include <VBox/log.h>
36
37#include <iprt/asm.h>
38#include <iprt/dir.h>
39#include <iprt/file.h>
40#include <iprt/isofs.h>
41#include <iprt/getopt.h>
42#include <iprt/list.h>
43#include <iprt/path.h>
44#include <iprt/thread.h>
45
46#include <map>
47#include <vector>
48
49#ifdef USE_XPCOM_QUEUE
50# include <sys/select.h>
51# include <errno.h>
52#endif
53
54#include <signal.h>
55
56#ifdef RT_OS_DARWIN
57# include <CoreFoundation/CFRunLoop.h>
58#endif
59
60using namespace com;
61
62/**
63 * IVirtualBoxCallback implementation for handling the GuestControlCallback in
64 * relation to the "guestcontrol * wait" command.
65 */
66/** @todo */
67
68/** Set by the signal handler. */
69static volatile bool g_fGuestCtrlCanceled = false;
70
71/**
72 * An entry for a source element, including an optional filter.
73 */
74typedef struct SOURCEFILEENTRY
75{
76 SOURCEFILEENTRY(const char *pszSource, const char *pszFilter)
77 : mSource(pszSource),
78 mFilter(pszFilter) {}
79 SOURCEFILEENTRY(const char *pszSource)
80 : mSource(pszSource)
81 {
82 if ( !RTFileExists(pszSource)
83 && !RTDirExists(pszSource))
84 {
85 /* No file and no directory -- maybe a filter? */
86 if (NULL != strpbrk(RTPathFilename(pszSource), "*?"))
87 {
88 /* Yep, get the actual filter part. */
89 mFilter = RTPathFilename(pszSource);
90 /* Remove the filter from actual sourcec directory name. */
91 RTPathStripFilename(mSource.mutableRaw());
92 mSource.jolt();
93 }
94 }
95 }
96 Utf8Str mSource;
97 Utf8Str mFilter;
98} SOURCEFILEENTRY, *PSOURCEFILEENTRY;
99typedef std::vector<SOURCEFILEENTRY> SOURCEVEC, *PSOURCEVEC;
100
101/**
102 * An entry for an element which needs to be copied to the guest.
103 */
104typedef struct DESTFILEENTRY
105{
106 DESTFILEENTRY(Utf8Str strFileName) : mFileName(strFileName) {}
107 Utf8Str mFileName;
108} DESTFILEENTRY, *PDESTFILEENTRY;
109/*
110 * Map for holding destination entires, whereas the key is the destination
111 * directory and the mapped value is a vector holding all elements for this directoy.
112 */
113typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> > DESTDIRMAP, *PDESTDIRMAP;
114typedef std::map< Utf8Str, std::vector<DESTFILEENTRY> >::iterator DESTDIRMAPITER, *PDESTDIRMAPITER;
115
116/**
117 * Special exit codes for returning errors/information of a
118 * started guest process to the command line VBoxManage was started from.
119 * Useful for e.g. scripting.
120 *
121 * @note These are frozen as of 4.1.0.
122 */
123enum EXITCODEEXEC
124{
125 EXITCODEEXEC_SUCCESS = RTEXITCODE_SUCCESS,
126 /* Process exited normally but with an exit code <> 0. */
127 EXITCODEEXEC_CODE = 16,
128 EXITCODEEXEC_FAILED = 17,
129 EXITCODEEXEC_TERM_SIGNAL = 18,
130 EXITCODEEXEC_TERM_ABEND = 19,
131 EXITCODEEXEC_TIMEOUT = 20,
132 EXITCODEEXEC_DOWN = 21,
133 EXITCODEEXEC_CANCELED = 22
134};
135
136/**
137 * RTGetOpt-IDs for the guest execution control command line.
138 */
139enum GETOPTDEF_EXEC
140{
141 GETOPTDEF_EXEC_IGNOREORPHANEDPROCESSES = 1000,
142 GETOPTDEF_EXEC_NO_PROFILE,
143 GETOPTDEF_EXEC_OUTPUTFORMAT,
144 GETOPTDEF_EXEC_DOS2UNIX,
145 GETOPTDEF_EXEC_UNIX2DOS,
146 GETOPTDEF_EXEC_WAITFOREXIT,
147 GETOPTDEF_EXEC_WAITFORSTDOUT,
148 GETOPTDEF_EXEC_WAITFORSTDERR
149};
150
151enum GETOPTDEF_COPYFROM
152{
153 GETOPTDEF_COPYFROM_DRYRUN = 1000,
154 GETOPTDEF_COPYFROM_FOLLOW,
155 GETOPTDEF_COPYFROM_PASSWORD,
156 GETOPTDEF_COPYFROM_TARGETDIR,
157 GETOPTDEF_COPYFROM_USERNAME
158};
159
160enum GETOPTDEF_COPYTO
161{
162 GETOPTDEF_COPYTO_DRYRUN = 1000,
163 GETOPTDEF_COPYTO_FOLLOW,
164 GETOPTDEF_COPYTO_PASSWORD,
165 GETOPTDEF_COPYTO_TARGETDIR,
166 GETOPTDEF_COPYTO_USERNAME
167};
168
169enum OUTPUTTYPE
170{
171 OUTPUTTYPE_UNDEFINED = 0,
172 OUTPUTTYPE_DOS2UNIX = 10,
173 OUTPUTTYPE_UNIX2DOS = 20
174};
175
176#endif /* VBOX_ONLY_DOCS */
177
178void usageGuestControl(PRTSTREAM pStrm)
179{
180 RTStrmPrintf(pStrm,
181 "VBoxManage guestcontrol <vmname>|<uuid>\n"
182 " exec[ute]\n"
183 " --image <path to program>\n"
184 " --username <name> --password <password>\n"
185 " [--dos2unix]\n"
186 " [--environment \"<NAME>=<VALUE> [<NAME>=<VALUE>]\"]\n"
187 " [--timeout <msec>] [--unix2dos] [--verbose]\n"
188 " [--wait-exit] [--wait-stdout] [--wait-stdout]\n"
189 //" [--output-format=<dos>|<unix>]\n"
190 " [--output-type=<binary>|<text>]\n"
191 " [-- [<argument1>] ... [<argumentN>]\n"
192 /** @todo Add a "--" parameter (has to be last parameter) to directly execute
193 * stuff, e.g. "VBoxManage guestcontrol execute <VMName> --username <> ... -- /bin/rm -Rf /foo". */
194 "\n"
195#if 0
196 " copyfrom\n"
197 " <source on guest> <destination on host>\n"
198 " --username <name> --password <password>\n"
199 " [--dryrun] [--follow] [--recursive] [--verbose]\n"
200 "\n"
201#endif
202 " copyto|cp\n"
203 " <source on host> <destination on guest>\n"
204 " --username <name> --password <password>\n"
205 " [--dryrun] [--follow] [--recursive] [--verbose]\n"
206 "\n"
207 " createdir[ectory]|mkdir|md\n"
208 " <directory to create on guest>\n"
209 " --username <name> --password <password>\n"
210 " [--parents] [--mode <mode>] [--verbose]\n"
211 "\n"
212 " updateadditions\n"
213 " [--source <guest additions .ISO>] [--verbose]\n"
214 "\n");
215}
216
217#ifndef VBOX_ONLY_DOCS
218
219/**
220 * Signal handler that sets g_fGuestCtrlCanceled.
221 *
222 * This can be executed on any thread in the process, on Windows it may even be
223 * a thread dedicated to delivering this signal. Do not doing anything
224 * unnecessary here.
225 */
226static void guestCtrlSignalHandler(int iSignal)
227{
228 NOREF(iSignal);
229 ASMAtomicWriteBool(&g_fGuestCtrlCanceled, true);
230}
231
232/**
233 * Installs a custom signal handler to get notified
234 * whenever the user wants to intercept the program.
235 */
236static void ctrlSignalHandlerInstall()
237{
238 signal(SIGINT, guestCtrlSignalHandler);
239#ifdef SIGBREAK
240 signal(SIGBREAK, guestCtrlSignalHandler);
241#endif
242}
243
244/**
245 * Uninstalls a previously installed signal handler.
246 */
247static void ctrlSignalHandlerUninstall()
248{
249 signal(SIGINT, SIG_DFL);
250#ifdef SIGBREAK
251 signal(SIGBREAK, SIG_DFL);
252#endif
253}
254
255/**
256 * Translates a process status to a human readable
257 * string.
258 */
259static const char *ctrlExecProcessStatusToText(ExecuteProcessStatus_T enmStatus)
260{
261 switch (enmStatus)
262 {
263 case ExecuteProcessStatus_Started:
264 return "started";
265 case ExecuteProcessStatus_TerminatedNormally:
266 return "successfully terminated";
267 case ExecuteProcessStatus_TerminatedSignal:
268 return "terminated by signal";
269 case ExecuteProcessStatus_TerminatedAbnormally:
270 return "abnormally aborted";
271 case ExecuteProcessStatus_TimedOutKilled:
272 return "timed out";
273 case ExecuteProcessStatus_TimedOutAbnormally:
274 return "timed out, hanging";
275 case ExecuteProcessStatus_Down:
276 return "killed";
277 case ExecuteProcessStatus_Error:
278 return "error";
279 default:
280 break;
281 }
282 return "unknown";
283}
284
285static int ctrlExecProcessStatusToExitCode(ExecuteProcessStatus_T enmStatus, ULONG uExitCode)
286{
287 int rc = EXITCODEEXEC_SUCCESS;
288 switch (enmStatus)
289 {
290 case ExecuteProcessStatus_Started:
291 rc = EXITCODEEXEC_SUCCESS;
292 break;
293 case ExecuteProcessStatus_TerminatedNormally:
294 rc = !uExitCode ? EXITCODEEXEC_SUCCESS : EXITCODEEXEC_CODE;
295 break;
296 case ExecuteProcessStatus_TerminatedSignal:
297 rc = EXITCODEEXEC_TERM_SIGNAL;
298 break;
299 case ExecuteProcessStatus_TerminatedAbnormally:
300 rc = EXITCODEEXEC_TERM_ABEND;
301 break;
302 case ExecuteProcessStatus_TimedOutKilled:
303 rc = EXITCODEEXEC_TIMEOUT;
304 break;
305 case ExecuteProcessStatus_TimedOutAbnormally:
306 rc = EXITCODEEXEC_TIMEOUT;
307 break;
308 case ExecuteProcessStatus_Down:
309 /* Service/OS is stopping, process was killed, so
310 * not exactly an error of the started process ... */
311 rc = EXITCODEEXEC_DOWN;
312 break;
313 case ExecuteProcessStatus_Error:
314 rc = EXITCODEEXEC_FAILED;
315 break;
316 default:
317 AssertMsgFailed(("Unknown exit code (%u) from guest process returned!\n", enmStatus));
318 break;
319 }
320 return rc;
321}
322
323static int ctrlPrintError(com::ErrorInfo &errorInfo)
324{
325 if ( errorInfo.isFullAvailable()
326 || errorInfo.isBasicAvailable())
327 {
328 /* If we got a VBOX_E_IPRT error we handle the error in a more gentle way
329 * because it contains more accurate info about what went wrong. */
330 if (errorInfo.getResultCode() == VBOX_E_IPRT_ERROR)
331 RTMsgError("%ls.", errorInfo.getText().raw());
332 else
333 {
334 RTMsgError("Error details:");
335 GluePrintErrorInfo(errorInfo);
336 }
337 return VERR_GENERAL_FAILURE; /** @todo */
338 }
339 AssertMsgFailedReturn(("Object has indicated no error!?\n"),
340 VERR_INVALID_PARAMETER);
341}
342
343static int ctrlPrintError(IUnknown *pObj, const GUID &aIID)
344{
345 com::ErrorInfo ErrInfo(pObj, aIID);
346 return ctrlPrintError(ErrInfo);
347}
348
349static int ctrlPrintProgressError(ComPtr<IProgress> progress)
350{
351 int rc;
352 BOOL fCanceled;
353 if ( SUCCEEDED(progress->COMGETTER(Canceled(&fCanceled)))
354 && fCanceled)
355 {
356 rc = VERR_CANCELLED;
357 }
358 else
359 {
360 com::ProgressErrorInfo ErrInfo(progress);
361 rc = ctrlPrintError(ErrInfo);
362 }
363 return rc;
364}
365
366/**
367 * Un-initializes the VM after guest control usage.
368 */
369static void ctrlUninitVM(HandlerArg *pArg)
370{
371 AssertPtrReturnVoid(pArg);
372 if (pArg->session)
373 pArg->session->UnlockMachine();
374}
375
376/**
377 * Initializes the VM for IGuest operations.
378 *
379 * That is, checks whether it's up and running, if it can be locked (shared
380 * only) and returns a valid IGuest pointer on success.
381 *
382 * @return IPRT status code.
383 * @param pArg Our command line argument structure.
384 * @param pszNameOrId The VM's name or UUID.
385 * @param pGuest Where to return the IGuest interface pointer.
386 */
387static int ctrlInitVM(HandlerArg *pArg, const char *pszNameOrId, ComPtr<IGuest> *pGuest)
388{
389 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
390 AssertPtrReturn(pszNameOrId, VERR_INVALID_PARAMETER);
391
392 /* Lookup VM. */
393 ComPtr<IMachine> machine;
394 /* Assume it's an UUID. */
395 HRESULT rc;
396 CHECK_ERROR(pArg->virtualBox, FindMachine(Bstr(pszNameOrId).raw(),
397 machine.asOutParam()));
398 if (FAILED(rc))
399 return VERR_NOT_FOUND;
400
401 /* Machine is running? */
402 MachineState_T machineState;
403 CHECK_ERROR_RET(machine, COMGETTER(State)(&machineState), 1);
404 if (machineState != MachineState_Running)
405 {
406 RTMsgError("Machine \"%s\" is not running (currently %s)!\n",
407 pszNameOrId, machineStateToName(machineState, false));
408 return VERR_VM_INVALID_VM_STATE;
409 }
410
411 do
412 {
413 /* Open a session for the VM. */
414 CHECK_ERROR_BREAK(machine, LockMachine(pArg->session, LockType_Shared));
415 /* Get the associated console. */
416 ComPtr<IConsole> console;
417 CHECK_ERROR_BREAK(pArg->session, COMGETTER(Console)(console.asOutParam()));
418 /* ... and session machine. */
419 ComPtr<IMachine> sessionMachine;
420 CHECK_ERROR_BREAK(pArg->session, COMGETTER(Machine)(sessionMachine.asOutParam()));
421 /* Get IGuest interface. */
422 CHECK_ERROR_BREAK(console, COMGETTER(Guest)(pGuest->asOutParam()));
423 } while (0);
424
425 if (FAILED(rc))
426 ctrlUninitVM(pArg);
427 return SUCCEEDED(rc) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
428}
429
430/* <Missing docuemntation> */
431static int handleCtrlExecProgram(ComPtr<IGuest> guest, HandlerArg *pArg)
432{
433 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
434
435 /*
436 * Parse arguments.
437 */
438 if (pArg->argc < 2) /* At least the command we want to execute in the guest should be present :-). */
439 return errorSyntax(USAGE_GUESTCONTROL, "Incorrect parameters");
440
441 static const RTGETOPTDEF s_aOptions[] =
442 {
443 { "--dos2unix", GETOPTDEF_EXEC_DOS2UNIX, RTGETOPT_REQ_NOTHING },
444 { "--environment", 'e', RTGETOPT_REQ_STRING },
445 { "--flags", 'f', RTGETOPT_REQ_STRING },
446 { "--ignore-operhaned-processes", GETOPTDEF_EXEC_IGNOREORPHANEDPROCESSES, RTGETOPT_REQ_NOTHING },
447 { "--image", 'i', RTGETOPT_REQ_STRING },
448 { "--no-profile", GETOPTDEF_EXEC_NO_PROFILE, RTGETOPT_REQ_NOTHING },
449 { "--password", 'p', RTGETOPT_REQ_STRING },
450 { "--timeout", 't', RTGETOPT_REQ_UINT32 },
451 { "--unix2dos", GETOPTDEF_EXEC_UNIX2DOS, RTGETOPT_REQ_NOTHING },
452 { "--username", 'u', RTGETOPT_REQ_STRING },
453 { "--verbose", 'v', RTGETOPT_REQ_NOTHING },
454 { "--wait-exit", GETOPTDEF_EXEC_WAITFOREXIT, RTGETOPT_REQ_NOTHING },
455 { "--wait-stdout", GETOPTDEF_EXEC_WAITFORSTDOUT, RTGETOPT_REQ_NOTHING },
456 { "--wait-stderr", GETOPTDEF_EXEC_WAITFORSTDERR, RTGETOPT_REQ_NOTHING }
457 };
458
459 int ch;
460 RTGETOPTUNION ValueUnion;
461 RTGETOPTSTATE GetState;
462 RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
463
464 Utf8Str Utf8Cmd;
465 uint32_t fExecFlags = ExecuteProcessFlag_None;
466 uint32_t fOutputFlags = ProcessOutputFlag_None;
467 com::SafeArray<IN_BSTR> args;
468 com::SafeArray<IN_BSTR> env;
469 Utf8Str Utf8UserName;
470 Utf8Str Utf8Password;
471 uint32_t cMsTimeout = 0;
472 OUTPUTTYPE eOutputType = OUTPUTTYPE_UNDEFINED;
473 bool fOutputBinary = false;
474 bool fWaitForExit = false;
475 bool fWaitForStdOut = false;
476 bool fVerbose = false;
477
478 int vrc = VINF_SUCCESS;
479 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
480 && RT_SUCCESS(vrc))
481 {
482 /* For options that require an argument, ValueUnion has received the value. */
483 switch (ch)
484 {
485 case GETOPTDEF_EXEC_DOS2UNIX:
486 if (eOutputType != OUTPUTTYPE_UNDEFINED)
487 return errorSyntax(USAGE_GUESTCONTROL, "More than one output type (dos2unix/unix2dos) specified!");
488 eOutputType = OUTPUTTYPE_DOS2UNIX;
489 break;
490
491 case 'e': /* Environment */
492 {
493 char **papszArg;
494 int cArgs;
495
496 vrc = RTGetOptArgvFromString(&papszArg, &cArgs, ValueUnion.psz, NULL);
497 if (RT_FAILURE(vrc))
498 return errorSyntax(USAGE_GUESTCONTROL, "Failed to parse environment value, rc=%Rrc", vrc);
499 for (int j = 0; j < cArgs; j++)
500 env.push_back(Bstr(papszArg[j]).raw());
501
502 RTGetOptArgvFree(papszArg);
503 break;
504 }
505
506 case GETOPTDEF_EXEC_IGNOREORPHANEDPROCESSES:
507 fExecFlags |= ExecuteProcessFlag_IgnoreOrphanedProcesses;
508 break;
509
510 case GETOPTDEF_EXEC_NO_PROFILE:
511 fExecFlags |= ExecuteProcessFlag_NoProfile;
512 break;
513
514 case 'i':
515 Utf8Cmd = ValueUnion.psz;
516 break;
517
518 /** @todo Add a hidden flag. */
519
520 case 'p': /* Password */
521 Utf8Password = ValueUnion.psz;
522 break;
523
524 case 't': /* Timeout */
525 cMsTimeout = ValueUnion.u32;
526 break;
527
528 case GETOPTDEF_EXEC_UNIX2DOS:
529 if (eOutputType != OUTPUTTYPE_UNDEFINED)
530 return errorSyntax(USAGE_GUESTCONTROL, "More than one output type (dos2unix/unix2dos) specified!");
531 eOutputType = OUTPUTTYPE_UNIX2DOS;
532 break;
533
534 case 'u': /* User name */
535 Utf8UserName = ValueUnion.psz;
536 break;
537
538 case 'v': /* Verbose */
539 fVerbose = true;
540 break;
541
542 case GETOPTDEF_EXEC_WAITFOREXIT:
543 fWaitForExit = true;
544 break;
545
546 case GETOPTDEF_EXEC_WAITFORSTDOUT:
547 fWaitForExit = true;
548 fWaitForStdOut = true;
549 break;
550
551 case GETOPTDEF_EXEC_WAITFORSTDERR:
552 fWaitForExit = (fOutputFlags |= ProcessOutputFlag_StdErr) ? true : false;
553 break;
554
555 case VINF_GETOPT_NOT_OPTION:
556 {
557 if (args.size() == 0 && Utf8Cmd.isEmpty())
558 Utf8Cmd = ValueUnion.psz;
559 else
560 args.push_back(Bstr(ValueUnion.psz).raw());
561 break;
562 }
563
564 default:
565 return RTGetOptPrintError(ch, &ValueUnion);
566 }
567 }
568
569 if (Utf8Cmd.isEmpty())
570 return errorSyntax(USAGE_GUESTCONTROL, "No command to execute specified!");
571
572 if (Utf8UserName.isEmpty())
573 return errorSyntax(USAGE_GUESTCONTROL, "No user name specified!");
574
575 /*
576 * <missing comment indicating that we're done parsing args and started doing something else>
577 */
578 HRESULT rc = S_OK;
579 if (fVerbose)
580 {
581 if (cMsTimeout == 0)
582 RTPrintf("Waiting for guest to start process ...\n");
583 else
584 RTPrintf("Waiting for guest to start process (within %ums)\n", cMsTimeout);
585 }
586
587 /* Get current time stamp to later calculate rest of timeout left. */
588 uint64_t u64StartMS = RTTimeMilliTS();
589
590 /* Execute the process. */
591 int rcProc = RTEXITCODE_FAILURE;
592 ComPtr<IProgress> progress;
593 ULONG uPID = 0;
594 rc = guest->ExecuteProcess(Bstr(Utf8Cmd).raw(),
595 fExecFlags,
596 ComSafeArrayAsInParam(args),
597 ComSafeArrayAsInParam(env),
598 Bstr(Utf8UserName).raw(),
599 Bstr(Utf8Password).raw(),
600 cMsTimeout,
601 &uPID,
602 progress.asOutParam());
603 if (FAILED(rc))
604 return ctrlPrintError(guest, COM_IIDOF(IGuest));
605
606 if (fVerbose)
607 RTPrintf("Process '%s' (PID: %u) started\n", Utf8Cmd.c_str(), uPID);
608 if (fWaitForExit)
609 {
610 if (fVerbose)
611 {
612 if (cMsTimeout) /* Wait with a certain timeout. */
613 {
614 /* Calculate timeout value left after process has been started. */
615 uint64_t u64Elapsed = RTTimeMilliTS() - u64StartMS;
616 /* Is timeout still bigger than current difference? */
617 if (cMsTimeout > u64Elapsed)
618 RTPrintf("Waiting for process to exit (%ums left) ...\n", cMsTimeout - u64Elapsed);
619 else
620 RTPrintf("No time left to wait for process!\n"); /** @todo a bit misleading ... */
621 }
622 else /* Wait forever. */
623 RTPrintf("Waiting for process to exit ...\n");
624 }
625
626 /* Setup signal handling if cancelable. */
627 ASSERT(progress);
628 bool fCanceledAlready = false;
629 BOOL fCancelable;
630 HRESULT hrc = progress->COMGETTER(Cancelable)(&fCancelable);
631 if (FAILED(hrc))
632 fCancelable = FALSE;
633 if (fCancelable)
634 ctrlSignalHandlerInstall();
635
636 /* Wait for process to exit ... */
637 BOOL fCompleted = FALSE;
638 BOOL fCanceled = FALSE;
639 while (SUCCEEDED(progress->COMGETTER(Completed(&fCompleted))))
640 {
641 SafeArray<BYTE> aOutputData;
642 ULONG cbOutputData = 0;
643
644 /*
645 * Some data left to output?
646 */
647 if (fOutputFlags || fWaitForStdOut)
648 {
649 /** @todo r=bird: The timeout argument is bogus in several
650 * ways:
651 * 1. RT_MAX will evaluate the arguments twice, which may
652 * result in different values because RTTimeMilliTS()
653 * returns a higher value the 2nd time. Worst case:
654 * Imagine when RT_MAX calculates the remaining time
655 * out (first expansion) there is say 60 ms left. Then
656 * we're preempted and rescheduled after, say, 120 ms.
657 * We call RTTimeMilliTS() again and ends up with a
658 * value -60 ms, which translate to a UINT32_MAX - 59
659 * ms timeout.
660 *
661 * 2. When the period expires, we will wait forever since
662 * both 0 and -1 mean indefinite timeout with this API,
663 * at least that's one way of reading the main code.
664 *
665 * 3. There is a signed/unsigned ambiguity in the
666 * RT_MAX expression. The left hand side is signed
667 * integer (0), the right side is unsigned 64-bit. From
668 * what I can tell, the compiler will treat this as
669 * unsigned 64-bit and never return 0.
670 */
671 rc = guest->GetProcessOutput(uPID, fOutputFlags,
672 RT_MAX(0, cMsTimeout - (RTTimeMilliTS() - u64StartMS)) /* Timeout in ms */,
673 _64K, ComSafeArrayAsOutParam(aOutputData));
674 if (FAILED(rc))
675 {
676 vrc = ctrlPrintError(guest, COM_IIDOF(IGuest));
677 cbOutputData = 0;
678 }
679 else
680 {
681 cbOutputData = aOutputData.size();
682 if (cbOutputData > 0)
683 {
684 /** @todo r=bird: Use a VFS I/O stream filter for doing this, it's a
685 * generic problem and the new VFS APIs will handle it more
686 * transparently. (requires writing dos2unix/unix2dos filters ofc) */
687 if (eOutputType != OUTPUTTYPE_UNDEFINED)
688 {
689 /*
690 * If aOutputData is text data from the guest process' stdout or stderr,
691 * it has a platform dependent line ending. So standardize on
692 * Unix style, as RTStrmWrite does the LF -> CR/LF replacement on
693 * Windows. Otherwise we end up with CR/CR/LF on Windows.
694 */
695 ULONG cbOutputDataPrint = cbOutputData;
696 for (BYTE *s = aOutputData.raw(), *d = s;
697 s - aOutputData.raw() < (ssize_t)cbOutputData;
698 s++, d++)
699 {
700 if (*s == '\r')
701 {
702 /* skip over CR, adjust destination */
703 d--;
704 cbOutputDataPrint--;
705 }
706 else if (s != d)
707 *d = *s;
708 }
709 RTStrmWrite(g_pStdOut, aOutputData.raw(), cbOutputDataPrint);
710 }
711 else /* Just dump all data as we got it ... */
712 RTStrmWrite(g_pStdOut, aOutputData.raw(), cbOutputData);
713 }
714 }
715 }
716
717 /* No more output data left? */
718 if (cbOutputData <= 0)
719 {
720 /* Only break out from process handling loop if we processed (displayed)
721 * all output data or if there simply never was output data and the process
722 * has been marked as complete. */
723 if (fCompleted)
724 break;
725 }
726
727 /* Process async cancelation */
728 if (g_fGuestCtrlCanceled && !fCanceledAlready)
729 {
730 hrc = progress->Cancel();
731 if (SUCCEEDED(hrc))
732 fCanceledAlready = TRUE;
733 else
734 g_fGuestCtrlCanceled = false;
735 }
736
737 /* Progress canceled by Main API? */
738 if ( SUCCEEDED(progress->COMGETTER(Canceled(&fCanceled)))
739 && fCanceled)
740 break;
741
742 /* Did we run out of time? */
743 if ( cMsTimeout
744 && RTTimeMilliTS() - u64StartMS > cMsTimeout)
745 {
746 progress->Cancel();
747 break;
748 }
749 } /* while */
750
751 /* Undo signal handling */
752 if (fCancelable)
753 ctrlSignalHandlerUninstall();
754
755 /* Report status back to the user. */
756 if (fCanceled)
757 {
758 if (fVerbose)
759 RTPrintf("Process execution canceled!\n");
760 rcProc = EXITCODEEXEC_CANCELED;
761 }
762 else if ( fCompleted
763 && SUCCEEDED(rc)) /* The GetProcessOutput rc. */
764 {
765 LONG iRc;
766 CHECK_ERROR_RET(progress, COMGETTER(ResultCode)(&iRc), rc);
767 if (FAILED(iRc))
768 vrc = ctrlPrintProgressError(progress);
769 else
770 {
771 ExecuteProcessStatus_T retStatus;
772 ULONG uRetExitCode, uRetFlags;
773 rc = guest->GetProcessStatus(uPID, &uRetExitCode, &uRetFlags, &retStatus);
774 if (SUCCEEDED(rc) && fVerbose)
775 RTPrintf("Exit code=%u (Status=%u [%s], Flags=%u)\n", uRetExitCode, retStatus, ctrlExecProcessStatusToText(retStatus), uRetFlags);
776 rcProc = ctrlExecProcessStatusToExitCode(retStatus, uRetExitCode);
777 }
778 }
779 else
780 {
781 if (fVerbose)
782 RTPrintf("Process execution aborted!\n");
783 rcProc = EXITCODEEXEC_TERM_ABEND;
784 }
785 }
786
787 if (RT_FAILURE(vrc) || FAILED(rc))
788 return RTEXITCODE_FAILURE;
789 return rcProc;
790}
791
792/** @todo Clean up too long parameter list -> move guest specific stuff into own struct etc! */
793static int ctrlCopyDirectoryReadGuest(IGuest *pGuest,
794 const char *pszUsername, const char *pszPassword,
795 const char *pszRootDir, const char *pszSubDir,
796 const char *pszFilter, const char *pszDest,
797 uint32_t fFlags, uint32_t *pcObjects, DESTDIRMAP &dirMap)
798{
799 AssertPtrReturn(pszRootDir, VERR_INVALID_POINTER);
800 /* Sub directory is optional. */
801 /* Filter directory is optional. */
802 AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
803 AssertPtrReturn(pcObjects, VERR_INVALID_POINTER);
804
805 /*
806 * Construct current path.
807 */
808 char szCurDir[RTPATH_MAX];
809 int rc = RTStrCopy(szCurDir, sizeof(szCurDir), pszRootDir);
810 if (RT_SUCCESS(rc) && pszSubDir != NULL)
811 rc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
812
813 if (RT_SUCCESS(rc))
814 {
815 ULONG uDirHandle;
816 HRESULT hr = pGuest->DirectoryOpen(Bstr(szCurDir).raw(), Bstr(pszFilter).raw(), fFlags,
817 Bstr(pszUsername).raw(), Bstr(pszPassword).raw(), &uDirHandle);
818 if (FAILED(hr))
819 rc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
820 else
821 {
822 ComPtr <IGuestDirEntry> dirEntry;
823 while (SUCCEEDED(hr = pGuest->DirectoryRead(uDirHandle, dirEntry.asOutParam())))
824 {
825 GuestDirEntryType_T enmType;
826 dirEntry->COMGETTER(Type)(&enmType);
827
828 Bstr strName;
829 dirEntry->COMGETTER(Name)(strName.asOutParam());
830
831 switch (enmType)
832 {
833 case GuestDirEntryType_Directory:
834 {
835 /* Skip "." and ".." entries. */
836 if ( !strName.compare(Bstr("."))
837 || !strName.compare(Bstr("..")))
838 break;
839
840 const char *pszName = Utf8Str(strName).c_str();
841 if (fFlags & CopyFileFlag_Recursive)
842 {
843 char *pszNewSub = NULL;
844 if (pszSubDir)
845 RTStrAPrintf(&pszNewSub, "%s/%s", pszSubDir, pszName);
846 else
847 RTStrAPrintf(&pszNewSub, "%s", pszName);
848
849 if (pszNewSub)
850 {
851 dirMap[pszNewSub];
852
853 rc = ctrlCopyDirectoryReadGuest(pGuest, pszUsername, pszPassword,
854 pszRootDir, pszNewSub,
855 pszFilter, pszDest,
856 fFlags, pcObjects, dirMap);
857 RTStrFree(pszNewSub);
858 }
859 else
860 rc = VERR_NO_MEMORY;
861 }
862 break;
863 }
864
865 case GuestDirEntryType_Symlink:
866 if ( (fFlags & CopyFileFlag_Recursive)
867 && (fFlags & CopyFileFlag_FollowLinks))
868 {
869 /* Fall through to next case is intentional. */
870 }
871 else
872 break;
873
874 case GuestDirEntryType_File:
875 {
876 const char *pszName = Utf8Str(strName).c_str();
877 if ( !pszFilter
878 || RTStrSimplePatternMatch(pszFilter, pszName))
879 {
880 dirMap[pszSubDir].push_back(DESTFILEENTRY(pszName));
881 *pcObjects += 1;
882 }
883 break;
884 }
885
886 default:
887 break;
888 }
889 }
890
891 hr = pGuest->DirectoryClose(uDirHandle);
892 if (FAILED(rc))
893 rc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
894 }
895 }
896 return rc;
897}
898
899/**
900 * Reads a specified directory (recursively) based on the copy flags
901 * and appends all matching entries to the supplied list.
902 *
903 * @return IPRT status code.
904 * @param pszRootDir Directory to start with. Must end with
905 * a trailing slash and must be absolute.
906 * @param pszSubDir Sub directory part relative to the root
907 * directory; needed for recursion.
908 * @param pszFilter Search filter (e.g. *.pdf).
909 * @param pszDest Destination directory.
910 * @param fFlags Copy flags.
911 * @param pcObjects Where to store the overall objects to
912 * copy found.
913 * @param dirMap Reference to destination directory map to store found
914 * directories (primary key) + files (secondary key, vector).
915 */
916static int ctrlCopyDirectoryReadHost(const char *pszRootDir, const char *pszSubDir,
917 const char *pszFilter, const char *pszDest,
918 uint32_t fFlags, uint32_t *pcObjects, DESTDIRMAP &dirMap)
919{
920 AssertPtrReturn(pszRootDir, VERR_INVALID_POINTER);
921 /* Sub directory is optional. */
922 /* Filter directory is optional. */
923 AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
924 AssertPtrReturn(pcObjects, VERR_INVALID_POINTER);
925
926 /*
927 * Construct current path.
928 */
929 char szCurDir[RTPATH_MAX];
930 int rc = RTStrCopy(szCurDir, sizeof(szCurDir), pszRootDir);
931 if (RT_SUCCESS(rc) && pszSubDir != NULL)
932 rc = RTPathAppend(szCurDir, sizeof(szCurDir), pszSubDir);
933
934 /*
935 * Open directory without a filter - RTDirOpenFiltered unfortunately
936 * cannot handle sub directories so we have to do the filtering ourselves.
937 */
938 PRTDIR pDir = NULL;
939 if (RT_SUCCESS(rc))
940 {
941 rc = RTDirOpen(&pDir, szCurDir);
942 if (RT_FAILURE(rc))
943 pDir = NULL;
944 }
945 if (RT_SUCCESS(rc))
946 {
947 /*
948 * Enumerate the directory tree.
949 */
950 while (RT_SUCCESS(rc))
951 {
952 RTDIRENTRY DirEntry;
953 rc = RTDirRead(pDir, &DirEntry, NULL);
954 if (RT_FAILURE(rc))
955 {
956 if (rc == VERR_NO_MORE_FILES)
957 rc = VINF_SUCCESS;
958 break;
959 }
960 switch (DirEntry.enmType)
961 {
962 case RTDIRENTRYTYPE_DIRECTORY:
963 {
964 /* Skip "." and ".." entries. */
965 if ( !strcmp(DirEntry.szName, ".")
966 || !strcmp(DirEntry.szName, ".."))
967 break;
968
969 if (fFlags & CopyFileFlag_Recursive)
970 {
971 char *pszNewSub = NULL;
972 if (pszSubDir)
973 RTStrAPrintf(&pszNewSub, "%s/%s", pszSubDir, DirEntry.szName);
974 else
975 RTStrAPrintf(&pszNewSub, "%s", DirEntry.szName);
976
977 if (pszNewSub)
978 {
979 dirMap[pszNewSub];
980
981 rc = ctrlCopyDirectoryReadHost(pszRootDir, pszNewSub,
982 pszFilter, pszDest,
983 fFlags, pcObjects, dirMap);
984 RTStrFree(pszNewSub);
985 }
986 else
987 rc = VERR_NO_MEMORY;
988 }
989 break;
990 }
991
992 case RTDIRENTRYTYPE_SYMLINK:
993 if ( (fFlags & CopyFileFlag_Recursive)
994 && (fFlags & CopyFileFlag_FollowLinks))
995 {
996 /* Fall through to next case is intentional. */
997 }
998 else
999 break;
1000
1001 case RTDIRENTRYTYPE_FILE:
1002 {
1003 if ( !pszFilter
1004 || RTStrSimplePatternMatch(pszFilter, DirEntry.szName))
1005 {
1006 dirMap[pszSubDir].push_back(DESTFILEENTRY(Utf8Str(DirEntry.szName)));
1007 *pcObjects += 1;
1008 }
1009 break;
1010 }
1011
1012 default:
1013 break;
1014 }
1015 if (RT_FAILURE(rc))
1016 break;
1017 }
1018
1019 RTDirClose(pDir);
1020 }
1021 return rc;
1022}
1023
1024/**
1025 * Constructs a destinations map from a source entry and a destination root.
1026 *
1027 * @return IPRT status code.
1028 * @param fHostToGuest
1029 * @param sourceEntry Reference to a specified source entry to use.
1030 * @param fFlags Copy file flags. Needed for recursive directory parsing.
1031 * @param pszDestRoot Pointer to destination root. This can be used to add one or
1032 * more directories to the actual destination path.
1033 * @param mapDest Reference to the destination map for storing the actual result.
1034 * @param pcObjects Pointer to a total object (file) count to copy.
1035 */
1036static int ctrlCopyConstructDestinationsForGuest(SOURCEFILEENTRY &sourceEntry, uint32_t fFlags,
1037 const char *pszDestRoot, DESTDIRMAP &mapDest,
1038 uint32_t *pcObjects)
1039{
1040 int rc = VINF_SUCCESS;
1041 const char *pszSource = sourceEntry.mSource.c_str();
1042
1043 if ( RTPathFilename(pszSource)
1044 && RTFileExists(pszSource))
1045 {
1046 /* Source is a single file. */
1047 char *pszFileName = RTPathFilename(pszSource);
1048 mapDest[Utf8Str("")].push_back(DESTFILEENTRY(pszFileName));
1049
1050 *pcObjects += 1;
1051 }
1052 else
1053 {
1054 /* Source is either a directory or a filter (e.g. *.dll). */
1055 rc = ctrlCopyDirectoryReadHost(pszSource,
1056 NULL /* pszSubDir */,
1057 sourceEntry.mFilter.isEmpty() ? NULL : sourceEntry.mFilter.c_str(),
1058 pszDestRoot, fFlags, pcObjects, mapDest);
1059 }
1060 return rc;
1061}
1062
1063static int ctrlCopyConstructDestinationsForHost(IGuest *pGuest,
1064 const char *pszUsername, const char *pszPassword,
1065 SOURCEFILEENTRY &sourceEntry, uint32_t fFlags,
1066 const char *pszDestRoot, DESTDIRMAP &mapDest,
1067 uint32_t *pcObjects)
1068{
1069 int rc = VINF_SUCCESS;
1070 const char *pszSource = sourceEntry.mSource.c_str();
1071
1072 BOOL fExists = FALSE;
1073 HRESULT hr = pGuest->FileExists(Bstr(pszSource).raw(),
1074 Bstr(pszUsername).raw(), Bstr(pszPassword).raw(), &fExists);
1075 if (FAILED(rc))
1076 rc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
1077 else
1078 {
1079 if (fExists)
1080 {
1081 /* Source is a single file. */
1082 char *pszFileName = RTPathFilename(pszSource);
1083 mapDest[Utf8Str(pszDestRoot)].push_back(DESTFILEENTRY(pszFileName));
1084
1085 *pcObjects++;
1086 }
1087 else
1088 {
1089 /* Source is either a directory or a filter (e.g. *.dll). */
1090 rc = ctrlCopyDirectoryReadGuest(pGuest, pszUsername, pszPassword,
1091 pszSource, NULL /* pszSubDir */,
1092 sourceEntry.mFilter.isEmpty() ? NULL : sourceEntry.mFilter.c_str(),
1093 pszDestRoot, fFlags, pcObjects, mapDest);
1094 }
1095 }
1096 return rc;
1097}
1098
1099/**
1100 * Prepares the destination directory hirarchy on the guest side by creating the directories
1101 * and sets the appropriate access rights.
1102 *
1103 * @return IPRT status code.
1104 * @param pGuest IGuest interface pointer.
1105 * @param fHostToGuest
1106 * @param itDest Destination map iterator to process.
1107 * @param pszDestRoot Destination root to use.
1108 * @param pszUsername Username to use.
1109 * @param pszPassword Password to use.
1110 */
1111static int ctrlCopyPrepareDestDirectory(IGuest *pGuest, bool fHostToGuest,
1112 const char *pszDestRoot, const char *pszDestSub,
1113 const char *pszUsername, const char *pszPassword)
1114{
1115 AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
1116 AssertPtrReturn(pszDestRoot, VERR_INVALID_POINTER);
1117 AssertPtrReturn(pszDestSub, VERR_INVALID_POINTER);
1118 AssertPtrReturn(pszUsername, VERR_INVALID_POINTER);
1119 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
1120
1121 char *pszDestFinal = NULL;
1122 int rc = VINF_SUCCESS;
1123
1124 /* Create root directory (= empty name) and skip the rest for
1125 * this round. */
1126 if (!strlen(pszDestSub))
1127 {
1128 pszDestFinal = RTStrDup(pszDestRoot);
1129 if (!pszDestFinal)
1130 rc = VERR_NO_MEMORY;
1131 }
1132 else /* Create sub-directories, also empty ones. */
1133 {
1134 if (!RTStrAPrintf(&pszDestFinal, "%s/%s", pszDestRoot, pszDestSub))
1135 rc = VERR_NO_MEMORY;
1136 }
1137
1138 if (RT_SUCCESS(rc) && pszDestFinal)
1139 {
1140 if (fHostToGuest) /* We want to create directories on the guest. */
1141 {
1142 HRESULT hrc = pGuest->DirectoryCreate(Bstr(pszDestFinal).raw(),
1143 Bstr(pszUsername).raw(), Bstr(pszPassword).raw(),
1144 700, DirectoryCreateFlag_Parents);
1145 if (FAILED(hrc))
1146 rc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
1147 }
1148 else /* ... or on the host. */
1149 {
1150 rc = RTDirCreate(pszDestFinal, 700);
1151 }
1152 RTStrFree(pszDestFinal);
1153 }
1154 return rc;
1155}
1156
1157/**
1158 * Copys a file from host to the guest.
1159 *
1160 * @return IPRT status code.
1161 * @param pGuest IGuest interface pointer.
1162 * @param pszSource Source path of existing host file to copy to the guest.
1163 * @param pszDest Destination path on guest to copy the file to.
1164 * @param pszUserName User name on guest to use for the copy operation.
1165 * @param pszPassword Password of user account.
1166 * @param fFlags Copy flags.
1167 */
1168static int ctrlCopyFileToGuest(IGuest *pGuest, const char *pszSource, const char *pszDest,
1169 const char *pszUserName, const char *pszPassword,
1170 uint32_t fFlags)
1171{
1172 AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
1173 AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
1174 AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
1175 AssertPtrReturn(pszUserName, VERR_INVALID_POINTER);
1176 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
1177
1178 int vrc = VINF_SUCCESS;
1179 ComPtr<IProgress> progress;
1180 HRESULT rc = pGuest->CopyToGuest(Bstr(pszSource).raw(), Bstr(pszDest).raw(),
1181 Bstr(pszUserName).raw(), Bstr(pszPassword).raw(),
1182 fFlags, progress.asOutParam());
1183 if (FAILED(rc))
1184 vrc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
1185 else
1186 {
1187 rc = showProgress(progress);
1188 if (FAILED(rc))
1189 vrc = ctrlPrintProgressError(progress);
1190 }
1191 return vrc;
1192}
1193
1194/**
1195 * Copys a file from guest to the host.
1196 *
1197 * @return IPRT status code.
1198 * @param pGuest IGuest interface pointer.
1199 * @param pszSource Source path of existing guest file to copy to the host.
1200 * @param pszDest Destination path/file on host to copy the file to.
1201 * @param pszUserName User name on guest to use for the copy operation.
1202 * @param pszPassword Password of user account.
1203 * @param fFlags Copy flags.
1204 */
1205static int ctrlCopyFileToHost(IGuest *pGuest, const char *pszSource, const char *pszDest,
1206 const char *pszUserName, const char *pszPassword,
1207 uint32_t fFlags)
1208{
1209 AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
1210 AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
1211 AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
1212 AssertPtrReturn(pszUserName, VERR_INVALID_POINTER);
1213 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
1214
1215 int vrc = VINF_SUCCESS;
1216 ComPtr<IProgress> progress;
1217 HRESULT rc = pGuest->CopyFromGuest(Bstr(pszSource).raw(), Bstr(pszDest).raw(),
1218 Bstr(pszUserName).raw(), Bstr(pszPassword).raw(),
1219 fFlags, progress.asOutParam());
1220 if (FAILED(rc))
1221 vrc = ctrlPrintError(pGuest, COM_IIDOF(IGuest));
1222 else
1223 {
1224 rc = showProgress(progress);
1225 if (FAILED(rc))
1226 vrc = ctrlPrintProgressError(progress);
1227 }
1228 return vrc;
1229}
1230
1231static int ctrlCopyToDestDirectory(IGuest *pGuest, bool fVerbose, bool fDryRun, bool fHostToGuest,
1232 const char *pszSourceDir,
1233 const char *pszDestRoot, const char *pszDestSub, const char *pszFileName,
1234 uint32_t uFlags, const char *pszUsername, const char *pszPassword)
1235{
1236 AssertPtrReturn(pGuest, VERR_INVALID_POINTER);
1237 AssertPtrReturn(pszDestRoot, VERR_INVALID_POINTER);
1238 AssertPtrReturn(pszDestSub, VERR_INVALID_POINTER);
1239 AssertPtrReturn(pszFileName, VERR_INVALID_POINTER);
1240 AssertPtrReturn(pszSourceDir, VERR_INVALID_POINTER);
1241 AssertPtrReturn(pszUsername, VERR_INVALID_POINTER);
1242 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
1243
1244 int iLen;
1245 char *pszSource;
1246 if (!strlen(pszDestSub))
1247 iLen = RTStrAPrintf(&pszSource, "%s/%s", pszSourceDir, pszFileName);
1248 else
1249 iLen = RTStrAPrintf(&pszSource, "%s/%s/%s",
1250 pszSourceDir, pszDestSub, pszFileName);
1251 if (!iLen)
1252 return VERR_NO_MEMORY;
1253
1254 char *pszDest;
1255 if (!strlen(pszDestSub))
1256 iLen = RTStrAPrintf(&pszDest, "%s/%s", pszDestRoot, pszFileName);
1257 else
1258 iLen = RTStrAPrintf(&pszDest, "%s/%s/%s", pszDestRoot, pszDestSub,
1259 pszFileName);
1260 if (!iLen)
1261 {
1262 RTStrFree(pszSource);
1263 return VERR_NO_MEMORY;
1264 }
1265
1266 if (fVerbose)
1267 RTPrintf("\"%s\" -> \"%s\"\n", pszSource, pszDest);
1268
1269 int rc = VINF_SUCCESS;
1270
1271 /* Finally copy the desired file (if no dry run selected). */
1272 if (!fDryRun)
1273 {
1274 if (fHostToGuest)
1275 rc = ctrlCopyFileToGuest(pGuest, pszSource, pszDest,
1276 pszUsername, pszPassword, uFlags);
1277 else
1278 rc = ctrlCopyFileToHost(pGuest, pszSource, pszDest,
1279 pszUsername, pszPassword, uFlags);
1280 }
1281 RTStrFree(pszSource);
1282 RTStrFree(pszDest);
1283
1284 return rc;
1285}
1286
1287static int handleCtrlCopyTo(ComPtr<IGuest> guest, HandlerArg *pArg,
1288 bool fHostToGuest)
1289{
1290 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
1291
1292 /** @todo r=bird: This command isn't very unix friendly in general. mkdir
1293 * is much better (partly because it is much simpler of course). The main
1294 * arguments against this is that (1) all but two options conflicts with
1295 * what 'man cp' tells me on a GNU/Linux system, (2) wildchar matching is
1296 * done windows CMD style (though not in a 100% compatible way), and (3)
1297 * that only one source is allowed - efficiently sabotaging default
1298 * wildcard expansion by a unix shell. The best solution here would be
1299 * two different variant, one windowsy (xcopy) and one unixy (gnu cp). */
1300
1301 /*
1302 * IGuest::CopyToGuest is kept as simple as possible to let the developer choose
1303 * what and how to implement the file enumeration/recursive lookup, like VBoxManage
1304 * does in here.
1305 */
1306
1307 static const RTGETOPTDEF s_aOptions[] =
1308 {
1309 { "--dryrun", GETOPTDEF_COPYTO_DRYRUN, RTGETOPT_REQ_NOTHING },
1310 { "--follow", GETOPTDEF_COPYTO_FOLLOW, RTGETOPT_REQ_NOTHING },
1311 { "--password", GETOPTDEF_COPYTO_PASSWORD, RTGETOPT_REQ_STRING },
1312 { "--recursive", 'R', RTGETOPT_REQ_NOTHING },
1313 { "--target-directory", GETOPTDEF_COPYTO_TARGETDIR, RTGETOPT_REQ_STRING },
1314 { "--username", GETOPTDEF_COPYTO_USERNAME, RTGETOPT_REQ_STRING },
1315 { "--verbose", 'v', RTGETOPT_REQ_NOTHING }
1316 };
1317
1318 int ch;
1319 RTGETOPTUNION ValueUnion;
1320 RTGETOPTSTATE GetState;
1321 RTGetOptInit(&GetState, pArg->argc, pArg->argv,
1322 s_aOptions, RT_ELEMENTS(s_aOptions), 0, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1323
1324 Utf8Str Utf8Source;
1325 Utf8Str Utf8Dest;
1326 Utf8Str Utf8UserName;
1327 Utf8Str Utf8Password;
1328 uint32_t fFlags = CopyFileFlag_None;
1329 bool fVerbose = false;
1330 bool fCopyRecursive = false;
1331 bool fDryRun = false;
1332
1333 SOURCEVEC vecSources;
1334
1335 int vrc = VINF_SUCCESS;
1336 while ((ch = RTGetOpt(&GetState, &ValueUnion)))
1337 {
1338 /* For options that require an argument, ValueUnion has received the value. */
1339 switch (ch)
1340 {
1341 case GETOPTDEF_COPYTO_DRYRUN:
1342 fDryRun = true;
1343 break;
1344
1345 case GETOPTDEF_COPYTO_FOLLOW:
1346 fFlags |= CopyFileFlag_FollowLinks;
1347 break;
1348
1349 case GETOPTDEF_COPYTO_PASSWORD:
1350 Utf8Password = ValueUnion.psz;
1351 break;
1352
1353 case 'R': /* Recursive processing */
1354 fFlags |= CopyFileFlag_Recursive;
1355 break;
1356
1357 case GETOPTDEF_COPYTO_TARGETDIR:
1358 Utf8Dest = ValueUnion.psz;
1359 break;
1360
1361 case GETOPTDEF_COPYTO_USERNAME:
1362 Utf8UserName = ValueUnion.psz;
1363 break;
1364
1365 case 'v': /* Verbose */
1366 fVerbose = true;
1367 break;
1368
1369 case VINF_GETOPT_NOT_OPTION:
1370 {
1371 /* Last argument and no destination specified with
1372 * --target-directory yet? Then use the current argument
1373 * as destination. */
1374 if ( pArg->argc == GetState.iNext
1375 && Utf8Dest.isEmpty())
1376 {
1377 Utf8Dest = ValueUnion.psz;
1378 }
1379 else
1380 {
1381 /* Save the source directory. */
1382 vecSources.push_back(SOURCEFILEENTRY(ValueUnion.psz));
1383 }
1384 break;
1385 }
1386
1387 default:
1388 return RTGetOptPrintError(ch, &ValueUnion);
1389 }
1390 }
1391
1392 if (!vecSources.size())
1393 return errorSyntax(USAGE_GUESTCONTROL,
1394 "No source(s) specified!");
1395
1396 if (Utf8Dest.isEmpty())
1397 return errorSyntax(USAGE_GUESTCONTROL,
1398 "No destination specified!");
1399
1400 if (Utf8UserName.isEmpty())
1401 return errorSyntax(USAGE_GUESTCONTROL,
1402 "No user name specified!");
1403
1404 /*
1405 * Done parsing arguments, do some more preparations.
1406 */
1407 if (fVerbose)
1408 {
1409 if (fHostToGuest)
1410 RTPrintf("Copying from host to guest ...\n");
1411 else
1412 RTPrintf("Copying from guest to host ...\n");
1413 if (fDryRun)
1414 RTPrintf("Dry run - no files copied!\n");
1415 }
1416
1417 /* Strip traling slash from destination path. */
1418 RTPathStripTrailingSlash(Utf8Dest.mutableRaw());
1419 Utf8Dest.jolt();
1420
1421 /*
1422 * Here starts the actual fun!
1423 */
1424 for (unsigned long s = 0; s < vecSources.size(); s++)
1425 {
1426 char *pszSourceDir;
1427 if (RTDirExists(vecSources[s].mSource.c_str()))
1428 pszSourceDir = RTStrDup(vecSources[s].mSource.c_str());
1429 else
1430 {
1431 pszSourceDir = RTStrDup(vecSources[s].mSource.c_str());
1432 RTPathStripFilename(pszSourceDir);
1433 }
1434
1435 uint32_t cObjects = 0;
1436 DESTDIRMAP mapDest;
1437 const char *pszDestRoot = Utf8Dest.c_str();
1438
1439 if (fHostToGuest)
1440 vrc = ctrlCopyConstructDestinationsForGuest(vecSources[s], fFlags, pszDestRoot,
1441 mapDest, &cObjects);
1442 else
1443 vrc = ctrlCopyConstructDestinationsForHost(guest, Utf8UserName.c_str(), Utf8Password.c_str(),
1444 vecSources[s], fFlags, pszDestRoot,
1445 mapDest, &cObjects);
1446 if (RT_FAILURE(vrc))
1447 {
1448 if ( fVerbose
1449 && vrc == VERR_FILE_NOT_FOUND)
1450 {
1451 RTPrintf("Warning: Source \"%s\" does not exist, skipping!\n",
1452 vecSources[s].mSource.c_str());
1453 }
1454 }
1455 else
1456 {
1457 /*
1458 * Prepare directory structure of each destination directory.
1459 */
1460 DESTDIRMAPITER itDest;
1461 for (itDest = mapDest.begin(); itDest != mapDest.end(); itDest++)
1462 {
1463 if (fVerbose)
1464 {
1465 const char *pszSubDir = itDest->first.c_str();
1466 AssertPtr(pszSubDir);
1467 if (!strlen(pszSubDir))
1468 RTPrintf("Preparing directory \"%s\" ...\n", pszDestRoot);
1469 else
1470 RTPrintf("Preparing directory \"%s/%s\" ...\n", pszDestRoot,
1471 itDest->first.c_str());
1472 }
1473 if (!fDryRun)
1474 vrc = ctrlCopyPrepareDestDirectory(guest, fHostToGuest,
1475 pszDestRoot, itDest->first.c_str(),
1476 Utf8UserName.c_str(), Utf8Password.c_str());
1477 if (RT_FAILURE(vrc))
1478 break;
1479 }
1480
1481 if (RT_FAILURE(vrc))
1482 break;
1483
1484 if (fVerbose)
1485 {
1486 if (!cObjects)
1487 RTPrintf("Warning: Source \"%s\" has no (matching) files to copy, skipping!\n",
1488 vecSources[s].mSource.c_str());
1489 else
1490 RTPrintf("Copying \"%s\" (%u files) ...\n",
1491 vecSources[s].mSource.c_str(), cObjects);
1492 }
1493
1494 /*
1495 * Copy files of each destination root directory to the guest.
1496 */
1497 for (itDest = mapDest.begin(); itDest != mapDest.end(); itDest++)
1498 {
1499 if (fVerbose && itDest->second.size())
1500 {
1501 if (itDest->first.isEmpty())
1502 RTPrintf("Copying %u files ...\n", itDest->second.size());
1503 else
1504 RTPrintf("Copying directory \"%s\" (%u files) ...\n",
1505 itDest->first.c_str(), itDest->second.size());
1506 }
1507
1508 for (unsigned long l = 0; l < itDest->second.size(); l++)
1509 {
1510 vrc = ctrlCopyToDestDirectory(guest, fVerbose, fDryRun, fHostToGuest,
1511 pszSourceDir,
1512 pszDestRoot, itDest->first.c_str() /* Sub directory */,
1513 itDest->second[l].mFileName.c_str() /* Filename */,
1514 fFlags, Utf8UserName.c_str(), Utf8Password.c_str());
1515 if (RT_FAILURE(vrc))
1516 break;
1517 }
1518
1519 if (RT_FAILURE(vrc))
1520 break;
1521 }
1522
1523 if (RT_FAILURE(vrc))
1524 break;
1525 }
1526
1527 RTStrFree(pszSourceDir);
1528 }
1529
1530 return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1531}
1532
1533static int handleCtrlCreateDirectory(ComPtr<IGuest> guest, HandlerArg *pArg)
1534{
1535 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
1536
1537 /*
1538 * Parse arguments.
1539 *
1540 * Note! No direct returns here, everyone must go thru the cleanup at the
1541 * end of this function.
1542 */
1543 static const RTGETOPTDEF s_aOptions[] =
1544 {
1545 { "--mode", 'm', RTGETOPT_REQ_UINT32 },
1546 { "--parents", 'P', RTGETOPT_REQ_NOTHING },
1547 { "--password", 'p', RTGETOPT_REQ_STRING },
1548 { "--username", 'u', RTGETOPT_REQ_STRING },
1549 { "--verbose", 'v', RTGETOPT_REQ_NOTHING }
1550 };
1551
1552 int ch;
1553 RTGETOPTUNION ValueUnion;
1554 RTGETOPTSTATE GetState;
1555 RTGetOptInit(&GetState, pArg->argc, pArg->argv,
1556 s_aOptions, RT_ELEMENTS(s_aOptions), 0, RTGETOPTINIT_FLAGS_OPTS_FIRST);
1557
1558 Utf8Str Utf8UserName;
1559 Utf8Str Utf8Password;
1560 uint32_t fFlags = DirectoryCreateFlag_None;
1561 uint32_t fDirMode = 0; /* Default mode. */
1562 bool fVerbose = false;
1563
1564 DESTDIRMAP mapDirs;
1565
1566 RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1567 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
1568 && rcExit == RTEXITCODE_SUCCESS)
1569 {
1570 /* For options that require an argument, ValueUnion has received the value. */
1571 switch (ch)
1572 {
1573 case 'm': /* Mode */
1574 fDirMode = ValueUnion.u32;
1575 break;
1576
1577 case 'P': /* Create parents */
1578 fFlags |= DirectoryCreateFlag_Parents;
1579 break;
1580
1581 case 'p': /* Password */
1582 Utf8Password = ValueUnion.psz;
1583 break;
1584
1585 case 'u': /* User name */
1586 Utf8UserName = ValueUnion.psz;
1587 break;
1588
1589 case 'v': /* Verbose */
1590 fVerbose = true;
1591 break;
1592
1593 case VINF_GETOPT_NOT_OPTION:
1594 {
1595 mapDirs[ValueUnion.psz]; /* Add destination directory to map. */
1596 break;
1597 }
1598
1599 default:
1600 rcExit = RTGetOptPrintError(ch, &ValueUnion);
1601 break;
1602 }
1603 }
1604
1605 uint32_t cDirs = mapDirs.size();
1606 if (rcExit == RTEXITCODE_SUCCESS && !cDirs)
1607 rcExit = errorSyntax(USAGE_GUESTCONTROL, "No directory to create specified!");
1608
1609 if (rcExit == RTEXITCODE_SUCCESS && Utf8UserName.isEmpty())
1610 rcExit = errorSyntax(USAGE_GUESTCONTROL, "No user name specified!");
1611
1612 if (rcExit == RTEXITCODE_SUCCESS)
1613 {
1614 /*
1615 * Create the directories.
1616 */
1617 HRESULT hrc = S_OK;
1618 if (fVerbose && cDirs)
1619 RTPrintf("Creating %u directories ...\n", cDirs);
1620
1621 DESTDIRMAPITER it = mapDirs.begin();
1622 while (it != mapDirs.end())
1623 {
1624 if (fVerbose)
1625 RTPrintf("Creating directory \"%s\" ...\n", it->first.c_str());
1626
1627 hrc = guest->DirectoryCreate(Bstr(it->first).raw(),
1628 Bstr(Utf8UserName).raw(), Bstr(Utf8Password).raw(),
1629 fDirMode, fFlags);
1630 if (FAILED(hrc))
1631 {
1632 ctrlPrintError(guest, COM_IIDOF(IGuest)); /* Return code ignored, save original rc. */
1633 break;
1634 }
1635
1636 it++;
1637 }
1638
1639 if (FAILED(hrc))
1640 rcExit = RTEXITCODE_FAILURE;
1641 }
1642
1643 return rcExit;
1644}
1645
1646static int handleCtrlUpdateAdditions(ComPtr<IGuest> guest, HandlerArg *pArg)
1647{
1648 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
1649
1650 /*
1651 * Check the syntax. We can deduce the correct syntax from the number of
1652 * arguments.
1653 */
1654 Utf8Str Utf8Source;
1655 bool fVerbose = false;
1656
1657 static const RTGETOPTDEF s_aOptions[] =
1658 {
1659 { "--source", 's', RTGETOPT_REQ_STRING },
1660 { "--verbose", 'v', RTGETOPT_REQ_NOTHING }
1661 };
1662
1663 int ch;
1664 RTGETOPTUNION ValueUnion;
1665 RTGETOPTSTATE GetState;
1666 RTGetOptInit(&GetState, pArg->argc, pArg->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 0, 0);
1667
1668 int vrc = VINF_SUCCESS;
1669 while ( (ch = RTGetOpt(&GetState, &ValueUnion))
1670 && RT_SUCCESS(vrc))
1671 {
1672 switch (ch)
1673 {
1674 case 's':
1675 Utf8Source = ValueUnion.psz;
1676 break;
1677
1678 case 'v':
1679 fVerbose = true;
1680 break;
1681
1682 default:
1683 return RTGetOptPrintError(ch, &ValueUnion);
1684 }
1685 }
1686
1687 if (fVerbose)
1688 RTPrintf("Updating Guest Additions ...\n");
1689
1690#ifdef DEBUG_andy
1691 if (Utf8Source.isEmpty())
1692 Utf8Source = "c:\\Downloads\\VBoxGuestAdditions-r67158.iso";
1693#endif
1694
1695 /* Determine source if not set yet. */
1696 if (Utf8Source.isEmpty())
1697 {
1698 char strTemp[RTPATH_MAX];
1699 vrc = RTPathAppPrivateNoArch(strTemp, sizeof(strTemp));
1700 AssertRC(vrc);
1701 Utf8Str Utf8Src1 = Utf8Str(strTemp).append("/VBoxGuestAdditions.iso");
1702
1703 vrc = RTPathExecDir(strTemp, sizeof(strTemp));
1704 AssertRC(vrc);
1705 Utf8Str Utf8Src2 = Utf8Str(strTemp).append("/additions/VBoxGuestAdditions.iso");
1706
1707 /* Check the standard image locations */
1708 if (RTFileExists(Utf8Src1.c_str()))
1709 Utf8Source = Utf8Src1;
1710 else if (RTFileExists(Utf8Src2.c_str()))
1711 Utf8Source = Utf8Src2;
1712 else
1713 {
1714 RTMsgError("Source could not be determined! Please use --source to specify a valid source.\n");
1715 vrc = VERR_FILE_NOT_FOUND;
1716 }
1717 }
1718 else if (!RTFileExists(Utf8Source.c_str()))
1719 {
1720 RTMsgError("Source \"%s\" does not exist!\n", Utf8Source.c_str());
1721 vrc = VERR_FILE_NOT_FOUND;
1722 }
1723
1724 if (RT_SUCCESS(vrc))
1725 {
1726 if (fVerbose)
1727 RTPrintf("Using source: %s\n", Utf8Source.c_str());
1728
1729 HRESULT rc = S_OK;
1730 ComPtr<IProgress> progress;
1731 CHECK_ERROR(guest, UpdateGuestAdditions(Bstr(Utf8Source).raw(),
1732 /* Wait for whole update process to complete. */
1733 AdditionsUpdateFlag_None,
1734 progress.asOutParam()));
1735 if (FAILED(rc))
1736 vrc = ctrlPrintError(guest, COM_IIDOF(IGuest));
1737 else
1738 {
1739 rc = showProgress(progress);
1740 if (FAILED(rc))
1741 vrc = ctrlPrintProgressError(progress);
1742 else if (fVerbose)
1743 RTPrintf("Guest Additions update successful.\n");
1744 }
1745 }
1746
1747 return RT_SUCCESS(vrc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
1748}
1749
1750/**
1751 * Access the guest control store.
1752 *
1753 * @returns program exit code.
1754 * @note see the command line API description for parameters
1755 */
1756int handleGuestControl(HandlerArg *pArg)
1757{
1758 AssertPtrReturn(pArg, VERR_INVALID_PARAMETER);
1759
1760 HandlerArg arg = *pArg;
1761 arg.argc = pArg->argc - 2; /* Skip VM name and sub command. */
1762 arg.argv = pArg->argv + 2; /* Same here. */
1763
1764 ComPtr<IGuest> guest;
1765 int vrc = ctrlInitVM(pArg, pArg->argv[0] /* VM Name */, &guest);
1766 if (RT_SUCCESS(vrc))
1767 {
1768 int rcExit;
1769 if ( !strcmp(pArg->argv[1], "exec")
1770 || !strcmp(pArg->argv[1], "execute"))
1771 {
1772 rcExit = handleCtrlExecProgram(guest, &arg);
1773 }
1774#if 0
1775 else if (!strcmp(pArg->argv[1], "copyfrom"))
1776 {
1777 rcExit = handleCtrlCopyTo(guest, &arg,
1778 false /* Guest to host */);
1779 }
1780#endif
1781 else if ( !strcmp(pArg->argv[1], "copyto")
1782 || !strcmp(pArg->argv[1], "cp"))
1783 {
1784 rcExit = handleCtrlCopyTo(guest, &arg,
1785 true /* Host to guest */);
1786 }
1787 else if ( !strcmp(pArg->argv[1], "createdirectory")
1788 || !strcmp(pArg->argv[1], "createdir")
1789 || !strcmp(pArg->argv[1], "mkdir")
1790 || !strcmp(pArg->argv[1], "md"))
1791 {
1792 rcExit = handleCtrlCreateDirectory(guest, &arg);
1793 }
1794 else if ( !strcmp(pArg->argv[1], "updateadditions")
1795 || !strcmp(pArg->argv[1], "updateadds"))
1796 {
1797 rcExit = handleCtrlUpdateAdditions(guest, &arg);
1798 }
1799 else
1800 rcExit = errorSyntax(USAGE_GUESTCONTROL, "No sub command specified!");
1801
1802 ctrlUninitVM(pArg);
1803 return rcExit;
1804 }
1805 return RTEXITCODE_FAILURE;
1806}
1807
1808#endif /* !VBOX_ONLY_DOCS */
1809
Note: See TracBrowser for help on using the repository browser.

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