Changeset 6379 in vbox for trunk/src/VBox

Timestamp:

Jan 18, 2008 5:25:20 PM (17 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

27322

Message:

support read-only shared folders

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManage.cpp (modified) (7 diffs)
• Frontends/VirtualBox/ui/VBoxSharedFoldersSettings.ui (modified) (1 diff)
• Frontends/VirtualBox/ui/VBoxSharedFoldersSettings.ui.h (modified) (4 diffs)
• HostServices/SharedFolders/mappings.cpp (modified) (3 diffs)
• HostServices/SharedFolders/mappings.h (modified) (2 diffs)
• HostServices/SharedFolders/service.cpp (modified) (3 diffs)
• HostServices/SharedFolders/vbsf.cpp (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (15 diffs)
• Main/MachineImpl.cpp (modified) (4 diffs)
• Main/SharedFolderImpl.cpp (modified) (10 diffs)
• Main/VirtualBoxImpl.cpp (modified) (1 diff)
• Main/idl/VirtualBox.xidl (modified) (4 diffs)
• Main/include/ConsoleImpl.h (modified) (3 diffs)
• Main/include/MachineImpl.h (modified) (1 diff)
• Main/include/SharedFolderImpl.h (modified) (5 diffs)
• Main/include/VirtualBoxImpl.h (modified) (1 diff)
• Main/xml/VirtualBox-settings-common.xsd (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

@@ -592 +592 @@
         RTPrintf("VBoxManage sharedfolder     add <vmname>|<uuid>\n"
                  "                            -name <name> -hostpath <hostpath>\n"
-                 "                            [-transient]\n"
+                 "                            [-transient] [-readonly]\n"
                  "\n");
     }
@@ -1907 +1907 @@
             CHECK_ERROR_RET(sfEnum, GetNext(sf.asOutParam()), rc);
             Bstr name, hostPath;
+            BOOL writable;
             sf->COMGETTER(Name)(name.asOutParam());
             sf->COMGETTER(HostPath)(hostPath.asOutParam());
+            sf->COMGETTER(Writable)(&writable);
             if (!numSharedFolders && details != VMINFO_MACHINEREADABLE)
                 RTPrintf("\n\n");
@@ -1919 +1921 @@
             }
             else
-                RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping)\n", name.raw(), hostPath.raw());
+                RTPrintf("Name: '%lS', Host path: '%lS' (machine mapping), %s\n",
+                         name.raw(), hostPath.raw(), writable ? "writable" : "readonly");
             ++numSharedFolders;
             CHECK_ERROR_RET(sfEnum, HasMore(&fMore), rc);
@@ -7022 +7025 @@
         char *hostpath = NULL;
         bool fTransient = false;
+        bool fWritable = true;
 
         for (int i = 2; i < argc; i++)
@@ -7042 +7046 @@
                 i++;
                 hostpath = argv[i];
-
+            }
+            else if (strcmp(argv[i], "-readonly") == 0)
+            {
+                fWritable = false;
             }
             else if (strcmp(argv[i], "-transient") == 0)
@@ -7071 +7078 @@
             CHECK_ERROR_RET(aSession, COMGETTER(Console)(console.asOutParam()), 1);
 
-            CHECK_ERROR(console, CreateSharedFolder(Bstr(name), Bstr(hostpath)));
+            CHECK_ERROR(console, CreateSharedFolder(Bstr(name), Bstr(hostpath), fWritable));
 
             if (console)
@@ -7084 +7091 @@
             aSession->COMGETTER(Machine)(machine.asOutParam());
 
-            CHECK_ERROR(machine, CreateSharedFolder(Bstr(name), Bstr(hostpath)));
+            CHECK_ERROR(machine, CreateSharedFolder(Bstr(name), Bstr(hostpath), fWritable));
 
             if (SUCCEEDED(rc))

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxSharedFoldersSettings.ui

@@ -241 +241 @@
     <function returnType="int">dialogType() {return mDialogType;}</function>
     <function access="private">removeSharedFolder( const QString &amp;, const QString &amp;, VBoxSharedFoldersSettings::SFDialogType )</function>
-    <function access="private">createSharedFolder( const QString &amp;, const QString &amp;, VBoxSharedFoldersSettings::SFDialogType )</function>
+    <function access="private">createSharedFolder( const QString &amp;, const QString &amp;, bool, VBoxSharedFoldersSettings::SFDialogType )</function>
     <function>getFromGlobal()</function>
     <function>getFromMachine( const CMachine &amp; )</function>

trunk/src/VBox/Frontends/VirtualBox/ui/VBoxSharedFoldersSettings.ui.h

@@ -404 +404 @@
 void VBoxSharedFoldersSettings::createSharedFolder (const QString & aName,
                                                     const QString & aPath,
+                                                    bool aWritable,
                                                     SFDialogType aType)
 {
@@ -417 +418 @@
         {
             Assert (!mMachine.isNull());
-            mMachine.CreateSharedFolder (aName, aPath);
+            mMachine.CreateSharedFolder (aName, aPath, aWritable);
             if (!mMachine.isOk())
                 vboxProblem().cannotCreateSharedFolder (this, mMachine,
@@ -426 +427 @@
         {
             Assert (!mConsole.isNull());
-            mConsole.CreateSharedFolder (aName, aPath);
+            mConsole.CreateSharedFolder (aName, aPath, aWritable);
             if (!mConsole.isOk())
                 vboxProblem().cannotCreateSharedFolder (this, mConsole,
@@ -573 +574 @@
         if (item && !item->getText (0).isNull() && !item->getText (1).isNull()
             && item->getText (2) == "edited")
-            createSharedFolder (item->getText (0), item->getText (1), type);
+            createSharedFolder (item->getText (0), item->getText (1), true, type);
         iterator = iterator->nextSibling();
     }

trunk/src/VBox/HostServices/SharedFolders/mappings.cpp

@@ -28 +28 @@
  *
  */
-int vbsfMappingsAdd (PSHFLSTRING pFolderName, PSHFLSTRING pMapName)
+int vbsfMappingsAdd (PSHFLSTRING pFolderName, PSHFLSTRING pMapName, uint32_t fWritable)
 {
     int i;
@@ -73 +73 @@
             FolderMapping[i].fValid    = true;
             FolderMapping[i].cMappings = 0;
+            FolderMapping[i].fWritable = fWritable;
 
             /* Check if the host file system is case sensitive */
@@ -232 +233 @@
 }
 
+int vbsfMappingsQueryWritable (SHFLCLIENTDATA *pClient, SHFLROOT root, bool *fWritable)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlow(("vbsfMappingsQueryWritable: pClient = %p, root = %d\n",
+             pClient, root));
+
+    if (root >= SHFL_MAX_MAPPINGS)
+        return VERR_INVALID_PARAMETER;
+
+    if (FolderMapping[root].fValid == true)
+        *fWritable = FolderMapping[root].fWritable;
+    else
+        rc = VERR_FILE_NOT_FOUND;
+
+    LogFlow(("vbsfMappingsQuery:Writable return rc = %Vrc\n", rc));
+
+    return rc;
+}
+
 static int vbsfQueryMappingIndex (PRTUTF16 utf16Name, size_t *pIndex)
 {

trunk/src/VBox/HostServices/SharedFolders/mappings.h

@@ -31 +31 @@
     bool        fHostCaseSensitive;
     bool        fGuestCaseSensitive;
+    bool        fWritable;
 } MAPPING, *PMAPPING;
 
@@ -37 +38 @@
 bool vbsfMappingQuery(uint32_t iMapping, PMAPPING *pMapping);
 
-int vbsfMappingsAdd (PSHFLSTRING pFolderName, PSHFLSTRING pMapName);
+int vbsfMappingsAdd (PSHFLSTRING pFolderName, PSHFLSTRING pMapName, uint32_t fWritable);
 int vbsfMappingsRemove (PSHFLSTRING pMapName);
 
 int vbsfMappingsQuery (SHFLCLIENTDATA *pClient, SHFLMAPPING *pMappings, uint32_t *pcMappings);
 int vbsfMappingsQueryName (SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pString);
+int vbsfMappingsQueryWritable (SHFLCLIENTDATA *pClient, SHFLROOT root, bool *fWritable);
 
 int vbsfMapFolder (SHFLCLIENTDATA *pClient, PSHFLSTRING pszMapName, RTUCS2 delimiter, bool fCaseSensitive, SHFLROOT *pRoot);

trunk/src/VBox/HostServices/SharedFolders/service.cpp

@@ -1097 +1097 @@
         else if (   paParms[0].type != VBOX_HGCM_SVC_PARM_PTR     /* host folder name */
                  || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR     /* guest map name */
+                 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT   /* fWritable */
                 )
         {
@@ -1108 +1109 @@
             SHFLSTRING *pMapName    = (SHFLSTRING *)paParms[1].u.pointer.addr;
             uint32_t cbStringMap    = paParms[1].u.pointer.size;
+            uint32_t fWritable      = paParms[2].u.uint32;
 
             /* Verify parameters values. */
@@ -1121 +1123 @@
             {
                 /* Execute the function. */
-                rc = vbsfMappingsAdd (pFolderName, pMapName);
+                rc = vbsfMappingsAdd (pFolderName, pMapName, fWritable);
 
                 if (VBOX_SUCCESS(rc))

trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp

@@ -1018 +1018 @@
                 }
             }
+
+            /* write access requested? */
+            if (pParms->CreateFlags & (  SHFL_CF_ACT_REPLACE_IF_EXISTS
+                                       | SHFL_CF_ACT_OVERWRITE_IF_EXISTS
+                                       | SHFL_CF_ACT_CREATE_IF_NEW
+                                       | SHFL_CF_ACCESS_WRITE))
+            {
+                /* is the guest allowed to write to this share? */
+                bool fWritable;
+                rc = vbsfMappingsQueryWritable (pClient, root, &fWritable);
+                if (RT_FAILURE(rc) || !fWritable)
+                    return VERR_WRITE_PROTECT;
+            }
+
             if (BIT_FLAG(pParms->CreateFlags, SHFL_CF_DIRECTORY))
             {

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -882 +882 @@
         vrc = SSMR3PutStrZ (pSSM, hostPath);
         AssertRC (vrc);
+
+//        XXX
+//        vrc = SSMR3PutBool (pSSM, folder->writable());
+//        AssertRC (vrc);
     }
 
@@ -953 +957 @@
         ComObjPtr <SharedFolder> sharedFolder;
         sharedFolder.createObject();
-        HRESULT rc = sharedFolder->init (that, name, hostPath);
+        HRESULT rc = sharedFolder->init (that, name, hostPath, PR_TRUE); /* TODO: fWritable */
         AssertComRCReturn (rc, VERR_INTERNAL_ERROR);
 
@@ -1315 +1319 @@
         for (SharedFolderMap::const_iterator it = mSharedFolders.begin();
              it != mSharedFolders.end(); ++ it)
-            sharedFolders [it->first] = it->second->hostPath();
+            sharedFolders [it->first] = SharedFolderData(it->second->hostPath(), it->second->writable());
     }
 
@@ -1991 +1995 @@
 
 STDMETHODIMP
-Console::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
+Console::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable)
 {
     if (!aName || !aHostPath)
@@ -2019 +2023 @@
 
     sharedFolder.createObject();
-    rc = sharedFolder->init (this, aName, aHostPath);
+    rc = sharedFolder->init (this, aName, aHostPath, aWritable);
     CheckComRCReturnRC (rc);
 
@@ -2047 +2051 @@
 
         /* second, create the given folder */
-        rc = createSharedFolder (aName, aHostPath);
+        rc = createSharedFolder (aName, SharedFolderData (aHostPath, aWritable));
         CheckComRCReturnRC (rc);
     }
@@ -4195 +4199 @@
             Bstr name;
             Bstr hostPath;
+            BOOL writable;
 
             rc = folder->COMGETTER(Name) (name.asOutParam());
@@ -4200 +4205 @@
             rc = folder->COMGETTER(HostPath) (hostPath.asOutParam());
             CheckComRCBreakRC (rc);
-
-            mMachineSharedFolders.insert (std::make_pair (name, hostPath));
+            rc = folder->COMGETTER(Writable) (&writable);
+
+            mMachineSharedFolders.insert (std::make_pair (name, SharedFolderData (hostPath, writable)));
 
             /* send changes to HGCM if the VM is running */
@@ -4208 +4214 @@
             {
                 SharedFolderDataMap::iterator it = oldFolders.find (name);
-                if (it == oldFolders.end() || it->second != hostPath)
+                if (it == oldFolders.end() || it->second.mHostPath != hostPath)
                 {
                     /* a new machine folder is added or
@@ -4223 +4229 @@
                             rc = removeSharedFolder (name);
                         /* create the new machine folder */
-                        rc = createSharedFolder (name, hostPath);
+                        rc = createSharedFolder (name, SharedFolderData (hostPath, writable));
                     }
                 }
@@ -4302 +4308 @@
  *  @note Doesn't lock anything.
  */
-HRESULT Console::createSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
+HRESULT Console::createSharedFolder (INPTR BSTR aName, SharedFolderData aData)
 {
     ComAssertRet (aName && *aName, E_FAIL);
-    ComAssertRet (aHostPath && *aHostPath, E_FAIL);
+    ComAssertRet (aData.mHostPath && *aData.mHostPath, E_FAIL);
 
     /* sanity checks */
@@ -4311 +4317 @@
     AssertReturn (mVMMDev->isShFlActive(), E_FAIL);
 
-    VBOXHGCMSVCPARM  parms[2];
+    VBOXHGCMSVCPARM  parms[SHFL_CPARMS_ADD_MAPPING];
     SHFLSTRING      *pFolderName, *pMapName;
     size_t           cbString;
@@ -4317 +4323 @@
     Log (("Adding shared folder '%ls' -> '%ls'\n", aName, aHostPath));
 
-    cbString = (RTStrUcs2Len (aHostPath) + 1) * sizeof (RTUCS2);
+    cbString = (RTStrUcs2Len (aData.mHostPath) + 1) * sizeof (RTUCS2);
     if (cbString >= UINT16_MAX)
         return setError (E_INVALIDARG, tr ("The name is too long"));
     pFolderName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
     Assert (pFolderName);
-    memcpy (pFolderName->String.ucs2, aHostPath, cbString);
+    memcpy (pFolderName->String.ucs2, aData.mHostPath, cbString);
 
     pFolderName->u16Size   = (uint16_t)cbString;
@@ -4348 +4354 @@
     parms[1].u.pointer.size = sizeof (SHFLSTRING) + (uint16_t)cbString;
 
+    parms[2].type = VBOX_HGCM_SVC_PARM_32BIT;
+    parms[2].u.uint32 = aData.mWritable;
+
     int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
                                      SHFL_FN_ADD_MAPPING,
-                                     2, &parms[0]);
+                                     SHFL_CPARMS_ADD_MAPPING, &parms[0]);
     RTMemFree (pFolderName);
     RTMemFree (pMapName);
@@ -4358 +4367 @@
                          tr ("Could not create a shared folder '%ls' "
                              "mapped to '%ls' (%Vrc)"),
-                         aName, aHostPath, vrc);
+                         aName, aData.mHostPath.raw(), vrc);
 
     return S_OK;

trunk/src/VBox/Main/MachineImpl.cpp

@@ -2372 +2372 @@
 
 STDMETHODIMP
-Machine::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
+Machine::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable)
 {
     if (!aName || !aHostPath)
@@ -2392 +2392 @@
 
     sharedFolder.createObject();
-    rc = sharedFolder->init (machine(), aName, aHostPath);
+    rc = sharedFolder->init (machine(), aName, aHostPath, aWritable);
     CheckComRCReturnRC (rc);
 
@@ -4314 +4314 @@
                 Bstr hostPath = (*it).stringValue ("hostPath");
 
-                rc = CreateSharedFolder (name, hostPath);
+                bool writable = (*it).value <bool> ("writable");
+
+                rc = CreateSharedFolder (name, hostPath, writable);
                 CheckComRCReturnRC (rc);
             }
@@ -5661 +5663 @@
             folderNode.setValue <Bstr> ("name", folder->name());
             folderNode.setValue <Bstr> ("hostPath", folder->hostPath());
+            folderNode.setValue <bool> ("writable", folder->writable());
         }
     }

trunk/src/VBox/Main/SharedFolderImpl.cpp

@@ -58 +58 @@
  *  @param aName        logical name of the shared folder
  *  @param aHostPath    full path to the shared folder on the host
+ *  @param aWritable    writable if true, readonly otherwise
  *
  *  @return          COM result indicator
  */
 HRESULT SharedFolder::init (Machine *aMachine,
-                            const BSTR aName, const BSTR aHostPath)
+                            const BSTR aName, const BSTR aHostPath, bool aWritable)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -70 +71 @@
     unconst (mMachine) = aMachine;
 
-    HRESULT rc = protectedInit (aMachine, aName, aHostPath);
+    HRESULT rc = protectedInit (aMachine, aName, aHostPath, aWritable);
 
     /* Confirm a successful initialization when it's the case */
@@ -100 +101 @@
 
     HRESULT rc = protectedInit (aMachine, aThat->mData.mName,
-                                aThat->mData.mHostPath);
+                                aThat->mData.mHostPath, aThat->mData.mWritable);
 
     /* Confirm a successful initialization when it's the case */
@@ -115 +116 @@
  *  @param aName        logical name of the shared folder
  *  @param aHostPath    full path to the shared folder on the host
+ *  @param aWritable    writable if true, readonly otherwise
  *
  *  @return          COM result indicator
  */
 HRESULT SharedFolder::init (Console *aConsole,
-                            const BSTR aName, const BSTR aHostPath)
+                            const BSTR aName, const BSTR aHostPath, bool aWritable)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -127 +129 @@
     unconst (mConsole) = aConsole;
 
-    HRESULT rc = protectedInit (aConsole, aName, aHostPath);
+    HRESULT rc = protectedInit (aConsole, aName, aHostPath, aWritable);
 
     /* Confirm a successful initialization when it's the case */
@@ -142 +144 @@
  *  @param aName        logical name of the shared folder
  *  @param aHostPath    full path to the shared folder on the host
+ *  @param aWritable    writable if true, readonly otherwise
  *
  *  @return          COM result indicator
  */
 HRESULT SharedFolder::init (VirtualBox *aVirtualBox,
-                            const BSTR aName, const BSTR aHostPath)
+                            const BSTR aName, const BSTR aHostPath, bool aWritable)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -154 +157 @@
     unconst (mVirtualBox) = aVirtualBox;
 
-    HRESULT rc = protectedInit (aVirtualBox, aName, aHostPath);
+    HRESULT rc = protectedInit (aVirtualBox, aName, aHostPath, aWritable);
 
     /* Confirm a successful initialization when it's the case */
@@ -170 +173 @@
  */
 HRESULT SharedFolder::protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
-                                     const BSTR aName, const BSTR aHostPath)
-{
-    LogFlowThisFunc (("aName={%ls}, aHostPath={%ls}\n", aName, aHostPath));
+                                     const BSTR aName, const BSTR aHostPath, bool aWritable)
+{
+    LogFlowThisFunc (("aName={%ls}, aHostPath={%ls}, aWritable={%d}\n",
+                      aName, aHostPath, aWritable));
 
     ComAssertRet (aParent && aName && aHostPath, E_INVALIDARG);
@@ -216 +220 @@
     unconst (mData.mName) = aName;
     unconst (mData.mHostPath) = hostPath;
+    mData.mWritable = aWritable;
 
     return S_OK;
@@ -307 +312 @@
 }
 
+STDMETHODIMP SharedFolder::COMGETTER(Writable) (BOOL *aWritable)
+{
+    if (!aWritable)
+        return E_POINTER;
+
+    *aWritable = mData.mWritable;
+
+    return S_OK;
+}

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -1575 +1575 @@
 
 STDMETHODIMP
-VirtualBox::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
+VirtualBox::CreateSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable)
 {
     if (!aName || !aHostPath)

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -1573 +1573 @@
         <desc>Full path to the shared folder in the host file system.</desc>
       </param>
+      <param name="writable" type="boolean" dir="in">
+        <desc>Whether the share is writable or readonly</desc>
+      </param>
     </method>
 
@@ -3046 +3049 @@
         <desc>Full path to the shared folder in the host file system.</desc>
       </param>
+      <param name="writable" type="boolean" dir="in">
+        <desc>Whether the share is writable or readonly</desc>
+      </param>
     </method>
 
@@ -3901 +3907 @@
       <param name="hostPath" type="wstring" dir="in">
         <desc>Full path to the shared folder in the host file system.</desc>
+      </param>
+      <param name="writable" type="boolean" dir="in">
+        <desc>Whether the share is writable or readonly</desc>
       </param>
     </method>
@@ -9037 +9046 @@
       </desc>
     </attribute>
+    
+    <attribute name="writable" type="boolean" readonly="yes">
+      <desc>
+        Whether the folder defined by the host path is writable or
+        not.
+      </desc>
+    </attribute>
 
   </interface>

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -134 +134 @@
     STDMETHOD(AttachUSBDevice) (INPTR GUIDPARAM aId);
     STDMETHOD(DetachUSBDevice) (INPTR GUIDPARAM aId, IUSBDevice **aDevice);
-    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath);
+    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable);
     STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
     STDMETHOD(TakeSnapshot) (INPTR BSTR aName, INPTR BSTR aDescription,
@@ -353 +353 @@
     typedef SafeVMPtrBase <true> SafeVMPtrQuiet;
 
+    class SharedFolderData
+    {
+    public:
+        SharedFolderData() {}
+        SharedFolderData(Bstr aHostPath, BOOL aWritable)
+           : mHostPath (aHostPath)
+           , mWritable (aWritable) {}
+        SharedFolderData(const SharedFolderData& aThat)
+           : mHostPath (aThat.mHostPath)
+           , mWritable (aThat.mWritable) {}
+        Bstr mHostPath;
+        BOOL mWritable;
+    };
     typedef std::map <Bstr, ComObjPtr <SharedFolder> > SharedFolderMap;
-    typedef std::map <Bstr, Bstr> SharedFolderDataMap;
+    typedef std::map <Bstr, SharedFolderData> SharedFolderDataMap;
 
 private:
@@ -386 +399 @@
                                 SharedFolderDataMap::const_iterator &aIt);
 
-    HRESULT createSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath);
+    HRESULT createSharedFolder (INPTR BSTR aName, SharedFolderData aData);
     HRESULT removeSharedFolder (INPTR BSTR aName);
 

trunk/src/VBox/Main/include/MachineImpl.h

@@ -498 +498 @@
     STDMETHOD(FindSnapshot) (INPTR BSTR aName, ISnapshot **aSnapshot);
     STDMETHOD(SetCurrentSnapshot) (INPTR GUIDPARAM aId);
-    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath);
+    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable);
     STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
     STDMETHOD(CanShowConsoleWindow) (BOOL *aCanShow);

trunk/src/VBox/Main/include/SharedFolderImpl.h

@@ -41 +41 @@
         const Bstr mName;
         const Bstr mHostPath;
+        bool       mWritable;
     };
 
@@ -62 +63 @@
 
     // public initializer/uninitializer for internal purposes only
-    HRESULT init (Machine *aMachine, const BSTR aName, const BSTR aHostPath);
+    HRESULT init (Machine *aMachine, const BSTR aName, const BSTR aHostPath, bool aWritable);
     HRESULT initCopy (Machine *aMachine, SharedFolder *aThat);
-    HRESULT init (Console *aConsole, const BSTR aName, const BSTR aHostPath);
-    HRESULT init (VirtualBox *aVirtualBox, const BSTR aName, const BSTR aHostPath);
+    HRESULT init (Console *aConsole, const BSTR aName, const BSTR aHostPath, bool aWritable);
+    HRESULT init (VirtualBox *aVirtualBox, const BSTR aName, const BSTR aHostPath, bool aWritable);
     void uninit();
 
@@ -72 +73 @@
     STDMETHOD(COMGETTER(HostPath)) (BSTR *aHostPath);
     STDMETHOD(COMGETTER(Accessible)) (BOOL *aAccessible);
+    STDMETHOD(COMGETTER(Writable)) (BOOL *aWritable);
 
     // public methods for internal purposes only
@@ -81 +83 @@
     const Bstr &name() const { return mData.mName; }
     const Bstr &hostPath() const { return mData.mHostPath; }
+    BOOL writable() const { return mData.mWritable; }
 
     // for VirtualBoxSupportErrorInfoImpl
@@ -88 +91 @@
 
     HRESULT protectedInit (VirtualBoxBaseWithChildrenNEXT *aParent,
-                           const BSTR aName, const BSTR aHostPath);
+                           const BSTR aName, const BSTR aHostPath, bool aWritable);
 
 private:

trunk/src/VBox/Main/include/VirtualBoxImpl.h

@@ -161 +161 @@
 
     STDMETHOD(GetGuestOSType) (INPTR BSTR aId, IGuestOSType **aType);
-    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath);
+    STDMETHOD(CreateSharedFolder) (INPTR BSTR aName, INPTR BSTR aHostPath, BOOL aWritable);
     STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
     STDMETHOD(GetNextExtraDataKey) (INPTR BSTR aKey, BSTR *aNextKey, BSTR *aNextValue);

trunk/src/VBox/Main/xml/VirtualBox-settings-common.xsd

@@ -630 +630 @@
   <xsd:attribute name="name" type="TNonEmptyString" use="required"/>
   <xsd:attribute name="hostPath" type="TLocalFile" use="required"/>
+  <xsd:attribute name="writable" type="xsd:boolean" default="true"/>
 </xsd:complexType>