VirtualBox

source: vbox/trunk/src/VBox/Main/include/GuestSessionImpl.h@ 62502

Last change on this file since 62502 was 62485, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.2 KB
Line 
1/* $Id: GuestSessionImpl.h 62485 2016-07-22 18:36:43Z vboxsync $ */
2/** @file
3 * VirtualBox Main - Guest session 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#ifndef ____H_GUESTSESSIONIMPL
19#define ____H_GUESTSESSIONIMPL
20
21#include "GuestSessionWrap.h"
22#include "EventImpl.h"
23
24#include "GuestCtrlImplPrivate.h"
25#include "GuestProcessImpl.h"
26#include "GuestDirectoryImpl.h"
27#include "GuestFileImpl.h"
28#include "GuestFsObjInfoImpl.h"
29#include "ThreadTask.h"
30
31#include <iprt/isofs.h> /* For UpdateAdditions. */
32
33class Guest;
34
35/**
36 * Abstract base class for a lenghtly per-session operation which
37 * runs in a Main worker thread.
38 */
39class GuestSessionTask : public ThreadTask
40{
41public:
42
43 GuestSessionTask(GuestSession *pSession);
44
45 virtual ~GuestSessionTask(void);
46
47public:
48
49 virtual int Run(void) = 0;
50 virtual int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress) = 0;
51
52 HRESULT Init(const Utf8Str &strTaskDesc)
53 {
54 HRESULT hr = S_OK;
55 setTaskDesc(strTaskDesc);
56 hr = createAndSetProgressObject();
57 return hr;
58 }
59
60 const ComObjPtr<Progress>& GetProgressObject() const {return mProgress;}
61
62protected:
63
64 int getGuestProperty(const ComObjPtr<Guest> &pGuest,
65 const Utf8Str &strPath, Utf8Str &strValue);
66 int setProgress(ULONG uPercent);
67 int setProgressSuccess(void);
68 HRESULT setProgressErrorMsg(HRESULT hr, const Utf8Str &strMsg);
69 inline void setTaskDesc(const Utf8Str &strTaskDesc) throw()
70 {
71 mDesc = strTaskDesc;
72 }
73
74 HRESULT createAndSetProgressObject();
75protected:
76
77 Utf8Str mDesc;
78 GuestSession *mSession;
79 /** Progress object for getting updated when running
80 * asynchronously. Optional. */
81 ComObjPtr<Progress> mProgress;
82};
83
84/**
85 * Task for opening a guest session.
86 */
87class SessionTaskOpen : public GuestSessionTask
88{
89public:
90
91 SessionTaskOpen(GuestSession *pSession,
92 uint32_t uFlags,
93 uint32_t uTimeoutMS);
94
95 virtual ~SessionTaskOpen(void);
96
97public:
98
99 int Run(int *pGuestRc);
100 int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
101 static DECLCALLBACK(int) taskThread(RTTHREAD Thread, void *pvUser);
102 void handler()
103 {
104 int vrc = SessionTaskOpen::taskThread(NULL, this);
105 }
106
107protected:
108
109 /** Session creation flags. */
110 uint32_t mFlags;
111 /** Session creation timeout (in ms). */
112 uint32_t mTimeoutMS;
113};
114
115/**
116 * Task for copying files from host to the guest.
117 */
118class SessionTaskCopyTo : public GuestSessionTask
119{
120public:
121
122 SessionTaskCopyTo(GuestSession *pSession,
123 const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags);
124
125 SessionTaskCopyTo(GuestSession *pSession,
126 PRTFILE pSourceFile, size_t cbSourceOffset, uint64_t cbSourceSize,
127 const Utf8Str &strDest, uint32_t uFlags);
128
129 virtual ~SessionTaskCopyTo(void);
130
131public:
132
133 int Run(void);
134 int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
135 static DECLCALLBACK(int) taskThread(RTTHREAD Thread, void *pvUser);
136 void handler()
137 {
138 int vrc = SessionTaskCopyTo::taskThread(NULL, this);
139 }
140
141protected:
142
143 Utf8Str mSource;
144 PRTFILE mSourceFile;
145 size_t mSourceOffset;
146 uint64_t mSourceSize;
147 Utf8Str mDest;
148 uint32_t mCopyFileFlags;
149};
150
151/**
152 * Task for copying files from guest to the host.
153 */
154class SessionTaskCopyFrom : public GuestSessionTask
155{
156public:
157
158 SessionTaskCopyFrom(GuestSession *pSession,
159 const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags);
160
161 virtual ~SessionTaskCopyFrom(void);
162
163public:
164
165 int Run(void);
166 int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
167 static DECLCALLBACK(int) taskThread(RTTHREAD Thread, void *pvUser);
168 void handler()
169 {
170 int vrc = SessionTaskCopyFrom::taskThread(NULL, this);
171 }
172
173protected:
174
175 Utf8Str mSource;
176 Utf8Str mDest;
177 uint32_t mFlags;
178};
179
180/**
181 * Task for automatically updating the Guest Additions on the guest.
182 */
183class SessionTaskUpdateAdditions : public GuestSessionTask
184{
185public:
186
187 SessionTaskUpdateAdditions(GuestSession *pSession,
188 const Utf8Str &strSource, const ProcessArguments &aArguments,
189 uint32_t uFlags);
190
191 virtual ~SessionTaskUpdateAdditions(void);
192
193public:
194
195 int Run(void);
196 int RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress);
197 static DECLCALLBACK(int) taskThread(RTTHREAD Thread, void *pvUser);
198 void handler()
199 {
200 int vrc = SessionTaskUpdateAdditions::taskThread(NULL, this);
201 }
202
203protected:
204
205 /**
206 * Suported OS types for automatic updating.
207 */
208 enum eOSType
209 {
210 eOSType_Unknown = 0,
211 eOSType_Windows = 1,
212 eOSType_Linux = 2,
213 eOSType_Solaris = 3
214 };
215
216 /**
217 * Structure representing a file to
218 * get off the .ISO, copied to the guest.
219 */
220 struct InstallerFile
221 {
222 InstallerFile(const Utf8Str &aSource,
223 const Utf8Str &aDest,
224 uint32_t aFlags = 0)
225 : strSource(aSource),
226 strDest(aDest),
227 fFlags(aFlags) { }
228
229 InstallerFile(const Utf8Str &aSource,
230 const Utf8Str &aDest,
231 uint32_t aFlags,
232 GuestProcessStartupInfo startupInfo)
233 : strSource(aSource),
234 strDest(aDest),
235 fFlags(aFlags),
236 mProcInfo(startupInfo)
237 {
238 mProcInfo.mExecutable = strDest;
239 if (mProcInfo.mName.isEmpty())
240 mProcInfo.mName = strDest;
241 }
242
243 /** Source file on .ISO. */
244 Utf8Str strSource;
245 /** Destination file on the guest. */
246 Utf8Str strDest;
247 /** File flags. */
248 uint32_t fFlags;
249 /** Optional arguments if this file needs to be
250 * executed. */
251 GuestProcessStartupInfo mProcInfo;
252 };
253
254 int i_addProcessArguments(ProcessArguments &aArgumentsDest,
255 const ProcessArguments &aArgumentsSource);
256 int i_copyFileToGuest(GuestSession *pSession, PRTISOFSFILE pISO,
257 Utf8Str const &strFileSource, const Utf8Str &strFileDest,
258 bool fOptional, uint32_t *pcbSize);
259 int i_runFileOnGuest(GuestSession *pSession, GuestProcessStartupInfo &procInfo);
260
261 /** Files to handle. */
262 std::vector<InstallerFile> mFiles;
263 /** The (optionally) specified Guest Additions .ISO on the host
264 * which will be used for the updating process. */
265 Utf8Str mSource;
266 /** (Optional) installer command line arguments. */
267 ProcessArguments mArguments;
268 /** Update flags. */
269 uint32_t mFlags;
270};
271
272/**
273 * Guest session implementation.
274 */
275class ATL_NO_VTABLE GuestSession :
276 public GuestSessionWrap,
277 public GuestBase
278{
279public:
280 /** @name COM and internal init/term/mapping cruft.
281 * @{ */
282 DECLARE_EMPTY_CTOR_DTOR(GuestSession)
283
284 int init(Guest *pGuest, const GuestSessionStartupInfo &ssInfo, const GuestCredentials &guestCreds);
285 void uninit(void);
286 HRESULT FinalConstruct(void);
287 void FinalRelease(void);
288 /** @} */
289
290private:
291
292 /** Wrapped @name IGuestSession properties.
293 * @{ */
294 HRESULT getUser(com::Utf8Str &aUser);
295 HRESULT getDomain(com::Utf8Str &aDomain);
296 HRESULT getName(com::Utf8Str &aName);
297 HRESULT getId(ULONG *aId);
298 HRESULT getTimeout(ULONG *aTimeout);
299 HRESULT setTimeout(ULONG aTimeout);
300 HRESULT getProtocolVersion(ULONG *aProtocolVersion);
301 HRESULT getStatus(GuestSessionStatus_T *aStatus);
302 HRESULT getEnvironmentChanges(std::vector<com::Utf8Str> &aEnvironmentChanges);
303 HRESULT setEnvironmentChanges(const std::vector<com::Utf8Str> &aEnvironmentChanges);
304 HRESULT getEnvironmentBase(std::vector<com::Utf8Str> &aEnvironmentBase);
305 HRESULT getProcesses(std::vector<ComPtr<IGuestProcess> > &aProcesses);
306 HRESULT getPathStyle(PathStyle_T *aPathStyle);
307 HRESULT getCurrentDirectory(com::Utf8Str &aCurrentDirectory);
308 HRESULT setCurrentDirectory(const com::Utf8Str &aCurrentDirectory);
309 HRESULT getDirectories(std::vector<ComPtr<IGuestDirectory> > &aDirectories);
310 HRESULT getFiles(std::vector<ComPtr<IGuestFile> > &aFiles);
311 HRESULT getEventSource(ComPtr<IEventSource> &aEventSource);
312 /** @} */
313
314 /** Wrapped @name IGuestSession methods.
315 * @{ */
316 HRESULT close();
317
318 HRESULT directoryCopy(const com::Utf8Str &aSource,
319 const com::Utf8Str &aDestination,
320 const std::vector<DirectoryCopyFlags_T> &aFlags,
321 ComPtr<IProgress> &aProgress);
322 HRESULT directoryCopyFromGuest(const com::Utf8Str &aSource,
323 const com::Utf8Str &aDestination,
324 const std::vector<DirectoryCopyFlags_T> &aFlags,
325 ComPtr<IProgress> &aProgress);
326 HRESULT directoryCopyToGuest(const com::Utf8Str &aSource,
327 const com::Utf8Str &aDestination,
328 const std::vector<DirectoryCopyFlags_T> &aFlags,
329 ComPtr<IProgress> &aProgress);
330 HRESULT directoryCreate(const com::Utf8Str &aPath,
331 ULONG aMode,
332 const std::vector<DirectoryCreateFlag_T> &aFlags);
333 HRESULT directoryCreateTemp(const com::Utf8Str &aTemplateName,
334 ULONG aMode,
335 const com::Utf8Str &aPath,
336 BOOL aSecure,
337 com::Utf8Str &aDirectory);
338 HRESULT directoryExists(const com::Utf8Str &aPath,
339 BOOL aFollowSymlinks,
340 BOOL *aExists);
341 HRESULT directoryOpen(const com::Utf8Str &aPath,
342 const com::Utf8Str &aFilter,
343 const std::vector<DirectoryOpenFlag_T> &aFlags,
344 ComPtr<IGuestDirectory> &aDirectory);
345 HRESULT directoryRemove(const com::Utf8Str &aPath);
346 HRESULT directoryRemoveRecursive(const com::Utf8Str &aPath,
347 const std::vector<DirectoryRemoveRecFlag_T> &aFlags,
348 ComPtr<IProgress> &aProgress);
349 HRESULT environmentScheduleSet(const com::Utf8Str &aName,
350 const com::Utf8Str &aValue);
351 HRESULT environmentScheduleUnset(const com::Utf8Str &aName);
352 HRESULT environmentGetBaseVariable(const com::Utf8Str &aName,
353 com::Utf8Str &aValue);
354 HRESULT environmentDoesBaseVariableExist(const com::Utf8Str &aName,
355 BOOL *aExists);
356
357 HRESULT fileCopy(const com::Utf8Str &aSource,
358 const com::Utf8Str &aDestination,
359 const std::vector<FileCopyFlag_T> &aFlags,
360 ComPtr<IProgress> &aProgress);
361 HRESULT fileCopyToGuest(const com::Utf8Str &aSource,
362 const com::Utf8Str &aDestination,
363 const std::vector<FileCopyFlag_T> &aFlags,
364 ComPtr<IProgress> &aProgress);
365 HRESULT fileCopyFromGuest(const com::Utf8Str &aSource,
366 const com::Utf8Str &aDestination,
367 const std::vector<FileCopyFlag_T> &aFlags,
368 ComPtr<IProgress> &aProgress);
369 HRESULT fileCreateTemp(const com::Utf8Str &aTemplateName,
370 ULONG aMode,
371 const com::Utf8Str &aPath,
372 BOOL aSecure,
373 ComPtr<IGuestFile> &aFile);
374 HRESULT fileExists(const com::Utf8Str &aPath,
375 BOOL aFollowSymlinks,
376 BOOL *aExists);
377 HRESULT fileOpen(const com::Utf8Str &aPath,
378 FileAccessMode_T aAccessMode,
379 FileOpenAction_T aOpenAction,
380 ULONG aCreationMode,
381 ComPtr<IGuestFile> &aFile);
382 HRESULT fileOpenEx(const com::Utf8Str &aPath,
383 FileAccessMode_T aAccessMode,
384 FileOpenAction_T aOpenAction,
385 FileSharingMode_T aSharingMode,
386 ULONG aCreationMode,
387 const std::vector<FileOpenExFlags_T> &aFlags,
388 ComPtr<IGuestFile> &aFile);
389 HRESULT fileQuerySize(const com::Utf8Str &aPath,
390 BOOL aFollowSymlinks,
391 LONG64 *aSize);
392 HRESULT fsObjExists(const com::Utf8Str &aPath,
393 BOOL aFollowSymlinks,
394 BOOL *pfExists);
395 HRESULT fsObjQueryInfo(const com::Utf8Str &aPath,
396 BOOL aFollowSymlinks,
397 ComPtr<IGuestFsObjInfo> &aInfo);
398 HRESULT fsObjRemove(const com::Utf8Str &aPath);
399 HRESULT fsObjRename(const com::Utf8Str &aOldPath,
400 const com::Utf8Str &aNewPath,
401 const std::vector<FsObjRenameFlag_T> &aFlags);
402 HRESULT fsObjMove(const com::Utf8Str &aSource,
403 const com::Utf8Str &aDestination,
404 const std::vector<FsObjMoveFlags_T> &aFlags,
405 ComPtr<IProgress> &aProgress);
406 HRESULT fsObjSetACL(const com::Utf8Str &aPath,
407 BOOL aFollowSymlinks,
408 const com::Utf8Str &aAcl,
409 ULONG aMode);
410 HRESULT processCreate(const com::Utf8Str &aCommand,
411 const std::vector<com::Utf8Str> &aArguments,
412 const std::vector<com::Utf8Str> &aEnvironment,
413 const std::vector<ProcessCreateFlag_T> &aFlags,
414 ULONG aTimeoutMS,
415 ComPtr<IGuestProcess> &aGuestProcess);
416 HRESULT processCreateEx(const com::Utf8Str &aCommand,
417 const std::vector<com::Utf8Str> &aArguments,
418 const std::vector<com::Utf8Str> &aEnvironment,
419 const std::vector<ProcessCreateFlag_T> &aFlags,
420 ULONG aTimeoutMS,
421 ProcessPriority_T aPriority,
422 const std::vector<LONG> &aAffinity,
423 ComPtr<IGuestProcess> &aGuestProcess);
424 HRESULT processGet(ULONG aPid,
425 ComPtr<IGuestProcess> &aGuestProcess);
426 HRESULT symlinkCreate(const com::Utf8Str &aSource,
427 const com::Utf8Str &aTarget,
428 SymlinkType_T aType);
429 HRESULT symlinkExists(const com::Utf8Str &aSymlink,
430 BOOL *aExists);
431 HRESULT symlinkRead(const com::Utf8Str &aSymlink,
432 const std::vector<SymlinkReadFlag_T> &aFlags,
433 com::Utf8Str &aTarget);
434 HRESULT waitFor(ULONG aWaitFor,
435 ULONG aTimeoutMS,
436 GuestSessionWaitResult_T *aReason);
437 HRESULT waitForArray(const std::vector<GuestSessionWaitForFlag_T> &aWaitFor,
438 ULONG aTimeoutMS,
439 GuestSessionWaitResult_T *aReason);
440 /** @} */
441
442 /** Map of guest directories. The key specifies the internal directory ID. */
443 typedef std::map <uint32_t, ComObjPtr<GuestDirectory> > SessionDirectories;
444 /** Map of guest files. The key specifies the internal file ID. */
445 typedef std::map <uint32_t, ComObjPtr<GuestFile> > SessionFiles;
446 /** Map of guest processes. The key specifies the internal process number.
447 * To retrieve the process' guest PID use the Id() method of the IProcess interface. */
448 typedef std::map <uint32_t, ComObjPtr<GuestProcess> > SessionProcesses;
449
450public:
451 /** @name Public internal methods.
452 * @todo r=bird: Most of these are public for no real reason...
453 * @{ */
454 int i_closeSession(uint32_t uFlags, uint32_t uTimeoutMS, int *pGuestRc);
455 inline bool i_directoryExists(uint32_t uDirID, ComObjPtr<GuestDirectory> *pDir);
456 int i_directoryRemoveFromList(GuestDirectory *pDirectory);
457 int i_directoryRemoveInternal(const Utf8Str &strPath, uint32_t uFlags, int *pGuestRc);
458 int i_directoryCreateInternal(const Utf8Str &strPath, uint32_t uMode, uint32_t uFlags, int *pGuestRc);
459 int i_objectCreateTempInternal(const Utf8Str &strTemplate, const Utf8Str &strPath, bool fDirectory,
460 Utf8Str &strName, int *pGuestRc);
461 int i_directoryOpenInternal(const GuestDirectoryOpenInfo &openInfo,
462 ComObjPtr<GuestDirectory> &pDirectory, int *pGuestRc);
463 int i_directoryQueryInfoInternal(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pGuestRc);
464 int i_dispatchToDirectory(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
465 int i_dispatchToFile(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
466 int i_dispatchToObject(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
467 int i_dispatchToProcess(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
468 int i_dispatchToThis(PVBOXGUESTCTRLHOSTCBCTX pCtxCb, PVBOXGUESTCTRLHOSTCALLBACK pSvcCb);
469 inline bool i_fileExists(uint32_t uFileID, ComObjPtr<GuestFile> *pFile);
470 int i_fileRemoveFromList(GuestFile *pFile);
471 int i_fileRemoveInternal(const Utf8Str &strPath, int *pGuestRc);
472 int i_fileOpenInternal(const GuestFileOpenInfo &openInfo, ComObjPtr<GuestFile> &pFile, int *pGuestRc);
473 int i_fileQueryInfoInternal(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pGuestRc);
474 int i_fileQuerySizeInternal(const Utf8Str &strPath, bool fFollowSymlinks, int64_t *pllSize, int *pGuestRc);
475 int i_fsQueryInfoInternal(const Utf8Str &strPath, bool fFollowSymlinks, GuestFsObjData &objData, int *pGuestRc);
476 const GuestCredentials &i_getCredentials(void);
477 EventSource *i_getEventSource(void) { return mEventSource; }
478 Utf8Str i_getName(void);
479 ULONG i_getId(void) { return mData.mSession.mID; }
480 static Utf8Str i_guestErrorToString(int guestRc);
481 HRESULT i_isReadyExternal(void);
482 int i_onRemove(void);
483 int i_onSessionStatusChange(PVBOXGUESTCTRLHOSTCBCTX pCbCtx, PVBOXGUESTCTRLHOSTCALLBACK pSvcCbData);
484 int i_startSessionInternal(int *pGuestRc);
485 int i_startSessionAsync(void);
486 static DECLCALLBACK(int)
487 i_startSessionThread(RTTHREAD Thread, void *pvUser);
488 Guest *i_getParent(void) { return mParent; }
489 uint32_t i_getProtocolVersion(void) { return mData.mProtocolVersion; }
490 int i_pathRenameInternal(const Utf8Str &strSource, const Utf8Str &strDest, uint32_t uFlags,
491 int *pGuestRc);
492 int i_processRemoveFromList(GuestProcess *pProcess);
493 int i_processCreateExInternal(GuestProcessStartupInfo &procInfo, ComObjPtr<GuestProcess> &pProgress);
494 inline bool i_processExists(uint32_t uProcessID, ComObjPtr<GuestProcess> *pProcess);
495 inline int i_processGetByPID(ULONG uPID, ComObjPtr<GuestProcess> *pProcess);
496 int i_sendCommand(uint32_t uFunction, uint32_t uParms, PVBOXHGCMSVCPARM paParms);
497 static HRESULT i_setErrorExternal(VirtualBoxBase *pInterface, int guestRc);
498 int i_setSessionStatus(GuestSessionStatus_T sessionStatus, int sessionRc);
499 int i_signalWaiters(GuestSessionWaitResult_T enmWaitResult, int rc /*= VINF_SUCCESS */);
500 int i_startTaskAsync(const Utf8Str &strTaskDesc, GuestSessionTask *pTask,
501 ComObjPtr<Progress> &pProgress);
502 int i_determineProtocolVersion(void);
503 int i_waitFor(uint32_t fWaitFlags, ULONG uTimeoutMS, GuestSessionWaitResult_T &waitResult, int *pGuestRc);
504 int i_waitForStatusChange(GuestWaitEvent *pEvent, uint32_t fWaitFlags, uint32_t uTimeoutMS,
505 GuestSessionStatus_T *pSessionStatus, int *pGuestRc);
506 /** @} */
507
508private:
509
510 /** Pointer to the parent (Guest). */
511 Guest *mParent;
512 /**
513 * The session's event source. This source is used for
514 * serving the internal listener as well as all other
515 * external listeners that may register to it.
516 *
517 * Note: This can safely be used without holding any locks.
518 * An AutoCaller suffices to prevent it being destroy while in use and
519 * internally there is a lock providing the necessary serialization.
520 */
521 const ComObjPtr<EventSource> mEventSource;
522
523 struct Data
524 {
525 /** The session credentials. */
526 GuestCredentials mCredentials;
527 /** The session's startup info. */
528 GuestSessionStartupInfo mSession;
529 /** The session's current status. */
530 GuestSessionStatus_T mStatus;
531 /** The set of environment changes for the session for use when
532 * creating new guest processes. */
533 GuestEnvironmentChanges mEnvironmentChanges;
534 /** Pointer to the immutable base environment for the session.
535 * @note This is not allocated until the guest reports it to the host. It is
536 * also shared with child processes. */
537 GuestEnvironment const *mpBaseEnvironment;
538 /** Directory objects bound to this session. */
539 SessionDirectories mDirectories;
540 /** File objects bound to this session. */
541 SessionFiles mFiles;
542 /** Process objects bound to this session. */
543 SessionProcesses mProcesses;
544 /** Guest control protocol version to be used.
545 * Guest Additions < VBox 4.3 have version 1,
546 * any newer version will have version 2. */
547 uint32_t mProtocolVersion;
548 /** Session timeout (in ms). */
549 uint32_t mTimeout;
550 /** Total number of session objects (processes,
551 * files, ...). */
552 uint32_t mNumObjects;
553 /** The last returned session status
554 * returned from the guest side. */
555 int mRC;
556
557 Data(void)
558 : mpBaseEnvironment(NULL)
559 { }
560 Data(const Data &rThat)
561 : mCredentials(rThat.mCredentials)
562 , mSession(rThat.mSession)
563 , mStatus(rThat.mStatus)
564 , mEnvironmentChanges(rThat.mEnvironmentChanges)
565 , mpBaseEnvironment(NULL)
566 , mDirectories(rThat.mDirectories)
567 , mFiles(rThat.mFiles)
568 , mProcesses(rThat.mProcesses)
569 , mProtocolVersion(rThat.mProtocolVersion)
570 , mTimeout(rThat.mTimeout)
571 , mNumObjects(rThat.mNumObjects)
572 , mRC(rThat.mRC)
573 { }
574 ~Data(void)
575 {
576 if (mpBaseEnvironment)
577 {
578 mpBaseEnvironment->releaseConst();
579 mpBaseEnvironment = NULL;
580 }
581 }
582 } mData;
583};
584
585#endif /* !____H_GUESTSESSIONIMPL */
586
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