Changeset 4041 in vbox

Timestamp:

Aug 6, 2007 12:47:18 PM (17 years ago)

Author:

vboxsync

Message:

Main: Shared Folders (#2130):

• Solved folder name unicity problems by introducing scope precedence (transient, then permanent, then global).
• Implemented VM process notification on permanent (machine) shared folder change.

Location:

trunk/src/VBox/Main

Files:

• ConsoleImpl.cpp (modified) (27 diffs)
• MachineImpl.cpp (modified) (8 diffs)
• SessionImpl.cpp (modified) (1 diff)
• idl/VirtualBox.xidl (modified) (10 diffs)
• include/ConsoleImpl.h (modified) (5 diffs)
• include/MachineImpl.h (modified) (2 diffs)
• include/SessionImpl.h (modified) (1 diff)

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -174 +174 @@
     PFNCFGMCONSTRUCTOR mConfigConstructor;
     Utf8Str mSavedStateFile;
-    std::map <Bstr, ComPtr <ISharedFolder> > mSharedFolders;
+    Console::SharedFolderDataMap mSharedFolders;
 };
 
@@ -266 +266 @@
 
     rc = mMachine->COMGETTER(State) (&mMachineState);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
 #ifdef VBOX_VRDP
     rc = mMachine->COMGETTER(VRDPServer) (unconst (mVRDPServer).asOutParam());
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 #endif
 
     rc = mMachine->COMGETTER(DVDDrive) (unconst (mDVDDrive).asOutParam());
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     rc = mMachine->COMGETTER(FloppyDrive) (unconst (mFloppyDrive).asOutParam());
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     /* Create associated child COM objects */
@@ -283 +283 @@
     unconst (mGuest).createObject();
     rc = mGuest->init (this);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     unconst (mKeyboard).createObject();
     rc = mKeyboard->init (this);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     unconst (mMouse).createObject();
     rc = mMouse->init (this);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     unconst (mDisplay).createObject();
     rc = mDisplay->init (this);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
 
     unconst (mRemoteDisplayInfo).createObject();
     rc = mRemoteDisplayInfo->init (this);
-    AssertComRCReturn (rc, rc);
+    AssertComRCReturnRC (rc);
+
+    /* Grab global and machine shared folder lists */
+
+    rc = fetchSharedFolders (true /* aGlobal */);
+    AssertComRCReturnRC (rc);
+    rc = fetchSharedFolders (false /* aGlobal */);
+    AssertComRCReturnRC (rc);
 
     /* Create other child objects */
@@ -378 +385 @@
         unconst (mVMMDev) = NULL;
     }
+
+    mGlobalSharedFolders.clear();
+    mMachineSharedFolders.clear();
 
     mSharedFolders.clear();
@@ -936 +946 @@
     AssertRC (vrc);
 
-    for (SharedFolderList::const_iterator it = that->mSharedFolders.begin();
+    for (SharedFolderMap::const_iterator it = that->mSharedFolders.begin();
          it != that->mSharedFolders.end();
          ++ it)
     {
-        ComObjPtr <SharedFolder> folder = (*it);
-        AutoLock folderLock (folder);
+        ComObjPtr <SharedFolder> folder = (*it).second;
+        // don't lock the folder because methods we access are const
 
         Utf8Str name = folder->name();
@@ -1027 +1037 @@
         HRESULT rc = sharedFolder->init (that, name, hostPath);
         AssertComRCReturn (rc, VERR_INTERNAL_ERROR);
-        if (FAILED (rc))
-            return rc;
-
-        that->mSharedFolders.push_back (sharedFolder);
+
+        that->mSharedFolders.insert (std::make_pair (name, sharedFolder));
     }
 
@@ -1236 +1244 @@
 
     if (mMachineState >= MachineState_Running)
-        return setError(E_FAIL, tr ("Cannot power up the machine as it is already running.  (Machine state: %d)"), mMachineState);
+        return setError(E_FAIL, tr ("Cannot power up the machine as it is "
+                                    "already running (machine state: %d)"),
+                        mMachineState);
 
     /*
@@ -1372 +1382 @@
 
     /* Check all types of shared folders and compose a single list */
-    std::map <Bstr, ComPtr <ISharedFolder> > sharedFolders;
-    {
-        /// @todo (dmik) check and add globally shared folders when they are
-        //  done
-
-        ComPtr <ISharedFolderCollection> coll;
-        HRESULT rc = mMachine->COMGETTER(SharedFolders) (coll.asOutParam());
-        CheckComRCReturnRC (rc);
-        ComPtr <ISharedFolderEnumerator> en;
-        rc = coll->Enumerate (en.asOutParam());
-        CheckComRCReturnRC (rc);
-
-        BOOL hasMore = FALSE;
-        while (SUCCEEDED (en->HasMore (&hasMore)) && hasMore)
-        {
-            ComPtr <ISharedFolder> folder;
-            en->GetNext (folder.asOutParam());
-
-            Bstr name;
-            rc = folder->COMGETTER(Name) (name.asOutParam());
-            CheckComRCReturnRC (rc);
-
-            BOOL accessible = FALSE;
-            rc = folder->COMGETTER(Accessible) (&accessible);
-            CheckComRCReturnRC (rc);
-
-            if (!accessible)
-            {
-                Bstr hostPath;
-                folder->COMGETTER(HostPath) (hostPath.asOutParam());
-                return setError (E_FAIL,
-                    tr ("Host path '%ls' of the shared folder '%ls' is not accessible"),
-                    hostPath.raw(), name.raw());
-            }
-
-            sharedFolders.insert (std::make_pair (name, folder));
-            /// @todo (dmik) later, do this:
-//            if (!sharedFolders.insert (std::pair <name, folder>).second)
-//                return setError (E_FAIL,
-//                    tr ("Could not accept a permanently shared folder named '%ls' "
-//                       "because a globally shared folder with the same name "
-//                       "already exists"),
-//                    name.raw());
-        }
-
-        for (SharedFolderList::const_iterator it = mSharedFolders.begin();
+    SharedFolderDataMap sharedFolders;
+    {
+        /* first, insert global folders */
+        for (SharedFolderDataMap::const_iterator it = mGlobalSharedFolders.begin();
+             it != mGlobalSharedFolders.end(); ++ it)
+            sharedFolders [it->first] = it->second;
+
+        /* second, insert machine folders */
+        for (SharedFolderDataMap::const_iterator it = mMachineSharedFolders.begin();
+             it != mMachineSharedFolders.end(); ++ it)
+            sharedFolders [it->first] = it->second;
+
+        /* third, insert console folders */
+        for (SharedFolderMap::const_iterator it = mSharedFolders.begin();
              it != mSharedFolders.end(); ++ it)
-        {
-            ComPtr <ISharedFolder> folder = static_cast <SharedFolder *> (*it);
-
-            if (!sharedFolders.insert (std::make_pair ((*it)->name(), folder)).second)
-                return setError (E_FAIL,
-                    tr ("Could not create a transient shared folder named '%ls' "
-                       "because a global or a permanent shared folder with "
-                       "the same name already exists"),
-                    (*it)->name().raw());
-        }
+            sharedFolders [it->first] = it->second->hostPath();
     }
 
@@ -1509 +1478 @@
             return setError(E_FAIL, tr ("Cannot power off a saved machine"));
         else
-            return setError(E_FAIL, tr ("Cannot power off the machine as it is not running or paused.  (Machine state: %d)"), mMachineState);
+            return setError(E_FAIL, tr ("Cannot power off the machine as it is "
+                                        "not running or paused (machine state: %d)"),
+                            mMachineState);
     }
 
@@ -1532 +1503 @@
 
     if (mMachineState != MachineState_Running)
-        return setError(E_FAIL, tr ("Cannot reset the machine as it is not running.  (Machine state: %d)"), mMachineState);
+        return setError(E_FAIL, tr ("Cannot reset the machine as it is "
+                                    "not running (machine state: %d)"),
+                        mMachineState);
 
     /* protect mpVM */
@@ -1544 +1517 @@
 
     HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
-        setError (E_FAIL, tr ("Could not reset the machine.  (Error: %Vrc)"), vrc);
+        setError (E_FAIL, tr ("Could not reset the machine (%Vrc)"), vrc);
 
     LogFlowThisFunc (("mMachineState=%d, rc=%08X\n", mMachineState, rc));
@@ -1561 +1534 @@
 
     if (mMachineState != MachineState_Running)
-        return setError (E_FAIL, tr ("Cannot pause the machine as it is not running.  (Machine state: %d)"), mMachineState);
+        return setError (E_FAIL, tr ("Cannot pause the machine as it is "
+                                     "not running (machine state: %d)"),
+                         mMachineState);
 
     /* protect mpVM */
@@ -1576 +1551 @@
     HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
         setError (E_FAIL,
-            tr ("Could not suspend the machine execution.  (Error: %Vrc)"), vrc);
+            tr ("Could not suspend the machine execution (%Vrc)"), vrc);
 
     LogFlowThisFunc (("rc=%08X\n", rc));
@@ -1593 +1568 @@
 
     if (mMachineState != MachineState_Paused)
-        return setError (E_FAIL, tr ("Cannot resume the machine as it is not paused.  (Machine state: %d)"), mMachineState);
+        return setError (E_FAIL, tr ("Cannot resume the machine as it is "
+                                     "not paused (machine state: %d)"),
+                         mMachineState);
 
     /* protect mpVM */
@@ -1608 +1585 @@
     HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
         setError (E_FAIL,
-            tr ("Could not resume the machine execution.  (Error: %Vrc)"), vrc);
+            tr ("Could not resume the machine execution (%Vrc)"), vrc);
 
     LogFlowThisFunc (("rc=%08X\n", rc));
@@ -1625 +1602 @@
 
     if (mMachineState != MachineState_Running)
-        return setError (E_FAIL, tr ("Cannot power off the machine as it is not running.  (Machine state: %d)"), mMachineState);
+        return setError (E_FAIL, tr ("Cannot power off the machine as it is "
+                                     "not running (machine state: %d)"),
+                         mMachineState);
 
     /* protect mpVM */
@@ -1643 +1622 @@
     HRESULT rc = VBOX_SUCCESS (vrc) ? S_OK :
         setError (E_FAIL,
-            tr ("Controlled power off failed.  (Error: %Vrc)"), vrc);
+            tr ("Controlled power off failed (%Vrc)"), vrc);
 
     LogFlowThisFunc (("rc=%08X\n", rc));
@@ -1734 +1713 @@
                 {
                     rc = setError (E_FAIL,
-                        tr ("Could not create a directory '%s' to save the state to.  (Error: %Vrc)"),
+                        tr ("Could not create a directory '%s' to save the state to (%Vrc)"),
                         dir.raw(), vrc);
                     break;
@@ -1802 +1781 @@
     if (mMachineState != MachineState_Saved)
         return setError (E_FAIL,
-            tr ("Cannot discard the machine state as the machine is not in the saved state.  (Machine state: %d"), mMachineState);
+            tr ("Cannot discard the machine state as the machine is "
+                "not in the saved state (machine state: %d)"),
+            mMachineState);
 
     /*
@@ -2025 +2006 @@
         return setError (E_FAIL,
             tr ("Cannot create a transient shared folder on a "
-                "machine in the saved state."));
-
-    /// @todo (dmik) check globally shared folders when they are done
-
-    /* check machine's shared folders */
-    {
-        ComPtr <ISharedFolderCollection> coll;
-        HRESULT rc = mMachine->COMGETTER(SharedFolders) (coll.asOutParam());
-        if (FAILED (rc))
-            return rc;
-
-        ComPtr <ISharedFolder> machineSharedFolder;
-        rc = coll->FindByName (aName, machineSharedFolder.asOutParam());
-        if (SUCCEEDED (rc))
-            return setError (E_FAIL,
-                tr ("A permanent shared folder named '%ls' already "
-                    "exists."), aName);
-    }
+                "machine in the saved state"));
 
     ComObjPtr <SharedFolder> sharedFolder;
@@ -2048 +2012 @@
     if (SUCCEEDED (rc))
         return setError (E_FAIL,
-            tr ("A shared folder named '%ls' already exists."), aName);
+            tr ("Shared folder named '%ls' already exists"), aName);
 
     sharedFolder.createObject();
@@ -2060 +2024 @@
     if (!accessible)
         return setError (E_FAIL,
-            tr ("The shared folder path '%ls' on the host is not accessible."), aHostPath);
-
-    /// @todo (r=sander?) should move this into the shared folder class */
-    if (mpVM && mVMMDev->isShFlActive())
-    {
-        /*
-         *  if the VM is online and supports shared folders, share this folder
-         *  under the specified name. On error, return it to the caller.
-         */
-
-        /* protect mpVM */
-        AutoVMCaller autoVMCaller (this);
-        CheckComRCReturnRC (autoVMCaller.rc());
-
-        VBOXHGCMSVCPARM  parms[2];
-        SHFLSTRING      *pFolderName, *pMapName;
-        int              cbString;
-
-        Log (("Add shared folder %ls -> %ls\n", aName, aHostPath));
-
-        cbString = (RTStrUcs2Len(aHostPath) + 1) * sizeof(RTUCS2);
-        pFolderName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
-        Assert(pFolderName);
-        memcpy(pFolderName->String.ucs2, aHostPath, cbString);
-
-        pFolderName->u16Size   = cbString;
-        pFolderName->u16Length = cbString - sizeof(RTUCS2);
-
-        parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
-        parms[0].u.pointer.addr = pFolderName;
-        parms[0].u.pointer.size = sizeof(SHFLSTRING) + cbString;
-
-        cbString = (RTStrUcs2Len(aName) + 1) * sizeof(RTUCS2);
-        pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
-        Assert(pMapName);
-        memcpy(pMapName->String.ucs2, aName, cbString);
-
-        pMapName->u16Size   = cbString;
-        pMapName->u16Length = cbString - sizeof(RTUCS2);
-
-        parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
-        parms[1].u.pointer.addr = pMapName;
-        parms[1].u.pointer.size = sizeof(SHFLSTRING) + cbString;
-
-        int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
-                                         SHFL_FN_ADD_MAPPING,
-                                         2, &parms[0]);
-        RTMemFree(pFolderName);
-        RTMemFree(pMapName);
-        if (vrc != VINF_SUCCESS)
-            return setError (E_FAIL,
-                tr ("Could not create a shared folder '%ls' mapped to '%ls' (%Vrc)"),
-                aName, aHostPath, vrc);
-    }
-
-    mSharedFolders.push_back (sharedFolder);
-    return S_OK;
+            tr ("Shared folder host path '%ls' is not accessible"), aHostPath);
+
+    /* protect mpVM (if not NULL) */
+    AutoVMCallerQuietWeak autoVMCaller (this);
+
+    if (mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive())
+    {
+        /* If the VM is online and supports shared folders, share this folder
+         * under the specified name. */
+
+        /* first, remove the machine or the global folder if there is any */
+        SharedFolderDataMap::const_iterator it;
+        if (findOtherSharedFolder (aName, it))
+        {
+            rc = removeSharedFolder (aName);
+            CheckComRCReturnRC (rc);
+        }
+
+        /* second, create the given folder */
+        rc = createSharedFolder (aName, aHostPath);
+        CheckComRCReturnRC (rc);
+    }
+
+    mSharedFolders.insert (std::make_pair (aName, sharedFolder));
+
+    return rc;
 }
 
@@ -2138 +2071 @@
     CheckComRCReturnRC (rc);
 
-    /* protect mpVM */
-    AutoVMCaller autoVMCaller (this);
-    CheckComRCReturnRC (autoVMCaller.rc());
-
-    if (mpVM && mVMMDev->isShFlActive())
-    {
-        /*
-         *  if the VM is online and supports shared folders, UNshare this folder.
-         *  On error, return it to the caller.
-         */
-        VBOXHGCMSVCPARM  parms;
-        SHFLSTRING      *pMapName;
-        int              cbString;
-
-        cbString = (RTStrUcs2Len(aName) + 1) * sizeof(RTUCS2);
-        pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
-        Assert(pMapName);
-        memcpy(pMapName->String.ucs2, aName, cbString);
-
-        pMapName->u16Size   = cbString;
-        pMapName->u16Length = cbString - sizeof(RTUCS2);
-
-        parms.type = VBOX_HGCM_SVC_PARM_PTR;
-        parms.u.pointer.addr = pMapName;
-        parms.u.pointer.size = sizeof(SHFLSTRING) + cbString;
-
-        int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
-                                         SHFL_FN_REMOVE_MAPPING,
-                                         1, &parms);
-        RTMemFree(pMapName);
-        if (vrc != VINF_SUCCESS)
-            rc = setError (E_FAIL,
-                tr ("Could not remove the shared folder '%ls' (%Vrc)"),
-                aName, vrc);
-    }
-
-    mSharedFolders.remove (sharedFolder);
+    /* protect mpVM (if not NULL) */
+    AutoVMCallerQuietWeak autoVMCaller (this);
+
+    if (mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive())
+    {
+        /* if the VM is online and supports shared folders, UNshare this
+         * folder. */
+
+        /* first, remove the given folder */
+        rc = removeSharedFolder (aName);
+        CheckComRCReturnRC (rc);
+
+        /* first, remove the machine or the global folder if there is any */
+        SharedFolderDataMap::const_iterator it;
+        if (findOtherSharedFolder (aName, it))
+        {
+            rc = createSharedFolder (aName, it->second);
+            /* don't check rc here because we need to remove the console
+             * folder from the collection even on failure */
+        }
+    }
+
+    mSharedFolders.erase (aName);
+
     return rc;
 }
@@ -3250 +3170 @@
 
 /**
+ *  Called by IInternalSessionControl::OnSharedFolderChange().
+ *
+ *  @note Locks this object for writing.
+ */
+HRESULT Console::onSharedFolderChange (BOOL aGlobal)
+{
+    LogFlowThisFunc (("aGlobal=%RTbool\n", aGlobal));
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturnRC (autoCaller.rc());
+
+    AutoLock alock (this);
+
+    return fetchSharedFolders (aGlobal);
+}
+
+/**
  *  Called by IInternalSessionControl::OnUSBDeviceAttach() or locally by
  *  processRemoteUSBDevices() after IInternalMachineControl::RunUSBDeviceFilters()
@@ -4066 +4003 @@
     AssertReturn (isLockedOnCurrentThread(), E_FAIL);
 
-    bool found = false;
-    for (SharedFolderList::const_iterator it = mSharedFolders.begin();
-        !found && it != mSharedFolders.end();
-        ++ it)
-    {
-        AutoLock alock (*it);
-        found = (*it)->name() == aName;
-        if (found)
-            aSharedFolder = *it;
-    }
-
-    HRESULT rc = found ? S_OK : E_INVALIDARG;
-
-    if (aSetError && !found)
-        setError (rc, tr ("Could not find a shared folder named '%ls'."), aName);
+    SharedFolderMap::const_iterator it = mSharedFolders.find (aName);
+    if (it != mSharedFolders.end())
+    {
+        aSharedFolder = it->second;
+        return S_OK;
+    }
+
+    if (aSetError)
+        setError (E_INVALIDARG,
+                  tr ("Could not find a shared folder named '%ls'."), aName);
+
+    return E_INVALIDARG;
+}
+
+/** 
+ *  Fetches the list of global or machine shared folders from the server.
+ * 
+ *  @param aGlobal true to fetch global folders.
+ *
+ *  @note The caller must lock this object for writing.
+ */
+HRESULT Console::fetchSharedFolders (BOOL aGlobal)
+{
+    /* sanity check */
+    AssertReturn (AutoCaller (this).state() == InInit ||
+                  isLockedOnCurrentThread(), E_FAIL);
+
+    /* protect mpVM (if not NULL) */
+    AutoVMCallerQuietWeak autoVMCaller (this);
+
+    HRESULT rc = S_OK;
+
+    bool online = mpVM && autoVMCaller.isOk() && mVMMDev->isShFlActive();
+
+    if (aGlobal)
+    {
+        /// @todo grab & process global folders when they are done
+    }
+    else
+    {
+        SharedFolderDataMap oldFolders;
+        if (online)
+            oldFolders = mMachineSharedFolders;
+        
+        mMachineSharedFolders.clear();
+
+        ComPtr <ISharedFolderCollection> coll;
+        rc = mMachine->COMGETTER(SharedFolders) (coll.asOutParam());
+        AssertComRCReturnRC (rc);
+
+        ComPtr <ISharedFolderEnumerator> en;
+        rc = coll->Enumerate (en.asOutParam());
+        AssertComRCReturnRC (rc);
+
+        BOOL hasMore = FALSE;
+        while (SUCCEEDED (rc = en->HasMore (&hasMore)) && hasMore)
+        {
+            ComPtr <ISharedFolder> folder;
+            rc = en->GetNext (folder.asOutParam());
+            CheckComRCBreakRC (rc);
+
+            Bstr name;
+            Bstr hostPath;
+
+            rc = folder->COMGETTER(Name) (name.asOutParam());
+            CheckComRCBreakRC (rc);
+            rc = folder->COMGETTER(HostPath) (hostPath.asOutParam());
+            CheckComRCBreakRC (rc);
+
+            mMachineSharedFolders.insert (std::make_pair (name, hostPath));
+
+            /* send changes to HGCM if the VM is running */
+            /// @todo report errors as runtime warnings through VMSetError
+            if (online)
+            {
+                SharedFolderDataMap::iterator it = oldFolders.find (name);
+                if (it == oldFolders.end() || it->second != hostPath)
+                {
+                    /* a new machine folder is added or
+                    /* the existing machine folder is changed */
+                    if (mSharedFolders.find (name) != mSharedFolders.end())
+                        ; /* the console folder exists, nothing to do */
+                    else
+                    {
+                        /* remove the old machhine folder (when changed)
+                         * or the global folder if any (when new) */
+                        if (it != oldFolders.end() ||
+                            mGlobalSharedFolders.find (name) !=
+                                mGlobalSharedFolders.end())
+                            rc = removeSharedFolder (name);
+                        /* create the new machine folder */
+                        rc = createSharedFolder (name, hostPath);
+                    }
+                }
+                /* forget the processed (or identical) folder */
+                if (it != oldFolders.end())
+                    oldFolders.erase (it);
+
+                rc = S_OK;
+            }
+        }
+
+        AssertComRCReturnRC (rc);
+
+        /* process outdated (removed) folders */
+        /// @todo report errors as runtime warnings through VMSetError
+        if (online)
+        {
+            for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
+                 it != oldFolders.end(); ++ it)
+            {
+                if (mSharedFolders.find (it->first) != mSharedFolders.end())
+                    ; /* the console folder exists, nothing to do */
+                else
+                {
+                    /* remove the outdated machine folder */
+                    rc = removeSharedFolder (it->first);
+                    /* create the global folder if there is any */
+                    SharedFolderDataMap::const_iterator it =
+                        mGlobalSharedFolders.find (it->first);
+                    if (it != mGlobalSharedFolders.end())
+                        rc = createSharedFolder (it->first, it->second);
+                }
+            }
+
+            rc = S_OK;
+        }
+    }
 
     return rc;
+}
+
+/** 
+ *  Searches for a shared folder with the given name in the list of machine
+ *  shared folders and then in the list of the global shared folders.
+ * 
+ *  @param aName    Name of the folder to search for.
+ *  @param aIt      Where to store the pointer to the found folder.
+ *  @return         @c true if the folder was found and @c false otherwise.
+ *
+ *  @note The caller must lock this object for reading.
+ */
+bool Console::findOtherSharedFolder (INPTR BSTR aName,
+                                     SharedFolderDataMap::const_iterator &aIt)
+{
+    /* sanity check */
+    AssertReturn (isLockedOnCurrentThread(), false);
+
+    /* first, search machine folders */
+    aIt = mMachineSharedFolders.find (aName);
+    if (aIt != mMachineSharedFolders.end())
+        return true;
+
+    /* second, search machine folders */
+    aIt = mGlobalSharedFolders.find (aName);
+    if (aIt != mGlobalSharedFolders.end())
+        return true;
+
+    return false;
+}
+
+/** 
+ *  Calls the HGCM service to add a shared folder definition.
+ * 
+ *  @param aName        Shared folder name.
+ *  @param aHostPath    Shared folder path.
+ *
+ *  @note Must be called from under AutoVMCaller and when mpVM != NULL!
+ *  @note Doesn't lock anything.
+ */
+HRESULT Console::createSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath)
+{
+    ComAssertRet (aName && *aName, E_FAIL);
+    ComAssertRet (aHostPath && *aHostPath, E_FAIL);
+
+    /* sanity checks */
+    AssertReturn (mpVM, E_FAIL);
+    AssertReturn (mVMMDev->isShFlActive(), E_FAIL);
+
+    VBOXHGCMSVCPARM  parms[2];
+    SHFLSTRING      *pFolderName, *pMapName;
+    int              cbString;
+
+    Log (("Adding shared folder '%ls' -> '%ls'\n", aName, aHostPath));
+
+    cbString = (RTStrUcs2Len (aHostPath) + 1) * sizeof (RTUCS2);
+    pFolderName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
+    Assert (pFolderName);
+    memcpy (pFolderName->String.ucs2, aHostPath, cbString);
+
+    pFolderName->u16Size   = cbString;
+    pFolderName->u16Length = cbString - sizeof(RTUCS2);
+
+    parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
+    parms[0].u.pointer.addr = pFolderName;
+    parms[0].u.pointer.size = sizeof (SHFLSTRING) + cbString;
+
+    cbString = (RTStrUcs2Len (aName) + 1) * sizeof (RTUCS2);
+    pMapName = (SHFLSTRING *) RTMemAllocZ (sizeof(SHFLSTRING) + cbString);
+    Assert (pMapName);
+    memcpy (pMapName->String.ucs2, aName, cbString);
+
+    pMapName->u16Size   = cbString;
+    pMapName->u16Length = cbString - sizeof (RTUCS2);
+
+    parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
+    parms[1].u.pointer.addr = pMapName;
+    parms[1].u.pointer.size = sizeof (SHFLSTRING) + cbString;
+
+    int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
+                                     SHFL_FN_ADD_MAPPING,
+                                     2, &parms[0]);
+    RTMemFree (pFolderName);
+    RTMemFree (pMapName);
+
+    if (VBOX_FAILURE (vrc))
+        return setError (E_FAIL,
+                         tr ("Could not create a shared folder '%ls' "
+                             "mapped to '%ls' (%Vrc)"),
+                         aName, aHostPath, vrc);
+
+    return S_OK;
+}
+
+/** 
+ *  Calls the HGCM service to remove the shared folder definition.
+ * 
+ *  @param aName        Shared folder name.
+ *
+ *  @note Must be called from under AutoVMCaller and when mpVM != NULL!
+ *  @note Doesn't lock anything.
+ */
+HRESULT Console::removeSharedFolder (INPTR BSTR aName)
+{
+    ComAssertRet (aName && *aName, E_FAIL);
+
+    /* sanity checks */
+    AssertReturn (mpVM, E_FAIL);
+    AssertReturn (mVMMDev->isShFlActive(), E_FAIL);
+
+    VBOXHGCMSVCPARM  parms;
+    SHFLSTRING      *pMapName;
+    int              cbString;
+
+    Log (("Removing shared folder '%ls'\n", aName));
+
+    cbString = (RTStrUcs2Len (aName) + 1) * sizeof (RTUCS2);
+    pMapName = (SHFLSTRING *) RTMemAllocZ (sizeof (SHFLSTRING) + cbString);
+    Assert (pMapName);
+    memcpy (pMapName->String.ucs2, aName, cbString);
+
+    pMapName->u16Size   = cbString;
+    pMapName->u16Length = cbString - sizeof (RTUCS2);
+
+    parms.type = VBOX_HGCM_SVC_PARM_PTR;
+    parms.u.pointer.addr = pMapName;
+    parms.u.pointer.size = sizeof (SHFLSTRING) + cbString;
+
+    int vrc = mVMMDev->hgcmHostCall ("VBoxSharedFolders",
+                                     SHFL_FN_REMOVE_MAPPING,
+                                     1, &parms);
+    RTMemFree(pMapName);
+    if (VBOX_FAILURE (vrc))
+        return setError (E_FAIL,
+                         tr ("Could not remove the shared folder '%ls' (%Vrc)"),
+                         aName, vrc);
+
+    return S_OK;
 }
 
@@ -6910 +7098 @@
                 }
 
+                /*
+                 * Shared Folders
+                 */
                 if (console->getVMMDev()->isShFlActive())
                 {
@@ -6917 +7108 @@
                     alock.leave();
 
-                    /*
-                     * Shared Folders
-                     */
-                    for (std::map <Bstr, ComPtr <ISharedFolder> >::const_iterator
-                         it = task->mSharedFolders.begin();
+                    for (SharedFolderDataMap::const_iterator
+                             it = task->mSharedFolders.begin();
                          it != task->mSharedFolders.end();
                          ++ it)
                     {
-                        Bstr name = (*it).first;
-                        ComPtr <ISharedFolder> folder = (*it).second;
-
-                        Bstr hostPath;
-                        hrc = folder->COMGETTER(HostPath) (hostPath.asOutParam());
+                        hrc = console->createSharedFolder ((*it).first, (*it).second);
                         CheckComRCBreakRC (hrc);
-
-                        LogFlowFunc (("Adding shared folder '%ls' -> '%ls'\n",
-                                      name.raw(), hostPath.raw()));
-                        ComAssertBreak (!name.isEmpty() && !hostPath.isEmpty(),
-                                        hrc = E_FAIL);
-
-                        /** @todo should move this into the shared folder class */
-                        VBOXHGCMSVCPARM  parms[2];
-                        SHFLSTRING      *pFolderName, *pMapName;
-                        int              cbString;
-
-                        cbString = (hostPath.length() + 1) * sizeof(RTUCS2);
-                        pFolderName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
-                        Assert(pFolderName);
-                        memcpy(pFolderName->String.ucs2, hostPath.raw(), cbString);
-
-                        pFolderName->u16Size   = cbString;
-                        pFolderName->u16Length = cbString - sizeof(RTUCS2);
-
-                        parms[0].type = VBOX_HGCM_SVC_PARM_PTR;
-                        parms[0].u.pointer.addr = pFolderName;
-                        parms[0].u.pointer.size = sizeof(SHFLSTRING) + cbString;
-
-                        cbString = (name.length() + 1) * sizeof(RTUCS2);
-                        pMapName = (SHFLSTRING *)RTMemAllocZ(sizeof(SHFLSTRING) + cbString);
-                        Assert(pMapName);
-                        memcpy(pMapName->String.ucs2, name.raw(), cbString);
-
-                        pMapName->u16Size   = cbString;
-                        pMapName->u16Length = cbString - sizeof(RTUCS2);
-
-                        parms[1].type = VBOX_HGCM_SVC_PARM_PTR;
-                        parms[1].u.pointer.addr = pMapName;
-                        parms[1].u.pointer.size = sizeof(SHFLSTRING) + cbString;
-
-                        vrc = console->getVMMDev()->hgcmHostCall("VBoxSharedFolders",
-                            SHFL_FN_ADD_MAPPING, 2, &parms[0]);
-
-                        RTMemFree(pFolderName);
-                        RTMemFree(pMapName);
-
-                        if (VBOX_FAILURE (vrc))
-                        {
-                            hrc = setError (E_FAIL,
-                                tr ("Could not create a shared folder '%ls' mapped to '%ls' (%Vrc)"),
-                                name.raw(), hostPath.raw(), vrc);
-                            break;
-                        }
                     }
 

trunk/src/VBox/Main/MachineImpl.cpp

@@ -2339 +2339 @@
     CheckComRCReturnRC (rc);
 
-    /// @todo (dmik) check global shared folders when they are done
-
     ComObjPtr <SharedFolder> sharedFolder;
     rc = findSharedFolder (aName, sharedFolder, false /* aSetError */);
@@ -2357 +2355 @@
     if (!accessible)
         return setError (E_FAIL,
-            tr ("Shared folder path '%ls' is not accessible"), aHostPath);
+            tr ("Shared folder host path '%ls' is not accessible"), aHostPath);
 
     mHWData.backup();
     mHWData->mSharedFolders.push_back (sharedFolder);
+
+    /* inform the direct session if any */
+    alock.leave();
+    onSharedFolderChange();
 
     return S_OK;
@@ -2384 +2386 @@
     mHWData.backup();
     mHWData->mSharedFolders.remove (sharedFolder);
+
+    /* inform the direct session if any */
+    alock.leave();
+    onSharedFolderChange();
 
     return S_OK;
@@ -7278 +7284 @@
     AutoLock alock (this);
 
+    /* check for changes in own data */
+
+    bool sharedFoldersChanged = false;
+
+    if (aNotify && mHWData.isBackedUp())
+    {
+        if (mHWData->mSharedFolders.size() !=
+            mHWData.backedUpData()->mSharedFolders.size())
+            sharedFoldersChanged = true;
+        else
+        {
+            for (HWData::SharedFolderList::iterator rit =
+                     mHWData->mSharedFolders.begin();
+                 rit != mHWData->mSharedFolders.end() && !sharedFoldersChanged;
+                 ++ rit)
+            {
+                for (HWData::SharedFolderList::iterator cit =
+                         mHWData.backedUpData()->mSharedFolders.begin();
+                     cit != mHWData.backedUpData()->mSharedFolders.end();
+                     ++ cit)
+                {
+                    if ((*cit)->name() != (*rit)->name() ||
+                        (*cit)->hostPath() != (*rit)->hostPath())
+                    {
+                        sharedFoldersChanged = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
     mUserData.rollback();
 
@@ -7285 +7323 @@
         fixupHardDisks (false /* aCommit */);
 
+    /* check for changes in child objects */
+
     bool vrdpChanged = false, dvdChanged = false, floppyChanged = false,
          usbChanged = false;
+
     ComPtr <INetworkAdapter> networkAdapters [ELEMENTS (mNetworkAdapters)];
     ComPtr <ISerialPort> serialPorts [ELEMENTS (mSerialPorts)];
@@ -7328 +7369 @@
     if (aNotify)
     {
-        // inform the direct session about changes
+        /* inform the direct session about changes */
 
         ComObjPtr <Machine> that = this;
         alock.leave();
+
+        if (sharedFoldersChanged)
+            that->onSharedFolderChange();
 
         if (vrdpChanged)
@@ -7341 +7385 @@
         if (usbChanged)
             that->onUSBControllerChange();
+
         for (ULONG slot = 0; slot < ELEMENTS (networkAdapters); slot ++)
             if (networkAdapters [slot])
@@ -8892 +8937 @@
  *  @note Locks this object for reading.
  */
+HRESULT SessionMachine::onSharedFolderChange()
+{
+    LogFlowThisFunc (("\n"));
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
+
+    ComPtr <IInternalSessionControl> directControl;
+    {
+        AutoReaderLock alock (this);
+        directControl = mData->mSession.mDirectControl;
+    }
+
+    /* ignore notifications sent after #OnSessionEnd() is called */
+    if (!directControl)
+        return S_OK;
+
+    return directControl->OnSharedFolderChange (FALSE /* aGlobal */);
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
 HRESULT SessionMachine::onUSBDeviceAttach (IUSBDevice *aDevice,
                                            IVirtualBoxErrorInfo *aError)

trunk/src/VBox/Main/SessionImpl.cpp

@@ -593 +593 @@
 
     return mConsole->onUSBControllerChange();
+}
+
+STDMETHODIMP Session::OnSharedFolderChange (BOOL aGlobal)
+{
+    LogFlowThisFunc (("\n"));
+
+    AutoCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
+
+    AutoReaderLock alock (this);
+    AssertReturn (mState == SessionState_SessionOpen &&
+                  mType == SessionType_DirectSession, E_FAIL);
+
+    return mConsole->onSharedFolderChange (aGlobal);
 }
 

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

@@ -735 +735 @@
     <attribute name="sharedFolders" type="ISharedFolderCollection" readonly="yes">
       <desc>
-        Collection of globally shared folders. These folders
-        are shared automatically upon VirtualBox server startup and
-        available only to every virtual machine.
-
-        New folders to share are added to the collection using
-        <link to="#createSharedFolder"/>. An existing shared folder can
-        be removed using <link to="#removeSharedFolder"/>.
+        Collection of global shared folders. Global shared folders are
+        available to all virtual machines.
+
+        New shared folders are added to the collection using
+        <link to="#createSharedFolder"/>. Existing shared folders can be
+        removed using <link to="#removeSharedFolder"/>.
       </desc>
     </attribute>
@@ -1383 +1382 @@
     <method name="createSharedFolder">
       <desc>
-        Creates a new shared folder by associating the given logical
-        name with the given host path, adds it to the collection of
-        shared folders and starts sharing it.
-        Refer to the description of <link to="ISharedFolder"/> to read
-        about logical name unicity.
+        Creates a new shared folder by associating the given logical name with
+        the given host path, adds it to the collection of shared folders and
+        starts sharing it. Refer to the description of
+        <link to="ISharedFolder"/> to read more about logical names.
       </desc>
       <param name="name" type="wstring" dir="in">
@@ -2284 +2282 @@
     <attribute name="sharedFolders" type="ISharedFolderCollection" readonly="yes">
       <desc>
-        Collection of shared folders for this machine. These folders
-        are shared automatically upon machine startup and available only
-        to the guest OS installed within this machine.
-
-        New folders to share are added to the collection using
-        <link to="#createSharedFolder"/>. An existing shared folder can
-        be removed using <link to="#removeSharedFolder"/>.
+        Collection of shared folders for this machine (permanent shared
+        folders). These folders are shared automatically at machine startup
+        and available only to the guest OS installed within this machine.
+
+        New shared folders are added to the collection using
+        <link to="#createSharedFolder"/>. Existing shared folders can be
+        removed using <link to="#removeSharedFolder"/>.
       </desc>
     </attribute>
@@ -2602 +2600 @@
     <method name="createSharedFolder">
       <desc>
-        Creates a new shared folder by associating the given logical
-        name with the given host path, adds it to the collection of
-        shared folders and starts sharing it.
-        Refer to the description of <link to="ISharedFolder"/> to read
-        about logical name unicity.
+        Creates a new shared folder by associating the given logical name with
+        the given host path, adds it to the collection of shared folders and
+        starts sharing it. Refer to the description of
+        <link to="ISharedFolder"/> to read more about logical names.
       </desc>
       <param name="name" type="wstring" dir="in">
@@ -3152 +3149 @@
     <attribute name="sharedFolders" type="ISharedFolderCollection" readonly="yes">
       <desc>
-        Collection of shared folders for the current session.
-        This collection is initially empty and is cleared once the
-        session is closed. On other words, this collection represents
-        transient shares (as opposed to <link to="IMachine::sharedFolders"/>
-        that stores permanent shares stored in the settings file).
-
-        New folders to share are added to the collection using
-        <link to="#createSharedFolder"/>. An existing shared folder can
-        be removed using <link to="#removeSharedFolder"/>.
+        Collection of shared folders for the current session.  These folders
+        are called transient shared folders because they are available to the
+        guest OS running inside the associated virtual machine only for the
+        duration of the session (as opposed to
+        <link to="IMachine::sharedFolders"/> which represent permanent shared
+        folders). When the session is closed (e.g. the machine is powered down),
+        these folders are automatically discarded.
+
+        New shared folders are added to the collection using
+        <link to="#createSharedFolder"/>. Existing shared folders can be
+        removed using <link to="#removeSharedFolder"/>.
       </desc>
     </attribute>
@@ -3318 +3317 @@
     <method name="createSharedFolder">
       <desc>
-        Creates a new shared folder by associating the given logical
-        name with the given host path, adds it to the collection of
-        shared folders and starts sharing it.
-        Refer to the description of <link to="ISharedFolder"/> to read
-        about logical name unicity.
+        Creates a new shared folder by associating the given logical name with
+        the given host path, adds it to the collection of shared folders and
+        starts sharing it. Refer to the description of
+        <link to="ISharedFolder"/> to read more about logical names.
       </desc>
       <param name="name" type="wstring" dir="in">
@@ -7768 +7766 @@
     <method name="findByName">
       <desc>
-        Searches this collection for a shared folder drive with the
-        given logical name.
-        <note>
-          The method returns an error if the given name does not
-          correspond to any shared folder in the collection.
+        Searches this collection for a shared folder with the given logical
+        name.
+        <note>
+          The method returns an error if the given name does not correspond to
+          any shared folder in the collection.
         </note>
       </desc>
@@ -7791 +7789 @@
      >
     <desc>
-      The ISharedFolder interface represents a folder in the host
-      computer's file system accessible from a guest OS running inside a
-      virtual machine using an associated logical name.
+      The ISharedFolder interface represents a folder in the host computer's
+      file system accessible from the guest OS running inside a virtual
+      machine using an associated logical name.
 
       There are three types of shared folders:
       <ul>
-        <li>permanent (<link to="IMachine::sharedFolders"/>)</li>
-        <li>transient (<link to="IConsole::sharedFolders"/>)</li>
-        <li>global (<link to="IVirtualBox::sharedFolders"/>)</li>
+        <li><i>Global</i> (<link to="IVirtualBox::sharedFolders"/>), shared
+        folders available to all virtual machines.</li>
+        <li><i>Permanent</i> (<link to="IMachine::sharedFolders"/>),
+        VM-specific shared folders available to the given virtual machine at
+        startup.</li>
+        <li><i>Transient</i> (<link to="IConsole::sharedFolders"/>),
+        VM-specific shared folders created in the session context (for
+        example, when the virtual machine is running) and automatically
+        discarded when the session is closed (the VM is powered off).</li>
       </ul>
 
-      For a given virtual machine, both permanently and transiently
-      shared folders have the same logical name space which also includes
-      all globally shared folders. Thus, every folder in this name space
-      must have an unique logical name. Note that permanent and transient
-      shares of other machines are in different name spaces, so they don't
-      have to have unique names.
+      Logical names of shared folders must be unique within the given scope
+      (global, permanent or transient). However, they do not need to be unique
+      across scopes. In this case, the definitioin of the shared folder in a
+      more specific scope takes precedence over definitions in all other
+      scopes. The order of precedence is (more specific to more general):
+      <ol>
+        <li>Transient definitions</li>
+        <li>Permanent definitions</li>
+        <li>Global definitions</li>
+      </ol>
+      
+      For example, if MyMachine has a shared folder named
+      <tt>C_DRIVE</tt> (that points to <tt>C:\\</tt>), then cretaing a
+      transient shared folder named <tt>C_DRIVE</tt> (that points
+      to <tt>C:\\\\WINDOWS</tt>) will change the definition
+      of <tt>C_DRIVE</tt> in the guest OS so
+      that <tt>\\\\VBOXSVR\\C_DRIVE</tt> will give access
+      to <tt>C:\\WINDOWS</tt> instead of <tt>C:\\</tt> on the host
+      PC. Removing the transient shared folder <tt>C_DRIVE</tt> will restore
+      the prevoious (permanent) definition of <tt>C_DRIVE</tt> that points
+      to <tt>C:\\</tt> if it still exists.
+      
+      Note that permanent and transient shared folders of different machines
+      are in different name spaces, so they don't overlap and don't need to
+      have unique logical names.
+
+      <note>
+        Global shared folders are not implemented in the current vesion of the
+        product.
+      </note>
     </desc>
 
@@ -7837 +7865 @@
   <interface
      name="IInternalSessionControl" extends="$unknown"
-     uuid="80a9b698-cc60-48cf-ab88-a7c2ea4013a6"
+     uuid="e25a28b0-a58a-4582-b7c8-40abaa1f5d5b"
      internal="yes"
      wsmap="suppress"
@@ -7937 +7965 @@
         associated virtual machine have changed.
       </desc>
+    </method>
+
+    <method name="onSharedFolderChange">
+      <desc>
+        Triggered when a permanent (global or machine) shared folder has been
+        created or removed.
+        <note>
+          We don't pass shared folder parameters in this notification because
+          the order in which parallel notifications are delivered is not defined,
+          therefore it could happen that these parameters were outdated by the
+          time of processing this notification.
+        </note>
+      </desc>
+      <param name="global" type="boolean" dir="in"/>
     </method>
 

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

@@ -176 +176 @@
     HRESULT onVRDPServerChange();
     HRESULT onUSBControllerChange();
+    HRESULT onSharedFolderChange (BOOL aGlobal);
     HRESULT onUSBDeviceAttach (IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError);
     HRESULT onUSBDeviceDetach (INPTR GUIDPARAM aId, IVirtualBoxErrorInfo *aError);
@@ -288 +289 @@
 
     /**
+     *  Same as AutoVMCaller but allows a null VM pointer (to trigger an error
+     *  instead of assertion).
+     */
+    typedef AutoVMCallerBase <false, true> AutoVMCallerWeak;
+
+    /**
+     *  Same as AutoVMCaller but doesn't set extended error info on failure
+     *  and allows a null VM pointer (to trigger an error instead of
+     *  assertion).
+     */
+    typedef AutoVMCallerBase <true, true> AutoVMCallerQuietWeak;
+
+    /**
      *  Base template for SaveVMPtr and SaveVMPtrQuiet.
      */
@@ -344 +358 @@
     typedef SafeVMPtrBase <true> SafeVMPtrQuiet;
 
+    typedef std::map <Bstr, ComObjPtr <SharedFolder> > SharedFolderMap;
+    typedef std::map <Bstr, Bstr> SharedFolderDataMap;
+
 private:
 
     typedef std::list <ComObjPtr <OUSBDevice> > USBDeviceList;
     typedef std::list <ComObjPtr <RemoteUSBDevice> > RemoteUSBDeviceList;
-    typedef std::list <ComObjPtr <SharedFolder> > SharedFolderList;
 
     HRESULT addVMCaller (bool aQuiet = false, bool aAllowNullVM = false);
@@ -370 +386 @@
                               ComObjPtr <SharedFolder> &aSharedFolder,
                               bool aSetError = false);
+
+    HRESULT fetchSharedFolders (BOOL aGlobal);
+    bool findOtherSharedFolder (INPTR BSTR aName, 
+                                SharedFolderDataMap::const_iterator &aIt);
+
+    HRESULT createSharedFolder (INPTR BSTR aName, INPTR BSTR aHostPath);
+    HRESULT removeSharedFolder (INPTR BSTR aName);
 
     static DECLCALLBACK(int) configConstructor(PVM pVM, void *pvConsole);
@@ -470 +493 @@
     USBDeviceList mUSBDevices;
     RemoteUSBDeviceList mRemoteUSBDevices;
-    SharedFolderList mSharedFolders;
+
+    SharedFolderMap mSharedFolders;
+    SharedFolderDataMap mMachineSharedFolders;
+    SharedFolderDataMap mGlobalSharedFolders;
 
     /** The VM instance handle. */

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

@@ -534 +534 @@
     virtual HRESULT onVRDPServerChange() { return S_OK; }
     virtual HRESULT onUSBControllerChange() { return S_OK; }
+    virtual HRESULT onSharedFolderChange() { return S_OK; }
 
     int calculateFullPath (const char *aPath, Utf8Str &aResult);
@@ -783 +784 @@
     HRESULT onUSBDeviceDetach (INPTR GUIDPARAM aId,
                                IVirtualBoxErrorInfo *aError);
+    HRESULT onSharedFolderChange();
 
 private:

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

@@ -102 +102 @@
     STDMETHOD(OnVRDPServerChange)();
     STDMETHOD(OnUSBControllerChange)();
+    STDMETHOD(OnSharedFolderChange) (BOOL aGlobal);
     STDMETHOD(OnUSBDeviceAttach) (IUSBDevice *aDevice, IVirtualBoxErrorInfo *aError);
     STDMETHOD(OnUSBDeviceDetach) (INPTR GUIDPARAM aId, IVirtualBoxErrorInfo *aError);