VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/SessionImpl.cpp@ 78126

Last change on this file since 78126 was 77910, checked in by vboxsync, 6 years ago

Main: bugref:7929: Added ability to change the priority of the VM process
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 38.6 KB
Line 
1/* $Id: SessionImpl.cpp 77910 2019-03-27 11:33:01Z vboxsync $ */
2/** @file
3 * VBox Client Session COM Class implementation in VBoxC.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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#define LOG_GROUP LOG_GROUP_MAIN_SESSION
19#include "LoggingNew.h"
20
21#include "SessionImpl.h"
22#include "ConsoleImpl.h"
23#include "Global.h"
24#include "ClientTokenHolder.h"
25
26#include "AutoCaller.h"
27
28#include <iprt/errcore.h>
29#include <iprt/process.h>
30
31
32/**
33 * Local macro to check whether the session is open and return an error if not.
34 * @note Don't forget to do |Auto[Reader]Lock alock (this);| before using this
35 * macro.
36 */
37#define CHECK_OPEN() \
38 do { \
39 if (mState != SessionState_Locked) \
40 return setError(E_UNEXPECTED, tr ("The session is not locked (session state: %s)"), \
41 Global::stringifySessionState(mState)); \
42 } while (0)
43
44// constructor / destructor
45/////////////////////////////////////////////////////////////////////////////
46
47Session::Session()
48{
49}
50
51Session::~Session()
52{
53}
54
55HRESULT Session::FinalConstruct()
56{
57 LogFlowThisFunc(("\n"));
58
59 HRESULT rc = init();
60
61 BaseFinalConstruct();
62
63 return rc;
64}
65
66void Session::FinalRelease()
67{
68 LogFlowThisFunc(("\n"));
69
70 uninit();
71
72 BaseFinalRelease();
73}
74
75// public initializer/uninitializer for internal purposes only
76/////////////////////////////////////////////////////////////////////////////
77
78/**
79 * Initializes the Session object.
80 */
81HRESULT Session::init()
82{
83 /* Enclose the state transition NotReady->InInit->Ready */
84 AutoInitSpan autoInitSpan(this);
85 AssertReturn(autoInitSpan.isOk(), E_FAIL);
86
87 LogFlowThisFuncEnter();
88
89 mState = SessionState_Unlocked;
90 mType = SessionType_Null;
91
92 mClientTokenHolder = NULL;
93
94 /* Confirm a successful initialization when it's the case */
95 autoInitSpan.setSucceeded();
96
97 LogFlowThisFuncLeave();
98
99 return S_OK;
100}
101
102/**
103 * Uninitializes the Session object.
104 *
105 * @note Locks this object for writing.
106 */
107void Session::uninit()
108{
109 LogFlowThisFuncEnter();
110
111 /* Enclose the state transition Ready->InUninit->NotReady */
112 AutoUninitSpan autoUninitSpan(this);
113 if (autoUninitSpan.uninitDone())
114 {
115 LogFlowThisFunc(("Already uninitialized.\n"));
116 LogFlowThisFuncLeave();
117 return;
118 }
119
120 /* close() needs write lock */
121 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
122
123 if (mState != SessionState_Unlocked)
124 {
125 Assert(mState == SessionState_Locked ||
126 mState == SessionState_Spawning);
127
128 HRESULT rc = i_unlockMachine(true /* aFinalRelease */, false /* aFromServer */, alock);
129 AssertComRC(rc);
130 }
131
132 LogFlowThisFuncLeave();
133}
134
135// ISession properties
136/////////////////////////////////////////////////////////////////////////////
137
138HRESULT Session::getState(SessionState_T *aState)
139{
140 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
141
142 *aState = mState;
143
144 return S_OK;
145}
146
147HRESULT Session::getType(SessionType_T *aType)
148{
149 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
150
151 CHECK_OPEN();
152
153 *aType = mType;
154 return S_OK;
155}
156
157HRESULT Session::getName(com::Utf8Str &aName)
158{
159 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
160
161 aName = mName;
162 return S_OK;
163}
164
165HRESULT Session::setName(const com::Utf8Str &aName)
166{
167 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
168
169 if (mState != SessionState_Unlocked)
170 return setError(VBOX_E_INVALID_OBJECT_STATE, tr("Trying to set name for a session which is not in state \"unlocked\""));
171
172 mName = aName;
173 return S_OK;
174}
175
176HRESULT Session::getMachine(ComPtr<IMachine> &aMachine)
177{
178 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
179
180 CHECK_OPEN();
181
182 HRESULT rc;
183#ifndef VBOX_COM_INPROC_API_CLIENT
184 if (mConsole)
185 rc = mConsole->i_machine().queryInterfaceTo(aMachine.asOutParam());
186 else
187#endif
188 rc = mRemoteMachine.queryInterfaceTo(aMachine.asOutParam());
189 if (FAILED(rc))
190 {
191#ifndef VBOX_COM_INPROC_API_CLIENT
192 if (mConsole)
193 setError(rc, tr("Failed to query the session machine"));
194 else
195#endif
196 if (FAILED_DEAD_INTERFACE(rc))
197 setError(rc, tr("Peer process crashed"));
198 else
199 setError(rc, tr("Failed to query the remote session machine"));
200 }
201
202 return rc;
203}
204
205HRESULT Session::getConsole(ComPtr<IConsole> &aConsole)
206{
207 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
208
209 CHECK_OPEN();
210
211 HRESULT rc = S_OK;
212#ifndef VBOX_COM_INPROC_API_CLIENT
213 if (mConsole)
214 rc = mConsole.queryInterfaceTo(aConsole.asOutParam());
215 else
216#endif
217 rc = mRemoteConsole.queryInterfaceTo(aConsole.asOutParam());
218
219 if (FAILED(rc))
220 {
221#ifndef VBOX_COM_INPROC_API_CLIENT
222 if (mConsole)
223 setError(rc, tr("Failed to query the console"));
224 else
225#endif
226 if (FAILED_DEAD_INTERFACE(rc))
227 setError(rc, tr("Peer process crashed"));
228 else
229 setError(rc, tr("Failed to query the remote console"));
230 }
231
232 return rc;
233}
234
235// ISession methods
236/////////////////////////////////////////////////////////////////////////////
237HRESULT Session::unlockMachine()
238{
239 LogFlowThisFunc(("mState=%d, mType=%d\n", mState, mType));
240
241 /* close() needs write lock */
242 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
243
244 CHECK_OPEN();
245 return i_unlockMachine(false /* aFinalRelease */, false /* aFromServer */, alock);
246}
247
248// IInternalSessionControl methods
249/////////////////////////////////////////////////////////////////////////////
250HRESULT Session::getPID(ULONG *aPid)
251{
252 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
253
254 *aPid = (ULONG)RTProcSelf();
255 AssertCompile(sizeof(*aPid) == sizeof(RTPROCESS));
256
257 return S_OK;
258}
259
260HRESULT Session::getRemoteConsole(ComPtr<IConsole> &aConsole)
261{
262 LogFlowThisFuncEnter();
263
264 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
265
266#ifndef VBOX_COM_INPROC_API_CLIENT
267 AssertMsgReturn(mType == SessionType_WriteLock && !!mConsole,
268 ("This is not a direct session!\n"),
269 VBOX_E_INVALID_OBJECT_STATE);
270
271 /* return a failure if the session already transitioned to Closing
272 * but the server hasn't processed Machine::OnSessionEnd() yet. */
273 if (mState != SessionState_Locked)
274 return VBOX_E_INVALID_VM_STATE;
275
276 mConsole.queryInterfaceTo(aConsole.asOutParam());
277
278 LogFlowThisFuncLeave();
279
280 return S_OK;
281
282#else /* VBOX_COM_INPROC_API_CLIENT */
283 RT_NOREF(aConsole);
284 AssertFailed();
285 return VBOX_E_INVALID_OBJECT_STATE;
286#endif /* VBOX_COM_INPROC_API_CLIENT */
287}
288
289HRESULT Session::getNominalState(MachineState_T *aNominalState)
290{
291 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
292 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
293 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
294#ifndef VBOX_COM_INPROC_API_CLIENT
295 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
296
297 return mConsole->i_getNominalState(*aNominalState);
298#else
299 RT_NOREF(aNominalState);
300 AssertFailed();
301 return E_NOTIMPL;
302#endif
303}
304
305#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
306HRESULT Session::assignMachine(const ComPtr<IMachine> &aMachine,
307 LockType_T aLockType,
308 const com::Utf8Str &aTokenId)
309#else
310HRESULT Session::assignMachine(const ComPtr<IMachine> &aMachine,
311 LockType_T aLockType,
312 const ComPtr<IToken> &aToken)
313#endif /* !VBOX_WITH_GENERIC_SESSION_WATCHER */
314{
315 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
316
317 AssertReturn(mState == SessionState_Unlocked, VBOX_E_INVALID_VM_STATE);
318
319 if (!aMachine)
320 {
321 /*
322 * A special case: the server informs us that this session has been
323 * passed to IMachine::launchVMProcess() so this session will become
324 * remote (but not existing) when AssignRemoteMachine() is called.
325 */
326
327 AssertReturn(mType == SessionType_Null, VBOX_E_INVALID_OBJECT_STATE);
328 mType = SessionType_Remote;
329 mState = SessionState_Spawning;
330
331 return S_OK;
332 }
333
334 /* query IInternalMachineControl interface */
335 mControl = aMachine;
336 AssertReturn(!!mControl, E_FAIL);
337
338 HRESULT rc = S_OK;
339#ifndef VBOX_COM_INPROC_API_CLIENT
340 if (aLockType == LockType_VM)
341 {
342 /* This is what is special about VM processes: they have a Console
343 * object which is the root of all VM related activity. */
344 rc = mConsole.createObject();
345 AssertComRCReturn(rc, rc);
346
347 rc = mConsole->init(aMachine, mControl, aLockType);
348 AssertComRCReturn(rc, rc);
349 }
350 else
351 mRemoteMachine = aMachine;
352#else
353 RT_NOREF(aLockType);
354 mRemoteMachine = aMachine;
355#endif
356
357#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
358 Utf8Str strTokenId(aTokenId);
359 Assert(!strTokenId.isEmpty());
360#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
361 Assert(!aToken.isNull());
362#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
363 /* create the machine client token */
364 try
365 {
366#ifndef VBOX_WITH_GENERIC_SESSION_WATCHER
367 mClientTokenHolder = new ClientTokenHolder(strTokenId);
368#else /* VBOX_WITH_GENERIC_SESSION_WATCHER */
369 mClientTokenHolder = new ClientTokenHolder(aToken);
370#endif /* VBOX_WITH_GENERIC_SESSION_WATCHER */
371 if (!mClientTokenHolder->isReady())
372 {
373 delete mClientTokenHolder;
374 mClientTokenHolder = NULL;
375 rc = E_FAIL;
376 }
377 }
378 catch (std::bad_alloc &)
379 {
380 rc = E_OUTOFMEMORY;
381 }
382
383 /*
384 * Reference the VirtualBox object to ensure the server is up
385 * until the session is closed
386 */
387 if (SUCCEEDED(rc))
388 rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
389
390 if (SUCCEEDED(rc))
391 {
392 mType = SessionType_WriteLock;
393 mState = SessionState_Locked;
394 }
395 else
396 {
397 /* some cleanup */
398 mControl.setNull();
399#ifndef VBOX_COM_INPROC_API_CLIENT
400 if (!mConsole.isNull())
401 {
402 mConsole->uninit();
403 mConsole.setNull();
404 }
405#endif
406 }
407
408 return rc;
409}
410
411HRESULT Session::assignRemoteMachine(const ComPtr<IMachine> &aMachine,
412 const ComPtr<IConsole> &aConsole)
413
414{
415 AssertReturn(aMachine, E_INVALIDARG);
416
417 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
418
419 AssertReturn(mState == SessionState_Unlocked ||
420 mState == SessionState_Spawning, VBOX_E_INVALID_VM_STATE);
421
422 HRESULT rc = E_FAIL;
423
424 /* query IInternalMachineControl interface */
425 mControl = aMachine;
426 AssertReturn(!!mControl, E_FAIL);
427
428 /// @todo (dmik)
429 // currently, the remote session returns the same machine and
430 // console objects as the direct session, thus giving the
431 // (remote) client full control over the direct session. For the
432 // console, it is the desired behavior (the ability to control
433 // VM execution is a must for the remote session). What about
434 // the machine object, we may want to prevent the remote client
435 // from modifying machine data. In this case, we must:
436 // 1) assign the Machine object (instead of the SessionMachine
437 // object that is passed to this method) to mRemoteMachine;
438 // 2) remove GetMachine() property from the IConsole interface
439 // because it always returns the SessionMachine object
440 // (alternatively, we can supply a separate IConsole
441 // implementation that will return the Machine object in
442 // response to GetMachine()).
443
444 mRemoteMachine = aMachine;
445 mRemoteConsole = aConsole;
446
447 /*
448 * Reference the VirtualBox object to ensure the server is up
449 * until the session is closed
450 */
451 rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
452
453 if (SUCCEEDED(rc))
454 {
455 /*
456 * RemoteSession type can be already set by AssignMachine() when its
457 * argument is NULL (a special case)
458 */
459 if (mType != SessionType_Remote)
460 mType = SessionType_Shared;
461 else
462 Assert(mState == SessionState_Spawning);
463
464 mState = SessionState_Locked;
465 }
466 else
467 {
468 /* some cleanup */
469 mControl.setNull();
470 mRemoteMachine.setNull();
471 mRemoteConsole.setNull();
472 }
473
474 LogFlowThisFunc(("rc=%08X\n", rc));
475 LogFlowThisFuncLeave();
476
477 return rc;
478}
479
480HRESULT Session::updateMachineState(MachineState_T aMachineState)
481{
482
483 if (getObjectState().getState() != ObjectState::Ready)
484 {
485 /*
486 * We might have already entered Session::uninit() at this point, so
487 * return silently (not interested in the state change during uninit)
488 */
489 LogFlowThisFunc(("Already uninitialized.\n"));
490 return S_OK;
491 }
492
493 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
494
495 if (mState == SessionState_Unlocking)
496 {
497 LogFlowThisFunc(("Already being unlocked.\n"));
498 return S_OK;
499 }
500
501 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
502 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
503
504 AssertReturn(!mControl.isNull(), E_FAIL);
505#ifndef VBOX_COM_INPROC_API_CLIENT
506 AssertReturn(!mConsole.isNull(), E_FAIL);
507
508 return mConsole->i_updateMachineState(aMachineState);
509#else
510 RT_NOREF(aMachineState);
511 return S_OK;
512#endif
513}
514
515HRESULT Session::uninitialize()
516{
517 LogFlowThisFuncEnter();
518
519 AutoCaller autoCaller(this);
520
521 HRESULT rc = S_OK;
522
523 if (getObjectState().getState() == ObjectState::Ready)
524 {
525 /* close() needs write lock */
526 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
527
528 LogFlowThisFunc(("mState=%s, mType=%d\n", Global::stringifySessionState(mState), mType));
529
530 if (mState == SessionState_Unlocking)
531 {
532 LogFlowThisFunc(("Already being unlocked.\n"));
533 return S_OK;
534 }
535
536 if ( mState == SessionState_Locked
537 || mState == SessionState_Spawning)
538 { /* likely */ }
539 else
540 {
541#ifndef DEBUG_bird /* bird: hitting this all the time running tdAddBaseic1.py. */
542 AssertMsgFailed(("Session is in wrong state (%d), expected locked (%d) or spawning (%d)\n",
543 mState, SessionState_Locked, SessionState_Spawning));
544#endif
545 return VBOX_E_INVALID_VM_STATE;
546 }
547
548 /* close ourselves */
549 rc = i_unlockMachine(false /* aFinalRelease */, true /* aFromServer */, alock);
550 }
551 else if (getObjectState().getState() == ObjectState::InUninit)
552 {
553 /*
554 * We might have already entered Session::uninit() at this point,
555 * return silently
556 */
557 LogFlowThisFunc(("Already uninitialized.\n"));
558 }
559 else
560 {
561 Log1WarningThisFunc(("UNEXPECTED uninitialization!\n"));
562 rc = autoCaller.rc();
563 }
564
565 LogFlowThisFunc(("rc=%08X\n", rc));
566 LogFlowThisFuncLeave();
567
568 return rc;
569}
570
571HRESULT Session::onNetworkAdapterChange(const ComPtr<INetworkAdapter> &aNetworkAdapter,
572 BOOL aChangeAdapter)
573
574{
575 LogFlowThisFunc(("\n"));
576
577 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
578 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
579 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
580#ifndef VBOX_COM_INPROC_API_CLIENT
581 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
582
583 return mConsole->i_onNetworkAdapterChange(aNetworkAdapter, aChangeAdapter);
584#else
585 RT_NOREF(aNetworkAdapter, aChangeAdapter);
586 return S_OK;
587#endif
588}
589
590HRESULT Session::onAudioAdapterChange(const ComPtr<IAudioAdapter> &aAudioAdapter)
591{
592 LogFlowThisFunc(("\n"));
593
594 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
595 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
596 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
597#ifndef VBOX_COM_INPROC_API_CLIENT
598 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
599
600 return mConsole->i_onAudioAdapterChange(aAudioAdapter);
601#else
602 RT_NOREF(aAudioAdapter);
603 return S_OK;
604#endif
605
606}
607
608HRESULT Session::onSerialPortChange(const ComPtr<ISerialPort> &aSerialPort)
609{
610 LogFlowThisFunc(("\n"));
611
612 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
613 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
614 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
615#ifndef VBOX_COM_INPROC_API_CLIENT
616 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
617
618 return mConsole->i_onSerialPortChange(aSerialPort);
619#else
620 RT_NOREF(aSerialPort);
621 return S_OK;
622#endif
623}
624
625HRESULT Session::onParallelPortChange(const ComPtr<IParallelPort> &aParallelPort)
626{
627 LogFlowThisFunc(("\n"));
628
629 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
630 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
631 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
632#ifndef VBOX_COM_INPROC_API_CLIENT
633 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
634
635 return mConsole->i_onParallelPortChange(aParallelPort);
636#else
637 RT_NOREF(aParallelPort);
638 return S_OK;
639#endif
640}
641
642HRESULT Session::onStorageControllerChange()
643{
644 LogFlowThisFunc(("\n"));
645
646 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
647 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
648 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
649#ifndef VBOX_COM_INPROC_API_CLIENT
650 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
651
652 return mConsole->i_onStorageControllerChange();
653#else
654 return S_OK;
655#endif
656}
657
658HRESULT Session::onMediumChange(const ComPtr<IMediumAttachment> &aMediumAttachment,
659 BOOL aForce)
660{
661 LogFlowThisFunc(("\n"));
662
663 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
664 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
665 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
666#ifndef VBOX_COM_INPROC_API_CLIENT
667 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
668
669 return mConsole->i_onMediumChange(aMediumAttachment, aForce);
670#else
671 RT_NOREF(aMediumAttachment, aForce);
672 return S_OK;
673#endif
674}
675
676HRESULT Session::onVMProcessPriorityChange(VMProcPriority_T priority)
677{
678 LogFlowThisFunc(("\n"));
679
680 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
681 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
682 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
683#ifndef VBOX_COM_INPROC_API_CLIENT
684 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
685
686 return mConsole->i_onVMProcessPriorityChange(priority);
687#else
688 RT_NOREF(priority);
689 return S_OK;
690#endif
691}
692
693HRESULT Session::onCPUChange(ULONG aCpu, BOOL aAdd)
694{
695 LogFlowThisFunc(("\n"));
696
697 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
698 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
699 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
700#ifndef VBOX_COM_INPROC_API_CLIENT
701 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
702
703 return mConsole->i_onCPUChange(aCpu, aAdd);
704#else
705 RT_NOREF(aCpu, aAdd);
706 return S_OK;
707#endif
708}
709
710HRESULT Session::onCPUExecutionCapChange(ULONG aExecutionCap)
711{
712 LogFlowThisFunc(("\n"));
713
714 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
715 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
716 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
717#ifndef VBOX_COM_INPROC_API_CLIENT
718 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
719
720 return mConsole->i_onCPUExecutionCapChange(aExecutionCap);
721#else
722 RT_NOREF(aExecutionCap);
723 return S_OK;
724#endif
725}
726
727HRESULT Session::onVRDEServerChange(BOOL aRestart)
728{
729 LogFlowThisFunc(("\n"));
730
731 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
732 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
733 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
734#ifndef VBOX_COM_INPROC_API_CLIENT
735 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
736
737 return mConsole->i_onVRDEServerChange(aRestart);
738#else
739 RT_NOREF(aRestart);
740 return S_OK;
741#endif
742}
743
744HRESULT Session::onRecordingChange(BOOL aEnable)
745{
746 LogFlowThisFunc(("\n"));
747
748 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
749 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
750 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
751#ifndef VBOX_COM_INPROC_API_CLIENT
752 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
753
754 return mConsole->i_onRecordingChange(aEnable);
755#else
756 RT_NOREF(aEnable);
757 return S_OK;
758#endif
759}
760
761HRESULT Session::onUSBControllerChange()
762{
763 LogFlowThisFunc(("\n"));
764
765 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
766 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
767 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
768#ifndef VBOX_COM_INPROC_API_CLIENT
769 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
770
771 return mConsole->i_onUSBControllerChange();
772#else
773 return S_OK;
774#endif
775}
776
777HRESULT Session::onSharedFolderChange(BOOL aGlobal)
778{
779 LogFlowThisFunc(("\n"));
780
781 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
782 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
783 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
784#ifndef VBOX_COM_INPROC_API_CLIENT
785 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
786
787 return mConsole->i_onSharedFolderChange(aGlobal);
788#else
789 RT_NOREF(aGlobal);
790 return S_OK;
791#endif
792}
793
794HRESULT Session::onClipboardModeChange(ClipboardMode_T aClipboardMode)
795{
796 LogFlowThisFunc(("\n"));
797
798 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
799 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
800 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
801#ifndef VBOX_COM_INPROC_API_CLIENT
802 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
803
804 return mConsole->i_onClipboardModeChange(aClipboardMode);
805#else
806 RT_NOREF(aClipboardMode);
807 return S_OK;
808#endif
809}
810
811HRESULT Session::onDnDModeChange(DnDMode_T aDndMode)
812{
813 LogFlowThisFunc(("\n"));
814
815 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
816 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
817#ifndef VBOX_COM_INPROC_API_CLIENT
818 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
819 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
820
821 return mConsole->i_onDnDModeChange(aDndMode);
822#else
823 RT_NOREF(aDndMode);
824 return S_OK;
825#endif
826}
827
828HRESULT Session::onUSBDeviceAttach(const ComPtr<IUSBDevice> &aDevice,
829 const ComPtr<IVirtualBoxErrorInfo> &aError,
830 ULONG aMaskedInterfaces,
831 const com::Utf8Str &aCaptureFilename)
832{
833 LogFlowThisFunc(("\n"));
834
835 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
836 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
837 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
838#ifndef VBOX_COM_INPROC_API_CLIENT
839 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
840
841 return mConsole->i_onUSBDeviceAttach(aDevice, aError, aMaskedInterfaces, aCaptureFilename);
842#else
843 RT_NOREF(aDevice, aError, aMaskedInterfaces, aCaptureFilename);
844 return S_OK;
845#endif
846}
847
848HRESULT Session::onUSBDeviceDetach(const com::Guid &aId,
849 const ComPtr<IVirtualBoxErrorInfo> &aError)
850{
851 LogFlowThisFunc(("\n"));
852
853 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
854 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
855 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
856#ifndef VBOX_COM_INPROC_API_CLIENT
857 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
858
859 return mConsole->i_onUSBDeviceDetach(aId.toUtf16().raw(), aError);
860#else
861 RT_NOREF(aId, aError);
862 return S_OK;
863#endif
864}
865
866HRESULT Session::onShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId)
867{
868 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
869
870 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
871#ifndef VBOX_COM_INPROC_API_CLIENT
872 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
873#endif
874
875 if (mState != SessionState_Locked)
876 {
877 /* the call from Machine issued when the session is open can arrive
878 * after the session starts closing or gets closed. Note that when
879 * aCheck is false, we return E_FAIL to indicate that aWinId we return
880 * is not valid */
881 *aCanShow = FALSE;
882 *aWinId = 0;
883 return aCheck ? S_OK : E_FAIL;
884 }
885
886#ifndef VBOX_COM_INPROC_API_CLIENT
887 return mConsole->i_onShowWindow(aCheck, aCanShow, aWinId);
888#else
889 return S_OK;
890#endif
891}
892
893HRESULT Session::onBandwidthGroupChange(const ComPtr<IBandwidthGroup> &aBandwidthGroup)
894{
895 LogFlowThisFunc(("\n"));
896
897 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
898 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
899 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
900#ifndef VBOX_COM_INPROC_API_CLIENT
901 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
902
903 return mConsole->i_onBandwidthGroupChange(aBandwidthGroup);
904#else
905 RT_NOREF(aBandwidthGroup);
906 return S_OK;
907#endif
908}
909
910HRESULT Session::onStorageDeviceChange(const ComPtr<IMediumAttachment> &aMediumAttachment, BOOL aRemove, BOOL aSilent)
911{
912 LogFlowThisFunc(("\n"));
913
914 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
915 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
916 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
917#ifndef VBOX_COM_INPROC_API_CLIENT
918 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
919
920 return mConsole->i_onStorageDeviceChange(aMediumAttachment, aRemove, aSilent);
921#else
922 RT_NOREF(aMediumAttachment, aRemove, aSilent);
923 return S_OK;
924#endif
925}
926
927HRESULT Session::accessGuestProperty(const com::Utf8Str &aName, const com::Utf8Str &aValue, const com::Utf8Str &aFlags,
928 ULONG aAccessMode, com::Utf8Str &aRetValue, LONG64 *aRetTimestamp, com::Utf8Str &aRetFlags)
929{
930#ifdef VBOX_WITH_GUEST_PROPS
931# ifndef VBOX_COM_INPROC_API_CLIENT
932 if (mState != SessionState_Locked)
933 return setError(VBOX_E_INVALID_VM_STATE,
934 tr("Machine is not locked by session (session state: %s)."),
935 Global::stringifySessionState(mState));
936 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
937 if (aName.isEmpty())
938 return E_INVALIDARG;
939 if (aAccessMode == 0 && !RT_VALID_PTR(aRetTimestamp))
940 return E_POINTER;
941
942 /* If this session is not in a VM process fend off the call. The caller
943 * handles this correctly, by doing the operation in VBoxSVC. */
944 if (!mConsole)
945 return E_ACCESSDENIED;
946
947 HRESULT hr;
948 if (aAccessMode == 2)
949 hr = mConsole->i_deleteGuestProperty(aName);
950 else if (aAccessMode == 1)
951 hr = mConsole->i_setGuestProperty(aName, aValue, aFlags);
952 else if (aAccessMode == 0)
953 hr = mConsole->i_getGuestProperty(aName, &aRetValue, aRetTimestamp, &aRetFlags);
954 else
955 hr = E_INVALIDARG;
956
957 return hr;
958# else /* VBOX_COM_INPROC_API_CLIENT */
959 /** @todo This is nonsense, non-VM API users shouldn't need to deal with this
960 * method call, VBoxSVC should be clever enough to see that the
961 * session doesn't have a console! */
962 RT_NOREF(aName, aValue, aFlags, aAccessMode, aRetValue, aRetTimestamp, aRetFlags);
963 return E_ACCESSDENIED;
964# endif /* VBOX_COM_INPROC_API_CLIENT */
965
966#else /* VBOX_WITH_GUEST_PROPS */
967 ReturnComNotImplemented();
968#endif /* VBOX_WITH_GUEST_PROPS */
969}
970
971HRESULT Session::enumerateGuestProperties(const com::Utf8Str &aPatterns,
972 std::vector<com::Utf8Str> &aKeys,
973 std::vector<com::Utf8Str> &aValues,
974 std::vector<LONG64> &aTimestamps,
975 std::vector<com::Utf8Str> &aFlags)
976{
977#if defined(VBOX_WITH_GUEST_PROPS) && !defined(VBOX_COM_INPROC_API_CLIENT)
978 if (mState != SessionState_Locked)
979 return setError(VBOX_E_INVALID_VM_STATE,
980 tr("Machine is not locked by session (session state: %s)."),
981 Global::stringifySessionState(mState));
982 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
983
984 /* If this session is not in a VM process fend off the call. The caller
985 * handles this correctly, by doing the operation in VBoxSVC. */
986 if (!mConsole)
987 return E_ACCESSDENIED;
988
989 return mConsole->i_enumerateGuestProperties(aPatterns, aKeys, aValues, aTimestamps, aFlags);
990
991#else /* VBOX_WITH_GUEST_PROPS not defined */
992 RT_NOREF(aPatterns, aKeys, aValues, aTimestamps, aFlags);
993 ReturnComNotImplemented();
994#endif /* VBOX_WITH_GUEST_PROPS not defined */
995}
996
997HRESULT Session::onlineMergeMedium(const ComPtr<IMediumAttachment> &aMediumAttachment, ULONG aSourceIdx,
998 ULONG aTargetIdx, const ComPtr<IProgress> &aProgress)
999{
1000 if (mState != SessionState_Locked)
1001 return setError(VBOX_E_INVALID_VM_STATE,
1002 tr("Machine is not locked by session (session state: %s)."),
1003 Global::stringifySessionState(mState));
1004#ifndef VBOX_COM_INPROC_API_CLIENT
1005 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1006 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1007
1008 return mConsole->i_onlineMergeMedium(aMediumAttachment,
1009 aSourceIdx, aTargetIdx,
1010 aProgress);
1011#else
1012 RT_NOREF(aMediumAttachment, aSourceIdx, aTargetIdx, aProgress);
1013 AssertFailed();
1014 return E_NOTIMPL;
1015#endif
1016}
1017
1018HRESULT Session::reconfigureMediumAttachments(const std::vector<ComPtr<IMediumAttachment> > &aAttachments)
1019{
1020 if (mState != SessionState_Locked)
1021 return setError(VBOX_E_INVALID_VM_STATE,
1022 tr("Machine is not locked by session (session state: %s)."),
1023 Global::stringifySessionState(mState));
1024#ifndef VBOX_COM_INPROC_API_CLIENT
1025 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1026 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1027
1028 return mConsole->i_reconfigureMediumAttachments(aAttachments);
1029#else
1030 RT_NOREF(aAttachments);
1031 AssertFailed();
1032 return E_NOTIMPL;
1033#endif
1034}
1035
1036HRESULT Session::enableVMMStatistics(BOOL aEnable)
1037{
1038 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1039 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
1040 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1041#ifndef VBOX_COM_INPROC_API_CLIENT
1042 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1043
1044 mConsole->i_enableVMMStatistics(aEnable);
1045
1046 return S_OK;
1047#else
1048 RT_NOREF(aEnable);
1049 AssertFailed();
1050 return E_NOTIMPL;
1051#endif
1052}
1053
1054HRESULT Session::pauseWithReason(Reason_T aReason)
1055{
1056 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1057 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
1058 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1059#ifndef VBOX_COM_INPROC_API_CLIENT
1060 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1061
1062 return mConsole->i_pause(aReason);
1063#else
1064 RT_NOREF(aReason);
1065 AssertFailed();
1066 return E_NOTIMPL;
1067#endif
1068}
1069
1070HRESULT Session::resumeWithReason(Reason_T aReason)
1071{
1072 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1073 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
1074 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1075#ifndef VBOX_COM_INPROC_API_CLIENT
1076 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1077
1078 AutoWriteLock dummyLock(mConsole COMMA_LOCKVAL_SRC_POS);
1079 return mConsole->i_resume(aReason, dummyLock);
1080#else
1081 RT_NOREF(aReason);
1082 AssertFailed();
1083 return E_NOTIMPL;
1084#endif
1085}
1086
1087HRESULT Session::saveStateWithReason(Reason_T aReason,
1088 const ComPtr<IProgress> &aProgress,
1089 const ComPtr<ISnapshot> &aSnapshot,
1090 const Utf8Str &aStateFilePath,
1091 BOOL aPauseVM, BOOL *aLeftPaused)
1092{
1093 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1094 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
1095 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1096#ifndef VBOX_COM_INPROC_API_CLIENT
1097 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1098
1099 bool fLeftPaused = false;
1100 HRESULT rc = mConsole->i_saveState(aReason, aProgress, aSnapshot, aStateFilePath, !!aPauseVM, fLeftPaused);
1101 if (aLeftPaused)
1102 *aLeftPaused = fLeftPaused;
1103 return rc;
1104#else
1105 RT_NOREF(aReason, aProgress, aSnapshot, aStateFilePath, aPauseVM, aLeftPaused);
1106 AssertFailed();
1107 return E_NOTIMPL;
1108#endif
1109}
1110
1111HRESULT Session::cancelSaveStateWithReason()
1112{
1113 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
1114 AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
1115 AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
1116#ifndef VBOX_COM_INPROC_API_CLIENT
1117 AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
1118
1119 return mConsole->i_cancelSaveState();
1120#else
1121 AssertFailed();
1122 return E_NOTIMPL;
1123#endif
1124}
1125
1126// private methods
1127///////////////////////////////////////////////////////////////////////////////
1128
1129/**
1130 * Unlocks a machine associated with the current session.
1131 *
1132 * @param aFinalRelease called as a result of FinalRelease()
1133 * @param aFromServer called as a result of Uninitialize()
1134 * @param aLockW The write lock this object is protected with.
1135 * Must be acquired already and will be released
1136 * and later reacquired during the unlocking.
1137 *
1138 * @note To be called only from #uninit(), ISession::UnlockMachine() or
1139 * ISession::Uninitialize().
1140 */
1141HRESULT Session::i_unlockMachine(bool aFinalRelease, bool aFromServer, AutoWriteLock &aLockW)
1142{
1143 LogFlowThisFuncEnter();
1144 LogFlowThisFunc(("aFinalRelease=%d, isFromServer=%d\n",
1145 aFinalRelease, aFromServer));
1146
1147 LogFlowThisFunc(("mState=%s, mType=%d\n", Global::stringifySessionState(mState), mType));
1148
1149 Assert(aLockW.isWriteLockOnCurrentThread());
1150
1151 if (mState != SessionState_Locked)
1152 {
1153 Assert(mState == SessionState_Spawning);
1154
1155 /* The session object is going to be uninitialized before it has been
1156 * assigned a direct console of the machine the client requested to open
1157 * a remote session to using IVirtualBox:: openRemoteSession(). It is OK
1158 * only if this close request comes from the server (for example, it
1159 * detected that the VM process it started terminated before opening a
1160 * direct session). Otherwise, it means that the client is too fast and
1161 * trying to close the session before waiting for the progress object it
1162 * got from IVirtualBox:: openRemoteSession() to complete, so assert. */
1163 Assert(aFromServer);
1164
1165 mState = SessionState_Unlocked;
1166 mType = SessionType_Null;
1167
1168 Assert(!mClientTokenHolder);
1169
1170 LogFlowThisFuncLeave();
1171 return S_OK;
1172 }
1173
1174 /* go to the closing state */
1175 mState = SessionState_Unlocking;
1176
1177 if (mType == SessionType_WriteLock)
1178 {
1179#ifndef VBOX_COM_INPROC_API_CLIENT
1180 if (!mConsole.isNull())
1181 {
1182 mConsole->uninit();
1183 mConsole.setNull();
1184 }
1185#else
1186 mRemoteMachine.setNull();
1187#endif
1188 }
1189 else
1190 {
1191 mRemoteMachine.setNull();
1192 mRemoteConsole.setNull();
1193 }
1194
1195 ComPtr<IProgress> progress;
1196
1197 if (!aFinalRelease && !aFromServer)
1198 {
1199 /*
1200 * We trigger OnSessionEnd() only when the session closes itself using
1201 * Close(). Note that if isFinalRelease = TRUE here, this means that
1202 * the client process has already initialized the termination procedure
1203 * without issuing Close() and the IPC channel is no more operational --
1204 * so we cannot call the server's method (it will definitely fail). The
1205 * server will instead simply detect the abnormal client death (since
1206 * OnSessionEnd() is not called) and reset the machine state to Aborted.
1207 */
1208
1209 /*
1210 * while waiting for OnSessionEnd() to complete one of our methods
1211 * can be called by the server (for example, Uninitialize(), if the
1212 * direct session has initiated a closure just a bit before us) so
1213 * we need to release the lock to avoid deadlocks. The state is already
1214 * SessionState_Closing here, so it's safe.
1215 */
1216 aLockW.release();
1217
1218 Assert(!aLockW.isWriteLockOnCurrentThread());
1219
1220 LogFlowThisFunc(("Calling mControl->OnSessionEnd()...\n"));
1221 HRESULT rc = mControl->OnSessionEnd(this, progress.asOutParam());
1222 LogFlowThisFunc(("mControl->OnSessionEnd()=%08X\n", rc));
1223
1224 aLockW.acquire();
1225
1226 /*
1227 * If we get E_UNEXPECTED this means that the direct session has already
1228 * been closed, we're just too late with our notification and nothing more
1229 *
1230 * bird: Seems E_ACCESSDENIED is what gets returned these days; see
1231 * ObjectState::addCaller.
1232 */
1233 if (mType != SessionType_WriteLock && (rc == E_UNEXPECTED || rc == E_ACCESSDENIED))
1234 rc = S_OK;
1235
1236#if !defined(DEBUG_bird) && !defined(DEBUG_andy) /* I don't want clients crashing on me just because VBoxSVC went belly up. */
1237 AssertComRC(rc);
1238#endif
1239 }
1240
1241 mControl.setNull();
1242
1243 if (mType == SessionType_WriteLock)
1244 {
1245 if (mClientTokenHolder)
1246 {
1247 delete mClientTokenHolder;
1248 mClientTokenHolder = NULL;
1249 }
1250
1251 if (!aFinalRelease && !aFromServer)
1252 {
1253 /*
1254 * Wait for the server to grab the semaphore and destroy the session
1255 * machine (allowing us to open a new session with the same machine
1256 * once this method returns)
1257 */
1258 Assert(!!progress);
1259 if (progress)
1260 progress->WaitForCompletion(-1);
1261 }
1262 }
1263
1264 mState = SessionState_Unlocked;
1265 mType = SessionType_Null;
1266
1267 /* release the VirtualBox instance as the very last step */
1268 mVirtualBox.setNull();
1269
1270 LogFlowThisFuncLeave();
1271 return S_OK;
1272}
1273
1274/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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