VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/GuestCtrlImpl.cpp

Last change on this file was 102533, checked in by vboxsync, 5 months ago

Main/Guest Control: Fixed a shutdown race when uninitializing guest sessions via IGuestSession::Close(): There we need to check if its parent object (IGuest) still is around and in a working shape, and if not, do the cleanup stuff ourselves. Renamed Guest::i_sessionDestroy() -> Guest::i_sessionRemove() to make its function more clear. This race seemed to happen in combination with FE/Qt's guest file manager every now and then. bugref:9135
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 25.1 KB
Line 
1/* $Id: GuestCtrlImpl.cpp 102533 2023-12-08 10:15:02Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation: Guest
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#define LOG_GROUP LOG_GROUP_GUEST_CONTROL
29#include "LoggingNew.h"
30
31#include "GuestImpl.h"
32#ifdef VBOX_WITH_GUEST_CONTROL
33# include "GuestSessionImpl.h"
34# include "GuestSessionImplTasks.h"
35# include "GuestCtrlImplPrivate.h"
36#endif
37
38#include "Global.h"
39#include "ConsoleImpl.h"
40#include "ProgressImpl.h"
41#include "VBoxEvents.h"
42#include "VMMDev.h"
43
44#include "AutoCaller.h"
45
46#include <VBox/VMMDev.h>
47#ifdef VBOX_WITH_GUEST_CONTROL
48# include <VBox/com/array.h>
49# include <VBox/com/ErrorInfo.h>
50#endif
51#include <iprt/cpp/utils.h>
52#include <iprt/file.h>
53#include <iprt/getopt.h>
54#include <iprt/list.h>
55#include <iprt/path.h>
56#include <VBox/vmm/pgm.h>
57#include <VBox/AssertGuest.h>
58
59#include <memory>
60
61
62/*
63 * This #ifdef goes almost to the end of the file where there are a couple of
64 * IGuest method implementations.
65 */
66#ifdef VBOX_WITH_GUEST_CONTROL
67
68
69// public methods only for internal purposes
70/////////////////////////////////////////////////////////////////////////////
71
72/**
73 * Static callback function for receiving updates on guest control messages
74 * from the guest. Acts as a dispatcher for the actual class instance.
75 *
76 * @returns VBox status code.
77 * @param pvExtension Pointer to HGCM service extension.
78 * @param idMessage HGCM message ID the callback was called for.
79 * @param pvData Pointer to user-supplied callback data.
80 * @param cbData Size (in bytes) of user-supplied callback data.
81 */
82/* static */
83DECLCALLBACK(int) Guest::i_notifyCtrlDispatcher(void *pvExtension,
84 uint32_t idMessage,
85 void *pvData,
86 uint32_t cbData)
87{
88 using namespace guestControl;
89
90 /*
91 * No locking, as this is purely a notification which does not make any
92 * changes to the object state.
93 */
94 Log2Func(("pvExtension=%p, idMessage=%RU32, pvParms=%p, cbParms=%RU32\n", pvExtension, idMessage, pvData, cbData));
95
96 ComObjPtr<Guest> pGuest = reinterpret_cast<Guest *>(pvExtension);
97 AssertReturn(pGuest.isNotNull(), VERR_WRONG_ORDER);
98
99 /*
100 * The data packet should ever be a problem, but check to be sure.
101 */
102 AssertMsgReturn(cbData == sizeof(VBOXGUESTCTRLHOSTCALLBACK),
103 ("Guest control host callback data has wrong size (expected %zu, got %zu) - buggy host service!\n",
104 sizeof(VBOXGUESTCTRLHOSTCALLBACK), cbData), VERR_INVALID_PARAMETER);
105 PVBOXGUESTCTRLHOSTCALLBACK pSvcCb = (PVBOXGUESTCTRLHOSTCALLBACK)pvData;
106 AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
107
108 /*
109 * Deal with GUEST_MSG_REPORT_FEATURES here as it shouldn't be handed
110 * i_dispatchToSession() and has different parameters.
111 */
112 if (idMessage == GUEST_MSG_REPORT_FEATURES)
113 {
114 Assert(pSvcCb->mParms == 2);
115 Assert(pSvcCb->mpaParms[0].type == VBOX_HGCM_SVC_PARM_64BIT);
116 Assert(pSvcCb->mpaParms[1].type == VBOX_HGCM_SVC_PARM_64BIT);
117 Assert(pSvcCb->mpaParms[1].u.uint64 & VBOX_GUESTCTRL_GF_1_MUST_BE_ONE);
118 pGuest->mData.mfGuestFeatures0 = pSvcCb->mpaParms[0].u.uint64;
119 pGuest->mData.mfGuestFeatures1 = pSvcCb->mpaParms[1].u.uint64;
120 LogRel(("Guest Control: GUEST_MSG_REPORT_FEATURES: %#RX64, %#RX64\n",
121 pGuest->mData.mfGuestFeatures0, pGuest->mData.mfGuestFeatures1));
122 return VINF_SUCCESS;
123 }
124
125 /*
126 * For guest control 2.0 using the legacy messages we need to do the following here:
127 * - Get the callback header to access the context ID
128 * - Get the context ID of the callback
129 * - Extract the session ID out of the context ID
130 * - Dispatch the whole stuff to the appropriate session (if still exists)
131 *
132 * At least context ID parameter must always be present.
133 */
134 ASSERT_GUEST_RETURN(pSvcCb->mParms > 0, VERR_WRONG_PARAMETER_COUNT);
135 ASSERT_GUEST_MSG_RETURN(pSvcCb->mpaParms[0].type == VBOX_HGCM_SVC_PARM_32BIT,
136 ("type=%d\n", pSvcCb->mpaParms[0].type), VERR_WRONG_PARAMETER_TYPE);
137 uint32_t const idContext = pSvcCb->mpaParms[0].u.uint32;
138
139 VBOXGUESTCTRLHOSTCBCTX CtxCb = { idMessage, idContext };
140 int vrc = pGuest->i_dispatchToSession(&CtxCb, pSvcCb);
141
142 Log2Func(("CID=%#x, idSession=%RU32, uObject=%RU32, uCount=%RU32, vrc=%Rrc\n",
143 idContext, VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(idContext), VBOX_GUESTCTRL_CONTEXTID_GET_OBJECT(idContext),
144 VBOX_GUESTCTRL_CONTEXTID_GET_COUNT(idContext), vrc));
145 return vrc;
146}
147
148// private methods
149/////////////////////////////////////////////////////////////////////////////
150
151/**
152 * Dispatches a host service callback to the appropriate guest control session object.
153 *
154 * @returns VBox status code.
155 * @param pCtxCb Pointer to host callback context.
156 * @param pSvcCb Pointer to callback parameters.
157 */
158int Guest::i_dispatchToSession(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb)
159{
160 LogFlowFunc(("pCtxCb=%p, pSvcCb=%p\n", pCtxCb, pSvcCb));
161
162 AssertPtrReturn(pCtxCb, VERR_INVALID_POINTER);
163 AssertPtrReturn(pSvcCb, VERR_INVALID_POINTER);
164
165 Log2Func(("uMessage=%RU32, uContextID=%RU32, uProtocol=%RU32\n", pCtxCb->uMessage, pCtxCb->uContextID, pCtxCb->uProtocol));
166
167 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
168
169 const uint32_t uSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtxCb->uContextID);
170
171 Log2Func(("uSessionID=%RU32 (%zu total)\n", uSessionID, mData.mGuestSessions.size()));
172
173 GuestSessions::const_iterator itSession = mData.mGuestSessions.find(uSessionID);
174
175 int vrc;
176 if (itSession != mData.mGuestSessions.end())
177 {
178 ComObjPtr<GuestSession> pSession(itSession->second);
179 Assert(!pSession.isNull());
180
181 alock.release();
182
183#ifdef DEBUG
184 /*
185 * Pre-check: If we got a status message with an error and VERR_TOO_MUCH_DATA
186 * it means that that guest could not handle the entire message
187 * because of its exceeding size. This should not happen on daily
188 * use but testcases might try this. It then makes no sense to dispatch
189 * this further because we don't have a valid context ID.
190 */
191 bool fDispatch = true;
192 vrc = VERR_INVALID_FUNCTION;
193 if ( pCtxCb->uMessage == GUEST_MSG_EXEC_STATUS
194 && pSvcCb->mParms >= 5)
195 {
196 CALLBACKDATA_PROC_STATUS dataCb;
197 /* pSvcCb->mpaParms[0] always contains the context ID. */
198 HGCMSvcGetU32(&pSvcCb->mpaParms[1], &dataCb.uPID);
199 HGCMSvcGetU32(&pSvcCb->mpaParms[2], &dataCb.uStatus);
200 HGCMSvcGetU32(&pSvcCb->mpaParms[3], &dataCb.uFlags);
201 HGCMSvcGetPv(&pSvcCb->mpaParms[4], &dataCb.pvData, &dataCb.cbData);
202
203 if ( dataCb.uStatus == PROC_STS_ERROR
204 && (int32_t)dataCb.uFlags == VERR_TOO_MUCH_DATA)
205 {
206 LogFlowFunc(("Requested message with too much data, skipping dispatching ...\n"));
207 Assert(dataCb.uPID == 0);
208 fDispatch = false;
209 }
210 }
211 if (fDispatch)
212#endif
213 {
214 switch (pCtxCb->uMessage)
215 {
216 case GUEST_MSG_DISCONNECTED:
217 vrc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
218 break;
219
220 /* Process stuff. */
221 case GUEST_MSG_EXEC_STATUS:
222 case GUEST_MSG_EXEC_OUTPUT:
223 case GUEST_MSG_EXEC_INPUT_STATUS:
224 case GUEST_MSG_EXEC_IO_NOTIFY:
225 vrc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
226 break;
227
228 /* File stuff. */
229 case GUEST_MSG_FILE_NOTIFY:
230 vrc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
231 break;
232
233 /* File system stuff. */
234#ifdef VBOX_WITH_GSTCTL_TOOLBOX_AS_CMDS
235 case GUEST_MSG_FS_NOTIFY:
236 vrc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
237 break;
238#endif
239 /* Session stuff. */
240 case GUEST_MSG_SESSION_NOTIFY:
241 vrc = pSession->i_dispatchToThis(pCtxCb, pSvcCb);
242 break;
243
244 default:
245 vrc = pSession->i_dispatchToObject(pCtxCb, pSvcCb);
246 break;
247 }
248 }
249 }
250 else
251 vrc = VERR_INVALID_SESSION_ID;
252
253 LogFlowFuncLeaveRC(vrc);
254 return vrc;
255}
256
257/**
258 * Creates a new guest session.
259 * This will invoke VBoxService running on the guest creating a new (dedicated) guest session
260 * On older Guest Additions this call has no effect on the guest, and only the credentials will be
261 * used for starting/impersonating guest processes.
262 *
263 * @returns VBox status code.
264 * @param ssInfo Guest session startup information.
265 * @param guestCreds Guest OS (user) credentials to use on the guest for creating the session.
266 * The specified user must be able to logon to the guest and able to start new processes.
267 * @param pGuestSession Where to store the created guest session on success.
268 *
269 * @note Takes the write lock.
270 */
271int Guest::i_sessionCreate(const GuestSessionStartupInfo &ssInfo,
272 const GuestCredentials &guestCreds, ComObjPtr<GuestSession> &pGuestSession)
273{
274 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
275
276 int vrc = VERR_MAX_PROCS_REACHED;
277 if (mData.mGuestSessions.size() >= VBOX_GUESTCTRL_MAX_SESSIONS)
278 return vrc;
279
280 try
281 {
282 /* Create a new session ID and assign it. */
283 uint32_t uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
284 uint32_t uTries = 0;
285
286 for (;;)
287 {
288 /* Is the context ID already used? */
289 if (!i_sessionExists(uNewSessionID))
290 {
291 vrc = VINF_SUCCESS;
292 break;
293 }
294 uNewSessionID++;
295 if (uNewSessionID >= VBOX_GUESTCTRL_MAX_SESSIONS)
296 uNewSessionID = VBOX_GUESTCTRL_SESSION_ID_BASE;
297
298 if (++uTries == VBOX_GUESTCTRL_MAX_SESSIONS)
299 break; /* Don't try too hard. */
300 }
301 if (RT_FAILURE(vrc)) throw vrc;
302
303 /* Create the session object. */
304 HRESULT hrc = pGuestSession.createObject();
305 if (FAILED(hrc)) throw VERR_COM_UNEXPECTED;
306
307 /** @todo Use an overloaded copy operator. Later. */
308 GuestSessionStartupInfo startupInfo;
309 startupInfo.mID = uNewSessionID; /* Assign new session ID. */
310 startupInfo.mName = ssInfo.mName;
311 startupInfo.mOpenFlags = ssInfo.mOpenFlags;
312 startupInfo.mOpenTimeoutMS = ssInfo.mOpenTimeoutMS;
313
314 GuestCredentials guestCredentials;
315 if (!guestCreds.mUser.isEmpty())
316 {
317 /** @todo Use an overloaded copy operator. Later. */
318 guestCredentials.mUser = guestCreds.mUser;
319 guestCredentials.mPassword = guestCreds.mPassword;
320 guestCredentials.mDomain = guestCreds.mDomain;
321 }
322 else
323 {
324 /* Internal (annonymous) session. */
325 startupInfo.mIsInternal = true;
326 }
327
328 vrc = pGuestSession->init(this, startupInfo, guestCredentials);
329 if (RT_FAILURE(vrc)) throw vrc;
330
331 /*
332 * Add session object to our session map. This is necessary
333 * before calling openSession because the guest calls back
334 * with the creation result of this session.
335 */
336 mData.mGuestSessions[uNewSessionID] = pGuestSession;
337
338 alock.release(); /* Release lock before firing off event. */
339
340 ::FireGuestSessionRegisteredEvent(mEventSource, pGuestSession, true /* Registered */);
341 }
342 catch (int vrc2)
343 {
344 vrc = vrc2;
345 }
346
347 LogFlowFuncLeaveRC(vrc);
348 return vrc;
349}
350
351/**
352 * Removes a given guest session and removes it from the internal list.
353 *
354 * @returns VBox status code.
355 * @param uSessionID ID of the guest control session to destroy.
356 *
357 * @note Takes the read + write locks.
358 */
359int Guest::i_sessionRemove(uint32_t uSessionID)
360{
361 LogFlowThisFuncEnter();
362
363 int vrc = VERR_NOT_FOUND;
364
365 LogFlowThisFunc(("Removing session (ID=%RU32) ...\n", uSessionID));
366
367 AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
368
369 GuestSessions::iterator itSessions = mData.mGuestSessions.find(uSessionID);
370 if (itSessions == mData.mGuestSessions.end())
371 return VERR_NOT_FOUND;
372
373 /* Make sure to consume the pointer before the one of the
374 * iterator gets released. */
375 ComObjPtr<GuestSession> pSession = itSessions->second;
376
377 LogFlowThisFunc(("Removing session %RU32 (now total %ld sessions)\n",
378 uSessionID, mData.mGuestSessions.size() ? mData.mGuestSessions.size() - 1 : 0));
379
380 vrc = pSession->i_onRemove();
381
382 arlock.release();
383
384 AutoWriteLock awlock(this COMMA_LOCKVAL_SRC_POS);
385 mData.mGuestSessions.erase(itSessions);
386 awlock.release(); /* Release write lock before firing off event. */
387
388 ::FireGuestSessionRegisteredEvent(mEventSource, pSession, false /* Unregistered */);
389 pSession.setNull();
390
391 LogFlowFuncLeaveRC(vrc);
392 return vrc;
393}
394
395/**
396 * Returns whether a guest control session with a specific ID exists or not.
397 *
398 * @returns Returns \c true if the session exists, \c false if not.
399 * @param uSessionID ID to check for.
400 *
401 * @note No locking done, as inline function!
402 */
403inline bool Guest::i_sessionExists(uint32_t uSessionID)
404{
405 GuestSessions::const_iterator itSessions = mData.mGuestSessions.find(uSessionID);
406 return (itSessions == mData.mGuestSessions.end()) ? false : true;
407}
408
409#endif /* VBOX_WITH_GUEST_CONTROL */
410
411
412// implementation of public methods
413/////////////////////////////////////////////////////////////////////////////
414HRESULT Guest::createSession(const com::Utf8Str &aUser, const com::Utf8Str &aPassword, const com::Utf8Str &aDomain,
415 const com::Utf8Str &aSessionName, ComPtr<IGuestSession> &aGuestSession)
416
417{
418#ifndef VBOX_WITH_GUEST_CONTROL
419 ReturnComNotImplemented();
420#else /* VBOX_WITH_GUEST_CONTROL */
421
422 AutoCaller autoCaller(this);
423 if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
424
425 /* Do not allow anonymous sessions (with system rights) with public API. */
426 if (RT_UNLIKELY(!aUser.length()))
427 return setError(E_INVALIDARG, tr("No user name specified"));
428
429 LogFlowFuncEnter();
430
431 GuestSessionStartupInfo startupInfo;
432 startupInfo.mName = aSessionName;
433
434 GuestCredentials guestCreds;
435 guestCreds.mUser = aUser;
436 guestCreds.mPassword = aPassword;
437 guestCreds.mDomain = aDomain;
438
439 ComObjPtr<GuestSession> pSession;
440 int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
441 if (RT_SUCCESS(vrc))
442 {
443 /* Return guest session to the caller. */
444 HRESULT hr2 = pSession.queryInterfaceTo(aGuestSession.asOutParam());
445 if (FAILED(hr2))
446 vrc = VERR_COM_OBJECT_NOT_FOUND;
447 }
448
449 if (RT_SUCCESS(vrc))
450 /* Start (fork) the session asynchronously
451 * on the guest. */
452 vrc = pSession->i_startSessionAsync();
453
454 HRESULT hrc = S_OK;
455 if (RT_FAILURE(vrc))
456 {
457 switch (vrc)
458 {
459 case VERR_MAX_PROCS_REACHED:
460 hrc = setErrorBoth(VBOX_E_MAXIMUM_REACHED, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
461 VBOX_GUESTCTRL_MAX_SESSIONS);
462 break;
463
464 case VERR_NOT_FOUND: /* Returned by i_sessionCreate(). */
465 hrc = setErrorBoth(VBOX_E_GSTCTL_GUEST_ERROR, vrc, tr("Guest Additions are not installed or not ready (yet)"));
466 break;
467
468 default:
469 hrc = setErrorBoth(VBOX_E_GSTCTL_GUEST_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
470 break;
471 }
472 }
473
474 LogFlowThisFunc(("Returning hrc=%Rhrc\n", hrc));
475 return hrc;
476#endif /* VBOX_WITH_GUEST_CONTROL */
477}
478
479HRESULT Guest::findSession(const com::Utf8Str &aSessionName, std::vector<ComPtr<IGuestSession> > &aSessions)
480{
481#ifndef VBOX_WITH_GUEST_CONTROL
482 ReturnComNotImplemented();
483#else /* VBOX_WITH_GUEST_CONTROL */
484
485 LogFlowFuncEnter();
486
487 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
488
489 Utf8Str strName(aSessionName);
490 std::list < ComObjPtr<GuestSession> > listSessions;
491
492 GuestSessions::const_iterator itSessions = mData.mGuestSessions.begin();
493 while (itSessions != mData.mGuestSessions.end())
494 {
495 if (strName.contains(itSessions->second->i_getName())) /** @todo Use a (simple) pattern match (IPRT?). */
496 listSessions.push_back(itSessions->second);
497 ++itSessions;
498 }
499
500 LogFlowFunc(("Sessions with \"%s\" = %RU32\n",
501 aSessionName.c_str(), listSessions.size()));
502
503 aSessions.resize(listSessions.size());
504 if (!listSessions.empty())
505 {
506 size_t i = 0;
507 for (std::list < ComObjPtr<GuestSession> >::const_iterator it = listSessions.begin(); it != listSessions.end(); ++it, ++i)
508 (*it).queryInterfaceTo(aSessions[i].asOutParam());
509
510 return S_OK;
511
512 }
513
514 return setErrorNoLog(VBOX_E_OBJECT_NOT_FOUND,
515 tr("Could not find sessions with name '%s'"),
516 aSessionName.c_str());
517#endif /* VBOX_WITH_GUEST_CONTROL */
518}
519
520HRESULT Guest::shutdown(const std::vector<GuestShutdownFlag_T> &aFlags)
521{
522#ifndef VBOX_WITH_GUEST_CONTROL
523 ReturnComNotImplemented();
524#else /* VBOX_WITH_GUEST_CONTROL */
525
526 /* Validate flags. */
527 uint32_t fFlags = GuestShutdownFlag_None;
528 if (aFlags.size())
529 for (size_t i = 0; i < aFlags.size(); ++i)
530 fFlags |= aFlags[i];
531
532 const uint32_t fValidFlags = GuestShutdownFlag_None
533 | GuestShutdownFlag_PowerOff | GuestShutdownFlag_Reboot | GuestShutdownFlag_Force;
534 if (fFlags & ~fValidFlags)
535 return setError(E_INVALIDARG,tr("Unknown flags: flags value %#x, invalid: %#x"), fFlags, fFlags & ~fValidFlags);
536
537 if ( (fFlags & GuestShutdownFlag_PowerOff)
538 && (fFlags & GuestShutdownFlag_Reboot))
539 return setError(E_INVALIDARG, tr("Invalid combination of flags (%#x)"), fFlags);
540
541 Utf8Str strAction = (fFlags & GuestShutdownFlag_Reboot) ? tr("Rebooting") : tr("Shutting down");
542
543 /*
544 * Create an anonymous session. This is required to run shutting down / rebooting
545 * the guest with administrative rights.
546 */
547 GuestSessionStartupInfo startupInfo;
548 startupInfo.mName = (fFlags & GuestShutdownFlag_Reboot) ? tr("Rebooting guest") : tr("Shutting down guest");
549
550 GuestCredentials guestCreds;
551
552 HRESULT hrc = S_OK;
553
554 ComObjPtr<GuestSession> pSession;
555 int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
556 if (RT_SUCCESS(vrc))
557 {
558 Assert(!pSession.isNull());
559
560 int vrcGuest = VERR_GSTCTL_GUEST_ERROR;
561 vrc = pSession->i_startSession(&vrcGuest);
562 if (RT_SUCCESS(vrc))
563 {
564 vrc = pSession->i_shutdown(fFlags, &vrcGuest);
565 if (RT_FAILURE(vrc))
566 {
567 switch (vrc)
568 {
569 case VERR_NOT_SUPPORTED:
570 hrc = setErrorBoth(VBOX_E_NOT_SUPPORTED, vrc,
571 tr("%s not supported by installed Guest Additions"), strAction.c_str());
572 break;
573
574 default:
575 {
576 if (vrc == VERR_GSTCTL_GUEST_ERROR)
577 vrc = vrcGuest;
578 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Error %s guest: %Rrc"), strAction.c_str(), vrc);
579 break;
580 }
581 }
582 }
583 }
584 else
585 {
586 if (vrc == VERR_GSTCTL_GUEST_ERROR)
587 vrc = vrcGuest;
588 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open guest session: %Rrc"), vrc);
589 }
590 }
591 else
592 {
593 switch (vrc)
594 {
595 case VERR_MAX_PROCS_REACHED:
596 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
597 VBOX_GUESTCTRL_MAX_SESSIONS);
598 break;
599
600 /** @todo Add more errors here. */
601
602 default:
603 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
604 break;
605 }
606 }
607
608 LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
609 return hrc;
610#endif /* VBOX_WITH_GUEST_CONTROL */
611}
612
613HRESULT Guest::updateGuestAdditions(const com::Utf8Str &aSource, const std::vector<com::Utf8Str> &aArguments,
614 const std::vector<AdditionsUpdateFlag_T> &aFlags, ComPtr<IProgress> &aProgress)
615{
616#ifndef VBOX_WITH_GUEST_CONTROL
617 ReturnComNotImplemented();
618#else /* VBOX_WITH_GUEST_CONTROL */
619
620 /* Validate flags. */
621 uint32_t fFlags = AdditionsUpdateFlag_None;
622 if (aFlags.size())
623 for (size_t i = 0; i < aFlags.size(); ++i)
624 fFlags |= aFlags[i];
625
626 if (fFlags && !(fFlags & AdditionsUpdateFlag_WaitForUpdateStartOnly))
627 return setError(E_INVALIDARG, tr("Unknown flags (%#x)"), fFlags);
628
629
630 /* Copy arguments into aArgs: */
631 ProcessArguments aArgs;
632 try
633 {
634 aArgs.resize(0);
635 for (size_t i = 0; i < aArguments.size(); ++i)
636 aArgs.push_back(aArguments[i]);
637 }
638 catch (std::bad_alloc &)
639 {
640 return E_OUTOFMEMORY;
641 }
642
643
644 /*
645 * Create an anonymous session. This is required to run the Guest Additions
646 * update process with administrative rights.
647 */
648 GuestSessionStartupInfo startupInfo;
649 startupInfo.mName = "Updating Guest Additions";
650
651 GuestCredentials guestCreds;
652
653 HRESULT hrc;
654 ComObjPtr<GuestSession> pSession;
655 int vrc = i_sessionCreate(startupInfo, guestCreds, pSession);
656 if (RT_SUCCESS(vrc))
657 {
658 Assert(!pSession.isNull());
659
660 int vrcGuest = VERR_GSTCTL_GUEST_ERROR;
661 vrc = pSession->i_startSession(&vrcGuest);
662 if (RT_SUCCESS(vrc))
663 {
664 /*
665 * Create the update task.
666 */
667 GuestSessionTaskUpdateAdditions *pTask = NULL;
668 try
669 {
670 pTask = new GuestSessionTaskUpdateAdditions(pSession /* GuestSession */, aSource, aArgs, fFlags);
671 hrc = S_OK;
672 }
673 catch (std::bad_alloc &)
674 {
675 hrc = setError(E_OUTOFMEMORY, tr("Failed to create SessionTaskUpdateAdditions object"));
676 }
677 if (SUCCEEDED(hrc))
678 {
679 try
680 {
681 hrc = pTask->Init(Utf8StrFmt(tr("Updating Guest Additions")));
682 }
683 catch (std::bad_alloc &)
684 {
685 hrc = E_OUTOFMEMORY;
686 }
687 if (SUCCEEDED(hrc))
688 {
689 ComPtr<Progress> ptrProgress = pTask->GetProgressObject();
690
691 /*
692 * Kick off the thread. Note! consumes pTask!
693 */
694 hrc = pTask->createThreadWithType(RTTHREADTYPE_MAIN_HEAVY_WORKER);
695 pTask = NULL;
696 if (SUCCEEDED(hrc))
697 hrc = ptrProgress.queryInterfaceTo(aProgress.asOutParam());
698 else
699 hrc = setError(hrc, tr("Starting thread for updating Guest Additions on the guest failed"));
700 }
701 else
702 {
703 hrc = setError(hrc, tr("Failed to initialize SessionTaskUpdateAdditions object"));
704 delete pTask;
705 }
706 }
707 }
708 else
709 {
710 if (vrc == VERR_GSTCTL_GUEST_ERROR)
711 vrc = vrcGuest;
712 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not open guest session: %Rrc"), vrc);
713 }
714 }
715 else
716 {
717 switch (vrc)
718 {
719 case VERR_MAX_PROCS_REACHED:
720 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Maximum number of concurrent guest sessions (%d) reached"),
721 VBOX_GUESTCTRL_MAX_SESSIONS);
722 break;
723
724 /** @todo Add more errors here. */
725
726 default:
727 hrc = setErrorBoth(VBOX_E_IPRT_ERROR, vrc, tr("Could not create guest session: %Rrc"), vrc);
728 break;
729 }
730 }
731
732 LogFlowFunc(("Returning hrc=%Rhrc\n", hrc));
733 return hrc;
734#endif /* VBOX_WITH_GUEST_CONTROL */
735}
736
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use