VirtualBox

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

Last change on this file since 63470 was 63186, checked in by vboxsync, 8 years ago

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