UpdateAgentImpl.cpp@ 98651

Last change on this file since 98651 was 98293, checked in by vboxsync, 22 months ago
Main/src-server: hr -> hrc. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.6 KB

Line
1	/* $Id: UpdateAgentImpl.cpp 98293 2023-01-25 01:22:39Z vboxsync $ */
2	/** @file
3	* IUpdateAgent COM class implementations.
4	*/
5
6	/*
7	* Copyright (C) 2020-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	#define LOG_GROUP LOG_GROUP_MAIN_UPDATEAGENT
30
31	#include <iprt/cpp/utils.h>
32	#include <iprt/param.h>
33	#include <iprt/path.h>
34	#include <iprt/http.h>
35	#include <iprt/system.h>
36	#include <iprt/message.h>
37	#include <iprt/pipe.h>
38	#include <iprt/env.h>
39	#include <iprt/process.h>
40	#include <iprt/assert.h>
41	#include <iprt/err.h>
42	#include <iprt/stream.h>
43	#include <iprt/time.h>
44	#include <VBox/com/defs.h>
45	#include <VBox/err.h>
46	#include <VBox/version.h>
47
48	#include "HostImpl.h"
49	#include "UpdateAgentImpl.h"
50	#include "ProgressImpl.h"
51	#include "AutoCaller.h"
52	#include "LoggingNew.h"
53	#include "VirtualBoxImpl.h"
54	#include "VBoxEvents.h"
55	#include "SystemPropertiesImpl.h"
56	#include "ThreadTask.h"
57	#include "VirtualBoxImpl.h"
58	#include "VirtualBoxBase.h"
59
60
61	/*********************************************************************************************************************************
62	* Update agent task implementation *
63	*********************************************************************************************************************************/
64
65	/**
66	* Base task class for asynchronous update agent tasks.
67	*/
68	class UpdateAgentTask : public ThreadTask
69	{
70	public:
71	UpdateAgentTask(UpdateAgentBase aThat, Progress aProgress)
72	: m_pParent(aThat)
73	, m_pProgress(aProgress)
74	{
75	m_strTaskName = "UpdateAgentTask";
76	}
77	virtual ~UpdateAgentTask(void) { }
78
79	private:
80	void handler(void);
81
82	/** Weak pointer to parent (update agent). */
83	UpdateAgentBase *m_pParent;
84	/** Smart pointer to the progress object for this job. */
85	ComObjPtr<Progress> m_pProgress;
86
87	friend class UpdateAgent; // allow member functions access to private data
88	};
89
90	void UpdateAgentTask::handler(void)
91	{
92	UpdateAgentBase *pUpdateAgent = this->m_pParent;
93	AssertPtr(pUpdateAgent);
94
95	/** @todo Differentiate tasks once we have more stuff to do (downloading, installing, ++). */
96
97	HRESULT hrc = pUpdateAgent->i_checkForUpdateTask(this);
98
99	if (!m_pProgress.isNull())
100	m_pProgress->i_notifyComplete(hrc);
101
102	LogFlowFunc(("hrc=%Rhrc\n", hrc)); RT_NOREF(hrc);
103	}
104
105
106	/*********************************************************************************************************************************
107	* Update agent base class implementation *
108	*********************************************************************************************************************************/
109
110	/**
111	* Returns platform information as a string.
112	*
113	* @returns Platform information as string.
114	*/
115	/* static */
116	Utf8Str UpdateAgentBase::i_getPlatformInfo(void)
117	{
118	/* Prepare platform report: */
119	Utf8Str strPlatform;
120
121	# if defined (RT_OS_WINDOWS)
122	strPlatform = "win";
123	# elif defined (RT_OS_LINUX)
124	strPlatform = "linux";
125	# elif defined (RT_OS_DARWIN)
126	strPlatform = "macosx";
127	# elif defined (RT_OS_OS2)
128	strPlatform = "os2";
129	# elif defined (RT_OS_FREEBSD)
130	strPlatform = "freebsd";
131	# elif defined (RT_OS_SOLARIS)
132	strPlatform = "solaris";
133	# else
134	strPlatform = "unknown";
135	# endif
136
137	/* The format is <system>.<bitness>: */
138	strPlatform.appendPrintf(".%lu", ARCH_BITS);
139
140	/* Add more system information: */
141	int vrc;
142	# ifdef RT_OS_LINUX
143	// WORKAROUND:
144	// On Linux we try to generate information using script first of all..
145
146	/* Get script path: */
147	char szAppPrivPath[RTPATH_MAX];
148	vrc = RTPathAppPrivateNoArch(szAppPrivPath, sizeof(szAppPrivPath));
149	AssertRC(vrc);
150	if (RT_SUCCESS(vrc))
151	vrc = RTPathAppend(szAppPrivPath, sizeof(szAppPrivPath), "/VBoxSysInfo.sh");
152	AssertRC(vrc);
153	if (RT_SUCCESS(vrc))
154	{
155	RTPIPE hPipeR;
156	RTHANDLE hStdOutPipe;
157	hStdOutPipe.enmType = RTHANDLETYPE_PIPE;
158	vrc = RTPipeCreate(&hPipeR, &hStdOutPipe.u.hPipe, RTPIPE_C_INHERIT_WRITE);
159	AssertLogRelRC(vrc);
160
161	char const *szAppPrivArgs[2];
162	szAppPrivArgs[0] = szAppPrivPath;
163	szAppPrivArgs[1] = NULL;
164	RTPROCESS hProc = NIL_RTPROCESS;
165
166	/* Run script: */
167	vrc = RTProcCreateEx(szAppPrivPath, szAppPrivArgs, RTENV_DEFAULT, 0 /fFlags/, NULL /phStdin/, &hStdOutPipe,
168	NULL /phStderr/, NULL /pszAsUser/, NULL /pszPassword/, NULL /pvExtraData/, &hProc);
169
170	(void) RTPipeClose(hStdOutPipe.u.hPipe);
171	hStdOutPipe.u.hPipe = NIL_RTPIPE;
172
173	if (RT_SUCCESS(vrc))
174	{
175	RTPROCSTATUS ProcStatus;
176	size_t cbStdOutBuf = 0;
177	size_t offStdOutBuf = 0;
178	char *pszStdOutBuf = NULL;
179	do
180	{
181	if (hPipeR != NIL_RTPIPE)
182	{
183	char achBuf[1024];
184	size_t cbRead;
185	vrc = RTPipeReadBlocking(hPipeR, achBuf, sizeof(achBuf), &cbRead);
186	if (RT_SUCCESS(vrc))
187	{
188	/* grow the buffer? */
189	size_t cbBufReq = offStdOutBuf + cbRead + 1;
190	if ( cbBufReq > cbStdOutBuf
191	&& cbBufReq < _256K)
192	{
193	size_t cbNew = RT_ALIGN_Z(cbBufReq, 16); // 1024
194	void *pvNew = RTMemRealloc(pszStdOutBuf, cbNew);
195	if (pvNew)
196	{
197	pszStdOutBuf = (char *)pvNew;
198	cbStdOutBuf = cbNew;
199	}
200	}
201
202	/* append if we've got room. */
203	if (cbBufReq <= cbStdOutBuf)
204	{
205	(void) memcpy(&pszStdOutBuf[offStdOutBuf], achBuf, cbRead);
206	offStdOutBuf = offStdOutBuf + cbRead;
207	pszStdOutBuf[offStdOutBuf] = '\0';
208	}
209	}
210	else
211	{
212	AssertLogRelMsg(vrc == VERR_BROKEN_PIPE, ("%Rrc\n", vrc));
213	RTPipeClose(hPipeR);
214	hPipeR = NIL_RTPIPE;
215	}
216	}
217
218	/*
219	* Service the process. Block if we have no pipe.
220	*/
221	if (hProc != NIL_RTPROCESS)
222	{
223	vrc = RTProcWait(hProc,
224	hPipeR == NIL_RTPIPE ? RTPROCWAIT_FLAGS_BLOCK : RTPROCWAIT_FLAGS_NOBLOCK,
225	&ProcStatus);
226	if (RT_SUCCESS(vrc))
227	hProc = NIL_RTPROCESS;
228	else
229	AssertLogRelMsgStmt(vrc == VERR_PROCESS_RUNNING, ("%Rrc\n", vrc), hProc = NIL_RTPROCESS);
230	}
231	} while ( hPipeR != NIL_RTPIPE
232	\|\| hProc != NIL_RTPROCESS);
233
234	if ( ProcStatus.enmReason == RTPROCEXITREASON_NORMAL
235	&& ProcStatus.iStatus == 0) {
236	pszStdOutBuf[offStdOutBuf-1] = '\0'; // remove trailing newline
237	Utf8Str pszStdOutBufUTF8(pszStdOutBuf);
238	strPlatform.appendPrintf(" [%s]", pszStdOutBufUTF8.strip().c_str());
239	// For testing, here is some sample output:
240	//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]");
241	}
242	}
243	else
244	vrc = VERR_TRY_AGAIN; /* (take the fallback path) */
245	}
246
247	if (RT_FAILURE(vrc))
248	# endif /* RT_OS_LINUX */
249	{
250	/* Use RTSystemQueryOSInfo: */
251	char szTmp[256];
252
253	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
254	if ((RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0')
255	strPlatform.appendPrintf(" [Product: %s", szTmp);
256
257	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
258	if ((RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0')
259	strPlatform.appendPrintf(" %sRelease: %s", strlen(szTmp) == 0 ? "[" : "\| ", szTmp);
260
261	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
262	if ((RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0')
263	strPlatform.appendPrintf(" %sVersion: %s", strlen(szTmp) == 0 ? "[" : "\| ", szTmp);
264
265	vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
266	if ((RT_SUCCESS(vrc) \|\| vrc == VERR_BUFFER_OVERFLOW) && szTmp[0] != '\0')
267	strPlatform.appendPrintf(" %sSP: %s]", strlen(szTmp) == 0 ? "[" : "\| ", szTmp);
268
269	if (!strPlatform.endsWith("]"))
270	strPlatform.append("]");
271	}
272
273	LogRel2(("UpdateAgent: Platform is '%s'\n", strPlatform.c_str()));
274
275	return strPlatform;
276	}
277
278	/**
279	* Returns the proxy mode as a string.
280	*
281	* @returns Proxy mode as string.
282	* @param enmMode Proxy mode to return as string.
283	*/
284	/* static */
285	const char *UpdateAgentBase::i_proxyModeToStr(ProxyMode_T enmMode)
286	{
287	switch (enmMode)
288	{
289	case ProxyMode_System: return "System";
290	case ProxyMode_Manual: return "Manual";
291	case ProxyMode_NoProxy: return "None";
292	default: break;
293	}
294
295	AssertFailed();
296	return "<Invalid>";
297	}
298
299	/**
300	* Returns whether a given URL's scheme is supported or not.
301	*
302	* @returns \c true if scheme is supported, or \c false if not.
303	* @param strUrl URL to check scheme for.
304	*
305	* @note Empty URL are considered as being supported for convenience.
306	*/
307	bool UpdateAgentBase::i_urlSchemeIsSupported(const Utf8Str &strUrl) const
308	{
309	if (strUrl.isEmpty())
310	return true;
311	return strUrl.startsWith("https://", com::Utf8Str::CaseInsensitive);
312	}
313
314
315	/*********************************************************************************************************************************
316	* Update agent class implementation *
317	*********************************************************************************************************************************/
318	UpdateAgent::UpdateAgent()
319	{
320	}
321
322	UpdateAgent::~UpdateAgent()
323	{
324	}
325
326	HRESULT UpdateAgent::FinalConstruct(void)
327	{
328	return BaseFinalConstruct();
329	}
330
331	void UpdateAgent::FinalRelease(void)
332	{
333	uninit();
334
335	BaseFinalRelease();
336	}
337
338	HRESULT UpdateAgent::init(VirtualBox *aVirtualBox)
339	{
340	/* Weak reference to a VirtualBox object */
341	unconst(m_VirtualBox) = aVirtualBox;
342
343	HRESULT hrc = unconst(m_EventSource).createObject();
344	if (SUCCEEDED(hrc))
345	hrc = m_EventSource->init();
346
347	return hrc;
348	}
349
350	void UpdateAgent::uninit(void)
351	{
352	// Enclose the state transition Ready->InUninit->NotReady.
353	AutoUninitSpan autoUninitSpan(this);
354	if (autoUninitSpan.uninitDone())
355	return;
356
357	unconst(m_EventSource).setNull();
358	}
359
360	HRESULT UpdateAgent::checkFor(ComPtr<IProgress> &aProgress)
361	{
362	RT_NOREF(aProgress);
363
364	return VBOX_E_NOT_SUPPORTED;
365	}
366
367	HRESULT UpdateAgent::download(ComPtr<IProgress> &aProgress)
368	{
369	RT_NOREF(aProgress);
370
371	return VBOX_E_NOT_SUPPORTED;
372	}
373
374	HRESULT UpdateAgent::install(ComPtr<IProgress> &aProgress)
375	{
376	RT_NOREF(aProgress);
377
378	return VBOX_E_NOT_SUPPORTED;
379	}
380
381	HRESULT UpdateAgent::rollback(void)
382	{
383	return VBOX_E_NOT_SUPPORTED;
384	}
385
386	HRESULT UpdateAgent::getName(com::Utf8Str &aName)
387	{
388	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
389
390	aName = mData.m_strName;
391
392	return S_OK;
393	}
394
395	HRESULT UpdateAgent::getEventSource(ComPtr<IEventSource> &aEventSource)
396	{
397	LogFlowThisFuncEnter();
398
399	/* No need to lock - lifetime constant. */
400	m_EventSource.queryInterfaceTo(aEventSource.asOutParam());
401
402	LogFlowFuncLeaveRC(S_OK);
403	return S_OK;
404	}
405
406	HRESULT UpdateAgent::getOrder(ULONG *aOrder)
407	{
408	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
409
410	aOrder = 0; / 0 means no order / disabled. */
411
412	return S_OK;
413	}
414
415	HRESULT UpdateAgent::getDependsOn(std::vector<com::Utf8Str> &aDeps)
416	{
417	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
418
419	aDeps.resize(0); /* No dependencies by default. */
420
421	return S_OK;
422	}
423
424	HRESULT UpdateAgent::getVersion(com::Utf8Str &aVer)
425	{
426	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
427
428	aVer = mData.m_lastResult.strVer;
429
430	return S_OK;
431	}
432
433	HRESULT UpdateAgent::getDownloadUrl(com::Utf8Str &aUrl)
434	{
435	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
436
437	aUrl = mData.m_lastResult.strDownloadUrl;
438
439	return S_OK;
440	}
441
442
443	HRESULT UpdateAgent::getWebUrl(com::Utf8Str &aUrl)
444	{
445	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
446
447	aUrl = mData.m_lastResult.strWebUrl;
448
449	return S_OK;
450	}
451
452	HRESULT UpdateAgent::getReleaseNotes(com::Utf8Str &aRelNotes)
453	{
454	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
455
456	aRelNotes = mData.m_lastResult.strReleaseNotes;
457
458	return S_OK;
459	}
460
461	HRESULT UpdateAgent::getEnabled(BOOL *aEnabled)
462	{
463	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
464
465	*aEnabled = m->fEnabled;
466
467	return S_OK;
468	}
469
470	HRESULT UpdateAgent::setEnabled(const BOOL aEnabled)
471	{
472	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
473
474	m->fEnabled = aEnabled;
475
476	return i_commitSettings(alock);
477	}
478
479
480	HRESULT UpdateAgent::getHidden(BOOL *aHidden)
481	{
482	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
483
484	*aHidden = mData.m_fHidden;
485
486	return S_OK;
487	}
488
489	HRESULT UpdateAgent::getState(UpdateState_T *aState)
490	{
491	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
492
493	*aState = mData.m_enmState;
494
495	return S_OK;
496	}
497
498	HRESULT UpdateAgent::getCheckFrequency(ULONG *aFreqSeconds)
499	{
500	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
501
502	*aFreqSeconds = m->uCheckFreqSeconds;
503
504	return S_OK;
505	}
506
507	HRESULT UpdateAgent::setCheckFrequency(ULONG aFreqSeconds)
508	{
509	if (aFreqSeconds < RT_SEC_1DAY) /* Don't allow more frequent checks for now. */
510	return setError(E_INVALIDARG, tr("Frequency too small; one day is the minimum"));
511
512	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
513
514	m->uCheckFreqSeconds = aFreqSeconds;
515
516	return i_commitSettings(alock);
517	}
518
519	HRESULT UpdateAgent::getChannel(UpdateChannel_T *aChannel)
520	{
521	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
522
523	*aChannel = m->enmChannel;
524
525	return S_OK;
526	}
527
528	HRESULT UpdateAgent::setChannel(UpdateChannel_T aChannel)
529	{
530	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
531
532	m->enmChannel = aChannel;
533
534	return i_commitSettings(alock);
535	}
536
537	HRESULT UpdateAgent::getCheckCount(ULONG *aCount)
538	{
539	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
540
541	*aCount = m->uCheckCount;
542
543	return S_OK;
544	}
545
546	HRESULT UpdateAgent::getRepositoryURL(com::Utf8Str &aRepo)
547	{
548	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
549
550	aRepo = m->strRepoUrl;
551
552	return S_OK;
553	}
554
555	HRESULT UpdateAgent::setRepositoryURL(const com::Utf8Str &aRepo)
556	{
557	if (!i_urlSchemeIsSupported(aRepo))
558	return setError(E_INVALIDARG, tr("Invalid URL scheme specified!"));
559
560	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
561
562	m->strRepoUrl = aRepo;
563
564	return i_commitSettings(alock);
565	}
566
567	HRESULT UpdateAgent::getLastCheckDate(com::Utf8Str &aDate)
568	{
569	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
570
571	aDate = m->strLastCheckDate;
572
573	return S_OK;
574	}
575
576	HRESULT UpdateAgent::getIsCheckNeeded(BOOL *aCheckNeeded)
577	{
578	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
579
580	/*
581	* Is update checking enabled at all?
582	*/
583	if (!m->fEnabled)
584	{
585	*aCheckNeeded = FALSE;
586	return S_OK;
587	}
588
589	/*
590	* When was the last update?
591	*/
592	if (m->strLastCheckDate.isEmpty()) /* No prior update check performed -- do so now. */
593	{
594	*aCheckNeeded = TRUE;
595	return S_OK;
596	}
597
598	RTTIMESPEC LastCheckTime;
599	if (!RTTimeSpecFromString(&LastCheckTime, Utf8Str(m->strLastCheckDate).c_str()))
600	{
601	aCheckNeeded = TRUE; / Invalid date set or error? Perform check. */
602	return S_OK;
603	}
604
605	/*
606	* Compare last update with how often we are supposed to check for updates.
607	*/
608	if ( !m->uCheckFreqSeconds /* Paranoia */
609	\|\| m->uCheckFreqSeconds < RT_SEC_1DAY) /* This is the minimum we currently allow. */
610	{
611	/* Consider config (enable, 0 day interval) as checking once but never again.
612	We've already check since we've got a date. */
613	*aCheckNeeded = FALSE;
614	return S_OK;
615	}
616
617	uint64_t const cCheckFreqDays = m->uCheckFreqSeconds / RT_SEC_1DAY_64;
618
619	RTTIMESPEC TimeDiff;
620	RTTimeSpecSub(RTTimeNow(&TimeDiff), &LastCheckTime);
621
622	int64_t const diffLastCheckSecs = RTTimeSpecGetSeconds(&TimeDiff);
623	int64_t const diffLastCheckDays = diffLastCheckSecs / (int64_t)RT_SEC_1DAY_64;
624
625	/* Be as accurate as possible. */
626	*aCheckNeeded = diffLastCheckSecs >= (int64_t)m->uCheckFreqSeconds ? TRUE : FALSE;
627
628	LogRel2(("Update agent (%s): Last update %RI64 days (%RI64 seconds) ago, check frequency is every %RU64 days (%RU64 seconds) -> Check %s\n",
629	mData.m_strName.c_str(), diffLastCheckDays, diffLastCheckSecs, cCheckFreqDays, m->uCheckFreqSeconds,
630	*aCheckNeeded ? "needed" : "not needed"));
631
632	return S_OK;
633	}
634
635	HRESULT UpdateAgent::getSupportedChannels(std::vector<UpdateChannel_T> &aSupportedChannels)
636	{
637	/* No need to take the read lock, as m_enmChannels is const. */
638
639	aSupportedChannels = mData.m_enmChannels;
640
641	return S_OK;
642	}
643
644
645	/*********************************************************************************************************************************
646	* Internal helper methods of update agent class *
647	*********************************************************************************************************************************/
648
649	/**
650	* Loads the settings of the update agent base class.
651	*
652	* @returns HRESULT
653	* @retval E_INVALIDARG if to-load settings are invalid / not supported.
654	* @param data Where to load the settings from.
655	*/
656	HRESULT UpdateAgent::i_loadSettings(const settings::UpdateAgent &data)
657	{
658	AutoCaller autoCaller(this);
659	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
660
661	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
662
663	m->fEnabled = data.fEnabled;
664	m->enmChannel = data.enmChannel;
665	m->uCheckFreqSeconds = data.uCheckFreqSeconds;
666	if (data.strRepoUrl.isNotEmpty()) /* Prevent overwriting the agent's default URL when XML settings are empty. */
667	m->strRepoUrl = data.strRepoUrl;
668	m->strLastCheckDate = data.strLastCheckDate;
669	m->uCheckCount = data.uCheckCount;
670
671	/* Sanity checks. */
672	if (!i_urlSchemeIsSupported(data.strRepoUrl))
673	return setError(E_INVALIDARG, tr("Invalid URL scheme specified!"));
674
675	return S_OK;
676	}
677
678	/**
679	* Saves the settings of the update agent base class.
680	*
681	* @returns HRESULT
682	* @param data Where to save the settings to.
683	*/
684	HRESULT UpdateAgent::i_saveSettings(settings::UpdateAgent &data)
685	{
686	AutoCaller autoCaller(this);
687	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
688
689	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
690
691	data = *m;
692
693	return S_OK;
694	}
695
696	/**
697	* Sets the update check count.
698	*
699	* @returns HRESULT
700	* @param aCount Update check count to set.
701	*/
702	HRESULT UpdateAgent::i_setCheckCount(ULONG aCount)
703	{
704	AutoCaller autoCaller(this);
705	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
706
707	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
708
709	m->uCheckCount = aCount;
710
711	return i_commitSettings(alock);
712	}
713
714	/**
715	* Sets the last update check date.
716	*
717	* @returns HRESULT
718	* @param aDate Last update check date to set.
719	* Must be in ISO 8601 format (e.g. 2020-05-11T21:13:39.348416000Z).
720	*/
721	HRESULT UpdateAgent::i_setLastCheckDate(const com::Utf8Str &aDate)
722	{
723	AutoCaller autoCaller(this);
724	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
725
726	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
727
728	m->strLastCheckDate = aDate;
729
730	return i_commitSettings(alock);
731	}
732
733	/**
734	* Internal helper function to commit modified settings.
735	*
736	* @returns HRESULT
737	* @param aLock Write lock to release before committing settings.
738	*/
739	HRESULT UpdateAgent::i_commitSettings(AutoWriteLock &aLock)
740	{
741	aLock.release();
742
743	m_VirtualBox->i_onUpdateAgentSettingsChanged(this, "" /** @todo Include attribute hints */);
744
745	AutoWriteLock vboxLock(m_VirtualBox COMMA_LOCKVAL_SRC_POS);
746	return m_VirtualBox->i_saveSettings();
747	}
748
749	/**
750	* Returns the proxy mode to use.
751	*
752	* @returns HRESULT
753	* @param aMode Where to return the proxy mode.
754	*/
755	HRESULT UpdateAgent::i_getProxyMode(ProxyMode_T *aMode)
756	{
757	ComPtr<ISystemProperties> pSystemProperties;
758	HRESULT hrc = m_VirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
759	if (SUCCEEDED(hrc))
760	hrc = pSystemProperties->COMGETTER(ProxyMode)(aMode);
761
762	return hrc;
763	}
764
765	/**
766	* Returns the proxy URL to use.
767	*
768	* @returns HRESULT
769	* @param aUrl Where to return the proxy URL to use.
770	*/
771	HRESULT UpdateAgent::i_getProxyURL(com::Utf8Str &aUrl)
772	{
773	ComPtr<ISystemProperties> pSystemProperties;
774	HRESULT hrc = m_VirtualBox->COMGETTER(SystemProperties)(pSystemProperties.asOutParam());
775	if (SUCCEEDED(hrc))
776	{
777	com::Bstr bstrVal;
778	hrc = pSystemProperties->COMGETTER(ProxyURL)(bstrVal.asOutParam());
779	if (SUCCEEDED(hrc))
780	aUrl = bstrVal;
781	}
782
783	return hrc;
784	}
785
786	/**
787	* Configures a HTTP client's proxy.
788	*
789	* @returns HRESULT
790	* @param hHttp HTTP client to configure proxy for.
791	*/
792	HRESULT UpdateAgent::i_configureProxy(RTHTTP hHttp)
793	{
794	ProxyMode_T enmProxyMode;
795	HRESULT hrc = i_getProxyMode(&enmProxyMode);
796	ComAssertComRCRetRC(hrc);
797
798	Utf8Str strProxyUrl;
799	hrc = i_getProxyURL(strProxyUrl);
800	ComAssertComRCRetRC(hrc);
801
802	if (enmProxyMode == ProxyMode_Manual)
803	{
804	int vrc = RTHttpSetProxyByUrl(hHttp, strProxyUrl.c_str());
805	if (RT_FAILURE(vrc))
806	return i_reportError(vrc, tr("RTHttpSetProxyByUrl() failed: %Rrc"), vrc);
807	}
808	else if (enmProxyMode == ProxyMode_System)
809	{
810	int vrc = RTHttpUseSystemProxySettings(hHttp);
811	if (RT_FAILURE(vrc))
812	return i_reportError(vrc, tr("RTHttpUseSystemProxySettings() failed: %Rrc"), vrc);
813	}
814	else
815	Assert(enmProxyMode == ProxyMode_NoProxy);
816
817	LogRel2(("Update agent (%s): Using proxy mode = '%s', URL = '%s'\n",
818	mData.m_strName.c_str(), UpdateAgentBase::i_proxyModeToStr(enmProxyMode), strProxyUrl.c_str()));
819
820	return S_OK;
821	}
822
823	/**
824	* Reports an error by setting the error info and also informs subscribed listeners.
825	*
826	* @returns HRESULT
827	* @param vrc Result code (IPRT-style) to report.
828	* @param pcszMsgFmt Error message to report.
829	* @param ... Format string for \a pcszMsgFmt.
830	*/
831	HRESULT UpdateAgent::i_reportError(int vrc, const char *pcszMsgFmt, ...)
832	{
833	AssertReturn(pcszMsgFmt && *pcszMsgFmt != '\0', E_INVALIDARG);
834
835	va_list va;
836	va_start(va, pcszMsgFmt);
837
838	Utf8Str strMsg;
839	int const vrc2 = strMsg.printfVNoThrow(pcszMsgFmt, va);
840	if (RT_FAILURE(vrc2))
841	{
842	va_end(va);
843	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc2, tr("Failed to format update agent error string (%Rrc)"), vrc2);
844	}
845
846	va_end(va);
847
848	LogRel(("Update agent (%s): %s\n", mData.m_strName.c_str(), strMsg.c_str()));
849
850	m_VirtualBox->i_onUpdateAgentError(this, strMsg.c_str(), vrc);
851
852	return setErrorBoth(VBOX_E_IPRT_ERROR, vrc, strMsg.c_str());
853	}
854
855
856	/*********************************************************************************************************************************
857	* Host update implementation *
858	*********************************************************************************************************************************/
859
860	HostUpdateAgent::HostUpdateAgent(void)
861	{
862	}
863
864	HostUpdateAgent::~HostUpdateAgent(void)
865	{
866	}
867
868
869	HRESULT HostUpdateAgent::FinalConstruct(void)
870	{
871	return BaseFinalConstruct();
872	}
873
874	void HostUpdateAgent::FinalRelease(void)
875	{
876	uninit();
877
878	BaseFinalRelease();
879	}
880
881	HRESULT HostUpdateAgent::init(VirtualBox *aVirtualBox)
882	{
883	// Enclose the state transition NotReady->InInit->Ready.
884	AutoInitSpan autoInitSpan(this);
885	AssertReturn(autoInitSpan.isOk(), E_FAIL);
886
887	/* Initialize the bare minimum to get things going.
888	** @todo Add more stuff later here. */
889	mData.m_strName = "VirtualBox";
890	mData.m_fHidden = false;
891
892	const UpdateChannel_T aChannels[] =
893	{
894	UpdateChannel_Stable,
895	UpdateChannel_All,
896	UpdateChannel_WithBetas
897	/** @todo Add UpdateChannel_WithTesting once it's implemented on the backend. */
898	};
899	unconst(mData.m_enmChannels).assign(aChannels, aChannels + RT_ELEMENTS(aChannels));
900
901	/* Set default repository. */
902	m->strRepoUrl = "https://update.virtualbox.org";
903
904	HRESULT hrc = UpdateAgent::init(aVirtualBox);
905	if (SUCCEEDED(hrc))
906	autoInitSpan.setSucceeded();
907
908	return hrc;
909	}
910
911	void HostUpdateAgent::uninit(void)
912	{
913	// Enclose the state transition Ready->InUninit->NotReady.
914	AutoUninitSpan autoUninitSpan(this);
915	if (autoUninitSpan.uninitDone())
916	return;
917	}
918
919	HRESULT HostUpdateAgent::checkFor(ComPtr<IProgress> &aProgress)
920	{
921	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
922
923	ComObjPtr<Progress> pProgress;
924	HRESULT hrc = pProgress.createObject();
925	if (FAILED(hrc))
926	return hrc;
927
928	hrc = pProgress->init(m_VirtualBox,
929	static_cast<IUpdateAgent*>(this),
930	tr("Checking for update for %s ...", this->mData.m_strName.c_str()),
931	TRUE /* aCancelable */);
932	if (FAILED(hrc))
933	return hrc;
934
935	/* initialize the worker task */
936	UpdateAgentTask *pTask = new UpdateAgentTask(this, pProgress);
937	hrc = pTask->createThread();
938	pTask = NULL;
939	if (FAILED(hrc))
940	return hrc;
941
942	return pProgress.queryInterfaceTo(aProgress.asOutParam());
943	}
944
945
946	/*********************************************************************************************************************************
947	* Host update internal functions *
948	*********************************************************************************************************************************/
949
950	/**
951	* Task callback to perform an update check for the VirtualBox host (core).
952	*
953	* @returns HRESULT
954	* @param pTask Associated update agent task to use.
955	*/
956	DECLCALLBACK(HRESULT) HostUpdateAgent::i_checkForUpdateTask(UpdateAgentTask *pTask)
957	{
958	RT_NOREF(pTask);
959
960	AssertReturn(m->strRepoUrl.isNotEmpty(), E_INVALIDARG);
961
962	// Following the sequence of steps in UIUpdateStepVirtualBox::sltStartStep()
963	// Build up our query URL starting with the configured repository.
964	Utf8Str strUrl;
965	strUrl.appendPrintf("%s/query.php/?", m->strRepoUrl.c_str());
966
967	// Add platform ID.
968	Bstr platform;
969	HRESULT hrc = m_VirtualBox->COMGETTER(PackageType)(platform.asOutParam());
970	AssertComRCReturn(hrc, hrc);
971	strUrl.appendPrintf("platform=%ls", platform.raw()); // e.g. SOLARIS_64BITS_GENERIC
972
973	// Get the complete current version string for the query URL
974	Bstr versionNormalized;
975	hrc = m_VirtualBox->COMGETTER(VersionNormalized)(versionNormalized.asOutParam());
976	AssertComRCReturn(hrc, hrc);
977	strUrl.appendPrintf("&version=%ls", versionNormalized.raw()); // e.g. 6.1.1
978	#ifdef DEBUG // Comment out previous line and uncomment this one for testing.
979	// strUrl.appendPrintf("&version=6.0.12");
980	#endif
981
982	ULONG revision = 0;
983	hrc = m_VirtualBox->COMGETTER(Revision)(&revision);
984	AssertComRCReturn(hrc, hrc);
985	strUrl.appendPrintf("_%u", revision); // e.g. 135618
986
987	// Update the last update check timestamp.
988	RTTIME Time;
989	RTTIMESPEC TimeNow;
990	char szTimeStr[RTTIME_STR_LEN];
991	RTTimeToString(RTTimeExplode(&Time, RTTimeNow(&TimeNow)), szTimeStr, sizeof(szTimeStr));
992	LogRel2(("Update agent (%s): Setting last update check timestamp to '%s'\n", mData.m_strName.c_str(), szTimeStr));
993
994	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
995
996	m->strLastCheckDate = szTimeStr;
997	m->uCheckCount++;
998
999	hrc = i_commitSettings(alock);
1000	AssertComRCReturn(hrc, hrc);
1001
1002	strUrl.appendPrintf("&count=%RU32", m->uCheckCount);
1003
1004	// Update the query URL (if necessary) with the 'channel' information.
1005	switch (m->enmChannel)
1006	{
1007	case UpdateChannel_All:
1008	strUrl.appendPrintf("&branch=allrelease"); // query.php expects 'allrelease' and not 'allreleases'
1009	break;
1010	case UpdateChannel_WithBetas:
1011	strUrl.appendPrintf("&branch=withbetas");
1012	break;
1013	/** @todo Handle UpdateChannel_WithTesting once implemented on the backend. */
1014	case UpdateChannel_Stable:
1015	RT_FALL_THROUGH();
1016	default:
1017	strUrl.appendPrintf("&branch=stable");
1018	break;
1019	}
1020
1021	LogRel2(("Update agent (%s): Using URL '%s'\n", mData.m_strName.c_str(), strUrl.c_str()));
1022
1023	/*
1024	* Compose the User-Agent header for the GET request.
1025	*/
1026	Bstr version;
1027	hrc = m_VirtualBox->COMGETTER(Version)(version.asOutParam()); // e.g. 6.1.0_RC1
1028	AssertComRCReturn(hrc, hrc);
1029
1030	Utf8StrFmt const strUserAgent("VirtualBox %ls <%s>", version.raw(), UpdateAgent::i_getPlatformInfo().c_str());
1031	LogRel2(("Update agent (%s): Using user agent '%s'\n", mData.m_strName.c_str(), strUserAgent.c_str()));
1032
1033	/*
1034	* Create the HTTP client instance and pass it to a inner worker method to
1035	* ensure proper cleanup.
1036	*/
1037	RTHTTP hHttp = NIL_RTHTTP;
1038	int vrc = RTHttpCreate(&hHttp);
1039	if (RT_SUCCESS(vrc))
1040	{
1041	try
1042	{
1043	hrc = i_checkForUpdateInner(hHttp, strUrl, strUserAgent);
1044	}
1045	catch (...)
1046	{
1047	AssertFailed();
1048	hrc = E_UNEXPECTED;
1049	}
1050	RTHttpDestroy(hHttp);
1051	}
1052	else
1053	hrc = i_reportError(vrc, tr("RTHttpCreate() failed: %Rrc"), vrc);
1054
1055	return hrc;
1056	}
1057
1058	/**
1059	* Inner function of the actual update checking mechanism.
1060	*
1061	* @returns HRESULT
1062	* @param hHttp HTTP client instance to use for checking.
1063	* @param strUrl URL of repository to check.
1064	* @param strUserAgent HTTP user agent to use for checking.
1065	*/
1066	HRESULT HostUpdateAgent::i_checkForUpdateInner(RTHTTP hHttp, Utf8Str const &strUrl, Utf8Str const &strUserAgent)
1067	{
1068	/*
1069	* Configure the proxy (if any).
1070	*/
1071	HRESULT hrc = i_configureProxy(hHttp);
1072	if (FAILED(hrc))
1073	return hrc;
1074
1075	/** @todo Are there any other headers needed to be added first via RTHttpSetHeaders()? */
1076	int vrc = RTHttpAddHeader(hHttp, "User-Agent", strUserAgent.c_str(), strUserAgent.length(), RTHTTPADDHDR_F_BACK);
1077	if (RT_FAILURE(vrc))
1078	return i_reportError(vrc, tr("RTHttpAddHeader() failed: %Rrc (user agent)"), vrc);
1079
1080	/*
1081	* Perform the GET request, returning raw binary stuff.
1082	*/
1083	void *pvResponse = NULL;
1084	size_t cbResponse = 0;
1085	vrc = RTHttpGetBinary(hHttp, strUrl.c_str(), &pvResponse, &cbResponse);
1086	if (RT_FAILURE(vrc))
1087	return i_reportError(vrc, tr("RTHttpGetBinary() failed: %Rrc"), vrc);
1088
1089	/* Note! We can do nothing that might throw exceptions till we call RTHttpFreeResponse! */
1090
1091	/*
1092	* If url is platform=DARWIN_64BITS_GENERIC&version=6.0.12&branch=stable for example, the reply is:
1093	* 6.0.14<SPACE>https://download.virtualbox.org/virtualbox/6.0.14/VirtualBox-6.0.14-133895-OSX.dmg
1094	* If no update required, 'UPTODATE' is returned.
1095	*/
1096	/* Parse out the two first words of the response, ignoring whatever follows: */
1097	const char pchResponse = (const char )pvResponse;
1098	while (cbResponse > 0 && *pchResponse == ' ')
1099	cbResponse--, pchResponse++;
1100
1101	char ch;
1102	const char *pchWord0 = pchResponse;
1103	while (cbResponse > 0 && (ch = *pchResponse) != ' ' && ch != '\0')
1104	cbResponse--, pchResponse++;
1105	size_t const cchWord0 = (size_t)(pchResponse - pchWord0);
1106
1107	while (cbResponse > 0 && *pchResponse == ' ')
1108	cbResponse--, pchResponse++;
1109	const char *pchWord1 = pchResponse;
1110	while (cbResponse > 0 && (ch = *pchResponse) != ' ' && ch != '\0')
1111	cbResponse--, pchResponse++;
1112	size_t const cchWord1 = (size_t)(pchResponse - pchWord1);
1113
1114	/* Decode the two word: */
1115	static char const s_szUpToDate[] = "UPTODATE";
1116	if ( cchWord0 == sizeof(s_szUpToDate) - 1
1117	&& memcmp(pchWord0, s_szUpToDate, sizeof(s_szUpToDate) - 1) == 0)
1118	{
1119	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1120
1121	mData.m_enmState = UpdateState_NotAvailable;
1122	hrc = S_OK;
1123
1124	alock.release(); /* Release lock before firing off event. */
1125
1126	m_VirtualBox->i_onUpdateAgentStateChanged(this, UpdateState_NotAvailable);
1127	}
1128	else
1129	{
1130	mData.m_enmState = UpdateState_Error; /* Play safe by default. */
1131
1132	vrc = RTStrValidateEncodingEx(pchWord0, cchWord0, 0 /fFlags/);
1133	if (RT_SUCCESS(vrc))
1134	vrc = RTStrValidateEncodingEx(pchWord1, cchWord1, 0 /fFlags/);
1135	if (RT_SUCCESS(vrc))
1136	{
1137	/** @todo Any additional sanity checks we could perform here? */
1138	hrc = mData.m_lastResult.strVer.assignEx(pchWord0, cchWord0);
1139	if (SUCCEEDED(hrc))
1140	hrc = mData.m_lastResult.strDownloadUrl.assignEx(pchWord1, cchWord1);
1141
1142	if (SUCCEEDED(hrc))
1143	{
1144	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
1145
1146	/** @todo Implement this on the backend first.
1147	* We also could do some guessing based on the installed version vs. reported update version? */
1148	mData.m_lastResult.enmSeverity = UpdateSeverity_Invalid;
1149	mData.m_enmState = UpdateState_Available;
1150
1151	alock.release(); /* Release lock before firing off events. */
1152
1153	m_VirtualBox->i_onUpdateAgentStateChanged(this, UpdateState_Available);
1154	m_VirtualBox->i_onUpdateAgentAvailable(this, mData.m_lastResult.strVer, m->enmChannel,
1155	mData.m_lastResult.enmSeverity, mData.m_lastResult.strDownloadUrl,
1156	mData.m_lastResult.strWebUrl, mData.m_lastResult.strReleaseNotes);
1157	}
1158	else
1159	hrc = i_reportError(VERR_GENERAL_FAILURE /** @todo Use a better hrc */,
1160	tr("Invalid server response [1]: %Rhrc (%.Rhxs -- %.Rhxs)"),
1161	hrc, cchWord0, pchWord0, cchWord1, pchWord1);
1162
1163	LogRel2(("Update agent (%s): HTTP server replied: %.s %.s\n",
1164	mData.m_strName.c_str(), cchWord0, pchWord0, cchWord1, pchWord1));
1165	}
1166	else
1167	hrc = i_reportError(vrc, tr("Invalid server response [2]: %Rrc (%.Rhxs -- %.Rhxs)"),
1168	vrc, cchWord0, pchWord0, cchWord1, pchWord1);
1169	}
1170
1171	RTHttpFreeResponse(pvResponse);
1172
1173	return hrc;
1174	}
1175

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-server/UpdateAgentImpl.cpp@ 98651

Download in other formats: