Changeset 108046 in vbox for trunk/src/VBox/Main

Timestamp:

Feb 4, 2025 5:24:54 AM (2 weeks ago)

Author:

vboxsync

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

167323

Message:

doc/manual,include/VBox,Frontends/{VBoxManage,VirtualBox/src},Main/{include,SharedFolder,Console,Machine,VirtualBox,VirtualBox.xidl}: Added global shared folders and adjusted fetching and handling of folders between shared folder types bugref:3544

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (5 diffs)
• include/ConsoleSharedFolderImpl.h (modified) (1 diff)
• include/MachineImpl.h (modified) (2 diffs)
• include/SharedFolderImpl.h (modified) (2 diffs)
• include/VirtualBoxImpl.h (modified) (2 diffs)
• src-all/SharedFolderImpl.cpp (modified) (6 diffs)
• src-client/ConsoleImpl.cpp (modified) (3 diffs)
• src-server/MachineImpl.cpp (modified) (5 diffs)
• src-server/VirtualBoxImpl.cpp (modified) (6 diffs)
• xml/Settings.cpp (modified) (6 diffs)
• xml/VirtualBox-settings.xsd (modified) (1 diff)

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

@@ -2764 +2764 @@
   <interface
     name="IVirtualBox" extends="$unknown"
-    uuid="d644ad1e-c501-4fc7-9ab6-aa6d763bc540"
+    uuid="2ce10519-3c09-45d8-a12d-e887786146b7"
     wsmap="managed"
     rest="managed"
@@ -2952 +2952 @@
         <link to="#createSharedFolder"/>. Existing shared folders can be
         removed using <link to="#removeSharedFolder"/>.
-
-        <note>
-          In the current version of the product, global shared folders are not
-          implemented and therefore this collection is always empty.
-        </note>
       </desc>
     </attribute>
@@ -3630 +3625 @@
         folders and starts sharing it. Refer to the description of
         <link to="ISharedFolder"/> to read more about logical names.
-        <note>
-          In the current implementation, this operation is not
-          implemented.
-        </note>
+
+        <result name="VBOX_E_OBJECT_IN_USE">
+          Shared folder already exists.
+        </result>
+        <result name="VBOX_E_FILE_ERROR">
+          Shared folder @a hostPath not accessible.
+        </result>
+
       </desc>
       <param name="name" type="wstring" dir="in">
@@ -3662 +3661 @@
         created by <link to="#createSharedFolder"/> from the collection of
         shared folders and stops sharing it.
-        <note>
-          In the current implementation, this operation is not
-          implemented.
-        </note>
+
+        <result name="VBOX_E_OBJECT_NOT_FOUND">
+          Shared folder @a name does not exist.
+        </result>
+
       </desc>
       <param name="name" type="wstring" dir="in">
@@ -24717 +24717 @@
       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 version of the
-        product.
-      </note>
     </desc>
 

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

@@ -53 +53 @@
     HRESULT init(Console *aConsole, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
                  bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
-//     HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
-//                  bool aWritable, const com::Utf8Str &aAutoMountPoint, bool aAutoMount, bool fFailOnError);
+//  HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
+//               bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
     void uninit();
 

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

@@ -566 +566 @@
     virtual HRESULT i_onCPUExecutionCapChange(ULONG /* aExecutionCap */) { return S_OK; }
     virtual HRESULT i_onMediumChange(IMediumAttachment * /* mediumAttachment */, BOOL /* force */) { return S_OK; }
-    virtual HRESULT i_onSharedFolderChange() { return S_OK; }
+    virtual HRESULT i_onSharedFolderChange(BOOL /* aGlobal */) { return S_OK; }
     virtual HRESULT i_onVMProcessPriorityChange(VMProcPriority_T /* aPriority */) { return S_OK; }
     virtual HRESULT i_onClipboardModeChange(ClipboardMode_T /* aClipboardMode */) { return S_OK; }
@@ -1408 +1408 @@
     HRESULT i_onUSBDeviceDetach(IN_BSTR aId,
                                 IVirtualBoxErrorInfo *aError);
-    HRESULT i_onSharedFolderChange() RT_OVERRIDE;
+    HRESULT i_onSharedFolderChange(BOOL aGlobal) RT_OVERRIDE;
     HRESULT i_onClipboardModeChange(ClipboardMode_T aClipboardMode) RT_OVERRIDE;
     HRESULT i_onClipboardFileTransferModeChange(BOOL aEnable) RT_OVERRIDE;

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

@@ -37 +37 @@
 class Console;
 
+namespace settings
+{
+    struct SharedFolder;
+}
+
 class ATL_NO_VTABLE SharedFolder :
     public SharedFolderWrap
@@ -54 +59 @@
 //    HRESULT init(Console *aConsole, const com::Utf8Str &aName, const com::Utf8Str &aHostPath,
 //                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError);
-//     HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
-//                  bool aWritable, const com::Utf8Str &aAutoMountPoint, bool aAutoMount, bool fFailOnError);
+    HRESULT init(VirtualBox *aVirtualBox, const Utf8Str &aName, const Utf8Str &aHostPath,
+                 bool aWritable, bool aAutoMount, const com::Utf8Str &aAutoMountPoint, bool fFailOnError,
+                 SymlinkPolicy_T enmSymlinkPolicy);
+    HRESULT init(VirtualBox *aVirtualBox, const settings::SharedFolder &rData);
     void uninit();
+    HRESULT i_saveSettings(settings::SharedFolder &data);
 
     // public methods for internal purposes only

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

@@ -171 +171 @@
     void i_onMediumConfigChanged(IMedium *aMedium);
     void i_onMediumChanged(IMediumAttachment* aMediumAttachment);
+    void i_onSharedFolderChanged();
     void i_onStorageControllerChanged(const Guid &aMachineId, const com::Utf8Str &aControllerName);
     void i_onStorageDeviceChanged(IMediumAttachment* aStorageDevice, BOOL fRemoved, BOOL fSilent);
@@ -270 +271 @@
                                    bool aSetError,
                                    ComObjPtr<Medium> &pMedium);
+    HRESULT i_findSharedFolder(const Utf8Str &aName,
+                               ComPtr<ISharedFolder> &aSharedFolder);
 
     HRESULT i_findGuestOSType(const Utf8Str &strOSType,

trunk/src/VBox/Main/src-all/SharedFolderImpl.cpp

@@ -167 +167 @@
 }
 
-# if 0
 
 /**
  *  Initializes the shared folder object.
  *
- *  This variant initializes a global instance that lives in the server address space. It is not presently used.
+ *  This variant initializes a global instance that lives in the server address space.
  *
  *  @param aVirtualBox  VirtualBox parent object
@@ -178 +177 @@
  *  @param aHostPath    full path to the shared folder on the host
  *  @param aWritable    writable if true, readonly otherwise
+ *  @param aAutoMount   if auto mounted by guest true, false otherwise
  *  @param aAutoMountPoint Where the guest should try auto mount it.
  *  @param fFailOnError Whether to fail with an error if the shared folder path is bad.
+ *  @param enmSymlinkPolicy The symbolic link creation policy to apply.
  *
  *  @return          COM result indicator
@@ -189 +190 @@
                            bool aAutoMount,
                            const Utf8Str &aAutoMountPoint,
-                           bool fFailOnError)
+                           bool fFailOnError,
+                           SymlinkPolicy_T enmSymlinkPolicy)
 {
     /* Enclose the state transition NotReady->InInit->Ready */
@@ -197 +199 @@
     unconst(mVirtualBox) = aVirtualBox;
 
-    HRESULT hrc = protectedInit(aVirtualBox, aName, aHostPath, aWritable, aAutoMount, aAutoMountPoint, fFailOnError);
+    HRESULT hrc = i_protectedInit(aVirtualBox, aName, aHostPath, aWritable, aAutoMount, aAutoMountPoint, fFailOnError,
+                                  enmSymlinkPolicy);
 
     /* Confirm a successful initialization when it's the case */
@@ -206 +209 @@
 }
 
-# endif
+/**
+ *  Initializes the shared folder object.
+ *
+ *  This variant initializes a global instance that lives in the server address space.
+ *
+ *  @param aVirtualBox  VirtualBox parent object
+ *  @param rData        Settings shared folder
+ *
+ *  @return          COM result indicator
+ */
+HRESULT SharedFolder::init(VirtualBox *aVirtualBox, const settings::SharedFolder &rData)
+{
+    /* Enclose the state transition NotReady->InInit->Ready */
+    AutoInitSpan autoInitSpan(this);
+    AssertReturn(autoInitSpan.isOk(), E_FAIL);
+
+    unconst(mVirtualBox) = aVirtualBox;
+    HRESULT hrc = i_protectedInit(aVirtualBox, rData.strName, rData.strHostPath,
+                                  rData.fWritable, rData.fAutoMount, rData.strAutoMountPoint,
+                                  false, rData.enmSymlinkPolicy);
+
+    /* Confirm a successful initialization or not: */
+    if (SUCCEEDED(hrc))
+        autoInitSpan.setSucceeded();
+    else
+        autoInitSpan.setFailed(hrc);
+    return hrc;
+}
+
 
 /**
@@ -301 +332 @@
 }
 
+HRESULT SharedFolder::i_saveSettings(settings::SharedFolder &data)
+{
+    AutoCaller autoCaller(this);
+    if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    AssertReturn(!m->strName.isEmpty(), E_FAIL);
+    data.strName = m->strName;
+    data.strHostPath = m->strHostPath;
+    data.fWritable = m->fWritable != FALSE;
+    data.fAutoMount = m->fAutoMount != FALSE;
+    data.strAutoMountPoint = m->strAutoMountPoint;
+    data.enmSymlinkPolicy = m->enmSymlinkPolicy;
+
+    return S_OK;
+}
+
 // wrapped ISharedFolder properties
 /////////////////////////////////////////////////////////////////////////////

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -3354 +3354 @@
             return hrc;
 
-        /* first, remove the machine or the global folder if there is any */
+        /* second, add the machine or the global folder if there is any */
         SharedFolderDataMap::const_iterator it;
         if (i_findOtherSharedFolder(aName, it))
@@ -9479 +9479 @@
         if (aGlobal)
         {
-            /// @todo grab & process global folders when they are done
+            SharedFolderDataMap oldFolders;
+            oldFolders = m_mapGlobalSharedFolders;
+
+            m_mapGlobalSharedFolders.clear();
+
+            ComPtr<IVirtualBox> ptrVirtualBox;
+            hrc = mMachine->COMGETTER(Parent)(ptrVirtualBox.asOutParam());
+            if (FAILED(hrc)) throw hrc;
+            SafeIfaceArray<ISharedFolder> folders;
+            hrc = ptrVirtualBox->COMGETTER(SharedFolders)(ComSafeArrayAsOutParam(folders));
+            if (FAILED(hrc)) throw hrc;
+
+            for (size_t i = 0; i < folders.size(); ++i)
+            {
+                ComPtr<ISharedFolder> pSharedFolder = folders[i];
+
+                Bstr bstr;
+                hrc = pSharedFolder->COMGETTER(Name)(bstr.asOutParam());
+                if (FAILED(hrc)) throw hrc;
+                Utf8Str strName(bstr);
+
+                hrc = pSharedFolder->COMGETTER(HostPath)(bstr.asOutParam());
+                if (FAILED(hrc)) throw hrc;
+                Utf8Str strHostPath(bstr);
+
+                BOOL writable;
+                hrc = pSharedFolder->COMGETTER(Writable)(&writable);
+                if (FAILED(hrc)) throw hrc;
+
+                BOOL autoMount;
+                hrc = pSharedFolder->COMGETTER(AutoMount)(&autoMount);
+                if (FAILED(hrc)) throw hrc;
+
+                hrc = pSharedFolder->COMGETTER(AutoMountPoint)(bstr.asOutParam());
+                if (FAILED(hrc)) throw hrc;
+                Utf8Str strAutoMountPoint(bstr);
+
+                m_mapGlobalSharedFolders.insert(std::make_pair(strName,
+                                                               SharedFolderData(strHostPath, !!writable,
+                                                                                 !!autoMount, strAutoMountPoint)));
+
+                /* send changes to HGCM if the VM is running */
+                if (online)
+                {
+                    SharedFolderDataMap::iterator it = oldFolders.find(strName);
+                    if (    it == oldFolders.end()
+                         || it->second.m_strHostPath != strHostPath)
+                    {
+                        /* a new global folder is added or
+                         * the existing global folder is changed */
+                        if (m_mapSharedFolders.find(strName) != m_mapSharedFolders.end())
+                            ; /* the console folder exists, nothing to do */
+                        else if (m_mapMachineSharedFolders.find(strName) != m_mapMachineSharedFolders.end())
+                            ; /* the machine folder exists, nothing to do */
+                        else
+                        {
+                            /* remove the old global folder (when changed) */
+                            if (it != oldFolders.end())
+                            {
+                                hrc = i_removeSharedFolder(strName);
+                                if (FAILED(hrc)) throw hrc;
+                            }
+
+                            /* create the new global folder */
+                            hrc = i_createSharedFolder(strName,
+                                                       SharedFolderData(strHostPath, !!writable, !!autoMount, strAutoMountPoint));
+                            if (FAILED(hrc)) throw hrc;
+                        }
+                    }
+                    /* forget the processed (or identical) folder */
+                    if (it != oldFolders.end())
+                        oldFolders.erase(it);
+                }
+            }
+
+            /* process outdated (removed) folders */
+            if (online)
+            {
+                for (SharedFolderDataMap::const_iterator it = oldFolders.begin();
+                     it != oldFolders.end(); ++it)
+                {
+                    if (m_mapSharedFolders.find(it->first) != m_mapSharedFolders.end())
+                        ; /* the console folder exists, nothing to do */
+                    else if (m_mapMachineSharedFolders.find(it->first) != m_mapMachineSharedFolders.end())
+                        ; /* the machine folder exists, nothing to do */
+                    else
+                    {
+                        /* remove the outdated global folder */
+                        hrc = i_removeSharedFolder(it->first);
+                        if (FAILED(hrc)) throw hrc;
+                    }
+                }
+            }
         }
         else
@@ -9617 +9709 @@
         return true;
 
-    /* second, search machine folders */
+    /* second, search global folders */
     aIt = m_mapGlobalSharedFolders.find(strName);
     if (aIt != m_mapGlobalSharedFolders.end())

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -5053 +5053 @@
     /* inform the direct session if any */
     alock.release();
-    i_onSharedFolderChange();
+    i_onSharedFolderChange(FALSE);
 
     return S_OK;
@@ -5075 +5075 @@
     /* inform the direct session if any */
     alock.release();
-    i_onSharedFolderChange();
+    i_onSharedFolderChange(FALSE);
 
     return S_OK;
@@ -11786 +11786 @@
 
         if (flModifications & IsModified_SharedFolders)
-            that->i_onSharedFolderChange();
+            that->i_onSharedFolderChange(FALSE);
 
         if (flModifications & IsModified_VRDEServer)
@@ -14331 +14331 @@
  *  @note Locks this object for reading.
  */
-HRESULT SessionMachine::i_onSharedFolderChange()
+HRESULT SessionMachine::i_onSharedFolderChange(BOOL aGlobal)
 {
     LogFlowThisFunc(("\n"));
@@ -14349 +14349 @@
         return S_OK;
 
-    return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
+    return directControl->OnSharedFolderChange(aGlobal);
 }
 

trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp

@@ -819 +819 @@
         }
 
+        for (settings::SharedFoldersList::const_iterator it = m->pMainConfigFile->llGlobalSharedFolders.begin();
+             it != m->pMainConfigFile->llGlobalSharedFolders.end();
+             ++it)
+        {
+            const settings::SharedFolder &sf = *it;
+            ComObjPtr<SharedFolder> pSharedFolder;
+            hrc = pSharedFolder.createObject();
+            AssertComRCThrowRC(hrc);
+            hrc = pSharedFolder->init(this, sf);
+            if (FAILED(hrc)) throw hrc;
+
+            AutoWriteLock alock(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            m->allSharedFolders.addChild(pSharedFolder);
+            alock.release();
+        }
+
         /* net services - nat networks */
         for (settings::NATNetworksList::const_iterator it = m->pMainConfigFile->llNATNetworks.begin();
@@ -1502 +1518 @@
 HRESULT VirtualBox::getSharedFolders(std::vector<ComPtr<ISharedFolder> > &aSharedFolders)
 {
-    NOREF(aSharedFolders);
-
-    return setError(E_NOTIMPL, tr("Not yet implemented"));
+    AutoReadLock al(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    aSharedFolders.resize(m->allSharedFolders.size());
+    size_t i = 0;
+    for (SharedFoldersOList::const_iterator it= m->allSharedFolders.begin();
+         it!= m->allSharedFolders.end(); ++it, ++i)
+         (*it).queryInterfaceTo(aSharedFolders[i].asOutParam());
+    return S_OK;
 }
 
@@ -2780 +2800 @@
                                        const com::Utf8Str &aAutoMountPoint)
 {
-    NOREF(aName);
-    NOREF(aHostPath);
-    NOREF(aWritable);
-    NOREF(aAutomount);
-    NOREF(aAutoMountPoint);
-
-    return setError(E_NOTIMPL, tr("Not yet implemented"));
+    LogFlowThisFunc(("Entering for '%s' -> '%s'\n", aName.c_str(), aHostPath.c_str()));
+
+    ComPtr<ISharedFolder> found;
+    HRESULT hrc = i_findSharedFolder(aName, found);
+    if (SUCCEEDED(hrc))
+        return setError(VBOX_E_OBJECT_IN_USE,
+                        tr("Shared folder named '%s' already exists"),
+                        aName.c_str());
+
+    ComObjPtr<SharedFolder> sharedFolder;
+    SymlinkPolicy_T enmSymlinkPolicy = SymlinkPolicy_None;
+    sharedFolder.createObject();
+    hrc = sharedFolder->init(this,
+                             aName,
+                             aHostPath,
+                             !!aWritable,
+                             !!aAutomount,
+                             aAutoMountPoint,
+                             true /* fFailOnError */,
+                             enmSymlinkPolicy);
+    if (FAILED(hrc)) return hrc;
+
+    AutoWriteLock alock(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    m->allSharedFolders.addChild(sharedFolder);
+    alock.release();
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+        {
+            alock.acquire();
+            m->allSharedFolders.removeChild(sharedFolder);
+            alock.release();
+        }
+    }
+
+    i_onSharedFolderChanged();
+    LogFlowThisFunc(("Leaving for '%s' -> '%s'\n", aName.c_str(), aHostPath.c_str()));
+    return hrc;
 }
 
 HRESULT VirtualBox::removeSharedFolder(const com::Utf8Str &aName)
 {
-    NOREF(aName);
-    return setError(E_NOTIMPL, tr("Not yet implemented"));
+    LogFlowThisFunc(("Entering for '%s'\n", aName.c_str()));
+
+    ComPtr<ISharedFolder> sharedFolder;
+    HRESULT hrc = i_findSharedFolder(aName, sharedFolder);
+    if (FAILED(hrc))
+        return hrc;
+
+    ISharedFolder *aP = sharedFolder;
+    SharedFolder *aP2 = static_cast<SharedFolder *>(aP);
+    AutoWriteLock alock(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+    m->allSharedFolders.removeChild(aP2);
+    alock.release();
+
+    {
+        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = i_saveSettings();
+        vboxLock.release();
+
+        if (FAILED(hrc))
+        {
+            alock.acquire();
+            m->allSharedFolders.addChild(aP2);
+            alock.release();
+        }
+    }
+
+    i_onSharedFolderChanged();
+    LogFlowThisFunc(("Leaving for '%s'\n", aName.c_str()));
+
+    return hrc;
 }
 
@@ -3622 +3704 @@
     AssertComRCReturnVoid(hrc);
     i_postEvent(new AsyncEvent(this, ptrEvent));
+}
+
+/**
+ *  @note Locks this object for reading.
+ */
+void VirtualBox::i_onSharedFolderChanged()
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.hrc());
+
+    SessionMachinesList aMachines;
+    i_getOpenedMachines(aMachines, NULL);
+    for (SessionMachinesList::iterator it = aMachines.begin();
+         it != aMachines.end();
+         ++it)
+    {
+        ComObjPtr<SessionMachine> &pMachine = *it;
+        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
+        pMachine->i_onSharedFolderChange(TRUE);
+    }
+    aMachines.clear();
 }
 
@@ -4555 +4660 @@
 }
 
+/**
+ *  Searches for a shared folder with the given logical name
+ *  in the collection of shared folders.
+ *
+ *  @param aName            logical name of the shared folder
+ *  @param aSharedFolder    where to return the found object
+ *
+ *  @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
+ *
+ *  @note must be called from under the object's lock
+ */
+HRESULT VirtualBox::i_findSharedFolder(const Utf8Str &aName,
+                                       ComPtr<ISharedFolder> &aSharedFolder)
+{
+    ComObjPtr<SharedFolder> found;
+
+    AutoReadLock alock(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+
+    for (SharedFoldersOList::const_iterator it = m->allSharedFolders.begin();
+        it != m->allSharedFolders.end();
+        ++it)
+    {
+        Bstr bstrSharedFolderName;
+        HRESULT hrc = (*it)->COMGETTER(Name)(bstrSharedFolderName.asOutParam());
+        if (FAILED(hrc)) return hrc;
+
+        if (Utf8Str(bstrSharedFolderName) == aName)
+        {
+            found = *it;
+            break;
+        }
+    }
+    if (!found)
+        return VBOX_E_OBJECT_NOT_FOUND;
+    return found.queryInterfaceTo(aSharedFolder.asOutParam());
+}
+
 /* Look for a GuestOSType object */
 HRESULT VirtualBox::i_findGuestOSType(const Utf8Str &strOSType,
@@ -5244 +5386 @@
                 if (FAILED(hrc)) throw hrc;
                 m->pMainConfigFile->llDhcpServers.push_back(d);
+            }
+        }
+        m->pMainConfigFile->llGlobalSharedFolders.clear();
+        {
+            AutoReadLock sharedFolderLock(m->allSharedFolders.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+            for (SharedFoldersOList::const_iterator it = m->allSharedFolders.begin();
+                 it != m->allSharedFolders.end();
+                 ++it)
+            {
+                settings::SharedFolder sf;
+                hrc = (*it)->i_saveSettings(sf);
+                if (FAILED(hrc)) throw hrc;
+                m->pMainConfigFile->llGlobalSharedFolders.push_back(sf);
             }
         }

trunk/src/VBox/Main/xml/Settings.cpp

@@ -1648 +1648 @@
 }
 
+/**
+ * Constructor. Needs to set sane defaults which stand the test of time.
+ */
+SharedFolder::SharedFolder() :
+    fWritable(false),
+    fAutoMount(false),
+    enmSymlinkPolicy(SymlinkPolicy_None)
+{
+}
+
+/**
+ * Comparison operator. This gets called from MachineConfigFile::operator==,
+ * which in turn gets called from Machine::saveSettings to figure out whether
+ * machine settings have really changed and thus need to be written out to disk.
+ */
+bool SharedFolder::operator==(const SharedFolder &g) const
+{
+    return (this == &g)
+        || (   strName           == g.strName
+            && strHostPath       == g.strHostPath
+            && fWritable         == g.fWritable
+            && fAutoMount        == g.fAutoMount
+            && strAutoMountPoint == g.strAutoMountPoint
+            && enmSymlinkPolicy  == g.enmSymlinkPolicy);
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2098 +2124 @@
                 throw ConfigFileError(this, pelmNet, N_("Required NATNetwork/@networkName, @gateway, @network,@advertiseDefaultIpv6Route , @needDhcp or @enabled attribute is missing"));
         }
+    }
+}
+
+/**
+ * Reads in the \<SharedFolders\> chunk.
+ * @param elmSharedFolders
+ */
+void MainConfigFile::readSharedFolders(const xml::ElementNode &elmSharedFolders)
+{
+    xml::NodesLoop nl1(elmSharedFolders, "SharedFolder");
+    const xml::ElementNode *pelmFolder;
+    while ((pelmFolder = nl1.forAllNodes()))
+    {
+        SharedFolder sf;
+        pelmFolder->getAttributeValue("name", sf.strName);
+        pelmFolder->getAttributeValue("hostPath", sf.strHostPath);
+        pelmFolder->getAttributeValue("writable", sf.fWritable);
+        pelmFolder->getAttributeValue("autoMount", sf.fAutoMount);
+        pelmFolder->getAttributeValue("autoMountPoint", sf.strAutoMountPoint);
+
+        Utf8Str strTemp;
+        if (pelmFolder->getAttributeValue("symlinkPolicy", strTemp))
+        {
+            if (strTemp == "forbidden")
+                sf.enmSymlinkPolicy = SymlinkPolicy_Forbidden;
+            else if (strTemp == "subtree")
+                sf.enmSymlinkPolicy = SymlinkPolicy_AllowedInShareSubtree;
+            else if (strTemp == "relative")
+                sf.enmSymlinkPolicy = SymlinkPolicy_AllowedToRelativeTargets;
+            else if (strTemp == "any")
+                sf.enmSymlinkPolicy = SymlinkPolicy_AllowedToAnyTarget;
+            else
+                throw ConfigFileError(this,
+                                      pelmFolder,
+                                      N_("Invalid value '%s' in SharedFolder/@symlinkPolicy attribute"),
+                                      strTemp.c_str());
+        }
+        llGlobalSharedFolders.push_back(sf);
     }
 }
@@ -2433 +2497 @@
                         }
                     }
+                    else if (pelmGlobalChild->nameEquals("SharedFolders"))
+                        readSharedFolders(*pelmGlobalChild);
                     else if (pelmGlobalChild->nameEquals("USBDeviceFilters"))
                         readUSBDeviceFilters(*pelmGlobalChild, host.llUSBDeviceFilters);
@@ -2508 +2574 @@
             m->sv = SettingsVersion_v1_14;
     }
+    if (m->sv < SettingsVersion_v1_20)
+    {
+        // VirtualBox 7.1 adds global shared folders.
+        if (!llGlobalSharedFolders.empty())
+            m->sv = SettingsVersion_v1_20;
+    }
+
 }
 
@@ -2623 +2696 @@
     }
 #endif /* VBOX_WITH_CLOUD_NET */
+
+xml::ElementNode *pelmSharedFolders = pelmGlobal->createChild("SharedFolders");
+    if (!llGlobalSharedFolders.empty())
+    {
+        for (SharedFoldersList::const_iterator it = llGlobalSharedFolders.begin();
+             it != llGlobalSharedFolders.end();
+             ++it)
+        {
+            const SharedFolder &sf = *it;
+            xml::ElementNode *pelmThis = pelmSharedFolders->createChild("SharedFolder");
+            pelmThis->setAttribute("name", sf.strName);
+            pelmThis->setAttribute("hostPath", sf.strHostPath);
+            pelmThis->setAttribute("writable", sf.fWritable);
+            pelmThis->setAttribute("autoMount", sf.fAutoMount);
+            if (sf.strAutoMountPoint.isNotEmpty())
+                pelmThis->setAttribute("autoMountPoint", sf.strAutoMountPoint);
+            const char *pcszSymlinkPolicy;
+            if (sf.enmSymlinkPolicy != SymlinkPolicy_None)
+            {
+                switch (sf.enmSymlinkPolicy)
+                {
+                    default: /*case SymlinkPolicy_Forbidden:*/    pcszSymlinkPolicy = "forbidden";  break;
+                    case SymlinkPolicy_AllowedInShareSubtree:     pcszSymlinkPolicy = "subtree";    break;
+                    case SymlinkPolicy_AllowedToRelativeTargets:  pcszSymlinkPolicy = "relative";   break;
+                    case SymlinkPolicy_AllowedToAnyTarget:        pcszSymlinkPolicy = "any";        break;
+                }
+                pelmThis->setAttribute("symlinkPolicy", pcszSymlinkPolicy);
+            }
+
+        }
+    }
 
 #ifdef VBOX_WITH_UPDATE_AGENT
@@ -3789 +3893 @@
 }
 
-/**
- * Constructor. Needs to set sane defaults which stand the test of time.
- */
-SharedFolder::SharedFolder() :
-    fWritable(false),
-    fAutoMount(false),
-    enmSymlinkPolicy(SymlinkPolicy_None)
-{
-}
-
-/**
- * Comparison operator. This gets called from MachineConfigFile::operator==,
- * which in turn gets called from Machine::saveSettings to figure out whether
- * machine settings have really changed and thus need to be written out to disk.
- */
-bool SharedFolder::operator==(const SharedFolder &g) const
-{
-    return (this == &g)
-        || (   strName           == g.strName
-            && strHostPath       == g.strHostPath
-            && fWritable         == g.fWritable
-            && fAutoMount        == g.fAutoMount
-            && strAutoMountPoint == g.strAutoMountPoint
-            && enmSymlinkPolicy  == g.enmSymlinkPolicy);
-}
 
 /**

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

@@ -571 +571 @@
       </xsd:complexType>
     </xsd:element>
+    <xsd:element name="SharedFolders" type="TSharedFolders" minOccurs="0"/>
     <xsd:element name="USBDeviceFilters">
       <xsd:complexType>