VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/GuestProcessImpl.cpp@ 70772

Last change on this file since 70772 was 70388, checked in by vboxsync, 6 years ago

Main/GuestProcessImpl.cpp: Made annoying assertion in GuestProcessTool::i_exitCodeToRc andy-only because he hasn't bothered making sure the testcase avoid this assertion yet.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 79.8 KB
Line 
1/* $Id: GuestProcessImpl.cpp 70388 2017-12-29 16:51:03Z vboxsync $ */
2/** @file
3 * VirtualBox Main - Guest process handling.
4 */
5
6/*
7 * Copyright (C) 2012-2017 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18/**
19 * Locking rules:
20 * - When the main dispatcher (callbackDispatcher) is called it takes the
21 * WriteLock while dispatching to the various on* methods.
22 * - All other outer functions (accessible by Main) must not own a lock
23 * while waiting for a callback or for an event.
24 * - Only keep Read/WriteLocks as short as possible and only when necessary.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#define LOG_GROUP LOG_GROUP_GUEST_CONTROL //LOG_GROUP_MAIN_GUESTPROCESS
32#include "LoggingNew.h"
33
34#ifndef VBOX_WITH_GUEST_CONTROL
35# error "VBOX_WITH_GUEST_CONTROL must defined in this file"
36#endif
37#include "GuestProcessImpl.h"
38#include "GuestSessionImpl.h"
39#include "GuestCtrlImplPrivate.h"
40#include "ConsoleImpl.h"
41#include "VirtualBoxErrorInfoImpl.h"
42
43#include "Global.h"
44#include "AutoCaller.h"
45#include "VBoxEvents.h"
46#include "ThreadTask.h"
47
48#include <memory> /* For auto_ptr. */
49
50#include <iprt/asm.h>
51#include <iprt/cpp/utils.h> /* For unconst(). */
52#include <iprt/getopt.h>
53
54#include <VBox/com/listeners.h>
55
56#include <VBox/com/array.h>
57
58
59class GuestProcessTask : public ThreadTask
60{
61public:
62
63 GuestProcessTask(GuestProcess *pProcess)
64 : ThreadTask("GenericGuestProcessTask")
65 , mProcess(pProcess)
66 , mRC(VINF_SUCCESS) { }
67
68 virtual ~GuestProcessTask(void) { }
69
70 int i_rc(void) const { return mRC; }
71 bool i_isOk(void) const { return RT_SUCCESS(mRC); }
72 const ComObjPtr<GuestProcess> &i_process(void) const { return mProcess; }
73
74protected:
75
76 const ComObjPtr<GuestProcess> mProcess;
77 int mRC;
78};
79
80class GuestProcessStartTask : public GuestProcessTask
81{
82public:
83
84 GuestProcessStartTask(GuestProcess *pProcess)
85 : GuestProcessTask(pProcess)
86 {
87 m_strTaskName = "gctlPrcStart";
88 }
89
90 void handler()
91 {
92 GuestProcess::i_startProcessThreadTask(this);
93 }
94};
95
96/**
97 * Internal listener class to serve events in an
98 * active manner, e.g. without polling delays.
99 */
100class GuestProcessListener
101{
102public:
103
104 GuestProcessListener(void)
105 {
106 }
107
108 virtual ~GuestProcessListener(void)
109 {
110 }
111
112 HRESULT init(GuestProcess *pProcess)
113 {
114 AssertPtrReturn(pProcess, E_POINTER);
115 mProcess = pProcess;
116 return S_OK;
117 }
118
119 void uninit(void)
120 {
121 mProcess = NULL;
122 }
123
124 STDMETHOD(HandleEvent)(VBoxEventType_T aType, IEvent *aEvent)
125 {
126 switch (aType)
127 {
128 case VBoxEventType_OnGuestProcessStateChanged:
129 case VBoxEventType_OnGuestProcessInputNotify:
130 case VBoxEventType_OnGuestProcessOutput:
131 {
132 AssertPtrReturn(mProcess, E_POINTER);
133 int rc2 = mProcess->signalWaitEvent(aType, aEvent);
134 RT_NOREF(rc2);
135#ifdef LOG_ENABLED
136 LogFlowThisFunc(("Signalling events of type=%RU32, pProcess=%p resulted in rc=%Rrc\n",
137 aType, &mProcess, rc2));
138#endif
139 break;
140 }
141
142 default:
143 AssertMsgFailed(("Unhandled event %RU32\n", aType));
144 break;
145 }
146
147 return S_OK;
148 }
149
150private:
151
152 GuestProcess *mProcess;
153};
154typedef ListenerImpl<GuestProcessListener, GuestProcess*> GuestProcessListenerImpl;
155
156VBOX_LISTENER_DECLARE(GuestProcessListenerImpl)
157
158// constructor / destructor
159/////////////////////////////////////////////////////////////////////////////
160
161DEFINE_EMPTY_CTOR_DTOR(GuestProcess)
162
163HRESULT GuestProcess::FinalConstruct(void)
164{
165 LogFlowThisFuncEnter();
166 return BaseFinalConstruct();
167}
168
169void GuestProcess::FinalRelease(void)
170{
171 LogFlowThisFuncEnter();
172 uninit();
173 BaseFinalRelease();
174 LogFlowThisFuncLeave();
175}
176
177// public initializer/uninitializer for internal purposes only
178/////////////////////////////////////////////////////////////////////////////
179
180int GuestProcess::init(Console *aConsole, GuestSession *aSession, ULONG aProcessID,
181 const GuestProcessStartupInfo &aProcInfo, const GuestEnvironment *pBaseEnv)
182{
183 LogFlowThisFunc(("aConsole=%p, aSession=%p, aProcessID=%RU32 pBaseEnv=%p\n",
184 aConsole, aSession, aProcessID, pBaseEnv));
185
186 AssertPtrReturn(aConsole, VERR_INVALID_POINTER);
187 AssertPtrReturn(aSession, VERR_INVALID_POINTER);
188
189 /* Enclose the state transition NotReady->InInit->Ready. */
190 AutoInitSpan autoInitSpan(this);
191 AssertReturn(autoInitSpan.isOk(), VERR_OBJECT_DESTROYED);
192
193 HRESULT hr;
194
195 int vrc = bindToSession(aConsole, aSession, aProcessID /* Object ID */);
196 if (RT_SUCCESS(vrc))
197 {
198 hr = unconst(mEventSource).createObject();
199 if (FAILED(hr))
200 vrc = VERR_NO_MEMORY;
201 else
202 {
203 hr = mEventSource->init();
204 if (FAILED(hr))
205 vrc = VERR_COM_UNEXPECTED;
206 }
207 }
208
209 if (RT_SUCCESS(vrc))
210 {
211 try
212 {
213 GuestProcessListener *pListener = new GuestProcessListener();
214 ComObjPtr<GuestProcessListenerImpl> thisListener;
215 hr = thisListener.createObject();
216 if (SUCCEEDED(hr))
217 hr = thisListener->init(pListener, this);
218
219 if (SUCCEEDED(hr))
220 {
221 com::SafeArray <VBoxEventType_T> eventTypes;
222 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
223 eventTypes.push_back(VBoxEventType_OnGuestProcessInputNotify);
224 eventTypes.push_back(VBoxEventType_OnGuestProcessOutput);
225 hr = mEventSource->RegisterListener(thisListener,
226 ComSafeArrayAsInParam(eventTypes),
227 TRUE /* Active listener */);
228 if (SUCCEEDED(hr))
229 {
230 vrc = baseInit();
231 if (RT_SUCCESS(vrc))
232 {
233 mLocalListener = thisListener;
234 }
235 }
236 else
237 vrc = VERR_COM_UNEXPECTED;
238 }
239 else
240 vrc = VERR_COM_UNEXPECTED;
241 }
242 catch(std::bad_alloc &)
243 {
244 vrc = VERR_NO_MEMORY;
245 }
246 }
247
248 if (RT_SUCCESS(vrc))
249 {
250 mData.mProcess = aProcInfo;
251 mData.mpSessionBaseEnv = pBaseEnv;
252 if (pBaseEnv)
253 pBaseEnv->retainConst();
254 mData.mExitCode = 0;
255 mData.mPID = 0;
256 mData.mLastError = VINF_SUCCESS;
257 mData.mStatus = ProcessStatus_Undefined;
258 /* Everything else will be set by the actual starting routine. */
259
260 /* Confirm a successful initialization when it's the case. */
261 autoInitSpan.setSucceeded();
262
263 return vrc;
264 }
265
266 autoInitSpan.setFailed();
267 return vrc;
268}
269
270/**
271 * Uninitializes the instance.
272 * Called from FinalRelease() or IGuestSession::uninit().
273 */
274void GuestProcess::uninit(void)
275{
276 /* Enclose the state transition Ready->InUninit->NotReady. */
277 AutoUninitSpan autoUninitSpan(this);
278 if (autoUninitSpan.uninitDone())
279 return;
280
281 LogFlowThisFunc(("mExe=%s, PID=%RU32\n", mData.mProcess.mExecutable.c_str(), mData.mPID));
282
283 /* Terminate process if not already done yet. */
284 int guestRc = VINF_SUCCESS;
285 int vrc = i_terminateProcess(30 * 1000, &guestRc); /** @todo Make timeouts configurable. */
286 /* Note: Don't return here yet; first uninit all other stuff in
287 * case of failure. */
288
289 if (mData.mpSessionBaseEnv)
290 {
291 mData.mpSessionBaseEnv->releaseConst();
292 mData.mpSessionBaseEnv = NULL;
293 }
294
295 baseUninit();
296
297 LogFlowThisFunc(("Returning rc=%Rrc, guestRc=%Rrc\n",
298 vrc, guestRc));
299 RT_NOREF_PV(vrc);
300}
301
302// implementation of public getters/setters for attributes
303/////////////////////////////////////////////////////////////////////////////
304HRESULT GuestProcess::getArguments(std::vector<com::Utf8Str> &aArguments)
305{
306 LogFlowThisFuncEnter();
307
308 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
309 aArguments = mData.mProcess.mArguments;
310 return S_OK;
311}
312
313HRESULT GuestProcess::getEnvironment(std::vector<com::Utf8Str> &aEnvironment)
314{
315#ifndef VBOX_WITH_GUEST_CONTROL
316 ReturnComNotImplemented();
317#else
318 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); /* (Paranoia since both environment objects are immutable.) */
319 HRESULT hrc;
320 if (mData.mpSessionBaseEnv)
321 {
322 int vrc;
323 if (mData.mProcess.mEnvironmentChanges.count() == 0)
324 vrc = mData.mpSessionBaseEnv->queryPutEnvArray(&aEnvironment);
325 else
326 {
327 GuestEnvironment TmpEnv;
328 vrc = TmpEnv.copy(*mData.mpSessionBaseEnv);
329 if (RT_SUCCESS(vrc))
330 {
331 vrc = TmpEnv.applyChanges(mData.mProcess.mEnvironmentChanges);
332 if (RT_SUCCESS(vrc))
333 vrc = TmpEnv.queryPutEnvArray(&aEnvironment);
334 }
335 }
336 hrc = Global::vboxStatusCodeToCOM(vrc);
337 }
338 else
339 hrc = setError(VBOX_E_NOT_SUPPORTED, tr("The base environment feature is not supported by the guest additions"));
340 LogFlowThisFuncLeave();
341 return hrc;
342#endif
343}
344
345HRESULT GuestProcess::getEventSource(ComPtr<IEventSource> &aEventSource)
346{
347 LogFlowThisFuncEnter();
348
349 // no need to lock - lifetime constant
350 mEventSource.queryInterfaceTo(aEventSource.asOutParam());
351
352 LogFlowThisFuncLeave();
353 return S_OK;
354}
355
356HRESULT GuestProcess::getExecutablePath(com::Utf8Str &aExecutablePath)
357{
358 LogFlowThisFuncEnter();
359
360 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
361
362 aExecutablePath = mData.mProcess.mExecutable;
363
364 return S_OK;
365}
366
367HRESULT GuestProcess::getExitCode(LONG *aExitCode)
368{
369 LogFlowThisFuncEnter();
370
371 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
372
373 *aExitCode = mData.mExitCode;
374
375 return S_OK;
376}
377
378HRESULT GuestProcess::getName(com::Utf8Str &aName)
379{
380 LogFlowThisFuncEnter();
381
382 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
383
384 aName = mData.mProcess.mName;
385
386 return S_OK;
387}
388
389HRESULT GuestProcess::getPID(ULONG *aPID)
390{
391 LogFlowThisFuncEnter();
392
393 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
394
395 *aPID = mData.mPID;
396
397 return S_OK;
398}
399
400HRESULT GuestProcess::getStatus(ProcessStatus_T *aStatus)
401{
402 LogFlowThisFuncEnter();
403
404 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
405
406 *aStatus = mData.mStatus;
407
408 return S_OK;
409}
410
411// private methods
412/////////////////////////////////////////////////////////////////////////////
413
414int GuestProcess::i_callbackDispatcher(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
415{
416 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
417 AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
418#ifdef DEBUG
419 LogFlowThisFunc(("uPID=%RU32, uContextID=%RU32, uFunction=%RU32, pSvcCb=%p\n",
420 mData.mPID, pCbCtx->uContextID, pCbCtx->uFunction, pSvcCb));
421#endif
422
423 int vrc;
424 switch (pCbCtx->uFunction)
425 {
426 case GUEST_DISCONNECTED:
427 {
428 vrc = i_onGuestDisconnected(pCbCtx, pSvcCb);
429 break;
430 }
431
432 case GUEST_EXEC_STATUS:
433 {
434 vrc = i_onProcessStatusChange(pCbCtx, pSvcCb);
435 break;
436 }
437
438 case GUEST_EXEC_OUTPUT:
439 {
440 vrc = i_onProcessOutput(pCbCtx, pSvcCb);
441 break;
442 }
443
444 case GUEST_EXEC_INPUT_STATUS:
445 {
446 vrc = i_onProcessInputStatus(pCbCtx, pSvcCb);
447 break;
448 }
449
450 default:
451 /* Silently ignore not implemented functions. */
452 vrc = VERR_NOT_SUPPORTED;
453 break;
454 }
455
456#ifdef DEBUG
457 LogFlowFuncLeaveRC(vrc);
458#endif
459 return vrc;
460}
461
462/**
463 * Checks if the current assigned PID matches another PID (from a callback).
464 *
465 * In protocol v1 we don't have the possibility to terminate/kill
466 * processes so it can happen that a formerly started process A
467 * (which has the context ID 0 (session=0, process=0, count=0) will
468 * send a delayed message to the host if this process has already
469 * been discarded there and the same context ID was reused by
470 * a process B. Process B in turn then has a different guest PID.
471 *
472 * Note: This also can happen when restoring from a saved state which
473 * had a guest process running.
474 *
475 * @return IPRT status code.
476 * @param uPID PID to check.
477 */
478inline int GuestProcess::i_checkPID(uint32_t uPID)
479{
480 int rc = VINF_SUCCESS;
481
482 /* Was there a PID assigned yet? */
483 if (mData.mPID)
484 {
485 if (RT_UNLIKELY(mData.mPID != uPID))
486 {
487 LogFlowFunc(("Stale guest process (PID=%RU32) sent data to a newly started process (pProcesS=%p, PID=%RU32, status=%RU32)\n",
488 uPID, this, mData.mPID, mData.mStatus));
489 rc = VERR_NOT_FOUND;
490 }
491 }
492
493 return rc;
494}
495
496/* static */
497Utf8Str GuestProcess::i_guestErrorToString(int guestRc)
498{
499 Utf8Str strError;
500
501 /** @todo pData->u32Flags: int vs. uint32 -- IPRT errors are *negative* !!! */
502 switch (guestRc)
503 {
504 case VERR_FILE_NOT_FOUND: /* This is the most likely error. */
505 strError += Utf8StrFmt(tr("The specified file was not found on guest"));
506 break;
507
508 case VERR_INVALID_VM_HANDLE:
509 strError += Utf8StrFmt(tr("VMM device is not available (is the VM running?)"));
510 break;
511
512 case VERR_HGCM_SERVICE_NOT_FOUND:
513 strError += Utf8StrFmt(tr("The guest execution service is not available"));
514 break;
515
516 case VERR_PATH_NOT_FOUND:
517 strError += Utf8StrFmt(tr("Could not resolve path to specified file was not found on guest"));
518 break;
519
520 case VERR_BAD_EXE_FORMAT:
521 strError += Utf8StrFmt(tr("The specified file is not an executable format on guest"));
522 break;
523
524 case VERR_AUTHENTICATION_FAILURE:
525 strError += Utf8StrFmt(tr("The specified user was not able to logon on guest"));
526 break;
527
528 case VERR_INVALID_NAME:
529 strError += Utf8StrFmt(tr("The specified file is an invalid name"));
530 break;
531
532 case VERR_TIMEOUT:
533 strError += Utf8StrFmt(tr("The guest did not respond within time"));
534 break;
535
536 case VERR_CANCELLED:
537 strError += Utf8StrFmt(tr("The execution operation was canceled"));
538 break;
539
540 case VERR_PERMISSION_DENIED: /** @todo r=bird: This is probably completely and utterly misleading. VERR_AUTHENTICATION_FAILURE could have this message. */
541 strError += Utf8StrFmt(tr("Invalid user/password credentials"));
542 break;
543
544 case VERR_MAX_PROCS_REACHED:
545 strError += Utf8StrFmt(tr("Maximum number of concurrent guest processes has been reached"));
546 break;
547
548 case VERR_NOT_FOUND:
549 strError += Utf8StrFmt(tr("The guest execution service is not ready (yet)"));
550 break;
551
552 default:
553 strError += Utf8StrFmt("%Rrc", guestRc);
554 break;
555 }
556
557 return strError;
558}
559
560/**
561 * Returns @c true if the passed in error code indicates an error which came
562 * from the guest side, or @c false if not.
563 *
564 * @return bool @c true if the passed in error code indicates an error which came
565 * from the guest side, or @c false if not.
566 * @param rc Error code to check.
567 */
568/* static */
569bool GuestProcess::i_isGuestError(int rc)
570{
571 return ( rc == VERR_GSTCTL_GUEST_ERROR
572 || rc == VWRN_GSTCTL_PROCESS_EXIT_CODE);
573}
574
575inline bool GuestProcess::i_isAlive(void)
576{
577 return ( mData.mStatus == ProcessStatus_Started
578 || mData.mStatus == ProcessStatus_Paused
579 || mData.mStatus == ProcessStatus_Terminating);
580}
581
582inline bool GuestProcess::i_hasEnded(void)
583{
584 return ( mData.mStatus == ProcessStatus_TerminatedNormally
585 || mData.mStatus == ProcessStatus_TerminatedSignal
586 || mData.mStatus == ProcessStatus_TerminatedAbnormally
587 || mData.mStatus == ProcessStatus_TimedOutKilled
588 || mData.mStatus == ProcessStatus_TimedOutAbnormally
589 || mData.mStatus == ProcessStatus_Down
590 || mData.mStatus == ProcessStatus_Error);
591}
592
593int GuestProcess::i_onGuestDisconnected(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
594{
595 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
596 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
597
598 int vrc = i_setProcessStatus(ProcessStatus_Down, VINF_SUCCESS);
599
600 LogFlowFuncLeaveRC(vrc);
601 return vrc;
602}
603
604int GuestProcess::i_onProcessInputStatus(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
605{
606 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
607 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
608 /* pCallback is optional. */
609
610 if (pSvcCbData->mParms < 5)
611 return VERR_INVALID_PARAMETER;
612
613 CALLBACKDATA_PROC_INPUT dataCb;
614 /* pSvcCb->mpaParms[0] always contains the context ID. */
615 int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
616 AssertRCReturn(vrc, vrc);
617 vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
618 AssertRCReturn(vrc, vrc);
619 vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
620 AssertRCReturn(vrc, vrc);
621 vrc = pSvcCbData->mpaParms[4].getUInt32(&dataCb.uProcessed);
622 AssertRCReturn(vrc, vrc);
623
624 LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RI32, cbProcessed=%RU32\n",
625 dataCb.uPID, dataCb.uStatus, dataCb.uFlags, dataCb.uProcessed));
626
627 vrc = i_checkPID(dataCb.uPID);
628 if (RT_SUCCESS(vrc))
629 {
630 ProcessInputStatus_T inputStatus = ProcessInputStatus_Undefined;
631 switch (dataCb.uStatus)
632 {
633 case INPUT_STS_WRITTEN:
634 inputStatus = ProcessInputStatus_Written;
635 break;
636 case INPUT_STS_ERROR:
637 inputStatus = ProcessInputStatus_Broken;
638 break;
639 case INPUT_STS_TERMINATED:
640 inputStatus = ProcessInputStatus_Broken;
641 break;
642 case INPUT_STS_OVERFLOW:
643 inputStatus = ProcessInputStatus_Overflow;
644 break;
645 case INPUT_STS_UNDEFINED:
646 /* Fall through is intentional. */
647 default:
648 AssertMsg(!dataCb.uProcessed, ("Processed data is not 0 in undefined input state\n"));
649 break;
650 }
651
652 if (inputStatus != ProcessInputStatus_Undefined)
653 {
654 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
655
656 /* Copy over necessary data before releasing lock again. */
657 uint32_t uPID = mData.mPID;
658 /** @todo Also handle mSession? */
659
660 alock.release(); /* Release lock before firing off event. */
661
662 fireGuestProcessInputNotifyEvent(mEventSource, mSession, this,
663 uPID, 0 /* StdIn */, dataCb.uProcessed, inputStatus);
664 }
665 }
666
667 LogFlowFuncLeaveRC(vrc);
668 return vrc;
669}
670
671int GuestProcess::i_onProcessNotifyIO(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
672{
673 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
674 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
675
676 return VERR_NOT_IMPLEMENTED;
677}
678
679int GuestProcess::i_onProcessStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
680{
681 AssertPtrReturn(pCbCtx, VERR_INVALID_POINTER);
682 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
683
684 if (pSvcCbData->mParms < 5)
685 return VERR_INVALID_PARAMETER;
686
687 CALLBACKDATA_PROC_STATUS dataCb;
688 /* pSvcCb->mpaParms[0] always contains the context ID. */
689 int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
690 AssertRCReturn(vrc, vrc);
691 vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uStatus);
692 AssertRCReturn(vrc, vrc);
693 vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
694 AssertRCReturn(vrc, vrc);
695 vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
696 AssertRCReturn(vrc, vrc);
697
698 LogFlowThisFunc(("uPID=%RU32, uStatus=%RU32, uFlags=%RU32\n",
699 dataCb.uPID, dataCb.uStatus, dataCb.uFlags));
700
701 vrc = i_checkPID(dataCb.uPID);
702 if (RT_SUCCESS(vrc))
703 {
704 ProcessStatus_T procStatus = ProcessStatus_Undefined;
705 int procRc = VINF_SUCCESS;
706
707 switch (dataCb.uStatus)
708 {
709 case PROC_STS_STARTED:
710 {
711 procStatus = ProcessStatus_Started;
712
713 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
714 mData.mPID = dataCb.uPID; /* Set the process PID. */
715 break;
716 }
717
718 case PROC_STS_TEN:
719 {
720 procStatus = ProcessStatus_TerminatedNormally;
721
722 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
723 mData.mExitCode = dataCb.uFlags; /* Contains the exit code. */
724 break;
725 }
726
727 case PROC_STS_TES:
728 {
729 procStatus = ProcessStatus_TerminatedSignal;
730
731 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
732 mData.mExitCode = dataCb.uFlags; /* Contains the signal. */
733 break;
734 }
735
736 case PROC_STS_TEA:
737 {
738 procStatus = ProcessStatus_TerminatedAbnormally;
739 break;
740 }
741
742 case PROC_STS_TOK:
743 {
744 procStatus = ProcessStatus_TimedOutKilled;
745 break;
746 }
747
748 case PROC_STS_TOA:
749 {
750 procStatus = ProcessStatus_TimedOutAbnormally;
751 break;
752 }
753
754 case PROC_STS_DWN:
755 {
756 procStatus = ProcessStatus_Down;
757 break;
758 }
759
760 case PROC_STS_ERROR:
761 {
762 procRc = dataCb.uFlags; /* mFlags contains the IPRT error sent from the guest. */
763 procStatus = ProcessStatus_Error;
764 break;
765 }
766
767 case PROC_STS_UNDEFINED:
768 default:
769 {
770 /* Silently skip this request. */
771 procStatus = ProcessStatus_Undefined;
772 break;
773 }
774 }
775
776 LogFlowThisFunc(("Got rc=%Rrc, procSts=%RU32, procRc=%Rrc\n",
777 vrc, procStatus, procRc));
778
779 /* Set the process status. */
780 int rc2 = i_setProcessStatus(procStatus, procRc);
781 if (RT_SUCCESS(vrc))
782 vrc = rc2;
783 }
784
785 LogFlowFuncLeaveRC(vrc);
786 return vrc;
787}
788
789int GuestProcess::i_onProcessOutput(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData)
790{
791 RT_NOREF(pCbCtx);
792 AssertPtrReturn(pSvcCbData, VERR_INVALID_POINTER);
793
794 if (pSvcCbData->mParms < 5)
795 return VERR_INVALID_PARAMETER;
796
797 CALLBACKDATA_PROC_OUTPUT dataCb;
798 /* pSvcCb->mpaParms[0] always contains the context ID. */
799 int vrc = pSvcCbData->mpaParms[1].getUInt32(&dataCb.uPID);
800 AssertRCReturn(vrc, vrc);
801 vrc = pSvcCbData->mpaParms[2].getUInt32(&dataCb.uHandle);
802 AssertRCReturn(vrc, vrc);
803 vrc = pSvcCbData->mpaParms[3].getUInt32(&dataCb.uFlags);
804 AssertRCReturn(vrc, vrc);
805 vrc = pSvcCbData->mpaParms[4].getPointer(&dataCb.pvData, &dataCb.cbData);
806 AssertRCReturn(vrc, vrc);
807
808 LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RI32, pvData=%p, cbData=%RU32\n",
809 dataCb.uPID, dataCb.uHandle, dataCb.uFlags, dataCb.pvData, dataCb.cbData));
810
811 vrc = i_checkPID(dataCb.uPID);
812 if (RT_SUCCESS(vrc))
813 {
814 com::SafeArray<BYTE> data((size_t)dataCb.cbData);
815 if (dataCb.cbData)
816 data.initFrom((BYTE*)dataCb.pvData, dataCb.cbData);
817
818 fireGuestProcessOutputEvent(mEventSource, mSession, this,
819 mData.mPID, dataCb.uHandle, dataCb.cbData, ComSafeArrayAsInParam(data));
820 }
821
822 LogFlowFuncLeaveRC(vrc);
823 return vrc;
824}
825
826/**
827 * Called by IGuestSession right before this process gets
828 * removed from the public process list.
829 */
830int GuestProcess::i_onRemove(void)
831{
832 LogFlowThisFuncEnter();
833
834 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
835
836 int vrc = VINF_SUCCESS;
837
838 /*
839 * Note: The event source stuff holds references to this object,
840 * so make sure that this is cleaned up *before* calling uninit().
841 */
842 if (!mEventSource.isNull())
843 {
844 mEventSource->UnregisterListener(mLocalListener);
845
846 mLocalListener.setNull();
847 unconst(mEventSource).setNull();
848 }
849
850 LogFlowFuncLeaveRC(vrc);
851 return vrc;
852}
853
854int GuestProcess::i_readData(uint32_t uHandle, uint32_t uSize, uint32_t uTimeoutMS,
855 void *pvData, size_t cbData, uint32_t *pcbRead, int *pGuestRc)
856{
857 LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uSize=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%RU32, pGuestRc=%p\n",
858 mData.mPID, uHandle, uSize, uTimeoutMS, pvData, cbData, pGuestRc));
859 AssertReturn(uSize, VERR_INVALID_PARAMETER);
860 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
861 AssertReturn(cbData >= uSize, VERR_INVALID_PARAMETER);
862 /* pcbRead is optional. */
863
864 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
865
866 if ( mData.mStatus != ProcessStatus_Started
867 /* Skip reading if the process wasn't started with the appropriate
868 * flags. */
869 || ( ( uHandle == OUTPUT_HANDLE_ID_STDOUT
870 || uHandle == OUTPUT_HANDLE_ID_STDOUT_DEPRECATED)
871 && !(mData.mProcess.mFlags & ProcessCreateFlag_WaitForStdOut))
872 || ( uHandle == OUTPUT_HANDLE_ID_STDERR
873 && !(mData.mProcess.mFlags & ProcessCreateFlag_WaitForStdErr))
874 )
875 {
876 if (pcbRead)
877 *pcbRead = 0;
878 if (pGuestRc)
879 *pGuestRc = VINF_SUCCESS;
880 return VINF_SUCCESS; /* Nothing to read anymore. */
881 }
882
883 int vrc;
884
885 GuestWaitEvent *pEvent = NULL;
886 GuestEventTypes eventTypes;
887 try
888 {
889 /*
890 * On Guest Additions < 4.3 there is no guarantee that the process status
891 * change arrives *after* the output event, e.g. if this was the last output
892 * block being read and the process will report status "terminate".
893 * So just skip checking for process status change and only wait for the
894 * output event.
895 */
896 if (mSession->i_getProtocolVersion() >= 2)
897 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
898 eventTypes.push_back(VBoxEventType_OnGuestProcessOutput);
899
900 vrc = registerWaitEvent(eventTypes, &pEvent);
901 }
902 catch (std::bad_alloc)
903 {
904 vrc = VERR_NO_MEMORY;
905 }
906
907 if (RT_FAILURE(vrc))
908 return vrc;
909
910 if (RT_SUCCESS(vrc))
911 {
912 VBOXHGCMSVCPARM paParms[8];
913 int i = 0;
914 paParms[i++].setUInt32(pEvent->ContextID());
915 paParms[i++].setUInt32(mData.mPID);
916 paParms[i++].setUInt32(uHandle);
917 paParms[i++].setUInt32(0 /* Flags, none set yet. */);
918
919 alock.release(); /* Drop the write lock before sending. */
920
921 vrc = sendCommand(HOST_EXEC_GET_OUTPUT, i, paParms);
922 }
923
924 if (RT_SUCCESS(vrc))
925 vrc = i_waitForOutput(pEvent, uHandle, uTimeoutMS,
926 pvData, cbData, pcbRead);
927
928 unregisterWaitEvent(pEvent);
929
930 LogFlowFuncLeaveRC(vrc);
931 return vrc;
932}
933
934/* Does not do locking; caller is responsible for that! */
935int GuestProcess::i_setProcessStatus(ProcessStatus_T procStatus, int procRc)
936{
937 LogFlowThisFuncEnter();
938
939 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
940
941 LogFlowThisFunc(("oldStatus=%RU32, newStatus=%RU32, procRc=%Rrc\n",
942 mData.mStatus, procStatus, procRc));
943
944 if (procStatus == ProcessStatus_Error)
945 {
946 AssertMsg(RT_FAILURE(procRc), ("Guest rc must be an error (%Rrc)\n", procRc));
947 /* Do not allow overwriting an already set error. If this happens
948 * this means we forgot some error checking/locking somewhere. */
949 AssertMsg(RT_SUCCESS(mData.mLastError), ("Guest rc already set (to %Rrc)\n", mData.mLastError));
950 }
951 else
952 AssertMsg(RT_SUCCESS(procRc), ("Guest rc must not be an error (%Rrc)\n", procRc));
953
954 int rc = VINF_SUCCESS;
955
956 if (mData.mStatus != procStatus) /* Was there a process status change? */
957 {
958 mData.mStatus = procStatus;
959 mData.mLastError = procRc;
960
961 ComObjPtr<VirtualBoxErrorInfo> errorInfo;
962 HRESULT hr = errorInfo.createObject();
963 ComAssertComRC(hr);
964 if (RT_FAILURE(mData.mLastError))
965 {
966 hr = errorInfo->initEx(VBOX_E_IPRT_ERROR, mData.mLastError,
967 COM_IIDOF(IGuestProcess), getComponentName(),
968 i_guestErrorToString(mData.mLastError));
969 ComAssertComRC(hr);
970 }
971
972 /* Copy over necessary data before releasing lock again. */
973 uint32_t uPID = mData.mPID;
974 /** @todo Also handle mSession? */
975
976 alock.release(); /* Release lock before firing off event. */
977
978 fireGuestProcessStateChangedEvent(mEventSource, mSession, this,
979 uPID, procStatus, errorInfo);
980#if 0
981 /*
982 * On Guest Additions < 4.3 there is no guarantee that outstanding
983 * requests will be delivered to the host after the process has ended,
984 * so just cancel all waiting events here to not let clients run
985 * into timeouts.
986 */
987 if ( mSession->getProtocolVersion() < 2
988 && hasEnded())
989 {
990 LogFlowThisFunc(("Process ended, canceling outstanding wait events ...\n"));
991 rc = cancelWaitEvents();
992 }
993#endif
994 }
995
996 return rc;
997}
998
999/* static */
1000HRESULT GuestProcess::i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc)
1001{
1002 AssertPtr(pInterface);
1003 AssertMsg(RT_FAILURE(guestRc), ("Guest rc does not indicate a failure when setting error\n"));
1004
1005 return pInterface->setError(VBOX_E_IPRT_ERROR, GuestProcess::i_guestErrorToString(guestRc).c_str());
1006}
1007
1008int GuestProcess::i_startProcess(uint32_t cMsTimeout, int *pGuestRc)
1009{
1010 LogFlowThisFunc(("cMsTimeout=%RU32, procExe=%s, procTimeoutMS=%RU32, procFlags=%x, sessionID=%RU32\n",
1011 cMsTimeout, mData.mProcess.mExecutable.c_str(), mData.mProcess.mTimeoutMS, mData.mProcess.mFlags,
1012 mSession->i_getId()));
1013
1014 /* Wait until the caller function (if kicked off by a thread)
1015 * has returned and continue operation. */
1016 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1017
1018 mData.mStatus = ProcessStatus_Starting;
1019
1020 int vrc;
1021
1022 GuestWaitEvent *pEvent = NULL;
1023 GuestEventTypes eventTypes;
1024 try
1025 {
1026 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1027 vrc = registerWaitEvent(eventTypes, &pEvent);
1028 }
1029 catch (std::bad_alloc)
1030 {
1031 vrc = VERR_NO_MEMORY;
1032 }
1033 if (RT_FAILURE(vrc))
1034 return vrc;
1035
1036 vrc = i_startProcessInner(cMsTimeout, alock, pEvent, pGuestRc);
1037
1038 unregisterWaitEvent(pEvent);
1039
1040 LogFlowFuncLeaveRC(vrc);
1041 return vrc;
1042}
1043
1044int GuestProcess::i_startProcessInner(uint32_t cMsTimeout, AutoWriteLock &rLock, GuestWaitEvent *pEvent, int *pGuestRc)
1045{
1046 GuestSession *pSession = mSession;
1047 AssertPtr(pSession);
1048 uint32_t const uProtocol = pSession->i_getProtocolVersion();
1049
1050 const GuestCredentials &sessionCreds = pSession->i_getCredentials();
1051
1052
1053 /* Prepare arguments. */
1054 size_t cArgs = mData.mProcess.mArguments.size();
1055 if (cArgs >= 128*1024)
1056 return VERR_BUFFER_OVERFLOW;
1057
1058 char *pszArgs = NULL;
1059 int vrc = VINF_SUCCESS;
1060 if (cArgs)
1061 {
1062 char const **papszArgv = (char const **)RTMemAlloc((cArgs + 1) * sizeof(papszArgv[0]));
1063 AssertReturn(papszArgv, VERR_NO_MEMORY);
1064
1065 for (size_t i = 0; i < cArgs; i++)
1066 {
1067 papszArgv[i] = mData.mProcess.mArguments[i].c_str();
1068 AssertPtr(papszArgv[i]);
1069 }
1070 papszArgv[cArgs] = NULL;
1071
1072 if (uProtocol < UINT32_C(0xdeadbeef) ) /** @todo implement a way of sending argv[0], best idea is a new command. */
1073 vrc = RTGetOptArgvToString(&pszArgs, papszArgv + 1, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
1074 else
1075 vrc = RTGetOptArgvToString(&pszArgs, papszArgv, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
1076
1077 RTMemFree(papszArgv);
1078 if (RT_FAILURE(vrc))
1079 return vrc;
1080
1081 /* Note! No returns after this. */
1082 }
1083
1084 /* Calculate arguments size (in bytes). */
1085 size_t cbArgs = pszArgs ? strlen(pszArgs) + 1 : 0; /* Include terminating zero. */
1086
1087 /* Prepare environment. The guest service dislikes the empty string at the end, so drop it. */
1088 size_t cbEnvBlock;
1089 char *pszzEnvBlock;
1090 vrc = mData.mProcess.mEnvironmentChanges.queryUtf8Block(&pszzEnvBlock, &cbEnvBlock);
1091 if (RT_SUCCESS(vrc))
1092 {
1093 Assert(cbEnvBlock > 0);
1094 cbEnvBlock--;
1095
1096 /* Prepare HGCM call. */
1097 VBOXHGCMSVCPARM paParms[16];
1098 int i = 0;
1099 paParms[i++].setUInt32(pEvent->ContextID());
1100 paParms[i++].setCppString(mData.mProcess.mExecutable);
1101 paParms[i++].setUInt32(mData.mProcess.mFlags);
1102 paParms[i++].setUInt32((uint32_t)mData.mProcess.mArguments.size());
1103 paParms[i++].setPointer(pszArgs, (uint32_t)cbArgs);
1104 paParms[i++].setUInt32(mData.mProcess.mEnvironmentChanges.count());
1105 paParms[i++].setUInt32((uint32_t)cbEnvBlock);
1106 paParms[i++].setPointer(pszzEnvBlock, (uint32_t)cbEnvBlock);
1107 if (uProtocol < 2)
1108 {
1109 /* In protocol v1 (VBox < 4.3) the credentials were part of the execution
1110 * call. In newer protocols these credentials are part of the opened guest
1111 * session, so not needed anymore here. */
1112 paParms[i++].setCppString(sessionCreds.mUser);
1113 paParms[i++].setCppString(sessionCreds.mPassword);
1114 }
1115 /*
1116 * If the WaitForProcessStartOnly flag is set, we only want to define and wait for a timeout
1117 * until the process was started - the process itself then gets an infinite timeout for execution.
1118 * This is handy when we want to start a process inside a worker thread within a certain timeout
1119 * but let the started process perform lengthly operations then.
1120 */
1121 if (mData.mProcess.mFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1122 paParms[i++].setUInt32(UINT32_MAX /* Infinite timeout */);
1123 else
1124 paParms[i++].setUInt32(mData.mProcess.mTimeoutMS);
1125 if (uProtocol >= 2)
1126 {
1127 paParms[i++].setUInt32(mData.mProcess.mPriority);
1128 /* CPU affinity: We only support one CPU affinity block at the moment,
1129 * so that makes up to 64 CPUs total. This can be more in the future. */
1130 paParms[i++].setUInt32(1);
1131 /* The actual CPU affinity blocks. */
1132 paParms[i++].setPointer((void *)&mData.mProcess.mAffinity, sizeof(mData.mProcess.mAffinity));
1133 }
1134
1135 rLock.release(); /* Drop the write lock before sending. */
1136
1137 vrc = sendCommand(HOST_EXEC_CMD, i, paParms);
1138 if (RT_FAILURE(vrc))
1139 {
1140 int rc2 = i_setProcessStatus(ProcessStatus_Error, vrc);
1141 AssertRC(rc2);
1142 }
1143
1144 mData.mProcess.mEnvironmentChanges.freeUtf8Block(pszzEnvBlock);
1145 }
1146
1147 RTStrFree(pszArgs);
1148
1149 if (RT_SUCCESS(vrc))
1150 vrc = i_waitForStatusChange(pEvent, cMsTimeout,
1151 NULL /* Process status */, pGuestRc);
1152 return vrc;
1153}
1154
1155int GuestProcess::i_startProcessAsync(void)
1156{
1157 LogFlowThisFuncEnter();
1158
1159 int vrc = VINF_SUCCESS;
1160 HRESULT hr = S_OK;
1161
1162 GuestProcessStartTask* pTask = NULL;
1163 try
1164 {
1165 pTask = new GuestProcessStartTask(this);
1166 if (!pTask->i_isOk())
1167 {
1168 delete pTask;
1169 LogFlow(("GuestProcess: Could not create GuestProcessStartTask object \n"));
1170 throw VERR_MEMOBJ_INIT_FAILED;
1171 }
1172 LogFlow(("GuestProcess: Successfully created GuestProcessStartTask object \n"));
1173 //this function delete pTask in case of exceptions, so there is no need in the call of delete operator
1174 hr = pTask->createThread();
1175 }
1176 catch(std::bad_alloc &)
1177 {
1178 vrc = VERR_NO_MEMORY;
1179 }
1180 catch(int eVRC)
1181 {
1182 vrc = eVRC;
1183 LogFlow(("GuestSession: Could not create thread for GuestProcessStartTask task %Rrc\n", vrc));
1184 }
1185
1186 LogFlowFuncLeaveRC(vrc);
1187 return vrc;
1188}
1189
1190/* static */
1191void GuestProcess::i_startProcessThreadTask(GuestProcessStartTask *pTask)
1192{
1193 LogFlowFunc(("pTask=%p\n", pTask));
1194
1195 const ComObjPtr<GuestProcess> pProcess(pTask->i_process());
1196 Assert(!pProcess.isNull());
1197
1198 AutoCaller autoCaller(pProcess);
1199 if (FAILED(autoCaller.rc()))
1200 return;
1201
1202 int vrc = pProcess->i_startProcess(30 * 1000 /* 30s timeout */,
1203 NULL /* Guest rc, ignored */);
1204/** @todo
1205 *
1206 * r=bird: what's up with vrc here? Safe to ignore it?
1207 *
1208 */
1209
1210 /* Nothing to do here anymore. */
1211
1212 LogFlowFunc(("pProcess=%p vrc=%Rrc (ignored)\n", (GuestProcess *)pProcess, vrc));
1213 NOREF(vrc);
1214}
1215
1216int GuestProcess::i_terminateProcess(uint32_t uTimeoutMS, int *pGuestRc)
1217{
1218 /* pGuestRc is optional. */
1219 LogFlowThisFunc(("uTimeoutMS=%RU32\n", uTimeoutMS));
1220
1221 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1222
1223 int vrc = VINF_SUCCESS;
1224
1225 if (mData.mStatus != ProcessStatus_Started)
1226 {
1227 LogFlowThisFunc(("Process not in started state (state is %RU32), skipping termination\n",
1228 mData.mStatus));
1229 }
1230 else
1231 {
1232 AssertPtr(mSession);
1233 /* Note: VBox < 4.3 (aka protocol version 1) does not
1234 * support this, so just skip. */
1235 if (mSession->i_getProtocolVersion() < 2)
1236 vrc = VERR_NOT_SUPPORTED;
1237
1238 if (RT_SUCCESS(vrc))
1239 {
1240 GuestWaitEvent *pEvent = NULL;
1241 GuestEventTypes eventTypes;
1242 try
1243 {
1244 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1245
1246 vrc = registerWaitEvent(eventTypes, &pEvent);
1247 }
1248 catch (std::bad_alloc)
1249 {
1250 vrc = VERR_NO_MEMORY;
1251 }
1252
1253 if (RT_FAILURE(vrc))
1254 return vrc;
1255
1256 VBOXHGCMSVCPARM paParms[4];
1257 int i = 0;
1258 paParms[i++].setUInt32(pEvent->ContextID());
1259 paParms[i++].setUInt32(mData.mPID);
1260
1261 alock.release(); /* Drop the write lock before sending. */
1262
1263 vrc = sendCommand(HOST_EXEC_TERMINATE, i, paParms);
1264 if (RT_SUCCESS(vrc))
1265 vrc = i_waitForStatusChange(pEvent, uTimeoutMS,
1266 NULL /* ProcessStatus */, pGuestRc);
1267 unregisterWaitEvent(pEvent);
1268 }
1269 }
1270
1271 LogFlowFuncLeaveRC(vrc);
1272 return vrc;
1273}
1274
1275/* static */
1276ProcessWaitResult_T GuestProcess::i_waitFlagsToResultEx(uint32_t fWaitFlags,
1277 ProcessStatus_T oldStatus, ProcessStatus_T newStatus,
1278 uint32_t uProcFlags, uint32_t uProtocol)
1279{
1280 ProcessWaitResult_T waitResult = ProcessWaitResult_None;
1281
1282 switch (newStatus)
1283 {
1284 case ProcessStatus_TerminatedNormally:
1285 case ProcessStatus_TerminatedSignal:
1286 case ProcessStatus_TerminatedAbnormally:
1287 case ProcessStatus_Down:
1288 /* Nothing to wait for anymore. */
1289 waitResult = ProcessWaitResult_Terminate;
1290 break;
1291
1292 case ProcessStatus_TimedOutKilled:
1293 case ProcessStatus_TimedOutAbnormally:
1294 /* Dito. */
1295 waitResult = ProcessWaitResult_Timeout;
1296 break;
1297
1298 case ProcessStatus_Started:
1299 switch (oldStatus)
1300 {
1301 case ProcessStatus_Undefined:
1302 case ProcessStatus_Starting:
1303 /* Also wait for process start. */
1304 if (fWaitFlags & ProcessWaitForFlag_Start)
1305 waitResult = ProcessWaitResult_Start;
1306 else
1307 {
1308 /*
1309 * If ProcessCreateFlag_WaitForProcessStartOnly was specified on process creation the
1310 * caller is not interested in getting further process statuses -- so just don't notify
1311 * anything here anymore and return.
1312 */
1313 if (uProcFlags & ProcessCreateFlag_WaitForProcessStartOnly)
1314 waitResult = ProcessWaitResult_Start;
1315 }
1316 break;
1317
1318 case ProcessStatus_Started:
1319 /* Only wait for process start. */
1320 if (fWaitFlags == ProcessWaitForFlag_Start)
1321 waitResult = ProcessWaitResult_Start;
1322 break;
1323
1324 default:
1325 AssertMsgFailed(("Unhandled old status %RU32 before new status 'started'\n",
1326 oldStatus));
1327 waitResult = ProcessWaitResult_Start;
1328 break;
1329 }
1330 break;
1331
1332 case ProcessStatus_Error:
1333 /* Nothing to wait for anymore. */
1334 waitResult = ProcessWaitResult_Error;
1335 break;
1336
1337 case ProcessStatus_Undefined:
1338 case ProcessStatus_Starting:
1339 case ProcessStatus_Terminating:
1340 case ProcessStatus_Paused:
1341 /* No result available yet, leave wait
1342 * flags untouched. */
1343 break;
1344 }
1345
1346 if (newStatus == ProcessStatus_Started)
1347 {
1348 /**
1349 * Filter out waits which are *not* supported using
1350 * older guest control Guest Additions.
1351 *
1352 ** @todo ProcessWaitForFlag_Std* flags are not implemented yet.
1353 */
1354 if (uProtocol < 99) /* See @todo above. */
1355 {
1356 if ( waitResult == ProcessWaitResult_None
1357 /* We don't support waiting for stdin, out + err,
1358 * just skip waiting then. */
1359 && ( (fWaitFlags & ProcessWaitForFlag_StdIn)
1360 || (fWaitFlags & ProcessWaitForFlag_StdOut)
1361 || (fWaitFlags & ProcessWaitForFlag_StdErr)
1362 )
1363 )
1364 {
1365 /* Use _WaitFlagNotSupported because we don't know what to tell the caller. */
1366 waitResult = ProcessWaitResult_WaitFlagNotSupported;
1367 }
1368 }
1369 }
1370
1371#ifdef DEBUG
1372 LogFlowFunc(("oldStatus=%RU32, newStatus=%RU32, fWaitFlags=0x%x, waitResult=%RU32\n",
1373 oldStatus, newStatus, fWaitFlags, waitResult));
1374#endif
1375 return waitResult;
1376}
1377
1378ProcessWaitResult_T GuestProcess::i_waitFlagsToResult(uint32_t fWaitFlags)
1379{
1380 AssertPtr(mSession);
1381 return GuestProcess::i_waitFlagsToResultEx(fWaitFlags,
1382 mData.mStatus /* curStatus */, mData.mStatus /* newStatus */,
1383 mData.mProcess.mFlags, mSession->i_getProtocolVersion());
1384}
1385
1386int GuestProcess::i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS,
1387 ProcessWaitResult_T &waitResult, int *pGuestRc)
1388{
1389 AssertReturn(fWaitFlags, VERR_INVALID_PARAMETER);
1390
1391 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1392
1393 LogFlowThisFunc(("fWaitFlags=0x%x, uTimeoutMS=%RU32, procStatus=%RU32, procRc=%Rrc, pGuestRc=%p\n",
1394 fWaitFlags, uTimeoutMS, mData.mStatus, mData.mLastError, pGuestRc));
1395
1396 /* Did some error occur before? Then skip waiting and return. */
1397 ProcessStatus_T curStatus = mData.mStatus;
1398 if (curStatus == ProcessStatus_Error)
1399 {
1400 waitResult = ProcessWaitResult_Error;
1401 AssertMsg(RT_FAILURE(mData.mLastError),
1402 ("No error rc (%Rrc) set when guest process indicated an error\n", mData.mLastError));
1403 if (pGuestRc)
1404 *pGuestRc = mData.mLastError; /* Return last set error. */
1405 LogFlowThisFunc(("Process is in error state (guestRc=%Rrc)\n", mData.mLastError));
1406 return VERR_GSTCTL_GUEST_ERROR;
1407 }
1408
1409 waitResult = i_waitFlagsToResult(fWaitFlags);
1410
1411 /* No waiting needed? Return immediately using the last set error. */
1412 if (waitResult != ProcessWaitResult_None)
1413 {
1414 if (pGuestRc)
1415 *pGuestRc = mData.mLastError; /* Return last set error (if any). */
1416 LogFlowThisFunc(("Nothing to wait for (guestRc=%Rrc)\n", mData.mLastError));
1417 return RT_SUCCESS(mData.mLastError) ? VINF_SUCCESS : VERR_GSTCTL_GUEST_ERROR;
1418 }
1419
1420 /* Adjust timeout. Passing 0 means RT_INDEFINITE_WAIT. */
1421 if (!uTimeoutMS)
1422 uTimeoutMS = RT_INDEFINITE_WAIT;
1423
1424 int vrc;
1425
1426 GuestWaitEvent *pEvent = NULL;
1427 GuestEventTypes eventTypes;
1428 try
1429 {
1430 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1431
1432 vrc = registerWaitEvent(eventTypes, &pEvent);
1433 }
1434 catch (std::bad_alloc)
1435 {
1436 vrc = VERR_NO_MEMORY;
1437 }
1438
1439 if (RT_FAILURE(vrc))
1440 return vrc;
1441
1442 alock.release(); /* Release lock before waiting. */
1443
1444 /*
1445 * Do the actual waiting.
1446 */
1447 ProcessStatus_T newStatus = ProcessStatus_Undefined;
1448 uint64_t u64StartMS = RTTimeMilliTS();
1449 for (;;)
1450 {
1451 uint64_t u64ElapsedMS = RTTimeMilliTS() - u64StartMS;
1452 if ( uTimeoutMS != RT_INDEFINITE_WAIT
1453 && u64ElapsedMS >= uTimeoutMS)
1454 {
1455 vrc = VERR_TIMEOUT;
1456 break;
1457 }
1458
1459 vrc = i_waitForStatusChange(pEvent,
1460 uTimeoutMS == RT_INDEFINITE_WAIT
1461 ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS,
1462 &newStatus, pGuestRc);
1463 if (RT_SUCCESS(vrc))
1464 {
1465 alock.acquire();
1466
1467 waitResult = i_waitFlagsToResultEx(fWaitFlags, curStatus, newStatus,
1468 mData.mProcess.mFlags, mSession->i_getProtocolVersion());
1469#ifdef DEBUG
1470 LogFlowThisFunc(("Got new status change: fWaitFlags=0x%x, newStatus=%RU32, waitResult=%RU32\n",
1471 fWaitFlags, newStatus, waitResult));
1472#endif
1473 if (ProcessWaitResult_None != waitResult) /* We got a waiting result. */
1474 break;
1475 }
1476 else /* Waiting failed, bail out. */
1477 break;
1478
1479 alock.release(); /* Don't hold lock in next waiting round. */
1480 }
1481
1482 unregisterWaitEvent(pEvent);
1483
1484 LogFlowThisFunc(("Returned waitResult=%RU32, newStatus=%RU32, rc=%Rrc\n",
1485 waitResult, newStatus, vrc));
1486 return vrc;
1487}
1488
1489int GuestProcess::i_waitForInputNotify(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
1490 ProcessInputStatus_T *pInputStatus, uint32_t *pcbProcessed)
1491{
1492 RT_NOREF(uHandle);
1493 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1494
1495 VBoxEventType_T evtType;
1496 ComPtr<IEvent> pIEvent;
1497 int vrc = waitForEvent(pEvent, uTimeoutMS,
1498 &evtType, pIEvent.asOutParam());
1499 if (RT_SUCCESS(vrc))
1500 {
1501 if (evtType == VBoxEventType_OnGuestProcessInputNotify)
1502 {
1503 ComPtr<IGuestProcessInputNotifyEvent> pProcessEvent = pIEvent;
1504 Assert(!pProcessEvent.isNull());
1505
1506 if (pInputStatus)
1507 {
1508 HRESULT hr2 = pProcessEvent->COMGETTER(Status)(pInputStatus);
1509 ComAssertComRC(hr2);
1510 }
1511 if (pcbProcessed)
1512 {
1513 HRESULT hr2 = pProcessEvent->COMGETTER(Processed)((ULONG*)pcbProcessed);
1514 ComAssertComRC(hr2);
1515 }
1516 }
1517 else
1518 vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1519 }
1520
1521 LogFlowThisFunc(("Returning pEvent=%p, uHandle=%RU32, rc=%Rrc\n",
1522 pEvent, uHandle, vrc));
1523 return vrc;
1524}
1525
1526int GuestProcess::i_waitForOutput(GuestWaitEvent *pEvent, uint32_t uHandle, uint32_t uTimeoutMS,
1527 void *pvData, size_t cbData, uint32_t *pcbRead)
1528{
1529 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1530 /* pvData is optional. */
1531 /* cbData is optional. */
1532 /* pcbRead is optional. */
1533
1534 LogFlowThisFunc(("cEventTypes=%zu, pEvent=%p, uHandle=%RU32, uTimeoutMS=%RU32, pvData=%p, cbData=%zu, pcbRead=%p\n",
1535 pEvent->TypeCount(), pEvent, uHandle, uTimeoutMS, pvData, cbData, pcbRead));
1536
1537 int vrc;
1538
1539 VBoxEventType_T evtType;
1540 ComPtr<IEvent> pIEvent;
1541 do
1542 {
1543 vrc = waitForEvent(pEvent, uTimeoutMS,
1544 &evtType, pIEvent.asOutParam());
1545 if (RT_SUCCESS(vrc))
1546 {
1547 if (evtType == VBoxEventType_OnGuestProcessOutput)
1548 {
1549 ComPtr<IGuestProcessOutputEvent> pProcessEvent = pIEvent;
1550 Assert(!pProcessEvent.isNull());
1551
1552 ULONG uHandleEvent;
1553 HRESULT hr = pProcessEvent->COMGETTER(Handle)(&uHandleEvent);
1554 if ( SUCCEEDED(hr)
1555 && uHandleEvent == uHandle)
1556 {
1557 if (pvData)
1558 {
1559 com::SafeArray <BYTE> data;
1560 hr = pProcessEvent->COMGETTER(Data)(ComSafeArrayAsOutParam(data));
1561 ComAssertComRC(hr);
1562 size_t cbRead = data.size();
1563 if (cbRead)
1564 {
1565 if (cbRead <= cbData)
1566 {
1567 /* Copy data from event into our buffer. */
1568 memcpy(pvData, data.raw(), data.size());
1569 }
1570 else
1571 vrc = VERR_BUFFER_OVERFLOW;
1572
1573 LogFlowThisFunc(("Read %zu bytes (uHandle=%RU32), rc=%Rrc\n",
1574 cbRead, uHandleEvent, vrc));
1575 }
1576 }
1577
1578 if ( RT_SUCCESS(vrc)
1579 && pcbRead)
1580 {
1581 ULONG cbRead;
1582 hr = pProcessEvent->COMGETTER(Processed)(&cbRead);
1583 ComAssertComRC(hr);
1584 *pcbRead = (uint32_t)cbRead;
1585 }
1586
1587 break;
1588 }
1589 else if (FAILED(hr))
1590 vrc = VERR_COM_UNEXPECTED;
1591 }
1592 else
1593 vrc = VWRN_GSTCTL_OBJECTSTATE_CHANGED;
1594 }
1595
1596 } while (vrc == VINF_SUCCESS);
1597
1598 if ( vrc != VINF_SUCCESS
1599 && pcbRead)
1600 {
1601 *pcbRead = 0;
1602 }
1603
1604 LogFlowFuncLeaveRC(vrc);
1605 return vrc;
1606}
1607
1608int GuestProcess::i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t uTimeoutMS,
1609 ProcessStatus_T *pProcessStatus, int *pGuestRc)
1610{
1611 AssertPtrReturn(pEvent, VERR_INVALID_POINTER);
1612 /* pProcessStatus is optional. */
1613 /* pGuestRc is optional. */
1614
1615 VBoxEventType_T evtType;
1616 ComPtr<IEvent> pIEvent;
1617 int vrc = waitForEvent(pEvent, uTimeoutMS,
1618 &evtType, pIEvent.asOutParam());
1619 if (RT_SUCCESS(vrc))
1620 {
1621 Assert(evtType == VBoxEventType_OnGuestProcessStateChanged);
1622 ComPtr<IGuestProcessStateChangedEvent> pProcessEvent = pIEvent;
1623 Assert(!pProcessEvent.isNull());
1624
1625 ProcessStatus_T procStatus;
1626 HRESULT hr = pProcessEvent->COMGETTER(Status)(&procStatus);
1627 ComAssertComRC(hr);
1628 if (pProcessStatus)
1629 *pProcessStatus = procStatus;
1630
1631 ComPtr<IVirtualBoxErrorInfo> errorInfo;
1632 hr = pProcessEvent->COMGETTER(Error)(errorInfo.asOutParam());
1633 ComAssertComRC(hr);
1634
1635 LONG lGuestRc;
1636 hr = errorInfo->COMGETTER(ResultDetail)(&lGuestRc);
1637 ComAssertComRC(hr);
1638
1639 LogFlowThisFunc(("Got procStatus=%RU32, guestRc=%RI32 (%Rrc)\n",
1640 procStatus, lGuestRc, lGuestRc));
1641
1642 if (RT_FAILURE((int)lGuestRc))
1643 vrc = VERR_GSTCTL_GUEST_ERROR;
1644
1645 if (pGuestRc)
1646 *pGuestRc = (int)lGuestRc;
1647 }
1648
1649 LogFlowFuncLeaveRC(vrc);
1650 return vrc;
1651}
1652
1653/* static */
1654bool GuestProcess::i_waitResultImpliesEx(ProcessWaitResult_T waitResult,
1655 ProcessStatus_T procStatus, uint32_t uProcFlags,
1656 uint32_t uProtocol)
1657{
1658 /** @todo r=bird: If you subscribe to HN, which the 'u' in 'uProcFlags'
1659 * indicates, you should actually be using 'fProc'! */
1660 RT_NOREF(uProtocol, uProcFlags);
1661 bool fImplies;
1662
1663 switch (waitResult)
1664 {
1665 case ProcessWaitResult_Start:
1666 fImplies = procStatus == ProcessStatus_Started;
1667 break;
1668
1669 case ProcessWaitResult_Terminate:
1670 fImplies = ( procStatus == ProcessStatus_TerminatedNormally
1671 || procStatus == ProcessStatus_TerminatedSignal
1672 || procStatus == ProcessStatus_TerminatedAbnormally
1673 || procStatus == ProcessStatus_TimedOutKilled
1674 || procStatus == ProcessStatus_TimedOutAbnormally
1675 || procStatus == ProcessStatus_Down
1676 || procStatus == ProcessStatus_Error);
1677 break;
1678
1679 default:
1680 fImplies = false;
1681 break;
1682 }
1683
1684 return fImplies;
1685}
1686
1687int GuestProcess::i_writeData(uint32_t uHandle, uint32_t uFlags,
1688 void *pvData, size_t cbData, uint32_t uTimeoutMS, uint32_t *puWritten, int *pGuestRc)
1689{
1690 LogFlowThisFunc(("uPID=%RU32, uHandle=%RU32, uFlags=%RU32, pvData=%p, cbData=%RU32, uTimeoutMS=%RU32, puWritten=%p, pGuestRc=%p\n",
1691 mData.mPID, uHandle, uFlags, pvData, cbData, uTimeoutMS, puWritten, pGuestRc));
1692 /* All is optional. There can be 0 byte writes. */
1693 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1694
1695 if (mData.mStatus != ProcessStatus_Started)
1696 {
1697 if (puWritten)
1698 *puWritten = 0;
1699 if (pGuestRc)
1700 *pGuestRc = VINF_SUCCESS;
1701 return VINF_SUCCESS; /* Not available for writing (anymore). */
1702 }
1703
1704 int vrc;
1705
1706 GuestWaitEvent *pEvent = NULL;
1707 GuestEventTypes eventTypes;
1708 try
1709 {
1710 /*
1711 * On Guest Additions < 4.3 there is no guarantee that the process status
1712 * change arrives *after* the input event, e.g. if this was the last input
1713 * block being written and the process will report status "terminate".
1714 * So just skip checking for process status change and only wait for the
1715 * input event.
1716 */
1717 if (mSession->i_getProtocolVersion() >= 2)
1718 eventTypes.push_back(VBoxEventType_OnGuestProcessStateChanged);
1719 eventTypes.push_back(VBoxEventType_OnGuestProcessInputNotify);
1720
1721 vrc = registerWaitEvent(eventTypes, &pEvent);
1722 }
1723 catch (std::bad_alloc)
1724 {
1725 vrc = VERR_NO_MEMORY;
1726 }
1727
1728 if (RT_FAILURE(vrc))
1729 return vrc;
1730
1731 VBOXHGCMSVCPARM paParms[5];
1732 int i = 0;
1733 paParms[i++].setUInt32(pEvent->ContextID());
1734 paParms[i++].setUInt32(mData.mPID);
1735 paParms[i++].setUInt32(uFlags);
1736 paParms[i++].setPointer(pvData, (uint32_t)cbData);
1737 paParms[i++].setUInt32((uint32_t)cbData);
1738
1739 alock.release(); /* Drop the write lock before sending. */
1740
1741 uint32_t cbProcessed = 0;
1742 vrc = sendCommand(HOST_EXEC_SET_INPUT, i, paParms);
1743 if (RT_SUCCESS(vrc))
1744 {
1745 ProcessInputStatus_T inputStatus;
1746 vrc = i_waitForInputNotify(pEvent, uHandle, uTimeoutMS,
1747 &inputStatus, &cbProcessed);
1748 if (RT_SUCCESS(vrc))
1749 {
1750 /** @todo Set guestRc. */
1751
1752 if (puWritten)
1753 *puWritten = cbProcessed;
1754 }
1755 /** @todo Error handling. */
1756 }
1757
1758 unregisterWaitEvent(pEvent);
1759
1760 LogFlowThisFunc(("Returning cbProcessed=%RU32, rc=%Rrc\n",
1761 cbProcessed, vrc));
1762 return vrc;
1763}
1764
1765// implementation of public methods
1766/////////////////////////////////////////////////////////////////////////////
1767
1768HRESULT GuestProcess::read(ULONG aHandle, ULONG aToRead, ULONG aTimeoutMS, std::vector<BYTE> &aData)
1769{
1770 LogFlowThisFuncEnter();
1771
1772 if (aToRead == 0)
1773 return setError(E_INVALIDARG, tr("The size to read is zero"));
1774
1775 aData.resize(aToRead);
1776
1777 HRESULT hr = S_OK;
1778
1779 uint32_t cbRead; int guestRc;
1780 int vrc = i_readData(aHandle, aToRead, aTimeoutMS, &aData.front(), aToRead, &cbRead, &guestRc);
1781 if (RT_SUCCESS(vrc))
1782 {
1783 if (aData.size() != cbRead)
1784 aData.resize(cbRead);
1785 }
1786 else
1787 {
1788 aData.resize(0);
1789
1790 switch (vrc)
1791 {
1792 case VERR_GSTCTL_GUEST_ERROR:
1793 hr = GuestProcess::i_setErrorExternal(this, guestRc);
1794 break;
1795
1796 default:
1797 hr = setError(VBOX_E_IPRT_ERROR,
1798 tr("Reading from process \"%s\" (PID %RU32) failed: %Rrc"),
1799 mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1800 break;
1801 }
1802 }
1803
1804 LogFlowThisFunc(("rc=%Rrc, cbRead=%RU32\n", vrc, cbRead));
1805
1806 LogFlowFuncLeaveRC(vrc);
1807 return hr;
1808}
1809
1810HRESULT GuestProcess::terminate()
1811{
1812 HRESULT hr = S_OK;
1813
1814 int guestRc;
1815 int vrc = i_terminateProcess(30 * 1000 /* Timeout in ms */,
1816 &guestRc);
1817 if (RT_FAILURE(vrc))
1818 {
1819 switch (vrc)
1820 {
1821 case VERR_GSTCTL_GUEST_ERROR:
1822 hr = GuestProcess::i_setErrorExternal(this, guestRc);
1823 break;
1824
1825 case VERR_NOT_SUPPORTED:
1826 hr = setError(VBOX_E_IPRT_ERROR,
1827 tr("Terminating process \"%s\" (PID %RU32) not supported by installed Guest Additions"),
1828 mData.mProcess.mExecutable.c_str(), mData.mPID);
1829 break;
1830
1831 default:
1832 hr = setError(VBOX_E_IPRT_ERROR,
1833 tr("Terminating process \"%s\" (PID %RU32) failed: %Rrc"),
1834 mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1835 break;
1836 }
1837 }
1838
1839 /* Remove process from guest session list. Now only API clients
1840 * still can hold references to it. */
1841 AssertPtr(mSession);
1842 int rc2 = mSession->i_processRemoveFromList(this);
1843 if (RT_SUCCESS(vrc))
1844 vrc = rc2;
1845
1846 LogFlowFuncLeaveRC(vrc);
1847 return hr;
1848}
1849
1850HRESULT GuestProcess::waitFor(ULONG aWaitFor,
1851 ULONG aTimeoutMS,
1852 ProcessWaitResult_T *aReason)
1853{
1854 /*
1855 * Note: Do not hold any locks here while waiting!
1856 */
1857 HRESULT hr = S_OK;
1858
1859 int guestRc;
1860 ProcessWaitResult_T waitResult;
1861 int vrc = i_waitFor(aWaitFor, aTimeoutMS, waitResult, &guestRc);
1862 if (RT_SUCCESS(vrc))
1863 {
1864 *aReason = waitResult;
1865 }
1866 else
1867 {
1868 switch (vrc)
1869 {
1870 case VERR_GSTCTL_GUEST_ERROR:
1871 hr = GuestProcess::i_setErrorExternal(this, guestRc);
1872 break;
1873
1874 case VERR_TIMEOUT:
1875 *aReason = ProcessWaitResult_Timeout;
1876 break;
1877
1878 default:
1879 hr = setError(VBOX_E_IPRT_ERROR,
1880 tr("Waiting for process \"%s\" (PID %RU32) failed: %Rrc"),
1881 mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1882 break;
1883 }
1884 }
1885
1886 LogFlowFuncLeaveRC(vrc);
1887 return hr;
1888}
1889
1890HRESULT GuestProcess::waitForArray(const std::vector<ProcessWaitForFlag_T> &aWaitFor,
1891 ULONG aTimeoutMS, ProcessWaitResult_T *aReason)
1892{
1893 /*
1894 * Note: Do not hold any locks here while waiting!
1895 */
1896 uint32_t fWaitFor = ProcessWaitForFlag_None;
1897 for (size_t i = 0; i < aWaitFor.size(); i++)
1898 fWaitFor |= aWaitFor[i];
1899
1900 return WaitFor(fWaitFor, aTimeoutMS, aReason);
1901}
1902
1903HRESULT GuestProcess::write(ULONG aHandle, ULONG aFlags, const std::vector<BYTE> &aData,
1904 ULONG aTimeoutMS, ULONG *aWritten)
1905{
1906 LogFlowThisFuncEnter();
1907
1908 HRESULT hr = S_OK;
1909
1910 uint32_t cbWritten; int guestRc;
1911 uint32_t cbData = (uint32_t)aData.size();
1912 void *pvData = cbData > 0? (void *)&aData.front(): NULL;
1913 int vrc = i_writeData(aHandle, aFlags, pvData, cbData, aTimeoutMS, &cbWritten, &guestRc);
1914 if (RT_FAILURE(vrc))
1915 {
1916 switch (vrc)
1917 {
1918 case VERR_GSTCTL_GUEST_ERROR:
1919 hr = GuestProcess::i_setErrorExternal(this, guestRc);
1920 break;
1921
1922 default:
1923 hr = setError(VBOX_E_IPRT_ERROR,
1924 tr("Writing to process \"%s\" (PID %RU32) failed: %Rrc"),
1925 mData.mProcess.mExecutable.c_str(), mData.mPID, vrc);
1926 break;
1927 }
1928 }
1929
1930 LogFlowThisFunc(("rc=%Rrc, aWritten=%RU32\n", vrc, cbWritten));
1931
1932 *aWritten = (ULONG)cbWritten;
1933
1934 LogFlowFuncLeaveRC(vrc);
1935 return hr;
1936}
1937
1938HRESULT GuestProcess::writeArray(ULONG aHandle, const std::vector<ProcessInputFlag_T> &aFlags,
1939 const std::vector<BYTE> &aData, ULONG aTimeoutMS, ULONG *aWritten)
1940{
1941 LogFlowThisFuncEnter();
1942
1943 /*
1944 * Note: Do not hold any locks here while writing!
1945 */
1946 ULONG fWrite = ProcessInputFlag_None;
1947 for (size_t i = 0; i < aFlags.size(); i++)
1948 fWrite |= aFlags[i];
1949
1950 return write(aHandle, fWrite, aData, aTimeoutMS, aWritten);
1951}
1952
1953///////////////////////////////////////////////////////////////////////////////
1954
1955GuestProcessTool::GuestProcessTool(void)
1956 : pSession(NULL),
1957 pProcess(NULL)
1958{
1959}
1960
1961GuestProcessTool::~GuestProcessTool(void)
1962{
1963 i_terminate(30 * 1000, NULL /* pGuestRc */);
1964}
1965
1966int GuestProcessTool::Init(GuestSession *pGuestSession, const GuestProcessStartupInfo &startupInfo,
1967 bool fAsync, int *pGuestRc)
1968{
1969 LogFlowThisFunc(("pGuestSession=%p, exe=%s, fAsync=%RTbool\n",
1970 pGuestSession, startupInfo.mExecutable.c_str(), fAsync));
1971
1972 AssertPtrReturn(pGuestSession, VERR_INVALID_POINTER);
1973 Assert(startupInfo.mArguments[0] == startupInfo.mExecutable);
1974
1975 pSession = pGuestSession;
1976 mStartupInfo = startupInfo;
1977
1978 /* Make sure the process is hidden. */
1979 mStartupInfo.mFlags |= ProcessCreateFlag_Hidden;
1980
1981 int vrc = pSession->i_processCreateExInternal(mStartupInfo, pProcess);
1982 if (RT_SUCCESS(vrc))
1983 {
1984 int vrcGuest = VINF_SUCCESS;
1985 vrc = fAsync
1986 ? pProcess->i_startProcessAsync()
1987 : pProcess->i_startProcess(30 * 1000 /* 30s timeout */, &vrcGuest);
1988
1989 if ( RT_SUCCESS(vrc)
1990 && !fAsync
1991 && RT_FAILURE(vrcGuest)
1992 )
1993 {
1994 if (pGuestRc)
1995 *pGuestRc = vrcGuest;
1996 vrc = VERR_GSTCTL_GUEST_ERROR;
1997 }
1998 }
1999
2000 LogFlowFuncLeaveRC(vrc);
2001 return vrc;
2002}
2003
2004int GuestProcessTool::i_getCurrentBlock(uint32_t uHandle, GuestProcessStreamBlock &strmBlock)
2005{
2006 const GuestProcessStream *pStream = NULL;
2007 if (uHandle == OUTPUT_HANDLE_ID_STDOUT)
2008 pStream = &mStdOut;
2009 else if (uHandle == OUTPUT_HANDLE_ID_STDERR)
2010 pStream = &mStdErr;
2011
2012 if (!pStream)
2013 return VERR_INVALID_PARAMETER;
2014
2015 int vrc;
2016 do
2017 {
2018 /* Try parsing the data to see if the current block is complete. */
2019 vrc = mStdOut.ParseBlock(strmBlock);
2020 if (strmBlock.GetCount())
2021 break;
2022 } while (RT_SUCCESS(vrc));
2023
2024 LogFlowThisFunc(("rc=%Rrc, %RU64 pairs\n",
2025 vrc, strmBlock.GetCount()));
2026 return vrc;
2027}
2028
2029int GuestProcessTool::i_getRc(void) const
2030{
2031 LONG exitCode = -1;
2032 HRESULT hr = pProcess->COMGETTER(ExitCode(&exitCode));
2033 AssertComRC(hr);
2034
2035 return GuestProcessTool::i_exitCodeToRc(mStartupInfo, exitCode);
2036}
2037
2038bool GuestProcessTool::i_isRunning(void)
2039{
2040 AssertReturn(!pProcess.isNull(), false);
2041
2042 ProcessStatus_T procStatus = ProcessStatus_Undefined;
2043 HRESULT hr = pProcess->COMGETTER(Status(&procStatus));
2044 AssertComRC(hr);
2045
2046 if ( procStatus == ProcessStatus_Started
2047 || procStatus == ProcessStatus_Paused
2048 || procStatus == ProcessStatus_Terminating)
2049 {
2050 return true;
2051 }
2052
2053 return false;
2054}
2055
2056/* static */
2057int GuestProcessTool::i_run( GuestSession *pGuestSession,
2058 const GuestProcessStartupInfo &startupInfo,
2059 int *pGuestRc /* = NULL */)
2060{
2061 int guestRc;
2062
2063 GuestProcessToolErrorInfo errorInfo;
2064 int vrc = i_runErrorInfo(pGuestSession, startupInfo, errorInfo);
2065 if (RT_SUCCESS(vrc))
2066 {
2067 if (errorInfo.guestRc == VWRN_GSTCTL_PROCESS_EXIT_CODE)
2068 guestRc = GuestProcessTool::i_exitCodeToRc(startupInfo, errorInfo.iExitCode);
2069 else
2070 guestRc = errorInfo.guestRc;
2071
2072 if (pGuestRc)
2073 *pGuestRc = guestRc;
2074 }
2075
2076 return vrc;
2077}
2078
2079/**
2080 * Static helper function to start and wait for a certain toolbox tool.
2081 *
2082 * @return IPRT status code.
2083 * @param pGuestSession Guest control session to use for starting the toolbox tool in.
2084 * @param startupInfo Startup information about the toolbox tool.
2085 * @param errorInfo Error information returned for error handling.
2086 */
2087/* static */
2088int GuestProcessTool::i_runErrorInfo( GuestSession *pGuestSession,
2089 const GuestProcessStartupInfo &startupInfo,
2090 GuestProcessToolErrorInfo &errorInfo)
2091{
2092 return i_runExErrorInfo(pGuestSession, startupInfo,
2093 NULL /* paStrmOutObjects */, 0 /* cStrmOutObjects */,
2094 errorInfo);
2095}
2096
2097/**
2098 * Static helper function to start and wait for output of a certain toolbox tool.
2099 *
2100 * @return IPRT status code.
2101 * @param pGuestSession Guest control session to use for starting the toolbox tool in.
2102 * @param startupInfo Startup information about the toolbox tool.
2103 * @param paStrmOutObjects Pointer to stream objects array to use for retrieving the output of the toolbox tool.
2104 * Optional.
2105 * @param cStrmOutObjects Number of stream objects passed in. Optional.
2106 * @param pGuestRc Error code returned from the guest side if VERR_GSTCTL_GUEST_ERROR is returned. Optional.
2107 */
2108/* static */
2109int GuestProcessTool::i_runEx( GuestSession *pGuestSession,
2110 const GuestProcessStartupInfo &startupInfo,
2111 GuestCtrlStreamObjects *paStrmOutObjects,
2112 uint32_t cStrmOutObjects,
2113 int *pGuestRc /* = NULL */)
2114{
2115 int guestRc;
2116
2117 GuestProcessToolErrorInfo errorInfo;
2118 int vrc = GuestProcessTool::i_runExErrorInfo(pGuestSession, startupInfo, paStrmOutObjects, cStrmOutObjects, errorInfo);
2119 if (RT_SUCCESS(vrc))
2120 {
2121 if (errorInfo.guestRc == VWRN_GSTCTL_PROCESS_EXIT_CODE)
2122 guestRc = GuestProcessTool::i_exitCodeToRc(startupInfo, errorInfo.iExitCode);
2123 else
2124 guestRc = errorInfo.guestRc;
2125
2126 /* Return VERR_GSTCTL_GUEST_ERROR if we retrieved a guest return code. */
2127 if (RT_FAILURE(guestRc))
2128 vrc = VERR_GSTCTL_GUEST_ERROR;
2129
2130 if (pGuestRc)
2131 *pGuestRc = guestRc;
2132 }
2133
2134 return vrc;
2135}
2136
2137/**
2138 * Static helper function to start and wait for output of a certain toolbox tool.
2139 *
2140 * This is the extended version, which addds the possibility of retrieving parsable so-called guest stream
2141 * objects. Those objects are issued on the guest side as part of VBoxService's toolbox tools (think of a BusyBox-like approach)
2142 * on stdout and can be used on the host side to retrieve more information about the actual command issued on the guest side.
2143 *
2144 * @return IPRT status code.
2145 * @param pGuestSession Guest control session to use for starting the toolbox tool in.
2146 * @param startupInfo Startup information about the toolbox tool.
2147 * @param paStrmOutObjects Pointer to stream objects array to use for retrieving the output of the toolbox tool.
2148 * Optional.
2149 * @param cStrmOutObjects Number of stream objects passed in. Optional.
2150 * @param errorInfo Error information returned for error handling.
2151 */
2152/* static */
2153int GuestProcessTool::i_runExErrorInfo( GuestSession *pGuestSession,
2154 const GuestProcessStartupInfo &startupInfo,
2155 GuestCtrlStreamObjects *paStrmOutObjects,
2156 uint32_t cStrmOutObjects,
2157 GuestProcessToolErrorInfo &errorInfo)
2158{
2159 AssertPtrReturn(pGuestSession, VERR_INVALID_POINTER);
2160 /* paStrmOutObjects is optional. */
2161
2162 /** @todo Check if this is a valid toolbox. */
2163
2164 GuestProcessTool procTool;
2165 int vrc = procTool.Init(pGuestSession, startupInfo, false /* Async */, &errorInfo.guestRc);
2166 if (RT_SUCCESS(vrc))
2167 {
2168 while (cStrmOutObjects--)
2169 {
2170 try
2171 {
2172 GuestProcessStreamBlock strmBlk;
2173 vrc = procTool.i_waitEx( paStrmOutObjects
2174 ? GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK
2175 : GUESTPROCESSTOOL_FLAG_NONE, &strmBlk, &errorInfo.guestRc);
2176 if (paStrmOutObjects)
2177 paStrmOutObjects->push_back(strmBlk);
2178 }
2179 catch (std::bad_alloc)
2180 {
2181 vrc = VERR_NO_MEMORY;
2182 }
2183 }
2184 }
2185
2186 if (RT_SUCCESS(vrc))
2187 {
2188 /* Make sure the process runs until completion. */
2189 vrc = procTool.i_wait(GUESTPROCESSTOOL_FLAG_NONE, &errorInfo.guestRc);
2190 if (RT_SUCCESS(vrc))
2191 errorInfo.guestRc = procTool.i_terminatedOk(&errorInfo.iExitCode);
2192 }
2193
2194 LogFlowFunc(("Returned rc=%Rrc, guestRc=%Rrc, iExitCode=%d\n", vrc, errorInfo.guestRc, errorInfo.iExitCode));
2195 return vrc;
2196}
2197
2198/**
2199 * Reports if the tool has been run correctly.
2200 *
2201 * @return Will return VWRN_GSTCTL_PROCESS_EXIT_CODE if the tool process returned an exit code <> 0,
2202 * VERR_GSTCTL_PROCESS_WRONG_STATE if the tool process is in a wrong state (e.g. still running),
2203 * or VINF_SUCCESS otherwise.
2204 *
2205 * @param piExitCode Exit code of the tool. Optional.
2206 */
2207int GuestProcessTool::i_terminatedOk(int32_t *piExitCode /* = NULL */)
2208{
2209 Assert(!pProcess.isNull());
2210 /* pExitCode is optional. */
2211
2212 int vrc;
2213 if (!i_isRunning())
2214 {
2215 LONG iExitCode = -1;
2216 HRESULT hr = pProcess->COMGETTER(ExitCode(&iExitCode));
2217 AssertComRC(hr);
2218
2219 if (piExitCode)
2220 *piExitCode = iExitCode;
2221
2222 vrc = iExitCode != 0 ? VWRN_GSTCTL_PROCESS_EXIT_CODE : VINF_SUCCESS;
2223 }
2224 else
2225 vrc = VERR_GSTCTL_PROCESS_WRONG_STATE;
2226
2227 LogFlowFuncLeaveRC(vrc);
2228 return vrc;
2229}
2230
2231int GuestProcessTool::i_wait(uint32_t fFlags, int *pGuestRc)
2232{
2233 return i_waitEx(fFlags, NULL /* pStrmBlkOut */, pGuestRc);
2234}
2235
2236int GuestProcessTool::i_waitEx(uint32_t fFlags, GuestProcessStreamBlock *pStrmBlkOut, int *pGuestRc)
2237{
2238 LogFlowThisFunc(("fFlags=0x%x, pStreamBlock=%p, pGuestRc=%p\n", fFlags, pStrmBlkOut, pGuestRc));
2239
2240 /* Can we parse the next block without waiting? */
2241 int vrc;
2242 if (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK)
2243 {
2244 AssertPtr(pStrmBlkOut);
2245 vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
2246 if (RT_SUCCESS(vrc))
2247 return vrc;
2248 /* else do the waiting below. */
2249 }
2250
2251 /* Do the waiting. */
2252 uint32_t fWaitFlags = ProcessWaitForFlag_Terminate;
2253 if (mStartupInfo.mFlags & ProcessCreateFlag_WaitForStdOut)
2254 fWaitFlags |= ProcessWaitForFlag_StdOut;
2255 if (mStartupInfo.mFlags & ProcessCreateFlag_WaitForStdErr)
2256 fWaitFlags |= ProcessWaitForFlag_StdErr;
2257
2258 /** @todo Decrease timeout while running. */
2259 uint64_t u64StartMS = RTTimeMilliTS();
2260 uint32_t uTimeoutMS = mStartupInfo.mTimeoutMS;
2261
2262 int vrcGuest = VINF_SUCCESS;
2263 bool fDone = false;
2264
2265 BYTE byBuf[_64K];
2266 uint32_t cbRead;
2267
2268 bool fHandleStdOut = false;
2269 bool fHandleStdErr = false;
2270
2271 /**
2272 * Updates the elapsed time and checks if a
2273 * timeout happened, then breaking out of the loop.
2274 */
2275#define UPDATE_AND_CHECK_ELAPSED_TIME() \
2276 u64ElapsedMS = RTTimeMilliTS() - u64StartMS; \
2277 if ( uTimeoutMS != RT_INDEFINITE_WAIT \
2278 && u64ElapsedMS >= uTimeoutMS) \
2279 { \
2280 vrc = VERR_TIMEOUT; \
2281 break; \
2282 }
2283
2284 /**
2285 * Returns the remaining time (in ms).
2286 */
2287#define GET_REMAINING_TIME \
2288 uTimeoutMS == RT_INDEFINITE_WAIT \
2289 ? RT_INDEFINITE_WAIT : uTimeoutMS - (uint32_t)u64ElapsedMS \
2290
2291 ProcessWaitResult_T waitRes = ProcessWaitResult_None;
2292 do
2293 {
2294 uint64_t u64ElapsedMS;
2295 UPDATE_AND_CHECK_ELAPSED_TIME();
2296
2297 vrc = pProcess->i_waitFor(fWaitFlags, GET_REMAINING_TIME,
2298 waitRes, &vrcGuest);
2299 if (RT_FAILURE(vrc))
2300 break;
2301
2302 switch (waitRes)
2303 {
2304 case ProcessWaitResult_StdIn:
2305 vrc = VERR_NOT_IMPLEMENTED;
2306 break;
2307
2308 case ProcessWaitResult_StdOut:
2309 fHandleStdOut = true;
2310 break;
2311
2312 case ProcessWaitResult_StdErr:
2313 fHandleStdErr = true;
2314 break;
2315
2316 case ProcessWaitResult_WaitFlagNotSupported:
2317 if (fWaitFlags & ProcessWaitForFlag_StdOut)
2318 fHandleStdOut = true;
2319 if (fWaitFlags & ProcessWaitForFlag_StdErr)
2320 fHandleStdErr = true;
2321 /* Since waiting for stdout / stderr is not supported by the guest,
2322 * wait a bit to not hog the CPU too much when polling for data. */
2323 RTThreadSleep(1); /* Optional, don't check rc. */
2324 break;
2325
2326 case ProcessWaitResult_Error:
2327 vrc = VERR_GSTCTL_GUEST_ERROR;
2328 break;
2329
2330 case ProcessWaitResult_Terminate:
2331 fDone = true;
2332 break;
2333
2334 case ProcessWaitResult_Timeout:
2335 vrc = VERR_TIMEOUT;
2336 break;
2337
2338 case ProcessWaitResult_Start:
2339 case ProcessWaitResult_Status:
2340 /* Not used here, just skip. */
2341 break;
2342
2343 default:
2344 AssertMsgFailed(("Unhandled process wait result %RU32\n", waitRes));
2345 break;
2346 }
2347
2348 if (RT_FAILURE(vrc))
2349 break;
2350
2351 if (fHandleStdOut)
2352 {
2353 UPDATE_AND_CHECK_ELAPSED_TIME();
2354
2355 cbRead = 0;
2356 vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDOUT, sizeof(byBuf),
2357 GET_REMAINING_TIME,
2358 byBuf, sizeof(byBuf),
2359 &cbRead, &vrcGuest);
2360 if ( RT_FAILURE(vrc)
2361 || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
2362 break;
2363
2364 if (cbRead)
2365 {
2366 LogFlowThisFunc(("Received %RU32 bytes from stdout\n", cbRead));
2367 vrc = mStdOut.AddData(byBuf, cbRead);
2368
2369 if ( RT_SUCCESS(vrc)
2370 && (fFlags & GUESTPROCESSTOOL_FLAG_STDOUT_BLOCK))
2371 {
2372 AssertPtr(pStrmBlkOut);
2373 vrc = i_getCurrentBlock(OUTPUT_HANDLE_ID_STDOUT, *pStrmBlkOut);
2374
2375 /* When successful, break out of the loop because we're done
2376 * with reading the first stream block. */
2377 if (RT_SUCCESS(vrc))
2378 fDone = true;
2379 }
2380 }
2381
2382 fHandleStdOut = false;
2383 }
2384
2385 if (fHandleStdErr)
2386 {
2387 UPDATE_AND_CHECK_ELAPSED_TIME();
2388
2389 cbRead = 0;
2390 vrc = pProcess->i_readData(OUTPUT_HANDLE_ID_STDERR, sizeof(byBuf),
2391 GET_REMAINING_TIME,
2392 byBuf, sizeof(byBuf),
2393 &cbRead, &vrcGuest);
2394 if ( RT_FAILURE(vrc)
2395 || vrc == VWRN_GSTCTL_OBJECTSTATE_CHANGED)
2396 break;
2397
2398 if (cbRead)
2399 {
2400 LogFlowThisFunc(("Received %RU32 bytes from stderr\n", cbRead));
2401 vrc = mStdErr.AddData(byBuf, cbRead);
2402 }
2403
2404 fHandleStdErr = false;
2405 }
2406
2407 } while (!fDone && RT_SUCCESS(vrc));
2408
2409#undef UPDATE_AND_CHECK_ELAPSED_TIME
2410#undef GET_REMAINING_TIME
2411
2412 if (RT_FAILURE(vrcGuest))
2413 vrc = VERR_GSTCTL_GUEST_ERROR;
2414
2415 LogFlowThisFunc(("Loop ended with rc=%Rrc, vrcGuest=%Rrc, waitRes=%RU32\n",
2416 vrc, vrcGuest, waitRes));
2417 if (pGuestRc)
2418 *pGuestRc = vrcGuest;
2419
2420 LogFlowFuncLeaveRC(vrc);
2421 return vrc;
2422}
2423
2424int GuestProcessTool::i_terminate(uint32_t uTimeoutMS, int *pGuestRc)
2425{
2426 LogFlowThisFuncEnter();
2427
2428 int rc = VINF_SUCCESS;
2429 if (!pProcess.isNull())
2430 {
2431 rc = pProcess->i_terminateProcess(uTimeoutMS, pGuestRc);
2432 pProcess.setNull();
2433 }
2434 else
2435 rc = VERR_NOT_FOUND;
2436
2437 LogFlowFuncLeaveRC(rc);
2438 return rc;
2439}
2440
2441/**
2442 * Converts a toolbox tool's exit code to an IPRT error code.
2443 *
2444 * @return int Returned IPRT error for the particular tool.
2445 * @param startupInfo Startup info of the toolbox tool to lookup error code for.
2446 * @param iExitCode The toolbox tool's exit code to lookup IPRT error for.
2447 */
2448/* static */
2449int GuestProcessTool::i_exitCodeToRc(const GuestProcessStartupInfo &startupInfo, int32_t iExitCode)
2450{
2451 if (startupInfo.mArguments.size() == 0)
2452 {
2453 AssertFailed();
2454 return VERR_GENERAL_FAILURE; /* Should not happen. */
2455 }
2456
2457 return i_exitCodeToRc(startupInfo.mArguments[0].c_str(), iExitCode);
2458}
2459
2460/**
2461 * Converts a toolbox tool's exit code to an IPRT error code.
2462 *
2463 * @return Returned IPRT error for the particular tool.
2464 * @param pszTool Name of toolbox tool to lookup error code for.
2465 * @param iExitCode The toolbox tool's exit code to lookup IPRT error for.
2466 */
2467/* static */
2468int GuestProcessTool::i_exitCodeToRc(const char *pszTool, int32_t iExitCode)
2469{
2470 AssertPtrReturn(pszTool, VERR_INVALID_POINTER);
2471
2472 LogFlowFunc(("%s: %d\n", pszTool, iExitCode));
2473
2474 if (iExitCode == 0) /* No error? Bail out early. */
2475 return VINF_SUCCESS;
2476
2477 if (!RTStrICmp(pszTool, VBOXSERVICE_TOOL_CAT))
2478 {
2479 switch (iExitCode)
2480 {
2481 case VBOXSERVICETOOLBOX_CAT_EXITCODE_ACCESS_DENIED: return VERR_ACCESS_DENIED;
2482 case VBOXSERVICETOOLBOX_CAT_EXITCODE_FILE_NOT_FOUND: return VERR_FILE_NOT_FOUND;
2483 case VBOXSERVICETOOLBOX_CAT_EXITCODE_PATH_NOT_FOUND: return VERR_PATH_NOT_FOUND;
2484 case VBOXSERVICETOOLBOX_CAT_EXITCODE_SHARING_VIOLATION: return VERR_SHARING_VIOLATION;
2485 default:
2486 break;
2487 }
2488 }
2489 else if (!RTStrICmp(pszTool, VBOXSERVICE_TOOL_STAT))
2490 {
2491 switch (iExitCode)
2492 {
2493 case VBOXSERVICETOOLBOX_STAT_EXITCODE_ACCESS_DENIED: return VERR_ACCESS_DENIED;
2494 case VBOXSERVICETOOLBOX_STAT_EXITCODE_FILE_NOT_FOUND: return VERR_FILE_NOT_FOUND;
2495 case VBOXSERVICETOOLBOX_STAT_EXITCODE_PATH_NOT_FOUND: return VERR_PATH_NOT_FOUND;
2496 default:
2497 break;
2498 }
2499 }
2500 else if (!RTStrICmp(pszTool, VBOXSERVICE_TOOL_MKDIR))
2501 {
2502 switch (iExitCode)
2503 {
2504 case RTEXITCODE_FAILURE: return VERR_CANT_CREATE;
2505 }
2506 }
2507
2508#ifdef DEBUG_andy
2509 AssertMsgFailed(("Exit code %d for tool '%s' not handled\n", iExitCode, pszTool));
2510#endif
2511 if (iExitCode == RTEXITCODE_SYNTAX)
2512 return VERR_INTERNAL_ERROR_5;
2513 return VERR_GENERAL_FAILURE;
2514}
2515
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use