Changeset 74431 in vbox for trunk/src/VBox

Timestamp:

Sep 24, 2018 9:16:17 AM (6 years ago)

Author:

vboxsync

Message:

Main,GUI,VBoxManage: Provide API for proxy settings that picks up the current GUI settings and converts it to SystemProperties XML attributes. Adjusted GUI to use it. Updated VBoxMangage system properties handling accordingly. bugref:9249

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageHelp.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageList.cpp (modified) (2 diffs)
• Frontends/VBoxManage/VBoxManageMisc.cpp (modified) (1 diff)
• Frontends/VirtualBox/src/globals/VBoxUtils.h (modified) (1 diff)
• Frontends/VirtualBox/src/net/UINetworkReply.cpp (modified) (2 diffs)
• Frontends/VirtualBox/src/settings/global/UIGlobalSettingsProxy.cpp (modified) (8 diffs)
• Main/idl/VirtualBox.xidl (modified) (2 diffs)
• Main/include/SystemPropertiesImpl.h (modified) (1 diff)
• Main/src-server/SystemPropertiesImpl.cpp (modified) (7 diffs)
• Main/xml/Settings.cpp (modified) (7 diffs)

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

@@ -1058 +1058 @@
                      "                            defaultfrontend default|<name>\n"
                      "                            logginglevel <log setting>\n"
+                     "                            proxymode system|noproxy|manual\n"
+                     "                            proxyurl <url>\n"
                      "\n", SEP);
 

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

@@ -623 +623 @@
 {
     ComPtr<ISystemProperties> systemProperties;
-    pVirtualBox->COMGETTER(SystemProperties)(systemProperties.asOutParam());
+    CHECK_ERROR2I_RET(pVirtualBox, COMGETTER(SystemProperties)(systemProperties.asOutParam()), hrcCheck);
 
     Bstr str;
@@ -758 +758 @@
     systemProperties->COMGETTER(LoggingLevel)(str.asOutParam());
     RTPrintf("Logging Level:                   %ls\n", str.raw());
+    ProxyMode_T enmProxyMode = (ProxyMode_T)42;
+    systemProperties->COMGETTER(ProxyMode)(&enmProxyMode);
+    psz = "Unknown";
+    switch (enmProxyMode)
+    {
+        case ProxyMode_System:              psz = "System"; break;
+        case ProxyMode_NoProxy:             psz = "NoProxy"; break;
+        case ProxyMode_Manual:              psz = "Manual"; break;
+    }
+    RTPrintf("Proxy Mode:                      %s\n", psz);
+    systemProperties->COMGETTER(ProxyURL)(str.asOutParam());
+    RTPrintf("Proxy URL:                       %ls\n", str.raw());
     return S_OK;
 }

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

@@ -1046 +1046 @@
             bstrLoggingLevel.setNull();
         CHECK_ERROR(systemProperties, COMSETTER(LoggingLevel)(bstrLoggingLevel.raw()));
+    }
+    else if (!strcmp(a->argv[0], "proxymode"))
+    {
+        ProxyMode_T enmProxyMode;
+        if (!RTStrICmpAscii(a->argv[1], "system"))
+            enmProxyMode = ProxyMode_System;
+        else if (!RTStrICmpAscii(a->argv[1], "noproxy"))
+            enmProxyMode = ProxyMode_NoProxy;
+        else if (!RTStrICmpAscii(a->argv[1], "manual"))
+            enmProxyMode = ProxyMode_Manual;
+        else
+            return errorArgument("Unknown proxy mode: '%s'", a->argv[1]);
+        CHECK_ERROR(systemProperties, COMSETTER(ProxyMode)(enmProxyMode));
+    }
+    else if (!strcmp(a->argv[0], "proxyurl"))
+    {
+        Bstr bstrProxyUrl(a->argv[1]);
+        CHECK_ERROR(systemProperties, COMSETTER(ProxyURL)(bstrProxyUrl.raw()));
     }
     else

trunk/src/VBox/Frontends/VirtualBox/src/globals/VBoxUtils.h

@@ -62 +62 @@
 
 
-/** Simple class,
-  * containing functionality to (de)serialize proxy settings. */
-class UIProxyManager
-{
-public:
-
-    /** Proxy states. */
-    enum ProxyState
-    {
-        ProxyState_Disabled,
-        ProxyState_Enabled,
-        ProxyState_Auto
-    };
-
-    /** Constructs proxy-manager which parses @a strProxySettings. */
-    UIProxyManager(const QString &strProxySettings = QString())
-        : m_enmProxyState(ProxyState_Auto)
-        , m_fAuthEnabled(false)
-    {
-        /* Parse proxy settings: */
-        if (strProxySettings.isEmpty())
-            return;
-        QStringList proxySettings = strProxySettings.split(",");
-
-        /* Parse proxy state, host and port: */
-        if (proxySettings.size() > 0)
-            m_enmProxyState = proxyStateFromString(proxySettings[0]);
-        if (proxySettings.size() > 1)
-            m_strProxyHost = proxySettings[1];
-        if (proxySettings.size() > 2)
-            m_strProxyPort = proxySettings[2];
-
-        /* Parse whether proxy auth enabled and has login/password: */
-        if (proxySettings.size() > 3)
-            m_fAuthEnabled = proxySettings[3] == "authEnabled";
-        if (proxySettings.size() > 4)
-            m_strAuthLogin = proxySettings[4];
-        if (proxySettings.size() > 5)
-            m_strAuthPassword = proxySettings[5];
-    }
-
-    /** Serializes proxy settings. */
-    QString toString() const
-    {
-        /* Serialize settings: */
-        QString strResult;
-        if (m_enmProxyState != ProxyState_Auto || !m_strProxyHost.isEmpty() || !m_strProxyPort.isEmpty() ||
-            m_fAuthEnabled || !m_strAuthLogin.isEmpty() || !m_strAuthPassword.isEmpty())
-        {
-            QStringList proxySettings;
-            proxySettings << proxyStateToString(m_enmProxyState);
-            proxySettings << m_strProxyHost;
-            proxySettings << m_strProxyPort;
-            proxySettings << QString(m_fAuthEnabled ? "authEnabled" : "authDisabled");
-            proxySettings << m_strAuthLogin;
-            proxySettings << m_strAuthPassword;
-            strResult = proxySettings.join(",");
-        }
-        return strResult;
-    }
-
-    /** Returns the proxy state. */
-    ProxyState proxyState() const { return m_enmProxyState; }
-    /** Returns the proxy host. */
-    const QString &proxyHost() const { return m_strProxyHost; }
-    /** Returns the proxy port. */
-    const QString &proxyPort() const { return m_strProxyPort; }
-
-    /** Returns whether the proxy auth is enabled. */
-    bool authEnabled() const { return m_fAuthEnabled; }
-    /** Returns the proxy auth login. */
-    const QString &authLogin() const { return m_strAuthLogin; }
-    /** Returns the proxy auth password. */
-    const QString &authPassword() const { return m_strAuthPassword; }
-
-    /** Defines the proxy @a enmState. */
-    void setProxyState(ProxyState enmState) { m_enmProxyState = enmState; }
-    /** Defines the proxy @a strHost. */
-    void setProxyHost(const QString &strHost) { m_strProxyHost = strHost; }
-    /** Defines the proxy @a strPort. */
-    void setProxyPort(const QString &strPort) { m_strProxyPort = strPort; }
-
-    /** Defines whether the proxy auth is @a fEnabled. */
-    void setAuthEnabled(bool fEnabled) { m_fAuthEnabled = fEnabled; }
-    /** Defines the proxy auth @a strLogin. */
-    void setAuthLogin(const QString &strLogin) { m_strAuthLogin = strLogin; }
-    /** Defines the proxy auth @a strPassword. */
-    void setAuthPassword(const QString &strPassword) { m_strAuthPassword = strPassword; }
-
-private:
-
-    /** Converts passed @a enmState to corresponding #QString. */
-    static QString proxyStateToString(ProxyState enmState)
-    {
-        switch (enmState)
-        {
-            case ProxyState_Disabled: return QString("ProxyDisabled");
-            case ProxyState_Enabled:  return QString("ProxyEnabled");
-            case ProxyState_Auto:     break;
-        }
-        return QString("ProxyAuto");
-    }
-
-    /** Converts passed @a strState to corresponding #ProxyState. */
-    static ProxyState proxyStateFromString(const QString &strState)
-    {
-        /* Compose the map of known states: */
-        QMap<QString, ProxyState> states;
-        states["ProxyDisabled"] = ProxyState_Disabled; // New since VBox 5.0
-        states["proxyEnabled"]  = ProxyState_Enabled;  // Old since VBox 4.1
-        states["ProxyEnabled"]  = ProxyState_Enabled;  // New since VBox 5.0
-        /* Return one of registered or 'Auto' by default: */
-        return states.value(strState, ProxyState_Auto);
-    }
-
-    /** Holds the proxy state. */
-    ProxyState  m_enmProxyState;
-    /** Holds the proxy host. */
-    QString     m_strProxyHost;
-    /** Holds the proxy port. */
-    QString     m_strProxyPort;
-
-    /** Holds whether the proxy auth is enabled. */
-    bool     m_fAuthEnabled;
-    /** Holds the proxy auth login. */
-    QString  m_strAuthLogin;
-    /** Holds the proxy auth password. */
-    QString  m_strAuthPassword;
-};
-
-
 #endif /* !___VBoxUtils_h___ */
 

trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkReply.cpp

@@ -35 +35 @@
 #  include "VBoxGlobal.h"
 #  include "VBoxUtils.h"
+#  include "CSystemProperties.h"
 # else /* VBOX_GUI_IN_TST_SSL_CERT_DOWNLOADS */
 #  include <VBox/log.h>
@@ -384 +385 @@
 
 #ifndef VBOX_GUI_IN_TST_SSL_CERT_DOWNLOADS
-    /* Get the proxy-manager: */
-    UIProxyManager proxyManager(gEDataManager->proxySettings());
-
     /* If the specific proxy settings are enabled, we'll use them
      * unless user disabled that functionality manually. */
-    switch (proxyManager.proxyState())
-    {
-        case UIProxyManager::ProxyState_Enabled:
-            return RTHttpSetProxy(m_hHttp,
-                                  proxyManager.proxyHost().toUtf8().constData(),
-                                  proxyManager.proxyPort().toUInt(),
-                                  NULL /* pszProxyUser */, NULL /* pszProxyPwd */);
-        case UIProxyManager::ProxyState_Disabled:
+    CSystemProperties properties = vboxGlobal().virtualBox().GetSystemProperties();
+    KProxyMode enmProxyMode = properties.GetProxyMode();
+    AssertReturn(properties.isOk(), VERR_INTERNAL_ERROR_3);
+    switch (enmProxyMode)
+    {
+        case KProxyMode_Manual:
+        {
+            QString strProxyURL = properties.GetProxyURL();
+            return RTHttpSetProxyByUrl(m_hHttp, strProxyURL.toUtf8().constData());
+        }
+        case KProxyMode_NoProxy:
             return VINF_SUCCESS;
         default:

trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsProxy.cpp

@@ -30 +30 @@
 # include "UIMessageCenter.h"
 # include "VBoxUtils.h"
+# include "VBoxGlobal.h"
+# include "CSystemProperties.h"
 
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
@@ -39 +41 @@
     /** Constructs data. */
     UIDataSettingsGlobalProxy()
-        : m_enmProxyState(UIProxyManager::ProxyState_Auto)
+        : m_enmProxyMode(KProxyMode_System)
         , m_strProxyHost(QString())
         , m_strProxyPort(QString())
@@ -48 +50 @@
     {
         return true
-               && (m_enmProxyState == other.m_enmProxyState)
+               && (m_enmProxyMode == other.m_enmProxyMode)
                && (m_strProxyHost == other.m_strProxyHost)
                && (m_strProxyPort == other.m_strProxyPort)
@@ -59 +61 @@
     bool operator!=(const UIDataSettingsGlobalProxy &other) const { return !equal(other); }
 
-    /** Holds the proxy state. */
-    UIProxyManager::ProxyState m_enmProxyState;
+    /** Holds the proxy mode. */
+    KProxyMode m_enmProxyMode;
     /** Holds the proxy host. */
     QString m_strProxyHost;
@@ -93 +95 @@
 
     /* Gather old proxy data: */
-    UIProxyManager proxyManager(gEDataManager->proxySettings());
-    oldProxyData.m_enmProxyState = proxyManager.proxyState();
-    oldProxyData.m_strProxyHost = proxyManager.proxyHost();
-    oldProxyData.m_strProxyPort = proxyManager.proxyPort();
+    CSystemProperties properties = vboxGlobal().virtualBox().GetSystemProperties();
+    if (properties.isNotNull())
+    {
+        oldProxyData.m_enmProxyMode = properties.GetProxyMode();
+        oldProxyData.m_strProxyHost = properties.GetProxyURL();
+        oldProxyData.m_strProxyPort = "";
+        if (!oldProxyData.m_strProxyHost.isEmpty())
+        {
+            QUrl url(oldProxyData.m_strProxyHost);
+            if (url.port() != -1)
+            {
+                oldProxyData.m_strProxyPort = QString::number(url.port());
+                url.setPort(-1);
+                oldProxyData.m_strProxyHost = url.url();
+            }
+        }
+    }
 
     /* Cache old proxy data: */
@@ -111 +126 @@
 
     /* Load old proxy data from the cache: */
-    switch (oldProxyData.m_enmProxyState)
-    {
-        case UIProxyManager::ProxyState_Auto:     m_pRadioProxyAuto->setChecked(true); break;
-        case UIProxyManager::ProxyState_Disabled: m_pRadioProxyDisabled->setChecked(true); break;
-        case UIProxyManager::ProxyState_Enabled:  m_pRadioProxyEnabled->setChecked(true); break;
+    switch (oldProxyData.m_enmProxyMode)
+    {
+        case KProxyMode_System:  m_pRadioProxyAuto->setChecked(true); break;
+        case KProxyMode_NoProxy: m_pRadioProxyDisabled->setChecked(true); break;
+        case KProxyMode_Manual:  m_pRadioProxyEnabled->setChecked(true); break;
+        case KProxyMode_Max: break; /* (compiler warnings) */
     }
     m_pHostEditor->setText(oldProxyData.m_strProxyHost);
@@ -131 +147 @@
 
     /* Gather new proxy data: */
-    newProxyData.m_enmProxyState = m_pRadioProxyEnabled->isChecked()  ? UIProxyManager::ProxyState_Enabled :
-                                   m_pRadioProxyDisabled->isChecked() ? UIProxyManager::ProxyState_Disabled :
-                                                                        UIProxyManager::ProxyState_Auto;
+    newProxyData.m_enmProxyMode = m_pRadioProxyEnabled->isChecked()  ? KProxyMode_Manual
+                                : m_pRadioProxyDisabled->isChecked() ? KProxyMode_NoProxy : KProxyMode_System;
     newProxyData.m_strProxyHost = m_pHostEditor->text();
     newProxyData.m_strProxyPort = m_pPortEditor->text();
@@ -266 +281 @@
 
         /* Save new proxy data from the cache: */
-        UIProxyManager proxyManager;
-        proxyManager.setProxyState(newProxyData.m_enmProxyState);
-        proxyManager.setProxyHost(newProxyData.m_strProxyHost);
-        proxyManager.setProxyPort(newProxyData.m_strProxyPort);
-        gEDataManager->setProxySettings(proxyManager.toString());
+        CSystemProperties properties = vboxGlobal().virtualBox().GetSystemProperties();
+        if (properties.isNull())
+            fSuccess = false;
+        else
+        {
+            properties.SetProxyMode(newProxyData.m_enmProxyMode);
+            fSuccess &= properties.isOk();
+
+            if (newProxyData.m_strProxyPort.isEmpty())
+                properties.SetProxyURL(newProxyData.m_strProxyHost);
+            else
+            {
+                QUrl url(newProxyData.m_strProxyHost);
+                if (url.port() == -1)
+                    url.setPort(newProxyData.m_strProxyPort.toUInt());
+                properties.SetProxyURL(url.url());
+            }
+            fSuccess &= properties.isOk();
+
+            /* Drop the old extra data setting if still around: */
+            if (fSuccess && !gEDataManager->proxySettings().isEmpty())
+                gEDataManager->setProxySettings(QString());
+        }
     }
     /* Return result: */

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

@@ -9912 +9912 @@
   -->
 
+  <enum name="ProxyMode" uuid="885264b3-b517-40fc-ce46-36e3bae895a4">
+    <desc> Proxy setting: System (default), NoProxy and Manual. <link to="ISystemProperties::proxyMode"/></desc>
+    <const name="System" value="0">
+      <desc>Use the system proxy settings as far as possible.</desc>
+    </const>
+    <const name="NoProxy" value="1">
+      <desc>Direct connection to the Internet.</desc>
+    </const>
+    <const name="Manual" value="2">
+      <desc>Use the manual proxy from <link to="ISystemProperties::proxyURL"/>.</desc>
+    </const>
+  </enum>
+
   <interface
     name="ISystemProperties"
     extends="$unknown"
-    uuid="0eb668d2-495e-5a36-8890-29999b5f030c"
+    uuid="d55176e5-6730-4e9e-fc1f-a59b1f44f78f"
     wsmap="managed"
     reservedMethods="4" reservedAttributes="16"
@@ -10226 +10239 @@
         Supported bitmap formats which can be used with takeScreenShot
         and takeScreenShotToArray methods.
+      </desc>
+    </attribute>
+
+    <attribute name="proxyMode" type="ProxyMode" readonly="no">
+      <desc> The proxy mode setting: System, NoProxy or Manual.</desc>
+    </attribute>
+    <attribute name="proxyURL" type="wstring" readonly="no">
+      <desc>
+       Proxy server URL for the <link to="ProxyMode::Manual" /> proxy mode.
+
+       The format is: [{type}"://"][{userid}[@{password}]:]{server}[":"{port}]
+
+       Valid types are: http (default), https, socks4, socks4a, socks5, socks5h and direct.
+       Please note that these are proxy types defining how the proxy operates rather than
+       how to proxy any similarly named protocol (i.e. don't confuse a http-proxy with
+       proxying the http protocol, as a http-proxy usually can proxy https and other protocols too).
+
+       The port number defaults to 80 for http, 443 for https and 1080 for the socks ones.
+
+       <note>The password is currently stored as plain text!  Use the <link to="ProxyMode::System" />
+       mode if you consider the proxy password to be sensitive.</note>
+
+       An empty string will cause the behavior to be identical to <link to="ProxyMode::System" />.
+       For compatibility with libproxy, an URL starting with "direct://" will cause
+       <link to="ProxyMode::NoProxy" /> behavior.
       </desc>
     </attribute>

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

@@ -106 +106 @@
     HRESULT setDefaultFrontend(const com::Utf8Str &aDefaultFrontend);
     HRESULT getScreenShotFormats(std::vector<BitmapFormat_T> &aScreenShotFormats);
+    HRESULT getProxyMode(ProxyMode_T *pProxyMode);
+    HRESULT setProxyMode(ProxyMode_T aProxyMode);
+    HRESULT getProxyURL(com::Utf8Str &aProxyURL);
+    HRESULT setProxyURL(const com::Utf8Str &aProxyURL);
 
     // wrapped ISystemProperties methods

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

@@ -34 +34 @@
 #include <iprt/path.h>
 #include <iprt/string.h>
+#include <iprt/uri.h>
 #include <iprt/cpp/utils.h>
 
@@ -97 +98 @@
     i_setDefaultVRDEExtPack(Utf8Str::Empty);
 
-    m->ulLogHistoryCount = 3;
+    m->uLogHistoryCount = 3;
 
 
@@ -873 +874 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *count = m->ulLogHistoryCount;
+    *count = m->uLogHistoryCount;
 
     return S_OK;
@@ -882 +883 @@
 {
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->ulLogHistoryCount = count;
+    m->uLogHistoryCount = count;
     alock.release();
 
@@ -986 +987 @@
 }
 
+HRESULT SystemProperties::getProxyMode(ProxyMode_T *pProxyMode)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    ProxyMode_T enmMode = *pProxyMode = (ProxyMode_T)m->uProxyMode;
+    AssertMsgReturn(enmMode == ProxyMode_System || enmMode == ProxyMode_NoProxy || enmMode == ProxyMode_Manual,
+                    ("enmMode=%d\n", enmMode), E_UNEXPECTED);
+    return S_OK;
+}
+
+HRESULT SystemProperties::setProxyMode(ProxyMode_T aProxyMode)
+{
+    /* Validate input. */
+    switch (aProxyMode)
+    {
+        case ProxyMode_System:
+        case ProxyMode_NoProxy:
+        case ProxyMode_Manual:
+            break;
+        default:
+            return setError(E_INVALIDARG, tr("Invalid ProxyMode value: %d"), (int)aProxyMode);
+    }
+
+    /* Set and write out settings. */
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        m->uProxyMode = aProxyMode;
+    }
+    AutoWriteLock alock(mParent COMMA_LOCKVAL_SRC_POS); /* required for saving. */
+    return mParent->i_saveSettings();
+}
+
+HRESULT SystemProperties::getProxyURL(com::Utf8Str &aProxyURL)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    aProxyURL = m->strProxyUrl;
+    return S_OK;
+}
+
+HRESULT SystemProperties::setProxyURL(const com::Utf8Str &aProxyURL)
+{
+    /*
+     * Validate input.
+     */
+    Utf8Str const *pStrProxyUrl = &aProxyURL;
+    Utf8Str strTmp;
+    if (pStrProxyUrl->isNotEmpty())
+    {
+        /* RTUriParse requires a scheme, so append 'http://' if none seems present: */
+        if (pStrProxyUrl->find("://") == RTCString::npos)
+        {
+            strTmp.printf("http://%s", aProxyURL.c_str());
+            pStrProxyUrl = &strTmp;
+        }
+
+        /* Use RTUriParse to check the format.  There must be a hostname, but nothing
+           can follow it and the port. */
+        RTURIPARSED Parsed;
+        int vrc = RTUriParse(pStrProxyUrl->c_str(), &Parsed);
+        if (RT_FAILURE(vrc))
+            return setErrorBoth(E_INVALIDARG, vrc, tr("Failed to parse proxy URL: %Rrc"), vrc);
+        if (   Parsed.cchAuthorityHost == 0
+            && !RTUriIsSchemeMatch(pStrProxyUrl->c_str(), "direct"))
+            return setError(E_INVALIDARG, tr("Proxy URL must include a hostname"));
+        if (Parsed.cchPath > 0)
+            return setError(E_INVALIDARG, tr("Proxy URL must not include a path component (%.*s)"),
+                            Parsed.cchPath, pStrProxyUrl->c_str() + Parsed.offPath);
+        if (Parsed.cchQuery > 0)
+            return setError(E_INVALIDARG, tr("Proxy URL must not include a query component (?%.*s)"),
+                            Parsed.cchQuery, pStrProxyUrl->c_str() + Parsed.offQuery);
+        if (Parsed.cchFragment > 0)
+            return setError(E_INVALIDARG, tr("Proxy URL must not include a fragment component (#%.*s)"),
+                            Parsed.cchFragment, pStrProxyUrl->c_str() + Parsed.offFragment);
+    }
+
+    /*
+     * Set and write out settings.
+     */
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        m->strProxyUrl = *pStrProxyUrl;
+    }
+    AutoWriteLock alock(mParent COMMA_LOCKVAL_SRC_POS); /* required for saving. */
+    return mParent->i_saveSettings();
+}
+
 // public methods only for internal purposes
 /////////////////////////////////////////////////////////////////////////////
@@ -1014 +1100 @@
     if (FAILED(rc)) return rc;
 
-    m->ulLogHistoryCount = data.ulLogHistoryCount;
+    m->uLogHistoryCount  = data.uLogHistoryCount;
     m->fExclusiveHwVirt  = data.fExclusiveHwVirt;
+    m->uProxyMode        = data.uProxyMode;
+    m->strProxyUrl       = data.strProxyUrl;
 
     rc = i_setAutostartDatabasePath(data.strAutostartDatabasePath);
@@ -1356 +1444 @@
     return S_OK;
 }
+

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

@@ -79 +79 @@
 #include <iprt/ldr.h>
 #include <iprt/base64.h>
+#include <iprt/uri.h>
 #include <iprt/cpp/lock.h>
 
@@ -1579 +1580 @@
  * Constructor. Needs to set sane defaults which stand the test of time.
  */
-SystemProperties::SystemProperties() :
-    ulLogHistoryCount(3),
-    fExclusiveHwVirt(true)
+SystemProperties::SystemProperties()
+    : uLogHistoryCount(3)
+    , uProxyMode(ProxyMode_System)
+    , fExclusiveHwVirt(true)
 {
 #if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS) || defined(RT_OS_SOLARIS)
@@ -1867 +1869 @@
 
 /**
+ * Converts old style Proxy settings from ExtraData/UI section.
+ *
+ * Saves proxy settings directly to systemProperties structure.
+ *
+ * @returns true if conversion was successfull, false if not.
+ * @param strUIProxySettings The GUI settings string to convert.
+ */
+bool MainConfigFile::convertGuiProxySettings(const com::Utf8Str &strUIProxySettings)
+{
+    /*
+     * Possible variants:
+     *    - "ProxyAuto,proxyserver.url,1080,authDisabled,,"
+     *    - "ProxyDisabled,proxyserver.url,1080,authDisabled,,"
+     *    - "ProxyEnabled,proxyserver.url,1080,authDisabled,,"
+     *
+     * Note! We only need to bother with the first three fields as the last
+     *       three was never really used or ever actually passed to the HTTP
+     *       client code.
+     */
+    /* First field: The proxy mode. */
+    const char *psz = RTStrStripL(strUIProxySettings.c_str());
+    static const struct { const char *psz; size_t cch; ProxyMode_T enmMode; } s_aModes[] =
+    {
+        { RT_STR_TUPLE("ProxyAuto"),     ProxyMode_System },
+        { RT_STR_TUPLE("ProxyDisabled"), ProxyMode_NoProxy },
+        { RT_STR_TUPLE("ProxyEnabled"),  ProxyMode_Manual },
+    };
+    for (size_t i = 0; i < RT_ELEMENTS(s_aModes); i++)
+        if (RTStrNICmpAscii(psz, s_aModes[i].psz, s_aModes[i].cch) == 0)
+        {
+            systemProperties.uProxyMode = s_aModes[i].enmMode;
+            psz = RTStrStripL(psz + s_aModes[i].cch);
+            if (*psz == ',')
+            {
+                /* Second field: The proxy host, possibly fully fledged proxy URL. */
+                psz = RTStrStripL(psz + 1);
+                if (*psz != '\0' && *psz != ',')
+                {
+                    const char *pszEnd  = strchr(psz, ',');
+                    size_t      cchHost = pszEnd ? pszEnd - psz : strlen(psz);
+                    while (cchHost > 0 && RT_C_IS_SPACE(psz[cchHost - 1]))
+                        cchHost--;
+                    systemProperties.strProxyUrl.assign(psz, cchHost);
+                    if (systemProperties.strProxyUrl.find("://") == RTCString::npos)
+                        systemProperties.strProxyUrl.replace(0, 0, "http://");
+
+                    /* Third field: The proxy port. Defaulted to 1080 for all proxies.
+                                    The new settings has type specific default ports.  */
+                    uint16_t uPort = 1080;
+                    if (pszEnd)
+                    {
+                        int rc = RTStrToUInt16Ex(RTStrStripL(pszEnd + 1), NULL, 10, &uPort);
+                        if (RT_FAILURE(rc))
+                            uPort = 1080;
+                    }
+                    RTURIPARSED Parsed;
+                    int rc = RTUriParse(systemProperties.strProxyUrl.c_str(), &Parsed);
+                    if (RT_SUCCESS(rc))
+                    {
+                        if (Parsed.uAuthorityPort == UINT32_MAX)
+                            systemProperties.strProxyUrl.appendPrintf(systemProperties.strProxyUrl.endsWith(":")
+                                                                      ? "%u" : ":%u", uPort);
+                    }
+                    else
+                    {
+                        LogRelFunc(("Dropping invalid proxy URL for %u: %s\n",
+                                    systemProperties.uProxyMode, systemProperties.strProxyUrl.c_str()));
+                        systemProperties.strProxyUrl.setNull();
+                    }
+                }
+                /* else: don't bother with the rest if we haven't got a host. */
+            }
+            if (   systemProperties.strProxyUrl.isEmpty()
+                && systemProperties.uProxyMode == ProxyMode_Manual)
+            {
+                systemProperties.uProxyMode = ProxyMode_System;
+                return false;
+            }
+            return true;
+        }
+    LogRelFunc(("Unknown proxy type: %s\n", psz));
+    return false;
+}
+
+/**
  * Constructor.
  *
@@ -1888 +1975 @@
         xml::NodesLoop nlRootChildren(*m->pelmRoot);
         const xml::ElementNode *pelmRootChild;
+        bool fCopyProxySettingsFromExtraData = false;
         while ((pelmRootChild = nlRootChildren.forAllNodes()))
         {
@@ -1906 +1994 @@
                         pelmGlobalChild->getAttributeValue("webServiceAuthLibrary", systemProperties.strWebServiceAuthLibrary);
                         pelmGlobalChild->getAttributeValue("defaultVRDEExtPack", systemProperties.strDefaultVRDEExtPack);
-                        pelmGlobalChild->getAttributeValue("LogHistoryCount", systemProperties.ulLogHistoryCount);
+                        pelmGlobalChild->getAttributeValue("LogHistoryCount", systemProperties.uLogHistoryCount);
                         pelmGlobalChild->getAttributeValue("autostartDatabasePath", systemProperties.strAutostartDatabasePath);
                         pelmGlobalChild->getAttributeValue("defaultFrontend", systemProperties.strDefaultFrontend);
                         pelmGlobalChild->getAttributeValue("exclusiveHwVirt", systemProperties.fExclusiveHwVirt);
+                        if (!pelmGlobalChild->getAttributeValue("proxyMode", systemProperties.uProxyMode))
+                            fCopyProxySettingsFromExtraData = true;
+                        pelmGlobalChild->getAttributeValue("proxyUrl", systemProperties.strProxyUrl);
                     }
                     else if (pelmGlobalChild->nameEquals("ExtraData"))
@@ -1941 +2032 @@
         }
 
+        if (fCopyProxySettingsFromExtraData)
+            for (StringsMap::const_iterator it = mapExtraDataItems.begin(); it != mapExtraDataItems.end(); ++it)
+                if (it->first.equals("GUI/ProxySettings"))
+                {
+                    convertGuiProxySettings(it->second);
+                    break;
+                }
+
         clearDocument();
     }
@@ -2141 +2240 @@
     if (systemProperties.strDefaultVRDEExtPack.length())
         pelmSysProps->setAttribute("defaultVRDEExtPack", systemProperties.strDefaultVRDEExtPack);
-    pelmSysProps->setAttribute("LogHistoryCount", systemProperties.ulLogHistoryCount);
+    pelmSysProps->setAttribute("LogHistoryCount", systemProperties.uLogHistoryCount);
     if (systemProperties.strAutostartDatabasePath.length())
         pelmSysProps->setAttribute("autostartDatabasePath", systemProperties.strAutostartDatabasePath);
     if (systemProperties.strDefaultFrontend.length())
         pelmSysProps->setAttribute("defaultFrontend", systemProperties.strDefaultFrontend);
+    if (systemProperties.strProxyUrl.length())
+        pelmSysProps->setAttribute("proxyUrl", systemProperties.strProxyUrl);
+    pelmSysProps->setAttribute("proxyMode", systemProperties.uProxyMode);
     pelmSysProps->setAttribute("exclusiveHwVirt", systemProperties.fExclusiveHwVirt);