diff options
Diffstat (limited to 'src/VBox/Main/src-server/UpdateAgentImpl.cpp')
| -rw-r--r-- | src/VBox/Main/src-server/UpdateAgentImpl.cpp | 1175 |
1 files changed, 1175 insertions, 0 deletions
diff --git a/src/VBox/Main/src-server/UpdateAgentImpl.cpp b/src/VBox/Main/src-server/UpdateAgentImpl.cpp new file mode 100644 index 00000000..3a89815a --- /dev/null +++ b/src/VBox/Main/src-server/UpdateAgentImpl.cpp @@ -0,0 +1,1175 @@ +/* $Id: UpdateAgentImpl.cpp $ */ +/** @file + * IUpdateAgent COM class implementations. + */ + +/* + * Copyright (C) 2020-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ + + +#define LOG_GROUP LOG_GROUP_MAIN_UPDATEAGENT + +#include <iprt/cpp/utils.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/http.h> +#include <iprt/system.h> +#include <iprt/message.h> +#include <iprt/pipe.h> +#include <iprt/env.h> +#include <iprt/process.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/stream.h> +#include <iprt/time.h> +#include <VBox/com/defs.h> +#include <VBox/err.h> +#include <VBox/version.h> + +#include "HostImpl.h" +#include "UpdateAgentImpl.h" +#include "ProgressImpl.h" +#include "AutoCaller.h" +#include "LoggingNew.h" +#include "VirtualBoxImpl.h" +#include "VBoxEvents.h" +#include "SystemPropertiesImpl.h" +#include "ThreadTask.h" +#include "VirtualBoxImpl.h" +#include "VirtualBoxBase.h" + + +/********************************************************************************************************************************* +* Update agent task implementation * +*********************************************************************************************************************************/ + +/** + * Base task class for asynchronous update agent tasks. + */ +class UpdateAgentTask : public ThreadTask +{ +public: + UpdateAgentTask(UpdateAgentBase *aThat, Progress *aProgress) + : m_pParent(aThat) + , m_pProgress(aProgress) + { + m_strTaskName = "UpdateAgentTask"; + } + virtual ~UpdateAgentTask(void) { } + +private: + void handler(void); + + /** Weak pointer to parent (update agent). */ + UpdateAgentBase *m_pParent; + /** Smart pointer to the progress object for this job. */ + ComObjPtr<Progress> m_pProgress; + + friend class UpdateAgent; // allow member functions access to private data +}; + +void UpdateAgentTask::handler(void) +{ + UpdateAgentBase *pUpdateAgent = this->m_pParent; + AssertPtr(pUpdateAgent); + + /** @todo Differentiate tasks once we have more stuff to do (downloading, installing, ++). */ + + HRESULT hrc = pUpdateAgent->i_checkForUpdateTask(this); + + if (!m_pProgress.isNull()) + m_pProgress->i_notifyComplete(hrc); + + LogFlowFunc(("hrc=%Rhrc\n", hrc)); RT_NOREF(hrc); +} + + +/********************************************************************************************************************************* +* Update agent base class implementation * +*********************************************************************************************************************************/ + +/** + * Returns platform information as a string. + * + * @returns Platform information as string. + */ +/* static */ +Utf8Str UpdateAgentBase::i_getPlatformInfo(void) +{ + /* Prepare platform report: */ + Utf8Str strPlatform; + +# if defined (RT_OS_WINDOWS) + strPlatform = "win"; +# elif defined (RT_OS_LINUX) + strPlatform = "linux"; +# elif defined (RT_OS_DARWIN) + strPlatform = "macosx"; +# elif defined (RT_OS_OS2) + strPlatform = "os2"; +# elif defined (RT_OS_FREEBSD) + strPlatform = "freebsd"; +# elif defined (RT_OS_SOLARIS) + strPlatform = "solaris"; +# else + strPlatform = "unknown"; +# endif + + /* The format is <system>.<bitness>: */ + strPlatform.appendPrintf(".%lu", ARCH_BITS); + + /* Add more system information: */ + int vrc; +# ifdef RT_OS_LINUX + // WORKAROUND: + // On Linux we try to generate information using script first of all.. + + /* Get script path: */ + char szAppPrivPath[RTPATH_MAX]; + vrc = RTPathAppPrivateNoArch(szAppPrivPath, sizeof(szAppPrivPath)); + AssertRC(vrc); + if (RT_SUCCESS(vrc)) + vrc = RTPathAppend(szAppPrivPath, sizeof(szAppPrivPath), "/VBoxSysInfo.sh"); + AssertRC(vrc); + if (RT_SUCCESS(vrc)) + { + RTPIPE hPipeR; + RTHANDLE hStdOutPipe; + hStdOutPipe.enmType = RTHANDLETYPE_PIPE; + vrc = RTPipeCreate(&hPipeR, &hStdOutPipe.u.hPipe, RTPIPE_C_INHERIT_WRITE); + AssertLogRelRC(vrc); + + char const *szAppPrivArgs[2]; + szAppPrivArgs[0] = szAppPrivPath; + szAppPrivArgs[1] = NULL; + RTPROCESS hProc = NIL_RTPROCESS; + + /* Run script: */ + vrc = RTProcCreateEx(szAppPrivPath, szAppPrivArgs, RTENV_DEFAULT, 0 /*fFlags*/, NULL /*phStdin*/, &hStdOutPipe, + NULL /*phStderr*/, NULL /*pszAsUser*/, NULL /*pszPassword*/, NULL /*pvExtraData*/, &hProc); + + (void) RTPipeClose(hStdOutPipe.u.hPipe); + hStdOutPipe.u.hPipe = NIL_RTPIPE; + + if (RT_SUCCESS(vrc)) + { + RTPROCSTATUS ProcStatus; + size_t cbStdOutBuf = 0; + size_t offStdOutBuf = 0; + char *pszStdOutBuf = NULL; + do + { + if (hPipeR != NIL_RTPIPE) + { + char achBuf[1024]; + size_t cbRead; + vrc = RTPipeReadBlocking(hPipeR, achBuf, sizeof(achBuf), &cbRead); + if (RT_SUCCESS(vrc)) + { + /* grow the buffer? */ + size_t cbBufReq = offStdOutBuf + cbRead + 1; + if ( cbBufReq > cbStdOutBuf + && cbBufReq < _256K) + { + size_t cbNew = RT_ALIGN_Z(cbBufReq, 16); // 1024 + void *pvNew = RTMemRealloc(pszStdOutBuf, cbNew); + if (pvNew) + { + pszStdOutBuf = (char *)pvNew; + cbStdOutBuf = cbNew; + } + } + + /* append if we've got room. */ + if (cbBufReq <= cbStdOutBuf) + { + (void) memcpy(&pszStdOutBuf[offStdOutBuf], achBuf, cbRead); + offStdOutBuf = offStdOutBuf + cbRead; + pszStdOutBuf[offStdOutBuf] = '\0'; + } + } + else + { + AssertLogRelMsg(vrc == VERR_BROKEN_PIPE, ("%Rrc\n", vrc)); + RTPipeClose(hPipeR); + hPipeR = NIL_RTPIPE; + } + } + + /* + * Service the process. Block if we have no pipe. + */ + if (hProc != NIL_RTPROCESS) + { + vrc = RTProcWait(hProc, + hPipeR == NIL_RTPIPE ? RTPROCWAIT_FLAGS_BLOCK : RTPROCWAIT_FLAGS_NOBLOCK, + &ProcStatus); + if (RT_SUCCESS(vrc)) + hProc = NIL_RTPROCESS; + else + AssertLogRelMsgStmt(vrc == VERR_PROCESS_RUNNING, ("%Rrc\n", vrc), hProc = NIL_RTPROCESS); + } + } while ( hPipeR != NIL_RTPIPE + || hProc != NIL_RTPROCESS); + + if ( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL + && ProcStatus.iStatus == 0) { + pszStdOutBuf[offStdOutBuf-1] = '\0'; // remove trailing newline + Utf8Str pszStdOutBufUTF8(pszStdOutBuf); + strPlatform.appendPrintf(" [%s]", pszStdOutBufUTF8.strip().c_str()); + // For testing, here is some sample output: + //strPlatform.appendPrintf(" [Distribution: Redhat | Version: 7.6.1810 | Kernel: Linux version 3.10.0-952.27.2.el7.x86_64 (gcc version 4.8.5 20150623 (Red Hat 4.8.5-36) (GCC) ) #1 SMP Mon Jul 29 17:46:05 UTC 2019]"); + } + } + else + vrc = VERR_TRY_AGAIN; /* (take the fallback path) */ + } + + if (RT_FAILURE(vrc)) +# endif /* RT_OS_LINUX */ + { + /* Use RTSystemQueryOSInfo: */ + char szTmp[256]; + + vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp)); + if ((RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0') + strPlatform.appendPrintf(" [Product: %s", szTmp); + + vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp)); + if ((RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0') + strPlatform.appendPrintf(" %sRelease: %s", strlen(szTmp) == 0 ? "[" : "| ", szTmp); + + vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp)); + if ((RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0') + strPlatform.appendPrintf(" %sVersion: %s", strlen(szTmp) == 0 ? "[" : "| ", szTmp); + + vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp)); + if ((RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0') + strPlatform.appendPrintf(" %sSP: %s]", strlen(szTmp) == 0 ? "[" : "| ", szTmp); + + if (!strPlatform.endsWith("]")) + strPlatform.append("]"); + } + + LogRel2(("UpdateAgent: Platform is '%s'\n", strPlatform.c_str())); + + return strPlatform; +} + +/** + * Returns the proxy mode as a string. + * + * @returns Proxy mode as string. + * @param enmMode Proxy mode to return as string. + */ +/* static */ +const char *UpdateAgentBase::i_proxyModeToStr(ProxyMode_T enmMode) +{ + switch (enmMode) + { + case ProxyMode_System: return "System"; + case ProxyMode_Manual: return "Manual"; + case ProxyMode_NoProxy: return "None"; + default: break; + } + + AssertFailed(); + return "<Invalid>"; +} + +/** + * Returns whether a given URL's scheme is supported or not. + * + * @returns \c true if scheme is supported, or \c false if not. + * @param strUrl URL to check scheme for. + * + * @note Empty URL are considered as being supported for convenience. + */ +bool UpdateAgentBase::i_urlSchemeIsSupported(const Utf8Str &strUrl) const +{ + if (strUrl.isEmpty()) + return true; + return strUrl.startsWith("https://", com::Utf8Str::CaseInsensitive); +} + + +/********************************************************************************************************************************* +* Update agent class implementation * +*********************************************************************************************************************************/ +UpdateAgent::UpdateAgent() +{ +} + +UpdateAgent::~UpdateAgent() +{ +} + +HRESULT UpdateAgent::FinalConstruct(void) +{ + return BaseFinalConstruct(); +} + +void UpdateAgent::FinalRelease(void) +{ + uninit(); + + BaseFinalRelease(); +} + +HRESULT UpdateAgent::init(VirtualBox *aVirtualBox) +{ + /* Weak reference to a VirtualBox object */ + unconst(m_VirtualBox) = aVirtualBox; + + HRESULT hrc = unconst(m_EventSource).createObject(); + if (SUCCEEDED(hrc)) + hrc = m_EventSource->init(); + + return hrc; +} + +void UpdateAgent::uninit(void) +{ + // Enclose the state transition Ready->InUninit->NotReady. + AutoUninitSpan autoUninitSpan(this); + if (autoUninitSpan.uninitDone()) + return; + + unconst(m_EventSource).setNull(); +} + +HRESULT UpdateAgent::checkFor(ComPtr<IProgress> &aProgress) +{ + RT_NOREF(aProgress); + + return VBOX_E_NOT_SUPPORTED; +} + +HRESULT UpdateAgent::download(ComPtr<IProgress> &aProgress) +{ + RT_NOREF(aProgress); + + return VBOX_E_NOT_SUPPORTED; +} + +HRESULT UpdateAgent::install(ComPtr<IProgress> &aProgress) +{ + RT_NOREF(aProgress); + + return VBOX_E_NOT_SUPPORTED; +} + +HRESULT UpdateAgent::rollback(void) +{ + return VBOX_E_NOT_SUPPORTED; +} + +HRESULT UpdateAgent::getName(com::Utf8Str &aName) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aName = mData.m_strName; + + return S_OK; +} + +HRESULT UpdateAgent::getEventSource(ComPtr<IEventSource> &aEventSource) +{ + LogFlowThisFuncEnter(); + + /* No need to lock - lifetime constant. */ + m_EventSource.queryInterfaceTo(aEventSource.asOutParam()); + + LogFlowFuncLeaveRC(S_OK); + return S_OK; +} + +HRESULT UpdateAgent::getOrder(ULONG *aOrder) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aOrder = 0; /* 0 means no order / disabled. */ + + return S_OK; +} + +HRESULT UpdateAgent::getDependsOn(std::vector<com::Utf8Str> &aDeps) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aDeps.resize(0); /* No dependencies by default. */ + + return S_OK; +} + +HRESULT UpdateAgent::getVersion(com::Utf8Str &aVer) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aVer = mData.m_lastResult.strVer; + + return S_OK; +} + +HRESULT UpdateAgent::getDownloadUrl(com::Utf8Str &aUrl) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aUrl = mData.m_lastResult.strDownloadUrl; + + return S_OK; +} + + +HRESULT UpdateAgent::getWebUrl(com::Utf8Str &aUrl) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aUrl = mData.m_lastResult.strWebUrl; + + return S_OK; +} + +HRESULT UpdateAgent::getReleaseNotes(com::Utf8Str &aRelNotes) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aRelNotes = mData.m_lastResult.strReleaseNotes; + + return S_OK; +} + +HRESULT UpdateAgent::getEnabled(BOOL *aEnabled) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aEnabled = m->fEnabled; + + return S_OK; +} + +HRESULT UpdateAgent::setEnabled(const BOOL aEnabled) +{ + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->fEnabled = aEnabled; + + return i_commitSettings(alock); +} + + +HRESULT UpdateAgent::getHidden(BOOL *aHidden) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aHidden = mData.m_fHidden; + + return S_OK; +} + +HRESULT UpdateAgent::getState(UpdateState_T *aState) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aState = mData.m_enmState; + + return S_OK; +} + +HRESULT UpdateAgent::getCheckFrequency(ULONG *aFreqSeconds) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aFreqSeconds = m->uCheckFreqSeconds; + + return S_OK; +} + +HRESULT UpdateAgent::setCheckFrequency(ULONG aFreqSeconds) +{ + if (aFreqSeconds < RT_SEC_1DAY) /* Don't allow more frequent checks for now. */ + return setError(E_INVALIDARG, tr("Frequency too small; one day is the minimum")); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->uCheckFreqSeconds = aFreqSeconds; + + return i_commitSettings(alock); +} + +HRESULT UpdateAgent::getChannel(UpdateChannel_T *aChannel) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aChannel = m->enmChannel; + + return S_OK; +} + +HRESULT UpdateAgent::setChannel(UpdateChannel_T aChannel) +{ + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->enmChannel = aChannel; + + return i_commitSettings(alock); +} + +HRESULT UpdateAgent::getCheckCount(ULONG *aCount) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + *aCount = m->uCheckCount; + + return S_OK; +} + +HRESULT UpdateAgent::getRepositoryURL(com::Utf8Str &aRepo) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aRepo = m->strRepoUrl; + + return S_OK; +} + +HRESULT UpdateAgent::setRepositoryURL(const com::Utf8Str &aRepo) +{ + if (!i_urlSchemeIsSupported(aRepo)) + return setError(E_INVALIDARG, tr("Invalid URL scheme specified!")); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->strRepoUrl = aRepo; + + return i_commitSettings(alock); +} + +HRESULT UpdateAgent::getLastCheckDate(com::Utf8Str &aDate) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + aDate = m->strLastCheckDate; + + return S_OK; +} + +HRESULT UpdateAgent::getIsCheckNeeded(BOOL *aCheckNeeded) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + /* + * Is update checking enabled at all? + */ + if (!m->fEnabled) + { + *aCheckNeeded = FALSE; + return S_OK; + } + + /* + * When was the last update? + */ + if (m->strLastCheckDate.isEmpty()) /* No prior update check performed -- do so now. */ + { + *aCheckNeeded = TRUE; + return S_OK; + } + + RTTIMESPEC LastCheckTime; + if (!RTTimeSpecFromString(&LastCheckTime, Utf8Str(m->strLastCheckDate).c_str())) + { + *aCheckNeeded = TRUE; /* Invalid date set or error? Perform check. */ + return S_OK; + } + + /* + * Compare last update with how often we are supposed to check for updates. + */ + if ( !m->uCheckFreqSeconds /* Paranoia */ + || m->uCheckFreqSeconds < RT_SEC_1DAY) /* This is the minimum we currently allow. */ + { + /* Consider config (enable, 0 day interval) as checking once but never again. + We've already check since we've got a date. */ + *aCheckNeeded = FALSE; + return S_OK; + } + + uint64_t const cCheckFreqDays = m->uCheckFreqSeconds / RT_SEC_1DAY_64; + + RTTIMESPEC TimeDiff; + RTTimeSpecSub(RTTimeNow(&TimeDiff), &LastCheckTime); + + int64_t const diffLastCheckSecs = RTTimeSpecGetSeconds(&TimeDiff); + int64_t const diffLastCheckDays = diffLastCheckSecs / (int64_t)RT_SEC_1DAY_64; + + /* Be as accurate as possible. */ + *aCheckNeeded = diffLastCheckSecs >= (int64_t)m->uCheckFreqSeconds ? TRUE : FALSE; + + LogRel2(("Update agent (%s): Last update %RI64 days (%RI64 seconds) ago, check frequency is every %RU64 days (%RU64 seconds) -> Check %s\n", + mData.m_strName.c_str(), diffLastCheckDays, diffLastCheckSecs, cCheckFreqDays, m->uCheckFreqSeconds, + *aCheckNeeded ? "needed" : "not needed")); + + return S_OK; +} + +HRESULT UpdateAgent::getSupportedChannels(std::vector<UpdateChannel_T> &aSupportedChannels) +{ + /* No need to take the read lock, as m_enmChannels is const. */ + + aSupportedChannels = mData.m_enmChannels; + + return S_OK; +} + + +/********************************************************************************************************************************* +* Internal helper methods of update agent class * +*********************************************************************************************************************************/ + +/** + * Loads the settings of the update agent base class. + * + * @returns HRESULT + * @retval E_INVALIDARG if to-load settings are invalid / not supported. + * @param data Where to load the settings from. + */ +HRESULT UpdateAgent::i_loadSettings(const settings::UpdateAgent &data) +{ + AutoCaller autoCaller(this); + if (FAILED(autoCaller.hrc())) return autoCaller.hrc(); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->fEnabled = data.fEnabled; + m->enmChannel = data.enmChannel; + m->uCheckFreqSeconds = data.uCheckFreqSeconds; + if (data.strRepoUrl.isNotEmpty()) /* Prevent overwriting the agent's default URL when XML settings are empty. */ + m->strRepoUrl = data.strRepoUrl; + m->strLastCheckDate = data.strLastCheckDate; + m->uCheckCount = data.uCheckCount; + + /* Sanity checks. */ + if (!i_urlSchemeIsSupported(data.strRepoUrl)) + return setError(E_INVALIDARG, tr("Invalid URL scheme specified!")); + + return S_OK; +} + +/** + * Saves the settings of the update agent base class. + * + * @returns HRESULT + * @param data Where to save the settings to. + */ +HRESULT UpdateAgent::i_saveSettings(settings::UpdateAgent &data) +{ + AutoCaller autoCaller(this); + if (FAILED(autoCaller.hrc())) return autoCaller.hrc(); + + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + data = *m; + + return S_OK; +} + +/** + * Sets the update check count. + * + * @returns HRESULT + * @param aCount Update check count to set. + */ +HRESULT UpdateAgent::i_setCheckCount(ULONG aCount) +{ + AutoCaller autoCaller(this); + if (FAILED(autoCaller.hrc())) return autoCaller.hrc(); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->uCheckCount = aCount; + + return i_commitSettings(alock); +} + +/** + * Sets the last update check date. + * + * @returns HRESULT + * @param aDate Last update check date to set. + * Must be in ISO 8601 format (e.g. 2020-05-11T21:13:39.348416000Z). + */ +HRESULT UpdateAgent::i_setLastCheckDate(const com::Utf8Str &aDate) +{ + AutoCaller autoCaller(this); + if (FAILED(autoCaller.hrc())) return autoCaller.hrc(); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->strLastCheckDate = aDate; + + return i_commitSettings(alock); +} + +/** + * Internal helper function to commit modified settings. + * + * @returns HRESULT + * @param aLock Write lock to release before committing settings. + */ +HRESULT UpdateAgent::i_commitSettings(AutoWriteLock &aLock) +{ + aLock.release(); + + m_VirtualBox->i_onUpdateAgentSettingsChanged(this, "" /** @todo Include attribute hints */); + + AutoWriteLock vboxLock(m_VirtualBox COMMA_LOCKVAL_SRC_POS); + return m_VirtualBox->i_saveSettings(); +} + +/** + * Returns the proxy mode to use. + * + * @returns HRESULT + * @param aMode Where to return the proxy mode. + */ +HRESULT UpdateAgent::i_getProxyMode(ProxyMode_T *aMode) +{ + ComPtr<ISystemProperties> pSystemProperties; + HRESULT hrc = m_VirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam()); + if (SUCCEEDED(hrc)) + hrc = pSystemProperties->COMGETTER(ProxyMode)(aMode); + + return hrc; +} + +/** + * Returns the proxy URL to use. + * + * @returns HRESULT + * @param aUrl Where to return the proxy URL to use. + */ +HRESULT UpdateAgent::i_getProxyURL(com::Utf8Str &aUrl) +{ + ComPtr<ISystemProperties> pSystemProperties; + HRESULT hrc = m_VirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam()); + if (SUCCEEDED(hrc)) + { + com::Bstr bstrVal; + hrc = pSystemProperties->COMGETTER(ProxyURL)(bstrVal.asOutParam()); + if (SUCCEEDED(hrc)) + aUrl = bstrVal; + } + + return hrc; +} + +/** + * Configures a HTTP client's proxy. + * + * @returns HRESULT + * @param hHttp HTTP client to configure proxy for. + */ +HRESULT UpdateAgent::i_configureProxy(RTHTTP hHttp) +{ + ProxyMode_T enmProxyMode; + HRESULT hrc = i_getProxyMode(&enmProxyMode); + ComAssertComRCRetRC(hrc); + + Utf8Str strProxyUrl; + hrc = i_getProxyURL(strProxyUrl); + ComAssertComRCRetRC(hrc); + + if (enmProxyMode == ProxyMode_Manual) + { + int vrc = RTHttpSetProxyByUrl(hHttp, strProxyUrl.c_str()); + if (RT_FAILURE(vrc)) + return i_reportError(vrc, tr("RTHttpSetProxyByUrl() failed: %Rrc"), vrc); + } + else if (enmProxyMode == ProxyMode_System) + { + int vrc = RTHttpUseSystemProxySettings(hHttp); + if (RT_FAILURE(vrc)) + return i_reportError(vrc, tr("RTHttpUseSystemProxySettings() failed: %Rrc"), vrc); + } + else + Assert(enmProxyMode == ProxyMode_NoProxy); + + LogRel2(("Update agent (%s): Using proxy mode = '%s', URL = '%s'\n", + mData.m_strName.c_str(), UpdateAgentBase::i_proxyModeToStr(enmProxyMode), strProxyUrl.c_str())); + + return S_OK; +} + +/** + * Reports an error by setting the error info and also informs subscribed listeners. + * + * @returns HRESULT + * @param vrc Result code (IPRT-style) to report. + * @param pcszMsgFmt Error message to report. + * @param ... Format string for \a pcszMsgFmt. + */ +HRESULT UpdateAgent::i_reportError(int vrc, const char *pcszMsgFmt, ...) +{ + AssertReturn(pcszMsgFmt && *pcszMsgFmt != '\0', E_INVALIDARG); + + va_list va; + va_start(va, pcszMsgFmt); + + Utf8Str strMsg; + int const vrc2 = strMsg.printfVNoThrow(pcszMsgFmt, va); + if (RT_FAILURE(vrc2)) + { + va_end(va); + return setErrorBoth(VBOX_E_IPRT_ERROR, vrc2, tr("Failed to format update agent error string (%Rrc)"), vrc2); + } + + va_end(va); + + LogRel(("Update agent (%s): %s\n", mData.m_strName.c_str(), strMsg.c_str())); + + m_VirtualBox->i_onUpdateAgentError(this, strMsg.c_str(), vrc); + + return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, strMsg.c_str()); +} + + +/********************************************************************************************************************************* +* Host update implementation * +*********************************************************************************************************************************/ + +HostUpdateAgent::HostUpdateAgent(void) +{ +} + +HostUpdateAgent::~HostUpdateAgent(void) +{ +} + + +HRESULT HostUpdateAgent::FinalConstruct(void) +{ + return BaseFinalConstruct(); +} + +void HostUpdateAgent::FinalRelease(void) +{ + uninit(); + + BaseFinalRelease(); +} + +HRESULT HostUpdateAgent::init(VirtualBox *aVirtualBox) +{ + // Enclose the state transition NotReady->InInit->Ready. + AutoInitSpan autoInitSpan(this); + AssertReturn(autoInitSpan.isOk(), E_FAIL); + + /* Initialize the bare minimum to get things going. + ** @todo Add more stuff later here. */ + mData.m_strName = "VirtualBox"; + mData.m_fHidden = false; + + const UpdateChannel_T aChannels[] = + { + UpdateChannel_Stable, + UpdateChannel_All, + UpdateChannel_WithBetas + /** @todo Add UpdateChannel_WithTesting once it's implemented on the backend. */ + }; + unconst(mData.m_enmChannels).assign(aChannels, aChannels + RT_ELEMENTS(aChannels)); + + /* Set default repository. */ + m->strRepoUrl = "https://update.virtualbox.org"; + + HRESULT hrc = UpdateAgent::init(aVirtualBox); + if (SUCCEEDED(hrc)) + autoInitSpan.setSucceeded(); + + return hrc; +} + +void HostUpdateAgent::uninit(void) +{ + // Enclose the state transition Ready->InUninit->NotReady. + AutoUninitSpan autoUninitSpan(this); + if (autoUninitSpan.uninitDone()) + return; +} + +HRESULT HostUpdateAgent::checkFor(ComPtr<IProgress> &aProgress) +{ + AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); + + ComObjPtr<Progress> pProgress; + HRESULT hrc = pProgress.createObject(); + if (FAILED(hrc)) + return hrc; + + hrc = pProgress->init(m_VirtualBox, + static_cast<IUpdateAgent*>(this), + tr("Checking for update for %s ...", this->mData.m_strName.c_str()), + TRUE /* aCancelable */); + if (FAILED(hrc)) + return hrc; + + /* initialize the worker task */ + UpdateAgentTask *pTask = new UpdateAgentTask(this, pProgress); + hrc = pTask->createThread(); + pTask = NULL; + if (FAILED(hrc)) + return hrc; + + return pProgress.queryInterfaceTo(aProgress.asOutParam()); +} + + +/********************************************************************************************************************************* +* Host update internal functions * +*********************************************************************************************************************************/ + +/** + * Task callback to perform an update check for the VirtualBox host (core). + * + * @returns HRESULT + * @param pTask Associated update agent task to use. + */ +DECLCALLBACK(HRESULT) HostUpdateAgent::i_checkForUpdateTask(UpdateAgentTask *pTask) +{ + RT_NOREF(pTask); + + AssertReturn(m->strRepoUrl.isNotEmpty(), E_INVALIDARG); + + // Following the sequence of steps in UIUpdateStepVirtualBox::sltStartStep() + // Build up our query URL starting with the configured repository. + Utf8Str strUrl; + strUrl.appendPrintf("%s/query.php/?", m->strRepoUrl.c_str()); + + // Add platform ID. + Bstr platform; + HRESULT hrc = m_VirtualBox->COMGETTER(PackageType)(platform.asOutParam()); + AssertComRCReturn(hrc, hrc); + strUrl.appendPrintf("platform=%ls", platform.raw()); // e.g. SOLARIS_64BITS_GENERIC + + // Get the complete current version string for the query URL + Bstr versionNormalized; + hrc = m_VirtualBox->COMGETTER(VersionNormalized)(versionNormalized.asOutParam()); + AssertComRCReturn(hrc, hrc); + strUrl.appendPrintf("&version=%ls", versionNormalized.raw()); // e.g. 6.1.1 +#ifdef DEBUG // Comment out previous line and uncomment this one for testing. +// strUrl.appendPrintf("&version=6.0.12"); +#endif + + ULONG revision = 0; + hrc = m_VirtualBox->COMGETTER(Revision)(&revision); + AssertComRCReturn(hrc, hrc); + strUrl.appendPrintf("_%u", revision); // e.g. 135618 + + // Update the last update check timestamp. + RTTIME Time; + RTTIMESPEC TimeNow; + char szTimeStr[RTTIME_STR_LEN]; + RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&TimeNow)), szTimeStr, sizeof(szTimeStr)); + LogRel2(("Update agent (%s): Setting last update check timestamp to '%s'\n", mData.m_strName.c_str(), szTimeStr)); + + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + m->strLastCheckDate = szTimeStr; + m->uCheckCount++; + + hrc = i_commitSettings(alock); + AssertComRCReturn(hrc, hrc); + + strUrl.appendPrintf("&count=%RU32", m->uCheckCount); + + // Update the query URL (if necessary) with the 'channel' information. + switch (m->enmChannel) + { + case UpdateChannel_All: + strUrl.appendPrintf("&branch=allrelease"); // query.php expects 'allrelease' and not 'allreleases' + break; + case UpdateChannel_WithBetas: + strUrl.appendPrintf("&branch=withbetas"); + break; + /** @todo Handle UpdateChannel_WithTesting once implemented on the backend. */ + case UpdateChannel_Stable: + RT_FALL_THROUGH(); + default: + strUrl.appendPrintf("&branch=stable"); + break; + } + + LogRel2(("Update agent (%s): Using URL '%s'\n", mData.m_strName.c_str(), strUrl.c_str())); + + /* + * Compose the User-Agent header for the GET request. + */ + Bstr version; + hrc = m_VirtualBox->COMGETTER(Version)(version.asOutParam()); // e.g. 6.1.0_RC1 + AssertComRCReturn(hrc, hrc); + + Utf8StrFmt const strUserAgent("VirtualBox %ls <%s>", version.raw(), UpdateAgent::i_getPlatformInfo().c_str()); + LogRel2(("Update agent (%s): Using user agent '%s'\n", mData.m_strName.c_str(), strUserAgent.c_str())); + + /* + * Create the HTTP client instance and pass it to a inner worker method to + * ensure proper cleanup. + */ + RTHTTP hHttp = NIL_RTHTTP; + int vrc = RTHttpCreate(&hHttp); + if (RT_SUCCESS(vrc)) + { + try + { + hrc = i_checkForUpdateInner(hHttp, strUrl, strUserAgent); + } + catch (...) + { + AssertFailed(); + hrc = E_UNEXPECTED; + } + RTHttpDestroy(hHttp); + } + else + hrc = i_reportError(vrc, tr("RTHttpCreate() failed: %Rrc"), vrc); + + return hrc; +} + +/** + * Inner function of the actual update checking mechanism. + * + * @returns HRESULT + * @param hHttp HTTP client instance to use for checking. + * @param strUrl URL of repository to check. + * @param strUserAgent HTTP user agent to use for checking. + */ +HRESULT HostUpdateAgent::i_checkForUpdateInner(RTHTTP hHttp, Utf8Str const &strUrl, Utf8Str const &strUserAgent) +{ + /* + * Configure the proxy (if any). + */ + HRESULT hrc = i_configureProxy(hHttp); + if (FAILED(hrc)) + return hrc; + + /** @todo Are there any other headers needed to be added first via RTHttpSetHeaders()? */ + int vrc = RTHttpAddHeader(hHttp, "User-Agent", strUserAgent.c_str(), strUserAgent.length(), RTHTTPADDHDR_F_BACK); + if (RT_FAILURE(vrc)) + return i_reportError(vrc, tr("RTHttpAddHeader() failed: %Rrc (user agent)"), vrc); + + /* + * Perform the GET request, returning raw binary stuff. + */ + void *pvResponse = NULL; + size_t cbResponse = 0; + vrc = RTHttpGetBinary(hHttp, strUrl.c_str(), &pvResponse, &cbResponse); + if (RT_FAILURE(vrc)) + return i_reportError(vrc, tr("RTHttpGetBinary() failed: %Rrc"), vrc); + + /* Note! We can do nothing that might throw exceptions till we call RTHttpFreeResponse! */ + + /* + * If url is platform=DARWIN_64BITS_GENERIC&version=6.0.12&branch=stable for example, the reply is: + * 6.0.14<SPACE>https://download.virtualbox.org/virtualbox/6.0.14/VirtualBox-6.0.14-133895-OSX.dmg + * If no update required, 'UPTODATE' is returned. + */ + /* Parse out the two first words of the response, ignoring whatever follows: */ + const char *pchResponse = (const char *)pvResponse; + while (cbResponse > 0 && *pchResponse == ' ') + cbResponse--, pchResponse++; + + char ch; + const char *pchWord0 = pchResponse; + while (cbResponse > 0 && (ch = *pchResponse) != ' ' && ch != '\0') + cbResponse--, pchResponse++; + size_t const cchWord0 = (size_t)(pchResponse - pchWord0); + + while (cbResponse > 0 && *pchResponse == ' ') + cbResponse--, pchResponse++; + const char *pchWord1 = pchResponse; + while (cbResponse > 0 && (ch = *pchResponse) != ' ' && ch != '\0') + cbResponse--, pchResponse++; + size_t const cchWord1 = (size_t)(pchResponse - pchWord1); + + /* Decode the two word: */ + static char const s_szUpToDate[] = "UPTODATE"; + if ( cchWord0 == sizeof(s_szUpToDate) - 1 + && memcmp(pchWord0, s_szUpToDate, sizeof(s_szUpToDate) - 1) == 0) + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + mData.m_enmState = UpdateState_NotAvailable; + hrc = S_OK; + + alock.release(); /* Release lock before firing off event. */ + + m_VirtualBox->i_onUpdateAgentStateChanged(this, UpdateState_NotAvailable); + } + else + { + mData.m_enmState = UpdateState_Error; /* Play safe by default. */ + + vrc = RTStrValidateEncodingEx(pchWord0, cchWord0, 0 /*fFlags*/); + if (RT_SUCCESS(vrc)) + vrc = RTStrValidateEncodingEx(pchWord1, cchWord1, 0 /*fFlags*/); + if (RT_SUCCESS(vrc)) + { + /** @todo Any additional sanity checks we could perform here? */ + hrc = mData.m_lastResult.strVer.assignEx(pchWord0, cchWord0); + if (SUCCEEDED(hrc)) + hrc = mData.m_lastResult.strDownloadUrl.assignEx(pchWord1, cchWord1); + + if (SUCCEEDED(hrc)) + { + AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS); + + /** @todo Implement this on the backend first. + * We also could do some guessing based on the installed version vs. reported update version? */ + mData.m_lastResult.enmSeverity = UpdateSeverity_Invalid; + mData.m_enmState = UpdateState_Available; + + alock.release(); /* Release lock before firing off events. */ + + m_VirtualBox->i_onUpdateAgentStateChanged(this, UpdateState_Available); + m_VirtualBox->i_onUpdateAgentAvailable(this, mData.m_lastResult.strVer, m->enmChannel, + mData.m_lastResult.enmSeverity, mData.m_lastResult.strDownloadUrl, + mData.m_lastResult.strWebUrl, mData.m_lastResult.strReleaseNotes); + } + else + hrc = i_reportError(VERR_GENERAL_FAILURE /** @todo Use a better hrc */, + tr("Invalid server response [1]: %Rhrc (%.*Rhxs -- %.*Rhxs)"), + hrc, cchWord0, pchWord0, cchWord1, pchWord1); + + LogRel2(("Update agent (%s): HTTP server replied: %.*s %.*s\n", + mData.m_strName.c_str(), cchWord0, pchWord0, cchWord1, pchWord1)); + } + else + hrc = i_reportError(vrc, tr("Invalid server response [2]: %Rrc (%.*Rhxs -- %.*Rhxs)"), + vrc, cchWord0, pchWord0, cchWord1, pchWord1); + } + + RTHttpFreeResponse(pvResponse); + + return hrc; +} + |