VirtualBox

source: vbox/trunk/src/VBox/Main/SharedFolderImpl.cpp@ 16560

Last change on this file since 16560 was 16215, checked in by vboxsync, 15 years ago

Reapplied r41613.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 9.5 KB
Line 
1/** @file
2 *
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18 * Clara, CA 95054 USA or visit http://www.sun.com if you need
19 * additional information or have any questions.
20 */
21
22#include "SharedFolderImpl.h"
23#include "VirtualBoxImpl.h"
24#include "MachineImpl.h"
25#include "ConsoleImpl.h"
26
27#include "Logging.h"
28
29#include <iprt/param.h>
30#include <iprt/path.h>
31#include <iprt/cpputils.h>
32
33// constructor / destructor
34/////////////////////////////////////////////////////////////////////////////
35
36SharedFolder::SharedFolder()
37 : mParent (NULL)
38{
39}
40
41SharedFolder::~SharedFolder()
42{
43}
44
45HRESULT SharedFolder::FinalConstruct()
46{
47 return S_OK;
48}
49
50void SharedFolder::FinalRelease()
51{
52 uninit();
53}
54
55// public initializer/uninitializer for internal purposes only
56/////////////////////////////////////////////////////////////////////////////
57
58/**
59 * Initializes the shared folder object.
60 *
61 * @param aMachine parent Machine object
62 * @param aName logical name of the shared folder
63 * @param aHostPath full path to the shared folder on the host
64 * @param aWritable writable if true, readonly otherwise
65 *
66 * @return COM result indicator
67 */
68HRESULT SharedFolder::init (Machine *aMachine,
69 CBSTR aName, CBSTR aHostPath, BOOL aWritable)
70{
71 /* Enclose the state transition NotReady->InInit->Ready */
72 AutoInitSpan autoInitSpan (this);
73 AssertReturn (autoInitSpan.isOk(), E_FAIL);
74
75 unconst (mMachine) = aMachine;
76
77 HRESULT rc = protectedInit (aMachine, aName, aHostPath, aWritable);
78
79 /* Confirm a successful initialization when it's the case */
80 if (SUCCEEDED (rc))
81 autoInitSpan.setSucceeded();
82
83 return rc;
84}
85
86/**
87 * Initializes the shared folder object given another object
88 * (a kind of copy constructor). This object makes a private copy of data
89 * of the original object passed as an argument.
90 *
91 * @param aMachine parent Machine object
92 * @param aThat shared folder object to copy
93 *
94 * @return COM result indicator
95 */
96HRESULT SharedFolder::initCopy (Machine *aMachine, SharedFolder *aThat)
97{
98 ComAssertRet (aThat, E_INVALIDARG);
99
100 /* Enclose the state transition NotReady->InInit->Ready */
101 AutoInitSpan autoInitSpan (this);
102 AssertReturn (autoInitSpan.isOk(), E_FAIL);
103
104 unconst (mMachine) = aMachine;
105
106 HRESULT rc = protectedInit (aMachine, aThat->m.name,
107 aThat->m.hostPath, aThat->m.writable);
108
109 /* Confirm a successful initialization when it's the case */
110 if (SUCCEEDED (rc))
111 autoInitSpan.setSucceeded();
112
113 return rc;
114}
115
116/**
117 * Initializes the shared folder object.
118 *
119 * @param aConsole Console parent object
120 * @param aName logical name of the shared folder
121 * @param aHostPath full path to the shared folder on the host
122 * @param aWritable writable if true, readonly otherwise
123 *
124 * @return COM result indicator
125 */
126HRESULT SharedFolder::init (Console *aConsole,
127 CBSTR aName, CBSTR aHostPath, BOOL aWritable)
128{
129 /* Enclose the state transition NotReady->InInit->Ready */
130 AutoInitSpan autoInitSpan (this);
131 AssertReturn (autoInitSpan.isOk(), E_FAIL);
132
133 unconst (mConsole) = aConsole;
134
135 HRESULT rc = protectedInit (aConsole, aName, aHostPath, aWritable);
136
137 /* Confirm a successful initialization when it's the case */
138 if (SUCCEEDED (rc))
139 autoInitSpan.setSucceeded();
140
141 return rc;
142}
143
144/**
145 * Initializes the shared folder object.
146 *
147 * @param aVirtualBox VirtualBox parent object
148 * @param aName logical name of the shared folder
149 * @param aHostPath full path to the shared folder on the host
150 * @param aWritable writable if true, readonly otherwise
151 *
152 * @return COM result indicator
153 */
154HRESULT SharedFolder::init (VirtualBox *aVirtualBox,
155 CBSTR aName, CBSTR aHostPath, BOOL aWritable)
156{
157 /* Enclose the state transition NotReady->InInit->Ready */
158 AutoInitSpan autoInitSpan (this);
159 AssertReturn (autoInitSpan.isOk(), E_FAIL);
160
161 unconst (mVirtualBox) = aVirtualBox;
162
163 HRESULT rc = protectedInit (aVirtualBox, aName, aHostPath, aWritable);
164
165 /* Confirm a successful initialization when it's the case */
166 if (SUCCEEDED (rc))
167 autoInitSpan.setSucceeded();
168
169 return rc;
170}
171
172/**
173 * Helper for init() methods.
174 *
175 * @note
176 * Must be called from under the object's lock!
177 */
178HRESULT SharedFolder::protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
179 CBSTR aName, CBSTR aHostPath, BOOL aWritable)
180{
181 LogFlowThisFunc (("aName={%ls}, aHostPath={%ls}, aWritable={%d}\n",
182 aName, aHostPath, aWritable));
183
184 ComAssertRet (aParent && aName && aHostPath, E_INVALIDARG);
185
186 Utf8Str hostPath = Utf8Str (aHostPath);
187 size_t hostPathLen = hostPath.length();
188
189 /* Remove the trailing slash unless it's a root directory
190 * (otherwise the comparison with the RTPathAbs() result will fail at least
191 * on Linux). Note that this isn't really necessary for the shared folder
192 * itself, since adding a mapping eventually results into a
193 * RTDirOpenFiltered() call (see HostServices/SharedFolders) that seems to
194 * accept both the slashified paths and not. */
195#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
196 if (hostPathLen > 2 &&
197 RTPATH_IS_SEP (hostPath.raw()[hostPathLen - 1]) &&
198 RTPATH_IS_VOLSEP (hostPath.raw()[hostPathLen - 2]))
199 ;
200#else
201 if (hostPathLen == 1 && RTPATH_IS_SEP (hostPath[0]))
202 ;
203#endif
204 else
205 RTPathStripTrailingSlash (hostPath.mutableRaw());
206
207 /* Check whether the path is full (absolute) */
208 char hostPathFull [RTPATH_MAX];
209 int vrc = RTPathAbsEx (NULL, hostPath,
210 hostPathFull, sizeof (hostPathFull));
211 if (RT_FAILURE (vrc))
212 return setError (E_INVALIDARG,
213 tr ("Invalid shared folder path: '%s' (%Rrc)"), hostPath.raw(), vrc);
214
215 if (RTPathCompare (hostPath, hostPathFull) != 0)
216 return setError (E_INVALIDARG,
217 tr ("Shared folder path '%s' is not absolute"), hostPath.raw());
218
219 unconst (mParent) = aParent;
220
221 /* register with parent */
222 mParent->addDependentChild (this);
223
224 unconst (m.name) = aName;
225 unconst (m.hostPath) = hostPath;
226 m.writable = aWritable;
227
228 return S_OK;
229}
230
231/**
232 * Uninitializes the instance and sets the ready flag to FALSE.
233 * Called either from FinalRelease() or by the parent when it gets destroyed.
234 */
235void SharedFolder::uninit()
236{
237 LogFlowThisFunc (("\n"));
238
239 /* Enclose the state transition Ready->InUninit->NotReady */
240 AutoUninitSpan autoUninitSpan (this);
241 if (autoUninitSpan.uninitDone())
242 return;
243
244 if (mParent)
245 mParent->removeDependentChild (this);
246
247 unconst (mParent) = NULL;
248
249 unconst (mMachine).setNull();
250 unconst (mConsole).setNull();
251 unconst (mVirtualBox).setNull();
252}
253
254// ISharedFolder properties
255/////////////////////////////////////////////////////////////////////////////
256
257STDMETHODIMP SharedFolder::COMGETTER(Name) (BSTR *aName)
258{
259 CheckComArgOutPointerValid(aName);
260
261 AutoCaller autoCaller (this);
262 CheckComRCReturnRC (autoCaller.rc());
263
264 /* mName is constant during life time, no need to lock */
265 m.name.cloneTo (aName);
266
267 return S_OK;
268}
269
270STDMETHODIMP SharedFolder::COMGETTER(HostPath) (BSTR *aHostPath)
271{
272 CheckComArgOutPointerValid(aHostPath);
273
274 AutoCaller autoCaller (this);
275 CheckComRCReturnRC (autoCaller.rc());
276
277 /* mHostPath is constant during life time, no need to lock */
278 m.hostPath.cloneTo (aHostPath);
279
280 return S_OK;
281}
282
283STDMETHODIMP SharedFolder::COMGETTER(Accessible) (BOOL *aAccessible)
284{
285 CheckComArgOutPointerValid (aAccessible);
286
287 AutoCaller autoCaller (this);
288 CheckComRCReturnRC (autoCaller.rc());
289
290 /* mName and mHostPath are constant during life time, no need to lock */
291
292 /* check whether the host path exists */
293 Utf8Str hostPath = Utf8Str (m.hostPath);
294 char hostPathFull [RTPATH_MAX];
295 int vrc = RTPathExists (hostPath) ? RTPathReal (hostPath, hostPathFull,
296 sizeof (hostPathFull))
297 : VERR_PATH_NOT_FOUND;
298 if (RT_SUCCESS (vrc))
299 {
300 *aAccessible = TRUE;
301 return S_OK;
302 }
303
304 AutoWriteLock alock (this);
305
306 m.lastAccessError = BstrFmt (
307 tr ("'%s' is not accessible (%Rrc)"), hostPath.raw(), vrc);
308
309 LogWarningThisFunc (("m.lastAccessError=\"%ls\"\n", m.lastAccessError.raw()));
310
311 *aAccessible = FALSE;
312 return S_OK;
313}
314
315STDMETHODIMP SharedFolder::COMGETTER(Writable) (BOOL *aWritable)
316{
317 CheckComArgOutPointerValid(aWritable);
318
319 *aWritable = m.writable;
320
321 return S_OK;
322}
323
324STDMETHODIMP SharedFolder::COMGETTER(LastAccessError) (BSTR *aLastAccessError)
325{
326 CheckComArgOutPointerValid (aLastAccessError);
327
328 AutoCaller autoCaller (this);
329 CheckComRCReturnRC (autoCaller.rc());
330
331 AutoReadLock alock (this);
332
333 m.lastAccessError.cloneTo (aLastAccessError);
334
335 return S_OK;
336}
337
338/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
ContactPrivacy policyTerms of Use