VirtualBox

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

Last change on this file since 73768 was 73505, checked in by vboxsync, 6 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use