VirtualBox

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

Last change on this file since 66629 was 65120, checked in by vboxsync, 8 years ago

Main: doxygen fixes

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

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